Merge branch 'develop' into refactor/duplication-api

refactor(api): 拆分 duplication.ts 为目录结构（types/duplication/index）
将 99 行的 duplication.ts 拆分为目录化结构： - types.ts: 类型定义（查重记录/片段/详情/响应） - duplication.ts: 全部 5 个 API 函数 - index.ts: 统一入口 re-export，保持 @/api/duplication 路径向后兼容
2026-07-27 12:34:51 +08:00 · 2026-07-26 17:17:09 +08:00
712 changed files with 22702 additions and 79685 deletions
@@ -21,8 +21,20 @@ on:
 permissions:
  contents: read
 concurrency:
-  group: ci-pipeline-${{ gitea.ref }}
-  cancel-in-progress: true
+  group: ci-pipeline-${{ gitea.event_name }}-${{ gitea.ref }}
+  # PR事件取消进行中的旧run，push事件不取消（确保完整CI跑完）
+  cancel-in-progress: ${{ gitea.event_name == 'pull_request' }}
+env:
+  CI_PG_HOST: host.docker.internal
+  CI_LOCAL_PG_PORT: "5432"
+  CI_PG_USER: postgres
+  CI_PG_PASSWORD: postgres
+  CI_PG_DB: xiaoxia_saas
+  CI_SHARED_PG_PORT: "5433"
+  CI_SHARED_PG_USER: postgres
+  CI_SHARED_PG_PASSWORD: ci_pg_2026!
+  CI_DEFAULT_DB: xiaoxia_saas
+
 jobs:
  check-frontend-only:
    name: Check if frontend-only change
@@ -37,7 +49,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Check changed files
      id: check
      shell: bash
@@ -46,24 +58,56 @@ jobs:
      run: |
        set -eu
        PR_NUMBER=$(echo "$GITHUB_REF" | sed 's|refs/pull/||; s|/.*||')
-        API_URL="${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}/files?limit=300"
-        FILES=$(curl -s -H "Authorization: token ${GITHUB_TOKEN}" "$API_URL" | python3 -c "import sys,json; [print(f['filename']) for f in json.load(sys.stdin)]")
-        FRONTEND_COUNT=$(echo "$FILES" | grep -c '^apps/web/' || true)
-        BACKEND_COUNT=$(echo "$FILES" | grep -cv '^apps/web/' || true)
-        TOTAL=$(echo "$FILES" | grep -cv '^$' || true)
-        echo "变更文件: ${TOTAL} 个 (前端: ${FRONTEND_COUNT}, 后端/公共: ${BACKEND_COUNT})"
-        if [ "$BACKEND_COUNT" = "0" ] && [ "$FRONTEND_COUNT" -gt "0" ]; then
+
+        # 分页获取所有变更文件（修复>300文件时漏判）
+        ALL_FILES=""
+        PAGE=1
+        while true; do
+          API_URL="${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}/files?limit=300&page=${PAGE}"
+          PAGE_FILES=$(curl -s -H "Authorization: token ${GITHUB_TOKEN}" "$API_URL" | python3 -c "import sys,json; files=json.load(sys.stdin); [print(f['filename']) for f in files]; sys.exit(0 if len(files)==300 else 1)" 2>/dev/null || true)
+          PAGE_COUNT=$(echo "$PAGE_FILES" | wc -l)
+          if [ "$PAGE_COUNT" -lt 300 ]; then HAS_MORE=1; else HAS_MORE=0; fi
+          ALL_FILES="${ALL_FILES}${PAGE_FILES}"$'\n'
+          if [ "$HAS_MORE" != "0" ]; then
+            break
+          fi
+          PAGE=$((PAGE + 1))
+        done
+
+        FRONTEND_COUNT=$(echo "$ALL_FILES" | grep -c '^apps/web/' || true)
+        TOTAL=$(echo "$ALL_FILES" | grep -cv '^$' || true)
+        BACKEND_COUNT=$(( TOTAL - FRONTEND_COUNT ))
+
+        # 基础设施文件：改了就强制全量CI（不跳过任何检查）
+        INFRA_COUNT=$(echo "$ALL_FILES" | grep -cE '^(infra/|Dockerfile|\.gitea/workflows/|scripts/ci/|docker/)' || true)
+
+        echo "变更文件: ${TOTAL} 个 (前端: ${FRONTEND_COUNT}, 后端/公共: ${BACKEND_COUNT}, 基础设施: ${INFRA_COUNT})"
+
+        # 判定是否纯前端/纯后端
+        PURE_FRONTEND=false
+        PURE_BACKEND=false
+        if [ "$BACKEND_COUNT" = "0" ] && [ "$FRONTEND_COUNT" -gt "0" ] && [ "$INFRA_COUNT" = "0" ]; then
+          PURE_FRONTEND=true
+        elif [ "$FRONTEND_COUNT" = "0" ] && [ "$BACKEND_COUNT" -gt "0" ] && [ "$INFRA_COUNT" = "0" ]; then
+          PURE_BACKEND=true
+        fi
+
+        if [ "$PURE_FRONTEND" = "true" ]; then
          echo "skip_backend=true" >> $GITHUB_OUTPUT
          echo "skip_frontend=false" >> $GITHUB_OUTPUT
          echo "✅ 纯前端改动，跳过后端检查"
-        elif [ "$FRONTEND_COUNT" = "0" ] && [ "$BACKEND_COUNT" -gt "0" ]; then
+        elif [ "$PURE_BACKEND" = "true" ]; then
          echo "skip_backend=false" >> $GITHUB_OUTPUT
          echo "skip_frontend=true" >> $GITHUB_OUTPUT
          echo "🔧 纯后端改动，跳过前端检查"
        else
          echo "skip_backend=false" >> $GITHUB_OUTPUT
          echo "skip_frontend=false" >> $GITHUB_OUTPUT
-          echo "🔧 包含全栈变更，运行完整CI"
+          if [ "$INFRA_COUNT" -gt "0" ]; then
+            echo "🏗️  包含基础设施变更，强制运行完整CI"
+          else
+            echo "🔧 包含全栈变更，运行完整CI"
+          fi
        fi

    - name: Report CI trace
@@ -90,7 +134,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -180,7 +224,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -250,7 +294,7 @@ jobs:
    permissions:
      contents: read
    env:
-      DATABASE_URL: postgresql+psycopg://postgres:postgres@host.docker.internal:5432/xiaoxia_saas
+      DATABASE_URL: postgresql+psycopg://${{ env.CI_PG_USER }}:${{ env.CI_PG_PASSWORD }}@${{ env.CI_PG_HOST }}:${{ env.CI_LOCAL_PG_PORT }}/${{ env.CI_PG_DB }}
      USE_IN_MEMORY_DB: 'false'
      CI_USE_SHARED_PG: 'true'
    steps:
@@ -259,7 +303,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -334,13 +378,14 @@ jobs:
      OSS_ACCESS_KEY_SECRET: placeholder
      OSS_BUCKET_NAME: xiaoxia-autocut
      OSS_ENDPOINT: oss-cn-hangzhou.aliyuncs.com
+      JWT_SECRET_KEY: test-jwt-secret-for-ci-only-2026
    steps:
    - name: Checkout code
      shell: sh
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -398,20 +443,21 @@ jobs:
      - validate-type-check
      - validate-migration
    env:
-      DATABASE_URL: postgresql+psycopg://postgres:postgres@host.docker.internal:5432/xiaoxia_saas
+      DATABASE_URL: postgresql+psycopg://${{ env.CI_PG_USER }}:${{ env.CI_PG_PASSWORD }}@${{ env.CI_PG_HOST }}:${{ env.CI_LOCAL_PG_PORT }}/${{ env.CI_PG_DB }}
      USE_IN_MEMORY_DB: 'false'
      CI_USE_SHARED_PG: 'true'
      OSS_ACCESS_KEY_ID: placeholder
      OSS_ACCESS_KEY_SECRET: placeholder
      OSS_BUCKET_NAME: xiaoxia-autocut
      OSS_ENDPOINT: oss-cn-hangzhou.aliyuncs.com
+      JWT_SECRET_KEY: test-jwt-secret-for-ci-only-2026
    steps:
    - name: Checkout code
      shell: sh
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -457,15 +503,13 @@ jobs:
    name: Frontend Lint
    runs-on: ci-l2
    timeout-minutes: 10
-    needs: check-frontend-only
-    if: needs.check-frontend-only.outputs.skip_frontend != 'true'
    steps:
    - name: Checkout code
      shell: sh
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -527,7 +571,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -577,12 +621,7 @@ jobs:
    name: PR Build ${{ matrix.service_display }} Image
    runs-on: runtime-builder
    timeout-minutes: ${{ matrix.timeout }}
-    needs: check-frontend-only
-    if: |
-      github.event_name == 'pull_request' && (
-        (matrix.service == 'web' && needs.check-frontend-only.outputs.skip_frontend != 'true') ||
-        (matrix.service != 'web' && needs.check-frontend-only.outputs.skip_backend != 'true')
-      )
+    if: github.event_name == 'pull_request'
    strategy:
      fail-fast: false
      matrix:
@@ -611,7 +650,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -633,60 +672,83 @@ jobs:
          echo "Docker login failed ($i/3), retrying in 5s..."
          sleep 5
        done
-    - name: Pre-build worker base images (fallback if not exist)
+    - name: Pre-build worker base images (3-level cache)
      if: matrix.service == 'worker'
      id: prebuild
-      shell: sh
+      shell: bash
      run: |
        set -eu
-        REGISTRY="git.xiaoxiajianji.com/xiaoxia-saas"
-        BASE_BUILDER="${REGISTRY}/worker-base-builder:latest"
-        BASE_RUNTIME="${REGISTRY}/worker-base-runtime:latest"
-        
-        # 尝试拉取基础镜像
-        echo "检查基础镜像..."
-        if docker pull "$BASE_BUILDER" 2>/dev/null && docker pull "$BASE_RUNTIME" 2>/dev/null; then
-          echo "基础镜像已存在，使用远程镜像"
-          echo "fallback=false" >> $GITHUB_OUTPUT
-        else
-          echo "基础镜像不存在，本地构建（fallback模式）..."
-          
-          # 尝试用buildx构建，失败则回退到普通docker build（DooD模式下buildx builder偶发崩溃）
-          BUILDER_NAME="ci-pr-builder-${GITHUB_RUN_ID:-local}"
-          BUILDX_AVAILABLE=true
-          if ! docker buildx create --use --name "$BUILDER_NAME" --driver docker-container > /dev/null 2>&1; then
-            BUILDX_AVAILABLE=false
-          fi
-          if [ "$BUILDX_AVAILABLE" = true ] && ! docker buildx inspect --bootstrap > /dev/null 2>&1; then
-            BUILDX_AVAILABLE=false
-            docker buildx rm "$BUILDER_NAME" > /dev/null 2>&1 || true
-          fi
-          
-          build_base() {
-            local df="$1"
-            local tag="$2"
-            local name="$3"
-            if [ "$BUILDX_AVAILABLE" = true ]; then
-              echo "构建 $name（buildx）..."
-              if docker buildx build --load -f "$df" -t "$tag" . > /dev/null 2>&1; then
-                echo "$name 构建成功"
-                return 0
-              fi
-              echo "buildx失败，回退到普通docker build"
-              BUILDX_AVAILABLE=false
-              docker buildx rm "$BUILDER_NAME" > /dev/null 2>&1 || true
-            fi
-            echo "构建 $name（docker build）..."
-            docker build -f "$df" -t "$tag" .
-          }
-          
-          build_base infra/docker/worker-base-builder.Dockerfile "$BASE_BUILDER" "worker-base-builder"
-          build_base infra/docker/worker-base-runtime.Dockerfile "$BASE_RUNTIME" "worker-base-runtime"
-          
-          echo "fallback=true" >> $GITHUB_OUTPUT
-          echo "基础镜像本地构建完成"
-        fi
+        GITEA_REGISTRY="git.xiaoxiajianji.com/xiaoxia-saas"
+        ACR_REGISTRY="xiaoxia-registry.cn-hangzhou.cr.aliyuncs.com/xiaoxiakeji"
+        GITEA_BUILDER="${GITEA_REGISTRY}/worker-base-builder:latest"
+        GITEA_RUNTIME="${GITEA_REGISTRY}/worker-base-runtime:latest"
+        ACR_BUILDER="${ACR_REGISTRY}/worker-base-builder:latest"
+        ACR_RUNTIME="${ACR_REGISTRY}/worker-base-runtime:latest"

+        # L1: 本地daemon缓存（DooD模式8runner共享宿主机daemon）
+        echo "=== L1 本地缓存 ==="
+        if docker image inspect "$ACR_BUILDER" > /dev/null 2>&1 \
+           && docker image inspect "$ACR_RUNTIME" > /dev/null 2>&1; then
+          echo "本地缓存命中"
+          echo "has_local_base=true" >> $GITHUB_OUTPUT
+          exit 0
+        fi
+        echo "本地无缓存"
+
+        # L2: Gitea registry缓存（内网快）
+        echo "=== L2 Registry拉取 ==="
+        if docker pull "$GITEA_BUILDER" 2>/dev/null && docker pull "$GITEA_RUNTIME" 2>/dev/null; then
+          echo "Registry拉取成功，重tag供Dockerfile使用"
+          docker tag "$GITEA_BUILDER" "$ACR_BUILDER"
+          docker tag "$GITEA_RUNTIME" "$ACR_RUNTIME"
+          echo "has_local_base=true" >> $GITHUB_OUTPUT
+          exit 0
+        fi
+        echo "Registry无缓存，需本地构建"
+
+        # L3: 本地构建
+        echo "=== L3 本地构建 ==="
+        BUILDER_NAME="ci-pr-builder-${GITHUB_RUN_ID:-local}"
+        if ! docker buildx inspect "$BUILDER_NAME" > /dev/null 2>&1; then
+          docker buildx create --use --name "$BUILDER_NAME" --driver docker-container
+        else
+          docker buildx use "$BUILDER_NAME"
+        fi
+        docker buildx inspect --bootstrap > /dev/null 2>&1
+
+        echo "构建 worker-base-builder..."
+        for attempt in 1 2 3; do
+          if docker buildx build --load -f infra/docker/worker-base-builder.Dockerfile -t "$ACR_BUILDER" .; then
+            echo "worker-base-builder 构建成功"
+            break
+          fi
+          echo "worker-base-builder 失败，重试 $attempt/3..."
+          docker buildx rm "$BUILDER_NAME" 2>/dev/null || true
+          docker buildx create --use --name "$BUILDER_NAME" --driver docker-container
+          sleep 3
+        done
+
+        echo "构建 worker-base-runtime..."
+        for attempt in 1 2 3; do
+          if docker buildx build --load -f infra/docker/worker-base-runtime.Dockerfile -t "$ACR_RUNTIME" .; then
+            echo "worker-base-runtime 构建成功"
+            break
+          fi
+          echo "worker-base-runtime 失败，重试 $attempt/3..."
+          docker buildx rm "$BUILDER_NAME" 2>/dev/null || true
+          docker buildx create --use --name "$BUILDER_NAME" --driver docker-container
+          sleep 3
+        done
+
+        # 推送到Gitea registry供后续复用
+        echo "=== 推送缓存到Registry ==="
+        docker tag "$ACR_BUILDER" "$GITEA_BUILDER"
+        docker tag "$ACR_RUNTIME" "$GITEA_RUNTIME"
+        docker push "$GITEA_BUILDER" 2>/dev/null || echo "push builder失败（不影响）"
+        docker push "$GITEA_RUNTIME" 2>/dev/null || echo "push runtime失败（不影响）"
+
+        echo "has_local_base=true" >> $GITHUB_OUTPUT
+        echo "基础镜像构建完成"
    - name: Build PR image (verify only, no push)
      shell: sh
      run: |
@@ -700,15 +762,15 @@ jobs:
          EXTRA_BUILD_ARGS="$EXTRA_BUILD_ARGS NGINX_CONF=infra/docker/nginx-staging.conf"
        fi

-        # Worker fallback模式：基础镜像本地已构建，用普通docker build绕过buildx
-        if [ "${{ matrix.service }}" = "worker" ] && [ "${{ steps.prebuild.outputs.fallback }}" = "true" ]; then
-          echo "Fallback模式：用普通docker build（基础镜像本地已构建）"
+        # Worker有本地base镜像时：用BuildKit直接构建（快，无需起buildx容器）
+        if [ "${{ matrix.service }}" = "worker" ] && [ "${{ steps.prebuild.outputs.has_local_base }}" = "true" ]; then
+          echo "本地base镜像已就绪，BuildKit快速构建"
          BUILD_ARG_STR=""
          for arg in $EXTRA_BUILD_ARGS; do
            BUILD_ARG_STR="$BUILD_ARG_STR --build-arg $arg"
          done
-          docker build -f ${{ matrix.dockerfile }} -t "${IMAGE_TAG}" $BUILD_ARG_STR .
-          echo "Fallback PR Build successful"
+          DOCKER_BUILDKIT=1 docker build -f ${{ matrix.dockerfile }} -t "${IMAGE_TAG}" $BUILD_ARG_STR .
+          echo "快速构建成功"
          exit 0
        fi

@@ -795,7 +857,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -927,7 +989,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -1079,14 +1141,32 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
    - name: Run Playwright E2E on staging
      shell: bash
      run: |
-        bash scripts/ci/run_staging_tests.sh e2e
+        set -eu
+        # DooD模式下不能用-v挂载（宿主机路径与CI容器路径不一致）
+        # 改用 docker create + docker cp 方式把代码拷进容器
+        CONTAINER_NAME="staging-e2e-${GITHUB_SHA::8}"
+        docker rm -f "$CONTAINER_NAME" 2>/dev/null || true
+        docker create --name "$CONTAINER_NAME" --ipc=host \
+          -e E2E_BASE_URL=https://staging.xiaoxiajianji.com \
+          -e E2E_API_BASE=https://staging-api.xiaoxiajianji.com/api/v1 \
+          -e E2E_BROWSER_CHANNEL=chromium \
+          -e PLAYWRIGHT_HEADLESS=1 \
+          -w /workspace/apps/web \
+          git.xiaoxiajianji.com/xiaoxia/base/playwright:v1.45.0-jammy \
+          sh -lc "npm ci && npx playwright test --reporter=line --project=chromium e2e/auth.spec.ts e2e/auth-guard.spec.ts e2e/core-upload.spec.ts e2e/core-generation.spec.ts"
+        docker cp apps "$CONTAINER_NAME:/workspace/"
+        docker cp package-lock.json "$CONTAINER_NAME:/workspace/" 2>/dev/null || true
+        docker start -a "$CONTAINER_NAME"
+        EXIT_CODE=$(docker wait "$CONTAINER_NAME")
+        docker rm "$CONTAINER_NAME" 2>/dev/null || true
+        exit $EXIT_CODE

    - name: Job duration summary
      if: always()
@@ -1126,14 +1206,30 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
    - name: Run API integration tests on staging
      shell: bash
      run: |
-        bash scripts/ci/run_staging_tests.sh api
+        set -eu
+        # DooD模式下不能用-v挂载（宿主机路径与CI容器路径不一致）
+        # 改用 docker create + docker cp 方式把代码拷进容器
+        CONTAINER_NAME="staging-api-tests-${GITHUB_SHA::8}"
+        docker rm -f "$CONTAINER_NAME" 2>/dev/null || true
+        docker create --name "$CONTAINER_NAME" \
+          -e E2E_BASE_URL=https://staging.xiaoxiajianji.com \
+          -e E2E_API_BASE=https://staging-api.xiaoxiajianji.com/api/v1 \
+          -w /workspace/apps/web \
+          git.xiaoxiajianji.com/xiaoxia/base/playwright:v1.45.0-jammy \
+          sh -lc 'npm ci && npx playwright test --reporter=line e2e/test_auth.spec.ts e2e/test_asset.spec.ts e2e/test_project.spec.ts'
+        docker cp apps "$CONTAINER_NAME:/workspace/"
+        docker cp package-lock.json "$CONTAINER_NAME:/workspace/" 2>/dev/null || true
+        docker start -a "$CONTAINER_NAME"
+        EXIT_CODE=$(docker wait "$CONTAINER_NAME")
+        docker rm "$CONTAINER_NAME" 2>/dev/null || true
+        exit $EXIT_CODE

    - name: Job duration summary
      if: always()
@@ -1166,11 +1262,6 @@ jobs:
    runs-on: runtime-builder
    timeout-minutes: ${{ matrix.timeout }}
    needs:
-      - validate-code-quality
-      - validate-type-check
-      - unit-tests
-      - frontend-lint
-      - frontend-unit-test
    if: startsWith(github.ref, 'refs/tags/v') || (github.event_name == 'push' && github.ref_name == 'main')
    strategy:
      fail-fast: false
@@ -1200,7 +1291,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -1244,7 +1335,7 @@ jobs:
        docker buildx inspect --bootstrap

    - name: Build and push production ${{ matrix.service_display }} image (with retry)
-      shell: bash
+      shell: sh
      run: |
        set -eu
        REGISTRY="xiaoxia-registry.cn-hangzhou.cr.aliyuncs.com/xiaoxiakeji"
@@ -1324,7 +1415,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -1455,13 +1546,14 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
    - name: Run production browser E2E
-      shell: bash
+      shell: sh
      run: |
+        set -eu
        docker run --rm --ipc=host \
          -e E2E_BASE_URL=https://saas.xiaoxiajianji.com \
          -e E2E_API_BASE=https://api.xiaoxiajianji.com/api/v1 \
@@ -1470,7 +1562,7 @@ jobs:
          -v "$PWD:/workspace" \
          -w /workspace/apps/web \
          git.xiaoxiajianji.com/xiaoxia/base/playwright:v1.45.0-jammy \
-          bash -c 'for i in 1 2 3; do npm ci --registry=https://registry.npmmirror.com && break; echo "npm ci attempt $i failed, retrying..."; sleep 15; done && npx playwright test --reporter=line --project=chromium e2e/auth.spec.ts e2e/auth-guard.spec.ts e2e/core-upload.spec.ts e2e/core-generation.spec.ts e2e/core-titles.spec.ts'
+          sh -lc 'npm ci && npx playwright test --reporter=line --project=chromium e2e/auth.spec.ts e2e/auth-guard.spec.ts e2e/core-upload.spec.ts e2e/core-generation.spec.ts e2e/core-titles.spec.ts'

    - name: Job duration summary
      if: always()
@@ -1514,7 +1606,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -1528,7 +1620,6 @@ jobs:
        set -eu
        python3 scripts/ci/acr_cleanup.py \
          --keep 20 \
-          --pr-days 7 \
          --execute

    - name: Job duration summary
@@ -1573,7 +1664,7 @@ jobs:
      env:
        GITHUB_TOKEN: ${{ github.token }}
      run: |
-        curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
+        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
    - name: Record job start time
      shell: sh
      run: bash scripts/ci/step_timer_start.sh
@@ -1640,190 +1731,3 @@ jobs:
        START_TIME=""
        [ -f /tmp/ci_job_start_time ] && START_TIME=$(cat /tmp/ci_job_start_time)
        python3 scripts/ci/ci_trace_report.py --service xiaoxia-saas-ci --status $STATUS --start-time "$START_TIME" || true
