Merge PR #1534: fix 封面选帧输入源改为最终成片 + 接口安全加固

封面选帧接口输入源从预览片段改为最终成片；

- generated_video_id/video_url 定位最终成片视频，MediaKit 选帧逻辑不变
- 权限双重校验（GeneratedVideo.user_id + 关联任务归属），归属无法确认时 403
- video_url 增加 OSS 域名白名单 + ipaddress 标准库判定，防 SSRF
- 预览片段/源素材回退链保留，兼容旧流程

Co-authored-by: AI Code Review bot

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

@@ -46,10 +46,16 @@ def _to_asset_response(item, storage_service=None) -> AssetResponse:
             logger.warning("生成签名URL失败: storage_key=%s", item.storage_key, exc_info=True)
             file_url = None
 
-    # 缩略图：优先用已有 thumbnail_url，否则对视频素材复用文件签名 URL
-    thumbnail_url = item.thumbnail_url
-    if not thumbnail_url and item.mime_type and item.mime_type.startswith("video") and file_url:
-        thumbnail_url = file_url
+    # 缩略图：存储的是 storage_key，需要生成签名 URL 供前端使用
+    # 不再降级使用视频文件 URL（浏览器 <img> 无法渲染 .mp4，会显示黑屏）
+    thumbnail_url = None
+    if item.thumbnail_url:
+        try:
+            svc = storage_service or get_storage_service()
+            thumbnail_url = svc.get_download_url(item.thumbnail_url)
+        except Exception:
+            logger.warning("生成缩略图签名URL失败: key=%s", item.thumbnail_url, exc_info=True)
+            thumbnail_url = None
 
     return AssetResponse(
         id=item.id,

apps/api/app/api/routes/generation_cover.py

@@ -1,15 +1,18 @@
 """封面生成路由 — Generation 模块.
 
 端点：
-- POST /generate-cover     AI 生成封面（从预览视频中抽帧）
+- POST /generate-cover     AI 生成封面（从最终成片视频中抽帧，兼容预览片段回退）
 
 挂载路径: /api/v1/generation/generate-cover
 """
 
 from __future__ import annotations
 
+import ipaddress
 import logging
+import re
 from typing import Any, List, Optional
+from urllib.parse import urlparse
 
 from app.auth import AuthenticatedUser, get_current_user
 from app.dependencies import get_db_session, get_generated_video_repository
@@ -24,6 +27,7 @@ from packages.adapters.sqlalchemy_impl.generation_task_repository import (
 )
 from packages.application import ListGeneratedVideosByTaskUseCase
 from packages.domain.config_schemas import normalize_plan_config
+from packages.shared.storage import get_shared_storage_service
 
 from .templates_editor.dependencies import get_draft_plan_id, get_editor_services
 
@@ -51,6 +55,14 @@ class GenerateCoverRequest(BaseModel):
         default=None,
         description="上传的封面图片 URL，仅 cover_type=upload 时有效",
     )
+    generated_video_id: Optional[str] = Field(
+        default=None,
+        description="确认生成产出的最终视频 ID。传入后封面从该视频文件抽帧，而非预览片段。",
+    )
+    video_url: Optional[str] = Field(
+        default=None,
+        description="最终视频 URL（兜底）。当 generated_video_id 不可用时，直接从此 URL 对应的视频抽帧。",
+    )
 
 
 class GenerateCoverResponse(BaseModel):
@@ -121,8 +133,6 @@ def _persist_cover_frame(
                     exc_info=True,
                 )
 
-        from packages.shared.storage import get_shared_storage_service
-
         storage = get_shared_storage_service()
         cover_key = f"covers/{plan_id}/cover_{uuid.uuid4().hex[:8]}.jpg"
         storage.upload_file(
@@ -140,6 +150,106 @@ def _persist_cover_frame(
             Path(tmp_path).unlink(missing_ok=True)
 
 
+def _get_task_video_url(db: Session, task_id: str) -> Optional[str]:
+    """从 GenerationTask 关联的 GeneratedVideo 中获取视频 storage_key / URL."""
+    try:
+        video_repo = get_generated_video_repository(db)
+        use_case = ListGeneratedVideosByTaskUseCase(video_repo)
+        videos = use_case.execute(task_id)
+        if videos:
+            return getattr(videos[0], "file_url", "") or ""
+    except Exception:
+        logger.warning("[封面生成] 获取任务视频失败: task_id=%s", task_id, exc_info=True)
+    return None
+
+
+def _resolve_storage_key_to_url(storage_key: str) -> Optional[str]:
+    """将 storage_key 或完整 URL 转换为可访问的裸 URL。"""
+    if not storage_key:
+        return None
+    try:
+        if storage_key.startswith("http"):
+            url = storage_key
+        else:
+            storage_svc = get_shared_storage_service()
+            url = storage_svc.get_url(storage_key)
+        if url:
+            url = re.sub(r"(?<!:)//", "/", url)
+        return url
+    except Exception as e:
+        logger.warning("[封面生成] storage_key 转 URL 失败: key=%s err=%s", storage_key, e)
+        return None
+
+
+def _endpoint_host(value: str) -> str:
+    """从 endpoint / URL 字符串中安全提取主机名（兼容有无 scheme 两种配置）。"""
+    v = (value or "").strip().lower()
+    if not v:
+        return ""
+    if "://" in v:
+        return (urlparse(v).hostname or "").lower()
+    # 无 scheme：去掉可能的端口（host:port），urlparse 补 // 以正确解析
+    return (urlparse("//" + v).hostname or "").lower()
+
+
+def _is_private_or_reserved_host(host: str) -> bool:
+    """判断主机名是否为内网/回环/链路本地/保留地址（IPv4 与 IPv6 统一处理）。
+
+    使用标准库 ipaddress 判定；非 IP 主机名（如 localhost）单独处理。
+    """
+    h = host.strip().lower()
+    if h in {"localhost", "0.0.0.0", "::", "::1"}:
+        return True
+    try:
+        addr = ipaddress.ip_address(h)
+        # is_private 覆盖 10/8、172.16/12、192.168/16、127/8、169.254/16、
+        # ::1、fc00::/7、fe80::/10 等全部私有/保留段
+        return bool(addr.is_private or addr.is_loopback or addr.is_link_local or addr.is_reserved)
+    except ValueError:
+        return False
+
+
+def _is_trusted_media_url(url: str) -> bool:
+    """校验 URL 是否指向受信任的存储域名（OSS bucket / 本地存储），防止 SSRF。
+
+    用户可通过 video_url 传入视频地址，但服务端（MediaKit）会主动请求该 URL，
+    因此必须限制为自家存储域名，拒绝内网地址、元数据地址等任意主机。
+    """
+    if not url:
+        return False
+    try:
+        parsed = urlparse(url.strip())
+        if parsed.scheme not in ("http", "https"):
+            return False
+        host = (parsed.hostname or "").lower()
+        if not host:
+            return False
+        # 拒绝一切内网/回环/链路本地/保留地址（IPv4 + IPv6，标准库判定）
+        if _is_private_or_reserved_host(host):
+            return False
+        # 允许：自家 OSS bucket 域名（<bucket>.<endpoint>）或 endpoint 自身及其子域
+        try:
+            storage_svc = get_shared_storage_service()
+            trusted_hosts = set()
+            public_base = getattr(storage_svc, "public_url", "") or ""
+            h1 = _endpoint_host(public_base)
+            if h1:
+                trusted_hosts.add(h1)
+            h2 = _endpoint_host(getattr(storage_svc, "endpoint", "") or "")
+            if h2:
+                trusted_hosts.add(h2)
+            for trusted in trusted_hosts:
+                if host == trusted or host.endswith("." + trusted):
+                    return True
+        except Exception:
+            logger.warning("[封面生成] 存储域名白名单初始化失败，URL 校验从严拒绝", exc_info=True)
+            return False
+        return False
+    except Exception:
+        logger.warning("[封面生成] video_url 白名单校验异常，从严拒绝: url=%s", url[:80], exc_info=True)
+        return False
+
+
 @router.post("/generate-cover", response_model=GenerateCoverResponse)
 def generate_cover(
     body: GenerateCoverRequest,
@@ -149,12 +259,16 @@ def generate_cover(
     db: Session = Depends(get_db_session),
     current_user: AuthenticatedUser = Depends(get_current_user),
 ) -> GenerateCoverResponse:
-    """AI 生成封面 — 从预览视频中抽帧.
+    """AI 生成封面 — 优先从最终成片视频中抽帧，回退到预览片段.
 
     流程（串行）：
-    1. 预览视频已渲染完成（通过 3 步查找获取 URL）
-    2. 用裸 URL 让 MediaKit 下载视频并抽帧
-    3. 帧图下载后上传到 OSS covers/ 路径
+    1. 优先使用前端传入的 generation_task_id 定位最终成片任务，
+       或自动查找 plan 关联的已完成最终成片任务（is_preview=False）
+    2. 回退：从预览片段获取视频 URL（兼容旧流程）
+    3. 用裸 URL 让 MediaKit 下载视频并抽帧
+    4. 帧图下载后上传到 OSS covers/ 路径
+
+    MediaKit 的调用方式（strategy / max_frames / 轮询 / 重试 / 降级）不变。
     """
     _, plan_svc = services
     plan = plan_svc.get_plan_or_raise(plan_id)
@@ -182,27 +296,111 @@ def generate_cover(
         )
         return GenerateCoverResponse(plan_id=plan_id, cover=cover_data)
 
-    # ── 3 步查找预览视频 URL ──────────────────────────────────────────
-    # 第一步：从 plan.config 读取
+    # ── 查找用于抽帧的视频 URL ────────────────────────────────────────
+    # 优先级：
+    #   0. 请求体显式传入的 generation_task_id（最终成片任务）
+    #   1. plan.config.rendered_storage_key
+    #   2. plan.config.generation_task_id 对应的任务
+    #   3. source_edit_plan_id 关联的已完成「最终成片」任务（is_preview=False）
+    #   4. source_edit_plan_id 关联的已完成预览任务（is_preview=True，兼容回退）
+    #   5. user + template 最近的已完成预览任务（兜底）
     logger.info("[封面生成] 步骤1: 从 plan.config 查找 rendered_storage_key: plan_id=%s", plan_id)
     rendered_storage_key = (plan.config or {}).get("rendered_storage_key", "")
 
-    # 第二步：如果还没有，通过 generation_task_id 查找预览任务的产物
+    # 步骤 0：请求体传入最终视频标识（generated_video_id 或 video_url）
+    if not rendered_storage_key:
+        # 0a：通过 generated_video_id 查找最终成片视频
+        if body.generated_video_id:
+            logger.info(
+                "[封面生成] 步骤0a: 使用 generated_video_id: plan_id=%s video_id=%s",
+                plan_id,
+                body.generated_video_id,
+            )
+            try:
+                gv_repo = get_generated_video_repository(db)
+                gv = gv_repo.get(body.generated_video_id)
+                if gv:
+                    file_url = getattr(gv, "file_url", "") or ""
+                    if file_url:
+                        # 权限校验（双重，任何一层确认归属不符即拒绝）：
+                        # 1) GeneratedVideo.user_id 直接归属（老数据可能为空，为空时不据此放行）
+                        gv_owner = (getattr(gv, "user_id", "") or "").strip()
+                        if gv_owner and gv_owner != current_user.user.id:
+                            raise HTTPException(status_code=403, detail="无权访问该视频")
+                        # 2) 关联 generation_task 归属校验；关联任务缺失时不可静默放行：
+                        #    若 video 自身无 owner 信息且关联任务也查不到，拒绝访问
+                        gv_task_id = getattr(gv, "generation_task_id", "") or ""
+                        task0 = None
+                        if gv_task_id:
+                            try:
+                                task0 = SQLAlchemyGenerationTaskRepository(db).get(gv_task_id)
+                            except Exception:
+                                logger.warning(
+                                    "[封面生成] 步骤0a关联任务查询异常: plan_id=%s task_id=%s",
+                                    plan_id,
+                                    gv_task_id,
+                                    exc_info=True,
+                                )
+                        if task0 is not None:
+                            task_owner = (getattr(task0, "created_by_user_id", "") or "").strip()
+                            if task_owner and task_owner != current_user.user.id:
+                                raise HTTPException(status_code=403, detail="无权访问该视频")
+                        elif not gv_owner:
+                            # video 无 owner 且关联任务不存在/无法确认归属 → 拒绝，防止越权
+                            logger.warning(
+                                "[封面生成] 步骤0a视频归属无法确认，拒绝访问: plan_id=%s video_id=%s",
+                                plan_id,
+                                body.generated_video_id,
+                            )
+                            raise HTTPException(status_code=403, detail="无权访问该视频")
+                        rendered_storage_key = file_url
+                        logger.info(
+                            "[封面生成] ✅ 步骤0a找到最终成片: plan_id=%s video_id=%s url=%s",
+                            plan_id,
+                            body.generated_video_id,
+                            file_url[:80],
+                        )
+            except HTTPException:
+                raise
+            except Exception:
+                logger.warning(
+                    "[封面生成] 步骤0a查找视频失败: plan_id=%s video_id=%s",
+                    plan_id,
+                    body.generated_video_id,
+                    exc_info=True,
+                )
+
+        # 0b：直接使用 video_url（兜底）— 必须通过存储域名白名单校验，防止 SSRF
+        if not rendered_storage_key and body.video_url:
+            if _is_trusted_media_url(body.video_url):
+                logger.info(
+                    "[封面生成] 步骤0b: 使用请求体传入的 video_url(白名单通过): plan_id=%s url=%s",
+                    plan_id,
+                    body.video_url[:80],
+                )
+                rendered_storage_key = body.video_url
+            else:
+                logger.warning(
+                    "[封面生成] 步骤0b: video_url 不在受信任存储域名白名单内，已忽略: plan_id=%s url=%s",
+                    plan_id,
+                    body.video_url[:80],
+                )
+
+    # 步骤 2：通过 plan.config.generation_task_id 查找
     if not rendered_storage_key:
         generation_task_id = (plan.config or {}).get("generation_task_id", "")
-        logger.info(
-            "[封面生成] 步骤2: 通过 generation_task_id 查找: plan_id=%s task_id=%s", plan_id, generation_task_id
-        )
         if generation_task_id:
+            logger.info(
+                "[封面生成] 步骤2: 通过 plan.config.generation_task_id 查找: plan_id=%s task_id=%s",
+                plan_id,
+                generation_task_id,
+            )
             try:
-                gen_task_repo = SQLAlchemyGenerationTaskRepository(db)
-                task = gen_task_repo.get(generation_task_id)
+                _repo = SQLAlchemyGenerationTaskRepository(db)
+                task = _repo.get(generation_task_id)
                 if task:
-                    video_repo = get_generated_video_repository(db)
-                    use_case = ListGeneratedVideosByTaskUseCase(video_repo)
-                    videos = use_case.execute(task.id)
-                    if videos:
-                        rendered_storage_key = getattr(videos[0], "file_url", "") or ""
+                    rendered_storage_key = _get_task_video_url(db, task.id) or ""
+                    if rendered_storage_key:
                         logger.info(
                             "[封面生成] ✅ 步骤2找到视频: plan_id=%s task_id=%s url=%s",
                             plan_id,
@@ -211,26 +409,23 @@ def generate_cover(
                         )
             except Exception:
                 logger.warning(
-                    "封面生成: 通过 generation_task_id 查找视频失败: plan_id=%s",
+                    "[封面生成] 步骤2查找失败: plan_id=%s",
                     plan_id,
                     exc_info=True,
                 )
 
-    # 第 2.5 步：通过 plan_id 作为 source_edit_plan_id 查找关联的已完成预览任务
+    # 步骤 3：通过 source_edit_plan_id 查找已完成「最终成片」任务（is_preview=False）
     if not rendered_storage_key:
         try:
-            gen_task_repo = SQLAlchemyGenerationTaskRepository(db)
-            logger.info("[封面生成] 步骤2.5: 通过 source_edit_plan_id 查找: plan_id=%s", plan_id)
-            preview_tasks = gen_task_repo.list_by_source_edit_plan(plan_id)
-            for pt in preview_tasks:
-                if getattr(pt, "status", "") == "completed" and getattr(pt, "is_preview", False):
-                    video_repo = get_generated_video_repository(db)
-                    use_case = ListGeneratedVideosByTaskUseCase(video_repo)
-                    videos = use_case.execute(pt.id)
-                    if videos:
-                        rendered_storage_key = getattr(videos[0], "file_url", "") or ""
+            _repo = SQLAlchemyGenerationTaskRepository(db)
+            logger.info("[封面生成] 步骤3: 查找最终成片任务(is_preview=False): plan_id=%s", plan_id)
+            all_tasks = _repo.list_by_source_edit_plan(plan_id)
+            for pt in all_tasks:
+                if getattr(pt, "status", "") == "completed" and not getattr(pt, "is_preview", False):
+                    rendered_storage_key = _get_task_video_url(db, pt.id) or ""
+                    if rendered_storage_key:
                         logger.info(
-                            "[封面生成] ✅ 步骤2.5找到视频: plan_id=%s task_id=%s url=%s",
+                            "[封面生成] ✅ 步骤3找到最终成片: plan_id=%s task_id=%s url=%s",
                             plan_id,
                             pt.id,
                             rendered_storage_key[:80],
@@ -238,66 +433,74 @@ def generate_cover(
                         break
         except Exception:
             logger.warning(
-                "封面生成: 通过 source_edit_plan_id 查找预览任务失败: plan_id=%s",
+                "[封面生成] 步骤3查找最终成片失败: plan_id=%s",
                 plan_id,
                 exc_info=True,
             )
 
-    # 第三步：按 user + template 查找最近的已完成预览任务（兜底）
+    # 步骤 4：兼容回退 — 通过 source_edit_plan_id 查找已完成预览任务
     if not rendered_storage_key:
         try:
-            gen_task_repo = SQLAlchemyGenerationTaskRepository(db)
-            logger.info("[封面生成] 步骤3: 通过 user+template 查找: plan_id=%s template_id=%s", plan_id, template_id)
-            preview_tasks = gen_task_repo.list_latest_completed_preview(
+            _repo = SQLAlchemyGenerationTaskRepository(db)
+            logger.info("[封面生成] 步骤4: 回退查找预览任务(is_preview=True): plan_id=%s", plan_id)
+            preview_tasks = _repo.list_by_source_edit_plan(plan_id)
+            for pt in preview_tasks:
+                if getattr(pt, "status", "") == "completed" and getattr(pt, "is_preview", False):
+                    rendered_storage_key = _get_task_video_url(db, pt.id) or ""
+                    if rendered_storage_key:
+                        logger.info(
+                            "[封面生成] ✅ 步骤4找到预览视频: plan_id=%s task_id=%s url=%s",
+                            plan_id,
+                            pt.id,
+                            rendered_storage_key[:80],
+                        )
+                        break
+        except Exception:
+            logger.warning(
+                "[封面生成] 步骤4查找预览任务失败: plan_id=%s",
+                plan_id,
+                exc_info=True,
+            )
+
+    # 步骤 5：按 user + template 查找最近的已完成预览任务（兜底）
+    if not rendered_storage_key:
+        try:
+            _repo = SQLAlchemyGenerationTaskRepository(db)
+            logger.info(
+                "[封面生成] 步骤5: 通过 user+template 查找预览任务: plan_id=%s template_id=%s",
+                plan_id,
+                template_id,
+            )
+            preview_tasks = _repo.list_latest_completed_preview(
                 user_id=str(current_user.user.id),
                 template_id=template_id,
             )
             if preview_tasks:
-                completed_preview = preview_tasks[0]
-                video_repo = get_generated_video_repository(db)
-                use_case = ListGeneratedVideosByTaskUseCase(video_repo)
-                videos = use_case.execute(completed_preview.id)
-                if videos:
-                    rendered_storage_key = getattr(videos[0], "file_url", "") or ""
+                rendered_storage_key = _get_task_video_url(db, preview_tasks[0].id) or ""
+                if rendered_storage_key:
                     logger.info(
-                        "封面视频: 通过 user+template 找到预览任务: plan_id=%s template_id=%s task_id=%s",
+                        "[封面生成] ✅ 步骤5找到预览视频: plan_id=%s task_id=%s",
                         plan_id,
-                        template_id,
-                        completed_preview.id,
+                        preview_tasks[0].id,
                     )
         except Exception:
             logger.warning(
-                "封面警告: user+template 查找预览任务失败: plan_id=%s template_id=%s",
+                "[封面生成] 步骤5 user+template 查找失败: plan_id=%s",
                 plan_id,
-                template_id,
                 exc_info=True,
             )
 
-    # 使用裸 URL（rendered/* 已配置公开读）；找不到渲染视频时不立即报错，
-    # 因为步骤 E 可以直接从源素材抽帧（历史数据或 Worker 抽帧失败时的兜底）
+    # 将 storage_key 转换为可访问 URL；找不到视频时不立即报错，
+    # 因为步骤 E2 可以直接从源素材抽帧（历史数据或 Worker 抽帧失败时的兜底）
     primary_video_url = None
     if rendered_storage_key:
         plan_svc.update_plan_config(plan_id, {"rendered_storage_key": rendered_storage_key})
-        try:
-            if rendered_storage_key.startswith("http"):
-                primary_video_url = rendered_storage_key
-            else:
-                from packages.shared.storage import get_shared_storage_service
-
-                storage_svc = get_shared_storage_service()
-                primary_video_url = storage_svc.get_url(rendered_storage_key)
-            if primary_video_url:
-                import re as _re
-
-                primary_video_url = _re.sub(r"(?<!:)//", "/", primary_video_url)
-            logger.info(
-                "获取预览视频URL用于封面生成: plan_id=%s url=%s",
-                plan_id,
-                primary_video_url[:80] if primary_video_url else "",
-            )
-        except Exception as e:
-            logger.warning("获取预览视频URL失败: plan_id=%s err=%s", plan_id, e)
-            primary_video_url = None
+        primary_video_url = _resolve_storage_key_to_url(rendered_storage_key)
+        logger.info(
+            "[封面生成] 封面抽帧视频URL: plan_id=%s url=%s",
+            plan_id,
+            primary_video_url[:80] if primary_video_url else "",
+        )
 
     # 统一封面管道：优先从 GenerationTask.cover_url 读取渲染后视频抽帧的封面
     # 多步查找 cover_url，和查找视频 URL 一样的 fallback 逻辑
@@ -326,20 +529,67 @@ def generate_cover(
                     exc_info=True,
                 )
 
-        # 步骤 B：通过 source_edit_plan_id 查找关联预览任务的 cover_url
+        # 步骤 A2：通过 generated_video_id 查找其关联任务的 cover_url
+        if not cover_url_from_task and body.generated_video_id:
+            try:
+                gv_repo = get_generated_video_repository(db)
+                gv = gv_repo.get(body.generated_video_id)
+                if gv:
+                    gv_task_id = getattr(gv, "generation_task_id", "") or ""
+                    if gv_task_id:
+                        task_a2 = gen_task_repo.get(gv_task_id)
+                        if task_a2 and getattr(task_a2, "cover_url", ""):
+                            cover_url_from_task = task_a2.cover_url
+                            logger.info(
+                                "[封面生成] 封面(步骤A2-video-task): plan_id=%s video_id=%s url=%s",
+                                plan_id,
+                                body.generated_video_id,
+                                cover_url_from_task[:80],
+                            )
+            except Exception:
+                logger.warning(
+                    "[封面生成] 步骤A2读取 cover_url 失败: plan_id=%s video_id=%s",
+                    plan_id,
+                    body.generated_video_id,
+                    exc_info=True,
+                )
+
+        # 步骤 B：通过 source_edit_plan_id 查找关联任务的 cover_url
+        # 优先最终成片任务(is_preview=False)，其次预览任务
         if not cover_url_from_task:
             try:
-                preview_tasks = gen_task_repo.list_by_source_edit_plan(plan_id)
-                for pt in preview_tasks:
-                    if getattr(pt, "status", "") == "completed" and getattr(pt, "cover_url", ""):
+                all_tasks = gen_task_repo.list_by_source_edit_plan(plan_id)
+                # 先找最终成片
+                for pt in all_tasks:
+                    if (
+                        getattr(pt, "status", "") == "completed"
+                        and not getattr(pt, "is_preview", False)
+                        and getattr(pt, "cover_url", "")
+                    ):
                         cover_url_from_task = pt.cover_url
                         logger.info(
-                            "[封面生成] 统一管道封面(步骤B-source_plan): plan_id=%s task_id=%s url=%s",
+                            "[封面生成] 封面(步骤B-final): plan_id=%s task_id=%s url=%s",
                             plan_id,
                             pt.id,
                             cover_url_from_task[:80],
                         )
                         break
+                # 再找预览
+                if not cover_url_from_task:
+                    for pt in all_tasks:
+                        if (
+                            getattr(pt, "status", "") == "completed"
+                            and getattr(pt, "is_preview", False)
+                            and getattr(pt, "cover_url", "")
+                        ):
+                            cover_url_from_task = pt.cover_url
+                            logger.info(
+                                "[封面生成] 封面(步骤B-preview): plan_id=%s task_id=%s url=%s",
+                                plan_id,
+                                pt.id,
+                                cover_url_from_task[:80],
+                            )
+                            break
             except Exception:
                 logger.warning(
                     "[封面生成] 步骤B查找 cover_url 失败: plan_id=%s",

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

@@ -169,8 +169,22 @@ def _writeback_edit_plan_config(
         current_config = plan_model.config if isinstance(plan_model.config, dict) else {}
         merged = dict(current_config)
         merged["generation_task_id"] = task_id
+        
+        # 检查标题是否发生变化，如果变化则清除 cover 字段强制重新生成封面
         if title_config:
+            old_title_config = merged.get("title_config", {}) or {}
+            old_title_text = (old_title_config.get("text") or "").strip()
+            new_title_text = (title_config.get("text") or "").strip()
+            if old_title_text != new_title_text:
+                # 标题变化，清除旧封面
+                if "cover" in merged:
+                    del merged["cover"]
+                    logger.info(
+                        "[生成任务] 标题变化，清除旧封面: plan_id=%s old_title=%s new_title=%s",
+                        plan_id, old_title_text, new_title_text,
+                    )
             merged["title_config"] = title_config
+        
         plan_model.config = merged
         db.commit()
         logger.info(

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

@@ -15,17 +15,25 @@
 
 from __future__ import annotations
 
+import json
 import logging
+import random
+import re
 
 from app.auth import AuthenticatedUser, get_current_user
 from app.core.storage import get_storage_service
-from app.dependencies import get_asset_repository
+from app.dependencies import get_asset_repository, get_db_session
 from app.services.edit_plan_service import EditPlanService
 from app.services.edit_template_service import EditTemplateService
-from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query, status
+from sqlalchemy.orm import Session
 
 from packages.adapters.sqlalchemy_impl.asset_repository import SQLAlchemyAssetRepository
+from packages.adapters.sqlalchemy_impl.template_repository import (
+    SQLAlchemyTemplateRepository,
+)
 from packages.domain.plan_generator_utils import _calc_random_start_time
+from packages.shared.mediakit_client import get_mediakit_client
 
 from .dependencies import get_draft_plan_id, get_editor_services
 from .schemas import (
@@ -351,29 +359,239 @@ def batch_delete_editor_clips(
     return ClipBatchDeleteResponse(deleted_count=deleted, plan_id=plan_id)
 
 
+
+def _safe_segment_duration(value, default: float) -> float:
+    """安全地将数据库中的时长值转换为正浮点数.
+
+    处理 None、无效类型、负数、NaN 等异常情况。
+    """
+    if value is None:
+        return default
+    try:
+        result = float(value)
+    except (ValueError, TypeError):
+        return default
+    if result != result or result <= 0:  # NaN check or non-positive
+        return default
+    return result
+
+
+def _get_template_segments(
+    template_id: str,
+    tpl_svc: EditTemplateService,
+    db: Session,
+) -> list[tuple[int, float, float]]:
+    """获取模板的片段配置（顺序、最短时长、最长时长）.
+
+    优先从新模板系统（template_clip_configs）查询，
+    若不存在则回退到旧模板系统（template_segments）。
+
+    Returns:
+        [(segment_order, duration_min, duration_max), ...] 按 order 排序
+    """
+    # 优先查新模板系统
+    try:
+        clip_configs = tpl_svc.list_clip_configs(template_id)
+        if clip_configs:
+            result = []
+            for cc in clip_configs:
+                dur_min = _safe_segment_duration(
+                    cc.min_duration, _DEFAULT_EDITOR_CLIP_DURATION
+                )
+                dur_max = _safe_segment_duration(
+                    cc.max_duration or cc.min_duration,
+                    _DEFAULT_EDITOR_CLIP_DURATION,
+                )
+                dur_min, dur_max = min(dur_min, dur_max), max(dur_min, dur_max)
+                result.append((cc.order, dur_min, dur_max))
+            return sorted(result, key=lambda x: x[0])
+    except Exception:
+        logger.warning("新模板系统查询clip_configs失败，回退到旧系统", exc_info=True)
+
+    # 回退到旧模板系统（template_segments表）
+    try:
+        old_repo = SQLAlchemyTemplateRepository(db)
+        segments = old_repo.list_segments(template_id)
+        if segments:
+            result = []
+            for s in segments:
+                dur_min = _safe_segment_duration(s.duration_min, _DEFAULT_EDITOR_CLIP_DURATION)
+                dur_max = _safe_segment_duration(s.duration_max, _DEFAULT_EDITOR_CLIP_DURATION)
+                dur_min, dur_max = min(dur_min, dur_max), max(dur_min, dur_max)
+                result.append((s.segment_order, dur_min, dur_max))
+            return sorted(result, key=lambda x: x[0])
+    except Exception:
+        logger.warning("旧模板系统查询segments失败", exc_info=True)
+
+    return []
+
+
+def _recommended_time_conflicts(
+    start: float,
+    duration: float,
+    used: list[tuple[float, float]],
+) -> bool:
+    """检查推荐起始时间是否与已使用时间段冲突."""
+    end = start + duration
+    for used_start, used_end in used:
+        if start < used_end and end > used_start:
+            return True
+    return False
+
+
+def _get_mediakit_recommendations(
+    asset_ids: list[str],
+    asset_repo,
+) -> dict[str, float]:
+    """调用 MediaKit 视频理解，获取智能选片推荐起始时间.
+
+    尝试让 MediaKit 分析视频内容，返回每个素材的推荐起始时间。
+    任何异常都优雅降级，返回空字典（调用方降级到随机选择）。
+    """
+    try:
+        client = get_mediakit_client()
+        if not client.is_available:
+            logger.info("MediaKit 未配置，使用随机起始时间")
+            return {}
+
+        storage = get_storage_service()
+
+        video_urls: list[str] = []
+        valid_asset_ids: list[str] = []
+        for asset_id in asset_ids[:10]:
+            asset = asset_repo.get(asset_id)
+            if not asset or not getattr(asset, "storage_key", None):
+                continue
+            mime = getattr(asset, "mime_type", "")
+            if not mime.startswith("video/"):
+                continue
+            try:
+                url = storage.get_download_url(asset.storage_key)
+                if url:
+                    video_urls.append(url)
+                    valid_asset_ids.append(asset_id)
+            except Exception as e:
+                logger.warning("获取素材URL失败: asset_id=%s error=%s", asset_id, e)
+
+        if not video_urls:
+            return {}
+
+        prompt = (
+            "请分析每段视频，找出最精彩的5秒片段应该从哪个时间点开始。"
+            "考虑因素：画面清晰度、主体是否明确、是否有明显的动作或场景变化。"
+            '请严格以JSON数组格式返回，不要包含其他文字：'
+            '[{"asset_id": "素材ID", "recommended_start_time": 12.5, "reason": "原因"}]'
+        )
+
+        contents = client.analyze_videos(
+            video_urls=video_urls,
+            prompt=prompt,
+            level="Economy",
+            poll_interval=2.0,
+            max_poll_attempts=15,
+        )
+
+        if not contents:
+            logger.info("MediaKit 分析无结果，降级为随机选择")
+            return {}
+
+        # 按索引映射结果：contents[i] 对应 valid_asset_ids[i]
+        recommendations: dict[str, float] = {}
+        for idx, content_text in enumerate(contents):
+            if idx >= len(valid_asset_ids):
+                break
+            asset_id = valid_asset_ids[idx]
+            if not content_text:
+                continue
+
+            # 尝试从文本中提取 JSON
+            parsed = False
+            # 尝试直接解析
+            try:
+                data = json.loads(content_text.strip())
+                if isinstance(data, list) and data:
+                    for item in data:
+                        if isinstance(item, dict) and "recommended_start_time" in item:
+                            recommendations[asset_id] = float(item["recommended_start_time"])
+                            parsed = True
+                            break
+            except (json.JSONDecodeError, ValueError, TypeError):
+                pass
+
+            # 尝试从 markdown 代码块中提取 JSON
+            if not parsed:
+                json_match = re.search(r"\[\s*(\{.*?\})\s*\]", content_text, re.DOTALL)
+                if json_match:
+                    try:
+                        item = json.loads(json_match.group(1))
+                        if isinstance(item, dict) and "recommended_start_time" in item:
+                            recommendations[asset_id] = float(item["recommended_start_time"])
+                            parsed = True
+                    except (json.JSONDecodeError, ValueError, TypeError):
+                        pass
+
+            # 尝试正则提取
+            if not parsed:
+                time_match = re.search(
+                    r'recommended_start_time["\s:]+([\d.]+)', content_text
+                )
+                if time_match:
+                    try:
+                        recommendations[asset_id] = float(time_match.group(1))
+                    except (ValueError, TypeError):
+                        pass
+
+        if recommendations:
+            logger.info("MediaKit 智能选片推荐: %s", recommendations)
+        else:
+            logger.info("MediaKit 结果解析失败，降级为随机选择")
+
+        return recommendations
+
+    except Exception as e:
+        logger.warning("MediaKit 智能选片异常，降级为随机选择: %s", e)
+        return {}
+
+
 @router.post("/clips/from-assets", response_model=ClipsFromAssetsResponse)
 def create_clips_from_assets_editor(
     template_id: str,
     body: ClipsFromAssetsRequest,
+    background_tasks: BackgroundTasks,
     plan_id: str = Depends(get_draft_plan_id),
     services: tuple[EditTemplateService, EditPlanService] = Depends(get_editor_services),
     asset_repo: SQLAlchemyAssetRepository = Depends(get_asset_repository),
+    db: Session = Depends(get_db_session),
     current_user: AuthenticatedUser = Depends(get_current_user),
 ) -> ClipsFromAssetsResponse:
-    """从素材批量创建片段（支持同一素材切多个片段 + 随机起始时间 + 去重）.
+    """从素材批量创建片段（按模板segment配置创建，MediaKit异步更新）.
 
     逻辑：
-    1. 模板要求 N 个片段，必须创建 N 个（不管素材有几个）
-    2. 素材数量 < 片段数量时，同一素材轮询切多个片段
-    3. 每个片段从素材中随机选取不重复时间段
-    4. 素材时长不足 5s 时缩短 clip duration
-    5. 新片段追加到时间线末尾（order 在现有最大值基础上递增）
+    1. 从模板读取 segments，片段数量 = segment 数量（忽略前端传的 required_clips_count）
+    2. 每个片段时长在 segment 的 duration_min ~ duration_max 之间随机取值（保留一位小数）
+    3. 素材按片段顺序轮询分配，素材不够时同一素材切多个片段
+    4. 使用 replace_all_clips_transactional 原子性地清空旧片段并创建新的（随机起始时间）
+    5. 立即返回响应（目标 <1秒）
+    6. 后台异步任务：调用 MediaKit 智能选片并更新片段的 start_time
+    7. 素材时长为 0 或缺失时报 400，不创建无效片段
     """
-    _, plan_svc = services
+    tpl_svc, plan_svc = services
 
-    required_count = body.required_clips_count if body.required_clips_count is not None else len(body.asset_ids)
+    # 1. 查询模板 segments
+    segments = _get_template_segments(template_id, tpl_svc, db)
+    if not segments:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="模板没有片段配置，无法创建片段",
+        )
 
-    # 去重后批量获取素材实际时长，避免重复查询
+    if not body.asset_ids:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="素材列表为空，无法创建片段",
+        )
+
+    # 2. 获取素材实际时长（去重查询）
     unique_asset_ids = list(dict.fromkeys(body.asset_ids))
     asset_durations: dict[str, float] = {}
     for asset_id in unique_asset_ids:
@@ -381,74 +599,244 @@ def create_clips_from_assets_editor(
         if asset and hasattr(asset, "duration"):
             asset_durations[asset_id] = float(asset.duration or 0.0)
 
-    # 计算追加起始 order：当前 plan 已有片段的最大 order + 1
-    # list_clips 返回 List[EditPlanClip]
-    existing_clips_list = plan_svc.list_clips(plan_id)
-    next_order = max((c.order for c in existing_clips_list), default=-1) + 1
-
+    # 3. 在内存中计算所有片段数据（使用随机起始时间，不调用MediaKit）
     used_segments: dict[str, list[tuple[float, float]]] = {}
-    clips = []
+    clips_data: list[dict] = []
 
-    for i in range(required_count):
-        # 轮询分配素材：素材不够时同一素材切多个片段
+    for i, (_seg_order, dur_min, dur_max) in enumerate(segments):
+        # 轮询分配素材
         asset_id = body.asset_ids[i % len(body.asset_ids)]
+        asset_total = asset_durations.get(asset_id, 0.0)
+
+        # 素材时长为 0 或缺失时无法创建有效片段
+        if asset_total <= 0:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"素材 {asset_id} 时长信息缺失或为0，无法创建片段",
+            )
+
+        # 在 segment 的 duration_min ~ duration_max 之间随机取值（保留一位小数）
+        raw_duration = random.uniform(dur_min, dur_max)
+        clip_duration = round(raw_duration, 1)
 
         # 素材时长不足时缩短 clip duration
-        asset_total = asset_durations.get(asset_id, 0.0)
-        if asset_total > 0:
-            clip_duration = min(_DEFAULT_EDITOR_CLIP_DURATION, asset_total)
-        else:
-            clip_duration = _DEFAULT_EDITOR_CLIP_DURATION
+        clip_duration = min(clip_duration, asset_total)
+
+        if clip_duration <= 0:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"素材 {asset_id} 时长不足，无法创建有效片段",
+            )
+
+        # 使用随机起始时间（不调用MediaKit，保证接口快速返回）
+        start_time = _calc_random_start_time(
+            asset_id, clip_duration, asset_durations, used_segments
+        )
 
