style: black format edit_plan_generation.py

3 个修复：
1. render_edit_plan 素材下载路径错误：直接传 asset_id 给 download_asset，
   改为先查 assets 表拿 file_url(storage_key) 再下载
2. 总时长=0.0s 日志误导：_build_plan_and_clips_from_task 中 _VirtualClip
   的 duration 未赋值导致日志永远显示 0s，改为用 probe_duration 预探测
3. video_processing/__init__.py 导入链副作用：顶层导入 render_adapter 等
   重依赖模块，导致只想用 oss_helpers/ffmpeg_utils 等轻量工具的地方也
   被迫拉进 packages/DB 全量依赖。改为只导出轻量工具模块，渲染组件
   按需从子模块导入

apps/api/app/api/router.py

@@ -8,6 +8,7 @@ from app.api.routes.dashboard import router as dashboard_router
 from app.api.routes.duplication import router as duplication_router
 from app.api.routes.edit_plans import router as edit_plans_router
 from app.api.routes.edit_templates import router as edit_templates_router
+from app.api.routes.feature_flags import router as feature_flags_router
 from app.api.routes.generated_videos import router as generated_videos_router
 from app.api.routes.generation_tasks import router as generation_tasks_router
 from app.api.routes.health import router as health_check_router
@@ -151,3 +152,7 @@ api_router.include_router(
     prefix="/tts",
     tags=["TTS"],
 )
+api_router.include_router(
+    feature_flags_router,
+    tags=["Internal"],
+)

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

@@ -0,0 +1,195 @@
+"""Feature Flag 内部管理接口。
+
+通过内部 API Key 鉴权，支持查看和修改 Feature Flag 配置。
+主要用于灰度发布期间的动态开关控制。
+
+API:
+  GET  /api/v1/internal/feature-flags          - 列出所有 flag
+  GET  /api/v1/internal/feature-flags/{name}   - 查看单个 flag
+  PUT  /api/v1/internal/feature-flags/{name}   - 设置 flag 配置
+  DELETE /api/v1/internal/feature-flags/{name} - 删除 flag
+
+鉴权：X-API-Key header，走内部 API Key 验证
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from app.api.routes.auth import _verify_internal_api_key
+from app.config import settings
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from pydantic import BaseModel, Field
+
+from packages.adapters.redis.feature_flag_store import (
+    FEATURE_FLAG_REDIS_PREFIX,
+    FeatureFlagConfig,
+    RedisFeatureFlagStore,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/internal/feature-flags", tags=["Internal"])
+
+# 允许管理的 flag 白名单（防止误操作其他系统 flag）
+ALLOWED_FLAGS = {
+    "render_engine",
+}
+
+
+def _get_feature_flag_store() -> RedisFeatureFlagStore:
+    """获取 Feature Flag 存储实例。"""
+    return RedisFeatureFlagStore(redis_url=settings.REDIS_URL)
+
+
+class FeatureFlagUpdateRequest(BaseModel):
+    """Feature Flag 更新请求体。"""
+
+    enabled: bool = Field(..., description="是否启用")
+    percentage: int = Field(0, ge=0, le=100, description="灰度百分比 (0-100)")
+    whitelist: list[str] = Field(default_factory=list, description="白名单列表（如 user_id）")
+
+
+class FeatureFlagResponse(BaseModel):
+    """Feature Flag 响应。"""
+
+    name: str
+    enabled: bool
+    percentage: int
+    whitelist: list[str]
+
+    @classmethod
+    def from_config(cls, config: FeatureFlagConfig) -> "FeatureFlagResponse":
+        return cls(
+            name=config.name,
+            enabled=config.enabled,
+            percentage=config.percentage,
+            whitelist=sorted(config.whitelist),
+        )
+
+
+class FeatureFlagCheckResponse(BaseModel):
+    """Flag 激活检查响应。"""
+
+    name: str
+    active: bool
+    identifier: Optional[str] = None
+
+
+def _validate_flag_name(name: str) -> None:
+    """校验 flag 名称是否在允许列表中。"""
+    if name not in ALLOWED_FLAGS:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Unsupported flag: {name}. Allowed: {sorted(ALLOWED_FLAGS)}",
+        )
+
+
+@router.get("", response_model=list[FeatureFlagResponse])
+async def list_feature_flags(
+    _: bool = Depends(_verify_internal_api_key),
+    store: RedisFeatureFlagStore = Depends(_get_feature_flag_store),
+):
+    """列出所有 Feature Flag。"""
+    try:
+        flags = store.list_all()
+        # 同时返回预定义的 flag（即使未设置也显示默认值）
+        result = []
+        for name in sorted(ALLOWED_FLAGS):
+            config = flags.get(name) or FeatureFlagConfig(name=name, enabled=False)
+            result.append(FeatureFlagResponse.from_config(config))
+        # 加上已存在但不在白名单中的 flag（只读展示）
+        for name, config in flags.items():
+            if name not in ALLOWED_FLAGS:
+                result.append(FeatureFlagResponse.from_config(config))
+        return sorted(result, key=lambda x: x.name)
+    except Exception as exc:
+        logger.error("Failed to list feature flags: %s", exc)
+        raise HTTPException(status_code=500, detail=f"Failed to list flags: {exc}")
+
+
+@router.get("/{name}", response_model=FeatureFlagResponse)
+async def get_feature_flag(
+    name: str,
+    _: bool = Depends(_verify_internal_api_key),
+    store: RedisFeatureFlagStore = Depends(_get_feature_flag_store),
+):
+    """获取单个 Feature Flag 配置。"""
+    try:
+        config = store.get(name)
+        return FeatureFlagResponse.from_config(config)
+    except Exception as exc:
+        logger.error("Failed to get feature flag %s: %s", name, exc)
+        raise HTTPException(status_code=500, detail=f"Failed to get flag: {exc}")
+
+
+@router.get("/{name}/check", response_model=FeatureFlagCheckResponse)
+async def check_feature_flag(
+    name: str,
+    identifier: Optional[str] = Query(None, description="标识符，如 user_id"),
+    _: bool = Depends(_verify_internal_api_key),
+    store: RedisFeatureFlagStore = Depends(_get_feature_flag_store),
+):
+    """检查某个标识符是否命中 Feature Flag。"""
+    try:
+        active = store.is_active(name, identifier=identifier)
+        return FeatureFlagCheckResponse(name=name, active=active, identifier=identifier)
+    except Exception as exc:
+        logger.error("Failed to check feature flag %s: %s", name, exc)
+        raise HTTPException(status_code=500, detail=f"Failed to check flag: {exc}")
+
+
+@router.put("/{name}", response_model=FeatureFlagResponse)
+async def update_feature_flag(
+    name: str,
+    request: FeatureFlagUpdateRequest,
+    _: bool = Depends(_verify_internal_api_key),
+    store: RedisFeatureFlagStore = Depends(_get_feature_flag_store),
+):
+    """更新 Feature Flag 配置。
+
+    只允许修改 ALLOWED_FLAGS 列表中的 flag。
+    """
+    _validate_flag_name(name)
+
+    try:
+        config = FeatureFlagConfig(
+            name=name,
+            enabled=request.enabled,
+            percentage=request.percentage,
+            whitelist=set(request.whitelist),
+        )
+        store.set(config)
+        logger.info(
+            "Feature flag updated: name=%s enabled=%s percentage=%d whitelist=%d",
+            name,
+            config.enabled,
+            config.percentage,
+            len(config.whitelist),
+        )
+        return FeatureFlagResponse.from_config(config)
+    except Exception as exc:
+        logger.error("Failed to update feature flag %s: %s", name, exc)
+        raise HTTPException(status_code=500, detail=f"Failed to update flag: {exc}")
+
+
+@router.delete("/{name}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_feature_flag(
+    name: str,
+    _: bool = Depends(_verify_internal_api_key),
+    store: RedisFeatureFlagStore = Depends(_get_feature_flag_store),
+):
+    """删除 Feature Flag。
+
+    只允许删除 ALLOWED_FLAGS 列表中的 flag。
+    """
+    _validate_flag_name(name)
+
+    try:
+        deleted = store.delete(name)
+        logger.info("Feature flag deleted: name=%s deleted=%s", name, deleted)
+        return None
+    except Exception as exc:
+        logger.error("Failed to delete feature flag %s: %s", name, exc)
+        raise HTTPException(status_code=500, detail=f"Failed to delete flag: {exc}")

apps/worker/video_processing/__init__.py

@@ -1,21 +1,17 @@
 """
 视频处理模块
+
+轻量工具（ffmpeg_utils / oss_helpers / dedup_helpers）顶层直接导出，
+无额外依赖。渲染相关组件（UnifiedRenderService / RenderAdapter /
+VideoProcessor 等）按需从子模块导入，避免 __init__ 阶段引入
+packages / DB 等重依赖。
 """
 
-# 共享工具模块（供 editing_modes / generation / edit_plan_generation 等复用）
+# 共享工具模块（零外部依赖，供 editing_modes / generation / edit_plan_generation 等复用）
 from . import dedup_helpers, ffmpeg_utils, oss_helpers
-from .processor import VideoProcessor, VideoResult
-from .unified_render_service import RenderResult, UnifiedRenderService
-from .render_adapter import RenderAdapter, RenderAdapterResult
 
 __all__ = [
-    "VideoProcessor",
-    "VideoResult",
     "ffmpeg_utils",
     "oss_helpers",
     "dedup_helpers",
-    "UnifiedRenderService",
-    "RenderResult",
-    "RenderAdapter",
-    "RenderAdapterResult",
 ]

apps/worker/video_processing/ffmpeg_utils.py

@@ -85,6 +85,41 @@ def run_ffmpeg(
         raise
 
 
+def probe_has_audio(local_path: str | Path) -> bool:
+    """探测文件是否包含音频流。
+
+    Args:
+        local_path: 本地文件路径
+
+    Returns:
+        True 表示有音频流（或探测失败保守返回），False 表示确认无音频流
+    """
+    try:
+        result = subprocess.run(  # nosec B603
+            [
+                FFPROBE_BIN,
+                "-v",
+                "error",
+                "-select_streams",
+                "a:0",
+                "-show_entries",
+                "stream=codec_type",
+                "-of",
+                "default=noprint_wrappers=1:nokey=1",
+                str(local_path),
+            ],
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=10,
+        )
+        return result.stdout.strip() == "audio"
+    except Exception:
+        # 探测失败保守返回 True，让 FFmpeg 自己处理（避免误删音频）
+        return True
+
+
 def probe_duration(local_path: str | Path) -> float:
     """用 ffprobe 获取视频时长（秒）。
 

apps/worker/video_processing/render_adapter.py

@@ -20,20 +20,13 @@ 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.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
-from video_processing.oss_helpers import download_asset, upload_to_oss
-from video_processing.unified_render_service import (
-    RenderResult,
-    UnifiedRenderService,
-)
 
 logger = logging.getLogger(__name__)
 
