fix(ditto): 网络不通快速失败回退+精细化超时

1. connect超时硬编码10s（网络断/Tailscale掉时快速失败，避免卡5分钟）
2. read超时默认120s（原300s过长，按RTF≈2.8推40s音频约112s）
3. ConnectError/NetworkError/OSError不重试，直接抛NetworkUnreachable快速回退MediaKit
4. 429/5xx/Timeout才走重试逻辑
5. 新增test_generate_network_error_fails_fast单测验证网络不通<5s失败且不重试

.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: ''

alembic/versions/106_system_settings.py

@@ -1,43 +0,0 @@
-# -*- coding: utf-8 -*-
-"""system_settings 正式建表（#2246）
-
-Revision ID: 106_system_settings
-Revises: 105_narration_first
-Create Date: 2026-10-08
-
-system_settings 表此前在 staging 手工创建（对应 034 占位迁移），
-此处补正式迁移保证其他环境一致。CREATE TABLE/INDEX 使用 IF NOT EXISTS，
-对已手工建表的环境幂等。
-"""
-
-from alembic import op
-
-revision = "106_system_settings"
-down_revision = "105_narration_first"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.execute("""
-        CREATE TABLE IF NOT EXISTS system_settings (
-            id VARCHAR(36) NOT NULL,
-            setting_key VARCHAR(100) NOT NULL,
-            setting_value TEXT,
-            setting_type VARCHAR(20) NOT NULL,
-            description VARCHAR(255) NOT NULL DEFAULT '',
-            is_public BOOLEAN NOT NULL DEFAULT FALSE,
-            updated_by VARCHAR(36),
-            category VARCHAR(50) NOT NULL DEFAULT 'general',
-            created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
-            updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
-            CONSTRAINT pk_system_settings PRIMARY KEY (id),
-            CONSTRAINT uq_system_settings_setting_key UNIQUE (setting_key)
-        )
-        """)
-    op.execute("CREATE INDEX IF NOT EXISTS ix_system_settings_category " "ON system_settings (category)")
-
-
-def downgrade() -> None:
-    op.execute("DROP INDEX IF EXISTS ix_system_settings_category")
-    op.execute("DROP TABLE IF EXISTS system_settings")

alembic/versions/107_add_language_to_viral_video_jobs.py

@@ -1,23 +0,0 @@
-"""add language column to viral_video_jobs
-
-Revision ID: 107
-Revises: 106_system_settings
-Create Date: 2026-10-09
-
-"""
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = "107"
-down_revision = "106_system_settings"
-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'")
-
-
-def downgrade() -> None:
-    op.execute("ALTER TABLE viral_video_jobs DROP COLUMN IF EXISTS language")

apps/api/app/api/router.py

@@ -1,4 +1,3 @@
-from app.api.routes.admin.ditto_emotion import router as admin_ditto_emotion_router
 from app.api.routes.ai import router as ai_router
 from app.api.routes.ai_avatar_render import router as ai_avatar_render_router
 from app.api.routes.asset_diagnosis import router as asset_diagnosis_router
@@ -243,6 +242,3 @@ api_router.include_router(
     tags=["GPU Worker"],
 )
 api_router.include_router(viral_video_router, prefix="/viral-video", tags=["爆款视频"])
-
-# #2246：后台 Ditto 表情配置（router 自带 /admin/ditto-emotion 前缀）
-api_router.include_router(admin_ditto_emotion_router)

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

@@ -1 +0,0 @@
-"""后台管理路由（#2246 起）."""

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

@@ -1,163 +0,0 @@
-"""Ditto 数字人表情后台配置 — #2246.
-
-路由前缀 /api/v1/admin/ditto-emotion，全部使用 _verify_internal_api_key 鉴权
-（X-API-Key header）。仅开放 5 项白名单配置：
-- ditto_emotion_enabled / ditto_emotion_model / ditto_emotion_temperature
-- ditto_emotion_prompt / ditto_blend_frames
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from fastapi import APIRouter, Depends
-from pydantic import BaseModel
-
-from packages.application.system_config_service import get_system_config_service
-from packages.config import get_api_settings
-from packages.domain.system_setting import (
-    SETTING_TYPE_BOOL,
-    SETTING_TYPE_FLOAT,
-    SETTING_TYPE_INT,
-    SETTING_TYPE_STRING,
-)
-
-from ..auth import _verify_internal_api_key
-
-router = APIRouter(
-    prefix="/admin/ditto-emotion",
-    tags=["Admin"],
-    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,
-    "ditto_emotion_model": SETTING_TYPE_STRING,
-    "ditto_emotion_temperature": SETTING_TYPE_FLOAT,
-    "ditto_emotion_prompt": SETTING_TYPE_STRING,
-    "ditto_blend_frames": SETTING_TYPE_INT,
-}
-
-_DESCRIPTIONS: dict[str, str] = {
-    "ditto_emotion_enabled": "LLM 情绪分析开关。关闭时回退到原有关键词匹配模式，不影响正常出片。",
-    "ditto_emotion_model": "用于分析文案情绪的大模型。",
-    "ditto_emotion_temperature": "模型温度，0-1，越低越稳定保守。",
-    "ditto_emotion_prompt": "情绪分析提示词，核心调优入口，必须包含 {文案} 占位符。",
-    "ditto_blend_frames": "表情切换过渡帧数（6-30），越大越柔和。",
-}
-
-
-def _settings():
-    return get_api_settings()
-
-
-def _default_value(key: str) -> Any:
-    return getattr(_settings(), key)
-
-
-def _build_config_item(key: str) -> dict[str, Any]:
-    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"] = list(MODEL_OPTIONS)
-    return item
-
-
-class ConfigUpdatePayload(BaseModel):
-    configs: dict[str, Any]
-
-
-class TestPayload(BaseModel):
-    test_text: str
-
-
-def _validate_value(key: str, value: Any) -> Any:
-    st = _WHITELIST[key]
-    if st == SETTING_TYPE_BOOL:
-        if not isinstance(value, bool):
-            raise ValueError(f"{key} 必须是布尔值")
-    elif st == SETTING_TYPE_INT:
-        if isinstance(value, bool) or not isinstance(value, int):
-            raise ValueError(f"{key} 必须是整数")
-        if not 6 <= value <= 30:
-            raise ValueError(f"{key} 必须在 6-30 之间")
-    elif st == SETTING_TYPE_FLOAT:
-        if isinstance(value, bool):
-            raise ValueError(f"{key} 必须是数字")
-        try:
-            value = float(value)
-        except (TypeError, ValueError) as exc:
-            raise ValueError(f"{key} 必须是数字") from exc
-        if not 0.0 <= value <= 1.0:
-            raise ValueError(f"{key} 必须在 0-1 之间")
-    elif st == SETTING_TYPE_STRING:
-        if not isinstance(value, str):
-            raise ValueError(f"{key} 必须是字符串")
-        if key == "ditto_emotion_prompt" and value.strip() and "{文案}" not in value:
-            raise ValueError("提示词必须包含 {文案} 占位符")
-        if key == "ditto_emotion_model" and value not in MODEL_OPTIONS:
-            raise ValueError(f"模型必须是以下之一：{', '.join(MODEL_OPTIONS)}")
-    return value
-
-
-@router.get("/config")
-def get_config() -> dict[str, Any]:
-    return {"configs": [_build_config_item(k) for k in _WHITELIST]}
-
-
-@router.put("/config")
-def update_config(
-    payload: ConfigUpdatePayload,
-    x_api_key: str = Depends(_verify_internal_api_key),
-) -> dict[str, Any]:
-    configs = payload.configs
-    illegal = [k for k in configs if k not in _WHITELIST]
-    if illegal:
-        return {
-            "ok": False,
-            "error": f"不允许修改的配置项：{', '.join(illegal)}",
-        }
-    service = get_system_config_service()
-    updated: dict[str, Any] = {}
-    for key, raw in configs.items():
-        try:
-            value = _validate_value(key, raw)
-        except ValueError as exc:
-            return {"ok": False, "error": str(exc)}
-        service.set_config(
-            key,
-            value,
-            setting_type=_WHITELIST[key],
-            updated_by=x_api_key[:8] if x_api_key else None,
-        )
-        updated[key] = value
-    return {"ok": True, "updated": updated}
-
-
-@router.post("/config/test")
-def test_config(payload: TestPayload) -> dict[str, Any]:
-    text = (payload.test_text or "").strip()
-    if not text:
-        return {"ok": False, "error": "test_text 不能为空"}
-    from packages.application.ditto_emotion_service import get_ditto_emotion_service
-
-    service = get_ditto_emotion_service()
-    segments = service.analyze(text)
-    return {
-        "ok": True,
-        "enabled": service.enabled,
-        "segments": [s.to_dict() for s in segments],
-    }

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

@@ -142,7 +142,6 @@ def _to_response(job) -> ViralVideoJobResponse:
         copy_result=_build_copy_result(job),
         voice_id=getattr(job, "voice_id", "") or "",
         voice_source=getattr(job, "voice_source", "") or "",
-        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,
@@ -244,7 +243,6 @@ def analyze_images(
         style_strength=request.style_strength or "medium",
         voice_id=request.voice_id or "",
         voice_source=request.voice_source or "",
-        language=getattr(request, "language", "zh-CN") or "zh-CN",
         video_ratio=request.video_ratio or "9:16",
         video_model=request.video_model or "",
         video_resolution=getattr(request, "video_resolution", "720p") or "720p",
@@ -316,7 +314,6 @@ def generate_copy(
         job.style_guide = request.style_guide
     job.voice_id = request.voice_id or job.voice_id
     job.voice_source = request.voice_source or job.voice_source
-    job.language = getattr(request, "language", "") or job.language or "zh-CN"
     job.video_ratio = request.video_ratio or job.video_ratio or "9:16"
     job.video_model = request.video_model or job.video_model or ""
     job.video_resolution = getattr(request, "video_resolution", "") or job.video_resolution or "720p"
@@ -355,34 +352,6 @@ def confirm_copy(
     if not isinstance(job.copy_result, dict) or not job.copy_result:
         raise HTTPException(status_code=409, detail="文案数据缺失，请先点击「生成文案」")
 
-    # Bug1 fix: 用户 confirm 时允许修改 video_model/video_resolution/video_ratio/duration
-    old_duration = int(getattr(job, "duration", 15) or 15)
-    old_resolution = getattr(job, "video_resolution", "720p") or "720p"
-    old_ratio = getattr(job, "video_ratio", "9:16") or "9:16"
-    old_model = getattr(job, "video_model", None) or "seedance-2.5"
-
-    if request.duration is not None:
-        job.duration = max(5, min(30, int(request.duration)))
-    if request.video_resolution is not None:
-        job.video_resolution = request.video_resolution
-    if request.video_ratio is not None:
-        job.video_ratio = request.video_ratio
-    if request.video_model is not None:
-        job.video_model = request.video_model
-    if request.voice_id is not None:
-        job.voice_id = request.voice_id
-    if request.voice_source is not None:
-        job.voice_source = request.voice_source
-    if getattr(request, "language", None) is not None:
-        job.language = request.language
-
-    param_changed = (
-        (request.duration is not None and int(request.duration) != old_duration)
-        or (request.video_resolution is not None and request.video_resolution != old_resolution)
-        or (request.video_ratio is not None and request.video_ratio != old_ratio)
-        or (request.video_model is not None and request.video_model != old_model)
-    )
-
     # 积分预扣（已扣过/重试任务跳过）
     from app.config import settings as _settings
 
@@ -390,51 +359,7 @@ def confirm_copy(
         already_paid = (float(getattr(job, "credits_prepaid", 0) or 0) > 0) or (
             float(getattr(job, "credits_cost", 0) or 0) > 0
         )
-        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:
+        if not already_paid:
             from packages.domain.points_rules import calculate_viral_video_credits, resolve_video_dimensions
             from packages.domain.points_service import PointsService
 

apps/api/app/schemas/viral_video.py

@@ -87,7 +87,6 @@ class CreateViralVideoRequest(BaseModel):
     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"
@@ -122,7 +121,6 @@ class AnalyzeImagesRequest(BaseModel):
     video_model: str = ""
     video_resolution: str = "720p"
     duration: int = Field(default=15, ge=5, le=30)
-    language: str = "zh-CN"
 
 
 class GenerateCopyRequest(BaseModel):
@@ -144,7 +142,6 @@ class GenerateCopyRequest(BaseModel):
     style_guide: dict | None = None
     voice_id: str = ""
     voice_source: str = ""
-    language: str = "zh-CN"
     video_ratio: str = "9:16"
     video_model: str = ""
     video_resolution: str = "720p"
@@ -170,13 +167,6 @@ class ConfirmCopyRequest(BaseModel):
     """v1.5+ 阶段3：用户确认/编辑口播后开始渲染（TTS+单次Seedance）。"""
 
     edited_copy: str = Field(default="", description="用户编辑后的口播文案；为空则用 AI 生成的 voiceover_script")
-    video_model: str | None = Field(default=None, description="用户选定的视频生成模型（confirm时可选）")
-    video_resolution: str | None = Field(default=None, description="用户选定的分辨率（confirm时可选）")
-    video_ratio: str | None = Field(default=None, description="用户选定的比例（confirm时可选）")
-    duration: int | None = Field(default=None, ge=5, le=30, description="用户选定的时长秒数（confirm时可选，5~30）")
-    voice_id: str | None = Field(default=None, description="用户选定的音色ID（confirm时可选）")
-    voice_source: str | None = Field(default=None, description="用户选定的音色来源（confirm时可选）")
-    language: str | None = Field(default=None, description="用户选定的语言（confirm时可选）")
 
 
 class ConfirmIntentRequest(BaseModel):
@@ -228,7 +218,6 @@ class ViralVideoJobResponse(BaseModel):
     # 音色/视频参数
     voice_id: str = ""
     voice_source: str = ""
-    language: str = "zh-CN"
     video_ratio: str = "9:16"
     video_model: str = ""
     intent_result: dict | None = None

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)
@@ -391,15 +206,10 @@ def lipsync_ditto_process_async(self, job_id: str, user_id: str) -> None:
         job_id: LipsyncJob ID
         user_id: 用户 ID
     """
-    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 +228,22 @@ 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）──
-        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)
-        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 +251,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 +283,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/src/api/admin/dittoEmotion.ts

