fix: 更新 test_1280 ASR跳过测试以匹配 PR #1294 的 voice_id 条件变更

从 main 分支 PR #1308 手动适配到 develop 分支，保留 develop 现有功能：

Schema 层：
- 新增 ConfirmGenerationRequest schema
- CreateGenerationTaskRequest 增加 6 个新字段（is_preview, source_task_id, output_width, output_height, cover_url, custom_title）
- GenerationTaskResponse 增加对应字段

Domain 层：
- GenerationTask 实体增加 source_task_id, output_width, output_height, cover_url, custom_title 字段
- create() 工厂方法增加对应参数

Application 层：
- CreateGenerationTaskCommand 增加对应字段
- UseCase 执行时传递新字段

DB 层：
- GenerationTaskModel 增加 5 个新列（is_preview 已存在于 develop）
- 仓储 _to_domain/create/update 映射更新

API 路由：
- 新增 POST /tasks/{task_id}/confirm 端点
- 使用 safe_enqueue_generation_task 适配 develop 任务入队机制
- 更新 _to_generation_task_response 和 retry 端点

Worker 层：
- _load_task_info 返回新字段
- generate_video 支持动态分辨率（output_width/output_height 覆盖默认分辨率）

Alembic 迁移 054：
- generation_tasks 表增加 source_task_id, output_width, output_height, cover_url, custom_title 列

单元测试：
- tests/unit/test_confirm_generation.py（7 个测试用例全部通过）
- 适配 develop 的 safe_enqueue_generation_task 入队机制

.gitea/workflows/ci-pipeline.yml

@@ -21,9 +21,8 @@ on:
 permissions:
   contents: read
 concurrency:
-  group: ci-pipeline-${{ gitea.event_name }}-${{ gitea.ref }}
-  # PR事件取消进行中的旧run，push事件不取消（确保完整CI跑完）
-  cancel-in-progress: ${{ gitea.event_name == 'pull_request' }}
+  group: ci-pipeline-${{ gitea.ref }}
+  cancel-in-progress: true
 jobs:
   check-frontend-only:
     name: Check if frontend-only change
@@ -38,7 +37,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Check changed files
       id: check
       shell: bash
@@ -91,7 +90,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -181,7 +180,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -260,7 +259,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -341,7 +340,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -412,7 +411,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -466,7 +465,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -528,7 +527,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -612,7 +611,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -796,7 +795,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -928,7 +927,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -1080,33 +1079,14 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
     - name: Run Playwright E2E on staging
       shell: bash
       run: |
-        set -eu
-        # DooD模式下不能用-v挂载（宿主机路径与CI容器路径不一致）
-        # 改用 docker create + docker cp 方式把代码拷进容器
-        CONTAINER_NAME="staging-e2e-$$"
-        # 强制清理可能残留的同名容器（上一次异常退出时未清理）
-        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
+        bash scripts/ci/run_staging_tests.sh e2e
 
     - name: Job duration summary
       if: always()
@@ -1146,29 +1126,14 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
     - name: Run API integration tests on staging
       shell: bash
       run: |
-        set -eu
-        # DooD模式下不能用-v挂载（宿主机路径与CI容器路径不一致）
-        # 改用 docker create + docker cp 方式把代码拷进容器
-        CONTAINER_NAME="staging-api-tests-$$"
-        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
+        bash scripts/ci/run_staging_tests.sh api
 
     - name: Job duration summary
       if: always()
@@ -1235,7 +1200,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -1359,7 +1324,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -1490,14 +1455,13 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
     - name: Run production browser E2E
-      shell: sh
+      shell: bash
       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 \
@@ -1506,7 +1470,7 @@ jobs:
           -v "$PWD:/workspace" \
           -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 e2e/core-titles.spec.ts'
+          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'
 
     - name: Job duration summary
       if: always()
@@ -1550,7 +1514,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -1609,7 +1573,7 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
       run: |
-        curl -sH "Authorization: token $GITHUB_TOKEN"           "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}"           | bash
+        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: Record job start time
       shell: sh
       run: bash scripts/ci/step_timer_start.sh
@@ -1698,9 +1662,8 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ github.token }}
         run: |
-          curl -sH "Authorization: token $GITHUB_TOKEN" \
-            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/raw/scripts/ci/step_checkout.sh?ref=${GITHUB_SHA}" \
-            | bash
+          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
@@ -1736,7 +1699,7 @@ jobs:
           # 查询 AI Code Review 状态（跨workflow，读commit status）
           AI_REVIEW_STATUS="pending"
           AI_REVIEW_DESC=""
-          STATUS_JSON=$(curl -sH "Authorization: token $GITHUB_TOKEN" \
+          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 "
@@ -1777,6 +1740,7 @@ jobs:
           # 后端检查
           REQUIRED_BACKEND=(
             "unit-tests:$RESULT_UNIT_TESTS"
+            "integration-tests:$RESULT_INTEGRATION"
           )
 
           # 前端检查
@@ -1862,4 +1826,4 @@ jobs:
           [ "${{ 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
+          python3 scripts/ci/ci_trace_report.py --service xiaoxia-saas-ci --status $STATUS --start-time "$START_TIME" || true

.gitea/workflows/preview-deploy.yml

@@ -95,12 +95,9 @@ 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 --no-audit --no-fund && break
+          npm ci --registry=https://registry.npmmirror.com --no-audit --no-fund && break
           echo "npm install failed, retry $i/3..."
           [ $i -eq 3 ] && exit 1
           rm -rf node_modules
@@ -109,12 +106,12 @@ jobs:
 
         # TypeScript check
         echo "=== TypeScript check ==="
-        npx --no-install tsc --noEmit
+        ./node_modules/.bin/tsc --noEmit
 
         # Vite build
         echo "=== Vite build ==="
         export VITE_API_URL=https://staging-api.xiaoxiajianji.com
-        npx --no-install vite build
+        ./node_modules/.bin/vite build
 
         echo "=== Build completed ==="
         ls -la dist/

1197_preview_generation_proposal.md

@@ -0,0 +1,222 @@
+---
+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 生成，请遵循相关法律法规及《人工智能生成合成内容标识办法》使用与传播。

1197_preview_generation_proposal_v2.md

@@ -0,0 +1,382 @@
+# #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 天（后端）

alembic/versions/053_generation_task_is_preview.py

@@ -0,0 +1,61 @@
+"""#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")

alembic/versions/054_confirm_gen_fields.py

@@ -0,0 +1,82 @@
+"""确认生成 API 改造：为 generation_tasks 表添加 source_task_id、output_width、output_height、cover_url、custom_title 字段
+
+Revision ID: 054_confirm_gen_fields
+Revises: 053_generation_task_is_preview
+Create Date: 2026-08-16
+
+Changes:
+1. generation_tasks 表新增 source_task_id（来源预览任务 ID，带索引）
+2. generation_tasks 表新增 output_width / output_height（动态输出分辨率）
+3. generation_tasks 表新增 cover_url / custom_title（自定义封面和标题）
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "054_confirm_gen_fields"
+down_revision = "053_generation_task_is_preview"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    is_pg = conn.dialect.name == "postgresql"
+
+    if is_pg:
+        # 幂等检查：source_task_id 列是否已存在
+        result = conn.execute(
+            sa.text(
+                "SELECT column_name FROM information_schema.columns "
+                "WHERE table_name = 'generation_tasks' AND column_name = 'source_task_id'"
+            )
+        )
+        if result.scalar() is not None:
+            return
+
+    # source_task_id
+    op.add_column(
+        "generation_tasks",
+        sa.Column("source_task_id", sa.String(32), nullable=False, server_default=""),
+    )
+
+    # output_width
+    op.add_column(
+        "generation_tasks",
+        sa.Column("output_width", sa.Integer, nullable=False, server_default=sa.text("1280")),
+    )
+
+    # output_height
+    op.add_column(
+        "generation_tasks",
+        sa.Column("output_height", sa.Integer, nullable=False, server_default=sa.text("720")),
+    )
+
+    # cover_url
+    op.add_column(
+        "generation_tasks",
+        sa.Column("cover_url", sa.String(1000), nullable=False, server_default=""),
+    )
+
+    # custom_title
+    op.add_column(
+        "generation_tasks",
+        sa.Column("custom_title", sa.String(500), nullable=False, server_default=""),
+    )
+
+    # 索引
+    op.create_index(
+        "ix_generation_tasks_source_task_id",
+        "generation_tasks",
+        ["source_task_id"],
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_generation_tasks_source_task_id", table_name="generation_tasks")
+    op.drop_column("generation_tasks", "custom_title")
+    op.drop_column("generation_tasks", "cover_url")
+    op.drop_column("generation_tasks", "output_height")
+    op.drop_column("generation_tasks", "output_width")
+    op.drop_column("generation_tasks", "source_task_id")

apps/api/app/api/router.py

@@ -7,6 +7,7 @@ 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
@@ -87,6 +88,11 @@ 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",

apps/api/app/api/routes/assets.py

@@ -19,6 +19,9 @@ from app.schemas.asset import (
     BatchTagRequest,
     CreateAssetRequest,
     ListAssetsResponse,
+    SmartMatchItem,
+    SmartMatchRequest,
+    SmartMatchResponse,
     UpdateAssetRequest,
     UpdateAssetReviewRequest,
 )
@@ -30,6 +33,7 @@ from packages.application import (
     CreateAssetUseCase,
 )
 from packages.domain import AssetStatus, ClassificationStatus
+from packages.domain.smart_match import smart_select_assets
 
 logger = logging.getLogger(__name__)
 
@@ -519,6 +523,51 @@ 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,
@@ -622,20 +671,28 @@ def create_asset(
     asset_library_repository: Any = Depends(get_asset_library_repository),
     project_repository: Any = Depends(get_project_repository),
 ) -> AssetResponse:
-    project = project_repository.find_by_id(request.project_id)
+    # 先获取素材库，用于推导 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)
     if project is None:
-        raise HTTPException(status_code=404, detail=f"Project {request.project_id} not found")
+        raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
     if not project.can_access(authenticated_user.user.id):
         raise HTTPException(status_code=403, detail="Access denied to 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")
+    # 确保 library 和 project 归属一致
+    if library.project_id != project_id:
+        raise HTTPException(status_code=400, detail="AssetLibrary does not belong to the specified project")
 
     use_case = CreateAssetUseCase(asset_repository)
     item = use_case.execute(
         CreateAssetCommand(
-            project_id=request.project_id,
+            project_id=project_id,
             library_id=request.library_id,
             name=request.name,
             storage_key=request.storage_key,

apps/api/app/api/routes/generation_preview.py

@@ -0,0 +1,403 @@
+"""预览生成路由 — 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)

apps/api/app/api/routes/generation_tasks.py

@@ -26,6 +26,7 @@ from app.schemas.generated_video import (
 )
 from app.schemas.generation_task import (
     BatchGenerationTaskResponse,
+    ConfirmGenerationRequest,
     CreateGenerationTaskRequest,
     GenerationTaskResponse,
     ListGenerationTasksResponse,
@@ -38,6 +39,7 @@ from packages.application import (
     GetGenerationTaskUseCase,
     ListGeneratedVideosByTaskUseCase,
 )
+from packages.domain.smart_match import smart_select_assets
 
 logger = logging.getLogger(__name__)
 
@@ -61,6 +63,12 @@ def _to_generation_task_response(task) -> GenerationTaskResponse:
         video_title=getattr(task, "video_title", ""),
         resolution=getattr(task, "resolution", ""),
         bgm_config=getattr(task, "bgm_config", {}) or {},
+        is_preview=getattr(task, "is_preview", False),
+        source_task_id=getattr(task, "source_task_id", ""),
+        output_width=getattr(task, "output_width", 1280),
+        output_height=getattr(task, "output_height", 720),
+        cover_url=getattr(task, "cover_url", ""),
+        custom_title=getattr(task, "custom_title", ""),
         logs=getattr(task, "logs", "[]"),
         status=task.status,
         progress=task.progress,
@@ -124,19 +132,11 @@ def _select_assets_from_library(
         return [a.id for a in selected]
 
     if mode == "smart":
-        # 智能匹配：按质量分降序 + 时长降序作为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]
+        # 智能匹配：统一使用 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]
 
     # 默认 all 模式：返回全部 ready 视频素材
     return [a.id for a in ready_video_assets]
@@ -271,13 +271,19 @@ 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=request.strategy_id,
+                    strategy_id=effective_strategy_id,
                     voice_library_id=request.voice_library_id,
                     template_id=request.template_id,
                     asset_ids=resolved_asset_ids,
@@ -292,6 +298,12 @@ def create_generation_task(
                     bgm_config=request.bgm_config,
                     auto_retry_enabled=request.auto_retry_enabled,
                     auto_retry_max=request.auto_retry_max,
+                    is_preview=request.is_preview,
+                    source_task_id=request.source_task_id,
+                    output_width=request.output_width,
+                    output_height=request.output_height,
+                    cover_url=request.cover_url,
+                    custom_title=request.custom_title,
                 )
             )
             try:
@@ -332,6 +344,83 @@ def create_generation_task(
     return BatchGenerationTaskResponse(items=items, total=len(items))
 
 
+@router.post("/tasks/{task_id}/confirm", response_model=BatchGenerationTaskResponse)
+def confirm_generation(
+    task_id: str,
+    request: ConfirmGenerationRequest,
+    authenticated_user: AuthenticatedUser = Depends(get_current_user),
+    generation_task_repository: Any = Depends(get_generation_task_repository),
+    project_repository: Any = Depends(get_project_repository),
+) -> BatchGenerationTaskResponse:
+    """确认生成 — 基于预览任务创建正式生成任务。
+
+    查找预览任务，复制其配置，创建新的正式生成任务（is_preview=False），
+    使用高分辨率，复用 worker.generate_video 渲染路径。
+    """
+    # 1. 查找源预览任务
+    source_task = generation_task_repository.get(task_id)
+    if source_task is None:
+        raise HTTPException(status_code=404, detail=f"Preview task {task_id} not found")
+
+    # 2. 权限检查
+    if source_task.created_by_user_id and source_task.created_by_user_id != authenticated_user.user.id:
+        raise HTTPException(status_code=403, detail="Access denied to this task")
+    if source_task.project_id:
+        check_project_access(source_task.project_id, authenticated_user.user.id, project_repository)
+
+    # 3. 创建正式生成任务，复制预览任务的配置
+    use_case = CreateGenerationTaskUseCase(generation_task_repository)
+    new_task = use_case.execute(
+        CreateGenerationTaskCommand(
+            project_id=source_task.project_id,
+            asset_library_id=source_task.asset_library_id,
+            strategy_id=source_task.strategy_id,
+            voice_library_id=source_task.voice_library_id,
+            template_id=source_task.template_id,
+            asset_ids=source_task.asset_ids,
+            title_ids=source_task.title_ids,
+            voice_ids=source_task.voice_ids,
+            created_by_user_id=authenticated_user.user.id,
+            source_edit_plan_id=source_task.source_edit_plan_id or "",
+            asset_select_mode=source_task.asset_select_mode,
+            video_title=getattr(source_task, "video_title", ""),
+            resolution=getattr(source_task, "resolution", ""),
+            is_preview=False,
+            source_task_id=task_id,
+            output_width=request.output_width,
+            output_height=request.output_height,
+            cover_url=request.cover_url,
+            custom_title=request.custom_title,
+        )
+    )
+
+    # 4. 调度 worker.generate_video（同一条渲染路径）
+    try:
+        if not safe_enqueue_generation_task(
+            new_task,
+            generation_task_repository,
+            user_id=authenticated_user.user.id,
+            log_prefix="[确认生成]",
+            log_task_status=True,
+        ):
+            logger.warning("[确认生成] 入队失败: task_id=%s", new_task.id)
+    except UserPendingLimitExceeded:
+        raise HTTPException(
+            status_code=429,
+            detail="您的待处理任务过多，请等待完成后再提交",
+        ) from None
+    except GlobalQueueFull:
+        raise HTTPException(
+            status_code=503,
+            detail="系统繁忙，请稍后再试",
+        ) from None
+
+    return BatchGenerationTaskResponse(
+        items=[_to_generation_task_response(new_task)],
+        total=1,
+    )
+
+
 @router.get("/tasks", response_model=ListGenerationTasksResponse)
 def list_generation_tasks(
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
@@ -429,6 +518,12 @@ def retry_generation_task(
             asset_select_mode=getattr(task, "asset_select_mode", ""),
             video_title=getattr(task, "video_title", ""),
             resolution=getattr(task, "resolution", ""),
+            is_preview=getattr(task, "is_preview", False),
+            source_task_id=getattr(task, "source_task_id", ""),
+            output_width=getattr(task, "output_width", 1280),
+            output_height=getattr(task, "output_height", 720),
+            cover_url=getattr(task, "cover_url", ""),
+            custom_title=getattr(task, "custom_title", ""),
         )
     )
     try:

apps/api/app/api/routes/templates_editor/_fallback.py

@@ -98,6 +98,15 @@ 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 个指定素材",
@@ -105,11 +114,42 @@ 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)
-            svc.assign_asset(clip.id, config_asset_ids[asset_idx])
-        logger.info("模板编辑器自动兜底3: plan=%s 素材分配完成", plan_id)
-        clips_without_asset = []
+            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,
+        )
 
     return clips_without_asset
 

apps/api/app/api/routes/templates_editor/ai_features.py

@@ -24,6 +24,94 @@ 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,
@@ -46,12 +134,16 @@ 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:

apps/api/app/api/routes/templates_editor/cover.py

@@ -184,6 +184,29 @@ 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(
@@ -191,6 +214,7 @@ 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 {}

apps/api/app/api/routes/templates_editor/generation.py

@@ -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:

apps/api/app/api/routes/voice_clones.py

@@ -11,6 +11,7 @@ from app.dependencies import get_cosyvoice_service, get_voice_clone_profile_repo
 from app.schemas.voice_clone import (
     CreateVoiceCloneRequest,
     ListVoiceCloneResponse,
+    VoiceClonePreviewResponse,
     VoiceCloneProfileResponse,
     VoiceCloneStatusResponse,
 )
@@ -19,7 +20,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 CosyVoiceService
+from packages.application.cosyvoice_service import CosyVoiceError, CosyVoiceService
 from packages.application.voice_clone.use_cases import (
     DeleteVoiceCloneUseCase,
     GetVoiceCloneStatusUseCase,
@@ -36,6 +37,13 @@ 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（可能是外部地址），不做预签名转换
@@ -223,3 +231,78 @@ 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,
+    )

apps/api/app/api/routes/voices.py

@@ -5,6 +5,8 @@
 
 from __future__ import annotations
 
+import logging
+import time
 from typing import Literal, Optional
 
 from app.api.routes._helpers import get_user_plan
@@ -42,6 +44,7 @@ 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)
@@ -51,6 +54,65 @@ 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)
 
@@ -118,8 +180,16 @@ def _to_unified_response(item, profile_id_map: dict | None = None, sign_url=None
     )
 
 
-def _preset_to_unified_response(preset) -> UnifiedVoiceItemResponse:
-    """将预置音色转换为统一响应格式。"""
+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]
     return UnifiedVoiceItemResponse(
         id=preset.voice_id,
         type="preset",
@@ -129,11 +199,40 @@ def _preset_to_unified_response(preset) -> UnifiedVoiceItemResponse:
         language=preset.language,
         voice_id=preset.voice_id,
         voice_provider="cosyvoice",
-        preview_url=preset.preview_url,
+        preview_url=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,
+    )
+
+
 # ==================== 统一配音列表（预置 + 克隆）====================
 
 
@@ -150,6 +249,7 @@ 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:
     """获取配音列表（预置音色 + 用户克隆音色）。
 
@@ -165,19 +265,30 @@ 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:
-        preset_items = [_preset_to_unified_response(p) for p in PRESET_VOICES]
+        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_count = len(preset_items)
 
-    # 获取克隆音色
+    # 获取克隆音色（从 voice_clone_profile 读取，ready 状态的克隆音色）
     if has_clone:
-        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]
+        # 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]
 
     # 组装结果
     if type == "preset":
@@ -204,11 +315,15 @@ def list_voices_unified(
 
 
 @router.get("/presets", response_model=PresetVoiceListResponse)
-def list_preset_voices() -> PresetVoiceListResponse:
+def list_preset_voices(
+    cosyvoice: CosyVoiceService = Depends(get_cosyvoice_service),
+) -> PresetVoiceListResponse:
     """获取预置音色列表。
 
     不需要认证，返回所有系统预置的 CosyVoice 音色。
+    preview_url 通过 CosyVoice 动态生成，不依赖硬编码的过期 URL。
     """
+    preview_url_map = _resolve_all_preset_preview_urls(PRESET_VOICES, cosyvoice)
     items = [
         PresetVoiceItemResponse(
             voice_id=p.voice_id,
@@ -216,7 +331,7 @@ def list_preset_voices() -> PresetVoiceListResponse:
             description=p.description,
             gender=p.gender,
             language=p.language,
-            preview_url=p.preview_url,
+            preview_url=preview_url_map.get(p.voice_id, p.preview_url),
             tags=p.tags or [],
         )
         for p in PRESET_VOICES
@@ -236,8 +351,6 @@ 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}")

apps/api/app/schemas/asset.py

@@ -2,7 +2,7 @@ from pydantic import BaseModel, Field
 
 
 class CreateAssetRequest(BaseModel):
-    project_id: str = Field(..., min_length=1)
+    project_id: str | None = Field(default=None, description="可选，不传时从 library.project_id 自动推导")
     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,3 +101,30 @@ 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="参与评分的候选素材总数")

apps/api/app/schemas/generation_task.py

@@ -1,8 +1,18 @@
 import json
+from datetime import datetime
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
 
+class ConfirmGenerationRequest(BaseModel):
+    """确认生成请求体 — 基于预览任务创建正式生成任务"""
+
+    output_width: int = Field(default=1080, description="输出视频宽度")
+    output_height: int = Field(default=1920, description="输出视频高度")
+    cover_url: str = Field(default="", description="自定义封面图片 URL")
+    custom_title: str = Field(default="", description="自定义视频标题")
+
+
 class CreateGenerationTaskRequest(BaseModel):
     """创建生成任务请求。
 
@@ -56,6 +66,13 @@ class CreateGenerationTaskRequest(BaseModel):
         default_factory=dict,
         description="自定义BGM配置，覆盖模板BGM设置。支持 enabled/source/asset_id/preset_id/audio_url/volume 等字段",
     )
+    # ── 预览 / 确认生成 ──
+    is_preview: bool = Field(default=False, description="是否为预览任务")
+    source_task_id: str = Field(default="", description="来源预览任务 ID（确认生成时传入）")
+    output_width: int = Field(default=1280, description="输出视频宽度")
+    output_height: int = Field(default=720, description="输出视频高度")
+    cover_url: str = Field(default="", description="封面图片 URL")
+    custom_title: str = Field(default="", description="自定义视频标题")
 
     @model_validator(mode="after")
     def _check_at_least_one_mode(self) -> "CreateGenerationTaskRequest":
@@ -86,6 +103,12 @@ class GenerationTaskResponse(BaseModel):
     video_title: str = ""
     resolution: str = ""
     bgm_config: dict = Field(default_factory=dict)
+    is_preview: bool = False
+    source_task_id: str = ""
+    output_width: int = 1280
+    output_height: int = 720
+    cover_url: str = ""
+    custom_title: str = ""
     status: str
     progress: float
     result_count: int
@@ -122,3 +145,68 @@ 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

apps/api/app/schemas/voice_clone.py

@@ -63,3 +63,25 @@ 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
+    """文件大小（字节）"""

apps/api/app/services/edit_plan_service.py

@@ -571,6 +571,10 @@ class EditPlanService:
     def can_generate(self, plan_id: str) -> tuple[bool, str]:
         """检查是否可以触发渲染
 
+        包含最后一道防线的自动修复：
+        - 如果 clips 存在但都没有 asset_id，且 config.asset_ids 非空，
+          直接在内部执行素材分配，不再依赖前置 fallback 链路。
+
         Returns:
             tuple: (can_generate, reason)
         """
@@ -585,10 +589,69 @@ 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
+        """将已分配素材的 pending 片段标记为 ready
+
+        只标记同时满足以下条件的片段：
+        - status == PENDING
+        - asset_id 非空（已分配素材）
 
         Returns:
             int: 标记的片段数量
@@ -599,10 +662,16 @@ class EditPlanService:
         )
         count = 0
         for clip in clips:
-            clip.mark_ready()
-            self._clip_repo.update(clip)
-            count += 1
-        logger.info("标记片段就绪: plan_id=%s count=%d", plan_id, count)
+            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),
+        )
         return count
 
     def update_plan_config(self, plan_id: str, config_updates: Dict[str, Any]) -> EditPlan:

apps/api/app/services/plan_generator_service.py

@@ -49,9 +49,10 @@ class PlanGeneratorService:
     基于模板 + 素材，自动生成 EditPlan 及 EditPlanClip 列表。
     """
 
-    def __init__(self, db: Session) -> None:
+    def __init__(self, db: Session, asset_repo=None) -> None:
         self._plan_repo = SQLAlchemyEditPlanRepository(db)
         self._clip_repo = SQLAlchemyEditPlanClipRepository(db)
+        self._asset_repo = asset_repo
 
     # ── 公开接口 ─────────────────────────────────────────────────────────────
 
@@ -64,6 +65,7 @@ class PlanGeneratorService:
         project_id: str = "",
         created_by_user_id: str = "",
         name: str = "",
+        random_preview: bool = False,
     ) -> dict[str, Any]:
         """基于模板+素材生成剪辑计划
 
@@ -74,6 +76,7 @@ class PlanGeneratorService:
             project_id: 所属项目 ID
             created_by_user_id: 创建者用户 ID
             name: 计划名称（为空则自动取模板名）
+            random_preview: 是否启用随机预览模式（随机选素材+随机截取片段）
 
         Returns:
             dict: {"plan": EditPlan, "clips": List[EditPlanClip]}
@@ -115,7 +118,17 @@ class PlanGeneratorService:
 
         # 4. 按 editing_mode 分配素材
         if asset_ids:
-            self._distribute_assets(clips, asset_ids, editing_mode)
+            # 如果是随机预览模式，获取素材时长信息
+            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,
+            )
 
         # 5. 持久化所有 clips 并计算总时长
         created_clips: List[EditPlanClip] = []