@@ -140,7 +133,7 @@ class RenderAdapter:
                 )
 
             logger.info(
-                "开始渲染: plan_id=%s job_id=%s ready_clips=%d",
+                "开始渲染: plan_id=%s job_id=%s ready_clips=%d engine=unified",
                 plan_id,
                 job_id,
                 len(ready_clips),
@@ -176,6 +169,18 @@ class RenderAdapter:
 
             self._report_progress(progress_cb, 100.0, "渲染完成")
 
+            logger.info(
+                "[render-adapter] render success: plan_id=%s job_id=%s engine=unified "
+                "duration=%.2fs file_size=%d resolution=%dx%d clip_count=%d",
+                plan_id,
+                job_id,
+                result.duration,
+                result.file_size,
+                result.width,
+                result.height,
+                len(ready_clips),
+            )
+
             return RenderAdapterResult(
                 success=True,
                 output_url=output_url or "",
@@ -188,7 +193,12 @@ class RenderAdapter:
             )
 
         except Exception as exc:
-            logger.exception("渲染失败: plan_id=%s", plan_id)
+            logger.exception(
+                "[render-adapter] render failed: plan_id=%s job_id=%s engine=unified error=%s",
+                plan_id,
+                job_id,
+                str(exc)[:200],
+            )
             return RenderAdapterResult(
                 success=False,
                 error_message=str(exc)[:500],

apps/worker/video_processing/render_engine_resolver.py

@@ -0,0 +1,204 @@
+"""渲染引擎 Feature Flag 解析器。
+
+封装渲染引擎选择逻辑，支持：
+- 环境变量作为默认值（RENDER_ENGINE=legacy/unified）
+- Redis Feature Flag 运行时覆盖（白名单 + 百分比 + 全局开关）
+- 定时刷新，支持热更新不重启 worker
+
+使用方式：
+    resolver = RenderEngineResolver(redis_url="redis://...", default_engine="legacy")
+    engine = resolver.get_engine(user_id="user123")
+    # engine: "legacy" 或 "unified"
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from typing import Optional
+
+from packages.adapters.redis.feature_flag_store import (
+    FeatureFlagConfig,
+    FeatureFlagStore,
+    InMemoryFeatureFlagStore,
+    RedisFeatureFlagStore,
+)
+
+logger = logging.getLogger(__name__)
+
+# Feature Flag 名称常量
+FLAG_RENDER_ENGINE = "render_engine"
+
+# 引擎常量
+ENGINE_LEGACY = "legacy"
+ENGINE_UNIFIED = "unified"
+VALID_ENGINES = {ENGINE_LEGACY, ENGINE_UNIFIED}
+
+
+class RenderEngineResolver:
+    """渲染引擎选择器。
+
+    判定逻辑（从高到低）：
+    1. Redis flag 白名单匹配 → unified
+    2. Redis flag 百分比命中 → unified
+    3. Redis flag 全局开启（100%）→ unified
+    4. 环境变量默认值 → legacy / unified
+
+    当 Redis 不可用时，自动降级到环境变量默认值，不影响业务。
+    """
+
+    def __init__(
+        self,
+        default_engine: str = ENGINE_LEGACY,
+        redis_url: Optional[str] = None,
+        refresh_interval: float = 30.0,
+        store: Optional[FeatureFlagStore] = None,
+    ) -> None:
+        """
+        Args:
+            default_engine: 环境变量默认的引擎名（legacy / unified）
+            redis_url: Redis 连接 URL，传 None 时使用内存实现（测试用）
+            refresh_interval: Redis flag 配置刷新间隔（秒）
+            store: 直接传入 store 实例（测试用，优先级高于 redis_url）
+        """
+        self._default_engine = default_engine.lower() if default_engine else ENGINE_LEGACY
+        if self._default_engine not in VALID_ENGINES:
+            logger.warning(
+                "Invalid default engine '%s', fallback to '%s'",
+                self._default_engine,
+                ENGINE_LEGACY,
+            )
+            self._default_engine = ENGINE_LEGACY
+
+        if store is not None:
+            self._store = store
+        elif redis_url:
+            self._store = RedisFeatureFlagStore(redis_url=redis_url)
+        else:
+            self._store = InMemoryFeatureFlagStore()
+            logger.info("No Redis configured, using in-memory feature flag store")
+
+        self._refresh_interval = refresh_interval
+        self._lock = threading.Lock()
+        self._cached_config: Optional[FeatureFlagConfig] = None
+        self._last_refresh: float = 0.0
+
+    def _maybe_refresh(self) -> None:
+        """惰性刷新配置，超过刷新间隔时从存储重新读取。"""
+        import time
+
+        now = time.time()
+        if now - self._last_refresh < self._refresh_interval:
+            return
+
+        try:
+            config = self._store.get(FLAG_RENDER_ENGINE)
+            with self._lock:
+                self._cached_config = config
+                self._last_refresh = now
+        except Exception as exc:
+            logger.warning("Failed to refresh render engine flag: %s", exc)
+            # 刷新失败时保留旧缓存，不中断业务
+            if self._cached_config is None:
+                # 首次就读失败，设一个默认值
+                with self._lock:
+                    self._cached_config = FeatureFlagConfig(name=FLAG_RENDER_ENGINE)
+                    self._last_refresh = now
+
+    def _get_config(self) -> FeatureFlagConfig:
+        """获取当前 flag 配置（带缓存）。"""
+        if self._cached_config is None:
+            self._maybe_refresh()
+        else:
+            self._maybe_refresh()
+        return self._cached_config or FeatureFlagConfig(name=FLAG_RENDER_ENGINE)
+
+    def get_engine(self, user_id: Optional[str] = None) -> str:
+        """获取当前应该使用的渲染引擎。
+
+        Args:
+            user_id: 用户ID，用于白名单匹配和百分比哈希。
+                    传 None 时只看全局开关。
+
+        Returns:
+            "legacy" 或 "unified"
+        """
+        config = self._get_config()
+
+        # 全局关闭 → 用默认值
+        if not config.enabled:
+            return self._default_engine
+
+        # 白名单匹配 / 百分比命中 → unified
+        if config.is_active(user_id):
+            return ENGINE_UNIFIED
+
+        # 未命中灰度 → 用默认值
+        return self._default_engine
+
+    def should_use_unified(self, user_id: Optional[str] = None) -> bool:
+        """便捷方法：是否应该使用统一渲染引擎。"""
+        return self.get_engine(user_id) == ENGINE_UNIFIED
+
+    def force_refresh(self) -> None:
+        """强制立即刷新配置（用于管理接口修改后立即生效）。"""
+        self._last_refresh = 0.0
+        if isinstance(self._store, RedisFeatureFlagStore):
+            self._store.invalidate_cache(FLAG_RENDER_ENGINE)
+        self._maybe_refresh()
+
+    def get_config_snapshot(self) -> dict:
+        """获取当前配置快照（用于管理接口展示）。"""
+        config = self._get_config()
+        return {
+            "flag_name": FLAG_RENDER_ENGINE,
+            "default_engine": self._default_engine,
+            "enabled": config.enabled,
+            "percentage": config.percentage,
+            "whitelist": sorted(config.whitelist),
+            "refresh_interval": self._refresh_interval,
+            "last_refresh": self._last_refresh,
+        }
+
+    def set_flag(self, config: FeatureFlagConfig) -> None:
+        """设置 flag 配置（管理接口用）。"""
+        config.name = FLAG_RENDER_ENGINE
+        self._store.set(config)
+        self.force_refresh()
+
+
+# 全局单例
+_resolver: Optional[RenderEngineResolver] = None
+_resolver_lock = threading.Lock()
+
+
+def get_render_engine_resolver() -> RenderEngineResolver:
+    """获取全局单例（基于 worker 配置）。"""
+    global _resolver
+    if _resolver is not None:
+        return _resolver
+
+    with _resolver_lock:
+        if _resolver is not None:
+            return _resolver
+
+        try:
+            from worker_app.core.config import get_settings
+
+            settings = get_settings()
+            redis_url = getattr(settings, "redis_url", None) or getattr(settings, "broker_url", None)
+            default = getattr(settings, "render_engine", ENGINE_LEGACY)
+            _resolver = RenderEngineResolver(
+                default_engine=default,
+                redis_url=redis_url,
+            )
+            logger.info(
+                "RenderEngineResolver initialized: default=%s, redis=%s",
+                default,
+                bool(redis_url),
+            )
+        except Exception as exc:
+            logger.warning("Failed to init RenderEngineResolver from settings: %s", exc)
+            _resolver = RenderEngineResolver(default_engine=ENGINE_LEGACY)
+
+    return _resolver

apps/worker/video_processing/unified_render_service.py

@@ -24,6 +24,7 @@ from __future__ import annotations
 import logging
 import os
 import subprocess
+import time
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
@@ -356,6 +357,8 @@ def _resolve_layer_role(clip_type: str, config: dict[str, Any]) -> str:
     # main type
     if role == "b_roll":
         return "broll"
+    if role == "audio":
+        return "audio"
     return "main"
 
 
@@ -415,9 +418,16 @@ class UnifiedRenderService:
         1. 视频主渲染（直通或完整链路）
         2. 如有 title/subtitle，叠加 ASS 字幕
 
+        音频后处理：
+        1. 主图层音频 concat 拼接
+        2. 独立音频轨 amix 混入
+        3. 合并到输出视频
+
         Raises:
             ValueError: 没有可渲染的片段时抛出
         """
+        t_start = time.time()
+
         # 1. 解析 clips → ResolvedClips（跳过无素材的 clip）
         resolved = self._resolve_clips()
         if not resolved:
@@ -432,18 +442,88 @@ class UnifiedRenderService:
         # 4. 生成 ASS 字幕文件（如果有 title/subtitle 配置）
         ass_path = self._maybe_generate_ass(video_duration)
 
-        output_path = self.work_dir / f"rendered_{self.plan.id}.mp4"
+        # 灰度埋点：开始渲染
+        layer_roles = [layer.role for layer in layers]
+        clip_counts = {layer.role: len(layer.clips) for layer in layers}
+        logger.info(
+            "[unified-render] start render: plan_id=%s clip_count=%d layers=%s clip_counts=%s",
+            self.plan.id,
+            len(resolved),
+            layer_roles,
+            clip_counts,
+        )
 
         # 5. 视频主渲染
-        if self._can_use_pass_through(layers):
-            self._render_pass_through(layers, output_path, ass_path=ass_path)
+        t_video_start = time.time()
+        video_only_path = self.work_dir / f"rendered_{self.plan.id}_video.mp4"
+        output_path = self.work_dir / f"rendered_{self.plan.id}.mp4"
+
+        is_pass_through = self._can_use_pass_through(layers)
+        pass_through_has_audio = False
+
+        if is_pass_through:
+            # 直通优化：单clip场景一次FFmpeg同时处理视频+音频，省去提取+合并两次调用
+            pass_through_has_audio = self._render_pass_through(
+                layers, output_path, ass_path=ass_path, video_duration=video_duration
+            )
         else:
             filter_complex, input_args = self._build_filter_complex(layers, ass_path=ass_path)
-            self._execute_ffmpeg(filter_complex, input_args, output_path)
+            self._execute_ffmpeg(filter_complex, input_args, video_only_path)
 
-        # 6. 探测输出
+        t_video_end = time.time()
+        video_render_ms = int((t_video_end - t_video_start) * 1000)
+        logger.info(
+            "[unified-render] video render done: plan_id=%s duration_ms=%d pass_through=%s",
+            self.plan.id,
+            video_render_ms,
+            is_pass_through,
+        )
+
+        # 6. 音频后处理混音（直通场景已合并处理，跳过）
+        t_audio_start = time.time()
+        audio_mix_ms = 0
+        has_audio = False
+
+        if is_pass_through:
+            # 直通场景已在一次调用中完成视频+音频
+            has_audio = pass_through_has_audio
+        else:
+            audio_path = self._mix_audio(layers, video_duration)
+            t_audio_end = time.time()
+            audio_mix_ms = int((t_audio_end - t_audio_start) * 1000)
+            has_audio = audio_path is not None
+            if has_audio:
+                logger.info(
+                    "[unified-render] audio mix done: plan_id=%s duration_ms=%d",
+                    self.plan.id,
+                    audio_mix_ms,
+                )
+                # 7. 合并音视频
+                self._merge_audio_video(video_only_path, audio_path, output_path)
+            else:
+                # 无音频，直接用无声视频
+                import shutil
+
+                shutil.copy2(video_only_path, output_path)
+
+        # 8. 探测输出
         duration, file_size, width, height = self._probe_output(output_path)
 
+        t_total = int((time.time() - t_start) * 1000)
+        logger.info(
+            "[unified-render] render done: plan_id=%s total_ms=%d video_ms=%d audio_ms=%d "
+            "output_duration=%.2fs output_size=%d resolution=%dx%d has_audio=%s",
+            self.plan.id,
+            t_total,
+            video_render_ms,
+            audio_mix_ms if has_audio else 0,
+            duration,
+            file_size,
+            width,
+            height,
+            has_audio,
+        )
+
         return RenderResult(
             output_path=output_path,
             duration=duration,
@@ -470,14 +550,7 @@ class UnifiedRenderService:
         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
-        )
+        total = sum(UnifiedRenderService._clip_effective_duration(c) for c in main_layer.clips)
 
         # 减去转场重叠时间（粗略估算）
         n_clips = len(main_layer.clips)
@@ -547,30 +620,36 @@ class UnifiedRenderService:
         return True
 
     def _render_pass_through(
-        self, layers: list[RenderLayer], output_path: Path, *, ass_path: Path | None = None
-    ) -> None:
-        """单图层单 clip 直通渲染（使用 -vf 而非 -filter_complex）。
+        self,
+        layers: list[RenderLayer],
+        output_path: Path,
+        *,
+        ass_path: Path | None = None,
+        video_duration: float = 0.0,
+    ) -> bool:
+        """单图层单 clip 直通渲染（使用 -vf 而非 -filter_complex），一次性输出带音频的最终视频。
 
-        性能优化：避免 filter_complex 的解析和调度开销，
-        对于一镜到底场景性能提升 ~30%，接近链路A水平。
+        性能优化：
+        - 避免 filter_complex 的解析和调度开销，单clip场景性能提升 ~30%
+        - 视频+音频一次FFmpeg调用完成，省去后续音频提取+音视频合并两次调用
 
         Args:
             layers: 图层列表（只有1个图层1个clip）
             output_path: 输出文件路径
             ass_path: ASS 字幕文件路径，有则叠加字幕
+            video_duration: 视频总时长（用于截断音频，0表示不额外截断）
+
+        Returns:
+            True 表示输出包含音频（近似判断，实际以输出文件为准）
         """
         clip = layers[0].clips[0]
         role = layers[0].role
 
-        # 构建滤镜链（与 _build_filter_complex 中预处理逻辑一致）
+        # 构建视频滤镜链（与 _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
+        effective_duration = UnifiedRenderService._clip_effective_duration(clip)
 
         if effective_duration > 0:
             filters.append(f"trim=duration={effective_duration}")
@@ -592,12 +671,16 @@ class UnifiedRenderService:
 
         # 字幕叠加
         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)
 
+        # 最终输出时长：取 clip 有效时长和 video_duration 的较小值
+        final_duration = effective_duration
+        if video_duration > 0 and (final_duration <= 0 or final_duration > video_duration):
+            final_duration = video_duration
+
         command = [
             FFMPEG_BIN,
             "-y",
@@ -615,16 +698,27 @@ class UnifiedRenderService:
             "yuv420p",
             "-movflags",
             "+faststart",
-            "-an",  # 直通模式暂不处理音频，音频统一在后续混音阶段处理
-            str(output_path),
         ]
 
+        # 音频处理：background 通常是图片无音频，跳过；其他编码为 aac
+        # background 以外的视频素材，默认带音频
+        has_audio = role != "background"
+        if has_audio:
+            command.extend(["-c:a", "aac", "-b:a", "128k"])
+
+        # 统一截断时长（同时作用于视频和音频）
+        if final_duration > 0:
+            command.extend(["-t", f"{final_duration:.3f}"])
+
+        command.append(str(output_path))
+
         logger.info(
-            "直通渲染: plan_id=%s clip=%s role=%s duration=%.2fs",
+            "直通渲染: plan_id=%s clip=%s role=%s duration=%.2fs has_audio=%s",
             self.plan.id,
             clip.clip_id,
             role,
             effective_duration,
+            has_audio,
         )
         try:
             run_ffmpeg(command)
@@ -638,6 +732,8 @@ class UnifiedRenderService:
             )
             raise
 
+        return has_audio
+
     # ── 内部方法 ──────────────────────────────────────────────────────────────
 
     def _resolve_clips(self) -> list[ResolvedClip]:
@@ -759,14 +855,7 @@ class UnifiedRenderService:
             filters: list[str] = []
 
             # trim — 始终将输出截断到有效时长，防止 xfade offset 与实际时长不匹配
-            # 有效时长 = 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
-                )
-            elif clip.actual_duration > 0:
-                effective_duration = clip.actual_duration
+            effective_duration = UnifiedRenderService._clip_effective_duration(clip)
 
             if effective_duration > 0:
                 filters.append(f"trim=duration={effective_duration}")
@@ -803,14 +892,7 @@ class UnifiedRenderService:
             layer_clip_indices = [all_clips.index(c) for c in layer.clips]
             layer_labels = [preprocessed_labels[i] for i in layer_clip_indices]
             # 使用 trim 后的有效时长，与 Step 1 的 trim=duration 保持一致
-            layer_durations = []
-            for i in layer_clip_indices:
-                c = all_clips[i]
-                if c.duration > 0:
-                    eff = min(c.duration, c.actual_duration) if c.actual_duration > 0 else c.duration
-                else:
-                    eff = c.actual_duration if c.actual_duration > 0 else 0.0
-                layer_durations.append(eff)
+            layer_durations = [UnifiedRenderService._clip_effective_duration(all_clips[i]) for i in layer_clip_indices]
             layer_transitions = [all_clips[i].transition_effect for i in layer_clip_indices]
 
             if len(layer_labels) == 1:
@@ -930,7 +1012,7 @@ class UnifiedRenderService:
             raise
 
     def _probe_output(self, output_path: Path) -> tuple[float, int, int, int]:
-        """探测输出文件的时长、大小、宽高。
+        """探测输出文件的时长、大小、宽高.
 
         Returns:
             (duration, file_size, width, height)
@@ -943,3 +1025,304 @@ class UnifiedRenderService:
             info["width"],
             info["height"],
         )
+
+    # ── 音频后处理 ────────────────────────────────────────────────────────
+
+    def _mix_audio(self, layers: list[RenderLayer], video_duration: float) -> Path | None:
+        """音频后处理混音.
+
+        处理逻辑：
+        1. 主音频源按优先级查找：main > broll（background 不参与主音频，通常是图片无音轨）
+        2. 主图层音频按顺序 concat 拼接
+        3. 独立音频轨（audio role）用 amix 混入
+        4. 输出时长截断到 video_duration
+        5. 无音频流的 clip 会被自动跳过，避免 FFmpeg 引用 [i:a] 失败
+
+        Args:
+            layers: 图层列表
+            video_duration: 视频总时长（用于截断音频）
+
+        Returns:
+            混音后的音频文件路径，无音频时返回 None
+        """
+        # 按优先级精确查找主音频图层：main > broll
+        # background 不参与主音频（通常是静态图片，无音轨）
+        layer_map = {layer.role: layer for layer in layers}
+        main_layer = None
+        for role in ("main", "broll"):
+            if role in layer_map and layer_map[role].clips:
+                main_layer = layer_map[role]
+                break
+
+        main_clips: list[ResolvedClip] = main_layer.clips if main_layer else []
+
+        # 没有主视频图层时兜底：检查 overlay/corner_voice 层是否有带音频的素材
+        if not main_clips:
+            for role in ("overlay", "corner_voice"):
+                if role in layer_map and layer_map[role].clips:
+                    main_clips = layer_map[role].clips
+                    break
+
+        # 收集独立音频轨
+        audio_clips: list[ResolvedClip] = []
+        if "audio" in layer_map:
+            audio_clips = layer_map["audio"].clips
+
+        # ── 防御：过滤掉无音频流的 clip ──
+        # 源视频可能没有音频流（如静音视频、纯图片转的视频），直接引用 [i:a] 会导致 FFmpeg 失败
+        main_clips = [c for c in main_clips if self._clip_has_audio(c)]
+        audio_clips = [c for c in audio_clips if self._clip_has_audio(c)]
+
+        if not main_clips and not audio_clips:
+            return None
+
+        # 构建音频处理命令
+        output_path = self.work_dir / f"audio_{self.plan.id}.aac"
+
+        # 简单场景：只有主图层 + 无独立音频 → 直接从视频提取音频并拼接
+        if main_clips and not audio_clips:
+            self._concat_main_audio(main_clips, output_path, video_duration)
+            return output_path
+
+        # 有独立音频轨 → amix 混音
+        self._mix_with_independent_audio(main_clips, audio_clips, output_path, video_duration)
+        return output_path
+
+    def _concat_main_audio(self, clips: list[ResolvedClip], output_path: Path, video_duration: float) -> None:
+        """主图层音频 concat 拼接（对齐链路A行为）.
+
+        每个 clip 提取音频 → trim → 按顺序 concat。
+        """
+        if len(clips) == 1:
+            # 单 clip，直接提取音频，截断到 min(clip有效时长, 视频总时长)
+            clip = clips[0]
+            effective_duration = self._clip_effective_duration(clip)
+            # 最终时长：取 clip 有效时长和视频总时长的较小值
+            # （视频总时长由主图层决定，但单 clip 场景下两者应该一致，仍做保护）
+            final_duration = effective_duration
+            if video_duration > 0 and (final_duration <= 0 or final_duration > video_duration):
+                final_duration = video_duration
+
+            command = [
+                FFMPEG_BIN,
+                "-y",
+                "-i",
+                str(clip.local_path),
+                "-vn",
+                "-acodec",
+                "aac",
+                "-b:a",
+                "128k",
+            ]
+            if final_duration > 0:
+                command.extend(["-t", f"{final_duration:.3f}"])
+            command.append(str(output_path))
+            run_ffmpeg(command)
+            return
+
+        # 多 clip，用 filter_complex concat
+        input_args: list[str] = []
+        filter_parts: list[str] = []
+
+        for i, clip in enumerate(clips):
+            input_args.extend(["-i", str(clip.local_path)])
+            effective_duration = self._clip_effective_duration(clip)
+            if effective_duration > 0:
+                filter_parts.append(f"[{i}:a]atrim=0:{effective_duration:.3f},asetpts=PTS-STARTPTS[a{i}]")
+            else:
+                filter_parts.append(f"[{i}:a]asetpts=PTS-STARTPTS[a{i}]")
+
+        audio_labels = "".join(f"[a{i}]" for i in range(len(clips)))
+        filter_parts.append(f"{audio_labels}concat=n={len(clips)}:v=0:a=1[outa]")
+
+        # 截断到视频总时长
+        if video_duration > 0:
+            filter_parts.append(f"[outa]atrim=0:{video_duration:.3f}[final_audio]")
+            final_label = "final_audio"
+        else:
+            final_label = "outa"
+
+        filter_complex = ";".join(filter_parts)
+
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            *input_args,
+            "-filter_complex",
+            filter_complex,
+            "-map",
+            f"[{final_label}]",
+            "-acodec",
+            "aac",
+            "-b:a",
+            "128k",
+            str(output_path),
+        ]
+        run_ffmpeg(command)
+
+    def _mix_with_independent_audio(
+        self,
+        main_clips: list[ResolvedClip],
+        audio_clips: list[ResolvedClip],
+        output_path: Path,
+        video_duration: float,
+    ) -> None:
+        """主音频 + 独立音频轨 amix 混音.
+
+        Args:
+            main_clips: 主视频 clips（提取音频后 concat）
+            audio_clips: 独立音频轨 clips
+            output_path: 输出路径
+            video_duration: 视频总时长
+        """
+        input_args: list[str] = []
+        filter_parts: list[str] = []
+        mix_labels: list[str] = []
+
+        input_idx = 0
+
+        # 1. 主图层音频 concat
+        if main_clips:
+            for clip in main_clips:
+                input_args.extend(["-i", str(clip.local_path)])
+                effective_duration = self._clip_effective_duration(clip)
+                if effective_duration > 0:
+                    filter_parts.append(
+                        f"[{input_idx}:a]atrim=0:{effective_duration:.3f},asetpts=PTS-STARTPTS[ma{input_idx}]"
+                    )
+                else:
+                    filter_parts.append(f"[{input_idx}:a]asetpts=PTS-STARTPTS[ma{input_idx}]")
+                input_idx += 1
+
+            if len(main_clips) == 1:
+                mix_labels.append("ma0")
+            else:
+                main_labels = "".join(f"[ma{i}]" for i in range(len(main_clips)))
+                filter_parts.append(f"{main_labels}concat=n={len(main_clips)}:v=0:a=1[main_audio]")
+                mix_labels.append("main_audio")
+
+        # 2. 独立音频轨
+        for j, clip in enumerate(audio_clips):
+            input_args.extend(["-i", str(clip.local_path)])
+            effective_duration = self._clip_effective_duration(clip)
+            volume = clip.config.get("volume", 1.0) if clip.config else 1.0
+            label = f"ia{j}"
+            filters = []
+            if effective_duration > 0:
+                filters.append(f"atrim=0:{effective_duration:.3f}")
+            filters.append("asetpts=PTS-STARTPTS")
+            if volume != 1.0:
+                filters.append(f"volume={volume}")
+            filter_parts.append(f"[{input_idx}:a]{','.join(filters)}[{label}]")
+            mix_labels.append(label)
+            input_idx += 1
+
+        # 3. amix 混音
+        mix_inputs = "".join(f"[{label}]" for label in mix_labels)
+        n_inputs = len(mix_labels)
+        # normalized=0 保持音量，duration=shortest 取最短
+        filter_parts.append(f"{mix_inputs}amix=inputs={n_inputs}:duration=longest:normalize=0[mixed_audio]")
+
+        # 4. 截断到视频时长
+        if video_duration > 0:
+            filter_parts.append(f"[mixed_audio]atrim=0:{video_duration:.3f}[final_audio]")
+            final_label = "final_audio"
+        else:
+            final_label = "mixed_audio"
+
+        filter_complex = ";".join(filter_parts)
+
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            *input_args,
+            "-filter_complex",
+            filter_complex,
+            "-map",
+            f"[{final_label}]",
+            "-acodec",
+            "aac",
+            "-b:a",
+            "128k",
+            str(output_path),
+        ]
+
+        logger.info(
+            "音频混音: plan_id=%s main_clips=%d audio_clips=%d",
+            self.plan.id,
+            len(main_clips),
+            len(audio_clips),
+        )
+        try:
+            run_ffmpeg(command)
+        except subprocess.CalledProcessError as e:
+            logger.error(
+                "音频混音失败: plan_id=%s exit_code=%d\nfilter_complex:\n%s",
+                self.plan.id,
+                e.returncode,
+                filter_complex[:3000],
+            )
+            raise
+
+    def _merge_audio_video(self, video_path: Path, audio_path: Path, output_path: Path) -> None:
+        """将音频合并到视频中（视频流拷贝，音频直接复用）.
+
+        Args:
+            video_path: 无声视频路径
+            audio_path: 音频文件路径
+            output_path: 输出文件路径
+        """
+        command = [
+            FFMPEG_BIN,
+            "-y",
+            "-i",
+            str(video_path),
+            "-i",
+            str(audio_path),
+            "-c:v",
+            "copy",
+            "-c:a",
+            "aac",
+            "-b:a",
+            "128k",
+            "-map",
+            "0:v:0",
+            "-map",
+            "1:a:0",
+            "-shortest",
+            "-movflags",
+            "+faststart",
+            str(output_path),
+        ]
+
+        logger.info("合并音视频: plan_id=%s", self.plan.id)
+        try:
+            run_ffmpeg(command)
+        except subprocess.CalledProcessError as e:
+            logger.error(
+                "合并音视频失败: plan_id=%s exit_code=%d",
+                self.plan.id,
+                e.returncode,
+            )
+            raise
+
+    @staticmethod
+    def _clip_effective_duration(clip: ResolvedClip) -> float:
+        """计算 clip 的有效时长."""
+        if clip.duration > 0:
+            return min(clip.duration, clip.actual_duration) if clip.actual_duration > 0 else clip.duration
+        return clip.actual_duration if clip.actual_duration > 0 else 0.0
+
+    def _clip_has_audio(self, clip: ResolvedClip) -> bool:
+        """探测 clip 是否有音频流（带缓存）.
+
+        避免同一个 clip 被多次 ffprobe 探测。
+        """
+        if not hasattr(self, "_audio_cache"):
+            self._audio_cache: dict[str, bool] = {}
+        key = str(clip.local_path)
+        if key not in self._audio_cache:
+            from .ffmpeg_utils import probe_has_audio
+
+            self._audio_cache[key] = probe_has_audio(clip.local_path)
+        return self._audio_cache[key]

apps/worker/worker_app/tasks/compose_video.py

@@ -61,10 +61,12 @@ def compose_video(self, job_id: str, **kwargs):
             return {"status": "error", "message": "Missing plan_id"}
 
         # 判断使用哪个渲染引擎
-        from worker_app.core.config import get_settings as get_worker_settings
+        # 优先级：Redis Feature Flag（白名单 > 百分比） > 环境变量默认
+        from video_processing.render_engine_resolver import get_render_engine_resolver
 
-        worker_settings = get_worker_settings()
-        engine = (worker_settings.render_engine or "legacy").lower()
+        resolver = get_render_engine_resolver()
+        user_id = job.created_by_user_id or None
+        engine = resolver.get_engine(user_id=user_id)
 
         if engine == "unified":
             return _compose_with_unified_engine(self, job_service, job, plan_id, db)
@@ -207,7 +209,12 @@ def _compose_with_unified_engine(task, job_service, job, plan_id: str, db) -> di
     }
     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)
+    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}
 
 

apps/worker/worker_app/tasks/edit_plan_generation.py

@@ -116,6 +116,15 @@ def render_edit_plan(self, plan_id: str) -> dict:
                 rendered_clip_ids: list[str] = []
                 failed_clip_ids: list[str] = []
 
+                # 预先批量查询所有素材的 storage_key（file_url）
+                from packages.adapters.sqlalchemy_impl.models import AssetModel
+
+                clip_asset_ids = [c.asset_id for c in clips if c.asset_id]
+                asset_storage_map: dict[str, str] = {}
+                if clip_asset_ids:
+                    assets = db.query(AssetModel).filter(AssetModel.id.in_(clip_asset_ids)).all()
+                    asset_storage_map = {a.id: a.file_url for a in assets if a.file_url}
+
                 for clip in clips:
                     if not clip.asset_id:
                         # 没有素材的片段跳过，标记为失败
@@ -129,10 +138,22 @@ def render_edit_plan(self, plan_id: str) -> dict:
                         rendered_clip_ids.append(clip.id)
                         continue
 
+                    storage_key = asset_storage_map.get(clip.asset_id)
+                    if not storage_key:
+                        logger.warning(
+                            "片段素材无 storage_key，跳过: clip_id=%s asset_id=%s",
+                            clip.id,
+                            clip.asset_id,
+                        )
+                        clip.mark_failed()
+                        clip_repo.update(clip)
+                        failed_clip_ids.append(clip.id)
+                        continue
+
                     # 下载素材
-                    ext = Path(clip.asset_id).suffix or ".mp4"
+                    ext = Path(storage_key).suffix or ".mp4"
                     local_path = tmpdir_path / f"clip_{clip.order:04d}{ext}"
-                    if download_asset(clip.asset_id, local_path):
+                    if download_asset(storage_key, local_path):
                         asset_path_map[clip.asset_id] = local_path
                         rendered_clip_ids.append(clip.id)
                     else:

apps/worker/worker_app/tasks/generation.py

@@ -162,13 +162,15 @@ def _build_plan_and_clips_from_task(
     """
     plan = _VirtualPlan(id=task_id, name=f"Generated-{task_id[:8]}")
 
-    # 为每个下载路径生成合成 asset_id
+    # 为每个下载路径生成合成 asset_id，并预探测素材时长
     asset_path_map: dict[str, Path] = {}
     path_to_asset_id: dict[Path, str] = {}
+    path_duration: dict[Path, float] = {}
     for i, p in enumerate(downloaded_paths):
         asset_id = f"gen_{task_id[:8]}_{i:03d}{p.suffix or '.mp4'}"
         asset_path_map[asset_id] = p
         path_to_asset_id[p] = asset_id
+        path_duration[p] = probe_duration(p)
 
     clips: list[_VirtualClip] = []
     n = len(downloaded_paths)
@@ -184,6 +186,7 @@ def _build_plan_and_clips_from_task(
                     clip_type=clip_type,
                     order=i,
                     asset_id=path_to_asset_id[p],
+                    duration=path_duration[p],
                 )
             )
     elif mode == "voice_over":
@@ -196,6 +199,7 @@ def _build_plan_and_clips_from_task(
                     clip_type="main",
                     order=i,
                     asset_id=path_to_asset_id[p],
+                    duration=path_duration[p],
                     config={"role": "b_roll"},
                 )
             )
