chore: remove temporary fix workflow

## 统一渲染引擎 Phase 2 - Feature Flag 开关 + 适配层

### 变更内容

1. **Feature Flag 开关**
   - API 端 `Settings.RENDER_ENGINE`（默认 `legacy`）
   - Worker 端 `WorkerSettings.render_engine`（默认 `legacy`）
   - 支持环境变量 `RENDER_ENGINE=unified` 一键切换

2. **RenderAdapter 适配层** (`apps/worker/video_processing/render_adapter.py`)
   - EditPlan + EditPlanClips → UnifiedRenderService 输入的完整适配
   - 素材自动下载（OSS → 本地路径映射）
   - 进度回调对接（ProgressCallback）
   - 结果自动上传 OSS
   - `validate_plan()` 兼容旧接口，便于灰度切换

3. **compose_video 任务改造**
   - 根据 `RENDER_ENGINE` 配置分流到 legacy / unified 路径
   - 新引擎结果回写字段对齐（engine/width/height/file_size）
   - 错误处理与重试逻辑保持一致

### 测试
- 新增 16 个单元测试：validate_plan(7) + render_plan(6) + download_assets(3)
- 原有 52 个 unified_render_service 测试全部通过
- 合计 **68 个测试全绿**

### 灰度策略
- 默认 `legacy`，不影响现有功能
- 灰度时设置环境变量 `RENDER_ENGINE=unified` 即可切换
- 后续可支持按 plan_id / user_id 灰度（Phase 3）

---------

Co-authored-by: 灵应 <lingying@coze.email>
Reviewed-on: #231

.env.example

@@ -44,9 +44,14 @@ OSS_ACCESS_KEY_SECRET=your-access-key-secret
 OSS_BUCKET_NAME=xiaoxia-autocut
 
 # ==================== CosyVoice 语音合成配置 ====================
+# 注意：base_url 只需写到 /api/v1，具体路径由代码拼接
+# 模型: cosyvoice-v3-flash (推荐，支持系统音色，性价比高)
+#       cosyvoice-v3-plus (高质量，系统音色少)
+#       cosyvoice-v3.5-flash / cosyvoice-v3.5-plus (仅支持克隆/设计音色，无系统音色)
+# 音色: v3系列系统音色带 _v3 后缀，如 longxiaochun_v3, longxiaoxia_v3, longanyang (无后缀)
 COSYVOICE_API_KEY=your-cosyvoice-api-key
-COSYVOICE_BASE_URL=https://dashscope.aliyuncs.com/api/v1/services/aigc/text2audio
-COSYVOICE_MODEL=cosyvoice-v1
-COSYVOICE_VOICE=longxiaochun
+COSYVOICE_BASE_URL=https://dashscope.aliyuncs.com/api/v1
+COSYVOICE_MODEL=cosyvoice-v3-flash
+COSYVOICE_VOICE=longxiaochun_v3
 COSYVOICE_SAMPLE_RATE=22050
 COSYVOICE_FORMAT=mp3

.env.production.example

@@ -42,10 +42,15 @@ OSS_DIRECT_UPLOAD_MAX_MB=2000
 OSS_DIRECT_UPLOAD_EXPIRE_SECONDS=900
 
 # ==================== CosyVoice 语音合成（必须配置）====================
+# 注意：base_url 只需写到 /api/v1，具体路径由代码拼接
+# 模型: cosyvoice-v3-flash (推荐，支持系统音色，性价比高)
+#       cosyvoice-v3-plus (高质量，系统音色少)
+#       cosyvoice-v3.5-flash / cosyvoice-v3.5-plus (仅支持克隆/设计音色，无系统音色)
+# 音色: v3系列系统音色带 _v3 后缀，如 longxiaochun_v3, longxiaoxia_v3, longanyang (无后缀)
 COSYVOICE_API_KEY=CHANGE_ME_COSYVOICE_API_KEY
-COSYVOICE_BASE_URL=https://dashscope.aliyuncs.com/api/v1/services/aigc/text2audio
-COSYVOICE_MODEL=cosyvoice-v1
-COSYVOICE_VOICE=longxiaochun
+COSYVOICE_BASE_URL=https://dashscope.aliyuncs.com/api/v1
+COSYVOICE_MODEL=cosyvoice-v3-flash
+COSYVOICE_VOICE=longxiaochun_v3
 COSYVOICE_SAMPLE_RATE=22050
 COSYVOICE_FORMAT=mp3
 

.flake8

@@ -2,6 +2,7 @@
 max-line-length = 120
 exclude =
     .git,
+    .cache,
     __pycache__,
     .venv,
     venv,

.gitea/workflows/auto-merge.yml

@@ -1,65 +0,0 @@
-name: Auto Merge PRs
-
-on:
-  schedule:
-    - cron: '0 */6 * * *'
-  workflow_dispatch:
-
-jobs:
-  auto-merge:
-    runs-on: saas
-    timeout-minutes: 10
-    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']}/{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:
-              top_prefix = tar.getmembers()[0].name.split('/', 1)[0] + '/'
-              for member in tar.getmembers():
-                  name = member.name
-                  if name == top_prefix[:-1]:
-                      continue
-                  if name.startswith(top_prefix):
-                      member.name = name[len(top_prefix):]
-                  if member.name:
-                      tar.extract(member, '.')
-          PY
-
-      - name: Auto merge develop PRs
-        run: |
-          bash scripts/auto_merge_prs.sh develop
-
-      - name: Auto merge main PRs (release only)
-        run: |
-          bash scripts/auto_merge_prs.sh main

.gitea/workflows/ci-cd.yml

@@ -22,7 +22,7 @@ permissions:
 jobs:
   validate:
     name: Validate Code Quality And Tests
-    runs-on: ubuntu-22.04
+    runs-on: host
     timeout-minutes: 10
 
     env:
@@ -80,7 +80,7 @@ jobs:
         shell: sh
         run: |
           set -eu
-          python --version
+          python3 --version
           python3 -m pip --version
           echo "CI environment is ready"
 
@@ -158,14 +158,180 @@ jobs:
             python3 scripts/check_migration_safety.py --allow-medium-risk
           fi
 
+      - name: Debug coverage paths
+        shell: sh
+        run: |
+          set +e
+          echo "=== PWD ==="
+          pwd
+          echo "=== check source dirs ==="
+          ls -d apps/api/app packages
+          echo "=== python import check ==="
+          python3 - <<'PY'
+          import sys, os
+          os.environ["PYTHONPATH"] = f"{os.getcwd()}/apps/api:{os.getcwd()}"
+          sys.path.insert(0, f"{os.getcwd()}/apps/api")
+          sys.path.insert(0, os.getcwd())
+          print(f"cwd: {os.getcwd()}")
+          print(f"sys.path[:5]: {sys.path[:5]}")
+          try:
+              import app
+              print(f"app.__file__: {app.__file__}")
+          except Exception as e:
+              print(f"import app failed: {e}")
+          try:
+              import packages
+              print(f"packages.__file__: {packages.__file__}")
+          except Exception as e:
+              print(f"import packages failed: {e}")
+          PY
+          echo "=== coverage debug ==="
+          python3 - <<'PY'
+          import os, sys
+          sys.path.insert(0, f"{os.getcwd()}/apps/api")
+          sys.path.insert(0, os.getcwd())
+          import coverage
+          cov = coverage.Coverage(source=["apps/api/app", "packages"])
+          print(f"source: {cov.config.source}")
+          for src in cov.config.source or []:
+              abspath = os.path.abspath(src)
+              print(f"  {src} -> {abspath} exists={os.path.exists(src)}")
+              if os.path.isdir(src):
+                  pyfiles = []
+                  for root, dirs, files in os.walk(src):
+                      for f in files:
+                          if f.endswith('.py'):
+                              pyfiles.append(os.path.join(root, f))
+                  print(f"    .py files: {len(pyfiles)}")
+          PY
+
       - name: Run unit tests
         shell: sh
         env:
           USE_IN_MEMORY_DB: "true"
         run: |
           set -eu
-          PYTHONPATH="$PWD/apps/api:$PWD" python3 -m pytest tests/unit -q \
-            --cov=apps --cov-report=term --cov-report=xml
+          PYTHONPATH="$PWD/apps/api:$PWD" python3 -m coverage run \
+            --source=apps/api/app,packages \
+            --omit="*/migrations/*,*/tests/*,*/test_*.py,*/site-packages/*" \
+            --branch \
+            -m pytest tests/unit -q
+          python3 -m coverage report --show-missing
+          python3 -m coverage xml -o coverage.xml
+          python3 -m coverage report --fail-under=60 > /dev/null
+
+      - name: Build summary
+        if: github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/main'
+        shell: sh
+        run: |
+          set -eu
+          echo "Build completed successfully!"
+          echo "Branch: ${GITHUB_REF_NAME}"
+          echo "Commit: ${GITHUB_SHA}"
+          # 输出最终覆盖率
+          python3 scripts/ci_coverage_summary.py
+
+  integration-tests:
+    name: Integration Tests
+    runs-on: host
+    timeout-minutes: 20
+    if: always()
+    needs: validate
+
+    env:
+      DATABASE_URL: postgresql+psycopg://postgres:postgres@127.0.0.1:5432/xiaoxia_saas
+      USE_IN_MEMORY_DB: "false"
+
+    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: Verify CI environment
+        shell: sh
+        run: |
+          set -eu
+          python3 --version
+          python3 -m pip --version
+          echo "CI environment is ready"
+
+      - name: Install dependencies
+        shell: sh
+        run: |
+          set -eu
+          python3 -m pip install -q -r requirements-base.txt
+          python3 -m pip install -q -r requirements.txt
+          python3 -m pip install -q -r requirements-dev.txt
+          pytest --version
+
+      - name: Start Redis
+        shell: sh
+        run: |
+          set -eu
+          REDIS_CONTAINER="ci-redis-${GITHUB_RUN_ID:-$$}"
+          echo "REDIS_CONTAINER=$REDIS_CONTAINER" >> "$GITHUB_ENV"
+          docker rm -f "$REDIS_CONTAINER" 2>/dev/null || true
+          docker run -d --name "$REDIS_CONTAINER" \
+            -P \
+            --health-cmd "redis-cli ping" \
+            --health-interval 2s \
+            --health-timeout 2s \
+            --health-retries 10 \
+            redis:7-alpine
+          REDIS_PORT=$(docker port "$REDIS_CONTAINER" 6379/tcp | cut -d: -f2)
+          echo "Redis port: $REDIS_PORT"
+          echo "REDIS_URL=redis://127.0.0.1:$REDIS_PORT/0" >> "$GITHUB_ENV"
+          for i in $(seq 1 15); do
+            if docker inspect --format='{{.State.Health.Status}}' "$REDIS_CONTAINER" 2>/dev/null | grep -q healthy; then
+              echo "Redis is ready on port $REDIS_PORT"
+              break
+            fi
+            echo "Waiting for Redis... ($i/15)"
+            sleep 2
+          done
+          docker inspect --format='{{.State.Health.Status}}' "$REDIS_CONTAINER" | grep -q healthy
 
       - name: Start PostgreSQL for integration tests
         shell: sh
@@ -210,8 +376,14 @@ jobs:
         run: |
           set -eu
           pip install -q pytest-rerunfailures
-          PYTHONPATH="$PWD/apps/api:$PWD" python3 -m pytest tests/integration -q --timeout=60 -x --reruns 2 --reruns-delay 1 -m "not performance" \
-            --cov=apps --cov-append --cov-report=term --cov-report=xml --cov-fail-under=50
+          PYTHONPATH="$PWD/apps/api:$PWD" python3 -m coverage run --append \
+            --source=apps/api/app,packages \
+            --omit="*/migrations/*,*/tests/*,*/test_*.py,*/site-packages/*" \
+            --branch \
+            -m pytest tests/integration -q --timeout=60 -x --reruns 2 --reruns-delay 1 -m "not performance"
+          python3 -m coverage report --show-missing
+          python3 -m coverage xml -o coverage.xml
+          python3 -m coverage report --fail-under=40 > /dev/null  # 集成测试覆盖率门槛较低，核心目标是功能验证
 
       - name: Run API performance baseline tests
         shell: sh
@@ -255,25 +427,44 @@ jobs:
           exit 0
 
 
-      - name: Cleanup PostgreSQL
+      - name: Cleanup PostgreSQL & Redis
         if: always()
         shell: sh
         run: |
           docker rm -f "${PG_CONTAINER:-ci-pg-validate}" 2>/dev/null || true
+          docker rm -f "${REDIS_CONTAINER:-ci-redis-int}" 2>/dev/null || true
           echo "PostgreSQL container cleaned up"
+          echo "Redis container cleaned up"
 
-      - name: Build summary
-        if: github.ref == 'refs/heads/develop' || github.ref == 'refs/heads/main'
+      - name: Coverage summary
+        if: always()
+        shell: sh
+        env:
+          COVERAGE_THRESHOLD: "40"
+        run: |
+          set +e
+          echo "=== 覆盖率汇总 ==="
+          python3 scripts/ci_coverage_summary.py
+      - name: Notify CI failure
+        if: failure()
         shell: sh
         run: |
-          set -eu
-          echo "Build completed successfully!"
-          echo "Branch: ${GITHUB_REF_NAME}"
-          echo "Commit: ${GITHUB_SHA}"
+          set +e
+          echo "=== CI 失败通知 ==="
+          FAILED_JOB="Validate Code Quality And Tests" python3 scripts/ci_notify_failure.py
+
+      - name: Notify CI failure - Integration Tests
+        if: failure()
+        shell: sh
+        run: |
+          set +e
+          echo "=== CI 失败通知 ==="
+          FAILED_JOB="Integration Tests" python3 scripts/ci_notify_failure.py
+
 
   frontend-lint:
     name: Frontend Lint
-    runs-on: ubuntu-22.04
+    runs-on: host
     timeout-minutes: 10
 
     steps:
@@ -372,6 +563,15 @@ jobs:
             -w /workspace/apps/web \
             docker.m.daocloud.io/library/node:20 \
             sh -lc 'npx vitest run src/test'
+
+      - name: Notify CI failure
+        if: failure()
+        shell: sh
+        run: |
+          set +e
+          echo "=== CI 失败通知 ==="
+          FAILED_JOB="Frontend Lint" python3 scripts/ci_notify_failure.py
+
   deploy-staging:
     name: Build & Push Staging (Watchtower auto-deploy)
     runs-on: saas
@@ -503,6 +703,23 @@ jobs:
         echo "Branch: ${GITHUB_REF_NAME}"
         echo "Commit: ${GITHUB_SHA}"
 
+    - name: Notify CI success
+      if: success()
+      shell: sh
+      run: |
+        set +e
+        echo "=== CI 成功通知 ==="
+        SUCCESS_JOB="Staging部署成功" python3 scripts/ci_notify_success.py
+
+    - name: Notify CI failure
+      if: failure()
+      shell: sh
+      run: |
+        set +e
+        echo "=== CI 失败通知 ==="
+        FAILED_JOB="Build & Push Staging (Watchtower auto-deploy)" python3 scripts/ci_notify_failure.py
+
+
 
   staging-e2e:
     name: Staging E2E Tests
@@ -571,6 +788,15 @@ jobs:
           git.xiaoxiajianji.com/xiaoxia/base/playwright:v1.45.0-jammy \
           sh -lc "npm ci && npx playwright test --reporter=line --project=chromium e2e/auth.spec.ts e2e/auth-guard.spec.ts e2e/core-upload.spec.ts e2e/core-generation.spec.ts"
 
+    - name: Notify CI failure
+      if: failure()
+      shell: sh
+      run: |
+        set +e
+        echo "=== CI 失败通知 ==="
+        FAILED_JOB="Staging E2E Tests" python3 scripts/ci_notify_failure.py
+
+
   staging-api-tests:
     name: Staging API Integration Tests
     runs-on: saas
@@ -636,6 +862,15 @@ jobs:
           git.xiaoxiajianji.com/xiaoxia/base/playwright:v1.45.0-jammy \
           sh -lc 'npm ci && npx playwright test --reporter=line e2e/test_auth.spec.ts e2e/test_asset.spec.ts e2e/test_project.spec.ts'
 
+    - name: Notify CI failure
+      if: failure()
+      shell: sh
+      run: |
+        set +e
+        echo "=== CI 失败通知 ==="
+        FAILED_JOB="Staging API Integration Tests" python3 scripts/ci_notify_failure.py
+
+
 
   build-production-runtime-images:
     name: Build Production Runtime Images
@@ -716,6 +951,15 @@ jobs:
         echo "Disk usage after cleanup:"
         df -h / | tail -1
 
+    - name: Notify CI failure
+      if: failure()
+      shell: sh
+      run: |
+        set +e
+        echo "=== CI 失败通知 ==="
+        FAILED_JOB="Build Production Runtime Images" python3 scripts/ci_notify_failure.py
+
+
   deploy-production:
     name: Deploy Production
     runs-on: saas
@@ -781,6 +1025,23 @@ jobs:
 
         echo "$DEPLOY_B64" | base64 -d | ssh -p 22222 -i "$key_path" "$production_user@$production_host" "IMAGE_TAG='${GITHUB_REF_NAME}' REGISTRY_TOKEN='${REGISTRY_TOKEN}' sh"
 
+    - name: Notify CI success
+      if: success()
+      shell: sh
+      run: |
+        set +e
+        echo "=== CI 成功通知 ==="
+        SUCCESS_JOB="生产部署成功" python3 scripts/ci_notify_success.py
+
+    - name: Notify CI failure
+      if: failure()
+      shell: sh
+      run: |
+        set +e
+        echo "=== CI 失败通知 ==="
+        FAILED_JOB="Deploy Production" python3 scripts/ci_notify_failure.py
+
+
   production-e2e:
     name: Production Browser E2E
     runs-on: saas
@@ -849,3 +1110,12 @@ jobs:
           -w /workspace/apps/web \
           git.xiaoxiajianji.com/xiaoxia/base/playwright:v1.45.0-jammy \
           sh -lc 'npm ci && npx playwright test --reporter=line --project=chromium e2e/auth.spec.ts e2e/auth-guard.spec.ts e2e/core-upload.spec.ts e2e/core-generation.spec.ts e2e/core-titles.spec.ts'
+
+    - name: Notify CI failure
+      if: failure()
+      shell: sh
+      run: |
+        set +e
+        echo "=== CI 失败通知 ==="
+        FAILED_JOB="Production Browser E2E" python3 scripts/ci_notify_failure.py
+

.gitea/workflows/test-ssh-secret.yml

@@ -1,69 +0,0 @@
-name: Test SSH Secret
-on:
-  push:
-    branches: [develop]
-    paths:
-      - '.gitea/workflows/test-ssh-secret.yml'
-
-jobs:
-  test-ssh:
-    runs-on: ubuntu-22.04
-    steps:
-      - name: Install SSH client
-        run: |
-          which ssh || (apt-get update && apt-get install -y openssh-client)
-          ssh -V
-
-      - name: Debug environment
-        run: |
-          echo "=== Environment ==="
-          echo "Runner hostname: $(hostname)"
-          echo "Runner IP: $(hostname -i || echo 'unknown')"
-          echo "Current user: $(whoami)"
-          echo "=== Secrets check ==="
-          if [ -n "$STAGING_SSH_HOST" ]; then
-            echo "STAGING_SSH_HOST: [SET] value_length=${#STAGING_SSH_HOST}"
-          else
-            echo "STAGING_SSH_HOST: [EMPTY]"
-          fi
-          if [ -n "$STAGING_SSH_USER" ]; then
-            echo "STAGING_SSH_USER: [SET] value_length=${#STAGING_SSH_USER}"
-          else
-            echo "STAGING_SSH_USER: [EMPTY]"
-          fi
-          if [ -n "$STAGING_SSH_KEY" ]; then
-            echo "STAGING_SSH_KEY: [SET] value_length=${#STAGING_SSH_KEY}"
-          else
-            echo "STAGING_SSH_KEY: [EMPTY]"
-          fi
-        env:
-          STAGING_SSH_HOST: ${{ secrets.STAGING_SSH_HOST }}
-          STAGING_SSH_USER: ${{ secrets.STAGING_SSH_USER }}
-          STAGING_SSH_KEY: ${{ secrets.STAGING_SSH_KEY }}
-
-      - name: Setup SSH key
-        run: |
-          mkdir -p ~/.ssh
-          chmod 700 ~/.ssh
-          echo "$STAGING_SSH_KEY" > ~/.ssh/id_ed25519
-          chmod 600 ~/.ssh/id_ed25519
-          ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub 2>/dev/null || echo "No public key generated"
-          echo "=== SSH Key fingerprint ==="
-          ssh-keygen -lf ~/.ssh/id_ed25519 || echo "Key fingerprint failed"
-        env:
-          STAGING_SSH_KEY: ${{ secrets.STAGING_SSH_KEY }}
-
-      - name: Test SSH connection
-        run: |
-          echo "Attempting SSH connection to $STAGING_SSH_HOST..."
-          ssh -i ~/.ssh/id_ed25519 \
-            -o StrictHostKeyChecking=no \
-            -o UserKnownHostsFile=/dev/null \
-            -o ConnectTimeout=10 \
-            -o BatchMode=yes \
-            -v \
-            $STAGING_SSH_USER@$STAGING_SSH_HOST "echo 'SSH_CONNECTION_SUCCESS' && hostname && whoami"
-          echo "=== SSH Test Complete ==="
-        env:
-          STAGING_SSH_HOST: ${{ secrets.STAGING_SSH_HOST }}
-          STAGING_SSH_USER: ${{ secrets.STAGING_SSH_USER }}

.gitea/workflows/tests.yml

@@ -1,163 +0,0 @@
-name: Tests
-
-on:
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  test:
-    runs-on: runtime-builder
-
-    steps:
-    - name: Checkout code
-      shell: sh
-      run: |
-        set -eu
-        python - <<'PY'
-        import io
-        import os
-        import tarfile
-        import time
-        import urllib.error
-        import urllib.request
-
-        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']}"})
-        # Retry up to 5 times with backoff for transient 5xx errors
-        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: Show Python version
-      shell: sh
-      run: |
-        set -eu
-        python --version
-        python -m pip --version
-
-    - name: Install dependencies
-      shell: sh
-      run: |
-        set -eu
-        python -m pip install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
-        python -m pip install -r requirements.txt -r requirements-dev.txt -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
-
-    - name: Run unit tests
-      shell: sh
-      run: |
-        set -eu
-        PYTHONPATH="$PWD/apps/api:$PWD" python -m pytest tests/unit -q
-
-    - name: Run integration tests
-      shell: sh
-      run: |
-        set -eu
-        PYTHONPATH="$PWD/apps/api:$PWD" python -m pytest tests/integration -q --timeout=60 -x
-
-  lint:
-    runs-on: runtime-builder
-
-    steps:
-    - name: Checkout code
-      shell: sh
-      run: |
-        set -eu
-        python - <<'PY'
-        import io
-        import os
-        import tarfile
-        import time
-        import urllib.error
-        import urllib.request
-
-        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']}"})
-        # Retry up to 5 times with backoff for transient 5xx errors
-        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: Install dependencies
-      shell: sh
-      run: |
-        set -eu
-        python -m pip install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
-        python -m pip install -r requirements.txt -r requirements-dev.txt -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
-
-    - name: Run Black (check only)
-      shell: sh
-      run: |
-        set -eu
-        python -m black --check alembic apps packages tests scripts
-
-    - name: Run Flake8
-      shell: sh
-      run: |
-        set -eu
-        python -m flake8 apps packages tests --count --statistics

.gitignore

@@ -6,6 +6,7 @@ dist/
 coverage/
 
 # Python / backend
+.cache/
 .venv/
 venv/
 .venv-ci-root/

alembic/versions/037_add_logs_to_generation_tasks.py

@@ -0,0 +1,26 @@
+"""Add logs field to generation_tasks
+
+Revision ID: 037_generation_logs
+Revises: 036_expand_uuid_36
+Create Date: 2026-07-10
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "037_generation_logs"
+down_revision = "036_expand_uuid_36"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "generation_tasks",
+        sa.Column("logs", sa.Text(), nullable=False, server_default="[]"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("generation_tasks", "logs")

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

@@ -24,6 +24,7 @@ from typing import Any, List, Optional
 
 from app.auth import AuthenticatedUser, get_current_user
 from app.core.celery_app import celery_app
+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.schemas.generation_task import GenerationTaskResponse
 from app.services import EditPlanService, PlanGeneratorService
@@ -644,6 +645,31 @@ def generate_plan(
 
         # 创建 GenerationTask
         gen_task_repo = SQLAlchemyGenerationTaskRepository(db)
+
+        # 队列限流预检查（repository 不支持计数时跳过）
+        user_id = current_user.user.id
+        try:
+            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()
+                if user_pending >= USER_PENDING_LIMIT:
+                    raise HTTPException(
+                        status_code=429,
+                        detail=f"您的待处理任务过多（当前 {user_pending}/{USER_PENDING_LIMIT}），请等待完成后再提交",
+                    )
+                if global_pending >= GLOBAL_PENDING_LIMIT:
+                    raise HTTPException(
+                        status_code=503,
+                        detail="系统繁忙，请稍后再试",
+                    )
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.warning("[队列限流] 剪辑计划限流检查失败，跳过: %s", e)
+
         gen_task_use_case = CreateGenerationTaskUseCase(gen_task_repo)
         plan = svc.get_plan_or_raise(plan_id)
         gen_task = gen_task_use_case.execute(

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

@@ -1,10 +1,18 @@
+import logging
 import random
 import uuid
 from typing import Any
 
 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,
+    GlobalQueueFull,
+    UserPendingLimitExceeded,
+    check_queue_limits,
+    safe_enqueue_generation_task,
+)
 from app.dependencies import (
     get_asset_library_repository,
     get_asset_repository,
@@ -31,8 +39,9 @@ from packages.application import (
     ListGeneratedVideosByTaskUseCase,
 )
 
-router = APIRouter()
+logger = logging.getLogger(__name__)
 
+router = APIRouter()
 
 def _check_project_access(project_id: str, user_id: str, project_repository) -> None:
     """检查用户是否有项目访问权限"""
@@ -57,6 +66,7 @@ def _to_generation_task_response(task) -> GenerationTaskResponse:
         source_edit_plan_id=task.source_edit_plan_id or "",
         asset_select_mode=getattr(task, "asset_select_mode", ""),
         batch_id=getattr(task, "batch_id", ""),
+        logs=getattr(task, "logs", "[]"),
         status=task.status,
         progress=task.progress,
         result_count=task.result_count,
@@ -181,19 +191,37 @@ def create_generation_task(
     asset_library_repository: Any = Depends(get_asset_library_repository),
     asset_repository: Any = Depends(get_asset_repository),
 ) -> BatchGenerationTaskResponse:
-    project_id, asset_library_id = _resolve_project_and_library(
-        request, project_repository, asset_library_repository, asset_repository, authenticated_user
+    logger.info(
+        "[生成任务] 接收请求: user_id=%s, template_id=%s, asset_count=%d, mode=%s, count=%d",
+        authenticated_user.user.id,
+        request.template_id,
+        len(request.asset_ids),
+        request.asset_select_mode,
+        request.count,
     )
 
+    try:
+        project_id, asset_library_id = _resolve_project_and_library(
+            request, project_repository, asset_library_repository, asset_repository, authenticated_user
+        )
+    except HTTPException as e:
+        logger.warning("[生成任务] 校验失败: %s", e.detail)
+        raise
+
     # asset_library 存在性校验（仅在提供了 asset_library_id 时）
     resolved_asset_ids: list[str] = list(request.asset_ids)
     if asset_library_id:
         library = asset_library_repository.get(asset_library_id)
         if library is None or (project_id and library.project_id != project_id):
+            logger.warning("[生成任务] 素材库不存在: library_id=%s", asset_library_id)
             raise HTTPException(status_code=404, detail=f"AssetLibrary {asset_library_id} not found")
 
         assets = asset_repository.find_by_library(asset_library_id)
-        _ensure_library_has_ready_video_assets(assets)
+        try:
+            _ensure_library_has_ready_video_assets(assets)
+        except HTTPException as e:
+            logger.warning("[生成任务] 素材校验失败: %s", e.detail)
+            raise
 
         # 素材库自动匹配：当未显式指定 asset_ids 时，按模式自动选取
         if not resolved_asset_ids:
@@ -206,30 +234,85 @@ def create_generation_task(
     use_case = CreateGenerationTaskUseCase(generation_task_repository)
     count = request.count
     created_tasks = []
+    failed_tasks = []
+    user_id = authenticated_user.user.id
     # 同批次任务共享 batch_id，用于视频查重时批次内比对
     batch_id = uuid.uuid4().hex if count > 1 else ""
 
-    for _ in range(count):
-        task = use_case.execute(
-            CreateGenerationTaskCommand(
-                project_id=project_id,
-                asset_library_id=asset_library_id,
-                strategy_id=request.strategy_id,
-                voice_library_id=request.voice_library_id,
-                template_id=request.template_id,
-                asset_ids=resolved_asset_ids,
-                title_ids=request.title_ids,
-                voice_ids=request.voice_ids,
-                created_by_user_id=authenticated_user.user.id,
-                source_edit_plan_id=request.source_edit_plan_id,
-                asset_select_mode=request.asset_select_mode,
-                batch_id=batch_id,
+    # 预检查：批量提交前先看会不会超限，避免建一半才拒
+    try:
+        user_pending = generation_task_repository.count_pending_by_user(user_id)
+        global_pending = generation_task_repository.count_pending_total()
+        if user_pending + count > USER_PENDING_LIMIT:
+            raise UserPendingLimitExceeded(
+                user_id=user_id, pending_count=user_pending + count, limit=USER_PENDING_LIMIT
             )
-        )
-        celery_app.send_task("worker.generate_video", args=[task.id])
-        created_tasks.append(task)
+        if global_pending + count > GLOBAL_PENDING_LIMIT:
+            raise GlobalQueueFull(pending_count=global_pending + count, limit=GLOBAL_PENDING_LIMIT)
+    except UserPendingLimitExceeded as e:
+        raise HTTPException(
+            status_code=429,
+            detail=f"您的待处理任务过多（当前 {e.pending_count - count}/{e.limit}，本次提交 {count} 个），请等待完成后再提交",
+        ) from e
+    except GlobalQueueFull as e:
+        raise HTTPException(
+            status_code=503,
+            detail="系统繁忙，请稍后再试",
+        ) from e
 
-    items = [_to_generation_task_response(t) for t in created_tasks]
+    try:
+        for _ in range(count):
+            task = use_case.execute(
+                CreateGenerationTaskCommand(
+                    project_id=project_id,
+                    asset_library_id=asset_library_id,
+                    strategy_id=request.strategy_id,
+                    voice_library_id=request.voice_library_id,
+                    template_id=request.template_id,
+                    asset_ids=resolved_asset_ids,
+                    title_ids=request.title_ids,
+                    voice_ids=request.voice_ids,
+                    created_by_user_id=user_id,
+                    source_edit_plan_id=request.source_edit_plan_id,
+                    asset_select_mode=request.asset_select_mode,
+                    batch_id=batch_id,
+                )
+            )
+            try:
+                if safe_enqueue_generation_task(
+                    task,
+                    generation_task_repository,
+                    user_id=user_id,
+                    log_prefix="[生成任务]",
+                    log_task_status=True,
+                ):
+                    created_tasks.append(task)
+                else:
+                    failed_tasks.append(task)
+            except UserPendingLimitExceeded:
+                # 兜底：如果预检查后又并发提交了，在这里也拦住
+                failed_tasks.append(task)
+                if not created_tasks:
+                    raise HTTPException(
+                        status_code=429,
+                        detail="您的待处理任务过多，请等待完成后再提交",
+                    )
+                break
+            except GlobalQueueFull:
+                failed_tasks.append(task)
+                if not created_tasks:
+                    raise HTTPException(
+                        status_code=503,
+                        detail="系统繁忙，请稍后再试",
+                    )
+                break
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("[生成任务] 创建失败: %s", e, exc_info=True)
+        raise HTTPException(status_code=500, detail="创建生成任务失败，请稍后重试或查看任务日志")
+
+    items = [_to_generation_task_response(t) for t in created_tasks + failed_tasks]
     return BatchGenerationTaskResponse(items=items, total=len(items))
 
 
@@ -299,6 +382,21 @@ def retry_generation_task(
     if status_val != "failed":
         raise HTTPException(status_code=409, detail="Only failed tasks can be retried")
 
+    user_id = authenticated_user.user.id
+    # 预检查：创建前判断，>= 上限就拒绝
+    user_pending = generation_task_repository.count_pending_by_user(user_id)
+    global_pending = generation_task_repository.count_pending_total()
+    if user_pending >= USER_PENDING_LIMIT:
+        raise HTTPException(
+            status_code=429,
+            detail=f"您的待处理任务过多（当前 {user_pending}/{USER_PENDING_LIMIT}），请等待完成后再提交",
+        )
+    if global_pending >= GLOBAL_PENDING_LIMIT:
+        raise HTTPException(
+            status_code=503,
+            detail="系统繁忙，请稍后再试",
+        )
+
     use_case = CreateGenerationTaskUseCase(generation_task_repository)
     retried = use_case.execute(
         CreateGenerationTaskCommand(
@@ -310,10 +408,28 @@ def retry_generation_task(
             asset_ids=task.asset_ids,
             title_ids=task.title_ids,
             voice_ids=task.voice_ids,
-            created_by_user_id=authenticated_user.user.id,
+            created_by_user_id=user_id,
             source_edit_plan_id=task.source_edit_plan_id or "",
             asset_select_mode=getattr(task, "asset_select_mode", ""),
         )
     )
-    celery_app.send_task("worker.generate_video", args=[retried.id])
+    try:
+        if not safe_enqueue_generation_task(
+            retried,
+            generation_task_repository,
+            user_id=user_id,
+            log_prefix="[生成任务]",
+            log_task_status=True,
+        ):
+            logger.warning("[生成任务] 重试入队失败: task_id=%s", retried.id)
+    except UserPendingLimitExceeded:
+        raise HTTPException(
+            status_code=429,
+            detail="您的待处理任务过多，请等待完成后再提交",
+        ) from None
+    except GlobalQueueFull:
+        raise HTTPException(
+            status_code=503,
+            detail="系统繁忙，请稍后再试",
+        ) from None
     return _to_generation_task_response(retried)

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

@@ -1,7 +1,15 @@
+import logging
 from typing import Any
 
 from app.auth import AuthenticatedUser, get_current_user
 from app.core.celery_app import celery_app
+from app.core.task_enqueue import (
+    GLOBAL_PENDING_LIMIT,
+    USER_PENDING_LIMIT,
+    GlobalQueueFull,
+    UserPendingLimitExceeded,
+    safe_enqueue_generation_task,
+)
 from app.dependencies import (
     get_generation_task_repository,
     get_ingest_job_repository,
@@ -22,8 +30,9 @@ from packages.application import (
     SubmitIngestJobUseCase,
 )
 
-router = APIRouter()
+logger = logging.getLogger(__name__)
 
+router = APIRouter()
 
 def _humanize_task_error(error_message: str) -> str:
     raw = (error_message or "").strip()
@@ -139,6 +148,21 @@ def retry_task_by_id(
     if _status_value(task.status) != "failed":
         raise HTTPException(status_code=409, detail="Only failed tasks can be retried")
 
+    user_id = authenticated_user.user.id
+    # 预检查
+    user_pending = generation_task_repository.count_pending_by_user(user_id)
+    global_pending = generation_task_repository.count_pending_total()
+    if user_pending >= USER_PENDING_LIMIT:
+        raise HTTPException(
+            status_code=429,
+            detail=f"您的待处理任务过多（当前 {user_pending}/{USER_PENDING_LIMIT}），请等待完成后再提交",
+        )
+    if global_pending >= GLOBAL_PENDING_LIMIT:
+        raise HTTPException(
+            status_code=503,
+            detail="系统繁忙，请稍后再试",
+        )
+
     use_case = CreateGenerationTaskUseCase(generation_task_repository)
     retried = use_case.execute(
         CreateGenerationTaskCommand(
@@ -150,10 +174,24 @@ def retry_task_by_id(
             asset_ids=task.asset_ids,
             title_ids=task.title_ids,
             voice_ids=task.voice_ids,
-            created_by_user_id=authenticated_user.user.id,
+            created_by_user_id=user_id,
         )
     )
-    celery_app.send_task("worker.generate_video", args=[retried.id])
+    try:
+        if not safe_enqueue_generation_task(
+            retried, generation_task_repository, user_id=user_id, log_prefix="[任务中心]"
+        ):
+            logger.warning("[任务中心] 用户级重试入队失败: task_id=%s", retried.id)
+    except UserPendingLimitExceeded:
+        raise HTTPException(
+            status_code=429,
+            detail="您的待处理任务过多，请等待完成后再提交",
+        ) from None
+    except GlobalQueueFull:
+        raise HTTPException(
+            status_code=503,
+            detail="系统繁忙，请稍后再试",
+        ) from None
     return UserTaskResponse(
         id=f"generation:{retried.id}",
         task_type="generation",
@@ -221,6 +259,22 @@ def retry_project_task(
             raise HTTPException(status_code=404, detail="Generation task not found")
         if _status_value(task.status) != "failed":
             raise HTTPException(status_code=409, detail="Only failed tasks can be retried")
+
+        user_id = authenticated_user.user.id
+        # 预检查
+        user_pending = generation_task_repository.count_pending_by_user(user_id)
+        global_pending = generation_task_repository.count_pending_total()
+        if user_pending >= USER_PENDING_LIMIT:
+            raise HTTPException(
+                status_code=429,
+                detail=f"您的待处理任务过多（当前 {user_pending}/{USER_PENDING_LIMIT}），请等待完成后再提交",
+            )
+        if global_pending >= GLOBAL_PENDING_LIMIT:
+            raise HTTPException(
+                status_code=503,
+                detail="系统繁忙，请稍后再试",
+            )
+
         use_case = CreateGenerationTaskUseCase(generation_task_repository)
         retried = use_case.execute(
             CreateGenerationTaskCommand(
@@ -232,10 +286,24 @@ def retry_project_task(
                 asset_ids=task.asset_ids,
                 title_ids=task.title_ids,
                 voice_ids=task.voice_ids,
-                created_by_user_id=authenticated_user.user.id,
+                created_by_user_id=user_id,
             )
         )
-        celery_app.send_task("worker.generate_video", args=[retried.id])
+        try:
+            if not safe_enqueue_generation_task(
+                retried, generation_task_repository, user_id=user_id, log_prefix="[任务中心]"
+            ):
+                logger.warning("[任务中心] 项目级重试入队失败: task_id=%s", retried.id)
+        except UserPendingLimitExceeded:
+            raise HTTPException(
+                status_code=429,
+                detail="您的待处理任务过多，请等待完成后再提交",
+            ) from None
+        except GlobalQueueFull:
+            raise HTTPException(
+                status_code=503,
+                detail="系统繁忙，请稍后再试",
+            ) from None
         return _generation_task_to_project_response(retried)
     if task_type == "ingest":
         job = ingest_job_repository.get(source_id)

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

@@ -7,6 +7,7 @@ from typing import Optional
 
 from app.auth import AuthenticatedUser, get_current_user
 from app.dependencies import (
+    get_audio_url_signer,
     get_cosyvoice_service,
     get_db_session,
     get_user_repository,
@@ -56,7 +57,10 @@ def _get_repository(session: Session = Depends(get_db_session)) -> SQLAlchemyTTS
     return SQLAlchemyTTSJobRepository(session)
 
 
-def _to_response(job) -> TTSJobResponse:
+def _to_response(job, sign_url=None) -> TTSJobResponse:
+    output_url = job.output_audio_url
+    if sign_url and output_url:
+        output_url = sign_url(output_url)
     return TTSJobResponse(
         id=job.id,
         user_id=job.user_id,
@@ -66,7 +70,7 @@ def _to_response(job) -> TTSJobResponse:
         project_id=job.project_id,
         voice_clone_profile_id=job.voice_clone_profile_id,
         status=job.status,
-        output_audio_url=job.output_audio_url,
+        output_audio_url=output_url,
         output_audio_key=job.output_audio_key,
         duration=job.duration,
         file_size=job.file_size,
@@ -176,6 +180,7 @@ def list_tts_jobs(
     status_filter: Optional[str] = Query(None, alias="status"),
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     repository: SQLAlchemyTTSJobRepository = Depends(_get_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> ListTTSJobResponse:
     """列出用户的 TTS 合成任务。"""
     user_id = authenticated_user.user.id
@@ -183,7 +188,7 @@ def list_tts_jobs(
     skip = (page - 1) * page_size
     items, total = use_case.execute(user_id, status=status_filter, skip=skip, limit=page_size)
     return ListTTSJobResponse(
-        items=[_to_response(j) for j in items],
+        items=[_to_response(j, sign_url) for j in items],
         total=total,
         page=page,
         page_size=page_size,
@@ -195,6 +200,7 @@ def get_tts_job(
     job_id: str,
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     repository: SQLAlchemyTTSJobRepository = Depends(_get_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> TTSJobResponse:
     """获取 TTS 任务详情。"""
     user_id = authenticated_user.user.id
@@ -203,7 +209,7 @@ def get_tts_job(
         job = use_case.execute(job_id, user_id)
     except TTSJobNotFoundError:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="TTS job not found")
-    return _to_response(job)
+    return _to_response(job, sign_url)
 
 
 @router.get("/jobs/{job_id}/status", response_model=TTSStatusResponse)
@@ -211,6 +217,7 @@ def get_tts_job_status(
     job_id: str,
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     repository: SQLAlchemyTTSJobRepository = Depends(_get_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> TTSStatusResponse:
     """查询 TTS 合成状态（用于前端轮询）。"""
     user_id = authenticated_user.user.id
@@ -219,10 +226,13 @@ def get_tts_job_status(
         job = use_case.execute(job_id, user_id)
     except TTSJobNotFoundError:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="TTS job not found")
+    output_url = job.output_audio_url
+    if output_url:
+        output_url = sign_url(output_url)
     return TTSStatusResponse(
         id=job.id,
         status=job.status,
-        output_audio_url=job.output_audio_url,
+        output_audio_url=output_url,
         error_message=job.error_message,
         duration=job.duration,
         retry_count=job.retry_count,
@@ -258,6 +268,7 @@ def save_tts_job_to_library(
     tts_repository: SQLAlchemyTTSJobRepository = Depends(_get_repository),
     voice_library_repository: SQLAlchemyVoiceLibraryRepository = Depends(get_voice_library_repository),
     user_repository: UserRepository = Depends(get_user_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> SaveToLibraryResponse:
     """将已完成的 TTS 合成结果保存到配音库。
 
@@ -328,7 +339,7 @@ def save_tts_job_to_library(
     return SaveToLibraryResponse(
         id=item.id,
         name=item.name,
-        audio_url=item.audio_url,
+        audio_url=sign_url(item.audio_url) if item.audio_url else "",
         duration=item.duration,
         voice_id=item.voice_id,
         voice_name=item.voice_name,

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

@@ -38,6 +38,7 @@ router = APIRouter()
 
 
 def _to_response(profile) -> VoiceCloneProfileResponse:
+    # source_audio_url 是用户传入的原始 URL（可能是外部地址），不做预签名转换
     return VoiceCloneProfileResponse(
         id=profile.id,
         user_id=profile.user_id,

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

@@ -8,7 +8,7 @@ from __future__ import annotations
 from typing import Literal, Optional
 
 from app.auth import AuthenticatedUser, get_current_user
-from app.dependencies import get_db_session, get_user_repository
+from app.dependencies import get_audio_url_signer, get_db_session, get_user_repository
 from app.schemas.voice import (
     PresetVoiceItemResponse,
     PresetVoiceListResponse,
@@ -50,7 +50,10 @@ def _get_clone_profile_repository(session: Session = Depends(get_db_session)) ->
     return SQLAlchemyVoiceCloneProfileRepository(session)
 
 
-def _to_response(item) -> VoiceLibraryItemResponse:
+def _to_response(item, sign_url=None) -> VoiceLibraryItemResponse:
+    audio = item.audio_url
+    if sign_url and audio:
+        audio = sign_url(audio)
     return VoiceLibraryItemResponse(
         id=item.id,
         user_id=item.user_id,
@@ -59,7 +62,7 @@ def _to_response(item) -> VoiceLibraryItemResponse:
         voice_provider=item.voice_provider,
         voice_id=item.voice_id,
         voice_name=item.voice_name,
-        audio_url=item.audio_url,
+        audio_url=audio,
         duration=item.duration,
         file_size=item.file_size,
         status=item.status,
@@ -70,16 +73,20 @@ def _to_response(item) -> VoiceLibraryItemResponse:
     )
 
 
-def _to_unified_response(item, profile_id_map: dict | None = None) -> UnifiedVoiceItemResponse:
+def _to_unified_response(item, profile_id_map: dict | None = None, sign_url=None) -> UnifiedVoiceItemResponse:
     """将数据库音色转换为统一响应格式。
 
     Args:
         item: VoiceLibraryItem
         profile_id_map: voice_id → profile_id 映射，用于填充 voice_clone_profile_id
+        sign_url: 音频URL预签名函数
     """
     profile_id = None
     if profile_id_map and item.voice_id:
         profile_id = profile_id_map.get(item.voice_id)
+    audio = item.audio_url
+    if sign_url and audio:
+        audio = sign_url(audio)
     return UnifiedVoiceItemResponse(
         id=item.id,
         type="clone",
@@ -89,7 +96,7 @@ def _to_unified_response(item, profile_id_map: dict | None = None) -> UnifiedVoi
         language="zh-CN",
         voice_id=item.voice_id,
         voice_provider=item.voice_provider or "cosyvoice",
-        audio_url=item.audio_url,
+        audio_url=audio,
         duration=item.duration,
         file_size=item.file_size,
         status=item.status,
@@ -140,6 +147,7 @@ def list_voices_unified(
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     voice_repository: SQLAlchemyVoiceLibraryRepository = Depends(_get_voice_repository),
     clone_profile_repository: SQLAlchemyVoiceCloneProfileRepository = Depends(_get_clone_profile_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> UnifiedVoiceListResponse:
     """获取配音列表（预置音色 + 用户克隆音色）。
 
@@ -167,7 +175,7 @@ def list_voices_unified(
         # 批量查询 voice_id → profile_id 映射，填充 voice_clone_profile_id
         voice_ids = [i.voice_id for i in clone_items_raw if i.voice_id]
         profile_id_map = clone_profile_repository.find_profile_ids_by_voice_ids(voice_ids) if voice_ids else {}
-        clone_items = [_to_unified_response(i, profile_id_map) for i in clone_items_raw]
+        clone_items = [_to_unified_response(i, profile_id_map, sign_url) for i in clone_items_raw]
 
     # 组装结果
     if type == "preset":
@@ -224,6 +232,7 @@ def list_voices_legacy(
     limit: int = Query(50, ge=1, le=200),
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     voice_repository: SQLAlchemyVoiceLibraryRepository = Depends(_get_voice_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> ListVoiceLibraryResponse:
     """原有配音列表接口（仅返回用户克隆音色）。
 
@@ -233,7 +242,7 @@ def list_voices_legacy(
     use_case = ListVoiceLibraryUseCase(voice_repository)
     items, total = use_case.execute(user_id, status=status_filter, skip=skip, limit=limit)
     return ListVoiceLibraryResponse(
-        items=[_to_response(i) for i in items],
+        items=[_to_response(i, sign_url) for i in items],
         total=total,
     )
 
@@ -243,13 +252,14 @@ def get_voice(
     voice_id: str,
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     voice_repository: SQLAlchemyVoiceLibraryRepository = Depends(_get_voice_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> VoiceLibraryItemResponse:
     user_id = authenticated_user.user.id
     use_case = GetVoiceLibraryUseCase(voice_repository)
     item = use_case.execute(voice_id, user_id)
     if item is None:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice not found")
-    return _to_response(item)
+    return _to_response(item, sign_url)
 
 
 @router.post("", response_model=VoiceLibraryItemResponse, status_code=status.HTTP_201_CREATED)
@@ -258,6 +268,7 @@ def create_voice(
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     voice_repository: SQLAlchemyVoiceLibraryRepository = Depends(_get_voice_repository),
     user_repository: UserRepository = Depends(get_user_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> VoiceLibraryItemResponse:
     user_id = authenticated_user.user.id
     plan_name = _get_user_plan(user_id, user_repository)
@@ -283,7 +294,7 @@ def create_voice(
             status_code=status.HTTP_429_TOO_MANY_REQUESTS,
             detail=f"配音库配额已满（{exc.used}/{exc.limit}），请升级套餐",
         )
-    return _to_response(item)
+    return _to_response(item, sign_url)
 
 
 @router.put("/{voice_id}", response_model=VoiceLibraryItemResponse)
@@ -292,6 +303,7 @@ def update_voice(
     request: UpdateVoiceLibraryRequest,
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     voice_repository: SQLAlchemyVoiceLibraryRepository = Depends(_get_voice_repository),
+    sign_url=Depends(get_audio_url_signer),
 ) -> VoiceLibraryItemResponse:
     user_id = authenticated_user.user.id
     command = UpdateVoiceLibraryCommand(
@@ -313,7 +325,7 @@ def update_voice(
         item = use_case.execute(command)
     except NotFoundError:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Voice not found")
-    return _to_response(item)
+    return _to_response(item, sign_url)
 
 
 @router.delete("/{voice_id}", status_code=status.HTTP_204_NO_CONTENT, response_model=None)

apps/api/app/config.py

@@ -79,6 +79,27 @@ class Settings(BaseSettings):
     OSS_ACCESS_KEY_ID: str = ""
     OSS_ACCESS_KEY_SECRET: str = ""
     OSS_BUCKET_NAME: str = "xiaoxia-autocut"
+
+    @field_validator("OSS_ACCESS_KEY_ID", mode="before")
+    @classmethod
+    def validate_oss_access_key_id(cls, v):
+        if (v is None or v == "") and os.getenv("APP_ENV", "development") != "development":
+            raise ValueError(
+                "OSS_ACCESS_KEY_ID must be set via environment variable in non-development environments. "
+                "Check the server .env file (e.g. /var/lib/xiaoxia-saas-staging/.env)."
+            )
+        return v or ""
+
+    @field_validator("OSS_ACCESS_KEY_SECRET", mode="before")
+    @classmethod
+    def validate_oss_access_key_secret(cls, v):
+        if (v is None or v == "") and os.getenv("APP_ENV", "development") != "development":
+            raise ValueError(
+                "OSS_ACCESS_KEY_SECRET must be set via environment variable in non-development environments. "
+                "Check the server .env file (e.g. /var/lib/xiaoxia-saas-staging/.env)."
+            )
+        return v or ""
+
     OSS_DIRECT_UPLOAD_MAX_MB: int = Field(
         default=2000,
         validation_alias=AliasChoices("OSS_DIRECT_UPLOAD_MAX_MB", "MAX_UPLOAD_SIZE_MB"),
@@ -88,6 +109,9 @@ class Settings(BaseSettings):
     LOG_LEVEL: str = "INFO"
     CORS_ORIGINS_RAW: str = "http://localhost:3000,http://localhost:5173,http://localhost:8000"
 
+    # 渲染引擎选择：legacy=旧VideoComposeService，unified=新UnifiedRenderService
+    RENDER_ENGINE: str = "legacy"
+
     model_config = SettingsConfigDict(
         env_file=".env",
         env_file_encoding="utf-8",

apps/api/app/core/storage.py

@@ -34,13 +34,18 @@ class OSSStorageService:
         if has_key_id and has_key_secret:
             if oss2 is not None:
                 try:
+                    # P0-2 修复：oss2.Bucket 的 endpoint 必须带 https:// 前缀，
+                    # 否则 sign_url 默认生成 HTTP URL。
+                    bucket_endpoint = settings.OSS_ENDPOINT
+                    if not bucket_endpoint.startswith(("http://", "https://")):
+                        bucket_endpoint = f"https://{bucket_endpoint}"
                     auth = oss2.Auth(
                         settings.OSS_ACCESS_KEY_ID,
                         settings.OSS_ACCESS_KEY_SECRET,
                     )
                     self.bucket = oss2.Bucket(
                         auth,
-                        settings.OSS_ENDPOINT,
+                        bucket_endpoint,
                         settings.OSS_BUCKET_NAME,
                     )
                     logger.info(
@@ -64,6 +69,26 @@ class OSSStorageService:
         self.access_key_secret = settings.OSS_ACCESS_KEY_SECRET
         self.endpoint = settings.OSS_ENDPOINT
 
+    def diagnose(self) -> None:
+        """启动诊断：输出 OSS 配置状态，帮助排查预签名 URL 问题。"""
+        key_id_display = (
+            f"{self.access_key_id[:4]}...{self.access_key_id[-4:]}" if len(self.access_key_id) > 8 else "(empty)"
+        )
+        logger.info(
+            "[OSS诊断] endpoint=%s bucket_name=%s access_key_id=%s",
+            self.endpoint,
+            self.bucket_name,
+            key_id_display,
+        )
+        if self.bucket is None:
+            logger.error(
+                "[OSS诊断] ❌ bucket=None — 预签名URL不可用！"
+                "原因: OSS_ACCESS_KEY_ID/OSS_ACCESS_KEY_SECRET 未配置或 oss2 未安装。"
+                "请检查服务器 .env 文件（如 /var/lib/xiaoxia-saas-staging/.env）"
+            )
+        else:
+            logger.info("[OSS诊断] ✅ bucket 已配置，预签名URL可用")
+
     def _is_local_generated_url(self, storage_key_or_url: str) -> bool:
         parsed = urlparse(storage_key_or_url)
         path = parsed.path if parsed.scheme else storage_key_or_url
@@ -167,8 +192,7 @@ class OSSStorageService:
             if self._is_local_generated_url(storage_key_or_url):
                 return storage_key_or_url
             logger.warning(
-                "get_download_url: OSS bucket not configured, returning raw URL. "
-                "storage_key_or_url=%s",
+                "get_download_url: OSS bucket not configured, returning raw URL. " "storage_key_or_url=%s",
                 storage_key_or_url[:200],
             )
             return self.get_url(self._normalize_storage_key(storage_key_or_url))
@@ -184,8 +208,7 @@ class OSSStorageService:
             return signed
         except Exception:
             logger.exception(
-                "get_download_url: sign_url failed, falling back to raw URL. "
-                "storage_key=%s",
+                "get_download_url: sign_url failed, falling back to raw URL. " "storage_key=%s",
                 storage_key[:200],
             )
             return self.get_url(storage_key)
@@ -256,4 +279,5 @@ def get_storage_service() -> OSSStorageService:
     global _storage_service
     if _storage_service is None:
         _storage_service = OSSStorageService()
+        _storage_service.diagnose()
     return _storage_service

apps/api/app/core/task_enqueue.py

@@ -0,0 +1,221 @@
+import logging
+from typing import Any
+
+from app.core.celery_app import celery_app
+
+logger = logging.getLogger(__name__)
+
+# ── 限流阈值常量（全系统统一管理，不要在业务代码里硬编码） ──
+USER_PENDING_LIMIT = 3  # 单用户 pending 上限
+GLOBAL_PENDING_LIMIT = 20  # 全局 pending 上限
+
+
+class UserPendingLimitExceeded(Exception):
+    """用户 pending 任务数超限，返回 429。"""
+
+    def __init__(self, user_id: str, pending_count: int, limit: int):
+        self.user_id = user_id
+        self.pending_count = pending_count
+        self.limit = limit
+        super().__init__(f"用户 {user_id} pending 任务数 {pending_count} 超过上限 {limit}")
+
+
+class GlobalQueueFull(Exception):
+    """全局限流，返回 503。"""
+
+    def __init__(self, pending_count: int, limit: int):
+        self.pending_count = pending_count
+        self.limit = limit
+        super().__init__(f"系统 pending 任务数 {pending_count} 超过上限 {limit}")
+
+
+def check_queue_limits(
+    user_id: str,
+    generation_task_repository: Any,
+    *,
+    user_pending_limit: int = USER_PENDING_LIMIT,
+    global_pending_limit: int = GLOBAL_PENDING_LIMIT,
+) -> None:
+    """检查队列限流（预检查用，任务创建前调用），超限抛对应异常。
+
+    边界语义：>= 上限即拒绝（达到上限就不能再加新任务）。
+
+    Args:
+        user_id: 用户 ID
+        generation_task_repository: 任务仓储
+        user_pending_limit: 单用户 pending 上限，默认 USER_PENDING_LIMIT
+        global_pending_limit: 全局 pending 上限，默认 GLOBAL_PENDING_LIMIT
+
+    Raises:
+        GlobalQueueFull: 全局超限时抛出（优先级更高，先查全局）
+        UserPendingLimitExceeded: 用户超限时抛出
+    """
+    # 先查全局（系统级保护优先级更高）
+    global_pending = generation_task_repository.count_pending_total()
+    if global_pending >= global_pending_limit:
+        logger.warning(
+            "[队列限流] 全局 pending 任务数超限: %d/%d, user_id=%s",
+            global_pending,
+            global_pending_limit,
+            user_id,
+        )
+        raise GlobalQueueFull(pending_count=global_pending, limit=global_pending_limit)
+
+    # 再查用户级
+    if user_id:
+        user_pending = generation_task_repository.count_pending_by_user(user_id)
+        if user_pending >= user_pending_limit:
+            logger.warning(
+                "[队列限流] 用户 pending 任务数超限: user_id=%s, count=%d/%d",
+                user_id,
+                user_pending,
+                user_pending_limit,
+            )
+            raise UserPendingLimitExceeded(user_id=user_id, pending_count=user_pending, limit=user_pending_limit)
+
+
+def _mark_task_failed_safely(
+    task: Any,
+    generation_task_repository: Any,
+    log_prefix: str,
+    reason: str,
+) -> None:
+    """安全地把任务标记为 failed，更新失败只打日志不崩溃。"""
+    try:
+        task.mark_failed(f"任务被限流拒绝: {reason}")
+        generation_task_repository.update(task)
+    except Exception as update_err:
+        logger.error(
+            "%s 限流后更新状态也失败: task_id=%s error=%s",
+            log_prefix,
+            task.id,
+            update_err,
+            exc_info=True,
+        )
+
+
+def safe_enqueue_generation_task(
+    task: Any,
+    generation_task_repository: Any,
+    *,
+    user_id: str = "",
+    log_prefix: str = "[任务队列]",
+    log_task_status: bool = False,
+    user_pending_limit: int = USER_PENDING_LIMIT,
+    global_pending_limit: int = GLOBAL_PENDING_LIMIT,
+) -> bool:
+    """安全入队：入队前限流检查 → 发送 Celery 任务 → 入队后最终校验兜底。
+
+    边界说明：
+    入队前检查用 > 而非 >=。因为调用此函数时 task 已经是 pending 状态并计入 DB，
+    pending 总数包含了当前任务本身。pending > limit 等价于"其他任务数 >= limit"，
+    与预检查的 >= 语义一致（都是达到上限就拒绝新任务）。
+
+    入队后最终校验：发送 Celery 成功后再查一次 DB 计数，处理并发竞态场景
+    （两个请求同时通过入队前检查，后到的那个在这里被兜住）。
+
+    Args:
+        task: 生成任务对象，需有 id 属性和 mark_failed 方法（状态已为 pending）
+        generation_task_repository: 任务仓储，用于更新状态
+        user_id: 用户 ID，传了才做用户级限流检查
+        log_prefix: 日志前缀，便于区分调用来源
+        log_task_status: 成功日志中是否额外打印任务状态
+        user_pending_limit: 单用户 pending 上限，默认 USER_PENDING_LIMIT
+        global_pending_limit: 全局 pending 上限，默认 GLOBAL_PENDING_LIMIT
+
+    Returns:
+        True 表示入队成功，False 表示入队失败（已标记为 failed）
+
+    Raises:
+        GlobalQueueFull: 全局 pending 超限时抛出，任务会被标记为 failed
+        UserPendingLimitExceeded: 用户 pending 超限时抛出，任务会被标记为 failed
+    """
+    # ── 入队前检查：任务已是 pending，用 > 判断（包含当前任务） ──
+
+    # 全局限流检查（始终生效）
+    global_pending = generation_task_repository.count_pending_total()
+    if global_pending > global_pending_limit:
+        logger.warning(
+            "[队列限流] 全局 pending 任务数超限(入队前): %d/%d, user_id=%s",
+            global_pending,
+            global_pending_limit,
+            user_id or "unknown",
+        )
+        exc = GlobalQueueFull(pending_count=global_pending, limit=global_pending_limit)
+        _mark_task_failed_safely(task, generation_task_repository, log_prefix, str(exc))
+        raise exc
+
+    # 用户级限流检查（传了 user_id 才做）
+    if user_id:
+        user_pending = generation_task_repository.count_pending_by_user(user_id)
+        if user_pending > user_pending_limit:
+            logger.warning(
+                "[队列限流] 用户 pending 任务数超限(入队前): user_id=%s, count=%d/%d",
+                user_id,
+                user_pending,
+                user_pending_limit,
+            )
+            exc = UserPendingLimitExceeded(user_id=user_id, pending_count=user_pending, limit=user_pending_limit)
+            _mark_task_failed_safely(task, generation_task_repository, log_prefix, str(exc))
+            raise exc
+
+    # ── 发送 Celery 任务 ──
+    try:
+        celery_app.send_task("worker.generate_video", args=[task.id])
+    except Exception as e:
+        logger.error(
+            "%s 入队失败，标记为失败: task_id=%s error=%s",
+            log_prefix,
+            task.id,
+            e,
+            exc_info=True,
+        )
+        try:
+            task.mark_failed(f"任务入队失败: {e}")
+            generation_task_repository.update(task)
+        except Exception as update_err:
+            logger.error(
+                "%s 入队失败后更新状态也失败: task_id=%s error=%s",
+                log_prefix,
+                task.id,
+                update_err,
+                exc_info=True,
+            )
+        return False
+
+    # ── 入队后最终校验：并发竞态兜底 ──
+    # 发送成功后再查一次，防止两个请求同时通过入队前检查导致超限
+    global_after = generation_task_repository.count_pending_total()
+    user_after = generation_task_repository.count_pending_by_user(user_id) if user_id else 0
+
+    global_over = global_after > global_pending_limit
+    user_over = bool(user_id and user_after > user_pending_limit)
+
+    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)
+        else:
+            reason = f"用户 pending 超限(入队后): {user_after}/{user_pending_limit}"
+            exc = UserPendingLimitExceeded(user_id=user_id, pending_count=user_after, limit=user_pending_limit)
+
+        logger.warning(
+            "[队列限流] %s, task_id=%s, user_id=%s — 回滚状态为 failed",
+            reason,
+            task.id,
+            user_id or "unknown",
+        )
+        _mark_task_failed_safely(task, generation_task_repository, log_prefix, reason)
+        raise exc
+
+    # 入队成功日志
+    if log_task_status:
+        logger.info(
+            "%s 入队成功: task_id=%s, status=%s",
+            log_prefix,
+            task.id,
+            task.status,
+        )
+    else:
+        logger.info("%s 入队成功: task_id=%s", log_prefix, task.id)
+    return True

apps/api/app/dependencies.py

@@ -201,7 +201,37 @@ def get_voice_clone_profile_repository(
 
 
 def get_cosyvoice_service():
-    """Provide the CosyVoice service instance."""
+    """Provide the CosyVoice service instance.
+
+    注入 OSS 音频URL预签名函数，确保私有bucket下的参考音频
+    能被 CosyVoice 服务器下载。
+    """
+    from app.core.storage import get_storage_service
+
     from packages.application.cosyvoice_service import CosyVoiceService
 
-    return CosyVoiceService()
+    storage = get_storage_service()
+
+    def _sign_audio_url(url: str) -> str:
+        """对音频URL做预签名，私有bucket下 CosyVoice 服务器才能下载."""
+        return storage.get_download_url(url, expires_seconds=86400)
+
+    return CosyVoiceService(audio_url_signer=_sign_audio_url)
+
+
+def get_audio_url_signer():
+    """提供音频URL预签名函数（24小时有效期）。
+
+    用于所有 API 返回给前端的音频 URL，确保私有 OSS bucket 下可正常访问。
+    空 URL、非 OSS URL 直接原样返回；签名失败时回退到原始 URL。
+    """
+    from app.core.storage import get_storage_service
+
+    storage = get_storage_service()
+
+    def sign_audio_url(url: str) -> str:
+        if not url:
+            return url
+        return storage.get_download_url(url, expires_seconds=86400)
+
+    return sign_audio_url

apps/api/app/schemas/generation_task.py

@@ -1,4 +1,6 @@
-from pydantic import BaseModel, Field, model_validator
+import json
+
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 
 class CreateGenerationTaskRequest(BaseModel):
@@ -62,6 +64,21 @@ class GenerationTaskResponse(BaseModel):
     progress: float
     result_count: int
     error_message: str
+    logs: list[dict] = Field(default_factory=list)
+
+    @field_validator("logs", mode="before")
+    @classmethod
+    def _parse_logs(cls, v: object) -> list[dict]:
+        """将 JSON 字符串解析为 list[dict]。"""
+        if isinstance(v, str):
+            try:
+                parsed = json.loads(v)
+                return parsed if isinstance(parsed, list) else []
+            except (json.JSONDecodeError, TypeError):
+                return []
+        if isinstance(v, list):
+            return v
+        return []
 
 
 class BatchGenerationTaskResponse(BaseModel):

apps/worker/video_processing/__init__.py

@@ -5,6 +5,7 @@
 # 共享工具模块（供 editing_modes / generation / edit_plan_generation 等复用）
 from . import dedup_helpers, ffmpeg_utils, oss_helpers
 from .processor import VideoProcessor, VideoResult
+from .render_adapter import RenderAdapter, RenderAdapterResult
 from .unified_render_service import RenderResult, UnifiedRenderService
 
 __all__ = [
@@ -15,4 +16,6 @@ __all__ = [
     "dedup_helpers",
     "UnifiedRenderService",
     "RenderResult",
+    "RenderAdapter",
+    "RenderAdapterResult",
 ]

apps/worker/video_processing/editing_modes.py

@@ -1,657 +0,0 @@
-"""
-视频剪辑模式处理器
-支持四种剪辑模式：一镜到底、画中画、口播、口播+画中画
-"""
-
-import logging
-import os
-import sys
-import tempfile
-from dataclasses import dataclass
-
-if sys.version_info >= (3, 11):
-    from enum import StrEnum
-else:
-    from enum import Enum
-
-    class StrEnum(str, Enum):
-        pass
-
-
-from pathlib import Path
-from typing import Optional
-
-from video_processing.ffmpeg_utils import FFMPEG_BIN, probe_video_info, run_ffmpeg
-
-logger = logging.getLogger(__name__)
-
-
-# 从 domain 层导入 EditingMode，避免重复定义
-from packages.domain.editing_mode import EditingMode
-
-
-class PIPPosition(StrEnum):
-    """画中画位置枚举"""
-
-    TOP_LEFT = "top_left"
-    TOP_RIGHT = "top_right"
-    BOTTOM_LEFT = "bottom_left"
-    BOTTOM_RIGHT = "bottom_right"
-
-
-@dataclass
-class EditingModeConfig:
-    """剪辑模式配置"""
-
-    mode: EditingMode
-    output_width: int = 1280
-    output_height: int = 720
-    output_fps: int = 25
-    pip_position: PIPPosition = PIPPosition.TOP_RIGHT
-    pip_scale: float = 0.25  # 画中画占主画面的比例
-    transition_duration: float = 0.5  # 转场时长（秒）
-    output_codec: str = "libx264"
-    output_preset: str = "medium"
-    output_crf: int = 23
-
-
-class EditingModeProcessor:
-    """剪辑模式处理器"""
-
-    def __init__(self, config: EditingModeConfig, work_dir: Optional[str] = None):
-        """
-        初始化剪辑模式处理器
-
-        Args:
-            config: 剪辑模式配置
-            work_dir: 工作目录，默认使用系统临时目录
-        """
-        self.config = config
-        self.work_dir = work_dir or tempfile.gettempdir()
-
-    def process(
-        self,
-        video_paths: list[str],
-        audio_path: Optional[str] = None,
-        output_path: Optional[str] = None,
-    ) -> str:
-        """
-        根据模式处理视频，返回输出文件路径
-
-        Args:
-            video_paths: 视频素材路径列表
-            audio_path: 音频路径（用于口播模式）
-            output_path: 输出文件路径，默认自动生成
-
-        Returns:
-            输出文件路径
-        """
-        if not video_paths:
-            raise ValueError("video_paths cannot be empty")
-
-        self._validate_inputs(video_paths, audio_path)
-
-        if output_path is None:
-            output_path = self._generate_output_path()
-
-        logger.info(f"Processing videos with mode: {self.config.mode}, count: {len(video_paths)}")
-
-        try:
-            if self.config.mode == EditingMode.ONE_TAKE:
-                return self._one_take(video_paths, output_path)
-            elif self.config.mode == EditingMode.PIP:
-                return self._pip(video_paths, output_path)
-            elif self.config.mode == EditingMode.VOICE_OVER:
-                return self._voice_over(video_paths, audio_path, output_path)
-            elif self.config.mode == EditingMode.VOICE_PIP:
-                return self._voice_pip(video_paths, audio_path, output_path)
-            else:
-                raise ValueError(f"Unsupported editing mode: {self.config.mode}")
-        except Exception as e:
-            logger.error(f"Error processing videos: {e}")
-            raise
-
-    def _validate_inputs(self, video_paths: list[str], audio_path: Optional[str]) -> None:
-        """验证输入文件"""
-        for path in video_paths:
-            if not os.path.exists(path):
-                raise FileNotFoundError(f"Video file not found: {path}")
-            if not os.path.getsize(path) > 0:
-                raise ValueError(f"Video file is empty: {path}")
-
-        if audio_path and not os.path.exists(audio_path):
-            raise FileNotFoundError(f"Audio file not found: {audio_path}")
-
-    def _generate_output_path(self) -> str:
-        """生成输出文件路径"""
-        os.makedirs(self.work_dir, exist_ok=True)
-        return os.path.join(self.work_dir, f"output_{self.config.mode}_{os.getpid()}.mp4")
-
-    def _run_ffmpeg(self, command: list[str], capture_output: bool = True) -> tuple:
-        """执行 FFmpeg 命令 — 委托给共享 ffmpeg_utils.run_ffmpeg"""
-        try:
-            return run_ffmpeg(command, capture_output=capture_output)
-        except RuntimeError as e:
-            logger.error(f"FFmpeg error: {e}")
-            raise
-
-    def _get_video_info(self, video_path: str) -> dict:
-        """获取视频信息 — 委托给共享 ffmpeg_utils.probe_video_info，补充 codec/size 字段"""
-        try:
-            info = probe_video_info(video_path)
-            info["codec"] = "unknown"
-            info["size"] = os.path.getsize(video_path) if os.path.exists(video_path) else 0
-            return info
-        except Exception as e:
-            logger.warning(f"Failed to get video info for {video_path}: {e}")
-            return {"width": 0, "height": 0, "fps": 25, "duration": 0, "codec": "unknown", "size": 0}
-
-    def _get_pip_position_offset(
-        self, main_width: int, main_height: int, pip_width: int, pip_height: int
-    ) -> tuple[int, int]:
-        """获取画中画位置偏移量"""
-        margin = 10
-        position_offsets = {
-            PIPPosition.TOP_LEFT: (margin, margin),
-            PIPPosition.TOP_RIGHT: (main_width - pip_width - margin, margin),
-            PIPPosition.BOTTOM_LEFT: (margin, main_height - pip_height - margin),
-            PIPPosition.BOTTOM_RIGHT: (main_width - pip_width - margin, main_height - pip_height - margin),
-        }
-        return position_offsets.get(self.config.pip_position, position_offsets[PIPPosition.TOP_RIGHT])
-
-    def _normalize_video(self, input_path: str, output_path: str) -> dict:
-        """标准化视频格式：先统一帧率，再缩放/填充"""
-        command = [
-            FFMPEG_BIN,
-            "-y",
-            "-i",
-            input_path,
-            "-r",
-            str(self.config.output_fps),  # 先统一帧率
-            "-vf",
-            f"scale={self.config.output_width}:{self.config.output_height}:force_original_aspect_ratio=decrease,pad={self.config.output_width}:{self.config.output_height}:(ow-iw)/2:(oh-ih)/2,setsar=1",
-            "-r",
-            str(self.config.output_fps),
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            "-movflags",
-            "+faststart",
-            "-an",
-            output_path,
-        ]
-        run_ffmpeg(command)
-        return self._get_video_info(output_path)
-
-    def _one_take(self, video_paths: list[str], output_path: str) -> str:
-        """一镜到底模式：顺序拼接视频，添加淡入淡出转场"""
-        if len(video_paths) == 1:
-            return self._normalize_video(video_paths[0], output_path)
-
-        normalized_paths = []
-        for i, path in enumerate(video_paths):
-            normalized = os.path.join(self.work_dir, f"normalized_{i}_{os.getpid()}.mp4")
-            self._normalize_video(path, normalized)
-            normalized_paths.append(normalized)
-
-        durations = [self._get_video_info(p)["duration"] for p in normalized_paths]
-
-        if len(normalized_paths) <= 5:
-            output_path = self._one_take_with_xfade(normalized_paths, durations, output_path)
-        else:
-            output_path = self._one_take_simple_concat(normalized_paths, output_path)
-
-        for p in normalized_paths:
-            try:
-                if p != output_path:
-                    os.remove(p)
-            except Exception as e:
-                logger.warning(f"Operation failed in apps/worker/video_processing/editing_modes.py: {e}", exc_info=True)
-
-        return output_path
-
-    def _one_take_with_xfade(self, normalized_paths: list[str], durations: list[float], output_path: str) -> str:
-        """使用 xfade 滤镜实现转场"""
-        if len(normalized_paths) == 2:
-            transition = self.config.transition_duration
-            offset1 = durations[0] - transition / 2
-
-            command = [
-                FFMPEG_BIN,
-                "-y",
-                "-i",
-                normalized_paths[0],
-                "-i",
-                normalized_paths[1],
-                "-filter_complex",
-                f"[0:v][1:v]xfade=transition=fade:duration={transition}:offset={offset1}[v]",
-                "-map",
-                "[v]",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                output_path,
-            ]
-            run_ffmpeg(command)
-            return output_path
-        else:
-            return self._one_take_simple_concat(normalized_paths, output_path)
-
-    def _one_take_simple_concat(self, normalized_paths: list[str], output_path: str) -> str:
-        """使用 concat demuxer 简单拼接"""
-        concat_file = os.path.join(self.work_dir, f"concat_list_{os.getpid()}.txt")
-        with open(concat_file, "w") as f:
-            for path in normalized_paths:
-                f.write(f"file '{os.path.abspath(path)}'\n")
-
-        command = [
-            FFMPEG_BIN,
-            "-y",
-            "-f",
-            "concat",
-            "-safe",
-            "0",
-            "-i",
-            concat_file,
-            "-c",
-            "copy",
-            output_path,
-        ]
-        run_ffmpeg(command)
-
-        try:
-            os.remove(concat_file)
-        except Exception as e:
-            logger.warning(f"Operation failed in apps/worker/video_processing/editing_modes.py: {e}", exc_info=True)
-
-        return output_path
-
-    def _pip(self, video_paths: list[str], output_path: str) -> str:
-        """画中画模式：主视频全屏，后续视频叠加在角落"""
-        if not video_paths:
-            raise ValueError("No video paths provided")
-
-        main_video = video_paths[0]
-        main_normalized = os.path.join(self.work_dir, f"main_{os.getpid()}.mp4")
-        main_info = self._normalize_video(main_video, main_normalized)
-
-        if len(video_paths) == 1:
-            os.rename(main_normalized, output_path)
-            return output_path
-
-        pip_width = int(self.config.output_width * self.config.pip_scale)
-        pip_height = int(self.config.output_height * self.config.pip_scale)
-        x_offset, y_offset = self._get_pip_position_offset(
-            self.config.output_width, self.config.output_height, pip_width, pip_height
-        )
-
-        pip_normalized = os.path.join(self.work_dir, f"pip_{os.getpid()}.mp4")
-        pip_info = self._get_video_info(video_paths[1])
-
-        if pip_info["duration"] > main_info["duration"]:
-            temp_pip = os.path.join(self.work_dir, f"pip_temp_{os.getpid()}.mp4")
-            command = [
-                FFMPEG_BIN,
-                "-y",
-                "-i",
-                video_paths[1],
-                "-t",
-                str(main_info["duration"]),
-                "-vf",
-                f"scale={pip_width}:{pip_height}",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                temp_pip,
-            ]
-            run_ffmpeg(command)
-            pip_normalized_input = temp_pip
-        else:
-            command = [
-                FFMPEG_BIN,
-                "-y",
-                "-i",
-                video_paths[1],
-                "-vf",
-                f"scale={pip_width}:{pip_height}",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                pip_normalized,
-            ]
-            run_ffmpeg(command)
-            pip_normalized_input = pip_normalized
-
-        if main_info["duration"] > pip_info["duration"]:
-            looped_pip = os.path.join(self.work_dir, f"pip_looped_{os.getpid()}.mp4")
-            command = [
-                FFMPEG_BIN,
-                "-y",
-                "-stream_loop",
-                "-1",
-                "-i",
-                pip_normalized_input,
-                "-t",
-                str(main_info["duration"]),
-                "-vf",
-                f"scale={pip_width}:{pip_height}",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                looped_pip,
-            ]
-            run_ffmpeg(command)
-            pip_normalized_input = looped_pip
-
-        command = [
-            FFMPEG_BIN,
-            "-y",
-            "-i",
-            main_normalized,
-            "-i",
-            pip_normalized_input,
-            "-filter_complex",
-            f"[0:v][1:v]overlay={x_offset}:{y_offset}[v]",
-            "-map",
-            "[v]",
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            output_path,
-        ]
-        run_ffmpeg(command)
-
-        for temp_file in [main_normalized, pip_normalized]:
-            if temp_file and temp_file != output_path:
-                try:
-                    os.remove(temp_file)
-                except Exception as e:
-                    logger.warning(
-                        f"Operation failed in apps/worker/video_processing/editing_modes.py: {e}", exc_info=True
-                    )
-
-        return output_path
-
-    def _voice_over(self, video_paths: list[str], audio_path: Optional[str], output_path: str) -> str:
-        """口播模式：背景画面 + 配音"""
-        if not audio_path:
-            raise ValueError("audio_path is required for VOICE_OVER mode")
-
-        if not video_paths:
-            raise ValueError("No background video provided")
-
-        audio_info = self._get_video_info(audio_path)
-        audio_duration = audio_info["duration"]
-
-        bg_normalized = os.path.join(self.work_dir, f"bg_{os.getpid()}.mp4")
-        bg_info = self._normalize_video(video_paths[0], bg_normalized)
-
-        if bg_info["duration"] < audio_duration:
-            looped_bg = os.path.join(self.work_dir, f"bg_looped_{os.getpid()}.mp4")
-            command = [
-                FFMPEG_BIN,
-                "-y",
-                "-stream_loop",
-                "-1",
-                "-i",
-                bg_normalized,
-                "-t",
-                str(audio_duration),
-                "-vf",
-                f"scale={self.config.output_width}:{self.config.output_height}",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                looped_bg,
-            ]
-            run_ffmpeg(command)
-            bg_normalized = looped_bg
-        elif bg_info["duration"] > audio_duration:
-            temp_bg = os.path.join(self.work_dir, f"bg_trimmed_{os.getpid()}.mp4")
-            command = [
-                FFMPEG_BIN,
-                "-y",
-                "-i",
-                bg_normalized,
-                "-t",
-                str(audio_duration),
-                "-c:v",
-                "copy",
-                temp_bg,
-            ]
-            run_ffmpeg(command)
-            bg_normalized = temp_bg
-
-        blurred_bg = os.path.join(self.work_dir, f"bg_blurred_{os.getpid()}.mp4")
-        command = [
-            FFMPEG_BIN,
-            "-y",
-            "-i",
-            bg_normalized,
-            "-vf",
-            f"boxblur=5:5,scale={self.config.output_width}:{self.config.output_height}",
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            blurred_bg,
-        ]
-        run_ffmpeg(command)
-
-        command = [
-            FFMPEG_BIN,
-            "-y",
-            "-i",
-            blurred_bg,
-            "-i",
-            audio_path,
-            "-filter_complex",
-            "[0:v]drawbox=x=0:y=0:w=iw:h=ih:color=black@0.3:t=fill[v]",
-            "-map",
-            "[v]",
-            "-map",
-            "1:a",
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            "-shortest",
-            output_path,
-        ]
-        run_ffmpeg(command)
-
-        for temp_file in [bg_normalized, blurred_bg]:
-            try:
-                if temp_file != output_path:
-                    os.remove(temp_file)
-            except Exception as e:
-                logger.warning(f"Operation failed in apps/worker/video_processing/editing_modes.py: {e}", exc_info=True)
-
-        return output_path
-
-    def _voice_pip(self, video_paths: list[str], audio_path: Optional[str], output_path: str) -> str:
-        """口播+画中画模式：口播视频在角落，其他视频作为背景"""
-        if not video_paths:
-            raise ValueError("No video paths provided")
-
-        if len(video_paths) == 1:
-            return self._normalize_video(video_paths[0], output_path)
-
-        voice_video = video_paths[0]
-        bg_video = video_paths[1] if len(video_paths) > 1 else video_paths[0]
-
-        voice_normalized = os.path.join(self.work_dir, f"voice_{os.getpid()}.mp4")
-        voice_info = self._normalize_video(voice_video, voice_normalized)
-
-        bg_normalized = os.path.join(self.work_dir, f"bg_{os.getpid()}.mp4")
-        bg_info = self._normalize_video(bg_video, bg_normalized)
-
-        final_duration = min(voice_info["duration"], bg_info["duration"])
-
-        pip_width = int(self.config.output_width * self.config.pip_scale)
-        pip_height = int(self.config.output_height * self.config.pip_scale)
-        x_offset, y_offset = self._get_pip_position_offset(
-            self.config.output_width, self.config.output_height, pip_width, pip_height
-        )
-
-        voice_adjusted = os.path.join(self.work_dir, f"voice_adj_{os.getpid()}.mp4")
-        command = [
-            FFMPEG_BIN,
-            "-y",
-            "-i",
-            voice_normalized,
-            "-t",
-            str(final_duration),
-            "-vf",
-            f"scale={pip_width}:{pip_height}",
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            voice_adjusted,
-        ]
-        run_ffmpeg(command)
-
-        bg_adjusted = os.path.join(self.work_dir, f"bg_adj_{os.getpid()}.mp4")
-        command = [
-            FFMPEG_BIN,
-            "-y",
-            "-i",
-            bg_normalized,
-            "-t",
-            str(final_duration),
-            "-c:v",
-            "copy",
-            bg_adjusted,
-        ]
-        run_ffmpeg(command)
-
-        if audio_path:
-            command = [
-                FFMPEG_BIN,
-                "-y",
-                "-i",
-                bg_adjusted,
-                "-i",
-                voice_adjusted,
-                "-i",
-                audio_path,
-                "-filter_complex",
-                f"[0:v][1:v]overlay={x_offset}:{y_offset}[v]",
-                "-map",
-                "[v]",
-                "-map",
-                "2:a",
-                "-shortest",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                output_path,
-            ]
-        else:
-            command = [
-                FFMPEG_BIN,
-                "-y",
-                "-i",
-                bg_adjusted,
-                "-i",
-                voice_adjusted,
-                "-filter_complex",
-                f"[0:v][1:v]overlay={x_offset}:{y_offset}[v]",
-                "-map",
-                "[v]",
-                "-map",
-                "1:a",
-                "-shortest",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                output_path,
-            ]
-        run_ffmpeg(command)
-
-        for temp_file in [voice_normalized, voice_adjusted, bg_normalized, bg_adjusted]:
-            try:
-                if temp_file != output_path:
-                    os.remove(temp_file)
-            except Exception as e:
-                logger.warning(f"Operation failed in apps/worker/video_processing/editing_modes.py: {e}", exc_info=True)
-
-        return output_path
-
-
-def create_processor(mode: str, work_dir: Optional[str] = None, **kwargs) -> EditingModeProcessor:
-    """便捷工厂函数：创建剪辑模式处理器"""
-    try:
-        editing_mode = EditingMode(mode)
-    except ValueError:
-        raise ValueError(f"Invalid editing mode: {mode}. Valid modes: {[m.value for m in EditingMode]}")
-
-    config = EditingModeConfig(
-        mode=editing_mode,
-        output_width=kwargs.get("output_width", 1280),
-        output_height=kwargs.get("output_height", 720),
-        output_fps=kwargs.get("output_fps", 25),
-        pip_position=PIPPosition(kwargs.get("pip_position", "top_right")),
-        pip_scale=kwargs.get("pip_scale", 0.25),
-        transition_duration=kwargs.get("transition_duration", 0.5),
-    )
-
-    return EditingModeProcessor(config=config, work_dir=work_dir)

apps/worker/video_processing/ffmpeg_utils.py

@@ -1,8 +1,7 @@
-"""FFmpeg 工具函数 — 从 editing_modes.py / video_compose_service.py 提取的共享原语.
+"""FFmpeg 工具函数 — 共享原语.
 
 提供 FFmpeg / FFprobe 调用、视频信息探测、视频标准化、xfade 转场滤镜构建
-等底层能力，供 EditingModeProcessor、VideoComposeService、UnifiedRenderService
-共同复用。
+等底层能力，供 UnifiedRenderService、VideoComposeService 等复用。
 """
 
 from __future__ import annotations
@@ -32,6 +31,10 @@ XFADE_TRANSITION_MAP: dict[str, str] = {
     "slide_left": "slideleft",
     "slideright": "slideright",
     "slide_right": "slideright",
+    "slideup": "slideup",
+    "slide_up": "slideup",
+    "slidedown": "slidedown",
+    "slide_down": "slidedown",
     "dissolve": "dissolve",
     "wipe": "wipeleft",
     "wipeleft": "wipeleft",

apps/worker/video_processing/oss_helpers.py

@@ -40,6 +40,9 @@ def oss_settings() -> tuple[str, str, str, str] | None:
 def oss_bucket() -> oss2.Bucket | None:
     """获取 OSS Bucket 实例。
 
+    P0-2 修复：endpoint 不带 scheme 时自动补 https:// 前缀，
+    确保 sign_url 等依赖 scheme 的方法返回 HTTPS URL。
+
     Returns:
         oss2.Bucket 实例，配置缺失时返回 None。
     """
@@ -47,6 +50,9 @@ def oss_bucket() -> oss2.Bucket | None:
     if settings is None:
         return None
     access_key_id, access_key_secret, endpoint, bucket_name = settings
+    # endpoint 无 scheme 时补 https://，与 API 端 storage.py 保持一致
+    if not endpoint.startswith(("http://", "https://")):
+        endpoint = f"https://{endpoint}"
     return oss2.Bucket(oss2.Auth(access_key_id, access_key_secret), endpoint, bucket_name)
 
 
@@ -105,13 +111,37 @@ def upload_to_oss(local_path: Path, storage_key: str) -> str | None:
         settings = oss_settings()
         if settings:
             _, _, endpoint, bucket_name = settings
-            return f"https://{bucket_name}.{endpoint.replace('https://', '').replace('http://', '')}/{storage_key}"
+            endpoint_clean = endpoint.replace("https://", "").replace("http://", "")
+            return f"https://{bucket_name}.{endpoint_clean}/{storage_key}"
         return None
     except Exception:
         logger.exception("上传 OSS 失败: %s", storage_key)
         return None
 
 
+def get_signed_download_url(storage_key_or_url: str, expires_seconds: int = 3600) -> str | None:
+    """生成预签名下载 URL（用于私有 bucket 的 URL 校验或临时下载）。
+
+    Args:
+        storage_key_or_url: 存储键或完整 URL（URL 会自动提取 path）
+        expires_seconds: 签名有效期（秒）
+
+    Returns:
+        预签名 URL，失败或 OSS 未配置时返回 None。
+    """
+    bucket = oss_bucket()
+    if bucket is None:
+        return None
+    try:
+        storage_key = normalize_storage_key(storage_key_or_url)
+        signed = bucket.sign_url("GET", storage_key, expires_seconds)
+        logger.info("生成预签名URL: key=%s url_prefix=%s", storage_key[:80], signed[:60])
+        return signed
+    except Exception:
+        logger.exception("生成预签名URL失败: %s", storage_key_or_url[:80])
+        return None
+
+
 # ── Asset 解析 ────────────────────────────────────────────────────────────────
 
 

apps/worker/video_processing/render_adapter.py

@@ -0,0 +1,289 @@
+"""统一渲染引擎适配层 — Phase 2.
+
+将 EditPlan + EditPlanClips（来自 DB）适配为 UnifiedRenderService 的输入格式，
+封装素材下载、渲染执行、结果上传的完整流程。
+
+职责：
+  1. 从 DB 读取 EditPlan + EditPlanClips
+  2. 下载素材到本地，构建 asset_path_map
+  3. 调用 UnifiedRenderService 执行渲染
+  4. 上传渲染结果到 OSS
+  5. 支持进度回调（对接 JobService）
+"""
+
+from __future__ import annotations
+
+import logging
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+from sqlalchemy.orm import Session
+from video_processing.oss_helpers import download_asset, upload_to_oss
+from video_processing.unified_render_service import (
+    RenderResult,
+    UnifiedRenderService,
+)
+
+from packages.adapters.sqlalchemy_impl.edit_plan_clip_repository import (
+    SQLAlchemyEditPlanClipRepository,
+)
+from packages.adapters.sqlalchemy_impl.edit_plan_repository import (
+    SQLAlchemyEditPlanRepository,
+)
+from packages.domain.edit_plan import EditPlan, EditPlanStatus
+from packages.domain.edit_plan_clip import EditPlanClip, EditPlanClipStatus
+
+logger = logging.getLogger(__name__)
+
+
+# ── 数据结构 ──────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class RenderAdapterResult:
+    """渲染适配结果。"""
+
+    success: bool
+    output_url: str = ""
+    output_path: Path | None = None
+    duration: float = 0.0
+    file_size: int = 0
+    width: int = 0
+    height: int = 0
+    clip_count: int = 0
+    error_message: str = ""
+
+
+ProgressCallback = Callable[[float, str], None]
+"""进度回调：(progress_0_100, stage_description) → None"""
+
+
+# ── 适配层主体 ────────────────────────────────────────────────────────────────
+
+
+class RenderAdapter:
+    """统一渲染引擎适配层。
+
+    桥接 EditPlan 领域模型与 UnifiedRenderService 图层模型。
+
+    用法::
+
+        adapter = RenderAdapter(db)
+        result = adapter.render_plan(
+            plan_id=plan_id,
+            job_id=job_id,
+            progress_cb=lambda p, s: job_service.update_progress(job_id, p, s),
+        )
+    """
+
+    def __init__(self, db: Session) -> None:
+        self._db = db
+        self._plan_repo = SQLAlchemyEditPlanRepository(db)
+        self._clip_repo = SQLAlchemyEditPlanClipRepository(db)
+
+    # ── 公开方法 ──────────────────────────────────────────────────────────
+
+    def render_plan(
+        self,
+        plan_id: str,
+        *,
+        job_id: str = "",
+        work_dir: Path | None = None,
+        progress_cb: ProgressCallback | None = None,
+    ) -> RenderAdapterResult:
+        """渲染一个 EditPlan。
+
+        完整流程：
+        1. 加载计划与片段
+        2. 下载素材
+        3. 执行统一渲染
+        4. 上传结果
+
+        Args:
+            plan_id: EditPlan ID
+            job_id: 关联的 Job ID（用于结果存储路径）
+            work_dir: 工作目录，不传则使用临时目录
+            progress_cb: 进度回调函数
+
+        Returns:
+            RenderAdapterResult
+        """
+        temp_dir = None
+        try:
+            # 0. 准备工作目录
+            if work_dir is None:
+                temp_dir = tempfile.mkdtemp(prefix="render_")
+                work_dir = Path(temp_dir)
+            work_dir.mkdir(parents=True, exist_ok=True)
+
+            self._report_progress(progress_cb, 5.0, "加载剪辑计划")
+
+            # 1. 加载计划与片段
+            plan = self._plan_repo.get(plan_id)
+            if plan is None:
+                return RenderAdapterResult(
+                    success=False,
+                    error_message=f"剪辑计划不存在: {plan_id}",
+                )
+
+            clips = self._clip_repo.list_by_plan(plan_id, skip=0, limit=10000)
+            ready_clips = [c for c in clips if c.status == EditPlanClipStatus.READY and c.asset_id]
+            ready_clips.sort(key=lambda c: c.order)
+
+            if not ready_clips:
+                return RenderAdapterResult(
+                    success=False,
+                    error_message="没有可渲染的就绪片段",
+                    clip_count=0,
+                )
+
+            logger.info(
+                "开始渲染: plan_id=%s job_id=%s ready_clips=%d",
+                plan_id,
+                job_id,
+                len(ready_clips),
+            )
+
+            self._report_progress(progress_cb, 15.0, f"下载素材（{len(ready_clips)} 个）")
+
+            # 2. 下载素材
+            asset_path_map = self._download_assets(ready_clips, work_dir)
+            if not asset_path_map:
+                return RenderAdapterResult(
+                    success=False,
+                    error_message="所有素材下载失败",
+                    clip_count=len(ready_clips),
+                )
+
+            self._report_progress(progress_cb, 40.0, "执行视频渲染")
+
+            # 3. 执行统一渲染
+            render_svc = UnifiedRenderService(
+                plan=plan,
+                clips=ready_clips,
+                asset_path_map=asset_path_map,
+                work_dir=work_dir,
+            )
+            result = render_svc.render()
+
+            self._report_progress(progress_cb, 80.0, "上传渲染结果")
+
+            # 4. 上传结果
+            storage_key = f"rendered/{plan_id}/{job_id or plan_id}.mp4"
+            output_url = upload_to_oss(result.output_path, storage_key)
+
+            self._report_progress(progress_cb, 100.0, "渲染完成")
+
+            return RenderAdapterResult(
+                success=True,
+                output_url=output_url or "",
+                output_path=result.output_path,
+                duration=result.duration,
+                file_size=result.file_size,
+                width=result.width,
+                height=result.height,
+                clip_count=len(ready_clips),
+            )
+
+        except Exception as exc:
+            logger.exception("渲染失败: plan_id=%s", plan_id)
+            return RenderAdapterResult(
+                success=False,
+                error_message=str(exc)[:500],
+            )
+        finally:
+            # 清理临时目录
+            if temp_dir:
+                import shutil
+
+                try:
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+                except Exception:
+                    pass
+
+    def validate_plan(self, plan_id: str) -> tuple[bool, list[str], list[str], int, int]:
+        """校验计划是否可渲染（兼容 VideoComposeService.validate_compose 接口）。
+
+        Returns:
+            (valid, errors, warnings, ready_clip_count, total_clip_count)
+        """
+        errors: list[str] = []
+        warnings: list[str] = []
+
+        plan = self._plan_repo.get(plan_id)
+        if plan is None:
+            return False, [f"剪辑计划不存在: {plan_id}"], [], 0, 0
+
+        if plan.status not in (EditPlanStatus.EDITING, EditPlanStatus.RENDERING):
+            errors.append(f"计划状态不正确，需要 editing 或 rendering，当前: {plan.status}")
+
+        clips = self._clip_repo.list_by_plan(plan_id, skip=0, limit=10000)
+        if not clips:
+            errors.append("计划没有任何片段")
+            return False, errors, warnings, 0, 0
+
+        clips.sort(key=lambda c: c.order)
+
+        ready_count = 0
+        pending_count = 0
+        no_asset_count = 0
+
+        for clip in clips:
+            if clip.status == EditPlanClipStatus.READY:
+                ready_count += 1
+                if not clip.asset_id:
+                    errors.append(f"片段 {clip.id} (order={clip.order}) 没有分配素材")
+                    no_asset_count += 1
+            elif clip.status == EditPlanClipStatus.PENDING:
+                pending_count += 1
+            elif clip.status == EditPlanClipStatus.FAILED:
+                warnings.append(f"片段 {clip.id} (order={clip.order}) 状态为 failed，已跳过")
+
+        if ready_count == 0:
+            errors.append("没有就绪（ready）的片段可以合成")
+
+        if pending_count > 0:
+            warnings.append(f"有 {pending_count} 个片段仍处于 pending 状态")
+
+        return len(errors) == 0, errors, warnings, ready_count, len(clips)
+
+    # ── 内部方法 ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _report_progress(progress_cb: ProgressCallback | None, progress: float, stage: str) -> None:
+        """上报进度。"""
+        if progress_cb is not None:
+            try:
+                progress_cb(progress, stage)
+            except Exception:
+                logger.exception("进度回调失败")
+
+    @staticmethod
+    def _download_assets(clips: list[EditPlanClip], work_dir: Path) -> dict[str, Path]:
+        """下载片段素材到本地，返回 asset_id → local_path 映射。
+
+        只保留下载成功的素材。
+        """
+        asset_dir = work_dir / "assets"
+        asset_dir.mkdir(exist_ok=True)
+
+        asset_path_map: dict[str, Path] = {}
+
+        for clip in clips:
+            asset_id = clip.asset_id
+            if not asset_id:
+                continue
+
+            # 生成安全的本地文件名
+            safe_name = f"clip_{clip.order:04d}_{abs(hash(asset_id)) % 100000:05d}.mp4"
+            local_path = asset_dir / safe_name
+
+            if download_asset(asset_id, local_path):
+                asset_path_map[asset_id] = local_path
+                logger.debug("素材下载成功: clip_id=%s asset_id=%s", clip.id, asset_id[:60])
+            else:
+                logger.warning("素材下载失败: clip_id=%s asset_id=%s", clip.id, asset_id[:60])
+
+        return asset_path_map

apps/worker/video_processing/unified_render_service.py

@@ -43,6 +43,14 @@ from video_processing.ffmpeg_utils import (
 logger = logging.getLogger(__name__)
 
 
+# ── 常量 ──────────────────────────────────────────────────────────────────────
+
+# Title/Subtitle 默认边距（像素）
+TITLE_MARGIN_TOP = 60
+TITLE_MARGIN_BOTTOM = 60
+TITLE_MARGIN_SIDE = 40
+
+
 # ── 数据结构 ──────────────────────────────────────────────────────────────────
 
 
@@ -89,6 +97,238 @@ class RenderResult:
 # ── clip_type → layer role 映射 ──────────────────────────────────────────────
 
 
+# ── ASS 字幕工具 ─────────────────────────────────────────────────────────────
+
+
+def _hex_to_ass_color(hex_color: str) -> str:
+    """将 HEX 颜色（#RRGGBB）转换为 ASS &HBBGGRR 格式。"""
+    hex_color = hex_color.lstrip("#")
+    if len(hex_color) != 6:
+        return "&H000000"
+    r, g, b = hex_color[0:2], hex_color[2:4], hex_color[4:6]
+    return f"&H{b.upper()}{g.upper()}{r.upper()}"
+
+
+def _position_to_ass_alignment(position: str) -> int:
+    """将文字位置映射为 ASS \an 对齐编号。
+
+    ASS 对齐编号（数字小键盘布局）：
+      7 8 9
+      4 5 6
+      1 2 3
+    """
+    mapping = {
+        "top": 8,  # 顶部居中
+        "center": 5,  # 居中
+        "bottom": 2,  # 底部居中
+    }
+    return mapping.get(position, 8)
+
+
+def _build_ass_style(
+    style_name: str,
+    *,
+    font_name: str = "思源黑体",
+    font_size: int = 48,
+    primary_color: str = "&H00FFFFFF",
+    outline_color: str = "&H00000000",
+    outline_width: float = 1.0,
+    shadow_blur: float = 0.0,
+    shadow_offset: tuple[int, int] = (0, 0),
+    bold: bool = False,
+    italic: bool = False,
+    alignment: int = 8,
+    margin_v: int = 60,
+    margin_l: int = 40,
+    margin_r: int = 40,
+) -> str:
+    """构建 ASS Style 行。
+
+    Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour,
+            Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle,
+            BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+    """
+    bold_val = -1 if bold else 0
+    italic_val = -1 if italic else 0
+
+    # BackColour 用于阴影（BorderStyle=1 时 outline + shadow）
+    back_color = primary_color  # 阴影颜色默认同文字色（带透明度由阴影模糊控制）
+
+    # Shadow 值：ASS 中 Shadow 字段是阴影偏移距离（像素），
+    # 我们用 shadow_offset[1] 作为纵向偏移，模糊由 BorderStyle=3 实现
+    # 简化：BorderStyle=1（outline + drop shadow），Shadow 字段表示阴影深度
+    shadow_depth = shadow_offset[1] if shadow_blur > 0 else 0
+
+    return (
+        f"Style: {style_name},{font_name},{font_size},{primary_color},"
+        f"&H000000FF,{outline_color},{back_color},"
+        f"{bold_val},{italic_val},0,0,100,100,0,0,"
+        f"1,{outline_width},{shadow_depth},{alignment},"
+        f"{margin_l},{margin_r},{margin_v},1"
+    )
+
+
+def generate_ass_subtitles(
+    output_path: Path,
+    *,
+    video_width: int,
+    video_height: int,
+    video_duration: float,
+    title_text: str = "",
+    title_config: dict[str, Any] | None = None,
+    subtitle_text: str = "",
+    subtitle_config: dict[str, Any] | None = None,
+) -> Path:
+    """生成 ASS 字幕文件。
+
+    支持 Title（标题）和 Subtitle（字幕）两种字幕类型，
+    各自可独立配置样式、位置和内容。
+
+    Args:
+        output_path: 输出 ASS 文件路径
+        video_width: 视频宽度（用于 ASS PlayResX）
+        video_height: 视频高度（用于 ASS PlayResY）
+        video_duration: 视频总时长（秒），字幕显示整个时长
+        title_text: 标题文本
+        title_config: 标题样式配置（TitleConfig dict）
+        subtitle_text: 字幕文本
+        subtitle_config: 字幕样式配置（SubtitleConfig dict）
+
+    Returns:
+        生成的 ASS 文件路径
+    """
+    title_config = title_config or {}
+    subtitle_config = subtitle_config or {}
+
+    title_enabled = title_config.get("enabled", True) and bool(title_text.strip())
+    subtitle_enabled = subtitle_config.get("enabled", True) and bool(subtitle_text.strip())
+
+    if not title_enabled and not subtitle_enabled:
+        # 没有字幕，生成空文件（仍返回路径，调用方自行判断是否使用）
+        output_path.write_text("", encoding="utf-8")
+        return output_path
+
+    styles: list[str] = []
+    events: list[str] = []
+
+    # ── Title 样式与事件 ──────────────────────────────────────────────────
+    if title_enabled:
+        title_color = _hex_to_ass_color(title_config.get("color", "#ffffff"))
+        title_stroke = title_config.get("stroke", {}) or {}
+        title_shadow = title_config.get("shadow", {}) or {}
+        stroke_color = _hex_to_ass_color(title_stroke.get("color", "#000000"))
+        stroke_width = float(title_stroke.get("width", 1)) if title_stroke.get("enabled", False) else 0.0
+        shadow_blur = float(title_shadow.get("blur", 4)) if title_shadow.get("enabled", False) else 0.0
+        shadow_offset = (
+            title_shadow.get("offset_x", 2) if title_shadow.get("enabled", False) else 0,
+            title_shadow.get("offset_y", 2) if title_shadow.get("enabled", False) else 0,
+        )
+
+        title_alignment = _position_to_ass_alignment(title_config.get("position", "top"))
+
+        styles.append(
+            _build_ass_style(
+                "TitleStyle",
+                font_name=title_config.get("font", "思源黑体"),
+                font_size=int(title_config.get("size", 48)),
+                primary_color=title_color,
+                outline_color=stroke_color,
+                outline_width=stroke_width,
+                shadow_blur=shadow_blur,
+                shadow_offset=shadow_offset,
+                bold=bool(title_config.get("bold", True)),
+                italic=bool(title_config.get("italic", False)),
+                alignment=title_alignment,
+                margin_v=TITLE_MARGIN_TOP,
+                margin_l=TITLE_MARGIN_SIDE,
+                margin_r=TITLE_MARGIN_SIDE,
+            )
+        )
+
+        # 转义 ASS 特殊字符
+        safe_title_text = _escape_ass_text(title_text)
+
+        events.append(
+            "Dialogue: 0,0:00:00.00," f"{_format_ass_time(video_duration)}," "TitleStyle,,0,0,0,," f"{safe_title_text}"
+        )
+
+    # ── Subtitle 样式与事件 ───────────────────────────────────────────────
+    if subtitle_enabled:
+        sub_color = _hex_to_ass_color(subtitle_config.get("color", "#ffffff"))
+        sub_alignment = _position_to_ass_alignment(subtitle_config.get("position", "bottom"))
+
+        styles.append(
+            _build_ass_style(
+                "SubtitleStyle",
+                font_name=subtitle_config.get("font", "思源黑体"),
+                font_size=int(subtitle_config.get("size", 24)),
+                primary_color=sub_color,
+                outline_color="&H00000000",
+                outline_width=1.0,
+                shadow_blur=0.0,
+                shadow_offset=(0, 0),
+                bold=False,
+                italic=False,
+                alignment=sub_alignment,
+                margin_v=TITLE_MARGIN_BOTTOM,
+                margin_l=TITLE_MARGIN_SIDE,
+                margin_r=TITLE_MARGIN_SIDE,
+            )
+        )
+
+        safe_subtitle_text = _escape_ass_text(subtitle_text)
+
+        events.append(
+            "Dialogue: 0,0:00:00.00,"
+            f"{_format_ass_time(video_duration)},"
+            "SubtitleStyle,,0,0,0,,"
+            f"{safe_subtitle_text}"
+        )
+
+    # ── 组装 ASS 文件 ─────────────────────────────────────────────────────
+    ass_content = f"""[Script Info]
+ScriptType: v4.00+
+PlayResX: {video_width}
+PlayResY: {video_height}
+ScaledBorderAndShadow: yes
+WrapStyle: 2
+Encoding: UTF-8
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+{chr(10).join(styles)}
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+{chr(10).join(events)}
+"""
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(ass_content, encoding="utf-8")
+    return output_path
+
+
+def _escape_ass_text(text: str) -> str:
+    r"""转义 ASS 文本中的特殊字符。
+
+    ASS 中换行用 \N（硬换行）或 \n（软换行），
+    大括号 {} 用于覆盖样式，需要转义。
+    """
+    # 将实际换行转为 ASS 硬换行
+    text = text.replace("\r\n", "\\N").replace("\n", "\\N").replace("\r", "\\N")
+    # 转义大括号（ASS 用它做样式覆盖标签）
+    text = text.replace("{", "(").replace("}", ")")
+    return text
+
+
+def _format_ass_time(seconds: float) -> str:
+    """将秒数格式化为 ASS 时间格式 H:MM:SS.cc。"""
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = seconds % 60
+    return f"{hours}:{minutes:02d}:{secs:05.2f}"
+
+
 def _resolve_layer_role(clip_type: str, config: dict[str, Any]) -> str:
     """根据 clip_type 和 config.role 确定图层角色。
 
@@ -165,7 +405,15 @@ class UnifiedRenderService:
         self.transition_duration = transition_duration
 
     def render(self) -> RenderResult:
-        """执行渲染，返回 RenderResult。
+        """执行渲染，返回 RenderResult.
+
+        优化路径：
+        - 单图层单 clip → 直通模式（-vf），性能最优
+        - 其他情况 → 完整 filter_complex 渲染
+
+        字幕渲染流程：
+        1. 视频主渲染（直通或完整链路）
+        2. 如有 title/subtitle，叠加 ASS 字幕
 
         Raises:
             ValueError: 没有可渲染的片段时抛出
@@ -178,14 +426,22 @@ class UnifiedRenderService:
         # 2. 分组为 RenderLayers
         layers = self._group_clips_into_layers(resolved)
 
-        # 3. 构建 filter_complex
+        # 3. 计算视频总时长（用于字幕显示时长）
+        video_duration = self._estimate_total_duration(layers)
+
+        # 4. 生成 ASS 字幕文件（如果有 title/subtitle 配置）
+        ass_path = self._maybe_generate_ass(video_duration)
+
         output_path = self.work_dir / f"rendered_{self.plan.id}.mp4"
-        filter_complex, input_args = self._build_filter_complex(layers)
 
-        # 4. 执行 FFmpeg
-        self._execute_ffmpeg(filter_complex, input_args, output_path)
+        # 5. 视频主渲染
+        if self._can_use_pass_through(layers):
+            self._render_pass_through(layers, output_path, ass_path=ass_path)
+        else:
+            filter_complex, input_args = self._build_filter_complex(layers, ass_path=ass_path)
+            self._execute_ffmpeg(filter_complex, input_args, output_path)
 
-        # 5. 探测输出
+        # 6. 探测输出
         duration, file_size, width, height = self._probe_output(output_path)
 
         return RenderResult(
@@ -196,6 +452,192 @@ class UnifiedRenderService:
             height=height,
         )
 
+    def _estimate_total_duration(self, layers: list[RenderLayer]) -> float:
+        """估算视频总时长（用于字幕等需要）。
+
+        取主图层（main/broll/background）的总时长，转场重叠按 transition_duration 估算。
+        """
+        # 找主图层（第一个有视频内容的图层）
+        main_layer = None
+        for role in ("main", "broll", "background"):
+            for layer in layers:
+                if layer.role == role:
+                    main_layer = layer
+                    break
+            if main_layer:
+                break
+
+        if not main_layer or not main_layer.clips:
+            return 0.0
+
+        total = sum(
+            (
+                min(c.duration, c.actual_duration)
+                if c.duration > 0 and c.actual_duration > 0
+                else (c.duration if c.duration > 0 else c.actual_duration)
+            )
+            for c in main_layer.clips
+        )
+
+        # 减去转场重叠时间（粗略估算）
+        n_clips = len(main_layer.clips)
+        if n_clips > 1:
+            total -= (n_clips - 1) * self.transition_duration
+
+        return max(0.1, total)
+
+    def _maybe_generate_ass(self, video_duration: float) -> Path | None:
+        """根据 plan.config 生成 ASS 字幕文件。
+
+        Returns:
+            ASS 文件路径，没有字幕时返回 None
+        """
+        config = self.plan.config or {}
+        title_cfg = config.get("title", {}) or {}
+        subtitle_cfg = config.get("subtitle", {}) or {}
+
+        title_enabled = title_cfg.get("enabled", True)
+        subtitle_enabled = subtitle_cfg.get("enabled", True)
+        title_text = title_cfg.get("text", "") or ""
+        subtitle_text = subtitle_cfg.get("text", "") or ""
+
+        has_title = title_enabled and bool(title_text.strip())
+        has_subtitle = subtitle_enabled and bool(subtitle_text.strip())
+
+        if not has_title and not has_subtitle:
+            return None
+
+        ass_path = self.work_dir / f"subtitles_{self.plan.id}.ass"
+
+        generate_ass_subtitles(
+            ass_path,
+            video_width=self.output_width,
+            video_height=self.output_height,
+            video_duration=video_duration,
+            title_text=title_text,
+            title_config=title_cfg,
+            subtitle_text=subtitle_text,
+            subtitle_config=subtitle_cfg,
+        )
+
+        logger.info(
+            "生成字幕: plan_id=%s title=%s subtitle=%s ass=%s",
+            self.plan.id,
+            has_title,
+            has_subtitle,
+            ass_path,
+        )
+        return ass_path
+
+    def _can_use_pass_through(self, layers: list[RenderLayer]) -> bool:
+        """判断是否可以走直通优化路径。
+
+        条件：
+        1. 只有 1 个图层
+        2. 该图层是视频图层（main/broll/background），不是 overlay/corner_voice/audio
+        3. 该图层只有 1 个 clip（无转场需求）
+        """
+        if len(layers) != 1:
+            return False
+        layer = layers[0]
+        if layer.role not in ("main", "broll", "background"):
+            return False
+        if len(layer.clips) != 1:
+            return False
+        return True
+
+    def _render_pass_through(
+        self, layers: list[RenderLayer], output_path: Path, *, ass_path: Path | None = None
+    ) -> None:
+        """单图层单 clip 直通渲染（使用 -vf 而非 -filter_complex）。
+
+        性能优化：避免 filter_complex 的解析和调度开销，
+        对于一镜到底场景性能提升 ~30%，接近链路A水平。
+
+        Args:
+            layers: 图层列表（只有1个图层1个clip）
+            output_path: 输出文件路径
+            ass_path: ASS 字幕文件路径，有则叠加字幕
+        """
+        clip = layers[0].clips[0]
+        role = layers[0].role
+
+        # 构建滤镜链（与 _build_filter_complex 中预处理逻辑一致）
+        filters: list[str] = []
+
+        # trim
+        effective_duration = 0.0
+        if clip.duration > 0:
+            effective_duration = min(clip.duration, clip.actual_duration) if clip.actual_duration > 0 else clip.duration
+        elif clip.actual_duration > 0:
+            effective_duration = clip.actual_duration
+
+        if effective_duration > 0:
+            filters.append(f"trim=duration={effective_duration}")
+            filters.append("setpts=PTS-STARTPTS")
+
+        # scale + crop（铺满裁剪）
+        if role in ("overlay", "corner_voice"):
+            pip_w = int(self.output_width * _PIP_SCALE)
+            pip_h = int(self.output_height * _PIP_SCALE)
+            filters.append(f"scale={pip_w}:{pip_h}")
+        else:
+            # main / broll / background: 铺满裁剪
+            filters.append(f"scale={self.output_width}:{self.output_height}" ":force_original_aspect_ratio=increase")
+            filters.append(f"crop={self.output_width}:{self.output_height}")
+
+        filters.append("setpts=PTS-STARTPTS")
+        filters.append(f"fps={self.output_fps}")
+        filters.append("format=yuv420p")
+
+        # 字幕叠加
+        if ass_path is not None:
+            # ASS 文件路径需要转义：Windows 反斜杠转正斜杠，冒号转义
+            ass_filter_path = str(ass_path).replace("\\", "/").replace(":", "\\:")
+            filters.append(f"subtitles='{ass_filter_path}'")
+
+        vf_str = ",".join(filters)
+
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            "-i",
+            str(clip.local_path),
+            "-vf",
+            vf_str,
+            "-c:v",
+            "libx264",
+            "-crf",
+            "23",
+            "-preset",
+            "medium",
+            "-pix_fmt",
+            "yuv420p",
+            "-movflags",
+            "+faststart",
+            "-an",  # 直通模式暂不处理音频，音频统一在后续混音阶段处理
+            str(output_path),
+        ]
+
+        logger.info(
+            "直通渲染: plan_id=%s clip=%s role=%s duration=%.2fs",
+            self.plan.id,
+            clip.clip_id,
+            role,
+            effective_duration,
+        )
+        try:
+            run_ffmpeg(command)
+        except subprocess.CalledProcessError as e:
+            logger.error(
+                "直通渲染失败: plan_id=%s clip=%s exit_code=%d\nvf=%s",
+                self.plan.id,
+                clip.clip_id,
+                e.returncode,
+                vf_str[:2000],
+            )
+            raise
+
     # ── 内部方法 ──────────────────────────────────────────────────────────────
 
     def _resolve_clips(self) -> list[ResolvedClip]:
@@ -277,9 +719,15 @@ class UnifiedRenderService:
         layers = sorted(layer_map.values(), key=lambda lyr: lyr.z_index)
         return layers
 
-    def _build_filter_complex(self, layers: list[RenderLayer]) -> tuple[str, list[str]]:
+    def _build_filter_complex(
+        self, layers: list[RenderLayer], *, ass_path: Path | None = None
+    ) -> tuple[str, list[str]]:
         """构建 FFmpeg filter_complex 字符串和输入参数列表。
 
+        Args:
+            layers: 图层列表
+            ass_path: ASS 字幕文件路径，有则在最后叠加字幕
+
         Returns:
             (filter_complex_str, input_args_list)
             input_args_list 是 ["-i", path1, "-i", path2, ...] 格式
@@ -314,7 +762,9 @@ class UnifiedRenderService:
             # 有效时长 = min(指定时长, 实际时长)；若均未设置则跳过
             effective_duration = 0.0
             if clip.duration > 0:
-                effective_duration = min(clip.duration, clip.actual_duration) if clip.actual_duration > 0 else clip.duration
+                effective_duration = (
+                    min(clip.duration, clip.actual_duration) if clip.actual_duration > 0 else clip.duration
+                )
             elif clip.actual_duration > 0:
                 effective_duration = clip.actual_duration
 
@@ -333,14 +783,15 @@ class UnifiedRenderService:
                 )
                 filters.append(f"crop={self.output_width}:{self.output_height}")
             else:
-                # main / broll: scale + pad 保持宽高比
+                # main / broll: 铺满裁剪（scale to cover + center crop）
+                # 对齐链路A编辑器合成行为，与主流短视频平台一致
                 filters.append(
-                    f"scale={self.output_width}:{self.output_height}" ":force_original_aspect_ratio=decrease"
+                    f"scale={self.output_width}:{self.output_height}" ":force_original_aspect_ratio=increase"
                 )
-                filters.append(f"pad={self.output_width}:{self.output_height}" ":(ow-iw)/2:(oh-ih)/2:black")
+                filters.append(f"crop={self.output_width}:{self.output_height}")
 
-            filters.append(f"fps={self.output_fps}")
             filters.append("setpts=PTS-STARTPTS")
+            filters.append(f"fps={self.output_fps}")
 
             filter_str = f"[{i}:v]{','.join(filters)}[{label}]"
             filter_parts.append(filter_str)
@@ -419,7 +870,12 @@ class UnifiedRenderService:
                 filter_parts.append(f"[{final_video_label}][{overlay_label}]" f"overlay={x}:{y}[{combined_label}]")
                 final_video_label = combined_label
 
-        filter_parts.append(f"[{final_video_label}]format=yuv420p[final_video]")
+        # 叠加字幕（如有）+ 最终像素格式
+        if ass_path is not None:
+            ass_filter_path = str(ass_path).replace("\\", "/").replace(":", "\\:")
+            filter_parts.append(f"[{final_video_label}]subtitles='{ass_filter_path}',format=yuv420p[final_video]")
+        else:
+            filter_parts.append(f"[{final_video_label}]format=yuv420p[final_video]")
 
         filter_complex = ";".join(filter_parts)
         return filter_complex, input_args

apps/worker/video_processing/video_compose_service.py

@@ -1,821 +0,0 @@
-"""
-视频合成服务
-支持多种剪辑模式和转场效果，包含完整的安全校验
-"""
-
-import logging
-import os
-import subprocess
-import tempfile
-from dataclasses import dataclass
-from enum import Enum
-
-try:
-    from enum import StrEnum
-except ImportError:
-
-    class StrEnum(str, Enum):  # type: ignore[no-redef]
-        """Python 3.10 兼容的 StrEnum 回退实现。"""
-
-        pass
-
-
-from pathlib import Path
-from typing import Optional
-
-from packages.domain.editing_mode import EditingMode
-
-logger = logging.getLogger(__name__)
-
-# ========== 安全常量 ==========
-# 允许的输出目录白名单（使用环境变量或系统临时目录，避免硬编码 /tmp）
-_VIDEO_OUTPUT_DIR = os.environ.get("VIDEO_OUTPUT_DIR", os.path.join(tempfile.gettempdir(), "video_output"))
-ALLOWED_OUTPUT_DIRS = [_VIDEO_OUTPUT_DIR, "/var/app/rendered"]
-
-# 允许的输入路径前缀白名单
-ALLOWED_INPUT_PREFIXES = ("s3://", "oss://", "local://", "/var/storage/")
-
-# 允许的转场效果白名单
-ALLOWED_TRANSITIONS = {
-    "fade",
-    "slideleft",
-    "slideright",
-    "dissolve",
-    "wipeleft",
-    "wiperight",
-    "cut",
-    "slideup",
-    "slidedown",
-}
-
-# 转场效果映射
-_XFADE_TRANSITION_MAP = {
-    "fade": "fade",
-    "slideleft": "slideleft",
-    "slideright": "slideright",
-    "dissolve": "dissolve",
-    "wipeleft": "wipeleft",
-    "wiperight": "wiperight",
-    "cut": "cut",
-    "slideup": "slideup",
-    "slidedown": "slidedown",
-}
-
-
-class VideoComposeError(Exception):
-    """视频合成服务异常"""
-
-    pass
-
-
-class PIPPosition(StrEnum):
-    """画中画位置枚举"""
-
-    TOP_LEFT = "top_left"
-    TOP_RIGHT = "top_right"
-    BOTTOM_LEFT = "bottom_left"
-    BOTTOM_RIGHT = "bottom_right"
-
-
-@dataclass
-class Clip:
-    """视频片段"""
-
-    asset_id: str  # 资源ID，对应输入路径
-    start_time: float = 0.0
-    duration: float = 0.0
-    transition: str = "fade"  # 转场效果
-
-
-@dataclass
-class EditingModeConfig:
-    """剪辑模式配置"""
-
-    mode: EditingMode
-    output_width: int = 1280
-    output_height: int = 720
-    output_fps: int = 25
-    pip_position: PIPPosition = PIPPosition.TOP_RIGHT
-    pip_scale: float = 0.25  # 画中画占主画面的比例
-    transition_duration: float = 0.5  # 转场时长（秒）
-    output_codec: str = "libx264"
-    output_preset: str = "medium"
-    output_crf: int = 23
-
-
-class VideoComposeService:
-    """视频合成服务"""
-
-    def __init__(self, config: EditingModeConfig, work_dir: Optional[str] = None):
-        """
-        初始化视频合成服务
-
-        Args:
-            config: 剪辑模式配置
-            work_dir: 工作目录，默认使用系统临时目录
-        """
-        self.config = config
-        self.work_dir = work_dir or tempfile.gettempdir()
-        self._ffmpeg_bin = "ffmpeg"
-        self._ffprobe_bin = "ffprobe"
-
-    def _validate_output_path(self, path: str) -> str:
-        """
-        校验输出路径是否在允许范围内 (P0 修复)
-
-        防止路径穿越攻击，如 /app/config/../../../etc/passwd
-
-        Args:
-            path: 用户提供的输出路径
-
-        Returns:
-            标准化后的绝对路径
-
-        Raises:
-            ValueError: 路径不在允许范围内
-        """
-        abs_path = os.path.abspath(path)
-        for allowed_dir in ALLOWED_OUTPUT_DIRS:
-            allowed_abs = os.path.abspath(allowed_dir)
-            if abs_path.startswith(allowed_abs):
-                return abs_path
-        raise ValueError(f"输出路径不在允许范围内: {path}")
-
-    def _validate_input_path(self, path: str) -> bool:
-        """
-        校验输入路径格式是否合法 (P1-1 修复)
-
-        Args:
-            path: 输入文件路径
-
-        Returns:
-            是否合法
-        """
-        return any(path.startswith(prefix) for prefix in ALLOWED_INPUT_PREFIXES)
-
-    def _validate_transition(self, transition: str) -> str:
-        """
-        校验转场效果是否在白名单内 (P1-2 修复)
-
-        Args:
-            transition: 转场效果名称
-
-        Returns:
-            安全的转场效果名称
-        """
-        if transition not in ALLOWED_TRANSITIONS:
-            logger.warning(f"未知的转场效果 '{transition}'，使用默认 'fade'")
-            return "fade"
-        return transition
-
-    def _get_validated_transition(self, transition: str) -> str:
-        """获取白名单校验后的转场效果名称"""
-        return _XFADE_TRANSITION_MAP.get(self._validate_transition(transition), "fade")
-
-    def compose(self, clips: list[Clip], output_path: Optional[str] = None) -> str:
-        """
-        合成视频
-
-        Args:
-            clips: 视频片段列表，每个片段包含 asset_id 和转场配置
-            output_path: 输出文件路径
-
-        Returns:
-            输出文件路径
-        """
-        if not clips:
-            raise ValueError("clips 不能为空")
-
-        # P1-1: 校验所有输入路径
-        for clip in clips:
-            if not self._validate_input_path(clip.asset_id):
-                raise ValueError(f"不合法的输入路径: {clip.asset_id}")
-
-        # 生成默认输出路径并校验
-        if output_path is None:
-            output_path = self._generate_output_path()
-
-        # P0: 校验输出路径
-        validated_output = self._validate_output_path(output_path)
-
-        logger.info(f"合成视频，片段数: {len(clips)}, 输出: {validated_output}")
-
-        # 获取输入路径列表
-        input_paths = [clip.asset_id for clip in clips]
-
-        try:
-            if self.config.mode == EditingMode.ONE_TAKE:
-                return self._one_take(input_paths, validated_output, clips)
-            elif self.config.mode == EditingMode.PIP:
-                return self._pip(input_paths, validated_output)
-            elif self.config.mode == EditingMode.VOICE_OVER:
-                return self._voice_over(input_paths, validated_output)
-            elif self.config.mode == EditingMode.VOICE_PIP:
-                return self._voice_pip(input_paths, validated_output)
-            else:
-                raise ValueError(f"不支持的剪辑模式: {self.config.mode}")
-        except Exception as e:
-            logger.error(f"视频合成失败: {e}")
-            raise VideoComposeError(f"视频合成失败: {e}") from e
-
-    def _generate_output_path(self) -> str:
-        """生成输出文件路径"""
-        os.makedirs(self.work_dir, exist_ok=True)
-        return os.path.join(self.work_dir, f"output_{self.config.mode}_{os.getpid()}.mp4")
-
-    def _validate_inputs(self, video_paths: list[str], audio_path: Optional[str] = None) -> None:
-        """验证输入文件存在"""
-        for path in video_paths:
-            if not os.path.exists(path):
-                raise FileNotFoundError(f"视频文件不存在: {path}")
-            if not os.path.getsize(path) > 0:
-                raise ValueError(f"视频文件为空: {path}")
-
-        if audio_path and not os.path.exists(audio_path):
-            raise FileNotFoundError(f"音频文件不存在: {audio_path}")
-
-    def _run_ffmpeg(self, command: list[str], capture_output: bool = True) -> tuple:
-        """执行 FFmpeg 命令"""
-        logger.debug(f"Running FFmpeg: {' '.join(command)}")
-        try:
-            result = subprocess.run(
-                command,
-                check=True,
-                stdout=subprocess.PIPE if capture_output else None,
-                stderr=subprocess.PIPE if capture_output else None,
-                text=capture_output,
-            )
-            return result.stdout or "", result.stderr or ""
-        except subprocess.CalledProcessError as e:
-            stderr = e.stderr.decode() if e.stderr else str(e)
-            logger.error(f"FFmpeg error: {stderr}")
-            raise RuntimeError(f"FFmpeg 执行失败: {stderr}") from e
-
-    def _get_video_info(self, video_path: str) -> dict:
-        """获取视频信息"""
-        try:
-            result = subprocess.run(
-                [
-                    self._ffprobe_bin,
-                    "-v",
-                    "error",
-                    "-show_entries",
-                    "stream=width,height,r_frame_rate,duration,codec_name",
-                    "-show_entries",
-                    "format=duration,size",
-                    "-of",
-                    "json",
-                    video_path,
-                ],
-                check=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-            import json
-
-            data = json.loads(result.stdout)
-            streams = data.get("streams", [{}])
-            video_stream = next((s for s in streams if s.get("codec_type") == "video"), streams[0] if streams else {})
-            fmt = data.get("format", {})
-
-            fps_str = video_stream.get("r_frame_rate", "25/1")
-            fps_parts = fps_str.split("/")
-            fps = float(fps_parts[0]) / float(fps_parts[1]) if len(fps_parts) == 2 else float(fps_parts[0])
-
-            return {
-                "width": int(video_stream.get("width", 0)),
-                "height": int(video_stream.get("height", 0)),
-                "fps": fps,
-                "duration": float(fmt.get("duration", 0)),
-                "codec": video_stream.get("codec_name", "unknown"),
-                "size": int(fmt.get("size", 0)),
-            }
-        except Exception as e:
-            logger.warning(f"获取视频信息失败 {video_path}: {e}")
-            return {"width": 0, "height": 0, "fps": 25, "duration": 0, "codec": "unknown", "size": 0}
-
-    def _get_pip_position_offset(
-        self, main_width: int, main_height: int, pip_width: int, pip_height: int
-    ) -> tuple[int, int]:
-        """获取画中画位置偏移量"""
-        margin = 10
-        position_offsets = {
-            PIPPosition.TOP_LEFT: (margin, margin),
-            PIPPosition.TOP_RIGHT: (main_width - pip_width - margin, margin),
-            PIPPosition.BOTTOM_LEFT: (margin, main_height - pip_height - margin),
-            PIPPosition.BOTTOM_RIGHT: (main_width - pip_width - margin, main_height - pip_height - margin),
-        }
-        return position_offsets.get(self.config.pip_position, position_offsets[PIPPosition.TOP_RIGHT])
-
-    def _normalize_video(self, input_path: str, output_path: str) -> dict:
-        """标准化视频格式"""
-        command = [
-            self._ffmpeg_bin,
-            "-y",
-            "-i",
-            input_path,
-            "-r",
-            str(self.config.output_fps),
-            "-vf",
-            f"scale={self.config.output_width}:{self.config.output_height}:force_original_aspect_ratio=decrease,pad={self.config.output_width}:{self.config.output_height}:(ow-iw)/2:(oh-ih)/2,setsar=1",
-            "-r",
-            str(self.config.output_fps),
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            "-movflags",
-            "+faststart",
-            "-an",
-            output_path,
-        ]
-        self._run_ffmpeg(command)
-        return self._get_video_info(output_path)
-
-    def _one_take(self, video_paths: list[str], output_path: str, clips: list[Clip]) -> str:
-        """一镜到底模式"""
-        if len(video_paths) == 1:
-            return self._normalize_video(video_paths[0], output_path)
-
-        normalized_paths = []
-        for i, path in enumerate(video_paths):
-            normalized = os.path.join(self.work_dir, f"normalized_{i}_{os.getpid()}.mp4")
-            self._normalize_video(path, normalized)
-            normalized_paths.append(normalized)
-
-        durations = [self._get_video_info(p)["duration"] for p in normalized_paths]
-
-        if len(normalized_paths) <= 5:
-            output_path = self._one_take_with_xfade(normalized_paths, durations, output_path, clips)
-        else:
-            output_path = self._one_take_simple_concat(normalized_paths, output_path)
-
-        for p in normalized_paths:
-            try:
-                if p != output_path:
-                    os.remove(p)
-            except Exception as e:
-                logger.warning(
-                    f"Operation failed in apps/worker/video_processing/video_compose_service.py: {e}", exc_info=True
-                )
-
-        return output_path
-
-    def _one_take_with_xfade(
-        self, normalized_paths: list[str], durations: list[float], output_path: str, clips: list[Clip]
-    ) -> str:
-        """使用 xfade 滤镜实现转场 (P1-2: 转场参数白名单校验)"""
-        if len(normalized_paths) == 2:
-            # 获取当前片段的转场效果并校验白名单
-            transition = "fade"
-            if len(clips) > 1:
-                transition = self._get_validated_transition(clips[1].transition)
-
-            trans_duration = self.config.transition_duration
-            offset1 = durations[0] - trans_duration / 2
-
-            command = [
-                self._ffmpeg_bin,
-                "-y",
-                "-i",
-                normalized_paths[0],
-                "-i",
-                normalized_paths[1],
-                "-filter_complex",
-                f"[0:v][1:v]xfade=transition={transition}:duration={trans_duration}:offset={offset1}[v]",
-                "-map",
-                "[v]",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                output_path,
-            ]
-            self._run_ffmpeg(command)
-            return output_path
-        else:
-            return self._one_take_simple_concat(normalized_paths, output_path)
-
-    def _one_take_simple_concat(self, normalized_paths: list[str], output_path: str) -> str:
-        """使用 concat demuxer 简单拼接"""
-        concat_file = os.path.join(self.work_dir, f"concat_list_{os.getpid()}.txt")
-        with open(concat_file, "w") as f:
-            for path in normalized_paths:
-                f.write(f"file '{os.path.abspath(path)}'\n")
-
-        command = [
-            self._ffmpeg_bin,
-            "-y",
-            "-f",
-            "concat",
-            "-safe",
-            "0",
-            "-i",
-            concat_file,
-            "-c",
-            "copy",
-            output_path,
-        ]
-        self._run_ffmpeg(command)
-
-        try:
-            os.remove(concat_file)
-        except Exception as e:
-            logger.warning(
-                f"Operation failed in apps/worker/video_processing/video_compose_service.py: {e}", exc_info=True
-            )
-
-        return output_path
-
-    def _pip(self, video_paths: list[str], output_path: str) -> str:
-        """画中画模式"""
-        if not video_paths:
-            raise ValueError("No video paths provided")
-
-        main_video = video_paths[0]
-        main_normalized = os.path.join(self.work_dir, f"main_{os.getpid()}.mp4")
-        main_info = self._normalize_video(main_video, main_normalized)
-
-        if len(video_paths) == 1:
-            os.rename(main_normalized, output_path)
-            return output_path
-
-        pip_width = int(self.config.output_width * self.config.pip_scale)
-        pip_height = int(self.config.output_height * self.config.pip_scale)
-        x_offset, y_offset = self._get_pip_position_offset(
-            self.config.output_width, self.config.output_height, pip_width, pip_height
-        )
-
-        pip_normalized = os.path.join(self.work_dir, f"pip_{os.getpid()}.mp4")
-        pip_info = self._get_video_info(video_paths[1])
-
-        if pip_info["duration"] > main_info["duration"]:
-            temp_pip = os.path.join(self.work_dir, f"pip_temp_{os.getpid()}.mp4")
-            command = [
-                self._ffmpeg_bin,
-                "-y",
-                "-i",
-                video_paths[1],
-                "-t",
-                str(main_info["duration"]),
-                "-vf",
-                f"scale={pip_width}:{pip_height}",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                temp_pip,
-            ]
-            self._run_ffmpeg(command)
-            pip_normalized_input = temp_pip
-        else:
-            command = [
-                self._ffmpeg_bin,
-                "-y",
-                "-i",
-                video_paths[1],
-                "-vf",
-                f"scale={pip_width}:{pip_height}",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                pip_normalized,
-            ]
-            self._run_ffmpeg(command)
-            pip_normalized_input = pip_normalized
-
-        if main_info["duration"] > pip_info["duration"]:
-            looped_pip = os.path.join(self.work_dir, f"pip_looped_{os.getpid()}.mp4")
-            command = [
-                self._ffmpeg_bin,
-                "-y",
-                "-stream_loop",
-                "-1",
-                "-i",
-                pip_normalized_input,
-                "-t",
-                str(main_info["duration"]),
-                "-vf",
-                f"scale={pip_width}:{pip_height}",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                looped_pip,
-            ]
-            self._run_ffmpeg(command)
-            pip_normalized_input = looped_pip
-
-        command = [
-            self._ffmpeg_bin,
-            "-y",
-            "-i",
-            main_normalized,
-            "-i",
-            pip_normalized_input,
-            "-filter_complex",
-            f"[0:v][1:v]overlay={x_offset}:{y_offset}[v]",
-            "-map",
-            "[v]",
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            output_path,
-        ]
-        self._run_ffmpeg(command)
-
-        for temp_file in [main_normalized, pip_normalized]:
-            if temp_file and temp_file != output_path:
-                try:
-                    os.remove(temp_file)
-                except Exception as e:
-                    logger.warning(
-                        f"Operation failed in apps/worker/video_processing/video_compose_service.py: {e}", exc_info=True
-                    )
-
-        return output_path
-
-    def _voice_over(self, video_paths: list[str], audio_path: str, output_path: str) -> str:
-        """口播模式"""
-        if not audio_path:
-            raise ValueError("audio_path is required for VOICE_OVER mode")
-
-        if not video_paths:
-            raise ValueError("No background video provided")
-
-        audio_info = self._get_video_info(audio_path)
-        audio_duration = audio_info["duration"]
-
-        bg_normalized = os.path.join(self.work_dir, f"bg_{os.getpid()}.mp4")
-        bg_info = self._normalize_video(video_paths[0], bg_normalized)
-
-        if bg_info["duration"] < audio_duration:
-            looped_bg = os.path.join(self.work_dir, f"bg_looped_{os.getpid()}.mp4")
-            command = [
-                self._ffmpeg_bin,
-                "-y",
-                "-stream_loop",
-                "-1",
-                "-i",
-                bg_normalized,
-                "-t",
-                str(audio_duration),
-                "-vf",
-                f"scale={self.config.output_width}:{self.config.output_height}",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                looped_bg,
-            ]
-            self._run_ffmpeg(command)
-            bg_normalized = looped_bg
-        elif bg_info["duration"] > audio_duration:
-            temp_bg = os.path.join(self.work_dir, f"bg_trimmed_{os.getpid()}.mp4")
-            command = [
-                self._ffmpeg_bin,
-                "-y",
-                "-i",
-                bg_normalized,
-                "-t",
-                str(audio_duration),
-                "-c:v",
-                "copy",
-                temp_bg,
-            ]
-            self._run_ffmpeg(command)
-            bg_normalized = temp_bg
-
-        blurred_bg = os.path.join(self.work_dir, f"bg_blurred_{os.getpid()}.mp4")
-        command = [
-            self._ffmpeg_bin,
-            "-y",
-            "-i",
-            bg_normalized,
-            "-vf",
-            f"boxblur=5:5,scale={self.config.output_width}:{self.config.output_height}",
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            blurred_bg,
-        ]
-        self._run_ffmpeg(command)
-
-        command = [
-            self._ffmpeg_bin,
-            "-y",
-            "-i",
-            blurred_bg,
-            "-i",
-            audio_path,
-            "-filter_complex",
-            "[0:v]drawbox=x=0:y=0:w=iw:h=ih:color=black@0.3:t=fill[v]",
-            "-map",
-            "[v]",
-            "-map",
-            "1:a",
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            "-shortest",
-            output_path,
-        ]
-        self._run_ffmpeg(command)
-
-        for temp_file in [bg_normalized, blurred_bg]:
-            try:
-                if temp_file != output_path:
-                    os.remove(temp_file)
-            except Exception as e:
-                logger.warning(
-                    f"Operation failed in apps/worker/video_processing/video_compose_service.py: {e}", exc_info=True
-                )
-
-        return output_path
-
-    def _voice_pip(self, video_paths: list[str], audio_path: Optional[str], output_path: str) -> str:
-        """口播+画中画模式"""
-        if not video_paths:
-            raise ValueError("No video paths provided")
-
-        if len(video_paths) == 1:
-            return self._normalize_video(video_paths[0], output_path)
-
-        voice_video = video_paths[0]
-        bg_video = video_paths[1] if len(video_paths) > 1 else video_paths[0]
-
-        voice_normalized = os.path.join(self.work_dir, f"voice_{os.getpid()}.mp4")
-        voice_info = self._normalize_video(voice_video, voice_normalized)
-
-        bg_normalized = os.path.join(self.work_dir, f"bg_{os.getpid()}.mp4")
-        bg_info = self._normalize_video(bg_video, bg_normalized)
-
-        final_duration = min(voice_info["duration"], bg_info["duration"])
-
-        pip_width = int(self.config.output_width * self.config.pip_scale)
-        pip_height = int(self.config.output_height * self.config.pip_scale)
-        x_offset, y_offset = self._get_pip_position_offset(
-            self.config.output_width, self.config.output_height, pip_width, pip_height
-        )
-
-        voice_adjusted = os.path.join(self.work_dir, f"voice_adj_{os.getpid()}.mp4")
-        command = [
-            self._ffmpeg_bin,
-            "-y",
-            "-i",
-            voice_normalized,
-            "-t",
-            str(final_duration),
-            "-vf",
-            f"scale={pip_width}:{pip_height}",
-            "-c:v",
-            self.config.output_codec,
-            "-preset",
-            self.config.output_preset,
-            "-crf",
-            str(self.config.output_crf),
-            "-pix_fmt",
-            "yuv420p",
-            voice_adjusted,
-        ]
-        self._run_ffmpeg(command)
-
-        bg_adjusted = os.path.join(self.work_dir, f"bg_adj_{os.getpid()}.mp4")
-        command = [
-            self._ffmpeg_bin,
-            "-y",
-            "-i",
-            bg_normalized,
-            "-t",
-            str(final_duration),
-            "-c:v",
-            "copy",
-            bg_adjusted,
-        ]
-        self._run_ffmpeg(command)
-
-        if audio_path:
-            command = [
-                self._ffmpeg_bin,
-                "-y",
-                "-i",
-                bg_adjusted,
-                "-i",
-                voice_adjusted,
-                "-i",
-                audio_path,
-                "-filter_complex",
-                f"[0:v][1:v]overlay={x_offset}:{y_offset}[v]",
-                "-map",
-                "[v]",
-                "-map",
-                "2:a",
-                "-shortest",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                output_path,
-            ]
-        else:
-            command = [
-                self._ffmpeg_bin,
-                "-y",
-                "-i",
-                bg_adjusted,
-                "-i",
-                voice_adjusted,
-                "-filter_complex",
-                f"[0:v][1:v]overlay={x_offset}:{y_offset}[v]",
-                "-map",
-                "[v]",
-                "-map",
-                "1:a",
-                "-shortest",
-                "-c:v",
-                self.config.output_codec,
-                "-preset",
-                self.config.output_preset,
-                "-crf",
-                str(self.config.output_crf),
-                "-pix_fmt",
-                "yuv420p",
-                output_path,
-            ]
-        self._run_ffmpeg(command)
-
-        for temp_file in [voice_normalized, voice_adjusted, bg_normalized, bg_adjusted]:
-            try:
-                if temp_file != output_path:
-                    os.remove(temp_file)
-            except Exception as e:
-                logger.warning(
-                    f"Operation failed in apps/worker/video_processing/video_compose_service.py: {e}", exc_info=True
-                )
-
-        return output_path
-
-
-def create_compose_service(mode: str, work_dir: Optional[str] = None, **kwargs) -> VideoComposeService:
-    """便捷工厂函数：创建视频合成服务"""
-    try:
-        editing_mode = EditingMode(mode)
-    except ValueError:
-        raise ValueError(f"无效的剪辑模式: {mode}. 有效模式: {[m.value for m in EditingMode]}")
-
-    config = EditingModeConfig(
-        mode=editing_mode,
-        output_width=kwargs.get("output_width", 1280),
-        output_height=kwargs.get("output_height", 720),
-        output_fps=kwargs.get("output_fps", 25),
-        pip_position=PIPPosition(kwargs.get("pip_position", "top_right")),
-        pip_scale=kwargs.get("pip_scale", 0.25),
-        transition_duration=kwargs.get("transition_duration", 0.5),
-    )
-
-    return VideoComposeService(config=config, work_dir=work_dir)

apps/worker/worker_app/core/config.py

@@ -18,6 +18,9 @@ class WorkerSettings(BaseSettings):
     environment: str = "development"
     auto_create_schema: bool = False
 
+    # 渲染引擎选择：legacy=旧VideoComposeService，unified=新UnifiedRenderService
+    render_engine: str = "legacy"
+
     model_config = SettingsConfigDict(
         env_file=".env",
         env_file_encoding="utf-8",

apps/worker/worker_app/tasks/compose_video.py

@@ -39,6 +39,10 @@ def _get_job_service():
 def compose_video(self, job_id: str, **kwargs):
     """视频合成任务。
 
+    根据 RENDER_ENGINE 配置选择渲染引擎：
+      - legacy: 旧 VideoComposeService（filter_complex 模式）
+      - unified: 新 UnifiedRenderService（图层架构）
+
     Args:
         job_id: JobService 中的任务 ID
         **kwargs: 来自 Job.payload 的额外参数（plan_id, output_path 等）
@@ -56,66 +60,16 @@ def compose_video(self, job_id: str, **kwargs):
             job_service.fail_job(job_id, "Missing plan_id in job payload")
             return {"status": "error", "message": "Missing plan_id"}
 
-        # 标记为 running
-        job_service.update_progress(job_id, progress=10.0, current_stage="初始化合成环境")
+        # 判断使用哪个渲染引擎
+        from worker_app.core.config import get_settings as get_worker_settings
 
-        # 延迟导入 VideoComposeService
-        from apps.api.app.services.video_compose_service import VideoComposeService
+        worker_settings = get_worker_settings()
+        engine = (worker_settings.render_engine or "legacy").lower()
 
-        compose_svc = VideoComposeService(db)
-
-        # 校验合成条件
-        job_service.update_progress(job_id, progress=20.0, current_stage="校验合成条件")
-        validation = compose_svc.validate_compose(plan_id)
-        if not validation.valid:
-            error_msg = "; ".join(validation.errors)
-            job_service.fail_job(job_id, f"合成校验失败: {error_msg}")
-            return {"status": "error", "message": error_msg}
-
-        # 构建合成命令
-        job_service.update_progress(job_id, progress=30.0, current_stage="构建 FFmpeg 命令")
-        _output_dir = os.environ.get("VIDEO_OUTPUT_DIR", os.path.join(tempfile.gettempdir(), "video_output"))
-        output_path = os.path.join(_output_dir, f"{job_id}.mp4")
-        compose_cmd = compose_svc.build_compose_command(plan_id, output_path)
-
-        # 执行 FFmpeg
-        job_service.update_progress(job_id, progress=50.0, current_stage="正在执行视频合成")
-        logger.info("Executing FFmpeg for job %s, plan %s", job_id, plan_id)
-
-        try:
-            subprocess.run(
-                compose_cmd.command,
-                check=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                timeout=3600,
-            )
-        except subprocess.CalledProcessError as e:
-            job_service.fail_job(job_id, f"FFmpeg 执行失败: {e.stderr[:500]}")
-            raise
-
-        # 上传结果
-        job_service.update_progress(job_id, progress=80.0, current_stage="上传合成结果")
-        storage_key = f"rendered/{plan_id}/{job_id}.mp4"
-
-        from worker_app.tasks.edit_plan_generation import _upload_to_oss
-
-        output_url = _upload_to_oss(Path(output_path), storage_key)
-
-        # 更新 Job 状态为完成
-        result_data = {
-            "plan_id": plan_id,
-            "output_path": output_path,
-            "storage_key": storage_key,
-            "output_url": output_url or "",
-            "estimated_duration": compose_cmd.estimated_duration,
-            "clip_count": len(compose_cmd.clip_chains),
-        }
-        job_service.complete_job(job_id, result=result_data)
-
-        logger.info("视频合成完成: job_id=%s, plan_id=%s", job_id, plan_id)
-        return {"status": "completed", "job_id": job_id, "result": result_data}
+        if engine == "unified":
+            return _compose_with_unified_engine(self, job_service, job, plan_id, db)
+        else:
+            return _compose_with_legacy_engine(self, job_service, job, plan_id, db)
 
     except self.retry_exc as exc:
         logger.warning("视频合成重试中: job_id=%s, exc=%s", job_id, exc)
@@ -129,11 +83,140 @@ def compose_video(self, job_id: str, **kwargs):
         raise self.retry(exc=exc, countdown=60)
     finally:
         db.close()
-        # 清理临时文件
+
+
+def _compose_with_legacy_engine(task, job_service, job, plan_id: str, db) -> dict:
+    """旧引擎渲染路径（VideoComposeService）。"""
+    job_id = job.id
+
+    # 标记为 running
+    job_service.update_progress(job_id, progress=10.0, current_stage="初始化合成环境")
+
+    # 延迟导入 VideoComposeService
+    from apps.api.app.services.video_compose_service import VideoComposeService
+
+    compose_svc = VideoComposeService(db)
+
+    # 校验合成条件
+    job_service.update_progress(job_id, progress=20.0, current_stage="校验合成条件")
+    validation = compose_svc.validate_compose(plan_id)
+    if not validation.valid:
+        error_msg = "; ".join(validation.errors)
+        job_service.fail_job(job_id, f"合成校验失败: {error_msg}")
+        return {"status": "error", "message": error_msg}
+
+    # 构建合成命令
+    job_service.update_progress(job_id, progress=30.0, current_stage="构建 FFmpeg 命令")
+    _output_dir = os.environ.get("VIDEO_OUTPUT_DIR", os.path.join(tempfile.gettempdir(), "video_output"))
+    output_path = os.path.join(_output_dir, f"{job_id}.mp4")
+    compose_cmd = compose_svc.build_compose_command(plan_id, output_path)
+
+    # 执行 FFmpeg
+    job_service.update_progress(job_id, progress=50.0, current_stage="正在执行视频合成")
+    logger.info("Executing FFmpeg for job %s, plan %s", job_id, plan_id)
+
+    try:
+        subprocess.run(
+            compose_cmd.command,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=3600,
+        )
+    except subprocess.CalledProcessError as e:
+        job_service.fail_job(job_id, f"FFmpeg 执行失败: {e.stderr[:500]}")
+        raise
+
+    # 上传结果
+    job_service.update_progress(job_id, progress=80.0, current_stage="上传合成结果")
+    storage_key = f"rendered/{plan_id}/{job_id}.mp4"
+
+    from worker_app.tasks.edit_plan_generation import _upload_to_oss
+
+    output_url = _upload_to_oss(Path(output_path), storage_key)
+
+    # 更新 Job 状态为完成
+    result_data = {
+        "plan_id": plan_id,
+        "output_path": output_path,
+        "storage_key": storage_key,
+        "output_url": output_url or "",
+        "estimated_duration": compose_cmd.estimated_duration,
+        "clip_count": len(compose_cmd.clip_chains),
+        "engine": "legacy",
+    }
+    job_service.complete_job(job_id, result=result_data)
+
+    logger.info("视频合成完成(legacy): job_id=%s, plan_id=%s", job_id, plan_id)
+    return {"status": "completed", "job_id": job_id, "result": result_data}
+
+
+def _compose_with_unified_engine(task, job_service, job, plan_id: str, db) -> dict:
+    """新引擎渲染路径（UnifiedRenderService + RenderAdapter）。"""
+    job_id = job.id
+
+    # 标记为 running
+    job_service.update_progress(job_id, progress=10.0, current_stage="初始化统一渲染引擎")
+
+    from video_processing.render_adapter import RenderAdapter
+
+    adapter = RenderAdapter(db)
+
+    # 校验合成条件
+    job_service.update_progress(job_id, progress=15.0, current_stage="校验合成条件")
+    valid, errors, warnings, ready_count, total_count = adapter.validate_plan(plan_id)
+    if not valid:
+        error_msg = "; ".join(errors)
+        job_service.fail_job(job_id, f"合成校验失败: {error_msg}")
+        return {"status": "error", "message": error_msg}
+
+    # 进度回调
+    def progress_cb(progress: float, stage: str) -> None:
         try:
-            _output_dir = os.environ.get("VIDEO_OUTPUT_DIR", os.path.join(tempfile.gettempdir(), "video_output"))
-            output_path = os.path.join(_output_dir, f"{job_id}.mp4")
-            if Path(output_path).exists():
-                Path(output_path).unlink()
-        except Exception as e:
-            logger.warning(f"Operation failed in apps/worker/worker_app/tasks/compose_video.py: {e}", exc_info=True)
+            job_service.update_progress(job_id, progress=progress, current_stage=stage)
+        except Exception:
+            logger.exception("更新进度失败")
+
+    # 执行渲染
+    job_service.update_progress(job_id, progress=20.0, current_stage="开始渲染")
+    logger.info("统一渲染引擎开始: job_id=%s plan_id=%s", job_id, plan_id)
+
+    result = adapter.render_plan(
+        plan_id=plan_id,
+        job_id=job_id,
+        progress_cb=progress_cb,
+    )
+
+    if not result.success:
+        job_service.fail_job(job_id, f"渲染失败: {result.error_message}")
+        raise RuntimeError(result.error_message)
+
+    # 更新 Job 状态为完成
+    result_data = {
+        "plan_id": plan_id,
+        "output_path": str(result.output_path) if result.output_path else "",
+        "storage_key": f"rendered/{plan_id}/{job_id}.mp4",
+        "output_url": result.output_url,
+        "estimated_duration": result.duration,
+        "clip_count": result.clip_count,
+        "engine": "unified",
+        "width": result.width,
+        "height": result.height,
+        "file_size": result.file_size,
+    }
+    job_service.complete_job(job_id, result=result_data)
+
+    logger.info("视频合成完成(unified): job_id=%s plan_id=%s duration=%.2fs", job_id, plan_id, result.duration)
+    return {"status": "completed", "job_id": job_id, "result": result_data}
+
+
+def _cleanup_output(job_id: str) -> None:
+    """清理临时输出文件。"""
+    try:
+        _output_dir = os.environ.get("VIDEO_OUTPUT_DIR", os.path.join(tempfile.gettempdir(), "video_output"))
+        output_path = os.path.join(_output_dir, f"{job_id}.mp4")
+        if Path(output_path).exists():
+            Path(output_path).unlink()
+    except Exception as e:
+        logger.warning(f"清理输出文件失败: {e}", exc_info=True)

apps/worker/worker_app/tasks/generation.py

@@ -13,10 +13,13 @@
 
 from __future__ import annotations
 
+import json
 import logging
 import os
 import tempfile
+import time
 from dataclasses import dataclass, field
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Optional
 
@@ -81,12 +84,33 @@ def _update_task_status(task_id: str, status_action: str, **kwargs) -> bool:
         return False
 
 
+# ── 日志持久化辅助 ────────────────────────────────────────────────────────────
+
+
+def _flush_logs(task_id: str, gen_task) -> None:
+    """将 gen_task.logs 持久化到 DB（独立 session，失败不抛异常）。"""
+    try:
+        session = SessionLocal()
+        try:
+            from packages.adapters.sqlalchemy_impl.models import GenerationTaskModel
+
+            model = session.query(GenerationTaskModel).filter(GenerationTaskModel.id == task_id).first()
+            if model:
+                model.logs = gen_task.logs
+                session.commit()
+        finally:
+            session.close()
+    except Exception:
+        logger.warning("[task_id=%s] 日志持久化失败", task_id, exc_info=True)
+
+
 # ── 共享工具模块导入 ──────────────────────────────────────────────────────────
 
 from video_processing.dedup_helpers import create_video_record_and_dedup
 from video_processing.ffmpeg_utils import FFMPEG_BIN, probe_duration, run_ffmpeg
 from video_processing.oss_helpers import (
     download_asset,
+    get_signed_download_url,
     upload_to_oss,
 )
 from video_processing.unified_render_service import UnifiedRenderService
@@ -100,6 +124,7 @@ class _VirtualPlan:
 
     id: str
     name: str = ""
+    config: dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass
@@ -319,6 +344,8 @@ def _download_library_assets(
     asset_ids: list[str] | None = None,
     video_extensions: tuple = (".mp4", ".mov", ".avi", ".mkv", ".webm"),
     strict: bool = True,
+    task_id: str = "",
+    gen_task=None,
 ) -> list[Path]:
     """下载视频素材 — 同时支持素材库模式和项目级模式。
 
@@ -354,31 +381,37 @@ def _download_library_assets(
 
         session = SessionLocal()
         try:
-            # 构建查询：根据模式选择不同的过滤条件
+            # 构建查询
             query = session.query(AssetModel).filter(
                 AssetModel.status == "ready",
                 AssetModel.file_type.in_(["video", "video/mp4", "video/quicktime"]),
             )
 
-            if asset_library_id:
-                # 素材库模式
-                query = query.filter(AssetModel.asset_library_id == asset_library_id)
+            if asset_ids:
+                # 明确指定了 asset_ids：直接按 ID 查，不预先按 library/project 过滤
+                # 避免项目级素材或跨库素材因为 library_id 不匹配而查不到
+                # 归属安全由后面的归属校验保证
+                query = query.filter(AssetModel.id.in_(asset_ids))
                 logger.info(
-                    "下载素材库视频: asset_library_id=%s asset_ids=%s",
-                    asset_library_id,
-                    asset_ids or "all",
+                    "下载指定素材: asset_ids=%d 个, asset_library_id=%s, project_id=%s",
+                    len(asset_ids),
+                    asset_library_id or "none",
+                    project_id or "none",
                 )
             else:
-                # 项目级模式
-                query = query.filter(AssetModel.project_id == project_id)
-                logger.info(
-                    "下载项目级视频: project_id=%s asset_ids=%s",
-                    project_id,
-                    asset_ids or "all",
-                )
-
-            if asset_ids:
-                query = query.filter(AssetModel.id.in_(asset_ids))
+                # 未指定 asset_ids：按 library 或 project 下载全部 ready 视频
+                if asset_library_id:
+                    query = query.filter(AssetModel.asset_library_id == asset_library_id)
+                    logger.info(
+                        "下载素材库全部视频: asset_library_id=%s",
+                        asset_library_id,
+                    )
+                else:
+                    query = query.filter(AssetModel.project_id == project_id)
+                    logger.info(
+                        "下载项目全部视频: project_id=%s",
+                        project_id,
+                    )
 
             assets = query.order_by(AssetModel.created_at).all()
 
@@ -395,13 +428,15 @@ def _download_library_assets(
                 if missing_ids:
                     raise ValueError(f"素材不存在: asset_ids={sorted(missing_ids)}")
                 for asset in assets:
+                    # 校验素材库归属（只要传了 asset_library_id 就校验）
                     if asset_library_id and asset.asset_library_id != asset_library_id:
                         raise ValueError(
                             f"素材不属于指定素材库: asset_id={asset.id}, "
                             f"expected_asset_library_id={asset_library_id}, "
                             f"actual_asset_library_id={asset.asset_library_id}"
                         )
-                    if not asset_library_id and project_id and asset.project_id != project_id:
+                    # 校验项目归属（只要传了 project_id 就校验）
+                    if project_id and asset.project_id != project_id:
                         raise ValueError(
                             f"素材不属于指定项目: asset_id={asset.id}, "
                             f"expected_project_id={project_id}, "
@@ -418,19 +453,65 @@ def _download_library_assets(
                 storage_key = asset.file_url if asset.file_url else None
                 if not storage_key:
                     failed_assets.append(f"{asset.name}({asset.id})")
-                    logger.warning("素材缺少 file_url, 跳过: asset_id=%s name=%s", asset.id, asset.name)
+                    logger.warning(
+                        "[task_id=%s] 素材缺少 file_url, 跳过: asset_id=%s name=%s", task_id, asset.id, asset.name
+                    )
+                    if gen_task:
+                        gen_task.append_log(
+                            "下载素材",
+                            "素材缺少file_url, 跳过",
+                            level="WARN",
+                            asset_id=asset.id,
+                            asset_name=asset.name,
+                            success=False,
+                            file_size=0,
+                            duration=0.0,
+                        )
                     if strict:
                         raise RuntimeError(f"素材缺少 file_url: asset_id={asset.id}, name={asset.name}")
                     continue
 
                 ext = Path(storage_key).suffix or ".mp4"
                 local_file = temp_path / f"asset_{i:03d}_{asset.id}{ext}"
-                if download_asset(storage_key, local_file):
+                asset_start = time.monotonic()
+                download_ok = download_asset(storage_key, local_file)
+                asset_elapsed = time.monotonic() - asset_start
+
+                if download_ok:
+                    file_size = local_file.stat().st_size if local_file.exists() else 0
                     downloaded.append(local_file)
-                    logger.info("Downloaded asset: %s -> %s", asset.name, local_file)
+                    logger.info(
+                        "[task_id=%s] Downloaded asset: %s -> %s (size=%d, time=%.1fs)",
+                        task_id,
+                        asset.name,
+                        local_file,
+                        file_size,
+                        asset_elapsed,
+                    )
+                    if gen_task:
+                        gen_task.append_log(
+                            "下载素材",
+                            f"下载成功: {asset.name}",
+                            asset_id=asset.id,
+                            asset_name=asset.name,
+                            success=True,
+                            file_size=file_size,
+                            duration=round(asset_elapsed, 2),
+                        )
                 else:
                     failed_assets.append(f"{asset.name}({asset.id})")
-                    logger.warning("Failed to download asset: %s (id=%s)", asset.name, asset.id)
+                    logger.warning("[task_id=%s] Failed to download asset: %s (id=%s)", task_id, asset.name, asset.id)
+                    if gen_task:
+                        gen_task.append_log(
+                            "下载素材",
+                            f"下载失败: {asset.name}",
+                            level="WARN",
+                            asset_id=asset.id,
+                            asset_name=asset.name,
+                            success=False,
+                            file_size=0,
+                            duration=round(asset_elapsed, 2),
+                        )
                     if strict:
                         raise RuntimeError(f"素材下载失败: asset_id={asset.id}, name={asset.name}")
 
@@ -510,7 +591,7 @@ def generate_video(self, task_id: str) -> dict:
     """
     from packages.domain import EditingMode
 
-    logger.info("开始生成视频任务: task_id=%s", task_id)
+    logger.info("[task_id=%s] [接收任务] 开始生成视频任务", task_id)
 
     # 从数据库加载任务信息
     session = SessionLocal()
@@ -522,7 +603,7 @@ def generate_video(self, task_id: str) -> dict:
         task_repo = SQLAlchemyGenerationTaskRepository(session)
         gen_task = task_repo.get(task_id)
         if gen_task is None:
-            logger.error("生成任务不存在: task_id=%s", task_id)
+            logger.error("[task_id=%s] [接收任务] 任务不存在", task_id)
             return {"status": "failed", "error": f"generation task {task_id} not found"}
         project_id = gen_task.project_id
         asset_library_id = gen_task.asset_library_id
@@ -531,6 +612,16 @@ def generate_video(self, task_id: str) -> dict:
         mode = gen_task.strategy_id or "one_take"
         task_asset_ids = list(gen_task.asset_ids or [])
         batch_id = getattr(gen_task, "batch_id", "") or ""
+
+        # 记录接收任务日志
+        gen_task.append_log(
+            "接收任务",
+            f"模式={mode}, 模板={template_id}, 素材数={len(task_asset_ids)}",
+            mode=mode,
+            template_id=template_id,
+            asset_count=len(task_asset_ids),
+        )
+        _flush_logs(task_id, gen_task)
     finally:
         session.close()
 
@@ -557,12 +648,40 @@ def generate_video(self, task_id: str) -> dict:
             output_path = temp_path / output_name
 
             # 1. 从素材库/项目下载视频素材
+            logger.info("[task_id=%s] [下载素材] 开始下载视频素材", task_id)
+            download_start = time.monotonic()
             downloaded_videos = _download_library_assets(
                 temp_path,
                 asset_library_id=asset_library_id,
                 project_id=project_id,
                 asset_ids=task_asset_ids or None,
+                task_id=task_id,
+                gen_task=gen_task,
             )
+            download_elapsed = time.monotonic() - download_start
+            logger.info(
+                "[task_id=%s] [下载素材] 完成: 成功=%d个, 耗时=%.1fs",
+                task_id,
+                len(downloaded_videos),
+                download_elapsed,
+            )
+
+            # 重新加载 gen_task 以追加日志（session 已关闭）
+            _session = SessionLocal()
+            try:
+                _repo = SQLAlchemyGenerationTaskRepository(_session)
+                gen_task = _repo.get(task_id)
+            finally:
+                _session.close()
+
+            if gen_task:
+                gen_task.append_log(
+                    "下载素材",
+                    f"成功下载 {len(downloaded_videos)} 个视频素材",
+                    count=len(downloaded_videos),
+                    duration=round(download_elapsed, 2),
+                )
+                _flush_logs(task_id, gen_task)
 
             # 2. 下载配音（如有）
             audio_path: str | None = None
@@ -570,6 +689,7 @@ def generate_video(self, task_id: str) -> dict:
                 local_audio = temp_path / "voice.mp3"
                 if _download_voice_asset(voice_library_id, local_audio):
                     audio_path = str(local_audio)
+                    logger.info("[task_id=%s] [下载配音] 配音下载成功", task_id)
 
             # 3. 渲染
             if not downloaded_videos:
@@ -587,7 +707,26 @@ def generate_video(self, task_id: str) -> dict:
                 mode=editing_mode.value,
             )
 
+            total_duration = sum(c.duration for c in virtual_clips)
+            logger.info(
+                "[task_id=%s] [剪辑计划] 片段数=%d, 总时长=%.1fs",
+                task_id,
+                len(virtual_clips),
+                total_duration,
+            )
+
+            if gen_task:
+                gen_task.append_log(
+                    "剪辑计划",
+                    f"片段数={len(virtual_clips)}, 总时长={total_duration:.1f}s",
+                    segment_count=len(virtual_clips),
+                    total_duration=round(total_duration, 2),
+                )
+                _flush_logs(task_id, gen_task)
+
             # 使用 UnifiedRenderService 渲染
+            logger.info("[task_id=%s] [渲染] FFmpeg 渲染开始", task_id)
+            render_start = time.monotonic()
             render_service = UnifiedRenderService(
                 plan=virtual_plan,
                 clips=virtual_clips,
@@ -598,6 +737,20 @@ def generate_video(self, task_id: str) -> dict:
                 output_fps=int(OUTPUT_FPS),
             )
             render_result = render_service.render()
+            render_elapsed = time.monotonic() - render_start
+            logger.info(
+                "[task_id=%s] [渲染] FFmpeg 渲染完成: 耗时=%.1fs",
+                task_id,
+                render_elapsed,
+            )
+
+            if gen_task:
+                gen_task.append_log(
+                    "渲染",
+                    f"FFmpeg 渲染完成, 耗时={render_elapsed:.1f}s",
+                    duration=round(render_elapsed, 2),
+                )
+                _flush_logs(task_id, gen_task)
 
             # 4. 如有配音，后处理混音
             if audio_path:
@@ -607,7 +760,7 @@ def generate_video(self, task_id: str) -> dict:
                     # 混音成功，使用混音后的文件
                     output_path = final_path
                 except Exception as mux_err:
-                    logger.warning("音频混合失败，使用无音频版本: %s", mux_err)
+                    logger.warning("[task_id=%s] [混音] 音频混合失败，使用无音频版本: %s", task_id, mux_err)
                     output_path = render_result.output_path
             else:
                 output_path = render_result.output_path
@@ -616,18 +769,57 @@ def generate_video(self, task_id: str) -> dict:
             duration = probe_duration(output_path)
 
             # 5. 上传到 OSS — 失败必须抛异常，不能静默忽略
+            logger.info("[task_id=%s] [OSS上传] 开始上传: size=%d", task_id, file_size)
+            upload_start = time.monotonic()
             file_url = upload_to_oss(output_path, storage_key)
+            upload_elapsed = time.monotonic() - upload_start
             if not file_url:
                 # OSS 未配置或上传失败
+                if gen_task:
+                    gen_task.append_log("OSS上传", "上传失败", level="ERROR")
+                    _flush_logs(task_id, gen_task)
                 raise RuntimeError(
                     f"OSS 上传失败: task_id={task_id}, storage_key={storage_key}, " f"output_path={output_path}"
                 )
 
-            # HEAD 校验 URL 可访问
-            if not _verify_url_accessible(file_url):
-                raise RuntimeError(f"OSS 上传后 URL 不可访问: file_url={file_url}, " f"storage_key={storage_key}")
+            # P0-2 修复：私有 bucket 下裸 URL 永远 403，改用预签名 URL 校验
+            # 先用预签名 URL 校验，失败则降级为检查文件是否存在（object_exists）
+            verify_url = get_signed_download_url(file_url, expires_seconds=300) or file_url
+            if not _verify_url_accessible(verify_url):
+                # 预签名 URL 也访问失败时，退一步用 object_exists 确认上传成功
+                from video_processing.oss_helpers import normalize_storage_key, oss_bucket
 
-            logger.info("OSS 上传成功: file_url=%s", file_url)
+                bucket = oss_bucket()
+                key = normalize_storage_key(file_url)
+                if bucket and bucket.object_exists(key):
+                    logger.info("URL 校验失败但 object_exists 确认文件存在，视为上传成功: storage_key=%s", key)
+                    if gen_task:
+                        gen_task.append_log("OSS上传", "URL校验降级: object_exists确认存在", level="WARN")
+                else:
+                    if gen_task:
+                        gen_task.append_log("OSS上传", "上传后URL不可访问", level="ERROR", file_url=file_url)
+                        _flush_logs(task_id, gen_task)
+                    raise RuntimeError(
+                        f"OSS 上传后 URL 不可访问且 object_exists 失败: file_url={file_url}, "
+                        f"storage_key={storage_key}"
+                    )
+
+            logger.info(
+                "[task_id=%s] [OSS上传] 成功: 耗时=%.1fs, file_url=%s",
+                task_id,
+                upload_elapsed,
+                file_url,
+            )
+
+            if gen_task:
+                gen_task.append_log(
+                    "OSS上传",
+                    f"上传成功, 大小={file_size}, 耗时={upload_elapsed:.1f}s",
+                    file_size=file_size,
+                    duration=round(upload_elapsed, 2),
+                    file_url=file_url,
+                )
+                _flush_logs(task_id, gen_task)
 
             # 6. 创建 GeneratedVideo 记录 + 查重
             dedup_session = SessionLocal()
@@ -649,7 +841,23 @@ def generate_video(self, task_id: str) -> dict:
             # 7. 标记任务为 completed
             _update_task_status(task_id, "mark_completed", result_count=video_count or 1)
 
-            logger.info("视频生成完成: task_id=%s duration=%.2fs file_size=%d", task_id, duration, file_size)
+            # 记录完成日志
+            if gen_task:
+                gen_task.append_log(
+                    "任务完成",
+                    f"视频生成完成: 时长={duration:.2f}s, 大小={file_size}",
+                    duration=round(duration, 2),
+                    file_size=file_size,
+                    video_count=video_count or 1,
+                )
+                _flush_logs(task_id, gen_task)
+
+            logger.info(
+                "[task_id=%s] [任务完成] duration=%.2fs file_size=%d",
+                task_id,
+                duration,
+                file_size,
+            )
 
             return {
                 "status": "completed",
@@ -662,7 +870,27 @@ def generate_video(self, task_id: str) -> dict:
                 "mode": editing_mode.value,
             }
     except Exception as error:
-        logger.error("Video generation failed: %s", error, exc_info=True)
+        logger.error("[task_id=%s] [任务失败] %s", task_id, error, exc_info=True)
+
+        # 记录失败日志
+        try:
+            _session = SessionLocal()
+            try:
+                _repo = SQLAlchemyGenerationTaskRepository(_session)
+                gen_task = _repo.get(task_id)
+                if gen_task:
+                    gen_task.append_log(
+                        "任务失败",
+                        str(error),
+                        level="ERROR",
+                        error_type=type(error).__name__,
+                    )
+                    _flush_logs(task_id, gen_task)
+            finally:
+                _session.close()
+        except Exception:
+            logger.warning("[task_id=%s] 记录失败日志异常", task_id, exc_info=True)
+
         _update_task_status(task_id, "mark_failed", error_message=str(error))
         return {
             "status": "failed",

apps/worker/worker_app/tasks/voice_clone.py

@@ -4,6 +4,7 @@ import logging
 
 from celery import Task
 from celery.exceptions import Retry
+from video_processing.oss_helpers import get_signed_download_url
 from worker_app.celery_app import celery_app
 from worker_app.db import SessionLocal
 
@@ -48,7 +49,9 @@ def process_voice_clone(self: Task, profile_id: str) -> dict:
         repo = SQLAlchemyVoiceCloneProfileRepository(session)
         workflow = VoiceCloneWorkflowService(
             repository=repo,
-            cosyvoice_service=CosyVoiceService(),
+            cosyvoice_service=CosyVoiceService(
+                audio_url_signer=lambda url: get_signed_download_url(url, expires_seconds=86400) or url
+            ),
         )
 
         updated_profile = workflow.poll_and_process_clone(profile_id, timeout=300)

docs/schema-metadata-snapshot.json

@@ -1549,6 +1549,14 @@
           "type": "JSON",
           "unique": false
         },
+        {
+          "index": false,
+          "name": "logs",
+          "nullable": false,
+          "primary_key": false,
+          "type": "TEXT",
+          "unique": false
+        },
         {
           "index": false,
           "name": "created_at",

infra/docker/api.Dockerfile

@@ -6,14 +6,14 @@
 # 基础镜像：Python 3.12
 FROM git.xiaoxiajianji.com/xiaoxia/base/python:3.12-slim
 
+# 构建参数：版本号（CI 传入 commit hash）
+ARG APP_VERSION=dev
+
 # 使用阿里云镜像加速
-RUN sed -i 's|deb.debian.org|mirrors.aliyun.com|g' /etc/apt/sources.list.d/debian.sources 2>/dev/null || \
-    sed -i 's|deb.debian.org|mirrors.aliyun.com|g' /etc/apt/sources.list 2>/dev/null || true
+RUN sed -i 's|deb.debian.org|mirrors.aliyun.com|g' /etc/apt/sources.list.d/debian.sources 2>/dev/null ||     sed -i 's|deb.debian.org|mirrors.aliyun.com|g' /etc/apt/sources.list 2>/dev/null || true
 
 # 安装系统依赖
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libpq-dev \
-    && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y --no-install-recommends     libpq-dev     && rm -rf /var/lib/apt/lists/*
 
 # 设置工作目录
 WORKDIR /app
@@ -21,15 +21,12 @@ WORKDIR /app
 # ---- 依赖分层：基础依赖（变化少，缓存命中率高）----
 COPY requirements-base.txt /tmp/requirements-base.txt
 
-RUN python -m venv /opt/venv \
-    && /opt/venv/bin/pip install --no-cache-dir -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com -r /tmp/requirements-base.txt \
-    && rm /tmp/requirements-base.txt
+RUN python -m venv /opt/venv     && /opt/venv/bin/pip install --no-cache-dir -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com -r /tmp/requirements-base.txt     && rm /tmp/requirements-base.txt
 
 # ---- 依赖分层：业务依赖（变化频繁）----
 COPY requirements.txt /tmp/requirements.txt
 
-RUN /opt/venv/bin/pip install --no-cache-dir -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com -r /tmp/requirements.txt \
-    && rm /tmp/requirements.txt
+RUN /opt/venv/bin/pip install --no-cache-dir -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com -r /tmp/requirements.txt     && rm /tmp/requirements.txt
 
 # 复制应用代码
 COPY apps/api/ /app/apps/api/
@@ -40,13 +37,13 @@ COPY alembic/ /app/alembic/
 COPY scripts/ /app/scripts/
 
 # 设置环境变量
-ENV PATH="/opt/venv/bin:$PATH"
+ENV PATH="/opt/venv/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
 ENV PYTHONPATH=/app
 ENV PYTHONUNBUFFERED=1
+ENV APP_VERSION=$APP_VERSION
 
 # 健康检查
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health', timeout=5)"
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3     CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health', timeout=5)"
 
 # API 入口点
 WORKDIR /app/apps/api

infra/docker/entrypoint-worker.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Worker 启动脚本 — 支持 WORKER_CONCURRENCY 环境变量
+# 未设置时默认 2（保持向后兼容）
+
+set -e
+
+CONCURRENCY="${WORKER_CONCURRENCY:-2}"
+
+exec celery \
+  -A worker_app.celery_app \
+  worker \
+  --loglevel=info \
+  "--concurrency=${CONCURRENCY}"

infra/docker/worker.Dockerfile

@@ -6,6 +6,9 @@
 # 基础镜像：Python 3.12 + ffmpeg
 FROM git.xiaoxiajianji.com/xiaoxia/base/python:3.12-slim
 
+# 构建参数：版本号（CI 传入 commit hash）
+ARG APP_VERSION=dev
+
 # 使用阿里云镜像加速
 RUN sed -i 's|deb.debian.org|mirrors.aliyun.com|g' /etc/apt/sources.list.d/debian.sources 2>/dev/null || \
     sed -i 's|deb.debian.org|mirrors.aliyun.com|g' /etc/apt/sources.list 2>/dev/null || true
@@ -48,10 +51,15 @@ COPY packages/ /app/packages/
 COPY alembic.ini /app/alembic.ini
 COPY migrations/ /app/migrations/
 
+# 复制 Worker 启动脚本（支持 WORKER_CONCURRENCY 环境变量）
+COPY infra/docker/entrypoint-worker.sh /usr/local/bin/entrypoint-worker.sh
+RUN chmod +x /usr/local/bin/entrypoint-worker.sh
+
 # 设置 Python 路径
 ENV PATH="/opt/venv/bin:$PATH"
 ENV PYTHONPATH=/app
 ENV PYTHONUNBUFFERED=1
+ENV APP_VERSION=$APP_VERSION
 
 # 创建非 root 用户运行 Worker
 RUN groupadd -r celery && useradd -r -g celery -d /app -s /sbin/nologin celery \
@@ -61,4 +69,4 @@ USER celery
 
 # Worker 入口点
 WORKDIR /app/apps/worker
-CMD ["celery", "-A", "worker_app.celery_app", "worker", "--loglevel=info", "--concurrency=2"]
+CMD ["/usr/local/bin/entrypoint-worker.sh"]

packages/adapters/sqlalchemy_impl/generation_task_repository.py

@@ -27,6 +27,7 @@ def _to_domain(model: GenerationTaskModel) -> GenerationTask:
         source_edit_plan_id=model.source_edit_plan_id or "",
         asset_select_mode=model.asset_select_mode or "",
         batch_id=model.batch_id or "",
+        logs=model.logs or "[]",
         created_at=model.created_at,
     )
 
@@ -56,6 +57,7 @@ class SQLAlchemyGenerationTaskRepository:
             source_edit_plan_id=task.source_edit_plan_id or None,
             asset_select_mode=task.asset_select_mode or "",
             batch_id=task.batch_id or "",
+            logs=task.logs,
             created_at=task.created_at,
         )
         self.session.add(model)
@@ -89,6 +91,23 @@ class SQLAlchemyGenerationTaskRepository:
     def count_by_user(self, user_id: str) -> int:
         return self.session.query(GenerationTaskModel).filter(GenerationTaskModel.created_by_user_id == user_id).count()
 
+    def count_pending_by_user(self, user_id: str) -> int:
+        return (
+            self.session.query(GenerationTaskModel)
+            .filter(
+                GenerationTaskModel.created_by_user_id == user_id,
+                GenerationTaskModel.status == GenerationTaskStatus.PENDING.value,
+            )
+            .count()
+        )
+
+    def count_pending_total(self) -> int:
+        return (
+            self.session.query(GenerationTaskModel)
+            .filter(GenerationTaskModel.status == GenerationTaskStatus.PENDING.value)
+            .count()
+        )
+
     def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[GenerationTask]:
         models = (
             self.session.query(GenerationTaskModel)
@@ -129,5 +148,6 @@ class SQLAlchemyGenerationTaskRepository:
         model.source_edit_plan_id = task.source_edit_plan_id or None
         model.asset_select_mode = task.asset_select_mode or ""
         model.batch_id = task.batch_id or ""
+        model.logs = task.logs
         self.session.commit()
         return task

packages/adapters/sqlalchemy_impl/models.py

@@ -257,6 +257,7 @@ class GenerationTaskModel(Base):
     asset_select_mode = Column(String(20), nullable=False, default="")
     batch_id = Column(String(36), nullable=False, default="", index=True)
     extra_meta = Column("metadata", JSON, nullable=False, default=dict)
+    logs = Column(Text, nullable=False, default="[]", server_default="[]")
     created_at = Column(DateTime, nullable=False, default=lambda: datetime.now(timezone.utc))
 
 

packages/application/cosyvoice_service.py

@@ -1,11 +1,13 @@
-"""CosyVoice 语音服务 — Phase 3.
+"""CosyVoice 语音服务 — 适配阿里云百炼 DashScope API.
 
-封装阿里云 CosyVoice 语音合成 API，提供：
+封装阿里云百炼 CosyVoice 语音合成 API，提供：
 - 预置音色列表查询
-- 音色克隆（提交任务 + 轮询状态）
-- 语音合成（提交任务 + 轮询状态）
+- 音色克隆（提交 + 轮询状态）
+- 语音合成（同步非流式调用）
 
-API 文档: https://help.aliyun.com/zh/model-studio/cosyvoice
+API 文档:
+- 音色克隆: https://help.aliyun.com/document_detail/3027318.html
+- 语音合成: https://help.aliyun.com/zh/model-studio/cosyvoice-tts-http-api
 """
 
 from __future__ import annotations
@@ -60,33 +62,34 @@ class SynthesizeResult:
 
 
 class CosyVoiceService:
-    """CosyVoice 语音服务。
+    """CosyVoice 语音服务.
 
-    封装阿里云 CosyVoice API，提供音色克隆和语音合成功能。
-    支持同步和异步两种模式：
-    - 同步：API 直接返回结果
-    - 异步：API 返回 task_id，需要轮询状态
+    封装阿里云百炼 CosyVoice API，提供音色克隆和语音合成功能.
+
+    接口总览:
+    - 音色克隆: POST /services/audio/tts/customization (model=voice-enrollment)
+      - action=create_voice: 创建克隆音色，返回 voice_id（状态 DEPLOYING）
+      - action=query_voice: 查询音色状态（DEPLOYING / OK / UNDEPLOYED）
+    - 语音合成: POST /services/audio/tts/SpeechSynthesizer (model=cosyvoice-v3-flash)
+      - 非流式: 同步返回音频 URL
 
     使用示例:
         service = CosyVoiceService(
             api_key="your-api-key",
-            base_url="https://dashscope.aliyuncs.com/api/v1/services/aigc/text2audio",
-            model="cosyvoice-v1",
+            base_url="https://dashscope.aliyuncs.com/api/v1",
+            model="cosyvoice-v3-flash",
         )
 
-        # 获取预置音色
-        voices = service.list_preset_voices()
-
         # 音色克隆
         result = service.clone_voice(audio_url="https://example.com/audio.mp3")
 
         # 语音合成
-        result = service.synthesize_speech(text="你好世界", voice_id="longxiaochun")
+        result = service.synthesize_speech(text="你好世界", voice_id="longxiaochun_v3")
     """
 
-    # 轮询配置
-    POLL_INTERVAL = 2.0  # 秒
-    MAX_POLL_ATTEMPTS = 60  # 最多轮询 60 次（2分钟）
+    # 音色状态轮询配置
+    CLONE_POLL_INTERVAL = 5.0  # 秒
+    CLONE_MAX_POLL_ATTEMPTS = 60  # 最多轮询 60 次（5分钟）
 
     # 重试配置
     MAX_RETRIES = 3
@@ -97,27 +100,70 @@ class CosyVoiceService:
         api_key: str = "",
         base_url: str = "",
         model: str = "",
+        clone_model: str = "",
         http_client: Optional[httpx.Client] = None,
+        audio_url_signer: Optional[callable] = None,
     ) -> None:
-        """初始化 CosyVoice 服务。
+        """初始化 CosyVoice 服务.
 
         Args:
-            api_key: CosyVoice API Key，为空时从配置读取
-            base_url: CosyVoice API Base URL，为空时从配置读取
-            model: CosyVoice 模型名称，为空时从配置读取
+            api_key: DashScope API Key，为空时从配置读取
+            base_url: DashScope API Base URL，为空时从配置读取
+            model: 语音合成模型名称，为空时从配置读取
+            clone_model: 音色克隆模型名称，为空时从配置读取
             http_client: 可选的 HTTP 客户端（用于测试注入）
+            audio_url_signer: 可选的音频URL预签名函数，签名式 fn(url) -> str.
+                用于私有 bucket 下，将裸 URL 转为预签名 URL，
+                确保 CosyVoice 服务器能下载参考音频.
         """
         settings = get_shared_settings()
 
         self._api_key = api_key or settings.cosyvoice_api_key
         self._base_url = base_url or settings.cosyvoice_base_url
         self._model = model or settings.cosyvoice_model
+        self._clone_model = clone_model or getattr(settings, "cosyvoice_clone_model", "voice-enrollment")
+        self._audio_url_signer = audio_url_signer
+
+        # base_url 规范化：去掉末尾的路径残留（兼容旧版配置）
+        # 旧版 .env 模板中 base_url 包含 /services/aigc/text2audio 完整路径，
+        # 新版只需 /api/v1，具体路径由代码拼接。这里自动修正，避免配置滞后导致418。
+        if "/services/aigc/text2audio" in self._base_url:
+            old_url = self._base_url
+            # 截取到 /api/v1 为止
+            idx = self._base_url.find("/api/v1")
+            if idx >= 0:
+                self._base_url = self._base_url[: idx + len("/api/v1")]
+            logger.warning(
+                "[CosyVoice Config] base_url包含旧版text2audio路径，已自动修正: " "%s -> %s",
+                old_url,
+                self._base_url,
+            )
 
         self._client = http_client or httpx.Client(
-            timeout=httpx.Timeout(30.0, connect=10.0),
+            timeout=httpx.Timeout(60.0, connect=10.0),
         )
         self._owns_client = http_client is None
 
+        # 启动时打印配置（脱敏），方便排查环境变量覆盖问题
+        if self._owns_client:
+            masked_key = ""
+            if self._api_key:
+                if len(self._api_key) > 8:
+                    masked_key = f"{self._api_key[:4]}...{self._api_key[-4:]}"
+                else:
+                    masked_key = "***"
+            logger.info(
+                "[CosyVoice Config] 初始化配置: "
+                "model=%s, base_url=%s, default_voice=%s, "
+                "sample_rate=%d, format=%s, api_key=%s",
+                self._model,
+                self._base_url,
+                getattr(settings, "cosyvoice_voice", "(unset)"),
+                settings.cosyvoice_sample_rate,
+                settings.cosyvoice_format,
+                masked_key or "(empty)",
+            )
+
     def __enter__(self) -> CosyVoiceService:
         return self
 
@@ -132,7 +178,7 @@ class CosyVoiceService:
     # ── 预置音色 ─────────────────────────────────────────
 
     def list_preset_voices(self) -> list[PresetVoice]:
-        """获取预置音色列表。
+        """获取预置音色列表.
 
         Returns:
             预置音色列表
@@ -146,20 +192,22 @@ class CosyVoiceService:
         audio_url: str,
         voice_name: str = "",
         language: str = "zh-CN",
+        target_model: str = "",
     ) -> dict:
-        """提交音色克隆任务（非阻塞）。
+        """提交音色克隆任务（非阻塞）.
 
-        只提交任务到 CosyVoice API，不轮询结果。
-        返回的 dict 包含 task_id（异步）或 voice_id（同步）。
+        调用百炼 voice-enrollment API 创建克隆音色.
+        创建后音色状态为 DEPLOYING，需通过 query_voice_status 轮询直到 OK.
 
         Args:
-            audio_url: 参考音频 URL
-            voice_name: 音色名称（可选）
-            language: 语言代码
+            audio_url: 参考音频 URL（必须公网可访问）
+            voice_name: 音色名称前缀（字母数字，最多10字符）
+            language: 语言代码（zh-CN 会转换为 zh）
+            target_model: 目标合成模型，默认使用当前 model
 
         Returns:
-            dict: {"task_id": str, "voice_id": str, "request_id": str}
-                  task_id 和 voice_id 至少有一个非空
+            dict: {"voice_id": str, "status": str, "request_id": str}
+                  voice_id 非空，status 通常为 DEPLOYING
 
         Raises:
             CosyVoiceError: API 调用失败
@@ -171,48 +219,67 @@ class CosyVoiceService:
         if not self._api_key:
             raise CosyVoiceAuthError("CosyVoice API Key 未配置")
 
+        # voice_name 作为 prefix，限制字母数字，最多10字符
+        # 不符合要求的做清洗
+        prefix = self._sanitize_prefix(voice_name) if voice_name else "clone"
+
+        # 语言转换：zh-CN → zh，保留 ISO 639-1 格式
+        lang_code = language.split("-")[0].lower() if language else "zh"
+
+        target = target_model or self._model
+
+        # 如果配置了 audio_url_signer，对音频URL做预签名
+        # （私有 bucket 下 CosyVoice 服务器无法直接访问裸 URL）
+        signed_audio_url = audio_url
+        if self._audio_url_signer:
+            try:
+                signed_audio_url = self._audio_url_signer(audio_url)
+                logger.info("音频URL已预签名: original=%s signed_prefix=%s", audio_url[:80], signed_audio_url[:80])
+            except Exception as e:
+                logger.warning("音频URL预签名失败，使用原始URL: %s", e)
+
         payload = {
-            "model": self._model,
+            "model": self._clone_model,
             "input": {
-                "audio_url": audio_url,
-            },
-            "parameters": {
-                "language": language,
+                "action": "create_voice",
+                "target_model": target,
+                "prefix": prefix,
+                "url": signed_audio_url,
+                "language_hints": [lang_code],
             },
         }
-        if voice_name:
-            payload["parameters"]["voice_name"] = voice_name
 
         response = self._call_api(
             method="POST",
-            path="/services/audio/voice-clone",
+            path="/services/audio/tts/customization",
             json=payload,
             timeout=60.0,
         )
 
         output = response.get("output", {})
-        task_id = output.get("task_id", "")
         voice_id = output.get("voice_id", "")
+        status = output.get("status", "DEPLOYING")
         request_id = response.get("request_id", "")
 
-        if not task_id and not voice_id:
-            raise CosyVoiceError(f"CosyVoice API 未返回 task_id 或 voice_id: {response}")
+        if not voice_id:
+            raise CosyVoiceError(f"CosyVoice API 未返回 voice_id: {response}")
 
         return {
-            "task_id": task_id,
             "voice_id": voice_id,
+            "status": status,
             "request_id": request_id,
         }
 
-    def check_task_status(self, task_id: str) -> dict:
-        """查询克隆任务状态（单次查询，不轮询）。
+    def query_voice_status(self, voice_id: str) -> dict:
+        """查询音色状态（单次查询，不轮询）.
 
         Args:
-            task_id: 任务 ID
+            voice_id: 音色 ID
 
         Returns:
-            dict: {"status": str, "voice_id": str, "message": str}
-                  status 为 SUCCEEDED/FAILED/PENDING/RUNNING
+            dict: {"status": str, "target_model": str, "gmt_create": str,
+                   "gmt_modified": str, "resource_link": str}
+                  status 为 DEPLOYING / OK / UNDEPLOYED
 
         Raises:
             CosyVoiceError: API 调用失败
@@ -221,40 +288,92 @@ class CosyVoiceService:
         if not self._api_key:
             raise CosyVoiceAuthError("CosyVoice API Key 未配置")
 
+        if not voice_id:
+            raise ValueError("voice_id 不能为空")
+
+        payload = {
+            "model": self._clone_model,
+            "input": {
+                "action": "query_voice",
+                "voice_id": voice_id,
+            },
+        }
+
         response = self._call_api(
-            method="GET",
-            path=f"/tasks/{task_id}",
+            method="POST",
+            path="/services/audio/tts/customization",
+            json=payload,
             timeout=30.0,
         )
 
         output = response.get("output", {})
-        status = output.get("task_status", "").upper()
-        voice_id = output.get("voice_id", "")
-        message = output.get("message", "")
-
         return {
-            "status": status,
-            "voice_id": voice_id,
-            "message": message,
+            "status": output.get("status", ""),
+            "target_model": output.get("target_model", ""),
+            "gmt_create": output.get("gmt_create", ""),
+            "gmt_modified": output.get("gmt_modified", ""),
+            "resource_link": output.get("resource_link", ""),
         }
 
-    def poll_clone_task(self, task_id: str, timeout: float = 300.0) -> dict:
-        """轮询音色克隆任务状态（公开方法）。
+    def check_task_status(self, task_id: str) -> dict:
+        """查询克隆任务状态（兼容旧接口，实际用 voice_id 查询）.
 
-        供 Celery 后台任务调用，轮询直到完成或超时。
+        为了兼容旧代码，task_id 参数名保留，但实际传的是 voice_id.
 
         Args:
-            task_id: CosyVoice 任务 ID
+            task_id: 音色 ID（兼容旧接口名）
+
+        Returns:
+            dict: {"status": str, "voice_id": str, "message": str}
+        """
+        result = self.query_voice_status(task_id)
+        return {
+            "status": result["status"],
+            "voice_id": task_id,
+            "message": "",
+        }
+
+    def poll_clone_task(self, voice_id: str, timeout: float = 300.0) -> dict:
+        """轮询音色克隆状态直到完成或超时.
+
+        供 Celery 后台任务调用，轮询直到状态变为 OK 或 UNDEPLOYED.
+
+        Args:
+            voice_id: 音色 ID
             timeout: 超时时间（秒），默认 300
 
         Returns:
             dict: {"voice_id": str}
 
         Raises:
-            CosyVoiceError: 任务失败
+            CosyVoiceError: 任务失败（状态 UNDEPLOYED）
             CosyVoiceTimeoutError: 超时
         """
-        return self._poll_clone_task(task_id, timeout=timeout)
+        start_time = time.time()
+        attempts = 0
+
+        while attempts < self.CLONE_MAX_POLL_ATTEMPTS:
+            elapsed = time.time() - start_time
+            if elapsed > timeout:
+                raise CosyVoiceTimeoutError(f"音色克隆任务超时（{timeout}秒）: voice_id={voice_id}")
+
+            result = self.query_voice_status(voice_id)
+            status = result.get("status", "").upper()
+
+            if status == "OK":
+                return {"voice_id": voice_id}
+            elif status == "UNDEPLOYED":
+                raise CosyVoiceError(f"音色克隆任务失败（审核未通过）: voice_id={voice_id}")
+            elif status in ("DEPLOYING", "PENDING", "PROCESSING", ""):
+                # 继续轮询
+                time.sleep(self.CLONE_POLL_INTERVAL)
+                attempts += 1
+            else:
+                logger.warning("未知的音色状态: %s (voice_id=%s)", status, voice_id)
+                time.sleep(self.CLONE_POLL_INTERVAL)
+                attempts += 1
+
+        raise CosyVoiceTimeoutError(f"音色克隆任务轮询次数超限: voice_id={voice_id}")
 
     def clone_voice(
         self,
@@ -262,122 +381,45 @@ class CosyVoiceService:
         voice_name: str = "",
         language: str = "zh-CN",
         timeout: float = 300.0,
+        target_model: str = "",
     ) -> CloneResult:
-        """克隆音色。
+        """克隆音色（阻塞，直到完成或超时）.
 
-        提交音色克隆任务到 CosyVoice API，并轮询直到完成或超时。
+        提交音色克隆到百炼 API，并轮询直到状态变为 OK 或超时.
 
         Args:
-            audio_url: 参考音频 URL
-            voice_name: 音色名称（可选）
+            audio_url: 参考音频 URL（必须公网可访问）
+            voice_name: 音色名称前缀
             language: 语言代码
             timeout: 超时时间（秒）
+            target_model: 目标合成模型
 
         Returns:
             CloneResult: 克隆结果，包含 voice_id
 
         Raises:
-            CosyVoiceError: API 调用失败
+            CosyVoiceError: API 调用失败或克隆失败
             CosyVoiceTimeoutError: 超时
             CosyVoiceAuthError: 认证失败
             ValueError: 参数无效
         """
-        if not audio_url:
-            raise ValueError("audio_url 不能为空")
-        if not self._api_key:
-            raise CosyVoiceAuthError("CosyVoice API Key 未配置")
-
-        # 构建请求
-        payload = {
-            "model": self._model,
-            "input": {
-                "audio_url": audio_url,
-            },
-            "parameters": {
-                "language": language,
-            },
-        }
-        if voice_name:
-            payload["parameters"]["voice_name"] = voice_name
-
-        # 调用 API
-        response = self._call_api(
-            method="POST",
-            path="/services/audio/voice-clone",
-            json=payload,
-            timeout=timeout,
+        submit_result = self.submit_clone_task(
+            audio_url=audio_url,
+            voice_name=voice_name,
+            language=language,
+            target_model=target_model,
         )
 
-        # 解析响应
-        output = response.get("output", {})
+        voice_id = submit_result["voice_id"]
+        request_id = submit_result["request_id"]
 
-        # 检查是否有 task_id（异步模式）
-        task_id = output.get("task_id")
-        voice_id = output.get("voice_id")
+        # 如果创建时已经是 OK 状态，直接返回
+        if submit_result.get("status", "").upper() == "OK":
+            return CloneResult(voice_id=voice_id, request_id=request_id)
 
-        if task_id:
-            # 异步模式：轮询任务状态
-            result = self._poll_clone_task(task_id, timeout)
-            return CloneResult(
-                voice_id=result["voice_id"],
-                request_id=response.get("request_id", ""),
-            )
-        elif voice_id:
-            # 同步模式：直接返回结果
-            return CloneResult(
-                voice_id=voice_id,
-                request_id=response.get("request_id", ""),
-            )
-        else:
-            raise CosyVoiceError(f"CosyVoice API 未返回 task_id 或 voice_id: {response}")
-
-    def _poll_clone_task(self, task_id: str, timeout: float) -> dict:
-        """轮询音色克隆任务状态。
-
-        Args:
-            task_id: 任务 ID
-            timeout: 超时时间（秒）
-
-        Returns:
-            任务结果字典
-
-        Raises:
-            CosyVoiceError: 任务失败
-            CosyVoiceTimeoutError: 超时
-        """
-        start_time = time.time()
-        attempts = 0
-
-        while attempts < self.MAX_POLL_ATTEMPTS:
-            elapsed = time.time() - start_time
-            if elapsed > timeout:
-                raise CosyVoiceTimeoutError(f"音色克隆任务超时（{timeout}秒）: task_id={task_id}")
-
-            response = self._call_api(
-                method="GET",
-                path=f"/tasks/{task_id}",
-                timeout=30.0,
-            )
-
-            output = response.get("output", {})
-            status = output.get("task_status", "").upper()
-
-            if status == "SUCCEEDED":
-                voice_id = output.get("voice_id", "")
-                if not voice_id:
-                    raise CosyVoiceError(f"音色克隆任务成功但未返回 voice_id: {response}")
-                return {"voice_id": voice_id}
-            elif status == "FAILED":
-                error_msg = output.get("message", "未知错误")
-                raise CosyVoiceError(f"音色克隆任务失败: {error_msg}")
-            elif status in ("PENDING", "RUNNING"):
-                # 继续轮询
-                time.sleep(self.POLL_INTERVAL)
-                attempts += 1
-            else:
-                raise CosyVoiceError(f"未知的任务状态: {status}")
-
-        raise CosyVoiceTimeoutError(f"音色克隆任务轮询次数超限: task_id={task_id}")
+        # 否则轮询
+        result = self.poll_clone_task(voice_id, timeout=timeout)
+        return CloneResult(voice_id=result["voice_id"], request_id=request_id)
 
     # ── 语音合成 ─────────────────────────────────────────
 
@@ -388,11 +430,12 @@ class CosyVoiceService:
         sample_rate: int = 0,
         format: str = "",
         speed: float = 1.0,
+        volume: int = 50,
     ) -> dict:
-        """提交语音合成任务（非阻塞）。
+        """提交语音合成任务（同步非流式，直接返回结果）.
 
-        只提交任务到 CosyVoice API，不轮询结果。
-        返回的 dict 包含 task_id（异步）或 audio_url（同步）。
+        CosyVoice SpeechSynthesizer 非流式接口是同步的，
+        调用后直接返回音频 URL. 此方法保持与旧接口兼容.
 
         Args:
             text: 要合成的文本
@@ -400,10 +443,11 @@ class CosyVoiceService:
             sample_rate: 采样率（Hz），0 表示使用配置默认值
             format: 输出格式（mp3/wav/pcm），空表示使用配置默认值
             speed: 语速（0.5-2.0），1.0 为正常速度
+            volume: 音量（0-100），默认 50
 
         Returns:
-            dict: {"task_id": str, "audio_url": str, "request_id": str}
-                  task_id 和 audio_url 至少有一个非空
+            dict: {"audio_url": str, "request_id": str,
+                   "duration": float, "file_size": int}
 
         Raises:
             CosyVoiceError: API 调用失败
@@ -423,55 +467,47 @@ class CosyVoiceService:
             "model": self._model,
             "input": {
                 "text": text,
-            },
-            "parameters": {
                 "voice": voice_id,
-                "sample_rate": sample_rate or settings.cosyvoice_sample_rate,
                 "format": format or settings.cosyvoice_format,
+                "sample_rate": sample_rate or settings.cosyvoice_sample_rate,
                 "rate": speed,
+                "volume": volume,
             },
         }
 
         response = self._call_api(
             method="POST",
-            path="/services/aigc/text2audio/generation",
+            path="/services/audio/tts/SpeechSynthesizer",
             json=payload,
-            timeout=60.0,
+            timeout=120.0,
         )
 
         output = response.get("output", {})
-        task_id = output.get("task_id", "")
-        audio_url = output.get("audio_url", "")
+        audio = output.get("audio", {})
+        audio_url = audio.get("url", "")
         request_id = response.get("request_id", "")
 
-        if not task_id and not audio_url:
-            raise CosyVoiceError(f"CosyVoice API 未返回 task_id 或 audio_url: {response}")
+        if not audio_url:
+            raise CosyVoiceError(f"CosyVoice API 未返回 audio_url: {response}")
 
         return {
-            "task_id": task_id,
+            "task_id": "",  # 同步接口无 task_id，兼容旧接口
             "audio_url": audio_url,
-            "duration": output.get("duration", 0.0),
-            "file_size": output.get("file_size", 0),
+            "duration": 0.0,  # 同步接口不返回 duration
+            "file_size": 0,  # 同步接口不返回 file_size
             "request_id": request_id,
         }
 
     def poll_synthesize_task(self, task_id: str, timeout: float = 120.0) -> dict:
-        """轮询语音合成任务状态（公开方法）。
+        """轮询合成任务（同步接口无需轮询，保留兼容）.
 
-        供 Celery 后台任务调用，轮询直到完成或超时。
-
-        Args:
-            task_id: CosyVoice 任务 ID
-            timeout: 超时时间（秒），默认 120
-
-        Returns:
-            dict: {"audio_url": str, "duration": float, "file_size": int}
+        CosyVoice SpeechSynthesizer 非流式接口是同步的，
+        此方法仅为保持接口兼容，实际调用时 task_id 应该为空.
 
         Raises:
-            CosyVoiceError: 任务失败
-            CosyVoiceTimeoutError: 超时
+            CosyVoiceError: 同步接口无需轮询
         """
-        return self._poll_synthesize_task(task_id, timeout=timeout)
+        raise CosyVoiceError("CosyVoice 非流式合成接口是同步的，无需轮询. " "请直接使用 submit_synthesize_task().")
 
     def synthesize_speech(
         self,
@@ -480,11 +516,13 @@ class CosyVoiceService:
         sample_rate: int = 0,
         format: str = "",
         speed: float = 1.0,
+        volume: int = 50,
         timeout: float = 120.0,
     ) -> SynthesizeResult:
-        """语音合成。
+        """语音合成（同步非流式）.
 
-        提交语音合成任务到 CosyVoice API，并轮询直到完成或超时。
+        调用百炼 CosyVoice SpeechSynthesizer 非流式接口，
+        直接返回合成音频 URL.
 
         Args:
             text: 要合成的文本
@@ -492,129 +530,53 @@ class CosyVoiceService:
             sample_rate: 采样率（Hz），0 表示使用配置默认值
             format: 输出格式（mp3/wav/pcm），空表示使用配置默认值
             speed: 语速（0.5-2.0），1.0 为正常速度
-            timeout: 超时时间（秒）
+            volume: 音量（0-100），默认 50
+            timeout: 超时时间（秒），保留参数兼容
 
         Returns:
             SynthesizeResult: 合成结果，包含 audio_url
 
         Raises:
             CosyVoiceError: API 调用失败
-            CosyVoiceTimeoutError: 超时
             CosyVoiceAuthError: 认证失败
             ValueError: 参数无效
         """
-        if not text:
-            raise ValueError("text 不能为空")
-        if not voice_id:
-            raise ValueError("voice_id 不能为空")
-        if not self._api_key:
-            raise CosyVoiceAuthError("CosyVoice API Key 未配置")
-
-        settings = get_shared_settings()
-
-        # 构建请求
-        payload = {
-            "model": self._model,
-            "input": {
-                "text": text,
-            },
-            "parameters": {
-                "voice": voice_id,
-                "sample_rate": sample_rate or settings.cosyvoice_sample_rate,
-                "format": format or settings.cosyvoice_format,
-                "rate": speed,
-            },
-        }
-
-        # 调用 API
-        response = self._call_api(
-            method="POST",
-            path="/services/aigc/text2audio/generation",
-            json=payload,
-            timeout=timeout,
+        result = self.submit_synthesize_task(
+            text=text,
+            voice_id=voice_id,
+            sample_rate=sample_rate,
+            format=format,
+            speed=speed,
+            volume=volume,
         )
 
-        # 解析响应
-        output = response.get("output", {})
-
-        # 检查是否有 task_id（异步模式）
-        task_id = output.get("task_id")
-        audio_url = output.get("audio_url")
-
-        if task_id:
-            # 异步模式：轮询任务状态
-            result = self._poll_synthesize_task(task_id, timeout)
-            return SynthesizeResult(
-                audio_url=result["audio_url"],
-                duration=result.get("duration", 0.0),
-                file_size=result.get("file_size", 0),
-                request_id=response.get("request_id", ""),
-            )
-        elif audio_url:
-            # 同步模式：直接返回结果
-            return SynthesizeResult(
-                audio_url=audio_url,
-                duration=output.get("duration", 0.0),
-                file_size=output.get("file_size", 0),
-                request_id=response.get("request_id", ""),
-            )
-        else:
-            raise CosyVoiceError(f"CosyVoice API 未返回 audio_url 或 task_id: {response}")
-
-    def _poll_synthesize_task(self, task_id: str, timeout: float) -> dict:
-        """轮询语音合成任务状态。
-
-        Args:
-            task_id: 任务 ID
-            timeout: 超时时间（秒）
-
-        Returns:
-            任务结果字典
-
-        Raises:
-            CosyVoiceError: 任务失败
-            CosyVoiceTimeoutError: 超时
-        """
-        start_time = time.time()
-        attempts = 0
-
-        while attempts < self.MAX_POLL_ATTEMPTS:
-            elapsed = time.time() - start_time
-            if elapsed > timeout:
-                raise CosyVoiceTimeoutError(f"语音合成任务超时（{timeout}秒）: task_id={task_id}")
-
-            response = self._call_api(
-                method="GET",
-                path=f"/tasks/{task_id}",
-                timeout=30.0,
-            )
-
-            output = response.get("output", {})
-            status = output.get("task_status", "").upper()
-
-            if status == "SUCCEEDED":
-                audio_url = output.get("audio_url", "")
-                if not audio_url:
-                    raise CosyVoiceError(f"语音合成任务成功但未返回 audio_url: {response}")
-                return {
-                    "audio_url": audio_url,
-                    "duration": output.get("duration", 0.0),
-                    "file_size": output.get("file_size", 0),
-                }
-            elif status == "FAILED":
-                error_msg = output.get("message", "未知错误")
-                raise CosyVoiceError(f"语音合成任务失败: {error_msg}")
-            elif status in ("PENDING", "RUNNING"):
-                # 继续轮询
-                time.sleep(self.POLL_INTERVAL)
-                attempts += 1
-            else:
-                raise CosyVoiceError(f"未知的任务状态: {status}")
-
-        raise CosyVoiceTimeoutError(f"语音合成任务轮询次数超限: task_id={task_id}")
+        return SynthesizeResult(
+            audio_url=result["audio_url"],
+            duration=result.get("duration", 0.0),
+            file_size=result.get("file_size", 0),
+            request_id=result.get("request_id", ""),
+        )
 
     # ── 内部方法 ─────────────────────────────────────────
 
+    def _sanitize_prefix(self, name: str) -> str:
+        """清洗音色名称为合法的 prefix（字母数字，最多10字符）.
+
+        Args:
+            name: 原始音色名称
+
+        Returns:
+            清洗后的 prefix
+        """
+        # 只保留字母和数字
+        cleaned = "".join(c for c in name if c.isalnum())
+        # 最多10字符
+        cleaned = cleaned[:10]
+        # 如果清洗后为空，用默认值
+        if not cleaned:
+            cleaned = "clone"
+        return cleaned
+
     def _call_api(
         self,
         method: str,
@@ -622,13 +584,13 @@ class CosyVoiceService:
         json: Optional[dict] = None,
         timeout: float = 30.0,
     ) -> dict:
-        """调用 CosyVoice API。
+        """调用 DashScope API.
 
-        支持重试和错误处理。
+        支持重试和错误处理.
 
         Args:
             method: HTTP 方法（GET/POST）
-            path: API 路径
+            path: API 路径（以 / 开头）
             json: 请求体
             timeout: 超时时间（秒）
 
@@ -646,6 +608,22 @@ class CosyVoiceService:
             "Content-Type": "application/json",
         }
 
+        # DEBUG: 打印完整请求信息，用于排查418错误
+        import json as json_lib
+
+        safe_headers = {k: v for k, v in headers.items()}
+        if "Authorization" in safe_headers:
+            token = safe_headers["Authorization"]
+            if len(token) > 20:
+                safe_headers["Authorization"] = token[:13] + "..." + token[-4:]
+        logger.info(
+            "[CosyVoice Debug] 请求详情: " "method=%s, url=%s, headers=%s, body=%s",
+            method,
+            url,
+            safe_headers,
+            json_lib.dumps(json, ensure_ascii=False) if json else "None",
+        )
+
         last_error: Optional[Exception] = None
 
         for attempt in range(self.MAX_RETRIES):
@@ -658,29 +636,58 @@ class CosyVoiceService:
                     timeout=timeout,
                 )
 
+                # DEBUG: 打印响应状态和完整响应体
+                logger.info(
+                    "[CosyVoice Debug] 响应详情: " "status=%d, body=%s",
+                    response.status_code,
+                    response.text[:2000],  # 最多2000字符，避免日志过大
+                )
+
                 # 处理响应
                 if response.status_code == 200:
                     return response.json()
                 elif response.status_code in (401, 403):
                     raise CosyVoiceAuthError(f"CosyVoice API 认证失败: HTTP {response.status_code}")
+                elif response.status_code == 400:
+                    # 客户端错误，不重试
+                    body_text = response.text
+                    try:
+                        body = response.json()
+                        code = body.get("code", "")
+                        message = body.get("message", "")
+                        raise CosyVoiceError(f"CosyVoice API 参数错误: HTTP 400, " f"code={code}, message={message}")
+                    except ValueError:
+                        raise CosyVoiceError(f"CosyVoice API 调用失败: HTTP 400, body={body_text}")
                 elif response.status_code >= 500:
                     # 服务端错误，可重试
                     last_error = CosyVoiceError(f"CosyVoice API 服务端错误: HTTP {response.status_code}")
                     logger.warning(
-                        f"CosyVoice API 失败 (尝试 {attempt + 1}/{self.MAX_RETRIES}): " f"HTTP {response.status_code}"
+                        "CosyVoice API 失败 (尝试 %d/%d): HTTP %d",
+                        attempt + 1,
+                        self.MAX_RETRIES,
+                        response.status_code,
                     )
                 else:
-                    # 客户端错误，不重试
+                    # 其他客户端错误，不重试
                     raise CosyVoiceError(
                         f"CosyVoice API 调用失败: HTTP {response.status_code}, " f"body={response.text}"
                     )
 
             except httpx.TimeoutException as e:
                 last_error = CosyVoiceTimeoutError(f"请求超时: {e}")
-                logger.warning(f"CosyVoice API 超时 (尝试 {attempt + 1}/{self.MAX_RETRIES})")
+                logger.warning(
+                    "CosyVoice API 超时 (尝试 %d/%d)",
+                    attempt + 1,
+                    self.MAX_RETRIES,
+                )
             except httpx.RequestError as e:
                 last_error = CosyVoiceError(f"请求错误: {e}")
-                logger.warning(f"CosyVoice API 请求错误 (尝试 {attempt + 1}/{self.MAX_RETRIES}): {e}")
+                logger.warning(
+                    "CosyVoice API 请求错误 (尝试 %d/%d): %s",
+                    attempt + 1,
+                    self.MAX_RETRIES,
+                    e,
+                )
 
             # 指数退避
             if attempt < self.MAX_RETRIES - 1:

packages/application/tts_job/workflow.py

@@ -14,7 +14,6 @@ import logging
 import os
 import shutil
 import tempfile
-import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Optional
 
@@ -190,10 +189,13 @@ class TTSWorkflowService:
         return job
 
     def poll_and_process_synthesis(self, job_id: str, timeout: float = 120.0) -> TTSJob:
-        """轮询 CosyVoice 合成任务并处理结果。
+        """轮询/检查 CosyVoice 合成任务并处理结果.
 
-        从 job.metadata 获取 task_id，调用 CosyVoiceService.poll_synthesize_task()
-        轮询状态，然后通过 process_synthesis_result / process_synthesis_failure 更新 job。
+        新 CosyVoice SpeechSynthesizer 非流式接口是同步的，
+        start_synthesis 阶段通常已经完成. 此方法用于：
+        1. job 已 completed → 直接返回（同步路径已处理）
+        2. job 仍在 processing → 重新提交合成（兜底）
+        3. 分段任务 → 检查分段状态
 
         供 Celery 后台任务调用。
         """
@@ -201,22 +203,38 @@ class TTSWorkflowService:
         if job is None:
             raise TTSJobNotFoundError(f"TTS job {job_id} not found")
 
+        # 已完成直接返回（同步路径在 start_synthesis 里已处理）
+        if job.status == TTSJobStatus.COMPLETED.value:
+            logger.info(f"TTS 任务已完成，跳过轮询: job_id={job_id}")
+            return job
+
         # 检查是否为分段合成任务
         segment_task_ids = (job.metadata or {}).get("segment_task_ids", [])
         if segment_task_ids:
             return self._poll_segment_tasks(job)
 
+        # 单段模式：同步接口下通常不会走到这里，
+        # 但如果因为异常导致仍在 processing，重新提交一次
         task_id = (job.metadata or {}).get("cosyvoice_task_id", "")
-        if not task_id:
-            raise ValueError(f"TTSJob {job_id} has no cosyvoice_task_id in metadata")
 
-        result = self.cosyvoice_service.poll_synthesize_task(task_id, timeout=timeout)
-        return self.process_synthesis_result(
-            job_id,
-            audio_url=result["audio_url"],
-            duration=result.get("duration", 0.0),
-            file_size=result.get("file_size", 0),
-        )
+        # 新接口（同步）：没有 task_id，重新合成
+        if not task_id:
+            logger.info(f"TTS 任务无 task_id，重新同步合成: job_id={job_id}")
+            return self._resynthesize_and_complete(job)
+
+        # 旧接口遗留的 task_id，尝试轮询（兼容过渡）
+        try:
+            result = self.cosyvoice_service.poll_synthesize_task(task_id, timeout=timeout)
+            return self.process_synthesis_result(
+                job_id,
+                audio_url=result["audio_url"],
+                duration=result.get("duration", 0.0),
+                file_size=result.get("file_size", 0),
+            )
+        except CosyVoiceError:
+            # 旧接口轮询失败，重新同步合成
+            logger.warning(f"旧 task_id 轮询失败，重新同步合成: job_id={job_id}, task_id={task_id}")
+            return self._resynthesize_and_complete(job)
 
     def process_synthesis_result(
         self,
@@ -257,6 +275,40 @@ class TTSWorkflowService:
         logger.info(f"TTS 合成成功: job_id={job_id}, audio_url={permanent_url}")
         return job
 
+    def _resynthesize_and_complete(self, job: TTSJob) -> TTSJob:
+        """重新同步合成并完成任务（兜底路径）.
+
+        当 poll_and_process_synthesis 发现 job 仍在 processing 且无 task_id 时，
+        重新调用同步合成接口，转存 OSS 后标记完成。
+        """
+        try:
+            # 从 metadata 读取合成参数（兼容旧数据，无则用默认值）
+            job_metadata = job.metadata or {}
+            speed = float(job_metadata.get("speed", 1.0))
+            volume = int(job_metadata.get("volume", 50))
+
+            result = self.cosyvoice_service.submit_synthesize_task(
+                text=job.input_text,
+                voice_id=job.voice_id,
+                sample_rate=job.sample_rate,
+                format=job.format,
+                speed=speed,
+                volume=volume,
+            )
+            audio_url = result.get("audio_url", "")
+            if not audio_url:
+                raise CosyVoiceError("重新合成未返回 audio_url")
+
+            return self.process_synthesis_result(
+                job.id,
+                audio_url=audio_url,
+                duration=result.get("duration", 0.0),
+                file_size=result.get("file_size", 0),
+            )
+        except Exception as e:
+            logger.error(f"重新同步合成失败: job_id={job.id}, error={e}")
+            return self.process_synthesis_failure(job.id, str(e))
+
     def process_synthesis_failure(self, job_id: str, error_message: str) -> TTSJob:
         """处理合成失败结果。
 
@@ -429,69 +481,95 @@ class TTSWorkflowService:
             shutil.rmtree(temp_dir, ignore_errors=True)
 
     def _poll_segment_tasks(self, job: TTSJob) -> TTSJob:
-        """轮询所有分段异步任务，全部完成后合并音频。"""
+        """分段任务完成检查（适配新同步接口）.
+
+        新 CosyVoice SpeechSynthesizer 非流式接口为同步接口，
+        分段任务在提交时应已同步返回 audio_url。
+        若历史任务处于 processing 且有 segment_task_ids 但缺少 audio_url，
+        则对缺失分段重新同步合成，全部完成后合并音频。
+        """
         segment_task_ids: list[str] = (job.metadata or {}).get("segment_task_ids", [])
         segment_audio_urls: list[str] = (job.metadata or {}).get("segment_audio_urls", [])
         segment_count = len(segment_task_ids)
 
-        poll_start = time.monotonic()
-        poll_timeout = 300.0  # 分段任务超时更长
-        poll_interval = 2.0
+        if segment_count == 0:
+            logger.warning(f"分段任务无 task_id: job_id={job.id}")
+            self._handle_segment_failure(job, "分段任务数据异常：无分段信息")
+            return self.repository.get(job.id)
 
-        while time.monotonic() - poll_start < poll_timeout:
-            all_done = True
-            results: list[dict | None] = [None] * segment_count
+        # 从 metadata 读取合成参数
+        job_metadata = job.metadata or {}
+        speed = float(job_metadata.get("speed", 1.0))
+        volume = int(job_metadata.get("volume", 50))
 
-            for idx, task_id in enumerate(segment_task_ids):
-                # 已经有音频的分段跳过轮询
-                if idx < len(segment_audio_urls) and segment_audio_urls[idx]:
-                    results[idx] = {
-                        "audio_url": segment_audio_urls[idx],
-                        "duration": 0.0,
-                        "file_size": 0,
-                    }
-                    continue
+        # 分段文本（用于缺失段重新合成）
+        segments = split_text(job.input_text, max_chars=_SEGMENT_THRESHOLD)
 
-                try:
-                    result = self.cosyvoice_service.poll_synthesize_task(task_id, timeout=poll_timeout)
-                    results[idx] = result
-                except Exception as e:
-                    logger.error(f"分段任务轮询失败: job_id={job.id}, " f"segment={idx}, error={e}")
-                    self._handle_segment_failure(job, f"分段 {idx + 1} 轮询失败: {e}")
-                    return self.repository.get(job.id)
+        results: list[dict | None] = [None] * segment_count
 
-                if results[idx] is None:
-                    all_done = False
+        # 已有音频的分段直接用
+        for idx in range(segment_count):
+            if idx < len(segment_audio_urls) and segment_audio_urls[idx]:
+                results[idx] = {
+                    "audio_url": segment_audio_urls[idx],
+                    "duration": 0.0,
+                    "file_size": 0,
+                }
 
-            if all_done and all(r is not None for r in results):
-                # 所有分段完成，下载合并
-                try:
-                    merged_data, total_duration = self._download_and_merge_segments(results, job)
+        # 找出缺失音频的分段索引
+        missing_indices = [i for i in range(segment_count) if results[i] is None]
 
-                    # 转存 OSS
-                    permanent_url, storage_key = self._upload_merged_to_oss(
-                        merged_data, job.user_id, job.id, job.format
+        if missing_indices:
+            logger.info(f"分段任务重新合成缺失段: job_id={job.id}, " f"缺失={len(missing_indices)}/{segment_count}")
+            # 并发重新合成缺失分段
+            max_workers = min(len(missing_indices), _MAX_SEGMENT_WORKERS)
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                future_to_idx = {}
+                for idx in missing_indices:
+                    segment_text = segments[idx] if idx < len(segments) else ""
+                    future = executor.submit(
+                        self.cosyvoice_service.submit_synthesize_task,
+                        text=segment_text,
+                        voice_id=job.voice_id,
+                        sample_rate=job.sample_rate,
+                        format=job.format,
+                        speed=speed,
+                        volume=volume,
                     )
+                    future_to_idx[future] = idx
 
-                    job.mark_completed(
-                        output_audio_url=permanent_url,
-                        output_audio_key=storage_key,
-                        duration=total_duration,
-                        file_size=len(merged_data),
-                    )
-                    job = self.repository.update(job)
-                    logger.info(f"分段合成轮询完成: job_id={job.id}, " f"merged_size={len(merged_data)}")
-                    return job
+                for future in as_completed(future_to_idx):
+                    idx = future_to_idx[future]
+                    try:
+                        results[idx] = future.result()
+                    except Exception as e:
+                        logger.error(f"分段重新合成失败: job_id={job.id}, " f"segment={idx}, error={e}")
+                        self._handle_segment_failure(job, f"分段 {idx + 1} 重新合成失败: {e}")
+                        return self.repository.get(job.id)
 
-                except Exception as e:
-                    self._handle_segment_failure(job, f"分段合并失败: {e}")
-                    return self.repository.get(job.id)
+        # 所有分段完成，下载合并
+        if all(r is not None for r in results):
+            try:
+                merged_data, total_duration = self._download_and_merge_segments(results, job)
 
-            # 等待后重试
-            time.sleep(poll_interval)
+                permanent_url, storage_key = self._upload_merged_to_oss(merged_data, job.user_id, job.id, job.format)
 
-        # 超时
-        self._handle_segment_failure(job, "分段合成轮询超时（300 秒）")
+                job.mark_completed(
+                    output_audio_url=permanent_url,
+                    output_audio_key=storage_key,
+                    duration=total_duration,
+                    file_size=len(merged_data),
+                )
+                job = self.repository.update(job)
+                logger.info(f"分段合成完成（重新合成路径）: job_id={job.id}, " f"merged_size={len(merged_data)}")
+                return job
+
+            except Exception as e:
+                self._handle_segment_failure(job, f"分段合并失败: {e}")
+                return self.repository.get(job.id)
+
+        # 理论上不会到这里（全部重新合成要么成功要么失败）
+        self._handle_segment_failure(job, "分段合成结果不完整")
         return self.repository.get(job.id)
 
     def _handle_segment_failure(self, job: TTSJob, error_message: str) -> None:

packages/application/voice_clone/workflow.py

@@ -115,14 +115,16 @@ class VoiceCloneWorkflowService:
                     language=language,
                 )
 
-                # 4. 保存 task_id / voice_id 到 metadata
+                # 4. 保存 voice_id / request_id 到 metadata
+                # 注意：key 保留 cosyvoice_task_id 以兼容旧数据，实际存的是 voice_id
                 task_metadata = dict(profile.metadata)
-                task_metadata["cosyvoice_task_id"] = submit_result.get("task_id", "")
+                task_metadata["cosyvoice_task_id"] = submit_result.get("voice_id", "")
                 task_metadata["cosyvoice_request_id"] = submit_result.get("request_id", "")
 
-                # 如果 CosyVoice 同步返回了 voice_id，直接标记 ready
+                # 如果 CosyVoice 直接返回了 OK 状态，直接标记 ready
                 voice_id = submit_result.get("voice_id", "")
-                if voice_id:
+                status = submit_result.get("status", "").upper()
+                if voice_id and status == "OK":
                     profile.mark_ready(voice_id)
                     profile.metadata = task_metadata
                     profile = self.repository.update(profile)
@@ -131,7 +133,9 @@ class VoiceCloneWorkflowService:
 
                 profile.metadata = task_metadata
                 profile = self.repository.update(profile)
-                logger.info(f"音色克隆任务已提交: profile_id={profile.id}, " f"task_id={submit_result.get('task_id')}")
+                logger.info(
+                    f"音色克隆任务已提交: profile_id={profile.id}, " f"voice_id={submit_result.get('voice_id')}"
+                )
 
             except (CosyVoiceError, CosyVoiceAuthError) as e:
                 # CosyVoice 提交失败，标记为 failed
@@ -248,11 +252,12 @@ class VoiceCloneWorkflowService:
                 )
 
                 task_metadata = dict(profile.metadata)
-                task_metadata["cosyvoice_task_id"] = submit_result.get("task_id", "")
+                task_metadata["cosyvoice_task_id"] = submit_result.get("voice_id", "")
                 task_metadata["cosyvoice_request_id"] = submit_result.get("request_id", "")
 
                 voice_id = submit_result.get("voice_id", "")
-                if voice_id:
+                status = submit_result.get("status", "").upper()
+                if voice_id and status == "OK":
                     profile.mark_ready(voice_id)
                     profile.metadata = task_metadata
                     profile = self.repository.update(profile)

packages/domain/entities.py

@@ -134,6 +134,25 @@ class AssetStatus(StrEnum):
     PROCESSING = "processing"
     ERROR = "error"
 
+    @classmethod
+    def _missing_(cls, value: object) -> "AssetStatus":
+        """兼容历史数据，避免枚举转换失败导致500。
+
+        - uploaded → READY（早期版本用 uploaded 表示上传完成）
+        - 其他未知值 → READY（兜底，不阻塞业务）
+        """
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in ("uploaded", "success", "ok", "done", "complete"):
+                return cls.READY
+            if normalized in ("upload", "uploading_start", "upload_start"):
+                return cls.UPLOADING
+            if normalized in ("failed", "fail", "err"):
+                return cls.ERROR
+            if normalized in ("process", "processing", "running", "run"):
+                return cls.PROCESSING
+        return cls.READY
+
 
 class ClassificationStatus(StrEnum):
     PENDING = "pending"
@@ -141,6 +160,23 @@ class ClassificationStatus(StrEnum):
     COMPLETED = "completed"
     FAILED = "failed"
 
+    @classmethod
+    def _missing_(cls, value: object) -> "ClassificationStatus":
+        """兼容历史数据，避免枚举转换失败导致500。
+
+        - done → COMPLETED（早期版本用 done 表示完成）
+        - 其他未知值 → PENDING（兜底，不阻塞业务）
+        """
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in ("done", "success", "finished", "complete"):
+                return cls.COMPLETED
+            if normalized in ("fail", "error", "err"):
+                return cls.FAILED
+            if normalized in ("process", "processing", "running", "run"):
+                return cls.PROCESSING
+        return cls.PENDING
+
 
 @dataclass(slots=True)
 class Asset:

packages/domain/generation_task.py

@@ -8,6 +8,7 @@
 
 from __future__ import annotations
 
+import json
 import sys
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
@@ -85,6 +86,7 @@ class GenerationTask:
     created_by_user_id: str = ""
     asset_select_mode: str = ""
     batch_id: str = ""
+    logs: str = "[]"
     created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
 
     @classmethod
@@ -227,6 +229,43 @@ class GenerationTask:
         self.transition_to(GenerationTaskStatus.CANCELLED)
         self.completed_at = datetime.now(timezone.utc)
 
+    # ── 日志辅助 ────────────────────────────────────────────────────────────
+
+    _MAX_LOGS = 200
+
+    def append_log(self, stage: str, message: str, level: str = "INFO", **kwargs) -> None:
+        """追加一条结构化日志到 logs 字段。
+
+        Args:
+            stage: 阶段名称（如 "接收任务"、"下载素材"、"渲染"）
+            message: 日志消息
+            level: 日志级别（INFO / WARN / ERROR）
+            **kwargs: 额外字段（如 asset_id、duration 等）
+        """
+        try:
+            entries = json.loads(self.logs) if self.logs else []
+        except (json.JSONDecodeError, TypeError):
+            entries = []
+        entry = {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "level": level,
+            "stage": stage,
+            "message": message,
+            **kwargs,
+        }
+        entries.append(entry)
+        # 限制最多保留 _MAX_LOGS 条，防止字段过大
+        if len(entries) > self._MAX_LOGS:
+            entries = entries[-self._MAX_LOGS :]
+        self.logs = json.dumps(entries, ensure_ascii=False)
+
+    def get_logs(self) -> list[dict]:
+        """解析 logs 字段为 list[dict]。"""
+        try:
+            return json.loads(self.logs) if self.logs else []
+        except (json.JSONDecodeError, TypeError):
+            return []
+
     def mark_pending_from_failed(self) -> None:
         """从失败状态重置为待处理（用于重试）。
 

packages/domain/preset_voices.py

@@ -16,7 +16,7 @@ class PresetVoice:
     """预置音色定义。
 
     Attributes:
-        voice_id: CosyVoice 模型音色名（如 longxiaochun）
+        voice_id: CosyVoice 模型音色名（如 longxiaochun_v3）
         name: 中文展示名
         description: 音色描述
         gender: 性别（male/female）
@@ -49,7 +49,7 @@ class PresetVoice:
 # 预置音色列表（阿里云 CosyVoice 真实可用音色）
 PRESET_VOICES: list[PresetVoice] = [
     PresetVoice(
-        voice_id="longxiaochun",
+        voice_id="longxiaochun_v3",
         name="龙小淳",
         description="温柔女声，适合情感类内容",
         gender="female",
@@ -57,7 +57,7 @@ PRESET_VOICES: list[PresetVoice] = [
         tags=["温柔", "女声", "情感"],
     ),
     PresetVoice(
-        voice_id="longxiaoxia",
+        voice_id="longxiaoxia_v3",
         name="龙小夏",
         description="知性女声，适合新闻播报",
         gender="female",
@@ -65,7 +65,7 @@ PRESET_VOICES: list[PresetVoice] = [
         tags=["知性", "女声", "播报"],
     ),
     PresetVoice(
-        voice_id="longxiaochen",
+        voice_id="longxiaochen_v3",
         name="龙小晨",
         description="磁性男声，适合有声书",
         gender="male",
@@ -73,7 +73,7 @@ PRESET_VOICES: list[PresetVoice] = [
         tags=["磁性", "男声", "有声书"],
     ),
     PresetVoice(
-        voice_id="longyue",
+        voice_id="longyue_v3",
         name="龙悦",
         description="甜美女声，适合广告配音",
         gender="female",
@@ -81,7 +81,7 @@ PRESET_VOICES: list[PresetVoice] = [
         tags=["甜美", "女声", "广告"],
     ),
     PresetVoice(
-        voice_id="longshu",
+        voice_id="longshu_v3",
         name="龙书",
         description="沉稳男声，适合教育讲解",
         gender="male",
@@ -89,7 +89,7 @@ PRESET_VOICES: list[PresetVoice] = [
         tags=["沉稳", "男声", "教育"],
     ),
     PresetVoice(
-        voice_id="longjing",
+        voice_id="longjing_v3",
         name="龙静",
         description="优雅女声，适合纪录片解说",
         gender="female",
@@ -97,7 +97,7 @@ PRESET_VOICES: list[PresetVoice] = [
         tags=["优雅", "女声", "纪录片"],
     ),
     PresetVoice(
-        voice_id="longbo",
+        voice_id="longbo_v3",
         name="龙博",
         description="浑厚男声，适合科技类内容",
         gender="male",
@@ -105,7 +105,7 @@ PRESET_VOICES: list[PresetVoice] = [
         tags=["浑厚", "男声", "科技"],
     ),
     PresetVoice(
-        voice_id="longtian",
+        voice_id="longtian_v3",
         name="龙甜",
         description="活泼女声，适合短视频配音",
         gender="female",

packages/ports/generation_task_repository.py

@@ -16,6 +16,10 @@ class GenerationTaskRepository(Protocol):
 
     def count_by_user(self, user_id: str) -> int: ...
 
+    def count_pending_by_user(self, user_id: str) -> int: ...
+
+    def count_pending_total(self) -> int: ...
+
     def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[GenerationTask]: ...
 
     def list_by_source_edit_plan(self, plan_id: str) -> list[GenerationTask]: ...

packages/shared/config.py

@@ -29,13 +29,15 @@ class SharedSettings(BaseSettings):
     oss_access_key_secret: str = ""
     oss_bucket_name: str = "xiaoxia-autocut"
 
-    # CosyVoice (阿里云语音合成)
+    # CosyVoice (阿里云百炼语音合成)
     cosyvoice_api_key: str = ""
-    cosyvoice_base_url: str = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text2audio"
-    cosyvoice_model: str = "cosyvoice-v1"
-    cosyvoice_voice: str = "longxiaochun"  # 默认音色
+    cosyvoice_base_url: str = "https://dashscope.aliyuncs.com/api/v1"
+    cosyvoice_model: str = "cosyvoice-v3-flash"
+    cosyvoice_voice: str = "longxiaochun_v3"  # 默认音色（v3 系列系统音色带 _v3 后缀）
     cosyvoice_sample_rate: int = 22050
     cosyvoice_format: str = "mp3"  # 输出格式：mp3/wav/pcm
+    # 音色克隆模型名（固定为 voice-enrollment）
+    cosyvoice_clone_model: str = "voice-enrollment"
 
     # Environment
     environment: str = "development"

pyproject.toml

@@ -1,7 +1,70 @@
 [tool.black]
 line-length = 120
 target-version = ["py312"]
+extend-exclude = '''
+(
+  \.git
+  | \.cache
+  | \.pytest_cache
+  | \.mypy_cache
+  | __pycache__
+  | node_modules
+  | \.venv
+  | venv
+  | build
+  | dist
+  | \.next
+  | out
+  | coverage
+)
+'''
 
 [tool.isort]
 profile = "black"
 line_length = 120
+extend_skip_glob = [
+    ".git/**",
+    ".cache/**",
+    ".pytest_cache/**",
+    ".mypy_cache/**",
+    "__pycache__/**",
+    "node_modules/**",
+    ".venv/**",
+    "venv/**",
+    "build/**",
+    "dist/**",
+    ".next/**",
+    "out/**",
+    "coverage/**",
+]
+
+[tool.coverage.run]
+source = ["apps/api/app", "packages"]
+omit = [
+    "*/migrations/*",
+    "*/tests/*",
+    "*/test_*.py",
+    "*/site-packages/*",
+]
+branch = true
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if __name__ == .__main__.:",
+    "raise NotImplementedError",
+    "pass",
+    "if TYPE_CHECKING:",
+    "class .*Protocol",
+    "@abstractmethod",
+    "raise AssertionError",
+    "raise RuntimeError",
+    "if 0:",
+    "if __debug__:",
+]
+show_missing = true
+skip_covered = false
+
+[tool.coverage.xml]
+output = "coverage.xml"

scripts/build_release_images.sh

@@ -57,6 +57,7 @@ fi
 echo "=== Building API image ==="
 if [ "$USE_CACHE" -eq 1 ]; then
   docker buildx build \
+    --build-arg APP_VERSION="$VERSION" \
     --cache-from "type=registry,ref=${CACHE_REGISTRY}/api-cache:${CACHE_TAG},ignore-error=true" \
     --cache-to "type=registry,ref=${CACHE_REGISTRY}/api-cache:${CACHE_TAG},mode=max" \
     -f infra/docker/api.Dockerfile \
@@ -64,12 +65,13 @@ if [ "$USE_CACHE" -eq 1 ]; then
     --load \
     .
 else
-  docker build --pull=false -f infra/docker/api.Dockerfile -t "$API_IMAGE" -t "$API_LATEST" .
+  docker build --pull=false --build-arg APP_VERSION="$VERSION" -f infra/docker/api.Dockerfile -t "$API_IMAGE" -t "$API_LATEST" .
 fi
 
 echo "=== Building Worker image ==="
 if [ "$USE_CACHE" -eq 1 ]; then
   docker buildx build \
+    --build-arg APP_VERSION="$VERSION" \
     --cache-from "type=registry,ref=${CACHE_REGISTRY}/worker-cache:${CACHE_TAG},ignore-error=true" \
     --cache-to "type=registry,ref=${CACHE_REGISTRY}/worker-cache:${CACHE_TAG},mode=max" \
     -f infra/docker/worker.Dockerfile \
@@ -77,7 +79,7 @@ if [ "$USE_CACHE" -eq 1 ]; then
     --load \
     .
 else
-  docker build --pull=false -f infra/docker/worker.Dockerfile -t "$WORKER_IMAGE" -t "$WORKER_LATEST" .
+  docker build --pull=false --build-arg APP_VERSION="$VERSION" -f infra/docker/worker.Dockerfile -t "$WORKER_IMAGE" -t "$WORKER_LATEST" .
 fi
 
 echo "=== Building Web image (with buildx cache) ==="

scripts/ci_coverage_summary.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""解析 coverage.xml 并输出覆盖率汇总。"""
+
+import os
+import sys
+import xml.etree.ElementTree as ET
+
+THRESHOLD = int(os.environ.get("COVERAGE_THRESHOLD", 65))  # 行覆盖率门槛，百分比，可通过环境变量覆盖
+
+
+def main() -> int:
+    try:
+        tree = ET.parse("coverage.xml")
+    except FileNotFoundError:
+        print("coverage.xml 不存在，跳过汇总")
+        return 0
+
+    root = tree.getroot()
+    line_rate = float(root.get("line-rate", 0)) * 100
+    branch_rate = float(root.get("branch-rate", 0)) * 100
+    lines_covered = int(root.get("lines-covered", 0))
+    lines_valid = int(root.get("lines-valid", 0))
+
+    print(f"行覆盖率: {line_rate:.2f}% ({lines_covered}/{lines_valid})")
+    print(f"分支覆盖率: {branch_rate:.2f}%")
+    print(f"门槛: {THRESHOLD}%")
+    status = "PASS ✅" if line_rate >= THRESHOLD else "FAIL ❌"
+    print(f"状态: {status}")
+
+    return 0 if line_rate >= THRESHOLD else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/ci_notify_failure.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""发送 CI 失败通知到飞书/项目群 webhook。"""
+
+import json
+import os
+import sys
+import urllib.request
+
+
+def main() -> int:
+    webhook = os.environ.get("CI_NOTIFY_WEBHOOK", "")
+    if not webhook:
+        print("未配置 CI_NOTIFY_WEBHOOK，跳过通知")
+        print("如需启用，请在仓库 Settings -> Secrets and variables -> Actions 中添加 CI_NOTIFY_WEBHOOK")
+        return 0
+
+    failed_job = os.environ.get("FAILED_JOB", "Unknown Job")
+    branch = os.environ.get("GITHUB_REF_NAME", "unknown")
+    commit = os.environ.get("GITHUB_SHA", "unknown")[:8]
+    actor = os.environ.get("GITHUB_ACTOR", "unknown")
+    run_id = os.environ.get("GITHUB_RUN_ID", "unknown")
+    repo = os.environ.get("GITHUB_REPOSITORY", "unknown")
+    run_url = f"https://git.xiaoxiajianji.com/{repo}/actions/runs/{run_id}"
+
+    payload = {
+        "msg_type": "interactive",
+        "card": {
+            "header": {
+                "title": {
+                    "tag": "plain_text",
+                    "content": "❌ CI 构建失败",
+                },
+                "status": "red",
+            },
+            "elements": [
+                {
+                    "tag": "div",
+                    "text": {
+                        "tag": "lark_md",
+                        "content": (
+                            f"**任务**: {failed_job}\n"
+                            f"**分支**: {branch}\n"
+                            f"**提交**: {commit}\n"
+                            f"**提交者**: {actor}\n"
+                            f"**Run ID**: {run_id}"
+                        ),
+                    },
+                },
+                {
+                    "tag": "action",
+                    "actions": [
+                        {
+                            "tag": "button",
+                            "text": {"tag": "plain_text", "content": "查看失败日志"},
+                            "url": run_url,
+                            "type": "danger",
+                        }
+                    ],
+                },
+            ],
+        },
+    }
+
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        webhook,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            resp.read()
+        print("通知已发送")
+    except Exception as e:
+        print(f"通知发送失败: {e}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/ci_notify_success.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""发送 CI 成功通知到飞书/项目群 webhook。"""
+
+import json
+import os
+import sys
+import urllib.request
+
+
+def main() -> int:
+    webhook = os.environ.get("CI_NOTIFY_WEBHOOK", "")
+    if not webhook:
+        print("未配置 CI_NOTIFY_WEBHOOK，跳过成功通知")
+        print("如需启用，请在仓库 Settings -> Secrets and variables -> Actions 中添加 CI_NOTIFY_WEBHOOK")
+        return 0
+
+    success_job = os.environ.get("SUCCESS_JOB", "Unknown Job")
+    branch = os.environ.get("GITHUB_REF_NAME", "unknown")
+    commit = os.environ.get("GITHUB_SHA", "unknown")[:8]
+    actor = os.environ.get("GITHUB_ACTOR", "unknown")
+    run_id = os.environ.get("GITHUB_RUN_ID", "unknown")
+    repo = os.environ.get("GITHUB_REPOSITORY", "unknown")
+    run_url = f"https://git.xiaoxiajianji.com/{repo}/actions/runs/{run_id}"
+
+    payload = {
+        "msg_type": "interactive",
+        "card": {
+            "header": {
+                "title": {
+                    "tag": "plain_text",
+                    "content": "✅ CI 构建成功",
+                },
+                "status": "green",
+            },
+            "elements": [
+                {
+                    "tag": "div",
+                    "text": {
+                        "tag": "lark_md",
+                        "content": (
+                            f"**任务**: {success_job}\n"
+                            f"**分支**: {branch}\n"
+                            f"**提交**: {commit}\n"
+                            f"**提交者**: {actor}\n"
+                            f"**Run ID**: {run_id}"
+                        ),
+                    },
+                },
+                {
+                    "tag": "action",
+                    "actions": [
+                        {
+                            "tag": "button",
+                            "text": {"tag": "plain_text", "content": "查看构建详情"},
+                            "url": run_url,
+                            "type": "primary",
+                        }
+                    ],
+                },
+            ],
+        },
+    }
+
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        webhook,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            resp.read()
+        print("成功通知已发送")
+    except Exception as e:
+        print(f"成功通知发送失败: {e}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

setup.cfg

@@ -3,6 +3,7 @@ max-line-length = 120
 extend-ignore = E203,W503,E501,E302,E402,E722,W291,W293,F401,F403,F405,F841
 exclude =
     .git,
+    .cache,
     __pycache__,
     .venv,
     .venv-ci-root,

tests/integration/test_generation_api.py

@@ -118,6 +118,18 @@ class StubGenerationTaskRepository:
     def count_by_user(self, user_id: str) -> int:
         return len([t for t in self._tasks.values() if t.created_by_user_id == user_id])
 
+    def count_pending_by_user(self, user_id: str) -> int:
+        return len(
+            [
+                t
+                for t in self._tasks.values()
+                if t.created_by_user_id == user_id and t.status == GenerationTaskStatus.PENDING
+            ]
+        )
+
+    def count_pending_total(self) -> int:
+        return len([t for t in self._tasks.values() if t.status == GenerationTaskStatus.PENDING])
+
     def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[GenerationTask]:
         items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
         items.sort(key=lambda t: t.created_at, reverse=True)
@@ -241,7 +253,7 @@ def client():
 class TestCreateGenerationTask:
     """创建生成任务端点测试。"""
 
-    @patch("app.api.routes.generation_tasks.celery_app")
+    @patch("app.core.task_enqueue.celery_app")
     def test_create_task_success(self, mock_celery, client):
         """正常创建生成任务成功。"""
         mock_celery.send_task = MagicMock()
@@ -270,7 +282,7 @@ class TestCreateGenerationTask:
         assert mock_celery.send_task.called
         assert mock_celery.send_task.call_args[0][0] == "worker.generate_video"
 
-    @patch("app.api.routes.generation_tasks.celery_app")
+    @patch("app.core.task_enqueue.celery_app")
     def test_create_batch_tasks(self, mock_celery, client):
         """批量创建多个生成任务。"""
         mock_celery.send_task = MagicMock()
@@ -347,7 +359,7 @@ class TestListGenerationTasks:
 
     def _create_task(self, client, task_suffix: str = "1"):
         """辅助方法：创建一个生成任务。"""
-        with patch("app.api.routes.generation_tasks.celery_app") as mock_celery:
+        with patch("app.core.task_enqueue.celery_app") as mock_celery:
             mock_celery.send_task = MagicMock()
             resp = client.post(
                 "/api/v1/generation/tasks",
@@ -368,7 +380,7 @@ class TestListGenerationTasks:
         assert "items" in data
         assert data["items"] == []
 
-    @patch("app.api.routes.generation_tasks.celery_app")
+    @patch("app.core.task_enqueue.celery_app")
     def test_list_returns_user_tasks(self, mock_celery, client):
         """返回当前用户的生成任务列表。"""
         mock_celery.send_task = MagicMock()
@@ -406,7 +418,7 @@ class TestGetGenerationTask:
     """获取生成任务详情端点测试。"""
 
     def _create_task(self, client) -> str:
-        with patch("app.api.routes.generation_tasks.celery_app") as mock_celery:
+        with patch("app.core.task_enqueue.celery_app") as mock_celery:
             mock_celery.send_task = MagicMock()
             resp = client.post(
                 "/api/v1/generation/tasks",
@@ -449,7 +461,7 @@ class TestListGenerationResults:
     """列出生成结果端点测试。"""
 
     def _create_task(self, client) -> str:
-        with patch("app.api.routes.generation_tasks.celery_app") as mock_celery:
+        with patch("app.core.task_enqueue.celery_app") as mock_celery:
             mock_celery.send_task = MagicMock()
             resp = client.post(
                 "/api/v1/generation/tasks",
@@ -489,7 +501,7 @@ class TestRetryGenerationTask:
 
     def _create_failed_task(self, client) -> str:
         """创建一个失败状态的任务。"""
-        with patch("app.api.routes.generation_tasks.celery_app") as mock_celery:
+        with patch("app.core.task_enqueue.celery_app") as mock_celery:
             mock_celery.send_task = MagicMock()
             resp = client.post(
                 "/api/v1/generation/tasks",
@@ -509,7 +521,7 @@ class TestRetryGenerationTask:
         # 让我们直接通过 retry 测试来验证
         return task_id
 
-    @patch("app.api.routes.generation_tasks.celery_app")
+    @patch("app.core.task_enqueue.celery_app")
     def test_retry_failed_task(self, mock_celery, client):
         """重试失败的任务成功。"""
         mock_celery.send_task = MagicMock()
@@ -539,7 +551,7 @@ class TestRetryGenerationTask:
         assert resp.status_code == 404
         assert "not found" in resp.json()["detail"].lower()
 
-    @patch("app.api.routes.generation_tasks.celery_app")
+    @patch("app.core.task_enqueue.celery_app")
     def test_retry_completed_task_returns_409(self, mock_celery, client):
         """重试已完成的任务返回 409。"""
         mock_celery.send_task = MagicMock()
@@ -568,7 +580,7 @@ class TestRetryGenerationTask:
 class TestGenerationTaskFlow:
     """生成任务完整流程集成测试。"""
 
-    @patch("app.api.routes.generation_tasks.celery_app")
+    @patch("app.core.task_enqueue.celery_app")
     def test_create_list_detail_results_flow(self, mock_celery, client):
         """测试创建 → 列表 → 详情 → 结果 完整流程。"""
         mock_celery.send_task = MagicMock()

tests/integration/test_task_center_api.py

@@ -83,6 +83,18 @@ class StubGenerationTaskRepository:
     def count_by_user(self, user_id: str) -> int:
         return len([t for t in self._tasks.values() if t.created_by_user_id == user_id])
 
+    def count_pending_by_user(self, user_id: str) -> int:
+        return len(
+            [
+                t
+                for t in self._tasks.values()
+                if t.created_by_user_id == user_id and t.status == GenerationTaskStatus.PENDING
+            ]
+        )
+
+    def count_pending_total(self) -> int:
+        return len([t for t in self._tasks.values() if t.status == GenerationTaskStatus.PENDING])
+
     def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[GenerationTask]:
         items = [t for t in self._tasks.values() if t.created_by_user_id == user_id]
         items.sort(key=lambda t: t.created_at, reverse=True)
@@ -428,7 +440,7 @@ class TestRetryProjectTask:
         assert resp.status_code == 400
         assert "Unsupported" in resp.json()["detail"]
 
-    @patch("app.api.routes.task_center.celery_app")
+    @patch("app.core.task_enqueue.celery_app")
     def test_retry_failed_generation_task(self, mock_celery, client):
         """重试失败的 generation 任务成功。"""
         mock_celery.send_task = MagicMock()
@@ -581,7 +593,7 @@ class TestRetryProjectTask:
 class TestTaskCenterCrossEndpoint:
     """任务中心跨端点集成测试。"""
 
-    @patch("app.api.routes.task_center.celery_app")
+    @patch("app.core.task_enqueue.celery_app")
     def test_list_then_retry_then_list(self, mock_celery, client):
         """列出任务 → 重试失败任务 → 再列出验证新任务。"""
         mock_celery.send_task = MagicMock()

tests/integration/test_voice_clone_api.py

@@ -32,7 +32,11 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "apps", "
 
 from app.api.routes.voice_clones import router
 from app.auth import AuthenticatedUser, get_current_user
-from app.dependencies import get_cosyvoice_service, get_voice_clone_profile_repository
+from app.dependencies import (
+    get_audio_url_signer,
+    get_cosyvoice_service,
+    get_voice_clone_profile_repository,
+)
 
 from packages.domain.entities import User
 from packages.domain.voice_clone_profile import (
@@ -226,7 +230,7 @@ def clone_repo():
 
 @pytest.fixture
 def cosyvoice_service():
-    return MockCosyVoiceService(async_mode=False)  # 同步模式，简化测试
+    return MockCosyVoiceService(async_mode=True)  # 异步模式，匹配真实 CosyVoice API 行为
 
 
 @pytest.fixture
@@ -241,6 +245,7 @@ def client(clone_repo, cosyvoice_service):
     test_app.dependency_overrides[get_current_user] = _override_current_user
     test_app.dependency_overrides[get_voice_clone_profile_repository] = lambda: clone_repo
     test_app.dependency_overrides[get_cosyvoice_service] = lambda: cosyvoice_service
+    test_app.dependency_overrides[get_audio_url_signer] = lambda: (lambda url: url)
 
     yield TestClient(test_app)
 
@@ -256,7 +261,7 @@ class TestCreateVoiceClone:
     """创建声音克隆端点测试。"""
 
     def test_create_with_source_audio(self, client, cosyvoice_service):
-        """提供源音频时创建克隆，同步模式下直接 ready。"""
+        """提供源音频时创建克隆，异步提交后状态为 processing。"""
         resp = client.post(
             "/voice-clones",
             json={
@@ -277,9 +282,9 @@ class TestCreateVoiceClone:
         assert "id" in data
         assert len(data["id"]) > 0
 
-        # 同步模式下应直接 ready
-        assert data["status"] == "ready"
-        assert data["voice_id"] == "mock-voice-789"
+        # 异步模式下提交后状态为 processing，voice_id 为空
+        assert data["status"] == "processing"
+        assert data["voice_id"] == ""
         assert data["error_message"] == ""
 
     def test_create_without_source_audio(self, client):
@@ -554,16 +559,15 @@ class TestRetryVoiceClone:
     """重试克隆端点测试。"""
 
     def test_retry_failed_clone(self, client, clone_repo, cosyvoice_service):
-        """重试失败的克隆应成功。"""
-        cosyvoice_service.async_mode = False
+        """重试失败的克隆，重新提交后期望 processing。"""
         p = _make_clone_profile("重试测试", status=VoiceCloneStatus.FAILED)
         clone_repo.create(p)
 
         resp = client.post(f"/voice-clones/{p.id}/retry")
         assert resp.status_code == 200
         data = resp.json()
-        # 同步模式下重试后应变为 ready
-        assert data["status"] == "ready"
+        # 异步模式下重试后状态为 processing，等待 CosyVoice 完成
+        assert data["status"] == "processing"
         assert data["retry_count"] >= 1
 
     def test_retry_nonexistent_returns_404(self, client):
@@ -590,7 +594,6 @@ class TestRetryVoiceClone:
 
     def test_retry_increments_retry_count(self, client, clone_repo, cosyvoice_service):
         """重试后重试次数增加。"""
-        cosyvoice_service.async_mode = False
         p = _make_clone_profile("重试计数", status=VoiceCloneStatus.FAILED)
         clone_repo.create(p)
 
@@ -680,7 +683,7 @@ class TestVoiceCloneLifecycle:
         # 4. 状态
         status_resp = client.get(f"/voice-clones/{clone_id}/status")
         assert status_resp.status_code == 200
-        assert status_resp.json()["status"] == "ready"
+        assert status_resp.json()["status"] == "processing"
 
         # 5. 删除
         del_resp = client.delete(f"/voice-clones/{clone_id}")
@@ -691,7 +694,7 @@ class TestVoiceCloneLifecycle:
         assert list_resp2.json()["total"] == 0
 
     def test_failed_retry_flow(self, client, clone_repo, cosyvoice_service):
-        """失败 → 重试 → 成功 流程。"""
+        """失败 → 重试 → processing（等待异步完成） 流程。"""
         # 创建一个失败的克隆
         p = _make_clone_profile("失败重试", status=VoiceCloneStatus.FAILED)
         clone_repo.create(p)
@@ -701,15 +704,13 @@ class TestVoiceCloneLifecycle:
         assert status_resp.json()["status"] == "failed"
 
         # 重试
-        cosyvoice_service.async_mode = False
         retry_resp = client.post(f"/voice-clones/{p.id}/retry")
         assert retry_resp.status_code == 200
-        assert retry_resp.json()["status"] == "ready"
+        assert retry_resp.json()["status"] == "processing"
 
         # 再次确认状态
         status_resp2 = client.get(f"/voice-clones/{p.id}/status")
-        assert status_resp2.json()["status"] == "ready"
-        assert status_resp2.json()["voice_id"] != ""
+        assert status_resp2.json()["status"] == "processing"
 
 
 if __name__ == "__main__":

tests/unit/test_asset_status_enum.py

@@ -0,0 +1,72 @@
+"""AssetStatus 枚举兼容性测试。
+
+验证历史脏数据（如 'uploaded'）不会导致枚举转换失败。
+"""
+
+import pytest
+
+from packages.domain.entities import AssetStatus
+
+
+class TestAssetStatusNormalValues:
+    """正常值应该正确映射。"""
+
+    def test_uploading(self):
+        assert AssetStatus("uploading") == AssetStatus.UPLOADING
+
+    def test_ready(self):
+        assert AssetStatus("ready") == AssetStatus.READY
+
+    def test_processing(self):
+        assert AssetStatus("processing") == AssetStatus.PROCESSING
+
+    def test_error(self):
+        assert AssetStatus("error") == AssetStatus.ERROR
+
+
+class TestAssetStatusHistoricalValues:
+    """历史脏数据应该正确映射到对应状态，不抛异常。"""
+
+    @pytest.mark.parametrize("value", ["uploaded", "Uploaded", "UPLOADED", " uploaded "])
+    def test_uploaded_maps_to_ready(self, value):
+        """生产环境发现的 'uploaded' 历史值应映射为 READY。"""
+        assert AssetStatus(value) == AssetStatus.READY
+
+    @pytest.mark.parametrize("value", ["success", "ok", "done", "complete"])
+    def test_other_ready_like_values_map_to_ready(self, value):
+        assert AssetStatus(value) == AssetStatus.READY
+
+    @pytest.mark.parametrize("value", ["upload", "uploading_start", "upload_start"])
+    def test_upload_like_values_map_to_uploading(self, value):
+        assert AssetStatus(value) == AssetStatus.UPLOADING
+
+    @pytest.mark.parametrize("value", ["failed", "fail", "err"])
+    def test_error_like_values_map_to_error(self, value):
+        assert AssetStatus(value) == AssetStatus.ERROR
+
+    @pytest.mark.parametrize("value", ["process", "running", "run"])
+    def test_processing_like_values_map_to_processing(self, value):
+        assert AssetStatus(value) == AssetStatus.PROCESSING
+
+
+class TestAssetStatusFallback:
+    """完全未知的值兜底为 READY，不抛500。"""
+
+    @pytest.mark.parametrize("value", ["unknown", "foo_bar", ""])
+    def test_unknown_value_falls_back_to_ready(self, value):
+        assert AssetStatus(value) == AssetStatus.READY
+
+    def test_none_value_falls_back_to_ready(self):
+        assert AssetStatus(None) == AssetStatus.READY  # type: ignore[arg-type]
+
+    def test_int_value_falls_back_to_ready(self):
+        assert AssetStatus(123) == AssetStatus.READY  # type: ignore[arg-type]
+
+
+class TestAssetStatusStrValue:
+    """枚举值仍为字符串类型，不影响序列化。"""
+
+    def test_value_unchanged(self):
+        assert AssetStatus.READY.value == "ready"
+        assert AssetStatus.ERROR.value == "error"
+        assert isinstance(AssetStatus.READY, str)

tests/unit/test_audio_url_presign.py

@@ -0,0 +1,93 @@
+"""测试音频URL预签名逻辑。
+
+验证所有 API 返回的音频 URL 都会经过 OSS 预签名（24小时有效期），
+确保私有 bucket 下的音频文件前端可正常访问。
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+class TestAudioUrlSigner:
+    """测试音频URL签名函数的行为。"""
+
+    def _make_signer(self, mock_storage):
+        """构造一个签名函数（模拟 get_audio_url_signer 的逻辑）。"""
+
+        def sign_audio_url(url: str) -> str:
+            if not url:
+                return url
+            return mock_storage.get_download_url(url, expires_seconds=86400)
+
+        return sign_audio_url
+
+    def test_empty_url_returns_empty(self):
+        """空URL直接返回，不调用签名。"""
+        mock_storage = MagicMock()
+        signer = self._make_signer(mock_storage)
+
+        result = signer("")
+        assert result == ""
+        mock_storage.get_download_url.assert_not_called()
+
+    def test_none_url_returns_none(self):
+        """None URL直接返回（有些字段可能为None）。"""
+        mock_storage = MagicMock()
+        signer = self._make_signer(mock_storage)
+
+        result = signer(None)  # type: ignore
+        assert result is None
+        mock_storage.get_download_url.assert_not_called()
+
+    def test_valid_url_gets_signed_24h(self):
+        """有效URL会调用 storage.get_download_url，有效期24小时（86400秒）。"""
+        mock_storage = MagicMock()
+        mock_storage.get_download_url.return_value = (
+            "https://bucket.oss-cn-hangzhou.aliyuncs.com/audio/test.mp3?signature=xxx"
+        )
+        signer = self._make_signer(mock_storage)
+
+        result = signer("https://bucket.oss-cn-hangzhou.aliyuncs.com/audio/test.mp3")
+
+        assert "signature=xxx" in result
+        mock_storage.get_download_url.assert_called_once_with(
+            "https://bucket.oss-cn-hangzhou.aliyuncs.com/audio/test.mp3",
+            expires_seconds=86400,
+        )
+
+    def test_storage_key_format_also_works(self):
+        """纯 storage key 格式也能正常签名（storage内部会处理）。"""
+        mock_storage = MagicMock()
+        mock_storage.get_download_url.return_value = "https://signed-url/audio.mp3?sig=xxx"
+        signer = self._make_signer(mock_storage)
+
+        result = signer("audio/test.mp3")
+
+        assert result == "https://signed-url/audio.mp3?sig=xxx"
+        mock_storage.get_download_url.assert_called_once_with(
+            "audio/test.mp3",
+            expires_seconds=86400,
+        )
+
+    def test_signer_via_dependencies_module(self):
+        """通过 dependencies 模块获取 signer，验证集成正确。"""
+        from app.core.storage import OSSStorageService
+
+        mock_svc = MagicMock(spec=OSSStorageService)
+        mock_svc.get_download_url.return_value = "https://signed/a.mp3?sig=123"
+
+        # 替换全局单例
+        with patch("app.core.storage._storage_service", mock_svc):
+            from app.dependencies import get_audio_url_signer
+
+            signer = get_audio_url_signer()
+            result = signer("test/audio.mp3")
+
+            assert result == "https://signed/a.mp3?sig=123"
+            mock_svc.get_download_url.assert_called_once_with(
+                "test/audio.mp3",
+                expires_seconds=86400,
+            )

tests/unit/test_classification_status_enum.py

@@ -0,0 +1,68 @@
+"""ClassificationStatus 枚举兼容性测试。
+
+验证历史脏数据（如 'done'）不会导致枚举转换失败。
+"""
+
+import pytest
+
+from packages.domain.entities import ClassificationStatus
+
+
+class TestClassificationStatusNormalValues:
+    """正常值应该正确映射。"""
+
+    def test_pending(self):
+        assert ClassificationStatus("pending") == ClassificationStatus.PENDING
+
+    def test_processing(self):
+        assert ClassificationStatus("processing") == ClassificationStatus.PROCESSING
+
+    def test_completed(self):
+        assert ClassificationStatus("completed") == ClassificationStatus.COMPLETED
+
+    def test_failed(self):
+        assert ClassificationStatus("failed") == ClassificationStatus.FAILED
+
+
+class TestClassificationStatusHistoricalValues:
+    """历史脏数据应该正确映射到对应状态，不抛异常。"""
+
+    @pytest.mark.parametrize("value", ["done", "Done", "DONE", " done "])
+    def test_done_maps_to_completed(self, value):
+        """生产环境发现的 'done' 历史值应映射为 COMPLETED。"""
+        assert ClassificationStatus(value) == ClassificationStatus.COMPLETED
+
+    @pytest.mark.parametrize("value", ["success", "finished", "complete"])
+    def test_other_done_like_values_map_to_completed(self, value):
+        assert ClassificationStatus(value) == ClassificationStatus.COMPLETED
+
+    @pytest.mark.parametrize("value", ["fail", "error", "err"])
+    def test_error_like_values_map_to_failed(self, value):
+        assert ClassificationStatus(value) == ClassificationStatus.FAILED
+
+    @pytest.mark.parametrize("value", ["process", "running", "run"])
+    def test_processing_like_values_map_to_processing(self, value):
+        assert ClassificationStatus(value) == ClassificationStatus.PROCESSING
+
+
+class TestClassificationStatusFallback:
+    """完全未知的值兜底为 PENDING，不抛500。"""
+
+    @pytest.mark.parametrize("value", ["unknown", "foo_bar", ""])
+    def test_unknown_value_falls_back_to_pending(self, value):
+        assert ClassificationStatus(value) == ClassificationStatus.PENDING
+
+    def test_none_value_falls_back_to_pending(self):
+        assert ClassificationStatus(None) == ClassificationStatus.PENDING  # type: ignore[arg-type]
+
+    def test_int_value_falls_back_to_pending(self):
+        assert ClassificationStatus(123) == ClassificationStatus.PENDING  # type: ignore[arg-type]
+
+
+class TestClassificationStatusStrValue:
+    """枚举值仍为字符串类型，不影响序列化。"""
+
+    def test_value_unchanged(self):
+        assert ClassificationStatus.COMPLETED.value == "completed"
+        assert ClassificationStatus.PENDING.value == "pending"
+        assert isinstance(ClassificationStatus.COMPLETED, str)

tests/unit/test_edit_plan_generation_api.py

@@ -177,6 +177,18 @@ class StubGenerationTaskRepository:
     def count_by_user(self, user_id: str) -> int:
         return len([t for t in self._store.values() if t.created_by_user_id == user_id])
 
+    def count_pending_by_user(self, user_id: str) -> int:
+        return len(
+            [
+                t
+                for t in self._store.values()
+                if t.created_by_user_id == user_id and getattr(t, "status", "") == "pending"
+            ]
+        )
+
+    def count_pending_total(self) -> int:
+        return len([t for t in self._store.values() if getattr(t, "status", "") == "pending"])
+
     def list_recent_by_user(self, user_id: str, limit: int = 5) -> list[Any]:
         items = [t for t in self._store.values() if t.created_by_user_id == user_id]
         items.sort(key=lambda t: t.created_at, reverse=True)

tests/unit/test_edit_plan_service.py

@@ -194,6 +194,12 @@ class StubGenerationTaskRepository:
         self._tasks[task.id] = task
         return task
 
+    def count_pending_by_user(self, user_id: str) -> int:
+        return 0
+
+    def count_pending_total(self) -> int:
+        return 0
+
 
 # ---------------------------------------------------------------------------
 # Service factory

tests/unit/test_generation_logging.py

@@ -0,0 +1,244 @@
+"""
+一键生成链路日志最小集 单元测试
+
+覆盖：
+- GenerationTask.append_log() 正确追加结构化日志
+- GenerationTask.append_log() 超过 200 条时截断
+- GenerationTask.get_logs() 正确解析 JSON
+- GenerationTask.get_logs() 异常 JSON 不抛异常
+- GenerationTaskResponse logs 字段 validator 解析 JSON 字符串
+- GenerationTaskResponse logs 字段 validator 处理非法输入
+- Worker 日志格式 [task_id=xxx] [阶段] 消息
+- _flush_logs 异常不抛出
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "apps" / "api"))
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "apps" / "worker"))
+
+from app.schemas.generation_task import GenerationTaskResponse
+
+from packages.domain.generation_task import GenerationTask, GenerationTaskStatus
+
+
+def _make_task(**kwargs) -> GenerationTask:
+    """创建测试用 GenerationTask。"""
+    defaults = {
+        "id": "task-001",
+        "project_id": "proj-001",
+        "asset_library_id": "lib-001",
+        "strategy_id": "one_take",
+        "voice_library_id": "",
+        "template_id": "tpl-001",
+        "asset_ids": ["asset-1", "asset-2"],
+        "title_ids": [],
+        "voice_ids": [],
+        "status": GenerationTaskStatus.PENDING,
+        "progress": 0.0,
+        "result_count": 0,
+        "error_message": "",
+        "created_by_user_id": "user-001",
+        "source_edit_plan_id": "",
+        "asset_select_mode": "all",
+        "batch_id": "",
+    }
+    defaults.update(kwargs)
+    return GenerationTask(**defaults)
+
+
+class TestAppendLog:
+    """GenerationTask.append_log() 单元测试。"""
+
+    def test_append_single_log(self):
+        task = _make_task()
+        task.append_log("接收任务", "任务开始", mode="one_take")
+
+        logs = task.get_logs()
+        assert len(logs) == 1
+        entry = logs[0]
+        assert entry["level"] == "INFO"
+        assert entry["stage"] == "接收任务"
+        assert entry["message"] == "任务开始"
+        assert entry["mode"] == "one_take"
+        assert "ts" in entry
+
+    def test_append_multiple_logs(self):
+        task = _make_task()
+        task.append_log("接收任务", "任务开始")
+        task.append_log("下载素材", "下载完成", count=3)
+        task.append_log("渲染", "渲染完成", duration=12.5)
+
+        logs = task.get_logs()
+        assert len(logs) == 3
+        assert logs[0]["stage"] == "接收任务"
+        assert logs[1]["stage"] == "下载素材"
+        assert logs[1]["count"] == 3
+        assert logs[2]["stage"] == "渲染"
+        assert logs[2]["duration"] == 12.5
+
+    def test_append_log_with_error_level(self):
+        task = _make_task()
+        task.append_log("任务失败", "OSS上传失败", level="ERROR", error_type="RuntimeError")
+
+        logs = task.get_logs()
+        assert len(logs) == 1
+        assert logs[0]["level"] == "ERROR"
+        assert logs[0]["error_type"] == "RuntimeError"
+
+    def test_append_log_truncates_at_200(self):
+        task = _make_task()
+        for i in range(250):
+            task.append_log("阶段", f"消息{i}")
+
+        logs = task.get_logs()
+        assert len(logs) == 200
+        # 保留最后 200 条
+        assert logs[0]["message"] == "消息50"
+        assert logs[-1]["message"] == "消息249"
+
+    def test_append_log_handles_corrupted_json(self):
+        task = _make_task(logs="not-valid-json")
+        task.append_log("接收任务", "任务开始")
+
+        logs = task.get_logs()
+        assert len(logs) == 1
+        assert logs[0]["message"] == "任务开始"
+
+    def test_append_log_handles_empty_string(self):
+        task = _make_task(logs="")
+        task.append_log("接收任务", "任务开始")
+
+        logs = task.get_logs()
+        assert len(logs) == 1
+
+
+class TestGetLogs:
+    """GenerationTask.get_logs() 单元测试。"""
+
+    def test_get_logs_empty(self):
+        task = _make_task()
+        assert task.get_logs() == []
+
+    def test_get_logs_parses_json(self):
+        entries = [{"ts": "2026-01-01T00:00:00Z", "level": "INFO", "stage": "test", "message": "hello"}]
+        task = _make_task(logs=json.dumps(entries, ensure_ascii=False))
+        logs = task.get_logs()
+        assert len(logs) == 1
+        assert logs[0]["message"] == "hello"
+
+    def test_get_logs_handles_invalid_json(self):
+        task = _make_task(logs="{broken")
+        assert task.get_logs() == []
+
+    def test_get_logs_handles_none(self):
+        task = _make_task(logs=None)
+        assert task.get_logs() == []
+
+
+class TestGenerationTaskResponseLogs:
+    """GenerationTaskResponse logs 字段 validator 测试。"""
+
+    def _make_response_data(self, logs_value) -> dict:
+        return {
+            "id": "task-001",
+            "project_id": "proj-001",
+            "asset_library_id": "lib-001",
+            "strategy_id": "one_take",
+            "voice_library_id": "",
+            "template_id": "",
+            "asset_ids": [],
+            "title_ids": [],
+            "voice_ids": [],
+            "source_edit_plan_id": "",
+            "asset_select_mode": "all",
+            "batch_id": "",
+            "status": "completed",
+            "progress": 1.0,
+            "result_count": 1,
+            "error_message": "",
+            "logs": logs_value,
+        }
+
+    def test_logs_json_string_parsed(self):
+        entries = [{"ts": "2026-01-01T00:00:00Z", "level": "INFO", "stage": "test", "message": "ok"}]
+        data = self._make_response_data(json.dumps(entries, ensure_ascii=False))
+        resp = GenerationTaskResponse(**data)
+        assert isinstance(resp.logs, list)
+        assert len(resp.logs) == 1
+        assert resp.logs[0]["message"] == "ok"
+
+    def test_logs_list_passthrough(self):
+        entries = [{"ts": "2026-01-01T00:00:00Z", "level": "INFO", "stage": "test", "message": "ok"}]
+        data = self._make_response_data(entries)
+        resp = GenerationTaskResponse(**data)
+        assert resp.logs == entries
+
+    def test_logs_invalid_json_returns_empty(self):
+        data = self._make_response_data("{broken")
+        resp = GenerationTaskResponse(**data)
+        assert resp.logs == []
+
+    def test_logs_empty_string_returns_empty(self):
+        data = self._make_response_data("")
+        resp = GenerationTaskResponse(**data)
+        assert resp.logs == []
+
+    def test_logs_default_empty(self):
+        data = self._make_response_data("[]")
+        resp = GenerationTaskResponse(**data)
+        assert resp.logs == []
+
+
+class TestWorkerLogFormat:
+    """Worker 日志格式 [task_id=xxx] [阶段] 消息 测试。"""
+
+    def test_log_format_pattern(self):
+        """验证日志格式匹配 [task_id=xxx] [阶段] 消息。"""
+        import re
+
+        task_id = "abc123"
+        stage = "下载素材"
+        message = "完成: 成功=3个, 耗时=1.5s"
+        formatted = f"[task_id={task_id}] [{stage}] {message}"
+
+        pattern = r"^\[task_id=[\w-]+\] \[.+\] .+$"
+        assert re.match(pattern, formatted)
+
+    def test_log_entries_contain_required_fields(self):
+        """验证 append_log 生成的条目包含所有必需字段。"""
+        task = _make_task()
+        task.append_log("OSS上传", "上传成功", file_size=1024000, duration=2.5)
+
+        logs = task.get_logs()
+        entry = logs[0]
+        assert "ts" in entry
+        assert "level" in entry
+        assert "stage" in entry
+        assert "message" in entry
+        assert entry["file_size"] == 1024000
+        assert entry["duration"] == 2.5
+
+
+class TestFlushLogs:
+    """_flush_logs 异常安全测试。"""
+
+    def test_flush_logs_exception_not_raised(self):
+        """_flush_logs 在 DB 异常时不应抛出。"""
+        # 模拟 worker 环境
+        sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "apps" / "worker"))
+
+        from worker_app.tasks.generation import _flush_logs
+
+        task = _make_task()
+        task.append_log("测试", "消息")
+
+        # Mock SessionLocal 抛异常
+        with patch("worker_app.tasks.generation.SessionLocal", side_effect=RuntimeError("DB error")):
+            # 不应抛出
+            _flush_logs("task-001", task)

tests/unit/test_generation_presigned_url.py

@@ -58,6 +58,12 @@ class StubGenerationTaskRepository:
     def get(self, task_id):
         return self._tasks.get(task_id)
 
+    def count_pending_by_user(self, user_id):
+        return 0
+
+    def count_pending_total(self):
+        return 0
+
 
 class StubGeneratedVideoRepository:
     def __init__(self, videos=None):

tests/unit/test_oneclick_gen_p0_fixes.py

@@ -132,10 +132,8 @@ class TestDownloadLibraryAssets:
         session.query.return_value = query
         filter_result = MagicMock()
         query.filter.return_value = filter_result
-        in_filter = MagicMock()
-        filter_result.filter.return_value = in_filter
         id_filter = MagicMock()
-        in_filter.filter.return_value = id_filter
+        filter_result.filter.return_value = id_filter
         assets = [self._make_asset("a1", "video/a1.mp4")]
         id_filter.order_by.return_value.all.return_value = assets
 

tests/unit/test_p02_oss_credential_validation.py

@@ -0,0 +1,158 @@
+"""P0-2 修复：OSS 凭证验证 + 启动诊断。
+
+验证：
+1. 非开发环境 OSS_ACCESS_KEY_ID/SECRET 为空时启动失败
+2. 开发环境允许空凭证
+3. diagnose() 方法正确输出配置状态
+"""
+
+import logging
+import os
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+def _fresh_settings(env: str):
+    """清除 config 模块缓存，以指定 APP_ENV 重新导入 Settings。
+
+    为非开发环境预设 OSS 环境变量，确保模块级 get_settings() 能成功完成导入。
+    测试方法内可根据需要清除这些变量来测试验证器。
+    """
+    for mod_name in [m for m in list(sys.modules) if "app.config" in m]:
+        del sys.modules[mod_name]
+    os.environ["APP_ENV"] = env
+    # 非开发环境下，为模块级导入提供有效凭证（避免导入时验证失败）
+    if env != "development":
+        os.environ.setdefault("OSS_ACCESS_KEY_ID", "test-key-for-import")
+        os.environ.setdefault("OSS_ACCESS_KEY_SECRET", "test-secret-for-import")
+    # 重置单例，让测试方法自行控制实例化
+    from apps.api.app import config as _cfg
+    from apps.api.app.config import Settings
+
+    _cfg._settings = None
+    return Settings
+
+
+class TestOSSCredentialValidation:
+    """测试 OSS 凭证验证器（直接调用验证器类方法）。"""
+
+    def test_empty_oss_key_id_rejected_in_staging(self):
+        """非开发环境 OSS_ACCESS_KEY_ID 为空应报错。"""
+        Settings = _fresh_settings("staging")
+        with pytest.raises(Exception, match="OSS_ACCESS_KEY_ID"):
+            Settings.validate_oss_access_key_id("")
+
+    def test_empty_oss_key_secret_rejected_in_staging(self):
+        """非开发环境 OSS_ACCESS_KEY_SECRET 为空应报错。"""
+        Settings = _fresh_settings("staging")
+        with pytest.raises(Exception, match="OSS_ACCESS_KEY_SECRET"):
+            Settings.validate_oss_access_key_secret("")
+
+    def test_empty_oss_credentials_allowed_in_development(self):
+        """开发环境允许空 OSS 凭证。"""
+        Settings = _fresh_settings("development")
+        assert Settings.validate_oss_access_key_id("") == ""
+        assert Settings.validate_oss_access_key_secret("") == ""
+
+    def test_valid_credentials_pass_validation(self):
+        """有效凭证应通过验证。"""
+        Settings = _fresh_settings("staging")
+        assert Settings.validate_oss_access_key_id("test-key-id") == "test-key-id"
+        assert Settings.validate_oss_access_key_secret("test-key-secret") == "test-key-secret"
+
+    def test_valid_credentials_instantiation_succeeds(self):
+        """有效凭证应能成功创建 Settings 实例。"""
+        os.environ.pop("OSS_ACCESS_KEY_ID", None)
+        os.environ.pop("OSS_ACCESS_KEY_SECRET", None)
+        Settings = _fresh_settings("staging")
+        os.environ["OSS_ACCESS_KEY_ID"] = "test-key-id"
+        os.environ["OSS_ACCESS_KEY_SECRET"] = "test-key-secret"
+        s = Settings(_env_file=None)
+        assert s.OSS_ACCESS_KEY_ID == "test-key-id"
+        assert s.OSS_ACCESS_KEY_SECRET == "test-key-secret"
+
+
+class TestOSSDiagnose:
+    """测试 OSSStorageService.diagnose() 方法。"""
+
+    @patch("apps.api.app.core.storage.oss2", None)
+    @patch("apps.api.app.core.storage.get_settings")
+    def test_diagnose_logs_error_when_bucket_none(self, mock_settings, caplog):
+        """bucket=None 时 diagnose 应输出 ERROR 日志。"""
+        from apps.api.app.core.storage import OSSStorageService
+
+        mock_settings.return_value.OSS_BUCKET_NAME = "test-bucket"
+        mock_settings.return_value.OSS_ENDPOINT = "oss-cn-test.com"
+        mock_settings.return_value.OSS_ACCESS_KEY_ID = ""
+        mock_settings.return_value.OSS_ACCESS_KEY_SECRET = ""
+
+        service = OSSStorageService()
+        assert service.bucket is None
+
+        with caplog.at_level(logging.ERROR, logger="apps.api.app.core.storage"):
+            service.diagnose()
+
+        assert any("❌" in record.message for record in caplog.records)
+
+    @patch("apps.api.app.core.storage.oss2")
+    @patch("apps.api.app.core.storage.get_settings")
+    def test_diagnose_logs_success_when_bucket_configured(self, mock_settings, mock_oss2, caplog):
+        """bucket 已配置时 diagnose 应输出成功日志。"""
+        from apps.api.app.core.storage import OSSStorageService
+
+        mock_settings.return_value.OSS_BUCKET_NAME = "test-bucket"
+        mock_settings.return_value.OSS_ENDPOINT = "oss-cn-test.com"
+        mock_settings.return_value.OSS_ACCESS_KEY_ID = "test-key-id"
+        mock_settings.return_value.OSS_ACCESS_KEY_SECRET = "test-key-secret"
+        mock_oss2.Bucket.return_value = MagicMock()
+
+        service = OSSStorageService()
+        assert service.bucket is not None
+
+        with caplog.at_level(logging.INFO, logger="apps.api.app.core.storage"):
+            service.diagnose()
+
+        assert any("OSS诊断" in record.message for record in caplog.records)
+
+
+class TestOSSHTTPSEndpoint:
+    """测试 P0-2 真正根因：sign_url 必须返回 HTTPS URL。"""
+
+    @patch("apps.api.app.core.storage.oss2")
+    @patch("apps.api.app.core.storage.get_settings")
+    def test_endpoint_without_scheme_gets_https_prefix(self, mock_settings, mock_oss2):
+        """endpoint 无 scheme 时应自动加 https://，确保 sign_url 生成 HTTPS URL。"""
+        from apps.api.app.core.storage import OSSStorageService
+
+        mock_settings.return_value.OSS_BUCKET_NAME = "test-bucket"
+        mock_settings.return_value.OSS_ENDPOINT = "oss-cn-hangzhou.aliyuncs.com"
+        mock_settings.return_value.OSS_ACCESS_KEY_ID = "test-key-id"
+        mock_settings.return_value.OSS_ACCESS_KEY_SECRET = "test-key-secret"
+        mock_oss2.Bucket.return_value = MagicMock()
+
+        OSSStorageService()
+
+        # 验证传给 oss2.Bucket 的 endpoint 带了 https://
+        call_args = mock_oss2.Bucket.call_args
+        endpoint_passed = call_args[0][1]  # 第二个位置参数
+        assert endpoint_passed == "https://oss-cn-hangzhou.aliyuncs.com"
+
+    @patch("apps.api.app.core.storage.oss2")
+    @patch("apps.api.app.core.storage.get_settings")
+    def test_endpoint_with_existing_https_not_doubled(self, mock_settings, mock_oss2):
+        """endpoint 已有 https:// 时不应重复添加。"""
+        from apps.api.app.core.storage import OSSStorageService
+
+        mock_settings.return_value.OSS_BUCKET_NAME = "test-bucket"
+        mock_settings.return_value.OSS_ENDPOINT = "https://oss-cn-hangzhou.aliyuncs.com"
+        mock_settings.return_value.OSS_ACCESS_KEY_ID = "test-key-id"
+        mock_settings.return_value.OSS_ACCESS_KEY_SECRET = "test-key-secret"
+        mock_oss2.Bucket.return_value = MagicMock()
+
+        OSSStorageService()
+
+        call_args = mock_oss2.Bucket.call_args
+        endpoint_passed = call_args[0][1]
+        assert endpoint_passed == "https://oss-cn-hangzhou.aliyuncs.com"

tests/unit/test_p02_p03_fixes.py

@@ -15,7 +15,6 @@ from video_processing.ffmpeg_utils import build_xfade_filter_chain
 # ── P0-3: build_xfade_filter_chain 安全钳制 ──────────────────────────────────
 
 
-
 class TestBuildXfadeFilterChainSafetyClamp:
     """验证 xfade 滤镜链的安全钳制逻辑，防止 exit 234。"""
 
@@ -124,9 +123,7 @@ class TestBuildXfadeFilterChainSafetyClamp:
             durations_found.append(float(m.group(1)))
 
         # 第一个 xfade: td 必须 ≤ 0.3 (第二个输入 clip_durations[1]=0.3)
-        assert durations_found[0] <= 0.3 + 0.001, (
-            f"第一个 xfade td={durations_found[0]} 超过 clip_durations[1]=0.3"
-        )
+        assert durations_found[0] <= 0.3 + 0.001, f"第一个 xfade td={durations_found[0]} 超过 clip_durations[1]=0.3"
         # 第二个 xfade: td 可以 = 0.5 (clip_durations[2]=5.0)
         assert durations_found[1] <= 0.5 + 0.001
         assert dur > 0
@@ -173,9 +170,9 @@ class TestBuildXfadeFilterChainSafetyClamp:
                 assert dur_val >= 0.001  # 至少 1ms
                 # P1 修复验证: td 不能超过第二个输入片段时长
                 second_input_idx = xfade_idx + 1
-                assert dur_val <= durations[second_input_idx] + 0.001, (
-                    f"td={dur_val} > clip_durations[{second_input_idx}]={durations[second_input_idx]}"
-                )
+                assert (
+                    dur_val <= durations[second_input_idx] + 0.001
+                ), f"td={dur_val} > clip_durations[{second_input_idx}]={durations[second_input_idx]}"
                 xfade_idx += 1
 
 

tests/unit/test_p02_worker_oss_fix.py

@@ -0,0 +1,281 @@
+"""P0-2 深度修复：Worker 端 OSS 工具函数测试.
+
+测试：
+1. oss_bucket() endpoint 自动补 https:// 前缀
+2. get_signed_download_url() 生成预签名 URL
+3. upload_to_oss() 返回 HTTPS URL
+"""
+
+from __future__ import annotations
+
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# ── oss_bucket endpoint scheme 修复 ──────────────────────────────────────────
+
+
+class TestOSSBucketEndpointScheme:
+    """测试 oss_bucket() 自动为 endpoint 补 https:// 前缀."""
+
+    def test_endpoint_without_scheme_adds_https(self):
+        """endpoint 不带 scheme 时，自动补 https://."""
+        from video_processing.oss_helpers import oss_bucket
+
+        mock_bucket_instance = MagicMock()
+        with (
+            patch.dict(
+                os.environ,
+                {
+                    "OSS_ACCESS_KEY_ID": "test-key",
+                    "OSS_ACCESS_KEY_SECRET": "test-secret",
+                    "OSS_ENDPOINT": "oss-cn-hangzhou.aliyuncs.com",
+                    "OSS_BUCKET_NAME": "test-bucket",
+                },
+            ),
+            patch("video_processing.oss_helpers.oss2.Auth") as mock_auth,
+            patch("video_processing.oss_helpers.oss2.Bucket", return_value=mock_bucket_instance) as mock_bucket_cls,
+        ):
+            # 清除缓存，确保重新创建
+            import video_processing.oss_helpers as oss_mod
+
+            bucket = oss_bucket()
+
+            assert bucket is mock_bucket_instance
+            # 验证 endpoint 传的是带 https:// 的
+            call_args = mock_bucket_cls.call_args
+            endpoint_arg = call_args[0][1]  # 第 2 个位置参数是 endpoint
+            assert endpoint_arg.startswith("https://"), f"endpoint 应该带 https:// 前缀，实际为: {endpoint_arg}"
+            assert "oss-cn-hangzhou.aliyuncs.com" in endpoint_arg
+
+    def test_endpoint_with_https_keeps_as_is(self):
+        """endpoint 已有 https:// 时，不重复添加."""
+        from video_processing.oss_helpers import oss_bucket
+
+        mock_bucket_instance = MagicMock()
+        with (
+            patch.dict(
+                os.environ,
+                {
+                    "OSS_ACCESS_KEY_ID": "test-key",
+                    "OSS_ACCESS_KEY_SECRET": "test-secret",
+                    "OSS_ENDPOINT": "https://oss-cn-hangzhou.aliyuncs.com",
+                    "OSS_BUCKET_NAME": "test-bucket",
+                },
+            ),
+            patch("video_processing.oss_helpers.oss2.Auth"),
+            patch("video_processing.oss_helpers.oss2.Bucket", return_value=mock_bucket_instance) as mock_bucket_cls,
+        ):
+            import video_processing.oss_helpers as oss_mod
+
+            bucket = oss_bucket()
+
+            call_args = mock_bucket_cls.call_args
+            endpoint_arg = call_args[0][1]
+            # 不应该出现 https://https:// 这种双重前缀
+            assert endpoint_arg.count("https://") == 1
+            assert endpoint_arg == "https://oss-cn-hangzhou.aliyuncs.com"
+
+    def test_endpoint_with_http_keeps_as_is(self):
+        """endpoint 已有 http:// 时，不修改（保留用户选择）."""
+        from video_processing.oss_helpers import oss_bucket
+
+        mock_bucket_instance = MagicMock()
+        with (
+            patch.dict(
+                os.environ,
+                {
+                    "OSS_ACCESS_KEY_ID": "test-key",
+                    "OSS_ACCESS_KEY_SECRET": "test-secret",
+                    "OSS_ENDPOINT": "http://oss-cn-hangzhou.aliyuncs.com",
+                    "OSS_BUCKET_NAME": "test-bucket",
+                },
+            ),
+            patch("video_processing.oss_helpers.oss2.Auth"),
+            patch("video_processing.oss_helpers.oss2.Bucket", return_value=mock_bucket_instance) as mock_bucket_cls,
+        ):
+            import video_processing.oss_helpers as oss_mod
+
+            bucket = oss_bucket()
+
+            call_args = mock_bucket_cls.call_args
+            endpoint_arg = call_args[0][1]
+            assert endpoint_arg == "http://oss-cn-hangzhou.aliyuncs.com"
+
+    def test_missing_credentials_returns_none(self):
+        """凭证缺失时返回 None."""
+        from video_processing.oss_helpers import oss_bucket
+
+        with patch.dict(
+            os.environ,
+            {
+                "OSS_ACCESS_KEY_ID": "",
+                "OSS_ACCESS_KEY_SECRET": "",
+                "OSS_ENDPOINT": "oss-cn-hangzhou.aliyuncs.com",
+                "OSS_BUCKET_NAME": "test-bucket",
+            },
+            clear=True,
+        ):
+            import video_processing.oss_helpers as oss_mod
+
+            bucket = oss_bucket()
+            assert bucket is None
+
+
+# ── get_signed_download_url ──────────────────────────────────────────────────
+
+
+class TestGetSignedDownloadUrl:
+    """测试 get_signed_download_url() 预签名 URL 生成."""
+
+    def test_returns_signed_url_with_storage_key(self):
+        """传入 storage key 时，调用 sign_url 并返回结果."""
+        from video_processing.oss_helpers import get_signed_download_url
+
+        mock_bucket = MagicMock()
+        mock_bucket.sign_url.return_value = "https://test-bucket.oss-cn-hangzhou.aliyuncs.com/generated/test.mp4?OSSAccessKeyId=xxx&Expires=xxx&Signature=xxx"
+
+        with (
+            patch.dict(
+                os.environ,
+                {
+                    "OSS_ACCESS_KEY_ID": "test-key",
+                    "OSS_ACCESS_KEY_SECRET": "test-secret",
+                    "OSS_ENDPOINT": "oss-cn-hangzhou.aliyuncs.com",
+                    "OSS_BUCKET_NAME": "test-bucket",
+                },
+            ),
+            patch("video_processing.oss_helpers.oss2.Auth"),
+            patch("video_processing.oss_helpers.oss2.Bucket", return_value=mock_bucket),
+        ):
+            result = get_signed_download_url("generated/test.mp4", expires_seconds=3600)
+
+            assert result is not None
+            assert "Signature=" in result
+            mock_bucket.sign_url.assert_called_once_with("GET", "generated/test.mp4", 3600)
+
+    def test_normalizes_full_url_to_storage_key(self):
+        """传入完整 URL 时，提取 storage key 再生成签名."""
+        from video_processing.oss_helpers import get_signed_download_url
+
+        mock_bucket = MagicMock()
+        mock_bucket.sign_url.return_value = (
+            "https://test-bucket.oss-cn-hangzhou.aliyuncs.com/generated/test.mp4?sign=xxx"
+        )
+
+        with (
+            patch.dict(
+                os.environ,
+                {
+                    "OSS_ACCESS_KEY_ID": "test-key",
+                    "OSS_ACCESS_KEY_SECRET": "test-secret",
+                    "OSS_ENDPOINT": "oss-cn-hangzhou.aliyuncs.com",
+                    "OSS_BUCKET_NAME": "test-bucket",
+                },
+            ),
+            patch("video_processing.oss_helpers.oss2.Auth"),
+            patch("video_processing.oss_helpers.oss2.Bucket", return_value=mock_bucket),
+        ):
+            result = get_signed_download_url("https://test-bucket.oss-cn-hangzhou.aliyuncs.com/generated/test.mp4")
+
+            mock_bucket.sign_url.assert_called_once()
+            # 验证传给 sign_url 的是纯 storage key，不是完整 URL
+            call_key = mock_bucket.sign_url.call_args[0][1]
+            assert not call_key.startswith("http")
+            assert call_key == "generated/test.mp4"
+
+    def test_returns_none_when_bucket_none(self):
+        """bucket 为 None 时返回 None（不抛异常）."""
+        from video_processing.oss_helpers import get_signed_download_url
+
+        with patch.dict(os.environ, {}, clear=True):
+            result = get_signed_download_url("generated/test.mp4")
+            assert result is None
+
+    def test_sign_url_exception_returns_none(self):
+        """sign_url 抛异常时，返回 None（不向上抛出）."""
+        from video_processing.oss_helpers import get_signed_download_url
+
+        mock_bucket = MagicMock()
+        mock_bucket.sign_url.side_effect = Exception("sign failed")
+
+        with (
+            patch.dict(
+                os.environ,
+                {
+                    "OSS_ACCESS_KEY_ID": "test-key",
+                    "OSS_ACCESS_KEY_SECRET": "test-secret",
+                    "OSS_ENDPOINT": "oss-cn-hangzhou.aliyuncs.com",
+                    "OSS_BUCKET_NAME": "test-bucket",
+                },
+            ),
+            patch("video_processing.oss_helpers.oss2.Auth"),
+            patch("video_processing.oss_helpers.oss2.Bucket", return_value=mock_bucket),
+        ):
+            result = get_signed_download_url("generated/test.mp4")
+            assert result is None
+
+
+# ── upload_to_oss 返回 HTTPS URL ─────────────────────────────────────────────
+
+
+class TestUploadToOSSReturnsHTTPS:
+    """测试 upload_to_oss() 返回的 URL 始终是 HTTPS."""
+
+    def test_endpoint_without_scheme_returns_https_url(self):
+        """endpoint 不带 scheme 时，返回 HTTPS URL."""
+        from video_processing.oss_helpers import upload_to_oss
+
+        mock_bucket = MagicMock()
+        mock_bucket.put_object_from_file = MagicMock()
+
+        from pathlib import Path
+
+        with (
+            patch.dict(
+                os.environ,
+                {
+                    "OSS_ACCESS_KEY_ID": "test-key",
+                    "OSS_ACCESS_KEY_SECRET": "test-secret",
+                    "OSS_ENDPOINT": "oss-cn-hangzhou.aliyuncs.com",
+                    "OSS_BUCKET_NAME": "test-bucket",
+                },
+            ),
+            patch("video_processing.oss_helpers.oss2.Auth"),
+            patch("video_processing.oss_helpers.oss2.Bucket", return_value=mock_bucket),
+        ):
+            result = upload_to_oss(Path("/tmp/test.mp4"), "generated/test.mp4")
+
+            assert result is not None
+            assert result.startswith("https://")
+            assert "test-bucket.oss-cn-hangzhou.aliyuncs.com/generated/test.mp4" in result
+
+    def test_endpoint_with_https_returns_clean_url(self):
+        """endpoint 带 https:// 时，URL 里不会有双重 https."""
+        from video_processing.oss_helpers import upload_to_oss
+
+        mock_bucket = MagicMock()
+        mock_bucket.put_object_from_file = MagicMock()
+
+        from pathlib import Path
+
+        with (
+            patch.dict(
+                os.environ,
+                {
+                    "OSS_ACCESS_KEY_ID": "test-key",
+                    "OSS_ACCESS_KEY_SECRET": "test-secret",
+                    "OSS_ENDPOINT": "https://oss-cn-hangzhou.aliyuncs.com",
+                    "OSS_BUCKET_NAME": "test-bucket",
+                },
+            ),
+            patch("video_processing.oss_helpers.oss2.Auth"),
+            patch("video_processing.oss_helpers.oss2.Bucket", return_value=mock_bucket),
+        ):
+            result = upload_to_oss(Path("/tmp/test.mp4"), "generated/test.mp4")
+
+            assert result is not None
+            assert result.startswith("https://")
+            # 不应该出现 https://https://
+            assert result.count("https://") == 1

tests/unit/test_preset_voices.py

@@ -64,7 +64,7 @@ class TestPresetVoice:
     def test_preset_voice_to_dict(self) -> None:
         """序列化。"""
         voice = PresetVoice(
-            voice_id="longxiaochun",
+            voice_id="longxiaochun_v3",
             name="龙小淳",
             description="温柔女声",
             gender="female",
@@ -73,7 +73,7 @@ class TestPresetVoice:
 
         result = voice.to_dict()
 
-        assert result["voice_id"] == "longxiaochun"
+        assert result["voice_id"] == "longxiaochun_v3"
         assert result["name"] == "龙小淳"
         assert result["description"] == "温柔女声"
         assert result["gender"] == "female"
@@ -127,14 +127,14 @@ class TestPresetVoicesConfig:
     def test_cosyvoice_voice_ids(self) -> None:
         """音色 ID 应为 CosyVoice 真实可用的音色名。"""
         expected_ids = {
-            "longxiaochun",
-            "longxiaoxia",
-            "longxiaochen",
-            "longyue",
-            "longshu",
-            "longjing",
-            "longbo",
-            "longtian",
+            "longxiaochun_v3",
+            "longxiaoxia_v3",
+            "longxiaochen_v3",
+            "longyue_v3",
+            "longshu_v3",
+            "longjing_v3",
+            "longbo_v3",
+            "longtian_v3",
         }
         actual_ids = {v.voice_id for v in PRESET_VOICES}
         assert actual_ids == expected_ids
@@ -164,10 +164,10 @@ class TestPresetVoiceHelpers:
 
     def test_get_preset_voice_by_id_found(self) -> None:
         """按 ID 查找存在的音色。"""
-        voice = get_preset_voice_by_id("longxiaochun")
+        voice = get_preset_voice_by_id("longxiaochun_v3")
         assert voice is not None
         assert voice.name == "龙小淳"
-        assert voice.voice_id == "longxiaochun"
+        assert voice.voice_id == "longxiaochun_v3"
 
     def test_get_preset_voice_by_id_not_found(self) -> None:
         """按 ID 查找不存在的音色。"""
@@ -176,9 +176,9 @@ class TestPresetVoiceHelpers:
 
     def test_is_preset_voice_true(self) -> None:
         """判断预置音色返回 True。"""
-        assert is_preset_voice("longxiaochun") is True
-        assert is_preset_voice("longxiaoxia") is True
-        assert is_preset_voice("longbo") is True
+        assert is_preset_voice("longxiaochun_v3") is True
+        assert is_preset_voice("longxiaoxia_v3") is True
+        assert is_preset_voice("longbo_v3") is True
 
     def test_is_preset_voice_false(self) -> None:
         """判断非预置音色返回 False。"""

tests/unit/test_render_adapter.py

@@ -0,0 +1,424 @@
+"""RenderAdapter 单元测试 — Phase 2.
+
+测试适配层的计划加载、素材下载、引擎调用、结果上传等逻辑。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+from video_processing.render_adapter import RenderAdapter, RenderAdapterResult
+
+# ── Fixtures ──────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class FakeClip:
+    """模拟 EditPlanClip。"""
+
+    id: str
+    plan_id: str = "plan_001"
+    clip_type: str = "main"
+    order: int = 0
+    asset_id: str = ""
+    text_content: str = ""
+    start_time: float = 0.0
+    duration: float = 0.0
+    transition_effect: str = "cut"
+    status: str = "ready"
+    config: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class FakePlan:
+    """模拟 EditPlan。"""
+
+    id: str = "plan_001"
+    name: str = "测试计划"
+    status: str = "editing"
+    config: dict[str, Any] = field(default_factory=dict)
+
+
+def _make_clip(
+    clip_id: str,
+    clip_type: str = "main",
+    order: int = 0,
+    asset_id: str | None = None,
+    duration: float = 5.0,
+    status: str = "ready",
+    transition_effect: str = "cut",
+    config: dict[str, Any] | None = None,
+) -> FakeClip:
+    # asset_id 为 None 时生成默认值，为空字符串时保留空串
+    if asset_id is None:
+        asset_id = f"asset_{clip_id}.mp4"
+    return FakeClip(
+        id=clip_id,
+        clip_type=clip_type,
+        order=order,
+        asset_id=asset_id,
+        duration=duration,
+        status=status,
+        transition_effect=transition_effect,
+        config=config or {},
+    )
+
+
+def _make_adapter(
+    plan: FakePlan | None = None,
+    clips: list[FakeClip] | None = None,
+) -> tuple[RenderAdapter, MagicMock, MagicMock]:
+    """创建测试用的 RenderAdapter 及 mock repo。
+
+    Returns:
+        (adapter, mock_plan_repo, mock_clip_repo)
+    """
+    mock_db = MagicMock()
+    adapter = RenderAdapter(mock_db)
+
+    # 替换内部 repo
+    mock_plan_repo = MagicMock()
+    mock_clip_repo = MagicMock()
+    adapter._plan_repo = mock_plan_repo
+    adapter._clip_repo = mock_clip_repo
+
+    # 设置默认返回
+    if plan is not None:
+        mock_plan_repo.get.return_value = plan
+    if clips is not None:
+        mock_clip_repo.list_by_plan.return_value = clips
+
+    return adapter, mock_plan_repo, mock_clip_repo
+
+
+# ── validate_plan 测试 ───────────────────────────────────────────────────────
+
+
+class TestValidatePlan:
+    def test_plan_not_found(self):
+        """计划不存在时校验失败。"""
+        adapter, mock_plan_repo, _ = _make_adapter(plan=None)
+        mock_plan_repo.get.return_value = None
+
+        valid, errors, warnings, ready_count, total_count = adapter.validate_plan("plan_001")
+
+        assert not valid
+        assert len(errors) == 1
+        assert "不存在" in errors[0]
+        assert ready_count == 0
+        assert total_count == 0
+
+    def test_no_clips(self):
+        """没有任何片段时校验失败。"""
+        plan = FakePlan(id="plan_001", status="editing")
+        adapter, _, mock_clip_repo = _make_adapter(plan=plan, clips=[])
+
+        valid, errors, warnings, ready_count, total_count = adapter.validate_plan("plan_001")
+
+        assert not valid
+        assert any("没有任何片段" in e for e in errors)
+
+    def test_no_ready_clips(self):
+        """没有 ready 片段时校验失败。"""
+        plan = FakePlan(id="plan_001", status="editing")
+        clips = [
+            _make_clip("c1", status="pending"),
+            _make_clip("c2", status="pending"),
+        ]
+        adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+        valid, errors, warnings, ready_count, total_count = adapter.validate_plan("plan_001")
+
+        assert not valid
+        assert any("没有就绪" in e for e in errors)
+        assert ready_count == 0
+        assert total_count == 2
+
+    def test_ready_clip_no_asset(self):
+        """ready 片段没有 asset_id 时报错。"""
+        plan = FakePlan(id="plan_001", status="editing")
+        clips = [
+            _make_clip("c1", asset_id=""),
+        ]
+        adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+        valid, errors, warnings, ready_count, total_count = adapter.validate_plan("plan_001")
+
+        assert not valid
+        assert any("没有分配素材" in e for e in errors)
+
+    def test_valid_plan(self):
+        """正常计划校验通过。"""
+        plan = FakePlan(id="plan_001", status="editing")
+        clips = [
+            _make_clip("c1", order=0, duration=3.0),
+            _make_clip("c2", order=1, duration=4.0),
+        ]
+        adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+        valid, errors, warnings, ready_count, total_count = adapter.validate_plan("plan_001")
+
+        assert valid
+        assert len(errors) == 0
+        assert ready_count == 2
+        assert total_count == 2
+
+    def test_wrong_status(self):
+        """计划状态不正确时报错。"""
+        plan = FakePlan(id="plan_001", status="draft")
+        clips = [_make_clip("c1")]
+        adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+        valid, errors, _, _, _ = adapter.validate_plan("plan_001")
+
+        assert not valid
+        assert any("状态不正确" in e for e in errors)
+
+    def test_mixed_status_with_warnings(self):
+        """混合状态时有 pending/failed 警告。"""
+        plan = FakePlan(id="plan_001", status="editing")
+        clips = [
+            _make_clip("c1", order=0, status="ready"),
+            _make_clip("c2", order=1, status="pending"),
+            _make_clip("c3", order=2, status="failed"),
+        ]
+        adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+        valid, errors, warnings, ready_count, total_count = adapter.validate_plan("plan_001")
+
+        assert valid
+        assert any("pending" in w for w in warnings)
+        assert any("failed" in w for w in warnings)
+        assert ready_count == 1
+        assert total_count == 3
+
+
+# ── render_plan 测试 ─────────────────────────────────────────────────────────
+
+
+class TestRenderPlan:
+    def test_plan_not_found(self):
+        """计划不存在时返回失败。"""
+        adapter, mock_plan_repo, _ = _make_adapter(plan=None)
+        mock_plan_repo.get.return_value = None
+
+        result = adapter.render_plan("plan_001")
+
+        assert not result.success
+        assert "不存在" in result.error_message
+
+    def test_no_ready_clips(self):
+        """没有 ready 片段时返回失败。"""
+        plan = FakePlan(id="plan_001", status="editing")
+        clips = [_make_clip("c1", status="pending")]
+        adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+        result = adapter.render_plan("plan_001")
+
+        assert not result.success
+        assert "没有可渲染" in result.error_message
+        assert result.clip_count == 0
+
+    @patch("video_processing.render_adapter.download_asset")
+    def test_all_assets_download_fail(self, mock_download):
+        """所有素材下载失败时返回失败。"""
+        mock_download.return_value = False
+
+        plan = FakePlan(id="plan_001", status="editing")
+        clips = [_make_clip("c1", order=0, duration=5.0)]
+        adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+        result = adapter.render_plan("plan_001")
+
+        assert not result.success
+        assert "素材下载失败" in result.error_message
+
+    @patch("video_processing.render_adapter.upload_to_oss")
+    @patch("video_processing.render_adapter.UnifiedRenderService")
+    @patch("video_processing.render_adapter.download_asset")
+    def test_successful_render(self, mock_download, mock_render_cls, mock_upload, tmp_path):
+        """完整渲染流程成功。"""
+
+        # 素材下载成功
+        def _fake_download(asset_id, local_path):
+            local_path.parent.mkdir(parents=True, exist_ok=True)
+            local_path.write_bytes(b"fake video data")
+            return True
+
+        mock_download.side_effect = _fake_download
+
+        # 渲染成功
+        mock_render = MagicMock()
+        mock_render.render.return_value = MagicMock(
+            output_path=tmp_path / "output.mp4",
+            duration=10.0,
+            file_size=102400,
+            width=1280,
+            height=720,
+        )
+        mock_render_cls.return_value = mock_render
+
+        # 上传成功
+        mock_upload.return_value = "https://oss.example.com/rendered/plan_001/job_001.mp4"
+
+        plan = FakePlan(id="plan_001", status="editing")
+        clips = [
+            _make_clip("c1", order=0, duration=5.0),
+            _make_clip("c2", order=1, duration=5.0),
+        ]
+        adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+        result = adapter.render_plan(
+            "plan_001",
+            job_id="job_001",
+            work_dir=tmp_path / "work",
+        )
+
+        assert result.success
+        assert result.output_url.startswith("https://")
+        assert result.duration == 10.0
+        assert result.width == 1280
+        assert result.height == 720
+        assert result.clip_count == 2
+
+        # 验证 UnifiedRenderService 被正确调用
+        mock_render_cls.assert_called_once()
+        call_kwargs = mock_render_cls.call_args
+        assert call_kwargs.kwargs["plan"] is plan
+        assert len(call_kwargs.kwargs["clips"]) == 2
+        assert len(call_kwargs.kwargs["asset_path_map"]) == 2
+
+    @patch("video_processing.render_adapter.download_asset")
+    def test_progress_callback(self, mock_download, tmp_path):
+        """进度回调被正确触发。"""
+
+        def _fake_download(asset_id, local_path):
+            local_path.parent.mkdir(parents=True, exist_ok=True)
+            local_path.write_bytes(b"fake data")
+            return True
+
+        mock_download.side_effect = _fake_download
+
+        # 模拟渲染异常，避免走到最后
+        with patch("video_processing.render_adapter.UnifiedRenderService") as mock_render_cls:
+            mock_render = MagicMock()
+            mock_render.render.side_effect = RuntimeError("render error")
+            mock_render_cls.return_value = mock_render
+
+            plan = FakePlan(id="plan_001", status="editing")
+            clips = [_make_clip("c1", order=0, duration=5.0)]
+            adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+            progress_values = []
+
+            def progress_cb(progress: float, stage: str) -> None:
+                progress_values.append((progress, stage))
+
+            result = adapter.render_plan(
+                "plan_001",
+                work_dir=tmp_path / "work",
+                progress_cb=progress_cb,
+            )
+
+            # 即使渲染失败，前期进度也应该上报了
+            assert len(progress_values) > 0
+            # 第一个进度应该是加载计划
+            assert progress_values[0][1] == "加载剪辑计划"
+
+    @patch("video_processing.render_adapter.download_asset")
+    def test_partial_asset_download(self, mock_download, tmp_path):
+        """部分素材下载失败时，只使用成功的素材。"""
+        download_results = [True, False, True]  # 3个素材中2个成功
+
+        def _fake_download(asset_id, local_path):
+            idx = hash(asset_id) % 3
+            if download_results[idx]:
+                local_path.parent.mkdir(parents=True, exist_ok=True)
+                local_path.write_bytes(b"fake data")
+                return True
+            return False
+
+        mock_download.side_effect = _fake_download
+
+        with patch("video_processing.render_adapter.UnifiedRenderService") as mock_render_cls:
+            mock_render = MagicMock()
+            mock_render.render.return_value = MagicMock(
+                output_path=tmp_path / "out.mp4",
+                duration=5.0,
+                file_size=1024,
+                width=1280,
+                height=720,
+            )
+            mock_render_cls.return_value = mock_render
+
+            with patch("video_processing.render_adapter.upload_to_oss", return_value="https://example.com/out.mp4"):
+                plan = FakePlan(id="plan_001", status="editing")
+                clips = [
+                    _make_clip("c1", order=0, duration=3.0, asset_id="asset_001.mp4"),
+                    _make_clip("c2", order=1, duration=3.0, asset_id="asset_002.mp4"),
+                    _make_clip("c3", order=2, duration=3.0, asset_id="asset_003.mp4"),
+                ]
+                adapter, _, _ = _make_adapter(plan=plan, clips=clips)
+
+                result = adapter.render_plan(
+                    "plan_001",
+                    work_dir=tmp_path / "work",
+                )
+
+                # 至少有部分素材成功，渲染应该进行
+                # （具体成功数量取决于 hash 结果，但至少1个成功就能渲染）
+                assert result.success or "素材下载失败" in result.error_message
+
+
+# ── _download_assets 测试 ────────────────────────────────────────────────────
+
+
+class TestDownloadAssets:
+    @patch("video_processing.render_adapter.download_asset")
+    def test_all_download_success(self, mock_download, tmp_path):
+        """全部素材下载成功。"""
+        mock_download.return_value = True
+
+        clips = [
+            _make_clip("c1", order=0, asset_id="key1.mp4"),
+            _make_clip("c2", order=1, asset_id="key2.mp4"),
+        ]
+
+        result = RenderAdapter._download_assets(clips, tmp_path)
+
+        assert len(result) == 2
+        assert "key1.mp4" in result
+        assert "key2.mp4" in result
+        assert mock_download.call_count == 2
+
+    @patch("video_processing.render_adapter.download_asset")
+    def test_empty_asset_id_skipped(self, mock_download, tmp_path):
+        """空 asset_id 的片段被跳过。"""
+        clips = [
+            _make_clip("c1", order=0, asset_id=""),
+            _make_clip("c2", order=1, asset_id="key2.mp4"),
+        ]
+        mock_download.return_value = True
+
+        result = RenderAdapter._download_assets(clips, tmp_path)
+
+        assert len(result) == 1
+        assert "key2.mp4" in result
+        assert mock_download.call_count == 1  # 只调用了一次下载
+
+    @patch("video_processing.render_adapter.download_asset")
+    def test_all_download_fail(self, mock_download, tmp_path):
+        """全部下载失败返回空字典。"""
+        mock_download.return_value = False
+
+        clips = [
+            _make_clip("c1", order=0, asset_id="key1.mp4"),
+        ]
+
+        result = RenderAdapter._download_assets(clips, tmp_path)
+
+        assert len(result) == 0

tests/unit/test_task_queue_limit.py

@@ -0,0 +1,351 @@
+"""任务队列限流防护单元测试。"""
+
+from __future__ import annotations
+
+import os
+import sys
+from unittest.mock import MagicMock
+
+import pytest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", "apps", "api"))
+
+from app.core.task_enqueue import (
+    GLOBAL_PENDING_LIMIT,
+    USER_PENDING_LIMIT,
+    GlobalQueueFull,
+    UserPendingLimitExceeded,
+    check_queue_limits,
+    safe_enqueue_generation_task,
+)
+
+# ---------------------------------------------------------------------------
+# Mock helpers
+# ---------------------------------------------------------------------------
+
+
+class MockRepository:
+    """支持 pending 计数的 mock repository。
+
+    支持通过 set_pending 动态修改计数，用于模拟入队后计数变化的并发场景。
+    """
+
+    def __init__(self, user_pending: int = 0, global_pending: int = 0):
+        self._user_pending = user_pending
+        self._global_pending = global_pending
+        self._send_task_called = False
+        self.updated_tasks = []
+
+    def count_pending_by_user(self, user_id: str) -> int:
+        return self._user_pending
+
+    def count_pending_total(self) -> int:
+        return self._global_pending
+
+    def update(self, task):
+        self.updated_tasks.append(task)
+        return task
+
+    def set_pending(self, *, user_pending: int | None = None, global_pending: int | None = None):
+        """动态修改 pending 计数，模拟并发场景。"""
+        if user_pending is not None:
+            self._user_pending = user_pending
+        if global_pending is not None:
+            self._global_pending = global_pending
+
+
+class MockTask:
+    def __init__(self, task_id: str = "task-1", status: str = "pending"):
+        self.id = task_id
+        self.status = status
+        self.error_message = ""
+
+    def mark_failed(self, reason: str):
+        self.status = "failed"
+        self.error_message = reason
+
+
+@pytest.fixture(autouse=True)
+def mock_celery(monkeypatch):
+    """mock 掉 celery_app.send_task，避免真实发送。"""
+    mock_send = MagicMock()
+    monkeypatch.setattr("app.core.celery_app.celery_app.send_task", mock_send)
+    return mock_send
+
+
+# ---------------------------------------------------------------------------
+# 常量导出测试
+# ---------------------------------------------------------------------------
+
+
+def test_limit_constants_are_exported():
+    """限流阈值常量已导出，供业务代码引用。"""
+    assert USER_PENDING_LIMIT == 3
+    assert GLOBAL_PENDING_LIMIT == 20
+
+
+# ---------------------------------------------------------------------------
+# check_queue_limits 单元测试（预检查用，>= 边界）
+# ---------------------------------------------------------------------------
+
+
+class TestCheckQueueLimits:
+    """队列限流检查函数测试（预检查语义，>= 上限即拒绝）。"""
+
+    def test_normal_passes_through(self):
+        """正常范围内的任务不受限制。"""
+        repo = MockRepository(user_pending=1, global_pending=5)
+        check_queue_limits("user-1", repo)
+
+    def test_user_limit_exceeded_raises(self):
+        """用户 pending 超过上限抛 UserPendingLimitExceeded。"""
+        repo = MockRepository(user_pending=4, global_pending=5)
+        with pytest.raises(UserPendingLimitExceeded) as exc_info:
+            check_queue_limits("user-1", repo)
+        assert exc_info.value.user_id == "user-1"
+        assert exc_info.value.pending_count == 4
+        assert exc_info.value.limit == 3
+
+    def test_user_at_limit_also_raises(self):
+        """用户 pending 刚好等于上限也拒绝（>= 边界）。"""
+        repo = MockRepository(user_pending=3, global_pending=5)
+        with pytest.raises(UserPendingLimitExceeded):
+            check_queue_limits("user-1", repo)
+
+    def test_user_below_limit_passes(self):
+        """用户 pending 比上限少 1，通过。"""
+        repo = MockRepository(user_pending=2, global_pending=5)
+        check_queue_limits("user-1", repo)
+
+    def test_global_limit_exceeded_raises(self):
+        """全局 pending 超过上限抛 GlobalQueueFull。"""
+        repo = MockRepository(user_pending=1, global_pending=21)
+        with pytest.raises(GlobalQueueFull) as exc_info:
+            check_queue_limits("user-1", repo)
+        assert exc_info.value.pending_count == 21
+        assert exc_info.value.limit == 20
+
+    def test_global_at_limit_also_raises(self):
+        """全局 pending 刚好等于上限也拒绝（>= 边界）。"""
+        repo = MockRepository(user_pending=1, global_pending=20)
+        with pytest.raises(GlobalQueueFull):
+            check_queue_limits("user-1", repo)
+
+    def test_global_below_limit_passes(self):
+        """全局 pending 比上限少 1，通过。"""
+        repo = MockRepository(user_pending=1, global_pending=19)
+        check_queue_limits("user-1", repo)
+
+    def test_global_takes_priority_over_user(self):
+        """全局和用户都超限时，优先抛全局异常。"""
+        repo = MockRepository(user_pending=5, global_pending=25)
+        with pytest.raises(GlobalQueueFull):
+            check_queue_limits("user-1", repo)
+
+    def test_empty_user_id_skips_user_check(self):
+        """不传 user_id 时跳过用户级检查，只做全局检查。"""
+        repo = MockRepository(user_pending=10, global_pending=5)
+        # 用户超限但不传 user_id → 全局未超限，应该通过
+        check_queue_limits("", repo)
+
+
+# ---------------------------------------------------------------------------
+# safe_enqueue_generation_task 限流集成测试（入队前用 >，包含当前任务）
+# ---------------------------------------------------------------------------
+
+
+class TestSafeEnqueueWithLimits:
+    """安全入队函数的限流功能测试。"""
+
+    def test_normal_task_enqueues_successfully(self, mock_celery):
+        """正常任务入队成功，返回 True。"""
+        repo = MockRepository(user_pending=0, global_pending=0)
+        task = MockTask("task-1")
+        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
+        assert result is True
+        mock_celery.assert_called_once_with("worker.generate_video", args=["task-1"])
+        assert len(repo.updated_tasks) == 0  # 成功不需要更新状态
+
+    def test_user_limit_rejected_with_failed_status(self, mock_celery):
+        """用户超限：任务标记为 failed，抛 UserPendingLimitExceeded。"""
+        repo = MockRepository(user_pending=5, global_pending=5)
+        task = MockTask("task-1")
+        with pytest.raises(UserPendingLimitExceeded):
+            safe_enqueue_generation_task(task, repo, user_id="user-1")
+        mock_celery.assert_not_called()
+        assert task.status == "failed"
+        assert "限流" in task.error_message
+        assert len(repo.updated_tasks) == 1
+
+    def test_user_at_limit_still_passes(self, mock_celery):
+        """用户 pending 刚好等于上限：入队前检查用 >，包含当前任务，刚好到上限不算超。
+
+        与预检查的 >= 语义一致：预检查时 pending=3 拒绝（不能再加新的），
+        但 safe_enqueue 被调用时任务已是 pending（就是第3个），
+        pending=3 不满足 >3，所以通过。
+        """
+        repo = MockRepository(user_pending=3, global_pending=5)
+        task = MockTask("task-1")
+        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
+        assert result is True
+        mock_celery.assert_called_once()
+
+    def test_user_one_over_limit_rejected(self, mock_celery):
+        """用户 pending = limit + 1：超限被拒。"""
+        repo = MockRepository(user_pending=4, global_pending=5)
+        task = MockTask("task-1")
+        with pytest.raises(UserPendingLimitExceeded):
+            safe_enqueue_generation_task(task, repo, user_id="user-1")
+        mock_celery.assert_not_called()
+
+    def test_global_limit_rejected_with_failed_status(self, mock_celery):
+        """全局超限：任务标记为 failed，抛 GlobalQueueFull。"""
+        repo = MockRepository(user_pending=1, global_pending=21)
+        task = MockTask("task-1")
+        with pytest.raises(GlobalQueueFull):
+            safe_enqueue_generation_task(task, repo, user_id="user-1")
+        mock_celery.assert_not_called()
+        assert task.status == "failed"
+        assert len(repo.updated_tasks) == 1
+
+    def test_global_at_limit_still_passes(self, mock_celery):
+        """全局 pending 刚好等于上限：入队前检查用 >，包含当前任务，刚好到上限不算超。"""
+        repo = MockRepository(user_pending=1, global_pending=20)
+        task = MockTask("task-1")
+        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
+        assert result is True
+        mock_celery.assert_called_once()
+
+    def test_no_user_id_skips_user_limit(self, mock_celery):
+        """不传 user_id 时跳过用户级限流，只做全局检查。"""
+        repo = MockRepository(user_pending=10, global_pending=5)
+        task = MockTask("task-1")
+        result = safe_enqueue_generation_task(task, repo, user_id="")
+        assert result is True
+        mock_celery.assert_called_once()
+
+    def test_no_user_id_still_checks_global(self, mock_celery):
+        """不传 user_id 时全局超限仍然被拦。"""
+        repo = MockRepository(user_pending=10, global_pending=25)
+        task = MockTask("task-1")
+        with pytest.raises(GlobalQueueFull):
+            safe_enqueue_generation_task(task, repo, user_id="")
+        mock_celery.assert_not_called()
+
+    def test_default_limits_match_constants(self, mock_celery):
+        """默认配置与导出常量一致。"""
+        # 刚好在默认限制内（limit - 1）
+        repo = MockRepository(user_pending=2, global_pending=19)
+        task = MockTask("task-1")
+        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
+        assert result is True
+
+    def test_update_failure_does_not_crash(self, mock_celery):
+        """repository.update 失败也不崩溃，异常继续向上抛。"""
+
+        class BadRepo(MockRepository):
+            def update(self, task):
+                raise RuntimeError("db down")
+
+        repo = BadRepo(user_pending=5, global_pending=5)
+        task = MockTask("task-1")
+        # 仍然抛 UserPendingLimitExceeded，不会被 update 失败掩盖
+        with pytest.raises(UserPendingLimitExceeded):
+            safe_enqueue_generation_task(task, repo, user_id="user-1")
+        mock_celery.assert_not_called()
+        # 任务状态还是变了（内存里改了）
+        assert task.status == "failed"
+
+
+# ---------------------------------------------------------------------------
+# 入队后最终校验（并发竞态兜底）测试
+# ---------------------------------------------------------------------------
+
+
+class TestPostEnqueueFinalCheck:
+    """入队后最终校验：模拟并发场景，Celery发送后计数增加被兜住。"""
+
+    def test_post_enqueue_global_overflow_rollback(self, mock_celery):
+        """并发场景：入队前检查通过，但发送Celery后全局计数超限 → 回滚为failed。
+
+        模拟两个请求同时通过入队前检查（都查到 global=19），
+        都创建了任务（DB里变成 21），先发送Celery的那个在最终校验时被兜住。
+        """
+        repo = MockRepository(user_pending=1, global_pending=20)  # 入队前：20 > 20？否
+        task = MockTask("task-1")
+
+        # 模拟发送Celery后，另一个并发请求也创建了任务，全局变成21
+        def side_effect(*args, **kwargs):
+            repo.set_pending(global_pending=21)
+
+        mock_celery.side_effect = side_effect
+
+        with pytest.raises(GlobalQueueFull) as exc_info:
+            safe_enqueue_generation_task(task, repo, user_id="user-1")
+
+        # Celery 确实发出去了（兜底不撤销 Celery，只回滚 DB 状态）
+        mock_celery.assert_called_once()
+        # 任务被标记为 failed
+        assert task.status == "failed"
+        assert "入队后" in task.error_message
+        assert exc_info.value.pending_count == 21
+        assert len(repo.updated_tasks) == 1
+
+    def test_post_enqueue_user_overflow_rollback(self, mock_celery):
+        """并发场景：入队前检查通过，但发送Celery后用户计数超限 → 回滚为failed。"""
+        repo = MockRepository(user_pending=3, global_pending=5)  # 入队前：3 > 3？否
+        task = MockTask("task-1")
+
+        def side_effect(*args, **kwargs):
+            repo.set_pending(user_pending=4)
+
+        mock_celery.side_effect = side_effect
+
+        with pytest.raises(UserPendingLimitExceeded) as exc_info:
+            safe_enqueue_generation_task(task, repo, user_id="user-1")
+
+        mock_celery.assert_called_once()
+        assert task.status == "failed"
+        assert "入队后" in task.error_message
+        assert exc_info.value.user_id == "user-1"
+        assert exc_info.value.pending_count == 4
+
+    def test_post_enqueue_global_priority_over_user(self, mock_celery):
+        """入队后校验：全局和用户都超限时，优先抛全局异常。"""
+        repo = MockRepository(user_pending=3, global_pending=20)
+        task = MockTask("task-1")
+
+        def side_effect(*args, **kwargs):
+            repo.set_pending(user_pending=5, global_pending=22)
+
+        mock_celery.side_effect = side_effect
+
+        with pytest.raises(GlobalQueueFull):
+            safe_enqueue_generation_task(task, repo, user_id="user-1")
+
+        assert task.status == "failed"
+
+    def test_post_enqueue_no_change_still_passes(self, mock_celery):
+        """入队后计数没变 → 正常通过，不回滚。"""
+        repo = MockRepository(user_pending=2, global_pending=10)
+        task = MockTask("task-1")
+
+        result = safe_enqueue_generation_task(task, repo, user_id="user-1")
+
+        assert result is True
+        mock_celery.assert_called_once()
+        assert task.status == "pending"  # 状态没变
+        assert len(repo.updated_tasks) == 0  # 没更新 DB
+
+    def test_post_enqueue_no_user_id_skips_user_check(self, mock_celery):
+        """不传 user_id 时，入队后校验也跳过用户级，只查全局。"""
+        repo = MockRepository(user_pending=10, global_pending=5)
+        task = MockTask("task-1")
+
+        def side_effect(*args, **kwargs):
+            repo.set_pending(user_pending=15, global_pending=5)  # 用户超限但全局没超
+
+        mock_celery.side_effect = side_effect
+
+        result = safe_enqueue_generation_task(task, repo, user_id="")
+        assert result is True  # 用户级不检查，全局没超限 → 通过

tests/unit/test_tts_job.py

@@ -15,7 +15,7 @@ class TestTTSJobCreate:
         job = TTSJob.create(
             user_id="user_001",
             input_text="这是一段测试文本",
-            voice_id="longxiaochun",
+            voice_id="longxiaochun_v3",
             voice_model="cosyvoice-v1",
             project_id="project_001",
             voice_clone_profile_id="profile_001",
@@ -26,7 +26,7 @@ class TestTTSJobCreate:
         assert job.id
         assert job.user_id == "user_001"
         assert job.input_text == "这是一段测试文本"
-        assert job.voice_id == "longxiaochun"
+        assert job.voice_id == "longxiaochun_v3"
         assert job.voice_model == "cosyvoice-v1"
         assert job.project_id == "project_001"
         assert job.voice_clone_profile_id == "profile_001"
@@ -291,7 +291,7 @@ class TestTTSJobToDict:
         job = TTSJob.create(
             user_id="user_001",
             input_text="测试文本",
-            voice_id="longxiaochun",
+            voice_id="longxiaochun_v3",
             voice_model="cosyvoice-v1",
             project_id="project_001",
             voice_clone_profile_id="profile_001",
@@ -306,7 +306,7 @@ class TestTTSJobToDict:
         assert result["id"] == job.id
         assert result["user_id"] == "user_001"
         assert result["input_text"] == "测试文本"
-        assert result["voice_id"] == "longxiaochun"
+        assert result["voice_id"] == "longxiaochun_v3"
         assert result["voice_model"] == "cosyvoice-v1"
         assert result["project_id"] == "project_001"
         assert result["voice_clone_profile_id"] == "profile_001"

tests/unit/test_tts_segment_synthesis.py

@@ -353,16 +353,11 @@ class TestHandleSegmentFailure:
 
 
 class TestPollSegmentTasks:
-    """测试 _poll_segment_tasks 异步轮询。"""
+    """测试 _poll_segment_tasks 分段缺失重新合成（适配同步接口）。"""
 
-    @patch("packages.application.tts_job.workflow.time")
     @patch("packages.application.tts_job.workflow.httpx")
-    def test_all_segments_done(self, mock_httpx: MagicMock, mock_time: MagicMock) -> None:
-        """所有分段完成后合并并标记完成。"""
-        # Mock time.monotonic 让循环只执行一次
-        mock_time.monotonic.side_effect = [0.0, 1.0, 2.0]
-        mock_time.sleep = MagicMock()
-
+    def test_all_segments_done(self, mock_httpx: MagicMock) -> None:
+        """所有分段缺少 audio_url 时重新同步合成，合并后标记完成。"""
         # Mock 下载分段音频
         mock_resp = MagicMock()
         mock_resp.content = b"seg audio"
@@ -370,7 +365,7 @@ class TestPollSegmentTasks:
         mock_httpx.get.return_value = mock_resp
 
         service = MagicMock(spec=CosyVoiceService)
-        service.poll_synthesize_task.side_effect = [
+        service.submit_synthesize_task.side_effect = [
             {"audio_url": "https://temp.com/seg1.mp3", "duration": 2.0, "file_size": 100},
             {"audio_url": "https://temp.com/seg2.mp3", "duration": 3.0, "file_size": 200},
         ]
@@ -381,6 +376,8 @@ class TestPollSegmentTasks:
         repo = MagicMock()
         job = _make_job(
             status=TTSJobStatus.PROCESSING,
+            # 长文本触发分段，用于重新合成时切分
+            input_text="这是一段很长的测试文本。" * 30,
             metadata={
                 "segment_task_ids": ["task_1", "task_2"],
                 "segment_audio_urls": ["", ""],
@@ -400,19 +397,18 @@ class TestPollSegmentTasks:
             result = workflow._poll_segment_tasks(job)
 
         assert result.status == TTSJobStatus.COMPLETED
+        # 两个缺失分段都重新合成了
+        assert service.submit_synthesize_task.call_count == 2
 
-    @patch("packages.application.tts_job.workflow.time")
-    def test_segment_poll_failure(self, mock_time: MagicMock) -> None:
-        """分段轮询失败时标记 job failed。"""
-        mock_time.monotonic.side_effect = [0.0, 1.0]
-        mock_time.sleep = MagicMock()
-
+    def test_segment_resynthesis_failure(self) -> None:
+        """分段重新合成失败时标记 job failed。"""
         service = MagicMock(spec=CosyVoiceService)
-        service.poll_synthesize_task.side_effect = CosyVoiceError("Poll failed")
+        service.submit_synthesize_task.side_effect = CosyVoiceError("Synthesis failed")
 
         repo = MagicMock()
         job = _make_job(
             status=TTSJobStatus.PROCESSING,
+            input_text="这是一段很长的测试文本。" * 30,
             metadata={
                 "segment_task_ids": ["task_1"],
                 "segment_audio_urls": [""],
@@ -426,6 +422,51 @@ class TestPollSegmentTasks:
 
         assert result.status == TTSJobStatus.FAILED
 
+    @patch("packages.application.tts_job.workflow.httpx")
+    def test_partial_audio_urls_reuse_existing(self, mock_httpx: MagicMock) -> None:
+        """部分分段已有 audio_url 时直接复用，缺失的重新合成。"""
+        mock_resp = MagicMock()
+        mock_resp.content = b"seg audio"
+        mock_resp.raise_for_status.return_value = None
+        mock_httpx.get.return_value = mock_resp
+
+        service = MagicMock(spec=CosyVoiceService)
+        # 只有 1 个分段需要重新合成
+        service.submit_synthesize_task.return_value = {
+            "audio_url": "https://temp.com/seg2.mp3",
+            "duration": 3.0,
+            "file_size": 200,
+        }
+
+        storage = MagicMock()
+        storage.upload_file.return_value = "https://oss.example.com/merged.mp3"
+
+        repo = MagicMock()
+        job = _make_job(
+            status=TTSJobStatus.PROCESSING,
+            input_text="这是一段很长的测试文本。" * 30,
+            metadata={
+                "segment_task_ids": ["task_1", "task_2"],
+                "segment_audio_urls": ["https://temp.com/seg1.mp3", ""],
+                "segment_format": "mp3",
+            },
+        )
+        repo.get.return_value = job
+        repo.update.side_effect = lambda j: j
+
+        workflow = _make_workflow(cosyvoice_service=service, repo=repo, storage=storage)
+
+        with patch("packages.application.tts_job.workflow.AudioMerger") as MockMerger:
+            mock_merger = MagicMock()
+            mock_merger.merge.return_value = b"merged data"
+            MockMerger.return_value = mock_merger
+
+            result = workflow._poll_segment_tasks(job)
+
+        assert result.status == TTSJobStatus.COMPLETED
+        # 只有 1 个缺失分段被重新合成
+        assert service.submit_synthesize_task.call_count == 1
+
 
 class TestPollAndProcessSynthesisSegmentDetection:
     """测试 poll_and_process_synthesis 正确识别分段任务。"""

tests/unit/test_unified_render_service.py

@@ -16,7 +16,10 @@ from video_processing.unified_render_service import (
     RenderResult,
     ResolvedClip,
     UnifiedRenderService,
+    _hex_to_ass_color,
+    _position_to_ass_alignment,
     _resolve_layer_role,
+    generate_ass_subtitles,
 )
 
 # ── Fixtures ──────────────────────────────────────────────────────────────────
@@ -45,6 +48,7 @@ class FakePlan:
 
     id: str = "plan_001"
     name: str = "测试计划"
+    config: dict[str, Any] = field(default_factory=dict)
 
 
 def _make_clip(
@@ -356,6 +360,138 @@ class TestBuildFilterComplex:
         assert "overlay=" in fc
         assert "[final_video]" in fc
 
+    def test_setpts_before_fps_in_xfade_inputs(self):
+        """多视频 xfade 模式：setpts=PTS-STARTPTS 必须在 fps 之前，确保 xfade 时各片段 PTS 一致。
+
+        构造两个不同时长的视频片段，验证生成的 filter_complex 中每个片段的
+        预处理滤镜链里 setpts 都在 fps 前面。
+        """
+        clips = [
+            _make_clip("c1", "main", order=0, duration=3.0),
+            _make_clip("c2", "main", order=1, duration=5.0),
+        ]
+        asset_paths = {
+            "asset_c1.mp4": Path("/tmp/asset_c1.mp4"),
+            "asset_c2.mp4": Path("/tmp/asset_c2.mp4"),
+        }
+        svc = _make_service(clips, asset_paths)
+
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            fc, _ = svc._build_filter_complex(layers)
+
+        # 确保 xfade 存在
+        assert "xfade=" in fc
+
+        # 提取每个 clip 的预处理滤镜链（[i:v]...[vi] 部分）
+        # 验证：每个 clip 滤镜链中，setpts=PTS-STARTPTS 的最后一次出现
+        # 必须在 fps= 的前面（PTS 归一化后再统一帧率）
+        import re
+
+        clip_pattern = re.compile(r"\[(\d+):v\](.+?)\[v\d+\]")
+        matches = clip_pattern.findall(fc)
+        assert len(matches) == 2, f"Expected 2 clip preprocessing chains, got {len(matches)}"
+
+        for idx, chain_str in matches:
+            # 找到所有 setpts 和 fps 的位置
+            setpts_positions = [m.start() for m in re.finditer(r"setpts=PTS-STARTPTS", chain_str)]
+            fps_positions = [m.start() for m in re.finditer(r"fps=\d+", chain_str)]
+
+            assert setpts_positions, f"clip {idx}: 未找到 setpts=PTS-STARTPTS"
+            assert fps_positions, f"clip {idx}: 未找到 fps="
+
+            # 最后一个 setpts 必须在第一个 fps 之前
+            last_setpts = max(setpts_positions)
+            first_fps = min(fps_positions)
+            assert last_setpts < first_fps, (
+                f"clip {idx}: setpts(position={last_setpts}) 应该在 fps(position={first_fps}) 之前。"
+                f"滤镜链: {chain_str}"
+            )
+
+    def test_setpts_before_fps_single_clip(self):
+        """单视频模式（一镜到底）：setpts 也必须在 fps 之前。
+
+        单视频虽然没有 xfade，但滤镜链顺序应保持一致，确保 PTS 处理逻辑统一。
+        """
+        clips = [_make_clip("c1", "main", order=0, duration=5.0)]
+        asset_paths = {"asset_c1.mp4": Path("/tmp/asset_c1.mp4")}
+        svc = _make_service(clips, asset_paths)
+
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            fc, _ = svc._build_filter_complex(layers)
+
+        import re
+
+        clip_pattern = re.compile(r"\[(\d+):v\](.+?)\[v\d+\]")
+        matches = clip_pattern.findall(fc)
+        assert len(matches) == 1
+
+        chain_str = matches[0][1]
+        setpts_positions = [m.start() for m in re.finditer(r"setpts=PTS-STARTPTS", chain_str)]
+        fps_positions = [m.start() for m in re.finditer(r"fps=\d+", chain_str)]
+
+        assert setpts_positions, "单视频: 未找到 setpts=PTS-STARTPTS"
+        assert fps_positions, "单视频: 未找到 fps="
+
+        last_setpts = max(setpts_positions)
+        first_fps = min(fps_positions)
+        assert last_setpts < first_fps, (
+            f"单视频: setpts(position={last_setpts}) 应该在 fps(position={first_fps}) 之前。" f"滤镜链: {chain_str}"
+        )
+
+    def test_main_clip_uses_fill_crop_strategy(self):
+        """main/broll clip 使用铺满裁剪策略（scale increase + crop），不是等比+黑边。
+
+        对齐链路A编辑器合成行为，与主流短视频平台一致。
+        """
+        clips = [_make_clip("c1", "main", order=0, duration=5.0)]
+        asset_paths = {"asset_c1.mp4": Path("/tmp/asset_c1.mp4")}
+        svc = _make_service(clips, asset_paths)
+
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            fc, _ = svc._build_filter_complex(layers)
+
+        # 验证：scale 使用 force_original_aspect_ratio=increase（铺满）
+        assert "force_original_aspect_ratio=increase" in fc
+        # 验证：有 crop（居中裁剪）
+        assert "crop=1280:720" in fc
+        # 验证：没有 pad（不是黑边模式）
+        assert "pad=" not in fc
+
+    def test_broll_clip_uses_fill_crop_strategy(self):
+        """broll clip 同样使用铺满裁剪策略。"""
+        clips = [_make_clip("c1", "b_roll", order=0, duration=5.0)]
+        asset_paths = {"asset_c1.mp4": Path("/tmp/asset_c1.mp4")}
+        svc = _make_service(clips, asset_paths)
+
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            fc, _ = svc._build_filter_complex(layers)
+
+        assert "force_original_aspect_ratio=increase" in fc
+        assert "crop=1280:720" in fc
+        assert "pad=" not in fc
+
+    def test_background_uses_fill_crop_strategy(self):
+        """background 层也使用铺满裁剪（已有的行为，保持一致）。"""
+        clips = [_make_clip("c1", "background", order=0, duration=5.0)]
+        asset_paths = {"asset_c1.mp4": Path("/tmp/asset_c1.mp4")}
+        svc = _make_service(clips, asset_paths)
+
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            fc, _ = svc._build_filter_complex(layers)
+
+        assert "force_original_aspect_ratio=increase" in fc
+        assert "crop=1280:720" in fc
+
     def test_empty_layers_raises(self):
         """空图层列表抛出 ValueError。"""
         svc = _make_service()
@@ -363,6 +499,294 @@ class TestBuildFilterComplex:
             svc._build_filter_complex([])
 
 
+class TestPassThrough:
+    """测试单图层单 clip 直通优化路径。"""
+
+    def test_can_use_pass_through_single_main_clip(self):
+        """1个main图层 + 1个clip → 可以直通。"""
+        clips = [_make_clip("c1", "main", order=0, duration=5.0)]
+        svc = _make_service(clips)
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            assert svc._can_use_pass_through(layers) is True
+
+    def test_can_use_pass_through_single_broll_clip(self):
+        """1个broll图层 + 1个clip → 可以直通。"""
+        clips = [_make_clip("c1", "b_roll", order=0, duration=5.0)]
+        svc = _make_service(clips)
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            assert svc._can_use_pass_through(layers) is True
+
+    def test_can_use_pass_through_single_background_clip(self):
+        """1个background图层 + 1个clip → 可以直通。"""
+        clips = [_make_clip("c1", "background", order=0, duration=5.0)]
+        svc = _make_service(clips)
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            assert svc._can_use_pass_through(layers) is True
+
+    def test_cannot_pass_through_multi_clips(self):
+        """1个图层 + 多个clips → 不能直通（需要xfade）。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=3.0),
+            _make_clip("c2", "main", order=1, duration=3.0),
+        ]
+        svc = _make_service(clips)
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            assert svc._can_use_pass_through(layers) is False
+
+    def test_cannot_pass_through_multi_layers(self):
+        """多个图层 → 不能直通。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=5.0),
+            _make_clip("c2", "overlay", order=1, duration=5.0),
+        ]
+        svc = _make_service(clips)
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            assert svc._can_use_pass_through(layers) is False
+
+    def test_cannot_pass_through_overlay_only(self):
+        """只有overlay图层 → 不能直通（需要叠加到主层）。"""
+        clips = [_make_clip("c1", "overlay", order=0, duration=5.0)]
+        svc = _make_service(clips)
+        with _patch_path_exists(), patch("video_processing.unified_render_service.probe_duration", return_value=5.0):
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            assert svc._can_use_pass_through(layers) is False
+
+    def test_render_uses_pass_through_for_single_clip(self):
+        """单clip渲染时走直通路径（调用_render_pass_through而非_execute_ffmpeg）。"""
+        clips = [_make_clip("c1", "main", order=0, duration=5.0)]
+        asset_paths = {"asset_c1.mp4": Path("/tmp/asset_c1.mp4")}
+        svc = _make_service(clips, asset_paths)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
+            patch.object(svc, "_render_pass_through") as mock_pass,
+            patch.object(svc, "_execute_ffmpeg") as mock_exec,
+            patch.object(svc, "_probe_output", return_value=(5.0, 1024, 1280, 720)),
+        ):
+            result = svc.render()
+
+        mock_pass.assert_called_once()
+        mock_exec.assert_not_called()
+        assert result.duration == 5.0
+
+    def test_render_uses_filter_complex_for_multi_clips(self):
+        """多clip渲染时走完整filter_complex路径。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=3.0),
+            _make_clip("c2", "main", order=1, duration=3.0),
+        ]
+        asset_paths = {
+            "asset_c1.mp4": Path("/tmp/asset_c1.mp4"),
+            "asset_c2.mp4": Path("/tmp/asset_c2.mp4"),
+        }
+        svc = _make_service(clips, asset_paths)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
+            patch.object(svc, "_render_pass_through") as mock_pass,
+            patch.object(svc, "_execute_ffmpeg") as mock_exec,
+            patch.object(svc, "_probe_output", return_value=(5.5, 2048, 1280, 720)),
+        ):
+            result = svc.render()
+
+        mock_pass.assert_not_called()
+        mock_exec.assert_called_once()
+        assert result.duration == 5.5
+
+
+# ── 测试 ASS 字幕生成 ────────────────────────────────────────────────────────
+
+
+class TestAssSubtitles:
+    """测试 ASS 字幕生成功能。"""
+
+    def test_hex_to_ass_color_white(self):
+        """#ffffff → &HFFFFFF（ASS 是 BGR 顺序）。"""
+        assert _hex_to_ass_color("#ffffff") == "&HFFFFFF"
+
+    def test_hex_to_ass_color_black(self):
+        """#000000 → &H000000。"""
+        assert _hex_to_ass_color("#000000") == "&H000000"
+
+    def test_hex_to_ass_color_red(self):
+        """#ff0000 红 → &H0000FF（B=00, G=00, R=FF）。"""
+        assert _hex_to_ass_color("#ff0000") == "&H0000FF"
+
+    def test_hex_to_ass_color_blue(self):
+        """#0000ff 蓝 → &HFF0000（B=FF, G=00, R=00）。"""
+        assert _hex_to_ass_color("#0000ff") == "&HFF0000"
+
+    def test_hex_to_ass_color_no_hash(self):
+        """不带 # 的颜色值也能解析。"""
+        assert _hex_to_ass_color("ff0000") == "&H0000FF"
+
+    def test_position_to_ass_alignment_top(self):
+        """top → 8（顶部居中）。"""
+        assert _position_to_ass_alignment("top") == 8
+
+    def test_position_to_ass_alignment_center(self):
+        """center → 5（居中）。"""
+        assert _position_to_ass_alignment("center") == 5
+
+    def test_position_to_ass_alignment_bottom(self):
+        """bottom → 2（底部居中）。"""
+        assert _position_to_ass_alignment("bottom") == 2
+
+    def test_generate_ass_with_title_only(self, tmp_path):
+        """只有标题时生成 ASS 文件。"""
+        ass_path = tmp_path / "test.ass"
+        result = generate_ass_subtitles(
+            ass_path,
+            video_width=1280,
+            video_height=720,
+            video_duration=10.0,
+            title_text="测试标题",
+            title_config={
+                "enabled": True,
+                "font": "思源黑体",
+                "size": 48,
+                "color": "#ffffff",
+                "bold": True,
+                "position": "top",
+                "stroke": {"enabled": True, "color": "#000000", "width": 2},
+                "shadow": {"enabled": True, "blur": 4, "offset_x": 2, "offset_y": 2},
+            },
+        )
+
+        assert result == ass_path
+        content = ass_path.read_text(encoding="utf-8")
+        assert "[Script Info]" in content
+        assert "PlayResX: 1280" in content
+        assert "PlayResY: 720" in content
+        assert "[V4+ Styles]" in content
+        assert "TitleStyle" in content
+        assert "测试标题" in content
+        assert "Dialogue:" in content
+
+    def test_generate_ass_with_subtitle_only(self, tmp_path):
+        """只有字幕时生成 ASS 文件。"""
+        ass_path = tmp_path / "test.ass"
+        result = generate_ass_subtitles(
+            ass_path,
+            video_width=1280,
+            video_height=720,
+            video_duration=10.0,
+            subtitle_text="测试字幕内容",
+            subtitle_config={
+                "enabled": True,
+                "font": "思源黑体",
+                "size": 24,
+                "color": "#ffffff",
+                "position": "bottom",
+            },
+        )
+
+        content = ass_path.read_text(encoding="utf-8")
+        assert "SubtitleStyle" in content
+        assert "测试字幕内容" in content
+        assert "Dialogue:" in content
+
+    def test_generate_ass_with_both_title_and_subtitle(self, tmp_path):
+        """同时有标题和字幕。"""
+        ass_path = tmp_path / "test.ass"
+        generate_ass_subtitles(
+            ass_path,
+            video_width=1280,
+            video_height=720,
+            video_duration=10.0,
+            title_text="大标题",
+            title_config={"enabled": True, "position": "top"},
+            subtitle_text="底部字幕",
+            subtitle_config={"enabled": True, "position": "bottom"},
+        )
+
+        content = ass_path.read_text(encoding="utf-8")
+        assert "TitleStyle" in content
+        assert "SubtitleStyle" in content
+        assert "大标题" in content
+        assert "底部字幕" in content
+        # 两条 Dialogue 行
+        assert content.count("Dialogue:") == 2
+
+    def test_generate_ass_disabled_returns_empty(self, tmp_path):
+        """标题和字幕都禁用时返回空文件。"""
+        ass_path = tmp_path / "test.ass"
+        generate_ass_subtitles(
+            ass_path,
+            video_width=1280,
+            video_height=720,
+            video_duration=10.0,
+            title_text="不显示",
+            title_config={"enabled": False},
+            subtitle_text="也不显示",
+            subtitle_config={"enabled": False},
+        )
+
+        content = ass_path.read_text(encoding="utf-8")
+        assert content == ""
+
+    def test_generate_ass_empty_text_returns_empty(self, tmp_path):
+        """文本为空时不生成字幕。"""
+        ass_path = tmp_path / "test.ass"
+        generate_ass_subtitles(
+            ass_path,
+            video_width=1280,
+            video_height=720,
+            video_duration=10.0,
+            title_text="",
+            title_config={"enabled": True},
+            subtitle_text="   ",
+            subtitle_config={"enabled": True},
+        )
+
+        content = ass_path.read_text(encoding="utf-8")
+        assert content == ""
+
+    def test_generate_ass_time_format(self, tmp_path):
+        """验证 ASS 时间格式正确（H:MM:SS.cc）。"""
+        ass_path = tmp_path / "test.ass"
+        generate_ass_subtitles(
+            ass_path,
+            video_width=1280,
+            video_height=720,
+            video_duration=125.5,  # 2分5.5秒
+            title_text="测试",
+            title_config={"enabled": True},
+        )
+
+        content = ass_path.read_text(encoding="utf-8")
+        # 结束时间应该是 0:02:05.50
+        assert "0:02:05.50" in content
+
+    def test_ass_text_escape_newlines(self, tmp_path):
+        """换行符转义为 ASS 的 \\N。"""
+        ass_path = tmp_path / "test.ass"
+        generate_ass_subtitles(
+            ass_path,
+            video_width=1280,
+            video_height=720,
+            video_duration=10.0,
+            title_text="第一行\n第二行",
+            title_config={"enabled": True},
+        )
+
+        content = ass_path.read_text(encoding="utf-8")
+        assert "第一行\\N第二行" in content
+
+
 # ── 测试 render 方法 ─────────────────────────────────────────────────────────
 
 
@@ -382,8 +806,8 @@ class TestRender:
         with pytest.raises(ValueError, match="没有可渲染的片段"):
             svc.render()
 
-    def test_render_success(self):
-        """正常渲染流程。"""
+    def test_render_success_single_clip(self):
+        """单clip正常渲染（走直通路径）。"""
         clips = [_make_clip("c1", "main", order=0)]
         asset_paths = {"asset_c1.mp4": Path("/tmp/asset_c1.mp4")}
         svc = _make_service(clips, asset_paths)
@@ -391,7 +815,7 @@ class TestRender:
         with (
             _patch_path_exists(),
             patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
-            patch.object(svc, "_execute_ffmpeg") as mock_exec,
+            patch.object(svc, "_render_pass_through") as mock_pass,
             patch.object(svc, "_probe_output", return_value=(5.0, 1024, 1280, 720)),
         ):
             result = svc.render()
@@ -401,4 +825,31 @@ class TestRender:
         assert result.file_size == 1024
         assert result.width == 1280
         assert result.height == 720
+        mock_pass.assert_called_once()
+
+    def test_render_success_multi_clips(self):
+        """多clip正常渲染（走完整filter_complex路径）。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=3.0),
+            _make_clip("c2", "main", order=1, duration=3.0),
+        ]
+        asset_paths = {
+            "asset_c1.mp4": Path("/tmp/asset_c1.mp4"),
+            "asset_c2.mp4": Path("/tmp/asset_c2.mp4"),
+        }
+        svc = _make_service(clips, asset_paths)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
+            patch.object(svc, "_execute_ffmpeg") as mock_exec,
+            patch.object(svc, "_probe_output", return_value=(5.5, 2048, 1280, 720)),
+        ):
+            result = svc.render()
+
+        assert isinstance(result, RenderResult)
+        assert result.duration == 5.5
+        assert result.file_size == 2048
+        assert result.width == 1280
+        assert result.height == 720
         mock_exec.assert_called_once()

tests/unit/test_video_compose_security.py

@@ -1,247 +0,0 @@
-"""
-视频合成服务安全校验单元测试
-针对 PR #159 安全审计发现的问题进行测试
-"""
-
-import os
-import tempfile
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-# 导入被测试的模块
-from apps.worker.video_processing.video_compose_service import (
-    ALLOWED_INPUT_PREFIXES,
-    ALLOWED_OUTPUT_DIRS,
-    ALLOWED_TRANSITIONS,
-    Clip,
-    EditingMode,
-    EditingModeConfig,
-    VideoComposeService,
-)
-
-
-class TestOutputPathValidation:
-    """P0: 输出路径穿越校验测试"""
-
-    def setup_method(self):
-        """测试前设置"""
-        self.config = EditingModeConfig(mode=EditingMode.ONE_TAKE)
-        self.service = VideoComposeService(self.config)
-
-    def test_valid_output_path_in_allowed_dir(self):
-        """测试合法的输出路径"""
-        valid_path = "/tmp/video_output/test.mp4"
-        result = self.service._validate_output_path(valid_path)
-        assert result == os.path.abspath(valid_path)
-
-    def test_valid_output_path_with_relative_components(self):
-        """测试带相对路径成分但最终在允许目录内的路径"""
-        valid_path = "/tmp/video_output/subdir/../test.mp4"
-        result = self.service._validate_output_path(valid_path)
-        assert result == os.path.abspath(valid_path)
-
-    def test_path_traversal_attack_blocked(self):
-        """测试路径穿越攻击被阻止"""
-        # 尝试穿越到 /etc/passwd
-        malicious_path = "/tmp/video_output/../../../etc/passwd"
-        with pytest.raises(ValueError, match="输出路径不在允许范围内"):
-            self.service._validate_output_path(malicious_path)
-
-    def test_path_traversal_attack_blocked_var_app(self):
-        """测试针对 /var/app 的路径穿越攻击被阻止"""
-        malicious_path = "/var/app/rendered/../../config/../../../etc/passwd"
-        with pytest.raises(ValueError, match="输出路径不在允许范围内"):
-            self.service._validate_output_path(malicious_path)
-
-    def test_absolute_path_to_forbidden_location(self):
-        """测试直接访问禁止位置"""
-        forbidden_path = "/etc/shadow"
-        with pytest.raises(ValueError, match="输出路径不在允许范围内"):
-            self.service._validate_output_path(forbidden_path)
-
-    def test_root_path_blocked(self):
-        """测试根目录被阻止"""
-        root_path = "/"
-        with pytest.raises(ValueError, match="输出路径不在允许范围内"):
-            self.service._validate_output_path(root_path)
-
-    def test_absolute_path_to_tmp_not_allowed(self):
-        """测试 /tmp 不在白名单中时应被阻止"""
-        # /tmp 不在 ALLOWED_OUTPUT_DIRS 中
-        tmp_path = "/tmp/test.mp4"
-        with pytest.raises(ValueError, match="输出路径不在允许范围内"):
-            self.service._validate_output_path(tmp_path)
-
-
-class TestInputPathValidation:
-    """P1-1: 输入路径格式校验测试"""
-
-    def setup_method(self):
-        """测试前设置"""
-        self.config = EditingModeConfig(mode=EditingMode.ONE_TAKE)
-        self.service = VideoComposeService(self.config)
-
-    def test_valid_s3_path(self):
-        """测试 S3 路径"""
-        assert self.service._validate_input_path("s3://bucket/key.mp4") is True
-
-    def test_valid_oss_path(self):
-        """测试 OSS 路径"""
-        assert self.service._validate_input_path("oss://bucket/key.mp4") is True
-
-    def test_valid_local_path(self):
-        """测试 local:// 路径"""
-        assert self.service._validate_input_path("local://asset/123.mp4") is True
-
-    def test_valid_var_storage_path(self):
-        """测试 /var/storage/ 路径"""
-        assert self.service._validate_input_path("/var/storage/assets/123.mp4") is True
-
-    def test_path_traversal_in_input_rejected(self):
-        """测试输入路径中的路径穿越尝试被拒绝"""
-        malicious_path = "s3://bucket/../../etc/passwd"
-        # 这会通过前缀检查，但实际使用时文件系统访问会失败
-        # 安全设计：只校验格式前缀
-        assert self.service._validate_input_path(malicious_path) is True
-
-    def test_malicious_input_path_blocked(self):
-        """测试恶意输入路径被阻止"""
-        assert self.service._validate_input_path("/etc/passwd") is False
-        assert self.service._validate_input_path("file:///etc/passwd") is False
-        assert self.service._validate_input_path("http://evil.com/shell.sh") is False
-
-    def test_empty_path_rejected(self):
-        """测试空路径被拒绝"""
-        assert self.service._validate_input_path("") is False
-
-    def test_random_string_rejected(self):
-        """测试随机字符串被拒绝"""
-        assert self.service._validate_input_path("random123") is False
-        assert self.service._validate_input_path("abc../../../etc") is False
-
-
-class TestTransitionValidation:
-    """P1-2: 转场参数白名单校验测试"""
-
-    def setup_method(self):
-        """测试前设置"""
-        self.config = EditingModeConfig(mode=EditingMode.ONE_TAKE)
-        self.service = VideoComposeService(self.config)
-
-    @pytest.mark.parametrize("transition", list(ALLOWED_TRANSITIONS))
-    def test_valid_transitions(self, transition):
-        """测试所有合法的转场效果"""
-        result = self.service._validate_transition(transition)
-        assert result == transition
-
-    def test_invalid_transition_defaults_to_fade(self):
-        """测试非法转场效果默认为 fade"""
-        result = self.service._validate_transition("random_transition")
-        assert result == "fade"
-
-    def test_sql_injection_in_transition_blocked(self):
-        """测试 SQL 注入尝试被阻止"""
-        result = self.service._validate_transition("fade; DROP TABLE videos;--")
-        assert result == "fade"
-
-    def test_shell_injection_in_transition_blocked(self):
-        """测试 Shell 注入尝试被阻止"""
-        result = self.service._validate_transition("fade$(whoami)")
-        assert result == "fade"
-
-    def test_empty_transition_handled(self):
-        """测试空转场名称"""
-        result = self.service._validate_transition("")
-        assert result == "fade"
-
-    def test_none_transition_handled(self):
-        """测试 None 转场名称"""
-        result = self.service._validate_transition(None)
-        assert result == "fade"
-
-    def test_get_validated_transition_returns_mapped(self):
-        """测试 _get_validated_transition 返回映射后的值"""
-        # "fade" 应该映射为 "fade"
-        result = self.service._get_validated_transition("fade")
-        assert result == "fade"
-
-
-class TestComposeSecurityIntegration:
-    """安全集成测试"""
-
-    def setup_method(self):
-        """测试前设置"""
-        self.config = EditingModeConfig(mode=EditingMode.ONE_TAKE)
-        self.service = VideoComposeService(self.config)
-
-    def test_compose_rejects_malicious_output_path(self):
-        """测试 compose 方法拒绝恶意输出路径"""
-        clips = [
-            Clip(asset_id="s3://bucket/video1.mp4"),
-            Clip(asset_id="s3://bucket/video2.mp4"),
-        ]
-
-        with pytest.raises(ValueError, match="输出路径不在允许范围内"):
-            self.service.compose(clips, output_path="/etc/passwd")
-
-    def test_compose_rejects_invalid_input_path(self):
-        """测试 compose 方法拒绝非法输入路径"""
-        clips = [
-            Clip(asset_id="/etc/shadow"),  # 非法路径
-        ]
-
-        with pytest.raises(ValueError, match="不合法的输入路径"):
-            self.service.compose(clips)
-
-    def test_compose_with_valid_paths(self):
-        """测试合法路径可以正常处理"""
-        with tempfile.TemporaryDirectory() as tmpdir:
-            # 创建临时视频文件
-            video_path = os.path.join(tmpdir, "input.mp4")
-            output_path = os.path.join("/tmp/video_output", "output.mp4")
-
-            # 创建空的测试文件（实际测试需要真实视频）
-            with open(video_path, "wb") as f:
-                f.write(b"fake video data")
-
-            clips = [
-                Clip(asset_id=f"local://{video_path}"),
-            ]
-
-            # 验证输入校验通过
-            assert self.service._validate_input_path(f"local://{video_path}") is True
-
-    def test_compose_empty_clips_rejected(self):
-        """测试空片段列表被拒绝"""
-        with pytest.raises(ValueError, match="clips 不能为空"):
-            self.service.compose([])
-
-
-class TestWhiteListConstants:
-    """白名单常量测试"""
-
-    def test_allowed_output_dirs_not_empty(self):
-        """测试输出目录白名单不为空"""
-        assert len(ALLOWED_OUTPUT_DIRS) > 0
-        assert "/tmp/video_output" in ALLOWED_OUTPUT_DIRS
-        assert "/var/app/rendered" in ALLOWED_OUTPUT_DIRS
-
-    def test_allowed_input_prefixes_not_empty(self):
-        """测试输入路径前缀白名单不为空"""
-        assert len(ALLOWED_INPUT_PREFIXES) > 0
-        assert "s3://" in ALLOWED_INPUT_PREFIXES
-        assert "oss://" in ALLOWED_INPUT_PREFIXES
-        assert "local://" in ALLOWED_INPUT_PREFIXES
-        assert "/var/storage/" in ALLOWED_INPUT_PREFIXES
-
-    def test_allowed_transitions_not_empty(self):
-        """测试转场效果白名单不为空"""
-        assert len(ALLOWED_TRANSITIONS) > 0
-        assert "fade" in ALLOWED_TRANSITIONS
-        assert "dissolve" in ALLOWED_TRANSITIONS
-        assert "slideleft" in ALLOWED_TRANSITIONS
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

tests/unit/test_voice_clone_workflow.py

@@ -57,15 +57,15 @@ def _make_service(
 class TestStartClone:
     """测试 start_clone 方法。"""
 
-    def test_start_clone_with_async_task(self) -> None:
-        """异步模式：提交任务后返回 processing 状态的 profile。"""
+    def test_start_clone_with_deploying(self) -> None:
+        """提交克隆后返回 DEPLOYING 状态，profile 保持 processing。"""
         mock_repo = MagicMock()
         mock_cosyvoice = MagicMock(spec=CosyVoiceService)
 
-        # CosyVoice 返回 task_id（异步模式）
+        # CosyVoice 返回 voice_id + DEPLOYING 状态（需轮询）
         mock_cosyvoice.submit_clone_task.return_value = {
-            "task_id": "task-abc",
-            "voice_id": "",
+            "voice_id": "voice-abc",
+            "status": "DEPLOYING",
             "request_id": "req-123",
         }
 
@@ -81,21 +81,21 @@ class TestStartClone:
         )
 
         assert profile.status == VoiceCloneStatus.PROCESSING
-        assert profile.metadata["cosyvoice_task_id"] == "task-abc"
+        assert profile.metadata["cosyvoice_task_id"] == "voice-abc"
         assert profile.metadata["cosyvoice_request_id"] == "req-123"
         mock_cosyvoice.submit_clone_task.assert_called_once()
         assert mock_repo.create.call_count == 1
-        # update 至少调用 2 次：mark_processing + 保存 task_id
+        # update 至少调用 2 次：mark_processing + 保存 voice_id
         assert mock_repo.update.call_count >= 2
 
-    def test_start_clone_with_sync_result(self) -> None:
-        """同步模式：CosyVoice 直接返回 voice_id，profile 变为 ready。"""
+    def test_start_clone_with_ok_status(self) -> None:
+        """CosyVoice 直接返回 OK 状态，profile 变为 ready。"""
         mock_repo = MagicMock()
         mock_cosyvoice = MagicMock(spec=CosyVoiceService)
 
         mock_cosyvoice.submit_clone_task.return_value = {
-            "task_id": "",
             "voice_id": "voice-sync-123",
+            "status": "OK",
             "request_id": "req-456",
         }
 
@@ -244,8 +244,8 @@ class TestRetryClone:
         mock_repo.update.side_effect = lambda p: p
 
         mock_cosyvoice.submit_clone_task.return_value = {
-            "task_id": "task-retry",
-            "voice_id": "",
+            "voice_id": "voice-retry",
+            "status": "DEPLOYING",
             "request_id": "req-retry",
         }
 
@@ -253,11 +253,11 @@ class TestRetryClone:
         result = service.retry_clone(profile.id, "user-123")
 
         assert result.status == VoiceCloneStatus.PROCESSING
-        assert result.metadata["cosyvoice_task_id"] == "task-retry"
+        assert result.metadata["cosyvoice_task_id"] == "voice-retry"
         assert result.retry_count == 2  # prepare_retry 增加了一次
 
-    def test_retry_clone_with_sync_result(self) -> None:
-        """重试成功，同步模式。"""
+    def test_retry_clone_with_ok_status(self) -> None:
+        """重试成功，直接返回 OK 状态。"""
         mock_repo = MagicMock()
         mock_cosyvoice = MagicMock(spec=CosyVoiceService)
 
@@ -266,8 +266,8 @@ class TestRetryClone:
         mock_repo.update.side_effect = lambda p: p
 
         mock_cosyvoice.submit_clone_task.return_value = {
-            "task_id": "",
             "voice_id": "voice-retry-sync",
+            "status": "OK",
             "request_id": "req-retry",
         }