@@ -199,9 +212,34 @@ 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)
+        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

apps/api/app/services/smart_asset_selector.py

@@ -1,164 +0,0 @@
-"""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)

apps/web/e2e/core-generation.spec.ts

@@ -196,24 +196,33 @@ test.describe("Core generation flow", () => {
     await materialLabel.locator("input[type='checkbox']").check()
     await page.getByRole("button", { name: "下一步" }).click()
 
-    // Step 3: preview (纯展示页，AI 智能匹配预览)
-    await expect(page.getByRole("heading", { name: /生成预览/ })).toBeVisible()
+    // Step 3: voice (可选步骤，新注册用户无配音素材，直接跳过)
+    await expect(page.getByRole("heading", { name: /选择配音/ })).toBeVisible({ timeout: 15000 })
     await page.getByRole("button", { name: "下一步" }).click()
 
-    // Step 4: title
-    await expect(page.getByRole("heading", { name: /选择标题/ })).toBeVisible()
+    // 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()
+      // 等待输入框出现（条件渲染，需要等待 DOM 更新）
+      await expect(page.getByPlaceholder("输入或从标题库选择…")).toBeVisible({ timeout: 5000 })
+    }
     const titleText = `E2E Test ${suffix}`
-    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.getByPlaceholder("输入或从标题库选择…").fill(titleText)
     await page.getByRole("button", { name: "下一步" }).click()
 
     // Step 6: cover (默认 AI 智能选帧模式，直接下一步)
-    await expect(page.getByRole("heading", { name: /选择封面/ })).toBeVisible()
+    await expect(page.getByRole("heading", { name: /选择封面/ })).toBeVisible({ timeout: 15000 })
     await page.getByRole("button", { name: "下一步" }).click()
 
     // Step 7: confirm and generate

apps/web/package-lock.json

@@ -1847,7 +1847,7 @@
     },
     "node_modules/@testing-library/dom": {
       "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+      "resolved": "https://registry.npmmirror.com/@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.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "resolved": "https://registry.npmmirror.com/@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.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "resolved": "https://registry.npmmirror.com/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
       "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
       "dev": true,
       "license": "MIT",
@@ -4028,18 +4028,6 @@
         "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",
@@ -4468,7 +4456,7 @@
     },
     "node_modules/lz-string": {
       "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+      "resolved": "https://registry.npmmirror.com/lz-string/-/lz-string-1.5.0.tgz",
       "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
       "dev": true,
       "license": "MIT",
@@ -5010,7 +4998,7 @@
     },
     "node_modules/pretty-format": {
       "version": "27.5.1",
-      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+      "resolved": "https://registry.npmmirror.com/pretty-format/-/pretty-format-27.5.1.tgz",
       "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
       "dev": true,
       "license": "MIT",
@@ -5026,7 +5014,7 @@
     },
     "node_modules/pretty-format/node_modules/ansi-styles": {
       "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-5.2.0.tgz",
       "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
       "dev": true,
       "license": "MIT",
@@ -5038,14 +5026,6 @@
         "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",
@@ -5743,6 +5723,14 @@
         "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",

apps/web/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: set this to true or false

apps/web/src/api/assets/assets.ts

@@ -49,6 +49,17 @@ export const getAssetsByKind = async (
   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

apps/web/src/api/assets/index.ts

@@ -29,10 +29,11 @@ export {
   deleteAssetLibrary,
 } from "./libraries"
 
-// 素材 CRUD
+// 素材 CRUD + 智能匹配
 export {
   getAssets,
   getAssetsByKind,
+  smartMatchAssets,
   createAsset,
   updateAsset,
   updateAssetReviewStatus,

apps/web/src/api/auth.ts

@@ -1,188 +0,0 @@
-/**
- * 认证相关 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
-}

apps/web/src/api/auth/contact.ts

@@ -0,0 +1,20 @@
+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
+}

apps/web/src/api/auth/currentUser.ts

@@ -0,0 +1,11 @@
+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)
+}

apps/web/src/api/auth/email.ts

@@ -0,0 +1,9 @@
+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
+}

apps/web/src/api/auth/index.ts

@@ -0,0 +1,39 @@
+/**
+ * 认证相关 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"

apps/web/src/api/auth/login.ts

@@ -0,0 +1,37 @@
+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")
+}

apps/web/src/api/auth/password.ts

@@ -0,0 +1,23 @@
+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
+}

apps/web/src/api/auth/types.ts

@@ -0,0 +1,82 @@
+/**
+ * 认证相关类型定义
+ */
+
+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
+}

apps/web/src/api/auth/user.ts

@@ -0,0 +1,20 @@
+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,
+  }
+}

apps/web/src/api/auth/wechat.ts

@@ -0,0 +1,21 @@
+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
+}

apps/web/src/api/client.ts

@@ -57,7 +57,21 @@ apiClient.interceptors.response.use(
     }
 
     // 401 → 尝试刷新 Token
-    if (error.response?.status === 401 && originalRequest && !originalRequest._retry) {
+    // 排除 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
+    ) {
       const refreshToken = useAuthStore.getState().refreshToken
 
       // 无 refresh_token → 直接登出

apps/web/src/api/generation/index.ts

@@ -0,0 +1,8 @@
+export type {
+  PreviewStatus,
+  CreatePreviewRequest,
+  CreatePreviewResponse,
+  PreviewTaskResponse,
+} from "./types"
+
+export { createPreview, getPreviewStatus } from "./preview"

apps/web/src/api/generation/preview.ts

@@ -0,0 +1,16 @@
+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
+}

apps/web/src/api/generation/types.ts

@@ -0,0 +1,47 @@
+/** 预览任务状态 */
+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
+}

apps/web/src/api/template-editor/mediaAssets.ts

@@ -18,6 +18,7 @@ const mapAssetToMediaAsset = (asset: AssetItem): MediaAsset => {
     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,

apps/web/src/api/template-editor/types.ts

@@ -424,6 +424,8 @@ export interface MediaAsset {
   id: string
   name: string
   type: "video" | "image" | "audio"
+  /** 源文件 URL（视频/原图），用于悬浮预览播放 */
+  source_url?: string
   /** 缩略图 URL */
   thumbnail_url?: string
   /** 时长（秒），仅 video/audio */

apps/web/src/api/voice-clone/clones.ts

@@ -11,6 +11,7 @@ import type {
   VoiceCloneListParams,
   ListVoiceCloneResponse,
   VoiceCloneStatusResponse,
+  VoiceClonePreviewResponse,
 } from "./types"
 
 /** 获取克隆音色列表（返回前端兼容数组） */
@@ -85,3 +86,17 @@ export const retryVoiceClone = async (id: string): Promise<VoiceCloneProfile> =>
   const response = await apiClient.post<VoiceCloneProfile>(`/voice-clones/${id}/retry`)
   return response.data
 }
+
+/** 获取克隆音色试听音频（实时 TTS 合成） */
+export const getVoiceClonePreview = async (
+  cloneId: string,
+  text?: string,
+): Promise<VoiceClonePreviewResponse> => {
+  const searchParams = new URLSearchParams()
+  if (text) searchParams.set("text", text)
+  const qs = searchParams.toString()
+  const response = await apiClient.get<VoiceClonePreviewResponse>(
+    `/voice-clones/${cloneId}/preview${qs ? `?${qs}` : ""}`,
+  )
+  return response.data
+}

apps/web/src/api/voice-clone/index.ts

@@ -14,6 +14,7 @@ export type {
   VoiceCloneStatusResponse,
   CreateVoiceCloneRequestFull,
   VoiceCloneListParams,
+  VoiceClonePreviewResponse,
 } from "./types"
 
 // 工具函数
@@ -29,4 +30,5 @@ export {
   updateVoiceClone,
   getVoiceCloneStatus,
   retryVoiceClone,
+  getVoiceClonePreview,
 } from "./clones"

apps/web/src/api/voice-clone/types.ts

@@ -90,3 +90,24 @@ export interface VoiceCloneListParams {
   skip?: number
   limit?: number
 }
+
+/** 克隆音色试听响应 */
+export interface VoiceClonePreviewResponse {
+  clone_id: string
+  /** 音色克隆档案 ID */
+
+  voice_id: string
+  /** CosyVoice 音色 ID */
+
+  audio_url: string
+  /** 试听音频 URL */
+
+  text: string
+  /** 试听文本 */
+
+  duration: number
+  /** 音频时长（秒） */
+
+  file_size: number
+  /** 文件大小（字节） */
+}

apps/web/src/components/asset-selector/AssetSelector.css

@@ -456,7 +456,8 @@
   margin-bottom: 8px;
 }
 
-.as-preview-overlay-thumb img {
+.as-preview-overlay-thumb img,
+.as-preview-overlay-thumb video {
   width: 100%;
   height: 100%;
   object-fit: cover;

apps/web/src/components/asset-selector/PreviewOverlay.tsx

@@ -12,7 +12,16 @@ const PreviewOverlay: React.FC<PreviewOverlayProps> = ({ asset, position }) => {
   return (
     <div className="as-preview-overlay" style={{ left: position.x, top: position.y }}>
       <div className="as-preview-overlay-thumb">
-        {asset.thumbnail_url ? (
+        {asset.type === "video" && asset.source_url ? (
+          <video
+            src={asset.source_url}
+            autoPlay
+            muted
+            loop
+            playsInline
+            poster={asset.thumbnail_url}
+          />
+        ) : asset.thumbnail_url ? (
           <img src={asset.thumbnail_url} alt={asset.name} />
         ) : (
           <span className="as-preview-overlay-thumb-icon">{MATERIAL_TYPE_ICONS[asset.type]}</span>

apps/web/src/components/auth/BindContactModal/hooks/useBindContactForm.ts

@@ -0,0 +1,97 @@
+import { useState, useEffect } from "react"
+import { Form, message } from "antd"
+import { sendVerificationCode, bindContact, type BindContactResponse } from "@/api/auth"
+import { useCountdown } from "./useCountdown"
+
+type ContactType = "email" | "phone"
+
+interface UseBindContactFormOptions {
+  open: boolean
+  onSuccess?: (user: BindContactResponse["user"]) => void
+  onCancel?: () => void
+}
+
+/**
+ * 绑定联系方式表单 Hook
+ * 封装表单状态、验证码发送、提交绑定等业务逻辑
+ */
+export const useBindContactForm = ({ open, onSuccess }: UseBindContactFormOptions) => {
+  const [activeTab, setActiveTab] = useState<ContactType>("email")
+  const [form] = Form.useForm()
+  const [loading, setLoading] = useState(false)
+  const [codeLoading, setCodeLoading] = useState(false)
+  const { countdown, isRunning, start: startCountdown, reset: resetCountdown } = useCountdown(60)
+
+  /* ── 打开时重置表单 ── */
+  useEffect(() => {
+    if (open) {
+      form.resetFields()
+      resetCountdown()
+    }
+  }, [open, form, resetCountdown])
+
+  /* ── 发送验证码 ── */
+  const handleSendCode = async () => {
+    try {
+      const fieldName = activeTab === "email" ? "email" : "phone"
+      const value = form.getFieldValue(fieldName)
+      if (!value) {
+        message.warning(activeTab === "email" ? "请输入邮箱" : "请输入手机号")
+        return
+      }
+      setCodeLoading(true)
+      await sendVerificationCode({
+        target: activeTab,
+        value,
+        purpose: "bind",
+      })
+      message.success("验证码已发送")
+      startCountdown()
+    } catch {
+      // error handled by interceptor
+    } finally {
+      setCodeLoading(false)
+    }
+  }
+
+  /* ── 提交绑定 ── */
+  const handleSubmit = async () => {
+    // 1. 表单验证（失败时 Ant Design Form 会自动展示错误信息）
+    let values
+    try {
+      values = await form.validateFields()
+    } catch {
+      return
+    }
+
+    // 2. 调用绑定接口
+    setLoading(true)
+    try {
+      const payload =
+        activeTab === "email"
+          ? { email: values.email, email_code: values.email_code }
+          : { phone: values.phone, phone_code: values.phone_code }
+
+      const result = await bindContact(payload)
+
+      message.success("绑定成功")
+      onSuccess?.(result.user)
+    } catch {
+      // API 错误由全局拦截器统一处理提示
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return {
+    activeTab,
+    setActiveTab,
+    form,
+    loading,
+    codeLoading,
+    countdown,
+    codeDisabled: isRunning,
+    handleSendCode,
+    handleSubmit,
+  }
+}

apps/web/src/components/auth/BindContactModal/hooks/useCountdown.ts

@@ -0,0 +1,39 @@
+import { useState, useEffect, useRef, useCallback } from "react"
+
+/**
+ * 倒计时 Hook
+ * 用于验证码发送等场景的倒计时控制
+ */
+export const useCountdown = (initialSeconds = 60) => {
+  const [countdown, setCountdown] = useState(0)
+  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null)
+
+  useEffect(() => {
+    if (countdown > 0) {
+      timerRef.current = setInterval(() => {
+        setCountdown((prev) => prev - 1)
+      }, 1000)
+    } else if (timerRef.current) {
+      clearInterval(timerRef.current)
+      timerRef.current = null
+    }
+    return () => {
+      if (timerRef.current) clearInterval(timerRef.current)
+    }
+  }, [countdown])
+
+  const start = useCallback(() => {
+    setCountdown(initialSeconds)
+  }, [initialSeconds])
+
+  const reset = useCallback(() => {
+    setCountdown(0)
+  }, [])
+
+  return {
+    countdown,
+    isRunning: countdown > 0,
+    start,
+    reset,
+  }
+}

apps/web/src/components/auth/BindContactModal/index.tsx

@@ -1,84 +1,20 @@
-import React, { useState, useEffect, useRef } from "react"
-import { Modal, Tabs, Form, Input, Button, message } from "antd"
-import { sendVerificationCode, bindContact, type BindContactResponse } from "@/api/auth"
-
-interface BindContactModalProps {
-  open: boolean
-  onSuccess?: (user: BindContactResponse["user"]) => void
-  onCancel?: () => void
-}
+import React from "react"
+import { Modal, Tabs, Form, Input, Button } from "antd"
+import { useBindContactForm } from "./hooks/useBindContactForm"
+import type { BindContactModalProps } from "./types"
 
 const BindContactModal: React.FC<BindContactModalProps> = ({ open, onSuccess, onCancel }) => {
-  const [activeTab, setActiveTab] = useState<"email" | "phone">("email")
-  const [form] = Form.useForm()
-  const [loading, setLoading] = useState(false)
-  const [codeLoading, setCodeLoading] = useState(false)
-  const [countdown, setCountdown] = useState(0)
-  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null)
-
-  useEffect(() => {
-    if (countdown > 0) {
-      timerRef.current = setInterval(() => {
-        setCountdown((prev) => prev - 1)
-      }, 1000)
-    } else if (timerRef.current) {
-      clearInterval(timerRef.current)
-      timerRef.current = null
-    }
-    return () => {
-      if (timerRef.current) clearInterval(timerRef.current)
-    }
-  }, [countdown])
-
-  useEffect(() => {
-    if (open) {
-      form.resetFields()
-      setCountdown(0)
-    }
-  }, [open, form])
-
-  const handleSendCode = async () => {
-    try {
-      const value = form.getFieldValue(activeTab === "email" ? "email" : "phone")
-      if (!value) {
-        message.warning(activeTab === "email" ? "请输入邮箱" : "请输入手机号")
-        return
-      }
-      setCodeLoading(true)
-      await sendVerificationCode({
-        target: activeTab,
-        value,
-        purpose: "bind",
-      })
-      message.success("验证码已发送")
-      setCountdown(60)
-    } catch (error) {
-      // error handled by interceptor
-    } finally {
-      setCodeLoading(false)
-    }
-  }
-
-  const handleSubmit = async () => {
-    try {
-      const values = await form.validateFields()
-      setLoading(true)
-
-      const payload =
-        activeTab === "email"
-          ? { email: values.email, email_code: values.code }
-          : { phone: values.phone, phone_code: values.code }
-
-      const result = await bindContact(payload)
-
-      message.success("绑定成功")
-      onSuccess?.(result.user)
-    } catch (error) {
-      // error handled by interceptor
-    } finally {
-      setLoading(false)
-    }
-  }
+  const {
+    activeTab,
+    setActiveTab,
+    form,
+    loading,
+    codeLoading,
+    countdown,
+    codeDisabled,
+    handleSendCode,
+    handleSubmit,
+  } = useBindContactForm({ open, onSuccess, onCancel })
 
   return (
     <Modal
@@ -111,7 +47,7 @@ const BindContactModal: React.FC<BindContactModalProps> = ({ open, onSuccess, on
                   <Input placeholder="请输入邮箱地址" size="large" />
                 </Form.Item>
                 <Form.Item
-                  name="code"
+                  name="email_code"
                   label="验证码"
                   rules={[{ required: true, message: "请输入验证码" }]}
                 >
@@ -121,7 +57,7 @@ const BindContactModal: React.FC<BindContactModalProps> = ({ open, onSuccess, on
                       size="large"
                       onClick={handleSendCode}
                       loading={codeLoading}
-                      disabled={countdown > 0}
+                      disabled={codeDisabled}
                     >
                       {countdown > 0 ? `${countdown}s 后重发` : "发送验证码"}
                     </Button>
@@ -146,7 +82,7 @@ const BindContactModal: React.FC<BindContactModalProps> = ({ open, onSuccess, on
                   <Input placeholder="请输入手机号" size="large" />
                 </Form.Item>
                 <Form.Item
-                  name="code"
+                  name="phone_code"
                   label="验证码"
                   rules={[{ required: true, message: "请输入验证码" }]}
                 >
@@ -156,7 +92,7 @@ const BindContactModal: React.FC<BindContactModalProps> = ({ open, onSuccess, on
                       size="large"
                       onClick={handleSendCode}
                       loading={codeLoading}
-                      disabled={countdown > 0}
+                      disabled={codeDisabled}
                     >
                       {countdown > 0 ? `${countdown}s 后重发` : "发送验证码"}
                     </Button>
@@ -178,3 +114,4 @@ const BindContactModal: React.FC<BindContactModalProps> = ({ open, onSuccess, on
 }
 
 export default BindContactModal
+export type { BindContactModalProps } from "./types"

apps/web/src/components/auth/BindContactModal/types.ts

@@ -0,0 +1,14 @@
+import type { BindContactResponse } from "@/api/auth"
+
+/** BindContactModal 组件属性 */
+export interface BindContactModalProps {
+  /** 是否打开 */
+  open: boolean
+  /** 绑定成功回调 */
+  onSuccess?: (user: BindContactResponse["user"]) => void
+  /** 取消回调 */
+  onCancel?: () => void
+}
+
+/** 联系方式类型 */
+export type ContactType = "email" | "phone"

apps/web/src/components/layout/PageHead.tsx

@@ -1,182 +0,0 @@
-/**
- * PageHead - 页面头部组件（Task 1.4）
- *
- * 功能：
- * - 页面标题展示
- * - 面包屑导航（自动根据路由生成，也支持手动传入）
- * - 右侧操作按钮区（slot，由页面自行填充）
- * - 响应式：移动端简化布局（隐藏面包屑，缩小标题）
- *
- * 复用 global.css 中已有的 .xx-page-head 基础样式，
- * 补充面包屑、操作区等扩展样式。
- */
-import React from "react"
-import { useLocation, useNavigate, Link } from "react-router-dom"
-import { RightOutlined, HomeOutlined } from "@ant-design/icons"
-import "./PageHead.css"
-
-/* ── 类型定义 ─────────────────────────────────────────────── */
-
-/** 面包屑项 */
-export interface BreadcrumbItem {
-  /** 显示文字 */
-  label: string
-  /** 路由路径，不传则为当前页（不可点击） */
-  path?: string
-}
-
-/** PageHead 组件属性 */
-export interface PageHeadProps {
-  /** 页面标题 */
-  title: string
-  /** 页面描述（可选，显示在标题下方） */
-  description?: React.ReactNode
-  /** 面包屑项（可选，不传则自动根据路由生成） */
-  breadcrumb?: BreadcrumbItem[]
-  /** 右侧操作区内容（按钮等） */
-  actions?: React.ReactNode
-  /** 是否隐藏面包屑 */
-  hideBreadcrumb?: boolean
-}
-
-/* ── 路由 → 标题映射（用于自动生成面包屑） ────────────────── */
-
-const ROUTE_TITLE_MAP: Record<string, string> = {
-  "/app/dashboard": "首页",
-  "/app/generate": "智能剪辑",
-  "/app/assets": "视频库",
-  "/app/voices": "配音库",
-  "/app/titles": "标题库",
-  "/app/products": "成片库",
-  "/app/templates": "模板库",
-  "/app/history": "任务历史",
-  "/app/admin": "控制台",
-  "/app/admin/users": "用户管理",
-  "/app/admin/analytics": "数据分析",
-  "/app/admin/monitor": "系统监控",
-  "/app/admin/logs": "系统日志",
-  "/app/subscription": "订阅管理",
-  "/app/subscription/upgrade": "升级订阅",
-  "/app/subscription/billing": "账单管理",
-  "/app/profile": "个人设置",
-  "/app/editing-planner": "模板制作",
-  "/app/my-templates": "我的模板",
-  "/app/voice-clone": "我的音色",
-  "/app/voice-materials": "配音库",
-  "/app/accounts": "账号管理",
-  "/app/duplication": "查重",
-  "/app/duplication/results": "查重结果",
-}
-
-/* ── 自动生成面包屑 ─────────────────────────────────────── */
-
-/** 根据当前路径生成面包屑 */
-const generateBreadcrumb = (pathname: string): BreadcrumbItem[] => {
-  const items: BreadcrumbItem[] = [{ label: "首页", path: "/app/dashboard" }]
-
-  // 首页本身不需要面包屑
-  if (pathname === "/app" || pathname === "/app/dashboard") {
-    return items
-  }
-
-  // 逐级拆分路径，生成中间层级
-  const segments = pathname.split("/").filter(Boolean)
-  let currentPath = ""
-
-  for (let i = 0; i < segments.length; i++) {
-    currentPath += `/${segments[i]}`
-    const title = ROUTE_TITLE_MAP[currentPath]
-
-    if (title) {
-      // 最后一级不带 path（当前页面，不可点击）
-      const isLast = i === segments.length - 1
-      items.push({
-        label: title,
-        path: isLast ? undefined : currentPath,
-      })
-    } else {
-      // 动态路由段（如 :id），用路径片段做 label
-      const isLast = i === segments.length - 1
-      items.push({
-        label: segments[i],
-        path: isLast ? undefined : currentPath,
-      })
-    }
-  }
-
-  return items
-}
-
-/* ── 组件 ───────────────────────────────────────────────── */
-
-const PageHead: React.FC<PageHeadProps> = ({
-  title,
-  description,
-  breadcrumb,
-  actions,
-  hideBreadcrumb = false,
-}) => {
-  const location = useLocation()
-  const navigate = useNavigate()
-
-  // 使用传入的面包屑或自动生成
-  const breadcrumbItems = breadcrumb ?? generateBreadcrumb(location.pathname)
-
-  // 首页不显示面包屑
-  const showBreadcrumb =
-    !hideBreadcrumb &&
-    breadcrumbItems.length > 1 &&
-    location.pathname !== "/app" &&
-    location.pathname !== "/app/dashboard"
-
-  return (
-    <header className="xx-page-head">
-      <div className="xx-page-head-left">
-        {/* 面包屑导航 */}
-        {showBreadcrumb && (
-          <nav className="xx-page-breadcrumb" aria-label="面包屑导航">
-            <ol>
-              {breadcrumbItems.map((item, index) => {
-                const isLast = index === breadcrumbItems.length - 1
-                return (
-                  <li key={`${item.label}-${index}`} className="xx-page-breadcrumb-item">
-                    {index > 0 && <RightOutlined className="xx-page-breadcrumb-separator" />}
-                    {item.path && !isLast ? (
-                      <Link
-                        to={item.path}
-                        className="xx-page-breadcrumb-link"
-                        onClick={(e) => {
-                          e.preventDefault()
-                          navigate(item.path!)
-                        }}
-                      >
-                        {index === 0 ? <HomeOutlined className="xx-page-breadcrumb-home" /> : null}
-                        <span>{item.label}</span>
-                      </Link>
-                    ) : (
-                      <span className="xx-page-breadcrumb-current" aria-current="page">
-                        {index === 0 ? <HomeOutlined className="xx-page-breadcrumb-home" /> : null}
-                        <span>{item.label}</span>
-                      </span>
-                    )}
-                  </li>
-                )
-              })}
-            </ol>
-          </nav>
-        )}
-
-        {/* 标题 + 描述 */}
-        <div className="xx-page-head-title">
-          <h2>{title}</h2>
-          {description && <p>{description}</p>}
-        </div>
-      </div>
-
-      {/* 右侧操作区 */}
-      {actions && <div className="xx-page-head-actions">{actions}</div>}
-    </header>
-  )
-}
-
-export default PageHead

apps/web/src/components/layout/PageHead/constants.ts

@@ -0,0 +1,27 @@
+/** 路由 → 标题映射（用于自动生成面包屑） */
+export const ROUTE_TITLE_MAP: Record<string, string> = {
+  "/app/dashboard": "首页",
+  "/app/generate": "智能剪辑",
+  "/app/assets": "视频库",
+  "/app/voices": "配音库",
+  "/app/titles": "标题库",
+  "/app/products": "成片库",
+  "/app/templates": "模板库",
+  "/app/history": "任务历史",
+  "/app/admin": "控制台",
+  "/app/admin/users": "用户管理",
+  "/app/admin/analytics": "数据分析",
+  "/app/admin/monitor": "系统监控",
+  "/app/admin/logs": "系统日志",
+  "/app/subscription": "订阅管理",
+  "/app/subscription/upgrade": "升级订阅",
+  "/app/subscription/billing": "账单管理",
+  "/app/profile": "个人设置",
+  "/app/editing-planner": "模板制作",
+  "/app/my-templates": "我的模板",
+  "/app/voice-clone": "我的音色",
+  "/app/voice-materials": "配音库",
+  "/app/accounts": "账号管理",
+  "/app/duplication": "查重",
+  "/app/duplication/results": "查重结果",
+}

apps/web/src/components/layout/PageHead/index.tsx

@@ -0,0 +1,91 @@
+/**
+ * PageHead - 页面头部组件（Task 1.4）
+ *
+ * 功能：
+ * - 页面标题展示
+ * - 面包屑导航（自动根据路由生成，也支持手动传入）
+ * - 右侧操作按钮区（slot，由页面自行填充）
+ * - 响应式：移动端简化布局（隐藏面包屑，缩小标题）
+ *
+ * 复用 global.css 中已有的 .xx-page-head 基础样式，
+ * 补充面包屑、操作区等扩展样式。
+ */
+import React from "react"
+import { useLocation, useNavigate, Link } from "react-router-dom"
+import { RightOutlined, HomeOutlined } from "@ant-design/icons"
+import type { PageHeadProps } from "./types"
+import { generateBreadcrumb } from "./utils"
+import "./PageHead.css"
+
+const PageHead: React.FC<PageHeadProps> = ({
+  title,
+  description,
+  breadcrumb,
+  actions,
+  hideBreadcrumb = false,
+}) => {
+  const location = useLocation()
+  const navigate = useNavigate()
+
+  // 使用传入的面包屑或自动生成
+  const breadcrumbItems = breadcrumb ?? generateBreadcrumb(location.pathname)
+
+  // 首页不显示面包屑
+  const showBreadcrumb =
+    !hideBreadcrumb &&
+    breadcrumbItems.length > 1 &&
+    location.pathname !== "/app" &&
+    location.pathname !== "/app/dashboard"
+
+  return (
+    <header className="xx-page-head">
+      <div className="xx-page-head-left">
+        {/* 面包屑导航 */}
+        {showBreadcrumb && (
+          <nav className="xx-page-breadcrumb" aria-label="面包屑导航">
+            <ol>
+              {breadcrumbItems.map((item, index) => {
+                const isLast = index === breadcrumbItems.length - 1
+                return (
+                  <li key={`${item.label}-${index}`} className="xx-page-breadcrumb-item">
+                    {index > 0 && <RightOutlined className="xx-page-breadcrumb-separator" />}
+                    {item.path && !isLast ? (
+                      <Link
+                        to={item.path}
+                        className="xx-page-breadcrumb-link"
+                        onClick={(e) => {
+                          e.preventDefault()
+                          navigate(item.path!)
+                        }}
+                      >
+                        {index === 0 ? <HomeOutlined className="xx-page-breadcrumb-home" /> : null}
+                        <span>{item.label}</span>
+                      </Link>
+                    ) : (
+                      <span className="xx-page-breadcrumb-current" aria-current="page">
+                        {index === 0 ? <HomeOutlined className="xx-page-breadcrumb-home" /> : null}
+                        <span>{item.label}</span>
+                      </span>
+                    )}
+                  </li>
+                )
+              })}
+            </ol>
+          </nav>
+        )}
+
+        {/* 标题 + 描述 */}
+        <div className="xx-page-head-title">
+          <h2>{title}</h2>
+          {description && <p>{description}</p>}
+        </div>
+      </div>
+
+      {/* 右侧操作区 */}
+      {actions && <div className="xx-page-head-actions">{actions}</div>}
+    </header>
+  )
+}
+
+export default PageHead
+export type { BreadcrumbItem, PageHeadProps } from "./types"

apps/web/src/components/layout/PageHead/types.ts

@@ -0,0 +1,23 @@
+import type React from "react"
+
+/** 面包屑项 */
+export interface BreadcrumbItem {
+  /** 显示文字 */
+  label: string
+  /** 路由路径，不传则为当前页（不可点击） */
+  path?: string
+}
+
+/** PageHead 组件属性 */
+export interface PageHeadProps {
+  /** 页面标题 */
+  title: string
+  /** 页面描述（可选，显示在标题下方） */
+  description?: React.ReactNode
+  /** 面包屑项（可选，不传则自动根据路由生成） */
+  breadcrumb?: BreadcrumbItem[]
+  /** 右侧操作区内容（按钮等） */
+  actions?: React.ReactNode
+  /** 是否隐藏面包屑 */
+  hideBreadcrumb?: boolean
+}

apps/web/src/components/layout/PageHead/utils.ts

@@ -0,0 +1,39 @@
+import { ROUTE_TITLE_MAP } from "./constants"
+import type { BreadcrumbItem } from "./types"
+
+/** 根据当前路径生成面包屑 */
+export const generateBreadcrumb = (pathname: string): BreadcrumbItem[] => {
+  const items: BreadcrumbItem[] = [{ label: "首页", path: "/app/dashboard" }]
+
+  // 首页本身不需要面包屑
+  if (pathname === "/app" || pathname === "/app/dashboard") {
+    return items
+  }
+
+  // 逐级拆分路径，生成中间层级
+  const segments = pathname.split("/").filter(Boolean)
+  let currentPath = ""
+
+  for (let i = 0; i < segments.length; i++) {
+    currentPath += `/${segments[i]}`
+    const title = ROUTE_TITLE_MAP[currentPath]
+
+    if (title) {
+      // 最后一级不带 path（当前页面，不可点击）
+      const isLast = i === segments.length - 1
+      items.push({
+        label: title,
+        path: isLast ? undefined : currentPath,
+      })
+    } else {
+      // 动态路由段（如 :id），用路径片段做 label
+      const isLast = i === segments.length - 1
+      items.push({
+        label: segments[i],
+        path: isLast ? undefined : currentPath,
+      })
+    }
+  }
+
+  return items
+}

apps/web/src/components/voice/CloneModal.tsx

@@ -1,82 +0,0 @@
-/**
- * CloneModal — 音色克隆弹窗（共享组件）
- *
- * 功能：
- * - 步骤引导：上传/录制音频 → 填写信息 → 提交克隆
- * - 两种输入方式：上传文件（wav/mp3/m4a，≤10MB）或浏览器原生录音（MediaRecorder）
- * - 提交：先 uploadAsset 获取真实 URL，再 createVoiceClone
- * - 进度展示：上传中 → 克隆中 → 完成（三阶段可视化）
- * - 错误处理：上传失败、格式错误、大小超限、录音权限拒绝等提示
- *
- * V21 Design System — 零 antd 直接导入
- */
-import React from "react"
-import { Modal } from "@/components/ui"
-import type { CloneModalProps } from "./types/cloneModal"
-import useCloneModal from "./hooks/useCloneModal"
-import InputView from "./clone-modal/InputView"
-import ProgressView from "./clone-modal/ProgressView"
-import "./clone-modal.css"
-
-const CloneModal: React.FC<CloneModalProps> = ({ open, onClose, onSuccess }) => {
-  const {
-    phase,
-    voiceName,
-    voiceDescription,
-    selectedFile,
-    dragActive,
-    errorMessage,
-    isRecording,
-    recordTime,
-    recordedBlob,
-    canSubmit,
-    isProcessing,
-    setVoiceName,
-    setVoiceDescription,
-    setDragActive,
-    handleFileSelect,
-    handleRecordToggle,
-    handleClose,
-    handleSubmit,
-  } = useCloneModal({ open, onClose, onSuccess })
-
-  return (
-    <Modal
-      open={open}
-      onCancel={handleClose}
-      title="克隆我的音色"
-      width={560}
-      footer={null}
-      destroyOnClose
-      maskClosable={!isProcessing}
-      keyboard={!isProcessing}
-    >
-      {/* 输入阶段 */}
-      {phase === "input" && (
-        <InputView
-          voiceName={voiceName}
-          voiceDescription={voiceDescription}
-          selectedFile={selectedFile}
-          dragActive={dragActive}
-          isRecording={isRecording}
-          recordTime={recordTime}
-          recordedBlob={recordedBlob}
-          errorMessage={errorMessage}
-          canSubmit={canSubmit}
-          onVoiceNameChange={setVoiceName}
-          onVoiceDescChange={setVoiceDescription}
-          onDragActiveChange={setDragActive}
-          onFileSelect={handleFileSelect}
-          onRecordToggle={handleRecordToggle}
-          onClose={handleClose}
-          onSubmit={handleSubmit}
-        />
-      )}
-
-      {/* 进度 / 完成阶段 */}
-      {phase !== "input" && <ProgressView phase={phase} />}
-    </Modal>
-  )
-}
-
-export default CloneModal

apps/web/src/components/voice/CloneModal/constants.ts

@@ -0,0 +1,20 @@
+import type { ProgressStep } from "./types"
+
+/** 进度阶段配置 */
+export const PROGRESS_STEPS: ProgressStep[] = [
+  { key: "uploading", label: "上传中", icon: "📤" },
+  { key: "cloning", label: "克隆中", icon: "🧬" },
+  { key: "done", label: "完成", icon: "✅" },
+]
+
+/** 支持的音频扩展名 */
+export const ACCEPTED_EXTENSIONS = ["mp3", "wav", "m4a", "webm"]
+
+/** 文件选择器 accept 属性 */
+export const ACCEPTED_MIME = ".mp3,.wav,.m4a,.webm,audio/mpeg,audio/wav,audio/mp4,audio/webm"
+
+/** 最大文件大小：10MB */
+export const MAX_FILE_SIZE = 10 * 1024 * 1024
+
+/** 最长录制时长：5 分钟（秒） */
+export const MAX_RECORD_SECONDS = 5 * 60

apps/web/src/components/voice/CloneModal/hooks/useAudioRecorder.ts

@@ -0,0 +1,146 @@
+import { useState, useRef, useCallback, useEffect } from "react"
+import { MAX_RECORD_SECONDS } from "../constants"
+import { formatRecordTime } from "../utils"
+
+/**
+ * 录音 Hook
+ * 封装浏览器 MediaRecorder 录音逻辑，含计时、自动停止、时长上限
+ */
+export const useAudioRecorder = (onError?: (msg: string) => void) => {
+  const [isRecording, setIsRecording] = useState(false)
+  const [recordTime, setRecordTime] = useState(0)
+  const [recordedBlob, setRecordedBlob] = useState<Blob | null>(null)
+
+  const recordTimerRef = useRef<ReturnType<typeof setInterval> | null>(null)
+  const mediaRecorderRef = useRef<MediaRecorder | null>(null)
+  const audioChunksRef = useRef<Blob[]>([])
+  const isMountedRef = useRef(true)
+  const isStartingRef = useRef(false)
+
+  /** 重置录音状态 */
+  const reset = useCallback(() => {
+    if (!isMountedRef.current) return
+    setIsRecording(false)
+    setRecordTime(0)
+    setRecordedBlob(null)
+    audioChunksRef.current = []
+    isStartingRef.current = false
+    if (recordTimerRef.current) {
+      clearInterval(recordTimerRef.current)
+      recordTimerRef.current = null
+    }
+    if (mediaRecorderRef.current && mediaRecorderRef.current.state !== "inactive") {
+      mediaRecorderRef.current.stop()
+    }
+    mediaRecorderRef.current = null
+  }, [])
+
+  /** 开始/停止录制 */
+  const toggleRecord = useCallback(async () => {
+    if (isRecording) {
+      // 停止录制
+      setIsRecording(false)
+      if (recordTimerRef.current) {
+        clearInterval(recordTimerRef.current)
+        recordTimerRef.current = null
+      }
+      if (mediaRecorderRef.current && mediaRecorderRef.current.state !== "inactive") {
+        mediaRecorderRef.current.stop()
+      }
+      return
+    }
+
+    // 防止快速双击导致重复启动
+    if (isStartingRef.current) return
+    isStartingRef.current = true
+
+    // 开始录制
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({
+        audio: true,
+      })
+      if (!isMountedRef.current) {
+        stream.getTracks().forEach((track) => track.stop())
+        isStartingRef.current = false
+        return
+      }
+      const mediaRecorder = new MediaRecorder(stream)
+      mediaRecorderRef.current = mediaRecorder
+      audioChunksRef.current = []
+
+      mediaRecorder.ondataavailable = (event) => {
+        if (event.data.size > 0) {
+          audioChunksRef.current.push(event.data)
+        }
+      }
+
+      mediaRecorder.onstop = () => {
+        if (recordTimerRef.current) {
+          clearInterval(recordTimerRef.current)
+          recordTimerRef.current = null
+        }
+        if (!isMountedRef.current) return
+        // 使用浏览器实际生成的 MIME 类型，避免跨浏览器兼容性问题
+        const mimeType = mediaRecorder.mimeType || "audio/webm"
+        const blob = new Blob(audioChunksRef.current, { type: mimeType })
+        setRecordedBlob(blob)
+        // 停止音轨
+        stream.getTracks().forEach((track) => track.stop())
+        isStartingRef.current = false
+      }
+
+      mediaRecorder.start()
+      setIsRecording(true)
+      setRecordTime(0)
+      setRecordedBlob(null)
+
+      recordTimerRef.current = setInterval(() => {
+        setRecordTime((prev) => {
+          const next = prev + 1
+          if (next >= MAX_RECORD_SECONDS) {
+            // 达到时长上限，自动停止
+            setTimeout(() => {
+              if (!isMountedRef.current) return
+              setIsRecording(false)
+              if (recordTimerRef.current) {
+                clearInterval(recordTimerRef.current)
+                recordTimerRef.current = null
+              }
+              if (mediaRecorderRef.current && mediaRecorderRef.current.state !== "inactive") {
+                mediaRecorderRef.current.stop()
+              }
+              onError?.("已达最长录制时长（5分钟），已自动停止")
+            }, 0)
+            return MAX_RECORD_SECONDS
+          }
+          return next
+        })
+      }, 1000)
+    } catch {
+      isStartingRef.current = false
+      onError?.("无法访问麦克风，请检查浏览器权限设置")
+    }
+  }, [isRecording, onError])
+
+  // 组件卸载时清理
+  useEffect(() => {
+    isMountedRef.current = true
+    return () => {
+      isMountedRef.current = false
+      isStartingRef.current = false
+      if (recordTimerRef.current) clearInterval(recordTimerRef.current)
+      if (mediaRecorderRef.current && mediaRecorderRef.current.state !== "inactive") {
+        mediaRecorderRef.current.stop()
+      }
+    }
+  }, [])
+
+  return {
+    isRecording,
+    recordTime,
+    recordedBlob,
+    formattedTime: formatRecordTime(recordTime),
+    toggleRecord,
+    reset,
+  }
+}

apps/web/src/components/voice/CloneModal/index.tsx

@@ -0,0 +1,460 @@
+import React, { useState, useCallback, useRef, useEffect } from "react"
+import { Modal, Button } from "@/components/ui"
+import { createVoiceClone, toVoiceClone } from "@/api/voice-clone"
+import { uploadAsset } from "@/api/assets"
+import { PROGRESS_STEPS, ACCEPTED_MIME } from "./constants"
+import { validateFile } from "./utils"
+import { useAudioRecorder } from "./hooks/useAudioRecorder"
+import type { CloneModalProps, ModalPhase } from "./types"
+import "./clone-modal.css"
+
+/** 根据 MIME 类型推断文件扩展名 */
+const getExtensionFromMime = (mime: string): string => {
+  if (mime.includes("webm")) return "webm"
+  if (mime.includes("mp4") || mime.includes("m4a")) return "m4a"
+  if (mime.includes("ogg")) return "ogg"
+  if (mime.includes("wav")) return "wav"
+  return "webm"
+}
+
+const CloneModal: React.FC<CloneModalProps> = ({ open, onClose, onSuccess }) => {
+  const [phase, setPhase] = useState<ModalPhase>("input")
+  const [voiceName, setVoiceName] = useState("")
+  const [voiceDescription, setVoiceDescription] = useState("")
+  const [selectedFile, setSelectedFile] = useState<File | null>(null)
+  const [dragActive, setDragActive] = useState(false)
+  const [errorMessage, setErrorMessage] = useState("")
+
+  const fileInputRef = useRef<HTMLInputElement>(null)
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  /** 默认音色名称计数器（组件级 ref，避免多实例串号） */
+  const cloneCounterRef = useRef(1)
+  /** 组件挂载状态标记，防止卸载后更新 state */
+  const isMountedRef = useRef(true)
+  const isSubmittingRef = useRef(false)
+
+  /* ── 录音 Hook ──────────────────────────────────── */
+  const {
+    isRecording,
+    recordedBlob,
+    formattedTime,
+    toggleRecord,
+    reset: resetRecorder,
+  } = useAudioRecorder(setErrorMessage)
+
+  /** 生成下一个默认音色名称 */
+  const getNextDefaultName = useCallback((): string => {
+    const name = `我的声音 ${cloneCounterRef.current}`
+    cloneCounterRef.current += 1
+    return name
+  }, [])
+
+  /** 重置弹窗状态 */
+  const resetState = useCallback(() => {
+    setPhase("input")
+    setVoiceName(getNextDefaultName())
+    setVoiceDescription("")
+    setSelectedFile(null)
+    setDragActive(false)
+    if (isSubmittingRef.current) return
+    isSubmittingRef.current = true
+    setErrorMessage("")
+    resetRecorder()
+  }, [getNextDefaultName, resetRecorder])
+
+  /** 关闭弹窗 */
+  const handleClose = useCallback(() => {
+    resetState()
+    onClose()
+  }, [resetState, onClose])
+
+  /** 弹窗打开时重置状态 */
+  useEffect(() => {
+    if (open) {
+      resetState()
+    }
+  }, [open, resetState])
+
+  /** 组件挂载/卸载标记 + 清理定时器 */
+  useEffect(() => {
+    isMountedRef.current = true
+    return () => {
+      isMountedRef.current = false
+      if (timerRef.current) clearTimeout(timerRef.current)
+    }
+  }, [])
+
+  /* ── 文件上传 ──────────────────────────────────── */
+
+  const handleUploadClick = () => {
+    fileInputRef.current?.click()
+  }
+
+  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    if (file) {
+      const error = validateFile(file)
+      if (error) {
+        setErrorMessage(error)
+        setSelectedFile(null)
+      } else {
+        if (isSubmittingRef.current) return
+        isSubmittingRef.current = true
+        setErrorMessage("")
+        setSelectedFile(file)
+        resetRecorder()
+      }
+    }
+    e.target.value = ""
+  }
+
+  /* ── 拖拽 ──────────────────────────────────────── */
+
+  const handleDrag = (e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    if (e.type === "dragenter" || e.type === "dragover") {
+      setDragActive(true)
+    } else if (e.type === "dragleave") {
+      setDragActive(false)
+    }
+  }
+
+  const handleDrop = (e: React.DragEvent) => {
+    e.preventDefault()
+    e.stopPropagation()
+    setDragActive(false)
+    const file = e.dataTransfer.files?.[0]
+    if (file) {
+      const error = validateFile(file)
+      if (error) {
+        setErrorMessage(error)
+        setSelectedFile(null)
+      } else {
+        if (isSubmittingRef.current) return
+        isSubmittingRef.current = true
+        setErrorMessage("")
+        setSelectedFile(file)
+        resetRecorder()
+      }
+    }
+  }
+
+  /* ── 计算属性 ──────────────────────────────────── */
+
+  const hasAudio = selectedFile !== null || recordedBlob !== null
+  const isProcessing = phase === "uploading" || phase === "cloning"
+  const canSubmit = hasAudio && !isProcessing
+
+  const progressIndex = PROGRESS_STEPS.findIndex((s) => s.key === phase)
+
+  /* ── 提交 ──────────────────────────────────────── */
+
+  const handleSubmit = async () => {
+    const name = voiceName.trim()
+    if (!name || name.length < 2 || name.length > 20) {
+      setErrorMessage("音色名称需在 2-20 个字符之间")
+      return
+    }
+    if (!hasAudio) {
+      setErrorMessage("请上传音频文件或录制一段声音")
+      return
+    }
+
+    if (isSubmittingRef.current) return
+    isSubmittingRef.current = true
+    setErrorMessage("")
+
+    try {
+      // 阶段 1：上传音频
+      setPhase("uploading")
+
+      let fileToUpload: File
+      if (selectedFile) {
+        fileToUpload = selectedFile
+      } else {
+        // 使用浏览器实际生成的 MIME 类型，避免跨浏览器格式不匹配
+        const mimeType = recordedBlob?.type || "audio/webm"
+        const ext = getExtensionFromMime(mimeType)
+        fileToUpload = new File([recordedBlob!], `recorded-${Date.now()}.${ext}`, {
+          type: mimeType,
+        })
+      }
+
+      const formData = new FormData()
+      formData.append("file", fileToUpload)
+      const uploadResult = await uploadAsset(formData)
+
+      // 组件已卸载则中止后续操作
+      if (!isMountedRef.current) return
+
+      // 阶段 2：克隆
+      setPhase("cloning")
+      const result = await createVoiceClone({
+        name,
+        description: voiceDescription.trim() || undefined,
+        audio_url: uploadResult.url,
+      })
+
+      // 组件已卸载则中止后续操作
+      if (!isMountedRef.current) return
+
+      isSubmittingRef.current = false
+      // 阶段 3：完成
+      setPhase("done")
+
+      // 2秒后自动关闭
+      timerRef.current = setTimeout(() => {
+        if (isMountedRef.current) {
+          onSuccess?.(toVoiceClone(result))
+          handleClose()
+        }
+      }, 2000)
+    } catch (err) {
+      isSubmittingRef.current = false
+      // 组件已卸载则不更新 state
+      if (!isMountedRef.current) return
+      setPhase("input")
+      setErrorMessage(err instanceof Error ? err.message : "克隆失败，请重试")
+    }
+  }
+
+  return (
+    <Modal
+      open={open}
+      onCancel={handleClose}
+      title="克隆我的音色"
+      width={560}
+      footer={null}
+      destroyOnClose
+      maskClosable={!isProcessing}
+      keyboard={!isProcessing}
+    >
+      {/* ── 输入阶段 ────────────────────────────────── */}
+      {phase === "input" && (
+        <div className="xx-clonemodal-body">
+          {/* 步骤引导 */}
+          <div className="xx-clonemodal-steps">
+            <div className="xx-clonemodal-step xx-clonemodal-step--active">
+              <div className="xx-clonemodal-step-number">1</div>
+              <span className="xx-clonemodal-step-label">上传/录制音频</span>
+            </div>
+            <div className="xx-clonemodal-step-connector" />
+            <div className="xx-clonemodal-step">
+              <div className="xx-clonemodal-step-number">2</div>
+              <span className="xx-clonemodal-step-label">填写信息</span>
+            </div>
+            <div className="xx-clonemodal-step-connector" />
+            <div className="xx-clonemodal-step">
+              <div className="xx-clonemodal-step-number">3</div>
+              <span className="xx-clonemodal-step-label">提交克隆</span>
+            </div>
+          </div>
+
+          {/* 音色名称 */}
+          <div className="xx-clonemodal-field">
+            <label className="xx-clonemodal-label">
+              音色名称 <span className="xx-clonemodal-required">*</span>
+            </label>
+            <input
+              type="text"
+              className="xx-clonemodal-input"
+              value={voiceName}
+              onChange={(e) => setVoiceName(e.target.value)}
+              placeholder="输入音色名称（2-20字符）"
+              maxLength={20}
+            />
+            <div className="xx-clonemodal-char-count">{voiceName.length}/20</div>
+          </div>
+
+          {/* 上传区域 */}
+          <div className="xx-clonemodal-field">
+            <label className="xx-clonemodal-label">上传音频</label>
+            <div
+              className={`xx-clonemodal-upload-zone${dragActive ? " xx-clonemodal-upload-zone--active" : ""}${selectedFile ? " xx-clonemodal-upload-zone--has-file" : ""}`}
+              onClick={handleUploadClick}
+              onDragEnter={handleDrag}
+              onDragOver={handleDrag}
+              onDragLeave={handleDrag}
+              onDrop={handleDrop}
+            >
+              <div className="xx-clonemodal-upload-icon">{selectedFile ? "📄" : "🎵"}</div>
+              <p className="xx-clonemodal-upload-title">
+                {selectedFile ? selectedFile.name : "拖拽音频文件到此处，或点击上传"}
+              </p>
+              <p className="xx-clonemodal-upload-hint">支持 MP3、WAV、M4A 格式，最大 10MB</p>
+              <input
+                ref={fileInputRef}
+                type="file"
+                accept={ACCEPTED_MIME}
+                style={{ display: "none" }}
+                onChange={handleFileChange}
+              />
+            </div>
+          </div>
+
+          {/* 或分隔 */}
+          <div className="xx-clonemodal-divider">
+            <div className="xx-clonemodal-divider-line" />
+            <span className="xx-clonemodal-divider-text">或</span>
+            <div className="xx-clonemodal-divider-line" />
+          </div>
+
+          {/* 录制区域 */}
+          <div className="xx-clonemodal-field">
+            <label className="xx-clonemodal-label">直接录制</label>
+            <div className="xx-clonemodal-record-area">
+              <div className="xx-clonemodal-record-info">
+                <p className="xx-clonemodal-record-hint">
+                  {isRecording
+                    ? `录制中 ${formattedTime}`
+                    : recordedBlob
+                      ? `已录制 ${formattedTime}`
+                      : "点击按钮开始录制（最长 5 分钟）"}
+                </p>
+                {isRecording && (
+                  <div className="xx-clonemodal-record-wave">
+                    <span className="xx-clonemodal-record-wave-bar" />
+                    <span className="xx-clonemodal-record-wave-bar" />
+                    <span className="xx-clonemodal-record-wave-bar" />
+                    <span className="xx-clonemodal-record-wave-bar" />
+                    <span className="xx-clonemodal-record-wave-bar" />
+                  </div>
+                )}
+              </div>
+              <button
+                type="button"
+                className={`xx-clonemodal-record-btn${isRecording ? " xx-clonemodal-record-btn--recording" : ""}`}
+                onClick={toggleRecord}
+                title={isRecording ? "停止录制" : "开始录制"}
+              >
+                {isRecording ? "⏹" : "🎙️"}
+              </button>
+            </div>
+          </div>
+
+          {/* 音色描述 */}
+          <div className="xx-clonemodal-field">
+            <label className="xx-clonemodal-label">音色描述</label>
+            <textarea
+              className="xx-clonemodal-textarea"
+              value={voiceDescription}
+              onChange={(e) => setVoiceDescription(e.target.value)}
+              placeholder="可选，描述这个音色的特点（最多100字符）"
+              maxLength={100}
+              rows={3}
+            />
+            <div className="xx-clonemodal-char-count">{voiceDescription.length}/100</div>
+          </div>
+
+          {/* 错误提示 */}
+          {errorMessage && (
+            <div className="xx-clonemodal-error">
+              <span className="xx-clonemodal-error-icon">⚠️</span>
+              <span>{errorMessage}</span>
+            </div>
+          )}
+
+          {/* 提示 */}
+          <div className="xx-clonemodal-tip">
+            <span className="xx-clonemodal-tip-icon">💡</span>
+            <span>建议上传 10 秒 ~ 3 分钟的清晰语音，环境安静、语速均匀效果最佳</span>
+          </div>
+
+          {/* 底部按钮 */}
+          <div className="xx-clonemodal-footer">
+            <Button buttonType="ghost" onClick={handleClose}>
+              取消
+            </Button>
+            <Button buttonType="primary" disabled={!canSubmit} onClick={handleSubmit}>
+              🎤 开始克隆
+            </Button>
+          </div>
+        </div>
+      )}
+
+      {/* ── 进度阶段（上传中 / 克隆中） ────────────── */}
+      {isProcessing && (
+        <div className="xx-clonemodal-progress-body">
+          {/* 步骤指示器 */}
+          <div className="xx-clonemodal-steps-progress">
+            {PROGRESS_STEPS.map((step, idx) => {
+              const isActive = idx === progressIndex
+              const isDone = idx < progressIndex
+              const stepClass = [
+                "xx-clonemodal-step-progress",
+                isActive ? "xx-clonemodal-step-progress--active" : "",
+                isDone ? "xx-clonemodal-step-progress--done" : "",
+              ]
+                .filter(Boolean)
+                .join(" ")
+
+              return (
+                <React.Fragment key={step.key}>
+                  {idx > 0 && (
+                    <div
+                      className={`xx-clonemodal-step-connector${isDone ? " xx-clonemodal-step-connector--done" : ""}`}
+                    />
+                  )}
+                  <div className={stepClass}>
+                    <div className="xx-clonemodal-step-icon">{isDone ? "✓" : step.icon}</div>
+                    <span className="xx-clonemodal-step-label">{step.label}</span>
+                  </div>
+                </React.Fragment>
+              )
+            })}
+          </div>
+
+          {/* 当前阶段描述 */}
+          <div className="xx-clonemodal-progress-info">
+            {phase === "uploading" && (
+              <>
+                <div className="xx-clonemodal-progress-spinner" />
+                <p className="xx-clonemodal-progress-text">正在上传音频文件…</p>
+                <p className="xx-clonemodal-progress-sub">请稍候，正在将音频上传至服务器</p>
+              </>
+            )}
+            {phase === "cloning" && (
+              <>
+                <div className="xx-clonemodal-progress-spinner xx-clonemodal-progress-spinner--cloning" />
+                <p className="xx-clonemodal-progress-text">AI 正在克隆你的声音…</p>
+                <p className="xx-clonemodal-progress-sub">正在分析声音特征，生成专属音色模型</p>
+              </>
+            )}
+          </div>
+        </div>
+      )}
+
+      {/* ── 完成阶段 ────────────────────────────────── */}
+      {phase === "done" && (
+        <div className="xx-clonemodal-progress-body">
+          {/* 步骤指示器（全部完成） */}
+          <div className="xx-clonemodal-steps-progress">
+            {PROGRESS_STEPS.map((step, idx) => (
+              <React.Fragment key={step.key}>
+                {idx > 0 && (
+                  <div className="xx-clonemodal-step-connector xx-clonemodal-step-connector--done" />
+                )}
+                <div className="xx-clonemodal-step-progress xx-clonemodal-step-progress--done">
+                  <div className="xx-clonemodal-step-icon">✓</div>
+                  <span className="xx-clonemodal-step-label">{step.label}</span>
+                </div>
+              </React.Fragment>
+            ))}
+          </div>
+
+          <div className="xx-clonemodal-success">
+            <div className="xx-clonemodal-success-icon">🎉</div>
+            <h3 className="xx-clonemodal-success-title">克隆已提交</h3>
+            <p className="xx-clonemodal-success-desc">
+              音色正在生成中，完成后将出现在「我的克隆」列表中
+            </p>
+          </div>
+        </div>
+      )}
+    </Modal>
+  )
+}
+
+export default CloneModal
+export type { CloneModalProps, ModalPhase } from "./types"

apps/web/src/components/voice/CloneModal/types.ts

@@ -0,0 +1,21 @@
+import type { VoiceClone } from "@/api/voice-clone"
+
+/** 弹窗阶段 */
+export type ModalPhase = "input" | "uploading" | "cloning" | "done"
+
+/** CloneModal 组件属性 */
+export interface CloneModalProps {
+  /** 弹窗是否可见 */
+  open: boolean
+  /** 关闭弹窗回调 */
+  onClose: () => void
+  /** 克隆成功回调（返回新创建的音色） */
+  onSuccess?: (voice: VoiceClone) => void
+}
+
+/** 进度步骤配置 */
+export interface ProgressStep {
+  key: string
+  label: string
+  icon: string
+}

apps/web/src/components/voice/CloneModal/utils.ts

@@ -0,0 +1,23 @@
+import { ACCEPTED_EXTENSIONS, MAX_FILE_SIZE } from "./constants"
+
+/**
+ * 验证音频文件
+ * @returns 错误信息，null 表示验证通过
+ */
+export const validateFile = (file: File): string | null => {
+  const ext = file.name.split(".").pop()?.toLowerCase()
+  if (!ext || !ACCEPTED_EXTENSIONS.includes(ext)) {
+    return "不支持的音频格式，请上传 MP3、WAV 或 M4A 文件"
+  }
+  if (file.size > MAX_FILE_SIZE) {
+    return "文件大小超过 10MB，请压缩后重试"
+  }
+  return null
+}
+
+/** 格式化录制时间 mm:ss */
+export const formatRecordTime = (seconds: number): string => {
+  const m = Math.floor(seconds / 60)
+  const s = seconds % 60
+  return `${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")}`
+}

apps/web/src/hooks/useAuth.ts

@@ -31,8 +31,8 @@ export const useLogin = () => {
     const user = await authApi.getCurrentUser()
     setAuth(user, data.access_token, refreshToken)
 
-    // 跳转到登录前页面或首页
-    const redirect = localStorage.getItem("login_redirect") || "/"
+    // 跳转到登录前页面或仪表盘（与 Login.tsx onFinish 保持一致）
+    const redirect = localStorage.getItem("login_redirect") || "/app/dashboard"
     localStorage.removeItem("login_redirect")
     navigate(redirect, { replace: true })
     return data

apps/web/src/pages/assets/hooks/asset-operations/batch-operations/index.ts

@@ -0,0 +1,4 @@
+export { useBatchDelete } from "./useBatchDelete"
+export { useBatchTag } from "./useBatchTag"
+export { useBatchClassify } from "./useBatchClassify"
+export { useBatchMark } from "./useBatchMark"

apps/web/src/pages/assets/hooks/asset-operations/batch-operations/useBatchClassify.ts

@@ -0,0 +1,58 @@
+import { useState, useCallback } from "react"
+import { message } from "antd"
+import { batchClassifyAssets, type BatchOperationResult } from "@/api/assets"
+
+interface UseBatchClassifyOptions {
+  selectedIds: Set<string>
+  queryClient: ReturnType<typeof import("@tanstack/react-query").useQueryClient>
+  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
+}
+
+export const useBatchClassify = ({
+  selectedIds,
+  queryClient,
+  showResult,
+}: UseBatchClassifyOptions) => {
+  const [classifyModalOpen, setClassifyModalOpen] = useState(false)
+  const [batchCategory, setBatchCategory] = useState("")
+  const [batchLoading, setBatchLoading] = useState(false)
+
+  const handleBatchClassify = useCallback(async () => {
+    if (!batchCategory) {
+      message.warning("请选择分类")
+      return
+    }
+    const ids = Array.from(selectedIds)
+    setBatchLoading(true)
+    try {
+      const result = await batchClassifyAssets({
+        asset_ids: ids,
+        category: batchCategory,
+      })
+      queryClient.invalidateQueries({ queryKey: ["assets"] })
+      showResult(result, "批量改分类")
+      setClassifyModalOpen(false)
+      setBatchCategory("")
+      if (result.failure_count === 0) {
+        message.success(`成功将 ${result.success_count} 个素材改为「${batchCategory}」`)
+      } else {
+        message.warning(
+          `改分类完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
+        )
+      }
+    } catch {
+      message.error("批量改分类失败，请重试")
+    } finally {
+      setBatchLoading(false)
+    }
+  }, [batchCategory, selectedIds, queryClient, showResult])
+
+  return {
+    classifyModalOpen,
+    setClassifyModalOpen,
+    batchCategory,
+    setBatchCategory,
+    batchLoading,
+    handleBatchClassify,
+  }
+}

apps/web/src/pages/assets/hooks/asset-operations/batch-operations/useBatchDelete.ts

@@ -0,0 +1,40 @@
+import { useState, useCallback } from "react"
+import { message } from "antd"
+import { batchDeleteAssets, type BatchOperationResult } from "@/api/assets"
+
+interface UseBatchDeleteOptions {
+  selectedIds: Set<string>
+  invalidateAssets: () => void
+  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
+}
+
+export const useBatchDelete = ({
+  selectedIds,
+  invalidateAssets,
+  showResult,
+}: UseBatchDeleteOptions) => {
+  const [batchLoading, setBatchLoading] = useState(false)
+
+  const handleBatchDelete = useCallback(async () => {
+    const ids = Array.from(selectedIds)
+    setBatchLoading(true)
+    try {
+      const result = await batchDeleteAssets(ids)
+      invalidateAssets()
+      showResult(result, "批量删除")
+      if (result.failure_count === 0) {
+        message.success(`成功删除 ${result.success_count} 个素材`)
+      } else {
+        message.warning(
+          `删除完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
+        )
+      }
+    } catch {
+      message.error("批量删除失败，请重试")
+    } finally {
+      setBatchLoading(false)
+    }
+  }, [selectedIds, invalidateAssets, showResult])
+
+  return { batchLoading, handleBatchDelete }
+}

apps/web/src/pages/assets/hooks/asset-operations/batch-operations/useBatchMark.ts

@@ -0,0 +1,53 @@
+import { useState, useCallback } from "react"
+import { message } from "antd"
+import { batchMarkAssets, type BatchOperationResult } from "@/api/assets"
+import type { SmartViewType } from "../../../components/BatchMarkModal"
+import { SMART_VIEW_LABELS } from "../constants"
+
+interface UseBatchMarkOptions {
+  selectedIds: Set<string>
+  queryClient: ReturnType<typeof import("@tanstack/react-query").useQueryClient>
+  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
+}
+
+export const useBatchMark = ({ selectedIds, queryClient, showResult }: UseBatchMarkOptions) => {
+  const [markModalOpen, setMarkModalOpen] = useState(false)
+  const [batchSmartView, setBatchSmartView] = useState<SmartViewType>("recommended")
+  const [batchLoading, setBatchLoading] = useState(false)
+
+  const handleBatchMark = useCallback(async () => {
+    const ids = Array.from(selectedIds)
+    setBatchLoading(true)
+    try {
+      const result = await batchMarkAssets({
+        asset_ids: ids,
+        smart_view: batchSmartView,
+      })
+      queryClient.invalidateQueries({ queryKey: ["assets"] })
+      showResult(result, "批量智能标记")
+      setMarkModalOpen(false)
+      if (result.failure_count === 0) {
+        message.success(
+          `成功将 ${result.success_count} 个素材标记为「${SMART_VIEW_LABELS[batchSmartView]}」`,
+        )
+      } else {
+        message.warning(
+          `智能标记完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
+        )
+      }
+    } catch {
+      message.error("批量智能标记失败，请重试")
+    } finally {
+      setBatchLoading(false)
+    }
+  }, [batchSmartView, selectedIds, queryClient, showResult])
+
+  return {
+    markModalOpen,
+    setMarkModalOpen,
+    batchSmartView,
+    setBatchSmartView,
+    batchLoading,
+    handleBatchMark,
+  }
+}

apps/web/src/pages/assets/hooks/asset-operations/batch-operations/useBatchTag.ts

@@ -0,0 +1,86 @@
+import { useState, useCallback } from "react"
+import { message } from "antd"
+import { batchTagAssets, type BatchOperationResult } from "@/api/assets"
+
+interface UseBatchTagOptions {
+  selectedIds: Set<string>
+  queryClient: ReturnType<typeof import("@tanstack/react-query").useQueryClient>
+  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
+}
+
+export const useBatchTag = ({ selectedIds, queryClient, showResult }: UseBatchTagOptions) => {
+  const [tagModalOpen, setTagModalOpen] = useState(false)
+  const [batchTagInput, setBatchTagInput] = useState("")
+  const [batchTags, setBatchTags] = useState<string[]>([])
+  const [tagMode, setTagMode] = useState<"add" | "replace">("add")
+  const [batchLoading, setBatchLoading] = useState(false)
+
+  const handleBatchTag = useCallback(async () => {
+    if (batchTags.length === 0) {
+      message.warning("请至少输入一个标签")
+      return
+    }
+    const ids = Array.from(selectedIds)
+    setBatchLoading(true)
+    try {
+      const result = await batchTagAssets({
+        asset_ids: ids,
+        tags: batchTags,
+        mode: tagMode,
+      })
+      queryClient.invalidateQueries({ queryKey: ["assets"] })
+      showResult(result, "批量打标签")
+      setTagModalOpen(false)
+      setBatchTags([])
+      setBatchTagInput("")
+      setTagMode("add")
+      if (result.failure_count === 0) {
+        message.success(`成功为 ${result.success_count} 个素材打标签`)
+      } else {
+        message.warning(
+          `打标签完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
+        )
+      }
+    } catch {
+      message.error("批量打标签失败，请重试")
+    } finally {
+      setBatchLoading(false)
+    }
+  }, [batchTags, selectedIds, tagMode, queryClient, showResult])
+
+  const handleTagInputKeyDown = useCallback(
+    (e: React.KeyboardEvent) => {
+      if (e.key === "Enter" && batchTagInput.trim()) {
+        e.preventDefault()
+        const tag = batchTagInput.trim()
+        if (!batchTags.includes(tag)) {
+          setBatchTags([...batchTags, tag])
+        }
+        setBatchTagInput("")
+      }
+    },
+    [batchTagInput, batchTags],
+  )
+
+  const removeBatchTag = useCallback(
+    (tag: string) => {
+      setBatchTags(batchTags.filter((t) => t !== tag))
+    },
+    [batchTags],
+  )
+
+  return {
+    tagModalOpen,
+    setTagModalOpen,
+    batchTagInput,
+    setBatchTagInput,
+    batchTags,
+    setBatchTags,
+    tagMode,
+    setTagMode,
+    batchLoading,
+    handleBatchTag,
+    handleTagInputKeyDown,
+    removeBatchTag,
+  }
+}

apps/web/src/pages/assets/hooks/asset-operations/batch/index.ts

@@ -0,0 +1,4 @@
+export { useBatchDelete } from "./useBatchDelete"
+export { useBatchTag } from "./useBatchTag"
+export { useBatchClassify } from "./useBatchClassify"
+export { useBatchMark } from "./useBatchMark"

apps/web/src/pages/assets/hooks/asset-operations/batch/useBatchClassify.ts

@@ -0,0 +1,58 @@
+import { useState, useCallback } from "react"
+import { message } from "antd"
+import { batchClassifyAssets, type BatchOperationResult } from "@/api/assets"
+
+interface UseBatchClassifyOptions {
+  selectedIds: Set<string>
+  queryClient: ReturnType<typeof import("@tanstack/react-query").useQueryClient>
+  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
+}
+
+export const useBatchClassify = ({
+  selectedIds,
+  queryClient,
+  showResult,
+}: UseBatchClassifyOptions) => {
+  const [classifyModalOpen, setClassifyModalOpen] = useState(false)
+  const [batchCategory, setBatchCategory] = useState("")
+  const [batchLoading, setBatchLoading] = useState(false)
+
+  const handleBatchClassify = useCallback(async () => {
+    if (!batchCategory) {
+      message.warning("请选择分类")
+      return
+    }
+    const ids = Array.from(selectedIds)
+    setBatchLoading(true)
+    try {
+      const result = await batchClassifyAssets({
+        asset_ids: ids,
+        category: batchCategory,
+      })
+      queryClient.invalidateQueries({ queryKey: ["assets"] })
+      showResult(result, "批量改分类")
+      setClassifyModalOpen(false)
+      setBatchCategory("")
+      if (result.failure_count === 0) {
+        message.success(`成功将 ${result.success_count} 个素材改为「${batchCategory}」`)
+      } else {
+        message.warning(
+          `改分类完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
+        )
+      }
+    } catch {
+      message.error("批量改分类失败，请重试")
+    } finally {
+      setBatchLoading(false)
+    }
+  }, [batchCategory, selectedIds, queryClient, showResult])
+
+  return {
+    classifyModalOpen,
+    setClassifyModalOpen,
+    batchCategory,
+    setBatchCategory,
+    batchLoading,
+    handleBatchClassify,
+  }
+}

apps/web/src/pages/assets/hooks/asset-operations/batch/useBatchDelete.ts

@@ -0,0 +1,40 @@
+import { useState, useCallback } from "react"
+import { message } from "antd"
+import { batchDeleteAssets, type BatchOperationResult } from "@/api/assets"
+
+interface UseBatchDeleteOptions {
+  selectedIds: Set<string>
+  invalidateAssets: () => void
+  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
+}
+
+export const useBatchDelete = ({
+  selectedIds,
+  invalidateAssets,
+  showResult,
+}: UseBatchDeleteOptions) => {
+  const [batchLoading, setBatchLoading] = useState(false)
+
+  const handleBatchDelete = useCallback(async () => {
+    const ids = Array.from(selectedIds)
+    setBatchLoading(true)
+    try {
+      const result = await batchDeleteAssets(ids)
+      invalidateAssets()
+      showResult(result, "批量删除")
+      if (result.failure_count === 0) {
+        message.success(`成功删除 ${result.success_count} 个素材`)
+      } else {
+        message.warning(
+          `删除完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
+        )
+      }
+    } catch {
+      message.error("批量删除失败，请重试")
+    } finally {
+      setBatchLoading(false)
+    }
+  }, [selectedIds, invalidateAssets, showResult])
+
+  return { batchLoading, handleBatchDelete }
+}

apps/web/src/pages/assets/hooks/asset-operations/batch/useBatchMark.ts

@@ -0,0 +1,53 @@
+import { useState, useCallback } from "react"
+import { message } from "antd"
+import { batchMarkAssets, type BatchOperationResult } from "@/api/assets"
+import type { SmartViewType } from "../../../components/BatchMarkModal"
+import { SMART_VIEW_LABELS } from "../constants"
+
+interface UseBatchMarkOptions {
+  selectedIds: Set<string>
+  queryClient: ReturnType<typeof import("@tanstack/react-query").useQueryClient>
+  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
+}
+
+export const useBatchMark = ({ selectedIds, queryClient, showResult }: UseBatchMarkOptions) => {
+  const [markModalOpen, setMarkModalOpen] = useState(false)
+  const [batchSmartView, setBatchSmartView] = useState<SmartViewType>("recommended")
+  const [batchLoading, setBatchLoading] = useState(false)
+
+  const handleBatchMark = useCallback(async () => {
+    const ids = Array.from(selectedIds)
+    setBatchLoading(true)
+    try {
+      const result = await batchMarkAssets({
+        asset_ids: ids,
+        smart_view: batchSmartView,
+      })
+      queryClient.invalidateQueries({ queryKey: ["assets"] })
+      showResult(result, "批量智能标记")
+      setMarkModalOpen(false)
+      if (result.failure_count === 0) {
+        message.success(
+          `成功将 ${result.success_count} 个素材标记为「${SMART_VIEW_LABELS[batchSmartView]}」`,
+        )
+      } else {
+        message.warning(
+          `智能标记完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
+        )
+      }
+    } catch {
+      message.error("批量智能标记失败，请重试")
+    } finally {
+      setBatchLoading(false)
+    }
+  }, [batchSmartView, selectedIds, queryClient, showResult])
+
+  return {
+    markModalOpen,
+    setMarkModalOpen,
+    batchSmartView,
+    setBatchSmartView,
+    batchLoading,
+    handleBatchMark,
+  }
+}

apps/web/src/pages/assets/hooks/asset-operations/batch/useBatchTag.ts

@@ -0,0 +1,86 @@
+import { useState, useCallback } from "react"
+import { message } from "antd"
+import { batchTagAssets, type BatchOperationResult } from "@/api/assets"
+
+interface UseBatchTagOptions {
+  selectedIds: Set<string>
+  queryClient: ReturnType<typeof import("@tanstack/react-query").useQueryClient>
+  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
+}
+
+export const useBatchTag = ({ selectedIds, queryClient, showResult }: UseBatchTagOptions) => {
+  const [tagModalOpen, setTagModalOpen] = useState(false)
+  const [batchTagInput, setBatchTagInput] = useState("")
+  const [batchTags, setBatchTags] = useState<string[]>([])
+  const [tagMode, setTagMode] = useState<"add" | "replace">("add")
+  const [batchLoading, setBatchLoading] = useState(false)
+
+  const handleBatchTag = useCallback(async () => {
+    if (batchTags.length === 0) {
+      message.warning("请至少输入一个标签")
+      return
+    }
+    const ids = Array.from(selectedIds)
+    setBatchLoading(true)
+    try {
+      const result = await batchTagAssets({
+        asset_ids: ids,
+        tags: batchTags,
+        mode: tagMode,
+      })
+      queryClient.invalidateQueries({ queryKey: ["assets"] })
+      showResult(result, "批量打标签")
+      setTagModalOpen(false)
+      setBatchTags([])
+      setBatchTagInput("")
+      setTagMode("add")
+      if (result.failure_count === 0) {
+        message.success(`成功为 ${result.success_count} 个素材打标签`)
+      } else {
+        message.warning(
+          `打标签完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
+        )
+      }
+    } catch {
+      message.error("批量打标签失败，请重试")
+    } finally {
+      setBatchLoading(false)
+    }
+  }, [batchTags, selectedIds, tagMode, queryClient, showResult])
+
+  const handleTagInputKeyDown = useCallback(
+    (e: React.KeyboardEvent) => {
+      if (e.key === "Enter" && batchTagInput.trim()) {
+        e.preventDefault()
+        const tag = batchTagInput.trim()
+        if (!batchTags.includes(tag)) {
+          setBatchTags([...batchTags, tag])
+        }
+        setBatchTagInput("")
+      }
+    },
+    [batchTagInput, batchTags],
+  )
+
+  const removeBatchTag = useCallback(
+    (tag: string) => {
+      setBatchTags(batchTags.filter((t) => t !== tag))
+    },
+    [batchTags],
+  )
+
+  return {
+    tagModalOpen,
+    setTagModalOpen,
+    batchTagInput,
+    setBatchTagInput,
+    batchTags,
+    setBatchTags,
+    tagMode,
+    setTagMode,
+    batchLoading,
+    handleBatchTag,
+    handleTagInputKeyDown,
+    removeBatchTag,
+  }
+}

apps/web/src/pages/assets/hooks/asset-operations/batchOperations.ts

@@ -1,238 +1,8 @@
-import { useState, useCallback } from "react"
-import { message } from "antd"
-import {
-  batchDeleteAssets,
-  batchTagAssets,
-  batchClassifyAssets,
-  batchMarkAssets,
-  type BatchOperationResult,
-} from "@/api/assets"
-import type { SmartViewType } from "../../components/BatchMarkModal"
-import { SMART_VIEW_LABELS } from "./constants"
-
-/* ── 批量删除 ── */
-interface UseBatchDeleteOptions {
-  selectedIds: Set<string>
-  invalidateAssets: () => void
-  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
-}
-
-export const useBatchDelete = ({
-  selectedIds,
-  invalidateAssets,
-  showResult,
-}: UseBatchDeleteOptions) => {
-  const [batchLoading, setBatchLoading] = useState(false)
-
-  const handleBatchDelete = useCallback(async () => {
-    const ids = Array.from(selectedIds)
-    setBatchLoading(true)
-    try {
-      const result = await batchDeleteAssets(ids)
-      invalidateAssets()
-      showResult(result, "批量删除")
-      if (result.failure_count === 0) {
-        message.success(`成功删除 ${result.success_count} 个素材`)
-      } else {
-        message.warning(
-          `删除完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
-        )
-      }
-    } catch {
-      message.error("批量删除失败，请重试")
-    } finally {
-      setBatchLoading(false)
-    }
-  }, [selectedIds, invalidateAssets, showResult])
-
-  return { batchLoading, handleBatchDelete }
-}
-
-/* ── 批量打标签 ── */
-interface UseBatchTagOptions {
-  selectedIds: Set<string>
-  queryClient: ReturnType<typeof import("@tanstack/react-query").useQueryClient>
-  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
-}
-
-export const useBatchTag = ({ selectedIds, queryClient, showResult }: UseBatchTagOptions) => {
-  const [tagModalOpen, setTagModalOpen] = useState(false)
-  const [batchTagInput, setBatchTagInput] = useState("")
-  const [batchTags, setBatchTags] = useState<string[]>([])
-  const [tagMode, setTagMode] = useState<"add" | "replace">("add")
-  const [batchLoading, setBatchLoading] = useState(false)
-
-  const handleBatchTag = useCallback(async () => {
-    if (batchTags.length === 0) {
-      message.warning("请至少输入一个标签")
-      return
-    }
-    const ids = Array.from(selectedIds)
-    setBatchLoading(true)
-    try {
-      const result = await batchTagAssets({
-        asset_ids: ids,
-        tags: batchTags,
-        mode: tagMode,
-      })
-      queryClient.invalidateQueries({ queryKey: ["assets"] })
-      showResult(result, "批量打标签")
-      setTagModalOpen(false)
-      setBatchTags([])
-      setBatchTagInput("")
-      setTagMode("add")
-      if (result.failure_count === 0) {
-        message.success(`成功为 ${result.success_count} 个素材打标签`)
-      } else {
-        message.warning(
-          `打标签完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
-        )
-      }
-    } catch {
-      message.error("批量打标签失败，请重试")
-    } finally {
-      setBatchLoading(false)
-    }
-  }, [batchTags, selectedIds, tagMode, queryClient, showResult])
-
-  const handleTagInputKeyDown = useCallback(
-    (e: React.KeyboardEvent) => {
-      if (e.key === "Enter" && batchTagInput.trim()) {
-        e.preventDefault()
-        const tag = batchTagInput.trim()
-        if (!batchTags.includes(tag)) {
-          setBatchTags([...batchTags, tag])
-        }
-        setBatchTagInput("")
-      }
-    },
-    [batchTagInput, batchTags],
-  )
-
-  const removeBatchTag = useCallback(
-    (tag: string) => {
-      setBatchTags(batchTags.filter((t) => t !== tag))
-    },
-    [batchTags],
-  )
-
-  return {
-    tagModalOpen,
-    setTagModalOpen,
-    batchTagInput,
-    setBatchTagInput,
-    batchTags,
-    setBatchTags,
-    tagMode,
-    setTagMode,
-    batchLoading,
-    handleBatchTag,
-    handleTagInputKeyDown,
-    removeBatchTag,
-  }
-}
-
-/* ── 批量改分类 ── */
-interface UseBatchClassifyOptions {
-  selectedIds: Set<string>
-  queryClient: ReturnType<typeof import("@tanstack/react-query").useQueryClient>
-  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
-}
-
-export const useBatchClassify = ({
-  selectedIds,
-  queryClient,
-  showResult,
-}: UseBatchClassifyOptions) => {
-  const [classifyModalOpen, setClassifyModalOpen] = useState(false)
-  const [batchCategory, setBatchCategory] = useState("")
-  const [batchLoading, setBatchLoading] = useState(false)
-
-  const handleBatchClassify = useCallback(async () => {
-    if (!batchCategory) {
-      message.warning("请选择分类")
-      return
-    }
-    const ids = Array.from(selectedIds)
-    setBatchLoading(true)
-    try {
-      const result = await batchClassifyAssets({
-        asset_ids: ids,
-        category: batchCategory,
-      })
-      queryClient.invalidateQueries({ queryKey: ["assets"] })
-      showResult(result, "批量改分类")
-      setClassifyModalOpen(false)
-      setBatchCategory("")
-      if (result.failure_count === 0) {
-        message.success(`成功将 ${result.success_count} 个素材改为「${batchCategory}」`)
-      } else {
-        message.warning(
-          `改分类完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
-        )
-      }
-    } catch {
-      message.error("批量改分类失败，请重试")
-    } finally {
-      setBatchLoading(false)
-    }
-  }, [batchCategory, selectedIds, queryClient, showResult])
-
-  return {
-    classifyModalOpen,
-    setClassifyModalOpen,
-    batchCategory,
-    setBatchCategory,
-    batchLoading,
-    handleBatchClassify,
-  }
-}
-
-/* ── 批量智能标记 ── */
-interface UseBatchMarkOptions {
-  selectedIds: Set<string>
-  queryClient: ReturnType<typeof import("@tanstack/react-query").useQueryClient>
-  showResult: (result: BatchOperationResult, title: string, clear?: boolean) => void
-}
-
-export const useBatchMark = ({ selectedIds, queryClient, showResult }: UseBatchMarkOptions) => {
-  const [markModalOpen, setMarkModalOpen] = useState(false)
-  const [batchSmartView, setBatchSmartView] = useState<SmartViewType>("recommended")
-  const [batchLoading, setBatchLoading] = useState(false)
-
-  const handleBatchMark = useCallback(async () => {
-    const ids = Array.from(selectedIds)
-    setBatchLoading(true)
-    try {
-      const result = await batchMarkAssets({
-        asset_ids: ids,
-        smart_view: batchSmartView,
-      })
-      queryClient.invalidateQueries({ queryKey: ["assets"] })
-      showResult(result, "批量智能标记")
-      setMarkModalOpen(false)
-      if (result.failure_count === 0) {
-        message.success(
-          `成功将 ${result.success_count} 个素材标记为「${SMART_VIEW_LABELS[batchSmartView]}」`,
-        )
-      } else {
-        message.warning(
-          `智能标记完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
-        )
-      }
-    } catch {
-      message.error("批量智能标记失败，请重试")
-    } finally {
-      setBatchLoading(false)
-    }
-  }, [batchSmartView, selectedIds, queryClient, showResult])
-
-  return {
-    markModalOpen,
-    setMarkModalOpen,
-    batchSmartView,
-    setBatchSmartView,
-    batchLoading,
-    handleBatchMark,
-  }
-}
+/**
+ * @deprecated 请从 ./batch/ 目录导入子模块
+ * 保持向后兼容，re-export 所有批量操作 Hook
+ */
+export { useBatchDelete } from "./batch/useBatchDelete"
+export { useBatchTag } from "./batch/useBatchTag"
+export { useBatchClassify } from "./batch/useBatchClassify"
+export { useBatchMark } from "./batch/useBatchMark"

apps/web/src/pages/assets/hooks/useAssetOperations.ts

@@ -12,7 +12,7 @@ import {
   useBatchTag,
   useBatchClassify,
   useBatchMark,
-} from "./asset-operations/batchOperations"
+} from "./asset-operations/batch-operations"
 import type { BatchOperationResult } from "@/api/assets"
 import type { SmartViewType } from "../components/BatchMarkModal"
 

apps/web/src/pages/editing-planner/EditingPlanner.css

@@ -3531,52 +3531,143 @@
   color: var(--text-tertiary, #9ca3af);
 }
 
-.tts-voice-grid {
-  display: grid;
-  grid-template-columns: repeat(3, 1fr);
-  gap: 8px;
+.tts-voice-tabs {
+  display: flex;
+  gap: 4px;
+  background: var(--bg-secondary, #f3f4f6);
+  border-radius: var(--radius-md, 8px);
+  padding: 3px;
 }
 
-.tts-voice-card {
+.tts-voice-tab {
+  flex: 1;
   display: flex;
-  flex-direction: column;
   align-items: center;
-  gap: 4px;
-  padding: 10px 6px;
-  border: 1px solid var(--border-primary, #e5e7eb);
-  border-radius: var(--radius-md, 8px);
-  background: var(--bg-surface, #fff);
+  justify-content: center;
+  gap: 6px;
+  padding: 6px 12px;
+  border: none;
+  background: transparent;
+  border-radius: 6px;
+  font-size: 12px;
+  font-weight: 500;
   color: var(--text-secondary, #6b7280);
   cursor: pointer;
   transition: all 0.2s ease;
-  font-size: 12px;
 }
 
-.tts-voice-card:hover:not(:disabled) {
-  border-color: var(--primary-300, #93c5fd);
-  color: var(--primary-600, #2563eb);
-  background: var(--primary-50, #eff6ff);
+.tts-voice-tab:hover {
+  color: var(--text-primary, #1f2937);
 }
 
-.tts-voice-card.active {
-  border-color: var(--primary-500, #3b82f6);
+.tts-voice-tab.active {
+  background: var(--bg-surface, #fff);
   color: var(--primary-600, #2563eb);
-  background: var(--primary-50, #eff6ff);
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08);
+}
+
+.tts-voice-tab-count {
+  font-size: 10px;
+  padding: 1px 6px;
+  background: var(--primary-100, #dbeafe);
+  color: var(--primary-600, #2563eb);
+  border-radius: 10px;
   font-weight: 600;
 }
 
-.tts-voice-card:disabled {
-  opacity: 0.5;
-  cursor: not-allowed;
+.tts-voice-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  max-height: 200px;
+  overflow-y: auto;
 }
 
-.tts-voice-card-icon {
-  font-size: 22px;
+.tts-voice-item {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 8px 10px;
+  border: 1px solid var(--border-primary, #e5e7eb);
+  border-radius: var(--radius-md, 8px);
+  background: var(--bg-surface, #fff);
+  cursor: pointer;
+  transition: all 0.2s ease;
 }
 
-.tts-voice-card-name {
+.tts-voice-item:hover {
+  border-color: var(--primary-300, #93c5fd);
+  background: var(--primary-50, #eff6ff);
+}
+
+.tts-voice-item.selected {
+  border-color: var(--primary-500, #3b82f6);
+  background: var(--primary-50, #eff6ff);
+}
+
+.tts-voice-item-icon {
+  font-size: 20px;
+  flex-shrink: 0;
+  width: 28px;
+  height: 28px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--bg-secondary, #f3f4f6);
+  border-radius: 50%;
+}
+
+.tts-voice-item-info {
+  flex: 1;
+  min-width: 0;
+}
+
+.tts-voice-item-name {
+  font-size: 13px;
+  font-weight: 500;
+  color: var(--text-primary, #1f2937);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.tts-voice-item-desc {
   font-size: 11px;
+  color: var(--text-tertiary, #9ca3af);
+  margin-top: 2px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.tts-voice-item-play {
+  flex-shrink: 0;
+  width: 26px;
+  height: 26px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: none;
+  background: var(--primary-500, #3b82f6);
+  color: #fff;
+  border-radius: 50%;
+  font-size: 11px;
+  cursor: pointer;
+  transition: all 0.2s ease;
+}
+
+.tts-voice-item-play:hover {
+  background: var(--primary-600, #2563eb);
+  transform: scale(1.08);
+}
+
+.tts-voice-empty {
+  padding: 20px;
   text-align: center;
+  font-size: 12px;
+  color: var(--text-tertiary, #9ca3af);
+  background: var(--bg-secondary, #f3f4f6);
+  border-radius: var(--radius-md, 8px);
 }
 
 /* ── 滑块区域 ── */

apps/web/src/pages/editing-planner/components/PipConfigPanel/components/LayerConfig.tsx

@@ -0,0 +1,268 @@
+import React from "react"
+import type { PipLayer, PipGridPosition, PipAnimType, PipSlideDirection } from "../../../types"
+import { GRID_POSITIONS, ANIM_OPTIONS, SLIDE_DIR_OPTIONS } from "../constants"
+
+export interface LayerConfigProps {
+  layer: PipLayer
+  totalDuration: number
+  onUpdate: (id: string, partial: Partial<PipLayer>) => void
+  onGridClick: (pos: PipGridPosition) => void
+  onWidthChange: (val: number) => void
+  onHeightChange: (val: number) => void
+}
+
+export const LayerConfig: React.FC<LayerConfigProps> = ({
+  layer,
+  totalDuration,
+  onUpdate,
+  onGridClick,
+  onWidthChange,
+  onHeightChange,
+}) => {
+  return (
+    <div className="pip-config-area">
+      {/* ── 素材类型 ── */}
+      <div className="pip-field">
+        <label className="pip-field-label">素材类型</label>
+        <div className="pip-type-btns">
+          <button
+            className={`pip-type-btn${layer.material_type === "image" ? " active" : ""}`}
+            onClick={() => onUpdate(layer.id, { material_type: "image" })}
+          >
+            🖼️ 图片
+          </button>
+          <button
+            className={`pip-type-btn${layer.material_type === "video" ? " active" : ""}`}
+            onClick={() => onUpdate(layer.id, { material_type: "video" })}
+          >
+            🎬 视频
+          </button>
+        </div>
+      </div>
+
+      {/* ── 素材 URL ── */}
+      <div className="pip-field">
+        <label className="pip-field-label">
+          {layer.material_type === "image" ? "图片" : "视频"} URL
+        </label>
+        <input
+          className="pip-input"
+          type="text"
+          placeholder={
+            layer.material_type === "image"
+              ? "https://example.com/image.png"
+              : "https://example.com/video.mp4"
+          }
+          value={layer.material_url}
+          onChange={(e) => onUpdate(layer.id, { material_url: e.target.value })}
+        />
+      </div>
+
+      {/* ── 位置：九宫格 + 坐标 ── */}
+      <div className="pip-field">
+        <label className="pip-field-label">位置</label>
+        <div style={{ display: "flex", gap: 16, alignItems: "flex-start" }}>
+          <div className="pip-grid">
+            {GRID_POSITIONS.map((pos) => (
+              <button
+                key={pos}
+                className={`pip-grid-btn${layer.grid_position === pos ? " active" : ""}`}
+                onClick={() => onGridClick(pos)}
+              >
+                <span className="pip-grid-dot" />
+              </button>
+            ))}
+          </div>
+          <div className="pip-field-row" style={{ flex: 1 }}>
+            <div>
+              <label className="pip-field-label">X (%)</label>
+              <input
+                className="pip-number"
+                type="number"
+                min={0}
+                max={100}
+                value={layer.x}
+                onChange={(e) => {
+                  const val = Number(e.target.value)
+                  if (!isNaN(val) && val >= 0 && val <= 100) onUpdate(layer.id, { x: val })
+                }}
+              />
+            </div>
+            <div>
+              <label className="pip-field-label">Y (%)</label>
+              <input
+                className="pip-number"
+                type="number"
+                min={0}
+                max={100}
+                value={layer.y}
+                onChange={(e) => {
+                  const val = Number(e.target.value)
+                  if (!isNaN(val) && val >= 0 && val <= 100) onUpdate(layer.id, { y: val })
+                }}
+              />
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* ── 尺寸 ── */}
+      <div className="pip-field">
+        <label className="pip-field-label">尺寸</label>
+        <div className="pip-slider-row">
+          <span style={{ fontSize: 12, color: "#999", width: 20 }}>宽</span>
+          <input
+            className="pip-slider"
+            type="range"
+            min={10}
+            max={80}
+            value={layer.width}
+            onChange={(e) => {
+              const val = Number(e.target.value)
+              if (!isNaN(val)) onWidthChange(val)
+            }}
+          />
+          <span className="pip-slider-value">{layer.width}%</span>
+        </div>
+        <div className="pip-slider-row" style={{ marginTop: 6 }}>
+          <span style={{ fontSize: 12, color: "#999", width: 20 }}>高</span>
+          <input
+            className="pip-slider"
+            type="range"
+            min={10}
+            max={80}
+            value={layer.height}
+            onChange={(e) => {
+              const val = Number(e.target.value)
+              if (!isNaN(val)) onHeightChange(val)
+            }}
+          />
+          <span className="pip-slider-value">{layer.height}%</span>
+        </div>
+        <div
+          className="pip-lock-row"
+          style={{ marginTop: 6 }}
+          onClick={() => onUpdate(layer.id, { aspect_lock: !layer.aspect_lock })}
+        >
+          <span className="pip-lock-icon">{layer.aspect_lock ? "🔒" : "🔓"}</span>
+          <span>{layer.aspect_lock ? "已锁定比例" : "锁定宽高比"}</span>
+        </div>
+      </div>
+
+      {/* ── 圆角 ── */}
+      <div className="pip-field">
+        <label className="pip-field-label">圆角</label>
+        <div className="pip-slider-row">
+          <input
+            className="pip-slider"
+            type="range"
+            min={0}
+            max={50}
+            value={layer.border_radius}
+            onChange={(e) => {
+              const val = Number(e.target.value)
+              if (!isNaN(val)) onUpdate(layer.id, { border_radius: val })
+            }}
+          />
+          <span className="pip-slider-value">{layer.border_radius}%</span>
+        </div>
+      </div>
+
+      {/* ── 透明度 ── */}
+      <div className="pip-field">
+        <label className="pip-field-label">透明度</label>
+        <div className="pip-slider-row">
+          <input
+            className="pip-slider"
+            type="range"
+            min={0}
+            max={100}
+            value={layer.opacity}
+            onChange={(e) => {
+              const val = Number(e.target.value)
+              if (!isNaN(val)) onUpdate(layer.id, { opacity: val })
+            }}
+          />
+          <span className="pip-slider-value">{layer.opacity}%</span>
+        </div>
+      </div>
+
+      {/* ── 时间 ── */}
+      <div className="pip-field">
+        <label className="pip-field-label">时间</label>
+        <div className="pip-field-row">
+          <div>
+            <label className="pip-field-label">开始 (s)</label>
+            <input
+              className="pip-number"
+              type="number"
+              min={0}
+              max={totalDuration || 999}
+              step={0.1}
+              value={layer.start_time}
+              onChange={(e) => {
+                const val = Number(e.target.value)
+                if (!isNaN(val) && val >= 0 && val <= totalDuration)
+                  onUpdate(layer.id, { start_time: val })
+              }}
+            />
+          </div>
+          <div>
+            <label className="pip-field-label">持续 (s)</label>
+            <input
+              className="pip-number"
+              type="number"
+              min={0.1}
+              max={totalDuration || 999}
+              step={0.1}
+              value={layer.duration}
+              onChange={(e) => {
+                const val = Number(e.target.value)
+                if (!isNaN(val) && val > 0 && val <= totalDuration)
+                  onUpdate(layer.id, { duration: val })
+              }}
+            />
+          </div>
+        </div>
+      </div>
+
+      {/* ── 入场动画 ── */}
+      <div className="pip-field">
+        <label className="pip-field-label">入场动画</label>
+        <select
+          className="pip-select"
+          value={layer.animation}
+          onChange={(e) => onUpdate(layer.id, { animation: e.target.value as PipAnimType })}
+        >
+          {ANIM_OPTIONS.map((opt) => (
+            <option key={opt.value} value={opt.value}>
+              {opt.label}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      {/* 滑入方向（仅 slide_in 时显示） */}
+      {layer.animation === "slide_in" && (
+        <div className="pip-field">
+          <label className="pip-field-label">滑入方向</label>
+          <select
+            className="pip-select"
+            value={layer.slide_direction}
+            onChange={(e) =>
+              onUpdate(layer.id, {
+                slide_direction: e.target.value as PipSlideDirection,
+              })
+            }
+          >
+            {SLIDE_DIR_OPTIONS.map((opt) => (
+              <option key={opt.value} value={opt.value}>
+                {opt.label}
+              </option>
+            ))}
+          </select>
+        </div>
+      )}
+    </div>
+  )
+}

apps/web/src/pages/editing-planner/components/PipConfigPanel/components/LayerList.tsx

@@ -0,0 +1,58 @@
+import React from "react"
+import type { PipLayer } from "../../../types"
+import { LAYER_COLORS } from "../constants"
+
+export interface LayerListProps {
+  layers: PipLayer[]
+  selectedId: string
+  onSelect: (id: string) => void
+  onDelete: (id: string) => void
+}
+
+export const LayerList: React.FC<LayerListProps> = ({ layers, selectedId, onSelect, onDelete }) => {
+  if (layers.length === 0) {
+    return (
+      <div className="pip-layer-list">
+        <div className="pip-layer-empty">暂无图层，点击上方添加</div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="pip-layer-list">
+      {layers.map((layer, idx) => (
+        <div
+          key={layer.id}
+          className={`pip-layer-item${selectedId === layer.id ? " active" : ""}`}
+          onClick={() => onSelect(layer.id)}
+        >
+          {layer.thumbnail_url || layer.material_url ? (
+            <img
+              className="pip-layer-thumb"
+              src={layer.thumbnail_url || layer.material_url || undefined}
+              alt={layer.name}
+            />
+          ) : (
+            <div
+              className="pip-layer-thumb"
+              style={{
+                background: LAYER_COLORS[idx % LAYER_COLORS.length],
+              }}
+            />
+          )}
+          <span className="pip-layer-name">{layer.name}</span>
+          <button
+            className="pip-layer-delete"
+            onClick={(e) => {
+              e.stopPropagation()
+              onDelete(layer.id)
+            }}
+            title="删除图层"
+          >
+            ✕
+          </button>
+        </div>
+      ))}
+    </div>
+  )
+}

apps/web/src/pages/editing-planner/components/PipConfigPanel/components/PipPreview.tsx

@@ -0,0 +1,33 @@
+import React from "react"
+import type { PipLayer } from "../../../types"
+import { LAYER_COLORS } from "../constants"
+
+export interface PipPreviewProps {
+  layers: PipLayer[]
+  selectedId: string
+}
+
+export const PipPreview: React.FC<PipPreviewProps> = ({ layers, selectedId }) => {
+  return (
+    <div className="pip-preview-box">
+      {layers.map((layer, idx) => (
+        <div
+          key={layer.id}
+          className={`pip-preview-layer${selectedId === layer.id ? " selected" : ""}`}
+          style={{
+            left: `${layer.x}%`,
+            top: `${layer.y}%`,
+            width: `${layer.width}%`,
+            height: `${layer.height}%`,
+            background: LAYER_COLORS[idx % LAYER_COLORS.length],
+            opacity: layer.opacity / 100,
+            borderRadius: `${layer.border_radius}%`,
+            zIndex: layer.z_index,
+          }}
+        >
+          <span className="pip-preview-label">{layer.name}</span>
+        </div>
+      ))}
+    </div>
+  )
+}

apps/web/src/pages/editing-planner/components/PipConfigPanel/constants.ts

@@ -0,0 +1,55 @@
+import type { PipGridPosition, PipAnimType, PipSlideDirection } from "../../types"
+
+/** 九宫格位置 → 百分比坐标映射 */
+export const GRID_POSITION_MAP: Record<PipGridPosition, { x: number; y: number }> = {
+  top_left: { x: 5, y: 5 },
+  top_center: { x: 37.5, y: 5 },
+  top_right: { x: 70, y: 5 },
+  center_left: { x: 5, y: 37.5 },
+  center: { x: 37.5, y: 37.5 },
+  center_right: { x: 70, y: 37.5 },
+  bottom_left: { x: 5, y: 70 },
+  bottom_center: { x: 37.5, y: 70 },
+  bottom_right: { x: 70, y: 70 },
+}
+
+/** 九宫格位置选项 */
+export const GRID_POSITIONS: PipGridPosition[] = [
+  "top_left",
+  "top_center",
+  "top_right",
+  "center_left",
+  "center",
+  "center_right",
+  "bottom_left",
+  "bottom_center",
+  "bottom_right",
+]
+
+/** 入场动画选项 */
+export const ANIM_OPTIONS: { value: PipAnimType; label: string }[] = [
+  { value: "none", label: "无" },
+  { value: "fade_in", label: "淡入" },
+  { value: "slide_in", label: "滑入" },
+]
+
+/** 滑入方向选项 */
+export const SLIDE_DIR_OPTIONS: { value: PipSlideDirection; label: string }[] = [
+  { value: "left", label: "← 左" },
+  { value: "right", label: "→ 右" },
+  { value: "up", label: "↑ 上" },
+  { value: "down", label: "↓ 下" },
+]
+
+/** 预览图层颜色池 */
+export const LAYER_COLORS = [
+  "rgba(22,119,255,0.5)",
+  "rgba(82,196,26,0.5)",
+  "rgba(250,173,20,0.5)",
+  "rgba(255,77,79,0.5)",
+  "rgba(114,46,209,0.5)",
+  "rgba(19,194,194,0.5)",
+]
+
+let layerIdCounter = 0
+export const genLayerId = () => `pip_layer_${Date.now()}_${++layerIdCounter}`

apps/web/src/pages/editing-planner/components/PipConfigPanel/hooks/usePipConfigPanel.ts

@@ -0,0 +1,130 @@
+import { useState, useCallback, useMemo } from "react"
+import type { PipConfig, PipLayer, PipGridPosition } from "../../../types"
+import { DEFAULT_PIP_LAYER, DEFAULT_PIP_CONFIG } from "../../../types"
+import { GRID_POSITION_MAP, genLayerId } from "../constants"
+
+const MIN_DIMENSION = 10
+const MAX_DIMENSION = 80
+
+interface UsePipConfigPanelOptions {
+  config: PipConfig
+  onChange: (config: PipConfig) => void
+}
+
+export const usePipConfigPanel = ({ config, onChange }: UsePipConfigPanelOptions) => {
+  const [selectedId, setSelectedId] = useState<string>("")
+
+  const selectedLayer = useMemo(
+    () => config.layers.find((l) => l.id === selectedId) ?? null,
+    [config.layers, selectedId],
+  )
+
+  /* ── 添加图层 ── */
+  const handleAddLayer = useCallback(() => {
+    const newLayer: PipLayer = {
+      ...DEFAULT_PIP_LAYER,
+      id: genLayerId(),
+      name: `图层 ${config.layers.length + 1}`,
+      z_index: config.layers.length + 1,
+    }
+    onChange({
+      ...config,
+      layers: [...config.layers, newLayer],
+    })
+    setSelectedId(newLayer.id)
+  }, [config, onChange])
+
+  /* ── 删除图层 ── */
+  const handleDeleteLayer = useCallback(
+    (id: string) => {
+      const newLayers = config.layers.filter((l) => l.id !== id)
+      onChange({ ...config, layers: newLayers })
+      if (selectedId === id) {
+        setSelectedId(newLayers.length > 0 ? newLayers[0].id : "")
+      }
+    },
+    [config, onChange, selectedId],
+  )
+
+  /* ── 更新图层 ── */
+  const updateLayer = useCallback(
+    (id: string, partial: Partial<PipLayer>) => {
+      onChange({
+        ...config,
+        layers: config.layers.map((l) => (l.id === id ? { ...l, ...partial } : l)),
+      })
+    },
+    [config, onChange],
+  )
+
+  /* ── 切换启用 ── */
+  const handleEnableToggle = useCallback(
+    (checked: boolean) => {
+      onChange({ ...config, enabled: checked })
+    },
+    [config, onChange],
+  )
+
+  /* ── 重置 ── */
+  const handleReset = useCallback(() => {
+    onChange({ ...DEFAULT_PIP_CONFIG })
+    setSelectedId("")
+  }, [onChange])
+
+  /* ── 九宫格点击 ── */
+  const handleGridClick = useCallback(
+    (pos: PipGridPosition) => {
+      if (!selectedLayer) return
+      const coords = GRID_POSITION_MAP[pos]
+      updateLayer(selectedLayer.id, {
+        grid_position: pos,
+        x: coords.x,
+        y: coords.y,
+      })
+    },
+    [selectedLayer, updateLayer],
+  )
+
+  /* ── 宽高变化 ── */
+  const handleWidthChange = useCallback(
+    (val: number) => {
+      if (!selectedLayer) return
+      const partial: Partial<PipLayer> = { width: val }
+      if (selectedLayer.aspect_lock && selectedLayer.height > 0) {
+        const ratio = selectedLayer.width / selectedLayer.height
+        const newHeight = Math.round(val / ratio)
+        partial.height = Math.max(MIN_DIMENSION, Math.min(MAX_DIMENSION, newHeight))
+      }
+      updateLayer(selectedLayer.id, partial)
+    },
+    [selectedLayer, updateLayer],
+  )
+
+  const handleHeightChange = useCallback(
+    (val: number) => {
+      if (!selectedLayer) return
+      const partial: Partial<PipLayer> = { height: val }
+      if (selectedLayer.aspect_lock && selectedLayer.width > 0 && selectedLayer.height > 0) {
+        const ratio = selectedLayer.width / selectedLayer.height
+        const newWidth = Math.round(val * ratio)
+        partial.width = Math.max(MIN_DIMENSION, Math.min(MAX_DIMENSION, newWidth))
+      }
+      updateLayer(selectedLayer.id, partial)
+    },
+    [selectedLayer, updateLayer],
+  )
+
+  return {
+    selectedId,
+    setSelectedId,
+    selectedLayer,
+    handleAddLayer,
+    handleDeleteLayer,
+    updateLayer,
+    handleEnableToggle,
+    handleReset,
+    handleGridClick,
+    handleWidthChange,
+    handleHeightChange,
+  }
+}

apps/web/src/pages/editing-planner/components/PipConfigPanel/index.tsx

@@ -4,12 +4,14 @@
  */
 import React from "react"
 import { Drawer, Switch } from "antd"
-import type { PipConfig } from "@/pages/editing-planner/types"
-import LayerList from "./pip-config/LayerList"
-import LayerConfig from "./pip-config/LayerConfig"
-import { usePipLayers } from "@/pages/editing-planner/hooks/usePipLayers"
+import type { PipConfig } from "../../types"
 
-interface PipConfigPanelProps {
+import { usePipConfigPanel } from "./hooks/usePipConfigPanel"
+import { LayerList } from "./components/LayerList"
+import { PipPreview } from "./components/PipPreview"
+import { LayerConfig } from "./components/LayerConfig"
+
+export interface PipConfigPanelProps {
   open: boolean
   onClose: () => void
   config: PipConfig
@@ -36,7 +38,7 @@ const PipConfigPanel: React.FC<PipConfigPanelProps> = ({
     handleGridClick,
     handleWidthChange,
     handleHeightChange,
-  } = usePipLayers({ config, onChange })
+  } = usePipConfigPanel({ config, onChange })
 
   return (
     <Drawer
@@ -50,7 +52,9 @@ const PipConfigPanel: React.FC<PipConfigPanelProps> = ({
       {/* ═══ 顶部工具栏 ═══ */}
       <div className="pip-toolbar">
         <div className="pip-toolbar-left">
-          <span style={{ fontSize: 13, color: "#666" }}>共 {config.layers.length} 个图层</span>
+          <button className="pip-add-btn" onClick={handleAddLayer}>
+            + 添加图层
+          </button>
         </div>
         <div className="pip-enable-switch">
           <span>启用</span>
@@ -60,22 +64,32 @@ const PipConfigPanel: React.FC<PipConfigPanelProps> = ({
 
       {/* ═══ 主体：图层列表 + 配置区 ═══ */}
       <div className="pip-body">
+        {/* 左侧图层列表 */}
         <LayerList
           layers={config.layers}
           selectedId={selectedId}
           onSelect={setSelectedId}
-          onAdd={handleAddLayer}
           onDelete={handleDeleteLayer}
         />
-        <LayerConfig
-          layer={selectedLayer}
-          layers={config.layers}
-          totalDuration={totalDuration}
-          onUpdate={updateLayer}
-          onGridClick={handleGridClick}
-          onWidthChange={handleWidthChange}
-          onHeightChange={handleHeightChange}
-        />
+
+        {/* 右侧配置区 */}
+        {!selectedLayer ? (
+          <div className="pip-config-area">
+            <div className="pip-config-empty">选择或添加图层以配置</div>
+          </div>
+        ) : (
+          <>
+            <PipPreview layers={config.layers} selectedId={selectedId} />
+            <LayerConfig
+              layer={selectedLayer}
+              totalDuration={totalDuration}
+              onUpdate={updateLayer}
+              onGridClick={handleGridClick}
+              onWidthChange={handleWidthChange}
+              onHeightChange={handleHeightChange}
+            />
+          </>
+        )}
       </div>
 
       {/* ── 底部操作 ── */}

apps/web/src/pages/editing-planner/components/StickerPanel/components/StickerList.tsx

@@ -0,0 +1,57 @@
+import React from "react"
+import type { StickerItem } from "../../../types"
+
+export interface StickerListProps {
+  items: StickerItem[]
+  selectedId: string | null
+  onSelect: (id: string) => void
+  onRemove: (id: string) => void
+}
+
+export const StickerList: React.FC<StickerListProps> = ({
+  items,
+  selectedId,
+  onSelect,
+  onRemove,
+}) => {
+  if (items.length === 0) return null
+
+  const getStickerDisplay = (item: StickerItem) => {
+    if (item.type === "emoji") return item.content
+    if (item.type === "text") return item.content.slice(0, 10)
+    return "🖼"
+  }
+
+  const getStickerName = (item: StickerItem) => {
+    if (item.type === "text") return item.content.slice(0, 10)
+    if (item.type === "emoji") return "表情贴纸"
+    return "图片贴纸"
+  }
+
+  return (
+    <div className="sticker-list-section">
+      <div className="sticker-section-title">已添加贴纸 ({items.length})</div>
+      <div className="sticker-list">
+        {items.map((item) => (
+          <div
+            key={item.id}
+            className={`sticker-list-item${selectedId === item.id ? " active" : ""}`}
+            onClick={() => onSelect(item.id)}
+          >
+            <span className="sticker-list-icon">{getStickerDisplay(item)}</span>
+            <span className="sticker-list-name">{getStickerName(item)}</span>
+            <button
+              className="sticker-list-delete"
+              onClick={(e) => {
+                e.stopPropagation()
+                onRemove(item.id)
+              }}
+            >
+              ✕
+            </button>
+          </div>
+        ))}
+      </div>
+    </div>
+  )
+}

apps/web/src/pages/editing-planner/components/StickerPanel/components/StickerPropsEditor.tsx

@@ -0,0 +1,203 @@
+import React from "react"
+import type { StickerItem, TextStickerPreset } from "../../../types"
+import { TEXT_STICKER_PRESET_LABELS } from "../../../types"
+import { TEXT_PRESET_STYLES } from "../constants"
+
+export interface StickerPropsEditorProps {
+  sticker: StickerItem
+  totalDuration: number
+  onChange: (id: string, partial: Partial<StickerItem>) => void
+}
+
+export const StickerPropsEditor: React.FC<StickerPropsEditorProps> = ({
+  sticker,
+  totalDuration,
+  onChange,
+}) => {
+  const update = (partial: Partial<StickerItem>) => {
+    onChange(sticker.id, partial)
+  }
+
+  return (
+    <div className="sticker-props-section">
+      <div className="sticker-section-title">属性调整</div>
+
+      {/* 位置 X */}
+      <div className="sticker-prop-row">
+        <span className="sticker-prop-label">位置 X</span>
+        <input
+          type="range"
+          className="sticker-prop-slider"
+          min={0}
+          max={100}
+          value={sticker.x}
+          onChange={(e) => update({ x: Number(e.target.value) })}
+        />
+        <span className="sticker-prop-value">{sticker.x}%</span>
+      </div>
+
+      {/* 位置 Y */}
+      <div className="sticker-prop-row">
+        <span className="sticker-prop-label">位置 Y</span>
+        <input
+          type="range"
+          className="sticker-prop-slider"
+          min={0}
+          max={100}
+          value={sticker.y}
+          onChange={(e) => update({ y: Number(e.target.value) })}
+        />
+        <span className="sticker-prop-value">{sticker.y}%</span>
+      </div>
+
+      {/* 尺寸 */}
+      <div className="sticker-prop-row">
+        <span className="sticker-prop-label">大小</span>
+        <input
+          type="range"
+          className="sticker-prop-slider"
+          min={5}
+          max={50}
+          value={sticker.width}
+          onChange={(e) =>
+            update({
+              width: Number(e.target.value),
+              height: Number(e.target.value),
+            })
+          }
+        />
+        <span className="sticker-prop-value">{sticker.width}%</span>
+      </div>
+
+      {/* 旋转 */}
+      <div className="sticker-prop-row">
+        <span className="sticker-prop-label">旋转</span>
+        <input
+          type="range"
+          className="sticker-prop-slider"
+          min={-180}
+          max={180}
+          value={sticker.rotation}
+          onChange={(e) => update({ rotation: Number(e.target.value) })}
+        />
+        <span className="sticker-prop-value">{sticker.rotation}°</span>
+      </div>
+
+      {/* 透明度 */}
+      <div className="sticker-prop-row">
+        <span className="sticker-prop-label">透明度</span>
+        <input
+          type="range"
+          className="sticker-prop-slider"
+          min={0}
+          max={100}
+          value={sticker.opacity}
+          onChange={(e) => update({ opacity: Number(e.target.value) })}
+        />
+        <span className="sticker-prop-value">{sticker.opacity}%</span>
+      </div>
+
+      {/* 时间 */}
+      <div className="sticker-prop-row">
+        <span className="sticker-prop-label">开始</span>
+        <input
+          type="number"
+          className="sticker-prop-number"
+          min={0}
+          max={totalDuration}
+          step={0.1}
+          value={sticker.start_time}
+          onChange={(e) => {
+            const val = Number(e.target.value)
+            if (!isNaN(val) && val >= 0 && val <= totalDuration) update({ start_time: val })
+          }}
+        />
+        <span className="sticker-prop-label">时长</span>
+        <input
+          type="number"
+          className="sticker-prop-number"
+          min={0}
+          max={totalDuration}
+          step={0.1}
+          value={sticker.duration}
+          onChange={(e) => {
+            const val = Number(e.target.value)
+            if (!isNaN(val) && val > 0 && val <= totalDuration) update({ duration: val })
+          }}
+        />
+      </div>
+
+      {/* 文字贴纸特有属性 */}
+      {sticker.type === "text" && (
+        <>
+          <div className="sticker-prop-row">
+            <span className="sticker-prop-label">花字</span>
+            <select
+              className="sticker-prop-select"
+              value={sticker.text_preset}
+              onChange={(e) => update({ text_preset: e.target.value as TextStickerPreset })}
+            >
+              {(Object.keys(TEXT_STICKER_PRESET_LABELS) as TextStickerPreset[]).map((p) => (
+                <option key={p} value={p}>
+                  {TEXT_STICKER_PRESET_LABELS[p]}
+                </option>
+              ))}
+            </select>
+          </div>
+          <div className="sticker-prop-row">
+            <span className="sticker-prop-label">字号</span>
+            <input
+              type="range"
+              className="sticker-prop-slider"
+              min={12}
+              max={72}
+              value={sticker.font_size}
+              onChange={(e) => update({ font_size: Number(e.target.value) })}
+            />
+            <span className="sticker-prop-value">{sticker.font_size}px</span>
+          </div>
+          <div className="sticker-prop-row">
+            <span className="sticker-prop-label">颜色</span>
+            <input
+              type="color"
+              className="sticker-prop-color"
+              value={sticker.text_color}
+              onChange={(e) => update({ text_color: e.target.value })}
+            />
+          </div>
+        </>
+      )}
+
+      {/* 预览 */}
+      <div className="sticker-preview-box">
+        <div
+          className="sticker-preview-item"
+          style={{
+            left: `${sticker.x}%`,
+            top: `${sticker.y}%`,
+            width: `${sticker.width}%`,
+            height: `${sticker.width}%`,
+            transform: `translate(-50%, -50%) rotate(${sticker.rotation}deg)`,
+            opacity: sticker.opacity / 100,
+            fontSize: sticker.type === "text" ? `${sticker.font_size}px` : undefined,
+            ...TEXT_PRESET_STYLES[sticker.text_preset],
+          }}
+        >
+          {sticker.type === "emoji" && sticker.content}
+          {sticker.type === "text" && sticker.content}
+          {sticker.type === "image" && (
+            <img
+              src={sticker.content}
+              alt="sticker"
+              style={{
+                width: "100%",
+                height: "100%",
+                objectFit: "contain",
+              }}
+            />
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}

apps/web/src/pages/editing-planner/components/StickerPanel/components/StickerTabs.tsx

@@ -0,0 +1,136 @@
+import React, { useState } from "react"
+import type { StickerType, TextStickerPreset } from "../../../types"
+import { TEXT_STICKER_PRESET_LABELS } from "../../../types"
+import { EMOJI_LIST, TEXT_PRESET_STYLES } from "../constants"
+
+export interface StickerTabsProps {
+  activeTab: StickerType
+  onTabChange: (tab: StickerType) => void
+  textInput: string
+  onTextInputChange: (val: string) => void
+  onAddEmoji: (emoji: string) => void
+  onAddImage: (url: string) => void
+  onAddText: (text: string) => void
+}
+
+export const StickerTabs: React.FC<StickerTabsProps> = ({
+  activeTab,
+  onTabChange,
+  textInput,
+  onTextInputChange,
+  onAddEmoji,
+  onAddImage,
+  onAddText,
+}) => {
+  const [imageUrl, setImageUrl] = useState("")
+
+  const handleImageAdd = () => {
+    if (imageUrl.trim()) {
+      onAddImage(imageUrl.trim())
+      setImageUrl("")
+    }
+  }
+
+  const handleTextAdd = () => {
+    if (textInput.trim()) {
+      onAddText(textInput.trim())
+    }
+  }
+
+  return (
+    <>
+      {/* 类型 Tab */}
+      <div className="sticker-tabs">
+        {(["emoji", "image", "text"] as StickerType[]).map((t) => (
+          <button
+            key={t}
+            className={`sticker-tab${activeTab === t ? " active" : ""}`}
+            onClick={() => onTabChange(t)}
+          >
+            {t === "emoji" ? "表情贴纸" : t === "image" ? "图片贴纸" : "文字花字"}
+          </button>
+        ))}
+      </div>
+
+      {/* Tab 内容区 */}
+      <div className="sticker-tab-content">
+        {/* Emoji 素材库 */}
+        {activeTab === "emoji" && (
+          <div className="sticker-emoji-grid">
+            {EMOJI_LIST.map((emoji) => (
+              <button key={emoji} className="sticker-emoji-btn" onClick={() => onAddEmoji(emoji)}>
+                {emoji}
+              </button>
+            ))}
+          </div>
+        )}
+
+        {/* 图片贴纸 */}
+        {activeTab === "image" && (
+          <div className="sticker-image-input">
+            <input
+              type="text"
+              className="sticker-url-input"
+              placeholder="输入图片 URL 添加贴纸..."
+              value={imageUrl}
+              onChange={(e) => setImageUrl(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === "Enter" && imageUrl.trim()) {
+                  onAddImage(imageUrl.trim())
+                  setImageUrl("")
+                }
+              }}
+            />
+            <button className="sticker-url-add-btn" onClick={handleImageAdd}>
+              添加
+            </button>
+          </div>
+        )}
+
+        {/* 文字花字 */}
+        {activeTab === "text" && (
+          <div className="sticker-text-section">
+            <div className="sticker-text-input-row">
+              <input
+                type="text"
+                className="sticker-text-input"
+                placeholder="输入文字内容..."
+                value={textInput}
+                onChange={(e) => onTextInputChange(e.target.value)}
+              />
+              <button
+                className="sticker-text-add-btn"
+                disabled={!textInput.trim()}
+                onClick={handleTextAdd}
+              >
+                添加
+              </button>
+            </div>
+            <div className="sticker-text-presets">
+              <div className="sticker-preset-title">花字预设预览</div>
+              <div className="sticker-preset-grid">
+                {(Object.keys(TEXT_STICKER_PRESET_LABELS) as TextStickerPreset[]).map((p) => (
+                  <div
+                    key={p}
+                    className="sticker-preset-preview"
+                    style={{
+                      background:
+                        p === "bubble"
+                          ? "rgba(0,0,0,0.5)"
+                          : p === "gradient"
+                            ? "linear-gradient(90deg,#f093fb,#f5576c)"
+                            : "#1a1a2e",
+                    }}
+                  >
+                    <span style={TEXT_PRESET_STYLES[p]}>示例</span>
+                    <div className="sticker-preset-name">{TEXT_STICKER_PRESET_LABELS[p]}</div>
+                  </div>
+                ))}
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+    </>
+  )
+}

apps/web/src/pages/editing-planner/components/StickerPanel/constants.ts

@@ -0,0 +1,54 @@
+import type { CSSProperties } from "react"
+import type { TextStickerPreset } from "../../types"
+
+/** 常用 emoji 素材 */
+export const EMOJI_LIST = [
+  "😀",
+  "😂",
+  "🥰",
+  "😎",
+  "🤩",
+  "😱",
+  "🤔",
+  "😴",
+  "🥳",
+  "😍",
+  "❤️",
+  "🔥",
+  "⭐",
+  "✨",
+  "💯",
+  "👍",
+  "👏",
+  "🎉",
+  "🎵",
+  "💪",
+  "📌",
+  "💡",
+  "🎯",
+  "✅",
+  "❌",
+  "⬆️",
+  "⬇️",
+  "➡️",
+  "⭕",
+  "🔔",
+]
+
+/** 文字花字预设对应的 CSS 样式预览 */
+export const TEXT_PRESET_STYLES: Record<TextStickerPreset, CSSProperties> = {
+  normal: { color: "#fff", textShadow: "none" },
+  highlight: { color: "#FFD700", textShadow: "0 0 8px rgba(255,215,0,0.6)" },
+  bubble: { color: "#fff", background: "rgba(0,0,0,0.5)", borderRadius: 8 },
+  neon: { color: "#0ff", textShadow: "0 0 6px #0ff, 0 0 12px #0ff" },
+  shadow: { color: "#fff", textShadow: "2px 2px 4px rgba(0,0,0,0.8)" },
+  outline: { color: "#fff", WebkitTextStroke: "1px #000" },
+  gradient: {
+    color: "transparent",
+    background: "linear-gradient(90deg,#f093fb,#f5576c)",
+    WebkitBackgroundClip: "text",
+  },
+  handwrite: { color: "#333", fontStyle: "italic", fontFamily: "cursive" },
+}
+
+export const genStickerId = () => `sticker_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`

apps/web/src/pages/editing-planner/components/StickerPanel/hooks/useStickerPanel.ts

@@ -0,0 +1,85 @@
+import { useState, useCallback, useMemo } from "react"
+import type { StickerConfig, StickerItem, StickerType } from "../../../types"
+import { DEFAULT_STICKER_CONFIG, DEFAULT_STICKER_ITEM } from "../../../types"
+import { genStickerId } from "../constants"
+
+interface UseStickerPanelOptions {
+  config: StickerConfig
+  onChange: (config: StickerConfig) => void
+  totalDuration: number
+}
+
+export const useStickerPanel = ({ config, onChange, totalDuration }: UseStickerPanelOptions) => {
+  const [selectedId, setSelectedId] = useState<string | null>(null)
+  const [activeTab, setActiveTab] = useState<StickerType>("emoji")
+  const [textInput, setTextInput] = useState("")
+
+  const selectedSticker = useMemo(
+    () => config.items.find((s) => s.id === selectedId) ?? null,
+    [config.items, selectedId],
+  )
+
+  /** 更新单个贴纸 */
+  const updateItem = useCallback(
+    (id: string, partial: Partial<StickerItem>) => {
+      onChange({
+        ...config,
+        items: config.items.map((s) => (s.id === id ? { ...s, ...partial } : s)),
+      })
+    },
+    [config, onChange],
+  )
+
+  /** 添加贴纸 */
+  const addSticker = useCallback(
+    (type: StickerType, content: string) => {
+      const newItem: StickerItem = {
+        ...DEFAULT_STICKER_ITEM,
+        id: genStickerId(),
+        type,
+        content,
+        duration: totalDuration > 0 ? totalDuration : 5,
+        z_index: config.items.length > 0 ? Math.max(...config.items.map((i) => i.z_index)) + 1 : 1,
+      }
+      onChange({
+        ...config,
+        enabled: true,
+        items: [...config.items, newItem],
+      })
+      setSelectedId(newItem.id)
+    },
+    [config, onChange, totalDuration],
+  )
+
+  /** 删除贴纸 */
+  const removeSticker = useCallback(
+    (id: string) => {
+      onChange({
+        ...config,
+        items: config.items.filter((s) => s.id !== id),
+      })
+      if (selectedId === id) setSelectedId(null)
+    },
+    [config, onChange, selectedId],
+  )
+
+  /** 重置所有 */
+  const handleReset = useCallback(() => {
+    onChange({ ...DEFAULT_STICKER_CONFIG, enabled: config.enabled })
+    setSelectedId(null)
+  }, [config.enabled, onChange])
+
+  return {
+    selectedId,
+    setSelectedId,
+    selectedSticker,
+    activeTab,
+    setActiveTab,
+    textInput,
+    setTextInput,
+    updateItem,
+    addSticker,
+    removeSticker,
+    handleReset,
+  }
+}

apps/web/src/pages/editing-planner/components/StickerPanel/index.tsx

@@ -1,16 +1,13 @@
-/**
- * 贴纸配置面板
- * 贴纸素材库（emoji / 图片）+ 文字花字 + 位置大小调整
- */
 import React from "react"
 import { Drawer, Switch } from "antd"
-import type { StickerConfig } from "@/pages/editing-planner/types"
-import StickerLibrary from "./sticker/StickerLibrary"
-import StickerList from "./sticker/StickerList"
-import StickerPropsEditor from "./sticker/StickerPropsEditor"
-import { useStickerItems } from "@/pages/editing-planner/hooks/useStickerItems"
+import type { StickerConfig } from "../../types"
 
-interface StickerPanelProps {
+import { useStickerPanel } from "./hooks/useStickerPanel"
+import { StickerTabs } from "./components/StickerTabs"
+import { StickerList } from "./components/StickerList"
+import { StickerPropsEditor } from "./components/StickerPropsEditor"
+
+export interface StickerPanelProps {
   open: boolean
   onClose: () => void
   config: StickerConfig
@@ -28,14 +25,28 @@ const StickerPanel: React.FC<StickerPanelProps> = ({
   const {
     selectedId,
     setSelectedId,
+    selectedSticker,
     activeTab,
     setActiveTab,
-    selectedSticker,
+    textInput,
+    setTextInput,
     updateItem,
     addSticker,
     removeSticker,
-    handleReset,
-  } = useStickerItems({ config, onChange, totalDuration })
+  } = useStickerPanel({ config, onChange, totalDuration })
+
+  const handleEmojiAdd = (emoji: string) => {
+    addSticker("emoji", emoji)
+  }
+
+  const handleImageAdd = (url: string) => {
+    addSticker("image", url)
+  }
+
+  const handleTextAdd = (text: string) => {
+    addSticker("text", text)
+    setTextInput("")
+  }
 
   return (
     <Drawer
@@ -56,15 +67,23 @@ const StickerPanel: React.FC<StickerPanelProps> = ({
         />
       </div>
 
-      {/* 素材库 + 类型Tab */}
-      <StickerLibrary activeTab={activeTab} onTabChange={setActiveTab} onAddSticker={addSticker} />
+      {/* Tab 选择器 + 内容 */}
+      <StickerTabs
+        activeTab={activeTab}
+        onTabChange={setActiveTab}
+        textInput={textInput}
+        onTextInputChange={setTextInput}
+        onAddEmoji={handleEmojiAdd}
+        onAddImage={handleImageAdd}
+        onAddText={handleTextAdd}
+      />
 
       {/* 已添加贴纸列表 */}
       <StickerList
         items={config.items}
         selectedId={selectedId}
         onSelect={setSelectedId}
-        onDelete={removeSticker}
+        onRemove={removeSticker}
       />
 
       {/* 选中贴纸的属性编辑 */}
@@ -72,16 +91,9 @@ const StickerPanel: React.FC<StickerPanelProps> = ({
         <StickerPropsEditor
           sticker={selectedSticker}
           totalDuration={totalDuration}
-          onUpdate={updateItem}
+          onChange={updateItem}
         />
       )}
-
-      {/* 底部重置 */}
-      <div className="sticker-footer">
-        <button className="sticker-reset-btn" onClick={handleReset}>
-          清空所有贴纸
-        </button>
-      </div>
     </Drawer>
   )
 }

apps/web/src/pages/editing-planner/components/TimelinePanel.tsx

@@ -1,22 +1,32 @@
 /**
  * 水平轨道时间线 — 支持裁剪手柄、分割、右键菜单
- * 时间标尺(20px) + 水平片段卡片轨道(100x100) + HTML5拖拽排序
- * "+" 卡片 → 类型+时长选择器
+ * 时间标尺 + 片段轨道 + HTML5拖拽排序
  *
- * 裁剪交互：
- * - 鼠标悬停片段两端显示拖拽手柄，拖动调整入点/出点
- * - 拖动时实时显示裁剪预览（入点/出点/时长）
- * - 右键片段弹出菜单：分割 / 恢复原始长度 / 删除
+ * 子组件（timeline/）：
+ * - TimeRuler - 时间标尺
+ * - ClipCard - 片段卡片
+ * - ClipTrack - 片段轨道（播放头+片段列表+添加卡片）
+ * - TimelineHeader - 时间线头部（标题+缩放+操作按钮）
+ * - AddClipPicker - 添加片段选择器
+ * - TrimPreview - 裁剪预览 tooltip
+ * - ContextMenu - 右键菜单
+ *
+ * Hooks：
+ * - useClipDrag - 片段拖拽排序
+ * - useTrimDrag - 裁剪拖拽
+ * - useTimelineMenus - 菜单 & 面板
+ * - usePlayheadDrag - 播放头拖拽
  */
-import React, { useState, useRef, useCallback, useEffect } from "react"
+import React from "react"
 import type { ClipData, ClipType, TrimConfig } from "../types"
 import { DEFAULT_PIXELS_PER_SECOND } from "../constants/timeline"
-import { formatTime } from "../utils/timeline"
 import { useClipDrag } from "../hooks/useClipDrag"
 import { useTrimDrag } from "../hooks/useTrimDrag"
 import { useTimelineMenus } from "../hooks/useTimelineMenus"
-import { ClipCard } from "./timeline/ClipCard"
+import { usePlayheadDrag } from "./timeline/hooks/usePlayheadDrag"
 import { TimeRuler } from "./timeline/TimeRuler"
+import { ClipTrack } from "./timeline/ClipTrack"
+import { TimelineHeader } from "./timeline/TimelineHeader"
 import { AddClipPicker } from "./timeline/AddClipPicker"
 import { TrimPreview } from "./timeline/TrimPreview"
 import { ContextMenu } from "./timeline/ContextMenu"
@@ -105,106 +115,32 @@ const TimelinePanel: React.FC<TimelinePanelProps> = ({
     setHoveredClipId,
   } = useTimelineMenus(clips, currentMode, onAddClip, onClipSplit, onClipResetTrim, onClipRemove)
 
-  /* ── 播放头拖拽状态 ── */
-  const [playheadDragging, setPlayheadDragging] = useState(false)
-  const trackRef = useRef<HTMLDivElement>(null)
+  /* ── 播放头拖拽 ── */
+  const { trackRef, handlePlayheadMouseDown, handleRulerClick } = usePlayheadDrag({
+    currentTime,
+    pps,
+    totalDuration,
+    onSeek,
+  })
 
-  /* ── 播放头拖拽全局 mousemove/mouseup ── */
-  useEffect(() => {
-    if (!playheadDragging) return
-
-    const handleMouseMove = (e: MouseEvent) => {
-      const trackEl = trackRef.current
-      if (!trackEl) return
-      const rect = trackEl.getBoundingClientRect()
-      const x = e.clientX - rect.left + trackEl.scrollLeft
-      const time = Math.max(0, Math.min(x / pps, totalDuration))
-      onSeek?.(Math.round(time * 10) / 10)
+  /* ── 撤销最后一个片段 ── */
+  const handleUndoClip = () => {
+    if (clips.length > 1) {
+      const last = clips[clips.length - 1]
+      onClipRemove(last.id)
     }
-
-    const handleMouseUp = () => {
-      setPlayheadDragging(false)
-    }
-
-    document.addEventListener("mousemove", handleMouseMove)
-    document.addEventListener("mouseup", handleMouseUp)
-    return () => {
-      document.removeEventListener("mousemove", handleMouseMove)
-      document.removeEventListener("mouseup", handleMouseUp)
-    }
-  }, [playheadDragging, pps, totalDuration, onSeek])
-
-  /* ── 标尺点击跳转播放头 ── */
-  const handleRulerClick = useCallback(
-    (e: React.MouseEvent<HTMLDivElement>) => {
-      const rect = e.currentTarget.getBoundingClientRect()
-      const x = e.clientX - rect.left
-      const time = Math.max(0, Math.min(x / pps, totalDuration))
-      onSeek?.(Math.round(time * 10) / 10)
-    },
-    [pps, totalDuration, onSeek],
-  )
-
-  /* ── 播放头拖拽开始 ── */
-  const handlePlayheadMouseDown = useCallback((e: React.MouseEvent) => {
-    e.preventDefault()
-    e.stopPropagation()
-    setPlayheadDragging(true)
-  }, [])
+  }
 
   return (
     <div className="ep-timeline-area">
       {/* 时间线头部 */}
-      <div className="ep-timeline-header">
-        <div className="ep-timeline-title">
-          <span>🎬 时间线</span>
-          <span className="ep-timeline-duration">总时长: {formatTime(totalDuration)}</span>
-        </div>
-        <div className="ep-timeline-actions">
-          {/* 缩放控件 */}
-          <div className="ep-timeline-zoom">
-            <button
-              className="ep-zoom-btn"
-              onClick={() => onZoomChange?.(Math.max(10, pps - 10))}
-              title="缩小"
-            >
-              −
-            </button>
-            <input
-              type="range"
-              className="ep-zoom-slider"
-              min={10}
-              max={120}
-              step={5}
-              value={pps}
-              onChange={(e) => onZoomChange?.(Number(e.target.value))}
-            />
-            <button
-              className="ep-zoom-btn"
-              onClick={() => onZoomChange?.(Math.min(120, pps + 10))}
-              title="放大"
-            >
-              +
-            </button>
-            <span className="ep-zoom-label">{pps}px/s</span>
-          </div>
-          <button
-            className="ep-timeline-action-btn"
-            onClick={() => {
-              if (clips.length > 1) {
-                const last = clips[clips.length - 1]
-                onClipRemove(last.id)
-              }
-            }}
-            title="删除最后一个片段"
-          >
-            ↩
-          </button>
-          <button className="ep-timeline-action-btn" title="重做">
-            ↪
-          </button>
-        </div>
-      </div>
+      <TimelineHeader
+        totalDuration={totalDuration}
+        pps={pps}
+        onZoomChange={onZoomChange}
+        onUndoClip={handleUndoClip}
+        clipsCount={clips.length}
+      />
 
       {/* 一镜到底提示 */}
       {currentMode === "one_take" && <div className="ep-one-take-hint">🎥 一镜到底模式无片段</div>}
@@ -216,61 +152,33 @@ const TimelinePanel: React.FC<TimelinePanelProps> = ({
 
       {/* 水平片段轨道 */}
       {currentMode !== "one_take" && (
-        <div className="ep-clip-track" ref={trackRef} onDragOver={handleEmptyDragOver}>
-          {/* 播放头 */}
-          {currentMode !== "one_take" && totalDuration > 0 && (
-            <div
-              className="ep-playhead"
-              style={{ left: currentTime * pps }}
-              onMouseDown={handlePlayheadMouseDown}
-            >
-              <div className="ep-playhead-handle" />
-            </div>
-          )}
-          {clips.length === 0 ? (
-            <div className="ep-track-empty">
-              <div className="ep-track-empty-icon">🎬</div>
-              <div className="ep-track-empty-text">点击右侧 + 添加片段</div>
-            </div>
-          ) : (
-            clips.map((clip, idx) => (
-              <ClipCard
-                key={clip.id}
-                clip={clip}
-                idx={idx}
-                isSelected={selectedClipId === clip.id}
-                isDragging={dragIdx === idx}
-                isDragOver={dragOverIdx === idx}
-                isHovered={hoveredClipId === clip.id}
-                pps={pps}
-                trimDragActive={!!trimDrag}
-                showTrimHandles={!!onClipTrim}
-                onDragStart={handleDragStart}
-                onDragOver={handleDragOver}
-                onDragEnd={handleDragEnd}
-                onDrop={handleDrop}
-                onSelect={onClipSelect}
-                onContextMenu={handleContextMenu}
-                onMouseEnter={() => setHoveredClipId(clip.id)}
-                onMouseLeave={() => setHoveredClipId(null)}
-                onTrimHandleMouseDown={handleTrimHandleMouseDown}
-                onRemove={onClipRemove}
-              />
-            ))
-          )}
-
-          {/* ── 轨道末尾 "+" 添加卡片 ── */}
-          <div className="ep-track-add-card-wrapper">
-            <div
-              ref={addCardRef}
-              className="ep-track-add-card"
-              onClick={handleTogglePicker}
-              title="添加片段"
-            >
-              +
-            </div>
-          </div>
-        </div>
+        <ClipTrack
+          clips={clips}
+          selectedClipId={selectedClipId}
+          pps={pps}
+          currentTime={currentTime}
+          totalDuration={totalDuration}
+          dragIdx={dragIdx}
+          dragOverIdx={dragOverIdx}
+          hoveredClipId={hoveredClipId}
+          trimDragActive={!!trimDrag}
+          showTrimHandles={!!onClipTrim}
+          trackRef={trackRef}
+          addCardRef={addCardRef}
+          onPlayheadMouseDown={handlePlayheadMouseDown}
+          onClipSelect={onClipSelect}
+          onDragStart={handleDragStart}
+          onDragOver={handleDragOver}
+          onDragEnd={handleDragEnd}
+          onDrop={handleDrop}
+          onEmptyDragOver={handleEmptyDragOver}
+          onContextMenu={handleContextMenu}
+          onClipMouseEnter={setHoveredClipId}
+          onClipMouseLeave={() => setHoveredClipId(null)}
+          onTrimHandleMouseDown={handleTrimHandleMouseDown}
+          onClipRemove={onClipRemove}
+          onTogglePicker={handleTogglePicker}
+        />
       )}
 
       {/* 裁剪预览 tooltip */}

apps/web/src/pages/editing-planner/components/TtsPanel/components/TtsSlider.tsx

@@ -0,0 +1,48 @@
+import React from "react"
+import { Slider } from "antd"
+
+export interface TtsSliderProps {
+  label: string
+  value: number
+  min: number
+  max: number
+  step: number
+  onChange: (val: number) => void
+  formatter: (val: number) => string
+  marks?: string[]
+}
+
+export const TtsSlider: React.FC<TtsSliderProps> = ({
+  label,
+  value,
+  min,
+  max,
+  step,
+  onChange,
+  formatter,
+  marks,
+}) => {
+  return (
+    <div className="tts-slider-section">
+      <div className="tts-slider-header">
+        <span className="tts-slider-label">{label}</span>
+        <span className="tts-slider-value">{formatter(value)}</span>
+      </div>
+      <Slider
+        min={min}
+        max={max}
+        step={step}
+        value={value}
+        onChange={onChange}
+        tooltip={{ formatter: (v) => (v != null ? formatter(v as number) : "") }}
+      />
+      {marks && (
+        <div className="tts-slider-marks">
+          {marks.map((m, i) => (
+            <span key={i}>{m}</span>
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}

apps/web/src/pages/editing-planner/components/TtsPanel/components/VoiceSelector.tsx

@@ -0,0 +1,107 @@
+import React, { useState } from "react"
+import type { UnifiedVoiceItem } from "@/api/voices"
+import { LoadingOutlined } from "@ant-design/icons"
+
+export interface VoiceSelectorProps {
+  presetVoices: UnifiedVoiceItem[]
+  cloneVoices: UnifiedVoiceItem[]
+  selectedVoiceId: string
+  loading: boolean
+  playingVoiceId: string | null
+  loadingSampleVoiceId: string | null
+  onSelect: (voiceId: string) => void
+  onPlaySample: (voice: UnifiedVoiceItem) => void
+}
+
+type VoiceTab = "preset" | "clone"
+
+const GENDER_ICON: Record<string, string> = {
+  male: "👨",
+  female: "👩",
+  young: "🧑",
+}
+
+export const VoiceSelector: React.FC<VoiceSelectorProps> = ({
+  presetVoices,
+  cloneVoices,
+  selectedVoiceId,
+  loading,
+  playingVoiceId,
+  loadingSampleVoiceId,
+  onSelect,
+  onPlaySample,
+}) => {
+  const [activeTab, setActiveTab] = useState<VoiceTab>("preset")
+
+  const currentList = activeTab === "preset" ? presetVoices : cloneVoices
+
+  return (
+    <div className="tts-voice-section">
+      <div className="tts-voice-label">
+        选择音色
+        {loading && <span className="tts-voice-loading">加载中...</span>}
+      </div>
+
+      {/* Tab 切换 */}
+      <div className="tts-voice-tabs">
+        <button
+          className={`tts-voice-tab${activeTab === "preset" ? " active" : ""}`}
+          onClick={() => setActiveTab("preset")}
+        >
+          预设音色
+        </button>
+        <button
+          className={`tts-voice-tab${activeTab === "clone" ? " active" : ""}`}
+          onClick={() => setActiveTab("clone")}
+        >
+          我的克隆
+          {cloneVoices.length > 0 && (
+            <span className="tts-voice-tab-count">{cloneVoices.length}</span>
+          )}
+        </button>
+      </div>
+
+      {/* 音色列表 */}
+      {loading ? (
+        <div className="tts-voice-empty">⏳ 加载中...</div>
+      ) : currentList.length === 0 ? (
+        <div className="tts-voice-empty">
+          {activeTab === "preset" ? "暂无预设音色" : "暂无克隆音色，快去克隆一个吧"}
+        </div>
+      ) : (
+        <div className="tts-voice-list">
+          {currentList.map((voice) => {
+            const isSelected = selectedVoiceId === voice.voice_id
+            const isPlaying = playingVoiceId === voice.voice_id
+            const isLoadingSample = loadingSampleVoiceId === voice.voice_id
+            const icon = GENDER_ICON[voice.gender] ?? "✨"
+            return (
+              <div
+                key={voice.voice_id}
+                className={`tts-voice-item${isSelected ? " selected" : ""}`}
+                onClick={() => onSelect(voice.voice_id)}
+              >
+                <div className="tts-voice-item-icon">{icon}</div>
+                <div className="tts-voice-item-info">
+                  <div className="tts-voice-item-name">{voice.name}</div>
+                  <div className="tts-voice-item-desc">{voice.description || voice.language}</div>
+                </div>
+                <button
+                  className="tts-voice-item-play"
+                  onClick={(e) => {
+                    e.stopPropagation()
+                    onPlaySample(voice)
+                  }}
+                  disabled={isLoadingSample}
+                  title={isPlaying ? "暂停" : isLoadingSample ? "合成中" : "试听"}
+                >
+                  {isLoadingSample ? <LoadingOutlined /> : isPlaying ? "⏸" : "▶"}
+                </button>
+              </div>
+            )
+          })}
+        </div>
+      )}
+    </div>
+  )
+}

apps/web/src/pages/editing-planner/components/TtsPanel/constants.ts

@@ -0,0 +1,18 @@
+import type { TtsMode } from "../../types"
+
+/** 音色卡片分类图标 */
+export const VOICE_CATEGORY_MAP: Record<string, { icon: string; label: string }> = {
+  male: { icon: "👨", label: "男声" },
+  female: { icon: "👩", label: "女声" },
+  young: { icon: "🧑", label: "少年" },
+  service: { icon: "🎧", label: "客服" },
+  news: { icon: "📰", label: "新闻" },
+  emotion: { icon: "🎭", label: "情感" },
+}
+
+/** 配音模式选项 */
+export const TTS_MODE_OPTIONS: { mode: TtsMode; icon: string; label: string }[] = [
+  { mode: "none", icon: "🔇", label: "无配音" },
+  { mode: "upload", icon: "📁", label: "上传配音" },
+  { mode: "tts", icon: "🤖", label: "TTS 合成" },
+]

apps/web/src/pages/editing-planner/components/TtsPanel/hooks/useTtsPanel.ts

@@ -0,0 +1,271 @@
+import { useState, useCallback, useEffect, useRef, type ChangeEvent } from "react"
+import { message } from "antd"
+import type { TtsConfig, TtsMode } from "../../../types"
+import { DEFAULT_TTS_CONFIG } from "../../../types"
+import { previewTts } from "@/api/tts"
+import { getVoiceClonePreview } from "@/api/voice-clone"
+import { fetchVoices, type UnifiedVoiceItem } from "@/api/voices"
+
+interface UseTtsPanelOptions {
+  open: boolean
+  config: TtsConfig
+  onChange: (config: TtsConfig) => void
+  onClose: () => void
+}
+
+export const useTtsPanel = ({ open, config, onChange, onClose }: UseTtsPanelOptions) => {
+  /* ── 音色列表（统一音色：预设 + 克隆） ── */
+  const [presetVoices, setPresetVoices] = useState<UnifiedVoiceItem[]>([])
+  const [cloneVoices, setCloneVoices] = useState<UnifiedVoiceItem[]>([])
+  const [voicesLoading, setVoicesLoading] = useState(false)
+
+  // 用 ref 保存最新 config 和 onChange，避免 useEffect 闭包陷阱
+  const configRef = useRef(config)
+  const onChangeRef = useRef(onChange)
+  configRef.current = config
+  onChangeRef.current = onChange
+
+  /* ── 试听状态 ── */
+  const [previewLoading, setPreviewLoading] = useState(false)
+  const audioRef = useRef<HTMLAudioElement | null>(null)
+  const mountedRef = useRef(true)
+
+  /* ── 加载音色列表 + 重置挂载状态 ── */
+  useEffect(() => {
+    if (!open) return
+    mountedRef.current = true
+    let active = true
+    setVoicesLoading(true)
+    fetchVoices({ status: "ready", limit: 100 })
+      .then((res) => {
+        if (!active) return
+        const presets = res.items.filter((v) => v.type === "preset")
+        const clones = res.items.filter((v) => v.type === "clone")
+        setPresetVoices(presets)
+        setCloneVoices(clones)
+        // 如果当前没有选中音色，默认选第一个预设（用 ref 读最新值，避免闭包旧值覆盖用户选择）
+        if (!configRef.current.voice_id && presets.length > 0) {
+          onChangeRef.current({
+            ...configRef.current,
+            voice_id: presets[0].voice_id,
+          })
+        }
+      })
+      .catch(() => {
+        if (active) message.error("加载音色列表失败")
+      })
+      .finally(() => {
+        if (active) setVoicesLoading(false)
+      })
+    return () => {
+      active = false
+    }
+  }, [open])
+
+  /* ── 组件卸载时清理音频资源 ── */
+  useEffect(() => {
+    return () => {
+      audioRef.current?.pause()
+      audioRef.current = null
+      mountedRef.current = false
+    }
+  }, [])
+
+  /* ── 切换配音模式 ── */
+  const handleModeChange = useCallback(
+    (mode: TtsMode) => {
+      onChange({ ...config, mode })
+    },
+    [config, onChange],
+  )
+
+  /* ── 文本输入 ── */
+  const handleTextChange = useCallback(
+    (e: ChangeEvent<HTMLTextAreaElement>) => {
+      const text = e.target.value.slice(0, 5000)
+      onChange({ ...config, text })
+    },
+    [config, onChange],
+  )
+
+  /* ── 选择音色 ── */
+  const handleVoiceSelect = useCallback(
+    (voiceId: string) => {
+      onChange({ ...config, voice_id: voiceId })
+    },
+    [config, onChange],
+  )
+
+  /* ── 语速 ── */
+  const handleSpeedChange = useCallback(
+    (speed: number) => {
+      onChange({ ...config, speed })
+    },
+    [config, onChange],
+  )
+
+  /* ── 语调 ── */
+  const handlePitchChange = useCallback(
+    (pitch: number) => {
+      onChange({ ...config, pitch })
+    },
+    [config, onChange],
+  )
+
+  /* ── 音量 ── */
+  const handleVolumeChange = useCallback(
+    (volume: number) => {
+      onChange({ ...config, volume })
+    },
+    [config, onChange],
+  )
+
+  /* ── 字幕联动 ── */
+  const handleSubtitleSyncToggle = useCallback(() => {
+    onChange({ ...config, subtitle_sync: !config.subtitle_sync })
+  }, [config, onChange])
+
+  /* ── 试听 ── */
+  const handlePreview = useCallback(async () => {
+    if (!config.text.trim()) {
+      message.warning("请先输入合成文本")
+      return
+    }
+    if (!config.voice_id) {
+      message.warning("请先选择音色")
+      return
+    }
+    setPreviewLoading(true)
+    try {
+      const res = await previewTts({
+        text: config.text.slice(0, 200),
+        voice_id: config.voice_id,
+        speed: config.speed,
+        pitch: config.pitch,
+      })
+      if (!mountedRef.current) return
+      audioRef.current?.pause()
+      const audio = new Audio(res.audio_url)
+      audioRef.current = audio
+      audio
+        .play()
+        .then(() => {
+          if (mountedRef.current) message.success("试听播放中")
+        })
+        .catch(() => {
+          if (mountedRef.current) message.error("播放失败")
+        })
+      audio.onended = () => {
+        if (mountedRef.current) audioRef.current = null
+      }
+    } catch {
+      if (mountedRef.current) message.error("试听生成失败")
+    } finally {
+      if (mountedRef.current) setPreviewLoading(false)
+    }
+  }, [config])
+
+  /* ── 单音色示例试听 ── */
+  const [playingVoiceId, setPlayingVoiceId] = useState<string | null>(null)
+  const [loadingSampleVoiceId, setLoadingSampleVoiceId] = useState<string | null>(null)
+  const handlePlayVoiceSample = useCallback(
+    async (voice: UnifiedVoiceItem) => {
+      const voiceId = voice.voice_id
+      if (playingVoiceId === voiceId) {
+        audioRef.current?.pause()
+        audioRef.current = null
+        setPlayingVoiceId(null)
+        return
+      }
+      // 暂停上一个音频并清除事件监听，避免竞态
+      if (audioRef.current) {
+        audioRef.current.onended = null
+        audioRef.current.pause()
+      }
+
+      let audioUrl: string | null = voice.preview_url ?? voice.audio_url
+
+      // 克隆音色：调用试听接口实时合成
+      if (voice.type === "clone" && voice.voice_clone_profile_id) {
+        setLoadingSampleVoiceId(voiceId)
+        try {
+          const preview = await getVoiceClonePreview(voice.voice_clone_profile_id)
+          audioUrl = preview.audio_url
+        } catch {
+          if (mountedRef.current) {
+            message.error("试听音频生成失败，请重试")
+          }
+          setLoadingSampleVoiceId(null)
+          return
+        } finally {
+          if (mountedRef.current) {
+            setLoadingSampleVoiceId(null)
+          }
+        }
+      }
+
+      if (!audioUrl) {
+        message.warning("该音色暂无示例音频")
+        return
+      }
+
+      const audio = new Audio(audioUrl)
+      audioRef.current = audio
+      audio
+        .play()
+        .then(() => {
+          // 只有当前活跃的音频实例才能更新状态，防止快速切换竞态
+          if (mountedRef.current && audioRef.current === audio) {
+            setPlayingVoiceId(voiceId)
+          }
+        })
+        .catch(() => {
+          if (mountedRef.current && audioRef.current === audio) {
+            message.error("播放失败")
+            audioRef.current = null
+          }
+        })
+      audio.onended = () => {
+        if (mountedRef.current && audioRef.current === audio) {
+          setPlayingVoiceId(null)
+          audioRef.current = null
+        }
+      }
+    },
+    [playingVoiceId],
+  )
+
+  /* ── 重置 ── */
+  const handleReset = useCallback(() => {
+    onChange({ ...DEFAULT_TTS_CONFIG })
+  }, [onChange])
+
+  /* ── 关闭时停止音频 ── */
+  const handleClose = useCallback(() => {
+    mountedRef.current = false
+    audioRef.current?.pause()
+    audioRef.current = null
+    setPlayingVoiceId(null)
+    onClose()
+  }, [onClose])
+
+  return {
+    presetVoices,
+    cloneVoices,
+    voicesLoading,
+    previewLoading,
+    playingVoiceId,
+    loadingSampleVoiceId,
+    handleModeChange,
+    handleTextChange,
+    handleVoiceSelect,
+    handlePlayVoiceSample,
+    handleSpeedChange,
+    handlePitchChange,
+    handleVolumeChange,
+    handleSubtitleSyncToggle,
+    handlePreview,
+    handleReset,
+    handleClose,
+  }
+}

apps/web/src/pages/editing-planner/components/TtsPanel/index.tsx

@@ -1,16 +1,17 @@
 /**
  * TTS 配音面板 — Drawer 形式
- * 配音模式切换 + 文本输入 + 音色选择 + 语速/语调/音量 + 试听 + 字幕联动
+ * 配音模式切换 + 文本输入 + 音色选择（预设+克隆） + 语速/语调/音量 + 试听 + 字幕联动
  */
 import React from "react"
 import { Drawer } from "antd"
-import type { TtsConfig } from "@/pages/editing-planner/types"
-import { TTS_MODE_OPTIONS } from "@/pages/editing-planner/constants/tts"
-import VoiceSelector from "./tts/VoiceSelector"
-import TtsSlider from "./tts/TtsSlider"
-import { useTtsPanel } from "@/pages/editing-planner/hooks/useTtsPanel"
+import type { TtsConfig } from "../../types"
 
-interface TtsPanelProps {
+import { useTtsPanel } from "./hooks/useTtsPanel"
+import { VoiceSelector } from "./components/VoiceSelector"
+import { TtsSlider } from "./components/TtsSlider"
+import { TTS_MODE_OPTIONS } from "./constants"
+
+export interface TtsPanelProps {
   open: boolean
   onClose: () => void
   /** 当前片段 TTS 配置 */
@@ -20,12 +21,16 @@ interface TtsPanelProps {
 
 const TtsPanel: React.FC<TtsPanelProps> = ({ open, onClose, config, onChange }) => {
   const {
-    voices,
+    presetVoices,
+    cloneVoices,
     voicesLoading,
     previewLoading,
+    playingVoiceId,
+    loadingSampleVoiceId,
     handleModeChange,
     handleTextChange,
     handleVoiceSelect,
+    handlePlayVoiceSample,
     handleSpeedChange,
     handlePitchChange,
     handleVolumeChange,
@@ -74,7 +79,7 @@ const TtsPanel: React.FC<TtsPanelProps> = ({ open, onClose, config, onChange })
               className="tts-text-input"
               placeholder="请输入需要合成的文本内容..."
               value={config.text}
-              onChange={(e) => handleTextChange(e.target.value)}
+              onChange={handleTextChange}
               maxLength={5000}
               rows={5}
             />
@@ -82,48 +87,49 @@ const TtsPanel: React.FC<TtsPanelProps> = ({ open, onClose, config, onChange })
 
           {/* 音色选择 */}
           <VoiceSelector
-            voices={voices}
-            voicesLoading={voicesLoading}
+            presetVoices={presetVoices}
+            cloneVoices={cloneVoices}
             selectedVoiceId={config.voice_id}
-            onVoiceSelect={handleVoiceSelect}
+            loading={voicesLoading}
+            playingVoiceId={playingVoiceId}
+            loadingSampleVoiceId={loadingSampleVoiceId}
+            onSelect={handleVoiceSelect}
+            onPlaySample={handlePlayVoiceSample}
           />
 
-          {/* 语速滑块 */}
+          {/* 语速 */}
           <TtsSlider
             label="语速"
             value={config.speed}
             min={0.5}
             max={2.0}
             step={0.05}
-            unit="x"
             onChange={handleSpeedChange}
+            formatter={(v) => `${v.toFixed(2)}x`}
             marks={["0.5x", "1.0x", "2.0x"]}
-            tooltipFormatter={(v) => `${v.toFixed(2)}x`}
           />
 
-          {/* 语调滑块 */}
+          {/* 语调 */}
           <TtsSlider
             label="语调"
             value={config.pitch}
             min={-12}
             max={12}
             step={1}
-            unit="半音"
             onChange={handlePitchChange}
+            formatter={(v) => `${v > 0 ? "+" : ""}${v} 半音`}
             marks={["-12", "0", "+12"]}
-            tooltipFormatter={(v) => `${v}半音`}
           />
 
-          {/* 音量滑块 */}
+          {/* 音量 */}
           <TtsSlider
             label="音量"
             value={config.volume}
             min={0}
             max={100}
             step={1}
-            unit="%"
             onChange={handleVolumeChange}
-            tooltipFormatter={(v) => `${v}%`}
+            formatter={(v) => `${v}%`}
           />
 
           {/* 试听按钮 */}

apps/web/src/pages/editing-planner/components/sticker/StickerPreview.tsx

@@ -0,0 +1,39 @@
+import React from "react"
+import type { StickerItem } from "@/pages/editing-planner/types"
+import { TEXT_PRESET_STYLES } from "@/pages/editing-planner/constants/sticker"
+
+interface StickerPreviewProps {
+  sticker: StickerItem
+}
+
+export const StickerPreview: React.FC<StickerPreviewProps> = ({ sticker }) => (
+  <div className="sticker-preview-box">
+    <div
+      className="sticker-preview-item"
+      style={{
+        left: `${sticker.x}%`,
+        top: `${sticker.y}%`,
+        width: `${sticker.width}%`,
+        height: `${sticker.height}%`,
+        transform: `translate(-50%, -50%) rotate(${sticker.rotation}deg)`,
+        opacity: sticker.opacity / 100,
+        fontSize: sticker.type === "text" ? `${sticker.font_size}px` : undefined,
+        ...TEXT_PRESET_STYLES[sticker.text_preset],
+      }}
+    >
+      {sticker.type === "emoji" && sticker.content}
+      {sticker.type === "text" && sticker.content}
+      {sticker.type === "image" && (
+        <img
+          src={sticker.content}
+          alt="sticker"
+          style={{
+            width: "100%",
+            height: "100%",
+            objectFit: "contain",
+          }}
+        />
+      )}
+    </div>
+  </div>
+)

apps/web/src/pages/editing-planner/components/sticker/StickerPropsEditor.tsx

@@ -2,11 +2,9 @@
  * 选中贴纸的属性编辑器
  */
 import React from "react"
-import type { StickerItem, TextStickerPreset } from "@/pages/editing-planner/types"
-import {
-  TEXT_PRESET_STYLES,
-  TEXT_STICKER_PRESET_LABELS,
-} from "@/pages/editing-planner/constants/sticker"
+import type { StickerItem } from "@/pages/editing-planner/types"
+import { StickerPreview } from "./StickerPreview"
+import { TextStickerPropsEditor } from "./TextStickerPropsEditor"
 
 interface StickerPropsEditorProps {
   sticker: StickerItem
@@ -121,78 +119,10 @@ const StickerPropsEditor: React.FC<StickerPropsEditorProps> = ({
       </div>
 
       {/* 文字贴纸特有属性 */}
-      {sticker.type === "text" && (
-        <>
-          <div className="sticker-prop-row">
-            <span className="sticker-prop-label">花字</span>
-            <select
-              className="sticker-prop-select"
-              value={sticker.text_preset}
-              onChange={(e) =>
-                onUpdate(sticker.id, { text_preset: e.target.value as TextStickerPreset })
-              }
-            >
-              {(Object.keys(TEXT_STICKER_PRESET_LABELS) as TextStickerPreset[]).map((p) => (
-                <option key={p} value={p}>
-                  {TEXT_STICKER_PRESET_LABELS[p]}
-                </option>
-              ))}
-            </select>
-          </div>
-          <div className="sticker-prop-row">
-            <span className="sticker-prop-label">字号</span>
-            <input
-              type="range"
-              className="sticker-prop-slider"
-              min={12}
-              max={72}
-              value={sticker.font_size}
-              onChange={(e) => onUpdate(sticker.id, { font_size: Number(e.target.value) })}
-            />
-            <span className="sticker-prop-value">{sticker.font_size}px</span>
-          </div>
-          <div className="sticker-prop-row">
-            <span className="sticker-prop-label">颜色</span>
-            <input
-              type="color"
-              className="sticker-prop-color"
-              value={sticker.text_color}
-              onChange={(e) => onUpdate(sticker.id, { text_color: e.target.value })}
-            />
-          </div>
-        </>
-      )}
+      <TextStickerPropsEditor sticker={sticker} onUpdate={onUpdate} />
 
       {/* 预览 */}
-      <div className="sticker-preview-box">
-        <div
-          className="sticker-preview-item"
-          style={{
-            left: `${sticker.x}%`,
-            top: `${sticker.y}%`,
-            width: `${sticker.width}%`,
-            height: `${sticker.width}%`,
-            transform: `translate(-50%, -50%) rotate(${sticker.rotation}deg)`,
-            opacity: sticker.opacity / 100,
-            fontSize: sticker.type === "text" ? `${sticker.font_size}px` : undefined,
-            ...TEXT_PRESET_STYLES[sticker.text_preset],
-          }}
-        >
-          {sticker.type === "emoji" && sticker.content}
-          {sticker.type === "text" && sticker.content}
-          {sticker.type === "image" && (
-            <img
-              src={sticker.content}
-              alt="sticker"
-              style={{
-                width: "100%",
-                height: "100%",
-                objectFit: "contain",
-              }}
-            />
-          )}
-        </div>
-      </div>
+      <StickerPreview sticker={sticker} />
     </div>
   )
 }

apps/web/src/pages/editing-planner/components/sticker/TextStickerPropsEditor.tsx

@@ -0,0 +1,57 @@
+import React from "react"
+import type { StickerItem, TextStickerPreset } from "@/pages/editing-planner/types"
+import { TEXT_STICKER_PRESET_LABELS } from "@/pages/editing-planner/constants/sticker"
+
+interface TextStickerPropsEditorProps {
+  sticker: StickerItem
+  onUpdate: (id: string, partial: Partial<StickerItem>) => void
+}
+
+export const TextStickerPropsEditor: React.FC<TextStickerPropsEditorProps> = ({
+  sticker,
+  onUpdate,
+}) => {
+  if (sticker.type !== "text") return null
+
+  return (
+    <>
+      <div className="sticker-prop-row">
+        <span className="sticker-prop-label">花字</span>
+        <select
+          className="sticker-prop-select"
+          value={sticker.text_preset}
+          onChange={(e) =>
+            onUpdate(sticker.id, { text_preset: e.target.value as TextStickerPreset })
+          }
+        >
+          {(Object.keys(TEXT_STICKER_PRESET_LABELS) as TextStickerPreset[]).map((p) => (
+            <option key={p} value={p}>
+              {TEXT_STICKER_PRESET_LABELS[p]}
+            </option>
+          ))}
+        </select>
+      </div>
+      <div className="sticker-prop-row">
+        <span className="sticker-prop-label">字号</span>
+        <input
+          type="range"
+          className="sticker-prop-slider"
+          min={12}
+          max={72}
+          value={sticker.font_size}
+          onChange={(e) => onUpdate(sticker.id, { font_size: Number(e.target.value) })}
+        />
+        <span className="sticker-prop-value">{sticker.font_size}px</span>
+      </div>
+      <div className="sticker-prop-row">
+        <span className="sticker-prop-label">颜色</span>
+        <input
+          type="color"
+          className="sticker-prop-color"
+          value={sticker.text_color}
+          onChange={(e) => onUpdate(sticker.id, { text_color: e.target.value })}
+        />
+      </div>
+    </>
+  )
+}