@@ -1,76 +0,0 @@
-/**
- * 后台管理 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/pages/admin/DittoEmotionConfig.tsx

@@ -1,311 +0,0 @@
-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/router/appRoutes.tsx

@@ -121,11 +121,7 @@ const appChildren: RouteObject[] = [
     children: [
       {
         index: true,
-        element: <Navigate to="/app/admin/ditto-emotion" replace />,
-      },
-      {
-        path: "ditto-emotion",
-        lazy: lazyRoute(() => import("@/pages/admin/DittoEmotionConfig")),
+        lazy: lazyRoute(() => import("@/pages/admin/AdminComingSoon")),
       },
       {
         path: "users",

apps/worker/worker_app/tasks/viral_video.py

@@ -24,7 +24,6 @@ from __future__ import annotations
 import json
 import logging
 import os
-import re
 import tempfile
 import threading
 import time
@@ -484,14 +483,6 @@ _PERSONA_STYLE_GUIDE: dict[str, str] = {
     "店主": "热情实在，像当面招呼客人，突出靠谱和实在优惠",
     "专业顾问": "专业可信，讲清原理和效果，用事实打消顾虑",
     "年轻达人": "活泼有网感，节奏轻快，金句和梗自然不尬",
-    "老板型IP": "以老板第一人称出镜，真诚接地气，像招呼街坊邻居一样分享，突出创业初心和靠谱",
-    "知识博主": "条理清晰、数据说话，干货密度高，语气专业但不枯燥",
-    "生活美学": "画面感强，注重氛围和质感描述，语速偏慢，文字有诗意",
-    "健身教练": "energetic、鼓励式口吻，强调动作要领和效果变化",
-    "美妆达人": "细腻讲质地和妆效，像闺蜜安利，语气亲切有感染力",
-    "美食博主": "色香味描述丰富，口语化带馋感，节奏轻快",
-    "穿搭博主": "讲搭配逻辑和场景适配，时尚但不高冷，像朋友建议",
-    "育儿师": "科学育儿角度，温柔坚定，给具体可操作的建议",
 }
 
 
@@ -506,47 +497,6 @@ def _persona_style_hint(persona_id: str) -> str:
     return "【人设风格：未指定】亲切自然、像朋友分享好物"
 
 
-_VIRAL_STRUCTURE_GUIDE: dict[str, str] = {
-    "反差破局+亮明观点+还原现状": "开头3秒用反差/痛点钩子抓注意力，中段亮出核心卖点或观点，结尾还原真实到店/使用场景引导行动",
-    "痛点切入+方案展示+效果对比": "开头直击用户痛点场景，中间展示产品/服务解决方案，结尾用前后对比强化效果",
-    "故事引入+产品种草+行动引导": "用一个真实小故事/案例引入，自然过渡到产品种草，结尾明确引导用户下一步行动",
-    "场景展示+价值输出+信任背书": "开头展示使用场景让用户代入，中间输出核心价值主张，结尾用客户评价/数据等信任背书收尾",
-    "悬念开场+层层递进+高潮转化": "开头制造悬念引发好奇，内容层层推进保持张力，高潮处给出转化钩子",
-}
-
-
-def _viral_structure_hint(structure: str) -> str:
-    """根据 viral_structure 映射具体写作指导；未命中返回通用提示。"""
-    s = (structure or "").strip()
-    if s in _VIRAL_STRUCTURE_GUIDE:
-        return f"【爆款结构：{s}】{_VIRAL_STRUCTURE_GUIDE[s]}"
-    if s:
-        return f"【爆款结构：{s}】按该结构编排内容节奏和叙事逻辑"
-    return "【爆款结构：未指定】自由组织，保证开头有钩子、中段有卖点、结尾有行动引导"
-
-
-def _language_hint(language: str) -> str:
-    """根据 language 代码返回语言提示。"""
-    lang = (language or "zh-CN").strip().lower()
-    mapping = {
-        "zh-cn": "使用标准普通话，口语化表达",
-        "zh-tw": "使用台湾腔中文，语气温柔亲切",
-        "zh-hk": "使用粤语风格中文表达",
-        "en-us": "使用美式英语，自然口语化",
-        "en-gb": "使用英式英语",
-        "ja-jp": "使用日语，自然口语化",
-        "ko-kr": "使用韩语，亲切自然",
-    }
-    hint = mapping.get(lang, "")
-    if hint:
-        return f"【语言：{lang}】{hint}"
-    if lang.startswith("zh"):
-        return f"【语言：{lang}】使用中文，口语化表达，可带方言特色"
-    if lang.startswith("en"):
-        return f"【语言：{lang}】使用英语，自然口语化"
-    return f"【语言：{lang}】按该语言习惯组织口播内容"
-
-
 def _determine_theme(image_analysis: dict | None, marketing_purpose: str = "") -> str:
     """根据图片类型分布和营销目的推断默认主题。"""
     images = _images_of(image_analysis)
@@ -823,35 +773,25 @@ def _step_script_generation(job: ViralVideoJob, image_analysis: dict) -> dict:
             + "</reference_video_style>"
         )
 
-    persona_hint = _persona_style_hint(getattr(job, "persona_id", ""))
-    viral_structure_hint = _viral_structure_hint(getattr(job, "viral_structure", ""))
-    language_hint = _language_hint(getattr(job, "language", "zh-CN"))
-    industry = getattr(job, "industry", "") or "通用"
-
     user = render_user_prompt(
         template,
         marketing_purpose=marketing_purpose,
-        industry=industry,
         image_summary=images_summary,
         theme_hint=theme_hint,
-        duration=str(dur),
+        dur=str(dur),
         aspect_ratio=getattr(job, "video_ratio", None) or "9:16",
         tone=getattr(job, "tone", "") or "亲切自然",
-        target_audience=getattr(job, "target_customer", "") or "未指定",
-        persona_hint=persona_hint,
-        viral_structure_hint=viral_structure_hint,
-        language_hint=language_hint,
+        target_audience=getattr(job, "target_audience", "") or "未指定",
         extra_requirements=job.user_copy_text or "（未提供额外要求，由 AI 创作）",
         video_style_section=style_section,
     )
 
-    def _try_gen(client, temp: float, max_tok: int, label: str, tmo: int, user_text: str = None):
+    def _try_gen(client, temp: float, max_tok: int, label: str, tmo: int):
         if not client or not client.is_available:
             return None
-        _u = user_text if user_text is not None else user
         logger.info("[爆款视频] 分镜生成 model=%s label=%s timeout=%d", client.model, label, tmo)
         raw = client.chat_completion(
-            [{"role": "system", "content": system}, {"role": "user", "content": _u}],
+            [{"role": "system", "content": system}, {"role": "user", "content": user}],
             temperature=temp,
             max_tokens=max_tok,
             timeout=tmo,
@@ -869,103 +809,37 @@ def _step_script_generation(job: ViralVideoJob, image_analysis: dict) -> dict:
         shots_cnt = len(normalized.get("shots") or [])
         is_fallback = shots_cnt < 1 or len(voiceover) < 12
         logger.info(
-            "[爆款视频] 分镜结果 label=%s voiceover_len=%d shots_cnt=%d fallback=%s",
+            "[爆款视频] 分镜结果 label=%s voiceover_len=%d shots=%d fallback=%s",
             label,
             len(voiceover),
             shots_cnt,
             is_fallback,
         )
-        if is_fallback:
-            return None
-        # Bug2 fix: 口播字数 + 镜头数量 + 时间轴后校验
-        _dur = max(5, min(30, int(getattr(job, "duration", 15) or 15)))
-        _max_chars = _dur * 3  # 每秒最多3字
-        _voiceover_chars = len(voiceover.strip())
-        _min_chars = max(10, int(_dur * 2.2))
-        if _voiceover_chars > _max_chars:
-            logger.warning(
-                "[爆款视频] 口播超长 label=%s voiceover_chars=%d max=%d dur=%ds，将尝试压缩",
-                label,
-                _voiceover_chars,
-                _max_chars,
-                _dur,
-            )
-            return None  # 触发外层重试/压缩
-        if _voiceover_chars < _min_chars:
-            logger.warning(
-                "[爆款视频] 口播过短 label=%s voiceover_chars=%d min=%d dur=%ds，将尝试重生成",
-                label,
-                _voiceover_chars,
-                _min_chars,
-                _dur,
-            )
-            return None  # 触发外层重生成
-
-        # Bug2 增强: 镜头数量校验
-        _shots = normalized.get("shots") or []
-        _shot_count = len(_shots)
-        _expected_range = _get_expected_shot_count(_dur)
-        if _expected_range and (_shot_count < _expected_range[0] or _shot_count > _expected_range[1]):
-            logger.warning(
-                "[爆款视频] 镜头数量不符 label=%s shots=%d expected=%s dur=%ds",
-                label,
-                _shot_count,
-                _expected_range,
-                _dur,
-            )
-            return None  # 触发外层重试
-
-        # Bug2 增强: 时间轴累加校验
-        _time_valid = _validate_shot_timeline(_shots, _dur)
-        if not _time_valid:
-            logger.warning(
-                "[爆款视频] 时间轴不合法 label=%s dur=%ds shots=%s",
-                label,
-                _dur,
-                [(s.get("time_range")) for s in _shots[:5]],
-            )
-            return None  # 触发外层重试
-
-        return normalized
+        return None if is_fallback else normalized
 
     client_fast = ai_router.get_llm_client("storyboard", variant="primary")
     client_pro = ai_router.get_llm_client("storyboard", variant="lite")
     fast_tmo = int(os.environ.get("VIRAL_VIDEO_SCRIPT_FAST_TIMEOUT", "90"))
     pro_tmo = int(os.environ.get("VIRAL_VIDEO_SCRIPT_PRO_TIMEOUT", "60"))
     deadline = time.time() + 180
-    # Bug2 fix: 构建字数约束提示，注入到 user prompt
-    _dur = max(5, min(30, int(getattr(job, "duration", 15) or 15)))
-    _max_chars = _dur * 3
-    _min_chars = max(10, _dur * 2)
-    _char_hint = f"口播总字数严格控制在 {_min_chars}~{_max_chars} 字（{_dur}秒视频），超长会导致配音失败"
-    user = user + "\n\n" + _char_hint
-
     try:
         result = _try_gen(client_fast, 0.8, 2500, "fast-first", fast_tmo)
         if result is not None:
             return result
         if time.time() > deadline:
-            return _finalize_fallback_script(job)
+            return _fallback_script(job)
         result = _try_gen(client_fast, 0.6, 3200, "fast-retry", fast_tmo)
         if result is not None:
             return result
-        # Bug2: 压缩重试 — 用更严格约束要求 LLM 压缩口播
-        if time.time() <= deadline:
-            user_compressed = user + "\n\n【紧急】上一次生成口播超长，请将口播压缩到 {} 字以内，保留核心卖点。".format(
-                _max_chars
-            )
-            compressed_result = _try_gen(client_fast, 0.5, 2000, "compress-retry", fast_tmo, user_text=user_compressed)
-            if compressed_result is not None:
-                return compressed_result
         if client_pro and client_pro.is_available and client_pro.model != client_fast.model:
             if time.time() <= deadline:
                 result = _try_gen(client_pro, 0.7, 3500, "pro-fallback", pro_tmo)
                 if result is not None:
                     return result
-        return _finalize_fallback_script(job)
+        return _fallback_script(job)
     except Exception as e:
         logger.warning("[爆款视频] 分镜生成异常: %s，使用兜底脚本", e, exc_info=True)
-        return _finalize_fallback_script(job)
+        return _fallback_script(job)
 
 
 def _step_review(job: ViralVideoJob, copy_result: dict) -> dict:
@@ -1136,22 +1010,17 @@ def _step_tts(job: ViralVideoJob, voiceover_script: str):
         if not text:
             logger.warning("[爆款视频] voiceover_script 为空，跳过 TTS")
             return None
-        language = getattr(job, "language", "zh-CN") or "zh-CN"
         try:
             result = tts_service.synthesize(
                 text=text,
                 voice_id=voice_id,
                 format="mp3",
-                language=language,
             )
         except TypeError:
             try:
-                result = tts_service.synthesize(text=text, voice_id=voice_id, language=language)
+                result = tts_service.synthesize(text=text, voice_id=voice_id)
             except TypeError:
-                try:
-                    result = tts_service.synthesize(text=text, voice_id=voice_id)
-                except TypeError:
-                    result = tts_service.synthesize(text=text)
+                result = tts_service.synthesize(text=text)
         if result is None:
             return None
         p = _Path(result) if not isinstance(result, _Path) else result
@@ -1185,385 +1054,54 @@ def _upload_tts_to_oss(job: ViralVideoJob, tts_path) -> str | None:
         return None
 
 
-def _check_and_fix_tts_duration(tts_path, target_duration: int):
-    """Bug3 fix: TTS 合成后校验音频时长，超限则加速/截断。
-
-    - 音频时长 > max(target+2, 30) → 加速到目标时长
-    - 音频时长 > 30s（Seedance 硬限制）→ 必须加速/截断到 30s 以内
-    返回处理后的路径（可能覆盖原文件），失败返回原路径不阻塞。
-    """
-    if tts_path is None:
-        return None
-    try:
-        import subprocess
-        from pathlib import Path as _Path
-
-        local = _Path(tts_path) if not isinstance(tts_path, _Path) else tts_path
-        if not local.exists():
-            return tts_path
-
-        # 用 ffprobe 检查音频时长
-        probe_cmd = [
-            "ffprobe",
-            "-v",
-            "quiet",
-            "-show_entries",
-            "format=duration",
-            "-of",
-            "default=noprint_wrappers=1:nokey=1",
-            str(local),
-        ]
-        result = subprocess.run(probe_cmd, capture_output=True, text=True, timeout=15)
-        if result.returncode != 0:
-            logger.warning("[爆款视频] ffprobe 检查音频时长失败: %s", result.stderr[:200])
-            return tts_path
-
-        audio_dur = float(result.stdout.strip())
-        hard_limit = 30.0  # Seedance 硬限制
-        soft_limit = float(target_duration) + 2.0
-        effective_limit = min(soft_limit, hard_limit)
-
-        logger.info(
-            "[爆款视频] TTS 音频时长检查: audio=%.1fs target=%ds limit=%.1fs",
-            audio_dur,
-            target_duration,
-            effective_limit,
-        )
-
-        if audio_dur <= effective_limit:
-            return tts_path  # 时长合理
-
-        # 需要处理：优先用 ffmpeg 加速（atempo）保持内容完整
-        if audio_dur > hard_limit:
-            target_sec = 29.0  # 必须压缩到 30s 以内
-        else:
-            target_sec = float(target_duration)
-
-        speed_factor = audio_dur / target_sec
-        if speed_factor > 2.0:
-            # atempo 最大 2.0x，超过则先加速到 2x 再截断
-            logger.warning(
-                "[爆款视频] TTS 音频加速比 %.2f 超过 2x，改为加速+截断",
-                speed_factor,
-            )
-            accel_path = local.with_suffix(".accel.mp3")
-            subprocess.run(
-                [
-                    "ffmpeg",
-                    "-y",
-                    "-i",
-                    str(local),
-                    "-filter:a",
-                    "atempo=2.0",
-                    "-c:a",
-                    "libmp3lame",
-                    "-q:a",
-                    "2",
-                    str(accel_path),
-                ],
-                capture_output=True,
-                timeout=60,
-            )
-            if accel_path.exists() and accel_path.stat().st_size > 0:
-                accel_path.replace(local)
-                # 再截断到目标时长
-                trimmed = local.with_suffix(".trimmed.mp3")
-                subprocess.run(
-                    [
-                        "ffmpeg",
-                        "-y",
-                        "-i",
-                        str(local),
-                        "-t",
-                        str(target_sec),
-                        "-c:a",
-                        "libmp3lame",
-                        "-q:a",
-                        "2",
-                        str(trimmed),
-                    ],
-                    capture_output=True,
-                    timeout=30,
-                )
-                if trimmed.exists() and trimmed.stat().st_size > 0:
-                    trimmed.replace(local)
-                logger.info("[爆款视频] TTS 音频加速+截断完成: %.1fs → %.1fs", audio_dur, target_sec)
-        else:
-            # 用 atempo 加速
-            accelerated = local.with_suffix(".accel.mp3")
-            subprocess.run(
-                [
-                    "ffmpeg",
-                    "-y",
-                    "-i",
-                    str(local),
-                    "-filter:a",
-                    f"atempo={speed_factor:.4f}",
-                    "-c:a",
-                    "libmp3lame",
-                    "-q:a",
-                    "2",
-                    str(accelerated),
-                ],
-                capture_output=True,
-                timeout=60,
-            )
-            if accelerated.exists() and accelerated.stat().st_size > 0:
-                accelerated.replace(local)
-                logger.info(
-                    "[爆款视频] TTS 音频加速完成: %.1fs → %.1fs (speed=%.2fx)",
-                    audio_dur,
-                    target_sec,
-                    speed_factor,
-                )
-
-        return tts_path
-    except Exception as e:
-        logger.warning("[爆款视频] TTS 音频时长校验异常: %s", e, exc_info=True)
-        return tts_path  # 校验异常不阻塞
-
-
-def _get_expected_shot_count(duration: int) -> tuple[int, int] | None:
-    """根据视频时长返回期望的镜头数量范围 (min, max)。"""
-    if duration <= 5:
-        return (1, 2)
-    elif duration <= 10:
-        return (3, 3)
-    elif duration <= 15:
-        return (3, 4)
-    elif duration <= 20:
-        return (4, 5)
-    elif duration <= 30:
-        return (6, 8)
-    return None
-
-
-def _validate_shot_timeline(shots: list[dict], total_duration: int) -> bool:
-    """校验镜头时间轴是否合法：
-    - 每个 shot 的 time_range 必须能解析为 "X-Y秒"
-    - 第一个镜头必须从 0 开始
-    - 最后一个镜头必须结束于 total_duration
-    - 相邻镜头首尾相接（允许1秒误差）
-    """
-    if not shots:
-        return False
-
-    prev_end = 0
-    for i, shot in enumerate(shots):
-        tr = str(shot.get("time_range", ""))
-        # 解析 "X-Y秒" 格式
-        match = re.match(r"(\d+)-(\d+)秒?", tr)
-        if not match:
-            return False
-        start = int(match.group(1))
-        end = int(match.group(2))
-
-        # 第一个镜头必须从 0 开始（允许1秒误差）
-        if i == 0 and start > 1:
-            return False
-
-        # 时间必须递增
-        if end <= start:
-            return False
-
-        # 与前一镜头衔接（允许1秒误差）
-        if abs(start - prev_end) > 1:
-            return False
-
-        prev_end = end
-
-    # 最后一个镜头必须结束于 total_duration（允许1秒误差）
-    if abs(prev_end - total_duration) > 1:
-        return False
-
-    return True
-
-
-def _parse_shot_seconds(time_range) -> tuple[int, int] | None:
-    """从 time_range 解析 (start, end)，无法解析返回 None。"""
-    m = re.match(r"(\d+)-(\d+)秒?", str(time_range or ""))
-    if not m:
-        return None
-    start, end = int(m.group(1)), int(m.group(2))
-    if end <= start:
-        return None
-    return start, end
-
-
-def _redistribute_timeline(shots: list[dict], total_duration: int) -> list[dict]:
-    """服务端强制按比例重新分配时间轴：
-    保留各镜头内容，按 2 秒最小粒度分配，余数补到最后一个镜头。
-    """
-    n = len(shots)
-    if n == 0:
-        return shots
-    # 每镜头基础秒数
-    base = max(2, total_duration // n)
-    boundaries: list[int] = [0]
-    for i in range(n):
-        if i == n - 1:
-            boundaries.append(total_duration)
-        else:
-            boundaries.append(min(total_duration - (n - 1 - i) * 2, boundaries[-1] + base))
-    for i, s in enumerate(shots):
-        s["time_range"] = f"{boundaries[i]}-{boundaries[i + 1]}秒"
-    logger.info("[爆款视频] 服务端强制重分配时间轴: %s total=%ds", boundaries, total_duration)
-    return shots
-
-
-def _truncate_voiceover(text: str, max_chars: int) -> str:
-    """口播超长兜底：按句号/问号/感叹号切句，按字数保留前面的完整句子。"""
-    text = text.strip()
-    if len(text) <= max_chars:
-        return text
-    parts = re.split(r"(?<=[。！？!?\.])", text)
-    out = ""
-    for p in parts:
-        if not p:
-            continue
-        if len(out) + len(p) > max_chars:
-            break
-        out += p
-    if not out:
-        out = text[:max_chars].rstrip("，、 ")
-    return out
-
-
-def _shot_visual(s: dict) -> str:
-    """合并镜头画面与动作描述。"""
-    visual = str(s.get("scene_and_dialogue", "") or s.get("visual", "")).strip()
-    act = str(s.get("action_details", "") or "").strip()
-    if act and act not in visual:
-        visual = f"{visual}，{act}" if visual else act
-    return visual
-
-
-def _finalize_fallback_script(job: ViralVideoJob) -> dict:
-    """所有 LLM 重试失败后的最终兜底：
-    - 时间轴不合法 → 服务端强制按比例重分配
-    - 口播超长 → 按句子截断；口播过短不处理（危害较小）
-    """
-    fb = _fallback_script(job)
-    dur = max(5, min(30, int(getattr(job, "duration", 15) or 15)))
-    shots = fb.get("shots") or []
-    if not _validate_shot_timeline(shots, dur):
-        fb["shots"] = _redistribute_timeline(shots, dur)
-    voice = fb.get("voiceover_script", "") or ""
-    max_chars = dur * 3
-    if len(voice) > max_chars:
-        voice = _truncate_voiceover(voice, max_chars)
-        fb["voiceover_script"] = voice
-        fb["final_copy"] = voice
-        fb["suggested_copy"] = voice
-        fb["copy_display_markdown"] = voice
-    logger.info(
-        "[爆款视频] 最终兜底脚本完成 dur=%ds shots=%d voice_chars=%d", dur, len(fb.get("shots") or []), len(voice)
-    )
-    return fb
-
-
 def _assemble_seedance_prompt(copy_result: dict, job: ViralVideoJob) -> str:
-    """把编导脚本拼成符合官方推荐格式的 prompt（按 provider 分发）。
-
-    - doubao (Seedance): [X-Y秒] 单行时间戳 + 镜头级 @图片N 绑定
-    - dashscope (Wan 3.0): 第N个镜头[X-Y秒] 单行格式
-    """
-    from packages.domain.points_rules import get_viral_video_model_config
-
+    """把编导脚本拼成 Seedance 长 prompt。"""
     if not isinstance(copy_result, dict) or not copy_result:
         return "产品展示短视频，清晰明亮，自然讲解"
-
     ov = copy_result.get("overview") or {}
-    theme = ov.get("theme", "") or ""
-    total_duration = int(ov.get("total_duration") or getattr(job, "duration", 15) or 15)
+    theme = ov.get("theme", "")
+    total_duration = ov.get("total_duration") or getattr(job, "duration", 15)
     aspect_ratio = ov.get("aspect_ratio") or getattr(job, "video_ratio", "9:16")
-    scene_lighting = str(copy_result.get("scene_and_lighting", "") or "")
-    shots = [s for s in (copy_result.get("shots") or []) if isinstance(s, dict)]
+    scene_lighting = copy_result.get("scene_and_lighting", "")
+    shots = copy_result.get("shots") or []
     hc = copy_result.get("hard_constraints") or _DEFAULT_HARD_CONSTRAINTS
-    np_list = copy_result.get("negative_prompts") or _DEFAULT_NEGATIVE_PROMPTS
-    images = list(job.images or [])
+    np = copy_result.get("negative_prompts") or _DEFAULT_NEGATIVE_PROMPTS
 
-    model = getattr(job, "video_model", "") or None
-    provider = get_viral_video_model_config(model).get("provider", "doubao")
-
-    def _ref(i: int):
-        """该镜头绑定的图片序号（越界/-1 回退首图）。"""
-        idx = shots[i].get("reference_image_index") if i < len(shots) else None
-        if isinstance(idx, int) and 0 <= idx < len(images):
-            return idx
-        return 0 if images else None
-
-    if provider == "dashscope":
-        # ========== Wan 3.0 格式 ==========
-        head = f"{theme}，{scene_lighting or '画面清晰有质感'}，总时长{total_duration}秒。"
-        body: list[str] = [head, ""]
-        for i, s in enumerate(shots):
-            tr = str(s.get("time_range", ""))
-            pr = _parse_shot_seconds(tr)
-            label = f"{pr[0]}-{pr[1]}秒" if pr else tr
-            cam = str(s.get("shot_type_angle_movement", "") or "").strip()
-            voice = str(s.get("voiceover", "") or "").strip()
-            pieces = [f"第{i + 1}个镜头[{label}]"]
-            if cam:
-                pieces.append(f"运镜：{cam}")
-            pieces.append(f"画面：{_shot_visual(s)}")
-            if voice:
-                pieces.append(f'配音："{voice}"')
-            # Wan 通过 input.media 数组顺序隐式引用图1/图2，不写@图片
-            body.append(" ".join(pieces))
-        style_parts = [str(x) for x in hc if x] + [str(x) for x in np_list if x]
-        if style_parts:
-            body.append("")
-            body.append("风格说明：" + "；".join(style_parts[:6]))
-        return "\n".join(body)
-
-    # ========== Seedance 格式 ==========
     lines: list[str] = []
     lines.append("【视频总览】")
-    lines.append(f"- 主题：{theme}")
-    lines.append(f"- 总时长：{total_duration}秒（单次生成，时长严格匹配）")
+    lines.append(f"- 整体主题：{theme}")
+    lines.append(f"- 总时长：{total_duration}秒（单次生成，时长必须严格匹配）")
     lines.append(f"- 画幅：{aspect_ratio}")
-    lines.append(f"- 整体风格：{scene_lighting or '专业、清晰、明亮有质感'}")
     lines.append("")
-
-    # 【参考素材】按镜头绑定
-    if images:
-        lines.append("【参考素材】")
-        for i in range(len(shots)):
-            ri = _ref(i)
-            if ri is not None:
-                lines.append(f"镜头{i + 1}参考@图片{ri + 1}")
-        lines.append("")
-
-    # 单行时间戳分镜
-    lines.append("【分镜脚本】")
+    lines.append("【场景与光线】")
+    lines.append(scene_lighting)
+    lines.append("")
+    lines.append("【逐镜头时间轴】（按时间顺序连贯拍摄，镜头之间自然衔接）")
     for i, s in enumerate(shots):
-        tr = str(s.get("time_range", ""))
-        pr = _parse_shot_seconds(tr)
-        label = f"{pr[0]}-{pr[1]}秒" if pr else tr
-        cam = str(s.get("shot_type_angle_movement", "") or "").strip()
-        voice = str(s.get("voiceover", "") or "").strip()
-        trans = str(s.get("transition", "") or "").strip()
-        pieces = [f"[{label}]"]
-        if cam:
-            pieces.append(f"景别/运镜：{cam}")
-        pieces.append(f"画面：{_shot_visual(s)}")
-        if voice:
-            pieces.append(f'口播："{voice}"')
-        ri = _ref(i)
-        if ri is not None:
-            pieces.append(f"参考@图片{ri + 1}")
-        if trans:
-            pieces.append(f"转场：{trans}")
-        lines.append(" ".join(pieces))
-
+        if not isinstance(s, dict):
+            continue
+        tr = s.get("time_range", "")
+        cam = s.get("shot_type_angle_movement", "")
+        sd = s.get("scene_and_dialogue", "")
+        act = s.get("action_details", "")
+        ab = s.get("audio_bgm", "")
+        t = s.get("transition", "")
+        ref = s.get("reference_image_index")
+        lines.append(f"- 镜头{i + 1}（{tr}）：")
+        lines.append(f"  景别/运镜：{cam}")
+        lines.append(f"  画面与对白：{sd}")
+        lines.append(f"  动作细节：{act}")
+        lines.append(f"  音效/BGM：{ab}")
+        lines.append(f"  转场：{t}")
+        if ref is not None and isinstance(ref, int):
+            lines.append(f"  参考图片：第{ref + 1}张产品图")
     lines.append("")
     lines.append("【硬性约束】")
     for c in hc:
         lines.append(f"- {c}")
     lines.append("")
-    lines.append("【负面提示词】")
-    lines.append("，".join([str(x) for x in np_list if x]))
+    lines.append("【负面提示词】（必须避免）")
+    lines.append("，".join([str(x) for x in np if x]))
     return "\n".join(lines)
 
 
@@ -2321,29 +1859,11 @@ def _run_render_pipeline(job_id: str, session, repo, job) -> dict:
 
     voiceover = copy_result.get("voiceover_script", "") or job.effective_copy_text
 
-    # provider 判断：Wan 3.0(dashscope) 在无自定义音色时跳过 TTS，用模型原生音频
-    from packages.domain.points_rules import get_viral_video_model_config
-
-    _vv_model = getattr(job, "video_model", "") or None
-    _vv_provider = get_viral_video_model_config(_vv_model).get("provider", "doubao")
-    _has_custom_voice = bool((getattr(job, "voice_id", "") or "").strip())
-    _skip_tts = _vv_provider == "dashscope" and not _has_custom_voice
-
-    tts_url = None
-    if _skip_tts:
-        logger.info("[爆款视频][阶段3] Wan原生音频模式：跳过TTS，由模型生成配音/BGM/音效 job_id=%s", job_id)
-        _set_stage(job, repo, session, ViralVideoStage.TTS, "使用模型原生音频...")
-        _emit_progress(job_id, ViralVideoStage.TTS, 78.0, "使用模型原生音频", {"has_tts": False, "native_audio": True})
-    else:
-        # Step 5: TTS 整段合成
-        _set_stage(job, repo, session, ViralVideoStage.TTS, "正在合成AI配音...")
-        tts_path = _step_tts(job, voiceover)
-        # Bug3 fix: TTS 音频时长校验与修正
-        if tts_path is not None:
-            _dur_limit = max(5, min(30, int(getattr(job, "duration", 15) or 15)))
-            tts_path = _check_and_fix_tts_duration(tts_path, _dur_limit)
-        tts_url = _upload_tts_to_oss(job, tts_path)
-        _emit_progress(job_id, ViralVideoStage.TTS, 78.0, "配音完成", {"has_tts": tts_url is not None})
+    # Step 5: TTS 整段合成
+    _set_stage(job, repo, session, ViralVideoStage.TTS, "正在合成AI配音...")
+    tts_path = _step_tts(job, voiceover)
+    tts_url = _upload_tts_to_oss(job, tts_path)
+    _emit_progress(job_id, ViralVideoStage.TTS, 78.0, "配音完成", {"has_tts": tts_url is not None})
 
     # Step 6: 单次 Seedance（失败自动退款）
     _set_stage(job, repo, session, ViralVideoStage.RENDERING, "正在生成视频（约1-3分钟）...")
@@ -2423,18 +1943,7 @@ def run_viral_video_render(self: Task, job_id: str) -> dict:
                         pass
         except Exception:
             logger.exception("[爆款视频][阶段3] 兜底退款异常")
-        # Bug4 fix: 使用 job 当前实际阶段而非硬编码 RENDERING
-        _err_stage = ViralVideoStage.RENDERING
-        _err_job = None
-        if session is not None:
-            try:
-                _repo_tmp = SQLAlchemyViralVideoJobRepository(session)
-                _err_job = _repo_tmp.get(job_id)
-                if _err_job is not None and getattr(_err_job, "current_stage", None):
-                    _err_stage = _err_job.current_stage
-            except Exception:
-                pass
-        _mark_failed_and_notify(job_id, session, None, _err_job, str(e), _err_stage)
+        _mark_failed_and_notify(job_id, session, None, None, str(e), ViralVideoStage.RENDERING)
         return {"ok": False, "job_id": job_id, "error": str(e)}
     finally:
         if _hb_stop is not None:

deploy/configs/.env.staging

@@ -311,10 +311,3 @@ GPU_ENCODE_CRF=23
 GPU_ENCODE_FALLBACK_CPU=true
 GPU_ENCODE_MEZZANINE_TRANSPORT=oss
 GPU_ENCODE_OSS_TMP_PREFIX=tmp/gpu-mezzanine/
-
-# ==================== Ditto 蚂蚁数字人口型 ====================
-# 注意：这些值必须写死在模板里（不是 CI Secret），否则每次 CI 重新渲染 .env 都会被丢弃，
-# 导致 staging 发版后 Ditto 口型服务静默降级到 GPU/MediaKit（P0 防复发）。
-USE_DITTO_LIPSYNC=true
-DITTO_API_BASE_URL=http://100.76.80.23:8000
-DITTO_DEFAULT_VIDEO_URL=https://xiaoxia-autocut.oss-cn-hangzhou.aliyuncs.com/uploads/default_avatar.mp4

packages/adapters/sqlalchemy_impl/models.py

@@ -961,7 +961,6 @@ class ViralVideoJobModel(Base):
     # v1.5 音频/视频参数
     voice_id = Column(String(200), nullable=False, default="")
     voice_source = Column(String(20), nullable=False, default="")
-    language = Column(String(20), nullable=False, default="zh-CN")
     video_ratio = Column(String(10), nullable=False, default="9:16")
     video_model = Column(String(100), nullable=False, default="")
     # 结果与状态
@@ -1020,20 +1019,3 @@ class ViralVideoPromptTemplateModel(Base):
     is_active = Column(Boolean, nullable=False, default=True)
     created_at = Column(DateTime(timezone=True), nullable=False, default=lambda: datetime.now(UTC))
     updated_at = Column(DateTime(timezone=True), nullable=False, default=lambda: datetime.now(UTC))
-
-
-class SystemSettingModel(Base):
-    """系统配置表 ORM 模型（#2246：后台可配置项，表已手工存在于 staging）."""
-
-    __tablename__ = "system_settings"
-
-    id = Column(String(36), primary_key=True)
-    setting_key = Column(String(100), nullable=False, unique=True)
-    setting_value = Column(Text, nullable=True)
-    setting_type = Column(String(20), nullable=False)
-    description = Column(String(255), nullable=False, default="", server_default="")
-    is_public = Column(Boolean, nullable=False, default=False, server_default="false")
-    updated_by = Column(String(36), nullable=True)
-    category = Column(String(50), nullable=False, default="general", server_default="general")
-    created_at = Column(DateTime(timezone=True), nullable=False, default=lambda: datetime.now(UTC))
-    updated_at = Column(DateTime(timezone=True), nullable=False, default=lambda: datetime.now(UTC))

packages/adapters/sqlalchemy_impl/system_setting_repository.py

@@ -1,65 +0,0 @@
-"""system_settings 表 SQLAlchemy Repository — #2246."""
-
-from __future__ import annotations
-
-from sqlalchemy.orm import Session
-
-from packages.adapters.sqlalchemy_impl.models import SystemSettingModel
-from packages.domain.system_setting import SystemSetting
-
-
-class SQLAlchemySystemSettingRepository:
-    def __init__(self, session: Session):
-        self.session = session
-
-    def get_by_key(self, setting_key: str) -> SystemSetting | None:
-        model = self.session.query(SystemSettingModel).filter(SystemSettingModel.setting_key == setting_key).first()
-        if model is None:
-            return None
-        return self._to_domain(model)
-
-    def list_all(self, category: str | None = None) -> list[SystemSetting]:
-        query = self.session.query(SystemSettingModel)
-        if category is not None:
-            query = query.filter(SystemSettingModel.category == category)
-        return [self._to_domain(m) for m in query.all()]
-
-    def upsert(self, setting: SystemSetting) -> SystemSetting:
-        model = (
-            self.session.query(SystemSettingModel).filter(SystemSettingModel.setting_key == setting.setting_key).first()
-        )
-        if model is None:
-            model = SystemSettingModel(id=setting.id)
-            self.session.add(model)
-        model.setting_key = setting.setting_key
-        model.setting_value = setting.setting_value
-        model.setting_type = setting.setting_type
-        model.description = setting.description
-        model.is_public = setting.is_public
-        model.category = setting.category
-        model.updated_by = setting.updated_by
-        self.session.commit()
-        return setting
-
-    def delete_by_key(self, setting_key: str) -> bool:
-        model = self.session.query(SystemSettingModel).filter(SystemSettingModel.setting_key == setting_key).first()
-        if model is None:
-            return False
-        self.session.delete(model)
-        self.session.commit()
-        return True
-
-    @staticmethod
-    def _to_domain(model: SystemSettingModel) -> SystemSetting:
-        return SystemSetting(
-            id=model.id,
-            setting_key=model.setting_key,
-            setting_value=model.setting_value,
-            setting_type=model.setting_type,
-            description=model.description or "",
-            is_public=bool(model.is_public),
-            category=model.category or "general",
-            updated_by=model.updated_by,
-            created_at=model.created_at,
-            updated_at=model.updated_at,
-        )

packages/adapters/sqlalchemy_impl/viral_video_repository.py

@@ -49,7 +49,6 @@ def _to_domain(model: ViralVideoJobModel) -> ViralVideoJob:
         style_template_id=getattr(model, "style_template_id", "") or "",
         voice_id=getattr(model, "voice_id", "") or "",
         voice_source=getattr(model, "voice_source", "") or "",
-        language=getattr(model, "language", "zh-CN") or "zh-CN",
         video_ratio=getattr(model, "video_ratio", "9:16") or "9:16",
         video_model=getattr(model, "video_model", "") or "",
         status=ViralVideoStatus(model.status) if model.status else ViralVideoStatus.PENDING,
@@ -103,7 +102,6 @@ class SQLAlchemyViralVideoJobRepository:
             style_template_id=job.style_template_id,
             voice_id=job.voice_id,
             voice_source=job.voice_source,
-            language=getattr(job, "language", "zh-CN") or "zh-CN",
             video_ratio=job.video_ratio,
             video_model=job.video_model,
             status=job.status,
@@ -171,7 +169,6 @@ class SQLAlchemyViralVideoJobRepository:
         model.style_template_id = job.style_template_id
         model.voice_id = job.voice_id or ""
         model.voice_source = job.voice_source or ""
-        model.language = getattr(job, "language", "zh-CN") or "zh-CN"
         model.video_ratio = job.video_ratio or "9:16"
         model.video_model = job.video_model or ""
         model.updated_at = datetime.now(timezone.utc)

packages/application/auth/password_hasher.py

@@ -3,24 +3,10 @@
 使用 bcrypt 安全存储密码
 """
 
-import hashlib
 from typing import Optional
 
 import bcrypt
 
-# bcrypt 只对前 72 字节有效，且 bcrypt>=4.1 会对超长输入直接抛 ValueError。
-# 超长密码先做一次 SHA-256（定长 hex），再交给 bcrypt，
-# 既绕过长度限制又保持对超长不同密码的区分度。
-_BCRYPT_MAX_BYTES = 72
-
-
-def _prepare_password_bytes(password: str) -> bytes:
-    raw = password.encode("utf-8")
-    if len(raw) > _BCRYPT_MAX_BYTES:
-        return hashlib.sha256(raw).hexdigest().encode("utf-8")
-    return raw
-
-
 from packages.domain.auth.password_hasher import PasswordHasherPort, PasswordValidatorPort
 
 
@@ -56,8 +42,8 @@ class PasswordHasher(PasswordHasherPort):
         if not password:
             raise ValueError("Password cannot be empty")
 
-        # bcrypt 需要 bytes（超长密码先 SHA-256 以兼容 72 字节限制）
-        password_bytes = _prepare_password_bytes(password)
+        # bcrypt 需要 bytes
+        password_bytes = password.encode("utf-8")
 
         # 生成 salt 并哈希
         salt = bcrypt.gensalt(rounds=self.rounds)
@@ -81,7 +67,7 @@ class PasswordHasher(PasswordHasherPort):
             return False
 
         try:
-            password_bytes = _prepare_password_bytes(password)
+            password_bytes = password.encode("utf-8")
             hashed_bytes = hashed_password.encode("utf-8")
 
             return bcrypt.checkpw(password_bytes, hashed_bytes)

packages/application/ditto_emotion_service.py

@@ -1,332 +0,0 @@
-"""Ditto LLM 情绪分析服务 — #2076 后续：根据文案生成 emo_timeline.
-
-职责：
-1. 正则按 。！？； 初步分句
-2. 调 DoubaoClient.chat_completion 分析每句表情（emo: 0-7, intensity: 0-1）
-3. 结果 LRU 缓存（文案 hash → 情绪列表）
-4. LLM 失败/超时/格式错 → 返回空列表（降级中性表情，不阻塞生成）
-5. TTS 完成后按字数比例或 sentence_timings 对齐成秒级 timeline
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-import logging
-import re
-from functools import lru_cache
-from pathlib import Path
-from typing import Any, Optional
-
-logger = logging.getLogger(__name__)
-
-# ── 表情常量 ─────────────────────────────────────────────────────
-EMO_ANGER = 0
-EMO_DISGUST = 1
-EMO_FEAR = 2
-EMO_HAPPY = 3
-EMO_NEUTRAL = 4
-EMO_SAD = 5
-EMO_SURPRISE = 6
-EMO_CONTEMPT = 7
-ALLOWED_EMOS = {EMO_HAPPY, EMO_NEUTRAL, EMO_SAD, EMO_SURPRISE}  # 营销场景白名单
-
-# ── 分句正则 ─────────────────────────────────────────────────────
-_SENT_SPLIT_RE = re.compile(r"(?<=[。！？；!?;])\s*")
-
-# ── 默认 prompt 模板文件路径 ──────────────────────────────────────
-_DEFAULT_PROMPT_PATH = Path(__file__).parent / "prompts" / "ditto_emotion.txt"
-
-
-def _load_default_prompt() -> str:
-    try:
-        return _DEFAULT_PROMPT_PATH.read_text(encoding="utf-8").strip()
-    except Exception:
-        # 文件不存在时用极简兜底
-        return (
-            "分析文案每句话表情，输出JSON数组："
-            '[{"text":"句子","emo":4,"intensity":0.2}]，emo:3开心4中性5伤心6惊讶，'
-            "禁止0/1/2/7。\n【文案】\n{文案}"
-        )
-
-
-# ── 数据结构 ─────────────────────────────────────────────────────
-class EmotionSegment:
-    """单句情绪结果（LLM 输出的原始结构）."""
-
-    __slots__ = ("text", "emo", "intensity")
-
-    def __init__(self, text: str, emo: int, intensity: float):
-        self.text = text
-        self.emo = emo
-        self.intensity = intensity
-
-    def to_dict(self) -> dict[str, Any]:
-        return {"text": self.text, "emo": self.emo, "intensity": self.intensity}
-
-
-class EmotionTimelineEntry:
-    """对齐到音频时间轴后的情绪片段（传给 Ditto）."""
-
-    __slots__ = ("start", "end", "emo", "intensity")
-
-    def __init__(self, start: float, end: float, emo: int, intensity: float):
-        self.start = round(start, 2)
-        self.end = round(end, 2)
-        self.emo = emo
-        self.intensity = round(intensity, 2)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "start": self.start,
-            "end": self.end,
-            "emo": self.emo,
-            "intensity": self.intensity,
-        }
-
-
-# ── 分句 ─────────────────────────────────────────────────────────
-def split_sentences(text: str) -> list[str]:
-    """按中文句末标点切分，过滤空串."""
-    if not text:
-        return []
-    parts = _SENT_SPLIT_RE.split(text.strip())
-    return [p.strip() for p in parts if p and p.strip()]
-
-
-# ── 解析 LLM 返回的 JSON ─────────────────────────────────────────
-def _parse_emotion_json(raw: str) -> list[EmotionSegment]:
-    """解析 LLM 返回，容错处理：
-    - 去掉 markdown 代码块包裹
-    - 只取第一个 JSON 数组
-    - 逐行校验 emo/intensity 合法性，过滤无效项
-    """
-    if not raw:
-        return []
-    text = raw.strip()
-    # 去掉 ```json ... ``` 包裹
-    if text.startswith("```"):
-        text = re.sub(r"^```(?:json)?\s*", "", text)
-        text = re.sub(r"\s*```$", "", text)
-    # 找第一个 [ 到最后一个 ]
-    lb = text.find("[")
-    rb = text.rfind("]")
-    if lb == -1 or rb == -1 or rb <= lb:
-        return []
-    try:
-        data = json.loads(text[lb : rb + 1])
-    except (json.JSONDecodeError, ValueError):
-        return []
-    if not isinstance(data, list):
-        return []
-
-    results: list[EmotionSegment] = []
-    for item in data:
-        if not isinstance(item, dict):
-            continue
-        try:
-            emo = int(item.get("emo", EMO_NEUTRAL))
-            intensity = float(item.get("intensity", 0.2))
-        except (TypeError, ValueError):
-            continue
-        if emo not in ALLOWED_EMOS:
-            emo = EMO_NEUTRAL
-        intensity = max(0.05, min(1.0, intensity))
-        sent_text = str(item.get("text", "")).strip()
-        if not sent_text:
-            continue
-        results.append(EmotionSegment(text=sent_text, emo=emo, intensity=intensity))
-    return results
-
-
-# ── 时间对齐（按字数比例）────────────────────────────────────────
-def align_timeline_by_length(
-    segments: list[EmotionSegment],
-    audio_duration: float,
-) -> list[EmotionTimelineEntry]:
-    """按各句字数占总字数比例分配 audio_duration 时长."""
-    if not segments or audio_duration <= 0:
-        return []
-    total_chars = sum(len(s.text) for s in segments)
-    if total_chars <= 0:
-        return []
-    entries: list[EmotionTimelineEntry] = []
-    pos = 0.0
-    for i, seg in enumerate(segments):
-        if i == len(segments) - 1:
-            end = audio_duration  # 最后一段到结尾，避免浮点误差
-        else:
-            end = pos + (len(seg.text) / total_chars) * audio_duration
-        if end > pos:
-            entries.append(
-                EmotionTimelineEntry(
-                    start=pos,
-                    end=end,
-                    emo=seg.emo,
-                    intensity=seg.intensity,
-                )
-            )
-        pos = end
-    return entries
-
-
-def align_timeline_by_timings(
-    segments: list[EmotionSegment],
-    sentence_timings: list[dict[str, Any]],
-    audio_duration: float,
-) -> list[EmotionTimelineEntry]:
-    """使用 TTS sentence_timings 精确对齐（优先方案）.
-
-    sentence_timings 格式：[{"start":0.0,"end":1.2,"text":"句子"}, ...]
-    按句序匹配 segments 和 timings，长度不一致时回退到按字数比例。
-    """
-    if not sentence_timings or len(sentence_timings) != len(segments):
-        return align_timeline_by_length(segments, audio_duration)
-    entries: list[EmotionTimelineEntry] = []
-    for seg, timing in zip(segments, sentence_timings, strict=False):
-        try:
-            start = float(timing.get("start", 0))
-            end = float(timing.get("end", 0))
-        except (TypeError, ValueError):
-            return align_timeline_by_length(segments, audio_duration)
-        if end <= start:
-            continue
-        entries.append(
-            EmotionTimelineEntry(
-                start=start,
-                end=end,
-                emo=seg.emo,
-                intensity=seg.intensity,
-            )
-        )
-    return entries
-
-
-# ── LLM 情绪分析服务 ─────────────────────────────────────────────
-class DittoEmotionService:
-    """Ditto 情绪分析服务（带 LRU 缓存）."""
-
-    def __init__(self, settings=None):
-        from packages.config import get_api_settings
-
-        self.settings = settings or get_api_settings()
-        self._client = None
-
-    def _cfg(self, key: str) -> Any:
-        """优先读后台 system_config，未配置则回退到 settings（env 默认）."""
-        try:
-            from packages.application.system_config_service import get_config
-
-            return get_config(key, getattr(self.settings, key, None))
-        except Exception:
-            return getattr(self.settings, key, None)
-
-    @property
-    def enabled(self) -> bool:
-        return bool(self._cfg("ditto_emotion_enabled"))
-
-    def _get_prompt_template(self) -> str:
-        """优先用配置（环境变量），否则读文件."""
-        cfg_prompt = self._cfg("ditto_emotion_prompt") or ""
-        if cfg_prompt.strip():
-            return cfg_prompt.strip()
-        return _load_default_prompt()
-
-    def _cache_key(self, text: str) -> str:
-        return hashlib.md5(text.strip().encode("utf-8")).hexdigest()
-
-    def _get_llm_client(self):
-        if self._client is None:
-            from packages.shared.ai_client import get_doubao_client
-
-            self._client = get_doubao_client()
-        return self._client
-
-    def _call_llm(self, text: str) -> list[EmotionSegment]:
-        """调 LLM 分析情绪，失败返回空列表."""
-        template = self._get_prompt_template()
-        prompt = template.replace("{文案}", text)
-        messages = [{"role": "user", "content": prompt}]
-        model = self._cfg("ditto_emotion_model") or None
-        temperature = self._cfg("ditto_emotion_temperature")
-        timeout = getattr(self.settings, "ditto_emotion_timeout", 10)
-        max_tokens = getattr(self.settings, "ditto_emotion_max_tokens", 1024)
-        try:
-            client = self._get_llm_client()
-            result = client.chat_completion(
-                messages=messages,
-                model=model,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                timeout=timeout,
-            )
-        except Exception as exc:
-            logger.warning("[ditto_emotion] LLM 调用异常: %s", exc)
-            return []
-        if not result:
-            return []
-        segments = _parse_emotion_json(result)
-        if not segments:
-            logger.warning("[ditto_emotion] LLM 返回解析失败: %s", result[:200])
-        return segments
-
-    def analyze(self, text: str) -> list[EmotionSegment]:
-        """分析文案情绪（带缓存），失败返回空列表."""
-        if not self.enabled or not text or not text.strip():
-            return []
-        key = self._cache_key(text)
-        return _cached_analyze(self, key, text)
-
-    def build_timeline(
-        self,
-        text: str,
-        audio_duration: float,
-        sentence_timings: Optional[list[dict[str, Any]]] = None,
-    ) -> str:
-        """完整流程：分句→LLM分析→时间对齐→序列化为JSON字符串.
-
-        返回: JSON 字符串（可直接传 Ditto emo_timeline 参数）；空字符串表示降级中性。
-        """
-        segments = self.analyze(text)
-        if not segments:
-            return ""
-        if sentence_timings:
-            entries = align_timeline_by_timings(segments, sentence_timings, audio_duration)
-        else:
-            entries = align_timeline_by_length(segments, audio_duration)
-        if not entries:
-            return ""
-        return json.dumps([e.to_dict() for e in entries], ensure_ascii=False)
-
-
-# ── 模块级 LRU 缓存实例 ─────────────────────────────────────────
-# 每个 service 实例共享缓存（按 cache_key 区分）
-@lru_cache(maxsize=512)
-def _cached_analyze(service: DittoEmotionService, cache_key: str, text: str) -> list[EmotionSegment]:
-    """LRU 缓存包装：cache_key 由文案 hash 生成，maxsize 从配置读."""
-    # 注意：service 参数仅用于传递调用，缓存由 cache_key 驱动
-    segments = service._call_llm(text)
-    # 如果 LLM 返回空（比如分句数量不匹配），尝试直接对预分句结果分析
-    if not segments:
-        pre_splits = split_sentences(text)
-        if len(pre_splits) > 1:
-            # 用预分句结果兜底：全中性低强度
-            segments = [EmotionSegment(text=s, emo=EMO_NEUTRAL, intensity=0.1) for s in pre_splits]
-    return segments
-
-
-_singleton: Optional[DittoEmotionService] = None
-
-
-def get_ditto_emotion_service() -> DittoEmotionService:
-    global _singleton
-    if _singleton is None:
-        _singleton = DittoEmotionService()
-    return _singleton
-
-
-def reset_ditto_emotion_service() -> None:
-    """#2246：后台配置变更后重置单例并清空 LLM 结果 LRU 缓存."""
-    global _singleton
-    _singleton = None
-    _cached_analyze.cache_clear()

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 音视频混流
 """
 
@@ -69,20 +67,10 @@ class DittoClient:
         self.default_video_url = default_video_url or s.ditto_default_video_url or ""
         self.max_retries = int(max_retries if max_retries is not None else s.ditto_max_retries)
         self.timeout = int(timeout if timeout is not None else s.ditto_request_timeout)
-        try:
-            from packages.application.system_config_service import get_config
-
-            self.blend_frames = int(get_config("ditto_blend_frames", s.ditto_blend_frames))
-        except Exception:
-            self.blend_frames = int(s.ditto_blend_frames)
 
     @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:
@@ -111,8 +99,7 @@ class DittoClient:
         video_url: Optional[str] = None,
         emo_global: int = 4,
         use_script_emo: bool = True,
-        blend_frames: Optional[int] = None,
-        emo_timeline: str = "",
+        blend_frames: int = 6,
     ) -> DittoResult:
         """调用 Ditto /generate 接口，返回 MP4 字节流结果.
 
@@ -128,17 +115,14 @@ class DittoClient:
         if not script:
             script = " "
 
-        _blend = blend_frames if blend_frames is not None else self.blend_frames
         payload = {
             "video_url": driver_url,
             "audio_url": audio_url,
             "script": script,
             "emo_global": emo_global,
             "use_script_emo": use_script_emo,
-            "blend_frames": _blend,
+            "blend_frames": blend_frames,
         }
-        if emo_timeline:
-            payload["emo_timeline"] = emo_timeline
         url = f"{self.base_url}/generate"
 
         last_exc: Optional[Exception] = None
@@ -258,17 +242,9 @@ class DittoClient:
         audio_url: str,
         script: str,
         video_url: Optional[str] = None,
-        emo_timeline: str = "",
-        blend_frames: Optional[int] = None,
     ) -> DittoResult:
         """调用 generate 并把 MP4 转存到自家 OSS，返回带 video_url 的结果."""
-        result = self.generate(
-            audio_url=audio_url,
-            script=script,
-            video_url=video_url,
-            emo_timeline=emo_timeline,
-            blend_frames=blend_frames,
-        )
+        result = self.generate(audio_url=audio_url, script=script, video_url=video_url)
         try:
             from packages.shared.storage import get_shared_storage_service
 
@@ -300,9 +276,3 @@ def get_ditto_client() -> DittoClient:
     if _ditto_client_singleton is None:
         _ditto_client_singleton = DittoClient()
     return _ditto_client_singleton
-
-
-def reset_ditto_client() -> None:
-    """#2246：后台配置变更后重置 DittoClient 单例."""
-    global _ditto_client_singleton
-    _ditto_client_singleton = None

packages/application/prompts/ditto_emotion.txt

@@ -1,27 +0,0 @@
-你是一个数字人视频表情导演。给定一段口播文案，分析每句话应该用什么表情和强度，让数字人说话时表情自然有变化，不僵硬。
-【表情编号】
-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/system_config_service.py

@@ -1,189 +0,0 @@
-"""系统配置应用服务 — #2246.
-
-- get_config(key, default) / set_config(...) / list_configs(category)
-- 首次访问时从 DB 加载并进程内缓存；set_config 后失效缓存
-- set_config 成功后重置 Ditto 情绪服务与 Ditto 客户端单例（含 LRU 缓存），
-  保证后台改动立即生效；worker 不直接 HTTP 读配置，统一通过本模块。
-"""
-
-from __future__ import annotations
-
-import logging
-import threading
-from typing import Any
-
-from packages.adapters.sqlalchemy_impl import session as db_session
-from packages.adapters.sqlalchemy_impl.system_setting_repository import (
-    SQLAlchemySystemSettingRepository,
-)
-from packages.domain.system_setting import (
-    SystemSetting,
-    infer_setting_type,
-    serialize_setting_value,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class SystemConfigService:
-    """进程内缓存的系统配置服务."""
-
-    def __init__(self, session_factory=None):
-        self._session_factory = session_factory
-        self._cache: dict[str, Any] | None = None
-        self._lock = threading.Lock()
-
-    # ── 会话 ─────────────────────────────────────────────────────
-    def _get_session_factory(self):
-        # 必须运行时读取模块属性：模块导入时 SessionLocal 还是 None，
-        # initialize_database() 之后才被赋值，import 时绑定会拿到旧值。
-        factory = self._session_factory or db_session.SessionLocal
-        if factory is None:
-            raise RuntimeError("数据库会话工厂未初始化")
-        return factory
-
-    # ── 缓存 ─────────────────────────────────────────────────────
-    def _load_cache(self) -> dict[str, Any]:
-        with self._lock:
-            if self._cache is not None:
-                return self._cache
-            cache: dict[str, Any] = {}
-            factory = self._get_session_factory()
-            session = factory()
-            try:
-                repo = SQLAlchemySystemSettingRepository(session)
-                for setting in repo.list_all():
-                    try:
-                        cache[setting.setting_key] = setting.get_typed_value()
-                    except Exception as exc:  # 损坏配置不阻塞启动
-                        logger.warning(
-                            "[system_config] 跳过损坏配置 %s: %s",
-                            setting.setting_key,
-                            exc,
-                        )
-            finally:
-                session.close()
-            self._cache = cache
-            return cache
-
-    def reload(self) -> dict[str, Any]:
-        """强制重新从 DB 加载配置，返回新缓存."""
-        with self._lock:
-            self._cache = None
-        return self._load_cache()
-
-    def invalidate(self) -> None:
-        with self._lock:
-            self._cache = None
-
-    # ── 读 ───────────────────────────────────────────────────────
-    def get_config(self, key: str, default: Any = None) -> Any:
-        cache = self._load_cache()
-        return cache.get(key, default)
-
-    def list_configs(self, category: str | None = None) -> list[SystemSetting]:
-        factory = self._get_session_factory()
-        session = factory()
-        try:
-            return SQLAlchemySystemSettingRepository(session).list_all(category)
-        finally:
-            session.close()
-
-    # ── 写 ───────────────────────────────────────────────────────
-    def set_config(
-        self,
-        key: str,
-        value: Any,
-        setting_type: str | None = None,
-        updated_by: str | None = None,
-        *,
-        description: str | None = None,
-        category: str = "general",
-        is_public: bool = False,
-    ) -> Any:
-        st = setting_type or infer_setting_type(value)
-        serialized = serialize_setting_value(value, st)
-
-        factory = self._get_session_factory()
-        session = factory()
-        try:
-            repo = SQLAlchemySystemSettingRepository(session)
-            existing = repo.get_by_key(key)
-            if existing is not None:
-                existing.setting_value = serialized
-                existing.setting_type = st
-                if updated_by is not None:
-                    existing.updated_by = updated_by
-                if description is not None:
-                    existing.description = description
-                setting = existing
-            else:
-                setting = SystemSetting(
-                    setting_key=key,
-                    setting_value=serialized,
-                    setting_type=st,
-                    description=description or "",
-                    is_public=is_public,
-                    category=category,
-                    updated_by=updated_by,
-                )
-            repo.upsert(setting)
-        finally:
-            session.close()
-
-        self.invalidate()
-        self._reset_ditto_singletons(key)
-        return value
-
-    def delete_config(self, key: str) -> bool:
-        factory = self._get_session_factory()
-        session = factory()
-        try:
-            deleted = SQLAlchemySystemSettingRepository(session).delete_by_key(key)
-        finally:
-            session.close()
-        if deleted:
-            self.invalidate()
-            self._reset_ditto_singletons(key)
-        return deleted
-
-    # ── Ditto 联动 ───────────────────────────────────────────────
-    @staticmethod
-    def _reset_ditto_singletons(key: str) -> None:
-        try:
-            from packages.application import ditto_emotion_service as emo_mod
-            from packages.application import ditto_service as ditto_mod
-
-            emo_mod.reset_ditto_emotion_service()
-            ditto_mod.reset_ditto_client()
-            logger.info("[system_config] %s 更新，已重置 Ditto 单例", key)
-        except Exception as exc:  # 联动失败不影响配置落库
-            logger.warning("[system_config] 重置 Ditto 单例失败: %s", exc)
-
-
-_service_singleton: SystemConfigService | None = None
-
-
-def get_system_config_service() -> SystemConfigService:
-    global _service_singleton
-    if _service_singleton is None:
-        _service_singleton = SystemConfigService()
-    return _service_singleton
-
-
-def get_config(key: str, default: Any = None) -> Any:
-    """便捷读取：优先 DB 配置，未配置时返回 default（调用方传 env 值兜底）."""
-    try:
-        return get_system_config_service().get_config(key, default)
-    except Exception as exc:
-        logger.warning("[system_config] 读取 %s 失败，使用默认值: %s", key, exc)
-        return default
-
-
-def set_config(
-    key: str,
-    value: Any,
-    setting_type: str | None = None,
-    updated_by: str | None = None,
-) -> Any:
-    return get_system_config_service().set_config(key, value, setting_type=setting_type, updated_by=updated_by)

packages/application/viral_video/prompts.py

@@ -124,34 +124,10 @@ _STORYBOARD_SYSTEM = (
 3. copy_display_markdown：直接展示给最终用户的文案，用 Markdown 写成自然、流畅、有感染力的成片成片文案，可用小标题与短句组织；不要做字段列表，不要出现“镜头一/台词：”这类制作说明。
 4. 内容必须来自图片观察与用户给出的信息，不编造卖点、不夸大、不使用绝对化用语和虚假承诺。
 5. reference_image_index 填本镜参考图片序号（从 0 开始），没有合适参考图填 -1。
-6. 分镜数量与时长匹配总时长，节奏紧凑。
-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>指定的参数写文案和分镜，不能忽略任何一项用户参数"""
+6. 分镜数量与时长匹配总时长，节奏紧凑。"""
 )
 
 _STORYBOARD_USER = """<marketing_purpose>{marketing_purpose}</marketing_purpose>
-<industry>{industry}</industry>
 <image_analysis>
 {image_summary}
 </image_analysis>
@@ -161,9 +137,6 @@ _STORYBOARD_USER = """<marketing_purpose>{marketing_purpose}</marketing_purpose>
 <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}

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,43 +202,6 @@ class SharedSettings(BaseSettings):
         default=120,
         validation_alias=AliasChoices("DITTO_REQUEST_TIMEOUT", "ditto_request_timeout"),
     )
-    # Ditto 句间过渡帧数（平滑表情/口型切换）
-    ditto_blend_frames: int = Field(
-        default=12,
-        validation_alias=AliasChoices("DITTO_BLEND_FRAMES", "ditto_blend_frames"),
-    )
-
-    # ── Ditto LLM 情绪分析（emo_timeline）──────────────────────────────
-    # 总开关；关闭或 LLM 失败时走 GPU 端关键词匹配兜底
-    ditto_emotion_enabled: bool = Field(
-        default=False,
-        validation_alias=AliasChoices("DITTO_EMOTION_ENABLED", "ditto_emotion_enabled"),
-    )
-    ditto_emotion_model: str = Field(
-        default="doubao-seed-2-1-lite-250915",
-        validation_alias=AliasChoices("DITTO_EMOTION_MODEL", "ditto_emotion_model"),
-    )
-    ditto_emotion_temperature: float = Field(
-        default=0.1,
-        validation_alias=AliasChoices("DITTO_EMOTION_TEMPERATURE", "ditto_emotion_temperature"),
-    )
-    ditto_emotion_timeout: int = Field(
-        default=10,
-        validation_alias=AliasChoices("DITTO_EMOTION_TIMEOUT", "ditto_emotion_timeout"),
-    )
-    ditto_emotion_max_tokens: int = Field(
-        default=1024,
-        validation_alias=AliasChoices("DITTO_EMOTION_MAX_TOKENS", "ditto_emotion_max_tokens"),
-    )
-    ditto_emotion_cache_size: int = Field(
-        default=500,
-        validation_alias=AliasChoices("DITTO_EMOTION_CACHE_SIZE", "ditto_emotion_cache_size"),
-    )
-    # 提示词模板：必须包含 {文案} 占位符；后台可通过环境变量覆盖
-    ditto_emotion_prompt: str = Field(
-        default="",
-        validation_alias=AliasChoices("DITTO_EMOTION_PROMPT", "ditto_emotion_prompt"),
-    )
 
     # ── P4000 NVENC 硬件编码 ────────────────────────────────────────────
     # GPU 编码总开关；关闭或 endpoint 为空时始终走本机 CPU libx264

packages/domain/asset_atom_clip.py

@@ -8,12 +8,7 @@ from __future__ import annotations
 
 import uuid
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
-
-try:
-    from datetime import UTC
-except ImportError:
-    UTC = timezone.utc
+from datetime import UTC, datetime
 
 
 @dataclass

packages/domain/system_setting.py

@@ -1,134 +0,0 @@
-"""系统配置领域实体 — #2246.
-
-承载 setting_type（bool/int/float/string/json）及 setting_value 的
-序列化/反序列化规则；与 DB、框架无关。
-"""
-
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass, field
-from datetime import UTC, datetime
-from typing import Any
-from uuid import uuid4
-
-SETTING_TYPE_BOOL = "bool"
-SETTING_TYPE_INT = "int"
-SETTING_TYPE_FLOAT = "float"
-SETTING_TYPE_STRING = "string"
-SETTING_TYPE_JSON = "json"
-
-VALID_SETTING_TYPES = {
-    SETTING_TYPE_BOOL,
-    SETTING_TYPE_INT,
-    SETTING_TYPE_FLOAT,
-    SETTING_TYPE_STRING,
-    SETTING_TYPE_JSON,
-}
-
-
-class SystemSettingError(ValueError):
-    """系统配置类型或序列化错误."""
-
-
-def infer_setting_type(value: Any) -> str:
-    """根据 Python 值推断 setting_type（bool 必须先于 int 判断）."""
-    if isinstance(value, bool):
-        return SETTING_TYPE_BOOL
-    if isinstance(value, int):
-        return SETTING_TYPE_INT
-    if isinstance(value, float):
-        return SETTING_TYPE_FLOAT
-    if isinstance(value, str):
-        return SETTING_TYPE_STRING
-    return SETTING_TYPE_JSON
-
-
-def serialize_setting_value(value: Any, setting_type: str) -> str:
-    """把 Python 值按 setting_type 序列化为可入库的字符串."""
-    if setting_type == SETTING_TYPE_BOOL:
-        if not isinstance(value, bool):
-            raise SystemSettingError(f"bool 配置值必须是布尔类型，收到 {value!r}")
-        return "true" if value else "false"
-    if setting_type == SETTING_TYPE_INT:
-        if isinstance(value, bool) or not isinstance(value, int):
-            raise SystemSettingError(f"int 配置值必须是整数，收到 {value!r}")
-        return str(value)
-    if setting_type == SETTING_TYPE_FLOAT:
-        if isinstance(value, bool):
-            raise SystemSettingError(f"float 配置值不能是布尔类型，收到 {value!r}")
-        try:
-            return repr(float(value))
-        except (TypeError, ValueError) as exc:
-            raise SystemSettingError(f"float 配置值非法：{value!r}") from exc
-    if setting_type == SETTING_TYPE_STRING:
-        if not isinstance(value, str):
-            raise SystemSettingError(f"string 配置值必须是字符串，收到 {value!r}")
-        return value
-    if setting_type == SETTING_TYPE_JSON:
-        try:
-            return json.dumps(value, ensure_ascii=False)
-        except (TypeError, ValueError) as exc:
-            raise SystemSettingError(f"json 配置值无法序列化：{value!r}") from exc
-    raise SystemSettingError(f"未知 setting_type: {setting_type}")
-
-
-def deserialize_setting_value(raw: str | None, setting_type: str) -> Any:
-    """把入库字符串按 setting_type 反序列化为 Python 值."""
-    if raw is None:
-        return None
-    if setting_type == SETTING_TYPE_BOOL:
-        return str(raw).strip().lower() in {"1", "true", "yes", "on"}
-    if setting_type == SETTING_TYPE_INT:
-        try:
-            return int(str(raw).strip())
-        except ValueError as exc:
-            raise SystemSettingError(f"int 配置值损坏：{raw!r}") from exc
-    if setting_type == SETTING_TYPE_FLOAT:
-        try:
-            return float(str(raw).strip())
-        except ValueError as exc:
-            raise SystemSettingError(f"float 配置值损坏：{raw!r}") from exc
-    if setting_type == SETTING_TYPE_STRING:
-        return raw
-    if setting_type == SETTING_TYPE_JSON:
-        try:
-            return json.loads(raw)
-        except (TypeError, ValueError) as exc:
-            raise SystemSettingError(f"json 配置值损坏：{raw!r}") from exc
-    raise SystemSettingError(f"未知 setting_type: {setting_type}")
-
-
-@dataclass(slots=True)
-class SystemSetting:
-    """系统配置领域实体."""
-
-    setting_key: str
-    setting_value: str | None = None
-    setting_type: str = SETTING_TYPE_STRING
-    description: str = ""
-    is_public: bool = False
-    category: str = "general"
-    updated_by: str | None = None
-    id: str = field(default_factory=lambda: uuid4().hex)
-    created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
-    updated_at: datetime = field(default_factory=lambda: datetime.now(UTC))
-
-    def get_typed_value(self) -> Any:
-        return deserialize_setting_value(self.setting_value, self.setting_type)
-
-    @classmethod
-    def from_value(
-        cls,
-        setting_key: str,
-        value: Any,
-        setting_type: str | None = None,
-        **kwargs: Any,
-    ) -> "SystemSetting":
-        st = setting_type or infer_setting_type(value)
-        return cls(
-            setting_key=setting_key,
-            setting_value=serialize_setting_value(value, st),
-            setting_type=st,
-            **kwargs,
-        )

packages/domain/viral_video.py

@@ -107,7 +107,6 @@ class ViralVideoJob:
     # v1.5.1 音频/视频参数
     voice_id: str = ""
     voice_source: str = ""
-    language: str = "zh-CN"
     video_ratio: str = "9:16"
     video_model: str = ""
     # v1.4+ 产物

packages/shared/ai_client.py

@@ -636,10 +636,6 @@ class DoubaoClient:
                     resolution=resolution,
                     output_dir=output_dir,
                     model=video_model,
-                    generate_audio=bool(generate_audio),
-                    reference_images=reference_images,
-                    reference_audios=reference_audios,
-                    reference_videos=reference_videos,
                 )
                 if not result and hasattr(ds, "last_video_error") and ds.last_video_error:
                     self.last_video_error = dict(ds.last_video_error)

packages/shared/dashscope_client.py

@@ -115,20 +115,10 @@ class DashScopeClient:
         watermark: bool = False,
         output_dir: str | None = None,
         model: str = "wan3.0-video",
-        generate_audio: bool = True,
-        reference_images: list[str] | None = None,
-        reference_audios: list[str] | None = None,
-        reference_videos: list[str] | None = None,
     ) -> dict | None:
-        """调用 DashScope Wan 3.0 异步视频合成接口，轮询完成后下载到本地。
+        """调用 DashScope 异步视频合成接口，轮询完成后下载到本地。
 
-        官方协议（input.media 数组 + parameters.audio）：
-        - 仅 1 张图且无其它参考 -> type=first_frame（首帧模式，严格从该帧起）。
-        - 有参考音频 / 多张图 -> 图片全部走 type=reference_image（全能参考模式，
-          可与 reference_audio 共存）；prompt 用"图1/图2/音频1"按 media 顺序引用。
-        - parameters.audio 控制输出是否含音轨；参考音频通过 media 传入。
-
-        返回 {"video_path": str, "usage": dict | None}；失败返回 None，错误写入 self.last_video_error。
+        返回 {"video_path": str, "usage": dict | None}；失败返回 None，错误详情写入 self.last_video_error。
         """
         self.last_video_error = {}
         if not self.is_available:
@@ -140,7 +130,7 @@ class DashScopeClient:
             return None
 
         # DashScope 分辨率参数：720P / 1080P / 480P（大写 P）
-        res_upper = (resolution or "720p").upper()
+        res_upper = (resolution or "720p").upper().replace("P", "P")
         if res_upper == "480P":
             ds_res = "480P"
         elif res_upper == "1080P":
@@ -148,35 +138,16 @@ class DashScopeClient:
         else:
             ds_res = "720P"
 
-        # ── 构造官方 media 数组 ────────────────────────────────────────
-        ref_imgs = [u for u in (reference_images or [])[:10] if u]
-        ref_auds = [u for u in (reference_audios or [])[:5] if u]
-        ref_vids = [u for u in (reference_videos or [])[:5] if u]
-
-        media: list[dict[str, Any]] = []
-        all_imgs = ([image_url] if image_url else []) + [u for u in ref_imgs if u != image_url]
-        use_first_frame = bool(image_url) and len(all_imgs) == 1 and not (ref_auds or ref_vids)
-        if use_first_frame:
-            media.append({"type": "first_frame", "url": image_url})
-        else:
-            for u in all_imgs:
-                media.append({"type": "reference_image", "url": u})
-            for u in ref_vids:
-                media.append({"type": "reference_video", "url": u})
-            for u in ref_auds:
-                media.append({"type": "reference_audio", "url": u})
-
-        # ── input + parameters ─────────────────────────────────────────
+        # 构造 input+parameters
         input_obj: dict[str, Any] = {"prompt": prompt.strip()}
-        if media:
-            input_obj["media"] = media
-
+        if image_url:
+            input_obj["img_url"] = image_url
         params: dict[str, Any] = {
             "resolution": ds_res,
-            "duration": int(duration),
+            "duration": str(float(duration)),
             "watermark": bool(watermark),
-            "audio": bool(generate_audio),
         }
+        # 比例透传：Wan 支持 "9:16" / "16:9" / "1:1" 等
         if ratio and ratio != "adaptive":
             params["aspect_ratio"] = ratio
 
@@ -192,15 +163,14 @@ class DashScopeClient:
         }
         create_url = f"{self.base_url}/services/aigc/video-generation/video-synthesis"
         logger.info(
-            "[dashscope] 创建任务: model=%s dur=%ds ratio=%s res=%s media=%d audio=%s",
+            "[dashscope] 创建任务: model=%s dur=%ds ratio=%s res=%s img=%s",
             model,
             duration,
             ratio,
             ds_res,
-            len(media),
-            generate_audio,
+            bool(image_url),
         )
-        logger.info("[dashscope] media types: %s", [m["type"] for m in media])
+        logger.info("[dashscope] 创建任务 payload: model=%s params=%s", model, params)
 
         # 创建任务
         task_id: str | None = None
@@ -226,14 +196,27 @@ class DashScopeClient:
                 if tid:
                     task_id = tid
                     break
+                # 部分情况下 code != 错误
                 code = data.get("code")
-                if code:
-                    logger.error("[dashscope] 创建任务返回 code=%s body=%s", code, body_text)
-                    err_code, user_msg = _classify_dashscope_error(sc, body_text)
+                if code and code != "":
+                    err_code, user_msg = _classify_dashscope_error(400, body_text, str(code))
                     self._set_error(err_code, user_msg, sc, body_text, model=model)
                     return None
+                else:
+                    self._set_error("unknown", "Wan 3.0 响应格式异常，未返回任务ID", sc, str(data)[:500], model=model)
+                    return None
+            except _HTTP_NETWORK_ERRORS as ne:
+                last_sc = 0
+                last_body = f"network error: {ne}"
+                logger.warning(
+                    "[dashscope] 网络异常 %s，重试 %d/%d", type(ne).__name__, attempt + 1, self.max_retries + 1
+                )
+                if attempt < self.max_retries:
+                    time.sleep(0.5 * (2**attempt))
+                    continue
+                self._set_error("network_error", "Wan 3.0 服务连接失败（网络超时），请稍后重试。", 0, str(ne))
+                return None
             except Exception as _e:
-                logger.warning("[dashscope] 创建任务异常(attempt=%d): %s", attempt, _e)
                 if attempt < self.max_retries:
                     time.sleep(0.5 * (2**attempt))
                     continue
@@ -275,6 +258,7 @@ class DashScopeClient:
                     video_url = out.get("video_url") or ""
                     usage = d.get("usage")
                     if not video_url:
+                        # 结果在 results 数组
                         results = out.get("results") or []
                         if results and isinstance(results, list):
                             video_url = results[0].get("url") or results[0].get("video_url")
@@ -300,6 +284,7 @@ class DashScopeClient:
                     logger.warning("[dashscope] 任务 %s 被取消", task_id)
                     self._set_error("unknown", "Wan 3.0 任务被取消。", 200, "task cancelled", task_id=task_id)
                     return None
+                # PENDING / RUNNING / SUSPENDED → 继续轮询
                 if poll_count % 5 == 0:
                     logger.info("[dashscope] 轮询中 task=%s status=%s polls=%d", task_id, task_status, poll_count)
             except Exception as e:

packages/shared/storage.py

@@ -334,7 +334,7 @@ class SharedStorageService(StoragePort):
 
         storage_key = self.normalize_storage_key(storage_key_or_url)
         try:
-            signed = sign_bucket.sign_url("GET", storage_key, expires_seconds, slash_safe=True)
+            signed = sign_bucket.sign_url("GET", storage_key, expires_seconds)
             logger.info(
                 "signed URL generated for key=%s prefix=%s",
                 storage_key[:80],

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,11 +4,6 @@
 
 set -e
 
-SCRIPT_DIR="$(dirname "${BASH_SOURCE[0]}")"
-# shellcheck source=ci_env.sh
-source "${SCRIPT_DIR}/ci_env.sh"
-
-
 echo "=== Installing mypy ==="
 python3 -m pip install -q mypy
 mypy --version

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

tests/unit/test_ai_router.py

@@ -1,210 +1,209 @@
-"""AI Router 单元测试 — routing/cache/fallback/client construction.
-
-本文件只做*用例级* mock：通过 autouse fixture 在每个用例内 patch
-``packages.shared.config.get_shared_settings`` / ``packages.shared.ai_router.get_shared_settings``
-并在退出时自动恢复，绝不在模块顶层替换 ``sys.modules``，因此不会污染同进程的
-其他测试模块（如 test_ai_client.py）。
-
-在 Python 3.12 且依赖齐全的 CI 环境中，直接 import 真实模块即可；Redis / DB
-会话通过 patch 隔离。
-"""
+"""AI Router 单元测试 — 23 cases covering routing/cache/fallback/client construction."""
 
 from __future__ import annotations
 
+import sys
 import unittest
+from dataclasses import dataclass
+from typing import Optional
 from unittest.mock import MagicMock, patch
 
-import pytest
+# ── Pre-mock heavy import chain to avoid pulling in full app ──
+_mock_config = MagicMock()
+_mock_settings = MagicMock()
+_mock_settings.doubao_model = "doubao-seed-2-1-pro-260915"
+_mock_settings.doubao_fast_model = "doubao-seed-2-1-pro-260915"
+_mock_settings.doubao_base_url = "https://ark.cn-beijing.volces.com/api/v3"
+_mock_settings.doubao_api_key = "test-key"
+_mock_settings.doubao_timeout = 45
+_mock_settings.doubao_max_retries = 1
+_mock_settings.doubao_image_model = "doubao-seedream-5-0-flash-260915"
+_mock_settings.doubao_image_timeout = 60
+_mock_settings.doubao_video_model = "doubao-seedance-2-5-260628"
+_mock_settings.doubao_video_timeout = 600
+_mock_settings.dashscope_api_key = "ds-key"
+_mock_settings.cosyvoice_api_key = "cv-key"
+_mock_settings.cosyvoice_base_url = "https://dashscope.aliyuncs.com/api/v1"
+_mock_settings.cosyvoice_model = "cosyvoice-v3-flash"
+_mock_settings.redis_url = "redis://localhost:6379/0"
+_mock_settings.celery_broker_url = "redis://localhost:6379/0"
+_mock_config.get_shared_settings.return_value = _mock_settings
 
-from packages.shared import ai_config_version as _config_version_mod
-from packages.shared import ai_router as ai_router_mod
+# Prevent the full packages.shared from loading
+for mod_name in list(sys.modules.keys()):
+    if "packages.shared" in mod_name and "ai_router" not in mod_name and "ai_config_version" not in mod_name:
+        pass  # don't remove, just prevent new imports
 
-# ── 统一的假配置（等价于旧文件里的 _mock_settings）──────────────────────────
+# Direct import of our modules (bypassing __init__.py)
+import importlib.util
+import os
 
 
-def _make_mock_settings() -> MagicMock:
-    s = MagicMock()
-    s.doubao_model = "doubao-seed-2-1-pro-260915"
-    s.doubao_fast_model = "doubao-seed-2-1-pro-260915"
-    s.doubao_base_url = "https://ark.cn-beijing.volces.com/api/v3"
-    s.doubao_api_key = "test-key"
-    s.doubao_timeout = 45
-    s.doubao_max_retries = 1
-    s.doubao_image_model = "doubao-seedream-5-0-flash-260915"
-    s.doubao_image_timeout = 60
-    s.doubao_vision_model = "doubao-seed-1-6-vision-250615"
-    s.doubao_video_model = "doubao-seedance-2-5-260628"
-    s.doubao_video_timeout = 600
-    s.dashscope_api_key = "ds-key"
-    s.dashscope_base_url = "https://dashscope.aliyuncs.com/api/v1"
-    s.dashscope_model = "qwen-vl-max"
-    s.cosyvoice_api_key = "cv-key"
-    s.cosyvoice_base_url = "https://dashscope.aliyuncs.com/api/v1"
-    s.cosyvoice_model = "cosyvoice-v3-flash"
-    s.redis_url = "redis://localhost:6379/0"
-    s.celery_broker_url = "redis://localhost:6379/0"
-    return s
+def _load_module_from_file(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[name] = mod
+    spec.loader.exec_module(mod)
+    return mod
 
 
-@pytest.fixture(autouse=True)
-def _mock_settings_fixture():
-    """每个用例内 patch 配置来源，退出即恢复，不污染 sys.modules。"""
-    settings = _make_mock_settings()
-    with (
-        patch("packages.shared.config.get_shared_settings", return_value=settings),
-        patch.object(ai_router_mod, "get_shared_settings", return_value=settings),
-    ):
-        yield settings
+# Load ai_config_version
+_ai_config_version = _load_module_from_file(
+    "packages.shared.ai_config_version",
+    os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "packages", "shared", "ai_config_version.py"),
+)
+# Patch get_shared_settings in the loaded module
+_ai_config_version.get_shared_settings = lambda: _mock_settings
 
+# Load ai_router - needs packages.shared.config to be available
+sys.modules["packages.shared.config"] = MagicMock()
+sys.modules["packages.shared.config"].get_shared_settings = lambda: _mock_settings
 
-def _capability_row() -> MagicMock:
-    row = MagicMock()
-    row.capability_key = "intent_parsing"
-    row.capability_name = "文案意图解析"
-    row.timeout_seconds = 45
-    row.max_retries = 1
-    row.max_tokens = None
-    row.temperature = None
-    row.concurrency = 2
-    row.extra_params = {}
-    row.is_enabled = True
-    row.pm_id = "model-1"
-    row.pm_name = "豆包"
-    row.pm_provider = "volcengine"
-    row.pm_model_key = "doubao-seed-1-6-250615"
-    row.pm_api_key = "test-key"
-    row.pm_api_base = "https://ark.test.com"
-    row.pm_api_version = None
-    row.pm_status = "active"
-    row.lm_id = None
-    row.fm_id = None
-    return row
+# Mock packages.shared.ai_client to avoid triggering packages.shared.__init__ chain
+# (which fails on Python 3.10 due to datetime.UTC import in packages.domain)
+_mock_ai_client = MagicMock()
 
+class _FakeDoubaoClient:
+    """Fake DoubaoClient for testing - mimics the real interface."""
+    def __init__(self, api_key="", base_url="", model="", timeout=0, max_retries=0,
+                 max_tokens=None, temperature=None, extra_params=None, provider="volcengine"):
+        self.api_key = api_key
+        self.base_url = base_url
+        self.model = model
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.max_tokens = max_tokens
+        self.temperature = temperature
+        self.extra_params = extra_params or {}
+        self.provider = provider
+        self.vision_model = model
 
-def _model_config(**overrides):
-    kwargs = dict(
-        id="m1",
-        name="test",
-        provider="volcengine",
-        model_key="test-model",
-        api_key="key",
-        api_base="https://test.com",
-        api_version=None,
-        status="active",
-    )
-    kwargs.update(overrides)
-    return ai_router_mod.ModelConfig(**kwargs)
+    @property
+    def is_available(self):
+        return bool(self.api_key)
 
+    def chat_completion(self, messages, **kwargs):
+        return None
 
-def _capability_config(**overrides):
-    kwargs = dict(
-        capability_key="test",
-        capability_name="test",
-        primary_model=None,
-        lite_model=None,
-        fallback_model=None,
-        timeout_seconds=30,
-        max_retries=1,
-        max_tokens=None,
-        temperature=None,
-        concurrency=2,
-        extra_params={},
-        is_enabled=True,
-    )
-    kwargs.update(overrides)
-    return ai_router_mod.CapabilityConfig(**kwargs)
+    def vision_completion(self, messages, **kwargs):
+        return None
 
+_mock_ai_client.DoubaoClient = _FakeDoubaoClient
+sys.modules["packages.shared.ai_client"] = _mock_ai_client
 
-# ── Redis 版本号机制 ────────────────────────────────────────────────────────
+_ai_router = _load_module_from_file(
+    "packages.shared.ai_router",
+    os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "packages", "shared", "ai_router.py"),
+)
 
 
 class TestAIConfigVersion(unittest.TestCase):
     """Redis 版本号机制测试"""
 
-    @patch.object(_config_version_mod, "_get_redis_client")
+    @patch.object(_ai_config_version, "_get_redis_client")
     def test_bump_version_success(self, mock_redis_fn):
         mock_r = MagicMock()
         mock_r.set.return_value = True
         mock_redis_fn.return_value = mock_r
-        ver = _config_version_mod.bump_version()
+        ver = _ai_config_version.bump_version()
         self.assertTrue(ver)
         self.assertTrue(ver.isdigit())
         mock_r.set.assert_called_once()
 
-    @patch.object(_config_version_mod, "_get_redis_client")
+    @patch.object(_ai_config_version, "_get_redis_client")
     def test_bump_version_redis_unavailable(self, mock_redis_fn):
         mock_redis_fn.return_value = None
-        ver = _config_version_mod.bump_version()
+        ver = _ai_config_version.bump_version()
         self.assertEqual(ver, "")
 
-    @patch.object(_config_version_mod, "_get_redis_client")
+    @patch.object(_ai_config_version, "_get_redis_client")
     def test_get_version_success(self, mock_redis_fn):
         mock_r = MagicMock()
         mock_r.get.return_value = "1234567890"
         mock_redis_fn.return_value = mock_r
-        ver = _config_version_mod.get_version()
+        ver = _ai_config_version.get_version()
         self.assertEqual(ver, "1234567890")
 
-    @patch.object(_config_version_mod, "_get_redis_client")
+    @patch.object(_ai_config_version, "_get_redis_client")
     def test_get_version_redis_down(self, mock_redis_fn):
         mock_redis_fn.return_value = None
-        ver = _config_version_mod.get_version()
+        ver = _ai_config_version.get_version()
         self.assertIsNone(ver)
 
-    @patch.object(_config_version_mod, "_get_redis_client")
+    @patch.object(_ai_config_version, "_get_redis_client")
     def test_get_version_exception(self, mock_redis_fn):
         mock_r = MagicMock()
         mock_r.get.side_effect = Exception("connection refused")
         mock_redis_fn.return_value = mock_r
-        ver = _config_version_mod.get_version()
+        ver = _ai_config_version.get_version()
         self.assertIsNone(ver)
 
 
-# ── AIRouter 路由/缓存/fallback ────────────────────────────────────────────
-
-
 class TestAIRouter(unittest.TestCase):
     """AIRouter 路由/缓存/fallback 测试"""
 
     def setUp(self):
-        self.router = ai_router_mod.AIRouter()
+        self.router = _ai_router.AIRouter()
 
-    def _freeze_version(self, value=None):
-        """让 get_capability 的版本比对固定，避免走 Redis。"""
-        return patch.object(_config_version_mod, "get_version", return_value=value)
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_get_capability_db_unavailable(self, mock_ver):
+        with patch.object(_ai_router, "_get_session", return_value=None):
+            cap = self.router.get_capability("intent_parsing")
+            self.assertIsNone(cap)
 
-    def test_get_capability_db_unavailable(self):
-        with self._freeze_version(None):
-            with patch.object(ai_router_mod, "_get_session", return_value=None):
-                cap = self.router.get_capability("intent_parsing")
-                self.assertIsNone(cap)
-
-    def test_get_capability_from_db(self):
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_get_capability_from_db(self, mock_ver):
         mock_session = MagicMock()
-        mock_session.execute.return_value.first.return_value = _capability_row()
-        with self._freeze_version(None):
-            with patch.object(ai_router_mod, "_get_session", return_value=mock_session):
-                cap = self.router.get_capability("intent_parsing")
-                self.assertIsNotNone(cap)
-                self.assertEqual(cap.capability_key, "intent_parsing")
-                self.assertEqual(cap.primary_model.model_key, "doubao-seed-1-6-250615")
+        mock_row = MagicMock()
+        mock_row.capability_key = "intent_parsing"
+        mock_row.capability_name = "文案意图解析"
+        mock_row.timeout_seconds = 45
+        mock_row.max_retries = 1
+        mock_row.max_tokens = None
+        mock_row.temperature = None
+        mock_row.concurrency = 2
+        mock_row.extra_params = {}
+        mock_row.is_enabled = True
+        mock_row.pm_id = "model-1"
+        mock_row.pm_name = "豆包"
+        mock_row.pm_provider = "volcengine"
+        mock_row.pm_model_key = "doubao-seed-1-6-250615"
+        mock_row.pm_api_key = "test-key"
+        mock_row.pm_api_base = "https://ark.test.com"
+        mock_row.pm_api_version = None
+        mock_row.pm_status = "active"
+        mock_row.lm_id = None
+        mock_row.fm_id = None
+        mock_session.execute.return_value.first.return_value = mock_row
 
-    def test_cache_invalidation_on_version_change(self):
-        with self._freeze_version(None):
-            with patch.object(self.router, "_load_from_db", return_value=None):
-                self.router.get_capability("test_key")
+        with patch.object(_ai_router, "_get_session", return_value=mock_session):
+            cap = self.router.get_capability("intent_parsing")
+            self.assertIsNotNone(cap)
+            self.assertEqual(cap.capability_key, "intent_parsing")
+            self.assertEqual(cap.primary_model.model_key, "doubao-seed-1-6-250615")
+
+    @patch.object(_ai_config_version, "get_version", side_effect=[None, "v2"])
+    def test_cache_invalidation_on_version_change(self, mock_ver):
+        with patch.object(self.router, "_load_from_db", return_value=None):
+            self.router.get_capability("test_key")
         self.router._local_ver = "v1"
-        with patch.object(_config_version_mod, "get_version", return_value="v2"):
-            self.assertTrue(self.router._check_version())
+        self.assertTrue(self.router._check_version())
 
-    def test_cache_hit_same_version(self):
-        cap = _capability_config(
-            primary_model=_model_config(model_key="test-model"),
+    @patch.object(_ai_config_version, "get_version", return_value="same_ver")
+    def test_cache_hit_same_version(self, mock_ver):
+        model = _ai_router.ModelConfig(
+            id="m1", name="test", provider="volcengine", model_key="test-model",
+            api_key="key", api_base="https://test.com", api_version=None, status="active",
+        )
+        cap = _ai_router.CapabilityConfig(
+            capability_key="test", capability_name="test", primary_model=model,
+            lite_model=None, fallback_model=None, timeout_seconds=30,
+            max_retries=1, max_tokens=None, temperature=None, concurrency=2,
+            extra_params={}, is_enabled=True,
         )
         self.router._cache["test"] = cap
         self.router._local_ver = "same_ver"
-        with patch.object(_config_version_mod, "get_version", return_value="same_ver"):
-            result = self.router.get_capability("test")
+        result = self.router.get_capability("test")
         self.assertEqual(result, cap)
 
     def test_invalidate_clears_cache(self):
@@ -214,163 +213,181 @@ class TestAIRouter(unittest.TestCase):
         self.assertEqual(len(self.router._cache), 0)
         self.assertIsNone(self.router._local_ver)
 
-    def test_get_llm_client_fallback(self):
-        with self._freeze_version(None):
-            with patch.object(ai_router_mod, "_get_session", return_value=None):
-                client = self.router.get_llm_client("intent_parsing")
+    @patch.object(_ai_router, "_get_session", return_value=None)
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_get_llm_client_fallback(self, mock_ver, mock_session):
+        _ai_router.get_shared_settings = lambda: _mock_settings
+        client = self.router.get_llm_client("intent_parsing")
         self.assertIsNotNone(client)
         self.assertEqual(client.model, "doubao-seed-2-1-pro-260915")
         self.assertEqual(client.api_key, "test-key")
 
-    def test_get_llm_client_from_db(self):
-        cap = _capability_config(
-            capability_key="image_analysis",
-            capability_name="图片分析",
-            max_tokens=350,
-            temperature=0.1,
-            primary_model=_model_config(
-                provider="dashscope",
-                model_key="qwen3.8-flash",
-                api_key="db-key",
-                api_base="https://dashscope.test.com",
-            ),
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_get_llm_client_from_db(self, mock_ver):
+        model = _ai_router.ModelConfig(
+            id="m1", name="test", provider="dashscope", model_key="qwen3.8-flash",
+            api_key="db-key", api_base="https://dashscope.test.com", api_version=None, status="active",
+        )
+        cap = _ai_router.CapabilityConfig(
+            capability_key="image_analysis", capability_name="图片分析",
+            primary_model=model, lite_model=None, fallback_model=None,
+            timeout_seconds=15, max_retries=1, max_tokens=350, temperature=0.1,
+            concurrency=2, extra_params={}, is_enabled=True,
         )
         with patch.object(self.router, "get_capability", return_value=cap):
             client = self.router.get_llm_client("image_analysis")
-        self.assertIsNotNone(client)
-        self.assertEqual(client.model, "qwen3.8-flash")
-        self.assertEqual(client.provider, "dashscope")
+            self.assertIsNotNone(client)
+            self.assertEqual(client.model, "qwen3.8-flash")
+            self.assertEqual(client.provider, "dashscope")
 
-    def test_get_vision_client(self):
-        cap = _capability_config(
-            capability_key="image_analysis",
-            capability_name="图片分析",
-            primary_model=_model_config(
-                provider="dashscope",
-                model_key="qwen3.8-flash",
-                api_key="key",
-                api_base="https://dashscope.test.com",
-            ),
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_get_vision_client(self, mock_ver):
+        model = _ai_router.ModelConfig(
+            id="m1", name="test", provider="dashscope", model_key="qwen3.8-flash",
+            api_key="key", api_base="https://dashscope.test.com", api_version=None, status="active",
+        )
+        cap = _ai_router.CapabilityConfig(
+            capability_key="image_analysis", capability_name="图片分析",
+            primary_model=model, lite_model=None, fallback_model=None,
+            timeout_seconds=15, max_retries=1, max_tokens=None, temperature=None,
+            concurrency=2, extra_params={}, is_enabled=True,
         )
         with patch.object(self.router, "get_capability", return_value=cap):
             client = self.router.get_vision_client("image_analysis")
-        self.assertIsNotNone(client)
-        # #2220: vision client is now DoubaoClient with vision_completion
-        self.assertTrue(hasattr(client, "vision_completion"))
+            self.assertIsNotNone(client)
+            # #2220: vision client is now DoubaoClient with vision_completion
+            self.assertTrue(hasattr(client, "vision_completion"))
 
-    def test_get_tts_client(self):
-        cap = _capability_config(
-            capability_key="tts",
-            capability_name="语音合成",
-            primary_model=_model_config(
-                provider="dashscope",
-                model_key="cosyvoice-v3-flash",
-                api_key="key",
-                api_base="https://dashscope.test.com",
-            ),
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_get_tts_client(self, mock_ver):
+        model = _ai_router.ModelConfig(
+            id="m1", name="test", provider="dashscope", model_key="cosyvoice-v3-flash",
+            api_key="key", api_base="https://dashscope.test.com", api_version=None, status="active",
+        )
+        cap = _ai_router.CapabilityConfig(
+            capability_key="tts", capability_name="语音合成",
+            primary_model=model, lite_model=None, fallback_model=None,
+            timeout_seconds=60, max_retries=1, max_tokens=None, temperature=None,
+            concurrency=2, extra_params={}, is_enabled=True,
         )
         with patch.object(self.router, "get_capability", return_value=cap):
             client = self.router.get_tts_client()
-        self.assertIsNotNone(client)
-        self.assertEqual(client.model, "cosyvoice-v3-flash")
+            self.assertIsNotNone(client)
+            self.assertEqual(client.model, "cosyvoice-v3-flash")
 
-    def test_get_image_gen_client(self):
-        cap = _capability_config(
-            capability_key="image_generation",
-            capability_name="图片生成",
-            extra_params={"size": "1K"},
-            primary_model=_model_config(
-                model_key="seedream-5.0-flash",
-                api_key="key",
-                api_base="https://ark.test.com",
-            ),
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_get_image_gen_client(self, mock_ver):
+        model = _ai_router.ModelConfig(
+            id="m1", name="test", provider="volcengine", model_key="seedream-5.0-flash",
+            api_key="key", api_base="https://ark.test.com", api_version=None, status="active",
+        )
+        cap = _ai_router.CapabilityConfig(
+            capability_key="image_generation", capability_name="图片生成",
+            primary_model=model, lite_model=None, fallback_model=None,
+            timeout_seconds=60, max_retries=1, max_tokens=None, temperature=None,
+            concurrency=2, extra_params={"size": "1K"}, is_enabled=True,
         )
         with patch.object(self.router, "get_capability", return_value=cap):
             client = self.router.get_image_gen_client()
-        self.assertIsNotNone(client)
-        self.assertEqual(client.model, "seedream-5.0-flash")
+            self.assertIsNotNone(client)
+            self.assertEqual(client.model, "seedream-5.0-flash")
 
-    def test_get_video_gen_client(self):
-        cap = _capability_config(
-            capability_key="video_generation",
-            capability_name="视频生成",
-            concurrency=1,
-            primary_model=_model_config(
-                model_key="seedance-2.5",
-                api_key="key",
-                api_base="https://ark.test.com",
-            ),
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_get_video_gen_client(self, mock_ver):
+        model = _ai_router.ModelConfig(
+            id="m1", name="test", provider="volcengine", model_key="seedance-2.5",
+            api_key="key", api_base="https://ark.test.com", api_version=None, status="active",
+        )
+        cap = _ai_router.CapabilityConfig(
+            capability_key="video_generation", capability_name="视频生成",
+            primary_model=model, lite_model=None, fallback_model=None,
+            timeout_seconds=600, max_retries=1, max_tokens=None, temperature=None,
+            concurrency=1, extra_params={}, is_enabled=True,
         )
         with patch.object(self.router, "get_capability", return_value=cap):
             client = self.router.get_video_gen_client()
-        self.assertIsNotNone(client)
-        self.assertEqual(client.model, "seedance-2.5")
+            self.assertIsNotNone(client)
+            self.assertEqual(client.model, "seedance-2.5")
 
-    def test_lite_variant_preference(self):
-        cap = _capability_config(
-            capability_key="image_analysis",
-            capability_name="图片分析",
-            primary_model=_model_config(id="p1", name="pro", model_key="pro-model", api_key="k", api_base="u"),
-            lite_model=_model_config(id="l1", name="lite", model_key="lite-model", api_key="k", api_base="u"),
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_lite_variant_preference(self, mock_ver):
+        primary = _ai_router.ModelConfig(id="p1", name="pro", provider="volcengine", model_key="pro-model", api_key="k", api_base="u", api_version=None, status="active")
+        lite = _ai_router.ModelConfig(id="l1", name="lite", provider="volcengine", model_key="lite-model", api_key="k", api_base="u", api_version=None, status="active")
+        cap = _ai_router.CapabilityConfig(
+            capability_key="image_analysis", capability_name="图片分析",
+            primary_model=primary, lite_model=lite, fallback_model=None,
+            timeout_seconds=15, max_retries=1, max_tokens=None, temperature=None,
+            concurrency=2, extra_params={}, is_enabled=True,
         )
         model = self.router._get_model_or_fallback(cap, "lite")
         self.assertEqual(model.model_key, "lite-model")
         model_primary = self.router._get_model_or_fallback(cap, "primary")
         self.assertEqual(model_primary.model_key, "pro-model")
 
-    def test_disabled_capability_returns_fallback(self):
-        cap = _capability_config(is_enabled=False)
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_disabled_capability_returns_fallback(self, mock_ver):
+        cap = _ai_router.CapabilityConfig(
+            capability_key="test", capability_name="test",
+            primary_model=None, lite_model=None, fallback_model=None,
+            timeout_seconds=30, max_retries=1, max_tokens=None, temperature=None,
+            concurrency=2, extra_params={}, is_enabled=False,
+        )
+        _ai_router.get_shared_settings = lambda: _mock_settings
         with patch.object(self.router, "get_capability", return_value=cap):
             client = self.router.get_llm_client("test")
-        self.assertIsNotNone(client)
-        self.assertEqual(client.model, "doubao-seed-2-1-pro-260915")
+            self.assertIsNotNone(client)
+            self.assertEqual(client.model, "doubao-seed-2-1-pro-260915")
 
-    def test_fallback_chain_primary_none(self):
+    @patch.object(_ai_config_version, "get_version", return_value=None)
+    def test_fallback_chain_primary_none(self, mock_ver):
         """primary_model 为 None 时 fallback 到 fallback_model"""
-        cap = _capability_config(
-            fallback_model=_model_config(id="f1", name="fb", model_key="fb-model", api_key="k", api_base="u"),
+        fb = _ai_router.ModelConfig(id="f1", name="fb", provider="volcengine", model_key="fb-model", api_key="k", api_base="u", api_version=None, status="active")
+        cap = _ai_router.CapabilityConfig(
+            capability_key="test", capability_name="test",
+            primary_model=None, lite_model=None, fallback_model=fb,
+            timeout_seconds=30, max_retries=1, max_tokens=None, temperature=None,
+            concurrency=2, extra_params={}, is_enabled=True,
         )
         model = self.router._get_model_or_fallback(cap, "primary")
         self.assertEqual(model.model_key, "fb-model")
 
 
-# ── 数据类冻结 ──────────────────────────────────────────────────────────────
-
-
 class TestModelConfig(unittest.TestCase):
     """数据类测试"""
 
     def test_model_config_frozen(self):
-        m = _model_config(id="1", name="t", provider="p", model_key="k", api_key="a", api_base="b")
+        m = _ai_router.ModelConfig(id="1", name="t", provider="p", model_key="k", api_key="a", api_base="b", api_version=None, status="active")
         with self.assertRaises(AttributeError):
             m.model_key = "new"
 
     def test_capability_config_frozen(self):
-        c = _capability_config()
+        c = _ai_router.CapabilityConfig(
+            capability_key="k", capability_name="n", primary_model=None,
+            lite_model=None, fallback_model=None, timeout_seconds=30,
+            max_retries=1, max_tokens=None, temperature=None, concurrency=2,
+            extra_params={}, is_enabled=True,
+        )
         with self.assertRaises(AttributeError):
             c.is_enabled = False
 
 
-# ── 客户端可用性 ────────────────────────────────────────────────────────────
-
-
 class TestClientAvailability(unittest.TestCase):
     """客户端可用性测试"""
 
     def test_tts_client_available(self):
-        c = ai_router_mod.TTSClient(provider="p", api_key="k", base_url="u", model="m")
+        c = _ai_router.TTSClient(provider="p", api_key="k", base_url="u", model="m")
         self.assertTrue(c.is_available)
 
     def test_tts_client_unavailable_no_model(self):
-        c = ai_router_mod.TTSClient(provider="p", api_key="k", base_url="u", model="")
+        c = _ai_router.TTSClient(provider="p", api_key="k", base_url="u", model="")
         self.assertFalse(c.is_available)
 
     def test_image_gen_client_unavailable_no_url(self):
-        c = ai_router_mod.ImageGenClient(provider="p", api_key="k", base_url="", model="m")
+        c = _ai_router.ImageGenClient(provider="p", api_key="k", base_url="", model="m")
         self.assertFalse(c.is_available)
 
     def test_video_gen_client_available(self):
-        c = ai_router_mod.VideoGenClient(provider="p", api_key="k", base_url="u", model="m")
+        c = _ai_router.VideoGenClient(provider="p", api_key="k", base_url="u", model="m")
         self.assertTrue(c.is_available)
 
 

tests/unit/test_ditto_emotion_service.py

@@ -1,225 +0,0 @@
-"""Ditto LLM 情绪分析服务单元测试."""
-
-from __future__ import annotations
-
-import json
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from packages.application.ditto_emotion_service import (
-    EMO_HAPPY,
-    EMO_NEUTRAL,
-    DittoEmotionService,
-    EmotionSegment,
-    _parse_emotion_json,
-    align_timeline_by_length,
-    align_timeline_by_timings,
-    split_sentences,
-)
-
-
-# ── 分句 ─────────────────────────────────────────────────────────
-class TestSplitSentences:
-    def test_empty(self):
-        assert split_sentences("") == []
-
-    def test_single(self):
-        assert split_sentences("你好。") == ["你好。"]
-
-    def test_multi(self):
-        sents = split_sentences("大家好！今天给大家推荐一款超棒的产品。它真的很好用；不信你试试？")
-        assert len(sents) == 4
-        assert "大家好！" in sents[0]
-
-    def test_english_punct(self):
-        sents = split_sentences("Hello! How are you? I'm fine.")
-        assert len(sents) == 3
-
-
-# ── JSON 解析 ────────────────────────────────────────────────────
-class TestParseEmotionJson:
-    def test_valid(self):
-        raw = json.dumps([{"text": "你好", "emo": 4, "intensity": 0.2}])
-        segs = _parse_emotion_json(raw)
-        assert len(segs) == 1
-        assert segs[0].emo == 4
-        assert segs[0].intensity == 0.2
-
-    def test_markdown_wrapped(self):
-        raw = "```json\n" + json.dumps([{"text": "好", "emo": 3, "intensity": 0.5}]) + "\n```"
-        segs = _parse_emotion_json(raw)
-        assert len(segs) == 1
-        assert segs[0].emo == 3
-
-    def test_forbidden_emo_becomes_neutral(self):
-        raw = json.dumps([{"text": "怒", "emo": 0, "intensity": 0.8}])
-        segs = _parse_emotion_json(raw)
-        assert len(segs) == 1
-        assert segs[0].emo == EMO_NEUTRAL
-
-    def test_invalid_json(self):
-        assert _parse_emotion_json("not json") == []
-
-    def test_empty(self):
-        assert _parse_emotion_json("") == []
-
-    def test_intensity_clamp(self):
-        raw = json.dumps([{"text": "a", "emo": 3, "intensity": 1.5}])
-        segs = _parse_emotion_json(raw)
-        assert segs[0].intensity == 1.0
-
-    def test_missing_text_skipped(self):
-        raw = json.dumps([{"emo": 3, "intensity": 0.4}])
-        segs = _parse_emotion_json(raw)
-        assert len(segs) == 0
-
-
-# ── 时间对齐（按字数比例）────────────────────────────────────────
-class TestAlignTimelineByLength:
-    def test_basic(self):
-        segs = [
-            EmotionSegment("ab", EMO_NEUTRAL, 0.2),
-            EmotionSegment("cd", EMO_HAPPY, 0.5),
-        ]
-        entries = align_timeline_by_length(segs, 4.0)
-        assert len(entries) == 2
-        assert entries[0].start == 0.0
-        assert entries[0].end == 2.0
-        assert entries[1].start == 2.0
-        assert entries[1].end == 4.0
-        assert entries[0].emo == EMO_NEUTRAL
-        assert entries[1].emo == EMO_HAPPY
-
-    def test_empty_segments(self):
-        assert align_timeline_by_length([], 5.0) == []
-
-    def test_zero_duration(self):
-        segs = [EmotionSegment("ab", EMO_NEUTRAL, 0.2)]
-        assert align_timeline_by_length(segs, 0) == []
-
-    def test_unequal_length(self):
-        segs = [
-            EmotionSegment("a" * 3, EMO_HAPPY, 0.5),
-            EmotionSegment("b" * 1, EMO_NEUTRAL, 0.2),
-        ]
-        entries = align_timeline_by_length(segs, 4.0)
-        assert entries[0].end == 3.0
-        assert entries[1].start == 3.0
-        assert entries[1].end == 4.0
-
-
-# ── 时间对齐（sentence_timings）──────────────────────────────────
-class TestAlignTimelineByTimings:
-    def test_exact_match(self):
-        segs = [
-            EmotionSegment("hello", EMO_HAPPY, 0.4),
-            EmotionSegment("world", EMO_NEUTRAL, 0.2),
-        ]
-        timings = [
-            {"start": 0.0, "end": 1.5},
-            {"start": 1.5, "end": 3.0},
-        ]
-        entries = align_timeline_by_timings(segs, timings, 3.0)
-        assert len(entries) == 2
-        assert entries[0].start == 0.0
-        assert entries[0].end == 1.5
-        assert entries[1].start == 1.5
-        assert entries[1].end == 3.0
-
-    def test_length_mismatch_fallback(self):
-        segs = [EmotionSegment("hello", EMO_HAPPY, 0.4)]
-        timings = [{"start": 0, "end": 1}, {"start": 1, "end": 2}]
-        entries = align_timeline_by_timings(segs, timings, 2.0)
-        assert len(entries) == 1
-        assert entries[0].end == 2.0
-
-
-# ── DittoEmotionService ──────────────────────────────────────────
-def _make_service(enabled=True, model=None, temperature=0.1, timeout=10, max_tokens=1024, prompt=""):
-    s = MagicMock()
-    s.ditto_emotion_enabled = enabled
-    s.ditto_emotion_model = model or ""
-    s.ditto_emotion_temperature = temperature
-    s.ditto_emotion_timeout = timeout
-    s.ditto_emotion_max_tokens = max_tokens
-    s.ditto_emotion_cache_size = 100
-    s.ditto_emotion_prompt = prompt
-    return DittoEmotionService(settings=s)
-
-
-class TestDittoEmotionService:
-    def test_disabled_returns_empty(self):
-        svc = _make_service(enabled=False)
-        assert svc.analyze("你好世界") == []
-
-    def test_empty_text_returns_empty(self):
-        svc = _make_service(enabled=True)
-        assert svc.analyze("") == []
-
-    def test_llm_success(self):
-        svc = _make_service(enabled=True)
-        fake_reply = json.dumps([{"text": "你好", "emo": 4, "intensity": 0.2}])
-        with patch.object(svc, "_call_llm", return_value=_parse_emotion_json(fake_reply)):
-            segs = svc.analyze("你好")
-            assert len(segs) == 1
-            assert segs[0].emo == 4
-
-    def test_cache_hit(self):
-        svc = _make_service(enabled=True)
-        fake_reply = json.dumps([{"text": "你好世界", "emo": 3, "intensity": 0.5}])
-        with patch.object(svc, "_call_llm", return_value=_parse_emotion_json(fake_reply)) as mock_call:
-            svc.analyze("你好世界")
-            svc.analyze("你好世界")
-            assert mock_call.call_count == 1
-
-    def test_build_timeline_empty_when_disabled(self):
-        svc = _make_service(enabled=False)
-        assert svc.build_timeline("test", 5.0) == ""
-
-    def test_build_timeline_returns_json(self):
-        svc = _make_service(enabled=True)
-        fake_reply = json.dumps(
-            [
-                {"text": "ab", "emo": 4, "intensity": 0.2},
-                {"text": "cd", "emo": 3, "intensity": 0.4},
-            ]
-        )
-        with patch.object(svc, "_call_llm", return_value=_parse_emotion_json(fake_reply)):
-            result = svc.build_timeline("ab。cd。", 4.0)
-            data = json.loads(result)
-            assert len(data) == 2
-            assert data[0]["emo"] == 4
-            assert data[1]["emo"] == 3
-
-    def test_build_timeline_with_sentence_timings(self):
-        svc = _make_service(enabled=True)
-        fake_reply = json.dumps(
-            [
-                {"text": "hello", "emo": 3, "intensity": 0.4},
-                {"text": "world", "emo": 4, "intensity": 0.2},
-            ]
-        )
-        timings = [
-            {"start": 0.0, "end": 1.0},
-            {"start": 1.0, "end": 3.0},
-        ]
-        with patch.object(svc, "_call_llm", return_value=_parse_emotion_json(fake_reply)):
-            result = svc.build_timeline("hello world", 3.0, sentence_timings=timings)
-            data = json.loads(result)
-            assert data[0]["start"] == 0.0
-            assert data[0]["end"] == 1.0
-            assert data[1]["end"] == 3.0
-
-
-class TestPromptLoading:
-    def test_default_prompt_contains_placeholder(self):
-        from packages.application.ditto_emotion_service import _load_default_prompt
-
-        prompt = _load_default_prompt()
-        assert "{文案}" in prompt
-
-    def test_config_prompt_override(self):
-        custom = "分析情绪: {文案}"
-        svc = _make_service(enabled=True, prompt=custom)
-        assert svc._get_prompt_template() == custom

tests/unit/test_ditto_service.py

@@ -201,7 +201,6 @@ def test_empty_script_replaced_with_space():
 def test_generate_network_error_fails_fast(monkeypatch):
     """网络不通（ConnectError）时不重试，直接快速抛 NetworkUnreachable，避免用户等5分钟"""
     import httpx
-
     from packages.application import ditto_service as ds_mod
 
     calls = {"n": 0}

tests/unit/test_p02_p03_fixes.py

@@ -286,7 +286,7 @@ class TestGetDownloadUrl:
 
             result = svc.get_download_url("uploads/video.mp4")
 
-            svc.bucket.sign_url.assert_called_once_with("GET", "uploads/video.mp4", 3600, slash_safe=True)
+            svc.bucket.sign_url.assert_called_once_with("GET", "uploads/video.mp4", 3600)
             assert "signed-url" in result
 
     def test_returns_raw_url_when_bucket_none(self):

tests/unit/test_storage_service.py

@@ -361,7 +361,7 @@ class TestGetDownloadUrlFallback:
 
         result = service.get_download_url("videos/test.mp4", expires_seconds=7200)
 
-        mock_bucket.sign_url.assert_called_once_with("GET", "videos/test.mp4", 7200, slash_safe=True)
+        mock_bucket.sign_url.assert_called_once_with("GET", "videos/test.mp4", 7200)
         assert result == "https://signed-url.com/file?sig=abc"
 
     def test_sign_url_exception_falls_back_to_public_url(self):

tests/unit/test_system_config.py

@@ -1,287 +0,0 @@
-"""#2246 system_settings / system_config_service 单元测试。
-
-覆盖：序列化反序列化、默认值兜底、DB 覆盖、缓存失效、白名单拒绝、
-Ditto 单例 reset 联动、PUT 校验。
-"""
-
-from __future__ import annotations
-
-import pytest
-from sqlalchemy import create_engine, event
-from sqlalchemy.orm import sessionmaker
-
-from packages.adapters.sqlalchemy_impl.models import Base
-from packages.application.system_config_service import SystemConfigService
-from packages.domain.system_setting import (
-    SETTING_TYPE_BOOL,
-    SETTING_TYPE_FLOAT,
-    SETTING_TYPE_INT,
-    SETTING_TYPE_JSON,
-    SETTING_TYPE_STRING,
-    SystemSettingError,
-    deserialize_setting_value,
-    infer_setting_type,
-    serialize_setting_value,
-)
-
-
-# ── domain 序列化 ──────────────────────────────────────────────
-class TestSerialization:
-    @pytest.mark.parametrize(
-        "value,st,expected",
-        [
-            (True, SETTING_TYPE_BOOL, "true"),
-            (False, SETTING_TYPE_BOOL, "false"),
-            (12, SETTING_TYPE_INT, "12"),
-            (-3, SETTING_TYPE_INT, "-3"),
-            (0.1, SETTING_TYPE_FLOAT, "0.1"),
-            ("hello", SETTING_TYPE_STRING, "hello"),
-        ],
-    )
-    def test_serialize(self, value, st, expected):
-        assert serialize_setting_value(value, st) == expected
-
-    def test_json_roundtrip(self):
-        raw = serialize_setting_value({"a": [1, 2]}, SETTING_TYPE_JSON)
-        assert deserialize_setting_value(raw, SETTING_TYPE_JSON) == {"a": [1, 2]}
-
-    def test_bool_roundtrip_variants(self):
-        for truthy in ("true", "1", "yes", "on", "TRUE"):
-            assert deserialize_setting_value(truthy, SETTING_TYPE_BOOL) is True
-        for falsy in ("false", "0", "", "no"):
-            assert deserialize_setting_value(falsy, SETTING_TYPE_BOOL) is False
-
-    def test_int_float_roundtrip(self):
-        assert deserialize_setting_value("42", SETTING_TYPE_INT) == 42
-        assert deserialize_setting_value("1.5", SETTING_TYPE_FLOAT) == 1.5
-
-    def test_type_errors(self):
-        with pytest.raises(SystemSettingError):
-            serialize_setting_value("x", SETTING_TYPE_INT)
-        with pytest.raises(SystemSettingError):
-            serialize_setting_value(1, SETTING_TYPE_BOOL)
-        with pytest.raises(SystemSettingError):
-            deserialize_setting_value("abc", SETTING_TYPE_INT)
-        with pytest.raises(SystemSettingError):
-            serialize_setting_value(1, "unknown")
-
-    def test_infer_type_bool_before_int(self):
-        assert infer_setting_type(True) == SETTING_TYPE_BOOL
-        assert infer_setting_type(5) == SETTING_TYPE_INT
-        assert infer_setting_type(0.5) == SETTING_TYPE_FLOAT
-        assert infer_setting_type("s") == SETTING_TYPE_STRING
-        assert infer_setting_type([1]) == SETTING_TYPE_JSON
-
-
-# ── DB fixture ─────────────────────────────────────────────────
-@pytest.fixture()
-def config_service():
-    engine = create_engine("sqlite://", echo=False)
-
-    @event.listens_for(engine, "connect")
-    def _noop(dbapi_conn, connection_record):
-        pass
-
-    Base.metadata.create_all(engine)
-    factory = sessionmaker(bind=engine)
-    yield SystemConfigService(session_factory=factory)
-
-
-class TestConfigService:
-    def test_default_when_missing(self, config_service):
-        assert config_service.get_config("not_exist", "fallback") == "fallback"
-
-    def test_uses_module_session_factory_assigned_after_import(self):
-        # 回归：模块导入时 session.SessionLocal 为 None，initialize_database()
-        # 之后才赋值；服务必须运行时读取模块属性，而不是 import 时绑定旧值。
-        from packages.adapters.sqlalchemy_impl import session as db_session
-
-        engine = create_engine("sqlite://")
-        Base.metadata.create_all(engine)
-        factory = sessionmaker(bind=engine)
-        writer = SystemConfigService(session_factory=factory)
-        writer.set_config("late_key", 7, setting_type=SETTING_TYPE_INT)
-
-        reader = SystemConfigService()  # 不注入工厂，依赖模块级 SessionLocal
-        old = db_session.SessionLocal
-        try:
-            db_session.SessionLocal = factory
-            assert reader.get_config("late_key", 0) == 7
-        finally:
-            db_session.SessionLocal = old
-
-    def test_raises_when_no_session_factory(self):
-        from packages.adapters.sqlalchemy_impl import session as db_session
-
-        svc = SystemConfigService()
-        old = db_session.SessionLocal
-        try:
-            db_session.SessionLocal = None
-            with pytest.raises(RuntimeError):
-                svc.get_config("anything", 1)
-        finally:
-            db_session.SessionLocal = old
-
-    def test_db_overrides_default(self, config_service):
-        config_service.set_config("k", 20, setting_type=SETTING_TYPE_INT)
-        # 再次读取应命中 DB 值，而非传入的默认
-        assert config_service.get_config("k", 12) == 20
-
-    def test_set_and_get_all_types(self, config_service):
-        config_service.set_config("b", True)
-        config_service.set_config("i", 7)
-        config_service.set_config("f", 0.3)
-        config_service.set_config("s", "文本")
-        config_service.set_config("j", {"x": 1})
-        assert config_service.get_config("b", False) is True
-        assert config_service.get_config("i", 0) == 7
-        assert abs(config_service.get_config("f", 0.0) - 0.3) < 1e-9
-        assert config_service.get_config("s", "") == "文本"
-        assert config_service.get_config("j", {}) == {"x": 1}
-
-    def test_update_existing(self, config_service):
-        config_service.set_config("k", 1, setting_type=SETTING_TYPE_INT)
-        config_service.set_config("k", 2, setting_type=SETTING_TYPE_INT)
-        assert config_service.get_config("k", 0) == 2
-        assert len(config_service.list_configs()) == 1
-
-    def test_cache_invalidation(self, config_service):
-        config_service.set_config("k", 1, setting_type=SETTING_TYPE_INT)
-        config_service.get_config("k", 0)  # 填充缓存
-        # 手工改库模拟外部写入，reload 后应可见
-        from packages.adapters.sqlalchemy_impl.models import SystemSettingModel
-
-        session = config_service._get_session_factory()()
-        session.query(SystemSettingModel).filter(SystemSettingModel.setting_key == "k").update({"setting_value": "99"})
-        session.commit()
-        session.close()
-        # 缓存未失效前仍是旧值
-        assert config_service.get_config("k", 0) == 1
-        config_service.reload()
-        assert config_service.get_config("k", 0) == 99
-
-    def test_list_by_category(self, config_service):
-        config_service.set_config("a", 1, category="ditto")
-        config_service.set_config("b", 2, category="other")
-        keys = {c.setting_key for c in config_service.list_configs("ditto")}
-        assert keys == {"a"}
-
-    def test_delete(self, config_service):
-        config_service.set_config("k", 1, setting_type=SETTING_TYPE_INT)
-        assert config_service.delete_config("k") is True
-        assert config_service.get_config("k", "d") == "d"
-        assert config_service.delete_config("k") is False
-
-    def test_reset_singletons_called(self, config_service):
-        called = {"emo": 0, "client": 0}
-
-        import packages.application.ditto_emotion_service as real_emo
-        import packages.application.ditto_service as real_client
-
-        orig_emo_reset = real_emo.reset_ditto_emotion_service
-        orig_client_reset = real_client.reset_ditto_client
-
-        def fake_emo_reset():
-            called["emo"] += 1
-
-        def fake_client_reset():
-            called["client"] += 1
-
-        real_emo.reset_ditto_emotion_service = fake_emo_reset
-        real_client.reset_ditto_client = fake_client_reset
-        try:
-            config_service.set_config("ditto_emotion_model", "m", setting_type=SETTING_TYPE_STRING)
-            assert called["emo"] == 1
-            assert called["client"] == 1
-        finally:
-            # 必须还原，否则污染同文件后续 reset 用例
-            real_emo.reset_ditto_emotion_service = orig_emo_reset
-            real_client.reset_ditto_client = orig_client_reset
-
-
-# ── Ditto 单例 reset ───────────────────────────────────────────
-class TestDittoSingletonReset:
-    def test_emotion_reset_clears_lru(self):
-        from unittest.mock import MagicMock
-
-        from packages.application import ditto_emotion_service as m
-
-        # 用一个可哈希的假 service 填 LRU，_call_llm 返回固定值，不触发真实逻辑
-        fake = MagicMock()
-        fake._call_llm.return_value = []
-        m._cached_analyze.cache_clear()
-        m._cached_analyze(fake, "k", "t")
-        assert m._cached_analyze.cache_info().currsize == 1
-
-        saved_singleton = m._singleton
-        m._singleton = fake
-        try:
-            m.reset_ditto_emotion_service()
-            assert m._singleton is None
-            assert m._cached_analyze.cache_info().currsize == 0
-        finally:
-            m._singleton = saved_singleton
-
-    def test_client_reset(self):
-        from packages.application import ditto_service as m
-
-        saved = m._ditto_client_singleton
-        m._ditto_client_singleton = object()
-        try:
-            m.reset_ditto_client()
-            assert m._ditto_client_singleton is None
-        finally:
-            m._ditto_client_singleton = saved
-
-
-# ── 路由层白名单与校验 ─────────────────────────────────────────
-class TestAdminRouteValidation:
-    def _route(self):
-        from apps.api.app.api.routes.admin import ditto_emotion as route
-
-        return route
-
-    def test_whitelist_rejects_unknown_key(self):
-        route = self._route()
-        from packages.application.system_config_service import SystemConfigService
-
-        svc = SystemConfigService(session_factory=lambda: pytest.fail("should not open session"))
-        payload = route.ConfigUpdatePayload(configs={"evil_key": 1})
-        # 直接调用 update_config，传入一个任意 key 标识
-        result = route.update_config(payload, x_api_key="k")
-        assert result["ok"] is False
-        assert "不允许修改" in result["error"]
-
-    def test_validate_blend_frames_range(self):
-        route = self._route()
-        with pytest.raises(ValueError):
-            route._validate_value("ditto_blend_frames", 3)
-        with pytest.raises(ValueError):
-            route._validate_value("ditto_blend_frames", 31)
-        assert route._validate_value("ditto_blend_frames", 12) == 12
-
-    def test_validate_temperature_range(self):
-        route = self._route()
-        with pytest.raises(ValueError):
-            route._validate_value("ditto_emotion_temperature", 1.5)
-        assert route._validate_value("ditto_emotion_temperature", "0.2") == pytest.approx(0.2)
-
-    def test_validate_prompt_placeholder(self):
-        route = self._route()
-        with pytest.raises(ValueError):
-            route._validate_value("ditto_emotion_prompt", "没有占位符的提示词")
-        assert route._validate_value("ditto_emotion_prompt", "分析：{文案}") == "分析：{文案}"
-        # 允许留空（使用默认）
-        assert route._validate_value("ditto_emotion_prompt", "") == ""
-
-    def test_validate_model_options(self):
-        route = self._route()
-        with pytest.raises(ValueError):
-            route._validate_value("ditto_emotion_model", "gpt-4")
-        assert route._validate_value("ditto_emotion_model", "deepseek-v3") == "deepseek-v3"
-
-    def test_validate_bool(self):
-        route = self._route()
-        with pytest.raises(ValueError):
-            route._validate_value("ditto_emotion_enabled", "yes")
-        assert route._validate_value("ditto_emotion_enabled", True) is True

tests/unit/test_viral_video.py

@@ -361,24 +361,16 @@ class TestViralVideoPipeline:
 <transition>硬切</transition>
 <reference_image_index>0</reference_image_index>
 </clip>
-<clip image_index="1" time_range="5-10秒">
-<voiceover>颜色特别好看</voiceover>
+<clip image_index="1" time_range="5-15秒">
+<voiceover>颜色特别好看很显白</voiceover>
 <visual>特写，固定镜头</visual>
 <action_details>嘴唇涂抹特写</action_details>
 <audio_bgm>轻快BGM继续</audio_bgm>
-<transition>硬切</transition>
+<transition>结束</transition>
 <reference_image_index>1</reference_image_index>
 </clip>
-<clip image_index="2" time_range="10-15秒">
-<voiceover>很显白，推荐给大家</voiceover>
-<visual>中景，微笑展示</visual>
-<action_details>口红展示</action_details>
-<audio_bgm>轻快BGM结束</audio_bgm>
-<transition>结束</transition>
-<reference_image_index>0</reference_image_index>
-</clip>
 </clips>
-<voiceover_script>大家好呀，今天来给大家分享一款超显白的口红。颜色特别好看很显气质，真心推荐给姐妹们</voiceover_script>
+<voiceover_script>大家好，今天分享一款口红。颜色特别好看很显白</voiceover_script>
 <theme>口红分享</theme>"""
 
     @pytest.fixture
@@ -463,7 +455,7 @@ class TestViralVideoPipeline:
         assert "voiceover_script" in result
         assert "shots" in result
         assert isinstance(result["shots"], list)
-        assert len(result["shots"]) == 3
+        assert len(result["shots"]) == 2
         assert result["overview"]["total_duration"] == 15
         # final_copy 必须 = voiceover_script（向后兼容）
         assert result.get("final_copy") == result["voiceover_script"]
@@ -512,7 +504,7 @@ class TestViralVideoPipeline:
         }
         prompt = _assemble_seedance_prompt(cr, mock_job)
         assert "【视频总览】" in prompt
-        assert "【分镜脚本】" in prompt
+        assert "【逐镜头时间轴】" in prompt
         assert "【硬性约束】" in prompt
         assert "【负面提示词】" in prompt
         assert "0-15秒" in prompt

tests/unit/test_viral_video_p0.py

@@ -129,7 +129,7 @@ class TestScriptGenerationV16:
             "negative_prompts": ["水印"],
         }
         p = _assemble_seedance_prompt(cr, mock_job)
-        for key in ("【视频总览】", "【参考素材】", "【分镜脚本】", "【硬性约束】", "【负面提示词】"):
+        for key in ("【视频总览】", "【场景与光线】", "【逐镜头时间轴】", "【硬性约束】", "【负面提示词】"):
             assert key in p
 
 
@@ -308,7 +308,8 @@ class TestResumeReadsImageAnalysis:
 
         # v1.5 改造后 resume 委托给 _run_render_pipeline，那里读取 job.image_analysis
         src = inspect.getsource(vv._run_render_pipeline)
-        assert "job.copy_result" in src
+        assert "job.image_analysis" in src
+        assert "image_analysis" in src
         # resume 本身应该调用 _run_render_pipeline
         resume_src = inspect.getsource(vv.resume_viral_video_pipeline)
         assert "_run_render_pipeline" in resume_src

tests/unit/test_viral_video_routes.py

@@ -29,15 +29,6 @@ def _make_job(job_id: str = "job-1", user_id: str = "u1", status: str = "pending
     job.user_id = user_id
     job.status = ViralVideoStatus(status) if isinstance(status, str) else status
     job.images = kwargs.pop("images", ["img-1"])
-    # confirm_copy 新增 copy_result 完整性校验：默认提供合法文案数据
-    job.copy_result = kwargs.pop(
-        "copy_result",
-        {
-            "theme": "测试主题",
-            "voiceover_script": "这是一段测试口播文案内容。",
-            "shots": [{"time_range": "0-15秒", "voiceover": "这是一段测试口播文案内容。"}],
-        },
-    )
     job.industry = kwargs.pop("industry", "电商")
     job.target_customer = kwargs.pop("target_customer", "年轻人")
     for k, v in {
@@ -64,8 +55,8 @@ def _make_job(job_id: str = "job-1", user_id: str = "u1", status: str = "pending
         "intent_result": None,
         "image_analysis": None,
         "storyboard": None,
+        "copy_result": None,
         "generated_copy_text": "",
-        "language": "zh-CN",
         "voice_id": "",
         "voice_source": "",
         "voice_mode": "global",
@@ -156,16 +147,9 @@ class TestRetryViralVideo:
         user = _auth_user("u1")
         session = MagicMock()
         job = _make_job(
-            job_id="job-retry2",
-            user_id="u1",
-            status=ViralVideoStatus.FAILED,
-            duration=15,
-            video_ratio="9:16",
-            video_resolution="720p",
-            video_model="seedance-2.5",
-            credits_prepaid=5.0,
-            credits_transaction_id="txn1",
-            retry_count=0,
+            job_id="job-retry2", user_id="u1", status=ViralVideoStatus.FAILED,
+            duration=15, video_ratio="9:16", video_resolution="720p", video_model="seedance-2.5",
+            credits_prepaid=5.0, credits_transaction_id="txn1", retry_count=0,
         )
         repo = MagicMock()
         repo.get.return_value = job
@@ -196,32 +180,24 @@ class TestRetryViralVideo:
         user = _auth_user("u1")
         session = MagicMock()
         job = _make_job(
-            job_id="job-retry3a",
-            user_id="u1",
-            status=ViralVideoStatus.FAILED,
-            duration=15,
-            video_ratio="9:16",
-            video_resolution="720p",
-            video_model="seedance-2.5",
-            credits_prepaid=5.0,
-            credits_transaction_id="txn-old",
-            retry_count=0,
+            job_id="job-retry3a", user_id="u1", status=ViralVideoStatus.FAILED,
+            duration=15, video_ratio="9:16", video_resolution="720p", video_model="seedance-2.5",
+            credits_prepaid=5.0, credits_transaction_id="txn-old", retry_count=0,
         )
         repo = MagicMock()
         repo.get.return_value = job
 
         fake_svc = MagicMock()
         fake_svc.deduct_viral_video.return_value = {"success": False, "balance": 1.0}
-        req = RetryViralVideoRequest(
-            duration=30, video_resolution="1080p", video_ratio="16:9", video_model="seedance-2.5"
-        )
+        req = RetryViralVideoRequest(duration=30, video_resolution="1080p", video_ratio="16:9", video_model="seedance-2.5")
 
         with (
             patch.object(vv_mod, "_get_job_repo", return_value=repo),
             patch("app.config.settings") as mock_settings,
             patch("packages.domain.points_service.PointsService", return_value=fake_svc),
             patch("packages.domain.points_rules.resolve_video_dimensions", return_value=(1920, 1080)),
-            patch("packages.domain.points_rules.calculate_viral_video_credits_with_breakdown", return_value=(15.0, {})),
+            patch("packages.domain.points_rules.calculate_viral_video_credits_with_breakdown",
+                  return_value=(15.0, {})),
             patch.object(vv_mod.celery_app, "send_task"),
         ):
             mock_settings.points_enabled = True
@@ -240,29 +216,19 @@ class TestRetryViralVideo:
         user = _auth_user("u1")
         session = MagicMock()
         job = _make_job(
-            job_id="job-retry3b",
-            user_id="u1",
-            status=ViralVideoStatus.FAILED,
-            duration=15,
-            video_ratio="9:16",
-            video_resolution="720p",
-            video_model="seedance-2.5",
-            credits_prepaid=5.0,
-            credits_transaction_id="txn-old",
-            retry_count=0,
+            job_id="job-retry3b", user_id="u1", status=ViralVideoStatus.FAILED,
+            duration=15, video_ratio="9:16", video_resolution="720p", video_model="seedance-2.5",
+            credits_prepaid=5.0, credits_transaction_id="txn-old", retry_count=0,
         )
         # 用 SimpleNamespace 让属性真正可写
         from types import SimpleNamespace
-
         job.credits_prepaid = 5.0
         repo = MagicMock()
         repo.get.return_value = job
 
         fake_svc = MagicMock()
         fake_svc.deduct_viral_video.return_value = {"success": True, "balance": 50.0, "transaction_id": "txn-new"}
-        req = RetryViralVideoRequest(
-            duration=30, video_resolution="1080p", video_ratio="16:9", video_model="seedance-2.5"
-        )
+        req = RetryViralVideoRequest(duration=30, video_resolution="1080p", video_ratio="16:9", video_model="seedance-2.5")
 
         new_est = 15.0
         with (
@@ -270,9 +236,8 @@ class TestRetryViralVideo:
             patch("app.config.settings") as mock_settings,
             patch("packages.domain.points_service.PointsService", return_value=fake_svc),
             patch("packages.domain.points_rules.resolve_video_dimensions", return_value=(1920, 1080)),
-            patch(
-                "packages.domain.points_rules.calculate_viral_video_credits_with_breakdown", return_value=(new_est, {})
-            ),
+            patch("packages.domain.points_rules.calculate_viral_video_credits_with_breakdown",
+                  return_value=(new_est, {})),
             patch.object(vv_mod.celery_app, "send_task"),
         ):
             mock_settings.points_enabled = True
@@ -297,16 +262,9 @@ class TestRetryViralVideo:
         user = _auth_user("u1")
         session = MagicMock()
         job = _make_job(
-            job_id="job-retry4",
-            user_id="u1",
-            status=ViralVideoStatus.FAILED,
-            duration=20,
-            video_ratio="16:9",
-            video_resolution="1080p",
-            video_model="seedance-2.5",
-            credits_prepaid=10.0,
-            credits_transaction_id="txn-old",
-            retry_count=0,
+            job_id="job-retry4", user_id="u1", status=ViralVideoStatus.FAILED,
+            duration=20, video_ratio="16:9", video_resolution="1080p", video_model="seedance-2.5",
+            credits_prepaid=10.0, credits_transaction_id="txn-old", retry_count=0,
         )
         job.credits_prepaid = 10.0
         repo = MagicMock()
@@ -322,9 +280,8 @@ class TestRetryViralVideo:
             patch("app.config.settings") as mock_settings,
             patch("packages.domain.points_service.PointsService", return_value=fake_svc),
             patch("packages.domain.points_rules.resolve_video_dimensions", return_value=(270, 480)),
-            patch(
-                "packages.domain.points_rules.calculate_viral_video_credits_with_breakdown", return_value=(new_est, {})
-            ),
+            patch("packages.domain.points_rules.calculate_viral_video_credits_with_breakdown",
+                  return_value=(new_est, {})),
             patch.object(vv_mod.celery_app, "send_task"),
         ):
             mock_settings.points_enabled = True
@@ -513,9 +470,7 @@ class TestGenerateCopy:
                 patch.object(vv_mod, "_get_job_repo", return_value=repo),
                 patch.object(vv_mod.celery_app, "send_task") as mock_send,
             ):
-                resp = vv_mod.generate_copy(
-                    f"job-regen-{regen_status}", GenerateCopyRequest(), authenticated_user=user, session=session
-                )
+                resp = vv_mod.generate_copy(f"job-regen-{regen_status}", GenerateCopyRequest(), authenticated_user=user, session=session)
             mock_send.assert_called_once()
             job.resume_from_image_analyzed.assert_called()
             assert job.retry_count >= 1
@@ -675,7 +630,7 @@ class TestConfirmCopyPointsDeduction:
         mock_svc.deduct_viral_video.assert_called_once()
         call_args = mock_svc.deduct_viral_video.call_args
         assert call_args.args[0] == "u1"  # user_id
-        assert call_args.args[1] == 5.2  # credits
+        assert call_args.args[1] == 5.2   # credits
         assert call_args.args[2] == "job-pay"  # job_id
         # credits_prepaid / credits_transaction_id 被写入
         assert job.credits_prepaid == 5.2
@@ -852,14 +807,9 @@ class TestEstimateCredits:
         req = EstimateCreditsRequest(model="seedance-2.5", resolution="1080p", ratio="16:9", duration=20)
         user = _auth_user("u1")
         fake_bd = {
-            "tokens": 1000.0,
-            "video_cost": 1.0,
-            "fixed_cost": 0.15,
-            "profit_multiplier": 1.3,
-            "model_price": 70.0,
-            "width": 1920,
-            "height": 1080,
-            "fps": 24,
+            "tokens": 1000.0, "video_cost": 1.0, "fixed_cost": 0.15,
+            "profit_multiplier": 1.3, "model_price": 70.0,
+            "width": 1920, "height": 1080, "fps": 24,
         }
 
         with (
@@ -891,14 +841,9 @@ class TestEstimateCredits:
         req = EstimateCreditsRequest(model="", resolution="720p", ratio="9:16", duration=10)
         user = _auth_user("u1")
         fake_bd = {
-            "tokens": 500.0,
-            "video_cost": 0.5,
-            "fixed_cost": 0.15,
-            "profit_multiplier": 1.3,
-            "model_price": 70.0,
-            "width": 720,
-            "height": 1280,
-            "fps": 24,
+            "tokens": 500.0, "video_cost": 0.5, "fixed_cost": 0.15,
+            "profit_multiplier": 1.3, "model_price": 70.0,
+            "width": 720, "height": 1280, "fps": 24,
         }
 
         with (
@@ -925,14 +870,9 @@ class TestEstimateCredits:
         )
         user = _auth_user("u1")
         fake_bd = {
-            "tokens": 100.0,
-            "video_cost": 0.1,
-            "fixed_cost": 0.15,
-            "profit_multiplier": 1.3,
-            "model_price": 46.0,
-            "width": 480,
-            "height": 480,
-            "fps": 24,
+            "tokens": 100.0, "video_cost": 0.1, "fixed_cost": 0.15,
+            "profit_multiplier": 1.3, "model_price": 46.0,
+            "width": 480, "height": 480, "fps": 24,
         }
 
         with (