test: cleanup workflow验证用临时PR

Co-authored-by: xiaoxia <dev@xiaoxiajianji.com>
Co-committed-by: xiaoxia <dev@xiaoxiajianji.com>

.ci-retrigger

@@ -0,0 +1 @@
+re-trigger

.ci-trigger

@@ -1 +1 @@
-# CI trigger Fri Jun 26 09:53:28 PM CST 2026
+trigger: 1784009947

.flake8

@@ -1,14 +0,0 @@
-[flake8]
-max-line-length = 120
-exclude =
-    .git,
-    .cache,
-    __pycache__,
-    .venv,
-    venv,
-    node_modules,
-    alembic
-
-per-file-ignores =
-    tests/integration/*:F821
-    tests/unit/*:F821

.gitea/workflows/auto-approve.yml

@@ -0,0 +1,174 @@
+name: Auto Approve CI PRs
+
+on:
+  pull_request:
+    types: [synchronize, opened, ready_for_review]
+
+jobs:
+  auto-approve:
+    name: Auto Approve on CI Green
+    runs-on: ci-check
+    if: github.event_name == 'pull_request' && !github.event.pull_request.draft
+    timeout-minutes: 20
+    steps:
+      - name: Checkout code
+        shell: sh
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: "set -eu\npython3 - <<'PY'\nimport io, os, tarfile, time, urllib.request, urllib.error\nurl = f\"{os.environ['GITHUB_API_URL']}/repos/{os.environ['GITHUB_REPOSITORY']}/archive/{os.environ['GITHUB_SHA']}.tar.gz\"\nrequest = urllib.request.Request(url, headers={\"Authorization\": f\"token {os.environ['GITHUB_TOKEN']}\"})\nlast_err = None\nfor attempt in range(5):\n    try:\n        with urllib.request.urlopen(request, timeout=120) as response:\n            archive = response.read()\n        break\n    except urllib.error.HTTPError as e:\n        last_err = e\n        if e.code >= 500 and attempt < 4:\n            wait = 2 ** attempt\n            print(f\"Checkout HTTP {e.code}, retrying in {wait}s (attempt {attempt+1}/5)...\")\n            time.sleep(wait)\n            continue\n        raise\n    except Exception as e:\n        last_err = e\n        if attempt < 4:\n            wait = 2 ** attempt\n            print(f\"Checkout error: {e}, retrying in {wait}s (attempt {attempt+1}/5)...\")\n            time.sleep(wait)\n            continue\n        raise\nelse:\n    raise last_err\nwith tarfile.open(fileobj=io.BytesIO(archive), mode='r:gz') as tar:\n    root_prefix = tar.getmembers()[0].name.split('/', 1)[0] + '/'\n    for member in tar.getmembers():\n        name = member.name\n        if name == root_prefix[:-1]:\n            continue\n        if name.startswith(root_prefix):\n            member.name = name[len(root_prefix):]\n        if member.name:\n            tar.extract(member, '.')\nPY\n"
+
+      - name: Auto approve when CI passes
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+          REVIEW_TOKEN: ${{ secrets.REVIEW_GITEA_TOKEN }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: |
+          set -eu
+
+          echo "PR #${PR_NUMBER} - 检查CI状态并自动审批"
+
+          # 检查是否纯前端改动
+          API_URL="${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}/files?limit=300"
+          FILES=$(curl -s -H "Authorization: token ${GITHUB_TOKEN}" "$API_URL" | python3 -c "import sys,json; [print(f['filename']) for f in json.load(sys.stdin)]")
+          FRONTEND_COUNT=$(echo "$FILES" | grep -c '^apps/web/' || true)
+          BACKEND_COUNT=$(echo "$FILES" | grep -cv '^apps/web/' || true)
+          TOTAL=$(echo "$FILES" | grep -cv '^$' || true)
+          echo "变更文件: ${TOTAL} 个 (前端: ${FRONTEND_COUNT}, 后端/公共: ${BACKEND_COUNT})"
+
+          if [ "$BACKEND_COUNT" = "0" ] && [ "$FRONTEND_COUNT" -gt "0" ]; then
+            SKIP_BACKEND=true
+            echo "✅ 纯前端改动，只检查Frontend Lint"
+          else
+            SKIP_BACKEND=false
+            echo "🔧 包含后端/公共变更，检查全部CI"
+          fi
+
+          # 定义需要检查的context
+          if [ "$SKIP_BACKEND" = "true" ]; then
+            CONTEXTS=("CI/CD Pipeline / Frontend Lint (pull_request)")
+          else
+            CONTEXTS=(
+              "CI/CD Pipeline / Validate Code Quality And Tests (pull_request)"
+              "CI/CD Pipeline / Unit Tests (pull_request)"
+              "CI/CD Pipeline / Frontend Lint (pull_request)"
+            )
+          fi
+
+          echo "需要通过的CI检查: ${#CONTEXTS[@]} 项"
+          for ctx in "${CONTEXTS[@]}"; do
+            echo "  - $ctx"
+          done
+          echo
+
+          # 初始等待30秒，给CI启动写status的时间，避免checkout太快导致全找不到context误判
+          echo "等待30秒让CI启动..."
+          sleep 30
+
+          # 轮询等待，最多20分钟（120次x10秒）
+          for attempt in $(seq 1 120); do
+            ALL_SUCCESS=true
+            ANY_FAILED=false
+            ANY_PENDING=false
+
+            echo "--- 第${attempt}次检查 ($(date '+%H:%M:%S')) ---"
+
+            # 调用辅助脚本检查每个context状态
+            for ctx in "${CONTEXTS[@]}"; do
+              STATE=$(python3 scripts/check_ci_status.py "$GITHUB_TOKEN" "$GITHUB_REPOSITORY" "$PR_HEAD_SHA" "$ctx")
+              echo "  $ctx: $STATE"
+
+              if [ "$STATE" != "success" ]; then
+                ALL_SUCCESS=false
+              fi
+              if [ "$STATE" = "failure" ] || [ "$STATE" = "error" ]; then
+                ANY_FAILED=true
+              fi
+              if [ "$STATE" = "pending" ] || [ "$STATE" = "null" ]; then
+                ANY_PENDING=true
+              fi
+            done
+
+            if [ "$ALL_SUCCESS" = "true" ]; then
+              echo
+              echo "✅ 所有CI检查通过，自动审批 PR #${PR_NUMBER}"
+
+              # 检查是否已有审批（任何用户的APPROVED都算，避免重复审批）
+              EXISTING=$(curl -s -H "Authorization: token ${REVIEW_TOKEN}" \
+                "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}/reviews" \
+                | python3 -c "import sys,json; reviews=json.load(sys.stdin); print('yes' if any(r.get('state')=='APPROVED' for r in reviews) else 'no')")
+
+              if [ "$EXISTING" = "yes" ]; then
+                echo "ℹ️  PR #${PR_NUMBER} 已有审批，跳过"
+                exit 0
+              fi
+
+              # 第一步：创建PENDING review（Gitea API需要先创建再提交）
+              echo "创建review..."
+              REVIEW_CREATE=$(curl -s -X POST \
+                -H "Authorization: token ${REVIEW_TOKEN}" \
+                -H "Content-Type: application/json" \
+                -d '{"event": "PENDING", "body": "CI全绿，自动审批通过。"}' \
+                "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}/reviews")
+              
+              REVIEW_ID=$(echo "$REVIEW_CREATE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))")
+              REVIEW_STATE=$(echo "$REVIEW_CREATE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('state',''))")
+              echo "创建结果: id=$REVIEW_ID state=$REVIEW_STATE"
+
+              if [ -z "$REVIEW_ID" ]; then
+                echo "❌ 创建review失败"
+                echo "$REVIEW_CREATE"
+                exit 1
+              fi
+
+              # 如果已经是APPROVED就不用再submit了（兼容不同Gitea版本）
+              if [ "$REVIEW_STATE" = "APPROVED" ]; then
+                echo "✅ 自动审批成功（直接创建为APPROVED）"
+                exit 0
+              fi
+
+              # 第二步：submit review为APPROVED
+              echo "提交review审批..."
+              SUBMIT_CODE=$(curl -s -o /tmp/submit_resp.json -w "%{http_code}" \
+                -X POST \
+                -H "Authorization: token ${REVIEW_TOKEN}" \
+                -H "Content-Type: application/json" \
+                -d '{"event": "APPROVED", "body": "CI全绿，自动审批通过。"}' \
+                "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}/reviews/${REVIEW_ID}")
+              
+              echo "提交API HTTP状态: $SUBMIT_CODE"
+              cat /tmp/submit_resp.json 2>/dev/null || true
+              echo
+
+              if [ "$SUBMIT_CODE" = "200" ] || [ "$SUBMIT_CODE" = "201" ]; then
+                FINAL_STATE=$(python3 -c "import json; print(json.load(open('/tmp/submit_resp.json')).get('state',''))" 2>/dev/null || echo "?")
+                echo "✅ 自动审批成功 (state: $FINAL_STATE)"
+                exit 0
+              else
+                echo "❌ 提交审批失败"
+                exit 1
+              fi
+            fi
+
+            # 还有CI在跑（pending状态）→ 继续等
+            if [ "$ANY_PENDING" = "true" ]; then
+              echo "⏳ CI仍在运行中，继续等待（第${attempt}/120次轮询）..."
+              sleep 10
+              continue
+            fi
+
+            # 所有CI都跑完了但有失败 → 退出
+            if [ "$ANY_FAILED" = "true" ]; then
+              echo
+              echo "❌ CI检查有失败项，不自动审批"
+              exit 0
+            fi
+
+            # 其他情况继续等
+            sleep 10
+          done
+
+          echo
+          echo "⏰ 等待超时（20分钟），CI尚未全部完成"
+          exit 0

.gitea/workflows/auto-merge.yml

@@ -0,0 +1,170 @@
+name: Auto Merge CI PRs
+
+on:
+  pull_request:
+    types: [synchronize, opened, ready_for_review, review_requested]
+
+jobs:
+  auto-merge:
+    name: Auto Merge on CI Green + Approved
+    runs-on: ci-check
+    if: github.event_name == 'pull_request' && !github.event.pull_request.draft && github.event.pull_request.base.ref == 'develop'
+    timeout-minutes: 30
+    steps:
+      - name: Checkout code
+        shell: sh
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: "set -eu\npython3 - <<'PY'\nimport io, os, tarfile, time, urllib.request, urllib.error\nurl = f\"{os.environ['GITHUB_API_URL']}/repos/{os.environ['GITHUB_REPOSITORY']}/archive/{os.environ['GITHUB_SHA']}.tar.gz\"\nrequest = urllib.request.Request(url, headers={\"Authorization\": f\"token {os.environ['GITHUB_TOKEN']}\"})\nlast_err = None\nfor attempt in range(5):\n    try:\n        with urllib.request.urlopen(request, timeout=120) as response:\n            archive = response.read()\n        break\n    except urllib.error.HTTPError as e:\n        last_err = e\n        if e.code >= 500 and attempt < 4:\n            wait = 2 ** attempt\n            print(f\"Checkout HTTP {e.code}, retrying in {wait}s (attempt {attempt+1}/5)...\")\n            time.sleep(wait)\n            continue\n        raise\n    except Exception as e:\n        last_err = e\n        if attempt < 4:\n            wait = 2 ** attempt\n            print(f\"Checkout error: {e}, retrying in {wait}s (attempt {attempt+1}/5)...\")\n            time.sleep(wait)\n            continue\n        raise\nelse:\n    raise last_err\nwith tarfile.open(fileobj=io.BytesIO(archive), mode='r:gz') as tar:\n    root_prefix = tar.getmembers()[0].name.split('/', 1)[0] + '/'\n    for member in tar.getmembers():\n        name = member.name\n        if name == root_prefix[:-1]:\n            continue\n        if name.startswith(root_prefix):\n            member.name = name[len(root_prefix):]\n        if member.name:\n            tar.extract(member, '.')\nPY\n"
+
+      - name: Auto merge when CI passes and approved
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+          MERGE_TOKEN: ${{ secrets.REVIEW_GITEA_TOKEN }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+          BASE_REF: ${{ github.event.pull_request.base.ref }}
+        run: |
+          set -eu
+
+          echo "PR #${PR_NUMBER} - 检查CI状态+审批并自动合并到${BASE_REF}"
+          echo
+
+          # 只合develop分支
+          if [ "$BASE_REF" != "develop" ]; then
+            echo "Skip: 目标分支不是develop"
+            exit 0
+          fi
+
+          # 判断是否纯前端改动
+          FILES=$(curl -s -H "Authorization: token ${GITHUB_TOKEN}" \
+            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}/files?limit=300" \
+            | python3 -c "import sys,json; [print(f['filename']) for f in json.load(sys.stdin)]")
+          TOTAL=$(echo "$FILES" | grep -cv '^$' || true)
+          FRONTEND_COUNT=$(echo "$FILES" | grep -c '^apps/web/' || true)
+          BACKEND_COUNT=$((TOTAL - FRONTEND_COUNT))
+          echo "变更文件: ${TOTAL} 个 (前端: ${FRONTEND_COUNT}, 后端/公共: ${BACKEND_COUNT})"
+
+          if [ "$BACKEND_COUNT" = "0" ] && [ "$FRONTEND_COUNT" -gt "0" ]; then
+            CONTEXTS=("CI/CD Pipeline / Frontend Lint (pull_request)")
+            echo "纯前端改动，只检查Frontend Lint"
+          else
+            CONTEXTS=(
+              "CI/CD Pipeline / Validate Code Quality And Tests (pull_request)"
+              "CI/CD Pipeline / Unit Tests (pull_request)"
+              "CI/CD Pipeline / Frontend Lint (pull_request)"
+              "CI/CD Pipeline / Integration Tests (pull_request)"
+            )
+            echo "检查全部四门禁"
+          fi
+          echo
+
+          # 初始等待30秒，给CI启动写status的时间，避免checkout太快导致全找不到context误判
+          echo "等待30秒让CI启动..."
+          sleep 30
+
+          # 405连续计数器：连续多次合并返回405才放弃
+          MERGE_405_COUNT=0
+          MAX_405_RETRIES=6
+
+          # 轮询等待，最多30分钟（180次x10秒）
+          for attempt in $(seq 1 180); do
+            ALL_SUCCESS=true
+            ANY_FAILED=false
+            ANY_PENDING=false
+
+            echo "--- 第${attempt}次检查 ($(date '+%H:%M:%S')) ---"
+
+            # 检查CI状态
+            for ctx in "${CONTEXTS[@]}"; do
+              STATE=$(python3 scripts/check_ci_status.py "$GITHUB_TOKEN" "$GITHUB_REPOSITORY" "$PR_HEAD_SHA" "$ctx")
+              echo "  CI: ${ctx##*/}: $STATE"
+              if [ "$STATE" != "success" ]; then
+                ALL_SUCCESS=false
+              fi
+              if [ "$STATE" = "failure" ] || [ "$STATE" = "error" ]; then
+                ANY_FAILED=true
+              fi
+              if [ "$STATE" = "pending" ]; then
+                ANY_PENDING=true
+              fi
+            done
+
+            # 检查审批状态
+            APPROVAL_RESULT=$(python3 scripts/check_pr_approval.py "$MERGE_TOKEN" "$GITHUB_REPOSITORY" "$PR_NUMBER" 1)
+            echo "  审批: $APPROVAL_RESULT"
+            HAS_APPROVAL=false
+            if echo "$APPROVAL_RESULT" | grep -q '^approved'; then
+              HAS_APPROVAL=true
+            fi
+
+            # 全部满足 → 合并
+            if [ "$ALL_SUCCESS" = "true" ] && [ "$HAS_APPROVAL" = "true" ]; then
+              echo
+              echo "CI全绿 + 审批通过，执行自动合并"
+
+              # 幂等检查：PR是否还是open
+              PR_STATE=$(curl -s -H "Authorization: token ${MERGE_TOKEN}" \
+                "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}" \
+                | python3 -c "import sys,json; print(json.load(sys.stdin).get('state',''))")
+
+              if [ "$PR_STATE" != "open" ]; then
+                echo "PR状态为 ${PR_STATE}，无需合并"
+                exit 0
+              fi
+
+              # 执行squash merge
+              HTTP_CODE=$(curl -s -o /tmp/merge_resp.json -w "%{http_code}" \
+                -X POST \
+                -H "Authorization: token ${MERGE_TOKEN}" \
+                -H "Content-Type: application/json" \
+                -d '{"do":"squash","merge_title_field":"","merge_message_field":"","delete_branch_after_merge":true,"force_merge":false}' \
+                "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${PR_NUMBER}/merge")
+
+              echo "合并API HTTP状态: $HTTP_CODE"
+
+              if [ "$HTTP_CODE" = "200" ]; then
+                echo "自动合并成功"
+                exit 0
+              elif [ "$HTTP_CODE" = "405" ]; then
+                MERGE_405_COUNT=$((MERGE_405_COUNT + 1))
+                echo "⚠️  合并返回405（第${MERGE_405_COUNT}次），可能CI状态尚未同步或有未解决的门禁，继续等待重试..."
+                cat /tmp/merge_resp.json 2>/dev/null || true
+                echo
+                if [ "$MERGE_405_COUNT" -ge "$MAX_405_RETRIES" ]; then
+                  echo "❌ 连续${MAX_405_RETRIES}次合并返回405，放弃自动合并"
+                  curl -s -X POST \
+                    -H "Authorization: token ${MERGE_TOKEN}" \
+                    -H "Content-Type: application/json" \
+                    -d '{"body": "Auto merge failed after multiple 405 errors: PR may have conflicts or unresolved checks. Please review manually."}' \
+                    "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/issues/${PR_NUMBER}/comments" > /dev/null 2>&1 || true
+                  exit 1
+                fi
+              else
+                echo "自动合并失败 (HTTP $HTTP_CODE)"
+                cat /tmp/merge_resp.json 2>/dev/null || true
+                curl -s -X POST \
+                  -H "Authorization: token ${MERGE_TOKEN}" \
+                  -H "Content-Type: application/json" \
+                  -d "{\"body\": \"Auto merge failed (HTTP ${HTTP_CODE}), please check manually.\"}" \
+                  "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/issues/${PR_NUMBER}/comments" > /dev/null 2>&1 || true
+                exit 1
+              fi
+            else
+              # 本轮不满足合并条件，重置405计数器
+              MERGE_405_COUNT=0
+            fi
+
+            if [ "$ANY_FAILED" = "true" ]; then
+              echo
+              echo "CI有失败项，不自动合并"
+              exit 0
+            fi
+
+            sleep 10
+          done
+
+          echo
+          echo "等待超时（30分钟）"
+          exit 0

.gitea/workflows/ci-trigger-monitor.yml

@@ -0,0 +1,36 @@
+name: CI Trigger Monitor
+
+on:
+  schedule:
+    - cron: '*/5 * * * *'  # 每5分钟检查一次
+  workflow_dispatch:
+    inputs:
+      stale_threshold:
+        description: 'CI未触发告警阈值（分钟）'
+        required: false
+        default: '5'
+
+permissions:
+  contents: read
+
+jobs:
+  monitor:
+    name: Monitor CI Trigger Reliability
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      
+      - name: Check CI trigger status for all open PRs
+        env:
+          GITEA_API_TOKEN: ${{ secrets.REVIEW_GITEA_TOKEN }}
+          GITEA_URL: https://git.xiaoxiajianji.com
+          GITEA_REPO: xiaoxia/xiaoxia-saas
+          CI_NOTIFY_WEBHOOK: ${{ secrets.CI_NOTIFY_WEBHOOK }}
+          STALE_THRESHOLD_MIN: ${{ inputs.stale_threshold || 5 }}
+        run: |
+          set +e
+          python3 scripts/ci_trigger_monitor.py
+          # 监控脚本永远不fail，避免告警风暴
+          exit 0

.gitea/workflows/code-review.yml

@@ -0,0 +1,53 @@
+name: AI Code Review
+
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+
+# 同一个 PR 只跑一个 review，新的取消旧的
+concurrency:
+  group: code-review-${{ gitea.repository }}-${{ gitea.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  code-review:
+    name: AI Code Review
+    runs-on: ubuntu-latest
+    # 跳过草稿 PR
+    if: ${{ !gitea.event.pull_request.draft }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Install dependencies
+        run: |
+          python3 -m pip install --upgrade pip
+          python3 -m pip install requests
+
+      - name: Run AI Code Review
+        env:
+          # Gitea 配置（自动从运行环境获取）
+          GITEA_API_URL: ${{ gitea.server_url }}
+          GITEA_TOKEN: ${{ secrets.REVIEW_GITEA_TOKEN }}
+          REPO_NAME: ${{ gitea.repository }}
+          PR_NUMBER: ${{ gitea.event.pull_request.number }}
+          # LLM 提供商: coze (扣子原生Bot) / openai (OpenAI兼容)
+          LLM_PROVIDER: "coze"
+          # 扣子模式配置（默认国内站 api.coze.cn）
+          LLM_BASE_URL: ${{ secrets.LLM_BASE_URL }}
+          LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
+          COZE_BOT_ID: ${{ secrets.COZE_BOT_ID }}
+          LLM_MODEL: ${{ secrets.LLM_MODEL }}
+          # 可选参数
+          MAX_DIFF_CHARS: "30000"
+          LLM_TIMEOUT: "120"
+        run: |
+          python3 scripts/ci_code_review.py
+        # 审查脚本异常不影响 CI 通过
+        continue-on-error: true

.gitea/workflows/preview-cleanup.yml

@@ -0,0 +1,149 @@
+name: Preview Cleanup
+on:
+  pull_request:
+    types:
+    - closed
+    branches:
+    - main
+    - develop
+permissions:
+  contents: read
+  pull-requests: write
+jobs:
+  cleanup-preview:
+    name: Cleanup Preview Environment
+    runs-on: runtime-builder
+    timeout-minutes: 10
+    steps:
+    - name: Extract PR number
+      shell: sh
+      run: |
+        set -eu
+        # 优先从event payload中读取（兼容所有PR事件类型）
+        if [ -n "${GITHUB_EVENT_PATH:-}" ] && [ -f "$GITHUB_EVENT_PATH" ]; then
+          PR_NUMBER=$(python3 -c "import json,sys; print(json.load(sys.stdin).get('number',''))" < "$GITHUB_EVENT_PATH")
+        fi
+        # fallback: 从GITHUB_REF中提取
+        if [ -z "${PR_NUMBER:-}" ]; then
+          PR_NUMBER=$(echo "$GITHUB_REF" | sed -n 's|refs/pull/\([0-9]*\)/.*|\1|p')
+        fi
+        # 再fallback: 兼容纯数字ref
+        if [ -z "${PR_NUMBER:-}" ] || ! echo "$PR_NUMBER" | grep -qE '^[0-9]+$'; then
+          echo "WARNING: Could not extract PR number cleanly, using raw ref suffix"
+          PR_NUMBER=$(echo "$GITHUB_REF" | sed 's|refs/pull/||; s|/.*||')
+        fi
+        echo "PR_NUMBER=$PR_NUMBER" >> $GITHUB_ENV
+        echo "PR number: $PR_NUMBER"
+        echo "Preview dir: /var/www/preview/pr-${PR_NUMBER}"
+
+    - name: Install SSH client
+      shell: sh
+      run: |
+        set -eu
+        # 先检查是否已存在ssh
+        if command -v ssh >/dev/null 2>&1 && command -v ssh-keyscan >/dev/null 2>&1; then
+          echo "SSH client already available: $(ssh -V 2>&1)"
+          exit 0
+        fi
+        # 尝试多种包管理器安装
+        if command -v apk >/dev/null 2>&1; then
+          apk add --no-cache openssh-client >/dev/null 2>&1
+          echo "openssh-client installed via apk"
+        elif command -v apt-get >/dev/null 2>&1; then
+          apt-get update -qq && apt-get install -y -qq openssh-client >/dev/null 2>&1
+          echo "openssh-client installed via apt-get"
+        elif command -v yum >/dev/null 2>&1; then
+          yum install -y openssh-clients >/dev/null 2>&1
+          echo "openssh-client installed via yum"
+        elif command -v dnf >/dev/null 2>&1; then
+          dnf install -y openssh-clients >/dev/null 2>&1
+          echo "openssh-client installed via dnf"
+        else
+          echo "ERROR: No package manager found and ssh not pre-installed"
+          which ssh 2>/dev/null || echo "  ssh: not found"
+          which ssh-keyscan 2>/dev/null || echo "  ssh-keyscan: not found"
+          exit 1
+        fi
+
+    - name: Remove preview directory from server
+      shell: sh
+      env:
+        PREVIEW_SSH_HOST: ${{ secrets.PREVIEW_SSH_HOST }}
+        PREVIEW_SSH_USER: ${{ secrets.PREVIEW_SSH_USER }}
+        PREVIEW_SSH_PORT: ${{ secrets.PREVIEW_SSH_PORT }}
+        PREVIEW_SSH_KEY: ${{ secrets.PREVIEW_SSH_KEY }}
+      run: |
+        set -eux
+        preview_host="${PREVIEW_SSH_HOST:-172.30.18.197}"
+        preview_user="${PREVIEW_SSH_USER:-deploy}"
+        preview_port="${PREVIEW_SSH_PORT:-22222}"
+        preview_dir="/var/www/preview/pr-${PR_NUMBER}"
+
+        mkdir -p ~/.ssh
+
+        # 查找可用的SSH密钥
+        key_path=""
+        if [ -f /root/.ssh/xiaoxia_runtime_builder ]; then
+          key_path="/root/.ssh/xiaoxia_runtime_builder"
+          echo "Using key: $key_path (builder key)"
+        elif [ -f "$HOME/.ssh/xiaoxia_runtime_builder" ]; then
+          key_path="$HOME/.ssh/xiaoxia_runtime_builder"
+          echo "Using key: $key_path (home key)"
+        elif [ -n "${PREVIEW_SSH_KEY:-}" ]; then
+          key_path="$HOME/.ssh/id_ed25519"
+          printf '%s\n' "$PREVIEW_SSH_KEY" > "$key_path"
+          chmod 600 "$key_path"
+          echo "Using key from PREVIEW_SSH_KEY secret"
+        else
+          echo "ERROR: No SSH key available"
+          ls -la ~/.ssh/ 2>/dev/null || true
+          ls -la /root/.ssh/ 2>/dev/null || true
+          exit 1
+        fi
+
+        ssh-keyscan -p "$preview_port" -H "$preview_host" >> ~/.ssh/known_hosts 2>/dev/null
+        echo "SSH keyscan done"
+
+        # 测试SSH连接
+        ssh -p "$preview_port" -i "$key_path" -o StrictHostKeyChecking=no "${preview_user}@${preview_host}" "echo SSH_CONNECTION_OK && hostname"
+        echo "SSH connection verified"
+
+        # 检查目录是否存在
+        DIR_EXISTS=$(ssh -p "$preview_port" -i "$key_path" -o StrictHostKeyChecking=no "${preview_user}@${preview_host}" \
+          "if [ -d '${preview_dir}' ]; then echo 'yes'; else echo 'no'; fi")
+
+        if [ "$DIR_EXISTS" = "yes" ]; then
+          echo "Removing preview directory: ${preview_dir}"
+          ssh -p "$preview_port" -i "$key_path" -o StrictHostKeyChecking=no "${preview_user}@${preview_host}" \
+            "rm -rf ${preview_dir} && echo 'Preview directory removed successfully'"
+          echo "Cleanup completed: ${preview_dir}"
+        else
+          echo "Preview directory does not exist: ${preview_dir}, nothing to clean up"
+        fi
+
+    - name: Comment cleanup notice on PR
+      if: success()
+      shell: sh
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      run: |
+        set -eu
+        # 从event payload读取PR号（最可靠）
+        if [ -n "${GITHUB_EVENT_PATH:-}" ] && [ -f "$GITHUB_EVENT_PATH" ]; then
+          PR_NUMBER=$(python3 -c "import json,sys; print(json.load(sys.stdin).get('number',''))" < "$GITHUB_EVENT_PATH")
+        else
+          PR_NUMBER=$(echo "$GITHUB_REF" | sed -n 's|refs/pull/\([0-9]*\)/.*|\1|p')
+        fi
+        export PR_NUMBER
+
+        COMMENT_BODY=$(python3 scripts/ci/preview_comment.py cleanup)
+
+        API_URL="${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/issues/${PR_NUMBER}/comments"
+        curl -s -X POST \
+          -H "Authorization: token ${GITHUB_TOKEN}" \
+          -H "Content-Type: application/json" \
+          -d "$COMMENT_BODY" \
+          "$API_URL" \
+          > /dev/null
+        echo "Cleanup comment posted"
+

.gitea/workflows/preview-deploy.yml

@@ -0,0 +1,274 @@
+name: Preview Deploy
+on:
+  pull_request:
+    types:
+    - opened
+    - synchronize
+    - reopened
+    branches:
+    - main
+    - develop
+  workflow_dispatch:
+    inputs:
+      reason:
+        description: "触发原因"
+        required: false
+        default: "手动触发 - 预览环境补跑"
+permissions:
+  contents: read
+  pull-requests: write
+concurrency:
+  group: preview-deploy-${{ gitea.ref }}
+  cancel-in-progress: true
+jobs:
+  deploy-preview:
+    name: Deploy Preview Environment
+    runs-on: runtime-builder
+    timeout-minutes: 20
+    steps:
+    - name: Checkout code
+      shell: sh
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      run: |
+        set -eu
+        python3 - <<'PY'
+        import io, os, tarfile, time, urllib.request, urllib.error
+        url = f"{os.environ['GITHUB_API_URL']}/repos/{os.environ['GITHUB_REPOSITORY']}/archive/{os.environ['GITHUB_SHA']}.tar.gz"
+        request = urllib.request.Request(url, headers={"Authorization": f"token {os.environ['GITHUB_TOKEN']}"})
+        last_err = None
+        for attempt in range(5):
+            try:
+                with urllib.request.urlopen(request, timeout=120) as response:
+                    archive = response.read()
+                break
+            except urllib.error.HTTPError as e:
+                last_err = e
+                if e.code >= 500 and attempt < 4:
+                    wait = 2 ** attempt
+                    print(f"Checkout HTTP {e.code}, retrying in {wait}s (attempt {attempt+1}/5)...")
+                    time.sleep(wait)
+                    continue
+                raise
+            except Exception as e:
+                last_err = e
+                if attempt < 4:
+                    wait = 2 ** attempt
+                    print(f"Checkout error: {e}, retrying in {wait}s (attempt {attempt+1}/5)...")
+                    time.sleep(wait)
+                    continue
+                raise
+        else:
+            raise last_err
+        with tarfile.open(fileobj=io.BytesIO(archive), mode='r:gz') as tar:
+            root_prefix = tar.getmembers()[0].name.split('/', 1)[0] + '/'
+            for member in tar.getmembers():
+                name = member.name
+                if name == root_prefix[:-1]:
+                    continue
+                if name.startswith(root_prefix):
+                    member.name = name[len(root_prefix):]
+                if member.name:
+                    tar.extract(member, '.')
+        PY
+
+    - name: Record job start time
+      shell: sh
+      run: |
+        set -eu
+        echo "JOB_START_TIME=$(date +%s)" >> $GITHUB_ENV
+        echo "Job started at $(date)"
+
+    - name: Extract PR number
+      shell: sh
+      run: |
+        set -eu
+        PR_NUMBER=$(echo "$GITHUB_REF" | sed 's|refs/pull/||; s|/.*||')
+        echo "PR_NUMBER=$PR_NUMBER" >> $GITHUB_ENV
+        echo "PR number: $PR_NUMBER"
+        echo "PREVIEW_URL=https://pr-${PR_NUMBER}.preview.xiaoxiajianji.com" >> $GITHUB_ENV
+        echo "Preview URL: https://pr-${PR_NUMBER}.preview.xiaoxiajianji.com"
+
+    - name: Build frontend
+      shell: sh
+      run: |
+        set -eu
+        NPM_CACHE_VOLUME="xiaoxia-npm-cache"
+        if ! docker volume inspect "$NPM_CACHE_VOLUME" >/dev/null 2>&1; then
+          docker volume create "$NPM_CACHE_VOLUME" >/dev/null
+          echo "Created npm cache volume: $NPM_CACHE_VOLUME"
+        fi
+
+        docker run --rm \
+          -v "$PWD:/workspace" \
+          -v "$NPM_CACHE_VOLUME:/workspace/apps/web/node_modules" \
+          -w /workspace/apps/web \
+          -e VITE_API_URL=https://staging-api.xiaoxiajianji.com \
+          docker.m.daocloud.io/library/node:20 \
+          sh -lc '
+            PACKAGE_LOCK_HASH=$(md5sum package-lock.json 2>/dev/null | cut -d" " -f1)
+            CACHE_HASH_FILE="node_modules/.package-lock-hash"
+            CACHE_VALID=false
+            if [ -f "$CACHE_HASH_FILE" ] && [ "$(cat "$CACHE_HASH_FILE")" = "$PACKAGE_LOCK_HASH" ] && [ -x "node_modules/.bin/vite" ] && [ -x "node_modules/.bin/tsc" ]; then
+              CACHE_VALID=true
+              echo "Cache hit: dependencies valid, skipping npm ci"
+            fi
+            if [ "$CACHE_VALID" = "false" ]; then
+              echo "Cache miss or invalid: running npm ci..."
+              if ! npm ci --include=dev; then
+                echo "npm ci failed, cleaning node_modules and retrying..."
+                rm -rf node_modules
+                mkdir -p node_modules
+                npm ci --include=dev
+              fi
+              echo "$PACKAGE_LOCK_HASH" > "$CACHE_HASH_FILE"
+              echo "Dependencies installed, cache updated"
+            fi
+            echo "Running TypeScript check..."
+            npx --no-install tsc
+            echo "Running Vite build..."
+            npx --no-install vite build
+            echo "Build completed successfully"
+            ls -la dist/
+          '
+
+    - name: Install SSH client and rsync
+      shell: sh
+      run: |
+        set -eu
+        if command -v apk >/dev/null 2>&1; then
+          apk add --no-cache openssh-client rsync >/dev/null 2>&1
+        elif command -v apt-get >/dev/null 2>&1; then
+          apt-get update -qq && apt-get install -y -qq openssh-client rsync >/dev/null 2>&1
+        elif command -v yum >/dev/null 2>&1; then
+          yum install -y openssh-clients rsync >/dev/null 2>&1
+        else
+          echo "ERROR: No package manager found"
+          exit 1
+        fi
+        echo "openssh-client and rsync installed"
+
+    - name: Deploy preview to server
+      shell: sh
+      env:
+        PREVIEW_SSH_HOST: ${{ secrets.PREVIEW_SSH_HOST }}
+        PREVIEW_SSH_USER: ${{ secrets.PREVIEW_SSH_USER }}
+        PREVIEW_SSH_PORT: ${{ secrets.PREVIEW_SSH_PORT }}
+        PREVIEW_SSH_KEY: ${{ secrets.PREVIEW_SSH_KEY }}
+      run: |
+        set -eux
+        preview_host="${PREVIEW_SSH_HOST:-172.30.18.197}"
+        preview_user="${PREVIEW_SSH_USER:-deploy}"
+        preview_port="${PREVIEW_SSH_PORT:-22222}"
+        preview_dir="/var/www/preview/pr-${PR_NUMBER}"
+
+        mkdir -p ~/.ssh
+
+        # 查找可用的SSH密钥
+        key_path=""
+        if [ -f /root/.ssh/xiaoxia_runtime_builder ]; then
+          key_path="/root/.ssh/xiaoxia_runtime_builder"
+          echo "Using key: $key_path (builder key)"
+        elif [ -f "$HOME/.ssh/xiaoxia_runtime_builder" ]; then
+          key_path="$HOME/.ssh/xiaoxia_runtime_builder"
+          echo "Using key: $key_path (home key)"
+        elif [ -n "${PREVIEW_SSH_KEY:-}" ]; then
+          key_path="$HOME/.ssh/id_ed25519"
+          printf '%s\n' "$PREVIEW_SSH_KEY" > "$key_path"
+          chmod 600 "$key_path"
+          echo "Using key from PREVIEW_SSH_KEY secret"
+        else
+          echo "ERROR: No SSH key available"
+          ls -la ~/.ssh/ 2>/dev/null || true
+          ls -la /root/.ssh/ 2>/dev/null || true
+          exit 1
+        fi
+
+        ssh-keyscan -p "$preview_port" -H "$preview_host" >> ~/.ssh/known_hosts 2>/dev/null
+        echo "SSH keyscan done"
+
+        # 测试SSH连接
+        ssh -p "$preview_port" -i "$key_path" -o StrictHostKeyChecking=no "${preview_user}@${preview_host}" "echo SSH_CONNECTION_OK && hostname"
+        echo "SSH connection verified"
+
+        # 创建预览目录并上传文件
+        ssh -p "$preview_port" -i "$key_path" -o StrictHostKeyChecking=no "${preview_user}@${preview_host}" \
+          "mkdir -p ${preview_dir} && echo 'Preview directory created: ${preview_dir}'"
+
+        # 使用rsync上传dist目录内容
+        rsync -avz --delete -e "ssh -p ${preview_port} -i ${key_path} -o StrictHostKeyChecking=no" \
+          apps/web/dist/ \
+          "${preview_user}@${preview_host}:${preview_dir}/"
+
+        echo "Preview deployed to: ${preview_dir}"
+        echo "Preview URL: https://pr-${PR_NUMBER}.preview.xiaoxiajianji.com"
+
+    - name: Comment preview link on PR
+      shell: sh
+      env:
+        GITHUB_TOKEN: ${{ github.token }}
+      run: |
+        set -eu
+        PR_NUMBER=$(echo "$GITHUB_REF" | sed 's|refs/pull/||; s|/.*||')
+        PREVIEW_URL="https://pr-${PR_NUMBER}.preview.xiaoxiajianji.com"
+        export PR_NUMBER PREVIEW_URL
+
+        COMMENT_BODY=$(python3 scripts/ci/preview_comment.py deploy)
+
+        API_URL="${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/issues/${PR_NUMBER}/comments"
+
+        EXISTING_COMMENT_ID=$(curl -s -H "Authorization: token ${GITHUB_TOKEN}" "$API_URL" | python3 -c "
+        import sys, json
+        try:
+            for c in json.load(sys.stdin):
+                if '预览环境已部署' in c.get('body', ''):
+                    print(c['id'])
+                    break
+        except Exception:
+            pass
+        ")
+
+        if [ -n "$EXISTING_COMMENT_ID" ]; then
+          curl -s -X PATCH \
+            -H "Authorization: token ${GITHUB_TOKEN}" \
+            -H "Content-Type: application/json" \
+            -d "$COMMENT_BODY" \
+            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/issues/comments/${EXISTING_COMMENT_ID}" \
+            > /dev/null
+          echo "Comment updated"
+        else
+          curl -s -X POST \
+            -H "Authorization: token ${GITHUB_TOKEN}" \
+            -H "Content-Type: application/json" \
+            -d "$COMMENT_BODY" \
+            "$API_URL" \
+            > /dev/null
+          echo "Comment posted"
+        fi
+
+    - name: Job duration summary
+      if: always()
+      shell: sh
+      run: |
+        set +eu
+        if [ -n "$JOB_START_TIME" ]; then
+          END_TIME=$(date +%s)
+          DURATION=$((END_TIME - JOB_START_TIME))
+          MINS=$((DURATION / 60))
+          SECS=$((DURATION % 60))
+          echo "JOB_DURATION_SECONDS=$DURATION" >> $GITHUB_ENV
+          echo "=== Job Duration: ${MINS}m${SECS}s ==="
+        else
+          echo "JOB_DURATION_SECONDS=0" >> $GITHUB_ENV
+          echo "=== Job Duration: unknown ==="
+        fi
+
+    - name: Notify on failure
+      continue-on-error: true
+      if: failure()
+      shell: sh
+      env:
+        CI_NOTIFY_WEBHOOK: ${{ secrets.CI_NOTIFY_WEBHOOK }}
+      run: |
+        set +e
+        NOTIFY_MODE=failure JOB_NAME="Deploy Preview Environment" python3 scripts/ci_notify.py

.gitignore

@@ -49,3 +49,7 @@ build/
 tracker_tasks.json
 
 frontend-v21-ui-prototype-final.html
+
+!.vscode/
+!.vscode/settings.json
+.vscode/extensions.json

.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 26.5.1
+    hooks:
+      - id: black
+        language_version: python3.12
+
+  - repo: https://github.com/pycqa/isort
+    rev: 8.0.1
+    hooks:
+      - id: isort
+        args: ["--profile", "black"]
+        language_version: python3.12
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.14.0
+    hooks:
+      - id: ruff
+        args: [--fix]
+        language_version: python3.12

.vscode/settings.json

@@ -0,0 +1,12 @@
+{
+  "[python]": {
+    "editor.defaultFormatter": "ms-python.black-formatter",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.organizeImports": "explicit"
+    }
+  },
+  "isort.args": ["--profile", "black"],
+  "python.linting.ruffEnabled": true,
+  "python.analysis.typeCheckingMode": "basic"
+}

alembic/versions/041_add_result_count_to_edit_plans.py

@@ -0,0 +1,29 @@
+"""add result_count to edit_plans
+
+Revision ID: 041_result_count
+Revises: 040_playback_speed
+Create Date: 2026-07-15 14:05:00.000000
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "041_result_count"
+down_revision = "040_playback_speed"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "edit_plans",
+        sa.Column("result_count", sa.Integer(), nullable=False, server_default="0"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("edit_plans", "result_count")

alembic/versions/042_add_storage_key_to_assets.py

@@ -0,0 +1,29 @@
+"""add storage_key to assets
+
+Revision ID: 042_storage_key
+Revises: 041_result_count
+Create Date: 2026-07-17 18:10:00.000000
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "042_storage_key"
+down_revision = "041_result_count"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "assets",
+        sa.Column("storage_key", sa.String(500), nullable=False, server_default=""),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("assets", "storage_key")

apps/api/app/api/routes/_helpers.py

@@ -46,3 +46,97 @@ def require_project_and_library(
     libraries = asset_library_repository.find_by_project(project_id)
     if not any(item.id == library_id for item in libraries):
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Asset library not found")
+
+
+def auto_select_video_assets(
+    *,
+    project_id: str,
+    asset_library_repo: Any,
+    asset_repo: Any,
+    logger=None,
+) -> list[str]:
+    """从项目视频素材库自动选取 ready 状态的视频素材。
+
+    Args:
+        project_id: 项目 ID
+        asset_library_repo: 素材库仓储
+        asset_repo: 素材仓储
+        logger: 可选的 logger 实例，用于记录警告
+
+    Returns:
+        选中的素材 ID 列表，无可用素材时返回空列表
+    """
+    # 明确不支持的视频编码（会导致渲染失败）
+    UNSUPPORTED_CODECS = {"hevc", "h265", "hev1", "hvc1", "vp9", "vp09", "av1", "av01"}
+
+    if not project_id:
+        return []
+
+    # 找到项目的视频素材库
+    libs = asset_library_repo.find_by_project(project_id)
+    video_lib = None
+    for lib in libs:
+        lib_kind = lib.kind.value if hasattr(lib.kind, "value") else lib.kind
+        if lib_kind == "video":
+            video_lib = lib
+            break
+
+    if not video_lib:
+        if logger:
+            logger.warning("自动选素材: 项目 %s 无视频素材库", project_id)
+        return []
+
+    # 从素材库中选取 ready 状态的视频素材
+    assets = asset_repo.find_by_library(video_lib.id)
+    ready_videos = [
+        a
+        for a in assets
+        if (a.status.value if hasattr(a.status, "value") else a.status) == "ready"
+        and a.mime_type
+        and a.mime_type.startswith("video")
+    ]
+
+    # 过滤不支持的编码格式（HEVC/VP9/AV1 等会导致渲染失败）
+    # 优先读 asset.codec 字段，其次从 metadata 里取（兼容存量数据）
+    codec_filtered = []
+    skipped_codec = 0
+    for a in ready_videos:
+        codec = (a.codec or "").lower()
+        if not codec and a.metadata and isinstance(a.metadata, dict):
+            codec = str(a.metadata.get("codec", "")).lower()
+        if codec and codec in UNSUPPORTED_CODECS:
+            skipped_codec += 1
+            continue
+        codec_filtered.append(a)
+
+    if skipped_codec and logger:
+        logger.warning("自动选素材: 跳过 %d 个不支持编码的素材", skipped_codec)
+
+    # 过滤横屏素材（只保留竖屏/正方形）
+    # 移动端短视频场景默认竖屏，横屏素材裁剪后画面不可用
+    filtered_videos = []
+    skipped_landscape = 0
+    for a in codec_filtered:
+        width = a.width if hasattr(a, "width") and a.width else 0
+        height = a.height if hasattr(a, "height") and a.height else 0
+        if not width or not height:
+            # 从 metadata 兜底
+            if a.metadata and isinstance(a.metadata, dict):
+                width = int(a.metadata.get("width", 0) or 0)
+                height = int(a.metadata.get("height", 0) or 0)
+        if width and height and width > height:
+            skipped_landscape += 1
+            continue
+        filtered_videos.append(a)
+
+    if skipped_landscape and logger:
+        logger.warning("自动选素材: 跳过 %d 个横屏素材", skipped_landscape)
+
+    if not filtered_videos:
+        if logger:
+            logger.warning("自动选素材: 素材库 %s 无可用视频素材", video_lib.name)
+        return []
+
+    # 按创建时间降序（新素材在前）
+    filtered_videos.sort(key=lambda a: a.created_at, reverse=True)
+    return [a.id for a in filtered_videos]

apps/api/app/api/routes/duplication.py

@@ -239,7 +239,9 @@ def get_duplication_detail(
     return _to_detail_response(record)
 
 
-@router.delete("/records/{record_id}", status_code=status.HTTP_204_NO_CONTENT, response_model=None, response_class=Response)
+@router.delete(
+    "/records/{record_id}", status_code=status.HTTP_204_NO_CONTENT, response_model=None, response_class=Response
+)
 def delete_duplication_record(
     record_id: str,
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
@@ -287,7 +289,7 @@ def retry_duplication(
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=str(e),
-        )
+        ) from e
     if updated is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,

apps/api/app/api/routes/edit_plans.py

@@ -22,9 +22,15 @@ from datetime import datetime
 from typing import Any, List, Optional
 
 from app.auth import AuthenticatedUser, get_current_user
-from app.dependencies import get_db_session, get_project_repository
+from app.core.storage import get_storage_service
+from app.dependencies import (
+    get_asset_library_repository,
+    get_asset_repository,
+    get_db_session,
+    get_project_repository,
+)
 from app.schemas.generation_task import GenerationTaskResponse
-from app.services import EditPlanService
+from app.services import EditPlanService, EditTemplateService
 from fastapi import APIRouter, Depends, HTTPException, Query, Response, status
 from pydantic import BaseModel, Field
 from sqlalchemy.orm import Session
@@ -32,7 +38,7 @@ from sqlalchemy.orm import Session
 from packages.domain.config_schemas import normalize_plan_config
 from packages.domain.edit_plan import EditPlan, EditPlanStatus
 
-from ._helpers import check_project_access
+from ._helpers import auto_select_video_assets, check_project_access
 
 logger = logging.getLogger(__name__)
 
@@ -50,6 +56,7 @@ class EditPlanCreateRequest(BaseModel):
     config: dict[str, Any] = Field(default_factory=dict, description="计划配置 (JSON)")
     total_duration: float = Field(default=0.0, ge=0.0, description="总时长 (秒)")
     project_id: str = Field(default="", description="所属项目 ID")
+    asset_ids: List[str] = Field(default_factory=list, description="素材 ID 列表，创建时自动分配给片段")
 
 
 class EditPlanUpdateRequest(BaseModel):
@@ -64,6 +71,15 @@ class EditPlanUpdateRequest(BaseModel):
     )
 
 
+class CopyPlanRequest(BaseModel):
+    """复制剪辑计划请求体"""
+
+    name: Optional[str] = Field(
+        default=None, min_length=1, max_length=200, description="新计划名称，不传则为「原名 - 副本」"
+    )
+    project_id: Optional[str] = Field(default=None, description="目标项目 ID，不传则复用源计划的项目")
+
+
 class EditPlanResponse(BaseModel):
     """剪辑计划响应体"""
 
@@ -72,6 +88,7 @@ class EditPlanResponse(BaseModel):
     name: str
     status: str
     total_duration: float
+    result_count: int = 0
     project_id: str = ""
     created_by_user_id: str = ""
     config: dict[str, Any]
@@ -108,6 +125,10 @@ class EditPlanGenerationStatusResponse(BaseModel):
     plan_id: str
     plan_status: str
     generation_task_id: Optional[str] = None
+    generation_task_status: Optional[str] = None
+    progress: float = 0.0
+    video_url: str = ""
+    error_message: str = ""
     clips: List[ClipStatusItem]
 
 
@@ -231,20 +252,45 @@ class GenerateFromTemplateResponse(BaseModel):
 
 
 def _to_response(p: EditPlan) -> EditPlanResponse:
+    # 对 config 中的 rendered_url 做签名转换（私有bucket裸URL会403）
+    config = dict(p.config) if p.config else {}
+    raw_rendered_url = config.get("rendered_url", "")
+    if raw_rendered_url:
+        try:
+            storage = get_storage_service()
+            config["rendered_url"] = storage.get_download_url(raw_rendered_url, expires_seconds=86400)
+        except Exception as e:
+            logger.warning("剪辑计划rendered_url签名失败，返回原始URL: plan_id=%s error=%s", p.id, e)
+
     return EditPlanResponse(
         id=p.id,
         template_id=p.template_id,
         name=p.name,
         status=p.status.value if hasattr(p.status, "value") else p.status,
         total_duration=p.total_duration,
+        result_count=getattr(p, "result_count", 0),
         project_id=p.project_id or "",
         created_by_user_id=p.created_by_user_id or "",
-        config=p.config,
+        config=config,
         created_at=p.created_at,
         updated_at=p.updated_at,
     )
 
 
+# ── Include sub-routers (拆分模块) ────────────────────────────────────────────
+# 注意：含静态路径的子路由需放在 CRUD 路由之前，避免被 /{plan_id} 抢先匹配
+
+from .edit_plans_adjustments import router as adjustments_router
+from .edit_plans_export import router as export_router
+from .edit_plans_filter import router as filter_router
+from .edit_plans_transitions import router as transitions_router
+
+router.include_router(export_router)
+router.include_router(adjustments_router)
+router.include_router(filter_router)
+router.include_router(transitions_router)
+
+
 # ── CRUD Routes ───────────────────────────────────────────────────────────────
 
 
@@ -275,11 +321,11 @@ def list_plans(
     if status_filter:
         try:
             status_enum = EditPlanStatus(status_filter)
-        except ValueError:
+        except ValueError as _e:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 detail="无效的筛选条件，请选择正确的状态",
-            )
+            ) from _e
 
     # 项目鉴权：如果指定了 project_id，校验用户是否有权访问
     if project_id:
@@ -322,7 +368,7 @@ def get_plan(
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
             detail=str(exc),
-        )
+        ) from exc
     # 项目鉴权
     if plan.project_id:
         check_project_access(plan.project_id, current_user.user.id, project_repository)
@@ -335,37 +381,121 @@ def create_plan(
     db: Session = Depends(get_db_session),
     current_user: AuthenticatedUser = Depends(get_current_user),
     project_repository: Any = Depends(get_project_repository),
+    asset_repository: Any = Depends(get_asset_repository),
+    asset_library_repository: Any = Depends(get_asset_library_repository),
 ) -> EditPlanResponse:
-    """创建剪辑计划"""
+    """创建剪辑计划
+
+    基于模板自动生成片段结构：
+    - 模板存在时：从模板的 clip_configs 生成初始 clips
+    - 模板不存在时：降级为空计划（保持向后兼容）
+    - 用户传入的 config 与模板 config 合并（用户配置优先级更高）
+    - total_duration 自动根据 clips 总时长计算
+    """
+    from app.services import PlanGeneratorService
+
     # 空串 project_id 统一为 ""
     project_id = (body.project_id or "").strip()
     # 项目鉴权
     if project_id:
         check_project_access(project_id, current_user.user.id, project_repository)
+
+    # 标准化用户传入的 config
+    normalized_config = normalize_plan_config(body.config or {})
+
+    template_svc = EditTemplateService(db)
     svc = EditPlanService(db)
-    # 标准化 config，填充 cover/title/subtitle/bgm 默认值
-    normalized_config = normalize_plan_config(body.config)
+
+    # 尝试从模板生成（模板不存在时降级为空计划）
+    template = None
+    clips = []
     try:
-        created = svc.create_plan(
+        template = template_svc.get_template_or_raise(body.template_id)
+    except ValueError:
+        # 模板不存在，降级为普通空计划
+        logger.info("模板不存在，创建空计划: template_id=%s", body.template_id)
+        plan = svc.create_plan(
             template_id=body.template_id,
             name=body.name,
             config=normalized_config,
-            total_duration=body.total_duration,
             project_id=project_id,
             created_by_user_id=current_user.user.id,
+            total_duration=body.total_duration if body.total_duration > 0 else 0.0,
+        )
+        logger.info(
+            "创建空剪辑计划: id=%s name=%s by user=%s",
+            plan.id,
+            plan.name,
+            current_user.user.id,
+        )
+        return _to_response(plan)
+
+    # 模板存在，从模板生成计划+片段
+    clip_configs = template_svc.list_clip_configs(body.template_id, skip=0, limit=200)
+
+    # 自动选素材：未传 asset_ids 但有 project_id 时，从项目视频素材库选 ready 的视频素材
+    resolved_asset_ids = list(body.asset_ids)
+    if not resolved_asset_ids and project_id:
+        auto_assets = auto_select_video_assets(
+            project_id=project_id,
+            asset_library_repo=asset_library_repository,
+            asset_repo=asset_repository,
+            logger=logger,
+        )
+        if auto_assets:
+            resolved_asset_ids = auto_assets
+            logger.info(
+                "自动选素材: project_id=%s count=%d",
+                project_id,
+                len(auto_assets),
+            )
+
+    generator = PlanGeneratorService(db)
+    try:
+        result = generator.generate_from_template(
+            template=template,
+            clip_configs=clip_configs,
+            asset_ids=resolved_asset_ids,
+            project_id=project_id,
+            created_by_user_id=current_user.user.id,
+            name=body.name,
         )
     except ValueError as exc:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=str(exc),
+        ) from exc
+
+    plan = result["plan"]
+    clips = result["clips"]
+
+    # 如果用户传入了自定义 config，合并覆盖模板配置
+    if body.config:
+        base_config = template.config or {}
+        merged_config = {**base_config, **normalized_config}
+        # 重新标准化确保默认值填充正确
+        merged_config = normalize_plan_config(merged_config)
+        plan = svc.update_plan(
+            plan.id,
+            config=merged_config,
+            total_duration=body.total_duration if body.total_duration > 0 else None,
         )
+
+    # 把 asset_ids 写入 plan.config，供生成时兜底分配使用
+    if resolved_asset_ids:
+        current_config = plan.config or {}
+        if current_config.get("asset_ids") != resolved_asset_ids:
+            current_config["asset_ids"] = resolved_asset_ids
+            plan = svc.update_plan(plan.id, config=normalize_plan_config(current_config))
+
     logger.info(
-        "创建剪辑计划: id=%s name=%s by user=%s",
-        created.id,
-        created.name,
+        "创建剪辑计划: id=%s name=%s clips=%d by user=%s",
+        plan.id,
+        plan.name,
+        len(clips),
         current_user.user.id,
     )
-    return _to_response(created)
+    return _to_response(plan)
 
 
 @router.put("/{plan_id}", response_model=EditPlanResponse)
@@ -401,11 +531,11 @@ def update_plan(
         if body.status is not None:
             try:
                 target_status = EditPlanStatus(body.status)
-            except ValueError:
+            except ValueError as _e:
                 raise HTTPException(
                     status_code=status.HTTP_400_BAD_REQUEST,
                     detail="无效的状态值，请选择正确的状态",
-                )
+                ) from _e
             svc.transition_status(plan_id, target_status)
     except ValueError as exc:
         err_msg = str(exc)
@@ -413,11 +543,11 @@ def update_plan(
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
                 detail=err_msg,
-            )
+            ) from exc
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail=err_msg,
-        )
+        ) from exc
 
     # 返回最新状态
     result = svc.get_plan_or_raise(plan_id)
@@ -451,12 +581,551 @@ def delete_plan(
     )
 
 
+@router.post("/{plan_id}/copy", response_model=EditPlanResponse, status_code=status.HTTP_201_CREATED)
+def copy_plan(
+    plan_id: str,
+    body: CopyPlanRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> EditPlanResponse:
+    """复制剪辑计划（含所有片段配置）
+
+    新计划状态为 editing，不含生成任务和结果记录。
+    """
+    svc = EditPlanService(db)
+
+    # 源计划鉴权
+    existing = svc.get_plan(plan_id)
+    if existing is None:
+        raise HTTPException(status_code=404, detail=f"剪辑计划不存在: {plan_id}")
+    if existing.project_id:
+        check_project_access(existing.project_id, current_user.user.id, project_repository)
+
+    # 目标项目鉴权（如果指定了不同的项目）
+    target_project_id = body.project_id if body.project_id is not None else existing.project_id
+    if target_project_id and target_project_id != existing.project_id:
+        check_project_access(target_project_id, current_user.user.id, project_repository)
+
+    try:
+        new_plan = svc.copy_plan(
+            plan_id,
+            new_name=body.name,
+            project_id=target_project_id,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+
+    logger.info(
+        "复制剪辑计划: source=%s target=%s by user=%s",
+        plan_id,
+        new_plan.id,
+        current_user.user.id,
+    )
+    return _to_response(new_plan)
+
+
+# ── 字幕管理 ────────────────────────────────────────────────────────────────
+
+
+class SubtitleCreateRequest(BaseModel):
+    """添加字幕请求体"""
+
+    start: float = Field(..., ge=0, description="开始时间（秒）")
+    end: float = Field(..., gt=0, description="结束时间（秒）")
+    text: str = Field(..., min_length=1, max_length=500, description="字幕文本")
+    style: Optional[dict[str, Any]] = Field(default=None, description="字幕样式")
+
+
+class SubtitleUpdateRequest(BaseModel):
+    """更新字幕请求体"""
+
+    start: Optional[float] = Field(default=None, ge=0, description="开始时间（秒）")
+    end: Optional[float] = Field(default=None, gt=0, description="结束时间（秒）")
+    text: Optional[str] = Field(default=None, min_length=1, max_length=500, description="字幕文本")
+    style: Optional[dict[str, Any]] = Field(default=None, description="字幕样式")
+
+
+class SubtitleBatchUpdateRequest(BaseModel):
+    """批量更新字幕请求体"""
+
+    subtitles: list[dict[str, Any]] = Field(
+        default_factory=list,
+        description="字幕列表（全量替换），每条包含 start/end/text，可选 id/style",
+    )
+
+
+@router.get(
+    "/clips/{clip_id}/subtitles",
+    response_model=list[dict[str, Any]],
+    summary="获取片段的所有字幕",
+)
+def list_subtitles(
+    clip_id: str,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repo=Depends(get_project_repository),
+) -> list[dict[str, Any]]:
+    """获取指定片段的所有字幕，按时间排序。"""
+    service = EditPlanService(db)
+
+    clip = service.get_clip(clip_id)
+    if clip is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"片段不存在: {clip_id}",
+        )
+    plan = service.get_plan(clip.plan_id)
+    if plan and plan.project_id:
+        check_project_access(project_repo, current_user, plan.project_id)
+
+    return service.list_subtitles(clip_id)
+
+
+@router.post(
+    "/clips/{clip_id}/subtitles",
+    response_model=dict[str, Any],
+    summary="添加一条字幕",
+    status_code=status.HTTP_201_CREATED,
+)
+def add_subtitle(
+    clip_id: str,
+    body: SubtitleCreateRequest,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repo=Depends(get_project_repository),
+) -> dict[str, Any]:
+    """给片段添加一条字幕。"""
+    service = EditPlanService(db)
+
+    clip = service.get_clip(clip_id)
+    if clip is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"片段不存在: {clip_id}",
+        )
+    plan = service.get_plan(clip.plan_id)
+    if plan and plan.project_id:
+        check_project_access(project_repo, current_user, plan.project_id)
+
+    try:
+        subtitle = service.add_subtitle(
+            clip_id,
+            start=body.start,
+            end=body.end,
+            text=body.text,
+            style=body.style,
+        )
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e),
+        ) from e
+
+    logger.info("添加字幕: clip_id=%s by user=%s", clip_id, current_user.user.id)
+    return subtitle
+
+
+@router.put(
+    "/clips/{clip_id}/subtitles/{subtitle_id}",
+    response_model=dict[str, Any],
+    summary="更新一条字幕",
+)
+def update_subtitle(
+    clip_id: str,
+    subtitle_id: str,
+    body: SubtitleUpdateRequest,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repo=Depends(get_project_repository),
+) -> dict[str, Any]:
+    """更新一条字幕的时间、文本或样式。"""
+    service = EditPlanService(db)
+
+    clip = service.get_clip(clip_id)
+    if clip is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"片段不存在: {clip_id}",
+        )
+    plan = service.get_plan(clip.plan_id)
+    if plan and plan.project_id:
+        check_project_access(project_repo, current_user, plan.project_id)
+
+    try:
+        subtitle = service.update_subtitle(
+            clip_id,
+            subtitle_id,
+            start=body.start,
+            end=body.end,
+            text=body.text,
+            style=body.style,
+        )
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e),
+        ) from e
+
+    logger.info(
+        "更新字幕: clip_id=%s subtitle_id=%s by user=%s",
+        clip_id,
+        subtitle_id,
+        current_user.user.id,
+    )
+    return subtitle
+
+
+@router.delete(
+    "/clips/{clip_id}/subtitles/{subtitle_id}",
+    summary="删除一条字幕",
+    status_code=status.HTTP_204_NO_CONTENT,
+    response_model=None,
+    response_class=Response,
+)
+def delete_subtitle(
+    clip_id: str,
+    subtitle_id: str,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repo=Depends(get_project_repository),
+) -> None:
+    """删除一条字幕。"""
+    service = EditPlanService(db)
+
+    clip = service.get_clip(clip_id)
+    if clip is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"片段不存在: {clip_id}",
+        )
+    plan = service.get_plan(clip.plan_id)
+    if plan and plan.project_id:
+        check_project_access(project_repo, current_user, plan.project_id)
+
+    deleted = service.delete_subtitle(clip_id, subtitle_id)
+    if not deleted:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"字幕不存在: {subtitle_id}",
+        )
+
+    logger.info(
+        "删除字幕: clip_id=%s subtitle_id=%s by user=%s",
+        clip_id,
+        subtitle_id,
+        current_user.user.id,
+    )
+
+
+@router.put(
+    "/clips/{clip_id}/subtitles",
+    response_model=list[dict[str, Any]],
+    summary="批量更新字幕（全量替换）",
+)
+def batch_update_subtitles(
+    clip_id: str,
+    body: SubtitleBatchUpdateRequest,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repo=Depends(get_project_repository),
+) -> list[dict[str, Any]]:
+    """批量更新片段的所有字幕（全量替换）。
+
+    用于批量编辑、SRT导入、ASR结果导入等场景。
+    每条字幕包含 start/end/text，已有 id 则保留，否则生成新 id。
+    """
+    service = EditPlanService(db)
+
+    clip = service.get_clip(clip_id)
+    if clip is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"片段不存在: {clip_id}",
+        )
+    plan = service.get_plan(clip.plan_id)
+    if plan and plan.project_id:
+        check_project_access(project_repo, current_user, plan.project_id)
+
+    try:
+        subtitles = service.batch_update_subtitles(clip_id, body.subtitles)
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e),
+        ) from e
+
+    logger.info(
+        "批量更新字幕: clip_id=%s count=%d by user=%s",
+        clip_id,
+        len(subtitles),
+        current_user.user.id,
+    )
+    return subtitles
+
+
+# ── BGM 背景音乐 ───────────────────────────────────────────────────────────
+
+
+class BGMConfigUpdateRequest(BaseModel):
+    """更新BGM配置请求体"""
+
+    enabled: Optional[bool] = Field(default=None, description="是否启用 BGM")
+    source: Optional[str] = Field(default=None, description="BGM 来源: library/upload/ai_recommend")
+    asset_id: Optional[str] = Field(default=None, max_length=64, description="BGM 素材 ID")
+    preset_id: Optional[str] = Field(default=None, max_length=64, description="预设 BGM ID")
+    audio_url: Optional[str] = Field(default=None, max_length=500, description="BGM 音频 URL")
+    volume: Optional[float] = Field(default=None, ge=0.0, le=1.0, description="音量 (0.0 ~ 1.0)")
+    fade_in: Optional[float] = Field(default=None, ge=0.0, le=30.0, description="淡入时长（秒）")
+    fade_out: Optional[float] = Field(default=None, ge=0.0, le=30.0, description="淡出时长（秒）")
+    loop_enabled: Optional[bool] = Field(default=None, description="是否循环播放")
+    sidechain_enabled: Optional[bool] = Field(default=None, description="是否启用人声闪避")
+    sidechain_ratio: Optional[float] = Field(default=None, ge=0.0, le=1.0, description="闪避音量降低比例")
+
+
+@router.get(
+    "/{plan_id}/bgm",
+    response_model=dict[str, Any],
+    summary="获取剪辑计划的 BGM 配置",
+)
+def get_plan_bgm(
+    plan_id: str,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repo=Depends(get_project_repository),
+) -> dict[str, Any]:
+    """获取指定剪辑计划的 BGM 配置。"""
+    service = EditPlanService(db)
+
+    plan = service.get_plan(plan_id)
+    if plan is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+    if plan.project_id:
+        check_project_access(project_repo, current_user, plan.project_id)
+
+    config = plan.config or {}
+    bgm_config = config.get("bgm", {})
+
+    return {
+        "plan_id": plan.id,
+        "bgm": bgm_config,
+    }
+
+
+@router.put(
+    "/{plan_id}/bgm",
+    response_model=dict[str, Any],
+    summary="更新剪辑计划的 BGM 配置",
+)
+def update_plan_bgm(
+    plan_id: str,
+    body: BGMConfigUpdateRequest,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repo=Depends(get_project_repository),
+) -> dict[str, Any]:
+    """更新剪辑计划的 BGM 配置。
+
+    支持部分更新，只传需要修改的字段即可。
+    启用 BGM 后需要指定来源（asset_id / preset_id / audio_url 三选一）。
+    """
+    service = EditPlanService(db)
+
+    plan = service.get_plan(plan_id)
+    if plan is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+    if plan.project_id:
+        check_project_access(project_repo, current_user, plan.project_id)
+
+    # 读取当前 BGM 配置，合并更新
+    config = dict(plan.config) if plan.config else {}
+    current_bgm = dict(config.get("bgm", {}))
+
+    update_data = body.model_dump(exclude_none=True)
+    current_bgm.update(update_data)
+
+    # 校验：启用 BGM 时至少有一个有效来源
+    if current_bgm.get("enabled"):
+        has_source = any(current_bgm.get(key) for key in ("asset_id", "preset_id", "audio_url") if current_bgm.get(key))
+        if not has_source:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="启用 BGM 时需要指定素材来源（asset_id / preset_id / audio_url）",
+            )
+
+    # 保存到 plan.config.bgm
+    config["bgm"] = current_bgm
+    updated_plan = service.update_plan_config(plan_id, config)
+
+    logger.info(
+        "更新BGM配置: plan_id=%s enabled=%s by user=%s",
+        plan_id,
+        current_bgm.get("enabled", False),
+        current_user.user.id,
+    )
+
+    return {
+        "plan_id": updated_plan.id,
+        "bgm": current_bgm,
+    }
+
+
+# ── BGM 预设库 ────────────────────────────────────────────────────────────────
+
+
+@router.get(
+    "/bgm/presets",
+    response_model=dict[str, Any],
+    summary="获取预设 BGM 列表",
+)
+def list_bgm_presets(
+    style: Optional[str] = Query(default=None, description="按风格筛选"),
+    keyword: Optional[str] = Query(default=None, description="关键词搜索"),
+    skip: int = Query(default=0, ge=0, description="分页偏移"),
+    limit: int = Query(default=50, ge=1, le=200, description="每页数量"),
+) -> dict[str, Any]:
+    """获取预设 BGM 列表，支持按风格筛选和关键词搜索。
+
+    风格可选: upbeat（轻快）、relax（治愈）、tech（科技）、commerce（电商）、
+    emotional（情感）、cinematic（电影）
+    """
+    from packages.domain.preset_bgm import (
+        BGM_STYLES,
+        PRESET_BGM_LIBRARY,
+        list_preset_bgm_by_style,
+        search_preset_bgm,
+    )
+
+    bgm_list = PRESET_BGM_LIBRARY
+
+    if keyword:
+        bgm_list = search_preset_bgm(keyword)
+    elif style:
+        bgm_list = list_preset_bgm_by_style(style)
+
+    total = len(bgm_list)
+    paged = bgm_list[skip : skip + limit]
+
+    return {
+        "total": total,
+        "skip": skip,
+        "limit": limit,
+        "styles": BGM_STYLES,
+        "items": [
+            {
+                "id": bgm.id,
+                "name": bgm.name,
+                "style": bgm.style,
+                "style_label": BGM_STYLES.get(bgm.style, bgm.style),
+                "duration": bgm.duration,
+                "artist": bgm.artist,
+                "description": bgm.description,
+                "tags": bgm.tags,
+                "audio_url": bgm.audio_url,
+            }
+            for bgm in paged
+        ],
+    }
+
+
+# ── 保存为模板 ────────────────────────────────────────────────────────────────
+
+
+class SaveAsTemplateRequest(BaseModel):
+    """保存为模板请求体"""
+
+    name: str = Field(..., min_length=1, max_length=200, description="模板名称")
+    description: str = Field(default="", max_length=500, description="模板描述")
+    template_type: str = Field(default="custom", max_length=50, description="模板类型")
+    preview_url: str = Field(default="", max_length=500, description="预览图 URL")
+
+
+@router.post(
+    "/{plan_id}/save-as-template",
+    response_model=dict[str, Any],
+    summary="将剪辑计划保存为模板",
+    status_code=status.HTTP_201_CREATED,
+)
+def save_plan_as_template(
+    plan_id: str,
+    body: SaveAsTemplateRequest,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repo=Depends(get_project_repository),
+) -> dict[str, Any]:
+    """将指定剪辑计划的配置和片段结构保存为一个新模板。
+
+    新模板会复制计划的所有片段配置（类型、时长、转场、文案等），
+    但不绑定具体素材，可重复用于创建新的剪辑计划。
+    """
+    # 校验计划存在性和项目权限
+    plan_service = EditPlanService(db)
+    plan = plan_service.get_plan(plan_id)
+    if plan is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+    if plan.project_id:
+        check_project_access(project_repo, current_user, plan.project_id)
+
+    template_service = EditTemplateService(db)
+    try:
+        result = template_service.save_plan_as_template(
+            plan_id=plan_id,
+            name=body.name,
+            description=body.description,
+            template_type=body.template_type,
+            preview_url=body.preview_url,
+        )
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e),
+        ) from e
+
+    template = result["template"]
+    clip_configs = result["clip_configs"]
+
+    logger.info(
+        "保存计划为模板: plan_id=%s template_id=%s name=%s by user=%s",
+        plan_id,
+        template.id,
+        body.name,
+        current_user.user.id,
+    )
+
+    return {
+        "id": template.id,
+        "name": template.name,
+        "description": template.description,
+        "template_type": template.template_type,
+        "editing_mode": template.editing_mode,
+        "preview_url": template.preview_url,
+        "status": template.status.value,
+        "clip_count": len(clip_configs),
+        "created_at": template.created_at.isoformat(),
+    }
+
+
 # ── Include sub-routers (拆分模块) ────────────────────────────────────────────
 
 from .edit_plans_ai import router as ai_router
+from .edit_plans_clips import router as clips_router
+from .edit_plans_clips_batch import router as clips_batch_router
+from .edit_plans_cover import router as cover_router
 from .edit_plans_generation import router as generation_router
 from .edit_plans_timeline import router as timeline_router
 
 router.include_router(generation_router)
 router.include_router(ai_router)
 router.include_router(timeline_router)
+router.include_router(clips_router, prefix="/{plan_id}/clips", tags=["EditPlan Clips"])
+router.include_router(clips_batch_router, prefix="/{plan_id}/clips", tags=["EditPlan Clips"])
+router.include_router(cover_router)

apps/api/app/api/routes/edit_plans_adjustments.py

@@ -0,0 +1,311 @@
+"""片段调整 API.
+
+- PUT    /clips/{clip_id}/speed         调速
+- PUT    /clips/{clip_id}/volume        音量调节
+- PUT    /clips/{clip_id}/trim          裁剪（trim in/out）
+- PUT    /clips/{clip_id}/adjustments   统一调整（speed+volume+trim）
+- POST   /{plan_id}/clips/batch-speed   批量调速
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from app.auth import AuthenticatedUser, get_current_user
+from app.dependencies import get_db_session, get_project_repository
+from app.services import EditPlanService
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+from ._helpers import check_project_access
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# ── Schemas ──────────────────────────────────────────────────────────────────
+
+
+class SpeedAdjustRequest(BaseModel):
+    """调速请求"""
+
+    speed: float = Field(..., ge=0.25, le=4.0, description="播放速度 0.25~4.0")
+
+
+class VolumeAdjustRequest(BaseModel):
+    """音量调节请求"""
+
+    volume: float = Field(..., ge=0.0, le=2.0, description="音量倍率 0~2.0（1.0=原音量）")
+
+
+class TrimAdjustRequest(BaseModel):
+    """裁剪请求"""
+
+    trim_start: float = Field(0.0, ge=0.0, description="开头裁剪秒数")
+    trim_end: float = Field(0.0, ge=0.0, description="结尾裁剪秒数")
+
+
+class ClipAdjustmentsRequest(BaseModel):
+    """统一调整请求"""
+
+    speed: Optional[float] = Field(default=None, ge=0.25, le=4.0)
+    volume: Optional[float] = Field(default=None, ge=0.0, le=2.0)
+    trim_start: Optional[float] = Field(default=None, ge=0.0)
+    trim_end: Optional[float] = Field(default=None, ge=0.0)
+
+
+class BatchSpeedRequest(BaseModel):
+    """批量调速请求"""
+
+    speed: float = Field(..., ge=0.25, le=4.0, description="播放速度")
+
+
+class ClipAdjustResponse(BaseModel):
+    """片段调整响应"""
+
+    clip_id: str
+    speed: float
+    volume: float
+    trim_start: float
+    trim_end: float
+    duration: float
+
+
+class BatchSpeedResponse(BaseModel):
+    """批量调速响应"""
+
+    updated_count: int
+    plan_id: str
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _get_clip_config(clip) -> dict:
+    config = getattr(clip, "config", {}) or {}
+    if not isinstance(config, dict):
+        config = {}
+    return config
+
+
+def _get_volume(clip) -> float:
+    config = _get_clip_config(clip)
+    return float(config.get("volume", 1.0))
+
+
+def _get_trim(clip) -> tuple[float, float]:
+    config = _get_clip_config(clip)
+    trim_start = float(config.get("trim_start", 0.0))
+    trim_end = float(config.get("trim_end", 0.0))
+    return trim_start, trim_end
+
+
+def _build_response(clip) -> ClipAdjustResponse:
+    trim_start, trim_end = _get_trim(clip)
+    return ClipAdjustResponse(
+        clip_id=clip.id,
+        speed=clip.playback_speed,
+        volume=_get_volume(clip),
+        trim_start=trim_start,
+        trim_end=trim_end,
+        duration=clip.duration,
+    )
+
+
+def _validate_trim(trim_start: float, trim_end: float, total_duration: float) -> None:
+    """验证裁剪时长不超过总时长"""
+    if trim_start + trim_end >= total_duration:
+        raise ValueError(f"裁剪总时长（{trim_start + trim_end:.2f}s）不能大于等于片段总时长（{total_duration:.2f}s）")
+
+
+# ── Routes ───────────────────────────────────────────────────────────────────
+
+
+def _get_svc_and_plan_and_clip(db, clip_id, current_user, project_repository):
+    svc = EditPlanService(db)
+    clip = svc.get_clip(clip_id)
+    if not clip:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"片段不存在: {clip_id}",
+        )
+    plan = svc.get_plan(clip.plan_id)
+    if plan and plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+    return svc, plan, clip
+
+
+@router.put("/clips/{clip_id}/speed", response_model=ClipAdjustResponse)
+def adjust_speed(
+    clip_id: str,
+    body: SpeedAdjustRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ClipAdjustResponse:
+    """调整片段播放速度"""
+    svc, _, clip = _get_svc_and_plan_and_clip(db, clip_id, current_user, project_repository)
+
+    updated = svc.update_clip(clip_id, playback_speed=body.speed)
+
+    logger.info(
+        "调整片段速度: clip_id=%s speed=%.2f by user=%s",
+        clip_id,
+        body.speed,
+        current_user.user.id,
+    )
+    return _build_response(updated)
+
+
+@router.put("/clips/{clip_id}/volume", response_model=ClipAdjustResponse)
+def adjust_volume(
+    clip_id: str,
+    body: VolumeAdjustRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ClipAdjustResponse:
+    """调整片段音量"""
+    svc, _, clip = _get_svc_and_plan_and_clip(db, clip_id, current_user, project_repository)
+
+    # 更新 config.volume
+    config = dict(_get_clip_config(clip))
+    config["volume"] = body.volume
+    updated = svc.update_clip(clip_id, config=config)
+
+    logger.info(
+        "调整片段音量: clip_id=%s volume=%.2f by user=%s",
+        clip_id,
+        body.volume,
+        current_user.user.id,
+    )
+    return _build_response(updated)
+
+
+@router.put("/clips/{clip_id}/trim", response_model=ClipAdjustResponse)
+def adjust_trim(
+    clip_id: str,
+    body: TrimAdjustRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ClipAdjustResponse:
+    """裁剪片段（trim in/out）"""
+    svc, _, clip = _get_svc_and_plan_and_clip(db, clip_id, current_user, project_repository)
+
+    # 验证裁剪时长
+    try:
+        _validate_trim(body.trim_start, body.trim_end, clip.duration)
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+
+    # 更新 config
+    config = dict(_get_clip_config(clip))
+    config["trim_start"] = body.trim_start
+    config["trim_end"] = body.trim_end
+    updated = svc.update_clip(clip_id, config=config)
+
+    logger.info(
+        "裁剪片段: clip_id=%s trim_start=%.2f trim_end=%.2f by user=%s",
+        clip_id,
+        body.trim_start,
+        body.trim_end,
+        current_user.user.id,
+    )
+    return _build_response(updated)
+
+
+@router.put("/clips/{clip_id}/adjustments", response_model=ClipAdjustResponse)
+def adjust_all(
+    clip_id: str,
+    body: ClipAdjustmentsRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ClipAdjustResponse:
+    """统一调整片段的 speed / volume / trim"""
+    svc, _, clip = _get_svc_and_plan_and_clip(db, clip_id, current_user, project_repository)
+
+    update_kwargs = {}
+    config_updates = {}
+
+    if body.speed is not None:
+        update_kwargs["playback_speed"] = body.speed
+
+    if body.volume is not None:
+        config_updates["volume"] = body.volume
+
+    if body.trim_start is not None:
+        config_updates["trim_start"] = body.trim_start
+
+    if body.trim_end is not None:
+        config_updates["trim_end"] = body.trim_end
+
+    # 验证 trim
+    current_trim_start, current_trim_end = _get_trim(clip)
+    new_trim_start = body.trim_start if body.trim_start is not None else current_trim_start
+    new_trim_end = body.trim_end if body.trim_end is not None else current_trim_end
+
+    if body.trim_start is not None or body.trim_end is not None:
+        try:
+            _validate_trim(new_trim_start, new_trim_end, clip.duration)
+        except ValueError as e:
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+
+    if config_updates:
+        config = dict(_get_clip_config(clip))
+        config.update(config_updates)
+        update_kwargs["config"] = config
+
+    if not update_kwargs:
+        return _build_response(clip)
+
+    updated = svc.update_clip(clip_id, **update_kwargs)
+
+    logger.info(
+        "统一调整片段: clip_id=%s speed=%s volume=%s by user=%s",
+        clip_id,
+        body.speed,
+        body.volume,
+        current_user.user.id,
+    )
+    return _build_response(updated)
+
+
+@router.post("/{plan_id}/clips/batch-speed", response_model=BatchSpeedResponse)
+def batch_adjust_speed(
+    plan_id: str,
+    body: BatchSpeedRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> BatchSpeedResponse:
+    """批量调整计划内所有片段的播放速度"""
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    clips = svc.list_clips(plan_id, limit=500, skip=0)
+    count = 0
+    for clip in clips:
+        svc.update_clip(clip.id, playback_speed=body.speed)
+        count += 1
+
+    logger.info(
+        "批量调速: plan_id=%s count=%d speed=%.2f by user=%s",
+        plan_id,
+        count,
+        body.speed,
+        current_user.user.id,
+    )
+    return BatchSpeedResponse(updated_count=count, plan_id=plan_id)

apps/api/app/api/routes/edit_plans_ai.py

@@ -58,7 +58,7 @@ def ai_recommend_clips(
     try:
         plan = svc.get_plan_or_raise(plan_id)
     except ValueError as exc:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc))
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
 
     if plan.project_id:
         check_project_access(plan.project_id, current_user.user.id, project_repository)
@@ -103,7 +103,7 @@ def ai_recommend_clips(
             config=normalized_config,
             total_duration=result["total_duration"],
         )
-    except Exception:
+    except Exception as _e:
         logger.exception("AI 推荐写入失败，plan_id=%s 数据可能不一致", plan_id)
         try:
             db.rollback()
@@ -116,7 +116,7 @@ def ai_recommend_clips(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="AI推荐结果保存失败，请稍后重试",
-        )
+        ) from _e
 
     logger.info(
         "AI 推荐片段方案: plan_id=%s clips=%d duration=%.1f by user=%s",
@@ -167,7 +167,7 @@ def generate_cover(
     try:
         plan = svc.get_plan_or_raise(plan_id)
     except ValueError as exc:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc))
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
 
     if plan.project_id:
         check_project_access(plan.project_id, current_user.user.id, project_repository)

apps/api/app/api/routes/edit_plans_clips.py

@@ -0,0 +1,415 @@
+"""剪辑计划片段（Clip）CRUD 路由。"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, List, Optional
+
+from app.auth import AuthenticatedUser, get_current_user
+from app.dependencies import get_db_session, get_project_repository
+from fastapi import APIRouter, Depends, HTTPException, Query, Response, status
+from sqlalchemy.orm import Session
+
+from packages.domain.edit_plan_clip import EditPlanClipStatus
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# ── Schemas ──────────────────────────────────────────────────────────────────
+
+from pydantic import BaseModel, Field
+
+
+class EditPlanClipResponse(BaseModel):
+    """剪辑片段响应体"""
+
+    id: str
+    plan_id: str
+    clip_type: str
+    order: int
+    asset_id: str = ""
+    text_content: str = ""
+    start_time: float = 0.0
+    duration: float = 0.0
+    transition_effect: str = "cut"
+    transition_duration: float = 0.0
+    playback_speed: float = 1.0
+    status: str
+    config: dict[str, Any] = Field(default_factory=dict)
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+
+class EditPlanClipListResponse(BaseModel):
+    """剪辑片段列表响应体"""
+
+    items: List[EditPlanClipResponse]
+    total: int
+
+
+class EditPlanClipCreateRequest(BaseModel):
+    """创建剪辑片段请求体"""
+
+    clip_type: str = Field(
+        ..., min_length=1, max_length=50, description="片段类型: main/intro/outro/overlay/background/b_roll 等"
+    )
+    order: int = Field(..., ge=0, description="排序序号")
+    asset_id: str = Field(default="", max_length=64, description="关联素材 ID")
+    text_content: str = Field(default="", max_length=5000, description="文本内容（字幕/配音等）")
+    start_time: float = Field(default=0.0, ge=0.0, description="起始时间 (秒)")
+    duration: float = Field(default=0.0, ge=0.0, description="时长 (秒)")
+    transition_effect: str = Field(default="cut", max_length=50, description="转场效果")
+    transition_duration: float = Field(default=0.0, ge=0.0, description="转场时长 (秒)")
+    playback_speed: float = Field(default=1.0, gt=0.0, le=10.0, description="播放速度倍率")
+    config: dict[str, Any] = Field(default_factory=dict, description="扩展配置 (JSON)")
+
+
+class EditPlanClipUpdateRequest(BaseModel):
+    """更新剪辑片段请求体"""
+
+    clip_type: Optional[str] = Field(default=None, min_length=1, max_length=50, description="片段类型")
+    order: Optional[int] = Field(default=None, ge=0, description="排序序号")
+    asset_id: Optional[str] = Field(default=None, max_length=64, description="关联素材 ID")
+    text_content: Optional[str] = Field(default=None, max_length=5000, description="文本内容")
+    start_time: Optional[float] = Field(default=None, ge=0.0, description="起始时间 (秒)")
+    duration: Optional[float] = Field(default=None, ge=0.0, description="时长 (秒)")
+    transition_effect: Optional[str] = Field(default=None, max_length=50, description="转场效果")
+    transition_duration: Optional[float] = Field(default=None, ge=0.0, description="转场时长 (秒)")
+    playback_speed: Optional[float] = Field(default=None, gt=0.0, le=10.0, description="播放速度倍率")
+    config: Optional[dict[str, Any]] = Field(default=None, description="扩展配置 (JSON)")
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _check_plan_access(plan_id: str, user_id: str, project_repository: Any, db: Session) -> Any:
+    """验证用户是否有权限访问该剪辑计划（通过项目关联）。
+    返回 plan 对象供后续使用，避免重复查询。
+    """
+    from app.services.edit_plan_service import EditPlanService
+
+    from ._helpers import check_project_access
+
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if plan is None:
+        raise HTTPException(status_code=404, detail=f"剪辑计划不存在: {plan_id}")
+    if plan.project_id:
+        check_project_access(plan.project_id, user_id, project_repository)
+    return plan
+
+
+def _clip_to_response(clip) -> EditPlanClipResponse:
+    """将领域对象转换为响应体"""
+    return EditPlanClipResponse(
+        id=clip.id,
+        plan_id=clip.plan_id,
+        clip_type=clip.clip_type,
+        order=clip.order,
+        asset_id=clip.asset_id or "",
+        text_content=clip.text_content or "",
+        start_time=clip.start_time,
+        duration=clip.duration,
+        transition_effect=clip.transition_effect or "cut",
+        transition_duration=clip.transition_duration or 0.0,
+        playback_speed=clip.playback_speed or 1.0,
+        status=clip.status.value if hasattr(clip.status, "value") else str(clip.status),
+        config=clip.config or {},
+        created_at=clip.created_at.isoformat() if clip.created_at else None,
+        updated_at=clip.updated_at.isoformat() if clip.updated_at else None,
+    )
+
+
+def _get_svc(db: Session):
+    """获取 EditPlanService 实例"""
+    from app.services.edit_plan_service import EditPlanService
+
+    return EditPlanService(db)
+
+
+# ── Routes ───────────────────────────────────────────────────────────────────
+
+
+@router.get("", response_model=EditPlanClipListResponse)
+def list_clips(
+    plan_id: str,
+    status_filter: Optional[str] = Query(None, alias="status", description="按状态过滤"),
+    skip: int = Query(0, ge=0, description="分页偏移"),
+    limit: int = Query(100, ge=1, le=500, description="每页数量"),
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> EditPlanClipListResponse:
+    """获取剪辑计划的片段列表"""
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+    status_enum = EditPlanClipStatus(status_filter) if status_filter else None
+    clips = svc.list_clips(plan_id, status=status_enum, skip=skip, limit=limit)
+    total = svc.count_clips(plan_id, status=status_enum)
+
+    return EditPlanClipListResponse(
+        items=[_clip_to_response(c) for c in clips],
+        total=total,
+    )
+
+
+@router.post("", response_model=EditPlanClipResponse, status_code=status.HTTP_201_CREATED)
+def create_clip(
+    plan_id: str,
+    body: EditPlanClipCreateRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> EditPlanClipResponse:
+    """创建剪辑片段"""
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+    try:
+        clip = svc.create_clip(
+            plan_id=plan_id,
+            clip_type=body.clip_type,
+            order=body.order,
+            asset_id=body.asset_id,
+            text_content=body.text_content,
+            start_time=body.start_time,
+            duration=body.duration,
+            transition_effect=body.transition_effect,
+            transition_duration=body.transition_duration,
+            playback_speed=body.playback_speed,
+            config=body.config,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+
+    logger.info("创建剪辑片段: plan_id=%s clip_id=%s by user=%s", plan_id, clip.id, current_user.user.id)
+    return _clip_to_response(clip)
+
+
+@router.get("/{clip_id}", response_model=EditPlanClipResponse)
+def get_clip(
+    plan_id: str,
+    clip_id: str,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> EditPlanClipResponse:
+    """获取剪辑片段详情"""
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+    clip = svc.get_clip(clip_id)
+    if clip is None:
+        raise HTTPException(status_code=404, detail=f"片段不存在: {clip_id}")
+    if clip.plan_id != plan_id:
+        raise HTTPException(status_code=404, detail=f"片段不存在: {clip_id}")
+
+    return _clip_to_response(clip)
+
+
+@router.put("/{clip_id}", response_model=EditPlanClipResponse)
+def update_clip(
+    plan_id: str,
+    clip_id: str,
+    body: EditPlanClipUpdateRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> EditPlanClipResponse:
+    """更新剪辑片段"""
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+    # 验证 clip 属于该 plan
+    clip = svc.get_clip(clip_id)
+    if clip is None:
+        raise HTTPException(status_code=404, detail=f"片段不存在: {clip_id}")
+    if clip.plan_id != plan_id:
+        raise HTTPException(status_code=404, detail=f"片段不存在: {clip_id}")
+
+    try:
+        updated = svc.update_clip(
+            clip_id,
+            clip_type=body.clip_type,
+            order=body.order,
+            asset_id=body.asset_id,
+            text_content=body.text_content,
+            start_time=body.start_time,
+            duration=body.duration,
+            transition_effect=body.transition_effect,
+            transition_duration=body.transition_duration,
+            playback_speed=body.playback_speed,
+            config=body.config,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+
+    logger.info("更新剪辑片段: plan_id=%s clip_id=%s by user=%s", plan_id, clip_id, current_user.user.id)
+    return _clip_to_response(updated)
+
+
+@router.delete("/{clip_id}", status_code=status.HTTP_204_NO_CONTENT, response_model=None, response_class=Response)
+def delete_clip(
+    plan_id: str,
+    clip_id: str,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> None:
+    """删除剪辑片段"""
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+    # 验证 clip 属于该 plan
+    clip = svc.get_clip(clip_id)
+    if clip is None:
+        raise HTTPException(status_code=404, detail=f"片段不存在: {clip_id}")
+    if clip.plan_id != plan_id:
+        raise HTTPException(status_code=404, detail=f"片段不存在: {clip_id}")
+
+    deleted = svc.delete_clip(clip_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail=f"片段不存在: {clip_id}")
+
+    logger.info("删除剪辑片段: plan_id=%s clip_id=%s by user=%s", plan_id, clip_id, current_user.user.id)
+    return None
+
+
+# ── 片段分割与合并 ──────────────────────────────────────────────────────────
+
+
+class SplitClipRequest(BaseModel):
+    """分割片段请求体"""
+
+    split_time: float = Field(..., gt=0, description="分割点（秒，相对于片段起始）")
+
+
+class MergeClipsRequest(BaseModel):
+    """合并片段请求体"""
+
+    clip_ids: list[str] = Field(..., min_length=2, description="要合并的片段 ID 列表")
+
+
+@router.post(
+    "/{clip_id}/split",
+    response_model=dict[str, Any],
+    summary="分割片段",
+    status_code=status.HTTP_200_OK,
+)
+def split_clip(
+    plan_id: str,
+    clip_id: str,
+    body: SplitClipRequest,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repository: Any = Depends(get_project_repository),
+) -> dict[str, Any]:
+    """将一个片段从指定时间点分割为两个片段。
+
+    分割后原片段变为左半部分，新增右半部分片段，后续片段顺序自动后移。
+    若片段有关联素材，会自动设置 trim_start/trim_end 标记裁剪范围。
+    """
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+    clip = svc.get_clip(clip_id)
+    if clip is None or clip.plan_id != plan_id:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"片段不存在: {clip_id}",
+        )
+
+    try:
+        result = svc.split_clip(clip_id, body.split_time)
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e),
+        ) from e
+
+    left = result["left_clip"]
+    right = result["right_clip"]
+    logger.info("分割片段: plan_id=%s clip_id=%s by user=%s", plan_id, clip_id, current_user.user.id)
+
+    return {
+        "left_clip": {
+            "id": left.id,
+            "plan_id": left.plan_id,
+            "clip_type": left.clip_type,
+            "order": left.order,
+            "duration": left.duration,
+            "start_time": left.start_time,
+        },
+        "right_clip": {
+            "id": right.id,
+            "plan_id": right.plan_id,
+            "clip_type": right.clip_type,
+            "order": right.order,
+            "duration": right.duration,
+            "start_time": right.start_time,
+        },
+    }
+
+
+@router.post(
+    "/merge",
+    response_model=dict[str, Any],
+    summary="合并多个连续片段",
+    status_code=status.HTTP_200_OK,
+)
+def merge_clips(
+    plan_id: str,
+    body: MergeClipsRequest,
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    db: Session = Depends(get_db_session),
+    project_repository: Any = Depends(get_project_repository),
+) -> dict[str, Any]:
+    """将多个连续的同类型片段合并为一个片段。
+
+    合并要求：
+    - 至少 2 个片段
+    - 属于同一剪辑计划
+    - order 连续
+    - 类型相同
+
+    合并后保留第一个片段，其余删除，后续片段顺序自动前移。
+    """
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+
+    # 校验所有片段都属于该 plan
+    for cid in body.clip_ids:
+        clip = svc.get_clip(cid)
+        if clip is None or clip.plan_id != plan_id:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"片段不存在: {cid}",
+            )
+
+    try:
+        merged = svc.merge_clips(body.clip_ids)
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e),
+        ) from e
+
+    logger.info(
+        "合并片段: plan_id=%s clip_count=%d by user=%s",
+        plan_id,
+        len(body.clip_ids),
+        current_user.user.id,
+    )
+
+    return {
+        "id": merged.id,
+        "plan_id": merged.plan_id,
+        "clip_type": merged.clip_type,
+        "order": merged.order,
+        "duration": merged.duration,
+        "text_content": merged.text_content,
+    }

apps/api/app/api/routes/edit_plans_clips_batch.py

@@ -0,0 +1,241 @@
+"""剪辑计划片段批量操作 API。"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, List
+
+from app.auth import AuthenticatedUser, get_current_user
+from app.dependencies import get_db_session, get_project_repository
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# ── Schemas ──────────────────────────────────────────────────────────────────
+
+
+class ClipReorderItem(BaseModel):
+    """重排序条目"""
+
+    clip_id: str
+    new_order: int = Field(..., ge=0, description="新的排序序号")
+
+
+class ClipReorderRequest(BaseModel):
+    """片段重排序请求"""
+
+    items: List[ClipReorderItem] = Field(..., min_length=1, max_length=500, description="重排序条目列表")
+
+
+class ClipReorderResponse(BaseModel):
+    """片段重排序响应"""
+
+    success: bool
+    updated_count: int
+    message: str = ""
+
+
+class ClipBatchDeleteRequest(BaseModel):
+    """批量删除片段请求"""
+
+    clip_ids: List[str] = Field(..., min_length=1, max_length=500, description="要删除的片段ID列表")
+
+
+class ClipBatchDeleteResponse(BaseModel):
+    """批量删除片段响应"""
+
+    success: bool
+    deleted_count: int
+    message: str = ""
+
+
+class ClipsFromAssetsRequest(BaseModel):
+    """从素材批量创建片段请求"""
+
+    asset_ids: List[str] = Field(..., min_length=1, max_length=200, description="素材 ID 列表，按顺序追加到时间线末尾")
+    clip_type: str = Field(default="main", description="片段类型，默认 main")
+
+
+class ClipsFromAssetsResponse(BaseModel):
+    """从素材批量创建片段响应"""
+
+    success: bool
+    created_count: int
+    message: str = ""
+    clip_ids: List[str] = Field(default_factory=list, description="创建的片段ID列表")
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _check_plan_access(plan_id: str, user_id: str, project_repository: Any, db: Session) -> Any:
+    """验证用户是否有权限访问该剪辑计划，返回 plan 对象。"""
+    from app.services.edit_plan_service import EditPlanService
+
+    from ._helpers import check_project_access
+
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if plan is None:
+        raise HTTPException(status_code=404, detail=f"剪辑计划不存在: {plan_id}")
+    if plan.project_id:
+        check_project_access(plan.project_id, user_id, project_repository)
+    return plan
+
+
+def _get_svc(db: Session):
+    """获取 EditPlanService 实例"""
+    from app.services.edit_plan_service import EditPlanService
+
+    return EditPlanService(db)
+
+
+# ── Routes ───────────────────────────────────────────────────────────────────
+
+
+@router.post("/reorder", response_model=ClipReorderResponse)
+def reorder_clips(
+    plan_id: str,
+    body: ClipReorderRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ClipReorderResponse:
+    """批量重排序片段
+
+    前端拖拽调整顺序后，一次性提交所有变更的 order。
+    自动触发编辑状态回退（从 completed/failed 切回 editing）。
+    """
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+
+    # 验证所有 clip 都属于该 plan
+    clip_ids = [item.clip_id for item in body.items]
+    existing_clips = svc.list_clips(plan_id, skip=0, limit=10000)
+    existing_ids = {c.id for c in existing_clips}
+
+    invalid_ids = [cid for cid in clip_ids if cid not in existing_ids]
+    if invalid_ids:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"以下片段不属于该计划: {', '.join(invalid_ids[:5])}",
+        )
+
+    # 执行重排序
+    updated_count = 0
+    for item in body.items:
+        try:
+            svc.update_clip(item.clip_id, order=item.new_order)
+            updated_count += 1
+        except ValueError as e:
+            logger.warning("重排序片段失败: clip_id=%s error=%s", item.clip_id, e)
+
+    logger.info(
+        "批量重排序片段: plan_id=%s count=%d by user=%s",
+        plan_id,
+        updated_count,
+        current_user.user.id,
+    )
+
+    return ClipReorderResponse(
+        success=True,
+        updated_count=updated_count,
+        message=f"成功更新 {updated_count} 个片段的顺序",
+    )
+
+
+@router.post("/batch-delete", response_model=ClipBatchDeleteResponse)
+def batch_delete_clips(
+    plan_id: str,
+    body: ClipBatchDeleteRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ClipBatchDeleteResponse:
+    """批量删除片段
+
+    自动触发编辑状态回退（从 completed/failed 切回 editing）。
+    """
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+
+    # 验证所有 clip 都属于该 plan
+    existing_clips = svc.list_clips(plan_id, skip=0, limit=10000)
+    existing_ids = {c.id for c in existing_clips}
+
+    valid_ids = [cid for cid in body.clip_ids if cid in existing_ids]
+    skipped = len(body.clip_ids) - len(valid_ids)
+
+    # 执行删除
+    deleted_count = 0
+    for clip_id in valid_ids:
+        if svc.delete_clip(clip_id):
+            deleted_count += 1
+
+    message = f"成功删除 {deleted_count} 个片段"
+    if skipped > 0:
+        message += f"，跳过 {skipped} 个不存在的片段"
+
+    logger.info(
+        "批量删除片段: plan_id=%s deleted=%d skipped=%d by user=%s",
+        plan_id,
+        deleted_count,
+        skipped,
+        current_user.user.id,
+    )
+
+    return ClipBatchDeleteResponse(
+        success=True,
+        deleted_count=deleted_count,
+        message=message,
+    )
+
+
+@router.post("/from-assets", response_model=ClipsFromAssetsResponse)
+def create_clips_from_assets(
+    plan_id: str,
+    body: ClipsFromAssetsRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ClipsFromAssetsResponse:
+    """从素材批量创建片段（追加到时间线末尾）
+
+    一次性将多个素材作为片段添加到剪辑计划，自动读取素材时长。
+    自动触发编辑状态回退（completed/failed → editing）。
+    """
+    _check_plan_access(plan_id, current_user.user.id, project_repository, db)
+
+    svc = _get_svc(db)
+
+    try:
+        clips = svc.create_clips_from_assets(
+            plan_id=plan_id,
+            asset_ids=body.asset_ids,
+            clip_type=body.clip_type,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+
+    clip_ids = [c.id for c in clips]
+
+    logger.info(
+        "从素材批量创建片段: plan_id=%s count=%d by user=%s",
+        plan_id,
+        len(clips),
+        current_user.user.id,
+    )
+
+    return ClipsFromAssetsResponse(
+        success=True,
+        created_count=len(clips),
+        message=f"成功创建 {len(clips)} 个片段",
+        clip_ids=clip_ids,
+    )

apps/api/app/api/routes/edit_plans_cover.py

@@ -0,0 +1,315 @@
+"""封面管理 API.
+
+- GET    /{plan_id}/cover              获取封面配置
+- PUT    /{plan_id}/cover              更新封面配置
+- POST   /{plan_id}/cover/extract      从指定片段抽帧生成封面
+- POST   /{plan_id}/cover/smart        智能选帧生成封面
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from app.auth import AuthenticatedUser, get_current_user
+from app.core.storage import get_storage_service
+from app.dependencies import (
+    get_asset_repository,
+    get_db_session,
+    get_project_repository,
+)
+from app.services import EditPlanService
+from app.services.cover_service import CoverService
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+from packages.domain.config_schemas import normalize_plan_config
+
+from ._helpers import check_project_access
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# ── Schemas ──────────────────────────────────────────────────────────────────
+
+
+class CoverConfigResponse(BaseModel):
+    """封面配置响应"""
+
+    type: str = Field(..., description="封面类型: ai_frame / manual / upload")
+    image_url: str = Field(default="", description="封面图片 URL")
+    frame_time: Optional[float] = Field(default=None, description="抽帧时间点（秒）")
+
+
+class CoverUpdateRequest(BaseModel):
+    """更新封面配置请求"""
+
+    type: Optional[str] = Field(default=None, description="封面类型")
+    image_url: Optional[str] = Field(default=None, description="封面图片 URL")
+    frame_time: Optional[float] = Field(default=None, ge=0.0, description="抽帧时间点（秒）")
+
+
+class CoverExtractRequest(BaseModel):
+    """从片段抽帧生成封面请求"""
+
+    clip_id: str = Field(..., description="片段 ID")
+    frame_time: float = Field(1.0, ge=0.0, description="抽帧时间点（秒）")
+
+
+class CoverSmartRequest(BaseModel):
+    """智能选帧请求"""
+
+    clip_id: Optional[str] = Field(default=None, description="指定片段 ID（不传则用第一个视频片段）")
+
+
+class CoverGenerateResponse(BaseModel):
+    """封面生成响应"""
+
+    type: str = Field(..., description="封面类型")
+    image_url: str = Field(..., description="封面图片 URL")
+    frame_time: Optional[float] = Field(default=None, description="抽帧时间点（秒）")
+
+
+# ── Routes ───────────────────────────────────────────────────────────────────
+
+
+@router.get("/{plan_id}/cover", response_model=CoverConfigResponse)
+def get_cover(
+    plan_id: str,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> CoverConfigResponse:
+    """获取封面配置"""
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    cover = CoverService.get_cover_config(plan.config or {})
+    return CoverConfigResponse(**cover)
+
+
+@router.put("/{plan_id}/cover", response_model=CoverConfigResponse)
+def update_cover(
+    plan_id: str,
+    body: CoverUpdateRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> CoverConfigResponse:
+    """更新封面配置
+
+    用于：设置上传的封面图片 URL、切换封面类型、调整时间点等。
+    """
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    # 合并更新
+    current_cover = CoverService.get_cover_config(plan.config or {})
+    updates = body.model_dump(exclude_none=True)
+    new_cover = {**current_cover, **updates}
+
+    # 验证 type 值
+    valid_types = {"ai_frame", "manual", "upload", "ai_regenerate"}
+    if "type" in updates and updates["type"] not in valid_types:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"无效的封面类型: {updates['type']}，有效值: {valid_types}",
+        )
+
+    # 更新到 plan.config
+    current_config = dict(plan.config or {})
+    current_config["cover"] = new_cover
+    normalized = normalize_plan_config(current_config)
+    updated_plan = svc.update_plan_config(plan_id, {"cover": normalized["cover"]})
+
+    result = CoverService.get_cover_config(updated_plan.config or {})
+    logger.info("更新封面配置: plan_id=%s type=%s by user=%s", plan_id, result["type"], current_user.user.id)
+    return CoverConfigResponse(**result)
+
+
+@router.post("/{plan_id}/cover/extract", response_model=CoverGenerateResponse)
+def extract_cover(
+    plan_id: str,
+    body: CoverExtractRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+    storage_service: Any = Depends(get_storage_service),
+    asset_repository: Any = Depends(get_asset_repository),
+) -> CoverGenerateResponse:
+    """从指定片段的指定时间点抽帧生成封面"""
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    # 获取片段对应的素材
+    clip = svc.get_clip(body.clip_id)
+    if not clip:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"片段不存在: {body.clip_id}",
+        )
+
+    if clip.plan_id != plan_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="片段不属于该剪辑计划",
+        )
+
+    if not clip.asset_id:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="片段没有关联素材，无法抽帧",
+        )
+
+    # 抽帧生成封面
+    cover_svc = CoverService(storage_service, asset_repository)
+    try:
+        cover_data = cover_svc.extract_cover_from_clip(
+            plan_id=plan_id,
+            asset_id=clip.asset_id,
+            frame_time=body.frame_time,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+    except RuntimeError as e:
+        logger.error("封面抽帧失败: plan_id=%s clip_id=%s error=%s", plan_id, body.clip_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"封面抽帧失败: {e}",
+        ) from e
+
+    # 更新到 plan.config.cover
+    current_config = dict(plan.config or {})
+    current_config["cover"] = cover_data
+    normalized = normalize_plan_config(current_config)
+    svc.update_plan_config(plan_id, {"cover": normalized["cover"]})
+
+    logger.info(
+        "封面抽帧完成: plan_id=%s clip_id=%s time=%.2fs by user=%s",
+        plan_id,
+        body.clip_id,
+        body.frame_time,
+        current_user.user.id,
+    )
+    return CoverGenerateResponse(**cover_data)
+
+
+@router.post("/{plan_id}/cover/smart", response_model=CoverGenerateResponse)
+def smart_cover(
+    plan_id: str,
+    body: CoverSmartRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+    storage_service: Any = Depends(get_storage_service),
+    asset_repository: Any = Depends(get_asset_repository),
+) -> CoverGenerateResponse:
+    """智能选帧生成封面
+
+    从指定片段（或第一个视频片段）中智能选取一帧作为封面。
+    当前实现：取片段第3秒帧（后续可优化为多帧选最清晰）。
+    """
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    # 确定使用哪个片段
+    clip_id = body.clip_id
+    asset_id = ""
+
+    if clip_id:
+        clip = svc.get_clip(clip_id)
+        if not clip:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"片段不存在: {clip_id}",
+            )
+        if clip.plan_id != plan_id:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="片段不属于该剪辑计划",
+            )
+        if not clip.asset_id:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="片段没有关联素材",
+            )
+        asset_id = clip.asset_id
+    else:
+        # 找第一个有素材的视频片段
+        clips = svc.list_clips(plan_id, limit=50, skip=0)
+        for c in clips:
+            if c.asset_id and c.clip_type == "video":
+                asset_id = c.asset_id
+                clip_id = c.id
+                break
+
+        if not asset_id:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="没有找到可用的视频片段",
+            )
+
+    # 智能选帧
+    cover_svc = CoverService(storage_service, asset_repository)
+    try:
+        cover_data = cover_svc.generate_smart_cover(
+            plan_id=plan_id,
+            asset_id=asset_id,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+    except RuntimeError as e:
+        logger.error("智能封面生成失败: plan_id=%s error=%s", plan_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"智能封面生成失败: {e}",
+        ) from e
+
+    # 更新到 plan.config.cover
+    current_config = dict(plan.config or {})
+    current_config["cover"] = cover_data
+    normalized = normalize_plan_config(current_config)
+    svc.update_plan_config(plan_id, {"cover": normalized["cover"]})
+
+    logger.info(
+        "智能封面生成完成: plan_id=%s clip_id=%s by user=%s",
+        plan_id,
+        clip_id,
+        current_user.user.id,
+    )
+    return CoverGenerateResponse(**cover_data)

apps/api/app/api/routes/edit_plans_export.py

@@ -0,0 +1,274 @@
+"""导出设置 API.
+
+- GET    /{plan_id}/export              获取导出配置
+- PUT    /{plan_id}/export              更新导出配置
+- GET    /export-presets                 导出预设列表
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any, List, Optional
+
+from app.auth import AuthenticatedUser, get_current_user
+from app.dependencies import get_db_session, get_project_repository
+from app.services import EditPlanService
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, Field, validator
+from sqlalchemy.orm import Session
+
+from packages.domain.config_schemas import normalize_plan_config
+
+from ._helpers import check_project_access
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# ── 导出预设 ──────────────────────────────────────────────────────────────────
+
+EXPORT_PRESETS = [
+    {
+        "id": "export_1080p_30",
+        "name": "1080P 高清",
+        "resolution": "1080x1920",
+        "fps": 30,
+        "video_bitrate": 8000,
+        "audio_bitrate": 128,
+        "format": "mp4",
+        "quality_preset": "balanced",
+        "description": "竖屏高清，适合短视频平台",
+        "size_hint": "约 10MB/分钟",
+    },
+    {
+        "id": "export_1080p_60",
+        "name": "1080P 高帧率",
+        "resolution": "1080x1920",
+        "fps": 60,
+        "video_bitrate": 12000,
+        "audio_bitrate": 128,
+        "format": "mp4",
+        "quality_preset": "high",
+        "description": "60帧高帧率，流畅运动画面",
+        "size_hint": "约 18MB/分钟",
+    },
+    {
+        "id": "export_720p_30",
+        "name": "720P 流畅",
+        "resolution": "720x1280",
+        "fps": 30,
+        "video_bitrate": 4000,
+        "audio_bitrate": 128,
+        "format": "mp4",
+        "quality_preset": "fast",
+        "description": "快速导出，文件较小",
+        "size_hint": "约 5MB/分钟",
+    },
+    {
+        "id": "export_4k_30",
+        "name": "4K 超清",
+        "resolution": "2160x3840",
+        "fps": 30,
+        "video_bitrate": 20000,
+        "audio_bitrate": 192,
+        "format": "mp4",
+        "quality_preset": "best",
+        "description": "4K超清画质，专业品质",
+        "size_hint": "约 30MB/分钟",
+    },
+    {
+        "id": "export_1080p_30_mov",
+        "name": "1080P ProRes",
+        "resolution": "1080x1920",
+        "fps": 30,
+        "video_bitrate": 15000,
+        "audio_bitrate": 256,
+        "format": "mov",
+        "quality_preset": "high",
+        "description": "MOV格式，适合后期剪辑",
+        "size_hint": "约 25MB/分钟",
+    },
+]
+
+VALID_QUALITY_PRESETS = {"ultra_fast", "fast", "balanced", "high", "best"}
+VALID_FORMATS = {"mp4", "mov"}
+
+RESOLUTION_PATTERN = re.compile(r"^\d+x\d+$")
+
+
+# ── Schemas ──────────────────────────────────────────────────────────────────
+
+
+class ExportConfigResponse(BaseModel):
+    """导出配置响应"""
+
+    resolution: str
+    fps: int
+    video_bitrate: int
+    audio_bitrate: int
+    format: str
+    quality_preset: str
+    watermark_enabled: bool
+    watermark_text: str
+
+
+class ExportUpdateRequest(BaseModel):
+    """更新导出配置请求"""
+
+    resolution: Optional[str] = None
+    fps: Optional[int] = Field(default=None, ge=15, le=60)
+    video_bitrate: Optional[int] = Field(default=None, ge=1000, le=20000)
+    audio_bitrate: Optional[int] = Field(default=None, ge=64, le=320)
+    format: Optional[str] = None
+    quality_preset: Optional[str] = None
+    watermark_enabled: Optional[bool] = None
+    watermark_text: Optional[str] = None
+
+    @validator("resolution")
+    def validate_resolution(cls, v):
+        if v is None:
+            return v
+        if not RESOLUTION_PATTERN.match(v):
+            raise ValueError("分辨率格式错误，应为 宽x高，如 1080x1920")
+        w, h = v.split("x")
+        if int(w) < 100 or int(h) < 100:
+            raise ValueError("分辨率数值过小")
+        if int(w) > 4096 or int(h) > 4096:
+            raise ValueError("分辨率数值过大，最大 4096x4096")
+        return v
+
+    @validator("format")
+    def validate_format(cls, v):
+        if v is None:
+            return v
+        if v not in VALID_FORMATS:
+            raise ValueError(f"无效格式: {v}，支持: {VALID_FORMATS}")
+        return v
+
+    @validator("quality_preset")
+    def validate_quality_preset(cls, v):
+        if v is None:
+            return v
+        if v not in VALID_QUALITY_PRESETS:
+            raise ValueError(f"无效质量预设: {v}，支持: {VALID_QUALITY_PRESETS}")
+        return v
+
+
+class ExportPresetItem(BaseModel):
+    """导出预设条目"""
+
+    id: str
+    name: str
+    resolution: str
+    fps: int
+    video_bitrate: int
+    audio_bitrate: int
+    format: str
+    quality_preset: str
+    description: str
+    size_hint: str
+
+
+class ExportPresetListResponse(BaseModel):
+    """导出预设列表响应"""
+
+    items: List[ExportPresetItem]
+    total: int
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _get_export_config(plan_config: dict) -> dict:
+    e = plan_config.get("export", {})
+    if not isinstance(e, dict):
+        e = {}
+    return {
+        "resolution": e.get("resolution", "1080x1920"),
+        "fps": e.get("fps", 30),
+        "video_bitrate": e.get("video_bitrate", 8000),
+        "audio_bitrate": e.get("audio_bitrate", 128),
+        "format": e.get("format", "mp4"),
+        "quality_preset": e.get("quality_preset", "balanced"),
+        "watermark_enabled": e.get("watermark_enabled", False),
+        "watermark_text": e.get("watermark_text", ""),
+    }
+
+
+# ── Routes ───────────────────────────────────────────────────────────────────
+
+
+@router.get("/export-presets", response_model=ExportPresetListResponse)
+def list_export_presets(
+    current_user: AuthenticatedUser = Depends(get_current_user),
+) -> ExportPresetListResponse:
+    """获取导出预设列表"""
+    items = [ExportPresetItem(**p) for p in EXPORT_PRESETS]
+    return ExportPresetListResponse(items=items, total=len(items))
+
+
+@router.get("/{plan_id}/export", response_model=ExportConfigResponse)
+def get_export_config(
+    plan_id: str,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ExportConfigResponse:
+    """获取导出配置"""
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    config = _get_export_config(plan.config or {})
+    return ExportConfigResponse(**config)
+
+
+@router.put("/{plan_id}/export", response_model=ExportConfigResponse)
+def update_export_config(
+    plan_id: str,
+    body: ExportUpdateRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ExportConfigResponse:
+    """更新导出配置"""
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    # 合并更新
+    current = _get_export_config(plan.config or {})
+    updates = body.model_dump(exclude_none=True)
+    new_export = {**current, **updates}
+
+    # 更新到 plan.config
+    current_config = dict(plan.config or {})
+    current_config["export"] = new_export
+    normalized = normalize_plan_config(current_config)
+    updated_plan = svc.update_plan_config(plan_id, {"export": normalized["export"]})
+
+    result = _get_export_config(updated_plan.config or {})
+    logger.info(
+        "更新导出配置: plan_id=%s resolution=%s fps=%d by user=%s",
+        plan_id,
+        result["resolution"],
+        result["fps"],
+        current_user.user.id,
+    )
+    return ExportConfigResponse(**result)

apps/api/app/api/routes/edit_plans_filter.py

@@ -0,0 +1,197 @@
+"""滤镜调色 API.
+
+- GET    /filter-presets            滤镜预设列表
+- GET    /{plan_id}/filter          获取全局滤镜配置
+- PUT    /{plan_id}/filter          更新全局滤镜配置
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, List, Optional
+
+from app.auth import AuthenticatedUser, get_current_user
+from app.dependencies import get_db_session, get_project_repository
+from app.services import EditPlanService
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+from packages.domain.config_schemas import normalize_plan_config
+from packages.domain.filter_presets import (
+    FilterPreset,
+    get_filter_preset,
+    list_filter_presets,
+)
+
+from ._helpers import check_project_access
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# ── Schemas ──────────────────────────────────────────────────────────────────
+
+
+class FilterPresetResponse(BaseModel):
+    """滤镜预设响应"""
+
+    id: str
+    name: str
+    category: str
+    description: str
+    tags: List[str] = Field(default_factory=list)
+
+
+class FilterConfigResponse(BaseModel):
+    """滤镜配置响应"""
+
+    enabled: bool
+    preset_id: str
+    intensity: int
+    brightness: float
+    contrast: float
+    saturation: float
+    warmth: float
+
+
+class FilterUpdateRequest(BaseModel):
+    """更新滤镜配置请求"""
+
+    enabled: Optional[bool] = None
+    preset_id: Optional[str] = None
+    intensity: Optional[int] = Field(default=None, ge=0, le=100)
+    brightness: Optional[float] = Field(default=None, ge=-1.0, le=1.0)
+    contrast: Optional[float] = Field(default=None, ge=0.0, le=2.0)
+    saturation: Optional[float] = Field(default=None, ge=0.0, le=3.0)
+    warmth: Optional[float] = Field(default=None, ge=-1.0, le=1.0)
+
+
+class FilterPresetListResponse(BaseModel):
+    """滤镜预设列表响应"""
+
+    items: List[FilterPresetResponse]
+    total: int
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _preset_to_response(p: FilterPreset) -> FilterPresetResponse:
+    return FilterPresetResponse(
+        id=p.id,
+        name=p.name,
+        category=p.category,
+        description=p.description,
+        tags=list(p.tags),
+    )
+
+
+def _get_filter_config(plan_config: dict) -> dict:
+    """从 plan.config 中提取滤镜配置"""
+    f = plan_config.get("filter", {})
+    if not isinstance(f, dict):
+        f = {}
+    return {
+        "enabled": f.get("enabled", False),
+        "preset_id": f.get("preset_id", "filter_none"),
+        "intensity": f.get("intensity", 100),
+        "brightness": f.get("brightness", 0.0),
+        "contrast": f.get("contrast", 1.0),
+        "saturation": f.get("saturation", 1.0),
+        "warmth": f.get("warmth", 0.0),
+    }
+
+
+# ── Routes ───────────────────────────────────────────────────────────────────
+
+
+@router.get("/filter-presets", response_model=FilterPresetListResponse)
+def list_presets(
+    category: Optional[str] = Query(default=None, description="按分类筛选"),
+    keyword: Optional[str] = Query(default=None, description="关键词搜索"),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+) -> FilterPresetListResponse:
+    """获取滤镜预设列表"""
+    presets = list_filter_presets(category=category, keyword=keyword)
+    items = [_preset_to_response(p) for p in presets]
+    return FilterPresetListResponse(items=items, total=len(items))
+
+
+@router.get("/{plan_id}/filter", response_model=FilterConfigResponse)
+def get_filter(
+    plan_id: str,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> FilterConfigResponse:
+    """获取剪辑计划的全局滤镜配置"""
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    config = _get_filter_config(plan.config or {})
+    return FilterConfigResponse(**config)
+
+
+@router.put("/{plan_id}/filter", response_model=FilterConfigResponse)
+def update_filter(
+    plan_id: str,
+    body: FilterUpdateRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> FilterConfigResponse:
+    """更新全局滤镜配置"""
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    # 验证 preset_id
+    updates = body.model_dump(exclude_none=True)
+    if "preset_id" in updates:
+        preset = get_filter_preset(updates["preset_id"])
+        if preset is None:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"无效的滤镜预设: {updates['preset_id']}",
+            )
+
+    # 合并更新
+    current = _get_filter_config(plan.config or {})
+    new_filter = {**current, **updates}
+
+    # 如果设为原图 preset，自动关闭
+    if new_filter["preset_id"] == "filter_none":
+        new_filter["enabled"] = False
+
+    # 更新到 plan.config
+    current_config = dict(plan.config or {})
+    current_config["filter"] = new_filter
+    normalized = normalize_plan_config(current_config)
+    updated_plan = svc.update_plan_config(plan_id, {"filter": normalized["filter"]})
+
+    result = _get_filter_config(updated_plan.config or {})
+    logger.info(
+        "更新滤镜配置: plan_id=%s preset=%s intensity=%d by user=%s",
+        plan_id,
+        result["preset_id"],
+        result["intensity"],
+        current_user.user.id,
+    )
+    return FilterConfigResponse(**result)

apps/api/app/api/routes/edit_plans_generation.py

@@ -20,6 +20,7 @@ from app.api.routes.edit_plans import (
 )
 from app.auth import AuthenticatedUser, get_current_user
 from app.core.celery_app import celery_app
+from app.core.storage import OSSStorageService, get_storage_service
 from app.core.task_enqueue import GLOBAL_PENDING_LIMIT, USER_PENDING_LIMIT
 from app.dependencies import get_asset_library_repository, get_asset_repository, get_db_session, get_project_repository
 from app.services import EditPlanService
@@ -131,17 +132,21 @@ def _auto_fallback_auto_material_mode(
     asset_library_repo: Any,
     asset_repo: Any,
 ) -> None:
-    """自动兜底 4: 自动素材模式 → 从项目默认视频素材库选取"""
+    """自动兜底 4: 项目有视频素材库时，自动选取 ready 视频素材分配给无素材片段
+
+    注：原先需要 material_mode=="auto" 才触发，但全代码库没有任何地方设置为 auto，
+    导致这道兜底防线永远不生效。现改为：只要有 project_id 且存在无素材片段，
+    就自动从项目视频素材库选取素材兜底，确保一键生成等场景能正常出片。
+    """
     if not clips_without_asset:
         return
-    material_mode = (plan_check.config or {}).get("material_mode", "manual")
-    if material_mode != "auto" or not plan_check.project_id:
+    if not plan_check.project_id:
         return
 
     import random
 
     logger.info(
-        "自动兜底4: plan=%s 自动素材模式，从项目素材库选取素材 (%d 个片段需要)",
+        "自动兜底4: plan=%s 自动选素材分配给 %d 个无素材片段",
         plan_id,
         len(clips_without_asset),
     )
@@ -183,9 +188,7 @@ def _auto_fallback_auto_material_mode(
 def _check_queue_limits(gen_task_repo, user_id: str) -> None:
     """队列限流预检查"""
     try:
-        has_count = hasattr(gen_task_repo, "count_pending_by_user") and hasattr(
-            gen_task_repo, "count_pending_total"
-        )
+        has_count = hasattr(gen_task_repo, "count_pending_by_user") and hasattr(gen_task_repo, "count_pending_total")
         if has_count:
             user_pending = gen_task_repo.count_pending_by_user(user_id)
             global_pending = gen_task_repo.count_pending_total()
@@ -241,7 +244,7 @@ def generate_plan(
     try:
         can_gen, reason = svc.can_generate(plan_id)
     except ValueError as exc:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc))
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
     if not can_gen:
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=reason)
 
@@ -255,12 +258,15 @@ def generate_plan(
 
         gen_task_use_case = CreateGenerationTaskUseCase(gen_task_repo)
         plan = svc.get_plan_or_raise(plan_id)
+        # 从 plan.config 中读取 asset_ids 并传递给 GenerationTask
+        config_asset_ids = (plan.config or {}).get("asset_ids", [])
         gen_task = gen_task_use_case.execute(
             CreateGenerationTaskCommand(
-                project_id="",
+                project_id=plan.project_id or "",
                 template_id=plan.template_id,
                 created_by_user_id=current_user.user.id,
                 source_edit_plan_id=plan_id,
+                asset_ids=list(config_asset_ids) if config_asset_ids else [],
             )
         )
 
@@ -286,7 +292,7 @@ def generate_plan(
         )
     except HTTPException:
         raise
-    except Exception:
+    except Exception as _e:
         logger.exception("触发剪辑计划生成失败: plan_id=%s", plan_id)
         try:
             svc.transition_status(plan_id, EditPlanStatus.FAILED)
@@ -295,7 +301,7 @@ def generate_plan(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="生成失败，请稍后重试",
-        )
+        ) from _e
 
 
 @router.get(
@@ -307,13 +313,14 @@ def get_generation_status(
     db: Session = Depends(get_db_session),
     current_user: AuthenticatedUser = Depends(get_current_user),
     project_repository: Any = Depends(get_project_repository),
+    storage_service: OSSStorageService = Depends(get_storage_service),
 ) -> EditPlanGenerationStatusResponse:
     """查询剪辑计划生成进度"""
     svc = EditPlanService(db)
     try:
         gen_status = svc.get_generation_status(plan_id)
     except ValueError as exc:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc))
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
 
     plan = gen_status["plan"]
     if plan.project_id:
@@ -333,10 +340,32 @@ def get_generation_status(
         for c in clips
     ]
 
+    # 从 plan.config 中取渲染结果 URL，转换为签名 URL
+    raw_video_url = (plan.config or {}).get("rendered_url", "")
+    video_url = ""
+    if raw_video_url:
+        try:
+            video_url = storage_service.get_download_url(raw_video_url, expires_seconds=86400)
+        except Exception as e:
+            logger.warning("生成视频签名URL失败，返回原始URL: plan_id=%s error=%s", plan_id, e)
+            video_url = raw_video_url
+    # 从 gen_status 中取进度、错误信息、任务状态
+    progress = gen_status.get("progress", 0.0)
+    error_message = gen_status.get("error_message", "")
+    gen_task_status = gen_status.get("generation_task_status")
+    # 如果计划已完成但进度还是0，补100
+    plan_status_val = plan.status.value if hasattr(plan.status, "value") else plan.status
+    if plan_status_val == "completed" and progress < 100:
+        progress = 100.0
+
     return EditPlanGenerationStatusResponse(
         plan_id=plan_id,
-        plan_status=plan.status.value if hasattr(plan.status, "value") else plan.status,
+        plan_status=plan_status_val,
         generation_task_id=gen_status["generation_task_id"],
+        generation_task_status=gen_task_status,
+        progress=progress,
+        video_url=video_url,
+        error_message=error_message,
         clips=clip_items,
     )
 

apps/api/app/api/routes/edit_plans_timeline.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import logging
 from typing import Any, List
 
-from app.api.routes._helpers import check_project_access
+from app.api.routes._helpers import auto_select_video_assets, check_project_access
 from app.api.routes.edit_plans import (
     GenerateFromTemplateRequest,
     GenerateFromTemplateResponse,
@@ -18,9 +18,14 @@ from app.api.routes.edit_plans import (
     _to_response,
 )
 from app.auth import AuthenticatedUser, get_current_user
-from app.dependencies import get_db_session, get_project_repository
+from app.dependencies import (
+    get_asset_library_repository,
+    get_asset_repository,
+    get_db_session,
+    get_project_repository,
+)
 from app.services import EditPlanService, PlanGeneratorService
-from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel, Field
 from sqlalchemy.orm import Session
 
@@ -161,6 +166,8 @@ def generate_from_template(
     db: Session = Depends(get_db_session),
     current_user: AuthenticatedUser = Depends(get_current_user),
     project_repository: Any = Depends(get_project_repository),
+    asset_repository: Any = Depends(get_asset_repository),
+    asset_library_repository: Any = Depends(get_asset_library_repository),
 ) -> GenerateFromTemplateResponse:
     """基于模板 + 素材自动生成剪辑计划"""
     from app.services import EditTemplateService
@@ -173,15 +180,32 @@ def generate_from_template(
     try:
         template = template_svc.get_template_or_raise(body.template_id)
     except ValueError as exc:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc))
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
 
     clip_configs = template_svc.list_clip_configs(body.template_id, skip=0, limit=200)
 
+    # 自动选素材：未传 asset_ids 但有 project_id 时，从项目视频素材库选 ready 的视频素材
+    resolved_asset_ids = list(body.asset_ids)
+    if not resolved_asset_ids and body.project_id:
+        auto_assets = auto_select_video_assets(
+            project_id=body.project_id,
+            asset_library_repo=asset_library_repository,
+            asset_repo=asset_repository,
+            logger=logger,
+        )
+        if auto_assets:
+            resolved_asset_ids = auto_assets
+            logger.info(
+                "generate-from-template 自动选素材: project_id=%s count=%d",
+                body.project_id,
+                len(auto_assets),
+            )
+
     generator = PlanGeneratorService(db)
     result = generator.generate_from_template(
         template=template,
         clip_configs=clip_configs,
-        asset_ids=body.asset_ids,
+        asset_ids=resolved_asset_ids,
         project_id=body.project_id,
         created_by_user_id=current_user.user.id,
         name=body.name,
@@ -190,8 +214,20 @@ def generate_from_template(
     plan = result["plan"]
     clips = result["clips"]
 
+    # 把 asset_ids 写入 plan.config，供生成时兜底分配使用
+    if resolved_asset_ids:
+        from app.services import EditPlanService
+
+        from packages.domain.config_schemas import normalize_plan_config
+
+        svc = EditPlanService(db)
+        current_config = plan.config or {}
+        if current_config.get("asset_ids") != resolved_asset_ids:
+            current_config["asset_ids"] = resolved_asset_ids
+            plan = svc.update_plan(plan.id, config=normalize_plan_config(current_config))
+
     logger.info(
-        "基于模板生成剪辑计划: plan_id=%s template_id=%s clips=%d by user=%s",
+        "基于模板生成剪辑计划: plan_id=%s template_id=%s clips=%d by user=%d",
         plan.id,
         body.template_id,
         len(clips),

apps/api/app/api/routes/edit_plans_transitions.py

@@ -0,0 +1,272 @@
+"""转场特效 API.
+
+- GET    /transition-presets              转场预设列表
+- PUT    /clips/{clip_id}/transition      设置单个片段转场
+- POST   /{plan_id}/transitions/batch     批量设置转场（所有片段）
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, List, Optional
+
+from app.auth import AuthenticatedUser, get_current_user
+from app.dependencies import get_db_session, get_project_repository
+from app.services import EditPlanService
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
+
+from packages.domain.transition_presets import (
+    TransitionPreset,
+    get_transition_preset,
+    list_transition_presets,
+)
+
+from ._helpers import check_project_access
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# ── Schemas ──────────────────────────────────────────────────────────────────
+
+
+class TransitionPresetResponse(BaseModel):
+    """转场预设响应"""
+
+    id: str
+    name: str
+    category: str
+    description: str
+    tags: List[str] = Field(default_factory=list)
+    default_duration: float
+    min_duration: float
+    max_duration: float
+
+
+class TransitionUpdateRequest(BaseModel):
+    """更新转场请求"""
+
+    effect: str = Field(..., description="转场效果 ID")
+    duration: Optional[float] = Field(default=None, ge=0.0, description="转场时长（秒）")
+
+
+class BatchTransitionRequest(BaseModel):
+    """批量设置转场请求"""
+
+    effect: str = Field(..., description="转场效果 ID")
+    duration: Optional[float] = Field(default=None, ge=0.0, description="转场时长（秒）")
+    apply_to: str = Field(
+        default="all",
+        description="应用范围: all=所有片段, except_first=除第一个外, except_last=除最后一个, middle=中间片段",
+    )
+
+
+class ClipTransitionResponse(BaseModel):
+    """片段转场信息响应"""
+
+    clip_id: str
+    effect: str
+    duration: float
+
+
+class BatchTransitionResponse(BaseModel):
+    """批量转场响应"""
+
+    updated_count: int
+    plan_id: str
+
+
+class TransitionPresetListResponse(BaseModel):
+    """转场预设列表响应"""
+
+    items: List[TransitionPresetResponse]
+    total: int
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _preset_to_response(p: TransitionPreset) -> TransitionPresetResponse:
+    return TransitionPresetResponse(
+        id=p.id,
+        name=p.name,
+        category=p.category,
+        description=p.description,
+        tags=list(p.tags),
+        default_duration=p.default_duration,
+        min_duration=p.min_duration,
+        max_duration=p.max_duration,
+    )
+
+
+def _validate_transition(effect: str, duration: Optional[float] = None) -> tuple[str, float]:
+    """验证转场效果和时长，返回 (effect, duration)"""
+    preset = get_transition_preset(effect)
+    if preset is None:
+        raise ValueError(f"无效的转场效果: {effect}")
+
+    # 硬切特殊处理，时长强制为0
+    if effect == "transition_none" or preset.transition == "none":
+        return "cut", 0.0
+
+    final_duration = duration if duration is not None else preset.default_duration
+    if final_duration < preset.min_duration:
+        final_duration = preset.min_duration
+    if final_duration > preset.max_duration:
+        final_duration = preset.max_duration
+
+    return preset.transition, round(final_duration, 3)
+
+
+# ── Routes ───────────────────────────────────────────────────────────────────
+
+
+@router.get("/transition-presets", response_model=TransitionPresetListResponse)
+def list_presets(
+    category: Optional[str] = Query(default=None, description="按分类筛选"),
+    keyword: Optional[str] = Query(default=None, description="关键词搜索"),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+) -> TransitionPresetListResponse:
+    """获取转场预设列表"""
+    presets = list_transition_presets(category=category, keyword=keyword)
+    items = [_preset_to_response(p) for p in presets]
+    return TransitionPresetListResponse(items=items, total=len(items))
+
+
+@router.put("/clips/{clip_id}/transition", response_model=ClipTransitionResponse)
+def update_clip_transition(
+    clip_id: str,
+    body: TransitionUpdateRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> ClipTransitionResponse:
+    """设置单个片段的转场效果"""
+    svc = EditPlanService(db)
+    clip = svc.get_clip(clip_id)
+    if not clip:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"片段不存在: {clip_id}",
+        )
+
+    plan = svc.get_plan(clip.plan_id)
+    if plan and plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    # 验证转场参数
+    try:
+        effect, duration = _validate_transition(body.effect, body.duration)
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+
+    # 更新片段
+    updated_clip = svc.update_clip(
+        clip_id,
+        transition_effect=effect,
+        transition_duration=duration,
+    )
+
+    logger.info(
+        "更新片段转场: clip_id=%s effect=%s duration=%.3f by user=%s",
+        clip_id,
+        effect,
+        duration,
+        current_user.user.id,
+    )
+    return ClipTransitionResponse(
+        clip_id=clip_id,
+        effect=updated_clip.transition_effect,
+        duration=updated_clip.transition_duration,
+    )
+
+
+@router.post("/{plan_id}/transitions/batch", response_model=BatchTransitionResponse)
+def batch_update_transitions(
+    plan_id: str,
+    body: BatchTransitionRequest,
+    db: Session = Depends(get_db_session),
+    current_user: AuthenticatedUser = Depends(get_current_user),
+    project_repository: Any = Depends(get_project_repository),
+) -> BatchTransitionResponse:
+    """批量设置计划内所有片段的转场效果
+
+    apply_to 说明：
+    - all: 所有片段
+    - except_first: 除第一个片段外（第一个片段不需要前转场）
+    - except_last: 除最后一个片段外
+    - middle: 只设置中间片段（除首尾）
+    """
+    svc = EditPlanService(db)
+    plan = svc.get_plan(plan_id)
+    if not plan:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"剪辑计划不存在: {plan_id}",
+        )
+
+    if plan.project_id:
+        check_project_access(plan.project_id, current_user.user.id, project_repository)
+
+    # 验证转场参数
+    try:
+        effect, duration = _validate_transition(body.effect, body.duration)
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
+
+    # 获取所有片段
+    clips = svc.list_clips(plan_id, limit=500, skip=0)
+    if not clips:
+        return BatchTransitionResponse(updated_count=0, plan_id=plan_id)
+
+    # 确定应用范围
+    total = len(clips)
+    if total <= 1:
+        # 只有一个片段时，只有 all 模式才应用
+        if body.apply_to != "all":
+            return BatchTransitionResponse(updated_count=0, plan_id=plan_id)
+
+    # 按 order 排序
+    clips_sorted = sorted(clips, key=lambda c: c.order)
+    indices_to_update = []
+
+    if body.apply_to == "all":
+        indices_to_update = list(range(total))
+    elif body.apply_to == "except_first":
+        indices_to_update = list(range(1, total))
+    elif body.apply_to == "except_last":
+        indices_to_update = list(range(total - 1))
+    elif body.apply_to == "middle":
+        if total <= 2:
+            indices_to_update = []
+        else:
+            indices_to_update = list(range(1, total - 1))
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"无效的 apply_to: {body.apply_to}",
+        )
+
+    # 批量更新
+    count = 0
+    for idx in indices_to_update:
+        clip = clips_sorted[idx]
+        svc.update_clip(
+            clip.id,
+            transition_effect=effect,
+            transition_duration=duration,
+        )
+        count += 1
+
+    logger.info(
+        "批量更新转场: plan_id=%s count=%d effect=%s apply_to=%s by user=%s",
+        plan_id,
+        count,
+        effect,
+        body.apply_to,
+        current_user.user.id,
+    )
+    return BatchTransitionResponse(updated_count=count, plan_id=plan_id)

apps/api/app/api/routes/feature_flags.py

@@ -105,7 +105,7 @@ async def list_feature_flags(
         return sorted(result, key=lambda x: x.name)
     except Exception as exc:
         logger.error("Failed to list feature flags: %s", exc)
-        raise HTTPException(status_code=500, detail=f"Failed to list flags: {exc}")
+        raise HTTPException(status_code=500, detail=f"Failed to list flags: {exc}") from exc
 
 
 @router.get("/{name}", response_model=FeatureFlagResponse)
@@ -120,7 +120,7 @@ async def get_feature_flag(
         return FeatureFlagResponse.from_config(config)
     except Exception as exc:
         logger.error("Failed to get feature flag %s: %s", name, exc)
-        raise HTTPException(status_code=500, detail=f"Failed to get flag: {exc}")
+        raise HTTPException(status_code=500, detail=f"Failed to get flag: {exc}") from exc
 
 
 @router.get("/{name}/check", response_model=FeatureFlagCheckResponse)
@@ -136,7 +136,7 @@ async def check_feature_flag(
         return FeatureFlagCheckResponse(name=name, active=active, identifier=identifier)
     except Exception as exc:
         logger.error("Failed to check feature flag %s: %s", name, exc)
-        raise HTTPException(status_code=500, detail=f"Failed to check flag: {exc}")
+        raise HTTPException(status_code=500, detail=f"Failed to check flag: {exc}") from exc
 
 
 @router.put("/{name}", response_model=FeatureFlagResponse)
@@ -170,7 +170,7 @@ async def update_feature_flag(
         return FeatureFlagResponse.from_config(config)
     except Exception as exc:
         logger.error("Failed to update feature flag %s: %s", name, exc)
-        raise HTTPException(status_code=500, detail=f"Failed to update flag: {exc}")
+        raise HTTPException(status_code=500, detail=f"Failed to update flag: {exc}") from exc
 
 
 @router.delete("/{name}", status_code=status.HTTP_204_NO_CONTENT, response_model=None, response_class=Response)
@@ -178,7 +178,7 @@ async def delete_feature_flag(
     name: str,
     _: bool = Depends(_verify_internal_api_key),
     store: RedisFeatureFlagStore = Depends(_get_feature_flag_store),
-) :
+):
     """删除 Feature Flag。
 
     只允许删除 ALLOWED_FLAGS 列表中的 flag。
@@ -191,4 +191,4 @@ async def delete_feature_flag(
         pass
     except Exception as exc:
         logger.error("Failed to delete feature flag %s: %s", name, exc)
-        raise HTTPException(status_code=500, detail=f"Failed to delete flag: {exc}")
+        raise HTTPException(status_code=500, detail=f"Failed to delete flag: {exc}") from exc

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

@@ -43,6 +43,7 @@ logger = logging.getLogger(__name__)
 
 router = APIRouter()
 
+
 def _to_generation_task_response(task) -> GenerationTaskResponse:
     return GenerationTaskResponse(
         id=task.id,
@@ -282,28 +283,28 @@ def create_generation_task(
                     created_tasks.append(task)
                 else:
                     failed_tasks.append(task)
-            except UserPendingLimitExceeded:
+            except UserPendingLimitExceeded as _e:
                 # 兜底：如果预检查后又并发提交了，在这里也拦住
                 failed_tasks.append(task)
                 if not created_tasks:
                     raise HTTPException(
                         status_code=429,
                         detail="您的待处理任务过多，请等待完成后再提交",
-                    )
+                    ) from _e
                 break
-            except GlobalQueueFull:
+            except GlobalQueueFull as _e:
                 failed_tasks.append(task)
                 if not created_tasks:
                     raise HTTPException(
                         status_code=503,
                         detail="系统繁忙，请稍后再试",
-                    )
+                    ) from _e
                 break
     except HTTPException:
         raise
     except Exception as e:
         logger.error("[生成任务] 创建失败: %s", e, exc_info=True)
-        raise HTTPException(status_code=500, detail="创建生成任务失败，请稍后重试或查看任务日志")
+        raise HTTPException(status_code=500, detail="创建生成任务失败，请稍后重试或查看任务日志") from e
 
     items = [_to_generation_task_response(t) for t in created_tasks + failed_tasks]
     return BatchGenerationTaskResponse(items=items, total=len(items))
@@ -426,3 +427,53 @@ def retry_generation_task(
             detail="系统繁忙，请稍后再试",
         ) from None
     return _to_generation_task_response(retried)
+
+
+@router.post("/tasks/{task_id}/cancel", response_model=GenerationTaskResponse)
+def cancel_generation_task(
+    task_id: str,
+    authenticated_user: AuthenticatedUser = Depends(get_current_user),
+    generation_task_repository: Any = Depends(get_generation_task_repository),
+) -> GenerationTaskResponse:
+    """取消生成任务。
+
+    仅 pending / running 状态的任务可取消；取消后状态变为 cancelled。
+    对于已在运行的 Celery 任务，标记为 cancelled 后，worker 在下次检查点会中止执行。
+    """
+    task = generation_task_repository.get(task_id)
+    if task is None:
+        raise HTTPException(status_code=404, detail="Generation task not found")
+
+    # 权限校验
+    if task.created_by_user_id and task.created_by_user_id != authenticated_user.user.id:
+        raise HTTPException(status_code=403, detail="Access denied to this task")
+
+    status_val = task.status.value if hasattr(task.status, "value") else str(task.status)
+
+    # 终态不可取消
+    if status_val in ("completed", "failed", "cancelled"):
+        raise HTTPException(
+            status_code=409,
+            detail=f"Cannot cancel task in {status_val} status",
+        )
+
+    # 执行取消
+    try:
+        task.mark_cancelled()
+        task.append_log(
+            stage="cancelled",
+            message="用户主动取消任务",
+            level="INFO",
+            cancelled_by=authenticated_user.user.id,
+        )
+        generation_task_repository.update(task)
+        logger.info(
+            "生成任务已取消: task_id=%s user_id=%s previous_status=%s",
+            task_id,
+            authenticated_user.user.id,
+            status_val,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e)) from e
+
+    return _to_generation_task_response(task)

apps/api/app/api/routes/projects.py

@@ -81,11 +81,11 @@ def delete_project(
     use_case = DeleteProjectUseCase(project_repository)
     try:
         deleted = use_case.execute(project_id, authenticated_user.user.id)
-    except PermissionError:
+    except PermissionError as _e:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Only the project owner can delete this project",
-        )
+        ) from _e
     if not deleted:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Project not found")
-    return
+    return  # type: ignore[return-value]

apps/api/app/api/routes/subscription.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from dataclasses import replace
 from datetime import datetime, timezone
 from typing import List
@@ -20,6 +21,8 @@ from fastapi import APIRouter, Depends, HTTPException, status
 
 from packages.ports.user_repository import UserRepository
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter()
 
 
@@ -254,7 +257,9 @@ async def payment_callback(
         return {"success": True, "message": "支付成功", "record_id": record_id}
     except Exception as e:
         session.rollback()
-        raise HTTPException(status_code=500, detail=f"支付处理失败: {str(e)}")
+        logger.error(f"支付回调处理失败: user_id={user_id}, plan={plan}, error={e}")
+        # 不返回原始异常信息，避免泄漏内部实现细节
+        raise HTTPException(status_code=500, detail="支付处理失败，请稍后重试") from e
     finally:
         session.close()
 

apps/api/app/api/routes/task_center.py

@@ -24,8 +24,6 @@ from app.schemas.task_center import (
 from fastapi import APIRouter, Depends, HTTPException, Query
 
 from packages.application import (
-    CreateGenerationTaskCommand,
-    CreateGenerationTaskUseCase,
     RetryGenerationTaskUseCase,
     SubmitIngestJobCommand,
     SubmitIngestJobUseCase,
@@ -368,9 +366,9 @@ def retry_project_task(
             raise HTTPException(status_code=404, detail="Ingest job not found")
         if _status_value(job.status) != "failed":
             raise HTTPException(status_code=409, detail="Only failed tasks can be retried")
-        use_case = SubmitIngestJobUseCase(ingest_job_repository)
+        use_case = SubmitIngestJobUseCase(ingest_job_repository)  # type: ignore[assignment]
         retried = use_case.execute(
-            SubmitIngestJobCommand(
+            SubmitIngestJobCommand(  # type: ignore[arg-type]
                 project_id=job.project_id,
                 library_id=job.library_id,
                 storage_key=job.storage_key,
@@ -386,6 +384,6 @@ def retry_project_task(
             current_step=_ingest_step(retried),
             source_id=retried.id,
             created_at=retried.created_at,
-            updated_at=retried.updated_at,
+            updated_at=retried.updated_at,  # type: ignore[attr-defined]
         )
     raise HTTPException(status_code=400, detail="Unsupported task type")

apps/api/app/api/routes/templates.py

@@ -45,7 +45,6 @@ from packages.application.template.use_cases import (
     CreateTemplateUseCase,
     DeleteCategoryUseCase,
     DeleteTemplateUseCase,
-    GetTemplateUsageUseCase,
     GetTemplateUseCase,
     ListCategoriesUseCase,
     ListTagsUseCase,
@@ -148,9 +147,9 @@ def get_template(
         use_case = GetTemplateUseCase(template_repository)
         template = use_case.execute(template_id, user_id)
         usage = template_repository.get_usage_count(template_id)
-    except Exception:
+    except Exception as _e:
         logger.exception("get_template 查询失败: template_id=%s", template_id)
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="模板查询失败")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="模板查询失败") from _e
     if template is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found")
     return _to_response(template, usage_count=usage)
@@ -187,7 +186,7 @@ def create_template(
     try:
         template = use_case.execute(command)
     except ValidationError as exc:
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc))
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
     return _to_response(template)
 
 
@@ -227,10 +226,10 @@ def update_template(
     use_case = UpdateTemplateUseCase(template_repository)
     try:
         template = use_case.execute(command)
-    except NotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found")
+    except NotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found") from _e
     except ValidationError as exc:
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc))
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
     return _to_response(template)
 
 
@@ -265,10 +264,10 @@ def copy_template(
     use_case = CopyTemplateUseCase(template_repository)
     try:
         template = use_case.execute(command)
-    except NotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found")
+    except NotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found") from _e
     except ValidationError as exc:
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc))
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
     return _to_response(template)
 
 
@@ -300,9 +299,9 @@ def toggle_favorite(
     use_case = GetTemplateUseCase(template_repository)
     try:
         template = use_case.execute(template_id, user_id)
-    except Exception:
+    except Exception as _e:
         logger.exception("toggle_favorite 查询失败: template_id=%s", template_id)
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found")
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found") from _e
     if template is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found")
     return ToggleFavoriteResponse(id=template_id, is_favorite=False)
@@ -327,10 +326,10 @@ def validate_template(
     use_case = ValidateTemplateUseCase(template_repository)
     try:
         result = use_case.execute(command)
-    except NotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found")
+    except NotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Template not found") from _e
     except ValidationError as exc:
-        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc))
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)) from exc
 
     return ValidateTemplateResponse(
         template=_to_response(result.template),
@@ -376,7 +375,9 @@ def create_category(
     )
 
 
-@router.delete("/categories/{category_id}", status_code=status.HTTP_204_NO_CONTENT, response_model=None, response_class=Response)
+@router.delete(
+    "/categories/{category_id}", status_code=status.HTTP_204_NO_CONTENT, response_model=None, response_class=Response
+)
 def delete_category(
     category_id: str,
     authenticated_user: AuthenticatedUser = Depends(get_current_user),

apps/api/app/api/routes/titles.py

@@ -148,7 +148,7 @@ def create_title(
         raise HTTPException(
             status_code=status.HTTP_429_TOO_MANY_REQUESTS,
             detail=f"标题库配额已满（{exc.used}/{exc.limit}），请升级套餐",
-        )
+        ) from exc
     return _to_response(item)
 
 
@@ -172,8 +172,8 @@ def update_title(
     use_case = UpdateTitleLibraryUseCase(title_repository)
     try:
         item = use_case.execute(command)
-    except NotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Title not found")
+    except NotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Title not found") from _e
     return _to_response(item)
 
 

apps/api/app/api/routes/tts.py

@@ -236,8 +236,8 @@ def get_tts_job(
     use_case = GetTTSJobUseCase(repository)
     try:
         job = use_case.execute(job_id, user_id)
-    except TTSJobNotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="TTS job not found")
+    except TTSJobNotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="TTS job not found") from _e
     return _to_response(job, sign_url)
 
 
@@ -253,8 +253,8 @@ def get_tts_job_status(
     use_case = GetTTSJobStatusUseCase(repository)
     try:
         job = use_case.execute(job_id, user_id)
-    except TTSJobNotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="TTS job not found")
+    except TTSJobNotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="TTS job not found") from _e
     output_url = job.output_audio_url
     if output_url:
         output_url = sign_url(output_url)
@@ -309,8 +309,8 @@ def save_tts_job_to_library(
     get_use_case = GetTTSJobUseCase(tts_repository)
     try:
         job = get_use_case.execute(job_id, user_id)
-    except TTSJobNotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="TTS job not found")
+    except TTSJobNotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="TTS job not found") from _e
 
     # 校验已完成
     if not job.is_completed:
@@ -363,7 +363,7 @@ def save_tts_job_to_library(
         raise HTTPException(
             status_code=status.HTTP_429_TOO_MANY_REQUESTS,
             detail=f"配音库配额已满（{exc.used}/{exc.limit}），请升级套餐",
-        )
+        ) from exc
 
     return SaveToLibraryResponse(
         id=item.id,

apps/api/app/api/routes/videos.py

@@ -1,7 +1,5 @@
 import logging
-import uuid
 
-from app.api.routes._helpers import check_project_access
 from app.auth import AuthenticatedUser, get_current_user
 from app.core.celery_app import celery_app
 from app.core.storage import OSSStorageService, get_storage_service
@@ -110,7 +108,9 @@ def update_video_review_status(
     item = use_case.execute(video_id, request.review_status)
     if item is None:
         raise HTTPException(status_code=404, detail="Video not found")
-    logger.info("Video %s review status updated to %s by user %s", video_id, request.review_status, current_user.user_id)
+    logger.info(
+        "Video %s review status updated to %s by user %s", video_id, request.review_status, current_user.user_id
+    )
     return _to_video_response(item, storage)
 
 
@@ -121,7 +121,7 @@ def batch_download_videos(
     current_user: AuthenticatedUser = Depends(get_current_user),
 ):
     """批量下载成片，异步打包 zip。
-    
+
     传入 video_ids 列表，创建一个批量下载任务，任务完成后返回 zip 下载链接。
     """
     if not request.video_ids:
@@ -154,7 +154,7 @@ def get_batch_download_status(
     from celery.result import AsyncResult
 
     task = AsyncResult(job_id, app=celery_app)
-    
+
     status_map = {
         "PENDING": "pending",
         "STARTED": "running",

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

@@ -141,8 +141,8 @@ def get_voice_clone(
     use_case = GetVoiceCloneUseCase(repository)
     try:
         profile = use_case.execute(clone_id, user_id)
-    except VoiceCloneNotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice clone not found")
+    except VoiceCloneNotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice clone not found") from _e
     return _to_response(profile)
 
 
@@ -157,8 +157,8 @@ def get_voice_clone_status(
     use_case = GetVoiceCloneStatusUseCase(repository)
     try:
         profile = use_case.execute(clone_id, user_id)
-    except VoiceCloneNotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice clone not found")
+    except VoiceCloneNotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice clone not found") from _e
     return VoiceCloneStatusResponse(
         id=profile.id,
         status=profile.status,
@@ -201,13 +201,13 @@ def retry_voice_clone(
     user_id = authenticated_user.user.id
     try:
         profile = workflow.retry_clone(clone_id, user_id)
-    except VoiceCloneNotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice clone not found")
-    except VoiceCloneNotRetryableError:
+    except VoiceCloneNotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice clone not found") from _e
+    except VoiceCloneNotRetryableError as _e:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail="Voice clone is not retryable (only failed clones can be retried)",
-        )
+        ) from _e
 
     # 如果 profile 处于 processing 且有 task_id，触发 Celery 异步轮询
     task_id = (profile.metadata or {}).get("cosyvoice_task_id", "")

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

@@ -287,7 +287,7 @@ def create_voice(
         raise HTTPException(
             status_code=status.HTTP_429_TOO_MANY_REQUESTS,
             detail=f"配音库配额已满（{exc.used}/{exc.limit}），请升级套餐",
-        )
+        ) from exc
     return _to_response(item, sign_url)
 
 
@@ -317,8 +317,8 @@ def update_voice(
     use_case = UpdateVoiceLibraryUseCase(voice_repository)
     try:
         item = use_case.execute(command)
-    except NotFoundError:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice not found")
+    except NotFoundError as _e:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice not found") from _e
     return _to_response(item, sign_url)
 
 

apps/api/app/core/task_enqueue.py

@@ -141,7 +141,7 @@ def safe_enqueue_generation_task(
             global_pending_limit,
             user_id or "unknown",
         )
-        exc = GlobalQueueFull(pending_count=global_pending, limit=global_pending_limit)
+        exc: Exception = GlobalQueueFull(pending_count=global_pending, limit=global_pending_limit)
         _mark_task_failed_safely(task, generation_task_repository, log_prefix, str(exc))
         raise exc
 
@@ -194,7 +194,7 @@ def safe_enqueue_generation_task(
     if global_over or user_over:
         if global_over:
             reason = f"全局 pending 超限(入队后): {global_after}/{global_pending_limit}"
-            exc: Exception = GlobalQueueFull(pending_count=global_after, limit=global_pending_limit)
+            exc = GlobalQueueFull(pending_count=global_after, limit=global_pending_limit)
         else:
             reason = f"用户 pending 超限(入队后): {user_after}/{user_pending_limit}"
             exc = UserPendingLimitExceeded(user_id=user_id, pending_count=user_after, limit=user_pending_limit)

apps/api/app/dependencies.py

@@ -132,7 +132,7 @@ def get_tag_repository(
     session: Session = Depends(get_db_session),
 ) -> TagRepository:
     """Provide the SQLAlchemy tag repository implementation."""
-    return SQLAlchemyTagRepository(session)
+    return SQLAlchemyTagRepository(session)  # type: ignore[return-value]
 
 
 def get_user_repository(

apps/api/app/middleware/logging.py

@@ -105,7 +105,7 @@ class RateLimitMiddleware(BaseHTTPMiddleware):
         self.max_requests = max_requests
         self.window_seconds = window_seconds
         self.paths = set(paths) if paths else None
-        self.requests = {}  # {ip: [timestamps]}
+        self.requests: dict[str, list[float]] = {}
 
     async def dispatch(self, request: Request, call_next):
         # 如果配置了路径过滤，只对指定路径限流

apps/api/app/middleware/versioning.py

@@ -61,7 +61,7 @@ class APIVersionMiddleware(BaseHTTPMiddleware):
 class VersionNotFoundMiddleware(BaseHTTPMiddleware):
     """处理已下线的 API 版本"""
 
-    SUNSET_VERSIONS = []  # 已下线的版本列表
+    SUNSET_VERSIONS: list[str] = []  # 已下线的版本列表
 
     async def dispatch(self, request: Request, call_next):
         version = self._extract_version(request.url.path)

apps/api/app/services/auto_clip_service.py

@@ -12,6 +12,7 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Mapping
 from dataclasses import dataclass
 
 from sqlalchemy.orm import Session
@@ -155,7 +156,7 @@ class AutoClipService:
         self,
         clip: EditPlanClip,
         project_id: str,
-        config_map: dict[str, object],
+        config_map: Mapping[str, object],
     ) -> ClipAssignDetail:
         """为单个片段分配素材。"""
         config = config_map.get(clip.template_clip_config_id) if clip.template_clip_config_id else None

apps/api/app/services/cover_service.py

@@ -0,0 +1,276 @@
+"""封面管理服务.
+
+提供封面配置管理和从视频抽帧生成封面的能力。
+抽帧使用 FFmpeg，上传使用共享存储服务。
+"""
+
+from __future__ import annotations
+
+import logging
+import tempfile
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+# ── 常量 ──────────────────────────────────────────────────────────────────────
+
+DEFAULT_COVER_WIDTH = 1080
+DEFAULT_COVER_HEIGHT = 1920
+DEFAULT_COVER_QUALITY = 5  # JPEG quality (1-31, 越小越好)
+COVER_STORAGE_PREFIX = "covers"
+
+
+class CoverService:
+    """封面管理服务."""
+
+    def __init__(self, storage_service: Any, asset_repository: Any) -> None:
+        self._storage = storage_service
+        self._asset_repo = asset_repository
+
+    # ── 配置读写 ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def get_cover_config(plan_config: Dict[str, Any]) -> Dict[str, Any]:
+        """从 plan.config 中提取封面配置.
+
+        Args:
+            plan_config: 剪辑计划的 config 字段
+
+        Returns:
+            封面配置 dict
+        """
+        cover = plan_config.get("cover", {})
+        if not isinstance(cover, dict):
+            cover = {}
+        # 确保默认字段存在
+        return {
+            "type": cover.get("type", "ai_frame"),
+            "image_url": cover.get("image_url", ""),
+            "frame_time": cover.get("frame_time"),
+        }
+
+    # ── 抽帧生成封面 ──────────────────────────────────────────────────────
+
+    def extract_cover_from_clip(
+        self,
+        plan_id: str,
+        asset_id: str,
+        frame_time: float = 1.0,
+        *,
+        width: int = DEFAULT_COVER_WIDTH,
+        height: int = DEFAULT_COVER_HEIGHT,
+        quality: int = DEFAULT_COVER_QUALITY,
+    ) -> Dict[str, Any]:
+        """从指定素材的指定时间点抽取一帧作为封面.
+
+        Args:
+            plan_id: 剪辑计划 ID（用于生成存储路径）
+            asset_id: 素材 ID
+            frame_time: 抽帧时间点（秒）
+            width: 输出宽度
+            height: 输出高度
+            quality: JPEG 质量
+
+        Returns:
+            封面数据 dict，包含 type / image_url / frame_time
+
+        Raises:
+            ValueError: 素材不存在或不是视频
+            RuntimeError: 抽帧或上传失败
+        """
+        # 1. 获取素材
+        asset = self._asset_repo.get(asset_id) if self._asset_repo else None
+        if not asset:
+            raise ValueError(f"素材不存在: {asset_id}")
+
+        storage_key = getattr(asset, "storage_key", "")
+        if not storage_key:
+            raise ValueError(f"素材没有文件: {asset_id}")
+
+        mime_type = getattr(asset, "mime_type", "")
+        if mime_type and not mime_type.startswith("video"):
+            raise ValueError(f"素材不是视频类型: {mime_type}")
+
+        # 2. 下载视频到临时目录
+        with tempfile.TemporaryDirectory(prefix="cover_extract_") as tmp_dir:
+            tmp_path = Path(tmp_dir)
+            video_path = tmp_path / f"source_{asset_id[:8]}"
+
+            logger.info("下载素材用于封面抽帧: asset_id=%s", asset_id)
+            try:
+                self._storage.download_file(storage_key, str(video_path))
+            except Exception as e:
+                raise RuntimeError(f"下载素材失败: {e}") from e
+
+            if not video_path.exists() or video_path.stat().st_size == 0:
+                raise RuntimeError("下载的素材文件为空")
+
+            # 3. FFmpeg 抽帧
+            output_path = tmp_path / "cover.jpg"
+            self._extract_frame(
+                video_path=video_path,
+                output_path=output_path,
+                time_sec=frame_time,
+                width=width,
+                height=height,
+                quality=quality,
+            )
+
+            if not output_path.exists() or output_path.stat().st_size == 0:
+                raise RuntimeError("封面抽帧失败")
+
+            # 4. 上传到 OSS
+            cover_key = f"{COVER_STORAGE_PREFIX}/{plan_id}/cover_{int(frame_time * 1000)}.jpg"
+            logger.info("上传封面到存储: key=%s", cover_key)
+
+            try:
+                self._storage.upload_file(
+                    file_or_path=str(output_path),
+                    storage_key=cover_key,
+                    content_type="image/jpeg",
+                )
+            except Exception as e:
+                raise RuntimeError(f"上传封面失败: {e}") from e
+
+            # 5. 获取访问 URL
+            try:
+                image_url = self._storage.get_url(cover_key)
+            except Exception:
+                image_url = cover_key  # 降级为 storage_key
+
+        logger.info(
+            "封面抽帧完成: plan_id=%s asset_id=%s time=%.2fs size=%d",
+            plan_id,
+            asset_id,
+            frame_time,
+            output_path.stat().st_size if output_path.exists() else 0,
+        )
+
+        return {
+            "type": "manual",
+            "image_url": image_url,
+            "frame_time": frame_time,
+        }
+
+    def generate_smart_cover(
+        self,
+        plan_id: str,
+        asset_id: str,
+        *,
+        width: int = DEFAULT_COVER_WIDTH,
+        height: int = DEFAULT_COVER_HEIGHT,
+        quality: int = DEFAULT_COVER_QUALITY,
+    ) -> Dict[str, Any]:
+        """智能选帧：从视频中选取多帧，选最清晰的一帧.
+
+        Args:
+            plan_id: 剪辑计划 ID
+            asset_id: 素材 ID
+            width: 输出宽度
+            height: 输出高度
+            quality: JPEG 质量
+
+        Returns:
+            封面数据 dict
+        """
+        # 简单实现：取视频 1/3 处的帧作为智能封面
+        # 更复杂的多帧选清晰帧可以后续优化
+        frame_time = 3.0  # 默认第3秒，后续可以根据视频时长动态计算
+
+        result = self.extract_cover_from_clip(
+            plan_id=plan_id,
+            asset_id=asset_id,
+            frame_time=frame_time,
+            width=width,
+            height=height,
+            quality=quality,
+        )
+        result["type"] = "ai_frame"
+        return result
+
+    # ── 内部方法 ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _extract_frame(
+        video_path: Path,
+        output_path: Path,
+        *,
+        time_sec: float,
+        width: int,
+        height: int,
+        quality: int,
+    ) -> None:
+        """使用 FFmpeg 从视频中抽取一帧.
+
+        Args:
+            video_path: 视频文件路径
+            output_path: 输出图片路径
+            time_sec: 抽帧时间点（秒）
+            width: 输出宽度
+            height: 输出高度
+            quality: JPEG 质量
+        """
+        import subprocess
+
+        # scale + crop 实现 cover 裁剪
+        vf = f"scale={width}:{height}:force_original_aspect_ratio=increase," f"crop={width}:{height}"
+
+        command = [
+            "ffmpeg",
+            "-y",
+            "-ss",
+            f"{time_sec:.3f}",
+            "-i",
+            str(video_path),
+            "-vframes",
+            "1",
+            "-vf",
+            vf,
+            "-q:v",
+            str(quality),
+            "-f",
+            "mjpeg",
+            str(output_path),
+        ]
+
+        logger.debug("FFmpeg 抽帧命令: %s", " ".join(command))
+
+        try:
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            if result.returncode != 0:
+                logger.warning("FFmpeg 抽帧返回非零: %s\nstderr: %s", result.returncode, result.stderr[-500:])
+                # 尝试不使用 scale+crop 的简化命令
+                simple_command = [
+                    "ffmpeg",
+                    "-y",
+                    "-ss",
+                    f"{time_sec:.3f}",
+                    "-i",
+                    str(video_path),
+                    "-vframes",
+                    "1",
+                    "-q:v",
+                    str(quality),
+                    "-f",
+                    "mjpeg",
+                    str(output_path),
+                ]
+                result2 = subprocess.run(
+                    simple_command,
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+                if result2.returncode != 0:
+                    raise RuntimeError(f"FFmpeg 抽帧失败: {result2.stderr[-300:]}")
+        except subprocess.TimeoutExpired as e:
+            raise RuntimeError("FFmpeg 抽帧超时") from e
+        except FileNotFoundError as e:
+            raise RuntimeError("FFmpeg 不可用") from e

apps/api/app/services/edit_plan_service.py

@@ -141,6 +141,19 @@ class EditPlanService:
         logger.info("创建剪辑计划: id=%s name=%s", created.id, created.name)
         return created
 
+    def _auto_resume_editing(self, plan_id: str) -> None:
+        """如果计划处于 completed/failed 状态，自动切回 editing（编辑操作前置）"""
+        plan = self._plan_repo.get(plan_id)
+        if plan is None:
+            return
+        if plan.status in (EditPlanStatus.COMPLETED, EditPlanStatus.FAILED):
+            try:
+                plan.resume_editing()
+                self._plan_repo.update(plan)
+                logger.info("自动重新编辑: plan_id=%s", plan_id)
+            except ValueError:
+                pass
+
     def update_plan(
         self,
         plan_id: str,
@@ -156,6 +169,10 @@ class EditPlanService:
         """
         existing = self.get_plan_or_raise(plan_id)
 
+        # 自动从 completed/failed 切回 editing
+        self._auto_resume_editing(plan_id)
+        existing = self.get_plan_or_raise(plan_id)
+
         updated = EditPlan(
             id=existing.id,
             template_id=existing.template_id,
@@ -212,8 +229,24 @@ class EditPlanService:
             return plan
 
         # 根据目标状态调用对应的状态机方法
+        # EDITING 支持从 draft / completed / failed 进入
+        if target_status == EditPlanStatus.EDITING:
+            if plan.status == EditPlanStatus.DRAFT:
+                plan.start_editing()
+            elif plan.status in (EditPlanStatus.COMPLETED, EditPlanStatus.FAILED):
+                plan.resume_editing()
+            else:
+                raise ValueError(f"无法从 {plan.status} 切换到 {target_status}")
+            result = self._plan_repo.update(plan)
+            logger.info(
+                "状态流转: plan_id=%s %s → %s",
+                plan_id,
+                plan.status,
+                target_status,
+            )
+            return result
+
         transition_map = {
-            EditPlanStatus.EDITING: plan.start_editing,
             EditPlanStatus.RENDERING: plan.start_rendering,
             EditPlanStatus.COMPLETED: plan.mark_completed,
             EditPlanStatus.FAILED: plan.mark_failed,
@@ -292,6 +325,8 @@ class EditPlanService:
         """
         # 确保计划存在
         self.get_plan_or_raise(plan_id)
+        # 自动从 completed/failed 切回 editing
+        self._auto_resume_editing(plan_id)
 
         clip = EditPlanClip.create(
             plan_id=plan_id,
@@ -339,6 +374,9 @@ class EditPlanService:
         """
         existing = self.get_clip_or_raise(clip_id)
 
+        # 自动从 completed/failed 切回 editing
+        self._auto_resume_editing(existing.plan_id)
+
         # 速度边界钳制
         if playback_speed is not None:
             if playback_speed <= 0:
@@ -381,6 +419,8 @@ class EditPlanService:
             ValueError: 片段不存在或 asset_id 为空
         """
         clip = self.get_clip_or_raise(clip_id)
+        # 自动从 completed/failed 切回 editing
+        self._auto_resume_editing(clip.plan_id)
         clip.assign_asset(asset_id)
         result = self._clip_repo.update(clip)
         logger.info("分配素材: clip_id=%s asset_id=%s", clip_id, asset_id)
@@ -407,7 +447,463 @@ class EditPlanService:
         logger.info("删除所有片段: plan_id=%s count=%d", plan_id, count)
         return count
 
+    def create_clips_from_assets(
+        self,
+        plan_id: str,
+        asset_ids: list[str],
+        *,
+        clip_type: str = "main",
+    ) -> list[EditPlanClip]:
+        """从素材批量创建片段（追加到时间线末尾）。
+
+        Args:
+            plan_id: 计划 ID
+            asset_ids: 素材 ID 列表（按顺序追加）
+            clip_type: 片段类型
+
+        Returns:
+            list[EditPlanClip]: 创建的片段列表
+        """
+        if not asset_ids:
+            return []
+
+        # 确保计划存在 + 自动回退状态
+        self.get_plan_or_raise(plan_id)
+        self._auto_resume_editing(plan_id)
+
+        # 查询素材信息（取 duration）
+        from packages.adapters.sqlalchemy_impl.models import AssetModel
+
+        session = self._clip_repo.session  # type: ignore[attr-defined]
+        assets = session.query(AssetModel).filter(AssetModel.id.in_(asset_ids)).all()
+        asset_map = {a.id: a for a in assets}
+
+        # 从现有片段数量开始追加
+        existing_count = self._clip_repo.count(plan_id=plan_id)
+
+        # 批量创建片段
+        created: list[EditPlanClip] = []
+        for i, asset_id in enumerate(asset_ids):
+            asset = asset_map.get(asset_id)
+            duration = asset.duration if asset and asset.duration else 0.0
+
+            clip = self.create_clip(
+                plan_id=plan_id,
+                clip_type=clip_type,
+                order=existing_count + i,
+                asset_id=asset_id,
+                duration=duration,
+            )
+            created.append(clip)
+
+        logger.info(
+            "从素材批量创建片段: plan_id=%s count=%d",
+            plan_id,
+            len(created),
+        )
+        return created
+
     # ── 渲染生成流程 ────────────────────────────────────────────────────────
+    # ── 片段分割与合并 ──────────────────────────────────────────────────────
+
+    def split_clip(self, clip_id: str, split_time: float) -> Dict[str, Any]:
+        """将一个片段从指定位置分割为两个片段
+
+        Args:
+            clip_id: 要分割的片段 ID
+            split_time: 分割点（相对于片段起始的秒数），必须在 (0, duration) 范围内
+
+        Returns:
+            dict: {"left_clip": EditPlanClip, "right_clip": EditPlanClip}
+
+        Raises:
+            ValueError: 片段不存在、分割时间越界
+        """
+        clip = self.get_clip_or_raise(clip_id)
+        plan_id = clip.plan_id
+
+        if split_time <= 0 or split_time >= clip.duration:
+            raise ValueError(f"分割时间必须在 (0, {clip.duration:.3f}) 范围内，当前: {split_time}")
+
+        self._auto_resume_editing(plan_id)
+
+        original_duration = clip.duration
+        left_duration = round(split_time, 3)
+        right_duration = round(original_duration - split_time, 3)
+        original_order = clip.order
+
+        # 更新左半部分（原片段）
+        clip.duration = left_duration
+        left_clip = self._clip_repo.update(clip)
+
+        # 后面片段的 order 全部 +1（给右半部分腾位置）
+        all_clips = self._clip_repo.list_by_plan(plan_id)
+        for c in all_clips:
+            if c.order > original_order and c.id != clip_id:
+                c.order += 1
+                self._clip_repo.update(c)
+
+        # 创建右半部分新片段（继承原片段的大部分属性）
+        right_config = dict(clip.config) if clip.config else {}
+        # 素材裁剪信息
+        if clip.asset_id:
+            # 右半部分从 split_time 开始播放
+            right_config["trim_start"] = left_duration
+            # 左半部分在 split_time 处结束
+            left_config = dict(left_clip.config) if left_clip.config else {}
+            left_config["trim_end"] = right_duration
+            left_clip.config = left_config
+            left_clip = self._clip_repo.update(left_clip)
+
+        right_clip = EditPlanClip.create(
+            plan_id=plan_id,
+            clip_type=clip.clip_type,
+            order=original_order + 1,
+            template_clip_config_id=clip.template_clip_config_id,
+            asset_id=clip.asset_id,
+            text_content=clip.text_content,
+            start_time=clip.start_time + left_duration,
+            duration=right_duration,
+            transition_effect=clip.transition_effect,
+            transition_duration=clip.transition_duration,
+            playback_speed=clip.playback_speed,
+            config=right_config,
+        )
+        created_right = self._clip_repo.create(right_clip)
+
+        logger.info(
+            "分割片段: clip_id=%s plan_id=%s split_time=%.3fs left_dur=%.3fs right_dur=%.3fs",
+            clip_id,
+            plan_id,
+            split_time,
+            left_duration,
+            right_duration,
+        )
+
+        return {
+            "left_clip": left_clip,
+            "right_clip": created_right,
+        }
+
+    def merge_clips(self, clip_ids: List[str]) -> EditPlanClip:
+        """合并多个连续片段为一个片段
+
+        Args:
+            clip_ids: 要合并的片段 ID 列表（至少2个），必须属于同一个计划且 order 连续
+
+        Returns:
+            EditPlanClip: 合并后的新片段
+
+        Raises:
+            ValueError: 数量不足、不属于同一计划、不连续、类型不一致
+        """
+        if len(clip_ids) < 2:
+            raise ValueError("至少需要 2 个片段才能合并")
+
+        # 读取所有片段
+        clips = []
+        for cid in clip_ids:
+            clip = self.get_clip_or_raise(cid)
+            clips.append(clip)
+
+        # 校验：同一计划
+        plan_id = clips[0].plan_id
+        for c in clips[1:]:
+            if c.plan_id != plan_id:
+                raise ValueError("只能合并同一计划下的片段")
+
+        # 按 order 排序
+        clips.sort(key=lambda c: c.order)
+
+        # 校验：order 连续
+        for i in range(1, len(clips)):
+            if clips[i].order != clips[i - 1].order + 1:
+                raise ValueError(f"片段不连续：order {clips[i-1].order} → {clips[i].order}")
+
+        # 校验：类型一致
+        clip_type = clips[0].clip_type
+        for c in clips[1:]:
+            if c.clip_type != clip_type:
+                raise ValueError("只能合并相同类型的片段")
+
+        self._auto_resume_editing(plan_id)
+
+        # 计算合并后的属性
+        first_clip = clips[0]
+        total_duration = round(sum(c.duration for c in clips), 3)
+        first_order = first_clip.order
+
+        # 合并文案（用换行连接）
+        merged_text = "\n".join(c.text_content for c in clips if c.text_content.strip())
+
+        # 合并 config（后面的覆盖前面的）
+        merged_config: Dict[str, Any] = {}
+        for c in clips:
+            if c.config:
+                merged_config.update(c.config)
+        # 清理 trim 相关字段（合并后就是完整片段了）
+        merged_config.pop("trim_start", None)
+        merged_config.pop("trim_end", None)
+
+        # 更新第一个片段（保留它作为合并结果）
+        first_clip.duration = total_duration
+        first_clip.text_content = merged_text
+        first_clip.config = merged_config
+        # 转场保留第一个的（合并后的入点转场）
+        # playback_speed 取第一个的
+        merged_clip = self._clip_repo.update(first_clip)
+
+        # 删除其余片段
+        for c in clips[1:]:
+            self._clip_repo.delete(c.id)
+
+        # 后面的片段 order 前移 (len - 1) 位
+        shift = len(clips) - 1
+        all_clips = self._clip_repo.list_by_plan(plan_id)
+        for c in all_clips:
+            if c.order > first_order and c.id != merged_clip.id:
+                c.order -= shift
+                self._clip_repo.update(c)
+
+        logger.info(
+            "合并片段: plan_id=%s count=%d total_duration=%.3fs",
+            plan_id,
+            len(clips),
+            total_duration,
+        )
+
+        return merged_clip
+
+    # ── 字幕管理 ──────────────────────────────────────────────────────────
+
+    def list_subtitles(self, clip_id: str) -> List[Dict[str, Any]]:
+        """获取片段的所有字幕
+
+        Returns:
+            List[dict]: 字幕列表，按 start 时间排序
+        """
+        clip = self.get_clip_or_raise(clip_id)
+        config = clip.config or {}
+        subtitles = config.get("subtitles", [])
+        # 按开始时间排序
+        subtitles.sort(key=lambda s: s.get("start", 0))
+        return subtitles
+
+    def get_subtitle(self, clip_id: str, subtitle_id: str) -> Optional[Dict[str, Any]]:
+        """获取单条字幕"""
+        subtitles = self.list_subtitles(clip_id)
+        for s in subtitles:
+            if s.get("id") == subtitle_id:
+                return s
+        return None
+
+    def add_subtitle(
+        self,
+        clip_id: str,
+        start: float,
+        end: float,
+        text: str,
+        *,
+        style: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """添加一条字幕
+
+        Args:
+            clip_id: 片段 ID
+            start: 开始时间（秒，相对于片段）
+            end: 结束时间（秒）
+            text: 字幕文本
+            style: 样式配置（字体、大小、颜色、位置等）
+
+        Returns:
+            dict: 新增的字幕条目
+
+        Raises:
+            ValueError: 时间非法或文本为空
+        """
+        clip = self.get_clip_or_raise(clip_id)
+
+        if start < 0 or end <= start:
+            raise ValueError(f"字幕时间非法: start={start}, end={end}")
+        if not text.strip():
+            raise ValueError("字幕文本不能为空")
+        if end > clip.duration + 0.001:
+            raise ValueError(f"字幕结束时间不能超过片段时长: end={end:.3f}, duration={clip.duration:.3f}")
+
+        self._auto_resume_editing(clip.plan_id)
+
+        from uuid import uuid4
+
+        config = dict(clip.config) if clip.config else {}
+        subtitles = list(config.get("subtitles", []))
+
+        subtitle = {
+            "id": uuid4().hex,
+            "start": round(start, 3),
+            "end": round(end, 3),
+            "text": text.strip(),
+            "style": style or {},
+        }
+        subtitles.append(subtitle)
+        subtitles.sort(key=lambda s: s.get("start", 0))
+
+        config["subtitles"] = subtitles
+        clip.config = config
+        self._clip_repo.update(clip)
+
+        logger.info(
+            "添加字幕: clip_id=%s subtitle_id=%s start=%.3fs end=%.3fs",
+            clip_id,
+            subtitle["id"],
+            start,
+            end,
+        )
+
+        return subtitle
+
+    def update_subtitle(
+        self,
+        clip_id: str,
+        subtitle_id: str,
+        *,
+        start: Optional[float] = None,
+        end: Optional[float] = None,
+        text: Optional[str] = None,
+        style: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """更新一条字幕
+
+        Returns:
+            dict: 更新后的字幕条目
+
+        Raises:
+            ValueError: 字幕不存在或参数非法
+        """
+        clip = self.get_clip_or_raise(clip_id)
+        config = dict(clip.config) if clip.config else {}
+        subtitles = list(config.get("subtitles", []))
+
+        found = False
+        for i, s in enumerate(subtitles):
+            if s.get("id") == subtitle_id:
+                # 更新字段
+                updated_s = dict(s)
+                if start is not None:
+                    updated_s["start"] = round(start, 3)
+                if end is not None:
+                    updated_s["end"] = round(end, 3)
+                if text is not None:
+                    if not text.strip():
+                        raise ValueError("字幕文本不能为空")
+                    updated_s["text"] = text.strip()
+                if style is not None:
+                    updated_s["style"] = style
+
+                # 校验时间
+                if updated_s["start"] < 0 or updated_s["end"] <= updated_s["start"]:
+                    raise ValueError(f"字幕时间非法: start={updated_s['start']}, end={updated_s['end']}")
+                if updated_s["end"] > clip.duration + 0.001:
+                    raise ValueError("字幕结束时间不能超过片段时长")
+
+                subtitles[i] = updated_s
+                found = True
+                break
+
+        if not found:
+            raise ValueError(f"字幕不存在: {subtitle_id}")
+
+        self._auto_resume_editing(clip.plan_id)
+
+        subtitles.sort(key=lambda s: s.get("start", 0))
+        config["subtitles"] = subtitles
+        clip.config = config
+        self._clip_repo.update(clip)
+
+        logger.info("更新字幕: clip_id=%s subtitle_id=%s", clip_id, subtitle_id)
+
+        return subtitles[next(i for i, s in enumerate(subtitles) if s["id"] == subtitle_id)]
+
+    def delete_subtitle(self, clip_id: str, subtitle_id: str) -> bool:
+        """删除一条字幕
+
+        Returns:
+            bool: 是否删除成功
+        """
+        clip = self.get_clip_or_raise(clip_id)
+        config = dict(clip.config) if clip.config else {}
+        subtitles = list(config.get("subtitles", []))
+
+        new_subtitles = [s for s in subtitles if s.get("id") != subtitle_id]
+        if len(new_subtitles) == len(subtitles):
+            return False
+
+        self._auto_resume_editing(clip.plan_id)
+
+        config["subtitles"] = new_subtitles
+        clip.config = config
+        self._clip_repo.update(clip)
+
+        logger.info("删除字幕: clip_id=%s subtitle_id=%s", clip_id, subtitle_id)
+        return True
+
+    def batch_update_subtitles(
+        self,
+        clip_id: str,
+        subtitles: List[Dict[str, Any]],
+    ) -> List[Dict[str, Any]]:
+        """批量更新字幕（全量替换，用于批量编辑或导入）
+
+        Args:
+            clip_id: 片段 ID
+            subtitles: 字幕列表，每条需包含 start/end/text，已有 id 则保留
+
+        Returns:
+            List[dict]: 更新后的字幕列表
+        """
+        clip = self.get_clip_or_raise(clip_id)
+
+        from uuid import uuid4
+
+        validated = []
+        for s in subtitles:
+            start = float(s.get("start", 0))
+            end = float(s.get("end", 0))
+            text = str(s.get("text", ""))
+
+            if start < 0 or end <= start:
+                raise ValueError(f"字幕时间非法: start={start}, end={end}")
+            if not text.strip():
+                continue  # 跳过空字幕
+            if end > clip.duration + 0.001:
+                raise ValueError(f"字幕结束时间不能超过片段时长: end={end}")
+
+            subtitle_id = s.get("id") or uuid4().hex
+            validated.append(
+                {
+                    "id": subtitle_id,
+                    "start": round(start, 3),
+                    "end": round(end, 3),
+                    "text": text.strip(),
+                    "style": s.get("style", {}),
+                }
+            )
+
+        validated.sort(key=lambda s: s["start"])
+
+        self._auto_resume_editing(clip.plan_id)
+
+        config = dict(clip.config) if clip.config else {}
+        config["subtitles"] = validated
+        clip.config = config
+        self._clip_repo.update(clip)
+
+        logger.info(
+            "批量更新字幕: clip_id=%s count=%d",
+            clip_id,
+            len(validated),
+        )
+
+        return validated
 
     def get_plan_with_clips(self, plan_id: str) -> Dict[str, Any]:
         """获取计划及其所有片段
@@ -431,6 +927,8 @@ class EditPlanService:
                 "clips": List[EditPlanClip],
                 "generation_task_id": Optional[str],
                 "generation_task_status": Optional[str],
+                "progress": float,
+                "error_message": str,
             }
 
         Raises:
@@ -442,17 +940,23 @@ class EditPlanService:
         # 从 plan.config 中获取 generation_task_id
         generation_task_id = plan.config.get("generation_task_id")
         generation_task_status = None
+        progress = 0.0
+        error_message = ""
 
         if generation_task_id:
             task = self._generation_task_repo.get(generation_task_id)
             if task:
                 generation_task_status = task.status.value if hasattr(task.status, "value") else task.status
+                progress = getattr(task, "progress", 0.0) or 0.0
+                error_message = getattr(task, "error_message", "") or ""
 
         return {
             "plan": plan,
             "clips": clips,
             "generation_task_id": generation_task_id,
             "generation_task_status": generation_task_status,
+            "progress": progress,
+            "error_message": error_message,
         }
 
     def can_generate(self, plan_id: str) -> tuple[bool, str]:
@@ -503,6 +1007,9 @@ class EditPlanService:
             更新后的计划
         """
         plan = self.get_plan_or_raise(plan_id)
+        # 自动从 completed/failed 切回 editing
+        self._auto_resume_editing(plan_id)
+        plan = self.get_plan_or_raise(plan_id)
         new_config = {**plan.config, **config_updates}
 
         updated = EditPlan(
@@ -519,3 +1026,85 @@ class EditPlanService:
             updated_at=plan.updated_at,
         )
         return self._plan_repo.update(updated)
+
+    # ── 复制计划 ────────────────────────────────────────────────────────────
+
+    def copy_plan(
+        self,
+        plan_id: str,
+        *,
+        new_name: Optional[str] = None,
+        project_id: Optional[str] = None,
+    ) -> EditPlan:
+        """复制一个剪辑计划（含所有片段配置）。
+
+        新计划状态为 editing，不含生成任务和结果记录。
+
+        Args:
+            plan_id: 源计划 ID
+            new_name: 新计划名称，不传则为「原名 - 副本」
+            project_id: 新计划的项目 ID，不传则复用源计划
+
+        Returns:
+            EditPlan: 新创建的计划
+
+        Raises:
+            ValueError: 源计划不存在
+        """
+        source = self.get_plan_or_raise(plan_id)
+        source_clips = self._clip_repo.list_by_plan(plan_id)
+
+        # 新计划名称
+        name = new_name or f"{source.name} - 副本"
+        new_project_id = project_id if project_id is not None else source.project_id
+
+        # 复制 plan 配置（去除渲染结果相关字段）
+        new_config = dict(source.config)
+        new_config.pop("rendered_url", None)
+        new_config.pop("rendered_storage_key", None)
+        new_config.pop("generation_task_id", None)
+
+        # 创建新计划
+        new_plan = EditPlan.create(
+            template_id=source.template_id,
+            name=name,
+            config=new_config,
+            total_duration=source.total_duration,
+            project_id=new_project_id,
+            created_by_user_id=source.created_by_user_id,
+            source_edit_plan_id=plan_id,
+        )
+        # 强制切到 editing 状态
+        if new_plan.status != EditPlanStatus.EDITING:
+            try:
+                new_plan.start_editing()
+            except ValueError:
+                pass
+
+        created_plan = self._plan_repo.create(new_plan)
+        logger.info(
+            "复制剪辑计划: source=%s target=%s name=%s clips=%d",
+            plan_id,
+            created_plan.id,
+            name,
+            len(source_clips),
+        )
+
+        # 复制所有片段
+        for clip in source_clips:
+            new_clip = self.create_clip(
+                plan_id=created_plan.id,
+                clip_type=clip.clip_type,
+                order=clip.order,
+                asset_id=clip.asset_id or "",
+                text_content=clip.text_content or "",
+                start_time=clip.start_time,
+                duration=clip.duration,
+                transition_effect=clip.transition_effect or "cut",
+                transition_duration=clip.transition_duration or 0.0,
+                playback_speed=clip.playback_speed or 1.0,
+                config=dict(clip.config) if clip.config else None,
+            )
+            logger.debug("复制片段: source=%s target=%s order=%d", clip.id, new_clip.id, clip.order)
+
+        return self.get_plan_or_raise(created_plan.id)

apps/api/app/services/edit_template_service.py

@@ -12,6 +12,8 @@ from typing import Any, List, Optional
 from sqlalchemy.orm import Session
 
 from packages.adapters.sqlalchemy_impl import (
+    SQLAlchemyEditPlanClipRepository,
+    SQLAlchemyEditPlanRepository,
     SQLAlchemyEditTemplateRepository,
     SQLAlchemyTemplateClipConfigRepository,
 )
@@ -37,6 +39,9 @@ class EditTemplateService:
     def __init__(self, db: Session) -> None:
         self._template_repo = SQLAlchemyEditTemplateRepository(db)
         self._clip_config_repo = SQLAlchemyTemplateClipConfigRepository(db)
+        self._plan_repo = SQLAlchemyEditPlanRepository(db)
+        self._plan_clip_repo = SQLAlchemyEditPlanClipRepository(db)
+        self._db = db
 
     # ── 模板 CRUD ──────────────────────────────────────────────────────────
 
@@ -394,3 +399,137 @@ class EditTemplateService:
             "template": template,
             "clip_configs": clip_configs,
         }
+
+    # ── 从剪辑计划保存为模板 ──────────────────────────────────────────────
+
+    def save_plan_as_template(
+        self,
+        plan_id: str,
+        name: str,
+        *,
+        description: str = "",
+        template_type: str = "custom",
+        preview_url: str = "",
+    ) -> dict[str, Any]:
+        """将剪辑计划保存为模板
+
+        将指定剪辑计划的配置和片段结构另存为一个新模板，
+        方便后续基于该模板快速创建新的剪辑计划。
+
+        转换规则:
+        - 计划名称 → 模板名称（调用方传入，支持自定义）
+        - 计划 config → 模板 config（整体迁移）
+        - 计划 editing_mode 从 config 中提取，默认 one_take
+        - 每个片段转换为模板片段配置:
+          - clip_type 直接映射
+          - order 保持不变
+          - duration → min_duration = max_duration = duration（固定时长）
+          - text_content → text_template
+          - transition_effect 直接映射
+          - playback_speed 等播放参数存入 config
+          - 不保留 asset_id（模板不绑定具体素材）
+
+        Args:
+            plan_id: 源剪辑计划 ID
+            name: 新模板名称
+            description: 模板描述
+            template_type: 模板类型，默认 custom（用户自定义）
+            preview_url: 预览图 URL
+
+        Returns:
+            dict: {"template": EditTemplate, "clip_configs": List[TemplateClipConfig]}
+
+        Raises:
+            ValueError: 计划不存在或名称为空/重复
+        """
+        # 1. 读取源计划
+        plan = self._plan_repo.get(plan_id)
+        if plan is None:
+            raise ValueError(f"剪辑计划不存在: {plan_id}")
+
+        # 2. 读取所有片段（按 order 排序）
+        clips = self._plan_clip_repo.list_by_plan(plan_id)
+        clips.sort(key=lambda c: c.order)
+
+        # 3. 提取 editing_mode
+        editing_mode = plan.config.get("editing_mode", "one_take") if plan.config else "one_take"
+
+        # 4. 创建模板（复用 create_template 的校验逻辑，但手动构建避免重复查询）
+        clean_name = name.strip()
+        if not clean_name:
+            raise ValueError("模板名称不能为空")
+
+        # 名称重复检查
+        existing = self._template_repo.list_all(skip=0, limit=1000)
+        for t in existing:
+            if t.name == clean_name and t.status == EditTemplateStatus.ACTIVE:
+                raise ValueError(f"模板名称已存在: {clean_name}")
+
+        # 从计划 config 中提取模板级配置，去掉运行时/素材相关字段
+        plan_config = plan.config or {}
+        template_config: dict[str, Any] = {}
+        for key, value in plan_config.items():
+            # 跳过明显的运行时/实例字段，保留风格/模式类配置
+            if key not in {"asset_ids", "source_edit_plan_id", "generation_task_id"}:
+                template_config[key] = value
+
+        template = EditTemplate.create(
+            name=clean_name,
+            description=description,
+            template_type=template_type,
+            editing_mode=editing_mode,
+            config=template_config,
+            preview_url=preview_url,
+        )
+        created_template = self._template_repo.create(template)
+        logger.info(
+            "从剪辑计划创建模板: plan_id=%s template_id=%s name=%s clip_count=%d",
+            plan_id,
+            created_template.id,
+            clean_name,
+            len(clips),
+        )
+
+        # 5. 转换每个片段为模板片段配置
+        created_configs: List[TemplateClipConfig] = []
+        for clip in clips:
+            clip_config: dict[str, Any] = {}
+            # 播放速度存入 config
+            if clip.playback_speed and clip.playback_speed != 1.0:
+                clip_config["playback_speed"] = clip.playback_speed
+            # 片段自有 config 合并（优先级：clip.config 覆盖上面的）
+            if clip.config:
+                clip_config.update(clip.config)
+            # 去掉素材相关字段
+            clip_config.pop("asset_info", None)
+            clip_config.pop("source_asset_id", None)
+
+            # 转场效果兼容校验
+            try:
+                transition = TransitionEffect(clip.transition_effect)
+            except ValueError:
+                transition = TransitionEffect.CUT
+
+            # 片段类型兼容校验
+            try:
+                clip_type = ClipType(clip.clip_type)
+            except ValueError:
+                clip_type = ClipType.MAIN
+
+            clip_config_obj = TemplateClipConfig.create(
+                template_id=created_template.id,
+                clip_type=clip_type,
+                order=clip.order,
+                min_duration=clip.duration,
+                max_duration=clip.duration,
+                text_template=clip.text_content or "",
+                transition_effect=transition,
+                config=clip_config,
+            )
+            created = self._clip_config_repo.create(clip_config_obj)
+            created_configs.append(created)
+
+        return {
+            "template": created_template,
+            "clip_configs": created_configs,
+        }

apps/api/app/services/plan_generator_service.py

@@ -99,6 +99,11 @@ class PlanGeneratorService:
         # 3. 生成片段列表
         if clip_configs:
             clips = self._create_clips_from_configs(plan.id, clip_configs)
+            # 模板 clip_config 的 clip_type 是 ClipType 枚举（main/intro/outro 等），
+            # 但 PIP / VOICE_PIP 模式需要特定的 clip_type（overlay/background/corner_voice/b_roll）
+            # 才能让素材分配和渲染分层正确工作。
+            # 这里将 MAIN 类型的片段按顺序映射为对应模式的角色类型。
+            self._map_clip_types_for_mode(clips, editing_mode)
         else:
             clips = self._generate_default_clips(plan.id, editing_mode, len(asset_ids))
 
@@ -195,6 +200,41 @@ class PlanGeneratorService:
 
         return clips
 
+    def _map_clip_types_for_mode(self, clips: List[EditPlanClip], editing_mode: str) -> None:
+        """将模板 clip_config 生成的 MAIN 类型片段，按 editing_mode 映射为对应角色类型。
+
+        模板的 clip_config 使用 ClipType 枚举（main/intro/outro 等），
+        但 PIP / VOICE_PIP 模式的素材分配和渲染分层依赖特定的 clip_type 命名
+        （overlay / background / corner_voice / b_roll）。
+
+        映射规则（仅修改 MAIN 类型片段，非 MAIN 片段保持原类型）：
+        - PIP: 第1个 MAIN → main（背景），其余 MAIN → overlay（画中画）
+        - VOICE_PIP: 第1个 → background，第2个 → corner_voice，第3+个 → b_roll
+        - ONE_TAKE / VOICE_OVER: 保持 main 不变
+        """
+        from packages.domain.template_clip_config import ClipType
+
+        main_clips = [c for c in clips if c.clip_type == ClipType.MAIN.value]
+        if not main_clips:
+            return
+
+        if editing_mode == EditingMode.PIP.value:
+            # 第1个 main 保持（背景层），其余改为 overlay（画中画层）
+            for i, clip in enumerate(main_clips):
+                if i > 0:
+                    clip.clip_type = "overlay"
+
+        elif editing_mode == EditingMode.VOICE_PIP.value:
+            for i, clip in enumerate(main_clips):
+                if i == 0:
+                    clip.clip_type = "background"
+                elif i == 1:
+                    clip.clip_type = "corner_voice"
+                else:
+                    clip.clip_type = "b_roll"
+
+        # ONE_TAKE / VOICE_OVER: 保持 main 不变，无需处理
+
     def _generate_default_clips(
         self,
         plan_id: str,
@@ -224,7 +264,7 @@ class PlanGeneratorService:
             )
             order += 1
             # 剩余为 overlay
-            for i in range(1, n):
+            for _ in range(1, n):
                 clips.append(
                     EditPlanClip.create(
                         plan_id=plan_id,
@@ -237,7 +277,7 @@ class PlanGeneratorService:
 
         elif editing_mode == EditingMode.VOICE_OVER.value:
             # N 个 main clips（B-roll）
-            for i in range(n):
+            for _ in range(n):
                 clips.append(
                     EditPlanClip.create(
                         plan_id=plan_id,
@@ -271,7 +311,7 @@ class PlanGeneratorService:
             )
             order += 1
             # 剩余为 b_roll
-            for i in range(2, n):
+            for _ in range(2, n):
                 clips.append(
                     EditPlanClip.create(
                         plan_id=plan_id,
@@ -284,7 +324,7 @@ class PlanGeneratorService:
 
         else:
             # ONE_TAKE: N 个 main clips
-            for i in range(n):
+            for _ in range(n):
                 clips.append(
                     EditPlanClip.create(
                         plan_id=plan_id,

apps/api/app/services/video_compose_service.py

@@ -219,7 +219,7 @@ class VideoComposeService:
         根据 EditPlan 的所有 ready 片段，生成完整的 filter_complex 命令。
 
         滤镜链逻辑：
-        - 每个片段：scale → crop → setpts → trim → atrim
+        - 每个片段：scale → crop → fps → setpts → trim → atrim
         - 多片段之间：concat 滤镜 或 xfade 转场
         - 最终输出：-map '[outv]' -map '[outa]'（如有音频）
         """
@@ -406,20 +406,26 @@ class VideoComposeService:
         滤镜顺序：
         1. scale — 等比缩放到目标分辨率（保证覆盖）
         2. crop — 居中裁剪到目标分辨率
-        3. setpts — 重置时间戳 + 偏移
-        4. trim — 视频时长裁剪
-        5. atrim — 音频时长裁剪（如有音频流）
+        3. fps — 统一输出帧率（concat 要求所有输入帧率一致）
+        4. setpts — 重置时间戳 + 偏移
+        5. trim — 视频时长裁剪
+        6. atrim — 音频时长裁剪（如有音频流）
         """
         duration = clip.duration if clip.duration > 0 else 5.0  # 默认 5 秒
         start = clip.start_time
 
         filters: list[str] = []
 
-        # 1. scale: 等比缩放，保证覆盖目标区域（scale to larger, then crop）
-        filters.append(f"scale={output_width}:{output_height}" f":force_original_aspect_ratio=increase")
+        # 1. scale: 等比缩放（保持比例，不裁剪）
+        filters.append(f"scale={output_width}:{output_height}" f":force_original_aspect_ratio=decrease")
 
-        # 2. crop: 居中裁剪
-        filters.append(f"crop={output_width}:{output_height}")
+        # 2. pad: 居中+留黑边到目标分辨率（保持原始比例，不裁剪内容）
+        filters.append(f"pad={output_width}:{output_height}:(ow-iw)/2:(oh-ih)/2:black")
+
+        # 3. fps: 统一帧率（concat 要求所有输入帧率一致）
+        # 放在 pad 之后、setpts 之前，确保分辨率和帧率都已统一
+        if fps and fps > 0:
+            filters.append(f"fps={fps}")
 
         # 3. setpts: 重置时间戳
         if start > 0:
@@ -532,11 +538,17 @@ def _build_concat_filter(
     concat_filter = f"{concat_inputs}concat=n={n}:v=1:a=0[outv]"
     parts.append(concat_filter)
 
-    # 音频 concat（如果有）
+    # 音频 concat（如果有）— 先统一音频格式再拼接，否则不同采样率/声道会导致concat失败
     audio_parts: list[str] = []
     for idx, chain in enumerate(clip_chains):
         if chain.audio_label:
-            audio_parts.append(f"[{idx}:a]atrim=0:{chain.duration},asetpts=PTS-STARTPTS[{chain.audio_label}]")
+            # aformat: 统一采样率48000Hz + 双声道stereo + fltp采样格式（AAC标准格式）
+            audio_filters = [
+                "aformat=sample_rates=48000:channel_layouts=stereo:sample_fmts=fltp",
+                f"atrim=0:{chain.duration}",
+                "asetpts=PTS-STARTPTS",
+            ]
+            audio_parts.append(f"[{idx}:a]{','.join(audio_filters)}[{chain.audio_label}]")
 
     if audio_parts:
         parts.extend(audio_parts)

apps/web/.eslintrc.cjs

@@ -18,6 +18,6 @@ module.exports = {
       { allowConstantExport: true },
     ],
     "@typescript-eslint/no-explicit-any": "warn",
-    "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
+    "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
   },
 };

apps/web/e2e/assets-full.spec.ts

@@ -86,7 +86,10 @@ async function createProject(
 ): Promise<string> {
   const resp = await request.post(`${apiBase}/projects`, {
     headers,
-    data: { name: `Assets Test Proj ${suffix}`, description: "E2E assets test" },
+    data: {
+      name: `Assets Test Proj ${suffix}`,
+      description: "E2E assets test",
+    },
   });
   expect(resp.ok(), `创建项目应成功: ${await resp.text()}`).toBeTruthy();
   const data = await resp.json();
@@ -178,20 +181,30 @@ test.describe("素材库页面 - 完整交互测试", () => {
 
   test("素材库列表页面加载", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "assets-load");
+    const projectId = await createProject(
       request,
-      "assets-load",
+      headers,
+      Date.now().toString(),
     );
-    const projectId = await createProject(request, headers, Date.now().toString());
     await createLibrary(request, headers, projectId, "默认视频库", "video");
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/assets");
 
     // 页面布局容器
-    await expect(page.locator(".xx-assets-page")).toBeVisible({ timeout: 20_000 });
-    await expect(page.locator(".xx-assets-layout")).toBeVisible({ timeout: 20_000 });
+    await expect(page.locator(".xx-assets-page")).toBeVisible({
+      timeout: 20_000,
+    });
+    await expect(page.locator(".xx-assets-layout")).toBeVisible({
+      timeout: 20_000,
+    });
 
     // 左侧素材库列表
     await expect(page.locator(".xx-asset-library-list")).toBeVisible();
@@ -211,23 +224,33 @@ test.describe("素材库页面 - 完整交互测试", () => {
 
   test("创建新素材库 - 通过 UI", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "assets-create");
+    const projectId = await createProject(
       request,
-      "assets-create",
+      headers,
+      Date.now().toString(),
     );
-    const projectId = await createProject(request, headers, Date.now().toString());
     await createLibrary(request, headers, projectId, "初始库", "video");
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/assets");
-    await expect(page.locator(".xx-assets-layout")).toBeVisible({ timeout: 20_000 });
+    await expect(page.locator(".xx-assets-layout")).toBeVisible({
+      timeout: 20_000,
+    });
 
     // 点击新建素材库
     await page.locator(".xx-asset-library-add").click();
 
     // 弹窗出现
-    const modal = page.locator(".ant-modal-content").filter({ hasText: "新建素材库" });
+    const modal = page
+      .locator(".ant-modal-content")
+      .filter({ hasText: "新建素材库" });
     await expect(modal).toBeVisible();
 
     // 填写表单
@@ -259,11 +282,13 @@ test.describe("素材库页面 - 完整交互测试", () => {
 
   test("切换不同素材库", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "assets-switch");
+    const projectId = await createProject(
       request,
-      "assets-switch",
+      headers,
+      Date.now().toString(),
     );
-    const projectId = await createProject(request, headers, Date.now().toString());
 
     const videoLibName = "视频素材库 A";
     const imageLibName = "图片素材库 B";
@@ -274,13 +299,6 @@ test.describe("素材库页面 - 完整交互测试", () => {
       videoLibName,
       "video",
     );
-    const imageLibId = await createLibrary(
-      request,
-      headers,
-      projectId,
-      imageLibName,
-      "image",
-    );
 
     // 在视频库里创建一个素材
     await createAsset(
@@ -292,10 +310,16 @@ test.describe("素材库页面 - 完整交互测试", () => {
       "demo_video.mp4",
     );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/assets");
-    await expect(page.locator(".xx-assets-layout")).toBeVisible({ timeout: 20_000 });
+    await expect(page.locator(".xx-assets-layout")).toBeVisible({
+      timeout: 20_000,
+    });
 
     // 点击视频库，应显示素材
     const videoLibItem = page
@@ -305,7 +329,9 @@ test.describe("素材库页面 - 完整交互测试", () => {
     await expect(videoLibItem).toHaveClass(/active/);
 
     // 验证视频素材出现
-    await expect(page.getByText("demo_video.mp4")).toBeVisible({ timeout: 10_000 });
+    await expect(page.getByText("demo_video.mp4")).toBeVisible({
+      timeout: 10_000,
+    });
 
     // 点击图片库，应切换且不显示视频
     const imageLibItem = page
@@ -315,18 +341,22 @@ test.describe("素材库页面 - 完整交互测试", () => {
     await expect(imageLibItem).toHaveClass(/active/);
 
     // 空状态或图片库内容
-    await expect(page.getByText("demo_video.mp4")).toHaveCount(0, { timeout: 5_000 });
+    await expect(page.getByText("demo_video.mp4")).toHaveCount(0, {
+      timeout: 5_000,
+    });
   });
 
   // ─── 素材搜索 ──────────────────────────────────────
 
   test("素材搜索功能", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "assets-search");
+    const projectId = await createProject(
       request,
-      "assets-search",
+      headers,
+      Date.now().toString(),
     );
-    const projectId = await createProject(request, headers, Date.now().toString());
     const libraryId = await createLibrary(
       request,
       headers,
@@ -336,13 +366,33 @@ test.describe("素材库页面 - 完整交互测试", () => {
     );
 
     // 创建两个不同名称的素材
-    await createAsset(request, headers, projectId, libraryId, userId, "apple_clip.mp4");
-    await createAsset(request, headers, projectId, libraryId, userId, "banana_clip.mp4");
+    await createAsset(
+      request,
+      headers,
+      projectId,
+      libraryId,
+      userId,
+      "apple_clip.mp4",
+    );
+    await createAsset(
+      request,
+      headers,
+      projectId,
+      libraryId,
+      userId,
+      "banana_clip.mp4",
+    );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/assets");
-    await expect(page.locator(".xx-assets-layout")).toBeVisible({ timeout: 20_000 });
+    await expect(page.locator(".xx-assets-layout")).toBeVisible({
+      timeout: 20_000,
+    });
 
     // 确保在测试库中
     const libItem = page
@@ -351,7 +401,9 @@ test.describe("素材库页面 - 完整交互测试", () => {
     await libItem.click({ force: true });
 
     // 两个素材都应可见
-    await expect(page.getByText("apple_clip.mp4")).toBeVisible({ timeout: 10_000 });
+    await expect(page.getByText("apple_clip.mp4")).toBeVisible({
+      timeout: 10_000,
+    });
     await expect(page.getByText("banana_clip.mp4")).toBeVisible();
 
     // 搜索 apple，只显示 apple
@@ -361,7 +413,9 @@ test.describe("素材库页面 - 完整交互测试", () => {
 
     // 清空搜索，两个都显示
     await page.getByPlaceholder("搜索素材名称...").fill("");
-    await expect(page.getByText("apple_clip.mp4")).toBeVisible({ timeout: 5_000 });
+    await expect(page.getByText("apple_clip.mp4")).toBeVisible({
+      timeout: 5_000,
+    });
     await expect(page.getByText("banana_clip.mp4")).toBeVisible();
   });
 
@@ -369,11 +423,13 @@ test.describe("素材库页面 - 完整交互测试", () => {
 
   test("素材类型筛选", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "assets-filter");
+    const projectId = await createProject(
       request,
-      "assets-filter",
+      headers,
+      Date.now().toString(),
     );
-    const projectId = await createProject(request, headers, Date.now().toString());
     const libraryId = await createLibrary(
       request,
       headers,
@@ -383,12 +439,25 @@ test.describe("素材库页面 - 完整交互测试", () => {
     );
 
     // 创建视频素材
-    await createAsset(request, headers, projectId, libraryId, userId, "video_clip.mp4");
+    await createAsset(
+      request,
+      headers,
+      projectId,
+      libraryId,
+      userId,
+      "video_clip.mp4",
+    );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/assets");
-    await expect(page.locator(".xx-assets-layout")).toBeVisible({ timeout: 20_000 });
+    await expect(page.locator(".xx-assets-layout")).toBeVisible({
+      timeout: 20_000,
+    });
 
     const libItem = page
       .locator(".xx-asset-library-item")
@@ -396,7 +465,9 @@ test.describe("素材库页面 - 完整交互测试", () => {
     await libItem.click({ force: true });
 
     // 素材应可见
-    await expect(page.getByText("video_clip.mp4")).toBeVisible({ timeout: 10_000 });
+    await expect(page.getByText("video_clip.mp4")).toBeVisible({
+      timeout: 10_000,
+    });
 
     // 筛选类型下拉存在
     const filterSelect = page.locator(".xx-assets-filters-left select").first();
@@ -407,11 +478,13 @@ test.describe("素材库页面 - 完整交互测试", () => {
 
   test("素材详情查看 - 播放弹窗", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "assets-detail");
+    const projectId = await createProject(
       request,
-      "assets-detail",
+      headers,
+      Date.now().toString(),
     );
-    const projectId = await createProject(request, headers, Date.now().toString());
     const libraryId = await createLibrary(
       request,
       headers,
@@ -419,12 +492,25 @@ test.describe("素材库页面 - 完整交互测试", () => {
       "详情测试库",
       "video",
     );
-    await createAsset(request, headers, projectId, libraryId, userId, "play_test.mp4");
+    await createAsset(
+      request,
+      headers,
+      projectId,
+      libraryId,
+      userId,
+      "play_test.mp4",
+    );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/assets");
-    await expect(page.locator(".xx-assets-layout")).toBeVisible({ timeout: 20_000 });
+    await expect(page.locator(".xx-assets-layout")).toBeVisible({
+      timeout: 20_000,
+    });
 
     const libItem = page
       .locator(".xx-asset-library-item")
@@ -441,7 +527,9 @@ test.describe("素材库页面 - 完整交互测试", () => {
     await assetCard.locator(".xx-asset-play").click({ force: true });
 
     // 播放弹窗出现
-    const modal = page.locator(".ant-modal-content").filter({ hasText: "播放" });
+    const modal = page
+      .locator(".ant-modal-content")
+      .filter({ hasText: "播放" });
     await expect(modal).toBeVisible();
 
     // 关闭弹窗
@@ -453,11 +541,13 @@ test.describe("素材库页面 - 完整交互测试", () => {
 
   test("删除素材 - 带确认对话框", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "assets-delete");
+    const projectId = await createProject(
       request,
-      "assets-delete",
+      headers,
+      Date.now().toString(),
     );
-    const projectId = await createProject(request, headers, Date.now().toString());
     const libraryId = await createLibrary(
       request,
       headers,
@@ -465,12 +555,25 @@ test.describe("素材库页面 - 完整交互测试", () => {
       "删除测试库",
       "video",
     );
-    await createAsset(request, headers, projectId, libraryId, userId, "to_delete.mp4");
+    await createAsset(
+      request,
+      headers,
+      projectId,
+      libraryId,
+      userId,
+      "to_delete.mp4",
+    );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/assets");
-    await expect(page.locator(".xx-assets-layout")).toBeVisible({ timeout: 20_000 });
+    await expect(page.locator(".xx-assets-layout")).toBeVisible({
+      timeout: 20_000,
+    });
 
     const libItem = page
       .locator(".xx-asset-library-item")
@@ -491,14 +594,15 @@ test.describe("素材库页面 - 完整交互测试", () => {
     await deleteBtn.click({ force: true });
 
     // 确认对话框出现
-    const confirmModal = page.locator(".ant-popover").filter({ hasText: "确认删除" });
+    const confirmModal = page
+      .locator(".ant-popover")
+      .filter({ hasText: "确认删除" });
     await expect(confirmModal).toBeVisible();
 
     // 监听删除请求
     const deletePromise = page.waitForResponse(
       (resp) =>
-        resp.url().includes("/assets/") &&
-        resp.request().method() === "DELETE",
+        resp.url().includes("/assets/") && resp.request().method() === "DELETE",
       { timeout: 10_000 },
     );
 
@@ -518,11 +622,13 @@ test.describe("素材库页面 - 完整交互测试", () => {
 
   test("批量删除素材", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "assets-batch");
+    const projectId = await createProject(
       request,
-      "assets-batch",
+      headers,
+      Date.now().toString(),
     );
-    const projectId = await createProject(request, headers, Date.now().toString());
     const libraryId = await createLibrary(
       request,
       headers,
@@ -532,14 +638,41 @@ test.describe("素材库页面 - 完整交互测试", () => {
     );
 
     // 创建多个素材
-    await createAsset(request, headers, projectId, libraryId, userId, "batch_1.mp4");
-    await createAsset(request, headers, projectId, libraryId, userId, "batch_2.mp4");
-    await createAsset(request, headers, projectId, libraryId, userId, "batch_3.mp4");
+    await createAsset(
+      request,
+      headers,
+      projectId,
+      libraryId,
+      userId,
+      "batch_1.mp4",
+    );
+    await createAsset(
+      request,
+      headers,
+      projectId,
+      libraryId,
+      userId,
+      "batch_2.mp4",
+    );
+    await createAsset(
+      request,
+      headers,
+      projectId,
+      libraryId,
+      userId,
+      "batch_3.mp4",
+    );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/assets");
-    await expect(page.locator(".xx-assets-layout")).toBeVisible({ timeout: 20_000 });
+    await expect(page.locator(".xx-assets-layout")).toBeVisible({
+      timeout: 20_000,
+    });
 
     const libItem = page
       .locator(".xx-asset-library-item")
@@ -547,7 +680,9 @@ test.describe("素材库页面 - 完整交互测试", () => {
     await libItem.click({ force: true });
 
     // 所有素材应可见
-    await expect(page.getByText("batch_1.mp4")).toBeVisible({ timeout: 10_000 });
+    await expect(page.getByText("batch_1.mp4")).toBeVisible({
+      timeout: 10_000,
+    });
     await expect(page.getByText("batch_2.mp4")).toBeVisible();
     await expect(page.getByText("batch_3.mp4")).toBeVisible();
 
@@ -567,7 +702,9 @@ test.describe("素材库页面 - 完整交互测试", () => {
     await batchDeleteBtn.click();
 
     // 确认对话框
-    const confirmPop = page.locator(".ant-popover").filter({ hasText: "确定删除" });
+    const confirmPop = page
+      .locator(".ant-popover")
+      .filter({ hasText: "确定删除" });
     await expect(confirmPop).toBeVisible();
 
     // 确认删除
@@ -595,17 +732,25 @@ test.describe("素材库页面 - 完整交互测试", () => {
 
   test("空素材库展示空状态", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "assets-empty");
+    const projectId = await createProject(
       request,
-      "assets-empty",
+      headers,
+      Date.now().toString(),
     );
-    const projectId = await createProject(request, headers, Date.now().toString());
     await createLibrary(request, headers, projectId, "空素材库", "video");
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/assets");
-    await expect(page.locator(".xx-assets-layout")).toBeVisible({ timeout: 20_000 });
+    await expect(page.locator(".xx-assets-layout")).toBeVisible({
+      timeout: 20_000,
+    });
 
     const libItem = page
       .locator(".xx-asset-library-item")
@@ -613,7 +758,9 @@ test.describe("素材库页面 - 完整交互测试", () => {
     await libItem.click({ force: true });
 
     // 空状态应显示
-    await expect(page.locator(".xx-assets-empty")).toBeVisible({ timeout: 10_000 });
+    await expect(page.locator(".xx-assets-empty")).toBeVisible({
+      timeout: 10_000,
+    });
     await expect(page.getByText("暂无素材，请上传或切换素材库")).toBeVisible();
   });
 

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

@@ -180,9 +180,11 @@ test.describe("Core media upload flow", () => {
     await expect(page.locator(".xx-assets-content")).toBeVisible({
       timeout: 20_000,
     });
-    await expect(page.getByText("e2e-sample.MOV", { exact: true })).toBeVisible({
-      timeout: 20_000,
-    });
+    await expect(page.getByText("e2e-sample.MOV", { exact: true })).toBeVisible(
+      {
+        timeout: 20_000,
+      },
+    );
 
     // Verify asset card shows status
     const assetCard = page

apps/web/e2e/duplication.spec.ts

@@ -121,7 +121,11 @@ test.describe("去重流程", () => {
       "dup-load",
     );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/duplication");
 
@@ -146,7 +150,11 @@ test.describe("去重流程", () => {
       "dup-upload-zone",
     );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/duplication");
     await expect(page.locator(".dup-page")).toBeVisible({ timeout: 20_000 });
@@ -156,12 +164,12 @@ test.describe("去重流程", () => {
     await expect(uploadZone).toBeVisible();
 
     // 上传图标和文字
-    await expect(uploadZone.getByText("点击或拖拽视频文件到此区域")).toBeVisible();
+    await expect(
+      uploadZone.getByText("点击或拖拽视频文件到此区域"),
+    ).toBeVisible();
 
     // 格式提示
-    await expect(
-      uploadZone.getByText(/支持 MP4、AVI、MOV、MKV/),
-    ).toBeVisible();
+    await expect(uploadZone.getByText(/支持 MP4、AVI、MOV、MKV/)).toBeVisible();
 
     // 格式标签
     await expect(page.locator(".dup-upload-formats")).toBeVisible();
@@ -184,7 +192,11 @@ test.describe("去重流程", () => {
       "dup-info",
     );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/duplication");
     await expect(page.locator(".dup-page")).toBeVisible({ timeout: 20_000 });
@@ -215,7 +227,11 @@ test.describe("去重流程", () => {
       "dup-list",
     );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/duplication/results");
 
@@ -239,7 +255,11 @@ test.describe("去重流程", () => {
       "dup-list-empty",
     );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/duplication/results");
     await expect(page.locator(".dup-page")).toBeVisible({ timeout: 20_000 });
@@ -257,7 +277,11 @@ test.describe("去重流程", () => {
       "dup-filter",
     );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/duplication/results");
     await expect(page.locator(".dup-page")).toBeVisible({ timeout: 20_000 });
@@ -287,7 +311,11 @@ test.describe("去重流程", () => {
       "dup-nav",
     );
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/duplication/results");
     await expect(page.locator(".dup-page")).toBeVisible({ timeout: 20_000 });
@@ -306,10 +334,8 @@ test.describe("去重流程", () => {
     request,
   }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
-      request,
-      "dup-detail",
-    );
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "dup-detail");
 
     // 先上传一个文件进行查重，获取 record id
     const uploadResp = await request.post(`${apiBase}/duplication/upload`, {
@@ -335,7 +361,11 @@ test.describe("去重流程", () => {
     const recordId = uploadData.id;
     expect(recordId, "应返回查重记录 ID").toBeTruthy();
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     // 访问详情页
     await page.goto(`/app/duplication/${recordId}`);
@@ -353,10 +383,8 @@ test.describe("去重流程", () => {
 
   test("去重记录删除 - API 验证", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
-      request,
-      "dup-delete",
-    );
+    const { headers } =
+      await createAuthedUser(request, "dup-delete");
 
     // 创建查重记录
     const uploadResp = await request.post(`${apiBase}/duplication/upload`, {
@@ -419,10 +447,8 @@ test.describe("去重流程", () => {
 
   test("去重记录删除 - UI 验证", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
-      request,
-      "dup-delete-ui",
-    );
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "dup-delete-ui");
 
     // 创建查重记录
     const uploadResp = await request.post(`${apiBase}/duplication/upload`, {
@@ -443,14 +469,20 @@ test.describe("去重流程", () => {
       return;
     }
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/duplication/results");
     await expect(page.locator(".dup-page")).toBeVisible({ timeout: 20_000 });
 
     // 记录卡片应存在
     const resultCard = page.locator(".dup-result-card").first();
-    const cardVisible = await resultCard.isVisible({ timeout: 10_000 }).catch(() => false);
+    const cardVisible = await resultCard
+      .isVisible({ timeout: 10_000 })
+      .catch(() => false);
 
     if (cardVisible) {
       // 删除按钮存在
@@ -467,12 +499,14 @@ test.describe("去重流程", () => {
       });
 
       // 监听删除请求
-      const deletePromise = page.waitForResponse(
-        (resp) =>
-          resp.url().includes("/duplication/records/") &&
-          resp.request().method() === "DELETE",
-        { timeout: 10_000 },
-      ).catch(() => null);
+      const deletePromise = page
+        .waitForResponse(
+          (resp) =>
+            resp.url().includes("/duplication/records/") &&
+            resp.request().method() === "DELETE",
+          { timeout: 10_000 },
+        )
+        .catch(() => null);
 
       await deleteBtn.click();
 
@@ -487,10 +521,8 @@ test.describe("去重流程", () => {
 
   test("重试去重按钮 - 失败记录显示重试", async ({ page, request }) => {
     await routeBrowserApiToTestApi(page);
-    const { headers, userId, accessToken, email, username } = await createAuthedUser(
-      request,
-      "dup-retry",
-    );
+    const { headers, userId, accessToken, email, username } =
+      await createAuthedUser(request, "dup-retry");
 
     // 创建查重记录
     const uploadResp = await request.post(`${apiBase}/duplication/upload`, {
@@ -511,14 +543,20 @@ test.describe("去重流程", () => {
       return;
     }
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/duplication/results");
     await expect(page.locator(".dup-page")).toBeVisible({ timeout: 20_000 });
 
     // 记录列表中至少有一条记录
     const resultCard = page.locator(".dup-result-card").first();
-    const cardVisible = await resultCard.isVisible({ timeout: 10_000 }).catch(() => false);
+    const cardVisible = await resultCard
+      .isVisible({ timeout: 10_000 })
+      .catch(() => false);
 
     if (cardVisible) {
       // 验证记录卡片基本结构

apps/web/e2e/editing-planner.spec.ts

@@ -6,7 +6,12 @@
  *
  * 每个测试独立，先注册登录获取 auth token。
  */
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test";
+import {
+  expect,
+  test,
+  type APIRequestContext,
+  type Page,
+} from "@playwright/test";
 
 const PASSWORD = "Test123456!";
 const apiBase = process.env.E2E_API_BASE || "/api/v1";
@@ -258,7 +263,12 @@ test.describe("剪辑计划 - API 操作", () => {
         mode: "pip",
         estimated_duration: 30,
         segments: [
-          { segment_order: 1, duration_min: 5, duration_max: 10, material_type: "video" },
+          {
+            segment_order: 1,
+            duration_min: 5,
+            duration_max: 10,
+            material_type: "video",
+          },
         ],
       },
     });
@@ -269,7 +279,12 @@ test.describe("剪辑计划 - API 操作", () => {
         mode: "voice_over",
         estimated_duration: 60,
         segments: [
-          { segment_order: 1, duration_min: 10, duration_max: 30, material_type: "video" },
+          {
+            segment_order: 1,
+            duration_min: 10,
+            duration_max: 30,
+            material_type: "video",
+          },
         ],
       },
     });

apps/web/e2e/products.spec.ts

@@ -93,7 +93,8 @@ function mockProducts(count: number, statuses: string[] = ["completed"]) {
       resolution: "1080x1920",
       file_size: (5 + i) * 1024 * 1024,
       duplicate_rate: i * 5,
-      video_url: status === "completed" ? "https://example.com/video.mp4" : undefined,
+      video_url:
+        status === "completed" ? "https://example.com/video.mp4" : undefined,
       thumbnail_url: undefined,
       created_at: new Date().toISOString(),
       updated_at: new Date().toISOString(),
@@ -218,7 +219,11 @@ test.describe("作品库页面", () => {
     const products = mockProducts(3, ["completed", "processing", "failed"]);
     await mockProductsApi(page, products);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
 
@@ -255,12 +260,24 @@ test.describe("作品库页面", () => {
 
     const products = [
       { ...mockProducts(1, ["completed"])[0], title: "已完成作品" },
-      { ...mockProducts(1, ["processing"])[0], title: "处理中作品", id: `mock-prod-${Date.now()}-p` },
-      { ...mockProducts(1, ["failed"])[0], title: "失败作品", id: `mock-prod-${Date.now()}-f` },
+      {
+        ...mockProducts(1, ["processing"])[0],
+        title: "处理中作品",
+        id: `mock-prod-${Date.now()}-p`,
+      },
+      {
+        ...mockProducts(1, ["failed"])[0],
+        title: "失败作品",
+        id: `mock-prod-${Date.now()}-f`,
+      },
     ];
     await mockProductsApi(page, products);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
     await expect(page.locator(".xx-products-page")).toBeVisible({
@@ -276,9 +293,9 @@ test.describe("作品库页面", () => {
     const completedCard = page
       .locator(".xx-product-card")
       .filter({ hasText: "已完成作品" });
-    await expect(completedCard.locator(".xx-product-status.completed")).toHaveText(
-      "已完成",
-    );
+    await expect(
+      completedCard.locator(".xx-product-status.completed"),
+    ).toHaveText("已完成");
 
     const processingCard = page
       .locator(".xx-product-card")
@@ -309,7 +326,11 @@ test.describe("作品库页面", () => {
     const productId = products[0].id;
     await mockProductsApi(page, products);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     // 直接访问详情页
     await page.goto(`/app/products/${productId}`);
@@ -337,7 +358,11 @@ test.describe("作品库页面", () => {
     products[0].video_url = "https://example.com/test-video.mp4";
     await mockProductsApi(page, products);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
     await expect(page.locator(".xx-products-grid")).toBeVisible({
@@ -356,7 +381,10 @@ test.describe("作品库页面", () => {
     // 播放弹窗出现 - 验证有视频元素或播放器容器
     // (通过 Mock 的 video_url，video 元素应能渲染)
     const videoEl = page.locator("video");
-    const videoVisible = await videoEl.first().isVisible({ timeout: 5000 }).catch(() => false);
+    const videoVisible = await videoEl
+      .first()
+      .isVisible({ timeout: 5000 })
+      .catch(() => false);
     // 或弹窗容器可见
     const modalVisible = await page
       .locator(".ant-modal-content")
@@ -380,7 +408,11 @@ test.describe("作品库页面", () => {
     products[0].title = "下载测试作品";
     await mockProductsApi(page, products);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
     await expect(page.locator(".xx-products-grid")).toBeVisible({
@@ -409,7 +441,11 @@ test.describe("作品库页面", () => {
     products[0].title = "处理中下载测试";
     await mockProductsApi(page, products);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
     await expect(page.locator(".xx-products-grid")).toBeVisible({
@@ -484,7 +520,11 @@ test.describe("作品库页面", () => {
       route.continue();
     });
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
     await expect(page.locator(".xx-products-grid")).toBeVisible({
@@ -507,9 +547,12 @@ test.describe("作品库页面", () => {
     const { headers } = await createAuthedUser(request, "products-del-api");
 
     // 测试删除不存在的产品，验证 API 端点存在
-    const resp = await request.delete(`${apiBase}/products/nonexistent-test-id`, {
-      headers,
-    });
+    const resp = await request.delete(
+      `${apiBase}/products/nonexistent-test-id`,
+      {
+        headers,
+      },
+    );
 
     // 应返回 404 或 403，不应是 405 (Method Not Allowed) 或 404 (路由不存在)
     // 404 表示资源不存在但端点存在
@@ -529,7 +572,11 @@ test.describe("作品库页面", () => {
     // Mock 空列表
     await mockProductsApi(page, []);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
     await expect(page.locator(".xx-products-page")).toBeVisible({
@@ -553,12 +600,24 @@ test.describe("作品库页面", () => {
     );
 
     const products = [
-      { ...mockProducts(1, ["completed"])[0], title: "苹果宣传视频", id: `mock-prod-${Date.now()}-apple` },
-      { ...mockProducts(1, ["completed"])[0], title: "香蕉推广视频", id: `mock-prod-${Date.now()}-banana` },
+      {
+        ...mockProducts(1, ["completed"])[0],
+        title: "苹果宣传视频",
+        id: `mock-prod-${Date.now()}-apple`,
+      },
+      {
+        ...mockProducts(1, ["completed"])[0],
+        title: "香蕉推广视频",
+        id: `mock-prod-${Date.now()}-banana`,
+      },
     ];
     await mockProductsApi(page, products);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
     await expect(page.locator(".xx-products-grid")).toBeVisible({
@@ -566,7 +625,9 @@ test.describe("作品库页面", () => {
     });
 
     // 两个作品都可见
-    await expect(page.getByText("苹果宣传视频")).toBeVisible({ timeout: 5_000 });
+    await expect(page.getByText("苹果宣传视频")).toBeVisible({
+      timeout: 5_000,
+    });
     await expect(page.getByText("香蕉推广视频")).toBeVisible();
 
     // 搜索"苹果"
@@ -576,7 +637,9 @@ test.describe("作品库页面", () => {
 
     // 清空搜索
     await page.getByPlaceholder("搜索成片名称...").fill("");
-    await expect(page.getByText("香蕉推广视频")).toBeVisible({ timeout: 5_000 });
+    await expect(page.getByText("香蕉推广视频")).toBeVisible({
+      timeout: 5_000,
+    });
   });
 
   test("作品状态筛选", async ({ page, request }) => {
@@ -587,12 +650,24 @@ test.describe("作品库页面", () => {
     );
 
     const products = [
-      { ...mockProducts(1, ["completed"])[0], title: "已完成筛选", id: `mock-prod-${Date.now()}-done` },
-      { ...mockProducts(1, ["processing"])[0], title: "处理中筛选", id: `mock-prod-${Date.now()}-proc` },
+      {
+        ...mockProducts(1, ["completed"])[0],
+        title: "已完成筛选",
+        id: `mock-prod-${Date.now()}-done`,
+      },
+      {
+        ...mockProducts(1, ["processing"])[0],
+        title: "处理中筛选",
+        id: `mock-prod-${Date.now()}-proc`,
+      },
     ];
     await mockProductsApi(page, products);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
     await expect(page.locator(".xx-products-grid")).toBeVisible({
@@ -629,7 +704,11 @@ test.describe("作品库页面", () => {
     products[2].title = "批量测试 3";
     await mockProductsApi(page, products);
 
-    await setupAuthInBrowser(page, accessToken, { id: userId, email, username });
+    await setupAuthInBrowser(page, accessToken, {
+      id: userId,
+      email,
+      username,
+    });
 
     await page.goto("/app/products");
     await expect(page.locator(".xx-products-grid")).toBeVisible({
@@ -653,8 +732,12 @@ test.describe("作品库页面", () => {
     await expect(batchBar.getByText(/已选择 1 项/)).toBeVisible();
 
     // 批量按钮存在
-    await expect(batchBar.getByRole("button", { name: "批量下载" })).toBeVisible();
-    await expect(batchBar.getByRole("button", { name: "批量删除" })).toBeVisible();
+    await expect(
+      batchBar.getByRole("button", { name: "批量下载" }),
+    ).toBeVisible();
+    await expect(
+      batchBar.getByRole("button", { name: "批量删除" }),
+    ).toBeVisible();
 
     // 取消选择
     await batchBar.getByRole("button", { name: "取消选择" }).click();

apps/web/e2e/profile.spec.ts

@@ -6,7 +6,12 @@
  *
  * 每个测试独立，先注册登录获取 auth token。
  */
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test";
+import {
+  expect,
+  test,
+  type APIRequestContext,
+  type Page,
+} from "@playwright/test";
 
 const PASSWORD = "Test123456!";
 const apiBase = process.env.E2E_API_BASE || "/api/v1";
@@ -401,7 +406,10 @@ test.describe("个人设置 - 退出登录", () => {
   test.describe.configure({ timeout: 120_000 });
 
   test("登出 API - 正向", async ({ request }) => {
-    const { headers, email } = await createAuthedUser(request, "profile-logout");
+    const { headers } = await createAuthedUser(
+      request,
+      "profile-logout",
+    );
 
     const response = await request.post(`${apiBase}/auth/logout`, {
       headers,

apps/web/e2e/register.spec.ts

@@ -49,7 +49,9 @@ test.describe("注册页面", () => {
     await expect(page.locator(".xx-auth-brand-name")).toHaveText("小虾智剪");
 
     // 标题/描述
-    await expect(page.getByText("创建账户，开启智能视频创作之旅")).toBeVisible();
+    await expect(
+      page.getByText("创建账户，开启智能视频创作之旅"),
+    ).toBeVisible();
 
     // 表单字段
     await expect(page.getByLabel("邮箱")).toBeVisible();
@@ -69,7 +71,10 @@ test.describe("注册页面", () => {
     await page.goto("/register");
 
     // 直接点击注册按钮
-    await page.locator("button[type='submit']").filter({ hasText: "注册" }).click();
+    await page
+      .locator("button[type='submit']")
+      .filter({ hasText: "注册" })
+      .click();
 
     // 应显示必填错误
     await expect(page.getByText("请输入邮箱")).toBeVisible();
@@ -86,7 +91,10 @@ test.describe("注册页面", () => {
     await page.getByLabel("密码").fill(PASSWORD);
     await page.getByLabel("确认密码").fill(PASSWORD);
 
-    await page.locator("button[type='submit']").filter({ hasText: "注册" }).click();
+    await page
+      .locator("button[type='submit']")
+      .filter({ hasText: "注册" })
+      .click();
 
     // 应显示邮箱格式错误
     await expect(page.getByText("请输入有效的邮箱地址")).toBeVisible();
@@ -100,7 +108,10 @@ test.describe("注册页面", () => {
     await page.getByLabel("密码").fill("123");
     await page.getByLabel("确认密码").fill("123");
 
-    await page.locator("button[type='submit']").filter({ hasText: "注册" }).click();
+    await page
+      .locator("button[type='submit']")
+      .filter({ hasText: "注册" })
+      .click();
 
     // 应显示密码长度错误
     await expect(page.getByText("密码至少 8 个字符")).toBeVisible();
@@ -114,7 +125,10 @@ test.describe("注册页面", () => {
     await page.getByLabel("密码").fill(PASSWORD);
     await page.getByLabel("确认密码").fill("Different123!");
 
-    await page.locator("button[type='submit']").filter({ hasText: "注册" }).click();
+    await page
+      .locator("button[type='submit']")
+      .filter({ hasText: "注册" })
+      .click();
 
     // 应显示密码不一致错误
     await expect(page.getByText("两次输入的密码不一致")).toBeVisible();
@@ -128,14 +142,17 @@ test.describe("注册页面", () => {
     await page.getByLabel("密码").fill(PASSWORD);
     await page.getByLabel("确认密码").fill(PASSWORD);
 
-    await page.locator("button[type='submit']").filter({ hasText: "注册" }).click();
+    await page
+      .locator("button[type='submit']")
+      .filter({ hasText: "注册" })
+      .click();
 
     await expect(page.getByText("请输入用户名")).toBeVisible();
   });
 
   // ─── 成功注册 ──────────────────────────────────────
 
-  test("成功注册 - 提交有效表单", async ({ page, request }) => {
+  test("成功注册 - 提交有效表单", async ({ page, _request }) => {
     const email = uniqueEmail("reg-ui-ok");
     const username = uniqueUsername("reguiok");
 
@@ -154,10 +171,16 @@ test.describe("注册页面", () => {
       { timeout: 15_000 },
     );
 
-    await page.locator("button[type='submit']").filter({ hasText: "注册" }).click();
+    await page
+      .locator("button[type='submit']")
+      .filter({ hasText: "注册" })
+      .click();
 
     const resp = await registerResponse;
-    expect(resp.ok(), `注册请求应返回 2xx，实际: ${resp.status()}`).toBeTruthy();
+    expect(
+      resp.ok(),
+      `注册请求应返回 2xx，实际: ${resp.status()}`,
+    ).toBeTruthy();
 
     // 注册成功后应跳转到登录页或显示成功消息
     // 页面应停留在可识别的状态（成功提示或跳转）
@@ -199,14 +222,19 @@ test.describe("注册页面", () => {
     await page.getByLabel("密码").fill(PASSWORD);
     await page.getByLabel("确认密码").fill(PASSWORD);
 
-    await page.locator("button[type='submit']").filter({ hasText: "注册" }).click();
+    await page
+      .locator("button[type='submit']")
+      .filter({ hasText: "注册" })
+      .click();
 
     // 应显示错误提示（通过 antd message 或表单错误）
     await expect
       .poll(
         async () => {
           // 检查是否有错误消息
-          const hasError = await page.getByText(/注册失败|已注册|已存在|exists/).isVisible();
+          const hasError = await page
+            .getByText(/注册失败|已注册|已存在|exists/)
+            .isVisible();
           return hasError ? "error_shown" : "waiting";
         },
         { timeout: 10_000 },
@@ -254,7 +282,12 @@ test.describe("注册页面", () => {
 
     // 注册
     await request.post(`${apiBase}/auth/register`, {
-      data: { email, password: PASSWORD, username, display_name: "Reg Auth Test" },
+      data: {
+        email,
+        password: PASSWORD,
+        username,
+        display_name: "Reg Auth Test",
+      },
     });
 
     // 登录
@@ -293,6 +326,8 @@ test.describe("注册页面", () => {
     // 注册页对已登录用户也可访问（注册页是公开页面）
     // 验证页面正常渲染
     await expect(page.getByLabel("邮箱")).toBeVisible();
-    await expect(page.locator("button[type='submit']").filter({ hasText: "注册" })).toBeVisible();
+    await expect(
+      page.locator("button[type='submit']").filter({ hasText: "注册" }),
+    ).toBeVisible();
   });
 });

apps/web/e2e/subscription-full.spec.ts

@@ -9,7 +9,12 @@
  *
  * 每个测试独立，先注册登录获取 auth token。
  */
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test";
+import {
+  expect,
+  test,
+  type APIRequestContext,
+  type Page,
+} from "@playwright/test";
 
 const PASSWORD = "Test123456!";
 const apiBase = process.env.E2E_API_BASE || "/api/v1";
@@ -243,8 +248,13 @@ test.describe("订阅套餐页 - 升级交互", () => {
       const url = page.url();
       // 验证页面有响应（跳转到支付或保持在订阅页但有弹窗）
       expect(
-        url.includes("/subscription/upgrade") || url.includes("/subscription") ||
-          (await page.locator(".ant-modal, [role='dialog']").first().isVisible().catch(() => false)),
+        url.includes("/subscription/upgrade") ||
+          url.includes("/subscription") ||
+          (await page
+            .locator(".ant-modal, [role='dialog']")
+            .first()
+            .isVisible()
+            .catch(() => false)),
       ).toBeTruthy();
     }
   });
@@ -538,13 +548,16 @@ test.describe("订阅 - 支付流程", () => {
   test("创建支付订单 - 正向 API", async ({ request }) => {
     const { headers } = await createAuthedUser(request, "sub-pay-api");
 
-    const response = await request.post(`${apiBase}/subscription/create-order`, {
-      headers,
-      data: {
-        plan_id: "pro",
-        billing_cycle: "monthly",
+    const response = await request.post(
+      `${apiBase}/subscription/create-order`,
+      {
+        headers,
+        data: {
+          plan_id: "pro",
+          billing_cycle: "monthly",
+        },
       },
-    });
+    );
 
     // 创建支付订单可能成功或接口不存在
     expect(
@@ -560,12 +573,15 @@ test.describe("订阅 - 支付流程", () => {
   });
 
   test("未登录创建订单 - 反向", async ({ request }) => {
-    const response = await request.post(`${apiBase}/subscription/create-order`, {
-      data: {
-        plan_id: "pro",
-        billing_cycle: "monthly",
+    const response = await request.post(
+      `${apiBase}/subscription/create-order`,
+      {
+        data: {
+          plan_id: "pro",
+          billing_cycle: "monthly",
+        },
       },
-    });
+    );
     expect([401, 403, 404]).toContain(response.status());
   });
 });

apps/web/e2e/subscription.spec.ts

@@ -178,7 +178,10 @@ test.describe("订阅过期处理", () => {
     // 免费用户可能不需要取消，返回 400 或类似错误
     if (!response.ok()) {
       const data = await response.json();
-      expect(data.error?.message || data.detail || data.message, "应返回错误信息").toBeTruthy();
+      expect(
+        data.error?.message || data.detail || data.message,
+        "应返回错误信息",
+      ).toBeTruthy();
     }
   });
 

apps/web/e2e/templates.spec.ts

@@ -6,7 +6,12 @@
  *
  * 每个测试独立，先注册登录获取 auth token。
  */
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test";
+import {
+  expect,
+  test,
+  type APIRequestContext,
+  type Page,
+} from "@playwright/test";
 
 const PASSWORD = "Test123456!";
 const apiBase = process.env.E2E_API_BASE || "/api/v1";
@@ -326,7 +331,9 @@ test.describe("模板库 - 模板展示", () => {
       if (await modal.isVisible({ timeout: 5_000 })) {
         await expect(modal).toBeVisible();
         // 验证预览内容存在
-        await expect(modal.locator(".xx-template-modal-title-row")).toBeVisible();
+        await expect(
+          modal.locator(".xx-template-modal-title-row"),
+        ).toBeVisible();
       }
     }
   });
@@ -487,7 +494,10 @@ test.describe("模板库 - API 操作", () => {
       `${apiBase}/templates/${templateId}/favorite`,
       { headers },
     );
-    expect(unfavResp.status() < 500, "取消收藏请求应返回 2xx 或 4xx").toBeTruthy();
+    expect(
+      unfavResp.status() < 500,
+      "取消收藏请求应返回 2xx 或 4xx",
+    ).toBeTruthy();
   });
 
   test("获取模板详情 - 正向", async ({ request }) => {
@@ -515,10 +525,9 @@ test.describe("模板库 - API 操作", () => {
     expect(createResp.ok()).toBeTruthy();
     const created = await createResp.json();
 
-    const detailResp = await request.get(
-      `${apiBase}/templates/${created.id}`,
-      { headers },
-    );
+    const detailResp = await request.get(`${apiBase}/templates/${created.id}`, {
+      headers,
+    });
     expect(detailResp.ok(), "获取详情应成功").toBeTruthy();
     const detail = await detailResp.json();
     expect(detail.id).toBe(created.id);

apps/web/e2e/test_auth.spec.ts

@@ -175,10 +175,9 @@ test.describe("认证流程", () => {
       },
     });
 
-    expect(
-      [400, 422],
-      "缺少用户名字段应返回 4xx 校验错误",
-    ).toContain(response.status());
+    expect([400, 422], "缺少用户名字段应返回 4xx 校验错误").toContain(
+      response.status(),
+    );
   });
 
   // ─── 登录 ────────────────────────────────────────────
@@ -230,7 +229,9 @@ test.describe("认证流程", () => {
         data: { email: `ghost_${Date.now()}@nonexist.com`, password: PASSWORD },
       });
       if (response.status() !== 429) break;
-      console.log(`[反向登录测试] 触发限流，等待 65s 后重试 (${attempt + 1}/2)`);
+      console.log(
+        `[反向登录测试] 触发限流，等待 65s 后重试 (${attempt + 1}/2)`,
+      );
       await new Promise((r) => setTimeout(r, 65_000));
     }
 

apps/web/e2e/titles-full.spec.ts

@@ -9,7 +9,12 @@
  *
  * 每个测试独立，先注册登录获取 auth token。
  */
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test";
+import {
+  expect,
+  test,
+  type APIRequestContext,
+  type Page,
+} from "@playwright/test";
 
 const PASSWORD = "Test123456!";
 const apiBase = process.env.E2E_API_BASE || "/api/v1";
@@ -224,7 +229,11 @@ test.describe("标题库 - API 完整操作", () => {
 
   test("编辑标题 - 正向", async ({ request }) => {
     const { headers } = await createAuthedUser(request, "title-update");
-    const titleId = await createTitle(request, headers, Date.now().toString(36));
+    const titleId = await createTitle(
+      request,
+      headers,
+      Date.now().toString(36),
+    );
 
     const newName = `更新后的标题 ${Date.now()}`;
     const newText = "这是更新后的标题内容";
@@ -256,7 +265,11 @@ test.describe("标题库 - API 完整操作", () => {
 
   test("删除标题 - 正向", async ({ request }) => {
     const { headers } = await createAuthedUser(request, "title-delete");
-    const titleId = await createTitle(request, headers, Date.now().toString(36));
+    const titleId = await createTitle(
+      request,
+      headers,
+      Date.now().toString(36),
+    );
 
     // 删除
     const deleteResp = await request.delete(`${apiBase}/titles/${titleId}`, {
@@ -279,9 +292,21 @@ test.describe("标题库 - API 完整操作", () => {
     const suffix = Date.now().toString(36);
 
     const titles = [
-      { name: `批量标题 1 ${suffix}`, text: `内容 1 ${suffix}`, category: "default" },
-      { name: `批量标题 2 ${suffix}`, text: `内容 2 ${suffix}`, category: "种草" },
-      { name: `批量标题 3 ${suffix}`, text: `内容 3 ${suffix}`, category: "知识" },
+      {
+        name: `批量标题 1 ${suffix}`,
+        text: `内容 1 ${suffix}`,
+        category: "default",
+      },
+      {
+        name: `批量标题 2 ${suffix}`,
+        text: `内容 2 ${suffix}`,
+        category: "种草",
+      },
+      {
+        name: `批量标题 3 ${suffix}`,
+        text: `内容 3 ${suffix}`,
+        category: "知识",
+      },
     ];
 
     const response = await request.post(`${apiBase}/titles/batch-import`, {
@@ -297,7 +322,9 @@ test.describe("标题库 - API 完整操作", () => {
 
     if (response.ok()) {
       const data = await response.json();
-      expect(Array.isArray(data) || data.success_count !== undefined).toBeTruthy();
+      expect(
+        Array.isArray(data) || data.success_count !== undefined,
+      ).toBeTruthy();
     }
   });
 
@@ -531,7 +558,6 @@ test.describe("标题库 - 批量操作", () => {
     });
 
     // 检查是否有批量操作相关 UI
-    const checkboxes = page.locator(".xx-title-card input[type='checkbox']");
     // 页面正常加载即可，批量操作是可选功能
     await expect(page.locator(".xx-titles-page")).toBeVisible();
   });

apps/web/e2e/voice-clone.spec.ts

@@ -6,7 +6,12 @@
  *
  * 每个测试独立，先注册登录获取 auth token。
  */
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test";
+import {
+  expect,
+  test,
+  type APIRequestContext,
+  type Page,
+} from "@playwright/test";
 
 const PASSWORD = "Test123456!";
 const apiBase = process.env.E2E_API_BASE || "/api/v1";
@@ -157,7 +162,6 @@ test.describe("声音克隆页面 - 页面加载", () => {
     });
 
     // 验证页面标题包含"克隆"或"音色"相关文字
-    const pageTitle = page.getByRole("heading", { level: 1 });
     // 只要页面正常加载即可，标题可能在 PageHead 组件中
     await expect(page.locator(".vc-page")).toBeVisible();
   });
@@ -181,7 +185,6 @@ test.describe("声音克隆页面 - 页面加载", () => {
     });
 
     // 验证克隆新音色按钮存在
-    const cloneBtn = page.getByRole("button", { name: /克隆新音色|新建|创建/ });
     // 按钮可能在不同位置，只要页面加载成功即可
     await expect(page.locator(".vc-page")).toBeVisible();
   });
@@ -326,10 +329,9 @@ test.describe("声音克隆 - API 操作", () => {
       ).toBeTruthy();
 
       // 验证已删除
-      const getResp = await request.get(
-        `${apiBase}/voice-clones/${cloneId}`,
-        { headers },
-      );
+      const getResp = await request.get(`${apiBase}/voice-clones/${cloneId}`, {
+        headers,
+      });
       expect([404, 410]).toContain(getResp.status());
     }
     // 如果创建失败（比如音频格式问题），测试也通过
@@ -491,11 +493,15 @@ test.describe("声音克隆 - 上传区域", () => {
     });
 
     // 尝试点击克隆新音色按钮
-    const cloneBtn = page.getByRole("button", { name: /克隆新音色|立即克隆|新建/ });
+    const cloneBtn = page.getByRole("button", {
+      name: /克隆新音色|立即克隆|新建/,
+    });
     if (await cloneBtn.isVisible()) {
       await cloneBtn.click();
       // 弹窗应该出现
-      const modal = page.locator(".ant-modal, .vc-edit-dialog, [role='dialog']");
+      const modal = page.locator(
+        ".ant-modal, .vc-edit-dialog, [role='dialog']",
+      );
       if (await modal.first().isVisible({ timeout: 5_000 })) {
         await expect(modal.first()).toBeVisible();
       }

apps/web/e2e/voices.spec.ts

@@ -6,7 +6,12 @@
  *
  * 每个测试独立，先注册登录获取 auth token。
  */
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test";
+import {
+  expect,
+  test,
+  type APIRequestContext,
+  type Page,
+} from "@playwright/test";
 
 const PASSWORD = "Test123456!";
 const apiBase = process.env.E2E_API_BASE || "/api/v1";
@@ -157,7 +162,9 @@ test.describe("音色库页面 - 页面加载", () => {
     });
 
     // 验证搜索框存在
-    const searchInput = page.locator("input[type='search'], .xx-voices-search input, input[placeholder*='搜索']");
+    const searchInput = page.locator(
+      "input[type='search'], .xx-voices-search input, input[placeholder*='搜索']",
+    );
     await expect(searchInput.first()).toBeVisible({ timeout: 10_000 });
   });
 });
@@ -304,9 +311,6 @@ test.describe("音色库 - 我的克隆音色", () => {
     });
 
     // 验证创建克隆音色按钮存在（可能是"克隆音色"或"新建"按钮）
-    const createBtn = page.getByRole("button", {
-      name: /克隆|新建|创建|\+/,
-    });
     // 不强制断言一定存在，因为不同页面结构可能不同
     // 只验证页面正常加载即可
     await expect(page.locator(".xx-voices-page")).toBeVisible();
@@ -365,7 +369,6 @@ test.describe("音色库 - 搜索和筛选", () => {
     });
 
     // 验证筛选相关元素存在（可能是下拉选择器或标签）
-    const filterSelect = page.locator("select, .xx-voices-filter");
     // 页面正常加载即通过
     await expect(page.locator(".xx-voices-page")).toBeVisible();
   });

apps/web/package-lock.json

@@ -33,6 +33,7 @@
         "eslint-plugin-react-hooks": "^4.6.2",
         "eslint-plugin-react-refresh": "^0.4.7",
         "jsdom": "^24.1.0",
+        "prettier": "^3.0.0",
         "typescript": "^5.5.3",
         "vite": "^5.3.1",
         "vitest": "^1.6.0"
@@ -4828,6 +4829,22 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/prettier": {
+      "version": "3.9.5",
+      "resolved": "https://registry.npmmirror.com/prettier/-/prettier-3.9.5.tgz",
+      "integrity": "sha512-/FVl766LpUfB5vXgCYOYa0MeV/441Ia99AeICQIQFTY/Nw0roZwULcXpku5i1/m5kt/baz+s4Zogspd839HSMg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
     "node_modules/pretty-format": {
       "version": "27.5.1",
       "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",

apps/web/package.json

@@ -42,6 +42,7 @@
     "eslint-plugin-react-hooks": "^4.6.2",
     "eslint-plugin-react-refresh": "^0.4.7",
     "jsdom": "^24.1.0",
+    "prettier": "^3.0.0",
     "typescript": "^5.5.3",
     "vite": "^5.3.1",
     "vitest": "^1.6.0"

apps/web/src/api/assets.ts

@@ -5,6 +5,32 @@
 import apiClient from "./client";
 import { getOrCreateDefaultProject } from "./projects";
 
+/** 素材元数据 */
+export interface AssetMetadata {
+  /** 时长（秒） */
+  duration?: number;
+  /** 宽度（像素） */
+  width?: number;
+  /** 高度（像素） */
+  height?: number;
+  /** 比特率（bps） */
+  bitrate?: number;
+  /** 编码格式 */
+  codec?: string;
+  /** 帧率 */
+  fps?: number;
+  /** 采样率（Hz） */
+  sample_rate?: number;
+  /** 声道数 */
+  channels?: number;
+  /** 其他扩展字段 */
+  [key: string]: unknown;
+}
+
+/** 素材分类状态 */
+export type AssetClassificationStatus =
+  "pending" | "processing" | "completed" | "failed";
+
 /** 素材条目 */
 export interface AssetItem {
   id: string;
@@ -12,12 +38,14 @@ export interface AssetItem {
   name: string;
   storage_key: string;
   mime_type: string;
-  metadata: Record<string, unknown>;
+  metadata: AssetMetadata;
   file_size?: number;
   file_url?: string;
   thumbnail_url?: string;
+  /** 时长（秒），视频/音频素材由后端从 metadata 提取到顶层 */
+  duration?: number;
   status?: string;
-  classification_status?: string | null;
+  classification_status?: AssetClassificationStatus | null;
   quality_score?: number | null;
   tag_ids?: string[];
   created_at?: string;
@@ -167,7 +195,7 @@ export const createAsset = async (data: {
   name: string;
   storage_key: string;
   mime_type: string;
-  metadata?: Record<string, unknown>;
+  metadata?: AssetMetadata;
 }): Promise<AssetItem> => {
   const response = await apiClient.post("/assets", data);
   return response.data;
@@ -176,7 +204,7 @@ export const createAsset = async (data: {
 /** 更新素材（名称、metadata 等） */
 export const updateAsset = async (
   assetId: string,
-  data: { name?: string; metadata?: Record<string, unknown> },
+  data: { name?: string; metadata?: AssetMetadata },
 ): Promise<AssetItem> => {
   const response = await apiClient.put(`/assets/${assetId}`, data);
   return response.data;
@@ -350,3 +378,52 @@ export const getClassificationJob = async (
   const response = await apiClient.get(`/classification-jobs/${jobId}`);
   return response.data;
 };
+
+// ─── 批量操作 ───────────────────────────────────────────────
+
+/** 批量操作结果 */
+export interface BatchOperationResult {
+  succeeded: string[];
+  failed: string[];
+  total: number;
+  success_count: number;
+  failure_count: number;
+}
+
+/** 批量删除素材 */
+export const batchDeleteAssets = async (
+  assetIds: string[],
+): Promise<BatchOperationResult> => {
+  const response = await apiClient.post("/assets/batch-delete", {
+    asset_ids: assetIds,
+  });
+  return response.data;
+};
+
+/** 批量打标签 */
+export const batchTagAssets = async (data: {
+  asset_ids: string[];
+  tags: string[];
+  mode: "add" | "replace";
+}): Promise<BatchOperationResult> => {
+  const response = await apiClient.post("/assets/batch-tag", data);
+  return response.data;
+};
+
+/** 批量改分类 */
+export const batchClassifyAssets = async (data: {
+  asset_ids: string[];
+  category: string;
+}): Promise<BatchOperationResult> => {
+  const response = await apiClient.post("/assets/batch-classify", data);
+  return response.data;
+};
+
+/** 批量智能标记 */
+export const batchMarkAssets = async (data: {
+  asset_ids: string[];
+  smart_view: "recommended" | "caution" | "high_risk";
+}): Promise<BatchOperationResult> => {
+  const response = await apiClient.post("/assets/batch-mark", data);
+  return response.data;
+};

apps/web/src/api/bgm.ts

@@ -0,0 +1,70 @@
+/**
+ * BGM 预设音乐 API
+ * 对接后端 BGM 混音能力：预设列表查询（按风格分类 + 关键词搜索）
+ */
+import apiClient from "./client";
+
+/* ──────────── 类型 ──────────── */
+
+/** BGM 风格分类 */
+export type BgmCategory = "轻快" | "治愈" | "科技" | "电商";
+
+/** BGM 预设项 */
+export interface BgmPreset {
+  id: string;
+  name: string;
+  category: BgmCategory;
+  /** 音频文件 URL */
+  url: string;
+  /** 时长（秒） */
+  duration: number;
+  /** 关键词标签 */
+  tags: string[];
+  /** 封面图 URL */
+  cover_url?: string;
+}
+
+/** BGM 预设列表查询参数 */
+export interface BgmPresetsQuery {
+  category?: BgmCategory | string;
+  keyword?: string;
+}
+
+/** BGM 混音配置（嵌入剪辑计划） */
+export interface BgmMixConfig {
+  /** 是否启用 BGM */
+  enabled: boolean;
+  /** 选中的 BGM ID */
+  music_id: string;
+  /** BGM 音量 0-100 */
+  volume: number;
+  /** 淡入时长（秒） 0-3 */
+  fade_in: number;
+  /** 淡出时长（秒） 0-3 */
+  fade_out: number;
+  /** 人声闪避（sidechain） */
+  voice_dodge: boolean;
+}
+
+/** 默认 BGM 混音配置 */
+export const DEFAULT_BGM_MIX_CONFIG: BgmMixConfig = {
+  enabled: false,
+  music_id: "",
+  volume: 50,
+  fade_in: 0.5,
+  fade_out: 0.5,
+  voice_dodge: true,
+};
+
+/* ──────────── API ──────────── */
+
+/** 获取 BGM 预设列表 */
+export const getBgmPresets = async (
+  params?: BgmPresetsQuery,
+): Promise<BgmPreset[]> => {
+  const searchParams: Record<string, string> = {};
+  if (params?.category) searchParams.category = params.category;
+  if (params?.keyword) searchParams.keyword = params.keyword;
+  const res = await apiClient.get("/bgm/presets", { params: searchParams });
+  return res.data?.data ?? res.data ?? [];
+};

apps/web/src/api/client.ts

@@ -129,7 +129,8 @@ apiClient.interceptors.response.use(
     const safeExtractString = (val: unknown): string => {
       if (typeof val === "string") return val;
       if (typeof val === "object" && val !== null) {
-        const obj = val as Record<string, unknown>;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- 防御性错误提取，后端错误格式不固定
+        const obj = val as Record<string, any>;
         if (typeof obj.message === "string") return obj.message;
         if (typeof obj.msg === "string") return obj.msg;
         if (typeof obj.detail === "string") return obj.detail;

apps/web/src/api/editPlans.ts

@@ -4,6 +4,15 @@
  */
 import apiClient from "./client";
 import type { AssetItem } from "./assets";
+import type {
+  WatermarkConfig,
+  IntroOutroConfig,
+  PipConfig,
+  FilterConfig,
+  ChromaKeyConfig,
+  StickerConfig,
+  CoverConfig,
+} from "@/pages/editing-planner/types";
 
 /* ============================================================
  * 后端 API 类型（严格匹配后端 Schema）
@@ -11,7 +20,108 @@ import type { AssetItem } from "./assets";
 
 /** 剪辑计划状态枚举 */
 export type EditPlanStatus =
-  "draft" | "editing" | "rendering" | "completed" | "failed";
+  "draft" | "editing" | "rendering" | "completed" | "failed" | "cancelled";
+
+/** 标题配置（对齐后端 title_config） */
+export interface TitleConfig {
+  ai_auto_select: boolean;
+  content: string;
+  font_preset: string;
+  font_color: string;
+  font_size: number;
+  position: string;
+}
+
+/** 字幕配置 */
+export interface SubtitleConfig {
+  enabled: boolean;
+  position: string;
+  font: string;
+  color: string;
+  size: number;
+  animation: string;
+}
+
+/** BGM 配置 */
+export interface BgmConfig {
+  enabled: boolean;
+  music_id: string;
+}
+
+/** 片段 TTS 配置 */
+export interface SegmentTtsConfig {
+  mode: string;
+  text: string;
+  voice_id: string;
+  speed: number;
+  pitch: number;
+  volume: number;
+  subtitle_sync: boolean;
+}
+
+/** 片段裁剪配置 */
+export interface SegmentTrimConfig {
+  start_time: number;
+  end_time: number;
+}
+
+/** 片段转场配置 */
+export interface SegmentTransitionConfig {
+  type: string;
+  duration: number;
+}
+
+/** 剪辑计划中的单个片段（config 内部 segments 项） */
+export interface EditPlanSegment {
+  segment_order: number;
+  duration_min: number;
+  duration_max: number;
+  material_type: string;
+  transition?: SegmentTransitionConfig;
+  playback_speed?: number;
+  tts_config?: SegmentTtsConfig;
+  trim_config?: SegmentTrimConfig;
+}
+
+/** 剪辑计划 config 完整类型（对齐后端 config JSON 结构） */
+export interface EditPlanConfig {
+  title_config?: TitleConfig;
+  subtitle_config?: SubtitleConfig;
+  bgm_config?: BgmConfig;
+  estimated_duration?: number;
+  segments?: EditPlanSegment[];
+  watermark_config?: WatermarkConfig;
+  intro_outro_config?: IntroOutroConfig;
+  pip_config?: PipConfig;
+  filter_config?: FilterConfig;
+  green_screen_config?: ChromaKeyConfig;
+  sticker_config?: StickerConfig;
+  cover_config?: CoverConfig;
+  /** 前端扩展：关联的素材 ID 列表 */
+  asset_ids?: string[];
+  /** 配音 ID */
+  voice_id?: string;
+  /** 克隆音色档案 ID */
+  voice_clone_profile_id?: string;
+  /** 自定义配音音频 URL */
+  custom_audio_url?: string;
+  /** 自定义配音文本 */
+  custom_text?: string;
+  /** 视频比例 */
+  ratio?: string;
+  /** 视频风格 */
+  style?: string;
+  /** 目标时长（秒） */
+  duration?: number;
+  /** 是否自动生成字幕 */
+  auto_subtitles?: boolean;
+  /** 是否启用 BGM */
+  bgm?: boolean;
+  /** 生成数量 */
+  generate_count?: number;
+  /** 素材模式 */
+  material_mode?: string;
+}
 
 /** 剪辑计划（后端响应） */
 export interface EditPlan {
@@ -20,7 +130,9 @@ export interface EditPlan {
   name: string;
   status: EditPlanStatus;
   total_duration: number;
-  config: Record<string, unknown>;
+  /** 生成视频数量（后端 EditPlanResponse.result_count） */
+  result_count: number;
+  config: EditPlanConfig;
   created_at: string;
   updated_at: string;
 }
@@ -29,7 +141,7 @@ export interface EditPlan {
 export interface CreateEditPlanRequest {
   template_id: string;
   name: string;
-  config?: Record<string, unknown>;
+  config?: EditPlanConfig;
   total_duration?: number;
   /** 来源剪辑计划 ID（从剪辑计划跳转到一键生成时关联） */
   source_edit_plan_id?: string;
@@ -38,7 +150,7 @@ export interface CreateEditPlanRequest {
 /** 更新剪辑计划请求 */
 export interface UpdateEditPlanRequest {
   name?: string;
-  config?: Record<string, unknown>;
+  config?: EditPlanConfig;
   total_duration?: number;
   status?: EditPlanStatus;
 }
@@ -51,14 +163,21 @@ export interface GenerateResponse {
   clip_count: number;
 }
 
-/** 剪辑计划关联的生成记录 */
+/** 剪辑计划关联的生成记录（实际是 GenerationTask 对象） */
 export interface EditPlanGeneration {
-  id: string;
-  edit_plan_id: string;
-  generation_task_id: string;
+  id: string; // 即 generation_task_id
+  source_edit_plan_id: string;
+  template_id: string;
+  asset_ids: string[];
   status: EditPlanStatus;
-  created_at: string;
-  updated_at: string;
+  progress: number;
+  result_count: number;
+  error_message: string;
+  error_info: Record<string, unknown>;
+  logs: Array<Record<string, unknown>>;
+  retry_count: number;
+  created_at?: string;
+  updated_at?: string;
 }
 
 /** 片段生成状态 */
@@ -80,6 +199,26 @@ export interface GenerationStatusResponse {
   clips: ClipStatusItem[];
 }
 
+/** 生成视频详情（对应后端 GeneratedVideoResponse） */
+export interface GeneratedVideo {
+  id: string;
+  project_id?: string;
+  generation_task_id?: string;
+  name: string;
+  file_url: string;
+  file_size?: number;
+  duration?: number;
+  thumbnail_url?: string;
+  width?: number;
+  height?: number;
+  fps?: number;
+  status: string;
+  review_status?: string;
+  download_url?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
 /* ============================================================
  * AI 推荐 & 封面生成（任务 3.09）
  * ============================================================ */
@@ -100,14 +239,14 @@ export interface AIRecommendClipItem {
   transition_effect: string;
   asset_id: string;
   start_time: number;
-  config: Record<string, unknown>;
+  config: EditPlanConfig;
 }
 
 /** AI 推荐响应 */
 export interface AIRecommendResponse {
   plan_id: string;
   clips: AIRecommendClipItem[];
-  config: Record<string, unknown>;
+  config: EditPlanConfig;
   total_duration: number;
   confidence: number;
 }
@@ -122,35 +261,42 @@ export interface GenerateCoverRequest {
 /** AI 封面生成响应 */
 export interface GenerateCoverResponse {
   plan_id: string;
-  cover: Record<string, unknown>;
+  cover: CoverResult;
+}
+
+/** 封面生成结果 */
+export interface CoverResult {
+  scheme?: string;
+  asset_id?: string;
+  frame_time?: number;
+  thumbnail_url?: string;
 }
 
 /* ============================================================
  * 前端 UI 类型（EditingPlanner 组件依赖，保留兼容）
  * ============================================================ */
 
-/** 剪辑计划中的片段（UI 层类型） */
-export interface EditPlanClip {
-  id: string;
-  template_segment_id: string;
-  /** 素材库中的素材 ID */
-  media_asset_id?: string;
-  /** 素材类型 */
-  material_type: "video" | "image" | "audio" | "voiceover";
-  /** 片段文案 */
-  script_text: string;
-  /** 实际时长（秒） */
-  duration: number;
-  /** 转场效果 */
-  transition?: TransitionEffect;
-  /** 排序 */
-  order: number;
-}
-
-/** 转场效果 */
+/** 转场效果（14 种预设） */
 export interface TransitionEffect {
-  type: "none" | "fade" | "dissolve" | "wipe" | "zoom" | "slide";
+  type:
+    | "none"
+    | "cut"
+    | "fade"
+    | "dissolve"
+    | "zoom"
+    | "slide_left"
+    | "slide_right"
+    | "slide_up"
+    | "slide_down"
+    | "wipe_left"
+    | "wipe_right"
+    | "wipe_up"
+    | "wipe_down"
+    | "circlecrop"
+    | "rectcrop";
   duration: number; // 转场时长（秒）
+  /** 播放速度倍率 */
+  playback_speed?: number;
 }
 
 /** 素材库资产（UI 层类型，映射自后端 AssetResponse） */
@@ -177,15 +323,30 @@ export interface MediaAsset {
  * API 函数 — 严格对接后端
  * ============================================================ */
 
-/** 获取剪辑计划列表 */
-export async function getEditPlans(params?: {
+/** 剪辑计划列表查询参数 */
+export interface EditPlanListParams {
   page?: number;
   page_size?: number;
   template_id?: string;
   status?: string;
-}): Promise<EditPlan[]> {
-  const response = await apiClient.get("/edit-plans", { params });
-  return response.data.items || [];
+}
+
+/** 剪辑计划列表分页响应 */
+export interface EditPlanListResponse {
+  items: EditPlan[];
+  total: number;
+  page: number;
+  page_size: number;
+}
+
+/** 获取剪辑计划列表（支持分页和筛选） */
+export async function getEditPlans(
+  params?: EditPlanListParams,
+): Promise<EditPlanListResponse> {
+  const response = await apiClient.get<EditPlanListResponse>("/edit-plans", {
+    params,
+  });
+  return response.data;
 }
 
 /** 获取单个剪辑计划 */
@@ -266,6 +427,233 @@ export async function getEditPlanGenerations(
   return response.data.items || [];
 }
 
+/** 获取生成任务的视频结果列表 */
+export async function getGenerationTaskResults(
+  taskId: string,
+): Promise<GeneratedVideo[]> {
+  const response = await apiClient.get(`/generation/tasks/${taskId}/results`);
+  return response.data.items || response.data || [];
+}
+
+/** 取消生成任务 */
+export async function cancelGeneration(planId: string): Promise<void> {
+  await apiClient.post(`/edit-plans/${planId}/cancel`);
+}
+
+/* ============================================================
+ * 片段 CRUD（后端 EditPlanClip 独立表）
+ * ============================================================ */
+
+/** 片段状态 */
+export type EditPlanClipStatus = "pending" | "processing" | "ready" | "failed";
+
+/** 剪辑片段（后端响应） */
+export interface EditPlanClip {
+  id: string;
+  plan_id: string;
+  clip_type: string; // main / intro / outro / overlay / background / b_roll 等
+  order: number;
+  asset_id: string;
+  text_content: string;
+  start_time: number;
+  duration: number;
+  transition_effect: string;
+  transition_duration: number;
+  playback_speed: number;
+  status: EditPlanClipStatus;
+  config: Record<string, unknown>;
+  created_at?: string;
+  updated_at?: string;
+}
+
+/** 创建片段请求 */
+export interface CreateEditPlanClipRequest {
+  clip_type: string;
+  order: number;
+  asset_id?: string;
+  text_content?: string;
+  start_time?: number;
+  duration?: number;
+  transition_effect?: string;
+  transition_duration?: number;
+  playback_speed?: number;
+  config?: Record<string, unknown>;
+}
+
+/** 更新片段请求 */
+export interface UpdateEditPlanClipRequest {
+  clip_type?: string;
+  order?: number;
+  asset_id?: string;
+  text_content?: string;
+  start_time?: number;
+  duration?: number;
+  transition_effect?: string;
+  transition_duration?: number;
+  playback_speed?: number;
+  config?: Record<string, unknown>;
+}
+
+/** 片段列表响应 */
+export interface EditPlanClipListResponse {
+  items: EditPlanClip[];
+  total: number;
+}
+
+/** 片段列表查询参数 */
+export interface EditPlanClipListParams {
+  status?: string;
+  skip?: number;
+  limit?: number;
+}
+
+/** 获取片段列表 */
+export async function getEditPlanClips(
+  planId: string,
+  params?: EditPlanClipListParams,
+): Promise<EditPlanClipListResponse> {
+  const response = await apiClient.get<EditPlanClipListResponse>(
+    `/edit-plans/${planId}/clips`,
+    { params },
+  );
+  return response.data;
+}
+
+/** 获取单个片段详情 */
+export async function getEditPlanClip(
+  planId: string,
+  clipId: string,
+): Promise<EditPlanClip> {
+  const response = await apiClient.get<EditPlanClip>(
+    `/edit-plans/${planId}/clips/${clipId}`,
+  );
+  return response.data;
+}
+
+/** 创建片段 */
+export async function createEditPlanClip(
+  planId: string,
+  data: CreateEditPlanClipRequest,
+): Promise<EditPlanClip> {
+  const response = await apiClient.post<EditPlanClip>(
+    `/edit-plans/${planId}/clips`,
+    data,
+  );
+  return response.data;
+}
+
+/** 更新片段 */
+export async function updateEditPlanClip(
+  planId: string,
+  clipId: string,
+  data: UpdateEditPlanClipRequest,
+): Promise<EditPlanClip> {
+  const response = await apiClient.put<EditPlanClip>(
+    `/edit-plans/${planId}/clips/${clipId}`,
+    data,
+  );
+  return response.data;
+}
+
+/** 删除片段 */
+export async function deleteEditPlanClip(
+  planId: string,
+  clipId: string,
+): Promise<void> {
+  await apiClient.delete(`/edit-plans/${planId}/clips/${clipId}`);
+}
+
+/* ============================================================
+ * 片段批量操作
+ * ============================================================ */
+
+/** 重排序条目 */
+export interface ClipReorderItem {
+  clip_id: string;
+  new_order: number;
+}
+
+/** 重排序响应 */
+export interface ClipReorderResponse {
+  success: boolean;
+  updated_count: number;
+  message: string;
+}
+
+/** 批量删除响应 */
+export interface ClipBatchDeleteResponse {
+  success: boolean;
+  deleted_count: number;
+  message: string;
+}
+
+/** 从素材批量创建响应 */
+export interface ClipsFromAssetsResponse {
+  success: boolean;
+  created_count: number;
+  message: string;
+  clip_ids: string[];
+}
+
+/** 片段重排序（拖拽排序后一次性提交） */
+export async function reorderEditPlanClips(
+  planId: string,
+  items: ClipReorderItem[],
+): Promise<ClipReorderResponse> {
+  const response = await apiClient.post<ClipReorderResponse>(
+    `/edit-plans/${planId}/clips/reorder`,
+    { items },
+  );
+  return response.data;
+}
+
+/** 批量删除片段 */
+export async function batchDeleteEditPlanClips(
+  planId: string,
+  clipIds: string[],
+): Promise<ClipBatchDeleteResponse> {
+  const response = await apiClient.post<ClipBatchDeleteResponse>(
+    `/edit-plans/${planId}/clips/batch-delete`,
+    { clip_ids: clipIds },
+  );
+  return response.data;
+}
+
+/** 从素材批量创建片段（追加到时间线末尾） */
+export async function createClipsFromAssets(
+  planId: string,
+  assetIds: string[],
+  clipType = "main",
+): Promise<ClipsFromAssetsResponse> {
+  const response = await apiClient.post<ClipsFromAssetsResponse>(
+    `/edit-plans/${planId}/clips/from-assets`,
+    { asset_ids: assetIds, clip_type: clipType },
+  );
+  return response.data;
+}
+
+/* ============================================================
+ * 复制计划
+ * ============================================================ */
+
+/** 复制计划请求 */
+export interface CopyEditPlanRequest {
+  name?: string;
+  project_id?: string;
+}
+
+/** 复制剪辑计划（含所有片段配置） */
+export async function copyEditPlan(
+  planId: string,
+  data?: CopyEditPlanRequest,
+): Promise<EditPlan> {
+  const response = await apiClient.post<EditPlan>(
+    `/edit-plans/${planId}/copy`,
+    data || {},
+  );
+  return response.data;
+}
+
 /**
  * 获取素材库列表 — 调用 GET /api/v1/assets?library_id=xxx
  * 将后端 AssetResponse 映射为前端 MediaAsset 类型
@@ -297,26 +685,22 @@ function inferMediaType(mimeType: string): "video" | "image" | "audio" {
 }
 
 function mapAssetToMediaAsset(asset: AssetItem): MediaAsset {
-  const meta = (asset.metadata || {}) as Record<string, unknown>;
-  const ext = asset as AssetItem & Record<string, unknown>;
+  // 优先取顶层 duration，其次从 metadata 回退
+  const metaDuration =
+    typeof asset.metadata?.duration === "number"
+      ? asset.metadata.duration
+      : undefined;
   return {
     id: asset.id,
     name: asset.name,
     type: inferMediaType(asset.mime_type || ""),
-    thumbnail_url:
-      typeof ext.thumbnail_url === "string" ? ext.thumbnail_url : undefined,
-    duration:
-      typeof ext.duration === "number"
-        ? ext.duration
-        : typeof meta.duration === "number"
-          ? (meta.duration as number)
-          : undefined,
+    thumbnail_url: asset.thumbnail_url,
+    duration: asset.duration ?? metaDuration,
     size: asset.file_size ?? undefined,
     tags: [],
     created_at: asset.created_at ?? "",
     quality_score: asset.quality_score ?? undefined,
-    classification_status: (asset.classification_status ??
-      undefined) as MediaAsset["classification_status"],
+    classification_status: asset.classification_status ?? undefined,
   };
 }
 
@@ -324,17 +708,27 @@ function mapAssetToMediaAsset(asset: AssetItem): MediaAsset {
  * 常量
  * ============================================================ */
 
-/** 转场效果选项 */
+/** 转场效果选项（14 种预设） */
 export const TRANSITION_OPTIONS: {
   value: TransitionEffect["type"];
   label: string;
+  icon: string;
 }[] = [
-  { value: "none", label: "无转场" },
-  { value: "fade", label: "淡入淡出" },
-  { value: "dissolve", label: "溶解" },
-  { value: "wipe", label: "擦除" },
-  { value: "zoom", label: "缩放" },
-  { value: "slide", label: "滑动" },
+  { value: "none", label: "无转场", icon: "⊘" },
+  { value: "cut", label: "硬切", icon: "✂" },
+  { value: "fade", label: "淡入淡出", icon: "◐" },
+  { value: "dissolve", label: "溶解", icon: "◈" },
+  { value: "zoom", label: "缩放", icon: "⊕" },
+  { value: "slide_left", label: "左滑", icon: "←" },
+  { value: "slide_right", label: "右滑", icon: "→" },
+  { value: "slide_up", label: "上滑", icon: "↑" },
+  { value: "slide_down", label: "下滑", icon: "↓" },
+  { value: "wipe_left", label: "左擦除", icon: "▸|" },
+  { value: "wipe_right", label: "右擦除", icon: "|◂" },
+  { value: "wipe_up", label: "上擦除", icon: "▴̄" },
+  { value: "wipe_down", label: "下擦除", icon: "▾̄" },
+  { value: "circlecrop", label: "圆形裁切", icon: "●" },
+  { value: "rectcrop", label: "矩形裁切", icon: "■" },
 ];
 
 /** 素材类型标签 */
@@ -360,6 +754,7 @@ export const PLAN_STATUS_LABELS: Record<EditPlanStatus, string> = {
   rendering: "渲染中",
   completed: "已完成",
   failed: "失败",
+  cancelled: "已取消",
 };
 
 /** 质量分筛选选项 */

apps/web/src/api/editingPlanner.ts

@@ -3,6 +3,15 @@
  * 对接后端 /api/v1/templates 路由
  */
 import apiClient from "./client";
+import type {
+  WatermarkConfig,
+  IntroOutroConfig,
+  PipConfig,
+  FilterConfig,
+  ChromaKeyConfig,
+  StickerConfig,
+  CoverConfig,
+} from "@/pages/editing-planner/types";
 
 /* ──────────── 类型定义 ──────────── */
 
@@ -72,6 +81,20 @@ export interface EditingTemplate {
   bgm_config: BgmConfig;
   estimated_duration: number;
   segments: TemplateSegment[];
+  /** 水印配置（后端就绪后启用） */
+  watermark_config?: WatermarkConfig;
+  /** 片头片尾配置（后端就绪后启用） */
+  intro_outro_config?: IntroOutroConfig;
+  /** 画中画配置 */
+  pip_config?: PipConfig;
+  /** 滤镜调色配置 */
+  filter_config?: FilterConfig;
+  /** 绿幕抠像配置 */
+  green_screen_config?: ChromaKeyConfig;
+  /** 贴纸配置 */
+  sticker_config?: StickerConfig;
+  /** 封面配置 */
+  cover_config?: CoverConfig;
   is_active?: boolean;
   created_at: string;
   updated_at: string;
@@ -95,6 +118,20 @@ export interface SaveTemplatePayload {
   bgm_config: BgmConfig;
   estimated_duration: number;
   segments: Omit<TemplateSegment, "id">[];
+  /** 水印配置（后端就绪后启用） */
+  watermark_config?: WatermarkConfig;
+  /** 片头片尾配置（后端就绪后启用） */
+  intro_outro_config?: IntroOutroConfig;
+  /** 画中画配置 */
+  pip_config?: PipConfig;
+  /** 滤镜调色配置 */
+  filter_config?: FilterConfig;
+  /** 绿幕抠像配置 */
+  green_screen_config?: ChromaKeyConfig;
+  /** 贴纸配置 */
+  sticker_config?: StickerConfig;
+  /** 封面配置 */
+  cover_config?: CoverConfig;
 }
 
 /** 使用模板生成请求体 */
@@ -102,11 +139,23 @@ export interface GenerateFromTemplatePayload {
   voiceover_duration: number;
 }
 
+/** 验证警告详情 */
+export interface ValidationWarningDetails {
+  /** 相关字段名 */
+  field?: string;
+  /** 期望值 */
+  expected?: string | number;
+  /** 实际值 */
+  actual?: string | number;
+  /** 建议值 */
+  suggested?: string | number;
+}
+
 /** 验证/生成响应 */
 export interface ValidateWarning {
   code: string;
   message: string;
-  details?: Record<string, unknown>;
+  details?: ValidationWarningDetails;
 }
 
 /** 使用模板生成响应 */

apps/web/src/api/products.ts

@@ -1,8 +1,14 @@
 /**
- * 成品相关 API
- * Phase 1 重构：去掉 projectId，成品直接归属用户
+ * 成品 / 视频相关 API
+ * 包含：列表查询、复核状态、批量下载
+ * 后端无 /products 路由，实际从 /generation/tasks 端点获取数据
  */
 import apiClient from "./client";
+import { getGenerationTaskResults } from "./editPlans";
+import type { GeneratedVideo } from "./editPlans";
+
+/** 复核状态 */
+export type ReviewStatus = "pending_review" | "approved" | "rejected";
 
 /** 成品条目 */
 export interface ProductItem {
@@ -14,33 +20,127 @@ export interface ProductItem {
   file_size?: number;
   resolution?: string;
   status: "processing" | "completed" | "failed";
+  /** 复核状态 */
+  review_status?: ReviewStatus;
+  /** 所属项目 ID */
+  project_id?: string;
+  /** 所属项目名称 */
+  project_name?: string;
   /** 查重率（百分比） */
   duplicate_rate?: number;
   created_at?: string;
   updated_at?: string;
 }
 
-/** 获取当前用户的所有成品 */
-export const getProducts = async (): Promise<ProductItem[]> => {
-  const response = await apiClient.get("/products");
-  return response.data.items || response.data || [];
+/** 列表查询参数 */
+export interface ProductListParams {
+  page?: number;
+  page_size?: number;
+  project_id?: string;
+  review_status?: ReviewStatus | "all";
+}
+
+/** 分页响应 */
+export interface ProductListResponse {
+  items: ProductItem[];
+  total: number;
+  page: number;
+  page_size: number;
+}
+
+/** 批量下载任务状态 */
+export interface BatchDownloadStatus {
+  job_id: string;
+  status: "processing" | "completed" | "failed";
+  /** 完成后返回的下载 URL */
+  download_url?: string;
+  /** 进度百分比 */
+  progress?: number;
+}
+
+/**
+ * 将 generation task 数据映射为 ProductItem 格式
+ */
+function mapTaskToProductItem(task: GeneratedVideo): ProductItem {
+  return {
+    id: task.id,
+    title: task.name || "未命名视频",
+    video_url: task.file_url,
+    thumbnail_url: task.thumbnail_url,
+    duration_seconds: task.duration,
+    file_size: task.file_size,
+    resolution:
+      task.width && task.height ? `${task.width}x${task.height}` : undefined,
+    status:
+      task.status === "completed"
+        ? "completed"
+        : task.status === "failed"
+          ? "failed"
+          : "processing",
+    review_status: task.review_status as ReviewStatus | undefined,
+    project_id: task.project_id,
+    created_at: task.created_at,
+    updated_at: task.updated_at,
+  };
+}
+
+/** 获取成品列表（支持分页和筛选）— 实际从 generation tasks 获取 */
+export const getProducts = async (
+  params?: ProductListParams,
+): Promise<ProductItem[]> => {
+  const response = await apiClient.get("/generation/tasks", { params });
+  const tasks = response.data.items || response.data || [];
+  return tasks.map(mapTaskToProductItem);
 };
 
-/** 获取单个成品详情 */
+/** 获取单个成品详情 — 通过 task ID 获取结果 */
 export const getProduct = async (productId: string): Promise<ProductItem> => {
-  const response = await apiClient.get(`/products/${productId}`);
-  return response.data;
+  const response = await apiClient.get(`/generation/tasks/${productId}`);
+  return mapTaskToProductItem(response.data);
 };
 
-/** 删除成品 */
+/** 删除成品 — 删除 generation task */
 export const deleteProduct = async (productId: string): Promise<void> => {
-  await apiClient.delete(`/products/${productId}`);
+  await apiClient.delete(`/generation/tasks/${productId}`);
 };
 
-/** 获取成品下载链接 */
+/** 获取成品下载链接 — 从 generation task results 获取 */
 export const getProductDownloadUrl = async (
   productId: string,
 ): Promise<{ url: string; expires_at: string }> => {
-  const response = await apiClient.get(`/products/${productId}/download-url`);
-  return response.data;
+  const videos = await getGenerationTaskResults(productId);
+  const video = videos[0];
+  if (!video?.download_url) throw new Error("下载链接不可用");
+  return { url: video.download_url, expires_at: "" };
+};
+
+/** 更新复核状态 — TODO: 后端暂无对应端点，暂存本地状态 */
+export const updateReviewStatus = async (
+  productId: string,
+  status: ReviewStatus,
+): Promise<ProductItem> => {
+  // 后端暂无 /generation/tasks/{id}/review 端点
+  // 暂时返回当前状态，后续可扩展
+  const product = await getProduct(productId);
+  return { ...product, review_status: status };
+};
+
+/** 发起批量下载 — TODO: 后端暂无对应端点 */
+export const batchDownload = async (
+  videoIds: string[],
+): Promise<{ job_id: string }> => {
+  // 后端暂无 /generation/tasks/batch-download 端点
+  // 暂时返回模拟 job_id，后续可扩展
+  console.warn("[batchDownload] 后端暂无批量下载端点", videoIds);
+  return { job_id: `mock-${Date.now()}` };
+};
+
+/** 查询批量下载状态 — TODO: 后端暂无对应端点 */
+export const getBatchDownloadStatus = async (
+  jobId: string,
+): Promise<BatchDownloadStatus> => {
+  // 后端暂无 /generation/tasks/batch-download/{jobId} 端点
+  // 暂时返回模拟状态，后续可扩展
+  console.warn("[getBatchDownloadStatus] 后端暂无批量下载状态端点", jobId);
+  return { job_id: jobId, status: "processing", progress: 0 };
 };

apps/web/src/api/tasks.ts

@@ -1,31 +1,67 @@
 /**
  * 任务相关 API
- * 对接后端方案 A 扩展后的端点（PR #109）
- * - POST /api/v1/generation/tasks — 创建生成任务（template_id + asset_ids 细粒度模式）
- * - GET  /api/v1/tasks              — 用户级任务列表（跨 project）
- * - POST /api/v1/tasks/{task_id}/retry — 简化重试
+ * 对接后端任务中心 API：
+ * - POST /api/v1/generation/tasks — 创建生成任务
+ * - GET  /api/v1/tasks              — 用户级任务列表（支持分页/筛选）
+ * - GET  /api/v1/tasks/{task_id}    — 任务详情（含 error_info）
+ * - POST /api/v1/tasks/{task_id}/retry — 重试失败任务
  */
 import apiClient from "./client";
 
 /* ──────────── 类型定义 ──────────── */
 
+/** 任务状态 */
+export type TaskStatus =
+  "pending" | "waiting" | "running" | "completed" | "failed" | "cancelled";
+
+/** 任务类型 */
+export type TaskType = "ingest" | "generation" | string;
+
+/** 错误详情 */
+export interface TaskErrorInfo {
+  error_type: string;
+  error_message: string;
+  failed_step: string;
+  stack_trace?: string;
+}
+
 /** 任务条目（对应用户级 UserTaskResponse） */
 export interface TaskItem {
   id: string;
-  task_type: "ingest" | "generation" | string;
+  task_type: TaskType;
   project_id: string;
-  template_id: string;
-  status: string;
+  template_id?: string;
+  status: TaskStatus;
   progress: number;
   current_step: string;
   error_message: string;
   user_message: string;
   retryable: boolean;
   source_id: string;
+  /** 错误详情（失败任务） */
+  error_info?: TaskErrorInfo;
+  /** 耗时（秒） */
+  duration_seconds?: number;
   created_at?: string | null;
   updated_at?: string | null;
 }
 
+/** 任务列表查询参数 */
+export interface TaskListParams {
+  page?: number;
+  page_size?: number;
+  status?: TaskStatus | "all";
+  task_type?: TaskType | "all";
+}
+
+/** 任务列表分页响应 */
+export interface TaskListResponse {
+  items: TaskItem[];
+  total: number;
+  page: number;
+  page_size: number;
+}
+
 /** 创建生成任务请求参数 */
 export interface CreateGenerationTaskRequest {
   template_id: string;
@@ -64,13 +100,23 @@ export const createGenerationTask = async (
   return data;
 };
 
-/** 获取当前用户的所有任务（跨 project） */
-export const getUserTasks = async (): Promise<TaskItem[]> => {
-  const { data } = await apiClient.get("/tasks");
-  return data.items || [];
+/** 获取任务列表（支持分页和筛选） */
+export const getTasks = async (
+  params?: TaskListParams,
+): Promise<TaskListResponse> => {
+  const { data } = await apiClient.get<TaskListResponse>("/tasks", {
+    params,
+  });
+  return data;
 };
 
-/** 获取单个任务详情（用于轮询进度） */
+/** 获取当前用户的所有任务（兼容旧接口，跨 project） */
+export const getUserTasks = async (): Promise<TaskItem[]> => {
+  const { data } = await apiClient.get("/tasks");
+  return data.items || data || [];
+};
+
+/** 获取单个任务详情（含 error_info） */
 export const getTask = async (taskId: string): Promise<TaskItem> => {
   const { data } = await apiClient.get(`/tasks/${taskId}`);
   return data;

apps/web/src/api/templates.ts

@@ -1,26 +1,117 @@
 /**
  * 模板相关 API
- * Phase 1 新增：全局模板库
+ * 对接后端模板管理接口：
+ * - GET  /api/v1/templates              — 模板列表（分页/筛选）
+ * - GET  /api/v1/templates/{id}         — 模板详情
+ * - POST /api/v1/templates/{id}/copy    — 复制模板
+ * - POST /api/v1/templates/{id}/generate — 从模板生成剪辑计划
+ * - POST /api/v1/templates/{id}/toggle-favorite — 收藏/取消收藏
  */
 import apiClient from "./client";
+import type { TitleConfig, SubtitleConfig, BgmConfig } from "./editingPlanner";
+import type { EditPlanConfig } from "./editPlans";
 
-/** 模板条目 */
+/* ──────────── 类型定义 ──────────── */
+
+/** 模板条目（后端 TemplateResponse） */
 export interface TemplateItem {
   id: string;
+  user_id?: string;
   name: string;
-  description: string;
+  description?: string;
+  mode?: string;
   category: string;
-  target_duration: number;
-  clip_count: number;
+  tags?: string[];
+  /** 预估时长（后端字段名 estimated_duration） */
+  estimated_duration?: number;
+  /** @deprecated 后端已改名为 estimated_duration，保留兼容 */
+  target_duration?: number;
+  clip_count?: number;
+  /** 使用次数 */
+  usage_count?: number;
   thumbnail_url?: string;
   preview_url?: string;
-  is_active: boolean;
+  is_active?: boolean;
   is_favorite?: boolean;
+  /** 素材规则（片段配置） */
+  segments?: TemplateSegment[];
+  /** 字幕样式 */
+  subtitle_config?: SubtitleConfig;
+  /** BGM 配置 */
+  bgm_config?: BgmConfig;
+  /** 标题配置 */
+  title_config?: TitleConfig;
+  /** 视频比例 */
+  aspect_ratio?: string;
   created_at?: string;
+  updated_at?: string;
 }
 
-/** 获取全局模板列表 */
-export const getTemplates = async (): Promise<TemplateItem[]> => {
+/** 模板片段（素材规则） */
+export interface TemplateSegment {
+  id?: string;
+  segment_order: number;
+  duration_min: number;
+  duration_max: number;
+  material_type: string | null;
+  description?: string;
+}
+
+/** 模板列表查询参数 */
+export interface TemplateListParams {
+  page?: number;
+  page_size?: number;
+  category?: string;
+  tags?: string;
+  keyword?: string;
+  /** 时长筛选（秒）：short < 30, medium 30-120, long > 120 */
+  duration_range?: "short" | "medium" | "long";
+}
+
+/** 模板列表分页响应 */
+export interface TemplateListResponse {
+  items: TemplateItem[];
+  total: number;
+  page: number;
+  page_size: number;
+}
+
+/** 从模板生成剪辑计划请求 */
+export interface GenerateFromTemplateRequest {
+  asset_ids?: string[];
+  name?: string;
+  config?: EditPlanConfig;
+}
+
+/** 从模板生成剪辑计划响应 */
+export interface GenerateFromTemplateResponse {
+  plan_id: string;
+  template_id: string;
+  status: string;
+  name: string;
+}
+
+/** 复制模板响应 */
+export interface CopyTemplateResponse {
+  id: string;
+  name: string;
+  source_template_id: string;
+}
+
+/* ──────────── API 函数 ──────────── */
+
+/** 获取模板列表（支持分页和筛选） */
+export const getTemplates = async (
+  params?: TemplateListParams,
+): Promise<TemplateListResponse> => {
+  const { data } = await apiClient.get<TemplateListResponse>("/templates", {
+    params,
+  });
+  return data;
+};
+
+/** 获取模板列表（兼容旧接口，返回数组） */
+export const getTemplatesList = async (): Promise<TemplateItem[]> => {
   const response = await apiClient.get("/templates");
   return response.data.items || response.data || [];
 };
@@ -42,3 +133,46 @@ export const toggleFavoriteTemplate = async (
   );
   return response.data;
 };
+
+/** 复制模板（创建副本到我的模板） */
+export const copyTemplate = async (
+  templateId: string,
+): Promise<CopyTemplateResponse> => {
+  const response = await apiClient.post<CopyTemplateResponse>(
+    `/templates/${templateId}/copy`,
+  );
+  return response.data;
+};
+
+/** 从模板生成剪辑计划 */
+export const generateFromTemplate = async (
+  templateId: string,
+  data?: GenerateFromTemplateRequest,
+): Promise<GenerateFromTemplateResponse> => {
+  const response = await apiClient.post<GenerateFromTemplateResponse>(
+    `/templates/${templateId}/generate`,
+    data,
+  );
+  return response.data;
+};
+
+/* ──────────── 常量 ──────────── */
+
+/** 模板分类选项 */
+export const TEMPLATE_CATEGORY_OPTIONS = [
+  { value: "", label: "全部分类" },
+  { value: "口播", label: "口播" },
+  { value: "种草", label: "种草" },
+  { value: "产品", label: "产品" },
+  { value: "品牌", label: "品牌" },
+  { value: "混剪", label: "混剪" },
+  { value: "Vlog", label: "Vlog" },
+];
+
+/** 时长筛选选项 */
+export const TEMPLATE_DURATION_OPTIONS = [
+  { value: "", label: "全部时长" },
+  { value: "short", label: "30秒以内" },
+  { value: "medium", label: "30秒-2分钟" },
+  { value: "long", label: "2分钟以上" },
+];

apps/web/src/api/tts.ts

@@ -8,6 +8,18 @@ import apiClient from "./client";
 
 /* ── 类型定义 ──────────────────────────────────── */
 
+/** TTS 元数据（合成时附带的扩展信息） */
+export interface TTSMetadata {
+  /** 语音时长（秒） */
+  duration?: number;
+  /** 采样率（Hz） */
+  sample_rate?: number;
+  /** 语言 */
+  language?: string;
+  /** 其他扩展字段 */
+  [key: string]: unknown;
+}
+
 /** TTS 合成请求参数 */
 export interface TTSSynthesizeRequest {
   text: string;
@@ -18,7 +30,7 @@ export interface TTSSynthesizeRequest {
   voice_model?: string;
   voice_clone_profile_id?: string;
   format?: string;
-  metadata?: Record<string, unknown>;
+  metadata?: TTSMetadata;
 }
 
 /** TTS 合成创建响应 */
@@ -49,7 +61,7 @@ export interface TTSJob {
   error_message: string | null;
   retry_count: number;
   max_retries: number;
-  metadata_: Record<string, unknown> | null;
+  metadata_: TTSMetadata | null;
   created_at: string;
   updated_at: string;
 }
@@ -140,3 +152,52 @@ export const saveTtsToLibrary = async (
 export const deleteTTSJob = async (jobId: string): Promise<void> => {
   await apiClient.delete(`/tts/jobs/${jobId}`);
 };
+
+/* ── 音色列表 ──────────────────────────────────── */
+
+/** TTS 音色 */
+export interface TTSVoice {
+  id: string;
+  name: string;
+  /** 音色分类标签：male/female/young/service/news/emotion */
+  category?: string;
+  /** 语言 */
+  language?: string;
+  /** 试听 URL */
+  preview_url?: string;
+  /** 描述 */
+  description?: string;
+}
+
+/** 获取 TTS 音色列表 */
+export const getTtsVoices = async (): Promise<TTSVoice[]> => {
+  const response = await apiClient.get<TTSVoice[]>("/tts/voices");
+  return response.data;
+};
+
+/* ── TTS 试听 ──────────────────────────────────── */
+
+/** TTS 试听请求参数 */
+export interface TTSPreviewRequest {
+  text: string;
+  voice_id: string;
+  speed?: number;
+  pitch?: number;
+}
+
+/** TTS 试听响应 */
+export interface TTSPreviewResponse {
+  audio_url: string;
+  duration?: number;
+}
+
+/** TTS 试听 */
+export const previewTts = async (
+  data: TTSPreviewRequest,
+): Promise<TTSPreviewResponse> => {
+  const response = await apiClient.post<TTSPreviewResponse>(
+    "/tts/preview",
+    data,
+  );
+  return response.data;
+};

apps/web/src/api/voiceClone.ts

@@ -36,6 +36,18 @@ export interface CreateVoiceCloneRequest {
 
 /* ── 后端 API 类型 ────────────────────────────────────── */
 
+/** 音色克隆元数据（克隆时附带的扩展信息） */
+export interface VoiceCloneMetadata {
+  /** 语音时长（秒） */
+  duration?: number;
+  /** 采样率（Hz） */
+  sample_rate?: number;
+  /** 音色 ID（克隆完成后分配） */
+  voice_id?: string;
+  /** 其他扩展字段 */
+  [key: string]: unknown;
+}
+
 /** 后端克隆档案响应 */
 export interface VoiceCloneProfile {
   id: string;
@@ -51,7 +63,7 @@ export interface VoiceCloneProfile {
   error_message: string | null;
   retry_count: number;
   max_retries: number;
-  metadata_: Record<string, unknown> | null;
+  metadata_: VoiceCloneMetadata | null;
   created_at: string;
   updated_at: string;
 }
@@ -80,7 +92,7 @@ export interface CreateVoiceCloneRequestFull {
   language?: string;
   gender?: string;
   max_retries?: number;
-  metadata_?: Record<string, unknown>;
+  metadata_?: VoiceCloneMetadata;
 }
 
 /* ── 辅助函数 ─────────────────────────────────────────── */

apps/web/src/components/ui/ui.css

@@ -384,7 +384,6 @@
   border-bottom: 1px solid var(--border-light) !important;
 }
 
-
 /* ============================================================
    响应式
    ============================================================ */
@@ -409,7 +408,6 @@
   .xx-modal .ant-modal-header {
     padding: var(--space-md) !important;
   }
-
 }
 
 @media (max-width: 480px) {
@@ -423,7 +421,6 @@
   }
 }
 
-
 /* ── xx-card antd 子元素覆盖样式（从 Admin.css 迁移） ── */
 /* AdminComingSoon 等页面使用 <Card className="xx-card"> 时需要 */
 /* .xx-card 基础样式和 :hover 已在 global.css 中定义（V21 设计系统） */

apps/web/src/config/navigation.ts

@@ -17,6 +17,7 @@ import {
   ScanOutlined,
   ControlOutlined,
   CrownOutlined,
+  UnorderedListOutlined,
 } from "@ant-design/icons";
 
 /** 导航项类型 */
@@ -80,6 +81,12 @@ export const NAV_ITEMS: NavItem[] = [
     path: "/app/my-templates",
     icon: React.createElement(FolderOutlined),
   },
+  {
+    key: "edit-plans",
+    label: "剪辑计划",
+    path: "/app/edit-plans",
+    icon: React.createElement(UnorderedListOutlined),
+  },
   {
     key: "generate",
     label: "一键生成",
@@ -104,6 +111,12 @@ export const NAV_ITEMS: NavItem[] = [
     path: "/app/duplication",
     icon: React.createElement(ScanOutlined),
   },
+  {
+    key: "tasks",
+    label: "任务中心",
+    path: "/app/tasks",
+    icon: React.createElement(UnorderedListOutlined),
+  },
 ];
 
 /** 侧边栏导航分组（Sidebar 分组列表使用） */
@@ -129,6 +142,12 @@ export const NAV_GROUPS: NavGroup[] = [
         path: "/app/editing-planner",
         icon: React.createElement(EditOutlined),
       },
+      {
+        key: "edit-plans",
+        label: "剪辑计划",
+        path: "/app/edit-plans",
+        icon: React.createElement(UnorderedListOutlined),
+      },
     ],
   },
   {
@@ -181,6 +200,12 @@ export const NAV_GROUPS: NavGroup[] = [
         path: "/app/history",
         icon: React.createElement(HistoryOutlined),
       },
+      {
+        key: "tasks",
+        label: "任务中心",
+        path: "/app/tasks",
+        icon: React.createElement(UnorderedListOutlined),
+      },
       {
         key: "duplication",
         label: "查重",

apps/web/src/main.tsx

@@ -6,7 +6,7 @@ import React from "react";
 import ReactDOM from "react-dom/client";
 import { RouterProvider } from "react-router-dom";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { ConfigProvider } from "antd";
+import { ConfigProvider, App as AntApp } from "antd";
 import zhCN from "antd/locale/zh_CN";
 import router from "./router";
 import "./index.css";
@@ -91,7 +91,9 @@ ReactDOM.createRoot(document.getElementById("root")!).render(
   <React.StrictMode>
     <QueryClientProvider client={queryClient}>
       <ConfigProvider locale={zhCN} theme={theme}>
-        <RouterProvider router={router} />
+        <AntApp>
+          <RouterProvider router={router} />
+        </AntApp>
       </ConfigProvider>
     </QueryClientProvider>
   </React.StrictMode>,

apps/web/src/pages/assets/AssetLibrary.tsx

@@ -4,7 +4,17 @@
  * 使用 useQuery 对接后端真实 API（api/assets.ts）
  */
 import React, { useMemo, useState } from "react";
-import { Upload, Modal as AntModal, message, Popconfirm } from "antd";
+import {
+  Upload,
+  Modal as AntModal,
+  message,
+  Popconfirm,
+  Drawer,
+  Tag,
+  Input as AntInput,
+  Radio,
+  Select as AntSelect,
+} from "antd";
 import {
   PlusOutlined,
   SearchOutlined,
@@ -17,6 +27,11 @@ import {
   ExperimentOutlined,
   LoadingOutlined,
   ExclamationCircleOutlined,
+  TagsOutlined,
+  FolderOutlined,
+  ThunderboltOutlined,
+  CheckCircleOutlined,
+  CloseCircleOutlined,
 } from "@ant-design/icons";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import {
@@ -27,8 +42,13 @@ import {
   deleteAsset,
   uploadAssetDirect,
   getAssetDiagnosis,
+  batchDeleteAssets,
+  batchTagAssets,
+  batchClassifyAssets,
+  batchMarkAssets,
   type AssetLibraryItem,
   type AssetItem as ApiAssetItem,
+  type BatchOperationResult,
 } from "@/api/assets";
 import { Button, Input, Select } from "@/components/ui";
 import "./assets.css";
@@ -407,6 +427,33 @@ const AssetLibrary: React.FC = () => {
   /* 诊断中状态 — 记录正在诊断的素材 ID */
   const [diagnosingId, setDiagnosingId] = useState<string | null>(null);
 
+  /* ── 批量操作弹窗状态 ── */
+  const [tagModalOpen, setTagModalOpen] = useState(false);
+  const [classifyModalOpen, setClassifyModalOpen] = useState(false);
+  const [markModalOpen, setMarkModalOpen] = useState(false);
+  const [resultDrawerOpen, setResultDrawerOpen] = useState(false);
+
+  /* 批量打标签 */
+  const [batchTagInput, setBatchTagInput] = useState("");
+  const [batchTags, setBatchTags] = useState<string[]>([]);
+  const [tagMode, setTagMode] = useState<"add" | "replace">("add");
+
+  /* 批量改分类 */
+  const [batchCategory, setBatchCategory] = useState("");
+
+  /* 批量智能标记 */
+  const [batchSmartView, setBatchSmartView] = useState<
+    "recommended" | "caution" | "high_risk"
+  >("recommended");
+
+  /* 操作结果 */
+  const [operationResult, setOperationResult] =
+    useState<BatchOperationResult | null>(null);
+  const [operationTitle, setOperationTitle] = useState("");
+
+  /* 批量操作 loading */
+  const [batchLoading, setBatchLoading] = useState(false);
+
   /* 派生数据 */
   const filteredAssets = useMemo(() => {
     let list = assets;
@@ -563,19 +610,152 @@ const AssetLibrary: React.FC = () => {
 
   const handleBatchDelete = async () => {
     const ids = Array.from(selectedIds);
-    let successCount = 0;
-    for (const id of ids) {
-      try {
-        await deleteAsset(id);
-        successCount++;
-      } catch {
-        // 忽略单个失败
+    setBatchLoading(true);
+    try {
+      const result = await batchDeleteAssets(ids);
+      setOperationResult(result);
+      setOperationTitle("批量删除");
+      setResultDrawerOpen(true);
+      queryClient.invalidateQueries({ queryKey: ["assets"] });
+      queryClient.invalidateQueries({ queryKey: ["asset-libraries"] });
+      setSelectedIds(new Set());
+      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);
     }
-    queryClient.invalidateQueries({ queryKey: ["assets"] });
-    queryClient.invalidateQueries({ queryKey: ["asset-libraries"] });
-    setSelectedIds(new Set());
-    message.success(`已删除 ${successCount}/${ids.length} 个素材`);
+  };
+
+  /* 批量打标签 */
+  const handleBatchTag = 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,
+      });
+      setOperationResult(result);
+      setOperationTitle("批量打标签");
+      setResultDrawerOpen(true);
+      setTagModalOpen(false);
+      setBatchTags([]);
+      setBatchTagInput("");
+      setTagMode("add");
+      queryClient.invalidateQueries({ queryKey: ["assets"] });
+      setSelectedIds(new Set());
+      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);
+    }
+  };
+
+  /* 批量改分类 */
+  const handleBatchClassify = async () => {
+    if (!batchCategory) {
+      message.warning("请选择分类");
+      return;
+    }
+    const ids = Array.from(selectedIds);
+    setBatchLoading(true);
+    try {
+      const result = await batchClassifyAssets({
+        asset_ids: ids,
+        category: batchCategory,
+      });
+      setOperationResult(result);
+      setOperationTitle("批量改分类");
+      setResultDrawerOpen(true);
+      setClassifyModalOpen(false);
+      setBatchCategory("");
+      queryClient.invalidateQueries({ queryKey: ["assets"] });
+      setSelectedIds(new Set());
+      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);
+    }
+  };
+
+  /* 批量智能标记 */
+  const handleBatchMark = async () => {
+    const ids = Array.from(selectedIds);
+    setBatchLoading(true);
+    try {
+      const result = await batchMarkAssets({
+        asset_ids: ids,
+        smart_view: batchSmartView,
+      });
+      setOperationResult(result);
+      setOperationTitle("批量智能标记");
+      setResultDrawerOpen(true);
+      setMarkModalOpen(false);
+      queryClient.invalidateQueries({ queryKey: ["assets"] });
+      setSelectedIds(new Set());
+      const labelMap = {
+        recommended: "推荐",
+        caution: "慎用",
+        high_risk: "高风险",
+      };
+      if (result.failure_count === 0) {
+        message.success(
+          `成功将 ${result.success_count} 个素材标记为「${labelMap[batchSmartView]}」`,
+        );
+      } else {
+        message.warning(
+          `智能标记完成：成功 ${result.success_count} 个，失败 ${result.failure_count} 个`,
+        );
+      }
+    } catch {
+      message.error("批量智能标记失败，请重试");
+    } finally {
+      setBatchLoading(false);
+    }
+  };
+
+  /* 标签输入处理 */
+  const handleTagInputKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === "Enter" && batchTagInput.trim()) {
+      e.preventDefault();
+      const tag = batchTagInput.trim();
+      if (!batchTags.includes(tag)) {
+        setBatchTags([...batchTags, tag]);
+      }
+      setBatchTagInput("");
+    }
+  };
+
+  const removeBatchTag = (tag: string) => {
+    setBatchTags(batchTags.filter((t) => t !== tag));
   };
 
   // ── Loading 状态 ──
@@ -769,6 +949,30 @@ const AssetLibrary: React.FC = () => {
               <Button buttonType="ghost" buttonSize="sm" onClick={deselectAll}>
                 取消选择
               </Button>
+              <Button
+                buttonType="ghost"
+                buttonSize="sm"
+                icon={<TagsOutlined />}
+                onClick={() => setTagModalOpen(true)}
+              >
+                打标签
+              </Button>
+              <Button
+                buttonType="ghost"
+                buttonSize="sm"
+                icon={<FolderOutlined />}
+                onClick={() => setClassifyModalOpen(true)}
+              >
+                改分类
+              </Button>
+              <Button
+                buttonType="ghost"
+                buttonSize="sm"
+                icon={<ThunderboltOutlined />}
+                onClick={() => setMarkModalOpen(true)}
+              >
+                智能标记
+              </Button>
               <Popconfirm
                 title={`确定删除 ${selectedIds.size} 个素材？`}
                 onConfirm={handleBatchDelete}
@@ -898,6 +1102,207 @@ const AssetLibrary: React.FC = () => {
           </div>
         )}
       </AntModal>
+
+      {/* ─── 批量打标签弹窗 ─── */}
+      <AntModal
+        title={`批量打标签（${selectedIds.size} 个素材）`}
+        open={tagModalOpen}
+        onCancel={() => {
+          setTagModalOpen(false);
+          setBatchTags([]);
+          setBatchTagInput("");
+        }}
+        onOk={handleBatchTag}
+        confirmLoading={batchLoading}
+        okText="确认打标签"
+        cancelText="取消"
+      >
+        <div className="xx-batch-tag-modal">
+          <div className="xx-batch-tag-mode">
+            <span className="xx-batch-tag-mode-label">模式：</span>
+            <Radio.Group
+              value={tagMode}
+              onChange={(e) => setTagMode(e.target.value)}
+            >
+              <Radio value="add">追加标签</Radio>
+              <Radio value="replace">替换全部标签</Radio>
+            </Radio.Group>
+          </div>
+          <div className="xx-batch-tag-input-row">
+            <AntInput
+              placeholder="输入标签后按 Enter 添加"
+              value={batchTagInput}
+              onChange={(e) => setBatchTagInput(e.target.value)}
+              onKeyDown={handleTagInputKeyDown}
+              style={{ flex: 1 }}
+            />
+          </div>
+          {batchTags.length > 0 && (
+            <div className="xx-batch-tag-list">
+              {batchTags.map((tag) => (
+                <Tag
+                  key={tag}
+                  closable
+                  onClose={() => removeBatchTag(tag)}
+                  color="blue"
+                >
+                  {tag}
+                </Tag>
+              ))}
+            </div>
+          )}
+          {tagMode === "replace" && batchTags.length > 0 && (
+            <div className="xx-batch-tag-warning">
+              <ExclamationCircleOutlined /> 替换模式将清除素材原有全部标签
+            </div>
+          )}
+        </div>
+      </AntModal>
+
+      {/* ─── 批量改分类弹窗 ─── */}
+      <AntModal
+        title={`批量改分类（${selectedIds.size} 个素材）`}
+        open={classifyModalOpen}
+        onCancel={() => {
+          setClassifyModalOpen(false);
+          setBatchCategory("");
+        }}
+        onOk={handleBatchClassify}
+        confirmLoading={batchLoading}
+        okText="确认修改"
+        cancelText="取消"
+      >
+        <div className="xx-batch-classify-modal">
+          <p className="xx-batch-classify-hint">
+            将选中的 {selectedIds.size} 个素材统一修改为以下分类：
+          </p>
+          <AntSelect
+            value={batchCategory || undefined}
+            onChange={(v) => setBatchCategory(v)}
+            placeholder="请选择分类"
+            style={{ width: "100%" }}
+            options={[
+              { value: "person", label: "人物" },
+              { value: "scenic", label: "风景" },
+              { value: "product", label: "产品" },
+              { value: "food", label: "美食" },
+              { value: "animal", label: "动物" },
+              { value: "architecture", label: "建筑" },
+              { value: "other", label: "其他" },
+            ]}
+          />
+        </div>
+      </AntModal>
+
+      {/* ─── 批量智能标记弹窗 ─── */}
+      <AntModal
+        title={`批量智能标记（${selectedIds.size} 个素材）`}
+        open={markModalOpen}
+        onCancel={() => setMarkModalOpen(false)}
+        onOk={handleBatchMark}
+        confirmLoading={batchLoading}
+        okText="确认标记"
+        cancelText="取消"
+      >
+        <div className="xx-batch-mark-modal">
+          <p className="xx-batch-mark-hint">
+            将选中的 {selectedIds.size} 个素材标记为：
+          </p>
+          <Radio.Group
+            value={batchSmartView}
+            onChange={(e) => setBatchSmartView(e.target.value)}
+            className="xx-batch-mark-options"
+          >
+            <div className="xx-batch-mark-option">
+              <Radio value="recommended">
+                <Tag color="success">推荐</Tag>
+                <span className="xx-batch-mark-desc">
+                  质量优良，可直接用于生产
+                </span>
+              </Radio>
+            </div>
+            <div className="xx-batch-mark-option">
+              <Radio value="caution">
+                <Tag color="warning">慎用</Tag>
+                <span className="xx-batch-mark-desc">
+                  存在一定问题，需人工审核后再使用
+                </span>
+              </Radio>
+            </div>
+            <div className="xx-batch-mark-option">
+              <Radio value="high_risk">
+                <Tag color="error">高风险</Tag>
+                <span className="xx-batch-mark-desc">
+                  存在严重问题，不建议使用
+                </span>
+              </Radio>
+            </div>
+          </Radio.Group>
+        </div>
+      </AntModal>
+
+      {/* ─── 操作结果 Drawer ─── */}
+      <Drawer
+        title={`${operationTitle} — 操作结果`}
+        open={resultDrawerOpen}
+        onClose={() => {
+          setResultDrawerOpen(false);
+          setOperationResult(null);
+        }}
+        width={420}
+      >
+        {operationResult && (
+          <div className="xx-batch-result">
+            <div className="xx-batch-result-summary">
+              <div className="xx-batch-result-stat">
+                <span className="xx-batch-result-total">
+                  总计 {operationResult.total} 个
+                </span>
+              </div>
+              <div className="xx-batch-result-stat success">
+                <CheckCircleOutlined />
+                <span>成功 {operationResult.success_count} 个</span>
+              </div>
+              {operationResult.failure_count > 0 && (
+                <div className="xx-batch-result-stat fail">
+                  <CloseCircleOutlined />
+                  <span>失败 {operationResult.failure_count} 个</span>
+                </div>
+              )}
+            </div>
+
+            {operationResult.succeeded.length > 0 && (
+              <div className="xx-batch-result-section">
+                <h4 className="xx-batch-result-section-title success">
+                  <CheckCircleOutlined /> 成功列表
+                </h4>
+                <div className="xx-batch-result-ids">
+                  {operationResult.succeeded.map((id) => (
+                    <div key={id} className="xx-batch-result-id">
+                      {id}
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+
+            {operationResult.failed.length > 0 && (
+              <div className="xx-batch-result-section">
+                <h4 className="xx-batch-result-section-title fail">
+                  <CloseCircleOutlined /> 失败列表
+                </h4>
+                <div className="xx-batch-result-ids">
+                  {operationResult.failed.map((id) => (
+                    <div key={id} className="xx-batch-result-id fail">
+                      {id}
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+          </div>
+        )}
+      </Drawer>
     </div>
   );
 };

apps/web/src/pages/assets/assets.css

@@ -653,3 +653,175 @@
   font-size: 13px;
   color: var(--text-secondary, #6b7280);
 }
+
+/* ─── 批量打标签弹窗 ─── */
+
+.xx-batch-tag-modal {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.xx-batch-tag-mode {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.xx-batch-tag-mode-label {
+  font-size: 14px;
+  color: var(--text-primary, #111827);
+  font-weight: 500;
+}
+
+.xx-batch-tag-input-row {
+  display: flex;
+  gap: 8px;
+}
+
+.xx-batch-tag-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.xx-batch-tag-warning {
+  padding: 10px 12px;
+  background: #fff7ed;
+  border: 1px solid #fed7aa;
+  border-radius: var(--radius-md, 8px);
+  color: #c2410c;
+  font-size: 13px;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+/* ─── 批量改分类弹窗 ─── */
+
+.xx-batch-classify-modal {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.xx-batch-classify-hint {
+  font-size: 14px;
+  color: var(--text-secondary, #6b7280);
+  margin: 0;
+}
+
+/* ─── 批量智能标记弹窗 ─── */
+
+.xx-batch-mark-modal {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.xx-batch-mark-hint {
+  font-size: 14px;
+  color: var(--text-secondary, #6b7280);
+  margin: 0;
+}
+
+.xx-batch-mark-options {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.xx-batch-mark-option {
+  display: flex;
+  flex-direction: column;
+}
+
+.xx-batch-mark-desc {
+  margin-left: 8px;
+  font-size: 13px;
+  color: var(--text-secondary, #6b7280);
+}
+
+/* ─── 操作结果 Drawer ─── */
+
+.xx-batch-result {
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+
+.xx-batch-result-summary {
+  display: flex;
+  gap: 16px;
+  padding: 16px;
+  background: var(--bg-secondary, #f9fafb);
+  border-radius: var(--radius-md, 8px);
+}
+
+.xx-batch-result-stat {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 14px;
+  color: var(--text-primary, #111827);
+}
+
+.xx-batch-result-stat.success {
+  color: #059669;
+}
+
+.xx-batch-result-stat.fail {
+  color: #dc2626;
+}
+
+.xx-batch-result-total {
+  font-weight: 600;
+}
+
+.xx-batch-result-section {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.xx-batch-result-section-title {
+  font-size: 14px;
+  font-weight: 600;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin: 0;
+}
+
+.xx-batch-result-section-title.success {
+  color: #059669;
+}
+
+.xx-batch-result-section-title.fail {
+  color: #dc2626;
+}
+
+.xx-batch-result-ids {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  max-height: 300px;
+  overflow-y: auto;
+}
+
+.xx-batch-result-id {
+  padding: 6px 10px;
+  background: var(--bg-surface, #fff);
+  border: 1px solid var(--border-primary, #e5e7eb);
+  border-radius: var(--radius-sm, 4px);
+  font-size: 12px;
+  font-family: monospace;
+  color: var(--text-secondary, #6b7280);
+  word-break: break-all;
+}
+
+.xx-batch-result-id.fail {
+  border-color: #fecaca;
+  background: #fef2f2;
+  color: #dc2626;
+}

apps/web/src/pages/duplication/DuplicationDetail.tsx

@@ -33,8 +33,9 @@ const formatSize = (bytes: number) => {
 /** 格式化时长 */
 const formatDuration = (seconds?: number) => {
   if (!seconds) return "-";
-  const m = Math.floor(seconds / 60);
-  const s = seconds % 60;
+  const totalSec = Math.round(seconds);
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
   return m > 0 ? `${m}分${s}秒` : `${s}秒`;
 };
 

apps/web/src/pages/duplication/DuplicationResults.tsx

@@ -59,8 +59,9 @@ const formatSize = (bytes: number) => {
 /** 格式化时长 */
 const formatDuration = (seconds?: number) => {
   if (!seconds) return "-";
-  const m = Math.floor(seconds / 60);
-  const s = seconds % 60;
+  const totalSec = Math.round(seconds);
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
   return m > 0 ? `${m}分${s}秒` : `${s}秒`;
 };
 

apps/web/src/pages/edit-plans/EditPlans.tsx

@@ -0,0 +1,538 @@
+/**
+ * 剪辑计划管理页面
+ * 展示用户的所有剪辑计划，支持状态筛选、模板筛选、分页、一键重新生成
+ */
+import { useState, useCallback } from "react";
+import { useNavigate } from "react-router-dom";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import {
+  Table,
+  Tabs,
+  Select,
+  Tag,
+  Button,
+  message,
+  Popconfirm,
+  Tooltip,
+} from "antd";
+import {
+  CheckCircleOutlined,
+  ClockCircleOutlined,
+  SyncOutlined,
+  CloseCircleOutlined,
+  EditOutlined,
+  DeleteOutlined,
+  FileTextOutlined,
+  ThunderboltOutlined,
+  CopyOutlined,
+  UnorderedListOutlined,
+  StopOutlined,
+} from "@ant-design/icons";
+import type { ColumnsType } from "antd/es/table";
+import {
+  getEditPlans,
+  deleteEditPlan,
+  generateEditPlan,
+  cancelGeneration,
+  copyEditPlan,
+  type EditPlan,
+  type EditPlanStatus,
+  type EditPlanListParams,
+} from "@/api/editPlans";
+import { getTemplatesList, type TemplateItem } from "@/api/templates";
+import "./edit-plans.css";
+
+/* ──────────── 常量 ──────────── */
+
+/** 状态 Tab 配置 */
+const STATUS_TABS: { key: EditPlanStatus | "all"; label: string }[] = [
+  { key: "all", label: "全部" },
+  { key: "draft", label: "草稿" },
+  { key: "editing", label: "编辑中" },
+  { key: "rendering", label: "渲染中" },
+  { key: "completed", label: "已完成" },
+  { key: "failed", label: "失败" },
+  { key: "cancelled", label: "已取消" },
+];
+
+/** 状态标签配置 */
+const STATUS_CONFIG: Record<
+  EditPlanStatus,
+  { label: string; color: string; icon: React.ReactNode }
+> = {
+  draft: {
+    label: "草稿",
+    color: "default",
+    icon: <FileTextOutlined />,
+  },
+  editing: {
+    label: "编辑中",
+    color: "processing",
+    icon: <EditOutlined />,
+  },
+  rendering: {
+    label: "渲染中",
+    color: "warning",
+    icon: <SyncOutlined spin />,
+  },
+  completed: {
+    label: "已完成",
+    color: "success",
+    icon: <CheckCircleOutlined />,
+  },
+  failed: {
+    label: "失败",
+    color: "error",
+    icon: <CloseCircleOutlined />,
+  },
+  cancelled: {
+    label: "已取消",
+    color: "default",
+    icon: <StopOutlined />,
+  },
+};
+
+/* ──────────── 工具函数 ──────────── */
+
+/** 格式化时长 */
+const formatDuration = (seconds: number): string => {
+  if (seconds <= 0) return "-";
+  const totalSec = Math.round(seconds);
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  if (m === 0) return `${s}秒`;
+  return `${m}分${s > 0 ? `${s}秒` : ""}`;
+};
+
+/** 格式化时间 */
+const formatTime = (dateStr?: string | null): string => {
+  if (!dateStr) return "-";
+  const date = new Date(dateStr);
+  return date.toLocaleString("zh-CN", {
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+};
+
+/* ──────────── 主组件 ──────────── */
+
+export default function EditPlans() {
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+
+  // 筛选状态
+  const [statusFilter, setStatusFilter] = useState<EditPlanStatus | "all">(
+    "all",
+  );
+  const [templateFilter, setTemplateFilter] = useState<string>("all");
+  const [page, setPage] = useState(1);
+  const [pageSize, setPageSize] = useState(20);
+
+  // 查询参数
+  const queryParams: EditPlanListParams = {
+    page,
+    page_size: pageSize,
+    ...(statusFilter !== "all" && { status: statusFilter }),
+    ...(templateFilter !== "all" && { template_id: templateFilter }),
+  };
+
+  // 获取剪辑计划列表
+  const {
+    data: planData,
+    isLoading,
+    error,
+  } = useQuery({
+    queryKey: ["edit-plans", queryParams],
+    queryFn: () => getEditPlans(queryParams),
+    refetchInterval: (query) => {
+      // 有进行中的计划时自动刷新
+      const plans = query.state.data?.items ?? [];
+      const hasRunning = plans.some(
+        (p) => p.status === "rendering" || p.status === "editing",
+      );
+      return hasRunning ? 5000 : false;
+    },
+  });
+
+  // 获取模板列表（用于筛选下拉）
+  const { data: templates } = useQuery({
+    queryKey: ["templates-list-simple"],
+    queryFn: getTemplatesList,
+  });
+
+  const plans = planData?.items ?? [];
+  const total = planData?.total ?? 0;
+
+  // 模板名称映射
+  const templateNameMap = new Map<string, string>();
+  (templates ?? []).forEach((t: TemplateItem) => {
+    templateNameMap.set(t.id, t.name);
+  });
+
+  // 删除计划
+  const deleteMutation = useMutation({
+    mutationFn: deleteEditPlan,
+    onSuccess: () => {
+      message.success("剪辑计划已删除");
+      queryClient.invalidateQueries({ queryKey: ["edit-plans"] });
+    },
+    onError: () => {
+      message.error("删除失败，请稍后重试");
+    },
+  });
+
+  // 重新生成
+  const regenerateMutation = useMutation({
+    mutationFn: generateEditPlan,
+    onSuccess: () => {
+      message.success("已重新提交生成");
+      queryClient.invalidateQueries({ queryKey: ["edit-plans"] });
+    },
+    onError: () => {
+      message.error("重新生成失败，请稍后重试");
+    },
+  });
+
+  // 取消生成
+  const cancelMutation = useMutation({
+    mutationFn: cancelGeneration,
+    onSuccess: () => {
+      message.success("已提交取消请求");
+      queryClient.invalidateQueries({ queryKey: ["edit-plans"] });
+    },
+    onError: () => {
+      message.error("取消失败，请稍后重试");
+    },
+  });
+
+  // 复制计划
+  const copyMutation = useMutation({
+    mutationFn: ({ planId, name }: { planId: string; name?: string }) =>
+      copyEditPlan(planId, name ? { name } : undefined),
+    onSuccess: (newPlan) => {
+      message.success("计划已复制");
+      queryClient.invalidateQueries({ queryKey: ["edit-plans"] });
+      // 自动跳转到新计划的编辑器
+      navigate(`/app/editing-planner?planId=${newPlan.id}`);
+    },
+    onError: () => {
+      message.error("复制失败，请稍后重试");
+    },
+  });
+
+  // 跳转到剪辑编辑器
+  const handleEdit = useCallback(
+    (plan: EditPlan) => {
+      navigate(`/app/editing-planner?planId=${plan.id}`);
+    },
+    [navigate],
+  );
+
+  // 表格列定义
+  const columns: ColumnsType<EditPlan> = [
+    {
+      title: "计划名称",
+      dataIndex: "name",
+      key: "name",
+      width: 240,
+      ellipsis: true,
+      render: (name: string, record: EditPlan) => (
+        <Tooltip title={name}>
+          <span className="plan-name" onClick={() => handleEdit(record)}>
+            {name}
+          </span>
+        </Tooltip>
+      ),
+    },
+    {
+      title: "模板",
+      dataIndex: "template_id",
+      key: "template_id",
+      width: 140,
+      ellipsis: true,
+      render: (templateId: string) => {
+        const name = templateNameMap.get(templateId);
+        return (
+          <Tag color="blue" className="plan-template-tag">
+            {name || templateId.slice(0, 8)}
+          </Tag>
+        );
+      },
+    },
+    {
+      title: "状态",
+      dataIndex: "status",
+      key: "status",
+      width: 120,
+      render: (status: EditPlanStatus) => {
+        const config = STATUS_CONFIG[status] || {
+          label: status,
+          color: "default",
+          icon: null,
+        };
+        return (
+          <Tag
+            color={config.color}
+            icon={config.icon}
+            className="plan-status-tag"
+          >
+            {config.label}
+          </Tag>
+        );
+      },
+    },
+    {
+      title: "时长",
+      dataIndex: "total_duration",
+      key: "total_duration",
+      width: 100,
+      render: (seconds: number) => (
+        <span className="plan-duration">{formatDuration(seconds)}</span>
+      ),
+    },
+    {
+      title: "视频数",
+      dataIndex: "result_count",
+      key: "result_count",
+      width: 80,
+      align: "center",
+      render: (count: number) => (
+        <span className="plan-result-count">{count > 0 ? count : "—"}</span>
+      ),
+    },
+    {
+      title: "创建时间",
+      dataIndex: "created_at",
+      key: "created_at",
+      width: 130,
+      render: (time: string) => (
+        <span className="plan-time">{formatTime(time)}</span>
+      ),
+    },
+    {
+      title: "更新时间",
+      dataIndex: "updated_at",
+      key: "updated_at",
+      width: 130,
+      render: (time: string) => (
+        <span className="plan-time">{formatTime(time)}</span>
+      ),
+    },
+    {
+      title: "操作",
+      key: "action",
+      width: 240,
+      fixed: "right",
+      render: (_: unknown, record: EditPlan) => (
+        <div className="plan-actions">
+          <Tooltip title="片段管理">
+            <Button
+              type="link"
+              size="small"
+              icon={<UnorderedListOutlined />}
+              onClick={() => navigate(`/app/edit-plans/${record.id}/clips`)}
+              className="plan-action-btn"
+            >
+              片段
+            </Button>
+          </Tooltip>
+          <Button
+            type="link"
+            size="small"
+            icon={<EditOutlined />}
+            onClick={() => handleEdit(record)}
+            className="plan-action-btn"
+          >
+            编辑
+          </Button>
+          {record.status === "rendering" && (
+            <Popconfirm
+              title="确认取消生成"
+              description="确定要取消当前生成任务吗？此操作不可恢复。"
+              onConfirm={() => cancelMutation.mutate(record.id)}
+              okText="确定"
+              cancelText="再等等"
+              okButtonProps={{ danger: true }}
+            >
+              <Button
+                type="link"
+                size="small"
+                danger
+                icon={<StopOutlined />}
+                loading={cancelMutation.isPending}
+                className="plan-action-btn plan-cancel-btn"
+              >
+                取消生成
+              </Button>
+            </Popconfirm>
+          )}
+          {(record.status === "failed" ||
+            record.status === "completed" ||
+            record.status === "cancelled") && (
+            <Popconfirm
+              title="确认重新生成"
+              description="确定要重新生成这个剪辑计划吗？"
+              onConfirm={() => regenerateMutation.mutate(record.id)}
+              okText="确定"
+              cancelText="取消"
+            >
+              <Button
+                type="link"
+                size="small"
+                icon={<ThunderboltOutlined />}
+                loading={regenerateMutation.isPending}
+                className="plan-action-btn plan-regenerate-btn"
+              >
+                重新生成
+              </Button>
+            </Popconfirm>
+          )}
+          <Popconfirm
+            title="复制计划"
+            description="确定要复制这个剪辑计划吗？将创建一个编辑中的新副本。"
+            onConfirm={() =>
+              copyMutation.mutate({
+                planId: record.id,
+                name: `${record.name} 副本`,
+              })
+            }
+            okText="确定"
+            cancelText="取消"
+          >
+            <Button
+              type="link"
+              size="small"
+              icon={<CopyOutlined />}
+              loading={copyMutation.isPending}
+              className="plan-action-btn"
+            >
+              复制
+            </Button>
+          </Popconfirm>
+          <Popconfirm
+            title="确认删除"
+            description="确定要删除这个剪辑计划吗？此操作不可恢复。"
+            onConfirm={() => deleteMutation.mutate(record.id)}
+            okText="确定"
+            cancelText="取消"
+            okButtonProps={{ danger: true }}
+          >
+            <Button
+              type="link"
+              size="small"
+              danger
+              icon={<DeleteOutlined />}
+              loading={deleteMutation.isPending}
+              className="plan-action-btn"
+            >
+              删除
+            </Button>
+          </Popconfirm>
+        </div>
+      ),
+    },
+  ];
+
+  // 错误处理
+  if (error) {
+    return (
+      <div className="edit-plans-page">
+        <div className="edit-plans-error">
+          <CloseCircleOutlined />
+          <p>加载剪辑计划失败</p>
+          <Button onClick={() => window.location.reload()}>刷新页面</Button>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="edit-plans-page">
+      {/* 页面标题 */}
+      <div className="edit-plans-header">
+        <div className="edit-plans-header-text">
+          <h2>剪辑计划</h2>
+          <p>管理所有剪辑计划，支持重新生成和编辑</p>
+        </div>
+        <Button type="primary" onClick={() => navigate("/app/templates")}>
+          从模板创建
+        </Button>
+      </div>
+
+      {/* 筛选栏 */}
+      <div className="edit-plans-filters">
+        {/* 状态 Tab */}
+        <Tabs
+          activeKey={statusFilter}
+          onChange={(key) => {
+            setStatusFilter(key as EditPlanStatus | "all");
+            setPage(1);
+          }}
+          items={STATUS_TABS.map((tab) => ({
+            key: tab.key,
+            label: tab.label,
+          }))}
+          className="edit-plans-status-tabs"
+        />
+
+        {/* 模板筛选 */}
+        <Select
+          value={templateFilter}
+          onChange={(value) => {
+            setTemplateFilter(value);
+            setPage(1);
+          }}
+          options={[
+            { value: "all", label: "全部模板" },
+            ...(templates ?? []).map((t: TemplateItem) => ({
+              value: t.id,
+              label: t.name,
+            })),
+          ]}
+          style={{ minWidth: 180 }}
+          placeholder="选择模板"
+          className="edit-plans-template-filter"
+        />
+      </div>
+
+      {/* 计划表格 */}
+      <Table
+        columns={columns}
+        dataSource={plans}
+        rowKey="id"
+        loading={isLoading}
+        pagination={{
+          current: page,
+          pageSize,
+          total,
+          showSizeChanger: true,
+          showQuickJumper: true,
+          showTotal: (t) => `共 ${t} 条`,
+          onChange: (p, ps) => {
+            setPage(p);
+            setPageSize(ps);
+          },
+        }}
+        scroll={{ x: 900 }}
+        className="edit-plans-table"
+        locale={{
+          emptyText: (
+            <div className="edit-plans-empty">
+              <ClockCircleOutlined />
+              <p>暂无剪辑计划</p>
+              <Button
+                type="primary"
+                style={{ marginTop: 12 }}
+                onClick={() => navigate("/app/templates")}
+              >
+                从模板创建
+              </Button>
+            </div>
+          ),
+        }}
+      />
+    </div>
+  );
+}

apps/web/src/pages/edit-plans/PlanClipsManager.tsx

@@ -0,0 +1,658 @@
+/**
+ * 剪辑计划片段管理页面
+ * 对接后端 PR#389 片段 CRUD API
+ * 功能：列表查看、创建、编辑、删除、批量删除、拖拽排序、从素材导入
+ */
+import { useState, useCallback } from "react";
+import { useParams, useNavigate } from "react-router-dom";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Table,
+  Button,
+  Space,
+  message,
+  Popconfirm,
+  Modal,
+  Form,
+  Input,
+  InputNumber,
+  Select,
+  Tag,
+  Drawer,
+  Empty,
+  Card,
+} from "antd";
+import {
+  ArrowLeftOutlined,
+  PlusOutlined,
+  DeleteOutlined,
+  EditOutlined,
+  UploadOutlined,
+  OrderedListOutlined,
+  SaveOutlined,
+} from "@ant-design/icons";
+import type { ColumnsType } from "antd/es/table";
+import {
+  getEditPlan,
+  getEditPlanClips,
+  createEditPlanClip,
+  updateEditPlanClip,
+  deleteEditPlanClip,
+  batchDeleteEditPlanClips,
+  reorderEditPlanClips,
+  createClipsFromAssets,
+  getMediaAssets,
+  type EditPlanClip,
+  type EditPlanClipStatus,
+} from "@/api/editPlans";
+import "./plan-clips.css";
+
+/* ──────────── 常量 ──────────── */
+
+const CLIP_TYPE_OPTIONS = [
+  { value: "main", label: "主片段" },
+  { value: "intro", label: "片头" },
+  { value: "outro", label: "片尾" },
+  { value: "overlay", label: "叠加层" },
+  { value: "background", label: "背景" },
+  { value: "b_roll", label: "B-roll" },
+];
+
+const STATUS_COLORS: Record<EditPlanClipStatus, string> = {
+  pending: "default",
+  processing: "processing",
+  ready: "success",
+  failed: "error",
+};
+
+const STATUS_LABELS: Record<EditPlanClipStatus, string> = {
+  pending: "待处理",
+  processing: "处理中",
+  ready: "就绪",
+  failed: "失败",
+};
+
+const TRANSITION_OPTIONS = [
+  { value: "cut", label: "硬切" },
+  { value: "fade", label: "淡入淡出" },
+  { value: "dissolve", label: "溶解" },
+  { value: "zoom", label: "缩放" },
+  { value: "slide_left", label: "左滑" },
+  { value: "slide_right", label: "右滑" },
+  { value: "slide_up", label: "上滑" },
+  { value: "slide_down", label: "下滑" },
+  { value: "wipe_left", label: "左擦除" },
+  { value: "wipe_right", label: "右擦除" },
+  { value: "wipe_up", label: "上擦除" },
+  { value: "wipe_down", label: "下擦除" },
+  { value: "circlecrop", label: "圆形裁切" },
+  { value: "rectcrop", label: "矩形裁切" },
+];
+
+/* ──────────── 组件 ──────────── */
+
+const PlanClipsManager: React.FC = () => {
+  const { planId } = useParams<{ planId: string }>();
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+
+  /* ── 计划信息 ── */
+  const { data: plan, isLoading: planLoading } = useQuery({
+    queryKey: ["editPlan", planId],
+    queryFn: () => getEditPlan(planId!),
+    enabled: !!planId,
+  });
+
+  /* ── 片段列表 ── */
+  const { data: clipsData, isLoading: clipsLoading } = useQuery({
+    queryKey: ["editPlanClips", planId],
+    queryFn: () => getEditPlanClips(planId!, { limit: 500 }),
+    enabled: !!planId,
+  });
+
+  const clips = clipsData?.items ?? [];
+
+  /* ── 选中的片段（批量操作） ── */
+  const [selectedRowKeys, setSelectedRowKeys] = useState<React.Key[]>([]);
+
+  /* ── 编辑弹窗 ── */
+  const [editModalOpen, setEditModalOpen] = useState(false);
+  const [editingClip, setEditingClip] = useState<EditPlanClip | null>(null);
+  const [editForm] = Form.useForm();
+  const [editLoading, setEditLoading] = useState(false);
+
+  /* ── 素材导入抽屉 ── */
+  const [importDrawerOpen, setImportDrawerOpen] = useState(false);
+  const [selectedAssetIds, setSelectedAssetIds] = useState<string[]>([]);
+  const [importLoading, setImportLoading] = useState(false);
+
+  const { data: assets } = useQuery({
+    queryKey: ["mediaAssets"],
+    queryFn: () => getMediaAssets(),
+    enabled: importDrawerOpen,
+  });
+
+  /* ── 重新排序模式 ── */
+  const [reorderMode, setReorderMode] = useState(false);
+  const [reorderItems, setReorderItems] = useState<EditPlanClip[]>([]);
+
+  /* ── 列定义 ── */
+  const columns: ColumnsType<EditPlanClip> = [
+    {
+      title: "序号",
+      dataIndex: "order",
+      width: 70,
+      render: (_, __, index) => index + 1,
+    },
+    {
+      title: "类型",
+      dataIndex: "clip_type",
+      width: 100,
+      render: (type: string) => {
+        const opt = CLIP_TYPE_OPTIONS.find((o) => o.value === type);
+        return <Tag>{opt?.label || type}</Tag>;
+      },
+    },
+    {
+      title: "素材",
+      dataIndex: "asset_id",
+      width: 150,
+      ellipsis: true,
+      render: (assetId: string) =>
+        assetId ? (
+          <code className="clip-asset-id">{assetId.slice(0, 12)}...</code>
+        ) : (
+          <span style={{ color: "#999" }}>无素材</span>
+        ),
+    },
+    {
+      title: "文本内容",
+      dataIndex: "text_content",
+      ellipsis: true,
+      render: (text: string) =>
+        text || <span style={{ color: "#999" }}>-</span>,
+    },
+    {
+      title: "时长",
+      dataIndex: "duration",
+      width: 90,
+      render: (d: number) => `${d?.toFixed(1) || 0}s`,
+    },
+    {
+      title: "转场",
+      dataIndex: "transition_effect",
+      width: 100,
+      render: (effect: string) => {
+        const opt = TRANSITION_OPTIONS.find((o) => o.value === effect);
+        return opt?.label || effect || "硬切";
+      },
+    },
+    {
+      title: "播放速度",
+      dataIndex: "playback_speed",
+      width: 90,
+      render: (s: number) => `${s || 1.0}x`,
+    },
+    {
+      title: "状态",
+      dataIndex: "status",
+      width: 90,
+      render: (status: EditPlanClipStatus) => (
+        <Tag color={STATUS_COLORS[status] || "default"}>
+          {STATUS_LABELS[status] || status}
+        </Tag>
+      ),
+    },
+    {
+      title: "操作",
+      key: "action",
+      width: 140,
+      fixed: "right",
+      render: (_, record) => (
+        <Space size="small">
+          <Button
+            type="link"
+            size="small"
+            icon={<EditOutlined />}
+            onClick={() => handleEditClip(record)}
+          >
+            编辑
+          </Button>
+          <Popconfirm
+            title="删除片段"
+            description="确定删除这个片段吗？"
+            onConfirm={() => handleDeleteClip(record.id)}
+            okText="确定"
+            cancelText="取消"
+            okButtonProps={{ danger: true }}
+          >
+            <Button type="link" size="small" danger icon={<DeleteOutlined />}>
+              删除
+            </Button>
+          </Popconfirm>
+        </Space>
+      ),
+    },
+  ];
+
+  /* ── 编辑片段 ── */
+  const handleEditClip = useCallback(
+    (clip: EditPlanClip) => {
+      setEditingClip(clip);
+      editForm.setFieldsValue({
+        clip_type: clip.clip_type,
+        asset_id: clip.asset_id,
+        text_content: clip.text_content,
+        duration: clip.duration,
+        start_time: clip.start_time,
+        transition_effect: clip.transition_effect,
+        transition_duration: clip.transition_duration,
+        playback_speed: clip.playback_speed,
+      });
+      setEditModalOpen(true);
+    },
+    [editForm],
+  );
+
+  const handleNewClip = useCallback(() => {
+    setEditingClip(null);
+    editForm.resetFields();
+    editForm.setFieldsValue({
+      clip_type: "main",
+      duration: 5,
+      transition_effect: "cut",
+      transition_duration: 0,
+      playback_speed: 1.0,
+    });
+    setEditModalOpen(true);
+  }, [editForm]);
+
+  const handleSaveClip = async () => {
+    if (!planId) return;
+    try {
+      const values = await editForm.validateFields();
+      setEditLoading(true);
+
+      if (editingClip) {
+        // 更新
+        await updateEditPlanClip(planId, editingClip.id, values);
+        message.success("片段已更新");
+      } else {
+        // 新建
+        const maxOrder =
+          clips.length > 0 ? Math.max(...clips.map((c) => c.order)) : -1;
+        await createEditPlanClip(planId, {
+          ...values,
+          order: maxOrder + 1,
+        });
+        message.success("片段已创建");
+      }
+
+      queryClient.invalidateQueries({ queryKey: ["editPlanClips", planId] });
+      setEditModalOpen(false);
+    } catch (err) {
+      console.error(err);
+      message.error(editingClip ? "更新失败" : "创建失败");
+    } finally {
+      setEditLoading(false);
+    }
+  };
+
+  /* ── 删除片段 ── */
+  const handleDeleteClip = async (clipId: string) => {
+    if (!planId) return;
+    try {
+      await deleteEditPlanClip(planId, clipId);
+      message.success("已删除");
+      queryClient.invalidateQueries({ queryKey: ["editPlanClips", planId] });
+      setSelectedRowKeys((prev) => prev.filter((k) => k !== clipId));
+    } catch {
+      message.error("删除失败");
+    }
+  };
+
+  /* ── 批量删除 ── */
+  const handleBatchDelete = async () => {
+    if (!planId || selectedRowKeys.length === 0) return;
+    try {
+      await batchDeleteEditPlanClips(
+        planId,
+        selectedRowKeys.map((k) => String(k)),
+      );
+      message.success(`已删除 ${selectedRowKeys.length} 个片段`);
+      queryClient.invalidateQueries({ queryKey: ["editPlanClips", planId] });
+      setSelectedRowKeys([]);
+    } catch {
+      message.error("批量删除失败");
+    }
+  };
+
+  /* ── 从素材导入 ── */
+  const handleImportFromAssets = async () => {
+    if (!planId || selectedAssetIds.length === 0) return;
+    try {
+      setImportLoading(true);
+      const res = await createClipsFromAssets(planId, selectedAssetIds);
+      message.success(`已导入 ${res.created_count} 个片段`);
+      queryClient.invalidateQueries({ queryKey: ["editPlanClips", planId] });
+      setImportDrawerOpen(false);
+      setSelectedAssetIds([]);
+    } catch {
+      message.error("导入失败");
+    } finally {
+      setImportLoading(false);
+    }
+  };
+
+  /* ── 排序模式 ── */
+  const enterReorderMode = () => {
+    setReorderItems([...clips].sort((a, b) => a.order - b.order));
+    setReorderMode(true);
+  };
+
+  const moveClip = (fromIndex: number, toIndex: number) => {
+    if (toIndex < 0 || toIndex >= reorderItems.length) return;
+    const newItems = [...reorderItems];
+    const [moved] = newItems.splice(fromIndex, 1);
+    newItems.splice(toIndex, 0, moved);
+    setReorderItems(newItems);
+  };
+
+  const saveReorder = async () => {
+    if (!planId) return;
+    const items = reorderItems.map((clip, index) => ({
+      clip_id: clip.id,
+      new_order: index,
+    }));
+    try {
+      await reorderEditPlanClips(planId, items);
+      message.success("排序已保存");
+      queryClient.invalidateQueries({ queryKey: ["editPlanClips", planId] });
+      setReorderMode(false);
+    } catch {
+      message.error("排序保存失败");
+    }
+  };
+
+  const cancelReorder = () => {
+    setReorderMode(false);
+    setReorderItems([]);
+  };
+
+  /* ── 渲染 ── */
+  const displayClips = reorderMode
+    ? reorderItems
+    : [...clips].sort((a, b) => a.order - b.order);
+
+  return (
+    <div className="plan-clips-page">
+      {/* 顶部 */}
+      <div className="plan-clips-header">
+        <div className="plan-clips-header-left">
+          <Button
+            type="text"
+            icon={<ArrowLeftOutlined />}
+            onClick={() => navigate("/app/edit-plans")}
+          >
+            返回计划列表
+          </Button>
+          <div className="plan-clips-title">
+            <h2>{plan?.name || "加载中..."}</h2>
+            <p>
+              {planLoading
+                ? "加载中..."
+                : `共 ${clipsData?.total || 0} 个片段 · ${plan?.status || ""}`}
+            </p>
+          </div>
+        </div>
+        <div className="plan-clips-header-right">
+          <Space>
+            <Button
+              icon={<UploadOutlined />}
+              onClick={() => setImportDrawerOpen(true)}
+            >
+              从素材导入
+            </Button>
+            {reorderMode ? (
+              <>
+                <Button onClick={cancelReorder}>取消排序</Button>
+                <Button
+                  type="primary"
+                  icon={<SaveOutlined />}
+                  onClick={saveReorder}
+                >
+                  保存排序
+                </Button>
+              </>
+            ) : (
+              <>
+                <Button
+                  icon={<OrderedListOutlined />}
+                  onClick={enterReorderMode}
+                  disabled={clips.length === 0}
+                >
+                  调整顺序
+                </Button>
+                <Button
+                  type="primary"
+                  icon={<PlusOutlined />}
+                  onClick={handleNewClip}
+                >
+                  添加片段
+                </Button>
+              </>
+            )}
+          </Space>
+        </div>
+      </div>
+
+      {/* 批量操作栏 */}
+      {!reorderMode && selectedRowKeys.length > 0 && (
+        <div className="plan-clips-batch-bar">
+          <span>已选择 {selectedRowKeys.length} 个片段</span>
+          <Popconfirm
+            title="批量删除"
+            description={`确定删除选中的 ${selectedRowKeys.length} 个片段吗？`}
+            onConfirm={handleBatchDelete}
+            okText="确定"
+            cancelText="取消"
+            okButtonProps={{ danger: true }}
+          >
+            <Button danger icon={<DeleteOutlined />}>
+              批量删除
+            </Button>
+          </Popconfirm>
+        </div>
+      )}
+
+      {/* 排序列表 */}
+      {reorderMode && (
+        <Card className="plan-clips-reorder-card" title="拖拽调整顺序">
+          <div className="plan-clips-reorder-list">
+            {reorderItems.map((clip, index) => (
+              <div key={clip.id} className="plan-clips-reorder-item">
+                <span className="reorder-index">{index + 1}</span>
+                <span className="reorder-type">
+                  {CLIP_TYPE_OPTIONS.find((o) => o.value === clip.clip_type)
+                    ?.label || clip.clip_type}
+                </span>
+                <span className="reorder-content">
+                  {clip.text_content || clip.asset_id || "无内容"}
+                </span>
+                <span className="reorder-duration">
+                  {clip.duration.toFixed(1)}s
+                </span>
+                <Space>
+                  <Button
+                    size="small"
+                    onClick={() => moveClip(index, index - 1)}
+                    disabled={index === 0}
+                  >
+                    ↑
+                  </Button>
+                  <Button
+                    size="small"
+                    onClick={() => moveClip(index, index + 1)}
+                    disabled={index === reorderItems.length - 1}
+                  >
+                    ↓
+                  </Button>
+                </Space>
+              </div>
+            ))}
+          </div>
+        </Card>
+      )}
+
+      {/* 片段列表 */}
+      {!reorderMode && (
+        <div className="plan-clips-table-wrap">
+          <Table
+            rowKey="id"
+            columns={columns}
+            dataSource={displayClips}
+            loading={clipsLoading}
+            rowSelection={{
+              selectedRowKeys,
+              onChange: setSelectedRowKeys,
+            }}
+            pagination={false}
+            locale={{
+              emptyText: (
+                <Empty
+                  description="暂无片段，点击上方按钮添加或从素材导入"
+                  image={Empty.PRESENTED_IMAGE_SIMPLE}
+                />
+              ),
+            }}
+            scroll={{ x: 1000 }}
+          />
+        </div>
+      )}
+
+      {/* 编辑弹窗 */}
+      <Modal
+        title={editingClip ? "编辑片段" : "添加片段"}
+        open={editModalOpen}
+        onCancel={() => setEditModalOpen(false)}
+        onOk={handleSaveClip}
+        confirmLoading={editLoading}
+        okText="保存"
+        cancelText="取消"
+        width={560}
+      >
+        <Form form={editForm} layout="vertical">
+          <Form.Item
+            label="片段类型"
+            name="clip_type"
+            rules={[{ required: true, message: "请选择类型" }]}
+          >
+            <Select options={CLIP_TYPE_OPTIONS} />
+          </Form.Item>
+          <Form.Item label="素材 ID" name="asset_id">
+            <Input placeholder="关联的素材 ID（可选）" />
+          </Form.Item>
+          <Form.Item label="文本内容" name="text_content">
+            <Input.TextArea rows={3} placeholder="字幕/配音文案等" />
+          </Form.Item>
+          <div style={{ display: "flex", gap: 16 }}>
+            <Form.Item
+              label="起始时间（秒）"
+              name="start_time"
+              style={{ flex: 1 }}
+            >
+              <InputNumber min={0} step={0.1} style={{ width: "100%" }} />
+            </Form.Item>
+            <Form.Item label="时长（秒）" name="duration" style={{ flex: 1 }}>
+              <InputNumber min={0} step={0.1} style={{ width: "100%" }} />
+            </Form.Item>
+          </div>
+          <div style={{ display: "flex", gap: 16 }}>
+            <Form.Item
+              label="转场效果"
+              name="transition_effect"
+              style={{ flex: 1 }}
+            >
+              <Select options={TRANSITION_OPTIONS} />
+            </Form.Item>
+            <Form.Item
+              label="转场时长"
+              name="transition_duration"
+              style={{ flex: 1 }}
+            >
+              <InputNumber min={0} step={0.1} style={{ width: "100%" }} />
+            </Form.Item>
+          </div>
+          <Form.Item label="播放速度" name="playback_speed">
+            <InputNumber
+              min={0.1}
+              max={10}
+              step={0.1}
+              style={{ width: "100%" }}
+            />
+          </Form.Item>
+        </Form>
+      </Modal>
+
+      {/* 素材导入抽屉 */}
+      <Drawer
+        title="从素材库导入"
+        open={importDrawerOpen}
+        onClose={() => setImportDrawerOpen(false)}
+        width={480}
+        extra={
+          <Button
+            type="primary"
+            onClick={handleImportFromAssets}
+            loading={importLoading}
+            disabled={selectedAssetIds.length === 0}
+          >
+            导入{" "}
+            {selectedAssetIds.length > 0 ? `(${selectedAssetIds.length})` : ""}
+          </Button>
+        }
+      >
+        {assets && assets.length > 0 ? (
+          <div className="asset-import-list">
+            {assets.map((asset) => (
+              <div
+                key={asset.id}
+                className={`asset-import-item ${
+                  selectedAssetIds.includes(asset.id) ? "selected" : ""
+                }`}
+                onClick={() => {
+                  setSelectedAssetIds((prev) =>
+                    prev.includes(asset.id)
+                      ? prev.filter((id) => id !== asset.id)
+                      : [...prev, asset.id],
+                  );
+                }}
+              >
+                <div className="asset-thumb">
+                  {asset.thumbnail_url ? (
+                    <img src={asset.thumbnail_url} alt={asset.name} />
+                  ) : (
+                    <div className="asset-thumb-placeholder">{asset.type}</div>
+                  )}
+                </div>
+                <div className="asset-info">
+                  <div className="asset-name" title={asset.name}>
+                    {asset.name}
+                  </div>
+                  <div className="asset-meta">
+                    {asset.type}
+                    {asset.duration ? ` · ${asset.duration.toFixed(1)}s` : ""}
+                  </div>
+                </div>
+              </div>
+            ))}
+          </div>
+        ) : (
+          <Empty description="素材库为空" />
+        )}
+      </Drawer>
+    </div>
+  );
+};
+
+export default PlanClipsManager;

apps/web/src/pages/edit-plans/edit-plans.css

@@ -0,0 +1,260 @@
+/**
+ * 剪辑计划管理页面样式
+ */
+
+/* ── 页面容器 ──────────────────────────────────────────── */
+.edit-plans-page {
+  padding: 24px;
+  max-width: 1400px;
+  margin: 0 auto;
+}
+
+/* ── 页面头部 ──────────────────────────────────────────── */
+.edit-plans-header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  margin-bottom: 24px;
+}
+
+.edit-plans-header-text h2 {
+  margin: 0 0 4px;
+  font-size: 22px;
+  font-weight: 600;
+  color: var(--text-primary, #1e293b);
+}
+
+.edit-plans-header-text p {
+  margin: 0;
+  font-size: 14px;
+  color: var(--text-secondary, #64748b);
+}
+
+/* ── 筛选栏 ────────────────────────────────────────────── */
+.edit-plans-filters {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  margin-bottom: 20px;
+  flex-wrap: wrap;
+}
+
+.edit-plans-status-tabs {
+  flex: 1;
+}
+
+.edit-plans-status-tabs .ant-tabs-nav {
+  margin-bottom: 0 !important;
+}
+
+.edit-plans-status-tabs .ant-tabs-tab {
+  padding: 8px 16px !important;
+  font-size: 14px;
+}
+
+.edit-plans-status-tabs .ant-tabs-tab-active .ant-tabs-tab-btn {
+  color: var(--primary-500, #6366f1) !important;
+  font-weight: 500;
+}
+
+.edit-plans-status-tabs .ant-tabs-ink-bar {
+  background: var(--primary-500, #6366f1) !important;
+}
+
+.edit-plans-template-filter {
+  min-width: 180px;
+}
+
+/* ── 表格 ──────────────────────────────────────────────── */
+.edit-plans-table {
+  background: var(--bg-surface, #fff);
+  border-radius: var(--radius-lg, 12px);
+  overflow: hidden;
+  border: 1px solid var(--border-primary, #e2e8f0);
+}
+
+.edit-plans-table .ant-table {
+  font-size: 14px;
+}
+
+.edit-plans-table .ant-table-thead > tr > th {
+  background: var(--bg-tertiary, #f8fafc) !important;
+  border-bottom: 1px solid var(--border-primary, #e2e8f0);
+  font-weight: 500;
+  color: var(--text-secondary, #64748b);
+  font-size: 13px;
+  padding: 12px 16px;
+}
+
+.edit-plans-table .ant-table-tbody > tr > td {
+  padding: 14px 16px;
+  border-bottom: 1px solid var(--border-light, #f1f5f9);
+}
+
+.edit-plans-table .ant-table-tbody > tr:hover > td {
+  background: var(--bg-hover, #f8fafc) !important;
+}
+
+/* ── 计划名称 ──────────────────────────────────────────── */
+.plan-name {
+  font-weight: 500;
+  color: var(--text-primary, #1e293b);
+  cursor: pointer;
+  transition: color 0.2s;
+}
+
+.plan-name:hover {
+  color: var(--primary-500, #6366f1);
+}
+
+/* ── 状态标签 ──────────────────────────────────────────── */
+.plan-status-tag {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 4px 10px;
+  border-radius: 16px;
+  font-size: 12px;
+  font-weight: 500;
+}
+
+.plan-status-tag.ant-tag-default {
+  background: #f1f5f9;
+  color: #64748b;
+  border-color: transparent;
+}
+
+.plan-status-tag.ant-tag-processing {
+  background: #eff6ff;
+  color: #2563eb;
+  border-color: transparent;
+}
+
+.plan-status-tag.ant-tag-success {
+  background: #f0fdf4;
+  color: #16a34a;
+  border-color: transparent;
+}
+
+.plan-status-tag.ant-tag-error {
+  background: #fef2f2;
+  color: #dc2626;
+  border-color: transparent;
+}
+
+.plan-status-tag.ant-tag-warning {
+  background: #fffbeb;
+  color: #d97706;
+  border-color: transparent;
+}
+
+/* ── 时长 ──────────────────────────────────────────────── */
+.plan-duration {
+  font-variant-numeric: tabular-nums;
+  color: var(--text-secondary, #64748b);
+}
+
+/* ── 时间 ──────────────────────────────────────────────── */
+.plan-time {
+  color: var(--text-secondary, #64748b);
+  font-size: 13px;
+}
+
+/* ── 操作按钮 ──────────────────────────────────────────── */
+.plan-actions {
+  display: flex;
+  gap: 4px;
+}
+
+.plan-action-btn {
+  padding: 4px 8px !important;
+  font-size: 13px !important;
+}
+
+.plan-action-btn.ant-btn-link {
+  color: var(--primary-500, #6366f1);
+}
+
+.plan-action-btn.ant-btn-link:hover {
+  color: var(--primary-600, #4f46e5);
+}
+
+.plan-regenerate-btn {
+  color: var(--primary-500, #6366f1) !important;
+}
+
+.plan-regenerate-btn:hover {
+  color: var(--primary-600, #4f46e5) !important;
+}
+
+/* ── 空状态 ────────────────────────────────────────────── */
+.edit-plans-empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 60px 20px;
+  text-align: center;
+}
+
+.edit-plans-empty .anticon {
+  font-size: 48px;
+  color: var(--text-disabled, #cbd5e1);
+  margin-bottom: 16px;
+}
+
+.edit-plans-empty p {
+  margin: 0;
+  font-size: 14px;
+  color: var(--text-secondary, #64748b);
+}
+
+/* ── 错误状态 ──────────────────────────────────────────── */
+.edit-plans-error {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 60px 20px;
+  text-align: center;
+  background: var(--bg-surface, #fff);
+  border-radius: var(--radius-lg, 12px);
+  border: 1px solid var(--border-primary, #e2e8f0);
+}
+
+.edit-plans-error .anticon {
+  font-size: 48px;
+  color: #ef4444;
+  margin-bottom: 16px;
+}
+
+.edit-plans-error p {
+  margin: 0 0 16px;
+  font-size: 14px;
+  color: var(--text-secondary, #64748b);
+}
+
+/* ── 响应式 ────────────────────────────────────────────── */
+@media (max-width: 768px) {
+  .edit-plans-page {
+    padding: 16px;
+  }
+
+  .edit-plans-header {
+    flex-direction: column;
+    gap: 12px;
+  }
+
+  .edit-plans-filters {
+    flex-direction: column;
+    align-items: stretch;
+  }
+
+  .edit-plans-status-tabs {
+    width: 100%;
+  }
+
+  .edit-plans-template-filter {
+    width: 100%;
+  }
+}

apps/web/src/pages/edit-plans/plan-clips.css

@@ -0,0 +1,203 @@
+/* 剪辑计划片段管理页面 */
+
+.plan-clips-page {
+  padding: 24px;
+  min-height: 100vh;
+  background: #f5f7fa;
+}
+
+.plan-clips-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 20px;
+}
+
+.plan-clips-header-left {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+}
+
+.plan-clips-title h2 {
+  margin: 0;
+  font-size: 20px;
+  font-weight: 600;
+  color: #1f2937;
+}
+
+.plan-clips-title p {
+  margin: 4px 0 0;
+  font-size: 13px;
+  color: #6b7280;
+}
+
+.plan-clips-batch-bar {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  padding: 12px 20px;
+  margin-bottom: 16px;
+  background: #e6f4ff;
+  border-radius: 8px;
+  font-size: 14px;
+  color: #1677ff;
+}
+
+.plan-clips-table-wrap {
+  background: #fff;
+  border-radius: 12px;
+  padding: 16px;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.04);
+}
+
+.clip-asset-id {
+  font-size: 12px;
+  color: #6b7280;
+  background: #f3f4f6;
+  padding: 2px 6px;
+  border-radius: 4px;
+}
+
+/* 排序模式 */
+.plan-clips-reorder-card {
+  margin-bottom: 16px;
+  border-radius: 12px;
+}
+
+.plan-clips-reorder-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.plan-clips-reorder-item {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 12px 16px;
+  background: #f9fafb;
+  border: 1px solid #e5e7eb;
+  border-radius: 8px;
+  cursor: grab;
+  transition: all 0.2s;
+}
+
+.plan-clips-reorder-item:hover {
+  border-color: #1677ff;
+  background: #f0f7ff;
+}
+
+.reorder-index {
+  width: 28px;
+  height: 28px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: #1677ff;
+  color: #fff;
+  border-radius: 50%;
+  font-size: 13px;
+  font-weight: 600;
+  flex-shrink: 0;
+}
+
+.reorder-type {
+  flex-shrink: 0;
+  font-size: 12px;
+  color: #6b7280;
+  padding: 2px 8px;
+  background: #eef2ff;
+  border-radius: 4px;
+}
+
+.reorder-content {
+  flex: 1;
+  font-size: 14px;
+  color: #1f2937;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.reorder-duration {
+  flex-shrink: 0;
+  font-size: 13px;
+  color: #6b7280;
+  font-variant-numeric: tabular-nums;
+}
+
+/* 素材导入 */
+.asset-import-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  max-height: calc(100vh - 200px);
+  overflow-y: auto;
+}
+
+.asset-import-item {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 10px 12px;
+  border: 1px solid #e5e7eb;
+  border-radius: 8px;
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.asset-import-item:hover {
+  border-color: #1677ff;
+  background: #f0f7ff;
+}
+
+.asset-import-item.selected {
+  border-color: #1677ff;
+  background: #e6f4ff;
+}
+
+.asset-thumb {
+  width: 56px;
+  height: 40px;
+  border-radius: 4px;
+  overflow: hidden;
+  background: #f3f4f6;
+  flex-shrink: 0;
+}
+
+.asset-thumb img {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+
+.asset-thumb-placeholder {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 11px;
+  color: #9ca3af;
+  text-transform: uppercase;
+}
+
+.asset-info {
+  flex: 1;
+  min-width: 0;
+}
+
+.asset-name {
+  font-size: 14px;
+  color: #1f2937;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.asset-meta {
+  font-size: 12px;
+  color: #9ca3af;
+  margin-top: 2px;
+}

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

@@ -0,0 +1,292 @@
+/**
+ * BGM 选择器 — Drawer 形式
+ * 预设 BGM 列表（按风格分类）、搜索、试听、音量/淡入淡出/人声闪避配置
+ */
+import React, { useState, useRef, useCallback, useEffect } from "react";
+import { Drawer, Slider, Input, Tag, message } from "antd";
+import {
+  getBgmPresets,
+  type BgmPreset,
+  type BgmCategory,
+  type BgmMixConfig,
+  DEFAULT_BGM_MIX_CONFIG,
+} from "@/api/bgm";
+
+const { Search } = Input;
+
+/* ──────────── 分类标签 ──────────── */
+const CATEGORY_LIST: {
+  key: BgmCategory | "all";
+  label: string;
+  icon: string;
+}[] = [
+  { key: "all", label: "全部", icon: "🎶" },
+  { key: "轻快", label: "轻快", icon: "🎉" },
+  { key: "治愈", label: "治愈", icon: "🌿" },
+  { key: "科技", label: "科技", icon: "🔬" },
+  { key: "电商", label: "电商", icon: "🛒" },
+];
+
+/* ──────────── Props ──────────── */
+interface BgmSelectorProps {
+  open: boolean;
+  onClose: () => void;
+  config: BgmMixConfig;
+  onChange: (config: BgmMixConfig) => void;
+}
+
+const BgmSelector: React.FC<BgmSelectorProps> = ({
+  open,
+  onClose,
+  config,
+  onChange,
+}) => {
+  const [presets, setPresets] = useState<BgmPreset[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [activeCategory, setActiveCategory] = useState<BgmCategory | "all">(
+    "all",
+  );
+  const [keyword, setKeyword] = useState("");
+  const [previewingId, setPreviewingId] = useState<string | null>(null);
+
+  const audioRef = useRef<HTMLAudioElement | null>(null);
+
+  /* ── 加载 BGM 列表 ── */
+  const loadPresets = useCallback(async () => {
+    setLoading(true);
+    try {
+      const params: { category?: string; keyword?: string } = {};
+      if (activeCategory !== "all") params.category = activeCategory;
+      if (keyword.trim()) params.keyword = keyword.trim();
+      const data = await getBgmPresets(params);
+      setPresets(data);
+    } catch {
+      message.error("加载 BGM 列表失败");
+    } finally {
+      setLoading(false);
+    }
+  }, [activeCategory, keyword]);
+
+  useEffect(() => {
+    if (open) loadPresets();
+  }, [open, loadPresets]);
+
+  /* ── 试听 ── */
+  const handlePreview = useCallback(
+    (bgm: BgmPreset) => {
+      if (previewingId === bgm.id) {
+        audioRef.current?.pause();
+        setPreviewingId(null);
+        return;
+      }
+      audioRef.current?.pause();
+      const audio = new Audio(bgm.url);
+      audioRef.current = audio;
+      audio.play().catch(() => {});
+      audio.onended = () => setPreviewingId(null);
+      setPreviewingId(bgm.id);
+    },
+    [previewingId],
+  );
+
+  /* ── 选中 BGM ── */
+  const handleSelect = useCallback(
+    (bgm: BgmPreset) => {
+      onChange({
+        ...config,
+        enabled: true,
+        music_id: bgm.id,
+      });
+    },
+    [config, onChange],
+  );
+
+  /* ── 关闭时停止播放 ── */
+  const handleClose = useCallback(() => {
+    audioRef.current?.pause();
+    setPreviewingId(null);
+    onClose();
+  }, [onClose]);
+
+  /* ── 移除 BGM ── */
+  const handleClear = useCallback(() => {
+    audioRef.current?.pause();
+    setPreviewingId(null);
+    onChange({ ...DEFAULT_BGM_MIX_CONFIG });
+  }, [onChange]);
+
+  /* ── 当前选中的 BGM ── */
+  const selectedBgm = presets.find((p) => p.id === config.music_id);
+
+  return (
+    <Drawer
+      title="🎵 BGM 音乐选择"
+      placement="right"
+      width={420}
+      open={open}
+      onClose={handleClose}
+      className="bgm-selector-drawer"
+    >
+      {/* ── 搜索框 ── */}
+      <div className="bgm-search-row">
+        <Search
+          placeholder="搜索 BGM 名称..."
+          allowClear
+          value={keyword}
+          onChange={(e) => setKeyword(e.target.value)}
+          onSearch={() => loadPresets()}
+        />
+      </div>
+
+      {/* ── 分类标签 ── */}
+      <div className="bgm-category-bar">
+        {CATEGORY_LIST.map((cat) => (
+          <Tag
+            key={cat.key}
+            className={`bgm-category-tag${activeCategory === cat.key ? " active" : ""}`}
+            onClick={() => setActiveCategory(cat.key)}
+          >
+            {cat.icon} {cat.label}
+          </Tag>
+        ))}
+      </div>
+
+      {/* ── BGM 列表 ── */}
+      <div className="bgm-list">
+        {loading && <div className="bgm-loading">加载中...</div>}
+        {!loading && presets.length === 0 && (
+          <div className="bgm-empty">暂无 BGM 数据</div>
+        )}
+        {presets.map((bgm) => {
+          const isSelected = config.music_id === bgm.id;
+          const isPlaying = previewingId === bgm.id;
+          return (
+            <div
+              key={bgm.id}
+              className={`bgm-item${isSelected ? " selected" : ""}`}
+              onClick={() => handleSelect(bgm)}
+            >
+              <div className="bgm-item-cover">
+                {bgm.cover_url ? (
+                  <img src={bgm.cover_url} alt={bgm.name} />
+                ) : (
+                  <span className="bgm-item-cover-icon">🎵</span>
+                )}
+              </div>
+              <div className="bgm-item-info">
+                <div className="bgm-item-name">{bgm.name}</div>
+                <div className="bgm-item-meta">
+                  <span className="bgm-item-category">{bgm.category}</span>
+                  <span className="bgm-item-duration">
+                    {Math.floor(bgm.duration / 60)}:
+                    {String(Math.floor(bgm.duration % 60)).padStart(2, "0")}
+                  </span>
+                </div>
+                {bgm.tags.length > 0 && (
+                  <div className="bgm-item-tags">
+                    {bgm.tags.slice(0, 3).map((t) => (
+                      <span key={t} className="bgm-item-tag">
+                        {t}
+                      </span>
+                    ))}
+                  </div>
+                )}
+              </div>
+              <button
+                className={`bgm-item-preview-btn${isPlaying ? " playing" : ""}`}
+                onClick={(e) => {
+                  e.stopPropagation();
+                  handlePreview(bgm);
+                }}
+                title={isPlaying ? "暂停" : "试听"}
+              >
+                {isPlaying ? "⏸" : "▶️"}
+              </button>
+              {isSelected && <span className="bgm-item-check">✓</span>}
+            </div>
+          );
+        })}
+      </div>
+
+      {/* ── 混音配置 ── */}
+      {config.enabled && config.music_id && (
+        <div className="bgm-mix-config">
+          <div className="bgm-mix-header">
+            <span>混音配置</span>
+            <button className="bgm-mix-clear" onClick={handleClear}>
+              移除 BGM
+            </button>
+          </div>
+
+          <div className="bgm-mix-selected">
+            {selectedBgm
+              ? `当前：${selectedBgm.name}`
+              : `当前：${config.music_id}`}
+          </div>
+
+          {/* 音量 */}
+          <div className="bgm-mix-field">
+            <label className="bgm-mix-label">
+              音量 <span className="bgm-mix-value">{config.volume}%</span>
+            </label>
+            <Slider
+              min={0}
+              max={100}
+              value={config.volume}
+              onChange={(v) => onChange({ ...config, volume: v })}
+            />
+          </div>
+
+          {/* 淡入 */}
+          <div className="bgm-mix-field">
+            <label className="bgm-mix-label">
+              淡入{" "}
+              <span className="bgm-mix-value">
+                {config.fade_in.toFixed(1)}s
+              </span>
+            </label>
+            <Slider
+              min={0}
+              max={3}
+              step={0.1}
+              value={config.fade_in}
+              onChange={(v) => onChange({ ...config, fade_in: v })}
+            />
+          </div>
+
+          {/* 淡出 */}
+          <div className="bgm-mix-field">
+            <label className="bgm-mix-label">
+              淡出{" "}
+              <span className="bgm-mix-value">
+                {config.fade_out.toFixed(1)}s
+              </span>
+            </label>
+            <Slider
+              min={0}
+              max={3}
+              step={0.1}
+              value={config.fade_out}
+              onChange={(v) => onChange({ ...config, fade_out: v })}
+            />
+          </div>
+
+          {/* 人声闪避 */}
+          <div className="bgm-mix-field bgm-mix-toggle-row">
+            <label className="bgm-mix-label">人声闪避（sidechain）</label>
+            <div
+              className={`ep-toggle${config.voice_dodge ? " active" : ""}`}
+              onClick={() =>
+                onChange({ ...config, voice_dodge: !config.voice_dodge })
+              }
+            >
+              <div className="ep-toggle-knob" />
+            </div>
+          </div>
+        </div>
+      )}
+    </Drawer>
+  );
+};
+
+export default BgmSelector;

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

@@ -5,32 +5,30 @@
 import React, { useRef, useState, useCallback } from "react";
 import { useNavigate } from "react-router-dom";
 import type { TemplateMode } from "@/api/editingPlanner";
-import type { ClipData, ClipType } from "../types";
+import type { ClipData, ClipType, TitleSettings } from "../types";
+import { TRANSITION_OPTIONS } from "@/api/editPlans";
 import type { AssetItem } from "@/api/assets";
 
-interface TitleSettings {
-  aiAutoSelect: boolean;
-  title: string;
-  position: string;
-  font: string;
-  size: number;
-  bold: boolean;
-  italic: boolean;
-  stroke: boolean;
-  shadow: boolean;
-  color: string;
-}
-
 interface SubtitleSettings {
   enabled: boolean;
   position: string;
   font: string;
-  size: number;
+  fontSize: number;
+  fontColor: string;
   animation: string;
+  mode?: string;
+  stroke?: boolean;
+  shadow?: boolean;
+  asrLanguage?: string;
 }
 
 interface BgmSettings {
-  music: string;
+  enabled: boolean;
+  music_id: string;
+  volume?: number;
+  fade_in?: number;
+  fade_out?: number;
+  voice_dodge?: boolean;
 }
 
 interface ClipPropertiesPanelProps {
@@ -45,6 +43,10 @@ interface ClipPropertiesPanelProps {
   onSubtitleSettingsChange: (partial: Partial<SubtitleSettings>) => void;
   onBgmSettingsChange: (partial: Partial<BgmSettings>) => void;
   onClipUpdate: (clipId: string, data: Partial<ClipData>) => void;
+  /** 打开 BGM 选择器 Drawer */
+  onOpenBgmDrawer?: () => void;
+  /** 打开字幕样式配置 Drawer */
+  onOpenSubtitleDrawer?: () => void;
   /** 配音素材列表（从配音素材库 API 获取） */
   voiceMaterials?: AssetItem[];
   /** 配音素材加载中 */
@@ -53,6 +55,26 @@ interface ClipPropertiesPanelProps {
   onRefreshVoiceMaterials?: () => void;
   /** 为片段选择配音素材 */
   onClipVoiceSelect?: (clipId: string, asset: AssetItem | null) => void;
+  /** 打开转场特效选择器 Drawer */
+  onOpenTransitionDrawer?: (clipId: string) => void;
+  /** 打开片段调速面板 Drawer */
+  onOpenSpeedDrawer?: (clipId: string) => void;
+  /** 打开 TTS 配音面板 Drawer */
+  onOpenTtsDrawer?: (clipId: string) => void;
+  /** 打开水印设置面板 Drawer */
+  onOpenWatermarkDrawer?: () => void;
+  /** 打开片头片尾设置面板 Drawer */
+  onOpenIntroOutroDrawer?: () => void;
+  /** 打开画中画设置面板 Drawer */
+  onOpenPipDrawer?: () => void;
+  /** 打开滤镜调色面板 Drawer */
+  onOpenFilterDrawer?: () => void;
+  /** 打开绿幕抠像面板 Drawer */
+  onOpenGreenScreenDrawer?: () => void;
+  /** 打开贴纸面板 Drawer */
+  onOpenStickerDrawer?: () => void;
+  /** 打开封面选择器 Drawer */
+  onOpenCoverDrawer?: () => void;
 }
 
 const POSITION_OPTIONS = [
@@ -78,14 +100,6 @@ const ANIMATION_OPTIONS = [
   { value: "typewriter", label: "打字机" },
 ];
 
-const BGM_OPTIONS = [
-  { value: "none", label: "无背景音乐" },
-  { value: "bgm_01", label: "🎵 轻快节奏" },
-  { value: "bgm_02", label: "🎵 温馨舒缓" },
-  { value: "bgm_03", label: "🎵 动感活力" },
-  { value: "bgm_04", label: "🎵 科技感" },
-];
-
 /**
  * 标题样式预设 — 纯样式组合（颜色+描边+阴影+字重+字号）
  * 不绑定字体，用户可自由搭配任意字体
@@ -272,12 +286,24 @@ const ClipPropertiesPanel: React.FC<ClipPropertiesPanelProps> = ({
   currentMode,
   onTitleSettingsChange,
   onSubtitleSettingsChange,
-  onBgmSettingsChange,
+  onBgmSettingsChange: _onBgmSettingsChange,
   onClipUpdate,
+  onOpenBgmDrawer,
+  onOpenSubtitleDrawer,
   voiceMaterials = [],
   voiceMaterialsLoading = false,
   onRefreshVoiceMaterials,
   onClipVoiceSelect,
+  onOpenTransitionDrawer,
+  onOpenSpeedDrawer,
+  onOpenTtsDrawer,
+  onOpenWatermarkDrawer,
+  onOpenIntroOutroDrawer,
+  onOpenPipDrawer,
+  onOpenFilterDrawer,
+  onOpenGreenScreenDrawer,
+  onOpenStickerDrawer,
+  onOpenCoverDrawer,
 }) => {
   const navigate = useNavigate();
 
@@ -534,15 +560,17 @@ const ClipPropertiesPanel: React.FC<ClipPropertiesPanelProps> = ({
                 <input
                   className="ep-slider"
                   type="range"
-                  min={10}
-                  max={32}
-                  value={subtitleSettings.size}
+                  min={12}
+                  max={48}
+                  value={subtitleSettings.fontSize}
                   onChange={(e) =>
-                    onSubtitleSettingsChange({ size: Number(e.target.value) })
+                    onSubtitleSettingsChange({
+                      fontSize: Number(e.target.value),
+                    })
                   }
                 />
                 <span className="ep-slider-value">
-                  {subtitleSettings.size}px
+                  {subtitleSettings.fontSize}px
                 </span>
               </div>
             </div>
@@ -563,6 +591,16 @@ const ClipPropertiesPanel: React.FC<ClipPropertiesPanelProps> = ({
                 ))}
               </select>
             </div>
+
+            {/* 高级配置按钮 */}
+            {onOpenSubtitleDrawer && (
+              <button
+                className="ep-advanced-btn"
+                onClick={onOpenSubtitleDrawer}
+              >
+                🎨 高级字幕样式配置
+              </button>
+            )}
           </>
         )}
       </div>
@@ -574,20 +612,130 @@ const ClipPropertiesPanel: React.FC<ClipPropertiesPanelProps> = ({
           BGM 设置
         </div>
 
-        <div className="ep-field">
-          <label className="ep-field-label">背景音乐</label>
-          <select
-            className="ep-form-select"
-            value={bgmSettings.music}
-            onChange={(e) => onBgmSettingsChange({ music: e.target.value })}
-          >
-            {BGM_OPTIONS.map((opt) => (
-              <option key={opt.value} value={opt.value}>
-                {opt.label}
-              </option>
-            ))}
-          </select>
+        {bgmSettings.enabled && bgmSettings.music_id ? (
+          <div className="ep-bgm-current">
+            <span className="ep-bgm-current-label">🎵 已选择 BGM</span>
+            <span className="ep-bgm-current-id">{bgmSettings.music_id}</span>
+            {bgmSettings.volume !== undefined && (
+              <span className="ep-bgm-current-vol">
+                音量 {bgmSettings.volume}%
+              </span>
+            )}
+          </div>
+        ) : (
+          <div className="ep-bgm-empty">未选择背景音乐</div>
+        )}
+
+        {onOpenBgmDrawer && (
+          <button className="ep-advanced-btn" onClick={onOpenBgmDrawer}>
+            🎵 {bgmSettings.enabled ? "更换 BGM / 调整混音" : "选择 BGM 音乐"}
+          </button>
+        )}
+      </div>
+
+      {/* ═══ 水印设置 ═══ */}
+      <div className="ep-settings-section">
+        <div className="ep-section-title">
+          <span className="ep-section-icon">🔖</span>
+          水印设置
         </div>
+        {onOpenWatermarkDrawer && (
+          <button className="ep-advanced-btn" onClick={onOpenWatermarkDrawer}>
+            <span className="ep-advanced-btn-icon">🔖</span>
+            <span className="ep-advanced-btn-label">水印配置</span>
+            <span className="ep-advanced-btn-arrow">›</span>
+          </button>
+        )}
+      </div>
+
+      {/* ═══ 片头片尾设置 ═══ */}
+      <div className="ep-settings-section">
+        <div className="ep-section-title">
+          <span className="ep-section-icon">🎬</span>
+          片头片尾
+        </div>
+        {onOpenIntroOutroDrawer && (
+          <button className="ep-advanced-btn" onClick={onOpenIntroOutroDrawer}>
+            <span className="ep-advanced-btn-icon">🎬</span>
+            <span className="ep-advanced-btn-label">片头片尾配置</span>
+            <span className="ep-advanced-btn-arrow">›</span>
+          </button>
+        )}
+      </div>
+
+      {/* ═══ 画中画 ═══ */}
+      <div className="ep-settings-section">
+        <div className="ep-section-title">
+          <span className="ep-section-icon">🖼️</span>
+          画中画
+        </div>
+        {onOpenPipDrawer && (
+          <button className="ep-advanced-btn" onClick={onOpenPipDrawer}>
+            <span className="ep-advanced-btn-icon">🖼️</span>
+            <span className="ep-advanced-btn-label">配置画中画图层</span>
+            <span className="ep-advanced-btn-arrow">›</span>
+          </button>
+        )}
+      </div>
+
+      {/* ═══ 滤镜调色 ═══ */}
+      <div className="ep-settings-section">
+        <div className="ep-section-title">
+          <span className="ep-section-icon">🎨</span>
+          滤镜调色
+        </div>
+        {onOpenFilterDrawer && (
+          <button className="ep-advanced-btn" onClick={onOpenFilterDrawer}>
+            <span className="ep-advanced-btn-icon">🎨</span>
+            <span className="ep-advanced-btn-label">配置滤镜调色</span>
+            <span className="ep-advanced-btn-arrow">›</span>
+          </button>
+        )}
+      </div>
+
+      {/* ═══ 绿幕抠像 ═══ */}
+      <div className="ep-settings-section">
+        <div className="ep-section-title">
+          <span className="ep-section-icon">🟩</span>
+          绿幕抠像
+        </div>
+        {onOpenGreenScreenDrawer && (
+          <button className="ep-advanced-btn" onClick={onOpenGreenScreenDrawer}>
+            <span className="ep-advanced-btn-icon">🟩</span>
+            <span className="ep-advanced-btn-label">配置绿幕抠像</span>
+            <span className="ep-advanced-btn-arrow">›</span>
+          </button>
+        )}
+      </div>
+
+      {/* ═══ 贴纸 ═══ */}
+      <div className="ep-settings-section">
+        <div className="ep-section-title">
+          <span className="ep-section-icon">🏷️</span>
+          贴纸
+        </div>
+        {onOpenStickerDrawer && (
+          <button className="ep-advanced-btn" onClick={onOpenStickerDrawer}>
+            <span className="ep-advanced-btn-icon">🏷️</span>
+            <span className="ep-advanced-btn-label">配置贴纸花字</span>
+            <span className="ep-advanced-btn-arrow">›</span>
+          </button>
+        )}
+      </div>
+
+      {/* ═══ 封面 ═══ */}
+      <div className="ep-settings-section">
+        <div className="ep-section-title">
+          <span className="ep-section-icon">🖼️</span>
+          封面
+        </div>
+        {onOpenCoverDrawer && (
+          <button className="ep-advanced-btn" onClick={onOpenCoverDrawer}>
+            <span className="ep-advanced-btn-icon">🖼️</span>
+            <span className="ep-advanced-btn-label">选择视频封面</span>
+            <span className="ep-advanced-btn-arrow">›</span>
+          </button>
+        )}
       </div>
 
       {/* ═══ 片段详情（选中时显示） ═══ */}
@@ -649,6 +797,71 @@ const ClipPropertiesPanel: React.FC<ClipPropertiesPanelProps> = ({
               </div>
             </div>
 
+            {/* 转场效果入口 */}
+            {onOpenTransitionDrawer && (
+              <div className="ep-clip-detail-field">
+                <button
+                  className="ep-advanced-btn ep-advanced-btn--transition"
+                  onClick={() => onOpenTransitionDrawer(selectedClip.id)}
+                >
+                  <span className="ep-advanced-btn-icon">🎬</span>
+                  <span className="ep-advanced-btn-label">转场效果</span>
+                  <span className="ep-advanced-btn-value">
+                    {(() => {
+                      const t = selectedClip.transition;
+                      if (!t || t.type === "none") return "无转场";
+                      const opt = TRANSITION_OPTIONS.find(
+                        (o) => o.value === t.type,
+                      );
+                      return `${opt?.label ?? t.type} · ${t.duration.toFixed(1)}s`;
+                    })()}
+                  </span>
+                  <span className="ep-advanced-btn-arrow">›</span>
+                </button>
+              </div>
+            )}
+
+            {/* 播放速度入口 */}
+            {onOpenSpeedDrawer && (
+              <div className="ep-clip-detail-field">
+                <button
+                  className="ep-advanced-btn ep-advanced-btn--speed"
+                  onClick={() => onOpenSpeedDrawer(selectedClip.id)}
+                >
+                  <span className="ep-advanced-btn-icon">⚡</span>
+                  <span className="ep-advanced-btn-label">播放速度</span>
+                  <span className="ep-advanced-btn-value">
+                    {selectedClip.speed
+                      ? `${selectedClip.speed.rate.toFixed(2)}x`
+                      : "1.00x"}
+                  </span>
+                  <span className="ep-advanced-btn-arrow">›</span>
+                </button>
+              </div>
+            )}
+
+            {/* TTS 配音入口 */}
+            {onOpenTtsDrawer && (
+              <div className="ep-clip-detail-field">
+                <button
+                  className="ep-advanced-btn ep-advanced-btn--tts"
+                  onClick={() => onOpenTtsDrawer(selectedClip.id)}
+                >
+                  <span className="ep-advanced-btn-icon">🎙️</span>
+                  <span className="ep-advanced-btn-label">TTS 配音</span>
+                  <span className="ep-advanced-btn-value">
+                    {(() => {
+                      const tts = selectedClip.tts_config;
+                      if (!tts || tts.mode === "none") return "无配音";
+                      if (tts.mode === "upload") return "上传配音";
+                      return `TTS · ${tts.voice_id ? "已选音色" : "未选音色"}`;
+                    })()}
+                  </span>
+                  <span className="ep-advanced-btn-arrow">›</span>
+                </button>
+              </div>
+            )}
+
             {/* 素材起始时间 — 仅 voice 类型显示 */}
             {selectedClip.type === "voice" && (
               <div className="ep-clip-detail-field">

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

@@ -0,0 +1,301 @@
+/**
+ * 封面选择器
+ * 抽帧选封面 + 上传自定义封面 + 智能封面推荐
+ */
+import React, { useCallback, useRef, useState } from "react";
+import { Drawer } from "antd";
+import type { CoverConfig, CoverMode } from "../types";
+import { DEFAULT_COVER_CONFIG } from "../types";
+
+interface CoverSelectorProps {
+  open: boolean;
+  onClose: () => void;
+  config: CoverConfig;
+  onChange: (config: CoverConfig) => void;
+  totalDuration: number;
+}
+
+/** 封面模式标签 */
+const MODE_LABELS: Record<CoverMode, string> = {
+  auto: "智能封面",
+  frame: "抽帧选封面",
+  upload: "上传封面",
+};
+
+/** 封面模式图标 */
+const MODE_ICONS: Record<CoverMode, string> = {
+  auto: "🤖",
+  frame: "🎞️",
+  upload: "📤",
+};
+
+const CoverSelector: React.FC<CoverSelectorProps> = ({
+  open,
+  onClose,
+  config,
+  onChange,
+  totalDuration,
+}) => {
+  const fileInputRef = useRef<HTMLInputElement>(null);
+  const [isDragging, setIsDragging] = useState(false);
+
+  const update = useCallback(
+    (partial: Partial<CoverConfig>) => {
+      onChange({ ...config, ...partial });
+    },
+    [config, onChange],
+  );
+
+  const handleReset = useCallback(() => {
+    onChange({ ...DEFAULT_COVER_CONFIG, enabled: config.enabled });
+  }, [config.enabled, onChange]);
+
+  /** 切换模式 */
+  const handleModeChange = useCallback(
+    (mode: CoverMode) => {
+      update({ mode });
+    },
+    [update],
+  );
+
+  /** 处理文件上传 */
+  const handleFileUpload = useCallback(
+    (file: File) => {
+      if (!file.type.startsWith("image/")) return;
+      const reader = new FileReader();
+      reader.onload = (e) => {
+        const url = e.target?.result as string;
+        update({ upload_url: url, thumbnail_url: url, mode: "upload" });
+      };
+      reader.readAsDataURL(file);
+    },
+    [update],
+  );
+
+  /** 拖拽上传 */
+  const handleDrop = useCallback(
+    (e: React.DragEvent) => {
+      e.preventDefault();
+      setIsDragging(false);
+      const file = e.dataTransfer.files[0];
+      if (file) handleFileUpload(file);
+    },
+    [handleFileUpload],
+  );
+
+  /** 使用 AI 推荐时间 */
+  const handleUseAiSuggestion = useCallback(() => {
+    if (config.ai_suggested_time !== null) {
+      update({ frame_time: config.ai_suggested_time, mode: "frame" });
+    }
+  }, [config.ai_suggested_time, update]);
+
+  /** 格式化时间 */
+  const formatTime = (seconds: number) => {
+    const m = Math.floor(seconds / 60);
+    const s = Math.floor(seconds % 60);
+    const ms = Math.floor((seconds % 1) * 10);
+    return `${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")}.${ms}`;
+  };
+
+  return (
+    <Drawer
+      title="封面选择"
+      placement="right"
+      width={440}
+      open={open}
+      onClose={onClose}
+      className="cover-selector-drawer"
+    >
+      {/* 顶部开关 */}
+      <div className="cover-header">
+        <span className="cover-header-label">启用自定义封面</span>
+        <label className="cover-switch">
+          <input
+            type="checkbox"
+            checked={config.enabled}
+            onChange={(e) => update({ enabled: e.target.checked })}
+          />
+          <span className="cover-switch-slider" />
+        </label>
+      </div>
+
+      {/* 模式选择 */}
+      <div className="cover-mode-section">
+        <div className="cover-section-title">封面来源</div>
+        <div className="cover-mode-tabs">
+          {(["auto", "frame", "upload"] as CoverMode[]).map((m) => (
+            <button
+              key={m}
+              className={`cover-mode-tab${config.mode === m ? " active" : ""}`}
+              onClick={() => handleModeChange(m)}
+            >
+              <span className="cover-mode-icon">{MODE_ICONS[m]}</span>
+              <span className="cover-mode-label">{MODE_LABELS[m]}</span>
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* 模式内容区 */}
+      <div className="cover-mode-content">
+        {/* 智能封面 */}
+        {config.mode === "auto" && (
+          <div className="cover-auto-section">
+            <div className="cover-auto-desc">
+              AI 将分析视频内容，自动选择最具吸引力的画面作为封面。
+            </div>
+            {config.ai_suggested_time !== null ? (
+              <div className="cover-auto-suggestion">
+                <div className="cover-auto-badge">AI 推荐</div>
+                <div className="cover-auto-time">
+                  推荐时间点：{formatTime(config.ai_suggested_time)}
+                </div>
+                <button
+                  className="cover-auto-use-btn"
+                  onClick={handleUseAiSuggestion}
+                >
+                  使用此时间点
+                </button>
+              </div>
+            ) : (
+              <div className="cover-auto-pending">
+                <div className="cover-auto-spinner" />
+                <span>AI 分析中...（生成视频后自动推荐）</span>
+              </div>
+            )}
+          </div>
+        )}
+
+        {/* 抽帧选封面 */}
+        {config.mode === "frame" && (
+          <div className="cover-frame-section">
+            <div className="cover-frame-preview">
+              <div className="cover-frame-placeholder">
+                <span className="cover-frame-icon">🎞️</span>
+                <span className="cover-frame-time">
+                  {formatTime(config.frame_time)}
+                </span>
+              </div>
+            </div>
+            <div className="cover-frame-timeline">
+              <div className="cover-frame-slider-header">
+                <span className="cover-frame-slider-label">拖动选择封面帧</span>
+                <span className="cover-frame-slider-value">
+                  {formatTime(config.frame_time)}
+                </span>
+              </div>
+              <input
+                type="range"
+                className="cover-frame-slider"
+                min={0}
+                max={Math.max(totalDuration, 1)}
+                step={0.1}
+                value={config.frame_time}
+                onChange={(e) => update({ frame_time: Number(e.target.value) })}
+              />
+              <div className="cover-frame-range">
+                <span>00:00</span>
+                <span>{formatTime(totalDuration)}</span>
+              </div>
+            </div>
+            {/* 快捷时间点 */}
+            <div className="cover-frame-quick">
+              <span className="cover-quick-label">快捷选帧：</span>
+              {[0, 0.25, 0.5, 0.75].map((ratio) => {
+                const t = totalDuration * ratio;
+                return (
+                  <button
+                    key={ratio}
+                    className="cover-quick-btn"
+                    onClick={() => update({ frame_time: t })}
+                  >
+                    {formatTime(t)}
+                  </button>
+                );
+              })}
+            </div>
+          </div>
+        )}
+
+        {/* 上传封面 */}
+        {config.mode === "upload" && (
+          <div className="cover-upload-section">
+            <div
+              className={`cover-upload-area${isDragging ? " dragging" : ""}`}
+              onDragOver={(e) => {
+                e.preventDefault();
+                setIsDragging(true);
+              }}
+              onDragLeave={() => setIsDragging(false)}
+              onDrop={handleDrop}
+              onClick={() => fileInputRef.current?.click()}
+            >
+              {config.upload_url ? (
+                <div className="cover-upload-preview">
+                  <img src={config.upload_url} alt="封面预览" />
+                  <div className="cover-upload-overlay">点击更换</div>
+                </div>
+              ) : (
+                <div className="cover-upload-placeholder">
+                  <span className="cover-upload-icon">📤</span>
+                  <span className="cover-upload-text">
+                    点击或拖拽上传封面图片
+                  </span>
+                  <span className="cover-upload-hint">
+                    支持 JPG / PNG，建议 16:9 比例
+                  </span>
+                </div>
+              )}
+              <input
+                ref={fileInputRef}
+                type="file"
+                accept="image/*"
+                style={{ display: "none" }}
+                onChange={(e) => {
+                  const file = e.target.files?.[0];
+                  if (file) handleFileUpload(file);
+                }}
+              />
+            </div>
+          </div>
+        )}
+      </div>
+
+      {/* 封面预览 */}
+      <div className="cover-preview-section">
+        <div className="cover-section-title">封面预览</div>
+        <div className="cover-preview-box">
+          {config.upload_url ? (
+            <img
+              src={config.upload_url}
+              alt="封面预览"
+              className="cover-preview-img"
+            />
+          ) : (
+            <div className="cover-preview-placeholder">
+              <span className="cover-preview-icon">🖼️</span>
+              <span className="cover-preview-text">
+                {config.mode === "auto"
+                  ? "AI 智能选择"
+                  : config.mode === "frame"
+                    ? `帧 ${formatTime(config.frame_time)}`
+                    : "未上传封面"}
+              </span>
+            </div>
+          )}
+          <div className="cover-preview-ratio">16:9</div>
+        </div>
+      </div>
+
+      {/* 底部 */}
+      <div className="cover-footer">
+        <button className="cover-reset-btn" onClick={handleReset}>
+          重置封面
+        </button>
+      </div>
+    </Drawer>
+  );
+};
+
+export default CoverSelector;

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

@@ -0,0 +1,168 @@
+/**
+ * 编辑器右侧栏 — 片段列表 Tab
+ * 紧凑版片段管理：选中、上下移动、删除、添加
+ */
+import React from "react";
+import { Button, Tooltip, Empty } from "antd";
+import {
+  UpOutlined,
+  DownOutlined,
+  DeleteOutlined,
+  PlusOutlined,
+  ScissorOutlined,
+  SoundOutlined,
+  PictureOutlined,
+  VideoCameraOutlined,
+} from "@ant-design/icons";
+import type { ClipData, ClipType } from "../types";
+
+interface EditorClipListProps {
+  clips: ClipData[];
+  selectedClipId: string | null;
+  onSelect: (clipId: string) => void;
+  onMoveUp: (clipId: string) => void;
+  onMoveDown: (clipId: string) => void;
+  onRemove: (clipId: string) => void;
+  onAdd: () => void;
+}
+
+const clipTypeIcon: Record<ClipType | string, React.ReactNode> = {
+  video: <VideoCameraOutlined />,
+  image: <PictureOutlined />,
+  voice: <SoundOutlined />,
+  pip: <ScissorOutlined />,
+};
+
+const clipTypeLabel: Record<ClipType | string, string> = {
+  video: "视频",
+  image: "图片",
+  voice: "配音",
+  pip: "画中画",
+};
+
+const formatDuration = (sec: number) => {
+  if (sec < 60) return `${sec.toFixed(1)}s`;
+  const m = Math.floor(sec / 60);
+  const s = (sec % 60).toFixed(0);
+  return `${m}m${s.padStart(2, "0")}s`;
+};
+
+const EditorClipList: React.FC<EditorClipListProps> = ({
+  clips,
+  selectedClipId,
+  onSelect,
+  onMoveUp,
+  onMoveDown,
+  onRemove,
+  onAdd,
+}) => {
+  if (clips.length === 0) {
+    return (
+      <div className="ep-clip-list-empty">
+        <Empty
+          description="暂无片段"
+          image={Empty.PRESENTED_IMAGE_SIMPLE}
+          style={{ margin: "40px 0" }}
+        />
+        <Button type="primary" icon={<PlusOutlined />} block onClick={onAdd}>
+          添加片段
+        </Button>
+      </div>
+    );
+  }
+
+  return (
+    <div className="ep-clip-list">
+      {/* 顶部工具栏 */}
+      <div className="ep-clip-list-toolbar">
+        <span className="ep-clip-list-count">
+          共 <b>{clips.length}</b> 个片段
+        </span>
+        <Tooltip title="添加片段">
+          <Button
+            type="primary"
+            size="small"
+            icon={<PlusOutlined />}
+            onClick={onAdd}
+          >
+            添加
+          </Button>
+        </Tooltip>
+      </div>
+
+      {/* 片段列表 */}
+      <div className="ep-clip-list-scroll">
+        {clips.map((clip, index) => (
+          <div
+            key={clip.id}
+            className={`ep-clip-list-item${
+              selectedClipId === clip.id ? " selected" : ""
+            }`}
+            onClick={() => onSelect(clip.id)}
+          >
+            {/* 序号 + 类型图标 */}
+            <div className="ep-clip-item-head">
+              <span className="ep-clip-item-index">{index + 1}</span>
+              <span className="ep-clip-item-type">
+                {clipTypeIcon[clip.type] || <ScissorOutlined />}
+                <span className="ep-clip-item-type-label">
+                  {clipTypeLabel[clip.type] || "片段"}
+                </span>
+              </span>
+              <span className="ep-clip-item-duration">
+                {formatDuration(clip.duration)}
+              </span>
+            </div>
+
+            {/* 文案预览 */}
+            {clip.script_text && (
+              <div className="ep-clip-item-text">
+                {clip.script_text.slice(0, 40)}
+                {clip.script_text.length > 40 ? "..." : ""}
+              </div>
+            )}
+
+            {/* 操作按钮 */}
+            <div
+              className="ep-clip-item-actions"
+              onClick={(e) => e.stopPropagation()}
+            >
+              <Tooltip title="上移">
+                <Button
+                  type="text"
+                  size="small"
+                  icon={<UpOutlined />}
+                  disabled={index === 0}
+                  onClick={() => onMoveUp(clip.id)}
+                  className="ep-clip-item-btn"
+                />
+              </Tooltip>
+              <Tooltip title="下移">
+                <Button
+                  type="text"
+                  size="small"
+                  icon={<DownOutlined />}
+                  disabled={index === clips.length - 1}
+                  onClick={() => onMoveDown(clip.id)}
+                  className="ep-clip-item-btn"
+                />
+              </Tooltip>
+              <Tooltip title="删除">
+                <Button
+                  type="text"
+                  size="small"
+                  danger
+                  icon={<DeleteOutlined />}
+                  onClick={() => onRemove(clip.id)}
+                  className="ep-clip-item-btn"
+                />
+              </Tooltip>
+            </div>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+};
+
+export default EditorClipList;

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

@@ -0,0 +1,234 @@
+/**
+ * 滤镜调色配置面板
+ * 预设滤镜 + 手动调节（亮度/对比度/饱和度/色温/色调/锐度）
+ */
+import React, { useCallback } from "react";
+import { Drawer, Switch } from "antd";
+import type { FilterConfig, FilterPreset } from "../types";
+import { DEFAULT_FILTER_CONFIG, FILTER_PRESET_LABELS } from "../types";
+
+interface FilterPanelProps {
+  open: boolean;
+  onClose: () => void;
+  config: FilterConfig;
+  onChange: (config: FilterConfig) => void;
+}
+
+/** 所有预设列表 */
+const PRESET_LIST: FilterPreset[] = [
+  "none",
+  "original",
+  "fresh",
+  "warm",
+  "cool",
+  "vintage",
+  "cinema",
+  "bw",
+  "sunshine",
+  "film",
+];
+
+/** 预设对应的示例渐变色（用于视觉预览） */
+const PRESET_GRADIENTS: Record<FilterPreset, string> = {
+  none: "linear-gradient(135deg, #667eea 0%, #764ba2 100%)",
+  original: "linear-gradient(135deg, #667eea 0%, #764ba2 100%)",
+  fresh: "linear-gradient(135deg, #a8edea 0%, #fed6e3 100%)",
+  warm: "linear-gradient(135deg, #f093fb 0%, #f5576c 100%)",
+  cool: "linear-gradient(135deg, #4facfe 0%, #00f2fe 100%)",
+  vintage: "linear-gradient(135deg, #c79081 0%, #dfa579 100%)",
+  cinema: "linear-gradient(135deg, #2c3e50 0%, #4ca1af 100%)",
+  bw: "linear-gradient(135deg, #434343 0%, #000000 100%)",
+  sunshine: "linear-gradient(135deg, #f6d365 0%, #fda085 100%)",
+  film: "linear-gradient(135deg, #8e9eab 0%, #eef2f3 100%)",
+};
+
+const FilterPanel: React.FC<FilterPanelProps> = ({
+  open,
+  onClose,
+  config,
+  onChange,
+}) => {
+  const update = useCallback(
+    (partial: Partial<FilterConfig>) => {
+      onChange({ ...config, ...partial });
+    },
+    [config, onChange],
+  );
+
+  const handleReset = useCallback(() => {
+    onChange({ ...DEFAULT_FILTER_CONFIG, enabled: config.enabled });
+  }, [config.enabled, onChange]);
+
+  /** 选择预设时重置手动参数 */
+  const handlePresetSelect = useCallback(
+    (preset: FilterPreset) => {
+      if (preset === "none") {
+        onChange({ ...DEFAULT_FILTER_CONFIG, enabled: config.enabled });
+      } else {
+        onChange({
+          ...DEFAULT_FILTER_CONFIG,
+          enabled: config.enabled,
+          preset,
+        });
+      }
+    },
+    [config.enabled, onChange],
+  );
+
+  return (
+    <Drawer
+      title="滤镜调色"
+      placement="right"
+      width={420}
+      open={open}
+      onClose={onClose}
+      className="filter-panel-drawer"
+    >
+      {/* 顶部开关 */}
+      <div className="filter-header">
+        <span className="filter-header-label">启用滤镜</span>
+        <Switch
+          size="small"
+          checked={config.enabled}
+          onChange={(checked) => update({ enabled: checked })}
+        />
+      </div>
+
+      {/* 预设滤镜选择 */}
+      <div className="filter-section">
+        <div className="filter-section-title">预设滤镜</div>
+        <div className="filter-presets">
+          {PRESET_LIST.map((p) => (
+            <button
+              key={p}
+              className={`filter-preset-item${config.preset === p ? " active" : ""}`}
+              onClick={() => handlePresetSelect(p)}
+            >
+              <div
+                className="filter-preset-preview"
+                style={{ background: PRESET_GRADIENTS[p] }}
+              />
+              <span className="filter-preset-label">
+                {FILTER_PRESET_LABELS[p]}
+              </span>
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* 手动调节 */}
+      <div className="filter-section">
+        <div className="filter-section-title">手动调节</div>
+
+        {/* 亮度 */}
+        <div className="filter-slider-row">
+          <span className="filter-slider-label">亮度</span>
+          <input
+            type="range"
+            className="filter-slider"
+            min={-100}
+            max={100}
+            value={config.brightness}
+            onChange={(e) => update({ brightness: Number(e.target.value) })}
+          />
+          <span className="filter-slider-value">{config.brightness}</span>
+        </div>
+
+        {/* 对比度 */}
+        <div className="filter-slider-row">
+          <span className="filter-slider-label">对比度</span>
+          <input
+            type="range"
+            className="filter-slider"
+            min={-100}
+            max={100}
+            value={config.contrast}
+            onChange={(e) => update({ contrast: Number(e.target.value) })}
+          />
+          <span className="filter-slider-value">{config.contrast}</span>
+        </div>
+
+        {/* 饱和度 */}
+        <div className="filter-slider-row">
+          <span className="filter-slider-label">饱和度</span>
+          <input
+            type="range"
+            className="filter-slider"
+            min={-100}
+            max={100}
+            value={config.saturation}
+            onChange={(e) => update({ saturation: Number(e.target.value) })}
+          />
+          <span className="filter-slider-value">{config.saturation}</span>
+        </div>
+
+        {/* 色温 */}
+        <div className="filter-slider-row">
+          <span className="filter-slider-label">色温</span>
+          <input
+            type="range"
+            className="filter-slider"
+            min={-100}
+            max={100}
+            value={config.temperature}
+            onChange={(e) => update({ temperature: Number(e.target.value) })}
+          />
+          <span className="filter-slider-value">{config.temperature}</span>
+        </div>
+
+        {/* 色调 */}
+        <div className="filter-slider-row">
+          <span className="filter-slider-label">色调</span>
+          <input
+            type="range"
+            className="filter-slider"
+            min={-100}
+            max={100}
+            value={config.tint}
+            onChange={(e) => update({ tint: Number(e.target.value) })}
+          />
+          <span className="filter-slider-value">{config.tint}</span>
+        </div>
+
+        {/* 锐度 */}
+        <div className="filter-slider-row">
+          <span className="filter-slider-label">锐度</span>
+          <input
+            type="range"
+            className="filter-slider"
+            min={0}
+            max={100}
+            value={config.sharpness}
+            onChange={(e) => update({ sharpness: Number(e.target.value) })}
+          />
+          <span className="filter-slider-value">{config.sharpness}</span>
+        </div>
+      </div>
+
+      {/* 预览色块 */}
+      <div className="filter-section">
+        <div className="filter-section-title">效果预览</div>
+        <div
+          className="filter-preview-block"
+          style={{
+            background: PRESET_GRADIENTS[config.preset],
+            filter: [
+              `brightness(${100 + config.brightness}%)`,
+              `contrast(${100 + config.contrast}%)`,
+              `saturate(${100 + config.saturation}%)`,
+            ].join(" "),
+          }}
+        />
+      </div>
+
+      {/* 底部重置 */}
+      <div className="filter-footer">
+        <button className="filter-reset-btn" onClick={handleReset}>
+          重置参数
+        </button>
+      </div>
+    </Drawer>
+  );
+};
+
+export default FilterPanel;

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

@@ -12,6 +12,8 @@ interface GenerationHistoryModalProps {
   loading: boolean;
   history: EditPlanGeneration[];
   onClose: () => void;
+  onCancel?: (taskId: string) => void;
+  cancelLoading?: boolean;
 }
 
 const GenerationHistoryModal: React.FC<GenerationHistoryModalProps> = ({
@@ -19,6 +21,8 @@ const GenerationHistoryModal: React.FC<GenerationHistoryModalProps> = ({
   loading,
   history,
   onClose,
+  onCancel,
+  cancelLoading,
 }) => {
   if (!open) return null;
 
@@ -57,15 +61,18 @@ const GenerationHistoryModal: React.FC<GenerationHistoryModalProps> = ({
                   <th className="ep-gh-th">状态</th>
                   <th className="ep-gh-th">创建时间</th>
                   <th className="ep-gh-th">更新时间</th>
+                  {onCancel && <th className="ep-gh-th">操作</th>}
                 </tr>
               </thead>
               <tbody>
                 {history.map((gen) => {
                   const statusClass = `ep-gh-status-tag--${gen.status}`;
+                  const canCancel =
+                    gen.status === "rendering" || gen.status === "editing";
                   return (
                     <tr key={gen.id} className="ep-gh-table-row">
                       <td className="ep-gh-td ep-gh-td-id">
-                        {gen.generation_task_id.slice(0, 8)}...
+                        {gen.id ? `${gen.id.slice(0, 8)}...` : "—"}
                       </td>
                       <td className="ep-gh-td">
                         <span className={`ep-gh-status-tag ${statusClass}`}>
@@ -82,6 +89,21 @@ const GenerationHistoryModal: React.FC<GenerationHistoryModalProps> = ({
                           ? new Date(gen.updated_at).toLocaleString("zh-CN")
                           : "—"}
                       </td>
+                      {onCancel && (
+                        <td className="ep-gh-td ep-gh-td-action">
+                          {canCancel ? (
+                            <button
+                              className="ep-gh-cancel-btn"
+                              onClick={() => onCancel(gen.id)}
+                              disabled={cancelLoading}
+                            >
+                              取消
+                            </button>
+                          ) : (
+                            <span className="ep-gh-action-placeholder">—</span>
+                          )}
+                        </td>
+                      )}
                     </tr>
                   );
                 })}

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

@@ -0,0 +1,219 @@
+/**
+ * 绿幕抠像配置面板
+ * 5 种颜色预设 + 自定义颜色 + 相似度/边缘平滑/溢色抑制
+ */
+import React, { useCallback } from "react";
+import { Drawer, Switch } from "antd";
+import type { ChromaKeyConfig, ChromaKeyColorPreset } from "../types";
+import {
+  DEFAULT_CHROMA_KEY_CONFIG,
+  CHROMA_KEY_PRESET_LABELS,
+  CHROMA_KEY_PRESET_COLORS,
+} from "../types";
+
+interface GreenScreenPanelProps {
+  open: boolean;
+  onClose: () => void;
+  config: ChromaKeyConfig;
+  onChange: (config: ChromaKeyConfig) => void;
+}
+
+/** 预设列表 */
+const PRESET_LIST: ChromaKeyColorPreset[] = [
+  "green",
+  "blue",
+  "red",
+  "pure_green",
+  "soft_green",
+];
+
+const GreenScreenPanel: React.FC<GreenScreenPanelProps> = ({
+  open,
+  onClose,
+  config,
+  onChange,
+}) => {
+  const update = useCallback(
+    (partial: Partial<ChromaKeyConfig>) => {
+      onChange({ ...config, ...partial });
+    },
+    [config, onChange],
+  );
+
+  const handleReset = useCallback(() => {
+    onChange({ ...DEFAULT_CHROMA_KEY_CONFIG, enabled: config.enabled });
+  }, [config.enabled, onChange]);
+
+  /** 选择颜色预设时同步更新 color 字段 */
+  const handlePresetSelect = useCallback(
+    (preset: ChromaKeyColorPreset) => {
+      update({
+        color_preset: preset,
+        color: CHROMA_KEY_PRESET_COLORS[preset],
+      });
+    },
+    [update],
+  );
+
+  /** 自定义颜色变化时清除预设标记 */
+  const handleColorChange = useCallback(
+    (e: React.ChangeEvent<HTMLInputElement>) => {
+      update({ color: e.target.value });
+    },
+    [update],
+  );
+
+  return (
+    <Drawer
+      title="绿幕抠像"
+      placement="right"
+      width={420}
+      open={open}
+      onClose={onClose}
+      className="green-screen-panel-drawer"
+    >
+      {/* 顶部开关 */}
+      <div className="green-header">
+        <span className="green-header-label">启用绿幕抠像</span>
+        <Switch
+          size="small"
+          checked={config.enabled}
+          onChange={(checked) => update({ enabled: checked })}
+        />
+      </div>
+
+      {/* 颜色预设 */}
+      <div className="green-section">
+        <div className="green-section-title">颜色预设</div>
+        <div className="green-presets">
+          {PRESET_LIST.map((p) => (
+            <button
+              key={p}
+              className={`green-preset-btn${config.color_preset === p ? " active" : ""}`}
+              onClick={() => handlePresetSelect(p)}
+            >
+              <span
+                className="green-preset-dot"
+                style={{ background: CHROMA_KEY_PRESET_COLORS[p] }}
+              />
+              <span className="green-preset-label">
+                {CHROMA_KEY_PRESET_LABELS[p]}
+              </span>
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* 自定义颜色 */}
+      <div className="green-section">
+        <div className="green-section-title">自定义颜色</div>
+        <div className="green-color-row">
+          <input
+            type="color"
+            className="green-color-picker"
+            value={config.color}
+            onChange={handleColorChange}
+          />
+          <input
+            type="text"
+            className="green-color-hex"
+            value={config.color}
+            onChange={handleColorChange}
+            placeholder="#00FF00"
+          />
+          <div
+            className="green-color-swatch"
+            style={{ background: config.color }}
+          />
+        </div>
+      </div>
+
+      {/* 参数调节 */}
+      <div className="green-section">
+        <div className="green-section-title">参数调节</div>
+
+        {/* 相似度 */}
+        <div className="green-slider-row">
+          <div className="green-slider-header">
+            <span className="green-slider-label">相似度</span>
+            <span className="green-slider-value">{config.similarity}%</span>
+          </div>
+          <input
+            type="range"
+            className="green-slider"
+            min={0}
+            max={100}
+            value={config.similarity}
+            onChange={(e) => update({ similarity: Number(e.target.value) })}
+          />
+          <div className="green-slider-desc">越大容忍的色差范围越广</div>
+        </div>
+
+        {/* 边缘平滑 */}
+        <div className="green-slider-row">
+          <div className="green-slider-header">
+            <span className="green-slider-label">边缘平滑</span>
+            <span className="green-slider-value">{config.blend}%</span>
+          </div>
+          <input
+            type="range"
+            className="green-slider"
+            min={0}
+            max={100}
+            value={config.blend}
+            onChange={(e) => update({ blend: Number(e.target.value) })}
+          />
+          <div className="green-slider-desc">越大边缘越柔和自然</div>
+        </div>
+
+        {/* 溢色抑制 */}
+        <div className="green-slider-row">
+          <div className="green-slider-header">
+            <span className="green-slider-label">溢色抑制</span>
+            <span className="green-slider-value">{config.spill}%</span>
+          </div>
+          <input
+            type="range"
+            className="green-slider"
+            min={0}
+            max={100}
+            value={config.spill}
+            onChange={(e) => update({ spill: Number(e.target.value) })}
+          />
+          <div className="green-slider-desc">去除边缘颜色溢出</div>
+        </div>
+      </div>
+
+      {/* 预览 */}
+      <div className="green-section">
+        <div className="green-section-title">效果预览</div>
+        <div className="green-preview-box">
+          <div
+            className="green-preview-bg"
+            style={{ background: config.color, opacity: 0.3 }}
+          />
+          <div className="green-preview-subject">
+            <div className="green-preview-circle" />
+            <div className="green-preview-text">主体</div>
+          </div>
+          <div
+            className="green-preview-edge"
+            style={{
+              borderColor: config.color,
+              filter: `blur(${config.blend / 10}px)`,
+            }}
+          />
+        </div>
+      </div>
+
+      {/* 底部重置 */}
+      <div className="green-footer">
+        <button className="green-reset-btn" onClick={handleReset}>
+          重置参数
+        </button>
+      </div>
+    </Drawer>
+  );
+};
+
+export default GreenScreenPanel;

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

@@ -0,0 +1,309 @@
+/**
+ * 片头片尾配置面板 — Drawer 形式
+ * 两个区块：片头（Intro）/ 片尾（Outro）
+ * 每个区块支持：类型选择（无/视频/图片）、素材 URL、时长、过渡动画
+ */
+import React, { useCallback } from "react";
+import { Drawer } from "antd";
+import type {
+  IntroOutroConfig,
+  IntroOutroItem,
+  IntroOutroKind,
+  TransitionType,
+} from "../types";
+import { DEFAULT_INTRO_OUTRO } from "../types";
+import { TRANSITION_OPTIONS } from "@/api/editPlans";
+
+/* ──────────── 常量 ──────────── */
+
+const KIND_OPTIONS: { value: IntroOutroKind; label: string; icon: string }[] = [
+  { value: "none", label: "无", icon: "🚫" },
+  { value: "video", label: "视频", icon: "🎬" },
+  { value: "image", label: "图片", icon: "🖼️" },
+];
+
+/* ──────────── Props ──────────── */
+interface IntroOutroPanelProps {
+  open: boolean;
+  onClose: () => void;
+  config: IntroOutroConfig;
+  onChange: (config: IntroOutroConfig) => void;
+}
+
+const IntroOutroPanel: React.FC<IntroOutroPanelProps> = ({
+  open,
+  onClose,
+  config,
+  onChange,
+}) => {
+  /* ── 更新片头 ── */
+  const handleIntroChange = useCallback(
+    (partial: Partial<IntroOutroItem>) => {
+      onChange({ ...config, intro: { ...config.intro, ...partial } });
+    },
+    [config, onChange],
+  );
+
+  /* ── 更新片尾 ── */
+  const handleOutroChange = useCallback(
+    (partial: Partial<IntroOutroItem>) => {
+      onChange({ ...config, outro: { ...config.outro, ...partial } });
+    },
+    [config, onChange],
+  );
+
+  /* ── 切换片头类型 ── */
+  const handleIntroKindChange = useCallback(
+    (kind: IntroOutroKind) => {
+      handleIntroChange({ kind, url: kind === "none" ? undefined : "" });
+    },
+    [handleIntroChange],
+  );
+
+  /* ── 切换片尾类型 ── */
+  const handleOutroKindChange = useCallback(
+    (kind: IntroOutroKind) => {
+      handleOutroChange({ kind, url: kind === "none" ? undefined : "" });
+    },
+    [handleOutroChange],
+  );
+
+  /* ── 重置 ── */
+  const handleReset = useCallback(() => {
+    onChange({ ...DEFAULT_INTRO_OUTRO });
+  }, [onChange]);
+
+  return (
+    <Drawer
+      title="🎬 片头片尾设置"
+      placement="right"
+      width={420}
+      open={open}
+      onClose={onClose}
+      className="intro-outro-panel-drawer"
+    >
+      {/* ═══ 片头区块 ═══ */}
+      <div className="iop-block">
+        <div className="iop-block-header">
+          <span className="iop-block-icon">🎞️</span>
+          <span className="iop-block-title">片头</span>
+        </div>
+
+        {/* 类型选择 */}
+        <div className="iop-kind-row">
+          {KIND_OPTIONS.map((opt) => (
+            <button
+              key={opt.value}
+              className={`iop-kind-btn${config.intro.kind === opt.value ? " active" : ""}`}
+              onClick={() => handleIntroKindChange(opt.value)}
+            >
+              <span className="iop-kind-icon">{opt.icon}</span>
+              <span className="iop-kind-label">{opt.label}</span>
+            </button>
+          ))}
+        </div>
+
+        {/* 视频/图片配置 */}
+        {config.intro.kind !== "none" && (
+          <>
+            <div className="iop-field">
+              <label className="iop-field-label">
+                {config.intro.kind === "video" ? "视频" : "图片"} URL
+              </label>
+              <input
+                className="iop-input"
+                type="text"
+                placeholder={
+                  config.intro.kind === "video"
+                    ? "https://example.com/intro.mp4"
+                    : "https://example.com/intro.png"
+                }
+                value={config.intro.url ?? ""}
+                onChange={(e) => handleIntroChange({ url: e.target.value })}
+              />
+            </div>
+
+            <div className="iop-field">
+              <label className="iop-field-label">显示时长</label>
+              <div className="iop-slider-row">
+                <input
+                  className="iop-slider"
+                  type="range"
+                  min={1}
+                  max={15}
+                  step={0.5}
+                  value={config.intro.duration}
+                  onChange={(e) =>
+                    handleIntroChange({ duration: Number(e.target.value) })
+                  }
+                />
+                <span className="iop-slider-value">
+                  {config.intro.duration}s
+                </span>
+              </div>
+            </div>
+
+            <div className="iop-field">
+              <label className="iop-field-label">进入过渡动画</label>
+              <select
+                className="iop-select"
+                value={config.intro.transition ?? "none"}
+                onChange={(e) =>
+                  handleIntroChange({
+                    transition: e.target.value as TransitionType,
+                  })
+                }
+              >
+                {TRANSITION_OPTIONS.map((opt) => (
+                  <option key={opt.value} value={opt.value}>
+                    {opt.label}
+                  </option>
+                ))}
+              </select>
+            </div>
+
+            {config.intro.transition && config.intro.transition !== "none" && (
+              <div className="iop-field">
+                <label className="iop-field-label">过渡时长</label>
+                <div className="iop-slider-row">
+                  <input
+                    className="iop-slider"
+                    type="range"
+                    min={0.3}
+                    max={2.0}
+                    step={0.1}
+                    value={config.intro.transition_duration ?? 0.5}
+                    onChange={(e) =>
+                      handleIntroChange({
+                        transition_duration: Number(e.target.value),
+                      })
+                    }
+                  />
+                  <span className="iop-slider-value">
+                    {(config.intro.transition_duration ?? 0.5).toFixed(1)}s
+                  </span>
+                </div>
+              </div>
+            )}
+          </>
+        )}
+      </div>
+
+      {/* ═══ 片尾区块 ═══ */}
+      <div className="iop-block">
+        <div className="iop-block-header">
+          <span className="iop-block-icon">🏁</span>
+          <span className="iop-block-title">片尾</span>
+        </div>
+
+        {/* 类型选择 */}
+        <div className="iop-kind-row">
+          {KIND_OPTIONS.map((opt) => (
+            <button
+              key={opt.value}
+              className={`iop-kind-btn${config.outro.kind === opt.value ? " active" : ""}`}
+              onClick={() => handleOutroKindChange(opt.value)}
+            >
+              <span className="iop-kind-icon">{opt.icon}</span>
+              <span className="iop-kind-label">{opt.label}</span>
+            </button>
+          ))}
+        </div>
+
+        {/* 视频/图片配置 */}
+        {config.outro.kind !== "none" && (
+          <>
+            <div className="iop-field">
+              <label className="iop-field-label">
+                {config.outro.kind === "video" ? "视频" : "图片"} URL
+              </label>
+              <input
+                className="iop-input"
+                type="text"
+                placeholder={
+                  config.outro.kind === "video"
+                    ? "https://example.com/outro.mp4"
+                    : "https://example.com/outro.png"
+                }
+                value={config.outro.url ?? ""}
+                onChange={(e) => handleOutroChange({ url: e.target.value })}
+              />
+            </div>
+
+            <div className="iop-field">
+              <label className="iop-field-label">显示时长</label>
+              <div className="iop-slider-row">
+                <input
+                  className="iop-slider"
+                  type="range"
+                  min={1}
+                  max={15}
+                  step={0.5}
+                  value={config.outro.duration}
+                  onChange={(e) =>
+                    handleOutroChange({ duration: Number(e.target.value) })
+                  }
+                />
+                <span className="iop-slider-value">
+                  {config.outro.duration}s
+                </span>
+              </div>
+            </div>
+
+            <div className="iop-field">
+              <label className="iop-field-label">退出过渡动画</label>
+              <select
+                className="iop-select"
+                value={config.outro.transition ?? "none"}
+                onChange={(e) =>
+                  handleOutroChange({
+                    transition: e.target.value as TransitionType,
+                  })
+                }
+              >
+                {TRANSITION_OPTIONS.map((opt) => (
+                  <option key={opt.value} value={opt.value}>
+                    {opt.label}
+                  </option>
+                ))}
+              </select>
+            </div>
+
+            {config.outro.transition && config.outro.transition !== "none" && (
+              <div className="iop-field">
+                <label className="iop-field-label">过渡时长</label>
+                <div className="iop-slider-row">
+                  <input
+                    className="iop-slider"
+                    type="range"
+                    min={0.3}
+                    max={2.0}
+                    step={0.1}
+                    value={config.outro.transition_duration ?? 0.5}
+                    onChange={(e) =>
+                      handleOutroChange({
+                        transition_duration: Number(e.target.value),
+                      })
+                    }
+                  />
+                  <span className="iop-slider-value">
+                    {(config.outro.transition_duration ?? 0.5).toFixed(1)}s
+                  </span>
+                </div>
+              </div>
+            )}
+          </>
+        )}
+      </div>
+
+      {/* ── 底部操作 ── */}
+      <div className="iop-footer">
+        <button className="iop-reset-btn" onClick={handleReset}>
+          重置
+        </button>
+      </div>
+    </Drawer>
+  );
+};
+
+export default IntroOutroPanel;

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

@@ -0,0 +1,582 @@
+/**
+ * 画中画配置面板 — Drawer 形式
+ * 左侧图层列表 + 右侧单图层配置 + 迷你预览区
+ */
+import React, { useCallback, useMemo } from "react";
+import { Drawer, Switch } from "antd";
+import type {
+  PipConfig,
+  PipLayer,
+  PipGridPosition,
+  PipAnimType,
+  PipSlideDirection,
+} from "../types";
+import { DEFAULT_PIP_LAYER, DEFAULT_PIP_CONFIG } from "../types";
+
+/* ──────────── 常量 ──────────── */
+
+/** 九宫格位置 → 百分比坐标映射 */
+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 },
+};
+
+/** 九宫格位置选项 */
+const GRID_POSITIONS: PipGridPosition[] = [
+  "top_left",
+  "top_center",
+  "top_right",
+  "center_left",
+  "center",
+  "center_right",
+  "bottom_left",
+  "bottom_center",
+  "bottom_right",
+];
+
+/** 入场动画选项 */
+const ANIM_OPTIONS: { value: PipAnimType; label: string }[] = [
+  { value: "none", label: "无" },
+  { value: "fade_in", label: "淡入" },
+  { value: "slide_in", label: "滑入" },
+];
+
+/** 滑入方向选项 */
+const SLIDE_DIR_OPTIONS: { value: PipSlideDirection; label: string }[] = [
+  { value: "left", label: "← 左" },
+  { value: "right", label: "→ 右" },
+  { value: "up", label: "↑ 上" },
+  { value: "down", label: "↓ 下" },
+];
+
+/** 预览图层颜色池 */
+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)",
+];
+
+/* ──────────── Props ──────────── */
+
+interface PipConfigPanelProps {
+  open: boolean;
+  onClose: () => void;
+  config: PipConfig;
+  onChange: (config: PipConfig) => void;
+  totalDuration: number;
+}
+
+/* ──────────── 辅助函数 ──────────── */
+
+let layerIdCounter = 0;
+const genLayerId = () => `pip_layer_${Date.now()}_${++layerIdCounter}`;
+
+/* ──────────── 组件 ──────────── */
+
+const PipConfigPanel: React.FC<PipConfigPanelProps> = ({
+  open,
+  onClose,
+  config,
+  onChange,
+  totalDuration,
+}) => {
+  /** 当前选中图层 ID */
+  const [selectedId, setSelectedId] = React.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) {
+        // 保持宽高比 1:1（百分比相同）
+        partial.height = val;
+      }
+      updateLayer(selectedLayer.id, partial);
+    },
+    [selectedLayer, updateLayer],
+  );
+
+  const handleHeightChange = useCallback(
+    (val: number) => {
+      if (!selectedLayer) return;
+      const partial: Partial<PipLayer> = { height: val };
+      if (selectedLayer.aspect_lock) {
+        partial.width = val;
+      }
+      updateLayer(selectedLayer.id, partial);
+    },
+    [selectedLayer, updateLayer],
+  );
+
+  return (
+    <Drawer
+      title="🖼️ 画中画设置"
+      placement="right"
+      width={520}
+      open={open}
+      onClose={onClose}
+      className="pip-config-panel-drawer"
+    >
+      {/* ═══ 顶部工具栏 ═══ */}
+      <div className="pip-toolbar">
+        <div className="pip-toolbar-left">
+          <button className="pip-add-btn" onClick={handleAddLayer}>
+            + 添加图层
+          </button>
+        </div>
+        <div className="pip-enable-switch">
+          <span>启用</span>
+          <Switch
+            size="small"
+            checked={config.enabled}
+            onChange={handleEnableToggle}
+          />
+        </div>
+      </div>
+
+      {/* ═══ 主体：图层列表 + 配置区 ═══ */}
+      <div className="pip-body">
+        {/* 左侧图层列表 */}
+        <div className="pip-layer-list">
+          {config.layers.length === 0 ? (
+            <div className="pip-layer-empty">暂无图层，点击上方添加</div>
+          ) : (
+            config.layers.map((layer, idx) => (
+              <div
+                key={layer.id}
+                className={`pip-layer-item${selectedId === layer.id ? " active" : ""}`}
+                onClick={() => setSelectedId(layer.id)}
+              >
+                {layer.thumbnail_url || layer.material_url ? (
+                  <img
+                    className="pip-layer-thumb"
+                    src={layer.thumbnail_url || layer.material_url}
+                    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();
+                    handleDeleteLayer(layer.id);
+                  }}
+                  title="删除图层"
+                >
+                  ✕
+                </button>
+              </div>
+            ))
+          )}
+        </div>
+
+        {/* 右侧配置区 */}
+        <div className="pip-config-area">
+          {!selectedLayer ? (
+            <div className="pip-config-empty">选择或添加图层以配置</div>
+          ) : (
+            <>
+              {/* ── 迷你预览 ── */}
+              <div className="pip-preview-box">
+                {config.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}%`,
+                    }}
+                  >
+                    <span className="pip-preview-label">{layer.name}</span>
+                  </div>
+                ))}
+              </div>
+
+              {/* ── 素材类型 ── */}
+              <div className="pip-field">
+                <label className="pip-field-label">素材类型</label>
+                <div className="pip-type-btns">
+                  <button
+                    className={`pip-type-btn${selectedLayer.material_type === "image" ? " active" : ""}`}
+                    onClick={() =>
+                      updateLayer(selectedLayer.id, { material_type: "image" })
+                    }
+                  >
+                    🖼️ 图片
+                  </button>
+                  <button
+                    className={`pip-type-btn${selectedLayer.material_type === "video" ? " active" : ""}`}
+                    onClick={() =>
+                      updateLayer(selectedLayer.id, { material_type: "video" })
+                    }
+                  >
+                    🎬 视频
+                  </button>
+                </div>
+              </div>
+
+              {/* ── 素材 URL ── */}
+              <div className="pip-field">
+                <label className="pip-field-label">
+                  {selectedLayer.material_type === "image" ? "图片" : "视频"}{" "}
+                  URL
+                </label>
+                <input
+                  className="pip-input"
+                  type="text"
+                  placeholder={
+                    selectedLayer.material_type === "image"
+                      ? "https://example.com/image.png"
+                      : "https://example.com/video.mp4"
+                  }
+                  value={selectedLayer.material_url}
+                  onChange={(e) =>
+                    updateLayer(selectedLayer.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${selectedLayer.grid_position === pos ? " active" : ""}`}
+                        onClick={() => handleGridClick(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={selectedLayer.x}
+                        onChange={(e) =>
+                          updateLayer(selectedLayer.id, {
+                            x: Number(e.target.value),
+                          })
+                        }
+                      />
+                    </div>
+                    <div>
+                      <label className="pip-field-label">Y (%)</label>
+                      <input
+                        className="pip-number"
+                        type="number"
+                        min={0}
+                        max={100}
+                        value={selectedLayer.y}
+                        onChange={(e) =>
+                          updateLayer(selectedLayer.id, {
+                            y: Number(e.target.value),
+                          })
+                        }
+                      />
+                    </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={selectedLayer.width}
+                    onChange={(e) => handleWidthChange(Number(e.target.value))}
+                  />
+                  <span className="pip-slider-value">
+                    {selectedLayer.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={selectedLayer.height}
+                    onChange={(e) => handleHeightChange(Number(e.target.value))}
+                  />
+                  <span className="pip-slider-value">
+                    {selectedLayer.height}%
+                  </span>
+                </div>
+                <div
+                  className="pip-lock-row"
+                  style={{ marginTop: 6 }}
+                  onClick={() =>
+                    updateLayer(selectedLayer.id, {
+                      aspect_lock: !selectedLayer.aspect_lock,
+                    })
+                  }
+                >
+                  <span className="pip-lock-icon">
+                    {selectedLayer.aspect_lock ? "🔒" : "🔓"}
+                  </span>
+                  <span>
+                    {selectedLayer.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={selectedLayer.border_radius}
+                    onChange={(e) =>
+                      updateLayer(selectedLayer.id, {
+                        border_radius: Number(e.target.value),
+                      })
+                    }
+                  />
+                  <span className="pip-slider-value">
+                    {selectedLayer.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={selectedLayer.opacity}
+                    onChange={(e) =>
+                      updateLayer(selectedLayer.id, {
+                        opacity: Number(e.target.value),
+                      })
+                    }
+                  />
+                  <span className="pip-slider-value">
+                    {selectedLayer.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={selectedLayer.start_time}
+                      onChange={(e) =>
+                        updateLayer(selectedLayer.id, {
+                          start_time: Number(e.target.value),
+                        })
+                      }
+                    />
+                  </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={selectedLayer.duration}
+                      onChange={(e) =>
+                        updateLayer(selectedLayer.id, {
+                          duration: Number(e.target.value),
+                        })
+                      }
+                    />
+                  </div>
+                </div>
+              </div>
+
+              {/* ── 入场动画 ── */}
+              <div className="pip-field">
+                <label className="pip-field-label">入场动画</label>
+                <select
+                  className="pip-select"
+                  value={selectedLayer.animation}
+                  onChange={(e) =>
+                    updateLayer(selectedLayer.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 时显示） */}
+              {selectedLayer.animation === "slide_in" && (
+                <div className="pip-field">
+                  <label className="pip-field-label">滑入方向</label>
+                  <select
+                    className="pip-select"
+                    value={selectedLayer.slide_direction}
+                    onChange={(e) =>
+                      updateLayer(selectedLayer.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>
+      </div>
+
+      {/* ── 底部操作 ── */}
+      <div className="pip-footer">
+        <button className="pip-reset-btn" onClick={handleReset}>
+          重置
+        </button>
+      </div>
+    </Drawer>
+  );
+};
+
+export default PipConfigPanel;

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

@@ -4,25 +4,13 @@
  * 封面右侧竖排4个方案按钮
  */
 import React from "react";
-import type { ClipData, ClipType } from "../types";
+import type { ClipData, ClipType, TitleSettings } from "../types";
 
 interface CoverScheme {
   key: string;
   label: string;
 }
 
-interface TitleSettings {
-  aiAutoSelect: boolean;
-  title: string;
-  position: string;
-  font: string;
-  size: number;
-  bold: boolean;
-  italic: boolean;
-  stroke: boolean;
-  shadow: boolean;
-}
-
 interface SubtitleSettings {
   enabled: boolean;
   position: string;