fix: 脚本超时优化 + 主题智能匹配

问题A - 超时优化:
1. DoubaoClient httpx timeout 改为显式 Timeout(connect=10, read=T, write=10, pool=5)
2. intent_parsing 单次超时 60s→20s
3. copy_review(reviewer) 添加 timeout=25s
4. 脚本 fast_timeout 150→90s, pro_timeout 150→60s
5. _step_intent_parsing 加 60s 总 deadline
6. _step_script_generation 加 180s 总 deadline
7. lite/fallback 模型与 primary 相同时跳过重复调用

问题B - 主题匹配:
1. 新增 _determine_theme() 根据图片类型+营销目的智能推断主题
2. _fallback_script 动态主题+对应口播文案
3. _empty_copy_result/_validate_and_normalize/_script_from_xml 去除硬编码好物分享
4. intent_parsing prompt 注入 marketing_purpose 和 image_category_hint
5. storyboard prompt 增加主题匹配指导

分支: fix/script-generation-timeout-and-theme

.env.example

@@ -211,10 +211,24 @@ COSYVOICE_CLONE_MODEL=voice-enrollment
 # 用于 AI 文案生成、智能剪辑等需要大模型能力的场景
 
 DOUBAO_API_KEY=your-doubao-api-key
-DOUBAO_MODEL=doubao-seed-1-6-250615
+DOUBAO_MODEL=doubao-seed-2-1-pro-260915
+DOUBAO_FAST_MODEL=doubao-seed-2-1-lite-260915
 DOUBAO_BASE_URL=https://ark.cn-beijing.volces.com/api/v3
 DOUBAO_TIMEOUT=30
 DOUBAO_MAX_RETRIES=2
+# 视觉模型：pro 精度高，lite 速度快（viral-video 商品识别默认用 lite 提速）
+DOUBAO_VISION_MODEL=doubao-seed-2-1-pro-260915
+DOUBAO_VISION_LITE_MODEL=doubao-seed-2-1-lite-260915
+DOUBAO_VISION_USE_LITE=true
+# Embedding 向量化模型
+DOUBAO_EMBEDDING_MODEL=doubao-embedding-vision-251215
+# 视频模型（Seedance 2.5，统一走方舟；真人参考图通过信任链自动 AI 化）
+DOUBAO_VIDEO_MODEL=doubao-seedance-2-5-260628
+DOUBAO_VIDEO_TIMEOUT=480
+DOUBAO_VIDEO_POLL_INTERVAL=10
+# 图片模型（Seedream 5.0 Pro，用于信任链真人 AI 化 + 文生图）
+DOUBAO_IMAGE_MODEL=doubao-seedream-5-0-pro-260628
+DOUBAO_IMAGE_TIMEOUT=120
 
 # ==================== 积分/会员系统 (#1895) ====================
 # 积分系统总开关：默认 false（暂停积分系统）。

.gitea/workflows/ci-pipeline.yml

@@ -1187,6 +1187,14 @@ jobs:
         DOUBAO_MODEL: "${{ secrets.DOUBAO_MODEL }}"
         DOUBAO_BASE_URL: "${{ secrets.DOUBAO_BASE_URL }}"
         DOUBAO_VISION_MODEL: "${{ secrets.DOUBAO_VISION_MODEL }}"
+        DOUBAO_VISION_LITE_MODEL: "${{ secrets.DOUBAO_VISION_LITE_MODEL }}"
+        DOUBAO_VISION_USE_LITE: "${{ secrets.DOUBAO_VISION_USE_LITE }}"
+        DOUBAO_IMAGE_MODEL: "${{ secrets.DOUBAO_IMAGE_MODEL }}"
+        DOUBAO_IMAGE_SIZE: "${{ secrets.DOUBAO_IMAGE_SIZE }}"
+        DOUBAO_IMAGE_TIMEOUT: "${{ secrets.DOUBAO_IMAGE_TIMEOUT }}"
+        DOUBAO_FAST_MODEL: "${{ secrets.DOUBAO_FAST_MODEL }}"
+        DOUBAO_TIMEOUT: "${{ secrets.DOUBAO_TIMEOUT }}"
+        DOUBAO_MAX_RETRIES: "${{ secrets.DOUBAO_MAX_RETRIES }}"
         WECHAT_APP_ID: "${{ secrets.WECHAT_APP_ID }}"
         WECHAT_APP_SECRET: "${{ secrets.WECHAT_APP_SECRET }}"
         TIKHUB_API_KEY: "${{ secrets.TIKHUB_API_KEY }}"

CHANGES.md

@@ -0,0 +1,2 @@
+Mon Oct  5 04:09:11 PM CST 2026
+2198 lite/pro并行竞速 (commit 9699a1f) — CI rebuild trigger Mon Oct  5 08:09:11 AM UTC 2026

alembic/versions/088_viral_video_copy_result.py

@@ -0,0 +1,51 @@
+"""viral video add copy_result + voice/video columns
+
+Revision ID: 088_viral_video_copy_result
+Revises: 087_viral_video_image_analysis
+Create Date: 2026-10-01
+
+v1.6 爆款视频字段补齐：
+- copy_result JSON: 编导分镜脚本完整结构（overview/scene_and_lighting/shots/hard_constraints/negative_prompts/voiceover_script）
+- voice_id/voice_source: TTS 音色参数
+- video_ratio/video_model: Seedance 视频比例/模型
+注意：线上启动也有幂等 ADD COLUMN 补列逻辑 (_ensure_viral_video_columns)，本 migration 提供标准 Alembic 路径，
+两套机制互不冲突（IF NOT EXISTS 等价行为）。
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "088_viral_video_copy_result"
+down_revision = "087_viral_video_image_analysis"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 幂等添加列（通过单独执行 + 异常忽略兼容已由 backfill 补上的环境）
+    cols = [
+        ("voice_id", "VARCHAR(200) NOT NULL DEFAULT ''"),
+        ("voice_source", "VARCHAR(20) NOT NULL DEFAULT ''"),
+        ("video_ratio", "VARCHAR(10) NOT NULL DEFAULT '9:16'"),
+        ("video_model", "VARCHAR(100) NOT NULL DEFAULT ''"),
+        ("copy_result", "JSON"),
+    ]
+    conn = op.get_bind()
+    for name, ddl in cols:
+        try:
+            conn.execute(sa.text(f"ALTER TABLE viral_video_jobs ADD COLUMN IF NOT EXISTS {name} {ddl}"))
+        except Exception:
+            # 不支持 IF NOT EXISTS 的库（如老版本 SQLite）直接尝试 ADD COLUMN，失败则忽略
+            try:
+                conn.execute(sa.text(f"ALTER TABLE viral_video_jobs ADD COLUMN {name} {ddl}"))
+            except Exception:
+                pass
+
+
+def downgrade() -> None:
+    for name in ("copy_result", "video_model", "video_ratio", "voice_source", "voice_id"):
+        try:
+            op.drop_column("viral_video_jobs", name)
+        except Exception:
+            pass

alembic/versions/089_viral_video_cols.py

@@ -0,0 +1,62 @@
+"""viral video add storyboard + generated_copy_text (complement 088)
+
+Revision ID: 089_viral_video_cols
+Revises: 088_viral_video_copy_result
+Create Date: 2026-10-01
+
+#2129 兜底迁移：补齐 _VIRAL_VIDEO_BACKFILL_COLS 中所有列，覆盖
+# watchtower 自动部署未跑历史 migration、且 AUTO_CREATE_SCHEMA=false 时
+# _ensure_viral_video_columns 未执行的场景。
+# 幂等 ADD COLUMN IF NOT EXISTS，已存在则跳过。
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "089_viral_video_cols"
+down_revision = "088_viral_video_copy_result"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # 扩展 alembic_version.version_num 字段长度（原来 VARCHAR(32) 装不下长 revision id）
+    conn = op.get_bind()
+    try:
+        conn.execute(sa.text("ALTER TABLE alembic_version ALTER COLUMN version_num TYPE VARCHAR(256)"))
+    except Exception:
+        pass
+    cols = [
+        ("storyboard", "JSON"),
+        ("generated_copy_text", "TEXT NOT NULL DEFAULT ''"),
+        ("voice_id", "VARCHAR(200) NOT NULL DEFAULT ''"),
+        ("voice_source", "VARCHAR(20) NOT NULL DEFAULT ''"),
+        ("video_ratio", "VARCHAR(10) NOT NULL DEFAULT '9:16'"),
+        ("video_model", "VARCHAR(100) NOT NULL DEFAULT ''"),
+        ("copy_result", "JSON"),
+    ]
+    for name, ddl in cols:
+        try:
+            conn.execute(sa.text(f"ALTER TABLE viral_video_jobs ADD COLUMN IF NOT EXISTS {name} {ddl}"))
+        except Exception:
+            try:
+                conn.execute(sa.text(f"ALTER TABLE viral_video_jobs ADD COLUMN {name} {ddl}"))
+            except Exception:
+                pass
+
+
+def downgrade() -> None:
+    for name in (
+        "copy_result",
+        "video_model",
+        "video_ratio",
+        "voice_source",
+        "voice_id",
+        "generated_copy_text",
+        "storyboard",
+    ):
+        try:
+            op.drop_column("viral_video_jobs", name)
+        except Exception:
+            pass

alembic/versions/090_viral_video_phase_msg.py

@@ -0,0 +1,35 @@
+"""viral video add phase_message column (#2134)
+
+Revision ID: 090_viral_video_phase_msg
+Revises: 089_viral_video_cols
+Create Date: 2026-10-02
+
+#2134 阶段细粒度提示：viral_video 表新增 phase_message 列（中文阶段提示文案）。
+current_stage 列已在之前版本存在，本迁移只补 phase_message。
+幂等 ADD COLUMN IF NOT EXISTS。
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "090_viral_video_phase_msg"
+down_revision = "089_viral_video_cols"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # SQLite/PostgreSQL 兼容的幂等添加列
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+    cols = {c["name"] for c in inspector.get_columns("viral_video_jobs")}
+    if "phase_message" not in cols:
+        op.add_column(
+            "viral_video_jobs",
+            sa.Column("phase_message", sa.String(length=500), nullable=False, server_default=""),
+        )
+
+
+def downgrade() -> None:
+    op.drop_column("viral_video_jobs", "phase_message")

alembic/versions/091_viral_video_stage.py

@@ -0,0 +1,49 @@
+"""viral video add current_stage column (#2137 follow-up)
+
+Revision ID: 091_viral_video_stage
+Revises: 090_viral_video_phase_msg
+Create Date: 2026-10-02
+
+#2137 follow-up fix: 090 migration missed current_stage column on viral_video_jobs,
+causing UndefinedColumn errors and 500s on all authenticated viral-video endpoints.
+Idempotently add current_stage and double-check phase_message.
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "091_viral_video_stage"
+down_revision = "090_viral_video_phase_msg"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+    cols = {c["name"] for c in inspector.get_columns("viral_video_jobs")}
+    if "current_stage" not in cols:
+        op.add_column(
+            "viral_video_jobs",
+            sa.Column(
+                "current_stage",
+                sa.String(length=200),
+                nullable=False,
+                server_default="",
+            ),
+        )
+    if "phase_message" not in cols:
+        op.add_column(
+            "viral_video_jobs",
+            sa.Column(
+                "phase_message",
+                sa.String(length=500),
+                nullable=False,
+                server_default="",
+            ),
+        )
+
+
+def downgrade() -> None:
+    op.drop_column("viral_video_jobs", "current_stage")

alembic/versions/092_viral_video_heartbeat.py

@@ -0,0 +1,42 @@
+"""viral_video_jobs 增加 heartbeat_at 列（worker 心跳，用于僵尸任务超时回收）
+
+Revision ID: 092_viral_video_heartbeat
+Revises: 091_viral_video_stage
+Create Date: 2026-10-02
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "092_viral_video_heartbeat"
+down_revision = "091_viral_video_stage"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+    cols = {c["name"] for c in inspector.get_columns("viral_video_jobs")}
+    if "heartbeat_at" not in cols:
+        op.add_column("viral_video_jobs", sa.Column("heartbeat_at", sa.DateTime(), nullable=True))
+        op.execute(
+            "UPDATE viral_video_jobs SET heartbeat_at = updated_at " "WHERE status = 'running' AND heartbeat_at IS NULL"
+        )
+        try:
+            op.create_index("ix_viral_video_jobs_heartbeat_at", "viral_video_jobs", ["heartbeat_at"])
+        except Exception:
+            pass
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+    cols = {c["name"] for c in inspector.get_columns("viral_video_jobs")}
+    if "heartbeat_at" in cols:
+        try:
+            op.drop_index("ix_viral_video_jobs_heartbeat_at", table_name="viral_video_jobs")
+        except Exception:
+            pass
+        op.drop_column("viral_video_jobs", "heartbeat_at")

alembic/versions/093_viral_video_pricing_points_float.py

@@ -0,0 +1,87 @@
+"""viral_video 动态积分定价 + 积分字段从 Integer 改为 Float (#2151)
+
+Revision ID: 093
+Revises: 092_viral_video_heartbeat
+Create Date: 2026-10-02
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "093"
+down_revision = "092_viral_video_heartbeat"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+
+    # 1) points_accounts 三列 Integer -> Float
+    pa_cols = {c["name"]: c for c in inspector.get_columns("points_accounts")}
+    for col in ("balance", "total_earned", "total_spent"):
+        if col in pa_cols:
+            op.alter_column(
+                "points_accounts",
+                col,
+                existing_type=sa.Integer(),
+                type_=sa.Float(),
+                existing_nullable=False,
+            )
+
+    # 2) points_transactions amount/balance_after Integer -> Float
+    pt_cols = {c["name"]: c for c in inspector.get_columns("points_transactions")}
+    for col in ("amount", "balance_after"):
+        if col in pt_cols:
+            op.alter_column(
+                "points_transactions",
+                col,
+                existing_type=sa.Integer(),
+                type_=sa.Float(),
+                existing_nullable=False,
+            )
+
+    # 3) users.points_balance Integer -> Float
+    user_cols = {c["name"]: c for c in inspector.get_columns("users")}
+    if "points_balance" in user_cols:
+        op.alter_column(
+            "users",
+            "points_balance",
+            existing_type=sa.Integer(),
+            type_=sa.Float(),
+            existing_nullable=False,
+        )
+
+    # 4) viral_video_jobs.credits_cost Integer -> Float
+    vv_cols = {c["name"]: c for c in inspector.get_columns("viral_video_jobs")}
+    if "credits_cost" in vv_cols:
+        op.alter_column(
+            "viral_video_jobs",
+            "credits_cost",
+            existing_type=sa.Integer(),
+            type_=sa.Float(),
+            existing_nullable=False,
+        )
+
+    # 5) viral_video_jobs 新增列
+    if "video_resolution" not in vv_cols:
+        op.add_column(
+            "viral_video_jobs",
+            sa.Column("video_resolution", sa.String(20), nullable=False, server_default="720p"),
+        )
+    if "credits_prepaid" not in vv_cols:
+        op.add_column(
+            "viral_video_jobs",
+            sa.Column("credits_prepaid", sa.Float(), nullable=False, server_default="0"),
+        )
+    if "credits_transaction_id" not in vv_cols:
+        op.add_column(
+            "viral_video_jobs",
+            sa.Column("credits_transaction_id", sa.String(36), nullable=False, server_default=""),
+        )
+
+
+def downgrade() -> None:
+    pass

alembic/versions/094_viral_video_pre_trusted.py

@@ -0,0 +1,31 @@
+"""viral_video_jobs 增加 pre_trusted_images 列（信任链Seedream预热结果）
+
+Revision ID: 094_viral_video_pre_trusted
+Revises: 093_viral_video_pricing_points_float
+Create Date: 2026-10-04
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "094_viral_video_pre_trusted"
+down_revision = "093"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+    cols = {c["name"] for c in inspector.get_columns("viral_video_jobs")}
+    if "pre_trusted_images" not in cols:
+        op.add_column("viral_video_jobs", sa.Column("pre_trusted_images", sa.Text(), nullable=True))
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    inspector = sa.inspect(conn)
+    cols = {c["name"] for c in inspector.get_columns("viral_video_jobs")}
+    if "pre_trusted_images" in cols:
+        op.drop_column("viral_video_jobs", "pre_trusted_images")

alembic/versions/095_viral_video_prompt_templates.py

@@ -0,0 +1,102 @@
+"""爆款视频 Prompt 模板配置表（#2040）。
+
+086 曾预留同名旧表（id varchar / content / variables json），从未被业务使用；
+本迁移将其替换为 #2040 新结构。
+
+Revision ID: 095_viral_video_prompt_templates
+Revises: 094_viral_video_pre_trusted
+Create Date: 2026-10-04
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "095_viral_video_prompt_templates"
+down_revision = "094_viral_video_pre_trusted"
+branch_labels = None
+depends_on = None
+
+
+def _table_exists(conn, name: str) -> bool:
+    return name in sa.inspect(conn).get_table_names()
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    # 086 预留的旧结构表：先删除（无业务数据、无任何引用）
+    if _table_exists(conn, "viral_video_prompt_templates"):
+        op.drop_table("viral_video_prompt_templates")
+
+    op.create_table(
+        "viral_video_prompt_templates",
+        sa.Column("id", sa.Integer, primary_key=True, autoincrement=True),
+        sa.Column("name", sa.String(128), nullable=False),
+        sa.Column("prompt_type", sa.String(32), nullable=False),
+        sa.Column("version", sa.Integer, nullable=False, server_default="1"),
+        sa.Column("system_prompt", sa.Text, nullable=False),
+        sa.Column("user_prompt_template", sa.Text, nullable=False),
+        sa.Column("example_output", sa.Text, nullable=True),
+        sa.Column("is_active", sa.Boolean, nullable=False, server_default=sa.text("true")),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.func.now(),
+            nullable=False,
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.func.now(),
+            nullable=False,
+        ),
+    )
+    op.create_index(
+        "ix_vvpt_type_active",
+        "viral_video_prompt_templates",
+        ["prompt_type", "is_active"],
+    )
+    op.create_index(
+        "uq_vvpt_type_version",
+        "viral_video_prompt_templates",
+        ["prompt_type", "version"],
+        unique=True,
+    )
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    if _table_exists(conn, "viral_video_prompt_templates"):
+        op.drop_index("uq_vvpt_type_version", table_name="viral_video_prompt_templates")
+        op.drop_index("ix_vvpt_type_active", table_name="viral_video_prompt_templates")
+        op.drop_table("viral_video_prompt_templates")
+
+    # 恢复 086 的旧预留结构
+    op.create_table(
+        "viral_video_prompt_templates",
+        sa.Column("id", sa.String(36), primary_key=True),
+        sa.Column("prompt_type", sa.String(50), nullable=False, index=True),
+        sa.Column("name", sa.String(200), nullable=False),
+        sa.Column("content", sa.Text, nullable=False, server_default=""),
+        sa.Column("variables", sa.JSON, nullable=False, server_default="[]"),
+        sa.Column("version", sa.Integer, nullable=False, server_default="1"),
+        sa.Column(
+            "is_active",
+            sa.Boolean,
+            nullable=False,
+            server_default=sa.text("true"),
+            index=True,
+        ),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+    )

alembic/versions/096_feature_billing_fields.py

@@ -0,0 +1,61 @@
+"""功能计费积分字段（爆款/对口型/智能剪辑 DB 化计费）。
+
+给 gpu_lipsync_tasks / generation_tasks / lipsync_jobs 三张表加积分字段：
+- credits_prepaid: 提交任务时预扣积分
+- credits_cost: 最终结算积分
+- credits_transaction_id: 预扣流水 ID
+
+注意：feature_pricing_configs 配置表由 xiaoxia-admin 侧 migration 建立，
+本仓库只读，不在此创建。
+
+Revision ID: 096_feature_billing_fields
+Revises: 095_viral_video_prompt_templates
+Create Date: 2026-10-05
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "096_feature_billing_fields"
+down_revision = "095_viral_video_prompt_templates"
+branch_labels = None
+depends_on = None
+
+_TABLES = ("gpu_lipsync_tasks", "generation_tasks", "lipsync_jobs")
+_COLUMNS = (
+    ("credits_prepaid", sa.Float(), "0"),
+    ("credits_cost", sa.Float(), "0"),
+    ("credits_transaction_id", sa.String(36), ""),
+)
+
+
+def _table_exists(conn, name: str) -> bool:
+    return name in sa.inspect(conn).get_table_names()
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    for table in _TABLES:
+        if not _table_exists(conn, table):
+            continue
+        existing = {c["name"] for c in sa.inspect(conn).get_columns(table)}
+        for col_name, col_type, default in _COLUMNS:
+            if col_name in existing:
+                continue
+            op.add_column(
+                table,
+                sa.Column(col_name, col_type, nullable=False, server_default=default),
+            )
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    for table in _TABLES:
+        if not _table_exists(conn, table):
+            continue
+        existing = {c["name"] for c in sa.inspect(conn).get_columns(table)}
+        for col_name, _col_type, _default in _COLUMNS:
+            if col_name not in existing:
+                continue
+            op.drop_column(table, col_name)

alembic/versions/099_ai_model_router_seed.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+"""099: AI 模型路由层 seed — 补齐缺失模型和能力配置.
+
+幂等：所有 INSERT 先检查存在性。
+- ai_models: 补齐 qwen3.7-plus, seedream, seedance, embedding, wan3.0 等
+- ai_capability_configs: 补齐 image_generation, video_generation, embedding
+- 更新已有 capability 的 lite_model_id
+"""
+
+import json
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "099_ai_model_router_seed"
+down_revision = "098_viral_video_image_analysis_v5"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+
+    # CI 环境下 ai_models 表可能尚未创建（由 ORM 自动建表，非 migration）
+    # 如果表不存在则跳过 seed，由应用启动时 ORM 建表后首次访问时生效
+    table_check = conn.execute(sa.text("SELECT to_regclass('public.ai_models')")).scalar()
+    if not table_check:
+        # ai_models 表不存在，跳过所有 seed（CI 环境）
+        return
+
+    # ── 1. 补齐 ai_models 缺失记录 ────────────────────────────────────────────
+    existing_models = {
+        row[0]
+        for row in conn.execute(
+            sa.text("SELECT model_key FROM ai_models WHERE deleted_at IS NULL")
+        ).fetchall()
+    }
+
+    # 从已有 active 记录获取 API key（复用，不硬编码）
+    dashscope_key_row = conn.execute(
+        sa.text(
+            "SELECT api_key FROM ai_models WHERE provider='dashscope' AND deleted_at IS NULL AND api_key IS NOT NULL AND api_key != '' LIMIT 1"
+        )
+    ).first()
+    dashscope_key = dashscope_key_row[0] if dashscope_key_row else ""
+
+    volcengine_key_row = conn.execute(
+        sa.text(
+            "SELECT api_key FROM ai_models WHERE provider='volcengine' AND deleted_at IS NULL AND api_key IS NOT NULL AND api_key != '' LIMIT 1"
+        )
+    ).first()
+    volcengine_key = volcengine_key_row[0] if volcengine_key_row else ""
+
+    new_models = [
+        {
+            "model_key": "qwen3.7-plus",
+            "name": "通义千问3.7 Plus（VLM 兜底）",
+            "provider": "dashscope",
+            "api_key": dashscope_key,
+            "api_base": "https://dashscope.aliyuncs.com/compatible-mode/v1",
+            "description": "阿里云百炼 Qwen3.7 Plus 多模态模型，用于 VLM 兜底分析",
+        },
+        {
+            "model_key": "doubao-seedream-5-0-flash-260915",
+            "name": "Seedream 5.0 Flash（图片生成）",
+            "provider": "volcengine",
+            "api_key": volcengine_key,
+            "api_base": "https://ark.cn-beijing.volces.com/api/v3",
+            "description": "火山引擎 Seedream 5.0 Flash 文生图模型",
+        },
+        {
+            "model_key": "doubao-seedance-2-5-260628",
+            "name": "Seedance 2.5（视频生成）",
+            "provider": "volcengine",
+            "api_key": volcengine_key,
+            "api_base": "https://ark.cn-beijing.volces.com/api/v3",
+            "description": "火山引擎 Seedance 2.5 图/文生视频模型",
+        },
+        {
+            "model_key": "doubao-embedding-vision-251215",
+            "name": "豆包多模态向量嵌入",
+            "provider": "volcengine",
+            "api_key": volcengine_key,
+            "api_base": "https://ark.cn-beijing.volces.com/api/v3",
+            "description": "火山引擎豆包多模态向量嵌入模型",
+        },
+        {
+            "model_key": "wan3.0-video",
+            "name": "Wan 3.0 视频生成",
+            "provider": "dashscope",
+            "api_key": dashscope_key,
+            "api_base": "https://dashscope.aliyuncs.com/api/v1",
+            "description": "阿里云百炼 Wan 3.0 视频生成模型",
+        },
+        {
+            "model_key": "doubao-seed-2-1-pro-260915",
+            "name": "豆包 Seed 2.1 Pro（高精度推理）",
+            "provider": "volcengine",
+            "api_key": volcengine_key,
+            "api_base": "https://ark.cn-beijing.volces.com/api/v3",
+            "description": "火山引擎豆包 Seed 2.1 Pro 深度思考+多模态",
+        },
+    ]
+
+    for m in new_models:
+        if m["model_key"] not in existing_models:
+            conn.execute(
+                sa.text(
+                    """
+                    INSERT INTO ai_models (id, name, provider, model_key, api_key, api_base, description, status, is_default, usage_today, created_at, updated_at)
+                    VALUES (gen_random_uuid()::text, :name, :provider, :model_key, :api_key, :api_base, :description, 'active', false, 0, now(), now())
+                    """
+                ),
+                m,
+            )
+
+    # ── 2. 补齐 ai_capability_configs 缺失项 ──────────────────────────────────
+    cap_table_check = conn.execute(sa.text("SELECT to_regclass('public.ai_capability_configs')")).scalar()
+    if not cap_table_check:
+        return
+
+    existing_caps = {
+        row[0]
+        for row in conn.execute(
+            sa.text("SELECT capability_key FROM ai_capability_configs")
+        ).fetchall()
+    }
+
+    def _get_model_id(model_key: str) -> str | None:
+        row = conn.execute(
+            sa.text(
+                "SELECT id FROM ai_models WHERE model_key = :key AND deleted_at IS NULL AND status = 'active' LIMIT 1"
+            ),
+            {"key": model_key},
+        ).first()
+        return row[0] if row else None
+
+    # image_generation
+    if "image_generation" not in existing_caps:
+        mid = _get_model_id("doubao-seedream-5-0-flash-260915")
+        if mid:
+            conn.execute(
+                sa.text(
+                    """
+                    INSERT INTO ai_capability_configs (id, capability_key, capability_name, primary_model_id, timeout_seconds, max_retries, concurrency, extra_params, is_enabled, created_at, updated_at)
+                    VALUES (gen_random_uuid()::text, :ck, :cn, :pm, 60, 1, 2, :ep, true, now(), now())
+                    """
+                ),
+                {
+                    "ck": "image_generation",
+                    "cn": "图片生成（Seedream）",
+                    "pm": mid,
+                    "ep": json.dumps({"size": "1K"}),
+                },
+            )
+
+    # video_generation
+    if "video_generation" not in existing_caps:
+        mid = _get_model_id("doubao-seedance-2-5-260628")
+        fb_mid = _get_model_id("wan3.0-video")
+        if mid:
+            conn.execute(
+                sa.text(
+                    """
+                    INSERT INTO ai_capability_configs (id, capability_key, capability_name, primary_model_id, fallback_model_id, timeout_seconds, max_retries, concurrency, extra_params, is_enabled, created_at, updated_at)
+                    VALUES (gen_random_uuid()::text, :ck, :cn, :pm, :fm, 600, 1, 1, :ep, true, now(), now())
+                    """
+                ),
+                {
+                    "ck": "video_generation",
+                    "cn": "视频生成（Seedance/Wan）",
+                    "pm": mid,
+                    "fm": fb_mid,
+                    "ep": json.dumps({}),
+                },
+            )
+
+    # embedding
+    if "embedding" not in existing_caps:
+        mid = _get_model_id("doubao-embedding-vision-251215")
+        if mid:
+            conn.execute(
+                sa.text(
+                    """
+                    INSERT INTO ai_capability_configs (id, capability_key, capability_name, primary_model_id, timeout_seconds, max_retries, concurrency, extra_params, is_enabled, created_at, updated_at)
+                    VALUES (gen_random_uuid()::text, :ck, :cn, :pm, 30, 2, 5, :ep, true, now(), now())
+                    """
+                ),
+                {
+                    "ck": "embedding",
+                    "cn": "向量嵌入",
+                    "pm": mid,
+                    "ep": json.dumps({}),
+                },
+            )
+
+    # ── 3. 更新 image_analysis 的 lite_model_id ─────────────────────────────
+    lite_model_id = _get_model_id("qwen3.8-flash")
+    if lite_model_id:
+        conn.execute(
+            sa.text(
+                "UPDATE ai_capability_configs SET lite_model_id = :lite WHERE capability_key = 'image_analysis' AND lite_model_id IS NULL"
+            ),
+            {"lite": lite_model_id},
+        )
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    # 安全检查表是否存在
+    table_check = conn.execute(sa.text("SELECT to_regclass('public.ai_models')")).scalar()
+    if not table_check:
+        return
+    conn.execute(
+        sa.text("DELETE FROM ai_capability_configs WHERE capability_key IN ('image_generation', 'video_generation', 'embedding')")
+    )
+    conn.execute(
+        sa.text(
+            "DELETE FROM ai_models WHERE model_key IN ('qwen3.7-plus', 'doubao-seedream-5-0-flash-260915', 'doubao-seedance-2-5-260628', 'doubao-embedding-vision-251215', 'wan3.0-video', 'doubao-seed-2-1-pro-260915') AND deleted_at IS NULL"
+        )
+    )

alembic/versions/100_fix_capability_model_bindings.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+"""100: 修正已有 capability 的模型绑定.
+
+幂等：仅当 primary_model_id 当前绑定到旧模型 (doubao-seed-1-6) 时才更新，
+避免覆盖用户在后台的自定义配置。
+
+- 更新 5 个 LLM capability (intent_parsing, copy_fusion, storyboard, copy_review, asset_classify)
+  的 primary_model_id 从 doubao-seed-1-6 改为 doubao-seed-2-1-pro-260915
+- 更新 image_analysis 的 primary/lite/fallback 模型绑定
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "100_fix_capability_model_bindings"
+down_revision = "099_ai_model_router_seed"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+
+    # Check tables exist
+    table_check = conn.execute(sa.text("SELECT to_regclass('public.ai_models')")).scalar()
+    if not table_check:
+        return
+
+    config_table_check = conn.execute(sa.text("SELECT to_regclass('public.ai_capability_configs')")).scalar()
+    if not config_table_check:
+        return
+
+    # Look up model IDs by model_key (not hardcoded UUIDs)
+    pro_model_row = conn.execute(
+        sa.text(
+            "SELECT id FROM ai_models WHERE model_key = 'doubao-seed-2-1-pro-260915' AND deleted_at IS NULL LIMIT 1"
+        )
+    ).first()
+    if not pro_model_row:
+        return
+    pro_model_id = pro_model_row[0]
+
+    old_model_row = conn.execute(
+        sa.text("SELECT id FROM ai_models WHERE model_key = 'doubao-seed-1-6-250615' LIMIT 1")
+    ).first()
+    old_model_id = old_model_row[0] if old_model_row else None
+
+    llm_capabilities = [
+        "intent_parsing",
+        "copy_fusion",
+        "storyboard",
+        "copy_review",
+        "asset_classify",
+    ]
+
+    for cap_key in llm_capabilities:
+        if old_model_id:
+            conn.execute(
+                sa.text(
+                    "UPDATE ai_capability_configs SET primary_model_id = :new_id, updated_at = NOW() "
+                    "WHERE capability_key = :cap_key AND primary_model_id = :old_id"
+                ),
+                {"new_id": pro_model_id, "old_id": old_model_id, "cap_key": cap_key},
+            )
+
+    # Update image_analysis
+    qwen38_row = conn.execute(
+        sa.text("SELECT id FROM ai_models WHERE model_key = 'qwen3.8-flash' AND deleted_at IS NULL LIMIT 1")
+    ).first()
+    qwen37_row = conn.execute(
+        sa.text("SELECT id FROM ai_models WHERE model_key = 'qwen3.7-plus' AND deleted_at IS NULL LIMIT 1")
+    ).first()
+
+    if qwen38_row and qwen37_row:
+        qwen38_id = qwen38_row[0]
+        qwen37_id = qwen37_row[0]
+
+        current_ia = conn.execute(
+            sa.text(
+                "SELECT primary_model_id, lite_model_id, fallback_model_id "
+                "FROM ai_capability_configs WHERE capability_key = 'image_analysis'"
+            )
+        ).first()
+
+        if current_ia:
+            current_primary, current_lite, current_fallback = current_ia
+            updates = {}
+            if current_primary != qwen38_id:
+                updates["primary_model_id"] = qwen38_id
+            if current_lite != qwen38_id:
+                updates["lite_model_id"] = qwen38_id
+            if current_fallback != qwen37_id:
+                updates["fallback_model_id"] = qwen37_id
+
+            if updates:
+                set_clause = ", ".join([f"{k} = :{k}" for k in updates.keys()])
+                set_clause += ", updated_at = NOW()"
+                updates["cap_key"] = "image_analysis"
+                conn.execute(
+                    sa.text(f"UPDATE ai_capability_configs SET {set_clause} WHERE capability_key = :cap_key"),
+                    updates,
+                )
+
+
+def downgrade() -> None:
+    pass

alembic/versions/101_qwen_vl_plus_and_max_tokens.py

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""101: 补齐 qwen-vl-plus 视觉模型并修正 image_analysis 绑定与 max_tokens.
+
+背景：
+- qwen-vl-plus 做图片识别时返回 JSON 约 500-600 tokens，旧硬编码
+  max_tokens=350 导致 JSON 被截断、解析失败返回"未识别"。
+- 代码侧已移除硬编码，改由 capability 的 DB 配置决定 max_tokens。
+
+幂等：
+- qwen-vl-plus 已存在则不插入；
+- 仅当 image_analysis 当前 primary_model 不是 qwen-vl-plus 时才更新绑定，
+  避免覆盖后台手动配置。
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "101_qwen_vl_plus_and_max_tokens"
+down_revision = "100_fix_capability_model_bindings"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+
+    models_table = conn.execute(sa.text("SELECT to_regclass('public.ai_models')")).scalar()
+    if not models_table:
+        return
+
+    caps_table = conn.execute(sa.text("SELECT to_regclass('public.ai_capability_configs')")).scalar()
+    if not caps_table:
+        return
+
+    # ── c. 补全其他 capability 的 max_tokens 默认值（幂等）──────────────────
+    # 放在 image_analysis 特定逻辑之前，确保任何分支 return 都不会跳过本段。
+    # 仅在当前值为 NULL 或过小 (<100) 时更新，不覆盖已有合理配置。
+    # embedding / tts / voice_clone 不走 chat 接口，无需设置。
+    default_max_tokens = {
+        "intent_parsing": 500,
+        "copy_fusion": 2500,
+        "storyboard": 4000,
+        "copy_review": 1000,
+        "asset_classify": 500,
+        "image_generation": 500,
+        "video_generation": 500,
+    }
+    for cap_key, mt in default_max_tokens.items():
+        conn.execute(
+            sa.text(
+                "UPDATE ai_capability_configs "
+                "SET max_tokens = :mt, updated_at = now() "
+                "WHERE capability_key = :key "
+                "AND (max_tokens IS NULL OR max_tokens < 100)"
+            ),
+            {"mt": mt, "key": cap_key},
+        )
+
+    # ── a. 确保 qwen-vl-plus 模型存在 ────────────────────────────────────────
+    conn.execute(sa.text("""
+            INSERT INTO ai_models (id, name, provider, model_key, api_key, api_base,
+                                   description, status, is_default, usage_today,
+                                   created_at, updated_at)
+            SELECT gen_random_uuid()::text,
+                   '通义千问VL Plus',
+                   'dashscope',
+                   'qwen-vl-plus',
+                   COALESCE(
+                       (SELECT api_key FROM ai_models
+                        WHERE provider = 'dashscope' AND deleted_at IS NULL
+                          AND api_key IS NOT NULL AND api_key != ''
+                        LIMIT 1),
+                       ''
+                   ),
+                   'https://dashscope.aliyuncs.com/compatible-mode/v1',
+                   '阿里云视觉理解模型（图片识别/分析）',
+                   'active', false, 0, now(), now()
+            WHERE NOT EXISTS (
+                SELECT 1 FROM ai_models
+                WHERE model_key = 'qwen-vl-plus' AND deleted_at IS NULL
+            )
+            """))
+
+    qwen_vl_row = conn.execute(
+        sa.text(
+            "SELECT id FROM ai_models WHERE model_key = 'qwen-vl-plus' "
+            "AND deleted_at IS NULL AND status = 'active' LIMIT 1"
+        )
+    ).first()
+    if not qwen_vl_row:
+        return
+    qwen_vl_id = qwen_vl_row[0]
+
+    qwen37_row = conn.execute(
+        sa.text(
+            "SELECT id FROM ai_models WHERE model_key = 'qwen3.7-plus' "
+            "AND deleted_at IS NULL AND status = 'active' LIMIT 1"
+        )
+    ).first()
+    qwen37_id = qwen37_row[0] if qwen37_row else None
+
+    # ── b. 仅当当前 primary 不是 qwen-vl-plus 时修正绑定与 max_tokens ───────
+    current = conn.execute(
+        sa.text(
+            "SELECT primary_model_id, lite_model_id, fallback_model_id, max_tokens "
+            "FROM ai_capability_configs WHERE capability_key = 'image_analysis'"
+        )
+    ).first()
+
+    if current is None:
+        # capability 不存在则创建
+        conn.execute(
+            sa.text("""
+                INSERT INTO ai_capability_configs
+                    (id, capability_key, capability_name, primary_model_id,
+                     lite_model_id, fallback_model_id, timeout_seconds,
+                     max_retries, max_tokens, concurrency, extra_params,
+                     is_enabled, created_at, updated_at)
+                VALUES (gen_random_uuid()::text, 'image_analysis', '图片分析',
+                        :primary, :primary, :fallback, 30, 1, 1000, 2,
+                        '{}'::jsonb, true, now(), now())
+                """),
+            {"primary": qwen_vl_id, "fallback": qwen37_id},
+        )
+        return
+
+    current_primary = current[0]
+    if current_primary == qwen_vl_id:
+        # 已经绑定 qwen-vl-plus：视为后台/数据迁移已处理，不覆盖任何配置
+        return
+
+    set_parts = [
+        "primary_model_id = :vl_id",
+        "lite_model_id = :vl_id",
+        "max_tokens = 1000",
+        "updated_at = now()",
+    ]
+    params: dict = {"vl_id": qwen_vl_id}
+    if qwen37_id is not None:
+        set_parts.insert(2, "fallback_model_id = :qwen37_id")
+        params["qwen37_id"] = qwen37_id
+
+    conn.execute(
+        sa.text(
+            "UPDATE ai_capability_configs SET " + ", ".join(set_parts) + " WHERE capability_key = 'image_analysis'"
+        ),
+        params,
+    )
+
+
+def downgrade() -> None:
+    pass

alembic/versions/102_image_analysis_max_tokens_1500.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""102: image_analysis max_tokens 1200 -> 1500.
+
+v6 prompt 更长、字段更多，旧 max_tokens 容易截断 JSON。
+仅在 image_analysis 当前 max_tokens < 1500 时更新（幂等，不覆盖后台已调到 >=1500 的配置）。
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "102_image_analysis_max_tokens_1500"
+down_revision = "101_qwen_vl_plus_and_max_tokens"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+
+    caps_table = conn.execute(sa.text("SELECT to_regclass('public.ai_capability_configs')")).scalar()
+    if not caps_table:
+        return
+
+    conn.execute(
+        sa.text(
+            "UPDATE ai_capability_configs "
+            "SET max_tokens = 1500, updated_at = now() "
+            "WHERE capability_key = 'image_analysis' "
+            "AND (max_tokens IS NULL OR max_tokens < 1500)"
+        )
+    )
+
+
+def downgrade() -> None:
+    pass

alembic/versions/103_v7_prompt_and_tokens_3000.py

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+"""image_analysis v7 prompt + max_tokens 3000 + max_retries 3
+
+Revision ID: 103_v7_prompt_and_tokens_3000
+Revises: 102_image_analysis_max_tokens_1500
+Create Date: 2026-10-07
+
+变更：
+1. 插入v7精简prompt（~1KB，v6 ~4.5KB，删除few-shot/冗长规则，减少输出token占用），设为active
+2. v6停用（is_active=False），保留历史
+3. image_analysis capability: max_tokens 1500→3000，max_retries 1→3
+
+ai_capability_configs 由应用 create_all 创建，全新 alembic-only 库可能不存在，
+故第3步做 to_regclass 守卫（同 102）。
+"""
+
+from sqlalchemy import text
+
+from alembic import op
+
+revision = "103_v7_prompt_and_tokens_3000"
+down_revision = "102_image_analysis_max_tokens_1500"
+branch_labels = None
+depends_on = None
+
+V7_SYSTEM = """# 角色
+你是一位专业的图片分析师，擅长准确识别图片中的场景、人物、物体、文字、氛围。
+
+# 任务
+对用户上传的图片逐张分析，描述你看到的内容，输出JSON格式。
+
+## 技能
+
+### 技能1：判断图片类型
+判断图片属于哪种类型，type字段填对应的英文值：
+- 商品图（product）：单个或多个商品、产品包装
+- 门店场景图（store）：店铺内部、门头招牌、货架陈列
+- 人物图（person）：人物形象、穿搭造型、肖像照片
+- 风景图（scene）：风景、动物、美食、街景
+- 其他（other）：以上都不是
+
+### 技能2：描述通用信息
+不管什么图都要描述：
+- type：图片类型，填product/store/person/scene/other其中一个
+- scene：一句话描述场景，例如"理疗养生店内部，摆着多张理疗床和产品货架"
+- mood：整体氛围，2-4个词，例如"整洁专业"、"热闹温馨"
+- colors：主要颜色，最多5个，写具体颜色名（亮红色/米白色/深蓝色，不写笼统的红色蓝色）
+- visible_text：图片里看到的文字，说明什么字、在什么位置，最多5条；没看到就空数组
+- lighting：光线情况，例如"明亮柔光"、"自然光"、"室内暖黄灯"
+- composition：怎么拍的，例如"居中特写"、"中景平视"、"俯拍"
+- has_person：有没有人，true或false
+
+### 技能3：描述门店场景
+如果是门店场景图（type="store"），还要描述：
+- store_type：什么类型的店，例如"养生馆"、"便利店"、"餐饮店"、"母婴店"
+- brand_signage：招牌上写了什么字、有什么品牌标识
+- visual_elements：看到哪些显眼的东西（招牌样式、灯光、货架、商品陈列、海报、收银台等），最多8个
+- product_categories：看到哪些品类的商品，例如"饮料零食"、"养生产品"
+- promotion_elements：有没有促销活动（打折海报、满减吊旗等），没有就空数组
+- atmosphere：店内什么氛围，例如"亲民生活化"、"老字号专业感"
+- cleanliness：店内干净程度，例如"干净整洁"、"货架整齐"
+- 看到顾客或店员要描述他们在做什么，has_person填true
+
+### 技能4：描述商品
+如果是商品图（type="product"），逐个商品描述：
+- product_name：商品名称，尽量具体，例如"OMO奥妙除菌除螨洗衣液"；看不出来填null
+- brand：什么牌子，看不出来填null
+- category：类目，从以下选一个：服饰鞋包/美妆/数码/食品/家居清洁/母婴/配饰/其他
+- package_type：什么包装，例如"瓶装"、"盒装"、"罐装"、"袋装"、"多瓶装"
+- package_color：包装主要颜色，写具体色（亮红色不写红色）
+- body_shape：瓶身或包装形状，例如"圆润胖瓶"、"竖款带把手瓶身"
+- label_design：标签设计，例如"红色标签印白色品牌logo"
+- key_text_on_package：包装上最显眼的文字（品牌名、功能词、卖点词），最多5个
+- product_features：包装特征，3-6个短语，包含颜色、瓶盖、形状、标签图案
+- key_selling_points：核心卖点，1-3个短语
+
+### 技能5：描述人物
+如果是人物图（type="person"），描述：
+- person_count：几个人
+- gender：性别（男/女/无法判断）
+- age_range：年龄段（儿童/青少年/青年/中年/老年/无法判断）
+- outfit_style：穿搭风格，例如"休闲日常"、"通勤商务"、"街头潮流"
+- upper_wear：上装（颜色+款式+材质），穿裙装不填
+- lower_wear：下装（颜色+款式+版型），穿裙装不填
+- dress_wear：裙装描述，穿上下装不填
+- outerwear：外套
+- shoes：鞋子
+- bag：包袋，没有填null
+- accessories：配饰（眼镜/帽子/项链/耳环/手表/手链/围巾/腰带等），没有填空数组
+- hairstyle：发型
+- makeup：妆容，男生或看不出填null
+- expression：表情，例如"微笑看镜头"、"冷酷无表情"
+- pose：姿势动作，例如"身直立正对镜头"、"单手撩发"
+- body_type：身材，例如"纤细苗条"、"高挑身材"、"丰满匀称"
+- portrait_prompt：80-150字详细描述人物形象（后面用来AI生成肖像图），要写清年龄段、穿搭完整细节、发型发色、妆容、表情、姿势、场景、光线、风格感觉，语言要有画面感
+
+### 技能6：描述风景
+如果是风景图（type="scene"），描述：
+- scene_type：什么场景，例如"自然风景"、"城市街景"、"动物"、"美食"
+- main_subject：画面主体是什么
+- key_elements：关键元素，最多8个
+- environment_objects：周围环境物体，最多8个
+- atmosphere：整体氛围，例如"秋日慵懒氛围感"、"清新自然氧气感"
+- 有人物就描述人物特征
+
+## 限制
+- 只输出JSON，不要任何解释文字，不要markdown代码块包裹，不要写"好的""以下是分析结果"这种废话
+- 颜色写具体色调（亮红色/米白色/深蓝色/翠绿色），不写笼统词汇
+- 瓶身、包装、招牌上的文字尽量识别出来（品牌名、功能词、卖点词）
+- 多个商品、多个人物分开描述，不要合并
+- 看不出来、不确定的字段填null或空数组，布尔值填true/false，绝对不要瞎编
+- 确保JSON格式合法，所有大括号、中括号、引号正确闭合
+- 数组字段控制数量：colors最多5个，visible_text最多5条，visual_elements最多8个，accessories最多10个"""
+V7_USER = "请分析这张图片，按系统消息的JSON结构输出。"
+
+
+def _capability_table_exists(bind) -> bool:
+    return bool(bind.execute(text("SELECT to_regclass('public.ai_capability_configs')")).scalar())
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    # 1. 停用旧的active image_analysis prompt（含v6）
+    bind.execute(
+        text(
+            "UPDATE viral_video_prompt_templates SET is_active = FALSE "
+            "WHERE prompt_type = 'image_analysis' AND is_active = TRUE"
+        )
+    )
+    # 2. 幂等插入v7（存在则更新并重新激活）
+    existing = bind.execute(
+        text("SELECT id FROM viral_video_prompt_templates " "WHERE prompt_type = 'image_analysis' AND version = 7")
+    ).fetchone()
+    if existing:
+        bind.execute(
+            text(
+                "UPDATE viral_video_prompt_templates SET is_active = TRUE, "
+                "system_prompt = :sys, user_prompt_template = :usr, "
+                "name = 'v7 精简结构化分析', updated_at = NOW() "
+                "WHERE prompt_type = 'image_analysis' AND version = 7"
+            ),
+            {"sys": V7_SYSTEM, "usr": V7_USER},
+        )
+    else:
+        bind.execute(
+            text(
+                "INSERT INTO viral_video_prompt_templates "
+                "(prompt_type, version, name, system_prompt, user_prompt_template, "
+                "is_active, created_at, updated_at) "
+                "VALUES ('image_analysis', 7, 'v7 精简结构化分析', "
+                ":sys, :usr, TRUE, NOW(), NOW())"
+            ),
+            {"sys": V7_SYSTEM, "usr": V7_USER},
+        )
+    # 3. capability max_tokens=3000、max_retries=3（表不存在则跳过）
+    if _capability_table_exists(bind):
+        bind.execute(
+            text(
+                "UPDATE ai_capability_configs SET max_tokens = 3000, "
+                "updated_at = NOW() "
+                "WHERE capability_key = 'image_analysis' AND "
+                "(max_tokens IS NULL OR max_tokens < 3000)"
+            )
+        )
+        bind.execute(
+            text(
+                "UPDATE ai_capability_configs SET max_retries = 3, updated_at = NOW() "
+                "WHERE capability_key = 'image_analysis' AND "
+                "(max_retries IS NULL OR max_retries < 3)"
+            )
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    # 删除v7
+    bind.execute(
+        text("DELETE FROM viral_video_prompt_templates " "WHERE prompt_type = 'image_analysis' AND version = 7")
+    )
+    # 恢复v6为active
+    bind.execute(
+        text(
+            "UPDATE viral_video_prompt_templates SET is_active = TRUE "
+            "WHERE prompt_type = 'image_analysis' AND version = 6"
+        )
+    )
+    # tokens/retries回退
+    if _capability_table_exists(bind):
+        bind.execute(
+            text(
+                "UPDATE ai_capability_configs SET max_tokens = 1500, max_retries = 1, "
+                "updated_at = NOW() WHERE capability_key = 'image_analysis'"
+            )
+        )

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

@@ -29,8 +29,6 @@ from app.services.ai_avatar_render_service import (
 from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.orm import Session
 
-from packages.middleware.points_gate import points_gate
-
 logger = logging.getLogger(__name__)
 
 router = APIRouter()
@@ -44,7 +42,6 @@ def _get_service(db: Session = Depends(get_db_session)) -> AiAvatarRenderService
 
 
 @router.post("", response_model=AiAvatarRenderJobResponse, status_code=201)
-@points_gate("ai_digital_human", per_unit=15)
 def create_render_job(
     body: CreateAiAvatarRenderRequest,
     current_user: AuthenticatedUser = Depends(get_current_user),

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

@@ -27,7 +27,6 @@ from packages.adapters.sqlalchemy_impl.generation_task_repository import (
 )
 from packages.application import ListGeneratedVideosByTaskUseCase
 from packages.domain.config_schemas import normalize_plan_config
-from packages.middleware.points_gate import points_gate
 from packages.shared.storage import get_shared_storage_service
 
 from .templates_editor.dependencies import get_draft_plan_id, get_editor_services
@@ -346,7 +345,6 @@ def _is_trusted_media_url(url: str) -> bool:
 
 
 @router.post("/generate-cover", response_model=GenerateCoverResponse)
-@points_gate("ai_cover")
 def generate_cover(
     body: GenerateCoverRequest,
     template_id: str = Query(..., description="模板 ID"),

apps/api/app/api/routes/generation_preview.py

@@ -41,7 +41,6 @@ from packages.application import (
     GetGenerationTaskUseCase,
     ListGeneratedVideosByTaskUseCase,
 )
-from packages.middleware.points_gate import points_gate
 
 logger = logging.getLogger(__name__)
 
@@ -270,7 +269,6 @@ def _variant_value(values: list[str], index: int, fallback: str = "") -> str:
 
 
 @router.post("/preview", response_model=BatchPreviewGenerationTaskResponse, status_code=201)
-@points_gate("ai_video", quantity_field="preview_count")
 def create_preview_generation_task(
     request: CreatePreviewGenerationTaskRequest,
     authenticated_user: AuthenticatedUser = Depends(get_current_user),

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

@@ -44,6 +44,7 @@ from packages.application import (
     GetGenerationTaskUseCase,
     ListGeneratedVideosByTaskUseCase,
 )
+from packages.domain import feature_pricing_service
 from packages.domain.smart_match import smart_select_assets
 
 # #2035：文案关键词 → 素材分类 映射表（用于 smart_match category_match 维度）
@@ -163,8 +164,6 @@ def _infer_expected_categories(script_tags: set[str] | None) -> set[str] | None:
     return matched or None
 
 
-from packages.middleware.points_gate import points_gate
-
 logger = logging.getLogger(__name__)
 
 router = APIRouter()
@@ -465,7 +464,6 @@ def _resolve_project_and_library(
 
 
 @router.post("/tasks", response_model=BatchGenerationTaskResponse)
-@points_gate("ai_video", quantity_field="count")
 def create_generation_task(
     request: CreateGenerationTaskRequest,
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
@@ -702,6 +700,17 @@ def create_generation_task(
         logger.info("画中画已下线，strategy_id %s → one_take", effective_strategy_id)
         effective_strategy_id = "one_take"
 
+    # ── smart_edit 计费预扣（全局 points 开关 + 功能开关均开才扣） ──
+    # 首期固定价：dynamic_cost=0，price=(0+fixed_cost)×multiplier，price_cap 封顶。
+    # 预览任务不扣费；按任务条数扣费，任一任务预扣失败（余额不足）整体拒绝。
+    smart_edit_charge = 0.0
+    charged_task_count = 0
+    if not request.is_preview and feature_pricing_service.is_feature_enabled("smart_edit"):
+        unit_credits, _bd = feature_pricing_service.calculate_price("smart_edit", 0.0)
+        if unit_credits > 0:
+            smart_edit_charge = round(unit_credits * count, 2)
+            charged_task_count = count
+
     # 批量生成（count>1）：每个变体必须走与单视频完全相同的独立选片流程（#1743/#1749）。
     # - 变体 0：clone 源 plan（不污染源 plan），变体 1..N-1 用 reselect_plan_for_variant
     #   完整重跑选片（素材级去重：fresh 优先 → 受控复用 overlap≤20% → 短素材禁复用）；
@@ -932,6 +941,42 @@ def create_generation_task(
             )
             # 变体序号写入 extra_meta（响应/排查时可辨识）
             task.extra_meta["variant_index"] = task_index
+
+            # smart_edit 逐条预扣（首期固定价，credits_cost=prepaid，不做结算）
+            task_txn_id = ""
+            if charged_task_count > 0:
+                from packages.domain.points_service import PointsService
+
+                unit_credits = round(smart_edit_charge / count, 2)
+                res = PointsService().deduct_points(
+                    user_id=user_id,
+                    amount=unit_credits,
+                    source="smart_edit",
+                    db=db,
+                    description="智能剪辑生成预扣",
+                    ref_id=task.id,
+                )
+                if not res.get("success"):
+                    # 余额不足：退还本次请求已扣积分后整体拒绝
+                    already_charged = round(unit_credits * task_index, 2)
+                    if already_charged > 0:
+                        PointsService().refund_points(
+                            user_id=user_id,
+                            amount=already_charged,
+                            source="smart_edit",
+                            db=db,
+                            ref_id=task.id,
+                            description="智能剪辑批量提交失败退回",
+                        )
+                    raise HTTPException(
+                        status_code=402,
+                        detail=(f"积分不足：智能剪辑每条需 {unit_credits:.2f} 积分，当前余额 {res.get('balance', 0)}"),
+                    )
+                task_txn_id = str(res.get("transaction_id") or "")
+                task.credits_prepaid = unit_credits
+                task.credits_cost = unit_credits
+                task.credits_transaction_id = task_txn_id
+                generation_task_repository.update(task)
             try:
                 # 兜底关联编辑计划：前端未传 source_edit_plan_id 时，
                 # 通过 template_id + user_id 在 DB 层直接查找最新的 plan。

apps/api/app/api/routes/health.py

@@ -9,6 +9,11 @@ from fastapi.responses import JSONResponse
 router = APIRouter(tags=["Health"])
 
 
+
+def _pg_url(url: str) -> str:
+    """Convert SQLAlchemy URL (postgresql+psycopg://...) to libpq connection string."""
+    return url.replace("postgresql+psycopg://", "postgresql://", 1).replace("postgresql+psycopg2://", "postgresql://", 1)
+
 @router.get("/health", status_code=status.HTTP_200_OK)
 async def health_check():
     return {
@@ -49,7 +54,7 @@ async def _check_database() -> dict:
             "message": "Using in-memory database",
         }
     try:
-        conn = psycopg.connect(settings.DATABASE_URL, connect_timeout=3)
+        conn = psycopg.connect(_pg_url(settings.DATABASE_URL), connect_timeout=3)
         with conn.cursor() as cur:
             cur.execute("SELECT 1")
             cur.fetchone()
@@ -124,7 +129,7 @@ async def _check_migrations() -> dict:
             "message": "Using in-memory database, no migrations needed",
         }
     try:
-        conn = psycopg.connect(settings.DATABASE_URL, connect_timeout=3)
+        conn = psycopg.connect(_pg_url(settings.DATABASE_URL), connect_timeout=3)
         with conn.cursor() as cur:
             cur.execute("""
                 SELECT COUNT(*) FROM information_schema.tables
@@ -137,3 +142,5 @@ async def _check_migrations() -> dict:
         return {"status": "unhealthy", "message": f"Missing tables, found {count}/5"}
     except Exception as error:
         return {"status": "unhealthy", "message": f"Migration check failed: {error}"}
+
+

apps/api/app/api/routes/lipsync.py

@@ -12,11 +12,9 @@
 from __future__ import annotations
 
 import logging
-import math
 from datetime import UTC
 
 from app.auth import AuthenticatedUser, get_current_user
-from app.config import settings
 from app.dependencies import (
     get_db_session,
     get_voice_clone_profile_repository,
@@ -32,9 +30,6 @@ from app.services.mediakit_client import MediaKitError
 from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query
 from sqlalchemy.orm import Session
 
-from packages.domain.points_rules import calculate_points_cost
-from packages.domain.points_service import PointsService
-
 logger = logging.getLogger(__name__)
 
 router = APIRouter()
@@ -61,37 +56,6 @@ def create_lipsync_job(
     db: Session = Depends(get_db_session),
     svc: LipsyncService = Depends(_get_service),
 ):
-    user_id = current_user.user.id
-
-    # ── 积分扣点（#1895 P2） ──
-    _points_deducted = 0
-    _points_scene = "ai_digital_human"
-    _points_svc = PointsService() if settings.points_enabled else None
-    if _points_svc is not None:
-        # 口型同步：TTS 模式按 script_text 估时长（240字/分钟）；音频直传按 audio_duration（秒→分钟）
-        if body.audio_url and body.audio_duration and body.audio_duration > 0:
-            est_minutes = max(1.0, math.ceil(body.audio_duration / 60.0))
-        elif body.script_text:
-            est_minutes = max(1.0, math.ceil(len(body.script_text) / 240))
-        else:
-            est_minutes = 1.0
-        _points_deducted = calculate_points_cost(
-            _points_scene,
-            is_member=getattr(current_user.user, "is_member", False),
-            duration_minutes=est_minutes,
-            member_type=getattr(current_user.user, "member_type", None),
-        )
-        _deduct_res = _points_svc.deduct_points(user_id, _points_deducted, _points_scene, db)
-        if not _deduct_res["success"]:
-            raise HTTPException(
-                status_code=402,
-                detail={
-                    "code": "INSUFFICIENT_POINTS",
-                    "message": f"积分不足，需要 {_points_deducted} 积分，当前余额 {_deduct_res['balance']}",
-                    "required": _points_deducted,
-                    "balance": _deduct_res["balance"],
-                },
-            )
     """提交对口型任务.
 
     三种模式：
@@ -101,6 +65,8 @@ def create_lipsync_job(
     - 预合成音频（#1845 新主路径）：传 {video_url, audio_url, audio_duration, sentence_timings}，
       后端同步ffprobe+写入timings+直接提交MediaKit（~2-3s）。
     """
+    user_id = current_user.user.id
+
     try:
         job = svc.create_job(
             user_id=user_id,
@@ -118,18 +84,8 @@ def create_lipsync_job(
             project_id=body.project_id,
         )
     except ValueError as exc:
-        if _points_deducted > 0 and _points_svc is not None:
-            try:
-                _points_svc.refund_points(user_id, _points_deducted, _points_scene, db)
-            except Exception as refund_err:
-                logger.warning(f"对口型 ValueError 退积分异常: err={refund_err}")
         raise HTTPException(status_code=400, detail=str(exc)) from exc
     except MediaKitError as exc:
-        if _points_deducted > 0 and _points_svc is not None:
-            try:
-                _points_svc.refund_points(user_id, _points_deducted, _points_scene, db)
-            except Exception as refund_err:
-                logger.warning(f"对口型 MediaKitError 退积分异常: err={refund_err}")
         status_code = 502
         if exc.code in ("VoiceForbidden",):
             status_code = 403
@@ -145,24 +101,11 @@ def create_lipsync_job(
         ) from exc
     except Exception as exc:
         logger.error("创建对口型任务异常: %s", exc, exc_info=True)
-        if _points_deducted > 0 and _points_svc is not None:
-            try:
-                _points_svc.refund_points(user_id, _points_deducted, _points_scene, db)
-            except Exception as refund_err:
-                logger.warning(f"对口型异常退积分异常: err={refund_err}")
         raise HTTPException(
             status_code=400,
             detail=f"创建对口型任务失败: {exc}",
         ) from exc
 
-    # 创建成功但状态为 failed（同步路径失败已抛异常到上面 except；此处处理 Celery 调度失败等）
-    # 若任务已创建且状态为 failed，退费
-    if _points_deducted > 0 and _points_svc is not None and getattr(job, "status", None) == "failed":
-        try:
-            _points_svc.refund_points(user_id, _points_deducted, _points_scene, db, ref_id=job.id)
-        except Exception as refund_err:
-            logger.warning(f"对口型任务失败退积分异常: job_id={job.id}, err={refund_err}")
-
     return job
 
 
@@ -176,37 +119,14 @@ def preview_tts(
     db: Session = Depends(get_db_session),
     svc: LipsyncService = Depends(_get_service),
 ):
-    user_id = current_user.user.id
-
-    # ── 积分扣点（#1895 P2） ──
-    _points_deducted = 0
-    _points_scene = "ai_digital_human"
-    _points_svc = PointsService() if settings.points_enabled else None
-    if _points_svc is not None:
-        est_minutes = max(1.0, math.ceil(len(body.script_text or "") / 240)) if body.script_text else 1.0
-        _points_deducted = calculate_points_cost(
-            _points_scene,
-            is_member=getattr(current_user.user, "is_member", False),
-            duration_minutes=est_minutes,
-            member_type=getattr(current_user.user, "member_type", None),
-        )
-        _deduct_res = _points_svc.deduct_points(user_id, _points_deducted, _points_scene, db)
-        if not _deduct_res["success"]:
-            raise HTTPException(
-                status_code=402,
-                detail={
-                    "code": "INSUFFICIENT_POINTS",
-                    "message": f"积分不足，需要 {_points_deducted} 积分，当前余额 {_deduct_res['balance']}",
-                    "required": _points_deducted,
-                    "balance": _deduct_res["balance"],
-                },
-            )
     """步骤1「生成配音」同步 TTS 预合成.
 
     同步执行 TTS 合成 → 下载音频 → ffprobe 时长 → 句子时间戳计算，
     不创建 LipsyncJob、不转存 OSS，直接返回 CosyVoice 临时 URL（~24h 有效）。
     耗时约 2-3 秒。
     """
+    user_id = current_user.user.id
+
     try:
         result = svc.preview_tts(
             user_id=user_id,
@@ -218,11 +138,6 @@ def preview_tts(
             emotion=body.emotion,
         )
     except MediaKitError as exc:
-        if _points_deducted > 0 and _points_svc is not None:
-            try:
-                _points_svc.refund_points(user_id, _points_deducted, _points_scene, db)
-            except Exception as refund_err:
-                logger.warning(f"TTS 预合成 MediaKitError 退积分异常: err={refund_err}")
         status_code = 400
         if exc.code in ("VoiceForbidden",):
             status_code = 403
@@ -237,11 +152,6 @@ def preview_tts(
         ) from exc
     except Exception as exc:
         logger.error("TTS 预合成异常: %s", exc, exc_info=True)
-        if _points_deducted > 0 and _points_svc is not None:
-            try:
-                _points_svc.refund_points(user_id, _points_deducted, _points_scene, db)
-            except Exception as refund_err:
-                logger.warning(f"TTS 预合成异常退积分异常: err={refund_err}")
         raise HTTPException(
             status_code=400,
             detail=f"TTS 合成失败: {exc}",

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

@@ -145,19 +145,22 @@ def get_rules(
 def get_packages(
     current_user: AuthenticatedUser = Depends(get_current_user),
 ):
-    """查询可购买的积分包列表。"""
-    packages = []
-    for code, pkg in POINTS_PACKAGES.items():
-        unit_price = f"¥{pkg['price_cents'] / 100 / pkg['points']:.3f}/积分"
-        packages.append(
-            PointsPackageItem(
-                code=code,
-                name=pkg["name"],
-                points=pkg["points"],
-                price_cents=pkg["price_cents"],
-                unit_price=unit_price,
-            )
+    """查询可购买的积分包列表（读管理后台 credit_packages 表真实数据）。
+
+    仅返回 is_active=true；后台改价/启停后最多 30 秒生效。
+    """
+    from packages.application.catalog.admin_catalog import get_points_packages
+
+    packages = [
+        PointsPackageItem(
+            code=row["code"],
+            name=row["name"],
+            points=row["points"],
+            price_cents=row["price_cents"],
+            unit_price=row["unit_price"],
         )
+        for row in get_points_packages()
+    ]
     mt = _member_type(current_user)
     discount = MEMBER_DISCOUNT.get(mt) if mt else None
     return PointsPackagesResponse(packages=packages, user_discount=discount)
@@ -169,17 +172,7 @@ def check_points(
     current_user: AuthenticatedUser = Depends(get_current_user),
     db: Session = Depends(get_db_session),
 ):
-    """消费前检查余额是否足够。未知 scene_key 返回 400（而非 500）。"""
-    if body.scene_key not in POINTS_SCENES:
-        raise HTTPException(
-            status_code=400,
-            detail={
-                "code": "UNKNOWN_SCENE",
-                "message": f"未知场景: {body.scene_key}",
-                "valid_scenes": sorted(POINTS_SCENES.keys()),
-            },
-        )
-
+    """消费前检查余额是否足够。已下线/未知场景返回 cost=0（免费）。"""
     # 积分系统暂停（ENABLE_CREDIT_SYSTEM=false）：所有场景直接放行，需 0 积分
     if not _credits_enabled():
         svc = _get_service()
@@ -195,13 +188,6 @@ def check_points(
     is_mem = _is_member(current_user)
     mt = _member_type(current_user)
 
-    # 混剪场景先检查免费额度
-    is_free_quota = False
-    if body.scene_key == "ai_video" and not is_mem:
-        svc = _get_service()
-        if svc.check_daily_free_clip(current_user.user.id, db):
-            is_free_quota = True
-
     required = calculate_points_cost(
         body.scene_key,
         is_mem,
@@ -215,11 +201,11 @@ def check_points(
     balance = account["balance"]
 
     return PointsCheckResponse(
-        allowed=is_free_quota or balance >= required,
+        allowed=balance >= required,
         required_points=required,
         current_balance=balance,
         remaining_after=balance - required,
-        is_free_quota=is_free_quota,
+        is_free_quota=False,
     )
 
 

apps/api/app/api/routes/scripts_ai.py

@@ -44,7 +44,6 @@ from app.services.script_asr_service import (
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 
-from packages.middleware.points_gate import points_gate
 from packages.shared.ai_client import get_doubao_client
 
 logger = logging.getLogger(__name__)
@@ -373,7 +372,6 @@ def douyin_diag():
 
 
 @router.post("/extract-from-douyin", response_model=ExtractFromDouyinResponse)
-@points_gate("douyin_extract")
 def extract_from_douyin(
     request: ExtractFromDouyinRequest,
     current_user: AuthenticatedUser = Depends(get_current_user),
@@ -497,7 +495,6 @@ def extract_from_douyin(
 
 
 @router.post("/ai-rewrite", response_model=AiRewriteResponse)
-@points_gate("ai_rewrite")
 def ai_rewrite(
     request: AiRewriteRequest,
     current_user: AuthenticatedUser = Depends(get_current_user),
@@ -537,7 +534,6 @@ def ai_rewrite(
 
 
 @router.post("/ai-generate-titles", response_model=AiGenerateTitlesResponse)
-@points_gate("ai_title")
 def ai_generate_titles(
     request: AiGenerateTitlesRequest,
     current_user: AuthenticatedUser = Depends(get_current_user),

apps/api/app/api/routes/subscription.py

@@ -86,33 +86,13 @@ async def get_current_subscription(
 def list_membership_plans(
     current_user: AuthenticatedUser = Depends(get_current_user),
 ) -> dict[str, list[dict[str, Any]]]:
-    """查询所有会员档位（供前端会员购买页展示）。
+    """查询可购买的会员套餐（读管理后台 plans 表真实数据）。
 
-    返回 points 积分体系下的会员档位（月卡/季卡/年卡），含价格、时长、积分折扣等信息。
+    仅返回 is_enabled=true 的套餐；后台启停/改价后最多 30 秒生效。
     """
-    from packages.domain.points_rules import MEMBER_DISCOUNT, MEMBERSHIP_PRICES
+    from packages.application.catalog.admin_catalog import get_membership_plans
 
-    plans: list[dict[str, Any]] = []
-    for plan_id, info in MEMBERSHIP_PRICES.items():
-        days = info["duration_days"]
-        monthly_cents = round(info["price_cents"] * 30 / days)
-        features: dict[str, Any] = {"max_resolution": "1080p"}
-        if plan_id == MembershipType.MONTHLY:
-            features.update({"free_clips_daily": 2})
-        elif plan_id == MembershipType.QUARTERLY:
-            features.update({"free_clips_daily": 5})
-        elif plan_id == MembershipType.YEARLY:
-            features.update({"free_clips_daily": "unlimited"})
-        plans.append({
-            "plan_id": plan_id,
-            "name": info["name"],
-            "price_cents": info["price_cents"],
-            "monthly_price_cents": monthly_cents,
-            "duration_days": days,
-            "points_discount": MEMBER_DISCOUNT.get(plan_id, 1.0),
-            "features": features,
-        })
-    return {"plans": plans}
+    return {"plans": get_membership_plans()}
 
 
 @router.get("/billing-records", response_model=list[BillingRecord])

apps/api/app/api/routes/tts.py

@@ -4,14 +4,12 @@ from __future__ import annotations
 
 import json
 import logging
-import math
 import subprocess
 import tempfile
 from pathlib import Path
 from typing import Any, Optional
 
 from app.auth import AuthenticatedUser, get_current_user
-from app.config import settings
 from app.core.celery_app import celery_app
 from app.core.storage import get_storage_service
 from app.dependencies import (
@@ -53,8 +51,6 @@ from packages.application.tts_job.use_cases import (
 )
 from packages.application.tts_job.workflow import TTSWorkflowService
 from packages.domain import Asset, AssetLibrary, AssetLibraryKind, AssetStatus, ClassificationStatus
-from packages.domain.points_rules import calculate_points_cost
-from packages.domain.points_service import PointsService
 from packages.domain.voice_presets import list_voices
 from packages.ports.asset_library_repository import AssetLibraryRepository
 from packages.ports.asset_repository import AssetRepository
@@ -144,31 +140,6 @@ def synthesize(
     """
     user_id = authenticated_user.user.id
 
-    # ── 积分扣点（#1895 P2） ──
-    _points_deducted = 0
-    _points_scene = "ai_voice"
-    _points_svc = PointsService() if settings.points_enabled else None
-    if _points_svc is not None:
-        # 中文按 ~240 字/分钟粗估时长，至少按 1 分钟扣 1 分
-        est_minutes = max(1.0, math.ceil(len(request.text) / 240))
-        _points_deducted = calculate_points_cost(
-            _points_scene,
-            is_member=getattr(authenticated_user.user, "is_member", False),
-            duration_minutes=est_minutes,
-            member_type=getattr(authenticated_user.user, "member_type", None),
-        )
-        _deduct_res = _points_svc.deduct_points(user_id, _points_deducted, _points_scene, db)
-        if not _deduct_res["success"]:
-            raise HTTPException(
-                status_code=402,
-                detail={
-                    "code": "INSUFFICIENT_POINTS",
-                    "message": f"积分不足，需要 {_points_deducted} 积分，当前余额 {_deduct_res['balance']}",
-                    "required": _points_deducted,
-                    "balance": _deduct_res["balance"],
-                },
-            )
-
     # 解析 voice_id：前端可能传克隆音色 profile UUID（而非 CosyVoice voice_id），
     # 与 /tts/preview 保持一致：命中 profile → 校验归属 → 取 CosyVoice voice_id
     actual_voice_id = request.voice_id
@@ -231,7 +202,6 @@ def synthesize(
         cosyvoice_service=cosyvoice_service,
     )
 
-    synthesis_error: Exception | None = None
     try:
         job = workflow.start_synthesis(job.id)
     except Exception as e:
@@ -239,18 +209,10 @@ def synthesize(
         # 但 DB 异常、网络异常等意外错误可能逃逸。
         # 与音色克隆接口保持一致：标记 failed，返回 201，不抛 500。
         logger.error(f"TTS 合成异常: job_id={job.id}, error={e}", exc_info=True)
-        synthesis_error = e
         try:
             job = workflow.process_synthesis_failure(job.id, str(e))
         except Exception as inner_e:
             logger.error(f"标记 TTS job 失败时出错: job_id={job.id}, error={inner_e}")
-    # 合成失败且已扣积分 → 退费
-    if synthesis_error is not None and _points_deducted > 0 and _points_svc is not None:
-        try:
-            _points_svc.refund_points(user_id, _points_deducted, _points_scene, db, ref_id=job.id)
-        except Exception as refund_err:
-            logger.warning(f"TTS 合失败退积分异常: job_id={job.id}, err={refund_err}")
-
     # 若任务处于 processing 状态（异步模式），触发 Celery 后台轮询
     if job.status.value == "processing":
         # 分段合成任务 vs 普通单段任务
@@ -269,13 +231,6 @@ def synthesize(
                 workflow.process_synthesis_failure(job.id, f"Celery 任务调度失败: {e}")
             except Exception as inner_e:
                 logger.error(f"Celery 调度后标记失败时出错: job_id={job.id}, error={inner_e}")
-            # 调度失败退费
-            if _points_deducted > 0 and _points_svc is not None:
-                try:
-                    _points_svc.refund_points(user_id, _points_deducted, _points_scene, db, ref_id=job.id)
-                except Exception as refund_err:
-                    logger.warning(f"Celery 调度失败退积分异常: job_id={job.id}, err={refund_err}")
-
     return TTSSynthesizeResponse(
         job_id=job.id,
         status=job.status,
@@ -610,31 +565,6 @@ def preview_tts(
     用于前端预览配音效果，限制文本长度 200 字以内。
     支持预设音色和克隆音色：克隆音色传的是 profile UUID，需解析为 CosyVoice voice_id。
     """
-    user_id = authenticated_user.user.id
-    # ── 积分扣点（#1895 P2） ──
-    _points_deducted = 0
-    _points_scene = "ai_voice"
-    _points_svc = PointsService() if settings.points_enabled else None
-    if _points_svc is not None:
-        est_minutes = max(1.0, math.ceil(len(request.text) / 240))
-        _points_deducted = calculate_points_cost(
-            _points_scene,
-            is_member=getattr(authenticated_user.user, "is_member", False),
-            duration_minutes=est_minutes,
-            member_type=getattr(authenticated_user.user, "member_type", None),
-        )
-        _deduct_res = _points_svc.deduct_points(user_id, _points_deducted, _points_scene, db)
-        if not _deduct_res["success"]:
-            raise HTTPException(
-                status_code=402,
-                detail={
-                    "code": "INSUFFICIENT_POINTS",
-                    "message": f"积分不足，需要 {_points_deducted} 积分，当前余额 {_deduct_res['balance']}",
-                    "required": _points_deducted,
-                    "balance": _deduct_res["balance"],
-                },
-            )
-
     # 解析 voice_id：前端可能传 VoiceCloneProfile UUID 或预设音色 ID
     actual_voice_id = request.voice_id
     profile = voice_clone_repo.get(request.voice_id)
@@ -664,12 +594,6 @@ def preview_tts(
             language=getattr(request, "language", "zh-CN"),
         )
     except (CosyVoiceError, ValueError) as e:
-        # 合成失败退费
-        if _points_deducted > 0 and _points_svc is not None:
-            try:
-                _points_svc.refund_points(user_id, _points_deducted, _points_scene, db)
-            except Exception as refund_err:
-                logger.warning(f"TTS 预览失败退积分异常: {refund_err}")
         if isinstance(e, CosyVoiceError):
             raise HTTPException(status_code=status.HTTP_502_BAD_GATEWAY, detail=f"TTS 合成失败: {e}") from e
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e

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

@@ -1,6 +1,6 @@
 """爆款视频 API 路由。
 
-v1.5 三步分步流水线端点（前端新交互）：
+v1.6 三步分步流水线端点（单次 Seedance 出片版）：
   POST   /api/v1/viral-video/analyze-images          阶段1：创建任务 + 仅做图片/视频分析，暂停在 image_analyzed
   POST   /api/v1/viral-video/{job_id}/generate-copy  阶段2：用户填完参数后跑意图+文案+分镜+审核，暂停在 copy_generated
   POST   /api/v1/viral-video/{job_id}/confirm-copy   阶段3：用户确认/编辑文案后跑渲染，直到完成
@@ -10,7 +10,7 @@ v1.5 三步分步流水线端点（前端新交互）：
   POST   /api/v1/viral-video/{job_id}/confirm-intent 旧的意图确认后继续渲染
 
 通用：
-  GET    /api/v1/viral-video/{job_id}                查询任务状态（含 image_analysis/storyboard/generated_copy_text）
+  GET    /api/v1/viral-video/{job_id}                查询任务状态（含 image_analysis/copy_result 编导脚本）
   GET    /api/v1/viral-video/history                 历史记录
   POST   /api/v1/viral-video/{job_id}/retry          重试失败任务
   POST   /api/v1/viral-video/{job_id}/analyze-style  触发风格分析
@@ -32,7 +32,11 @@ from app.schemas.viral_video import (
     ConfirmCopyRequest,
     ConfirmIntentRequest,
     CreateViralVideoRequest,
+    CreditsFormulaBreakdown,
+    EstimateCreditsRequest,
+    EstimateCreditsResponse,
     GenerateCopyRequest,
+    RetryViralVideoRequest,
     StyleTemplateListResponse,
     StyleTemplateResponse,
     ViralVideoHistoryResponse,
@@ -45,7 +49,9 @@ from packages.adapters.sqlalchemy_impl.viral_video_repository import (
     SQLAlchemyViralVideoJobRepository,
     SQLAlchemyViralVideoStyleTemplateRepository,
 )
+from packages.domain.points_rules import list_viral_video_models
 from packages.domain.viral_video import ViralVideoStatus
+from packages.shared.dashscope_client import get_dashscope_client
 
 logger = logging.getLogger(__name__)
 
@@ -56,27 +62,55 @@ router = APIRouter()
 
 
 def _build_copy_result(job) -> dict | None:
-    """将后端原始字段拼装为前端期望的 CopyResult 结构（final_copy/suggested_copy/title/scenes）。"""
+    """v1.6: 返回编导分镜脚本 CopyResult 结构（给前端/Seedance 使用）。
+
+    - 若 job.copy_result 已持久化（v1.6 worker 生成），直接返回（补 final_copy 兜底）。
+    - 否则从老字段（generated_copy_text=口播, storyboard=分镜列表, intent_result）拼装兼容结构。
+    """
+    cr = getattr(job, "copy_result", None)
+    if isinstance(cr, dict) and cr:
+        out = dict(cr)
+        # 向后兼容字段
+        voiceover = out.get("voiceover_script", "") or ""
+        out.setdefault("final_copy", voiceover)
+        out.setdefault("suggested_copy", voiceover)
+        out.setdefault("title", "")
+        return out
+    # 兼容 v1.5 老数据：storyboard 是老格式 [{order,type,description,text,duration,...}]
     copy_text = getattr(job, "generated_copy_text", "") or ""
     sb = getattr(job, "storyboard", None) or []
     intent = getattr(job, "intent_result", None) or {}
     if not copy_text and not sb:
         return None
-    scenes = []
+    title = ""
+    if isinstance(intent, dict):
+        title = intent.get("suggested_title") or intent.get("intent", "") or ""
+    shots = []
     for seg in sb:
         if isinstance(seg, dict):
-            scenes.append(
+            shots.append(
                 {
-                    "shot": seg.get("description", ""),
-                    "narration": seg.get("text", ""),
-                    "duration": seg.get("duration"),
+                    "time_range": "",
+                    "shot_type_angle_movement": seg.get("ken_burns", ""),
+                    "scene_and_dialogue": (seg.get("text") or "")
+                    + (" " + seg.get("description", "") if seg.get("description") else ""),
+                    "action_details": "",
+                    "audio_bgm": "",
+                    "transition": seg.get("transition", "硬切"),
+                    "reference_image_index": None,
                 }
             )
+    ratio = getattr(job, "video_ratio", None) or "9:16"
     return {
-        "title": (intent.get("suggested_title") if isinstance(intent, dict) else None) or "",
+        "overview": {"theme": title, "total_duration": getattr(job, "duration", 15), "aspect_ratio": ratio},
+        "scene_and_lighting": "",
+        "shots": shots,
+        "hard_constraints": ["无字幕", "无水印", "人物一致性"],
+        "negative_prompts": ["字幕", "水印", "错误文字", "五官崩坏"],
+        "voiceover_script": copy_text,
         "final_copy": copy_text,
         "suggested_copy": copy_text,
-        "scenes": scenes,
+        "title": title,
     }
 
 
@@ -91,7 +125,7 @@ def _to_response(job) -> ViralVideoJobResponse:
         viral_structure=job.viral_structure,
         marketing_purpose=job.marketing_purpose,
         bgm_preference=job.bgm_preference,
-        duration=job.duration,
+        duration=job.duration or 15,
         user_copy_text=job.user_copy_text,
         fusion_level=job.fusion_level,
         reference_audio_path=job.reference_audio_path,
@@ -100,13 +134,22 @@ def _to_response(job) -> ViralVideoJobResponse:
         style_guide=job.style_guide,
         style_template_id=job.style_template_id,
         status=job.status,
+        current_stage=getattr(job, "current_stage", "") or "",
+        phase_message=getattr(job, "phase_message", "") or "",
         image_analysis=getattr(job, "image_analysis", None),
         storyboard=getattr(job, "storyboard", None),
         generated_copy_text=getattr(job, "generated_copy_text", "") or "",
         copy_result=_build_copy_result(job),
+        voice_id=getattr(job, "voice_id", "") or "",
+        voice_source=getattr(job, "voice_source", "") or "",
+        video_ratio=getattr(job, "video_ratio", "9:16") or "9:16",
+        video_model=getattr(job, "video_model", "") or "",
         intent_result=job.intent_result,
         result_video_url=job.result_video_url,
-        credits_cost=job.credits_cost,
+        pre_trusted_images=getattr(job, "pre_trusted_images", None) or None,
+        video_resolution=getattr(job, "video_resolution", "720p") or "720p",
+        credits_prepaid=float(getattr(job, "credits_prepaid", 0) or 0),
+        credits_cost=float(getattr(job, "credits_cost", 0) or 0),
         error_msg=job.error_msg,
         retry_count=job.retry_count,
         started_at=job.started_at,
@@ -148,13 +191,19 @@ def create_viral_video(
         viral_structure=request.viral_structure,
         marketing_purpose=request.marketing_purpose,
         bgm_preference=request.bgm_preference,
-        duration=request.duration,
+        duration=request.duration or 15,
         user_copy_text=request.user_copy_text,
         fusion_level=request.fusion_level,
         reference_audio_path=request.reference_audio_path,
         reference_video_url=request.reference_video_url,
         style_strength=request.style_strength,
         style_template_id=request.style_template_id,
+        voice_id=getattr(request, "voice_id", "") or "",
+        voice_source=getattr(request, "voice_source", "") or "",
+        video_ratio=getattr(request, "video_ratio", "9:16") or "9:16",
+        video_model=getattr(request, "video_model", "") or "",
+        video_resolution=getattr(request, "video_resolution", "720p") or "720p",
+        copy_result=None,
     )
 
     # 持久化
@@ -192,6 +241,12 @@ def analyze_images(
         reference_video_url=request.reference_video_url or "",
         style_template_id=request.style_template_id or "",
         style_strength=request.style_strength or "medium",
+        voice_id=request.voice_id or "",
+        voice_source=request.voice_source or "",
+        video_ratio=request.video_ratio or "9:16",
+        video_model=request.video_model or "",
+        video_resolution=getattr(request, "video_resolution", "720p") or "720p",
+        duration=request.duration or 15,
     )
     repo.save(job)
 
@@ -213,10 +268,11 @@ def generate_copy(
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     session: Session = Depends(get_db_session),
 ) -> ViralVideoJobResponse:
-    """v1.5 阶段2：用户填完营销参数后，跑 意图解析 → 文案融合 → 分镜 → 合规审核。
+    """v1.6 阶段2：用户填完营销参数后，跑 意图解析 → 编导分镜脚本生成 → 合规审核。
 
-    跑完后状态=copy_generated，响应包含 generated_copy_text + storyboard，
-    前端展示文案供用户编辑；确认/编辑后调 /{id}/confirm-copy 进入阶段3。
+    跑完后状态=copy_generated，响应 copy_result（含 overview/scene_and_lighting/shots/
+    hard_constraints/negative_prompts/voiceover_script），前端展示脚本与口播供用户编辑；
+    确认/编辑后调 /{id}/confirm-copy 进入阶段3（TTS + 单次 Seedance 出片）。
     """
     repo = _get_job_repo(session)
     job = repo.get(job_id)
@@ -224,11 +280,18 @@ def generate_copy(
         raise HTTPException(status_code=404, detail="任务不存在")
     if job.user_id != authenticated_user.user.id:
         raise HTTPException(status_code=403, detail="无权操作此任务")
-    if job.status not in (ViralVideoStatus.IMAGE_ANALYZED, ViralVideoStatus.PENDING, ViralVideoStatus.FAILED):
+    # 允许首次进入（IMAGE_ANALYZED/PENDING）、失败重试（FAILED）、文案重新生成（COPY_GENERATED/COMPLETED）
+    if job.status not in (
+        ViralVideoStatus.IMAGE_ANALYZED,
+        ViralVideoStatus.PENDING,
+        ViralVideoStatus.FAILED,
+        ViralVideoStatus.COPY_GENERATED,
+        ViralVideoStatus.COMPLETED,
+    ):
         raise HTTPException(status_code=409, detail=f"任务当前状态 {job.status} 不能生成文案")
 
-    # 允许失败任务重试：重置
-    if job.status == ViralVideoStatus.FAILED:
+    # 失败重试 / 重新生成：retry_count 自增
+    if job.status in (ViralVideoStatus.FAILED, ViralVideoStatus.COPY_GENERATED, ViralVideoStatus.COMPLETED):
         job.retry_count += 1
         job.error_msg = ""
 
@@ -240,13 +303,20 @@ def generate_copy(
     job.marketing_purpose = request.marketing_purpose or job.marketing_purpose
     job.bgm_preference = request.bgm_preference or job.bgm_preference
     if request.duration:
-        job.duration = request.duration
+        job.duration = max(5, min(30, int(request.duration)))
     job.user_copy_text = request.user_copy_text if request.user_copy_text else job.user_copy_text
     job.fusion_level = request.fusion_level or job.fusion_level
     job.reference_audio_path = request.reference_audio_path or job.reference_audio_path
     job.reference_video_url = request.reference_video_url or job.reference_video_url
     job.style_strength = request.style_strength or job.style_strength
     job.style_template_id = request.style_template_id or job.style_template_id
+    if request.style_guide is not None:
+        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.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"
 
     job.resume_from_image_analyzed()
     repo.update(job)
@@ -269,7 +339,7 @@ def confirm_copy(
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     session: Session = Depends(get_db_session),
 ) -> ViralVideoJobResponse:
-    """v1.5 阶段3：用户确认/编辑文案后开始 TTS+BGM(skip)+渲染+上传。"""
+    """v1.6 阶段3：用户确认/编辑口播后开始 TTS + 单次 Seedance 生成 + 上传。"""
     repo = _get_job_repo(session)
     job = repo.get(job_id)
     if job is None:
@@ -278,6 +348,44 @@ def confirm_copy(
         raise HTTPException(status_code=403, detail="无权操作此任务")
     if job.status != ViralVideoStatus.COPY_GENERATED:
         raise HTTPException(status_code=409, detail=f"任务当前状态 {job.status} 不能确认文案（需 copy_generated）")
+    # #2218: 额外校验 copy_result 完整性，防止孤儿/脏数据进入渲染
+    if not isinstance(job.copy_result, dict) or not job.copy_result:
+        raise HTTPException(status_code=409, detail="文案数据缺失，请先点击「生成文案」")
+
+    # 积分预扣（已扣过/重试任务跳过）
+    from app.config import settings as _settings
+
+    if _settings.points_enabled:
+        already_paid = (float(getattr(job, "credits_prepaid", 0) or 0) > 0) or (
+            float(getattr(job, "credits_cost", 0) or 0) > 0
+        )
+        if not already_paid:
+            from packages.domain.points_rules import calculate_viral_video_credits, resolve_video_dimensions
+            from packages.domain.points_service import PointsService
+
+            w, h = resolve_video_dimensions(
+                getattr(job, "video_resolution", "720p") or "720p",
+                job.video_ratio or "9:16",
+            )
+            est_credits = calculate_viral_video_credits(
+                int(job.duration or 15), w, h, job.video_model or "seedance-2.5"
+            )
+            svc = PointsService()
+            res = svc.deduct_viral_video(authenticated_user.user.id, est_credits, job.id, session)
+            if not res.get("success"):
+                balance = res.get("balance", 0)
+                raise HTTPException(
+                    status_code=402,
+                    detail={
+                        "code": "INSUFFICIENT_POINTS",
+                        "message": f"积分不足，需要 {est_credits} 积分，当前余额 {balance}",
+                        "required": est_credits,
+                        "balance": balance,
+                    },
+                )
+            job.credits_prepaid = est_credits
+            job.credits_transaction_id = res.get("transaction_id", "") or ""
+            repo.update(job)
 
     job.resume_from_copy_generated(edited_copy=request.edited_copy or None)
     repo.update(job)
@@ -293,6 +401,38 @@ def confirm_copy(
     return _to_response(job)
 
 
+@router.post("/estimate-credits", response_model=EstimateCreditsResponse)
+def estimate_credits(
+    request: EstimateCreditsRequest,
+    authenticated_user: AuthenticatedUser = Depends(get_current_user),
+) -> EstimateCreditsResponse:
+    """爆款视频积分预估（纯计算，不扣费、不创建任务）。
+
+    返回 estimated_credits 与 formula_breakdown（tokens / video_cost / fixed_cost /
+    profit_multiplier / model_price / width / height / fps），便于前端展示计费明细。
+    同时兼容前端传 model 或 video_model、resolution 或 video_resolution、ratio 或 video_ratio。
+    """
+    from packages.domain.points_rules import (
+        calculate_viral_video_credits_with_breakdown,
+        resolve_video_dimensions,
+    )
+
+    model = (request.model or "").strip() or "seedance-2.5"
+    resolution = (request.resolution or "").strip() or "720p"
+    ratio = (request.ratio or "").strip() or "9:16"
+    duration = int(request.duration or 15)
+
+    w, h = resolve_video_dimensions(resolution, ratio)
+    credits, bd = calculate_viral_video_credits_with_breakdown(
+        duration,
+        w,
+        h,
+        model,
+    )
+    breakdown = CreditsFormulaBreakdown(**bd)
+    return EstimateCreditsResponse(estimated_credits=credits, formula_breakdown=breakdown)
+
+
 @router.get("/history", response_model=ViralVideoHistoryResponse)
 def list_viral_video_history(
     limit: int = 50,
@@ -327,6 +467,17 @@ def list_style_templates(
     return StyleTemplateListResponse(items=items)
 
 
+@router.get("/models")
+def list_available_models() -> dict:
+    """返回爆款视频可用模型列表（供前端模型选择器使用）。"""
+    dashscope_available = get_dashscope_client() is not None
+    models = list_viral_video_models(
+        include_placeholder=False,
+        dashscope_available=dashscope_available,
+    )
+    return {"models": models}
+
+
 @router.get("/{job_id}", response_model=ViralVideoJobResponse)
 def get_viral_video_job(
     job_id: str,
@@ -346,31 +497,156 @@ def get_viral_video_job(
 @router.post("/{job_id}/retry", response_model=ViralVideoJobResponse)
 def retry_viral_video_job(
     job_id: str,
+    request: RetryViralVideoRequest | None = None,
     authenticated_user: AuthenticatedUser = Depends(get_current_user),
     session: Session = Depends(get_db_session),
 ) -> ViralVideoJobResponse:
-    """重试失败的爆款视频任务。"""
+    """重试失败的爆款视频任务（也支持对僵尸/超时 running 任务强制重置后重试）。
+
+    可选 body (RetryViralVideoRequest)：若传入新的 duration/video_resolution/video_ratio/
+    video_model，会重新预估积分并与原 credits_prepaid 做差额多退少补（不足抛 402 阻止重试）；
+    不传 body 或参数无变化时，保持原参数、原预扣金额不变，仅重置状态并入队。
+    credits_prepaid 为 0 的老任务首次重试会走预扣流程（与 confirm-copy 一致）。
+    """
+    from datetime import datetime, timezone
+
     repo = _get_job_repo(session)
     job = repo.get(job_id)
     if job is None:
         raise HTTPException(status_code=404, detail="任务不存在")
     if job.user_id != authenticated_user.user.id:
         raise HTTPException(status_code=403, detail="无权操作此任务")
-    if job.status != ViralVideoStatus.FAILED:
-        raise HTTPException(status_code=409, detail="只有失败的任务可以重试")
+
+    # 判定是否为僵尸 running 任务：running 超过 10 分钟且心跳停止超过 2 分钟
+    now = datetime.now(timezone.utc)
+    is_stale_running = False
+    if job.status == ViralVideoStatus.RUNNING and job.started_at is not None:
+        hb = getattr(job, "heartbeat_at", None) or job.updated_at
+        if (now - job.started_at).total_seconds() > 10 * 60 and hb is not None and (now - hb).total_seconds() > 2 * 60:
+            is_stale_running = True
+
+    if job.status != ViralVideoStatus.FAILED and not is_stale_running:
+        raise HTTPException(status_code=409, detail="只有失败或超时的任务可以重试")
+
+    # ── 参数变更检测 + 积分多退少补 ──────────────────────────────────────
+    req = request or RetryViralVideoRequest()
+    new_duration = req.duration
+    new_resolution = (req.video_resolution or "").strip() or None
+    new_ratio = (req.video_ratio or "").strip() or None
+    new_model = (req.video_model or "").strip() or None
+
+    old_duration = int(getattr(job, "duration", 15) or 15)
+    old_resolution = (getattr(job, "video_resolution", "720p") or "720p").strip() or "720p"
+    old_ratio = (getattr(job, "video_ratio", "9:16") or "9:16").strip() or "9:16"
+    old_model = (getattr(job, "video_model", "") or "").strip()
+
+    # 仅当有任意字段传入且值不同才算"参数变更"
+    param_changed = bool(
+        (new_duration is not None and int(new_duration) != old_duration)
+        or (new_resolution is not None and new_resolution != old_resolution)
+        or (new_ratio is not None and new_ratio != old_ratio)
+        or (new_model is not None and new_model != old_model)
+    )
+
+    from app.config import settings as _settings
+
+    need_points_settle = False
+    new_est = 0.0
+    if _settings.points_enabled and param_changed:
+        from packages.domain.points_rules import (
+            calculate_viral_video_credits_with_breakdown,
+            resolve_video_dimensions,
+        )
+
+        eff_dur = int(new_duration if new_duration is not None else old_duration)
+        eff_res = new_resolution if new_resolution is not None else old_resolution
+        eff_ratio = new_ratio if new_ratio is not None else old_ratio
+        eff_model = new_model if new_model is not None else (old_model or "seedance-2.5")
+        w, h = resolve_video_dimensions(eff_res, eff_ratio)
+        new_est, _ = calculate_viral_video_credits_with_breakdown(eff_dur, w, h, eff_model or "seedance-2.5")
+        need_points_settle = True
+
+    # 写入新参数（即使不开 points 也要允许用户重试时改参数）
+    if new_duration is not None:
+        job.duration = max(5, min(30, int(new_duration)))
+    if new_resolution is not None:
+        job.video_resolution = new_resolution
+    if new_ratio is not None:
+        job.video_ratio = new_ratio
+    if new_model is not None:
+        job.video_model = new_model
+
+    if need_points_settle:
+        from packages.domain.points_service import PointsService
+
+        old_prepaid = float(getattr(job, "credits_prepaid", 0) or 0)
+        svc = PointsService()
+        diff = round(new_est - old_prepaid, 2)
+        if abs(diff) >= 0.01:
+            if diff > 0:
+                # 新预扣更多：补扣差额
+                res = svc.deduct_viral_video(authenticated_user.user.id, diff, job.id, session)
+                if not res.get("success"):
+                    balance = res.get("balance", 0)
+                    raise HTTPException(
+                        status_code=402,
+                        detail={
+                            "code": "INSUFFICIENT_POINTS",
+                            "message": f"重试参数变更后需补扣 {diff} 积分，余额不足（当前 {balance}，需 {new_est}）",
+                            "required": new_est,
+                            "balance": balance,
+                            "delta": diff,
+                        },
+                    )
+                job.credits_prepaid = round(old_prepaid + diff, 2)
+                logger.info(
+                    "[爆款视频][retry] 补扣差额 job_id=%s diff=%.2f new_prepaid=%.2f",
+                    job.id,
+                    diff,
+                    job.credits_prepaid,
+                )
+            else:
+                # 新预扣更少：退还差额
+                refund = round(-diff, 2)
+                txn_id = getattr(job, "credits_transaction_id", "") or ""
+                svc.refund_points(
+                    user_id=authenticated_user.user.id,
+                    amount=refund,
+                    source="viral_video",
+                    db=session,
+                    ref_id=txn_id or job.id,
+                    description="爆款视频重试参数变更退费",
+                )
+                job.credits_prepaid = round(old_prepaid - refund, 2)
+                logger.info(
+                    "[爆款视频][retry] 退还差额 job_id=%s refund=%.2f new_prepaid=%.2f",
+                    job.id,
+                    refund,
+                    job.credits_prepaid,
+                )
+        # 差额为 0 则不调整
 
     # 重置状态
     job.retry_count += 1
     job.status = ViralVideoStatus.PENDING
-    job.error_msg = ""
+    job.error_msg = "" if not is_stale_running else "任务执行超时，已重置重试"
     job.started_at = None
     job.completed_at = None
+    job.current_stage = ""
+    job.phase_message = ""
+    job.heartbeat_at = None
     repo.update(job)
 
     # 重新入队
     try:
         celery_app.send_task("worker.run_viral_video_pipeline", args=[job.id])
-        logger.info("[爆款视频] 重试入队: job_id=%s retry_count=%d", job.id, job.retry_count)
+        logger.info(
+            "[爆款视频] 重试入队: job_id=%s retry_count=%d stale=%s params_changed=%s",
+            job.id,
+            job.retry_count,
+            is_stale_running,
+            param_changed,
+        )
     except Exception as e:
         logger.error("[爆款视频] 重试入队失败: %s", e, exc_info=True)
         job.mark_failed(f"重试入队失败: {e}")

apps/api/app/schemas/points.py

@@ -13,9 +13,9 @@ from pydantic import BaseModel, Field
 class PointsBalanceResponse(BaseModel):
     """积分余额 + 会员状态"""
 
-    balance: int = Field(..., description="当前积分余额")
-    total_earned: int = Field(..., description="累计获得积分")
-    total_spent: int = Field(..., description="累计消耗积分")
+    balance: float = Field(..., description="当前积分余额")
+    total_earned: float = Field(..., description="累计获得积分")
+    total_spent: float = Field(..., description="累计消耗积分")
     is_member: bool = Field(default=False, description="是否付费会员")
     member_type: Optional[str] = Field(None, description="会员类型: monthly/quarterly/yearly")
     member_expires_at: Optional[datetime] = Field(None, description="会员到期时间")
@@ -30,8 +30,8 @@ class PointsTransactionItem(BaseModel):
     id: str
     type: str = Field(..., description="类型: add/deduct")
     source: str = Field(..., description="来源场景")
-    amount: int
-    balance_after: int
+    amount: float
+    balance_after: float
     description: str = ""
     ref_id: str = ""
     created_at: Optional[str] = None
@@ -99,9 +99,9 @@ class PointsCheckResponse(BaseModel):
     """消费前余额检查响应"""
 
     allowed: bool
-    required_points: int
-    current_balance: int
-    remaining_after: int
+    required_points: float
+    current_balance: float
+    remaining_after: float
     is_free_quota: bool = False
 
 
@@ -112,7 +112,7 @@ class PointsDeductRequest(BaseModel):
     """积分扣减请求"""
 
     scene_key: str
-    amount: int
+    amount: float
     description: Optional[str] = ""
     ref_id: Optional[str] = ""
 
@@ -170,7 +170,7 @@ class MembershipStatusResponse(BaseModel):
     is_member: bool
     member_type: Optional[str] = None
     member_expires_at: Optional[datetime] = None
-    points_balance: int
+    points_balance: float
     max_resolution: str = Field(
         default="1080p",
         description="可用最高分辨率: 720p(free) / 1080p(paid)",

apps/api/app/schemas/viral_video.py

@@ -1,4 +1,4 @@
-"""爆款视频 API schemas。"""
+"""爆款视频 API schemas (v1.6 单次 Seedance 出片版)。"""
 
 from __future__ import annotations
 
@@ -14,41 +14,86 @@ VALID_STAGES = (
     "image_analysis",
     "video_analysis",
     "intent_parsing",
-    "copy_fusion",
-    "storyboard",
+    "script_generation",
     "review",
     "tts",
-    "bgm_select",
     "rendering",
-    "musetalk",
     "uploading",
 )
+VALID_VIDEO_RATIOS = ("9:16", "16:9", "1:1", "4:3", "3:4", "21:9")
+VALID_DURATIONS = (5, 10, 15, 20, 25, 30)
+VALID_VIDEO_RESOLUTIONS = ("480p", "720p", "1080p", "普清", "高清", "超清")
+
+
+# -- 编导脚本结构（v1.6） --
+
+
+class ShotScript(BaseModel):
+    """逐镜头分镜。"""
+
+    time_range: str = Field(default="", description="时间区间，如 0-3秒")
+    shot_type_angle_movement: str = Field(default="", description="景别/角度/运镜，如『近景俯拍45度，缓慢推镜』")
+    scene_and_dialogue: str = Field(default="", description="场景描述+口播台词")
+    action_details: str = Field(default="", description="人物动作、表情、物品操作细节")
+    audio_bgm: str = Field(default="", description="环境音+BGM提示")
+    transition: str = Field(default="硬切", description="转场方式：硬切/淡入淡出/叠化")
+    reference_image_index: int | None = Field(
+        default=None, description="参考图片索引（0-based，对应上传的第几张产品图）"
+    )
+
+
+class CopyResultOverview(BaseModel):
+    theme: str = ""
+    total_duration: int = 15
+    aspect_ratio: str = "9:16"
+
+
+class CopyResult(BaseModel):
+    """v1.6 编导分镜脚本结构（给前端 + Seedance 用）。"""
+
+    overview: CopyResultOverview = Field(default_factory=CopyResultOverview)
+    scene_and_lighting: str = ""
+    shots: list[ShotScript] = Field(default_factory=list)
+    hard_constraints: list[str] = Field(default_factory=list)
+    negative_prompts: list[str] = Field(default_factory=list)
+    voiceover_script: str = Field(
+        default="", description="纯口播对白，从各镜 scene_and_dialogue 的对白部分拼接，供 TTS 使用"
+    )
+    # 向后兼容：final_copy = voiceover_script
+    final_copy: str = ""
+    suggested_copy: str = ""
+    title: str = ""
 
 
 # -- Request Schemas --
 
 
 class CreateViralVideoRequest(BaseModel):
-    """创建爆款视频任务请求（旧接口：一键跑完前半段到 WAIT_USER_CONFIRM，保留兼容）。"""
+    """旧接口：一键创建（保留兼容）。"""
 
-    images: list[str] = Field(..., min_length=1, max_length=20, description="产品图片 URL 列表")
-    industry: str = Field(default="", description="行业")
-    target_customer: str = Field(default="", description="目标客户描述")
-    persona_id: str = Field(default="", description="人设 ID")
-    viral_structure: str = Field(default="", description="爆款结构类型")
-    marketing_purpose: str = Field(default="", description="营销目的")
-    bgm_preference: str = Field(default="", description="BGM 偏好")
-    duration: int = Field(default=30, ge=5, le=180, description="视频时长（秒）")
-    user_copy_text: str = Field(default="", description="用户原始文案（我说你写）")
-    fusion_level: str = Field(default="ai_polish", description="文案融合级别: ai_full/ai_polish/user_primary")
-    reference_audio_path: str = Field(default="", description="参考音频路径")
-    reference_video_url: str = Field(default="", description="参考爆款视频 URL")
-    style_strength: str = Field(default="medium", description="风格强度: light/medium/strict")
-    style_template_id: str = Field(default="", description="风格模板 ID")
+    images: list[str] = Field(..., min_length=1, max_length=20)
+    industry: str = ""
+    target_customer: str = ""
+    persona_id: str = ""
+    viral_structure: str = ""
+    marketing_purpose: str = ""
+    bgm_preference: str = ""
+    duration: int = Field(default=15, ge=5, le=30, description="视频时长（秒），5-30")
+    user_copy_text: str = ""
+    fusion_level: str = "ai_polish"
+    reference_audio_path: str = ""
+    reference_video_url: str = ""
+    style_strength: str = "medium"
+    style_template_id: str = ""
+    voice_id: str = ""
+    voice_source: str = ""
+    video_ratio: str = "9:16"
+    video_model: str = ""
+    video_resolution: str = "720p"
 
     @field_validator("fusion_level")
     @classmethod
-    def _validate_fusion_level(cls, v: str) -> str:
+    def _v_fl(cls, v: str) -> str:
         if v == "full_ai":
             return "ai_full"
         if v not in VALID_FUSION_LEVELS:
@@ -57,37 +102,49 @@ class CreateViralVideoRequest(BaseModel):
 
     @field_validator("style_strength")
     @classmethod
-    def _validate_style_strength(cls, v: str) -> str:
+    def _v_ss(cls, v: str) -> str:
         if v not in VALID_STYLE_STRENGTHS:
             raise ValueError(f"style_strength must be one of {VALID_STYLE_STRENGTHS}")
         return v
 
 
 class AnalyzeImagesRequest(BaseModel):
-    """v1.5 阶段1：创建任务并仅做图片/视频分析。images 必填，其他参数可选（阶段2再传）。"""
+    """v1.5+ 阶段1：创建任务 + 图片/视频分析。"""
 
-    images: list[str] = Field(..., min_length=1, max_length=20)
-    reference_video_url: str = Field(default="", description="参考爆款视频 URL（可选，有则同步做风格分析）")
-    style_template_id: str = Field(default="", description="风格模板 ID（可选）")
-    style_strength: str = Field(default="medium")
+    images: list[str] = Field(..., min_length=1, max_length=30)
+    reference_video_url: str = ""
+    style_template_id: str = ""
+    style_strength: str = "medium"
+    voice_id: str = ""
+    voice_source: str = ""
+    video_ratio: str = "9:16"
+    video_model: str = ""
+    video_resolution: str = "720p"
+    duration: int = Field(default=15, ge=5, le=30)
 
 
 class GenerateCopyRequest(BaseModel):
-    """v1.5 阶段2：用户填完参数后跑意图+文案+分镜+审核，暂停在 COPY_GENERATED。"""
+    """v1.5+ 阶段2：填完营销参数，生成编导脚本。"""
 
-    industry: str = Field(default="")
-    target_customer: str = Field(default="")
-    persona_id: str = Field(default="")
-    viral_structure: str = Field(default="")
-    marketing_purpose: str = Field(default="")
-    bgm_preference: str = Field(default="")
-    duration: int = Field(default=30, ge=5, le=180)
-    user_copy_text: str = Field(default="")
-    fusion_level: str = Field(default="ai_polish")
-    reference_audio_path: str = Field(default="")
-    reference_video_url: str = Field(default="")
-    style_strength: str = Field(default="medium")
-    style_template_id: str = Field(default="")
+    industry: str = ""
+    target_customer: str = ""
+    persona_id: str = ""
+    viral_structure: str = ""
+    marketing_purpose: str = ""
+    bgm_preference: str = ""
+    duration: int = Field(default=15, ge=5, le=30)
+    user_copy_text: str = ""
+    fusion_level: str = "ai_polish"
+    reference_audio_path: str = ""
+    reference_video_url: str = ""
+    style_strength: str = "medium"
+    style_template_id: str = ""
+    style_guide: dict | None = None
+    voice_id: str = ""
+    voice_source: str = ""
+    video_ratio: str = "9:16"
+    video_model: str = ""
+    video_resolution: str = "720p"
 
     @field_validator("fusion_level")
     @classmethod
@@ -107,30 +164,28 @@ class GenerateCopyRequest(BaseModel):
 
 
 class ConfirmCopyRequest(BaseModel):
-    """v1.5 阶段3：用户确认/编辑文案后开始渲染。"""
+    """v1.5+ 阶段3：用户确认/编辑口播后开始渲染（TTS+单次Seedance）。"""
 
-    edited_copy: str = Field(default="", description="用户编辑后的最终文案；为空则使用 AI 生成文案")
+    edited_copy: str = Field(default="", description="用户编辑后的口播文案；为空则用 AI 生成的 voiceover_script")
 
 
 class ConfirmIntentRequest(BaseModel):
-    """确认意图请求（旧 confirm-intent，兼容）。"""
+    """旧 confirm-intent（兼容）。"""
 
-    confirmed_copy: str = Field(default="", description="用户确认/修改后的文案")
-    adjustments: str = Field(default="", description="用户对 AI 文案的调整意见")
+    confirmed_copy: str = ""
+    adjustments: str = ""
 
 
 class AnalyzeStyleRequest(BaseModel):
-    """触发参考视频风格分析请求。"""
-
     reference_video_url: str = Field(..., description="参考视频 URL")
-    style_template_id: str = Field(default="", description="风格模板 ID（可选覆盖）")
+    style_template_id: str = ""
 
 
 # -- Response Schemas --
 
 
 class ViralVideoJobResponse(BaseModel):
-    """爆款视频任务响应。v1.5 新增 image_analysis/storyboard/generated_copy_text 字段。"""
+    """爆款视频任务响应（v1.6 包含 copy_result 编导脚本结构）。"""
 
     id: str
     user_id: str
@@ -141,7 +196,7 @@ class ViralVideoJobResponse(BaseModel):
     viral_structure: str = ""
     marketing_purpose: str = ""
     bgm_preference: str = ""
-    duration: int = 30
+    duration: int = 15
     user_copy_text: str = ""
     fusion_level: str = "ai_polish"
     reference_audio_path: str = ""
@@ -150,16 +205,27 @@ class ViralVideoJobResponse(BaseModel):
     style_guide: dict | None = None
     style_template_id: str = ""
     status: str
-    # v1.4 VLM 结果
+    current_stage: str = (
+        ""  # 细粒度阶段 snake_case（analyzing_images/parsing_intent/generating_script/reviewing/tts_synthesizing/rendering_video/uploading）
+    )
+    phase_message: str = ""  # 中文阶段提示文案（前端轮询/SSE 直接展示）
     image_analysis: dict | None = None
-    # v1.5 三步分步产物（原始字段，保留给后端/老调用方）
+    # v1.6 编导脚本（推荐前端使用）
+    copy_result: dict | None = None
+    # v1.5 兼容字段
     storyboard: list | None = None
     generated_copy_text: str = ""
-    # v1.5 前端 CopyResult 结构（final_copy/suggested_copy/title/scenes）
-    copy_result: dict | None = None
+    # 音色/视频参数
+    voice_id: str = ""
+    voice_source: str = ""
+    video_ratio: str = "9:16"
+    video_model: str = ""
     intent_result: dict | None = None
     result_video_url: str = ""
-    credits_cost: int = 0
+    pre_trusted_images: list[str] | None = None
+    video_resolution: str = "720p"
+    credits_prepaid: float = 0.0
+    credits_cost: float = 0.0
     error_msg: str = ""
     retry_count: int = 0
     started_at: datetime | None = None
@@ -191,6 +257,57 @@ class AnalyzeStyleResponse(BaseModel):
     style_guide: dict | None = None
 
 
+# -- 积分预估 --
+
+
+class EstimateCreditsRequest(BaseModel):
+    """爆款视频积分预估请求。
+
+    前端可传 model 或 video_model（兼容老字段）；resolution/ratio/duration 为预估所需参数。
+    """
+
+    model: str = Field(default="", alias="video_model")
+    resolution: str = Field(default="720p", alias="video_resolution")
+    ratio: str = Field(default="9:16", alias="video_ratio")
+    duration: int = Field(default=15, ge=5, le=30)
+
+    model_config = {"populate_by_name": True}
+
+
+class CreditsFormulaBreakdown(BaseModel):
+    """爆款视频积分计费公式明细（前端展示用）。"""
+
+    tokens: float = Field(..., description="估算视频 tokens 数 (duration*width*height*fps/1024)")
+    video_cost: float = Field(..., description="视频生成成本（元）= tokens/1e6 * model_price")
+    fixed_cost: float = Field(..., description="固定成本（元），含 VLM/LLM/TTS/OSS/服务器")
+    profit_multiplier: float = Field(..., description="利润系数（默认 1.3）")
+    model_price: float = Field(..., description="模型单价（元/百万 tokens）")
+    width: int = Field(..., description="视频宽度像素")
+    height: int = Field(..., description="视频高度像素")
+    fps: int = Field(..., description="视频帧率")
+
+
+class EstimateCreditsResponse(BaseModel):
+    """爆款视频积分预估响应。"""
+
+    estimated_credits: float
+    formula_breakdown: CreditsFormulaBreakdown = Field(..., description="计费公式明细")
+
+
+class RetryViralVideoRequest(BaseModel):
+    """重试爆款视频任务的请求体（可选，允许改参数重新预估积分多退少补）。
+
+    不传 body 或字段全缺省：保持原参数、不重新扣点，走默认重置+入队逻辑。
+    传入新的 duration/video_resolution/video_ratio/video_model：重新预估积分，
+    与原 credits_prepaid 比较后多退少补（差额补扣不足抛 402）。
+    """
+
+    duration: int | None = Field(default=None, ge=5, le=30, description="重试时新的视频时长（秒）")
+    video_resolution: str | None = Field(default=None, description="重试时新的分辨率，如 720p/1080p")
+    video_ratio: str | None = Field(default=None, description="重试时新的画幅比，如 9:16/16:9")
+    video_model: str | None = Field(default=None, description="重试时新的视频模型，如 seedance-2.5")
+
+
 # -- WebSocket 事件 Schema --
 
 

apps/api/app/services/gpu_lipsync_service.py

@@ -228,6 +228,8 @@ class GpuLipsyncService:
         lipsync_job_id: str = "",
         user_id: str = "",
         project_id: str = "",
+        credits_prepaid: float = 0.0,
+        credits_transaction_id: str = "",
     ) -> GpuLipsyncTaskModel:
         task_id = str(uuid.uuid4())
         now = datetime.now(UTC)
@@ -240,6 +242,8 @@ class GpuLipsyncService:
             audio_url=audio_url,
             status="pending",
             attempt=0,
+            credits_prepaid=float(credits_prepaid or 0.0),
+            credits_transaction_id=str(credits_transaction_id or ""),
             created_at=now,
             updated_at=now,
         )

apps/api/app/services/lipsync_service.py

@@ -38,6 +38,7 @@ from sqlalchemy.orm import Session
 from packages.adapters.sqlalchemy_impl.models import LipsyncJobModel
 from packages.application.cosyvoice_service import CosyVoiceError
 from packages.config import get_api_settings
+from packages.domain import feature_pricing_service
 from packages.domain.sentence_timings import (
     compute_sentence_timings,
     probe_audio_duration,
@@ -368,6 +369,8 @@ class LipsyncService:
             lipsync_job_id=job.id,
             user_id=job.user_id,
             project_id=job.project_id,
+            credits_prepaid=float(getattr(job, "credits_prepaid", 0) or 0),
+            credits_transaction_id=str(getattr(job, "credits_transaction_id", "") or ""),
         )
         logger.info(
             "[lipsync] 已创建 GPU 任务（异步）: job_id=%s gpu_task=%s",
@@ -415,6 +418,121 @@ class LipsyncService:
             job.output_duration,
         )
 
+    # ── lip_sync 计费辅助 ────────────────────────────────────────────────
+
+    @staticmethod
+    def _estimate_duration(
+        *,
+        audio_duration: Optional[float] = None,
+        sentence_timings: Optional[list] = None,
+        script_text: str = "",
+    ) -> float:
+        """预估音频/成片秒数。
+
+        优先级：audio_duration（预合成前端已 ffprobe）> timings 末句 end_time >
+        脚本字数 / 5 字每秒 > 默认 10 秒。
+        """
+        if audio_duration and float(audio_duration) > 0:
+            return float(audio_duration)
+        if sentence_timings:
+            max_end = 0.0
+            for item in sentence_timings:
+                if isinstance(item, dict):
+                    end = item.get("end_time") or item.get("end") or 0.0
+                else:
+                    end = 0.0
+                try:
+                    max_end = max(max_end, float(end))
+                except (TypeError, ValueError):
+                    continue
+            if max_end > 0:
+                return max_end
+        text = (script_text or "").strip()
+        if text:
+            return max(1.0, len(text) / 5.0)
+        return 10.0
+
+    def _settle_lip_sync(self, job: LipsyncJobModel, actual_duration: float) -> None:
+        """按实际时长结算（首期只退不补：final < prepaid 退差额，> 不补）。
+
+        幂等：credits_cost 已 > 0 说明结算过，直接跳过。
+        结算失败不阻塞业务（结果已产出），仅记录日志。
+        """
+        try:
+            prepaid = float(getattr(job, "credits_prepaid", 0) or 0)
+            if prepaid <= 0:
+                return
+            if float(getattr(job, "credits_cost", 0) or 0) > 0:
+                return
+            feature_cfg = feature_pricing_service.get_feature_config("lip_sync")
+            unit_cost = float(feature_cfg.dynamic_unit_cost) if feature_cfg is not None else 0.0
+            duration = float(actual_duration or 0.0)
+            if duration <= 0:
+                duration = self._estimate_duration(
+                    sentence_timings=job.sentence_timings,
+                    script_text=job.script_text,
+                )
+            final_price, _bd = feature_pricing_service.calculate_price("lip_sync", duration * unit_cost)
+            final_price = round(float(final_price), 2)
+            job.credits_cost = final_price
+            if final_price < prepaid - 0.009:
+                refund = round(prepaid - final_price, 2)
+                from packages.domain.points_service import PointsService
+
+                res = PointsService().refund_points(
+                    user_id=job.user_id,
+                    amount=refund,
+                    source="lip_sync",
+                    db=self.db,
+                    ref_id=str(job.credits_transaction_id or job.id),
+                    description="对口型结算退费",
+                )
+                if not res.get("success"):
+                    logger.warning(
+                        "[lip_sync] 结算退费失败 job_id=%s refund=%.2f（不阻塞）",
+                        job.id,
+                        refund,
+                    )
+            # final > prepaid：首期只退不补，不补扣
+            self.db.commit()
+        except Exception:  # noqa: BLE001
+            logger.exception("[lip_sync] 结算异常 job_id=%s（不阻塞结果）", job.id)
+            try:
+                self.db.rollback()
+            except Exception:  # noqa: BLE001
+                pass
+
+    def _refund_lip_sync(self, job: LipsyncJobModel) -> None:
+        """任务失败/取消时全额退还预扣积分（credits_cost 已结算则退实际未消耗部分）。"""
+        try:
+            prepaid = float(getattr(job, "credits_prepaid", 0) or 0)
+            if prepaid <= 0:
+                return
+            txn_id = str(getattr(job, "credits_transaction_id", "") or "")
+            cost = float(getattr(job, "credits_cost", 0) or 0)
+            refund = round(prepaid - cost, 2) if cost > 0 else round(prepaid, 2)
+            if refund <= 0:
+                return
+            from packages.domain.points_service import PointsService
+
+            res = PointsService().refund_points(
+                user_id=job.user_id,
+                amount=refund,
+                source="lip_sync",
+                db=self.db,
+                ref_id=txn_id or job.id,
+                description="对口型失败/取消退款",
+            )
+            if res.get("success"):
+                job.credits_cost = prepaid  # 标记已全额退回，防重复退
+                self.db.commit()
+        except Exception:  # noqa: BLE001
+            logger.exception("[lip_sync] 退款异常 job_id=%s", job.id)
+            try:
+                self.db.rollback()
+            except Exception:  # noqa: BLE001
+                pass
+
     # ── 创建任务 ──────────────────────────────────────────────────────────
 
     def create_job(
@@ -466,6 +584,35 @@ class LipsyncService:
             if not isinstance(sentence_timings, list) or len(sentence_timings) == 0:
                 raise MediaKitError("预合成模式 sentence_timings 不能为空", code="InvalidInput")
 
+        # 0.5 lip_sync 计费预扣（全局 points 开关 + 功能开关均开才扣）
+        prepaid_credits = 0.0
+        prepaid_txn_id = ""
+        if feature_pricing_service.is_feature_enabled("lip_sync"):
+            est_duration = self._estimate_duration(
+                audio_duration=audio_duration,
+                sentence_timings=sentence_timings,
+                script_text=script_text,
+            )
+            feature_cfg = feature_pricing_service.get_feature_config("lip_sync")
+            unit_cost = float(feature_cfg.dynamic_unit_cost) if feature_cfg is not None else 0.0
+            dynamic_cost = est_duration * unit_cost
+            prepaid_credits, _bd = feature_pricing_service.calculate_price("lip_sync", dynamic_cost)
+            if prepaid_credits > 0:
+                from packages.domain.points_service import PointsService
+
+                res = PointsService().deduct_points(
+                    user_id=user_id,
+                    amount=prepaid_credits,
+                    source="lip_sync",
+                    db=self.db,
+                    description="对口型生成预扣",
+                )
+                if not res.get("success"):
+                    raise ValueError(
+                        f"积分不足：本次对口型需 {prepaid_credits:.2f} 积分，当前余额 {res.get('balance', 0)}"
+                    )
+                prepaid_txn_id = str(res.get("transaction_id") or "")
+
         # 1. 创建数据库记录
         job_id = str(uuid.uuid4())
         job = LipsyncJobModel(
@@ -482,6 +629,8 @@ class LipsyncService:
             emotion=emotion or "",
             # 音频直传（含预合成）直接进入 pending（后续同步改为 submitted）；TTS 模式进入 tts_processing
             status="tts_processing" if is_tts_mode else "pending",
+            credits_prepaid=prepaid_credits,
+            credits_transaction_id=prepaid_txn_id,
         )
         self.db.add(job)
         self.db.flush()
@@ -677,6 +826,8 @@ class LipsyncService:
                     job.completed_at = _now
                     job.updated_at = _now
                     self.db.commit()
+                    # lip_sync 超时全额退款
+                    self._refund_lip_sync(job)
             return job
 
         # 未提交的任务不轮询
@@ -702,6 +853,8 @@ class LipsyncService:
                 job.completed_at = datetime.now(UTC)
                 job.updated_at = datetime.now(UTC)
                 self.db.commit()
+                # lip_sync 结算（只退不补）
+                self._settle_lip_sync(job, float(job.output_duration or 0.0))
                 # 异步转存自家 OSS
                 try:
                     from app.tasks.lipsync_tts import persist_output_video_task
@@ -719,6 +872,8 @@ class LipsyncService:
                 job.error_message = error.get("message", "任务执行失败")
                 job.error_code = error.get("code", "TaskFailed")
                 job.completed_at = datetime.now(UTC)
+                # lip_sync 失败全额退款（先退款再统一 commit）
+                self._refund_lip_sync(job)
             else:
                 # 中间状态（running/processing/queued 等）同步到 DB，避免前端永远卡在 submitted
                 if isinstance(mk_status, str) and mk_status:
@@ -812,6 +967,8 @@ class LipsyncService:
             job.status = "cancelled"
             job.updated_at = datetime.now(UTC)
             self.db.commit()
+            # lip_sync 取消全额退款
+            self._refund_lip_sync(job)
             self.db.refresh(job)
 
         return job

apps/api/app/services/narrative_service.py

@@ -11,14 +11,12 @@
    存储路径与元信息约定），返回 asset_id —— 下游仍以 voice_library_id（实为
    audio asset id）消费，渲染链路零改动。
 
-积分扣点与 /tts 合成端点保持一致（ai_voice 场景），失败退费。
 """
 
 from __future__ import annotations
 
 import json
 import logging
-import math
 import subprocess
 import tempfile
 from dataclasses import dataclass
@@ -32,13 +30,10 @@ from packages.application.cosyvoice_service import CosyVoiceService
 from packages.application.tts_job.use_cases import CreateTTSJobUseCase
 from packages.application.tts_job.workflow import TTSWorkflowService
 from packages.domain import Asset, AssetLibrary, AssetLibraryKind, AssetStatus, ClassificationStatus
-from packages.domain.points_rules import calculate_points_cost
-from packages.domain.points_service import PointsService
 from packages.shared.storage import SharedStorageService
 
 logger = logging.getLogger(__name__)
 
-_POINTS_SCENE = "ai_voice"
 _SYNTH_TIMEOUT = 180.0  # 叙事配音在 HTTP 请求内同步等待，长文案分段合成时留出余量
 _CONTENT_TYPE_MAP = {"mp3": "audio/mpeg", "wav": "audio/wav", "pcm": "audio/pcm", "opus": "audio/opus"}
 
@@ -273,24 +268,6 @@ def prepare_narrative_voice(
         voice_clone_repository=voice_clone_repository,
     )
 
-    # 积分扣点（与 /tts 合成端点同口径），失败时在合成失败分支退费
-    points_svc = PointsService() if points_enabled else None
-    points_deducted = 0
-    if points_svc is not None:
-        est_minutes = max(1.0, math.ceil(len(content) / 240))
-        points_deducted = calculate_points_cost(
-            _POINTS_SCENE,
-            is_member=is_member,
-            duration_minutes=est_minutes,
-            member_type=member_type,
-        )
-        deduct_res = points_svc.deduct_points(user_id, points_deducted, _POINTS_SCENE, db)
-        if not deduct_res["success"]:
-            raise NarrativeError(
-                f"积分不足，需要 {points_deducted} 积分，当前余额 {deduct_res['balance']}",
-                status_code=402,
-            )
-
     use_case = CreateTTSJobUseCase(tts_repository)
     job = use_case.execute(
         user_id=user_id,
@@ -311,19 +288,9 @@ def prepare_narrative_voice(
             workflow.process_synthesis_failure(job.id, str(e))
         except Exception:  # noqa: BLE001
             logger.warning("标记叙事 TTS job 失败出错: job_id=%s", job.id, exc_info=True)
-        if points_deducted and points_svc is not None:
-            try:
-                points_svc.refund_points(user_id, points_deducted, _POINTS_SCENE, db, ref_id=job.id)
-            except Exception:  # noqa: BLE001
-                logger.warning("叙事 TTS 失败退积分异常: job_id=%s", job.id, exc_info=True)
         raise NarrativeError(f"配音合成失败：{e}", status_code=502) from e
 
     if not job.is_completed:
-        if points_deducted and points_svc is not None:
-            try:
-                points_svc.refund_points(user_id, points_deducted, _POINTS_SCENE, db, ref_id=job.id)
-            except Exception:  # noqa: BLE001
-                logger.warning("叙事 TTS 未完成退积分异常: job_id=%s", job.id, exc_info=True)
         raise NarrativeError("配音合成未完成，请稍后重试", status_code=504)
 
     asset = _save_tts_job_as_voice_asset(

apps/api/app/tasks/lipsync_gpu.py

@@ -104,6 +104,7 @@ def lipsync_gpu_process_async(self, job_id: str, user_id: str, gpu_task_id: str)
             job.updated_at = datetime.now(UTC)
             db.commit()
             logger.info("[lipsync_gpu_async] GPU 任务已被用户取消: job_id=%s", job_id)
+            _refund_lip_sync(db, job)
             return
 
         if final_task.status != "done":
@@ -141,6 +142,7 @@ def lipsync_gpu_process_async(self, job_id: str, user_id: str, gpu_task_id: str)
             job_id,
             job.output_duration,
         )
+        _settle_lip_sync(db, job, final_task)
     except Exception as exc:
         logger.exception("[lipsync_gpu_async] 异常: job_id=%s err=%s", job_id, exc)
         try:
@@ -157,6 +159,33 @@ def lipsync_gpu_process_async(self, job_id: str, user_id: str, gpu_task_id: str)
         db.close()
 
 
+def _settle_lip_sync(db: Session, job: LipsyncJobModel, gpu_task) -> None:
+    """GPU 成功后结算：同步 credits_cost 到 gpu 任务并按实际时长多退少不补。"""
+    try:
+        from app.services.lipsync_service import LipsyncService
+
+        # GPU 任务表先同步结算结果（标记用）
+        LipsyncService._settle_lip_sync(job, float(getattr(gpu_task, "result_duration", 0) or 0.0))
+        gpu_task.credits_cost = float(job.credits_cost or 0.0)
+        db.commit()
+    except Exception:  # noqa: BLE001
+        logger.exception("[lipsync_gpu_async] lip_sync 结算异常 job_id=%s（不阻塞）", job.id)
+        try:
+            db.rollback()
+        except Exception:  # noqa: BLE001
+            pass
+
+
+def _refund_lip_sync(db: Session, job: LipsyncJobModel) -> None:
+    """GPU 取消/失败路径全额退款。"""
+    try:
+        from app.services.lipsync_service import LipsyncService
+
+        LipsyncService(db)._refund_lip_sync(job)
+    except Exception:  # noqa: BLE001
+        logger.exception("[lipsync_gpu_async] lip_sync 退款异常 job_id=%s", job.id)
+
+
 def _fallback_to_mediakit(db: Session, job: LipsyncJobModel) -> None:
     """GPU 失败时回退到 MediaKit 云端渲染。"""
     try:

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

@@ -9,6 +9,8 @@ import type {
   AnalyzeImagesRequest,
   GenerateCopyRequest,
   ConfirmCopyRequest,
+  ViralVideoModel,
+  ViralVideoModelsResponse,
 } from "./types"
 
 /** 创建爆款视频任务 */
@@ -51,6 +53,29 @@ export function analyzeViralStyle(id: string) {
   return apiClient.post<ViralVideoJob>(`/viral-video/${id}/analyze-style`).then((r) => r.data)
 }
 
+/** 动态预估积分消耗（STEP3 参数变化时调用） */
+export function estimateViralVideoCredits(params: {
+  video_model: string
+  resolution: string
+  video_ratio: string
+  duration: number
+}) {
+  return apiClient
+    .post<{ estimated_credits: number }>("/viral-video/estimate-credits", params)
+    .then((r) => r.data)
+}
+
+/** 获取支持的视频模型列表（GET /viral-video/models）。后端返回 {models: [...]} 包装 */
+export function getViralVideoModels() {
+  return apiClient.get<ViralVideoModelsResponse>("/viral-video/models").then((r) => {
+    const data = r.data as ViralVideoModelsResponse | ViralVideoModel[] | null | undefined
+    if (Array.isArray(data)) return data
+    if (data && Array.isArray((data as ViralVideoModelsResponse).models)) {
+      return (data as ViralVideoModelsResponse).models
+    }
+    return []
+  })
+}
 /** ── 三步拆分：前端 mock 辅助函数（后端新接口上线后可替换） ── */
 
 /**

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

@@ -12,6 +12,14 @@ export const STYLE_STRENGTHS: { value: StyleStrength; label: string }[] = [
   { value: "strict", label: "像素级复刻" },
 ]
 
+/** v1.6 前端时长下拉选项（5/10/15/20/25/30秒） */
+export const VALID_DURATIONS = [5, 10, 15, 20, 25, 30] as const
+export type VideoDuration = (typeof VALID_DURATIONS)[number]
+
+/** v1.6 支持的画幅比例 */
+export const VALID_RATIOS = ["9:16", "16:9", "1:1"] as const
+export type VideoRatio = (typeof VALID_RATIOS)[number]
+
 export type ViralVideoStatus =
   | "pending"
   | "running"
@@ -23,39 +31,25 @@ export type ViralVideoStatus =
   | "cancelled"
 
 /**
- * 后端流水线阶段字符串。前端不展示逐阶段进度列表，仅保留类型
- * 用于轮询时判断当前在哪个大阶段（分析中 vs 文案生成 vs 视频生成）。
+ * v1.6 后端流水线阶段。单次 Seedance 出片版：
+ * image_analysis → video_analysis(可选) → intent_parsing → script_generation → review → tts → rendering → uploading
  */
 export type ViralVideoStage =
   | "image_analysis"
   | "video_analysis"
   | "intent_parsing"
-  | "copy_fusion"
-  | "storyboard"
+  | "script_generation"
   | "review"
   | "tts"
-  | "bgm_select"
   | "rendering"
-  | "musetalk"
   | "uploading"
 
 /** 图片+视频分析阶段：属于「分析图片」按钮的范围 */
 const IMAGE_ANALYSIS_STAGES = new Set<ViralVideoStage>(["image_analysis", "video_analysis"])
-/** 文案相关阶段：属于「生成文案」按钮的范围 */
-const COPY_STAGES = new Set<ViralVideoStage>([
-  "intent_parsing",
-  "copy_fusion",
-  "storyboard",
-  "review",
-])
-/** 视频相关阶段：属于「开始生成视频」按钮的范围 */
-const VIDEO_STAGES = new Set<ViralVideoStage>([
-  "tts",
-  "bgm_select",
-  "rendering",
-  "musetalk",
-  "uploading",
-])
+/** 编导脚本阶段：属于「生成文案」按钮的范围 */
+const COPY_STAGES = new Set<ViralVideoStage>(["intent_parsing", "script_generation", "review"])
+/** 视频生成阶段：属于「开始生成视频」按钮的范围（v1.6: TTS+单次Seedance+上传） */
+const VIDEO_STAGES = new Set<ViralVideoStage>(["tts", "rendering", "uploading"])
 
 export function isImageAnalysisStage(stage: ViralVideoStage | undefined): boolean {
   return !!stage && IMAGE_ANALYSIS_STAGES.has(stage)
@@ -66,7 +60,7 @@ export function isCopyStage(stage: ViralVideoStage | undefined): boolean {
 export function isVideoStage(stage: ViralVideoStage | undefined): boolean {
   return !!stage && VIDEO_STAGES.has(stage)
 }
-/** 兼容旧调用：旧的 isAnalysisStage 视为「图片分析+文案」的所有前置阶段 */
+/** 兼容旧调用：分析图片+生成文案 的所有前置阶段 */
 export function isAnalysisStage(stage: ViralVideoStage | undefined): boolean {
   return isImageAnalysisStage(stage) || isCopyStage(stage)
 }
@@ -74,12 +68,20 @@ export function isAnalysisStage(stage: ViralVideoStage | undefined): boolean {
 /** 单张图片 VLM 识别出的商品信息 */
 export interface ImageProductAnalysis {
   name?: string
-  spec?: string
+  category?: string
   brand?: string
+  colors?: string[]
+  material_or_texture?: string
+  key_features?: string[]
+  visual_style?: string
+  scene?: string
+  target_audience_hint?: string
+  text_on_image?: string
+  /** 旧字段兼容 */
+  spec?: string
   features?: string[] | string
   label_text?: string
-  selling_points?: string[]
-  scene?: string
+  selling_points?: string
   image_index?: number
 }
 
@@ -87,10 +89,50 @@ export interface ImageAnalysisResult {
   products?: ImageProductAnalysis[]
 }
 
+/** v1.6 编导分镜脚本 - 单镜头 */
+export interface ShotScript {
+  /** 时间区间，如 "0-3秒" */
+  time_range?: string
+  /** 景别/角度/运镜，如 "近景俯拍45度，缓慢推镜" */
+  shot_type_angle_movement?: string
+  /** 场景描述+对白 */
+  scene_and_dialogue?: string
+  /** 人物动作/表情/物品操作细节 */
+  action_details?: string
+  /** 环境音+BGM提示 */
+  audio_bgm?: string
+  /** 转场方式（硬切/淡入淡出/叠化/结束） */
+  transition?: string
+  /** 参考图片索引（0-based，对应上传产品图数组） */
+  reference_image_index?: number | null
+}
+
+/** v1.6 编导分镜脚本 - 总览 */
+export interface CopyResultOverview {
+  theme?: string
+  total_duration?: number
+  aspect_ratio?: string
+}
+
+/** v1.6 编导分镜脚本（核心输出结构，给 Seedance 做 prompt，给 TTS 取 voiceover_script） */
 export interface CopyResult {
+  overview?: CopyResultOverview
+  /** 整体场景+光线描述 */
+  scene_and_lighting?: string
+  /** 逐镜头时间轴 */
+  shots?: ShotScript[]
+  /** 硬性约束（禁止字幕/水印/变形等） */
+  hard_constraints?: string[]
+  /** 负面提示词 */
+  negative_prompts?: string[]
+  /** 完整口播稿（纯文本，用于 TTS 合成） */
+  voiceover_script?: string
+  /** 向后兼容：= voiceover_script */
   final_copy?: string
+  /** 向后兼容：= voiceover_script */
   suggested_copy?: string
   title?: string
+  /** v1.5 旧字段兼容（老数据降级时可能出现） */
   scenes?: Array<{ shot: string; narration: string; duration?: number }>
 }
 
@@ -104,13 +146,18 @@ export interface StyleTemplate {
 }
 
 export interface IntentResult {
-  product: string
-  selling_points: string[]
-  target_audience: string
-  tone: string
-  structure: string
-  duration: number
+  intent?: string
+  key_messages?: string[]
+  tone?: string
+  target_emotion?: string
+  call_to_action?: string
   suggested_title?: string
+  /** v1.5 旧字段兼容 */
+  product?: string
+  selling_points?: string[]
+  target_audience?: string
+  structure?: string
+  duration?: number
   suggested_copy?: string
 }
 
@@ -123,16 +170,27 @@ export interface ViralVideoJob {
   style_template_id?: string
   style_guide?: string | Record<string, unknown>
   user_copy_text?: string
+  /** v1.6: = copy_result.voiceover_script（从 copy_result 派生，向后兼容） */
   final_copy_text?: string
+  generated_copy_text?: string
   fusion_level?: FusionLevel
   voice_id?: string
   voice_mode?: "global" | "per_video"
-  voice_source?: "preset" | "library" | "clone" | "upload"
+  voice_source?: "preset" | "library" | "clone" | "upload" | "my_voice"
   bgm_preference?: string
   intent_result?: IntentResult
   intent_text?: string
+  /** v1.6 编导分镜脚本（核心产物） */
   copy_result?: CopyResult
+  /** 向后兼容：= copy_result.shots */
+  storyboard?: ShotScript[]
   image_analysis?: ImageAnalysisResult
+  /** 视频比例：9:16 / 16:9 / 1:1，默认 9:16 */
+  video_ratio?: string
+  /** Seedance 模型 ID（空=后端默认） */
+  video_model?: string
+  /** 视频时长（秒，5-30，默认15） */
+  duration?: number
   progress_stage?: ViralVideoStage
   progress_percent?: number
   progress_message?: string
@@ -154,7 +212,7 @@ export interface GenerateViralVideoRequest {
   user_copy_text?: string
   fusion_level?: FusionLevel
   voice_id?: string
-  voice_source?: "preset" | "library" | "clone" | "upload"
+  voice_source?: "preset" | "library" | "clone" | "upload" | "my_voice"
   bgm_preference?: string
   industry?: string
   target_customer?: string
@@ -162,6 +220,7 @@ export interface GenerateViralVideoRequest {
   persona_id?: string
   viral_structure?: string
   marketing_purpose?: string
+  /** 视频时长（5-30秒，默认15） */
   duration?: number
   video_model?: string
   video_ratio?: string
@@ -176,15 +235,25 @@ export interface HistoryResponse {
   page_size: number
 }
 
-/** v1.5 阶段1请求：仅做图片/视频分析（POST /viral-video/analyze-images） */
+/** v1.6 阶段1请求：图片/视频分析（POST /viral-video/analyze-images） */
 export interface AnalyzeImagesRequest {
   images: string[]
   reference_video_url?: string
   style_template_id?: string
   style_strength?: StyleStrength
+  /** TTS 音色 ID（STEP1 已选音色时传） */
+  voice_id?: string
+  /** 音色来源：preset | library | clone | upload */
+  voice_source?: "preset" | "library" | "clone" | "upload" | "my_voice"
+  /** Seedance 视频比例：9:16 | 16:9 | 1:1 */
+  video_ratio?: string
+  /** Seedance 模型 ID（空则使用服务端默认） */
+  video_model?: string
+  /** 视频时长（秒，5-30，默认15） */
+  duration?: number
 }
 
-/** v1.5 阶段2请求：填完营销参数后生成文案+分镜（POST /viral-video/{id}/generate-copy） */
+/** v1.6 阶段2请求：填完营销参数后生成编导分镜脚本（POST /viral-video/{id}/generate-copy） */
 export interface GenerateCopyRequest {
   industry?: string
   target_customer?: string
@@ -192,6 +261,7 @@ export interface GenerateCopyRequest {
   viral_structure?: string
   marketing_purpose?: string
   bgm_preference?: string
+  /** 视频时长（秒，5-30，默认15） */
   duration?: number
   user_copy_text?: string
   fusion_level?: FusionLevel
@@ -200,15 +270,42 @@ export interface GenerateCopyRequest {
   style_strength?: StyleStrength
   style_template_id?: string
   style_guide?: string | Record<string, unknown>
+  /** TTS 音色 ID（优先级高于 persona_id） */
+  voice_id?: string
+  /** 音色来源：preset | library | clone | upload */
+  voice_source?: "preset" | "library" | "clone" | "upload" | "my_voice"
+  /** Seedance 视频比例（9:16/16:9/1:1 等） */
+  video_ratio?: string
+  /** Seedance 模型 ID（空则使用服务端默认） */
+  video_model?: string
 }
 
-/** v1.5 阶段3请求：用户确认/编辑文案后开始渲染（POST /viral-video/{id}/confirm-copy） */
+/** 视频模型描述（GET /viral-video/models） */
+export interface ViralVideoModel {
+  key: string
+  display_name: string
+  supports_audio: boolean
+  supported_resolutions: string[]
+  max_duration: number
+  /** 计费模式（可选）：per_second / per_video / token 等 */
+  billing_mode?: string
+  is_default?: boolean
+}
+
+/** GET /viral-video/models 响应包装 */
+export interface ViralVideoModelsResponse {
+  models: ViralVideoModel[]
+}
+
+/** v1.6 阶段3请求：用户确认/编辑口播文案后开始单次 Seedance 出片（POST /viral-video/{id}/confirm-copy） */
 export interface ConfirmCopyRequest {
-  /** 用户编辑后的最终文案；为空则使用 AI 生成文案 */
+  /** 用户编辑后的口播文案；为空则使用 AI 生成的 voiceover_script */
   edited_copy?: string
+  /** 视频模型 key，覆盖默认 */
+  video_model?: string
 }
 
-/** 分镜片段结构（后端 storyboard 字段的元素形态，保留供调试/进阶使用；主流程请使用 copy_result.scenes） */
+/** 旧分镜片段结构（保留兼容；新代码请使用 ShotScript） */
 export interface StoryboardSegment {
   order: number
   type: string

apps/web/src/api/voice-clone/types.ts

@@ -18,6 +18,8 @@ export interface VoiceClone {
   language: string
   gender: string
   error_message: string | null
+  /** CosyVoice 实际使用的音色 ID（status=ready 时由后端填充，用于 TTS 调用） */
+  voice_id?: string | null
   created_at: string
   updated_at: string
 }

apps/web/src/api/voice-clone/utils.ts

@@ -18,6 +18,7 @@ export const toVoiceClone = (profile: VoiceCloneProfile): VoiceClone => ({
   language: profile.language || "",
   gender: profile.gender || "",
   error_message: profile.error_message || null,
+  voice_id: profile.voice_id,
   created_at: profile.created_at,
   updated_at: profile.updated_at,
 })

apps/web/src/components/common/DurationWheelPicker/DurationWheelPicker.css

@@ -0,0 +1,182 @@
+/* DurationWheelPicker —— 弹层式滚轮选择器（样式与表单一致） */
+
+/* 触发按钮：外观复用 .vv-select 风格 */
+.dw-trigger {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  width: 100%;
+  height: 36px;
+  padding: 0 12px;
+  background: #fff;
+  border: 1px solid #e0e0e8;
+  border-radius: 8px;
+  font-size: 13px;
+  color: #1f2937;
+  cursor: pointer;
+  box-sizing: border-box;
+  transition: all 0.15s;
+  user-select: none;
+}
+.dw-trigger:hover {
+  border-color: #c0c0d0;
+}
+.dw-trigger-open,
+.dw-trigger:focus-within {
+  border-color: #7c3aed !important;
+  box-shadow: 0 0 0 2px rgba(124, 58, 237, 0.12);
+}
+.dw-trigger-disabled {
+  opacity: 0.5;
+  pointer-events: none;
+  cursor: not-allowed;
+}
+.dw-trigger-val {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.dw-trigger-placeholder {
+  color: #9ca3af;
+}
+.dw-trigger-arrow {
+  font-size: 10px;
+  color: #9ca3af;
+  margin-left: 8px;
+  transition: transform 0.2s;
+}
+.dw-trigger-arrow-up {
+  transform: rotate(180deg);
+}
+
+/* 弹层容器 */
+.dw-popup {
+  padding: 8px;
+  min-width: 140px;
+}
+
+/* 滚轮 */
+.dw-picker {
+  position: relative;
+  width: 100%;
+  overflow: hidden;
+  border-radius: 8px;
+  background: #fafafe;
+  border: 1px solid #e5e7eb;
+}
+.dw-picker-list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  height: 100%;
+  overflow-y: scroll;
+  scroll-snap-type: y mandatory;
+  -webkit-overflow-scrolling: touch;
+  scrollbar-width: none;
+}
+.dw-picker-list::-webkit-scrollbar {
+  display: none;
+}
+.dw-picker-item {
+  display: flex;
+  align-items: baseline;
+  justify-content: center;
+  gap: 3px;
+  scroll-snap-align: center;
+  cursor: pointer;
+  font-size: 15px;
+  color: #9ca3af;
+  font-weight: 400;
+  transition:
+    color 0.15s,
+    transform 0.15s,
+    font-weight 0.15s;
+}
+.dw-picker-item-val {
+  font-variant-numeric: tabular-nums;
+}
+.dw-picker-item-unit {
+  font-size: 13px;
+  color: inherit;
+}
+.dw-picker-item-active {
+  color: #7c3aed;
+  font-weight: 600;
+}
+.dw-picker-item-active .dw-picker-item-val {
+  font-size: 18px;
+}
+.dw-picker-item-active .dw-picker-item-unit {
+  font-size: 14px;
+}
+
+/* 中心选中条 */
+.dw-picker-mask {
+  position: absolute;
+  left: 6px;
+  right: 6px;
+  pointer-events: none;
+  background: #f5f0ff;
+  border-radius: 6px;
+  z-index: 1;
+}
+.dw-picker-mask::before,
+.dw-picker-mask::after {
+  content: "";
+  position: absolute;
+  left: 0;
+  right: 0;
+  height: 1px;
+  background: #d8c4ff;
+}
+.dw-picker-mask::before {
+  top: 0;
+}
+.dw-picker-mask::after {
+  bottom: 0;
+}
+
+/* 上下渐变 */
+.dw-picker-fade {
+  position: absolute;
+  left: 0;
+  right: 0;
+  height: 40%;
+  pointer-events: none;
+  z-index: 2;
+}
+.dw-picker-fade-top {
+  top: 0;
+  background: linear-gradient(to bottom, #fafafe 25%, rgba(250, 250, 254, 0));
+}
+.dw-picker-fade-bottom {
+  bottom: 0;
+  background: linear-gradient(to top, #fafafe 25%, rgba(250, 250, 254, 0));
+}
+
+/* 弹层按钮区 */
+.dw-popup-actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+  margin-top: 8px;
+}
+.dw-popup-actions .ant-btn {
+  border-radius: 6px;
+}
+.dw-popup-actions .ant-btn-primary {
+  background: #7c3aed;
+}
+.dw-popup-actions .ant-btn-primary:hover {
+  background: #6d28d9 !important;
+}
+
+/* 覆盖 antd Popover 默认内边距 */
+.dw-popover .ant-popover-inner {
+  padding: 0 !important;
+  overflow: hidden;
+}
+.dw-popover .ant-popover-arrow {
+  display: none;
+}

apps/web/src/components/common/DurationWheelPicker/index.tsx

@@ -0,0 +1,180 @@
+/**
+ * DurationWheelPicker —— 竖屏滚轮式时长选择器（弹层版）
+ *
+ * 设计：
+ * - 外观是和其他表单 Select 一致的输入框（白色底+1px灰边+紫色focus ring）
+ * - 点击输入框弹出 Popover，内部是滚轮 picker（原生 scroll-snap，零依赖）
+ * - 滚轮样式：白底容器，选中行 #7c3aed 紫字加粗+浅紫背景条
+ * - 支持触摸/鼠标滚轮/点击；松手吸附；底部"确认/取消"按钮
+ * - 默认范围 15–30 秒，步长 1 秒
+ */
+import React, { useEffect, useMemo, useRef, useState, useCallback } from "react"
+import { Popover, Button } from "antd"
+import { DownOutlined } from "@ant-design/icons"
+import "./DurationWheelPicker.css"
+
+export interface DurationWheelPickerProps {
+  value?: number
+  min?: number
+  max?: number
+  step?: number
+  unit?: string
+  onChange?: (value: number) => void
+  placeholder?: string
+  disabled?: boolean
+  /** 弹层宽度，默认 160px */
+  popupWidth?: number
+  /** 弹层内滚轮高度，默认 180px */
+  wheelHeight?: number
+}
+
+const ITEM_HEIGHT = 36
+
+const DurationWheelPicker: React.FC<DurationWheelPickerProps> = ({
+  value = 20,
+  min = 15,
+  max = 30,
+  step = 1,
+  unit = "秒",
+  onChange,
+  placeholder = "请选择时长",
+  disabled = false,
+  popupWidth = 160,
+  wheelHeight = 180,
+}) => {
+  const options = useMemo(() => {
+    const arr: number[] = []
+    for (let v = min; v <= max; v += step) arr.push(v)
+    return arr
+  }, [min, max, step])
+
+  const [open, setOpen] = useState(false)
+  // 弹层内暂存值，点确认才提交
+  const [draft, setDraft] = useState<number>(value)
+  const listRef = useRef<HTMLUListElement>(null)
+  const scrollTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+  useEffect(() => {
+    if (open) {
+      setDraft(value)
+      // 下一帧滚到当前值
+      requestAnimationFrame(() => scrollToValue(value, false))
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [open])
+
+  const scrollToValue = useCallback(
+    (v: number, smooth = true) => {
+      const list = listRef.current
+      if (!list) return
+      const idx = options.indexOf(v)
+      if (idx < 0) return
+      list.scrollTo({ top: idx * ITEM_HEIGHT, behavior: smooth ? "smooth" : "auto" })
+    },
+    [options],
+  )
+
+  const handleScroll = () => {
+    if (scrollTimerRef.current) clearTimeout(scrollTimerRef.current)
+    scrollTimerRef.current = setTimeout(() => {
+      const list = listRef.current
+      if (!list) return
+      const idx = Math.round(list.scrollTop / ITEM_HEIGHT)
+      const clamped = Math.max(0, Math.min(options.length - 1, idx))
+      const targetTop = clamped * ITEM_HEIGHT
+      if (Math.abs(list.scrollTop - targetTop) > 1) {
+        list.scrollTo({ top: targetTop, behavior: "smooth" })
+      }
+      setDraft(options[clamped])
+    }, 100)
+  }
+
+  const handleConfirm = () => {
+    onChange?.(draft)
+    setOpen(false)
+  }
+
+  const handleCancel = () => {
+    setOpen(false)
+  }
+
+  const handleItemClick = (v: number) => {
+    setDraft(v)
+    scrollToValue(v, true)
+  }
+
+  const maskTop = wheelHeight / 2 - ITEM_HEIGHT / 2
+
+  const wheel = (
+    <div className="dw-popup">
+      <div
+        className="dw-picker"
+        style={{ height: wheelHeight, width: popupWidth - 24 /* padding */ }}
+      >
+        <div className="dw-picker-mask" style={{ top: maskTop, height: ITEM_HEIGHT }} aria-hidden />
+        <div className="dw-picker-fade dw-picker-fade-top" aria-hidden />
+        <div className="dw-picker-fade dw-picker-fade-bottom" aria-hidden />
+        <ul
+          ref={listRef}
+          className="dw-picker-list"
+          onScroll={handleScroll}
+          style={{
+            paddingTop: wheelHeight / 2 - ITEM_HEIGHT / 2,
+            paddingBottom: wheelHeight / 2 - ITEM_HEIGHT / 2,
+          }}
+        >
+          {options.map((v) => {
+            const isActive = v === draft
+            return (
+              <li
+                key={v}
+                className={`dw-picker-item${isActive ? " dw-picker-item-active" : ""}`}
+                style={{ height: ITEM_HEIGHT, lineHeight: `${ITEM_HEIGHT}px` }}
+                onClick={() => handleItemClick(v)}
+                aria-selected={isActive}
+                role="option"
+              >
+                <span className="dw-picker-item-val">{v}</span>
+                <span className="dw-picker-item-unit">{unit}</span>
+              </li>
+            )
+          })}
+        </ul>
+      </div>
+      <div className="dw-popup-actions">
+        <Button size="small" onClick={handleCancel}>
+          取消
+        </Button>
+        <Button size="small" type="primary" onClick={handleConfirm}>
+          确认
+        </Button>
+      </div>
+    </div>
+  )
+
+  return (
+    <Popover
+      open={!disabled && open}
+      onOpenChange={(v) => setOpen(v)}
+      content={wheel}
+      trigger="click"
+      placement="bottomLeft"
+      overlayClassName="dw-popover"
+      overlayStyle={{ padding: 0 }}
+      overlayInnerStyle={{ padding: 0, borderRadius: 10 }}
+      destroyTooltipOnHide
+    >
+      <div
+        className={`dw-trigger${disabled ? " dw-trigger-disabled" : ""}${open ? " dw-trigger-open" : ""}`}
+        style={{ height: 36 }}
+      >
+        <span className={`dw-trigger-val${value != null ? "" : " dw-trigger-placeholder"}`}>
+          {value != null ? `${value}${unit}` : placeholder}
+        </span>
+        <DownOutlined className={`dw-trigger-arrow${open ? " dw-trigger-arrow-up" : ""}`} />
+      </div>
+    </Popover>
+  )
+}
+
+export default DurationWheelPicker

apps/web/src/config/features.ts

@@ -10,4 +10,4 @@
  *   功能流程不做积分预校验，直接走生成。
  * - true：展示完整积分系统 UI。
  */
-export const ENABLE_CREDIT_SYSTEM = false
+export const ENABLE_CREDIT_SYSTEM = true

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

@@ -80,6 +80,8 @@ const AiAvatarPage: React.FC = () => {
   const [finalizeLoading, setFinalizeLoading] = useState(false)
 
   /* ── 对口型轮询 ── */
+  /** 对口型轮询总时长上限（10分钟）：超过后停止轮询并提示去历史记录查看 */
+  const LIPSYNC_POLL_MAX_MS = 10 * 60 * 1000
   const lipsyncTimerRef = useRef<ReturnType<typeof setInterval> | null>(null)
   /* ── 渲染进度轮询 ── */
   const renderTimerRef = useRef<ReturnType<typeof setInterval> | null>(null)
@@ -270,7 +272,24 @@ const AiAvatarPage: React.FC = () => {
       // 如果是预合成模式，后端会同步把状态置为 submitted（甚至可能已返回 running），
       // 但仍需轮询等 completed
       if (lipsyncTimerRef.current) clearInterval(lipsyncTimerRef.current)
+      // 轮询间隔 5 秒；单请求超时 5 分钟（见 api/aiAvatar.ts）；总轮询上限 10 分钟
+      // 单次请求失败/超时不中断轮询，继续下一轮；超过总上限后停止并提示用户去历史记录查看
       lipsyncTimerRef.current = setInterval(async () => {
+        // 总时长保护：超过 10 分钟停止轮询
+        if (Date.now() - lipsyncStartAtRef.current > LIPSYNC_POLL_MAX_MS) {
+          if (lipsyncTimerRef.current) {
+            clearInterval(lipsyncTimerRef.current)
+            lipsyncTimerRef.current = null
+          }
+          if (lipsyncTickRef.current) {
+            clearInterval(lipsyncTickRef.current)
+            lipsyncTickRef.current = null
+          }
+          setLipsyncStatus("failed")
+          setLipsyncErrorMessage("渲染时间较长，请稍后在历史记录中查看")
+          message.warning("对口型渲染时间较长，已停止自动刷新，请稍后在历史记录中查看")
+          return
+        }
         try {
           const updated = await getLipsyncJob(job.id)
           state.setLipsyncJob(updated)
@@ -296,9 +315,10 @@ const AiAvatarPage: React.FC = () => {
             setLipsyncErrorMessage(updated.error_message || "对口型生成失败")
           }
         } catch (err) {
-          console.error("[对口型] 轮询错误:", err)
+          // 单次轮询失败（含 timeout）：不中断轮询，打印日志后等下一轮
+          console.warn("[对口型] 轮询请求失败，将继续下一轮:", err)
         }
-      }, 3000)
+      }, 5000)
     } catch (err) {
       console.error("[对口型] 创建失败:", {
         status: (err as { response?: { status?: number } })?.response?.status,

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

@@ -72,7 +72,8 @@ export const previewTts = async (data: {
 }
 
 export const getLipsyncJob = async (id: string): Promise<LipsyncJob> => {
-  const response = await apiClient.get<LipsyncJob>(`/lipsync/jobs/${id}`, { timeout: 60000 })
+  // MuseTalk 渲染 8s 视频约 54s + 排队时间，给足 5 分钟超时避免单次轮询 AxiosError 中断
+  const response = await apiClient.get<LipsyncJob>(`/lipsync/jobs/${id}`, { timeout: 300_000 })
   return response.data
 }
 
@@ -91,7 +92,10 @@ export const submitRender = async (data: {
 }
 
 export const getRenderJob = async (jobId: string): Promise<RenderJob> => {
-  const response = await apiClient.get<RenderJob>(`/ai-avatar/render/${jobId}`, { timeout: 60000 })
+  // 渲染链路（对口型+B-roll+标题+合成+上传）耗时较长，给足 5 分钟超时
+  const response = await apiClient.get<RenderJob>(`/ai-avatar/render/${jobId}`, {
+    timeout: 300_000,
+  })
   return response.data
 }
 

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

@@ -245,12 +245,11 @@ export default function AssetPickerModal({
         </div>
         {multiple && (
           <div className="vv-modal-foot">
-            <button className="vv-btn vv-btn-ghost vv-btn-sm" onClick={onClose}>
+            <button className="vv-btn vv-btn-ghost" onClick={onClose}>
               取消
             </button>
             <button
               className="vv-btn vv-btn-primary"
-              style={{ width: "auto", marginTop: 0, padding: "8px 18px" }}
               onClick={handleConfirm}
               disabled={picked.size === 0}
             >

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

@@ -34,83 +34,63 @@ interface Props {
 
 /** 兜底 mock 音色（后端 /api/v1/tts/presets 返回字段不够时使用） */
 const MOCK_VOICES: PresetVoice[] = [
+  // ⚠️ 兜底 mock，仅在 /voices/presets 接口不可达时使用；ID 必须与后端
+  // packages/domain/preset_voices.py PRESET_VOICES 的 voice_id 对齐（v3后缀）
   {
-    id: "long-xiaochun",
+    id: "longxiaochun_v3",
     name: "龙小淳",
     gender: "female",
     category: "女声",
     desc: "知性积极女声，适合语音助手",
   },
   {
-    id: "long-xiaoxia",
+    id: "longxiaoxia_v3",
     name: "龙小夏",
     gender: "female",
     category: "女声",
     desc: "沉稳权威女声，适合新闻播报",
   },
   {
-    id: "long-xiaoyan",
-    name: "龙小颜",
-    gender: "female",
-    category: "女声",
-    desc: "温柔甜美女声，适合情感口播",
-  },
-  {
-    id: "long-xiaotong",
-    name: "龙小彤",
-    gender: "female",
-    category: "女声",
-    desc: "活力少女音，适合短视频带货",
-  },
-  {
-    id: "long-sanshu",
+    id: "longsanshu_v3",
     name: "龙三叔",
     gender: "male",
     category: "男声",
     desc: "沉稳质感男声，适合有声书",
   },
   {
-    id: "long-xiaogang",
-    name: "龙小刚",
-    gender: "male",
-    category: "男声",
-    desc: "阳光活力男声，适合解说",
-  },
-  {
-    id: "long-xiaocheng",
-    name: "龙小诚",
-    gender: "male",
-    category: "男声",
-    desc: "磁性商务男声，适合品牌宣传",
-  },
-  {
-    id: "long-xiaozhi",
-    name: "龙小智",
-    gender: "child",
-    category: "童声",
-    desc: "可爱童声，适合亲子内容",
-  },
-  {
-    id: "long-yue",
+    id: "longyue_v3",
     name: "龙悦",
     gender: "female",
-    category: "情绪",
-    desc: "温柔治愈女声，适合睡前/助眠",
+    category: "女声",
+    desc: "温暖磁性女声，适合广告配音",
   },
   {
-    id: "long-xiaodong",
-    name: "龙晓东",
+    id: "longshu_v3",
+    name: "龙书",
     gender: "male",
-    category: "方言",
-    desc: "东北方言男声，接地气",
+    category: "男声",
+    desc: "沉稳青年男声，适合教育讲解",
   },
-  { id: "long-xiaoling", name: "龙小玲", gender: "female", category: "方言", desc: "粤语女声" },
   {
-    id: "long-xiaoxiao-neural",
-    name: "晓晓",
+    id: "longyingjing_v3",
+    name: "龙应静",
     gender: "female",
     category: "女声",
-    desc: "温柔女声",
+    desc: "低调冷静女声，适合纪录片解说",
+  },
+  {
+    id: "longshuo_v3",
+    name: "龙硕",
+    gender: "male",
+    category: "男声",
+    desc: "博才干练男声，适合科技类内容",
+  },
+  {
+    id: "longtian_v3",
+    name: "龙甜",
+    gender: "female",
+    category: "女声",
+    desc: "活泼女声，适合短视频配音",
   },
 ]
 
@@ -178,23 +158,22 @@ const PresetVoicePickerModal: React.FC<Props> = ({
 
   // 合并真实数据和 mock：如果真实数据 gender/category 缺失，用 mock 兜底
   const allVoices: PresetVoice[] = useMemo(() => {
+    // 真实 API 返回的 voice_id 以 API 为准（如 longxiaochun_v3），前端不做硬编码覆盖
     const realList: PresetVoice[] = (voices || []).map((v) => {
-      // 按 name 模糊匹配 mock 获取补充信息
-      const mockMatch = MOCK_VOICES.find(
-        (m) => v.name?.includes(m.name.slice(1)) || m.name.includes(v.name?.slice(0, 2) || "___"),
-      )
+      // 按 id 精确匹配 mock 获取补充元信息（id 即 voice_id，唯一稳定键）
+      const mockMatch = MOCK_VOICES.find((m) => m.id === v.id)
       return {
         ...v,
         gender: v.gender || mockMatch?.gender,
         category:
           v.category ||
           mockMatch?.category ||
-          (v.gender === "female" ? "女声" : v.gender === "male" ? "男声" : undefined),
+          (v.gender === "female" ? "女声" : v.gender === "male" ? "男声" : "其他"),
         desc: v.desc || mockMatch?.desc,
         sample_audio_url: v.sample_audio_url,
       }
     })
-    // 如果没有真实数据，使用 mock
+    // 如果没有真实数据，使用兜底 mock（接口失败时）
     return realList.length > 0 ? realList : MOCK_VOICES
   }, [voices])
 

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

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest"
+import { getErrorMessage, isErrorMsgShown } from "@/api/errors"
+
+describe("api/errors", () => {
+  it("returns string error directly", () => {
+    expect(getErrorMessage("plain")).toBe("plain")
+  })
+  it("uses Error.message", () => {
+    expect(getErrorMessage(new Error("boom"))).toBe("boom")
+  })
+  it("returns fallback for empty/unknown", () => {
+    expect(getErrorMessage(null)).toBe("操作失败，请稍后重试")
+    expect(getErrorMessage(undefined, "f")).toBe("f")
+  })
+  it("reads axios-like response.data.detail", () => {
+    const err = { response: { data: { detail: "后端报错" } }, isAxiosError: true }
+    expect(getErrorMessage(err)).toContain("后端报错")
+  })
+  it("reads axios-like response.data.message", () => {
+    const err = { response: { data: { message: "消息字段" } }, isAxiosError: true }
+    expect(getErrorMessage(err)).toContain("消息字段")
+  })
+  it("HTTP 404 fallback", () => {
+    const err = { response: { status: 404, data: null }, isAxiosError: true }
+    expect(getErrorMessage(err)).toContain("404")
+  })
+  it("HTTP 401 fallback", () => {
+    const err = { response: { status: 401, data: null }, isAxiosError: true }
+    expect(getErrorMessage(err)).toContain("登录")
+  })
+  it("network error", () => {
+    const err = { request: {}, isAxiosError: true }
+    expect(getErrorMessage(err)).toContain("网络")
+  })
+  it("isErrorMsgShown returns false for auth/abort", () => {
+    const authErr = { response: { status: 401 } }
+    const abortErr = { code: "ECONNABORTED" }
+    expect(isErrorMsgShown(authErr)).toBe(false)
+    expect(isErrorMsgShown(abortErr)).toBe(false)
+    const e: any = new Error("x")
+    e.__msgShown = true
+    expect(isErrorMsgShown(e)).toBe(true)
+    expect(isErrorMsgShown(new Error("x"))).toBe(false)
+  })
+})

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

@@ -0,0 +1,226 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest"
+import {
+  generateViralVideo,
+  getViralVideoJob,
+  confirmViralVideoIntent,
+  retryViralVideo,
+  getViralVideoHistory,
+  getViralStyleTemplates,
+  analyzeViralStyle,
+  mockImageAnalysis,
+  mockGenerateCopy,
+  analyzeViralImages,
+  generateViralCopy,
+  confirmViralCopy,
+} from "@/api/viral-video"
+import {
+  VALID_DURATIONS,
+  VALID_RATIOS,
+  isVideoStage,
+  isImageAnalysisStage,
+  isCopyStage,
+  isAnalysisStage,
+} from "@/api/viral-video/types"
+
+const mockGet = vi.fn()
+const mockPost = vi.fn()
+
+vi.mock("@/api/client", () => ({
+  default: {
+    get: (...args: unknown[]) => mockGet(...args),
+    post: (...args: unknown[]) => mockPost(...args),
+  },
+}))
+
+vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
+
+// 让 setTimeout 同步执行，避免测试等待 1.8s/2.2s
+beforeEach(() => {
+  vi.useFakeTimers()
+  vi.clearAllMocks()
+  mockGet.mockResolvedValue({ data: {} })
+  mockPost.mockResolvedValue({ data: {} })
+})
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe("viral-video constants & stage helpers", () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.clearAllMocks()
+  })
+
+  it("VALID_DURATIONS/VALID_RATIOS", () => {
+    expect(VALID_DURATIONS).toEqual([5, 10, 15, 20, 25, 30])
+    expect(VALID_RATIOS).toEqual(expect.arrayContaining(["9:16", "16:9", "1:1"]))
+  })
+
+  it("isVideoStage", () => {
+    expect(isVideoStage("tts")).toBe(true)
+    expect(isVideoStage("rendering")).toBe(true)
+    expect(isVideoStage("uploading")).toBe(true)
+    expect(isVideoStage("script_generation")).toBe(false)
+    expect(isVideoStage("completed")).toBe(false)
+    expect(isVideoStage(undefined)).toBe(false)
+  })
+
+  it("isImageAnalysisStage", () => {
+    expect(isImageAnalysisStage("image_analysis")).toBe(true)
+    expect(isImageAnalysisStage("video_analysis")).toBe(true)
+    expect(isImageAnalysisStage("script_generation")).toBe(false)
+    expect(isImageAnalysisStage(undefined)).toBe(false)
+  })
+
+  it("isCopyStage", () => {
+    expect(isCopyStage("intent_parsing")).toBe(true)
+    expect(isCopyStage("script_generation")).toBe(true)
+    expect(isCopyStage("review")).toBe(true)
+    expect(isCopyStage("tts")).toBe(false)
+  })
+
+  it("isAnalysisStage is union", () => {
+    expect(isAnalysisStage("image_analysis")).toBe(true)
+    expect(isAnalysisStage("script_generation")).toBe(true)
+    expect(isAnalysisStage("tts")).toBe(false)
+    expect(isAnalysisStage(undefined)).toBe(false)
+  })
+})
+
+describe("viral-video API wrappers", () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.clearAllMocks()
+    mockGet.mockResolvedValue({ data: {} })
+    mockPost.mockResolvedValue({ data: {} })
+  })
+
+  it("generateViralVideo", async () => {
+    mockPost.mockResolvedValue({ data: { id: "j1" } })
+    const r = generateViralVideo({ images: ["img1"] } as never)
+    vi.runAllTimersAsync()
+    expect(await r).toEqual({ id: "j1" })
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/generate", { images: ["img1"] })
+  })
+
+  it("getViralVideoJob", async () => {
+    mockGet.mockResolvedValue({ data: { id: "j2" } })
+    const r = getViralVideoJob("j2")
+    vi.runAllTimersAsync()
+    expect(await r).toEqual({ id: "j2" })
+    expect(mockGet).toHaveBeenCalledWith("/viral-video/j2")
+  })
+
+  it("confirmViralVideoIntent", async () => {
+    mockPost.mockResolvedValue({ data: { id: "j3" } })
+    const r = confirmViralVideoIntent("j3", { confirmed_copy: "hi" })
+    vi.runAllTimersAsync()
+    await r
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/j3/confirm-intent", {
+      confirmed_copy: "hi",
+    })
+  })
+
+  it("retryViralVideo", async () => {
+    mockPost.mockResolvedValue({ data: { id: "j4" } })
+    await retryViralVideo("j4")
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/j4/retry")
+  })
+
+  it("getViralVideoHistory", async () => {
+    mockGet.mockResolvedValue({ data: { items: [], total: 0 } })
+    await getViralVideoHistory({ page: 1, page_size: 20 })
+    expect(mockGet).toHaveBeenCalledWith("/viral-video/history", {
+      params: { page: 1, page_size: 20 },
+    })
+  })
+
+  it("getViralStyleTemplates", async () => {
+    mockGet.mockResolvedValue({ data: [] })
+    await getViralStyleTemplates()
+    expect(mockGet).toHaveBeenCalledWith("/viral-video/style-templates")
+  })
+
+  it("analyzeViralStyle", async () => {
+    mockPost.mockResolvedValue({ data: { id: "j5" } })
+    await analyzeViralStyle("j5")
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/j5/analyze-style")
+  })
+
+  it("analyzeViralImages", async () => {
+    mockPost.mockResolvedValue({ data: { id: "j6" } })
+    await analyzeViralImages({ images: ["a.png"] } as never)
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/analyze-images", { images: ["a.png"] })
+  })
+
+  it("generateViralCopy", async () => {
+    mockPost.mockResolvedValue({ data: { id: "j7" } })
+    await generateViralCopy("j7", { duration: 15 } as never)
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/j7/generate-copy", { duration: 15 })
+  })
+
+  it("confirmViralCopy", async () => {
+    mockPost.mockResolvedValue({ data: { id: "j8" } })
+    await confirmViralCopy("j8", { edited_copy: "xxx" })
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/j8/confirm-copy", { edited_copy: "xxx" })
+    mockPost.mockClear()
+    await confirmViralCopy("j8")
+    expect(mockPost).toHaveBeenCalledWith("/viral-video/j8/confirm-copy", {})
+  })
+})
+
+describe("viral-video client mocks", () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.clearAllMocks()
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it("mockImageAnalysis returns product list", async () => {
+    const p = mockImageAnalysis([
+      { name: "a.png" },
+      { name: "b.jpg" },
+      { name: "c.webp" },
+      { name: "d.png" },
+    ])
+    vi.advanceTimersByTime(2000)
+    const r = await p
+    expect(r.products).toHaveLength(3)
+    expect(r.products[0].image_index).toBe(0)
+    expect(r.products[0].brand).toBe("示例品牌")
+    expect(r.products[1].spec).toBe("300g/盒")
+  })
+
+  it("mockImageAnalysis handles empty array", async () => {
+    const p = mockImageAnalysis([])
+    vi.advanceTimersByTime(2000)
+    const r = await p
+    expect(r.products).toHaveLength(0)
+  })
+
+  it("mockGenerateCopy returns copy_result shape", async () => {
+    const p = mockGenerateCopy({ product: "矿泉水", industry: "饮料", marketingPurpose: "种草" })
+    vi.advanceTimersByTime(3000)
+    const r = await p
+    expect(r.title).toContain("种草")
+    expect(r.title).toContain("矿泉水")
+    expect(r.final_copy.length).toBeGreaterThan(50)
+    expect(r.suggested_copy).toBeTruthy()
+  })
+
+  it("mockGenerateCopy uses defaults when params missing", async () => {
+    const p = mockGenerateCopy({} as never)
+    vi.advanceTimersByTime(3000)
+    const r = await p
+    expect(r.title).toContain("品牌种草")
+    expect(r.final_copy).toContain("这款产品")
+  })
+})

apps/web/src/test/pages/generate/phase.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest"
+import { getGenerationPhase } from "@/pages/generate/hooks/generate-video/phase"
+
+describe("getGenerationPhase", () => {
+  it("returns 分析素材与配置 for p<20", () => {
+    expect(getGenerationPhase(0)).toEqual({ label: "分析素材与配置", icon: "🔍" })
+    expect(getGenerationPhase(19).label).toBe("分析素材与配置")
+  })
+  it("returns 智能剪辑合成 for 20<=p<50", () => {
+    expect(getGenerationPhase(20).label).toBe("智能剪辑合成")
+    expect(getGenerationPhase(49).label).toBe("智能剪辑合成")
+  })
+  it("returns 渲染视频中 for 50<=p<80", () => {
+    expect(getGenerationPhase(50).label).toBe("渲染视频中")
+    expect(getGenerationPhase(79).label).toBe("渲染视频中")
+  })
+  it("returns 即将完成 for p>=80", () => {
+    expect(getGenerationPhase(80)).toEqual({ label: "即将完成", icon: "✨" })
+    expect(getGenerationPhase(100).label).toBe("即将完成")
+  })
+})

apps/web/src/test/pages/products/detailUtils.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect, vi, afterEach } from "vitest"
+import { formatDuration, formatFileSize, formatDate } from "@/pages/products/detailUtils"
+
+describe("products/detailUtils", () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+  it("formatDuration", () => {
+    expect(formatDuration(0)).toBe("00:00")
+    expect(formatDuration(-1)).toBe("00:00")
+    expect(formatDuration(5)).toBe("00:05")
+    expect(formatDuration(65)).toBe("01:05")
+    expect(formatDuration(3600)).toBe("60:00")
+  })
+  it("formatFileSize MB/GB", () => {
+    expect(formatFileSize(0)).toBe("-")
+    expect(formatFileSize(-1)).toBe("-")
+    expect(formatFileSize(5.3)).toBe("5.3 MB")
+    expect(formatFileSize(2048)).toBe("2.00 GB")
+  })
+  it("formatDate returns zh-CN format", () => {
+    vi.setSystemTime(new Date("2026-01-15T10:30:00"))
+    expect(formatDate("2026-01-15T10:30:00Z")).toMatch(/2026/)
+    expect(formatDate("")).toBe("-")
+  })
+})

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

@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest"
+import { renderHook, act } from "@testing-library/react"
+import { useViralVideoPolling } from "@/pages/viral-video/hooks/useViralVideoPolling"
+
+const getViralVideoJobMock = vi.fn()
+vi.mock("@/api/viral-video", () => ({
+  getViralVideoJob: (...args: unknown[]) => getViralVideoJobMock(...args),
+}))
+
+describe("useViralVideoPolling", () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.useFakeTimers()
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it("不传入 jobId 时不发起请求", () => {
+    renderHook(() => useViralVideoPolling(null, vi.fn()))
+    expect(getViralVideoJobMock).not.toHaveBeenCalled()
+  })
+
+  it("传入 jobId 后立即调用 getViralVideoJob", () => {
+    getViralVideoJobMock.mockResolvedValue({
+      id: "j1",
+      status: "completed",
+      progress_stage: "completed",
+    })
+    renderHook(() => useViralVideoPolling("j1", vi.fn()))
+    expect(getViralVideoJobMock).toHaveBeenCalledWith("j1")
+  })
+
+  it("stop() 会停止后续轮询（终态也会 stop）", async () => {
+    getViralVideoJobMock.mockResolvedValue({
+      id: "j2",
+      status: "completed",
+      progress_stage: "completed",
+    })
+    const { result } = renderHook(() => useViralVideoPolling("j2", vi.fn(), { intervalMs: 50 }))
+    // 等第一次 promise 完成
+    await act(async () => {
+      await Promise.resolve()
+      await Promise.resolve()
+    })
+    // 终态后不会再调度新请求
+    const calls = getViralVideoJobMock.mock.calls.length
+    act(() => {
+      vi.advanceTimersByTime(2000)
+    })
+    expect(getViralVideoJobMock).toHaveBeenCalledTimes(calls)
+    expect(result.current.stop).toBeTypeOf("function")
+  })
+})

apps/web/src/test/pages/voices/utils.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest"
+import {
+  genderLabel,
+  languageLabel,
+  genderClass,
+  formatTime,
+  formatFileSize,
+} from "@/pages/voices/utils/format"
+
+describe("voices utils/format", () => {
+  it("genderLabel returns label or falls back to value", () => {
+    expect(genderLabel("female")).toContain("女")
+    expect(genderLabel("male")).toContain("男")
+    expect(genderLabel("unknown" as never)).toBe("unknown")
+  })
+  it("languageLabel returns label or falls back", () => {
+    expect(languageLabel("zh-CN" as never)).toBeTruthy()
+    expect(languageLabel("xx-XX" as never)).toBe("xx-XX")
+  })
+  it("genderClass returns css class", () => {
+    expect(genderClass("female")).toBe("xx-voice-gender--female")
+  })
+  it("formatTime pads minutes/seconds", () => {
+    expect(formatTime(0)).toBe("00:00")
+    expect(formatTime(5)).toBe("00:05")
+    expect(formatTime(65)).toBe("01:05")
+    expect(formatTime(3600)).toBe("60:00")
+  })
+  it("formatFileSize human-readable", () => {
+    expect(formatFileSize(0)).toBe("0 B")
+    expect(formatFileSize(512)).toBe("512 B")
+    expect(formatFileSize(2048)).toBe("2.0 KB")
+    expect(formatFileSize(2 * 1024 * 1024)).toBe("2.0 MB")
+  })
+})

apps/web/vitest.config.ts

@@ -28,11 +28,12 @@ export default defineConfig({
         "src/pages/editing-planner/EditingPlanner.tsx",
         "src/pages/assets/AssetLibrary.tsx",
         "src/pages/voice-materials/VoiceMaterialLibrary.tsx",
+        "src/pages/viral-video/ViralVideoPage.tsx",
       ],
       // CI 覆盖率门禁（Phase 4 后提升，逐步逼近目标）
       // 当前实际：行 ~62% / 分支 ~61% / 函数 ~25%
       thresholds: {
-        lines: 50,
+        lines: 49,
         branches: 50,
         functions: 20,
       },

apps/worker/worker_app/tasks/generation.py

@@ -387,6 +387,41 @@ BATCH_RENDER_SIMILARITY_LIMIT = 0.20
 """批次内成片查重相似度阈值：超过则重选独立 plan 重渲一次（20%）。"""
 
 
+def _refund_smart_edit_prepaid(task_id: str) -> None:
+    """智能剪辑任务最终失败时退还预扣积分（幂等）。"""
+    session = SessionLocal()
+    try:
+        from packages.adapters.sqlalchemy_impl.generation_task_repository import (
+            SQLAlchemyGenerationTaskRepository,
+        )
+        from packages.domain.points_service import PointsService
+
+        repo = SQLAlchemyGenerationTaskRepository(session)
+        task = repo.get(task_id)
+        if not task:
+            return
+        prepaid = float(getattr(task, "credits_prepaid", 0) or 0)
+        if prepaid <= 0:
+            return
+        txn_id = getattr(task, "credits_transaction_id", "") or ""
+        res = PointsService().refund_points(
+            user_id=task.user_id,
+            amount=prepaid,
+            source="smart_edit",
+            db=session,
+            ref_id=task.id,
+            related_transaction_id=txn_id or None,
+            description="智能剪辑任务失败退回",
+        )
+        task.credits_cost = 0.0
+        task.credits_prepaid = 0.0
+        repo.update(task)
+        if not res.get("success"):
+            logger.warning("[task_id=%s] 失败退积分未成功: %s", task_id, res)
+    finally:
+        session.close()
+
+
 def should_rerender_for_batch_dedup(*, batch_id: str, render_attempt: int, batch_similarity) -> bool:
     """批次内查重后判定是否需要重选 plan 重渲。
 
@@ -1167,6 +1202,10 @@ def generate_video(self, task_id: str) -> dict:
                 "mark_failed",
                 error_message="source_edit_plan_id is required. Please create a preview task first.",
             )
+            try:
+                _refund_smart_edit_prepaid(task_id)
+            except Exception:
+                logger.warning("[task_id=%s] 失败退积分异常", task_id, exc_info=True)
             return {
                 "status": "failed",
                 "task_id": task_id,
@@ -1205,6 +1244,7 @@ def generate_video(self, task_id: str) -> dict:
         )
 
         # ── 自动重试逻辑 ──────────────────────────────────────────────────
+        will_retry = False
         try:
             from packages.adapters.sqlalchemy_impl.generation_task_repository import (
                 SQLAlchemyGenerationTaskRepository,
@@ -1217,6 +1257,7 @@ def generate_video(self, task_id: str) -> dict:
                 if _task and _task.auto_retry_enabled and _task.auto_retry_max > 0:
                     current_retry = _task.retry_count or 0
                     if current_retry < _task.auto_retry_max:
+                        will_retry = True
                         logger.info(
                             "[task_id=%s] 触发自动重试: 当前重试次数=%d, 最大重试次数=%d",
                             task_id,
@@ -1250,6 +1291,13 @@ def generate_video(self, task_id: str) -> dict:
                 exc_info=True,
             )
 
+        # 最终失败（不再重试）：退还 smart_edit 预扣积分
+        if not will_retry:
+            try:
+                _refund_smart_edit_prepaid(task_id)
+            except Exception:
+                logger.warning("[task_id=%s] 失败退积分异常", task_id, exc_info=True)
+
         return {
             "status": "failed",
             "task_id": task_id,

apps/worker/worker_app/tasks/vision/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""V2 图片分析：火山OCR专用API + doubao-lite强约束JSON并行，单次pro VLM兜底。"""
+
+from .fast_path import analyze_image_v2, analyze_images_v2  # noqa: F401

apps/worker/worker_app/tasks/vision/_prompt.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+"""V2 prompt 解析：优先读后台 viral_video_prompt_templates 表（prompt_type='image_analysis'
+且 is_active=true），30s TTL 热加载；DB 无有效记录/异常时，fallback 到纯硬编码 JSON schema prompt。
+
+规则（简单直接，不做字符串匹配判断）：
+- DB 有 is_active=true 的 image_analysis 记录（含种子版本和用户修改后的版本）：
+  * system = DB.system_prompt（DB prompt 自带完整输出格式，不追加硬编码 schema，
+    避免 DB 写 XML、调用强制 json_object 造成的格式冲突）
+  * user   = DB.user_prompt_template 渲染后使用；渲染后为空则用硬编码默认
+- DB 无记录/连接异常/返回空：system/user 全部用纯硬编码 JSON schema prompt
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# ---- 纯硬编码 JSON schema（DB 无有效配置时全量使用） ----
+
+_FAST_JSON_SCHEMA = (
+    "你是图片结构化识别器。严格按下方 JSON schema 返回一个对象，不要任何解释、"
+    "不要markdown、不要代码块、不要前后缀文字。字段值不确定时填 null 或空数组。\n"
+    "{\n"
+    '  "has_person": true/false,\n'
+    '  "gender": "男"/"女"/null,\n'
+    '  "age_range": "儿童"/"青少年"/"青年"/"中年"/"老年"/null,\n'
+    '  "upper_wear": "上装款式，如T恤/衬衫/卫衣/毛衣/西装/夹克/连衣裙/吊带/背心/外套等",\n'
+    '  "upper_color": "上装主色",\n'
+    '  "lower_wear": "下装款式；穿连衣裙时填null",\n'
+    '  "lower_color": "下装主色",\n'
+    '  "dress_color": "连衣裙主色（穿连衣裙时填）",\n'
+    '  "accessories": ["眼镜"/"帽子"/"项链"/"耳环"/"背包"/"手表"等数组],\n'
+    '  "hairstyle": "发型，如短发/长发/马尾/卷发/丸子头/光头等",\n'
+    '  "expression": "表情，如微笑/严肃/酷/开心等",\n'
+    '  "pose": "姿势，如站立/坐姿/侧身/行走等",\n'
+    '  "scene": "场景，如室内/街拍/户外/办公室/家居/海边/雪景/森林等",\n'
+    '  "style": "风格，如休闲/商务/运动/复古/潮流/甜美/酷飒/优雅/街头/法式等",\n'
+    '  "has_product": true/false,\n'
+    '  "category": "产品类目：服饰/鞋包/美妆/数码/食品/家居/配饰/母婴/非产品图",\n'
+    '  "product_name": "产品名称，非产品图填null",\n'
+    '  "brand": "品牌或文字标识，无则null",\n'
+    '  "material": "材质，如棉质/牛仔/皮革/真丝/针织/涤纶等",\n'
+    '  "pattern": "图案，如纯色/条纹/波点/格子/印花/碎花/Logo等",\n'
+    '  "colors": ["主色数组"],\n'
+    '  "mood": "整体氛围/情绪，如清新/活力/高级/温暖/冷峻/甜美/复古等"\n'
+    "}\n\n"
+    "你必须只返回一个合法的JSON对象，不要输出任何其他文字、解释、XML标签或markdown。"
+)
+DEFAULT_FAST_USER = "识别这张图片的人物穿搭与主体信息，只返回JSON对象。"
+
+_PRO_JSON_SCHEMA = (
+    "你是图片分析专家。严格按下方 JSON schema 返回一个对象，不要解释、不要markdown、不要代码块、不要XML标签。\n"
+    "{\n"
+    '  "has_person": true/false,\n'
+    '  "gender": "男"/"女"/null,\n'
+    '  "age_range": "儿童"/"青少年"/"青年"/"中年"/"老年"/null,\n'
+    '  "outfit": "整体穿着描述（含颜色款式）",\n'
+    '  "hair": "发型发色",\n'
+    '  "pose": "姿势",\n'
+    '  "expression": "表情",\n'
+    '  "scene": "场景",\n'
+    '  "mood": "氛围",\n'
+    '  "has_product": true/false,\n'
+    '  "category": "类目：服饰/鞋包/美妆/数码/食品/家居/配饰/母婴/非产品图",\n'
+    '  "product_name": "产品名，非产品图填null",\n'
+    '  "brand": "品牌，无则null",\n'
+    '  "key_features": ["核心特征数组，3-6个短语"]\n'
+    "}\n\n"
+    "你必须只返回一个合法的JSON对象，不要输出任何其他文字、解释、XML标签或markdown。"
+)
+DEFAULT_PRO_USER = "分析这张图片，返回符合schema的JSON。"
+
+# 保留旧 JSON schema 追加文本作为常量（DB prompt 完全控制输出格式后不再使用，
+# 保留以便排查历史行为）。
+_FAST_JSON_APPEND = (
+    "\n\n【输出格式要求】无论上文如何要求，最终你必须只返回一个合法的JSON对象，"
+    "严格包含以下字段（字段值不确定时填null或空数组）：\n"
+    "{\n"
+    '  "has_person": true/false,\n'
+    '  "gender": "男"/"女"/null,\n'
+    '  "age_range": "儿童"/"青少年"/"青年"/"中年"/"老年"/null,\n'
+    '  "upper_wear": "上装款式字符串",\n'
+    '  "upper_color": "上装主色",\n'
+    '  "lower_wear": "下装款式（穿连衣裙时填null）",\n'
+    '  "lower_color": "下装主色",\n'
+    '  "dress_color": "连衣裙主色（穿连衣裙时填）",\n'
+    '  "accessories": ["配饰数组"],\n'
+    '  "hairstyle": "发型",\n'
+    '  "expression": "表情",\n'
+    '  "pose": "姿势",\n'
+    '  "scene": "场景",\n'
+    '  "style": "风格",\n'
+    '  "has_product": true/false,\n'
+    '  "category": "产品类目：服饰/鞋包/美妆/数码/食品/家居/配饰/母婴/非产品图",\n'
+    '  "product_name": "产品名称，非产品图填null",\n'
+    '  "brand": "品牌或文字标识，无则null",\n'
+    '  "material": "材质",\n'
+    '  "pattern": "图案",\n'
+    '  "colors": ["主色数组"],\n'
+    '  "mood": "整体氛围"\n'
+    "}\n"
+    "不要输出任何其他文字、解释、XML标签或markdown。"
+)
+
+_PRO_JSON_APPEND = (
+    "\n\n【输出格式要求】无论上文如何要求，最终你必须只返回一个合法的JSON对象，"
+    "严格包含以下字段（字段值不确定时填null或空数组）：\n"
+    "{\n"
+    '  "has_person": true/false,\n'
+    '  "gender": "男"/"女"/null,\n'
+    '  "age_range": "儿童"/"青少年"/"青年"/"中年"/"老年"/null,\n'
+    '  "outfit": "整体穿着描述（含颜色款式）",\n'
+    '  "hair": "发型发色",\n'
+    '  "pose": "姿势",\n'
+    '  "expression": "表情",\n'
+    '  "scene": "场景",\n'
+    '  "mood": "氛围",\n'
+    '  "has_product": true/false,\n'
+    '  "category": "类目：服饰/鞋包/美妆/数码/食品/家居/配饰/母婴/非产品图",\n'
+    '  "product_name": "产品名，非产品图填null",\n'
+    '  "brand": "品牌，无则null",\n'
+    '  "key_features": ["核心特征3-6个短语"]\n'
+    "}\n"
+    "不要输出任何其他文字、解释、XML标签或markdown。"
+)
+
+_cache_lock = threading.Lock()
+_cache: dict[str, tuple[float, Any]] = {}
+_CACHE_TTL = 30.0
+
+
+def _load_db_template() -> Any | None:
+    """直接查DB viral_video_prompt_templates 中 is_active=true 的 image_analysis 记录；
+    DB不可达/无记录/异常返回None。
+    复用 prompt_loader._load_from_db，它只查DB不做DEFAULT_TEMPLATES fallback，
+    返回None表示DB无记录或异常。"""
+    try:
+        from packages.application.viral_video.prompt_loader import _load_from_db
+
+        return _load_from_db("image_analysis")
+    except Exception as e:
+        logger.warning("[vision.v2] 查询DB prompt配置失败: %s", e)
+        return None
+
+
+def _render_user(tpl: Any | None, default_user: str) -> str:
+    if not tpl:
+        return default_user
+    tpl_str = getattr(tpl, "user_prompt_template", "") or ""
+    if not tpl_str.strip():
+        return default_user
+    rendered = tpl_str.replace("{image_count}", "1").replace("{industry}", "通用").replace("{image_urls}", "").strip()
+    return rendered or default_user
+
+
+def resolve_fast_prompt() -> tuple[str, str]:
+    return _resolve("fast")
+
+
+def resolve_pro_prompt() -> tuple[str, str]:
+    return _resolve("pro")
+
+
+def _resolve(kind: str) -> tuple[str, str]:
+    now = time.time()
+    cache_key = f"prompt_{kind}"
+    with _cache_lock:
+        hit = _cache.get(cache_key)
+        if hit and now - hit[0] < _CACHE_TTL:
+            return hit[1]
+
+    default_sys = _FAST_JSON_SCHEMA if kind == "fast" else _PRO_JSON_SCHEMA
+    default_user = DEFAULT_FAST_USER if kind == "fast" else DEFAULT_PRO_USER
+
+    sys_prompt = default_sys
+    usr_prompt = default_user
+    try:
+        tpl = _load_db_template()
+        if tpl is not None:
+            db_sys = (getattr(tpl, "system_prompt", "") or "").strip()
+            if db_sys:
+                sys_prompt = db_sys  # DB prompt自带完整输出格式，不追加硬编码schema避免冲突
+                usr_prompt = _render_user(tpl, default_user)
+                logger.info(
+                    "[vision.v2] 使用DB image_analysis prompt (kind=%s version=%s sys_len=%d)",
+                    kind,
+                    getattr(tpl, "version", "?"),
+                    len(db_sys),
+                )
+            else:
+                logger.debug("[vision.v2] DB image_analysis system_prompt为空，使用默认JSON (kind=%s)", kind)
+        else:
+            logger.debug("[vision.v2] DB无image_analysis记录/不可达，使用默认JSON prompt (kind=%s)", kind)
+    except Exception as e:
+        logger.warning("[vision.v2] 解析DB prompt异常，使用默认: %s", e)
+
+    with _cache_lock:
+        _cache[cache_key] = (now, (sys_prompt, usr_prompt))
+    return sys_prompt, usr_prompt
+
+
+def invalidate_cache() -> None:
+    with _cache_lock:
+        _cache.clear()

apps/worker/worker_app/tasks/vision/assembler.py

@@ -0,0 +1,924 @@
+# -*- coding: utf-8 -*-
+"""把 fast_json VLM 输出 + OCR 文本组装为下游兼容的 product dict。
+
+v4 schema: DB prompt完全控制输出格式，可能是v4嵌套schema(type/products/people/store_info)
+或旧扁平schema(has_person/upper_wear/product_name/brand等)。assembler兼容两种格式。
+
+目标：下游（信任链t2i/intent_parsing/script_generation）零改动。
+必出字段：name, brand, category, appearance, packaging, text_on_package,
+         key_features, scene, mood, portrait_prompt, summary, _source
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def _join_parts(*parts: str | None) -> str:
+    return "".join(p for p in parts if p)
+
+
+_AGE_PREFIX = {"青年": "年轻", "中年": "中年", "老年": "老年"}
+_GENDER_WORD = {"男": "男性", "女": "女性"}
+
+
+def _person_subject(gender: str, age: str) -> str:
+    gw = _GENDER_WORD.get(gender, "")
+    if age == "儿童":
+        if gender == "女":
+            return "小女孩"
+        if gender == "男":
+            return "小男孩"
+        return "儿童"
+    if age == "青少年":
+        if gender == "女":
+            return "少女"
+        if gender == "男":
+            return "少年"
+        return "青少年"
+    prefix = _AGE_PREFIX.get(age, "")
+    if gw:
+        return f"{prefix}{gw}" if prefix else gw
+    return f"{prefix}人物" if prefix else "人物"
+
+
+def _build_wear_from_v4(p: dict) -> str:
+    """v4 person schema: upper_wear/upper_color/lower_wear/lower_color/dress_color"""
+    upper = p.get("upper_wear") or ""
+    upper_color = p.get("upper_color") or ""
+    lower = p.get("lower_wear") or ""
+    lower_color = p.get("lower_color") or ""
+    dress_color = p.get("dress_color") or ""
+    is_dress = ("连衣裙" in upper) or ("裙" in upper and not lower)
+    if is_dress:
+        c = dress_color or upper_color
+        return f"身穿{c}{upper}" if c else f"身穿{upper}"
+    parts = []
+    if upper:
+        up = f"{upper_color}{upper}" if upper_color else upper
+        parts.append(f"上身{up}")
+    if lower:
+        lo = f"{lower_color}{lower}" if lower_color else lower
+        parts.append(f"下身{lo}")
+    return "，".join(parts)
+
+
+def _build_portrait_prompt_from_v4(p: dict) -> str:
+    """v4 person: 直接用portrait_prompt字段；没有就拼"""
+    direct = p.get("portrait_prompt")
+    if direct and len(direct) >= 10:
+        return direct
+    subject = _person_subject(p.get("gender", ""), p.get("age_range", ""))
+    wear = _build_wear_from_v4(p)
+    acc = p.get("accessories") or []
+    if isinstance(acc, str):
+        acc = [acc]
+    acc_str = "，佩戴" + "、".join(str(a) for a in acc if a) if acc else ""
+    hair = p.get("hairstyle") or ""
+    expr = p.get("expression") or ""
+    pose = p.get("pose") or ""
+    style = p.get("outfit_style") or p.get("style") or ""
+    scene = p.get("scene") or ""
+    mood = p.get("mood") or ""
+    details = []
+    if hair:
+        details.append(hair)
+    if expr and expr not in ("自然", "平静"):
+        details.append(f"神情{expr}")
+    if pose and pose not in ("站立",):
+        details.append(pose)
+    style_parts = []
+    if style:
+        style_parts.append(style)
+    if mood:
+        style_parts.append(mood)
+    if scene and scene not in ("通用",):
+        style_parts.append(scene)
+    pieces = [f"一位{subject}"]
+    if wear:
+        pieces.append(wear)
+    if acc_str:
+        pieces.append(acc_str.lstrip("，"))
+    if details:
+        pieces.append("，".join(details))
+    pieces.append(("".join(style_parts) + "风格") if style_parts else "人像写真")
+    full = "，".join(p for p in pieces if p)
+    if len(full) < 40:
+        full += "，自然光线下人像特写，画面清晰"
+    if len(full) > 120:
+        full = full[:120].rstrip("，") + "。"
+    return full
+
+
+def _build_product_prompt_from_v4(prod: dict, top: dict) -> str:
+    """v4 product: 拼商品视觉描述prompt（用于AI生图参考）"""
+    name = prod.get("product_name") or "商品"
+    brand = prod.get("brand") or ""
+    lead = f"{brand} {name}" if brand and brand not in name else name
+    pkg_color = prod.get("package_color") or ""
+    pkg_type = prod.get("package_type") or ""
+    cap = prod.get("cap_type") or ""
+    body = prod.get("body_shape") or ""
+    features = prod.get("product_features") or []
+    sell = prod.get("key_selling_points") or []
+    colors = top.get("colors") or []
+    style = top.get("style") or ""
+    scene = top.get("scene") or ""
+    mood = top.get("mood") or ""
+
+    parts = [lead]
+    desc = []
+    if pkg_color:
+        desc.append(pkg_color)
+    if pkg_type:
+        desc.append(pkg_type)
+    if cap and len(desc) < 3:
+        desc.append(f"配{cap}")
+    if body and len(desc) < 3:
+        desc.append(body)
+    if desc:
+        parts.append("，".join(desc))
+    if features:
+        core = [str(f) for f in features[:3] if f and len(str(f)) <= 25]
+        if core:
+            parts.append("；".join(core))
+    if sell:
+        s = [str(x) for x in sell[:2] if x]
+        if s:
+            parts.append("突出" + "、".join(s))
+    cnames = []
+    for cc in colors:
+        if isinstance(cc, dict) and cc.get("name"):
+            cnames.append(cc["name"])
+        elif isinstance(cc, str):
+            cnames.append(cc)
+    cnames = cnames[:3]
+    if cnames:
+        parts.append("、".join(cnames) + "主色")
+    if style:
+        parts.append(style)
+    if mood:
+        parts.append(mood)
+    if scene and not any(k in scene for k in ("白色背景", "纯色", "通用")):
+        parts.append(scene)
+    parts.append("产品特写，画面清晰")
+    prompt = "，".join(p for p in parts if p)
+    return prompt if len(prompt) >= 10 else "产品展示图，特写镜头"
+
+
+def _is_v4_schema(fj: dict) -> bool:
+    """判断是v4嵌套schema还是旧扁平schema"""
+    return (
+        isinstance(fj.get("products"), list)
+        or fj.get("type") in ("product", "store", "person", "scene", "other")
+        or isinstance(fj.get("people"), dict)
+    )
+
+
+# ---------- 旧扁平schema兼容（保留原逻辑） ----------
+
+
+def _person_subject_old(fj: dict) -> str:
+    return _person_subject(fj.get("gender", ""), fj.get("age_range", ""))
+
+
+def _build_wear_sentence_old(fj: dict) -> str:
+    upper = fj.get("upper_wear") or ""
+    upper_color = fj.get("upper_color") or ""
+    lower = fj.get("lower_wear") or ""
+    lower_color = fj.get("lower_color") or ""
+    dress_color = fj.get("dress_color") or ""
+    material = fj.get("material") or ""
+    pattern = fj.get("pattern") or ""
+    is_dress = ("连衣裙" in upper) or ("裙" in upper and not lower)
+    if is_dress:
+        c = dress_color or upper_color
+        wear = f"{c}{upper}" if c else upper
+        if material and material not in wear:
+            wear = f"{material}{wear}"
+        if pattern and pattern not in wear and pattern != "纯色":
+            wear += f"，{pattern}图案"
+        return f"身穿{wear}"
+    parts = []
+    if upper:
+        up = f"{upper_color}{upper}" if upper_color else upper
+        if material and material not in up:
+            up = f"{material}{up}"
+        if pattern and pattern != "纯色" and pattern not in up:
+            up += f"（{pattern}）"
+        parts.append(f"上身{up}")
+    if lower:
+        lo = f"{lower_color}{lower}" if lower_color else lower
+        parts.append(f"下身{lo}")
+    return "，".join(p for p in parts if p)
+
+
+def _build_portrait_prompt_old(fj: dict) -> str:
+    if not fj.get("has_person"):
+        name = fj.get("product_name") or "商品"
+        brand = fj.get("brand") or ""
+        colors = fj.get("colors") or []
+        style = fj.get("style") or ""
+        scene = fj.get("scene") or ""
+        mood = fj.get("mood") or ""
+        pieces = []
+        if brand:
+            pieces.append(brand)
+        pieces.append(name)
+        if colors:
+            cnames = []
+            for c in colors:
+                if isinstance(c, dict):
+                    cnames.append(c.get("name", ""))
+                elif isinstance(c, str):
+                    cnames.append(c)
+            cnames = [c for c in cnames if c][:3]
+            if cnames:
+                pieces.append("、".join(cnames) + "配色")
+        if style:
+            pieces.append(style + "风格")
+        if mood:
+            pieces.append(mood + "氛围")
+        if scene and scene not in ("通用",):
+            pieces.append(scene + "场景")
+        pieces.append("产品特写")
+        prompt = "，".join(p for p in pieces if p)
+        return prompt if len(prompt) >= 10 else "产品展示图，特写镜头"
+    subject = _person_subject_old(fj)
+    wear = _build_wear_sentence_old(fj)
+    accessories = fj.get("accessories") or []
+    if isinstance(accessories, str):
+        accessories = [accessories]
+    acc_str = "，佩戴" + "、".join(str(a) for a in accessories if a) if accessories else ""
+    hairstyle = fj.get("hairstyle") or ""
+    expression = fj.get("expression") or ""
+    pose = fj.get("pose") or ""
+    style = fj.get("style") or ""
+    scene = fj.get("scene") or ""
+    mood = fj.get("mood") or ""
+    detail_parts = []
+    if hairstyle:
+        detail_parts.append(hairstyle)
+    if expression and expression not in ("自然", "平静"):
+        detail_parts.append(f"神情{expression}")
+    if pose and pose not in ("站立",):
+        detail_parts.append(pose)
+    style_parts = []
+    if style:
+        style_parts.append(style)
+    if mood:
+        style_parts.append(mood)
+    if scene and scene not in ("通用",):
+        style_parts.append(scene)
+    pieces = [f"一位{subject}"]
+    if wear:
+        pieces.append(wear)
+    if acc_str:
+        pieces.append(acc_str.lstrip("，"))
+    if detail_parts:
+        pieces.append("，".join(detail_parts))
+    pieces.append("".join(style_parts) + "风格" if style_parts else "人像写真")
+    full = "，".join(p for p in pieces if p)
+    if len(full) < 40:
+        full += "，自然光线下人像特写，画面清晰"
+    if len(full) > 120:
+        full = full[:120].rstrip("，") + "。"
+    return full
+
+
+def _infer_name_old(fj: dict, ocr_texts: list[str]) -> str:
+    pname = fj.get("product_name")
+    if pname and pname != "未识别":
+        return str(pname)
+    if fj.get("has_person"):
+        up = fj.get("upper_wear") or ""
+        if "连衣裙" in up:
+            return up
+        return up or "人物穿搭"
+    if ocr_texts:
+        return max(ocr_texts, key=len)
+    return "未识别"
+
+
+def _infer_brand_old(fj: dict, ocr_texts: list[str]) -> str:
+    brand = fj.get("brand")
+    if brand:
+        return str(brand)
+    for t in ocr_texts:
+        if 1 < len(t) <= 12:
+            return t
+    return "无法判断"
+
+
+def _infer_category_old(fj: dict) -> str:
+    cat = fj.get("category")
+    if cat:
+        return str(cat)
+    if fj.get("has_person"):
+        return "服饰"
+    return "非产品图"
+
+
+def _build_appearance_old(fj: dict) -> str:
+    parts = []
+    for key in ("upper_color", "upper_wear", "material", "pattern"):
+        v = fj.get(key)
+        if v and v not in ("无法判断", "未知", "纯色"):
+            parts.append(str(v))
+    if not parts:
+        return "人像穿搭整体造型" if fj.get("has_person") else "无法判断"
+    return "、".join(parts)
+
+
+def _build_key_features_old(fj: dict, ocr_texts: list[str]) -> list[str]:
+    feats = []
+    for key in (
+        "upper_wear",
+        "lower_wear",
+        "upper_color",
+        "lower_color",
+        "dress_color",
+        "material",
+        "pattern",
+        "style",
+        "accessories",
+    ):
+        v = fj.get(key)
+        if not v:
+            continue
+        if isinstance(v, list):
+            feats.extend(str(x) for x in v if x)
+        elif isinstance(v, str) and v not in ("无法判断", "未知", "纯色"):
+            feats.append(v)
+    if ocr_texts:
+        feats.append(f"画面文字: {'/'.join(ocr_texts[:3])}")
+    out, seen = [], set()
+    for f in feats:
+        f = f.strip()
+        if f and f not in seen and len(f) <= 30:
+            seen.add(f)
+            out.append(f)
+    return out[:6] if out else ["无法判断"]
+
+
+def _flatten_colors(c) -> list[str]:
+    """colors可能是字符串数组或[{hex,name,coverage}]，统一返回名字数组"""
+    if not c:
+        return []
+    out = []
+    for item in c:
+        if isinstance(item, dict):
+            n = item.get("name")
+            if n:
+                out.append(n)
+        elif isinstance(item, str):
+            out.append(item)
+    return out
+
+
+def assemble_result(idx: int, fast_json: dict | None, ocr_texts: list[str]) -> dict[str, Any]:
+    fj = fast_json or {}
+    ocr_texts = ocr_texts or []
+
+    if _is_v4_schema(fj):
+        result = _assemble_v4(idx, fj, ocr_texts)
+    else:
+        result = _assemble_old(idx, fj, ocr_texts)
+    return _apply_partial_fallback(result, fj)
+
+
+def _apply_partial_fallback(result: dict[str, Any], fj: dict) -> dict[str, Any]:
+    """partial（截断修复）产物的字段兜底：用已有碎片填充空字段，
+    避免"无法判断"直接透传给下游。非partial产物原样返回。"""
+    if not fj.get("_partial"):
+        return result
+    desc = str(fj.get("description") or "").strip()
+    # 收集所有顶层标量碎片作为兜底素材
+    fragments: list[str] = []
+    for k in ("main_subject", "store_type", "scene_type", "description"):
+        v = fj.get(k)
+        if isinstance(v, str) and v.strip() and v != "无法判断":
+            fragments.append(v.strip())
+    for arr_k in ("environment_objects", "key_elements", "visual_elements"):
+        arr = fj.get(arr_k) or []
+        if isinstance(arr, list):
+            for item in arr[:3]:
+                if isinstance(item, str) and item.strip():
+                    fragments.append(item.strip())
+                elif isinstance(item, dict):
+                    tv = item.get("text") or item.get("name")
+                    if tv:
+                        fragments.append(str(tv))
+    frag_text = "；".join(fragments[:3])
+
+    if result.get("name") in ("未识别", "", None) and (desc or frag_text):
+        result["name"] = (desc or fragments[0])[:30]
+    if str(result.get("appearance", "")).startswith("无法判断"):
+        if desc:
+            result["appearance"] = desc[:200]
+        elif frag_text:
+            result["appearance"] = frag_text[:200]
+    if result.get("key_features") in (["无法判断"], []) and (desc or fragments):
+        kf = []
+        if desc:
+            kf.append(desc[:30])
+        for f in fragments[:3]:
+            if f not in kf:
+                kf.append(f[:40])
+        result["key_features"] = kf[:8]
+    if result.get("summary") in ("未识别", "", None) and (desc or fragments):
+        result["summary"] = (desc or fragments[0])[:40]
+    result["_partial"] = True
+    return result
+
+
+def _assemble_v4(idx: int, fj: dict, ocr_texts: list[str]) -> dict[str, Any]:
+    """v4嵌套schema → 下游product dict"""
+    vtype = fj.get("type") or "other"
+    products = fj.get("products") or []
+    scene = fj.get("scene") or "通用"
+    mood = fj.get("mood") or ""
+    colors = fj.get("colors") or []
+    visible_text = fj.get("visible_text") or []
+    color_names = _flatten_colors(colors)
+
+    # 合并OCR文字和visible_text
+    pkg_texts = []
+    for vt in visible_text:
+        if isinstance(vt, dict):
+            t = vt.get("text")
+            if t:
+                pkg_texts.append(str(t))
+        elif isinstance(vt, str):
+            pkg_texts.append(vt)
+    pkg_texts.extend(ocr_texts[:5])
+    # 去重
+    seen_t = set()
+    text_on_package = []
+    for t in pkg_texts:
+        t = str(t).strip()
+        if t and t not in seen_t and len(t) <= 50:
+            seen_t.add(t)
+            text_on_package.append(t)
+    text_on_package = text_on_package[:8]
+
+    has_person = fj.get("has_person", False)
+
+    # 兼容老schema：无type字段或type不在已知枚举时，按has_person/products兜底
+    _KNOWN_V4_TYPES = ("product", "store", "person", "scene", "other")
+    if vtype not in _KNOWN_V4_TYPES:
+        if has_person:
+            vtype = "person"
+        elif products:
+            vtype = "product"
+        else:
+            vtype = "other"
+
+    # 人物信息提取辅助（scene/store分支有人物时追加到key_features）
+    def _extract_person_features(source: dict) -> list[str]:
+        parts = []
+        for pk in ("outfit_style", "upper_wear", "lower_wear", "dress_wear", "outerwear", "pose", "expression"):
+            pv = source.get(pk)
+            if pv and str(pv) not in ("null", None, "无法判断") and len(str(pv)) <= 40:
+                parts.append(f"人物:{pv}")
+        for pk2 in ("shoes", "bag", "hairstyle"):
+            pv2 = source.get(pk2)
+            if pv2 and str(pv2) not in ("null", None) and len(str(pv2)) <= 40:
+                parts.append(f"人物:{pv2}")
+        return parts
+
+    # partial截断保护：声明了product但products数组没来得及输出时，
+    # 按已返回的碎片字段改路由，避免直接掉到other丢信息
+    if fj.get("_partial") and vtype == "product" and not products:
+        if any(fj.get(k) for k in ("signage_details", "store_layout", "brand_signage", "store_type")):
+            vtype = "store"
+        elif any(fj.get(k) for k in ("key_elements", "main_subject", "scene_type", "spatial_layout")):
+            vtype = "scene"
+        else:
+            vtype = "other"
+
+    # ── 人物类 ──
+    if vtype == "person":
+        # 取第一个人物信息（v5 schema人物信息在顶层）
+        person_info = fj
+        # 兼容people嵌套
+        ppl = fj.get("people")
+        if isinstance(ppl, dict) and ppl.get("has_person"):
+            person_info = {**fj, **ppl}
+            has_person = True
+
+        portrait_prompt = _build_portrait_prompt_from_v4(person_info)
+        outfit_style = person_info.get("outfit_style") or ""
+        upper = person_info.get("upper_wear") or ""
+        lower = person_info.get("lower_wear") or ""
+        dress = person_info.get("dress_wear") or ""
+        outer = person_info.get("outerwear") or ""
+        if dress:
+            name = str(dress)[:25]
+        elif outer and upper:
+            name = f"{outer}+{upper}"[:30]
+        elif upper:
+            name = (str(upper) + (f"+{lower}" if lower else ""))[:30]
+        else:
+            name = "人物穿搭"
+        brand = "无法判断"
+        category = "人物穿搭"
+        # appearance: 外套+上衣+下装/裙+鞋+包+发型+妆容
+        app_parts = []
+        for k in ("outerwear", "upper_wear", "lower_wear", "dress_wear", "shoes", "bag", "hairstyle", "makeup"):
+            v = person_info.get(k)
+            if v and v not in ("null", None, "无明显妆容"):
+                app_parts.append(str(v))
+        appearance = "；".join(app_parts) if app_parts else "人像穿搭整体造型"
+        # key_features: 服装+配饰+拍摄信息
+        kf = []
+        for k in (
+            "outfit_style",
+            "upper_wear",
+            "lower_wear",
+            "dress_wear",
+            "outerwear",
+            "shoes",
+            "bag",
+            "hairstyle",
+            "expression",
+            "pose",
+        ):
+            v = person_info.get(k)
+            if v and v not in ("null", None, "无法判断"):
+                kf.append(str(v))
+        acc = person_info.get("accessories") or []
+        if isinstance(acc, list):
+            for a in acc:
+                if a and str(a) not in kf:
+                    kf.append(str(a))
+        elif isinstance(acc, str) and acc:
+            kf.append(acc)
+        for k in ("shot_type", "camera_angle", "lighting", "atmosphere"):
+            v = person_info.get(k)
+            if v and v not in ("null", None):
+                kf.append(str(v))
+        env_obj = person_info.get("environment_objects") or []
+        if not isinstance(env_obj, list):
+            env_obj = [env_obj]
+        for o in env_obj:
+            if o and str(o) not in kf and len(str(o)) <= 40:
+                kf.append(str(o))
+        if text_on_package:
+            kf.append(f"文字:{'/'.join(text_on_package[:3])}")
+        kf = kf[:8] or ["无法判断"]
+        summary = (outfit_style + " " if outfit_style and outfit_style not in name else "") + name[:25]
+        if not summary.strip():
+            summary = "人物穿搭"
+        return {
+            "name": name[:30],
+            "brand": brand,
+            "category": category,
+            "appearance": appearance[:400],
+            "packaging": "人物形象无包装",
+            "text_on_package": text_on_package,
+            "key_features": kf,
+            "scene": scene,
+            "mood": mood,
+            "portrait_prompt": portrait_prompt[:300],
+            "summary": summary[:50],
+            "_source": "v2_fast_json_v5",
+            "has_person": True,
+        }
+
+    # 商品类
+    if vtype == "product" and products:
+        # 主商品（第一个position=main或第一个）
+        main = products[0]
+        for p in products:
+            if p.get("position") == "main":
+                main = p
+                break
+        name = main.get("product_name") or "未识别"
+        brand = main.get("brand") or "无法判断"
+        category = main.get("category") or "非产品图"
+        # appearance: 包装外观
+        app_parts = []
+        for k in ("package_color", "package_type", "cap_type", "body_shape", "label_design"):
+            v = main.get(k)
+            if v and v not in ("null", None):
+                app_parts.append(str(v))
+        appearance = "；".join(app_parts) if app_parts else "无法判断"
+        # packaging: 包装信息（直接用package_type+package_color）
+        pkg_parts = []
+        if main.get("package_type"):
+            pkg_parts.append(str(main["package_type"]))
+        if main.get("package_color"):
+            pkg_parts.append(str(main["package_color"]))
+        if main.get("cap_type"):
+            pkg_parts.append(f"配{main['cap_type']}")
+        packaging = "，".join(pkg_parts) if pkg_parts else "无法判断"
+        # key_features: product_features字段
+        feats = main.get("product_features") or []
+        if not isinstance(feats, list):
+            feats = [str(feats)]
+        kf = [str(f) for f in feats if f and len(str(f)) <= 40][:6]
+        # 补充卖点
+        sell = main.get("key_selling_points") or []
+        if isinstance(sell, list):
+            for s in sell[:2]:
+                if s and len(str(s)) <= 30 and str(s) not in kf:
+                    kf.append(f"卖点:{s}")
+        env_obj = fj.get("environment_objects") or []
+        if not isinstance(env_obj, list):
+            env_obj = [env_obj]
+        for o in env_obj:
+            if o and str(o) not in kf and len(str(o)) <= 40:
+                kf.append(str(o))
+        if text_on_package:
+            kf.append(f"文字: {'/'.join(text_on_package[:3])}")
+        kf = kf[:8] or ["无法判断"]
+        portrait_prompt = _build_product_prompt_from_v4(main, fj)
+        if brand != "无法判断" and brand not in name:
+            summary = f"{brand} {name}"
+        else:
+            summary = name
+        return {
+            "name": str(name)[:50],
+            "brand": str(brand)[:30],
+            "category": str(category)[:20],
+            "appearance": appearance[:200],
+            "packaging": packaging[:100],
+            "text_on_package": text_on_package,
+            "key_features": kf,
+            "scene": scene,
+            "mood": mood,
+            "portrait_prompt": portrait_prompt[:200],
+            "summary": str(summary)[:60],
+            "has_person": False,
+            "_source": "v2_fast_json_v4",
+        }
+
+    # 门店类
+    if vtype == "store":
+        store_type = fj.get("store_type") or "店铺"
+        # brand 多级兜底：brand_signage → visible_text招牌文字 → text_on_package短词
+        brand_raw = fj.get("brand_signage")
+        if not brand_raw or brand_raw in ("无法判断", "", None):
+            brand = None
+            # 从visible_text找招牌文字（通常是位置含招牌/门头/背景的短词）
+            for vt in visible_text:
+                vt_str = vt.get("text") if isinstance(vt, dict) else str(vt)
+                if not vt_str or len(vt_str) < 2 or len(vt_str) > 12:
+                    continue
+                loc = (vt.get("location") or "") if isinstance(vt, dict) else ""
+                if any(k in loc for k in ("招牌", "门头", "背景", "招牌墙")):
+                    brand = vt_str
+                    break
+            # 从text_on_package找2-8字的短词（非描述性）
+            if not brand:
+                _desc_words = {"干净", "整洁", "温馨", "专业", "明亮", "舒适", "宽敞", "现代", "传统", "时尚"}
+                for t in text_on_package:
+                    if 2 <= len(t) <= 8 and t not in _desc_words and not any(c in t for c in "的了是在我"):
+                        brand = t
+                        break
+            if not brand:
+                brand = "无法判断"
+        else:
+            brand = brand_raw
+        # name兜底：store_type为空时用brand
+        name = store_type if store_type != "店铺" else (brand if brand != "无法判断" else store_type)
+        category = "门店场景"
+        # appearance: store_layout + furnishings + 陈设色调
+        appearance_parts = []
+        if fj.get("store_layout"):
+            appearance_parts.append(str(fj["store_layout"]))
+        furnishings = fj.get("furnishings") or []
+        if isinstance(furnishings, dict):
+            _furn_vals = []
+            for fk in ("materials", "furniture", "shelving", "seating"):
+                fv = furnishings.get(fk)
+                if isinstance(fv, list):
+                    _furn_vals.extend(str(x) for x in fv if x)
+                elif isinstance(fv, str) and fv:
+                    _furn_vals.append(fv)
+            if _furn_vals:
+                appearance_parts.append("陈设：" + "、".join(_furn_vals[:4]))
+        elif isinstance(furnishings, list) and furnishings:
+            appearance_parts.append("陈设：" + "、".join(str(f) for f in furnishings[:4] if f))
+        if fj.get("cleanliness"):
+            appearance_parts.append(str(fj["cleanliness"]))
+        appearance = "；".join(appearance_parts) if appearance_parts else "门店环境"
+        # key_features: 招牌细节+海报+外部物品+视觉元素+陈列商品+环境物件
+        kf = []
+        for arr_key in (
+            "signage_details",
+            "signage_posters",
+            "exterior_items",
+            "visual_elements",
+            "products_on_display",
+            "environment_objects",
+        ):
+            arr = fj.get(arr_key) or []
+            if not isinstance(arr, list):
+                arr = [arr]
+            for item in arr:
+                if item and str(item) not in kf and len(str(item)) <= 40:
+                    kf.append(str(item))
+        prods_vis = fj.get("product_categories_visible") or []
+        if isinstance(prods_vis, list):
+            for c in prods_vis[:3]:
+                if c and str(c) not in kf:
+                    kf.append(str(c))
+        promo = fj.get("promotion_elements") or []
+        if isinstance(promo, list) and promo:
+            kf.append("促销活动:" + "、".join(str(p) for p in promo[:2]))
+        if has_person:
+            for pf in _extract_person_features(fj):
+                if pf not in kf:
+                    kf.append(pf)
+        if text_on_package:
+            kf.append("文字:" + "/".join(text_on_package[:3]))
+        kf = kf[:8] or ["门店场景"]
+        atmosphere = fj.get("atmosphere") or fj.get("mood") or mood
+        # portrait_prompt: 品牌+store_type+主色+atmosphere+scene+核心视觉元素
+        pieces = []
+        if brand != "无法判断":
+            pieces.append(brand)
+        pieces.append(store_type)
+        if color_names:
+            pieces.append("、".join(color_names[:3]) + "配色")
+        if atmosphere:
+            pieces.append(atmosphere)
+        if scene and scene != "通用":
+            pieces.append(scene)
+        visual = fj.get("visual_elements") or []
+        if isinstance(visual, list) and visual:
+            pieces.append("、".join(str(v) for v in visual[:3] if v))
+        pieces.append("门店实拍")
+        portrait_prompt = "，".join(p for p in pieces if p)
+        if len(portrait_prompt) > 200:
+            portrait_prompt = portrait_prompt[:200].rstrip("，")
+        summary = f"{brand} {store_type}" if brand != "无法判断" else f"{store_type}场景"
+        return {
+            "name": name[:30],
+            "brand": str(brand)[:30],
+            "category": category,
+            "appearance": appearance[:300],
+            "packaging": "门店场景无包装",
+            "text_on_package": text_on_package,
+            "key_features": kf,
+            "scene": scene,
+            "mood": atmosphere,
+            "portrait_prompt": portrait_prompt[:200],
+            "summary": summary[:40],
+            "has_person": bool(fj.get("has_person", False)),
+            "_source": "v2_fast_json_v6_store",
+        }
+
+    # 场景类（纯场景图，无产品/人物）
+    if vtype == "scene":
+        main_subject = fj.get("main_subject") or ""
+        scene_type = fj.get("scene_type") or "场景图"
+        name = main_subject or scene_type
+        brand = "无法判断"
+        category = scene_type or "场景图"
+        # appearance: 空间布局 + 关键元素
+        app_parts = []
+        if fj.get("spatial_layout"):
+            app_parts.append(str(fj["spatial_layout"]))
+        key_elements = fj.get("key_elements") or []
+        if not isinstance(key_elements, list):
+            key_elements = [key_elements]
+        if key_elements:
+            app_parts.append("关键元素：" + "、".join(str(k) for k in key_elements[:4] if k))
+        if fj.get("lighting"):
+            app_parts.append("光线：" + str(fj["lighting"]))
+        appearance = "；".join(app_parts) if app_parts else "场景环境"
+        # key_features: key_elements + environment_objects（去重，最多8）
+        kf = []
+        for k in key_elements:
+            if k and str(k) not in kf and len(str(k)) <= 40:
+                kf.append(str(k))
+        env_obj = fj.get("environment_objects") or []
+        if not isinstance(env_obj, list):
+            env_obj = [env_obj]
+        for o in env_obj:
+            if o and str(o) not in kf and len(str(o)) <= 40:
+                kf.append(str(o))
+        if has_person:
+            for pf in _extract_person_features(fj):
+                if pf not in kf:
+                    kf.append(pf)
+        if text_on_package:
+            kf.append("文字:" + "/".join(text_on_package[:3]))
+        kf = kf[:8] or ["场景元素"]
+        scene_name = fj.get("scene") or scene_type
+        scene_mood = fj.get("mood") or mood
+        packaging = "场景无包装"
+        # portrait_prompt: main_subject + key_elements + lighting + atmosphere + composition + style
+        pieces = []
+        if main_subject:
+            pieces.append(main_subject)
+        if key_elements:
+            pieces.append("、".join(str(k) for k in key_elements[:3] if k))
+        if fj.get("lighting"):
+            pieces.append(str(fj["lighting"]) + "光线")
+        if scene_mood:
+            pieces.append(scene_mood + "氛围")
+        if fj.get("composition"):
+            pieces.append(str(fj["composition"]))
+        if fj.get("style"):
+            pieces.append(str(fj["style"]))
+        pieces.append("场景实拍，摄影级画质")
+        portrait_prompt = "，".join(p for p in pieces if p)
+        if len(portrait_prompt) > 200:
+            portrait_prompt = portrait_prompt[:200].rstrip("，")
+        summary = main_subject or scene_type
+        return {
+            "name": str(name)[:30],
+            "brand": brand,
+            "category": str(category)[:20],
+            "appearance": appearance[:300],
+            "packaging": packaging,
+            "text_on_package": text_on_package,
+            "key_features": kf,
+            "scene": scene_name,
+            "mood": scene_mood,
+            "portrait_prompt": portrait_prompt[:200],
+            "summary": str(summary)[:40],
+            "has_person": bool(fj.get("has_person", False)),
+            "_source": "v2_fast_json_v6_scene",
+        }
+
+    # other 兜底：当 description 为空时，用 environment_objects/scene 拼基本描述
+    desc = fj.get("description") or ""
+    if not desc.strip():
+        env_obj = fj.get("environment_objects") or []
+        if not isinstance(env_obj, list):
+            env_obj = [env_obj]
+        env_names = [str(e) for e in env_obj if e and len(str(e)) <= 25][:5]
+        scene_text = fj.get("scene") or ""
+        if env_names:
+            desc = f"{scene_text}场景中" + "、".join(env_names) if scene_text else "、".join(env_names)
+        elif scene_text and scene_text != "通用":
+            desc = f"{scene_text}场景"
+        else:
+            desc = "未识别"
+    kf_other = []
+    if desc != "未识别":
+        kf_other.append(desc[:30])
+    env_obj = fj.get("environment_objects") or []
+    if not isinstance(env_obj, list):
+        env_obj = [env_obj]
+    for o in env_obj:
+        if o and str(o) not in kf_other and len(str(o)) <= 40:
+            kf_other.append(str(o))
+    kf_other = kf_other[:8] or ["无法判断"]
+    return {
+        "name": desc[:30],
+        "brand": "无法判断",
+        "category": "非产品图",
+        "appearance": desc[:200],
+        "packaging": "无法判断",
+        "text_on_package": text_on_package,
+        "key_features": kf_other,
+        "scene": scene,
+        "mood": mood,
+        "portrait_prompt": f"{scene}，{mood}氛围，{desc}"[:200],
+        "summary": desc[:40],
+        "has_person": False,
+        "_source": "v2_fast_json_v4_other",
+    }
+
+
+def _assemble_old(idx: int, fj: dict, ocr_texts: list[str]) -> dict[str, Any]:
+    """旧扁平schema（兼容存量prompt或pro兜底输出）"""
+    portrait_prompt = _build_portrait_prompt_old(fj)
+    name = _infer_name_old(fj, ocr_texts)
+    brand = _infer_brand_old(fj, ocr_texts)
+    category = _infer_category_old(fj)
+    appearance = _build_appearance_old(fj)
+    key_features = _build_key_features_old(fj, ocr_texts)
+    scene = fj.get("scene") or "通用"
+    mood = fj.get("mood") or ""
+    packaging = "无法判断"
+    text_on_package = ocr_texts[:8]
+    if fj.get("has_person"):
+        up = fj.get("upper_wear") or "穿搭"
+        style = fj.get("style") or ""
+        summary = f"{style}{up}" if style and style not in up else up
+    elif brand != "无法判断" and name != brand:
+        summary = f"{brand} {name}"
+    else:
+        summary = name
+    return {
+        "name": name,
+        "brand": brand,
+        "category": category,
+        "appearance": appearance,
+        "packaging": packaging,
+        "text_on_package": text_on_package,
+        "key_features": key_features,
+        "scene": scene,
+        "mood": mood,
+        "portrait_prompt": portrait_prompt,
+        "summary": summary,
+        "_source": "v2_fast_json",
+        "has_person": bool(fj.get("has_person", False)),
+    }

apps/worker/worker_app/tasks/vision/fast_path.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""V2 图片分析主路径：每图并行 OCR（火山MediaKit，未配置时自动跳过）+ qwen3.8-flash JSON VLM，
+失败时单次 qwen3.7-plus 兜底。
+
+架构（灵应10-05确认）：
+- 唯一后端：阿里云百炼 DashScope，qwen3.8-flash 做快速路径、qwen3.7-plus 做兜底
+- 主力：单图2路并行（OCR + fast VLM），外层N图全并发（workers=8）
+- 兜底：单次 pro VLM 调用，无竞速/重试/复杂超时
+- 输出 dict 格式与旧版完全一致，下游零改动
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+
+from . import assembler, ocr_volc, vlm_fallback, vlm_fast_json
+
+logger = logging.getLogger(__name__)
+
+# 超时（可通过环境变量覆盖）
+_IMG_WORKERS = int(os.environ.get("VISION_V2_IMG_WORKERS", "8"))
+_FAST_TIMEOUT = float(os.environ.get("VISION_V2_FAST_TIMEOUT", "20"))
+_FAST_JSON_TIMEOUT = float(os.environ.get("VISION_V2_FAST_JSON_TIMEOUT", "20"))
+_OCR_TIMEOUT = float(os.environ.get("VISION_V2_OCR_TIMEOUT", "6"))
+_PRO_TIMEOUT = float(os.environ.get("VISION_V2_PRO_TIMEOUT", "45"))
+
+_FALLBACK_RESULT = {
+    "name": "未识别",
+    "brand": "无法判断",
+    "category": "非产品图",
+    "appearance": "无法判断",
+    "packaging": "无法判断",
+    "text_on_package": [],
+    "key_features": ["无法判断"],
+    "scene": "通用",
+    "mood": "",
+    "portrait_prompt": "无法判断",
+    "summary": "未识别",
+}
+
+
+def _is_usable(r: dict[str, Any]) -> bool:
+    pp = (r.get("portrait_prompt") or "").strip()
+    if pp and pp not in ("无人像", "无法判断", "未识别"):
+        return True
+    name = (r.get("name") or "").strip()
+    if name and name not in ("未识别", "无法判断", "未知"):
+        return True
+    return False
+
+
+def analyze_image_v2(idx: int, img_url: str) -> dict[str, Any]:
+    t0 = time.time()
+
+    fj_result: dict[str, Any] | None = None
+    ocr_result: list[str] = []
+    fast_elapsed = 0.0
+    pool = ThreadPoolExecutor(max_workers=2)
+    f_fj = pool.submit(vlm_fast_json.call_fast_json, img_url, timeout=_FAST_JSON_TIMEOUT)
+    f_ocr = pool.submit(ocr_volc.call_ocr, img_url, timeout=_OCR_TIMEOUT)
+    try:
+        for fut in as_completed([f_fj, f_ocr], timeout=_FAST_TIMEOUT):
+            try:
+                res = fut.result(timeout=1)
+            except Exception as e:
+                logger.warning("[vision.v2] 图片 #%d 子任务异常: %s", idx, e)
+                continue
+            if fut is f_fj and isinstance(res, dict):
+                fj_result = res
+            elif fut is f_ocr and isinstance(res, list):
+                ocr_result = res
+    except TimeoutError:
+        for f in (f_fj, f_ocr):
+            if not f.done():
+                f.cancel()
+        logger.warning("[vision.v2] 图片 #%d fast路径超时(%.0fs)，走pro兜底", idx, _FAST_TIMEOUT)
+    finally:
+        fast_elapsed = time.time() - t0
+        pool.shutdown(wait=False)  # 不等待未完成的线程，避免计时膨胀
+
+    if fj_result:
+        assembled = assembler.assemble_result(idx, fj_result, ocr_result)
+        if _is_usable(assembled):
+            assembled["_fast_elapsed"] = round(fast_elapsed, 2)
+            logger.info(
+                "[vision.v2] 图片 #%d fast命中 elapsed=%.2fs pp=%s",
+                idx,
+                fast_elapsed,
+                (assembled.get("portrait_prompt") or "")[:40],
+            )
+            return assembled
+
+    pro_t0 = time.time()
+    pro_result = vlm_fallback.call_pro_vlm(img_url, idx, timeout=_PRO_TIMEOUT)
+    if pro_result and _is_usable(pro_result):
+        pro_result["_fallback_used"] = True
+        pro_result["_fast_elapsed"] = round(fast_elapsed, 2)
+        pro_result["_pro_elapsed"] = round(time.time() - pro_t0, 2)
+        if ocr_result and not pro_result.get("text_on_package"):
+            pro_result["text_on_package"] = ocr_result[:8]
+        logger.info("[vision.v2] 图片 #%d pro兜底命中 total=%.2fs", idx, time.time() - t0)
+        return pro_result
+
+    logger.warning("[vision.v2] 图片 #%d 全路径失败 elapsed=%.2fs", idx, time.time() - t0)
+    out = dict(_FALLBACK_RESULT)
+    out["_source"] = "v2_all_failed"
+    out["text_on_package"] = ocr_result[:8]
+    out["_fast_elapsed"] = round(fast_elapsed, 2)
+    return out
+
+
+def analyze_images_v2(img_urls: list[str]) -> list[dict[str, Any]]:
+    if not img_urls:
+        return []
+    workers = min(_IMG_WORKERS, len(img_urls), 16)
+    results: list[dict[str, Any] | None] = [None] * len(img_urls)
+
+    logger.info(
+        "[vision.v2] 开始图片分析 n=%d workers=%d fast_timeout=%.0fs pro_timeout=%.0fs",
+        len(img_urls),
+        workers,
+        _FAST_TIMEOUT,
+        _PRO_TIMEOUT,
+    )
+    t0 = time.time()
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        future_to_idx = {pool.submit(analyze_image_v2, idx, url): idx for idx, url in enumerate(img_urls)}
+        for fut in as_completed(future_to_idx):
+            idx = future_to_idx[fut]
+            try:
+                results[idx] = fut.result()
+            except Exception as e:
+                logger.warning("[vision.v2] 图片 #%d future异常: %s", idx, e, exc_info=True)
+                r = dict(_FALLBACK_RESULT)
+                r["_source"] = "v2_future_exception"
+                results[idx] = r
+
+    elapsed = time.time() - t0
+    succ = sum(1 for r in results if r and _is_usable(r))
+    fb = sum(1 for r in results if r and r.get("_fallback_used"))
+    logger.info("[vision.v2] 完成 n=%d usable=%d pro_fallback=%d elapsed=%.2fs", len(img_urls), succ, fb, elapsed)
+    return [r for r in results if r is not None]

apps/worker/worker_app/tasks/vision/json_utils.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+"""VLM 返回文本的稳健 JSON 提取工具。
+
+背景：复杂门店图 VLM 输出经常被 max_tokens 截断（finish_reason=length），
+json.loads 失败后整个结果被丢弃，导致"未识别"。本工具提供：
+1. markdown 代码块剥离（含只开不闭的截断场景）
+2. 最外层 { } 切片
+3. 非法控制字符清理
+4. 直接 json.loads
+5. 截断 JSON 括号/引号栈补全修复
+6. 尾部逐字符截断重试（去除最后一个不完整 token 后修复）
+
+成功返回 dict；截断修复产物带 _partial=True 标记；彻底失败返回 None。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+_CODE_FENCE_RE = re.compile(r"^```(?:json)?\s*\n?(.*?)\n?```\s*$", re.DOTALL)
+
+
+def _strip_code_fence(s: str) -> str:
+    s = s.strip()
+    m = _CODE_FENCE_RE.match(s)
+    if m:
+        return m.group(1).strip()
+    # 兼容开头 ```json 但结尾无 ```（截断场景）
+    if s.startswith("```"):
+        lines = s.split("\n")
+        if lines and lines[0].startswith("```"):
+            lines = lines[1:]
+        s = "\n".join(lines).strip()
+    return s
+
+
+def _repair_truncated_json(text: str) -> str:
+    """尝试补全被截断的JSON：维护 bracket/quote 栈，在末尾补闭合符。"""
+    stack: list[str] = []
+    in_string = False
+    escape = False
+    for ch in text:
+        if escape:
+            escape = False
+            continue
+        if ch == "\\" and in_string:
+            escape = True
+            continue
+        if ch == '"':
+            in_string = not in_string
+            continue
+        if in_string:
+            continue
+        if ch in "{[":
+            stack.append(ch)
+        elif ch == "}":
+            if stack and stack[-1] == "{":
+                stack.pop()
+        elif ch == "]":
+            if stack and stack[-1] == "[":
+                stack.pop()
+    repair = ""
+    if in_string:
+        repair += '"'
+    for opener in reversed(stack):
+        repair += "}" if opener == "{" else "]"
+    if repair:
+        logger.info(
+            "[json_utils] 截断JSON修复: 补全%d个闭合符 in_string=%s",
+            len(repair),
+            in_string,
+        )
+    return text + repair
+
+
+def _clean_invalid_chars(text: str) -> str:
+    """清理JSON中非法的控制字符（tab/newline 之外的 0x00-0x1f 段）。"""
+    return re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", "", text)
+
+
+def extract_json_object(text: str) -> dict | None:
+    """从VLM返回文本中稳健提取JSON对象。
+
+    返回 dict 或 None。成功的 dict 可能带 _partial=True 标记，
+    表示原始文本被截断、经括号补全后得到的产物。
+    """
+    if not text or not isinstance(text, str):
+        return None
+    # 1. 剥离 markdown
+    text = _strip_code_fence(text)
+    # 2. 找最外层 { }
+    lpos = text.find("{")
+    if lpos < 0:
+        return None
+    rpos = text.rfind("}")
+    if rpos > lpos:
+        text = text[lpos : rpos + 1]
+    else:
+        # 截断场景：无任何闭合 }，取到末尾交给修复器
+        text = text[lpos:]
+    # 3. 清理非法控制字符
+    text = _clean_invalid_chars(text)
+    # 4. 直接 loads
+    try:
+        obj = json.loads(text)
+        return obj if isinstance(obj, dict) else None
+    except json.JSONDecodeError:
+        pass
+    # 5. 尝试截断修复
+    repaired = _repair_truncated_json(text)
+    try:
+        obj = json.loads(repaired)
+        if isinstance(obj, dict):
+            obj["_partial"] = True
+            return obj
+    except json.JSONDecodeError:
+        pass
+    # 6. 尾部逐字符截断重试（去除最后一个不完整 token）
+    for _ in range(50):
+        last_comma = repaired.rfind(",")
+        last_brace = max(repaired.rfind("}"), repaired.rfind("]"))
+        cut = max(last_comma, last_brace)
+        if cut < 10:
+            break
+        repaired = repaired[: cut + 1]
+        repaired = _repair_truncated_json(repaired)
+        try:
+            obj = json.loads(repaired)
+            if isinstance(obj, dict):
+                obj["_partial"] = True
+                return obj
+        except json.JSONDecodeError:
+            continue
+    return None

apps/worker/worker_app/tasks/vision/ocr_volc.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+"""火山引擎 AI MediaKit OCR（同步）调用封装。
+
+接口：POST {mediakit_base_url}/tools-sync/ocr
+鉴权：Bearer {mediakit_api_key}
+请求体：{"image_url": "<公网可访问URL>"}  （部分版本也支持 image_base64）
+响应：{"code":0,"data":{"texts":[{"text":"...","bbox":[x,y,w,h],...},...],...}}
+
+目标：识别商品包装/Logo/水印上的文字，作为 fast_json VLM 的补充。
+返回值：识别到的文本字符串列表（失败返回 []）。
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_TIMEOUT = 8  # OCR 秒级返回，8s 绰绰有余
+
+
+def call_ocr(img_url: str, *, timeout: int = DEFAULT_TIMEOUT) -> list[str]:
+    """调用 MediaKit 同步 OCR，返回去重后的纯文本列表。
+
+    不做重试（外层降级逻辑负责）。失败/未配置返回空列表，不抛异常。
+    """
+    t0 = time.time()
+    try:
+        import httpx
+
+        from packages.shared.mediakit_client import get_mediakit_client
+
+        client = get_mediakit_client()
+        if not client.is_available:
+            logger.info("[vision.v2] mediakit 未配置，跳过 OCR")
+            return []
+
+        url = f"{client.base_url}/tools-sync/ocr"
+        headers = {
+            "Authorization": f"Bearer {client.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload: dict[str, Any] = {"image_url": img_url}
+        # 部分文档版本用 image_base64，但公网 URL 场景下 image_url 最简
+        resp = httpx.post(url, headers=headers, json=payload, timeout=timeout)
+        elapsed = time.time() - t0
+        if resp.status_code != 200:
+            logger.warning(
+                "[vision.v2] OCR HTTP %d elapsed=%.1fs body=%s",
+                resp.status_code,
+                elapsed,
+                resp.text[:200],
+            )
+            return []
+        data = resp.json()
+        # 兼容几种可能的响应结构
+        code = data.get("code", data.get("status", 0))
+        if code not in (0, "OK", "success", 200):
+            logger.warning("[vision.v2] OCR 业务错误 code=%s elapsed=%.1fs resp=%s", code, elapsed, str(data)[:200])
+            return []
+        texts = _extract_texts(data)
+        # 去重 + 过滤空
+        seen: set[str] = set()
+        out: list[str] = []
+        for t in texts:
+            t = (t or "").strip()
+            if t and t not in seen and len(t) <= 100:  # 过滤过长的误识别
+                seen.add(t)
+                out.append(t)
+        logger.info("[vision.v2] OCR 完成 elapsed=%.1fs n=%d texts=%s", elapsed, len(out), out[:5])
+        return out
+    except Exception as e:
+        elapsed = time.time() - t0
+        logger.warning("[vision.v2] OCR 异常 elapsed=%.1fs err=%s", elapsed, e, exc_info=True)
+        return []
+
+
+def _extract_texts(data: dict) -> list[str]:
+    """从 OCR 响应中抽取文本，兼容多种结构。"""
+    out: list[str] = []
+    # 常见结构1: data.texts = [{"text": "..."}, ...]
+    d = data.get("data") or data
+    if isinstance(d, dict):
+        for key in ("texts", "lines", "words", "items", "result"):
+            items = d.get(key)
+            if isinstance(items, list):
+                for it in items:
+                    if isinstance(it, dict):
+                        txt = it.get("text") or it.get("content") or it.get("word")
+                        if txt:
+                            out.append(str(txt))
+                    elif isinstance(it, str):
+                        out.append(it)
+                break
+        # 结构2: data.text = "..."
+        if not out:
+            t = d.get("text")
+            if isinstance(t, str):
+                out.append(t)
+        # 结构3: data.ocr_text / data.content
+        if not out:
+            for key in ("ocr_text", "content", "raw_text"):
+                v = d.get(key)
+                if isinstance(v, str) and v.strip():
+                    out.append(v)
+                    break
+    return out

apps/worker/worker_app/tasks/vision/vlm_fallback.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+"""V2 兜底路径：image_analysis（默认 qwen-vl-plus 视觉模型，fallback qwen3.7-plus / DashScope）单图调用。
+
+fast_json 超时/返回非 JSON/识别为空时，本路径单次调用兜底。
+设计要点：
+- 通过 ai_router.get_vision_client() 获取 DoubaoClient 实例，不再自己拼 httpx 请求
+- enable_thinking=False + response_format=json_object
+- system prompt 优先读后台 viral_video_prompt_templates 配置，DB不可用时fallback到硬编码JSON schema
+- max_tokens 不传，使用 client 中 capability 的 DB 配置（避免硬编码截断 JSON）
+- timeout=30s
+- 返回 dict 统一走 assembler.assemble_result 组装，与 fast 路径输出格式完全一致
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from . import _prompt, assembler
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_TIMEOUT = 45
+
+
+def call_pro_vlm(
+    img_url: str,
+    idx: int,
+    *,
+    timeout: int = _DEFAULT_TIMEOUT,
+    max_tokens: int | None = None,
+) -> dict[str, Any] | None:
+    """max_tokens 默认 None：不显式传参，使用 client 内 capability 的 DB 配置。"""
+    t0 = time.time()
+
+    try:
+        from packages.shared.ai_router import ai_router
+
+        client = ai_router.get_vision_client("image_analysis", variant="fallback")
+        if not client or not client.is_available:
+            logger.warning("[vision.v2] pro vision client 不可用，跳过")
+            return None
+    except Exception as e:
+        logger.warning("[vision.v2] ai_router 获取失败: %s", e)
+        return None
+
+    system_prompt, user_prompt = _prompt.resolve_pro_prompt()
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": img_url}},
+                {"type": "text", "text": user_prompt},
+            ],
+        },
+    ]
+
+    try:
+        call_kwargs: dict[str, Any] = {
+            "messages": messages,
+            "images": None,  # 图片已在 messages 中
+            "temperature": 0.3,
+            "timeout": timeout,
+            "enable_thinking": False,
+            "response_format": {"type": "json_object"},
+        }
+        # pro fallback：显式4000 tokens给复杂门店图留足空间
+        call_kwargs["max_tokens"] = max_tokens if max_tokens is not None else 4000
+
+        from .json_utils import extract_json_object
+
+        raw = None
+        obj = None
+        for _outer in range(2):
+            kw = dict(call_kwargs)
+            if _outer == 1:
+                kw.pop("response_format", None)
+                msgs2 = [dict(messages[0]), dict(messages[1])]
+                cont = [dict(c) for c in list(msgs2[1]["content"])]
+                cont[-1] = {"type": "text", "text": user_prompt + "\n严格只输出JSON对象，不要解释或markdown。"}
+                msgs2[1] = {"role": "user", "content": cont}
+                kw["messages"] = msgs2
+            raw = client.vision_completion(**kw)
+            if not raw:
+                logger.warning("[vision.v2] pro 返回空 outer=%s", _outer)
+                continue
+            obj = extract_json_object(raw)
+            if obj is not None:
+                break
+            logger.warning("[vision.v2] pro 非JSON(100字) outer=%s: %s", _outer, raw[:100])
+
+        elapsed = time.time() - t0
+        if obj is None:
+            logger.warning("[vision.v2] pro 两次均未得到JSON elapsed=%.1fs", elapsed)
+            return None
+        if obj.get("_partial"):
+            logger.warning("[vision.v2] pro 返回截断JSON(partial) elapsed=%.1fs", elapsed)
+        logger.info(
+            "[vision.v2] pro 完成 model=%s elapsed=%.1fs type=%s",
+            client.model,
+            elapsed,
+            obj.get("type"),
+        )
+
+        # 通过assembler统一组装，兼容v4嵌套schema和旧扁平schema
+        result = assembler.assemble_result(idx, obj, [])
+        result["_source"] = "vlm_pro"
+        result["_fallback_used"] = True
+        return result
+    except Exception as e:
+        elapsed = time.time() - t0
+        logger.warning("[vision.v2] pro 异常 elapsed=%.1fs err=%s", elapsed, e, exc_info=True)
+        return None

apps/worker/worker_app/tasks/vision/vlm_fast_json.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""V2 快速路径：image_analysis capability（默认 qwen-vl-plus 视觉模型 / DashScope）强约束 JSON-only 调用。
+
+目标：替代"人体属性/商品检测/图像标签"三个火山不存在的专用云端 API。
+设计要点：
+- 通过 ai_router.get_vision_client() 获取 DoubaoClient 实例，不再自己拼 httpx 请求
+- enable_thinking=False 关闭推理链（reasoning 是延迟主因）
+- response_format=json_object 强约束JSON输出
+- system prompt 优先读后台 viral_video_prompt_templates 配置，DB不可用时fallback到硬编码JSON schema
+- max_tokens 不传，使用 client 中 capability 的 DB 配置（避免硬编码截断 JSON）
+- temperature=0.1（稳定输出 JSON）
+- timeout=15s（失败由外层走 pro 兜底）
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from . import _prompt
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_TIMEOUT = 20
+
+
+def call_fast_json(
+    img_url: str,
+    *,
+    timeout: int = _DEFAULT_TIMEOUT,
+    max_tokens: int | None = None,
+) -> dict[str, Any] | None:
+    """调用 vision client 返回结构化 dict；失败/非 JSON 返回 None。
+
+    max_tokens 默认 None：不显式传参，使用 client 内 capability 的 DB 配置；
+    显式传入时作为覆盖。
+    """
+    t0 = time.time()
+
+    try:
+        from packages.shared.ai_router import ai_router
+
+        client = ai_router.get_vision_client("image_analysis", variant="primary")
+        if not client or not client.is_available:
+            logger.warning("[vision.v2] vision client 不可用，跳过 fast_json")
+            return None
+    except Exception as e:
+        logger.warning("[vision.v2] ai_router 获取失败: %s", e)
+        return None
+
+    system_prompt, user_prompt = _prompt.resolve_fast_prompt()
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": img_url}},
+                {"type": "text", "text": user_prompt},
+            ],
+        },
+    ]
+
+    try:
+        call_kwargs: dict[str, Any] = {
+            "messages": messages,
+            "images": None,  # 图片已在 messages 中
+            "temperature": 0.1,
+            "timeout": timeout,
+            "enable_thinking": False,
+            "response_format": {"type": "json_object"},
+        }
+        if max_tokens is not None:
+            call_kwargs["max_tokens"] = max_tokens
+
+        # 双重防护：第1次正常调用；第2次去掉json_object强约束（部分模型在该约束下
+        # 反而幻觉），并加严格指令。解析全部走 json_utils，截断partial产物可用。
+        from .json_utils import extract_json_object
+
+        raw = None
+        obj = None
+        for _outer in range(2):
+            kw = dict(call_kwargs)
+            if _outer == 1:
+                kw.pop("response_format", None)
+                msgs2 = [dict(messages[0]), dict(messages[1])]
+                cont = list(msgs2[1]["content"])
+                cont = [dict(c) for c in cont]
+                cont[-1] = {"type": "text", "text": user_prompt + "\n严格只输出JSON对象，不要解释或markdown。"}
+                msgs2[1] = {"role": "user", "content": cont}
+                kw["messages"] = msgs2
+            raw = client.vision_completion(**kw)
+            if not raw:
+                logger.warning("[vision.v2] fast_json 返回空 outer=%s", _outer)
+                continue
+            obj = extract_json_object(raw)
+            if obj is not None:
+                break
+            logger.warning(
+                "[vision.v2] fast_json 非JSON(100字) outer=%s: %s",
+                _outer,
+                raw[:100],
+            )
+
+        elapsed = time.time() - t0
+        if obj is None:
+            logger.warning("[vision.v2] fast_json 两次均未得到JSON elapsed=%.1fs", elapsed)
+            return None
+        if obj.get("_partial"):
+            logger.warning("[vision.v2] fast_json 返回截断JSON(partial) elapsed=%.1fs", elapsed)
+        logger.info(
+            "[vision.v2] fast_json 完成 model=%s elapsed=%.1fs has_person=%s type=%s",
+            client.model,
+            elapsed,
+            obj.get("has_person"),
+            obj.get("type"),
+        )
+        return obj
+    except Exception as e:
+        elapsed = time.time() - t0
+        logger.warning("[vision.v2] fast_json 异常 elapsed=%.1fs err=%s", elapsed, e, exc_info=True)
+        return None

deploy/configs/.env.staging

@@ -241,19 +241,35 @@ DOUBAO_API_KEY=${DOUBAO_API_KEY}
 
 # 模型 Endpoint ID（在 ARK 控制台创建推理接入点后获得）
 DOUBAO_MODEL=${DOUBAO_MODEL}
+DOUBAO_FAST_MODEL=${DOUBAO_FAST_MODEL}
 
 # API Base URL
 DOUBAO_BASE_URL=${DOUBAO_BASE_URL}
 
 # 请求超时（秒）
-DOUBAO_TIMEOUT=60
+DOUBAO_TIMEOUT=${DOUBAO_TIMEOUT}
 
 # 最大重试次数
-DOUBAO_MAX_RETRIES=2
+DOUBAO_MAX_RETRIES=${DOUBAO_MAX_RETRIES}
 
-# 视觉模型 Endpoint ID（支持图片/视频理解的模型）
+# 视觉模型（支持图片/视频理解的模型，model name 格式）
 DOUBAO_VISION_MODEL=${DOUBAO_VISION_MODEL}
 
+# 快速视觉模型（viral-video 图片分析 lite 路径）
+DOUBAO_VISION_LITE_MODEL=${DOUBAO_VISION_LITE_MODEL}
+
+# 是否启用 lite 视觉路径（true/false）
+DOUBAO_VISION_USE_LITE=${DOUBAO_VISION_USE_LITE}
+
+# 信任链文生图模型（Seedream）
+DOUBAO_IMAGE_MODEL=${DOUBAO_IMAGE_MODEL}
+
+# 文生图尺寸
+DOUBAO_IMAGE_SIZE=${DOUBAO_IMAGE_SIZE}
+
+# 文生图超时（秒）
+DOUBAO_IMAGE_TIMEOUT=${DOUBAO_IMAGE_TIMEOUT}
+
 
 # ==================== 微信开放平台 OAuth（网页扫码登录）====================
 # 回调域名：xiaoxiajianji.com（微信开放平台已配置）

docs/DEPLOYMENT.md

@@ -104,6 +104,43 @@ Staging 当前可以保持 no-op；Production 开启前必须先验证 SMTP/Redi
 
 ---
 
+## Staging 服务器 Docker 凭证配置
+
+Staging 服务器（116.62.226.203）需要配置 ACR 和 Gitea Registry 凭证，否则 docker pull 和 Watchtower 自动更新会失败。
+
+### 凭证文件位置
+- Docker 配置文件：`/root/.docker/config.json`
+- 包含两个 registry 的认证信息：
+  - `xiaoxia-registry.cn-hangzhou.cr.aliyuncs.com`（阿里云 ACR）
+  - `git.xiaoxiajianji.com`（Gitea 容器镜像仓库）
+
+### 服务器迁移后恢复步骤
+```bash
+# 1. 登录 ACR
+docker login xiaoxia-registry.cn-hangzhou.cr.aliyuncs.com -u <ACR_USERNAME>
+
+# 2. 登录 Gitea Registry
+docker login git.xiaoxiajianji.com -u xiaoxia -p <GITEA_REGISTRY_TOKEN>
+
+# 3. 重启 Watchtower（确保挂载最新 config.json）
+docker restart watchtower
+```
+
+### Watchtower 配置
+- 容器名：`watchtower`
+- 检查间隔：300 秒（5 分钟）
+- 监控容器：`xiaoxia-api-staging`、`xiaoxia-worker-staging`、`xiaoxia-web-staging`
+- 必须挂载 `-v /root/.docker/config.json:/config.json` 才能拉取私有镜像
+- 必须挂载 `-v /var/run/docker.sock:/var/run/docker.sock` 才能管理容器
+- 容器使用 `:dev` 稳定 tag，Watchtower 通过检测 `:dev` tag 的 digest 变化来发现更新
+
+### 镜像 Tag 策略
+- CI 每次构建推送三种 tag：`${GITHUB_SHA}`（精确版本）、`${GITHUB_REF_NAME}`（分支名）、`:dev`（滚动 tag，仅 develop 分支）
+- Staging 容器统一使用 `:dev` tag 启动，确保 Watchtower 能自动发现新版本
+- Migration（alembic）使用 commit SHA tag 执行，不依赖 Watchtower
+
+---
+
 ## Gitea Actions 约定
 
 - `develop` 分支触发 staging 部署。

infra/docker/api.Dockerfile

@@ -30,6 +30,10 @@ COPY deploy/configs/douyin_cookies.txt /app/configs/douyin_cookies.txt
 # 强制升级 yt-dlp 到最新（抖音反爬经常变更，旧版 cookies 支持失效；#1968/#1963）
 RUN pip install --no-cache-dir -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com --upgrade "yt-dlp>=2026.8.19"
 
+# API 启动入口（幂等迁移 + uvicorn）—— #2129: watchtower 自动部署兜底
+COPY infra/docker/entrypoint-api.sh /usr/local/bin/entrypoint-api.sh
+RUN chmod +x /usr/local/bin/entrypoint-api.sh
+
 # 设置环境变量
 ENV PATH="/opt/venv/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
 ENV PYTHONPATH=/app:/app/apps/api
@@ -41,4 +45,4 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
     CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health', timeout=5)"
 
 # API 入口点
-CMD ["uvicorn", "apps.api.main:app", "--host", "0.0.0.0", "--port", "8000"]
+ENTRYPOINT ["/usr/local/bin/entrypoint-api.sh"]

infra/docker/entrypoint-api.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+# API 启动入口：先幂等执行数据库迁移，再启动传入的 CMD（默认 uvicorn）
+# 解决 watchtower 自动拉取新镜像后容器重启、未跑 alembic upgrade head 导致新列缺失 500 的问题（#2129）
+set -e
+
+cd /app
+
+echo "[entrypoint-api] Running alembic upgrade head..."
+if alembic upgrade head; then
+  echo "[entrypoint-api] Migrations ok."
+else
+  echo "[entrypoint-api] WARNING: alembic upgrade failed, continuing (existing columns should be fine)..." >&2
+fi
+
+# 若有显式 CMD（CI 部署时 docker compose run --rm api sh -c '...' 传入），直接 exec 它
+if [ "$#" -gt 0 ]; then
+  echo "[entrypoint-api] Exec custom command: $*"
+  exec "$@"
+fi
+
+echo "[entrypoint-api] Starting uvicorn..."
+exec uvicorn apps.api.main:app --host 0.0.0.0 --port 8000

infra/docker/entrypoint-worker.sh

@@ -18,6 +18,17 @@
 
 set -e
 
+# #2129: 幂等执行数据库迁移（watchtower 自动部署兜底）
+# worker 容器独立启动，不能依赖 API 容器先跑迁移
+cd /app
+echo "[entrypoint-worker] Running alembic upgrade head..."
+if alembic upgrade head; then
+  echo "[entrypoint-worker] Migrations ok."
+else
+  echo "[entrypoint-worker] WARNING: alembic upgrade failed, continuing to start workers..." >&2
+fi
+cd - >/dev/null
+
 MAX_TASKS="${WORKER_MAX_TASKS_PER_CHILD:-100}"
 
 # ── 并发计算：显式 env 优先；否则从 WORKER_CONCURRENCY 按比例推导 ──

infra/docker/worker.Dockerfile

@@ -34,6 +34,7 @@ ENV APP_VERSION=$APP_VERSION
 
 # 复制文件（按变化频率从低到高排序，最大化层缓存命中）
 COPY alembic.ini /app/alembic.ini
+COPY alembic/ /app/alembic/
 COPY migrations/ /app/migrations/
 COPY packages/ /app/packages/
 # PR #1844 起，worker 还需要加载 apps.api.app.tasks.lipsync_tts，

packages/adapters/sqlalchemy_impl/models.py

@@ -56,7 +56,7 @@ class UserModel(Base):
     is_member = Column(Boolean, nullable=False, default=False)
     member_type = Column(String(20), nullable=True)
     member_expires_at = Column(DateTime, nullable=True)
-    points_balance = Column(Integer, nullable=False, default=0)
+    points_balance = Column(Float, nullable=False, default=0)
     created_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))
 
 
@@ -335,6 +335,10 @@ class GenerationTaskModel(Base):
     bgm_config = Column(JSON, nullable=False, default=dict)
     extra_meta = Column("metadata", JSON, nullable=False, default=dict)
     logs = Column(Text, nullable=False, default="[]", server_default="[]")
+    # 功能计费（smart_edit）：预扣积分 / 最终积分 / 预扣流水 ID
+    credits_prepaid = Column(Float, nullable=False, default=0.0, server_default="0")
+    credits_cost = Column(Float, nullable=False, default=0.0, server_default="0")
+    credits_transaction_id = Column(String(36), nullable=False, default="", server_default="")
     created_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))
     updated_at = Column(
         DateTime,
@@ -727,6 +731,11 @@ class LipsyncJobModel(Base):
     # 精确句子时间戳（TTS 合成后由 silencedetect 计算，用于 B-roll 精确定位）
     sentence_timings = Column(JSON, nullable=True)  # list[{index,text,start_time,end_time}]
 
+    # 功能计费（lip_sync）：预扣积分 / 最终积分 / 预扣流水 ID
+    credits_prepaid = Column(Float, nullable=False, default=0.0, server_default="0")
+    credits_cost = Column(Float, nullable=False, default=0.0, server_default="0")
+    credits_transaction_id = Column(String(36), nullable=False, default="", server_default="")
+
     # 时间戳
     submitted_at = Column(DateTime, nullable=True)
     completed_at = Column(DateTime, nullable=True)
@@ -775,9 +784,9 @@ class PointsAccountModel(Base):
 
     id = Column(String(36), primary_key=True)
     user_id = Column(String(36), nullable=False, unique=True, index=True)
-    balance = Column(Integer, nullable=False, default=0)
-    total_earned = Column(Integer, nullable=False, default=0)
-    total_spent = Column(Integer, nullable=False, default=0)
+    balance = Column(Float, nullable=False, default=0)
+    total_earned = Column(Float, nullable=False, default=0)
+    total_spent = Column(Float, nullable=False, default=0)
     created_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))
     updated_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))
 
@@ -792,8 +801,8 @@ class PointsTransactionModel(Base):
     account_id = Column(String(36), nullable=False, index=True)
     type = Column(String(20), nullable=False, index=True)  # earn / spend / refund
     source = Column(String(50), nullable=False, index=True)
-    amount = Column(Integer, nullable=False)
-    balance_after = Column(Integer, nullable=False)
+    amount = Column(Float, nullable=False)
+    balance_after = Column(Float, nullable=False)
     description = Column(String(255), nullable=False, default="")
     ref_id = Column(String(100), nullable=False, default="")
     created_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))
@@ -905,6 +914,11 @@ class GpuLipsyncTaskModel(Base):
     # 心跳：worker 最近一次 poll/result 的时间，用于判定 worker 失联
     last_heartbeat_at = Column(DateTime, nullable=True)
 
+    # 功能计费（lip_sync）：预扣积分 / 最终积分 / 预扣流水 ID
+    credits_prepaid = Column(Float, nullable=False, default=0.0, server_default="0")
+    credits_cost = Column(Float, nullable=False, default=0.0, server_default="0")
+    credits_transaction_id = Column(String(36), nullable=False, default="", server_default="")
+
 
 class GpuWorkerModel(Base):
     """GPU Worker 注册表 — 反向轮询模式下用于心跳与监控."""
@@ -928,6 +942,7 @@ class ViralVideoJobModel(Base):
     id = Column(String(36), primary_key=True)
     user_id = Column(String(36), nullable=False, index=True)
     images = Column(JSON, nullable=False, default=list)  # 产品图片 URL 列表
+    pre_trusted_images = Column(JSON, nullable=True)  # #2172 信任链预热结果（Seedream AI 化 URL 列表）
     industry = Column(String(100), nullable=False, default="")
     target_customer = Column(String(500), nullable=False, default="")
     persona_id = Column(String(36), nullable=False, default="")
@@ -943,14 +958,28 @@ class ViralVideoJobModel(Base):
     style_strength = Column(String(20), nullable=False, default="medium")
     style_guide = Column(JSON, nullable=True)
     style_template_id = Column(String(36), nullable=False, default="", index=True)
+    # v1.5 音频/视频参数
+    voice_id = Column(String(200), nullable=False, default="")
+    voice_source = Column(String(20), nullable=False, default="")
+    video_ratio = Column(String(10), nullable=False, default="9:16")
+    video_model = Column(String(100), nullable=False, default="")
     # 结果与状态
     status = Column(String(30), nullable=False, default="pending", index=True)
+    current_stage = Column(String(200), nullable=False, default="")  # 细粒度阶段 snake_case
+    phase_message = Column(String(500), nullable=False, default="")  # 阶段中文提示文案
+    heartbeat_at = Column(DateTime, nullable=True, index=True)  # worker 心跳，用于僵尸任务超时回收
     intent_result = Column(JSON, nullable=True)
     image_analysis = Column(JSON, nullable=True)
     storyboard = Column(JSON, nullable=True)
     generated_copy_text = Column(Text, nullable=False, default="")
+    copy_result = Column(
+        JSON, nullable=True
+    )  # v1.6: 编导脚本结构{overview,scene_and_lighting,shots,hard_constraints,negative_prompts,voiceover_script}
     result_video_url = Column(String(1000), nullable=False, default="")
-    credits_cost = Column(Integer, nullable=False, default=0)
+    credits_cost = Column(Float, nullable=False, default=0)
+    video_resolution = Column(String(20), nullable=False, default="720p")
+    credits_prepaid = Column(Float, nullable=False, default=0.0)
+    credits_transaction_id = Column(String(36), nullable=False, default="")
     error_msg = Column(Text, nullable=False, default="")
     retry_count = Column(Integer, nullable=False, default=0)
     started_at = Column(DateTime(timezone=True), nullable=True)
@@ -976,16 +1005,17 @@ class ViralVideoStyleTemplateModel(Base):
 
 
 class ViralVideoPromptTemplateModel(Base):
-    """爆款视频 Prompt 模板表（由 #2040 seed）"""
+    """爆款视频 Prompt 模板表（#2040：纯文本 XML 标签模板，运营可直接编辑）"""
 
     __tablename__ = "viral_video_prompt_templates"
 
-    id = Column(String(36), primary_key=True)
-    prompt_type = Column(String(50), nullable=False, index=True)
-    name = Column(String(200), nullable=False)
-    content = Column(Text, nullable=False, default="")
-    variables = Column(JSON, nullable=False, default=list)
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(128), nullable=False)
+    prompt_type = Column(String(32), nullable=False)
     version = Column(Integer, nullable=False, default=1)
-    is_active = Column(Boolean, nullable=False, default=True, index=True)
+    system_prompt = Column(Text, nullable=False)
+    user_prompt_template = Column(Text, nullable=False)
+    example_output = Column(Text, nullable=True)
+    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))

packages/adapters/sqlalchemy_impl/session.py

@@ -84,6 +84,11 @@ def ensure_database_exists(database_url: str) -> None:
 _VIRAL_VIDEO_BACKFILL_COLS = [
     ("storyboard", "JSON"),
     ("generated_copy_text", "TEXT NOT NULL DEFAULT ''"),
+    ("voice_id", "VARCHAR(200) NOT NULL DEFAULT ''"),
+    ("voice_source", "VARCHAR(20) NOT NULL DEFAULT ''"),
+    ("video_ratio", "VARCHAR(10) NOT NULL DEFAULT '9:16'"),
+    ("video_model", "VARCHAR(100) NOT NULL DEFAULT ''"),
+    ("copy_result", "JSON"),
 ]
 
 

packages/adapters/sqlalchemy_impl/user_repository.py

@@ -39,6 +39,9 @@ class SQLAlchemyUserRepository(UserRepository):
         model.phone_verified = user.phone_verified
         model.binding_completed_at = user.binding_completed_at
         model.profile_completed = user.profile_completed
+        model.is_member = user.is_member
+        model.member_type = user.member_type
+        model.member_expires_at = user.member_expires_at
         model.created_at = user.created_at
 
         self.session.commit()
@@ -115,5 +118,8 @@ class SQLAlchemyUserRepository(UserRepository):
             phone_verified=model.phone_verified or False,
             binding_completed_at=model.binding_completed_at,
             profile_completed=model.profile_completed if model.profile_completed is not None else True,
+            is_member=model.is_member if model.is_member is not None else False,
+            member_type=model.member_type,
+            member_expires_at=model.member_expires_at,
             created_at=model.created_at,
         )

packages/adapters/sqlalchemy_impl/viral_video_repository.py

@@ -6,25 +6,40 @@ from sqlalchemy.orm import Session
 
 from packages.adapters.sqlalchemy_impl.models import (
     ViralVideoJobModel,
-    ViralVideoPromptTemplateModel,
     ViralVideoStyleTemplateModel,
 )
 from packages.domain.viral_video import ViralVideoJob, ViralVideoStatus
 
 
 def _to_domain(model: ViralVideoJobModel) -> ViralVideoJob:
-    """ORM → 领域实体。"""
+    """ORM → 领域实体。pre_trusted_images 兼容脏数据：双序列化字符串/字符数组/list[str]。"""
+    import json as _pti_json
+
+    _raw_pti = getattr(model, "pre_trusted_images", None)
+    _pti: list[str] | None = None
+    if _raw_pti is not None:
+        if isinstance(_raw_pti, str):
+            try:
+                _p = _pti_json.loads(_raw_pti)
+                if isinstance(_p, list):
+                    _pti = [u for u in _p if isinstance(u, str) and u] or None
+            except Exception:
+                _pti = None
+        elif isinstance(_raw_pti, list):
+            _f = [u for u in _raw_pti if isinstance(u, str) and len(u) > 5]
+            _pti = _f if _f else None
     return ViralVideoJob(
         id=model.id,
         user_id=model.user_id,
         images=list(model.images or []),
+        pre_trusted_images=_pti,
         industry=model.industry or "",
         target_customer=model.target_customer or "",
         persona_id=model.persona_id or "",
         viral_structure=model.viral_structure or "",
         marketing_purpose=model.marketing_purpose or "",
         bgm_preference=model.bgm_preference or "",
-        duration=model.duration or 30,
+        duration=model.duration or 15,
         user_copy_text=model.user_copy_text or "",
         fusion_level=model.fusion_level or "ai_polish",
         reference_audio_path=model.reference_audio_path or "",
@@ -32,13 +47,24 @@ def _to_domain(model: ViralVideoJobModel) -> ViralVideoJob:
         style_strength=getattr(model, "style_strength", "medium") or "medium",
         style_guide=dict(model.style_guide) if model.style_guide else None,
         style_template_id=getattr(model, "style_template_id", "") or "",
+        voice_id=getattr(model, "voice_id", "") or "",
+        voice_source=getattr(model, "voice_source", "") or "",
+        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,
+        current_stage=getattr(model, "current_stage", "") or "",
+        phase_message=getattr(model, "phase_message", "") or "",
+        heartbeat_at=getattr(model, "heartbeat_at", None),
         intent_result=dict(model.intent_result) if model.intent_result else None,
         image_analysis=dict(model.image_analysis) if getattr(model, "image_analysis", None) else None,
         storyboard=list(model.storyboard) if getattr(model, "storyboard", None) else None,
         generated_copy_text=getattr(model, "generated_copy_text", "") or "",
+        copy_result=dict(model.copy_result) if getattr(model, "copy_result", None) else None,
         result_video_url=model.result_video_url or "",
-        credits_cost=model.credits_cost or 0,
+        video_resolution=getattr(model, "video_resolution", "720p") or "720p",
+        credits_prepaid=float(getattr(model, "credits_prepaid", 0) or 0),
+        credits_transaction_id=getattr(model, "credits_transaction_id", "") or "",
+        credits_cost=float(model.credits_cost or 0),
         error_msg=model.error_msg or "",
         retry_count=model.retry_count or 0,
         started_at=model.started_at,
@@ -59,6 +85,7 @@ class SQLAlchemyViralVideoJobRepository:
             id=job.id,
             user_id=job.user_id,
             images=job.images,
+            pre_trusted_images=job.pre_trusted_images,
             industry=job.industry,
             target_customer=job.target_customer,
             persona_id=job.persona_id,
@@ -73,13 +100,24 @@ class SQLAlchemyViralVideoJobRepository:
             style_strength=job.style_strength,
             style_guide=job.style_guide,
             style_template_id=job.style_template_id,
+            voice_id=job.voice_id,
+            voice_source=job.voice_source,
+            video_ratio=job.video_ratio,
+            video_model=job.video_model,
             status=job.status,
+            current_stage=job.current_stage or "",
+            phase_message=job.phase_message or "",
+            heartbeat_at=job.heartbeat_at,
             intent_result=job.intent_result,
             image_analysis=job.image_analysis,
             storyboard=job.storyboard,
             generated_copy_text=job.generated_copy_text,
+            copy_result=job.copy_result,
             result_video_url=job.result_video_url,
-            credits_cost=job.credits_cost,
+            video_resolution=getattr(job, "video_resolution", "720p") or "720p",
+            credits_prepaid=float(getattr(job, "credits_prepaid", 0) or 0),
+            credits_transaction_id=getattr(job, "credits_transaction_id", "") or "",
+            credits_cost=float(getattr(job, "credits_cost", 0) or 0),
             error_msg=job.error_msg,
             retry_count=job.retry_count,
             started_at=job.started_at,
@@ -96,12 +134,20 @@ class SQLAlchemyViralVideoJobRepository:
         if model is None:
             raise ValueError(f"ViralVideoJob {job.id} not found")
         model.status = job.status
+        model.current_stage = job.current_stage or ""
+        model.phase_message = job.phase_message or ""
+        model.heartbeat_at = job.heartbeat_at
         model.intent_result = job.intent_result
         model.image_analysis = job.image_analysis
         model.storyboard = job.storyboard
         model.generated_copy_text = job.generated_copy_text or ""
+        model.copy_result = job.copy_result
+        model.pre_trusted_images = job.pre_trusted_images
         model.result_video_url = job.result_video_url
-        model.credits_cost = job.credits_cost
+        model.video_resolution = getattr(job, "video_resolution", "720p") or "720p"
+        model.credits_prepaid = float(getattr(job, "credits_prepaid", 0) or 0)
+        model.credits_transaction_id = getattr(job, "credits_transaction_id", "") or ""
+        model.credits_cost = float(getattr(job, "credits_cost", 0) or 0)
         model.error_msg = job.error_msg
         model.retry_count = job.retry_count
         model.started_at = job.started_at
@@ -121,6 +167,10 @@ class SQLAlchemyViralVideoJobRepository:
         model.reference_video_url = job.reference_video_url
         model.style_strength = job.style_strength
         model.style_template_id = job.style_template_id
+        model.voice_id = job.voice_id or ""
+        model.voice_source = job.voice_source or ""
+        model.video_ratio = job.video_ratio or "9:16"
+        model.video_model = job.video_model or ""
         model.updated_at = datetime.now(timezone.utc)
         self.session.commit()
 
@@ -194,31 +244,3 @@ class SQLAlchemyViralVideoStyleTemplateRepository:
             "style_config": dict(model.style_config) if model.style_config else {},
             "is_system": model.is_system,
         }
-
-
-class SQLAlchemyViralVideoPromptTemplateRepository:
-    """Prompt 模板仓储（由 #2040 seed，这里只读取）。"""
-
-    def __init__(self, session: Session):
-        self.session = session
-
-    def get_active_by_type(self, prompt_type: str) -> dict | None:
-        model = (
-            self.session.query(ViralVideoPromptTemplateModel)
-            .filter(
-                ViralVideoPromptTemplateModel.prompt_type == prompt_type,
-                ViralVideoPromptTemplateModel.is_active.is_(True),
-            )
-            .order_by(ViralVideoPromptTemplateModel.version.desc())
-            .first()
-        )
-        if model is None:
-            return None
-        return {
-            "id": model.id,
-            "prompt_type": model.prompt_type,
-            "name": model.name,
-            "content": model.content,
-            "variables": list(model.variables or []),
-            "version": model.version,
-        }

packages/application/catalog/__init__.py

@@ -0,0 +1 @@
+"""应用层：对外展示目录（套餐/积分包）。"""

packages/application/catalog/admin_catalog.py

@@ -0,0 +1,152 @@
+"""读取管理后台配置的会员套餐 / 积分充值包（共享库真实数据）。
+
+替代旧的硬编码 MEMBERSHIP_PRICES / POINTS_PACKAGES。
+短 TTL 缓存（30 秒），后台改价/启停后用户端最多 30 秒可见。
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Any
+
+_CACHE_TTL = 30.0
+_lock = threading.Lock()
+_cache: dict[str, tuple[float, Any]] = {}
+
+_QUOTA_LABELS = {
+    "4k": "4K 超清分辨率",
+    "batch_render": "批量渲染",
+    "priority_queue": "优先处理队列",
+    "ai_matting": "AI 智能抠像",
+    "remove_watermark": "去水印",
+}
+
+
+def _cached(key: str, loader):
+    now = time.time()
+    hit = _cache.get(key)
+    if hit and now - hit[0] < _CACHE_TTL:
+        return hit[1]
+    with _lock:
+        hit = _cache.get(key)
+        if hit and time.time() - hit[0] < _CACHE_TTL:
+            return hit[1]
+        value = loader()
+        _cache[key] = (time.time(), value)
+        return value
+
+
+def _quota_features(quotas: dict[str, Any] | None) -> dict[str, Any]:
+    quotas = quotas or {}
+    features: dict[str, Any] = {}
+    for k, v in quotas.items():
+        if k == "credits_per_month":
+            features["credits_per_month"] = v
+        elif k in _QUOTA_LABELS:
+            features[_QUOTA_LABELS[k]] = v
+        else:
+            features[k] = v
+    return features
+
+
+def get_membership_plans() -> list[dict[str, Any]]:
+    """读取 is_enabled=true 的套餐，按年/月周期展开为用户端档位。"""
+
+    def _load() -> list[dict[str, Any]]:
+        from sqlalchemy import text
+
+        from packages.adapters.sqlalchemy_impl.session import SessionLocal
+
+        if SessionLocal is None:
+            return []
+
+        session = SessionLocal()
+        try:
+            rows = session.execute(text("""
+                    SELECT plan_key, name, description, monthly_price, yearly_price,
+                           quotas, display_order
+                    FROM plans
+                    WHERE is_enabled = TRUE
+                    ORDER BY display_order NULLS LAST, created_at
+                    """)).fetchall()
+        finally:
+            session.close()
+
+        plans: list[dict[str, Any]] = []
+        for r in rows:
+            base_features = _quota_features(r.quotas if isinstance(r.quotas, dict) else None)
+            if r.yearly_price and float(r.yearly_price) > 0:
+                plans.append(
+                    {
+                        "plan_id": r.plan_key,
+                        "billing_cycle": "yearly",
+                        "name": r.name,
+                        "description": r.description,
+                        "price_cents": int(round(float(r.yearly_price) * 100)),
+                        "monthly_price_cents": int(round(float(r.yearly_price) * 100 / 12)),
+                        "duration_days": 365,
+                        "features": dict(base_features),
+                    }
+                )
+            if r.monthly_price and float(r.monthly_price) > 0:
+                plans.append(
+                    {
+                        "plan_id": r.plan_key,
+                        "billing_cycle": "monthly",
+                        "name": r.name,
+                        "description": r.description,
+                        "price_cents": int(round(float(r.monthly_price) * 100)),
+                        "monthly_price_cents": int(round(float(r.monthly_price) * 100)),
+                        "duration_days": 30,
+                        "features": dict(base_features),
+                    }
+                )
+        return plans
+
+    return _cached("membership_plans", _load)
+
+
+def get_points_packages() -> list[dict[str, Any]]:
+    """读取 is_active=true 的积分充值包。"""
+
+    def _load() -> list[dict[str, Any]]:
+        from sqlalchemy import text
+
+        from packages.adapters.sqlalchemy_impl.session import SessionLocal
+
+        if SessionLocal is None:
+            return []
+
+        session = SessionLocal()
+        try:
+            rows = session.execute(text("""
+                    SELECT package_key, name, price, credits, bonus_credits,
+                           is_recommended, description, sort_order
+                    FROM credit_packages
+                    WHERE is_active = TRUE
+                    ORDER BY sort_order NULLS LAST, price
+                    """)).fetchall()
+        finally:
+            session.close()
+
+        packages: list[dict[str, Any]] = []
+        for r in rows:
+            total_points = int(r.credits or 0) + int(r.bonus_credits or 0)
+            price_cents = int(round(float(r.price) * 100))
+            unit = (price_cents / 100 / total_points) if total_points else 0
+            packages.append(
+                {
+                    "code": r.package_key,
+                    "name": r.name,
+                    "points": total_points,
+                    "bonus_credits": int(r.bonus_credits or 0),
+                    "price_cents": price_cents,
+                    "unit_price": f"¥{unit:.3f}/积分",
+                    "is_recommended": bool(r.is_recommended),
+                    "description": r.description,
+                }
+            )
+        return packages
+
+    return _cached("points_packages", _load)

packages/application/cosyvoice_service.py

@@ -351,12 +351,25 @@ class CosyVoiceService:
                 用于私有 bucket 下，将裸 URL 转为预签名 URL，
                 确保 CosyVoice 服务器能下载参考音频.
         """
+        # 优先从 ai_router 获取 DB 配置
+        _router_key, _router_url, _router_model = "", "", ""
+        try:
+            from packages.shared.ai_router import ai_router
+
+            tts_client = ai_router.get_tts_client("tts")
+            if tts_client and tts_client.is_available:
+                _router_key = tts_client.api_key
+                _router_url = tts_client.base_url
+                _router_model = tts_client.model
+        except Exception:
+            pass
+
         settings = get_shared_settings()
 
-        self._api_key = api_key or settings.cosyvoice_api_key
-        self._base_url = base_url or settings.cosyvoice_base_url
-        self._model = model or settings.cosyvoice_model
-        self._clone_model = clone_model or getattr(settings, "cosyvoice_clone_model", "voice-enrollment")
+        self._api_key = api_key or _router_key or settings.cosyvoice_api_key
+        self._base_url = base_url or _router_url or settings.cosyvoice_base_url
+        self._model = model or _router_model or settings.cosyvoice_model
+        self._clone_model = clone_model or getattr(settings, "cosyvoice_clone_model", "")
         self._audio_url_signer = audio_url_signer
 
         # base_url 规范化：去掉末尾的路径残留（兼容旧版配置）

packages/application/viral_video/__init__.py

@@ -0,0 +1 @@
+"""应用层：爆款视频 Prompt 模板系统（#2040）。"""

packages/application/viral_video/generator.py

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

packages/application/viral_video/prompt_loader.py

@@ -0,0 +1,160 @@
+"""Prompt 模板加载器：从 viral_video_prompt_templates 读模板，30 秒 TTL 热加载。
+
+DB 不可用或没有数据时自动回落到 prompts.DEFAULT_TEMPLATES，保证流程不阻断。
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+import sqlalchemy as sa
+
+from packages.adapters.sqlalchemy_impl import session as _session_mod
+from packages.application.viral_video.prompts import DEFAULT_TEMPLATES
+
+CACHE_TTL_SECONDS = 30.0
+
+_VALID_TYPES = {"image_analysis", "intent_parsing", "copy_fusion", "storyboard", "review"}
+
+
+@dataclass
+class PromptTemplate:
+    name: str
+    prompt_type: str
+    version: int
+    system_prompt: str
+    user_prompt_template: str
+    example_output: str = ""
+    is_active: bool = True
+
+
+_lock = threading.Lock()
+_cache: dict[str, tuple[float, PromptTemplate]] = {}
+
+
+def _fallback(prompt_type: str) -> Optional[PromptTemplate]:
+    for item in DEFAULT_TEMPLATES:
+        if item["prompt_type"] == prompt_type:
+            return PromptTemplate(
+                name=item["name"],
+                prompt_type=item["prompt_type"],
+                version=item["version"],
+                system_prompt=item["system_prompt"],
+                user_prompt_template=item["user_prompt_template"],
+                example_output=item["example_output"] or "",
+                is_active=bool(item["is_active"]),
+            )
+    return None
+
+
+_lazy_session = None
+
+
+def _get_session():
+    """优先用全局 SessionLocal（worker）；否则按应用配置懒建同步引擎（api）。"""
+    global _lazy_session
+    if _session_mod.SessionLocal is not None:
+        return _session_mod.SessionLocal()
+    if _lazy_session is not None:
+        return _lazy_session()
+    try:
+        from packages.config import get_shared_settings
+
+        url = str(get_shared_settings().database_url)
+    except Exception:  # noqa: BLE001
+        return None
+    if not url:
+        return None
+    url = url.replace("postgresql+asyncpg://", "postgresql+psycopg://")
+    url = url.replace("postgresql://", "postgresql+psycopg://") if url.startswith("postgresql://") else url
+    engine = sa.create_engine(url, pool_pre_ping=True, pool_size=2, max_overflow=2)
+    from sqlalchemy.orm import sessionmaker
+
+    _lazy_session = sessionmaker(bind=engine)
+    return _lazy_session()
+
+
+def _load_from_db(prompt_type: str) -> Optional[PromptTemplate]:
+    session = None
+    try:
+        session = _get_session()
+        if session is None:
+            return None
+        sql = sa.text("""
+            SELECT name, prompt_type, version, system_prompt,
+                   user_prompt_template, COALESCE(example_output, '') AS example_output,
+                   is_active
+              FROM viral_video_prompt_templates
+             WHERE prompt_type = :pt AND is_active = TRUE
+             ORDER BY version DESC
+             LIMIT 1
+            """)
+        row = session.execute(sql, {"pt": prompt_type}).first()
+        if row is None:
+            return None
+        return PromptTemplate(
+            name=row[0],
+            prompt_type=row[1],
+            version=int(row[2]),
+            system_prompt=row[3],
+            user_prompt_template=row[4],
+            example_output=row[5] or "",
+            is_active=bool(row[6]),
+        )
+    except Exception:  # noqa: BLE001 - 表不存在/DB 不可用时静默回落
+        return None
+    finally:
+        if session is not None:
+            try:
+                session.close()
+            except Exception:  # noqa: BLE001
+                pass
+
+
+def get_template(prompt_type: str, *, force_refresh: bool = False) -> Optional[PromptTemplate]:
+    """取某类型当前启用模板，30 秒缓存；DB 无数据则回落到代码默认模板。"""
+    if prompt_type not in _VALID_TYPES:
+        raise ValueError(f"未知 prompt_type: {prompt_type}")
+
+    now = time.monotonic()
+    with _lock:
+        cached = _cache.get(prompt_type)
+        if not force_refresh and cached and now - cached[0] < CACHE_TTL_SECONDS:
+            return cached[1]
+
+    template = _load_from_db(prompt_type) or _fallback(prompt_type)
+    if template is not None:
+        with _lock:
+            _cache[prompt_type] = (now, template)
+    return template
+
+
+def invalidate() -> None:
+    """清空缓存（测试用）。"""
+    with _lock:
+        _cache.clear()
+
+
+class _SafeDict(dict):
+    def __missing__(self, key: str) -> str:
+        return "{" + key + "}"
+
+
+def _safe_format(text: str, kwargs: dict) -> str:
+    try:
+        return text.format_map(_SafeDict(kwargs))
+    except Exception:  # noqa: BLE001
+        return text
+
+
+def render_user_prompt(template: PromptTemplate, **kwargs) -> str:
+    """填充 user_prompt_template 占位符，缺键原样保留不报错。"""
+    return _safe_format(template.user_prompt_template, kwargs)
+
+
+def render_system_prompt(template: PromptTemplate, **kwargs) -> str:
+    """copy_fusion 等 system_prompt 含运行时变量时填充。"""
+    return _safe_format(template.system_prompt, kwargs)

packages/application/viral_video/prompts.py

@@ -0,0 +1,342 @@
+"""爆款视频 5 套 Prompt 模板默认值（#2040 核心资产）。
+
+重要约定（用户明确要求）：
+- 所有 system_prompt / user_prompt_template / example_output 都是**纯文本自然语言 + XML 标签**，
+  运营可直接看懂和编辑，禁止 JSON、禁止 ```json 代码块。
+- LLM 按 XML 标签输出字段，程序用正则解析（见 xml_parser.py）。
+- user_prompt_template 中花括号占位符（如 {user_copy_text}）在运行时填充。
+"""
+
+from __future__ import annotations
+
+TEMPLATE_VERSION = 1
+
+# 所有文案类 Prompt 自动注入的硬约束
+GLOBAL_CONSTRAINTS = """【必须遵守的硬约束】
+1. 不编造时间：不写“今年最新”“2024 爆款”等会过时的时间表述。
+2. 不承诺效果：不写“保证”“一定”“100%有效”“包治百病”等绝对化用语。
+3. 不编造价格、销量、认证、奖项：除非用户在文案中明确给出，否则一律不写。
+4. 符合广告法及平台社区规范。
+5. 只描述图片中真实可见的内容，看不到的不瞎猜。"""
+
+# 反套路化要求
+NEGATIVE_RULES = """【反套路化要求】
+禁止使用“家人们谁懂啊”“绝绝子”“宝子们”“家人们”“太绝了”“yyds”等烂大街网络词；
+禁止固定模板化开头；语言要像真人朋友之间的分享，自然、具体、有信息量。"""
+
+# 输出禁用套路词（测试会检查）
+BANNED_PHRASES = ["家人们谁懂啊", "绝绝子", "宝子们", "yyds", "太绝了"]
+
+# 文案融合三档独立指令段
+FUSION_INSTRUCTIONS = {
+    "ai_full": """【本次创作模式：AI 全权创作】
+你是资深短视频编导。用户只提供了产品图片，没有给出具体文案方向。请根据图片内容和营销参数，自由发挥创作完整的爆款短视频文案。充分挖掘产品真实可见的卖点，使用爆款结构，抓人眼球。""",
+    "ai_polish": """【本次创作模式：AI 辅助润色】
+你是用户的文案助理。用户已经写了草稿/关键词/碎碎念，表达了他想讲的核心意思，但表达不完整、不够吸引人。你的任务是：以用户的意思为主，保留他想表达的所有核心信息点，在此基础上润色扩写、调整语序、增加衔接、优化表达，让文案更流畅更有吸引力。绝对不能改变用户想表达的核心意思，不能把用户的观点换成相反的，不能添加用户没提到的产品卖点。用户提到的品牌名、价格、人名、具体事实必须原样保留。""",
+    "user_primary": """【本次创作模式：以用户原文为主】
+你是文案润色助手。用户已经写好了明确的文案，这是他最终想表达的内容。你的任务是最小化修改：只做必要的错别字修正、标点调整、语句通顺度优化，以及添加必要的衔接词让口播更自然。用户的核心句子、关键表述、事实信息一律不改。如果用户文案本身已经很好，直接返回，不要为了改而改。personal_brands 中的事实信息必须逐字保留。""",
+}
+
+# ── 模板1：图片多模态分析（VLM）────────────────────────────────────────
+_IMAGE_ANALYSIS_SYSTEM = f"""你是电商商品视觉分析师，负责从商品图片中提取真实可见的商品信息。
+
+工作方式（分步骤看，不要跳步）：
+1. 先看整体：有哪些产品、什么场景、有没有人物。
+2. 再看细节：包装文字、颜色构成、人物状态、画面质感。
+3. 最后提炼卖点：只总结图片里能看到的卖点。
+
+{GLOBAL_CONSTRAINTS}
+
+请严格按下面的标签格式输出，标签名一个都不能改，不要输出任何解释，不要用代码块：
+<products> 下面每个产品用一个 <product> 标签，属性 name 是产品名、features 是外观特征、position 是 main 或 secondary、image_index 是第几张图（从0开始）。
+<colors> 下面每个主要颜色用一个 <color> 标签，属性 hex 是色值、name 是颜色名、coverage 是占比小数。
+<people> 用一个标签，属性 has_person、count、gender、age_range、hair（发型发色）、skin_tone（肤色）、face_shape（脸型）、outfit（穿着）、pose（姿态）、expression（表情）分别描述人物外貌。有人物时属性尽量具体（如hair="黑色长直发"、outfit="白色衬衫"），无人像时除has_person=false外其他填"无法判断"。
+<mood> 标签写画面整体情绪氛围。
+<visible_text> 下面每处可见文字用一个 <text_item> 标签，属性 text 是文字内容、position 是位置。
+<scene> 标签写场景描述。
+<quality> 用一个标签，属性 resolution、lighting、composition、blur 描述画质。
+<key_selling_points> 下面每个卖点用一个 <point> 标签。
+
+【人物属性硬性要求（has_person=true时必须遵守）】
+hair/skin_tone/face_shape/outfit四项绝对禁止填“无法判断”，必须基于图片可见特征给出具体中文描述：
+- hair：必须描述发型+发色，如“黑色齐肩直发”“棕色微卷中长发”“深棕色短发”
+- skin_tone：必须描述肤色，如“暖调自然肤色”“白皙肤色”“小麦色”
+- face_shape：必须描述脸型，如“鹅蛋脸”“圆脸”“瓜子脸”“方脸”
+- outfit：必须描述可见穿着，如“米色翻领衬衫”“白色T恤”“黑色连衣裙”
+即使局部被遮挡也要根据可见部分合理推断；确实看不清时按最接近的直观印象描述。
+
+其他非人物属性看不到或无法判断时填“无法判断”，布尔值填false，不要留空标签。
+
+【有人物场景输出参考（女性手持商品示例，必须写全10个属性，禁止省略）】
+<people has_person="true" count="1" gender="女" age_range="青年" hair="黑色齐肩直发" skin_tone="暖调自然肤色" face_shape="鹅蛋脸" outfit="米色翻领衬衫" pose="正面半身，手持商品" expression="面带微笑"/>"""
+
+_IMAGE_ANALYSIS_USER = """请分析以下商品图片，共 {image_count} 张。
+所属行业：{industry}
+图片地址：
+{image_urls}
+
+按约定的标签格式输出分析结果。"""
+
+_IMAGE_ANALYSIS_EXAMPLE = """<products>
+<product name="大公鸡头 多功能油污净 625ml" features="红色瓶盖白色瓶身，鸡头图案Logo" position="main" image_index="0"/>
+</products>
+<colors>
+<color hex="#D32F2F" name="红色" coverage="0.4"/>
+<color hex="#FFFFFF" name="白色" coverage="0.5"/>
+</colors>
+<people has_person="false" count="0" gender="无法判断" age_range="无法判断" hair="无法判断" skin_tone="无法判断" face_shape="无法判断" outfit="无法判断" pose="无法判断" expression="无法判断"/>
+<mood>干净、实用</mood>
+<visible_text>
+<text_item text="多功能油污净" position="瓶身正面"/>
+</visible_text>
+<scene>白底棚拍产品图</scene>
+<quality resolution="高清" lighting="均匀柔和" composition="主体居中" blur="false"/>
+<key_selling_points>
+<point>针对重油污设计</point>
+<point>大容量625ml</point>
+</key_selling_points>"""
+
+# ── 模板2：用户文案意图解析（LLM）──────────────────────────────────────
+_INTENT_SYSTEM = f"""你负责理解用户的营销意图。用户给的文案可能只是几个关键词、碎碎念或者不完整的短句，你要读懂他真正想讲什么。
+
+{GLOBAL_CONSTRAINTS}
+
+请严格按下面的标签格式输出，不要解释，不要用代码块：
+<intent_summary> 用用户的语言风格，一句话、30字以内概括核心意图。
+<core_messages> 下面每个核心信息点用一个 <message> 标签，属性 must_keep 为 true 或 false、confidence 为 0 到 1 的小数，标签内容写信息点。
+<personal_brands> 把用户提到的具体事实——品牌名、价格、人名、地名、时间、产品名——每条用一个 <brand> 标签，属性 category 取 brand、price、person、place、time、product 之一。这些事实必须原样引用，一个字都不能改。
+<emotion_tone> 写文案的情绪调性。
+<missing_info> 把你认为缺失、后续生成时需要合理推断的信息，每条用一个 <info> 标签；没有就输出空标签。"""
+
+_INTENT_USER = """用户原始文案：{user_copy_text}
+所属行业：{industry}
+营销目的：{marketing_purpose}
+图片分析结果（供参考）：
+{image_analysis}
+图片类型推断：{image_category_hint}
+
+请理解用户意图，按标签格式输出。注意：theme和emotion_tone应与图片类型和营销目的匹配——门店类图片偏向"门店探店/到店体验"，商品图偏向"好物分享/产品种草"，人物图偏向"穿搭/人物故事"。"""
+
+_INTENT_EXAMPLE = """<intent_summary>一款厨房去油污神器，喷一喷油污就掉</intent_summary>
+<core_messages>
+<message must_keep="true" confidence="0.97">去油污效果好，喷上等几分钟再擦</message>
+<message must_keep="false" confidence="0.7">适合厨房重油污场景</message>
+</core_messages>
+<personal_brands>
+<brand category="product">大公鸡头多功能油污净</brand>
+<brand category="price">39块钱一瓶</brand>
+</personal_brands>
+<emotion_tone>亲切、真实、带分享感</emotion_tone>
+<missing_info>
+<info>没有说明具体容量，按图片读出的625ml处理</info>
+</missing_info>"""
+
+# ── 模板3：文案融合生成（LLM）──────────────────────────────────────────
+_FUSION_SYSTEM = """你负责为短视频生成营销文案。请按思维链分步完成：先定人设和目标客户，再找卖点，再搭结构，再安排情绪，最后写行动号召，不要一步到位乱写。
+
+{fusion_instruction}
+
+{global_constraints}
+
+{negative_rules}
+
+请严格按下面的标签格式输出，不要解释，不要用代码块：
+<title> 视频标题。
+<hook> 开头3秒钩子，5到15字。
+<body_points> 每个要点用一个 <point> 标签，属性 elaboration 是展开说明、image_index 是对应第几张图（从0开始），标签内容写要点。
+<cta> 口语化的行动号召。
+<script_segments> 每段配音用一个 <segment> 标签，属性 duration_sec 是秒数、image_index 是对应图片，标签内容写配音文案（纯口播文本，不加旁白标注、不加镜头标注、不加"主播："之类前缀）。
+<voiceover_script> 把所有 segment 的配音文案按顺序自然拼接成一段完整的纯口播文本（无标记、无括号、无前缀），长度要适配 {duration} 秒，约 {approx_chars} 字。
+<overview_theme> 视频主题（一句话概括）。
+<scene_and_lighting> 整体场景描述+光线设定（100-200字，要具体：在哪拍、什么光线、什么色调、什么氛围）。
+<word_count> 配音总字数，只写数字。
+<estimated_duration> 预计时长秒数，只写数字。
+
+用户在 personal_brands 中提到的品牌名、价格、人名、地名、时间、产品名等事实信息，必须原样出现在文案里，一个字都不能改。"""
+
+_FUSION_USER = """所属行业：{industry}
+目标客户：{target_customer}
+营销目的：{marketing_purpose}
+视频时长：{duration}秒
+图片分析结果：
+{image_analysis}
+用户意图解析结果：
+{intent_result}
+
+请按标签格式生成文案。"""
+
+_FUSION_EXAMPLE = """<title>厨房重油污，别再用洗洁精硬擦了</title>
+<hook>这油污，我真的忍很久了</hook>
+<body_points>
+<point elaboration="喷在油污上等几分钟，一擦就干净" image_index="0">大公鸡头油污净去油快</point>
+<point elaboration="39块钱625ml，能用很久" image_index="0">39块钱一瓶，性价比高</point>
+</body_points>
+<cta>厨房油污重的，真的可以试一瓶</cta>
+<script_segments>
+<segment duration_sec="3" image_index="0">这油污我真的忍很久了，用洗洁精擦半天都没用</segment>
+<segment duration_sec="6" image_index="0">后来换了这个大公鸡头油污净，喷上等几分钟，一擦就干净</segment>
+<segment duration_sec="4" image_index="0">39块钱625ml，厨房重油污的可以试一瓶</segment>
+</script_segments>
+<voiceover_script>这油污我真的忍很久了，用洗洁精擦半天都没用。后来换了这个大公鸡头油污净，喷上等几分钟，一擦就干净。39块钱625ml，厨房重油污的可以试一瓶。</voiceover_script>
+<overview_theme>厨房好物分享·产品种草</overview_theme>
+<scene_and_lighting>简洁明亮的厨房台面场景，自然光从窗户洒入，色调温暖柔和，突出产品白色瓶身与去油污对比效果。</scene_and_lighting>
+<word_count>58</word_count>
+<estimated_duration>13</estimated_duration>"""
+
+# ── 模板4：编导级分镜（LLM）────────────────────────────────────────────
+_STORYBOARD_SYSTEM = """你是短视频编导，负责把文案拆成可拍摄的分镜，为 Seedance 2.5 视频模型写编导分镜脚本。脚本将整体作为 prompt 一次性传给视频模型，必须让模型在连贯镜头流中清楚每段时间拍什么、画面如何、人物说什么。
+
+工作方式：
+1. 按文案的 script_segments 顺序分配镜头。
+2. 每个镜头确定景别/角度/运镜、画面场景与对白、人物动作细节、音效/BGM、转场。
+3. 检查所有镜头时长加起来接近目标时长，误差不超过2秒。
+4. image_index 必须在已上传图片范围内，第一张主图必须用在第一个镜头。
+
+{fusion_instruction}
+
+{global_constraints}
+
+{negative_rules}
+
+请严格按下面的标签格式输出，不要解释，不要用代码块：
+<clips> 下面每个镜头用一个 <clip> 标签，属性 image_index 是图片序号（从0开始）、transition 取 fade/cut/zoom_in/slide_left/dissolve/wipe 之一、zoom 取 in/out/null、duration_sec 是该镜头秒数、bgm_note 是该段BGM情绪。每个 <clip> 里面包含：
+  <voice_text> 该镜头配音文本（纯口播文本，不加旁白标注）；
+  <subtitle_text> 字幕文本，可与配音一致或更精简；
+  <shot_type_angle_movement> 景别+角度+运镜（例：近景俯拍45度，缓慢推镜；中景平视，固定镜头；特写平视，快速拉镜）；
+  <scene_and_dialogue> 画面场景描述 + 人物口播台词（对白要自然口语化，像朋友聊天，不要硬广推销腔）；
+  <action_details> 人物动作、表情、物品操作细节（手怎么动、表情变化、产品怎么展示）；
+  <audio_bgm> 环境音+BGM提示（例：轻快流行BGM，环境嘈杂咖啡店背景音）；
+  <transition> 硬切/淡入淡出/叠化（最后一镜写『结束』即可）；
+  <reference_image_index> 参考图片索引（0-based，对应第几张产品图，无则空）；
+  <ken_burns> 用一个空标签，属性 start、end 写"x,y"坐标、ease 写缓动方式；不需要运镜时坐标相同。"""
+
+_STORYBOARD_USER = """目标时长：{duration}秒
+上传图片数量：{image_count}张（第1张是主图/封面）
+文案内容：
+{fusion_result}
+图片分析结果：
+{image_analysis}
+
+重要：overview_theme 必须与图片实际内容和营销目的匹配。门店/餐饮/服务类图片用"门店探店·到店体验"；商品图用"好物分享·产品种草"；人物图用"穿搭分享·人物故事"；场景图用"空间体验·场景氛围"。不要对所有图片都使用"好物分享"。
+
+请按标签格式输出分镜。"""
+
+_STORYBOARD_EXAMPLE = """<clips>
+<clip image_index="0" transition="cut" zoom="null" duration_sec="3" bgm_note="日常、轻微烦躁">
+<voice_text>这油污我真的忍很久了</voice_text>
+<subtitle_text>这油污忍很久了</subtitle_text>
+<shot_type_angle_movement>近景俯拍45度，缓慢推镜</shot_type_angle_movement>
+<scene_and_dialogue>厨房台面，主妇皱眉看着灶台油污。对白：这油污我真的忍很久了</scene_and_dialogue>
+<action_details>右手拿着脏抹布，无奈摇头</action_details>
+<audio_bgm>轻快日常BGM，带一点烦躁感</audio_bgm>
+<transition>硬切</transition>
+<reference_image_index>0</reference_image_index>
+<ken_burns start="0,0" end="0,0" ease="linear"/>
+</clip>
+<clip image_index="0" transition="zoom_in" zoom="in" duration_sec="6" bgm_note="轻快、出现转机">
+<voice_text>后来换了大公鸡头油污净，喷上等几分钟，一擦就干净</voice_text>
+<subtitle_text>喷上等几分钟，一擦就干净</subtitle_text>
+<shot_type_angle_movement>特写平视，固定镜头</shot_type_angle_movement>
+<scene_and_dialogue>手部特写，喷油污净在油污处。对白：后来换了这个大公鸡头油污净，喷上等几分钟，一擦就干净</scene_and_dialogue>
+<action_details>左手拿产品瓶身，右手按压喷头，等待片刻后用抹布轻擦</action_details>
+<audio_bgm>轻快转折BGM，带清爽感</audio_bgm>
+<transition>淡入淡出</transition>
+<reference_image_index>0</reference_image_index>
+<ken_burns start="20,20" end="80,80" ease="ease-in-out"/>
+</clip>
+<clip image_index="0" transition="fade" zoom="null" duration_sec="4" bgm_note="温暖、推荐">
+<voice_text>39块钱625ml，厨房重油污的可以试一瓶</voice_text>
+<subtitle_text>39元625ml，可以试一瓶</subtitle_text>
+<shot_type_angle_movement>中景平视，缓慢拉镜</shot_type_angle_movement>
+<scene_and_dialogue>产品正面展示，明亮背景。对白：39块钱625ml，厨房重油污的可以试一瓶</scene_and_dialogue>
+<action_details>产品置于画面中央，轻微转动展示瓶身</action_details>
+<audio_bgm>温暖收尾BGM</audio_bgm>
+<transition>结束</transition>
+<reference_image_index>0</reference_image_index>
+<ken_burns start="50,50" end="20,20" ease="ease-in-out"/>
+</clip>
+</clips>"""
+
+# ── 模板5：文案审核（LLM）──────────────────────────────────────────────
+_REVIEW_SYSTEM = f"""你是短视频文案合规审核员，从6个维度逐条检查文案：
+1. 违规词：有没有平台禁用词、敏感词。
+2. 夸大承诺：有没有“包治百病”“100%有效”“保证赚钱”等绝对化、夸大表述。
+3. 事实一致性：有没有编造价格、数据、认证，或者用户没提到的产品特性。
+4. 用户意图保留：在 ai_polish 和 user_primary 模式下，core_messages 中 must_keep=true 的点是否都保留了。
+5. 结构完整性：标题、钩子、正文、行动号召是否齐全。
+6. 语气人设：是否符合选定的人设语气，有没有“家人们谁懂啊”“绝绝子”“宝子们”等套路词。
+
+{GLOBAL_CONSTRAINTS}
+
+请严格按下面的标签格式输出，不要解释，不要用代码块：
+<passed> 整体是否通过，只写 true 或 false。
+<issues> 每个问题用一个 <issue> 标签，属性 dimension 是维度名、severity 取 error 或 warning、location 是问题所在（如 hook、body_points、cta），标签内容写问题描述；没有问题就输出空标签。
+<rewrite_suggestions> 每条具体修改建议用一个 <suggestion> 标签；没有就输出空标签。"""
+
+_REVIEW_USER = """本次创作模式：{fusion_level}
+待审核文案：
+{fusion_result}
+用户意图解析（用于核对核心信息是否保留）：
+{intent_result}
+
+请按6个维度审核，按标签格式输出。"""
+
+_REVIEW_EXAMPLE = """<passed>false</passed>
+<issues>
+<issue dimension="夸大承诺" severity="error" location="body_points">出现了“一喷100%掉光”的绝对化表述，违反广告法</issue>
+<issue dimension="用户意图保留" severity="warning" location="cta">用户强调的“39块钱”没有保留</issue>
+</issues>
+<rewrite_suggestions>
+<suggestion>把“一喷100%掉光”改为“喷上等几分钟，大部分油污能擦掉”</suggestion>
+<suggestion>在结尾补回“39块钱625ml”</suggestion>
+</rewrite_suggestions>"""
+
+
+# 5 套模板默认数据（seed 数据源与 loader 的兜底）
+DEFAULT_TEMPLATES: list[dict] = [
+    {
+        "name": "图片多模态分析",
+        "prompt_type": "image_analysis",
+        "version": TEMPLATE_VERSION,
+        "system_prompt": _IMAGE_ANALYSIS_SYSTEM,
+        "user_prompt_template": _IMAGE_ANALYSIS_USER,
+        "example_output": _IMAGE_ANALYSIS_EXAMPLE,
+        "is_active": True,
+    },
+    {
+        "name": "用户文案意图解析",
+        "prompt_type": "intent_parsing",
+        "version": TEMPLATE_VERSION,
+        "system_prompt": _INTENT_SYSTEM,
+        "user_prompt_template": _INTENT_USER,
+        "example_output": _INTENT_EXAMPLE,
+        "is_active": True,
+    },
+    {
+        "name": "文案融合生成",
+        "prompt_type": "copy_fusion",
+        "version": TEMPLATE_VERSION,
+        "system_prompt": _FUSION_SYSTEM,
+        "user_prompt_template": _FUSION_USER,
+        "example_output": _FUSION_EXAMPLE,
+        "is_active": True,
+    },
+    {
+        "name": "编导级分镜",
+        "prompt_type": "storyboard",
+        "version": TEMPLATE_VERSION,
+        "system_prompt": _STORYBOARD_SYSTEM,
+        "user_prompt_template": _STORYBOARD_USER,
+        "example_output": _STORYBOARD_EXAMPLE,
+        "is_active": True,
+    },
+    {
+        "name": "文案审核",
+        "prompt_type": "review",
+        "version": TEMPLATE_VERSION,
+        "system_prompt": _REVIEW_SYSTEM,
+        "user_prompt_template": _REVIEW_USER,
+        "example_output": _REVIEW_EXAMPLE,
+        "is_active": True,
+    },
+]

packages/application/viral_video/reviewer.py

@@ -0,0 +1,319 @@
+"""文案审核 + 自动重写（#2040 第5套 Prompt）。
+
+6 维度：违规词 / 夸大承诺 / 事实一致性 / 用户意图保留 / 结构完整性 / 语气人设。
+LLM 审核之外叠加本地规则预检（保证即使 LLM 不可用也能兜住广告法红线）。
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Optional
+
+from packages.application.viral_video import xml_parser as xp
+from packages.application.viral_video.prompt_loader import (
+    get_template,
+    render_system_prompt,
+    render_user_prompt,
+)
+from packages.application.viral_video.schemas import (
+    FusionResult,
+    IntentResult,
+    ReviewIssue,
+    ReviewResult,
+)
+
+logger = logging.getLogger(__name__)
+
+# 本地规则：绝对化/夸大词
+_EXAGGERATION_PATTERNS = [
+    r"100\s*%",
+    r"百分百",
+    r"包治百病",
+    r"保证.{0,8}(有效|赚钱|瘦|好)",
+    r"绝对(有效|安全|靠谱)",
+    r"全网第一",
+    r"国家级",
+    r"特效",
+    r"立刻见效",
+    r"一喷(就|全|100)",
+]
+
+# 本地规则：平台违规/套路词
+_VIOLATION_PHRASES = [
+    "家人们谁懂啊",
+    "绝绝子",
+    "宝子们",
+    "yyds",
+    "最(好|强|牛|便宜)",  # 广告法极限词
+    "第一(名|品牌)?",
+]
+
+_LOCATIONS = ["title", "hook", "body_points", "cta", "script_segments"]
+
+
+class Reviewer:
+    def __init__(self, client=None):
+        if client is None:
+            try:
+                from packages.shared.ai_router import ai_router
+
+                client = ai_router.get_llm_client("copy_review")
+            except Exception:
+                from packages.shared.ai_client import get_doubao_client
+
+                client = get_doubao_client()
+        self.client = client
+
+    # ── 审核 ────────────────────────────────────────────────────────────
+    def review(self, fusion: FusionResult, intent: IntentResult, fusion_level: str) -> ReviewResult:
+        local = self._rule_check(fusion, intent, fusion_level)
+        llm_result = self._llm_review(fusion, intent, fusion_level)
+        if llm_result is None:
+            return ReviewResult(
+                passed=not local,
+                issues=local,
+                rewrite_suggestions=[],
+                raw="",
+            )
+        # LLM 与本地规则合并去重
+        issues = self._merge_issues(llm_result.issues, local)
+        return ReviewResult(
+            passed=llm_result.passed and not local,
+            issues=issues,
+            rewrite_suggestions=llm_result.rewrite_suggestions,
+            raw=llm_result.raw,
+        )
+
+    def _llm_review(self, fusion: FusionResult, intent: IntentResult, fusion_level: str) -> Optional[ReviewResult]:
+        template = get_template("review")
+        system = render_system_prompt(template)
+        user = render_user_prompt(
+            template,
+            fusion_level=fusion_level,
+            fusion_result=self._fusion_text(fusion),
+            intent_result=self._intent_text(intent),
+        )
+        raw = self.client.chat_completion(
+            [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            temperature=0.2,
+            max_tokens=1024,
+            timeout=25,
+        )
+        if not raw:
+            return None
+        passed = xp.text_of(raw, "passed").strip().lower()
+        issues = [
+            ReviewIssue(
+                dimension=n["attrs"].get("dimension", "未知维度"),
+                severity=n["attrs"].get("severity", "warning"),
+                location=n["attrs"].get("location", ""),
+                text=n["text"],
+            )
+            for n in xp.find_all(raw, "issue")
+            if n["text"]
+        ]
+        suggestions = [n["text"] for n in xp.find_all(raw, "suggestion") if n["text"]]
+        parsed = ReviewResult(
+            passed=passed == "true" and not issues,
+            issues=issues,
+            rewrite_suggestions=suggestions,
+            raw=raw,
+        )
+        return parsed
+
+    # ── 本地规则预检 ────────────────────────────────────────────────────
+    def _rule_check(self, fusion: FusionResult, intent, fusion_level: str) -> list[ReviewIssue]:
+        issues: list[ReviewIssue] = []
+        for location, text in self._segments(fusion):
+            for pattern in _EXAGGERATION_PATTERNS:
+                if re.search(pattern, text):
+                    issues.append(
+                        ReviewIssue(
+                            dimension="夸大承诺",
+                            severity="error",
+                            location=location,
+                            text=f"出现夸大/绝对化表述：{self._hit(text, pattern)}",
+                        )
+                    )
+            for phrase in _VIOLATION_PHRASES:
+                if re.search(phrase, text, flags=re.IGNORECASE):
+                    issues.append(
+                        ReviewIssue(
+                            dimension="违规词",
+                            severity="error",
+                            location=location,
+                            text=f"出现违规或套路词：{self._hit(text, phrase)}",
+                        )
+                    )
+
+        # 结构完整性
+        if not fusion.title:
+            issues.append(ReviewIssue(dimension="结构完整性", severity="warning", location="title", text="缺少标题"))
+        if not fusion.hook:
+            issues.append(ReviewIssue(dimension="结构完整性", severity="warning", location="hook", text="缺少开头钩子"))
+        if not fusion.cta:
+            issues.append(ReviewIssue(dimension="结构完整性", severity="warning", location="cta", text="缺少行动号召"))
+
+        # 用户意图保留（must_keep）
+        full_text = self._fusion_text(fusion)
+        if fusion_level in {"ai_polish", "user_primary"} and intent is not None:
+            for message in intent.core_messages:
+                if message.must_keep:
+                    key = self._compact(message.text)
+                    if key and key[:10] not in self._compact(full_text):
+                        issues.append(
+                            ReviewIssue(
+                                dimension="用户意图保留",
+                                severity="warning",
+                                location="script_segments",
+                                text=f"用户核心信息被丢失：{message.text[:30]}",
+                            )
+                        )
+            for brand in intent.personal_brands:
+                if brand.text and brand.text not in full_text:
+                    issues.append(
+                        ReviewIssue(
+                            dimension="事实一致性",
+                            severity="error",
+                            location="script_segments",
+                            text=f"personal_brands 事实信息未原样保留：{brand.text[:30]}",
+                        )
+                    )
+        return issues
+
+    @staticmethod
+    def _hit(text: str, pattern: str) -> str:
+        match = re.search(pattern, text, flags=re.IGNORECASE)
+        return match.group(0) if match else pattern
+
+    @staticmethod
+    def _compact(text: str) -> str:
+        return re.sub(r"[\s，。！？、,.!?；;：:\"'“”‘’（）()【】\[\]]", "", text)
+
+    @staticmethod
+    def _merge_issues(llm_issues: list[ReviewIssue], local: list[ReviewIssue]) -> list[ReviewIssue]:
+        merged = list(local)
+        seen = {(i.dimension, Reviewer._compact(i.text)[:20]) for i in local}
+        for issue in llm_issues:
+            key = (issue.dimension, Reviewer._compact(issue.text)[:20])
+            if key not in seen:
+                merged.append(issue)
+                seen.add(key)
+        return merged
+
+    # ── 自动重写（1 次）─────────────────────────────────────────────────
+    def rewrite(
+        self,
+        fusion: FusionResult,
+        review: ReviewResult,
+        intent: IntentResult,
+        fusion_level: str,
+    ) -> FusionResult:
+        from packages.application.viral_video.generator import CopyGenerator
+
+        template = get_template("copy_fusion")
+        system_kwargs = {
+            "fusion_instruction": (
+                "【本次任务：按审核意见修正文案】只修改指出的问题，其他内容尽量原样保留；"
+                "personal_brands 事实信息逐字保留；修正后按原标签格式完整输出。"
+            ),
+            "global_constraints": "",
+            "negative_rules": "",
+        }
+        issue_text = "\n".join(f"- [{i.dimension}/{i.location}] {i.text}" for i in review.issues)
+        suggestion_text = "\n".join(f"- {s}" for s in review.rewrite_suggestions)
+        user = render_user_prompt(
+            template,
+            industry="",
+            target_customer="",
+            marketing_purpose="",
+            duration=fusion.estimated_duration or 15,
+            image_analysis="（沿用原图片分析）",
+            intent_result=self._intent_text(intent),
+        )
+        user = (
+            f"{user}\n\n原文案：\n{self._fusion_text(fusion)}\n\n"
+            f"审核发现的问题：\n{issue_text}\n\n修改建议：\n{suggestion_text or '（无）'}\n"
+            "请输出修正后的完整文案。"
+        )
+        system = render_system_prompt(template, **system_kwargs)
+        raw = self.client.chat_completion(
+            [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            temperature=0.5,
+            max_tokens=2048,
+            timeout=25,
+        )
+        if not raw:
+            return self._rule_fix(fusion, review)
+        rewritten = CopyGenerator._parse_fusion(CopyGenerator(self.client), raw)
+        if not rewritten.title and not rewritten.script_segments:
+            return self._rule_fix(fusion, review)
+        # 保底：personal_brands 必须保留
+        full = self._fusion_text(rewritten)
+        for brand in intent.personal_brands:
+            if brand.text and brand.text not in full:
+                rewritten.cta = (rewritten.cta + brand.text).strip()
+        return rewritten
+
+    def _rule_fix(self, fusion: FusionResult, review: ReviewResult) -> FusionResult:
+        """LLM 重写不可用时的本地兜底：删除/替换明显违规表述。"""
+        replacements = [
+            (re.compile(r"100\s*%|百分百"), "大部分"),
+            (re.compile(r"绝对(有效|安全|靠谱)"), "比较\\1"),
+            (re.compile(r"包治百病"), "适用多种情况"),
+            (re.compile(r"立刻见效"), "坚持使用会有改善"),
+            (re.compile(r"一喷(就|全|100%)"), "喷上等一会儿可以"),
+            (re.compile(r"家人们谁懂啊|绝绝子|宝子们|yyds", re.IGNORECASE), ""),
+            (re.compile(r"最好|最强|最牛|最便宜"), "很不错"),
+        ]
+
+        def fix(text: str) -> str:
+            for pattern, repl in replacements:
+                text = pattern.sub(repl, text)
+            return text
+
+        fusion.title = fix(fusion.title)
+        fusion.hook = fix(fusion.hook)
+        fusion.cta = fix(fusion.cta)
+        for point in fusion.body_points:
+            point.text = fix(point.text)
+            point.elaboration = fix(point.elaboration)
+        for segment in fusion.script_segments:
+            segment.text = fix(segment.text)
+        fusion.raw = ""
+        return fusion
+
+    # ── 文本工具 ────────────────────────────────────────────────────────
+    @staticmethod
+    def _segments(fusion: FusionResult):
+        yield "title", fusion.title
+        yield "hook", fusion.hook
+        for point in fusion.body_points:
+            yield "body_points", f"{point.text} {point.elaboration}"
+        yield "cta", fusion.cta
+        for segment in fusion.script_segments:
+            yield "script_segments", segment.text
+
+    @staticmethod
+    def _fusion_text(fusion: FusionResult) -> str:
+        parts = [fusion.title, fusion.hook]
+        parts += [p.text for p in fusion.body_points]
+        parts += [s.text for s in fusion.script_segments]
+        parts.append(fusion.cta)
+        return "\n".join(p for p in parts if p)
+
+    @staticmethod
+    def _intent_text(intent) -> str:
+        if intent is None:
+            return "无意图信息"
+        parts = [f"意图：{intent.intent_summary}"]
+        parts += [f"核心信息[must_keep={m.must_keep}]：{m.text}" for m in intent.core_messages]
+        parts += [f"事实（{b.category}）：{b.text}" for b in intent.personal_brands]
+        return "\n".join(parts)

packages/application/viral_video/schemas.py

@@ -0,0 +1,116 @@
+"""内部 Pydantic 校验模型（不暴露给运营，运营只看 DB 里的纯文本）。"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class ProductItem(BaseModel):
+    name: str = "无法判断"
+    features: str = "无法判断"
+    position: str = "secondary"
+    image_index: int = 0
+
+
+class ColorItem(BaseModel):
+    hex: str = "#000000"
+    name: str = "无法判断"
+    coverage: float = 0.0
+
+
+class TextItem(BaseModel):
+    text: str = ""
+    position: str = ""
+
+
+class ImageAnalysis(BaseModel):
+    products: list[ProductItem] = Field(default_factory=list)
+    colors: list[ColorItem] = Field(default_factory=list)
+    has_person: bool = False
+    person_count: int = 0
+    people: dict[str, str] = Field(default_factory=dict)
+    mood: str = ""
+    visible_text: list[TextItem] = Field(default_factory=list)
+    scene: str = ""
+    quality: dict[str, str] = Field(default_factory=dict)
+    key_selling_points: list[str] = Field(default_factory=list)
+    raw: str = ""
+
+
+class CoreMessage(BaseModel):
+    text: str
+    must_keep: bool = False
+    confidence: float = 0.0
+
+
+class PersonalBrand(BaseModel):
+    text: str
+    category: str = "brand"
+
+
+class IntentResult(BaseModel):
+    intent_summary: str = ""
+    core_messages: list[CoreMessage] = Field(default_factory=list)
+    personal_brands: list[PersonalBrand] = Field(default_factory=list)
+    emotion_tone: str = ""
+    missing_info: list[str] = Field(default_factory=list)
+    raw: str = ""
+
+
+class BodyPoint(BaseModel):
+    text: str
+    elaboration: str = ""
+    image_index: int = 0
+
+
+class ScriptSegment(BaseModel):
+    text: str
+    duration_sec: float = 0
+    image_index: int = 0
+
+
+class FusionResult(BaseModel):
+    title: str = ""
+    hook: str = ""
+    body_points: list[BodyPoint] = Field(default_factory=list)
+    cta: str = ""
+    script_segments: list[ScriptSegment] = Field(default_factory=list)
+    word_count: int = 0
+    estimated_duration: int = 0
+    raw: str = ""
+
+
+class KenBurns(BaseModel):
+    start: str = "0,0"
+    end: str = "0,0"
+    ease: str = "linear"
+
+
+class Clip(BaseModel):
+    image_index: int = 0
+    transition: str = "cut"
+    zoom: str | None = None
+    duration_sec: float = 0
+    bgm_note: str = ""
+    voice_text: str = ""
+    subtitle_text: str = ""
+    ken_burns: KenBurns = Field(default_factory=KenBurns)
+
+
+class Storyboard(BaseModel):
+    clips: list[Clip] = Field(default_factory=list)
+    raw: str = ""
+
+
+class ReviewIssue(BaseModel):
+    dimension: str
+    severity: str = "warning"
+    location: str = ""
+    text: str = ""
+
+
+class ReviewResult(BaseModel):
+    passed: bool = True
+    issues: list[ReviewIssue] = Field(default_factory=list)
+    rewrite_suggestions: list[str] = Field(default_factory=list)
+    raw: str = ""

packages/application/viral_video/xml_parser.py

@@ -0,0 +1,104 @@
+"""XML 标签式输出解析器（替代 json.loads）。
+
+LLM 按 ``<tag attr="x">内容</tag>`` 输出，本模块解析，解析失败不抛异常，
+由调用方走规则 fallback。采用栈式扫描，嵌套标签全部可提取（内外层都保留）。
+"""
+
+from __future__ import annotations
+
+import re
+from html import unescape
+from typing import Optional
+
+_OPEN_RE = re.compile(r"<(?P<tag>[\w-]+)(?P<attrs>(?:\s(?:[^>]*?\S)?)?)(?P<self>/?)>")
+_CLOSE_RE = re.compile(r"</(?P<tag>[\w-]+)\s*>")
+_ATTR_RE = re.compile(r"""([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')""")
+
+
+def parse_attributes(raw: str) -> dict[str, str]:
+    """解析标签属性字符串。"""
+    attrs: dict[str, str] = {}
+    for match in _ATTR_RE.finditer(raw or ""):
+        value = match.group(2) if match.group(2) is not None else match.group(3)
+        attrs[match.group(1)] = value
+    return attrs
+
+
+def parse_tags(text: Optional[str]) -> list[dict]:
+    """提取全部标签（含嵌套内外层），返回 [{tag, attrs, text}]，按开标签出现顺序。"""
+    if not text:
+        return []
+    results: list[dict] = []
+    stack: list[dict] = []
+    token_re = re.compile(r"<[^>]+>")
+    for token in token_re.finditer(text):
+        raw_token = token.group(0)
+        # 先按开/闭标签匹配
+        open_match = _OPEN_RE.match(raw_token)
+        close_match = _CLOSE_RE.match(raw_token)
+        is_close_tag = raw_token.startswith("</")
+        if not is_close_tag and open_match:
+            is_self_close = open_match.group("self") == "/"
+            node = {
+                "tag": open_match.group("tag"),
+                "attrs": parse_attributes(open_match.group("attrs")),
+                "text": "",
+                "_start": token.end(),
+            }
+            if is_self_close:
+                node.pop("_start")
+                results.append(node)
+            else:
+                stack.append(node)
+                results.append(node)
+        elif is_close_tag and close_match:
+            tag = close_match.group("tag")
+            # 弹出到最近同名开标签
+            for idx in range(len(stack) - 1, -1, -1):
+                if stack[idx]["tag"] == tag:
+                    node = stack[idx]
+                    node["text"] = unescape(text[node["_start"] : token.start()].strip())
+                    node.pop("_start", None)
+                    del stack[idx:]
+                    break
+    # 未闭合标签：给剩余部分作为文本
+    for node in stack:
+        if "_start" in node:
+            node["text"] = unescape(text[node["_start"] :].strip())
+            node.pop("_start", None)
+    return results
+
+
+def find_all(text: Optional[str], tag: str) -> list[dict]:
+    """提取指定标签的全部节点。"""
+    return [n for n in parse_tags(text) if n["tag"] == tag]
+
+
+def find_first(text: Optional[str], tag: str) -> Optional[dict]:
+    nodes = find_all(text, tag)
+    return nodes[0] if nodes else None
+
+
+def text_of(text: Optional[str], tag: str, default: str = "") -> str:
+    node = find_first(text, tag)
+    return node["text"] if node else default
+
+
+def attr_bool(value: Optional[str], default: bool = False) -> bool:
+    if value is None:
+        return default
+    return value.strip().lower() in {"true", "1", "yes", "是"}
+
+
+def attr_float(value: Optional[str], default: float = 0.0) -> float:
+    try:
+        return float(value) if value is not None and value.strip() else default
+    except (TypeError, ValueError):
+        return default
+
+
+def attr_int(value: Optional[str], default: int = 0) -> int:
+    try:
+        return int(float(value)) if value is not None and value.strip() else default
+    except (TypeError, ValueError):
+        return default

packages/config/base.py

@@ -80,31 +80,46 @@ class SharedSettings(BaseSettings):
 
     # ── CosyVoice (阿里云百炼语音合成) ───────────────────────────────────
     cosyvoice_api_key: str = ""
-    cosyvoice_base_url: str = "https://dashscope.aliyuncs.com/api/v1"
-    cosyvoice_model: str = "cosyvoice-v3-flash"
-    cosyvoice_voice: str = "longxiaochun_v3"  # 默认音色（v3 系列系统音色带 _v3 后缀）
+    cosyvoice_base_url: str = ""
+    cosyvoice_model: str = ""
+    cosyvoice_voice: str = "longxiaochun_v3"
     cosyvoice_sample_rate: int = 22050
-    cosyvoice_format: str = "mp3"  # 输出格式：mp3/wav/pcm
+    cosyvoice_format: str = "mp3"
     # 音色克隆模型名（固定为 voice-enrollment）
-    cosyvoice_clone_model: str = "voice-enrollment"
+    cosyvoice_clone_model: str = ""
 
     # ── 豆包大模型（火山引擎方舟） ────────────────────────────────────────
+    # AI模型路由化：model/base_url 默认值清空，由 DB ai_models/ai_capability_configs 配置驱动。
+    # 环境变量仍可覆盖（兼容旧部署）；无任何配置时 ai_router fallback 提供最终默认值。
     doubao_api_key: str = ""
-    doubao_model: str = "doubao-seed-1-6-250615"
-    doubao_base_url: str = "https://ark.cn-beijing.volces.com/api/v3"
-    doubao_timeout: int = 30
-    doubao_max_retries: int = 2
-    doubao_vision_model: str = "doubao-1-5-vision-pro-250915"
-    doubao_embedding_model: str = "doubao-embedding-large-text-240915"
-    doubao_video_model: str = "doubao-seedance-2-5-260628"
-    doubao_video_timeout: int = 600  # 视频生成轮询总超时（秒）
-    doubao_video_poll_interval: int = 10  # 轮询间隔（秒）
+    doubao_model: str = ""
+    doubao_fast_model: str = ""
+    doubao_base_url: str = ""
+    doubao_timeout: int = 45
+    doubao_max_retries: int = 3
+    doubao_vision_model: str = ""
+    doubao_vision_lite_model: str = ""
+    doubao_vision_use_lite: bool = True
+    doubao_embedding_model: str = ""
+    doubao_video_model: str = ""
+    doubao_video_timeout: int = 600
+    doubao_video_poll_interval: int = 10
+    doubao_image_model: str = ""
+    doubao_image_size: str = "1K"
+    doubao_image_timeout: int = 60
+    doubao_trust_chain_enabled: bool = True
+
+    # ── DashScope (阿里云百炼 Wan 3.0 等) ─────────────────────────────────
+    dashscope_api_key: str = ""
+    dashscope_base_url: str = ""
+    dashscope_video_timeout: int = 900
+    dashscope_video_poll_interval: int = 10
 
     # ── MediaKit (火山引擎 AI 媒体工具) ──────────────────────────────────
     mediakit_api_key: str = ""
-    mediakit_base_url: str = "https://mediakit.cn-beijing.volces.com/api/v1"
+    mediakit_base_url: str = ""
     mediakit_timeout: int = 60
-    mediakit_cover_enabled: bool = False  # 封面抽帧是否走MediaKit(默认false走本地ffmpeg+cv2，<2s完成)
+    mediakit_cover_enabled: bool = False
 
     # ── 积分/会员系统 (#1895) ────────────────────────────────────────────
     # 积分系统总开关（产品要求 #1895：暂停积分系统但保留全部代码/表/接口）。

packages/domain/entities.py

@@ -60,6 +60,11 @@ class User:
     # 资料是否已完善（微信新用户首次设置昵称后置 True；邮箱注册默认 True）
     profile_completed: bool = True
 
+    # 会员字段 (#1895)：与 users 表列对应
+    is_member: bool = False
+    member_type: str | None = None
+    member_expires_at: datetime | None = None
+
     created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
 
 

packages/domain/feature_pricing_service.py

@@ -0,0 +1,376 @@
+"""功能计费配置服务：从 feature_pricing_configs 读配置，300 秒 TTL 内存缓存。
+
+配置表由 xiaoxia-admin 侧维护（同库 PostgreSQL），本服务只读。
+DB 不可用 / 表不存在 / 无数据时自动回落到内置兜底配置，保证业务不崩。
+
+计费公式：最终积分 = (动态成本 + 固定成本) × 利润系数，price_cap 封顶。
+启用条件：全局 points_enabled 总开关 AND 功能 is_enabled 同时为 true。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+import sqlalchemy as sa
+
+from packages.adapters.sqlalchemy_impl import session as _session_mod
+
+logger = logging.getLogger(__name__)
+
+CACHE_TTL_SECONDS = 300.0
+
+# ── 爆款视频兜底模型单价（与旧硬编码表/现状一致；DB 不可用时使用） ───────
+# 结构：models[model_key][resolution]["true"/"false"] = 单价
+# token 模式：元/百万输出 tokens；per_second 模式：元/秒
+# 注意：仅 seedance-2.5 配置 true（图生视频）单价；其余模型只有 false，
+# 精确 key 缺失时由 points_rules 回落到 seedance-2.5/false（与旧现状一致）。
+_FALLBACK_VIRAL_MODEL_PRICING: dict = {
+    "seedance-2.5": {
+        "480p": {"false": 70.0, "true": 42.0},
+        "720p": {"false": 70.0, "true": 42.0},
+        "1080p": {"false": 77.0, "true": 46.0},
+    },
+    "seedance-2.0": {
+        "480p": {"false": 46.0},
+        "720p": {"false": 46.0},
+        "1080p": {"false": 51.0},
+        "4k": {"false": 80.0},
+    },
+    "seedance-2.0-fast": {
+        "480p": {"false": 28.0},
+        "720p": {"false": 28.0},
+    },
+    "seedance-2.0-mini": {
+        "480p": {"false": 9.2},
+        "720p": {"false": 9.2},
+    },
+    "wan-3.0": {
+        "480p": {"false": 0.3},
+        "720p": {"false": 0.6},
+        "1080p": {"false": 1.2},
+    },
+}
+
+
+@dataclass
+class FeatureConfig:
+    """功能计费配置快照。"""
+
+    feature_key: str
+    name: str = ""
+    emoji: str = ""
+    is_enabled: bool = False
+    fixed_cost: float = 0.0
+    profit_multiplier: float = 1.0
+    dynamic_unit_cost: float = 0.0
+    billing_mode: str = "model_based"
+    price_cap: float = 0.0
+    model_pricing: dict = field(default_factory=dict)
+    description: str = ""
+
+
+# ── 进程内缓存：(loaded_monotonic, {feature_key: FeatureConfig}) ──────────
+_lock = threading.Lock()
+_cache: Optional[tuple[float, dict[str, FeatureConfig]]] = None
+
+
+def _fallback_configs() -> dict[str, FeatureConfig]:
+    """内置兜底配置：爆款启用（与现状一致），其余两个关闭。"""
+    return {
+        "viral_video": FeatureConfig(
+            feature_key="viral_video",
+            name="爆款视频",
+            emoji="🎬",
+            is_enabled=True,
+            fixed_cost=0.15,
+            profit_multiplier=1.3,
+            dynamic_unit_cost=0.0,
+            billing_mode="model_based",
+            price_cap=0.0,
+            model_pricing=json.loads(json.dumps(_FALLBACK_VIRAL_MODEL_PRICING)),
+            description="爆款视频动态定价（兜底配置）",
+        ),
+        "lip_sync": FeatureConfig(
+            feature_key="lip_sync",
+            name="对口型",
+            emoji="🎙️",
+            is_enabled=False,
+            fixed_cost=0.0,
+            profit_multiplier=1.0,
+            dynamic_unit_cost=0.0,
+            billing_mode="per_second",
+            price_cap=0.0,
+            description="对口型计费（兜底配置，默认关闭）",
+        ),
+        "smart_edit": FeatureConfig(
+            feature_key="smart_edit",
+            name="智能剪辑",
+            emoji="✂️",
+            is_enabled=False,
+            fixed_cost=0.0,
+            profit_multiplier=1.0,
+            dynamic_unit_cost=0.0,
+            billing_mode="model_based",
+            price_cap=0.0,
+            description="智能剪辑固定价计费（兜底配置，默认关闭）",
+        ),
+    }
+
+
+_lazy_session = None
+
+
+def _get_session():
+    """优先用全局 SessionLocal（worker）；否则按应用配置懒建同步引擎（api）。"""
+    global _lazy_session
+    if _session_mod.SessionLocal is not None:
+        return _session_mod.SessionLocal()
+    if _lazy_session is not None:
+        return _lazy_session()
+    try:
+        from packages.config import get_shared_settings
+
+        url = str(get_shared_settings().database_url)
+    except Exception:  # noqa: BLE001
+        return None
+    if not url:
+        return None
+    url = url.replace("postgresql+asyncpg://", "postgresql+psycopg://")
+    if url.startswith("postgresql://"):
+        url = url.replace("postgresql://", "postgresql+psycopg://")
+    engine = sa.create_engine(url, pool_pre_ping=True, pool_size=2, max_overflow=2)
+    from sqlalchemy.orm import sessionmaker
+
+    _lazy_session = sessionmaker(bind=engine)
+    return _lazy_session()
+
+
+def _parse_model_pricing(raw) -> dict:
+    """解析 model_pricing_json（Text JSON），空/失败 → {}。"""
+    if raw is None:
+        return {}
+    if isinstance(raw, dict):
+        return raw
+    text = str(raw).strip()
+    if not text:
+        return {}
+    try:
+        data = json.loads(text)
+    except (ValueError, TypeError):
+        logger.warning("model_pricing_json 解析失败，按空配置处理: %r", text[:200])
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _to_float(value, default: float = 0.0) -> float:
+    try:
+        if value is None:
+            return default
+        return float(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _load_all() -> dict[str, FeatureConfig]:
+    """SELECT * FROM feature_pricing_configs，返回 {feature_key: FeatureConfig}。
+
+    表不存在 / DB 异常由调用方捕获并回落兜底配置。
+    """
+    session = None
+    try:
+        session = _get_session()
+        if session is None:
+            raise RuntimeError("no db session available")
+        sql = sa.text("""
+            SELECT feature_key, name, emoji, is_enabled, fixed_cost,
+                   profit_multiplier, dynamic_unit_cost, billing_mode,
+                   price_cap, model_pricing_json, description
+              FROM feature_pricing_configs
+            """)
+        rows = session.execute(sql).mappings().all()
+        configs: dict[str, FeatureConfig] = {}
+        for row in rows:
+            key = str(row["feature_key"] or "").strip()
+            if not key:
+                continue
+            configs[key] = FeatureConfig(
+                feature_key=key,
+                name=str(row["name"] or key),
+                emoji=str(row["emoji"] or ""),
+                is_enabled=bool(row["is_enabled"]),
+                fixed_cost=_to_float(row["fixed_cost"]),
+                profit_multiplier=_to_float(row["profit_multiplier"], 1.0),
+                dynamic_unit_cost=_to_float(row["dynamic_unit_cost"]),
+                billing_mode=str(row["billing_mode"] or "model_based"),
+                price_cap=_to_float(row["price_cap"]),
+                model_pricing=_parse_model_pricing(row["model_pricing_json"]),
+                description=str(row["description"] or ""),
+            )
+        return configs
+    finally:
+        if session is not None:
+            try:
+                session.close()
+            except Exception:  # noqa: BLE001
+                pass
+
+
+def _get_cache() -> dict[str, FeatureConfig]:
+    """TTL 内返回缓存，否则重新 load；DB 异常/表不存在时返回内置兜底配置。"""
+    global _cache
+    now = time.monotonic()
+    with _lock:
+        if _cache is not None and now - _cache[0] < CACHE_TTL_SECONDS:
+            return _cache[1]
+
+    try:
+        loaded = _load_all()
+    except Exception:  # noqa: BLE001 - 表不存在/DB 不可用时静默回落
+        logger.info("feature_pricing_configs 读取失败，使用内置兜底配置", exc_info=True)
+        return _fallback_configs()
+
+    # DB 可用但表为空：同样回落兜底（保证爆款现状不被改变）
+    if not loaded:
+        fallback = _fallback_configs()
+        with _lock:
+            _cache = (now, fallback)
+        return fallback
+
+    # 以兜底为底（DB 未配置的 feature_key 仍有兜底），DB 行覆盖
+    merged = _fallback_configs()
+    merged.update(loaded)
+    with _lock:
+        _cache = (now, merged)
+    return merged
+
+
+def get_feature_config(feature_key: str) -> Optional[FeatureConfig]:
+    """获取指定功能配置，未知 key 返回 None。"""
+    key = str(feature_key or "").strip()
+    if not key:
+        return None
+    return _get_cache().get(key)
+
+
+def _global_points_enabled() -> bool:
+    """全局积分总开关（兼容 api / worker 运行时），取不到时默认关闭。"""
+    try:
+        from packages.shared import get_shared_settings
+
+        return bool(get_shared_settings().points_enabled)
+    except Exception:  # noqa: BLE001
+        pass
+    try:
+        from app.config import settings
+
+        return bool(getattr(settings, "points_enabled", False))
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def is_feature_enabled(feature_key: str) -> bool:
+    """功能是否启用并扣费：全局 points_enabled AND 功能 is_enabled。"""
+    cfg = get_feature_config(feature_key)
+    if cfg is None:
+        return False
+    return bool(cfg.is_enabled) and _global_points_enabled()
+
+
+def calculate_price(feature_key: str, dynamic_cost: float = 0.0) -> tuple[float, dict]:
+    """按公式计算最终积分并返回明细。
+
+    price = (dynamic_cost + fixed_cost) × profit_multiplier
+    price_cap > 0 时封顶（取 min）。
+    功能未启用 → (0.0, breakdown{is_enabled: False, charged: False})。
+    """
+    cfg = get_feature_config(feature_key)
+    dynamic = max(0.0, _to_float(dynamic_cost))
+    if cfg is None or not cfg.is_enabled:
+        return 0.0, {
+            "feature_key": feature_key,
+            "is_enabled": False,
+            "charged": False,
+            "dynamic_cost": dynamic,
+            "fixed_cost": 0.0,
+            "profit_multiplier": 1.0,
+            "price_cap": 0.0,
+            "final_price": 0.0,
+        }
+
+    fixed = max(0.0, cfg.fixed_cost)
+    multiplier = cfg.profit_multiplier if cfg.profit_multiplier > 0 else 1.0
+    raw_price = (dynamic + fixed) * multiplier
+    cap = cfg.price_cap if cfg.price_cap and cfg.price_cap > 0 else 0.0
+    final_price = min(raw_price, cap) if cap else raw_price
+    final_price = round(float(final_price), 2)
+    breakdown = {
+        "feature_key": cfg.feature_key,
+        "is_enabled": True,
+        "charged": True,
+        "dynamic_cost": round(dynamic, 4),
+        "fixed_cost": float(fixed),
+        "profit_multiplier": float(multiplier),
+        "price_cap": float(cap),
+        "raw_price": round(float(raw_price), 4),
+        "final_price": final_price,
+    }
+    return final_price, breakdown
+
+
+def lookup_model_price(
+    model_pricing: dict,
+    model_key: str,
+    resolution: str,
+    has_video_input: bool,
+) -> Optional[float]:
+    """从 model_pricing dict 取模型单价，兼容两种常见 JSON 结构。
+
+    1. 嵌套：{model: {resolution: {"true"/"false": price}}}
+       （内层 bool key 也兼容直接 bool / 省略）
+    2. 扁平：{"model|resolution|true_or_false": price}
+       （分隔符支持 | / : / , / 空格；bool 段可省略）
+    取不到返回 None。
+    """
+    if not isinstance(model_pricing, dict):
+        return None
+    model = str(model_key or "").strip()
+    res = str(resolution or "").strip()
+    flag = "true" if has_video_input else "false"
+
+    # 1. 嵌套
+    model_node = model_pricing.get(model)
+    if isinstance(model_node, dict):
+        res_node = model_node.get(res)
+        if isinstance(res_node, dict):
+            # 精确 bool key 命中才返回；不做“只有一个值就取”的模糊匹配
+            # （否则缺失 true 时会错误地取到 false 价，破坏旧版回落规则）
+            if flag in res_node:
+                return _to_float(res_node[flag]) if res_node[flag] is not None else None
+            if has_video_input in res_node:
+                val = res_node[has_video_input]
+                return _to_float(val) if val is not None else None
+        elif isinstance(res_node, (int, float)):
+            return float(res_node)
+
+    # 2. 扁平
+    for sep in ("|", ":", ",", " "):
+        for key in (
+            f"{model}{sep}{res}{sep}{flag}",
+            f"{model}{sep}{res}",
+        ):
+            if key in model_pricing:
+                value = model_pricing[key]
+                return _to_float(value) if value is not None else None
+    return None
+
+
+def refresh_feature_configs() -> None:
+    """清空缓存（下次读取重新 load DB；测试/admin 改配置后可手动调）。"""
+    global _cache
+    with _lock:
+        _cache = None

packages/domain/points_account.py

@@ -9,9 +9,9 @@ from uuid import uuid4
 class PointsAccount:
     id: str
     user_id: str
-    balance: int = 0
-    total_earned: int = 0
-    total_spent: int = 0
+    balance: float = 0.0
+    total_earned: float = 0.0
+    total_spent: float = 0.0
     created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
     updated_at: datetime = field(default_factory=lambda: datetime.now(UTC))
 

packages/domain/points_rules.py

@@ -1,32 +1,384 @@
-"""积分消耗规则配置 (#1895)"""
+"""积分消耗规则配置 (#1895)
+
+v1.6.1: 按产品决策，智能混剪/AI数字人/AI配音/抖音解析/改写/标题/封面 全部免费，
+仅保留声音克隆合成（voice_clone_synth）的扣点逻辑；声音克隆训练保持免费。
+爆款视频（viral_video）走动态定价，计费参数 DB 化（feature_pricing_configs，
+见 feature_pricing_service），calculate_viral_video_credits 从配置读取单价/
+固定成本/利润系数/封顶，DB 不可用时回落兜底配置。
+"""
 
 from __future__ import annotations
 
 import math
 
+from packages.domain import feature_pricing_service
+
+# ============ 爆款视频动态定价 ============
+# 单价/固定成本/利润系数已 DB 化（feature_pricing_configs，feature_key=viral_video），
+# 由 feature_pricing_service 读取（300s 缓存），DB 不可用时回落内置兜底配置。
+# 以下三个常量仅为向后兼容保留（旧引用方/兜底场景），值取自兜底配置。
+VIRAL_VIDEO_MODEL_PRICES: dict[tuple[str, str, bool], float] = {
+    ("seedance-2.5", "480p", False): 70.0,
+    ("seedance-2.5", "720p", False): 70.0,
+    ("seedance-2.5", "1080p", False): 77.0,
+    ("seedance-2.5", "480p", True): 42.0,
+    ("seedance-2.5", "720p", True): 42.0,
+    ("seedance-2.5", "1080p", True): 46.0,
+    ("seedance-2.0", "480p", False): 46.0,
+    ("seedance-2.0", "720p", False): 46.0,
+    ("seedance-2.0", "1080p", False): 51.0,
+    ("seedance-2.0", "4k", False): 80.0,
+    ("seedance-2.0-fast", "480p", False): 28.0,
+    ("seedance-2.0-fast", "720p", False): 28.0,
+    ("seedance-2.0-mini", "480p", False): 9.2,
+    ("seedance-2.0-mini", "720p", False): 9.2,
+    ("wan-3.0", "480p", False): 0.3,
+    ("wan-3.0", "720p", False): 0.6,
+    ("wan-3.0", "1080p", False): 1.2,
+}
+
+# 固定成本（元）：VLM 分析 + LLM 文案 + TTS + OSS + 服务器（兜底默认值）
+VIRAL_VIDEO_FIXED_COST = 0.15
+# 利润系数（兜底默认值）
+VIRAL_VIDEO_PROFIT_MULTIPLIER = 1.3
+# Seedance 输出帧率
+VIRAL_VIDEO_FPS = 24
+
+# 分辨率别名映射 -> 标准 key
+_RESOLUTION_ALIASES: dict[str, str] = {
+    "480p": "480p",
+    "普清": "480p",
+    "default": "480p",
+    "low": "480p",
+    "sd": "480p",
+    "720p": "720p",
+    "高清": "720p",
+    "medium": "720p",
+    "hd": "720p",
+    "1080p": "1080p",
+    "超清": "1080p",
+    "high": "1080p",
+    "ultra": "1080p",
+    "全能": "1080p",
+    "fhd": "1080p",
+}
+# 分辨率 -> 短边像素数（p 值代表短边，不是 height）
+_RESOLUTION_SHORT_SIDE: dict[str, int] = {"480p": 480, "720p": 720, "1080p": 1080, "4k": 2160}
+_RESOLUTION_ALIASES["4k"] = "4k"
+_RESOLUTION_ALIASES["2160p"] = "4k"
+_RESOLUTION_ALIASES["uhd"] = "4k"
+
+
+def resolve_video_dimensions(resolution: str, ratio: str) -> tuple[int, int]:
+    """把 (resolution, ratio) 解析为 (width, height)。
+
+    resolution 数字代表短边像素数（480p/720p/1080p 等）：
+    - 横屏 16:9：短边是 height，width = short * 16/9
+    - 竖屏 9:16：短边是 width，height = short * 16/9
+    - 方屏 1:1：width = height = short
+    """
+    key = str(resolution or "").strip()
+    key_l = key.lower()
+    res_key = _RESOLUTION_ALIASES.get(key_l) or _RESOLUTION_ALIASES.get(key) or "720p"
+    short = _RESOLUTION_SHORT_SIDE.get(res_key, 720)
+    r = str(ratio or "").strip().lower()
+    if r == "16:9":
+        # 横屏：短边是 height，width 向上取整并对齐偶数
+        w = math.ceil(short * 16 / 9)
+        h = short
+    elif r == "1:1":
+        w, h = short, short
+    else:
+        # 9:16 竖屏（默认）：短边是 width，height 向上取整并对齐偶数
+        w = short
+        h = math.ceil(short * 16 / 9)
+    # 对齐到偶数（视频编码要求）
+    w = w + (w % 2)
+    h = h + (h % 2)
+    return int(w), int(h)
+
+
+# ── 爆款视频多模型元数据 (#2159) ──────────────────────────────────────
+VIRAL_VIDEO_MODEL_CONFIG: dict[str, dict] = {
+    "seedance-2.5": {
+        "key": "seedance-2.5",
+        "display_name": "Seedance 2.5 — 最新最强",
+        "model_id": "doubao-seedance-2-5-260628",
+        "provider": "doubao",
+        "supports_audio": True,
+        "supported_resolutions": ["480p", "720p", "1080p"],
+        "max_duration": 30,
+        "billing_mode": "token",
+        "is_default": True,
+    },
+    "seedance-2.0": {
+        "key": "seedance-2.0",
+        "display_name": "Seedance 2.0 — 正式首选",
+        "model_id": "doubao-seedance-2-0-260128",
+        "provider": "doubao",
+        "supports_audio": True,
+        "supported_resolutions": ["480p", "720p", "1080p", "4k"],
+        "max_duration": 15,
+        "billing_mode": "token",
+        "is_default": False,
+    },
+    "seedance-2.0-fast": {
+        "key": "seedance-2.0-fast",
+        "display_name": "Seedance 2.0 Fast — 快速低成本",
+        "model_id": "doubao-seedance-2-0-fast-260128",
+        "provider": "doubao",
+        "supports_audio": True,
+        "supported_resolutions": ["480p", "720p"],
+        "max_duration": 15,
+        "billing_mode": "token",
+        "is_default": False,
+    },
+    "seedance-2.0-mini": {
+        "key": "seedance-2.0-mini",
+        "display_name": "Seedance 2.0 Mini — 低成本测试",
+        "model_id": "doubao-seedance-2-0-mini-260615",
+        "provider": "doubao",
+        "supports_audio": True,
+        "supported_resolutions": ["480p", "720p"],
+        "max_duration": 15,
+        "billing_mode": "token",
+        "is_default": False,
+    },
+    "wan-3.0": {
+        "key": "wan-3.0",
+        "display_name": "Wan 3.0 — 通义万相（阿里云）",
+        "model_id": "wan3.0-video",
+        "provider": "dashscope",
+        "supports_audio": True,
+        "supported_resolutions": ["480p", "720p", "1080p"],
+        "max_duration": 30,
+        "billing_mode": "per_second",
+        "is_default": False,
+    },
+}
+
+
+def get_viral_video_model_config(model_key: str | None) -> dict:
+    """获取模型配置，未知 key 回落到默认 seedance-2.5。"""
+    key = (model_key or "").strip().lower()
+    if key and key in VIRAL_VIDEO_MODEL_CONFIG:
+        return VIRAL_VIDEO_MODEL_CONFIG[key]
+    return VIRAL_VIDEO_MODEL_CONFIG["seedance-2.5"]
+
+
+def list_viral_video_models(
+    include_placeholder: bool = False,
+    dashscope_available: bool = False,
+) -> list[dict]:
+    """返回前端可用的模型列表（供 GET /api/v1/viral-video/models 端点用）。"""
+    out: list[dict] = []
+    for _k, cfg in VIRAL_VIDEO_MODEL_CONFIG.items():
+        if cfg.get("_placeholder") and not include_placeholder:
+            continue
+        if cfg.get("provider") == "dashscope" and not dashscope_available:
+            continue
+        out.append(
+            {
+                "key": cfg["key"],
+                "display_name": cfg["display_name"],
+                "supports_audio": bool(cfg.get("supports_audio", True)),
+                "supported_resolutions": list(cfg.get("supported_resolutions", ["720p"])),
+                "max_duration": int(cfg.get("max_duration", 15)),
+                "billing_mode": cfg.get("billing_mode", "token"),
+                "is_default": bool(cfg.get("is_default", False)),
+            }
+        )
+    return out
+
+
+def _match_model_prefix(model: str | None) -> str:
+    """匹配 model key（支持全部内部别名，未知回落到 seedance-2.5）。
+
+    按 key 长度从长到短匹配，避免 "seedance-2.0-fast" 被 "seedance-2.0" 前缀命中。
+    """
+    mm = (model or "").strip().lower()
+    for k in sorted(VIRAL_VIDEO_MODEL_CONFIG.keys(), key=len, reverse=True):
+        if mm == k or mm.startswith(k):
+            return k
+    return "seedance-2.5"
+
+
+def _infer_resolution_key(width: int, height: int) -> str:
+    """从实际 (width, height) 用短边推断 resolution key。"""
+    short = min(int(width or 720), int(height or 720))
+    if short >= 1900:
+        return "4k"
+    if short >= 1000:
+        return "1080p"
+    if short >= 650:
+        return "720p"
+    return "480p"
+
+
+def calculate_viral_video_credits_with_breakdown(
+    duration_seconds: int,
+    width: int,
+    height: int,
+    model: str = "seedance-2.5",
+    has_video_input: bool = False,
+    actual_tokens: int | None = None,
+    fps: int = VIRAL_VIDEO_FPS,
+) -> tuple[float, dict]:
+    """计算爆款视频所需积分（1 积分 = 1 元），并返回计费公式明细。
+
+    单价/固定成本/利润系数/封顶从 feature_pricing_configs（viral_video）读取；
+    DB 不可用时回落与现状一致的内置兜底配置。
+
+    公式:
+        tokens = duration * width * height * fps / 1024
+        video_cost = tokens / 1_000_000 * model_token_price
+        total = round((video_cost + fixed_cost) * profit_multiplier, 2)
+        price_cap > 0 时封顶取 min
+    若传入 actual_tokens 则用它替代计算值。
+
+    Returns:
+        (credits, breakdown) 二元组：
+        - credits: 四舍五入保留两位小数的最终积分
+        - breakdown: dict，包含 tokens / video_cost / fixed_cost / profit_multiplier /
+          model_price / width / height / fps / feature_enabled / charged / price_cap
+          字段，便于前端展示计费明细。功能关闭时 credits=0、charged=False。
+    """
+    w = max(1, int(width or 1))
+    h = max(1, int(height or 1))
+    effective_fps = int(fps or VIRAL_VIDEO_FPS)
+
+    prefix = _match_model_prefix(model)
+    cfg = get_viral_video_model_config(prefix)
+    res_key = _infer_resolution_key(w, h)
+    billing = cfg.get("billing_mode", "token")
+    dur = max(1, int(duration_seconds or 15))
+
+    # ── 从 DB 配置（兜底内置）取计费参数 ──
+    feature_cfg = feature_pricing_service.get_feature_config("viral_video")
+    # 注意：此处 feature_enabled 只表示“功能自身开关”，不并入全局 points_enabled
+    # 总开关（保持与旧版计费函数行为一致：价格照常计算）。全局总开关由业务层
+    # （route/worker）通过 feature_pricing_service.is_feature_enabled 统一把关。
+    feature_enabled = bool(feature_cfg.is_enabled) if feature_cfg is not None else True
+    model_pricing = feature_cfg.model_pricing if feature_cfg is not None else {}
+    fixed_cost = float(feature_cfg.fixed_cost) if feature_cfg is not None else float(VIRAL_VIDEO_FIXED_COST)
+    multiplier = (
+        float(feature_cfg.profit_multiplier)
+        if feature_cfg is not None and feature_cfg.profit_multiplier > 0
+        else float(VIRAL_VIDEO_PROFIT_MULTIPLIER)
+    )
+    price_cap = float(feature_cfg.price_cap) if feature_cfg is not None else 0.0
+
+    # 单价：优先配置 dict；复刻旧版回落规则——精确 key 取不到时，回落
+    # seedance-2.5 同分辨率 False 单价；最终兜底 70.0。
+    price = feature_pricing_service.lookup_model_price(model_pricing, prefix, res_key, bool(has_video_input))
+    if price is None:
+        # 配置表未命中：先尝试配置里的 seedance-2.5/False
+        if prefix != "seedance-2.5" or bool(has_video_input):
+            price = feature_pricing_service.lookup_model_price(model_pricing, "seedance-2.5", res_key, False)
+    if price is None:
+        key = (prefix, res_key, bool(has_video_input))
+        price = VIRAL_VIDEO_MODEL_PRICES.get(key)
+    if price is None:
+        price = VIRAL_VIDEO_MODEL_PRICES.get(("seedance-2.5", res_key, False), 70.0)
+
+    if billing == "per_second":
+        tokens = 0.0
+        video_cost = dur * float(price)
+        billing_unit = "second"
+    else:
+        if actual_tokens is not None and actual_tokens > 0:
+            tokens = float(actual_tokens)
+        else:
+            tokens = dur * w * h * effective_fps / 1024.0
+        video_cost = tokens / 1_000_000.0 * float(price)
+        billing_unit = "token"
+
+    if not feature_enabled:
+        # 功能关闭（is_enabled=false 或全局 points 关闭）：不扣费，明细照旧返回
+        credits = 0.0
+        raw_total = (video_cost + fixed_cost) * multiplier
+        breakdown = {
+            "tokens": float(tokens),
+            "video_cost": float(video_cost),
+            "fixed_cost": float(fixed_cost),
+            "profit_multiplier": float(multiplier),
+            "price_cap": float(price_cap or 0.0),
+            "model_price": float(price),
+            "model_key": prefix,
+            "billing_mode": billing,
+            "billing_unit": billing_unit,
+            "width": int(w),
+            "height": int(h),
+            "fps": int(effective_fps),
+            "duration": dur,
+            "feature_enabled": False,
+            "charged": False,
+            "raw_price": round(float(raw_total), 4),
+        }
+        return credits, breakdown
+
+    total = (video_cost + fixed_cost) * multiplier
+    if price_cap and price_cap > 0:
+        total = min(total, price_cap)
+    credits = round(float(total), 2)
+    breakdown = {
+        "tokens": float(tokens),
+        "video_cost": float(video_cost),
+        "fixed_cost": float(fixed_cost),
+        "profit_multiplier": float(multiplier),
+        "price_cap": float(price_cap or 0.0),
+        "model_price": float(price),
+        "model_key": prefix,
+        "billing_mode": billing,
+        "billing_unit": billing_unit,
+        "width": int(w),
+        "height": int(h),
+        "fps": int(effective_fps),
+        "duration": dur,
+        "feature_enabled": True,
+        "charged": True,
+    }
+    return credits, breakdown
+
+
+def calculate_viral_video_credits(
+    duration_seconds: int,
+    width: int,
+    height: int,
+    model: str = "seedance-2.5",
+    has_video_input: bool = False,
+    actual_tokens: int | None = None,
+    fps: int = VIRAL_VIDEO_FPS,
+) -> float:
+    """计算爆款视频所需积分（1 积分 = 1 元），仅返回积分值（向后兼容包装器）。
+
+    内部调用 calculate_viral_video_credits_with_breakdown，仅返回 credits 部分，
+    保持旧调用方签名与返回值类型不变。
+
+    公式:
+        tokens = duration * width * height * fps / 1024
+        video_cost = tokens / 1_000_000 * model_token_price
+        total = round((video_cost + fixed_cost) * profit_multiplier, 2)
+    若传入 actual_tokens 则用它替代计算值。
+    """
+    credits, _ = calculate_viral_video_credits_with_breakdown(
+        duration_seconds=duration_seconds,
+        width=width,
+        height=height,
+        model=model,
+        has_video_input=has_video_input,
+        actual_tokens=actual_tokens,
+        fps=fps,
+    )
+    return credits
+
+
 # ============ 场景定义 ============
-# 每个场景: base_points(基础积分), unit(计费单位), name(显示名称)
+# 每个场景: base_points(基础积分), unit(计费单位), name(显示名称), dynamic(是否动态定价)
+# 说明：爆款视频（viral_video）走动态定价（预扣→结算多退少补），因此不使用 @points_gate
+# 装饰器，base_points=0，dynamic=True；前端展示场景列表时仍可看到。
 
 POINTS_SCENES: dict[str, dict] = {
-    "ai_voice": {
-        "base_points": 1,
-        "unit": "分钟",
-        "name": "AI 配音",
-        "description": "AI 配音每分钟消耗 1 积分（免费用户上浮 15%，会员 8~9 折）",
-    },
-    "ai_video": {
-        "base_points": 3,
-        "unit": "条",
-        "name": "智能混剪",
-        "extra_per_30s": 1,
-        "description": "智能混剪每条 3 积分起，视频超过 30 秒后每 30 秒加 1 积分；免费用户每日 2 条免费额度",
-    },
-    "ai_digital_human": {
-        "base_points": 15,
-        "unit": "分钟",
-        "name": "AI 数字人",
-        "description": "AI 数字人每分钟消耗 15 积分",
-    },
     "voice_clone_train": {
         "base_points": 0,
         "unit": "次",
@@ -39,23 +391,16 @@ POINTS_SCENES: dict[str, dict] = {
         "name": "声音克隆合成",
         "description": "克隆音色合成每分钟消耗 1 积分",
     },
-    "douyin_extract": {
-        "base_points": 1,
+    "viral_video": {
+        "base_points": 0,
         "unit": "次",
-        "name": "抖音链接提取",
-        "description": "抖音文案提取每次 1 积分",
+        "name": "爆款视频",
+        "dynamic": True,
+        "description": "爆款视频动态定价（按视频时长/分辨率/模型计算，预扣→结算多退少补）",
     },
-    "ai_rewrite": {"base_points": 1, "unit": "次", "name": "AI 改写文案", "description": "AI 改写文案每次 1 积分"},
-    "ai_title": {
-        "base_points": 1,
-        "unit": "次",
-        "name": "AI 标题生成",
-        "description": "AI 生成标题每次 1 积分（免费用户实际上浮后 2 积分/次）",
-    },
-    "ai_cover": {"base_points": 1, "unit": "张", "name": "AI 封面生成", "description": "AI 封面生成每张 1 积分"},
 }
 
-# 免费用户积分消耗上浮系数
+# 免费用户积分消耗上浮系数（仅对 voice_clone_synth 生效）
 FREE_USER_MULTIPLIER = 1.15
 
 # ============ 积分包定义 ============
@@ -81,9 +426,6 @@ MEMBER_DISCOUNT: dict[str, float] = {
     "yearly": 0.8,
 }
 
-# 每日免费混剪次数（免费用户）
-DAILY_FREE_CLIP_LIMIT = 2
-
 
 def calculate_points_cost(
     scene_key: str,
@@ -91,48 +433,45 @@ def calculate_points_cost(
     quantity: int = 1,
     duration_minutes: float = 0,
     member_type: str | None = None,
-) -> int:
+) -> float:
     """计算指定场景的积分消耗。
 
     Args:
-        scene_key: 场景标识，如 "ai_voice"、"ai_video"
+        scene_key: 场景标识（当前支持 voice_clone_train/voice_clone_synth/viral_video；
+                   viral_video 为动态定价场景，此处返回 0，由业务侧调用
+                   calculate_viral_video_credits 手动计算）
         is_member: 是否付费会员
         quantity: 数量（按次计费场景）
         duration_minutes: 时长分钟数（按时长计费场景）
         member_type: 会员类型 (monthly/quarterly/yearly)，用于折扣
 
     Returns:
-        实际消耗积分（已含免费用户 ×1.15 上浮或会员折扣）
-
-    Raises:
-        ValueError: 未知场景标识
+        实际消耗积分（float；已含免费用户 ×1.15 上浮或会员折扣）；免费/动态/已下线场景统一返回 0。
     """
     scene = POINTS_SCENES.get(scene_key)
     if not scene:
-        raise ValueError(f"Unknown points scene: {scene_key}")
+        # 已下线/未注册的场景统一返回 0（免费），保持向后兼容
+        return 0.0
+
+    # 动态定价场景（如 viral_video）由业务侧手动计算，这里统一返回 0
+    if scene.get("dynamic"):
+        return 0.0
 
     base = scene["base_points"]
     if base == 0:
-        return 0
+        return 0.0
 
-    # —— 计算基础消耗 ——
     unit = scene["unit"]
     if unit == "分钟":
         total_base = base * max(1, math.ceil(duration_minutes))
-    elif unit in ("条", "次", "张"):
+    elif unit in ("次", "张"):
         total_base = base * quantity
-        # 混剪特殊逻辑：视频超过 30s 后每 +30s 额外加 1 积分
-        if scene_key == "ai_video" and duration_minutes > 0.5:
-            extra_segments = math.ceil((duration_minutes * 60 - 30) / 30)
-            if extra_segments > 0:
-                total_base += scene.get("extra_per_30s", 1) * extra_segments
     else:
         total_base = base
 
-    # —— 会员折扣 / 免费用户上浮 ——
     if is_member and member_type and member_type in MEMBER_DISCOUNT:
         total_base = max(1, math.floor(total_base * MEMBER_DISCOUNT[member_type]))
     elif not is_member:
         total_base = math.ceil(total_base * FREE_USER_MULTIPLIER)
 
-    return total_base
+    return float(total_base)

packages/domain/points_service.py

@@ -13,7 +13,6 @@ from typing import Any
 from sqlalchemy.orm import Session
 
 from packages.domain.points_rules import (
-    DAILY_FREE_CLIP_LIMIT,
     POINTS_PACKAGES,
 )
 
@@ -84,7 +83,7 @@ class PointsService:
 
     # ──────────────── 余额检查 ────────────────
 
-    def check_balance(self, user_id: str, amount: int, db: Session) -> dict[str, Any]:
+    def check_balance(self, user_id: str, amount: float, db: Session) -> dict[str, Any]:
         """检查余额是否足够。"""
         account_data = self.get_or_create_account(user_id, db)
         balance = account_data["balance"]
@@ -100,7 +99,7 @@ class PointsService:
     def deduct_points(
         self,
         user_id: str,
-        amount: int,
+        amount: float,
         source: str,
         db: Session,
         description: str = "",
@@ -109,7 +108,7 @@ class PointsService:
         """扣减积分（事务性：SELECT FOR UPDATE → 检查余额 → 扣减 → 流水 → 同步用户表）。
 
         Returns:
-            {"success": True/False, "balance": int, "transaction_id": str|None}
+            {"success": True/False, "balance": float, "transaction_id": str|None}
         """
         PointsAccountModel, PointsTransactionModel, _, _, UserModel = _get_models()
 
@@ -173,7 +172,7 @@ class PointsService:
         except Exception:
             db.rollback()
             logger.exception(
-                "积分扣减失败: user_id=%s, amount=%d, source=%s",
+                "积分扣减失败: user_id=%s, amount=%.2f, source=%s",
                 user_id,
                 amount,
                 source,
@@ -185,7 +184,7 @@ class PointsService:
     def add_points(
         self,
         user_id: str,
-        amount: int,
+        amount: float,
         source: str,
         db: Session,
         description: str = "",
@@ -242,7 +241,7 @@ class PointsService:
         except Exception:
             db.rollback()
             logger.exception(
-                "积分增加失败: user_id=%s, amount=%d, source=%s",
+                "积分增加失败: user_id=%s, amount=%.2f, source=%s",
                 user_id,
                 amount,
                 source,
@@ -254,7 +253,7 @@ class PointsService:
     def refund_points(
         self,
         user_id: str,
-        amount: int,
+        amount: float,
         source: str,
         db: Session,
         ref_id: str = "",
@@ -270,6 +269,92 @@ class PointsService:
             ref_id=ref_id,
         )
 
+    # ──────────────── 爆款视频（viral_video）动态定价 ────────────────
+
+    def deduct_viral_video(self, user_id: str, credits: float, job_id: str, db: Session) -> dict[str, Any]:
+        """爆款视频预扣积分（confirm-copy 阶段）。"""
+        return self.deduct_points(
+            user_id=user_id,
+            amount=float(credits or 0),
+            source="viral_video",
+            db=db,
+            description="爆款视频生成",
+            ref_id=job_id,
+        )
+
+    def settle_viral_video(
+        self,
+        user_id: str,
+        estimated: float,
+        actual: float,
+        txn_id: str,
+        db: Session,
+    ) -> dict[str, Any]:
+        """爆款视频完成后按实际 tokens 结算（多退少补）。
+
+        - actual < estimated: 退差额
+        - actual > estimated: 补扣差额（余额不足时记 warning，不阻塞完成）
+        - |diff| < 0.01: 不动
+        """
+        diff = round(float(actual or 0) - float(estimated or 0), 2)
+        if abs(diff) < 0.01:
+            return {"success": True, "action": "none", "diff": 0.0}
+        if diff < 0:
+            refund = round(-diff, 2)
+            try:
+                res = self.refund_points(
+                    user_id=user_id,
+                    amount=refund,
+                    source="viral_video",
+                    db=db,
+                    ref_id=txn_id,
+                    description="爆款视频结算退费",
+                )
+                return {"success": bool(res.get("success")), "action": "refund", "diff": -refund, "amount": refund}
+            except Exception:
+                logger.exception("[viral_video] 结算退费异常 user_id=%s refund=%.2f", user_id, refund)
+                return {"success": False, "action": "refund", "diff": -refund}
+        else:
+            extra = round(diff, 2)
+            try:
+                res = self.deduct_points(
+                    user_id=user_id,
+                    amount=extra,
+                    source="viral_video",
+                    db=db,
+                    description="爆款视频结算补扣",
+                    ref_id=txn_id,
+                )
+                if not res.get("success"):
+                    logger.warning(
+                        "[viral_video] 结算补扣余额不足 user_id=%s extra=%.2f balance=%s (不阻塞任务完成)",
+                        user_id,
+                        extra,
+                        res.get("balance"),
+                    )
+                return {"success": bool(res.get("success")), "action": "deduct", "diff": extra, "amount": extra}
+            except Exception:
+                logger.exception("[viral_video] 结算补扣异常 user_id=%s extra=%.2f", user_id, extra)
+                return {"success": False, "action": "deduct", "diff": extra}
+
+    def refund_viral_video(self, user_id: str, credits: float, txn_id: str, db: Session) -> dict[str, Any]:
+        """爆款视频失败全额退款。"""
+        amount = float(credits or 0)
+        if amount <= 0:
+            return {"success": True, "action": "none", "amount": 0.0}
+        try:
+            return self.refund_points(
+                user_id=user_id,
+                amount=amount,
+                source="viral_video",
+                db=db,
+                ref_id=txn_id,
+                description="爆款视频失败退款",
+            )
+        except Exception:
+            logger.exception("[viral_video] 失败退款异常 user_id=%s amount=%.2f", user_id, amount)
+            return {"success": False, "action": "refund", "amount": amount}
+
     # ──────────────── 流水查询 ────────────────
 
     def get_transactions(
@@ -324,132 +409,16 @@ class PointsService:
             "page_size": page_size,
         }
 
-    # ──────────────── 每日免费混剪额度 ────────────────
-
-    def _daily_key(self, user_id: str) -> str:
-        """生成 Redis 每日额度 key。格式: daily_usage:{user_id}:{YYYYMMDD}:free_clip"""
-        today = datetime.now(UTC).strftime("%Y%m%d")
-        return f"daily_usage:{user_id}:{today}:free_clip"
-
-    def check_daily_free_clip(self, user_id: str, db: Session) -> bool:
-        """检查今日是否还有免费混剪额度。
-
-        优先查 Redis，Redis 不可用时降级到 DB。
-        """
-        redis_client = _get_redis_client()
-        if redis_client:
-            try:
-                key = self._daily_key(user_id)
-                current = redis_client.get(key)
-                if current is None:
-                    return True
-                return int(current) < DAILY_FREE_CLIP_LIMIT
-            except Exception:
-                logger.warning("Redis 不可用，降级到 DB 查询每日额度")
-
-        # 降级到 DB
-        _, _, _, DailyUsageRecordModel, _ = _get_models()
-        today_start = datetime.now(UTC).replace(hour=0, minute=0, second=0, microsecond=0)
-        record = (
-            db.query(DailyUsageRecordModel)
-            .filter(
-                DailyUsageRecordModel.user_id == user_id,
-                DailyUsageRecordModel.usage_type == "free_clip",
-                DailyUsageRecordModel.usage_date >= today_start,
-            )
-            .first()
-        )
-        if record is None:
-            return True
-        return record.count < DAILY_FREE_CLIP_LIMIT
-
-    def record_daily_free_clip(self, user_id: str, db: Session) -> bool:
-        """记录使用一次免费混剪。
-
-        先 INCR Redis；如果超限回退 Redis。DB 使用 upsert 语义（唯一约束）。
-        """
-        redis_client = _get_redis_client()
-        if redis_client:
-            try:
-                key = self._daily_key(user_id)
-                new_count = redis_client.incr(key)
-                if new_count == 1:
-                    redis_client.expire(key, 48 * 3600)  # TTL 48h
-                if new_count <= DAILY_FREE_CLIP_LIMIT:
-                    return True
-                # 超限，回退 Redis
-                redis_client.decr(key)
-            except Exception:
-                logger.warning("Redis 不可用，降级到 DB 记录每日额度")
-
-        # 降级/兜底到 DB（upsert 语义）
-        _, _, _, DailyUsageRecordModel, _ = _get_models()
-        today_start = datetime.now(UTC).replace(hour=0, minute=0, second=0, microsecond=0)
-
-        record = (
-            db.query(DailyUsageRecordModel)
-            .filter(
-                DailyUsageRecordModel.user_id == user_id,
-                DailyUsageRecordModel.usage_type == "free_clip",
-                DailyUsageRecordModel.usage_date >= today_start,
-            )
-            .first()
-        )
-
-        if record is None:
-            if DAILY_FREE_CLIP_LIMIT <= 0:
-                return False
-            record = DailyUsageRecordModel(
-                id=uuid.uuid4().hex,
-                user_id=user_id,
-                usage_type="free_clip",
-                usage_date=datetime.now(UTC),
-                count=1,
-            )
-            db.add(record)
-        else:
-            if record.count >= DAILY_FREE_CLIP_LIMIT:
-                return False
-            record.count += 1
-
-        db.commit()
-        return True
+    # ──────────────── 每日免费混剪额度（已下线：智能混剪全免费） ────────────────
 
     def get_daily_usage(self, user_id: str, db: Session) -> dict[str, Any]:
-        """查询今日免费额度使用情况。"""
-        redis_client = _get_redis_client()
-        used = 0
-
-        if redis_client:
-            try:
-                key = self._daily_key(user_id)
-                val = redis_client.get(key)
-                used = int(val) if val else 0
-            except Exception:
-                pass
-
-        if used == 0:
-            # 从 DB 查
-            _, _, _, DailyUsageRecordModel, _ = _get_models()
-            today_start = datetime.now(UTC).replace(hour=0, minute=0, second=0, microsecond=0)
-            record = (
-                db.query(DailyUsageRecordModel)
-                .filter(
-                    DailyUsageRecordModel.user_id == user_id,
-                    DailyUsageRecordModel.usage_type == "free_clip",
-                    DailyUsageRecordModel.usage_date >= today_start,
-                )
-                .first()
-            )
-            used = record.count if record else 0
-
+        """查询今日免费额度使用情况（智能混剪已全免费，返回 unlimited）。"""
         now = datetime.now(UTC)
         tomorrow = (now + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
-
         return {
-            "free_clips_used": used,
-            "free_clips_limit": DAILY_FREE_CLIP_LIMIT,
-            "free_clips_remaining": max(0, DAILY_FREE_CLIP_LIMIT - used),
+            "free_clips_used": 0,
+            "free_clips_limit": -1,  # -1 表示 unlimited
+            "free_clips_remaining": -1,
             "reset_at": tomorrow.isoformat(),
         }
 

packages/domain/viral_video.py

@@ -1,6 +1,7 @@
 """ViralVideoJob 领域模型 — 爆款视频任务.
 
-状态机（v1.5 三步分步）：
+v1.6 重大简化：Seedance 2.5 单次最长30秒，单次调用直接出片，不再分段/拼接/ffmpeg concat。
+状态机（三步分步）：
   pending -> running -> image_analyzed -> running -> copy_generated -> running -> completed
                                  wait_user_confirm -> running -> completed (旧路径兼容)
   任意阶段 fail; 任意非终态 cancel.
@@ -26,8 +27,6 @@ from uuid import uuid4
 
 
 class ViralVideoStatus(StrEnum):
-    """爆款视频任务状态枚举。"""
-
     PENDING = "pending"
     RUNNING = "running"
     IMAGE_ANALYZED = "image_analyzed"
@@ -39,98 +38,94 @@ class ViralVideoStatus(StrEnum):
 
 
 class ViralVideoStage(StrEnum):
-    """编排流水线阶段枚举（用于 WS 进度推送）。"""
-
     IMAGE_ANALYSIS = "image_analysis"
     VIDEO_ANALYSIS = "video_analysis"
     INTENT_PARSING = "intent_parsing"
-    COPY_FUSION = "copy_fusion"
-    STORYBOARD = "storyboard"
+    SCRIPT_GENERATION = "script_generation"  # v1.6: 编导分镜脚本（融合原 copy_fusion+storyboard+review）
     REVIEW = "review"
     TTS = "tts"
-    BGM_SELECT = "bgm_select"
-    RENDERING = "rendering"
-    MUSETALK = "musetalk"
+    RENDERING = "rendering"  # v1.6: 单次 Seedance 生成（BGM/音效/画面一次出片）
     UPLOADING = "uploading"
 
 
 class FusionLevel(StrEnum):
-    """文案融合级别。"""
-
     AI_FULL = "ai_full"
     AI_POLISH = "ai_polish"
     USER_PRIMARY = "user_primary"
 
 
 class StyleStrength(StrEnum):
-    """风格强度。"""
-
     LIGHT = "light"
     MEDIUM = "medium"
     STRICT = "strict"
 
 
 class PromptType(StrEnum):
-    """Prompt 模板类型（与 #2040 seed 对齐）。"""
-
     IMAGE_ANALYSIS = "image_analysis"
     INTENT_PARSING = "intent_parsing"
-    COPY_FUSION = "copy_fusion"
-    STORYBOARD = "storyboard"
+    SCRIPT_GENERATION = "script_generation"
     REVIEW = "review"
     VIDEO_STYLE_INTEGRATION = "video_style_integration"
     STYLE_CONSTRAINT = "style_constraint"
 
 
-CREDITS_VIRAL_VIDEO_COST = 50
-
 STAGE_LABELS = {
     ViralVideoStage.IMAGE_ANALYSIS: "图片分析",
     ViralVideoStage.VIDEO_ANALYSIS: "视频风格分析",
     ViralVideoStage.INTENT_PARSING: "意图解析",
-    ViralVideoStage.COPY_FUSION: "文案融合",
-    ViralVideoStage.STORYBOARD: "分镜脚本",
+    ViralVideoStage.SCRIPT_GENERATION: "编导脚本生成",
     ViralVideoStage.REVIEW: "合规审核",
     ViralVideoStage.TTS: "AI 配音",
-    ViralVideoStage.BGM_SELECT: "BGM 选择",
-    ViralVideoStage.RENDERING: "视频渲染",
-    ViralVideoStage.MUSETALK: "数字人口型",
+    ViralVideoStage.RENDERING: "视频生成",
     ViralVideoStage.UPLOADING: "上传发布",
 }
 
 
 @dataclass
 class ViralVideoJob:
-    """爆款视频任务领域实体。"""
+    """爆款视频任务领域实体（v1.6 单次 Seedance 出片版）。"""
 
     user_id: str
     images: list[str] = field(default_factory=list)
+    pre_trusted_images: list[str] | None = (
+        None  # #2172 信任链预热结果（Seedream AI 化后的 URL 列表），与 images 顺序对应
+    )
     industry: str = ""
     target_customer: str = ""
     persona_id: str = ""
     viral_structure: str = ""
     marketing_purpose: str = ""
     bgm_preference: str = ""
-    duration: int = 30
+    duration: int = 15  # v1.6: 默认15秒，上限30秒（Seedance 2.5 单次最大30s）
     user_copy_text: str = ""
     fusion_level: str = FusionLevel.AI_POLISH
     reference_audio_path: str = ""
-    # v1.3
     reference_video_url: str = ""
     style_strength: str = StyleStrength.MEDIUM
     style_guide: dict | None = None
     style_template_id: str = ""
-    # v1.4 图片分析结果（run_pipeline 持久化，resume 时读取给文案/分镜）
+    # v1.5.1 音频/视频参数
+    voice_id: str = ""
+    voice_source: str = ""
+    video_ratio: str = "9:16"
+    video_model: str = ""
+    # v1.4+ 产物
     image_analysis: dict | None = None
-    # v1.5 三步分步流水线产物（持久化，供前端 GET 读取 + resume 消费）
-    storyboard: list | None = None
-    generated_copy_text: str = ""
+    intent_result: dict | None = None
+    generated_copy_text: str = ""  # v1.6: 存 voiceover_script（纯口播对白），字段名兼容
+    storyboard: list | None = None  # v1.6: 存 copy_result.shots，字段名兼容
+    copy_result: dict | None = None  # v1.6: 完整编导脚本结构
     # 状态
     id: str = field(default_factory=lambda: uuid4().hex)
     status: ViralVideoStatus = ViralVideoStatus.PENDING
-    intent_result: dict | None = None
+    current_stage: str = ""  # 细粒度阶段（ViralVideoStage.value，snake_case）
+    phase_message: str = ""  # 阶段中文提示文案，前端轮询直接展示
+    heartbeat_at: datetime | None = None  # worker 心跳时间，用于超时僵尸任务检测
     result_video_url: str = ""
-    credits_cost: int = 0
+    video_resolution: str = "720p"
+    credits_prepaid: float = 0.0
+    credits_transaction_id: str = ""
+    credits_cost: float = 0.0
     error_msg: str = ""
     retry_count: int = 0
     started_at: datetime | None = None
@@ -150,12 +145,21 @@ class ViralVideoJob:
         ):
             raise ValueError(f"Cannot transition from {self.status} to running")
         self.status = ViralVideoStatus.RUNNING
+        now = datetime.now(timezone.utc)
         if self.started_at is None:
-            self.started_at = datetime.now(timezone.utc)
-        self.updated_at = datetime.now(timezone.utc)
+            self.started_at = now
+        self.heartbeat_at = now
+        self.updated_at = now
+
+    def touch_heartbeat(self) -> None:
+        """更新心跳时间（worker 在长任务中周期性调用，用于超时检测）。"""
+        now = datetime.now(timezone.utc)
+        if self.started_at is None:
+            self.started_at = now
+        self.heartbeat_at = now
+        self.updated_at = now
 
     def mark_image_analyzed(self) -> None:
-        """阶段1完成：图片/视频分析完成，等待用户填参数或直接触发阶段2。"""
         if self.status not in (ViralVideoStatus.PENDING, ViralVideoStatus.RUNNING):
             raise ValueError(f"Cannot transition from {self.status} to image_analyzed")
         self.status = ViralVideoStatus.IMAGE_ANALYZED
@@ -163,8 +167,8 @@ class ViralVideoJob:
             self.started_at = datetime.now(timezone.utc)
         self.updated_at = datetime.now(timezone.utc)
 
-    def mark_copy_generated(self, copy_text: str, storyboard: list) -> None:
-        """阶段2完成：文案+分镜+审核完成，等待用户编辑后确认。"""
+    def mark_copy_generated(self, copy_result: dict) -> None:
+        """v1.6 阶段2完成：编导脚本（含 voiceover_script/shots/硬约束/负面词）已生成。"""
         if self.status not in (
             ViralVideoStatus.IMAGE_ANALYZED,
             ViralVideoStatus.RUNNING,
@@ -172,12 +176,14 @@ class ViralVideoJob:
         ):
             raise ValueError(f"Cannot transition from {self.status} to copy_generated")
         self.status = ViralVideoStatus.COPY_GENERATED
-        self.generated_copy_text = copy_text or ""
-        self.storyboard = list(storyboard) if storyboard else []
+        self.copy_result = copy_result or {}
+        if isinstance(copy_result, dict):
+            self.generated_copy_text = copy_result.get("voiceover_script", "") or ""
+            shots = copy_result.get("shots") or []
+            self.storyboard = list(shots) if isinstance(shots, list) else []
         self.updated_at = datetime.now(timezone.utc)
 
     def mark_wait_user_confirm(self, intent_result: dict) -> None:
-        """旧流水线兼容：意图解析完成等待用户确认（老接口）。"""
         if self.status != ViralVideoStatus.RUNNING:
             raise ValueError(f"Cannot transition from {self.status} to wait_user_confirm")
         self.status = ViralVideoStatus.WAIT_USER_CONFIRM
@@ -185,31 +191,67 @@ class ViralVideoJob:
         self.updated_at = datetime.now(timezone.utc)
 
     def resume_from_image_analyzed(self, **kwargs) -> None:
-        """阶段1->阶段2：用户已填参数，开始跑文案/分镜。kwargs 覆盖参数字段。"""
-        if self.status not in (ViralVideoStatus.IMAGE_ANALYZED, ViralVideoStatus.PENDING):
+        """阶段2入口：允许从 IMAGE_ANALYZED/PENDING 首次进入，也允许从 COPY_GENERATED/COMPLETED/FAILED 重新生成文案。
+
+        重新生成时清空上一轮文案产物（copy_result/intent_result/storyboard/generated_copy_text），
+        并重置 completed_at/result_video_url/error_msg，确保前端轮询能看到新的阶段2进度。
+        """
+        _allowed = (
+            ViralVideoStatus.IMAGE_ANALYZED,
+            ViralVideoStatus.PENDING,
+            ViralVideoStatus.COPY_GENERATED,
+            ViralVideoStatus.COMPLETED,
+            ViralVideoStatus.FAILED,
+        )
+        if self.status not in _allowed:
             raise ValueError(f"Cannot resume from {self.status} to copy-gen")
+        _is_regen = self.status in (
+            ViralVideoStatus.COPY_GENERATED,
+            ViralVideoStatus.COMPLETED,
+            ViralVideoStatus.FAILED,
+        )
         for k, v in kwargs.items():
             if hasattr(self, k) and v not in (None, "", []):
                 setattr(self, k, v)
+        if _is_regen:
+            # 清空上一轮文案/视频产物，避免前端拿到旧数据
+            self.intent_result = None
+            self.copy_result = None
+            self.storyboard = None
+            self.generated_copy_text = ""
+            self.result_video_url = ""
+            self.current_stage = ""
+            self.phase_message = ""
+            self.error_msg = ""
+            self.completed_at = None
+            self.heartbeat_at = None
+        _now = datetime.now(timezone.utc)
+        self.started_at = _now
+        self.heartbeat_at = _now
         self.status = ViralVideoStatus.RUNNING
-        self.updated_at = datetime.now(timezone.utc)
+        self.updated_at = _now
 
     def resume_from_copy_generated(self, edited_copy: str | None = None) -> None:
-        """阶段2->阶段3：用户确认/编辑文案，开始跑渲染。"""
+        """阶段2->阶段3：用户确认/编辑口播文案，开始跑 TTS+单次Seedance渲染。"""
         if self.status != ViralVideoStatus.COPY_GENERATED:
             raise ValueError(f"Cannot resume from {self.status} to render")
-        if edited_copy:
-            self.user_copy_text = edited_copy
+        if edited_copy and isinstance(self.copy_result, dict):
+            self.copy_result = {**self.copy_result, "voiceover_script": edited_copy}
             self.generated_copy_text = edited_copy
+        _now = datetime.now(timezone.utc)
+        self.started_at = _now
+        self.heartbeat_at = _now
         self.status = ViralVideoStatus.RUNNING
-        self.updated_at = datetime.now(timezone.utc)
+        self.updated_at = _now
 
     def resume_from_confirm(self) -> None:
-        """旧流水线兼容：从 WAIT_USER_CONFIRM 恢复。"""
         if self.status != ViralVideoStatus.WAIT_USER_CONFIRM:
             raise ValueError(f"Cannot resume from {self.status}")
+        _now = datetime.now(timezone.utc)
+        self.started_at = _now
+        self.heartbeat_at = _now
         self.status = ViralVideoStatus.RUNNING
-        self.updated_at = datetime.now(timezone.utc)
+        self.updated_at = _now
 
     def mark_completed(self, video_url: str) -> None:
         self.status = ViralVideoStatus.COMPLETED
@@ -240,5 +282,11 @@ class ViralVideoJob:
 
     @property
     def effective_copy_text(self) -> str:
-        """渲染阶段使用的最终文案：用户编辑 > 生成文案 > 用户原始 > 占位。"""
-        return self.user_copy_text or self.generated_copy_text or "精选好物推荐"
+        """TTS 用的最终口播文案：优先 copy_result.voiceover_script，兼容老字段。"""
+        if isinstance(self.copy_result, dict) and self.copy_result.get("voiceover_script"):
+            return self.copy_result["voiceover_script"]
+        return self.generated_copy_text or self.user_copy_text or "你好，给大家推荐一款好物"
+
+    @property
+    def voiceover_script(self) -> str:
+        return self.effective_copy_text

packages/middleware/points_gate.py

@@ -185,19 +185,6 @@ def _execute_with_gate_impl(
     is_member = getattr(user, "is_member", False)
     member_type = getattr(user, "member_type", None)
 
-    if scene_key == "ai_video":
-        from packages.domain.points_service import PointsService
-
-        svc = PointsService()
-        if not is_member:
-            if svc.check_daily_free_clip(user.id, db):
-                svc.record_daily_free_clip(user.id, db)
-                kwargs["_points_deducted"] = 0
-                kwargs["_is_free_quota"] = True
-                if is_async:
-                    return _run_async_impl(func, args, _filter_kwargs_impl(func, kwargs))
-                return func(*args, **_filter_kwargs_impl(func, kwargs))
-
     if per_unit is not None:
         total_points = per_unit
     else:

packages/shared/ai_config_version.py

@@ -0,0 +1,62 @@
+"""AI 配置版本号管理 — Redis 通知机制.
+
+admin 后台修改 ai_models / ai_capability_configs 后调用 bump_version()，
+SaaS 端 AIRouter 每次取配置前比对版本号，变了才重新查 DB。
+
+Redis key: xiaoxia:ai_config:version = 时间戳字符串
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+_REDIS_KEY = "xiaoxia:ai_config:version"
+
+
+def _get_redis_client():
+    """获取 Redis 客户端（复用 Celery broker 连接）."""
+    try:
+        import redis as _redis
+
+        from packages.shared.config import get_shared_settings
+
+        settings = get_shared_settings()
+        redis_url = getattr(settings, "redis_url", None) or getattr(
+            settings, "celery_broker_url", "redis://localhost:6379/0"
+        )
+        return _redis.Redis.from_url(redis_url, decode_responses=True, socket_timeout=2)
+    except Exception as e:
+        logger.warning("AI config version: Redis 客户端初始化失败: %s", e)
+        return None
+
+
+def bump_version() -> str:
+    """写入新版本号（当前时间戳），返回版本号字符串。失败返回空串。"""
+    r = _get_redis_client()
+    if r is None:
+        logger.warning("AI config bump_version: Redis 不可用，跳过版本号更新")
+        return ""
+    try:
+        ver = str(int(time.time() * 1000))
+        r.set(_REDIS_KEY, ver)
+        logger.info("AI config version bumped to %s", ver)
+        return ver
+    except Exception as e:
+        logger.warning("AI config bump_version 失败: %s", e)
+        return ""
+
+
+def get_version() -> Optional[str]:
+    """读取当前版本号。Redis 不可用或异常返回 None。"""
+    r = _get_redis_client()
+    if r is None:
+        return None
+    try:
+        return r.get(_REDIS_KEY)
+    except Exception as e:
+        logger.warning("AI config get_version 失败: %s", e)
+        return None

packages/shared/ai_router.py

@@ -0,0 +1,516 @@
+"""AI 模型路由层 — 统一模型配置读取与客户端构建.
+
+业务代码通过 AIRouter 获取客户端，不再硬编码 model/api_key/base_url。
+配置来源：DB ai_capability_configs JOIN ai_models → Redis 版本号缓存 → SharedSettings fallback。
+
+使用方式：
+    from packages.shared.ai_router import ai_router
+
+    client = ai_router.get_llm_client("intent_parsing")
+    result = client.chat_completion(messages=[...])
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from dataclasses import dataclass
+
+from packages.shared.config import get_shared_settings
+
+logger = logging.getLogger(__name__)
+
+
+# ── 配置数据类 ──────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class ModelConfig:
+    """单个 AI 模型配置（来自 ai_models 表）"""
+
+    id: str
+    name: str
+    provider: str
+    model_key: str
+    api_key: str
+    api_base: str
+    api_version: str | None
+    status: str
+
+
+@dataclass(frozen=True)
+class CapabilityConfig:
+    """业务能力配置（来自 ai_capability_configs JOIN ai_models）"""
+
+    capability_key: str
+    capability_name: str
+    primary_model: ModelConfig | None
+    lite_model: ModelConfig | None
+    fallback_model: ModelConfig | None
+    timeout_seconds: int
+    max_retries: int
+    max_tokens: int | None
+    temperature: float | None
+    concurrency: int
+    extra_params: dict
+    is_enabled: bool
+
+
+# ── 简单包装类（TTS / ImageGen / VideoGen）──────────────────────────────────
+
+
+class TTSClient:
+    """TTS 客户端（简单配置持有者，实际调用由 CosyVoiceService 完成）"""
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,
+        base_url: str,
+        model: str,
+        timeout: int = 60,
+        extra_params: dict | None = None,
+    ):
+        self.provider = provider
+        self.api_key = api_key
+        self.base_url = base_url
+        self.model = model
+        self.timeout = timeout
+        self.extra_params = extra_params or {}
+
+    @property
+    def is_available(self) -> bool:
+        return bool(self.api_key and self.base_url and self.model)
+
+
+class ImageGenClient:
+    """图片生成客户端（简单配置持有者）"""
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,
+        base_url: str,
+        model: str,
+        timeout: int = 60,
+        extra_params: dict | None = None,
+    ):
+        self.provider = provider
+        self.api_key = api_key
+        self.base_url = base_url
+        self.model = model
+        self.timeout = timeout
+        self.extra_params = extra_params or {}
+
+    @property
+    def is_available(self) -> bool:
+        return bool(self.api_key and self.base_url and self.model)
+
+
+class VideoGenClient:
+    """视频生成客户端（简单配置持有者）"""
+
+    def __init__(
+        self,
+        provider: str,
+        api_key: str,
+        base_url: str,
+        model: str,
+        timeout: int = 600,
+        extra_params: dict | None = None,
+    ):
+        self.provider = provider
+        self.api_key = api_key
+        self.base_url = base_url
+        self.model = model
+        self.timeout = timeout
+        self.extra_params = extra_params or {}
+
+    @property
+    def is_available(self) -> bool:
+        return bool(self.api_key and self.base_url and self.model)
+
+
+# ── DB Session 获取 ─────────────────────────────────────────────────────────
+
+
+def _get_session():
+    """获取 DB session，兼容 api / worker / 独立脚本场景"""
+    from packages.adapters.sqlalchemy_impl.session import SessionLocal
+
+    if SessionLocal is not None:
+        return SessionLocal()
+
+    try:
+        from worker_app.db import SessionLocal as WorkerSL
+
+        if WorkerSL is not None:
+            return WorkerSL()
+    except ImportError:
+        pass
+
+    try:
+        from app.db import SessionLocal as ApiSL
+
+        if ApiSL is not None:
+            return ApiSL()
+    except ImportError:
+        pass
+
+    return None
+
+
+# ── 核心路由类 ──────────────────────────────────────────────────────────────
+
+
+class AIRouter:
+    """AI 模型路由器 — 统一配置读取与客户端构建.
+
+    缓存策略：
+    1. 本地内存缓存 {capability_key: CapabilityConfig}
+    2. 每次读取前比对 Redis 版本号，变了则清缓存重新查 DB
+    3. DB 无配置 / Redis 不可用 → fallback 到 SharedSettings 环境变量
+    """
+
+    def __init__(self):
+        self._cache: dict[str, CapabilityConfig] = {}
+        self._local_ver: str | None = None
+        self._lock = threading.Lock()
+
+    def _check_version(self) -> bool:
+        """检查 Redis 版本号，变了返回 True（需要刷新缓存）"""
+        from packages.shared.ai_config_version import get_version
+
+        current_ver = get_version()
+        if current_ver is None:
+            return False
+        if self._local_ver != current_ver:
+            return True
+        return False
+
+    def _load_from_db(self, capability_key: str) -> CapabilityConfig | None:
+        """从 DB 加载配置（ai_capability_configs JOIN ai_models）"""
+        session = _get_session()
+        if session is None:
+            logger.warning("AI Router: 无法获取 DB session")
+            return None
+        try:
+            from sqlalchemy import text
+
+            sql = text("""
+                SELECT
+                    cc.capability_key, cc.capability_name, cc.timeout_seconds,
+                    cc.max_retries, cc.max_tokens, cc.temperature,
+                    cc.concurrency, cc.extra_params, cc.is_enabled,
+                    pm.id AS pm_id, pm.name AS pm_name, pm.provider AS pm_provider,
+                    pm.model_key AS pm_model_key, pm.api_key AS pm_api_key,
+                    pm.api_base AS pm_api_base, pm.api_version AS pm_api_version,
+                    pm.status AS pm_status,
+                    lm.id AS lm_id, lm.name AS lm_name, lm.provider AS lm_provider,
+                    lm.model_key AS lm_model_key, lm.api_key AS lm_api_key,
+                    lm.api_base AS lm_api_base, lm.api_version AS lm_api_version,
+                    lm.status AS lm_status,
+                    fm.id AS fm_id, fm.name AS fm_name, fm.provider AS fm_provider,
+                    fm.model_key AS fm_model_key, fm.api_key AS fm_api_key,
+                    fm.api_base AS fm_api_base, fm.api_version AS fm_api_version,
+                    fm.status AS fm_status
+                FROM ai_capability_configs cc
+                LEFT JOIN ai_models pm ON cc.primary_model_id = pm.id AND pm.deleted_at IS NULL
+                LEFT JOIN ai_models lm ON cc.lite_model_id = lm.id AND lm.deleted_at IS NULL
+                LEFT JOIN ai_models fm ON cc.fallback_model_id = fm.id AND fm.deleted_at IS NULL
+                WHERE cc.capability_key = :key AND cc.is_enabled = true
+            """)
+            row = session.execute(sql, {"key": capability_key}).first()
+            if not row:
+                return None
+
+            def _to_model(prefix: str) -> ModelConfig | None:
+                mid = getattr(row, f"{prefix}_id", None)
+                if not mid:
+                    return None
+                return ModelConfig(
+                    id=mid,
+                    name=getattr(row, f"{prefix}_name", "") or "",
+                    provider=getattr(row, f"{prefix}_provider", "") or "",
+                    model_key=getattr(row, f"{prefix}_model_key", "") or "",
+                    api_key=getattr(row, f"{prefix}_api_key", "") or "",
+                    api_base=getattr(row, f"{prefix}_api_base", "") or "",
+                    api_version=getattr(row, f"{prefix}_api_version", None),
+                    status=getattr(row, f"{prefix}_status", "active") or "active",
+                )
+
+            return CapabilityConfig(
+                capability_key=row.capability_key,
+                capability_name=row.capability_name,
+                primary_model=_to_model("pm"),
+                lite_model=_to_model("lm"),
+                fallback_model=_to_model("fm"),
+                timeout_seconds=row.timeout_seconds or 30,
+                max_retries=row.max_retries or 1,
+                max_tokens=row.max_tokens,
+                temperature=row.temperature,
+                concurrency=row.concurrency or 2,
+                extra_params=row.extra_params or {},
+                is_enabled=row.is_enabled,
+            )
+        except Exception as e:
+            logger.warning("AI Router: DB 查询失败 (key=%s): %s", capability_key, e)
+            return None
+        finally:
+            session.close()
+
+    def get_capability(self, key: str) -> CapabilityConfig | None:
+        """获取业务能力配置（带缓存）"""
+        with self._lock:
+            if self._check_version():
+                self._cache.clear()
+                from packages.shared.ai_config_version import get_version
+
+                self._local_ver = get_version()
+
+            if key in self._cache:
+                return self._cache[key]
+
+            config = self._load_from_db(key)
+            if config:
+                self._cache[key] = config
+            return config
+
+    def _get_model_or_fallback(self, cap: CapabilityConfig, variant: str = "primary") -> ModelConfig | None:
+        """按 variant 选择模型，不存在则降级。
+
+        - primary: primary → fallback
+        - lite: lite → primary
+        - fallback: fallback → primary（修复点：此前 fallback variant 被忽略，错误地使用了 primary 模型）
+        """
+        if variant == "fallback":
+            if cap.fallback_model:
+                return cap.fallback_model
+            if cap.primary_model:
+                return cap.primary_model
+        elif variant == "lite":
+            if cap.lite_model:
+                return cap.lite_model
+            if cap.primary_model:
+                return cap.primary_model
+        else:  # primary
+            if cap.primary_model:
+                return cap.primary_model
+            if cap.fallback_model:
+                return cap.fallback_model
+        return None
+
+    # ── 构建客户端 ─────────────────────────────────────────────────────────
+
+    def _build_llm_client(self, model: ModelConfig, cap: CapabilityConfig):
+        """构建 LLM 客户端 — 返回 DoubaoClient 实例"""
+        from packages.shared.ai_client import DoubaoClient
+
+        return DoubaoClient(
+            api_key=model.api_key,
+            base_url=model.api_base,
+            model=model.model_key,
+            timeout=cap.timeout_seconds,
+            max_retries=cap.max_retries,
+            max_tokens=cap.max_tokens,
+            temperature=cap.temperature,
+            extra_params=cap.extra_params,
+            provider=model.provider,
+        )
+
+    def _build_vision_client(self, model: ModelConfig, cap: CapabilityConfig):
+        """构建 VLM 客户端 — 返回 DoubaoClient 实例（DoubaoClient 已支持 vision_completion）"""
+        from packages.shared.ai_client import DoubaoClient
+
+        return DoubaoClient(
+            api_key=model.api_key,
+            base_url=model.api_base,
+            model=model.model_key,
+            timeout=cap.timeout_seconds,
+            max_retries=cap.max_retries,
+            max_tokens=cap.max_tokens,
+            temperature=cap.temperature,
+            extra_params=cap.extra_params,
+            provider=model.provider,
+        )
+
+    def _build_tts_client(self, model: ModelConfig, cap: CapabilityConfig) -> TTSClient:
+        return TTSClient(
+            provider=model.provider,
+            api_key=model.api_key,
+            base_url=model.api_base,
+            model=model.model_key,
+            timeout=cap.timeout_seconds,
+            extra_params=cap.extra_params,
+        )
+
+    def _build_image_gen_client(self, model: ModelConfig, cap: CapabilityConfig) -> ImageGenClient:
+        return ImageGenClient(
+            provider=model.provider,
+            api_key=model.api_key,
+            base_url=model.api_base,
+            model=model.model_key,
+            timeout=cap.timeout_seconds,
+            extra_params=cap.extra_params,
+        )
+
+    def _build_video_gen_client(self, model: ModelConfig, cap: CapabilityConfig) -> VideoGenClient:
+        return VideoGenClient(
+            provider=model.provider,
+            api_key=model.api_key,
+            base_url=model.api_base,
+            model=model.model_key,
+            timeout=cap.timeout_seconds,
+            extra_params=cap.extra_params,
+        )
+
+    # ── 公开接口 ────────────────────────────────────────────────────────────
+
+    def get_llm_client(self, key: str, variant: str = "primary"):
+        """获取 LLM 客户端（返回 DoubaoClient 实例）"""
+        cap = self.get_capability(key)
+        if cap and cap.is_enabled:
+            model = self._get_model_or_fallback(cap, variant)
+            if model and model.api_key:
+                return self._build_llm_client(model, cap)
+
+        return self._fallback_llm_client(key)
+
+    def get_vision_client(self, key: str, variant: str = "primary"):
+        """获取 VLM 客户端（返回 DoubaoClient 实例）"""
+        cap = self.get_capability(key)
+        if cap and cap.is_enabled:
+            model = self._get_model_or_fallback(cap, variant)
+            if model and model.api_key:
+                return self._build_vision_client(model, cap)
+
+        return self._fallback_vision_client(key)
+
+    def get_tts_client(self, key: str = "tts") -> TTSClient | None:
+        """获取 TTS 客户端"""
+        cap = self.get_capability(key)
+        if cap and cap.is_enabled and cap.primary_model and cap.primary_model.api_key:
+            return self._build_tts_client(cap.primary_model, cap)
+
+        return self._fallback_tts_client()
+
+    def get_image_gen_client(self, key: str = "image_generation") -> ImageGenClient | None:
+        """获取图片生成客户端"""
+        cap = self.get_capability(key)
+        if cap and cap.is_enabled and cap.primary_model and cap.primary_model.api_key:
+            return self._build_image_gen_client(cap.primary_model, cap)
+
+        return self._fallback_image_gen_client()
+
+    def get_video_gen_client(self, key: str = "video_generation") -> VideoGenClient | None:
+        """获取视频生成客户端"""
+        cap = self.get_capability(key)
+        if cap and cap.is_enabled and cap.primary_model and cap.primary_model.api_key:
+            return self._build_video_gen_client(cap.primary_model, cap)
+
+        return self._fallback_video_gen_client()
+
+    # ── Fallback 方法（读 SharedSettings 环境变量）──────────────────────────
+
+    def _fallback_llm_client(self, key: str):
+        """Fallback LLM 客户端 — 从 settings 读取配置，不硬编码"""
+        settings = get_shared_settings()
+        model_map = {
+            "intent_parsing": (settings.doubao_fast_model, settings.doubao_base_url, settings.doubao_api_key),
+            "copy_fusion": (settings.doubao_fast_model, settings.doubao_base_url, settings.doubao_api_key),
+            "storyboard": (settings.doubao_model, settings.doubao_base_url, settings.doubao_api_key),
+            "copy_review": (settings.doubao_model, settings.doubao_base_url, settings.doubao_api_key),
+            "asset_classify": (settings.doubao_model, settings.doubao_base_url, settings.doubao_api_key),
+        }
+        if key in model_map:
+            model_id, base_url, api_key = model_map[key]
+        else:
+            model_id = settings.doubao_model
+            base_url = settings.doubao_base_url
+            api_key = settings.doubao_api_key
+
+        if not api_key:
+            return None
+
+        from packages.shared.ai_client import DoubaoClient
+
+        return DoubaoClient(
+            provider="volcengine",
+            api_key=api_key,
+            base_url=base_url,
+            model=model_id,
+            timeout=settings.doubao_timeout,
+            max_retries=settings.doubao_max_retries,
+        )
+
+    def _fallback_vision_client(self, key: str):
+        """Fallback VLM 客户端 — 从 settings 读取 dashscope 配置，不硬编码"""
+        settings = get_shared_settings()
+        api_key = getattr(settings, "dashscope_api_key", "")
+        if not api_key:
+            return None
+        base_url = getattr(settings, "dashscope_base_url", "") or ""
+        model = getattr(settings, "dashscope_model", "") or getattr(settings, "doubao_vision_model", "")
+
+        from packages.shared.ai_client import DoubaoClient
+
+        return DoubaoClient(
+            provider="dashscope",
+            api_key=api_key,
+            base_url=base_url,
+            model=model,
+            timeout=15,
+        )
+
+    def _fallback_tts_client(self) -> TTSClient | None:
+        settings = get_shared_settings()
+        api_key = getattr(settings, "cosyvoice_api_key", "")
+        if not api_key:
+            return None
+        base_url = getattr(settings, "cosyvoice_base_url", "")
+        model = getattr(settings, "cosyvoice_model", "")
+
+        return TTSClient(provider="dashscope", api_key=api_key, base_url=base_url, model=model)
+
+    def _fallback_image_gen_client(self) -> ImageGenClient | None:
+        settings = get_shared_settings()
+        api_key = getattr(settings, "doubao_api_key", "")
+        if not api_key:
+            return None
+        base_url = getattr(settings, "doubao_base_url", "")
+        model = getattr(settings, "doubao_image_model", "")
+
+        return ImageGenClient(
+            provider="volcengine",
+            api_key=api_key,
+            base_url=base_url,
+            model=model,
+            timeout=getattr(settings, "doubao_image_timeout", 60),
+        )
+
+    def _fallback_video_gen_client(self) -> VideoGenClient | None:
+        settings = get_shared_settings()
+        api_key = getattr(settings, "doubao_api_key", "")
+        if not api_key:
+            return None
+        base_url = getattr(settings, "doubao_base_url", "")
+        model = getattr(settings, "doubao_video_model", "")
+
+        return VideoGenClient(
+            provider="volcengine",
+            api_key=api_key,
+            base_url=base_url,
+            model=model,
+            timeout=getattr(settings, "doubao_video_timeout", 600),
+        )
+
+    def invalidate(self):
+        """清空本地缓存"""
+        with self._lock:
+            self._cache.clear()
+            self._local_ver = None
+
+
+# ── 全局单例 ──────────────────────────────────────────────────────────────
+
+ai_router = AIRouter()

packages/shared/ai_service.py

@@ -496,16 +496,33 @@ def run_generate_cover(
 # ── 通用 LLM / Vision 调用（#2039 ViralVideoOrchestrator 使用，复用现有豆包客户端）──
 
 
-def call_llm(prompt: str, temperature: float = 0.7) -> object:
-    """调用豆包大模型（文本对话），返回解析后的 JSON（dict/list）或原文字符串；失败返回 None。"""
+def call_llm(
+    prompt: str,
+    temperature: float = 0.7,
+    max_tokens: int = 2048,
+    model: str | None = None,
+    system_prompt: str | None = None,
+    timeout: int | None = None,
+) -> object:
+    """调用豆包大模型（文本对话），返回解析后的 JSON（dict/list）或原文字符串；失败返回 None。
+
+    Args:
+        prompt: 用户侧提示。
+        temperature: 采样温度。
+        max_tokens: 输出上限（结构化任务默认 2048，长文案可按需加大）。
+        model: 覆盖默认模型（如 fast_model 提速用），None 走配置默认推理模型。
+        system_prompt: 覆盖默认 system prompt。
+    """
     client = get_doubao_client()
     if not client.is_available:
         return None
+    if system_prompt is None:
+        system_prompt = "你是专业的短视频内容策划助手。需要结构化输出时请严格使用 JSON。"
     messages = [
-        {"role": "system", "content": "你是专业的短视频内容策划助手。需要结构化输出时请严格使用 JSON。"},
+        {"role": "system", "content": system_prompt},
         {"role": "user", "content": prompt},
     ]
-    raw = client.chat_completion(messages, temperature=temperature, max_tokens=4096)
+    raw = client.chat_completion(messages, temperature=temperature, max_tokens=max_tokens, model=model, timeout=timeout)
     if raw is None:
         return None
     try:
@@ -514,14 +531,26 @@ def call_llm(prompt: str, temperature: float = 0.7) -> object:
         return raw
 
 
-def call_vision(image_url: str, prompt: str) -> object:
+def call_vision(
+    image_url: str,
+    prompt: str,
+    *,
+    model: str | None = None,
+    max_tokens: int = 1024,
+    temperature: float = 0.2,
+    timeout: int = 45,
+    system_prompt: str | None = None,
+) -> object:
     """调用豆包视觉大模型分析图片，返回解析后的 JSON 或原文字符串；失败返回 None。
 
-    Bug #2114 (VLM 牛头不对马嘴根因修复):
-    之前误走 client.chat_completion(用文本模型 doubao-seed-1.6)，多模态 content list 被当成
-    纯文本发给文本模型 → 模型要么看不到图、要么抛 400，静默被 except 吞掉 → 返回 None →
-    _step_image_analysis fallback 到 {"name":"未识别"} → 后续文案/分镜完全没图的信息。
-    现改走 vision_completion，走视觉模型 doubao-1-5-vision-pro-250915。
+    Args:
+        image_url: 可公网访问的图片 URL（直接传给豆包视觉模型，无需本地下载）。
+        prompt: 用户侧文本提示。
+        model: 覆盖默认视觉模型（如 vision_lite_model 提速用），None 走配置默认。
+        max_tokens: 输出上限，商品识别用 800~1200 足够，避免长输出拖慢首 token。
+        temperature: 温度。
+        timeout: 单次请求超时（秒）。
+        system_prompt: 覆盖默认 system prompt（viral-video 商品分析会传专门的详细 prompt）。
     """
     client = get_doubao_client()
     if not client.is_available:
@@ -531,28 +560,33 @@ def call_vision(image_url: str, prompt: str) -> object:
         logger.warning("[call_vision] 空 image_url，跳过视觉分析")
         return None
 
-    system_prompt = (
-        "你是资深电商视觉分析师。请严格基于用户提供的图片观察回答，"
-        "图片里没有的信息不要凭空想象或编造；看不清或无法判断时明确说"
-        "「图片中无法判断」，不要猜测。输出必须是严格 JSON，不要附加 Markdown 或解释文字。"
-    )
+    if system_prompt is None:
+        system_prompt = (
+            "你是资深电商视觉分析师。请严格基于用户提供的图片观察回答，"
+            "图片里没有的信息不要凭空想象或编造；看不清或无法判断时明确说"
+            "「无法判断」，不要猜测。输出必须是严格 JSON，不要附加 Markdown 或解释文字。"
+        )
     messages = [
         {"role": "system", "content": system_prompt},
         {"role": "user", "content": prompt},
     ]
 
+    used_model = model or getattr(client, "vision_model", "?")
     logger.info(
-        "[call_vision] 调用豆包视觉模型 vision_model=%s image_url=%s prompt_len=%d",
-        getattr(client, "vision_model", "?"),
+        "[call_vision] 调用豆包视觉模型 model=%s image_url=%s prompt_len=%d max_tokens=%d timeout=%d",
+        used_model,
         image_url[:120],
         len(prompt),
+        max_tokens,
+        timeout,
     )
     raw = client.vision_completion(
         messages=messages,
         images=[image_url],
-        temperature=0.2,
-        max_tokens=2048,
-        timeout=60,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        timeout=timeout,
+        model=model,
     )
     if raw is None:
         logger.warning("[call_vision] 视觉模型返回 None (image_url=%s)", image_url[:80])
@@ -571,40 +605,93 @@ def call_vision(image_url: str, prompt: str) -> object:
         return raw
 
 
+def preheat_trust_chain(portrait_descriptions: list[str], *, timeout: int = 120) -> list[str] | None:
+    """#2174 信任链预热（t2i版）：用 VLM 分析出的人物外貌描述，跑 Seedream 文生图，
+    生成的信任产物 URL 可传给 call_video_generation(pre_trusted_images=...)。
+
+    - portrait_descriptions: VLM输出的portrait_prompt列表（中文人物外貌描述）
+    - 成功返回与输入同序的信任图URL列表；任意一张失败返回None（调用方回退到纯t2v）
+    - 必须传VLM人物描述，不传reference_images，走纯t2i路径才是方舟信任产物
+    """
+    client = get_doubao_client()
+    if not client.is_available:
+        return None
+    try:
+        return client.preheat_trust_chain(portrait_descriptions, timeout=timeout)
+    except Exception as e:
+        logger.error("[ai_service] preheat_trust_chain 异常: %s", e, exc_info=True)
+        return None
+
+
 def call_video_generation(
     prompt: str,
     *,
     image_url: str | None = None,
-    duration: int = 5,
+    duration: int = 15,
     ratio: str | None = "9:16",
     resolution: str = "720p",
     output_dir: str | None = None,
-) -> str | None:
-    """调用 Seedance 2.5 生成视频段，返回本地 MP4 路径；失败返回 None。
+    model: str | None = None,
+    generate_audio: bool = True,
+    reference_images: list[str] | None = None,
+    reference_audios: list[str] | None = None,
+    reference_videos: list[str] | None = None,
+    pre_trusted_images: list[str] | None = None,
+) -> dict | None:
+    """调用 Seedance / Wan 视频生成（v1.6.2 多模型版 + #2172 信任链预热）。
 
-    封装 ai_client.video_generation：提交异步任务→轮询→下载到本地。
-    Bug #2110: 首帧参考图模式下不传 ratio（API 要求跟随首帧图比例，传 ratio=9:16
-    会返回 400 InvalidParameter）。
+    成功返回 {"video_path": str, "usage": dict | None}（usage 含 completion_tokens），失败返回 None。
+    失败时错误详情会写入 client.last_video_error，可通过 get_last_video_error() 读取：
+      {"error_code": str, "user_message": str, "status_code": int, "detail": str, ...}
     """
     client = get_doubao_client()
     if not client.is_available:
-        logger.warning("[ai_service] 豆包客户端未配置，跳过视频生成")
+        msg = "豆包客户端未配置（DOUBAO_API_KEY 缺失），跳过视频生成"
+        logger.warning("[ai_service] %s", msg)
+        # 写入 last_video_error 供上层读取
+        client.last_video_error = {
+            "error_code": "auth_error",
+            "user_message": "视频生成服务未配置，请联系管理员。",
+            "status_code": 0,
+            "detail": msg,
+        }
         return None
-    # 首帧模式：不强制 ratio，让模型跟随首帧图比例
-    effective_ratio = None if image_url else ratio
+    effective_ratio = ratio or "9:16"
     try:
         kwargs: dict = dict(
             prompt=prompt,
             image_url=image_url,
-            duration=duration,
+            duration=int(duration),
             resolution=resolution,
-            generate_audio=False,  # 我们自己混 TTS
+            generate_audio=bool(generate_audio),
             watermark=False,
             output_dir=output_dir,
+            model=model,
+            reference_images=reference_images,
+            reference_audios=reference_audios,
+            reference_videos=reference_videos,
+            pre_trusted_images=pre_trusted_images,
         )
         if effective_ratio:
             kwargs["ratio"] = effective_ratio
         return client.video_generation(**kwargs)
     except Exception as e:
         logger.error("[ai_service] call_video_generation 异常: %s", e, exc_info=True)
+        client.last_video_error = {
+            "error_code": "unknown",
+            "user_message": f"视频生成异常：{e!s}"[:200],
+            "status_code": 0,
+            "detail": str(e),
+        }
         return None
+
+
+def get_last_video_error() -> dict:
+    """读取最近一次视频生成失败的详细错误（含 error_code/user_message/status_code/detail）。
+    成功或未调用过返回空 dict。
+    """
+    try:
+        client = get_doubao_client()
+        return client.get_last_video_error() if hasattr(client, "get_last_video_error") else {}
+    except Exception:
+        return {}

packages/shared/dashscope_client.py

@@ -0,0 +1,344 @@
+"""DashScope 客户端（阿里云百炼 Wan 3.0 等非方舟模型）。
+
+#2159: 新增 Wan 3.0 视频生成支持。DashScope 异步协议：
+- POST  {base_url}/services/aigc/video-generation/video-synthesis  (X-DashScope-Async: enable)
+  → 返回 output.task_id
+- GET   {base_url}/tasks/{task_id} 轮询状态
+  → SUCCEEDED 时 output.video_url 可下载
+认证：Authorization: Bearer {DASHSCOPE_API_KEY}
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from packages.shared.config import get_shared_settings
+
+# 网络/超时类异常父类集合：覆盖 Timeout/Connect/Network/ReadTimeout/WriteTimeout/PoolTimeout
+_HTTP_NETWORK_ERRORS = ()
+try:
+    _HTTP_NETWORK_ERRORS = (httpx.TimeoutException, httpx.NetworkError)
+except Exception:
+    _HTTP_NETWORK_ERRORS = (Exception,)
+
+_HTTP_STATUS_ERROR = httpx.HTTPStatusError if hasattr(httpx, "HTTPStatusError") else Exception
+
+logger = logging.getLogger(__name__)
+
+_DASHSCOPE_CLIENT_SINGLETON: "DashScopeClient | None" = None
+
+
+def _classify_dashscope_error(status_code: int, body: str, task_msg: str = "") -> tuple[str, str]:
+    """DashScope 错误分类，返回 (error_code, user_message)。"""
+    body_lower = (body or "").lower()
+    msg_in_body = task_msg or ""
+    try:
+        import json as _json
+
+        parsed = _json.loads(body or "{}")
+        if isinstance(parsed, dict):
+            msg_in_body = msg_in_body or str(parsed.get("message", "") or "")
+    except Exception:
+        pass
+
+    if status_code in (401, 403):
+        return "auth_error", "Wan 3.0 服务鉴权失败（DASHSCOPE_API_KEY 无效或过期），请联系管理员。"
+    if status_code == 429 or "rate" in body_lower or "throttl" in body_lower:
+        return "rate_limit", "Wan 3.0 服务繁忙（限流），请稍等1-2分钟后重试。"
+    if status_code == 400 and any(
+        kw in body_lower for kw in ("portrait", "真人", "人脸", "肖像", "content_violation", "risk", "blocked")
+    ):
+        return (
+            "portrait_intercept",
+            "参考素材包含真人照片或违规内容被安全策略拦截，请移除真人图片或调整文案后重试。",
+        )
+    if status_code == 404 or ("not found" in body_lower) or ("model" in body_lower and "not exist" in body_lower):
+        return "model_not_found", "Wan 3.0 模型未开通或模型ID无效，请联系管理员。"
+    if status_code in (402, 400) and ("quota" in body_lower or "billing" in body_lower or "insufficient" in body_lower):
+        return "quota_exceeded", "Wan 3.0 服务配额不足，请联系管理员充值或稍后重试。"
+    if status_code == 400:
+        return "invalid_param", f"Wan 3.0 参数错误：{msg_in_body or body[:200]}"
+    if status_code == 0:
+        return "network_error", "Wan 3.0 服务连接失败（网络超时），请稍后重试。"
+    # 任务内失败
+    if task_msg and any(kw in task_msg.lower() for kw in ("portrait", "真人", "人脸", "violation", "blocked")):
+        return "portrait_intercept", "Wan 3.0 视频内容被安全策略拦截，请调整文案或参考图后重试。"
+    detail = msg_in_body or body[:200]
+    return "unknown", f"Wan 3.0 视频生成失败（HTTP {status_code}）：{detail}"
+
+
+class DashScopeClient:
+    """阿里云 DashScope 异步 API 客户端（Wan 3.0 等视频生成）。"""
+
+    def __init__(self) -> None:
+        settings = get_shared_settings()
+        self.api_key: str = getattr(settings, "dashscope_api_key", "") or os.getenv("DASHSCOPE_API_KEY", "")
+        self.base_url: str = (
+            getattr(settings, "dashscope_base_url", "") or "https://dashscope.aliyuncs.com/api/v1"
+        ).rstrip("/")
+        self.poll_interval: int = int(getattr(settings, "dashscope_video_poll_interval", 10) or 10)
+        self.total_timeout: int = int(getattr(settings, "dashscope_video_timeout", 900) or 900)
+        self.max_retries: int = 2
+        self.last_video_error: dict = {}
+
+    @property
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def get_last_video_error(self) -> dict:
+        return dict(self.last_video_error or {})
+
+    def _set_error(self, error_code: str, user_message: str, status_code: int = 0, detail: str = "", **extra) -> None:
+        self.last_video_error = {
+            "error_code": error_code,
+            "user_message": user_message,
+            "status_code": status_code,
+            "detail": detail[:500] if detail else "",
+            **extra,
+        }
+
+    def video_generation(
+        self,
+        prompt: str,
+        *,
+        image_url: str | None = None,
+        duration: int = 5,
+        ratio: str | None = "9:16",
+        resolution: str = "720p",
+        watermark: bool = False,
+        output_dir: str | None = None,
+        model: str = "wan3.0-video",
+    ) -> dict | None:
+        """调用 DashScope 异步视频合成接口，轮询完成后下载到本地。
+
+        返回 {"video_path": str, "usage": dict | None}；失败返回 None，错误详情写入 self.last_video_error。
+        """
+        self.last_video_error = {}
+        if not self.is_available:
+            self._set_error("auth_error", "Wan 3.0 API key 未配置，请联系管理员。", detail="dashscope api_key empty")
+            logger.error("[dashscope] API key 未配置，无法调用视频生成")
+            return None
+        if not prompt or not prompt.strip():
+            self._set_error("invalid_param", "视频生成提示词不能为空。", detail="empty prompt")
+            return None
+
+        # DashScope 分辨率参数：720P / 1080P / 480P（大写 P）
+        res_upper = (resolution or "720p").upper().replace("P", "P")
+        if res_upper == "480P":
+            ds_res = "480P"
+        elif res_upper == "1080P":
+            ds_res = "1080P"
+        else:
+            ds_res = "720P"
+
+        # 构造 input+parameters
+        input_obj: dict[str, Any] = {"prompt": prompt.strip()}
+        if image_url:
+            input_obj["img_url"] = image_url
+        params: dict[str, Any] = {
+            "resolution": ds_res,
+            "duration": str(float(duration)),
+            "watermark": bool(watermark),
+        }
+        # 比例透传：Wan 支持 "9:16" / "16:9" / "1:1" 等
+        if ratio and ratio != "adaptive":
+            params["aspect_ratio"] = ratio
+
+        payload: dict[str, Any] = {
+            "model": model,
+            "input": input_obj,
+            "parameters": params,
+        }
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "X-DashScope-Async": "enable",
+        }
+        create_url = f"{self.base_url}/services/aigc/video-generation/video-synthesis"
+        logger.info(
+            "[dashscope] 创建任务: model=%s dur=%ds ratio=%s res=%s img=%s",
+            model,
+            duration,
+            ratio,
+            ds_res,
+            bool(image_url),
+        )
+        logger.info("[dashscope] 创建任务 payload: model=%s params=%s", model, params)
+
+        # 创建任务
+        task_id: str | None = None
+        last_sc = 0
+        last_body = ""
+        for attempt in range(self.max_retries + 1):
+            try:
+                resp = httpx.post(create_url, headers=headers, json=payload, timeout=60)
+                sc = int(getattr(resp, "status_code", 0) or 0)
+                body_text = (getattr(resp, "text", "") or "")[:2000]
+                last_sc = sc
+                last_body = body_text
+                if sc >= 400:
+                    logger.error("[dashscope] 创建任务 HTTP %d: %s", sc, body_text)
+                    if sc >= 500 and attempt < self.max_retries:
+                        time.sleep(0.5 * (2**attempt))
+                        continue
+                    err_code, user_msg = _classify_dashscope_error(sc, body_text)
+                    self._set_error(err_code, user_msg, sc, body_text, model=model)
+                    return None
+                data = resp.json()
+                tid = (data.get("output") or {}).get("task_id")
+                if tid:
+                    task_id = tid
+                    break
+                # 部分情况下 code != 错误
+                code = data.get("code")
+                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:
+                if attempt < self.max_retries:
+                    time.sleep(0.5 * (2**attempt))
+                    continue
+                logger.error("[dashscope] 创建任务最终失败: %s", _e)
+                self._set_error("unknown", f"Wan 3.0 创建任务异常：{_e!s}"[:200], 0, str(_e))
+                return None
+        if not task_id:
+            if not self.last_video_error:
+                err_code, user_msg = _classify_dashscope_error(last_sc, last_body)
+                self._set_error(err_code, user_msg, last_sc, last_body, model=model)
+            return None
+
+        # 轮询任务
+        poll_url = f"{self.base_url}/tasks/{task_id}"
+        deadline = time.time() + self.total_timeout
+        video_url: str | None = None
+        usage: dict | None = None
+        poll_count = 0
+        last_status = ""
+        while time.time() < deadline:
+            poll_count += 1
+            try:
+                r = httpx.get(poll_url, headers=headers, timeout=30)
+                psc = int(getattr(r, "status_code", 0) or 0)
+                pbody = (getattr(r, "text", "") or "")[:1500]
+                if psc >= 400:
+                    logger.warning("[dashscope] 轮询 HTTP %d: %s", psc, pbody[:300])
+                    if poll_count < 3:
+                        time.sleep(self.poll_interval)
+                        continue
+                    err_code, user_msg = _classify_dashscope_error(psc, pbody)
+                    self._set_error(err_code, user_msg, psc, pbody, task_id=task_id)
+                    return None
+                d = r.json()
+                out = d.get("output") or {}
+                task_status = out.get("task_status") or d.get("task_status") or ""
+                last_status = task_status
+                if task_status == "SUCCEEDED":
+                    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")
+                    if video_url:
+                        logger.info("[dashscope] 任务 %s 完成: %s", task_id, video_url[:120])
+                        break
+                    logger.error("[dashscope] 任务 %s SUCCEEDED 但无 video_url: %s", task_id, str(d)[:500])
+                    self._set_error(
+                        "unknown",
+                        "Wan 3.0 任务成功但未返回视频URL，请联系管理员。",
+                        200,
+                        str(d)[:500],
+                        task_id=task_id,
+                    )
+                    return None
+                if task_status in ("FAILED", "FAILED_WITH_ERROR", "ERROR"):
+                    msg = out.get("message") or d.get("message") or out.get("error_msg") or "unknown error"
+                    logger.error("[dashscope] 任务 %s 失败: %s", task_id, msg)
+                    err_code, user_msg = _classify_dashscope_error(200, "", msg)
+                    self._set_error(err_code, user_msg, 200, msg, task_id=task_id, last_status=task_status)
+                    return None
+                if task_status in ("CANCELED", "CANCELLED"):
+                    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:
+                logger.warning("[dashscope] 轮询异常: %s", e)
+            time.sleep(self.poll_interval)
+        if not video_url:
+            logger.error("[dashscope] 任务 %s 轮询超时（%ds）", task_id, self.total_timeout)
+            self._set_error(
+                "network_error",
+                f"Wan 3.0 视频生成超时（>{self.total_timeout}s），任务仍在排队，请稍后重试。",
+                0,
+                f"timeout after {self.total_timeout}s, polls={poll_count}, last_status={last_status}",
+                task_id=task_id,
+                last_status=last_status,
+            )
+            return None
+
+        # 下载视频
+        out_dir = output_dir or os.path.join(os.getcwd(), "seedance_outputs")
+        os.makedirs(out_dir, exist_ok=True)
+        suffix = Path(urlparse(video_url).path).suffix or ".mp4"
+        if suffix.lower() not in (".mp4", ".mov", ".webm"):
+            suffix = ".mp4"
+        safe_tid = "".join(c if c.isalnum() or c in "-_" else "_" for c in task_id)[:40]
+        out_path = os.path.join(out_dir, f"wan_{safe_tid}{suffix}")
+        try:
+            with httpx.stream("GET", video_url, timeout=300, follow_redirects=True) as resp:
+                dsc = int(getattr(resp, "status_code", 0) or 0)
+                if dsc >= 400:
+                    logger.error("[dashscope] 下载 HTTP %d", dsc)
+                    self._set_error("network_error", "Wan 3.0 视频下载失败（HTTP错误），请稍后重试。", dsc)
+                    return None
+                with open(out_path, "wb") as f:
+                    for chunk in resp.iter_bytes(chunk_size=1024 * 256):
+                        if chunk:
+                            f.write(chunk)
+        except Exception as e:
+            logger.error("[dashscope] 下载视频失败: %s", e, exc_info=True)
+            self._set_error("network_error", f"Wan 3.0 视频下载失败：{e!s}"[:200], 0, str(e))
+            return None
+        size = os.path.getsize(out_path) if os.path.exists(out_path) else 0
+        if size < 1024:
+            logger.error("[dashscope] 下载文件过小: %d bytes", size)
+            self._set_error("unknown", "Wan 3.0 视频下载文件过小，请稍后重试。", 0, f"downloaded only {size} bytes")
+            return None
+        logger.info("[dashscope] 视频已下载: %s (%d bytes)", out_path, size)
+        return {"video_path": out_path, "usage": usage}
+
+
+def get_dashscope_client() -> DashScopeClient | None:
+    """返回 DashScope 客户端单例；未配置 API key 时返回 None。"""
+    global _DASHSCOPE_CLIENT_SINGLETON
+    if _DASHSCOPE_CLIENT_SINGLETON is None:
+        _DASHSCOPE_CLIENT_SINGLETON = DashScopeClient()
+    if not _DASHSCOPE_CLIENT_SINGLETON.is_available:
+        return None
+    return _DASHSCOPE_CLIENT_SINGLETON

scripts/ci_staging_deploy.sh

@@ -368,6 +368,21 @@ fi
 
 echo "All images pulled."
 
+# ====== 打稳定 tag（:dev），供 Watchtower 监控 ======
+# Watchtower 只能检测同一个 tag 的 digest 变化。
+# commit SHA tag 每次构建都不同，Watchtower 无法感知更新。
+# 因此每次部署都将最新镜像 tag 为 :dev，容器统一使用 :dev 启动。
+DEV_API="${REGISTRY}/xiaoxia-saas-api:dev"
+DEV_WORKER="${REGISTRY}/xiaoxia-saas-worker:dev"
+DEV_WEB="${REGISTRY}/xiaoxia-saas-web:dev"
+docker tag "$REGISTRY_API" "$DEV_API"
+docker tag "$REGISTRY_WORKER" "$DEV_WORKER"
+docker tag "$REGISTRY_WEB" "$DEV_WEB"
+echo "✅ Tagged images as :dev for Watchtower monitoring"
+echo "  API:    $DEV_API"
+echo "  Worker: $DEV_WORKER"
+echo "  Web:    $DEV_WEB"
+
 # ====== 镜像内容校验 ======
 echo ""
 echo "=========================================="
@@ -533,7 +548,7 @@ docker run -d \
   --health-retries 3 \
   --health-start-period 40s \
   $LOG_OPTS \
-  "$REGISTRY_API" &
+  "$DEV_API" &
 PID_API_START=$!
 
 # ── Worker: 通过 compose 启动（单一事实来源）──
@@ -541,7 +556,7 @@ PID_API_START=$!
 # healthcheck 匹配 'celery.*worker'（不把 beat 算活）、资源限制 4C/8G。
 # WORKER_IMAGE 通过环境变量覆盖镜像 tag（compose.yml 默认 :dev）。
 echo "Starting worker via docker compose (from $INFRA_DOCKER_DIR)..."
-WORKER_IMAGE="$REGISTRY_WORKER" APP_VERSION="$IMAGE_TAG" compose up -d --no-deps worker &
+WORKER_IMAGE="$DEV_WORKER" APP_VERSION="$IMAGE_TAG" compose up -d --no-deps worker &
 PID_WORKER_START=$!
 
 # ── Web: 暂保留 docker run（TODO: 后续收敛到 compose）──
@@ -557,7 +572,7 @@ docker run -d \
   --health-timeout 5s \
   --health-retries 3 \
   $LOG_OPTS \
-  "$REGISTRY_WEB" &
+  "$DEV_WEB" &
 PID_WEB_START=$!
 
 wait $PID_API_START $PID_WORKER_START $PID_WEB_START
@@ -688,5 +703,5 @@ echo "=== Staging deployment complete ==="
 echo "API:      http://127.0.0.1:8000"
 echo "Web:      http://127.0.0.1:3001"
 echo "Worker:   managed by docker compose (project=$COMPOSE_PROJECT)"
-echo "Version:  $IMAGE_TAG"
+echo "Version:  $IMAGE_TAG (running as :dev for Watchtower)"
 docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Image}}" | grep staging