-
-  ci-gate:
-    name: CI Gate
-    runs-on: ci-l2
-    if: always() && github.event_name == 'pull_request'
-    needs:
-      - check-frontend-only
-      - validate-code-quality
-      - validate-type-check
-      - validate-migration
-      - unit-tests
-      - integration-tests
-      - frontend-lint
-      - frontend-unit-test
-      - build-pr
-    timeout-minutes: 3
-    steps:
-      - name: Checkout code
-        shell: sh
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        run: |
-          curl -sfH "Authorization: token $GITHUB_TOKEN" -o /tmp/_ci_checkout.sh \
-            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" && bash /tmp/_ci_checkout.sh
-
-      - name: Evaluate CI Gate
-        id: gate
-        shell: bash
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
-          RESULT_CHECK_FRONTEND: ${{ needs.check-frontend-only.result }}
-          RESULT_CODE_QUALITY: ${{ needs.validate-code-quality.result }}
-          RESULT_TYPE_CHECK: ${{ needs.validate-type-check.result }}
-          RESULT_MIGRATION: ${{ needs.validate-migration.result }}
-          RESULT_UNIT_TESTS: ${{ needs.unit-tests.result }}
-          RESULT_INTEGRATION: ${{ needs.integration-tests.result }}
-          RESULT_FRONTEND_LINT: ${{ needs.frontend-lint.result }}
-          RESULT_FRONTEND_UNIT: ${{ needs.frontend-unit-test.result }}
-          RESULT_BUILD_PR: ${{ needs.build-pr.result }}
-        run: |
-          set -eu
-          echo "=== CI Gate 评估 ==="
-          echo ""
-          echo "各job结果:"
-          echo "  check-frontend-only: $RESULT_CHECK_FRONTEND"
-          echo "  validate-code-quality: $RESULT_CODE_QUALITY"
-          echo "  validate-type-check: $RESULT_TYPE_CHECK"
-          echo "  validate-migration: $RESULT_MIGRATION"
-          echo "  unit-tests: $RESULT_UNIT_TESTS"
-          echo "  integration-tests: $RESULT_INTEGRATION"
-          echo "  frontend-lint: $RESULT_FRONTEND_LINT"
-          echo "  frontend-unit-test: $RESULT_FRONTEND_UNIT"
-          echo "  build-pr: $RESULT_BUILD_PR"
-
-          # 查询 AI Code Review 状态（跨workflow，读commit status）
-          AI_REVIEW_STATUS="pending"
-          AI_REVIEW_DESC=""
-          STATUS_JSON=$(curl -sfH "Authorization: token $GITHUB_TOKEN" \
-            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/commits/${PR_HEAD_SHA}/status" 2>/dev/null || true)
-          if [ -n "$STATUS_JSON" ]; then
-            AI_STATUS=$(echo "$STATUS_JSON" | python3 -c "
-          import json,sys
-          try:
-              data=json.load(sys.stdin)
-              for s in data.get('statuses',[]):
-                  if 'AI Code Review' in s.get('context',''):
-                      print(s['state']+'|'+s.get('description',''))
-                      break
-          except: pass
-          " 2>/dev/null)
-            if [ -n "$AI_STATUS" ]; then
-              AI_REVIEW_STATUS="${AI_STATUS%%|*}"
-              AI_REVIEW_DESC="${AI_STATUS#*|}"
-            fi
-          fi
-          echo "  ai-code-review: $AI_REVIEW_STATUS ($AI_REVIEW_DESC)"
-
-          echo ""
-
-          # 判断PR类型
-          SKIP_BACKEND="${{ needs.check-frontend-only.outputs.skip_backend }}"
-          SKIP_FRONTEND="${{ needs.check-frontend-only.outputs.skip_frontend }}"
-          echo "PR类型: skip_backend=$SKIP_BACKEND, skip_frontend=$SKIP_FRONTEND"
-
-          # 必填检查项（根据PR类型决定）
-          # 通用检查（所有PR都必须过）
-          REQUIRED_GENERAL=(
-            "validate-code-quality:$RESULT_CODE_QUALITY"
-            "validate-type-check:$RESULT_TYPE_CHECK"
-            "validate-migration:$RESULT_MIGRATION"
-            "frontend-lint:$RESULT_FRONTEND_LINT"
-            "build-pr:$RESULT_BUILD_PR"
-            "ai-code-review:$AI_REVIEW_STATUS"
-          )
-
-          # 后端检查
-          REQUIRED_BACKEND=(
-            "unit-tests:$RESULT_UNIT_TESTS"
-            "integration-tests:$RESULT_INTEGRATION"
-          )
-
-          # 前端检查
-          REQUIRED_FRONTEND=(
-            "frontend-unit-test:$RESULT_FRONTEND_UNIT"
-          )
-
-          ALL_PASSED=true
-          FAILED_ITEMS=()
-
-          check_job() {
-            local name=$1
-            local result=$2
-            if [ "$result" = "success" ]; then
-              echo "  ✅ $name: success"
-            elif [ "$result" = "skipped" ]; then
-              echo "  ⏭️  $name: skipped（跳过，不影响）"
-            else
-              echo "  ❌ $name: $result"
-              ALL_PASSED=false
-              FAILED_ITEMS+=("$name=$result")
-            fi
-          }
-
-          echo ""
-          echo "=== 通用检查（所有PR必填）==="
-          for item in "${REQUIRED_GENERAL[@]}"; do
-            name="${item%%:*}"
-            result="${item##*:}"
-            # AI Code Review pending时不阻塞（可能还在跑），等它跑完自然会重跑Gate
-            if [ "$name" = "ai-code-review" ] && [ "$result" = "pending" ]; then
-              echo "  ⏳ $name: pending（审查中，暂不阻塞）"
-              continue
-            fi
-            check_job "$name" "$result"
-          done
-
-          if [ "$SKIP_BACKEND" != "true" ]; then
-            echo ""
-            echo "=== 后端检查 ==="
-            for item in "${REQUIRED_BACKEND[@]}"; do
-              name="${item%%:*}"
-              result="${item##*:}"
-              check_job "$name" "$result"
-            done
-          else
-            echo ""
-            echo "=== 后端检查（纯前端PR，跳过）==="
-          fi
-
-          if [ "$SKIP_FRONTEND" != "true" ]; then
-            echo ""
-            echo "=== 前端检查 ==="
-            for item in "${REQUIRED_FRONTEND[@]}"; do
-              name="${item%%:*}"
-              result="${item##*:}"
-              check_job "$name" "$result"
-            done
-          else
-            echo ""
-            echo "=== 前端检查（纯后端PR，跳过）==="
-          fi
-
-          echo ""
-          if [ "$ALL_PASSED" = "true" ]; then
-            echo "✅ CI Gate: PASSED"
-            echo "gate_result=success" >> $GITHUB_OUTPUT
-            exit 0
-          else
-            echo "❌ CI Gate: FAILED"
-            echo "失败项: ${FAILED_ITEMS[*]}"
-            echo "gate_result=failure" >> $GITHUB_OUTPUT
-            exit 1
-          fi
-
-      - name: Report CI trace
-        if: always()
-        shell: sh
-        env:
-          AGENTLOOP_LICENSE_KEY: ${{ secrets.AGENTLOOP_LICENSE_KEY }}
-        run: |
-          STATUS="ok"
-          [ "${{ steps.gate.outputs.gate_result }}" = "success" ] || STATUS="error"
-          START_TIME=""
-          [ -f /tmp/ci_job_start_time ] && START_TIME=$(cat /tmp/ci_job_start_time)
-          python3 scripts/ci/ci_trace_report.py --service xiaoxia-saas-ci --status $STATUS --start-time "$START_TIME" || true
@@ -48,7 +48,6 @@ jobs:
          GITEA_TOKEN: ${{ secrets.REVIEW_GITEA_TOKEN }}
          REPO_NAME: ${{ gitea.repository }}
          PR_NUMBER: ${{ gitea.event.pull_request.number }}
-          PR_HEAD_SHA: ${{ gitea.event.pull_request.head.sha }}
          # LLM 提供商: coze (扣子原生Bot) / openai (OpenAI兼容)
          LLM_PROVIDER: "coze"
          # 扣子模式配置（默认国内站 api.coze.cn）
@@ -61,9 +60,8 @@ jobs:
          LLM_TIMEOUT: "120"
        run: |
          python3 scripts/ci_code_review.py
-        # 注意：脚本退出码决定job状态
-        # - 有阻塞级问题 → exit 1 → job失败 → 门禁拦截
-        # - 无阻塞级问题/LLM异常 → exit 0 → 通过（fail-open）
+        # 审查脚本异常不影响 CI 通过
+        continue-on-error: true

      - name: Report CI trace
        if: always()
@@ -87,7 +87,7 @@ jobs:
    runs-on: ci-l2
    timeout-minutes: 10
    outputs:
-      report: ${{ steps.report.outputs.report }}
+      report: ${{ steps.smoke.outputs.report }}

    steps:
      - name: Checkout code
@@ -201,7 +201,7 @@ jobs:
    runs-on: ci-l2
    timeout-minutes: 15
    outputs:
-      report: ${{ steps.e2e.outputs.report }}
+      report: ${{ steps.smoke.outputs.report }}

    steps:
      - name: Checkout code
@@ -8,11 +8,6 @@ on:
 permissions:
  contents: read

-
-concurrency:
-  group: pr-automation-${{ gitea.event.pull_request.number }}
-  cancel-in-progress: true
-
 jobs:
  auto-approve:
    name: Auto Approve on CI Green
@@ -61,7 +56,7 @@ jobs:
    name: Auto Merge on CI Green + Approved
    runs-on: ci-check
    if: github.event_name == 'pull_request' && !github.event.pull_request.draft && github.event.pull_request.base.ref == 'develop'
-    timeout-minutes: 3  # 短作业模式：检查一次，不满足就退出，由pr-auto-scan每5分钟定时兜底
+    timeout-minutes: 45  # 长等待模式：等CI全绿后自动合并，不遗漏任何PR
    steps:
      - name: Checkout code
        shell: sh
@@ -120,7 +120,7 @@ jobs:
        PREVIEW_SSH_KEY: ${{ secrets.PREVIEW_SSH_KEY }}
      run: |
        set -eux
-        preview_host="${PREVIEW_SSH_HOST:-47.98.113.167}"
+        preview_host="${PREVIEW_SSH_HOST:-172.30.18.197}"
        preview_user="${PREVIEW_SSH_USER:-deploy}"
        preview_port="${PREVIEW_SSH_PORT:-22222}"
        preview_dir="/var/www/preview/pr-${PR_NUMBER}"
@@ -95,10 +95,13 @@ jobs:
        set -eu
        cd apps/web

+        # Config npm mirror for speed
+        npm config set registry https://registry.npmmirror.com
+
        # Install dependencies with retry
        for i in 1 2 3; do
-          npm ci --registry=https://registry.npmmirror.com --no-audit --no-fund && break
-          echo "npm install failed, retry $i/3..."
+          npm ci --no-audit --no-fund && break
+          echo "npm ci failed, retry $i/3..."
          [ $i -eq 3 ] && exit 1
          rm -rf node_modules
          sleep 5
@@ -106,12 +109,12 @@ jobs:

        # TypeScript check
        echo "=== TypeScript check ==="
-        ./node_modules/.bin/tsc --noEmit
+        npx --no-install tsc --noEmit

        # Vite build
        echo "=== Vite build ==="
        export VITE_API_URL=https://staging-api.xiaoxiajianji.com
-        ./node_modules/.bin/vite build
+        npx --no-install vite build

        echo "=== Build completed ==="
        ls -la dist/
@@ -1,222 +0,0 @@
---
-AIGC:
-    Label: "1"
-    ContentProducer: 001191110102MACQD9K64018705
-    ProduceID: 15868733686388_0/project_7655981463858544923-files/docs/1197_preview_generation_proposal.md
-    ReservedCode1: ""
-    ContentPropagator: 001191110102MACQD9K64028705
-    PropagateID: 15868733686388#1785468313901
-    ReservedCode2: ""
---
-# #1197 预览生成接口方案评估
-
-## 背景
-
-智能剪辑「一键生成」流程中，第3步预览生成当前被跳过，直接进入下一步。需要实现真正的预览生成功能，让用户在正式生成前能看到效果预览。
-
-## 现状分析
-
-### 现有生成链路
-
-```
-API 触发生成 → GenerationTask入库 → Celery异步任务 → UnifiedRenderService渲染 → OSS上传 → 更新状态
-```
-
-**关键节点：**
-1. **API层**：`POST /generation-tasks` 或 `POST /templates/{id}/generate` 触发生成
-2. **任务调度**：Celery task `worker.generate_video`
-3. **渲染引擎**：`UnifiedRenderService`（统一渲染引擎，已接入9个效果层）
-4. **输出配置**：默认 720p (1280x720)，支持 `resolution` 字段自定义
-5. **产物存储**：`GeneratedVideo` 表记录，OSS 存储视频文件
-
-### 已有可复用能力
-
-| 能力 | 位置 | 是否可复用 |
-|------|------|-----------|
-| 任务创建与状态管理 | `GenerationTask` + `CreateGenerationTaskUseCase` | ✅ 是 |
-| 素材下载与预处理 | `_download_video_assets` / `_download_voice_asset` | ✅ 是 |
-| 统一渲染引擎 | `UnifiedRenderService` | ✅ 是 |
-| 分辨率配置 | `resolution` 字段已支持 | ✅ 是 |
-| 混音与后处理 | `_render_video` 内流程 | ✅ 是 |
-| OSS 上传与查重 | `_upload_and_dedup` | ✅ 是 |
-| 进度追踪 | `append_log` / `progress` 字段 | ✅ 是 |
-
-## 方案对比
-
-### 方案A：复用现有生成链路 + is_preview 标记（推荐）
-
-**思路**：在现有 GenerationTask 上加 `is_preview` 标记，预览生成走完整链路但参数降级。
-
-**改动点：**
-1. **数据模型**：`GenerationTask` 加 `is_preview: bool` 字段（默认 false）；`GeneratedVideo` 加 `is_preview: bool`
-2. **API 层**：生成接口加 `is_preview` 参数，预览任务不计入配额
-3. **渲染参数**：预览模式下自动调整
-   - 分辨率：480p (854x480)
-   - 时长：限制前 15 秒（或模板第一个片段）
-   - 码率：降低至 1.5Mbps（正式 4Mbps）
-   - 效果层：跳过高级转场/粒子特效等耗时效果
-4. **任务调度**：预览任务走低优先级队列（或复用现有队列，标记优先级）
-5. **前端对接**：预览生成结果带 `is_preview=true` 标记，前端展示"预览"标签
-
-**优点：**
- 代码复用率 90%+，改动最小
- 与正式生成逻辑一致，预览效果真实可信
- 进度查询、结果展示等功能直接复用
- 后续可平滑升级：预览满意后一键转正式生成
-
-**缺点：**
- 需要区分预览和正式任务，避免数据混淆
- 预览任务和正式任务竞争同一队列资源（可后续优化为独立队列）
-
-**开发量估算**：2-3 天
- 数据模型 + 迁移：0.5 天
- API 层改造：0.5 天
- 渲染参数降级：1 天
- 测试 + 联调：1 天
-
---
-
-### 方案B：新建独立预览接口 + 轻量渲染逻辑
-
-**思路**：新建独立的预览生成接口，使用简化的渲染逻辑（如只拼接素材+基础配音，跳过大部分效果）。
-
-**改动点：**
-1. 新增 `PreviewTask` 数据模型
-2. 新增 `POST /api/v1/preview/generate` 接口
-3. 新增独立的 Celery task `worker.generate_preview`
-4. 简化渲染流程：只做素材裁剪+拼接+配音，跳过转场/滤镜/字幕特效等
-
-**优点：**
- 完全隔离，不影响正式生成链路
- 可以做极致优化，预览生成速度快
- 数据模型清晰，不会混淆
-
-**缺点：**
- 代码重复率高，两套生成逻辑维护成本翻倍
- 预览效果与正式生成可能不一致（效果层差异）
- 前端需要对接两套接口
- 无法从预览升级为正式生成（需重新走完整流程）
-
-**开发量估算**：4-5 天
- 数据模型 + 接口：1 天
- 简化渲染逻辑：2 天
- 测试 + 联调：1-2 天
-
---
-
-### 方案C：图片预览（首帧/关键帧截图）
-
-**思路**：不生成视频，只生成几张关键帧的预览图片。
-
-**优点：**
- 生成速度极快（秒级）
- 资源消耗小
-
-**缺点：**
- 预览效果差，用户无法感知动态效果
- 无法验证配音、转场、节奏等时间维度的效果
- 用户体验不佳，不如"真预览"有说服力
-
-**开发量估算**：1-2 天
-
---
-
-## 推荐方案：方案A（复用现有生成链路）
-
-### 核心理由
-
-1. **效果保真**：预览和正式生成用同一套渲染引擎，效果一致，用户信任度高
-2. **开发效率**：90% 代码复用，2-3 天可上线
-3. **可扩展性强**：后续可加「预览转正式」「低分辨率快速预览」等增强功能
-4. **维护成本低**：一套生成逻辑，bug 修复和新功能同时生效
-
-### 详细设计
-
-#### 1. 数据模型变更
-
-```python
-# GenerationTask 新增字段
-is_preview: bool = False
-"""是否为预览生成"""
-
-preview_of: str = ""
-"""预览对应的正式任务 ID（或反向关联）"""
-
-# GeneratedVideo 新增字段
-is_preview: bool = False
-"""是否为预览视频"""
-```
-
-**迁移**：alembic 新增 migration，两个表各加 1-2 个字段。
-
-#### 2. API 层
-
-```
-POST /api/v1/generation-tasks
-  Body 增加 is_preview: bool = false
-  
-POST /api/v1/templates/{id}/generate
-  Query 增加 is_preview: bool = false
-```
-
-**配额处理**：预览生成不计入用户配额，不占用生成次数限制。
-
-#### 3. 渲染参数降级
-
-| 参数 | 正式生成 | 预览生成 |
-|------|---------|---------|
-| 分辨率 | 720p (1280x720) | 480p (854x480) |
-| 码率 | 4 Mbps | 1.5 Mbps |
-| 时长 | 完整时长 | 前 15 秒（或第一段） |
-| 帧率 | 30 fps | 24 fps |
-| 转场效果 | 完整转场 | 仅淡入淡出（或简单切） |
-| 特效滤镜 | 全部启用 | 跳过粒子/光效等高级效果 |
-| 字幕 | 完整渲染 | 正常渲染（字幕是核心信息） |
-| 配音 | 完整混音 | 正常混音（配音是核心信息） |
-
-**实现方式**：在 `_render_video` 或 UnifiedRenderService 入口处，根据 `is_preview` 标记调整渲染配置。
-
-#### 4. 任务调度
-
- 初期复用现有队列，预览任务正常排队
- 后续如需优化，可拆分独立预览队列（低优先级）
- 预览任务可设置较短超时时间
-
-#### 5. 前端对接
-
- 调用生成接口时传 `is_preview=true`
- 结果列表中预览视频带「预览」标签
- 预览满意后可一键「升级为正式生成」（重新触发全分辨率生成，可复用素材下载缓存）
-
-### 实施步骤
-
-**Phase 1（MVP，2天）：**
-1. 数据模型 + 迁移
-2. API 层支持 is_preview 参数
-3. 渲染分辨率降级（480p）
-4. 不计入配额
-5. 基础测试
-
-**Phase 2（优化，1-2天）：**
-1. 时长限制（前15秒）
-2. 效果层降级（跳高级效果）
-3. 预览任务低优先级队列
-4. 预览转正式生成功能
-
-## 与前端对齐点
-
-1. 预览生成的触发时机（第3步自动生成？用户点击才生成？）
-2. 预览时长是固定15秒还是完整但低清？
-3. 是否需要「预览转正式生成」功能
-4. 预览视频的展示形态（和正式视频一样还是有特殊UI）
-
-## 风险与注意事项
-
-1. **数据混淆**：确保统计、计费、列表展示时正确区分预览和正式任务
-2. **存储成本**：预览视频也占 OSS 空间，可设置自动清理（7天后自动删除）
-3. **用户预期**：要明确告诉用户这是预览，效果和正式生成一致但清晰度低
-4. **并发压力**：如果用户频繁生成预览，可能增加系统负载，需要限流
-
---
-
-> 本内容由 Coze AI 生成，请遵循相关法律法规及《人工智能生成合成内容标识办法》使用与传播。
@@ -1,382 +0,0 @@
-# #1197 预览生成接口技术方案（v2）
-
-> 更新说明：v2 新增「多版本预览生成」能力，支持一个模板生成多个不重复的预览视频，左侧列表展示，用户可挑选满意的版本转正式生成。
-
-## 1. 背景与目标
-
-**现状**：智能剪辑「一键生成」第3步预览生成被跳过，用户直接进入正式生成，缺少效果预览环节。
-
-**目标**：
-1. ✅ 实现真正的预览生成（低分辨率快速出片）
-2. ✅ **支持生成 1~N 个不重复的预览版本**（默认 3 个），左侧列表展示
-3. ✅ 预览满意后可一键转正式生成（复用素材下载缓存）
-4. ✅ 不计入用户配额，不占用正式生成次数
-
---
-
-## 2. 现有生成链路分析
-
-### 2.1 链路总览
-
-```
-API 触发生成 → GenerationTask入库 → Celery异步任务
-  → 下载素材 → 构建plan/clips → UnifiedRenderService渲染
-  → 混音后处理 → OSS上传 + 查重 → 更新状态
-```
-
-### 2.2 决定视频差异的变量
-
-要做"多个不重复版本"，先分析哪些环节可以引入变化：
-
-| 变量 | 当前行为 | 能否引入变化 | 影响程度 |
-|------|---------|------------|---------|
-| 素材选择 | 按 asset_ids 顺序全用 | ✅ 可随机选择子集/不同组合 | 大 |
-| 素材排序 | 按 asset_ids 顺序 | ✅ 可 shuffle 重排 | 大 |
-| 配音选择 | 固定 voice_library_id | ✅ 可选不同音色 | 中 |
-| 标题选择 | 固定 title_ids 或随机选 | ✅ 可选不同标题 | 中 |
-| BGM | 固定 bgm_config | ✅ 可选不同BGM | 小 |
-| 转场效果 | 模板固定 | ✅ 可随机化转场类型 | 小 |
-| 播放速度 | 模板固定 | ✅ 可微调速度 | 小 |
-| 分辨率/码率 | 固定 | ✅ 预览可降级 | 不影响内容 |
-
-### 2.3 可复用能力
-
- 任务创建与状态管理：`GenerationTask` + `CreateGenerationTaskUseCase`
- 素材下载与预处理：`_download_all_assets`
- 统一渲染引擎：`UnifiedRenderService`
- 分辨率配置：`resolution` 字段已支持
- 批量任务：`batch_id` 字段已存在（可用于预览组）
-
---
-
-## 3. 总体方案：复用现有链路 + 多变体引擎
-
-**核心思路**：沿用 v1 的"复用现有生成链路 + is_preview 标记"方案，在此基础上增加「多版本生成」能力。
-
-**架构**：
-```
-预览生成请求（count=N）
-    ↓
-创建预览批次（preview_batch）
-    ↓
-变体引擎生成 N 个变体参数（variation seed + 参数组合）
-    ↓
-为每个变体创建 1 个 GenerationTask（is_preview=true）
-    ↓
-N 个 Celery 任务并行执行（走现有生成链路，参数降级）
-    ↓
-N 个结果汇聚，前端左侧列表展示
-```
-
---
-
-## 4. 详细设计
-
-### 4.1 数据模型变更
-
-#### 4.1.1 GenerationTask 新增字段
-
-```python
-# 现有字段保留，新增：
-is_preview: bool = False
-"""是否为预览生成"""
-
-preview_batch_id: str = ""
-"""预览批次 ID（同批次的 N 个预览共享一个 batch）"""
-
-variant_seed: int = 0
-"""变体种子，用于控制随机化行为（素材选择、排序、转场等）"""
-
-variant_params: dict = field(default_factory=dict)
-"""变体参数快照（记录本次使用了哪些素材、标题、配音等，可追溯）
-   {
-     "asset_ids": [...],      # 实际选用的素材子集
-     "title_id": "",         # 选用的标题
-     "voice_id": "",         # 选用的配音
-     "transition_style": "", # 转场风格
-     "bgm_track": "",        # BGM 音轨
-   }
-"""
-```
-
-#### 4.1.2 GeneratedVideo 新增字段
-
-```python
-is_preview: bool = False
-"""是否为预览视频"""
-
-preview_batch_id: str = ""
-"""所属预览批次"""
-
-variant_index: int = 0
-"""在批次中的序号（0, 1, 2...）"""
-```
-
-#### 4.1.3 迁移方案
-
-alembic 新增 migration，两个表各加 4 个字段，默认值为空/false，无数据回填成本。
-
---
-
-### 4.2 变体引擎（Variant Engine）
-
-**核心组件**：根据 count 和 seed，生成 N 组互不相同的生成参数。
-
-#### 4.2.1 变纬度设计
-
-| 维度 | 策略 | 说明 |
-|------|------|------|
-| **素材子集选择** | 从素材池中随机选 M 个（M=min(素材数, 模板clip数*2)） | 版本差异最大的来源 |
-| **素材排序** | 随机打乱顺序 | 影响叙事节奏 |
-| **标题选择** | 从 title_ids 中随机选 1 个 | 影响文案内容 |
-| **配音选择** | 从 voice_ids 中随机选 1 个（如有多个） | 影响听觉体验 |
-| **转场风格** | 从预设转场池中随机选 1 种 | 影响视觉过渡 |
-| **BGM 选择** | 从 bgm 列表中随机选 1 首（如有配置） | 影响氛围 |
-
-#### 4.2.2 去重机制
-
- 同一批次内，变体参数必须两两不同（至少素材组合或排序不同）
- 使用 `variant_seed` 保证可复现（相同 seed → 相同变体）
- 如果素材数量不足导致无法生成 N 个不同版本，按实际能生成的数量返回
-
-#### 4.2.3 接口设计
-
-```python
-def generate_variants(
-    count: int,
-    seed: int,
-    asset_pool: list[str],        # 可用素材 ID 列表
-    title_pool: list[str] = [],    # 可用标题 ID 列表
-    voice_pool: list[str] = [],    # 可用配音 ID 列表
-    template_id: str = "",
-) -> list[dict]:
-    """
-    生成 count 组变体参数。
-    
-    每组参数包含：asset_ids（选用的素材+排序）、title_id、voice_id、
-    transition_style 等，确保两两不同。
-    """
-```
-
---
-
-### 4.3 API 层设计
-
-#### 4.3.1 预览生成接口
-
-```
-POST /api/v1/templates/{template_id}/generate-preview
-```
-
-**请求体**：
-```json
-{
-  "asset_library_id": "lib_xxx",
-  "asset_ids": ["asset_1", "asset_2", ...],
-  "title_ids": ["title_1", "title_2"],
-  "voice_ids": ["voice_1", "voice_2"],
-  "bgm_config": {},
-  "count": 3,
-  "seed": 0
-}
-```
-
-| 参数 | 类型 | 必填 | 默认 | 说明 |
-|------|------|------|------|------|
-| template_id | path | ✅ | - | 模板 ID |
-| asset_library_id | body | ✅ | - | 素材库 ID |
-| asset_ids | body | ✅ | - | 素材池（从中选子集/排序） |
-| title_ids | body | - | [] | 标题池（可选，不传则不用标题） |
-| voice_ids | body | - | [] | 配音池（可选） |
-| bgm_config | body | - | {} | BGM 配置 |
-| count | body | - | 3 | 生成几个预览版本（1~10） |
-| seed | body | - | 0 | 随机种子，0 表示随机 |
-
-**响应**：
-```json
-{
-  "preview_batch_id": "pb_xxx",
-  "count": 3,
-  "tasks": [
-    {
-      "task_id": "gen_xxx_0",
-      "variant_index": 0,
-      "status": "processing"
-    },
-    {
-      "task_id": "gen_xxx_1",
-      "variant_index": 1,
-      "status": "processing"
-    },
-    ...
-  ]
-}
-```
-
-#### 4.3.2 预览批次查询接口
-
-```
-GET /api/v1/preview-batches/{batch_id}
-```
-
-返回批次内所有预览任务的状态、结果（已完成的带 video_url）。
-
-**响应**：
-```json
-{
-  "preview_batch_id": "pb_xxx",
-  "count": 3,
-  "completed_count": 2,
-  "tasks": [
-    {
-      "task_id": "gen_xxx_0",
-      "variant_index": 0,
-      "status": "completed",
-      "video_url": "https://oss.xxx/preview/xxx.mp4",
-      "duration": 15.5,
-      "thumbnail_url": "https://oss.xxx/preview/xxx.jpg"
-    },
-    ...
-  ]
-}
-```
-
-#### 4.3.3 预览转正式生成
-
-```
-POST /api/v1/preview-batches/{batch_id}/tasks/{task_id}/promote
-```
-
-将某个预览版本升级为正式生成（复用素材缓存，重新全分辨率渲染）。
-
---
-
-### 4.4 渲染参数降级
-
-预览模式下自动调整以下参数：
-
-| 参数 | 正式生成 | 预览生成 |
-|------|---------|---------|
-| 分辨率 | 720p (1280x720) | 480p (854x480) |
-| 码率 | 4 Mbps | 1.5 Mbps |
-| 帧率 | 30 fps | 24 fps |
-| 时长 | 完整时长 | 前 15 秒（或第一段完整clip） |
-| 转场效果 | 完整转场 | 仅淡入淡出 |
-| 高级特效 | 全部启用 | 跳过粒子/光效等 |
-| 字幕 | 完整渲染 | 正常渲染 |
-| 配音 | 完整混音 | 正常混音 |
-| 输出质量 | high | medium |
-
-**实现位置**：`_render_video` 函数入口处，根据 `is_preview` 标记调整渲染配置。
-
---
-
-### 4.5 任务调度
-
- **并行执行**：N 个预览任务并行提交到 Celery，不排队等待
- **低优先级**：预览任务走独立队列（`preview_queue`），不抢占正式生成资源
- **超时控制**：预览任务超时时间 5 分钟（正式 30 分钟）
- **自动清理**：预览视频 7 天后自动从 OSS 删除，任务记录标记为 archived
-
---
-
-## 5. 前端对接要点
-
-### 5.1 交互流程
-
-```
-第2步选素材 → 第3步点击"生成预览"
-  → 显示 loading + 进度
-  → 预览陆续完成，左侧列表逐张出现
-  → 用户点击左侧不同版本，右侧预览区切换
-  → 用户选中满意版本 → 点击"正式生成"
-```
-
-### 5.2 需要对齐的接口
-
-1. **预览创建**：`POST /templates/{id}/generate-preview`
-2. **批次状态轮询**：`GET /preview-batches/{id}`（建议 2s 轮询，或走 SSE）
-3. **预览转正式**：`POST /preview-batches/{id}/tasks/{task_id}/promote`
-
-### 5.3 数据格式对齐
-
-预览视频条目结构：
-```json
-{
-  "id": "gen_xxx",
-  "variant_index": 0,
-  "status": "completed",
-  "video_url": "https://...",
-  "duration": 15.5,
-  "file_size": 2850000,
-  "thumbnail_url": "https://...",
-  "is_preview": true
-}
-```
-
---
-
-## 6. 配额与计费
-
- 预览生成**不计入**用户配额
- 同一模板 + 同一素材池，每天最多生成 3 次多版本预览（防滥用）
- 单个预览批次最多 10 个版本
-
---
-
-## 7. 实施步骤
-
-### Phase 1：单版本预览（MVP，2 天）
-1. 数据模型 + 迁移（is_preview 字段）
-2. API 层支持 is_preview 参数
-3. 渲染分辨率降级（480p）
-4. 不计入配额
-5. 基础测试
-
-### Phase 2：多版本预览（3 天）
-1. 变体引擎实现（素材随机选择 + 排序 + 去重）
-2. preview_batch 批次管理
-3. 批量创建 N 个预览任务
-4. 批次查询接口
-5. 前端联调
-
-### Phase 3：预览转正式 + 优化（2 天）
-1. 预览转正式生成接口（promote）
-2. 素材下载缓存复用
-3. 独立预览队列（低优先级）
-4. 自动清理机制
-5. 完整测试 + 压测
-
---
-
-## 8. 风险与注意事项
-
-| 风险 | 影响 | 应对 |
-|------|------|------|
-| 并发预览任务过多打满 worker | 正式生成被阻塞 | 独立预览队列 + 限流 |
-| 变体生成的视频差异不够大 | 用户觉得"都一样" | 优先素材子集+排序差异，保证视觉差异 |
-| 预览视频占用 OSS 存储 | 存储成本上升 | 7 天自动清理 + 低码率 |
-| N 个版本同时下载重复素材 | 带宽浪费 | 批次内共享一次下载（Phase 3 优化） |
-| 用户预期管理 | 以为预览就是最终效果 | 明确标注"预览版"，说明分辨率差异 |
-
---
-
-## 9. 开发量估算
-
-| 阶段 | 后端 | 前端 | 合计 |
-|------|------|------|------|
-| Phase 1 单版本预览 | 2 天 | 1 天 | 3 天 |
-| Phase 2 多版本预览 | 3 天 | 2 天 | 5 天 |
-| Phase 3 转正式+优化 | 2 天 | 1 天 | 3 天 |
-| **总计** | **7 天** | **4 天** | **~7 天（并行）** |
-
---
-
-## 10. 与 v1 方案的差异总结
-
-1. **新增多版本能力**：从"生成1个预览"升级为"生成N个不重复预览"
-2. **新增变体引擎**：负责素材选择/排序/配音/标题的随机化
-3. **新增批次概念**：preview_batch 管理一组预览任务
-4. **新增 promote 接口**：预览转正式生成
-5. **独立队列**：预览不抢占正式生成资源
-6. **开发量**：从 2-3 天增加到约 7 天（后端）
@@ -1,61 +0,0 @@
-"""#1197 - 预览生成：generation_tasks 表新增 is_preview 字段
-
-Revision ID: 053
-Revises: 052
-Create Date: 2026-08-15
-
-Changes:
-1. generation_tasks 表新增 is_preview 字段，标记是否为预览生成任务（低清 480p）
-2. 默认 False，与现有正式生成任务兼容
-3. 加索引以支持按预览/正式任务筛选
-"""
-
-import sqlalchemy as sa
-
-from alembic import context, op
-
-revision = "053_generation_task_is_preview"
-down_revision = "052_generation_task_bgm_config"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    conn = op.get_bind()
-    if context.get_context().dialect.name == "postgresql":
-        # 检查列是否已存在（幂等）
-        result = conn.execute(
-            sa.text(
-                "SELECT column_name FROM information_schema.columns "
-                "WHERE table_name = 'generation_tasks' AND column_name = 'is_preview'"
-            )
-        )
-        if result.scalar() is not None:
-            return
-
-    op.add_column(
-        "generation_tasks",
-        sa.Column("is_preview", sa.Boolean, nullable=False, server_default=sa.text("false")),
-    )
-    # 加索引
-    op.create_index(
-        "ix_generation_tasks_is_preview",
-        "generation_tasks",
-        ["is_preview"],
-    )
-
-
-def downgrade() -> None:
-    conn = op.get_bind()
-    if context.get_context().dialect.name == "postgresql":
-        result = conn.execute(
-            sa.text(
-                "SELECT column_name FROM information_schema.columns "
-                "WHERE table_name = 'generation_tasks' AND column_name = 'is_preview'"
-            )
-        )
-        if result.scalar() is None:
-            return
-
-    op.drop_index("ix_generation_tasks_is_preview", table_name="generation_tasks")
-    op.drop_column("generation_tasks", "is_preview")
@@ -7,7 +7,6 @@ from app.api.routes.chunked_upload import router as chunked_upload_router
 from app.api.routes.classification_jobs import router as classification_jobs_router
 from app.api.routes.duplication import router as duplication_router
 from app.api.routes.feature_flags import router as feature_flags_router
-from app.api.routes.generation_preview import router as generation_preview_router
 from app.api.routes.generation_tasks import router as generation_tasks_router
 from app.api.routes.health import router as health_check_router
 from app.api.routes.ingest_jobs import router as ingest_jobs_router
@@ -88,11 +87,6 @@ api_router.include_router(
    prefix="/generation",
    tags=["Generation"],
 )
-api_router.include_router(
-    generation_preview_router,
-    prefix="/generation",
-    tags=["Generation"],
-)
 api_router.include_router(
    titles_router,
    prefix="/titles",
@@ -19,9 +19,6 @@ from app.schemas.asset import (
    BatchTagRequest,
    CreateAssetRequest,
    ListAssetsResponse,
-    SmartMatchItem,
-    SmartMatchRequest,
-    SmartMatchResponse,
    UpdateAssetRequest,
    UpdateAssetReviewRequest,
 )
@@ -33,7 +30,6 @@ from packages.application import (
    CreateAssetUseCase,
 )
 from packages.domain import AssetStatus, ClassificationStatus
-from packages.domain.smart_match import smart_select_assets

 logger = logging.getLogger(__name__)

@@ -523,51 +519,6 @@ def batch_mark_assets(
    )


-@router.post("/smart-match", response_model=SmartMatchResponse)
-def smart_match_assets(
-    request: SmartMatchRequest,
-    authenticated_user: AuthenticatedUser = Depends(get_current_user),
-    asset_repository: Any = Depends(get_asset_repository),
-    asset_library_repository: Any = Depends(get_asset_library_repository),
-    project_repository: Any = Depends(get_project_repository),
-) -> SmartMatchResponse:
-    """智能选素材：根据素材库内容，按质量分+时长均衡+新鲜度+未使用偏好综合评分，返回 Top N 素材。"""
-    library = asset_library_repository.get(request.library_id)
-    if library is None:
-        raise HTTPException(status_code=404, detail=f"AssetLibrary {request.library_id} not found")
-    check_project_access(library.project_id, authenticated_user.user.id, project_repository)
-
-    # 获取素材库中所有 ready 素材（DB 层按 kind 过滤，避免加载不必要的数据到内存）
-    # kind → file_type 映射：schema 已校验只允许 video/image/audio，与 file_type 一致
-    if request.kind:
-        filtered_assets = asset_repository.find_by_library_and_file_type(
-            request.library_id, request.kind, status=["ready"], limit=10000
-        )
-    else:
-        filtered_assets = asset_repository.find_by_library(
-            request.library_id, status=["ready"], limit=10000
-        )
-    total_candidates = len(filtered_assets)
-
-    # 调用统一智能选素材算法（kind 已在 DB 层过滤，无需重复过滤）
-    results = smart_select_assets(
-        filtered_assets,
-        limit=request.limit,
-        kind=None,
-    )
-
-    items = [
-        SmartMatchItem(
-            asset=_to_asset_response(r.asset),
-            score=r.score,
-            breakdown=r.breakdown,
-        )
-        for r in results
-    ]
-
-    return SmartMatchResponse(items=items, total_candidates=total_candidates)
-
-
@router.get("/{asset_id}", response_model=AssetResponse)
 def get_asset(
    asset_id: str,
@@ -671,28 +622,20 @@ def create_asset(
    asset_library_repository: Any = Depends(get_asset_library_repository),
    project_repository: Any = Depends(get_project_repository),
 ) -> AssetResponse:
-    # 先获取素材库，用于推导 project_id（前端可能不传）
-    library = asset_library_repository.get(request.library_id)
-    if library is None:
-        raise HTTPException(status_code=404, detail=f"AssetLibrary {request.library_id} not found")
-
-    # project_id 自动推导：优先用请求值，否则从 library 关联的项目获取
-    project_id = request.project_id or library.project_id
-
-    project = project_repository.find_by_id(project_id)
+    project = project_repository.find_by_id(request.project_id)
    if project is None:
-        raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
+        raise HTTPException(status_code=404, detail=f"Project {request.project_id} not found")
    if not project.can_access(authenticated_user.user.id):
        raise HTTPException(status_code=403, detail="Access denied to project")

-    # 确保 library 和 project 归属一致
-    if library.project_id != project_id:
-        raise HTTPException(status_code=400, detail="AssetLibrary does not belong to the specified project")
+    library = asset_library_repository.get(request.library_id)
+    if library is None or library.project_id != request.project_id:
+        raise HTTPException(status_code=404, detail=f"AssetLibrary {request.library_id} not found")

    use_case = CreateAssetUseCase(asset_repository)
    item = use_case.execute(
        CreateAssetCommand(
-            project_id=project_id,
+            project_id=request.project_id,
            library_id=request.library_id,
            name=request.name,
            storage_key=request.storage_key,
@@ -1,403 +0,0 @@
-"""预览生成路由 — Phase 1：单版本预览接口（创建 + 查询）。
-
-路径前缀：/api/v1/generation/preview（与 /generation/tasks 同体系）
-"""
-
-from __future__ import annotations
-
-import logging
-
-from app.auth import AuthenticatedUser, get_current_user
-from app.core.storage import get_storage_service
-from app.core.task_enqueue import (
-    GLOBAL_PENDING_LIMIT,
-    USER_PENDING_LIMIT,
-    GlobalQueueFull,
-    UserPendingLimitExceeded,
-    safe_enqueue_generation_task,
-)
-from app.dependencies import (
-    get_db_session,
-    get_generated_video_repository,
-    get_generation_task_repository,
-)
-from app.schemas.generation_task import (
-    CreatePreviewGenerationTaskRequest,
-    PreviewGenerationTaskResponse,
-)
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
-
-from packages.adapters.sqlalchemy_impl.edit_template_repository import (
-    SQLAlchemyEditTemplateRepository,
-)
-from packages.adapters.sqlalchemy_impl.template_repository import (
-    SQLAlchemyTemplateRepository,
-)
-from packages.application import (
-    CreateGenerationTaskCommand,
-    CreateGenerationTaskUseCase,
-    GetGenerationTaskUseCase,
-    ListGeneratedVideosByTaskUseCase,
-)
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-PREVIEW_RESOLUTION = "854x480"
-
-# 模板 mode → 视频比例映射
-_TEMPLATE_MODE_TO_RATIO = {
-    "pip": "9:16",
-    "standard": "16:9",
-    "square": "1:1",
-}
-
-
-def _calc_preview_resolution(video_ratio: str = "") -> str:
-    """根据视频比例计算预览分辨率（短边 480，长边按比例）。
-
-    支持的比例：16:9, 9:16, 1:1, 4:3, 3:4, 其他默认 16:9。
-    """
-    ratio_map = {
-        "16:9": "854x480",
-        "9:16": "480x854",
-        "1:1": "480x480",
-        "4:3": "640x480",
-        "3:4": "480x640",
-    }
-    return ratio_map.get(video_ratio.strip(), PREVIEW_RESOLUTION)
-
-
-def _infer_video_ratio_from_template(
-    template_id: str, db: Session, user_id: str = ""
-) -> str:
-    """从模板 mode 推断视频比例，前端未传 video_ratio 时使用。
-
-    Returns:
-        视频比例字符串（如 "9:16"），查询失败返回空字符串。
-    """
-    if not template_id:
-        return ""
-    try:
-        repo = SQLAlchemyTemplateRepository(db)
-        template = repo.get(template_id, user_id)
-        if template:
-            mode = getattr(template, "mode", "") or ""
-            ratio = _TEMPLATE_MODE_TO_RATIO.get(mode.strip(), "")
-            if ratio:
-                logger.info(
-                    "[预览生成] 从模板 mode=%s 推断 video_ratio=%s",
-                    mode,
-                    ratio,
-                )
-            return ratio
-    except Exception:
-        logger.warning(
-            "[预览生成] 查询模板失败，跳过 video_ratio 推断: template_id=%s",
-            template_id,
-            exc_info=True,
-        )
-    return ""
-
-
-def _resolve_strategy_id_from_template(
-    template_id: str, db: Session, user_id: str = ""
-) -> str:
-    """从模板读取 editing_mode / mode 作为 strategy_id。
-
-    优先查新模板系统（EditTemplate.editing_mode），fallback 旧模板（Template.mode）。
-    Worker 端使用 strategy_id 作为渲染 mode，为空则默认 one_take。
-    """
-    if not template_id:
-        return ""
-
-    # 优先查新模板系统
-    try:
-        new_repo = SQLAlchemyEditTemplateRepository(db)
-        new_template = new_repo.get(template_id)
-        if new_template and getattr(new_template, "editing_mode", ""):
-            mode = new_template.editing_mode.strip()
-            if mode:
-                logger.info(
-                    "[预览生成] 从新模板 editing_mode=%s (template_id=%s)",
-                    mode,
-                    template_id,
-                )
-                # 画中画已下线，pip/voice_pip 统一映射为 one_take
-                if mode in ("pip", "voice_pip"):
-                    logger.info("[预览生成] %s → one_take (画中画已下线)", mode)
-                    mode = "one_take"
-                return mode
-    except Exception:
-        logger.debug(
-            "[预览生成] 新模板查询失败，尝试旧模板: template_id=%s",
-            template_id,
-            exc_info=True,
-        )
-
-    # fallback 旧模板系统
-    try:
-        old_repo = SQLAlchemyTemplateRepository(db)
-        old_template = old_repo.get(template_id, user_id)
-        if old_template:
-            mode = getattr(old_template, "mode", "") or ""
-            mode = mode.strip()
-            if mode:
-                logger.info(
-                    "[预览生成] 从旧模板 mode=%s (template_id=%s)",
-                    mode,
-                    template_id,
-                )
-                # 画中画已下线，pip/voice_pip 统一映射为 one_take
-                if mode in ("pip", "voice_pip"):
-                    logger.info("[预览生成] %s → one_take (画中画已下线)", mode)
-                    mode = "one_take"
-                return mode
-    except Exception:
-        logger.warning(
-            "[预览生成] 旧模板查询也失败，strategy_id 留空: template_id=%s",
-            template_id,
-            exc_info=True,
-        )
-
-    return ""
-
-
-def _mark_task_failed(repo, task, reason: str) -> None:
-    """入队失败时将任务标记为 failed，避免产生僵尸 pending 数据。"""
-    try:
-        task.mark_failed(error_message=f"入队失败：{reason}")
-        repo.update(task)
-    except Exception:
-        logger.exception("[预览生成] 标记任务失败时异常: task_id=%s", task.id)
-
-
-def _sign_video_url(raw_url: str) -> str:
-    """为私有 OSS bucket 的视频 URL 生成预签名下载链接。
-
-    有效期 2 小时，签名失败时降级返回原始 URL。
-    """
-    if not raw_url:
-        return ""
-    try:
-        storage = get_storage_service()
-        signed = storage.get_download_url(raw_url, expires_seconds=7200)
-        # 如果返回的 URL 与原始 URL 完全不同且不是签名 URL（说明 bucket 未配置），
-        # 降级返回原始 URL
-        if signed and signed != raw_url:
-            return signed
-        if signed == raw_url:
-            return raw_url
-        # signed 为空或与 raw_url 无关，返回原始
-        return raw_url
-    except Exception:
-        logger.warning("[预览] URL签名失败，降级返回原始URL: %s", raw_url[:100], exc_info=True)
-        return raw_url
-
-
-def _to_preview_response(task, generated_videos: list | None = None) -> PreviewGenerationTaskResponse:
-    """将领域任务对象转换为预览响应 DTO。
-
-    Args:
-        task: GenerationTask 领域对象
-        generated_videos: 生成的视频列表（可选），取第一个作为 video_url
-
-    Returns:
-        PreviewGenerationTaskResponse
-    """
-    video_url = ""
-    duration = 0.0
-    file_size = 0
-    if generated_videos:
-        first_video = generated_videos[0]
-        raw_url = getattr(first_video, "file_url", "") or ""
-        # P0 修复：私有 bucket 需要预签名 URL，否则前端 403 → 黑屏
-        video_url = _sign_video_url(raw_url)
-        duration = float(getattr(first_video, "duration", 0.0) or 0.0)
-        file_size = int(getattr(first_video, "file_size", 0) or 0)
-
-    # 从 extra_meta / metadata 中提取统计信息（如果有）
-    extra_meta = getattr(task, "extra_meta", {}) or {}
-    clip_count = int(extra_meta.get("clip_count", len(getattr(task, "asset_ids", [])) or 0))
-    transition_count = int(extra_meta.get("transition_count", max(0, clip_count - 1)))
-    material_usage = extra_meta.get("material_usage", {}) or {}
-
-    # 计算生成耗时
-    generate_duration = 0.0
-    started_at = getattr(task, "started_at", None)
-    completed_at = getattr(task, "completed_at", None)
-    if started_at and completed_at:
-        generate_duration = (completed_at - started_at).total_seconds()
-
-    return PreviewGenerationTaskResponse(
-        task_id=task.id,
-        status=task.status.value if hasattr(task.status, "value") else str(task.status),
-        progress=float(task.progress or 0.0),
-        is_preview=bool(getattr(task, "is_preview", True)),
-        resolution=getattr(task, "resolution", PREVIEW_RESOLUTION) or PREVIEW_RESOLUTION,
-        video_url=video_url,
-        duration=duration,
-        file_size=file_size,
-        clip_count=clip_count,
-        transition_count=transition_count,
-        material_usage=material_usage,
-        error_message=task.error_message or "",
-        created_at=task.created_at,
-        started_at=started_at,
-        finished_at=completed_at,
-        generate_duration=generate_duration,
-    )
-
-
-@router.post("/preview", response_model=PreviewGenerationTaskResponse, status_code=201)
-def create_preview_generation_task(
-    request: CreatePreviewGenerationTaskRequest,
-    authenticated_user: AuthenticatedUser = Depends(get_current_user),
-    generation_task_repository=Depends(get_generation_task_repository),
-    db: Session = Depends(get_db_session),
-) -> PreviewGenerationTaskResponse:
-    """创建预览生成任务。
-
-    预览为完整时长的低清版（480p + 低码率），效果与正式生成一致，仅清晰度降低。
-
-    Args:
-        request: 预览任务创建请求（template_id + asset_ids 等）
-
-    Returns:
-        201 + 预览任务详情
-    """
-    user_id = authenticated_user.user.id
-    logger.info(
-        "[预览生成] 接收请求: user_id=%s, template_id=%s, asset_count=%d, preview_count=%d",
-        user_id,
-        request.template_id,
-        len(request.asset_ids),
-        request.preview_count,
-    )
-
-    # 预检查队列限流
-    try:
-        user_pending = generation_task_repository.count_pending_by_user(user_id)
-        global_pending = generation_task_repository.count_pending_total()
-        if user_pending + 1 > USER_PENDING_LIMIT:
-            raise UserPendingLimitExceeded(user_id=user_id, pending_count=user_pending + 1, limit=USER_PENDING_LIMIT)
-        if global_pending + 1 > GLOBAL_PENDING_LIMIT:
-            raise GlobalQueueFull(pending_count=global_pending + 1, limit=GLOBAL_PENDING_LIMIT)
-    except UserPendingLimitExceeded as e:
-        raise HTTPException(
-            status_code=429,
-            detail=f"您的待处理任务过多（当前 {e.pending_count - 1}/{e.limit}），请等待后再提交",
-        ) from e
-    except GlobalQueueFull as e:
-        raise HTTPException(
-            status_code=503,
-            detail="系统繁忙，请稍后再试",
-        ) from e
-
-    # 确定视频比例：优先前端传入，否则从模板 mode 推断
-    video_ratio = request.video_ratio or ""
-    if not video_ratio and request.template_id:
-        video_ratio = _infer_video_ratio_from_template(request.template_id, db, user_id)
-
-    # 从模板读取 editing_mode / mode 作为 strategy_id（渲染 pipeline 的 mode 参数）
-    strategy_id = _resolve_strategy_id_from_template(request.template_id, db, user_id)
-
-    use_case = CreateGenerationTaskUseCase(generation_task_repository)
-
-    try:
-        task = use_case.execute(
-            CreateGenerationTaskCommand(
-                project_id="",
-                asset_library_id="",
-                strategy_id=strategy_id,
-                voice_library_id="",
-                template_id=request.template_id,
-                asset_ids=list(request.asset_ids),
-                title_ids=list(request.title_ids),
-                voice_ids=list(request.voice_ids),
-                created_by_user_id=user_id,
-                source_edit_plan_id="",
-                asset_select_mode="",
-                batch_id="",
-                video_title=request.video_title,
-                resolution=_calc_preview_resolution(video_ratio),
-                bgm_config=request.bgm_config or {},
-                auto_retry_enabled=False,
-                auto_retry_max=0,
-                is_preview=True,
-            )
-        )
-    except ValueError as e:
-        logger.warning("[预览生成] 创建失败: %s", e)
-        raise HTTPException(status_code=400, detail=str(e)) from e
-    except Exception as e:
-        logger.error("[预览生成] 创建失败: %s", e, exc_info=True)
-        raise HTTPException(status_code=500, detail="创建预览生成任务失败，请稍后再试") from e
-
-    # 入队执行；若入队失败则标记任务为 failed 避免僵尸数据
-    try:
-        if not safe_enqueue_generation_task(
-            task,
-            generation_task_repository,
-            user_id=user_id,
-            log_prefix="[预览生成]",
-            log_task_status=True,
-        ):
-            logger.warning("[预览生成] 任务入队失败: task_id=%s", task.id)
-            _mark_task_failed(generation_task_repository, task, "任务入队失败")
-            raise HTTPException(status_code=500, detail="任务入队失败，请稍后重试")
-    except UserPendingLimitExceeded as e:
-        _mark_task_failed(generation_task_repository, task, "待处理任务超限")
-        raise HTTPException(
-            status_code=429,
-            detail=f"您的待处理任务过多（当前 {e.pending_count - 1}/{e.limit}），请等待后再提交",
-        ) from None
-    except GlobalQueueFull:
-        _mark_task_failed(generation_task_repository, task, "系统队列已满")
-        raise HTTPException(
-            status_code=503,
-            detail="系统繁忙，请稍后再试",
-        ) from None
-
-    return _to_preview_response(task)
-
-
-@router.get("/preview/{task_id}", response_model=PreviewGenerationTaskResponse)
-def get_preview_generation_task(
-    task_id: str,
-    authenticated_user: AuthenticatedUser = Depends(get_current_user),
-    generation_task_repository=Depends(get_generation_task_repository),
-    generated_video_repository=Depends(get_generated_video_repository),
-) -> PreviewGenerationTaskResponse:
-    """查询预览生成任务状态。
-
-    Args:
-        task_id: 任务 ID
-
-    Returns:
-        预览任务详情（含状态、进度、结果 URL 等）
-    """
-    use_case = GetGenerationTaskUseCase(generation_task_repository)
-    task = use_case.execute(task_id)
-    if task is None:
-        raise HTTPException(status_code=404, detail=f"预览任务 {task_id} 不存在")
-
-    # 权限校验：任务必须属于当前用户（统一转 str 比较，避免 UUID/str 类型差异）
-    task_user_id = str(getattr(task, "created_by_user_id", "") or "")
-    if not task_user_id or task_user_id != str(authenticated_user.user.id):
-        raise HTTPException(status_code=403, detail="无权访问该任务")
-
-    # 校验是否为预览任务
-    if not getattr(task, "is_preview", False):
-        raise HTTPException(status_code=404, detail=f"预览任务 {task_id} 不存在")
-
-    # 查询生成的视频（取第一个）
-    generated_videos = []
-    status_val = task.status.value if hasattr(task.status, "value") else str(task.status)
-    if status_val == "completed":
-        list_use_case = ListGeneratedVideosByTaskUseCase(generated_video_repository)
-        generated_videos = list_use_case.execute(task_id)
-
-    return _to_preview_response(task, generated_videos=generated_videos)
@@ -38,7 +38,6 @@ from packages.application import (
    GetGenerationTaskUseCase,
    ListGeneratedVideosByTaskUseCase,
 )
-from packages.domain.smart_match import smart_select_assets

 logger = logging.getLogger(__name__)

@@ -125,11 +124,19 @@ def _select_assets_from_library(
        return [a.id for a in selected]

    if mode == "smart":
-        # 智能匹配：统一使用 packages/domain/smart_match.py 的多维评分+多样性选取
-        # 评分维度：质量分(40%) + 时长适配(30%) + 新鲜度(20%) + 未使用加分(10%)
-        limit = count if count > 0 else None
-        results = smart_select_assets(ready_video_assets, limit=limit, kind="video")
-        return [r.asset.id for r in results]
+        # 智能匹配：按质量分降序 + 时长降序作为tiebreaker
+        # 注意：这里使用简单的 quality_score 排序保持向后兼容
+        # 更复杂的4维评分+多样性策略由 SmartAssetSelector 服务提供（用于 AI 精选等场景）
+        scored_assets = sorted(
+            ready_video_assets,
+            key=lambda a: (
+                -(a.quality_score if a.quality_score is not None else 0.0),
+                -(getattr(a, "duration", 0.0) or 0.0),
+            ),
+        )
+        if count > 0:
+            scored_assets = scored_assets[:count]
+        return [a.id for a in scored_assets]

    # 默认 all 模式：返回全部 ready 视频素材
    return [a.id for a in ready_video_assets]
@@ -264,19 +271,13 @@ def create_generation_task(
            detail="系统繁忙，请稍后再试",
        ) from e

-    # 画中画已下线：strategy_id 中的 pip/voice_pip 统一映射为 one_take
-    effective_strategy_id = request.strategy_id
-    if effective_strategy_id in ("pip", "voice_pip"):
-        logger.info("画中画已下线，strategy_id %s → one_take", effective_strategy_id)
-        effective_strategy_id = "one_take"
-
    try:
        for _ in range(count):
            task = use_case.execute(
                CreateGenerationTaskCommand(
                    project_id=project_id,
                    asset_library_id=asset_library_id,
-                    strategy_id=effective_strategy_id,
+                    strategy_id=request.strategy_id,
                    voice_library_id=request.voice_library_id,
                    template_id=request.template_id,
                    asset_ids=resolved_asset_ids,
@@ -98,15 +98,6 @@ def _auto_fallback_assign_assets(
    clips_without_asset = [c for c in all_clips if not c.asset_id]
    config_asset_ids = (plan_check.config or {}).get("asset_ids", [])

-    logger.info(
-        "模板编辑器自动兜底3 诊断: plan=%s total_clips=%d "
-        "clips_without_asset=%d config_asset_ids=%r",
-        plan_id,
-        len(all_clips),
-        len(clips_without_asset),
-        config_asset_ids[:5] if config_asset_ids else [],
-    )
-
    if clips_without_asset and config_asset_ids:
        logger.info(
            "模板编辑器自动兜底3: plan=%s 为 %d 个无素材片段分配 %d 个指定素材",
@@ -114,42 +105,11 @@ def _auto_fallback_assign_assets(
            len(clips_without_asset),
            len(config_asset_ids),
        )
-        assigned = 0
        for i, clip in enumerate(clips_without_asset):
            asset_idx = i % len(config_asset_ids)
-            try:
-                svc.assign_asset(clip.id, config_asset_ids[asset_idx])
-                assigned += 1
-            except Exception as exc:
-                logger.error(
-                    "模板编辑器自动兜底3: plan=%s clip=%s 分配素材 %s 失败: %s",
-                    plan_id,
-                    clip.id,
-                    config_asset_ids[asset_idx],
-                    exc,
-                )
-        logger.info(
-            "模板编辑器自动兜底3: plan=%s 素材分配完成 assigned=%d/%d",
-            plan_id,
-            assigned,
-            len(clips_without_asset),
-        )
-        # 重新检查剩余无素材片段
-        all_clips_after = svc.list_clips(plan_id)
-        clips_without_asset = [c for c in all_clips_after if not c.asset_id]
-        if clips_without_asset:
-            logger.warning(
-                "模板编辑器自动兜底3: plan=%s 仍有 %d 个片段无素材",
-                plan_id,
-                len(clips_without_asset),
-            )
-    elif not clips_without_asset:
-        logger.info("模板编辑器自动兜底3: plan=%s 所有片段已有素材，跳过", plan_id)
-    elif not config_asset_ids:
-        logger.info(
-            "模板编辑器自动兜底3: plan=%s config.asset_ids 为空，跳过分配",
-            plan_id,
-        )
+            svc.assign_asset(clip.id, config_asset_ids[asset_idx])
+        logger.info("模板编辑器自动兜底3: plan=%s 素材分配完成", plan_id)
+        clips_without_asset = []

    return clips_without_asset

@@ -24,94 +24,6 @@ logger = logging.getLogger(__name__)
 router = APIRouter(tags=["Template Editor"])


-def _build_asset_analyses(
-    asset_ids: list[str],
-    db: Session,
-) -> dict[str, str]:
-    """调用 MediaKit 视频理解，返回 {asset_id: 分析文本}.
-
-    如果 MediaKit 不可用或分析失败，返回空 dict（调用方降级处理）。
-    """
-    if not asset_ids:
-        return {}
-
-    try:
-        from packages.adapters.sqlalchemy_impl.asset_repository import SQLAlchemyAssetRepository
-        from packages.shared.mediakit_client import get_mediakit_client
-        from packages.shared.storage import get_shared_storage_service
-
-        client = get_mediakit_client()
-        if not client.is_available:
-            logger.info("MediaKit 未配置，跳过视频理解分析")
-            return {}
-
-        asset_repo = SQLAlchemyAssetRepository(db)
-        storage_svc = get_shared_storage_service()
-
-        # 查找素材并获取下载 URL（使用并行列表保持索引对应，避免 URL 重复导致映射覆盖）
-        video_urls: list[str] = []
-        valid_asset_ids: list[str] = []
-
-        for aid in asset_ids[:10]:  # MediaKit 单次最多 10 个视频
-            asset = asset_repo.get(aid)
-            if not asset or not asset.storage_key:
-                continue
-            # 只处理视频素材
-            mime = getattr(asset, "mime_type", "")
-            if not mime.startswith("video/"):
-                continue
-            try:
-                url = storage_svc.get_download_url(asset.storage_key)
-                if url:
-                    video_urls.append(url)
-                    valid_asset_ids.append(aid)
-            except Exception as e:
-                logger.warning("获取素材URL失败: asset_id=%s error=%s", aid, str(e))
-
-        if not video_urls:
-            logger.info("无可用视频素材，跳过视频理解分析")
-            return {}
-
-        # 调用 MediaKit 视频理解
-        prompt = (
-            "请简要描述这段视频的主要内容，包括：场景（室内/室外/具体场所）、"
-            "主体（人物/物体/动物）、动作/活动、氛围/情绪、主要色调。"
-            "控制在100字以内。"
-        )
-
-        # 限制轮询参数以适配 API 网关超时（nginx 60s）
-        # 视频理解最多 30s（poll_interval=2s * max_poll_attempts=15）
-        # 剩余 30s 留给 LLM 调用
-        contents = client.analyze_videos(
-            video_urls=video_urls,
-            prompt=prompt,
-            level="Economy",
-            poll_interval=2.0,
-            max_poll_attempts=15,
-        )
-
-        if not contents:
-            logger.warning("MediaKit 视频理解未返回结果")
-            return {}
-
-        # 将结果映射回 asset_id（通过索引对应）
-        analyses: dict[str, str] = {}
-        for i, content in enumerate(contents):
-            if i < len(valid_asset_ids) and content:
-                analyses[valid_asset_ids[i]] = content
-
-        logger.info(
-            "MediaKit 视频理解完成: total=%d analyzed=%d",
-            len(video_urls),
-            len(analyses),
-        )
-        return analyses
-
-    except Exception as e:
-        logger.warning("MediaKit 视频理解异常，将降级到无分析模式: %s", str(e))
-        return {}
-
-
@router.post("/ai-recommend", response_model=AIRecommendResponse)
 def editor_ai_recommend(
    template_id: str,
@@ -134,16 +46,12 @@ def editor_ai_recommend(

    from packages.shared.ai_service import run_ai_recommend

-    # 调用 MediaKit 视频理解，获取素材内容分析
-    asset_analyses = _build_asset_analyses(body.asset_ids, db)
-
    result = run_ai_recommend(
        plan_id=plan_id,
        template_id=plan.template_id,
        asset_ids=body.asset_ids,
        editing_mode=body.editing_mode,
        target_duration=body.target_duration,
-        asset_analyses=asset_analyses,
    )

    try:
@@ -184,29 +184,6 @@ def editor_generate_cover(
    _, plan_svc = services
    plan = plan_svc.get_plan_or_raise(plan_id)

-    # 获取第一个视频的下载 URL（用于 MediaKit 抽帧）
-    primary_video_url = None
-    if body.asset_ids and body.cover_type in ("ai_frame", "ai_regenerate"):
-        try:
-            from app.database import get_db_session
-
-            from packages.adapters.sqlalchemy_impl.asset_repository import SQLAlchemyAssetRepository
-            from packages.shared.storage import get_shared_storage_service
-
-            with get_db_session() as session:
-                asset_repo = SQLAlchemyAssetRepository(session)
-                first_asset = asset_repo.get(body.asset_ids[0])
-                if first_asset and first_asset.storage_key:
-                    storage_svc = get_shared_storage_service()
-                    primary_video_url = storage_svc.get_download_url(first_asset.storage_key)
-                    logger.info(
-                        "获取视频URL用于封面生成: asset_id=%s url=%s",
-                        body.asset_ids[0],
-                        primary_video_url[:80] if primary_video_url else None,
-                    )
-        except Exception as e:
-            logger.warning("获取视频URL失败，将使用stub封面: %s", str(e))
-
    from packages.shared.ai_service import run_generate_cover

    cover_data = run_generate_cover(
@@ -214,7 +191,6 @@ def editor_generate_cover(
        asset_ids=body.asset_ids,
        cover_type=body.cover_type,
        frame_time=body.frame_time,
-        primary_video_url=primary_video_url,
    )

    current_config = dict(plan.config) if plan.config else {}
@@ -74,7 +74,7 @@ def generate_editor_draft(
        plan_svc, plan_id, plan_check, clips_without_asset, asset_library_repo, asset_repo
    )

-    # 检查是否可生成（含最后防线自动修复 + 诊断日志）
+    # 检查是否可生成
    try:
        can_gen, reason = plan_svc.can_generate(plan_id)
    except ValueError as exc:
@@ -11,7 +11,6 @@ from app.dependencies import get_cosyvoice_service, get_voice_clone_profile_repo
 from app.schemas.voice_clone import (
    CreateVoiceCloneRequest,
    ListVoiceCloneResponse,
-    VoiceClonePreviewResponse,
    VoiceCloneProfileResponse,
    VoiceCloneStatusResponse,
 )
@@ -20,7 +19,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query, Response, status
 from packages.adapters.sqlalchemy_impl.voice_clone_profile_repository import (
    SQLAlchemyVoiceCloneProfileRepository,
 )
-from packages.application.cosyvoice_service import CosyVoiceError, CosyVoiceService
+from packages.application.cosyvoice_service import CosyVoiceService
 from packages.application.voice_clone.use_cases import (
    DeleteVoiceCloneUseCase,
    GetVoiceCloneStatusUseCase,
@@ -37,13 +36,6 @@ logger = logging.getLogger(__name__)

 router = APIRouter()

-# 克隆音色试听缓存（减少重复TTS调用）
-# key: clone_id, value: (audio_url, duration, file_size, text, timestamp)
-_clone_preview_cache: dict[str, tuple[str, float, int, str, float]] = {}
-CLONE_PREVIEW_CACHE_TTL = 7 * 24 * 3600  # 7天TTL
-# 默认试听文本
-CLONE_PREVIEW_TEMPLATE = "你好，这是我的克隆音色，很高兴能为你配音。"
-

 def _to_response(profile) -> VoiceCloneProfileResponse:
    # source_audio_url 是用户传入的原始 URL（可能是外部地址），不做预签名转换
@@ -231,78 +223,3 @@ def retry_voice_clone(
                logger.error(f"Failed to mark profile as failed after dispatch error: {inner_e}")

    return _to_response(profile)
-
-
-@router.get("/{clone_id}/preview", response_model=VoiceClonePreviewResponse)
-def get_voice_clone_preview(
-    clone_id: str,
-    text: str = Query("", description="自定义试听文本，为空则使用默认示例"),
-    authenticated_user: AuthenticatedUser = Depends(get_current_user),
-    repository: SQLAlchemyVoiceCloneProfileRepository = Depends(get_voice_clone_profile_repository),
-    cosyvoice: CosyVoiceService = Depends(get_cosyvoice_service),
-) -> VoiceClonePreviewResponse:
-    """获取克隆音色试听音频（实时 TTS 合成）。
-
-    - 克隆音色必须处于 ready 状态
-    - 使用默认试听文本时，结果缓存 7 天
-    - 可传入自定义 text 参数试听不同文本
-    """
-    import time
-
-    use_case = GetVoiceCloneUseCase(repository)
-    try:
-        profile = use_case.execute(clone_id, authenticated_user.user.id)
-    except VoiceCloneNotFoundError as _e:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice clone not found") from _e
-
-    if not profile.is_ready:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Voice clone is not ready (current status: {profile.status})",
-        )
-
-    # 有自定义文本时不缓存
-    use_cache = not text.strip()
-
-    if use_cache and clone_id in _clone_preview_cache:
-        audio_url, duration, file_size, cached_text, cached_at = _clone_preview_cache[clone_id]
-        if time.time() - cached_at < CLONE_PREVIEW_CACHE_TTL:
-            return VoiceClonePreviewResponse(
-                clone_id=clone_id,
-                voice_id=profile.voice_id,
-                audio_url=audio_url,
-                text=cached_text,
-                duration=duration,
-                file_size=file_size,
-            )
-
-    # 合成试听音频
-    preview_text = text.strip() or CLONE_PREVIEW_TEMPLATE
-    try:
-        result = cosyvoice.synthesize_speech(
-            text=preview_text,
-            voice_id=profile.voice_id,
-            format="mp3",
-            speed=1.0,
-        )
-    except CosyVoiceError as e:
-        raise HTTPException(status_code=502, detail=f"TTS 合成失败: {e}") from e
-
-    # 缓存（仅默认试听文本）
-    if use_cache:
-        _clone_preview_cache[clone_id] = (
-            result.audio_url,
-            result.duration,
-            result.file_size,
-            preview_text,
-            time.time(),
-        )
-
-    return VoiceClonePreviewResponse(
-        clone_id=clone_id,
-        voice_id=profile.voice_id,
-        audio_url=result.audio_url,
-        text=preview_text,
-        duration=result.duration,
-        file_size=result.file_size,
-    )
@@ -5,8 +5,6 @@

 from __future__ import annotations

-import logging
-import time
 from typing import Literal, Optional

 from app.api.routes._helpers import get_user_plan
@@ -44,7 +42,6 @@ from packages.domain.preset_voices import PRESET_VOICES, get_preset_voice_by_id
 from packages.ports.user_repository import UserRepository

 router = APIRouter()
-logger = logging.getLogger(__name__)

 # 预置音色试听音频缓存（内存缓存，减少重复TTS调用）
 # key: voice_id, value: (audio_url, timestamp)
@@ -54,65 +51,6 @@ PREVIEW_CACHE_TTL = 7 * 24 * 3600  # 7天TTL
 PREVIEW_TEMPLATE = "你好，我是{name}，很高兴认识你。"


-def _resolve_preset_preview_url(
-    voice_id: str,
-    fallback_url: str,
-    cosyvoice: CosyVoiceService,
-) -> str:
-    """为预置音色获取有效的 preview_url.
-
-    优先从内存缓存读取；缓存失效时调用 CosyVoice 重新合成；
-    合成失败时降级返回硬编码 URL（可能已过期，但不会报错）。
-    """
-    # 检查缓存
-    if voice_id in _preset_preview_cache:
-        audio_url, cached_at = _preset_preview_cache[voice_id]
-        if time.time() - cached_at < PREVIEW_CACHE_TTL:
-            return audio_url
-
-    # 缓存失效，调用 CosyVoice 合成
-    preset = get_preset_voice_by_id(voice_id)
-    if preset is None:
-        return fallback_url
-
-    preview_text = PREVIEW_TEMPLATE.format(name=preset.name)
-    try:
-        result = cosyvoice.synthesize_speech(
-            text=preview_text,
-            voice_id=voice_id,
-            format="mp3",
-            speed=1.0,
-        )
-        audio_url = result.audio_url
-        _preset_preview_cache[voice_id] = (audio_url, time.time())
-        logger.info("Preset voice preview generated: %s", voice_id)
-        return audio_url
-    except Exception as e:
-        logger.warning("Failed to generate preview for %s, using fallback: %s", voice_id, e)
-        return fallback_url
-
-
-def _resolve_all_preset_preview_urls(
-    presets: list,
-    cosyvoice: CosyVoiceService,
-) -> dict[str, str]:
-    """顺序解析所有预置音色的 preview_url.
-
-    采用顺序调用（而非并行）以避免触发 DashScope API 速率限制。
-    首次调用后结果缓存 7 天，后续请求直接命中缓存。
-
-    Returns:
-        voice_id -> preview_url 映射
-    """
-    result_map: dict[str, str] = {}
-    for p in presets:
-        try:
-            result_map[p.voice_id] = _resolve_preset_preview_url(p.voice_id, p.preview_url, cosyvoice)
-        except Exception:
-            result_map[p.voice_id] = p.preview_url
-    return result_map
-
-
 def _get_voice_repository(session: Session = Depends(get_db_session)) -> SQLAlchemyVoiceLibraryRepository:
    return SQLAlchemyVoiceLibraryRepository(session)

@@ -180,16 +118,8 @@ def _to_unified_response(item, profile_id_map: dict | None = None, sign_url=None
    )


-def _preset_to_unified_response(preset, preview_url_map: dict[str, str] | None = None) -> UnifiedVoiceItemResponse:
-    """将预置音色转换为统一响应格式。
-
-    Args:
-        preset: 预置音色对象
-        preview_url_map: voice_id -> preview_url 动态映射，优先使用
-    """
-    preview_url = preset.preview_url
-    if preview_url_map and preset.voice_id in preview_url_map:
-        preview_url = preview_url_map[preset.voice_id]
+def _preset_to_unified_response(preset) -> UnifiedVoiceItemResponse:
+    """将预置音色转换为统一响应格式。"""
    return UnifiedVoiceItemResponse(
        id=preset.voice_id,
        type="preset",
@@ -199,40 +129,11 @@ def _preset_to_unified_response(preset, preview_url_map: dict[str, str] | None =
        language=preset.language,
        voice_id=preset.voice_id,
        voice_provider="cosyvoice",
-        preview_url=preview_url,
+        preview_url=preset.preview_url,
        tags=preset.tags or [],
    )


-def _clone_profile_to_unified_response(profile) -> UnifiedVoiceItemResponse:
-    """将克隆音色档案转换为统一响应格式。
-
-    注意：克隆音色是「音色模型」（可用于 TTS 合成任意文本），
-    不同于配音库条目（具体的配音作品）。
-    """
-    return UnifiedVoiceItemResponse(
-        id=profile.id,
-        type="clone",
-        name=profile.name,
-        description=profile.description or "",
-        gender=profile.gender or "unknown",
-        language=profile.language or "zh-CN",
-        voice_id=profile.voice_id or "",
-        voice_provider=profile.voice_model or "cosyvoice",
-        audio_url="",  # 克隆音色没有预合成音频，需通过 /voice-clones/{id}/preview 试听
-        preview_url="",  # 试听需实时合成，前端调用 preview 接口
-        duration=0,
-        file_size=0,
-        status=profile.status.value if hasattr(profile.status, "value") else str(profile.status),
-        tags=[],
-        user_id=profile.user_id,
-        project_id=None,
-        voice_clone_profile_id=profile.id,
-        created_at=profile.created_at,
-        updated_at=profile.updated_at,
-    )
-
-
 # ==================== 统一配音列表（预置 + 克隆）====================


@@ -249,7 +150,6 @@ def list_voices_unified(
    voice_repository: SQLAlchemyVoiceLibraryRepository = Depends(_get_voice_repository),
    clone_profile_repository: SQLAlchemyVoiceCloneProfileRepository = Depends(_get_clone_profile_repository),
    sign_url=Depends(get_audio_url_signer),
-    cosyvoice: CosyVoiceService = Depends(get_cosyvoice_service),
 ) -> UnifiedVoiceListResponse:
    """获取配音列表（预置音色 + 用户克隆音色）。

@@ -265,30 +165,19 @@ def list_voices_unified(
    has_preset = type is None or type == "preset"
    has_clone = type is None or type == "clone"

-    # 获取预置音色（动态生成 preview_url）
+    # 获取预置音色
    if has_preset:
-        preview_url_map = _resolve_all_preset_preview_urls(PRESET_VOICES, cosyvoice)
-        preset_items = [_preset_to_unified_response(p, preview_url_map) for p in PRESET_VOICES]
+        preset_items = [_preset_to_unified_response(p) for p in PRESET_VOICES]
        preset_count = len(preset_items)

-    # 获取克隆音色（从 voice_clone_profile 读取，ready 状态的克隆音色）
+    # 获取克隆音色
    if has_clone:
-        # status_filter 映射：不传则默认只返回 ready 状态（可用的克隆音色）
-        # 前端可以传 status=all 获取所有状态，或传具体状态过滤
-        filter_status = None
-        if status_filter and status_filter != "all":
-            filter_status = status_filter
-        elif not status_filter:
-            filter_status = "ready"
-
-        clone_profiles = clone_profile_repository.list_by_user(
-            user_id,
-            status=filter_status,
-            limit=limit,
-            offset=skip,
-        )
-        clone_count = clone_profile_repository.count_by_user(user_id, status=filter_status)
-        clone_items = [_clone_profile_to_unified_response(p) for p in clone_profiles]
+        use_case = ListVoiceLibraryUseCase(voice_repository)
+        clone_items_raw, clone_count = use_case.execute(user_id, status=status_filter, skip=skip, limit=limit)
+        # 批量查询 voice_id → profile_id 映射，填充 voice_clone_profile_id
+        voice_ids = [i.voice_id for i in clone_items_raw if i.voice_id]
+        profile_id_map = clone_profile_repository.find_profile_ids_by_voice_ids(voice_ids) if voice_ids else {}
+        clone_items = [_to_unified_response(i, profile_id_map, sign_url) for i in clone_items_raw]

    # 组装结果
    if type == "preset":
@@ -315,15 +204,11 @@ def list_voices_unified(


@router.get("/presets", response_model=PresetVoiceListResponse)
-def list_preset_voices(
-    cosyvoice: CosyVoiceService = Depends(get_cosyvoice_service),
-) -> PresetVoiceListResponse:
+def list_preset_voices() -> PresetVoiceListResponse:
    """获取预置音色列表。

    不需要认证，返回所有系统预置的 CosyVoice 音色。
-    preview_url 通过 CosyVoice 动态生成，不依赖硬编码的过期 URL。
    """
-    preview_url_map = _resolve_all_preset_preview_urls(PRESET_VOICES, cosyvoice)
    items = [
        PresetVoiceItemResponse(
            voice_id=p.voice_id,
@@ -331,7 +216,7 @@ def list_preset_voices(
            description=p.description,
            gender=p.gender,
            language=p.language,
-            preview_url=preview_url_map.get(p.voice_id, p.preview_url),
+            preview_url=p.preview_url,
            tags=p.tags or [],
        )
        for p in PRESET_VOICES
@@ -351,6 +236,8 @@ def get_preset_voice_preview(
    - 相同 voice_id 重复调用直接返回缓存的音频URL
    - 可传入自定义 text 参数试听不同文本
    """
+    import time
+
    preset = get_preset_voice_by_id(voice_id)
    if preset is None:
        raise HTTPException(status_code=404, detail=f"预置音色不存在: {voice_id}")
@@ -2,7 +2,7 @@ from pydantic import BaseModel, Field


 class CreateAssetRequest(BaseModel):
-    project_id: str | None = Field(default=None, description="可选，不传时从 library.project_id 自动推导")
+    project_id: str = Field(..., min_length=1)
    library_id: str = Field(..., min_length=1)
    name: str = Field(..., min_length=1, max_length=100)
    storage_key: str = Field(..., min_length=1, max_length=255)
@@ -101,30 +101,3 @@ class ListAssetsResponse(BaseModel):
    total: int = Field(default=0, ge=0)
    skip: int = Field(default=0, ge=0)
    limit: int = Field(default=100, ge=1)
-
-
-class SmartMatchRequest(BaseModel):
-    """智能选素材请求。"""
-
-    library_id: str = Field(..., min_length=1, description="素材库 ID")
-    limit: int | None = Field(default=None, ge=1, le=200, description="最大返回数量，不传则返回全部匹配素材")
-    kind: str | None = Field(
-        default=None,
-        pattern="^(video|image|audio)$",
-        description="按文件类型过滤，不传则返回所有类型",
-    )
-
-
-class SmartMatchItem(BaseModel):
-    """智能选素材结果条目。"""
-
-    asset: AssetResponse
-    score: float = Field(..., ge=0, le=100, description="综合得分 0-100")
-    breakdown: dict[str, float] = Field(default_factory=dict, description="各维度得分明细")
-
-
-class SmartMatchResponse(BaseModel):
-    """智能选素材响应。"""
-
-    items: list[SmartMatchItem]
-    total_candidates: int = Field(default=0, ge=0, description="参与评分的候选素材总数")
@@ -1,5 +1,4 @@
 import json
-from datetime import datetime

 from pydantic import BaseModel, Field, field_validator, model_validator

@@ -123,68 +122,3 @@ class ListGenerationTasksResponse(BaseModel):
    """用户级生成任务列表响应（跨 project）。"""

    items: list[GenerationTaskResponse]
-
-
-# ── 预览生成（Phase 1） ───────────────────────────────────────────────────────
-
-
-class CreatePreviewGenerationTaskRequest(BaseModel):
-    """创建预览生成任务请求。
-
-    仅支持模板模式：template_id + asset_ids 等素材 ID 列表。
-    预览为完整时长低清版（480p + 低码率）。
-    """
-
-    template_id: str
-    asset_ids: list[str] = Field(default_factory=list)
-    title_ids: list[str] = Field(default_factory=list)
-    voice_ids: list[str] = Field(default_factory=list)
-    video_title: str = Field(default="", description="生成视频的标题/名称，为空则使用默认命名")
-    duration: float = Field(default=0.0, ge=0, description="期望视频时长（秒），0 表示由模板决定")
-    video_ratio: str = Field(default="", description="视频比例，如 16:9 / 9:16，为空使用模板默认")
-    bgm_config: dict = Field(
-        default_factory=dict,
-        description="自定义BGM配置，覆盖模板BGM设置。支持 enabled/source/asset_id/preset_id/audio_url/volume 等字段",
-    )
-    preview_count: int = Field(
-        default=1,
-        ge=1,
-        le=10,
-        description="预览视频生成数量，范围 1-10，默认 1",
-    )
-
-    @model_validator(mode="after")
-    def _check_template_id(self) -> "CreatePreviewGenerationTaskRequest":
-        if not self.template_id.strip():
-            raise ValueError("template_id 不能为空")
-        return self
-
-    @model_validator(mode="after")
-    def _check_asset_ids(self) -> "CreatePreviewGenerationTaskRequest":
-        if not self.asset_ids and not self.title_ids and not self.voice_ids:
-            raise ValueError("asset_ids/title_ids/voice_ids 至少需要提供一个")
-        return self
-
-
-class PreviewGenerationTaskResponse(BaseModel):
-    """预览生成任务响应。
-
-    包含任务状态、进度、分辨率、生成结果 URL 等关键字段。
-    """
-
-    task_id: str
-    status: str
-    progress: float
-    is_preview: bool = True
-    resolution: str = ""
-    video_url: str = ""
-    duration: float = 0.0
-    file_size: int = 0
-    clip_count: int = 0
-    transition_count: int = 0
-    material_usage: dict = Field(default_factory=dict)
-    error_message: str = ""
-    created_at: datetime | None = None
-    started_at: datetime | None = None
-    finished_at: datetime | None = None
-    generate_duration: float = 0.0
@@ -63,25 +63,3 @@ class ListVoiceCloneResponse(BaseModel):

    items: List[VoiceCloneProfileResponse]
    total: int
-
-
-class VoiceClonePreviewResponse(BaseModel):
-    """克隆音色试听响应。"""
-
-    clone_id: str
-    """音色克隆档案 ID"""
-
-    voice_id: str
-    """CosyVoice 音色 ID"""
-
-    audio_url: str
-    """试听音频 URL"""
-
-    text: str
-    """试听文本"""
-
-    duration: float = 0.0
-    """音频时长（秒）"""
-
-    file_size: int = 0
-    """文件大小（字节）"""
@@ -12,6 +12,7 @@

 from __future__ import annotations

+import json
 import logging
 from typing import Any, Dict, List, Optional

@@ -571,10 +571,6 @@ class EditPlanService:
    def can_generate(self, plan_id: str) -> tuple[bool, str]:
        """检查是否可以触发渲染

-        包含最后一道防线的自动修复：
-        - 如果 clips 存在但都没有 asset_id，且 config.asset_ids 非空，
-          直接在内部执行素材分配，不再依赖前置 fallback 链路。
-
        Returns:
            tuple: (can_generate, reason)
        """
@@ -589,69 +585,10 @@ class EditPlanService:
        if not clips:
            return False, "请先添加片段后再生成视频"

-        # 检查是否至少有一个片段分配了素材
-        has_asset = any(c.asset_id for c in clips)
-        config_asset_ids_count = len((plan.config or {}).get("asset_ids", []))
-        clips_with_asset_count = sum(1 for c in clips if c.asset_id)
-        logger.info(
-            "can_generate 诊断: plan=%s status=%s total_clips=%d " "clips_with_asset=%d config_asset_ids_count=%d",
-            plan_id,
-            plan.status,
-            len(clips),
-            clips_with_asset_count,
-            config_asset_ids_count,
-        )
-        if not has_asset:
-            # ── 最后防线：自动从 config.asset_ids 分配素材 ──
-            config_asset_ids = (plan.config or {}).get("asset_ids", [])
-            if config_asset_ids:
-                logger.warning(
-                    "can_generate 最后防线触发: plan=%s clips=%d 均无素材，" "从 config.asset_ids(%d个) 自动分配",
-                    plan_id,
-                    len(clips),
-                    len(config_asset_ids),
-                )
-                clips_without_asset = [c for c in clips if not c.asset_id]
-                assigned_count = 0
-                for i, clip in enumerate(clips_without_asset):
-                    asset_idx = i % len(config_asset_ids)
-                    try:
-                        self.assign_asset(clip.id, config_asset_ids[asset_idx])
-                        assigned_count += 1
-                    except Exception as exc:
-                        logger.warning(
-                            "can_generate 最后防线: plan=%s clip=%s 分配素材 %s 失败: %s",
-                            plan_id,
-                            clip.id,
-                            config_asset_ids[asset_idx],
-                            exc,
-                        )
-                logger.info(
-                    "can_generate 最后防线: plan=%s 已为 %d/%d 个片段分配素材",
-                    plan_id,
-                    assigned_count,
-                    len(clips_without_asset),
-                )
-                # 重新加载 clips 验证分配结果
-                clips = self._clip_repo.list_by_plan(plan_id)
-                if not any(c.asset_id for c in clips):
-                    return False, "没有可渲染的就绪片段，自动修复后仍未分配素材"
-            else:
-                logger.warning(
-                    "can_generate 失败: plan=%s clips=%d 均无素材，" "且 config.asset_ids 为空，无法自动修复",
-                    plan_id,
-                    len(clips),
-                )
-                return False, "没有可渲染的就绪片段，请确保已选择素材"
-
        return True, ""

    def mark_clips_ready(self, plan_id: str) -> int:
-        """将已分配素材的 pending 片段标记为 ready
-
-        只标记同时满足以下条件的片段：
-        - status == PENDING
-        - asset_id 非空（已分配素材）
+        """将所有 pending 状态的片段标记为 ready

        Returns:
            int: 标记的片段数量
@@ -662,16 +599,10 @@ class EditPlanService:
        )
        count = 0
        for clip in clips:
-            if clip.asset_id:
-                clip.mark_ready()
-                self._clip_repo.update(clip)
-                count += 1
-        logger.info(
-            "标记片段就绪: plan_id=%s marked=%d total_pending=%d",
-            plan_id,
-            count,
-            len(clips),
-        )
+            clip.mark_ready()
+            self._clip_repo.update(clip)
+            count += 1
+        logger.info("标记片段就绪: plan_id=%s count=%d", plan_id, count)
        return count

    def update_plan_config(self, plan_id: str, config_updates: Dict[str, Any]) -> EditPlan:
@@ -49,10 +49,9 @@ class PlanGeneratorService:
    基于模板 + 素材，自动生成 EditPlan 及 EditPlanClip 列表。
    """

-    def __init__(self, db: Session, asset_repo=None) -> None:
+    def __init__(self, db: Session) -> None:
        self._plan_repo = SQLAlchemyEditPlanRepository(db)
        self._clip_repo = SQLAlchemyEditPlanClipRepository(db)
-        self._asset_repo = asset_repo

    # ── 公开接口 ─────────────────────────────────────────────────────────────

@@ -65,7 +64,6 @@ class PlanGeneratorService:
        project_id: str = "",
        created_by_user_id: str = "",
        name: str = "",
-        random_preview: bool = False,
    ) -> dict[str, Any]:
        """基于模板+素材生成剪辑计划

@@ -76,7 +74,6 @@ class PlanGeneratorService:
            project_id: 所属项目 ID
            created_by_user_id: 创建者用户 ID
            name: 计划名称（为空则自动取模板名）
-            random_preview: 是否启用随机预览模式（随机选素材+随机截取片段）

        Returns:
            dict: {"plan": EditPlan, "clips": List[EditPlanClip]}
@@ -118,17 +115,7 @@ class PlanGeneratorService:

        # 4. 按 editing_mode 分配素材
        if asset_ids:
-            # 如果是随机预览模式，获取素材时长信息
-            asset_durations = None
-            if random_preview and self._asset_repo:
-                asset_durations = self._fetch_asset_durations(asset_ids)
-            self._distribute_assets(
-                clips,
-                asset_ids,
-                editing_mode,
-                random_selection=random_preview,
-                asset_durations=asset_durations,
-            )
+            self._distribute_assets(clips, asset_ids, editing_mode)

        # 5. 持久化所有 clips 并计算总时长
        created_clips: List[EditPlanClip] = []
@@ -212,34 +199,9 @@ class PlanGeneratorService:
        clips: List[EditPlanClip],
        asset_ids: List[str],
        editing_mode: str,
-        *,
-        random_selection: bool = False,
-        asset_durations: dict[str, float] | None = None,
    ) -> None:
        """按 editing_mode 将素材分配到 clips（就地修改，未持久化）.

        委托给 plan_generator_utils.distribute_assets 纯函数。
        """
-        distribute_assets(
-            clips,
-            asset_ids,
-            editing_mode,
-            random_selection=random_selection,
-            asset_durations=asset_durations,
-        )
-
-    def _fetch_asset_durations(self, asset_ids: List[str]) -> dict[str, float]:
-        """从数据库获取素材时长信息.
-
-        Args:
-            asset_ids: 素材 ID 列表
-
-        Returns:
-            dict: 素材 ID -> 时长（秒）映射
-        """
-        durations: dict[str, float] = {}
-        for asset_id in asset_ids:
-            asset = self._asset_repo.get(asset_id)
-            if asset and hasattr(asset, "duration"):
-                durations[asset_id] = float(asset.duration or 0.0)
-        return durations
+        distribute_assets(clips, asset_ids, editing_mode)
@@ -0,0 +1,164 @@
+"""SmartAssetSelector — 智能素材选择服务.
+
+根据多维度评分从素材库中自动选择最优视频素材，
+用于一键生成等需要自动选取素材的场景。
+
+评分维度（加权求和，总分 0-1）：
+  - 质量分（quality_score）：权重 0.5 — 来自人工或AI的质量评分
+  - 分辨率适配：权重 0.2 — 分辨率越接近 1080p 得分越高
+  - 时长合理性：权重 0.2 — 3-30 秒区间最佳，过短/过长扣分
+  - 码率质量：权重 0.1 — 用文件大小/时长估算，码率适中得分高
+
+特性：
+  - 最低质量分门槛：自动过滤低质量素材
+  - 时长多样性：保证选出的素材时长分布均匀（短/中/长各占一定比例）
+  - 兼容全部模式：素材库模式和项目模式都可用
+
+纯逻辑部分已抽离到 packages.domain.asset_scoring。
+"""
+
+from __future__ import annotations
+
+import logging
+
+from packages.domain.asset_scoring import MEDIUM_BUCKET_MAX as _MEDIUM_BUCKET_MAX  # noqa: F401 - re-export for tests
+from packages.domain.asset_scoring import SHORT_BUCKET_MAX as _SHORT_BUCKET_MAX  # noqa: F401 - re-export for tests
+from packages.domain.asset_scoring import (
+    AssetScoreDetail,
+    SmartSelectResult,
+    diverse_selection,
+    filter_candidates,
+    score_asset_detail,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class SmartAssetSelector:
+    """智能素材选择器.
+
+    从一组素材中按综合评分选择最优的 N 个，
+    同时保证时长分布的多样性。
+    """
+
+    def __init__(
+        self,
+        min_quality_score: float = 30.0,
+        target_width: int = 1920,
+        target_height: int = 1080,
+    ):
+        self.min_quality_score = min_quality_score
+        self.target_width = target_width
+        self.target_height = target_height
+
+    # ── 公开方法 ──────────────────────────────────────────────────────────────
+
+    def select(
+        self,
+        assets: list,
+        count: int = 0,
+        *,
+        ensure_diversity: bool = True,
+    ) -> SmartSelectResult:
+        """从素材列表中智能选择最优素材.
+
+        Args:
+            assets: Asset 实体列表（需要有 id/quality_score/width/height/duration/file_size 属性）
+            count: 选取数量，0 表示全部符合条件的
+            ensure_diversity: 是否保证时长多样性（默认开启）
+
+        Returns:
+            SmartSelectResult 选择结果
+        """
+        # 1. 过滤：只保留 ready 状态的视频素材 + 最低质量分门槛
+        candidates, filtered_out = filter_candidates(assets, self.min_quality_score)
+
+        if not candidates:
+            return SmartSelectResult(
+                selected_ids=[],
+                total_candidates=0,
+                filtered_out=filtered_out,
+                avg_score=0.0,
+                details=[],
+            )
+
+        # 2. 对每个候选素材评分
+        scored: list[AssetScoreDetail] = []
+        for asset in candidates:
+            detail = score_asset_detail(
+                asset_id=asset.id,
+                quality=getattr(asset, "quality_score", None),
+                width=getattr(asset, "width", None),
+                height=getattr(asset, "height", None),
+                duration=getattr(asset, "duration", None),
+                file_size=getattr(asset, "file_size", 0) or 0,
+                target_width=self.target_width,
+                target_height=self.target_height,
+            )
+            scored.append(detail)
+
+        # 3. 按总分降序排列
+        scored.sort(key=lambda d: d.total_score, reverse=True)
+
+        # 4. 多样性选择（如果需要且数量有限制）
+        if ensure_diversity and count > 0 and len(scored) > count:
+            selected = diverse_selection(scored, count)
+        else:
+            # 无数量限制或不要求多样性，直接按排名取
+            selected = scored if count <= 0 else scored[:count]
+
+        avg_score = sum(d.total_score for d in selected) / len(selected) if selected else 0.0
+
+        result = SmartSelectResult(
+            selected_ids=[d.asset_id for d in selected],
+            total_candidates=len(candidates),
+            filtered_out=filtered_out,
+            avg_score=avg_score,
+            details=selected,
+        )
+
+        logger.info(
+            "智能素材选择完成: 候选=%d, 过滤=%d, 选中=%d, 平均分=%.3f",
+            result.total_candidates,
+            result.filtered_out,
+            len(result.selected_ids),
+            result.avg_score,
+        )
+        return result
+
+    # ── 向后兼容：私有方法别名（委托给 asset_scoring 纯函数） ────────────────
+
+    def _score_asset(self, asset) -> AssetScoreDetail:
+        """对单个素材进行多维度评分（向后兼容）."""
+        return score_asset_detail(
+            asset_id=asset.id,
+            quality=getattr(asset, "quality_score", None),
+            width=getattr(asset, "width", None),
+            height=getattr(asset, "height", None),
+            duration=getattr(asset, "duration", None),
+            file_size=getattr(asset, "file_size", 0) or 0,
+            target_width=self.target_width,
+            target_height=self.target_height,
+        )
+
+    def _score_resolution(self, width: int | None, height: int | None) -> float:
+        """分辨率评分（向后兼容）."""
+        from packages.domain.asset_scoring import score_resolution
+
+        return score_resolution(width, height, self.target_width, self.target_height)
+
+    def _score_duration(self, duration: float | None) -> float:
+        """时长评分（向后兼容）."""
+        from packages.domain.asset_scoring import score_duration
+
+        return score_duration(duration)
+
+    def _score_bitrate(self, file_size: int, duration: float | None) -> float:
+        """码率评分（向后兼容）."""
+        from packages.domain.asset_scoring import score_bitrate
+
+        return score_bitrate(file_size, duration)
+
+    def _diverse_selection(self, scored: list[AssetScoreDetail], count: int) -> list[AssetScoreDetail]:
+        """多样性选择（向后兼容）."""
+        return diverse_selection(scored, count)
@@ -196,31 +196,24 @@ test.describe("Core generation flow", () => {
    await materialLabel.locator("input[type='checkbox']").check()
    await page.getByRole("button", { name: "下一步" }).click()

-    // Step 3: voice (可选步骤，新注册用户无配音素材，直接跳过)
-    await expect(page.getByRole("heading", { name: /选择配音/ })).toBeVisible({ timeout: 15000 })
+    // Step 3: preview (纯展示页，AI 智能匹配预览)
+    await expect(page.getByRole("heading", { name: /生成预览/ })).toBeVisible()
    await page.getByRole("button", { name: "下一步" }).click()

-    // Step 4: preview — 需要先生成预览视频，才能进入下一步
-    await expect(page.getByRole("heading", { name: /生成预览/ })).toBeVisible({ timeout: 15000 })
-    // 点击"生成预览"按钮触发预览生成
-    await page.locator(".xx-preview-generate-btn").click()
-    // 等待预览生成完成（后端渲染，可能需要较长时间）
-    await expect(page.getByText("预览生成成功")).toBeVisible({ timeout: 120_000 })
-    await page.getByRole("button", { name: "下一步" }).click()
-
-    // Step 5: title
-    await expect(page.getByRole("heading", { name: /选择标题/ })).toBeVisible({ timeout: 15000 })
-    // 如果 AI 自动选择标题模式开启，先切换到手动模式以显示输入框
-    const aiSwitch = page.locator(".xx-title-ai-toggle .xx-switch.active")
-    if (await aiSwitch.isVisible({ timeout: 2000 }).catch(() => false)) {
-      await aiSwitch.click()
-    }
+    // Step 4: title
+    await expect(page.getByRole("heading", { name: /选择标题/ })).toBeVisible()
    const titleText = `E2E Test ${suffix}`
-    await page.getByPlaceholder("输入或从标题库选择…").fill(titleText)
+    await page.getByPlaceholder("输入自定义标题…").fill(titleText)
+    await page.getByRole("button", { name: "下一步" }).click()
+
+    // Step 5: voice
+    await expect(page.getByRole("heading", { name: /选择配音/ })).toBeVisible()
+    const firstVoiceCard = page.locator(".xx-voice-choice-item").first()
+    await firstVoiceCard.click()
    await page.getByRole("button", { name: "下一步" }).click()

    // Step 6: cover (默认 AI 智能选帧模式，直接下一步)
-    await expect(page.getByRole("heading", { name: /选择封面/ })).toBeVisible({ timeout: 15000 })
+    await expect(page.getByRole("heading", { name: /选择封面/ })).toBeVisible()
    await page.getByRole("button", { name: "下一步" }).click()

    // Step 7: confirm and generate
@@ -1847,7 +1847,7 @@
    },
    "node_modules/@testing-library/dom": {
      "version": "10.4.1",
-      "resolved": "https://registry.npmmirror.com/@testing-library/dom/-/dom-10.4.1.tgz",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
      "dev": true,
      "license": "MIT",
@@ -1937,7 +1937,7 @@
    },
    "node_modules/@types/aria-query": {
      "version": "5.0.4",
-      "resolved": "https://registry.npmmirror.com/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
      "dev": true,
      "license": "MIT",
@@ -3112,7 +3112,7 @@
    },
    "node_modules/dom-accessibility-api": {
      "version": "0.5.16",
-      "resolved": "https://registry.npmmirror.com/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
      "dev": true,
      "license": "MIT",
@@ -4028,6 +4028,18 @@
        "node": ">= 4"
      }
    },
+    "node_modules/immer": {
+      "version": "10.2.0",
+      "resolved": "https://registry.npmjs.org/immer/-/immer-10.2.0.tgz",
+      "integrity": "sha512-d/+XTN3zfODyjr89gM3mPq1WNX2B8pYsu7eORitdwyA2sBubnTl3laYlBk4sXY5FUa5qTZGBDPJICVbvqzjlbw==",
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/immer"
+      }
+    },
    "node_modules/import-fresh": {
      "version": "3.3.1",
      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
@@ -4456,7 +4468,7 @@
    },
    "node_modules/lz-string": {
      "version": "1.5.0",
-      "resolved": "https://registry.npmmirror.com/lz-string/-/lz-string-1.5.0.tgz",
+      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
      "dev": true,
      "license": "MIT",
@@ -4998,7 +5010,7 @@
    },
    "node_modules/pretty-format": {
      "version": "27.5.1",
-      "resolved": "https://registry.npmmirror.com/pretty-format/-/pretty-format-27.5.1.tgz",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
      "dev": true,
      "license": "MIT",
@@ -5014,7 +5026,7 @@
    },
    "node_modules/pretty-format/node_modules/ansi-styles": {
      "version": "5.2.0",
-      "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
      "dev": true,
      "license": "MIT",
@@ -5026,6 +5038,14 @@
        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
      }
    },
+    "node_modules/pretty-format/node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
    "node_modules/proxy-from-env": {
      "version": "2.1.0",
      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
@@ -5723,14 +5743,6 @@
        "react": "^18.3.1"
      }
    },
-    "node_modules/react-is": {
-      "version": "17.0.2",
-      "resolved": "https://registry.npmmirror.com/react-is/-/react-is-17.0.2.tgz",
-      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true
-    },
    "node_modules/react-refresh": {
      "version": "0.17.0",
      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
@@ -1,2 +0,0 @@
-allowBuilds:
-  esbuild: set this to true or false
@@ -0,0 +1,443 @@
+/**
+ * 素材相关 API
+ * Phase 1 重构：去掉 project_id，素材直接归属用户
+ */
+import apiClient from "./client"
+import { getOrCreateDefaultProject } from "./projects"
+
+/** 素材元数据 */
+export interface AssetMetadata {
+  /** 时长（秒） */
+  duration?: number
+  /** 宽度（像素） */
+  width?: number
+  /** 高度（像素） */
+  height?: number
+  /** 比特率（bps） */
+  bitrate?: number
+  /** 编码格式 */
+  codec?: string
+  /** 帧率 */
+  fps?: number
+  /** 采样率（Hz） */
+  sample_rate?: number
+  /** 声道数 */
+  channels?: number
+  /** 其他扩展字段 */
+  [key: string]: unknown
+}
+
+/** 素材分类状态 */
+export type AssetClassificationStatus = "pending" | "processing" | "completed" | "failed"
+
+/** 素材条目 */
+export interface AssetItem {
+  id: string
+  library_id: string
+  name: string
+  storage_key: string
+  mime_type: string
+  metadata: AssetMetadata
+  file_size?: number
+  file_url?: string
+  thumbnail_url?: string
+  /** 时长（秒），视频/音频素材由后端从 metadata 提取到顶层 */
+  duration?: number
+  status?: string
+  classification_status?: AssetClassificationStatus | null
+  quality_score?: number | null
+  tag_ids?: string[]
+  created_at?: string
+}
+
+/** 素材库 */
+export interface AssetLibraryItem {
+  id: string
+  name: string
+  kind: "video" | "voice" | "image"
+  asset_count?: number
+  total_size?: number
+  created_at?: string
+}
+
+/** 入库任务 */
+export interface IngestJob {
+  id: string
+  library_id: string
+  storage_key: string
+  status: "pending" | "processing" | "completed" | "failed"
+  error_message: string
+  result_asset_id: string
+}
+
+/** 分类任务 */
+export interface ClassificationJob {
+  id: string
+  asset_id: string
+  status: "pending" | "processing" | "completed" | "failed"
+  classification: string
+  confidence: number
+  error_message: string
+}
+
+/** 素材诊断信息 */
+export interface AssetDiagnosis {
+  readiness_score: number
+  readiness_label: string
+  total_assets: number
+  ready_assets: number
+  video_assets: number
+  image_assets: number
+  voice_assets: number
+  total_duration_seconds: number
+  estimated_video_count: number
+  used_assets: number
+  unused_assets: number
+  pending_review_assets: number
+  smart_views: Array<{
+    key: string
+    label: string
+    count: number
+    description: string
+  }>
+  gaps: Array<{
+    key: string
+    severity: "critical" | "warning" | "info"
+    message: string
+    recommendation: string
+  }>
+}
+
+// ─── 素材诊断 ──────────────────────────────────────────────
+
+/** 获取素材诊断信息（可选 asset_id 查单素材，否则全局诊断） */
+export const getAssetDiagnosis = async (assetId?: string): Promise<AssetDiagnosis> => {
+  const params: Record<string, string> = {}
+  if (assetId) params.asset_id = assetId
+  const response = await apiClient.get("/asset-diagnosis", { params })
+  return response.data
+}
+
+// ─── 素材库 ────────────────────────────────────────────────
+
+/** 获取当前用户的所有素材库 */
+export const getAssetLibraries = async (): Promise<AssetLibraryItem[]> => {
+  const response = await apiClient.get("/asset-libraries")
+  return response.data.items || []
+}
+
+/** 创建素材库（自动获取或创建默认项目以提供 project_id） */
+export const createAssetLibrary = async (data: {
+  name: string
+  kind: "video" | "voice" | "image"
+}): Promise<AssetLibraryItem> => {
+  // 后端要求 project_id，前端自动管理默认项目
+  const project = await getOrCreateDefaultProject()
+  const response = await apiClient.post("/asset-libraries", {
+    project_id: project.id,
+    ...data,
+  })
+  return response.data
+}
+
+/** 确保项目下指定 kind 的默认素材库存在（不存在则自动创建） */
+export const ensureDefaultLibrary = async (data: {
+  project_id: string
+  kind: "video" | "voice" | "image"
+}): Promise<AssetLibraryItem> => {
+  const response = await apiClient.post("/asset-libraries/ensure-default", data)
+  return response.data
+}
+
+/** 删除素材库 */
+export const deleteAssetLibrary = async (libraryId: string): Promise<void> => {
+  await apiClient.delete(`/asset-libraries/${libraryId}`)
+}
+
+// ─── 素材 ──────────────────────────────────────────────────
+
+/** 获取素材库下的所有素材 */
+export const getAssets = async (
+  libraryId: string,
+  options?: { status?: string; page?: number; page_size?: number },
+): Promise<{ items: AssetItem[]; total: number }> => {
+  const params: Record<string, string | number> = { library_id: libraryId }
+  // 默认拉取所有非删除状态的素材（ready/ingesting/processing/uploading/error/failed）
+  // 让用户能看到"处理中"的素材，不会以为上传失败了
+  if (options?.status) {
+    params.status = options.status
+  }
+  if (options?.page) params.page = options.page
+  if (options?.page_size) params.page_size = options.page_size
+  const response = await apiClient.get("/assets", { params })
+  const data = response.data || {}
+  const items: AssetItem[] = data.items || []
+  const total: number = typeof data.total === "number" ? data.total : items.length
+  return { items, total }
+}
+
+/** 按类型获取素材（如 voice/video/image），支持可选筛选 */
+export const getAssetsByKind = async (
+  kind: string,
+  filters?: {
+    keyword?: string
+    gender?: string
+    style?: string
+    tag_ids?: string[]
+    limit?: number
+    page?: number
+    page_size?: number
+  },
+): Promise<AssetItem[]> => {
+  const params: Record<string, string | number> = { kind }
+  if (filters?.keyword) params.keyword = filters.keyword
+  if (filters?.gender) params.gender = filters.gender
+  if (filters?.style) params.style = filters.style
+  if (filters?.tag_ids?.length) params.tag_ids = filters.tag_ids.join(",")
+  if (filters?.limit) params.limit = filters.limit
+  if (filters?.page) params.page = filters.page
+  if (filters?.page_size) params.page_size = filters.page_size
+  const response = await apiClient.get("/assets", { params })
+  return response.data.items || []
+}
+
+/** 创建素材（上传文件后调用，附带 metadata） */
+export const createAsset = async (data: {
+  library_id: string
+  name: string
+  storage_key: string
+  mime_type: string
+  metadata?: AssetMetadata
+}): Promise<AssetItem> => {
+  const response = await apiClient.post("/assets", data)
+  return response.data
+}
+
+/** 更新素材（名称、metadata 等） */
+export const updateAsset = async (
+  assetId: string,
+  data: { name?: string; metadata?: AssetMetadata },
+): Promise<AssetItem> => {
+  const response = await apiClient.put(`/assets/${assetId}`, data)
+  return response.data
+}
+
+/** 更新素材审核状态 */
+export const updateAssetReviewStatus = async (
+  assetId: string,
+  reviewStatus: "pending_review" | "approved" | "rejected",
+): Promise<AssetItem> => {
+  const response = await apiClient.patch(`/assets/${assetId}/review`, {
+    review_status: reviewStatus,
+  })
+  return response.data
+}
+
+/** 删除素材 */
+export const deleteAsset = async (assetId: string): Promise<void> => {
+  await apiClient.delete(`/assets/${assetId}`)
+}
+
+// ─── 上传 ──────────────────────────────────────────────────
+
+/** 表单上传素材（小文件） */
+export const uploadAsset = async (
+  formData: FormData,
+): Promise<{ storage_key: string; ingest_job_id: string; url: string }> => {
+  const response = await apiClient.post("/upload", formData, {
+    headers: { "Content-Type": "multipart/form-data" },
+    timeout: 30 * 60 * 1000,
+  })
+  return response.data
+}
+
+/** 预签名直传准备 */
+export const prepareDirectUpload = async (data: {
+  project_id: string
+  library_id: string
+  filename: string
+  content_type: string
+  file_size: number
+}): Promise<{
+  upload_url: string
+  method: string
+  storage_key: string
+  expires_at: string
+  fields: Record<string, string>
+  max_size_bytes: number
+}> => {
+  const response = await apiClient.post("/upload/direct/prepare", data)
+  return response.data
+}
+
+/** 直传完成确认 */
+export const completeDirectUpload = async (data: {
+  project_id: string
+  library_id: string
+  storage_key: string
+}): Promise<{ storage_key: string; ingest_job_id: string }> => {
+  const response = await apiClient.post("/upload/direct/complete", data)
+  return response.data
+}
+
+/** 直传上传（大文件推荐），支持可选进度回调 */
+export const uploadAssetDirect = async (data: {
+  file: File
+  library_id: string
+  onProgress?: (percent: number) => void
+}): Promise<{ storage_key: string; ingest_job_id: string }> => {
+  // 后端要求 project_id，前端自动获取默认项目
+  const project = await getOrCreateDefaultProject()
+
+  const prepared = await prepareDirectUpload({
+    project_id: project.id,
+    library_id: data.library_id,
+    filename: data.file.name,
+    content_type: data.file.type || "application/octet-stream",
+    file_size: data.file.size,
+  })
+
+  const directForm = new FormData()
+  Object.entries(prepared.fields).forEach(([key, value]) => directForm.append(key, value))
+  directForm.append("file", data.file)
+
+  // 使用 XMLHttpRequest 以获取上传进度 + 超时控制 + 详细错误诊断
+  await new Promise<void>((resolve, reject) => {
+    const xhr = new XMLHttpRequest()
+    xhr.open(prepared.method, prepared.upload_url)
+
+    // 超时 10 分钟
+    xhr.timeout = 10 * 60 * 1000
+
+    xhr.upload.onprogress = (e) => {
+      if (e.lengthComputable && data.onProgress) {
+        data.onProgress(Math.round((e.loaded / e.total) * 100))
+      }
+    }
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        resolve()
+      } else {
+        // 解析 OSS 返回的 XML 错误信息
+        let ossError = ""
+        try {
+          const codeMatch = xhr.responseText.match(/<Code>([^<]+)<\/Code>/)
+          const msgMatch = xhr.responseText.match(/<Message>([^<]+)<\/Message>/)
+          if (codeMatch || msgMatch) {
+            ossError = ` [OSS: ${codeMatch?.[1] || "unknown"} - ${msgMatch?.[1] || "unknown"}]`
+          }
+        } catch {
+          // 无法解析响应体
+        }
+        const detail = `OSS 直传失败: HTTP ${xhr.status} ${xhr.statusText}${ossError}`
+        console.error("[OSS Upload] 直传失败:", {
+          url: prepared.upload_url,
+          storage_key: prepared.storage_key,
+          status: xhr.status,
+          statusText: xhr.statusText,
+        })
+        reject(new Error(detail))
+      }
+    }
+    xhr.onerror = () => {
+      console.error("[OSS Upload] 网络错误:", {
+        url: prepared.upload_url,
+        storage_key: prepared.storage_key,
+      })
+      reject(new Error("OSS 上传网络错误，请检查网络连接"))
+    }
+    xhr.ontimeout = () => {
+      console.error("[OSS Upload] 上传超时:", {
+        url: prepared.upload_url,
+        storage_key: prepared.storage_key,
+      })
+      reject(new Error("OSS 上传超时（10分钟），请检查网络或尝试更小的文件"))
+    }
+    xhr.send(directForm)
+  })
+
+  return completeDirectUpload({
+    project_id: project.id,
+    library_id: data.library_id,
+    storage_key: prepared.storage_key,
+  })
+}
+
+// ─── 入库 / 分类任务 ───────────────────────────────────────
+
+/** 查询入库任务状态 */
+export const getIngestJob = async (jobId: string): Promise<IngestJob> => {
+  const response = await apiClient.get(`/ingest-jobs/${jobId}`)
+  return response.data
+}
+
+/** 提交素材分类任务 */
+export const submitClassificationJob = async (data: {
+  asset_id: string
+}): Promise<ClassificationJob> => {
+  const response = await apiClient.post("/classification-jobs", data)
+  return response.data
+}
+
+/** 查询分类任务状态 */
+export const getClassificationJob = async (jobId: string): Promise<ClassificationJob> => {
+  const response = await apiClient.get(`/classification-jobs/${jobId}`)
+  return response.data
+}
+
+// ─── 批量操作 ───────────────────────────────────────────────
+
+/** 批量操作结果 */
+export interface BatchOperationResult {
+  succeeded: string[]
+  failed: string[]
+  total: number
+  success_count: number
+  failure_count: number
+}
+
+/** 统一批量操作结果归一化，防御后端字段缺失或格式不一致 */
+const normalizeBatchResult = (raw: Record<string, unknown>): BatchOperationResult => {
+  const succeeded = Array.isArray(raw.succeeded) ? (raw.succeeded as string[]) : []
+  const failed = Array.isArray(raw.failed) ? (raw.failed as string[]) : []
+  const success_count = typeof raw.success_count === "number" ? raw.success_count : succeeded.length
+  const failure_count = typeof raw.failure_count === "number" ? raw.failure_count : failed.length
+  const total = typeof raw.total === "number" ? raw.total : success_count + failure_count
+  return { succeeded, failed, total, success_count, failure_count }
+}
+
+/** 批量删除素材 */
+export const batchDeleteAssets = async (assetIds: string[]): Promise<BatchOperationResult> => {
+  const response = await apiClient.post("/assets/batch-delete", {
+    asset_ids: assetIds,
+  })
+  return normalizeBatchResult((response.data || {}) as Record<string, unknown>)
+}
+
+/** 批量打标签 */
+export const batchTagAssets = async (data: {
+  asset_ids: string[]
+  tags: string[]
+  mode: "add" | "replace"
+}): Promise<BatchOperationResult> => {
+  const response = await apiClient.post("/assets/batch-tag", data)
+  return normalizeBatchResult((response.data || {}) as Record<string, unknown>)
+}
+
+/** 批量改分类 */
+export const batchClassifyAssets = async (data: {
+  asset_ids: string[]
+  category: string
+}): Promise<BatchOperationResult> => {
+  const response = await apiClient.post("/assets/batch-classify", data)
+  return normalizeBatchResult((response.data || {}) as Record<string, unknown>)
+}
+
+/** 批量智能标记 */
+export const batchMarkAssets = async (data: {
+  asset_ids: string[]
+  smart_view: "recommended" | "caution" | "high_risk"
+}): Promise<BatchOperationResult> => {
+  const response = await apiClient.post("/assets/batch-mark", data)
+  return normalizeBatchResult((response.data || {}) as Record<string, unknown>)
+}
@@ -1,98 +0,0 @@
-/**
- * 素材 CRUD API
- */
-import apiClient from "../client"
-import type { AssetItem, AssetMetadata } from "./types"
-
-/** 获取素材库下的所有素材 */
-export const getAssets = async (
-  libraryId: string,
-  options?: {
-    status?: string
-    page?: number
-    page_size?: number
-  },
-): Promise<{ items: AssetItem[]; total: number }> => {
-  const params: Record<string, string | number> = { library_id: libraryId }
-  if (options?.status) params.status = options.status
-  if (options?.page) params.page = options.page
-  if (options?.page_size) params.page_size = options.page_size
-  const response = await apiClient.get("/assets", { params })
-  const data = response.data || {}
-  const items: AssetItem[] = data.items || []
-  const total: number = typeof data.total === "number" ? data.total : items.length
-  return { items, total }
-}
-
-/** 按类型获取素材（如 voice/video/image），支持可选筛选 */
-export const getAssetsByKind = async (
-  kind: string,
-  filters?: {
-    keyword?: string
-    gender?: string
-    style?: string
-    tag_ids?: string[]
-    limit?: number
-    page?: number
-    page_size?: number
-  },
-): Promise<AssetItem[]> => {
-  const params: Record<string, string | number> = { kind }
-  if (filters?.keyword) params.keyword = filters.keyword
-  if (filters?.gender) params.gender = filters.gender
-  if (filters?.style) params.style = filters.style
-  if (filters?.tag_ids?.length) params.tag_ids = filters.tag_ids.join(",")
-  if (filters?.limit) params.limit = filters.limit
-  if (filters?.page) params.page = filters.page
-  if (filters?.page_size) params.page_size = filters.page_size
-  const response = await apiClient.get("/assets", { params })
-  return response.data.items || []
-}
-
-/**
- * 智能匹配素材（后端 AI 选素材）
- * 调用后端 smart-match 端点，由后端根据素材库内容智能选择素材
- */
-export const smartMatchAssets = async (libraryId: string): Promise<{ items: AssetItem[] }> => {
-  const response = await apiClient.post("/assets/smart-match", {
-    library_id: libraryId,
-  })
-  return response.data
-}
-
-/** 创建素材（上传文件后调用，附带 metadata） */
-export const createAsset = async (data: {
-  library_id: string
-  name: string
-  storage_key: string
-  mime_type: string
-  metadata?: AssetMetadata
-}): Promise<AssetItem> => {
-  const response = await apiClient.post("/assets", data)
-  return response.data
-}
-
-/** 更新素材（名称、metadata 等） */
-export const updateAsset = async (
-  assetId: string,
-  data: { name?: string; metadata?: AssetMetadata },
-): Promise<AssetItem> => {
-  const response = await apiClient.put(`/assets/${assetId}`, data)
-  return response.data
-}
-
-/** 更新素材审核状态 */
-export const updateAssetReviewStatus = async (
-  assetId: string,
-  reviewStatus: "pending_review" | "approved" | "rejected",
-): Promise<AssetItem> => {
-  const response = await apiClient.patch(`/assets/${assetId}/review`, {
-    review_status: reviewStatus,
-  })
-  return response.data
-}
-
-/** 删除素材 */
-export const deleteAsset = async (assetId: string): Promise<void> => {
-  await apiClient.delete(`/assets/${assetId}`)
-}
@@ -1,51 +0,0 @@
-/**
- * 素材批量操作 API
- */
-import apiClient from "../client"
-import type { BatchOperationResult } from "./types"
-
-/** 统一批量操作结果归一化，防御后端字段缺失或格式不一致 */
-export const normalizeBatchResult = (raw: Record<string, unknown>): BatchOperationResult => {
-  const succeeded = Array.isArray(raw.succeeded) ? (raw.succeeded as string[]) : []
-  const failed = Array.isArray(raw.failed) ? (raw.failed as string[]) : []
-  const success_count = typeof raw.success_count === "number" ? raw.success_count : succeeded.length
-  const failure_count = typeof raw.failure_count === "number" ? raw.failure_count : failed.length
-  const total = typeof raw.total === "number" ? raw.total : success_count + failure_count
-  return { succeeded, failed, total, success_count, failure_count }
-}
-
-/** 批量删除素材 */
-export const batchDeleteAssets = async (assetIds: string[]): Promise<BatchOperationResult> => {
-  const response = await apiClient.post("/assets/batch-delete", {
-    asset_ids: assetIds,
-  })
-  return normalizeBatchResult((response.data || {}) as Record<string, unknown>)
-}
-
-/** 批量打标签 */
-export const batchTagAssets = async (data: {
-  asset_ids: string[]
-  tags: string[]
-  mode: "add" | "replace"
-}): Promise<BatchOperationResult> => {
-  const response = await apiClient.post("/assets/batch-tag", data)
-  return normalizeBatchResult((response.data || {}) as Record<string, unknown>)
-}
-
-/** 批量改分类 */
-export const batchClassifyAssets = async (data: {
-  asset_ids: string[]
-  category: string
-}): Promise<BatchOperationResult> => {
-  const response = await apiClient.post("/assets/batch-classify", data)
-  return normalizeBatchResult((response.data || {}) as Record<string, unknown>)
-}
-
-/** 批量智能标记 */
-export const batchMarkAssets = async (data: {
-  asset_ids: string[]
-  smart_view: "recommended" | "caution" | "high_risk"
-}): Promise<BatchOperationResult> => {
-  const response = await apiClient.post("/assets/batch-mark", data)
-  return normalizeBatchResult((response.data || {}) as Record<string, unknown>)
-}
@@ -1,13 +0,0 @@
-/**
- * 素材诊断 API
- */
-import apiClient from "../client"
-import type { AssetDiagnosis } from "./types"
-
-/** 获取素材诊断信息（可选 asset_id 查单素材，否则全局诊断） */
-export const getAssetDiagnosis = async (assetId?: string): Promise<AssetDiagnosis> => {
-  const params: Record<string, string> = {}
-  if (assetId) params.asset_id = assetId
-  const response = await apiClient.get("/asset-diagnosis", { params })
-  return response.data
-}
@@ -1,56 +0,0 @@
-/**
- * 素材相关 API — 按模块拆分后的统一入口
- * 保持与原 assets.ts 相同的导出结构，向后兼容
- */
-
-// 类型
-export type {
-  AssetMetadata,
-  AssetClassificationStatus,
-  AssetItem,
-  AssetLibraryItem,
-  IngestJob,
-  ClassificationJob,
-  AssetDiagnosis,
-  BatchOperationResult,
-  UploadResult,
-  DirectUploadPrepareResult,
-  DirectUploadCompleteResult,
-} from "./types"
-
-// 素材诊断
-export { getAssetDiagnosis } from "./diagnosis"
-
-// 素材库
-export {
-  getAssetLibraries,
-  createAssetLibrary,
-  ensureDefaultLibrary,
-  deleteAssetLibrary,
-} from "./libraries"
-
-// 素材 CRUD + 智能匹配
-export {
-  getAssets,
-  getAssetsByKind,
-  smartMatchAssets,
-  createAsset,
-  updateAsset,
-  updateAssetReviewStatus,
-  deleteAsset,
-} from "./assets"
-
-// 上传
-export { uploadAsset, prepareDirectUpload, completeDirectUpload, uploadAssetDirect } from "./upload"
-
-// 任务
-export { getIngestJob, submitClassificationJob, getClassificationJob } from "./jobs"
-
-// 批量操作
-export {
-  normalizeBatchResult,
-  batchDeleteAssets,
-  batchTagAssets,
-  batchClassifyAssets,
-  batchMarkAssets,
-} from "./batch"
@@ -1,25 +0,0 @@
-/**
- * 入库任务 & 分类任务 API
- */
-import apiClient from "../client"
-import type { IngestJob, ClassificationJob } from "./types"
-
-/** 查询入库任务状态 */
-export const getIngestJob = async (jobId: string): Promise<IngestJob> => {
-  const response = await apiClient.get(`/ingest-jobs/${jobId}`)
-  return response.data
-}
-
-/** 提交素材分类任务 */
-export const submitClassificationJob = async (data: {
-  asset_id: string
-}): Promise<ClassificationJob> => {
-  const response = await apiClient.post("/classification-jobs", data)
-  return response.data
-}
-
-/** 查询分类任务状态 */
-export const getClassificationJob = async (jobId: string): Promise<ClassificationJob> => {
-  const response = await apiClient.get(`/classification-jobs/${jobId}`)
-  return response.data
-}
@@ -1,39 +0,0 @@
-/**
- * 素材库 API
- */
-import apiClient from "../client"
-import { getOrCreateDefaultProject } from "../projects"
-import type { AssetLibraryItem } from "./types"
-
-/** 获取当前用户的所有素材库 */
-export const getAssetLibraries = async (): Promise<AssetLibraryItem[]> => {
-  const response = await apiClient.get("/asset-libraries")
-  return response.data.items || []
-}
-
-/** 创建素材库（自动获取或创建默认项目以提供 project_id） */
-export const createAssetLibrary = async (data: {
-  name: string
-  kind: "video" | "voice" | "image"
-}): Promise<AssetLibraryItem> => {
-  const project = await getOrCreateDefaultProject()
-  const response = await apiClient.post("/asset-libraries", {
-    project_id: project.id,
-    ...data,
-  })
-  return response.data
-}
-
-/** 确保项目下指定 kind 的默认素材库存在 */
-export const ensureDefaultLibrary = async (data: {
-  project_id: string
-  kind: "video" | "voice" | "image"
-}): Promise<AssetLibraryItem> => {
-  const response = await apiClient.post("/asset-libraries/ensure-default", data)
-  return response.data
-}
-
-/** 删除素材库 */
-export const deleteAssetLibrary = async (libraryId: string): Promise<void> => {
-  await apiClient.delete(`/asset-libraries/${libraryId}`)
-}
@@ -1,138 +0,0 @@
-/**
- * 素材相关类型定义
- */
-
-/** 素材元数据 */
-export interface AssetMetadata {
-  /** 时长（秒） */
-  duration?: number
-  /** 宽度（像素） */
-  width?: number
-  /** 高度（像素） */
-  height?: number
-  /** 比特率（bps） */
-  bitrate?: number
-  /** 编码格式 */
-  codec?: string
-  /** 帧率 */
-  fps?: number
-  /** 采样率（Hz） */
-  sample_rate?: number
-  /** 声道数 */
-  channels?: number
-  /** 其他扩展字段 */
-  [key: string]: unknown
-}
-
-/** 素材分类状态 */
-export type AssetClassificationStatus = "pending" | "processing" | "completed" | "failed"
-
-/** 素材条目 */
-export interface AssetItem {
-  id: string
-  library_id: string
-  name: string
-  storage_key: string
-  mime_type: string
-  metadata: AssetMetadata
-  file_size?: number
-  file_url?: string
-  thumbnail_url?: string
-  /** 时长（秒），视频/音频素材由后端从 metadata 提取到顶层 */
-  duration?: number
-  status?: string
-  classification_status?: AssetClassificationStatus | null
-  quality_score?: number | null
-  tag_ids?: string[]
-  created_at?: string
-}
-
-/** 素材库 */
-export interface AssetLibraryItem {
-  id: string
-  name: string
-  kind: "video" | "voice" | "image"
-  asset_count?: number
-  total_size?: number
-  created_at?: string
-}
-
-/** 入库任务 */
-export interface IngestJob {
-  id: string
-  library_id: string
-  storage_key: string
-  status: "pending" | "processing" | "completed" | "failed"
-  error_message: string
-  result_asset_id: string
-}
-
-/** 分类任务 */
-export interface ClassificationJob {
-  id: string
-  asset_id: string
-  status: "pending" | "processing" | "completed" | "failed"
-  classification: string
-  confidence: number
-  error_message: string
-}
-
-/** 素材诊断信息 */
-export interface AssetDiagnosis {
-  readiness_score: number
-  readiness_label: string
-  total_assets: number
-  ready_assets: number
-  video_assets: number
-  image_assets: number
-  voice_assets: number
-  total_duration_seconds: number
-  estimated_video_count: number
-  used_assets: number
-  unused_assets: number
-  pending_review_assets: number
-  smart_views: Array<{
-    key: string
-    label: string
-    count: number
-    description: string
-  }>
-  gaps: Array<{
-    key: string
-    severity: "critical" | "warning" | "info"
-    message: string
-    recommendation: string
-  }>
-}
-
-/** 批量操作结果 */
-export interface BatchOperationResult {
-  succeeded: string[]
-  failed: string[]
-  total: number
-  success_count: number
-  failure_count: number
-}
-
-/** 上传返回 */
-export interface UploadResult {
-  storage_key: string
-  ingest_job_id: string
-  url: string
-}
-
-/** 预签名直传准备返回 */
-export interface DirectUploadPrepareResult {
-  upload_url: string
-  method: string
-  storage_key: string
-  expires_at: string
-  fields: Record<string, string>
-  max_size_bytes: number
-}
-
-/** 直传完成确认返回 */
-export interface DirectUploadCompleteResult {
-  storage_key: string
-  ingest_job_id: string
-}
@@ -1,119 +0,0 @@
-/**
- * 上传相关 API（表单上传 + OSS 直传）
- */
-import apiClient from "../client"
-import { getOrCreateDefaultProject } from "../projects"
-import type { UploadResult, DirectUploadPrepareResult, DirectUploadCompleteResult } from "./types"
-
-/** 表单上传素材（小文件） */
-export const uploadAsset = async (formData: FormData): Promise<UploadResult> => {
-  const response = await apiClient.post("/upload", formData, {
-    headers: { "Content-Type": "multipart/form-data" },
-    timeout: 30 * 60 * 1000,
-  })
-  return response.data
-}
-
-/** 预签名直传准备 */
-export const prepareDirectUpload = async (data: {
-  project_id: string
-  library_id: string
-  filename: string
-  content_type: string
-  file_size: number
-}): Promise<DirectUploadPrepareResult> => {
-  const response = await apiClient.post("/upload/direct/prepare", data)
-  return response.data
-}
-
-/** 直传完成确认 */
-export const completeDirectUpload = async (data: {
-  project_id: string
-  library_id: string
-  storage_key: string
-}): Promise<DirectUploadCompleteResult> => {
-  const response = await apiClient.post("/upload/direct/complete", data)
-  return response.data
-}
-
-/** 直传上传（大文件推荐），支持可选进度回调 */
-export const uploadAssetDirect = async (data: {
-  file: File
-  library_id: string
-  onProgress?: (percent: number) => void
-}): Promise<DirectUploadCompleteResult> => {
-  const project = await getOrCreateDefaultProject()
-
-  const prepared = await prepareDirectUpload({
-    project_id: project.id,
-    library_id: data.library_id,
-    filename: data.file.name,
-    content_type: data.file.type || "application/octet-stream",
-    file_size: data.file.size,
-  })
-
-  const directForm = new FormData()
-  Object.entries(prepared.fields).forEach(([key, value]) => directForm.append(key, value))
-  directForm.append("file", data.file)
-
-  // 使用 XMLHttpRequest 以获取上传进度 + 超时控制 + 详细错误诊断
-  await new Promise<void>((resolve, reject) => {
-    const xhr = new XMLHttpRequest()
-    xhr.open(prepared.method, prepared.upload_url)
-
-    // 超时 10 分钟
-    xhr.timeout = 10 * 60 * 1000
-
-    xhr.upload.onprogress = (e) => {
-      if (e.lengthComputable && data.onProgress) {
-        data.onProgress(Math.round((e.loaded / e.total) * 100))
-      }
-    }
-    xhr.onload = () => {
-      if (xhr.status >= 200 && xhr.status < 300) {
-        resolve()
-      } else {
-        // 解析 OSS 返回的 XML 错误信息
-        let ossError = ""
-        try {
-          const codeMatch = xhr.responseText.match(/<Code>([^<]+)<\/Code>/)
-          const msgMatch = xhr.responseText.match(/<Message>([^<]+)<\/Message>/)
-          if (codeMatch || msgMatch) {
-            ossError = ` [OSS: ${codeMatch?.[1] || "unknown"} - ${msgMatch?.[1] || "unknown"}]`
-          }
-        } catch {
-          // 无法解析响应体
-        }
-        const detail = `OSS 直传失败: HTTP ${xhr.status} ${xhr.statusText}${ossError}`
-        console.error("[OSS Upload] 直传失败:", {
-          url: prepared.upload_url,
-          storage_key: prepared.storage_key,
-          status: xhr.status,
-          statusText: xhr.statusText,
-        })
-        reject(new Error(detail))
-      }
-    }
-    xhr.onerror = () => {
-      console.error("[OSS Upload] 网络错误:", {
-        url: prepared.upload_url,
-        storage_key: prepared.storage_key,
-      })
-      reject(new Error("OSS 上传网络错误，请检查网络连接"))
-    }
-    xhr.ontimeout = () => {
-      console.error("[OSS Upload] 上传超时:", {
-        url: prepared.upload_url,
-        storage_key: prepared.storage_key,
-      })
-      reject(new Error("OSS 上传超时（10分钟），请检查网络或尝试更小的文件"))
-    }
-    xhr.send(directForm)
-  })
-
-  return completeDirectUpload({
-    project_id: project.id,
-    library_id: data.library_id,
-    storage_key: prepared.storage_key,
-  })
-}
@@ -0,0 +1,188 @@
+/**
+ * 认证相关 API
+ */
+import axios from "axios"
+import apiClient from "./client"
+
+// 类型定义
+export interface LoginRequest {
+  email: string
+  password: string
+}
+
+export interface LoginResponse {
+  access_token: string
+  refresh_token?: string | null
+  token_type: string
+  expires_in: number
+  user_id: string
+  email: string
+  username: string
+  display_name: string
+}
+
+export interface RegisterRequest {
+  email: string
+  password: string
+  username: string
+  display_name?: string
+}
+
+export interface User {
+  id: string
+  user_id: string
+  email: string
+  username: string
+  display_name: string
+  is_email_verified: boolean
+  email_verified: boolean
+  created_at?: string
+}
+
+export interface UserResponse {
+  id?: string
+  user_id?: string
+  email: string
+  username: string
+  display_name: string
+  is_email_verified?: boolean
+  email_verified?: boolean
+  created_at?: string
+}
+
+export const normalizeUser = (data: UserResponse): User => {
+  const userId = data.id ?? data.user_id ?? ""
+  const emailVerified = data.is_email_verified ?? data.email_verified ?? false
+
+  return {
+    id: userId,
+    user_id: userId,
+    email: data.email,
+    username: data.username,
+    display_name: data.display_name,
+    is_email_verified: emailVerified,
+    email_verified: emailVerified,
+    created_at: data.created_at,
+  }
+}
+
+// 登录
+export const login = async (data: LoginRequest): Promise<LoginResponse> => {
+  const response = await apiClient.post("/auth/login", data)
+  return response.data
+}
+
+// 刷新 access_token（使用裸 axios 避免拦截器递归）
+export const refreshAccessToken = async (refreshToken: string): Promise<LoginResponse> => {
+  const baseURL = apiClient.defaults.baseURL ?? ""
+  const response = await axios.post(`${baseURL}/auth/refresh`, {
+    refresh_token: refreshToken,
+  })
+  return response.data
+}
+
+// 注册
+export const register = async (data: RegisterRequest): Promise<{ message: string }> => {
+  const response = await apiClient.post("/auth/register", data)
+  return response.data
+}
+
+// 登出
+export const logout = async (): Promise<void> => {
+  await apiClient.post("/auth/logout")
+}
+
+// 获取当前用户
+export const getCurrentUser = async (): Promise<User> => {
+  const response = await apiClient.get<UserResponse>("/auth/me")
+  return normalizeUser(response.data)
+}
+
+// 请求密码重置
+export const requestPasswordReset = async (email: string): Promise<{ message: string }> => {
+  const response = await apiClient.post("/auth/forgot-password", { email })
+  return response.data
+}
+
+// 重置密码
+export const resetPassword = async (
+  token: string,
+  newPassword: string,
+): Promise<{ message: string }> => {
+  const response = await apiClient.post("/auth/reset-password", {
+    token,
+    new_password: newPassword,
+  })
+  return response.data
+}
+
+// 验证邮箱
+export const verifyEmail = async (token: string): Promise<{ message: string }> => {
+  const response = await apiClient.post("/auth/verify-email", { token })
+  return response.data
+}
+
+/* ========== 微信登录 ========== */
+
+export interface WechatAuthUrlResponse {
+  auth_url: string
+  state: string
+}
+
+export interface WechatCallbackResponse {
+  access_token: string
+  refresh_token?: string | null
+  user_id: string
+  display_name: string
+  avatar_url: string
+  is_new_user: boolean
+  binding_complete: boolean
+  expires_in: number
+}
+
+export interface SendVerificationCodeRequest {
+  target: "email" | "phone"
+  value: string
+  purpose: "bind" | "login" | "reset_password"
+}
+
+export interface BindContactRequest {
+  email?: string
+  email_code?: string
+  phone?: string
+  phone_code?: string
+}
+
+export interface BindContactResponse {
+  success: boolean
+  user: User
+}
+
+// 获取微信授权链接
+export const getWechatAuthUrl = async (): Promise<WechatAuthUrlResponse> => {
+  const response = await apiClient.get("/auth/wechat/url")
+  return response.data
+}
+
+// 微信回调登录
+export const wechatCallback = async (
+  code: string,
+  state: string,
+): Promise<WechatCallbackResponse> => {
+  const response = await apiClient.post("/auth/wechat/callback", { code, state })
+  return response.data
+}
+
+// 发送验证码
+export const sendVerificationCode = async (
+  data: SendVerificationCodeRequest,
+): Promise<{ message: string }> => {
+  const response = await apiClient.post("/auth/send-verification-code", data)
+  return response.data
+}
+
+// 绑定联系方式
+export const bindContact = async (data: BindContactRequest): Promise<BindContactResponse> => {
+  const response = await apiClient.post("/auth/bind-contact", data)
+  return response.data
+}
@@ -1,20 +0,0 @@
-import apiClient from "../client"
-import type { SendVerificationCodeRequest, BindContactRequest, BindContactResponse } from "./types"
-
-/**
- * 发送验证码
- */
-export const sendVerificationCode = async (
-  data: SendVerificationCodeRequest,
-): Promise<{ message: string }> => {
-  const response = await apiClient.post("/auth/send-verification-code", data)
-  return response.data
-}
-
-/**
- * 绑定联系方式
- */
-export const bindContact = async (data: BindContactRequest): Promise<BindContactResponse> => {
-  const response = await apiClient.post("/auth/bind-contact", data)
-  return response.data
-}
@@ -1,11 +0,0 @@
-import apiClient from "../client"
-import type { User, UserResponse } from "./types"
-import { normalizeUser } from "./user"
-
-/**
- * 获取当前用户
- */
-export const getCurrentUser = async (): Promise<User> => {
-  const response = await apiClient.get<UserResponse>("/auth/me")
-  return normalizeUser(response.data)
-}
@@ -1,9 +0,0 @@
-import apiClient from "../client"
-
-/**
- * 验证邮箱
- */
-export const verifyEmail = async (token: string): Promise<{ message: string }> => {
-  const response = await apiClient.post("/auth/verify-email", { token })
-  return response.data
-}
@@ -1,39 +0,0 @@
-/**
- * 认证相关 API
- * 保持向后兼容，从子模块 re-export
- */
-
-// 类型
-export type {
-  LoginRequest,
-  LoginResponse,
-  RegisterRequest,
-  User,
-  UserResponse,
-  WechatAuthUrlResponse,
-  WechatCallbackResponse,
-  SendVerificationCodeRequest,
-  BindContactRequest,
-  BindContactResponse,
-} from "./types"
-
-// 用户工具函数
-export { normalizeUser } from "./user"
-
-// 登录/注册/登出/刷新
-export { login, refreshAccessToken, register, logout } from "./login"
-
-// 当前用户
-export { getCurrentUser } from "./currentUser"
-
-// 密码重置
-export { requestPasswordReset, resetPassword } from "./password"
-
-// 邮箱验证
-export { verifyEmail } from "./email"
-
-// 微信登录
-export { getWechatAuthUrl, wechatCallback } from "./wechat"
-
-// 联系方式
-export { sendVerificationCode, bindContact } from "./contact"
@@ -1,37 +0,0 @@
-import axios from "axios"
-import apiClient from "../client"
-import type { LoginRequest, LoginResponse, RegisterRequest } from "./types"
-
-/**
- * 登录
- */
-export const login = async (data: LoginRequest): Promise<LoginResponse> => {
-  const response = await apiClient.post("/auth/login", data)
-  return response.data
-}
-
-/**
- * 刷新 access_token（使用裸 axios 避免拦截器递归）
- */
-export const refreshAccessToken = async (refreshToken: string): Promise<LoginResponse> => {
-  const baseURL = apiClient.defaults.baseURL ?? ""
-  const response = await axios.post(`${baseURL}/auth/refresh`, {
-    refresh_token: refreshToken,
-  })
-  return response.data
-}
-
-/**
- * 注册
- */
-export const register = async (data: RegisterRequest): Promise<{ message: string }> => {
-  const response = await apiClient.post("/auth/register", data)
-  return response.data
-}
-
-/**
- * 登出
- */
-export const logout = async (): Promise<void> => {
-  await apiClient.post("/auth/logout")
-}
@@ -1,23 +0,0 @@
-import apiClient from "../client"
-
-/**
- * 请求密码重置
- */
-export const requestPasswordReset = async (email: string): Promise<{ message: string }> => {
-  const response = await apiClient.post("/auth/forgot-password", { email })
-  return response.data
-}
-
-/**
- * 重置密码
- */
-export const resetPassword = async (
-  token: string,
-  newPassword: string,
-): Promise<{ message: string }> => {
-  const response = await apiClient.post("/auth/reset-password", {
-    token,
-    new_password: newPassword,
-  })
-  return response.data
-}
@@ -1,82 +0,0 @@
-/**
- * 认证相关类型定义
- */
-
-export interface LoginRequest {
-  email: string
-  password: string
-}
-
-export interface LoginResponse {
-  access_token: string
-  refresh_token?: string | null
-  token_type: string
-  expires_in: number
-  user_id: string
-  email: string
-  username: string
-  display_name: string
-}
-
-export interface RegisterRequest {
-  email: string
-  password: string
-  username: string
-  display_name?: string
-}
-
-export interface User {
-  id: string
-  user_id: string
-  email: string
-  username: string
-  display_name: string
-  is_email_verified: boolean
-  email_verified: boolean
-  created_at?: string
-}
-
-export interface UserResponse {
-  id?: string
-  user_id?: string
-  email: string
-  username: string
-  display_name: string
-  is_email_verified?: boolean
-  email_verified?: boolean
-  created_at?: string
-}
-
-export interface WechatAuthUrlResponse {
-  auth_url: string
-  state: string
-}
-
-export interface WechatCallbackResponse {
-  access_token: string
-  refresh_token?: string | null
-  user_id: string
-  display_name: string
-  avatar_url: string
-  is_new_user: boolean
-  binding_complete: boolean
-  expires_in: number
-}
-
-export interface SendVerificationCodeRequest {
-  target: "email" | "phone"
-  value: string
-  purpose: "bind" | "login" | "reset_password"
-}
-
-export interface BindContactRequest {
-  email?: string
-  email_code?: string
-  phone?: string
-  phone_code?: string
-}
-
-export interface BindContactResponse {
-  success: boolean
-  user: User
-}
@@ -1,20 +0,0 @@
-import type { User, UserResponse } from "./types"
-
-/**
- * 规范化用户数据，兼容不同后端返回格式
- */
-export const normalizeUser = (data: UserResponse): User => {
-  const userId = data.id ?? data.user_id ?? ""
-  const emailVerified = data.is_email_verified ?? data.email_verified ?? false
-
-  return {
-    id: userId,
-    user_id: userId,
-    email: data.email,
-    username: data.username,
-    display_name: data.display_name,
-    is_email_verified: emailVerified,
-    email_verified: emailVerified,
-    created_at: data.created_at,
-  }
-}
@@ -1,21 +0,0 @@
-import apiClient from "../client"
-import type { WechatAuthUrlResponse, WechatCallbackResponse } from "./types"
-
-/**
- * 获取微信授权链接
- */
-export const getWechatAuthUrl = async (): Promise<WechatAuthUrlResponse> => {
-  const response = await apiClient.get("/auth/wechat/url")
-  return response.data
-}
-
-/**
- * 微信回调登录
- */
-export const wechatCallback = async (
-  code: string,
-  state: string,
-): Promise<WechatCallbackResponse> => {
-  const response = await apiClient.post("/auth/wechat/callback", { code, state })
-  return response.data
-}
@@ -0,0 +1,68 @@
+/**
+ * BGM 预设音乐 API
+ * 对接后端 BGM 混音能力：预设列表查询（按风格分类 + 关键词搜索）
+ */
+import apiClient from "./client"
+
+/* ──────────── 类型 ──────────── */
+
+/** BGM 风格分类 */
+export type BgmCategory = "轻快" | "治愈" | "科技" | "电商"
+
+/** BGM 预设项 */
+export interface BgmPreset {
+  id: string
+  name: string
+  category: BgmCategory
+  /** 音频文件 URL */
+  url: string
+  /** 时长（秒） */
+  duration: number
+  /** 关键词标签 */
+  tags: string[]
+  /** 封面图 URL */
+  cover_url?: string
+}
+
+/** BGM 预设列表查询参数 */
+export interface BgmPresetsQuery {
+  category?: BgmCategory | string
+  keyword?: string
+}
+
+/** BGM 混音配置（嵌入模板） */
+export interface BgmMixConfig {
+  /** 是否启用 BGM */
+  enabled: boolean
+  /** 选中的 BGM ID */
+  music_id: string
+  /** BGM 音量 0-100 */
+  volume: number
+  /** 淡入时长（秒） 0-3 */
+  fade_in: number
+  /** 淡出时长（秒） 0-3 */
+  fade_out: number
+  /** 人声闪避（sidechain） */
+  voice_dodge: boolean
+}
+
+/** 默认 BGM 混音配置 */
+export const DEFAULT_BGM_MIX_CONFIG: BgmMixConfig = {
+  enabled: false,
+  music_id: "",
+  volume: 50,
+  fade_in: 0.5,
+  fade_out: 0.5,
+  voice_dodge: true,
+}
+
+/* ──────────── API ──────────── */
+
+/** 获取 BGM 预设列表 */
+export const getBgmPresets = async (params?: BgmPresetsQuery): Promise<BgmPreset[]> => {
+  const searchParams: Record<string, string> = {}
+  if (params?.category) searchParams.category = params.category
+  if (params?.keyword) searchParams.keyword = params.keyword
+  const res = await apiClient.get("/bgm/presets", { params: searchParams })
+  return res.data?.data ?? res.data ?? []
+}
@@ -1,14 +0,0 @@
-/**
- * BGM 预设音乐 API 函数
- */
-import apiClient from "../client"
-import type { BgmPreset, BgmPresetsQuery } from "./types"
-
-/** 获取 BGM 预设列表 */
-export const getBgmPresets = async (params?: BgmPresetsQuery): Promise<BgmPreset[]> => {
-  const searchParams: Record<string, string> = {}
-  if (params?.category) searchParams.category = params.category
-  if (params?.keyword) searchParams.keyword = params.keyword
-  const res = await apiClient.get("/bgm/presets", { params: searchParams })
-  return res.data?.data ?? res.data ?? []
-}
@@ -1,14 +0,0 @@
-/**
- * BGM 相关常量
- */
-import type { BgmMixConfig } from "./types"
-
-/** 默认 BGM 混音配置 */
-export const DEFAULT_BGM_MIX_CONFIG: BgmMixConfig = {
-  enabled: false,
-  music_id: "",
-  volume: 50,
-  fade_in: 0.5,
-  fade_out: 0.5,
-  voice_dodge: true,
-}
@@ -1,13 +0,0 @@
-/**
- * BGM API — 目录化入口
- * 保持与原 bgm.ts 相同导出，向后兼容
- */
-
-// 类型
-export type { BgmCategory, BgmPreset, BgmPresetsQuery, BgmMixConfig } from "./types"
-
-// 常量
-export { DEFAULT_BGM_MIX_CONFIG } from "./constants"
-
-// API 函数
-export { getBgmPresets } from "./bgm"
@@ -1,43 +0,0 @@
-/**
- * BGM 相关类型定义
- */
-
-/** BGM 风格分类 */
-export type BgmCategory = "轻快" | "治愈" | "科技" | "电商"
-
-/** BGM 预设项 */
-export interface BgmPreset {
-  id: string
-  name: string
-  category: BgmCategory
-  /** 音频文件 URL */
-  url: string
-  /** 时长（秒） */
-  duration: number
-  /** 关键词标签 */
-  tags: string[]
-  /** 封面图 URL */
-  cover_url?: string
-}
-
-/** BGM 预设列表查询参数 */
-export interface BgmPresetsQuery {
-  category?: BgmCategory | string
-  keyword?: string
-}
-
-/** BGM 混音配置（嵌入模板） */
-export interface BgmMixConfig {
-  /** 是否启用 BGM */
-  enabled: boolean
-  /** 选中的 BGM ID */
-  music_id: string
-  /** BGM 音量 0-100 */
-  volume: number
-  /** 淡入时长（秒） 0-3 */
-  fade_in: number
-  /** 淡出时长（秒） 0-3 */
-  fade_out: number
-  /** 人声闪避（sidechain） */
-  voice_dodge: boolean
-}
@@ -57,21 +57,7 @@ apiClient.interceptors.response.use(
    }

    // 401 → 尝试刷新 Token
-    // 排除 auth 端点：登录/注册/找回密码的 401 是正常业务响应（如密码错误），
-    // 不应触发 token 刷新或登出跳转，走后面的错误提示逻辑即可
-    const requestUrl = originalRequest?.url || ""
-    const isAuthEndpoint =
-      requestUrl.includes("/auth/login") ||
-      requestUrl.includes("/auth/register") ||
-      requestUrl.includes("/auth/forgot-password") ||
-      requestUrl.includes("/auth/reset-password")
-
-    if (
-      error.response?.status === 401 &&
-      originalRequest &&
-      !originalRequest._retry &&
-      !isAuthEndpoint
-    ) {
+    if (error.response?.status === 401 && originalRequest && !originalRequest._retry) {
      const refreshToken = useAuthStore.getState().refreshToken

      // 无 refresh_token → 直接登出
@@ -0,0 +1,243 @@
+/**
+ * 模板编辑器 API
+ * 对接后端 /api/v1/templates 路由
+ */
+import apiClient from "./client"
+import type {
+  WatermarkConfig,
+  IntroOutroConfig,
+  PipConfig,
+  FilterConfig,
+  ChromaKeyConfig,
+  StickerConfig,
+  CoverConfig,
+} from "@/pages/editing-planner/types"
+
+/* ──────────── 类型定义 ──────────── */
+
+/** 模板模式（后端枚举值） */
+export type TemplateMode = "pip" | "voice_over" | "one_take" | "voice_pip"
+
+/** 模式显示名称映射 */
+export const MODE_LABELS: Record<TemplateMode, string> = {
+  pip: "混剪",
+  voice_over: "人物口播",
+  one_take: "一镜到底",
+  voice_pip: "口播+混剪",
+}
+
+/** 模式颜色映射 */
+export const MODE_COLORS: Record<TemplateMode, string> = {
+  pip: "blue",
+  voice_over: "green",
+  one_take: "orange",
+  voice_pip: "purple",
+}
+
+/** 标题配置 */
+export interface TitleConfig {
+  ai_auto_select: boolean
+  content: string
+  font_preset: string
+  font_color: string
+  font_size: number
+  position: string
+}
+
+/** 字幕配置 */
+export interface SubtitleConfig {
+  enabled: boolean
+  position: string
+  font: string
+  color: string
+  size: number
+  animation: string
+}
+
+/** BGM 配置 */
+export interface BgmConfig {
+  enabled: boolean
+  music_id: string
+}
+
+/** 模板片段 */
+export interface TemplateSegment {
+  id?: string
+  segment_order: number
+  duration_min: number
+  duration_max: number
+  material_type: string | null
+}
+
+/** 剪辑模板 */
+export interface EditingTemplate {
+  id: string
+  name: string
+  mode: TemplateMode
+  category: string
+  tags: string[]
+  title_config: TitleConfig
+  subtitle_config: SubtitleConfig
+  bgm_config: BgmConfig
+  estimated_duration: number
+  segments: TemplateSegment[]
+  /** 水印配置（后端就绪后启用） */
+  watermark_config?: WatermarkConfig
+  /** 片头片尾配置（后端就绪后启用） */
+  intro_outro_config?: IntroOutroConfig
+  /** 混剪配置 */
+  pip_config?: PipConfig
+  /** 滤镜调色配置 */
+  filter_config?: FilterConfig
+  /** 绿幕抠像配置 */
+  green_screen_config?: ChromaKeyConfig
+  /** 贴纸配置 */
+  sticker_config?: StickerConfig
+  /** 封面配置 */
+  cover_config?: CoverConfig
+  is_active?: boolean
+  created_at: string
+  updated_at: string
+}
+
+/** 模板分类 */
+export interface TemplateCategory {
+  id: string
+  name: string
+  created_at?: string
+}
+
+/** 创建/更新模板请求体 */
+export interface SaveTemplatePayload {
+  name: string
+  mode: TemplateMode
+  category: string
+  tags: string[]
+  title_config: TitleConfig
+  subtitle_config: SubtitleConfig
+  bgm_config: BgmConfig
+  estimated_duration: number
+  segments: Omit<TemplateSegment, "id">[]
+  /** 水印配置（后端就绪后启用） */
+  watermark_config?: WatermarkConfig
+  /** 片头片尾配置（后端就绪后启用） */
+  intro_outro_config?: IntroOutroConfig
+  /** 混剪配置 */
+  pip_config?: PipConfig
+  /** 滤镜调色配置 */
+  filter_config?: FilterConfig
+  /** 绿幕抠像配置 */
+  green_screen_config?: ChromaKeyConfig
+  /** 贴纸配置 */
+  sticker_config?: StickerConfig
+  /** 封面配置 */
+  cover_config?: CoverConfig
+}
+
+/** 使用模板生成请求体 */
+export interface GenerateFromTemplatePayload {
+  voiceover_duration: number
+}
+
+/** 验证警告详情 */
+export interface ValidationWarningDetails {
+  /** 相关字段名 */
+  field?: string
+  /** 期望值 */
+  expected?: string | number
+  /** 实际值 */
+  actual?: string | number
+  /** 建议值 */
+  suggested?: string | number
+}
+
+/** 验证/生成响应 */
+export interface ValidateWarning {
+  code: string
+  message: string
+  details?: ValidationWarningDetails
+}
+
+/** 使用模板生成响应 */
+export interface GenerateFromTemplateResponse {
+  template: EditingTemplate
+  warnings: ValidateWarning[]
+}
+
+/** 列表响应（带分页） */
+export interface ListTemplatesResponse {
+  items: EditingTemplate[]
+  total: number
+}
+
+/** 分类列表响应 */
+export interface ListCategoriesResponse {
+  items: TemplateCategory[]
+}
+
+// ============ API 函数 ============
+
+/** 获取模板列表 */
+export const getEditingTemplates = async (params?: {
+  category?: string
+  tag?: string
+  skip?: number
+  limit?: number
+}): Promise<EditingTemplate[]> => {
+  const response = await apiClient.get<ListTemplatesResponse>("/templates", {
+    params: {
+      skip: params?.skip ?? 0,
+      limit: params?.limit ?? 50,
+    },
+  })
+  let list = response.data.items
+  if (params?.category) list = list.filter((t) => t.category === params.category)
+  if (params?.tag) list = list.filter((t) => t.tags.includes(params.tag!))
+  return list
+}
+
+/** 获取模板详情 */
+export const getEditingTemplate = async (id: string): Promise<EditingTemplate> => {
+  const response = await apiClient.get<EditingTemplate>(`/templates/${id}`)
+  return response.data
+}
+
+/** 创建模板 */
+export const createEditingTemplate = async (
+  data: SaveTemplatePayload,
+): Promise<EditingTemplate> => {
+  const response = await apiClient.post<EditingTemplate>("/templates", data)
+  return response.data
+}
+
+/** 更新模板 */
+export const updateEditingTemplate = async (
+  id: string,
+  data: SaveTemplatePayload,
+): Promise<EditingTemplate> => {
+  const response = await apiClient.patch<EditingTemplate>(`/templates/${id}`, data)
+  return response.data
+}
+
+/** 删除模板 */
+export const deleteEditingTemplate = async (id: string): Promise<void> => {
+  await apiClient.delete(`/templates/${id}`)
+}
+
+/** 获取模板分类列表 */
+export const getTemplateCategories = async (): Promise<TemplateCategory[]> => {
+  const response = await apiClient.get<ListCategoriesResponse>("/templates/categories/list")
+  return response.data.items
+}
+
+/** 使用模板生成视频（调用 validate 端点） */
+export const generateFromTemplate = async (
+  templateId: string,
+  data: GenerateFromTemplatePayload,
+): Promise<GenerateFromTemplateResponse> => {
+  const response = await apiClient.post<GenerateFromTemplateResponse>(
+    `/templates/${templateId}/validate`,
+    data,
+  )
+  return response.data
+}
@@ -1,20 +0,0 @@
-/**
- * 模板编辑器常量
- */
-import type { TemplateMode } from "./types"
-
-/** 模式显示名称映射 */
-export const MODE_LABELS: Record<TemplateMode, string> = {
-  pip: "混剪",
-  voice_over: "人物口播",
-  one_take: "一镜到底",
-  voice_pip: "口播+混剪",
-}
-
-/** 模式颜色映射 */
-export const MODE_COLORS: Record<TemplateMode, string> = {
-  pip: "blue",
-  voice_over: "green",
-  one_take: "orange",
-  voice_pip: "purple",
-}
@@ -1,36 +0,0 @@
-/**
- * 模板编辑器 API — 目录化入口
- * 保持与原 editing-planner.ts 相同导出，向后兼容
- */
-
-// 类型
-export type {
-  TemplateMode,
-  TitleConfig,
-  SubtitleConfig,
-  BgmConfig,
-  TemplateSegment,
-  EditingTemplate,
-  TemplateCategory,
-  SaveTemplatePayload,
-  GenerateFromTemplatePayload,
-  ValidationWarningDetails,
-  ValidateWarning,
-  GenerateFromTemplateResponse,
-  ListTemplatesResponse,
-  ListCategoriesResponse,
-} from "./types"
-
-// 常量
-export { MODE_LABELS, MODE_COLORS } from "./constants"
-
-// API 函数
-export {
-  getEditingTemplates,
-  getEditingTemplate,
-  createEditingTemplate,
-  updateEditingTemplate,
-  deleteEditingTemplate,
-  getTemplateCategories,
-  generateFromTemplate,
-} from "./templates"
@@ -1,78 +0,0 @@
-/**
- * 模板编辑器 API 函数
- */
-import apiClient from "../client"
-import type {
-  EditingTemplate,
-  TemplateCategory,
-  SaveTemplatePayload,
-  GenerateFromTemplatePayload,
-  GenerateFromTemplateResponse,
-  ListTemplatesResponse,
-  ListCategoriesResponse,
-} from "./types"
-
-/** 获取模板列表 */
-export const getEditingTemplates = async (params?: {
-  category?: string
-  tag?: string
-  skip?: number
-  limit?: number
-}): Promise<EditingTemplate[]> => {
-  const response = await apiClient.get<ListTemplatesResponse>("/templates", {
-    params: {
-      skip: params?.skip ?? 0,
-      limit: params?.limit ?? 50,
-    },
-  })
-  let list = response.data.items
-  if (params?.category) list = list.filter((t) => t.category === params.category)
-  if (params?.tag) list = list.filter((t) => t.tags.includes(params.tag!))
-  return list
-}
-
-/** 获取模板详情 */
-export const getEditingTemplate = async (id: string): Promise<EditingTemplate> => {
-  const response = await apiClient.get<EditingTemplate>(`/templates/${id}`)
-  return response.data
-}
-
-/** 创建模板 */
-export const createEditingTemplate = async (
-  data: SaveTemplatePayload,
-): Promise<EditingTemplate> => {
-  const response = await apiClient.post<EditingTemplate>("/templates", data)
-  return response.data
-}
-
-/** 更新模板 */
-export const updateEditingTemplate = async (
-  id: string,
-  data: SaveTemplatePayload,
-): Promise<EditingTemplate> => {
-  const response = await apiClient.patch<EditingTemplate>(`/templates/${id}`, data)
-  return response.data
-}
-
-/** 删除模板 */
-export const deleteEditingTemplate = async (id: string): Promise<void> => {
-  await apiClient.delete(`/templates/${id}`)
-}
-
-/** 获取模板分类列表 */
-export const getTemplateCategories = async (): Promise<TemplateCategory[]> => {
-  const response = await apiClient.get<ListCategoriesResponse>("/templates/categories/list")
-  return response.data.items
-}
-
-/** 使用模板生成视频（调用 validate 端点） */
-export const generateFromTemplate = async (
-  templateId: string,
-  data: GenerateFromTemplatePayload,
-): Promise<GenerateFromTemplateResponse> => {
-  const response = await apiClient.post<GenerateFromTemplateResponse>(
-    `/templates/${templateId}/validate`,
-    data,
-  )
-  return response.data
-}
@@ -1,138 +0,0 @@
-/**
- * 模板编辑器类型定义
- */
-import type {
-  WatermarkConfig,
-  IntroOutroConfig,
-  PipConfig,
-  FilterConfig,
-  ChromaKeyConfig,
-  StickerConfig,
-  CoverConfig,
-} from "@/pages/editing-planner/types"
-
-/** 模板模式（后端枚举值） */
-export type TemplateMode = "pip" | "voice_over" | "one_take" | "voice_pip"
-
-/** 标题配置 */
-export interface TitleConfig {
-  ai_auto_select: boolean
-  content: string
-  font_preset: string
-  font_color: string
-  font_size: number
-  position: string
-}
-
-/** 字幕配置 */
-export interface SubtitleConfig {
-  enabled: boolean
-  position: string
-  font: string
-  color: string
-  size: number
-  animation: string
-}
-
-/** BGM 配置 */
-export interface BgmConfig {
-  enabled: boolean
-  music_id: string
-}
-
-/** 模板片段 */
-export interface TemplateSegment {
-  id?: string
-  segment_order: number
-  duration_min: number
-  duration_max: number
-  material_type: string | null
-}
-
-/** 剪辑模板 */
-export interface EditingTemplate {
-  id: string
-  name: string
-  mode: TemplateMode
-  category: string
-  tags: string[]
-  title_config: TitleConfig
-  subtitle_config: SubtitleConfig
-  bgm_config: BgmConfig
-  estimated_duration: number
-  segments: TemplateSegment[]
-  watermark_config?: WatermarkConfig
-  intro_outro_config?: IntroOutroConfig
-  pip_config?: PipConfig
-  filter_config?: FilterConfig
-  green_screen_config?: ChromaKeyConfig
-  sticker_config?: StickerConfig
-  cover_config?: CoverConfig
-  is_active?: boolean
-  created_at: string
-  updated_at: string
-}
-
-/** 模板分类 */
-export interface TemplateCategory {
-  id: string
-  name: string
-  created_at?: string
-}
-
-/** 创建/更新模板请求体 */
-export interface SaveTemplatePayload {
-  name: string
-  mode: TemplateMode
-  category: string
-  tags: string[]
-  title_config: TitleConfig
-  subtitle_config: SubtitleConfig
-  bgm_config: BgmConfig
-  estimated_duration: number
-  segments: Omit<TemplateSegment, "id">[]
-  watermark_config?: WatermarkConfig
-  intro_outro_config?: IntroOutroConfig
-  pip_config?: PipConfig
-  filter_config?: FilterConfig
-  green_screen_config?: ChromaKeyConfig
-  sticker_config?: StickerConfig
-  cover_config?: CoverConfig
-}
-
-/** 使用模板生成请求体 */
-export interface GenerateFromTemplatePayload {
-  voiceover_duration: number
-}
-
-/** 验证警告详情 */
-export interface ValidationWarningDetails {
-  field?: string
-  expected?: string | number
-  actual?: string | number
-  suggested?: string | number
-}
-
-/** 验证警告 */
-export interface ValidateWarning {
-  code: string
-  message: string
-  details?: ValidationWarningDetails
-}
-
-/** 使用模板生成响应 */
-export interface GenerateFromTemplateResponse {
-  template: EditingTemplate
-  warnings: ValidateWarning[]
-}
-
-/** 列表响应（带分页） */
-export interface ListTemplatesResponse {
-  items: EditingTemplate[]
-  total: number
-}
-
-/** 分类列表响应 */
-export interface ListCategoriesResponse {
-  items: TemplateCategory[]
-}
@@ -1,8 +0,0 @@
-export type {
-  PreviewStatus,
-  CreatePreviewRequest,
-  CreatePreviewResponse,
-  PreviewTaskResponse,
-} from "./types"
-
-export { createPreview, getPreviewStatus } from "./preview"
@@ -1,16 +0,0 @@
-import apiClient from "../client"
-import type { CreatePreviewRequest, CreatePreviewResponse, PreviewTaskResponse } from "./types"
-
-/** 创建预览生成任务（单版本） */
-export const createPreview = async (
-  params: CreatePreviewRequest,
-): Promise<CreatePreviewResponse> => {
-  const response = await apiClient.post<CreatePreviewResponse>("/generation/preview", params)
-  return response.data
-}
-
-/** 查询预览任务状态及结果 */
-export const getPreviewStatus = async (taskId: string): Promise<PreviewTaskResponse> => {
-  const response = await apiClient.get<PreviewTaskResponse>(`/generation/preview/${taskId}`)
-  return response.data
-}
@@ -1,47 +0,0 @@
-/** 预览任务状态 */
-export type PreviewStatus = "pending" | "generating" | "completed" | "failed" | "cancelled"
-
-/** 创建预览任务请求 */
-export interface CreatePreviewRequest {
-  template_id: string
-  asset_ids: string[]
-  title_ids?: string[]
-  voice_ids?: string[]
-  video_title?: string
-  duration?: number
-  video_ratio?: string
-  bgm_config?: {
-    enabled: boolean
-    preset_id?: string
-    volume?: number
-  }
-}
-
-/** 创建预览任务响应 */
-export interface CreatePreviewResponse {
-  task_id: string
-  status: PreviewStatus
-  is_preview: boolean
-  resolution: string
-  created_at: string
-}
-
-/** 预览任务详情响应 */
-export interface PreviewTaskResponse {
-  task_id: string
-  status: PreviewStatus
-  progress: number
-  is_preview: boolean
-  resolution: string
-  video_url?: string
-  duration?: number
-  file_size?: number
-  clip_count?: number
-  transition_count?: number
-  material_usage?: number
-  error_message?: string
-  created_at: string
-  started_at?: string
-  finished_at?: string
-  generate_duration?: number
-}
@@ -0,0 +1,174 @@
+/**
+ * 成品 / 视频相关 API
+ * 后端实际接口：/videos
+ */
+import apiClient from "./client"
+
+/** 复核状态 */
+export type ReviewStatus = "pending_review" | "approved" | "rejected"
+
+/** 成品条目 */
+export interface ProductItem {
+  id: string
+  title: string
+  video_url?: string
+  thumbnail_url?: string
+  duration_seconds?: number
+  file_size?: number
+  resolution?: string
+  status: "processing" | "completed" | "failed"
+  /** 复核状态 */
+  review_status?: ReviewStatus
+  /** 所属项目 ID */
+  project_id?: string
+  /** 所属项目名称 */
+  project_name?: string
+  /** 查重率（百分比） */
+  duplicate_rate?: number
+  created_at?: string
+  updated_at?: string
+}
+
+/** 列表查询参数 */
+export interface ProductListParams {
+  page?: number
+  page_size?: number
+  project_id?: string
+  review_status?: ReviewStatus | "all"
+}
+
+/** 分页响应 */
+export interface ProductListResponse {
+  items: ProductItem[]
+  total: number
+  page: number
+  page_size: number
+}
+
+/** 批量下载任务状态 */
+export interface BatchDownloadStatus {
+  job_id: string
+  status: "processing" | "completed" | "failed"
+  /** 完成后返回的下载 URL */
+  download_url?: string
+  /** 进度百分比 */
+  progress?: number
+}
+
+/** 后端 /videos 接口返回的原始视频条目 */
+interface VideoItem {
+  id: string
+  project_id: string
+  generation_task_id: string
+  name: string
+  file_url: string
+  file_size: number
+  duration: number
+  thumbnail_url: string | null
+  width: number
+  height: number
+  fps: number
+  status: string
+  review_status: ReviewStatus
+  generation_params: Record<string, unknown>
+  download_url: string
+  generated_at: string
+}
+
+/**
+ * 将后端 VideoItem 映射为 ProductItem 格式
+ */
+function mapVideoToProductItem(video: VideoItem): ProductItem {
+  return {
+    id: video.id,
+    title: video.name || "未命名视频",
+    // 优先用 download_url（带签名）播放，file_url 无签名无法访问
+    video_url: video.download_url || video.file_url,
+    thumbnail_url: video.thumbnail_url || undefined,
+    duration_seconds: video.duration,
+    file_size: video.file_size,
+    resolution: video.width && video.height ? `${video.width}x${video.height}` : undefined,
+    status:
+      video.status === "completed"
+        ? "completed"
+        : video.status === "failed"
+          ? "failed"
+          : "processing",
+    review_status: video.review_status,
+    project_id: video.project_id,
+    // 后端 /videos 接口暂无 project_name 字段
+    project_name: undefined,
+    // 后端字段名为 generated_at，映射为 created_at 供前端统一使用
+    created_at: video.generated_at,
+    updated_at: video.generated_at,
+    // 后端 /videos 接口暂无 duplicate_rate 字段
+    duplicate_rate: undefined,
+  }
+}
+
+/** 获取成品列表（支持分页和筛选） */
+export const getProducts = async (params?: ProductListParams): Promise<ProductItem[]> => {
+  const response = await apiClient.get("/videos", { params })
+  const data = response.data
+  const videos: VideoItem[] = Array.isArray(data?.items)
+    ? data.items
+    : Array.isArray(data)
+      ? data
+      : []
+  return videos.map(mapVideoToProductItem)
+}
+
+/** 获取单个成品详情 */
+export const getProduct = async (productId: string): Promise<ProductItem> => {
+  const response = await apiClient.get(`/videos/${productId}`)
+  return mapVideoToProductItem(response.data as VideoItem)
+}
+
+/**
+ * 删除成品
+ * 注意：后端暂未实现 /videos DELETE 接口，调用会返回 405
+ * 待后端实现后自动生效
+ */
+export const deleteProduct = async (productId: string): Promise<void> => {
+  await apiClient.delete(`/videos/${productId}`)
+}
+
+/**
+ * 获取成品下载链接
+ * 直接使用列表返回的 download_url（带OSS签名）
+ */
+export const getProductDownloadUrl = async (
+  productId: string,
+): Promise<{ url: string; expires_at: string }> => {
+  // 优先从列表缓存取；如果没有则调详情接口
+  const product = await getProduct(productId)
+  if (!product.video_url) throw new Error("下载链接不可用")
+  return { url: product.video_url, expires_at: "" }
+}
+
+/** 更新复核状态 — TODO: 后端暂无对应端点，暂存本地状态 */
+export const updateReviewStatus = async (
+  productId: string,
+  status: ReviewStatus,
+): Promise<ProductItem> => {
+  // 后端暂无 /videos/{id}/review 端点
+  // 暂时返回当前状态，后续可扩展
+  const product = await getProduct(productId)
+  return { ...product, review_status: status }
+}
+
+/** 发起批量下载 — TODO: 后端暂无对应端点 */
+export const batchDownload = async (videoIds: string[]): Promise<{ job_id: string }> => {
+  // 后端暂无 /videos/batch-download 端点
+  // 暂时返回模拟 job_id，后续可扩展
+  console.warn("[batchDownload] 后端暂无批量下载端点", videoIds)
+  return { job_id: `mock-${Date.now()}` }
+}
+
+/** 查询批量下载状态 — TODO: 后端暂无对应端点 */
+export const getBatchDownloadStatus = async (jobId: string): Promise<BatchDownloadStatus> => {
+  // 后端暂无 /videos/batch-download/{jobId} 端点
+  // 暂时返回模拟状态，后续可扩展
+  console.warn("[getBatchDownloadStatus] 后端暂无批量下载状态端点", jobId)
+  return { job_id: jobId, status: "processing", progress: 0 }
+}
@@ -1,28 +0,0 @@
-/**
- * 成品 / 视频相关 API — 目录化入口
- * 保持与原 products.ts 相同导出，向后兼容
- */
-
-// 类型
-export type {
-  ReviewStatus,
-  ProductItem,
-  ProductListParams,
-  ProductListResponse,
-  BatchDownloadStatus,
-  VideoItem,
-} from "./types"
-
-// 工具函数
-export { mapVideoToProductItem } from "./utils"
-
-// API 函数
-export {
-  getProducts,
-  getProduct,
-  deleteProduct,
-  getProductDownloadUrl,
-  updateReviewStatus,
-  batchDownload,
-  getBatchDownloadStatus,
-} from "./products"
@@ -1,80 +0,0 @@
-/**
- * 成品 / 视频相关 API 函数
- * 后端实际接口：/videos
- */
-import apiClient from "../client"
-import type {
-  BatchDownloadStatus,
-  ProductItem,
-  ProductListParams,
-  VideoItem,
-  ReviewStatus,
-} from "./types"
-import { mapVideoToProductItem } from "./utils"
-
-/** 获取成品列表（支持分页和筛选） */
-export const getProducts = async (params?: ProductListParams): Promise<ProductItem[]> => {
-  const response = await apiClient.get("/videos", { params })
-  const data = response.data
-  const videos: VideoItem[] = Array.isArray(data?.items)
-    ? data.items
-    : Array.isArray(data)
-      ? data
-      : []
-  return videos.map(mapVideoToProductItem)
-}
-
-/** 获取单个成品详情 */
-export const getProduct = async (productId: string): Promise<ProductItem> => {
-  const response = await apiClient.get(`/videos/${productId}`)
-  return mapVideoToProductItem(response.data as VideoItem)
-}
-
-/**
- * 删除成品
- * 注意：后端暂未实现 /videos DELETE 接口，调用会返回 405
- * 待后端实现后自动生效
- */
-export const deleteProduct = async (productId: string): Promise<void> => {
-  await apiClient.delete(`/videos/${productId}`)
-}
-
-/**
- * 获取成品下载链接
- * 直接使用列表返回的 download_url（带OSS签名）
- */
-export const getProductDownloadUrl = async (
-  productId: string,
-): Promise<{ url: string; expires_at: string }> => {
-  // 优先从列表缓存取；如果没有则调详情接口
-  const product = await getProduct(productId)
-  if (!product.video_url) throw new Error("下载链接不可用")
-  return { url: product.video_url, expires_at: "" }
-}
-
-/** 更新复核状态 — TODO: 后端暂无对应端点，暂存本地状态 */
-export const updateReviewStatus = async (
-  productId: string,
-  status: ReviewStatus,
-): Promise<ProductItem> => {
-  // 后端暂无 /videos/{id}/review 端点
-  // 暂时返回当前状态，后续可扩展
-  const product = await getProduct(productId)
-  return { ...product, review_status: status }
-}
-
-/** 发起批量下载 — TODO: 后端暂无对应端点 */
-export const batchDownload = async (videoIds: string[]): Promise<{ job_id: string }> => {
-  // 后端暂无 /videos/batch-download 端点
-  // 暂时返回模拟 job_id，后续可扩展
-  console.warn("[batchDownload] 后端暂无批量下载端点", videoIds)
-  return { job_id: `mock-${Date.now()}` }
-}
-
-/** 查询批量下载状态 — TODO: 后端暂无对应端点 */
-export const getBatchDownloadStatus = async (jobId: string): Promise<BatchDownloadStatus> => {
-  // 后端暂无 /videos/batch-download/{jobId} 端点
-  // 暂时返回模拟状态，后续可扩展
-  console.warn("[getBatchDownloadStatus] 后端暂无批量下载状态端点", jobId)
-  return { job_id: jobId, status: "processing", progress: 0 }
-}
@@ -1,74 +0,0 @@
-/**
- * 成品 / 视频相关类型定义
- */
-
-/** 复核状态 */
-export type ReviewStatus = "pending_review" | "approved" | "rejected"
-
-/** 成品条目 */
-export interface ProductItem {
-  id: string
-  title: string
-  video_url?: string
-  thumbnail_url?: string
-  duration_seconds?: number
-  file_size?: number
-  resolution?: string
-  status: "processing" | "completed" | "failed"
-  /** 复核状态 */
-  review_status?: ReviewStatus
-  /** 所属项目 ID */
-  project_id?: string
-  /** 所属项目名称 */
-  project_name?: string
-  /** 查重率（百分比） */
-  duplicate_rate?: number
-  created_at?: string
-  updated_at?: string
-}
-
-/** 列表查询参数 */
-export interface ProductListParams {
-  page?: number
-  page_size?: number
-  project_id?: string
-  review_status?: ReviewStatus | "all"
-}
-
-/** 分页响应 */
-export interface ProductListResponse {
-  items: ProductItem[]
-  total: number
-  page: number
-  page_size: number
-}
-
-/** 批量下载任务状态 */
-export interface BatchDownloadStatus {
-  job_id: string
-  status: "processing" | "completed" | "failed"
-  /** 完成后返回的下载 URL */
-  download_url?: string
-  /** 进度百分比 */
-  progress?: number
-}
-
-/** 后端 /videos 接口返回的原始视频条目 */
-export interface VideoItem {
-  id: string
-  project_id: string
-  generation_task_id: string
-  name: string
-  file_url: string
-  file_size: number
-  duration: number
-  thumbnail_url: string | null
-  width: number
-  height: number
-  fps: number
-  status: string
-  review_status: ReviewStatus
-  generation_params: Record<string, unknown>
-  download_url: string
-  generated_at: string
-}
@@ -1,35 +0,0 @@
-/**
- * 成品数据转换工具函数
- */
-import type { ProductItem, VideoItem } from "./types"
-
-/**
- * 将后端 VideoItem 映射为 ProductItem 格式
- */
-export function mapVideoToProductItem(video: VideoItem): ProductItem {
-  return {
-    id: video.id,
-    title: video.name || "未命名视频",
-    // 优先用 download_url（带签名）播放，file_url 无签名无法访问
-    video_url: video.download_url || video.file_url,
-    thumbnail_url: video.thumbnail_url || undefined,
-    duration_seconds: video.duration,
-    file_size: video.file_size,
-    resolution: video.width && video.height ? `${video.width}x${video.height}` : undefined,
-    status:
-      video.status === "completed"
-        ? "completed"
-        : video.status === "failed"
-          ? "failed"
-          : "processing",
-    review_status: video.review_status,
-    project_id: video.project_id,
-    // 后端 /videos 接口暂无 project_name 字段
-    project_name: undefined,
-    // 后端字段名为 generated_at，映射为 created_at 供前端统一使用
-    created_at: video.generated_at,
-    updated_at: video.generated_at,
-    // 后端 /videos 接口暂无 duplicate_rate 字段
-    duplicate_rate: undefined,
-  }
-}
@@ -1,10 +1,32 @@
 /**
- * 项目相关 API 函数
+ * 项目相关 API
 * 素材库需要 project_id，前端自动管理默认项目
 */
-import apiClient from "../client"
-import type { BackendListProjectsResponse, BackendProjectResponse, ProjectItem } from "./types"
-import { toProjectItem } from "./utils"
+import apiClient from "./client"
+
+export interface ProjectItem {
+  id: string
+  name: string
+  description: string
+}
+
+/** 后端 ProjectResponse 只返回 id, name, description */
+interface BackendProjectResponse {
+  id: string
+  name: string
+  description: string
+}
+
+/** 后端 ListProjectsResponse 返回 { items: [...] } */
+interface BackendListProjectsResponse {
+  items: BackendProjectResponse[]
+}
+
+const toProjectItem = (item: BackendProjectResponse): ProjectItem => ({
+  id: item.id,
+  name: item.name,
+  description: item.description,
+})

 /** 获取当前用户的项目列表 */
 export const getProjects = async (): Promise<ProjectItem[]> => {
@@ -1,13 +0,0 @@
-/**
- * 项目 API — 目录化入口
- * 保持与原 projects.ts 相同导出，向后兼容
- */
-
-// 类型
-export type { ProjectItem, BackendProjectResponse, BackendListProjectsResponse } from "./types"
-
-// 工具函数
-export { toProjectItem } from "./utils"
-
-// API 函数
-export { getProjects, createProject, getOrCreateDefaultProject } from "./projects"
@@ -1,21 +0,0 @@
-/**
- * 项目相关类型定义
- */
-
-export interface ProjectItem {
-  id: string
-  name: string
-  description: string
-}
-
-/** 后端 ProjectResponse 只返回 id, name, description */
-export interface BackendProjectResponse {
-  id: string
-  name: string
-  description: string
-}
-
-/** 后端 ListProjectsResponse 返回 { items: [...] } */
-export interface BackendListProjectsResponse {
-  items: BackendProjectResponse[]
-}
@@ -1,10 +0,0 @@
-/**
- * 项目相关工具函数
- */
-import type { BackendProjectResponse, ProjectItem } from "./types"
-
-export const toProjectItem = (item: BackendProjectResponse): ProjectItem => ({
-  id: item.id,
-  name: item.name,
-  description: item.description,
-})
@@ -1,6 +1,8 @@
 /**
- * 订阅相关类型定义
+ * 订阅 API 模块
+ * 对接后端订阅管理接口
 */
+import apiClient from "./client"

 /** 套餐类型 */
 export type PlanType = "free" | "standard" | "pro" | "enterprise"
@@ -63,3 +65,42 @@ export interface ChangePlanResponse {
  message: string
  new_subscription?: SubscriptionInfo
 }
+
+// ============ API 函数 ============
+
+/** 获取当前订阅信息 */
+export const getCurrentSubscription = async (): Promise<SubscriptionInfo> => {
+  const response = await apiClient.get("/subscription/current")
+  return response.data
+}
+
+/** 获取账单记录列表 */
+export const getBillingRecords = async (): Promise<BillingRecord[]> => {
+  const response = await apiClient.get("/subscription/billing-records")
+  return response.data
+}
+
+/** 升级/降级套餐 */
+export const changePlan = async (request: ChangePlanRequest): Promise<ChangePlanResponse> => {
+  const response = await apiClient.post("/subscription/change-plan", request)
+  return response.data
+}
+
+/** 取消订阅 */
+export const cancelSubscription = async (): Promise<{
+  success: boolean
+  message: string
+}> => {
+  const response = await apiClient.post("/subscription/cancel")
+  return response.data
+}
+
+/** 切换自动续费 */
+export const toggleAutoRenew = async (
+  enabled: boolean,
+): Promise<{ success: boolean; message: string }> => {
+  const response = await apiClient.post("/subscription/toggle-auto-renew", {
+    enabled,
+  })
+  return response.data
+}
@@ -1,26 +0,0 @@
-/**
- * 订阅 API — 目录化入口
- * 保持与原 subscription.ts 相同导出，向后兼容
- */
-
-// 类型
-export type {
-  PlanType,
-  SubscriptionStatus,
-  BillingStatus,
-  BillingCycle,
-  Plan,
-  SubscriptionInfo,
-  BillingRecord,
-  ChangePlanRequest,
-  ChangePlanResponse,
-} from "./types"
-
-// API 函数
-export {
-  getCurrentSubscription,
-  getBillingRecords,
-  changePlan,
-  cancelSubscription,
-  toggleAutoRenew,
-} from "./subscription"
@@ -1,47 +0,0 @@
-/**
- * 订阅相关 API 函数
- */
-import apiClient from "../client"
-import type {
-  BillingRecord,
-  ChangePlanRequest,
-  ChangePlanResponse,
-  SubscriptionInfo,
-} from "./types"
-
-/** 获取当前订阅信息 */
-export const getCurrentSubscription = async (): Promise<SubscriptionInfo> => {
-  const response = await apiClient.get("/subscription/current")
-  return response.data
-}
-
-/** 获取账单记录列表 */
-export const getBillingRecords = async (): Promise<BillingRecord[]> => {
-  const response = await apiClient.get("/subscription/billing-records")
-  return response.data
-}
-
-/** 升级/降级套餐 */
-export const changePlan = async (request: ChangePlanRequest): Promise<ChangePlanResponse> => {
-  const response = await apiClient.post("/subscription/change-plan", request)
-  return response.data
-}
-
-/** 取消订阅 */
-export const cancelSubscription = async (): Promise<{
-  success: boolean
-  message: string
-}> => {
-  const response = await apiClient.post("/subscription/cancel")
-  return response.data
-}
-
-/** 切换自动续费 */
-export const toggleAutoRenew = async (
-  enabled: boolean,
-): Promise<{ success: boolean; message: string }> => {
-  const response = await apiClient.post("/subscription/toggle-auto-renew", {
-    enabled,
-  })
-  return response.data
-}
@@ -1,9 +1,15 @@
 /**
- * 标签 CRUD API 函数
+ * 标签 CRUD API
 * P3 标签体系：对接后端标签表
 */
-import apiClient from "../client"
-import type { TagItem } from "./types"
+import apiClient from "./client"
+
+export interface TagItem {
+  id: string
+  name: string
+  created_at?: string
+  usage_count?: number
+}

 /** 获取当前用户所有标签 */
 export const getTags = async (): Promise<TagItem[]> => {
@@ -1,10 +0,0 @@
-/**
- * 标签 API — 目录化入口
- * 保持与原 tags.ts 相同导出，向后兼容
- */
-
-// 类型
-export type { TagItem } from "./types"
-
-// API 函数
-export { getTags, createTag, deleteTag, tagAsset, untagAsset } from "./tags"
@@ -1,10 +0,0 @@
-/**
- * 标签相关类型定义
- */
-
-export interface TagItem {
-  id: string
-  name: string
-  created_at?: string
-  usage_count?: number
-}
@@ -1,6 +1,14 @@
 /**
- * 任务相关类型定义
+ * 任务相关 API
+ * 对接后端任务中心 API：
+ * - POST /api/v1/generation/tasks — 创建生成任务
+ * - GET  /api/v1/tasks              — 用户级任务列表（支持分页/筛选）
+ * - GET  /api/v1/tasks/{task_id}    — 任务详情（含 error_info）
+ * - POST /api/v1/tasks/{task_id}/retry — 重试失败任务
 */
+import apiClient from "./client"
+
+/* ──────────── 类型定义 ──────────── */

 /** 任务状态 */
 export type TaskStatus = "pending" | "waiting" | "running" | "completed" | "failed" | "cancelled"
@@ -77,3 +85,39 @@ export interface CreateGenerationTaskResponse {
  result_count: number
  error_message: string
 }
+
+/* ──────────── API 函数 ──────────── */
+
+/** 创建生成任务（智能剪辑） */
+export const createGenerationTask = async (
+  params: CreateGenerationTaskRequest,
+): Promise<CreateGenerationTaskResponse> => {
+  const { data } = await apiClient.post<CreateGenerationTaskResponse>("/generation/tasks", params)
+  return data
+}
+
+/** 获取任务列表（支持分页和筛选） */
+export const getTasks = async (params?: TaskListParams): Promise<TaskListResponse> => {
+  const { data } = await apiClient.get<TaskListResponse>("/tasks", {
+    params,
+  })
+  return data
+}
+
+/** 获取当前用户的所有任务（兼容旧接口，跨 project） */
+export const getUserTasks = async (): Promise<TaskItem[]> => {
+  const { data } = await apiClient.get("/tasks")
+  return data.items || data || []
+}
+
+/** 获取单个任务详情（含 error_info） */
+export const getTask = async (taskId: string): Promise<TaskItem> => {
+  const { data } = await apiClient.get(`/tasks/${taskId}`)
+  return data
+}
+
+/** 重试失败的任务 */
+export const retryTask = async (taskId: string): Promise<TaskItem> => {
+  const { data } = await apiClient.post(`/tasks/${taskId}/retry`)
+  return data
+}
@@ -1,19 +0,0 @@
-/**
- * 任务相关 API — 目录化入口
- * 保持与原 tasks.ts 相同导出，向后兼容
- */
-
-// 类型
-export type {
-  TaskStatus,
-  TaskType,
-  TaskErrorInfo,
-  TaskItem,
-  TaskListParams,
-  TaskListResponse,
-  CreateGenerationTaskRequest,
-  CreateGenerationTaskResponse,
-} from "./types"
-
-// API 函数
-export { createGenerationTask, getTasks, getUserTasks, getTask, retryTask } from "./tasks"
@@ -1,46 +0,0 @@
-/**
- * 任务相关 API 函数
- * 对接后端任务中心 API
- */
-import apiClient from "../client"
-import type {
-  CreateGenerationTaskRequest,
-  CreateGenerationTaskResponse,
-  TaskItem,
-  TaskListParams,
-  TaskListResponse,
-} from "./types"
-
-/** 创建生成任务（智能剪辑） */
-export const createGenerationTask = async (
-  params: CreateGenerationTaskRequest,
-): Promise<CreateGenerationTaskResponse> => {
-  const { data } = await apiClient.post<CreateGenerationTaskResponse>("/generation/tasks", params)
-  return data
-}
-
-/** 获取任务列表（支持分页和筛选） */
-export const getTasks = async (params?: TaskListParams): Promise<TaskListResponse> => {
-  const { data } = await apiClient.get<TaskListResponse>("/tasks", {
-    params,
-  })
-  return data
-}
-
-/** 获取当前用户的所有任务（兼容旧接口，跨 project） */
-export const getUserTasks = async (): Promise<TaskItem[]> => {
-  const { data } = await apiClient.get("/tasks")
-  return data.items || data || []
-}
-
-/** 获取单个任务详情（含 error_info） */
-export const getTask = async (taskId: string): Promise<TaskItem> => {
-  const { data } = await apiClient.get(`/tasks/${taskId}`)
-  return data
-}
-
-/** 重试失败的任务 */
-export const retryTask = async (taskId: string): Promise<TaskItem> => {
-  const { data } = await apiClient.post(`/tasks/${taskId}/retry`)
-  return data
-}
@@ -0,0 +1,744 @@
+/**
+ * 模板草稿 API — 对接后端 Template Editor Schema
+ * 字段名严格匹配后端 API 响应
+ */
+import apiClient from "./client"
+import type { AssetItem } from "./assets"
+import type {
+  WatermarkConfig,
+  IntroOutroConfig,
+  PipConfig,
+  FilterConfig,
+  ChromaKeyConfig,
+  StickerConfig,
+  CoverConfig,
+} from "@/pages/editing-planner/types"
+
+/* ============================================================
+ * 后端 API 类型（严格匹配后端 Schema）
+ * ============================================================ */
+
+/** 模板草稿状态枚举 */
+export type EditPlanStatus =
+  "draft" | "editing" | "rendering" | "completed" | "failed" | "cancelled"
+
+/** 标题配置（对齐后端 title_config） */
+export interface TitleConfig {
+  ai_auto_select: boolean
+  content: string
+  font_preset: string
+  font_color: string
+  font_size: number
+  position: string
+}
+
+/** 字幕配置 */
+export interface SubtitleConfig {
+  enabled: boolean
+  position: string
+  font: string
+  color: string
+  size: number
+  animation: string
+}
+
+/** BGM 配置 */
+export interface BgmConfig {
+  enabled: boolean
+  music_id: string
+}
+
+/** 片段 TTS 配置 */
+export interface SegmentTtsConfig {
+  mode: string
+  text: string
+  voice_id: string
+  speed: number
+  pitch: number
+  volume: number
+  subtitle_sync: boolean
+}
+
+/** 片段裁剪配置 */
+export interface SegmentTrimConfig {
+  start_time: number
+  end_time: number
+}
+
+/** 片段转场配置 */
+export interface SegmentTransitionConfig {
+  type: string
+  duration: number
+}
+
+/** 模板草稿中的单个片段（config 内部 segments 项） */
+export interface EditPlanSegment {
+  segment_order: number
+  duration_min: number
+  duration_max: number
+  material_type: string
+  transition?: SegmentTransitionConfig
+  playback_speed?: number
+  tts_config?: SegmentTtsConfig
+  trim_config?: SegmentTrimConfig
+}
+
+/** 模板草稿 config 完整类型（对齐后端 config JSON 结构） */
+export interface EditPlanConfig {
+  title_config?: TitleConfig
+  subtitle_config?: SubtitleConfig
+  bgm_config?: BgmConfig
+  estimated_duration?: number
+  segments?: EditPlanSegment[]
+  watermark_config?: WatermarkConfig
+  intro_outro_config?: IntroOutroConfig
+  pip_config?: PipConfig
+  filter_config?: FilterConfig
+  green_screen_config?: ChromaKeyConfig
+  sticker_config?: StickerConfig
+  cover_config?: CoverConfig
+  /** 前端扩展：关联的素材 ID 列表 */
+  asset_ids?: string[]
+  /** 配音 ID */
+  voice_id?: string
+  /** 克隆音色档案 ID */
+  voice_clone_profile_id?: string
+  /** 自定义配音音频 URL */
+  custom_audio_url?: string
+  /** 自定义配音文本 */
+  custom_text?: string
+  /** 视频比例 */
+  ratio?: string
+  /** 视频风格 */
+  style?: string
+  /** 目标时长（秒） */
+  duration?: number
+  /** 是否自动生成字幕 */
+  auto_subtitles?: boolean
+  /** 是否启用 BGM */
+  bgm?: boolean
+  /** 生成数量 */
+  generate_count?: number
+  /** 素材模式 */
+  material_mode?: string
+}
+
+/** 模板草稿（后端响应） */
+export interface EditPlan {
+  id: string
+  template_id: string
+  name: string
+  status: EditPlanStatus
+  total_duration: number
+  /** 生成视频数量（后端 EditPlanResponse.result_count） */
+  result_count: number
+  config: EditPlanConfig
+  created_at: string
+  updated_at: string
+}
+
+/** 创建模板草稿请求（后端要求 template_id + name 必填） */
+export interface CreateEditPlanRequest {
+  template_id: string
+  name: string
+  config?: EditPlanConfig
+  total_duration?: number
+  /** 来源模板草稿 ID（从模板编辑器跳转到智能剪辑时关联） */
+  source_edit_plan_id?: string
+}
+
+/** 更新模板草稿请求 */
+export interface UpdateEditPlanRequest {
+  name?: string
+  config?: EditPlanConfig
+  total_duration?: number
+  status?: EditPlanStatus
+}
+
+/** 生成响应 */
+export interface GenerateResponse {
+  plan_id: string
+  plan_status: EditPlanStatus
+  generation_task_id: string
+  clip_count: number
+}
+
+/** 模板草稿关联的生成记录（实际是 GenerationTask 对象） */
+export interface EditPlanGeneration {
+  id: string // 即 generation_task_id
+  source_edit_plan_id: string
+  template_id: string
+  asset_ids: string[]
+  status: EditPlanStatus
+  progress: number
+  result_count: number
+  error_message: string
+  error_info: Record<string, unknown>
+  logs: Array<Record<string, unknown>>
+  retry_count: number
+  created_at?: string
+  updated_at?: string
+}
+
+/** 片段生成状态 */
+export interface ClipStatusItem {
+  clip_id: string
+  clip_type: string
+  order: number
+  status: string
+  asset_id?: string
+  text_content?: string
+  duration?: number
+  error_message?: string
+}
+
+/** 生成状态轮询响应 */
+export interface GenerationStatusResponse {
+  plan_id: string
+  plan_status: EditPlanStatus
+  generation_task_id?: string
+  error_message?: string
+  clips: ClipStatusItem[]
+  error?: string
+  message?: string
+}
+
+/** 生成视频详情（对应后端 GeneratedVideoResponse） */
+export interface GeneratedVideo {
+  id: string
+  project_id?: string
+  generation_task_id?: string
+  name: string
+  file_url: string
+  file_size?: number
+  duration?: number
+  thumbnail_url?: string
+  width?: number
+  height?: number
+  fps?: number
+  status: string
+  review_status?: string
+  download_url?: string
+  created_at?: string
+  updated_at?: string
+}
+
+/* ============================================================
+ * AI 推荐 & 封面生成（任务 3.09）
+ * ============================================================ */
+
+/** AI 推荐请求 */
+export interface AIRecommendRequest {
+  asset_ids: string[]
+  editing_mode?: string
+  target_duration?: number
+}
+
+/** AI 推荐单个片段 */
+export interface AIRecommendClipItem {
+  clip_type: string
+  order: number
+  text_content: string
+  duration: number
+  transition_effect: string
+  asset_id: string
+  start_time: number
+  config: EditPlanConfig
+}
+
+/** AI 推荐响应 */
+export interface AIRecommendResponse {
+  plan_id: string
+  clips: AIRecommendClipItem[]
+  config: EditPlanConfig
+  total_duration: number
+  confidence: number
+}
+
+/** AI 封面生成请求 */
+export interface GenerateCoverRequest {
+  asset_ids: string[]
+  cover_type?: "ai_frame" | "manual" | "upload" | "ai_regenerate"
+  frame_time?: number
+}
+
+/** AI 封面生成响应 */
+export interface GenerateCoverResponse {
+  plan_id: string
+  cover: CoverResult
+}
+
+/** 封面生成结果 */
+export interface CoverResult {
+  scheme?: string
+  asset_id?: string
+  frame_time?: number
+  thumbnail_url?: string
+}
+
+/* ============================================================
+ * 前端 UI 类型（EditingPlanner 组件依赖，保留兼容）
+ * ============================================================ */
+
+/** 转场效果（14 种预设） */
+export interface TransitionEffect {
+  type:
+    | "none"
+    | "cut"
+    | "fade"
+    | "dissolve"
+    | "zoom"
+    | "slide_left"
+    | "slide_right"
+    | "slide_up"
+    | "slide_down"
+    | "wipe_left"
+    | "wipe_right"
+    | "wipe_up"
+    | "wipe_down"
+    | "circlecrop"
+    | "rectcrop"
+  duration: number // 转场时长（秒）
+  /** 播放速度倍率 */
+  playback_speed?: number
+}
+
+/** 素材库资产（UI 层类型，映射自后端 AssetResponse） */
+export interface MediaAsset {
+  id: string
+  name: string
+  type: "video" | "image" | "audio"
+  /** 缩略图 URL */
+  thumbnail_url?: string
+  /** 时长（秒），仅 video/audio */
+  duration?: number
+  /** 文件大小（字节） */
+  size?: number
+  /** 标签 */
+  tags: string[]
+  created_at: string
+  /** 质量分 0-100 */
+  quality_score?: number
+  /** 分类状态 */
+  classification_status?: "pending" | "processing" | "completed" | "failed"
+}
+
+/* ============================================================
+ * API 函数 — 严格对接后端
+ * ============================================================ */
+
+/** 模板草稿列表查询参数 */
+export interface EditPlanListParams {
+  page?: number
+  page_size?: number
+  template_id?: string
+  status?: string
+}
+
+/** 模板草稿列表分页响应 */
+export interface EditPlanListResponse {
+  items: EditPlan[]
+  total: number
+  page: number
+  page_size: number
+}
+
+/** 获取模板草稿列表（支持分页和筛选） */
+export async function getEditPlans(params?: EditPlanListParams): Promise<EditPlanListResponse> {
+  const response = await apiClient.get<EditPlanListResponse>("/templates/drafts", {
+    params,
+  })
+  return response.data
+}
+
+/** 获取单个模板草稿 */
+export async function getEditPlan(templateId: string): Promise<EditPlan> {
+  const response = await apiClient.get(`/templates/${templateId}/editor`)
+  return response.data
+}
+
+/** 创建模板草稿 */
+export async function createEditPlan(data: CreateEditPlanRequest): Promise<EditPlan> {
+  const response = await apiClient.post("/templates/drafts", data)
+  return response.data
+}
+
+/** 更新模板草稿 */
+export async function updateEditPlan(
+  templateId: string,
+  data: UpdateEditPlanRequest,
+): Promise<EditPlan> {
+  const response = await apiClient.put(`/templates/${templateId}/editor`, data)
+  return response.data
+}
+
+/** 删除模板草稿 */
+export async function deleteEditPlan(templateId: string): Promise<void> {
+  await apiClient.delete(`/templates/${templateId}/editor`)
+}
+
+/** 触发生成 */
+export async function generateEditPlan(templateId: string): Promise<GenerateResponse> {
+  const response = await apiClient.post(`/templates/${templateId}/editor/generate`)
+  return response.data
+}
+
+/** 获取生成状态（轮询用） */
+export async function getGenerationStatus(templateId: string): Promise<GenerationStatusResponse> {
+  const response = await apiClient.get(`/templates/${templateId}/editor/generation-status`)
+  return response.data
+}
+
+/** AI 推荐片段方案 */
+export async function aiRecommendClips(
+  templateId: string,
+  data: AIRecommendRequest,
+): Promise<AIRecommendResponse> {
+  const response = await apiClient.post(`/templates/${templateId}/editor/ai-recommend`, data)
+  return response.data
+}
+
+/** AI 生成封面 */
+export async function generateCover(
+  templateId: string,
+  data: GenerateCoverRequest,
+): Promise<GenerateCoverResponse> {
+  const response = await apiClient.post(`/templates/${templateId}/editor/generate-cover`, data)
+  return response.data
+}
+
+/** 获取模板草稿关联的生成记录 */
+export async function getEditPlanGenerations(templateId: string): Promise<EditPlanGeneration[]> {
+  const response = await apiClient.get(`/templates/${templateId}/editor/generations`)
+  return response.data.items || []
+}
+
+/** 获取生成任务的视频结果列表 */
+export async function getGenerationTaskResults(taskId: string): Promise<GeneratedVideo[]> {
+  const response = await apiClient.get(`/generation/tasks/${taskId}/results`)
+  return response.data.items || response.data || []
+}
+
+/** 取消生成任务 */
+export async function cancelGeneration(templateId: string): Promise<void> {
+  await apiClient.post(`/templates/${templateId}/editor/cancel`)
+}
+
+/* ============================================================
+ * 片段 CRUD（后端 EditPlanClip 独立表）
+ * ============================================================ */
+
+/** 片段状态 */
+export type EditPlanClipStatus = "pending" | "processing" | "ready" | "failed"
+
+/** 剪辑片段（后端响应） */
+export interface EditPlanClip {
+  id: string
+  plan_id: string
+  clip_type: string // main / intro / outro / overlay / background / b_roll 等
+  order: number
+  asset_id: string
+  text_content: string
+  start_time: number
+  duration: number
+  transition_effect: string
+  transition_duration: number
+  playback_speed: number
+  status: EditPlanClipStatus
+  config: Record<string, unknown>
+  created_at?: string
+  updated_at?: string
+}
+
+/** 创建片段请求 */
+export interface CreateEditPlanClipRequest {
+  clip_type: string
+  order: number
+  asset_id?: string
+  text_content?: string
+  start_time?: number
+  duration?: number
+  transition_effect?: string
+  transition_duration?: number
+  playback_speed?: number
+  config?: Record<string, unknown>
+}
+
+/** 更新片段请求 */
+export interface UpdateEditPlanClipRequest {
+  clip_type?: string
+  order?: number
+  asset_id?: string
+  text_content?: string
+  start_time?: number
+  duration?: number
+  transition_effect?: string
+  transition_duration?: number
+  playback_speed?: number
+  config?: Record<string, unknown>
+}
+
+/** 片段列表响应 */
+export interface EditPlanClipListResponse {
+  items: EditPlanClip[]
+  total: number
+}
+
+/** 片段列表查询参数 */
+export interface EditPlanClipListParams {
+  status?: string
+  skip?: number
+  limit?: number
+}
+
+/** 获取片段列表 */
+export async function getEditPlanClips(
+  templateId: string,
+  params?: EditPlanClipListParams,
+): Promise<EditPlanClipListResponse> {
+  const response = await apiClient.get<EditPlanClipListResponse>(
+    `/templates/${templateId}/editor/clips`,
+    {
+      params,
+    },
+  )
+  return response.data
+}
+
+/** 获取单个片段详情 */
+export async function getEditPlanClip(templateId: string, clipId: string): Promise<EditPlanClip> {
+  const response = await apiClient.get<EditPlanClip>(
+    `/templates/${templateId}/editor/clips/${clipId}`,
+  )
+  return response.data
+}
+
+/** 创建片段 */
+export async function createEditPlanClip(
+  templateId: string,
+  data: CreateEditPlanClipRequest,
+): Promise<EditPlanClip> {
+  const response = await apiClient.post<EditPlanClip>(`/templates/${templateId}/editor/clips`, data)
+  return response.data
+}
+
+/** 更新片段 */
+export async function updateEditPlanClip(
+  templateId: string,
+  clipId: string,
+  data: UpdateEditPlanClipRequest,
+): Promise<EditPlanClip> {
+  const response = await apiClient.put<EditPlanClip>(
+    `/templates/${templateId}/editor/clips/${clipId}`,
+    data,
+  )
+  return response.data
+}
+
+/** 删除片段 */
+export async function deleteEditPlanClip(templateId: string, clipId: string): Promise<void> {
+  await apiClient.delete(`/templates/${templateId}/editor/clips/${clipId}`)
+}
+
+/* ============================================================
+ * 片段批量操作
+ * ============================================================ */
+
+/** 重排序条目 */
+export interface ClipReorderItem {
+  clip_id: string
+  new_order: number
+}
+
+/** 重排序响应 */
+export interface ClipReorderResponse {
+  success: boolean
+  updated_count: number
+  message: string
+}
+
+/** 批量删除响应 */
+export interface ClipBatchDeleteResponse {
+  success: boolean
+  deleted_count: number
+  message: string
+}
+
+/** 从素材批量创建响应 */
+export interface ClipsFromAssetsResponse {
+  success: boolean
+  created_count: number
+  message: string
+  clip_ids: string[]
+}
+
+/** 片段重排序（拖拽排序后一次性提交） */
+export async function reorderEditPlanClips(
+  templateId: string,
+  items: ClipReorderItem[],
+): Promise<ClipReorderResponse> {
+  const response = await apiClient.post<ClipReorderResponse>(
+    `/templates/${templateId}/editor/clips/reorder`,
+    { items },
+  )
+  return response.data
+}
+
+/** 批量删除片段 */
+export async function batchDeleteEditPlanClips(
+  templateId: string,
+  clipIds: string[],
+): Promise<ClipBatchDeleteResponse> {
+  const response = await apiClient.post<ClipBatchDeleteResponse>(
+    `/templates/${templateId}/editor/clips/batch-delete`,
+    { clip_ids: clipIds },
+  )
+  return response.data
+}
+
+/** 从素材批量创建片段（追加到时间线末尾） */
+export async function createClipsFromAssets(
+  templateId: string,
+  assetIds: string[],
+  clipType = "main",
+): Promise<ClipsFromAssetsResponse> {
+  const response = await apiClient.post<ClipsFromAssetsResponse>(
+    `/templates/${templateId}/editor/clips/from-assets`,
+    { asset_ids: assetIds, clip_type: clipType },
+  )
+  return response.data
+}
+
+/* ============================================================
+ * 复制计划
+ * ============================================================ */
+
+/** 复制计划请求 */
+export interface CopyEditPlanRequest {
+  name?: string
+  project_id?: string
+}
+
+/** 复制模板草稿（含所有片段配置） */
+export async function copyEditPlan(
+  templateId: string,
+  data?: CopyEditPlanRequest,
+): Promise<EditPlan> {
+  const response = await apiClient.post<EditPlan>(
+    `/templates/${templateId}/editor/copy`,
+    data || {},
+  )
+  return response.data
+}
+
+/**
+ * 获取素材库列表 — 调用 GET /api/v1/assets?library_id=xxx
+ * 将后端 AssetResponse 映射为前端 MediaAsset 类型
+ */
+export async function getMediaAssets(libraryId?: string): Promise<MediaAsset[]> {
+  const response = await apiClient.get("/assets", {
+    params: libraryId ? { library_id: libraryId } : undefined,
+  })
+  const items: AssetItem[] = response.data.items || []
+  return items.map(mapAssetToMediaAsset)
+}
+
+/** 获取单个素材 */
+export async function getMediaAsset(id: string): Promise<MediaAsset> {
+  const response = await apiClient.get(`/assets/${id}`)
+  return mapAssetToMediaAsset(response.data)
+}
+
+/* ============================================================
+ * 映射函数：AssetResponse → MediaAsset
+ * ============================================================ */
+
+function inferMediaType(mimeType: string): "video" | "image" | "audio" {
+  if (mimeType.startsWith("video/")) return "video"
+  if (mimeType.startsWith("image/")) return "image"
+  return "audio"
+}
+
+function mapAssetToMediaAsset(asset: AssetItem): MediaAsset {
+  // 优先取顶层 duration，其次从 metadata 回退
+  const metaDuration =
+    typeof asset.metadata?.duration === "number" ? asset.metadata.duration : undefined
+  return {
+    id: asset.id,
+    name: asset.name,
+    type: inferMediaType(asset.mime_type || ""),
+    thumbnail_url: asset.thumbnail_url,
+    duration: asset.duration ?? metaDuration,
+    size: asset.file_size ?? undefined,
+    tags: [],
+    created_at: asset.created_at ?? "",
+    quality_score: asset.quality_score ?? undefined,
+    classification_status: asset.classification_status ?? undefined,
+  }
+}
+
+/* ============================================================
+ * 常量
+ * ============================================================ */
+
+/** 转场效果选项（14 种预设） */
+export const TRANSITION_OPTIONS: {
+  value: TransitionEffect["type"]
+  label: string
+  icon: string
+}[] = [
+  { value: "none", label: "无转场", icon: "⊘" },
+  { value: "cut", label: "硬切", icon: "✂" },
+  { value: "fade", label: "淡入淡出", icon: "◐" },
+  { value: "dissolve", label: "溶解", icon: "◈" },
+  { value: "zoom", label: "缩放", icon: "⊕" },
+  { value: "slide_left", label: "左滑", icon: "←" },
+  { value: "slide_right", label: "右滑", icon: "→" },
+  { value: "slide_up", label: "上滑", icon: "↑" },
+  { value: "slide_down", label: "下滑", icon: "↓" },
+  { value: "wipe_left", label: "左擦除", icon: "▸|" },
+  { value: "wipe_right", label: "右擦除", icon: "|◂" },
+  { value: "wipe_up", label: "上擦除", icon: "▴̄" },
+  { value: "wipe_down", label: "下擦除", icon: "▾̄" },
+  { value: "circlecrop", label: "圆形裁切", icon: "●" },
+  { value: "rectcrop", label: "矩形裁切", icon: "■" },
+]
+
+/** 素材类型标签 */
+export const MATERIAL_TYPE_LABELS: Record<string, string> = {
+  video: "视频",
+  image: "图片",
+  audio: "音频",
+  voiceover: "配音",
+}
+
+/** 素材类型图标 */
+export const MATERIAL_TYPE_ICONS: Record<string, string> = {
+  video: "🎬",
+  image: "🖼️",
+  audio: "🎵",
+  voiceover: "🎙️",
+}
+
+/** 计划状态标签 */
+export const PLAN_STATUS_LABELS: Record<EditPlanStatus, string> = {
+  draft: "草稿",
+  editing: "编辑中",
+  rendering: "渲染中",
+  completed: "已完成",
+  failed: "失败",
+  cancelled: "已取消",
+}
+
+/** 质量分筛选选项 */
+export const QUALITY_OPTIONS: {
+  value: string
+  label: string
+  min?: number
+  max?: number
+}[] = [
+  { value: "all", label: "全部质量" },
+  { value: "high", label: "高质量 (80-100)", min: 80, max: 100 },
+  { value: "medium", label: "中质量 (50-79)", min: 50, max: 79 },
+  { value: "low", label: "低质量 (0-49)", min: 0, max: 49 },
+]
@@ -1,28 +0,0 @@
-/**
- * AI 推荐 + 封面生成 API
- */
-import apiClient from "../client"
-import type {
-  AIRecommendRequest,
-  AIRecommendResponse,
-  GenerateCoverRequest,
-  GenerateCoverResponse,
-} from "./types"
-
-/** AI 推荐片段方案 */
-export async function aiRecommendClips(
-  templateId: string,
-  data: AIRecommendRequest,
-): Promise<AIRecommendResponse> {
-  const response = await apiClient.post(`/templates/${templateId}/editor/ai-recommend`, data)
-  return response.data
-}
-
-/** AI 生成封面 */
-export async function generateCover(
-  templateId: string,
-  data: GenerateCoverRequest,
-): Promise<GenerateCoverResponse> {
-  const response = await apiClient.post(`/templates/${templateId}/editor/generate-cover`, data)
-  return response.data
-}
@@ -1,99 +0,0 @@
-/**
- * 片段 CRUD + 批量操作 API
- */
-import apiClient from "../client"
-import type {
-  EditPlanClip,
-  EditPlanClipListParams,
-  EditPlanClipListResponse,
-  CreateEditPlanClipRequest,
-  UpdateEditPlanClipRequest,
-  ClipReorderItem,
-  ClipReorderResponse,
-  ClipBatchDeleteResponse,
-  ClipsFromAssetsResponse,
-} from "./types"
-
-/** 获取片段列表 */
-export async function getEditPlanClips(
-  templateId: string,
-  params?: EditPlanClipListParams,
-): Promise<EditPlanClipListResponse> {
-  const response = await apiClient.get<EditPlanClipListResponse>(
-    `/templates/${templateId}/editor/clips`,
-    { params },
-  )
-  return response.data
-}
-
-/** 获取单个片段详情 */
-export async function getEditPlanClip(templateId: string, clipId: string): Promise<EditPlanClip> {
-  const response = await apiClient.get<EditPlanClip>(
-    `/templates/${templateId}/editor/clips/${clipId}`,
-  )
-  return response.data
-}
-
-/** 创建片段 */
-export async function createEditPlanClip(
-  templateId: string,
-  data: CreateEditPlanClipRequest,
-): Promise<EditPlanClip> {
-  const response = await apiClient.post<EditPlanClip>(`/templates/${templateId}/editor/clips`, data)
-  return response.data
-}
-
-/** 更新片段 */
-export async function updateEditPlanClip(
-  templateId: string,
-  clipId: string,
-  data: UpdateEditPlanClipRequest,
-): Promise<EditPlanClip> {
-  const response = await apiClient.put<EditPlanClip>(
-    `/templates/${templateId}/editor/clips/${clipId}`,
-    data,
-  )
-  return response.data
-}
-
-/** 删除片段 */
-export async function deleteEditPlanClip(templateId: string, clipId: string): Promise<void> {
-  await apiClient.delete(`/templates/${templateId}/editor/clips/${clipId}`)
-}
-
-/** 片段重排序（拖拽排序后一次性提交） */
-export async function reorderEditPlanClips(
-  templateId: string,
-  items: ClipReorderItem[],
-): Promise<ClipReorderResponse> {
-  const response = await apiClient.post<ClipReorderResponse>(
-    `/templates/${templateId}/editor/clips/reorder`,
-    { items },
-  )
-  return response.data
-}
-
-/** 批量删除片段 */
-export async function batchDeleteEditPlanClips(
-  templateId: string,
-  clipIds: string[],
-): Promise<ClipBatchDeleteResponse> {
-  const response = await apiClient.post<ClipBatchDeleteResponse>(
-    `/templates/${templateId}/editor/clips/batch-delete`,
-    { clip_ids: clipIds },
-  )
-  return response.data
-}
-
-/** 从素材批量创建片段（追加到时间线末尾） */
-export async function createClipsFromAssets(
-  templateId: string,
-  assetIds: string[],
-  clipType = "main",
-): Promise<ClipsFromAssetsResponse> {
-  const response = await apiClient.post<ClipsFromAssetsResponse>(
-    `/templates/${templateId}/editor/clips/from-assets`,
-    { asset_ids: assetIds, clip_type: clipType },
-  )
-  return response.data
-}
@@ -1,66 +0,0 @@
-/**
- * 模板编辑器常量
- */
-import type { TransitionEffect, EditPlanStatus } from "./types"
-
-/** 转场效果选项（14 种预设） */
-export const TRANSITION_OPTIONS: {
-  value: TransitionEffect["type"]
-  label: string
-  icon: string
-}[] = [
-  { value: "none", label: "无转场", icon: "⊘" },
-  { value: "cut", label: "硬切", icon: "✂" },
-  { value: "fade", label: "淡入淡出", icon: "◐" },
-  { value: "dissolve", label: "溶解", icon: "◈" },
-  { value: "zoom", label: "缩放", icon: "⊕" },
-  { value: "slide_left", label: "左滑", icon: "←" },
-  { value: "slide_right", label: "右滑", icon: "→" },
-  { value: "slide_up", label: "上滑", icon: "↑" },
-  { value: "slide_down", label: "下滑", icon: "↓" },
-  { value: "wipe_left", label: "左擦除", icon: "▸|" },
-  { value: "wipe_right", label: "右擦除", icon: "|◂" },
-  { value: "wipe_up", label: "上擦除", icon: "▴̄" },
-  { value: "wipe_down", label: "下擦除", icon: "▾̄" },
-  { value: "circlecrop", label: "圆形裁切", icon: "●" },
-  { value: "rectcrop", label: "矩形裁切", icon: "■" },
-]
-
-/** 素材类型标签 */
-export const MATERIAL_TYPE_LABELS: Record<string, string> = {
-  video: "视频",
-  image: "图片",
-  audio: "音频",
-  voiceover: "配音",
-}
-
-/** 素材类型图标 */
-export const MATERIAL_TYPE_ICONS: Record<string, string> = {
-  video: "🎬",
-  image: "🖼️",
-  audio: "🎵",
-  voiceover: "🎙️",
-}
-
-/** 计划状态标签 */
-export const PLAN_STATUS_LABELS: Record<EditPlanStatus, string> = {
-  draft: "草稿",
-  editing: "编辑中",
-  rendering: "渲染中",
-  completed: "已完成",
-  failed: "失败",
-  cancelled: "已取消",
-}
-
-/** 质量分筛选选项 */
-export const QUALITY_OPTIONS: {
-  value: string
-  label: string
-  min?: number
-  max?: number
-}[] = [
-  { value: "all", label: "全部质量" },
-  { value: "high", label: "高质量 (80-100)", min: 80, max: 100 },
-  { value: "medium", label: "中质量 (50-79)", min: 50, max: 79 },
-  { value: "low", label: "低质量 (0-49)", min: 0, max: 49 },
-]
@@ -1,91 +0,0 @@
-/**
- * 模板草稿 CRUD + 生成相关 API
- */
-import apiClient from "../client"
-import type {
-  EditPlan,
-  EditPlanListParams,
-  EditPlanListResponse,
-  CreateEditPlanRequest,
-  UpdateEditPlanRequest,
-  GenerateResponse,
-  GenerationStatusResponse,
-  EditPlanGeneration,
-  GeneratedVideo,
-  CopyEditPlanRequest,
-} from "./types"
-
-/** 获取模板草稿列表（支持分页和筛选） */
-export async function getEditPlans(params?: EditPlanListParams): Promise<EditPlanListResponse> {
-  const response = await apiClient.get<EditPlanListResponse>("/templates/drafts", {
-    params,
-  })
-  return response.data
-}
-
-/** 获取单个模板草稿 */
-export async function getEditPlan(templateId: string): Promise<EditPlan> {
-  const response = await apiClient.get(`/templates/${templateId}/editor`)
-  return response.data
-}
-
-/** 创建模板草稿 */
-export async function createEditPlan(data: CreateEditPlanRequest): Promise<EditPlan> {
-  const response = await apiClient.post("/templates/drafts", data)
-  return response.data
-}
-
-/** 更新模板草稿 */
-export async function updateEditPlan(
-  templateId: string,
-  data: UpdateEditPlanRequest,
-): Promise<EditPlan> {
-  const response = await apiClient.put(`/templates/${templateId}/editor`, data)
-  return response.data
-}
-
-/** 删除模板草稿 */
-export async function deleteEditPlan(templateId: string): Promise<void> {
-  await apiClient.delete(`/templates/${templateId}/editor`)
-}
-
-/** 触发生成 */
-export async function generateEditPlan(templateId: string): Promise<GenerateResponse> {
-  const response = await apiClient.post(`/templates/${templateId}/editor/generate`)
-  return response.data
-}
-
-/** 获取生成状态（轮询用） */
-export async function getGenerationStatus(templateId: string): Promise<GenerationStatusResponse> {
-  const response = await apiClient.get(`/templates/${templateId}/editor/generation-status`)
-  return response.data
-}
-
-/** 获取模板草稿关联的生成记录 */
-export async function getEditPlanGenerations(templateId: string): Promise<EditPlanGeneration[]> {
-  const response = await apiClient.get(`/templates/${templateId}/editor/generations`)
-  return response.data.items || []
-}
-
-/** 获取生成任务的视频结果列表 */
-export async function getGenerationTaskResults(taskId: string): Promise<GeneratedVideo[]> {
-  const response = await apiClient.get(`/generation/tasks/${taskId}/results`)
-  return response.data.items || response.data || []
-}
-
-/** 取消生成任务 */
-export async function cancelGeneration(templateId: string): Promise<void> {
-  await apiClient.post(`/templates/${templateId}/editor/cancel`)
-}
-
-/** 复制模板草稿（含所有片段配置） */
-export async function copyEditPlan(
-  templateId: string,
-  data?: CopyEditPlanRequest,
-): Promise<EditPlan> {
-  const response = await apiClient.post<EditPlan>(
-    `/templates/${templateId}/editor/copy`,
-    data || {},
-  )
-  return response.data
-}
@@ -1,88 +0,0 @@
-/**
- * 模板编辑器 API — 按模块拆分后的统一入口
- * 保持与原 template-editor.ts 相同的导出结构，向后兼容
- */
-
-// 类型
-export type {
-  EditPlanStatus,
-  TitleConfig,
-  SubtitleConfig,
-  BgmConfig,
-  SegmentTtsConfig,
-  SegmentTrimConfig,
-  SegmentTransitionConfig,
-  EditPlanSegment,
-  EditPlanConfig,
-  EditPlan,
-  CreateEditPlanRequest,
-  UpdateEditPlanRequest,
-  EditPlanListParams,
-  EditPlanListResponse,
-  GenerateResponse,
-  EditPlanGeneration,
-  ClipStatusItem,
-  GenerationStatusResponse,
-  GeneratedVideo,
-  AIRecommendRequest,
-  AIRecommendClipItem,
-  AIRecommendResponse,
-  GenerateCoverRequest,
-  GenerateCoverResponse,
-  CoverResult,
-  EditPlanClipStatus,
-  EditPlanClip,
-  CreateEditPlanClipRequest,
-  UpdateEditPlanClipRequest,
-  EditPlanClipListResponse,
-  EditPlanClipListParams,
-  ClipReorderItem,
-  ClipReorderResponse,
-  ClipBatchDeleteResponse,
-  ClipsFromAssetsResponse,
-  CopyEditPlanRequest,
-  TransitionEffect,
-  MediaAsset,
-} from "./types"
-
-// 常量
-export {
-  TRANSITION_OPTIONS,
-  MATERIAL_TYPE_LABELS,
-  MATERIAL_TYPE_ICONS,
-  PLAN_STATUS_LABELS,
-  QUALITY_OPTIONS,
-} from "./constants"
-
-// 模板草稿 CRUD + 生成
-export {
-  getEditPlans,
-  getEditPlan,
-  createEditPlan,
-  updateEditPlan,
-  deleteEditPlan,
-  generateEditPlan,
-  getGenerationStatus,
-  getEditPlanGenerations,
-  getGenerationTaskResults,
-  cancelGeneration,
-  copyEditPlan,
-} from "./editPlans"
-
-// 片段 CRUD + 批量操作
-export {
-  getEditPlanClips,
-  getEditPlanClip,
-  createEditPlanClip,
-  updateEditPlanClip,
-  deleteEditPlanClip,
-  reorderEditPlanClips,
-  batchDeleteEditPlanClips,
-  createClipsFromAssets,
-} from "./clips"
-
-// AI 推荐 + 封面生成
-export { aiRecommendClips, generateCover } from "./aiFeatures"
-
-// 素材库
-export { getMediaAssets, getMediaAsset } from "./mediaAssets"
@@ -1,45 +0,0 @@
-/**
- * 素材库 API（对接 /assets 接口，映射为 MediaAsset 类型）
- */
-import apiClient from "../client"
-import type { AssetItem } from "../assets"
-import type { MediaAsset } from "./types"
-
-const inferMediaType = (mimeType: string): "video" | "image" | "audio" => {
-  if (mimeType.startsWith("video/")) return "video"
-  if (mimeType.startsWith("image/")) return "image"
-  return "audio"
-}
-
-const mapAssetToMediaAsset = (asset: AssetItem): MediaAsset => {
-  const metaDuration =
-    typeof asset.metadata?.duration === "number" ? asset.metadata.duration : undefined
-  return {
-    id: asset.id,
-    name: asset.name,
-    type: inferMediaType(asset.mime_type || ""),
-    source_url: asset.file_url,
-    thumbnail_url: asset.thumbnail_url,
-    duration: asset.duration ?? metaDuration,
-    size: asset.file_size ?? undefined,
-    tags: [],
-    created_at: asset.created_at ?? "",
-    quality_score: asset.quality_score ?? undefined,
-    classification_status: asset.classification_status ?? undefined,
-  }
-}
-
-/** 获取素材库列表 */
-export async function getMediaAssets(libraryId?: string): Promise<MediaAsset[]> {
-  const response = await apiClient.get("/assets", {
-    params: libraryId ? { library_id: libraryId } : undefined,
-  })
-  const items: AssetItem[] = response.data.items || []
-  return items.map(mapAssetToMediaAsset)
-}
-
-/** 获取单个素材 */
-export async function getMediaAsset(id: string): Promise<MediaAsset> {
-  const response = await apiClient.get(`/assets/${id}`)
-  return mapAssetToMediaAsset(response.data)
-}
@@ -1,442 +0,0 @@
-/**
- * 模板编辑器 API 类型定义
- * 字段名严格匹配后端 API 响应
- */
-import type {
-  WatermarkConfig,
-  IntroOutroConfig,
-  PipConfig,
-  FilterConfig,
-  ChromaKeyConfig,
-  StickerConfig,
-  CoverConfig,
-} from "@/pages/editing-planner/types"
-
-/* ── 模板草稿状态 ── */
-
-export type EditPlanStatus =
-  "draft" | "editing" | "rendering" | "completed" | "failed" | "cancelled"
-
-/* ── 配置相关类型 ── */
-
-/** 标题配置（对齐后端 title_config） */
-export interface TitleConfig {
-  ai_auto_select: boolean
-  content: string
-  font_preset: string
-  font_color: string
-  font_size: number
-  position: string
-}
-
-/** 字幕配置 */
-export interface SubtitleConfig {
-  enabled: boolean
-  position: string
-  font: string
-  color: string
-  size: number
-  animation: string
-}
-
-/** BGM 配置 */
-export interface BgmConfig {
-  enabled: boolean
-  music_id: string
-}
-
-/** 片段 TTS 配置 */
-export interface SegmentTtsConfig {
-  mode: string
-  text: string
-  voice_id: string
-  speed: number
-  pitch: number
-  volume: number
-  subtitle_sync: boolean
-}
-
-/** 片段裁剪配置 */
-export interface SegmentTrimConfig {
-  start_time: number
-  end_time: number
-}
-
-/** 片段转场配置 */
-export interface SegmentTransitionConfig {
-  type: string
-  duration: number
-}
-
-/** 模板草稿中的单个片段 */
-export interface EditPlanSegment {
-  segment_order: number
-  duration_min: number
-  duration_max: number
-  material_type: string
-  transition?: SegmentTransitionConfig
-  playback_speed?: number
-  tts_config?: SegmentTtsConfig
-  trim_config?: SegmentTrimConfig
-}
-
-/** 模板草稿 config 完整类型 */
-export interface EditPlanConfig {
-  title_config?: TitleConfig
-  subtitle_config?: SubtitleConfig
-  bgm_config?: BgmConfig
-  estimated_duration?: number
-  segments?: EditPlanSegment[]
-  watermark_config?: WatermarkConfig
-  intro_outro_config?: IntroOutroConfig
-  pip_config?: PipConfig
-  filter_config?: FilterConfig
-  green_screen_config?: ChromaKeyConfig
-  sticker_config?: StickerConfig
-  cover_config?: CoverConfig
-  /** 前端扩展：关联的素材 ID 列表 */
-  asset_ids?: string[]
-  /** 配音 ID */
-  voice_id?: string
-  /** 克隆音色档案 ID */
-  voice_clone_profile_id?: string
-  /** 自定义配音音频 URL */
-  custom_audio_url?: string
-  /** 自定义配音文本 */
-  custom_text?: string
-  /** 视频比例 */
-  ratio?: string
-  /** 视频风格 */
-  style?: string
-  /** 目标时长（秒） */
-  duration?: number
-  /** 是否自动生成字幕 */
-  auto_subtitles?: boolean
-  /** 是否启用 BGM */
-  bgm?: boolean
-  /** 生成数量 */
-  generate_count?: number
-  /** 素材模式 */
-  material_mode?: string
-}
-
-/* ── 模板草稿主体 ── */
-
-/** 模板草稿（后端响应） */
-export interface EditPlan {
-  id: string
-  template_id: string
-  name: string
-  status: EditPlanStatus
-  total_duration: number
-  /** 生成视频数量 */
-  result_count: number
-  config: EditPlanConfig
-  created_at: string
-  updated_at: string
-}
-
-/** 创建模板草稿请求 */
-export interface CreateEditPlanRequest {
-  template_id: string
-  name: string
-  config?: EditPlanConfig
-  total_duration?: number
-  /** 来源模板草稿 ID */
-  source_edit_plan_id?: string
-}
-
-/** 更新模板草稿请求 */
-export interface UpdateEditPlanRequest {
-  name?: string
-  config?: EditPlanConfig
-  total_duration?: number
-  status?: EditPlanStatus
-}
-
-/** 模板草稿列表查询参数 */
-export interface EditPlanListParams {
-  page?: number
-  page_size?: number
-  template_id?: string
-  status?: string
-}
-
-/** 模板草稿列表分页响应 */
-export interface EditPlanListResponse {
-  items: EditPlan[]
-  total: number
-  page: number
-  page_size: number
-}
-
-/* ── 生成相关 ── */
-
-/** 生成响应 */
-export interface GenerateResponse {
-  plan_id: string
-  plan_status: EditPlanStatus
-  generation_task_id: string
-  clip_count: number
-}
-
-/** 模板草稿关联的生成记录 */
-export interface EditPlanGeneration {
-  id: string
-  source_edit_plan_id: string
-  template_id: string
-  asset_ids: string[]
-  status: EditPlanStatus
-  progress: number
-  result_count: number
-  error_message: string
-  error_info: Record<string, unknown>
-  logs: Array<Record<string, unknown>>
-  retry_count: number
-  created_at?: string
-  updated_at?: string
-}
-
-/** 片段生成状态 */
-export interface ClipStatusItem {
-  clip_id: string
-  clip_type: string
-  order: number
-  status: string
-  asset_id?: string
-  text_content?: string
-  duration?: number
-  error_message?: string
-}
-
-/** 生成状态轮询响应 */
-export interface GenerationStatusResponse {
-  plan_id: string
-  plan_status: EditPlanStatus
-  generation_task_id?: string
-  error_message?: string
-  clips: ClipStatusItem[]
-  error?: string
-  message?: string
-}
-
-/** 生成视频详情 */
-export interface GeneratedVideo {
-  id: string
-  project_id?: string
-  generation_task_id?: string
-  name: string
-  file_url: string
-  file_size?: number
-  duration?: number
-  thumbnail_url?: string
-  width?: number
-  height?: number
-  fps?: number
-  status: string
-  review_status?: string
-  download_url?: string
-  created_at?: string
-  updated_at?: string
-}
-
-/* ── AI 推荐 & 封面生成 ── */
-
-/** AI 推荐请求 */
-export interface AIRecommendRequest {
-  asset_ids: string[]
-  editing_mode?: string
-  target_duration?: number
-}
-
-/** AI 推荐单个片段 */
-export interface AIRecommendClipItem {
-  clip_type: string
-  order: number
-  text_content: string
-  duration: number
-  transition_effect: string
-  asset_id: string
-  start_time: number
-  config: EditPlanConfig
-}
-
-/** AI 推荐响应 */
-export interface AIRecommendResponse {
-  plan_id: string
-  clips: AIRecommendClipItem[]
-  config: EditPlanConfig
-  total_duration: number
-  confidence: number
-}
-
-/** AI 封面生成请求 */
-export interface GenerateCoverRequest {
-  asset_ids: string[]
-  cover_type?: "ai_frame" | "manual" | "upload" | "ai_regenerate"
-  frame_time?: number
-}
-
-/** AI 封面生成响应 */
-export interface GenerateCoverResponse {
-  plan_id: string
-  cover: CoverResult
-}
-
-/** 封面生成结果 */
-export interface CoverResult {
-  scheme?: string
-  asset_id?: string
-  frame_time?: number
-  thumbnail_url?: string
-}
-
-/* ── 片段 CRUD 相关 ── */
-
-/** 片段状态 */
-export type EditPlanClipStatus = "pending" | "processing" | "ready" | "failed"
-
-/** 剪辑片段（后端响应） */
-export interface EditPlanClip {
-  id: string
-  plan_id: string
-  clip_type: string
-  order: number
-  asset_id: string
-  text_content: string
-  start_time: number
-  duration: number
-  transition_effect: string
-  transition_duration: number
-  playback_speed: number
-  status: EditPlanClipStatus
-  config: Record<string, unknown>
-  created_at?: string
-  updated_at?: string
-}
-
-/** 创建片段请求 */
-export interface CreateEditPlanClipRequest {
-  clip_type: string
-  order: number
-  asset_id?: string
-  text_content?: string
-  start_time?: number
-  duration?: number
-  transition_effect?: string
-  transition_duration?: number
-  playback_speed?: number
-  config?: Record<string, unknown>
-}
-
-/** 更新片段请求 */
-export interface UpdateEditPlanClipRequest {
-  clip_type?: string
-  order?: number
-  asset_id?: string
-  text_content?: string
-  start_time?: number
-  duration?: number
-  transition_effect?: string
-  transition_duration?: number
-  playback_speed?: number
-  config?: Record<string, unknown>
-}
-
-/** 片段列表响应 */
-export interface EditPlanClipListResponse {
-  items: EditPlanClip[]
-  total: number
-}
-
-/** 片段列表查询参数 */
-export interface EditPlanClipListParams {
-  status?: string
-  skip?: number
-  limit?: number
-}
-
-/* ── 片段批量操作 ── */
-
-/** 重排序条目 */
-export interface ClipReorderItem {
-  clip_id: string
-  new_order: number
-}
-
-/** 重排序响应 */
-export interface ClipReorderResponse {
-  success: boolean
-  updated_count: number
-  message: string
-}
-
-/** 批量删除响应 */
-export interface ClipBatchDeleteResponse {
-  success: boolean
-  deleted_count: number
-  message: string
-}
-
-/** 从素材批量创建响应 */
-export interface ClipsFromAssetsResponse {
-  success: boolean
-  created_count: number
-  message: string
-  clip_ids: string[]
-}
-
-/* ── 复制计划 ── */
-
-/** 复制计划请求 */
-export interface CopyEditPlanRequest {
-  name?: string
-  project_id?: string
-}
-
-/* ── 前端 UI 类型 ── */
-
-/** 转场效果（14 种预设） */
-export interface TransitionEffect {
-  type:
-    | "none"
-    | "cut"
-    | "fade"
-    | "dissolve"
-    | "zoom"
-    | "slide_left"
-    | "slide_right"
-    | "slide_up"
-    | "slide_down"
-    | "wipe_left"
-    | "wipe_right"
-    | "wipe_up"
-    | "wipe_down"
-    | "circlecrop"
-    | "rectcrop"
-  duration: number
-  /** 播放速度倍率 */
-  playback_speed?: number
-}
-
-/** 素材库资产（UI 层类型） */
-export interface MediaAsset {
-  id: string
-  name: string
-  type: "video" | "image" | "audio"
-  /** 源文件 URL（视频/原图），用于悬浮预览播放 */
-  source_url?: string
-  /** 缩略图 URL */
-  thumbnail_url?: string
-  /** 时长（秒），仅 video/audio */
-  duration?: number
-  /** 文件大小（字节） */
-  size?: number
-  /** 标签 */
-  tags: string[]
-  created_at: string
-  /** 质量分 0-100 */
-  quality_score?: number
-  /** 分类状态 */
-  classification_status?: "pending" | "processing" | "completed" | "failed"
-}
@@ -0,0 +1,168 @@
+/**
+ * 模板相关 API
+ * 对接后端模板管理接口：
+ * - GET  /api/v1/templates              — 模板列表（分页/筛选）
+ * - GET  /api/v1/templates/{id}         — 模板详情
+ * - POST /api/v1/templates/{id}/copy    — 复制模板
+ * - POST /api/v1/templates/{id}/generate — 从模板生成
+ * - POST /api/v1/templates/{id}/toggle-favorite — 收藏/取消收藏
+ */
+import apiClient from "./client"
+import type { TitleConfig, SubtitleConfig, BgmConfig } from "./editing-planner"
+import type { EditPlanConfig } from "./template-editor"
+
+/* ──────────── 类型定义 ──────────── */
+
+/** 模板条目（后端 TemplateResponse） */
+export interface TemplateItem {
+  id: string
+  user_id?: string
+  name: string
+  description?: string
+  mode?: string
+  category: string
+  tags?: string[]
+  /** 预估时长（后端字段名 estimated_duration） */
+  estimated_duration?: number
+  /** @deprecated 后端已改名为 estimated_duration，保留兼容 */
+  target_duration?: number
+  clip_count?: number
+  /** 使用次数 */
+  usage_count?: number
+  thumbnail_url?: string
+  preview_url?: string
+  is_active?: boolean
+  is_favorite?: boolean
+  /** 素材规则（片段配置） */
+  segments?: TemplateSegment[]
+  /** 字幕样式 */
+  subtitle_config?: SubtitleConfig
+  /** BGM 配置 */
+  bgm_config?: BgmConfig
+  /** 标题配置 */
+  title_config?: TitleConfig
+  /** 视频比例 */
+  aspect_ratio?: string
+  created_at?: string
+  updated_at?: string
+}
+
+/** 模板片段（素材规则） */
+export interface TemplateSegment {
+  id?: string
+  segment_order: number
+  duration_min: number
+  duration_max: number
+  material_type: string | null
+  description?: string
+}
+
+/** 模板列表查询参数 */
+export interface TemplateListParams {
+  page?: number
+  page_size?: number
+  category?: string
+  tags?: string
+  keyword?: string
+  /** 时长筛选（秒）：short < 30, medium 30-120, long > 120 */
+  duration_range?: "short" | "medium" | "long"
+}
+
+/** 模板列表分页响应 */
+export interface TemplateListResponse {
+  items: TemplateItem[]
+  total: number
+  page: number
+  page_size: number
+}
+
+/** 从模板生成请求 */
+export interface GenerateFromTemplateRequest {
+  asset_ids?: string[]
+  name?: string
+  config?: EditPlanConfig
+}
+
+/** 从模板生成响应 */
+export interface GenerateFromTemplateResponse {
+  plan_id: string
+  template_id: string
+  status: string
+  name: string
+}
+
+/** 复制模板响应 */
+export interface CopyTemplateResponse {
+  id: string
+  name: string
+  source_template_id: string
+}
+
+/* ──────────── API 函数 ──────────── */
+
+/** 获取模板列表（支持分页和筛选） */
+export const getTemplates = async (params?: TemplateListParams): Promise<TemplateListResponse> => {
+  const { data } = await apiClient.get<TemplateListResponse>("/templates", {
+    params,
+  })
+  return data
+}
+
+/** 获取模板列表（兼容旧接口，返回数组） */
+export const getTemplatesList = async (): Promise<TemplateItem[]> => {
+  const response = await apiClient.get("/templates")
+  return response.data.items || response.data || []
+}
+
+/** 获取单个模板详情 */
+export const getTemplate = async (templateId: string): Promise<TemplateItem> => {
+  const response = await apiClient.get(`/templates/${templateId}`)
+  return response.data
+}
+
+/** 收藏 / 取消收藏模板 */
+export const toggleFavoriteTemplate = async (
+  templateId: string,
+): Promise<{ is_favorite: boolean }> => {
+  const response = await apiClient.post(`/templates/${templateId}/toggle-favorite`)
+  return response.data
+}
+
+/** 复制模板（创建副本到我的模板） */
+export const copyTemplate = async (templateId: string): Promise<CopyTemplateResponse> => {
+  const response = await apiClient.post<CopyTemplateResponse>(`/templates/${templateId}/copy`)
+  return response.data
+}
+
+/** 从模板生成 */
+export const generateFromTemplate = async (
+  templateId: string,
+  data?: GenerateFromTemplateRequest,
+): Promise<GenerateFromTemplateResponse> => {
+  const response = await apiClient.post<GenerateFromTemplateResponse>(
+    `/templates/${templateId}/generate`,
+    data,
+  )
+  return response.data
+}
+
+/* ──────────── 常量 ──────────── */
+
+/** 模板分类选项 */
+export const TEMPLATE_CATEGORY_OPTIONS = [
+  { value: "", label: "全部分类" },
+  { value: "口播", label: "口播" },
+  { value: "种草", label: "种草" },
+  { value: "产品", label: "产品" },
+  { value: "品牌", label: "品牌" },
+  { value: "混剪", label: "混剪" },
+  { value: "Vlog", label: "Vlog" },
+]
+
+/** 时长筛选选项 */
+export const TEMPLATE_DURATION_OPTIONS = [
+  { value: "", label: "全部时长" },
+  { value: "short", label: "30秒以内" },
+  { value: "medium", label: "30秒-2分钟" },
+  { value: "long", label: "2分钟以上" },
+]
@@ -1,22 +0,0 @@
-/**
- * 模板相关常量
- */
-
-/** 模板分类选项 */
-export const TEMPLATE_CATEGORY_OPTIONS = [
-  { value: "", label: "全部分类" },
-  { value: "口播", label: "口播" },
-  { value: "种草", label: "种草" },
-  { value: "产品", label: "产品" },
-  { value: "品牌", label: "品牌" },
-  { value: "混剪", label: "混剪" },
-  { value: "Vlog", label: "Vlog" },
-]
-
-/** 时长筛选选项 */
-export const TEMPLATE_DURATION_OPTIONS = [
-  { value: "", label: "全部时长" },
-  { value: "short", label: "30秒以内" },
-  { value: "medium", label: "30秒-2分钟" },
-  { value: "long", label: "2分钟以上" },
-]
@@ -1,28 +0,0 @@
-/**
- * 模板相关 API — 目录化入口
- * 保持与原 templates.ts 相同导出，向后兼容
- */
-
-// 类型
-export type {
-  TemplateItem,
-  TemplateSegment,
-  TemplateListParams,
-  TemplateListResponse,
-  GenerateFromTemplateRequest,
-  GenerateFromTemplateResponse,
-  CopyTemplateResponse,
-} from "./types"
-
-// 常量
-export { TEMPLATE_CATEGORY_OPTIONS, TEMPLATE_DURATION_OPTIONS } from "./constants"
-
-// API 函数
-export {
-  getTemplates,
-  getTemplatesList,
-  getTemplate,
-  toggleFavoriteTemplate,
-  copyTemplate,
-  generateFromTemplate,
-} from "./templates"
@@ -1,59 +0,0 @@
-/**
- * 模板相关 API 函数
- * 对接后端模板管理接口
- */
-import apiClient from "../client"
-import type {
-  CopyTemplateResponse,
-  GenerateFromTemplateRequest,
-  GenerateFromTemplateResponse,
-  TemplateItem,
-  TemplateListParams,
-  TemplateListResponse,
-} from "./types"
-
-/** 获取模板列表（支持分页和筛选） */
-export const getTemplates = async (params?: TemplateListParams): Promise<TemplateListResponse> => {
-  const { data } = await apiClient.get<TemplateListResponse>("/templates", {
-    params,
-  })
-  return data
-}
-
-/** 获取模板列表（兼容旧接口，返回数组） */
-export const getTemplatesList = async (): Promise<TemplateItem[]> => {
-  const response = await apiClient.get("/templates")
-  return response.data.items || response.data || []
-}
-
-/** 获取单个模板详情 */
-export const getTemplate = async (templateId: string): Promise<TemplateItem> => {
-  const response = await apiClient.get(`/templates/${templateId}`)
-  return response.data
-}
-
-/** 收藏 / 取消收藏模板 */
-export const toggleFavoriteTemplate = async (
-  templateId: string,
-): Promise<{ is_favorite: boolean }> => {
-  const response = await apiClient.post(`/templates/${templateId}/toggle-favorite`)
-  return response.data
-}
-
-/** 复制模板（创建副本到我的模板） */
-export const copyTemplate = async (templateId: string): Promise<CopyTemplateResponse> => {
-  const response = await apiClient.post<CopyTemplateResponse>(`/templates/${templateId}/copy`)
-  return response.data
-}
-
-/** 从模板生成 */
-export const generateFromTemplate = async (
-  templateId: string,
-  data?: GenerateFromTemplateRequest,
-): Promise<GenerateFromTemplateResponse> => {
-  const response = await apiClient.post<GenerateFromTemplateResponse>(
-    `/templates/${templateId}/generate`,
-    data,
-  )
-  return response.data
-}
@@ -1,90 +0,0 @@
-/**
- * 模板相关类型定义
- */
-import type { TitleConfig, SubtitleConfig, BgmConfig } from "../editing-planner"
-import type { EditPlanConfig } from "../template-editor"
-
-/** 模板条目（后端 TemplateResponse） */
-export interface TemplateItem {
-  id: string
-  user_id?: string
-  name: string
-  description?: string
-  mode?: string
-  category: string
-  tags?: string[]
-  /** 预估时长（后端字段名 estimated_duration） */
-  estimated_duration?: number
-  /** @deprecated 后端已改名为 estimated_duration，保留兼容 */
-  target_duration?: number
-  clip_count?: number
-  /** 使用次数 */
-  usage_count?: number
-  thumbnail_url?: string
-  preview_url?: string
-  is_active?: boolean
-  is_favorite?: boolean
-  /** 素材规则（片段配置） */
-  segments?: TemplateSegment[]
-  /** 字幕样式 */
-  subtitle_config?: SubtitleConfig
-  /** BGM 配置 */
-  bgm_config?: BgmConfig
-  /** 标题配置 */
-  title_config?: TitleConfig
-  /** 视频比例 */
-  aspect_ratio?: string
-  created_at?: string
-  updated_at?: string
-}
-
-/** 模板片段（素材规则） */
-export interface TemplateSegment {
-  id?: string
-  segment_order: number
-  duration_min: number
-  duration_max: number
-  material_type: string | null
-  description?: string
-}
-
-/** 模板列表查询参数 */
-export interface TemplateListParams {
-  page?: number
-  page_size?: number
-  category?: string
-  tags?: string
-  keyword?: string
-  /** 时长筛选（秒）：short < 30, medium 30-120, long > 120 */
-  duration_range?: "short" | "medium" | "long"
-}
-
-/** 模板列表分页响应 */
-export interface TemplateListResponse {
-  items: TemplateItem[]
-  total: number
-  page: number
-  page_size: number
-}
-
-/** 从模板生成请求 */
-export interface GenerateFromTemplateRequest {
-  asset_ids?: string[]
-  name?: string
-  config?: EditPlanConfig
-}
-
-/** 从模板生成响应 */
-export interface GenerateFromTemplateResponse {
-  plan_id: string
-  template_id: string
-  status: string
-  name: string
-}
-
-/** 复制模板响应 */
-export interface CopyTemplateResponse {
-  id: string
-  name: string
-  source_template_id: string
-}
@@ -1,17 +1,70 @@
 /**
- * 标题相关 API 函数
+ * 标题相关 API
 * Phase 1 新增：全局标题库
 * 注意：后端 schema 使用 name + text 字段，前端 UI 用 content 展示
 */
-import apiClient from "../client"
-import type {
-  BackendCreateTitleRequest,
-  BackendTitleResponse,
-  BackendUpdateTitleRequest,
-  CreateTitleRequest,
-  TitleItem,
-} from "./types"
-import { toTitleItem } from "./utils"
+import apiClient from "./client"
+
+/** 标题条目（前端展示用） */
+export interface TitleItem {
+  id: string
+  content: string
+  category?: string
+  source?: string
+  word_count?: number
+  is_favorite?: boolean
+  created_at?: string
+  updated_at?: string
+}
+
+/** 后端标题响应格式 */
+interface BackendTitleResponse {
+  id: string
+  user_id: string
+  name: string
+  text: string
+  category: string
+  description: string
+  tags: string[]
+  usage_count: number
+  is_active: boolean
+  created_at: string
+  updated_at: string
+}
+
+/** 后端创建标题请求格式 */
+interface BackendCreateTitleRequest {
+  name: string
+  text: string
+  category: string
+  description?: string
+  tags?: string[]
+}
+
+/** 后端更新标题请求格式 */
+interface BackendUpdateTitleRequest {
+  name?: string
+  text?: string
+  category?: string
+  description?: string
+  tags?: string[]
+}
+
+/** 将后端响应映射为前端 TitleItem */
+const toTitleItem = (item: BackendTitleResponse): TitleItem => ({
+  id: item.id,
+  content: item.text,
+  category: item.category,
+  word_count: item.text?.length || 0,
+  created_at: item.created_at,
+  updated_at: item.updated_at,
+})
+
+/** 创建标题请求（前端接口，保持向后兼容） */
+export interface CreateTitleRequest {
+  content: string
+  category?: string
+}

 /** 获取当前用户的所有标题 */
 export const getTitles = async (): Promise<TitleItem[]> => {
@@ -1,19 +0,0 @@
-/**
- * 标题相关 API — 目录化入口
- * 保持与原 titles.ts 相同导出，向后兼容
- */
-
-// 类型
-export type {
-  TitleItem,
-  BackendTitleResponse,
-  BackendCreateTitleRequest,
-  BackendUpdateTitleRequest,
-  CreateTitleRequest,
-} from "./types"
-
-// 工具函数
-export { toTitleItem } from "./utils"
-
-// API 函数
-export { getTitles, createTitle, updateTitle, deleteTitle, batchImportTitles } from "./titles"
@@ -1,54 +0,0 @@
-/**
- * 标题相关类型定义
- */
-
-/** 标题条目（前端展示用） */
-export interface TitleItem {
-  id: string
-  content: string
-  category?: string
-  source?: string
-  word_count?: number
-  is_favorite?: boolean
-  created_at?: string
-  updated_at?: string
-}
-
-/** 后端标题响应格式 */
-export interface BackendTitleResponse {
-  id: string
-  user_id: string
-  name: string
-  text: string
-  category: string
-  description: string
-  tags: string[]
-  usage_count: number
-  is_active: boolean
-  created_at: string
-  updated_at: string
-}
-
-/** 后端创建标题请求格式 */
-export interface BackendCreateTitleRequest {
-  name: string
-  text: string
-  category: string
-  description?: string
-  tags?: string[]
-}
-
-/** 后端更新标题请求格式 */
-export interface BackendUpdateTitleRequest {
-  name?: string
-  text?: string
-  category?: string
-  description?: string
-  tags?: string[]
-}
-
-/** 创建标题请求（前端接口，保持向后兼容） */
-export interface CreateTitleRequest {
-  content: string
-  category?: string
-}
@@ -1,14 +0,0 @@
-/**
- * 标题数据转换工具函数
- */
-import type { BackendTitleResponse, TitleItem } from "./types"
-
-/** 将后端响应映射为前端 TitleItem */
-export const toTitleItem = (item: BackendTitleResponse): TitleItem => ({
-  id: item.id,
-  content: item.text,
-  category: item.category,
-  word_count: item.text?.length || 0,
-  created_at: item.created_at,
-  updated_at: item.updated_at,
-})
@@ -0,0 +1,188 @@
+/**
+ * TTS 语音合成 API
+ * 对接后端 /api/v1/tts/* 端点
+ *
+ * 任务 3.14 新增
+ */
+import apiClient from "./client"
+
+/* ── 类型定义 ──────────────────────────────────── */
+
+/** TTS 元数据（合成时附带的扩展信息） */
+export interface TTSMetadata {
+  /** 语音时长（秒） */
+  duration?: number
+  /** 采样率（Hz） */
+  sample_rate?: number
+  /** 语言 */
+  language?: string
+  /** 其他扩展字段 */
+  [key: string]: unknown
+}
+
+/** TTS 合成请求参数 */
+export interface TTSSynthesizeRequest {
+  text: string
+  voice_id?: string
+  output_name?: string
+  language?: string
+  speed?: number
+  voice_model?: string
+  voice_clone_profile_id?: string
+  format?: string
+  metadata?: TTSMetadata
+}
+
+/** TTS 合成创建响应 */
+export interface TTSSynthesizeResponse {
+  job_id: string
+  status: string
+  message: string
+}
+
+/** TTS 任务详情 */
+export interface TTSJob {
+  id: string
+  user_id: string
+  project_id: string | null
+  text: string
+  voice_id: string | null
+  voice_model: string | null
+  voice_clone_profile_id: string | null
+  language: string
+  speed: number
+  output_name: string | null
+  output_audio_url: string | null
+  output_format: string
+  duration_seconds: number | null
+  file_size_bytes: number | null
+  sample_rate: number | null
+  status: string
+  error_message: string | null
+  retry_count: number
+  max_retries: number
+  metadata_: TTSMetadata | null
+  created_at: string
+  updated_at: string
+}
+
+/** TTS 任务状态（轻量轮询用） */
+export interface TTSJobStatus {
+  id: string
+  status: string
+  output_audio_url: string | null
+  error_message: string | null
+  duration_seconds: number | null
+  retry_count: number
+}
+
+/** TTS 任务列表响应 */
+export interface TTSJobListResponse {
+  items: TTSJob[]
+  total: number
+  skip: number
+  limit: number
+}
+
+/** TTS 任务列表查询参数 */
+export interface TTSJobListParams {
+  status?: string
+  skip?: number
+  limit?: number
+}
+
+/* ── API 函数 ──────────────────────────────────── */
+
+/** 创建 TTS 合成任务 */
+export const synthesizeSpeech = async (
+  data: TTSSynthesizeRequest,
+): Promise<TTSSynthesizeResponse> => {
+  const response = await apiClient.post<TTSSynthesizeResponse>("/tts/synthesize", data)
+  return response.data
+}
+
+/** 获取 TTS 任务详情 */
+export const getTTSJob = async (jobId: string): Promise<TTSJob> => {
+  const response = await apiClient.get<TTSJob>(`/tts/jobs/${jobId}`)
+  return response.data
+}
+
+/** 获取 TTS 任务状态（轻量轮询） */
+export const getTTSJobStatus = async (jobId: string): Promise<TTSJobStatus> => {
+  const response = await apiClient.get<TTSJobStatus>(`/tts/jobs/${jobId}/status`)
+  return response.data
+}
+
+/** 获取 TTS 任务列表 */
+export const getTTSJobs = async (params?: TTSJobListParams): Promise<TTSJobListResponse> => {
+  const searchParams = new URLSearchParams()
+  if (params?.status) searchParams.set("status", params.status)
+  if (params?.skip !== undefined) searchParams.set("skip", String(params.skip))
+  if (params?.limit !== undefined) searchParams.set("limit", String(params.limit))
+  const qs = searchParams.toString()
+  const response = await apiClient.get<TTSJobListResponse>(`/tts/jobs${qs ? `?${qs}` : ""}`)
+  return response.data
+}
+
+/** 存为素材请求参数 */
+export interface SaveTtsToLibraryRequest {
+  name?: string
+  tag_ids?: string[]
+}
+
+/** 将 TTS 合成结果保存到配音库 */
+export const saveTtsToLibrary = async (
+  jobId: string,
+  data?: SaveTtsToLibraryRequest,
+): Promise<void> => {
+  await apiClient.post(`/tts/jobs/${jobId}/save-to-library`, data ?? {})
+}
+
+/** 删除 TTS 任务 */
+export const deleteTTSJob = async (jobId: string): Promise<void> => {
+  await apiClient.delete(`/tts/jobs/${jobId}`)
+}
+
+/* ── 音色列表 ──────────────────────────────────── */
+
+/** TTS 音色 */
+export interface TTSVoice {
+  id: string
+  name: string
+  /** 音色分类标签：male/female/young/service/news/emotion */
+  category?: string
+  /** 语言 */
+  language?: string
+  /** 试听 URL */
+  preview_url?: string
+  /** 描述 */
+  description?: string
+}
+
+/** 获取 TTS 音色列表 */
+export const getTtsVoices = async (): Promise<TTSVoice[]> => {
+  const response = await apiClient.get<TTSVoice[]>("/tts/voices")
+  return response.data
+}
+
+/* ── TTS 试听 ──────────────────────────────────── */
+
+/** TTS 试听请求参数 */
+export interface TTSPreviewRequest {
+  text: string
+  voice_id: string
+  speed?: number
+  pitch?: number
+}
+
+/** TTS 试听响应 */
+export interface TTSPreviewResponse {
+  audio_url: string
+  duration?: number
+}
+
+/** TTS 试听 */
+export const previewTts = async (data: TTSPreviewRequest): Promise<TTSPreviewResponse> => {
+  const response = await apiClient.post<TTSPreviewResponse>("/tts/preview", data)
+  return response.data
+}
@@ -1,31 +0,0 @@
-/**
- * TTS 语音合成 API — 目录化入口
- * 保持与原 tts.ts 相同导出，向后兼容
- */
-
-// 类型
-export type {
-  TTSMetadata,
-  TTSSynthesizeRequest,
-  TTSSynthesizeResponse,
-  TTSJob,
-  TTSJobStatus,
-  TTSJobListResponse,
-  TTSJobListParams,
-  SaveTtsToLibraryRequest,
-  TTSVoice,
-  TTSPreviewRequest,
-  TTSPreviewResponse,
-} from "./types"
-
-// API 函数
-export {
-  synthesizeSpeech,
-  getTTSJob,
-  getTTSJobStatus,
-  getTTSJobs,
-  saveTtsToLibrary,
-  deleteTTSJob,
-  getTtsVoices,
-  previewTts,
-} from "./jobs"
@@ -1,72 +0,0 @@
-/**
- * TTS 语音合成 API 函数
- */
-import apiClient from "../client"
-import type {
-  TTSSynthesizeRequest,
-  TTSSynthesizeResponse,
-  TTSJob,
-  TTSJobStatus,
-  TTSJobListResponse,
-  TTSJobListParams,
-  SaveTtsToLibraryRequest,
-  TTSVoice,
-  TTSPreviewRequest,
-  TTSPreviewResponse,
-} from "./types"
-
-/** 创建 TTS 合成任务 */
-export const synthesizeSpeech = async (
-  data: TTSSynthesizeRequest,
-): Promise<TTSSynthesizeResponse> => {
-  const response = await apiClient.post<TTSSynthesizeResponse>("/tts/synthesize", data)
-  return response.data
-}
-
-/** 获取 TTS 任务详情 */
-export const getTTSJob = async (jobId: string): Promise<TTSJob> => {
-  const response = await apiClient.get<TTSJob>(`/tts/jobs/${jobId}`)
-  return response.data
-}
-
-/** 获取 TTS 任务状态（轻量轮询） */
-export const getTTSJobStatus = async (jobId: string): Promise<TTSJobStatus> => {
-  const response = await apiClient.get<TTSJobStatus>(`/tts/jobs/${jobId}/status`)
-  return response.data
-}
-
-/** 获取 TTS 任务列表 */
-export const getTTSJobs = async (params?: TTSJobListParams): Promise<TTSJobListResponse> => {
-  const searchParams = new URLSearchParams()
-  if (params?.status) searchParams.set("status", params.status)
-  if (params?.skip !== undefined) searchParams.set("skip", String(params.skip))
-  if (params?.limit !== undefined) searchParams.set("limit", String(params.limit))
-  const qs = searchParams.toString()
-  const response = await apiClient.get<TTSJobListResponse>(`/tts/jobs${qs ? `?${qs}` : ""}`)
-  return response.data
-}
-
-/** 将 TTS 合成结果保存到配音库 */
-export const saveTtsToLibrary = async (
-  jobId: string,
-  data?: SaveTtsToLibraryRequest,
-): Promise<void> => {
-  await apiClient.post(`/tts/jobs/${jobId}/save-to-library`, data ?? {})
-}
-
-/** 删除 TTS 任务 */
-export const deleteTTSJob = async (jobId: string): Promise<void> => {
-  await apiClient.delete(`/tts/jobs/${jobId}`)
-}
-
-/** 获取 TTS 音色列表 */
-export const getTtsVoices = async (): Promise<TTSVoice[]> => {
-  const response = await apiClient.get<TTSVoice[]>("/tts/voices")
-  return response.data
-}
-
-/** TTS 试听 */
-export const previewTts = async (data: TTSPreviewRequest): Promise<TTSPreviewResponse> => {
-  const response = await apiClient.post<TTSPreviewResponse>("/tts/preview", data)
-  return response.data
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
xiaoxia	ab1faf97e9	Merge branch 'develop' into refactor/duplication-api CI/CD Pipeline / Check if frontend-only change (pull_request) Successful in 14s Details CI/CD Pipeline / Validate - Type Check (mypy) (pull_request) Successful in 1m24s Details CI/CD Pipeline / Validate - Migration (alembic) (pull_request) Successful in 1m13s Details CI/CD Pipeline / Frontend Lint (pull_request) Successful in 36s Details CI/CD Pipeline / Build Staging API Image (pull_request) Has been skipped Details CI/CD Pipeline / Build Staging Web Image (pull_request) Has been skipped Details CI/CD Pipeline / Build Staging Worker Image (pull_request) Has been skipped Details CI/CD Pipeline / PR Build Worker Image (pull_request) Successful in 35s Details CI/CD Pipeline / Validate - Code Quality (pull_request) Failing after 2m54s Details PR Automation / Auto Approve on CI Green (pull_request) Successful in 53s Details CI/CD Pipeline / PR Build API Image (pull_request) Successful in 2m15s Details CI/CD Pipeline / PR Build Web Image (pull_request) Successful in 1m50s Details Preview Deploy / Deploy Preview Environment (pull_request) Successful in 43s Details AI Code Review / AI Code Review (pull_request) Successful in 2m6s Details PR Automation / Auto Merge on CI Green + Approved (pull_request) Successful in 15m21s Details CI/CD Pipeline / CI Gate (pull_request) 失败: CI/CD Pipeline / Validate - Code Quality (pull_request) [frontend-only] Details CI/CD Pipeline / Unit Tests (pull_request) Has been skipped Details CI/CD Pipeline / Build Production API Image (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Web Image (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Worker Image (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Frontend Unit Tests (pull_request) Failing after 19s Details ACR Cleanup / ACR Image Cleanup (pull_request_target) Has been cancelled Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / ACR Image Cleanup (pull_request) Has been skipped Details CI/CD Pipeline / Canary Release to Production (pull_request) Has been cancelled Details Preview Cleanup / Cleanup Preview Environment (pull_request) Successful in 16s Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details	2026-07-27 12:34:51 +08:00
xiaoxia	c853fa2ceb	refactor(api): 拆分 duplication.ts 为目录结构（types/duplication/index） CI/CD Pipeline / Check if frontend-only change (pull_request) Successful in 15s Details CI/CD Pipeline / PR Build Worker Image (pull_request) Successful in 23s Details CI/CD Pipeline / Build Staging API Image (pull_request) Has been skipped Details CI/CD Pipeline / Build Staging Web Image (pull_request) Has been skipped Details CI/CD Pipeline / Build Staging Worker Image (pull_request) Has been skipped Details CI/CD Pipeline / Validate - Type Check (mypy) (pull_request) Successful in 1m5s Details CI/CD Pipeline / Validate - Migration (alembic) (pull_request) Successful in 1m27s Details CI/CD Pipeline / Frontend Lint (pull_request) Failing after 1m31s Details PR Automation / Auto Approve on CI Green (pull_request) Successful in 1m4s Details CI/CD Pipeline / Validate - Code Quality (pull_request) Failing after 2m23s Details PR Automation / Auto Merge on CI Green + Approved (pull_request) Successful in 54s Details Preview Deploy / Deploy Preview Environment (pull_request) Failing after 46s Details CI/CD Pipeline / PR Build Web Image (pull_request) Failing after 2m36s Details AI Code Review / AI Code Review (pull_request) Successful in 2m25s Details CI/CD Pipeline / PR Build API Image (pull_request) Successful in 6m15s Details CI/CD Pipeline / Unit Tests (pull_request) Has been skipped Details CI/CD Pipeline / Build Production API Image (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Web Image (pull_request) Has been skipped Details CI/CD Pipeline / Build Production Worker Image (pull_request) Has been skipped Details CI/CD Pipeline / Frontend Unit Tests (pull_request) Failing after 20s Details CI/CD Pipeline / Deploy Staging (Watchtower auto-deploy) (pull_request) Has been skipped Details CI/CD Pipeline / Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / Deploy Production (pull_request) Has been skipped Details CI/CD Pipeline / Staging E2E Tests (pull_request) Has been skipped Details CI/CD Pipeline / Staging API Integration Tests (pull_request) Has been skipped Details CI/CD Pipeline / ACR Image Cleanup (pull_request) Has been skipped Details CI/CD Pipeline / Canary Release to Production (pull_request) Has been cancelled Details CI/CD Pipeline / Production Browser E2E (pull_request) Has been skipped Details 将 99 行的 duplication.ts 拆分为目录化结构： - types.ts: 类型定义（查重记录/片段/详情/响应） - duplication.ts: 全部 5 个 API 函数 - index.ts: 统一入口 re-export，保持 @/api/duplication 路径向后兼容	2026-07-26 17:17:09 +08:00