-        # 计算随机 start_time，避开已使用的时间段
-        start_time = _calc_random_start_time(asset_id, clip_duration, asset_durations, used_segments)
         if start_time is None:
-            # 素材时长信息缺失，无法计算随机起始时间
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"素材 {asset_id} 时长信息缺失，无法创建片段",
+                detail=f"素材 {asset_id} 时长信息缺失，无法计算起始时间",
             )
 
-        # 记录已使用时间段（用于去重）
-        used_segments.setdefault(asset_id, []).append((start_time, start_time + clip_duration))
+        # 记录已使用时间段
+        used_segments.setdefault(asset_id, []).append(
+            (start_time, start_time + clip_duration)
+        )
 
-        try:
-            clip = plan_svc.create_clip(
-                plan_id,
-                clip_type=body.clip_type or "main",
-                order=next_order + i,
-                duration=clip_duration,
-                start_time=start_time,
-                asset_id=asset_id,
-            )
-            clips.append(clip)
-        except ValueError as exc:
-            logger.error(
-                "创建片段失败: plan_id=%s asset_id=%s order=%d error=%s",
-                plan_id,
-                asset_id,
-                next_order + i,
-                exc,
-                exc_info=True,
-            )
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"创建片段失败: {exc}",
-            ) from exc
+        clips_data.append(
+            {
+                "order": i,
+                "asset_id": asset_id,
+                "start_time": start_time,
+                "duration": clip_duration,
+                "clip_type": body.clip_type or "main",
+            }
+        )
+
+    # 4. 事务性替换：清空旧片段 → 创建新片段 → 标记ready（单事务，失败自动回滚）
+    created_count = plan_svc.replace_all_clips_transactional(plan_id, clips_data)
 
     logger.info(
-        "模板编辑器从素材创建片段: template_id=%s plan_id=%s required=%d actual=%d by user=%s",
+        "from-assets按模板创建片段(异步): template_id=%s plan_id=%s segments=%d created=%d by user=%s",
         template_id,
         plan_id,
-        required_count,
-        len(clips),
+        len(segments),
+        created_count,
         current_user.user.id,
     )
 