@@ -215,6 +219,7 @@ def _build_plan_and_clips_from_task(
                     clip_type=clip_type,
                     order=i,
                     asset_id=path_to_asset_id[p],
+                    duration=path_duration[p],
                 )
             )
     else:
@@ -227,6 +232,7 @@ def _build_plan_and_clips_from_task(
                     clip_type="main",
                     order=i,
                     asset_id=path_to_asset_id[p],
+                    duration=path_duration[p],
                 )
             )
 

packages/adapters/redis/__init__.py

@@ -1,3 +1,9 @@
+from packages.adapters.redis.feature_flag_store import (
+    FeatureFlagConfig,
+    FeatureFlagStore,
+    InMemoryFeatureFlagStore,
+    RedisFeatureFlagStore,
+)
 from packages.adapters.redis.session_store import (
     NoopSessionStore,
     RedisConfig,
@@ -5,4 +11,13 @@ from packages.adapters.redis.session_store import (
     get_session_store,
 )
 
-__all__ = ["NoopSessionStore", "RedisConfig", "SessionStore", "get_session_store"]
+__all__ = [
+    "FeatureFlagConfig",
+    "FeatureFlagStore",
+    "InMemoryFeatureFlagStore",
+    "NoopSessionStore",
+    "RedisConfig",
+    "RedisFeatureFlagStore",
+    "SessionStore",
+    "get_session_store",
+]

packages/adapters/redis/feature_flag_store.py

@@ -0,0 +1,259 @@
+"""Feature Flag 存储实现。
+
+支持两种后端：
+- RedisFeatureFlagStore：生产环境使用，支持多实例共享、热更新
+- InMemoryFeatureFlagStore：测试/开发环境使用，纯内存
+
+支持的 Flag 类型：
+- 全局开关（enabled: bool）
+- 白名单（whitelist: Set[str]，如 user_id 列表）
+- 百分比切流（percentage: 0-100，基于标识符哈希取模）
+
+判定优先级：白名单 > 百分比 > 全局开关
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import threading
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Optional, Set
+
+logger = logging.getLogger(__name__)
+
+# Redis key 前缀
+FEATURE_FLAG_REDIS_PREFIX = "feature_flag:"
+
+
+@dataclass
+class FeatureFlagConfig:
+    """单个 Feature Flag 的配置。"""
+
+    name: str
+    enabled: bool = False
+    percentage: int = 0  # 0-100
+    whitelist: Set[str] = field(default_factory=set)
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "enabled": self.enabled,
+            "percentage": self.percentage,
+            "whitelist": sorted(self.whitelist),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "FeatureFlagConfig":
+        return cls(
+            name=data["name"],
+            enabled=bool(data.get("enabled", False)),
+            percentage=int(data.get("percentage", 0)),
+            whitelist=set(data.get("whitelist", [])),
+        )
+
+    def is_active(self, identifier: Optional[str] = None) -> bool:
+        """判断当前 flag 是否激活。
+
+        判定优先级：
+        1. 全局关闭 → False
+        2. 白名单匹配 → True
+        3. 百分比命中 → True
+        4. 其他 → False
+
+        Args:
+            identifier: 用于白名单匹配和百分比哈希的标识符（如 user_id）。
+                       传 None 时只看全局开关 + 百分比（百分比用随机值）。
+        """
+        if not self.enabled:
+            return False
+
+        # 白名单：精确匹配
+        if identifier and identifier in self.whitelist:
+            return True
+
+        # 百分比：0 直接 False，100 直接 True
+        if self.percentage <= 0:
+            # 没有白名单且百分比为0 → 未启用
+            return False
+        if self.percentage >= 100:
+            return True
+
+        # 基于 identifier 做哈希取模，确保同一用户始终落在同一侧
+        if identifier:
+            hash_val = int(
+                hashlib.md5(f"{self.name}:{identifier}".encode("utf-8")).hexdigest(), 16  # nosec B324
+            )  # nosec B324 - 用于哈希取模做百分比切流，非安全用途
+            return (hash_val % 100) < self.percentage
+
+        # 无 identifier 且百分比在 0-100 之间 → 按比例随机（不保证一致性）
+        import random
+
+        return random.randint(0, 99) < self.percentage
+
+
+class FeatureFlagStore(ABC):
+    """Feature Flag 存储抽象接口。"""
+
+    @abstractmethod
+    def get(self, name: str) -> FeatureFlagConfig:
+        """获取指定 flag 的配置，不存在则返回默认配置（关闭状态）。"""
+        ...
+
+    @abstractmethod
+    def set(self, config: FeatureFlagConfig) -> None:
+        """设置 flag 配置。"""
+        ...
+
+    @abstractmethod
+    def delete(self, name: str) -> bool:
+        """删除 flag，返回是否成功删除。"""
+        ...
+
+    @abstractmethod
+    def list_all(self) -> dict[str, FeatureFlagConfig]:
+        """列出所有 flag。"""
+        ...
+
+    def is_active(self, name: str, identifier: Optional[str] = None) -> bool:
+        """便捷方法：判断 flag 是否激活。"""
+        return self.get(name).is_active(identifier)
+
+
+class InMemoryFeatureFlagStore(FeatureFlagStore):
+    """内存实现，用于测试和本地开发。"""
+
+    def __init__(self) -> None:
+        self._flags: dict[str, FeatureFlagConfig] = {}
+        self._lock = threading.Lock()
+
+    def get(self, name: str) -> FeatureFlagConfig:
+        with self._lock:
+            return self._flags.get(name, FeatureFlagConfig(name=name, enabled=False))
+
+    def set(self, config: FeatureFlagConfig) -> None:
+        with self._lock:
+            self._flags[config.name] = config
+
+    def delete(self, name: str) -> bool:
+        with self._lock:
+            if name in self._flags:
+                del self._flags[name]
+                return True
+            return False
+
+    def list_all(self) -> dict[str, FeatureFlagConfig]:
+        with self._lock:
+            return dict(self._flags)
+
+
+class RedisFeatureFlagStore(FeatureFlagStore):
+    """Redis 实现，支持多实例共享配置。
+
+    每个 flag 存在一个独立的 Redis hash key 中：
+      Key: feature_flag:{name}
+      Fields: enabled, percentage, whitelist(JSON array)
+    """
+
+    def __init__(self, redis_url: str, key_prefix: str = FEATURE_FLAG_REDIS_PREFIX) -> None:
+        import redis as redis_lib
+
+        self._redis = redis_lib.from_url(redis_url, decode_responses=True)
+        self._key_prefix = key_prefix
+        # 本地缓存 + TTL，减少 Redis 调用
+        self._cache: dict[str, tuple[FeatureFlagConfig, float]] = {}
+        self._cache_ttl = 5.0  # 秒，默认5秒本地缓存
+        self._lock = threading.Lock()
+
+    def _redis_key(self, name: str) -> str:
+        return f"{self._key_prefix}{name}"
+
+    def _parse_whitelist(self, raw: Optional[str]) -> Set[str]:
+        if not raw:
+            return set()
+        try:
+            data = json.loads(raw)
+            return set(data) if isinstance(data, list) else set()
+        except (json.JSONDecodeError, TypeError):
+            return set()
+
+    def get(self, name: str) -> FeatureFlagConfig:
+        now = time.time()
+
+        # 先查本地缓存
+        with self._lock:
+            cached = self._cache.get(name)
+            if cached and now - cached[1] < self._cache_ttl:
+                return cached[0]
+
+        # 从 Redis 读取
+        try:
+            key = self._redis_key(name)
+            data = self._redis.hgetall(key)
+            if not data:
+                config = FeatureFlagConfig(name=name, enabled=False)
+            else:
+                config = FeatureFlagConfig(
+                    name=name,
+                    enabled=(data.get("enabled", "0") in ("1", "true", "True")),
+                    percentage=int(data.get("percentage", 0)),
+                    whitelist=self._parse_whitelist(data.get("whitelist")),
+                )
+
+            # 写入本地缓存
+            with self._lock:
+                self._cache[name] = (config, now)
+
+            return config
+        except Exception as exc:
+            logger.warning("Failed to get feature flag %s from Redis: %s", name, exc)
+            # Redis 不可用时返回默认值（关闭），不影响业务
+            return FeatureFlagConfig(name=name, enabled=False)
+
+    def set(self, config: FeatureFlagConfig) -> None:
+        key = self._redis_key(config.name)
+        self._redis.hset(
+            key,
+            mapping={
+                "enabled": "1" if config.enabled else "0",
+                "percentage": str(config.percentage),
+                "whitelist": json.dumps(sorted(config.whitelist), ensure_ascii=False),
+            },
+        )
+        # 失效本地缓存
+        with self._lock:
+            self._cache.pop(config.name, None)
+
+    def delete(self, name: str) -> bool:
+        key = self._redis_key(name)
+        result = self._redis.delete(key)
+        with self._lock:
+            self._cache.pop(name, None)
+        return bool(result)
+
+    def list_all(self) -> dict[str, FeatureFlagConfig]:
+        pattern = f"{self._key_prefix}*"
+        result: dict[str, FeatureFlagConfig] = {}
+        try:
+            cursor = 0
+            while True:
+                cursor, keys = self._redis.scan(cursor=cursor, match=pattern, count=100)
+                for key in keys:
+                    name = key[len(self._key_prefix) :]
+                    result[name] = self.get(name)
+                if cursor == 0:
+                    break
+        except Exception as exc:
+            logger.warning("Failed to list feature flags from Redis: %s", exc)
+        return result
+
+    def invalidate_cache(self, name: Optional[str] = None) -> None:
+        """手动失效本地缓存。"""
+        with self._lock:
+            if name:
+                self._cache.pop(name, None)
+            else:
+                self._cache.clear()

tests/unit/test_feature_flag.py

@@ -0,0 +1,424 @@
+"""Feature Flag 单元测试。
+
+测试 FeatureFlagConfig、InMemoryFeatureFlagStore、RenderEngineResolver 的核心逻辑。
+"""
+
+from __future__ import annotations
+
+import time
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from packages.adapters.redis.feature_flag_store import (
+    FeatureFlagConfig,
+    InMemoryFeatureFlagStore,
+)
+
+# ── FeatureFlagConfig 测试 ──────────────────────────────────────────────────
+
+
+class TestFeatureFlagConfig:
+    """FeatureFlagConfig 核心逻辑测试。"""
+
+    def test_default_disabled(self):
+        """默认配置为关闭状态。"""
+        config = FeatureFlagConfig(name="test_flag")
+        assert config.enabled is False
+        assert config.percentage == 0
+        assert config.whitelist == set()
+        assert config.is_active() is False
+        assert config.is_active("user1") is False
+
+    def test_global_enabled_100_percent(self):
+        """100% + 启用 = 全部命中。"""
+        config = FeatureFlagConfig(name="test_flag", enabled=True, percentage=100)
+        assert config.is_active() is True
+        assert config.is_active("user1") is True
+        assert config.is_active("any_user") is True
+
+    def test_global_enabled_0_percent_no_whitelist(self):
+        """启用但 0% 且无白名单 = 不命中。"""
+        config = FeatureFlagConfig(name="test_flag", enabled=True, percentage=0)
+        assert config.is_active() is False
+        assert config.is_active("user1") is False
+
+    def test_whitelist_takes_priority(self):
+        """白名单优先级高于百分比。"""
+        config = FeatureFlagConfig(
+            name="test_flag",
+            enabled=True,
+            percentage=0,
+            whitelist={"user1", "user2"},
+        )
+        assert config.is_active("user1") is True
+        assert config.is_active("user2") is True
+        assert config.is_active("user3") is False
+
+    def test_whitelist_with_percentage(self):
+        """白名单用户即使百分比为0也命中，非白名单按百分比。"""
+        config = FeatureFlagConfig(
+            name="test_flag",
+            enabled=True,
+            percentage=100,  # 100% 所有人命中
+            whitelist={"user1"},
+        )
+        assert config.is_active("user1") is True
+        assert config.is_active("user999") is True  # 100% 命中
+
+    def test_percentage_consistency_same_user(self):
+        """同一用户多次调用结果一致（哈希确定性）。"""
+        config = FeatureFlagConfig(name="test_flag", enabled=True, percentage=50)
+        results = [config.is_active("user_fixed") for _ in range(100)]
+        assert all(r == results[0] for r in results)
+
+    def test_percentage_different_users_distributed(self):
+        """不同用户分布大致符合百分比（统计检验，宽松阈值）。"""
+        config = FeatureFlagConfig(name="test_flag", enabled=True, percentage=50)
+        active_count = sum(1 for i in range(1000) if config.is_active(f"user_{i}"))
+        # 50% 上下浮动 10% 都算合理
+        assert 400 <= active_count <= 600, f"Expected ~500, got {active_count}"
+
+    def test_percentage_boundary_0_and_100(self):
+        """0% 和 100% 的边界情况。"""
+        config_0 = FeatureFlagConfig(name="test", enabled=True, percentage=0)
+        config_100 = FeatureFlagConfig(name="test", enabled=True, percentage=100)
+
+        for i in range(100):
+            assert config_0.is_active(f"user_{i}") is False
+            assert config_100.is_active(f"user_{i}") is True
+
+    def test_disabled_ignores_all_other_settings(self):
+        """关闭时忽略白名单和百分比。"""
+        config = FeatureFlagConfig(
+            name="test_flag",
+            enabled=False,
+            percentage=100,
+            whitelist={"user1"},
+        )
+        assert config.is_active("user1") is False
+        assert config.is_active() is False
+
+    def test_none_identifier_with_percentage(self):
+        """无 identifier 时按随机比例（0% 和 100% 是确定的）。"""
+        config_0 = FeatureFlagConfig(name="test", enabled=True, percentage=0)
+        config_100 = FeatureFlagConfig(name="test", enabled=True, percentage=100)
+        assert config_0.is_active(None) is False
+        assert config_100.is_active(None) is True
+
+    def test_to_dict_and_from_dict(self):
+        """序列化和反序列化对称。"""
+        original = FeatureFlagConfig(
+            name="test_flag",
+            enabled=True,
+            percentage=30,
+            whitelist={"user_a", "user_b", "user_c"},
+        )
+        data = original.to_dict()
+        restored = FeatureFlagConfig.from_dict(data)
+        assert restored.name == original.name
+        assert restored.enabled == original.enabled
+        assert restored.percentage == original.percentage
+        assert restored.whitelist == original.whitelist
+
+    def test_from_dict_with_missing_fields(self):
+        """from_dict 缺失字段时使用默认值。"""
+        config = FeatureFlagConfig.from_dict({"name": "minimal"})
+        assert config.name == "minimal"
+        assert config.enabled is False
+        assert config.percentage == 0
+        assert config.whitelist == set()
+
+
+# ── InMemoryFeatureFlagStore 测试 ───────────────────────────────────────────
+
+
+class TestInMemoryFeatureFlagStore:
+    """内存存储实现测试。"""
+
+    def test_get_nonexistent_returns_default(self):
+        """获取不存在的 flag 返回默认配置（关闭）。"""
+        store = InMemoryFeatureFlagStore()
+        config = store.get("nonexistent")
+        assert config.name == "nonexistent"
+        assert config.enabled is False
+
+    def test_set_and_get(self):
+        """设置后可以读取。"""
+        store = InMemoryFeatureFlagStore()
+        config = FeatureFlagConfig(name="test", enabled=True, percentage=50, whitelist={"u1"})
+        store.set(config)
+
+        got = store.get("test")
+        assert got.enabled is True
+        assert got.percentage == 50
+        assert got.whitelist == {"u1"}
+
+    def test_delete_existing(self):
+        """删除存在的 flag 返回 True。"""
+        store = InMemoryFeatureFlagStore()
+        store.set(FeatureFlagConfig(name="test", enabled=True))
+        assert store.delete("test") is True
+        assert store.get("test").enabled is False
+
+    def test_delete_nonexistent(self):
+        """删除不存在的 flag 返回 False。"""
+        store = InMemoryFeatureFlagStore()
+        assert store.delete("nonexistent") is False
+
+    def test_list_all(self):
+        """列出所有 flag。"""
+        store = InMemoryFeatureFlagStore()
+        store.set(FeatureFlagConfig(name="flag_a", enabled=True))
+        store.set(FeatureFlagConfig(name="flag_b", percentage=10))
+
+        all_flags = store.list_all()
+        assert len(all_flags) == 2
+        assert "flag_a" in all_flags
+        assert "flag_b" in all_flags
+        assert all_flags["flag_a"].enabled is True
+
+    def test_is_active_convenience(self):
+        """is_active 便捷方法。"""
+        store = InMemoryFeatureFlagStore()
+        store.set(FeatureFlagConfig(name="render", enabled=True, percentage=0, whitelist={"vip_user"}))
+        assert store.is_active("render", "vip_user") is True
+        assert store.is_active("render", "normal_user") is False
+        assert store.is_active("nonexistent") is False
+
+
+# ── RenderEngineResolver 测试 ───────────────────────────────────────────────
+
+
+class TestRenderEngineResolver:
+    """渲染引擎选择器测试。"""
+
+    def test_default_legacy_when_flag_disabled(self):
+        """flag 关闭时使用默认引擎（legacy）。"""
+        store = InMemoryFeatureFlagStore()
+        resolver = self._make_resolver(store=store, default="legacy")
+        assert resolver.get_engine() == "legacy"
+        assert resolver.get_engine("user1") == "legacy"
+
+    def test_default_unified_when_flag_disabled(self):
+        """flag 关闭但默认值是 unified 时返回 unified。"""
+        store = InMemoryFeatureFlagStore()
+        resolver = self._make_resolver(store=store, default="unified")
+        assert resolver.get_engine() == "unified"
+
+    def test_whitelist_user_uses_unified(self):
+        """白名单用户走新引擎。"""
+        store = InMemoryFeatureFlagStore()
+        store.set(
+            FeatureFlagConfig(
+                name="render_engine",
+                enabled=True,
+                percentage=0,
+                whitelist={"beta_tester"},
+            )
+        )
+        resolver = self._make_resolver(store=store, default="legacy")
+        assert resolver.get_engine("beta_tester") == "unified"
+        assert resolver.get_engine("normal_user") == "legacy"
+
+    def test_100_percent_all_unified(self):
+        """100% 时所有用户走新引擎。"""
+        store = InMemoryFeatureFlagStore()
+        store.set(FeatureFlagConfig(name="render_engine", enabled=True, percentage=100))
+        resolver = self._make_resolver(store=store, default="legacy")
+        for i in range(50):
+            assert resolver.get_engine(f"user_{i}") == "unified"
+
+    def test_invalid_default_engine_fallback(self):
+        """无效默认值回退到 legacy。"""
+        store = InMemoryFeatureFlagStore()
+        resolver = self._make_resolver(store=store, default="invalid_value")
+        assert resolver.get_engine() == "legacy"
+
+    def test_should_use_unified_helper(self):
+        """should_use_unified 便捷方法。"""
+        store = InMemoryFeatureFlagStore()
+        store.set(
+            FeatureFlagConfig(
+                name="render_engine",
+                enabled=True,
+                percentage=0,
+                whitelist={"user_a"},
+            )
+        )
+        resolver = self._make_resolver(store=store)
+        assert resolver.should_use_unified("user_a") is True
+        assert resolver.should_use_unified("user_b") is False
+
+    def test_config_snapshot(self):
+        """配置快照。"""
+        store = InMemoryFeatureFlagStore()
+        store.set(
+            FeatureFlagConfig(
+                name="render_engine",
+                enabled=True,
+                percentage=30,
+                whitelist={"u1", "u2"},
+            )
+        )
+        resolver = self._make_resolver(store=store)
+        snapshot = resolver.get_config_snapshot()
+        assert snapshot["flag_name"] == "render_engine"
+        assert snapshot["enabled"] is True
+        assert snapshot["percentage"] == 30
+        assert snapshot["whitelist"] == ["u1", "u2"]
+
+    def test_set_flag_updates_config(self):
+        """通过 set_flag 修改后立即生效。"""
+        store = InMemoryFeatureFlagStore()
+        resolver = self._make_resolver(store=store, default="legacy")
+
+        # 初始：关闭
+        assert resolver.get_engine("user1") == "legacy"
+
+        # 开启 100%
+        resolver.set_flag(FeatureFlagConfig(name="render_engine", enabled=True, percentage=100))
+        assert resolver.get_engine("user1") == "unified"
+
+        # 关闭
+        resolver.set_flag(FeatureFlagConfig(name="render_engine", enabled=False))
+        assert resolver.get_engine("user1") == "legacy"
+
+    def test_force_refresh(self):
+        """强制刷新不报错。"""
+        store = InMemoryFeatureFlagStore()
+        resolver = self._make_resolver(store=store)
+        resolver.force_refresh()  # 不抛异常即可
+
+    def test_does_not_affect_in_flight_tasks(self):
+        """
+        热更新不影响在途任务验证：
+        任务开始时确定引擎，中途配置变更不改变当前任务的引擎选择。
+        （这是通过"每次调用 get_engine 时读取当前配置"来保证的，
+        任务开始时调用一次拿到结果，之后不再变化）
+        """
+        store = InMemoryFeatureFlagStore()
+        store.set(FeatureFlagConfig(name="render_engine", enabled=True, percentage=100))
+        resolver = self._make_resolver(store=store, default="legacy")
+
+        # 模拟任务开始时获取引擎
+        engine_at_start = resolver.get_engine("user1")
+        assert engine_at_start == "unified"
+
+        # 任务进行中关闭 flag
+        store.set(FeatureFlagConfig(name="render_engine", enabled=False))
+        resolver.force_refresh()
+
+        # 在途任务持有的 engine_at_start 仍然是 unified（不随配置变化）
+        assert engine_at_start == "unified"
+        # 新任务会拿到 legacy
+        assert resolver.get_engine("user1") == "legacy"
+
+    # ── 辅助方法 ──
+
+    @staticmethod
+    def _make_resolver(store=None, default="legacy"):
+        from apps.worker.video_processing.render_engine_resolver import (
+            RenderEngineResolver,
+        )
+
+        return RenderEngineResolver(
+            default_engine=default,
+            store=store or InMemoryFeatureFlagStore(),
+            refresh_interval=9999,  # 测试时禁用自动刷新
+        )
+
+
+# ── RedisFeatureFlagStore 降级测试（无 Redis 环境） ───────────────────────
+
+
+class TestRedisStoreDegradation:
+    """Redis 不可用时的降级行为测试。"""
+
+    def test_get_returns_default_when_redis_unavailable(self):
+        """Redis 连接失败时返回默认关闭配置，不抛异常。"""
+        import importlib
+
+        from packages.adapters.redis import feature_flag_store as ff_module
+
+        # 模拟 redis 模块不存在的场景不好做，这里直接测试异常捕获逻辑
+        store = ff_module.RedisFeatureFlagStore.__new__(ff_module.RedisFeatureFlagStore)
+        store._redis = MagicMock()
+        store._redis.hgetall.side_effect = ConnectionError("Redis down")
+        store._key_prefix = ff_module.FEATURE_FLAG_REDIS_PREFIX
+        store._cache = {}
+        store._cache_ttl = 5.0
+        import threading
+
+        store._lock = threading.Lock()
+
+        config = store.get("render_engine")
+        assert config.enabled is False
+        assert config.name == "render_engine"
+
+    def test_list_all_returns_empty_on_redis_error(self):
+        """Redis 错误时 list_all 返回空字典。"""
+        import importlib
+
+        from packages.adapters.redis import feature_flag_store as ff_module
+
+        store = ff_module.RedisFeatureFlagStore.__new__(ff_module.RedisFeatureFlagStore)
+        store._redis = MagicMock()
+        store._redis.scan.side_effect = ConnectionError("Redis down")
+        store._key_prefix = ff_module.FEATURE_FLAG_REDIS_PREFIX
+        store._cache = {}
+        store._cache_ttl = 5.0
+        import threading
+
+        store._lock = threading.Lock()
+
+        result = store.list_all()
+        assert result == {}
+
+
+class TestRedisStoreListAll:
+    """RedisFeatureFlagStore list_all 正常路径测试。"""
+
+    def _make_store(self):
+        from packages.adapters.redis import feature_flag_store as ff_module
+
+        store = ff_module.RedisFeatureFlagStore.__new__(ff_module.RedisFeatureFlagStore)
+        store._redis = MagicMock()
+        store._key_prefix = ff_module.FEATURE_FLAG_REDIS_PREFIX
+        store._cache = {}
+        store._cache_ttl = 5.0
+        import threading
+
+        store._lock = threading.Lock()
+        return store
+
+    def test_list_all_scan_with_match_param(self):
+        """list_all 调用 redis.scan 时使用正确的 match 参数名。"""
+        store = self._make_store()
+        prefix = store._key_prefix
+
+        # 模拟 scan 返回 2 个 key，分 2 次游标
+        store._redis.scan.side_effect = [
+            (10, [f"{prefix}render_engine", f"{prefix}other_flag"]),
+            (0, []),
+        ]
+        # 模拟 hgetall 返回配置
+        store._redis.hgetall.return_value = {
+            b"enabled": b"true",
+            b"percentage": b"50",
+            b"whitelist": b'["user1","user2"]',
+        }
+
+        result = store.list_all()
+
+        # 验证 scan 被调用了 2 次（游标遍历）
+        assert store._redis.scan.call_count == 2
+        # 验证参数名是 match（不是 match_pattern）
+        first_call_kwargs = store._redis.scan.call_args_list[0][1]
+        assert "match" in first_call_kwargs
+        assert "match_pattern" not in first_call_kwargs
+        assert first_call_kwargs["match"] == f"{prefix}*"
+        # 验证返回了 2 个 flag
+        assert len(result) == 2
+        assert "render_engine" in result
+        assert "other_flag" in result

tests/unit/test_render_adapter.py

@@ -13,7 +13,6 @@ from unittest.mock import MagicMock, patch
 import pytest
 from video_processing.render_adapter import RenderAdapter, RenderAdapterResult
 
-
 # ── Fixtures ──────────────────────────────────────────────────────────────────
 
 
@@ -243,6 +242,7 @@ class TestRenderPlan:
     @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)
@@ -295,6 +295,7 @@ class TestRenderPlan:
     @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")

tests/unit/test_unified_render_service.py

@@ -573,6 +573,8 @@ class TestPassThrough:
             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, "_mix_audio", return_value=None),
+            patch("shutil.copy2"),
             patch.object(svc, "_probe_output", return_value=(5.0, 1024, 1280, 720)),
         ):
             result = svc.render()
@@ -598,6 +600,8 @@ class TestPassThrough:
             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, "_mix_audio", return_value=None),
+            patch("shutil.copy2"),
             patch.object(svc, "_probe_output", return_value=(5.5, 2048, 1280, 720)),
         ):
             result = svc.render()
@@ -816,6 +820,8 @@ class TestRender:
             _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, "_mix_audio", return_value=None),
+            patch("shutil.copy2"),
             patch.object(svc, "_probe_output", return_value=(5.0, 1024, 1280, 720)),
         ):
             result = svc.render()
@@ -843,6 +849,8 @@ class TestRender:
             _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, "_mix_audio", return_value=None),
+            patch("shutil.copy2"),
             patch.object(svc, "_probe_output", return_value=(5.5, 2048, 1280, 720)),
         ):
             result = svc.render()
@@ -853,3 +861,541 @@ class TestRender:
         assert result.width == 1280
         assert result.height == 720
         mock_exec.assert_called_once()
+
+
+# ── 测试音频后处理 ──────────────────────────────────────────────────────────
+
+
+class TestAudioMixing:
+    """测试音频后处理混音功能。"""
+
+    def test_clip_effective_duration_with_both(self):
+        """指定时长和实际时长都有时取较小值。"""
+        clip = ResolvedClip(
+            clip_id="c1",
+            asset_id="a1",
+            local_path=Path("/tmp/c1.mp4"),
+            clip_type="main",
+            order=0,
+            duration=3.0,
+            actual_duration=5.0,
+        )
+        assert UnifiedRenderService._clip_effective_duration(clip) == 3.0
+
+    def test_clip_effective_duration_only_actual(self):
+        """只有实际时长时用实际时长。"""
+        clip = ResolvedClip(
+            clip_id="c1",
+            asset_id="a1",
+            local_path=Path("/tmp/c1.mp4"),
+            clip_type="main",
+            order=0,
+            duration=0.0,
+            actual_duration=5.0,
+        )
+        assert UnifiedRenderService._clip_effective_duration(clip) == 5.0
+
+    def test_clip_effective_duration_only_specified(self):
+        """只有指定时长时用指定时长。"""
+        clip = ResolvedClip(
+            clip_id="c1",
+            asset_id="a1",
+            local_path=Path("/tmp/c1.mp4"),
+            clip_type="main",
+            order=0,
+            duration=3.0,
+            actual_duration=0.0,
+        )
+        assert UnifiedRenderService._clip_effective_duration(clip) == 3.0
+
+    def test_clip_effective_duration_zero(self):
+        """都没有时返回0。"""
+        clip = ResolvedClip(
+            clip_id="c1",
+            asset_id="a1",
+            local_path=Path("/tmp/c1.mp4"),
+            clip_type="main",
+            order=0,
+            duration=0.0,
+            actual_duration=0.0,
+        )
+        assert UnifiedRenderService._clip_effective_duration(clip) == 0.0
+
+    def test_mix_audio_single_main_clip(self):
+        """单主clip时直接提取音频。"""
+        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("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 5.0)
+
+        assert result is not None
+        assert result.name == "audio_plan_001.aac"
+        mock_run.assert_called_once()
+        # 验证命令包含 -vn（无视频）和 aac 编码
+        cmd = mock_run.call_args[0][0]
+        assert "-vn" in cmd
+        assert "aac" in cmd
+
+    def test_mix_audio_multi_main_clips(self):
+        """多主clip时用concat拼接音频。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=3.0),
+            _make_clip("c2", "main", order=1, duration=2.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("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 4.5)
+
+        assert result is not None
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        # 验证有 filter_complex 和 concat
+        assert "-filter_complex" in cmd
+        cmd_str = " ".join(cmd)
+        assert "concat=n=2:v=0:a=1" in cmd_str
+
+    def test_mix_audio_with_independent_audio_track(self):
+        """有独立音频轨时用amix混音。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=5.0),
+            _make_clip(
+                "bgm1",
+                "main",
+                order=0,
+                duration=5.0,
+                config={"role": "audio", "volume": 0.5},
+            ),
+        ]
+        asset_paths = {
+            "asset_c1.mp4": Path("/tmp/asset_c1.mp4"),
+            "asset_bgm1.mp4": Path("/tmp/asset_bgm1.mp4"),
+        }
+        svc = _make_service(clips, asset_paths)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
+            patch("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 5.0)
+
+        assert result is not None
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        cmd_str = " ".join(cmd)
+        assert "amix" in cmd_str
+        assert "volume=0.5" in cmd_str
+
+    def test_mix_audio_no_audio_returns_none(self):
+        """没有音频素材时返回None。"""
+        # 构造一个没有音频的场景（比如纯文字）
+        clips = [_make_clip("t1", "title", order=0, duration=3.0)]
+        clips[0].asset_id = ""  # 无素材
+        asset_paths: dict[str, Path] = {}
+        svc = _make_service(clips, asset_paths)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=3.0),
+        ):
+            # 没有素材的clip会被跳过，layers为空
+            resolved = svc._resolve_clips()
+            layers = svc._group_clips_into_layers(resolved)
+            result = svc._mix_audio(layers, 3.0)
+
+        assert result is None
+
+    def test_mix_audio_background_not_used_as_main(self):
+        """background 图层不参与主音频，main 优先级更高。"""
+        clips = [
+            _make_clip("bg1", "background", order=0, duration=5.0),
+            _make_clip("c1", "main", order=0, duration=5.0),
+        ]
+        asset_paths = {
+            "asset_bg1.mp4": Path("/tmp/asset_bg1.mp4"),
+            "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("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 5.0)
+
+        assert result is not None
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        # 验证主音频源是 main 的 c1，不是 background 的 bg1
+        # 单 main clip 走直接提取路径，输入文件应该只有 c1
+        cmd_str = " ".join(cmd)
+        assert "asset_c1.mp4" in cmd_str
+        assert "asset_bg1.mp4" not in cmd_str
+
+    def test_mix_audio_main_priority_over_broll(self):
+        """main 图层优先级高于 broll。"""
+        clips = [
+            _make_clip("b1", "b_roll", order=0, duration=5.0),
+            _make_clip("c1", "main", order=0, duration=5.0),
+        ]
+        asset_paths = {
+            "asset_b1.mp4": Path("/tmp/asset_b1.mp4"),
+            "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("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 5.0)
+
+        assert result is not None
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        cmd_str = " ".join(cmd)
+        # 主音频源应该是 main 的 c1，不是 broll 的 b1
+        assert "asset_c1.mp4" in cmd_str
+        assert "asset_b1.mp4" not in cmd_str
+
+    def test_mix_audio_broll_used_when_no_main(self):
+        """没有 main 时，broll 作为主音频源。"""
+        clips = [_make_clip("b1", "b_roll", order=0, duration=5.0)]
+        asset_paths = {"asset_b1.mp4": Path("/tmp/asset_b1.mp4")}
+        svc = _make_service(clips, asset_paths)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
+            patch("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 5.0)
+
+        assert result is not None
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        assert "-vn" in cmd
+        assert "asset_b1.mp4" in " ".join(cmd)
+
+    def test_mix_audio_single_clip_truncated_to_video_duration(self):
+        """单clip音频截断到 video_duration（video_duration < clip有效时长）。"""
+        clips = [_make_clip("c1", "main", order=0, duration=10.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=10.0),
+            patch("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            # video_duration 只有 3.0，小于 clip 的 10.0
+            result = svc._mix_audio(layers, 3.0)
+
+        assert result is not None
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        # 验证 -t 参数是 3.0 不是 10.0
+        t_index = cmd.index("-t")
+        assert t_index >= 0
+        t_value = float(cmd[t_index + 1])
+        assert t_value == 3.0
+
+    def test_merge_audio_video(self):
+        """合并音视频命令正确。"""
+        svc = _make_service([], {})
+        video_path = Path("/tmp/video.mp4")
+        audio_path = Path("/tmp/audio.aac")
+        output_path = Path("/tmp/output.mp4")
+
+        with patch("video_processing.unified_render_service.run_ffmpeg") as mock_run:
+            svc._merge_audio_video(video_path, audio_path, output_path)
+
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        assert "-c:v" in cmd
+        assert "copy" in cmd
+        assert "-map" in cmd
+        assert "-shortest" in cmd
+
+    def test_render_calls_audio_mixing(self):
+        """多clip完整render流程会调用音频混音（非直通路径）。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=3.0),
+            _make_clip("c2", "main", order=1, duration=2.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"),
+            patch.object(svc, "_mix_audio", return_value=Path("/tmp/audio.aac")) as mock_mix,
+            patch.object(svc, "_merge_audio_video") as mock_merge,
+            patch.object(svc, "_probe_output", return_value=(5.0, 1024, 1280, 720)),
+        ):
+            result = svc.render()
+
+        mock_mix.assert_called_once()
+        mock_merge.assert_called_once()
+        assert result.duration == 5.0
+
+    def test_render_without_audio_copies_video(self):
+        """多clip无音频时走copy路径（非直通路径）。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=3.0),
+            _make_clip("c2", "main", order=1, duration=2.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"),
+            patch.object(svc, "_mix_audio", return_value=None),
+            patch("shutil.copy2") as mock_copy,
+            patch.object(svc, "_probe_output", return_value=(5.0, 1024, 1280, 720)),
+        ):
+            result = svc.render()
+
+        mock_copy.assert_called_once()
+        assert result.duration == 5.0
+
+    def test_render_pass_through_skips_audio_mix(self):
+        """直通场景下视频+音频一次完成，跳过 _mix_audio 和 _merge_audio_video。"""
+        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", return_value=True) as mock_pt,
+            patch.object(svc, "_mix_audio") as mock_mix,
+            patch.object(svc, "_merge_audio_video") as mock_merge,
+            patch("shutil.copy2") as mock_copy,
+            patch.object(svc, "_probe_output", return_value=(5.0, 1024, 1280, 720)),
+        ):
+            result = svc.render()
+
+        # 直通场景调用了 _render_pass_through，跳过了 _mix_audio / _merge / copy
+        mock_pt.assert_called_once()
+        mock_mix.assert_not_called()
+        mock_merge.assert_not_called()
+        mock_copy.assert_not_called()
+        assert result.duration == 5.0
+
+    def test_pass_through_main_has_aac_audio(self):
+        """直通main/broll场景输出带aac音频。"""
+        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("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._render_pass_through(layers, Path("/tmp/out.mp4"), video_duration=5.0)
+
+        assert result is True  # main 类型返回有音频
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        assert "-an" not in cmd  # 不再是无声
+        assert "aac" in cmd  # 有aac音频编码
+        assert "-b:a" in cmd
+
+    def test_pass_through_background_no_audio(self):
+        """直通background场景不带音频（图片素材）。"""
+        clips = [_make_clip("bg1", "background", order=0, duration=5.0)]
+        asset_paths = {"asset_bg1.mp4": Path("/tmp/asset_bg1.mp4")}
+        svc = _make_service(clips, asset_paths)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
+            patch("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._render_pass_through(layers, Path("/tmp/out.mp4"))
+
+        assert result is False  # background 返回无音频
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        assert "aac" not in cmd  # 没有音频编码参数
+
+    # ── 无音轨视频防御测试 ──
+
+    def test_mix_audio_main_no_audio_stream_returns_none(self):
+        """主图层clip无音频流且无独立音频轨时，返回None（不报错）。"""
+        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("video_processing.ffmpeg_utils.probe_has_audio", return_value=False),
+            patch("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 5.0)
+
+        assert result is None
+        # 没有音频流时不应调用 FFmpeg
+        mock_run.assert_not_called()
+
+    def test_mix_audio_partial_clips_no_audio_filtered(self):
+        """部分主图层clip无音频流时，过滤掉无音轨的，剩余有音频的正常concat。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=3.0),  # 无音频
+            _make_clip("c2", "main", order=1, duration=2.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)
+
+        # 模拟：c1 无音频，c2 有音频
+        def fake_has_audio(path):
+            return "c2" in str(path)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
+            patch("video_processing.ffmpeg_utils.probe_has_audio", side_effect=fake_has_audio),
+            patch("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 5.0)
+
+        assert result is not None
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        cmd_str = " ".join(cmd)
+        # 只剩 1 个有效音频 clip，走单clip路径（-vn），不走 filter_complex concat
+        assert "-vn" in cmd
+        assert "concat=n=2" not in cmd_str
+
+    def test_mix_audio_all_main_no_audio_but_independent_track(self):
+        """主图层全部无音频，但有独立音频轨时，正常走amix混音。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=5.0),  # 无音频
+            _make_clip(
+                "bgm1",
+                "main",
+                order=0,
+                duration=5.0,
+                config={"role": "audio", "volume": 0.5},
+            ),  # 独立音频轨（有音频）
+        ]
+        asset_paths = {
+            "asset_c1.mp4": Path("/tmp/asset_c1.mp4"),
+            "asset_bgm1.mp4": Path("/tmp/asset_bgm1.mp4"),
+        }
+        svc = _make_service(clips, asset_paths)
+
+        def fake_has_audio(path):
+            return "bgm" in str(path)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
+            patch("video_processing.ffmpeg_utils.probe_has_audio", side_effect=fake_has_audio),
+            patch("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 5.0)
+
+        assert result is not None
+        mock_run.assert_called_once()
+        cmd = mock_run.call_args[0][0]
+        cmd_str = " ".join(cmd)
+        # 只有独立音频轨参与混音，amix 输入数=1
+        assert "amix=inputs=1" in cmd_str
+
+    def test_mix_audio_both_no_audio_returns_none(self):
+        """主图层和独立音频轨都无音频时，返回None。"""
+        clips = [
+            _make_clip("c1", "main", order=0, duration=5.0),
+            _make_clip(
+                "bgm1",
+                "main",
+                order=0,
+                duration=5.0,
+                config={"role": "audio"},
+            ),
+        ]
+        asset_paths = {
+            "asset_c1.mp4": Path("/tmp/asset_c1.mp4"),
+            "asset_bgm1.mp4": Path("/tmp/asset_bgm1.mp4"),
+        }
+        svc = _make_service(clips, asset_paths)
+
+        with (
+            _patch_path_exists(),
+            patch("video_processing.unified_render_service.probe_duration", return_value=5.0),
+            patch("video_processing.ffmpeg_utils.probe_has_audio", return_value=False),
+            patch("video_processing.unified_render_service.run_ffmpeg") as mock_run,
+        ):
+            layers = svc._group_clips_into_layers(svc._resolve_clips())
+            result = svc._mix_audio(layers, 5.0)
+
+        assert result is None
+        mock_run.assert_not_called()
+
+    def test_clip_has_audio_cache(self):
+        """_clip_has_audio 带缓存，同一clip只探测一次。"""
+        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()
+            clip = resolved[0]
+
+        with patch("video_processing.ffmpeg_utils.probe_has_audio", return_value=True) as mock_probe:
+            # 调用 3 次
+            r1 = svc._clip_has_audio(clip)
+            r2 = svc._clip_has_audio(clip)
+            r3 = svc._clip_has_audio(clip)
+
+        assert r1 is True and r2 is True and r3 is True
+        # 实际只探测了 1 次
+        assert mock_probe.call_count == 1