diff --git a/.gitignore b/.gitignore
index 609b66b..72f03fd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -44,6 +44,7 @@ pip-delete-this-directory.txt
 # Runtime data and logs
 runtime/
 backend/runtime/
+backend/storage/
 logs/
 backend/logs/
 *.db
diff --git a/backend/app/api/v1/endpoints/data_process.py b/backend/app/api/v1/endpoints/data_process.py
index b024ff6..96cd93f 100644
--- a/backend/app/api/v1/endpoints/data_process.py
+++ b/backend/app/api/v1/endpoints/data_process.py
@@ -3,13 +3,15 @@ from __future__ import annotations
 import hashlib
 import ipaddress
 import json
+import logging
 import os
+import re
 import socket
 from contextlib import contextmanager
 from dataclasses import asdict
 from pathlib import Path
 from typing import Any, Iterator, Literal
-from urllib.parse import urlsplit
+from urllib.parse import quote, urlsplit
 
 import psycopg
 from fastapi import (
@@ -18,22 +20,38 @@ from fastapi import (
     Body,
     Depends,
     File,
+    Header,
     HTTPException,
     Query,
     UploadFile,
 )
+from fastapi.responses import StreamingResponse
 from psycopg.rows import dict_row
 
 from app.modules.data_process.algorithms import (
+    ParsedText,
+    TextChunk,
+    canonical_record_json,
     chunk_unstructured,
-    decode_utf8,
+    content_quality_flags,
     desensitize_pii,
+    desensitize_structured_record,
+    detect_document_structure,
     estimate_token_count,
+    extract_pdf_page_texts,
     generate_standard_records,
+    is_near_duplicate,
+    near_duplicate_fingerprint,
     parse_text_content,
+    preprocess_structured_records,
     score_quality,
 )
 from app.modules.data_process.generation import generate_model_records
+from app.modules.data_process.storage import (
+    LocalDataProcessStorage,
+    StagedSourceObject,
+    get_data_process_storage,
+)
 from app.modules.data_process.store import (
     ConflictError,
     DataProcessStore,
@@ -41,11 +59,12 @@ from app.modules.data_process.store import (
     InvalidStateError,
     NotFoundError,
     get_data_process_store,
+    new_id,
 )
 from app.schemas.data_process import (
+    DataProcessStatus,
     DataProcessTaskCreate,
     DataProcessTaskUpdate,
-    DataProcessStatus,
     ExternalPullRequest,
     ExternalSourceRequest,
     GenerateRequest,
@@ -57,12 +76,34 @@ from app.schemas.data_process import (
     ResultUpdate,
 )
 
-
 router = APIRouter(prefix="/data-process")
+logger = logging.getLogger(__name__)
 MAX_SOURCE_FILE_BYTES = 200 * 1024 * 1024
 MAX_SOURCE_FILE_COUNT = 20
 MAX_SOURCE_BATCH_BYTES = 500 * 1024 * 1024
 MAX_EXTERNAL_PULL_BYTES = 50 * 1024 * 1024
+STRUCTURED_SOURCE_SUFFIXES = frozenset(
+    {".json", ".jsonl", ".ndjson", ".csv", ".tsv", ".xlsx"}
+)
+UNSTRUCTURED_SOURCE_SUFFIXES = frozenset(
+    {
+        ".txt",
+        ".md",
+        ".markdown",
+        ".pdf",
+        ".docx",
+        ".pptx",
+        ".json",
+        ".jsonl",
+        ".ndjson",
+    }
+)
+SUPPORTED_SOURCE_SUFFIXES = STRUCTURED_SOURCE_SUFFIXES | UNSTRUCTURED_SOURCE_SUFFIXES
+LEGACY_OFFICE_CONVERSIONS = {
+    ".doc": ".docx",
+    ".xls": ".xlsx",
+    ".ppt": ".pptx",
+}
 
 
 def ok(data: Any = None, message: str = "ok") -> dict[str, Any]:
@@ -99,6 +140,57 @@ def _safe_file_name(value: str | None, fallback: str) -> str:
     return name if name not in {"", ".", ".."} else fallback
 
 
+def _range_not_satisfiable(size: int) -> HTTPException:
+    return HTTPException(
+        status_code=416,
+        detail={"code": 416, "message": "invalid source byte range", "data": None},
+        headers={"Content-Range": f"bytes */{size}"},
+    )
+
+
+def _source_byte_range(value: str | None, size: int) -> tuple[int, int] | None:
+    if value is None:
+        return None
+    match = re.fullmatch(r"bytes=(\d*)-(\d*)", value.strip())
+    if match is None or size <= 0:
+        raise _range_not_satisfiable(size)
+    start_text, end_text = match.groups()
+    if not start_text and not end_text:
+        raise _range_not_satisfiable(size)
+    if start_text:
+        start = int(start_text)
+        end = int(end_text) if end_text else size - 1
+        if start >= size or end < start:
+            raise _range_not_satisfiable(size)
+    else:
+        suffix_length = int(end_text)
+        if suffix_length <= 0:
+            raise _range_not_satisfiable(size)
+        start = max(0, size - suffix_length)
+        end = size - 1
+    return start, min(end, size - 1)
+
+
+def _commit_source_batch(
+    store: DataProcessStore,
+    storage: LocalDataProcessStorage,
+    task_id: str,
+    prepared: list[dict[str, Any]],
+    staged: list[StagedSourceObject],
+) -> list[dict[str, Any]]:
+    storage.publish(staged)
+    try:
+        return store.add_source_files(task_id, prepared)
+    except Exception:
+        for item in staged:
+            try:
+                storage.delete(item.reference)
+            except Exception:
+                # 文件系统回滚失败不能覆盖数据库抛出的根因，并继续清理其余对象。
+                pass
+        raise
+
+
 def _value(config: dict[str, Any], snake_name: str, camel_name: str, default: Any) -> Any:
     if snake_name in config:
         return config[snake_name]
@@ -126,6 +218,204 @@ def _preview_quality(content: str, config: dict[str, Any]) -> dict[str, Any]:
     )
 
 
+def _parse_stored_source(source: dict[str, Any]) -> ParsedText:
+    """重新读取已入库的规范化正文，避免把二进制格式当二进制重复解析。"""
+
+    content = str(source.get("content") or "")
+    file_format = str(source.get("file_format") or "").lower()
+    if file_format == "xlsx":
+        # XLSX 上传阶段已安全解析为 JSONL 后入库。
+        return parse_text_content(content, file_format="jsonl")
+    if file_format in {"pdf", "docx", "pptx"}:
+        # 文档上传阶段已抽取文本，预览阶段只需要对正文切片。
+        return ParsedText(format=file_format, text=content, records=())
+    return parse_text_content(
+        content,
+        filename=source.get("name"),
+        file_format=file_format or None,
+    )
+
+
+def _shift_chunk(chunk: TextChunk, offset: int, source_text: str) -> TextChunk:
+    start = offset + chunk.start
+    end = offset + chunk.end
+    return TextChunk(
+        content=chunk.content,
+        start=start,
+        end=end,
+        start_line=source_text.count("\n", 0, start) + 1,
+        end_line=source_text.count("\n", 0, max(start, end - 1)) + 1,
+        token_count=chunk.token_count,
+    )
+
+
+def _merge_short_chunks(
+    chunks: list[TextChunk],
+    source_text: str,
+    *,
+    min_token_count: int,
+    chunk_size: int,
+) -> list[TextChunk]:
+    """在同一章节内合并短块，同时严格遵守切片大小上限。"""
+
+    merged: list[TextChunk] = []
+    index = 0
+    while index < len(chunks):
+        current = chunks[index]
+        if current.token_count >= min_token_count:
+            merged.append(current)
+            index += 1
+            continue
+
+        candidates: list[tuple[int, int, int]] = []
+        if merged:
+            candidates.append((merged[-1].start, current.end, -1))
+        if index + 1 < len(chunks):
+            candidates.append((current.start, chunks[index + 1].end, 1))
+        selected = next(
+            (
+                (start, end, direction)
+                for start, end, direction in candidates
+                if estimate_token_count(source_text[start:end]) <= chunk_size
+            ),
+            None,
+        )
+        if selected is None:
+            merged.append(current)
+            index += 1
+            continue
+
+        start, end, direction = selected
+        combined = TextChunk(
+            content=source_text[start:end],
+            start=start,
+            end=end,
+            start_line=source_text.count("\n", 0, start) + 1,
+            end_line=source_text.count("\n", 0, max(start, end - 1)) + 1,
+            token_count=estimate_token_count(source_text[start:end]),
+        )
+        if direction < 0:
+            merged[-1] = combined
+            index += 1
+        else:
+            merged.append(combined)
+            index += 2
+    return merged
+
+
+def _chunk_source_text(
+    text: str,
+    config: dict[str, Any],
+    preprocess_options: set[str],
+) -> list[tuple[TextChunk, tuple[str, ...]]]:
+    """按可选文档结构分段后切片，章节之间绝不共享 overlap。"""
+
+    method = str(_value(config, "chunk_method", "chunkMethod", "structure"))
+    detect_structure = (
+        method == "structure" or "detect_document_structure" in preprocess_options
+    )
+    preserve_context = "preserve_context" in preprocess_options
+    merge_short = "merge_short_content" in preprocess_options
+    chunk_size = int(_value(config, "chunk_size", "chunkSize", 800))
+    configured_minimum = int(_value(config, "min_chunk_size", "minChunkSize", 100))
+    minimum = configured_minimum if merge_short else 1
+    overlap = (
+        int(_value(config, "chunk_overlap", "chunkOverlap", 100))
+        if preserve_context
+        else 0
+    )
+    common = {
+        "method": method,
+        "chunk_size": chunk_size,
+        "chunk_overlap": overlap,
+        "min_chunk_size": minimum,
+        "custom_delimiter": str(
+            _value(config, "custom_delimiter", "customDelimiter", "") or ""
+        ),
+        "preserve_code_blocks": bool(
+            _value(config, "preserve_code_blocks", "preserveCodeBlocks", False)
+        ),
+        "preserve_tables": bool(
+            _value(config, "preserve_tables", "preserveTables", False)
+        ),
+        "preserve_lists": bool(
+            _value(config, "preserve_lists", "preserveLists", False)
+        ),
+    }
+
+    sections: list[tuple[int, int, tuple[str, ...]]] = [(0, len(text), ())]
+    if detect_structure:
+        structure = detect_document_structure(text)
+        if structure.headings:
+            sections = []
+            first_start = structure.headings[0].start
+            if first_start > 0 and text[:first_start].strip():
+                sections.append((0, first_start, ()))
+            stack: list[tuple[int, str]] = []
+            for index, heading in enumerate(structure.headings):
+                while stack and stack[-1][0] >= heading.level:
+                    stack.pop()
+                stack.append((heading.level, heading.title))
+                end = (
+                    structure.headings[index + 1].start
+                    if index + 1 < len(structure.headings)
+                    else len(text)
+                )
+                sections.append((heading.start, end, tuple(title for _, title in stack)))
+
+    result: list[tuple[TextChunk, tuple[str, ...]]] = []
+    for start, end, heading_path in sections:
+        section_text = text[start:end]
+        local_chunks = chunk_unstructured(section_text, **common)
+        shifted = [_shift_chunk(chunk, start, text) for chunk in local_chunks]
+        if merge_short:
+            shifted = _merge_short_chunks(
+                shifted,
+                text,
+                min_token_count=configured_minimum,
+                chunk_size=chunk_size,
+            )
+        result.extend((chunk, heading_path) for chunk in shifted)
+    return result
+
+
+_NEGATION_MARKERS = frozenset({"不", "无", "未", "否", "没有", "并非", "not", "no", "never"})
+
+
+def _safe_near_duplicate(left: str, right: str) -> bool:
+    """保守判断近重复，数字或否定含义变化时始终保留。"""
+
+    if min(estimate_token_count(left), estimate_token_count(right)) < 20:
+        return False
+    if re.findall(r"\d+(?:\.\d+)?", left) != re.findall(r"\d+(?:\.\d+)?", right):
+        return False
+    left_lower = left.casefold()
+    right_lower = right.casefold()
+    left_negations = {marker for marker in _NEGATION_MARKERS if marker in left_lower}
+    right_negations = {marker for marker in _NEGATION_MARKERS if marker in right_lower}
+    if left_negations != right_negations:
+        return False
+    return is_near_duplicate(
+        left,
+        right,
+        similarity_threshold=0.92,
+        max_hamming_distance=2,
+    )
+
+
+def _near_duplicate_band_keys(content: str) -> tuple[tuple[int, int], ...]:
+    """将 64 位 SimHash 分为三段，汉明距离不超过 2 时至少命中一段。"""
+
+    fingerprint = int(near_duplicate_fingerprint(content), 16)
+    widths = (22, 21, 21)
+    shift = 0
+    keys: list[tuple[int, int]] = []
+    for index, width in enumerate(widths):
+        keys.append((index, (fingerprint >> shift) & ((1 << width) - 1)))
+        shift += width
+    return tuple(keys)
+
+
 def _build_preview_items(
     task: dict[str, Any], source_files: list[dict[str, Any]]
 ) -> list[dict[str, Any]]:
@@ -140,6 +430,7 @@ def _build_preview_items(
         preprocess_options & {"deduplicate", "deduplicate_content"}
     )
     seen_content_hashes: set[str] = set()
+    seen_near_duplicate_bands: dict[tuple[int, int], list[str]] = {}
     items: list[dict[str, Any]] = []
 
     def append_item(item: dict[str, Any]) -> None:
@@ -155,38 +446,58 @@ def _build_preview_items(
         items.append(item)
 
     for source in source_files:
-        parsed = parse_text_content(
-            source.get("content") or "",
-            filename=source.get("name"),
-            file_format=source.get("file_format"),
-        )
+        parsed = _parse_stored_source(source)
         if process_type == "unstructured":
-            chunks = chunk_unstructured(
-                parsed.text,
-                method=_value(config, "chunk_method", "chunkMethod", "semantic"),
-                chunk_size=int(_value(config, "chunk_size", "chunkSize", 800)),
-                chunk_overlap=int(_value(config, "chunk_overlap", "chunkOverlap", 100)),
-                min_chunk_size=int(_value(config, "min_chunk_size", "minChunkSize", 100)),
-                custom_delimiter=str(
-                    _value(config, "custom_delimiter", "customDelimiter", "") or ""
-                ),
-                preserve_code_blocks=bool(
-                    _value(config, "preserve_code_blocks", "preserveCodeBlocks", False)
-                ),
-                preserve_tables=bool(
-                    _value(config, "preserve_tables", "preserveTables", False)
-                ),
-                preserve_lists=bool(
-                    _value(config, "preserve_lists", "preserveLists", False)
-                ),
-            )
-            for chunk in chunks:
+            chunks = _chunk_source_text(parsed.text, config, preprocess_options)
+            for chunk, heading_path in chunks:
+                preprocess_flags = content_quality_flags(
+                    chunk.content,
+                    min_chars=0,
+                    min_tokens=0,
+                )
+                flag_set = set(preprocess_flags)
+                if "clean_invalid_content" in preprocess_options and flag_set & {
+                    "empty_content",
+                    "low_printable_ratio",
+                    "repetitive_content",
+                }:
+                    continue
+                if "filter_low_quality" in preprocess_options and flag_set & {
+                    "content_too_long",
+                    "mojibake",
+                    "low_printable_ratio",
+                    "repetitive_content",
+                }:
+                    continue
+                if "deduplicate_content" in preprocess_options:
+                    band_keys = _near_duplicate_band_keys(chunk.content)
+                    candidates = {
+                        previous
+                        for key in band_keys
+                        for previous in seen_near_duplicate_bands.get(key, ())
+                    }
+                    if any(
+                        _safe_near_duplicate(chunk.content, previous)
+                        for previous in candidates
+                    ):
+                        continue
+                    for key in band_keys:
+                        seen_near_duplicate_bands.setdefault(key, []).append(chunk.content)
                 content = chunk.content
                 pii_counts: dict[str, int] = {}
                 if should_desensitize:
                     content, pii_counts = desensitize_pii(content)
                 quality = _preview_quality(content, config)
                 quality["pii_replacements"] = pii_counts
+                quality["preprocess_flags"] = list(preprocess_flags)
+                chunk_method = str(
+                    _value(config, "chunk_method", "chunkMethod", "structure")
+                )
+                if (
+                    chunk_method == "structure"
+                    or "detect_document_structure" in preprocess_options
+                ):
+                    quality["heading_path"] = list(heading_path)
                 append_item(
                     {
                         "source_file_id": source["id"],
@@ -203,19 +514,41 @@ def _build_preview_items(
                 )
             continue
 
-        record_contents = [
-            json.dumps(record, ensure_ascii=False, separators=(",", ":"))
-            for record in parsed.records
-            if not should_clean_invalid
-            or any(value not in (None, "", [], {}) for value in record.values())
-        ]
-        if not record_contents and parsed.text:
-            record_contents = [parsed.text]
-        for content in record_contents:
-            original_content = content
-            pii_counts = {}
+        structured_options = preprocess_options & {
+            "clean_invalid",
+            "detect_structure",
+            "deduplicate",
+            "normalize_format",
+            "filter_anomaly",
+        }
+        source_records = list(parsed.records)
+        processed_records = preprocess_structured_records(
+            source_records,
+            structured_options,
+        )
+        if not processed_records and parsed.text and not source_records:
+            processed_records = [{"value": parsed.text}]
+        same_cardinality = len(processed_records) == len(source_records)
+        for index, record in enumerate(processed_records):
+            original_record = source_records[index] if same_cardinality else record
+            original_content = json.dumps(
+                original_record,
+                ensure_ascii=False,
+                separators=(",", ":"),
+            )
+            pii_counts: dict[str, int] = {}
+            edited_record = record
             if should_desensitize:
-                content, pii_counts = desensitize_pii(content)
+                edited_record, pii_counts = desensitize_structured_record(record)
+            content = (
+                canonical_record_json(edited_record)
+                if "normalize_format" in preprocess_options
+                else json.dumps(
+                    edited_record,
+                    ensure_ascii=False,
+                    separators=(",", ":"),
+                )
+            )
             quality = _preview_quality(content, config)
             quality["pii_replacements"] = pii_counts
             append_item(
@@ -488,58 +821,91 @@ async def upload_source_files(
     task_id: str,
     files: list[UploadFile] = File(...),
     store: DataProcessStore = Depends(get_data_process_store),
+    storage: LocalDataProcessStorage = Depends(get_data_process_storage),
 ) -> dict[str, Any]:
     if not files:
         raise fail(400, "at least one source file is required")
     if len(files) > MAX_SOURCE_FILE_COUNT:
         raise fail(413, f"a source batch may contain at most {MAX_SOURCE_FILE_COUNT} files")
     prepared: list[dict[str, Any]] = []
+    staged: list[StagedSourceObject] = []
+    batch_id = storage.new_batch_id()
     batch_size = 0
-    with api_errors():
-        store.get_task(task_id)
-        for upload in files:
-            raw = await upload.read(MAX_SOURCE_FILE_BYTES + 1)
-            if len(raw) > MAX_SOURCE_FILE_BYTES:
-                raise fail(413, f"source file exceeds {MAX_SOURCE_FILE_BYTES} bytes")
-            content = decode_utf8(raw)
-            name = _safe_file_name(upload.filename, "source.txt")
-            suffix = Path(name).suffix.lower()
-            if suffix not in {
-                ".txt",
-                ".md",
-                ".markdown",
-                ".csv",
-                ".tsv",
-                ".json",
-                ".jsonl",
-                ".ndjson",
-            }:
-                raise fail(415, f"unsupported source file format: {suffix or 'none'}")
-            parsed = parse_text_content(content, filename=name)
-            if not parsed.text:
-                raise fail(400, f"source file is empty: {name}")
-            normalized_raw = parsed.text.encode("utf-8")
-            batch_size += len(normalized_raw)
-            if batch_size > MAX_SOURCE_BATCH_BYTES:
-                raise fail(413, f"source batch exceeds {MAX_SOURCE_BATCH_BYTES} bytes")
-            record_count = len(parsed.records) or (1 if parsed.text else 0)
-            prepared.append(
-                {
-                    "name": name,
-                    "content": parsed.text,
-                    "raw_size": len(normalized_raw),
-                    "checksum_sha256": hashlib.sha256(normalized_raw).hexdigest(),
-                    "file_format": parsed.format,
-                    "record_count": record_count,
-                    "metadata": {
-                        "content_type": upload.content_type or "text/plain",
-                        "original_size_bytes": len(raw),
-                        "original_checksum_sha256": hashlib.sha256(raw).hexdigest(),
-                    },
-                    "created_by": None,
-                }
+    commit_attempted = False
+    try:
+        with api_errors():
+            task = store.get_task(task_id)
+            process_type = str(task["process_type"])
+            if process_type == "external":
+                raise InvalidStateError(
+                    "external tasks must import data through the external source endpoint"
+                )
+            allowed_suffixes = (
+                UNSTRUCTURED_SOURCE_SUFFIXES
+                if process_type == "unstructured"
+                else STRUCTURED_SOURCE_SUFFIXES
             )
-        created = store.add_source_files(task_id, prepared)
+            for upload in files:
+                raw = await upload.read(MAX_SOURCE_FILE_BYTES + 1)
+                if len(raw) > MAX_SOURCE_FILE_BYTES:
+                    raise fail(413, f"source file exceeds {MAX_SOURCE_FILE_BYTES} bytes")
+                name = _safe_file_name(upload.filename, "source.txt")
+                suffix = Path(name).suffix.lower()
+                if suffix in LEGACY_OFFICE_CONVERSIONS:
+                    replacement = LEGACY_OFFICE_CONVERSIONS[suffix]
+                    raise fail(
+                        415,
+                        f"legacy {suffix} format is not supported; "
+                        f"convert the file to {replacement} and upload again",
+                    )
+                if suffix not in SUPPORTED_SOURCE_SUFFIXES:
+                    raise fail(415, f"unsupported source file format: {suffix or 'none'}")
+                if suffix not in allowed_suffixes:
+                    raise fail(
+                        415,
+                        f"{suffix} is not supported for {process_type} data processing",
+                    )
+                parsed = parse_text_content(raw, filename=name)
+                if not parsed.text:
+                    raise fail(400, f"source file is empty: {name}")
+                batch_size += len(raw)
+                if batch_size > MAX_SOURCE_BATCH_BYTES:
+                    raise fail(413, f"source batch exceeds {MAX_SOURCE_BATCH_BYTES} bytes")
+                source_file_id = new_id("dpsf")
+                staged_object = storage.stage_bytes(
+                    batch_id=batch_id,
+                    task_id=task_id,
+                    source_file_id=source_file_id,
+                    version=1,
+                    name=name,
+                    content=raw,
+                )
+                staged.append(staged_object)
+                record_count = len(parsed.records) or (1 if parsed.text else 0)
+                prepared.append(
+                    {
+                        "id": source_file_id,
+                        "storage_object_id": staged_object.reference,
+                        "name": name,
+                        "content": parsed.text,
+                        "raw_size": len(raw),
+                        "checksum_sha256": hashlib.sha256(raw).hexdigest(),
+                        "file_format": parsed.format,
+                        "record_count": record_count,
+                        "metadata": {
+                            "content_type": upload.content_type or "text/plain",
+                            "original_size_bytes": len(raw),
+                            "original_checksum_sha256": hashlib.sha256(raw).hexdigest(),
+                        },
+                        "created_by": None,
+                    }
+                )
+            # publish 无论成功或失败都会消费并清理暂存对象，外层不能再次 discard。
+            commit_attempted = True
+            created = _commit_source_batch(store, storage, task_id, prepared, staged)
+    finally:
+        if not commit_attempted:
+            storage.discard(staged)
     return ok({"files": created}, "source files uploaded")
 
 
@@ -559,15 +925,145 @@ def source_file_content(
         return ok(store.source_content_window(task_id, file_id, offset, limit))
 
 
+@router.get("/{task_id}/source-files/{file_id}/raw")
+def source_file_raw(
+    task_id: str,
+    file_id: str,
+    range_header: str | None = Header(default=None, alias="Range"),
+    store: DataProcessStore = Depends(get_data_process_store),
+    storage: LocalDataProcessStorage = Depends(get_data_process_storage),
+) -> StreamingResponse:
+    with api_errors():
+        source = store.get_source_file(task_id, file_id, include_content=False)
+        if str(source.get("file_format") or "").lower() != "pdf":
+            raise fail(415, "raw inline preview is only available for PDF source files")
+        storage_object_id = str(source.get("storage_object_id") or "")
+        actual_size = storage.file_size(
+            storage_object_id,
+            expected_task_id=task_id,
+            expected_source_file_id=file_id,
+        )
+        if actual_size is None:
+            raise fail(410, "the original PDF is unavailable for this legacy source file")
+        expected_size = int(source.get("size_bytes") or 0)
+        if actual_size != expected_size:
+            raise ValueError("source object size does not match metadata")
+        selected_range = _source_byte_range(range_header, actual_size)
+        start, end = selected_range or (0, actual_size - 1)
+        length = end - start + 1
+        name = _safe_file_name(str(source.get("name") or "source.pdf"), "source.pdf")
+        headers = {
+            "Accept-Ranges": "bytes",
+            "Cache-Control": "private, no-store",
+            "Content-Disposition": f"inline; filename*=UTF-8''{quote(name, safe='')}",
+            "Content-Length": str(length),
+            "X-Accel-Buffering": "no",
+            "X-Content-Type-Options": "nosniff",
+        }
+        checksum = str(source.get("checksum_sha256") or "")
+        if checksum:
+            headers["ETag"] = f'"{checksum}"'
+        if selected_range is not None:
+            headers["Content-Range"] = f"bytes {start}-{end}/{actual_size}"
+        body = storage.iter_bytes(
+            storage_object_id,
+            expected_task_id=task_id,
+            expected_source_file_id=file_id,
+            expected_size=actual_size,
+            start=start,
+            length=length,
+        )
+        return StreamingResponse(
+            body,
+            status_code=206 if selected_range is not None else 200,
+            media_type="application/pdf",
+            headers=headers,
+        )
+
+
+@router.get("/{task_id}/source-files/{file_id}/pdf-pages")
+def source_file_pdf_pages(
+    task_id: str,
+    file_id: str,
+    store: DataProcessStore = Depends(get_data_process_store),
+    storage: LocalDataProcessStorage = Depends(get_data_process_storage),
+) -> dict[str, Any]:
+    """返回切片全文偏移对应的 PDF 物理页范围。"""
+
+    with api_errors():
+        source = store.get_source_file(task_id, file_id, include_content=False)
+        if str(source.get("file_format") or "").lower() != "pdf":
+            raise fail(415, "PDF page mapping is only available for PDF source files")
+        storage_object_id = str(source.get("storage_object_id") or "")
+        actual_size = storage.file_size(
+            storage_object_id,
+            expected_task_id=task_id,
+            expected_source_file_id=file_id,
+        )
+        if actual_size is None:
+            raise fail(410, "the original PDF is unavailable for this legacy source file")
+        expected_size = int(source.get("size_bytes") or 0)
+        if actual_size != expected_size:
+            raise ValueError("source object size does not match metadata")
+        raw = b"".join(
+            storage.iter_bytes(
+                storage_object_id,
+                expected_task_id=task_id,
+                expected_source_file_id=file_id,
+                expected_size=actual_size,
+            )
+        )
+        pages = extract_pdf_page_texts(raw)
+        return ok(
+            {
+                "page_count": len(pages),
+                "pages": [
+                    {
+                        "page_number": page.page_number,
+                        "source_start": page.source_start,
+                        "source_end": page.source_end,
+                    }
+                    for page in pages
+                ],
+            }
+        )
+
+
 @router.delete("/{task_id}/source-files/{file_id}")
 def delete_source_file(
     task_id: str,
     file_id: str,
     store: DataProcessStore = Depends(get_data_process_store),
+    storage: LocalDataProcessStorage = Depends(get_data_process_storage),
 ) -> dict[str, Any]:
     with api_errors():
+        source = store.get_source_file(task_id, file_id, include_content=False)
+        storage_object_id = str(source.get("storage_object_id") or "")
+        storage.validate_owner(
+            storage_object_id,
+            expected_task_id=task_id,
+            expected_source_file_id=file_id,
+        )
         store.delete_source_file(task_id, file_id)
-        return ok({"deleted": file_id}, "source file removed")
+        cleanup_pending = False
+        try:
+            storage.delete(
+                storage_object_id,
+                expected_task_id=task_id,
+                expected_source_file_id=file_id,
+            )
+        except Exception:
+            # 数据库软删除已经提交，不能再向客户端返回可重试的失败；保留逻辑引用，
+            # 由后续存储清理任务重试物理删除。
+            cleanup_pending = True
+            logger.exception(
+                "failed to remove data process source object after soft deletion",
+                extra={"task_id": task_id, "source_file_id": file_id},
+            )
+        return ok(
+            {"deleted": file_id, "storage_cleanup_pending": cleanup_pending},
+            "source file removed",
+        )
 
 
 def _external_postgres_connection(payload: ExternalSourceRequest) -> psycopg.Connection[Any]:
@@ -635,7 +1131,11 @@ def test_external_source(
     store: DataProcessStore = Depends(get_data_process_store),
 ) -> dict[str, Any]:
     with api_errors():
-        store.get_task(task_id)
+        task = store.get_task(task_id)
+        if str(task.get("process_type")) != "external":
+            raise InvalidStateError(
+                "external source access requires an external data processing task"
+            )
         try:
             with _external_postgres_connection(payload) as conn:
                 conn.execute("SELECT 1 AS ok").fetchone()
@@ -649,6 +1149,7 @@ def pull_external_source(
     task_id: str,
     payload: ExternalPullRequest,
     store: DataProcessStore = Depends(get_data_process_store),
+    storage: LocalDataProcessStorage = Depends(get_data_process_storage),
 ) -> dict[str, Any]:
     query = (payload.query or "").strip()
     if query.endswith(";"):
@@ -659,7 +1160,9 @@ def pull_external_source(
     if first_token not in {"select", "with"}:
         raise fail(400, "a read-only SELECT or WITH query is required for external pull")
     with api_errors():
-        store.get_task(task_id)
+        task = store.get_task(task_id)
+        if str(task.get("process_type")) != "external":
+            raise InvalidStateError("external pull requires an external data processing task")
         try:
             with _external_postgres_connection(payload) as conn:
                 conn.execute("SET TRANSACTION READ ONLY")
@@ -686,20 +1189,40 @@ def pull_external_source(
             raise fail(400, "external query returned no rows")
         content = "".join(content_parts)
         raw = content.encode("utf-8")
-        source = store.add_source_file(
-            task_id,
-            name=_safe_file_name(payload.file_name, "external-data.jsonl"),
-            content=content,
-            raw_size=len(raw),
-            checksum_sha256=hashlib.sha256(raw).hexdigest(),
-            file_format="jsonl",
-            record_count=len(rows),
-            metadata={
-                "external_type": payload.type,
-                "external_host": urlsplit(payload.url).hostname,
-                "external_limit": payload.limit,
-            },
+        name = _safe_file_name(payload.file_name, "external-data.jsonl")
+        source_file_id = new_id("dpsf")
+        staged = storage.stage_bytes(
+            batch_id=storage.new_batch_id(),
+            task_id=task_id,
+            source_file_id=source_file_id,
+            version=1,
+            name=name,
+            content=raw,
         )
+        sources = _commit_source_batch(
+            store,
+            storage,
+            task_id,
+            [
+                {
+                    "id": source_file_id,
+                    "storage_object_id": staged.reference,
+                    "name": name,
+                    "content": content,
+                    "raw_size": len(raw),
+                    "checksum_sha256": hashlib.sha256(raw).hexdigest(),
+                    "file_format": "jsonl",
+                    "record_count": len(rows),
+                    "metadata": {
+                        "external_type": payload.type,
+                        "external_host": urlsplit(payload.url).hostname,
+                        "external_limit": payload.limit,
+                    },
+                }
+            ],
+            [staged],
+        )
+        source = sources[0]
         return ok({"files": [source]}, "external source pulled")
 
 
@@ -724,7 +1247,7 @@ def _prepare_preview_items(
     if not sources:
         raise InvalidStateError("at least one source file is required")
     items = _build_preview_items(task, sources)
-    if not items:
+    if not items and source_file_ids is None:
         raise InvalidStateError("source files did not produce preview items")
     return items
 
@@ -736,10 +1259,38 @@ def build_preview(
     store: DataProcessStore = Depends(get_data_process_store),
 ) -> dict[str, Any]:
     with api_errors():
-        items = _prepare_preview_items(task_id, store, payload.source_file_ids)
-        created = store.replace_preview_items(task_id, items)
+        selected_ids = payload.source_file_ids
+        items = _prepare_preview_items(task_id, store, selected_ids)
+        created = store.replace_preview_items(
+            task_id,
+            items,
+            source_file_ids=selected_ids,
+        )
+        target_ids = selected_ids or [
+            str(source["id"]) for source in store.list_source_files(task_id)
+        ]
+        file_counts = dict.fromkeys(target_ids, 0)
+        for item in created:
+            source_file_id = str(item.get("source_file_id") or "")
+            if source_file_id in file_counts:
+                file_counts[source_file_id] += 1
+        files = [
+            {
+                "source_file_id": source_file_id,
+                "preview_count": count,
+                "status": "completed" if count else "empty",
+            }
+            for source_file_id, count in file_counts.items()
+        ]
         return ok(
-            {"items": created, "total": len(created), "page": 1, "page_size": len(created)},
+            {
+                "items": created,
+                "total": len(created),
+                "page": 1,
+                "page_size": len(created),
+                "file_counts": file_counts,
+                "files": files,
+            },
             "preview built",
         )
 
diff --git a/backend/app/modules/data_process/algorithms.py b/backend/app/modules/data_process/algorithms.py
index 9e4fb12..a293f9e 100644
--- a/backend/app/modules/data_process/algorithms.py
+++ b/backend/app/modules/data_process/algorithms.py
@@ -11,18 +11,53 @@ import csv
 import hashlib
 import io
 import json
+import math
 import re
 import unicodedata
+import xml.etree.ElementTree as ET
+import zipfile
 from bisect import bisect_left
+from collections import Counter
 from collections.abc import Iterable, Mapping, Sequence
+from copy import deepcopy
 from dataclasses import dataclass
-from pathlib import Path
+from datetime import date, datetime, time
+from pathlib import Path, PurePosixPath
 from typing import Any, Literal
+from urllib.parse import unquote, urlsplit
 
+from docx import Document
+from docx.oxml.table import CT_Tbl
+from docx.oxml.text.paragraph import CT_P
+from docx.table import Table
+from docx.text.paragraph import Paragraph
+from llama_index.core.node_parser import SentenceSplitter, TokenTextSplitter
+from openpyxl import load_workbook
+from openpyxl.utils.cell import range_boundaries
+from pptx import Presentation
+from pypdf import PdfReader
 
-TextFormat = Literal["json", "jsonl", "csv", "markdown", "txt"]
-ChunkMethod = Literal["semantic", "heading", "fixed", "custom"]
+TextFormat = Literal[
+    "json",
+    "jsonl",
+    "csv",
+    "markdown",
+    "txt",
+    "pdf",
+    "docx",
+    "xlsx",
+    "pptx",
+]
+ChunkMethod = Literal["structure", "fixed", "custom"]
 DatasetSplit = Literal["train", "validation", "test"]
+StructuredPreprocessOption = Literal[
+    "clean_invalid",
+    "detect_structure",
+    "deduplicate",
+    "normalize_format",
+    "filter_anomaly",
+    "desensitize",
+]
 
 SUPPORTED_TEXT_FORMATS: tuple[TextFormat, ...] = (
     "json",
@@ -30,6 +65,10 @@ SUPPORTED_TEXT_FORMATS: tuple[TextFormat, ...] = (
     "csv",
     "markdown",
     "txt",
+    "pdf",
+    "docx",
+    "xlsx",
+    "pptx",
 )
 
 _FORMAT_ALIASES: dict[str, TextFormat] = {
@@ -42,6 +81,58 @@ _FORMAT_ALIASES: dict[str, TextFormat] = {
     "markdown": "markdown",
     "txt": "txt",
     "text": "txt",
+    "pdf": "pdf",
+    "docx": "docx",
+    "xlsx": "xlsx",
+    "pptx": "pptx",
+}
+_LEGACY_OFFICE_FORMATS: dict[str, str] = {
+    "doc": "docx",
+    "xls": "xlsx",
+    "ppt": "pptx",
+}
+_OFFICE_OPEN_XML_FORMATS = {"docx", "xlsx", "pptx"}
+_MAX_ARCHIVE_ENTRIES = 10_000
+_MAX_ARCHIVE_UNCOMPRESSED_BYTES = 512 * 1024 * 1024
+_MAX_ARCHIVE_ENTRY_BYTES = 128 * 1024 * 1024
+_MAX_ARCHIVE_COMPRESSION_RATIO = 200
+_MAX_EXTRACTED_TEXT_CHARS = 20_000_000
+_MAX_PDF_PAGES = 2_000
+_MAX_PRESENTATION_SLIDES = 2_000
+_MAX_WORKBOOK_SHEETS = 100
+_MAX_WORKBOOK_ROWS = 100_000
+_MAX_WORKBOOK_SCANNED_ROWS = 200_000
+_MAX_WORKBOOK_COLUMNS = 256
+_MAX_WORKBOOK_CELLS = 2_000_000
+_MAX_WORKBOOK_HEADER_ROWS = 8
+_MAX_WORKBOOK_HEADER_SCAN_ROWS = 64
+_MAX_WORKBOOK_MERGED_RANGES = 100_000
+_MAX_STRUCTURED_FIELDS = 1_024
+_MAX_STRUCTURED_DEPTH = 16
+_MAX_ANOMALY_TEXT_CHARS = 1_000_000
+_STRUCTURED_OPTIONS = {
+    "clean_invalid",
+    "detect_structure",
+    "deduplicate",
+    "normalize_format",
+    "filter_anomaly",
+    "desensitize",
+}
+_IDENTITY_FIELD_PATTERN = re.compile(r"(?:^|[._])(?:id|uuid|key|code)$|(?:^|[._]).+_id$")
+_MOJIBAKE_MARKERS = ("\ufffd", "锟斤拷", "烫烫烫", "屯屯屯", "Ã", "Â", "â€")
+_NAME_FIELD_NAMES = {
+    "name",
+    "full_name",
+    "fullname",
+    "real_name",
+    "contact_name",
+    "customer_name",
+    "recipient_name",
+    "姓名",
+    "真实姓名",
+    "联系人",
+    "联系人姓名",
+    "收件人",
 }
 
 _EMAIL_PATTERN = re.compile(
@@ -51,23 +142,39 @@ _EMAIL_PATTERN = re.compile(
 )
 _PHONE_PATTERN = re.compile(r"(?<!\d)(?:(?:\+|00)?86[-\s]?)?1[3-9]\d{9}(?!\d)")
 _ID_CARD_PATTERN = re.compile(r"(?<!\d)(?:\d{17}[\dXx]|\d{15})(?!\d)")
-_TOKEN_PATTERN = re.compile(r"[\u3400-\u4dbf\u4e00-\u9fff]|[A-Za-z0-9_]+|[^\s]")
-_HEADING_PATTERN = re.compile(
-    r"(?m)^(?:#{1,6}\s+|第[一二三四五六七八九十百千万0-9]+[章节篇部分]\s*|"
-    r"\d+(?:\.\d+)*[、.\s]+)"
+_CHINESE_NAME_CONTEXT_PATTERN = re.compile(
+    r"(?P<label>姓名|真实姓名|联系人(?:姓名)?|收件人)"
+    r"(?P<separator>\s*(?:[:：=]|为)\s*|\s+)"
+    r"(?P<name>[\u3400-\u4dbf\u4e00-\u9fff·]{2,8})"
 )
+_ENGLISH_NAME_CONTEXT_PATTERN = re.compile(
+    r"(?im)(?P<label>full\s+name|contact\s+name|name)"
+    r"(?P<separator>\s*[:=]\s*)"
+    r"(?P<name>[A-Za-z][A-Za-z'’-]*(?:[ \t]+[A-Za-z][A-Za-z'’-]*){0,3})"
+)
+_TOKEN_PATTERN = re.compile(r"[\u3400-\u4dbf\u4e00-\u9fff]|[A-Za-z0-9_]+|[^\s]")
 _SEMANTIC_BOUNDARY_PATTERN = re.compile(r"\n\s*\n|[。！？!?；;](?:[\"'”’）】》]*)|\.(?:\s+|$)")
 
 
 @dataclass(frozen=True, slots=True)
 class ParsedText:
-    """UTF-8 文本的解析结果。"""
+    """文本、文档或工作簿的统一解析结果。"""
 
     format: TextFormat
     text: str
     records: tuple[dict[str, Any], ...]
 
 
+@dataclass(frozen=True, slots=True)
+class PdfPageText:
+    """PDF 物理页在统一提取文本中的字符范围。"""
+
+    page_number: int
+    text: str
+    source_start: int
+    source_end: int
+
+
 @dataclass(frozen=True, slots=True)
 class TextChunk:
     """带有可追溯来源位置的非结构化文本切片。"""
@@ -95,6 +202,29 @@ class QualityScore:
     fingerprint: str
 
 
+@dataclass(frozen=True, slots=True)
+class DocumentHeading:
+    """文档标题的位置和层级。"""
+
+    level: int
+    title: str
+    line_number: int
+    start: int
+    end: int
+
+
+@dataclass(frozen=True, slots=True)
+class DocumentStructure:
+    """无需外部模型即可复现的文档结构摘要。"""
+
+    line_count: int
+    paragraph_count: int
+    headings: tuple[DocumentHeading, ...]
+    code_block_count: int
+    table_block_count: int
+    list_block_count: int
+
+
 def decode_utf8(raw: bytes | bytearray | memoryview | str) -> str:
     """严格解码 UTF-8 文本，并移除可选 BOM。
 
@@ -137,6 +267,12 @@ def _normalize_format(value: str | None) -> TextFormat | None:
     if value is None:
         return None
     normalized = value.strip().lower().removeprefix(".")
+    if normalized in _LEGACY_OFFICE_FORMATS:
+        replacement = _LEGACY_OFFICE_FORMATS[normalized]
+        raise ValueError(
+            f"legacy .{normalized} format is not supported; "
+            f"convert the file to .{replacement} and upload again"
+        )
     try:
         return _FORMAT_ALIASES[normalized]
     except KeyError as exc:
@@ -157,6 +293,12 @@ def detect_text_format(
 
     if filename:
         suffix = Path(filename).suffix.lower().removeprefix(".")
+        if suffix in _LEGACY_OFFICE_FORMATS:
+            replacement = _LEGACY_OFFICE_FORMATS[suffix]
+            raise ValueError(
+                f"legacy .{suffix} format is not supported; "
+                f"convert the file to .{replacement} and upload again"
+            )
         detected = _FORMAT_ALIASES.get(suffix)
         if detected:
             return detected
@@ -198,6 +340,752 @@ def detect_text_format(
     return "txt"
 
 
+def _binary_bytes(
+    raw: bytes | bytearray | memoryview | str,
+    file_format: TextFormat,
+) -> bytes:
+    if isinstance(raw, str):
+        raise ValueError(f"{file_format.upper()} content must be uploaded as binary data")
+    if not isinstance(raw, (bytes, bytearray, memoryview)):
+        raise TypeError("raw must be bytes-like or str")
+    return bytes(raw)
+
+
+def _validate_office_archive(raw: bytes, file_format: TextFormat) -> None:
+    """在交给 Office 解析库前限制 ZIP 包规模并拒绝活动 XML。"""
+
+    required_members = {
+        "docx": {"[Content_Types].xml", "word/document.xml"},
+        "xlsx": {"[Content_Types].xml", "xl/workbook.xml"},
+        "pptx": {"[Content_Types].xml", "ppt/presentation.xml"},
+    }
+    try:
+        with zipfile.ZipFile(io.BytesIO(raw)) as archive:
+            members = archive.infolist()
+            if len(members) > _MAX_ARCHIVE_ENTRIES:
+                raise ValueError(
+                    f"{file_format.upper()} archive contains too many entries "
+                    f"(limit {_MAX_ARCHIVE_ENTRIES})"
+                )
+
+            names: set[str] = set()
+            total_size = 0
+            for member in members:
+                path = PurePosixPath(member.filename.replace("\\", "/"))
+                if path.is_absolute() or ".." in path.parts:
+                    raise ValueError(
+                        f"{file_format.upper()} archive contains an unsafe member path"
+                    )
+                if member.filename in names:
+                    raise ValueError(
+                        f"{file_format.upper()} archive contains duplicate member names"
+                    )
+                names.add(member.filename)
+                if member.flag_bits & 0x1:
+                    raise ValueError(f"encrypted {file_format.upper()} files are not supported")
+                if member.is_dir():
+                    continue
+                if member.file_size > _MAX_ARCHIVE_ENTRY_BYTES:
+                    raise ValueError(
+                        f"{file_format.upper()} archive entry exceeds "
+                        f"{_MAX_ARCHIVE_ENTRY_BYTES} bytes"
+                    )
+                total_size += member.file_size
+                if total_size > _MAX_ARCHIVE_UNCOMPRESSED_BYTES:
+                    raise ValueError(
+                        f"{file_format.upper()} archive expands beyond "
+                        f"{_MAX_ARCHIVE_UNCOMPRESSED_BYTES} bytes"
+                    )
+                if member.file_size >= 1024 * 1024:
+                    if member.compress_size <= 0:
+                        raise ValueError(
+                            f"{file_format.upper()} archive has an unsafe compression ratio"
+                        )
+                    ratio = member.file_size / member.compress_size
+                    if ratio > _MAX_ARCHIVE_COMPRESSION_RATIO:
+                        raise ValueError(
+                            f"{file_format.upper()} archive has an unsafe compression ratio"
+                        )
+
+            missing = required_members[file_format] - names
+            if missing:
+                raise ValueError(
+                    f"invalid {file_format.upper()} package: missing "
+                    f"{', '.join(sorted(missing))}"
+                )
+
+            for member in members:
+                if member.is_dir() or not member.filename.lower().endswith((".xml", ".rels")):
+                    continue
+                with archive.open(member) as stream:
+                    prefix = stream.read(min(member.file_size, 1024 * 1024)).upper()
+                if b"<!DOCTYPE" in prefix or b"<!ENTITY" in prefix:
+                    raise ValueError(
+                        f"{file_format.upper()} archive contains unsupported active XML"
+                    )
+    except zipfile.BadZipFile as exc:
+        raise ValueError(f"invalid {file_format.upper()} file: not an Office ZIP package") from exc
+
+
+def _append_bounded_text(parts: list[str], value: Any, total: int) -> int:
+    text = normalize_text(str(value or ""))
+    if not text:
+        return total
+    total += len(text)
+    if total > _MAX_EXTRACTED_TEXT_CHARS:
+        raise ValueError(
+            f"extracted document text exceeds {_MAX_EXTRACTED_TEXT_CHARS} characters"
+        )
+    parts.append(text)
+    return total
+
+
+def extract_pdf_page_texts(raw: bytes) -> tuple[PdfPageText, ...]:
+    """提取 PDF 各页文本，并保留与切片字符偏移一致的页范围。"""
+
+    if b"%PDF-" not in raw[:1024]:
+        raise ValueError("invalid PDF file: missing PDF header")
+    try:
+        reader = PdfReader(io.BytesIO(raw), strict=True)
+    except Exception as exc:
+        raise ValueError(f"invalid PDF file: {exc}") from exc
+    if reader.is_encrypted and not reader.decrypt(""):
+        raise ValueError("password-protected PDF files are not supported")
+    if len(reader.pages) > _MAX_PDF_PAGES:
+        raise ValueError(f"PDF contains too many pages (limit {_MAX_PDF_PAGES})")
+
+    pages: list[PdfPageText] = []
+    total = 0
+    has_text = False
+    for page_number, page in enumerate(reader.pages, start=1):
+        try:
+            text = normalize_text(page.extract_text() or "")
+        except Exception as exc:
+            raise ValueError(
+                f"failed to extract text from PDF page {page_number}: {exc}"
+            ) from exc
+        if not text:
+            pages.append(
+                PdfPageText(
+                    page_number=page_number,
+                    text="",
+                    source_start=total,
+                    source_end=total,
+                )
+            )
+            continue
+        if has_text:
+            total += 2
+        start = total
+        total += len(text)
+        if total > _MAX_EXTRACTED_TEXT_CHARS:
+            raise ValueError(
+                f"extracted document text exceeds {_MAX_EXTRACTED_TEXT_CHARS} characters"
+            )
+        pages.append(
+            PdfPageText(
+                page_number=page_number,
+                text=text,
+                source_start=start,
+                source_end=total,
+            )
+        )
+        has_text = True
+    if not has_text:
+        raise ValueError("PDF contains no extractable text; scanned PDF requires OCR")
+    return tuple(pages)
+
+
+def _extract_pdf_text(raw: bytes) -> str:
+    return "\n\n".join(page.text for page in extract_pdf_page_texts(raw) if page.text)
+
+
+def _extract_docx_text(raw: bytes) -> str:
+    _validate_office_archive(raw, "docx")
+    try:
+        document = Document(io.BytesIO(raw))
+    except Exception as exc:
+        raise ValueError(f"invalid DOCX file: {exc}") from exc
+
+    parts: list[str] = []
+    total = 0
+    for child in document.element.body.iterchildren():
+        if isinstance(child, CT_P):
+            total = _append_bounded_text(parts, Paragraph(child, document).text, total)
+            continue
+        if isinstance(child, CT_Tbl):
+            table = Table(child, document)
+            for row in table.rows:
+                cells = [normalize_text(cell.text) for cell in row.cells]
+                total = _append_bounded_text(parts, "\t".join(cells), total)
+    return normalize_text("\n\n".join(parts))
+
+
+def _presentation_shape_text(shape: Any) -> list[str]:
+    if getattr(shape, "has_table", False):
+        return [
+            "\t".join(normalize_text(cell.text) for cell in row.cells)
+            for row in shape.table.rows
+        ]
+    if getattr(shape, "has_text_frame", False):
+        return [shape.text]
+    child_shapes = getattr(shape, "shapes", None)
+    if child_shapes is not None:
+        values: list[str] = []
+        for child in child_shapes:
+            values.extend(_presentation_shape_text(child))
+        return values
+    return []
+
+
+def _extract_pptx_text(raw: bytes) -> str:
+    _validate_office_archive(raw, "pptx")
+    try:
+        presentation = Presentation(io.BytesIO(raw))
+    except Exception as exc:
+        raise ValueError(f"invalid PPTX file: {exc}") from exc
+    if len(presentation.slides) > _MAX_PRESENTATION_SLIDES:
+        raise ValueError(
+            f"PPTX contains too many slides (limit {_MAX_PRESENTATION_SLIDES})"
+        )
+
+    parts: list[str] = []
+    total = 0
+    for slide in presentation.slides:
+        slide_parts: list[str] = []
+        for shape in slide.shapes:
+            slide_parts.extend(_presentation_shape_text(shape))
+        total = _append_bounded_text(parts, "\n".join(slide_parts), total)
+    return normalize_text("\n\n".join(parts))
+
+
+def _normalize_spreadsheet_value(value: Any) -> Any:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return normalize_text(value)
+    if isinstance(value, (datetime, date, time)):
+        return value.isoformat()
+    if isinstance(value, (bool, int, float)):
+        return value
+    return normalize_text(str(value))
+
+
+def _xml_local_name(tag: str) -> str:
+    return tag.rsplit("}", 1)[-1]
+
+
+def _resolve_xlsx_relationship_target(
+    archive: zipfile.ZipFile,
+    target: str,
+    *,
+    source_part: str = "xl/workbook.xml",
+) -> str:
+    """按 OPC URI 规则解析内部关系目标，并保证结果仍位于 ZIP 根内。"""
+
+    raw_target = target.strip()
+    if (
+        raw_target != target
+        or not raw_target
+        or "\\" in raw_target
+        or any(unicodedata.category(char).startswith("C") for char in raw_target)
+        or re.search(r"%(?![0-9A-Fa-f]{2})", raw_target)
+    ):
+        raise ValueError("XLSX workbook contains an unsafe worksheet path")
+    try:
+        parsed = urlsplit(raw_target)
+    except ValueError as exc:
+        raise ValueError("XLSX workbook contains an unsafe worksheet path") from exc
+    if parsed.scheme or parsed.netloc or parsed.query or parsed.fragment:
+        raise ValueError("XLSX workbook contains an unsafe worksheet path")
+    if re.search(r"%(?:2[fF]|5[cC]|0{2})", parsed.path):
+        raise ValueError("XLSX workbook contains an unsafe worksheet path")
+    try:
+        decoded_path = unquote(parsed.path, encoding="utf-8", errors="strict")
+    except UnicodeDecodeError as exc:
+        raise ValueError("XLSX workbook contains an unsafe worksheet path") from exc
+    if not decoded_path or "\\" in decoded_path or "\x00" in decoded_path or "%" in decoded_path:
+        raise ValueError("XLSX workbook contains an unsafe worksheet path")
+
+    parts = [] if decoded_path.startswith("/") else list(PurePosixPath(source_part).parent.parts)
+    for part in decoded_path.lstrip("/").split("/"):
+        if part in {"", "."}:
+            continue
+        if part == "..":
+            if not parts:
+                raise ValueError("XLSX workbook contains an unsafe worksheet path")
+            parts.pop()
+            continue
+        if unicodedata.category(part[0]).startswith("C") or any(
+            unicodedata.category(char).startswith("C") for char in part
+        ):
+            raise ValueError("XLSX workbook contains an unsafe worksheet path")
+        parts.append(part)
+    if not parts:
+        raise ValueError("XLSX workbook contains an unsafe worksheet path")
+
+    member_name = "/".join(parts)
+    try:
+        member = archive.getinfo(member_name)
+    except KeyError as exc:
+        raise ValueError(
+            f"XLSX worksheet relationship target does not exist: {member_name}"
+        ) from exc
+    if member.is_dir():
+        raise ValueError("XLSX worksheet relationship target must be a file")
+    return member_name
+
+
+def _rewrite_xlsx_workbook_relationships(
+    raw: bytes,
+    replacements: Mapping[str, str],
+) -> bytes:
+    """把已验证的 worksheet Target 改为解析库稳定支持的包内绝对路径。"""
+
+    relationships_member = "xl/_rels/workbook.xml.rels"
+    output = io.BytesIO()
+    with zipfile.ZipFile(io.BytesIO(raw)) as source, zipfile.ZipFile(output, "w") as target:
+        target.comment = source.comment
+        for member in source.infolist():
+            if member.filename == relationships_member:
+                root = ET.fromstring(source.read(member))
+                pending = dict(replacements)
+                for element in root:
+                    if _xml_local_name(element.tag) != "Relationship":
+                        continue
+                    relationship_id = element.attrib.get("Id")
+                    if relationship_id in pending:
+                        element.set("Target", pending.pop(relationship_id))
+                if pending:
+                    raise ValueError(
+                        "XLSX workbook relationship changed during normalization"
+                    )
+                content = ET.tostring(root, encoding="utf-8", xml_declaration=True)
+                target.writestr(member, content)
+                continue
+            if member.is_dir():
+                target.writestr(member, b"")
+                continue
+            with source.open(member) as source_stream, target.open(
+                member,
+                "w",
+                force_zip64=True,
+            ) as target_stream:
+                while chunk := source_stream.read(1024 * 1024):
+                    target_stream.write(chunk)
+    return output.getvalue()
+
+
+def _xlsx_sheet_merge_ranges(
+    raw: bytes,
+) -> tuple[
+    dict[str, tuple[tuple[int, int, int, int], ...]],
+    dict[str, str],
+]:
+    """流式读取 XLSX 合并单元格，不把工作表 XML 整体载入内存。"""
+
+    relationship_namespace = (
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+    )
+    try:
+        with zipfile.ZipFile(io.BytesIO(raw)) as archive:
+            relationships: dict[str, tuple[str, str, str]] = {}
+            with archive.open("xl/_rels/workbook.xml.rels") as stream:
+                for _, element in ET.iterparse(stream, events=("end",)):
+                    if _xml_local_name(element.tag) != "Relationship":
+                        element.clear()
+                        continue
+                    relationship_id = element.attrib.get("Id")
+                    target = element.attrib.get("Target")
+                    target_mode = element.attrib.get("TargetMode", "Internal")
+                    relationship_type = element.attrib.get("Type", "")
+                    if relationship_id:
+                        if relationship_id in relationships:
+                            raise ValueError(
+                                "XLSX workbook contains duplicate relationship identifiers"
+                            )
+                        relationships[relationship_id] = (
+                            target or "",
+                            target_mode,
+                            relationship_type,
+                        )
+                    element.clear()
+
+            sheet_paths: dict[str, str] = {}
+            normalized_targets: dict[str, str] = {}
+            with archive.open("xl/workbook.xml") as stream:
+                for _, element in ET.iterparse(stream, events=("end",)):
+                    if _xml_local_name(element.tag) != "sheet":
+                        element.clear()
+                        continue
+                    title = element.attrib.get("name")
+                    relationship_id = element.attrib.get(
+                        f"{{{relationship_namespace}}}id"
+                    )
+                    if title and relationship_id:
+                        relationship = relationships.get(relationship_id)
+                        if relationship is None:
+                            raise ValueError(
+                                f"XLSX worksheet {title!r} references a missing relationship"
+                            )
+                        target, target_mode, relationship_type = relationship
+                        if target_mode.strip().lower() != "internal":
+                            raise ValueError(
+                                f"XLSX worksheet {title!r} uses an external relationship"
+                            )
+                        if not relationship_type.endswith("/worksheet"):
+                            raise ValueError(
+                                f"XLSX worksheet {title!r} has an invalid relationship type"
+                            )
+                        member_name = _resolve_xlsx_relationship_target(
+                            archive,
+                            target,
+                        )
+                        sheet_paths[title] = member_name
+                        canonical_target = f"/{member_name}"
+                        if target != canonical_target:
+                            normalized_targets[relationship_id] = canonical_target
+                    element.clear()
+
+            result: dict[str, tuple[tuple[int, int, int, int], ...]] = {}
+            total_ranges = 0
+            for title, member_name in sheet_paths.items():
+                ranges: list[tuple[int, int, int, int]] = []
+                with archive.open(member_name) as stream:
+                    for _, element in ET.iterparse(stream, events=("end",)):
+                        if _xml_local_name(element.tag) != "mergeCell":
+                            element.clear()
+                            continue
+                        reference = element.attrib.get("ref")
+                        if reference:
+                            try:
+                                boundaries = range_boundaries(reference)
+                            except ValueError as exc:
+                                raise ValueError(
+                                    f"XLSX worksheet {title!r} has an invalid merged range"
+                                ) from exc
+                            ranges.append(boundaries)
+                            total_ranges += 1
+                            if total_ranges > _MAX_WORKBOOK_MERGED_RANGES:
+                                raise ValueError(
+                                    "XLSX workbook contains too many merged ranges "
+                                    f"(limit {_MAX_WORKBOOK_MERGED_RANGES})"
+                                )
+                        element.clear()
+                result[title] = tuple(ranges)
+            return result, normalized_targets
+    except (KeyError, ET.ParseError, zipfile.BadZipFile) as exc:
+        raise ValueError(f"invalid XLSX workbook structure: {exc}") from exc
+
+
+def _xlsx_header_end_row(
+    first_row: int,
+    rows: Mapping[int, Sequence[Any]],
+    merged_ranges: Sequence[tuple[int, int, int, int]],
+) -> int:
+    """在固定深度内闭包表头合并关系，忽略越界或跨空行的可疑级联。"""
+
+    header_end = first_row
+    maximum_end = first_row + _MAX_WORKBOOK_HEADER_ROWS - 1
+    has_header_hierarchy = any(
+        max_column > min_column and min_row == first_row
+        for min_column, min_row, max_column, _ in merged_ranges
+    )
+    changed = True
+    while changed:
+        changed = False
+        for min_column, min_row, max_column, max_row in merged_ranges:
+            if min_row < first_row or min_row > header_end or max_row < first_row:
+                continue
+            if max_column == min_column and not has_header_hierarchy:
+                continue
+            candidate = max_row + 1 if max_column > min_column else max_row
+            if candidate <= header_end or candidate > maximum_end:
+                continue
+            if (
+                max_column > min_column
+                and len(_xlsx_nonempty_values(rows.get(min_row, ()))) < 2
+                and len(_xlsx_nonempty_values(rows.get(candidate, ()))) < 2
+            ):
+                continue
+            if any(
+                not rows.get(row_number)
+                for row_number in range(header_end + 1, candidate + 1)
+            ):
+                continue
+            header_end = candidate
+            changed = True
+    return header_end
+
+
+def _xlsx_headers(
+    title: str,
+    rows: Mapping[int, Sequence[Any]],
+    first_row: int,
+    header_end: int,
+    merged_ranges: Sequence[tuple[int, int, int, int]],
+) -> list[str]:
+    width = max((len(row) for row in rows.values()), default=0)
+    for min_column, min_row, max_column, max_row in merged_ranges:
+        if min_row <= header_end and max_row >= first_row:
+            width = max(width, max_column)
+    if width > _MAX_WORKBOOK_COLUMNS:
+        raise ValueError(
+            f"XLSX worksheet {title!r} exceeds {_MAX_WORKBOOK_COLUMNS} columns"
+        )
+
+    matrix = [
+        list(rows.get(row_number, ())) + [None] * (width - len(rows.get(row_number, ())))
+        for row_number in range(first_row, header_end + 1)
+    ]
+    for min_column, min_row, max_column, max_row in merged_ranges:
+        if min_row > header_end or max_row < first_row:
+            continue
+        source_row = max(first_row, min_row) - first_row
+        source_column = min_column - 1
+        source = matrix[source_row][source_column]
+        for row_number in range(max(first_row, min_row), min(header_end, max_row) + 1):
+            for column_number in range(min_column, max_column + 1):
+                matrix[row_number - first_row][column_number - 1] = source
+
+    headers: list[str] = []
+    for column in range(width):
+        components: list[str] = []
+        for row in matrix:
+            component = normalize_text(str(row[column] or ""))
+            if component and (not components or component != components[-1]):
+                components.append(component)
+        header = ".".join(components)
+        if not header:
+            raise ValueError(f"XLSX worksheet {title!r} contains an empty header")
+        headers.append(header)
+    if len(set(headers)) != len(headers):
+        raise ValueError(f"XLSX worksheet {title!r} contains duplicate headers")
+    return headers
+
+
+_XLSX_REPORT_METADATA_PATTERN = re.compile(
+    r"^(?:报表|报告|标题|说明|备注|制表|统计|日期|时间|期间|"
+    r"report|title|note|remark|date|time|period)\b",
+    flags=re.IGNORECASE,
+)
+
+
+def _xlsx_nonempty_values(row: Sequence[Any]) -> list[Any]:
+    return [value for value in row if value not in {None, ""}]
+
+
+def _infer_xlsx_header_region(
+    title: str,
+    rows: Mapping[int, Sequence[Any]],
+    merged_ranges: Sequence[tuple[int, int, int, int]],
+) -> tuple[int, int, list[str]]:
+    """从有界前缀中推断表头，区分报表说明、多级表头和正文合并。"""
+
+    ordered_rows = sorted(rows)
+    if not ordered_rows:
+        return 0, 0, []
+    first_nonempty_row = ordered_rows[0]
+    horizontal_merge_rows = {
+        min_row
+        for min_column, min_row, max_column, _ in merged_ranges
+        if max_column > min_column
+    }
+    candidates: list[tuple[float, int, int, list[str]]] = []
+    for first_row in ordered_rows:
+        raw_values = _xlsx_nonempty_values(rows[first_row])
+        if not raw_values:
+            continue
+        if len(raw_values) < 2 and first_row in horizontal_merge_rows:
+            continue
+
+        header_end = _xlsx_header_end_row(first_row, rows, merged_ranges)
+        header_rows = {
+            row_number: rows[row_number]
+            for row_number in range(first_row, header_end + 1)
+            if row_number in rows
+        }
+        try:
+            headers = _xlsx_headers(
+                title,
+                header_rows,
+                first_row,
+                header_end,
+                merged_ranges,
+            )
+        except ValueError:
+            if header_end == first_row:
+                continue
+            header_end = first_row
+            try:
+                headers = _xlsx_headers(
+                    title,
+                    {first_row: rows[first_row]},
+                    first_row,
+                    first_row,
+                    merged_ranges,
+                )
+            except ValueError:
+                continue
+
+        data_rows = [rows[row_number] for row_number in ordered_rows if row_number > header_end]
+        if any(len(row) > len(headers) for row in data_rows):
+            continue
+
+        text_ratio = sum(isinstance(value, str) for value in raw_values) / len(raw_values)
+        score = text_ratio * 6 + min(len(raw_values), 4)
+        if data_rows:
+            first_data_values = _xlsx_nonempty_values(data_rows[0])
+            score += 4 * min(len(first_data_values), len(headers)) / len(headers)
+            if first_data_values:
+                score += (
+                    2
+                    * sum(
+                        not isinstance(value, str)
+                        for value in first_data_values
+                    )
+                    / len(first_data_values)
+                )
+        first_label = normalize_text(str(raw_values[0]))
+        if len(raw_values) <= 2 and _XLSX_REPORT_METADATA_PATTERN.match(first_label):
+            score -= 8
+        candidates.append((score, first_row, header_end, headers))
+
+    if not candidates:
+        first_row = first_nonempty_row
+        headers = _xlsx_headers(
+            title,
+            {first_row: rows[first_row]},
+            first_row,
+            first_row,
+            (),
+        )
+        return first_row, first_row, headers
+    _, first_row, header_end, headers = max(
+        candidates,
+        key=lambda candidate: (candidate[0], -candidate[1]),
+    )
+    return first_row, header_end, headers
+
+
+def _extract_xlsx_records(raw: bytes) -> list[dict[str, Any]]:
+    _validate_office_archive(raw, "xlsx")
+    merged_by_sheet, normalized_targets = _xlsx_sheet_merge_ranges(raw)
+    workbook_raw = (
+        _rewrite_xlsx_workbook_relationships(raw, normalized_targets)
+        if normalized_targets
+        else raw
+    )
+    try:
+        workbook = load_workbook(
+            io.BytesIO(workbook_raw),
+            read_only=True,
+            data_only=True,
+            keep_links=False,
+        )
+    except Exception as exc:
+        raise ValueError(f"invalid XLSX file: {exc}") from exc
+
+    records: list[dict[str, Any]] = []
+    total_cells = 0
+    try:
+        if len(workbook.worksheets) > _MAX_WORKBOOK_SHEETS:
+            raise ValueError(
+                f"XLSX contains too many worksheets (limit {_MAX_WORKBOOK_SHEETS})"
+            )
+        for worksheet in workbook.worksheets:
+            reset_dimensions = getattr(worksheet, "reset_dimensions", None)
+            if callable(reset_dimensions):
+                reset_dimensions()
+            merged_ranges = merged_by_sheet.get(worksheet.title, ())
+            sheet_rows = 0
+            scanned_rows = 0
+            row_iterator = enumerate(
+                worksheet.iter_rows(values_only=True),
+                start=1,
+            )
+            buffered_rows: dict[int, Sequence[Any]] = {}
+
+            def normalized_row_values(row: Sequence[Any]) -> list[Any]:
+                values = list(row)
+                while values and values[-1] in {None, ""}:
+                    values.pop()
+                if len(values) > _MAX_WORKBOOK_COLUMNS:
+                    raise ValueError(
+                        f"XLSX worksheet {worksheet.title!r} exceeds "
+                        f"{_MAX_WORKBOOK_COLUMNS} columns"
+                    )
+                return values
+
+            for row_number, row in row_iterator:
+                scanned_rows += 1
+                if scanned_rows > _MAX_WORKBOOK_SCANNED_ROWS:
+                    raise ValueError(
+                        f"XLSX worksheet {worksheet.title!r} exceeds "
+                        f"{_MAX_WORKBOOK_SCANNED_ROWS} scanned rows"
+                    )
+                values = normalized_row_values(row)
+                if not values or all(value in {None, ""} for value in values):
+                    continue
+                buffered_rows[row_number] = tuple(values)
+                if len(buffered_rows) >= _MAX_WORKBOOK_HEADER_SCAN_ROWS:
+                    break
+
+            if not buffered_rows:
+                continue
+            _, header_end_row, headers = _infer_xlsx_header_region(
+                worksheet.title,
+                buffered_rows,
+                merged_ranges,
+            )
+
+            def append_record(values: Sequence[Any]) -> None:
+                nonlocal total_cells, sheet_rows
+                row_values = list(values)
+                if len(row_values) > len(headers):
+                    raise ValueError(
+                        f"XLSX worksheet {worksheet.title!r} has a row wider than its header"
+                    )
+                row_values.extend([None] * (len(headers) - len(row_values)))
+                record = {
+                    header: _normalize_spreadsheet_value(value)
+                    for header, value in zip(headers, row_values, strict=True)
+                }
+                if not any(value not in {"", None} for value in record.values()):
+                    return
+                sheet_rows += 1
+                total_cells += len(headers)
+                if sheet_rows > _MAX_WORKBOOK_ROWS:
+                    raise ValueError(
+                        f"XLSX worksheet {worksheet.title!r} exceeds "
+                        f"{_MAX_WORKBOOK_ROWS} data rows"
+                    )
+                if total_cells > _MAX_WORKBOOK_CELLS:
+                    raise ValueError(
+                        f"XLSX workbook exceeds {_MAX_WORKBOOK_CELLS} populated cells"
+                    )
+                records.append(record)
+
+            for row_number, values in buffered_rows.items():
+                if row_number > header_end_row:
+                    append_record(values)
+
+            for _, row in row_iterator:
+                scanned_rows += 1
+                if scanned_rows > _MAX_WORKBOOK_SCANNED_ROWS:
+                    raise ValueError(
+                        f"XLSX worksheet {worksheet.title!r} exceeds "
+                        f"{_MAX_WORKBOOK_SCANNED_ROWS} scanned rows"
+                    )
+                values = normalized_row_values(row)
+                if not values or all(value in {None, ""} for value in values):
+                    continue
+                append_record(values)
+    finally:
+        workbook.close()
+    return records
+
+
 def _normalize_value(value: Any) -> Any:
     if isinstance(value, str):
         return normalize_text(value)
@@ -299,7 +1187,35 @@ def parse_text_content(
     filename: str | None = None,
     file_format: str | None = None,
 ) -> ParsedText:
-    """严格解码并解析支持的 UTF-8 文本格式。"""
+    """安全解析 UTF-8 文本、文本型 PDF 和现代 Office 文件。"""
+
+    detected_format = detect_text_format(
+        filename=filename,
+        text="",
+        file_format=file_format,
+    )
+    if detected_format in _OFFICE_OPEN_XML_FORMATS or detected_format == "pdf":
+        binary = _binary_bytes(raw, detected_format)
+        if detected_format == "pdf":
+            text = _extract_pdf_text(binary)
+            return ParsedText(format=detected_format, text=text, records=())
+        if detected_format == "docx":
+            text = _extract_docx_text(binary)
+            return ParsedText(format=detected_format, text=text, records=())
+        if detected_format == "pptx":
+            text = _extract_pptx_text(binary)
+            return ParsedText(format=detected_format, text=text, records=())
+
+        records = _extract_xlsx_records(binary)
+        text = "\n".join(
+            json.dumps(record, ensure_ascii=False, separators=(",", ":"))
+            for record in records
+        )
+        return ParsedText(
+            format=detected_format,
+            text=normalize_text(text),
+            records=tuple(records),
+        )
 
     text = normalize_text(decode_utf8(raw))
     detected_format = detect_text_format(filename=filename, text=text, file_format=file_format)
@@ -310,7 +1226,7 @@ def parse_text_content(
 
 
 def desensitize_pii(text: str) -> tuple[str, dict[str, int]]:
-    """掩码邮箱、中国大陆手机号和 15/18 位身份证号，并返回命中统计。"""
+    """掩码邮箱、手机号、身份证号及有明确上下文的姓名。"""
 
     if not isinstance(text, str):
         raise TypeError("text must be str")
@@ -326,10 +1242,490 @@ def desensitize_pii(text: str) -> tuple[str, dict[str, int]]:
     masked = replace(_EMAIL_PATTERN, "[EMAIL]", "email", text)
     masked = replace(_ID_CARD_PATTERN, "[ID_CARD]", "id_card", masked)
     masked = replace(_PHONE_PATTERN, "[PHONE]", "phone", masked)
+
+    def replace_context_name(match: re.Match[str]) -> str:
+        counts["name"] = counts.get("name", 0) + 1
+        return f"{match.group('label')}{match.group('separator')}[NAME]"
+
+    masked = _CHINESE_NAME_CONTEXT_PATTERN.sub(replace_context_name, masked)
+    masked = _ENGLISH_NAME_CONTEXT_PATTERN.sub(replace_context_name, masked)
     counts["total"] = sum(counts.values())
     return masked, counts
 
 
+def _is_empty_value(value: Any) -> bool:
+    if value is None:
+        return True
+    if isinstance(value, str):
+        return not normalize_text(value)
+    if isinstance(value, Mapping):
+        return not value or all(_is_empty_value(item) for item in value.values())
+    if isinstance(value, (list, tuple, set, frozenset)):
+        return not value or all(_is_empty_value(item) for item in value)
+    return False
+
+
+def _canonical_value(value: Any) -> Any:
+    if value is None or isinstance(value, (bool, int)):
+        return value
+    if isinstance(value, float):
+        if math.isfinite(value):
+            return value
+        return str(value).lower()
+    if isinstance(value, str):
+        return normalize_text(value)
+    if isinstance(value, (datetime, date, time)):
+        return value.isoformat()
+    if isinstance(value, Mapping):
+        normalized: dict[str, Any] = {}
+        for key, item in sorted(value.items(), key=lambda pair: str(pair[0])):
+            normalized_key = normalize_text(str(key))
+            if not normalized_key:
+                raise ValueError("structured record contains an empty field name")
+            if normalized_key in normalized:
+                raise ValueError(
+                    f"structured record fields collide after normalization: {normalized_key}"
+                )
+            normalized[normalized_key] = _canonical_value(item)
+        return normalized
+    if isinstance(value, (list, tuple)):
+        return [_canonical_value(item) for item in value]
+    if isinstance(value, (set, frozenset)):
+        items = [_canonical_value(item) for item in value]
+        return sorted(
+            items,
+            key=lambda item: json.dumps(
+                item,
+                ensure_ascii=False,
+                sort_keys=True,
+                separators=(",", ":"),
+            ),
+        )
+    if isinstance(value, (bytes, bytearray, memoryview)):
+        return bytes(value).hex()
+    return normalize_text(str(value))
+
+
+def canonical_record_json(record: Mapping[str, Any]) -> str:
+    """生成与字段顺序无关、可用于比较和落库的 canonical JSON。"""
+
+    if not isinstance(record, Mapping):
+        raise TypeError("record must be a mapping")
+    return json.dumps(
+        _canonical_value(record),
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    )
+
+
+def _normalize_field_name(value: Any, style: str) -> str:
+    name = normalize_text(str(value))
+    if style == "preserve":
+        return name
+    if style == "lower":
+        return name.lower()
+    if style != "snake_case":
+        raise ValueError("field_name_style must be snake_case, lower or preserve")
+    name = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", "_", name)
+    name = re.sub(r"[^\w\u3400-\u4dbf\u4e00-\u9fff]+", "_", name, flags=re.UNICODE)
+    return re.sub(r"_+", "_", name).strip("_").lower()
+
+
+def normalize_structured_record(
+    record: Mapping[str, Any],
+    *,
+    field_name_style: str = "snake_case",
+) -> dict[str, Any]:
+    """规范字段名、Unicode/空白、容器类型和不可 JSON 化的标量。"""
+
+    if not isinstance(record, Mapping):
+        raise TypeError("record must be a mapping")
+    normalized: dict[str, Any] = {}
+    for key, value in record.items():
+        normalized_key = _normalize_field_name(key, field_name_style)
+        if not normalized_key:
+            raise ValueError("structured record contains an empty field name")
+        if normalized_key in normalized:
+            raise ValueError(
+                f"structured record fields collide after normalization: {normalized_key}"
+            )
+        normalized[normalized_key] = _canonical_value(value)
+    return dict(sorted(normalized.items()))
+
+
+def _embedded_structure(value: Any) -> Any:
+    if not isinstance(value, str):
+        return value
+    candidate = value.strip()
+    if not candidate or candidate[0] not in "[{":
+        return value
+    try:
+        parsed = json.loads(candidate)
+    except json.JSONDecodeError:
+        return value
+    return parsed if isinstance(parsed, (Mapping, list)) else value
+
+
+def flatten_structured_record(
+    record: Mapping[str, Any],
+    *,
+    separator: str = ".",
+) -> dict[str, Any]:
+    """把嵌套对象展平；数组保留为 canonical JSON 兼容值。"""
+
+    if not isinstance(record, Mapping):
+        raise TypeError("record must be a mapping")
+    if not separator:
+        raise ValueError("separator cannot be empty")
+    flattened: dict[str, Any] = {}
+
+    def visit(value: Any, path: tuple[str, ...], depth: int) -> None:
+        if depth > _MAX_STRUCTURED_DEPTH:
+            raise ValueError(
+                f"structured record nesting exceeds {_MAX_STRUCTURED_DEPTH} levels"
+            )
+        value = _embedded_structure(value)
+        if isinstance(value, Mapping):
+            if not value and path:
+                key = separator.join(path)
+                flattened[key] = {}
+                return
+            for child_key, child_value in value.items():
+                normalized_key = normalize_text(str(child_key))
+                if not normalized_key:
+                    raise ValueError("structured record contains an empty field name")
+                visit(child_value, (*path, normalized_key), depth + 1)
+            return
+        key = separator.join(path)
+        if key in flattened:
+            raise ValueError(f"structured record fields collide while flattening: {key}")
+        flattened[key] = _canonical_value(value)
+        if len(flattened) > _MAX_STRUCTURED_FIELDS:
+            raise ValueError(
+                f"structured record exceeds {_MAX_STRUCTURED_FIELDS} flattened fields"
+            )
+
+    for field, value in record.items():
+        field_name = normalize_text(str(field))
+        if not field_name:
+            raise ValueError("structured record contains an empty field name")
+        visit(value, (field_name,), 1)
+    return flattened
+
+
+def _clean_invalid_structured_records(
+    records: Sequence[Mapping[str, Any]],
+) -> list[dict[str, Any]]:
+    if not records:
+        return []
+    fields: list[str] = []
+    for record in records:
+        for field in record:
+            if field not in fields:
+                fields.append(field)
+    active_fields = [
+        field
+        for field in fields
+        if any(not _is_empty_value(record.get(field)) for record in records)
+    ]
+    if not active_fields:
+        return []
+    identity_fields = [
+        field
+        for field in active_fields
+        if _IDENTITY_FIELD_PATTERN.search(_normalize_field_name(field, "snake_case"))
+    ]
+    cleaned: list[dict[str, Any]] = []
+    for record in records:
+        values = {field: deepcopy(record.get(field)) for field in active_fields}
+        # 空记录一定无效；存在身份字段时只把身份字段缺失视作“残缺行”，
+        # 避免因为备注等可选列为空而误删有效业务数据。
+        if all(_is_empty_value(value) for value in values.values()):
+            continue
+        if identity_fields and any(_is_empty_value(values[field]) for field in identity_fields):
+            continue
+        cleaned.append(values)
+    return cleaned
+
+
+def _percentile(values: Sequence[float], fraction: float) -> float:
+    if not values:
+        raise ValueError("cannot calculate a percentile of an empty sequence")
+    ordered = sorted(values)
+    position = (len(ordered) - 1) * fraction
+    lower = math.floor(position)
+    upper = math.ceil(position)
+    if lower == upper:
+        return ordered[lower]
+    weight = position - lower
+    return ordered[lower] * (1 - weight) + ordered[upper] * weight
+
+
+def content_quality_flags(
+    text: str,
+    *,
+    min_chars: int = 20,
+    min_tokens: int = 5,
+    max_chars: int = _MAX_ANOMALY_TEXT_CHARS,
+) -> tuple[str, ...]:
+    """返回非结构化内容的确定性低质量原因。"""
+
+    if min_chars < 0 or min_tokens < 0 or max_chars <= 0:
+        raise ValueError("content quality limits must be non-negative")
+    normalized = normalize_text(text)
+    if not normalized:
+        return ("empty_content",)
+    flags: list[str] = []
+    if len(normalized) < min_chars or estimate_token_count(normalized) < min_tokens:
+        flags.append("content_too_short")
+    if len(normalized) > max_chars:
+        flags.append("content_too_long")
+    if any(marker in normalized for marker in _MOJIBAKE_MARKERS):
+        flags.append("mojibake")
+    nonspace = [char for char in normalized if not char.isspace()]
+    if nonspace:
+        readable_ratio = sum(
+            char.isprintable()
+            and unicodedata.category(char) not in {"Co", "Cs", "Cn"}
+            for char in nonspace
+        ) / len(nonspace)
+        if readable_ratio < 0.85:
+            flags.append("low_printable_ratio")
+        if len(nonspace) >= 100:
+            most_common = Counter(nonspace).most_common(1)[0][1]
+            if most_common / len(nonspace) > 0.9:
+                flags.append("repetitive_content")
+    return tuple(dict.fromkeys(flags))
+
+
+def is_low_quality_content(
+    text: str,
+    *,
+    min_chars: int = 20,
+    min_tokens: int = 5,
+    max_chars: int = _MAX_ANOMALY_TEXT_CHARS,
+) -> bool:
+    """判断内容是否命中任一低质量规则。"""
+
+    return bool(
+        content_quality_flags(
+            text,
+            min_chars=min_chars,
+            min_tokens=min_tokens,
+            max_chars=max_chars,
+        )
+    )
+
+
+def filter_anomalous_structured_records(
+    records: Sequence[Mapping[str, Any]],
+    *,
+    iqr_multiplier: float = 1.5,
+) -> list[dict[str, Any]]:
+    """按字段级数值 IQR、乱码和极端文本长度过滤异常记录。"""
+
+    if iqr_multiplier <= 0:
+        raise ValueError("iqr_multiplier must be greater than 0")
+    numeric_values: dict[str, list[float]] = {}
+    text_lengths: dict[str, list[float]] = {}
+    for record in records:
+        for field, value in record.items():
+            if (
+                isinstance(value, (int, float))
+                and not isinstance(value, bool)
+                and not _IDENTITY_FIELD_PATTERN.search(
+                    _normalize_field_name(field, "snake_case")
+                )
+            ):
+                number = float(value)
+                if math.isfinite(number):
+                    numeric_values.setdefault(field, []).append(number)
+            elif isinstance(value, str) and value:
+                text_lengths.setdefault(field, []).append(float(len(value)))
+
+    numeric_bounds: dict[str, tuple[float, float]] = {}
+    for field, values in numeric_values.items():
+        # 小样本不做统计异常判断，避免把合法长尾值误删。
+        if len(values) < 8:
+            continue
+        first_quartile = _percentile(values, 0.25)
+        third_quartile = _percentile(values, 0.75)
+        spread = third_quartile - first_quartile
+        numeric_bounds[field] = (
+            first_quartile - iqr_multiplier * spread,
+            third_quartile + iqr_multiplier * spread,
+        )
+
+    text_upper_bounds: dict[str, float] = {}
+    for field, lengths in text_lengths.items():
+        if len(lengths) < 8:
+            continue
+        first_quartile = _percentile(lengths, 0.25)
+        third_quartile = _percentile(lengths, 0.75)
+        spread = third_quartile - first_quartile
+        text_upper_bounds[field] = max(512.0, third_quartile + 3 * spread)
+
+    accepted: list[dict[str, Any]] = []
+    for record in records:
+        anomalous = False
+        for field, value in record.items():
+            if (
+                isinstance(value, (int, float))
+                and not isinstance(value, bool)
+                and not _IDENTITY_FIELD_PATTERN.search(
+                    _normalize_field_name(field, "snake_case")
+                )
+            ):
+                number = float(value)
+                if not math.isfinite(number):
+                    anomalous = True
+                    break
+                bounds = numeric_bounds.get(field)
+                if bounds and not bounds[0] <= number <= bounds[1]:
+                    anomalous = True
+                    break
+            if isinstance(value, str):
+                flags = content_quality_flags(value, min_chars=0, min_tokens=0)
+                if {"content_too_long", "mojibake", "low_printable_ratio"} & set(flags):
+                    anomalous = True
+                    break
+                upper_bound = text_upper_bounds.get(field)
+                if upper_bound is not None and len(value) > upper_bound:
+                    anomalous = True
+                    break
+        if not anomalous:
+            accepted.append(deepcopy(dict(record)))
+    return accepted
+
+
+def _identity_tokens(record: Mapping[str, Any]) -> set[tuple[str, str]]:
+    tokens: set[tuple[str, str]] = set()
+    for field, value in record.items():
+        normalized_field = _normalize_field_name(field, "snake_case")
+        if not _IDENTITY_FIELD_PATTERN.search(normalized_field) or _is_empty_value(value):
+            continue
+        tokens.add(
+            (
+                normalized_field,
+                json.dumps(
+                    _canonical_value(value),
+                    ensure_ascii=False,
+                    sort_keys=True,
+                    separators=(",", ":"),
+                ),
+            )
+        )
+    return tokens
+
+
+def deduplicate_structured_records(
+    records: Sequence[Mapping[str, Any]],
+) -> list[dict[str, Any]]:
+    """按整条 canonical JSON 和 id/uuid/key/code/*_id 字段稳定去重。"""
+
+    exact_seen: set[str] = set()
+    identity_seen: set[tuple[str, str]] = set()
+    unique: list[dict[str, Any]] = []
+    for record in records:
+        fingerprint = hashlib.sha256(canonical_record_json(record).encode("utf-8")).hexdigest()
+        identities = _identity_tokens(record)
+        if fingerprint in exact_seen or identities & identity_seen:
+            continue
+        exact_seen.add(fingerprint)
+        identity_seen.update(identities)
+        unique.append(deepcopy(dict(record)))
+    return unique
+
+
+def _is_name_field(field: Any) -> bool:
+    normalized = _normalize_field_name(field, "snake_case")
+    if normalized in _NAME_FIELD_NAMES:
+        return True
+    suffixes = ("_name", "_full_name", "_姓名", "_真实姓名", "_联系人", "_联系人姓名")
+    return normalized.endswith(suffixes)
+
+
+def desensitize_structured_record(
+    record: Mapping[str, Any],
+) -> tuple[dict[str, Any], dict[str, int]]:
+    """递归脱敏结构化姓名字段及任意文本中的手机号、邮箱、身份证号。"""
+
+    if not isinstance(record, Mapping):
+        raise TypeError("record must be a mapping")
+    counts: dict[str, int] = {"email": 0, "phone": 0, "id_card": 0}
+
+    def add_counts(values: Mapping[str, int]) -> None:
+        for kind, count in values.items():
+            if kind != "total" and count:
+                counts[kind] = counts.get(kind, 0) + count
+
+    def visit(value: Any, field: Any = "") -> Any:
+        if isinstance(value, Mapping):
+            return {key: visit(item, key) for key, item in value.items()}
+        if isinstance(value, list):
+            return [visit(item, field) for item in value]
+        if isinstance(value, tuple):
+            return [visit(item, field) for item in value]
+        if _is_name_field(field) and not _is_empty_value(value):
+            counts["name"] = counts.get("name", 0) + 1
+            return "[NAME]"
+        if isinstance(value, str):
+            masked, found = desensitize_pii(value)
+            add_counts(found)
+            return masked
+        return deepcopy(value)
+
+    masked = {key: visit(value, key) for key, value in record.items()}
+    counts["total"] = sum(counts.values())
+    return masked, counts
+
+
+def _structured_options(options: Iterable[str] | Mapping[str, Any]) -> set[str]:
+    if isinstance(options, str):
+        raise TypeError("options must be an iterable or mapping of option names")
+    if isinstance(options, Mapping):
+        enabled = {str(key) for key, value in options.items() if bool(value)}
+    else:
+        enabled = {str(option) for option in options}
+    unknown = enabled - _STRUCTURED_OPTIONS
+    if unknown:
+        raise ValueError(f"unsupported structured preprocess options: {', '.join(sorted(unknown))}")
+    return enabled
+
+
+def preprocess_structured_records(
+    records: Iterable[Mapping[str, Any]],
+    options: Iterable[str] | Mapping[str, Any],
+) -> list[dict[str, Any]]:
+    """按界面选项执行确定性、无副作用的结构化数据预处理。"""
+
+    enabled = _structured_options(options)
+    current: list[dict[str, Any]] = []
+    for record in records:
+        if not isinstance(record, Mapping):
+            if "clean_invalid" in enabled:
+                continue
+            raise TypeError("structured records must contain mappings")
+        value = deepcopy(dict(record))
+        if "detect_structure" in enabled:
+            value = flatten_structured_record(value)
+        if "normalize_format" in enabled:
+            value = normalize_structured_record(value)
+        current.append(value)
+
+    if "clean_invalid" in enabled:
+        current = _clean_invalid_structured_records(current)
+    if "filter_anomaly" in enabled:
+        current = filter_anomalous_structured_records(current)
+    if "deduplicate" in enabled:
+        current = deduplicate_structured_records(current)
+    if "desensitize" in enabled:
+        current = [desensitize_structured_record(record)[0] for record in current]
+    return current
+
+
 def estimate_token_count(text: str) -> int:
     """无分词器依赖的确定性 token 估算，用于预览与保护性限流。"""
 
@@ -340,6 +1736,27 @@ def _token_spans(text: str) -> list[tuple[int, int]]:
     return [match.span() for match in _TOKEN_PATTERN.finditer(text)]
 
 
+def _deterministic_tokenizer(text: str) -> list[str]:
+    """LlamaIndex splitter 使用的稳定 tokenizer，与预览 token 计数完全一致。"""
+
+    return _TOKEN_PATTERN.findall(text)
+
+
+def _sentence_chunks(text: str) -> list[str]:
+    """按项目既有中英文句界切句，避免 SentenceSplitter 触发 NLTK 下载。"""
+
+    chunks: list[str] = []
+    cursor = 0
+    for match in _SEMANTIC_BOUNDARY_PATTERN.finditer(text):
+        end = match.end()
+        if end > cursor:
+            chunks.append(text[cursor:end])
+        cursor = end
+    if cursor < len(text):
+        chunks.append(text[cursor:])
+    return chunks or [text]
+
+
 def _line_number(newline_offsets: list[int], offset: int) -> int:
     # 换行符本身仍属于上一行；只有严格位于 offset 之前的换行才推进行号。
     return bisect_left(newline_offsets, offset) + 1
@@ -456,6 +1873,334 @@ def _range_containing(
     return next((item for item in ranges if item[0] < offset < item[1]), None)
 
 
+def protected_context_ranges(
+    text: str,
+    *,
+    preserve_code_blocks: bool = True,
+    preserve_tables: bool = True,
+    preserve_lists: bool = True,
+) -> tuple[tuple[int, int], ...]:
+    """返回代码块、表格和列表的不可拆分区间。
+
+    返回的偏移量基于规范化后的文本；调用方应在同一份 ``normalize_text``
+    结果上使用这些区间。
+    """
+
+    normalized = normalize_text(text)
+    return tuple(
+        _protected_markdown_ranges(
+            normalized,
+            preserve_code_blocks=preserve_code_blocks,
+            preserve_tables=preserve_tables,
+            preserve_lists=preserve_lists,
+        )
+    )
+
+
+def expand_to_context_boundaries(
+    text: str,
+    start: int,
+    end: int,
+    *,
+    preserve_paragraph: bool = True,
+    preserve_code_blocks: bool = True,
+    preserve_tables: bool = True,
+    preserve_lists: bool = True,
+) -> tuple[int, int]:
+    """将一个文本区间扩展到段落及受保护 Markdown 结构边界。"""
+
+    normalized = normalize_text(text)
+    if isinstance(start, bool) or isinstance(end, bool):
+        raise TypeError("start and end must be integers")
+    if not isinstance(start, int) or not isinstance(end, int):
+        raise TypeError("start and end must be integers")
+    if not 0 <= start <= end <= len(normalized):
+        raise ValueError("start and end must define a valid normalized text range")
+
+    expanded_start = start
+    expanded_end = end
+    if preserve_paragraph and normalized:
+        paragraph_start = normalized.rfind("\n\n", 0, start)
+        expanded_start = 0 if paragraph_start < 0 else paragraph_start + 2
+        paragraph_end = normalized.find("\n\n", end)
+        expanded_end = len(normalized) if paragraph_end < 0 else paragraph_end
+
+    ranges = protected_context_ranges(
+        normalized,
+        preserve_code_blocks=preserve_code_blocks,
+        preserve_tables=preserve_tables,
+        preserve_lists=preserve_lists,
+    )
+    changed = True
+    while changed:
+        changed = False
+        for range_start, range_end in ranges:
+            overlaps = range_start < expanded_end and range_end > expanded_start
+            contains_boundary = (
+                range_start <= expanded_start < range_end
+                or range_start < expanded_end <= range_end
+            )
+            if not overlaps and not contains_boundary:
+                continue
+            next_start = min(expanded_start, range_start)
+            next_end = max(expanded_end, range_end)
+            if (next_start, next_end) != (expanded_start, expanded_end):
+                expanded_start, expanded_end = next_start, next_end
+                changed = True
+    return expanded_start, expanded_end
+
+
+def detect_document_structure(text: str) -> DocumentStructure:
+    """识别 Markdown、中文章节和数字编号标题及不可拆分块。"""
+
+    normalized = normalize_text(text)
+    if not normalized:
+        return DocumentStructure(
+            line_count=0,
+            paragraph_count=0,
+            headings=(),
+            code_block_count=0,
+            table_block_count=0,
+            list_block_count=0,
+        )
+
+    code_ranges = protected_context_ranges(
+        normalized,
+        preserve_code_blocks=True,
+        preserve_tables=False,
+        preserve_lists=False,
+    )
+    table_candidates = protected_context_ranges(
+        normalized,
+        preserve_code_blocks=False,
+        preserve_tables=True,
+        preserve_lists=False,
+    )
+    list_candidates = protected_context_ranges(
+        normalized,
+        preserve_code_blocks=False,
+        preserve_tables=False,
+        preserve_lists=True,
+    )
+    table_ranges = tuple(
+        item
+        for item in table_candidates
+        if not any(
+            item[0] < code_end and item[1] > code_start
+            for code_start, code_end in code_ranges
+        )
+    )
+    list_ranges = tuple(
+        item
+        for item in list_candidates
+        if not any(
+            item[0] < code_end and item[1] > code_start
+            for code_start, code_end in code_ranges
+        )
+    )
+    markdown_heading = re.compile(r"^\s*(?P<marks>#{1,6})\s+(?P<title>.+?)\s*#*\s*$")
+    chinese_heading = re.compile(
+        r"^\s*(?P<title>第[一二三四五六七八九十百千万0-9]+[章节篇部分].*)$"
+    )
+    numbered_heading = re.compile(
+        r"^\s*(?P<number>\d+(?:\.\d+)*)(?:[、.]|\s+)\s*(?P<title>\S.*)$"
+    )
+
+    headings: list[DocumentHeading] = []
+    cursor = 0
+    for line_number, raw_line in enumerate(normalized.splitlines(keepends=True), start=1):
+        line = raw_line.rstrip("\n")
+        line_end = cursor + len(line)
+        if not any(range_start <= cursor < range_end for range_start, range_end in code_ranges):
+            match = markdown_heading.match(line)
+            if match:
+                headings.append(
+                    DocumentHeading(
+                        level=len(match.group("marks")),
+                        title=normalize_text(match.group("title")),
+                        line_number=line_number,
+                        start=cursor,
+                        end=line_end,
+                    )
+                )
+            else:
+                match = chinese_heading.match(line)
+                if match:
+                    headings.append(
+                        DocumentHeading(
+                            level=1,
+                            title=normalize_text(match.group("title")),
+                            line_number=line_number,
+                            start=cursor,
+                            end=line_end,
+                        )
+                    )
+                else:
+                    match = numbered_heading.match(line)
+                    if match:
+                        headings.append(
+                            DocumentHeading(
+                                level=min(6, match.group("number").count(".") + 1),
+                                title=normalize_text(match.group("title")),
+                                line_number=line_number,
+                                start=cursor,
+                                end=line_end,
+                            )
+                        )
+        cursor += len(raw_line)
+
+    paragraphs = [part for part in re.split(r"\n\s*\n", normalized) if part.strip()]
+    return DocumentStructure(
+        line_count=len(normalized.splitlines()),
+        paragraph_count=len(paragraphs),
+        headings=tuple(headings),
+        code_block_count=len(code_ranges),
+        table_block_count=len(table_ranges),
+        list_block_count=len(list_ranges),
+    )
+
+
+def merge_short_blocks(
+    blocks: Iterable[str],
+    *,
+    min_token_count: int = 100,
+    separator: str = "\n\n",
+) -> list[str]:
+    """按原顺序合并短内容块，并把末尾残块归入前一块。"""
+
+    if isinstance(min_token_count, bool) or not isinstance(min_token_count, int):
+        raise TypeError("min_token_count must be an integer")
+    if min_token_count <= 0:
+        raise ValueError("min_token_count must be greater than 0")
+    if not isinstance(separator, str):
+        raise TypeError("separator must be str")
+
+    merged: list[str] = []
+    pending: list[str] = []
+    pending_tokens = 0
+    for block in blocks:
+        if not isinstance(block, str):
+            raise TypeError("blocks must contain strings")
+        normalized = normalize_text(block)
+        if not normalized:
+            continue
+        token_count = estimate_token_count(normalized)
+        if not pending and token_count >= min_token_count:
+            merged.append(normalized)
+            continue
+        pending.append(normalized)
+        pending_tokens += token_count
+        if pending_tokens >= min_token_count:
+            merged.append(separator.join(pending))
+            pending = []
+            pending_tokens = 0
+
+    if pending:
+        tail = separator.join(pending)
+        if merged:
+            merged[-1] = separator.join((merged[-1], tail))
+        else:
+            merged.append(tail)
+    return merged
+
+
+def _near_duplicate_features(text: str, shingle_size: int) -> tuple[str, ...]:
+    if isinstance(shingle_size, bool) or not isinstance(shingle_size, int):
+        raise TypeError("shingle_size must be an integer")
+    if shingle_size <= 0:
+        raise ValueError("shingle_size must be greater than 0")
+    tokens = re.findall(
+        r"[\u3400-\u4dbf\u4e00-\u9fff]|[A-Za-z0-9_]+",
+        normalize_text(text).casefold(),
+    )
+    if not tokens:
+        return ()
+    if len(tokens) < shingle_size:
+        return ("\x1f".join(tokens),)
+    return tuple(
+        "\x1f".join(tokens[index : index + shingle_size])
+        for index in range(len(tokens) - shingle_size + 1)
+    )
+
+
+def near_duplicate_fingerprint(text: str, *, shingle_size: int = 3) -> str:
+    """生成 64 位 SimHash 指纹，用于低成本近重复候选筛选。"""
+
+    if isinstance(shingle_size, bool) or not isinstance(shingle_size, int):
+        raise TypeError("shingle_size must be an integer")
+    if shingle_size <= 0:
+        raise ValueError("shingle_size must be greater than 0")
+    features = Counter(_near_duplicate_features(text, shingle_size))
+    if not features:
+        return "0" * 16
+    vector = [0] * 64
+    for feature, weight in features.items():
+        digest = int.from_bytes(hashlib.sha256(feature.encode("utf-8")).digest()[:8], "big")
+        for bit in range(64):
+            vector[bit] += weight if digest & (1 << bit) else -weight
+    fingerprint = sum(1 << bit for bit, value in enumerate(vector) if value >= 0)
+    return f"{fingerprint:016x}"
+
+
+def fingerprints_are_near_duplicate(
+    left: str,
+    right: str,
+    *,
+    max_hamming_distance: int = 3,
+) -> bool:
+    """比较两个 64 位十六进制 SimHash 指纹。"""
+
+    if isinstance(max_hamming_distance, bool) or not isinstance(max_hamming_distance, int):
+        raise TypeError("max_hamming_distance must be an integer")
+    if not 0 <= max_hamming_distance <= 64:
+        raise ValueError("max_hamming_distance must be in [0, 64]")
+    if not re.fullmatch(r"[0-9a-fA-F]{16}", left) or not re.fullmatch(
+        r"[0-9a-fA-F]{16}", right
+    ):
+        raise ValueError("fingerprints must be 16-character hexadecimal strings")
+    distance = (int(left, 16) ^ int(right, 16)).bit_count()
+    return distance <= max_hamming_distance
+
+
+def is_near_duplicate(
+    left: str,
+    right: str,
+    *,
+    shingle_size: int = 3,
+    similarity_threshold: float = 0.9,
+    max_hamming_distance: int = 3,
+) -> bool:
+    """结合词片 Jaccard 和 SimHash 判断两段内容是否近重复。"""
+
+    if isinstance(similarity_threshold, bool) or not isinstance(
+        similarity_threshold, (int, float)
+    ):
+        raise TypeError("similarity_threshold must be a number")
+    if not 0 <= similarity_threshold <= 1:
+        raise ValueError("similarity_threshold must be in [0, 1]")
+    if isinstance(max_hamming_distance, bool) or not isinstance(max_hamming_distance, int):
+        raise TypeError("max_hamming_distance must be an integer")
+    if not 0 <= max_hamming_distance <= 64:
+        raise ValueError("max_hamming_distance must be in [0, 64]")
+    left_normalized = normalize_text(left)
+    right_normalized = normalize_text(right)
+    if not left_normalized or not right_normalized:
+        return left_normalized == right_normalized
+    if left_normalized.casefold() == right_normalized.casefold():
+        return True
+    left_features = set(_near_duplicate_features(left_normalized, shingle_size))
+    right_features = set(_near_duplicate_features(right_normalized, shingle_size))
+    union = left_features | right_features
+    similarity = len(left_features & right_features) / len(union) if union else 1.0
+    if similarity >= similarity_threshold:
+        return True
+    return fingerprints_are_near_duplicate(
+        near_duplicate_fingerprint(left_normalized, shingle_size=shingle_size),
+        near_duplicate_fingerprint(right_normalized, shingle_size=shingle_size),
+        max_hamming_distance=max_hamming_distance,
+    )
+
+
 def _boundary_for_method(
     text: str,
     spans: list[tuple[int, int]],
@@ -464,15 +2209,31 @@ def _boundary_for_method(
     minimum_end_index: int,
     method: ChunkMethod,
     custom_delimiter: str,
+    splitter: SentenceSplitter | TokenTextSplitter | None,
 ) -> tuple[int, int | None]:
-    if method == "fixed":
-        return ideal_end_index, None
+    if method == "fixed" and not isinstance(splitter, TokenTextSplitter):
+        raise RuntimeError("fixed chunking requires TokenTextSplitter")
 
     start_offset = spans[start_index][0]
     ideal_end_offset = spans[ideal_end_index - 1][1]
     minimum_end_offset = spans[minimum_end_index - 1][1]
     search_text = text[start_offset:ideal_end_offset]
 
+    if method == "fixed":
+        # 直接让 TokenTextSplitter 处理真实文本；开启空白保留后将首块边界
+        # 投影回稳定 token span，offset 和实际 overlap 仍由外层统一维护。
+        lookahead_end = min(len(spans), ideal_end_index + 1)
+        window_end = spans[lookahead_end - 1][1]
+        window = text[start_offset:window_end]
+        chunks = splitter.split_text(window)
+        first_chunk = chunks[0] if chunks else ""
+        if first_chunk and window.startswith(first_chunk):
+            boundary_offset = start_offset + len(first_chunk)
+            boundary_index = _token_index_at_or_after(spans, boundary_offset)
+            if boundary_index > start_index:
+                return min(boundary_index, ideal_end_index), boundary_offset
+        return ideal_end_index, None
+
     if method == "custom":
         delimiter = custom_delimiter.replace("\\n", "\n").replace("\\t", "\t")
         if not delimiter:
@@ -486,35 +2247,29 @@ def _boundary_for_method(
                 return min(boundary_index, ideal_end_index), boundary_offset
         return ideal_end_index, None
 
-    if method == "heading":
-        heading_offsets = [
-            start_offset + match.start()
-            for match in _HEADING_PATTERN.finditer(search_text)
-            if start_offset + match.start() >= minimum_end_offset
-        ]
-        if heading_offsets:
-            boundary_offset = heading_offsets[-1]
-            boundary_index = _token_index_at_or_after(spans, boundary_offset)
-            if start_index < boundary_index <= ideal_end_index:
-                return boundary_index, boundary_offset
-
-    semantic_boundaries = [
-        start_offset + match.end()
-        for match in _SEMANTIC_BOUNDARY_PATTERN.finditer(search_text)
-        if start_offset + match.end() >= minimum_end_offset
-    ]
-    if semantic_boundaries:
-        boundary_offset = semantic_boundaries[-1]
+    if method == "structure":
+        if not isinstance(splitter, SentenceSplitter):
+            raise RuntimeError("structure chunking requires SentenceSplitter")
+        # 多给一个 token 使 splitter 确实执行限长；只取首块并投影回原文。
+        lookahead_end = min(len(spans), ideal_end_index + 1)
+        window_end = spans[lookahead_end - 1][1]
+        window = text[start_offset:window_end]
+        chunks = splitter.split_text(window)
+        first_chunk = chunks[0] if chunks else ""
+        if first_chunk and window.startswith(first_chunk):
+            boundary_offset = start_offset + len(first_chunk)
+        else:
+            boundary_offset = ideal_end_offset
         boundary_index = _token_index_at_or_after(spans, boundary_offset)
-        if boundary_index > start_index:
+        if boundary_index >= minimum_end_index:
             return min(boundary_index, ideal_end_index), boundary_offset
     return ideal_end_index, None
 
 
-def chunk_unstructured(
-    text: str,
+def _chunk_normalized_text(
+    normalized: str,
     *,
-    method: ChunkMethod = "semantic",
+    method: ChunkMethod,
     chunk_size: int = 800,
     chunk_overlap: int = 100,
     min_chunk_size: int = 100,
@@ -523,26 +2278,6 @@ def chunk_unstructured(
     preserve_tables: bool = False,
     preserve_lists: bool = False,
 ) -> list[TextChunk]:
-    """按估算 token 切分非结构化文本。
-
-    overlap 足够时精确保留配置数量；短边界下会自动收缩，并且每轮至少推进
-    一个 token，避免异常配置或分隔符造成死循环。
-    """
-
-    if method not in {"semantic", "heading", "fixed", "custom"}:
-        raise ValueError(f"unsupported chunk method: {method}")
-    if chunk_size <= 0:
-        raise ValueError("chunk_size must be greater than 0")
-    if chunk_overlap < 0 or chunk_overlap >= chunk_size:
-        raise ValueError("chunk_overlap must be in [0, chunk_size)")
-    if min_chunk_size <= 0 or min_chunk_size > chunk_size:
-        raise ValueError("min_chunk_size must be in [1, chunk_size]")
-    if chunk_overlap + min_chunk_size > chunk_size:
-        raise ValueError("chunk_overlap + min_chunk_size cannot exceed chunk_size")
-    if method == "custom" and not custom_delimiter:
-        raise ValueError("custom_delimiter is required for custom chunking")
-
-    normalized = normalize_text(text)
     if not normalized:
         return []
     spans = _token_spans(normalized)
@@ -556,6 +2291,29 @@ def chunk_unstructured(
         preserve_tables=preserve_tables,
         preserve_lists=preserve_lists,
     )
+    splitter: SentenceSplitter | TokenTextSplitter | None
+    if method == "fixed":
+        splitter = TokenTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            tokenizer=_deterministic_tokenizer,
+            separator=" ",
+            backup_separators=["\n"],
+            keep_whitespaces=True,
+            include_metadata=False,
+            include_prev_next_rel=False,
+        )
+    elif method == "structure":
+        splitter = SentenceSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            tokenizer=_deterministic_tokenizer,
+            chunking_tokenizer_fn=_sentence_chunks,
+            include_metadata=False,
+            include_prev_next_rel=False,
+        )
+    else:
+        splitter = None
     chunks: list[TextChunk] = []
     start_index = 0
 
@@ -573,6 +2331,7 @@ def chunk_unstructured(
                 minimum_end_index,
                 method,
                 custom_delimiter,
+                splitter,
             )
         if end_index <= start_index:
             end_index = min(len(spans), start_index + chunk_size)
@@ -619,6 +2378,92 @@ def chunk_unstructured(
     return chunks
 
 
+def _structure_sections(text: str) -> list[tuple[int, int]]:
+    structure = detect_document_structure(text)
+    if not structure.headings:
+        return [(0, len(text))]
+
+    sections: list[tuple[int, int]] = []
+    first_start = structure.headings[0].start
+    if first_start > 0:
+        sections.append((0, first_start))
+    sections.extend(
+        (
+            heading.start,
+            structure.headings[index + 1].start
+            if index + 1 < len(structure.headings)
+            else len(text),
+        )
+        for index, heading in enumerate(structure.headings)
+    )
+    return sections
+
+
+def chunk_unstructured(
+    text: str,
+    *,
+    method: ChunkMethod = "structure",
+    chunk_size: int = 800,
+    chunk_overlap: int = 100,
+    min_chunk_size: int = 100,
+    custom_delimiter: str = "",
+    preserve_code_blocks: bool = False,
+    preserve_tables: bool = False,
+    preserve_lists: bool = False,
+) -> list[TextChunk]:
+    """按确定性 token 切分，并保留规范化原文的 offset、行号和实际 overlap。"""
+
+    if method not in {"structure", "fixed", "custom"}:
+        raise ValueError(f"unsupported chunk method: {method}")
+    if chunk_size <= 0:
+        raise ValueError("chunk_size must be greater than 0")
+    if chunk_overlap < 0 or chunk_overlap >= chunk_size:
+        raise ValueError("chunk_overlap must be in [0, chunk_size)")
+    if min_chunk_size <= 0 or min_chunk_size > chunk_size:
+        raise ValueError("min_chunk_size must be in [1, chunk_size]")
+    if chunk_overlap + min_chunk_size > chunk_size:
+        raise ValueError("chunk_overlap + min_chunk_size cannot exceed chunk_size")
+    if method == "custom" and not custom_delimiter:
+        raise ValueError("custom_delimiter is required for custom chunking")
+
+    normalized = normalize_text(text)
+    if not normalized:
+        return []
+    section_ranges = (
+        _structure_sections(normalized)
+        if method == "structure"
+        else [(0, len(normalized))]
+    )
+    newline_offsets = [index for index, char in enumerate(normalized) if char == "\n"]
+    chunks: list[TextChunk] = []
+    for section_start, section_end in section_ranges:
+        section = normalized[section_start:section_end]
+        for chunk in _chunk_normalized_text(
+            section,
+            method=method,
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            min_chunk_size=min_chunk_size,
+            custom_delimiter=custom_delimiter,
+            preserve_code_blocks=preserve_code_blocks,
+            preserve_tables=preserve_tables,
+            preserve_lists=preserve_lists,
+        ):
+            start = section_start + chunk.start
+            end = section_start + chunk.end
+            chunks.append(
+                TextChunk(
+                    content=normalized[start:end],
+                    start=start,
+                    end=end,
+                    start_line=_line_number(newline_offsets, start),
+                    end_line=_line_number(newline_offsets, max(start, end - 1)),
+                    token_count=chunk.token_count,
+                )
+            )
+    return chunks
+
+
 def record_fingerprint(record: Mapping[str, Any]) -> str:
     """计算与字典键顺序无关的稳定记录指纹。"""
 
@@ -891,21 +2736,42 @@ def generate_standard_records(
 __all__ = [
     "ChunkMethod",
     "DatasetSplit",
+    "DocumentHeading",
+    "DocumentStructure",
     "ParsedText",
+    "PdfPageText",
     "QualityScore",
     "SUPPORTED_TEXT_FORMATS",
+    "StructuredPreprocessOption",
     "TextChunk",
     "TextFormat",
+    "canonical_record_json",
     "chunk_unstructured",
+    "content_quality_flags",
     "decode_utf8",
     "desensitize_pii",
+    "desensitize_structured_record",
+    "detect_document_structure",
     "detect_text_format",
+    "deduplicate_structured_records",
     "estimate_token_count",
+    "expand_to_context_boundaries",
+    "extract_pdf_page_texts",
     "extract_structured_records",
+    "filter_anomalous_structured_records",
+    "fingerprints_are_near_duplicate",
+    "flatten_structured_record",
     "generate_standard_records",
+    "is_low_quality_content",
+    "is_near_duplicate",
+    "merge_short_blocks",
+    "near_duplicate_fingerprint",
+    "normalize_structured_record",
     "normalize_text",
     "parse_text_content",
     "parse_utf8_text",
+    "preprocess_structured_records",
+    "protected_context_ranges",
     "record_fingerprint",
     "score_quality",
     "stable_split",
diff --git a/backend/app/modules/data_process/storage.py b/backend/app/modules/data_process/storage.py
new file mode 100644
index 0000000..b6051e3
--- /dev/null
+++ b/backend/app/modules/data_process/storage.py
@@ -0,0 +1,499 @@
+"""数据处理原始源文件的受控本地对象存储。"""
+
+from __future__ import annotations
+
+import os
+import re
+import stat
+import unicodedata
+import uuid
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path, PurePosixPath
+from typing import Iterable, Iterator
+from urllib.parse import quote, unquote, urlsplit
+
+
+class DataProcessStorageError(ValueError):
+    """本地对象引用或文件系统状态不安全。"""
+
+
+@dataclass(frozen=True, slots=True)
+class StagedSourceObject:
+    """尚未发布的原始文件；绝对路径仅在存储模块内部流转。"""
+
+    reference: str
+    _temporary_path: Path
+    _relative_path: PurePosixPath
+
+
+def _default_storage_root() -> Path:
+    return Path(__file__).resolve().parents[3] / "storage" / "data-process"
+
+
+def _configured_storage_root() -> Path:
+    configured = os.getenv("DATA_PROCESS_STORAGE_DIR", "").strip()
+    if not configured:
+        return _default_storage_root()
+    path = Path(configured).expanduser()
+    # 相对配置固定以 backend 目录为基准，
+    # 避免从不同 cwd 启动时写入不同位置。
+    return path if path.is_absolute() else Path(__file__).resolve().parents[3] / path
+
+
+def _safe_component(value: str, label: str) -> str:
+    if not value or value in {".", ".."} or len(value) > 128:
+        raise DataProcessStorageError(f"invalid {label}")
+    if not value[0].isalnum() or any(
+        not (character.isalnum() or character in {"-", "_", "."})
+        for character in value
+    ):
+        raise DataProcessStorageError(f"invalid {label}")
+    return value
+
+
+def _safe_basename(value: str) -> str:
+    if not value or len(value.encode("utf-8")) > 255:
+        raise DataProcessStorageError("invalid source file name")
+    if value != Path(value).name or "/" in value or "\\" in value or "\x00" in value:
+        raise DataProcessStorageError("invalid source file name")
+    if value in {".", ".."} or any(
+        unicodedata.category(character).startswith("C") for character in value
+    ):
+        raise DataProcessStorageError("invalid source file name")
+    return value
+
+
+class LocalDataProcessStorage:
+    """只允许访问配置根目录下的版本化原始文件。"""
+
+    def __init__(self, root: str | os.PathLike[str] | Path | None = None) -> None:
+        configured = Path(root) if root is not None else _configured_storage_root()
+        configured = configured.expanduser()
+        if configured.exists() and configured.is_symlink():
+            raise DataProcessStorageError("data process storage root must not be a symlink")
+        configured.mkdir(parents=True, exist_ok=True, mode=0o700)
+        self._root = configured.resolve(strict=True)
+        # StagedSourceObject 本身是普通 dataclass，不能只依赖其中的路径字段判断
+        # 来源；只接受由当前存储实例实际签发的对象，
+        # 避免调用方伪造暂存路径。
+        self._issued_staged_objects: dict[Path, StagedSourceObject] = {}
+        self._ensure_directory(self._root / ".staging")
+
+    @property
+    def root(self) -> Path:
+        """仅供运维和测试检查；API 响应不得序列化该属性。"""
+
+        return self._root
+
+    def new_batch_id(self) -> str:
+        return f"batch-{uuid.uuid4().hex}"
+
+    def stage_bytes(
+        self,
+        *,
+        batch_id: str,
+        task_id: str,
+        source_file_id: str,
+        version: int,
+        name: str,
+        content: bytes,
+    ) -> StagedSourceObject:
+        batch_id = _safe_component(batch_id, "batch id")
+        task_id = _safe_component(task_id, "task id")
+        source_file_id = _safe_component(source_file_id, "source file id")
+        if isinstance(version, bool) or not isinstance(version, int) or version < 1:
+            raise DataProcessStorageError("invalid source file version")
+        basename = _safe_basename(name)
+        if not isinstance(content, bytes):
+            raise TypeError("content must be bytes")
+
+        batch_directory = self._ensure_directory(self._root / ".staging" / batch_id)
+        temporary_path = batch_directory / f"{source_file_id}-{uuid.uuid4().hex}.tmp"
+        flags = os.O_CREAT | os.O_EXCL | os.O_WRONLY
+        if hasattr(os, "O_NOFOLLOW"):
+            flags |= os.O_NOFOLLOW
+        descriptor = os.open(temporary_path, flags, 0o600)
+        try:
+            with os.fdopen(descriptor, "wb", closefd=True) as stream:
+                stream.write(content)
+                stream.flush()
+                os.fsync(stream.fileno())
+        except Exception:
+            temporary_path.unlink(missing_ok=True)
+            raise
+
+        relative_path = PurePosixPath(
+            task_id,
+            source_file_id,
+            f"v{version}",
+            basename,
+        )
+        reference = (
+            "local://data-process/"
+            f"{task_id}/{source_file_id}/v{version}/{quote(basename, safe='')}"
+        )
+        staged = StagedSourceObject(reference, temporary_path, relative_path)
+        self._issued_staged_objects[temporary_path] = staged
+        return staged
+
+    def publish(self, objects: Iterable[StagedSourceObject]) -> None:
+        staged = list(objects)
+        published: list[StagedSourceObject] = []
+        try:
+            seen_temporary_paths: set[Path] = set()
+            for item in staged:
+                self._validate_staged_object(item, require_file=True)
+                if item._temporary_path in seen_temporary_paths:
+                    raise DataProcessStorageError("duplicate staged source object")
+                seen_temporary_paths.add(item._temporary_path)
+            for item in staged:
+                final_path = self._path_for_relative(item._relative_path)
+                self._ensure_directory(final_path.parent)
+                if final_path.exists() or final_path.is_symlink():
+                    raise DataProcessStorageError("source storage object already exists")
+                os.link(item._temporary_path, final_path, follow_symlinks=False)
+                published.append(item)
+                item._temporary_path.unlink()
+                self._fsync_directory(final_path.parent)
+        except Exception:
+            for item in reversed(published):
+                try:
+                    self.delete(item.reference)
+                except Exception:
+                    # 回滚必须尽量处理其余对象，并保留真正的发布异常。
+                    pass
+            for item in staged:
+                try:
+                    self.discard([item])
+                except Exception:
+                    pass
+            raise
+        self.discard(staged)
+
+    def discard(self, objects: Iterable[StagedSourceObject]) -> None:
+        staged = list(objects)
+        for item in staged:
+            self._validate_staged_object(item, require_file=False)
+
+        batch_directories: set[Path] = set()
+        first_error: Exception | None = None
+        for item in staged:
+            temporary_path = item._temporary_path
+            try:
+                temporary_path.unlink(missing_ok=True)
+            except Exception as exc:
+                if first_error is None:
+                    first_error = exc
+            else:
+                self._issued_staged_objects.pop(temporary_path, None)
+            batch_directories.add(temporary_path.parent)
+        for directory in batch_directories:
+            self._remove_empty_directory(directory)
+        if first_error is not None:
+            raise first_error
+
+    def read(self, reference: str) -> bytes | None:
+        """读取 local 引用；旧 ``db://`` 对象返回 ``None`` 由数据库正文兜底。"""
+
+        relative_path = self._relative_from_reference(reference)
+        if relative_path is None:
+            return None
+        descriptor, _ = self._open_read_descriptor(relative_path)
+        with os.fdopen(descriptor, "rb", closefd=True) as stream:
+            return stream.read()
+
+    def file_size(
+        self,
+        reference: str,
+        *,
+        expected_task_id: str,
+        expected_source_file_id: str,
+    ) -> int | None:
+        """返回受控 local 对象大小；旧 ``db://`` 对象没有原始文件。"""
+
+        relative_path = self._relative_from_reference(reference)
+        if relative_path is None:
+            return None
+        self._assert_expected_owner(
+            relative_path,
+            expected_task_id=expected_task_id,
+            expected_source_file_id=expected_source_file_id,
+        )
+        descriptor, info = self._open_read_descriptor(relative_path)
+        os.close(descriptor)
+        return info.st_size
+
+    def iter_bytes(
+        self,
+        reference: str,
+        *,
+        expected_task_id: str,
+        expected_source_file_id: str,
+        expected_size: int,
+        start: int = 0,
+        length: int | None = None,
+        chunk_size: int = 256 * 1024,
+    ) -> Iterator[bytes]:
+        """按范围流式读取原始文件，避免 PDF 预览把大文件整体载入内存。"""
+
+        relative_path = self._relative_from_reference(reference)
+        if relative_path is None:
+            raise DataProcessStorageError("original source object is not available")
+        self._assert_expected_owner(
+            relative_path,
+            expected_task_id=expected_task_id,
+            expected_source_file_id=expected_source_file_id,
+        )
+        if start < 0 or expected_size < 0 or chunk_size < 1:
+            raise DataProcessStorageError("invalid source byte range")
+        descriptor, info = self._open_read_descriptor(relative_path)
+        if info.st_size != expected_size:
+            os.close(descriptor)
+            raise DataProcessStorageError("source object size does not match metadata")
+        remaining = expected_size - start if length is None else length
+        if remaining < 0 or start + remaining > expected_size:
+            os.close(descriptor)
+            raise DataProcessStorageError("invalid source byte range")
+        with os.fdopen(descriptor, "rb", closefd=True) as stream:
+            stream.seek(start)
+            while remaining:
+                chunk = stream.read(min(chunk_size, remaining))
+                if not chunk:
+                    raise DataProcessStorageError("source object ended unexpectedly")
+                remaining -= len(chunk)
+                yield chunk
+
+    def validate_owner(
+        self,
+        reference: str,
+        *,
+        expected_task_id: str,
+        expected_source_file_id: str,
+    ) -> bool:
+        """校验 local 引用归属；旧 ``db://`` 引用无需文件系统处理。"""
+
+        relative_path = self._relative_from_reference(reference)
+        if relative_path is None:
+            return False
+        self._assert_expected_owner(
+            relative_path,
+            expected_task_id=expected_task_id,
+            expected_source_file_id=expected_source_file_id,
+        )
+        return True
+
+    def _open_read_descriptor(
+        self,
+        relative_path: PurePosixPath,
+    ) -> tuple[int, os.stat_result]:
+        path = self._path_for_relative(relative_path)
+        self._assert_controlled_parent(path)
+        try:
+            before_open = path.lstat()
+        except FileNotFoundError as exc:
+            raise DataProcessStorageError("source storage object does not exist") from exc
+        if stat.S_ISLNK(before_open.st_mode) or not stat.S_ISREG(before_open.st_mode):
+            raise DataProcessStorageError("source storage object is not a regular file")
+        flags = os.O_RDONLY
+        if hasattr(os, "O_NOFOLLOW"):
+            flags |= os.O_NOFOLLOW
+        descriptor = os.open(path, flags)
+        after_open = os.fstat(descriptor)
+        if (
+            not stat.S_ISREG(after_open.st_mode)
+            or before_open.st_dev != after_open.st_dev
+            or before_open.st_ino != after_open.st_ino
+        ):
+            os.close(descriptor)
+            raise DataProcessStorageError("source storage object changed while opening")
+        return descriptor, after_open
+
+    def delete(
+        self,
+        reference: str,
+        *,
+        expected_task_id: str | None = None,
+        expected_source_file_id: str | None = None,
+    ) -> bool:
+        """删除受控 local 对象；旧 ``db://`` 引用保持不变。"""
+
+        relative_path = self._relative_from_reference(reference)
+        if relative_path is None:
+            return False
+        if (expected_task_id is None) != (expected_source_file_id is None):
+            raise DataProcessStorageError("both expected storage owner fields are required")
+        if expected_task_id is not None and expected_source_file_id is not None:
+            self._assert_expected_owner(
+                relative_path,
+                expected_task_id=expected_task_id,
+                expected_source_file_id=expected_source_file_id,
+            )
+        path = self._path_for_relative(relative_path)
+        self._assert_controlled_parent(path)
+        try:
+            info = path.lstat()
+        except FileNotFoundError:
+            return False
+        if stat.S_ISLNK(info.st_mode) or not stat.S_ISREG(info.st_mode):
+            raise DataProcessStorageError("refusing to delete a non-regular storage object")
+        path.unlink()
+        self._fsync_directory(path.parent)
+        for directory in (path.parent, path.parent.parent, path.parent.parent.parent):
+            self._remove_empty_directory(directory)
+        return True
+
+    @staticmethod
+    def _assert_expected_owner(
+        relative_path: PurePosixPath,
+        *,
+        expected_task_id: str,
+        expected_source_file_id: str,
+    ) -> None:
+        task_id = _safe_component(expected_task_id, "expected task id")
+        source_file_id = _safe_component(
+            expected_source_file_id,
+            "expected source file id",
+        )
+        if relative_path.parts[:2] != (task_id, source_file_id):
+            raise DataProcessStorageError("source storage object owner mismatch")
+
+    def _relative_from_reference(self, reference: str) -> PurePosixPath | None:
+        if reference.startswith("db://"):
+            return None
+        parsed = urlsplit(reference)
+        if parsed.scheme != "local" or parsed.netloc != "data-process":
+            raise DataProcessStorageError("unsupported source storage reference")
+        if parsed.query or parsed.fragment or "\\" in parsed.path:
+            raise DataProcessStorageError("unsafe source storage reference")
+        raw_parts = parsed.path.lstrip("/").split("/")
+        if len(raw_parts) != 4:
+            raise DataProcessStorageError("unsafe source storage reference")
+        if any(re.search(r"%(?![0-9A-Fa-f]{2})", part) for part in raw_parts):
+            raise DataProcessStorageError("unsafe source storage reference")
+        try:
+            decoded = [unquote(part, encoding="utf-8", errors="strict") for part in raw_parts]
+        except UnicodeDecodeError as exc:
+            raise DataProcessStorageError("unsafe source storage reference") from exc
+        if any("/" in part or "\\" in part for part in decoded):
+            raise DataProcessStorageError("unsafe source storage reference")
+        canonical_parts = [
+            quote(decoded[0], safe="-_."),
+            quote(decoded[1], safe="-_."),
+            quote(decoded[2], safe="-_."),
+            quote(decoded[3], safe=""),
+        ]
+        if canonical_parts != raw_parts:
+            raise DataProcessStorageError("source storage reference is not canonical")
+        task_id = _safe_component(decoded[0], "task id")
+        source_file_id = _safe_component(decoded[1], "source file id")
+        version_component = decoded[2]
+        if not version_component.startswith("v") or not version_component[1:].isdigit():
+            raise DataProcessStorageError("invalid source file version")
+        version = int(version_component[1:])
+        if version < 1:
+            raise DataProcessStorageError("invalid source file version")
+        basename = _safe_basename(decoded[3])
+        return PurePosixPath(task_id, source_file_id, f"v{version}", basename)
+
+    def _path_for_relative(self, relative_path: PurePosixPath) -> Path:
+        if relative_path.is_absolute() or any(
+            part in {"", ".", ".."} for part in relative_path.parts
+        ):
+            raise DataProcessStorageError("storage path escapes the configured root")
+        path = self._root.joinpath(*relative_path.parts)
+        self._assert_controlled_parent(path)
+        return path
+
+    def _validate_staged_object(
+        self,
+        item: StagedSourceObject,
+        *,
+        require_file: bool,
+    ) -> None:
+        if not isinstance(item, StagedSourceObject):
+            raise DataProcessStorageError("invalid staged source object")
+        if self._issued_staged_objects.get(item._temporary_path) is not item:
+            raise DataProcessStorageError("staged source object was not issued by this storage")
+        expected_relative = self._relative_from_reference(item.reference)
+        if expected_relative is None or expected_relative != item._relative_path:
+            raise DataProcessStorageError("staged source object reference mismatch")
+        staging_root = self._root / ".staging"
+        try:
+            relative_temporary = item._temporary_path.relative_to(staging_root)
+        except ValueError as exc:
+            raise DataProcessStorageError("staged source object escapes staging") from exc
+        if len(relative_temporary.parts) != 2:
+            raise DataProcessStorageError("invalid staged source object path")
+        _safe_component(relative_temporary.parts[0], "batch id")
+        _safe_basename(relative_temporary.parts[1])
+        self._assert_controlled_parent(item._temporary_path)
+        try:
+            info = item._temporary_path.lstat()
+        except FileNotFoundError:
+            if require_file:
+                raise DataProcessStorageError("staged source object does not exist") from None
+            return
+        if stat.S_ISLNK(info.st_mode) or not stat.S_ISREG(info.st_mode):
+            raise DataProcessStorageError("staged source object is not a regular file")
+
+    def _ensure_directory(self, directory: Path) -> Path:
+        try:
+            relative = directory.relative_to(self._root)
+        except ValueError as exc:
+            raise DataProcessStorageError("storage path escapes the configured root") from exc
+        current = self._root
+        for component in relative.parts:
+            current = current / component
+            try:
+                current.mkdir(mode=0o700)
+            except FileExistsError:
+                pass
+            info = current.lstat()
+            if stat.S_ISLNK(info.st_mode) or not stat.S_ISDIR(info.st_mode):
+                raise DataProcessStorageError("storage path contains a symlink or non-directory")
+        return directory
+
+    def _assert_controlled_parent(self, path: Path) -> None:
+        try:
+            relative_parent = path.parent.relative_to(self._root)
+        except ValueError as exc:
+            raise DataProcessStorageError("storage path escapes the configured root") from exc
+        current = self._root
+        for component in relative_parent.parts:
+            current = current / component
+            if not current.exists():
+                continue
+            info = current.lstat()
+            if stat.S_ISLNK(info.st_mode) or not stat.S_ISDIR(info.st_mode):
+                raise DataProcessStorageError("storage path contains a symlink or non-directory")
+
+    @staticmethod
+    def _fsync_directory(directory: Path) -> None:
+        descriptor = os.open(directory, os.O_RDONLY)
+        try:
+            os.fsync(descriptor)
+        finally:
+            os.close(descriptor)
+
+    def _remove_empty_directory(self, directory: Path) -> None:
+        if directory in {self._root, self._root / ".staging"}:
+            return
+        self._assert_controlled_parent(directory / "placeholder")
+        try:
+            directory.rmdir()
+        except (FileNotFoundError, OSError):
+            return
+
+
+@lru_cache
+def get_data_process_storage() -> LocalDataProcessStorage:
+    return LocalDataProcessStorage()
+
+
+__all__ = [
+    "DataProcessStorageError",
+    "LocalDataProcessStorage",
+    "StagedSourceObject",
+    "get_data_process_storage",
+]
diff --git a/backend/app/modules/data_process/store.py b/backend/app/modules/data_process/store.py
index 806ca23..e501550 100644
--- a/backend/app/modules/data_process/store.py
+++ b/backend/app/modules/data_process/store.py
@@ -15,7 +15,6 @@ from psycopg.rows import dict_row
 from app.core.config import get_settings
 from app.modules.data_process.algorithms import estimate_token_count, stable_split
 
-
 TASK_STATUSES = {"pending", "running", "completed", "failed", "stopped"}
 EDITABLE_STATUSES = {"pending", "failed", "stopped", "completed"}
 
@@ -69,6 +68,34 @@ def _serialize_value(value: Any) -> Any:
     return value
 
 
+def _source_storage_descriptor(
+    payload: dict[str, Any],
+    task_id: str,
+    file_id: str,
+) -> tuple[str, dict[str, Any]]:
+    storage_object_id = str(
+        payload.get("storage_object_id")
+        or f"db://data-process/{task_id}/{file_id}/v1"
+    )
+    expected_local_prefix = f"local://data-process/{task_id}/{file_id}/v1/"
+    expected_database_reference = f"db://data-process/{task_id}/{file_id}/v1"
+    if storage_object_id.startswith(expected_local_prefix) and len(storage_object_id) > len(
+        expected_local_prefix
+    ):
+        storage_backend = "local"
+    elif storage_object_id == expected_database_reference:
+        storage_backend = "database"
+    elif storage_object_id.startswith(("local://data-process/", "db://data-process/")):
+        raise DataProcessStoreError("source storage object owner mismatch")
+    else:
+        raise DataProcessStoreError("unsupported source storage object reference")
+    metadata = {
+        **(payload.get("metadata") or {}),
+        "storage_backend": storage_backend,
+    }
+    return storage_object_id, metadata
+
+
 def _decode_row(row: dict[str, Any] | None) -> dict[str, Any] | None:
     if row is None:
         return None
@@ -343,6 +370,8 @@ class DataProcessStore:
         record_count: int,
         metadata: dict[str, Any] | None = None,
         created_by: str | None = None,
+        source_file_id: str | None = None,
+        storage_object_id: str | None = None,
     ) -> dict[str, Any]:
         return self.add_source_files(
             task_id,
@@ -356,6 +385,8 @@ class DataProcessStore:
                     "record_count": record_count,
                     "metadata": metadata or {},
                     "created_by": created_by,
+                    "id": source_file_id,
+                    "storage_object_id": storage_object_id,
                 }
             ],
         )[0]
@@ -376,12 +407,12 @@ class DataProcessStore:
                 task = self._task_in_connection(conn, task_id, for_update=True)
                 self._ensure_editable(task)
                 for payload in files:
-                    file_id = new_id("dpsf")
-                    storage_object_id = f"db://data-process/{task_id}/{file_id}/v1"
-                    metadata_payload = {
-                        "storage_backend": "database",
-                        **(payload.get("metadata") or {}),
-                    }
+                    file_id = str(payload.get("id") or new_id("dpsf"))
+                    storage_object_id, metadata_payload = _source_storage_descriptor(
+                        payload,
+                        task_id,
+                        file_id,
+                    )
                     row = conn.execute(
                         """
                         INSERT INTO data_process_source_files
@@ -530,14 +561,59 @@ class DataProcessStore:
             )
 
     def replace_preview_items(
-        self, task_id: str, items: Sequence[dict[str, Any]]
+        self,
+        task_id: str,
+        items: Sequence[dict[str, Any]],
+        *,
+        source_file_ids: Sequence[str] | None = None,
     ) -> list[dict[str, Any]]:
+        selected_ids = (
+            list(dict.fromkeys(str(file_id) for file_id in source_file_ids))
+            if source_file_ids is not None
+            else None
+        )
+        if selected_ids is not None:
+            if not selected_ids or any(not file_id for file_id in selected_ids):
+                raise ValueError("source_file_ids must contain non-empty ids")
+            selected_set = set(selected_ids)
+            unexpected = {
+                str(item.get("source_file_id") or "")
+                for item in items
+                if str(item.get("source_file_id") or "") not in selected_set
+            }
+            if unexpected:
+                raise ValueError("preview items contain an unselected source file")
+
         now = utcnow()
         with self.connect() as conn:
             task = self._task_in_connection(conn, task_id, for_update=True)
             self._ensure_editable(task)
             conn.execute("DELETE FROM data_process_results WHERE task_id=%s", (task_id,))
-            conn.execute("DELETE FROM data_process_preview_items WHERE task_id=%s", (task_id,))
+            if selected_ids is None:
+                conn.execute(
+                    "DELETE FROM data_process_preview_items WHERE task_id=%s", (task_id,)
+                )
+            else:
+                rows = conn.execute(
+                    """
+                    SELECT id FROM data_process_source_files
+                    WHERE task_id=%s AND deleted_at IS NULL AND id=ANY(%s)
+                    """,
+                    (task_id, selected_ids),
+                ).fetchall()
+                found = {str(row["id"]) for row in rows}
+                missing = set(selected_ids) - found
+                if missing:
+                    raise NotFoundError(
+                        f"source files not found: {', '.join(sorted(missing))}"
+                    )
+                conn.execute(
+                    """
+                    DELETE FROM data_process_preview_items
+                    WHERE task_id=%s AND source_file_id=ANY(%s)
+                    """,
+                    (task_id, selected_ids),
+                )
             created: list[dict[str, Any]] = []
             for item in items:
                 row = conn.execute(
diff --git a/backend/app/schemas/data_process.py b/backend/app/schemas/data_process.py
index 1ceac43..248857a 100644
--- a/backend/app/schemas/data_process.py
+++ b/backend/app/schemas/data_process.py
@@ -13,6 +13,24 @@ def _config_value(config: dict[str, Any], snake_name: str, camel_name: str, defa
 
 
 def _validate_process_config(config: dict[str, Any]) -> None:
+    chunk_method = _config_value(config, "chunk_method", "chunkMethod", "structure")
+    if not isinstance(chunk_method, str) or chunk_method not in {
+        "structure",
+        "fixed",
+        "custom",
+    }:
+        raise ValueError("chunk_method must be one of: structure, fixed, custom")
+    custom_delimiter = _config_value(
+        config,
+        "custom_delimiter",
+        "customDelimiter",
+        "",
+    )
+    if chunk_method == "custom" and (
+        not isinstance(custom_delimiter, str) or not custom_delimiter
+    ):
+        raise ValueError("custom_delimiter is required for custom chunking")
+
     split = _config_value(config, "dataset_split", "datasetSplit", None)
     if split is not None:
         if not isinstance(split, dict) or set(split) != {"train", "validation", "test"}:
@@ -140,6 +158,23 @@ class PreviewBuildRequest(BaseModel):
 
     replace_existing: Literal[True] = True
     source_file_ids: list[str] | None = None
+    source_file_id: str | None = None
+
+    @model_validator(mode="after")
+    def validate_source_file_selection(self) -> "PreviewBuildRequest":
+        if self.source_file_ids is not None and self.source_file_id is not None:
+            raise ValueError("source_file_id and source_file_ids cannot be used together")
+        values = self.source_file_ids
+        if values is None and self.source_file_id is not None:
+            values = [self.source_file_id]
+        if values is None:
+            return self
+        normalized = list(dict.fromkeys(str(value).strip() for value in values))
+        if not normalized or any(not value for value in normalized):
+            raise ValueError("at least one non-empty source file id is required")
+        self.source_file_ids = normalized
+        self.source_file_id = None
+        return self
 
 
 class PreviewItemCreate(BaseModel):
diff --git a/backend/pyproject.toml b/backend/pyproject.toml
index 042a8ab..5758310 100644
--- a/backend/pyproject.toml
+++ b/backend/pyproject.toml
@@ -16,6 +16,11 @@ dependencies = [
   "PyJWT>=2.8.0",
   "passlib[bcrypt]>=1.7.4",
   "python-dotenv>=1.0.1",
+  "pypdf[crypto]>=5.0.0",
+  "python-docx>=1.1.2",
+  "openpyxl>=3.1.5",
+  "python-pptx>=1.0.2",
+  "llama-index-core==0.14.23",
 ]
 
 [project.optional-dependencies]
diff --git a/backend/requirements.txt b/backend/requirements.txt
index 6ef0933..fc80dad 100644
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@@ -10,3 +10,8 @@ httpx>=0.27.0
 PyJWT>=2.8.0
 passlib[bcrypt]>=1.7.4
 python-dotenv>=1.0.1
+pypdf[crypto]>=5.0.0
+python-docx>=1.1.2
+openpyxl>=3.1.5
+python-pptx>=1.0.2
+llama-index-core==0.14.23
diff --git a/backend/tests/test_data_process_algorithms.py b/backend/tests/test_data_process_algorithms.py
index 21dca28..57f8200 100644
--- a/backend/tests/test_data_process_algorithms.py
+++ b/backend/tests/test_data_process_algorithms.py
@@ -1,23 +1,151 @@
 from __future__ import annotations
 
+import io
 import json
+import xml.etree.ElementTree as ET
+import zipfile
+from datetime import datetime
 
 import pytest
+from docx import Document
+from openpyxl import Workbook
+from pptx import Presentation
+from pptx.util import Inches
+from pypdf import PdfWriter
 
 from app.modules.data_process.algorithms import (
     chunk_unstructured,
+    content_quality_flags,
     desensitize_pii,
+    desensitize_structured_record,
+    detect_document_structure,
     detect_text_format,
+    estimate_token_count,
+    extract_pdf_page_texts,
     extract_structured_records,
     generate_standard_records,
+    is_near_duplicate,
+    merge_short_blocks,
     normalize_text,
     parse_text_content,
+    preprocess_structured_records,
     record_fingerprint,
     score_quality,
     stable_split,
 )
 
 
+def _minimal_pdf(text: str = "Hello PDF") -> bytes:
+    stream = f"BT /F1 12 Tf 72 720 Td ({text}) Tj ET".encode("ascii")
+    objects = [
+        b"<< /Type /Catalog /Pages 2 0 R >>",
+        b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+        (
+            b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] "
+            b"/Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>"
+        ),
+        b"<< /Length " + str(len(stream)).encode("ascii") + b" >>\nstream\n"
+        + stream
+        + b"\nendstream",
+        b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+    ]
+    result = bytearray(b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n")
+    offsets = [0]
+    for object_number, value in enumerate(objects, start=1):
+        offsets.append(len(result))
+        result.extend(f"{object_number} 0 obj\n".encode("ascii"))
+        result.extend(value)
+        result.extend(b"\nendobj\n")
+    xref_offset = len(result)
+    result.extend(f"xref\n0 {len(objects) + 1}\n".encode("ascii"))
+    result.extend(b"0000000000 65535 f \n")
+    for offset in offsets[1:]:
+        result.extend(f"{offset:010d} 00000 n \n".encode("ascii"))
+    result.extend(
+        (
+            f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\n"
+            f"startxref\n{xref_offset}\n%%EOF\n"
+        ).encode("ascii")
+    )
+    return bytes(result)
+
+
+def _aes_encrypted_pdf(*, user_password: str) -> bytes:
+    writer = PdfWriter(clone_from=io.BytesIO(_minimal_pdf()))
+    writer.encrypt(
+        user_password=user_password,
+        owner_password="owner-secret",
+        algorithm="AES-256",
+    )
+    output = io.BytesIO()
+    writer.write(output)
+    return output.getvalue()
+
+
+def _docx_bytes() -> bytes:
+    document = Document()
+    document.add_heading("服务说明", level=1)
+    document.add_paragraph("这是 DOCX 正文。")
+    table = document.add_table(rows=1, cols=2)
+    table.cell(0, 0).text = "字段"
+    table.cell(0, 1).text = "内容"
+    output = io.BytesIO()
+    document.save(output)
+    return output.getvalue()
+
+
+def _xlsx_bytes() -> bytes:
+    workbook = Workbook()
+    worksheet = workbook.active
+    worksheet.title = "数据"
+    worksheet.append(["name", "score", "created_at"])
+    worksheet.append(["Alice", 95, datetime(2026, 7, 23, 10, 30)])
+    worksheet.append(["Bob", 88, datetime(2026, 7, 24, 9, 0)])
+    output = io.BytesIO()
+    workbook.save(output)
+    workbook.close()
+    return output.getvalue()
+
+
+def _xlsx_with_worksheet_relationship(
+    raw: bytes,
+    target: str,
+    *,
+    target_mode: str | None = None,
+) -> bytes:
+    member_name = "xl/_rels/workbook.xml.rels"
+    source = io.BytesIO(raw)
+    output = io.BytesIO()
+    with zipfile.ZipFile(source) as original, zipfile.ZipFile(output, "w") as rewritten:
+        for member in original.infolist():
+            content = original.read(member.filename)
+            if member.filename == member_name:
+                root = ET.fromstring(content)
+                worksheet_relationship = next(
+                    element
+                    for element in root
+                    if element.attrib.get("Type", "").endswith("/worksheet")
+                )
+                worksheet_relationship.set("Target", target)
+                if target_mode is None:
+                    worksheet_relationship.attrib.pop("TargetMode", None)
+                else:
+                    worksheet_relationship.set("TargetMode", target_mode)
+                content = ET.tostring(root, encoding="utf-8", xml_declaration=True)
+            rewritten.writestr(member, content)
+    return output.getvalue()
+
+
+def _pptx_bytes() -> bytes:
+    presentation = Presentation()
+    slide = presentation.slides.add_slide(presentation.slide_layouts[6])
+    text_box = slide.shapes.add_textbox(Inches(1), Inches(1), Inches(6), Inches(1))
+    text_box.text = "PPTX 页面正文"
+    output = io.BytesIO()
+    presentation.save(output)
+    return output.getvalue()
+
+
 def test_parse_utf8_json_jsonl_csv_markdown_and_txt() -> None:
     parsed_json = parse_text_content(
         b'\xef\xbb\xbf{"data":[{"name":"\xe5\xbc\xa0\xe4\xb8\x89"}]}',
@@ -44,6 +172,269 @@ def test_parse_utf8_json_jsonl_csv_markdown_and_txt() -> None:
     assert parsed_txt.text == "普通文本"
 
 
+def test_parse_pdf_docx_xlsx_and_pptx() -> None:
+    parsed_pdf = parse_text_content(_minimal_pdf(), filename="manual.pdf")
+    assert parsed_pdf.format == "pdf"
+    assert "Hello PDF" in parsed_pdf.text
+    assert parsed_pdf.records == ()
+
+    pdf_pages = extract_pdf_page_texts(_minimal_pdf())
+    assert len(pdf_pages) == 1
+    assert pdf_pages[0].page_number == 1
+    assert pdf_pages[0].text == "Hello PDF"
+    assert pdf_pages[0].source_start == 0
+    assert pdf_pages[0].source_end == len(parsed_pdf.text)
+
+    parsed_docx = parse_text_content(_docx_bytes(), filename="manual.docx")
+    assert parsed_docx.format == "docx"
+    assert "服务说明" in parsed_docx.text
+    assert "这是 DOCX 正文。" in parsed_docx.text
+    assert "字段\t内容" in parsed_docx.text
+    assert parsed_docx.records == ()
+
+    parsed_xlsx = parse_text_content(_xlsx_bytes(), filename="records.xlsx")
+    assert parsed_xlsx.format == "xlsx"
+    assert parsed_xlsx.records == (
+        {"name": "Alice", "score": 95, "created_at": "2026-07-23T10:30:00"},
+        {"name": "Bob", "score": 88, "created_at": "2026-07-24T09:00:00"},
+    )
+    assert json.loads(parsed_xlsx.text.splitlines()[0]) == parsed_xlsx.records[0]
+
+    parsed_pptx = parse_text_content(_pptx_bytes(), filename="slides.pptx")
+    assert parsed_pptx.format == "pptx"
+    assert parsed_pptx.text == "PPTX 页面正文"
+    assert parsed_pptx.records == ()
+
+
+def test_xlsx_merged_multilevel_headers_are_flattened_without_losing_columns() -> None:
+    workbook = Workbook()
+    worksheet = workbook.active
+    worksheet.merge_cells("A1:A2")
+    worksheet.merge_cells("B1:C1")
+    worksheet["A1"] = "地区"
+    worksheet["B1"] = "销售"
+    worksheet["B2"] = "Q1"
+    worksheet["C2"] = "Q2"
+    worksheet.append(["华东", 100, 120])
+    output = io.BytesIO()
+    workbook.save(output)
+    workbook.close()
+
+    parsed = parse_text_content(output.getvalue(), filename="sales.xlsx")
+    assert parsed.records == ({"地区": "华东", "销售.Q1": 100, "销售.Q2": 120},)
+
+
+def test_xlsx_header_inference_skips_more_than_eight_merged_report_titles() -> None:
+    workbook = Workbook()
+    worksheet = workbook.active
+    for row_number in range(1, 13):
+        worksheet.merge_cells(
+            start_row=row_number,
+            start_column=1,
+            end_row=row_number,
+            end_column=4,
+        )
+        worksheet.cell(row_number, 1, f"报表说明 {row_number}")
+    worksheet.append(["姓名", "部门", "得分", "日期"])
+    worksheet.append(["张三", "研发", 95, "2026-07-23"])
+    output = io.BytesIO()
+    workbook.save(output)
+    workbook.close()
+
+    parsed = parse_text_content(output.getvalue(), filename="report.xlsx")
+    assert parsed.records == (
+        {"姓名": "张三", "部门": "研发", "得分": 95, "日期": "2026-07-23"},
+    )
+
+
+def test_xlsx_header_inference_ignores_continuous_body_merges() -> None:
+    workbook = Workbook()
+    worksheet = workbook.active
+    worksheet.append(["类别", "名称", "数量"])
+    worksheet.append(["水果", "苹果", 10])
+    worksheet.append([None, "香蕉", 12])
+    worksheet.append(["蔬菜", "白菜", 8])
+    worksheet.append([None, "萝卜", 9])
+    worksheet.merge_cells("A2:A3")
+    worksheet.merge_cells("A4:A5")
+    output = io.BytesIO()
+    workbook.save(output)
+    workbook.close()
+
+    parsed = parse_text_content(output.getvalue(), filename="inventory.xlsx")
+    assert parsed.records == (
+        {"类别": "水果", "名称": "苹果", "数量": 10},
+        {"类别": "", "名称": "香蕉", "数量": 12},
+        {"类别": "蔬菜", "名称": "白菜", "数量": 8},
+        {"类别": "", "名称": "萝卜", "数量": 9},
+    )
+
+
+def test_xlsx_header_inference_supports_title_and_two_header_levels() -> None:
+    workbook = Workbook()
+    worksheet = workbook.active
+    worksheet.merge_cells("A1:C1")
+    worksheet["A1"] = "区域销售报表"
+    worksheet["A2"] = "统计日期"
+    worksheet["B2"] = "2026-07-23"
+    worksheet.merge_cells("A4:A5")
+    worksheet.merge_cells("B4:C4")
+    worksheet["A4"] = "地区"
+    worksheet["B4"] = "销售"
+    worksheet["B5"] = "Q1"
+    worksheet["C5"] = "Q2"
+    worksheet.append(["华南", 88, 92])
+    output = io.BytesIO()
+    workbook.save(output)
+    workbook.close()
+
+    parsed = parse_text_content(output.getvalue(), filename="two-level.xlsx")
+    assert parsed.records == (
+        {"地区": "华南", "销售.Q1": 88, "销售.Q2": 92},
+    )
+
+
+def test_xlsx_header_inference_supports_title_and_three_header_levels() -> None:
+    workbook = Workbook()
+    worksheet = workbook.active
+    worksheet.merge_cells("A1:D1")
+    worksheet["A1"] = "年度销售分析报告"
+    worksheet["A2"] = "统计日期"
+    worksheet["B2"] = "2026-07-23"
+    worksheet.merge_cells("A4:A6")
+    worksheet.merge_cells("B4:D4")
+    worksheet.merge_cells("B5:C5")
+    worksheet.merge_cells("D5:D6")
+    worksheet["A4"] = "地区"
+    worksheet["B4"] = "销售"
+    worksheet["B5"] = "国内"
+    worksheet["D5"] = "海外"
+    worksheet["B6"] = "Q1"
+    worksheet["C6"] = "Q2"
+    worksheet.append(["华东", 100, 120, 80])
+    output = io.BytesIO()
+    workbook.save(output)
+    workbook.close()
+
+    parsed = parse_text_content(output.getvalue(), filename="three-level.xlsx")
+    assert parsed.records == (
+        {
+            "地区": "华东",
+            "销售.国内.Q1": 100,
+            "销售.国内.Q2": 120,
+            "销售.海外": 80,
+        },
+    )
+
+
+def test_xlsx_header_inference_keeps_an_ordinary_single_header_row() -> None:
+    parsed = parse_text_content(_xlsx_bytes(), filename="ordinary.xlsx")
+    assert tuple(parsed.records[0]) == ("name", "score", "created_at")
+    assert len(parsed.records) == 2
+
+
+@pytest.mark.parametrize(
+    "target",
+    [
+        "./worksheets/../worksheets/sheet1.xml",
+        "./worksheets/%2e%2e/worksheets/sheet1.xml",
+        "../xl/worksheets/sheet1.xml",
+        "/xl/worksheets/./sheet1.xml",
+    ],
+)
+def test_xlsx_worksheet_relationship_allows_safe_dot_segments(target: str) -> None:
+    raw = _xlsx_with_worksheet_relationship(_xlsx_bytes(), target)
+    parsed = parse_text_content(raw, filename="records.xlsx")
+    assert parsed.records[0]["name"] == "Alice"
+
+
+@pytest.mark.parametrize(
+    "target",
+    [
+        "../../outside.xml",
+        "worksheets\\sheet1.xml",
+        "%2e%2e/%2e%2e/outside.xml",
+        "%252e%252e/%252e%252e/outside.xml",
+        "https://example.com/sheet1.xml",
+    ],
+)
+def test_xlsx_worksheet_relationship_rejects_path_traversal(target: str) -> None:
+    raw = _xlsx_with_worksheet_relationship(_xlsx_bytes(), target)
+    with pytest.raises(ValueError, match="unsafe worksheet path"):
+        parse_text_content(raw, filename="unsafe.xlsx")
+
+
+def test_xlsx_worksheet_relationship_rejects_external_and_missing_targets() -> None:
+    external = _xlsx_with_worksheet_relationship(
+        _xlsx_bytes(),
+        "https://example.com/sheet1.xml",
+        target_mode="External",
+    )
+    with pytest.raises(ValueError, match="external relationship"):
+        parse_text_content(external, filename="external.xlsx")
+
+    missing = _xlsx_with_worksheet_relationship(
+        _xlsx_bytes(),
+        "worksheets/missing.xml",
+    )
+    with pytest.raises(ValueError, match="target does not exist"):
+        parse_text_content(missing, filename="missing.xlsx")
+
+
+@pytest.mark.parametrize(
+    ("filename", "replacement"),
+    [
+        ("legacy.doc", ".docx"),
+        ("legacy.xls", ".xlsx"),
+        ("legacy.ppt", ".pptx"),
+    ],
+)
+def test_legacy_office_formats_require_conversion(filename: str, replacement: str) -> None:
+    with pytest.raises(ValueError, match=rf"convert the file to \{replacement}"):
+        parse_text_content(b"legacy", filename=filename)
+
+
+def test_office_zip_bomb_and_invalid_pdf_are_rejected_before_parsing() -> None:
+    archive = io.BytesIO()
+    with zipfile.ZipFile(archive, "w", compression=zipfile.ZIP_DEFLATED) as package:
+        package.writestr("[Content_Types].xml", "<Types/>")
+        package.writestr("word/document.xml", b"A" * (2 * 1024 * 1024))
+    with pytest.raises(ValueError, match="unsafe compression ratio"):
+        parse_text_content(archive.getvalue(), filename="unsafe.docx")
+
+    active_xml = io.BytesIO()
+    with zipfile.ZipFile(active_xml, "w") as package:
+        package.writestr("[Content_Types].xml", "<Types/>")
+        package.writestr(
+            "word/document.xml",
+            '<!DOCTYPE document [<!ENTITY xxe SYSTEM "file:///etc/passwd">]><document/>',
+        )
+    with pytest.raises(ValueError, match="unsupported active XML"):
+        parse_text_content(active_xml.getvalue(), filename="active.docx")
+
+    with pytest.raises(ValueError, match="missing PDF header"):
+        parse_text_content(b"not a pdf", filename="broken.pdf")
+
+    blank_pdf = io.BytesIO()
+    blank_writer = PdfWriter()
+    blank_writer.add_blank_page(width=612, height=792)
+    blank_writer.write(blank_pdf)
+    with pytest.raises(ValueError, match="scanned PDF requires OCR"):
+        parse_text_content(blank_pdf.getvalue(), filename="scanned.pdf")
+
+    aes_pdf_without_open_password = parse_text_content(
+        _aes_encrypted_pdf(user_password=""),
+        filename="aes-no-password.pdf",
+    )
+    assert "Hello PDF" in aes_pdf_without_open_password.text
+
+    with pytest.raises(ValueError, match="password-protected PDF files are not supported"):
+        parse_text_content(
+            _aes_encrypted_pdf(user_password="secret"),
+            filename="aes-password.pdf",
+        )
+
+
 def test_invalid_utf8_and_malformed_structured_content_fail_loudly() -> None:
     with pytest.raises(ValueError, match="not valid UTF-8"):
         parse_text_content(b"\xff\xfe", filename="broken.txt")
@@ -80,7 +471,89 @@ def test_desensitize_pii_returns_masked_text_and_counts() -> None:
     assert counts == {"email": 1, "phone": 1, "id_card": 1, "total": 3}
 
 
-@pytest.mark.parametrize("method", ["semantic", "heading", "fixed", "custom"])
+def test_every_structured_preprocess_option_has_independent_behavior() -> None:
+    clean_source = [
+        {"id": "1", "name": "有效", "empty_column": ""},
+        {"id": "", "name": "缺少关键字段", "empty_column": ""},
+        {"id": "2", "name": "有效", "empty_column": ""},
+    ]
+    assert preprocess_structured_records(clean_source, []) == clean_source
+    assert preprocess_structured_records(clean_source, ["clean_invalid"]) == [
+        {"id": "1", "name": "有效"},
+        {"id": "2", "name": "有效"},
+    ]
+
+    nested = [{"id": 1, "profile": {"name": "张三", "level": 2}}]
+    assert "profile" in preprocess_structured_records(nested, [])[0]
+    assert preprocess_structured_records(nested, ["detect_structure"])[0] == {
+        "id": 1,
+        "profile.name": "张三",
+        "profile.level": 2,
+    }
+
+    duplicates = [
+        {"customer_id": "C-1", "value": "first"},
+        {"customer_id": "C-1", "value": "updated"},
+        {"customer_id": "", "value": "blank-one"},
+        {"customer_id": "", "value": "blank-two"},
+    ]
+    assert len(preprocess_structured_records(duplicates, [])) == 4
+    deduplicated = preprocess_structured_records(duplicates, ["deduplicate"])
+    assert [record["value"] for record in deduplicated] == [
+        "first",
+        "blank-one",
+        "blank-two",
+    ]
+
+    unnormalized = [{" User Name ": "ＡＢＣ\r\n第二行"}]
+    assert preprocess_structured_records(unnormalized, []) == unnormalized
+    assert preprocess_structured_records(unnormalized, ["normalize_format"]) == [
+        {"user_name": "ABC\n第二行"}
+    ]
+
+    anomaly_source = [
+        {"id": 10_000 + index, "amount": amount, "text": "正常内容"}
+        for index, amount in enumerate((10, 10, 11, 11, 12, 12, 13, 1000))
+    ]
+    assert len(preprocess_structured_records(anomaly_source, [])) == 8
+    filtered = preprocess_structured_records(anomaly_source, ["filter_anomaly"])
+    assert len(filtered) == 7
+    assert all(record["amount"] != 1000 for record in filtered)
+    assert max(record["id"] for record in filtered) > 10_000
+
+    sensitive = [{"姓名": "张三", "phone": "13800138000", "email": "a@b.com"}]
+    assert preprocess_structured_records(sensitive, []) == sensitive
+    masked = preprocess_structured_records(sensitive, ["desensitize"])[0]
+    assert masked == {"姓名": "[NAME]", "phone": "[PHONE]", "email": "[EMAIL]"}
+
+
+def test_structured_desensitization_counts_and_document_helpers() -> None:
+    masked, counts = desensitize_structured_record(
+        {"联系人姓名": "李四", "说明": "邮箱 user@example.com，手机 13900139000"}
+    )
+    assert masked == {
+        "联系人姓名": "[NAME]",
+        "说明": "邮箱 [EMAIL]，手机 [PHONE]",
+    }
+    assert counts == {"email": 1, "phone": 1, "id_card": 0, "name": 1, "total": 3}
+
+    structure = detect_document_structure(
+        "# 第一章\n正文\n\n## 细节\n- 项目一\n- 项目二\n\n```python\nprint(1)\n```"
+    )
+    assert [heading.title for heading in structure.headings] == ["第一章", "细节"]
+    assert structure.list_block_count == 1
+    assert structure.code_block_count == 1
+    assert merge_short_blocks(["短一", "短二", "这是一段足够长的正文内容"], min_token_count=4)
+    assert "mojibake" in content_quality_flags("正常文字锟斤拷内容", min_chars=0, min_tokens=0)
+    assert is_near_duplicate(
+        "alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu nu xi omicron",
+        "alpha beta gamma, delta epsilon zeta eta theta iota kappa lambda mu nu xi omicron",
+        similarity_threshold=0.92,
+        max_hamming_distance=2,
+    )
+
+
+@pytest.mark.parametrize("method", ["structure", "fixed", "custom"])
 def test_chunk_methods_preserve_offsets_and_always_advance(method: str) -> None:
     text = "# 第一章\n" + "甲。" * 18 + "\n# 第二章\n" + "乙。" * 18
     kwargs = {"custom_delimiter": "\\n"} if method == "custom" else {}
@@ -99,8 +572,38 @@ def test_chunk_methods_preserve_offsets_and_always_advance(method: str) -> None:
     assert all(chunk.start_line <= chunk.end_line for chunk in chunks)
 
 
-def test_fixed_chunk_overlap_is_exact_when_chunks_are_large_enough() -> None:
-    text = " ".join(f"token{i}" for i in range(30))
+def test_default_and_structure_chunking_split_headings_without_cross_section_overlap() -> None:
+    text = (
+        "# 第一章\n"
+        + " ".join(f"alpha{i}" for i in range(18))
+        + "\n# 第二章\n"
+        + " ".join(f"beta{i}" for i in range(18))
+    )
+    normalized = normalize_text(text)
+    second_chapter_start = normalized.index("# 第二章")
+    kwargs = {"chunk_size": 10, "chunk_overlap": 3, "min_chunk_size": 4}
+
+    default_chunks = chunk_unstructured(text, **kwargs)
+    structure_chunks = chunk_unstructured(text, method="structure", **kwargs)
+
+    assert default_chunks == structure_chunks
+    assert len(structure_chunks) > 2
+    assert all(
+        chunk.content == normalized[chunk.start : chunk.end] for chunk in structure_chunks
+    )
+    assert all(
+        not (chunk.start < second_chapter_start < chunk.end) for chunk in structure_chunks
+    )
+    second_chapter_chunks = [
+        chunk for chunk in structure_chunks if chunk.start >= second_chapter_start
+    ]
+    assert second_chapter_chunks[0].start == second_chapter_start
+    assert second_chapter_chunks[0].content.startswith("# 第二章")
+
+
+def test_fixed_chunk_offsets_and_actual_token_overlap_are_exact() -> None:
+    text = "  ".join(f"token{i}" for i in range(30))
+    normalized = normalize_text(text)
     chunks = chunk_unstructured(
         text,
         method="fixed",
@@ -108,10 +611,16 @@ def test_fixed_chunk_overlap_is_exact_when_chunks_are_large_enough() -> None:
         chunk_overlap=3,
         min_chunk_size=4,
     )
-    first_tokens = chunks[0].content.split()
-    second_tokens = chunks[1].content.split()
-    assert first_tokens[-3:] == second_tokens[:3]
-    assert chunks[0].token_count == 10
+    assert len(chunks) > 2
+    assert all(chunk.content == normalized[chunk.start : chunk.end] for chunk in chunks)
+    assert all(chunk.token_count == estimate_token_count(chunk.content) for chunk in chunks)
+    assert all(chunk.token_count == 10 for chunk in chunks[:-1])
+    for left, right in zip(chunks, chunks[1:]):
+        overlap_text = normalized[right.start : left.end]
+        assert right.start < left.end
+        assert estimate_token_count(overlap_text) == 3
+        assert left.content.endswith(overlap_text)
+        assert right.content.startswith(overlap_text)
 
 
 def test_chunk_line_numbers_treat_newline_as_previous_line_boundary() -> None:
@@ -129,18 +638,7 @@ def test_chunk_line_numbers_treat_newline_as_previous_line_boundary() -> None:
     assert chunks[1].start_line == 2
 
 
-def test_heading_and_custom_boundaries_are_respected() -> None:
-    heading_text = "前言 " * 8 + "\n# 第二章\n" + "正文 " * 12
-    heading_chunks = chunk_unstructured(
-        heading_text,
-        method="heading",
-        chunk_size=20,
-        chunk_overlap=0,
-        min_chunk_size=4,
-    )
-    assert "# 第二章" not in heading_chunks[0].content
-    assert heading_chunks[1].content.startswith("#")
-
+def test_custom_delimiter_is_preserved_as_the_chunk_boundary() -> None:
     custom_chunks = chunk_unstructured(
         "a b c d <CUT> e f g h i j",
         method="custom",
@@ -172,6 +670,13 @@ def test_heading_and_custom_boundaries_are_respected() -> None:
 )
 def test_markdown_protected_blocks_are_not_split(field: str, block: str) -> None:
     text = "前言。" * 15 + "\n" + block + "\n" + "结尾。" * 40
+    unprotected = chunk_unstructured(
+        text,
+        method="fixed",
+        chunk_size=40,
+        chunk_overlap=0,
+        min_chunk_size=10,
+    )
     chunks = chunk_unstructured(
         text,
         method="fixed",
@@ -180,6 +685,7 @@ def test_markdown_protected_blocks_are_not_split(field: str, block: str) -> None
         min_chunk_size=10,
         **{field: True},
     )
+    assert all(block not in chunk.content for chunk in unprotected)
     assert any(block in chunk.content for chunk in chunks)
 
 
@@ -194,6 +700,8 @@ def test_markdown_protected_blocks_are_not_split(field: str, block: str) -> None
             "cannot exceed",
         ),
         ({"method": "custom", "custom_delimiter": ""}, "custom_delimiter"),
+        ({"method": "semantic"}, "unsupported chunk method"),
+        ({"method": "heading"}, "unsupported chunk method"),
     ],
 )
 def test_chunk_configuration_validation(kwargs: dict[str, object], message: str) -> None:
diff --git a/backend/tests/test_data_process_api.py b/backend/tests/test_data_process_api.py
index e86cbcf..54e390a 100644
--- a/backend/tests/test_data_process_api.py
+++ b/backend/tests/test_data_process_api.py
@@ -1,13 +1,23 @@
 from __future__ import annotations
 
 from copy import deepcopy
+from io import BytesIO
+from pathlib import Path
 from typing import Any
 
+import pytest
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
+from openpyxl import Workbook
 
 from app.api.v1.endpoints import data_process as data_process_endpoint
 from app.api.v1.endpoints.data_process import router
+from app.modules.data_process.algorithms import normalize_text
+from app.modules.data_process.storage import (
+    DataProcessStorageError,
+    LocalDataProcessStorage,
+    get_data_process_storage,
+)
 from app.modules.data_process.store import InvalidStateError, NotFoundError, get_data_process_store
 
 
@@ -87,11 +97,26 @@ class FakeDataProcessStore:
 
     def add_source_file(self, task_id: str, **payload: Any) -> dict[str, Any]:
         self.get_task(task_id)
+        values = deepcopy(payload)
+        source_id = str(values.pop("id", None) or self._id("dpsf"))
+        storage_object_id = str(
+            values.pop("storage_object_id", None)
+            or f"db://data-process/{task_id}/{source_id}/v1"
+        )
+        raw_size = int(values.pop("raw_size"))
+        metadata = deepcopy(values.pop("metadata", {}))
+        metadata.setdefault(
+            "storage_backend",
+            "local" if storage_object_id.startswith("local://data-process/") else "database",
+        )
         source = {
-            "id": self._id("dpsf"),
+            "id": source_id,
             "task_id": task_id,
             "version_no": 1,
-            **deepcopy(payload),
+            "storage_object_id": storage_object_id,
+            "size_bytes": raw_size,
+            "metadata": metadata,
+            **values,
         }
         self.sources[task_id].append(source)
         self.tasks[task_id]["input_count"] += payload["record_count"]
@@ -163,14 +188,27 @@ class FakeDataProcessStore:
         self.results[task_id] = []
 
     def replace_preview_items(
-        self, task_id: str, items: list[dict[str, Any]]
+        self,
+        task_id: str,
+        items: list[dict[str, Any]],
+        *,
+        source_file_ids: list[str] | None = None,
     ) -> list[dict[str, Any]]:
-        self.previews[task_id] = [
+        created = [
             {"id": self._id("dpp"), "task_id": task_id, **deepcopy(item)} for item in items
         ]
+        if source_file_ids is None:
+            self.previews[task_id] = created
+        else:
+            selected = set(source_file_ids)
+            self.previews[task_id] = [
+                item
+                for item in self.previews[task_id]
+                if item["source_file_id"] not in selected
+            ] + created
         self.results[task_id] = []
         self.tasks[task_id]["progress"] = 20
-        return deepcopy(self.previews[task_id])
+        return deepcopy(created)
 
     def list_preview_items(
         self,
@@ -389,16 +427,59 @@ class FakeDataProcessStore:
         return {"dataset": deepcopy(dataset), "created": True}
 
 
-def make_client() -> tuple[TestClient, FakeDataProcessStore]:
+def make_client(
+    tmp_path: Path,
+) -> tuple[TestClient, FakeDataProcessStore, LocalDataProcessStorage]:
     store = FakeDataProcessStore()
+    storage = LocalDataProcessStorage(tmp_path / "data-process")
     app = FastAPI()
     app.include_router(router, prefix="/modelTF")
     app.dependency_overrides[get_data_process_store] = lambda: store
-    return TestClient(app), store
+    app.dependency_overrides[get_data_process_storage] = lambda: storage
+    return TestClient(app), store, storage
 
 
-def test_data_process_full_contract_without_database() -> None:
-    client, store = make_client()
+def _stored_files(storage: LocalDataProcessStorage) -> list[Path]:
+    return [path for path in storage.root.rglob("*") if path.is_file() or path.is_symlink()]
+
+
+def _minimal_pdf(text: str = "Hello PDF") -> bytes:
+    stream = f"BT /F1 12 Tf 72 720 Td ({text}) Tj ET".encode("ascii")
+    objects = [
+        b"<< /Type /Catalog /Pages 2 0 R >>",
+        b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+        (
+            b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] "
+            b"/Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>"
+        ),
+        b"<< /Length " + str(len(stream)).encode() + b" >>\nstream\n"
+        + stream
+        + b"\nendstream",
+        b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+    ]
+    result = bytearray(b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n")
+    offsets = [0]
+    for object_number, value in enumerate(objects, start=1):
+        offsets.append(len(result))
+        result.extend(f"{object_number} 0 obj\n".encode())
+        result.extend(value)
+        result.extend(b"\nendobj\n")
+    xref_offset = len(result)
+    result.extend(f"xref\n0 {len(objects) + 1}\n".encode())
+    result.extend(b"0000000000 65535 f \n")
+    for offset in offsets[1:]:
+        result.extend(f"{offset:010d} 00000 n \n".encode())
+    result.extend(
+        (
+            f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\n"
+            f"startxref\n{xref_offset}\n%%EOF\n"
+        ).encode()
+    )
+    return bytes(result)
+
+
+def test_data_process_full_contract_without_database(tmp_path: Path) -> None:
+    client, store, _ = make_client(tmp_path)
     created = client.post(
         "/modelTF/data-process",
         json={
@@ -506,8 +587,143 @@ def test_data_process_full_contract_without_database() -> None:
     )
 
 
-def test_external_source_never_returns_fake_success() -> None:
-    client, _ = make_client()
+def test_preview_build_replaces_only_selected_files_and_reports_file_counts(
+    tmp_path: Path,
+) -> None:
+    client, store, _ = make_client(tmp_path)
+    task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "逐文件预览", "process_type": "structured", "config": {}},
+    ).json()["data"]["id"]
+    uploaded = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files=[
+            ("files", ("first.jsonl", b'{"id":1}\n', "application/jsonl")),
+            (
+                "files",
+                ("second.jsonl", b'{"id":2}\n{"id":3}\n', "application/jsonl"),
+            ),
+        ],
+    )
+    assert uploaded.status_code == 200
+    first_source, second_source = uploaded.json()["data"]["files"]
+
+    first_build = client.post(
+        f"/modelTF/data-process/{task_id}/preview/build",
+        json={"source_file_ids": [first_source["id"]]},
+    )
+    assert first_build.status_code == 200
+    first_data = first_build.json()["data"]
+    assert first_data["file_counts"] == {first_source["id"]: 1}
+    assert first_data["files"] == [
+        {
+            "source_file_id": first_source["id"],
+            "preview_count": 1,
+            "status": "completed",
+        }
+    ]
+    first_item = first_data["items"][0]
+    edited = client.put(
+        f"/modelTF/data-process/{task_id}/preview/{first_item['id']}",
+        json={"edited_content": "人工确认后的第一文件预览"},
+    )
+    assert edited.status_code == 200
+
+    second_build = client.post(
+        f"/modelTF/data-process/{task_id}/preview/build",
+        json={"source_file_id": second_source["id"]},
+    )
+    assert second_build.status_code == 200
+    second_data = second_build.json()["data"]
+    assert second_data["file_counts"] == {second_source["id"]: 2}
+    assert second_data["files"] == [
+        {
+            "source_file_id": second_source["id"],
+            "preview_count": 2,
+            "status": "completed",
+        }
+    ]
+    assert {item["source_file_id"] for item in store.previews[task_id]} == {
+        first_source["id"],
+        second_source["id"],
+    }
+    preserved_first = next(
+        item
+        for item in store.previews[task_id]
+        if item["source_file_id"] == first_source["id"]
+    )
+    assert preserved_first["id"] == first_item["id"]
+    assert preserved_first["edited_content"] == "人工确认后的第一文件预览"
+
+    previous_second_ids = {
+        item["id"]
+        for item in store.previews[task_id]
+        if item["source_file_id"] == second_source["id"]
+    }
+    next(
+        source
+        for source in store.sources[task_id]
+        if source["id"] == second_source["id"]
+    )["content"] = '{"id":4}\n'
+    rebuilt = client.post(
+        f"/modelTF/data-process/{task_id}/preview/build",
+        json={"source_file_ids": [second_source["id"]]},
+    )
+    assert rebuilt.status_code == 200
+    assert rebuilt.json()["data"]["file_counts"] == {second_source["id"]: 1}
+    current_second_ids = {
+        item["id"]
+        for item in store.previews[task_id]
+        if item["source_file_id"] == second_source["id"]
+    }
+    assert current_second_ids.isdisjoint(previous_second_ids)
+    assert len(current_second_ids) == 1
+    assert next(
+        item
+        for item in store.previews[task_id]
+        if item["source_file_id"] == first_source["id"]
+    )["id"] == first_item["id"]
+
+
+def test_preview_build_rejects_unknown_and_cross_task_source_file_ids(
+    tmp_path: Path,
+) -> None:
+    client, _, _ = make_client(tmp_path)
+    first_task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "归属任务一", "process_type": "structured", "config": {}},
+    ).json()["data"]["id"]
+    second_task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "归属任务二", "process_type": "structured", "config": {}},
+    ).json()["data"]["id"]
+    foreign_source = client.post(
+        f"/modelTF/data-process/{second_task_id}/source-files",
+        files={"files": ("foreign.jsonl", b'{"id":2}\n', "application/jsonl")},
+    ).json()["data"]["files"][0]
+
+    unknown = client.post(
+        f"/modelTF/data-process/{first_task_id}/preview/build",
+        json={"source_file_ids": ["dpsf_not_found"]},
+    )
+    assert unknown.status_code == 404
+    foreign = client.post(
+        f"/modelTF/data-process/{first_task_id}/preview/build",
+        json={"source_file_id": foreign_source["id"]},
+    )
+    assert foreign.status_code == 404
+    ambiguous = client.post(
+        f"/modelTF/data-process/{first_task_id}/preview/build",
+        json={
+            "source_file_id": foreign_source["id"],
+            "source_file_ids": [foreign_source["id"]],
+        },
+    )
+    assert ambiguous.status_code == 422
+
+
+def test_external_source_never_returns_fake_success(tmp_path: Path) -> None:
+    client, _, _ = make_client(tmp_path)
     task_id = client.post(
         "/modelTF/data-process",
         json={"name": "外部数据", "process_type": "external", "config": {}},
@@ -520,8 +736,8 @@ def test_external_source_never_returns_fake_success() -> None:
     assert response.json()["detail"]["code"] == 501
 
 
-def test_config_validation_and_stop_state() -> None:
-    client, store = make_client()
+def test_config_validation_and_stop_state(tmp_path: Path) -> None:
+    client, store, _ = make_client(tmp_path)
     invalid = client.post(
         "/modelTF/data-process",
         json={
@@ -537,6 +753,28 @@ def test_config_validation_and_stop_state() -> None:
     )
     assert invalid.status_code == 422
 
+    legacy_semantic = client.post(
+        "/modelTF/data-process",
+        json={
+            "name": "旧切分策略",
+            "process_type": "unstructured",
+            "config": {"chunk_method": "semantic"},
+        },
+    )
+    assert legacy_semantic.status_code == 422
+    assert "chunk_method" in legacy_semantic.text
+
+    missing_custom_delimiter = client.post(
+        "/modelTF/data-process",
+        json={
+            "name": "缺少自定义分隔符",
+            "process_type": "unstructured",
+            "config": {"chunk_method": "custom"},
+        },
+    )
+    assert missing_custom_delimiter.status_code == 422
+    assert "custom_delimiter" in missing_custom_delimiter.text
+
     task_id = client.post(
         "/modelTF/data-process",
         json={"name": "可停止任务", "process_type": "structured", "config": {}},
@@ -547,11 +785,11 @@ def test_config_validation_and_stop_state() -> None:
     assert stopped.json()["data"]["status"] == "stopped"
 
 
-def test_upload_batch_is_atomic_and_empty_files_are_rejected() -> None:
-    client, store = make_client()
+def test_upload_batch_is_atomic_and_empty_files_are_rejected(tmp_path: Path) -> None:
+    client, store, storage = make_client(tmp_path)
     task_id = client.post(
         "/modelTF/data-process",
-        json={"name": "批量上传", "process_type": "structured", "config": {}},
+        json={"name": "批量上传", "process_type": "unstructured", "config": {}},
     ).json()["data"]["id"]
 
     duplicate_batch = client.post(
@@ -563,6 +801,18 @@ def test_upload_batch_is_atomic_and_empty_files_are_rejected() -> None:
     )
     assert duplicate_batch.status_code == 400
     assert store.sources[task_id] == []
+    assert _stored_files(storage) == []
+
+    parse_failure = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files=[
+            ("files", ("valid.txt", "先暂存的内容".encode(), "text/plain")),
+            ("files", ("broken.txt", b"\xff", "text/plain")),
+        ],
+    )
+    assert parse_failure.status_code == 400
+    assert store.sources[task_id] == []
+    assert _stored_files(storage) == []
 
     empty = client.post(
         f"/modelTF/data-process/{task_id}/source-files",
@@ -570,10 +820,45 @@ def test_upload_batch_is_atomic_and_empty_files_are_rejected() -> None:
     )
     assert empty.status_code == 400
     assert store.sources[task_id] == []
+    assert _stored_files(storage) == []
 
 
-def test_preprocess_deduplicates_and_quality_filter_removes_short_results() -> None:
-    client, _ = make_client()
+def test_upload_preserves_store_error_when_storage_rollback_fails(
+    tmp_path: Path,
+    monkeypatch: Any,
+) -> None:
+    client, store, storage = make_client(tmp_path)
+    task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "回滚异常", "process_type": "unstructured", "config": {}},
+    ).json()["data"]["id"]
+    cleanup_attempts: list[str] = []
+
+    def fail_store(*_: Any, **__: Any) -> list[dict[str, Any]]:
+        raise ValueError("simulated database transaction failure")
+
+    def fail_cleanup(reference: str, **_: Any) -> bool:
+        cleanup_attempts.append(reference)
+        raise OSError("simulated storage cleanup failure")
+
+    monkeypatch.setattr(store, "add_source_files", fail_store)
+    monkeypatch.setattr(storage, "delete", fail_cleanup)
+
+    response = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files={"files": ("rollback.txt", b"rollback payload", "text/plain")},
+    )
+
+    assert response.status_code == 400
+    assert response.json()["detail"]["message"] == "simulated database transaction failure"
+    assert len(cleanup_attempts) == 1
+    assert store.sources[task_id] == []
+
+
+def test_preprocess_deduplicates_and_quality_filter_removes_short_results(
+    tmp_path: Path,
+) -> None:
+    client, _, _ = make_client(tmp_path)
     task_id = client.post(
         "/modelTF/data-process",
         json={
@@ -651,8 +936,8 @@ def test_stale_generation_worker_cannot_overwrite_new_run(monkeypatch: Any) -> N
     assert store.tasks[task_id]["status"] == "running"
 
 
-def test_result_status_cannot_be_forged_by_client() -> None:
-    client, _ = make_client()
+def test_result_status_cannot_be_forged_by_client(tmp_path: Path) -> None:
+    client, _, _ = make_client(tmp_path)
     task_id = client.post(
         "/modelTF/data-process",
         json={"name": "状态保护", "process_type": "structured", "config": {}},
@@ -664,8 +949,8 @@ def test_result_status_cannot_be_forged_by_client() -> None:
     assert response.status_code == 422
 
 
-def test_start_rebuilds_preview_and_generates_in_one_request() -> None:
-    client, _ = make_client()
+def test_start_rebuilds_preview_and_generates_in_one_request(tmp_path: Path) -> None:
+    client, _, _ = make_client(tmp_path)
     task_id = client.post(
         "/modelTF/data-process",
         json={"name": "一键处理", "process_type": "structured", "config": {}},
@@ -691,14 +976,487 @@ def test_start_rebuilds_preview_and_generates_in_one_request() -> None:
     assert client.get(f"/modelTF/data-process/{task_id}/results").json()["data"]["total"] == 1
 
 
-def test_unsupported_upload_format_returns_415() -> None:
-    client, _ = make_client()
+def test_unsupported_upload_format_returns_415(tmp_path: Path) -> None:
+    client, _, _ = make_client(tmp_path)
     task_id = client.post(
         "/modelTF/data-process",
         json={"name": "格式限制", "process_type": "structured", "config": {}},
     ).json()["data"]["id"]
     response = client.post(
         f"/modelTF/data-process/{task_id}/source-files",
-        files={"files": ("document.pdf", b"not a pdf", "application/pdf")},
+        files={"files": ("payload.exe", b"not supported", "application/octet-stream")},
     )
     assert response.status_code == 415
+
+    legacy = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files={"files": ("document.doc", b"legacy", "application/msword")},
+    )
+    assert legacy.status_code == 415
+    assert "convert the file to .docx" in legacy.json()["detail"]["message"]
+
+
+def test_xlsx_upload_is_accepted_as_structured_records(tmp_path: Path) -> None:
+    client, store, storage = make_client(tmp_path)
+    task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "XLSX 上传", "process_type": "structured", "config": {}},
+    ).json()["data"]["id"]
+    workbook = Workbook()
+    worksheet = workbook.active
+    worksheet.append(["question", "answer"])
+    worksheet.append(["问题一", "答案一"])
+    worksheet.append(["问题二", "答案二"])
+    output = BytesIO()
+    workbook.save(output)
+    workbook.close()
+    original_bytes = output.getvalue()
+
+    response = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files={
+            "files": (
+                "records.xlsx",
+                original_bytes,
+                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            )
+        },
+    )
+    assert response.status_code == 200
+    source = response.json()["data"]["files"][0]
+    assert source["file_format"] == "xlsx"
+    assert source["record_count"] == 2
+    assert source["size_bytes"] == len(original_bytes)
+    assert source["storage_object_id"].startswith("local://data-process/")
+    assert str(storage.root) not in response.text
+    assert storage.read(source["storage_object_id"]) == original_bytes
+
+    stored_source = store.get_source_file(task_id, source["id"])
+    assert stored_source["id"] == source["id"]
+    assert stored_source["storage_object_id"] == source["storage_object_id"]
+    assert stored_source["metadata"]["storage_backend"] == "local"
+    assert stored_source["metadata"]["original_size_bytes"] == len(original_bytes)
+    assert '"question":"问题一"' in stored_source["content"]
+
+    content = client.get(
+        f"/modelTF/data-process/{task_id}/source-files/{source['id']}/content"
+    )
+    assert content.status_code == 200
+    assert '"answer":"答案二"' in content.json()["data"]["content"]
+    preview = client.post(f"/modelTF/data-process/{task_id}/preview/build")
+    assert preview.status_code == 200
+    assert preview.json()["data"]["total"] == 2
+
+
+def test_pdf_raw_preview_streams_original_file_and_supports_ranges(tmp_path: Path) -> None:
+    client, store, _ = make_client(tmp_path)
+    task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "PDF 原件预览", "process_type": "unstructured", "config": {}},
+    ).json()["data"]["id"]
+    original_pdf = _minimal_pdf()
+    uploaded = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files={"files": ("说明 文档.pdf", original_pdf, "application/pdf")},
+    ).json()["data"]["files"][0]
+    raw_url = f"/modelTF/data-process/{task_id}/source-files/{uploaded['id']}/raw"
+
+    full = client.get(raw_url)
+    assert full.status_code == 200
+    assert full.content == original_pdf
+    assert full.headers["content-type"] == "application/pdf"
+    assert full.headers["accept-ranges"] == "bytes"
+    assert full.headers["cache-control"] == "private, no-store"
+    assert full.headers["content-length"] == str(len(original_pdf))
+    assert full.headers["content-disposition"].startswith("inline;")
+    assert "%E8%AF%B4%E6%98%8E%20%E6%96%87%E6%A1%A3.pdf" in full.headers[
+        "content-disposition"
+    ]
+    assert full.headers["etag"] == f'"{uploaded["checksum_sha256"]}"'
+
+    partial = client.get(raw_url, headers={"Range": "bytes=5-14"})
+    assert partial.status_code == 206
+    assert partial.content == original_pdf[5:15]
+    assert partial.headers["content-range"] == f"bytes 5-14/{len(original_pdf)}"
+    assert partial.headers["content-length"] == "10"
+
+    suffix = client.get(raw_url, headers={"Range": "bytes=-8"})
+    assert suffix.status_code == 206
+    assert suffix.content == original_pdf[-8:]
+
+    invalid = client.get(raw_url, headers={"Range": "bytes=0-1,4-5"})
+    assert invalid.status_code == 416
+    assert invalid.headers["content-range"] == f"bytes */{len(original_pdf)}"
+
+    pages_url = (
+        f"/modelTF/data-process/{task_id}/source-files/{uploaded['id']}/pdf-pages"
+    )
+    pages = client.get(pages_url)
+    assert pages.status_code == 200
+    assert pages.json()["data"] == {
+        "page_count": 1,
+        "pages": [
+            {
+                "page_number": 1,
+                "source_start": 0,
+                "source_end": len("Hello PDF"),
+            }
+        ],
+    }
+
+    legacy_id = "dpsf_legacy_pdf"
+    store.add_source_file(
+        task_id,
+        id=legacy_id,
+        storage_object_id=f"db://data-process/{task_id}/{legacy_id}/v1",
+        name="legacy.pdf",
+        content="legacy extracted PDF text",
+        raw_size=len(original_pdf),
+        checksum_sha256="a" * 64,
+        file_format="pdf",
+        record_count=1,
+        metadata={"legacy": True},
+    )
+    legacy = client.get(
+        f"/modelTF/data-process/{task_id}/source-files/{legacy_id}/raw"
+    )
+    assert legacy.status_code == 410
+    legacy_pages = client.get(
+        f"/modelTF/data-process/{task_id}/source-files/{legacy_id}/pdf-pages"
+    )
+    assert legacy_pages.status_code == 410
+
+
+def test_raw_inline_preview_rejects_non_pdf_source(tmp_path: Path) -> None:
+    client, _, _ = make_client(tmp_path)
+    task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "非 PDF 原件", "process_type": "unstructured", "config": {}},
+    ).json()["data"]["id"]
+    uploaded = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files={"files": ("notes.txt", b"plain source text", "text/plain")},
+    ).json()["data"]["files"][0]
+
+    response = client.get(
+        f"/modelTF/data-process/{task_id}/source-files/{uploaded['id']}/raw"
+    )
+    assert response.status_code == 415
+    pages_response = client.get(
+        f"/modelTF/data-process/{task_id}/source-files/{uploaded['id']}/pdf-pages"
+    )
+    assert pages_response.status_code == 415
+
+
+def test_delete_source_removes_owned_local_object_and_accepts_legacy_db_reference(
+    tmp_path: Path,
+) -> None:
+    client, store, storage = make_client(tmp_path)
+    task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "删除原件", "process_type": "unstructured", "config": {}},
+    ).json()["data"]["id"]
+    uploaded = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files={"files": ("原件.txt", "本地原始内容".encode(), "text/plain")},
+    ).json()["data"]["files"][0]
+    reference = uploaded["storage_object_id"]
+    assert storage.read(reference) == "本地原始内容".encode()
+
+    deleted = client.delete(
+        f"/modelTF/data-process/{task_id}/source-files/{uploaded['id']}"
+    )
+    assert deleted.status_code == 200
+    assert deleted.json()["data"]["storage_cleanup_pending"] is False
+    with pytest.raises(DataProcessStorageError, match="does not exist"):
+        storage.read(reference)
+
+    legacy_id = "dpsf_legacy"
+    store.add_source_file(
+        task_id,
+        id=legacy_id,
+        storage_object_id=f"db://data-process/{task_id}/{legacy_id}/v1",
+        name="legacy.txt",
+        content="旧记录正文",
+        raw_size=len("旧记录正文".encode()),
+        checksum_sha256="a" * 64,
+        file_format="txt",
+        record_count=1,
+        metadata={"legacy": True},
+    )
+    legacy_deleted = client.delete(
+        f"/modelTF/data-process/{task_id}/source-files/{legacy_id}"
+    )
+    assert legacy_deleted.status_code == 200
+    assert legacy_deleted.json()["data"]["storage_cleanup_pending"] is False
+
+
+def test_delete_reports_pending_cleanup_after_database_soft_delete(
+    tmp_path: Path,
+    monkeypatch: Any,
+) -> None:
+    client, store, storage = make_client(tmp_path)
+    task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "待清理原件", "process_type": "unstructured", "config": {}},
+    ).json()["data"]["id"]
+    uploaded = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files={"files": ("pending.txt", b"pending cleanup", "text/plain")},
+    ).json()["data"]["files"][0]
+
+    def fail_cleanup(*_: Any, **__: Any) -> bool:
+        raise OSError("simulated storage failure")
+
+    monkeypatch.setattr(storage, "delete", fail_cleanup)
+    response = client.delete(
+        f"/modelTF/data-process/{task_id}/source-files/{uploaded['id']}"
+    )
+
+    assert response.status_code == 200
+    assert response.json()["data"]["storage_cleanup_pending"] is True
+    with pytest.raises(NotFoundError):
+        store.get_source_file(task_id, uploaded["id"])
+    assert storage.read(uploaded["storage_object_id"]) == b"pending cleanup"
+
+
+def test_delete_rejects_polluted_reference_owned_by_another_source(tmp_path: Path) -> None:
+    client, store, storage = make_client(tmp_path)
+    task_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "归属校验", "process_type": "unstructured", "config": {}},
+    ).json()["data"]["id"]
+    uploaded = client.post(
+        f"/modelTF/data-process/{task_id}/source-files",
+        files={"files": ("safe.txt", b"owned content", "text/plain")},
+    ).json()["data"]["files"][0]
+    target_reference = uploaded["storage_object_id"]
+
+    polluted_id = "dpsf_polluted"
+    store.add_source_file(
+        task_id,
+        id=polluted_id,
+        storage_object_id=target_reference,
+        name="polluted.txt",
+        content="polluted",
+        raw_size=8,
+        checksum_sha256="b" * 64,
+        file_format="txt",
+        record_count=1,
+        metadata={},
+    )
+    rejected = client.delete(
+        f"/modelTF/data-process/{task_id}/source-files/{polluted_id}"
+    )
+    assert rejected.status_code == 400
+    assert storage.read(target_reference) == b"owned content"
+    assert store.get_source_file(task_id, polluted_id)["id"] == polluted_id
+
+
+def test_upload_format_must_match_process_type(tmp_path: Path) -> None:
+    client, _, _ = make_client(tmp_path)
+    structured_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "结构化格式约束", "process_type": "structured", "config": {}},
+    ).json()["data"]["id"]
+    structured_pdf = client.post(
+        f"/modelTF/data-process/{structured_id}/source-files",
+        files={"files": ("manual.pdf", b"not parsed", "application/pdf")},
+    )
+    assert structured_pdf.status_code == 415
+
+    unstructured_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "非结构化格式约束", "process_type": "unstructured", "config": {}},
+    ).json()["data"]["id"]
+    unstructured_xlsx = client.post(
+        f"/modelTF/data-process/{unstructured_id}/source-files",
+        files={"files": ("records.xlsx", b"not parsed", "application/octet-stream")},
+    )
+    assert unstructured_xlsx.status_code == 415
+
+    external_id = client.post(
+        "/modelTF/data-process",
+        json={"name": "外部数据格式约束", "process_type": "external", "config": {}},
+    ).json()["data"]["id"]
+    external_upload = client.post(
+        f"/modelTF/data-process/{external_id}/source-files",
+        files={"files": ("records.jsonl", b'{"id":1}', "application/jsonl")},
+    )
+    assert external_upload.status_code == 409
+
+
+def _preview_task(
+    content: str,
+    *,
+    options: list[str],
+    config: dict[str, Any] | None = None,
+    source_id: str = "source-1",
+    file_format: str = "txt",
+) -> list[dict[str, Any]]:
+    task_config = {
+        "preprocess_options": options,
+        "chunk_size": 200,
+        "chunk_overlap": 20,
+        "min_chunk_size": 20,
+        **(config or {}),
+    }
+    return data_process_endpoint._build_preview_items(
+        {"process_type": "unstructured", "config": task_config},
+        [
+            {
+                "id": source_id,
+                "name": f"{source_id}.{file_format}",
+                "file_format": file_format,
+                "content": content,
+            }
+        ],
+    )
+
+
+def test_default_and_structure_preview_split_headings_without_cross_section_overlap() -> None:
+    content = (
+        "# 第一章\n"
+        + " ".join(f"alpha{index}" for index in range(18))
+        + "\n# 第二章\n"
+        + " ".join(f"beta{index}" for index in range(18))
+    )
+    normalized = normalize_text(content)
+    second_chapter_start = normalized.index("# 第二章")
+    common_config = {"chunk_size": 10, "chunk_overlap": 3, "min_chunk_size": 4}
+
+    default_items = _preview_task(
+        content,
+        options=["preserve_context"],
+        config=common_config,
+    )
+    structure_items = _preview_task(
+        content,
+        options=["preserve_context"],
+        config={**common_config, "chunk_method": "structure"},
+    )
+
+    def snapshot(items: list[dict[str, Any]]) -> list[tuple[Any, ...]]:
+        return [
+            (
+                item["original_content"],
+                item["source_start"],
+                item["source_end"],
+                item["source_start_line"],
+                item["source_end_line"],
+            )
+            for item in items
+        ]
+
+    assert snapshot(default_items) == snapshot(structure_items)
+    assert all(
+        item["original_content"]
+        == normalized[item["source_start"] : item["source_end"]]
+        for item in structure_items
+    )
+    assert all(
+        not (item["source_start"] < second_chapter_start < item["source_end"])
+        for item in structure_items
+    )
+    second_chapter_items = [
+        item for item in structure_items if item["source_start"] >= second_chapter_start
+    ]
+    assert second_chapter_items[0]["source_start"] == second_chapter_start
+    assert second_chapter_items[0]["original_content"].startswith("# 第二章")
+
+
+def test_every_unstructured_preprocess_option_changes_preview_behavior() -> None:
+    repeated = "@" * 120
+    assert len(_preview_task(repeated, options=[])) == 1
+    assert _preview_task(repeated, options=["clean_invalid_content"]) == []
+
+    structured_text = "# 第一章\n" + "甲。" * 30 + "\n# 第二章\n" + "乙。" * 30
+    detected = _preview_task(
+        structured_text,
+        options=["detect_document_structure"],
+        config={"chunk_method": "fixed", "chunk_size": 20, "min_chunk_size": 5},
+    )
+    undetected = _preview_task(
+        structured_text,
+        options=[],
+        config={"chunk_method": "fixed", "chunk_size": 20, "min_chunk_size": 5},
+    )
+    assert all("heading_path" in item["quality_score"] for item in detected)
+    assert {tuple(item["quality_score"]["heading_path"]) for item in detected} == {
+        ("第一章",),
+        ("第二章",),
+    }
+    assert all("heading_path" not in item["quality_score"] for item in undetected)
+    assert all(not ("第一章" in item["edited_content"] and "第二章" in item["edited_content"]) for item in detected)
+
+    short_lead = "a b. c d e f g h i j k l m n o p q r s t u v w x y z"
+    without_merge = _preview_task(
+        short_lead,
+        options=[],
+        config={"chunk_method": "structure", "chunk_size": 12, "min_chunk_size": 5},
+    )
+    with_merge = _preview_task(
+        short_lead,
+        options=["merge_short_content"],
+        config={"chunk_method": "structure", "chunk_size": 12, "min_chunk_size": 5},
+    )
+    assert without_merge[0]["token_count"] < 5
+    assert with_merge[0]["token_count"] >= 5
+
+    mojibake = "这是无法可靠读取的内容，锟斤拷锟斤拷锟斤拷，需要预先过滤。"
+    assert len(_preview_task(mojibake, options=[])) == 1
+    assert _preview_task(mojibake, options=["filter_low_quality"]) == []
+
+    first = "alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu nu xi omicron pi rho sigma tau upsilon phi chi psi omega"
+    second = "alpha beta gamma, delta epsilon zeta eta theta iota kappa lambda mu nu xi omicron pi rho sigma tau upsilon phi chi psi omega"
+    sources = [
+        {"id": "near-1", "name": "one.txt", "file_format": "txt", "content": first},
+        {"id": "near-2", "name": "two.txt", "file_format": "txt", "content": second},
+    ]
+    base_task = {
+        "process_type": "unstructured",
+        "config": {
+            "chunk_method": "fixed",
+            "chunk_size": 200,
+            "chunk_overlap": 0,
+            "min_chunk_size": 1,
+            "preprocess_options": [],
+        },
+    }
+    assert len(data_process_endpoint._build_preview_items(base_task, sources)) == 2
+    deduplicated_task = deepcopy(base_task)
+    deduplicated_task["config"]["preprocess_options"] = ["deduplicate_content"]
+    assert len(data_process_endpoint._build_preview_items(deduplicated_task, sources)) == 1
+
+    context_text = " ".join(f"token{index}" for index in range(45))
+    no_context = _preview_task(
+        context_text,
+        options=[],
+        config={"chunk_method": "fixed", "chunk_size": 20, "chunk_overlap": 5},
+    )
+    with_context = _preview_task(
+        context_text,
+        options=["preserve_context"],
+        config={"chunk_method": "fixed", "chunk_size": 20, "chunk_overlap": 5},
+    )
+    assert no_context[1]["source_start"] >= no_context[0]["source_end"]
+    assert with_context[1]["source_start"] < with_context[0]["source_end"]
+
+    sensitive = "联系人：张三，手机 13800138000，邮箱 user@example.com。"
+    plain = _preview_task(sensitive, options=[])[0]
+    masked = _preview_task(sensitive, options=["desensitize"])[0]
+    assert "张三" in plain["edited_content"]
+    assert "联系人:[NAME]" in masked["edited_content"]
+    assert "[PHONE]" in masked["edited_content"]
+    assert "[EMAIL]" in masked["edited_content"]
+
+
+def test_stored_binary_document_text_is_not_reparsed_as_binary() -> None:
+    for file_format in ("pdf", "docx", "pptx"):
+        items = _preview_task(
+            f"{file_format.upper()} 已抽取正文，可直接进入切片处理。",
+            options=[],
+            file_format=file_format,
+        )
+        assert len(items) == 1
+        assert "已抽取正文" in items[0]["edited_content"]
diff --git a/backend/tests/test_data_process_storage.py b/backend/tests/test_data_process_storage.py
new file mode 100644
index 0000000..b31f6c2
--- /dev/null
+++ b/backend/tests/test_data_process_storage.py
@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+
+import pytest
+
+from app.modules.data_process import storage as storage_module
+from app.modules.data_process.storage import (
+    DataProcessStorageError,
+    LocalDataProcessStorage,
+    StagedSourceObject,
+)
+
+
+def _stage(
+    storage: LocalDataProcessStorage,
+    *,
+    batch_id: str = "batch-main",
+    task_id: str = "task-1",
+    source_file_id: str = "source-1",
+    version: int = 1,
+    name: str = "source.txt",
+    content: bytes = b"payload",
+) -> StagedSourceObject:
+    return storage.stage_bytes(
+        batch_id=batch_id,
+        task_id=task_id,
+        source_file_id=source_file_id,
+        version=version,
+        name=name,
+        content=content,
+    )
+
+
+def _create_symlink(link: Path, target: Path, *, target_is_directory: bool = False) -> None:
+    try:
+        link.symlink_to(target, target_is_directory=target_is_directory)
+    except (NotImplementedError, OSError) as exc:
+        pytest.skip(f"当前平台不支持创建测试所需的符号链接: {exc}")
+
+
+def _assert_staging_empty(storage: LocalDataProcessStorage) -> None:
+    assert list((storage.root / ".staging").iterdir()) == []
+
+
+def test_stage_publish_read_delete_roundtrip_with_unicode_filename(tmp_path: Path) -> None:
+    storage = LocalDataProcessStorage(tmp_path / "storage")
+    content = "第一行\n第二行，100% 完成".encode()
+
+    staged = _stage(
+        storage,
+        name="中文 数据 100%.csv",
+        content=content,
+    )
+
+    assert "%20" in staged.reference
+    assert "%25" in staged.reference
+    storage.publish([staged])
+
+    assert storage.read(staged.reference) == content
+    assert storage.delete(staged.reference) is True
+    assert storage.delete(staged.reference) is False
+    _assert_staging_empty(storage)
+
+
+def test_db_reference_is_left_to_database_storage(tmp_path: Path) -> None:
+    storage = LocalDataProcessStorage(tmp_path / "storage")
+
+    assert storage.read("db://source-files/source-1") is None
+    assert storage.delete("db://source-files/source-1") is False
+
+
+def test_owned_source_can_be_streamed_by_byte_range(tmp_path: Path) -> None:
+    storage = LocalDataProcessStorage(tmp_path / "storage")
+    content = b"0123456789abcdef"
+    staged = _stage(storage, content=content)
+    storage.publish([staged])
+
+    assert storage.file_size(
+        staged.reference,
+        expected_task_id="task-1",
+        expected_source_file_id="source-1",
+    ) == len(content)
+    assert b"".join(storage.iter_bytes(
+        staged.reference,
+        expected_task_id="task-1",
+        expected_source_file_id="source-1",
+        expected_size=len(content),
+        start=4,
+        length=6,
+        chunk_size=2,
+    )) == b"456789"
+
+    with pytest.raises(DataProcessStorageError, match="owner mismatch"):
+        storage.file_size(
+            staged.reference,
+            expected_task_id="another-task",
+            expected_source_file_id="source-1",
+        )
+    with pytest.raises(DataProcessStorageError, match="does not match metadata"):
+        b"".join(storage.iter_bytes(
+            staged.reference,
+            expected_task_id="task-1",
+            expected_source_file_id="source-1",
+            expected_size=len(content) + 1,
+        ))
+
+
+@pytest.mark.parametrize(
+    "reference",
+    [
+        "local://data-process/../source-1/v1/file.txt",
+        "local://data-process/task-1/source-1/v1/file%2Fname.txt",
+        "local://data-process/task-1/source-1/v1/file.txt?download=1",
+        "local://data-process/task-1/source-1/v1/file.txt#fragment",
+        "https://data-process/task-1/source-1/v1/file.txt",
+    ],
+    ids=[
+        "parent-traversal",
+        "percent-encoded-slash",
+        "query",
+        "fragment",
+        "wrong-scheme",
+    ],
+)
+def test_unsafe_references_are_rejected(tmp_path: Path, reference: str) -> None:
+    storage = LocalDataProcessStorage(tmp_path / "storage")
+
+    with pytest.raises(DataProcessStorageError):
+        storage.read(reference)
+    with pytest.raises(DataProcessStorageError):
+        storage.delete(reference)
+
+
+def test_publish_rejects_intermediate_directory_symlink(tmp_path: Path) -> None:
+    storage = LocalDataProcessStorage(tmp_path / "storage")
+    outside = tmp_path / "outside"
+    outside.mkdir()
+    staged = _stage(storage, task_id="linked-task")
+    _create_symlink(
+        storage.root / "linked-task",
+        outside,
+        target_is_directory=True,
+    )
+
+    with pytest.raises(DataProcessStorageError, match="symlink|non-directory"):
+        storage.publish([staged])
+
+    assert list(outside.iterdir()) == []
+    _assert_staging_empty(storage)
+
+
+def test_target_symlink_is_never_followed_or_deleted(tmp_path: Path) -> None:
+    storage = LocalDataProcessStorage(tmp_path / "storage")
+    staged = _stage(storage, task_id="task-link", source_file_id="source-link")
+    outside_file = tmp_path / "outside.txt"
+    outside_file.write_bytes(b"outside sentinel")
+    final_path = storage.root.joinpath(*staged._relative_path.parts)
+    final_path.parent.mkdir(parents=True)
+    _create_symlink(final_path, outside_file)
+
+    with pytest.raises(DataProcessStorageError, match="already exists"):
+        storage.publish([staged])
+    with pytest.raises(DataProcessStorageError, match="regular file"):
+        storage.read(staged.reference)
+    with pytest.raises(DataProcessStorageError, match="non-regular"):
+        storage.delete(staged.reference)
+
+    assert final_path.is_symlink()
+    assert outside_file.read_bytes() == b"outside sentinel"
+    _assert_staging_empty(storage)
+
+
+def test_publish_rolls_back_first_object_when_second_target_collides(tmp_path: Path) -> None:
+    storage = LocalDataProcessStorage(tmp_path / "storage")
+    existing = _stage(
+        storage,
+        batch_id="batch-existing",
+        source_file_id="source-existing",
+        content=b"existing content",
+    )
+    storage.publish([existing])
+
+    first = _stage(
+        storage,
+        batch_id="batch-new",
+        source_file_id="source-new",
+        content=b"must be rolled back",
+    )
+    colliding_second = _stage(
+        storage,
+        batch_id="batch-new",
+        source_file_id="source-existing",
+        content=b"must not replace existing content",
+    )
+
+    with pytest.raises(DataProcessStorageError, match="already exists"):
+        storage.publish([first, colliding_second])
+
+    with pytest.raises(DataProcessStorageError, match="does not exist"):
+        storage.read(first.reference)
+    assert storage.read(existing.reference) == b"existing content"
+    _assert_staging_empty(storage)
+
+
+def test_publish_rejects_manually_forged_staged_object(tmp_path: Path) -> None:
+    storage = LocalDataProcessStorage(tmp_path / "storage")
+    temporary_path = storage.root / ".staging" / "batch-forged" / "forged.tmp"
+    temporary_path.parent.mkdir()
+    temporary_path.write_bytes(b"forged content")
+    relative_path = PurePosixPath("task-forged", "source-forged", "v1", "forged.txt")
+    forged = StagedSourceObject(
+        reference="local://data-process/task-forged/source-forged/v1/forged.txt",
+        _temporary_path=temporary_path,
+        _relative_path=relative_path,
+    )
+
+    with pytest.raises(DataProcessStorageError, match="was not issued"):
+        storage.publish([forged])
+    with pytest.raises(DataProcessStorageError, match="was not issued"):
+        storage.discard([forged])
+
+    assert temporary_path.read_bytes() == b"forged content"
+    assert not storage.root.joinpath(*relative_path.parts).exists()
+
+
+def test_relative_storage_configuration_is_anchored_to_backend_root(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    relative_configuration = Path("relative-storage") / tmp_path.name
+    backend_root = Path(storage_module.__file__).resolve().parents[3]
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("DATA_PROCESS_STORAGE_DIR", str(relative_configuration))
+    storage_module.get_data_process_storage.cache_clear()
+
+    try:
+        configured_root = storage_module._configured_storage_root()
+        assert configured_root == backend_root / relative_configuration
+        assert not configured_root.exists()
+    finally:
+        storage_module.get_data_process_storage.cache_clear()
diff --git a/backend/tests/test_data_process_store.py b/backend/tests/test_data_process_store.py
new file mode 100644
index 0000000..0e7ba29
--- /dev/null
+++ b/backend/tests/test_data_process_store.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import pytest
+
+from app.modules.data_process.store import (
+    DataProcessStoreError,
+    _source_storage_descriptor,
+)
+
+
+def test_source_storage_descriptor_accepts_owned_local_and_legacy_db_references() -> None:
+    task_id = "dpt_task"
+    source_file_id = "dpsf_source"
+    local_reference = (
+        f"local://data-process/{task_id}/{source_file_id}/v1/source%20100%25.csv"
+    )
+
+    reference, metadata = _source_storage_descriptor(
+        {
+            "storage_object_id": local_reference,
+            "metadata": {"storage_backend": "spoofed", "content_type": "text/csv"},
+        },
+        task_id,
+        source_file_id,
+    )
+    assert reference == local_reference
+    assert metadata == {"storage_backend": "local", "content_type": "text/csv"}
+
+    legacy_reference, legacy_metadata = _source_storage_descriptor(
+        {"metadata": {"legacy": True}},
+        task_id,
+        source_file_id,
+    )
+    assert legacy_reference == f"db://data-process/{task_id}/{source_file_id}/v1"
+    assert legacy_metadata == {"storage_backend": "database", "legacy": True}
+
+
+@pytest.mark.parametrize(
+    "reference",
+    [
+        "local://data-process/dpt_other/dpsf_source/v1/source.txt",
+        "db://data-process/dpt_task/dpsf_other/v1",
+        "/var/tmp/source.txt",
+    ],
+)
+def test_source_storage_descriptor_rejects_unowned_or_unsupported_references(
+    reference: str,
+) -> None:
+    with pytest.raises(DataProcessStoreError):
+        _source_storage_descriptor(
+            {"storage_object_id": reference},
+            "dpt_task",
+            "dpsf_source",
+        )