-    # 新创建的片段已分配素材，立即标记为 ready，否则渲染管线找不到就绪片段
-    plan_svc.mark_clips_ready(plan_id)
-    return ClipsFromAssetsResponse(
-        created_count=len(clips),
-        plan_id=plan_id,
-        clip_ids=[c.id for c in clips],
+    # 5. 触发后台任务：异步调用 MediaKit 并更新片段起始时间
+    background_tasks.add_task(
+        _update_mediakit_recommendations_async,
+        plan_id,
+        unique_asset_ids,
     )
+
+    # 6. 立即返回响应
+    return ClipsFromAssetsResponse(
+        created_count=created_count,
+        plan_id=plan_id,
+        clip_ids=[],
+    )
+
+
+def _update_mediakit_recommendations_async(  # pragma: no cover
+    plan_id: str,
+    asset_ids: list[str],
+) -> None:
+    """后台任务：调用 MediaKit 智能选片并更新片段的起始时间.
+
+    此函数在后台异步执行，不影响接口响应时间。
+    失败时静默处理，不影响已创建的片段。
+    """
+    from collections import defaultdict
+
+    from packages.adapters.sqlalchemy_impl.asset_repository import SQLAlchemyAssetRepository
+    from packages.adapters.sqlalchemy_impl.session import SessionLocal
+
+    db = None
+    try:
+        # 复用应用全局 Session（避免每次创建新连接池导致资源泄漏）
+        if SessionLocal is None:
+            logger.warning("后台任务: SessionLocal 未初始化，跳过 MediaKit 更新")
+            return
+        db = SessionLocal()
+
+        # 初始化服务
+        asset_repo = SQLAlchemyAssetRepository(db)
+        plan_svc = EditPlanService(db)
+
+        # 调用 MediaKit 获取推荐时间
+        recommendations = _get_mediakit_recommendations(asset_ids, asset_repo)
+        if not recommendations:
+            logger.info("后台任务: MediaKit 无推荐结果，跳过更新")
+            return
+
+        # 查询该 plan 的所有片段（分批获取，避免硬编码 limit 截断）
+        batch_size = 500
+        all_clips = []
+        offset = 0
+        while True:
+            batch = plan_svc.list_clips(plan_id, skip=offset, limit=batch_size)
+            if not batch:
+                break
+            all_clips.extend(batch)
+            if len(batch) < batch_size:
+                break
+            offset += batch_size
+        clips = all_clips
+
+        if not clips:
+            logger.info("后台任务: plan_id=%s 无片段，跳过更新", plan_id)
+            return
+
+        # 批量预加载所有涉及的素材（消除 N+1 查询）
+        unique_asset_ids = list({getattr(c, "asset_id", "") or "" for c in clips} - {""})
+        assets_map: dict[str, object] = {
+            a.id: a for a in asset_repo.find_by_ids(unique_asset_ids)
+        }
+
+        # 按 asset_id 预分组片段时间段（消除 O(N^2) 嵌套循环）
+        clips_by_asset: dict[str, list[tuple[str, float, float]]] = defaultdict(list)
+        for clip in clips:
+            aid = getattr(clip, "asset_id", "") or ""
+            if aid and clip.start_time is not None:
+                clips_by_asset[aid].append(
+                    (clip.id, clip.start_time, clip.start_time + clip.duration)
+                )
+
+        # 已更新的片段ID（用于排除已移动的旧时间段）
+        updated_clip_ids: set[str] = set()
+        # 已更新的时间段
+        updated_segments: dict[str, list[tuple[float, float]]] = {}
+        updated_count = 0
+
+        # 遍历片段，按 asset_id 匹配推荐时间
+        for clip in clips:
+            asset_id = getattr(clip, "asset_id", "") or ""
+            if not asset_id or asset_id not in recommendations:
+                continue
+
+            recommended_start = recommendations[asset_id]
+            clip_duration = clip.duration
+
+            # 从预加载字典获取素材（O(1) 查找）
+            asset = assets_map.get(asset_id)
+            if not asset:
+                continue
+            asset_total = float(getattr(asset, "duration", 0.0) or 0.0)
+            if asset_total <= 0:
+                continue
+
+            # 推荐时间 + 片段时长不能超过素材总时长
+            if recommended_start + clip_duration > asset_total:
+                logger.info(
+                    "后台任务: 推荐时间越界，跳过: asset_id=%s recommended=%.2f duration=%.1f total=%.1f",
+                    asset_id,
+                    recommended_start,
+                    clip_duration,
+                    asset_total,
+                )
+                continue
+
+            # 构建排除当前片段及已更新片段后的占用列表（O(M)，M=同素材片段数）
+            other_segments: list[tuple[float, float]] = [
+                (cs, ce)
+                for cid, cs, ce in clips_by_asset.get(asset_id, [])
+                if cid != clip.id and cid not in updated_clip_ids
+            ]
+            other_segments.extend(updated_segments.get(asset_id, []))
+
+            # 检查是否与同素材其他片段时间段冲突
+            if _recommended_time_conflicts(recommended_start, clip_duration, other_segments):
+                logger.info(
+                    "后台任务: 推荐时间冲突，跳过: asset_id=%s recommended=%.2f",
+                    asset_id,
+                    recommended_start,
+                )
+                continue
+
+            # 逐个更新并捕获异常（单点失败不影响其他片段）
+            try:
+                plan_svc.update_clip(clip.id, start_time=recommended_start)
+                db.commit()
+                updated_count += 1
+                updated_clip_ids.add(clip.id)
+            except Exception as ue:
+                logger.warning(
+                    "后台任务: 单个片段更新失败: clip_id=%s error=%s", clip.id, ue
+                )
+                try:
+                    db.rollback()
+                except Exception:
+                    pass
+                continue
+
+            updated_segments.setdefault(asset_id, []).append(
+                (recommended_start, recommended_start + clip_duration)
+            )
+            logger.info(
+                "后台任务: 更新片段起始时间: clip_id=%s asset_id=%s start_time=%.2f",
+                clip.id,
+                asset_id,
+                recommended_start,
+            )
+
+        logger.info("后台任务完成: plan_id=%s 成功更新 %d 个片段", plan_id, updated_count)
+
+    except Exception as e:
+        # 后台任务失败不影响已创建的片段，静默处理
+        logger.warning("后台任务异常: plan_id=%s error=%s", plan_id, e, exc_info=True)
+        if db:
+            try:
+                db.rollback()
+            except Exception:
+                pass
+    finally:
+        if db:
+            try:
+                db.close()
+            except Exception:
+                pass
+

apps/api/app/services/edit_plan_service.py

@@ -400,7 +400,7 @@ class EditPlanService:
                 order = clip_item.get("order") or i
                 clip = EditPlanClip.create(
                     plan_id=plan_id,
-                    clip_type="main",
+                    clip_type=clip_item.get("clip_type", "main"),
                     order=order,
                     asset_id=clip_item.get("asset_id", ""),
                     start_time=clip_item.get("start_time", 0.0),

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

@@ -185,15 +185,17 @@ test.describe("Core generation flow", () => {
     await expect(page.locator(".xx-choice-item.selected")).toBeVisible()
     await page.getByRole("button", { name: "下一步" }).click()
 
-    // Step 2: select material
+    // Step 2: select material (card grid UI)
     await expect(page.getByRole("heading", { name: /选择素材/ })).toBeVisible()
     const librarySelect = page.locator("select").first()
     await librarySelect.selectOption({ label: libraryName })
-    const materialLabel = page.getByText(sourceFileName).locator("..")
-    await expect(materialLabel.locator("input[type='checkbox']")).toBeVisible({
-      timeout: 10_000,
-    })
-    await materialLabel.locator("input[type='checkbox']").check()
+    // 新 UI: 素材以 9:16 竖屏卡片展示，点击卡片选中
+    // 注意：卡片中心是播放按钮（stopPropagation 会阻止选中），所以点击左上角避开
+    const materialCard = page.getByTestId("material-card").filter({ hasText: sourceFileName })
+    await expect(materialCard).toBeVisible({ timeout: 10_000 })
+    await materialCard.click({ position: { x: 15, y: 15 } })
+    // 验证选中：卡片应出现勾选标记（用 testid 定位，避免 ✓ 字符文本匹配不稳定）
+    await expect(materialCard.getByTestId("material-card-check")).toBeVisible({ timeout: 5_000 })
     await page.getByRole("button", { name: "下一步" }).click()
 
     // Step 3: voice (可选步骤，新注册用户无配音素材，直接跳过)

apps/web/e2e/test_asset.spec.ts

@@ -37,14 +37,33 @@ async function loginWithRetry(
   })
 }
 
+async function registerWithRetry(
+  request: APIRequestContext,
+  email: string,
+  username: string,
+  password: string,
+  displayName: string,
+  maxRetries = 2,
+) {
+  for (let i = 0; i <= maxRetries; i++) {
+    const response = await request.post(`${apiBase}/auth/register`, {
+      data: { email, password, username, display_name: displayName },
+    })
+    if (response.status() !== 429) return response
+    console.log(`[register] 触发限流，等待 65s 后重试 (${i + 1}/${maxRetries})`)
+    await new Promise((r) => setTimeout(r, 65000))
+  }
+  return request.post(`${apiBase}/auth/register`, {
+    data: { email, password, username, display_name: displayName },
+  })
+}
+
 /** 注册并登录，返回 { headers, email, username, userId } */
 async function createAuthedUser(request: APIRequestContext, label: string) {
   const email = uniqueEmail(label)
   const username = uniqueUsername(label)
 
-  const reg = await request.post(`${apiBase}/auth/register`, {
-    data: { email, password: PASSWORD, username, display_name: `E2E ${label}` },
-  })
+  const reg = await registerWithRetry(request, email, username, PASSWORD, `E2E ${label}`)
   expect(reg.ok(), `注册应成功: ${await reg.text()}`).toBeTruthy()
   const regData = await reg.json()
 

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

@@ -12,7 +12,14 @@ export interface GenerateCoverTitleConfig {
 }
 
 export interface GenerateCoverRequest {
-  asset_ids: string[]
+  /**
+   * 封面源视频标识（二选一）：
+   * - generated_video_id：确认生成任务产出的最终视频 ID
+   * - video_url：最终视频 URL（兜底）
+   * 后端根据此标识定位最终成片文件并抽帧，MediaKit 选帧逻辑不变
+   */
+  generated_video_id?: string
+  video_url?: string
   cover_type?: "ai_frame" | "manual" | "upload" | "ai_regenerate"
   frame_time?: number
   /** 标题样式，用于在封面上叠加标题文字 */
@@ -31,7 +38,7 @@ export interface GenerateCoverResponse {
   }
 }
 
-/** AI 生成封面 — 从预览视频中抽帧 */
+/** AI 生成封面 — 从最终成片中抽帧（MediaKit 选帧） */
 export async function generateCover(
   templateId: string,
   data: GenerateCoverRequest,

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

@@ -91,6 +91,7 @@ export async function createClipsFromAssets(
   assetIds: string[],
   clipType = "main",
   requiredClipsCount?: number,
+  opts?: { signal?: AbortSignal },
 ): Promise<ClipsFromAssetsResponse> {
   const body: Record<string, unknown> = {
     asset_ids: assetIds,
@@ -99,9 +100,11 @@ export async function createClipsFromAssets(
   if (requiredClipsCount !== undefined) {
     body.required_clips_count = requiredClipsCount
   }
+  // from-assets 后端会调用 MediaKit 智能选片（最长 60s），单独延长超时
   const response = await apiClient.post<ClipsFromAssetsResponse>(
     `/templates/${templateId}/editor/clips/from-assets`,
     body,
+    { timeout: 60000, signal: opts?.signal },
   )
   return response.data
 }

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

@@ -59,8 +59,23 @@ const AssetCard: React.FC<AssetCardProps> = ({
     >
       {/* 缩略图 */}
       <div className="as-card-thumb">
-        {asset.thumbnail_url ? (
-          <img src={asset.thumbnail_url} alt={asset.name} loading="lazy" />
+        {asset.thumbnail_url && !asset.thumbnail_url.match(/\.(mp4|mov|avi|webm|mkv)(\?|$)/i) ? (
+          <img
+            src={asset.thumbnail_url}
+            alt={asset.name}
+            loading="lazy"
+            onError={(e) => {
+              // 图片加载失败时降级显示类型图标
+              const parent = (e.target as HTMLElement).parentElement
+              if (parent) {
+                ;(e.target as HTMLElement).style.display = "none"
+                const icon = document.createElement("span")
+                icon.className = "as-card-thumb-icon"
+                icon.textContent = MATERIAL_TYPE_ICONS[asset.type] || "🎬"
+                parent.appendChild(icon)
+              }
+            }}
+          />
         ) : (
           <span className="as-card-thumb-icon">{MATERIAL_TYPE_ICONS[asset.type]}</span>
         )}

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

@@ -15,8 +15,6 @@ import React, { useState } from "react"
 import { useSearchParams } from "react-router-dom"
 import { MODE_LABELS } from "@/api/editing-planner"
 import { MODE_LIST } from "./constants"
-import type { MediaAsset } from "@/api/template-editor"
-
 import MediaPanel from "./components/MediaPanel"
 import PreviewPlayer from "./components/PreviewPlayer"
 import TimelinePanel from "./components/TimelinePanel"
@@ -79,14 +77,6 @@ const EditingPlanner: React.FC = () => {
   /* ── 右侧栏 Tab ── */
   const [rightTab, setRightTab] = useState<"properties" | "clips">("properties")
 
-  /* ── 素材库 ── */
-  const [mediaAssets, setMediaAssets] = useState<MediaAsset[]>([])
-  const [selectedAssetIds, setSelectedAssetIds] = useState<string[]>([])
-
-  const handleAssetSelect = (ids: string[]) => {
-    setSelectedAssetIds(ids)
-  }
-
   /* ── 配音素材 ── */
   const {
     voiceMaterials,
@@ -113,7 +103,6 @@ const EditingPlanner: React.FC = () => {
     resetClips,
     setClips,
     setSelectedClipId: clipOps.setSelectedClipId,
-    setMediaAssets,
     setTitleConfig,
     setSubtitleSettings,
     setBgmSettings,
@@ -164,9 +153,6 @@ const EditingPlanner: React.FC = () => {
           onLoadTemplate={tpl.handleLoadTemplate}
           onSearchChange={tpl.setSearchQuery}
           onFilterChange={tpl.setCurrentFilter}
-          mediaAssets={mediaAssets}
-          onAssetSelect={handleAssetSelect}
-          selectedAssetIds={selectedAssetIds}
         />
 
         {/* 中栏 flex-1 */}

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

@@ -1,12 +1,10 @@
 /**
- * 左侧面板 — V8 原型 1:1 还原
- * Tab 切换：模板列表 + 素材库
+ * 左侧面板 — 模板列表
+ * 模板编辑器只负责定义模板规则（片段数量、时长范围），不承载素材管理。
  */
-import React, { useState } from "react"
+import React from "react"
 import type { EditingTemplate } from "@/api/editing-planner"
 import { MODE_LABELS } from "@/api/editing-planner"
-import type { MediaAsset } from "@/api/template-editor"
-import AssetSelector from "@/components/asset-selector/AssetSelector"
 
 interface MediaPanelProps {
   templates: EditingTemplate[]
@@ -18,10 +16,6 @@ interface MediaPanelProps {
   onLoadTemplate: (id: string) => void
   onSearchChange: (q: string) => void
   onFilterChange: (f: string) => void
-  // 素材相关
-  mediaAssets?: MediaAsset[]
-  onAssetSelect?: (ids: string[]) => void
-  selectedAssetIds?: string[]
 }
 
 const MediaPanel: React.FC<MediaPanelProps> = ({
@@ -34,113 +28,73 @@ const MediaPanel: React.FC<MediaPanelProps> = ({
   onLoadTemplate,
   onSearchChange,
   onFilterChange,
-  mediaAssets = [],
-  onAssetSelect,
-  selectedAssetIds = [],
 }) => {
-  const [activeTab, setActiveTab] = useState<"templates" | "assets">("templates")
-
   return (
     <div className="ep-left-panel">
-      {/* Tab 切换 */}
-      <div className="ep-left-tabs">
-        <button
-          className={`ep-left-tab ${activeTab === "templates" ? "active" : ""}`}
-          onClick={() => setActiveTab("templates")}
-        >
-          📋 模板
-        </button>
-        <button
-          className={`ep-left-tab ${activeTab === "assets" ? "active" : ""}`}
-          onClick={() => setActiveTab("assets")}
-        >
-          📁 素材
-        </button>
+      {/* 搜索 */}
+      <div className="ep-search-wrap ep-media-panel-inner">
+        <span className="ep-search-icon">🔍</span>
+        <input
+          className="ep-search-input"
+          placeholder="搜索模板..."
+          value={searchQuery}
+          onChange={(e) => onSearchChange(e.target.value)}
+        />
       </div>
 
-      {/* 模板 Tab */}
-      {activeTab === "templates" && (
-        <>
-          {/* 搜索 */}
-          <div className="ep-search-wrap ep-media-panel-inner">
-            <span className="ep-search-icon">🔍</span>
-            <input
-              className="ep-search-input"
-              placeholder="搜索模板..."
-              value={searchQuery}
-              onChange={(e) => onSearchChange(e.target.value)}
-            />
-          </div>
+      {/* Chip 分类筛选 */}
+      <div className="ep-filter-chips">
+        {filterCategories.map((cat) => (
+          <button
+            key={cat}
+            className={`ep-filter-chip ${currentFilter === cat ? "active" : ""}`}
+            onClick={() => onFilterChange(cat)}
+          >
+            {cat}
+          </button>
+        ))}
+      </div>
 
-          {/* Chip 分类筛选 */}
-          <div className="ep-filter-chips">
-            {filterCategories.map((cat) => (
-              <button
-                key={cat}
-                className={`ep-filter-chip ${currentFilter === cat ? "active" : ""}`}
-                onClick={() => onFilterChange(cat)}
-              >
-                {cat}
-              </button>
-            ))}
+      {/* 模板列表 */}
+      <div className="ep-template-list">
+        {loading ? (
+          <div className="ep-loading">
+            <span>⏳</span>
+            <span>加载中...</span>
           </div>
-
-          {/* 模板列表 */}
-          <div className="ep-template-list">
-            {loading ? (
-              <div className="ep-loading">
-                <span>⏳</span>
-                <span>加载中...</span>
+        ) : templates.length === 0 ? (
+          <div className="ep-empty">
+            <span>📭</span>
+            <span>暂无模板</span>
+          </div>
+        ) : (
+          templates.map((tpl) => (
+            <div
+              key={tpl.id}
+              className={`ep-template-card ${loadedTemplateId === tpl.id ? "active" : ""}`}
+              onClick={() => onLoadTemplate(tpl.id)}
+            >
+              <div className="ep-template-card-header">
+                <span className="ep-template-card-name">{tpl.name}</span>
+                <span className="ep-template-card-mode">{MODE_LABELS[tpl.mode]}</span>
               </div>
-            ) : templates.length === 0 ? (
-              <div className="ep-empty">
-                <span>📭</span>
-                <span>暂无模板</span>
+              <div className="ep-template-card-meta">
+                <span>⏱️ {tpl.estimated_duration}s</span>
+                <span>📐 {tpl.segments.length}片段</span>
               </div>
-            ) : (
-              templates.map((tpl) => (
-                <div
-                  key={tpl.id}
-                  className={`ep-template-card ${loadedTemplateId === tpl.id ? "active" : ""}`}
-                  onClick={() => onLoadTemplate(tpl.id)}
-                >
-                  <div className="ep-template-card-header">
-                    <span className="ep-template-card-name">{tpl.name}</span>
-                    <span className="ep-template-card-mode">{MODE_LABELS[tpl.mode]}</span>
-                  </div>
-                  <div className="ep-template-card-meta">
-                    <span>⏱️ {tpl.estimated_duration}s</span>
-                    <span>📐 {tpl.segments.length}片段</span>
-                  </div>
-                  {tpl.tags.length > 0 && (
-                    <div className="ep-template-card-tags">
-                      {tpl.tags.map((tag) => (
-                        <span key={tag} className="ep-template-tag">
-                          {tag}
-                        </span>
-                      ))}
-                    </div>
-                  )}
+              {tpl.tags.length > 0 && (
+                <div className="ep-template-card-tags">
+                  {tpl.tags.map((tag) => (
+                    <span key={tag} className="ep-template-tag">
+                      {tag}
+                    </span>
+                  ))}
                 </div>
-              ))
-            )}
-          </div>
-        </>
-      )}
-
-      {/* 素材 Tab */}
-      {activeTab === "assets" && (
-        <div className="ep-assets-tab">
-          <AssetSelector
-            assets={mediaAssets}
-            selectedIds={selectedAssetIds}
-            onSelectionChange={onAssetSelect}
-            showQualityFilter={false}
-            showBatchSelect={false}
-            compact
-          />
-        </div>
-      )}
+              )}
+            </div>
+          ))
+        )}
+      </div>
     </div>
   )
 }

apps/web/src/pages/editing-planner/hooks/template-management/useTemplateList.ts

@@ -6,16 +6,13 @@ import {
   type EditingTemplate,
   type TemplateCategory,
 } from "@/api/editing-planner"
-import { getMediaAssets, type MediaAsset } from "@/api/template-editor"
 import { FILTER_CATEGORIES } from "../../constants"
 
 /**
  * 模板列表 + 分类 + 筛选搜索
+ * 模板编辑器只负责模板规则定义，不再加载/管理业务素材。
  */
-export function useTemplateList(
-  setMediaAssets: (assets: MediaAsset[]) => void,
-  initialTemplateId: string | null,
-) {
+export function useTemplateList(initialTemplateId: string | null) {
   const [templates, setTemplates] = useState<EditingTemplate[]>([])
   const [categories, setCategories] = useState<TemplateCategory[]>([])
   const [loadingTemplates, setLoadingTemplates] = useState(false)
@@ -24,26 +21,20 @@ export function useTemplateList(
   const [loadedTemplateId, setLoadedTemplateId] = useState<string | null>(initialTemplateId)
 
   /**
-   * 并行加载模板列表、分类、素材库
-   * 三个接口无依赖关系，用 Promise.all 并发
+   * 并行加载模板列表和分类（两者无依赖关系）
    */
   const loadTemplates = useCallback(async () => {
     setLoadingTemplates(true)
     try {
-      const [tpls, cats, assets] = await Promise.all([
-        getEditingTemplates(),
-        getTemplateCategories(),
-        getMediaAssets(),
-      ])
+      const [tpls, cats] = await Promise.all([getEditingTemplates(), getTemplateCategories()])
       setTemplates(tpls)
       setCategories(cats)
-      setMediaAssets(assets)
     } catch {
       message.error("加载模板失败")
     } finally {
       setLoadingTemplates(false)
     }
-  }, [setMediaAssets])
+  }, [])
 
   useEffect(() => {
     loadTemplates()

apps/web/src/pages/editing-planner/hooks/useTemplateManagement.ts

@@ -1,6 +1,6 @@
 import { useState, useCallback, type Dispatch, type SetStateAction } from "react"
 import type { TemplateMode } from "@/api/editing-planner"
-import type { MediaAsset, TitleConfig } from "@/api/template-editor"
+import type { TitleConfig } from "@/api/template-editor"
 import type {
   ClipData,
   WatermarkConfig,
@@ -24,7 +24,6 @@ interface UseTemplateManagementParams {
   resetClips: (clips: ClipData[]) => void
   setClips: (updater: (prev: ClipData[]) => ClipData[]) => void
   setSelectedClipId: (id: string | null) => void
-  setMediaAssets: (assets: MediaAsset[]) => void
   setTitleConfig: Dispatch<SetStateAction<TitleConfig>>
   setSubtitleSettings: Dispatch<SetStateAction<SubtitleStyleConfig>>
   setBgmSettings: Dispatch<SetStateAction<BgmMixConfig>>
@@ -52,7 +51,6 @@ export const useTemplateManagement = (params: UseTemplateManagementParams) => {
     resetClips,
     setClips,
     setSelectedClipId,
-    setMediaAssets,
     setTitleConfig,
     setSubtitleSettings,
     setBgmSettings,
@@ -86,7 +84,7 @@ export const useTemplateManagement = (params: UseTemplateManagementParams) => {
     filteredTemplates,
     currentTemplate,
     loadTemplates,
-  } = useTemplateList(setMediaAssets, urlTemplateId || null)
+  } = useTemplateList(urlTemplateId || null)
 
   /* ── 保存 ── */
   const {

apps/web/src/pages/generate/GeneratePage.tsx

@@ -1,14 +1,14 @@
 /**
  * 智能剪辑页面 — 前端实时预览架构
- * 7 步向导：选择模板 → 素材 → 配音 → 标题 → 预览 → 封面 → 确认生成
- * 左右布局：左侧 generate-form + 右侧 generate-preview
+ * 6 步向导：选择模板 → 素材 → 配音 → 标题(含预览) → 确认生成 → 选择封面
  *
  * 架构：
- * - 步骤 4-6 右侧显示 FrontendPreviewPlayer 实时预览
- * - 步骤 7 右侧内联播放生成的最终视频
+ * - 步骤 4 右侧显示 FrontendPreviewPlayer 实时预览
+ * - 步骤 5 右侧内联播放生成中的/最终视频
+ * - 步骤 6 封面从最终成片中智能选帧（MediaKit）
  * - 点"确认生成"时调用 createGenerationTask 创建一次服务器渲染任务
  */
-import React, { useMemo, useState, useEffect, useRef } from "react"
+import React, { useMemo, useState, useEffect, useRef, useCallback } from "react"
 import { message } from "antd"
 import { useNavigate } from "react-router-dom"
 import type { VoiceClone } from "@/api/voice-clone"
@@ -74,6 +74,8 @@ const GeneratePage: React.FC = () => {
     setPreviewTaskId,
     storedSourceEditPlanId,
     setStoredSourceEditPlanId,
+    serverClips,
+    setServerClips,
   } = formState
 
   /* ── 标题样式回调 ── */
@@ -161,7 +163,16 @@ const GeneratePage: React.FC = () => {
 
   /* ── 加载素材详情（供前端预览播放器使用 + 配音时长校验） ── */
   const previewAssetsEnabled = previewAssetIds.length > 0
-  const { assets: previewAssets } = usePreviewAssets(previewAssetIds, previewAssetsEnabled)
+  const { assets: previewAssets, ready: previewAssetsReady } = usePreviewAssets(
+    previewAssetIds,
+    previewAssetsEnabled,
+  )
+
+  /* ── 预览就绪：素材已加载，且有模板 ── */
+  const previewReady = useMemo(
+    () => previewAssetsReady && !!currentTemplate,
+    [previewAssetsReady, currentTemplate],
+  )
 
   /* ── 视频总时长计算 ── */
   const totalVideoDuration = useMemo(() => {
@@ -170,17 +181,6 @@ const GeneratePage: React.FC = () => {
     return estimateTotalVideoDuration(currentTemplate ?? undefined)
   }, [previewAssets, currentTemplate])
 
-  /* ── 步骤导航 ── */
-  const { goNext, goPrev } = useStepNavigation({
-    currentStep,
-    setCurrentStep,
-    selectedTemplate,
-    materialMode,
-    selectedMaterials,
-    smartSelectedIds,
-    titleSettings,
-  })
-
   /* ── 视频生成核心逻辑 ── */
   const {
     generating,
@@ -217,6 +217,38 @@ const GeneratePage: React.FC = () => {
     },
   })
 
+  /* ── 步骤4「确认生成视频」：校验标题/预览 → 创建最终渲染任务 → 成功后进入步骤5 ── */
+  const handleConfirmGenerate = useCallback(async () => {
+    if (!titleSettings.title.trim()) {
+      message.warning("请选择或输入标题")
+      return
+    }
+    if (!previewReady) {
+      message.warning("预览视频正在加载，请稍候")
+      return
+    }
+    const ok = await handleGenerate()
+    if (ok) {
+      setCurrentStep(5)
+    }
+  }, [titleSettings.title, previewReady, handleGenerate, setCurrentStep])
+
+  /* ── 步骤导航 ── */
+  const { goNext, goPrev } = useStepNavigation({
+    currentStep,
+    setCurrentStep,
+    selectedTemplate,
+    materialMode,
+    selectedMaterials,
+    smartSelectedIds,
+    titleSettings,
+    previewReady,
+    generated,
+  })
+
+  /* ── 最终成片（步骤5/6 右侧播放） ── */
+  const finalVideo = generatedVideos[0]
+
   /* ================================================================
      渲染
      ================================================================ */
@@ -253,16 +285,14 @@ const GeneratePage: React.FC = () => {
             onApplyPreset={styleUpdaters.applyPreset}
             activePreset={styleUpdaters.activePreset}
             titlePresets={styleUpdaters.titlePresets}
-            onPreviewTaskCreated={setPreviewTaskId}
-            onSourceEditPlanIdExtracted={setStoredSourceEditPlanId}
             bgm={bgm}
             bgmConfig={bgmConfig}
             coverSettings={coverSettings}
             onCoverSettingsChange={setCoverSettings}
-            duration={duration}
             selectedVoice={selectedVoice}
             onSelectedVoiceChange={setSelectedVoice}
             totalVideoDuration={totalVideoDuration}
+            onServerClipsChange={setServerClips}
             voiceMode={voiceMode}
             onVoiceModeChange={setVoiceMode}
             selectedClonedVoice={selectedClonedVoice}
@@ -286,21 +316,22 @@ const GeneratePage: React.FC = () => {
             currentStep={currentStep}
             onPrev={goPrev}
             onNext={goNext}
-            onGenerate={handleGenerate}
+            onConfirmGenerate={handleConfirmGenerate}
             generating={generating}
             generated={generated}
             generateError={generateError}
           />
         </div>
 
-        {/* ════ 右侧：步骤 4-6 实时预览，步骤 7 最终视频 ════ */}
+        {/* ════ 右侧：步骤4实时预览，步骤5/6最终视频 ════ */}
         <div className="xx-generate-right-col">
-          {currentStep >= 4 && currentStep <= 6 && !!currentTemplate && (
+          {currentStep === 4 && !!currentTemplate && (
             <FrontendPreviewPlayer
               assets={previewAssets}
               template={currentTemplate}
               videoRatio={videoRatio}
               ready={previewAssets.length > 0}
+              serverClips={serverClips}
               voiceAudioUrl={previewVoiceAudioUrl || undefined}
               titleSettings={{
                 title: titleSettings.title,
@@ -315,14 +346,14 @@ const GeneratePage: React.FC = () => {
               }}
             />
           )}
-          {currentStep === 7 && generated && generatedVideos.length > 0 && (
+          {currentStep >= 5 && generated && finalVideo && (
             <div className="xx-inline-video-player">
               <video
-                src={generatedVideos[0].download_url || generatedVideos[0].file_url}
+                src={finalVideo.download_url || finalVideo.file_url}
                 controls
-                autoPlay
+                autoPlay={currentStep === 5}
                 style={{ width: "100%", maxHeight: "70vh", objectFit: "contain", borderRadius: 12 }}
-                poster={generatedVideos[0].thumbnail_url || undefined}
+                poster={finalVideo.thumbnail_url || undefined}
               />
               <div style={{ display: "flex", gap: 8, marginTop: 12, justifyContent: "center" }}>
                 <button className="xx-btn xx-btn-ghost xx-btn-sm" onClick={handleDownload}>

apps/web/src/pages/generate/components/FrontendPreviewPlayer.tsx

@@ -16,6 +16,7 @@ import {
 } from "@ant-design/icons"
 import type { AssetItem } from "@/api/assets"
 import type { EditingTemplate } from "@/api/editing-planner"
+import type { EditPlanClip } from "@/api/template-editor"
 import { useSegmentScheduler, type PlaybackSegment } from "../hooks/useSegmentScheduler"
 import { useCanvasPlayer } from "../hooks/useCanvasPlayer"
 
@@ -24,6 +25,7 @@ interface FrontendPreviewPlayerProps {
   template: EditingTemplate | null
   videoRatio: string
   ready: boolean
+  serverClips?: EditPlanClip[]
   voiceAudioUrl?: string
   titleSettings?: {
     title: string
@@ -50,9 +52,31 @@ function formatTime(seconds: number): string {
 function buildPlaybackSegments(
   assets: AssetItem[],
   template: EditingTemplate | null,
+  serverClips?: EditPlanClip[],
 ): PlaybackSegment[] {
   if (!assets.length) return []
 
+  // Build asset lookup map
+  const assetMap = new Map(assets.map((a) => [a.id, a]))
+
+  // 优先使用服务端 clips（含随机 start_time 和正确数量），与最终生成结果一致
+  if (serverClips && serverClips.length > 0) {
+    const segments: PlaybackSegment[] = []
+    for (const clip of serverClips) {
+      const asset = assetMap.get(clip.asset_id)
+      if (!asset) continue
+      const assetDuration = asset.duration || asset.metadata?.duration || 30
+      const startTime = clip.start_time || 0
+      const endTime = Math.min(startTime + (clip.duration || assetDuration), assetDuration)
+      const videoUrl = asset.file_url || asset.storage_key
+      segments.push({ assetId: asset.id, videoUrl, startTime, endTime, order: clip.order })
+    }
+    if (segments.length > 0) {
+      return segments.sort((a, b) => a.order - b.order)
+    }
+  }
+
+  // Fallback: 本地构建片段（与旧行为一致）
   const templateSegments = template?.segments || []
   const segments: PlaybackSegment[] = []
 
@@ -78,10 +102,14 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
   template,
   videoRatio,
   ready,
+  serverClips,
   voiceAudioUrl,
   titleSettings,
 }) => {
-  const segments = useMemo(() => buildPlaybackSegments(assets, template), [assets, template])
+  const segments = useMemo(
+    () => buildPlaybackSegments(assets, template, serverClips),
+    [assets, template, serverClips],
+  )
 
   // ── ASS 坐标系参数（与后端 ass_subtitle_builder.py 一致） ──
   const TITLE_MARGIN_TOP = 120
@@ -143,7 +171,7 @@ const FrontendPreviewPlayer: React.FC<FrontendPreviewPlayerProps> = ({
         fontSize: titleSettings.size,
         fontFamily: titleSettings.font || "思源黑体",
         color: titleSettings.color || "#ffffff",
-        position: titleSettings.position || "bottom",
+        position: titleSettings.position || "top",
         bold: titleSettings.bold,
         stroke: titleSettings.stroke,
         shadow: titleSettings.shadow,

apps/web/src/pages/generate/components/GenerateStepActions.tsx

@@ -1,14 +1,19 @@
 /**
  * GeneratePage 步骤底部操作按钮
+ *
+ * 步骤 1~3：上一步 / 下一步
+ * 步骤 4（标题+预览）：上一步 / 确认生成视频（点击后直接创建最终渲染任务，成功后跳转步骤5）
+ * 步骤 5（确认生成）：上一步 / 下一步（渲染中禁用，渲染完成后可进入封面）
+ * 步骤 6（选择封面）：仅上一步
  */
 import React from "react"
-import { ThunderboltOutlined } from "@ant-design/icons"
 
 export interface GenerateStepActionsProps {
   currentStep: number
   onPrev: () => void
   onNext: () => void
-  onGenerate: () => void
+  /** 步骤4：确认生成视频（校验 + 创建渲染任务 + 成功后进入步骤5） */
+  onConfirmGenerate: () => void | Promise<void>
   generating: boolean
   generated: boolean
   generateError: string | null
@@ -18,36 +23,65 @@ export const GenerateStepActions: React.FC<GenerateStepActionsProps> = ({
   currentStep,
   onPrev,
   onNext,
-  onGenerate,
+  onConfirmGenerate,
   generating,
   generated,
   generateError,
 }) => {
+  const renderPrimaryButton = () => {
+    /* 步骤 4：确认生成视频（触发按钮在标题页） */
+    if (currentStep === 4) {
+      if (generating) {
+        return (
+          <button className="xx-btn xx-btn-primary" disabled>
+            ⏳ 视频生成中…
+          </button>
+        )
+      }
+      if (generateError) {
+        return (
+          <button className="xx-btn xx-btn-primary" onClick={onConfirmGenerate}>
+            🔄 重新生成视频
+          </button>
+        )
+      }
+      if (generated) {
+        return (
+          <button className="xx-btn xx-btn-primary" onClick={onNext}>
+            下一步 →
+          </button>
+        )
+      }
+      return (
+        <button className="xx-btn xx-btn-primary" onClick={onConfirmGenerate}>
+          ✨ 确认生成视频
+        </button>
+      )
+    }
+
+    /* 步骤 5：渲染中禁用，完成后下一步进入封面 */
+    if (currentStep === 5) {
+      return (
+        <button
+          className="xx-btn xx-btn-primary"
+          onClick={onNext}
+          disabled={generating || !generated}
+        >
+          {generating ? "视频生成中…" : "下一步 →"}
+        </button>
+      )
+    }
+
+    /* 步骤 6（最后一步）：无主按钮 */
+    return null
+  }
+
   return (
     <div className="xx-step-actions">
       <button className="xx-btn xx-btn-ghost" onClick={onPrev} disabled={currentStep === 1}>
         ← 上一步
       </button>
-      {currentStep < 7 ? (
-        <button className="xx-btn xx-btn-primary" onClick={onNext}>
-          下一步 →
-        </button>
-      ) : (
-        <button
-          className="xx-btn xx-btn-primary"
-          onClick={onGenerate}
-          disabled={generating || (generated && !generateError)}
-        >
-          <ThunderboltOutlined />
-          {generating
-            ? "生成中…"
-            : generated && !generateError
-              ? "已生成"
-              : generateError
-                ? "🔄 重新生成"
-                : "✨ 确认生成"}
-        </button>
-      )}
+      {renderPrimaryButton()}
     </div>
   )
 }

apps/web/src/pages/generate/components/GenerateStepContent.tsx

@@ -1,12 +1,10 @@
 /**
  * GeneratePage 步骤内容渲染
- * 根据当前步骤渲染对应的 Step 组件
- * 步骤顺序：模板(1) → 素材(2) → 配音(3) → 标题(4) → 预览(5) → 封面(6) → 确认(7)
- *
- * V24: 移除 Step5 预览生成相关 props，改为纯标题样式编辑
+ * 步骤顺序（6步）：模板(1) → 素材(2) → 配音(3) → 标题(4) → 确认生成(5) → 封面(6)
  */
 import React from "react"
 import type { EditingTemplate } from "@/api/editing-planner"
+import type { EditPlanClip } from "@/api/template-editor"
 import type { PresetVoiceItem } from "@/api/voices"
 import type { VoiceClone } from "@/api/voice-clone"
 import type { CoverConfig } from "../types/cover"
@@ -14,10 +12,9 @@ import type { TitleSettings } from "../types"
 import Step1TemplateSelect from "../components/Step1TemplateSelect"
 import Step2MaterialSelect from "../components/Step2MaterialSelect"
 import Step3VoiceSelect from "../components/Step5VoiceSelect"
-import Step5GeneratePreview from "../components/Step5GeneratePreview"
 import Step4TitleSettings from "../components/Step4TitleSettings"
+import Step5ConfirmGenerate from "../components/Step7ConfirmGenerate"
 import Step6CoverSettings from "../components/Step6CoverSettings"
-import Step7ConfirmGenerate from "../components/Step7ConfirmGenerate"
 import type { GeneratedVideo } from "@/api/template-editor"
 
 export interface GenerateStepContentProps {
@@ -36,7 +33,6 @@ export interface GenerateStepContentProps {
   /* 标题 */
   titleSettings: TitleSettings
   onTitleSettingsChange: (settings: TitleSettings) => void
-  /* 标题样式回调 — Step5 样式面板使用 */
   onUpdatePosition: (position: string) => void
   onUpdateFont: (font: string) => void
   onUpdateSize: (size: number) => void
@@ -50,11 +46,11 @@ export interface GenerateStepContentProps {
   /* 封面 */
   coverSettings: CoverConfig
   onCoverSettingsChange: (settings: CoverConfig) => void
-  duration: number
   /* 配音 */
   selectedVoice: string
   onSelectedVoiceChange: (id: string) => void
   totalVideoDuration?: number
+  onServerClipsChange: (clips: EditPlanClip[]) => void
   voiceMode: "preset" | "custom" | "clone"
   onVoiceModeChange: (mode: "preset" | "custom" | "clone") => void
   selectedClonedVoice: string
@@ -74,10 +70,6 @@ export interface GenerateStepContentProps {
   onDismissError: () => void
   /* 其他 */
   presetVoices: PresetVoiceItem[]
-  /** 预览任务创建回调——传递给 Step6CoverSettings */
-  onPreviewTaskCreated?: (taskId: string) => void
-  /** 从预览响应中提取到 source_edit_plan_id 时的回调 */
-  onSourceEditPlanIdExtracted?: (planId: string) => void
   /** BGM 开关 */
   bgm: boolean
   /** BGM 配置（来自模板） */
@@ -110,10 +102,10 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
     titlePresets,
     coverSettings,
     onCoverSettingsChange,
-    duration,
     selectedVoice,
     onSelectedVoiceChange,
     totalVideoDuration,
+    onServerClipsChange,
     voiceMode,
     selectedClonedVoice,
     clonedVoices,
@@ -125,10 +117,6 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
     onRetry,
     onDismissError,
     presetVoices,
-    onPreviewTaskCreated,
-    onSourceEditPlanIdExtracted,
-    bgm,
-    bgmConfig,
   } = props
 
   /* 当前模板的 segments，传给 Step2 构建 clips */
@@ -155,6 +143,7 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
           onSmartSelectedIdsChange={onSmartSelectedIdsChange}
           selectedTemplate={selectedTemplate}
           templateSegments={templateSegments}
+          onServerClipsChange={onServerClipsChange}
         />
       )
     case 3:
@@ -171,12 +160,6 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
           titleSettings={titleSettings}
           onTitleSettingsChange={onTitleSettingsChange}
           selectedTemplate={selectedTemplate}
-        />
-      )
-    case 5:
-      return (
-        <Step5GeneratePreview
-          titleSettings={titleSettings}
           onUpdatePosition={onUpdatePosition}
           onUpdateFont={onUpdateFont}
           onUpdateSize={onUpdateSize}
@@ -189,27 +172,9 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
           titlePresets={titlePresets}
         />
       )
-    case 6:
+    case 5:
       return (
-        <Step6CoverSettings
-          coverSettings={coverSettings}
-          onCoverSettingsChange={onCoverSettingsChange}
-          duration={duration}
-          assetIds={materialMode === "auto" ? smartSelectedIds : selectedMaterials}
-          selectedTemplate={selectedTemplate}
-          titleSettings={titleSettings}
-          onPreviewTaskCreated={onPreviewTaskCreated}
-          onSourceEditPlanIdExtracted={onSourceEditPlanIdExtracted}
-          voiceMode={voiceMode}
-          selectedVoice={selectedVoice}
-          selectedClonedVoice={selectedClonedVoice}
-          bgm={bgm}
-          bgmConfig={bgmConfig}
-        />
-      )
-    case 7:
-      return (
-        <Step7ConfirmGenerate
+        <Step5ConfirmGenerate
           templates={userTemplates}
           selectedTemplate={selectedTemplate}
           materialMode={materialMode}
@@ -231,6 +196,16 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
           onDismissError={onDismissError}
         />
       )
+    case 6:
+      return (
+        <Step6CoverSettings
+          coverSettings={coverSettings}
+          onCoverSettingsChange={onCoverSettingsChange}
+          selectedTemplate={selectedTemplate}
+          titleSettings={titleSettings}
+          generatedVideos={generatedVideos}
+        />
+      )
     default:
       return null
   }

apps/web/src/pages/generate/components/Step2MaterialSelect.tsx

@@ -3,6 +3,7 @@
  */
 import React from "react"
 import type { TemplateSegment } from "@/api/templates/types"
+import type { EditPlanClip } from "@/api/template-editor"
 import { useStep2Materials } from "../hooks/useStep2Materials"
 import MaterialModeTabs from "./material/MaterialModeTabs"
 import ManualMaterialList from "./material/ManualMaterialList"
@@ -20,6 +21,8 @@ interface Step2MaterialSelectProps {
   selectedTemplate?: string
   /** 当前模板的 segments（用于构建 clips duration） */
   templateSegments?: TemplateSegment[]
+  /** 服务端 clips 创建成功后的回调 */
+  onServerClipsChange?: (clips: EditPlanClip[]) => void
 }
 
 const Step2MaterialSelect: React.FC<Step2MaterialSelectProps> = (props) => {

apps/web/src/pages/generate/components/Step4TitleSettings.tsx

@@ -1,23 +1,50 @@
 /**
- * Step 4 标题设置组件
- * 仅包含标题文字输入 + AI 标题生成
- * 标题样式面板已迁移到 Step5（生成预览页面）
+ * Step 4 选择标题（合并原 Step4 标题输入 + Step5 标题样式面板）
+ *
+ * 左侧：标题文字输入 + AI生成标题 + 样式设置（位置/字号/字体/颜色/样式/预设）
+ * 右侧：FrontendPreviewPlayer 实时预览（由 GeneratePage 统一渲染）
  */
 import React from "react"
 import { AutoComplete } from "antd"
+import { PlayCircleOutlined } from "@ant-design/icons"
 import type { TitleSettings } from "../types"
+import { POSITION_OPTIONS, FONT_OPTIONS } from "../constants"
 import { useStep4Title } from "../hooks/useStep4Title"
 import AiTitleGenerator from "./title/AiTitleGenerator"
+import TitleStylePanel from "./title/TitleStylePanel"
 
 interface Step4TitleSettingsProps {
   titleSettings: TitleSettings
   onTitleSettingsChange: (settings: TitleSettings) => void
   /** 当前选中的模板/草稿 ID，用于自动保存 */
   selectedTemplate?: string
+  /* 标题样式回调 */
+  onUpdatePosition: (position: string) => void
+  onUpdateFont: (font: string) => void
+  onUpdateSize: (size: number) => void
+  onToggleBold: () => void
+  onToggleItalic: () => void
+  onToggleStroke: () => void
+  onToggleShadow: () => void
+  onApplyPreset: (presetKey: string) => void
+  activePreset: string | null
+  titlePresets: { key: string; label: string; previewStyle: React.CSSProperties }[]
 }
 
 const Step4TitleSettings: React.FC<Step4TitleSettingsProps> = (props) => {
   const t = useStep4Title(props)
+  const {
+    onUpdatePosition,
+    onUpdateFont,
+    onUpdateSize,
+    onToggleBold,
+    onToggleItalic,
+    onToggleStroke,
+    onToggleShadow,
+    onApplyPreset,
+    activePreset,
+    titlePresets,
+  } = props
 
   return (
     <div className="xx-form-section">
@@ -112,6 +139,42 @@ const Step4TitleSettings: React.FC<Step4TitleSettingsProps> = (props) => {
           </div>
         </>
       )}
+
+      {/* 标题样式面板（原 Step5） */}
+      <div
+        style={{
+          display: "flex",
+          alignItems: "center",
+          gap: 8,
+          padding: "10px 14px",
+          background: "rgba(59, 130, 246, 0.08)",
+          borderRadius: 8,
+          marginTop: 16,
+          marginBottom: 12,
+          border: "1px solid rgba(59, 130, 246, 0.15)",
+        }}
+      >
+        <PlayCircleOutlined style={{ fontSize: 16, color: "#3b82f6" }} />
+        <span style={{ fontSize: 12, color: "var(--text-secondary, #666)" }}>
+          右侧为实时预览，调整样式即时生效
+        </span>
+      </div>
+
+      <TitleStylePanel
+        settings={t.titleSettings}
+        onUpdatePosition={onUpdatePosition}
+        onUpdateFont={onUpdateFont}
+        onUpdateSize={onUpdateSize}
+        onToggleBold={onToggleBold}
+        onToggleItalic={onToggleItalic}
+        onToggleStroke={onToggleStroke}
+        onToggleShadow={onToggleShadow}
+        onApplyPreset={onApplyPreset}
+        activePreset={activePreset}
+        titlePresets={titlePresets}
+        POSITION_OPTIONS={POSITION_OPTIONS}
+        FONT_OPTIONS={FONT_OPTIONS}
+      />
     </div>
   )
 }

apps/web/src/pages/generate/components/Step5GeneratePreview.tsx

@@ -1,83 +0,0 @@
-/**
- * Step 5 预览设置组件
- *
- * 前端实时预览架构：
- * - 右侧面板使用 FrontendPreviewPlayer 实时播放素材片段
- * - 标题样式可实时调整，CSS 层即时叠加预览
- * - 点"确认生成"时触发一次服务器渲染
- */
-import React from "react"
-import { PlayCircleOutlined } from "@ant-design/icons"
-import { POSITION_OPTIONS, FONT_OPTIONS } from "../constants"
-import type { TitleSettings } from "../types"
-import TitleStylePanel from "./title/TitleStylePanel"
-
-interface Step5GeneratePreviewProps {
-  titleSettings: TitleSettings
-  onUpdatePosition: (position: string) => void
-  onUpdateFont: (font: string) => void
-  onUpdateSize: (size: number) => void
-  onToggleBold: () => void
-  onToggleItalic: () => void
-  onToggleStroke: () => void
-  onToggleShadow: () => void
-  onApplyPreset: (presetKey: string) => void
-  activePreset: string | null
-  titlePresets: { key: string; label: string; previewStyle: React.CSSProperties }[]
-}
-
-const Step5GeneratePreview: React.FC<Step5GeneratePreviewProps> = ({
-  titleSettings,
-  onUpdatePosition,
-  onUpdateFont,
-  onUpdateSize,
-  onToggleBold,
-  onToggleItalic,
-  onToggleStroke,
-  onToggleShadow,
-  onApplyPreset,
-  activePreset,
-  titlePresets,
-}) => {
-  return (
-    <div className="xx-form-section">
-      <h3>🎬 预览设置</h3>
-
-      <div
-        style={{
-          display: "flex",
-          alignItems: "center",
-          gap: 8,
-          padding: "12px 16px",
-          background: "rgba(59, 130, 246, 0.08)",
-          borderRadius: 8,
-          marginBottom: 16,
-          border: "1px solid rgba(59, 130, 246, 0.15)",
-        }}
-      >
-        <PlayCircleOutlined style={{ fontSize: 18, color: "#3b82f6" }} />
-        <span style={{ fontSize: 13, color: "var(--text-secondary, #666)" }}>
-          右侧为实时预览，选完素材即可播放。确认生成后服务器渲染最终视频
-        </span>
-      </div>
-
-      <TitleStylePanel
-        settings={titleSettings}
-        onUpdatePosition={onUpdatePosition}
-        onUpdateFont={onUpdateFont}
-        onUpdateSize={onUpdateSize}
-        onToggleBold={onToggleBold}
-        onToggleItalic={onToggleItalic}
-        onToggleStroke={onToggleStroke}
-        onToggleShadow={onToggleShadow}
-        onApplyPreset={onApplyPreset}
-        activePreset={activePreset}
-        titlePresets={titlePresets}
-        POSITION_OPTIONS={POSITION_OPTIONS}
-        FONT_OPTIONS={FONT_OPTIONS}
-      />
-    </div>
-  )
-}
-
-export default Step5GeneratePreview

apps/web/src/pages/generate/components/Step6CoverSettings.tsx

@@ -1,6 +1,8 @@
 import React from "react"
 import { Modal, Spin } from "antd"
 import type { CoverConfig } from "../types/cover"
+import type { GeneratedVideo } from "@/api/template-editor"
+import type { TitleSettings } from "../types"
 import { useStep6Cover } from "../hooks/useStep6Cover"
 import Button from "@/components/ui/Button"
 import CoverSettingsModal from "./cover-settings/CoverSettingsModal"
@@ -9,27 +11,12 @@ import CoverEditorModal from "./cover-settings/CoverEditorModal"
 interface Step6CoverSettingsProps {
   coverSettings: CoverConfig
   onCoverSettingsChange: (settings: CoverConfig) => void
-  duration: number
-  /** 当前素材 ID 列表，用于智能封面生成 */
-  assetIds?: string[]
   /** 当前选中的模板 ID */
   selectedTemplate?: string
-  /** Step4 标题设置，用于预览视频烧录标题 & 封面叠加标题 */
-  titleSettings?: import("../types").TitleSettings
-  /** 预览任务创建回调——将 task_id 暴露给父组件供 confirmGeneration 复用 */
-  onPreviewTaskCreated?: (taskId: string) => void
-  /** 从预览响应中提取到 source_edit_plan_id 时的回调 */
-  onSourceEditPlanIdExtracted?: (planId: string) => void
-  /** 配音模式 */
-  voiceMode?: "preset" | "custom" | "clone"
-  /** 选中的配音素材 ID */
-  selectedVoice?: string
-  /** 选中的克隆音色 ID */
-  selectedClonedVoice?: string
-  /** BGM 开关 */
-  bgm?: boolean
-  /** BGM 配置 */
-  bgmConfig?: { enabled: boolean; music_id?: string }
+  /** Step4 标题设置，用于封面叠加标题 */
+  titleSettings?: TitleSettings
+  /** 确认生成步骤产出的最终视频列表 */
+  generatedVideos: GeneratedVideo[]
 }
 
 const Step6CoverSettings: React.FC<Step6CoverSettingsProps> = (props) => {
@@ -37,6 +24,7 @@ const Step6CoverSettings: React.FC<Step6CoverSettingsProps> = (props) => {
     coverSettings,
     generating,
     generateAutoCover,
+    finalVideo,
     showCoverSettings,
     setShowCoverSettings,
     showCoverEditor,
@@ -53,17 +41,9 @@ const Step6CoverSettings: React.FC<Step6CoverSettingsProps> = (props) => {
   } = useStep6Cover({
     coverSettings: props.coverSettings,
     onCoverSettingsChange: props.onCoverSettingsChange,
-    duration: props.duration,
-    assetIds: props.assetIds,
     selectedTemplate: props.selectedTemplate,
     titleSettings: props.titleSettings,
-    onPreviewTaskCreated: props.onPreviewTaskCreated,
-    onSourceEditPlanIdExtracted: props.onSourceEditPlanIdExtracted,
-    voiceMode: props.voiceMode,
-    selectedVoice: props.selectedVoice,
-    selectedClonedVoice: props.selectedClonedVoice,
-    bgm: props.bgm,
-    bgmConfig: props.bgmConfig,
+    generatedVideos: props.generatedVideos,
   })
 
   const handleAutoGenerate = () => {
@@ -77,8 +57,25 @@ const Step6CoverSettings: React.FC<Step6CoverSettingsProps> = (props) => {
     <div className="xx-form-section">
       <h3>🖼️ 选择封面</h3>
 
+      {/* 最终成片信息 */}
+      {finalVideo && (
+        <div
+          style={{
+            padding: "10px 14px",
+            background: "rgba(16, 185, 129, 0.08)",
+            borderRadius: 8,
+            marginBottom: 16,
+            border: "1px solid rgba(16, 185, 129, 0.15)",
+            fontSize: 13,
+            color: "var(--text-secondary, #666)",
+          }}
+        >
+          🎬 封面将从最终成片「{finalVideo.name}」中智能选帧
+        </div>
+      )}
+
       <div className="xx-cover-actions">
-        <Button buttonType="primary" onClick={handleAutoGenerate}>
+        <Button buttonType="primary" onClick={handleAutoGenerate} disabled={!finalVideo}>
           ✨ 自动生成封面
         </Button>
         <Button buttonType="ghost" onClick={() => setShowCoverSettings(true)}>
@@ -126,7 +123,9 @@ const Step6CoverSettings: React.FC<Step6CoverSettingsProps> = (props) => {
       <Modal open={generating} closable={false} footer={null} centered>
         <div style={{ textAlign: "center", padding: "24px 0" }}>
           <Spin size="large" />
-          <p style={{ marginTop: 16, fontSize: 14, color: "#666" }}>AI 正在生成封面，请稍候...</p>
+          <p style={{ marginTop: 16, fontSize: 14, color: "#666" }}>
+            AI 正在从最终成片选帧，请稍候...
+          </p>
         </div>
       </Modal>
     </div>

apps/web/src/pages/generate/components/material/ManualMaterialList.tsx

@@ -1,7 +1,8 @@
 /**
- * 手动选择素材列表
+ * 手动选择素材列表 — 竖屏 9:16 卡片网格
+ * 交互：默认显示封面，点击播放按钮播放，播放中隐藏按钮，点击视频区域暂停
  */
-import React, { useRef, useCallback } from "react"
+import React, { useRef, useState, useCallback } from "react"
 import { Typography } from "antd"
 import type { AssetItem } from "@/api/assets"
 
@@ -14,39 +15,241 @@ interface ManualMaterialListProps {
   onToggle: (materialId: string) => void
 }
 
+/** 秒数格式化为 mm:ss */
+const fmtDuration = (seconds?: number): string => {
+  if (!seconds && seconds !== 0) return "--:--"
+  const m = Math.floor(seconds / 60)
+  const s = Math.floor(seconds % 60)
+  return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`
+}
+
+/** 单个素材卡片 */
+const MaterialCard: React.FC<{
+  asset: AssetItem
+  checked: boolean
+  onToggle: () => void
+}> = ({ asset, checked, onToggle }) => {
+  const videoRef = useRef<HTMLVideoElement>(null)
+  const [isPlaying, setIsPlaying] = useState(false)
+  const isVideo = asset.mime_type?.startsWith("video/") ?? false
+  const thumbSrc = asset.thumbnail_url || undefined
+
+  const handlePlayToggle = useCallback(
+    (e: React.MouseEvent) => {
+      e.stopPropagation()
+      const video = videoRef.current
+      if (!video || !isVideo) return
+
+      if (isPlaying) {
+        video.pause()
+        setIsPlaying(false)
+      } else {
+        video.play().catch(() => {})
+        setIsPlaying(true)
+      }
+    },
+    [isPlaying, isVideo],
+  )
+
+  const handleVideoEnded = useCallback(() => {
+    setIsPlaying(false)
+  }, [])
+
+  const handleCardClick = useCallback(() => {
+    // 如果视频正在播放，点击卡片空白区域暂停视频
+    if (isPlaying) {
+      const video = videoRef.current
+      if (video) {
+        video.pause()
+        setIsPlaying(false)
+      }
+      return
+    }
+    onToggle()
+  }, [isPlaying, onToggle])
+
+  return (
+    <div
+      data-testid="material-card"
+      onClick={handleCardClick}
+      style={{
+        position: "relative",
+        aspectRatio: "9 / 16",
+        borderRadius: 10,
+        overflow: "hidden",
+        cursor: "pointer",
+        border: checked ? "2px solid var(--primary-color, #4f46e5)" : "2px solid transparent",
+        boxShadow: checked ? "0 0 0 2px rgba(79, 70, 229, 0.2)" : "0 1px 3px rgba(0, 0, 0, 0.1)",
+        background: "#1e293b",
+        transition: "all 0.15s ease",
+      }}
+    >
+      {/* 视频元素 */}
+      {isVideo && asset.file_url ? (
+        <video
+          ref={videoRef}
+          src={asset.file_url}
+          poster={thumbSrc}
+          muted
+          loop
+          playsInline
+          preload="metadata"
+          onEnded={handleVideoEnded}
+          style={{
+            width: "100%",
+            height: "100%",
+            objectFit: "cover",
+            display: "block",
+          }}
+        />
+      ) : thumbSrc ? (
+        <img
+          src={thumbSrc}
+          alt={asset.name}
+          style={{
+            width: "100%",
+            height: "100%",
+            objectFit: "cover",
+            display: "block",
+          }}
+          onError={(e) => {
+            const target = e.target as HTMLImageElement
+            target.style.display = "none"
+          }}
+        />
+      ) : (
+        <div
+          style={{
+            width: "100%",
+            height: "100%",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            background: "linear-gradient(135deg, #334155, #1e293b)",
+            color: "rgba(255,255,255,0.5)",
+            fontSize: 28,
+          }}
+        >
+          {isVideo ? "🎬" : "🎵"}
+        </div>
+      )}
+
+      {/* 底部渐变遮罩 */}
+      <div
+        style={{
+          position: "absolute",
+          bottom: 0,
+          left: 0,
+          right: 0,
+          height: "50%",
+          background: "linear-gradient(0deg, rgba(0,0,0,0.6) 0%, transparent 100%)",
+          pointerEvents: "none",
+        }}
+      />
+
+      {/* 播放按钮 — 播放中隐藏 */}
+      {!isPlaying && (
+        <div
+          onClick={handlePlayToggle}
+          style={{
+            position: "absolute",
+            top: "50%",
+            left: "50%",
+            transform: "translate(-50%, -50%)",
+            width: 36,
+            height: 36,
+            borderRadius: "50%",
+            background: "rgba(99, 102, 241, 0.85)",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            zIndex: 3,
+            transition: "opacity 0.2s ease",
+          }}
+        >
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="white">
+            <path d="M8 5v14l11-7z" />
+          </svg>
+        </div>
+      )}
+
+      {/* 文件名（左下角） */}
+      <div
+        style={{
+          position: "absolute",
+          bottom: 6,
+          left: 6,
+          right: 50,
+          color: "white",
+          fontSize: 11,
+          fontWeight: 500,
+          whiteSpace: "nowrap",
+          overflow: "hidden",
+          textOverflow: "ellipsis",
+          textShadow: "0 1px 2px rgba(0,0,0,0.5)",
+          pointerEvents: "none",
+          zIndex: 1,
+        }}
+      >
+        {asset.name}
+      </div>
+
+      {/* 时长（右下角） */}
+      <div
+        style={{
+          position: "absolute",
+          bottom: 6,
+          right: 6,
+          background: "rgba(0, 0, 0, 0.7)",
+          color: "white",
+          padding: "1px 5px",
+          borderRadius: 3,
+          fontSize: 10,
+          fontWeight: 600,
+          fontVariantNumeric: "tabular-nums",
+          pointerEvents: "none",
+          zIndex: 1,
+        }}
+      >
+        {fmtDuration(asset.duration)}
+      </div>
+
+      {/* 选中勾选标记（左上角） */}
+      {checked && (
+        <div
+          data-testid="material-card-check"
+          aria-label="已选中"
+          style={{
+            position: "absolute",
+            top: 6,
+            left: 6,
+            width: 20,
+            height: 20,
+            borderRadius: "50%",
+            background: "var(--primary-color, #4f46e5)",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            color: "white",
+            fontSize: 12,
+            fontWeight: 700,
+            zIndex: 2,
+            pointerEvents: "none",
+          }}
+        >
+          ✓
+        </div>
+      )}
+    </div>
+  )
+}
+
 const ManualMaterialList: React.FC<ManualMaterialListProps> = ({
   materials,
   materialsLoading,
   selectedMaterials,
   onToggle,
 }) => {
-  // 追踪当前正在播放的视频元素，确保同时只有一个视频播放
-  const activeVideoRef = useRef<HTMLVideoElement | null>(null)
-
-  const handleVideoMouseEnter = useCallback((e: React.MouseEvent<HTMLVideoElement>) => {
-    const video = e.currentTarget
-    // 暂停之前正在播放的视频（检查是否仍在 DOM 中）
-    if (
-      activeVideoRef.current &&
-      activeVideoRef.current !== video &&
-      document.body.contains(activeVideoRef.current)
-    ) {
-      activeVideoRef.current.pause()
-      activeVideoRef.current.currentTime = 0
-    }
-    activeVideoRef.current = video
-    video.play().catch(() => {})
-  }, [])
-
-  const handleVideoMouseLeave = useCallback((e: React.MouseEvent<HTMLVideoElement>) => {
-    const video = e.currentTarget
-    video.pause()
-    video.currentTime = 0
-    if (activeVideoRef.current === video) {
-      activeVideoRef.current = null
-    }
-  }, [])
-
   return (
     <div style={{ marginTop: 14 }}>
       {materialsLoading ? (
@@ -56,145 +259,21 @@ const ManualMaterialList: React.FC<ManualMaterialListProps> = ({
           暂无素材，请先在视频库中上传
         </Text>
       ) : (
-        <div style={{ display: "flex", flexDirection: "column", gap: 6 }}>
-          {materials.items.map((m) => {
-            const checked = selectedMaterials.includes(m.id)
-            const isVideo = m.mime_type?.startsWith("video/") ?? false
-            const thumbSrc = m.thumbnail_url || undefined
-            return (
-              <label
-                key={m.id}
-                style={{
-                  display: "flex",
-                  alignItems: "center",
-                  gap: 10,
-                  padding: "8px 12px",
-                  background: checked ? "var(--primary-soft, #eef2ff)" : "#f8fafc",
-                  borderRadius: 10,
-                  cursor: "pointer",
-                  border: checked
-                    ? "1px solid var(--primary-color, #4f46e5)"
-                    : "1px solid transparent",
-                  transition: "all 0.15s ease",
-                }}
-              >
-                <input
-                  type="checkbox"
-                  checked={checked}
-                  onChange={() => onToggle(m.id)}
-                  style={{
-                    accentColor: "var(--primary-color, #4f46e5)",
-                    flexShrink: 0,
-                  }}
-                />
-                {/* 缩略图预览 48×48 */}
-                <div
-                  style={{
-                    width: 48,
-                    height: 48,
-                    borderRadius: 6,
-                    overflow: "hidden",
-                    background: "#e2e8f0",
-                    flexShrink: 0,
-                    display: "flex",
-                    alignItems: "center",
-                    justifyContent: "center",
-                  }}
-                >
-                  {isVideo && m.file_url ? (
-                    <video
-                      src={m.file_url}
-                      poster={m.thumbnail_url || undefined}
-                      muted
-                      loop
-                      playsInline
-                      preload="none"
-                      onMouseEnter={handleVideoMouseEnter}
-                      onMouseLeave={handleVideoMouseLeave}
-                      style={{
-                        width: "100%",
-                        height: "100%",
-                        objectFit: "cover",
-                        cursor: "pointer",
-                      }}
-                    />
-                  ) : thumbSrc ? (
-                    <img
-                      src={thumbSrc}
-                      alt={m.name}
-                      style={{
-                        width: "100%",
-                        height: "100%",
-                        objectFit: "cover",
-                      }}
-                      onError={(e) => {
-                        const target = e.target as HTMLImageElement
-                        target.style.display = "none"
-                        const fallback = target.nextElementSibling as HTMLElement | null
-                        if (fallback) fallback.style.display = "flex"
-                      }}
-                    />
-                  ) : null}
-                  {!thumbSrc && !isVideo && (
-                    <span
-                      style={{
-                        fontSize: 20,
-                        opacity: 0.5,
-                        display: "flex",
-                      }}
-                    >
-                      🎵
-                    </span>
-                  )}
-                  {!thumbSrc && isVideo && !m.file_url && (
-                    <span
-                      style={{
-                        fontSize: 20,
-                        opacity: 0.5,
-                        display: "flex",
-                      }}
-                    >
-                      🎬
-                    </span>
-                  )}
-                  {/* img onError 时显示的 fallback（初始隐藏） */}
-                  {thumbSrc && !(isVideo && m.file_url) && (
-                    <span
-                      style={{
-                        fontSize: 20,
-                        opacity: 0.5,
-                        display: "none",
-                      }}
-                    >
-                      {isVideo ? "🎬" : "🎵"}
-                    </span>
-                  )}
-                </div>
-                <span
-                  style={{
-                    fontSize: 13,
-                    color: "var(--text-primary)",
-                    flex: 1,
-                    minWidth: 0,
-                    overflow: "hidden",
-                    textOverflow: "ellipsis",
-                    whiteSpace: "nowrap",
-                  }}
-                >
-                  {m.name}
-                </span>
-                <span
-                  style={{
-                    fontSize: 11,
-                    color: "var(--text-tertiary, #94a3b8)",
-                    flexShrink: 0,
-                  }}
-                >
-                  {m.mime_type?.split("/")?.[1]?.toUpperCase() ?? "FILE"}
-                </span>
-              </label>
-            )
-          })}
+        <div
+          style={{
+            display: "grid",
+            gridTemplateColumns: "repeat(auto-fill, minmax(110px, 1fr))",
+            gap: 10,
+          }}
+        >
+          {materials.items.map((asset) => (
+            <MaterialCard
+              key={asset.id}
+              asset={asset}
+              checked={selectedMaterials.includes(asset.id)}
+              onToggle={() => onToggle(asset.id)}
+            />
+          ))}
         </div>
       )}
     </div>

apps/web/src/pages/generate/components/step7-confirm/GenerationStatus.tsx

@@ -25,10 +25,21 @@ const GenerationStatus: React.FC<GenerationStatusProps> = ({
   onRetry,
   onDismissError,
 }) => {
-  if (!generating && !generated && !generateError) return null
-
   return (
     <div style={{ marginTop: 16 }}>
+      {!generating && !generated && !generateError && (
+        <div className="xx-gen-progress-card" style={{ opacity: 0.85 }}>
+          <div className="xx-gen-progress-header">
+            <div className="xx-gen-progress-icon">🎬</div>
+            <div className="xx-gen-progress-info">
+              <div className="xx-gen-progress-phase">尚未开始生成视频</div>
+              <div className="xx-gen-progress-sub">
+                请返回「选择标题」步骤，点击「确认生成视频」开始渲染最终视频
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
       {generating && (
         <div className="xx-gen-progress-card">
           <div className="xx-gen-progress-header">

apps/web/src/pages/generate/constants.ts

@@ -33,9 +33,8 @@ export const STEPS = [
   { key: 2, label: "选择素材" },
   { key: 3, label: "选择配音" },
   { key: 4, label: "选择标题" },
-  { key: 5, label: "生成预览" },
+  { key: 5, label: "确认生成" },
   { key: 6, label: "选择封面" },
-  { key: 7, label: "确认生成" },
 ]
 
 /* ── 标题位置选项 ── */

apps/web/src/pages/generate/generate.css

@@ -194,16 +194,16 @@
    ============================================================ */
 .xx-choice-list {
   display: grid;
-  grid-template-columns: repeat(3, 1fr);
-  gap: 12px;
+  grid-template-columns: repeat(6, 1fr);
+  gap: 8px;
 }
 
 .xx-choice-item {
   position: relative;
   background: var(--bg-primary);
   border: 2px solid var(--border-color);
-  border-radius: var(--radius-md);
-  padding: 14px;
+  border-radius: var(--radius-sm);
+  padding: 6px;
   cursor: pointer;
   transition: 0.18s ease;
   text-align: center;
@@ -219,18 +219,20 @@
 }
 
 .xx-choice-thumb {
-  height: 60px;
+  width: 33%;
+  max-width: 52px;
+  height: 24px;
   border-radius: var(--radius-sm);
   display: grid;
   place-items: center;
   color: var(--text-inverse);
-  font-size: 24px;
+  font-size: 12px;
   font-weight: 700;
-  margin-bottom: 10px;
+  margin: 0 auto 4px;
 }
 
 .xx-choice-item h4 {
-  margin: 0 0 4px;
+  margin: 0 0 2px;
   font-size: 13px;
   font-weight: 600;
   color: var(--text-primary);
@@ -238,7 +240,7 @@
 
 .xx-choice-item p {
   margin: 0;
-  font-size: 11px;
+  font-size: 12px;
   color: var(--text-tertiary);
 }
 
@@ -1063,7 +1065,7 @@
   }
 
   .xx-choice-list {
-    grid-template-columns: repeat(2, 1fr);
+    grid-template-columns: repeat(4, 1fr);
   }
 
   .xx-voice-choice-list {

apps/web/src/pages/generate/hooks/useGenerateFormState/index.ts

@@ -5,6 +5,7 @@
 import { useState } from "react"
 import { useSearchParams } from "react-router-dom"
 import type { EditingTemplate } from "@/api/editing-planner"
+import type { EditPlanClip } from "@/api/template-editor"
 import type { CoverConfig } from "../../types/cover"
 import type { PresetVoiceItem } from "@/api/voices"
 import { DEFAULT_COVER_SETTINGS } from "../../constants"
@@ -18,7 +19,7 @@ import { usePersistedState } from "../usePersistedState"
 const DEFAULT_TITLE_SETTINGS: TitleSettings = {
   aiAutoSelect: false,
   title: "",
-  position: "bottom",
+  position: "top",
   font: "思源黑体",
   size: 28,
   bold: true,
@@ -46,6 +47,10 @@ export interface GenerateFormState {
   smartSelectedIds: string[]
   setSmartSelectedIds: (ids: string[]) => void
 
+  /* 服务端片段（/clips/from-assets 创建后获取） */
+  serverClips: EditPlanClip[]
+  setServerClips: (clips: EditPlanClip[]) => void
+
   /* 标题 */
   titleSettings: TitleSettings
   setTitleSettings: (settings: TitleSettings | ((prev: TitleSettings) => TitleSettings)) => void
@@ -116,6 +121,9 @@ export const useGenerateFormState = (): GenerateFormState => {
   const [materialMode, setMaterialMode] = useState<"manual" | "auto">("manual")
   const [smartSelectedIds, setSmartSelectedIds] = useState<string[]>([])
 
+  /* ── 服务端片段（供预览播放器使用）── */
+  const [serverClips, setServerClips] = useState<EditPlanClip[]>([])
+
   /* ── 标题设置 ── */
   const [titleSettings, setTitleSettings] = useState<TitleSettings>(DEFAULT_TITLE_SETTINGS)
 
@@ -196,6 +204,8 @@ export const useGenerateFormState = (): GenerateFormState => {
     setMaterialMode,
     smartSelectedIds,
     setSmartSelectedIds,
+    serverClips,
+    setServerClips,
     titleSettings,
     setTitleSettings,
     coverSettings,

apps/web/src/pages/generate/hooks/useGenerateVideo.ts

@@ -4,7 +4,7 @@
  */
 import { useState, useCallback } from "react"
 import { message } from "antd"
-import type { GeneratedVideo } from "@/api/template-editor"
+import { type GeneratedVideo, getEditPlanClips, createClipsFromAssets } from "@/api/template-editor"
 import { createGenerationTask } from "@/api/tasks/tasks"
 import type { UseGenerateVideoProps } from "./generate-video/types"
 import { getGenerationPhase } from "./generate-video/phase"
@@ -29,7 +29,6 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
       setGenerating(false)
       setGenerated(true)
       setGeneratedVideos(videos as GeneratedVideo[])
-      // 生成成功后清除持久化的预览状态，避免下次进入复用旧任务
       onGenerationSuccess?.()
     },
     [onGenerationSuccess],
@@ -45,12 +44,13 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
     onFailed: handleFailed,
   })
 
-  /* ── 生成视频 ── */
-  const generate = useCallback(async () => {
+  /* ── 生成视频 ──
+     返回 true 表示任务创建成功并已开始轮询；false 表示校验未通过或创建失败 */
+  const generate = useCallback(async (): Promise<boolean> => {
     const errorMsg = validateGenerateInputs(props)
     if (errorMsg) {
       message.warning(errorMsg)
-      return
+      return false
     }
 
     setGenerating(true)
@@ -60,7 +60,6 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
     clearTimer()
 
     try {
-      // 解析分辨率（共享工具函数）
       const { width: outputWidth, height: outputHeight } = calculateResolution(
         props.videoRatio || "9:16",
       )
@@ -68,57 +67,74 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
       const assetIds =
         props.materialMode === "auto" ? props.smartSelectedIds : props.selectedMaterials
 
-      // 封面 URL：优先 AI 生成缩略图，兜底用户上传
+      // from-assets 已由 useStep2Materials 在用户选素材时（debounce 800ms）调用，
+      // 后端已改为异步秒级返回，这里做一次轻量兜底：
+      // 单次查 clips，已有则直接放行；没有则再调一次 from-assets。
+      if (assetIds.length > 0 && selectedTemplate) {
+        try {
+          const clipList = await getEditPlanClips(selectedTemplate, { limit: 500 })
+          if (clipList.items.length === 0) {
+            // 片段不存在（极端情况：useStep2Materials 的 debounce 还没触发）
+            // 手动补一次 from-assets（后端秒级返回）
+            await createClipsFromAssets(selectedTemplate, assetIds, "main")
+          }
+        } catch {
+          // 查询失败不阻塞，继续生成
+        }
+      }
+
+      const hide = message.loading("正在生成预览视频...", 0)
+
       const coverUrl = props.coverSettings?.thumbnail_url || props.coverSettings?.upload_url || ""
 
-      // 解析配音参数：voice_library_id 是配音素材库 asset ID
-      // 优先用当前 voiceMode 对应的选择，兜底用 selectedVoice（防止 voiceMode 切换后丢失）
       const voiceLibraryId =
         props.voiceMode === "clone"
           ? props.selectedClonedVoice || props.selectedVoice || ""
           : props.selectedVoice || ""
 
-      // 创建生成任务（服务器渲染）
-      const taskResp = await createGenerationTask({
-        template_id: selectedTemplate,
-        asset_ids: assetIds,
-        output_width: outputWidth,
-        output_height: outputHeight,
-        cover_url: coverUrl,
-        custom_title: props.titleSettings?.title || "",
-        duration: props.duration || undefined,
-        video_ratio: props.videoRatio,
-        // 配音：始终传递 voice_library_id，确保后端能正确接收
-        voice_library_id: voiceLibraryId,
-        // 兜底：如果 voice_library_id 为空但 selectedVoice 有值，也传 voice_ids
-        ...(props.selectedVoice && !voiceLibraryId ? { voice_ids: [props.selectedVoice] } : {}),
-        // BGM 配置：受 bgm 开关控制，enabled=false 时也显式传覆盖模板 BGM
-        bgm_config: {
-          enabled: props.bgm !== false,
-          ...(props.bgmConfig?.music_id ? { preset_id: props.bgmConfig.music_id } : {}),
-        },
-        ...(props.sourceEditPlanId ? { source_edit_plan_id: props.sourceEditPlanId } : {}),
-        ...(props.titleSettings?.title
-          ? {
-              title_config: {
-                text: props.titleSettings.title,
-                font: props.titleSettings.font,
-                font_size: props.titleSettings.size,
-                font_color: props.titleSettings.color,
-                position: props.titleSettings.position,
-                bold: props.titleSettings.bold,
-                stroke: props.titleSettings.stroke,
-                shadow: props.titleSettings.shadow,
-              },
-            }
-          : {}),
-      })
-      const taskId = taskResp.items?.[0]?.id
+      try {
+        const taskResp = await createGenerationTask({
+          template_id: selectedTemplate,
+          asset_ids: assetIds,
+          output_width: outputWidth,
+          output_height: outputHeight,
+          cover_url: coverUrl,
+          custom_title: props.titleSettings?.title || "",
+          duration: props.duration || undefined,
+          video_ratio: props.videoRatio,
+          voice_library_id: voiceLibraryId,
+          ...(props.selectedVoice && !voiceLibraryId ? { voice_ids: [props.selectedVoice] } : {}),
+          bgm_config: {
+            enabled: props.bgm !== false,
+            ...(props.bgmConfig?.music_id ? { preset_id: props.bgmConfig.music_id } : {}),
+          },
+          ...(props.sourceEditPlanId ? { source_edit_plan_id: props.sourceEditPlanId } : {}),
+          ...(props.titleSettings?.title
+            ? {
+                title_config: {
+                  text: props.titleSettings.title,
+                  font: props.titleSettings.font,
+                  font_size: props.titleSettings.size,
+                  font_color: props.titleSettings.color,
+                  position: props.titleSettings.position,
+                  bold: props.titleSettings.bold,
+                  stroke: props.titleSettings.stroke,
+                  shadow: props.titleSettings.shadow,
+                },
+              }
+            : {}),
+        })
+        hide()
+        const taskId = taskResp.items?.[0]?.id
 
-      if (!taskId) {
-        throw new Error("创建任务成功但未返回任务 ID，请稍后在任务列表查看")
+        if (!taskId) {
+          throw new Error("创建任务成功但未返回任务 ID，请稍后在任务列表查看")
+        }
+        startPolling(taskId)
+      } catch (err) {
+        hide()
+        throw err
       }
-      startPolling(taskId)
     } catch (err: unknown) {
       console.error("[handleGenerate] 生成失败:", err)
       setGenerating(false)
@@ -127,21 +143,20 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
       const finalMsg = translateError(backendMsg)
       setGenerateError(finalMsg)
       message.error(finalMsg)
+      return false
     }
+    return true
   }, [props, clearTimer, startPolling, selectedTemplate])
 
-  /* 重新生成（失败后重试） */
   const retry = useCallback(() => {
     setGenerateError(null)
     generate()
   }, [generate])
 
-  /* 清除错误 */
   const dismissError = useCallback(() => {
     setGenerateError(null)
   }, [])
 
-  /* ── 下载视频 ── */
   const download = useCallback(async () => {
     if (!generatedVideos.length) return
     const video = generatedVideos[0]
@@ -162,7 +177,6 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
     }
   }, [generatedVideos])
 
-  /* ── 分享视频 ── */
   const share = useCallback(async () => {
     if (!generatedVideos.length) return
     const video = generatedVideos[0]
@@ -176,19 +190,16 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
   }, [generatedVideos])
 
   return {
-    // 状态
     generating,
     progress,
     generated,
     generateError,
     generatedVideos,
-    // 操作
     generate,
     retry,
     dismissError,
     download,
     share,
-    // 工具
     getGenerationPhase,
   }
 }

apps/web/src/pages/generate/hooks/useSegmentScheduler.ts

@@ -236,6 +236,12 @@ export function useSegmentScheduler(segments: PlaybackSegment[]): SegmentSchedul
       await waitForReady(video)
     }
 
+    // 播放前 seek 到片段起始时间，确保 progress 计算正确
+    const seg = segmentsRef.current[idx]
+    if (seg && Math.abs(video.currentTime - seg.startTime) > 0.1) {
+      video.currentTime = seg.startTime
+    }
+
     try {
       await video.play()
       setIsPlaying(true)

apps/web/src/pages/generate/hooks/useStep2Materials.ts

@@ -3,8 +3,10 @@
  * 组合素材库加载 + 智能匹配两个子 Hook
  */
 import { useCallback, useEffect, useRef } from "react"
+import { message } from "antd"
 import type { TemplateSegment } from "@/api/templates/types"
-import { updateEditPlanClips, createClipsFromAssets } from "@/api/template-editor"
+import type { EditPlanClip } from "@/api/template-editor"
+import { updateEditPlanClips, createClipsFromAssets, getEditPlanClips } from "@/api/template-editor"
 import { formatDuration } from "../utils/formatDuration"
 import { useMaterialLibrary } from "./step2-materials/useMaterialLibrary"
 import { useSmartMatch } from "./step2-materials/useSmartMatch"
@@ -21,6 +23,8 @@ interface UseStep2MaterialsProps {
   selectedTemplate?: string
   /** 当前模板的 segments（用于构建 clips duration） */
   templateSegments?: TemplateSegment[]
+  /** 服务端 clips 创建成功后的回调，用于通知预览播放器 */
+  onServerClipsChange?: (clips: EditPlanClip[]) => void
 }
 
 export function useStep2Materials({
@@ -32,6 +36,7 @@ export function useStep2Materials({
   onSmartSelectedIdsChange,
   selectedTemplate,
   templateSegments,
+  onServerClipsChange,
 }: UseStep2MaterialsProps) {
   const { libraries, selectedLibraryId, setSelectedLibraryId, materials, materialsLoading } =
     useMaterialLibrary()
@@ -83,12 +88,17 @@ export function useStep2Materials({
   templateSegmentsRef.current = templateSegments
   const selectedTemplateRef = useRef(selectedTemplate)
   selectedTemplateRef.current = selectedTemplate
+  const onServerClipsChangeRef = useRef(onServerClipsChange)
+  onServerClipsChangeRef.current = onServerClipsChange
 
   useEffect(() => {
     const tid = selectedTemplateRef.current
     if (!tid) return
     const ids = materialMode === "auto" ? smartSelectedIds : selectedMaterials
-    if (!ids.length) return
+    if (!ids.length) {
+      onServerClipsChangeRef.current?.([])
+      return
+    }
 
     if (clipsTimerRef.current) clearTimeout(clipsTimerRef.current)
     clipsTimerRef.current = setTimeout(async () => {
@@ -103,13 +113,28 @@ export function useStep2Materials({
       try {
         // 1. 清空旧片段
         await updateEditPlanClips(tid, [], controller.signal)
-        // 2. 调用后端 from-assets 接口创建片段
-        await createClipsFromAssets(tid, ids, "main", requiredClipsCount)
+        // 2. 调用后端 from-assets 接口创建片段（异步秒级返回，60s 超时仅为兜底）
+        await createClipsFromAssets(tid, ids, "main", requiredClipsCount, {
+          signal: controller.signal,
+        })
+        // 3. 获取服务端生成的 clips（含 start_time/duration），供预览播放器使用
+        const clipList = await getEditPlanClips(tid, { limit: 500 })
+        const readyClips = clipList.items
+          .filter((c) => c.status === "ready")
+          .sort((a, b) => a.order - b.order)
+        onServerClipsChangeRef.current?.(readyClips)
       } catch (err) {
         const name = (err as { name?: string })?.name
-        if (name !== "CanceledError" && name !== "AbortError") {
-          console.warn("[useStep2Materials] 写入 clips 失败:", err)
+        // 用户切换素材导致的主动取消，静默
+        if (name === "CanceledError" || name === "AbortError") return
+        // from-assets 60s 超时（MediaKit 智能选片未完成）
+        const code = (err as { code?: string })?.code
+        if (code === "ECONNABORTED" || /timeout/i.test((err as Error)?.message || "")) {
+          console.warn("[useStep2Materials] 智能选片超时:", err)
+          message.error("智能选片失败，请重试")
+          return
         }
+        console.warn("[useStep2Materials] 写入 clips 失败:", err)
       }
     }, 800)
 

apps/web/src/pages/generate/hooks/useStep6Cover.ts

@@ -1,13 +1,13 @@
 /**
  * Step 6 封面设置 Hook
- * 封装封面设置的交互逻辑，对接后端封面模板 CRUD API
+ * 封面候选帧从确认生成的最终视频中获取（MediaKit 选帧）
+ * 不再从预览片段创建预览视频
  */
-import { useCallback, useEffect, useRef, useState } from "react"
+import { useCallback, useEffect, useState } from "react"
 import { message } from "antd"
 import type { CoverConfig, CoverTemplate } from "../types/cover"
 import { generateCover } from "@/api/generation"
-import { createPreview, getPreviewStatus } from "@/api/generation/preview"
-import { updateEditPlan } from "@/api/template-editor"
+import type { GeneratedVideo } from "@/api/template-editor"
 import type { TitleSettings } from "../types"
 import {
   fetchCoverTemplates,
@@ -19,47 +19,22 @@ import {
 interface UseStep6CoverProps {
   coverSettings: CoverConfig
   onCoverSettingsChange: (settings: CoverConfig) => void
-  duration: number
-  /** 当前素材 ID 列表，用于智能封面生成 */
-  assetIds?: string[]
   /** 当前选中的模板 ID */
   selectedTemplate?: string
-  /** Step4 标题设置，用于预览视频烧录标题 & 封面叠加标题 */
+  /** Step4 标题设置，用于封面叠加标题 */
   titleSettings?: TitleSettings
-  /** 预览任务创建回调——将 task_id 暴露给父组件供 confirmGeneration 复用 */
-  onPreviewTaskCreated?: (taskId: string) => void
-  /** 从预览响应中提取到 source_edit_plan_id 时的回调 */
-  onSourceEditPlanIdExtracted?: (planId: string) => void
-  /** 配音模式 */
-  voiceMode?: "preset" | "custom" | "clone"
-  /** 选中的配音素材 ID（配音素材库 asset ID） */
-  selectedVoice?: string
-  /** 选中的克隆音色 ID */
-  selectedClonedVoice?: string
-  /** BGM 开关 */
-  bgm?: boolean
-  /** BGM 配置（来自模板） */
-  bgmConfig?: { enabled: boolean; music_id?: string }
+  /** 确认生成步骤产出的最终视频列表 */
+  generatedVideos: GeneratedVideo[]
 }
 
 export function useStep6Cover({
   coverSettings,
   onCoverSettingsChange,
-  duration,
-  assetIds = [],
   selectedTemplate = "",
   titleSettings,
-  onPreviewTaskCreated,
-  onSourceEditPlanIdExtracted,
-  voiceMode,
-  selectedVoice,
-  selectedClonedVoice,
-  bgm,
-  bgmConfig,
+  generatedVideos,
 }: UseStep6CoverProps) {
   const [generating, setGenerating] = useState(false)
-  // 防竞态：记录当前预览生成的参数指纹，任务完成时校验一致性
-  const previewParamsRef = useRef<string>("")
 
   // ── 封面设置弹窗状态 ──
   const [showCoverSettings, setShowCoverSettings] = useState(false)
@@ -72,6 +47,9 @@ export function useStep6Cover({
   const [templatesLoading, setTemplatesLoading] = useState(false)
   const [templatesError, setTemplatesError] = useState<string | null>(null)
 
+  /** 最终成片：取第一个已完成视频 */
+  const finalVideo = generatedVideos.find((v) => v.status === "completed") || generatedVideos[0]
+
   /** 从后端加载封面模板列表 */
   const loadTemplates = useCallback(async () => {
     setTemplatesLoading(true)
@@ -94,7 +72,7 @@ export function useStep6Cover({
     }
   }, [showCoverSettings, loadTemplates])
 
-  /** 调用后端智能封面 API，生成封面并更新预览 */
+  /** 调用后端智能封面 API，从最终成片中抽帧 */
   const generateAutoCover = useCallback(async () => {
     if (generating) {
       message.warning("封面正在生成中，请稍候...")
@@ -106,19 +84,20 @@ export function useStep6Cover({
       return
     }
 
-    if (assetIds.length === 0) {
-      message.error("请先选择素材")
+    if (!finalVideo) {
+      message.error("请先生成视频再选择封面")
       return
     }
 
     setGenerating(true)
-    // 超时保护：300 秒后强制重置，防止 state 卡死导致按钮永久失效
     const timeoutId = setTimeout(() => {
       setGenerating(false)
     }, 300000)
+
     try {
       const response = await generateCover(selectedTemplate, {
-        asset_ids: assetIds,
+        generated_video_id: finalVideo.id,
+        video_url: finalVideo.file_url || finalVideo.download_url || "",
         cover_type: "ai_frame",
         ...(titleSettings?.title
           ? {
@@ -151,151 +130,9 @@ export function useStep6Cover({
       clearTimeout(timeoutId)
       console.error("[Step6] 智能封面生成失败:", err)
 
-      // 提取详细错误信息
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const anyErr = err as any
-      const statusCode = anyErr?.response?.status
-
-      // 400 错误：精确判断是否为"预览缺失"，避免误判其他 400 错误
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const errCode = anyErr?.response?.data?.code as string | undefined
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const errMsg = (anyErr?.response?.data?.message ||
-        anyErr?.response?.data?.detail ||
-        "") as string
-      const isPreviewMissing =
-        statusCode === 400 &&
-        (errCode?.includes("PREVIEW") ||
-          /预览.*(?:缺失|不存在|未找到)|(?:missing|not found|does not exist).*preview/i.test(
-            errMsg,
-          ))
-
-      if (isPreviewMissing) {
-        console.log("[Step6] 检测到预览缺失，尝试自动创建预览渲染任务...")
-        message.info("正在准备预览视频，请稍候...")
-        try {
-          // 记录当前参数指纹，用于任务完成时校验一致性（防竞态）
-          previewParamsRef.current = JSON.stringify({ selectedTemplate, assetIds, titleSettings })
-          // 解析配音参数：voiceMode=clone 时用 selectedClonedVoice，否则用 selectedVoice
-          const previewVoiceLibraryId =
-            voiceMode === "clone" ? selectedClonedVoice || selectedVoice || "" : selectedVoice || ""
-          const previewResp = await createPreview({
-            template_id: selectedTemplate,
-            asset_ids: assetIds,
-            duration: duration || 30,
-            // 配音：始终传递 voice_library_id，确保后端能正确接收
-            voice_library_id: previewVoiceLibraryId,
-            // 兜底：如果 voice_library_id 为空但 selectedVoice 有值，也传 voice_ids
-            ...(selectedVoice && !previewVoiceLibraryId ? { voice_ids: [selectedVoice] } : {}),
-            // BGM 配置：受 bgm 开关控制
-            bgm_config: {
-              enabled: bgm !== false,
-              ...(bgmConfig?.music_id ? { preset_id: bgmConfig.music_id } : {}),
-            },
-            ...(titleSettings?.title
-              ? {
-                  title_config: {
-                    text: titleSettings.title,
-                    font: titleSettings.font,
-                    font_size: titleSettings.size,
-                    font_color: titleSettings.color,
-                    position: titleSettings.position,
-                    bold: titleSettings.bold,
-                    stroke: titleSettings.stroke,
-                    shadow: titleSettings.shadow,
-                  },
-                }
-              : {}),
-          })
-          // 将预览任务 ID 暴露给父组件，供 Step7 确认生成时复用（confirmGeneration）
-          const currentFingerprint = JSON.stringify({ selectedTemplate, assetIds, titleSettings })
-          if (previewResp.task_id && previewParamsRef.current === currentFingerprint) {
-            onPreviewTaskCreated?.(previewResp.task_id)
-            // 提取后端自动关联的 source_edit_plan_id，供 fallback 路径使用
-            if (previewResp.source_edit_plan_id) {
-              onSourceEditPlanIdExtracted?.(previewResp.source_edit_plan_id)
-            }
-          }
-          // 轮询等待预览渲染完成：递归 setTimeout 避免请求重叠 + 120s 超时兜底
-          await new Promise<void>((resolve, reject) => {
-            let finished = false
-            const done = (fn: () => void) => {
-              if (finished) return
-              finished = true
-              clearTimeout(timeoutId)
-              fn()
-            }
-            const timeoutId = setTimeout(() => {
-              done(() => reject(new Error("预览生成超时，请稍后重试")))
-            }, 120_000)
-            const poll = async () => {
-              if (finished) return
-              try {
-                const status = await getPreviewStatus(previewResp.task_id)
-                if (status.status === "completed") {
-                  // 保存预览视频地址到 plan.config.rendered_storage_key，
-                  // 供封面 API 的 E1 兜底路径定位渲染后的视频（含标题烧录）。
-                  // video_url 可能是完整 http(s) URL 或 OSS storage_key，两种格式后端都能处理。
-                  if (status.video_url) {
-                    try {
-                      await updateEditPlan(selectedTemplate, {
-                        config: { rendered_storage_key: status.video_url },
-                      })
-                    } catch (saveErr) {
-                      console.warn(
-                        "[Step6] 保存 rendered_storage_key 失败（不阻塞封面重试）:",
-                        saveErr,
-                      )
-                    }
-                  }
-                  done(() => resolve())
-                } else if (status.status === "failed") {
-                  done(() => reject(new Error(status.error_message || "预览渲染失败")))
-                } else {
-                  setTimeout(poll, 2000)
-                }
-              } catch (e) {
-                done(() => reject(e))
-              }
-            }
-            poll()
-          })
-          message.success("预览视频就绪，重新生成封面...")
-          // 重试封面生成
-          const retryResp = await generateCover(selectedTemplate, {
-            asset_ids: assetIds,
-            cover_type: "ai_frame",
-            ...(titleSettings?.title
-              ? {
-                  title_config: {
-                    text: titleSettings.title,
-                    font: titleSettings.font,
-                    font_size: titleSettings.size,
-                    font_color: titleSettings.color,
-                    position: titleSettings.position,
-                    bold: titleSettings.bold,
-                    stroke: titleSettings.stroke,
-                    shadow: titleSettings.shadow,
-                  },
-                }
-              : {}),
-          })
-          const retryUrl = retryResp.cover?.image_url || ""
-          if (retryUrl) {
-            onCoverSettingsChange({
-              ...coverSettings,
-              thumbnail_url: retryUrl,
-              ai_suggested_time: retryResp.cover?.frame_time ?? null,
-            })
-            message.success("封面生成成功")
-          } else {
-            message.warning("封面生成未返回图片，请重试")
-          }
-        } catch (retryErr) {
-          console.error("[Step6] 自动创建预览后重试失败:", retryErr)
-          message.error("预览视频创建失败，请稍后重试")
-        }
-      } else if (anyErr?.__msgShown) {
+      if (anyErr?.__msgShown) {
         // 拦截器已处理，不再重复弹出
       } else {
         let errorMsg = "封面生成失败"
@@ -310,31 +147,21 @@ export function useStep6Cover({
           console.error("[Step6] 后端返回:", e.response.data)
         } else if (e.request) {
           errorMsg = "服务器无响应，请检查网络连接"
-          console.error("[Step6] 请求无响应:", e.request)
         } else if (e.message) {
           errorMsg = e.message
         }
         message.error(errorMsg)
       }
     } finally {
-      clearTimeout(timeoutId)
       setGenerating(false)
     }
   }, [
     selectedTemplate,
-    assetIds,
+    finalVideo,
     coverSettings,
     onCoverSettingsChange,
     generating,
-    duration,
     titleSettings,
-    onPreviewTaskCreated,
-    onSourceEditPlanIdExtracted,
-    voiceMode,
-    selectedVoice,
-    selectedClonedVoice,
-    bgm,
-    bgmConfig,
   ])
 
   // ── 模板操作方法 ──
@@ -391,13 +218,11 @@ export function useStep6Cover({
   const selectedTemplateName =
     coverTemplates.find((t) => t.id === selectedTemplateId)?.name || "默认"
 
-  const totalDuration = duration || 30
-
   return {
     coverSettings,
     generating,
     generateAutoCover,
-    totalDuration,
+    finalVideo,
     showCoverSettings,
     setShowCoverSettings,
     showCoverEditor,

apps/web/src/pages/generate/hooks/useStep7Generate.ts

@@ -87,7 +87,9 @@ export function useStep7Generate({
   }
 
   const handleScrollToPreview = () => {
-    const el = document.querySelector(".xx-preview-section")
+    const el =
+      document.querySelector(".xx-inline-video-player") ||
+      document.querySelector(".xx-preview-section")
     el?.scrollIntoView({ behavior: "smooth", block: "start" })
   }
 

apps/web/src/pages/generate/hooks/useStepNavigation.ts

@@ -1,9 +1,6 @@
 /**
  * GeneratePage 步骤导航
- * 管理步骤切换与各步骤的前置校验
- * 步骤顺序：模板(1) → 素材(2) → 配音(3) → 标题(4) → 预览(5) → 封面(6) → 确认(7)
- *
- * 前端实时预览架构：Step5 无需等待服务器渲染
+ * 步骤顺序（6步）：模板(1) → 素材(2) → 配音(3) → 标题(4) → 确认生成(5) → 封面(6)
  */
 import { message } from "antd"
 import type { TitleSettings } from "../types"
@@ -16,6 +13,10 @@ export interface UseStepNavigationOptions {
   selectedMaterials: string[]
   smartSelectedIds: string[]
   titleSettings: TitleSettings
+  /** 预览是否已就绪（素材已加载，可播放） */
+  previewReady: boolean
+  /** 是否已完成视频生成（步骤5确认生成后才能进入封面） */
+  generated: boolean
 }
 
 export interface UseStepNavigationReturn {
@@ -32,6 +33,8 @@ export const useStepNavigation = (options: UseStepNavigationOptions): UseStepNav
     selectedMaterials,
     smartSelectedIds,
     titleSettings,
+    previewReady,
+    generated,
   } = options
 
   const goNext = () => {
@@ -47,11 +50,23 @@ export const useStepNavigation = (options: UseStepNavigationOptions): UseStepNav
       message.warning("请先进行智能匹配并选择素材")
       return
     }
-    if (currentStep === 4 && !titleSettings.title.trim()) {
-      message.warning("请选择或输入标题")
+    // Step4（标题+预览）：标题必填 + 预览必须已加载
+    if (currentStep === 4) {
+      if (!titleSettings.title.trim()) {
+        message.warning("请选择或输入标题")
+        return
+      }
+      if (!previewReady) {
+        message.warning("预览视频正在加载，请稍候")
+        return
+      }
+    }
+    // Step5（确认生成）：必须已完成生成才能进入封面
+    if (currentStep === 5 && !generated) {
+      message.warning("请先生成视频")
       return
     }
-    if (currentStep < 7) {
+    if (currentStep < 6) {
       setCurrentStep((s) => s + 1)
     }
   }

apps/web/src/test/pages/generate/smoke.test.tsx

@@ -17,7 +17,6 @@ import "@/api/generation/types"
 // 直接引入所有 Step 组件，建立完整依赖链
 import "@/pages/generate/GeneratePage"
 import "@/pages/generate/components/Step2MaterialSelect"
-import "@/pages/generate/components/Step5GeneratePreview"
 import "@/pages/generate/components/Step4TitleSettings"
 import "@/pages/generate/components/Step5VoiceSelect"
 import "@/pages/generate/components/PreviewVideoPanel"

apps/web/src/test/pages/generate/step5-preview.smoke.test.tsx

@@ -1,10 +1,9 @@
 /**
- * Step5GeneratePreview smoke test
+ * Step4+5 merged preview smoke test
  * 确保 vitest related 模式能匹配到第5步预览生成相关文件的改动
  */
 import { describe, it, expect } from "vitest"
 
-import "@/pages/generate/components/Step5GeneratePreview"
 import "@/pages/generate/hooks/usePreviewAssets"
 import "@/pages/generate/hooks/useSegmentScheduler"
 import "@/pages/generate/components/FrontendPreviewPlayer"
@@ -12,8 +11,8 @@ import "@/pages/generate/hooks/useStepNavigation"
 import "@/pages/generate/components/GenerateStepContent"
 import "@/pages/generate/GeneratePage"
 
-describe("Step5GeneratePreview module smoke test", () => {
-  it("should load all step5 preview modules", () => {
+describe("Merged Step4+5 preview module smoke test", () => {
+  it("should load all merged step4+5 preview modules", () => {
     expect(true).toBe(true)
   })
 })

apps/worker/video_processing/render_adapter.py

@@ -575,12 +575,13 @@ class RenderAdapter:
 
         self._report_progress(progress_cb, 90.0, "生成封面缩略图")
 
-        # 6. 生成封面缩略图
+        # 6. 生成封面缩略图（结果通过 RenderAdapterResult.thumbnail_url 返回给调用方）
         thumbnail_url = ""
         try:
             from video_processing.thumbnail_generator import generate_and_upload_thumbnail
 
-            thumb_storage_key = f"rendered/{plan_id}/thumbnail.jpg"
+            # job_id 是 _do_render 方法的参数（参见方法签名）
+            thumb_storage_key = f"rendered/{plan_id}/thumbnails/{job_id}.jpg"
             thumbnail_url = generate_and_upload_thumbnail(str(result.output_path), thumb_storage_key)
         except Exception as thumb_err:
             logger.warning(
@@ -598,7 +599,7 @@ class RenderAdapter:
             # 抽帧天然带标题，因此这里传空字符串，避免 Pillow 二次叠加导致重影。
             # Pillow 叠加仅用于 API 从源素材抽帧（源素材本身无标题）的兜底场景。
             cover_candidates = extract_and_upload_cover_frames(
-                str(result.output_path), plan_id, num_frames=3, title_text=""
+                str(result.output_path), plan_id, task_id=job_id, num_frames=3, title_text=""
             )
             if cover_candidates:
                 logger.info(

apps/worker/video_processing/thumbnail_generator.py

@@ -278,6 +278,7 @@ def extract_and_upload_cover_frames(
     video_path: str,
     plan_id: str,
     *,
+    task_id: str = "",
     num_frames: int = 3,
     title_text: str = "",
     title_color: str = "#ffffff",
@@ -291,6 +292,7 @@ def extract_and_upload_cover_frames(
     Args:
         video_path: 视频文件路径
         plan_id: 编辑计划 ID（用于生成 storage key）
+        task_id: 任务 ID（用于生成独立的 storage key，避免标题变更时封面冲突）
         num_frames: 抽取帧数（默认 3）
         title_text: 标题文字；非空时用 Pillow 叠加到每帧。
             从已渲染视频抽帧时通常传空（标题已烧录）；从源素材抽帧时传标题。
@@ -338,7 +340,7 @@ def extract_and_upload_cover_frames(
                         font_size=title_font_size,
                     )
 
-                storage_key = f"covers/{plan_id}/mediakit_frame_{i}.jpg"
+                storage_key = f"covers/{plan_id}/{task_id}/mediakit_frame_{i}.jpg"
                 url = upload_to_oss(tmp.name, storage_key)
                 if url:
                     seek_time = frame.get("timestamp", 0.0)
@@ -377,7 +379,7 @@ def extract_and_upload_cover_frames(
                     position=title_position,
                     font_size=title_font_size,
                 )
-            storage_key = f"covers/{plan_id}/frame_{i}.jpg"
+            storage_key = f"covers/{plan_id}/{task_id}/frame_{i}.jpg"
             url = upload_to_oss(frame_path, storage_key)
             if url:
                 seek_time = max(0.5, duration * ratio) if duration > 0 else 0.0

apps/worker/worker_app/tasks/__init__.py

@@ -49,10 +49,15 @@ def __getattr__(name: str):
         from .ai_tasks import run_generate_cover
 
         return run_generate_cover
+    elif name == "batch_generate_thumbnails":
+        from .batch_thumbnail import batch_generate_thumbnails
+
+        return batch_generate_thumbnails
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
 __all__ = [
+    "batch_generate_thumbnails",
     "classify_asset",
     "generate_video",
     "healthcheck",

apps/worker/worker_app/tasks/batch_thumbnail.py

@@ -0,0 +1,165 @@
+"""批量修复素材缩略图 — 为历史视频素材生成缩略图。
+
+使用方式：
+  从管理接口或 shell 触发：
+    celery_app.send_task("worker.batch_generate_thumbnails")
+
+逻辑：
+  1. 查询所有 file_type=video 且 thumbnail_url 为空或为旧格式公开 URL 的素材
+  2. 逐个：下载视频 → 抽第一帧 → 上传 OSS → 更新 thumbnail_url 为 storage_key
+  3. 每处理 50 条 commit 一次，失败单条跳过不阻塞
+"""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from celery.utils.log import get_task_logger
+from worker_app.celery_app import celery_app
+from worker_app.db import SessionLocal
+
+logger = get_task_logger(__name__)
+
+# 旧格式 URL 前缀（ingest 旧代码生成的公开 URL），需替换为 storage_key
+_OLD_URL_PREFIX = "https://xiaoxia-autocut.oss-cn-hangzhou.aliyuncs.com/"
+# 从公开 URL 中提取 storage_key 时，去掉域名前缀即可
+_DOMAIN_PREFIXES = [
+    "https://xiaoxia-autocut.oss-cn-hangzhou.aliyuncs.com/",
+    "http://xiaoxia-autocut.oss-cn-hangzhou.aliyuncs.com/",
+]
+
+
+def _url_to_storage_key(url: str) -> str | None:
+    """尝试将旧格式公开 URL 转回 storage_key。"""
+    for prefix in _DOMAIN_PREFIXES:
+        if url.startswith(prefix):
+            return url[len(prefix) :]
+    return None
+
+
+@celery_app.task(name="worker.batch_generate_thumbnails")
+def batch_generate_thumbnails() -> dict:
+    """为所有缺少缩略图的视频素材批量生成缩略图。
+
+    Returns:
+        dict: {total, success, skipped, failed, converted_legacy}
+    """
+    from video_processing.oss_helpers import download_asset, upload_to_oss
+    from video_processing.thumbnail_generator import extract_first_frame
+
+    from packages.adapters.sqlalchemy_impl.models import AssetModel
+
+    db = SessionLocal()
+    stats = {"total": 0, "success": 0, "skipped": 0, "failed": 0, "converted_legacy": 0}
+
+    try:
+        # 查询所有视频素材中缩略图缺失的
+        assets = (
+            db.query(AssetModel)
+            .filter(
+                AssetModel.file_type == "video",
+                AssetModel.status != "deleted",
+            )
+            .all()
+        )
+
+        # 筛选需要处理的：thumbnail_url 为空 或 旧格式公开 URL
+        to_process = []
+        for asset in assets:
+            thumb = asset.thumbnail_url or ""
+            if not thumb:
+                to_process.append((asset, None))  # (asset, None=需要新生成)
+            elif thumb.startswith("http"):
+                # 旧格式公开 URL → 尝试转为 storage_key
+                sk = _url_to_storage_key(thumb)
+                if sk:
+                    to_process.append((asset, sk))  # 已有文件，只需改 DB
+                else:
+                    # 非预期 URL 格式，跳过
+                    stats["skipped"] += 1
+            # else: 已经是 storage_key 格式，跳过
+
+        stats["total"] = len(to_process)
+        logger.info(
+            "批量缩略图修复启动: total=%d (new=%d, legacy_convert=%d)",
+            stats["total"],
+            sum(1 for _, sk in to_process if sk is None),
+            sum(1 for _, sk in to_process if sk is not None),
+        )
+
+        batch_count = 0
+        for asset, existing_key in to_process:
+            try:
+                if existing_key is not None:
+                    # 旧 URL → storage_key，只需更新 DB
+                    asset.thumbnail_url = existing_key
+                    stats["converted_legacy"] += 1
+                    stats["success"] += 1
+                else:
+                    # 需要新生成缩略图
+                    if not asset.storage_key:
+                        stats["skipped"] += 1
+                        continue
+
+                    suffix = Path(asset.storage_key).suffix or ".mp4"
+                    local_file = None
+                    frame_path = None
+                    try:
+                        # 下载视频
+                        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
+                            local_file = Path(tmp.name)
+
+                        if not download_asset(asset.storage_key, local_file):
+                            logger.warning("下载失败: asset_id=%s key=%s", asset.id, asset.storage_key[:60])
+                            stats["failed"] += 1
+                            continue
+
+                        # 抽帧
+                        frame_path = extract_first_frame(str(local_file), width=640)
+
+                        # 上传
+                        thumb_key = f"assets/{asset.project_id}/thumbnails/{asset.id}.jpg"
+                        upload_ok = upload_to_oss(frame_path, thumb_key)
+                        if upload_ok:
+                            asset.thumbnail_url = thumb_key
+                            stats["success"] += 1
+                        else:
+                            logger.warning("上传失败: asset_id=%s", asset.id)
+                            stats["failed"] += 1
+                    finally:
+                        if local_file and local_file.exists():
+                            try:
+                                local_file.unlink(missing_ok=True)
+                            except OSError:
+                                pass
+                        if frame_path and Path(frame_path).exists():
+                            try:
+                                Path(frame_path).unlink(missing_ok=True)
+                            except OSError:
+                                pass
+
+                batch_count += 1
+                if batch_count % 50 == 0:
+                    db.commit()
+                    logger.info("批量缩略图进度: %d/%d", batch_count, stats["total"])
+
+            except Exception as e:
+                logger.warning("单条处理失败: asset_id=%s error=%s", asset.id, e)
+                stats["failed"] += 1
+                try:
+                    db.rollback()
+                except Exception:
+                    pass
+
+        # 最后提交
+        db.commit()
+        logger.info("批量缩略图修复完成: %s", stats)
+        return stats
+
+    except Exception as e:
+        logger.error("批量缩略图修复异常: %s", e)
+        db.rollback()
+        return {**stats, "error": str(e)}
+    finally:
+        db.close()

apps/worker/worker_app/tasks/generation.py

@@ -389,6 +389,7 @@ def _upload_and_record(
     editing_mode,
     user_id: str = "",
     video_name: str = "",
+    thumbnail_url: str = "",
 ) -> tuple[str, float, int, int]:
     """上传 OSS、创建视频记录并查重。
 
@@ -447,6 +448,7 @@ def _upload_and_record(
             mode=editing_mode.value,
             session=dedup_session,
             name=video_name,
+            thumbnail_url=thumbnail_url,
         )
     finally:
         dedup_session.close()
@@ -535,11 +537,11 @@ def _render_from_edit_plan(
     task_id: str,
     source_edit_plan_id: str,
     task_info: dict,
-) -> tuple[Path, float, list[dict] | None, str | None, str | None]:
+) -> tuple[Path, float, list[dict] | None, str | None, str | None, str]:
     """从 EditPlan 数据库记录直接渲染（不再内存重建clips）。
 
     Returns:
-        (output_path, render_duration, cover_candidates, voiceover_path, temp_dir)
+        (output_path, render_duration, cover_candidates, voiceover_path, temp_dir, thumbnail_url)
     """
     from video_processing.render_adapter import RenderAdapter
     from worker_app.db import SessionLocal
@@ -580,7 +582,14 @@ def _render_from_edit_plan(
         cover_candidates = getattr(result, "cover_candidates", None)
         render_temp_dir = getattr(result, "temp_dir", None)
 
-        return output_path, result.duration, cover_candidates, voiceover_path, render_temp_dir
+        return (
+            output_path,
+            result.duration,
+            cover_candidates,
+            voiceover_path,
+            render_temp_dir,
+            result.thumbnail_url or "",
+        )
     finally:
         db.close()
 
@@ -692,7 +701,7 @@ def generate_video(self, task_id: str) -> dict:
                     gen_task.append_log("渲染模式", "从草稿数据渲染（与预览一致）")
                     _flush_logs(task_id, gen_task)
 
-                output_path, render_duration, cover_candidates, voiceover_tmp_path, render_temp_dir = (
+                output_path, render_duration, cover_candidates, voiceover_tmp_path, render_temp_dir, thumbnail_url = (
                     _render_from_edit_plan(
                         task_id=task_id,
                         source_edit_plan_id=source_edit_plan_id,
@@ -717,6 +726,7 @@ def generate_video(self, task_id: str) -> dict:
                         editing_mode=editing_mode,
                         user_id=user_id,
                         video_name=task_info.get("video_title", ""),
+                        thumbnail_url=thumbnail_url,
                     )
 
                     if gen_task:

apps/worker/worker_app/tasks/ingest.py

@@ -214,20 +214,26 @@ def ingest_asset(job_id: str) -> dict:
 
                     frame_path = extract_first_frame(str(local_file), width=640)
                     thumb_storage_key = f"assets/{job.project_id}/thumbnails/{job_id}.jpg"
-                    try:
-                        thumbnail_url = upload_to_oss(frame_path, thumb_storage_key)
-                    finally:
-                        if frame_path:
-                            try:
-                                Path(frame_path).unlink(missing_ok=True)
-                            except Exception:
-                                pass
-                    if thumbnail_url:
+                    upload_ok = upload_to_oss(frame_path, thumb_storage_key)
+                    if upload_ok:
+                        # 存储 storage_key（非公开 URL），API 层通过 get_download_url 生成签名 URL
+                        thumbnail_url = thumb_storage_key
                         logger.info(
-                            "素材缩略图生成成功: job_id=%s url=%s",
+                            "素材缩略图生成成功: job_id=%s key=%s",
                             job_id,
-                            thumbnail_url[:80],
+                            thumb_storage_key[:80],
                         )
+                    else:
+                        logger.warning(
+                            "素材缩略图上传 OSS 失败: job_id=%s",
+                            job_id,
+                        )
+                    # frame_path 是临时文件，及时清理
+                    if frame_path:
+                        try:
+                            Path(frame_path).unlink(missing_ok=True)
+                        except Exception:
+                            pass
                 except Exception as thumb_err:
                     logger.warning(
                         "素材缩略图生成失败（不影响主流程）: job_id=%s error=%s",

packages/domain/ass_subtitle_builder.py

@@ -224,8 +224,8 @@ def _wrap_title_text(
     if available_width <= 0:
         return text
 
-    # 换行宽度必须与实际渲染（补偿后的 ASS Fontsize）一致，否则换行位置会错位
-    ass_font_size = _compensate_ass_fontsize(font_size)
+    # 换行计算使用原始 font_size，与 CSS 预览一致；1.35x 补偿仅用于 ASS Fontsize 渲染
+
 
     # 先按已有 \N 分段，每段独立自动换行，最后用 \N 拼回
     segments = text.split("\\N")
@@ -238,7 +238,7 @@ def _wrap_title_text(
 
         for ch in seg:
             # CJK 字符按全角估算，其他按半角
-            char_width = float(ass_font_size) if ord(ch) > 0x2E80 else ass_font_size * 0.55
+            char_width = float(font_size) if ord(ch) > 0x2E80 else font_size * 0.55
 
             if current_width + char_width > available_width and current_line:
                 lines.append(current_line)

tests/unit/domain/test_ass_subtitle_builder.py

@@ -15,6 +15,7 @@ from packages.domain.ass_subtitle_builder import (
     TITLE_MARGIN_BOTTOM,
     TITLE_MARGIN_SIDE,
     TITLE_MARGIN_TOP,
+    _wrap_title_text,
     build_ass_content,
     build_ass_style,
     escape_ass_text,
@@ -579,3 +580,44 @@ class TestConstants:
         assert isinstance(TITLE_MARGIN_TOP, int)
         assert isinstance(TITLE_MARGIN_BOTTOM, int)
         assert isinstance(TITLE_MARGIN_SIDE, int)
+
+# ============================================================
+# _wrap_title_text 换行逻辑验证
+# ============================================================
+
+
+class TestWrapTitleTextFontSizeConsistency:
+    """验证换行计算使用原始 font_size，与 CSS 预览一致。"""
+
+    def test_font_size_113_uses_original_not_compensated(self):
+        """font_size=113 时，每行应容纳8个字（113px字宽），而非6个字（153px字宽）。"""
+        # 标题"永康拾掇脚阔头"共7个字
+        # 可用宽度 = 1080 - 60 - 60 = 960px
+        # 用 font_size=113：char_width=113，960/113 ≈ 8.5，每行8个字
+        # 7个字 < 8个字，应该在一行内
+        title = "永康拾掇脚阔头"
+        result = _wrap_title_text(title, video_width=1080, font_size=113, margin_l=60, margin_r=60)
+        # 不应该有换行
+        assert "\\N" not in result
+        assert result == title
+
+    def test_long_title_wraps_correctly(self):
+        """长标题应该按 font_size 字宽正确换行。"""
+        # 16个中文字，每行8个字，应该换行为2行
+        title = "永康拾掇脚阔头来一个笑一个哈哈哈"
+        result = _wrap_title_text(title, video_width=1080, font_size=113, margin_l=60, margin_r=60)
+        # 应该有一个换行
+        assert result.count("\\N") == 1
+        # 每行8个字
+        lines = result.split("\\N")
+        assert len(lines) == 2
+        assert len(lines[0]) == 8
+        assert len(lines[1]) == 8
+
+    def test_mixed_cjk_and_ascii(self):
+        """混合中英文时，英文按半角宽度计算。"""
+        # "测试test" = 2个中文(2*113=226) + 4个英文(4*113*0.55=248.6) = 474.6px
+        title = "测试test"
+        result = _wrap_title_text(title, video_width=1080, font_size=113, margin_l=60, margin_r=60)
+        # 总宽度474.6px < 960px，应该在一行内
+        assert "\\N" not in result

tests/unit/test_editor_clips_random_start.py

@@ -1,14 +1,15 @@
-"""测试编辑器 from-assets 端点：同一素材切多个片段 + 随机起始 + 去重.
+"""测试编辑器 from-assets 端点：按模板segment创建片段 + 事务性替换 + 随机起始.
 
 覆盖：
-- required_clips_count 精确控制片段数量
+- 片段数量 = segment 数量（required_clips_count 被忽略）
 - 素材不足时同一素材轮询切多个片段
 - 随机 start_time + used_segments 去重
 - 素材时长不足时 clip duration 缩短
-- 向后兼容（不传 required_clips_count 时等于素材数量）
-- order 追加到时间线末尾
+- 素材时长为 0 时抛 400
+- 使用 replace_all_clips_transactional 原子性替换
+- order 从 0 开始
 - start_time=None 时抛出 400
-- create_clip 失败时抛出 400 并记录日志
+- mark_clips_ready 在事务方法内部完成
 """
 
 from __future__ import annotations
@@ -29,6 +30,20 @@ from fastapi import HTTPException
 TEST_PLAN_ID = "plan-draft-001"
 TEST_USER_ID = "user-001"
 
+# 默认测试用 segments：4 个片段，每个 3~5 秒
+DEFAULT_SEGMENTS = [(0, 3.0, 5.0), (1, 3.0, 5.0), (2, 3.0, 5.0), (3, 3.0, 5.0)]
+
+
+def _segments(count: int, dur_min: float = 3.0, dur_max: float = 5.0):
+    return [(i, dur_min, dur_max) for i in range(count)]
+
+
+def _patch_segments(segments=None):
+    return patch(
+        "app.api.routes.templates_editor.clips._get_template_segments",
+        return_value=segments if segments is not None else DEFAULT_SEGMENTS,
+    )
+
 
 def _make_auth_user():
     auth = MagicMock()
@@ -39,27 +54,6 @@ def _make_auth_user():
     return auth
 
 
-def _make_mock_clip(clip_id, order, duration, start_time=0.0, asset_id=""):
-    clip = MagicMock()
-    clip.id = clip_id
-    clip.plan_id = TEST_PLAN_ID
-    clip.clip_type = "main"
-    clip.order = order
-    clip.duration = duration
-    clip.start_time = start_time
-    clip.text_content = ""
-    clip.transition_effect = "cut"
-    clip.transition_duration = 0.0
-    clip.playback_speed = 1.0
-    clip.config = {}
-    clip.asset_id = asset_id
-    clip.status = "pending"
-    clip.template_clip_config_id = ""
-    clip.created_at = None
-    clip.updated_at = None
-    return clip
-
-
 def _make_mock_asset(asset_id, duration):
     asset = MagicMock()
     asset.id = asset_id
@@ -67,123 +61,130 @@ def _make_mock_asset(asset_id, duration):
     return asset
 
 
-def _create_clips(plan_id, clip_type, order, duration=0.0, start_time=0.0, asset_id="", **kw):
-    return _make_mock_clip(
-        clip_id=f"clip-{order}",
-        order=order,
-        duration=duration,
-        start_time=start_time,
-        asset_id=asset_id,
-    )
-
-
-def _make_plan_svc(existing_clips=None):
+def _make_plan_svc(replace_return_count=None):
     svc = MagicMock()
-    svc.get_plan_or_raise = MagicMock()
-    svc.create_clip = MagicMock(side_effect=_create_clips)
-    svc.list_clips = MagicMock(return_value=existing_clips or [])
+    # replace_all_clips_transactional 返回创建的片段数量
+    if replace_return_count is not None:
+        svc.replace_all_clips_transactional = MagicMock(return_value=replace_return_count)
+    else:
+        svc.replace_all_clips_transactional = MagicMock(return_value=0)
     return svc
 
 
-class TestEditorClipsRequiredCount:
-    """测试 required_clips_count 控制片段数量 + 同素材多片段."""
+def _get_clips_data_from_call(mock_plan_svc):
+    """从 replace_all_clips_transactional 的调用中获取 clips_data。"""
+    assert mock_plan_svc.replace_all_clips_transactional.called, "replace_all_clips_transactional 未被调用"
+    call_args = mock_plan_svc.replace_all_clips_transactional.call_args
+    # call_args = ((plan_id, clips_data), kwargs)
+    if len(call_args.args) >= 2:
+        return call_args.args[1]
+    return call_args.kwargs.get("clips_data", [])
+
+
+class TestEditorClipsBySegments:
+    """测试按 segment 数量创建片段 + 素材轮询。"""
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
-    def test_creates_exactly_required_clips_count(self, mock_storage):
-        """required_clips_count=4 时，即使只有2个素材也创建4个片段."""
+    def test_creates_clips_matching_segment_count(self, mock_storage):
+        """4 个 segment 即使只有2个素材也创建4个片段，required_clips_count 被忽略。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
         from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
 
-        mock_plan_svc = _make_plan_svc()
+        mock_plan_svc = _make_plan_svc(replace_return_count=4)
         mock_asset_repo = MagicMock()
         mock_asset_repo.get = MagicMock(side_effect=lambda aid: _make_mock_asset(aid, {"a1": 30.0, "a2": 20.0}[aid]))
 
-        body = ClipsFromAssetsRequest(asset_ids=["a1", "a2"], required_clips_count=4)
+        body = ClipsFromAssetsRequest(asset_ids=["a1", "a2"], required_clips_count=2)
 
-        result = create_clips_from_assets_editor(
-            template_id="tpl-001",
-            body=body,
-            plan_id=TEST_PLAN_ID,
-            services=(MagicMock(), mock_plan_svc),
-            asset_repo=mock_asset_repo,
-            current_user=_make_auth_user(),
-        )
+        with _patch_segments(DEFAULT_SEGMENTS):
+            result = create_clips_from_assets_editor(
+                template_id="tpl-001",
+                body=body,
+                background_tasks=MagicMock(),
+                plan_id=TEST_PLAN_ID,
+                services=(MagicMock(), mock_plan_svc),
+                asset_repo=mock_asset_repo,
+                db=MagicMock(),
+                current_user=_make_auth_user(),
+            )
 
         assert result.created_count == 4
-        assert mock_plan_svc.create_clip.call_count == 4
+        clips_data = _get_clips_data_from_call(mock_plan_svc)
+        assert len(clips_data) == 4
 
         # 验证轮询分配：a1, a2, a1, a2
-        calls = mock_plan_svc.create_clip.call_args_list
-        assert calls[0].kwargs["asset_id"] == "a1"
-        assert calls[1].kwargs["asset_id"] == "a2"
-        assert calls[2].kwargs["asset_id"] == "a1"
-        assert calls[3].kwargs["asset_id"] == "a2"
+        assert clips_data[0]["asset_id"] == "a1"
+        assert clips_data[1]["asset_id"] == "a2"
+        assert clips_data[2]["asset_id"] == "a1"
+        assert clips_data[3]["asset_id"] == "a2"
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
-    def test_orders_append_to_existing_timeline(self, mock_storage):
-        """时间线已有2个片段时，新片段 order 应从 2 开始连续递增."""
+    def test_orders_start_at_zero(self, mock_storage):
+        """片段 order 从 0 开始递增。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
         from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
 
-        # 模拟已有 order=0, order=1 的片段
-        existing = [_make_mock_clip("old-1", 0, 5.0), _make_mock_clip("old-2", 1, 5.0)]
-        mock_plan_svc = _make_plan_svc(existing_clips=existing)
-
+        mock_plan_svc = _make_plan_svc(replace_return_count=3)
         mock_asset_repo = MagicMock()
         mock_asset_repo.get = MagicMock(return_value=_make_mock_asset("a1", 30.0))
 
         body = ClipsFromAssetsRequest(asset_ids=["a1"], required_clips_count=3)
 
-        create_clips_from_assets_editor(
-            template_id="tpl-001",
-            body=body,
-            plan_id=TEST_PLAN_ID,
-            services=(MagicMock(), mock_plan_svc),
-            asset_repo=mock_asset_repo,
-            current_user=_make_auth_user(),
-        )
+        with _patch_segments(_segments(3)):
+            create_clips_from_assets_editor(
+                template_id="tpl-001",
+                body=body,
+                background_tasks=MagicMock(),
+                plan_id=TEST_PLAN_ID,
+                services=(MagicMock(), mock_plan_svc),
+                asset_repo=mock_asset_repo,
+                db=MagicMock(),
+                current_user=_make_auth_user(),
+            )
 
-        calls = mock_plan_svc.create_clip.call_args_list
-        assert calls[0].kwargs["order"] == 2
-        assert calls[1].kwargs["order"] == 3
-        assert calls[2].kwargs["order"] == 4
+        clips_data = _get_clips_data_from_call(mock_plan_svc)
+        assert clips_data[0]["order"] == 0
+        assert clips_data[1]["order"] == 1
+        assert clips_data[2]["order"] == 2
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
-    def test_orders_start_at_zero_when_empty(self, mock_storage):
-        """空时间线时 order 从 0 开始."""
+    def test_uses_transactional_replace(self, mock_storage):
+        """使用 replace_all_clips_transactional 而不是分别 delete + create。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
         from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
 
-        mock_plan_svc = _make_plan_svc(existing_clips=[])
-
+        mock_plan_svc = _make_plan_svc(replace_return_count=2)
         mock_asset_repo = MagicMock()
         mock_asset_repo.get = MagicMock(return_value=_make_mock_asset("a1", 30.0))
 
-        body = ClipsFromAssetsRequest(asset_ids=["a1"], required_clips_count=3)
+        body = ClipsFromAssetsRequest(asset_ids=["a1"])
 
-        create_clips_from_assets_editor(
-            template_id="tpl-001",
-            body=body,
-            plan_id=TEST_PLAN_ID,
-            services=(MagicMock(), mock_plan_svc),
-            asset_repo=mock_asset_repo,
-            current_user=_make_auth_user(),
-        )
+        with _patch_segments(_segments(2)):
+            create_clips_from_assets_editor(
+                template_id="tpl-001",
+                body=body,
+                background_tasks=MagicMock(),
+                plan_id=TEST_PLAN_ID,
+                services=(MagicMock(), mock_plan_svc),
+                asset_repo=mock_asset_repo,
+                db=MagicMock(),
+                current_user=_make_auth_user(),
+            )
 
-        calls = mock_plan_svc.create_clip.call_args_list
-        assert calls[0].kwargs["order"] == 0
-        assert calls[1].kwargs["order"] == 1
-        assert calls[2].kwargs["order"] == 2
+        # 必须调用事务方法
+        mock_plan_svc.replace_all_clips_transactional.assert_called_once()
+        # 不应调用单独的 delete 或 create
+        assert not hasattr(mock_plan_svc, "create_clip") or not mock_plan_svc.create_clip.called
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
-    def test_backward_compatible_default_count(self, mock_storage):
-        """不传 required_clips_count 时，片段数等于素材数（向后兼容）."""
+    def test_no_segments_raises_400(self, mock_storage):
+        """模板没有 segment 配置时返回 400。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
@@ -191,56 +192,63 @@ class TestEditorClipsRequiredCount:
 
         mock_plan_svc = _make_plan_svc()
         mock_asset_repo = MagicMock()
-        mock_asset_repo.get = MagicMock(side_effect=lambda aid: _make_mock_asset(aid, 30.0))
 
-        body = ClipsFromAssetsRequest(asset_ids=["a1", "a2", "a3"])
+        body = ClipsFromAssetsRequest(asset_ids=["a1"])
 
-        result = create_clips_from_assets_editor(
-            template_id="tpl-001",
-            body=body,
-            plan_id=TEST_PLAN_ID,
-            services=(MagicMock(), mock_plan_svc),
-            asset_repo=mock_asset_repo,
-            current_user=_make_auth_user(),
-        )
+        with _patch_segments([]):
+            with pytest.raises(HTTPException) as exc_info:
+                create_clips_from_assets_editor(
+                    template_id="tpl-001",
+                    body=body,
+                    background_tasks=MagicMock(),
+                    plan_id=TEST_PLAN_ID,
+                    services=(MagicMock(), mock_plan_svc),
+                    asset_repo=mock_asset_repo,
+                    db=MagicMock(),
+                    current_user=_make_auth_user(),
+                )
 
-        assert result.created_count == 3
-        assert mock_plan_svc.create_clip.call_count == 3
+        assert exc_info.value.status_code == 400
+        assert "片段配置" in exc_info.value.detail
+        # 不应调用替换方法
+        mock_plan_svc.replace_all_clips_transactional.assert_not_called()
 
 
 class TestEditorClipsDurationAndStartTime:
-    """测试素材时长获取、clip duration 缩短、start_time 传入."""
+    """测试素材时长获取、clip duration 缩短、start_time 传入。"""
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
     def test_clip_duration_shortened_for_short_assets(self, mock_storage):
-        """素材只有 3s 时 clip duration 缩短到 3.0."""
+        """素材只有 3s 时 clip duration 缩短到不超过 3.0。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
         from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
 
-        mock_plan_svc = _make_plan_svc()
+        mock_plan_svc = _make_plan_svc(replace_return_count=1)
         mock_asset_repo = MagicMock()
         mock_asset_repo.get = MagicMock(return_value=_make_mock_asset("short", 3.0))
 
         body = ClipsFromAssetsRequest(asset_ids=["short"])
 
-        create_clips_from_assets_editor(
-            template_id="tpl-001",
-            body=body,
-            plan_id=TEST_PLAN_ID,
-            services=(MagicMock(), mock_plan_svc),
-            asset_repo=mock_asset_repo,
-            current_user=_make_auth_user(),
-        )
+        with _patch_segments(_segments(1, dur_min=5.0, dur_max=10.0)):
+            create_clips_from_assets_editor(
+                template_id="tpl-001",
+                body=body,
+                background_tasks=MagicMock(),
+                plan_id=TEST_PLAN_ID,
+                services=(MagicMock(), mock_plan_svc),
+                asset_repo=mock_asset_repo,
+                db=MagicMock(),
+                current_user=_make_auth_user(),
+            )
 
-        calls = mock_plan_svc.create_clip.call_args_list
-        assert len(calls) == 1
-        assert calls[0].kwargs["duration"] == 3.0
+        clips_data = _get_clips_data_from_call(mock_plan_svc)
+        assert clips_data[0]["duration"] <= 3.0
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
-    def test_start_time_passed_to_create_clip(self, mock_storage):
-        """验证 _calc_random_start_time 返回值被传入 create_clip."""
+    def test_zero_duration_asset_raises_400(self, mock_storage):
+        """素材时长为 0 时应抛出 400，而不是创建无效片段。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
@@ -248,64 +256,130 @@ class TestEditorClipsDurationAndStartTime:
 
         mock_plan_svc = _make_plan_svc()
         mock_asset_repo = MagicMock()
-        mock_asset_repo.get = MagicMock(return_value=_make_mock_asset("a1", 30.0))
+        mock_asset_repo.get = MagicMock(return_value=_make_mock_asset("bad", 0.0))
 
-        body = ClipsFromAssetsRequest(asset_ids=["a1"], required_clips_count=2)
+        body = ClipsFromAssetsRequest(asset_ids=["bad"])
 
-        with patch(
-            "app.api.routes.templates_editor.clips._calc_random_start_time",
-            side_effect=[12.5, 18.0],
-        ) as mock_calc:
+        with _patch_segments(_segments(1)):
+            with pytest.raises(HTTPException) as exc_info:
+                create_clips_from_assets_editor(
+                    template_id="tpl-001",
+                    body=body,
+                    background_tasks=MagicMock(),
+                    plan_id=TEST_PLAN_ID,
+                    services=(MagicMock(), mock_plan_svc),
+                    asset_repo=mock_asset_repo,
+                    db=MagicMock(),
+                    current_user=_make_auth_user(),
+                )
+
+        assert exc_info.value.status_code == 400
+        assert "时长" in exc_info.value.detail
+
+    @patch("app.api.routes.templates_editor.clips.get_storage_service")
+    def test_missing_duration_asset_raises_400(self, mock_storage):
+        """素材时长缺失（asset_repo.get 返回 None）时抛出 400。"""
+        from app.api.routes.templates_editor.clips import (
+            create_clips_from_assets_editor,
+        )
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+
+        mock_plan_svc = _make_plan_svc()
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get = MagicMock(return_value=None)
+
+        body = ClipsFromAssetsRequest(asset_ids=["missing"])
+
+        with _patch_segments(_segments(1)):
+            with pytest.raises(HTTPException) as exc_info:
+                create_clips_from_assets_editor(
+                    template_id="tpl-001",
+                    body=body,
+                    background_tasks=MagicMock(),
+                    plan_id=TEST_PLAN_ID,
+                    services=(MagicMock(), mock_plan_svc),
+                    asset_repo=mock_asset_repo,
+                    db=MagicMock(),
+                    current_user=_make_auth_user(),
+                )
+
+        assert exc_info.value.status_code == 400
+
+    @patch("app.api.routes.templates_editor.clips.get_storage_service")
+    def test_start_time_passed_to_create(self, mock_storage):
+        """_calc_random_start_time 返回值被传入 clips_data。"""
+        from app.api.routes.templates_editor.clips import (
+            create_clips_from_assets_editor,
+        )
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+
+        mock_plan_svc = _make_plan_svc(replace_return_count=2)
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get = MagicMock(side_effect=lambda aid: _make_mock_asset(aid, 30.0))
+
+        body = ClipsFromAssetsRequest(asset_ids=["a1", "a2"], required_clips_count=2)
+
+        with (
+            _patch_segments(_segments(2)),
+            patch(
+                "app.api.routes.templates_editor.clips._calc_random_start_time",
+                side_effect=[12.5, 18.0],
+            ) as mock_calc,
+        ):
             create_clips_from_assets_editor(
                 template_id="tpl-001",
                 body=body,
+                background_tasks=MagicMock(),
                 plan_id=TEST_PLAN_ID,
                 services=(MagicMock(), mock_plan_svc),
                 asset_repo=mock_asset_repo,
+                db=MagicMock(),
                 current_user=_make_auth_user(),
             )
 
         assert mock_calc.call_count == 2
-        calls = mock_plan_svc.create_clip.call_args_list
-        assert calls[0].kwargs["start_time"] == 12.5
-        assert calls[1].kwargs["start_time"] == 18.0
+        clips_data = _get_clips_data_from_call(mock_plan_svc)
+        assert clips_data[0]["start_time"] == 12.5
+        assert clips_data[1]["start_time"] == 18.0
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
     def test_asset_durations_deduped(self, mock_storage):
-        """asset_ids 有重复时只查询一次素材时长."""
+        """asset_ids 有重复时只查询一次素材时长。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
         from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
 
-        mock_plan_svc = _make_plan_svc()
+        mock_plan_svc = _make_plan_svc(replace_return_count=3)
         mock_asset_repo = MagicMock()
         mock_asset_repo.get = MagicMock(return_value=_make_mock_asset("a1", 30.0))
 
-        # a1 出现 3 次，但时长只应查一次
         body = ClipsFromAssetsRequest(asset_ids=["a1", "a1", "a1"])
 
-        create_clips_from_assets_editor(
-            template_id="tpl-001",
-            body=body,
-            plan_id=TEST_PLAN_ID,
-            services=(MagicMock(), mock_plan_svc),
-            asset_repo=mock_asset_repo,
-            current_user=_make_auth_user(),
-        )
+        with _patch_segments(_segments(3)):
+            create_clips_from_assets_editor(
+                template_id="tpl-001",
+                body=body,
+                background_tasks=MagicMock(),
+                plan_id=TEST_PLAN_ID,
+                services=(MagicMock(), mock_plan_svc),
+                asset_repo=mock_asset_repo,
+                db=MagicMock(),
+                current_user=_make_auth_user(),
+            )
 
-        # 去重后只调用 1 次
+        # 去重后只调用 1 次获取素材时长
         assert mock_asset_repo.get.call_count == 1
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
-    def test_used_segments_passed_to_calc(self, mock_storage):
-        """同一素材切多个片段时，used_segments 应被维护并传入."""
+    def test_used_segments_maintained_across_clips(self, mock_storage):
+        """同一素材切多个片段时，used_segments 应被维护。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
         from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
 
-        mock_plan_svc = _make_plan_svc()
+        mock_plan_svc = _make_plan_svc(replace_return_count=3)
         mock_asset_repo = MagicMock()
         mock_asset_repo.get = MagicMock(return_value=_make_mock_asset("a1", 30.0))
 
@@ -317,107 +391,96 @@ class TestEditorClipsDurationAndStartTime:
             captured_used_segments.append({aid: list(segs) for aid, segs in (used_segments or {}).items()})
             return (len(captured_used_segments) - 1) * 5.0
 
-        with patch(
-            "app.api.routes.templates_editor.clips._calc_random_start_time",
-            side_effect=fake_calc,
+        with (
+            _patch_segments(_segments(3)),
+            patch(
+                "app.api.routes.templates_editor.clips._calc_random_start_time",
+                side_effect=fake_calc,
+            ),
         ):
             create_clips_from_assets_editor(
                 template_id="tpl-001",
                 body=body,
+                background_tasks=MagicMock(),
                 plan_id=TEST_PLAN_ID,
                 services=(MagicMock(), mock_plan_svc),
                 asset_repo=mock_asset_repo,
+                db=MagicMock(),
                 current_user=_make_auth_user(),
             )
 
+        # 第一次没有已使用时间段
         assert captured_used_segments[0] == {}
-        assert captured_used_segments[1] == {"a1": [(0.0, 5.0)]}
-        assert captured_used_segments[2] == {"a1": [(0.0, 5.0), (5.0, 10.0)]}
+        # 第二次有第一次的记录
+        assert len(captured_used_segments[1]["a1"]) == 1
+        # 第三次有前两次的记录
+        assert len(captured_used_segments[2]["a1"]) == 2
 
 
 class TestEditorClipsErrorHandling:
-    """测试异常处理."""
+    """测试异常处理。"""
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
     def test_none_start_time_raises_400(self, mock_storage):
-        """_calc_random_start_time 返回 None 时应抛出 HTTPException 400."""
+        """_calc_random_start_time 返回 None 时应抛出 HTTPException 400。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
         from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
 
         mock_plan_svc = _make_plan_svc()
-        # asset_repo.get 返回 None → asset_durations 为空 → _calc_random_start_time 返回 None
         mock_asset_repo = MagicMock()
-        mock_asset_repo.get = MagicMock(return_value=None)
+        # 素材有 duration 但 random 返回 None
+        mock_asset_repo.get = MagicMock(return_value=_make_mock_asset("a1", 30.0))
 
-        body = ClipsFromAssetsRequest(asset_ids=["missing-asset"])
+        body = ClipsFromAssetsRequest(asset_ids=["a1"])
 
-        with pytest.raises(HTTPException) as exc_info:
-            create_clips_from_assets_editor(
-                template_id="tpl-001",
-                body=body,
-                plan_id=TEST_PLAN_ID,
-                services=(MagicMock(), mock_plan_svc),
-                asset_repo=mock_asset_repo,
-                current_user=_make_auth_user(),
-            )
+        with (
+            _patch_segments(_segments(1)),
+            patch(
+                "app.api.routes.templates_editor.clips._calc_random_start_time",
+                return_value=None,
+            ),
+        ):
+            with pytest.raises(HTTPException) as exc_info:
+                create_clips_from_assets_editor(
+                    template_id="tpl-001",
+                    body=body,
+                    background_tasks=MagicMock(),
+                    plan_id=TEST_PLAN_ID,
+                    services=(MagicMock(), mock_plan_svc),
+                    asset_repo=mock_asset_repo,
+                    db=MagicMock(),
+                    current_user=_make_auth_user(),
+                )
 
         assert exc_info.value.status_code == 400
-        assert "时长信息缺失" in exc_info.value.detail
+        assert "时长" in exc_info.value.detail
 
     @patch("app.api.routes.templates_editor.clips.get_storage_service")
-    def test_create_clip_value_error_raises_400(self, mock_storage):
-        """create_clip 抛出 ValueError 时应转为 HTTPException 400."""
+    def test_transactional_replace_exception_propagates(self, mock_storage):
+        """replace_all_clips_transactional 抛异常时应向上传播（事务已回滚）。"""
         from app.api.routes.templates_editor.clips import (
             create_clips_from_assets_editor,
         )
         from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
 
         mock_plan_svc = _make_plan_svc()
-        mock_plan_svc.create_clip = MagicMock(side_effect=ValueError("计划不存在"))
-
+        mock_plan_svc.replace_all_clips_transactional = MagicMock(side_effect=RuntimeError("DB connection lost"))
         mock_asset_repo = MagicMock()
         mock_asset_repo.get = MagicMock(return_value=_make_mock_asset("a1", 30.0))
 
         body = ClipsFromAssetsRequest(asset_ids=["a1"])
 
-        with pytest.raises(HTTPException) as exc_info:
-            create_clips_from_assets_editor(
-                template_id="tpl-001",
-                body=body,
-                plan_id=TEST_PLAN_ID,
-                services=(MagicMock(), mock_plan_svc),
-                asset_repo=mock_asset_repo,
-                current_user=_make_auth_user(),
-            )
-
-        assert exc_info.value.status_code == 400
-        assert "创建片段失败" in exc_info.value.detail
-
-
-class TestMarkClipsReadyAfterCreation:
-    """验证 from-assets 创建片段后立即调用 mark_clips_ready，确保渲染管线能找到就绪片段。"""
-
-    @patch("app.api.routes.templates_editor.clips.get_storage_service")
-    def test_mark_clips_ready_called_after_creation(self, _mock_storage):
-        """创建片段后必须调用 plan_svc.mark_clips_ready(plan_id)。"""
-        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
-        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
-
-        mock_plan_svc = _make_plan_svc()
-        mock_asset_repo = MagicMock()
-        mock_asset_repo.get = MagicMock(side_effect=lambda aid: _make_mock_asset(aid, {"a1": 30.0}[aid]))
-
-        body = ClipsFromAssetsRequest(asset_ids=["a1"], required_clips_count=2)
-        create_clips_from_assets_editor(
-            template_id="tmpl-1",
-            body=body,
-            plan_id="plan-xyz",
-            services=(MagicMock(), mock_plan_svc),
-            asset_repo=mock_asset_repo,
-            current_user=_make_auth_user(),
-        )
-
-        # 关键断言：mark_clips_ready 必须被调用，且传入正确的 plan_id
-        mock_plan_svc.mark_clips_ready.assert_called_once_with("plan-xyz")
+        with _patch_segments(_segments(1)):
+            with pytest.raises(RuntimeError, match="DB connection lost"):
+                create_clips_from_assets_editor(
+                    template_id="tpl-001",
+                    body=body,
+                    background_tasks=MagicMock(),
+                    plan_id=TEST_PLAN_ID,
+                    services=(MagicMock(), mock_plan_svc),
+                    asset_repo=mock_asset_repo,
+                    db=MagicMock(),
+                    current_user=_make_auth_user(),
+                )

tests/unit/test_generation_cover.py

@@ -181,7 +181,7 @@ class TestUnifiedCoverPipelineEndpoint:
 
         with (
             patch("app.api.routes.generation_cover.SQLAlchemyGenerationTaskRepository") as mock_repo_cls,
-            patch("packages.shared.storage.get_shared_storage_service") as mock_storage_getter,
+            patch("app.api.routes.generation_cover.get_shared_storage_service") as mock_storage_getter,
             patch("packages.shared.mediakit_client.get_mediakit_client") as mock_mk_getter,
         ):
             mock_repo = MagicMock()
@@ -449,7 +449,7 @@ class TestUnifiedCoverPipelineEndpoint:
 
         with (
             patch("app.api.routes.generation_cover.SQLAlchemyGenerationTaskRepository") as mock_repo_cls,
-            patch("packages.shared.storage.get_shared_storage_service") as mock_storage_getter,
+            patch("app.api.routes.generation_cover.get_shared_storage_service") as mock_storage_getter,
         ):
             mock_repo = MagicMock()
             mock_repo.get.return_value = None
@@ -590,7 +590,7 @@ class TestSourceEditPlanFallback:
             patch("app.api.routes.generation_cover.get_generated_video_repository") as mock_video_repo,
             patch("app.api.routes.generation_cover.ListGeneratedVideosByTaskUseCase") as mock_usecase_cls,
             patch("app.api.routes.generation_cover.normalize_plan_config") as mock_normalize,
-            patch("packages.shared.storage.get_shared_storage_service") as mock_storage_getter,
+            patch("app.api.routes.generation_cover.get_shared_storage_service") as mock_storage_getter,
         ):
             mock_repo = MagicMock()
             mock_repo.get.return_value = None
@@ -657,7 +657,7 @@ class TestSourceEditPlanFallback:
             patch("app.api.routes.generation_cover.get_generated_video_repository") as mock_video_repo,
             patch("app.api.routes.generation_cover.ListGeneratedVideosByTaskUseCase") as mock_usecase_cls,
             patch("app.api.routes.generation_cover.normalize_plan_config") as mock_normalize,
-            patch("packages.shared.storage.get_shared_storage_service") as mock_storage_getter,
+            patch("app.api.routes.generation_cover.get_shared_storage_service") as mock_storage_getter,
         ):
             mock_repo = MagicMock()
             mock_repo.get.return_value = None
@@ -1177,7 +1177,7 @@ class TestUploadCoverType:
                 return_value=mock_asset_repo,
             ),
             patch("packages.shared.mediakit_client.get_mediakit_client", return_value=mock_mk),
-            patch("packages.shared.storage.get_shared_storage_service") as mock_storage_getter,
+            patch("app.api.routes.generation_cover.get_shared_storage_service") as mock_storage_getter,
         ):
             mock_repo = MagicMock()
             mock_repo.get.return_value = None
@@ -1200,3 +1200,511 @@ class TestUploadCoverType:
 
             assert exc_info.value.status_code == 400
             mock_mk.extract_frames.assert_not_called()
+
+
+class TestCoverFromFinalVideo:
+    """测试封面从最终成片任务(is_preview=False)获取视频源。"""
+
+    def test_generated_video_fields_in_schema(self):
+        """请求体支持 generated_video_id 和 video_url 字段。"""
+        from app.api.routes.generation_cover import GenerateCoverRequest
+
+        req = GenerateCoverRequest(
+            generated_video_id="gv-001",
+            video_url="https://example.com/final.mp4",
+        )
+        assert req.generated_video_id == "gv-001"
+        assert req.video_url == "https://example.com/final.mp4"
+
+        # 默认 None
+        req_default = GenerateCoverRequest()
+        assert req_default.generated_video_id is None
+        assert req_default.video_url is None
+
+    def test_cover_uses_final_video_when_generated_video_id_provided(self):
+        """传 generated_video_id 时，从该最终成片视频抽帧。"""
+        from unittest.mock import MagicMock, patch
+
+        from app.api.routes.generation_cover import GenerateCoverRequest
+
+        mock_plan = MagicMock()
+        mock_plan.config = {}
+
+        mock_plan_svc = MagicMock()
+        mock_plan_svc.get_plan_or_raise.return_value = mock_plan
+        mock_template_svc = MagicMock()
+
+        # Generated video
+        mock_gv = MagicMock()
+        mock_gv.file_url = "rendered/final/video.mp4"
+        mock_gv.generation_task_id = "task-final-001"
+        mock_gv.user_id = "user-1"
+
+        # 最终成片任务
+        mock_final_task = MagicMock()
+        mock_final_task.id = "task-final-001"
+        mock_final_task.created_by_user_id = "user-1"
+        mock_final_task.cover_url = ""
+
+        mock_gv_repo = MagicMock()
+        mock_gv_repo.get.return_value = mock_gv
+
+        mock_db = MagicMock()
+        mock_current_user = MagicMock()
+        mock_current_user.user.id = "user-1"
+
+        body = GenerateCoverRequest(
+            cover_type="ai_frame",
+            generated_video_id="gv-final-001",
+        )
+
+        with (
+            patch("app.api.routes.generation_cover.SQLAlchemyGenerationTaskRepository") as mock_repo_cls,
+            patch(
+                "app.api.routes.generation_cover.get_generated_video_repository",
+                return_value=mock_gv_repo,
+            ),
+            patch("app.api.routes.generation_cover.get_shared_storage_service") as mock_storage_getter,
+            patch("packages.shared.mediakit_client.get_mediakit_client") as mock_mk_getter,
+            patch(
+                "app.api.routes.generation_cover._persist_cover_frame",
+                return_value="https://oss.example.com/covers/final-cover.jpg",
+            ) as mock_persist,
+            patch("app.api.routes.generation_cover.normalize_plan_config") as mock_normalize,
+        ):
+            mock_repo = MagicMock()
+            mock_repo.get.return_value = mock_final_task
+            mock_repo.list_by_source_edit_plan.return_value = []
+            mock_repo.list_latest_completed_preview.return_value = []
+            mock_repo_cls.return_value = mock_repo
+
+            mock_storage_svc = MagicMock()
+            mock_storage_svc.get_url.return_value = "https://oss.example.com/rendered/final/video.mp4"
+            mock_storage_svc.public_url = "https://oss.example.com"
+            mock_storage_svc.endpoint = "oss.example.com"
+            mock_storage_getter.return_value = mock_storage_svc
+
+            mock_mk = MagicMock()
+            mock_mk.is_available = True
+            mock_mk.extract_frames.return_value = [{"image_url": "https://mk/frame.jpg"}]
+            mock_mk_getter.return_value = mock_mk
+
+            mock_normalize.return_value = {
+                "cover": {"type": "ai_frame", "image_url": "https://oss.example.com/covers/final-cover.jpg"}
+            }
+
+            from app.api.routes.generation_cover import generate_cover
+
+            result = generate_cover(
+                body=body,
+                template_id="tpl-1",
+                plan_id="plan-final",
+                services=(mock_template_svc, mock_plan_svc),
+                db=mock_db,
+                current_user=mock_current_user,
+            )
+
+            assert result.cover["image_url"] == "https://oss.example.com/covers/final-cover.jpg"
+            call_kwargs = mock_mk.extract_frames.call_args.kwargs
+            assert "rendered/final/video.mp4" in call_kwargs["video_url"]
+            assert call_kwargs["strategy"] == "SpecifiedFrames"
+            assert call_kwargs["max_frames"] == 1
+            assert call_kwargs["max_retries"] == 0
+            mock_persist.assert_called_once()
+
+    def test_cover_uses_video_url_directly(self):
+        """传 video_url 时，直接从该 URL 抽帧。"""
+        from unittest.mock import MagicMock, patch
+
+        from app.api.routes.generation_cover import GenerateCoverRequest
+
+        mock_plan = MagicMock()
+        mock_plan.config = {}
+        mock_plan_svc = MagicMock()
+        mock_plan_svc.get_plan_or_raise.return_value = mock_plan
+        mock_template_svc = MagicMock()
+        mock_db = MagicMock()
+        mock_current_user = MagicMock()
+        mock_current_user.user.id = "user-1"
+
+        body = GenerateCoverRequest(
+            cover_type="ai_frame",
+            video_url="https://oss.example.com/rendered/final/video.mp4",
+        )
+
+        with (
+            patch("app.api.routes.generation_cover.SQLAlchemyGenerationTaskRepository") as mock_repo_cls,
+            patch("app.api.routes.generation_cover.get_shared_storage_service") as mock_storage_getter,
+            patch("packages.shared.mediakit_client.get_mediakit_client") as mock_mk_getter,
+            patch(
+                "app.api.routes.generation_cover._persist_cover_frame",
+                return_value="https://oss.example.com/covers/c.jpg",
+            ),
+            patch("app.api.routes.generation_cover.normalize_plan_config") as mock_normalize,
+        ):
+            mock_repo = MagicMock()
+            mock_repo.get.return_value = None
+            mock_repo.list_by_source_edit_plan.return_value = []
+            mock_repo.list_latest_completed_preview.return_value = []
+            mock_repo_cls.return_value = mock_repo
+
+            mock_storage_svc = MagicMock()
+            mock_storage_svc.public_url = "https://oss.example.com"
+            mock_storage_svc.endpoint = "oss.example.com"
+            mock_storage_getter.return_value = mock_storage_svc
+
+            mock_mk = MagicMock()
+            mock_mk.is_available = True
+            mock_mk.extract_frames.return_value = [{"image_url": "https://mk/f.jpg"}]
+            mock_mk_getter.return_value = mock_mk
+
+            mock_normalize.return_value = {
+                "cover": {"type": "ai_frame", "image_url": "https://oss.example.com/covers/c.jpg"}
+            }
+
+            from app.api.routes.generation_cover import generate_cover
+
+            generate_cover(
+                body=body,
+                template_id="tpl-1",
+                plan_id="plan-url",
+                services=(mock_template_svc, mock_plan_svc),
+                db=mock_db,
+                current_user=mock_current_user,
+            )
+
+            call_kwargs = mock_mk.extract_frames.call_args.kwargs
+            assert "rendered/final/video.mp4" in call_kwargs["video_url"]
+
+    def test_cover_prefers_final_task_over_preview_in_source_plan(self):
+        """步骤3：source_edit_plan 关联任务中，优先使用 is_preview=False 的最终成片。"""
+        from unittest.mock import MagicMock, patch
+
+        from app.api.routes.generation_cover import GenerateCoverRequest
+
+        mock_plan = MagicMock()
+        mock_plan.config = {}  # 无 rendered_storage_key / generation_task_id
+
+        mock_plan_svc = MagicMock()
+        mock_plan_svc.get_plan_or_raise.return_value = mock_plan
+        mock_template_svc = MagicMock()
+
+        # 一个预览任务 + 一个最终成片任务
+        mock_preview = MagicMock()
+        mock_preview.id = "task-preview"
+        mock_preview.status = "completed"
+        mock_preview.is_preview = True
+        mock_preview.cover_url = ""
+
+        mock_final = MagicMock()
+        mock_final.id = "task-final"
+        mock_final.status = "completed"
+        mock_final.is_preview = False
+        mock_final.cover_url = ""
+
+        mock_video_preview = MagicMock()
+        mock_video_preview.file_url = "rendered/preview/video.mp4"
+        mock_video_final = MagicMock()
+        mock_video_final.file_url = "rendered/final/video.mp4"
+
+        mock_db = MagicMock()
+        mock_current_user = MagicMock()
+        mock_current_user.user.id = "user-1"
+
+        body = GenerateCoverRequest(cover_type="ai_frame")
+
+        with (
+            patch("app.api.routes.generation_cover.SQLAlchemyGenerationTaskRepository") as mock_repo_cls,
+            patch("app.api.routes.generation_cover.ListGeneratedVideosByTaskUseCase") as mock_list_videos,
+            patch("app.api.routes.generation_cover.get_shared_storage_service") as mock_storage_getter,
+            patch("packages.shared.mediakit_client.get_mediakit_client") as mock_mk_getter,
+            patch(
+                "app.api.routes.generation_cover._persist_cover_frame",
+                return_value="https://oss.example.com/covers/c.jpg",
+            ),
+            patch("app.api.routes.generation_cover.normalize_plan_config") as mock_normalize,
+        ):
+            mock_repo = MagicMock()
+            mock_repo.get.return_value = None
+            # list_by_source_edit_plan 返回 [preview, final]，最终成片排在后面
+            mock_repo.list_by_source_edit_plan.return_value = [mock_preview, mock_final]
+            mock_repo.list_latest_completed_preview.return_value = []
+            mock_repo_cls.return_value = mock_repo
+
+            # 根据 task id 返回不同 video
+            def get_videos(task_id):
+                if task_id == "task-final":
+                    return [mock_video_final]
+                return [mock_video_preview]
+
+            mock_use_case = MagicMock()
+            mock_use_case.execute.side_effect = get_videos
+            mock_list_videos.return_value = mock_use_case
+
+            mock_storage_svc = MagicMock()
+            mock_storage_svc.get_url.side_effect = lambda key: f"https://oss.example.com/{key}"
+            mock_storage_svc.public_url = "https://oss.example.com"
+            mock_storage_svc.endpoint = "oss.example.com"
+            mock_storage_getter.return_value = mock_storage_svc
+
+            mock_mk = MagicMock()
+            mock_mk.is_available = True
+            mock_mk.extract_frames.return_value = [{"image_url": "https://mk/f.jpg"}]
+            mock_mk_getter.return_value = mock_mk
+
+            mock_normalize.return_value = {
+                "cover": {"type": "ai_frame", "image_url": "https://oss.example.com/covers/c.jpg"}
+            }
+
+            from app.api.routes.generation_cover import generate_cover
+
+            generate_cover(
+                body=body,
+                template_id="tpl-1",
+                plan_id="plan-priority",
+                services=(mock_template_svc, mock_plan_svc),
+                db=mock_db,
+                current_user=mock_current_user,
+            )
+
+            # 应该使用 final video URL 抽帧，而非 preview
+            call_kwargs = mock_mk.extract_frames.call_args.kwargs
+            assert "rendered/final/video.mp4" in call_kwargs["video_url"]
+            assert "rendered/preview" not in call_kwargs["video_url"]
+
+    def test_cover_generated_video_permission_denied(self):
+        """generated_video_id 关联任务属于其他用户时，返回 403。"""
+        from unittest.mock import MagicMock, patch
+
+        import pytest
+        from app.api.routes.generation_cover import GenerateCoverRequest
+        from fastapi import HTTPException
+
+        mock_plan = MagicMock()
+        mock_plan.config = {}
+        mock_plan_svc = MagicMock()
+        mock_plan_svc.get_plan_or_raise.return_value = mock_plan
+        mock_template_svc = MagicMock()
+
+        mock_gv = MagicMock()
+        mock_gv.file_url = "rendered/other/video.mp4"
+        mock_gv.generation_task_id = "task-other"
+        mock_gv.user_id = ""  # 老数据无 user_id，走关联任务归属校验
+
+        mock_other_task = MagicMock()
+        mock_other_task.created_by_user_id = "other-user"
+
+        mock_gv_repo = MagicMock()
+        mock_gv_repo.get.return_value = mock_gv
+
+        mock_db = MagicMock()
+        mock_current_user = MagicMock()
+        mock_current_user.user.id = "user-1"
+
+        body = GenerateCoverRequest(
+            cover_type="ai_frame",
+            generated_video_id="gv-other",
+        )
+
+        with (
+            patch("app.api.routes.generation_cover.SQLAlchemyGenerationTaskRepository") as mock_repo_cls,
+            patch(
+                "app.api.routes.generation_cover.get_generated_video_repository",
+                return_value=mock_gv_repo,
+            ),
+        ):
+            mock_repo = MagicMock()
+            mock_repo.get.return_value = mock_other_task
+            mock_repo_cls.return_value = mock_repo
+
+            from app.api.routes.generation_cover import generate_cover
+
+            with pytest.raises(HTTPException) as exc_info:
+                generate_cover(
+                    body=body,
+                    template_id="tpl-1",
+                    plan_id="plan-perm",
+                    services=(mock_template_svc, mock_plan_svc),
+                    db=mock_db,
+                    current_user=mock_current_user,
+                )
+            assert exc_info.value.status_code == 403
+
+    def test_cover_video_url_ssrf_blocked(self):
+        """video_url 指向内网/非白名单域名时被忽略，不向其发起抽帧请求。"""
+        from unittest.mock import MagicMock, patch
+
+        from app.api.routes.generation_cover import GenerateCoverRequest
+
+        mock_plan = MagicMock()
+        mock_plan.config = {}
+        mock_plan_svc = MagicMock()
+        mock_plan_svc.get_plan_or_raise.return_value = mock_plan
+        mock_template_svc = MagicMock()
+        mock_db = MagicMock()
+        mock_current_user = MagicMock()
+        mock_current_user.user.id = "user-1"
+
+        # SSRF 攻击载荷：内网元数据地址
+        body = GenerateCoverRequest(
+            cover_type="ai_frame",
+            video_url="http://100.100.100.200/latest/meta-data/",
+        )
+
+        with (
+            patch("app.api.routes.generation_cover.SQLAlchemyGenerationTaskRepository") as mock_repo_cls,
+            patch("app.api.routes.generation_cover.get_shared_storage_service") as mock_storage_getter,
+            patch("packages.shared.mediakit_client.get_mediakit_client") as mock_mk_getter,
+            patch("app.api.routes.generation_cover._persist_cover_frame") as mock_persist,
+            patch("app.api.routes.generation_cover.normalize_plan_config") as mock_normalize,
+        ):
+            mock_repo = MagicMock()
+            mock_repo.get.return_value = None
+            mock_repo.list_by_source_edit_plan.return_value = []
+            mock_repo.list_latest_completed_preview.return_value = []
+            mock_repo_cls.return_value = mock_repo
+
+            mock_storage_svc = MagicMock()
+            mock_storage_svc.public_url = "https://xiaoxia-media.oss-cn-hangzhou.aliyuncs.com"
+            mock_storage_svc.endpoint = "oss-cn-hangzhou.aliyuncs.com"
+            mock_storage_svc.get_url.side_effect = lambda k: f"https://xiaoxia-media.oss-cn-hangzhou.aliyuncs.com/{k}"
+            mock_storage_getter.return_value = mock_storage_svc
+
+            mock_mk = MagicMock()
+            mock_mk.is_available = True
+            mock_mk.extract_frames.return_value = [{"image_url": "https://mk/f.jpg"}]
+            mock_mk_getter.return_value = mock_mk
+
+            mock_normalize.return_value = {"cover": {"type": "ai_frame", "image_url": "https://mk/f.jpg"}}
+
+            from app.api.routes.generation_cover import generate_cover
+            from fastapi import HTTPException
+
+            # 内网 URL 被白名单拦截后，无任何可用视频源 → 400（而不是向内网发请求）
+            with pytest.raises(HTTPException) as exc_info:
+                generate_cover(
+                    body=body,
+                    template_id="tpl-1",
+                    plan_id="plan-ssrf",
+                    services=(mock_template_svc, mock_plan_svc),
+                    db=mock_db,
+                    current_user=mock_current_user,
+                )
+            assert exc_info.value.status_code == 400
+            # MediaKit 从未被要求抽帧该内网地址
+            if mock_mk.extract_frames.called:
+                called_url = mock_mk.extract_frames.call_args.kwargs.get("video_url", "")
+                assert "100.100.100.200" not in called_url
+                assert "meta-data" not in called_url
+
+    def test_cover_generated_video_ownership_unverifiable_denied(self):
+        """video 无 user_id 且关联任务不存在时，归属无法确认 → 403（防权限绕过）。"""
+        from unittest.mock import MagicMock, patch
+
+        import pytest
+        from app.api.routes.generation_cover import GenerateCoverRequest
+        from fastapi import HTTPException
+
+        mock_plan = MagicMock()
+        mock_plan.config = {}
+        mock_plan_svc = MagicMock()
+        mock_plan_svc.get_plan_or_raise.return_value = mock_plan
+        mock_template_svc = MagicMock()
+
+        mock_gv = MagicMock()
+        mock_gv.file_url = "rendered/mystery/video.mp4"
+        mock_gv.generation_task_id = "task-gone"  # 关联任务已删除
+        mock_gv.user_id = ""  # 老数据无 owner
+
+        mock_gv_repo = MagicMock()
+        mock_gv_repo.get.return_value = mock_gv
+
+        mock_db = MagicMock()
+        mock_current_user = MagicMock()
+        mock_current_user.user.id = "user-1"
+
+        body = GenerateCoverRequest(
+            cover_type="ai_frame",
+            generated_video_id="gv-mystery",
+        )
+
+        with (
+            patch("app.api.routes.generation_cover.SQLAlchemyGenerationTaskRepository") as mock_repo_cls,
+            patch(
+                "app.api.routes.generation_cover.get_generated_video_repository",
+                return_value=mock_gv_repo,
+            ),
+        ):
+            mock_repo = MagicMock()
+            mock_repo.get.return_value = None  # 关联任务查不到
+            mock_repo_cls.return_value = mock_repo
+
+            from app.api.routes.generation_cover import generate_cover
+
+            with pytest.raises(HTTPException) as exc_info:
+                generate_cover(
+                    body=body,
+                    template_id="tpl-1",
+                    plan_id="plan-orphan",
+                    services=(mock_template_svc, mock_plan_svc),
+                    db=mock_db,
+                    current_user=mock_current_user,
+                )
+            assert exc_info.value.status_code == 403
+
+    def test_is_trusted_media_url_blocks_internal_and_ipv6(self):
+        """白名单函数：内网 IPv4/IPv6/元数据地址一律拒绝，自家 OSS 域名放行。"""
+        from unittest.mock import MagicMock, patch
+
+        from app.api.routes.generation_cover import _is_trusted_media_url
+
+        mock_storage = MagicMock()
+        mock_storage.public_url = "https://xiaoxia-media.oss-cn-hangzhou.aliyuncs.com"
+        mock_storage.endpoint = "oss-cn-hangzhou.aliyuncs.com"
+
+        with patch(
+            "app.api.routes.generation_cover.get_shared_storage_service",
+            return_value=mock_storage,
+        ):
+            # 内网 / 元数据 / IPv6 本地地址全部拒绝
+            for bad in [
+                "http://127.0.0.1/admin",
+                "http://10.0.0.5/video.mp4",
+                "http://192.168.1.1/video.mp4",
+                "http://172.16.0.1/video.mp4",
+                "http://169.254.169.254/latest/meta-data/",
+                "http://[::1]:8080/video.mp4",
+                "http://[fe80::1]/video.mp4",
+                "http://[fc00::1]/video.mp4",
+                "http://localhost/x",
+                "ftp://oss-cn-hangzhou.aliyuncs.com/a.mp4",
+                "",
+            ]:
+                assert _is_trusted_media_url(bad) is False, f"应拒绝: {bad}"
+
+            # 自家 OSS 域名（含签名 URL 子路径、bucket 域名）放行
+            for good in [
+                "https://xiaoxia-media.oss-cn-hangzhou.aliyuncs.com/rendered/final/v.mp4",
+                "https://xiaoxia-media.oss-cn-hangzhou.aliyuncs.com/rendered/v.mp4?Expires=123&Signature=abc",
+            ]:
+                assert _is_trusted_media_url(good) is True, f"应放行: {good}"
+
+    def test_is_trusted_media_url_endpoint_with_scheme_parsed(self):
+        """endpoint 配置带 http:// 前缀时也能正确提取主机名，不出现 .http 后缀绕过。"""
+        from unittest.mock import MagicMock, patch
+
+        from app.api.routes.generation_cover import _is_trusted_media_url
+
+        mock_storage = MagicMock()
+        mock_storage.public_url = "http://oss.internal.example.com:9000"
+        mock_storage.endpoint = "http://oss.internal.example.com:9000"
+
+        with patch(
+            "app.api.routes.generation_cover.get_shared_storage_service",
+            return_value=mock_storage,
+        ):
+            # 正确域名放行
+            assert _is_trusted_media_url("http://oss.internal.example.com:9000/a/b.mp4") is True
+            # 伪造后缀域名必须拒绝（修复前 split(':')[0] 会取到 'http' 导致绕过）
+            assert _is_trusted_media_url("http://evil-http.com/x.mp4") is False
+            assert _is_trusted_media_url("http://evil.http/x.mp4") is False

tests/unit/test_mediakit_smart_clips.py

@@ -0,0 +1,657 @@
+"""测试 MediaKit 智能选片 + from-assets 按模板 segment 创建片段。
+
+覆盖：
+- _recommended_time_conflicts 冲突检测
+- _get_mediakit_recommendations 解析与降级
+- _get_template_segments 查询模板片段配置
+- from-assets 端点：按模板 segment 数量和时长创建片段
+- from-assets 端点：事务性原子替换
+- from-assets 端点：素材轮询分配
+- from-assets 端点：MediaKit 推荐时间首片段使用
+- from-assets 端点：同一素材多片段时后续用随机
+- from-assets 端点：无 segment 配置时报错
+- from-assets 端点：素材时长为0时报400
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+os.environ.setdefault("JWT_SECRET_KEY", "unit-test-secret-key-for-testing")
+os.environ.setdefault("DATABASE_URL", "sqlite:///test.db")
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "apps" / "api"))
+
+import pytest
+
+# ── _recommended_time_conflicts 单元测试 ─────────────────────────────────────
+
+
+class TestRecommendedTimeConflicts:
+    """测试推荐时间与已使用时间段的冲突检测。"""
+
+    def test_no_conflict_when_empty(self):
+        from app.api.routes.templates_editor.clips import _recommended_time_conflicts
+
+        assert _recommended_time_conflicts(5.0, 5.0, []) is False
+
+    def test_no_conflict_when_before(self):
+        from app.api.routes.templates_editor.clips import _recommended_time_conflicts
+
+        assert _recommended_time_conflicts(5.0, 5.0, [(15.0, 20.0)]) is False
+
+    def test_no_conflict_when_after(self):
+        from app.api.routes.templates_editor.clips import _recommended_time_conflicts
+
+        assert _recommended_time_conflicts(20.0, 5.0, [(0.0, 10.0)]) is False
+
+    def test_conflict_overlap_start(self):
+        from app.api.routes.templates_editor.clips import _recommended_time_conflicts
+
+        # 推荐 [5, 10]，已用 [0, 7]
+        assert _recommended_time_conflicts(5.0, 5.0, [(0.0, 7.0)]) is True
+
+    def test_conflict_overlap_end(self):
+        from app.api.routes.templates_editor.clips import _recommended_time_conflicts
+
+        # 推荐 [5, 10]，已用 [8, 15]
+        assert _recommended_time_conflicts(5.0, 5.0, [(8.0, 15.0)]) is True
+
+    def test_conflict_contained(self):
+        from app.api.routes.templates_editor.clips import _recommended_time_conflicts
+
+        # 推荐 [5, 10]，已用 [0, 20]
+        assert _recommended_time_conflicts(5.0, 5.0, [(0.0, 20.0)]) is True
+
+    def test_conflict_exact_boundary_no_overlap(self):
+        from app.api.routes.templates_editor.clips import _recommended_time_conflicts
+
+        # 推荐 [10, 15]，已用 [0, 10] — 边界相接不算冲突
+        assert _recommended_time_conflicts(10.0, 5.0, [(0.0, 10.0)]) is False
+
+    def test_conflict_multiple_used(self):
+        from app.api.routes.templates_editor.clips import _recommended_time_conflicts
+
+        used = [(0.0, 5.0), (10.0, 15.0), (20.0, 25.0)]
+        # 推荐 [6, 11] 与 [10, 15] 冲突
+        assert _recommended_time_conflicts(6.0, 5.0, used) is True
+        # 推荐 [15, 20] 不冲突
+        assert _recommended_time_conflicts(15.0, 5.0, used) is False
+
+
+# ── _get_mediakit_recommendations 单元测试 ──────────────────────────────────
+
+
+class TestGetMediakitRecommendations:
+    """测试 MediaKit 推荐结果解析和降级。"""
+
+    @patch("app.api.routes.templates_editor.clips.get_mediakit_client")
+    @patch("app.api.routes.templates_editor.clips.get_storage_service")
+    def test_returns_parsed_recommendations(self, mock_storage, mock_client_fn):
+        from app.api.routes.templates_editor.clips import _get_mediakit_recommendations
+
+        mock_client = MagicMock()
+        mock_client.is_available = True
+        mock_client.analyze_videos.return_value = [
+            '[{"asset_id": "a1", "recommended_start_time": 12.5, "reason": "动作场景"}]'
+        ]
+        mock_client_fn.return_value = mock_client
+
+        mock_storage_svc = MagicMock()
+        mock_storage_svc.get_download_url.return_value = "https://example.com/v.mp4"
+        mock_storage.return_value = mock_storage_svc
+
+        asset = MagicMock()
+        asset.storage_key = "v.mp4"
+        asset.mime_type = "video/mp4"
+
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get.return_value = asset
+
+        result = _get_mediakit_recommendations(["a1"], mock_asset_repo)
+        assert result == {"a1": 12.5}
+
+    @patch("app.api.routes.templates_editor.clips.get_mediakit_client")
+    @patch("app.api.routes.templates_editor.clips.get_storage_service")
+    def test_client_not_available_returns_empty(self, mock_storage, mock_client_fn):
+        from app.api.routes.templates_editor.clips import _get_mediakit_recommendations
+
+        mock_client = MagicMock()
+        mock_client.is_available = False
+        mock_client_fn.return_value = mock_client
+
+        result = _get_mediakit_recommendations(["a1"], MagicMock())
+        assert result == {}
+
+    @patch("app.api.routes.templates_editor.clips.get_mediakit_client")
+    @patch("app.api.routes.templates_editor.clips.get_storage_service")
+    def test_empty_contents_returns_empty(self, mock_storage, mock_client_fn):
+        from app.api.routes.templates_editor.clips import _get_mediakit_recommendations
+
+        mock_client = MagicMock()
+        mock_client.is_available = True
+        mock_client.analyze_videos.return_value = []
+        mock_client_fn.return_value = mock_client
+
+        mock_storage_svc = MagicMock()
+        mock_storage_svc.get_download_url.return_value = "https://example.com/v.mp4"
+        mock_storage.return_value = mock_storage_svc
+
+        asset = MagicMock()
+        asset.storage_key = "v.mp4"
+        asset.mime_type = "video/mp4"
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get.return_value = asset
+
+        result = _get_mediakit_recommendations(["a1"], mock_asset_repo)
+        assert result == {}
+
+    @patch("app.api.routes.templates_editor.clips.get_mediakit_client")
+    @patch("app.api.routes.templates_editor.clips.get_storage_service")
+    def test_unparseable_response_returns_empty(self, mock_storage, mock_client_fn):
+        from app.api.routes.templates_editor.clips import _get_mediakit_recommendations
+
+        mock_client = MagicMock()
+        mock_client.is_available = True
+        mock_client.analyze_videos.return_value = ["这是一段自然语言描述，没有JSON"]
+        mock_client_fn.return_value = mock_client
+
+        mock_storage_svc = MagicMock()
+        mock_storage_svc.get_download_url.return_value = "https://example.com/v.mp4"
+        mock_storage.return_value = mock_storage_svc
+
+        asset = MagicMock()
+        asset.storage_key = "v.mp4"
+        asset.mime_type = "video/mp4"
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get.return_value = asset
+
+        result = _get_mediakit_recommendations(["a1"], mock_asset_repo)
+        assert result == {}
+
+    @patch("app.api.routes.templates_editor.clips.get_mediakit_client")
+    @patch("app.api.routes.templates_editor.clips.get_storage_service")
+    def test_storage_failure_returns_empty(self, mock_storage, mock_client_fn):
+        from app.api.routes.templates_editor.clips import _get_mediakit_recommendations
+
+        mock_client = MagicMock()
+        mock_client.is_available = True
+        mock_client_fn.return_value = mock_client
+        mock_storage.side_effect = RuntimeError("storage unavailable")
+
+        result = _get_mediakit_recommendations(["a1"], MagicMock())
+        assert result == {}
+
+    @patch("app.api.routes.templates_editor.clips.get_mediakit_client")
+    @patch("app.api.routes.templates_editor.clips.get_storage_service")
+    def test_exception_returns_empty(self, mock_storage, mock_client_fn):
+        from app.api.routes.templates_editor.clips import _get_mediakit_recommendations
+
+        mock_client_fn.side_effect = RuntimeError("unexpected error")
+
+        result = _get_mediakit_recommendations(["a1"], MagicMock())
+        assert result == {}
+
+    @patch("app.api.routes.templates_editor.clips.get_mediakit_client")
+    @patch("app.api.routes.templates_editor.clips.get_storage_service")
+    def test_skips_non_video_assets(self, mock_storage, mock_client_fn):
+        from app.api.routes.templates_editor.clips import _get_mediakit_recommendations
+
+        mock_client = MagicMock()
+        mock_client.is_available = True
+        mock_client_fn.return_value = mock_client
+
+        mock_asset_repo = MagicMock()
+        mock_asset = MagicMock()
+        mock_asset.storage_key = "images/test.jpg"
+        mock_asset.mime_type = "image/jpeg"
+        mock_asset_repo.get.return_value = mock_asset
+
+        result = _get_mediakit_recommendations(["a1"], mock_asset_repo)
+        assert result == {}
+        mock_client.analyze_videos.assert_not_called()
+
+
+# ── _get_template_segments 单元测试 ─────────────────────────────────────────
+
+
+class TestGetTemplateSegments:
+    """测试模板片段配置查询。"""
+
+    def test_returns_segments_from_new_template_system(self):
+        """新模板系统（clip_configs）有数据时优先使用。"""
+        from app.api.routes.templates_editor.clips import _get_template_segments
+
+        mock_tpl_svc = MagicMock()
+        cc1 = MagicMock()
+        cc1.order = 0
+        cc1.min_duration = 3.0
+        cc1.max_duration = 5.0
+        cc2 = MagicMock()
+        cc2.order = 1
+        cc2.min_duration = 4.0
+        cc2.max_duration = 8.0
+        mock_tpl_svc.list_clip_configs.return_value = [cc2, cc1]  # 乱序返回
+
+        result = _get_template_segments("tmpl-1", mock_tpl_svc, MagicMock())
+        assert len(result) == 2
+        assert result[0] == (0, 3.0, 5.0)
+        assert result[1] == (1, 4.0, 8.0)
+
+    def test_falls_back_to_old_template_segments(self):
+        """新模板系统无数据时回退到旧系统。"""
+        from app.api.routes.templates_editor.clips import _get_template_segments
+
+        mock_tpl_svc = MagicMock()
+        mock_tpl_svc.list_clip_configs.return_value = []
+
+        with patch("app.api.routes.templates_editor.clips.SQLAlchemyTemplateRepository") as MockRepo:
+            mock_repo = MagicMock()
+            seg1 = MagicMock()
+            seg1.segment_order = 0
+            seg1.duration_min = 2.0
+            seg1.duration_max = 4.0
+            mock_repo.list_segments.return_value = [seg1]
+            MockRepo.return_value = mock_repo
+
+            result = _get_template_segments("tmpl-1", mock_tpl_svc, MagicMock())
+            assert len(result) == 1
+            assert result[0] == (0, 2.0, 4.0)
+
+    def test_returns_empty_when_no_segments(self):
+        """两套系统都没有片段配置时返回空列表。"""
+        from app.api.routes.templates_editor.clips import _get_template_segments
+
+        mock_tpl_svc = MagicMock()
+        mock_tpl_svc.list_clip_configs.return_value = []
+
+        with patch("app.api.routes.templates_editor.clips.SQLAlchemyTemplateRepository") as MockRepo:
+            mock_repo = MagicMock()
+            mock_repo.list_segments.return_value = []
+            MockRepo.return_value = mock_repo
+
+            result = _get_template_segments("tmpl-1", mock_tpl_svc, MagicMock())
+            assert result == []
+
+    def test_new_system_exception_falls_back(self):
+        """新模板系统异常时回退到旧系统。"""
+        from app.api.routes.templates_editor.clips import _get_template_segments
+
+        mock_tpl_svc = MagicMock()
+        mock_tpl_svc.list_clip_configs.side_effect = RuntimeError("db error")
+
+        with patch("app.api.routes.templates_editor.clips.SQLAlchemyTemplateRepository") as MockRepo:
+            mock_repo = MagicMock()
+            seg = MagicMock()
+            seg.segment_order = 0
+            seg.duration_min = 1.0
+            seg.duration_max = 3.0
+            mock_repo.list_segments.return_value = [seg]
+            MockRepo.return_value = mock_repo
+
+            result = _get_template_segments("tmpl-1", mock_tpl_svc, MagicMock())
+            assert len(result) == 1
+
+
+# ── from-assets 端点集成测试 ────────────────────────────────────────────────
+
+
+def _make_auth_user():
+    auth = MagicMock()
+    auth.user.id = "user-001"
+    auth.user.email = "test@example.com"
+    auth.user.display_name = "test"
+    auth.user_id = "user-001"
+    return auth
+
+
+def _make_clip_config(order, min_dur, max_dur):
+    cc = MagicMock()
+    cc.order = order
+    cc.min_duration = min_dur
+    cc.max_duration = max_dur
+    return cc
+
+
+def _make_plan_svc(replace_return_count=None):
+    svc = MagicMock()
+    svc.get_plan_or_raise = MagicMock()
+    if replace_return_count is not None:
+        svc.replace_all_clips_transactional = MagicMock(return_value=replace_return_count)
+    else:
+        svc.replace_all_clips_transactional = MagicMock(return_value=0)
+    return svc
+
+
+def _make_tpl_svc_with_segments(segments):
+    """segments: list of (order, min_dur, max_dur)"""
+    svc = MagicMock()
+    clip_configs = [_make_clip_config(o, mn, mx) for o, mn, mx in segments]
+    svc.list_clip_configs.return_value = clip_configs
+    return svc
+
+
+def _make_rich_asset(asset_id, duration, storage_key="v.mp4", mime="video/mp4"):
+    asset = MagicMock()
+    asset.id = asset_id
+    asset.duration = duration
+    asset.storage_key = storage_key
+    asset.mime_type = mime
+    return asset
+
+
+def _get_clips_data(mock_plan_svc):
+    """从 replace_all_clips_transactional 调用中提取 clips_data。"""
+    call_args = mock_plan_svc.replace_all_clips_transactional.call_args
+    if len(call_args.args) >= 2:
+        return call_args.args[1]
+    return call_args.kwargs.get("clips_data", [])
+
+
+class TestFromAssetsByTemplateSegments:
+    """测试 from-assets 按模板 segment 创建片段（V2 事务性替换）。"""
+
+    def test_creates_clips_matching_segment_count(self):
+        """片段数量 = segment 数量，忽略 required_clips_count。"""
+        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+
+        segments = [(0, 3.0, 5.0), (1, 4.0, 8.0), (2, 2.0, 6.0), (3, 5.0, 10.0)]
+        mock_tpl_svc = _make_tpl_svc_with_segments(segments)
+        mock_plan_svc = _make_plan_svc(replace_return_count=4)
+
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get.return_value = _make_rich_asset("a1", 60.0)
+
+        body = ClipsFromAssetsRequest(asset_ids=["a1"], required_clips_count=2)
+        result = create_clips_from_assets_editor(
+            template_id="tmpl-1",
+            body=body,
+            background_tasks=MagicMock(),
+            plan_id="plan-1",
+            services=(mock_tpl_svc, mock_plan_svc),
+            asset_repo=mock_asset_repo,
+            db=MagicMock(),
+            current_user=_make_auth_user(),
+        )
+
+        assert result.created_count == 4
+        clips_data = _get_clips_data(mock_plan_svc)
+        assert len(clips_data) == 4
+
+    def test_uses_transactional_replace(self):
+        """使用 replace_all_clips_transactional 而不是分别 delete + create。"""
+        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+
+        segments = [(0, 3.0, 5.0), (1, 4.0, 8.0)]
+        mock_tpl_svc = _make_tpl_svc_with_segments(segments)
+        mock_plan_svc = _make_plan_svc(replace_return_count=2)
+
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get.return_value = _make_rich_asset("a1", 60.0)
+
+        body = ClipsFromAssetsRequest(asset_ids=["a1"])
+        create_clips_from_assets_editor(
+            template_id="tmpl-1",
+            body=body,
+            background_tasks=MagicMock(),
+            plan_id="plan-1",
+            services=(mock_tpl_svc, mock_plan_svc),
+            asset_repo=mock_asset_repo,
+            db=MagicMock(),
+            current_user=_make_auth_user(),
+        )
+
+        mock_plan_svc.replace_all_clips_transactional.assert_called_once()
+        assert not mock_plan_svc.delete_all_clips.called
+        assert not mock_plan_svc.create_clip.called
+
+    def test_duration_within_segment_range(self):
+        """每个片段时长在 segment 的 min~max 范围内。"""
+        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+
+        segments = [(0, 3.0, 5.0), (1, 4.0, 8.0)]
+        mock_tpl_svc = _make_tpl_svc_with_segments(segments)
+        mock_plan_svc = _make_plan_svc(replace_return_count=2)
+
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get.return_value = _make_rich_asset("a1", 60.0)
+
+        body = ClipsFromAssetsRequest(asset_ids=["a1"])
+        create_clips_from_assets_editor(
+            template_id="tmpl-1",
+            body=body,
+            background_tasks=MagicMock(),
+            plan_id="plan-1",
+            services=(mock_tpl_svc, mock_plan_svc),
+            asset_repo=mock_asset_repo,
+            db=MagicMock(),
+            current_user=_make_auth_user(),
+        )
+
+        clips_data = _get_clips_data(mock_plan_svc)
+        assert 3.0 <= clips_data[0]["duration"] <= 5.0
+        assert 4.0 <= clips_data[1]["duration"] <= 8.0
+
+    def test_assets_round_robin_assignment(self):
+        """素材按片段顺序轮询分配。"""
+        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+
+        segments = [(0, 3.0, 5.0), (1, 3.0, 5.0), (2, 3.0, 5.0), (3, 3.0, 5.0)]
+        mock_tpl_svc = _make_tpl_svc_with_segments(segments)
+        mock_plan_svc = _make_plan_svc(replace_return_count=4)
+
+        mock_asset_repo = MagicMock()
+
+        def get_asset(aid):
+            return _make_rich_asset(aid, 60.0)
+
+        mock_asset_repo.get.side_effect = get_asset
+
+        body = ClipsFromAssetsRequest(asset_ids=["a1", "a2"])
+        create_clips_from_assets_editor(
+            template_id="tmpl-1",
+            body=body,
+            background_tasks=MagicMock(),
+            plan_id="plan-1",
+            services=(mock_tpl_svc, mock_plan_svc),
+            asset_repo=mock_asset_repo,
+            db=MagicMock(),
+            current_user=_make_auth_user(),
+        )
+
+        clips_data = _get_clips_data(mock_plan_svc)
+        asset_ids = [c["asset_id"] for c in clips_data]
+        assert asset_ids == ["a1", "a2", "a1", "a2"]
+
+    def test_orders_start_from_zero(self):
+        """片段 order 从 0 开始递增。"""
+        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+
+        segments = [(0, 3.0, 5.0), (1, 3.0, 5.0), (2, 3.0, 5.0)]
+        mock_tpl_svc = _make_tpl_svc_with_segments(segments)
+        mock_plan_svc = _make_plan_svc(replace_return_count=3)
+
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get.return_value = _make_rich_asset("a1", 60.0)
+
+        body = ClipsFromAssetsRequest(asset_ids=["a1"])
+        create_clips_from_assets_editor(
+            template_id="tmpl-1",
+            body=body,
+            background_tasks=MagicMock(),
+            plan_id="plan-1",
+            services=(mock_tpl_svc, mock_plan_svc),
+            asset_repo=mock_asset_repo,
+            db=MagicMock(),
+            current_user=_make_auth_user(),
+        )
+
+        clips_data = _get_clips_data(mock_plan_svc)
+        orders = [c["order"] for c in clips_data]
+        assert orders == [0, 1, 2]
+
+    def test_no_segments_raises_400(self):
+        """模板没有 segment 配置时返回 400。"""
+        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+        from fastapi import HTTPException
+
+        mock_tpl_svc = MagicMock()
+        mock_tpl_svc.list_clip_configs.return_value = []
+        mock_plan_svc = _make_plan_svc()
+
+        with patch("app.api.routes.templates_editor.clips.SQLAlchemyTemplateRepository") as MockRepo:
+            mock_repo = MagicMock()
+            mock_repo.list_segments.return_value = []
+            MockRepo.return_value = mock_repo
+
+            body = ClipsFromAssetsRequest(asset_ids=["a1"])
+            with pytest.raises(HTTPException) as exc_info:
+                create_clips_from_assets_editor(
+                    template_id="tmpl-1",
+                    body=body,
+                    background_tasks=MagicMock(),
+                    plan_id="plan-1",
+                    services=(mock_tpl_svc, mock_plan_svc),
+                    asset_repo=MagicMock(),
+                    db=MagicMock(),
+                    current_user=_make_auth_user(),
+                )
+            assert exc_info.value.status_code == 400
+
+        mock_plan_svc.replace_all_clips_transactional.assert_not_called()
+
+    def test_duration_capped_by_asset_duration(self):
+        """素材时长不足时 clip duration 被缩短。"""
+        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+
+        segments = [(0, 10.0, 20.0)]
+        mock_tpl_svc = _make_tpl_svc_with_segments(segments)
+        mock_plan_svc = _make_plan_svc(replace_return_count=1)
+
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get.return_value = _make_rich_asset("a1", 5.0)
+
+        body = ClipsFromAssetsRequest(asset_ids=["a1"])
+        create_clips_from_assets_editor(
+            template_id="tmpl-1",
+            body=body,
+            background_tasks=MagicMock(),
+            plan_id="plan-1",
+            services=(mock_tpl_svc, mock_plan_svc),
+            asset_repo=mock_asset_repo,
+            db=MagicMock(),
+            current_user=_make_auth_user(),
+        )
+
+        clips_data = _get_clips_data(mock_plan_svc)
+        assert clips_data[0]["duration"] <= 5.0
+
+    def test_zero_duration_asset_raises_400(self):
+        """素材时长为 0 时抛出 400。"""
+        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
+        from app.api.routes.templates_editor.schemas import ClipsFromAssetsRequest
+        from fastapi import HTTPException
+
+        segments = [(0, 3.0, 5.0)]
+        mock_tpl_svc = _make_tpl_svc_with_segments(segments)
+        mock_plan_svc = _make_plan_svc()
+
+        mock_asset_repo = MagicMock()
+        mock_asset_repo.get.return_value = _make_rich_asset("bad", 0.0)
+
+        body = ClipsFromAssetsRequest(asset_ids=["bad"])
+        with pytest.raises(HTTPException) as exc_info:
+            create_clips_from_assets_editor(
+                template_id="tmpl-1",
+                body=body,
+                background_tasks=MagicMock(),
+                plan_id="plan-1",
+                services=(mock_tpl_svc, mock_plan_svc),
+                asset_repo=mock_asset_repo,
+                db=MagicMock(),
+                current_user=_make_auth_user(),
+            )
+
+        assert exc_info.value.status_code == 400
+        mock_plan_svc.replace_all_clips_transactional.assert_not_called()
+
+    def test_empty_asset_ids_raises_400(self):
+        """asset_ids 为空列表时返回 400（defense-in-depth，schema 层也有 min_length=1）。"""
+        from app.api.routes.templates_editor.clips import create_clips_from_assets_editor
+        from fastapi import HTTPException
+
+        segments = [(0, 3.0, 5.0)]
+        mock_tpl_svc = _make_tpl_svc_with_segments(segments)
+        mock_plan_svc = _make_plan_svc()
+
+        # 用 MagicMock 模拟 body，绕过 Pydantic schema 的 min_length 校验
+        mock_body = MagicMock()
+        mock_body.asset_ids = []
+        mock_body.required_clips_count = None
+
+        with pytest.raises(HTTPException) as exc_info:
+            create_clips_from_assets_editor(
+                template_id="tmpl-1",
+                body=mock_body,
+                background_tasks=MagicMock(),
+                plan_id="plan-1",
+                services=(mock_tpl_svc, mock_plan_svc),
+                asset_repo=MagicMock(),
+                db=MagicMock(),
+                current_user=_make_auth_user(),
+            )
+        assert exc_info.value.status_code == 400
+        assert "素材" in exc_info.value.detail
+        mock_plan_svc.replace_all_clips_transactional.assert_not_called()
+
+
+# ── _safe_segment_duration 单元测试 ─────────────────────────────────────────
+
+
+class TestSafeSegmentDuration:
+    """测试片段时长安全转换。"""
+
+    def test_normal_float(self):
+        from app.api.routes.templates_editor.clips import _safe_segment_duration
+
+        assert _safe_segment_duration(3.5, 1.0) == 3.5
+
+    def test_none_returns_default(self):
+        from app.api.routes.templates_editor.clips import _safe_segment_duration
+
+        assert _safe_segment_duration(None, 5.0) == 5.0
+
+    def test_string_number(self):
+        from app.api.routes.templates_editor.clips import _safe_segment_duration
+
+        assert _safe_segment_duration("4.2", 1.0) == 4.2
+
+    def test_invalid_string_returns_default(self):
+        from app.api.routes.templates_editor.clips import _safe_segment_duration
+
+        assert _safe_segment_duration("abc", 5.0) == 5.0
+
+    def test_negative_returns_default(self):
+        from app.api.routes.templates_editor.clips import _safe_segment_duration
+
+        assert _safe_segment_duration(-1.0, 5.0) == 5.0
+
+    def test_zero_returns_default(self):
+        from app.api.routes.templates_editor.clips import _safe_segment_duration
+
+        assert _safe_segment_duration(0, 5.0) == 5.0
+
+    def test_integer_value(self):
+        from app.api.routes.templates_editor.clips import _safe_segment_duration
+
+        assert _safe_segment_duration(10, 1.0) == 10.0