fix(viral-video): 修复用户参数未生效 6 项问题 #2249

Bug1(P0): worker 用 target_customer 替代 target_audience，目标客户正确注入 prompt
Bug2(P0): 调用 _persona_style_hint()、扩充 _PERSONA_STYLE_GUIDE 覆盖老板型IP等、<persona> 进 prompt
Bug3(P0): 新增 _viral_structure_hint() 映射结构名到写作指导、<viral_structure> 进 prompt
Bug4(P1): <industry> 标签进 prompt，render 时传入 industry
Bug5(P1): language 字段全链路：Domain/Schema/DB Model/Repository/Migration/Prompt/TTS
Bug6(P1): ConfirmCopyRequest 补 voice_id/voice_source/language，confirm_copy 路由持久化

Prompt 改动：_STORYBOARD_USER 加 industry/persona/viral_structure/language 标签
_SYSTEM 追加规则：必须按用户参数写文案和分镜
alembic migration 107: ADD COLUMN language VARCHAR(20) DEFAULT zh-CN

.ci-trigger

@@ -1 +1,2 @@
-trigger staging deploy for 3fa1fbf0 (MOCK_STORYBOARD fix) at 2026-10-12 13:40:16
+CI trigger file - safe to delete
+retrigger at 2026-09-15 20:31:24 UTC

.gitea/workflows/ci-pipeline.yml

@@ -437,7 +437,7 @@ jobs:
     if: "always() && needs.dedupe-check.outputs.skip_tests != 'true' && needs.check-frontend-only.outputs.skip_backend != 'true'"
     name: Unit Tests
     runs-on: ci-l2
-    timeout-minutes: 20
+    timeout-minutes: 8
     env:
       PIP_CACHE_DIR: /root/.cache/pip
       PIP_NO_CACHE_DIR: ''
@@ -1195,7 +1195,6 @@ jobs:
         DOUBAO_FAST_MODEL: "${{ secrets.DOUBAO_FAST_MODEL }}"
         DOUBAO_TIMEOUT: "${{ secrets.DOUBAO_TIMEOUT }}"
         DOUBAO_MAX_RETRIES: "${{ secrets.DOUBAO_MAX_RETRIES }}"
-        DITTO_EMOTION_TIMEOUT: "${{ secrets.DITTO_EMOTION_TIMEOUT }}"
         WECHAT_APP_ID: "${{ secrets.WECHAT_APP_ID }}"
         WECHAT_APP_SECRET: "${{ secrets.WECHAT_APP_SECRET }}"
         TIKHUB_API_KEY: "${{ secrets.TIKHUB_API_KEY }}"

alembic/versions/105_narration_first.py

@@ -28,17 +28,10 @@ depends_on = None
 
 
 def _tpl(prompt_type: str, version: int) -> dict:
-    """取模板：先按指定版本找，找不到则取该类型最新版本（兼容 v3→v4 升级）。"""
-    # 先按指定版本找
     for t in DEFAULT_TEMPLATES:
         if t["prompt_type"] == prompt_type and t["version"] == version:
             return t
-    # 找不到则取最新版本
-    candidates = [t for t in DEFAULT_TEMPLATES if t["prompt_type"] == prompt_type]
-    if candidates:
-        latest = max(candidates, key=lambda x: x["version"])
-        return latest
-    raise RuntimeError("default template missing: %s" % prompt_type)
+    raise RuntimeError("default template missing: %s v%s" % (prompt_type, version))
 
 
 def _upsert(bind, t: dict) -> None:

alembic/versions/107_add_language_to_viral_video_jobs.py

@@ -1,7 +1,7 @@
 """add language column to viral_video_jobs
 
 Revision ID: 107
-Revises: 106_system_settings
+Revises: 106
 Create Date: 2026-10-09
 
 """
@@ -10,13 +10,16 @@ from alembic import op
 
 # revision identifiers, used by Alembic.
 revision = "107"
-down_revision = "106_system_settings"
+down_revision = "106"
 branch_labels = None
 depends_on = None
 
 
 def upgrade() -> None:
-    op.execute("ALTER TABLE viral_video_jobs " "ADD COLUMN IF NOT EXISTS language VARCHAR(20) NOT NULL DEFAULT 'zh-CN'")
+    op.execute(
+        "ALTER TABLE viral_video_jobs "
+        "ADD COLUMN IF NOT EXISTS language VARCHAR(20) NOT NULL DEFAULT 'zh-CN'"
+    )
 
 
 def downgrade() -> None:

alembic/versions/108_storyboard_v4_multivoice.py

@@ -1,235 +0,0 @@
-# -*- coding: utf-8 -*-
-"""storyboard v4 - 多角色对话 + 废除旁白 + visual 5要素
-
-Revision ID: 108_storyboard_v4_multivoice
-Revises: 107
-Create Date: 2026-10-10
-
-变更：
-1. storyboard v4: 废除旁白思维，所有voiceover必须是角色台词
-   - 增加<speaker>标签，每镜必须标注说话人
-   - visual强制5要素结构（景别/运镜/动作/环境/光线），每镜不少于30字
-   - voiceover_script用[speaker:xxx]标记格式
-2. 旧版storyboard模板is_active设为false
-3. 检查image_analysis和review是否有active模板，没有则插入保底版本
-"""
-
-from sqlalchemy import text
-
-from alembic import op
-
-revision = "108_storyboard_v4_multivoice"
-down_revision = "107"
-branch_labels = None
-depends_on = None
-
-# ── storyboard v4 system_prompt ──────────────────────────────────────
-V4_STORYBOARD_SYSTEM = """你是一名懂短视频的编导和口播文案高手。你会拿到图片的真实观察、营销目的和用户参数，请一次性完成对营销意图的理解，并产出可直接拍摄/生成的分镜脚本。不要单独输出"意图解析"，意图要直接体现在台词和分镜里。
-
-## 核心设计原则（必须严格遵守）
-1. **废除旁白思维**：所有视频类型——无论对话短剧/口播带货/获客引流/品牌故事——voiceover 必须是人物说的话（第一人称或角色对白），绝对不能出现第三人称旁白解说。观众看的是人在演、在说。
-2. **严禁第三人称解说性台词**：如"接下来展示...""这款产品..."这类上帝视角描述禁止出现在 voiceover 中。
-3. **短剧类营销目的**（对话短剧/反转短剧/悬念短剧/情绪短片）：双角色对话格式"甲：xxx 乙：xxx"，镜头在角色间切换。
-4. **口播类**（口播带货/促销转化/功能演示/痛点解决/获客引流/账号涨粉/活动通知/场景种草）：第一人称对镜头说话，像真人出镜。
-
-## 输出格式（XML，严格按结构输出，不要输出额外解释）
-<script>
-  <copy_display_markdown><![CDATA[直接展示给用户看的成片文案，用 Markdown 写成流畅叙述]]></copy_display_markdown>
-  <clips>
-    <clip index="1">
-      <time_range>0-3秒</time_range>
-      <speaker>说话人标识（如"店主""顾客""主播"）</speaker>
-      <voiceover>这一镜的角色台词（人物说的话，不是旁白）</voiceover>
-      <visual>【景别】【镜头运动】【人物动作/表情】【环境/道具】【光线氛围】5要素结构，不少于30字</visual>
-      <reference_image_index>0</reference_image_index>
-    </clip>
-  </clips>
-  <voiceover_script>把所有 clip 的 voiceover 连成完整台词稿，用 [speaker:xxx] 标记每个说话段落</voiceover_script>
-  <theme>一句话主题</theme>
-  <negative>【反套路化要求】
-禁止使用"家人们谁懂啊""绝绝子""宝子们""家人们""太绝了""yyds"等烂大街网络词；
-禁止固定模板化开头；语言要像真人朋友之间的分享，自然、具体、有信息量。</negative>
-</script>
-
-## 写作要求
-1. **台词（voiceover）**：像真人面对镜头说话或角色对白，短句、口语化、有停顿有情绪，开头 3 秒给出钩子；不要书面腔，不要机械报参数。严禁第三人称解说。
-2. **说话人（speaker）**：每个 clip 必须标注说话人标识，如"店主""顾客""主播""我"等。短剧类必须有至少 2 个不同角色。
-3. **画面描述（visual）**：强制 5 要素结构——【景别】【镜头运动】【人物动作/表情】【环境/道具】【光线氛围】，每镜 visual 不少于 30 字，要具体到"闭眼听台词能想象出画面"。
-4. **voiceover_script 格式**：用 [speaker:xxx] 标记每个说话段落，如"[speaker:店主]你是不是也觉得...[speaker:顾客]是啊，怎么回事？"
-5. copy_display_markdown：直接展示给最终用户的文案，用 Markdown 写成自然、流畅、有感染力的成片文案。
-6. 内容必须来自图片观察与用户给出的信息，不编造卖点、不夸大、不使用绝对化用语和虚假承诺。
-7. reference_image_index 填本镜参考图片序号（从 0 开始），没有合适参考图填 -1。
-8. 分镜数量与时长匹配总时长，节奏紧凑。
-9. **口播字数硬约束**（必须严格遵守）：按每秒约 2.5~3 个中文字（正常口播语速）计算：
-   - 5秒视频：voiceover_script 总字数 12~15 字
-   - 10秒视频：voiceover_script 总字数 25~30 字
-   - 15秒视频：voiceover_script 总字数 35~45 字
-   - 20秒视频：voiceover_script 总字数 50~60 字
-   - 30秒视频：voiceover_script 总字数 75~90 字
-   - 宁可少写也不要多写，超长会导致 TTS 音频超出视频时长限制
-10. **镜头数量硬约束**：5秒1~2镜、10秒3镜、15秒3~4镜、20秒4~5镜、30秒6~8镜
-11. **时间轴硬约束**：第一个clip从0秒开始，最后一个clip结束于total_duration秒，相邻clip首尾相接
-12. 必须严格按<marketing_purpose><target_audience><persona><viral_structure><language><industry>指定的参数写文案和分镜
-13. 镜头间动作衔接要自然，画面描述要具体到能直接拍摄/生成"""
-
-V4_STORYBOARD_USER = """<marketing_purpose>{marketing_purpose}</marketing_purpose>
-<industry>{industry}</industry>
-<image_analysis>
-{image_summary}
-</image_analysis>
-<user_parameters>
-<theme_hint>{theme_hint}</theme_hint>
-<duration>{duration}秒</duration>
-<aspect_ratio>{aspect_ratio}</aspect_ratio>
-<tone>{tone}</tone>
-<target_audience>{target_audience}</target_audience>
-<persona>{persona_hint}</persona>
-<viral_structure>{viral_structure_hint}</viral_structure>
-<language>{language_hint}</language>
-<extra_requirements>{extra_requirements}</extra_requirements>
-</user_parameters>
-{video_style_section}
-请严格按 XML 结构输出分镜脚本。"""
-
-V4_STORYBOARD_EXAMPLE = """<script>
-  <copy_display_markdown><![CDATA[# 在御众堂，把松弛的自己一点点找回来
-产后妈妈最懂那种力不从心，推开门，暖光和一杯热茶先接住了你……]]></copy_display_markdown>
-  <clips>
-    <clip index="1">
-      <time_range>0-3秒</time_range>
-      <speaker>店主</speaker>
-      <voiceover>生完娃，是不是连照镜子的勇气都没了？</voiceover>
-      <visual>【中近景】【缓推】【妈妈疲惫看向镜子】【暖光店内环境】【柔和暖光】</visual>
-      <reference_image_index>0</reference_image_index>
-    </clip>
-    <clip index="2">
-      <time_range>3-6秒</time_range>
-      <speaker>顾客</speaker>
-      <voiceover>是啊，怎么回事？</voiceover>
-      <visual>【近景】【固定】【顾客表情惊讶】【店内休息区】【暖色调】</visual>
-      <reference_image_index>0</reference_image_index>
-    </clip>
-  </clips>
-  <voiceover_script>[speaker:店主]生完娃，是不是连照镜子的勇气都没了？[speaker:顾客]是啊，怎么回事？</voiceover_script>
-  <theme>产后妈妈走进御众堂重拾状态</theme>
-  <negative>模糊、畸变、夸大疗效、绝对化用语</negative>
-</script>"""
-
-
-def upgrade() -> None:
-    conn = op.get_bind()
-
-    # 1. 查询 storyboard 当前最大 version
-    result = conn.execute(
-        text("SELECT MAX(version) FROM viral_video_prompt_templates WHERE prompt_type = :pt"),
-        {"pt": "storyboard"},
-    )
-    max_version = result.scalar() or 0
-    new_version = max_version + 1
-
-    # 2. 旧版 storyboard 模板 is_active 设为 false
-    conn.execute(
-        text("UPDATE viral_video_prompt_templates SET is_active = false WHERE prompt_type = :pt"),
-        {"pt": "storyboard"},
-    )
-
-    # 3. 防御性插入新版 storyboard 模板
-    existing = conn.execute(
-        text("SELECT id FROM viral_video_prompt_templates " "WHERE prompt_type = :pt AND version = :ver"),
-        {"pt": "storyboard", "ver": new_version},
-    ).fetchone()
-
-    if not existing:
-        conn.execute(
-            text(
-                "INSERT INTO viral_video_prompt_templates "
-                "(name, prompt_type, version, system_prompt, user_prompt_template, example_output, is_active) "
-                "VALUES (:name, :pt, :ver, :sys, :usr, :ex, :active)"
-            ),
-            {
-                "name": "编导分镜v4-多角色对话版",
-                "pt": "storyboard",
-                "ver": new_version,
-                "sys": V4_STORYBOARD_SYSTEM,
-                "usr": V4_STORYBOARD_USER,
-                "ex": V4_STORYBOARD_EXAMPLE,
-                "active": True,
-            },
-        )
-
-    # 4. 检查 image_analysis 是否有 active 模板，没有则插入保底
-    ia_active = conn.execute(
-        text("SELECT COUNT(*) FROM viral_video_prompt_templates WHERE prompt_type = :pt AND is_active = true"),
-        {"pt": "image_analysis"},
-    ).scalar()
-
-    if ia_active == 0:
-        # 插入保底 image_analysis 模板（简化版）
-        ia_max = (
-            conn.execute(
-                text("SELECT MAX(version) FROM viral_video_prompt_templates WHERE prompt_type = :pt"),
-                {"pt": "image_analysis"},
-            ).scalar()
-            or 0
-        )
-        conn.execute(
-            text(
-                "INSERT INTO viral_video_prompt_templates "
-                "(name, prompt_type, version, system_prompt, user_prompt_template, example_output, is_active) "
-                "VALUES (:name, :pt, :ver, :sys, :usr, :ex, :active)"
-            ),
-            {
-                "name": "图片分析保底版",
-                "pt": "image_analysis",
-                "ver": ia_max + 1,
-                "sys": "你是一名擅长观察和写作的品牌内容编导。分析图片并输出JSON。",
-                "usr": "请分析这张图片。图片地址：{image_url}",
-                "ex": '{"images": [{"type": "store", "name": "门店", "summary_markdown": "描述"}]}',
-                "active": True,
-            },
-        )
-
-    # 5. 检查 review 是否有 active 模板
-    review_active = conn.execute(
-        text("SELECT COUNT(*) FROM viral_video_prompt_templates WHERE prompt_type = :pt AND is_active = true"),
-        {"pt": "review"},
-    ).scalar()
-
-    if review_active == 0:
-        rv_max = (
-            conn.execute(
-                text("SELECT MAX(version) FROM viral_video_prompt_templates WHERE prompt_type = :pt"),
-                {"pt": "review"},
-            ).scalar()
-            or 0
-        )
-        conn.execute(
-            text(
-                "INSERT INTO viral_video_prompt_templates "
-                "(name, prompt_type, version, system_prompt, user_prompt_template, example_output, is_active) "
-                "VALUES (:name, :pt, :ver, :sys, :usr, :ex, :active)"
-            ),
-            {
-                "name": "文案审核保底版",
-                "pt": "review",
-                "ver": rv_max + 1,
-                "sys": "你是短视频广告合规审核专家。审核文案输出XML。",
-                "usr": "请审核：{fusion_text}",
-                "ex": "<review><passed>true</passed></review>",
-                "active": True,
-            },
-        )
-
-
-def downgrade() -> None:
-    # 恢复旧版 storyboard 为 active
-    conn = op.get_bind()
-    conn.execute(
-        text("UPDATE viral_video_prompt_templates SET is_active = true WHERE prompt_type = :pt AND version < :ver"),
-        {"pt": "storyboard", "ver": 4},
-    )
-    # 删除新版
-    conn.execute(
-        text("DELETE FROM viral_video_prompt_templates WHERE prompt_type = :pt AND version >= :ver"),
-        {"pt": "storyboard", "ver": 4},
-    )

alembic/versions/109_add_viral_video_param_guides.py

@@ -1,42 +0,0 @@
-# -*- coding: utf-8 -*-
-"""viral_video_param_guides 表：运营可配置的人设/结构/营销目的/目标客群/语言指导文案（PR3 P2-h）。
-
-Revision ID: 109_add_viral_video_param_guides
-Revises: 108_storyboard_v4_multivoice
-Create Date: 2026-10-12
-
-表用途：
-- 替代 worker 中 ~130 行硬编码 if/elif mapping；
-- 5 类 guide_type: persona / structure / marketing_purpose / target_customer / language；
-- 启动时由 seed_viral_video_param_guides.py 灌入代码默认值，运营可在后台改，30s TTL 缓存自动热加载。
-"""
-
-from alembic import op
-
-revision = "109_add_viral_video_param_guides"
-down_revision = "108_storyboard_v4_multivoice"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.execute("""
-        CREATE TABLE IF NOT EXISTS viral_video_param_guides (
-            id SERIAL PRIMARY KEY,
-            guide_type VARCHAR(32) NOT NULL,
-            guide_key VARCHAR(64) NOT NULL,
-            guide_text TEXT NOT NULL,
-            created_at TIMESTAMP NOT NULL DEFAULT NOW(),
-            updated_at TIMESTAMP NOT NULL DEFAULT NOW(),
-            UNIQUE (guide_type, guide_key)
-        )
-    """)
-    op.execute("""
-        CREATE INDEX IF NOT EXISTS ix_viral_video_param_guides_type_key
-            ON viral_video_param_guides (guide_type, guide_key)
-    """)
-
-
-def downgrade() -> None:
-    op.execute("DROP INDEX IF EXISTS ix_viral_video_param_guides_type_key")
-    op.execute("DROP TABLE IF EXISTS viral_video_param_guides")

alembic/versions/110_add_tone_to_viral_video_jobs.py

@@ -1,23 +0,0 @@
-"""add tone column to viral_video_jobs
-
-Revision ID: 110
-Revises: 109_add_viral_video_param_guides
-Create Date: 2026-10-14
-
-"""
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = "110"
-down_revision = "109_add_viral_video_param_guides"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.execute("ALTER TABLE viral_video_jobs ADD COLUMN IF NOT EXISTS tone VARCHAR(50) NOT NULL DEFAULT ''")
-
-
-def downgrade() -> None:
-    op.execute("ALTER TABLE viral_video_jobs DROP COLUMN IF EXISTS tone")

apps/api/app/api/routes/admin/ditto_emotion.py

@@ -1,18 +1,13 @@
 """Ditto 数字人表情后台配置 — #2246.
 
 路由前缀 /api/v1/admin/ditto-emotion，全部使用 _verify_internal_api_key 鉴权
-（X-API-Key header）。仅开放 6 项白名单配置：
+（X-API-Key header）。仅开放 5 项白名单配置：
 - ditto_emotion_enabled / ditto_emotion_model / ditto_emotion_temperature
-- ditto_emotion_prompt / ditto_blend_frames / doubao_api_key
-注意：doubao_api_key 属于密钥，GET 只返回脱敏占位，绝不返回明文。
-ditto_emotion_model 为自由文本（支持火山方舟 ep- 接入点 ID），
-推荐选项 model_options 从 system_config 的 ditto_emotion_model_options（JSON 数组）读取。
+- ditto_emotion_prompt / ditto_blend_frames
 """
 
 from __future__ import annotations
 
-import json
-import re
 from typing import Any
 
 from fastapi import APIRouter, Depends
@@ -35,6 +30,12 @@ router = APIRouter(
     dependencies=[Depends(_verify_internal_api_key)],
 )
 
+MODEL_OPTIONS = [
+    "doubao-seed-2-1-lite-250915",
+    "doubao-seed-2-1-pro-250915",
+    "deepseek-v3",
+]
+
 # key → (类型, 分类)
 _WHITELIST: dict[str, str] = {
     "ditto_emotion_enabled": SETTING_TYPE_BOOL,
@@ -42,7 +43,6 @@ _WHITELIST: dict[str, str] = {
     "ditto_emotion_temperature": SETTING_TYPE_FLOAT,
     "ditto_emotion_prompt": SETTING_TYPE_STRING,
     "ditto_blend_frames": SETTING_TYPE_INT,
-    "doubao_api_key": SETTING_TYPE_STRING,
 }
 
 _DESCRIPTIONS: dict[str, str] = {
@@ -51,13 +51,8 @@ _DESCRIPTIONS: dict[str, str] = {
     "ditto_emotion_temperature": "模型温度，0-1，越低越稳定保守。",
     "ditto_emotion_prompt": "情绪分析提示词，核心调优入口，必须包含 {文案} 占位符。",
     "ditto_blend_frames": "表情切换过渡帧数（6-30），越大越柔和。",
-    "doubao_api_key": "豆包/火山方舟 API Key（用于情绪分析LLM调用）",
 }
 
-# 密钥类配置：GET 脱敏、PUT 响应不回显明文
-_SECRET_KEYS = {"doubao_api_key"}
-_SECRET_PLACEHOLDER = "***已配置***"
-
 
 def _settings():
     return get_api_settings()
@@ -67,45 +62,17 @@ def _default_value(key: str) -> Any:
     return getattr(_settings(), key)
 
 
-def _model_options_from_db(service) -> list[str]:
-    """模型推荐选项：从 system_config 读 ditto_emotion_model_options（JSON 数组字符串）。
-
-    未配置 / 非法 JSON / 非数组 JSON 均返回空数组；数组元素统一转字符串。
-    """
-    raw = service.get_config("ditto_emotion_model_options", "") or ""
-    if not str(raw).strip():
-        return []
-    try:
-        data = json.loads(raw)
-    except (TypeError, ValueError):
-        return []
-    if not isinstance(data, list):
-        return []
-    return [str(x) for x in data if isinstance(x, (str, int, float))]
-
-
 def _build_config_item(key: str) -> dict[str, Any]:
-    service = get_system_config_service()
-    if key in _SECRET_KEYS:
-        # 密钥不回明文、不暴露 env 默认值：DB 或 env 任一侧已配置即视为已配置
-        db_value = service.get_config(key, None)
-        configured = bool((db_value or "").strip()) or bool((getattr(_settings(), key, "") or "").strip())
-        return {
-            "key": key,
-            "type": _WHITELIST[key],
-            "description": _DESCRIPTIONS.get(key, ""),
-            "default": "",
-            "value": _SECRET_PLACEHOLDER if configured else "",
-        }
     item: dict[str, Any] = {
         "key": key,
         "type": _WHITELIST[key],
         "description": _DESCRIPTIONS.get(key, ""),
         "default": _default_value(key),
     }
+    service = get_system_config_service()
     item["value"] = service.get_config(key, _default_value(key))
     if key == "ditto_emotion_model":
-        item["model_options"] = _model_options_from_db(service)
+        item["model_options"] = list(MODEL_OPTIONS)
     return item
 
 
@@ -141,15 +108,8 @@ def _validate_value(key: str, value: Any) -> Any:
             raise ValueError(f"{key} 必须是字符串")
         if key == "ditto_emotion_prompt" and value.strip() and "{文案}" not in value:
             raise ValueError("提示词必须包含 {文案} 占位符")
-        if key == "ditto_emotion_model":
-            if not value.strip():
-                raise ValueError(f"{key} 不能为空字符串")
-            if len(value) > 200:
-                raise ValueError(f"{key} 长度不能超过 200 字符")
-            if not re.fullmatch(r"[A-Za-z0-9_-]+", value):
-                raise ValueError(f"{key} 只能包含字母、数字、连字符和下划线")
-        if key == "doubao_api_key" and not value.strip():
-            raise ValueError(f"{key} 不能为空字符串")
+        if key == "ditto_emotion_model" and value not in MODEL_OPTIONS:
+            raise ValueError(f"模型必须是以下之一：{', '.join(MODEL_OPTIONS)}")
     return value
 
 
@@ -181,9 +141,9 @@ def update_config(
             key,
             value,
             setting_type=_WHITELIST[key],
-            updated_by=str(x_api_key)[:8] if x_api_key and x_api_key is not True else None,
+            updated_by=x_api_key[:8] if x_api_key else None,
         )
-        updated[key] = _SECRET_PLACEHOLDER if key in _SECRET_KEYS else value
+        updated[key] = value
     return {"ok": True, "updated": updated}
 
 

apps/api/app/api/routes/ai_avatar_render.py

@@ -18,7 +18,6 @@ from app.dependencies import get_db_session
 from app.schemas.ai_avatar_render import (
     AiAvatarRenderJobResponse,
     CreateAiAvatarRenderRequest,
-    FinalizeRenderRequest,
     FinalizeRenderResponse,
     SmartCoverResponse,
 )
@@ -27,7 +26,7 @@ from app.services.ai_avatar_render_service import (
     AiAvatarRenderError,
     AiAvatarRenderService,
 )
-from fastapi import APIRouter, Body, Depends, HTTPException, Query
+from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.orm import Session
 
 logger = logging.getLogger(__name__)
@@ -268,16 +267,13 @@ def generate_render_smart_cover(
 @router.post("/{job_id}/finalize", response_model=FinalizeRenderResponse)
 def finalize_render_job(
     job_id: str,
-    body: FinalizeRenderRequest = Body(default=FinalizeRenderRequest()),
     current_user: AuthenticatedUser = Depends(get_current_user),
     db: Session = Depends(get_db_session),
 ):
     """用户完成封面选择后，将视频正式保存到成片库.
 
     - 必须等渲染任务 completed 后才可调用
-    - body.cover_url：用户选定的封面公网 URL（本地上传需前端先走 OSS 直传拿公网 URL，blob:/data: URL 无效）；
-      为空时优先使用 smart-cover 已写入的 output_cover_url，仍为空则兜底自动抽一帧
-    - body.video_title：成片库展示标题；为空用默认 AI数字人_{job_id[:8]}
+    - 如果已通过 smart-cover/custom-cover 设置了封面，会自动带上
     - 返回成片库视频ID
     - 幂等：已 finalize 的任务重复调用会返回 existing 记录
     """
@@ -289,9 +285,6 @@ def finalize_render_job(
         raise HTTPException(status_code=404, detail="渲染任务不存在")
     if job.status != "completed":
         raise HTTPException(status_code=400, detail="请先完成视频生成")
-    video_url = (job.output_video_url or "").strip()
-    if not video_url:
-        raise HTTPException(status_code=400, detail="渲染成片视频 URL 为空，无法入库")
 
     # 幂等检查（通过 generation_task_id=job_id 识别，finalize_job 内部也做了一次，这里提前返回简化）
     from packages.adapters.sqlalchemy_impl.models import GeneratedVideoModel
@@ -311,58 +304,11 @@ def finalize_render_job(
             status="already_finalized",
         )
 
-    # 封面 URL 解析：按优先级 body.cover_url → job.output_cover_url（smart-cover）→ 兜底自动抽帧，
-    # 每一级都要校验是公网 HTTP(S) URL（拒绝 blob:/data: 等后端无法访问的 URL）
-    def _is_valid_public_url(u: str) -> bool:
-        return bool(u) and u.startswith(("http://", "https://"))
-
-    cover_url = ""
-    for candidate, source in [
-        ((body.cover_url or "").strip(), "body"),
-        ((job.output_cover_url or "").strip(), "job"),
-    ]:
-        if _is_valid_public_url(candidate):
-            cover_url = candidate
-            break
-        if candidate:
-            logger.warning(
-                "finalize 收到无效封面URL（非HTTP，跳过该来源）: job_id=%s source=%s url=%s",
-                job_id,
-                source,
-                candidate[:80],
-            )
-
-    # 兜底：body 和 job 都没有可用封面时，后端主动从成片抽一帧
-    if not cover_url:
-        try:
-            fallback_url = (generate_smart_cover(video_url, job_id=job_id, max_frames=5) or "").strip()
-        except Exception as exc:
-            logger.warning("finalize 兜底抽帧失败（不阻断入库）: job_id=%s err=%s", job_id, exc)
-            fallback_url = ""
-        if _is_valid_public_url(fallback_url):
-            cover_url = fallback_url
-            try:
-                job.cover_config = {
-                    **(job.cover_config if isinstance(job.cover_config, dict) else {}),
-                    "mode": "auto_frame",
-                    "url": cover_url,
-                }
-                job.output_cover_url = cover_url
-                db.commit()
-            except Exception as exc:
-                logger.warning("finalize 兜底封面写回DB失败（不阻断入库）: job_id=%s err=%s", job_id, exc)
-        elif fallback_url:
-            logger.warning(
-                "finalize 兜底抽帧返回了非HTTP URL（忽略）: job_id=%s url=%s", job_id, fallback_url[:80]
-            )
-
-    video_title = (body.video_title or "").strip() or None
-
     try:
-        video = svc.finalize_job(job_id, current_user.user.id, cover_url=cover_url or None, video_title=video_title)
+        video = svc.finalize_job(job_id, current_user.user.id)
         return FinalizeRenderResponse(
             video_id=video.id,
-            cover_url=video.thumbnail_url or cover_url or "",
+            cover_url=video.thumbnail_url or job.output_cover_url or "",
             status="success",
         )
     except AiAvatarRenderError as exc:

apps/api/app/api/routes/points.py

@@ -89,7 +89,6 @@ def get_balance(
         is_member=_is_member(current_user),
         member_type=_member_type(current_user),
         member_expires_at=getattr(current_user.user, "member_expires_at", None),
-        credits_enabled=_credits_enabled(),
     )
 
 

apps/api/app/api/routes/viral_video.py

@@ -2,10 +2,12 @@
 
 v1.6 三步分步流水线端点（单次 Seedance 出片版）：
   POST   /api/v1/viral-video/analyze-images          阶段1：创建任务 + 仅做图片/视频分析，暂停在 image_analyzed
-  POST   /api/v1/viral-video/{job_id}/generate-copy  阶段2：用户填完参数后文案+分镜一步生成+审核，暂停在 copy_generated
-  POST   /api/v1/viral-video/{job_id}/confirm-copy   阶段3：用户确认/编辑文案后跑渲染（TTS+Seedance+上传），直到完成
+  POST   /api/v1/viral-video/{job_id}/generate-copy  阶段2：用户填完参数后跑意图+文案+分镜+审核，暂停在 copy_generated
+  POST   /api/v1/viral-video/{job_id}/confirm-copy   阶段3：用户确认/编辑文案后跑渲染，直到完成
 
-意图分析已并入脚本生成一步完成，不再有独立的 intent_parsing 阶段或 wait_user_confirm 状态。
+旧端点（兼容保留，旧前端/一键生成模式）：
+  POST   /api/v1/viral-video/generate                一键入队，前半段跑到 wait_user_confirm
+  POST   /api/v1/viral-video/{job_id}/confirm-intent 旧的意图确认后继续渲染
 
 通用：
   GET    /api/v1/viral-video/{job_id}                查询任务状态（含 image_analysis/copy_result 编导脚本）
@@ -28,6 +30,8 @@ from app.schemas.viral_video import (
     AnalyzeStyleRequest,
     AnalyzeStyleResponse,
     ConfirmCopyRequest,
+    ConfirmIntentRequest,
+    CreateViralVideoRequest,
     CreditsFormulaBreakdown,
     EstimateCreditsRequest,
     EstimateCreditsResponse,
@@ -45,17 +49,7 @@ from packages.adapters.sqlalchemy_impl.viral_video_repository import (
     SQLAlchemyViralVideoJobRepository,
     SQLAlchemyViralVideoStyleTemplateRepository,
 )
-from packages.application.viral_video.constants import (
-    API_FALLBACK_HARD_CONSTRAINTS,
-    API_FALLBACK_NEGATIVE_PROMPTS,
-)
-from packages.domain.points_rules import (
-    calculate_viral_video_credits,
-    calculate_viral_video_credits_with_breakdown,
-    list_viral_video_models,
-    resolve_video_dimensions,
-)
-from packages.domain.points_service import PointsService
+from packages.domain.points_rules import list_viral_video_models
 from packages.domain.viral_video import ViralVideoStatus
 from packages.shared.dashscope_client import get_dashscope_client
 
@@ -71,7 +65,7 @@ def _build_copy_result(job) -> dict | None:
     """v1.6: 返回编导分镜脚本 CopyResult 结构（给前端/Seedance 使用）。
 
     - 若 job.copy_result 已持久化（v1.6 worker 生成），直接返回（补 final_copy 兜底）。
-    - 否则从老字段（generated_copy_text=口播, storyboard=分镜列表）拼装兼容结构。
+    - 否则从老字段（generated_copy_text=口播, storyboard=分镜列表, intent_result）拼装兼容结构。
     """
     cr = getattr(job, "copy_result", None)
     if isinstance(cr, dict) and cr:
@@ -85,9 +79,12 @@ def _build_copy_result(job) -> dict | None:
     # 兼容 v1.5 老数据：storyboard 是老格式 [{order,type,description,text,duration,...}]
     copy_text = getattr(job, "generated_copy_text", "") or ""
     sb = getattr(job, "storyboard", None) or []
+    intent = getattr(job, "intent_result", None) or {}
     if not copy_text and not sb:
         return None
     title = ""
+    if isinstance(intent, dict):
+        title = intent.get("suggested_title") or intent.get("intent", "") or ""
     shots = []
     for seg in sb:
         if isinstance(seg, dict):
@@ -108,8 +105,8 @@ def _build_copy_result(job) -> dict | None:
         "overview": {"theme": title, "total_duration": getattr(job, "duration", 15), "aspect_ratio": ratio},
         "scene_and_lighting": "",
         "shots": shots,
-        "hard_constraints": list(API_FALLBACK_HARD_CONSTRAINTS),
-        "negative_prompts": list(API_FALLBACK_NEGATIVE_PROMPTS),
+        "hard_constraints": ["无字幕", "无水印", "人物一致性"],
+        "negative_prompts": ["字幕", "水印", "错误文字", "五官崩坏"],
         "voiceover_script": copy_text,
         "final_copy": copy_text,
         "suggested_copy": copy_text,
@@ -127,7 +124,6 @@ def _to_response(job) -> ViralVideoJobResponse:
         persona_id=job.persona_id,
         viral_structure=job.viral_structure,
         marketing_purpose=job.marketing_purpose,
-        tone=getattr(job, "tone", "") or "",
         bgm_preference=job.bgm_preference,
         duration=job.duration or 15,
         user_copy_text=job.user_copy_text,
@@ -149,6 +145,7 @@ def _to_response(job) -> ViralVideoJobResponse:
         language=getattr(job, "language", "zh-CN") or "zh-CN",
         video_ratio=getattr(job, "video_ratio", "9:16") or "9:16",
         video_model=getattr(job, "video_model", "") or "",
+        intent_result=job.intent_result,
         result_video_url=job.result_video_url,
         pre_trusted_images=getattr(job, "pre_trusted_images", None) or None,
         video_resolution=getattr(job, "video_resolution", "720p") or "720p",
@@ -171,157 +168,58 @@ def _get_style_repo(session: Session) -> SQLAlchemyViralVideoStyleTemplateReposi
     return SQLAlchemyViralVideoStyleTemplateRepository(session)
 
 
-def _settle_viral_video_credits(
-    user_id: int,
-    job,
-    session: Session,
-    *,
-    action: str,
-    old_duration: int | None = None,
-    old_resolution: str | None = None,
-    old_ratio: str | None = None,
-    old_model: str | None = None,
-    new_duration: int | None = None,
-    new_resolution: str | None = None,
-    new_ratio: str | None = None,
-    new_model: str | None = None,
-) -> dict:
-    """爆款视频积分结算统一入口（confirm-copy / retry 共用）。
+# ── Endpoints ────────────────────────────────────────────────────────────
 
-    action 取值：
-    - "deduct_first"   首次扣费（confirm 时还没付过）
-    - "recompute"      参数变更重算：退旧扣新（confirm_copy 时传 old/new）
-    - "delta"          参数变更差额结算：多退少补（retry 时传 old/new）
-    返回 credits_info dict，包含 old_est / new_est / action / diff 等。
-    积分不足时 raise HTTPException(402)，调用方无需再捕获。
-    """
-    from app.config import settings as _settings
 
-    info: dict = {"action": action, "old_est": 0.0, "new_est": 0.0, "diff": 0.0, "settled": False}
-    if not _settings.points_enabled:
-        return info
+@router.post("/generate", response_model=ViralVideoJobResponse)
+def create_viral_video(
+    request: CreateViralVideoRequest,
+    authenticated_user: AuthenticatedUser = Depends(get_current_user),
+    session: Session = Depends(get_db_session),
+) -> ViralVideoJobResponse:
+    """创建爆款视频任务，入队 Celery 编排器。"""
+    from packages.domain.viral_video import ViralVideoJob
 
-    already_paid = (float(getattr(job, "credits_prepaid", 0) or 0) > 0) or (
-        float(getattr(job, "credits_cost", 0) or 0) > 0
+    repo = _get_job_repo(session)
+
+    # 创建领域实体
+    job = ViralVideoJob(
+        user_id=authenticated_user.user.id,
+        images=list(request.images),
+        industry=request.industry,
+        target_customer=request.target_customer,
+        persona_id=request.persona_id,
+        viral_structure=request.viral_structure,
+        marketing_purpose=request.marketing_purpose,
+        bgm_preference=request.bgm_preference,
+        duration=request.duration or 15,
+        user_copy_text=request.user_copy_text,
+        fusion_level=request.fusion_level,
+        reference_audio_path=request.reference_audio_path,
+        reference_video_url=request.reference_video_url,
+        style_strength=request.style_strength,
+        style_template_id=request.style_template_id,
+        voice_id=getattr(request, "voice_id", "") or "",
+        voice_source=getattr(request, "voice_source", "") or "",
+        video_ratio=getattr(request, "video_ratio", "9:16") or "9:16",
+        video_model=getattr(request, "video_model", "") or "",
+        video_resolution=getattr(request, "video_resolution", "720p") or "720p",
+        copy_result=None,
     )
 
-    if action == "deduct_first":
-        if already_paid:
-            return info
-        w, h = resolve_video_dimensions(
-            getattr(job, "video_resolution", "720p") or "720p", job.video_ratio or "9:16"
-        )
-        est = calculate_viral_video_credits(int(job.duration or 15), w, h, job.video_model or "seedance-2.5")
-        info["new_est"] = est
-        svc = PointsService()
-        res = svc.deduct_viral_video(user_id, est, job.id, session)
-        if not res.get("success"):
-            balance = res.get("balance", 0)
-            raise HTTPException(
-                status_code=402,
-                detail={
-                    "code": "INSUFFICIENT_POINTS",
-                    "message": f"积分不足，需要 {est} 积分，当前余额 {balance}",
-                    "required": est,
-                    "balance": balance,
-                },
-            )
-        job.credits_prepaid = est
-        job.credits_transaction_id = res.get("transaction_id", "") or ""
-        info["settled"] = True
-        info["diff"] = est
-        return info
+    # 持久化
+    repo.save(job)
 
-    if action == "recompute":
-        if not already_paid:
-            # 等价于首次扣费
-            return _settle_viral_video_credits(user_id, job, session, action="deduct_first")
-        old_w, old_h = resolve_video_dimensions(old_resolution or "720p", old_ratio or "9:16")
-        old_est = calculate_viral_video_credits(
-            int(old_duration or 15), old_w, old_h, old_model or "seedance-2.5"
-        )
-        new_w, new_h = resolve_video_dimensions(
-            getattr(job, "video_resolution", "720p") or "720p", job.video_ratio or "9:16"
-        )
-        new_est = calculate_viral_video_credits(
-            int(job.duration or 15), new_w, new_h, job.video_model or "seedance-2.5"
-        )
-        info.update({"old_est": old_est, "new_est": new_est, "diff": new_est - old_est})
-        svc = PointsService()
-        if getattr(job, "credits_transaction_id", None):
-            svc.refund_points(
-                user_id=user_id,
-                amount=float(job.credits_prepaid),
-                source="viral_video",
-                db=session,
-                ref_id=job.credits_transaction_id,
-                description="confirm-copy 参数变更退还旧预扣",
-            )
-        if new_est > 0:
-            res = svc.deduct_viral_video(user_id, new_est, job.id, session)
-            if not res.get("success"):
-                balance = res.get("balance", 0)
-                raise HTTPException(
-                    status_code=402,
-                    detail={
-                        "code": "INSUFFICIENT_POINTS",
-                        "message": f"积分不足，需要 {new_est} 积分，当前余额 {balance}",
-                        "required": new_est,
-                        "balance": balance,
-                    },
-                )
-            job.credits_prepaid = new_est
-            job.credits_transaction_id = res.get("transaction_id", "") or ""
-        info["settled"] = True
-        return info
+    # 入队 Celery 任务
+    try:
+        celery_app.send_task("worker.run_viral_video_pipeline", args=[job.id])
+        logger.info("[爆款视频] 任务已入队: job_id=%s user_id=%s", job.id, job.user_id)
+    except Exception as e:
+        logger.error("[爆款视频] 入队失败: %s", e, exc_info=True)
+        job.mark_failed(f"任务入队失败: {e}")
+        repo.update(job)
 
-    if action == "delta":
-        eff_dur = int(new_duration if new_duration is not None else old_duration or 15)
-        eff_res = new_resolution if new_resolution is not None else (old_resolution or "720p")
-        eff_ratio = new_ratio if new_ratio is not None else (old_ratio or "9:16")
-        eff_model = new_model if new_model is not None else (old_model or "seedance-2.5")
-        w, h = resolve_video_dimensions(eff_res, eff_ratio)
-        new_est, _ = calculate_viral_video_credits_with_breakdown(eff_dur, w, h, eff_model)
-        old_prepaid = float(getattr(job, "credits_prepaid", 0) or 0)
-        diff = round(new_est - old_prepaid, 2)
-        info.update({"old_est": old_prepaid, "new_est": new_est, "diff": diff})
-        if abs(diff) < 0.01:
-            return info
-        svc = PointsService()
-        if diff > 0:
-            res = svc.deduct_viral_video(user_id, diff, job.id, session)
-            if not res.get("success"):
-                balance = res.get("balance", 0)
-                raise HTTPException(
-                    status_code=402,
-                    detail={
-                        "code": "INSUFFICIENT_POINTS",
-                        "message": f"重试参数变更后需补扣 {diff} 积分，余额不足（当前 {balance}，需 {new_est}）",
-                        "required": new_est,
-                        "balance": balance,
-                        "delta": diff,
-                    },
-                )
-            job.credits_prepaid = round(old_prepaid + diff, 2)
-        else:
-            refund = round(-diff, 2)
-            txn_id = getattr(job, "credits_transaction_id", "") or ""
-            svc.refund_points(
-                user_id=user_id,
-                amount=refund,
-                source="viral_video",
-                db=session,
-                ref_id=txn_id or job.id,
-                description="爆款视频重试参数变更退费",
-            )
-            job.credits_prepaid = round(old_prepaid - refund, 2)
-        info["settled"] = True
-        return info
-
-    raise ValueError(f"unknown action: {action}")
-
-
-# ── Endpoints ────────────────────────────────────────────────────────────
+    return _to_response(job)
 
 
 @router.post("/analyze-images", response_model=ViralVideoJobResponse)
@@ -405,7 +303,6 @@ def generate_copy(
     job.persona_id = request.persona_id or job.persona_id
     job.viral_structure = request.viral_structure or job.viral_structure
     job.marketing_purpose = request.marketing_purpose or job.marketing_purpose
-    job.tone = getattr(request, "tone", "") or job.tone
     job.bgm_preference = request.bgm_preference or job.bgm_preference
     if request.duration:
         job.duration = max(5, min(30, int(request.duration)))
@@ -486,27 +383,84 @@ def confirm_copy(
         or (request.video_model is not None and request.video_model != old_model)
     )
 
-    # 积分预扣（PR2：统一走 _settle_viral_video_credits）
-    if param_changed:
-        credits_info = _settle_viral_video_credits(
-            authenticated_user.user.id,
-            job,
-            session,
-            action="recompute",
-            old_duration=old_duration,
-            old_resolution=old_resolution,
-            old_ratio=old_ratio,
-            old_model=old_model,
+    # 积分预扣（已扣过/重试任务跳过）
+    from app.config import settings as _settings
+
+    if _settings.points_enabled:
+        already_paid = (float(getattr(job, "credits_prepaid", 0) or 0) > 0) or (
+            float(getattr(job, "credits_cost", 0) or 0) > 0
         )
-        logger.info(
-            "[爆款视频][confirm-copy] 参数变更，积分重算: old=%s new=%s job_id=%s",
-            credits_info.get("old_est"),
-            credits_info.get("new_est"),
-            job.id,
-        )
-    else:
-        _settle_viral_video_credits(authenticated_user.user.id, job, session, action="deduct_first")
-        repo.update(job)
+        if param_changed and already_paid:
+            # 参数变更：回退旧预扣，按新参数重新预扣
+            from packages.domain.points_rules import calculate_viral_video_credits, resolve_video_dimensions
+            from packages.domain.points_service import PointsService
+
+            old_w, old_h = resolve_video_dimensions(old_resolution, old_ratio)
+            old_est = calculate_viral_video_credits(old_duration, old_w, old_h, old_model)
+            new_w, new_h = resolve_video_dimensions(
+                getattr(job, "video_resolution", "720p") or "720p",
+                job.video_ratio or "9:16",
+            )
+            new_est = calculate_viral_video_credits(
+                int(job.duration or 15), new_w, new_h, job.video_model or "seedance-2.5"
+            )
+            svc = PointsService()
+            # 退回旧预扣
+            if getattr(job, "credits_transaction_id", None):
+                svc.refund_points(
+                    user_id=authenticated_user.user.id,
+                    amount=float(job.credits_prepaid),
+                    source="viral_video",
+                    db=session,
+                    ref_id=job.credits_transaction_id,
+                    description="confirm-copy 参数变更退还旧预扣",
+                )
+            # 预扣新金额
+            if new_est > 0:
+                res = svc.deduct_viral_video(authenticated_user.user.id, new_est, job.id, session)
+                if not res.get("success"):
+                    balance = res.get("balance", 0)
+                    raise HTTPException(
+                        status_code=402,
+                        detail={
+                            "code": "INSUFFICIENT_POINTS",
+                            "message": f"积分不足，需要 {new_est} 积分，当前余额 {balance}",
+                            "required": new_est,
+                            "balance": balance,
+                        },
+                    )
+                job.credits_prepaid = new_est
+                job.credits_transaction_id = res.get("transaction_id", "") or ""
+            logger.info(
+                "[爆款视频][confirm-copy] 参数变更，积分重算: old=%d new=%d job_id=%s", old_est, new_est, job.id
+            )
+        elif not already_paid:
+            from packages.domain.points_rules import calculate_viral_video_credits, resolve_video_dimensions
+            from packages.domain.points_service import PointsService
+
+            w, h = resolve_video_dimensions(
+                getattr(job, "video_resolution", "720p") or "720p",
+                job.video_ratio or "9:16",
+            )
+            est_credits = calculate_viral_video_credits(
+                int(job.duration or 15), w, h, job.video_model or "seedance-2.5"
+            )
+            svc = PointsService()
+            res = svc.deduct_viral_video(authenticated_user.user.id, est_credits, job.id, session)
+            if not res.get("success"):
+                balance = res.get("balance", 0)
+                raise HTTPException(
+                    status_code=402,
+                    detail={
+                        "code": "INSUFFICIENT_POINTS",
+                        "message": f"积分不足，需要 {est_credits} 积分，当前余额 {balance}",
+                        "required": est_credits,
+                        "balance": balance,
+                    },
+                )
+            job.credits_prepaid = est_credits
+            job.credits_transaction_id = res.get("transaction_id", "") or ""
+            repo.update(job)
 
     job.resume_from_copy_generated(edited_copy=request.edited_copy or None)
     repo.update(job)
@@ -516,7 +470,6 @@ def confirm_copy(
         logger.info("[爆款视频][阶段3] confirm-copy 入队: job_id=%s", job.id)
     except Exception as e:
         logger.error("[爆款视频][阶段3] confirm-copy 入队失败: %s", e, exc_info=True)
-        # TODO(PR2-followup): 入队失败应返回 HTTP 503 而非 mark_failed + 200，避免前端收到"成功"但 job 已 failed 的不一致状态
         job.mark_failed(f"任务入队失败: {e}")
         repo.update(job)
 
@@ -534,6 +487,11 @@ def estimate_credits(
     profit_multiplier / model_price / width / height / fps），便于前端展示计费明细。
     同时兼容前端传 model 或 video_model、resolution 或 video_resolution、ratio 或 video_ratio。
     """
+    from packages.domain.points_rules import (
+        calculate_viral_video_credits_with_breakdown,
+        resolve_video_dimensions,
+    )
+
     model = (request.model or "").strip() or "seedance-2.5"
     resolution = (request.resolution or "").strip() or "720p"
     ratio = (request.ratio or "").strip() or "9:16"
@@ -665,7 +623,25 @@ def retry_viral_video_job(
         or (new_model is not None and new_model != old_model)
     )
 
-    # 写入新参数（即使不开 points 也要允许用户重试时改参数；delta 结算依赖这些新值）
+    from app.config import settings as _settings
+
+    need_points_settle = False
+    new_est = 0.0
+    if _settings.points_enabled and param_changed:
+        from packages.domain.points_rules import (
+            calculate_viral_video_credits_with_breakdown,
+            resolve_video_dimensions,
+        )
+
+        eff_dur = int(new_duration if new_duration is not None else old_duration)
+        eff_res = new_resolution if new_resolution is not None else old_resolution
+        eff_ratio = new_ratio if new_ratio is not None else old_ratio
+        eff_model = new_model if new_model is not None else (old_model or "seedance-2.5")
+        w, h = resolve_video_dimensions(eff_res, eff_ratio)
+        new_est, _ = calculate_viral_video_credits_with_breakdown(eff_dur, w, h, eff_model or "seedance-2.5")
+        need_points_settle = True
+
+    # 写入新参数（即使不开 points 也要允许用户重试时改参数）
     if new_duration is not None:
         job.duration = max(5, min(30, int(new_duration)))
     if new_resolution is not None:
@@ -675,31 +651,57 @@ def retry_viral_video_job(
     if new_model is not None:
         job.video_model = new_model
 
-    # PR2：统一走 _settle_viral_video_credits（delta 多退少补）
-    if param_changed:
-        credits_info = _settle_viral_video_credits(
-            authenticated_user.user.id,
-            job,
-            session,
-            action="delta",
-            old_duration=old_duration,
-            old_resolution=old_resolution,
-            old_ratio=old_ratio,
-            old_model=old_model,
-            new_duration=new_duration,
-            new_resolution=new_resolution,
-            new_ratio=new_ratio,
-            new_model=new_model,
-        )
-        if credits_info.get("settled"):
-            logger.info(
-                "[爆款视频][retry] 积分差额结算 job_id=%s diff=%.2f new_prepaid=%.2f",
-                job.id,
-                credits_info["diff"],
-                job.credits_prepaid,
-            )
+    if need_points_settle:
+        from packages.domain.points_service import PointsService
 
-    # 重置状态（从阶段1重新开始，清空上一次产物避免脏数据）
+        old_prepaid = float(getattr(job, "credits_prepaid", 0) or 0)
+        svc = PointsService()
+        diff = round(new_est - old_prepaid, 2)
+        if abs(diff) >= 0.01:
+            if diff > 0:
+                # 新预扣更多：补扣差额
+                res = svc.deduct_viral_video(authenticated_user.user.id, diff, job.id, session)
+                if not res.get("success"):
+                    balance = res.get("balance", 0)
+                    raise HTTPException(
+                        status_code=402,
+                        detail={
+                            "code": "INSUFFICIENT_POINTS",
+                            "message": f"重试参数变更后需补扣 {diff} 积分，余额不足（当前 {balance}，需 {new_est}）",
+                            "required": new_est,
+                            "balance": balance,
+                            "delta": diff,
+                        },
+                    )
+                job.credits_prepaid = round(old_prepaid + diff, 2)
+                logger.info(
+                    "[爆款视频][retry] 补扣差额 job_id=%s diff=%.2f new_prepaid=%.2f",
+                    job.id,
+                    diff,
+                    job.credits_prepaid,
+                )
+            else:
+                # 新预扣更少：退还差额
+                refund = round(-diff, 2)
+                txn_id = getattr(job, "credits_transaction_id", "") or ""
+                svc.refund_points(
+                    user_id=authenticated_user.user.id,
+                    amount=refund,
+                    source="viral_video",
+                    db=session,
+                    ref_id=txn_id or job.id,
+                    description="爆款视频重试参数变更退费",
+                )
+                job.credits_prepaid = round(old_prepaid - refund, 2)
+                logger.info(
+                    "[爆款视频][retry] 退还差额 job_id=%s refund=%.2f new_prepaid=%.2f",
+                    job.id,
+                    refund,
+                    job.credits_prepaid,
+                )
+        # 差额为 0 则不调整
+
+    # 重置状态
     job.retry_count += 1
     job.status = ViralVideoStatus.PENDING
     job.error_msg = "" if not is_stale_running else "任务执行超时，已重置重试"
@@ -708,18 +710,11 @@ def retry_viral_video_job(
     job.current_stage = ""
     job.phase_message = ""
     job.heartbeat_at = None
-    # 重试时清空上次产物（参考 resume_from_image_analyzed 逻辑）
-    job.copy_result = None
-    job.storyboard = None
-    job.generated_copy_text = ""
-    job.result_video_url = ""
-    job.pre_trusted_images = None
-    job.credits_cost = 0.0
     repo.update(job)
 
-    # 重新入队：从图片分析阶段1重新跑
+    # 重新入队
     try:
-        celery_app.send_task("worker.run_viral_video_analyze", args=[job.id])
+        celery_app.send_task("worker.run_viral_video_pipeline", args=[job.id])
         logger.info(
             "[爆款视频] 重试入队: job_id=%s retry_count=%d stale=%s params_changed=%s",
             job.id,
@@ -729,13 +724,49 @@ def retry_viral_video_job(
         )
     except Exception as e:
         logger.error("[爆款视频] 重试入队失败: %s", e, exc_info=True)
-        # TODO(PR2-followup): 入队失败应返回 HTTP 503 而非 mark_failed + 200
         job.mark_failed(f"重试入队失败: {e}")
         repo.update(job)
 
     return _to_response(job)
 
 
+@router.post("/{job_id}/confirm-intent", response_model=ViralVideoJobResponse)
+def confirm_intent(
+    job_id: str,
+    request: ConfirmIntentRequest,
+    authenticated_user: AuthenticatedUser = Depends(get_current_user),
+    session: Session = Depends(get_db_session),
+) -> ViralVideoJobResponse:
+    """用户确认/修改 AI 生成的意图文案，恢复流水线。"""
+    repo = _get_job_repo(session)
+    job = repo.get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    if job.user_id != authenticated_user.user.id:
+        raise HTTPException(status_code=403, detail="无权操作此任务")
+    if job.status != ViralVideoStatus.WAIT_USER_CONFIRM:
+        raise HTTPException(status_code=409, detail="任务当前不在等待确认状态")
+
+    # 更新文案
+    if request.confirmed_copy:
+        job.user_copy_text = request.confirmed_copy
+
+    # 恢复流水线
+    job.resume_from_confirm()
+    repo.update(job)
+
+    # 从断点恢复 Celery 任务
+    try:
+        celery_app.send_task("worker.resume_viral_video_pipeline", args=[job.id])
+        logger.info("[爆款视频] 意图确认，恢复流水线: job_id=%s", job.id)
+    except Exception as e:
+        logger.error("[爆款视频] 恢复流水线失败: %s", e, exc_info=True)
+        job.mark_failed(f"恢复流水线失败: {e}")
+        repo.update(job)
+
+    return _to_response(job)
+
+
 @router.post("/{job_id}/analyze-style", response_model=AnalyzeStyleResponse)
 def analyze_style(
     job_id: str,
@@ -1002,6 +1033,7 @@ _STATUS_STAGE = {
     "running": "",
     "image_analyzed": "image_analysis",
     "copy_generated": "review",
+    "wait_user_confirm": "intent_parsing",
     "completed": "uploading",
     "failed": "",
     "cancelled": "",
@@ -1012,6 +1044,7 @@ _STATUS_PROGRESS = {
     "running": 5.0,
     "image_analyzed": 15.0,
     "copy_generated": 70.0,
+    "wait_user_confirm": 35.0,
     "completed": 100.0,
     "failed": 0.0,
     "cancelled": 0.0,
@@ -1022,6 +1055,7 @@ _STATUS_MESSAGE = {
     "running": "任务执行中",
     "image_analyzed": "图片分析完成，等待填写营销参数",
     "copy_generated": "文案与分镜已生成，等待确认文案",
+    "wait_user_confirm": "等待用户确认意图文案",
     "completed": "视频生成完成",
     "failed": "任务失败",
     "cancelled": "任务已取消",

apps/api/app/schemas/ai_avatar_render.py

@@ -124,15 +124,6 @@ class SmartCoverResponse(BaseModel):
     message: str = Field("", description="失败原因（如有）")
 
 
-class FinalizeRenderRequest(BaseModel):
-    """finalize 入库请求体（所有字段可选，缺省时用渲染任务自身状态）."""
-
-    cover_url: Optional[str] = Field(
-        None, description="用户选定的封面公网 URL（必须是 OSS/HTTP(S) 公网地址，blob:/data: URL 无效）"
-    )
-    video_title: Optional[str] = Field(None, description="成片库展示标题；为空时用默认 AI数字人_{job_id[:8]}")
-
-
 class FinalizeRenderResponse(BaseModel):
     """封面选好后点「完成」，正式入库成片库的响应."""
 

apps/api/app/schemas/points.py

@@ -19,7 +19,6 @@ class PointsBalanceResponse(BaseModel):
     is_member: bool = Field(default=False, description="是否付费会员")
     member_type: Optional[str] = Field(None, description="会员类型: monthly/quarterly/yearly")
     member_expires_at: Optional[datetime] = Field(None, description="会员到期时间")
-    credits_enabled: bool = Field(default=False, description="积分系统是否启用（false=免费放行不扣分）")
 
 
 # ============ 流水 ============

apps/api/app/schemas/viral_video.py

@@ -13,6 +13,7 @@ VALID_STYLE_STRENGTHS = ("light", "medium", "strict")
 VALID_STAGES = (
     "image_analysis",
     "video_analysis",
+    "intent_parsing",
     "script_generation",
     "review",
     "tts",
@@ -36,7 +37,6 @@ class ShotScript(BaseModel):
     action_details: str = Field(default="", description="人物动作、表情、物品操作细节")
     audio_bgm: str = Field(default="", description="环境音+BGM提示")
     transition: str = Field(default="硬切", description="转场方式：硬切/淡入淡出/叠化")
-    voiceover: str = Field(default="", description="该镜头口播台词（纯对白，不含画面描述）")
     reference_image_index: int | None = Field(
         default=None, description="参考图片索引（0-based，对应上传的第几张产品图）"
     )
@@ -68,6 +68,47 @@ class CopyResult(BaseModel):
 # -- Request Schemas --
 
 
+class CreateViralVideoRequest(BaseModel):
+    """旧接口：一键创建（保留兼容）。"""
+
+    images: list[str] = Field(..., min_length=1, max_length=20)
+    industry: str = ""
+    target_customer: str = ""
+    persona_id: str = ""
+    viral_structure: str = ""
+    marketing_purpose: str = ""
+    bgm_preference: str = ""
+    duration: int = Field(default=15, ge=5, le=30, description="视频时长（秒），5-30")
+    user_copy_text: str = ""
+    fusion_level: str = "ai_polish"
+    reference_audio_path: str = ""
+    reference_video_url: str = ""
+    style_strength: str = "medium"
+    style_template_id: str = ""
+    voice_id: str = ""
+    voice_source: str = ""
+    language: str = "zh-CN"
+    video_ratio: str = "9:16"
+    video_model: str = ""
+    video_resolution: str = "720p"
+
+    @field_validator("fusion_level")
+    @classmethod
+    def _v_fl(cls, v: str) -> str:
+        if v == "full_ai":
+            return "ai_full"
+        if v not in VALID_FUSION_LEVELS:
+            raise ValueError(f"fusion_level must be one of {VALID_FUSION_LEVELS}")
+        return v
+
+    @field_validator("style_strength")
+    @classmethod
+    def _v_ss(cls, v: str) -> str:
+        if v not in VALID_STYLE_STRENGTHS:
+            raise ValueError(f"style_strength must be one of {VALID_STYLE_STRENGTHS}")
+        return v
+
+
 class AnalyzeImagesRequest(BaseModel):
     """v1.5+ 阶段1：创建任务 + 图片/视频分析。"""
 
@@ -92,7 +133,6 @@ class GenerateCopyRequest(BaseModel):
     persona_id: str = ""
     viral_structure: str = ""
     marketing_purpose: str = ""
-    tone: str = ""
     bgm_preference: str = ""
     duration: int = Field(default=15, ge=5, le=30)
     user_copy_text: str = ""
@@ -139,6 +179,13 @@ class ConfirmCopyRequest(BaseModel):
     language: str | None = Field(default=None, description="用户选定的语言（confirm时可选）")
 
 
+class ConfirmIntentRequest(BaseModel):
+    """旧 confirm-intent（兼容）。"""
+
+    confirmed_copy: str = ""
+    adjustments: str = ""
+
+
 class AnalyzeStyleRequest(BaseModel):
     reference_video_url: str = Field(..., description="参考视频 URL")
     style_template_id: str = ""
@@ -158,7 +205,6 @@ class ViralVideoJobResponse(BaseModel):
     persona_id: str = ""
     viral_structure: str = ""
     marketing_purpose: str = ""
-    tone: str = ""
     bgm_preference: str = ""
     duration: int = 15
     user_copy_text: str = ""
@@ -185,6 +231,7 @@ class ViralVideoJobResponse(BaseModel):
     language: str = "zh-CN"
     video_ratio: str = "9:16"
     video_model: str = ""
+    intent_result: dict | None = None
     result_video_url: str = ""
     pre_trusted_images: list[str] | None = None
     video_resolution: str = "720p"

apps/api/app/services/ai_avatar_render_service.py

@@ -420,25 +420,19 @@ class AiAvatarRenderService:
             logger.exception("渲染任务异常 [%s]", job_id)
             raise
 
-    def _persist_to_library(
-        self,
-        job: AiAvatarRenderJob,
-        cover_url: Optional[str] = None,
-        video_title: Optional[str] = None,
-    ):
+    def _persist_to_library(self, job: AiAvatarRenderJob, cover_url: Optional[str] = None):
         """将渲染结果写入成片库，返回 GeneratedVideo 领域对象.
 
         Args:
             job: 渲染任务（必须 status=completed 且 output_video_url 非空）
             cover_url: 可选的封面 URL 覆盖（finalize 时传入即优先使用，否则取 job.output_cover_url）
-            video_title: 可选的成片标题覆盖；为空用默认 AI数字人_{job.id[:8]}
         """
         from packages.adapters.sqlalchemy_impl.generated_video_repository import (
             SQLAlchemyGeneratedVideoRepository,
         )
         from packages.domain.generated_video import GeneratedVideo
 
-        clip_name = (video_title or "").strip() or f"AI数字人_{job.id[:8]}"
+        clip_name = f"AI数字人_{job.id[:8]}"
         # AI数字人入口是独立页面，前端可能不传 project_id（无项目概念），
         # 兜底为 "ai_avatar" 避免 DB 非空约束/查询问题；generation_task_id 用 render_job_id 便于反查。
         clip_project_id = (job.project_id or "").strip() or "ai_avatar"
@@ -462,18 +456,11 @@ class AiAvatarRenderService:
         logger.info("[数字人渲染] 成片已入库: clip_id=%s render_job=%s", clip.id, job.id)
         return clip
 
-    def finalize_job(
-        self,
-        job_id: str,
-        user_id: str,
-        cover_url: Optional[str] = None,
-        video_title: Optional[str] = None,
-    ):
+    def finalize_job(self, job_id: str, user_id: str, cover_url: Optional[str] = None):
         """用户在前端点「完成」后调用：将已 completed 的渲染任务正式入库到成片库.
 
         - 必须 status=completed 才可调用
         - cover_url 若传入则优先使用并回写 job.output_cover_url；否则使用 job.output_cover_url（smart-cover/custom-cover 已写入）
-        - video_title 若传入则作为成片库展示标题；否则使用默认 AI数字人_{job_id[:8]}
         - 幂等：已入库则返回已存在的 GeneratedVideo
         """
         from packages.adapters.sqlalchemy_impl.generated_video_repository import (
@@ -512,7 +499,7 @@ class AiAvatarRenderService:
             job.updated_at = datetime.now(UTC)
             self.db.commit()
 
-        return self._persist_to_library(job, cover_url=cover_url, video_title=video_title)
+        return self._persist_to_library(job, cover_url=cover_url)
 
     def _download_video(self, url: str) -> str:
         """下载视频到临时文件."""

apps/api/app/tasks/lipsync_ditto.py

@@ -2,25 +2,19 @@
 
 把 Ditto 同步 HTTP 调用（30-120s）从 API 请求移到 Celery 后台执行：
 1. 加载 LipsyncJob
-2. 确定驱动视频：用户上传的 video_url 优先，无则用 settings.ditto_default_video_url 兜底
-3. 视频时长对齐：若视频 < 音频+2s，用 ffmpeg 循环视频到足够长度后上传临时文件
-4. 调 DittoClient.generate_and_persist
-5. 成功：标记 completed，写入 output_video_url（Ditto 输出自带音频，无需二次混流/超分）
-6. 失败：回退 GPU MuseTalk → 再失败回退 MediaKit
+2. 调 DittoClient.generate_and_persist(video_url=默认模板, audio_url=job.audio_url, script=job.script_text)
+3. 成功：标记 completed，写入 output_video_url（Ditto 输出自带音频，无需二次混流/超分）
+4. 失败：回退 GPU MuseTalk → 再失败回退 MediaKit
 
 注意：
 - 保留 MuseTalk 代码不动；Ditto 优先，失败按原链路兜底
-- Ditto 默认使用用户上传的视频作为驱动模板，default_video_url 仅作兜底
-- 用户视频短于音频时，ffmpeg stream_loop 循环到音频时长+2s余量
-- 不传 GFPGAN 超分，不需要 ffmpeg 音视频混流（Ditto 输出已带音视频）
+- Ditto 使用预置的人物模板视频（settings.ditto_default_video_url），不用用户上传的 video_url
+- 不传 GFPGAN 超分，不需要 ffmpeg 音视频混流
 """
 
 from __future__ import annotations
 
 import logging
-import os
-import subprocess
-import tempfile
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Optional
 
@@ -33,8 +27,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 _DITTO_URL_TTL_SECONDS = 7 * 24 * 3600  # Ditto 结果 OSS URL 7 天有效
-_VIDEO_LOOP_MARGIN_SECONDS = 2.0  # 循环视频时比音频多留 2 秒余量
-_MAX_VIDEO_PREPROCESS_SIZE = 200 * 1024 * 1024  # 用户视频最大 200MB
 
 
 def _get_db_session() -> Session:
@@ -67,215 +59,37 @@ def _sign_media_url(url: str) -> str:
         return url
 
 
-def _probe_media_duration(path_or_bytes, *, is_bytes: bool = False) -> float:
-    """用 ffprobe 探测视频/音频时长（秒）；失败返回 0。
-
-    Args:
-        path_or_bytes: 文件路径(str) 或 字节数据(bytes)
-        is_bytes: 传入的是 bytes 还是文件路径
-    """
-    tmp_path = None
+def _probe_video_duration(video_bytes: bytes) -> float:
+    """用 ffprobe 探测视频时长（秒）；失败返回 0。"""
     try:
-        if is_bytes:
-            with tempfile.NamedTemporaryFile(suffix=".bin", delete=False) as tmp:
-                tmp.write(path_or_bytes)
-                tmp_path = tmp.name
-            target = tmp_path
-        else:
-            target = path_or_bytes
-        out = subprocess.check_output(
-            [
-                "ffprobe",
-                "-v",
-                "error",
-                "-show_entries",
-                "format=duration",
-                "-of",
-                "default=noprint_wrappers=1:nokey=1",
-                target,
-            ],
-            stderr=subprocess.STDOUT,
-            timeout=15,
-        )
-        return float(out.decode().strip() or 0)
+        import os
+        import subprocess
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
+            tmp.write(video_bytes)
+            tmp_path = tmp.name
+        try:
+            out = subprocess.check_output(
+                [
+                    "ffprobe",
+                    "-v",
+                    "error",
+                    "-show_entries",
+                    "format=duration",
+                    "-of",
+                    "default=noprint_wrappers=1:nokey=1",
+                    tmp_path,
+                ],
+                stderr=subprocess.STDOUT,
+                timeout=10,
+            )
+            return float(out.decode().strip() or 0)
+        finally:
+            os.unlink(tmp_path)
     except Exception as exc:
         logger.warning("[ditto_task] ffprobe 失败: %s", exc)
         return 0.0
-    finally:
-        if tmp_path and os.path.exists(tmp_path):
-            try:
-                os.unlink(tmp_path)
-            except Exception:
-                pass
-
-
-def _probe_video_duration(video_bytes: bytes) -> float:
-    """用 ffprobe 探测视频时长（秒）；失败返回 0。"""
-    return _probe_media_duration(video_bytes, is_bytes=True)
-
-
-def _prepare_driver_video(
-    *,
-    user_video_url: str,
-    default_video_url: str,
-    audio_duration: float,
-    job_id: str,
-    user_id: str,
-) -> tuple[str, bool]:
-    """准备传给 Ditto 的驱动视频 URL。
-
-    逻辑：
-    1. 优先使用用户上传的视频（user_video_url），无则用 default_video_url 兜底
-    2. 下载视频，探测时长
-    3. 若视频时长 >= 音频时长+2s 余量：直接用原 URL（签名后）
-    4. 若视频时长 < 音频时长+2s：ffmpeg stream_loop 循环到目标时长，上传临时 OSS，返回临时 URL
-    5. 任何异常：回退到 default_video_url（兜底）
-
-    Returns:
-        (video_url_for_ditto, is_temporary) — is_temporary=True 表示 URL 是本次临时生成的
-    """
-    from packages.shared.storage import get_shared_storage_service
-    from packages.shared.url_security import safe_download_bytes
-
-    storage = get_shared_storage_service()
-
-    # 1. 选择源 URL（用户视频优先）
-    source_url = user_video_url or default_video_url
-    source_label = "user" if user_video_url else "default"
-    if not source_url:
-        raise RuntimeError("无可用驱动视频（用户视频和默认模板都为空）")
-
-    # 2. 下载视频
-    try:
-        # 用户视频需要签名才能下载
-        signed_source = _sign_media_url(source_url) if user_video_url else source_url
-        video_bytes = safe_download_bytes(
-            signed_source,
-            purpose="ditto-driver-video",
-            max_size=_MAX_VIDEO_PREPROCESS_SIZE,
-            allowed_mime_types=("video/mp4", "video/quicktime", "video/x-msvideo", "video/webm"),
-            timeout=60,
-        )
-    except Exception as dl_exc:
-        logger.warning(
-            "[ditto_task] 下载驱动视频失败（%s），回退默认模板: job=%s err=%s",
-            source_label,
-            job_id,
-            dl_exc,
-        )
-        if user_video_url and default_video_url:
-            return default_video_url, False
-        raise
-
-    # 3. 探测视频时长
-    video_duration = _probe_media_duration(video_bytes, is_bytes=True)
-    target_duration = audio_duration + _VIDEO_LOOP_MARGIN_SECONDS
-
-    # 4. 视频足够长：直接用签名后的原 URL
-    if video_duration >= target_duration:
-        logger.info(
-            "[ditto_task] 驱动视频足够长（%.2fs >= %.2fs），直接使用: job=%s source=%s",
-            video_duration,
-            target_duration,
-            job_id,
-            source_label,
-        )
-        return _sign_media_url(source_url) if user_video_url else source_url, False
-
-    # 5. 视频不够长：ffmpeg 循环到目标时长
-    logger.info(
-        "[ditto_task] 驱动视频不够长（%.2fs < %.2fs），ffmpeg 循环延长: job=%s",
-        video_duration,
-        target_duration,
-        job_id,
-    )
-    looped_path = None
-    try:
-        # 写临时文件
-        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as src_tmp:
-            src_tmp.write(video_bytes)
-            src_path = src_tmp.name
-        looped_fd, looped_path = tempfile.mkstemp(suffix=".mp4")
-        os.close(looped_fd)
-
-        # ffmpeg: stream_loop -1 循环输入，-t 截到目标时长
-        # 使用 -c copy 快速复制流（不重编码），速度快无画质损失
-        cmd = [
-            "ffmpeg",
-            "-y",
-            "-stream_loop",
-            "-1",
-            "-i",
-            src_path,
-            "-t",
-            str(target_duration),
-            "-c",
-            "copy",
-            "-movflags",
-            "+faststart",
-            looped_path,
-        ]
-        try:
-            subprocess.run(cmd, check=True, capture_output=True, timeout=60)
-        except subprocess.CalledProcessError:
-            # copy 模式失败（编码不兼容），回退重编码
-            logger.warning("[ditto_task] stream_loop copy 失败，回退重编码: job=%s", job_id)
-            cmd = [
-                "ffmpeg",
-                "-y",
-                "-stream_loop",
-                "-1",
-                "-i",
-                src_path,
-                "-t",
-                str(target_duration),
-                "-c:v",
-                "libx264",
-                "-preset",
-                "veryfast",
-                "-crf",
-                "23",
-                "-c:a",
-                "aac",
-                "-movflags",
-                "+faststart",
-                looped_path,
-            ]
-            subprocess.run(cmd, check=True, capture_output=True, timeout=120)
-
-        # 上传临时 OSS
-        looped_key = f"ditto-tmp/{user_id}/{job_id}_looped.mp4"
-        with open(looped_path, "rb") as f:
-            tmp_url = storage.upload_file(
-                f,
-                looped_key,
-                content_type="video/mp4",
-            )
-        # 临时文件需要签名（private bucket）
-        signed_tmp_url = _sign_media_url(tmp_url)
-        logger.info(
-            "[ditto_task] 循环视频已上传: job=%s key=%s dur=%.2fs",
-            job_id,
-            looped_key,
-            target_duration,
-        )
-        return signed_tmp_url, True
-
-    except Exception as loop_exc:
-        logger.warning(
-            "[ditto_task] 视频循环处理失败，回退直接使用（Ditto 侧处理）: job=%s err=%s",
-            job_id,
-            loop_exc,
-        )
-        # 兜底：直接用原视频（交给 Ditto 侧处理时长不一致）
-        return _sign_media_url(source_url) if user_video_url else source_url, False
-    finally:
-        for p in (locals().get("src_path"), looped_path):
-            if p and os.path.exists(p):
-                try:
-                    os.unlink(p)
-                except Exception:
-                    pass
 
 
 def _refund_lip_sync(db: Session, job: "LipsyncJobModel") -> None:
@@ -311,6 +125,7 @@ def _fallback_to_gpu_then_mediakit(db: Session, job: "LipsyncJobModel") -> None:
         gpu_svc = GpuLipsyncService(db)
         if gpu_svc.has_available_worker():
             logger.info("[ditto_task] 回退 GPU MuseTalk: job_id=%s", job.id)
+            # 复用 lipsync_service._submit_to_gpu_create 逻辑
             from app.services.lipsync_service import LipsyncService
 
             svc = LipsyncService(db)
@@ -393,13 +208,9 @@ def lipsync_ditto_process_async(self, job_id: str, user_id: str) -> None:
     """
     from packages.application.ditto_emotion_service import get_ditto_emotion_service
     from packages.application.ditto_service import DittoError, get_ditto_client
-    from packages.config import get_api_settings
-    from packages.domain.sentence_timings import probe_audio_duration
-    from packages.shared.url_security import safe_download_bytes
 
     db: Session = _get_db_session()
     job: Optional[LipsyncJobModel] = None
-    prepared_video_url: str = ""
     try:
         from packages.adapters.sqlalchemy_impl.models import LipsyncJobModel
 
@@ -418,70 +229,54 @@ def lipsync_ditto_process_async(self, job_id: str, user_id: str) -> None:
 
         audio_url = job.audio_url or ""
         script = job.script_text or ""
-        user_video_url = job.video_url or ""
         if not audio_url:
             raise DittoError("job.audio_url 为空，无法调用 Ditto", code="InvalidParam")
 
-        settings = get_api_settings()
-        default_video_url = settings.ditto_default_video_url or ""
-
         logger.info(
-            "[ditto_task] 开始 Ditto 生成: job_id=%s has_user_video=%s script_len=%d",
+            "[ditto_task] 开始 Ditto 生成: job_id=%s audio=%s script_len=%d",
             job_id,
-            bool(user_video_url),
+            audio_url[:100],
             len(script),
         )
-
-        # ── 0. 探测音频时长（情绪分析 + 视频循环都需要）──
-        audio_duration = 0.0
-        audio_bytes_for_probe = None
-        try:
-            audio_bytes_for_probe = safe_download_bytes(
-                audio_url,
-                allowed_mime_types=("audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp3"),
-                timeout=30,
-            )
-            audio_duration = probe_audio_duration(audio_bytes_for_probe)
-            logger.info("[ditto_task] 音频时长: %.2fs", audio_duration)
-        except Exception as audio_exc:
-            logger.warning("[ditto_task] 音频时长探测失败: %s", audio_exc)
-            audio_duration = 0.0
-
-        # ── 1. LLM 情绪分析（生成 emo_timeline）──
+        # ── LLM 情绪分析（#2076 后续）：生成 emo_timeline ──
         emo_timeline = ""
         try:
             emo_svc = get_ditto_emotion_service()
-            if emo_svc.enabled and script and audio_duration > 0:
-                sentence_timings = getattr(job, "sentence_timings", None)
-                emo_timeline = emo_svc.build_timeline(
-                    text=script,
-                    audio_duration=audio_duration,
-                    sentence_timings=sentence_timings,
-                )
-                if emo_timeline:
-                    logger.info("[ditto_task] 情绪时间线已生成: segments≈%d", len(emo_timeline) // 50)
+            if emo_svc.enabled and script:
+                # 探测音频时长用于时间对齐
+                try:
+                    from packages.domain.sentence_timings import probe_audio_duration
+                    from packages.shared.url_security import safe_download_bytes
+
+                    audio_bytes = safe_download_bytes(
+                        audio_url,
+                        allowed_mime_types=("audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp3"),
+                        timeout=30,
+                    )
+                    audio_duration = probe_audio_duration(audio_bytes)
+                except Exception as audio_exc:
+                    logger.warning("[ditto_task] 音频时长探测失败，emo_timeline 降级空: %s", audio_exc)
+                    audio_duration = 0.0
+                if audio_duration > 0:
+                    sentence_timings = getattr(job, "sentence_timings", None)
+                    emo_timeline = emo_svc.build_timeline(
+                        text=script,
+                        audio_duration=audio_duration,
+                        sentence_timings=sentence_timings,
+                    )
+                    if emo_timeline:
+                        logger.info("[ditto_task] 情绪时间线已生成: segments=%d", len(emo_timeline) // 50)
         except Exception as emo_exc:
             logger.warning("[ditto_task] 情绪分析异常（降级中性）: %s", emo_exc)
             emo_timeline = ""
-
-        # ── 2. 准备驱动视频（用户视频优先，必要时循环延长）──
-        prepared_video_url, _is_tmp = _prepare_driver_video(
-            user_video_url=user_video_url,
-            default_video_url=default_video_url,
-            audio_duration=audio_duration if audio_duration > 0 else 10.0,  # 探测失败时按10s估
-            job_id=job_id,
-            user_id=user_id,
-        )
-
-        # ── 3. 调用 Ditto ──
         client = get_ditto_client()
         result = client.generate_and_persist(
             job_id=job_id,
             user_id=user_id,
             audio_url=audio_url,
             script=script,
-            video_url=prepared_video_url,
             emo_timeline=emo_timeline,
+            # video_url 不传则用默认模板
         )
 
         # Ditto 返回的 MP4 自带音频，签名 OSS URL（7天有效）后标记完成
@@ -489,14 +284,17 @@ def lipsync_ditto_process_async(self, job_id: str, user_id: str) -> None:
         # 探测时长（用于计费）
         duration = _probe_video_duration(result.video_bytes)
         if duration <= 0:
-            # 兜底：按音频时长估算
-            if audio_bytes_for_probe is not None:
-                try:
-                    duration = probe_audio_duration(audio_bytes_for_probe)
-                except Exception:
-                    duration = 0.0
-            if duration <= 0 and audio_duration > 0:
-                duration = audio_duration
+            # 兜底：按音频时长估算（1秒≈1秒）
+            try:
+                from packages.domain.sentence_timings import probe_audio_duration
+                from packages.shared.url_security import safe_download_bytes
+
+                audio_data = safe_download_bytes(
+                    audio_url, allowed_mime_types=("audio/mpeg", "audio/wav", "audio/x-wav"), timeout=30
+                )
+                duration = probe_audio_duration(audio_data)
+            except Exception:
+                duration = 0.0
         job.output_duration = duration
         job.status = "completed"
         job.completed_at = datetime.now(UTC)
@@ -518,6 +316,7 @@ def lipsync_ditto_process_async(self, job_id: str, user_id: str) -> None:
             try:
                 db.rollback()
                 job = db.query(type(job)).filter_by(id=job_id).first() if hasattr(job, "id") else job
+                # 回退 GPU/MediaKit
                 _fallback_to_gpu_then_mediakit(db, job)
             except Exception as fallback_exc:
                 logger.exception("[ditto_task] 回退也失败 job_id=%s err=%s", job_id, fallback_exc)

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

@@ -11,34 +11,12 @@ const apiOrigin = apiBase.endsWith("/api/v1") ? apiBase.slice(0, -"/api/v1".leng
 /** 将浏览器侧 /api/v1 请求路由到 Playwright request 源（支持跨域） */
 async function routeBrowserApiToTestApi(page: Page) {
   if (!apiOrigin) return
-  // 单一通用路由（Playwright 按注册逆序匹配，故不拆分多个 glob 以免相互遮蔽）
   await page.route("**/api/v1/**", async (route) => {
-    try {
-      const sourceUrl = new URL(route.request().url())
-      const response = await route.fetch({
-        url: `${apiOrigin}${sourceUrl.pathname}${sourceUrl.search}`,
-      })
-      // /points/balance：Staging 后端积分总开关关闭（credits_enabled=false，免费放行）。
-      // 旧 bundle 部署的接口暂未返回该字段、且预校验只看余额，这里同时补开关与余额，
-      // 以验证“免费期不拦截生成”；新后端+新前端部署后读 credits_enabled=false 直接放行，
-      // 余额被忽略，此补丁随之成为 no-op。
-      if (sourceUrl.pathname.endsWith("/points/balance")) {
-        const body = await response.json().catch(() => ({}))
-        await route.fulfill({
-          response,
-          json: { ...body, credits_enabled: false, balance: 999999 },
-        })
-        return
-      }
-      await route.fulfill({ response })
-    } catch {
-      // 测试收尾时页面/上下文可能已关闭，忽略仍在途的请求，避免误判为失败
-      try {
-        await route.abort()
-      } catch {
-        /* noop */
-      }
-    }
+    const sourceUrl = new URL(route.request().url())
+    const response = await route.fetch({
+      url: `${apiOrigin}${sourceUrl.pathname}${sourceUrl.search}`,
+    })
+    await route.fulfill({ response })
   })
 }
 
@@ -67,13 +45,7 @@ async function loginWithRetry(
 async function setupFreshUser(
   request: APIRequestContext,
   label: string,
-): Promise<{
-  token: string
-  user: Record<string, unknown>
-  libraryId: string
-  assetId: string
-  suffix: string
-}> {
+): Promise<{ token: string; libraryId: string; assetId: string; suffix: string }> {
   const suffix = Math.random().toString(36).slice(2, 8)
   const email = `e2e-${label}-${suffix}@example.com`
   await request.post(`${apiBase}/auth/register`, {
@@ -81,19 +53,7 @@ async function setupFreshUser(
   })
   const token = await loginWithRetry(request, email, PASSWORD)
   const auth = { Authorization: `Bearer ${token}` }
-  const me = await request.get(`${apiBase}/auth/me`, { headers: auth })
-  expect(me.ok(), `fetch profile: ${await me.text()}`).toBeTruthy()
-  const user = (await me.json()) as Record<string, unknown>
 
-  // 预置一条文案：标题下拉候选来自文案库，新用户为空会导致无法选中标题
-  await request.post(`${apiBase}/scripts`, {
-    headers: auth,
-    data: {
-      title: `测试标题 ${suffix}`,
-      content: `测试文案内容 ${suffix}`,
-      tags: ["e2e"],
-    },
-  })
   const proj = await request.post(`${apiBase}/projects`, {
     headers: auth,
     data: { name: `Smoke ${label} ${suffix}` },
@@ -133,7 +93,7 @@ async function setupFreshUser(
       { timeout: 90_000, intervals: [3000, 3000, 5000] },
     )
     .toBe("ready")
-  return { token, user, libraryId, assetId, suffix }
+  return { token, libraryId, assetId, suffix }
 }
 
 /**
@@ -152,7 +112,7 @@ test.describe("Core Smart-Edit Flow (#1970)", () => {
   test("random mode: 5-step wizard creates generation task", async ({ page, request }) => {
     test.setTimeout(600_000)
     await page.setViewportSize({ width: 1440, height: 1000 })
-    const { token, user, suffix } = await setupFreshUser(request, "random")
+    const { token, suffix } = await setupFreshUser(request, "random")
     const authHeader = { Authorization: `Bearer ${token}` }
 
     // 确保默认模板存在（智能剪辑页依赖模板）
@@ -166,24 +126,13 @@ test.describe("Core Smart-Edit Flow (#1970)", () => {
     expect(templates.length).toBeGreaterThan(0)
 
     // 注入登录态 + 路由 API
-    await page.addInitScript(
-      ({ token, user }) => {
-        window.localStorage.setItem("access_token", token)
-        window.localStorage.setItem(
-          "auth-storage",
-          JSON.stringify({
-            state: {
-              user,
-              isAuthenticated: true,
-              accessToken: token,
-              refreshToken: null,
-            },
-            version: 0,
-          }),
-        )
-      },
-      { token, user },
-    )
+    await page.addInitScript((t: string) => {
+      window.localStorage.setItem("access_token", t)
+      window.localStorage.setItem(
+        "auth-storage",
+        JSON.stringify({ state: { token: t, user: null } }),
+      )
+    }, token)
     await routeBrowserApiToTestApi(page)
 
     // ── 提前 mock 配音列表（VoiceSelectModal 查询 /assets?kind=voice） ──
@@ -229,28 +178,16 @@ test.describe("Core Smart-Edit Flow (#1970)", () => {
     await expect(page.getByText("🎙️ 选择配音")).not.toBeVisible()
 
     // ── Step 2：选择素材 ──────────────────────────────────────────
-    await expect(page.getByText(/选择素材/).first()).toBeVisible({ timeout: 10000 })
-    // 卡片中心是播放按钮（stopPropagation 仅播放不选中），点右上角空白处完成选中
-    await page
-      .getByTestId("material-card")
-      .first()
-      .click({ position: { x: 70, y: 12 } })
-    await expect(page.getByText(/已选 1 个素材|已选[^0]*[1-9]/)).toBeVisible({ timeout: 5000 })
+    await expect(page.getByText("选择素材", { exact: true })).toBeVisible({ timeout: 10000 })
+    await page.getByTestId("material-card").first().click()
     await page.getByRole("button", { name: /下一步/ }).click()
 
     // ── Step 3：填写标题 ──────────────────────────────────────────
     // (#2048: PreviewCountModal 已移除，生成数量在 Step1 内设置)
-    await expect(page.getByText(/选择标题/).first()).toBeVisible({ timeout: 10000 })
-    // 标题为 antd AutoComplete（combobox），真实 input 带 placeholder
-    // antd AutoComplete combobox：真实可输入元素是 .ant-select-selection-search-input，
-    // 灰色提示语是单独的 placeholder span（input 自身无 placeholder 属性）
-    // 标题候选来自文案库（setupFreshUser 已预置一条文案）。
-    // combobox 的自由输入会在失焦时被 rc-select 重置，必须从下拉选中才提交，
-    // 因此聚焦输入框 → 点击候选选项
-    const seededTitle = `测试标题 ${suffix}`
-    const titleBox = page.locator(".ant-select-selection-search-input:visible").first()
-    await titleBox.click()
-    await page.locator(".ant-select-item-option", { hasText: seededTitle }).first().click()
+    await expect(page.getByText("选择标题", { exact: true })).toBeVisible({ timeout: 10000 })
+    const titleInput = page.getByPlaceholder("输入或从标题库选择")
+    await expect(titleInput).toBeVisible({ timeout: 5000 })
+    await titleInput.fill(`测试随机剪辑 ${suffix}`)
     await page.getByRole("button", { name: /下一步/ }).click()
 
     // ── Step 4：确认生成 ──────────────────────────────────────────
@@ -267,11 +204,9 @@ test.describe("Core Smart-Edit Flow (#1970)", () => {
     await confirmBtn.click()
     const taskResp = await createTask
     expect(taskResp.ok(), `Create task: ${await taskResp.text()}`).toBeTruthy()
-    const taskBody = await taskResp.json()
-    const taskId = taskBody.items?.[0]?.id ?? taskBody.id ?? taskBody.task_id
-    expect(taskId, "created task should return an id").toBeTruthy()
+    const taskId = (await taskResp.json()).id ?? (await taskResp.json()).task_id
     console.log("[random] Generation task created:", taskId)
-    await expect(page.getByText(/正在生成|提交/).first()).toBeVisible({ timeout: 15000 })
+    await expect(page.getByText(/正在生成|提交/)).toBeVisible({ timeout: 15000 })
     console.log("[random] Wizard flow completed ✓")
   })
 
@@ -281,28 +216,113 @@ test.describe("Core Smart-Edit Flow (#1970)", () => {
   }) => {
     test.setTimeout(600_000)
     await page.setViewportSize({ width: 1440, height: 1000 })
-    const { token, user, suffix } = await setupFreshUser(request, "narrative")
+    const { token, suffix } = await setupFreshUser(request, "narrative")
 
-    await page.addInitScript(
-      ({ token, user }) => {
-        window.localStorage.setItem("access_token", token)
-        window.localStorage.setItem(
-          "auth-storage",
-          JSON.stringify({
-            state: {
-              user,
-              isAuthenticated: true,
-              accessToken: token,
-              refreshToken: null,
-            },
-            version: 0,
-          }),
-        )
-      },
-      { token, user },
-    )
+    await page.addInitScript((t: string) => {
+      window.localStorage.setItem("access_token", t)
+      window.localStorage.setItem(
+        "auth-storage",
+        JSON.stringify({ state: { token: t, user: null } }),
+      )
+    }, token)
     await routeBrowserApiToTestApi(page)
 
+    // ── Mock 文案列表、音色、TTS 合成（避免真实合成） ──────────────
+    const mockScriptId = `script-mock-${suffix}`
+    const mockVoiceId = `preset-voice-${suffix}`
+    const mockJobId = `tts-job-${suffix}`
+
+    // 文案列表（ScriptSelectModal 查询 /scripts）
+    await page.route("**/api/v1/scripts**", (route) => {
+      const url = new URL(route.request().url())
+      if (url.pathname.includes("/extract-from-douyin")) {
+        route.continue()
+        return
+      }
+      route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          items: [
+            {
+              id: mockScriptId,
+              title: "测试带货文案",
+              content: "这是一段测试用的带货文案内容，用于 E2E 冒烟测试。",
+              tags: ["带货"],
+              title_category: "daihuo",
+              created_at: new Date().toISOString(),
+              updated_at: new Date().toISOString(),
+            },
+          ],
+          total: 1,
+          page: 1,
+          page_size: 200,
+        }),
+      })
+    })
+
+    // 预设音色（TtsVoiceModal 查询 GET /voices/presets）
+    await page.route("**/api/v1/voices/presets**", (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          items: [
+            {
+              voice_id: mockVoiceId,
+              name: "晓晓（女声）",
+              description: "温柔女声",
+              gender: "female",
+              language: "zh-CN",
+              preview_url: null,
+              tags: ["温柔"],
+            },
+          ],
+          total: 1,
+        }),
+      }),
+    )
+
+    // 克隆音色：空列表
+    await page.route(
+      (url) => url.pathname.endsWith("/voice-clones"),
+      (route) =>
+        route.fulfill({
+          status: 200,
+          contentType: "application/json",
+          body: JSON.stringify({ items: [] }),
+        }),
+    )
+
+    // TTS 合成：直接返回 completed 任务
+    await page.route("**/api/v1/tts/synthesize", (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({ job_id: mockJobId, status: "queued" }),
+      }),
+    )
+    await page.route(`**/api/v1/tts/jobs/${mockJobId}/status`, (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          job_id: mockJobId,
+          status: "completed",
+          progress: 100,
+          audio_url: "data:audio/mpeg;base64,",
+          duration: 5,
+        }),
+      }),
+    )
+    await page.route(`**/api/v1/tts/jobs/${mockJobId}/save-to-library`, (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({ id: `tts-asset-${suffix}`, name: "AI合成配音" }),
+      }),
+    )
+
     await page.goto("/app/generate")
     // ── 页面标题 ─────────────────────────────────────────────────
     await expect(page.getByText("智能剪辑").first()).toBeVisible({ timeout: 30000 })
@@ -314,38 +334,28 @@ test.describe("Core Smart-Edit Flow (#1970)", () => {
 
     // ── 文案选择弹窗：选第一条 → 确认 ─────────────────────────────
     await expect(page.getByText("📝 选择文案")).toBeVisible({ timeout: 5000 })
-    await page.getByText(`测试标题 ${suffix}`).first().click()
+    await page.getByText("测试带货文案").first().click()
     await page.getByRole("button", { name: "确认选择" }).click()
     await expect(page.getByText("📝 选择文案")).not.toBeVisible()
 
     // ── TTS 音色弹窗：选系统音色 → 合成 ─────────────────────────
     await expect(page.getByText("🎙️ 合成配音")).toBeVisible({ timeout: 5000 })
-    await page.getByText("龙小夏").first().click()
+    await page.getByText("晓晓（女声）").first().click()
     await page.getByRole("button", { name: "🎧 合成配音" }).click()
-    // 真实阿里云 CosyVoice 合成耗时偶有波动，放宽到 90s
-    await expect(page.getByText("🎙️ 合成配音")).not.toBeVisible({ timeout: 90000 })
+    await expect(page.getByText("🎙️ 合成配音")).not.toBeVisible({ timeout: 30000 })
 
     // ── Step 2：AI 匹配提示卡可见 + 选素材 ────────────────────────
-    await expect(page.getByText(/选择素材/).first()).toBeVisible({ timeout: 10000 })
-    await expect(page.getByText(/AI智能匹配/).first()).toBeVisible()
-    // 卡片中心是播放按钮（stopPropagation 仅播放不选中），点右上角空白处完成选中
-    await page
-      .getByTestId("material-card")
-      .first()
-      .click({ position: { x: 70, y: 12 } })
-    await expect(page.getByText(/已选 1 个素材|已选[^0]*[1-9]/)).toBeVisible({ timeout: 5000 })
+    await expect(page.getByText("选择素材", { exact: true })).toBeVisible({ timeout: 10000 })
+    await expect(page.getByText(/AI智能匹配/)).toBeVisible()
+    await page.getByTestId("material-card").first().click()
     await page.getByRole("button", { name: /下一步/ }).click()
 
     // ── Step 3：填写标题（handleScriptModalConfirm 已预填 script.title，但我们再覆盖一次） ─
     // (#2048: PreviewCountModal 已移除)
-    await expect(page.getByText(/选择标题/).first()).toBeVisible({ timeout: 10000 })
-    // 选中文案后标题框已预填该文案标题，下拉按当前输入过滤，直接选中该选项确认
-    const titleBox2 = page.locator(".ant-select-selection-search-input:visible").first()
-    await titleBox2.click()
-    await page
-      .locator(".ant-select-item-option", { hasText: `测试标题 ${suffix}` })
-      .first()
-      .click()
+    await expect(page.getByText("选择标题", { exact: true })).toBeVisible({ timeout: 10000 })
+    const titleInput2 = page.getByPlaceholder("输入或从标题库选择")
+    await expect(titleInput2).toBeVisible({ timeout: 5000 })
+    await titleInput2.fill(`测试叙事剪辑 ${suffix}`)
     await page.getByRole("button", { name: /下一步/ }).click()
 
     // ── Step 4：确认生成 ──────────────────────────────────────────
@@ -361,11 +371,8 @@ test.describe("Core Smart-Edit Flow (#1970)", () => {
     await confirmBtn2.click()
     const taskResp2 = await createTask2
     expect(taskResp2.ok(), `Create task: ${await taskResp2.text()}`).toBeTruthy()
-    const taskBody2 = await taskResp2.json()
-    const taskId2 = taskBody2.items?.[0]?.id ?? taskBody2.id ?? taskBody2.task_id
-    expect(taskId2, "created task should return an id").toBeTruthy()
-    console.log("[narrative] Generation task created:", taskId2)
-    await expect(page.getByText(/正在生成|提交/).first()).toBeVisible({ timeout: 15000 })
+    console.log("[narrative] Generation task created:", (await taskResp2.json()).id)
+    await expect(page.getByText(/正在生成|提交/)).toBeVisible({ timeout: 15000 })
     console.log("[narrative] Wizard flow completed ✓")
   })
 })

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

@@ -11,20 +11,11 @@ const apiOrigin = apiBase.endsWith("/api/v1") ? apiBase.slice(0, -"/api/v1".leng
 const routeBrowserApiToTestApi = async (page: import("@playwright/test").Page) => {
   if (!apiOrigin) return
   await page.route("**/api/v1/**", async (route) => {
-    try {
-      const sourceUrl = new URL(route.request().url())
-      const response = await route.fetch({
-        url: `${apiOrigin}${sourceUrl.pathname}${sourceUrl.search}`,
-      })
-      await route.fulfill({ response })
-    } catch {
-      // 收尾时页面可能已关闭，忽略在途请求避免误判
-      try {
-        await route.abort()
-      } catch {
-        /* noop */
-      }
-    }
+    const sourceUrl = new URL(route.request().url())
+    const response = await route.fetch({
+      url: `${apiOrigin}${sourceUrl.pathname}${sourceUrl.search}`,
+    })
+    await route.fulfill({ response })
   })
 }
 
@@ -54,7 +45,8 @@ type LibraryResponse = { id: string }
 test.describe("Core media upload flow", () => {
   test.describe.configure({ timeout: 180_000 })
   test("uploads a video asset and shows it in the asset library", async ({ page, request }) => {
-    // 串行执行时登录可能触发 429，两次退避约 130s，沿用 describe 的 180s 超时
+    test.setTimeout(120_000)
+
     await routeBrowserApiToTestApi(page)
     const suffix = Date.now().toString(36)
     const email = `e2e-mov-${suffix}@example.com`

apps/web/index.html

@@ -4,27 +4,13 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <!-- 标题字体（#2001 / #font-selection 修复）：完全非阻塞加载中文字体
-         - 使用 preload + 动态 rel 切换的"无阻塞字体加载"模式：
-           浏览器以 preload 低优先级拉取 CSS，不会阻塞 render/DOMContentLoaded/load 任一事件
-         - onload 后切换 rel=stylesheet 字体才生效，首屏用系统字体兜底（Noto Sans SC → PingFang SC → Microsoft YaHei → sans-serif）
-         - 解决境内访问 Google Fonts 挂起时首屏白屏 + Playwright load 事件超时（E2E 也受益） -->
+    <!-- 标题字体（#2001 / #font-selection 修复）：Google Fonts CDN 引入中文字体，保证优设标题黑/抖音美好体/阿里普惠体等fallback可用 -->
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link
-      rel="preload"
-      as="style"
       href="https://fonts.googleapis.com/css2?family=Noto+Sans+SC:wght@400;500;700;900&family=Noto+Serif+SC:wght@400;700;900&family=ZCOOL+KuaiLe&family=ZCOOL+XiaoWei&family=ZCOOL+QingKe+HuangYou&family=Ma+Shan+Zheng&family=Long+Cang&family=Liu+Jian+Mao+Cao&family=Zhi+Mang+Xing&display=swap"
-    />
-    <link
       rel="stylesheet"
-      href="https://fonts.googleapis.com/css2?family=Noto+Sans+SC:wght@400;500;700;900&family=Noto+Serif+SC:wght@400;700;900&family=ZCOOL+KuaiLe&family=ZCOOL+XiaoWei&family=ZCOOL+QingKe+HuangYou&family=Ma+Shan+Zheng&family=Long+Cang&family=Liu+Jian+Mao+Cao&family=Zhi+Mang+Xing&display=swap"
-      media="print"
-      onload="this.media='all'; this.onload=null"
     />
-    <noscript
-      ><link
-        rel="stylesheet"
-        href="https://fonts.googleapis.com/css2?family=Noto+Sans+SC:wght@400;500;700;900&family=Noto+Serif+SC:wght@400;700;900&family=ZCOOL+KuaiLe&family=ZCOOL+XiaoWei&family=ZCOOL+QingKe+HuangYou&family=Ma+Shan+Zheng&family=Long+Cang&family=Liu+Jian+Mao+Cao&family=Zhi+Mang+Xing&display=swap"
-    /></noscript>
     <title>小虾 SaaS - 自动化视频剪辑平台</title>
   </head>
   <body>

apps/web/src/api/admin/dittoEmotion.ts

@@ -0,0 +1,76 @@
+/**
+ * 后台管理 API client（#2246）
+ *
+ * 独立 axios 实例：不经过主 apiClient 的 Bearer token / 401 刷新逻辑，
+ * 后台鉴权使用 X-API-Key（存 localStorage，不硬编码）。
+ */
+import axios from "axios"
+
+export const ADMIN_API_KEY_STORAGE = "ditto_admin_api_key"
+
+export type ConfigType = "bool" | "int" | "float" | "string" | "json"
+
+export interface ConfigItem {
+  key: string
+  value: unknown
+  default: unknown
+  type: ConfigType
+  description: string
+  model_options?: string[]
+}
+
+export interface TestResult {
+  ok: boolean
+  enabled?: boolean
+  segments?: Array<{ text: string; emo: number; intensity: number }>
+  error?: string
+}
+
+export function getAdminApiKey(): string {
+  return localStorage.getItem(ADMIN_API_KEY_STORAGE) || ""
+}
+
+export function setAdminApiKey(key: string): void {
+  localStorage.setItem(ADMIN_API_KEY_STORAGE, key)
+}
+
+export function clearAdminApiKey(): void {
+  localStorage.removeItem(ADMIN_API_KEY_STORAGE)
+}
+
+function createAdminClient() {
+  const client = axios.create({
+    baseURL: "/api/v1",
+    timeout: 60000,
+    headers: { "Content-Type": "application/json" },
+  })
+  client.interceptors.request.use((config) => {
+    const key = getAdminApiKey()
+    if (key && config.headers) {
+      config.headers["X-API-Key"] = key
+    }
+    return config
+  })
+  return client
+}
+
+const adminClient = createAdminClient()
+
+export async function fetchConfig(): Promise<ConfigItem[]> {
+  const { data } = await adminClient.get("/admin/ditto-emotion/config")
+  return data.configs as ConfigItem[]
+}
+
+export async function updateConfig(
+  configs: Record<string, unknown>,
+): Promise<{ ok: boolean; updated?: Record<string, unknown>; error?: string }> {
+  const { data } = await adminClient.put("/admin/ditto-emotion/config", { configs })
+  return data
+}
+
+export async function testConfig(testText: string): Promise<TestResult> {
+  const { data } = await adminClient.post("/admin/ditto-emotion/config/test", {
+    test_text: testText,
+  })
+  return data as TestResult
+}

apps/web/src/api/env-flags.ts

@@ -1,41 +0,0 @@
-/**
- * 运行时开关安全读取
- *
- * 背景：本项目使用 Vite 构建，浏览器运行时不存在 Node 的全局 `process`。
- * 直接写 `process.env.XXX` 会在模块加载阶段抛出 `ReferenceError: process is not defined`，
- * 导致整个页面白屏崩溃。
- *
- * 统一通过本模块读取这类仅在构建/调试期注入的布尔开关：
- * - 优先读取 Vite 的 `import.meta.env.VITE_XXX`
- * - 兼容历史上未加 VITE_ 前缀、经由 Node 环境（单测 / 旧构建脚本）注入的 `process.env.XXX`
- * - 任何情况下访问失败都安全返回 false（默认走真实后端 API，不启用 mock）
- */
-
-/** 从可能不存在的 Node 全局 process 上安全读取环境变量 */
-function readNodeEnv(name: string): string | undefined {
-  try {
-    const proc = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process
-    return proc?.env?.[name]
-  } catch {
-    return undefined
-  }
-}
-
-/**
- * 读取运行时布尔开关。
- *
- * @param name 开关名（不含 VITE_ 前缀的历史名称，如 POINTS_API_MOCK）
- * @returns 开关是否显式置为 "true"；未设置或读取失败时为 false
- */
-export function readRuntimeFlag(name: string): boolean {
-  // Vite 注入的环境变量（需 VITE_ 前缀才会暴露到浏览器）
-  const viteKey = `VITE_${name}`
-  const viteEnv = (import.meta as unknown as { env?: Record<string, string | undefined> }).env
-  const viteVal = viteEnv?.[viteKey] ?? viteEnv?.[name]
-
-  // 兼容 Node 环境下无前缀的历史变量名
-  const nodeVal = readNodeEnv(name)
-
-  const raw = viteVal ?? nodeVal
-  return raw === "true"
-}

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

@@ -8,7 +8,6 @@
  * 会员/订阅 API 在 @/api/subscription 中定义，避免重复封装。
  */
 import apiClient from "../client"
-import { readRuntimeFlag } from "../env-flags"
 import type {
   PointsBalance,
   PointsRulesResponse,
@@ -202,7 +201,7 @@ const MOCK_MEMBERSHIP: MembershipResponse = {
 
 /** 获取积分余额 */
 export async function getPointsBalance(): Promise<PointsBalance> {
-  if (readRuntimeFlag("POINTS_API_MOCK")) {
+  if (process.env.POINTS_API_MOCK === "true") {
     await new Promise((resolve) => setTimeout(resolve, MOCK_DELAY))
     return { ...MOCK_BALANCE }
   }
@@ -212,7 +211,7 @@ export async function getPointsBalance(): Promise<PointsBalance> {
 
 /** 获取积分消耗规则 */
 export async function getPointsRules(): Promise<PointsRulesResponse> {
-  if (readRuntimeFlag("POINTS_API_MOCK")) {
+  if (process.env.POINTS_API_MOCK === "true") {
     await new Promise((resolve) => setTimeout(resolve, MOCK_DELAY))
     return { rules: [...MOCK_RULES.rules], free_user_multiplier: MOCK_RULES.free_user_multiplier }
   }
@@ -222,7 +221,7 @@ export async function getPointsRules(): Promise<PointsRulesResponse> {
 
 /** 获取充值包列表 */
 export async function getPointsPackages(): Promise<PointsPackagesResponse> {
-  if (readRuntimeFlag("POINTS_API_MOCK")) {
+  if (process.env.POINTS_API_MOCK === "true") {
     await new Promise((resolve) => setTimeout(resolve, MOCK_DELAY))
     return { packages: MOCK_PACKAGES.packages.map((p) => ({ ...p })), user_discount: null }
   }
@@ -237,7 +236,7 @@ export async function getPointsTransactions(
   page = 1,
   pageSize = 20,
 ): Promise<PointsTransactionsResponse> {
-  if (readRuntimeFlag("POINTS_API_MOCK")) {
+  if (process.env.POINTS_API_MOCK === "true") {
     await new Promise((resolve) => setTimeout(resolve, MOCK_DELAY))
     const start = (page - 1) * pageSize
     const items = MOCK_TRANSACTIONS.slice(start, start + pageSize)
@@ -262,7 +261,7 @@ export async function getPointsTransactions(
 export async function createPointsOrder(
   data: CreateRechargeOrderRequest,
 ): Promise<CreateRechargeOrderResponse> {
-  if (readRuntimeFlag("POINTS_API_MOCK")) {
+  if (process.env.POINTS_API_MOCK === "true") {
     await new Promise((resolve) => setTimeout(resolve, MOCK_DELAY * 2))
     const pkg = MOCK_PACKAGES.packages.find((p) => p.code === data.package_id)
     if (!pkg) throw new Error("充值包不存在")
@@ -286,7 +285,7 @@ export async function createPointsOrder(
  * 积分预检查（消耗前调用）
  */
 export async function checkPoints(data: PointsCheckRequest): Promise<PointsCheckResponse> {
-  if (readRuntimeFlag("POINTS_API_MOCK")) {
+  if (process.env.POINTS_API_MOCK === "true") {
     await new Promise((resolve) => setTimeout(resolve, MOCK_DELAY))
     const rule = MOCK_RULES.rules.find((r) => r.scene_key === data.scene_key)
     if (!rule) {
@@ -327,7 +326,7 @@ export async function checkPoints(data: PointsCheckRequest): Promise<PointsCheck
 
 /** 获取每日免费额度使用情况 */
 export async function getDailyUsage(): Promise<DailyUsage> {
-  if (readRuntimeFlag("POINTS_API_MOCK")) {
+  if (process.env.POINTS_API_MOCK === "true") {
     await new Promise((resolve) => setTimeout(resolve, MOCK_DELAY))
     return { ...MOCK_DAILY_USAGE }
   }
@@ -337,7 +336,7 @@ export async function getDailyUsage(): Promise<DailyUsage> {
 
 /** 获取会员聚合信息（创作页可用来判断 max_resolution） */
 export async function getMembership(): Promise<MembershipResponse> {
-  if (readRuntimeFlag("POINTS_API_MOCK")) {
+  if (process.env.POINTS_API_MOCK === "true") {
     await new Promise((resolve) => setTimeout(resolve, MOCK_DELAY))
     return { ...MOCK_MEMBERSHIP }
   }

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

@@ -50,8 +50,6 @@ export interface PointsBalance {
   member_type: "monthly" | "quarterly" | "yearly" | null
   /** 会员到期时间 */
   member_expires_at: ISODate | null
-  /** 后端积分系统是否启用（false=免费放行，不做余额预校验） */
-  credits_enabled?: boolean
 }
 
 /* ================================================================

apps/web/src/api/scripts/scripts.ts

@@ -3,7 +3,6 @@
  * CRUD + 搜索/分类/分页；后端未就绪时使用 mock 数据（SCRIPTS_API_MOCK=true）
  */
 import apiClient from "../client"
-import { readRuntimeFlag } from "../env-flags"
 import type {
   ScriptItem,
   ScriptListParams,
@@ -17,7 +16,7 @@ import type {
  * #1894：文案库接口已上线，默认 false 走真实 API；
  * 通过 SCRIPTS_API_MOCK=true 环境变量可本地开启 mock 调试（行为同 POINTS_API_MOCK）。
  */
-export const SCRIPTS_API_MOCK = readRuntimeFlag("SCRIPTS_API_MOCK")
+export const SCRIPTS_API_MOCK = (process.env.SCRIPTS_API_MOCK as string | undefined) === "true"
 
 // ==================== Mock 数据 ====================
 

apps/web/src/api/subscription/subscription.ts

@@ -6,7 +6,6 @@
  * 所有请求走 apiClient（已配置 baseURL=/api/v1 和 token 拦截器）。
  */
 import apiClient from "../client"
-import { readRuntimeFlag } from "../env-flags"
 import type {
   SubscriptionInfo,
   SubscriptionPlan,
@@ -73,7 +72,7 @@ const MOCK_PLANS: SubscriptionPlan[] = [
 
 const MOCK_BILLING: BillingRecord[] = []
 
-const isMock = () => readRuntimeFlag("POINTS_API_MOCK")
+const isMock = () => (process.env.POINTS_API_MOCK as string | undefined) === "true"
 
 /** 获取当前订阅 */
 export const getCurrentSubscription = async (): Promise<SubscriptionInfo> => {

apps/web/src/api/viral-video/index.ts

@@ -1,5 +1,6 @@
 import apiClient from "@/api/client"
 import type {
+  GenerateViralVideoRequest,
   HistoryResponse,
   StyleTemplate,
   ViralVideoJob,
@@ -12,11 +13,26 @@ import type {
   ViralVideoModelsResponse,
 } from "./types"
 
+/** 创建爆款视频任务 */
+export function generateViralVideo(payload: GenerateViralVideoRequest) {
+  return apiClient.post<ViralVideoJob>("/viral-video/generate", payload).then((r) => r.data)
+}
+
 /** 查询单个任务 */
 export function getViralVideoJob(id: string) {
   return apiClient.get<ViralVideoJob>(`/viral-video/${id}`).then((r) => r.data)
 }
 
+/** 用户确认/修改 AI 理解的意图后继续 */
+export function confirmViralVideoIntent(
+  id: string,
+  payload: { confirmed_copy?: string; edits?: Record<string, unknown> },
+) {
+  return apiClient
+    .post<ViralVideoJob>(`/viral-video/${id}/confirm-intent`, payload)
+    .then((r) => r.data)
+}
+
 /** 重试失败任务 */
 export function retryViralVideo(id: string) {
   return apiClient.post<ViralVideoJob>(`/viral-video/${id}/retry`).then((r) => r.data)

apps/web/src/api/viral-video/types.ts

@@ -21,15 +21,23 @@ export const VALID_RATIOS = ["9:16", "16:9", "1:1"] as const
 export type VideoRatio = (typeof VALID_RATIOS)[number]
 
 export type ViralVideoStatus =
-  "pending" | "running" | "image_analyzed" | "copy_generated" | "completed" | "failed" | "cancelled"
+  | "pending"
+  | "running"
+  | "wait_user_confirm"
+  | "image_analyzed"
+  | "copy_generated"
+  | "completed"
+  | "failed"
+  | "cancelled"
 
 /**
  * v1.6 后端流水线阶段。单次 Seedance 出片版：
- * image_analysis → video_analysis(可选) → script_generation(含意图理解) → review → tts → rendering → uploading
+ * image_analysis → video_analysis(可选) → intent_parsing → script_generation → review → tts → rendering → uploading
  */
 export type ViralVideoStage =
   | "image_analysis"
   | "video_analysis"
+  | "intent_parsing"
   | "script_generation"
   | "review"
   | "tts"
@@ -39,7 +47,7 @@ export type ViralVideoStage =
 /** 图片+视频分析阶段：属于「分析图片」按钮的范围 */
 const IMAGE_ANALYSIS_STAGES = new Set<ViralVideoStage>(["image_analysis", "video_analysis"])
 /** 编导脚本阶段：属于「生成文案」按钮的范围 */
-const COPY_STAGES = new Set<ViralVideoStage>(["script_generation", "review"])
+const COPY_STAGES = new Set<ViralVideoStage>(["intent_parsing", "script_generation", "review"])
 /** 视频生成阶段：属于「开始生成视频」按钮的范围（v1.6: TTS+单次Seedance+上传） */
 const VIDEO_STAGES = new Set<ViralVideoStage>(["tts", "rendering", "uploading"])
 
@@ -57,22 +65,6 @@ export function isAnalysisStage(stage: ViralVideoStage | undefined): boolean {
   return isImageAnalysisStage(stage) || isCopyStage(stage)
 }
 
-/** 从 job 对象取到有效阶段（兼容 progress_stage/current_stage 两种字段名） */
-export function getJobStage(
-  job: { current_stage?: ViralVideoStage; progress_stage?: ViralVideoStage } | null | undefined,
-): ViralVideoStage | undefined {
-  if (!job) return undefined
-  return job.current_stage || job.progress_stage
-}
-
-/** 从 job 对象取到阶段提示文案（兼容 phase_message/progress_message） */
-export function getJobPhaseMessage(
-  job: { phase_message?: string; progress_message?: string } | null | undefined,
-): string {
-  if (!job) return ""
-  return job.phase_message || job.progress_message || ""
-}
-
 /** 单张图片 VLM 识别结果（v8 叙述优先，仅保留最少结构化字段） */
 export interface ImageProductAnalysis {
   /** store / product / person / scene */
@@ -97,8 +89,6 @@ export interface ImageAnalysisResult {
 export interface ShotScript {
   /** 时间区间，如 "0-3秒" */
   time_range?: string
-  /** 说话人角色，如 "店主"、"顾客" */
-  speaker?: string
   /** 景别/角度/运镜，如 "近景俯拍45度，缓慢推镜" */
   shot_type_angle_movement?: string
   /** 场景描述+对白 */
@@ -153,6 +143,22 @@ export interface StyleTemplate {
   tags?: string[]
 }
 
+export interface IntentResult {
+  intent?: string
+  key_messages?: string[]
+  tone?: string
+  target_emotion?: string
+  call_to_action?: string
+  suggested_title?: string
+  /** v1.5 旧字段兼容 */
+  product?: string
+  selling_points?: string[]
+  target_audience?: string
+  structure?: string
+  duration?: number
+  suggested_copy?: string
+}
+
 export interface ViralVideoJob {
   id: string
   status: ViralVideoStatus
@@ -170,6 +176,8 @@ export interface ViralVideoJob {
   voice_mode?: "global" | "per_video"
   voice_source?: "preset" | "library" | "clone" | "upload" | "my_voice"
   bgm_preference?: string
+  intent_result?: IntentResult
+  intent_text?: string
   /** v1.6 编导分镜脚本（核心产物） */
   copy_result?: CopyResult
   /** 向后兼容：= copy_result.shots */
@@ -181,14 +189,8 @@ export interface ViralVideoJob {
   video_model?: string
   /** 视频时长（秒，5-30，默认15） */
   duration?: number
-  /** 后端真实字段名（snake_case）：当前细粒度阶段 */
-  current_stage?: ViralVideoStage
-  /** 后端真实字段名：当前阶段中文提示文案 */
-  phase_message?: string
-  /** @deprecated 兼容旧前端：使用 current_stage */
   progress_stage?: ViralVideoStage
   progress_percent?: number
-  /** @deprecated 兼容旧前端：使用 phase_message */
   progress_message?: string
   output_url?: string
   result_video_url?: string
@@ -199,6 +201,31 @@ export interface ViralVideoJob {
   updated_at?: string
 }
 
+export interface GenerateViralVideoRequest {
+  images: string[]
+  reference_video_url?: string
+  douyin_url?: string
+  style_strength?: StyleStrength
+  style_template_id?: string
+  user_copy_text?: string
+  fusion_level?: FusionLevel
+  voice_id?: string
+  voice_source?: "preset" | "library" | "clone" | "upload" | "my_voice"
+  bgm_preference?: string
+  industry?: string
+  target_customer?: string
+  language?: string
+  persona_id?: string
+  viral_structure?: string
+  marketing_purpose?: string
+  /** 视频时长（5-30秒，默认15） */
+  duration?: number
+  video_model?: string
+  video_ratio?: string
+  /** 三步拆分：step 控制后端执行到哪一步暂停 */
+  step?: "analyze" | "generate_copy" | "generate_video"
+}
+
 export interface HistoryResponse {
   items: ViralVideoJob[]
   total: number
@@ -274,18 +301,6 @@ export interface ConfirmCopyRequest {
   edited_copy?: string
   /** 视频模型 key，覆盖默认 */
   video_model?: string
-  /** 分辨率，如 480p/720p/1080p */
-  video_resolution?: string
-  /** 画面比例，如 9:16/16:9/1:1 */
-  video_ratio?: string
-  /** 成片时长秒数 */
-  duration?: number
-  /** 音色 ID（CosyVoice voice_id 或 preset id） */
-  voice_id?: string
-  /** 音色来源：preset/library/upload/clone/my_voice */
-  voice_source?: string
-  /** 口播语言 */
-  language?: string
 }
 
 /** 旧分镜片段结构（保留兼容；新代码请使用 ShotScript） */

apps/web/src/components/layout/PageHead/constants.ts

@@ -8,6 +8,11 @@ export const ROUTE_TITLE_MAP: Record<string, string> = {
   "/app/products": "成片库",
   "/app/templates": "模板库",
   "/app/history": "任务历史",
+  "/app/admin": "控制台",
+  "/app/admin/users": "用户管理",
+  "/app/admin/analytics": "数据分析",
+  "/app/admin/monitor": "系统监控",
+  "/app/admin/logs": "系统日志",
   "/app/subscription": "订阅管理",
   "/app/subscription/upgrade": "升级订阅",
   "/app/subscription/billing": "账单管理",

apps/web/src/config/navigation.ts

@@ -13,6 +13,7 @@ import {
   HistoryOutlined,
   TrophyOutlined,
   ScanOutlined,
+  ControlOutlined,
   CrownOutlined,
   ThunderboltOutlined,
   UnorderedListOutlined,
@@ -206,6 +207,12 @@ export const NAV_GROUPS: NavGroup[] = [
         path: "/app/duplication",
         icon: React.createElement(ScanOutlined),
       },
+      {
+        key: "admin",
+        label: "控制台",
+        path: "/app/admin",
+        icon: React.createElement(ControlOutlined),
+      },
       {
         key: "subscription",
         label: "会员订阅",

apps/web/src/pages/admin/Admin.css

@@ -0,0 +1,27 @@
+/* Admin 页面样式（Phase 3 精简）
+ *
+ * 原始 477 行 → 精简至仅保留实际使用的 class。
+ * 已迁移至 global.css / ui.css 的样式不再重复定义：
+ *   .xx-page-head       → global.css
+ *   .xx-primary-btn     → global.css
+ *   .xx-tag / .xx-card  → ui.css / global.css
+ *
+ * 以下 class 仅被 AdminComingSoon.tsx 使用。
+ */
+
+.admin-coming-soon-page {
+  padding: 32px;
+  max-width: 1680px;
+  margin: 0 auto;
+}
+
+.xx-result-center {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  min-height: 400px;
+}
+
+.xx-result-center .ant-result {
+  padding: 48px;
+}

apps/web/src/pages/admin/AdminComingSoon.tsx

@@ -0,0 +1,35 @@
+import React from "react"
+import { Button, Card, Result } from "antd"
+import { useNavigate } from "react-router-dom"
+import "./Admin.css"
+
+const AdminComingSoon: React.FC = () => {
+  const navigate = useNavigate()
+
+  return (
+    <div className="admin-coming-soon-page">
+      <div className="xx-result-center">
+        <Card className="xx-card">
+          <Result
+            status="info"
+            title="Admin 后台暂未开放"
+            subTitle="当前版本未接入后台用户、监控、日志、分析等后端服务，因此不展示模拟运营数据，也不会提供假操作入口。"
+            extra={[
+              <Button
+                type="primary"
+                onClick={() => navigate("/app/dashboard")}
+                className="xx-primary-btn"
+              >
+                返回首页
+              </Button>,
+            ]}
+          />
+        </Card>
+      </div>
+    </div>
+  )
+}
+
+export default AdminComingSoon
+
+export const Component = AdminComingSoon

apps/web/src/pages/admin/DittoEmotionConfig.tsx

@@ -0,0 +1,311 @@
+import React, { useEffect, useMemo, useState } from "react"
+import {
+  Alert,
+  Button,
+  Card,
+  Form,
+  Input,
+  InputNumber,
+  Modal,
+  Select,
+  Slider,
+  Space,
+  Spin,
+  Switch,
+  message,
+} from "antd"
+import {
+  clearAdminApiKey,
+  fetchConfig,
+  getAdminApiKey,
+  setAdminApiKey,
+  testConfig,
+  updateConfig,
+  type ConfigItem,
+} from "@/api/admin/dittoEmotion"
+import "./Admin.css"
+
+const EMO_LABELS: Record<number, string> = {
+  3: "开心",
+  4: "中性",
+  5: "伤心",
+  6: "惊讶",
+}
+
+const DittoEmotionConfig: React.FC = () => {
+  const [hasKey, setHasKey] = useState<boolean>(!!getAdminApiKey())
+  const [keyInput, setKeyInput] = useState<string>("")
+  const [loading, setLoading] = useState<boolean>(false)
+  const [saving, setSaving] = useState<boolean>(false)
+  const [testing, setTesting] = useState<boolean>(false)
+  const [items, setItems] = useState<ConfigItem[]>([])
+  const [modelOptions, setModelOptions] = useState<string[]>([])
+  const [testResult, setTestResult] = useState<string>("")
+  const [form] = Form.useForm()
+
+  const [testInput, setTestInput] = useState<string>("")
+
+  const load = React.useCallback(async () => {
+    setLoading(true)
+    try {
+      const configs = await fetchConfig()
+      setItems(configs)
+      const values: Record<string, unknown> = {}
+      configs.forEach((c) => {
+        values[c.key] = c.value
+        if (c.model_options) setModelOptions(c.model_options)
+      })
+      form.setFieldsValue(values)
+    } catch {
+      // 401/403 等 → 提示 key 可能无效
+      message.error("加载配置失败，请检查 X-API-Key 是否正确")
+    } finally {
+      setLoading(false)
+    }
+  }, [form])
+
+  useEffect(() => {
+    if (hasKey) {
+      void load()
+    }
+  }, [hasKey, load])
+
+  const defaults = useMemo(() => {
+    const m: Record<string, unknown> = {}
+    items.forEach((c) => {
+      m[c.key] = c.default
+    })
+    return m
+  }, [items])
+
+  const submitKey = () => {
+    if (!keyInput.trim()) {
+      message.warning("请输入 X-API-Key")
+      return
+    }
+    setAdminApiKey(keyInput.trim())
+    setHasKey(true)
+  }
+
+  const changeKey = () => {
+    clearAdminApiKey()
+    setHasKey(false)
+    setKeyInput("")
+  }
+
+  const resetDefaults = () => {
+    form.setFieldsValue(defaults)
+    message.info("已填入默认值，点击「保存配置」后生效")
+  }
+
+  const validateBeforeSave = async (): Promise<Record<string, unknown> | null> => {
+    try {
+      const values = await form.validateFields()
+      const prompt = (values.ditto_emotion_prompt || "") as string
+      if (prompt.trim() && !prompt.includes("{文案}")) {
+        message.error("提示词必须包含 {文案} 占位符")
+        return null
+      }
+      return values as Record<string, unknown>
+    } catch {
+      return null
+    }
+  }
+
+  const onSave = async () => {
+    const values = await validateBeforeSave()
+    if (!values) return
+    setSaving(true)
+    try {
+      const res = await updateConfig(values)
+      if (res.ok) {
+        message.success("配置已保存并立即生效")
+        await load()
+      } else {
+        message.error(res.error || "保存失败")
+      }
+    } catch {
+      message.error("保存失败，请检查网络或 X-API-Key")
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  const onTest = async () => {
+    const testText = (testInput || "").trim()
+    if (!testText) {
+      message.warning("请先在下方输入测试文案")
+      return
+    }
+    setTesting(true)
+    setTestResult("")
+    try {
+      const res = await testConfig(testText)
+      if (!res.ok) {
+        message.error(res.error || "测试失败")
+      } else if (!res.enabled) {
+        message.info("当前表情开关为关闭状态，无情绪结果，可先开启后再测")
+      } else {
+        const lines = (res.segments || []).map(
+          (s) => `【${EMO_LABELS[s.emo] ?? s.emo} ${s.intensity}】${s.text}`,
+        )
+        setTestResult(lines.join("\n") || "未解析到情绪结果")
+      }
+    } catch {
+      message.error("测试失败，请检查网络或 X-API-Key")
+    } finally {
+      setTesting(false)
+    }
+  }
+
+  if (!hasKey) {
+    return (
+      <div className="admin-coming-soon-page">
+        <Modal
+          title="请输入后台 X-API-Key"
+          open
+          closable={false}
+          footer={[
+            <Button type="primary" key="ok" onClick={submitKey}>
+              确认
+            </Button>,
+          ]}
+        >
+          <Alert
+            type="info"
+            showIcon
+            style={{ marginBottom: 12 }}
+            message="Key 仅保存在本机浏览器 localStorage，用于后台接口鉴权（X-API-Key）。"
+          />
+          <Input.Password
+            autoFocus
+            placeholder="X-API-Key"
+            value={keyInput}
+            onChange={(e) => setKeyInput(e.target.value)}
+            onPressEnter={submitKey}
+          />
+        </Modal>
+      </div>
+    )
+  }
+
+  return (
+    <div className="admin-coming-soon-page">
+      <div style={{ maxWidth: 860, width: "100%" }}>
+        <Card
+          title="Ditto 数字人表情设置"
+          extra={
+            <Button size="small" onClick={changeKey}>
+              更换 X-API-Key
+            </Button>
+          }
+          className="xx-card"
+        >
+          <Alert
+            type="success"
+            showIcon
+            style={{ marginBottom: 16 }}
+            message="修改保存后立即生效，无需重启或发版。"
+            action={
+              <Button size="small" onClick={resetDefaults}>
+                重置默认
+              </Button>
+            }
+          />
+
+          <Spin spinning={loading}>
+            <Form form={form} layout="vertical">
+              <Form.Item
+                name="ditto_emotion_enabled"
+                label="启用 LLM 情绪分析"
+                valuePropName="checked"
+                extra="关闭后立即回退到原有关键词匹配模式，不影响正常出片。"
+              >
+                <Switch />
+              </Form.Item>
+
+              <Form.Item
+                name="ditto_emotion_model"
+                label="情绪分析模型"
+                rules={[{ required: true, message: "请选择模型" }]}
+              >
+                <Select
+                  options={(modelOptions.length ? modelOptions : []).map((m) => ({
+                    label: m,
+                    value: m,
+                  }))}
+                />
+              </Form.Item>
+
+              <Form.Item name="ditto_emotion_temperature" label="温度（0-1，越低越稳定）">
+                <Space style={{ width: "100%" }} align="center">
+                  <Slider min={0} max={1} step={0.1} style={{ width: 320 }} />
+                  <InputNumber min={0} max={1} step={0.1} />
+                </Space>
+              </Form.Item>
+
+              <Form.Item
+                name="ditto_emotion_prompt"
+                label="情绪分析提示词（必须包含 {文案} 占位符）"
+                rules={[
+                  {
+                    validator: (_, value) =>
+                      !value || !String(value).trim() || String(value).includes("{文案}")
+                        ? Promise.resolve()
+                        : Promise.reject(new Error("必须包含 {文案} 占位符")),
+                  },
+                ]}
+              >
+                <Input.TextArea
+                  rows={15}
+                  placeholder="留空则使用系统默认提示词"
+                  style={{ fontFamily: "monospace" }}
+                />
+              </Form.Item>
+
+              <Form.Item
+                name="ditto_blend_frames"
+                label="表情过渡帧数（6-30，越大越柔和）"
+                rules={[{ required: true, message: "请输入过渡帧数" }]}
+              >
+                <InputNumber min={6} max={30} step={1} precision={0} />
+              </Form.Item>
+            </Form>
+
+            <Space style={{ marginTop: 8 }}>
+              <Button type="primary" loading={saving} onClick={onSave}>
+                保存配置
+              </Button>
+            </Space>
+          </Spin>
+        </Card>
+
+        <Card title="配置测试" className="xx-card" style={{ marginTop: 16 }}>
+          <Input.TextArea
+            rows={3}
+            placeholder="输入测试文案，例如：这款面膜超级好用！今天补水效果太棒了。"
+            value={testInput}
+            onChange={(e) => setTestInput(e.target.value)}
+          />
+          <Space style={{ marginTop: 12 }}>
+            <Button loading={testing} onClick={onTest}>
+              用当前配置测试
+            </Button>
+          </Space>
+          {testResult && (
+            <Input.TextArea
+              readOnly
+              rows={6}
+              value={testResult}
+              style={{ marginTop: 12, fontFamily: "monospace", whiteSpace: "pre-wrap" }}
+            />
+          )}
+        </Card>
+      </div>
+    </div>
+  )
+}
+
+export default DittoEmotionConfig
+
+export const Component = DittoEmotionConfig

apps/web/src/pages/ai-avatar/AiAvatarPage.tsx

@@ -28,7 +28,6 @@ import {
   generateRenderSmartCover,
   finalizeRenderJob,
 } from "./api/aiAvatar"
-import { uploadAssetDirect } from "@/api/assets"
 import { getOrCreateDefaultProject } from "@/api/projects"
 import type { RenderJob, SentenceTiming } from "./types"
 import { buildTitleConfigPayload, buildCoverConfigPayload } from "./utils/contract"
@@ -532,7 +531,7 @@ const AiAvatarPage: React.FC = () => {
     setShowCoverModal(false)
   }, [])
 
-  /* ── 自定义上传封面：本地预览 + 保存 File 引用，点完成时直传 OSS 再 finalize ── */
+  /* ── 自定义上传封面（本地预览，不单独上传；点完成时一起入库） ── */
   const handleUploadCover = useCallback(
     (file: File) => {
       const url = URL.createObjectURL(file)
@@ -541,15 +540,13 @@ const AiAvatarPage: React.FC = () => {
         mode: "upload",
         upload_url: url,
         thumbnail_url: url,
-        smart_cover_url: null,
-        upload_file: file,
       }))
       setSelectedCoverUrl(url)
     },
     [state],
   )
 
-  /* ── 点「完成」：本地上传封面先直传 OSS，再调 finalize 入库成片库 ── */
+  /* ── 点「完成」：调用 finalize 入库成片库，成功后跳转到成片库 ── */
   const handleFinalize = useCallback(async () => {
     if (!currentRenderJob?.id) {
       message.error("渲染任务不存在")
@@ -559,35 +556,9 @@ const AiAvatarPage: React.FC = () => {
       message.warning("请先完成视频生成")
       return
     }
-    const { coverConfig } = state
-    const hasSmartCover = !!coverConfig.smart_cover_url
-    const hasLocalUpload = coverConfig.mode === "upload" && !!coverConfig.upload_file
     setFinalizeLoading(true)
     try {
-      // 本地上传封面：先走 OSS 直传拿到公网 URL（智能封面已由 /smart-cover 后端上传 OSS，无需重复传；
-      // 两种都没选则不传 cover_url，后端 finalize 兜底自动抽帧）
-      let finalCoverUrl: string | undefined
-      if (hasSmartCover) {
-        finalCoverUrl = coverConfig.smart_cover_url!
-      } else if (hasLocalUpload && coverConfig.upload_file) {
-        const hide = message.loading("正在上传封面...", 0)
-        try {
-          const result = await uploadAssetDirect({
-            file: coverConfig.upload_file,
-            kind: "image",
-          })
-          finalCoverUrl = result.url || undefined
-          if (!finalCoverUrl) {
-            message.warning("封面上传未返回URL，将使用视频首帧作为封面")
-          }
-        } finally {
-          hide()
-        }
-      }
-      const res = await finalizeRenderJob(
-        currentRenderJob.id,
-        finalCoverUrl ? { cover_url: finalCoverUrl } : undefined,
-      )
+      const res = await finalizeRenderJob(currentRenderJob.id)
       if (res.data?.status === "success" || res.data?.status === "already_finalized") {
         message.success("已保存到成片库")
         navigate("/app/products")
@@ -603,7 +574,7 @@ const AiAvatarPage: React.FC = () => {
     } finally {
       setFinalizeLoading(false)
     }
-  }, [currentRenderJob, navigate, state])
+  }, [currentRenderJob, navigate])
 
   /* ── 配置汇总 ── */
   const coverStatus: "not_ready" | "pending" | "selected" = (() => {

apps/web/src/pages/ai-avatar/api/aiAvatar.ts

@@ -119,12 +119,8 @@ export const generateRenderSmartCover = async (
   return response.data
 }
 
-/* ── 封面选定后点「完成」正式入库（POST /ai-avatar/render/{job_id}/finalize）
- * 后端契约：body 支持可选 cover_url（OSS 公网 URL，智能封面已经由后端/smart-cover 写入则不传）
- */
-export const finalizeRenderJob = (renderId: string, payload?: { cover_url?: string }) =>
+/* ── 封面选定后点「完成」正式入库（POST /ai-avatar/render/{job_id}/finalize） ── */
+export const finalizeRenderJob = (renderId: string) =>
   apiClient.post<{ video_id: string; cover_url: string; status: string }>(
     `/ai-avatar/render/${renderId}/finalize`,
-    payload ?? {},
-    { timeout: 120_000 }, // 后端兜底抽帧/写入成片库可能耗时较长
   )

apps/web/src/pages/ai-avatar/components/ModalCoverSelect.tsx

@@ -73,8 +73,6 @@ const ModalCoverSelect: React.FC<ModalCoverSelectProps> = ({
             mode: "auto_frame",
             thumbnail_url: coverUrl,
             smart_cover_url: coverUrl,
-            upload_url: null,
-            upload_file: null,
           })
           onCoverSelected(coverUrl)
           message.success("智能封面已生成")
@@ -115,7 +113,6 @@ const ModalCoverSelect: React.FC<ModalCoverSelectProps> = ({
           mode: "upload",
           upload_url: url,
           thumbnail_url: url,
-          smart_cover_url: null,
         })
         onCoverSelected(url)
       }

apps/web/src/pages/ai-avatar/types.ts

@@ -162,8 +162,6 @@ export interface AiAvatarCoverConfig {
   thumbnail_url: string | null
   /** 智能封面（MediaKit 选帧）返回的 OSS 非临时 URL（#1822） */
   smart_cover_url: string | null
-  /** 本地上传封面时保存的原始 File 对象，finalize 时先直传 OSS 再带公网 URL */
-  upload_file?: File | null
 }
 
 /* ── 渲染任务 ── */
@@ -217,5 +215,4 @@ export const DEFAULT_COVER_CONFIG: AiAvatarCoverConfig = {
   upload_url: null,
   thumbnail_url: null,
   smart_cover_url: null,
-  upload_file: null,
 }

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

@@ -38,8 +38,6 @@ const GeneratePage: React.FC = () => {
 
   /* ── 积分状态 ── */
   const { balance, dailyUsage, rules, init: initPoints } = usePointsStore()
-  // 后端积分总开关（由 /points/balance 返回；数据未就绪时保守按 UI 开关处理）
-  const creditsEnabled = balance?.credits_enabled ?? ENABLE_CREDIT_SYSTEM
   useEffect(() => {
     initPoints()
   }, [initPoints])
@@ -344,8 +342,7 @@ const GeneratePage: React.FC = () => {
   const handleConfirmGenerate = useCallback(async () => {
     // 积分预检查（积分系统关闭时跳过，直接走生成流程）
     let check: ReturnType<typeof hasEnoughPoints> = { sufficient: true, cost: 0 }
-    // 仅当后端积分系统真实启用时才做余额预校验（后端免费放行时前端不得拦截）
-    if (creditsEnabled) {
+    if (ENABLE_CREDIT_SYSTEM) {
       const units = isBatch ? Math.max(selectedVariantIds.length, 1) : 1
       check = hasEnoughPoints(
         balance ?? null,
@@ -391,7 +388,6 @@ const GeneratePage: React.FC = () => {
     balance,
     dailyUsage,
     rules,
-    creditsEnabled,
   ])
 
   /* ── 步骤导航 ── */
@@ -506,7 +502,7 @@ const GeneratePage: React.FC = () => {
   /* ── 积分消耗估算（步骤3确认生成展示用） ── */
   const unitsForCost = isBatch ? Math.max(selectedVariantIds.length, 1) : 1
   const pointsEstimate = useMemo(() => {
-    if (!creditsEnabled) return { sufficient: true, cost: 0 }
+    if (!ENABLE_CREDIT_SYSTEM) return { sufficient: true, cost: 0 }
     return hasEnoughPoints(
       balance ?? null,
       unitsForCost,
@@ -515,8 +511,8 @@ const GeneratePage: React.FC = () => {
       "free",
       rules?.free_user_multiplier ?? 1.15,
     )
-  }, [unitsForCost, balance, dailyUsage, rules, creditsEnabled])
-  const insufficientPoints = creditsEnabled && !pointsEstimate.sufficient
+  }, [unitsForCost, balance, dailyUsage, rules])
+  const insufficientPoints = ENABLE_CREDIT_SYSTEM && !pointsEstimate.sufficient
 
   /* ================================================================
      渲染

apps/web/src/pages/viral-video/ViralVideoPage.constants.ts

@@ -1,128 +0,0 @@
-import type { ViralVideoModel } from "@/api/viral-video/types"
-
-export const LANGUAGES = ["中文(普通话)", "粤语", "英语", "日语", "韩语"]
-export const TARGET_CUSTOMERS = [
-  "小镇青年",
-  "小镇中老年",
-  "Z世代",
-  "精致妈妈",
-  "新锐白领",
-  "资深中产",
-  "都市蓝领",
-  "都市银发",
-]
-export const PERSONAS = [
-  "通用个人IP",
-  "老板型IP",
-  "专家型IP",
-  "顾问型IP",
-  "创始人IP",
-  "创业者IP",
-  "从业者经验派",
-  "避坑顾问型",
-  "知识科普型",
-  "测评种草型",
-]
-export const STRUCTURES = [
-  "反差破局+亮明观点+还原现状",
-  "痛点场景植入+给出通关秘籍",
-  "反常识开场+扎心现状+制造焦虑",
-  "核心难题+化解焦虑+描绘愿景",
-  "痛点前置+前后对比+给出期许",
-  "悬念拉满+揭露危害+明确目的",
-  "情绪共鸣+勾起好奇+拔高价值",
-  "颠覆认知+现状拆解+赋予价值",
-  "结果先行+消除顾虑+保留悬念",
-  "真实困境+认知反转+传授秘籍",
-  "反差事实+案例佐证+戳破真相",
-  "预埋悬念+标杆案例+引出核心",
-  "危机渲染+放大痛点+输出干货",
-  "逆袭开场+成功诀窍+低价引流",
-  "反常识观点+分析危害+描述现状",
-  "正反对比+解析原因+简易方法",
-  "真实场景+内心刻画+共情引导+展望未来",
-  "连续否定+代入感受+打破认知+精准戳痛",
-  "揭秘行业+类比施压+放大焦虑+精准锁客",
-]
-export const PURPOSES = [
-  "获客引流",
-  "账号涨粉",
-  "活动通知",
-  "口播带货",
-  "促销转化",
-  "场景种草",
-  "痛点解决",
-  "功能演示",
-  "门店发现",
-  "到店实录",
-  "招牌体验",
-  "同城团购",
-  "品牌主张",
-  "品牌故事",
-  "生活方式",
-  "创意概念",
-  "对话短剧",
-  "反转短剧",
-  "悬念短剧",
-  "情绪短片",
-]
-export const RATIOS = [
-  { v: "9:16", label: "9:16 竖屏（抖音/视频号）" },
-  { v: "16:9", label: "16:9 横屏（B站/YouTube）" },
-  { v: "1:1", label: "1:1 方形（小红书）" },
-]
-export const DURATIONS = Array.from({ length: 16 }, (_, i) => 15 + i)
-/** 兜底模型列表（接口未返回时使用） */
-export const FALLBACK_VIDEO_MODELS: ViralVideoModel[] = [
-  {
-    key: "seedance-2.5",
-    display_name: "Seedance 2.5 — 最新最强",
-    supports_audio: true,
-    supported_resolutions: ["480p", "720p", "1080p"],
-    max_duration: 30,
-    is_default: true,
-  },
-  {
-    key: "seedance-2.0",
-    display_name: "Seedance 2.0 — 正式首选",
-    supports_audio: true,
-    supported_resolutions: ["480p", "720p", "1080p"],
-    max_duration: 15,
-  },
-  {
-    key: "seedance-2.0-fast",
-    display_name: "Seedance 2.0 Fast — 快速测试",
-    supports_audio: true,
-    supported_resolutions: ["480p", "720p"],
-    max_duration: 15,
-  },
-  {
-    key: "seedance-2.0-mini",
-    display_name: "Seedance 2.0 Mini — 低成本",
-    supports_audio: true,
-    supported_resolutions: ["480p", "720p"],
-    max_duration: 15,
-  },
-  {
-    key: "wan-3.0",
-    display_name: "Wan 3.0 — 通义万相全能",
-    supports_audio: true,
-    supported_resolutions: ["480p", "720p", "1080p"],
-    max_duration: 15,
-  },
-]
-export const RESOLUTION_ORDER = ["480p", "720p", "1080p", "4k"]
-export const QUALITY_OPTIONS = [
-  { v: "480p", label: "480p（快速）" },
-  { v: "720p", label: "720p（清晰）" },
-  { v: "1080p", label: "1080p（高清）" },
-]
-export const UPSCALE_OPTIONS = [
-  { v: "default", label: "默认" },
-  { v: "sd", label: "普清" },
-  { v: "hd", label: "高清" },
-  { v: "uhd", label: "超清" },
-  { v: "omnipotent", label: "全能" },
-]
-export const VOICE_TIPS =
-  "支持 MP3/WAV/M4A/AAC/OGG 格式，最大 10MB，时长 ≤30 秒。建议清晰人声、无背景音乐、环境安静；录音请保持距麦克风 15-20cm，音量适中。"

apps/web/src/pages/viral-video/ViralVideoPage.css

@@ -138,6 +138,27 @@
   border-radius: 12px;
   overflow: hidden;
 }
+.vv-section-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 14px 16px;
+  cursor: pointer;
+  user-select: none;
+  border-bottom: 1px solid #f0f0f5;
+  gap: 8px;
+}
+.vv-section.collapsed .vv-section-head {
+  border-bottom: none;
+}
+.vv-section-title {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 15px;
+  font-weight: 600;
+  color: #1f2937;
+}
 .vv-step-badge {
   width: 22px;
   height: 22px;
@@ -289,6 +310,11 @@
 
 /* antd Select dropdown light */
 .vv-page .ant-select-dropdown,
+.vv-select-dropdown {
+  background: #fff !important;
+  border-radius: 8px !important;
+  padding: 4px !important;
+}
 .vv-page .ant-select-item {
   color: #1f2937 !important;
   border-radius: 6px !important;
@@ -629,6 +655,10 @@
   margin-left: auto;
 }
 
+.vv-douyin-input {
+  margin-bottom: 8px;
+}
+
 .vv-ref-video-box {
   margin-top: 8px;
 }
@@ -639,6 +669,44 @@
   max-height: 200px;
 }
 
+.vv-audio-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 8px;
+}
+.vv-audio-cell {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  padding: 14px 8px;
+  background: #fff;
+  border: 1px solid #e0e0e8;
+  border-radius: 8px;
+  color: #6b7280;
+  font-size: 12px;
+  cursor: pointer;
+  transition: all 0.15s;
+}
+.vv-audio-cell:hover:not(:disabled) {
+  border-color: #7c3aed;
+  color: #7c3aed;
+}
+.vv-audio-cell.selected,
+.vv-audio-cell.active {
+  background: #f5f0ff;
+  border-color: #7c3aed;
+  color: #7c3aed;
+}
+.vv-audio-cell:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+.vv-audio-ic {
+  font-size: 20px;
+}
+
 .vv-selected-audio {
   display: flex;
   align-items: center;
@@ -789,6 +857,12 @@
   color: #6b7280;
   flex-shrink: 0;
 }
+.vv-recog-v {
+  color: #1f2937;
+}
+.vv-recog-meta {
+  color: #9ca3af;
+}
 
 /* progress mini */
 .vv-progress-mini-inline {
@@ -928,6 +1002,11 @@
 .vv-form-row {
   margin-bottom: 10px;
 }
+.vv-form-hint {
+  font-size: 12px;
+  color: #9ca3af;
+  line-height: 1.4;
+}
 @media (max-width: 500px) {
   .vv-form-grid {
     grid-template-columns: 1fr;
@@ -941,11 +1020,29 @@
   border-radius: 10px;
   padding: 10px 12px;
   margin-top: 8px;
+}
+.vv-copy-head {
   display: flex;
-  flex-direction: column;
-  flex: 1 1 auto;
-  min-height: 260px;
-  overflow: hidden;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 12px;
+}
+.vv-copy-title {
+  font-size: 14px;
+  font-weight: 600;
+  color: #1f2937;
+}
+.vv-copy-tag {
+  font-size: 11px;
+  padding: 2px 8px;
+  border-radius: 10px;
+  font-weight: 400;
+}
+.vv-copy-tag-preview {
+  background: #fef3c7;
+  color: #b45309;
+  border: 1px solid #fcd34d;
+  margin-left: auto;
 }
 
 .vv-copy-loading {
@@ -953,8 +1050,7 @@
   flex-direction: column;
   align-items: center;
   justify-content: center;
-  flex: 1 1 auto;
-  min-height: 260px;
+  height: 360px;
   padding: 28px 16px;
   gap: 10px;
   background: #fff;
@@ -978,12 +1074,20 @@
   color: #6b7280;
 }
 
+.vv-copy-locked {
+  background: #fafafe;
+  border-color: #d8cafc;
+}
+.vv-copy-sub {
+  font-size: 12px;
+  color: #6b7280;
+}
+
 /* ── Storyboard (linear doc style) ── */
 .vv-storyboard {
   display: flex;
   flex-direction: column;
-  flex: 1 1 auto;
-  min-height: 260px;
+  height: 360px;
   padding: 10px 12px;
   background: #fff;
   border: 1px solid #e5e7eb;
@@ -1336,8 +1440,7 @@
 /* ── Preview ──────────────── */
 .vv-preview {
   aspect-ratio: 9 / 16;
-  max-height: 100%;
-  max-width: 100%;
+  max-height: 360px;
   background: #fff;
   border: 1px dashed #e5e7eb;
   border-radius: 10px;
@@ -1678,10 +1781,84 @@
 }
 
 /* intent (keyword chips) - if used */
+.vv-intent {
+  margin-top: 10px;
+}
+.vv-intent-title {
+  font-size: 12px;
+  color: #6b7280;
+  margin-bottom: 6px;
+}
+.vv-intent-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+.vv-chip {
+  padding: 4px 10px;
+  background: #fff;
+  border: 1px solid #e0e0e8;
+  border-radius: 14px;
+  font-size: 12px;
+  color: #374151;
+  cursor: pointer;
+}
+.vv-chip.picked {
+  background: #f5f0ff;
+  color: #7c3aed;
+  border-color: #7c3aed;
+}
 
 /* misc helpers */
+.vv-k {
+  color: #6b7280;
+}
+.vv-v {
+  color: #1f2937;
+}
+.vv-hint-yellow {
+  background: #fef3c7;
+  border: 1px solid #fcd34d;
+  color: #b45309;
+  font-size: 12px;
+  padding: 8px;
+  border-radius: 6px;
+  line-height: 1.6;
+  margin-top: 8px;
+}
+.vv-hint-gray {
+  color: #9ca3af;
+  font-size: 12px;
+}
 
 /* Segmented tabs (legacy) */
+.vv-seg-tabs {
+  display: inline-flex;
+  background: #f5f6fa;
+  border: 1px solid #e5e7eb;
+  border-radius: 8px;
+  padding: 3px;
+  gap: 2px;
+}
+.vv-seg-tab {
+  padding: 6px 14px;
+  border-radius: 6px;
+  background: #fff;
+  border: none;
+  color: #6b7280;
+  font-size: 12px;
+  cursor: pointer;
+  transition: all 0.15s;
+}
+.vv-seg-tab:hover {
+  color: #374151;
+  background: #fff;
+}
+.vv-seg-tab.active {
+  background: #f3f0ff;
+  color: #7c3aed;
+  font-weight: 500;
+}
 
 /* ── v1.6 我的音色（默认主路径） ── */
 .vv-voice-section {
@@ -1892,289 +2069,3 @@
   border-top: 1px solid #e5e7eb;
   margin: 12px 0;
 }
-
-/* ── 分镜脚本流式预览（WebSocket delta 实时输出） ── */
-.vv-streaming-box {
-  outline: 2px solid #ede9fe;
-  background: linear-gradient(180deg, #fafafe 0%, #ffffff 100%);
-}
-.vv-streaming-header {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  padding: 4px 0 10px 0;
-  border-bottom: 1px dashed #ede9fe;
-  margin-bottom: 8px;
-  flex-shrink: 0;
-}
-.vv-streaming-title {
-  font-size: 13px;
-  color: #7c3aed;
-  font-weight: 500;
-  flex: 1 1 auto;
-}
-.vv-streaming-count {
-  font-size: 12px;
-  color: #9ca3af;
-  background: #f5f0ff;
-  padding: 1px 8px;
-  border-radius: 10px;
-}
-.vv-streaming-doc {
-  flex: 1 1 auto;
-  overflow-y: auto;
-  padding: 4px 2px 8px 2px;
-  /* 复用 vv-sb-doc 的滚动条样式 */
-  scrollbar-width: thin;
-  scrollbar-color: #d8c4ff transparent;
-}
-.vv-streaming-doc::-webkit-scrollbar {
-  width: 6px;
-}
-.vv-streaming-doc::-webkit-scrollbar-thumb {
-  background: #d8c4ff;
-  border-radius: 3px;
-}
-.vv-streaming-pre {
-  margin: 0;
-  padding: 4px 6px;
-  white-space: pre-wrap;
-  word-break: break-word;
-  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, "Liberation Mono", monospace;
-  font-size: 13px;
-  line-height: 1.65;
-  color: #1f2937;
-  tab-size: 2;
-}
-.vv-streaming-caret {
-  display: inline-block;
-  width: 2px;
-  height: 14px;
-  background: #7c3aed;
-  vertical-align: middle;
-  margin-left: 2px;
-  animation: vv-caret-blink 1s steps(2, start) infinite;
-}
-@keyframes vv-caret-blink {
-  to {
-    visibility: hidden;
-  }
-}
-.vv-streaming-actions {
-  flex-shrink: 0;
-  background: #fff;
-  padding-top: 8px;
-  border-top: 1px solid #f3f4f6;
-}
-.vv-streaming-hint {
-  font-size: 12px;
-  color: #9ca3af;
-}
-
-/* ── 三列等高布局（2026-10-10 fix） ──
- * vv-page 作为纵向 flex 容器，tabs 固定 + grid 占满剩余高度；
- * vv-grid 改用 grid-auto-rows:1fr 强制三列等高；
- * 每列的卡片使用 flex column + min-height:0，正文区域 flex:1 并内部滚动。
- */
-.vv-page {
-  display: flex;
-  flex-direction: column;
-  /* 减去顶部导航 56px 和自身 padding 16*2=32px，给 Tabs + 三列区留一屏 */
-  height: calc(100vh - 56px);
-  min-height: 640px; /* 小窗口保底 */
-  overflow: hidden;
-}
-.vv-tabs {
-  flex-shrink: 0;
-}
-.vv-grid {
-  flex: 1 1 auto;
-  min-height: 0;
-  align-items: stretch; /* 覆盖原来的 start，强制行内格子撑满行高 */
-  grid-auto-rows: 1fr; /* 每行所有格子等高 */
-  overflow: hidden;
-}
-.vv-col {
-  display: flex;
-  flex-direction: column;
-  gap: 12px;
-  min-height: 0;
-  min-width: 0;
-}
-/* 列内的卡片（.vv-section）默认允许收缩，正文区域接管滚动 */
-.vv-col > .vv-section {
-  display: flex;
-  flex-direction: column;
-  min-height: 0;
-  flex-shrink: 1;
-}
-/* STEP1/STEP2 唯一卡片：撑满列高 */
-.vv-col > .vv-section:only-child {
-  flex: 1 1 auto;
-}
-/* STEP3 右侧两卡片：配置固定不缩，预览区吸剩余空间 */
-.vv-col > .vv-section-preview {
-  flex: 1 1 auto;
-  min-height: 0;
-}
-.vv-section-preview .vv-section-body.vv-preview-body {
-  flex: 1 1 auto;
-  min-height: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding: 12px;
-  overflow: hidden;
-}
-.vv-section-preview .vv-preview {
-  max-height: 100%;
-  height: 100%;
-  aspect-ratio: auto;
-  width: 100%;
-}
-
-/* 列内 .vv-credits / .vv-error / 主按钮 不参与收缩，永远固定在底部可见 */
-.vv-col > .vv-credits,
-.vv-col > .vv-error,
-.vv-col > .vv-btn-primary {
-  flex-shrink: 0;
-}
-.vv-col > .vv-credits {
-  margin-top: 0;
-}
-
-/* 可滚动 section 正文 */
-.vv-section-body.vv-section-body-scroll {
-  flex: 1 1 auto;
-  min-height: 0;
-  display: flex;
-  flex-direction: column;
-  padding: 14px 16px 14px;
-  overflow: hidden;
-}
-.vv-scroll-inner {
-  flex: 1 1 auto;
-  min-height: 0;
-  overflow-y: auto;
-  padding-right: 6px;
-  display: flex;
-  flex-direction: column;
-  /* 美化滚动条（紫白主题） */
-  scrollbar-width: thin;
-  scrollbar-color: #d8c4ff transparent;
-}
-.vv-scroll-inner::-webkit-scrollbar {
-  width: 6px;
-}
-.vv-scroll-inner::-webkit-scrollbar-thumb {
-  background: #d8c4ff;
-  border-radius: 3px;
-}
-.vv-scroll-inner::-webkit-scrollbar-thumb:hover {
-  background: #c4a8ff;
-}
-.vv-scroll-inner::-webkit-scrollbar-track {
-  background: transparent;
-}
-
-/* 主按钮始终顶在 section-body 底部（在 vv-scroll-inner 之外） */
-.vv-section-body.vv-section-body-scroll > .vv-btn-primary {
-  margin-top: 10px;
-  flex-shrink: 0;
-}
-
-/* STEP1 文件列表改为根据可用空间自适应，不再用 max-height:260px 硬编码 */
-.vv-file-list {
-  max-height: none;
-}
-
-/* ── P2 新增 utility / 组件类 ── */
-/* 短剧模式提示条（放在 Step2 区域就地显示） */
-.vv-shortdrama-hint {
-  padding: 8px 12px;
-  margin-bottom: 8px;
-  background-color: #fff7e6;
-  border: 1px solid #ffd591;
-  border-radius: 4px;
-  font-size: 13px;
-  color: #d46b08;
-}
-
-/* speaker 标签（主角 / 配角） */
-.vv-sb-speaker-tag {
-  display: inline-block;
-  padding: 2px 8px;
-  margin: 0 8px;
-  border-radius: 4px;
-  font-size: 12px;
-  font-weight: 500;
-  vertical-align: middle;
-}
-.vv-sb-speaker-tag-main {
-  background-color: #e6f7ff;
-  color: #1890ff;
-}
-.vv-sb-speaker-tag-guest {
-  background-color: #fff7e6;
-  color: #fa8c16;
-}
-.vv-sb-speaker-main {
-  color: #1890ff;
-}
-.vv-sb-speaker-guest {
-  color: #fa8c16;
-}
-
-/* 间距 / 排版 helpers */
-.vv-mt-4 {
-  margin-top: 4px;
-}
-.vv-mt-6 {
-  margin-top: 6px;
-}
-.vv-mt-8 {
-  margin-top: 8px;
-}
-.vv-mb-6 {
-  margin-bottom: 6px;
-}
-.vv-mr-6 {
-  margin-right: 6px;
-}
-.vv-fs-12 {
-  font-size: 12px;
-}
-.vv-fs-13 {
-  font-size: 13px;
-}
-.vv-fs-22 {
-  font-size: 22px;
-}
-.vv-p-12 {
-  padding: 12px;
-}
-.vv-text-center {
-  text-align: center;
-}
-.vv-flex-1 {
-  flex: 1;
-}
-.vv-w-170 {
-  width: 170px;
-  flex: 0 0 auto;
-}
-
-.vv-inline-spinner {
-  margin-right: 6px;
-  display: inline-block;
-  vertical-align: middle;
-}
-
-.vv-progress-bar-sm {
-  margin: 6px 0 4px;
-}
-
-.vv-loading-ic {
-  font-size: 36px;
-  color: #7c3aed;
-}

apps/web/src/pages/viral-video/components/AssetPickerModal.tsx

@@ -152,7 +152,8 @@ export default function AssetPickerModal({
         <div className="vv-modal-body">
           <div className="vv-asset-search">
             <select
-              className="vv-input vv-w-170"
+              className="vv-input"
+              style={{ width: 170, flex: "0 0 auto" }}
               value={libraryId}
               onChange={(e) => setLibraryId(e.target.value)}
               disabled={loadingLibs || libraries.length === 0}
@@ -200,8 +201,8 @@ export default function AssetPickerModal({
               </div>
               {kind === "voice" ? (
                 <>
-                  <div className="vv-mt-8 vv-fs-13">暂无配音素材</div>
-                  <div className="vv-muted vv-mt-4 vv-fs-12">
+                  <div style={{ marginTop: 8, fontSize: 13 }}>暂无配音素材</div>
+                  <div style={{ marginTop: 4, fontSize: 12, color: "#9ca3af" }}>
                     请先在「配音/我的音色」中上传音频文件，或在素材库管理中添加
                   </div>
                 </>

apps/web/src/pages/viral-video/components/EmptyBlock.tsx

@@ -1,33 +0,0 @@
-import React from "react"
-
-export interface EmptyBlockProps {
-  icon?: React.ReactNode
-  title?: string
-  desc?: React.ReactNode
-  action?: React.ReactNode
-  className?: string
-  style?: React.CSSProperties
-}
-
-/**
- * 统一空态组件：icon + title + desc + action，避免散落的 vv-muted 空文案
- */
-export const EmptyBlock: React.FC<EmptyBlockProps> = ({
-  icon = "🎬",
-  title,
-  desc,
-  action,
-  className,
-  style,
-}) => {
-  return (
-    <div className={`vv-empty-block ${className || ""}`} style={style}>
-      <div className="vv-empty-icon">{icon}</div>
-      {title && <div className="vv-empty-title">{title}</div>}
-      {desc && <div className="vv-empty-desc vv-muted">{desc}</div>}
-      {action && <div className="vv-empty-action">{action}</div>}
-    </div>
-  )
-}
-
-export default EmptyBlock

apps/web/src/pages/viral-video/components/ErrorRetryBar.tsx

@@ -1,43 +0,0 @@
-import React from "react"
-import { WarningFilled, ReloadOutlined } from "@ant-design/icons"
-
-export interface ErrorRetryBarProps {
-  label?: string
-  message: string
-  onRetry?: () => void
-  retryText?: string
-  className?: string
-  style?: React.CSSProperties
-}
-
-/**
- * 统一错误条：警告图标 + 标签前缀 + 错误消息 + 可选重试按钮
- * 替换主页面里散落的 .vv-error 块
- */
-export const ErrorRetryBar: React.FC<ErrorRetryBarProps> = ({
-  label,
-  message,
-  onRetry,
-  retryText = "重试",
-  className,
-  style,
-}) => {
-  return (
-    <div className={`vv-error ${className || ""}`} style={style}>
-      <WarningFilled style={{ marginRight: 6 }} />
-      {label ? `${label}：` : ""}
-      {message}
-      {onRetry && (
-        <button
-          className="vv-btn vv-btn-warn vv-btn-sm"
-          style={{ marginLeft: 10 }}
-          onClick={onRetry}
-        >
-          <ReloadOutlined /> {retryText}
-        </button>
-      )}
-    </div>
-  )
-}
-
-export default ErrorRetryBar

apps/web/src/pages/viral-video/components/InlineEditTextarea.tsx

@@ -1,111 +0,0 @@
-import React, { useState, useRef, useEffect, useCallback } from "react"
-
-export interface InlineTextProps {
-  value: string
-  onChange?: (v: string) => void // 受控模式
-  onCommit: (v: string) => void // blur/Enter 提交
-  onCancel?: () => void
-  multiline?: boolean
-  textareaClass?: string
-  textClass?: string
-  placeholder?: string
-  editing: boolean
-  onStartEdit: () => void
-  rows?: number
-  maxLength?: number
-  disabled?: boolean
-}
-
-/**
- * 通用"点文字→textarea→blur/Enter保存→Esc取消"内联编辑组件
- * 替换 ViralVideoPage 里 11 处反射式 textarea/span 复制粘贴
- */
-export const InlineText: React.FC<InlineTextProps> = ({
-  value,
-  onChange,
-  onCommit,
-  onCancel,
-  multiline,
-  textareaClass,
-  textClass,
-  placeholder,
-  editing,
-  onStartEdit,
-  rows = 2,
-  maxLength,
-  disabled,
-}) => {
-  const taRef = useRef<HTMLTextAreaElement>(null)
-  const [local, setLocal] = useState(value)
-
-  useEffect(() => {
-    setLocal(value)
-  }, [value])
-
-  useEffect(() => {
-    if (editing && taRef.current) {
-      taRef.current.focus()
-      taRef.current.select()
-    }
-  }, [editing])
-
-  const commit = useCallback(() => {
-    const v = (onChange ? value : local).trim()
-    const cur = (value ?? "").trim()
-    if (v !== cur) onCommit(v)
-    else onCancel?.()
-  }, [local, value, onCommit, onCancel, onChange])
-
-  const handleKey = useCallback(
-    (e: React.KeyboardEvent) => {
-      if (e.key === "Escape") {
-        e.preventDefault()
-        onCancel?.()
-      }
-      if (!multiline && e.key === "Enter" && !e.shiftKey) {
-        e.preventDefault()
-        commit()
-      }
-    },
-    [multiline, commit, onCancel],
-  )
-
-  if (editing) {
-    return (
-      <textarea
-        ref={taRef}
-        className={textareaClass}
-        value={onChange ? value : local}
-        onChange={(e) => (onChange ? onChange(e.target.value) : setLocal(e.target.value))}
-        onBlur={commit}
-        onKeyDown={handleKey}
-        rows={rows}
-        maxLength={maxLength}
-        placeholder={placeholder}
-      />
-    )
-  }
-
-  const displayText = value || placeholder || "点击编辑"
-  const isPlaceholder = !value
-
-  return (
-    <span
-      className={`${textClass || ""} ${isPlaceholder ? "vv-inline-placeholder" : ""} ${
-        disabled ? "vv-inline-disabled" : ""
-      }`}
-      onClick={() => {
-        if (!disabled) onStartEdit()
-      }}
-      style={
-        isPlaceholder
-          ? { color: "#9ca3af", cursor: disabled ? "not-allowed" : "text" }
-          : { cursor: disabled ? "not-allowed" : "text" }
-      }
-    >
-      {displayText}
-    </span>
-  )
-}
-
-export default InlineText

apps/web/src/pages/viral-video/components/PresetVoicePickerModal.tsx

@@ -106,10 +106,10 @@ const CATEGORY_LABELS: Record<string, string> = {
 const GENDER_LABEL = (v: PresetVoice) => {
   if (v.gender_label) return v.gender_label
   const g = v.gender
-  if (g === "female") return "女声"
-  if (g === "male") return "男声"
-  if (g === "child") return "童声"
-  return "其他"
+  if (g === "female") return "女声·女声"
+  if (g === "male") return "男声·男声"
+  if (g === "child") return "童声·童声"
+  return "性别未标注·其他"
 }
 
 const AVATAR_BG = (gender?: string) => {
@@ -303,7 +303,7 @@ const PresetVoicePickerModal: React.FC<Props> = ({
                       {v.avatar_url ? (
                         <img src={v.avatar_url} alt={v.name} />
                       ) : (
-                        <UserOutlined className="vv-fs-22" />
+                        <UserOutlined style={{ fontSize: 22 }} />
                       )}
                     </div>
                     <div className="vv-voice-card-name" title={v.name}>

apps/web/src/pages/viral-video/components/Step1UploadPanel.tsx

@@ -1,315 +0,0 @@
-import React, { useMemo } from "react"
-import {
-  UploadOutlined,
-  FolderOpenOutlined,
-  ArrowUpOutlined,
-  ArrowDownOutlined,
-  CloseOutlined,
-} from "@ant-design/icons"
-import { VVSpinner } from "./VVSpinner"
-import { renderMarkdown } from "../utils/renderMarkdown"
-import { CheckCircleFilled } from "@ant-design/icons"
-import { VoicePickerSection } from "./VoicePickerSection"
-import type { UploadedImage, RefVideo, RefAudio, VoicePanel, ImageAnalysisResult } from "../types"
-import type { ImageProductAnalysis, StyleStrength } from "@/api/viral-video/types"
-import { STYLE_STRENGTHS } from "@/api/viral-video/types"
-import type { VoiceClone } from "@/api/voice-clone"
-import type { AssetItem } from "@/api/assets"
-
-export interface Step1UploadPanelProps {
-  images: UploadedImage[]
-  refVideo: RefVideo
-  voicePanel: VoicePanel
-  refAudio: RefAudio
-  voiceTipsOpen: boolean
-  myVoices: VoiceClone[]
-  myVoicesLoading: boolean
-  voiceAssets: { id: string; name: string; url: string; desc?: string }[]
-  playingVoiceId: string | null
-  styleStrength: StyleStrength
-  imageAnalysis: ImageAnalysisResult | null
-  isAnalyzing: boolean
-  analysisError?: string
-  canAnalyze: boolean
-  analyzeBtnText: React.ReactNode
-  // callbacks - images
-  onPickLocalImages: () => void
-  onPickAssetImages: () => void
-  onRemoveImage: (localId: string) => void
-  onMoveImage: (idx: number, dir: -1 | 1) => void
-  onClearImages: () => void
-  onImagesSelected: (files: FileList) => void
-  onAnalyze: () => void
-  // callbacks - ref video
-  onPickLocalVideo: () => void
-  onVideoSelected: (file: File) => void
-  onRemoveRefVideo: () => void
-  onStyleStrengthChange: (v: StyleStrength) => void
-  // callbacks - voice (delegated to VoicePickerSection)
-  onPickLocalAudio: () => void
-  onPickAssetAudio: () => void
-  onRemoveRefAudio: () => void
-  onToggleVoicePanel: (p: VoicePanel) => void
-  onSelectMyVoice: (v: VoiceClone) => void
-  onOpenCloneModal: () => void
-  onSelectVoiceAsset: (a: AssetItem) => void
-  onToggleVoicePlay: (v: { id: string; url: string }) => void
-  onVoiceSelected: (file: File) => void
-  onToggleVoiceTips: () => void
-  // refs
-  imgInputRef: React.Ref<HTMLInputElement>
-  videoInputRef: React.Ref<HTMLInputElement>
-  voiceInputRef: React.Ref<HTMLInputElement>
-}
-
-const fmtSize = (bytes: number | undefined) => {
-  if (!bytes || bytes <= 0) return "--"
-  if (bytes < 1024) return `${bytes}B`
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`
-  return `${(bytes / 1024 / 1024).toFixed(1)}MB`
-}
-
-function RecognitionBlock({
-  imageAnalysis,
-  isAnalyzing,
-}: {
-  imageAnalysis: ImageAnalysisResult | null
-  isAnalyzing: boolean
-}) {
-  const images: ImageProductAnalysis[] = useMemo(() => {
-    return (
-      (imageAnalysis?.images as ImageProductAnalysis[] | undefined) ||
-      (imageAnalysis?.products as ImageProductAnalysis[] | undefined) ||
-      []
-    )
-  }, [imageAnalysis])
-
-  if (isAnalyzing) {
-    return (
-      <div className="vv-recog">
-        <div className="vv-recog-title">
-          <VVSpinner color="#7c3aed" className="vv-inline-spinner" />
-          识别描述汇览
-        </div>
-        <div className="vv-muted">AI 正在识别画面…</div>
-      </div>
-    )
-  }
-  if (images.length === 0) return null
-  return (
-    <div className="vv-recog">
-      <div className="vv-recog-title">
-        <CheckCircleFilled style={{ color: "#10b981" }} />
-        识别描述汇览
-      </div>
-      {images.map((p, i) => {
-        const meta = [p.name || "未识别", p.brand, p.category].filter(Boolean)
-        return (
-          <div key={i} className="vv-recog-item vv-recog-md">
-            <div className="vv-recog-line">
-              <span className="vv-recog-k">图片{i + 1}：</span>
-              <span>{meta.join(" · ")}</span>
-            </div>
-            {p.summary_markdown ? (
-              <div
-                className="vv-md-body"
-                dangerouslySetInnerHTML={{ __html: renderMarkdown(p.summary_markdown) }}
-              />
-            ) : (
-              <div className="vv-muted">（暂无叙述描述）</div>
-            )}
-          </div>
-        )
-      })}
-    </div>
-  )
-}
-
-export const Step1UploadPanel: React.FC<Step1UploadPanelProps> = (p) => {
-  return (
-    <div className="vv-section">
-      <div className="vv-step1-head">
-        <span className="vv-step-badge">1</span>
-        <span className="vv-step1-title">STEP 1 上传素材并分析图片</span>
-      </div>
-      <div className="vv-section-body vv-section-body-scroll">
-        <div className="vv-scroll-inner">
-          {/* 图片按钮 */}
-          <div className="vv-action-row">
-            <button className="vv-action-btn" onClick={p.onPickLocalImages}>
-              <UploadOutlined /> 本地上传
-            </button>
-            <button className="vv-action-btn" onClick={p.onPickAssetImages}>
-              <FolderOpenOutlined /> 从素材库选择图片
-            </button>
-          </div>
-          <input
-            ref={p.imgInputRef}
-            type="file"
-            multiple
-            accept="image/*"
-            hidden
-            onChange={(e) => {
-              if (e.target.files) p.onImagesSelected(e.target.files)
-              e.target.value = ""
-            }}
-          />
-
-          <div className="vv-count-row">
-            <span className="vv-muted">
-              已选 <strong style={{ color: "#111827" }}>{p.images.length}</strong>/9
-            </span>
-            {p.images.length > 0 && (
-              <button className="vv-link-btn" onClick={p.onClearImages}>
-                清空图片
-              </button>
-            )}
-          </div>
-
-          {p.images.length > 0 && (
-            <div className="vv-file-list">
-              {p.images.map((im, i) => (
-                <div key={im.localId} className="vv-file-item">
-                  <div className="vv-file-thumb">
-                    <span className="vv-img-badge">{i + 1}</span>
-                    <img src={im.ossUrl || im.url} alt={im.name} />
-                  </div>
-                  <div className="vv-file-info">
-                    <div className="vv-file-name" title={im.name}>
-                      {im.name}
-                    </div>
-                    <div className="vv-file-sub">
-                      {im.uploading ? (
-                        <>
-                          <span className="vv-progress-mini-inline" />
-                          上传中 {im.pct}%
-                        </>
-                      ) : (
-                        <>{fmtSize(im.size)}</>
-                      )}
-                    </div>
-                  </div>
-                  <div className="vv-file-actions">
-                    <button
-                      className="vv-icon-btn"
-                      onClick={() => p.onMoveImage(i, -1)}
-                      disabled={i === 0 || im.uploading}
-                      title="上移"
-                    >
-                      <ArrowUpOutlined />
-                    </button>
-                    <button
-                      className="vv-icon-btn"
-                      onClick={() => p.onMoveImage(i, 1)}
-                      disabled={i === p.images.length - 1 || im.uploading}
-                      title="下移"
-                    >
-                      <ArrowDownOutlined />
-                    </button>
-                    <button
-                      className="vv-icon-btn vv-icon-btn-danger"
-                      onClick={() => p.onRemoveImage(im.localId)}
-                      disabled={!!im.uploading}
-                      title="删除"
-                    >
-                      <CloseOutlined />
-                    </button>
-                  </div>
-                </div>
-              ))}
-            </div>
-          )}
-
-          {/* 参考视频 */}
-          <div className="vv-subblock">
-            <div className="vv-subblock-head">
-              <span className="vv-subblock-title">参考视频</span>
-              <span className="vv-opt-tag">选填</span>
-              <span className="vv-subblock-hint">最大 200MB · 最长 120 秒</span>
-            </div>
-            <div className="vv-action-row">
-              <button className="vv-action-btn" onClick={p.onPickLocalVideo}>
-                <UploadOutlined /> 本地上传视频
-              </button>
-            </div>
-            <input
-              ref={p.videoInputRef}
-              type="file"
-              accept="video/*"
-              hidden
-              onChange={(e) => {
-                if (e.target.files?.[0]) p.onVideoSelected(e.target.files[0])
-                e.target.value = ""
-              }}
-            />
-            {p.refVideo && (
-              <div className="vv-ref-video-box">
-                <video
-                  src={p.refVideo.ossUrl || p.refVideo.url}
-                  controls
-                  className="vv-ref-video-el"
-                />
-                <div className="vv-file-info vv-mt-6">
-                  <div className="vv-file-name">{p.refVideo.name}</div>
-                  {p.refVideo.uploading && (
-                    <div className="vv-progress-bar vv-progress-bar-sm">
-                      <div className="vv-progress-fill" style={{ width: `${p.refVideo.pct}%` }} />
-                    </div>
-                  )}
-                </div>
-                <button className="vv-link-btn" onClick={p.onRemoveRefVideo}>
-                  删除重传
-                </button>
-                {p.refVideo.ossUrl && (
-                  <div className="vv-mt-8">
-                    <div className="vv-label vv-mb-6">风格借鉴强度</div>
-                    <div className="vv-pill-row">
-                      {STYLE_STRENGTHS.map((s) => (
-                        <button
-                          key={s.value}
-                          className={`vv-pill ${p.styleStrength === s.value ? "active" : ""}`}
-                          onClick={() => p.onStyleStrengthChange(s.value)}
-                        >
-                          {s.label}
-                        </button>
-                      ))}
-                    </div>
-                  </div>
-                )}
-              </div>
-            )}
-          </div>
-
-          <VoicePickerSection
-            refAudio={p.refAudio}
-            voicePanel={p.voicePanel}
-            voiceTipsOpen={p.voiceTipsOpen}
-            myVoices={p.myVoices}
-            myVoicesLoading={p.myVoicesLoading}
-            voiceAssets={p.voiceAssets}
-            playingVoiceId={p.playingVoiceId}
-            voiceInputRef={p.voiceInputRef}
-            onOpenCloneModal={p.onOpenCloneModal}
-            onToggleVoicePanel={p.onToggleVoicePanel}
-            onSelectMyVoice={p.onSelectMyVoice}
-            onSelectVoiceAsset={p.onSelectVoiceAsset}
-            onToggleVoicePlay={p.onToggleVoicePlay}
-            onPickLocalAudio={p.onPickLocalAudio}
-            onPickAssetAudio={p.onPickAssetAudio}
-            onVoiceSelected={p.onVoiceSelected}
-            onRemoveRefAudio={p.onRemoveRefAudio}
-            onToggleVoiceTips={p.onToggleVoiceTips}
-          />
-
-          <RecognitionBlock imageAnalysis={p.imageAnalysis} isAnalyzing={p.isAnalyzing} />
-        </div>
-
-        <button className="vv-btn vv-btn-primary" disabled={!p.canAnalyze} onClick={p.onAnalyze}>
-          {p.analyzeBtnText}
-        </button>
-      </div>
-    </div>
-  )
-}
-
-export default Step1UploadPanel

apps/web/src/pages/viral-video/components/Step2CopyPanel.tsx

@@ -1,237 +0,0 @@
-import React from "react"
-import { EditOutlined } from "@ant-design/icons"
-import { Select } from "antd"
-import { FUSION_LEVELS } from "@/api/viral-video/types"
-import type { FusionLevel } from "@/api/viral-video/types"
-import { VVSpinner } from "./VVSpinner"
-import { ErrorRetryBar } from "./ErrorRetryBar"
-import { StoryboardCard } from "./StoryboardCard"
-import type { SbDoc, StoryboardEditor } from "../hooks/useStoryboardEditor"
-import type { UploadedImage, UIStep, ViralVideoJob } from "../types"
-import {
-  LANGUAGES,
-  TARGET_CUSTOMERS,
-  PERSONAS,
-  STRUCTURES,
-  PURPOSES,
-  DURATIONS,
-} from "../ViralVideoPage.constants"
-import { getJobPhaseMessage } from "@/api/viral-video/types"
-
-export interface Step2CopyPanelProps {
-  // 启用状态
-  step2Enabled: boolean
-  uiStep: UIStep
-  // 文案参数
-  fusionLevel: FusionLevel
-  userCopy: string
-  industry: string
-  targetCustomer: string
-  persona: string
-  language: string
-  viralStructure: string
-  marketingPurpose: string
-  duration: number
-  // 回调
-  onFusionLevelChange: (v: FusionLevel) => void
-  onUserCopyChange: (v: string) => void
-  onParamChange: (patch: {
-    industry?: string
-    targetCustomer?: string
-    persona?: string
-    language?: string
-    viralStructure?: string
-    marketingPurpose?: string
-    duration?: number
-  }) => void
-  onGenerateCopy: () => void
-  // 分镜/流式预览
-  storyboard: SbDoc | null
-  scriptStreamText: string
-  scriptStreamMessage?: string
-  editor: StoryboardEditor
-  images: UploadedImage[]
-  locked: boolean
-  job: ViralVideoJob | null
-  copyError?: string
-}
-
-export const Step2CopyPanel: React.FC<Step2CopyPanelProps> = (p) => {
-  const isGenerating = p.uiStep === "step2_generating"
-  const showGenerateBtn =
-    p.uiStep !== "step2_copy_ready" && p.uiStep !== "step3_generating" && p.uiStep !== "step3_done"
-
-  return (
-    <div className="vv-section">
-      <div className="vv-step-subhead">
-        <span className={`vv-step-badge ${p.step2Enabled ? "" : "vv-step-badge-dim"}`}>2</span>
-        <span className="vv-step-subtitle">STEP 2 生成视频文案</span>
-        {!p.step2Enabled && <span className="vv-step-lock">请先完成 STEP 1</span>}
-      </div>
-      <div className="vv-section-body vv-section-body-scroll">
-        <div className="vv-scroll-inner">
-          {/* 文案融合方式 */}
-          <div className="vv-section-subtitle">文案融合方式</div>
-          <div className="vv-fusion-grid">
-            {FUSION_LEVELS.map((f) => (
-              <button
-                key={f.value}
-                className={`vv-fusion-btn ${p.fusionLevel === f.value ? "active" : ""}`}
-                onClick={() => p.onFusionLevelChange(f.value)}
-              >
-                <strong>{f.label}</strong>
-                {f.desc}
-              </button>
-            ))}
-          </div>
-          {(p.fusionLevel === "ai_polish" || p.fusionLevel === "user_primary") && (
-            <div className="vv-form-row">
-              <label className="vv-label">
-                {p.fusionLevel === "ai_polish" ? "写下你的文案草稿" : "写下你的文案/草稿"}
-              </label>
-              <textarea
-                key={p.fusionLevel}
-                className="vv-textarea"
-                placeholder={
-                  p.fusionLevel === "ai_polish"
-                    ? "请输入你的文案草稿，AI将在此基础上润色优化..."
-                    : "请输入你想要的原始文案，AI将严格保留你的表达..."
-                }
-                value={p.userCopy}
-                onChange={(e) => p.onUserCopyChange(e.target.value)}
-              />
-            </div>
-          )}
-
-          {/* 参数（2列网格） */}
-          <div className="vv-form-grid">
-            <div className="vv-form-row">
-              <label className="vv-label">
-                行业与产品 <span className="vv-label-optional">（选填）</span>
-              </label>
-              <input
-                className="vv-input"
-                placeholder="如：家具店、宠物店、装修公司"
-                value={p.industry}
-                onChange={(e) => p.onParamChange({ industry: e.target.value })}
-              />
-            </div>
-            <div className="vv-form-row">
-              <label className="vv-label">目标客户</label>
-              <Select
-                className="vv-select"
-                style={{ width: "100%" }}
-                placeholder="请选择目标客户"
-                value={p.targetCustomer || undefined}
-                onChange={(v) => p.onParamChange({ targetCustomer: v })}
-                options={TARGET_CUSTOMERS.map((i) => ({ value: i, label: i }))}
-                allowClear
-              />
-            </div>
-            <div className="vv-form-row">
-              <label className="vv-label">台词语言</label>
-              <Select
-                className="vv-select"
-                style={{ width: "100%" }}
-                value={p.language}
-                onChange={(v) => p.onParamChange({ language: v })}
-                options={LANGUAGES.map((i) => ({ value: i, label: i }))}
-              />
-            </div>
-            <div className="vv-form-row">
-              <label className="vv-label">我的人设</label>
-              <Select
-                className="vv-select"
-                style={{ width: "100%" }}
-                placeholder="请选择人设类型"
-                optionFilterProp="children"
-                value={p.persona || undefined}
-                onChange={(v) => p.onParamChange({ persona: v })}
-                options={PERSONAS.map((i) => ({ value: i, label: i }))}
-              />
-            </div>
-            <div className="vv-form-row">
-              <label className="vv-label">爆款结构</label>
-              <Select
-                className="vv-select"
-                style={{ width: "100%" }}
-                value={p.viralStructure}
-                onChange={(v) => p.onParamChange({ viralStructure: v })}
-                options={STRUCTURES.map((i) => ({ value: i, label: i }))}
-              />
-            </div>
-            <div className="vv-form-row">
-              <label className="vv-label">营销目的</label>
-              <Select
-                className="vv-select"
-                style={{ width: "100%" }}
-                placeholder="请选择营销目的"
-                value={p.marketingPurpose || undefined}
-                onChange={(v) => p.onParamChange({ marketingPurpose: v })}
-                options={PURPOSES.map((i) => ({ value: i, label: i }))}
-              />
-            </div>
-            <div className="vv-form-row">
-              <label className="vv-label">文案视频时长</label>
-              <Select
-                className="vv-select"
-                style={{ width: "100%" }}
-                value={p.duration}
-                onChange={(v) => p.onParamChange({ duration: v })}
-                options={DURATIONS.map((n) => ({ value: n, label: `${n}秒` }))}
-              />
-            </div>
-          </div>
-
-          {/* 短剧模式提示 */}
-          {p.marketingPurpose && p.marketingPurpose.includes("短剧") && (
-            <div className="vv-shortdrama-hint">
-              💡 短剧模式已选中，对手戏角色将自动分配配角音色
-            </div>
-          )}
-
-          {/* 文案审核错误（持久显示） */}
-          {p.copyError && <ErrorRetryBar label="文案审核未通过" message={p.copyError} />}
-
-          {/* 分镜结果区 / 流式预览 */}
-          <StoryboardCard
-            uiStep={p.uiStep}
-            scriptStreamText={p.scriptStreamText}
-            scriptStreamMessage={p.scriptStreamMessage}
-            jobPhaseMessage={getJobPhaseMessage(p.job)}
-            storyboard={p.storyboard}
-            editor={p.editor}
-            images={p.images}
-            locked={p.locked}
-            onRegenerateCopy={p.onGenerateCopy}
-          />
-        </div>
-
-        {showGenerateBtn && (
-          <button
-            className={`vv-btn vv-btn-primary ${!p.step2Enabled ? "vv-btn-disabled-gray" : ""}`}
-            onClick={p.onGenerateCopy}
-            disabled={isGenerating || !p.step2Enabled}
-            title={!p.step2Enabled ? "请先完成图片分析" : ""}
-          >
-            {isGenerating ? (
-              <>
-                <VVSpinner /> AI 生成文案中…
-              </>
-            ) : !p.step2Enabled ? (
-              <>
-                <EditOutlined /> 生成文案（请先完成图片分析）
-              </>
-            ) : (
-              <>
-                <EditOutlined /> 生成文案
-              </>
-            )}
-          </button>
-        )}
-      </div>
-    </div>
-  )
-}
-
-export default Step2CopyPanel

apps/web/src/pages/viral-video/components/Step3VideoPanel.tsx

@@ -1,216 +0,0 @@
-import React from "react"
-import {
-  VideoCameraOutlined,
-  SoundOutlined,
-  ReloadOutlined,
-  HistoryOutlined,
-  LoadingOutlined,
-} from "@ant-design/icons"
-import { Select } from "antd"
-import { VVSpinner } from "./VVSpinner"
-import { ErrorRetryBar } from "./ErrorRetryBar"
-import type { UIStep, ViralVideoJob, ViralVideoModel } from "../types"
-import { getJobPhaseMessage } from "@/api/viral-video/types"
-import { RATIOS, QUALITY_OPTIONS, UPSCALE_OPTIONS } from "../ViralVideoPage.constants"
-
-export interface Step3VideoPanelProps {
-  step3Enabled: boolean
-  uiStep: UIStep
-  videoRatio: string
-  videoModel: string
-  quality: string
-  upscale: string
-  duration: number
-  estimatedCredits: number | null
-  estimatedCreditsError: boolean
-  isGenerating: boolean
-  outputUrl: string | null
-  videoError?: string
-  creditsReady: boolean
-  job: ViralVideoJob | null
-  videoModels: ViralVideoModel[]
-  locked: boolean
-  // callbacks
-  onRatioChange: (v: string) => void
-  onModelChange: (v: string) => void
-  onQualityChange: (v: string) => void
-  onUpscaleChange: (v: string) => void
-  onGenerate: () => void
-  onReset: () => void
-  onRetry: () => void
-}
-
-export const Step3VideoPanel: React.FC<Step3VideoPanelProps> = (p) => {
-  const isDone = p.uiStep === "step3_done"
-  const isGenerating = p.uiStep === "step3_generating"
-  const isFailed = p.uiStep === "failed"
-
-  const curM = p.videoModels.find((m) => m && m.key === p.videoModel)
-  const supportedRes = Array.isArray(curM?.supported_resolutions)
-    ? curM!.supported_resolutions
-    : QUALITY_OPTIONS.map((o) => o.v)
-  const qualityPool =
-    supportedRes && supportedRes.length > 0 ? supportedRes : QUALITY_OPTIONS.map((o) => o.v)
-  const qualityOptions = QUALITY_OPTIONS.filter((o) => qualityPool.includes(o.v))
-
-  return (
-    <>
-      <div className="vv-section">
-        <div className="vv-step-subhead vv-step3-head">
-          <div className="vv-step3-head-left">
-            <span className={`vv-step-badge ${p.step3Enabled ? "" : "vv-step-badge-dim"}`}>3</span>
-            <span className="vv-step-subtitle">STEP 3 生成视频</span>
-          </div>
-          {p.step3Enabled && (
-            <button
-              className="vv-btn vv-btn-ghost vv-btn-xs vv-history-btn"
-              onClick={() => {
-                // 历史作品功能待开发，此处保留原行为（message 由父组件触发）
-              }}
-              title="历史作品"
-            >
-              <HistoryOutlined /> 历史作品
-            </button>
-          )}
-          {!p.step3Enabled && <span className="vv-step-lock">请先完成 STEP 2</span>}
-        </div>
-        <div className="vv-step3-divider" />
-        <div className="vv-section-body vv-section-body-scroll vv-step3-config-body">
-          <div className="vv-scroll-inner">
-            <div className="vv-step3-grid">
-              <div className="vv-form-row">
-                <label className="vv-label">视频比例</label>
-                <Select
-                  className="vv-select vv-select-step3"
-                  style={{ width: "100%" }}
-                  value={p.videoRatio}
-                  onChange={p.onRatioChange}
-                  disabled={p.locked}
-                  options={RATIOS.map((r) => ({ value: r.v, label: r.v }))}
-                />
-              </div>
-              <div className="vv-form-row">
-                <label className="vv-label">视频模型</label>
-                <Select
-                  className="vv-select vv-select-step3"
-                  style={{ width: "100%" }}
-                  value={p.videoModel}
-                  disabled={p.locked}
-                  onChange={(v) => p.onModelChange(v)}
-                  options={p.videoModels
-                    .filter((m) => m && typeof m === "object" && m.key)
-                    .map((m) => ({ value: m.key, label: m.display_name || m.key }))}
-                />
-              </div>
-              <div className="vv-form-row">
-                <label className="vv-label">清晰度</label>
-                <Select
-                  className="vv-select vv-select-step3"
-                  style={{ width: "100%" }}
-                  value={p.quality}
-                  onChange={p.onQualityChange}
-                  disabled={p.locked}
-                  options={qualityOptions.map((o) => ({ value: o.v, label: o.label }))}
-                />
-              </div>
-              <div className="vv-form-row">
-                <label className="vv-label">成片超分</label>
-                <Select
-                  className="vv-select vv-select-step3"
-                  style={{ width: "100%" }}
-                  value={p.upscale}
-                  onChange={p.onUpscaleChange}
-                  disabled={p.locked}
-                  options={UPSCALE_OPTIONS.map((m) => ({ value: m.v, label: m.label }))}
-                />
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-
-      {p.creditsReady && (
-        <div className="vv-credits">
-          <span>
-            <SoundOutlined style={{ marginRight: 4 }} />
-            预计消耗
-          </span>
-          <strong>
-            {p.estimatedCreditsError
-              ? "-- 积分"
-              : p.estimatedCredits === null
-                ? "… 积分"
-                : `${p.estimatedCredits.toFixed(2)} 积分`}
-          </strong>
-        </div>
-      )}
-
-      {/* 视频预览 */}
-      <div className="vv-section vv-section-preview">
-        <div className="vv-section-body vv-preview-body">
-          <div className="vv-preview">
-            {isDone && p.outputUrl ? (
-              <video src={p.outputUrl} controls />
-            ) : isGenerating ? (
-              <div className="vv-preview-placeholder">
-                <div className="ph-icon">
-                  <LoadingOutlined className="vv-loading-ic" />
-                </div>
-                <div className="ph-txt">
-                  AI 正在生成视频中…
-                  <br />
-                  预计 1-3 分钟，请勿关闭页面
-                </div>
-                {getJobPhaseMessage(p.job) && (
-                  <div className="vv-muted vv-mt-6 vv-fs-12">{getJobPhaseMessage(p.job)}</div>
-                )}
-              </div>
-            ) : (
-              <div className="vv-preview-placeholder">
-                <div className="ph-icon">🎬</div>
-                <div className="ph-txt">完成前面步骤后视频将在此处预览</div>
-              </div>
-            )}
-          </div>
-        </div>
-      </div>
-
-      {/* 错误条 */}
-      {isFailed && p.videoError && (
-        <ErrorRetryBar label="视频生成失败" message={p.videoError} onRetry={p.onRetry} />
-      )}
-
-      {/* 主按钮 */}
-      {!isDone ? (
-        <button
-          className={`vv-btn vv-btn-primary ${!p.step3Enabled ? "vv-btn-disabled-gray" : ""}`}
-          onClick={p.onGenerate}
-          disabled={isGenerating || !p.step3Enabled}
-          title={!p.step3Enabled ? "请先在 STEP 2 生成文案" : ""}
-        >
-          {isGenerating ? (
-            <>
-              <VVSpinner /> AI 正在生成视频中…
-            </>
-          ) : !p.step3Enabled ? (
-            <>
-              <VideoCameraOutlined /> 开始生成视频（请先生成文案）
-            </>
-          ) : (
-            <>
-              <VideoCameraOutlined /> 开始生成视频
-            </>
-          )}
-        </button>
-      ) : (
-        p.outputUrl && (
-          <button className="vv-btn vv-btn-ghost vv-btn-block" onClick={p.onReset}>
-            <ReloadOutlined /> 再生成一个
-          </button>
-        )
-      )}
-    </>
-  )
-}
-
-export default Step3VideoPanel

apps/web/src/pages/viral-video/components/StoryboardCard.tsx

@@ -1,327 +0,0 @@
-import React from "react"
-import { Select } from "antd"
-import { FileTextOutlined, SoundOutlined, ReloadOutlined } from "@ant-design/icons"
-import { InlineText } from "./InlineEditTextarea"
-import { StoryboardShotItem } from "./StoryboardShotItem"
-import { VVSpinner } from "./VVSpinner"
-import type { StoryboardEditor, SbDoc } from "../hooks/useStoryboardEditor"
-import type { UploadedImage, UIStep } from "../types"
-import { RATIOS } from "../ViralVideoPage.constants"
-
-export interface StoryboardCardProps {
-  /** 当前 uiStep（仅用于按钮/锁定判定） */
-  uiStep: UIStep
-  /** 当前流式预览文本（step2_generating 时优先展示） */
-  scriptStreamText: string
-  scriptStreamMessage?: string
-  jobPhaseMessage?: string
-  /** 真实 storyboard（已补默认值的 SbDoc） */
-  storyboard: SbDoc | null
-  editor: StoryboardEditor
-  images: UploadedImage[]
-  /** 是否锁定编辑（视频生成中/完成时为 true） */
-  locked: boolean
-  onRegenerateCopy?: () => void
-}
-
-import { renderMarkdown } from "../utils/renderMarkdown"
-
-/** 解析 voiceover_script 中的 [speaker:xxx] 标记，渲染为带颜色的 React 片段 */
-function renderVoiceoverWithSpeakers(text: string) {
-  if (!text) return null
-  const parts = text.split(/\[speaker:([^\]]+)\]/)
-  if (parts.length === 1) return <span>{text}</span>
-  const elements: React.ReactNode[] = []
-  const MAIN_SPEAKERS = ["店主", "主播", "老板", "我", "主讲人"]
-  for (let i = 1; i < parts.length; i += 2) {
-    const speaker = parts[i]
-    const segText = parts[i + 1] || ""
-    const isMain = MAIN_SPEAKERS.includes(speaker)
-    elements.push(
-      <span key={i}>
-        <strong className={isMain ? "vv-sb-speaker-main" : "vv-sb-speaker-guest"}>{speaker}</strong>
-        <span>{segText}</span>
-      </span>,
-    )
-  }
-  return <>{elements}</>
-}
-
-export const StoryboardCard: React.FC<StoryboardCardProps> = ({
-  uiStep,
-  scriptStreamText,
-  scriptStreamMessage,
-  jobPhaseMessage,
-  storyboard,
-  editor,
-  images,
-  locked,
-  onRegenerateCopy,
-}) => {
-  const {
-    editingField,
-    startEdit,
-    cancelEdit,
-    commitField,
-    updateOverview,
-    updateConstraint,
-    addConstraint,
-    removeConstraint,
-    updateSbField,
-  } = editor
-
-  /* ── 生成中：流式预览 or 骨架 ── */
-  if (uiStep === "step2_generating") {
-    const hasStream = scriptStreamText.trim().length > 0
-    const stageMsg = scriptStreamMessage || jobPhaseMessage || "🎬 AI 正在创作视频分镜脚本..."
-    if (!hasStream) {
-      return (
-        <div className="vv-copy-box vv-copy-loading">
-          <VVSpinner />
-          <span className="vv-copy-loading-text">{stageMsg}</span>
-          <span className="vv-copy-loading-hint">预计 10-30 秒，请稍候</span>
-        </div>
-      )
-    }
-    return (
-      <div className="vv-copy-box vv-storyboard vv-streaming-box">
-        <div className="vv-streaming-header">
-          <VVSpinner />
-          <span className="vv-streaming-title">{stageMsg}</span>
-          <span className="vv-streaming-count">{scriptStreamText.length} 字</span>
-        </div>
-        <div className="vv-sb-doc vv-streaming-doc">
-          <pre className="vv-streaming-pre">
-            {scriptStreamText
-              .replace(/<\/?[a-zA-Z_][\w:-]*(?:\s[^>]*)?>/g, "")
-              .replace(/\s{3,}/g, "\n\n")
-              .trim()}
-            <span className="vv-streaming-caret" aria-hidden="true" />
-          </pre>
-        </div>
-        <div className="vv-sb-actions vv-streaming-actions">
-          <span className="vv-streaming-hint">AI 实时输出中，完成后可编辑分镜与口播文案</span>
-        </div>
-      </div>
-    )
-  }
-
-  /* ── 没有 storyboard 时的空态 ── */
-  if (!storyboard) {
-    if (uiStep === "step2_copy_ready" || uiStep === "step3_generating" || uiStep === "step3_done") {
-      return (
-        <div className="vv-copy-box vv-copy-loading">
-          <span className="vv-muted">暂无分镜数据</span>
-        </div>
-      )
-    }
-    return null
-  }
-
-  const sb = storyboard
-  const textCls = "vv-sb-field-val"
-  const taCls = "vv-textarea vv-sb-doc-ta vv-sb-inline-edit-ta"
-
-  return (
-    <div className="vv-copy-box vv-storyboard">
-      <div className="vv-sb-doc">
-        {/* 文案预览 markdown（只读） */}
-        {sb.copy_display_markdown && (
-          <div className="vv-copy-preview">
-            <h4 className="vv-sb-h vv-copy-preview-h">
-              <FileTextOutlined style={{ color: "#7c3aed", marginRight: 6 }} />
-              文案预览
-            </h4>
-            <div
-              className="vv-md-body"
-              dangerouslySetInnerHTML={{ __html: renderMarkdown(sb.copy_display_markdown) }}
-            />
-          </div>
-        )}
-
-        {/* 视频总览 */}
-        <h4 className="vv-sb-h">视频总览</h4>
-        <p className="vv-sb-inline-row">
-          <strong className="vv-sb-field-k">整体主题：</strong>
-          <InlineText
-            value={sb.overview.theme}
-            editing={!locked && editingField === "overview.theme"}
-            onStartEdit={() => startEdit("overview.theme")}
-            onCommit={(v) => commitField("overview.theme", v)}
-            onCancel={cancelEdit}
-            textClass={textCls}
-            textareaClass={`${taCls} vv-sb-inline-edit-ta-sm`}
-            disabled={locked}
-            rows={1}
-          />
-        </p>
-        <p className="vv-sb-inline-row">
-          <strong className="vv-sb-field-k">总时长：</strong>
-          <InlineText
-            value={sb.overview.total_duration}
-            editing={!locked && editingField === "overview.total_duration"}
-            onStartEdit={() => startEdit("overview.total_duration")}
-            onCommit={(v) => commitField("overview.total_duration", v)}
-            onCancel={cancelEdit}
-            textClass={textCls}
-            textareaClass={`${taCls} vv-sb-inline-edit-ta-sm`}
-            disabled={locked}
-            rows={1}
-          />
-        </p>
-        <p className="vv-sb-inline-row">
-          <strong className="vv-sb-field-k">画幅：</strong>
-          <Select
-            className="vv-select vv-sb-inline-select"
-            style={{ width: 90 }}
-            value={sb.overview.aspect_ratio}
-            disabled={locked}
-            onChange={(v) => updateOverview({ aspect_ratio: v })}
-            options={RATIOS.map((r) => ({ value: r.v, label: r.v }))}
-            variant="borderless"
-          />
-        </p>
-
-        {/* 场景与光线 */}
-        <h4 className="vv-sb-h">场景与光线</h4>
-        <p className="vv-sb-para">
-          <InlineText
-            value={sb.scene_and_lighting}
-            editing={!locked && editingField === "scene_and_lighting"}
-            onStartEdit={() => startEdit("scene_and_lighting")}
-            onCommit={(v) => commitField("scene_and_lighting", v)}
-            onCancel={cancelEdit}
-            textClass={textCls}
-            textareaClass={taCls}
-            placeholder="描述整体场景氛围、光线方向与色温…"
-            disabled={locked}
-            multiline
-            rows={2}
-          />
-        </p>
-
-        {/* 逐镜头 */}
-        <h4 className="vv-sb-h">逐秒镜头拆解</h4>
-        <div className="vv-sb-doc-shots">
-          {sb.shots.map((sh, idx) => (
-            <StoryboardShotItem
-              key={idx}
-              index={idx}
-              shot={sh}
-              editor={editor}
-              images={images}
-              locked={locked}
-            />
-          ))}
-        </div>
-
-        {/* 硬性约束 */}
-        <h4 className="vv-sb-h">硬性约束</h4>
-        <div className="vv-sb-tags-block">
-          <div className="vv-sb-taglist">
-            {sb.hard_constraints.map((c, i) => (
-              <span key={i} className="vv-sb-tag vv-sb-tag-hard">
-                <input
-                  className="vv-sb-tag-input"
-                  value={c}
-                  disabled={locked}
-                  onChange={(e) => updateConstraint("hard_constraints", i, e.target.value)}
-                />
-                {!locked && (
-                  <button
-                    className="vv-sb-tag-del"
-                    onClick={() => removeConstraint("hard_constraints", i)}
-                    aria-label="删除"
-                  >
-                    ×
-                  </button>
-                )}
-              </span>
-            ))}
-            {!locked && (
-              <button className="vv-sb-tag-add" onClick={() => addConstraint("hard_constraints")}>
-                + 添加
-              </button>
-            )}
-          </div>
-        </div>
-
-        {/* 负面提示词 */}
-        <h4 className="vv-sb-h">负面提示词</h4>
-        <div className="vv-sb-tags-block">
-          <div className="vv-sb-taglist">
-            {sb.negative_prompts.map((c, i) => (
-              <span key={i} className="vv-sb-tag vv-sb-tag-neg">
-                <input
-                  className="vv-sb-tag-input"
-                  value={c}
-                  disabled={locked}
-                  onChange={(e) => updateConstraint("negative_prompts", i, e.target.value)}
-                />
-                {!locked && (
-                  <button
-                    className="vv-sb-tag-del"
-                    onClick={() => removeConstraint("negative_prompts", i)}
-                    aria-label="删除"
-                  >
-                    ×
-                  </button>
-                )}
-              </span>
-            ))}
-            {!locked && (
-              <button className="vv-sb-tag-add" onClick={() => addConstraint("negative_prompts")}>
-                + 添加
-              </button>
-            )}
-          </div>
-        </div>
-
-        {/* 完整口播稿 */}
-        <p className="vv-sb-field">
-          <strong className="vv-sb-field-k">
-            <SoundOutlined style={{ color: "#7c3aed", marginRight: 4 }} />
-            口播稿：
-          </strong>
-          {editingField === "voiceover_script" ? (
-            <textarea
-              className={taCls}
-              value={sb.voiceover_script}
-              autoFocus
-              onChange={(e) => updateSbField("voiceover_script", e.target.value)}
-              onBlur={() => {
-                // 受控模式：blur 即退出编辑（内容已实时同步）
-                if (editingField === "voiceover_script") cancelEdit()
-              }}
-              onKeyDown={(e) => {
-                if (e.key === "Escape") cancelEdit()
-              }}
-              placeholder="AI 合成配音用的完整口播稿…"
-              rows={4}
-            />
-          ) : (
-            <span
-              className={textCls}
-              onClick={() => {
-                if (!locked) startEdit("voiceover_script")
-              }}
-              style={{ cursor: locked ? "not-allowed" : "text" }}
-            >
-              {renderVoiceoverWithSpeakers(sb.voiceover_script)}
-            </span>
-          )}
-        </p>
-      </div>
-
-      <div className="vv-sb-actions">
-        {uiStep === "step2_copy_ready" && onRegenerateCopy && (
-          <button className="vv-btn vv-btn-ghost" onClick={onRegenerateCopy}>
-            <ReloadOutlined /> 重新生成文案
-          </button>
-        )}
-      </div>
-    </div>
-  )
-}
-
-export default StoryboardCard

apps/web/src/pages/viral-video/components/StoryboardShotItem.tsx

@@ -1,182 +0,0 @@
-import React from "react"
-import { InlineText } from "./InlineEditTextarea"
-import type { StoryboardEditor, SbShot } from "../hooks/useStoryboardEditor"
-import type { UploadedImage } from "../types"
-
-export interface StoryboardShotItemProps {
-  index: number
-  shot: SbShot
-  editor: StoryboardEditor
-  images: UploadedImage[]
-  locked: boolean
-}
-
-const MAIN_SPEAKERS = ["店主", "主播", "老板", "我", "主讲人"]
-
-const SHOT_FIELD_KEY = (idx: number, field: string) => `shot.${idx}.${field}`
-
-/** 单个镜头行：时间/说话人/景别/场景/动作/BGM/转场/参考图 */
-export const StoryboardShotItem: React.FC<StoryboardShotItemProps> = ({
-  index,
-  shot,
-  editor,
-  images,
-  locked,
-}) => {
-  const { editingField, startEdit, cancelEdit, commitField, updateShot } = editor
-  const refImg =
-    typeof shot.reference_image_index === "number" ? images[shot.reference_image_index] : undefined
-
-  const textCls = "vv-sb-field-val"
-  const taCls = "vv-textarea vv-sb-doc-ta vv-sb-inline-edit-ta"
-
-  const isMainSpeaker = shot.speaker ? MAIN_SPEAKERS.includes(shot.speaker) : false
-
-  return (
-    <div className="vv-sb-doc-shot">
-      {/* 时间 */}
-      <InlineText
-        value={shot.time_range}
-        editing={!locked && editingField === SHOT_FIELD_KEY(index, "time_range")}
-        onStartEdit={() => startEdit(SHOT_FIELD_KEY(index, "time_range"))}
-        onCommit={(v) => commitField(SHOT_FIELD_KEY(index, "time_range"), v)}
-        onCancel={cancelEdit}
-        textClass="vv-sb-time-doc"
-        textareaClass={`${taCls} vv-sb-time-ta`}
-        placeholder="0-3秒"
-        disabled={locked}
-        rows={1}
-      />
-
-      {/* 说话人标签（有 speaker 时展示，纯展示不加编辑） */}
-      {shot.speaker && (
-        <span
-          className={`vv-sb-speaker-tag ${isMainSpeaker ? "vv-sb-speaker-tag-main" : "vv-sb-speaker-tag-guest"}`}
-        >
-          {shot.speaker}
-        </span>
-      )}
-
-      {/* 景别/角度与运镜 */}
-      <p className="vv-sb-field">
-        <strong className="vv-sb-field-k">景别/角度与运镜：</strong>
-        <InlineText
-          value={shot.shot_type_angle_movement}
-          editing={!locked && editingField === SHOT_FIELD_KEY(index, "shot_type_angle_movement")}
-          onStartEdit={() => startEdit(SHOT_FIELD_KEY(index, "shot_type_angle_movement"))}
-          onCommit={(v) => commitField(SHOT_FIELD_KEY(index, "shot_type_angle_movement"), v)}
-          onCancel={cancelEdit}
-          textClass={textCls}
-          textareaClass={taCls}
-          disabled={locked}
-          multiline
-          rows={2}
-        />
-      </p>
-
-      {/* 场景与对白 */}
-      <p className="vv-sb-field">
-        <strong className="vv-sb-field-k">场景与对白：</strong>
-        <InlineText
-          value={shot.scene_and_dialogue}
-          editing={!locked && editingField === SHOT_FIELD_KEY(index, "scene_and_dialogue")}
-          onStartEdit={() => startEdit(SHOT_FIELD_KEY(index, "scene_and_dialogue"))}
-          onCommit={(v) => commitField(SHOT_FIELD_KEY(index, "scene_and_dialogue"), v)}
-          onCancel={cancelEdit}
-          textClass={textCls}
-          textareaClass={taCls}
-          disabled={locked}
-          multiline
-          rows={2}
-        />
-      </p>
-
-      {/* 动作与真人细节 */}
-      <p className="vv-sb-field">
-        <strong className="vv-sb-field-k">动作与真人细节：</strong>
-        <InlineText
-          value={shot.action_details}
-          editing={!locked && editingField === SHOT_FIELD_KEY(index, "action_details")}
-          onStartEdit={() => startEdit(SHOT_FIELD_KEY(index, "action_details"))}
-          onCommit={(v) => commitField(SHOT_FIELD_KEY(index, "action_details"), v)}
-          onCancel={cancelEdit}
-          textClass={textCls}
-          textareaClass={taCls}
-          disabled={locked}
-          multiline
-          rows={2}
-        />
-      </p>
-
-      {/* 音效/BGM */}
-      <p className="vv-sb-field">
-        <strong className="vv-sb-field-k">音效/BGM：</strong>
-        <InlineText
-          value={shot.audio_bgm}
-          editing={!locked && editingField === SHOT_FIELD_KEY(index, "audio_bgm")}
-          onStartEdit={() => startEdit(SHOT_FIELD_KEY(index, "audio_bgm"))}
-          onCommit={(v) => commitField(SHOT_FIELD_KEY(index, "audio_bgm"), v)}
-          onCancel={cancelEdit}
-          textClass={textCls}
-          textareaClass={taCls}
-          disabled={locked}
-          multiline
-          rows={1}
-        />
-      </p>
-
-      {/* 转场 */}
-      <p className="vv-sb-field">
-        <strong className="vv-sb-field-k">转场：</strong>
-        <InlineText
-          value={shot.transition}
-          editing={!locked && editingField === SHOT_FIELD_KEY(index, "transition")}
-          onStartEdit={() => startEdit(SHOT_FIELD_KEY(index, "transition"))}
-          onCommit={(v) => commitField(SHOT_FIELD_KEY(index, "transition"), v)}
-          onCancel={cancelEdit}
-          textClass={textCls}
-          textareaClass={taCls}
-          disabled={locked}
-          multiline
-          rows={1}
-        />
-      </p>
-
-      {/* 参考图片 */}
-      <p className="vv-sb-field vv-sb-ref-row">
-        <strong className="vv-sb-field-k">参考图片：</strong>
-        {refImg?.url ? (
-          <span className="vv-sb-ref-badge">
-            <img src={refImg.url} alt={`ref-${index}`} className="vv-sb-ref-thumb" />
-            {!locked && (
-              <button
-                className="vv-sb-ref-x"
-                onClick={() => updateShot(index, { reference_image_index: undefined })}
-                aria-label="移除参考图"
-              >
-                ×
-              </button>
-            )}
-          </span>
-        ) : !locked && images.length > 0 ? (
-          <span className="vv-sb-ref-pick">
-            {images.map((im, i) => (
-              <button
-                key={im.localId}
-                className="vv-sb-ref-opt"
-                onClick={() => updateShot(index, { reference_image_index: i })}
-                title={`@图片${i + 1}`}
-              >
-                <img src={im.url} alt={`img${i}`} />
-              </button>
-            ))}
-          </span>
-        ) : (
-          <span className="vv-sb-muted">未指定</span>
-        )}
-      </p>
-    </div>
-  )
-}
-
-export default StoryboardShotItem

apps/web/src/pages/viral-video/components/VVSpinner.tsx

@@ -1,26 +0,0 @@
-import React from "react"
-
-export interface VVSpinnerProps {
-  size?: number
-  color?: string
-  style?: React.CSSProperties
-  className?: string
-}
-
-/**
- * 统一 spinner 组件：复用 vv-spinner CSS 动画类，避免多处散落的 LoadingOutlined
- */
-export const VVSpinner: React.FC<VVSpinnerProps> = ({ size, color, style, className }) => {
-  return (
-    <span
-      className={`vv-spinner ${className || ""}`}
-      style={{
-        ...(size ? { width: size, height: size, borderWidth: Math.max(2, size / 8) } : {}),
-        ...(color ? { borderTopColor: color } : {}),
-        ...style,
-      }}
-    />
-  )
-}
-
-export default VVSpinner

apps/web/src/pages/viral-video/components/VoicePickerSection.tsx

@@ -1,216 +0,0 @@
-import React from "react"
-import {
-  UserOutlined,
-  AudioMutedOutlined,
-  PlayCircleOutlined,
-  PauseCircleOutlined,
-  FileTextOutlined,
-  FolderOpenOutlined,
-  UploadOutlined,
-  CaretDownOutlined,
-  CaretRightOutlined,
-  PlusOutlined,
-} from "@ant-design/icons"
-import { message } from "antd"
-import type { RefAudio, VoicePanel } from "../types"
-import type { VoiceClone } from "@/api/voice-clone"
-import { getVoiceClonePreview } from "@/api/voice-clone"
-import type { AssetItem } from "@/api/assets"
-import { VOICE_TIPS } from "../ViralVideoPage.constants"
-
-export interface VoicePickerSectionProps {
-  refAudio: RefAudio
-  voicePanel: VoicePanel
-  voiceTipsOpen: boolean
-  myVoices: VoiceClone[]
-  myVoicesLoading: boolean
-  voiceAssets: { id: string; name: string; url: string; desc?: string }[]
-  playingVoiceId: string | null
-  voiceInputRef: React.Ref<HTMLInputElement>
-  onOpenCloneModal: () => void
-  onToggleVoicePanel: (p: VoicePanel) => void
-  onSelectMyVoice: (v: VoiceClone) => void
-  onSelectVoiceAsset: (a: AssetItem) => void
-  onToggleVoicePlay: (v: { id: string; url: string }) => void
-  onPickLocalAudio: () => void
-  onPickAssetAudio: () => void
-  onVoiceSelected: (file: File) => void
-  onRemoveRefAudio: () => void
-  onToggleVoiceTips: () => void
-}
-
-export const VoicePickerSection: React.FC<VoicePickerSectionProps> = (p) => {
-  return (
-    <div className="vv-subblock">
-      <div className="vv-subblock-head">
-        <span className="vv-subblock-title">AI 配音</span>
-        <span className="vv-opt-tag">选填</span>
-        <span className="vv-subblock-hint">默认使用我的克隆音色，也可选择内置音色或上传配音</span>
-      </div>
-
-      {/* 我的音色（主路径） */}
-      <div className="vv-voice-section">
-        <div className="vv-voice-section-head">
-          <span className="vv-voice-section-title">
-            <UserOutlined /> 我的音色
-          </span>
-          <button className="vv-link-btn vv-link-btn-sm" onClick={p.onOpenCloneModal}>
-            <PlusOutlined /> 录制新音色
-          </button>
-        </div>
-        {p.myVoicesLoading ? (
-          <div className="vv-muted vv-voice-empty">加载中…</div>
-        ) : p.myVoices.length === 0 ? (
-          <div className="vv-voice-empty">
-            <AudioMutedOutlined className="vv-voice-empty-ic" />
-            <div className="vv-voice-empty-text">还没有克隆音色</div>
-            <button className="vv-btn vv-btn-primary vv-btn-sm" onClick={p.onOpenCloneModal}>
-              去录制一个
-            </button>
-          </div>
-        ) : (
-          <div className="vv-my-voice-list">
-            {p.myVoices.map((v) => {
-              const selected = p.refAudio?.source === "my_voice" && p.refAudio.id === v.id
-              const playing = p.playingVoiceId === `my-${v.id}`
-              return (
-                <div
-                  key={v.id}
-                  className={`vv-my-voice-item ${selected ? "selected" : ""}`}
-                  onClick={() => p.onSelectMyVoice(v)}
-                >
-                  <div className="vv-voice-radio" />
-                  <div className="vv-voice-info">
-                    <div className="vv-voice-name">{v.name}</div>
-                    <div className="vv-voice-desc">
-                      AI 克隆声音
-                      {v.gender
-                        ? ` · ${v.gender === "male" ? "男" : v.gender === "female" ? "女" : ""}`
-                        : ""}
-                    </div>
-                  </div>
-                  <button
-                    className={`vv-voice-play ${playing ? "playing" : ""}`}
-                    onClick={(e) => {
-                      e.stopPropagation()
-                      if (v.sample_url) {
-                        p.onToggleVoicePlay({ id: `my-${v.id}`, url: v.sample_url })
-                      } else {
-                        message.info("正在获取试听音频…")
-                        getVoiceClonePreview(v.id)
-                          .then((r) => {
-                            if (r.audio_url)
-                              p.onToggleVoicePlay({ id: `my-${v.id}`, url: r.audio_url })
-                          })
-                          .catch(() => message.error("试听获取失败"))
-                      }
-                    }}
-                  >
-                    {playing ? <PauseCircleOutlined /> : <PlayCircleOutlined />}
-                  </button>
-                </div>
-              )
-            })}
-          </div>
-        )}
-      </div>
-
-      {/* 次要选项 */}
-      <div className="vv-voice-alt-row">
-        <button
-          className={`vv-voice-alt-btn ${p.refAudio?.source === "preset" ? "selected" : ""}`}
-          onClick={() => p.onToggleVoicePanel("preset")}
-        >
-          <FileTextOutlined /> 内置音色
-        </button>
-        <button
-          className={`vv-voice-alt-btn ${p.refAudio?.source === "upload" || p.refAudio?.source === "library" ? "selected" : ""}`}
-          onClick={() => p.onToggleVoicePanel("library")}
-        >
-          <FolderOpenOutlined /> 上传配音
-        </button>
-      </div>
-
-      <input
-        ref={p.voiceInputRef}
-        type="file"
-        accept="audio/*"
-        hidden
-        onChange={(e) => {
-          if (e.target.files?.[0]) p.onVoiceSelected(e.target.files[0])
-          e.target.value = ""
-        }}
-      />
-      {p.refAudio && (
-        <div className="vv-selected-audio">
-          <span className="vv-mr-6">🔊</span>
-          <span className="vv-flex-1">
-            已选：
-            {p.refAudio.source === "my_voice"
-              ? `我的音色 · ${p.refAudio.name}`
-              : p.refAudio.source === "preset"
-                ? `内置 · ${p.refAudio.name}`
-                : p.refAudio.name}
-          </span>
-          <button className="vv-link-btn" onClick={p.onRemoveRefAudio}>
-            移除
-          </button>
-        </div>
-      )}
-      {p.voicePanel === "library" && (
-        <div className="vv-voice-panel">
-          <div className="vv-voice-panel-actions">
-            <button className="vv-link-btn vv-link-btn-sm" onClick={p.onPickLocalAudio}>
-              <UploadOutlined /> 本地上传音频文件
-            </button>
-            <button className="vv-link-btn vv-link-btn-sm" onClick={p.onPickAssetAudio}>
-              <FolderOpenOutlined /> 从素材库选择
-            </button>
-          </div>
-          {p.voiceAssets.length === 0 ? (
-            <div className="vv-muted vv-text-center vv-p-12">暂无已上传的配音文件</div>
-          ) : (
-            <div className="vv-voice-list">
-              {p.voiceAssets.map((v) => (
-                <div
-                  key={v.id}
-                  className={`vv-voice-item ${p.refAudio?.id === v.id && (p.refAudio.source === "library" || p.refAudio.source === "upload") ? "selected" : ""}`}
-                  onClick={() =>
-                    p.onSelectVoiceAsset({ id: v.id, name: v.name, file_url: v.url } as AssetItem)
-                  }
-                >
-                  <div className="vv-voice-radio" />
-                  <div className="vv-voice-info">
-                    <div className="vv-voice-name">{v.name}</div>
-                    <div className="vv-voice-desc">{v.desc || ""}</div>
-                  </div>
-                  {v.url && (
-                    <button
-                      className={`vv-voice-play ${p.playingVoiceId === v.id ? "playing" : ""}`}
-                      onClick={(e) => {
-                        e.stopPropagation()
-                        p.onToggleVoicePlay(v)
-                      }}
-                    >
-                      {p.playingVoiceId === v.id ? <PauseCircleOutlined /> : <PlayCircleOutlined />}
-                    </button>
-                  )}
-                </div>
-              ))}
-            </div>
-          )}
-        </div>
-      )}
-
-      <div className="vv-tips">
-        <button className="vv-tips-head" onClick={p.onToggleVoiceTips}>
-          {p.voiceTipsOpen ? <CaretDownOutlined /> : <CaretRightOutlined />}
-          支持格式与录音建议
-        </button>
-        {p.voiceTipsOpen && <div className="vv-tips-body">{VOICE_TIPS}</div>}
-      </div>
-    </div>
-  )
-}
-
-export default VoicePickerSection

apps/web/src/pages/viral-video/hooks/useStoryboardEditor.ts

@@ -1,140 +0,0 @@
-import { useCallback, useState } from "react"
-
-// 最小化的 Storyboard 类型，避免循环依赖（字段名与 api/viral-video/types 对齐）
-export interface SbShot {
-  time_range: string
-  speaker?: string
-  shot_type_angle_movement: string
-  scene_and_dialogue: string
-  action_details: string
-  audio_bgm: string
-  transition: string
-  reference_image_index?: number
-}
-export interface SbOverview {
-  theme: string
-  total_duration: string
-  aspect_ratio: string
-}
-export interface SbDoc {
-  overview: SbOverview
-  scene_and_lighting: string
-  shots: SbShot[]
-  hard_constraints: string[]
-  negative_prompts: string[]
-  voiceover_script: string
-  copy_display_markdown: string
-}
-
-export type SbUpdater = (patch: (sb: SbDoc) => SbDoc) => void
-
-export interface StoryboardEditor {
-  editingField: string | null
-  startEdit: (field: string) => void
-  cancelEdit: () => void
-  updateShot: (idx: number, patch: Partial<SbShot>) => void
-  updateOverview: (patch: Partial<SbOverview>) => void
-  updateSbField: <K extends keyof SbDoc>(key: K, value: SbDoc[K]) => void
-  updateConstraint: (list: "hard_constraints" | "negative_prompts", idx: number, v: string) => void
-  addConstraint: (list: "hard_constraints" | "negative_prompts") => void
-  removeConstraint: (list: "hard_constraints" | "negative_prompts", idx: number) => void
-  commitField: (field: string, value: string) => void
-}
-
-/**
- * 分镜脚本编辑器 hook：管理 editingField 状态，以及 storyboard 字段级更新方法。
- * 父组件传入 updateSb(fn) 即可，fn 接收当前 sb 返回新 sb（immer 风格）。
- */
-export function useStoryboardEditor(updateSb: SbUpdater): StoryboardEditor {
-  const [editingField, setEditingField] = useState<string | null>(null)
-
-  const startEdit = useCallback((field: string) => {
-    setEditingField(field)
-  }, [])
-
-  const cancelEdit = useCallback(() => {
-    setEditingField(null)
-  }, [])
-
-  const updateShot = useCallback(
-    (idx: number, patch: Partial<SbShot>) => {
-      updateSb((sb) => ({
-        ...sb,
-        shots: sb.shots.map((s, i) => (i === idx ? { ...s, ...patch } : s)),
-      }))
-    },
-    [updateSb],
-  )
-
-  const updateOverview = useCallback(
-    (patch: Partial<SbOverview>) => {
-      updateSb((sb) => ({ ...sb, overview: { ...sb.overview, ...patch } }))
-    },
-    [updateSb],
-  )
-
-  const updateSbField = useCallback(
-    <K extends keyof SbDoc>(key: K, value: SbDoc[K]) => {
-      updateSb((sb) => ({ ...sb, [key]: value }))
-    },
-    [updateSb],
-  )
-
-  const updateConstraint = useCallback(
-    (list: "hard_constraints" | "negative_prompts", idx: number, v: string) => {
-      updateSb((sb) => {
-        const arr = [...sb[list]]
-        arr[idx] = v
-        return { ...sb, [list]: arr }
-      })
-    },
-    [updateSb],
-  )
-
-  const addConstraint = useCallback(
-    (list: "hard_constraints" | "negative_prompts") => {
-      updateSb((sb) => ({ ...sb, [list]: [...sb[list], ""] }))
-    },
-    [updateSb],
-  )
-
-  const removeConstraint = useCallback(
-    (list: "hard_constraints" | "negative_prompts", idx: number) => {
-      updateSb((sb) => ({ ...sb, [list]: sb[list].filter((_, i) => i !== idx) }))
-    },
-    [updateSb],
-  )
-
-  const commitField = useCallback(
-    (field: string, value: string) => {
-      if (field.startsWith("shot.")) {
-        const parts = field.split(".")
-        const idx = Number(parts[1])
-        const shotField = parts.slice(2).join(".") as keyof SbShot
-        updateShot(idx, { [shotField]: value } as Partial<SbShot>)
-      } else if (field.startsWith("overview.")) {
-        const f = field.split(".")[1] as keyof SbOverview
-        updateOverview({ [f]: value } as Partial<SbOverview>)
-      } else if (field === "scene_and_lighting" || field === "voiceover_script") {
-        updateSbField(field, value)
-      }
-      setEditingField(null)
-    },
-    [updateShot, updateOverview, updateSbField],
-  )
-
-  return {
-    editingField,
-    startEdit,
-    cancelEdit,
-    updateShot,
-    updateOverview,
-    updateSbField,
-    updateConstraint,
-    addConstraint,
-    removeConstraint,
-    commitField,
-  }
-}
-
-export default useStoryboardEditor

apps/web/src/pages/viral-video/hooks/useViralVideoHandlers.ts

@@ -1,403 +0,0 @@
-import { useCallback, useEffect } from "react"
-import axios from "axios"
-import { message } from "antd"
-import { isVideoStage, isCopyStage, getJobStage } from "@/api/viral-video/types"
-import type { UIStep, TabTask } from "../types"
-import {
-  retryViralVideo,
-  analyzeViralImages,
-  generateViralCopy,
-  confirmViralCopy,
-} from "@/api/viral-video"
-import type { CopyResult } from "@/api/viral-video/types"
-import type { ViralVideoJob } from "@/api/viral-video/types"
-import { applyPollUpdate } from "../utils/applyPollUpdate"
-import {
-  useViralVideoMedia,
-  type UseViralVideoMediaOptions,
-  type MediaActions,
-} from "./useViralVideoMedia"
-import { resolveModelSwitch } from "../utils/resolveModelSwitch"
-
-export interface ViralVideoActionsApi extends MediaActions {
-  resetTask: () => void
-  handleAnalyzeImages: () => void
-  handleGenerateCopy: () => void
-  handleGenerateVideo: () => void
-  handleRetry: () => void
-  onPollUpdate: (job: ViralVideoJob) => void
-  onScriptDelta: (ev: { data: { full_text?: string }; progress?: number; message?: string }) => void
-  handleModelChange: (
-    v: string,
-    videoModels: { key: string; supported_resolutions?: string[]; max_duration?: number }[],
-  ) => void
-  setTask: (patch: Partial<TabTask> | ((t: TabTask) => TabTask)) => void
-  setAssetPicker: React.Dispatch<
-    React.SetStateAction<{ open: boolean; kind: "image" | "video" | "voice"; multiple: boolean }>
-  >
-  setCloneModalOpen: React.Dispatch<React.SetStateAction<boolean>>
-  setPresetVoicePickerOpen: React.Dispatch<React.SetStateAction<boolean>>
-  refreshVoiceAssets: () => void
-  reloadMyVoices: () => void
-}
-
-export interface UseViralVideoHandlersOptions extends Omit<UseViralVideoMediaOptions, "setTask"> {
-  activeId: string
-  setTasks: React.Dispatch<React.SetStateAction<TabTask[]>>
-  videoModels: {
-    key: string
-    supported_resolutions?: string[]
-    max_duration?: number
-    display_name?: string
-  }[]
-}
-
-function emptyTask(id: string, title: string): TabTask {
-  return {
-    id,
-    title,
-    images: [],
-    refVideo: null,
-    voicePanel: null,
-    refAudio: null,
-    fusionLevel: "ai_full",
-    styleStrength: "medium",
-    userCopy: "",
-    industry: "",
-    targetCustomer: "",
-    language: "中文(普通话)",
-    viralStructure: "反差破局+亮明观点+还原现状",
-    marketingPurpose: "",
-    duration: 20,
-    persona: "",
-    videoRatio: "9:16",
-    videoModel: "seedance-2.5",
-    quality: "480p",
-    upscale: "default",
-    estimatedCredits: null,
-    estimatedCreditsError: false,
-    uiStep: "step1_upload",
-    imageAnalysis: null,
-    storyboard: null,
-    voiceTipsOpen: false,
-    job: null,
-    jobId: null,
-    playingVoiceId: null,
-    scriptStreamText: "",
-    scriptStreamProgress: 0,
-    scriptStreamMessage: "",
-  }
-}
-
-const CLEAR_STREAM = {
-  scriptStreamText: "",
-  scriptStreamProgress: 0,
-  scriptStreamMessage: "",
-} as const
-
-/**
- * 业务 action hook：聚合素材操作 + 三步骤 submit/retry/polling/model switch 等业务动作。
- */
-export function useViralVideoHandlers(opts: UseViralVideoHandlersOptions): ViralVideoActionsApi {
-  const {
-    task,
-    activeId,
-    setTasks,
-    setAssetPicker,
-    setCloneModalOpen,
-    refreshVoiceAssets,
-    reloadMyVoices,
-    setPresetVoicePickerOpen,
-  } = opts
-
-  const setTask = useCallback(
-    (patch: Partial<TabTask> | ((t: TabTask) => TabTask)) => {
-      setTasks((ts) =>
-        ts.map((t) =>
-          t.id === activeId ? (typeof patch === "function" ? patch(t) : { ...t, ...patch }) : t,
-        ),
-      )
-    },
-    [activeId, setTasks],
-  )
-
-  const media = useViralVideoMedia({
-    task,
-    setTask,
-    setAssetPicker,
-    setCloneModalOpen,
-    setPresetVoicePickerOpen,
-    refreshVoiceAssets,
-    reloadMyVoices,
-  })
-
-  // 卸载时停掉正在播放的音频
-  useEffect(() => () => media.audioRef.current?.pause(), [media.audioRef])
-
-  const resetTask = () => {
-    media.audioRef.current?.pause()
-    setTasks((ts) => ts.map((t) => (t.id === activeId ? emptyTask(t.id, t.title) : t)))
-  }
-
-  const handleAnalyzeImages = async () => {
-    const readyImgs = task.images.filter((i) => i.ossUrl && !i.uploading)
-    if (readyImgs.length === 0) {
-      message.warning("请至少上传 1 张产品图")
-      return
-    }
-    if (task.images.some((i) => i.uploading)) {
-      message.warning("图片上传中，请稍候")
-      return
-    }
-    if (task.refVideo?.uploading) {
-      message.warning("参考视频上传中，请稍候")
-      return
-    }
-    setTask({
-      uiStep: "step1_analyzing",
-      jobId: null,
-      job: null,
-      analysisError: undefined,
-      copyError: undefined,
-      videoError: undefined,
-      imageAnalysis: undefined,
-      storyboard: undefined,
-      ...CLEAR_STREAM,
-      estimatedCredits: null,
-      estimatedCreditsError: false,
-    })
-    try {
-      const job = await analyzeViralImages({
-        images: readyImgs.map((i) => i.ossUrl as string),
-        reference_video_url: task.refVideo?.ossUrl || undefined,
-        style_strength: task.refVideo?.ossUrl ? task.styleStrength : undefined,
-      })
-      setTask({ job, jobId: job.id })
-      message.success("已提交图片分析…")
-    } catch (err: unknown) {
-      message.error(err instanceof Error ? err.message : "分析失败")
-      setTask({
-        uiStep: "failed",
-        analysisError: err instanceof Error ? err.message : "分析失败",
-        copyError: undefined,
-        videoError: undefined,
-      })
-    }
-  }
-
-  const handleGenerateCopy = async () => {
-    if (!task.jobId) {
-      message.warning("请先完成图片分析")
-      return
-    }
-    setTask({
-      uiStep: "step2_generating",
-      copyError: undefined,
-      videoError: undefined,
-      analysisError: undefined,
-      ...CLEAR_STREAM,
-    })
-    try {
-      const job = await generateViralCopy(task.jobId, {
-        industry: task.industry || undefined,
-        target_customer: task.targetCustomer || undefined,
-        viral_structure: task.viralStructure || undefined,
-        marketing_purpose: task.marketingPurpose || undefined,
-        duration: task.duration,
-        persona_id: task.persona || undefined,
-        user_copy_text:
-          (task.fusionLevel === "user_primary" || task.fusionLevel === "ai_polish") && task.userCopy
-            ? task.userCopy
-            : undefined,
-        fusion_level: task.fusionLevel,
-        style_strength: task.refVideo?.ossUrl ? task.styleStrength : undefined,
-        voice_id:
-          task.refAudio?.source === "preset"
-            ? task.refAudio.id
-            : task.refAudio?.source === "my_voice"
-              ? task.refAudio.ttsVoiceId || task.refAudio.id
-              : undefined,
-        voice_source: task.refAudio?.source || undefined,
-        video_ratio: task.videoRatio,
-        video_model: task.videoModel,
-      })
-      setTask({ job })
-    } catch (err: unknown) {
-      message.error(err instanceof Error ? err.message : "文案生成失败")
-      setTask({
-        uiStep: "failed",
-        copyError: err instanceof Error ? err.message : "文案生成失败",
-        videoError: undefined,
-        analysisError: undefined,
-      })
-    }
-  }
-
-  const handleGenerateVideo = async () => {
-    setTask({
-      uiStep: "step3_generating",
-      videoError: undefined,
-      copyError: undefined,
-      analysisError: undefined,
-      ...CLEAR_STREAM,
-    })
-    try {
-      let job
-      if (task.jobId && task.storyboard && task.storyboard.voiceover_script.trim()) {
-        const edited = task.storyboard.voiceover_script.trim()
-        const originalCopy =
-          (task.job?.copy_result as CopyResult | null | undefined)?.voiceover_script ||
-          task.job?.copy_result?.final_copy ||
-          ""
-        job = await confirmViralCopy(task.jobId, {
-          edited_copy: edited && edited !== originalCopy.trim() ? edited : undefined,
-          video_model: task.videoModel,
-          video_resolution: task.quality,
-          video_ratio: task.videoRatio,
-          duration: task.duration,
-          voice_id:
-            task.refAudio?.source === "preset"
-              ? task.refAudio.id
-              : task.refAudio?.source === "my_voice"
-                ? task.refAudio.ttsVoiceId || task.refAudio.id
-                : undefined,
-          voice_source: task.refAudio?.source || undefined,
-          language: task.language || undefined,
-        })
-      } else {
-        message.warning("请先生成文案后再生成视频")
-        setTask({
-          uiStep: task.storyboard
-            ? "step2_copy_ready"
-            : task.imageAnalysis
-              ? "step1_done"
-              : "step1_upload",
-        })
-        return
-      }
-      setTask({ job, jobId: job.id })
-      message.success("视频已提交生成，预计 1-3 分钟…")
-    } catch (err: unknown) {
-      if (axios.isAxiosError(err) && err.response?.status === 402) {
-        const detail =
-          (err.response.data as { detail?: string; message?: string; msg?: string } | undefined)
-            ?.detail ||
-          (err.response.data as { detail?: string; message?: string; msg?: string } | undefined)
-            ?.message ||
-          "积分不足，请充值"
-        message.error(detail)
-        setTask({
-          uiStep: "step2_copy_ready",
-          videoError: detail,
-          copyError: undefined,
-          analysisError: undefined,
-          ...CLEAR_STREAM,
-        })
-        return
-      }
-      const msg = err instanceof Error ? err.message : "提交失败"
-      message.error(msg)
-      setTask({ uiStep: "failed", videoError: msg, copyError: undefined, analysisError: undefined })
-    }
-  }
-
-  const handleRetry = async () => {
-    if (task.jobId) {
-      try {
-        const j = await retryViralVideo(task.jobId)
-        const retryStage = getJobStage(j)
-        let retryStep: UIStep = "step1_analyzing"
-        if (isVideoStage(retryStage)) retryStep = "step3_generating"
-        else if (isCopyStage(retryStage)) retryStep = "step2_generating"
-        else if (task.storyboard) retryStep = "step2_copy_ready"
-        else if (task.imageAnalysis) retryStep = "step1_done"
-        setTask({
-          job: j,
-          jobId: j.id,
-          uiStep: retryStep,
-          videoError: undefined,
-          copyError: undefined,
-          analysisError: undefined,
-          imageAnalysis: undefined,
-          storyboard: undefined,
-          ...CLEAR_STREAM,
-          estimatedCredits: null,
-          estimatedCreditsError: false,
-        })
-        message.success("已重试")
-      } catch (err: unknown) {
-        message.error(err instanceof Error ? err.message : "重试失败")
-      }
-    } else {
-      setTask({
-        uiStep: task.storyboard ? "step2_copy_ready" : "step1_done",
-        jobId: null,
-        job: null,
-        videoError: undefined,
-        copyError: undefined,
-        analysisError: undefined,
-        imageAnalysis: undefined,
-        storyboard: undefined,
-        ...CLEAR_STREAM,
-        estimatedCredits: null,
-        estimatedCreditsError: false,
-      })
-    }
-  }
-
-  const onPollUpdate = useCallback(
-    (job: ViralVideoJob) => {
-      setTask((t) => applyPollUpdate(t, job))
-    },
-    [setTask],
-  )
-
-  const onScriptDelta = useCallback(
-    (ev: { data: { full_text?: string }; progress?: number; message?: string }) => {
-      setTask((t) => ({
-        ...t,
-        scriptStreamText: ev.data.full_text || t.scriptStreamText,
-        scriptStreamProgress:
-          typeof ev.progress === "number" ? ev.progress : t.scriptStreamProgress,
-        scriptStreamMessage: ev.message || t.scriptStreamMessage,
-      }))
-    },
-    [setTask],
-  )
-
-  const handleModelChange = (
-    v: string,
-    vms: { key: string; supported_resolutions?: string[]; max_duration?: number }[],
-  ) => {
-    const m = vms.find((x) => x && x.key === v)
-    if (!m) {
-      setTask({ videoModel: v })
-      return
-    }
-    const { quality, duration } = resolveModelSwitch(
-      { quality: task.quality, duration: task.duration },
-      m,
-    )
-    setTask({ videoModel: v, quality, duration })
-  }
-
-  return {
-    ...media,
-    resetTask,
-    handleAnalyzeImages,
-    handleGenerateCopy,
-    handleGenerateVideo,
-    handleRetry,
-    onPollUpdate,
-    onScriptDelta,
-    handleModelChange,
-    setTask,
-    setAssetPicker,
-    setCloneModalOpen,
-    setPresetVoicePickerOpen,
-    refreshVoiceAssets,
-    reloadMyVoices,
-  }
-}
-
-export default useViralVideoHandlers

apps/web/src/pages/viral-video/hooks/useViralVideoMedia.ts

@@ -1,349 +0,0 @@
-import { useCallback, useRef } from "react"
-import { message } from "antd"
-import { getAssetLibraries, uploadAssetDirect, type AssetItem } from "@/api/assets"
-import type { UploadedImage, RefVideo, RefAudio, VoicePanel, TabTask } from "../types"
-import type { VoiceClone } from "@/api/voice-clone"
-
-export interface UseViralVideoMediaOptions {
-  task: TabTask
-  setTask: (patch: Partial<TabTask> | ((t: TabTask) => TabTask)) => void
-  setAssetPicker: React.Dispatch<
-    React.SetStateAction<{ open: boolean; kind: "image" | "video" | "voice"; multiple: boolean }>
-  >
-  setCloneModalOpen: React.Dispatch<React.SetStateAction<boolean>>
-  setPresetVoicePickerOpen: React.Dispatch<React.SetStateAction<boolean>>
-  refreshVoiceAssets: () => void
-  reloadMyVoices: () => void
-}
-
-export interface MediaActions {
-  imgInputRef: React.MutableRefObject<HTMLInputElement | null>
-  videoInputRef: React.MutableRefObject<HTMLInputElement | null>
-  voiceInputRef: React.MutableRefObject<HTMLInputElement | null>
-  audioRef: React.MutableRefObject<HTMLAudioElement | null>
-  appendImagesFromFiles: (files: FileList | File[]) => void
-  appendImagesFromAssets: (assets: AssetItem[]) => void
-  clearImages: () => void
-  removeImg: (localId: string) => void
-  moveImg: (idx: number, dir: -1 | 1) => void
-  handleLocalRefVideo: (file: File) => void
-  removeRefVideo: () => void
-  handleVoiceFile: (file: File) => void
-  onCloneSuccess: (v: VoiceClone | { id?: string; name?: string; voice_id?: string | null }) => void
-  pickVoiceAsset: (a: AssetItem) => void
-  selectMyVoice: (v: VoiceClone) => void
-  toggleVoicePanel: (p: VoicePanel) => void
-  toggleVoice: (v: { id: string; url: string }) => void
-  openAssetPicker: (kind: "image" | "video" | "voice", multiple: boolean) => void
-}
-
-/**
- * 素材上传/音色选择/图片列表/参考视频等操作：独立 hook，保持每个文件 ≤400 行。
- */
-export function useViralVideoMedia(opts: UseViralVideoMediaOptions): MediaActions {
-  const {
-    task,
-    setTask,
-    setAssetPicker,
-    setCloneModalOpen,
-    refreshVoiceAssets,
-    setPresetVoicePickerOpen,
-  } = opts
-  const imgInputRef = useRef<HTMLInputElement>(null)
-  const videoInputRef = useRef<HTMLInputElement>(null)
-  const voiceInputRef = useRef<HTMLInputElement>(null)
-  const audioRef = useRef<HTMLAudioElement | null>(null)
-
-  const uploadFile = useCallback(
-    async (file: File, kind: "image" | "video" | "voice", onProgress?: (pct: number) => void) => {
-      const libs = await getAssetLibraries()
-      const lib = (libs as { kind: string; id: string }[]).find((l) => l.kind === kind) || libs[0]
-      if (!lib) throw new Error("未找到素材库")
-      const res = await uploadAssetDirect({
-        file,
-        library_id: lib.id,
-        onProgress: (p) => onProgress?.(Math.round(p)),
-      })
-      return res.url
-    },
-    [],
-  )
-
-  const appendImagesFromFiles = useCallback(
-    async (files: FileList | File[]) => {
-      const remaining = 9 - task.images.length
-      if (remaining <= 0) {
-        message.warning("最多上传 9 张产品图")
-        return
-      }
-      const arr = Array.from(files)
-        .filter((f) => f.type.startsWith("image/"))
-        .slice(0, remaining)
-      if (arr.length === 0) return
-      const newImgs: UploadedImage[] = arr.map((f) => ({
-        localId: `${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
-        url: URL.createObjectURL(f),
-        name: f.name,
-        size: f.size,
-        uploading: true,
-        pct: 0,
-        file: f,
-      }))
-      setTask((t) => ({
-        ...t,
-        images: [...t.images, ...newImgs.map(({ file: _f, ...rest }) => rest)],
-      }))
-      for (const item of newImgs) {
-        try {
-          const url = await uploadFile(item.file!, "image", (p) => {
-            setTask((t) => ({
-              ...t,
-              images: t.images.map((im) => (im.localId === item.localId ? { ...im, pct: p } : im)),
-            }))
-          })
-          setTask((t) => ({
-            ...t,
-            images: t.images.map((im) =>
-              im.localId === item.localId
-                ? {
-                    ...im,
-                    uploading: false,
-                    pct: 100,
-                    ossUrl: url,
-                    size: item.file!.size || im.size,
-                  }
-                : im,
-            ),
-          }))
-        } catch {
-          message.error(`${item.name} 上传失败`)
-          setTask((t) => ({ ...t, images: t.images.filter((im) => im.localId !== item.localId) }))
-        }
-      }
-    },
-    [task.images.length, setTask, uploadFile],
-  )
-
-  const appendImagesFromAssets = useCallback(
-    (assets: AssetItem[]) => {
-      const remaining = 9 - task.images.length
-      const picked = assets.slice(0, remaining)
-      if (picked.length === 0) return
-      const newImgs: UploadedImage[] = picked.map((a) => ({
-        localId: `lib_${a.id}_${Math.random().toString(36).slice(2, 6)}`,
-        url: a.thumbnail_url || a.file_url || "",
-        name: a.name || "未命名",
-        size: a.file_size || undefined,
-        uploading: false,
-        pct: 100,
-        ossUrl: a.file_url || undefined,
-      }))
-      setTask((t) => ({ ...t, images: [...t.images, ...newImgs] }))
-      message.success(`已添加 ${picked.length} 张图片`)
-    },
-    [task.images.length, setTask],
-  )
-
-  const clearImages = () => {
-    setTask((t) => {
-      t.images.forEach((im) => {
-        if (im.url?.startsWith("blob:")) URL.revokeObjectURL(im.url)
-      })
-      return {
-        ...t,
-        images: [],
-        imageAnalysis: null,
-        uiStep: "step1_upload",
-        storyboard: null,
-        job: null,
-        jobId: null,
-      }
-    })
-  }
-
-  const removeImg = (localId: string) => {
-    setTask((t) => {
-      const im = t.images.find((i) => i.localId === localId)
-      if (im?.url?.startsWith("blob:")) URL.revokeObjectURL(im.url)
-      const newImgs = t.images.filter((i) => i.localId !== localId)
-      return {
-        ...t,
-        images: newImgs,
-        imageAnalysis: newImgs.length === 0 ? null : t.imageAnalysis,
-        storyboard: newImgs.length === 0 ? null : t.storyboard,
-      }
-    })
-  }
-
-  const moveImg = (idx: number, dir: -1 | 1) => {
-    setTask((t) => {
-      const imgs = [...t.images]
-      const target = idx + dir
-      if (target < 0 || target >= imgs.length) return t
-      ;[imgs[idx], imgs[target]] = [imgs[target], imgs[idx]]
-      return { ...t, images: imgs }
-    })
-  }
-
-  const handleLocalRefVideo = useCallback(
-    async (file: File) => {
-      if (file.size > 200 * 1024 * 1024) {
-        message.warning("视频不能超过 200MB")
-        return
-      }
-      const localUrl = URL.createObjectURL(file)
-      setTask({
-        refVideo: {
-          source: "local",
-          url: localUrl,
-          name: file.name,
-          uploading: true,
-          pct: 0,
-          file,
-        } as RefVideo,
-      })
-      try {
-        const url = await uploadFile(file, "video", (p) => {
-          setTask((t) => (t.refVideo ? { ...t, refVideo: { ...t.refVideo, pct: p } } : t))
-        })
-        setTask((t) =>
-          t.refVideo
-            ? { ...t, refVideo: { ...t.refVideo, uploading: false, pct: 100, ossUrl: url } }
-            : t,
-        )
-      } catch {
-        message.error("参考视频上传失败")
-        if (localUrl.startsWith("blob:")) URL.revokeObjectURL(localUrl)
-        setTask({ refVideo: null })
-      }
-    },
-    [setTask, uploadFile],
-  )
-
-  const removeRefVideo = () => {
-    setTask((t) => {
-      if (t.refVideo?.url.startsWith("blob:")) URL.revokeObjectURL(t.refVideo.url)
-      return { ...t, refVideo: null }
-    })
-  }
-
-  const handleVoiceFile = useCallback(
-    async (file: File) => {
-      if (file.size > 10 * 1024 * 1024) {
-        message.warning("音频不能超过 10MB")
-        return
-      }
-      const localUrl = URL.createObjectURL(file)
-      try {
-        const url = await uploadFile(file, "voice")
-        setTask({
-          refAudio: { source: "upload", name: file.name, url, id: url } as RefAudio,
-          voicePanel: null,
-        })
-        message.success("音频已上传")
-        refreshVoiceAssets()
-      } catch {
-        message.error("音频上传失败")
-        URL.revokeObjectURL(localUrl)
-      }
-    },
-    [setTask, uploadFile, refreshVoiceAssets],
-  )
-
-  const onCloneSuccess = (
-    v: VoiceClone | { id?: string; name?: string; voice_id?: string | null },
-  ) => {
-    setCloneModalOpen(false)
-    opts.reloadMyVoices()
-    const vid = "voice_id" in v ? v.voice_id : undefined
-    if (v?.id) {
-      setTask({
-        refAudio: {
-          source: "my_voice",
-          id: v.id,
-          name: v.name || "我录制的音色",
-          ttsVoiceId: vid || undefined,
-        } as RefAudio,
-        voicePanel: null,
-      })
-      refreshVoiceAssets()
-      message.success("音色克隆完成，已自动选中")
-    }
-  }
-
-  const pickVoiceAsset = (asset: AssetItem) => {
-    setTask({
-      refAudio: {
-        source: "library",
-        id: asset.id,
-        name: asset.name,
-        url: asset.file_url || "",
-      } as RefAudio,
-      voicePanel: null,
-    })
-  }
-
-  const selectMyVoice = (v: VoiceClone) => {
-    setTask({
-      refAudio: {
-        source: "my_voice",
-        id: v.id,
-        name: v.name,
-        ttsVoiceId: v.voice_id || undefined,
-      } as RefAudio,
-      voicePanel: null,
-    })
-  }
-
-  const toggleVoicePanel = (p: VoicePanel) => {
-    if (p === "preset") {
-      setPresetVoicePickerOpen(true)
-      return
-    }
-    setTask({ voicePanel: task.voicePanel === p ? null : p })
-  }
-
-  const openAssetPicker = (kind: "image" | "video" | "voice", multiple: boolean) => {
-    setAssetPicker({ open: true, kind, multiple })
-  }
-
-  const toggleVoice = (v: { id: string; url: string }) => {
-    if (!v.url) return
-    if (task.playingVoiceId === v.id) {
-      audioRef.current?.pause()
-      audioRef.current = null
-      setTask({ playingVoiceId: null })
-      return
-    }
-    audioRef.current?.pause()
-    const a = new Audio(v.url)
-    a.dataset.playingId = v.id
-    a.onended = () => setTask({ playingVoiceId: null })
-    a.play().catch(() => {})
-    audioRef.current = a
-    setTask({ playingVoiceId: v.id })
-  }
-
-  return {
-    imgInputRef,
-    videoInputRef,
-    voiceInputRef,
-    audioRef,
-    appendImagesFromFiles,
-    appendImagesFromAssets,
-    clearImages,
-    removeImg,
-    moveImg,
-    handleLocalRefVideo,
-    removeRefVideo,
-    handleVoiceFile,
-    onCloneSuccess,
-    pickVoiceAsset,
-    selectMyVoice,
-    toggleVoicePanel,
-    toggleVoice,
-    openAssetPicker,
-  }
-}
-
-export default useViralVideoMedia

apps/web/src/pages/viral-video/hooks/useViralVideoPolling.ts

@@ -1,11 +1,6 @@
 import { useCallback, useEffect, useRef } from "react"
 import { getViralVideoJob } from "@/api/viral-video"
-import {
-  isAnalysisStage,
-  getJobStage,
-  type ViralVideoJob,
-  type ViralVideoStatus,
-} from "@/api/viral-video/types"
+import { isAnalysisStage, type ViralVideoJob, type ViralVideoStatus } from "@/api/viral-video/types"
 
 const TERMINAL: ViralVideoStatus[] = ["completed", "failed", "cancelled"]
 
@@ -16,9 +11,8 @@ export interface UseViralVideoPollingOptions {
 
 /**
  * 爆款视频任务 HTTP 轮询 hook。
- * - onUpdate 通过 ref 持有，避免 useCallback 依赖变化导致重启轮询。
- * - 任务进入终态（completed/failed/cancelled）后自动停止。
- * - 连续失败 20 次（约 2 分钟）后熔断。
+ * 负责持续拉取任务状态并回调给上层；上层负责根据状态/阶段切换 UI 文案。
+ * 任务进入终态（completed/failed/cancelled）后自动停止。
  */
 export function useViralVideoPolling(
   jobId: string | null | undefined,
@@ -29,9 +23,6 @@ export function useViralVideoPolling(
   const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const stoppedRef = useRef(false)
   const failCountRef = useRef(0)
-  // ref 持有最新 onUpdate，避免依赖变化导致 pollOnce 重建、轮询被重启
-  const onUpdateRef = useRef(onUpdate)
-  onUpdateRef.current = onUpdate
 
   const stop = useCallback(() => {
     stoppedRef.current = true
@@ -46,30 +37,26 @@ export function useViralVideoPolling(
       try {
         const job = await getViralVideoJob(id)
         failCountRef.current = 0
-        onUpdateRef.current(job)
+        onUpdate(job)
         if (TERMINAL.includes(job.status)) {
           stop()
           return
         }
         if (stoppedRef.current) return
-        const stage = getJobStage(job)
-        const inRender = stage === "rendering"
-        const isAnalyzing = isAnalysisStage(stage)
+        // 视频渲染阶段（Seedance 多段视频生成较慢）拉长轮询间隔
+        const inRender = job.progress_stage === "rendering"
+        // 分析阶段走默认间隔即可
+        const isAnalyzing = isAnalysisStage(job.progress_stage)
         const nextDelay = inRender ? 3000 : isAnalyzing ? 2000 : intervalMs
         timerRef.current = setTimeout(() => pollOnce(id), nextDelay)
       } catch (_err) {
         failCountRef.current += 1
         if (stoppedRef.current) return
-        if (failCountRef.current >= 20) {
-          // 轮询连续失败 20 次，停止轮询
-          stop()
-          return
-        }
         const delay = Math.min(intervalMs * 2 ** Math.min(failCountRef.current, 3), 10000)
         timerRef.current = setTimeout(() => pollOnce(id), delay)
       }
     },
-    [intervalMs, stop],
+    [intervalMs, onUpdate, stop],
   )
 
   useEffect(() => {

apps/web/src/pages/viral-video/hooks/useViralVideoWebSocket.ts

@@ -1,151 +0,0 @@
-import { useCallback, useEffect, useRef } from "react"
-
-export interface ViralVideoDeltaEvent {
-  type: "viral_video:script_delta"
-  job_id: string
-  stage: string
-  progress: number
-  message?: string
-  data: {
-    delta: string
-    full_text: string
-    text_length: number
-  }
-}
-
-export interface ViralVideoWSError {
-  message: string
-}
-
-export interface ViralVideoTerminalEvent {
-  type: "viral_video:completed" | "viral_video:failed" | "viral_video:copy_generated"
-  job_id: string
-}
-
-export interface UseViralVideoWSOptions {
-  /** delta 事件回调（script_delta 推送时触发） */
-  onDelta?: (ev: ViralVideoDeltaEvent) => void
-  /** 连接关闭/失败回调 */
-  onError?: (err: ViralVideoWSError) => void
-  /** 连接建立回调 */
-  onOpen?: () => void
-  /** P2-6: 收到终态事件（copy_generated/completed/failed）时回调，上层应立即主动拉取一次最新 job，减少终态延迟 */
-  onTerminal?: (ev: ViralVideoTerminalEvent) => void
-}
-
-const WS_SCHEME =
-  typeof window !== "undefined" && window.location.protocol === "https:" ? "wss:" : "ws:"
-
-function buildWsUrl(jobId: string): string {
-  const token = localStorage.getItem("access_token") || ""
-  const host = window.location.host
-  return `${WS_SCHEME}//${host}/api/v1/viral-video/ws/${jobId}?token=${encodeURIComponent(token)}`
-}
-
-/**
- * 爆款视频 WebSocket 订阅 hook。
- * 仅在 jobId 非空时建立连接；组件卸载/ jobId 变更时自动关闭。
- * 失败静默：后端已说明流式异常会自动 fallback 到 HTTP 轮询的 copy_generated 终态，
- * 前端不需要中断主流程，连接失败时只记录不影响轮询继续推进 UI。
- */
-export function useViralVideoWS(
-  jobId: string | null | undefined,
-  { onDelta, onError, onOpen, onTerminal }: UseViralVideoWSOptions = {},
-) {
-  const wsRef = useRef<WebSocket | null>(null)
-  const manualCloseRef = useRef(false)
-  const onDeltaRef = useRef(onDelta)
-  const onErrorRef = useRef(onError)
-  const onOpenRef = useRef(onOpen)
-  const onTerminalRef = useRef<UseViralVideoWSOptions["onTerminal"]>()
-  onDeltaRef.current = onDelta
-  onErrorRef.current = onError
-  onOpenRef.current = onOpen
-  onTerminalRef.current = onTerminal
-
-  const close = useCallback(() => {
-    manualCloseRef.current = true
-    if (wsRef.current) {
-      try {
-        wsRef.current.close()
-      } catch {
-        /* noop */
-      }
-      wsRef.current = null
-    }
-  }, [])
-
-  useEffect(() => {
-    if (!jobId) {
-      close()
-      return
-    }
-    manualCloseRef.current = false
-    let closed = false
-    let retryTimer: ReturnType<typeof setTimeout> | null = null
-    let startTimer: ReturnType<typeof setTimeout> | null = null
-    let retries = 0
-    const MAX_RETRIES = 3
-
-    const connect = () => {
-      if (closed) return
-      try {
-        const ws = new WebSocket(buildWsUrl(jobId))
-        wsRef.current = ws
-
-        ws.onopen = () => {
-          if (closed) return
-          retries = 0
-          onOpenRef.current?.()
-        }
-
-        ws.onmessage = (ev) => {
-          try {
-            const payload = JSON.parse(ev.data)
-            if (payload?.type === "viral_video:script_delta" && payload.data) {
-              onDeltaRef.current?.(payload as ViralVideoDeltaEvent)
-            } else if (
-              payload?.type === "viral_video:completed" ||
-              payload?.type === "viral_video:failed" ||
-              payload?.type === "viral_video:copy_generated"
-            ) {
-              // P2-6: 收到终态事件时主动通知上层立即拉取，降低终态延迟（不用等下一个轮询周期）
-              onTerminalRef.current?.(payload as ViralVideoTerminalEvent)
-            }
-            // 心跳/其他事件忽略
-          } catch {
-            // 心跳/非 JSON 消息忽略
-          }
-        }
-
-        ws.onerror = () => {
-          onErrorRef.current?.({ message: "websocket error" })
-        }
-
-        ws.onclose = () => {
-          wsRef.current = null
-          if (closed || manualCloseRef.current) return
-          if (retries < MAX_RETRIES) {
-            retries += 1
-            const delay = 500 * 2 ** (retries - 1)
-            retryTimer = setTimeout(connect, delay)
-          }
-        }
-      } catch (e) {
-        onErrorRef.current?.({ message: (e as Error).message })
-      }
-    }
-
-    // 延迟 100ms 再连，给后端 job 初始化留一点时间
-    startTimer = setTimeout(connect, 100)
-
-    return () => {
-      closed = true
-      if (startTimer) clearTimeout(startTimer)
-      if (retryTimer) clearTimeout(retryTimer)
-      close()
-    }
-  }, [jobId, close])
-
-  return { close }
-}

apps/web/src/pages/viral-video/types.ts

@@ -1,132 +0,0 @@
-import type {
-  FusionLevel,
-  StyleStrength,
-  ViralVideoJob,
-  ImageAnalysisResult,
-  CopyResult,
-  ShotScript,
-  ViralVideoModel,
-} from "@/api/viral-video/types"
-
-/* ─────────── UI 阶段（三步骤独立交互） ─────────── */
-export type UIStep =
-  | "step1_upload" // 初始：上传素材
-  | "step1_analyzing" // 图片分析中
-  | "step1_done" // 图片分析完成
-  | "step2_generating" // 文案生成中
-  | "step2_copy_ready" // 文案已生成，等待确认
-  | "step3_generating" // 视频生成中
-  | "step3_done" // 视频完成
-  | "failed" // 失败
-
-export const TERMINAL_UI_STEPS: UIStep[] = ["step3_done", "failed"]
-
-export type UploadedImage = {
-  localId: string
-  url: string
-  name: string
-  size: number | undefined
-  uploading: boolean
-  pct: number
-  ossUrl?: string
-  file?: File
-}
-
-export type RefVideo = {
-  source: "local"
-  url: string
-  name: string
-  uploading: boolean
-  pct: number
-  ossUrl?: string
-  file?: File
-} | null
-
-export type RefAudio = {
-  source: "preset" | "library" | "upload" | "clone" | "my_voice"
-  id?: string
-  name: string
-  url?: string
-  /** 克隆音色的 CosyVoice voice_id（source=my_voice 时使用） */
-  ttsVoiceId?: string
-} | null
-
-export type VoicePanel = "my_voices" | "preset" | "upload" | "library" | "record" | null
-
-// ── 分镜脚本数据模型（新后端 copy_result 结构） ──
-export interface StoryboardShot {
-  time_range: string
-  speaker?: string
-  shot_type_angle_movement: string
-  scene_and_dialogue: string
-  action_details: string
-  audio_bgm: string
-  transition: string
-  reference_image_index?: number
-}
-export interface Storyboard {
-  overview: { theme: string; total_duration: string; aspect_ratio: string }
-  scene_and_lighting: string
-  shots: StoryboardShot[]
-  hard_constraints: string[]
-  negative_prompts: string[]
-  voiceover_script: string
-  /** v3: 用户端展示用 markdown 文案（由提示词控制排版） */
-  copy_display_markdown: string
-}
-
-export type TabTask = {
-  id: string
-  title: string
-  // 素材
-  images: UploadedImage[]
-  refVideo: RefVideo
-  voicePanel: VoicePanel
-  refAudio: RefAudio
-  // STEP2 参数
-  fusionLevel: FusionLevel
-  styleStrength: StyleStrength
-  userCopy: string
-  industry: string
-  targetCustomer: string
-  persona: string
-  language: string
-  viralStructure: string
-  marketingPurpose: string
-  duration: number
-  // STEP3 设置
-  videoRatio: string
-  videoModel: string
-  quality: string
-  upscale: string
-  // 积分预估
-  estimatedCredits: number | null
-  estimatedCreditsError: boolean
-  // UI 状态
-  uiStep: UIStep
-  imageAnalysis: ImageAnalysisResult | null
-  storyboard: Storyboard | null
-  voiceTipsOpen: boolean
-  copyError?: string
-  videoError?: string
-  analysisError?: string
-  // 运行态（后端 job）
-  job: ViralVideoJob | null
-  jobId: string | null
-  playingVoiceId: string | null
-  // 分镜脚本流式预览
-  scriptStreamText: string
-  scriptStreamProgress: number
-  scriptStreamMessage: string
-}
-
-// re-export api types for convenience
-export type {
-  FusionLevel,
-  StyleStrength,
-  ViralVideoJob,
-  ImageAnalysisResult,
-  CopyResult,
-  ShotScript,
-  ViralVideoModel,
-}

apps/web/src/pages/viral-video/utils/applyPollUpdate.ts

@@ -1,99 +0,0 @@
-import { message } from "antd"
-import {
-  isVideoStage,
-  isCopyStage,
-  isImageAnalysisStage,
-  getJobStage,
-  type ViralVideoJob,
-} from "@/api/viral-video/types"
-import type { UIStep, TabTask } from "../types"
-import { TERMINAL_UI_STEPS } from "../types"
-import { copyResultToStoryboard } from "./copyResultToStoryboard"
-import { classifyJobError, cleanErrorMessage } from "./errorClassification"
-
-/**
- * 根据 job 状态计算下一个 TabTask 快照：单调性守卫 + 阶段推进 + 错误分类。
- * 返回 null 表示丢弃此次更新（终态守卫命中，使用旧状态即可）。
- */
-export function applyPollUpdate(t: TabTask, job: ViralVideoJob): TabTask {
-  if (
-    TERMINAL_UI_STEPS.includes(t.uiStep) &&
-    job.status !== "completed" &&
-    job.status !== "failed"
-  ) {
-    return t
-  }
-  let nextStep: UIStep = t.uiStep
-  let copyError = t.copyError
-  let videoError = t.videoError
-  let analysisError = t.analysisError
-  const err = job.error_message || job.error_msg
-  const nextImageAnalysis = job.image_analysis || t.imageAnalysis
-  const nextCopy = job.copy_result
-  const nextStoryboard = nextCopy ? copyResultToStoryboard(nextCopy) || t.storyboard : t.storyboard
-  const stage = getJobStage(job)
-
-  switch (job.status) {
-    case "image_analyzed":
-      nextStep = "step1_done"
-      copyError = undefined
-      break
-    case "copy_generated":
-      nextStep = "step2_copy_ready"
-      copyError = undefined
-      break
-    case "running":
-      if (isVideoStage(stage)) nextStep = "step3_generating"
-      else if (isCopyStage(stage)) nextStep = "step2_generating"
-      else if (isImageAnalysisStage(stage)) nextStep = "step1_analyzing"
-      copyError = undefined
-      videoError = undefined
-      break
-    case "completed":
-      nextStep = "step3_done"
-      copyError = undefined
-      videoError = undefined
-      break
-    case "failed": {
-      if (stage === "review" && err && (err.includes("合规") || err.includes("审核未通过"))) {
-        nextStep = "step2_copy_ready"
-        copyError = err
-        videoError = undefined
-        analysisError = undefined
-        message.warning(err)
-        break
-      }
-      nextStep = "failed"
-      const cleaned = cleanErrorMessage(err || "")
-      const kind = classifyJobError(cleaned, stage)
-      if (kind === "video") {
-        videoError = cleaned || "视频生成失败"
-        copyError = undefined
-        analysisError = undefined
-      } else if (kind === "image") {
-        analysisError = cleaned || "图片分析失败"
-        copyError = undefined
-        videoError = undefined
-      } else {
-        copyError = cleaned || "文案生成失败"
-        videoError = undefined
-        analysisError = undefined
-      }
-      break
-    }
-    case "pending":
-      break
-  }
-  return {
-    ...t,
-    job,
-    uiStep: nextStep,
-    imageAnalysis: nextImageAnalysis,
-    storyboard: nextStoryboard,
-    copyError,
-    videoError,
-    analysisError,
-  }
-}
-
-export default applyPollUpdate

apps/web/src/pages/viral-video/utils/copyResultToStoryboard.ts

@@ -1,71 +0,0 @@
-import type { Storyboard } from "../types"
-import type { CopyResult, ShotScript } from "@/api/viral-video/types"
-
-export function copyResultToStoryboard(cr: CopyResult | null | undefined): Storyboard | null {
-  if (!cr) return null
-  if (Array.isArray(cr.shots) && cr.overview) {
-    return {
-      overview: {
-        theme: cr.overview.theme || cr.title || "",
-        total_duration: (() => {
-          const d = cr.overview.total_duration
-          if (!d) return ""
-          return String(d).endsWith("s") ? String(d) : `${d}s`
-        })(),
-        aspect_ratio: cr.overview.aspect_ratio || "9:16",
-      },
-      scene_and_lighting: cr.scene_and_lighting || "",
-      shots: ((cr.shots ?? []) as ShotScript[]).map((s) => ({
-        time_range: s.time_range || "",
-        speaker: s.speaker || "",
-        shot_type_angle_movement: s.shot_type_angle_movement || "",
-        scene_and_dialogue: s.scene_and_dialogue || "",
-        action_details: s.action_details || "",
-        audio_bgm: s.audio_bgm || "",
-        transition: s.transition || "",
-        reference_image_index:
-          typeof s.reference_image_index === "number" ? s.reference_image_index : undefined,
-      })),
-      hard_constraints: Array.isArray(cr.hard_constraints) ? cr.hard_constraints : [],
-      negative_prompts: Array.isArray(cr.negative_prompts) ? cr.negative_prompts : [],
-      voiceover_script: cr.voiceover_script || cr.final_copy || cr.suggested_copy || "",
-      copy_display_markdown: cr.copy_display_markdown || "",
-    }
-  }
-  const finalCopy = cr.final_copy || cr.suggested_copy || ""
-  const title = cr.title || ""
-  return {
-    overview: { theme: title || "AI 分镜脚本", total_duration: "", aspect_ratio: "9:16" },
-    scene_and_lighting: "",
-    shots:
-      cr.scenes && cr.scenes.length
-        ? cr.scenes.map((sc, i: number) => ({
-            time_range: sc.duration
-              ? `${i * sc.duration}-${(i + 1) * sc.duration}s`
-              : `镜头${i + 1}`,
-            shot_type_angle_movement: sc.shot || "",
-            scene_and_dialogue: sc.narration || "",
-            action_details: "",
-            audio_bgm: "",
-            transition: "",
-          }))
-        : finalCopy
-          ? [
-              {
-                time_range: "0-15s",
-                shot_type_angle_movement: "",
-                scene_and_dialogue: finalCopy,
-                action_details: "",
-                audio_bgm: "",
-                transition: "",
-              },
-            ]
-          : [],
-    hard_constraints: [],
-    negative_prompts: [],
-    voiceover_script: finalCopy,
-    copy_display_markdown: cr.copy_display_markdown || "",
-  }
-}
-
-export default copyResultToStoryboard

apps/web/src/pages/viral-video/utils/errorClassification.ts

@@ -1,55 +0,0 @@
-import {
-  isCopyStage,
-  isImageAnalysisStage,
-  isVideoStage,
-  getJobStage,
-} from "@/api/viral-video/types"
-import type { ViralVideoJob, ViralVideoStage } from "@/api/viral-video/types"
-
-/**
- * 统一的视频/文案/图片阶段错误分类。
- * 优先按 stage 字段判定；stage 丢失时基于错误消息关键词兜底。
- */
-export type JobErrorKind = "image" | "copy" | "video"
-
-const VIDEO_ERR_RE =
-  /wan 3\.0|wan-?3|seedance|视频生成|视频下载|视频渲染|tts|配音|render|musetalk|lip.?sync/i
-const IMAGE_ERR_RE = /vlm|图片分析|vision|商品识别|ocr|image analysis|图片识别|图像分析/i
-
-export function classifyJobError(err: string, stage?: string | null): JobErrorKind {
-  const msg = err || ""
-  if (stage) {
-    const s = stage as ViralVideoStage
-    if (isVideoStage(s)) return "video"
-    if (isImageAnalysisStage(s)) return "image"
-    if (isCopyStage(s)) return "copy"
-  }
-  if (VIDEO_ERR_RE.test(msg)) return "video"
-  if (IMAGE_ERR_RE.test(msg)) return "image"
-  return "copy"
-}
-
-/**
- * 去掉后端错误消息中常见的"XX失败："前缀，避免前端 UI 重复前缀。
- */
-const ERROR_PREFIX_RE =
-  /^(视频生成失败|文案生成失败|图片分析失败|Wan 3\.0 视频生成失败|Seedance[0-9. ]*视频生成失败)[：:]\s*/g
-
-export function cleanErrorMessage(err: string): string {
-  if (!err) return ""
-  return err.replace(ERROR_PREFIX_RE, "").trim()
-}
-
-/**
- * 基于 job 统一提取错误分类和清理后的消息；无错误返回 null。
- */
-export function extractJobError(
-  job: ViralVideoJob | null | undefined,
-): { kind: JobErrorKind; msg: string } | null {
-  if (!job) return null
-  const raw = job.error_message || job.error_msg
-  if (!raw) return null
-  const stage = getJobStage(job)
-  const kind = classifyJobError(raw, stage)
-  return { kind, msg: cleanErrorMessage(raw) }
-}

apps/web/src/pages/viral-video/utils/renderMarkdown.ts

@@ -1,70 +0,0 @@
-/**
- * 极简 markdown 渲染器：仅支持粗体、斜体、标题、列表、换行。
- * 不依赖 marked 包（node_modules 中暂未安装），满足 viral-video 文案预览的
- * 简单排版需求。
- */
-function escapeHtml(s: string): string {
-  return s
-    .replace(/&/g, "&")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-}
-
-function inline(md: string): string {
-  let s = escapeHtml(md)
-  // bold **xxx**
-  s = s.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
-  // italic *xxx*
-  s = s.replace(/(^|[^*])\*([^*\n]+)\*/g, "$1<em>$2</em>")
-  // inline code `xxx`
-  s = s.replace(/`([^`]+)`/g, "<code>$1</code>")
-  return s
-}
-
-export function renderMarkdown(md: string): string {
-  if (!md) return ""
-  const lines = md.split(/\r?\n/)
-  const out: string[] = []
-  let inList = false
-  for (const raw of lines) {
-    const line = raw.trimEnd()
-    if (!line.trim()) {
-      if (inList) {
-        out.push("</ul>")
-        inList = false
-      }
-      continue
-    }
-    // headings
-    const h = line.match(/^(#{1,4})\s+(.*)$/)
-    if (h) {
-      if (inList) {
-        out.push("</ul>")
-        inList = false
-      }
-      const lvl = h[1].length
-      out.push(`<h${lvl}>${inline(h[2])}</h${lvl}>`)
-      continue
-    }
-    // unordered list
-    const li = line.match(/^\s*[-*]\s+(.*)$/)
-    if (li) {
-      if (!inList) {
-        out.push("<ul>")
-        inList = true
-      }
-      out.push(`<li>${inline(li[1])}</li>`)
-      continue
-    }
-    if (inList) {
-      out.push("</ul>")
-      inList = false
-    }
-    out.push(`<p>${inline(line)}</p>`)
-  }
-  if (inList) out.push("</ul>")
-  return out.join("\n")
-}
-
-export default renderMarkdown

apps/web/src/pages/viral-video/utils/resolveModelSwitch.ts

@@ -1,30 +0,0 @@
-import { RESOLUTION_ORDER } from "../ViralVideoPage.constants"
-
-/**
- * resolveModelSwitch 所需的最小模型信息（结构性类型，兼容 ViralVideoModel）。
- */
-export interface ModelSwitchInfo {
-  supported_resolutions?: string[]
-  max_duration?: number
-}
-
-/**
- * 切换视频模型时，联动修正分辨率/时长：新模型不支持当前分辨率则回退到最低支持，
- * 当前时长超过新模型 max_duration 则截断到 max_duration。
- */
-export function resolveModelSwitch(
-  cur: { quality: string; duration: number },
-  m: ModelSwitchInfo,
-): { quality: string; duration: number } {
-  const mRes = Array.isArray(m.supported_resolutions)
-    ? m.supported_resolutions
-    : ["480p", "720p", "1080p"]
-  const sortedRes = mRes.slice().sort((a, b) => {
-    const ra = RESOLUTION_ORDER.indexOf(a)
-    const rb = RESOLUTION_ORDER.indexOf(b)
-    return (rb === -1 ? -1 : rb) - (ra === -1 ? -1 : ra)
-  })
-  const newRes = mRes.includes(cur.quality) ? cur.quality : sortedRes[0] || "480p"
-  const newDur = Math.min(cur.duration, typeof m.max_duration === "number" ? m.max_duration : 15)
-  return { quality: newRes, duration: newDur }
-}

apps/web/src/router/appRoutes.tsx

@@ -116,6 +116,35 @@ const appChildren: RouteObject[] = [
     path: "profile",
     lazy: lazyRoute(() => import("@/pages/profile/Settings")),
   },
+  {
+    path: "admin",
+    children: [
+      {
+        index: true,
+        element: <Navigate to="/app/admin/ditto-emotion" replace />,
+      },
+      {
+        path: "ditto-emotion",
+        lazy: lazyRoute(() => import("@/pages/admin/DittoEmotionConfig")),
+      },
+      {
+        path: "users",
+        lazy: lazyRoute(() => import("@/pages/admin/AdminComingSoon")),
+      },
+      {
+        path: "analytics",
+        lazy: lazyRoute(() => import("@/pages/admin/AdminComingSoon")),
+      },
+      {
+        path: "monitor",
+        lazy: lazyRoute(() => import("@/pages/admin/AdminComingSoon")),
+      },
+      {
+        path: "logs",
+        lazy: lazyRoute(() => import("@/pages/admin/AdminComingSoon")),
+      },
+    ],
+  },
 ]
 
 export const appRoutes: RouteObject = {

apps/web/src/test/api/viral-video.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest"
 import {
+  generateViralVideo,
   getViralVideoJob,
+  confirmViralVideoIntent,
   retryViralVideo,
   getViralVideoHistory,
   getViralStyleTemplates,
@@ -74,10 +76,10 @@ describe("viral-video constants & stage helpers", () => {
   })
 
   it("isCopyStage", () => {
+    expect(isCopyStage("intent_parsing")).toBe(true)
     expect(isCopyStage("script_generation")).toBe(true)
     expect(isCopyStage("review")).toBe(true)
     expect(isCopyStage("tts")).toBe(false)
-    expect(isCopyStage("image_analysis")).toBe(false)
   })
 
   it("isAnalysisStage is union", () => {
@@ -99,6 +101,14 @@ describe("viral-video API wrappers", () => {
     mockPost.mockResolvedValue({ data: {} })
   })
 
+  it("generateViralVideo", async () => {
+    mockPost.mockResolvedValue({ data: { id: "j1" } })
+    const r = generateViralVideo({ images: ["img1"] } as never)
+    vi.runAllTimersAsync()
+    expect(await r).toEqual({ id: "j1" })
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/generate", { images: ["img1"] })
+  })
+
   it("getViralVideoJob", async () => {
     mockGet.mockResolvedValue({ data: { id: "j2" } })
     const r = getViralVideoJob("j2")
@@ -107,6 +117,16 @@ describe("viral-video API wrappers", () => {
     expect(mockGet).toHaveBeenCalledWith("/viral-video/j2")
   })
 
+  it("confirmViralVideoIntent", async () => {
+    mockPost.mockResolvedValue({ data: { id: "j3" } })
+    const r = confirmViralVideoIntent("j3", { confirmed_copy: "hi" })
+    vi.runAllTimersAsync()
+    await r
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/j3/confirm-intent", {
+      confirmed_copy: "hi",
+    })
+  })
+
   it("retryViralVideo", async () => {
     mockPost.mockResolvedValue({ data: { id: "j4" } })
     await retryViralVideo("j4")

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

@@ -0,0 +1,32 @@
+import { describe, expect, it, vi } from "vitest"
+import { render, screen } from "@testing-library/react"
+import { MemoryRouter } from "react-router-dom"
+import AdminComingSoon from "@/pages/admin/AdminComingSoon"
+
+vi.mock("react-router-dom", async () => {
+  const actual = await vi.importActual("react-router-dom")
+  return {
+    ...actual,
+    useNavigate: () => vi.fn(),
+  }
+})
+
+describe("AdminComingSoon Page", () => {
+  it("should render without crashing", () => {
+    render(
+      <MemoryRouter>
+        <AdminComingSoon />
+      </MemoryRouter>,
+    )
+    expect(screen.getByText("Admin 后台暂未开放")).toBeTruthy()
+  })
+
+  it("should render back button", () => {
+    render(
+      <MemoryRouter>
+        <AdminComingSoon />
+      </MemoryRouter>,
+    )
+    expect(screen.getByText("返回首页")).toBeTruthy()
+  })
+})

apps/web/vitest.config.ts

@@ -29,8 +29,6 @@ export default defineConfig({
         "src/pages/assets/AssetLibrary.tsx",
         "src/pages/voice-materials/VoiceMaterialLibrary.tsx",
         "src/pages/viral-video/ViralVideoPage.tsx",
-        "src/pages/ai-avatar/AiAvatarPage.tsx",
-        "src/pages/ai-avatar/components/**",
       ],
       // CI 覆盖率门禁（Phase 4 后提升，逐步逼近目标）
       // 当前实际：行 ~62% / 分支 ~61% / 函数 ~25%

deploy/configs/.env.staging

@@ -252,9 +252,6 @@ DOUBAO_TIMEOUT=${DOUBAO_TIMEOUT}
 # 最大重试次数
 DOUBAO_MAX_RETRIES=${DOUBAO_MAX_RETRIES}
 
-# Ditto 情绪分析 LLM 调用超时（秒）
-DITTO_EMOTION_TIMEOUT=${DITTO_EMOTION_TIMEOUT}
-
 # 视觉模型（支持图片/视频理解的模型，model name 格式）
 DOUBAO_VISION_MODEL=${DOUBAO_VISION_MODEL}
 

infra/docker/nginx-production.conf

@@ -40,9 +40,7 @@ server {
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "upgrade";
-        proxy_read_timeout 3600s;
+        proxy_read_timeout 300s;
         proxy_send_timeout 300s;
         proxy_request_buffering off;
     }

infra/docker/nginx-staging.conf

@@ -39,9 +39,7 @@ server {
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "upgrade";
-        proxy_read_timeout 3600s;
+        proxy_read_timeout 300s;
         proxy_send_timeout 300s;
         proxy_request_buffering off;
     }

packages/adapters/sqlalchemy_impl/models.py

@@ -948,7 +948,6 @@ class ViralVideoJobModel(Base):
     persona_id = Column(String(36), nullable=False, default="")
     viral_structure = Column(String(50), nullable=False, default="")
     marketing_purpose = Column(String(100), nullable=False, default="")
-    tone = Column(String(50), nullable=False, default="")
     bgm_preference = Column(String(50), nullable=False, default="")
     duration = Column(Integer, nullable=False, default=30)
     user_copy_text = Column(Text, nullable=False, default="")

packages/adapters/sqlalchemy_impl/viral_video_repository.py

@@ -38,7 +38,6 @@ def _to_domain(model: ViralVideoJobModel) -> ViralVideoJob:
         persona_id=model.persona_id or "",
         viral_structure=model.viral_structure or "",
         marketing_purpose=model.marketing_purpose or "",
-        tone=getattr(model, "tone", "") or "",
         bgm_preference=model.bgm_preference or "",
         duration=model.duration or 15,
         user_copy_text=model.user_copy_text or "",
@@ -57,6 +56,7 @@ def _to_domain(model: ViralVideoJobModel) -> ViralVideoJob:
         current_stage=getattr(model, "current_stage", "") or "",
         phase_message=getattr(model, "phase_message", "") or "",
         heartbeat_at=getattr(model, "heartbeat_at", None),
+        intent_result=dict(model.intent_result) if model.intent_result else None,
         image_analysis=dict(model.image_analysis) if getattr(model, "image_analysis", None) else None,
         storyboard=list(model.storyboard) if getattr(model, "storyboard", None) else None,
         generated_copy_text=getattr(model, "generated_copy_text", "") or "",
@@ -92,7 +92,6 @@ class SQLAlchemyViralVideoJobRepository:
             persona_id=job.persona_id,
             viral_structure=job.viral_structure,
             marketing_purpose=job.marketing_purpose,
-            tone=getattr(job, "tone", "") or "",
             bgm_preference=job.bgm_preference,
             duration=job.duration,
             user_copy_text=job.user_copy_text,
@@ -111,6 +110,7 @@ class SQLAlchemyViralVideoJobRepository:
             current_stage=job.current_stage or "",
             phase_message=job.phase_message or "",
             heartbeat_at=job.heartbeat_at,
+            intent_result=job.intent_result,
             image_analysis=job.image_analysis,
             storyboard=job.storyboard,
             generated_copy_text=job.generated_copy_text,
@@ -139,6 +139,7 @@ class SQLAlchemyViralVideoJobRepository:
         model.current_stage = job.current_stage or ""
         model.phase_message = job.phase_message or ""
         model.heartbeat_at = job.heartbeat_at
+        model.intent_result = job.intent_result
         model.image_analysis = job.image_analysis
         model.storyboard = job.storyboard
         model.generated_copy_text = job.generated_copy_text or ""
@@ -161,7 +162,6 @@ class SQLAlchemyViralVideoJobRepository:
         model.persona_id = job.persona_id
         model.viral_structure = job.viral_structure
         model.marketing_purpose = job.marketing_purpose
-        model.tone = getattr(job, "tone", "") or ""
         model.bgm_preference = job.bgm_preference
         model.duration = job.duration
         model.fusion_level = job.fusion_level
@@ -199,7 +199,9 @@ class SQLAlchemyViralVideoJobRepository:
             self.session.query(ViralVideoJobModel)
             .filter(
                 ViralVideoJobModel.user_id == user_id,
-                ViralVideoJobModel.status.in_(["pending", "running", "image_analyzed", "copy_generated"]),
+                ViralVideoJobModel.status.in_(
+                    ["pending", "running", "wait_user_confirm", "image_analyzed", "copy_generated"]
+                ),
             )
             .count()
         )

packages/application/ditto_emotion_service.py

@@ -1,11 +1,10 @@
 """Ditto LLM 情绪分析服务 — #2076 后续：根据文案生成 emo_timeline.
 
 职责：
-1. 分句：先按 。！？； 句末标点切分；整段无句末标点且超长时按逗号等语义停顿二次切分
-2. 调 DoubaoClient.chat_completion 分析每句表情（emo: 0-7 八种全部开放, intensity: 0-1）
+1. 正则按 。！？； 初步分句
+2. 调 DoubaoClient.chat_completion 分析每句表情（emo: 0-7, intensity: 0-1）
 3. 结果 LRU 缓存（文案 hash → 情绪列表）
-4. LLM 失败/超时/格式错 → analyze 层预分句全中性兜底；build_timeline 识别全兜底特征后
-   返回空串不传 emo_timeline（避免压制 GPU 端自身表情逻辑），不阻塞生成
+4. LLM 失败/超时/格式错 → 返回空列表（降级中性表情，不阻塞生成）
 5. TTS 完成后按字数比例或 sentence_timings 对齐成秒级 timeline
 """
 
@@ -30,23 +29,10 @@ EMO_NEUTRAL = 4
 EMO_SAD = 5
 EMO_SURPRISE = 6
 EMO_CONTEMPT = 7
-ALLOWED_EMOS = set(range(8))  # 8 种表情全部开放（0-7）；超出范围的非法值仍会被降级为中性
-
-# 传给 Ditto 的 emo_timeline 强度下限：GPU 端表情混合公式修复后，intensity>=0.3
-# 目标情绪才能压过中性；LLM 常给陈述句打 0.1-0.2，信号太弱、表情效果一眼假。
-# 构造 timeline entry 时统一保底到该值（不影响 analyze 层 LLM 原始输出与日志排查）
-MIN_TIMELINE_INTENSITY = 0.35
+ALLOWED_EMOS = {EMO_HAPPY, EMO_NEUTRAL, EMO_SAD, EMO_SURPRISE}  # 营销场景白名单
 
 # ── 分句正则 ─────────────────────────────────────────────────────
 _SENT_SPLIT_RE = re.compile(r"(?<=[。！？；!?;])\s*")
-# 二次切分：逗号/分号/顿号/冒号等语义停顿（lookbehind 保留标点在前句末尾）
-_CLAUSE_SPLIT_RE = re.compile(r"(?<=[，,、：:])")
-# 整段无句末标点且超过该长度时才做逗号二次切分
-_SINGLE_SENTENCE_THRESHOLD = 30
-# 二次切分后过短片段（<10 字）向后并入相邻句，确保每段至少 10 字、语义相对完整
-# （如"心中有爱，眼里有光，"合并为一段）；避免长文案被切成十几个碎段导致
-# LLM 处理的句子过多而超时，且过碎片段语义不完整、情绪分析意义不大
-_MIN_CLAUSE_LEN = 10
 
 # ── 默认 prompt 模板文件路径 ──────────────────────────────────────
 _DEFAULT_PROMPT_PATH = Path(__file__).parent / "prompts" / "ditto_emotion.txt"
@@ -59,8 +45,8 @@ def _load_default_prompt() -> str:
         # 文件不存在时用极简兜底
         return (
             "分析文案每句话表情，输出JSON数组："
-            '[{"text":"句子","emo":4,"intensity":0.2}]，emo:0-7八种表情全部开放，'
-            "至少30%句子用非中性表情。\n【文案】\n{文案}"
+            '[{"text":"句子","emo":4,"intensity":0.2}]，emo:3开心4中性5伤心6惊讶，'
+            "禁止0/1/2/7。\n【文案】\n{文案}"
         )
 
 
@@ -88,8 +74,7 @@ class EmotionTimelineEntry:
         self.start = round(start, 2)
         self.end = round(end, 2)
         self.emo = emo
-        # 强度保底：低于 MIN_TIMELINE_INTENSITY 的信号在 GPU 混合公式中压不过中性
-        self.intensity = round(max(intensity, MIN_TIMELINE_INTENSITY), 2)
+        self.intensity = round(intensity, 2)
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -101,47 +86,12 @@ class EmotionTimelineEntry:
 
 
 # ── 分句 ─────────────────────────────────────────────────────────
-def _split_by_clauses(sentence: str) -> list[str]:
-    """按逗号/分号等语义停顿二次切分；过短片段（<10 字）向后并入相邻句，避免切太碎.
-
-    每段至少 10 字、尽量控制在 10-50 字左右（50 字为软上限，无更细停顿点时保持
-    语义完整不硬切）。例："心中有爱，眼里有光，"合并为一段而非各自成段。
-    """
-    raw = [c for c in _CLAUSE_SPLIT_RE.split(sentence) if c and c.strip()]
-    if len(raw) <= 1:
-        return [sentence]
-    merged: list[str] = []
-    buf = ""
-    for clause in raw:
-        if not buf:
-            buf = clause
-            continue
-        if len(buf) < _MIN_CLAUSE_LEN:
-            buf += clause
-            continue
-        merged.append(buf)
-        buf = clause
-    if buf:
-        if merged and len(buf) < _MIN_CLAUSE_LEN:
-            merged[-1] += buf
-        else:
-            merged.append(buf)
-    return [m.strip() for m in merged if m.strip()]
-
-
 def split_sentences(text: str) -> list[str]:
-    """按中文句末标点切分，过滤空串.
-
-    Bug1 修复：若按句末标点切分后只有 1 段且文本超过 30 字（文案全是逗号、
-    结尾无标点），再按逗号/分号等语义停顿做二次切分，避免整段只返回 1 个
-    segment 导致 LLM 只能对整段打一个表情。
-    """
+    """按中文句末标点切分，过滤空串."""
     if not text:
         return []
-    parts = [p.strip() for p in _SENT_SPLIT_RE.split(text.strip()) if p and p.strip()]
-    if len(parts) <= 1 and parts and len(parts[0]) > _SINGLE_SENTENCE_THRESHOLD:
-        parts = _split_by_clauses(parts[0])
-    return parts
+    parts = _SENT_SPLIT_RE.split(text.strip())
+    return [p.strip() for p in parts if p and p.strip()]
 
 
 # ── 解析 LLM 返回的 JSON ─────────────────────────────────────────
@@ -252,25 +202,6 @@ def align_timeline_by_timings(
     return entries
 
 
-# ── LLM 结果合理性校验（提示词遵循度排查）─────────────────────────
-# 感叹号或明显情绪关键词出现时，LLM 不应返回全中性/低强度
-_EMO_SIGNAL_RE = re.compile(r"[！!]|是不是|有没有|居然|竟然|只要|太坑|千万别|免费|赶紧|推荐|惊艳")
-
-
-def _warn_if_suspicious_all_neutral(text: str, segments: list[EmotionSegment]) -> None:
-    """文案含明显情绪信号但 LLM 返回全部 emo=4 且 intensity<=0.1 时打 warning 日志."""
-    if not segments:
-        return
-    all_flat = all(s.emo == EMO_NEUTRAL and s.intensity <= 0.1 for s in segments)
-    if all_flat and _EMO_SIGNAL_RE.search(text):
-        logger.warning(
-            "[ditto_emotion] 文案含情绪信号(感叹号/关键词)但 LLM 返回全中性/低强度，"
-            "疑似提示词遵循度差: text=%.80s, segments=%d",
-            text,
-            len(segments),
-        )
-
-
 # ── LLM 情绪分析服务 ─────────────────────────────────────────────
 class DittoEmotionService:
     """Ditto 情绪分析服务（带 LRU 缓存）."""
@@ -280,7 +211,6 @@ class DittoEmotionService:
 
         self.settings = settings or get_api_settings()
         self._client = None
-        self._client_api_key: str | None = None
 
     def _cfg(self, key: str) -> Any:
         """优先读后台 system_config，未配置则回退到 settings（env 默认）."""
@@ -306,16 +236,10 @@ class DittoEmotionService:
         return hashlib.md5(text.strip().encode("utf-8")).hexdigest()
 
     def _get_llm_client(self):
-        """创建/复用 DoubaoClient；API Key 优先读后台配置（DB），fallback 环境变量。
+        if self._client is None:
+            from packages.shared.ai_client import get_doubao_client
 
-        后台可能随时改 doubao_api_key，每次调用前对比 key，变化则重建 client。
-        """
-        api_key = (self._cfg("doubao_api_key") or "").strip()
-        if self._client is None or self._client_api_key != api_key:
-            from packages.shared.ai_client import DoubaoClient
-
-            self._client = DoubaoClient(api_key=api_key)
-            self._client_api_key = api_key
+            self._client = get_doubao_client()
         return self._client
 
     def _call_llm(self, text: str) -> list[EmotionSegment]:
@@ -344,8 +268,6 @@ class DittoEmotionService:
         segments = _parse_emotion_json(result)
         if not segments:
             logger.warning("[ditto_emotion] LLM 返回解析失败: %s", result[:200])
-        else:
-            _warn_if_suspicious_all_neutral(text, segments)
         return segments
 
     def analyze(self, text: str) -> list[EmotionSegment]:
@@ -368,18 +290,6 @@ class DittoEmotionService:
         segments = self.analyze(text)
         if not segments:
             return ""
-        # LLM 失败/异常时 _cached_analyze 会兜底返回"全中性(emo=4)+低强度(<=0.1)"的
-        # 预分句结果；把这种"明确的全中性指令"传给 GPU 会压制 Ditto 端
-        # use_script_emo/emo_global 的自身处理，比不传更糟糕。识别全兜底特征后
-        # 返回空串（payload 不带 emo_timeline），交由 GPU 端自行决定表情。
-        # 注意：LLM 真实分析即使全中性，intensity 一般 >0.1，不会被误伤。
-        if all(s.emo == EMO_NEUTRAL and s.intensity <= 0.1 for s in segments):
-            logger.info(
-                "[ditto_emotion] 分析结果全为中性低强度（疑似 LLM 兜底），"
-                "emo_timeline 置空交由 GPU 端处理: text=%.80s",
-                text,
-            )
-            return ""
         if sentence_timings:
             entries = align_timeline_by_timings(segments, sentence_timings, audio_duration)
         else:
@@ -399,7 +309,7 @@ def _cached_analyze(service: DittoEmotionService, cache_key: str, text: str) ->
     # 如果 LLM 返回空（比如分句数量不匹配），尝试直接对预分句结果分析
     if not segments:
         pre_splits = split_sentences(text)
-        if len(pre_splits) >= 1:
+        if len(pre_splits) > 1:
             # 用预分句结果兜底：全中性低强度
             segments = [EmotionSegment(text=s, emo=EMO_NEUTRAL, intensity=0.1) for s in pre_splits]
     return segments

packages/application/ditto_service.py

@@ -5,17 +5,15 @@
 - POST /generate             生成口型视频（同步返回 MP4 流）
 
 关键特性：
-- 入参：video_url（人物驱动视频 URL，用户上传优先；未传时用 default_video_url 兜底）
-        + audio_url（TTS 音频 URL） + script（文案原文）
-        + emo_timeline（可选，LLM 情绪时间线 JSON 字符串）
+- 入参：video_url（人物模板视频 URL） + audio_url（TTS 音频 URL） + script（文案原文）
 - 出参：直接返回 video/mp4 字节流（自带音频，无需二次混流）
 - 429 时指数退避重试（最多 ditto_max_retries 次）
-- 500/超时/网络不可达视为失败
+- 500/超时视为失败
 - 输出 MP4 字节流转存到自家 OSS，返回公网 URL
 
 注意：
 - 保留 MuseTalk/GPU 路径不变；本服务作为更高优先级的第三条口型路径
-- video_url 时长对齐（视频<音频时循环延长）在 Celery 任务层用 ffmpeg 预处理
+- 不传 emotion/表情精细控制，使用默认 emo_global=4（中性）+ use_script_emo=true（关键词驱动表情）
 - Ditto 输出自带音视频，不需要 GFPGAN 超分，不需要 ffmpeg 音视频混流
 """
 
@@ -78,11 +76,7 @@ class DittoClient:
 
     @property
     def is_configured(self) -> bool:
-        """配置是否完整（base_url 必填 + 默认模板视频兜底 URL 有值）。
-
-        注意：即使 is_configured=True，实际生成时优先使用用户上传的 video_url；
-        default_video_url 仅作为用户未上传视频时的兜底。
-        """
+        """配置是否完整（base_url + 默认模板视频都有值）."""
         return bool(self.base_url) and bool(self.default_video_url)
 
     def health(self) -> bool:

packages/application/prompts/ditto_emotion.txt

@@ -1,42 +1,27 @@
-你是一个数字人短视频表情导演。为每句话分配一个最贴切的表情，让数字人表情丰富、有情绪感染力，像真人说话一样有起伏变化。
-
-【8种表情】
-0=愤怒：怒斥、骂坑、强烈不满、控诉
-1=厌恶：嫌弃、吐槽劣质、鄙视套路
-2=害怕：紧张、警告、危险提示、悬念
-3=开心：夸赞、推荐、好消息、福利、号召
-4=中性：陈述事实、客观描述、数据、过渡衔接
-5=伤心：共情痛点、遗憾、难过、踩坑经历
-6=惊讶：惊喜、超预期、居然、竟然、只要、数字冲击
-7=轻蔑：嘲讽、冷笑、拆穿套路、不屑
-
-【分句说明】
-- 输入文案已按句末标点预分句；若某句内部仍有明显语义停顿（逗号、分号），你应根据语义进一步拆分成更细的句子分别打分
-- 若输入没有句末标点，要自己根据语义在逗号处分句
-
-【强度】0.1几乎无变化 0.3轻微自然 0.5明显情绪 0.7强烈 0.9爆发
-感叹号结尾0.4-0.7，句号0.2-0.4，问号0.3-0.6。
-
-【示例1】
-文案："家人们！你们是不是经常买东西踩坑？花了大价钱买回来的东西根本没法用！但是今天这款产品真的惊艳到我了！"
-输出：
-[{"text":"家人们！","emo":6,"intensity":0.5},{"text":"你们是不是经常买东西踩坑？","emo":5,"intensity":0.3},{"text":"花了大价钱买回来的东西根本没法用！","emo":0,"intensity":0.5},{"text":"但是今天这款产品真的惊艳到我了！","emo":3,"intensity":0.6}]
-
-【示例2】
-文案："做公益不一定是一个人去做惊天动地的大事，而是一群人扎扎实实的干好身边的小事，心中有爱，眼里有光。"
-输出：
-[{"text":"做公益不一定是一个人去做惊天动地的大事，","emo":4,"intensity":0.2},{"text":"而是一群人扎扎实实的干好身边的小事，","emo":4,"intensity":0.2},{"text":"心中有爱，","emo":3,"intensity":0.4},{"text":"眼里有光。","emo":3,"intensity":0.5}]
-
-【关键要求】
-- 每句话都必须独立判断情绪，至少有30%的句子使用非中性(4)表情！感叹号结尾的句子intensity不得低于0.4！
-- 严禁全部句子都返回中性(4)！严禁全部强度都是0.1！
-- 情绪要有变化：痛点段伤心或愤怒→转折→卖点开心→福利惊讶→号召开心
-- 语义优先：根据每句话的实际语义选择表情，不要固定开头结尾情绪
-- 8种表情全部开放，该愤怒就愤怒(0)，该厌恶就厌恶(1)，该害怕就害怕(2)，该轻蔑就轻蔑(7)
-- 开头第一句就根据内容定情绪，不要强行用中性开场
-
-【输出】严格JSON数组，只输出JSON，不要其他文字。
-[{"text":"原文","emo":3,"intensity":0.5}]
-
+你是一个数字人视频表情导演。给定一段口播文案，分析每句话应该用什么表情和强度，让数字人说话时表情自然有变化，不僵硬。
+【表情编号】
+0=愤怒（营销场景禁用）
+1=厌恶（禁用）
+2=害怕（禁用）
+3=开心：介绍优点、优惠、好消息、号召行动时用
+4=中性：默认表情，陈述事实、平铺直叙时用
+5=伤心：仅在共情用户痛点时低强度使用（如"是不是经常遇到…"）
+6=惊讶：惊喜、意外、强调价值时用（如"居然""只要""竟然"）
+7=轻蔑（禁用）
+【强度说明】
+0.1-0.2：几乎看不出变化，比中性多一点情绪色彩
+0.3-0.4：有明显但自然的情绪，正常说话的波动
+0.5-0.6：较强情绪，感叹句/重点强调
+0.7+：极强情绪，极少使用
+【规则】
+1. 按自然语义分句，以。！？；为主要分界，逗号不分
+2. 60-70%的句子应该用中性(4)，不要每句都标情绪
+3. 情绪和内容匹配：卖点→开心(3)，痛点共情→伤心(5)低强度，惊喜/划算→惊讶(6)，陈述→中性(4)
+4. 相邻句子情绪不要剧烈跳变
+5. 感叹号结尾强度0.4-0.6，句号结尾一般0.1-0.3
+6. 开头结尾句用中性(4)或低强度开心(3)
+7. 禁止使用0/1/2/7
+【输出格式】严格JSON数组，不要输出其他内容
+[{"text":"句子原文","emo":3,"intensity":0.4}]
 【文案】
 {文案}

packages/application/viral_video/constants.py

@@ -1,86 +0,0 @@
-# -*- coding: utf-8 -*-
-"""爆款视频时长-字数-镜头数统一规范。
-
-prompt 模板与代码校验共用同一份数据，避免不一致。"""
-
-from __future__ import annotations
-
-# 时长规格：key=duration(秒)，value=对应约束
-DURATION_SPEC: dict[int, dict[str, int]] = {
-    5: {"min_chars": 12, "max_chars": 25, "min_shots": 1, "max_shots": 2},
-    10: {"min_chars": 25, "max_chars": 50, "min_shots": 2, "max_shots": 3},
-    15: {"min_chars": 38, "max_chars": 75, "min_shots": 3, "max_shots": 4},
-    20: {"min_chars": 50, "max_chars": 100, "min_shots": 4, "max_shots": 5},
-    30: {"min_chars": 75, "max_chars": 150, "min_shots": 6, "max_shots": 8},
-}
-
-
-def get_duration_spec(dur: int) -> dict[str, int]:
-    """获取时长规格；clamp 到 [5,30] 并选取最近档位。
-
-    注意：dur=0/falsey 时默认取 15 秒档位（兜底）；dur 为正数时按实际值 clamp。
-    """
-    if dur is None:
-        dur = 15
-    try:
-        d = int(dur)
-    except (TypeError, ValueError):
-        d = 15
-    if d <= 0:
-        d = 15
-    clamped = max(5, min(30, d))
-    nearest = min(DURATION_SPEC.keys(), key=lambda k: abs(k - clamped))
-    return DURATION_SPEC[nearest]
-
-
-def build_duration_constraint_text(dur: int) -> str:
-    """生成注入到 LLM user prompt 的字数/镜头数约束文本。"""
-    spec = get_duration_spec(dur)
-    return (
-        f"视频时长{dur}秒。口播总字数严格控制在{spec['min_chars']}~{spec['max_chars']}字之间"
-        f"（中文口播语速约3~5字/秒，{dur}秒={spec['max_chars']}字为硬上限，必须严格遵守，"
-        f"超长会被截断导致语义不完整）。"
-        f"分镜镜头数{spec['min_shots']}~{spec['max_shots']}个，每个镜头的time_range首尾相接，"
-        f"不得跳秒或重叠，每个镜头时长≥2秒。"
-    )
-
-
-def get_expected_shot_count(dur: int) -> tuple[int, int]:
-    """返回 (min_shots, max_shots)，供代码校验使用。"""
-    spec = get_duration_spec(dur)
-    return spec["min_shots"], spec["max_shots"]
-
-
-# ── Seedance 生成默认约束（worker/API 共用，避免硬编码漂移） ──────────────
-DEFAULT_HARD_CONSTRAINTS: list[str] = [
-    "无字幕、无水印、无任何自动生成文字、无 logo",
-    "严格还原参考图片中的真实场景、门店环境、商品陈列、人物外貌服装特征，不得凭空生成与参考图无关的人物、场景或物品",
-    "同一人物全程保持一致的五官、发型、服装、身材，不得换脸或变形",
-    "口播语音必须在指定时长内自然念完，语速自然，口型与语音同步",
-    "画面流畅无闪烁、无多余肢体、无扭曲变形、无穿模",
-    "色彩自然、曝光正确、电影级质感、高清细节",
-]
-
-DEFAULT_NEGATIVE_PROMPTS: list[str] = [
-    "字幕",
-    "自动字幕",
-    "水印",
-    "logo",
-    "图标",
-    "错误文字",
-    "乱码文字",
-    "男女声错配",
-    "中途换声",
-    "五官崩坏",
-    "脸部变形",
-    "多余手指",
-    "肢体扭曲",
-    "闪烁",
-    "画面抖动",
-    "模糊",
-    "低分辨率",
-]
-
-# API _build_copy_result 兼容老数据的兜底（比 worker 的短，仅用于老字段拼装）
-API_FALLBACK_HARD_CONSTRAINTS: list[str] = ["无字幕", "无水印", "人物一致性"]
-API_FALLBACK_NEGATIVE_PROMPTS: list[str] = ["字幕", "水印", "错误文字", "五官崩坏"]

packages/application/viral_video/generator.py

@@ -1,12 +1,427 @@
-# -*- coding: utf-8 -*-
-"""爆款视频旧 5 步编排器（已废弃）。
+"""爆款视频 5 步编排：图片分析 → 意图解析 → 文案融合 → 分镜 → 审核重写。
 
-PR1 (refactor/viral-video-backend-p0-deadcode-and-consistency)：CopyGenerator 整体删除。
-- 图片分析走 worker_app/tasks/vision 下的 V2 fast_path（analyze_images_v2）；
-- 文案/分镜/审核走 worker_app/tasks/viral_video.py 的 _step_script_generation / _step_review；
-- 旧的 intent_parsing / copy_fusion 两步早已在叙述优先重构中删除，不再有调用点。
-
-本文件保留为空壳，避免误导入；任何新代码请不要从这里 import。
+所有 LLM 调用走 DoubaoClient，单测通过 client 参数注入 mock，不真调 API。
+任何一步解析失败都走规则 fallback，不抛异常阻断。
 """
 
 from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from packages.application.viral_video import xml_parser as xp
+from packages.application.viral_video.prompt_loader import (
+    PromptTemplate,
+    get_template,
+    render_system_prompt,
+    render_user_prompt,
+)
+from packages.application.viral_video.prompts import (
+    FUSION_INSTRUCTIONS,
+    GLOBAL_CONSTRAINTS,
+    NEGATIVE_RULES,
+)
+from packages.application.viral_video.reviewer import Reviewer
+from packages.application.viral_video.schemas import (
+    BodyPoint,
+    Clip,
+    ColorItem,
+    CoreMessage,
+    FusionResult,
+    ImageAnalysis,
+    IntentResult,
+    KenBurns,
+    PersonalBrand,
+    ProductItem,
+    ReviewResult,
+    ScriptSegment,
+    Storyboard,
+    TextItem,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class CopyGenerator:
+    """5 步 Prompt 编排器。"""
+
+    def __init__(self, client=None, reviewer: Optional[Reviewer] = None):
+        if client is None:
+            from packages.shared.ai_client import get_doubao_client
+
+            client = get_doubao_client()
+        self.client = client
+        self.reviewer = reviewer or Reviewer(client)
+
+    # ── 底层调用 ────────────────────────────────────────────────────────
+    def _chat(self, template: PromptTemplate, system_kwargs: dict | None, **user_kwargs) -> str:
+        system = render_system_prompt(template, **(system_kwargs or {}))
+        user = render_user_prompt(template, **user_kwargs)
+        result = self.client.chat_completion(
+            [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            temperature=0.7,
+            max_tokens=2048,
+        )
+        return result or ""
+
+    # ── 步骤1：图片多模态分析 ───────────────────────────────────────────
+    def analyze_images(self, images: list[str], industry: str = "") -> ImageAnalysis:
+        template = get_template("image_analysis")
+        image_urls = "\n".join(f"第{i + 1}张：{url}" for i, url in enumerate(images))
+        system = render_system_prompt(template)
+        user = render_user_prompt(template, image_count=len(images), industry=industry or "通用", image_urls=image_urls)
+        raw = self.client.vision_completion(
+            [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            images=images,
+            max_tokens=2048,
+            temperature=0.3,
+        )
+        analysis = self._parse_image_analysis(raw or "")
+        if not analysis.products and not analysis.key_selling_points:
+            logger.warning("图片分析标签解析失败，走规则 fallback")
+            return self._fallback_image_analysis(images, raw or "")
+        return analysis
+
+    def _parse_image_analysis(self, raw: str) -> ImageAnalysis:
+        products = [
+            ProductItem(
+                name=n["attrs"].get("name", "无法判断"),
+                features=n["attrs"].get("features", "无法判断"),
+                position=n["attrs"].get("position", "secondary"),
+                image_index=xp.attr_int(n["attrs"].get("image_index"), 0),
+            )
+            for n in xp.find_all(raw, "product")
+        ]
+        colors = [
+            ColorItem(
+                hex=c["attrs"].get("hex", "#000000"),
+                name=c["attrs"].get("name", "无法判断"),
+                coverage=xp.attr_float(c["attrs"].get("coverage"), 0.0),
+            )
+            for c in xp.find_all(raw, "color")
+        ]
+        people = xp.find_first(raw, "people")
+        visible_text = [
+            TextItem(text=t["attrs"].get("text", ""), position=t["attrs"].get("position", ""))
+            for t in xp.find_all(raw, "text_item")
+        ]
+        quality_node = xp.find_first(raw, "quality")
+        selling_points = [n["text"] or n["attrs"].get("text", "") for n in xp.find_all(raw, "point")]
+        return ImageAnalysis(
+            products=products,
+            colors=colors,
+            has_person=xp.attr_bool(people["attrs"].get("has_person")) if people else False,
+            person_count=xp.attr_int(people["attrs"].get("count"), 0) if people else 0,
+            people=people["attrs"] if people else {},
+            mood=xp.text_of(raw, "mood"),
+            visible_text=visible_text,
+            scene=xp.text_of(raw, "scene"),
+            quality=quality_node["attrs"] if quality_node else {},
+            key_selling_points=[p for p in selling_points if p],
+            raw=raw,
+        )
+
+    def _fallback_image_analysis(self, images: list[str], raw: str) -> ImageAnalysis:
+        return ImageAnalysis(
+            products=[ProductItem(name="无法判断（视觉分析不可用）", image_index=0)],
+            scene="无法判断",
+            raw=raw,
+        )
+
+    # ── 步骤2：意图解析 ─────────────────────────────────────────────────
+    def parse_intent(self, user_copy_text: str, image_analysis: ImageAnalysis, industry: str = "") -> IntentResult:
+        template = get_template("intent_parsing")
+        raw = self._chat(
+            template,
+            None,
+            user_copy_text=user_copy_text or "（用户没有提供文案）",
+            industry=industry or "通用",
+            image_analysis=self._image_brief(image_analysis),
+        )
+        intent = self._parse_intent(raw)
+        if not intent.intent_summary and not intent.core_messages:
+            logger.warning("意图解析标签解析失败，走规则 fallback")
+            return self._fallback_intent(user_copy_text, raw)
+        return intent
+
+    def _parse_intent(self, raw: str) -> IntentResult:
+        messages = [
+            CoreMessage(
+                text=n["text"],
+                must_keep=xp.attr_bool(n["attrs"].get("must_keep"), default=False),
+                confidence=xp.attr_float(n["attrs"].get("confidence"), 0.0),
+            )
+            for n in xp.find_all(raw, "message")
+            if n["text"]
+        ]
+        brands = [
+            PersonalBrand(text=n["text"], category=n["attrs"].get("category", "brand"))
+            for n in xp.find_all(raw, "brand")
+            if n["text"]
+        ]
+        missing = [n["text"] for n in xp.find_all(raw, "info") if n["text"]]
+        return IntentResult(
+            intent_summary=xp.text_of(raw, "intent_summary"),
+            core_messages=messages,
+            personal_brands=brands,
+            emotion_tone=xp.text_of(raw, "emotion_tone"),
+            missing_info=missing,
+            raw=raw,
+        )
+
+    def _fallback_intent(self, user_copy_text: str, raw: str) -> IntentResult:
+        text = (user_copy_text or "").strip()
+        messages = [CoreMessage(text=text[:80], must_keep=True, confidence=1.0)] if text else []
+        return IntentResult(
+            intent_summary=text[:30] or "未提供文案，按产品图片自由创作",
+            core_messages=messages,
+            personal_brands=[],
+            raw=raw,
+        )
+
+    # ── 步骤3：文案融合生成（三档）──────────────────────────────────────
+    def fuse(
+        self,
+        fusion_level: str,
+        image_analysis: ImageAnalysis,
+        intent: IntentResult,
+        industry: str = "",
+        target_customer: str = "",
+        marketing_purpose: str = "",
+        duration: int = 15,
+    ) -> FusionResult:
+        template = get_template("copy_fusion")
+        system_kwargs = {
+            "fusion_instruction": FUSION_INSTRUCTIONS.get(fusion_level, FUSION_INSTRUCTIONS["ai_polish"]),
+            "global_constraints": GLOBAL_CONSTRAINTS,
+            "negative_rules": NEGATIVE_RULES,
+        }
+        raw = self._chat(
+            template,
+            system_kwargs,
+            industry=industry or "通用",
+            target_customer=target_customer or "通用消费者",
+            marketing_purpose=marketing_purpose or "产品种草",
+            duration=duration,
+            image_analysis=self._image_brief(image_analysis),
+            intent_result=self._intent_brief(intent),
+        )
+        result = self._parse_fusion(raw)
+        if not result.title and not result.script_segments:
+            logger.warning("文案融合标签解析失败（fusion=%s），走规则 fallback", fusion_level)
+            return self._fallback_fusion(fusion_level, image_analysis, intent, duration, raw)
+        return result
+
+    def _parse_fusion(self, raw: str) -> FusionResult:
+        body_points = [
+            BodyPoint(
+                text=n["text"],
+                elaboration=n["attrs"].get("elaboration", ""),
+                image_index=xp.attr_int(n["attrs"].get("image_index"), 0),
+            )
+            for n in xp.find_all(raw, "point")
+            if n["text"]
+        ]
+        segments = [
+            ScriptSegment(
+                text=n["text"],
+                duration_sec=xp.attr_float(n["attrs"].get("duration_sec"), 0.0),
+                image_index=xp.attr_int(n["attrs"].get("image_index"), 0),
+            )
+            for n in xp.find_all(raw, "segment")
+            if n["text"]
+        ]
+        return FusionResult(
+            title=xp.text_of(raw, "title"),
+            hook=xp.text_of(raw, "hook"),
+            body_points=body_points,
+            cta=xp.text_of(raw, "cta"),
+            script_segments=segments,
+            word_count=xp.attr_int(xp.text_of(raw, "word_count"), 0),
+            estimated_duration=xp.attr_int(xp.text_of(raw, "estimated_duration"), 0),
+            raw=raw,
+        )
+
+    def _fallback_fusion(
+        self,
+        fusion_level: str,
+        image_analysis: ImageAnalysis,
+        intent: IntentResult,
+        duration: int,
+        raw: str,
+    ) -> FusionResult:
+        product_name = image_analysis.products[0].name if image_analysis.products else "这款产品"
+        selling = image_analysis.key_selling_points[:2]
+        if fusion_level == "ai_full":
+            title = f"{product_name}，很多人用完都回购了"
+            hook = f"这个{product_name}，我想认真说说"
+            body = selling or ["图片可见的产品卖点"]
+            cta = "感兴趣的可以了解一下"
+        elif fusion_level == "user_primary":
+            user_text = intent.intent_summary or product_name
+            title = user_text[:20]
+            hook = user_text[:15]
+            body = [m.text for m in intent.core_messages] or [user_text]
+            cta = "想了解的可以看看"
+        else:
+            title = intent.intent_summary[:20] or product_name
+            hook = intent.core_messages[0].text[:15] if intent.core_messages else product_name
+            body = [m.text for m in intent.core_messages] or selling or [product_name]
+            cta = "有需要的可以了解一下"
+
+        brand_texts = [b.text for b in intent.personal_brands]
+        points = [BodyPoint(text=b) for b in body]
+        lines = [hook] + body + brand_texts[:2] + [cta]
+        joined = "，".join(lines)
+        per = max(3, duration // max(1, len(lines)))
+        segments = [ScriptSegment(text=line, duration_sec=per, image_index=0) for line in lines]
+        return FusionResult(
+            title=title,
+            hook=hook,
+            body_points=points,
+            cta=cta,
+            script_segments=segments,
+            word_count=len(joined),
+            estimated_duration=duration,
+            raw=raw,
+        )
+
+    # ── 步骤4：编导级分镜 ───────────────────────────────────────────────
+    def storyboard(
+        self, fusion: FusionResult, image_analysis: ImageAnalysis, images: list[str], duration: int
+    ) -> Storyboard:
+        template = get_template("storyboard")
+        raw = self._chat(
+            template,
+            None,
+            duration=duration,
+            image_count=len(images),
+            fusion_result=self._fusion_brief(fusion),
+            image_analysis=self._image_brief(image_analysis),
+        )
+        board = self._parse_storyboard(raw)
+        if not board.clips:
+            logger.warning("分镜标签解析失败，走规则 fallback")
+            return self._fallback_storyboard(fusion, duration, raw)
+        return board
+
+    def _parse_storyboard(self, raw: str) -> Storyboard:
+        clips: list[Clip] = []
+        for node in xp.find_all(raw, "clip"):
+            attrs = node["attrs"]
+            body = node["text"]
+            kb = xp.find_first(node["text"] and f"<root>{node['text']}</root>", "ken_burns")
+            clips.append(
+                Clip(
+                    image_index=xp.attr_int(attrs.get("image_index"), 0),
+                    transition=attrs.get("transition", "cut"),
+                    zoom=(None if attrs.get("zoom") in (None, "null", "None", "") else attrs.get("zoom")),
+                    duration_sec=xp.attr_float(attrs.get("duration_sec"), 0.0),
+                    bgm_note=attrs.get("bgm_note", ""),
+                    voice_text=xp.text_of(body and f"<root>{body}</root>", "voice_text"),
+                    subtitle_text=xp.text_of(body and f"<root>{body}</root>", "subtitle_text"),
+                    ken_burns=KenBurns(
+                        start=kb["attrs"].get("start", "0,0") if kb else "0,0",
+                        end=kb["attrs"].get("end", "0,0") if kb else "0,0",
+                        ease=kb["attrs"].get("ease", "linear") if kb else "linear",
+                    ),
+                )
+            )
+        return Storyboard(clips=clips, raw=raw)
+
+    def _fallback_storyboard(self, fusion: FusionResult, duration: int, raw: str) -> Storyboard:
+        segments = fusion.script_segments or [ScriptSegment(text=fusion.hook or fusion.title, duration_sec=duration)]
+        total = sum(s.duration_sec for s in segments) or duration
+        clips = [
+            Clip(
+                image_index=min(s.image_index, 0),
+                transition="cut",
+                duration_sec=max(2.0, s.duration_sec * duration / total if total else duration / len(segments)),
+                voice_text=s.text,
+                subtitle_text=s.text[:20],
+            )
+            for s in segments
+        ]
+        return Storyboard(clips=clips, raw=raw)
+
+    # ── 步骤5：审核（不通过自动重写1次）─────────────────────────────────
+    def review_and_rewrite(
+        self, fusion: FusionResult, intent: IntentResult, fusion_level: str
+    ) -> tuple[FusionResult, ReviewResult, int]:
+        """返回最终文案、最后一次审核结果、重写次数（0或1）。"""
+        review = self.reviewer.review(fusion, intent, fusion_level)
+        if review.passed:
+            return fusion, review, 0
+
+        logger.info("文案审核不通过，自动重写 1 次：%s", [i.text for i in review.issues])
+        rewritten = self.reviewer.rewrite(fusion, review, intent, fusion_level)
+        second = self.reviewer.review(rewritten, intent, fusion_level)
+        if second.passed:
+            return rewritten, second, 1
+        # 二次仍不通过：带上重写结果和问题返回，由上游决定是否交给前端
+        return rewritten, second, 1
+
+    # ── 全流程编排 ──────────────────────────────────────────────────────
+    def generate(
+        self,
+        images: list[str],
+        *,
+        industry: str = "",
+        target_customer: str = "",
+        marketing_purpose: str = "",
+        duration: int = 15,
+        user_copy_text: str = "",
+        fusion_level: str = "ai_polish",
+    ) -> dict:
+        image_analysis = self.analyze_images(images, industry)
+        intent = self.parse_intent(user_copy_text, image_analysis, industry)
+        fusion = self.fuse(
+            fusion_level,
+            image_analysis,
+            intent,
+            industry=industry,
+            target_customer=target_customer,
+            marketing_purpose=marketing_purpose,
+            duration=duration,
+        )
+        fusion, review, rewrites = self.review_and_rewrite(fusion, intent, fusion_level)
+        board = self.storyboard(fusion, image_analysis, images, duration)
+        return {
+            "image_analysis": image_analysis,
+            "intent_result": intent,
+            "fusion_result": fusion,
+            "review_result": review,
+            "storyboard": board,
+            "rewrite_count": rewrites,
+        }
+
+    # ── 简报工具 ────────────────────────────────────────────────────────
+    @staticmethod
+    def _image_brief(a) -> str:
+        if a is None:
+            return "无图片分析信息"
+        lines = [f"产品：{p.name}（{p.features}）" for p in a.products]
+        lines += [f"卖点：{s}" for s in a.key_selling_points]
+        lines.append(f"场景：{a.scene}")
+        return "\n".join(lines) or "无图片分析信息"
+
+    @staticmethod
+    def _intent_brief(i: IntentResult) -> str:
+        lines = [f"意图：{i.intent_summary}"]
+        lines += [f"核心信息[must_keep={m.must_keep}]：{m.text}" for m in i.core_messages]
+        lines += [f"事实（{b.category}）：{b.text}" for b in i.personal_brands]
+        return "\n".join(lines)
+
+    @staticmethod
+    def _fusion_brief(f: FusionResult) -> str:
+        lines = [f"标题：{f.title}", f"钩子：{f.hook}"]
+        lines += [f"要点：{p.text}" for p in f.body_points]
+        lines += [f"配音：{s.text}" for s in f.script_segments]
+        lines.append(f"行动号召：{f.cta}")
+        return "\n".join(lines)

packages/application/viral_video/param_guides.py

@@ -1,115 +0,0 @@
-"""爆款视频参数指导（persona/viral_structure/marketing_purpose/target_customer/language）。
-
-PR3 P2(h): 把原来 worker 里 130 行 if/elif 硬编码 mapping 迁到 DB 表
-`viral_video_param_guides`，提供 30 秒 TTL 缓存读取。DB miss 时返回 None，
-由调用方兜底到代码默认值（保证 worker 冷启动/DB 不可用时不阻断流程）。
-"""
-
-from __future__ import annotations
-
-import threading
-import time
-from typing import Optional
-
-import sqlalchemy as sa
-
-from packages.adapters.sqlalchemy_impl import session as _session_mod
-
-CACHE_TTL_SECONDS = 30.0
-
-VALID_GUIDE_TYPES = frozenset({"persona", "structure", "marketing_purpose", "target_customer", "language"})
-
-_lock = threading.Lock()
-# key = f"{guide_type}:{guide_key}", value = (expire_monotonic_ts, text|None)
-_cache: dict[str, tuple[float, Optional[str]]] = {}
-
-_lazy_session = None
-
-
-def _get_session():
-    """优先复用 worker 的 SessionLocal；否则懒建（API 场景）。"""
-    global _lazy_session
-    if _session_mod.SessionLocal is not None:
-        return _session_mod.SessionLocal()
-    if _lazy_session is not None:
-        return _lazy_session()
-    try:
-        from packages.config import get_shared_settings
-
-        url = str(get_shared_settings().database_url)
-    except Exception:  # noqa: BLE001
-        return None
-    if not url:
-        return None
-    url = url.replace("postgresql+asyncpg://", "postgresql+psycopg://")
-    if url.startswith("postgresql://") and "psycopg" not in url:
-        url = url.replace("postgresql://", "postgresql+psycopg://", 1)
-    engine = sa.create_engine(url, pool_pre_ping=True, pool_size=2, max_overflow=2)
-    from sqlalchemy.orm import sessionmaker
-
-    _lazy_session = sessionmaker(bind=engine)
-    return _lazy_session()
-
-
-def _cache_key(guide_type: str, guide_key: str) -> str:
-    return f"{guide_type}:{guide_key}"
-
-
-def _load_from_db(guide_type: str, guide_key: str) -> Optional[str]:
-    session = None
-    try:
-        session = _get_session()
-        if session is None:
-            return None
-        sql = sa.text("""
-            SELECT guide_text
-              FROM viral_video_param_guides
-             WHERE guide_type = :gt AND guide_key = :gk
-            """)
-        row = session.execute(sql, {"gt": guide_type, "gk": guide_key}).first()
-        if row is None:
-            return None
-        return row[0] if row[0] is not None else None
-    except Exception:  # noqa: BLE001 - 表不存在/DB 不可用静默返回 None
-        return None
-    finally:
-        if session is not None:
-            try:
-                session.close()
-            except Exception:  # noqa: BLE001
-                pass
-
-
-def get_param_guide(guide_type: str, guide_key: str, *, force_refresh: bool = False) -> Optional[str]:
-    """读参数指导文本，30 秒 TTL；DB 无数据返回 None，调用方自行兜底。"""
-    if guide_type not in VALID_GUIDE_TYPES:
-        return None
-    gk = (guide_key or "").strip()
-    if not gk:
-        return None
-    key = _cache_key(guide_type, gk)
-    now = time.monotonic()
-    with _lock:
-        if not force_refresh:
-            cached = _cache.get(key)
-            if cached and now < cached[0]:
-                return cached[1]
-
-    text = _load_from_db(guide_type, gk)
-    with _lock:
-        _cache[key] = (now + CACHE_TTL_SECONDS, text)
-    return text
-
-
-def invalidate() -> None:
-    """清空缓存（测试用）。"""
-    with _lock:
-        _cache.clear()
-
-
-__all__ = [
-    "CACHE_TTL_SECONDS",
-    "VALID_GUIDE_TYPES",
-    "get_param_guide",
-    "invalidate",
-]

packages/application/viral_video/prompt_loader.py

@@ -1,12 +1,10 @@
 """Prompt 模板加载器：从 viral_video_prompt_templates 读模板，30 秒 TTL 热加载。
 
-DB 不可用或没有数据时自动回落到 prompts.DEFAULT_TEMPLATES，保证流程不阻断；
-首次回落会打 warning（PR3 P2(f)），避免静默掩盖配置问题，又不刷屏。
+DB 不可用或没有数据时自动回落到 prompts.DEFAULT_TEMPLATES，保证流程不阻断。
 """
 
 from __future__ import annotations
 
-import logging
 import threading
 import time
 from dataclasses import dataclass
@@ -17,27 +15,9 @@ import sqlalchemy as sa
 from packages.adapters.sqlalchemy_impl import session as _session_mod
 from packages.application.viral_video.prompts import DEFAULT_TEMPLATES
 
-logger = logging.getLogger(__name__)
-
 CACHE_TTL_SECONDS = 30.0
 
-_VALID_TYPES = {"image_analysis", "storyboard", "review"}
-
-# PR3 P2(f): 回落 warning 去重 — key -> 上次打 warning 的 monotonic 时间戳，
-# 同一 key 在 _WARN_COOLDOWN_SECONDS 内不再重复告警。
-_WARN_COOLDOWN_SECONDS = 300.0  # 5 分钟
-_warned: dict[str, float] = {}
-_warn_lock = threading.Lock()
-
-
-def _warn_once(key: str, template_type: str, e: BaseException | str | None = None) -> None:
-    now = time.monotonic()
-    with _warn_lock:
-        last = _warned.get(key, 0.0)
-        if now - last < _WARN_COOLDOWN_SECONDS:
-            return
-        _warned[key] = now
-    logger.warning("viral_video prompt template %s fallback to default: %s", template_type, e)
+_VALID_TYPES = {"image_analysis", "intent_parsing", "copy_fusion", "storyboard", "review"}
 
 
 @dataclass
@@ -84,15 +64,12 @@ def _get_session():
         from packages.config import get_shared_settings
 
         url = str(get_shared_settings().database_url)
-    except Exception as e:  # noqa: BLE001
-        _warn_once("session_config", "db_config", e)
+    except Exception:  # noqa: BLE001
         return None
     if not url:
-        _warn_once("session_url", "db_url", "database_url empty")
         return None
     url = url.replace("postgresql+asyncpg://", "postgresql+psycopg://")
-    if url.startswith("postgresql://") and "psycopg" not in url:
-        url = url.replace("postgresql://", "postgresql+psycopg://", 1)
+    url = url.replace("postgresql://", "postgresql+psycopg://") if url.startswith("postgresql://") else url
     engine = sa.create_engine(url, pool_pre_ping=True, pool_size=2, max_overflow=2)
     from sqlalchemy.orm import sessionmaker
 
@@ -127,15 +104,14 @@ def _load_from_db(prompt_type: str) -> Optional[PromptTemplate]:
             example_output=row[5] or "",
             is_active=bool(row[6]),
         )
-    except Exception as e:  # noqa: BLE001 - 表不存在/DB 不可用时静默回落
-        _warn_once(f"load_db:{prompt_type}", prompt_type, e)
+    except Exception:  # noqa: BLE001 - 表不存在/DB 不可用时静默回落
         return None
     finally:
         if session is not None:
             try:
                 session.close()
-            except Exception as e:  # noqa: BLE001
-                _warn_once(f"session_close:{prompt_type}", prompt_type, e)
+            except Exception:  # noqa: BLE001
+                pass
 
 
 def get_template(prompt_type: str, *, force_refresh: bool = False) -> Optional[PromptTemplate]:
@@ -150,8 +126,6 @@ def get_template(prompt_type: str, *, force_refresh: bool = False) -> Optional[P
             return cached[1]
 
     template = _load_from_db(prompt_type) or _fallback(prompt_type)
-    if template is None:
-        _warn_once(f"no_template:{prompt_type}", prompt_type, "no template in db or code defaults")
     if template is not None:
         with _lock:
             _cache[prompt_type] = (now, template)
@@ -162,109 +136,25 @@ def invalidate() -> None:
     """清空缓存（测试用）。"""
     with _lock:
         _cache.clear()
-    with _warn_lock:
-        _warned.clear()
+
+
+class _SafeDict(dict):
+    def __missing__(self, key: str) -> str:
+        return "{" + key + "}"
 
 
 def _safe_format(text: str, kwargs: dict) -> str:
-    """安全格式化模板：任何占位符异常（缺key/属性访问失败/格式符非法/JSON花括号样例）
-    都原样保留，不抛异常、不静默回落默认模板，只打一条warning告警。
-
-    不用 str.format_map(_SafeDict)：_SafeDict 只能防 KeyError，无法防 AttributeError
-    （如 {duration.1格式写全6项参数} 访问 str.1格式... 会抛 AttributeError），
-    也无法防非法 format_spec（如 JSON 样例 {"key":"val"} 里冒号被当格式符）。
-    """
-    import string as _string
-
-    out: list[str] = []
-    i, n = 0, len(text)
-    errors: list[str] = []
-    while i < n:
-        c = text[i]
-        if c == "{":
-            if i + 1 < n and text[i + 1] == "{":
-                out.append("{")
-                i += 2
-                continue
-            j = i + 1
-            depth = 1
-            while j < n and depth > 0:
-                if text[j] == "{":
-                    depth += 1
-                elif text[j] == "}":
-                    depth -= 1
-                j += 1
-            if depth == 0:
-                inner = text[i + 1 : j - 1]
-                try:
-                    val = _string.Formatter().vformat("{" + inner + "}", (), kwargs)
-                    out.append(val)
-                except Exception as e:  # noqa: BLE001
-                    # 非法占位符原样保留，避免模板里的样例JSON/说明文本炸format
-                    errors.append(f"{inner!r}: {type(e).__name__}")
-                    out.append(text[i:j])
-                i = j
-                continue
-        if c == "}":
-            if i + 1 < n and text[i + 1] == "}":
-                out.append("}")
-                i += 2
-                continue
-        out.append(c)
-        i += 1
-    if errors:
-        # 模板里花括号炸format是配置bug（如v5事故里{duration.1格式写全6项参数}），
-        # 提升到 ERROR 级别，避免被warning海淹没
-        logger.error(
-            "[viral][prompt] 模板格式化有%d个占位符无法渲染（示例：%s），"
-            "已原样保留——请检查system/user_prompt_template中花括号是否为样例文本而非变量",
-            len(errors),
-            errors[0],
-        )
-        _warn_once("safe_format", "format", f"{len(errors)}个占位符异常（首条{errors[0]}）")
-    return "".join(out)
-
-
-def render_system_prompt(template: PromptTemplate, **kwargs) -> str:
-    """system_prompt 含运行时变量时填充；example_output 存在时作为 few-shot 样例追加到末尾。"""
-    body = _safe_format(template.system_prompt, kwargs)
-    example = (template.example_output or "").strip()
-    if not example:
-        return body
-    # 追加一个 assistant 角色样例消息由调用方拼成多轮；system 里只能带规则，example 统一由 user 侧追加
-    return body
+    try:
+        return text.format_map(_SafeDict(kwargs))
+    except Exception:  # noqa: BLE001
+        return text
 
 
 def render_user_prompt(template: PromptTemplate, **kwargs) -> str:
-    r"""填充 user_prompt_template 占位符；example_output 存在时作为 few-shot 样例追加到 user 消息末尾，
-    配合 \_build_example_exchange 拼多轮 messages，LLM 收到完整「示例输入→示例输出」对齐格式。"""
-    body = _safe_format(template.user_prompt_template, kwargs)
-    example = (template.example_output or "").strip()
-    if not example:
-        return body
-    return body
+    """填充 user_prompt_template 占位符，缺键原样保留不报错。"""
+    return _safe_format(template.user_prompt_template, kwargs)
 
 
-def build_messages(template: PromptTemplate, **kwargs) -> list[dict]:
-    """构造传给 LLM 的 messages 列表：system + (user, assistant[example]) + user。
-
-    - 第 1 条 system：规则
-    - 如果 template.example_output 非空，追加一轮 few-shot：user 给示例 user_prompt 渲染结果，assistant 给示例输出
-    - 最后 user：当前任务真实 user_prompt
-    这样 LLM 既能看到规则，又能看到一个完整「输入→输出」样例，格式遵从度大幅提升。
-    """
-    sys_body = render_system_prompt(template, **kwargs)
-    user_body = render_user_prompt(template, **kwargs)
-    example = (template.example_output or "").strip()
-    messages: list[dict] = [{"role": "system", "content": sys_body}]
-    if example:
-        # 用一个通用「请参考以下示例输出格式」作为 few-shot user 前缀
-        messages.append(
-            {
-                "role": "user",
-                "content": "以下是一个符合规范的完整示例输出，请严格参照其格式、字段、风格来生成：",
-            }
-        )
-        messages.append({"role": "assistant", "content": example})
-    messages.append({"role": "user", "content": user_body})
-    return messages
+def render_system_prompt(template: PromptTemplate, **kwargs) -> str:
+    """copy_fusion 等 system_prompt 含运行时变量时填充。"""
+    return _safe_format(template.system_prompt, kwargs)

packages/application/viral_video/prompts.py

@@ -1,12 +1,11 @@
-# -*- coding: utf-8 -*-
-"""爆款视频 Prompt 模板默认值（v8 / v3 叙述优先重构，PR1 清理版）。
+"""爆款视频 Prompt 模板默认值（v8 / v3 叙述优先重构）。
 
 设计原则（灵应 2026-10-07）：LLM 直接输出最终给用户看的文案，代码尽量薄。
 - image_analysis v8：VLM 主交付物是自然叙述风格的 summary_markdown，结构化
   字段仅保留 type/name/brand/has_person，顶层 products 改名 images；
 - storyboard v3：口播台词口语化、画面描述有画面感，copy_display_markdown 是
   LLM 直接写给用户看的流畅叙述文案，代码只做解析不改写；
-- intent_parsing / copy_fusion 两步整体删除，意图理解并入 storyboard 一次调用。
+- intent_parsing 步骤整体删除，意图理解并入 storyboard 一次调用。
 
 模板字段与 DB 表 viral_video_prompt_templates、prompt_loader 完全对应：
 name / prompt_type / version(int) / system_prompt / user_prompt_template /
@@ -17,32 +16,29 @@ from __future__ import annotations
 
 # 所有文案类 Prompt 自动注入的硬约束
 GLOBAL_CONSTRAINTS = """【必须遵守的硬约束】
-1. 不编造时间：不写"今年最新""2024 爆款"等会过时的时间表述。
-2. 不承诺效果：不写"保证""一定""100%有效""包治百病"等绝对化用语。
+1. 不编造时间：不写“今年最新”“2024 爆款”等会过时的时间表述。
+2. 不承诺效果：不写“保证”“一定”“100%有效”“包治百病”等绝对化用语。
 3. 不编造价格、销量、认证、奖项：除非用户在文案中明确给出，否则一律不写。
 4. 符合广告法及平台社区规范。
 5. 只描述图片中真实可见的内容，看不到的不瞎猜。"""
 
 # 负向提示（注入 storyboard / 视频生成负面词）
 NEGATIVE_RULES = """【反套路化要求】
-禁止使用"家人们谁懂啊""绝绝子""宝子们""家人们""太绝了""yyds"等烂大街网络词；
-禁止使用"很近"等错别字，应使用"最近"；
+禁止使用“家人们谁懂啊”“绝绝子”“宝子们”“家人们”“太绝了”“yyds”等烂大街网络词；
 禁止固定模板化开头；语言要像真人朋友之间的分享，自然、具体、有信息量。"""
 
-# 输出禁用套路词（测试/reviewer/worker 三处共享）
-# 注：广告法绝对化用语（如"最""第一""100%"）在 worker 侧 _quick_compliance_blacklist_check 单独做本地替换，
-# 这里只列出明显的网络烂梗/套路词。
-COMPLIANCE_BLACKLIST: list[str] = [
-    "家人们谁懂啊",
-    "绝绝子",
-    "宝子们",
-    "yyds",
-    "太绝了",
-    "家人们",
-]
+# 输出禁用套路词（测试会检查）
+BANNED_PHRASES = ["家人们谁懂啊", "绝绝子", "宝子们", "yyds", "太绝了"]
 
-# 向后兼容别名
-BANNED_PHRASES = COMPLIANCE_BLACKLIST
+# 文案融合三档独立指令段（storyboard 一次生成，按档位注入风格指令）
+FUSION_INSTRUCTIONS = {
+    "ai_full": """【本次创作模式：AI 全权创作】
+你是资深短视频编导。用户只提供了产品/门店图片，没有给出具体文案方向。请根据图片的真实观察和营销参数，自由发挥创作完整成片级方案，口播自然、画面可拍。""",
+    "ai_polish": """【本次创作模式：AI 辅助润色】
+用户已给出方向或碎碎念。以用户的意思为主，保留其所有核心信息，在此基础上润色、补衔接、优化表达，让口播更自然、画面更具体；绝不改变用户核心意思，不添加用户没提到的卖点，品牌名、价格、人名等事实原样保留。""",
+    "user_primary": """【本次创作模式：以用户原文为主】
+最小化修改：只做必要的通顺、合规修正与衔接补全，用户的核心句子与事实一律不改；用户文案已经很好就直接用，不为改而改。""",
+}
 
 # ── 模板1：图片多模态分析 v8（叙述优先）───────────────────────────────
 _IMAGE_ANALYSIS_SYSTEM = """你是一名擅长观察和写作的品牌内容编导。面对一张真实图片，先用眼睛仔细看，再用自然、流畅、具体的中文把画面写成一段可以直接读给人听的描述。
@@ -52,7 +48,7 @@ _IMAGE_ANALYSIS_SYSTEM = """你是一名擅长观察和写作的品牌内容编
   "images": [
     {
       "type": "store 或 product 或 person 或 scene，四选一",
-      "name": "主体名称，看不出就写"未识别"",
+      "name": "主体名称，看不出就写“未识别”",
       "brand": "品牌名，看不出就留空字符串",
       "has_person": false,
       "summary_markdown": "用 Markdown 写成的自然叙述，这是最主要的交付物"
@@ -61,7 +57,7 @@ _IMAGE_ANALYSIS_SYSTEM = """你是一名擅长观察和写作的品牌内容编
 }
 
 ## summary_markdown 写作要求（最重要）
-1. 写成完整、通顺的句子，像在跟朋友认真描述你看到的画面；不要用分号堆砌关键词，不要罗列"核心特征：xxx""主色调：xxx"这类填表式标签。
+1. 写成完整、通顺的句子，像在跟朋友认真描述你看到的画面；不要用分号堆砌关键词，不要罗列“核心特征：xxx”“主色调：xxx”这类填表式标签。
 2. 开头先给一句整体定性，让读者立刻明白这是什么场景、什么主体。
 3. 颜色、材质、形状、部件要具体可感，写到位置和搭配；画面里出现的文字原样读出并自然融进句子，数字、规格、价格精确引用，看不清的不要编造。
 4. 只写真实看到的内容，不脑补功能、疗效、销量或画面之外的信息。
@@ -95,16 +91,14 @@ _IMAGE_ANALYSIS_EXAMPLE = """{
       "name": "御众堂门店",
       "brand": "御众堂",
       "has_person": false,
-      "summary_markdown": "###店铺主体\\n这是一家名为"御众堂"的线下门店内部，整体暖木色调……"
+      "summary_markdown": "###店铺主体\\n这是一家名为“御众堂”的线下门店内部，整体暖木色调……"
     }
   ]
 }"""
 
 # ── 模板2：编导级分镜 v3（意图理解 + 分镜一次完成）────────────────────
-# 字数/镜头数硬约束在 user_prompt 通过 {duration_constraint_text} 占位符注入，
-# 由 constants.build_duration_constraint_text(dur) 统一生成，避免模板与代码校验不一致。
 _STORYBOARD_SYSTEM = (
-    """你是一名懂短视频的编导和口播文案高手。你会拿到图片的真实观察、营销目的和用户参数，请一次性完成对营销意图的理解，并产出可直接拍摄/生成的分镜脚本。不要单独输出"意图解析"，意图要直接体现在台词和分镜里。
+    """你是一名懂短视频的编导和口播文案高手。你会拿到图片的真实观察、营销目的和用户参数，请一次性完成对营销意图的理解，并产出可直接拍摄/生成的分镜脚本。不要单独输出“意图解析”，意图要直接体现在台词和分镜里。
 
 ## 输出格式（XML，严格按结构输出，不要输出额外解释）
 <script>
@@ -126,15 +120,34 @@ _STORYBOARD_SYSTEM = (
 
 ## 写作要求
 1. 口播台词：像真人面对镜头说话，短句、口语化、有停顿有情绪，开头 3 秒给出钩子；不要书面腔，不要机械报参数。
-2. 画面描述：写清"观众会看到什么"，有动作、有镜头运动、有景别和光线，具体可拍；不堆砌形容词，不写无法实现的画面。
-3. copy_display_markdown：直接展示给最终用户的文案，用 Markdown 写成自然、流畅、有感染力的成片文案，可用小标题与短句组织；不要做字段列表，不要出现"镜头一/台词："这类制作说明。
+2. 画面描述：写清“观众会看到什么”，有动作、有镜头运动、有景别和光线，具体可拍；不堆砌形容词，不写无法实现的画面。
+3. copy_display_markdown：直接展示给最终用户的文案，用 Markdown 写成自然、流畅、有感染力的成片成片文案，可用小标题与短句组织；不要做字段列表，不要出现“镜头一/台词：”这类制作说明。
 4. 内容必须来自图片观察与用户给出的信息，不编造卖点、不夸大、不使用绝对化用语和虚假承诺。
 5. reference_image_index 填本镜参考图片序号（从 0 开始），没有合适参考图填 -1。
 6. 分镜数量与时长匹配总时长，节奏紧凑。
-7. 【字数/镜头数/时间轴硬约束】：严格遵守 user_prompt 里给出的 {duration_constraint_text}，宁少勿多。
-8. 每个 clip 必须分配一个 reference_image_index（从 0 开始的图片序号），没有合适图片填 -1。
-9. 必须严格按<marketing_purpose><target_audience><persona><viral_structure><language><industry>指定的参数写文案和分镜，不能忽略任何一项用户参数。
-10. 禁止使用"很近"等错别字，统一使用"最近"。"""
+7. 口播字数硬约束（必须严格遵守）：按每秒约 2.5~3 个中文字（正常口播语速）计算：
+   - 5秒视频：voiceover_script 总字数 12~15 字
+   - 10秒视频：voiceover_script 总字数 25~30 字
+   - 15秒视频：voiceover_script 总字数 35~45 字
+   - 20秒视频：voiceover_script 总字数 50~60 字
+   - 30秒视频：voiceover_script 总字数 75~90 字
+   - 每个 clip 的 voiceover 字数按该镜头时长比例分配
+   - 所有 clip 的 voiceover 字数之和必须等于总 voiceover_script 字数
+   - 宁可少写也不要多写，超长会导致 TTS 音频超出视频时长限制
+8. 镜头数量硬约束（必须严格遵守）：
+   - 5秒视频：1~2 个镜头
+   - 10秒视频：3 个镜头
+   - 15秒视频：3~4 个镜头
+   - 20秒视频：4~5 个镜头
+   - 30秒视频：6~8 个镜头
+9. 时间轴硬约束（必须严格遵守）：
+   - 每个 clip 的 time_range 必须写成 "X-Y秒" 格式，X 和 Y 是具体数字
+   - 第一个 clip 必须从 0 秒开始
+   - 最后一个 clip 必须结束于 total_duration 秒
+   - 相邻 clip 首尾相接，不能有间隙也不能重叠
+   - 每个 clip 的时长 = Y - X，必须 >= 2 秒
+10. 每个 clip 必须分配一个 reference_image_index（从 0 开始的图片序号），没有合适图片填 -1
+11. 必须严格按<marketing_purpose><target_audience><persona><viral_structure><language><industry>指定的参数写文案和分镜，不能忽略任何一项用户参数"""
 )
 
 _STORYBOARD_USER = """<marketing_purpose>{marketing_purpose}</marketing_purpose>
@@ -154,67 +167,62 @@ _STORYBOARD_USER = """<marketing_purpose>{marketing_purpose}</marketing_purpose>
 <extra_requirements>{extra_requirements}</extra_requirements>
 </user_parameters>
 {video_style_section}
-<duration_constraints>
-{duration_constraint_text}
-</duration_constraints>
 请严格按 XML 结构输出分镜脚本。"""
 
 _STORYBOARD_EXAMPLE = """<script>
   <copy_display_markdown><![CDATA[# 在御众堂，把松弛的自己一点点找回来
-产后妈妈最懂那种力不从心，推开门，暖光和一杯热茶先接住了你。
-最近连抱娃都觉得腰发硬，过来躺一会儿，按完整个背都松了，带娃也有力气了。]]></copy_display_markdown>
+产后妈妈最懂那种力不从心，推开门，暖光和一杯热茶先接住了你……]]></copy_display_markdown>
   <clips>
     <clip index="1">
-      <time_range>0-4秒</time_range>
+      <time_range>0-3秒</time_range>
       <voiceover>生完娃，是不是连照镜子的勇气都没了？</voiceover>
       <visual>中近景，暖光下一位妈妈略显疲惫地看向镜中，镜头缓缓推近</visual>
       <reference_image_index>0</reference_image_index>
     </clip>
-    <clip index="2">
-      <time_range>4-10秒</time_range>
-      <voiceover>推开门，暖光和一杯热茶先接住了你。</voiceover>
-      <visual>中景，门店前台暖光木色装修，店员微笑递上茶水，镜头平移扫过环境</visual>
-      <reference_image_index>1</reference_image_index>
-    </clip>
-    <clip index="3">
-      <time_range>10-15秒</time_range>
-      <voiceover>来御众堂躺一会儿，整个人都松了。</voiceover>
-      <visual>特写，妈妈闭眼放松做护理，暖光打在侧脸，最后镜头拉远露出品牌LOGO</visual>
-      <reference_image_index>2</reference_image_index>
-    </clip>
   </clips>
-  <voiceover_script>生完娃，是不是连照镜子的勇气都没了？推开门，暖光和一杯热茶先接住了你。来御众堂躺一会儿，整个人都松了。</voiceover_script>
+  <voiceover_script>生完娃，是不是连照镜子的勇气都没了？</voiceover_script>
   <theme>产后妈妈走进御众堂重拾状态</theme>
-  <negative>模糊、畸变、夸大疗效、绝对化用语、"很近"等错别字</negative>
+  <negative>模糊、畸变、夸大疗效、绝对化用语</negative>
 </script>"""
 
 # ── 模板3：文案审核（合规/质量门禁）───────────────────────────────────
-_REVIEW_SYSTEM = """你是一名短视频广告合规审核与文案优化专家。请审核下面这段口播文案：
-1) 广告法与平台合规（绝对化用语、虚假承诺、医疗功效宣称、导流违规、套路烂梗词）；
-2) 口播是否自然、口语化、无书面腔；
-3) 是否有明显错别字（例如把"最近"写成"很近"）。
+_REVIEW_SYSTEM = """你是一名短视频广告合规审核与文案优化专家。审核待审文案：
+1) 广告法与平台合规（绝对化用语、虚假承诺、医疗功效宣称、导流违规）；
+2) 卖点是否聚焦、逻辑是否通顺、口播是否自然；
+3) 是否有机械堆砌、书面腔、标签化表述。
 
 只输出 XML，结构：
 <review>
   <passed>true 或 false</passed>
   <issues>
-    <issue dimension="违规词/夸大承诺/错别字/其他" severity="error或warning">具体问题</issue>
+    <issue>
+      <severity>high 或 medium 或 low</severity>
+      <field>问题所在位置/字段</field>
+      <problem>具体问题</problem>
+      <suggestion>可直接替换的修改</suggestion>
+    </issue>
   </issues>
+  <rewrite>整体重写后的合规流畅版本（无问题时留空）</rewrite>
 </review>
-没有问题时 issues 留空、passed 为 true。不要输出 rewrite/rewrite_suggestion 字段。"""
+没有问题时 issues 留空、passed 为 true、rewrite 留空。"""
 
-_REVIEW_USER = """<voiceover_script>
-{voiceover_script}
-</voiceover_script>
+_REVIEW_USER = """<fusion_text>
+{fusion_text}
+</fusion_text>
 
-请审核以上口播文案。"""
+请审核以上文案。"""
 
 _REVIEW_EXAMPLE = """<review>
   <passed>false</passed>
   <issues>
-    <issue dimension="夸大承诺" severity="error">使用绝对化用语"100%有效"，违反广告法</issue>
-    <issue dimension="违规词" severity="warning">使用套路词"绝绝子"</issue>
+    <issue>
+      <severity>high</severity>
+      <field>opening</field>
+      <problem>使用绝对化用语“全网第一”</problem>
+      <suggestion>改为“很多老客户回购的一款”</suggestion>
+    </issue>
   </issues>
+  <rewrite>……</rewrite>
 </review>"""
 
 
@@ -229,18 +237,18 @@ DEFAULT_TEMPLATES: list[dict] = [
         "is_active": True,
     },
     {
-        "name": "编导级分镜 v3.1",
+        "name": "编导级分镜 v3",
         "prompt_type": "storyboard",
-        "version": 4,
+        "version": 3,
         "system_prompt": _STORYBOARD_SYSTEM,
         "user_prompt_template": _STORYBOARD_USER,
         "example_output": _STORYBOARD_EXAMPLE,
         "is_active": True,
     },
     {
-        "name": "文案审核 v2",
+        "name": "文案审核",
         "prompt_type": "review",
-        "version": 2,
+        "version": 1,
         "system_prompt": _REVIEW_SYSTEM,
         "user_prompt_template": _REVIEW_USER,
         "example_output": _REVIEW_EXAMPLE,

packages/application/viral_video/reviewer.py

@@ -1,12 +1,7 @@
-# -*- coding: utf-8 -*-
-"""文案审核（PR1 简化版）。
+"""文案审核 + 自动重写（#2040 第5套 Prompt）。
 
-只做两件事：
-1. 本地规则预检：广告法绝对化用语 + 套路烂梗词（COMPLIANCE_BLACKLIST）；
-2. LLM 审核（单参数 voiceover_script），LLM 不可用时降级放行并塞 warning issue。
-
-不再有 rewrite / rule_fix / intent 保留检查等死路径（intent 在新链路里永远是空的，
-personal_brands/must_keep 检查在原链路里也从未真正生效）。
+6 维度：违规词 / 夸大承诺 / 事实一致性 / 用户意图保留 / 结构完整性 / 语气人设。
+LLM 审核之外叠加本地规则预检（保证即使 LLM 不可用也能兜住广告法红线）。
 """
 
 from __future__ import annotations
@@ -17,15 +12,20 @@ from typing import Optional
 
 from packages.application.viral_video import xml_parser as xp
 from packages.application.viral_video.prompt_loader import (
-    build_messages,
     get_template,
+    render_system_prompt,
+    render_user_prompt,
+)
+from packages.application.viral_video.schemas import (
+    FusionResult,
+    IntentResult,
+    ReviewIssue,
+    ReviewResult,
 )
-from packages.application.viral_video.prompts import COMPLIANCE_BLACKLIST
-from packages.application.viral_video.schemas import ReviewIssue, ReviewResult
 
 logger = logging.getLogger(__name__)
 
-# 本地规则：绝对化/夸大词（广告法红线，兜底挡住最明显违规）
+# 本地规则：绝对化/夸大词
 _EXAGGERATION_PATTERNS = [
     r"100\s*%",
     r"百分百",
@@ -39,16 +39,22 @@ _EXAGGERATION_PATTERNS = [
     r"一喷(就|全|100)",
 ]
 
-# 本地规则：套路烂梗/明显错别字（与 prompts.COMPLIANCE_BLACKLIST 同步）
-_VIOLATION_PATTERNS = [re.escape(p) for p in COMPLIANCE_BLACKLIST] + [
-    r"最(好|强|牛|便宜|美|棒)",  # 广告法极限词（最X）
-    r"第一(名|品牌)?",
-    r"很近",  # 常见错别字，应使用"最近"
+# 本地规则：平台违规/套路词
+_VIOLATION_PHRASES = [
+    "家人们谁懂啊",
+    "绝绝子",
+    "宝子们",
+    "yyds",
+    "最(好|强|牛|便宜)",  # 广告法极限词
+    "第一(名|品牌)?",
 ]
 
+_LOCATIONS = ["title", "hook", "body_points", "cta", "script_segments"]
+
 
 class Reviewer:
-    """口播文案审核器。"""
+    # markdown展示字段不参与合规审核（避免格式字符误判）
+    _MARKDOWN_FIELDS = {"summary_markdown", "copy_display_markdown"}
 
     def __init__(self, client=None):
         if client is None:
@@ -56,123 +62,142 @@ class Reviewer:
                 from packages.shared.ai_router import ai_router
 
                 client = ai_router.get_llm_client("copy_review")
-            except Exception:  # noqa: BLE001
-                try:
-                    from packages.shared.ai_client import get_doubao_client
+            except Exception:
+                from packages.shared.ai_client import get_doubao_client
 
-                    client = get_doubao_client()
-                except Exception:  # noqa: BLE001
-                    client = None
+                client = get_doubao_client()
         self.client = client
 
     # ── 审核 ────────────────────────────────────────────────────────────
-    def review(
-        self,
-        voiceover_script: str,
-        copy_display_markdown: str = "",
-    ) -> ReviewResult:
-        """审核口播文案。
-
-        Args:
-            voiceover_script: 完整口播稿字符串（必传）。
-            copy_display_markdown: 展示给用户看的 Markdown 文案（可选，保留接口）。
-
-        Returns:
-            ReviewResult: passed=True 表示放行；LLM 不可用时降级放行（带 warning issue）。
-        """
-        text = voiceover_script or ""
-        local = self._check_compliance(text)
-        llm_result = self._llm_review(text)
+    def review(self, fusion: FusionResult, intent: IntentResult, fusion_level: str) -> ReviewResult:
+        local = self._rule_check(fusion, intent, fusion_level)
+        llm_result = self._llm_review(fusion, intent, fusion_level)
         if llm_result is None:
-            # LLM 审核失败（超时/网络/不可用），降级放行
-            degraded_issue = ReviewIssue(
-                dimension="审核降级",
-                severity="warning",
-                location="voiceover_script",
-                text="LLM 审核不可用，已降级为本地规则审核放行，请人工复核",
-            )
+            # LLM审核失败（超时/网络错误等），降级放行，不阻断渲染
             return ReviewResult(
-                passed=not any(i.severity == "error" for i in local),
-                issues=local + [degraded_issue],
+                passed=True,
+                issues=local,
                 rewrite_suggestions=[],
                 raw="",
             )
         # LLM 与本地规则合并去重
         issues = self._merge_issues(llm_result.issues, local)
-        has_error = any(i.severity == "error" for i in issues)
         return ReviewResult(
-            passed=llm_result.passed and not has_error,
+            passed=llm_result.passed and not local,
             issues=issues,
             rewrite_suggestions=llm_result.rewrite_suggestions,
             raw=llm_result.raw,
         )
 
-    def _llm_review(self, voiceover_script: str) -> Optional[ReviewResult]:
+    def _llm_review(self, fusion: FusionResult, intent: IntentResult, fusion_level: str) -> Optional[ReviewResult]:
         try:
-            return self._llm_review_inner(voiceover_script)
-        except Exception as e:  # noqa: BLE001
-            logger.warning("[Reviewer] LLM审核调用异常，降级放行: %s", e)
+            return self._llm_review_inner(fusion, intent, fusion_level)
+        except Exception as e:
+            import logging
+
+            logging.getLogger(__name__).warning("[Reviewer] LLM审核调用异常，降级放行: %s", e)
             return None
 
-    def _llm_review_inner(self, voiceover_script: str) -> Optional[ReviewResult]:
-        if not self.client or not getattr(self.client, "is_available", True):
-            return None
+    def _llm_review_inner(
+        self, fusion: FusionResult, intent: IntentResult, fusion_level: str
+    ) -> Optional[ReviewResult]:
         template = get_template("review")
-        messages = build_messages(template, voiceover_script=voiceover_script)
+        system = render_system_prompt(template)
+        user = render_user_prompt(
+            template,
+            fusion_level=fusion_level,
+            fusion_result=self._fusion_text(fusion),
+            intent_result=self._intent_text(intent),
+        )
         raw = self.client.chat_completion(
-            messages,
+            [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
             temperature=0.2,
             max_tokens=1024,
             timeout=25,
         )
         if not raw:
             return None
-        passed_text = xp.text_of(raw, "passed").strip().lower()
+        passed = xp.text_of(raw, "passed").strip().lower()
         issues = [
             ReviewIssue(
                 dimension=n["attrs"].get("dimension", "未知维度"),
                 severity=n["attrs"].get("severity", "warning"),
-                location=n["attrs"].get("location", "voiceover_script"),
+                location=n["attrs"].get("location", ""),
                 text=n["text"],
             )
             for n in xp.find_all(raw, "issue")
             if n["text"]
         ]
         suggestions = [n["text"] for n in xp.find_all(raw, "suggestion") if n["text"]]
-        return ReviewResult(
-            passed=passed_text == "true" and not issues,
+        parsed = ReviewResult(
+            passed=passed == "true" and not issues,
             issues=issues,
             rewrite_suggestions=suggestions,
             raw=raw,
         )
+        return parsed
 
     # ── 本地规则预检 ────────────────────────────────────────────────────
-    def _check_compliance(self, text: str) -> list[ReviewIssue]:
-        """扫描口播文本中的广告法红线和套路词。"""
+    def _rule_check(self, fusion: FusionResult, intent, fusion_level: str) -> list[ReviewIssue]:
         issues: list[ReviewIssue] = []
-        if not text:
-            return issues
-        for pattern in _EXAGGERATION_PATTERNS:
-            if re.search(pattern, text):
-                issues.append(
-                    ReviewIssue(
-                        dimension="夸大承诺",
-                        severity="error",
-                        location="voiceover_script",
-                        text="出现夸大/绝对化表述：" + self._hit(text, pattern),
+        for location, text in self._segments(fusion):
+            for pattern in _EXAGGERATION_PATTERNS:
+                if re.search(pattern, text):
+                    issues.append(
+                        ReviewIssue(
+                            dimension="夸大承诺",
+                            severity="error",
+                            location=location,
+                            text=f"出现夸大/绝对化表述：{self._hit(text, pattern)}",
+                        )
                     )
-                )
-        for pattern in _VIOLATION_PATTERNS:
-            if re.search(pattern, text, flags=re.IGNORECASE):
-                sev = "warning" if pattern == "很近" else "error"
-                issues.append(
-                    ReviewIssue(
-                        dimension="违规词",
-                        severity=sev,
-                        location="voiceover_script",
-                        text="出现违规/套路词或错别字：" + self._hit(text, pattern),
+            for phrase in _VIOLATION_PHRASES:
+                if re.search(phrase, text, flags=re.IGNORECASE):
+                    issues.append(
+                        ReviewIssue(
+                            dimension="违规词",
+                            severity="error",
+                            location=location,
+                            text=f"出现违规或套路词：{self._hit(text, phrase)}",
+                        )
+                    )
+
+        # 结构完整性
+        if not fusion.title:
+            issues.append(ReviewIssue(dimension="结构完整性", severity="warning", location="title", text="缺少标题"))
+        if not fusion.hook:
+            issues.append(ReviewIssue(dimension="结构完整性", severity="warning", location="hook", text="缺少开头钩子"))
+        if not fusion.cta:
+            issues.append(ReviewIssue(dimension="结构完整性", severity="warning", location="cta", text="缺少行动号召"))
+
+        # 用户意图保留（must_keep）
+        full_text = self._fusion_text(fusion)
+        if fusion_level in {"ai_polish", "user_primary"} and intent is not None:
+            for message in intent.core_messages:
+                if message.must_keep:
+                    key = self._compact(message.text)
+                    if key and key[:10] not in self._compact(full_text):
+                        issues.append(
+                            ReviewIssue(
+                                dimension="用户意图保留",
+                                severity="warning",
+                                location="script_segments",
+                                text=f"用户核心信息被丢失：{message.text[:30]}",
+                            )
+                        )
+            for brand in intent.personal_brands:
+                if brand.text and brand.text not in full_text:
+                    issues.append(
+                        ReviewIssue(
+                            dimension="事实一致性",
+                            severity="error",
+                            location="script_segments",
+                            text=f"personal_brands 事实信息未原样保留：{brand.text[:30]}",
+                        )
                     )
-                )
         return issues
 
     @staticmethod
@@ -182,7 +207,7 @@ class Reviewer:
 
     @staticmethod
     def _compact(text: str) -> str:
-        return re.sub(r"[\s，。！？、,.!?；;：:\"'\u201c\u201d\u2018\u2019（）()【】\[\]]", "", text)
+        return re.sub(r"[\s，。！？、,.!?；;：:\"'“”‘’（）()【】\[\]]", "", text)
 
     @staticmethod
     def _merge_issues(llm_issues: list[ReviewIssue], local: list[ReviewIssue]) -> list[ReviewIssue]:
@@ -194,3 +219,119 @@ class Reviewer:
                 merged.append(issue)
                 seen.add(key)
         return merged
+
+    # ── 自动重写（1 次）─────────────────────────────────────────────────
+    def rewrite(
+        self,
+        fusion: FusionResult,
+        review: ReviewResult,
+        intent: IntentResult,
+        fusion_level: str,
+    ) -> FusionResult:
+        from packages.application.viral_video.generator import CopyGenerator
+
+        template = get_template("copy_fusion")
+        system_kwargs = {
+            "fusion_instruction": (
+                "【本次任务：按审核意见修正文案】只修改指出的问题，其他内容尽量原样保留；"
+                "personal_brands 事实信息逐字保留；修正后按原标签格式完整输出。"
+            ),
+            "global_constraints": "",
+            "negative_rules": "",
+        }
+        issue_text = "\n".join(f"- [{i.dimension}/{i.location}] {i.text}" for i in review.issues)
+        suggestion_text = "\n".join(f"- {s}" for s in review.rewrite_suggestions)
+        user = render_user_prompt(
+            template,
+            industry="",
+            target_customer="",
+            marketing_purpose="",
+            duration=fusion.estimated_duration or 15,
+            image_analysis="（沿用原图片分析）",
+            intent_result=self._intent_text(intent),
+        )
+        user = (
+            f"{user}\n\n原文案：\n{self._fusion_text(fusion)}\n\n"
+            f"审核发现的问题：\n{issue_text}\n\n修改建议：\n{suggestion_text or '（无）'}\n"
+            "请输出修正后的完整文案。"
+        )
+        system = render_system_prompt(template, **system_kwargs)
+        raw = self.client.chat_completion(
+            [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            temperature=0.5,
+            max_tokens=2048,
+            timeout=25,
+        )
+        if not raw:
+            return self._rule_fix(fusion, review)
+        rewritten = CopyGenerator._parse_fusion(CopyGenerator(self.client), raw)
+        if not rewritten.title and not rewritten.script_segments:
+            return self._rule_fix(fusion, review)
+        # 保底：personal_brands 必须保留
+        full = self._fusion_text(rewritten)
+        for brand in intent.personal_brands:
+            if brand.text and brand.text not in full:
+                rewritten.cta = (rewritten.cta + brand.text).strip()
+        return rewritten
+
+    def _rule_fix(self, fusion: FusionResult, review: ReviewResult) -> FusionResult:
+        """LLM 重写不可用时的本地兜底：删除/替换明显违规表述。"""
+        replacements = [
+            (re.compile(r"100\s*%|百分百"), "大部分"),
+            (re.compile(r"绝对(有效|安全|靠谱)"), "比较\\1"),
+            (re.compile(r"包治百病"), "适用多种情况"),
+            (re.compile(r"立刻见效"), "坚持使用会有改善"),
+            (re.compile(r"一喷(就|全|100%)"), "喷上等一会儿可以"),
+            (re.compile(r"家人们谁懂啊|绝绝子|宝子们|yyds", re.IGNORECASE), ""),
+            (re.compile(r"最好|最强|最牛|最便宜"), "很不错"),
+        ]
+
+        def fix(text: str) -> str:
+            for pattern, repl in replacements:
+                text = pattern.sub(repl, text)
+            return text
+
+        fusion.title = fix(fusion.title)
+        fusion.hook = fix(fusion.hook)
+        fusion.cta = fix(fusion.cta)
+        for point in fusion.body_points:
+            point.text = fix(point.text)
+            point.elaboration = fix(point.elaboration)
+        for segment in fusion.script_segments:
+            segment.text = fix(segment.text)
+        fusion.raw = ""
+        return fusion
+
+    # ── 文本工具 ────────────────────────────────────────────────────────
+    @staticmethod
+    def _segments(fusion: FusionResult):
+        yield "title", fusion.title
+        yield "hook", fusion.hook
+        for point in fusion.body_points:
+            yield "body_points", f"{point.text} {point.elaboration}"
+        yield "cta", fusion.cta
+        for segment in fusion.script_segments:
+            yield "script_segments", segment.text
+
+    @staticmethod
+    def _fusion_text(fusion: FusionResult) -> str:
+        _MARKDOWN_FIELDS = {"summary_markdown", "copy_display_markdown"}
+        parts = [fusion.title, fusion.hook]
+        parts += [p.text for p in fusion.body_points]
+        parts += [s.text for s in fusion.script_segments]
+        parts.append(fusion.cta)
+        # 过滤掉markdown展示字段，避免格式字符被误判
+        parts = [p for p in parts if not any(mk in p for mk in _MARKDOWN_FIELDS)]
+        return "\n".join(p for p in parts if p)
+
+    @staticmethod
+    def _intent_text(intent) -> str:
+        if intent is None:
+            return "无意图信息"
+        parts = [f"意图：{intent.intent_summary}"]
+        parts += [f"核心信息[must_keep={m.must_keep}]：{m.text}" for m in intent.core_messages]
+        parts += [f"事实（{b.category}）：{b.text}" for b in intent.personal_brands]
+        return "\n".join(parts)

packages/application/viral_video/schemas.py

@@ -37,6 +37,26 @@ class ImageAnalysis(BaseModel):
     raw: str = ""
 
 
+class CoreMessage(BaseModel):
+    text: str
+    must_keep: bool = False
+    confidence: float = 0.0
+
+
+class PersonalBrand(BaseModel):
+    text: str
+    category: str = "brand"
+
+
+class IntentResult(BaseModel):
+    intent_summary: str = ""
+    core_messages: list[CoreMessage] = Field(default_factory=list)
+    personal_brands: list[PersonalBrand] = Field(default_factory=list)
+    emotion_tone: str = ""
+    missing_info: list[str] = Field(default_factory=list)
+    raw: str = ""
+
+
 class BodyPoint(BaseModel):
     text: str
     elaboration: str = ""

packages/config/base.py

@@ -185,8 +185,8 @@ class SharedSettings(BaseSettings):
         default="",
         validation_alias=AliasChoices("DITTO_API_BASE_URL", "ditto_api_base_url"),
     )
-    # 默认人物模板视频 URL（兜底用：用户未上传视频时使用，或视频预处理失败时回退）。
-    # 正面 5-10 秒、光线均匀、半身 1080x1920 竖版；正常流程下 Ditto 优先使用用户上传的 video_url。
+    # 默认人物模板视频 URL（正面 5-10 秒循环、光线均匀、半身）。Ditto 模式下忽略
+    # 用户上传的驱动视频/图片，统一用该模板；后续可扩展为多模板让用户选择。
     ditto_default_video_url: str = Field(
         default="",
         validation_alias=AliasChoices("DITTO_DEFAULT_VIDEO_URL", "ditto_default_video_url"),
@@ -202,9 +202,9 @@ class SharedSettings(BaseSettings):
         default=120,
         validation_alias=AliasChoices("DITTO_REQUEST_TIMEOUT", "ditto_request_timeout"),
     )
-    # Ditto 句间过渡帧数（平滑表情/口型切换）；默认 6 与 GPU 端 clamp 最优值对齐（表情切换更灵敏）
+    # Ditto 句间过渡帧数（平滑表情/口型切换）
     ditto_blend_frames: int = Field(
-        default=6,
+        default=12,
         validation_alias=AliasChoices("DITTO_BLEND_FRAMES", "ditto_blend_frames"),
     )
 
@@ -219,11 +219,11 @@ class SharedSettings(BaseSettings):
         validation_alias=AliasChoices("DITTO_EMOTION_MODEL", "ditto_emotion_model"),
     )
     ditto_emotion_temperature: float = Field(
-        default=0.8,
+        default=0.1,
         validation_alias=AliasChoices("DITTO_EMOTION_TEMPERATURE", "ditto_emotion_temperature"),
     )
     ditto_emotion_timeout: int = Field(
-        default=30,
+        default=10,
         validation_alias=AliasChoices("DITTO_EMOTION_TIMEOUT", "ditto_emotion_timeout"),
     )
     ditto_emotion_max_tokens: int = Field(

packages/domain/viral_video.py

@@ -3,10 +3,9 @@
 v1.6 重大简化：Seedance 2.5 单次最长30秒，单次调用直接出片，不再分段/拼接/ffmpeg concat。
 状态机（三步分步）：
   pending -> running -> image_analyzed -> running -> copy_generated -> running -> completed
+                                 wait_user_confirm -> running -> completed (旧路径兼容)
   任意阶段 fail; 任意非终态 cancel.
   failed -> pending (retry 重置后重跑)。
-
-  意图解析(intent_parsing) 已并入脚本生成一步完成，不再单独作为阶段/状态存在。
 """
 
 from __future__ import annotations
@@ -32,6 +31,7 @@ class ViralVideoStatus(StrEnum):
     RUNNING = "running"
     IMAGE_ANALYZED = "image_analyzed"
     COPY_GENERATED = "copy_generated"
+    WAIT_USER_CONFIRM = "wait_user_confirm"
     COMPLETED = "completed"
     FAILED = "failed"
     CANCELLED = "cancelled"
@@ -40,6 +40,7 @@ class ViralVideoStatus(StrEnum):
 class ViralVideoStage(StrEnum):
     IMAGE_ANALYSIS = "image_analysis"
     VIDEO_ANALYSIS = "video_analysis"
+    INTENT_PARSING = "intent_parsing"
     SCRIPT_GENERATION = "script_generation"  # v1.6: 编导分镜脚本（融合原 copy_fusion+storyboard+review）
     REVIEW = "review"
     TTS = "tts"
@@ -61,6 +62,7 @@ class StyleStrength(StrEnum):
 
 class PromptType(StrEnum):
     IMAGE_ANALYSIS = "image_analysis"
+    INTENT_PARSING = "intent_parsing"
     SCRIPT_GENERATION = "script_generation"
     REVIEW = "review"
     VIDEO_STYLE_INTEGRATION = "video_style_integration"
@@ -70,6 +72,7 @@ class PromptType(StrEnum):
 STAGE_LABELS = {
     ViralVideoStage.IMAGE_ANALYSIS: "图片分析",
     ViralVideoStage.VIDEO_ANALYSIS: "视频风格分析",
+    ViralVideoStage.INTENT_PARSING: "意图解析",
     ViralVideoStage.SCRIPT_GENERATION: "编导脚本生成",
     ViralVideoStage.REVIEW: "合规审核",
     ViralVideoStage.TTS: "AI 配音",
@@ -92,7 +95,6 @@ class ViralVideoJob:
     persona_id: str = ""
     viral_structure: str = ""
     marketing_purpose: str = ""
-    tone: str = ""
     bgm_preference: str = ""
     duration: int = 15  # v1.6: 默认15秒，上限30秒（Seedance 2.5 单次最大30s）
     user_copy_text: str = ""
@@ -110,6 +112,7 @@ class ViralVideoJob:
     video_model: str = ""
     # v1.4+ 产物
     image_analysis: dict | None = None
+    intent_result: dict | None = None
     generated_copy_text: str = ""  # v1.6: 存 voiceover_script（纯口播对白），字段名兼容
     storyboard: list | None = None  # v1.6: 存 copy_result.shots，字段名兼容
     copy_result: dict | None = None  # v1.6: 完整编导脚本结构
@@ -138,6 +141,7 @@ class ViralVideoJob:
             ViralVideoStatus.PENDING,
             ViralVideoStatus.IMAGE_ANALYZED,
             ViralVideoStatus.COPY_GENERATED,
+            ViralVideoStatus.WAIT_USER_CONFIRM,
             ViralVideoStatus.RUNNING,
         ):
             raise ValueError(f"Cannot transition from {self.status} to running")
@@ -180,10 +184,17 @@ class ViralVideoJob:
             self.storyboard = list(shots) if isinstance(shots, list) else []
         self.updated_at = datetime.now(timezone.utc)
 
+    def mark_wait_user_confirm(self, intent_result: dict) -> None:
+        if self.status != ViralVideoStatus.RUNNING:
+            raise ValueError(f"Cannot transition from {self.status} to wait_user_confirm")
+        self.status = ViralVideoStatus.WAIT_USER_CONFIRM
+        self.intent_result = intent_result
+        self.updated_at = datetime.now(timezone.utc)
+
     def resume_from_image_analyzed(self, **kwargs) -> None:
         """阶段2入口：允许从 IMAGE_ANALYZED/PENDING 首次进入，也允许从 COPY_GENERATED/COMPLETED/FAILED 重新生成文案。
 
-        重新生成时清空上一轮文案产物（copy_result/storyboard/generated_copy_text），
+        重新生成时清空上一轮文案产物（copy_result/intent_result/storyboard/generated_copy_text），
         并重置 completed_at/result_video_url/error_msg，确保前端轮询能看到新的阶段2进度。
         """
         _allowed = (
@@ -205,6 +216,7 @@ class ViralVideoJob:
                 setattr(self, k, v)
         if _is_regen:
             # 清空上一轮文案/视频产物，避免前端拿到旧数据
+            self.intent_result = None
             self.copy_result = None
             self.storyboard = None
             self.generated_copy_text = ""
@@ -232,13 +244,15 @@ class ViralVideoJob:
         self.heartbeat_at = _now
         self.status = ViralVideoStatus.RUNNING
         self.updated_at = _now
-        # 清空上一次渲染留下的错误/产物（参考 resume_from_image_analyzed 对齐）
-        self.error_msg = ""
-        self.result_video_url = ""
-        self.current_stage = ""
-        self.phase_message = ""
-        self.completed_at = None
-        self.credits_cost = 0.0
+
+    def resume_from_confirm(self) -> None:
+        if self.status != ViralVideoStatus.WAIT_USER_CONFIRM:
+            raise ValueError(f"Cannot resume from {self.status}")
+        _now = datetime.now(timezone.utc)
+        self.started_at = _now
+        self.heartbeat_at = _now
+        self.status = ViralVideoStatus.RUNNING
+        self.updated_at = _now
 
     def mark_completed(self, video_url: str) -> None:
         self.status = ViralVideoStatus.COMPLETED
@@ -246,12 +260,9 @@ class ViralVideoJob:
         self.completed_at = datetime.now(timezone.utc)
         self.updated_at = datetime.now(timezone.utc)
 
-    def mark_failed(self, error_msg: str, stage: str = "") -> None:
+    def mark_failed(self, error_msg: str) -> None:
         self.status = ViralVideoStatus.FAILED
         self.error_msg = error_msg
-        # 失败时持久化失败阶段，避免前端错误归因
-        if stage:
-            self.current_stage = stage
         self.completed_at = datetime.now(timezone.utc)
         self.updated_at = datetime.now(timezone.utc)
 

packages/domain/viral_video/__init__.py

@@ -1,86 +0,0 @@
-"""爆款视频领域层包（PR3 P2：从单文件转为包，保持原有对外符号不变）。"""
-
-from packages.domain.viral_video.entities import (
-    STAGE_LABELS,
-    FusionLevel,
-    PromptType,
-    StyleStrength,
-    ViralVideoJob,
-    ViralVideoStage,
-    ViralVideoStatus,
-)
-from packages.domain.viral_video.errors import (
-    ViralVideoComplianceError,
-    ViralVideoConfigError,
-    ViralVideoCreditsError,
-    ViralVideoError,
-    ViralVideoLLMError,
-    ViralVideoResourceError,
-    ViralVideoTimeoutError,
-    ViralVideoUpstreamError,
-)
-from packages.domain.viral_video.stages import (
-    PROGRESS_COPY_DONE,
-    PROGRESS_COPY_START,
-    PROGRESS_COPY_STREAMING,
-    PROGRESS_DONE,
-    PROGRESS_IMAGE_DONE,
-    PROGRESS_REVIEW,
-    PROGRESS_START,
-    PROGRESS_TRUST,
-    PROGRESS_TTS,
-    PROGRESS_UPLOAD_DONE,
-    PROGRESS_VIDEO_DONE,
-    PROGRESS_VIDEO_START,
-    STAGE_COPY_GENERATION,
-    STAGE_IMAGE_ANALYSIS,
-    STAGE_PHASE_MESSAGES,
-    STAGE_REVIEW,
-    STAGE_TRUST_CHAIN,
-    STAGE_TTS,
-    STAGE_UPLOADING,
-    STAGE_VIDEO_ANALYSIS,
-    STAGE_VIDEO_GENERATION,
-)
-
-__all__ = [
-    # entities
-    "FusionLevel",
-    "PromptType",
-    "STAGE_LABELS",
-    "StyleStrength",
-    "ViralVideoJob",
-    "ViralVideoStage",
-    "ViralVideoStatus",
-    # errors
-    "ViralVideoError",
-    "ViralVideoConfigError",
-    "ViralVideoUpstreamError",
-    "ViralVideoComplianceError",
-    "ViralVideoResourceError",
-    "ViralVideoCreditsError",
-    "ViralVideoTimeoutError",
-    "ViralVideoLLMError",
-    # stages
-    "STAGE_IMAGE_ANALYSIS",
-    "STAGE_VIDEO_ANALYSIS",
-    "STAGE_COPY_GENERATION",
-    "STAGE_REVIEW",
-    "STAGE_TRUST_CHAIN",
-    "STAGE_TTS",
-    "STAGE_VIDEO_GENERATION",
-    "STAGE_UPLOADING",
-    "STAGE_PHASE_MESSAGES",
-    "PROGRESS_START",
-    "PROGRESS_IMAGE_DONE",
-    "PROGRESS_COPY_START",
-    "PROGRESS_COPY_STREAMING",
-    "PROGRESS_COPY_DONE",
-    "PROGRESS_REVIEW",
-    "PROGRESS_TRUST",
-    "PROGRESS_TTS",
-    "PROGRESS_VIDEO_START",
-    "PROGRESS_VIDEO_DONE",
-    "PROGRESS_UPLOAD_DONE",
-    "PROGRESS_DONE",
-]

packages/domain/viral_video/errors.py

@@ -1,167 +0,0 @@
-"""爆款视频领域统一异常体系（PR3 P2）。
-
-所有爆款视频相关业务异常均继承 ViralVideoError，保证：
-1. 上层可统一捕获，按 code/user_message 组装前端响应；
-2. 不暴露内部栈/traceback；
-3. http_status 供 API 层映射 HTTP 状态码。
-"""
-
-from __future__ import annotations
-
-
-class ViralVideoError(Exception):
-    """爆款视频业务异常基类。"""
-
-    code: str = "viral_video_error"
-    user_message: str = "视频生成失败，请稍后重试"
-    detail: str | None = None
-    http_status: int = 500
-
-    def __init__(
-        self,
-        user_message: str | None = None,
-        detail: str | None = None,
-        code: str | None = None,
-        http_status: int | None = None,
-    ) -> None:
-        if user_message is not None:
-            self.user_message = user_message
-        self.detail = detail
-        if code is not None:
-            self.code = code
-        if http_status is not None:
-            self.http_status = http_status
-        super().__init__(self.user_message)
-
-    def __str__(self) -> str:  # pragma: no cover
-        return f"[{self.code}] {self.user_message}" + (f" :: {self.detail}" if self.detail else "")
-
-
-class ViralVideoConfigError(ViralVideoError):
-    """配置/初始化错误：缺模型、缺 API Key、依赖未就绪等。"""
-
-    code = "config_error"
-    http_status = 500
-
-    def __init__(
-        self,
-        user_message: str = "服务配置异常，请稍后重试",
-        detail: str | None = None,
-    ) -> None:
-        super().__init__(user_message=user_message, detail=detail)
-
-
-class ViralVideoUpstreamError(ViralVideoError):
-    """上游模型/云服务错误（火山 Seedance、阿里 Wan、OSS 等）。"""
-
-    code = "upstream_error"
-    http_status = 502
-
-    def __init__(
-        self,
-        provider: str,
-        upstream_code: str = "unknown",
-        user_message: str = "视频生成服务暂时不可用，请稍后重试",
-        detail: str | None = None,
-        status_code: int | None = None,
-    ) -> None:
-        self.provider = provider
-        self.upstream_code = upstream_code
-        self.status_code = status_code
-        super().__init__(user_message=user_message, detail=detail)
-
-
-class ViralVideoComplianceError(ViralVideoError):
-    """合规审核不通过（用户文案命中敏感/违规内容）。"""
-
-    code = "compliance_rejected"
-    http_status = 400
-
-    def __init__(
-        self,
-        user_message: str = "文案未通过合规审核，请修改后重试",
-        issues: list | None = None,
-        detail: str | None = None,
-    ) -> None:
-        self.issues: list = list(issues) if issues else []
-        super().__init__(user_message=user_message, detail=detail)
-
-
-class ViralVideoResourceError(ViralVideoError):
-    """资源不存在/失效：OSS URL 过期、图片找不到、返回空文件等。"""
-
-    code = "resource_error"
-    http_status = 502
-
-    def __init__(
-        self,
-        resource_type: str = "file",
-        resource_id: str = "",
-        user_message: str = "素材失效，请重新上传后重试",
-        detail: str | None = None,
-    ) -> None:
-        self.resource_type = resource_type
-        self.resource_id = resource_id
-        super().__init__(user_message=user_message, detail=detail)
-
-
-class ViralVideoCreditsError(ViralVideoError):
-    """积分不足/结算失败。"""
-
-    code = "credits_insufficient"
-    http_status = 402
-
-    def __init__(
-        self,
-        user_message: str = "积分不足，请充值后重试",
-        detail: str | None = None,
-    ) -> None:
-        super().__init__(user_message=user_message, detail=detail)
-
-
-class ViralVideoTimeoutError(ViralVideoError):
-    """某阶段执行超时（LLM/渲染/上传）。"""
-
-    code = "timeout"
-    http_status = 504
-
-    def __init__(
-        self,
-        stage: str,
-        timeout_s: float = 0.0,
-        user_message: str = "处理超时，请稍后重试",
-        detail: str | None = None,
-    ) -> None:
-        self.stage = stage
-        self.timeout_s = timeout_s
-        super().__init__(user_message=user_message, detail=detail)
-
-
-class ViralVideoLLMError(ViralVideoError):
-    """LLM 调用失败/重试耗尽/解析失败。"""
-
-    code = "llm_error"
-    http_status = 502
-
-    def __init__(
-        self,
-        stage: str = "script_generation",
-        model: str = "",
-        user_message: str = "文案生成失败，请稍后重试",
-        detail: str | None = None,
-    ) -> None:
-        self.stage = stage
-        self.model = model
-        super().__init__(user_message=user_message, detail=detail)
-
-
-__all__ = [
-    "ViralVideoError",
-    "ViralVideoConfigError",
-    "ViralVideoUpstreamError",
-    "ViralVideoComplianceError",
-    "ViralVideoResourceError",
-    "ViralVideoCreditsError",
-    "ViralVideoTimeoutError",
-    "ViralVideoLLMError",
-]

packages/domain/viral_video/stages.py

@@ -1,68 +0,0 @@
-"""爆款视频阶段与进度点常量（PR3 P2）。
-
-worker/API 中硬编码的阶段字符串与进度数值集中到此文件统一维护；
-注意：Celery task name / HTTP path / WS event name 属对外契约，不在此列。
-"""
-
-from __future__ import annotations
-
-# ── 阶段标识（对齐 ViralVideoStage 但更贴合 v1.6 实际链路） ──────────────
-STAGE_IMAGE_ANALYSIS: str = "image_analysis"
-STAGE_VIDEO_ANALYSIS: str = "video_analysis"
-STAGE_COPY_GENERATION: str = "script_generation"  # v1.6 文案=编导分镜
-STAGE_REVIEW: str = "review"
-STAGE_TRUST_CHAIN: str = "trust_chain"  # #2172 信任链预热
-STAGE_TTS: str = "tts"
-STAGE_VIDEO_GENERATION: str = "rendering"
-STAGE_UPLOADING: str = "uploading"
-
-# ── 阶段中文提示 ────────────────────────────────────────────────────────
-STAGE_PHASE_MESSAGES: dict[str, str] = {
-    STAGE_IMAGE_ANALYSIS: "正在分析图片内容...",
-    STAGE_VIDEO_ANALYSIS: "正在分析参考视频风格...",
-    STAGE_COPY_GENERATION: "正在生成文案与分镜...",
-    STAGE_REVIEW: "正在进行出片前合规审核...",
-    STAGE_TRUST_CHAIN: "正在AI化人像参考...",
-    STAGE_TTS: "正在合成AI配音...",
-    STAGE_VIDEO_GENERATION: "正在生成视频（约1-3分钟）...",
-    STAGE_UPLOADING: "正在上传成片...",
-}
-
-# ── 关键进度点（0-100）────────────────────────────────────────────────
-PROGRESS_START: float = 0.0
-PROGRESS_IMAGE_DONE: float = 10.0  # 图片分析完成
-PROGRESS_COPY_START: float = 15.0  # 进入文案生成
-PROGRESS_COPY_STREAMING: float = 30.0  # 文案流式输出中
-PROGRESS_COPY_DONE: float = 45.0  # 文案生成完成
-PROGRESS_REVIEW: float = 50.0  # 合规审核
-PROGRESS_TRUST: float = 60.0  # 信任链 AI 化
-PROGRESS_TTS: float = 65.0  # TTS 合成
-PROGRESS_VIDEO_START: float = 70.0  # 开始视频生成
-PROGRESS_VIDEO_DONE: float = 95.0  # 视频生成完成
-PROGRESS_UPLOAD_DONE: float = 98.0  # 上传完成
-PROGRESS_DONE: float = 100.0  # 全流程完成
-
-
-__all__ = [
-    "STAGE_IMAGE_ANALYSIS",
-    "STAGE_VIDEO_ANALYSIS",
-    "STAGE_COPY_GENERATION",
-    "STAGE_REVIEW",
-    "STAGE_TRUST_CHAIN",
-    "STAGE_TTS",
-    "STAGE_VIDEO_GENERATION",
-    "STAGE_UPLOADING",
-    "STAGE_PHASE_MESSAGES",
-    "PROGRESS_START",
-    "PROGRESS_IMAGE_DONE",
-    "PROGRESS_COPY_START",
-    "PROGRESS_COPY_STREAMING",
-    "PROGRESS_COPY_DONE",
-    "PROGRESS_REVIEW",
-    "PROGRESS_TRUST",
-    "PROGRESS_TTS",
-    "PROGRESS_VIDEO_START",
-    "PROGRESS_VIDEO_DONE",
-    "PROGRESS_UPLOAD_DONE",
-    "PROGRESS_DONE",
-]

packages/shared/ai_client.py

@@ -363,111 +363,6 @@ class DoubaoClient:
         logger.error("豆包API调用最终失败: elapsed=%.1fs err=%s", time.time() - _t0, last_error)
         return None
 
-    def chat_completion_stream(
-        self,
-        messages: list[dict[str, str]],
-        temperature: float = 0.7,
-        max_tokens: int | None = None,
-        model: str | None = None,
-        timeout: int | None = None,
-        **kwargs,
-    ):
-        """流式调用 Chat Completion 接口（SSE），逐块 yield delta 文本。
-
-        Yields:
-            str: 增量文本片段（delta.content）；全部结束后 StopIteration。
-            失败时 yield 空并返回（由调用方决定是否降级到同步调用）。
-
-        注意：
-        - 流式不做 finish_reason=length 自动扩容（流式难以拼接重试）；
-          如果调用方需要 length 截断处理，建议自行 fallback 到同步 chat_completion。
-        - 重试只在连接建立阶段（首包之前）有效；一旦开始 yield，错误直接抛出。
-        """
-        if not self.is_available:
-            return
-
-        import json as _json
-
-        url = f"{self.base_url}/chat/completions"
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "Accept": "text/event-stream",
-        }
-        effective_max_tokens = max_tokens if max_tokens is not None else (self.max_tokens or 1024)
-        payload: dict[str, Any] = {
-            "model": model or self.model,
-            "messages": messages,
-            "temperature": temperature,
-            "max_tokens": effective_max_tokens,
-            "stream": True,
-        }
-        if self.extra_params:
-            payload.update(self.extra_params)
-        if kwargs:
-            payload.update(kwargs)
-
-        _t0 = time.time()
-        for attempt in range(self.max_retries + 1):
-            try:
-                _req_timeout = httpx.Timeout(connect=10.0, read=120.0, write=30.0, pool=10.0)
-                if timeout:
-                    _req_timeout = httpx.Timeout(connect=10.0, read=max(int(timeout), 30), write=30.0, pool=10.0)
-                with httpx.stream(
-                    "POST",
-                    url,
-                    headers=headers,
-                    json=payload,
-                    timeout=_req_timeout,
-                ) as resp:
-                    resp.raise_for_status()
-                    for line in resp.iter_lines():
-                        if not line:
-                            continue
-                        line = line.strip()
-                        if not line.startswith("data:"):
-                            continue
-                        data_str = line[5:].strip()
-                        if data_str == "[DONE]":
-                            break
-                        try:
-                            chunk = _json.loads(data_str)
-                        except (_json.JSONDecodeError, ValueError):
-                            continue
-                        choices = chunk.get("choices") or []
-                        if not choices:
-                            continue
-                        delta = choices[0].get("delta") or {}
-                        content_piece = delta.get("content") or ""
-                        if content_piece:
-                            yield content_piece
-                        finish_reason = choices[0].get("finish_reason")
-                        if finish_reason:
-                            self.last_finish_reason = finish_reason
-                _elapsed = time.time() - _t0
-                logger.info(
-                    "[doubao] chat_completion_stream 完成 model=%s elapsed=%.1fs attempt=%d",
-                    payload.get("model"),
-                    _elapsed,
-                    attempt + 1,
-                )
-                return
-            except Exception as e:
-                if attempt < self.max_retries:
-                    wait = 0.5 * (2**attempt)
-                    logger.warning(
-                        "豆包流式API失败，%.1fs后重试 (%d/%d, elapsed=%.1fs): %s",
-                        wait,
-                        attempt + 1,
-                        self.max_retries + 1,
-                        time.time() - _t0,
-                        e,
-                    )
-                    time.sleep(wait)
-                    continue
-                logger.error("豆包流式API最终失败: elapsed=%.1fs err=%s", time.time() - _t0, e)
-                return
-
     def vision_completion(
         self,
         messages: list[dict],

packages/shared/dashscope_client.py

@@ -67,12 +67,10 @@ def _classify_dashscope_error(status_code: int, body: str, task_msg: str = "") -
         return "invalid_param", f"Wan 3.0 参数错误：{msg_in_body or body[:200]}"
     if status_code == 0:
         return "network_error", "Wan 3.0 服务连接失败（网络超时），请稍后重试。"
-    # 任务内失败（异步轮询结果）：此时 HTTP 200 只是查询成功，不代表任务成功，提示文案不要带 HTTP 200 以免误导
+    # 任务内失败
     if task_msg and any(kw in task_msg.lower() for kw in ("portrait", "真人", "人脸", "violation", "blocked")):
         return "portrait_intercept", "Wan 3.0 视频内容被安全策略拦截，请调整文案或参考图后重试。"
     detail = msg_in_body or body[:200]
-    if task_msg and status_code == 200:
-        return "task_failed", f"Wan 3.0 视频生成失败：{detail}"
     return "unknown", f"Wan 3.0 视频生成失败（HTTP {status_code}）：{detail}"
 
 

reports/viral-video-audit-20261014.md

@@ -1,116 +0,0 @@
-# 爆款视频模块全面审计报告
-
-**审计日期**: 2026-10-14
-**审计分支**: fix/viral-script-dual-format-parser
-**审计人**: CodeAct Agent
-**基准 commit**: 5e5a9b6 (#2294)
-
----
-
-## 一、Parser 改造说明
-
-### 改造内容
-将 `_script_from_xml`（仅支持纯 XML）改造为 `_parse_script`，支持三种 LLM 输出格式：
-
-| 格式 | 描述 | 解析路径 |
-|------|------|----------|
-| A: 纯 XML | `<script>...</script>` 包裹（v3/v4） | `_parse_script_xml` |
-| B: 双段式 | 中文 markdown 说明 + 末尾 `<script>` XML 块 | `_parse_script_xml`（提取最后一个 script 块） |
-| C: 纯中文 markdown | 无 `<script>` 标签，按"镜头1/镜头2..."分段 | `_parse_script_markdown` |
-| (兼容) 无包裹 v3 XML | 含 `<clips>/<voiceover_script>` 但无 `<script>` 包裹 | `_parse_script_xml`（整个 raw 当 XML body） |
-
-### 解析策略
-1. 正则 `r'<script[^>]*>(.*?)</script>'` (DOTALL) 提取所有 `<script>` 块，取最后一个
-2. 有 XML 块 → 走 XML 解析（`_parse_script_xml`）
-3. 无 `<script>` 但含 v3 结构标签（`<clips>/<voiceover_script>/<copy_display_markdown>`）→ 整个 raw 走 XML 解析（兼容旧格式）
-4. 都不匹配 → 走中文 markdown 兜底解析（`_parse_script_markdown`）
-5. 都解析不出 → 返回 None
-
-### 代码变更
-- `_script_from_xml` → `_parse_script`（入口函数）
-- 新增 `_parse_script_xml`（XML 路径解析，从原函数抽出）
-- 新增 `_parse_script_markdown`（中文 markdown 兜底解析）
-- 模块级常量：`_MD_SHOT_SPLIT_RE`, `_MD_TIME_RE`, `_MD_FIELD_RE` 等正则
-
----
-
-## 二、Seedance voiceover bug 修复说明
-
-### 问题
-`_assemble_seedance_prompt`（~line 1990/2010）循环 shots 时读 `s.get("voiceover", "")`，但原 `_script_from_xml` 输出的 shot dict 没有 `voiceover` 字段——口播被拼进了 `scene_and_dialogue = f"{visual}｜{voice}"`，导致 Seedance/Wan prompt 中口播为空。
-
-### 修复
-1. `_parse_script_xml`: 每个 shot dict 显式设置 `"voiceover": voice or ""`
-2. `_parse_script_markdown`: 同样输出 `"voiceover": voice` 字段
-3. `_fallback_script`: shot dict 加 `"voiceover": voiceover`（就是那一句 voiceover）
-4. `_assemble_seedance_prompt` 的 Wan 和 Seedance 两个分支都已正确读 `s.get("voiceover")`，无需改动
-
-### 验证
-- 新增测试 `TestShotVoiceoverField`（3 个用例）确认 XML/Markdown/Fallback 三条路径的 shot 都有 `voiceover`
-- 新增测试 `test_assemble_seedance_uses_shot_voiceover` 确认 Seedance prompt 能取到口播
-
----
-
-## 三、冗余代码清理情况
-
-| 项目 | 状态 | 说明 |
-|------|------|------|
-| `_script_from_xml` → `_parse_script` 重命名 | ✅ 完成 | 调用点（line ~1484）已同步更新 |
-| `_safe_json_loads` | ⚠️ 保留 | 已不在主流程使用（JSON fallback 路径已删），但 2 个单测引用它，暂保留 |
-| `_validate_copy_result` docstring | ✅ 更新 | 引用从 `_script_from_xml` 改为 `_parse_script` |
-| `_step_script_generation` docstring | ✅ 更新 | 反映双格式解析支持 |
-| reviewer.py voiceover_script XML 标签 | ✅ 确认无需改 | `<voiceover_script>` 仅存在于 reviewer 自己构造的 messages 里，跟 storyboard 输出格式无关 |
-| JSON fallback 残留 | ✅ 无残留 | 主流程无 JSON 解析路径，`_safe_json_loads` 仅测试引用 |
-
----
-
-## 四、全面审计结果
-
-### 审计清单 9 项
-
-| # | 审计项 | 验证结果 | 发现问题 | 修复情况 |
-|---|--------|----------|----------|----------|
-| 1 | **用户配置参数链路** | ✅ 基本完整 | `tone` 字段未在 API schema (GenerateCopyRequest) 中定义，但 worker 用 `getattr(job, "tone", "") or "亲切自然"` 优雅降级，不影响功能 | 记录为 minor issue，不影响本次 PR |
-| 2 | **图片分析→文案→review→渲染全流程** | ✅ 链路完整 | `_step_image_analysis` → `_step_script_generation` → `_step_review` → `_step_tts` → `_step_render` → `_step_upload`，每步有错误处理和降级 | 无需修复 |
-| 3 | **三视图机制** | ✅ 链路完整 | `pre_trusted_images` → `_build_character_section` → Seedream 三视图 → reference_images 通道。代码注释明确标注"当前为空实现，仅保留扩展点" | 无需修复 |
-| 4 | **few-shot example_output** | ✅ 正确使用 | `prompt_loader.build_messages` 在 storyboard 和 reviewer 两个场景都正确注入 few-shot（system→user示例→assistant示例→user任务） | 无需修复 |
-| 5 | **字数/时长约束** | ✅ 链路正确 | `constants.DURATION_SPEC` → `build_duration_constraint_text` → `{duration_constraint_text}` 占位符注入 → `_validate_copy_result` 校验 → `_truncate_voiceover` 截断 | 无需修复 |
-| 6 | **重试/超时机制** | ✅ 链路正确 | deadline 300s + fast@0.8 → fast@0.6 → pro@0.7 三档重试 + 流式外层 deadline + next() 超时 + 口播超长自动截断（`_truncate_voiceover`）| 无需修复 |
-| 7 | **fallback 脚本** | ✅ brand==name 去重生效 | `_fallback_script` 中 `_brand_str == _name_str or _brand_str in _name_str or _name_str in _brand_str` 三重判断确保去重（#2294 修复） | 本次新增 `voiceover` 字段到 shot dict |
-| 8 | **TTS/口型驱动链路** | ✅ 链路完整 | `voiceover_script` → `_step_tts` (CosyVoice) → 音频 URL → `_step_render` (Seedance) → 视频 → Ditto/MuseTalk 口型。voiceover 字段修复后链路更完整 | voiceover bug 修复（本次 PR） |
-| 9 | **review 审核阶段** | ✅ 逻辑正确 | `reviewer.py` 的 `_llm_review_inner` 用 `build_messages(template, voiceover_script=...)` 送审，XML 解析 `<passed>/<issues>`，审核失败合并本地规则后返回；LLM 不可用时降级放行（带 warning issue）| 无需修复 |
-
-### 发现的 Minor Issues（不阻塞本次 PR）
-
-1. **`tone` 参数未暴露到 API**: `GenerateCopyRequest` schema 没有 `tone` 字段，但 worker 用 `getattr` 优雅降级到默认值 "亲切自然"。前端如需自定义语气，需后续版本补 schema 字段。
-2. **`_safe_json_loads` 死代码**: 主流程已不使用（JSON fallback 在 PR1 已删），但 2 个单测 (`test_safe_json_loads_*`) 引用它。建议下个 PR 清理。
-3. **API ShotScript schema 缺 `voiceover` 字段**: `apps/api/app/schemas/viral_video.py` 的 `ShotScript` 模型没有 `voiceover` 字段定义。前端目前从 `scene_and_dialogue` 拆口播，后续可考虑暴露 `voiceover` 字段给前端。
-
----
-
-## 五、测试覆盖情况
-
-### 新增测试文件: `tests/unit/test_viral_video_dual_parser.py`
-
-| 测试类 | 用例数 | 覆盖范围 |
-|--------|--------|----------|
-| `TestDualFormatParsing` | 2 | 双段式（中文+XML）解析 + voiceover 字段 |
-| `TestPureXmlParsing` | 2 | 纯 XML 兼容性 + voiceover 字段 |
-| `TestPureMarkdownParsing` | 9 | 纯中文 markdown 解析（shots/theme/voiceover/time_range/audio/transition/reference/拼接/中文数字） |
-| `TestShotVoiceoverField` | 3 | XML/Fallback/Seedance 三条路径的 voiceover 字段 |
-| `TestParameterPassing` | 3 | marketing_purpose/target_audience/fusion_level 参数传递 |
-| `TestMarkdownParseFailures` | 4 | 解析失败返回 None（纯文本/空字符串/None/无口播） |
-
-**合计**: 23 个新增用例，全部通过。
-
-### 回归测试
-- 全量 viral 相关测试: **269 passed, 2 skipped**
-- 覆盖了 test_viral_video.py / test_viral_video_p0.py / test_viral_video_p2_errors.py / test_viral_video_prompt_system.py / test_viral_video_routes.py / test_viral_video_v8_bugs.py / test_viral_video_wiring.py / test_viral_video_ws.py / test_viral_video_models.py
-
----
-
-## 六、PR 信息
-
-- **分支**: `fix/viral-script-dual-format-parser`
-- **Base**: `develop`
-- **PR**: 待创建

scripts/ci/ci_env.sh

@@ -12,22 +12,3 @@ export CI_LOCAL_PG_PORT="${CI_LOCAL_PG_PORT:-5432}"
 
 # === 默认数据库名 ===
 export CI_DEFAULT_DB="${CI_DEFAULT_DB:-xiaoxia_saas}"
-
-# === Python 版本保障：本项目依赖 datetime.UTC，需要 Python >= 3.11 ===
-_ensure_python311() {
-  if python3 -c "import sys; assert sys.version_info >= (3, 11)" 2>/dev/null; then
-    return 0
-  fi
-  for cand in python3.12 python3.11 /opt/python3.12/bin/python3; do
-    if command -v "$cand" >/dev/null 2>&1 && "$cand" -c "import sys; assert sys.version_info >= (3, 11)" 2>/dev/null; then
-      _d="$(dirname "$(command -v "$cand")")"
-      export PATH="$_d:$PATH"
-      hash -r
-      echo "✅ ci_env: 切换到 $cand ($("$cand" -c 'import sys; print(sys.version.split()[0])'))"
-      return 0
-    fi
-  done
-  echo "❌ ci_env: 未找到 Python >= 3.11（datetime.UTC 需要），请安装 Python 3.11/3.12" >&2
-  return 1
-}
-_ensure_python311

scripts/ci/mypy_check.sh

@@ -4,28 +4,8 @@
 
 set -e
 
-SCRIPT_DIR="$(dirname "${BASH_SOURCE[0]}")"
-# shellcheck source=ci_env.sh
-source "${SCRIPT_DIR}/ci_env.sh"
-
-
 echo "=== Installing mypy ==="
-# pip�容错: 默认�(阿里云)缺文件时fallback到清�/官方�(2026-10-10 librt-0.6.0 metadata 404)
-MYPY_SPEC="mypy<1.19"
-INSTALL_OK=0
-python3 -m pip install -q "$MYPY_SPEC" && INSTALL_OK=1 || true
-if [ "$INSTALL_OK" != "1" ]; then
-  echo "WARN: default pip index failed, retry tsinghua mirror..."
-  python3 -m pip install -q -i https://pypi.tuna.tsinghua.edu.cn/simple "$MYPY_SPEC" && INSTALL_OK=1 || true
-fi
-if [ "$INSTALL_OK" != "1" ]; then
-  echo "WARN: tsinghua mirror failed, retry pypi.org..."
-  python3 -m pip install -q -i https://pypi.org/simple "$MYPY_SPEC" && INSTALL_OK=1 || true
-fi
-if [ "$INSTALL_OK" != "1" ]; then
-  echo "ERROR: pip install mypy failed on all indexes"
-  exit 1
-fi
+python3 -m pip install -q mypy
 mypy --version
 echo ""
 echo "=== Running mypy type check (hard gate mode) ==="

scripts/ci/run_unit_tests.sh

@@ -7,29 +7,9 @@ JOB_NAME="${1:-Unit Tests}"
 
 echo "=== CI Unit Tests 开始 ==="
 
-# --- Python 版本选择（必须 >= 3.11，代码使用 datetime.UTC）---
-if ! python3 -c "import sys; assert sys.version_info >= (3, 11)" 2>/dev/null; then
-  for cand in python3.12 python3.11 /opt/python3.12/bin/python3; do
-    if command -v "$cand" >/dev/null 2>&1 && "$cand" -c "import sys; assert sys.version_info >= (3, 11)" 2>/dev/null; then
-      PY3_DIR="$(dirname "$(command -v "$cand")")"
-      export PATH="$PY3_DIR:$PATH"
-      hash -r
-      echo "✅ python3 版本过低，改用 $cand ($("$cand" -c "import sys; print(sys.version.split()[0])"))"
-      break
-    fi
-  done
-  if ! python3 -c "import sys; assert sys.version_info >= (3, 11)" 2>/dev/null; then
-    echo "❌ 未找到 Python >= 3.11，本项目要求 Python 3.11+（使用 datetime.UTC）" >&2
-    exit 1
-  fi
-fi
-
-PYVER=$(python3 -c 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")')
-echo "使用 Python 版本: $(python3 --version)"
-
-# --- 依赖缓存检查（按 Python 版本区分缓存文件，避免跨版本复用）---
+# --- 依赖缓存检查 ---
 # 如果 requirements 文件未变化且依赖已安装，跳过 pip install（持久 runner 优化）
-REQ_HASH_FILE="/tmp/.ci_unit_tests_req_hash_py${PYVER}"
+REQ_HASH_FILE="/tmp/.ci_unit_tests_req_hash"
 CURRENT_REQ_HASH=""
 if [ -f requirements-base.txt ] && [ -f requirements.txt ] && [ -f requirements-dev.txt ]; then
   CURRENT_REQ_HASH=$(cat requirements-base.txt requirements.txt requirements-dev.txt | md5sum | cut -d' ' -f1)

scripts/ci/validate_code_quality.sh

@@ -77,11 +77,6 @@ set +e
 bandit -r apps packages -q -ll
 BANDIT_EXIT=$?
 set -e
-
-SCRIPT_DIR="$(dirname "${BASH_SOURCE[0]}")"
-# shellcheck source=ci_env.sh
-source "${SCRIPT_DIR}/ci_env.sh"
-
 if [ "$BANDIT_EXIT" -ne 0 ]; then
   echo "⚠️  Bandit found security issues (advisory mode - not blocking CI)"
 else

scripts/ci_staging_deploy.sh

@@ -108,10 +108,8 @@ server {
         proxy_set_header X-Real-IP $remote_addr;
         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
         proxy_set_header X-Forwarded-Proto $scheme;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection "upgrade";
-        proxy_read_timeout 3600s;
-        proxy_send_timeout 3600s;
+        proxy_read_timeout 300s;
+        proxy_send_timeout 300s;
         proxy_request_buffering off;
     }
 

scripts/render_env.sh

@@ -57,7 +57,7 @@ if [ "$TARGET_ENV" = "staging" ]; then
 fi
 
 # 共用 secrets 直接导出（如果存在）
-SHARED_SECRETS="OSS_ACCESS_KEY_ID OSS_ACCESS_KEY_SECRET COSYVOICE_API_KEY DASHSCOPE_API_KEY MEDIAKIT_API_KEY DOUBAO_API_KEY DOUBAO_MODEL DOUBAO_FAST_MODEL DOUBAO_BASE_URL DOUBAO_VISION_MODEL DOUBAO_VISION_LITE_MODEL DOUBAO_VISION_USE_LITE DOUBAO_IMAGE_MODEL DOUBAO_IMAGE_SIZE DOUBAO_IMAGE_TIMEOUT DOUBAO_FAST_MODEL DOUBAO_TIMEOUT DOUBAO_MAX_RETRIES DITTO_EMOTION_TIMEOUT WECHAT_APP_ID WECHAT_APP_SECRET TIKHUB_API_KEY APIZERO_API_KEY GPU_WORKER_TOKEN"
+SHARED_SECRETS="OSS_ACCESS_KEY_ID OSS_ACCESS_KEY_SECRET COSYVOICE_API_KEY DASHSCOPE_API_KEY MEDIAKIT_API_KEY DOUBAO_API_KEY DOUBAO_MODEL DOUBAO_FAST_MODEL DOUBAO_BASE_URL DOUBAO_VISION_MODEL DOUBAO_VISION_LITE_MODEL DOUBAO_VISION_USE_LITE DOUBAO_IMAGE_MODEL DOUBAO_IMAGE_SIZE DOUBAO_IMAGE_TIMEOUT DOUBAO_FAST_MODEL DOUBAO_TIMEOUT DOUBAO_MAX_RETRIES WECHAT_APP_ID WECHAT_APP_SECRET TIKHUB_API_KEY APIZERO_API_KEY GPU_WORKER_TOKEN"
 for var in $SHARED_SECRETS; do
   value="${!var:-}"
   # 已经在环境中了，无需额外操作

scripts/seed_viral_video_param_guides.py

@@ -1,247 +0,0 @@
-"""Seed viral_video_param_guides 表（PR3 P2-h）。
-
-将 worker 中硬编码的人设/结构/语言默认值灌入 DB，保证部署后查询有默认返回；
-运营可后续在后台修改，30s TTL 缓存自动生效。
-
-用法：
-    cd /root/work/xiaoxia-saas
-    PYTHONPATH=. python scripts/seed_viral_video_param_guides.py
-
-幂等：用 ON CONFLICT (guide_type, guide_key) DO UPDATE 保证重复执行安全。
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ROOT))
-
-from sqlalchemy import create_engine, text  # noqa: E402
-
-SEED_DATA: list[tuple[str, str, str]] = [
-    # ── persona：人设风格 ──────────────────────────────────────────────
-    ("persona", "宝妈", "温柔贴心，多从带娃和家庭实用角度分享，语气亲切有共鸣"),
-    ("persona", "店主", "热情实在，像当面招呼客人，突出靠谱和实在优惠"),
-    ("persona", "专业顾问", "专业可信，讲清原理和效果，用事实打消顾虑"),
-    ("persona", "年轻达人", "活泼有网感，节奏轻快，金句和梗自然不尬"),
-    ("persona", "老板型IP", "以老板第一人称出镜，真诚接地气，像招呼街坊邻居一样分享，突出创业初心和靠谱"),
-    ("persona", "知识博主", "条理清晰、数据说话，干货密度高，语气专业但不枯燥"),
-    ("persona", "生活美学", "画面感强，注重氛围和质感描述，语速偏慢，文字有诗意"),
-    ("persona", "健身教练", "energetic、鼓励式口吻，强调动作要领和效果变化"),
-    ("persona", "美妆达人", "细腻讲质地和妆效，像闺蜜安利，语气亲切有感染力"),
-    ("persona", "美食博主", "色香味描述丰富，口语化带馋感，节奏轻快"),
-    ("persona", "穿搭博主", "讲搭配逻辑和场景适配，时尚但不高冷，像朋友建议"),
-    ("persona", "育儿师", "科学育儿角度，温柔坚定，给具体可操作的建议"),
-    # ── structure：爆款结构 ────────────────────────────────────────────
-    (
-        "structure",
-        "反差破局+亮明观点+还原现状",
-        "开头3秒用反差/痛点钩子抓注意力，中段亮出核心卖点或观点，结尾还原真实到店/使用场景引导行动",
-    ),
-    (
-        "structure",
-        "痛点切入+方案展示+效果对比",
-        "开头直击用户痛点场景，中间展示产品/服务解决方案，结尾用前后对比强化效果",
-    ),
-    (
-        "structure",
-        "故事引入+产品种草+行动引导",
-        "用一个真实小故事/案例引入，自然过渡到产品种草，结尾明确引导用户下一步行动",
-    ),
-    (
-        "structure",
-        "场景展示+价值输出+信任背书",
-        "开头展示使用场景让用户代入，中间输出核心价值主张，结尾用客户评价/数据等信任背书收尾",
-    ),
-    ("structure", "悬念开场+层层递进+高潮转化", "开头制造悬念引发好奇，内容层层推进保持张力，高潮处给出转化钩子"),
-    # ── language：语言提示 ─────────────────────────────────────────────
-    ("language", "zh-cn", "使用标准普通话，口语化表达"),
-    ("language", "zh-tw", "使用台湾腔中文，语气温柔亲切"),
-    ("language", "zh-hk", "使用粤语风格中文表达"),
-    ("language", "en-us", "使用美式英语，自然口语化"),
-    ("language", "en-gb", "使用英式英语"),
-    ("language", "ja-jp", "使用日语，自然口语化"),
-    ("language", "ko-kr", "使用韩语，亲切自然"),
-    # ── marketing_purpose：营销目的（前端枚举 + 常见关键词，20项）─────────
-    (
-        "marketing_purpose",
-        "获客引流",
-        "【口播获客】第一人称对镜头发声，突出到店/加粉福利和行动引导，节奏紧凑有钩子，结尾明确CTA",
-    ),
-    (
-        "marketing_purpose",
-        "账号涨粉",
-        "【涨粉内容】开头有强反差/悬念钩子抓注意力，内容有信息密度和共鸣点，结尾引导关注不生硬",
-    ),
-    (
-        "marketing_purpose",
-        "活动通知",
-        "【活动通知】开头直接说活动主题和时间，中段讲福利/优惠力度，结尾强调截止时间和参与方式，信息清晰不绕弯",
-    ),
-    (
-        "marketing_purpose",
-        "口播带货",
-        "【口播带货】第一人称对镜头说话，像真人出镜推荐好物，有真实使用体验感，突出卖点和使用效果，结尾有购买引导",
-    ),
-    (
-        "marketing_purpose",
-        "促销转化",
-        "【促销转化】强调限时/限量/专属优惠，制造紧迫感，价格/优惠信息清晰突出，有明确购买路径",
-    ),
-    (
-        "marketing_purpose",
-        "场景种草",
-        "【场景种草】在真实使用场景中展示产品/服务，自然带出卖点，让用户产生代入感和'我也想试试'的欲望",
-    ),
-    (
-        "marketing_purpose",
-        "痛点解决",
-        "【痛点解决】开头直击目标用户的具体痛点场景，中段给出解决方案和使用演示，结尾强调效果对比",
-    ),
-    (
-        "marketing_purpose",
-        "功能演示",
-        "【功能演示】以产品功能展示为主，操作步骤清晰可见，讲清楚'怎么用'和'用了有什么效果'，少废话多演示",
-    ),
-    (
-        "marketing_purpose",
-        "门店发现",
-        "【门店探店】店主或探店博主出镜，真实展示门店环境、招牌产品/服务、价格和体验感，结尾有到店引导",
-    ),
-    (
-        "marketing_purpose",
-        "到店实录",
-        "【到店实录】真实记录到店体验全过程，镜头跟着主走进店、看环境、体验服务、尝产品，节奏自然真实",
-    ),
-    (
-        "marketing_purpose",
-        "招牌体验",
-        "【招牌体验】聚焦门店/品牌的招牌产品/服务，细节展示特色卖点，突出'为什么这是招牌'，有记忆点",
-    ),
-    (
-        "marketing_purpose",
-        "同城团购",
-        "【同城团购】突出本地/同城/到店属性，讲清楚团购优惠内容、使用规则、门店位置，结尾引导下单",
-    ),
-    (
-        "marketing_purpose",
-        "品牌主张",
-        "【品牌主张】传递品牌理念和价值观，有态度有情感共鸣，画面质感高级，少硬广多故事感",
-    ),
-    (
-        "marketing_purpose",
-        "品牌故事",
-        "【品牌故事】用叙事方式讲品牌的创立初心/工艺传承/用户故事，有情感起伏，建立品牌信任",
-    ),
-    (
-        "marketing_purpose",
-        "生活方式",
-        "【生活方式】营造向往的生活场景和氛围，产品/服务自然融入生活片段，调性好看有质感，引发'想过这样的生活'的共鸣",
-    ),
-    (
-        "marketing_purpose",
-        "创意概念",
-        "【创意概念】画面有创意和视觉冲击力，概念新颖不套路，适合做品牌传播内容，让人愿意转发分享",
-    ),
-    (
-        "marketing_purpose",
-        "对话短剧",
-        "【短剧模式】必须双/多角色对话格式，台词用'角色：xxx'格式，镜头在角色间切换，有剧情冲突或反转，禁止第三人称旁白解说",
-    ),
-    (
-        "marketing_purpose",
-        "反转短剧",
-        "【反转短剧】前半段建立常规预期，后半段出人意料反转，对话推动剧情，节奏紧凑有爽感，结尾反转干脆利落",
-    ),
-    (
-        "marketing_purpose",
-        "悬念短剧",
-        "【悬念短剧】开头制造悬念或谜题，剧情层层推进吊足胃口，结尾揭晓答案，角色对话推进，不要旁白解说",
-    ),
-    (
-        "marketing_purpose",
-        "情绪短片",
-        "【情绪短片】用画面、音乐和简短台词传递情绪（治愈/感动/激励/共鸣），节奏偏慢有氛围感，文字克制留白",
-    ),
-    # ── target_customer：目标客群（前端枚举 8项）─────────────────────
-    (
-        "target_customer",
-        "小镇青年",
-        "【目标小镇青年】台词接地气有网感，贴近下沉市场生活场景，讲实在优惠和真实体验，节奏轻快不端着",
-    ),
-    (
-        "target_customer",
-        "小镇中老年",
-        "【目标小镇中老年】台词慢节奏、吐字清晰、信息直白，强调实惠耐用和健康养生，少用网络梗",
-    ),
-    (
-        "target_customer",
-        "Z世代",
-        "【目标Z世代】台词活泼有梗、节奏快，可用流行语和弹幕感表达，突出个性、有趣、社交话题性",
-    ),
-    (
-        "target_customer",
-        "精致妈妈",
-        "【目标精致妈妈】台词温柔贴心，从育儿/家庭/品质生活角度切入，强调安全、省心、性价比，有真实带娃/家居场景共鸣",
-    ),
-    (
-        "target_customer",
-        "新锐白领",
-        "【目标新锐白领】台词简洁干练，突出效率、品质、格调，讲职场/都市生活场景，少废话直接说价值",
-    ),
-    (
-        "target_customer",
-        "资深中产",
-        "【目标资深中产】台词专业有深度，强调品质、品位、身份感，调性高级克制，不浮夸不喊麦",
-    ),
-    (
-        "target_customer",
-        "都市蓝领",
-        "【目标都市蓝领】台词实在接地气，强调性价比、耐用、实惠，讲打工/租房/日常刚需场景，贴近生活",
-    ),
-    (
-        "target_customer",
-        "都市银发",
-        "【目标都市银发】台词清晰慢节奏，强调健康、实惠、方便操作，避免复杂术语和网络用语，信息直白",
-    ),
-]
-
-
-def _get_engine():
-    """获取 DB engine。优先 DATABASE_URL 环境变量；否则走应用配置（与 seed_viral_video_prompts.py 一致）。"""
-    import os
-
-    database_url = os.environ.get("DATABASE_URL")
-    if database_url:
-        url = database_url
-    else:
-        from packages.config import get_shared_settings
-
-        url = str(get_shared_settings().database_url)
-    # asyncpg → psycopg2（脚本里不能用 async driver）
-    url = url.replace("postgresql+asyncpg://", "postgresql+psycopg2://")
-    if url.startswith("postgresql://") and "psycopg" not in url:
-        url = url.replace("postgresql://", "postgresql+psycopg2://", 1)
-    return create_engine(url, pool_pre_ping=True)
-
-
-def main() -> None:
-    engine = _get_engine()
-    insert_sql = text("""
-        INSERT INTO viral_video_param_guides (guide_type, guide_key, guide_text)
-        VALUES (:gt, :gk, :gtxt)
-        ON CONFLICT (guide_type, guide_key)
-        DO UPDATE SET guide_text = EXCLUDED.guide_text, updated_at = NOW()
-        """)
-    count = 0
-    with engine.begin() as conn:
-        for gt, gk, gtxt in SEED_DATA:
-            conn.execute(insert_sql, {"gt": gt, "gk": gk, "gtxt": gtxt})
-            count += 1
-    print(f"[seed_viral_video_param_guides] upserted {count} rows")
-
-
-if __name__ == "__main__":
-    main()

scripts/seed_viral_video_prompts.py

@@ -1,4 +1,4 @@
-"""爆款视频 Prompt 模板种子脚本（#2040，PR1 清理至 3 套：image_analysis/storyboard/review）。
+"""爆款视频 5 套 Prompt 模板种子脚本（#2040）。
 
 幂等：以 (prompt_type, version) 为唯一键，存在则更新（UPSERT），重复执行结果一致。
 用法：
@@ -72,7 +72,7 @@ def seed(engine) -> int:
 def main() -> int:
     engine = _engine()
     count = seed(engine)
-    print(f"seed 完成：{count} 套模板已写入/更新（image_analysis/storyboard/review）")
+    print(f"seed 完成：{count} 套模板已写入/更新（image_analysis/intent_parsing/copy_fusion/storyboard/review）")
     return 0
 
 

tests/unit/test_ai_avatar_render_routes.py

@@ -449,296 +449,3 @@ class TestRenderSmartCoverRoute:
         assert result.cover_url == ""
         # 失败时不写 cover_config / 不 commit
         mock_db.commit.assert_not_called()
-
-
-class TestFinalizeRoute:
-    """POST /renders/{job_id}/finalize — 封面选好后正式入库成片库."""
-
-    def _make_existing_video(self, video_id="video-1", cover_url="https://oss/existing-cover.jpg"):
-        v = MagicMock()
-        v.id = video_id
-        v.thumbnail_url = cover_url
-        return v
-
-    def _make_finalized_video(self, video_id="video-new", thumbnail_url="https://oss/final-cover.jpg"):
-        v = MagicMock()
-        v.id = video_id
-        v.thumbnail_url = thumbnail_url
-        return v
-
-    def test_finalize_job_not_found_returns_404(self):
-        """任务不存在 → 404."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-        from fastapi import HTTPException
-
-        mock_service = MagicMock()
-        mock_service.get_render_job.return_value = None
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest()
-
-        with patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service):
-            with pytest.raises(HTTPException) as exc_info:
-                finalize_render_job(job_id="render-missing", body=body, current_user=mock_user, db=mock_db)
-
-        assert exc_info.value.status_code == 404
-        assert "不存在" in exc_info.value.detail
-
-    def test_finalize_job_not_completed_returns_400(self):
-        """任务未 completed（如 processing）→ 400."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-        from fastapi import HTTPException
-
-        mock_service = MagicMock()
-        mock_job = _make_mock_render_job(status="processing", output_video_url="https://oss/v.mp4")
-        mock_service.get_render_job.return_value = mock_job
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest()
-
-        with patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service):
-            with pytest.raises(HTTPException) as exc_info:
-                finalize_render_job(job_id="render-1", body=body, current_user=mock_user, db=mock_db)
-
-        assert exc_info.value.status_code == 400
-        assert "先完成视频生成" in exc_info.value.detail
-
-    def test_finalize_empty_video_url_returns_400(self):
-        """已 completed 但 output_video_url 为空 → 400."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-        from fastapi import HTTPException
-
-        mock_service = MagicMock()
-        mock_job = _make_mock_render_job(status="completed", output_video_url="   ")
-        mock_service.get_render_job.return_value = mock_job
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest()
-
-        with patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service):
-            with pytest.raises(HTTPException) as exc_info:
-                finalize_render_job(job_id="render-1", body=body, current_user=mock_user, db=mock_db)
-
-        assert exc_info.value.status_code == 400
-        assert "URL 为空" in exc_info.value.detail
-
-    def test_finalize_idempotent_returns_existing(self):
-        """已 finalize 过 → 幂等返回 existing 记录，不重复入库."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-
-        mock_service = MagicMock()
-        mock_job = _make_mock_render_job(status="completed", output_video_url="https://oss/v.mp4")
-        mock_service.get_render_job.return_value = mock_job
-        existing = self._make_existing_video()
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = existing
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest()
-
-        with patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service):
-            result = finalize_render_job(job_id="render-1", body=body, current_user=mock_user, db=mock_db)
-
-        assert result.status == "already_finalized"
-        assert result.video_id == "video-1"
-        assert result.cover_url == "https://oss/existing-cover.jpg"
-        mock_service.finalize_job.assert_not_called()
-
-    def test_finalize_empty_body_uses_smart_cover_url(self):
-        """空 body 且 job.output_cover_url 已由 smart-cover 写入 → 直接用，不抽帧."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-
-        mock_service = MagicMock()
-        mock_job = _make_mock_render_job(
-            status="completed",
-            output_video_url="https://oss/v.mp4",
-            output_cover_url="https://oss/smart-cover.jpg",
-        )
-        mock_service.get_render_job.return_value = mock_job
-        finalized = self._make_finalized_video(thumbnail_url="https://oss/smart-cover.jpg")
-        mock_service.finalize_job.return_value = finalized
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest()
-
-        with (
-            patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service),
-            patch("app.api.routes.ai_avatar_render.generate_smart_cover") as mock_gen,
-        ):
-            result = finalize_render_job(job_id="render-1", body=body, current_user=mock_user, db=mock_db)
-
-        mock_gen.assert_not_called()
-        mock_service.finalize_job.assert_called_once()
-        call_kwargs = mock_service.finalize_job.call_args.kwargs
-        assert call_kwargs["cover_url"] == "https://oss/smart-cover.jpg"
-        assert call_kwargs.get("video_title") is None
-        assert result.status == "success"
-        assert result.cover_url == "https://oss/smart-cover.jpg"
-
-    def test_finalize_body_cover_url_takes_priority(self):
-        """body.cover_url 优先于 job.output_cover_url."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-
-        mock_service = MagicMock()
-        mock_job = _make_mock_render_job(
-            status="completed",
-            output_video_url="https://oss/v.mp4",
-            output_cover_url="https://oss/smart-cover.jpg",
-        )
-        mock_service.get_render_job.return_value = mock_job
-        finalized = self._make_finalized_video(thumbnail_url="https://oss/custom-cover.jpg")
-        mock_service.finalize_job.return_value = finalized
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest(cover_url="https://oss/custom-cover.jpg")
-
-        with (
-            patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service),
-            patch("app.api.routes.ai_avatar_render.generate_smart_cover") as mock_gen,
-        ):
-            result = finalize_render_job(job_id="render-1", body=body, current_user=mock_user, db=mock_db)
-
-        mock_gen.assert_not_called()
-        call_kwargs = mock_service.finalize_job.call_args.kwargs
-        assert call_kwargs["cover_url"] == "https://oss/custom-cover.jpg"
-        assert result.cover_url == "https://oss/custom-cover.jpg"
-
-    def test_finalize_blob_url_is_ignored(self):
-        """body 传 blob:/data: 等非 HTTP URL → 忽略，走已有 cover/兜底."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-
-        mock_service = MagicMock()
-        mock_job = _make_mock_render_job(
-            status="completed",
-            output_video_url="https://oss/v.mp4",
-            output_cover_url="https://oss/smart-cover.jpg",
-        )
-        mock_service.get_render_job.return_value = mock_job
-        finalized = self._make_finalized_video(thumbnail_url="https://oss/smart-cover.jpg")
-        mock_service.finalize_job.return_value = finalized
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest(cover_url="blob:http://localhost/xxx")
-
-        with (
-            patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service),
-            patch("app.api.routes.ai_avatar_render.generate_smart_cover") as mock_gen,
-        ):
-            result = finalize_render_job(job_id="render-1", body=body, current_user=mock_user, db=mock_db)
-
-        mock_gen.assert_not_called()
-        call_kwargs = mock_service.finalize_job.call_args.kwargs
-        # blob URL 被忽略，fallback 到 job.output_cover_url
-        assert call_kwargs["cover_url"] == "https://oss/smart-cover.jpg"
-        assert result.cover_url == "https://oss/smart-cover.jpg"
-
-    def test_finalize_no_cover_fallback_to_smart_cover(self):
-        """无 body.cover_url 且 job.output_cover_url 为空 → 兜底自动抽帧."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-
-        mock_service = MagicMock()
-        mock_job = _make_mock_render_job(
-            status="completed",
-            output_video_url="https://oss/v.mp4",
-            output_cover_url="",
-        )
-        mock_job.cover_config = {}
-        mock_service.get_render_job.return_value = mock_job
-        finalized = self._make_finalized_video(thumbnail_url="https://oss/fallback-cover.jpg")
-        mock_service.finalize_job.return_value = finalized
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest()
-
-        with (
-            patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service),
-            patch(
-                "app.api.routes.ai_avatar_render.generate_smart_cover",
-                return_value="https://oss/fallback-cover.jpg",
-            ) as mock_gen,
-        ):
-            result = finalize_render_job(job_id="render-1", body=body, current_user=mock_user, db=mock_db)
-
-        mock_gen.assert_called_once_with("https://oss/v.mp4", job_id="render-1", max_frames=5)
-        call_kwargs = mock_service.finalize_job.call_args.kwargs
-        assert call_kwargs["cover_url"] == "https://oss/fallback-cover.jpg"
-        # 兜底成功应回写 job.cover_config 和 output_cover_url
-        assert mock_job.output_cover_url == "https://oss/fallback-cover.jpg"
-        assert mock_job.cover_config["mode"] == "auto_frame"
-        assert mock_job.cover_config["url"] == "https://oss/fallback-cover.jpg"
-        assert mock_db.commit.called
-        assert result.cover_url == "https://oss/fallback-cover.jpg"
-
-    def test_finalize_video_title_override(self):
-        """body.video_title 覆盖默认 AI数字人_xxx."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-
-        mock_service = MagicMock()
-        mock_job = _make_mock_render_job(
-            status="completed",
-            output_video_url="https://oss/v.mp4",
-            output_cover_url="https://oss/c.jpg",
-        )
-        mock_service.get_render_job.return_value = mock_job
-        finalized = self._make_finalized_video()
-        mock_service.finalize_job.return_value = finalized
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest(video_title="我和我的养生馆")
-
-        with (
-            patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service),
-            patch("app.api.routes.ai_avatar_render.generate_smart_cover") as mock_gen,
-        ):
-            result = finalize_render_job(job_id="render-1", body=body, current_user=mock_user, db=mock_db)
-
-        mock_gen.assert_not_called()
-        call_kwargs = mock_service.finalize_job.call_args.kwargs
-        assert call_kwargs["video_title"] == "我和我的养生馆"
-        assert result.status == "success"
-
-    def test_finalize_service_error_mapped_to_http(self):
-        """service 抛 AiAvatarRenderError → 按 code 映射 HTTP 状态码."""
-        from app.api.routes.ai_avatar_render import finalize_render_job
-        from app.schemas.ai_avatar_render import FinalizeRenderRequest
-        from app.services.ai_avatar_render_service import AiAvatarRenderError
-        from fastapi import HTTPException
-
-        mock_service = MagicMock()
-        mock_job = _make_mock_render_job(
-            status="completed",
-            output_video_url="https://oss/v.mp4",
-            output_cover_url="https://oss/c.jpg",
-        )
-        mock_service.get_render_job.return_value = mock_job
-        mock_service.finalize_job.side_effect = AiAvatarRenderError("成片视频不存在", code="OutputVideoMissing")
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-        mock_user = _make_mock_auth_user()
-        body = FinalizeRenderRequest()
-
-        with (
-            patch("app.services.ai_avatar_render_service.AiAvatarRenderService", return_value=mock_service),
-            patch("app.api.routes.ai_avatar_render.generate_smart_cover") as mock_gen,
-        ):
-            with pytest.raises(HTTPException) as exc_info:
-                finalize_render_job(job_id="render-1", body=body, current_user=mock_user, db=mock_db)
-
-        assert exc_info.value.status_code == 400
-        mock_gen.assert_not_called()