feat: sync selected materials to edit_plan_clips on Step2

- New API updateEditPlanClips (PUT /templates/{id}/editor/clips)
- useStep2Materials: debounced 800ms, builds clips with same logic
  as FrontendPreviewPlayer.buildPlaybackSegments (clamp asset
  duration to template segment duration_min/max)
- buildClipsFromAssets shared util ensures duration consistency
  between preview and clips written to DB
- Supports both manual and smart-match modes
- Failures are silent (console.warn), never block the user
- Step2MaterialSelect/GenerateStepContent pass templateSegments

alembic/versions/057_add_title_config_to_generation_tasks.py

@@ -1,26 +0,0 @@
-"""Add title_config to generation_tasks
-
-Revision ID: 057_title_config
-Revises: 056_fix_cover_templates_config
-Create Date: 2026-08-23
-"""
-
-import sqlalchemy as sa
-
-from alembic import op
-
-revision = "057_title_config"
-down_revision = "056_fix_cover_templates_config"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.add_column(
-        "generation_tasks",
-        sa.Column("title_config", sa.JSON(), nullable=False, server_default="{}"),
-    )
-
-
-def downgrade() -> None:
-    op.drop_column("generation_tasks", "title_config")

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

@@ -16,7 +16,6 @@ from app.core.task_enqueue import (
 from app.dependencies import (
     get_asset_library_repository,
     get_asset_repository,
-    get_db_session,
     get_generated_video_repository,
     get_generation_task_repository,
     get_project_repository,
@@ -33,7 +32,6 @@ from app.schemas.generation_task import (
     ListGenerationTasksResponse,
 )
 from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
 
 from packages.application import (
     CreateGenerationTaskCommand,
@@ -71,7 +69,6 @@ def _to_generation_task_response(task) -> GenerationTaskResponse:
         output_height=getattr(task, "output_height", 720),
         cover_url=getattr(task, "cover_url", ""),
         custom_title=getattr(task, "custom_title", ""),
-        title_config=getattr(task, "title_config", {}) or {},
         logs=getattr(task, "logs", "[]"),
         status=task.status,
         progress=task.progress,
@@ -145,54 +142,6 @@ def _select_assets_from_library(
     return [a.id for a in ready_video_assets]
 
 
-
-def _writeback_edit_plan_config(
-    plan_id: str,
-    task_id: str,
-    title_config: dict | None,
-    db: Session,
-) -> None:
-    """任务入队成功后，回写 EditPlan.config：generation_task_id + title_config。
-
-    用 merge 方式更新，不整体覆盖 config，避免丢失其他字段。
-    失败只记日志，不影响任务创建。
-    """
-    if not plan_id:
-        return
-    try:
-        from packages.adapters.sqlalchemy_impl.models import EditPlanModel
-
-        plan_model = db.query(EditPlanModel).filter(EditPlanModel.id == plan_id).first()
-        if plan_model is None:
-            logger.warning("[生成任务] 回写plan.config失败: plan不存在 plan_id=%s", plan_id)
-            return
-
-        current_config = plan_model.config if isinstance(plan_model.config, dict) else {}
-        merged = dict(current_config)
-        merged["generation_task_id"] = task_id
-        if title_config:
-            merged["title_config"] = title_config
-        plan_model.config = merged
-        db.commit()
-        logger.info(
-            "[生成任务] 回写plan.config成功: plan_id=%s task_id=%s keys=%s",
-            plan_id,
-            task_id,
-            list(merged.keys()),
-        )
-    except Exception as e:
-        logger.warning(
-            "[生成任务] 回写plan.config异常（不影响任务创建）: plan_id=%s error=%s",
-            plan_id,
-            e,
-            exc_info=True,
-        )
-        try:
-            db.rollback()
-        except Exception:
-            pass
-
-
 def _resolve_project_and_library(
     request: CreateGenerationTaskRequest,
     project_repository: Any,
@@ -238,7 +187,6 @@ def create_generation_task(
     project_repository: Any = Depends(get_project_repository),
     asset_library_repository: Any = Depends(get_asset_library_repository),
     asset_repository: Any = Depends(get_asset_repository),
-    db: Session = Depends(get_db_session),
 ) -> BatchGenerationTaskResponse:
     logger.info(
         "[生成任务] 接收请求: user_id=%s, template_id=%s, asset_count=%d, mode=%s, count=%d",
@@ -356,7 +304,6 @@ def create_generation_task(
                     output_height=request.output_height,
                     cover_url=request.cover_url,
                     custom_title=request.custom_title,
-                    title_config=request.title_config or {},
                 )
             )
             try:
@@ -368,13 +315,6 @@ def create_generation_task(
                     log_task_status=True,
                 ):
                     created_tasks.append(task)
-                    if request.source_edit_plan_id:
-                        _writeback_edit_plan_config(
-                            plan_id=request.source_edit_plan_id,
-                            task_id=task.id,
-                            title_config=request.title_config,
-                            db=db,
-                        )
                 else:
                     failed_tasks.append(task)
             except UserPendingLimitExceeded as _e:

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

@@ -56,7 +56,6 @@ logger = logging.getLogger(__name__)
 router = APIRouter(tags=["Template Editor"])
 
 
-# DEPRECATED: 前端已改用 /generation/tasks 体系，此路由保留仅供旧版兼容，计划下线
 @router.post("/generate", response_model=EditPlanGenerateResponse)
 def generate_editor_draft(
     template_id: str,
@@ -286,7 +285,6 @@ def _get_task_output_url(task, gen_task_repo, db) -> str:
     return ""
 
 
-# DEPRECATED: 前端已改用 /generation/tasks 体系，此路由保留仅供旧版兼容，计划下线
 @router.get("/generation-status", response_model=EditPlanGenerationStatusResponse)
 def get_editor_generation_status(
     template_id: str,

apps/api/app/schemas/generation_task.py

@@ -33,11 +33,6 @@ class CreateGenerationTaskRequest(BaseModel):
     voice_ids: list[str] = Field(default_factory=list)
     # ── 来源剪辑计划 ──
     source_edit_plan_id: str = ""
-    # ── 标题配置（结构化，优先于 custom_title 纯文本）──
-    title_config: dict | None = Field(
-        default=None,
-        description="标题样式对象，包含 text/font/font_size/font_color/position/bold/stroke/shadow 等。为空时不影响现有行为。",
-    )
     # ── 视频标题 ──
     video_title: str = Field(default="", description="生成视频的标题/名称，为空则使用默认命名")
     # ── 批量生成 ──
@@ -114,7 +109,6 @@ class GenerationTaskResponse(BaseModel):
     output_height: int = 720
     cover_url: str = ""
     custom_title: str = ""
-    title_config: dict = Field(default_factory=dict)
     status: str
     progress: float
     result_count: int

apps/web/src/api/bgm/bgm.ts

@@ -4,11 +4,20 @@
 import apiClient from "../client"
 import type { BgmPreset, BgmPresetsQuery } from "./types"
 
-/** 获取 BGM 预设列表 */
-export const getBgmPresets = async (params?: BgmPresetsQuery): Promise<BgmPreset[]> => {
+/**
+ * 获取 BGM 预设列表
+ * @param templateId 模板/草稿 ID
+ * @param params 分类/关键词筛选
+ */
+export const getBgmPresets = async (
+  templateId: string,
+  params?: BgmPresetsQuery,
+): Promise<BgmPreset[]> => {
   const searchParams: Record<string, string> = {}
   if (params?.category) searchParams.category = params.category
   if (params?.keyword) searchParams.keyword = params.keyword
-  const res = await apiClient.get("/bgm/presets", { params: searchParams })
+  const res = await apiClient.get(`/templates/${templateId}/editor/bgm/presets`, {
+    params: searchParams,
+  })
   return res.data?.data ?? res.data ?? []
 }

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

@@ -1,9 +1,22 @@
 import apiClient from "../client"
 
+export interface GenerateCoverTitleConfig {
+  text?: string
+  font?: string
+  font_size?: number
+  font_color?: string
+  position?: string
+  bold?: boolean
+  stroke?: boolean
+  shadow?: boolean
+}
+
 export interface GenerateCoverRequest {
   asset_ids: string[]
   cover_type?: "ai_frame" | "manual" | "upload" | "ai_regenerate"
   frame_time?: number
+  /** 标题样式，用于在封面上叠加标题文字 */
+  title_config?: GenerateCoverTitleConfig
 }
 
 export interface GenerateCoverResponse {

apps/web/src/api/tasks/tasks.ts

@@ -6,6 +6,7 @@ import apiClient from "../client"
 import type {
   CreateGenerationTaskRequest,
   CreateGenerationTaskResponse,
+  GenerationTaskDetail,
   TaskItem,
   TaskListParams,
   TaskListResponse,
@@ -19,6 +20,12 @@ export const createGenerationTask = async (
   return data
 }
 
+/** 获取单个生成任务详情（轮询用） */
+export const getGenerationTask = async (taskId: string): Promise<GenerationTaskDetail> => {
+  const { data } = await apiClient.get<GenerationTaskDetail>(`/generation/tasks/${taskId}`)
+  return data
+}
+
 /** 获取任务列表（支持分页和筛选） */
 export const getTasks = async (params?: TaskListParams): Promise<TaskListResponse> => {
   const { data } = await apiClient.get<TaskListResponse>("/tasks", {

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

@@ -82,10 +82,12 @@ export interface CreateGenerationTaskRequest {
     stroke?: boolean
     shadow?: boolean
   }
+  /** 关联的草稿 ID（编辑流程数据链路用） */
+  source_edit_plan_id?: string
 }
 
-/** 创建生成任务响应（对齐后端 GenerationTaskResponse） */
-export interface CreateGenerationTaskResponse {
+/** 单个生成任务详情（对齐后端 GenerationTaskResponse） */
+export interface GenerationTaskDetail {
   id: string
   project_id: string
   asset_library_id: string
@@ -95,8 +97,18 @@ export interface CreateGenerationTaskResponse {
   asset_ids: string[]
   title_ids: string[]
   voice_ids: string[]
+  source_edit_plan_id?: string
   status: string
   progress: number
   result_count: number
   error_message: string
+  error_info?: TaskErrorInfo
+  created_at?: string | null
+  updated_at?: string | null
+}
+
+/** 创建生成任务响应（后端返回批量结构 {items, total}） */
+export interface CreateGenerationTaskResponse {
+  items: GenerationTaskDetail[]
+  total: number
 }

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

@@ -4,51 +4,29 @@
 import apiClient from "../client"
 import type {
   EditPlan,
-  EditPlanListParams,
-  EditPlanListResponse,
-  CreateEditPlanRequest,
   UpdateEditPlanRequest,
   GenerateResponse,
   GenerationStatusResponse,
   EditPlanGeneration,
   GeneratedVideo,
-  CopyEditPlanRequest,
 } from "./types"
 
-/** 获取模板草稿列表（支持分页和筛选） */
-export async function getEditPlans(params?: EditPlanListParams): Promise<EditPlanListResponse> {
-  const response = await apiClient.get<EditPlanListResponse>("/templates/drafts", {
-    params,
-  })
-  return response.data
-}
-
 /** 获取单个模板草稿 */
 export async function getEditPlan(templateId: string): Promise<EditPlan> {
   const response = await apiClient.get(`/templates/${templateId}/editor`)
   return response.data
 }
 
-/** 创建模板草稿 */
-export async function createEditPlan(data: CreateEditPlanRequest): Promise<EditPlan> {
-  const response = await apiClient.post("/templates/drafts", data)
-  return response.data
-}
-
-/** 更新模板草稿 */
+/** 更新模板草稿（支持传入 AbortSignal 用于自动保存竞态取消） */
 export async function updateEditPlan(
   templateId: string,
   data: UpdateEditPlanRequest,
+  signal?: AbortSignal,
 ): Promise<EditPlan> {
-  const response = await apiClient.put(`/templates/${templateId}/editor`, data)
+  const response = await apiClient.put(`/templates/${templateId}/editor`, data, { signal })
   return response.data
 }
 
-/** 删除模板草稿 */
-export async function deleteEditPlan(templateId: string): Promise<void> {
-  await apiClient.delete(`/templates/${templateId}/editor`)
-}
-
 /** 触发生成 */
 export async function generateEditPlan(templateId: string): Promise<GenerateResponse> {
   const response = await apiClient.post(`/templates/${templateId}/editor/generate`)
@@ -73,19 +51,28 @@ export async function getGenerationTaskResults(taskId: string): Promise<Generate
   return response.data.items || response.data || []
 }
 
-/** 取消生成任务 */
-export async function cancelGeneration(templateId: string): Promise<void> {
-  await apiClient.post(`/templates/${templateId}/editor/cancel`)
+/** ── 草稿 clips 批量更新 ── */
+
+export interface EditPlanClipInput {
+  asset_id: string
+  start_time: number
+  duration: number
+  order: number
 }
 
-/** 复制模板草稿（含所有片段配置） */
-export async function copyEditPlan(
+/**
+ * 批量替换草稿的 clips（先全删再批量插入）
+ * 后端路由：PUT /templates/{template_id}/editor/clips
+ */
+export async function updateEditPlanClips(
   templateId: string,
-  data?: CopyEditPlanRequest,
-): Promise<EditPlan> {
-  const response = await apiClient.post<EditPlan>(
-    `/templates/${templateId}/editor/copy`,
-    data || {},
+  clips: EditPlanClipInput[],
+  signal?: AbortSignal,
+): Promise<{ count: number }> {
+  const response = await apiClient.put(
+    `/templates/${templateId}/editor/clips`,
+    { clips },
+    { signal },
   )
   return response.data
 }

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

@@ -15,10 +15,7 @@ export type {
   EditPlanSegment,
   EditPlanConfig,
   EditPlan,
-  CreateEditPlanRequest,
   UpdateEditPlanRequest,
-  EditPlanListParams,
-  EditPlanListResponse,
   GenerateResponse,
   EditPlanGeneration,
   ClipStatusItem,
@@ -37,7 +34,6 @@ export type {
   ClipReorderResponse,
   ClipBatchDeleteResponse,
   ClipsFromAssetsResponse,
-  CopyEditPlanRequest,
   TransitionEffect,
   MediaAsset,
 } from "./types"
@@ -53,18 +49,15 @@ export {
 
 // 模板草稿 CRUD + 生成
 export {
-  getEditPlans,
   getEditPlan,
-  createEditPlan,
   updateEditPlan,
-  deleteEditPlan,
+  updateEditPlanClips,
   generateEditPlan,
   getGenerationStatus,
   getEditPlanGenerations,
   getGenerationTaskResults,
-  cancelGeneration,
-  copyEditPlan,
 } from "./editPlans"
+export type { EditPlanClipInput } from "./editPlans"
 
 // 片段 CRUD + 批量操作
 export {

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

@@ -118,6 +118,17 @@ export interface EditPlanConfig {
   generate_count?: number
   /** 素材模式 */
   material_mode?: string
+  /** 前端标题设置（Step4 自动保存，与 title_config 字段分离，不影响后端渲染） */
+  title?: {
+    text?: string
+    font?: string
+    font_size?: number
+    color?: string
+    position?: string
+    bold?: boolean
+    stroke?: boolean
+    shadow?: boolean
+  }
   /** 预览视频 URL（封面生成用） */
   rendered_storage_key?: string
   /** 生成任务 ID */

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

@@ -9,8 +9,6 @@ export type {
   TemplateSegment,
   TemplateListParams,
   TemplateListResponse,
-  GenerateFromTemplateRequest,
-  GenerateFromTemplateResponse,
   CopyTemplateResponse,
 } from "./types"
 
@@ -24,5 +22,4 @@ export {
   getTemplate,
   toggleFavoriteTemplate,
   copyTemplate,
-  generateFromTemplate,
 } from "./templates"

apps/web/src/api/templates/templates.ts

@@ -5,8 +5,6 @@
 import apiClient from "../client"
 import type {
   CopyTemplateResponse,
-  GenerateFromTemplateRequest,
-  GenerateFromTemplateResponse,
   TemplateItem,
   TemplateListParams,
   TemplateListResponse,
@@ -45,15 +43,3 @@ export const copyTemplate = async (templateId: string): Promise<CopyTemplateResp
   const response = await apiClient.post<CopyTemplateResponse>(`/templates/${templateId}/copy`)
   return response.data
 }
-
-/** 从模板生成 */
-export const generateFromTemplate = async (
-  templateId: string,
-  data?: GenerateFromTemplateRequest,
-): Promise<GenerateFromTemplateResponse> => {
-  const response = await apiClient.post<GenerateFromTemplateResponse>(
-    `/templates/${templateId}/generate`,
-    data,
-  )
-  return response.data
-}

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

@@ -16,9 +16,17 @@ interface BgmSelectorProps {
   onClose: () => void
   config: BgmMixConfig
   onChange: (config: BgmMixConfig) => void
+  /** 模板/草稿 ID，用于请求 BGM 预设 */
+  templateId?: string
 }
 
-const BgmSelector: React.FC<BgmSelectorProps> = ({ open, onClose, config, onChange }) => {
+const BgmSelector: React.FC<BgmSelectorProps> = ({
+  open,
+  onClose,
+  config,
+  onChange,
+  templateId,
+}) => {
   const {
     presets,
     loading,
@@ -30,7 +38,7 @@ const BgmSelector: React.FC<BgmSelectorProps> = ({ open, onClose, config, onChan
     loadPresets,
     handlePreview,
     stopPreview,
-  } = useBgmSelector(open)
+  } = useBgmSelector(open, templateId)
 
   /* ── 选中 BGM ── */
   const handleSelect = useCallback(

apps/web/src/pages/editing-planner/components/bgm-selector/useBgmSelector.ts

@@ -19,7 +19,7 @@ export const CATEGORY_LIST: {
  * BGM 选择器数据与交互 Hook
  * 封装列表加载、搜索、分类筛选、试听播放逻辑
  */
-export function useBgmSelector(open: boolean) {
+export function useBgmSelector(open: boolean, templateId?: string) {
   const [presets, setPresets] = useState<BgmPreset[]>([])
   const [loading, setLoading] = useState(false)
   const [activeCategory, setActiveCategory] = useState<BgmCategory | "all">("all")
@@ -30,19 +30,23 @@ export function useBgmSelector(open: boolean) {
 
   /* ── 加载 BGM 列表 ── */
   const loadPresets = useCallback(async () => {
+    if (!templateId) {
+      setPresets([])
+      return
+    }
     setLoading(true)
     try {
       const params: { category?: string; keyword?: string } = {}
       if (activeCategory !== "all") params.category = activeCategory
       if (keyword.trim()) params.keyword = keyword.trim()
-      const data = await getBgmPresets(params)
+      const data = await getBgmPresets(templateId, params)
       setPresets(data)
     } catch {
       message.error("加载 BGM 列表失败")
     } finally {
       setLoading(false)
     }
-  }, [activeCategory, keyword])
+  }, [activeCategory, keyword, templateId])
 
   useEffect(() => {
     if (open) loadPresets()

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

@@ -171,6 +171,7 @@ const GeneratePage: React.FC = () => {
     autoSubtitles,
     bgm,
     generateCount,
+    sourceEditPlanId: editPlanId,
   })
 
   /* ================================================================

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

@@ -123,6 +123,10 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
     presetVoices,
   } = props
 
+  /* 当前模板的 segments，传给 Step2 构建 clips */
+  const currentTemplate = userTemplates.find((t) => t.id === selectedTemplate)
+  const templateSegments = currentTemplate?.segments
+
   switch (currentStep) {
     case 1:
       return (
@@ -141,6 +145,8 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
           onSelectedMaterialsChange={onSelectedMaterialsChange}
           smartSelectedIds={smartSelectedIds}
           onSmartSelectedIdsChange={onSmartSelectedIdsChange}
+          selectedTemplate={selectedTemplate}
+          templateSegments={templateSegments}
         />
       )
     case 3:
@@ -156,6 +162,7 @@ export const GenerateStepContent: React.FC<GenerateStepContentProps> = (props) =
         <Step4TitleSettings
           titleSettings={titleSettings}
           onTitleSettingsChange={onTitleSettingsChange}
+          selectedTemplate={selectedTemplate}
         />
       )
     case 5:

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

@@ -2,6 +2,7 @@
  * Step 2 素材选择组件
  */
 import React from "react"
+import type { TemplateSegment } from "@/api/templates/types"
 import { useStep2Materials } from "../hooks/useStep2Materials"
 import MaterialModeTabs from "./material/MaterialModeTabs"
 import ManualMaterialList from "./material/ManualMaterialList"
@@ -15,6 +16,10 @@ interface Step2MaterialSelectProps {
   onSelectedMaterialsChange: (ids: string[]) => void
   smartSelectedIds: string[]
   onSmartSelectedIdsChange: (ids: string[]) => void
+  /** 当前选中的模板/草稿 ID，用于自动保存 */
+  selectedTemplate?: string
+  /** 当前模板的 segments（用于构建 clips duration） */
+  templateSegments?: TemplateSegment[]
 }
 
 const Step2MaterialSelect: React.FC<Step2MaterialSelectProps> = (props) => {

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

@@ -12,6 +12,8 @@ import AiTitleGenerator from "./title/AiTitleGenerator"
 interface Step4TitleSettingsProps {
   titleSettings: TitleSettings
   onTitleSettingsChange: (settings: TitleSettings) => void
+  /** 当前选中的模板/草稿 ID，用于自动保存 */
+  selectedTemplate?: string
 }
 
 const Step4TitleSettings: React.FC<Step4TitleSettingsProps> = (props) => {

apps/web/src/pages/generate/hooks/generate-video/types.ts

@@ -19,6 +19,8 @@ export interface UseGenerateVideoProps {
   autoSubtitles: boolean
   bgm: boolean
   generateCount: number
+  /** 当前草稿 ID（URL 参数 edit_plan_id，用于后端回写任务关联） */
+  sourceEditPlanId?: string | null
 }
 
 /** 生成阶段 */

apps/web/src/pages/generate/hooks/generate-video/useGenerationPolling.ts

@@ -1,87 +1,146 @@
 import { useRef, useCallback } from "react"
 import { message } from "antd"
-import { getGenerationStatus, getGenerationTaskResults } from "@/api/template-editor"
+import axios from "axios"
+import { getGenerationTask } from "@/api/tasks/tasks"
+import { getGenerationTaskResults } from "@/api/template-editor"
 import { safeExtractError } from "./errorUtils"
 
 interface UseGenerationPollingOptions {
-  templateId: string
   onProgress: (progress: number) => void
   onComplete: (videos: unknown[]) => void
   onFailed: (errorMsg: string) => void
 }
 
+/** 最大连续错误次数（仅对可重试错误），超过后终止轮询 */
+const MAX_RETRYABLE_ERRORS = 10
+/** 获取结果的最大重试次数 */
+const MAX_RESULTS_RETRIES = 3
+
 /**
- * 生成状态轮询 Hook
- * 轮询生成状态，更新进度，处理完成/失败
+ * 生成状态轮询 Hook（v2 — 改用 /generation/tasks/{task_id}）
+ *
+ * 旧版轮询 GET /templates/{id}/editor/generation-status 依赖 plan 维度状态，
+ * 在编辑流程数据链路断裂时拿不到 task_id。新版直接使用 POST /generation/tasks
+ * 返回的 task_id 轮询任务详情，不再依赖 plan。
+ *
+ * 错误处理：
+ * - 4xx（尤其 404）视为不可恢复，立即 onFailed，不再重试
+ * - 5xx / 网络错误重试，最多连续 MAX_RETRYABLE_ERRORS 次
+ * - 任务完成后获取结果失败会重试 MAX_RESULTS_RETRIES 次，仍失败则 onFailed
  */
 export const useGenerationPolling = ({
-  templateId,
   onProgress,
   onComplete,
   onFailed,
 }: UseGenerationPollingOptions) => {
   const progressTimer = useRef<ReturnType<typeof setTimeout>>()
+  const cancelledRef = useRef(false)
 
   const clearTimer = useCallback(() => {
+    cancelledRef.current = true
     if (progressTimer.current) {
       clearTimeout(progressTimer.current)
       progressTimer.current = undefined
     }
   }, [])
 
-  const startPolling = useCallback(() => {
-    const poll = async () => {
+  /** 任务完成后拉取结果列表，带重试 */
+  const fetchResultsWithRetry = useCallback(
+    async (taskId: string, attempt = 0): Promise<unknown[] | null> => {
       try {
-        const data = await getGenerationStatus(templateId)
-
-        if (data.plan_status === "completed") {
-          onProgress(100)
-          // 获取生成的视频结果
-          let videos: unknown[] = []
-          if (data.generation_task_id) {
-            try {
-              videos = await getGenerationTaskResults(data.generation_task_id)
-            } catch (err) {
-              console.error("[获取生成结果失败]", err)
-            }
-          }
-          onComplete(videos)
-          message.success("视频生成完成！")
-          return
+        return await getGenerationTaskResults(taskId)
+      } catch (err) {
+        if (cancelledRef.current) return null
+        console.error(`[获取生成结果失败] 第 ${attempt + 1} 次`, err)
+        if (attempt < MAX_RESULTS_RETRIES - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 1000 * (attempt + 1)))
+          return fetchResultsWithRetry(taskId, attempt + 1)
         }
-        if (data.plan_status === "failed") {
-          const dataAny = data as unknown as Record<string, unknown>
-          const rawMsg =
-            dataAny.error_message ||
-            dataAny.error ||
-            dataAny.message ||
-            (Array.isArray(data.clips)
-              ? (data.clips as { status: string; error_message?: string }[]).find(
-                  (c) => c.status === "failed",
-                )?.error_message
-              : undefined) ||
-            "视频生成失败，请联系管理员或重试"
-          const errorMsg = safeExtractError(rawMsg)
-          console.error("[生成失败] templateId:", templateId, "响应:", data)
-          onFailed(errorMsg)
-          message.error(errorMsg)
-          return
-        }
-
-        const clips = data.clips || []
-        const total = clips.length || 1
-        const done = (clips as { status: string }[]).filter((c) => c.status === "completed").length
-        onProgress(Math.round((done / total) * 100))
-
-        progressTimer.current = setTimeout(poll, 2000)
-      } catch (pollErr) {
-        console.error("[轮询出错] templateId:", templateId, pollErr)
-        progressTimer.current = setTimeout(poll, 3000)
+        return null
       }
-    }
+    },
+    [],
+  )
 
-    progressTimer.current = setTimeout(poll, 2000)
-  }, [templateId, onProgress, onComplete, onFailed])
+  const startPolling = useCallback(
+    (taskId: string) => {
+      cancelledRef.current = false
+      let consecutiveErrors = 0
+
+      const poll = async () => {
+        if (cancelledRef.current) return
+        try {
+          const task = await getGenerationTask(taskId)
+          consecutiveErrors = 0
+
+          if (task.status === "completed") {
+            onProgress(100)
+            const videos = await fetchResultsWithRetry(taskId)
+            if (cancelledRef.current) return
+            if (videos === null) {
+              const errorMsg = "视频已生成，但获取结果列表失败，请稍后在任务列表查看"
+              console.error("[生成结果获取失败] taskId:", taskId)
+              onFailed(errorMsg)
+              message.error(errorMsg)
+              return
+            }
+            onComplete(videos)
+            message.success("视频生成完成！")
+            return
+          }
+
+          if (task.status === "failed" || task.status === "cancelled") {
+            const rawMsg =
+              task.error_info?.error_message ||
+              task.error_message ||
+              (task.status === "cancelled" ? "任务已取消" : "视频生成失败，请联系管理员或重试")
+            const errorMsg = safeExtractError(rawMsg)
+            console.error("[生成失败] taskId:", taskId, "响应:", task)
+            onFailed(errorMsg)
+            message.error(errorMsg)
+            return
+          }
+
+          // pending / waiting / running — 继续轮询
+          const pct = Math.max(0, Math.min(99, Math.round(Number(task.progress) || 0)))
+          onProgress(pct)
+          progressTimer.current = setTimeout(poll, 2000)
+        } catch (pollErr) {
+          if (cancelledRef.current) return
+          console.error("[轮询出错] taskId:", taskId, pollErr)
+
+          // 4xx 不可恢复，立即失败
+          const status = axios.isAxiosError(pollErr) ? pollErr.response?.status : undefined
+          if (status && status >= 400 && status < 500) {
+            const msg =
+              (axios.isAxiosError(pollErr) &&
+                (pollErr.response?.data as { detail?: string; message?: string } | undefined)
+                  ?.detail) ||
+              (axios.isAxiosError(pollErr) &&
+                (pollErr.response?.data as { detail?: string; message?: string } | undefined)
+                  ?.message) ||
+              `查询任务失败 (${status})`
+            const errorMsg = safeExtractError(msg)
+            onFailed(errorMsg)
+            message.error(errorMsg)
+            return
+          }
+
+          consecutiveErrors += 1
+          if (consecutiveErrors >= MAX_RETRYABLE_ERRORS) {
+            const errorMsg = "任务状态查询连续失败，请稍后在任务列表查看结果"
+            onFailed(errorMsg)
+            message.error(errorMsg)
+            return
+          }
+          progressTimer.current = setTimeout(poll, 3000)
+        }
+      }
+
+      progressTimer.current = setTimeout(poll, 1500)
+    },
+    [onProgress, onComplete, onFailed, fetchResultsWithRetry],
+  )
 
   return { startPolling, clearTimer }
 }

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

@@ -0,0 +1,124 @@
+/**
+ * 草稿自动保存工具 Hook
+ *
+ * 背景：后端 PUT /templates/{id}/editor 的 config 是「整体替换」语义，
+ * 直接发送 { config: { asset_ids } } 会把 title 等其他字段覆盖掉。
+ * 本 Hook 统一执行「GET 当前 config → 浅合并新字段 → PUT 回去」，
+ * 并用串行队列 + AbortController 保证：
+ *   - 同一时刻只有一个保存请求在飞
+ *   - 快速连续变化时只提交最后一次
+ *   - 组件卸载时取消未完成请求
+ *   - 保存失败时保留补丁，自动重试（指数退避，最多 5 次）
+ *
+ * 保存失败只 console.warn，不弹窗、不阻塞。
+ */
+import { useCallback, useEffect, useRef } from "react"
+import { getEditPlan, updateEditPlan } from "@/api/template-editor"
+
+type ConfigPatch = Record<string, unknown>
+
+/** 最大自动重试次数 */
+const MAX_RETRIES = 5
+/** 初始重试延迟（ms），每次翻倍 */
+const BASE_RETRY_DELAY = 1000
+
+export function useDraftAutoSave(templateId?: string) {
+  const timerRef = useRef<ReturnType<typeof setTimeout>>()
+  const abortRef = useRef<AbortController | null>(null)
+  // 待合并的补丁队列（解决「保存进行中又来了新变化」）
+  const pendingPatchRef = useRef<ConfigPatch | null>(null)
+  const savingRef = useRef(false)
+  const templateIdRef = useRef(templateId)
+  templateIdRef.current = templateId
+
+  const flush = useCallback(async (retryCount = 0) => {
+    const tid = templateIdRef.current
+    if (!tid) return
+    // 已有保存在飞：把新补丁暂存，等当前请求结束后再合并一次
+    if (savingRef.current) return
+
+    // 快照当前补丁，但先不清空 —— 成功后才清除，失败时保留以便重试
+    const patchToSave = pendingPatchRef.current
+    if (!patchToSave) {
+      savingRef.current = false
+      return
+    }
+    savingRef.current = true
+
+    const controller = new AbortController()
+    abortRef.current = controller
+    try {
+      // 1. 读当前 config（拿最新，避免覆盖别人/别的步骤写入的字段）
+      const current = await getEditPlan(tid)
+      if (controller.signal.aborted) return
+      const merged = { ...(current.config || {}), ...patchToSave }
+      // 2. 写回完整合并后的 config
+      await updateEditPlan(tid, { config: merged }, controller.signal)
+      // 3. 保存成功才清除已保存的补丁
+      //    （保存期间可能有新补丁进来，只清除我们已经保存的部分）
+      pendingPatchRef.current = null
+    } catch (err) {
+      const name = (err as { name?: string })?.name
+      if (name === "CanceledError" || name === "AbortError") {
+        // 组件卸载或新请求取消，不重试
+        return
+      }
+      console.warn("[useDraftAutoSave] 自动保存草稿失败:", err)
+
+      // 保存失败：把本次尝试保存的补丁合并回 pendingPatchRef
+      // （保存期间可能有新补丁，新补丁优先）
+      pendingPatchRef.current = {
+        ...patchToSave,
+        ...(pendingPatchRef.current || {}),
+      }
+
+      // 指数退避重试
+      if (retryCount < MAX_RETRIES && !controller.signal.aborted) {
+        const delay = BASE_RETRY_DELAY * Math.pow(2, retryCount)
+        timerRef.current = setTimeout(() => {
+          void flush(retryCount + 1)
+        }, delay)
+      }
+      // 超过最大重试次数后，补丁仍保留在 pendingPatchRef 中，
+      // 下次 scheduleSave 触发时会一起带上
+    } finally {
+      savingRef.current = false
+      // 保存期间又积累了新变化（且不是在重试路径中），再触发一次
+      if (pendingPatchRef.current && !controller.signal.aborted && retryCount === 0) {
+        timerRef.current = setTimeout(() => {
+          void flush()
+        }, 50)
+      }
+    }
+  }, [])
+
+  /**
+   * 调度一次自动保存（防抖）
+   * @param patch 要合并进 config 的局部字段
+   * @param delay 防抖毫秒数
+   */
+  const scheduleSave = useCallback(
+    (patch: ConfigPatch, delay = 500) => {
+      const tid = templateIdRef.current
+      if (!tid) return
+      if (timerRef.current) clearTimeout(timerRef.current)
+      // 累计补丁（同一周期内多次变化合并成一次写入）
+      pendingPatchRef.current = { ...(pendingPatchRef.current || {}), ...patch }
+      timerRef.current = setTimeout(() => {
+        void flush()
+      }, delay)
+    },
+    [flush],
+  )
+
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current)
+      if (abortRef.current) abortRef.current.abort()
+    }
+  }, [])
+
+  return { scheduleSave }
+}
+
+export default useDraftAutoSave

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

@@ -34,7 +34,6 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
   }, [])
 
   const { startPolling, clearTimer } = useGenerationPolling({
-    templateId: selectedTemplate,
     onProgress: handleProgress,
     onComplete: handleComplete,
     onFailed: handleFailed,
@@ -90,16 +89,20 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
       const assetIds =
         props.materialMode === "auto" ? props.smartSelectedIds : props.selectedMaterials
 
+      // 封面 URL：优先 AI 生成缩略图，兜底用户上传
+      const coverUrl = props.coverSettings?.thumbnail_url || props.coverSettings?.upload_url || ""
+
       // 直接创建正式生成任务
-      await createGenerationTask({
+      const taskResp = await createGenerationTask({
         template_id: selectedTemplate,
         asset_ids: assetIds,
         output_width: outputWidth,
         output_height: outputHeight,
-        cover_url: props.coverSettings?.upload_url || "",
+        cover_url: coverUrl,
         custom_title: props.titleSettings?.title || "",
         duration: props.duration || undefined,
         video_ratio: props.videoRatio,
+        ...(props.sourceEditPlanId ? { source_edit_plan_id: props.sourceEditPlanId } : {}),
         ...(props.titleSettings?.title
           ? {
               title_config: {
@@ -116,7 +119,12 @@ export function useGenerateVideo(props: UseGenerateVideoProps) {
           : {}),
       })
 
-      startPolling()
+      // 从创建响应直接拿 task_id，改用新接口轮询
+      const taskId = taskResp.items?.[0]?.id
+      if (!taskId) {
+        throw new Error("创建任务成功但未返回任务 ID，请稍后在任务列表查看")
+      }
+      startPolling(taskId)
     } catch (err: unknown) {
       console.error("[handleGenerate] 生成失败:", err)
       setGenerating(false)

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

@@ -3,9 +3,14 @@
  * 组合素材库加载 + 智能匹配两个子 Hook
  */
 import { useCallback, useEffect, useRef } from "react"
+import type { AssetItem } from "@/api/assets"
+import type { TemplateSegment } from "@/api/templates/types"
+import { updateEditPlanClips } from "@/api/template-editor"
 import { formatDuration } from "../utils/formatDuration"
+import { buildClipsFromAssets } from "../utils/buildClipsFromAssets"
 import { useMaterialLibrary } from "./step2-materials/useMaterialLibrary"
 import { useSmartMatch } from "./step2-materials/useSmartMatch"
+import { useDraftAutoSave } from "./useDraftAutoSave"
 
 interface UseStep2MaterialsProps {
   materialMode: "manual" | "auto"
@@ -14,6 +19,10 @@ interface UseStep2MaterialsProps {
   onSelectedMaterialsChange: (ids: string[]) => void
   smartSelectedIds: string[]
   onSmartSelectedIdsChange: (ids: string[]) => void
+  /** 当前选中的模板/草稿 ID，用于自动保存 */
+  selectedTemplate?: string
+  /** 当前模板的 segments（用于构建 clips duration） */
+  templateSegments?: TemplateSegment[]
 }
 
 export function useStep2Materials({
@@ -23,6 +32,8 @@ export function useStep2Materials({
   onSelectedMaterialsChange,
   smartSelectedIds,
   onSmartSelectedIdsChange,
+  selectedTemplate,
+  templateSegments,
 }: UseStep2MaterialsProps) {
   const { libraries, selectedLibraryId, setSelectedLibraryId, materials, materialsLoading } =
     useMaterialLibrary()
@@ -53,6 +64,69 @@ export function useStep2Materials({
     handleSmartMatch()
   }, [selectedLibraryId, materialMode, materialsLoading, materials.items, handleSmartMatch])
 
+  /* ── Step2 选择素材后自动保存草稿 asset_ids（防抖 500ms，失败静默） ── */
+  const { scheduleSave } = useDraftAutoSave(selectedTemplate)
+  useEffect(() => {
+    if (!selectedTemplate) return
+    const ids = materialMode === "auto" ? smartSelectedIds : selectedMaterials
+    scheduleSave({ asset_ids: ids }, 500)
+  }, [selectedTemplate, materialMode, selectedMaterials, smartSelectedIds, scheduleSave])
+
+  /* ── Step2 选择素材后同步写入 edit_plan_clips（防抖 800ms，失败静默） ── */
+  const clipsTimerRef = useRef<ReturnType<typeof setTimeout>>()
+  const clipsAbortRef = useRef<AbortController | null>(null)
+  const templateSegmentsRef = useRef(templateSegments)
+  templateSegmentsRef.current = templateSegments
+  const selectedTemplateRef = useRef(selectedTemplate)
+  selectedTemplateRef.current = selectedTemplate
+  const materialsRef = useRef(materials)
+  materialsRef.current = materials
+  const smartMatchedRef = useRef<AssetItem[]>(smartMatch.smartMatchedResults)
+  smartMatchedRef.current = smartMatch.smartMatchedResults
+
+  useEffect(() => {
+    const tid = selectedTemplateRef.current
+    if (!tid) return
+    const ids = materialMode === "auto" ? smartSelectedIds : selectedMaterials
+    if (!ids.length) return
+
+    if (clipsTimerRef.current) clearTimeout(clipsTimerRef.current)
+    clipsTimerRef.current = setTimeout(async () => {
+      // 取消上一次未完成的请求
+      if (clipsAbortRef.current) clipsAbortRef.current.abort()
+      const controller = new AbortController()
+      clipsAbortRef.current = controller
+
+      const clips = buildClipsFromAssets({
+        selectedIds: ids,
+        materials: materialsRef.current.items,
+        smartMatchedAssets: smartMatchedRef.current,
+        templateSegments: templateSegmentsRef.current || [],
+      })
+
+      try {
+        await updateEditPlanClips(tid, clips, controller.signal)
+      } catch (err) {
+        const name = (err as { name?: string })?.name
+        if (name !== "CanceledError" && name !== "AbortError") {
+          console.warn("[useStep2Materials] 写入 clips 失败:", err)
+        }
+      }
+    }, 800)
+
+    return () => {
+      if (clipsTimerRef.current) clearTimeout(clipsTimerRef.current)
+    }
+  }, [selectedTemplate, materialMode, selectedMaterials, smartSelectedIds, templateSegments])
+
+  // 组件卸载时取消未完成请求
+  useEffect(() => {
+    return () => {
+      if (clipsTimerRef.current) clearTimeout(clipsTimerRef.current)
+      if (clipsAbortRef.current) clipsAbortRef.current.abort()
+    }
+  }, [])
+
   /* ── 手动选择素材 ── */
   const handleToggleMaterial = useCallback(
     (materialId: string) => {

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

@@ -4,17 +4,24 @@ import { getTitles } from "@/api/titles"
 import type { TitleSettings } from "../../types"
 import { useAiTitleGenerator } from "./useAiTitleGenerator"
 import { useTitleStyleUpdaters } from "./useTitleStyleUpdaters"
+import { useDraftAutoSave } from "../useDraftAutoSave"
 
 interface UseStep4TitleProps {
   titleSettings: TitleSettings
   onTitleSettingsChange: (settings: TitleSettings) => void
+  /** 当前选中的模板/草稿 ID，用于自动保存 */
+  selectedTemplate?: string
 }
 
 /**
  * Step 4 标题设置 Hook
  * 封装 AI 标题生成、标题样式设置等逻辑
  */
-export function useStep4Title({ titleSettings, onTitleSettingsChange }: UseStep4TitleProps) {
+export function useStep4Title({
+  titleSettings,
+  onTitleSettingsChange,
+  selectedTemplate,
+}: UseStep4TitleProps) {
   // 标题库数据
   const { data: userTitles = [] } = useQuery({
     queryKey: ["titles"],
@@ -42,6 +49,38 @@ export function useStep4Title({ titleSettings, onTitleSettingsChange }: UseStep4
   const prevAiAutoSelect = useRef(titleSettings.aiAutoSelect)
   const isFirstMount = useRef(true)
 
+  /* ── Step4 标题内容/样式变化后自动保存草稿（防抖 800ms，失败静默） ── */
+  const { scheduleSave: scheduleTitleSave } = useDraftAutoSave(selectedTemplate)
+  useEffect(() => {
+    if (!selectedTemplate) return
+    scheduleTitleSave(
+      {
+        title: {
+          text: titleSettings.title,
+          font: titleSettings.font,
+          font_size: titleSettings.size,
+          color: titleSettings.color,
+          position: titleSettings.position,
+          bold: titleSettings.bold,
+          stroke: titleSettings.stroke,
+          shadow: titleSettings.shadow,
+        },
+      },
+      800,
+    )
+  }, [
+    selectedTemplate,
+    titleSettings.title,
+    titleSettings.font,
+    titleSettings.size,
+    titleSettings.color,
+    titleSettings.position,
+    titleSettings.bold,
+    titleSettings.stroke,
+    titleSettings.shadow,
+    scheduleTitleSave,
+  ])
+
   // 当 AI 自动选择开关打开时，自动生成/选择一个标题填入
   // 首次挂载时如果开关已经是 true 且无标题，也需要触发
   useEffect(() => {

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

@@ -97,6 +97,20 @@ export function useStep6Cover({
       const response = 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,
+              },
+            }
+          : {}),
       })
       clearTimeout(timeoutId)
       const thumbnailUrl = response.cover?.image_url || ""
@@ -205,6 +219,20 @@ export function useStep6Cover({
           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) {

apps/web/src/pages/generate/utils/buildClipsFromAssets.ts

@@ -0,0 +1,57 @@
+/**
+ * 将选中素材 + 模板 segments 构建为 edit_plan_clips 写入数据。
+ *
+ * 逻辑必须与 FrontendPreviewPlayer.tsx 中 buildPlaybackSegments 完全一致：
+ *   assetDuration = asset.duration || asset.metadata?.duration || 30
+ *   tplSeg = templateSegments[i] || lastSegment
+ *   segDuration = clamp(assetDuration, tplSeg.duration_min, tplSeg.duration_max)
+ *   start_time = 0
+ *   duration = segDuration
+ */
+import type { AssetItem } from "@/api/assets"
+import type { TemplateSegment } from "@/api/templates/types"
+import type { EditPlanClipInput } from "@/api/template-editor"
+
+interface BuildClipsOptions {
+  /** 选中的素材 ID 列表（按选择顺序） */
+  selectedIds: string[]
+  /** 已加载的素材列表（用于查 duration） */
+  materials: AssetItem[]
+  /** 智能匹配返回的素材（auto 模式下可能不在 materials 列表中） */
+  smartMatchedAssets?: AssetItem[]
+  /** 模板 segments */
+  templateSegments?: TemplateSegment[]
+}
+
+export function buildClipsFromAssets({
+  selectedIds,
+  materials,
+  smartMatchedAssets = [],
+  templateSegments = [],
+}: BuildClipsOptions): EditPlanClipInput[] {
+  if (!selectedIds.length) return []
+
+  // 合并两个素材来源，建立 id → asset 索引
+  const assetMap = new Map<string, AssetItem>()
+  for (const a of materials) assetMap.set(a.id, a)
+  for (const a of smartMatchedAssets) assetMap.set(a.id, a)
+
+  const lastSeg = templateSegments[templateSegments.length - 1]
+
+  return selectedIds.map((assetId, i) => {
+    const asset = assetMap.get(assetId)
+    const assetDuration = asset?.duration || asset?.metadata?.duration || 30
+
+    const tplSeg = templateSegments[i] || lastSeg
+    const segDuration = tplSeg
+      ? Math.min(tplSeg.duration_max, Math.max(tplSeg.duration_min, assetDuration))
+      : Math.min(assetDuration, 10)
+
+    return {
+      asset_id: assetId,
+      start_time: 0,
+      duration: segDuration,
+      order: i,
+    }
+  })
+}

apps/web/src/test/api/bgm.test.ts

@@ -32,7 +32,7 @@ describe("bgm API", () => {
 
   describe("getBgmPresets", () => {
     it("should resolve successfully", async () => {
-      await expect(getBgmPresets("test-params?")).resolves.not.toThrow()
+      await expect(getBgmPresets("test-template", { category: "test" })).resolves.not.toThrow()
     })
 
     it("should reject on API error", async () => {
@@ -42,7 +42,7 @@ describe("bgm API", () => {
       mockDelete.mockRejectedValue(new Error("Network error"))
       mockPatch.mockRejectedValue(new Error("Network error"))
 
-      await expect(getBgmPresets("test-params?")).rejects.toThrow()
+      await expect(getBgmPresets("test-template", { category: "test" })).rejects.toThrow()
     })
   })
 })

apps/web/src/test/api/edit-plans.test.ts

@@ -1,16 +1,12 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
 import {
-  getEditPlans,
   getEditPlan,
-  createEditPlan,
   updateEditPlan,
-  deleteEditPlan,
   generateEditPlan,
   getGenerationStatus,
   aiRecommendClips,
   getEditPlanGenerations,
   getGenerationTaskResults,
-  cancelGeneration,
   getEditPlanClips,
   getEditPlanClip,
   createEditPlanClip,
@@ -19,7 +15,6 @@ import {
   reorderEditPlanClips,
   batchDeleteEditPlanClips,
   createClipsFromAssets,
-  copyEditPlan,
   getMediaAssets,
   getMediaAsset,
 } from "@/api/template-editor"
@@ -53,22 +48,6 @@ describe("editPlans API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-  describe("getEditPlans", () => {
-    it("should resolve successfully", async () => {
-      await expect(getEditPlans("test-params?")).resolves.not.toThrow()
-    })
-
-    it("should reject on API error", async () => {
-      mockGet.mockRejectedValue(new Error("Network error"))
-      mockPost.mockRejectedValue(new Error("Network error"))
-      mockPut.mockRejectedValue(new Error("Network error"))
-      mockDelete.mockRejectedValue(new Error("Network error"))
-      mockPatch.mockRejectedValue(new Error("Network error"))
-
-      await expect(getEditPlans("test-params?")).rejects.toThrow()
-    })
-  })
-
   describe("getEditPlan", () => {
     it("should resolve successfully", async () => {
       await expect(getEditPlan("test-planId")).resolves.not.toThrow()
@@ -85,22 +64,6 @@ describe("editPlans API", () => {
     })
   })
 
-  describe("createEditPlan", () => {
-    it("should resolve successfully", async () => {
-      await expect(createEditPlan({ name: "test-item" })).resolves.not.toThrow()
-    })
-
-    it("should reject on API error", async () => {
-      mockGet.mockRejectedValue(new Error("Network error"))
-      mockPost.mockRejectedValue(new Error("Network error"))
-      mockPut.mockRejectedValue(new Error("Network error"))
-      mockDelete.mockRejectedValue(new Error("Network error"))
-      mockPatch.mockRejectedValue(new Error("Network error"))
-
-      await expect(createEditPlan({ name: "test-item" })).rejects.toThrow()
-    })
-  })
-
   describe("updateEditPlan", () => {
     it("should resolve successfully", async () => {
       await expect(updateEditPlan("test-planId")).resolves.not.toThrow()
@@ -117,22 +80,6 @@ describe("editPlans API", () => {
     })
   })
 
-  describe("deleteEditPlan", () => {
-    it("should resolve successfully", async () => {
-      await expect(deleteEditPlan("test-planId")).resolves.not.toThrow()
-    })
-
-    it("should reject on API error", async () => {
-      mockGet.mockRejectedValue(new Error("Network error"))
-      mockPost.mockRejectedValue(new Error("Network error"))
-      mockPut.mockRejectedValue(new Error("Network error"))
-      mockDelete.mockRejectedValue(new Error("Network error"))
-      mockPatch.mockRejectedValue(new Error("Network error"))
-
-      await expect(deleteEditPlan("test-planId")).rejects.toThrow()
-    })
-  })
-
   describe("generateEditPlan", () => {
     it("should resolve successfully", async () => {
       await expect(generateEditPlan("test-planId")).resolves.not.toThrow()
@@ -213,22 +160,6 @@ describe("editPlans API", () => {
     })
   })
 
-  describe("cancelGeneration", () => {
-    it("should resolve successfully", async () => {
-      await expect(cancelGeneration("test-planId")).resolves.not.toThrow()
-    })
-
-    it("should reject on API error", async () => {
-      mockGet.mockRejectedValue(new Error("Network error"))
-      mockPost.mockRejectedValue(new Error("Network error"))
-      mockPut.mockRejectedValue(new Error("Network error"))
-      mockDelete.mockRejectedValue(new Error("Network error"))
-      mockPatch.mockRejectedValue(new Error("Network error"))
-
-      await expect(cancelGeneration("test-planId")).rejects.toThrow()
-    })
-  })
-
   describe("getEditPlanClips", () => {
     it("should resolve successfully", async () => {
       await expect(getEditPlanClips("test-planId")).resolves.not.toThrow()
@@ -357,22 +288,6 @@ describe("editPlans API", () => {
     })
   })
 
-  describe("copyEditPlan", () => {
-    it("should resolve successfully", async () => {
-      await expect(copyEditPlan("test-planId")).resolves.not.toThrow()
-    })
-
-    it("should reject on API error", async () => {
-      mockGet.mockRejectedValue(new Error("Network error"))
-      mockPost.mockRejectedValue(new Error("Network error"))
-      mockPut.mockRejectedValue(new Error("Network error"))
-      mockDelete.mockRejectedValue(new Error("Network error"))
-      mockPatch.mockRejectedValue(new Error("Network error"))
-
-      await expect(copyEditPlan("test-planId")).rejects.toThrow()
-    })
-  })
-
   describe("getMediaAssets", () => {
     it("should resolve successfully", async () => {
       await expect(getMediaAssets("test-libraryId?")).resolves.not.toThrow()

apps/web/src/test/api/templates.test.ts

@@ -5,7 +5,6 @@ import {
   getTemplate,
   toggleFavoriteTemplate,
   copyTemplate,
-  generateFromTemplate,
 } from "@/api/templates"
 
 const mockGet = vi.fn()
@@ -116,20 +115,4 @@ describe("templates API", () => {
       await expect(copyTemplate("test-templateId")).rejects.toThrow()
     })
   })
-
-  describe("generateFromTemplate", () => {
-    it("should resolve successfully", async () => {
-      await expect(generateFromTemplate("test-templateId")).resolves.not.toThrow()
-    })
-
-    it("should reject on API error", async () => {
-      mockGet.mockRejectedValue(new Error("Network error"))
-      mockPost.mockRejectedValue(new Error("Network error"))
-      mockPut.mockRejectedValue(new Error("Network error"))
-      mockDelete.mockRejectedValue(new Error("Network error"))
-      mockPatch.mockRejectedValue(new Error("Network error"))
-
-      await expect(generateFromTemplate("test-templateId")).rejects.toThrow()
-    })
-  })
 })

apps/web/src/test/pages/EditingPlanner.test.tsx

@@ -150,12 +150,10 @@ vi.mock("@/api/template-editor", () => ({
   getMediaAssets: vi.fn().mockResolvedValue({ items: [] }),
   getEditPlanGenerations: vi.fn().mockResolvedValue({ items: [] }),
   getEditPlan: vi.fn().mockResolvedValue({}),
-  createEditPlan: vi.fn().mockResolvedValue({ id: "test-plan" }),
   updateEditPlan: vi.fn().mockResolvedValue({}),
   generateEditPlan: vi.fn().mockResolvedValue({ task_id: "test-task" }),
   getGenerationStatus: vi.fn().mockResolvedValue({ status: "completed" }),
   getGenerationTaskResults: vi.fn().mockResolvedValue({ items: [] }),
-  cancelGeneration: vi.fn().mockResolvedValue({}),
   getEditPlanClips: vi.fn().mockResolvedValue({ items: [] }),
   createEditPlanClip: vi.fn().mockResolvedValue({}),
   batchDeleteEditPlanClips: vi.fn().mockResolvedValue({}),

apps/web/src/test/pages/TemplateLibrary.test.tsx

@@ -109,7 +109,6 @@ vi.mock("@/api/templates", () => ({
   getTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
   toggleFavoriteTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
   copyTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
-  generateFromTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
 }))
 
 vi.mock("@/pages/templates/TemplateLibrary.css", () => ({}))

apps/worker/worker_app/tasks/generation.py

@@ -887,7 +887,6 @@ def _load_task_info(task_id: str) -> dict | None:
             "output_height": getattr(gen_task, "output_height", OUTPUT_HEIGHT) or OUTPUT_HEIGHT,
             "cover_url": getattr(gen_task, "cover_url", "") or "",
             "custom_title": getattr(gen_task, "custom_title", "") or "",
-            "title_config": dict(getattr(gen_task, "title_config", {}) or {}),
             "voice_ids": list(getattr(gen_task, "voice_ids", []) or []),
         }
     finally:
@@ -968,7 +967,6 @@ def _render_video(
     bgm_config: dict | None = None,
     voice_ids: list[str] | None = None,
     custom_title: str = "",
-    title_config: dict | None = None,
 ) -> tuple[Path, float, list[dict] | None]:
     """渲染视频（含配音混音）。
 
@@ -1001,34 +999,27 @@ def _render_video(
                 list(template_config.keys()),
             )
 
-    # ── 用户自定义标题：title_config 优先，custom_title 兜底 ─────────────
-    effective_title_cfg: dict | None = None
-    if title_config and isinstance(title_config, dict) and title_config.get("text", "").strip():
-        effective_title_cfg = dict(title_config)
-    elif custom_title:
+    # ── 用户自定义标题覆盖模板标题配置 ──────────────────────────────────
+    if custom_title:
         try:
-            parsed = json.loads(custom_title) if isinstance(custom_title, str) else custom_title
-            if isinstance(parsed, dict) and parsed.get("text", "").strip():
-                effective_title_cfg = parsed
+            user_title_cfg = json.loads(custom_title) if isinstance(custom_title, str) else custom_title
+            if isinstance(user_title_cfg, dict) and user_title_cfg.get("text", "").strip():
+                # 字段名归一化: 前端 font_size/font_color → 后端 size/color
+                if "font_size" in user_title_cfg and "size" not in user_title_cfg:
+                    user_title_cfg["size"] = user_title_cfg["font_size"]
+                if "font_color" in user_title_cfg and "color" not in user_title_cfg:
+                    user_title_cfg["color"] = user_title_cfg["font_color"]
+                plan_cfg = dict(virtual_plan.config or {})
+                plan_cfg["title"] = user_title_cfg
+                virtual_plan.config = plan_cfg
+                logger.info(
+                    "[task_id=%s] [渲染] 用户自定义标题已注入: text=%s",
+                    task_id,
+                    user_title_cfg.get("text", "")[:30],
+                )
         except (json.JSONDecodeError, TypeError):
             logger.warning("[task_id=%s] custom_title JSON解析失败: %s", task_id, custom_title[:100])
 
-    if effective_title_cfg:
-        # 字段名归一化: 前端 font_size/font_color → 后端 size/color
-        if "font_size" in effective_title_cfg and "size" not in effective_title_cfg:
-            effective_title_cfg["size"] = effective_title_cfg["font_size"]
-        if "font_color" in effective_title_cfg and "color" not in effective_title_cfg:
-            effective_title_cfg["color"] = effective_title_cfg["font_color"]
-        plan_cfg = dict(virtual_plan.config or {})
-        plan_cfg["title"] = effective_title_cfg
-        virtual_plan.config = plan_cfg
-        logger.info(
-            "[task_id=%s] [渲染] 标题配置已注入(source=%s): text=%s",
-            task_id,
-            "title_config" if title_config else "custom_title",
-            effective_title_cfg.get("text", "")[:30],
-        )
-
     # 用户自定义 BGM 覆盖模板 BGM（用户指定优先级最高）
     if bgm_config:
         plan_cfg = virtual_plan.config or {}
@@ -1410,7 +1401,6 @@ def generate_video(self, task_id: str) -> dict:
                 bgm_config=task_info.get("bgm_config", {}),
                 voice_ids=task_info.get("voice_ids", []),
                 custom_title=task_info.get("custom_title", ""),
-                title_config=task_info.get("title_config", {}),
             )
 
             if gen_task:

packages/adapters/sqlalchemy_impl/generation_task_repository.py

@@ -42,7 +42,6 @@ def _to_domain(model: GenerationTaskModel) -> GenerationTask:
         output_height=getattr(model, "output_height", 720) or 720,
         cover_url=getattr(model, "cover_url", "") or "",
         custom_title=getattr(model, "custom_title", "") or "",
-        title_config=dict(getattr(model, "title_config", {}) or {}),
         logs=model.logs or "[]",
         created_at=model.created_at,
         updated_at=model.updated_at,
@@ -87,7 +86,6 @@ class SQLAlchemyGenerationTaskRepository:
             output_height=task.output_height,
             cover_url=task.cover_url or "",
             custom_title=task.custom_title or "",
-            title_config=dict(task.title_config) if task.title_config else {},
             logs=task.logs,
             created_at=task.created_at,
             updated_at=task.updated_at,
@@ -275,7 +273,6 @@ class SQLAlchemyGenerationTaskRepository:
         model.output_height = task.output_height
         model.cover_url = task.cover_url or ""
         model.custom_title = task.custom_title or ""
-        model.title_config = dict(task.title_config) if task.title_config else {}
         model.logs = task.logs
         self.session.commit()
         return task

packages/adapters/sqlalchemy_impl/models.py

@@ -298,7 +298,6 @@ class GenerationTaskModel(Base):
     output_height = Column(Integer, nullable=False, default=720)
     cover_url = Column(String(1000), nullable=False, default="")
     custom_title = Column(String(500), nullable=False, default="")
-    title_config = Column(JSON, nullable=False, default=dict)
     bgm_config = Column(JSON, nullable=False, default=dict)
     extra_meta = Column("metadata", JSON, nullable=False, default=dict)
     logs = Column(Text, nullable=False, default="[]", server_default="[]")

packages/application/generation_tasks.py

@@ -69,7 +69,6 @@ class CreateGenerationTaskUseCase:
             output_height=command.output_height,
             cover_url=command.cover_url,
             custom_title=command.custom_title,
-            title_config=command.title_config,
         )
         return self.generation_task_repository.create(task)
 

packages/domain/generation_task.py

@@ -121,7 +121,6 @@ class GenerationTask:
     output_height: int = 720
     cover_url: str = ""
     custom_title: str = ""
-    title_config: dict = field(default_factory=dict)
     extra_meta: dict = field(default_factory=dict)
     logs: str = "[]"
     created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
@@ -154,7 +153,6 @@ class GenerationTask:
         output_height: int = 720,
         cover_url: str = "",
         custom_title: str = "",
-        title_config: dict | None = None,
         extra_meta: dict | None = None,
     ) -> "GenerationTask":
         if not project_id.strip() and not template_id.strip():
@@ -186,7 +184,6 @@ class GenerationTask:
             output_height=output_height,
             cover_url=cover_url,
             custom_title=custom_title,
-            title_config=dict(title_config) if title_config else {},
             extra_meta=dict(extra_meta) if extra_meta else {},
         )
 

tests/unit/test_writeback_edit_plan_config.py

@@ -1,126 +0,0 @@
-"""Tests for _writeback_edit_plan_config in generation_tasks route.
-
-覆盖 CI 增量覆盖率不足的代码：
-- generation_tasks.py 行 160-193 (_writeback_edit_plan_config 函数体)
-- generation_tasks.py 行 371-372 (路由中调用该函数)
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "apps" / "api"))
-
-from app.api.routes.generation_tasks import _writeback_edit_plan_config
-
-
-@pytest.fixture
-def mock_db():
-    """Mock SQLAlchemy Session."""
-    db = MagicMock()
-    db.query.return_value = db
-    db.filter.return_value = db
-    return db
-
-
-@pytest.fixture
-def mock_plan():
-    """Mock EditPlanModel instance."""
-    plan = MagicMock()
-    plan.config = {"existing_key": "existing_value"}
-    return plan
-
-
-class TestWritebackEditPlanConfig:
-    """_writeback_edit_plan_config 全分支覆盖"""
-
-    # ---- 行 160-161: plan_id 为空直接返回 ----
-    def test_empty_plan_id_returns_immediately(self, mock_db):
-        _writeback_edit_plan_config(plan_id="", task_id="task_1", title_config={"text": "hi"}, db=mock_db)
-        mock_db.query.assert_not_called()
-        mock_db.commit.assert_not_called()
-
-    def test_none_plan_id_returns_immediately(self, mock_db):
-        _writeback_edit_plan_config(plan_id=None, task_id="task_1", title_config=None, db=mock_db)
-        mock_db.query.assert_not_called()
-
-    # ---- 行 165-168: plan 不存在 → warning + 不 commit ----
-    def test_plan_not_found_no_commit(self, mock_db):
-        mock_db.first.return_value = None
-
-        _writeback_edit_plan_config(plan_id="plan_999", task_id="task_1", title_config=None, db=mock_db)
-
-        mock_db.query.assert_called_once()
-        mock_db.commit.assert_not_called()
-
-    # ---- 行 170-182: 正常写入 + title_config ----
-    def test_success_with_title_config(self, mock_db, mock_plan):
-        mock_db.first.return_value = mock_plan
-
-        _writeback_edit_plan_config(
-            plan_id="plan_123",
-            task_id="task_456",
-            title_config={"text": "标题", "font_size": 36},
-            db=mock_db,
-        )
-
-        assert mock_plan.config["generation_task_id"] == "task_456"
-        assert mock_plan.config["title_config"] == {"text": "标题", "font_size": 36}
-        assert mock_plan.config["existing_key"] == "existing_value"
-        mock_db.commit.assert_called_once()
-
-    # ---- 行 170-175: 正常写入、无 title_config ----
-    def test_success_without_title_config(self, mock_db, mock_plan):
-        mock_db.first.return_value = mock_plan
-
-        _writeback_edit_plan_config(plan_id="plan_123", task_id="task_789", title_config=None, db=mock_db)
-
-        assert mock_plan.config["generation_task_id"] == "task_789"
-        assert "title_config" not in mock_plan.config
-        mock_db.commit.assert_called_once()
-
-    # ---- 行 170: config 不是 dict → 兜底空 dict ----
-    def test_config_not_dict_uses_empty_dict(self, mock_db):
-        bad_plan = MagicMock()
-        bad_plan.config = "not_a_dict"
-        mock_db.first.return_value = bad_plan
-
-        _writeback_edit_plan_config(plan_id="plan_123", task_id="task_1", title_config=None, db=mock_db)
-
-        assert isinstance(bad_plan.config, dict)
-        assert bad_plan.config["generation_task_id"] == "task_1"
-        mock_db.commit.assert_called_once()
-
-    # ---- 行 183-189: DB 异常 → warning + rollback ----
-    def test_db_exception_triggers_rollback(self, mock_db, mock_plan):
-        mock_db.first.return_value = mock_plan
-        mock_db.commit.side_effect = RuntimeError("DB connection lost")
-
-        # 不应抛异常
-        _writeback_edit_plan_config(plan_id="plan_123", task_id="task_1", title_config=None, db=mock_db)
-
-        mock_db.rollback.assert_called_once()
-
-    # ---- 行 190-193: rollback 也失败 → 静默 ----
-    def test_rollback_failure_silent(self, mock_db, mock_plan):
-        mock_db.first.return_value = mock_plan
-        mock_db.commit.side_effect = RuntimeError("commit failed")
-        mock_db.rollback.side_effect = RuntimeError("rollback also failed")
-
-        # 两个异常都不应抛出
-        _writeback_edit_plan_config(plan_id="plan_123", task_id="task_1", title_config=None, db=mock_db)
-        mock_db.rollback.assert_called_once()
-
-    # ---- 行 173: title_config 为空 dict → 不写入 title_config ----
-    def test_empty_title_config_not_written(self, mock_db, mock_plan):
-        mock_db.first.return_value = mock_plan
-
-        _writeback_edit_plan_config(plan_id="plan_123", task_id="task_1", title_config={}, db=mock_db)
-
-        # 空 dict 为 falsy，不写入
-        assert "title_config" not in mock_plan.config
-        assert mock_plan.config["generation_task_id"] == "task_1"