release v0.1.137: 抖音多源轮询重构+ASR降级+文案库切换+积分系统+多个修复

- Copy ci-canary.yml from develop (PR #1636) to enable 30-min health checks on main
- Disable pr-auto-scan.yml schedule on main (was still running */15, causing failure spam)
- Relates: PR #1635 (develop already had schedule disabled)

.env.example

@@ -198,13 +198,10 @@ DOUBAO_TIMEOUT=30
 DOUBAO_MAX_RETRIES=2
 
 # ==================== 积分/会员系统 (#1895) ====================
-# 积分系统总开关：默认 false（暂停积分系统）。
-# - false：生成视频/口型同步/数字人/AI标题/TTS/克隆音色等所有功能对登录
-#   用户免费放行，不扣积分、不做余额拦截；积分余额/流水/会员状态查询接口
-#   保留可用，但数据不再变动。积分相关的表、代码、接口均保留不删除。
-# - 恢复积分：设置 ENABLE_CREDIT_SYSTEM=true 即可，无需改代码。
-ENABLE_CREDIT_SYSTEM=false
-# 旧开关名（兼容别名）：与 ENABLE_CREDIT_SYSTEM 任一为 true 即启用。
+# 积分扣点总开关：默认 false（对现有用户零影响）。
+# P2 阶段各业务路由逐个接入 @points_gate 时，用
+#   `if settings.points_enabled: ...`
+# 包裹扣点逻辑；所有路由接入完成并验证通过后再在 staging/prod 打开。
 POINTS_ENABLED=false
 
 # ==================== 抖音解析多源轮询 (#1963) ====================
@@ -216,20 +213,3 @@ TIKHUB_API_KEY=
 # apizero.cn API Key (https://v1.apizero.cn) — 国内抖音解析服务
 APIZERO_API_KEY=
 
-# ==================== GPU MuseTalk Worker（反向轮询口型同步）====================
-# GPU Worker 长期鉴权 Token，Worker 端 .env 的 GPU_WORKER_TOKEN 必须与此一致
-# 留空时 development 环境允许匿名访问（仅本地调试），staging/production 必须配置
-GPU_WORKER_TOKEN=
-# 单任务超时（秒），processing 超过此时长无任务心跳才回退 pending 或标记 failed
-# #1970：RTX2060 6G 推理 720p 长视频需 5 分钟以上，默认 900
-GPU_TASK_TIMEOUT_SECONDS=900
-# 是否启用 GPU 口型同步（开关）。开启后需同时有 Worker 在心跳窗口内（5分钟）才会走 GPU 路径；
-# 开关关闭 / 无可用 Worker / GPU 任务失败或超时 → 自动回退现有 MediaKit 云端 lipsync
-USE_GPU_LIPSYNC=false
-# 业务侧轮询 GPU 任务结果的间隔（秒）
-GPU_LIPSYNC_POLL_INTERVAL=5
-# 业务侧等待 GPU 任务总超时（秒）；超时回退 MediaKit
-GPU_LIPSYNC_WAIT_TIMEOUT=1200
-# Worker 心跳新鲜度窗口（秒），last_heartbeat_at 在此窗口内视为在线
-GPU_WORKER_STALE_SECONDS=300
-

.gitea/workflows/ci-pipeline.yml

@@ -1186,12 +1186,10 @@ jobs:
         DOUBAO_API_KEY: "${{ secrets.DOUBAO_API_KEY }}"
         DOUBAO_MODEL: "${{ secrets.DOUBAO_MODEL }}"
         DOUBAO_BASE_URL: "${{ secrets.DOUBAO_BASE_URL }}"
-        DOUBAO_VISION_MODEL: "${{ secrets.DOUBAO_VISION_MODEL }}"
         WECHAT_APP_ID: "${{ secrets.WECHAT_APP_ID }}"
         WECHAT_APP_SECRET: "${{ secrets.WECHAT_APP_SECRET }}"
         TIKHUB_API_KEY: "${{ secrets.TIKHUB_API_KEY }}"
         APIZERO_API_KEY: "${{ secrets.APIZERO_API_KEY }}"
-        GPU_WORKER_TOKEN: "${{ secrets.GPU_WORKER_TOKEN }}"
       run: |
         set -eu
         echo "Rendering .env from template + secrets..."
@@ -1642,12 +1640,10 @@ jobs:
         DOUBAO_API_KEY: "${{ secrets.DOUBAO_API_KEY }}"
         DOUBAO_MODEL: "${{ secrets.DOUBAO_MODEL }}"
         DOUBAO_BASE_URL: "${{ secrets.DOUBAO_BASE_URL }}"
-        DOUBAO_VISION_MODEL: "${{ secrets.DOUBAO_VISION_MODEL }}"
         WECHAT_APP_ID: "${{ secrets.WECHAT_APP_ID }}"
         WECHAT_APP_SECRET: "${{ secrets.WECHAT_APP_SECRET }}"
         TIKHUB_API_KEY: "${{ secrets.TIKHUB_API_KEY }}"
         APIZERO_API_KEY: "${{ secrets.APIZERO_API_KEY }}"
-        GPU_WORKER_TOKEN: "${{ secrets.GPU_WORKER_TOKEN }}"
       run: |
         set -eu
         echo "Rendering .env from template + secrets..."

alembic/versions/081_add_gpu_lipsync_tasks.py

@@ -1,58 +0,0 @@
-"""add gpu_lipsync_tasks and gpu_workers tables for MuseTalk reverse-poll worker
-
-Revision ID: 081_add_gpu_lipsync
-Revises: 080_edit_plan_clips_atom_clip_id
-Create Date: 2026-09-18
-"""
-
-import sqlalchemy as sa
-
-from alembic import op
-
-revision = "081_add_gpu_lipsync"
-down_revision = "080_edit_plan_clips_atom_clip_id"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # GPU Worker 注册表
-    op.create_table(
-        "gpu_workers",
-        sa.Column("worker_id", sa.String(100), primary_key=True),
-        sa.Column("hostname", sa.String(200), nullable=False, server_default=""),
-        sa.Column("gpu_name", sa.String(200), nullable=False, server_default=""),
-        sa.Column("free_vram_mb", sa.Integer(), nullable=False, server_default=sa.text("0")),
-        sa.Column("capabilities", sa.String(500), nullable=False, server_default=""),
-        sa.Column("last_heartbeat_at", sa.DateTime(), nullable=True, index=True),
-        sa.Column("created_at", sa.DateTime(), nullable=False, server_default=sa.func.now()),
-    )
-
-    # GPU 口型同步任务表
-    op.create_table(
-        "gpu_lipsync_tasks",
-        sa.Column("id", sa.String(36), primary_key=True),
-        sa.Column("lipsync_job_id", sa.String(36), nullable=False, server_default="", index=True),
-        sa.Column("user_id", sa.String(36), nullable=False, server_default="", index=True),
-        sa.Column("project_id", sa.String(36), nullable=False, server_default="", index=True),
-        sa.Column("video_url", sa.Text(), nullable=False),
-        sa.Column("audio_url", sa.Text(), nullable=False),
-        sa.Column("result_url", sa.Text(), nullable=False, server_default=""),
-        sa.Column("result_duration", sa.Float(), nullable=False, server_default=sa.text("0.0")),
-        sa.Column("status", sa.String(20), nullable=False, server_default="pending", index=True),
-        sa.Column("worker_id", sa.String(100), nullable=False, server_default="", index=True),
-        sa.Column("attempt", sa.Integer(), nullable=False, server_default=sa.text("0")),
-        sa.Column("error_msg", sa.Text(), nullable=False, server_default=""),
-        sa.Column("created_at", sa.DateTime(), nullable=False, server_default=sa.func.now()),
-        sa.Column("started_at", sa.DateTime(), nullable=True),
-        sa.Column("finished_at", sa.DateTime(), nullable=True),
-        sa.Column("updated_at", sa.DateTime(), nullable=False, server_default=sa.func.now()),
-        sa.Column("last_heartbeat_at", sa.DateTime(), nullable=True),
-    )
-    op.create_index("ix_gpu_lipsync_status_created", "gpu_lipsync_tasks", ["status", "created_at"])
-
-
-def downgrade() -> None:
-    op.drop_index("ix_gpu_lipsync_status_created", table_name="gpu_lipsync_tasks")
-    op.drop_table("gpu_lipsync_tasks")
-    op.drop_table("gpu_workers")

alembic/versions/082_atom_clip_ai_tags.py

@@ -1,26 +0,0 @@
-"""add ai_tags to asset_atom_clips for #1970 fragment-level AI tagging
-
-Revision ID: 082_atom_clip_ai_tags
-Revises: 081_add_gpu_lipsync
-Create Date: 2026-09-18
-"""
-
-import sqlalchemy as sa
-
-from alembic import op
-
-revision = "082_atom_clip_ai_tags"
-down_revision = "081_add_gpu_lipsync"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    op.add_column(
-        "asset_atom_clips",
-        sa.Column("ai_tags", sa.JSON(), nullable=True),
-    )
-
-
-def downgrade() -> None:
-    op.drop_column("asset_atom_clips", "ai_tags")

apps/api/app/api/router.py

@@ -14,7 +14,6 @@ from app.api.routes.generation_cover import router as generation_cover_router
 from app.api.routes.generation_preview import router as generation_preview_router
 from app.api.routes.generation_tasks import router as generation_tasks_router
 from app.api.routes.generation_variant_plans import router as generation_variant_plans_router
-from app.api.routes.gpu_lipsync import router as gpu_lipsync_router
 from app.api.routes.health import router as health_check_router
 from app.api.routes.ingest_jobs import router as ingest_jobs_router
 from app.api.routes.internal_render import router as internal_render_router
@@ -212,8 +211,3 @@ api_router.include_router(
     prefix="/usage",
     tags=["Usage"],
 )
-api_router.include_router(
-    gpu_lipsync_router,
-    prefix="/gpu",
-    tags=["GPU Worker"],
-)

apps/api/app/api/routes/gpu_lipsync.py

@@ -1,231 +0,0 @@
-"""GPU MuseTalk Worker 反向轮询路由 — /api/v1/gpu/lipsync/*.
-
-仅面向部署在用户 RTX2060 本地的 GPU Worker 脚本，不面向前端用户。
-鉴权方式：长期 API Token（`Authorization: Bearer <GPU_WORKER_TOKEN>`），不走用户 JWT。
-
-接口：
-  POST  /api/v1/gpu/register              Worker 注册/心跳
-  GET   /api/v1/gpu/lipsync/poll          Worker 轮询拉任务（无任务返回 204）
-  POST  /api/v1/gpu/lipsync/result        Worker multipart 上传结果视频/上报失败
-  GET   /api/v1/gpu/lipsync/status/{id}   业务侧查询任务状态（内部接口，暂开放给登录用户）
-"""
-
-from __future__ import annotations
-
-import logging
-import tempfile
-from datetime import UTC, datetime
-from pathlib import Path
-from typing import Optional
-
-import requests
-from app.core.storage import get_storage_service
-from app.dependencies import get_db_session
-from app.schemas.gpu_lipsync import (
-    GpuLipsyncPollResponse,
-    GpuLipsyncResultResponse,
-    GpuLipsyncStatusResponse,
-    GpuLipsyncTaskPayload,
-    GpuWorkerRegisterRequest,
-    GpuWorkerRegisterResponse,
-)
-from app.services.gpu_lipsync_service import GpuLipsyncService
-from fastapi import (
-    APIRouter,
-    Depends,
-    File,
-    Form,
-    HTTPException,
-    Query,
-    Request,
-    UploadFile,
-    status,
-)
-from fastapi.responses import Response
-from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
-
-from packages.config import get_api_settings
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-# 复用 bearer scheme 抽 Token，但不校验用户 JWT
-_gpu_bearer = HTTPBearer(auto_error=False)
-
-
-def _verify_gpu_token(
-    credentials: Optional[HTTPAuthorizationCredentials] = Depends(_gpu_bearer),
-) -> str:
-    """校验 GPU Worker Token，返回 worker 提供的 token 串（仅用于日志，不做身份识别）.
-
-    - development 且未配置 token → 直接放行（方便本地调试）。
-    - production/staging 未配置 token → 拒绝（避免裸奔）。
-    - token 不匹配 → 401。
-    """
-    settings = get_api_settings()
-    expected = (settings.gpu_worker_token or "").strip()
-    is_dev = settings.environment == "development"
-    if not expected:
-        if is_dev:
-            return credentials.credentials if credentials else ""
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="GPU_WORKER_TOKEN not configured on server",
-        )
-    if credentials is None or credentials.scheme.lower() != "bearer":
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Missing bearer token")
-    if credentials.credentials != expected:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid GPU worker token")
-    return credentials.credentials
-
-
-def _get_svc(db=Depends(get_db_session)) -> GpuLipsyncService:
-    return GpuLipsyncService(db)
-
-
-# ── POST /register — Worker 注册/心跳 ──────────────────────────────
-
-
-@router.post("/register", response_model=GpuWorkerRegisterResponse)
-def register_worker(
-    body: GpuWorkerRegisterRequest,
-    svc: GpuLipsyncService = Depends(_get_svc),
-    _token: str = Depends(_verify_gpu_token),
-):
-    svc.register_worker(
-        worker_id=body.worker_id,
-        hostname=body.hostname,
-        gpu_name=body.gpu_name,
-        free_vram_mb=body.free_vram_mb,
-        capabilities=body.capabilities,
-        task_id=body.task_id,
-    )
-    return GpuWorkerRegisterResponse(ok=True, server_time=datetime.now(UTC), message="ok")
-
-
-# ── GET /lipsync/poll — Worker 轮询拉任务 ─────────────────────────
-
-
-@router.get("/lipsync/poll")
-def poll_task(
-    worker_id: str = Query(..., min_length=1, max_length=100, description="Worker 唯一 ID"),
-    svc: GpuLipsyncService = Depends(_get_svc),
-    _token: str = Depends(_verify_gpu_token),
-):
-    task = svc.poll_task(worker_id=worker_id)
-    if task is None:
-        return Response(status_code=status.HTTP_204_NO_CONTENT)
-    payload = GpuLipsyncTaskPayload(
-        task_id=task.id,
-        video_url=getattr(task, "_signed_video_url", task.video_url),
-        audio_url=getattr(task, "_signed_audio_url", task.audio_url),
-        lipsync_job_id=task.lipsync_job_id or "",
-        user_id=task.user_id or "",
-        project_id=task.project_id or "",
-        created_at=task.created_at,
-        upload_url=getattr(task, "_signed_upload_url", ""),
-        upload_method="PUT",
-        expires_at=getattr(task, "_upload_expires_at", datetime.now(UTC)),
-    )
-    return GpuLipsyncPollResponse(task=payload)
-
-
-# ── POST /lipsync/result — Worker 上报结果（multipart） ─────────────
-
-
-@router.post("/lipsync/result", response_model=GpuLipsyncResultResponse)
-async def report_result(
-    request: Request,
-    task_id: str = Form(...),
-    worker_id: str = Form(...),
-    success: bool = Form(True),
-    duration_seconds: float = Form(0.0),
-    error_msg: str = Form(""),
-    result: Optional[UploadFile] = File(None),
-    svc: GpuLipsyncService = Depends(_get_svc),
-    _token: str = Depends(_verify_gpu_token),
-):
-    # 参数校验：
-    # - success=true + result 文件 → API 代为上传到 OSS（方便 Worker 端实现）
-    # - success=true + 无文件 → Worker 已经自己 PUT 到预签名 upload_url，直接确认
-    # - success=false → 不上传文件，错误信息通过 error_msg 传递
-    if success and result is not None:
-        # 把文件落盘到临时目录，然后 PUT 到预签名 URL
-        storage = get_storage_service()
-        result_key = svc._result_key(task_id)
-        upload_url = storage.get_upload_url(result_key, expires_seconds=3600, content_type="video/mp4")
-        try:
-            with tempfile.TemporaryDirectory(prefix="gpu_result_") as tmpdir:
-                tmp_path = Path(tmpdir) / "result.mp4"
-                content = await result.read()
-                if not content:
-                    raise HTTPException(status_code=400, detail="上传的 result 文件为空")
-                tmp_path.write_bytes(content)
-                headers = {"Content-Type": "video/mp4"}
-                with open(tmp_path, "rb") as f:
-                    resp = requests.put(upload_url, data=f, headers=headers, timeout=300)
-                if resp.status_code >= 400:
-                    logger.error(
-                        "上传 GPU 结果到 OSS 失败: status=%d body=%s",
-                        resp.status_code,
-                        resp.text[:500],
-                    )
-                    raise HTTPException(
-                        status_code=502,
-                        detail=f"上传结果视频到 OSS 失败 (HTTP {resp.status_code})",
-                    )
-        except HTTPException:
-            raise
-        except Exception as exc:
-            logger.exception("上传 GPU 结果视频异常: %s", exc)
-            raise HTTPException(status_code=500, detail=f"上传结果视频异常: {exc}") from exc
-    elif not success:
-        # 失败时忽略 result 文件（即便传了也没用）
-        pass
-    # 其他情况：success=true 且无文件 → Worker 已自行 PUT 到预签名 URL，直接标记完成
-
-    try:
-        task = svc.report_result(
-            task_id=task_id,
-            worker_id=worker_id,
-            success=success,
-            duration_seconds=duration_seconds,
-            error_msg=error_msg,
-        )
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    return GpuLipsyncResultResponse(
-        ok=True,
-        task_id=task.id,
-        status=task.status,
-        message="ok",
-    )
-
-
-# ── GET /lipsync/status/{task_id} — 业务侧查询状态 ─────────────────
-# 说明：此接口会被 lipsync_service 内部在业务流程里直接读 DB，不通过 HTTP。
-# 但仍暴露一个简单查询接口，方便调试和前端轮询（如后续需要）。暂不做用户权限校验，
-# task_id 本身是 UUID，不可枚举。
-
-
-@router.get("/lipsync/status/{task_id}", response_model=GpuLipsyncStatusResponse)
-def get_task_status(
-    task_id: str,
-    svc: GpuLipsyncService = Depends(_get_svc),
-):
-    task = svc.get_task(task_id)
-    if task is None:
-        raise HTTPException(status_code=404, detail="task not found")
-    return GpuLipsyncStatusResponse(
-        task_id=task.id,
-        status=task.status,
-        result_url=task.result_url,
-        result_duration=task.result_duration,
-        error_msg=task.error_msg,
-        worker_id=task.worker_id,
-        attempt=task.attempt,
-        created_at=task.created_at,
-        started_at=task.started_at,
-        finished_at=task.finished_at,
-    )

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

@@ -12,7 +12,6 @@ from datetime import datetime, timedelta, timezone
 from typing import Optional
 
 from app.auth import AuthenticatedUser, get_current_user
-from app.config import settings
 from app.dependencies import get_db_session
 from app.schemas.points import (
     DailyUsageResponse,
@@ -45,12 +44,6 @@ from packages.domain.points_service import PointsService
 
 logger = logging.getLogger(__name__)
 
-
-def _credits_enabled() -> bool:
-    """积分系统总开关（ENABLE_CREDIT_SYSTEM），关闭时全部功能免费放行。"""
-    return bool(getattr(settings, "points_enabled", False))
-
-
 # ── 两个 router ──
 points_router = APIRouter()
 usage_router = APIRouter()
@@ -179,19 +172,6 @@ def check_points(
                 "valid_scenes": sorted(POINTS_SCENES.keys()),
             },
         )
-
-    # 积分系统暂停（ENABLE_CREDIT_SYSTEM=false）：所有场景直接放行，需 0 积分
-    if not _credits_enabled():
-        svc = _get_service()
-        account = svc.get_or_create_account(current_user.user.id, db)
-        return PointsCheckResponse(
-            allowed=True,
-            required_points=0,
-            current_balance=account["balance"],
-            remaining_after=account["balance"],
-            is_free_quota=False,
-        )
-
     is_mem = _is_member(current_user)
     mt = _member_type(current_user)
 
@@ -229,19 +209,8 @@ def deduct_points(
     current_user: AuthenticatedUser = Depends(get_current_user),
     db: Session = Depends(get_db_session),
 ):
-    """积分扣减（内部服务调用）。
-
-    积分系统暂停（ENABLE_CREDIT_SYSTEM=false）时为 no-op：不扣分、余额不变，
-    直接返回成功，保证内部调用方拿到 success=True 继续业务流程。
-    """
+    """积分扣减（内部服务调用）。"""
     svc = _get_service()
-    if not _credits_enabled():
-        account = svc.get_or_create_account(current_user.user.id, db)
-        return SimpleMessageResponse(
-            success=True,
-            message="积分系统已暂停，未扣减积分",
-            data={"transaction_id": "", "balance": account["balance"]},
-        )
     result = svc.deduct_points(
         user_id=current_user.user.id,
         amount=body.amount,
@@ -274,7 +243,11 @@ def refund_points(
     """积分退还（内部服务调用）。"""
     from packages.adapters.sqlalchemy_impl.models import PointsTransactionModel
 
-    txn = db.query(PointsTransactionModel).filter(PointsTransactionModel.id == body.transaction_id).first()
+    txn = (
+        db.query(PointsTransactionModel)
+        .filter(PointsTransactionModel.id == body.transaction_id)
+        .first()
+    )
     if txn is None:
         raise HTTPException(status_code=404, detail="交易记录不存在")
     if txn.user_id != current_user.user.id:

apps/api/app/schemas/gpu_lipsync.py

@@ -1,111 +0,0 @@
-"""GPU MuseTalk 反向轮询 API Schema 定义.
-
-面向部署在用户 RTX2060 本地的 GPU Worker 脚本，不面向前端用户。
-Worker 用长期 GPU_WORKER_TOKEN 鉴权（不是用户 JWT）。
-"""
-
-from __future__ import annotations
-
-from datetime import datetime
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-# ── Worker 注册/心跳 ──────────────────────────────────────────────
-
-
-class GpuWorkerRegisterRequest(BaseModel):
-    """Worker 启动/心跳时上报自身信息."""
-
-    worker_id: str = Field(..., min_length=1, max_length=100, description="Worker 唯一 ID（机器名+UUID 等）")
-    hostname: str = Field("", max_length=200, description="主机名，用于运维排查")
-    gpu_name: str = Field("", max_length=200, description="GPU 型号，如 'NVIDIA GeForce RTX 2060'")
-    free_vram_mb: int = Field(0, ge=0, description="当前空闲显存（MB）")
-    capabilities: str = Field("musetalk", max_length=500, description="能力列表，逗号分隔，如 'musetalk'")
-    task_id: Optional[str] = Field(
-        None,
-        max_length=64,
-        description=(
-            "当前正在处理的任务 ID。Worker 推理期间定期心跳时携带，"
-            "服务端同步刷新该任务 last_heartbeat_at，防止长推理被误判超时；空闲时不传"
-        ),
-    )
-
-
-class GpuWorkerRegisterResponse(BaseModel):
-    ok: bool = True
-    server_time: datetime
-    message: str = "ok"
-
-
-# ── 轮询任务 ────────────────────────────────────────────────────
-
-
-class GpuLipsyncTaskPayload(BaseModel):
-    """下发给 Worker 的任务载荷（含预签名下载 URL）."""
-
-    task_id: str
-    video_url: str = Field(..., description="人物视频预签名下载 URL（GET）")
-    audio_url: str = Field(..., description="驱动音频预签名下载 URL（GET）")
-    lipsync_job_id: str = ""
-    user_id: str = ""
-    project_id: str = ""
-    created_at: datetime
-    upload_url: str = Field(..., description="结果视频预签名上传 URL（PUT, video/mp4）")
-    upload_method: str = Field("PUT", description="上传方式，目前只支持 PUT")
-    expires_at: datetime
-
-
-class GpuLipsyncPollResponse(BaseModel):
-    """Worker poll 的返回：200 带任务，204 无任务."""
-
-    task: Optional[GpuLipsyncTaskPayload] = None
-
-
-# ── Worker 上报结果 ──────────────────────────────────────────────
-
-
-class GpuLipsyncResultRequest(BaseModel):
-    """Worker 通过 multipart 上传结果时携带的字段（非文件字段）."""
-
-    task_id: str = Field(..., min_length=1, max_length=64)
-    worker_id: str = Field(..., min_length=1, max_length=100)
-    success: bool = Field(True, description="true=成功（此时必须上传 result 视频文件）；false=失败")
-    duration_seconds: float = Field(0.0, ge=0, description="合成后视频时长（秒），成功时应填入")
-    error_msg: str = Field("", max_length=2000, description="失败原因，success=false 时必填")
-
-
-class GpuLipsyncResultResponse(BaseModel):
-    ok: bool = True
-    task_id: str
-    status: str  # done / failed
-    message: str = "ok"
-
-
-# ── 业务侧查询任务状态 ────────────────────────────────────────────
-
-
-class GpuLipsyncStatusResponse(BaseModel):
-    task_id: str
-    status: str
-    result_url: str = ""
-    result_duration: float = 0.0
-    error_msg: str = ""
-    worker_id: str = ""
-    attempt: int = 0
-    created_at: datetime
-    started_at: Optional[datetime] = None
-    finished_at: Optional[datetime] = None
-
-
-# ── 创建任务（内部服务调用） ──────────────────────────────────────
-
-
-class GpuLipsyncCreateRequest(BaseModel):
-    """服务层内部创建 GPU 任务用（不通过 HTTP 暴露给 Worker/前端）."""
-
-    video_url: str  # 已可访问的 OSS key 或公网 URL（API 侧会转预签名）
-    audio_url: str
-    lipsync_job_id: str = ""
-    user_id: str = ""
-    project_id: str = ""

apps/api/app/services/gpu_lipsync_service.py

@@ -1,382 +0,0 @@
-"""GPU MuseTalk 口型同步服务 — 反向轮询模式.
-
-职责：
-1. 创建任务（由 lipsync 业务流程调用），为输入/输出生成预签名 URL，任务入队；
-2. Worker 心跳注册（register）：登记/刷新 worker 状态；
-3. Worker 轮询拉任务（poll）：原子地 CLAIM 一条 pending 任务，返回预签名 URL；
-4. Worker 上报结果（report_result）：标记 done/failed，失败可重试；
-5. 业务侧查询状态（get_status）。
-"""
-
-from __future__ import annotations
-
-import logging
-import uuid
-from datetime import UTC, datetime, timedelta
-from typing import Optional
-
-from app.core.storage import get_storage_service
-from sqlalchemy.orm import Session
-
-from packages.adapters.sqlalchemy_impl.models import GpuLipsyncTaskModel, GpuWorkerModel
-from packages.config import get_api_settings
-
-logger = logging.getLogger(__name__)
-
-# 任务在 processing 超过此时长仍未完成 → 超时回退 pending 或置 failed
-MAX_ATTEMPTS = 3
-
-
-class GpuLipsyncService:
-    """GPU 口型同步服务（无状态方法，每次调用从 DI 拿 db/storage）."""
-
-    RESULT_PREFIX = "gpu-lipsync/results/"
-    INPUT_SIGN_EXPIRES_PAD = 600  # 输入预签名 URL 在任务超时基础上再加 10min 余量
-
-    # ── 公共入口 ────────────────────────────────────────────────────
-
-    def __init__(self, db: Session):
-        self.db = db
-        self.settings = get_api_settings()
-        self.storage = get_storage_service()
-
-    # ── Worker 注册/心跳 ────────────────────────────────────────────
-
-    def register_worker(
-        self,
-        worker_id: str,
-        hostname: str = "",
-        gpu_name: str = "",
-        free_vram_mb: int = 0,
-        capabilities: str = "musetalk",
-        task_id: Optional[str] = None,
-    ) -> GpuWorkerModel:
-        """Worker 注册/心跳。
-
-        task_id 非空时（Worker 推理期间的任务级心跳），同步把对应 processing
-        任务的 last_heartbeat_at 续到当前时间，使长推理不会被
-        ``_recover_timed_out_tasks`` 误回退。任务已结束 / 不属于该 worker
-        （如已被超时回收重新派发）时忽略，不报错。
-        """
-        now = datetime.now(UTC)
-        worker = self.db.query(GpuWorkerModel).filter(GpuWorkerModel.worker_id == worker_id).one_or_none()
-        if worker is None:
-            worker = GpuWorkerModel(
-                worker_id=worker_id,
-                hostname=hostname,
-                gpu_name=gpu_name,
-                free_vram_mb=free_vram_mb,
-                capabilities=capabilities,
-                last_heartbeat_at=now,
-                created_at=now,
-            )
-            self.db.add(worker)
-        else:
-            worker.hostname = hostname or worker.hostname
-            worker.gpu_name = gpu_name or worker.gpu_name
-            worker.free_vram_mb = free_vram_mb
-            worker.capabilities = capabilities or worker.capabilities
-            worker.last_heartbeat_at = now
-        if task_id:
-            self._touch_task_heartbeat(task_id, worker_id, now)
-        self.db.commit()
-        return worker
-
-    # ── 轮询拉任务（Worker 调用） ──────────────────────────────────
-
-    def poll_task(self, worker_id: str) -> Optional[GpuLipsyncTaskModel]:
-        """原子地认领一条最早的 pending 任务，返回给 worker；无任务返回 None.
-
-        同时会：
-        - 把 processing 状态且真正超时（任务心跳停滞超过
-          gpu_task_timeout_seconds；Worker 推理期会通过 register(task_id=...)
-          续心跳，长推理不会误判）的任务回退为 pending（attempt++，超过
-          MAX_ATTEMPTS 置 failed），让其它 worker 认领。
-        - 刷新 worker 心跳。
-        """
-        now = datetime.now(UTC)
-        self._recover_timed_out_tasks(now)
-        # 更新 worker 心跳
-        self._touch_worker(worker_id, now)
-
-        # 选一条最早 pending 任务（FOR UPDATE SKIP LOCKED 语义：简单起见先查再锁状态）
-        task = (
-            self.db.query(GpuLipsyncTaskModel)
-            .filter(GpuLipsyncTaskModel.status == "pending")
-            .order_by(GpuLipsyncTaskModel.created_at.asc())
-            .first()
-        )
-        if task is None:
-            self.db.commit()
-            return None
-
-        # 原子 claim：用 UPDATE WHERE status=pending 避免并发
-        upd_rows = (
-            self.db.query(GpuLipsyncTaskModel)
-            .filter(
-                GpuLipsyncTaskModel.id == task.id,
-                GpuLipsyncTaskModel.status == "pending",
-            )
-            .update(
-                {
-                    GpuLipsyncTaskModel.status: "processing",
-                    GpuLipsyncTaskModel.worker_id: worker_id,
-                    GpuLipsyncTaskModel.started_at: now,
-                    GpuLipsyncTaskModel.last_heartbeat_at: now,
-                    GpuLipsyncTaskModel.attempt: GpuLipsyncTaskModel.attempt + 1,
-                    GpuLipsyncTaskModel.updated_at: now,
-                },
-                synchronize_session=False,
-            )
-        )
-        self.db.commit()
-        if upd_rows == 0:
-            # 被其它 worker 抢先了
-            return None
-        self.db.refresh(task)
-        # 生成预签名输入/输出 URL（在 claim 时动态生成，避免长时间过期）
-        expires = self.settings.gpu_task_timeout_seconds + self.INPUT_SIGN_EXPIRES_PAD
-        task._signed_video_url = self.storage.get_download_url(task.video_url, expires_seconds=expires)
-        task._signed_audio_url = self.storage.get_download_url(task.audio_url, expires_seconds=expires)
-        task._signed_upload_url = self.storage.get_upload_url(
-            self._result_key(task.id),
-            expires_seconds=expires,
-            content_type="video/mp4",
-        )
-        task._upload_expires_at = now + timedelta(seconds=expires)
-        return task
-
-    # ── 上报结果 ──────────────────────────────────────────────────
-
-    def report_result(
-        self,
-        task_id: str,
-        worker_id: str,
-        success: bool,
-        duration_seconds: float = 0.0,
-        error_msg: str = "",
-    ) -> GpuLipsyncTaskModel:
-        task = self.db.get(GpuLipsyncTaskModel, task_id)
-        if task is None:
-            raise KeyError(f"task {task_id} not found")
-        now = datetime.now(UTC)
-        if success:
-            task.status = "done"
-            task.result_url = self._result_key(task_id)
-            task.result_duration = duration_seconds or 0.0
-            task.error_msg = ""
-            task.finished_at = now
-        else:
-            # 失败：若仍可重试（已尝试次数 < MAX_ATTEMPTS）→ 回退 pending；否则 → failed
-            if task.attempt < MAX_ATTEMPTS:
-                task.status = "pending"
-                task.worker_id = ""
-                task.started_at = None
-                task.error_msg = error_msg[:2000]
-                logger.warning(
-                    "GPU 任务 %s 在 worker %s 上失败，回退 pending 等待重试（attempt=%d）: %s",
-                    task_id,
-                    worker_id,
-                    task.attempt,
-                    error_msg[:200],
-                )
-            else:
-                task.status = "failed"
-                task.error_msg = error_msg[:2000]
-                task.finished_at = now
-                logger.error(
-                    "GPU 任务 %s 失败达到最大重试次数 %d，置为 failed: %s",
-                    task_id,
-                    MAX_ATTEMPTS,
-                    error_msg[:200],
-                )
-        task.updated_at = now
-        task.last_heartbeat_at = now
-        self._touch_worker(worker_id, now)
-        self.db.commit()
-        self.db.refresh(task)
-        return task
-
-    # ── 业务侧查询 ────────────────────────────────────────────────
-
-    def get_task(self, task_id: str) -> Optional[GpuLipsyncTaskModel]:
-        return self.db.get(GpuLipsyncTaskModel, task_id)
-
-    def get_by_lipsync_job(self, lipsync_job_id: str) -> Optional[GpuLipsyncTaskModel]:
-        return (
-            self.db.query(GpuLipsyncTaskModel)
-            .filter(GpuLipsyncTaskModel.lipsync_job_id == lipsync_job_id)
-            .order_by(GpuLipsyncTaskModel.created_at.desc())
-            .first()
-        )
-
-    # ── 创建任务（业务侧调用） ────────────────────────────────────
-
-    def create_task(
-        self,
-        video_url: str,
-        audio_url: str,
-        lipsync_job_id: str = "",
-        user_id: str = "",
-        project_id: str = "",
-    ) -> GpuLipsyncTaskModel:
-        task_id = str(uuid.uuid4())
-        now = datetime.now(UTC)
-        task = GpuLipsyncTaskModel(
-            id=task_id,
-            lipsync_job_id=lipsync_job_id,
-            user_id=user_id,
-            project_id=project_id,
-            video_url=video_url,
-            audio_url=audio_url,
-            status="pending",
-            attempt=0,
-            created_at=now,
-            updated_at=now,
-        )
-        self.db.add(task)
-        self.db.commit()
-        self.db.refresh(task)
-        logger.info(
-            "创建 GPU 口型任务 %s (lipsync_job=%s, user=%s)",
-            task_id,
-            lipsync_job_id,
-            user_id,
-        )
-        return task
-
-    # ── 内部辅助 ──────────────────────────────────────────────────
-
-    def _result_key(self, task_id: str) -> str:
-        return f"{self.RESULT_PREFIX}{task_id}.mp4"
-
-    def _touch_task_heartbeat(self, task_id: str, worker_id: str, now: datetime) -> None:
-        """Worker 推理期间的任务级心跳：只刷新属于该 worker 且仍在 processing 的任务。
-
-        任务不存在 / 已被超时回收重新派发 / 已完成 → 静默忽略（此时旧 worker 的
-        结果上报会被结果接口按最终态处理）。
-        """
-        task = self.db.get(GpuLipsyncTaskModel, task_id)
-        if task is None:
-            return
-        if task.status != "processing" or task.worker_id != worker_id:
-            logger.info(
-                "忽略过期任务心跳 task=%s worker=%s（status=%s owner=%s）",
-                task_id,
-                worker_id,
-                task.status,
-                task.worker_id,
-            )
-            return
-        task.last_heartbeat_at = now
-        task.updated_at = now
-        self.db.flush()
-
-    def _touch_worker(self, worker_id: str, now: datetime) -> None:
-        if not worker_id:
-            return
-        worker = self.db.query(GpuWorkerModel).filter(GpuWorkerModel.worker_id == worker_id).one_or_none()
-        if worker is not None:
-            worker.last_heartbeat_at = now
-            self.db.flush()
-        else:
-            # 自注册（poll 时允许自动建一个空 worker 记录，运维可见）
-            worker = GpuWorkerModel(
-                worker_id=worker_id,
-                hostname="",
-                gpu_name="",
-                free_vram_mb=0,
-                capabilities="musetalk",
-                last_heartbeat_at=now,
-                created_at=now,
-            )
-            self.db.add(worker)
-            self.db.flush()
-
-    def _recover_timed_out_tasks(self, now: datetime) -> None:
-        """扫描 processing 状态且真正超时的任务，回退 pending 或失败。
-
-        判定只看任务自身 last_heartbeat_at：claim 时写入，Worker 推理期间通过
-        /gpu/register(task_id=...) 每 30s 续期。因此仅在 Worker 崩溃/断网
-        （任务心跳停滞超过 gpu_task_timeout_seconds）时才回收，
-        不会因 Worker 主循环忙于推理而误回退。
-        """
-        timeout = self.settings.gpu_task_timeout_seconds
-        cutoff = now - timedelta(seconds=timeout)
-        stuck_tasks = (
-            self.db.query(GpuLipsyncTaskModel)
-            .filter(
-                GpuLipsyncTaskModel.status == "processing",
-                GpuLipsyncTaskModel.last_heartbeat_at < cutoff,
-            )
-            .all()
-        )
-        for t in stuck_tasks:
-            if t.attempt >= MAX_ATTEMPTS:
-                t.status = "failed"
-                t.error_msg = f"worker 心跳超时（{timeout}s），重试次数已耗尽"
-                t.finished_at = now
-            else:
-                t.status = "pending"
-                t.worker_id = ""
-                t.started_at = None
-                t.error_msg = f"worker 心跳超时（{timeout}s），等待重试"
-                logger.warning("GPU 任务 %s 心跳超时，回退 pending（attempt=%d）", t.id, t.attempt)
-            t.updated_at = now
-        if stuck_tasks:
-            self.db.flush()
-
-    # ── 业务侧辅助 ──────────────────────────────────────────────────
-
-    def has_available_worker(self) -> bool:
-        """判断是否有 Worker 在心跳新鲜窗口内可用."""
-        stale_cutoff = datetime.now(UTC) - timedelta(seconds=self.settings.gpu_worker_stale_seconds)
-        return (
-            self.db.query(GpuWorkerModel).filter(GpuWorkerModel.last_heartbeat_at >= stale_cutoff).first() is not None
-        )
-
-    def wait_for_result(
-        self,
-        task_id: str,
-        timeout_seconds: Optional[int] = None,
-        poll_interval: Optional[float] = None,
-    ) -> Optional[GpuLipsyncTaskModel]:
-        """同步轮询等待 GPU 任务完成。
-
-        Args:
-            task_id: 任务 ID（由 create_task 返回）
-            timeout_seconds: 总超时，默认取 settings.gpu_lipsync_wait_timeout
-            poll_interval: 轮询间隔秒，默认取 settings.gpu_lipsync_poll_interval
-
-        Returns:
-            终态 task（status=done/failed）；超时返回 None（此时调用方应回退 MediaKit）。
-            等待期间会自动调用 _recover_timed_out_tasks 做超时回收。
-        """
-        import time
-
-        timeout = timeout_seconds if timeout_seconds is not None else self.settings.gpu_lipsync_wait_timeout
-        interval = poll_interval if poll_interval is not None else self.settings.gpu_lipsync_poll_interval
-        deadline = time.monotonic() + timeout
-
-        while True:
-            now = datetime.now(UTC)
-            # 顺手回收超时任务
-            try:
-                self._recover_timed_out_tasks(now)
-                self.db.commit()
-            except Exception as exc:  # noqa: BLE001 - 回收失败不阻塞主流程
-                logger.warning("wait_for_result 回收超时任务异常: %s", exc)
-                self.db.rollback()
-
-            task = self.db.get(GpuLipsyncTaskModel, task_id)
-            if task is None:
-                return None
-            if task.status == "done":
-                return task
-            if task.status == "failed":
-                return task
-            # pending/processing 继续等
-            if time.monotonic() >= deadline:
-                logger.warning("GPU 任务 %s 等待超时（%ds），回退 MediaKit", task_id, timeout)
-                return None
-            time.sleep(interval)

apps/api/app/services/lipsync_service.py

@@ -29,7 +29,6 @@ from app.services.mediakit_client import (
     MediaKitError,
     get_mediakit_client,
 )
-from app.tasks.lipsync_gpu import lipsync_gpu_process_async
 
 # Celery 异步任务：TTS 合成 + MediaKit 提交（降级路径）
 from app.tasks.lipsync_tts import tts_synthesize_and_submit
@@ -37,7 +36,6 @@ 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.sentence_timings import (
     compute_sentence_timings,
     probe_audio_duration,
@@ -65,7 +63,6 @@ class LipsyncService:
         self.client = client or get_mediakit_client()
         self._cosyvoice = cosyvoice_service
         self._voice_clone_repo = voice_clone_repo
-        self.settings = get_api_settings()
 
     def _get_cosyvoice(self):
         """延迟获取 CosyVoiceService（与 tts 路由一致，含 OSS 预签名配置）."""
@@ -218,57 +215,7 @@ class LipsyncService:
         if timings:
             job.sentence_timings = timings
 
-        # 4. 检查是否走 GPU 路径：开关打开 + 有可用 Worker
-        use_gpu = False
-        if self.settings.use_gpu_lipsync:
-            try:
-                from app.services.gpu_lipsync_service import GpuLipsyncService
-
-                gpu_svc = GpuLipsyncService(self.db)
-                if gpu_svc.has_available_worker():
-                    use_gpu = True
-                    logger.info("[lipsync] 检测到可用 GPU Worker，优先走 MuseTalk 本地推理: job_id=%s", job.id)
-                else:
-                    logger.info("[lipsync] GPU 开关已开但无可用 Worker（心跳过期），回退 MediaKit: job_id=%s", job.id)
-            except Exception as exc:
-                logger.warning("[lipsync] GPU 服务初始化失败，回退 MediaKit: job_id=%s err=%s", job.id, exc)
-
-        if use_gpu:
-            try:
-                gpu_task = self._submit_to_gpu_create(job=job, gpu_svc=gpu_svc)
-                if gpu_task is not None:
-                    # GPU 任务已创建，设为 processing 并异步等待结果
-                    job.mediakit_task_id = f"gpu:{gpu_task.id}"
-                    job.status = "processing"
-                    job.updated_at = datetime.now(UTC)
-                    self.db.commit()
-                    # 派发 Celery 异步任务处理 GPU 等待+结果回写
-                    try:
-                        lipsync_gpu_process_async.apply_async(args=(job.id, job.user_id, gpu_task.id))
-                        logger.info(
-                            "[lipsync] GPU 任务已异步派发: job_id=%s gpu_task=%s",
-                            job.id,
-                            gpu_task.id,
-                        )
-                    except Exception as celery_exc:
-                        logger.warning(
-                            "[lipsync] Celery 派发失败，降级同步等待: job_id=%s err=%s",
-                            job.id,
-                            celery_exc,
-                        )
-                        self._submit_to_gpu_wait(job=job, gpu_svc=gpu_svc, gpu_task=gpu_task)
-                    return
-                # create 失败 → 回退 MediaKit
-                logger.warning("[lipsync] GPU 任务创建失败，回退 MediaKit: job_id=%s", job.id)
-                self.db.rollback()
-            except Exception as exc:
-                logger.exception("[lipsync] GPU 路径异常，回退 MediaKit: job_id=%s err=%s", job.id, exc)
-                try:
-                    self.db.rollback()
-                except Exception:
-                    pass
-
-        # 5. 签名 URL 并提交 MediaKit（兜底路径）
+        # 4. 签名 URL 并提交 MediaKit
         video_url = self._sign_media_url(job.video_url)
         signed_audio_url = self._sign_media_url(job.audio_url)
         job.audio_url = signed_audio_url
@@ -297,120 +244,6 @@ class LipsyncService:
             self.db.commit()
             raise
 
-    # ── GPU MuseTalk 路径 ────────────────────────────────────────────────
-
-    def _is_own_oss_url(self, url: str, storage) -> bool:
-        """判断 URL / 存储 key 是否属于自家 OSS。
-
-        - 裸存储 key（无 scheme）：自家对象
-        - host 与 storage.public_url host 一致：自家对象
-        - 其余 http(s) 公网链接（如 dashscope-result 临时地址）：外部对象
-        """
-        if not url:
-            return False
-        parsed = urlparse(url)
-        if not parsed.scheme:
-            return True  # 裸存储 key
-        public_base = getattr(storage, "public_url", "")
-        own_host = urlparse(public_base).netloc.lower() if public_base else ""
-        return bool(own_host) and parsed.netloc.lower() == own_host
-
-    def _persist_external_audio_for_gpu(self, *, job, storage) -> Optional[str]:
-        """GPU 任务创建前，把外部域名的预合成 TTS 音频转存到自家 OSS。
-
-        Worker 部署在用户家庭网络，dashscope-result 等第三方临时 OSS 地址
-        可能无法访问；转存后 gpu_svc 在 poll 时会签自家预签名 URL 给 Worker。
-        已是自家 OSS 对象（含裸 key）直接返回 None（无需转存）；
-        转存失败返回 None，调用方回退使用原始 URL（最坏情况是 Worker 拉取失败，
-        服务端重试耗尽后回退 MediaKit，不阻断业务）。
-        """
-        if self._is_own_oss_url(job.audio_url, storage):
-            return None
-        try:
-            audio_data = safe_download_bytes(
-                job.audio_url,
-                purpose="lipsync_gpu_tts_audio",
-                allowed_mime_types=ALLOWED_AUDIO_MIME_TYPES,
-                timeout=60.0,
-            )
-            storage_key = f"lipsync-tts/{job.user_id}/{job.id}.mp3"
-            permanent_url = storage.upload_file(io.BytesIO(audio_data), storage_key, content_type="audio/mpeg")
-            logger.info(
-                "[lipsync] GPU 任务外部音频已转存自家 OSS: job_id=%s key=%s",
-                job.id,
-                storage_key,
-            )
-            return permanent_url
-        except Exception as exc:
-            logger.warning(
-                "[lipsync] GPU 任务外部音频转存 OSS 失败，回退原始 URL: job_id=%s err=%s",
-                job.id,
-                exc,
-            )
-            return None
-
-    def _submit_to_gpu_create(self, *, job, gpu_svc) -> Optional[object]:
-        """创建 GPU 任务并立即返回（异步模式）。
-
-        成功返回 gpu_task 对象；创建失败返回 None。
-        不再同步等待结果，结果由 Celery 异步任务 lipsync_gpu_process_async 回写。
-        """
-        storage = get_shared_storage_service()
-        persisted_audio_url = self._persist_external_audio_for_gpu(job=job, storage=storage)
-        audio_url_for_task = persisted_audio_url or job.audio_url
-        gpu_task = gpu_svc.create_task(
-            video_url=job.video_url,
-            audio_url=audio_url_for_task,
-            lipsync_job_id=job.id,
-            user_id=job.user_id,
-            project_id=job.project_id,
-        )
-        logger.info(
-            "[lipsync] 已创建 GPU 任务（异步）: job_id=%s gpu_task=%s",
-            job.id,
-            gpu_task.id,
-        )
-        return gpu_task
-
-    def _submit_to_gpu_wait(self, *, job, gpu_svc, gpu_task) -> None:
-        """同步等待 GPU 结果（Celery 派发失败时的降级路径）。"""
-        final_task = gpu_svc.wait_for_result(gpu_task.id)
-        if final_task is None:
-            logger.warning("[lipsync] GPU 同步等待超时，回退 MediaKit: gpu_task=%s", gpu_task.id)
-            return
-        if final_task.status != "done":
-            logger.warning(
-                "[lipsync] GPU 同步等待失败: gpu_task=%s status=%s",
-                gpu_task.id,
-                final_task.status,
-            )
-            return
-        try:
-            storage = get_shared_storage_service()
-            signed_result_url = storage.get_download_url(
-                final_task.result_url, expires_seconds=MEDIAKIT_URL_TTL_SECONDS
-            )
-            if signed_result_url:
-                final_task.result_url = signed_result_url
-        except Exception as exc:
-            logger.warning(
-                "[lipsync] GPU 结果签名失败: gpu_task=%s err=%s",
-                gpu_task.id,
-                exc,
-            )
-        job.mediakit_task_id = ""
-        job.status = STATUS_COMPLETED
-        job.output_video_url = final_task.result_url
-        job.output_duration = final_task.result_duration or 0.0
-        job.completed_at = datetime.now(UTC)
-        job.updated_at = datetime.now(UTC)
-        self.db.commit()
-        logger.info(
-            "[lipsync] GPU 同步等待完成: job_id=%s duration=%.2f",
-            job.id,
-            job.output_duration,
-        )
-
     # ── 创建任务 ──────────────────────────────────────────────────────────
 
     def create_job(
@@ -645,29 +478,6 @@ class LipsyncService:
         if job.status in (STATUS_COMPLETED, "failed"):
             return job
 
-        # GPU 异步路径：mediakit_task_id 以 "gpu:" 开头，由 Celery 任务异步更新
-        # 不做 MediaKit 轮询，只检查是否卡住太久（>30 分钟）则标失败
-        if job.mediakit_task_id and job.mediakit_task_id.startswith("gpu:"):
-            if job.status in ("processing", "gpu_processing"):
-                _now = datetime.now(UTC)
-                _upd = job.updated_at
-                if _upd is not None and _upd.tzinfo is None:
-                    _upd = _upd.replace(tzinfo=UTC)
-                stale_minutes = 30
-                if _upd and (_now - _upd).total_seconds() > stale_minutes * 60:
-                    logger.warning(
-                        "GPU 异步任务超时（>%d 分钟），标记失败: job_id=%s",
-                        stale_minutes,
-                        job_id,
-                    )
-                    job.status = "failed"
-                    job.error_message = f"GPU 处理超时（>{stale_minutes} 分钟）"
-                    job.error_code = "GpuTimeout"
-                    job.completed_at = _now
-                    job.updated_at = _now
-                    self.db.commit()
-            return job
-
         # 未提交的任务不轮询
         if not job.mediakit_task_id:
             return job

apps/api/app/tasks/lipsync_gpu.py

@@ -1,190 +0,0 @@
-"""GPU MuseTalk 异步推理任务 — 将 GPU 推理等待从 HTTP 请求移至 Celery 后台执行.
-
-优化目标：将 POST /lipsync/jobs 的 API 响应时间从 >200s 降到 <1s。
-任务流程：
-1. 加载 LipsyncJob，获取 gpu_task_id
-2. 调用 GpuLipsyncService.wait_for_result 轮询等待 GPU 完成
-3. 签名结果 URL（7 天），更新 job 为 completed
-4. 失败/超时时：尝试 MediaKit 兜底，若仍失败则标记 job 为 failed
-
-使用 @shared_task 确保被 Worker 侧 celery_app 正确注册。
-"""
-
-import logging
-from datetime import UTC, datetime
-
-from celery import shared_task
-from sqlalchemy.orm import Session
-
-from packages.adapters.sqlalchemy_impl.models import LipsyncJobModel
-from packages.shared.storage import get_shared_storage_service
-
-logger = logging.getLogger(__name__)
-
-# 与 LipsyncService 保持一致
-_MEDIAKIT_URL_TTL_SECONDS = 7 * 24 * 3600
-
-
-def _get_db_session() -> Session:
-    """获取 DB session（兼容 API 和 Worker 两种运行时）."""
-    try:
-        from worker_app.db import SessionLocal  # type: ignore
-    except ImportError:
-        from app.db import SessionLocal  # type: ignore
-    return SessionLocal()
-
-
-def _sign_media_url(url: str) -> str:
-    """对自家 OSS URL 签 7 天预签名。"""
-    if not url:
-        return url
-    try:
-        from urllib.parse import urlparse
-
-        storage = get_shared_storage_service()
-        public_base = getattr(storage, "public_url", "")
-        if not isinstance(public_base, str) or not public_base:
-            return url
-        own_host = urlparse(public_base).netloc.lower()
-        host = urlparse(url).netloc.lower()
-        if not own_host or host != own_host:
-            return url
-        return storage.get_download_url(url, expires_seconds=_MEDIAKIT_URL_TTL_SECONDS)
-    except Exception:
-        return url
-
-
-@shared_task(
-    name="lipsync_gpu_process_async",
-    bind=True,
-    max_retries=0,
-    acks_late=True,
-)
-def lipsync_gpu_process_async(self, job_id: str, user_id: str, gpu_task_id: str) -> None:
-    """异步处理 GPU MuseTalk 推理。
-
-    Args:
-        job_id: LipsyncJob 的 ID
-        user_id: 用户 ID
-        gpu_task_id: GpuLipsyncTask 的 ID
-    """
-    db: Session = _get_db_session()
-    try:
-        job = db.query(LipsyncJobModel).filter_by(id=job_id, user_id=user_id).first()
-        if job is None:
-            logger.error("[lipsync_gpu_async] job 不存在: job_id=%s", job_id)
-            return
-
-        # 确保状态为 processing
-        if job.status not in ("processing", "gpu_processing"):
-            logger.warning(
-                "[lipsync_gpu_async] job 状态异常，跳过: job_id=%s status=%s",
-                job_id,
-                job.status,
-            )
-            return
-
-        from app.services.gpu_lipsync_service import GpuLipsyncService
-
-        gpu_svc = GpuLipsyncService(db)
-        final_task = gpu_svc.wait_for_result(gpu_task_id)
-
-        if final_task is None:
-            logger.warning(
-                "[lipsync_gpu_async] GPU 超时，回退 MediaKit: job_id=%s gpu_task=%s",
-                job_id,
-                gpu_task_id,
-            )
-            _fallback_to_mediakit(db, job)
-            return
-
-        if final_task.status != "done":
-            logger.warning(
-                "[lipsync_gpu_async] GPU 失败，回退 MediaKit: job_id=%s gpu_task=%s status=%s",
-                job_id,
-                gpu_task_id,
-                final_task.status,
-            )
-            _fallback_to_mediakit(db, job)
-            return
-
-        # 签名结果 URL
-        result_url = final_task.result_url or ""
-        try:
-            storage = get_shared_storage_service()
-            signed = storage.get_download_url(result_url, expires_seconds=_MEDIAKIT_URL_TTL_SECONDS)
-            if signed:
-                result_url = signed
-        except Exception as exc:
-            logger.warning(
-                "[lipsync_gpu_async] 签名失败，用原 URL: job_id=%s err=%s",
-                job_id,
-                exc,
-            )
-
-        job.status = "completed"
-        job.output_video_url = result_url
-        job.output_duration = final_task.result_duration or 0.0
-        job.completed_at = datetime.now(UTC)
-        job.updated_at = datetime.now(UTC)
-        db.commit()
-        logger.info(
-            "[lipsync_gpu_async] GPU 完成: job_id=%s duration=%.2f",
-            job_id,
-            job.output_duration,
-        )
-    except Exception as exc:
-        logger.exception("[lipsync_gpu_async] 异常: job_id=%s err=%s", job_id, exc)
-        try:
-            job = db.query(LipsyncJobModel).filter_by(id=job_id).first()
-            if job:
-                job.status = "failed"
-                job.error_message = f"GPU 异步处理异常: {exc}"
-                job.error_code = "GpuAsyncError"
-                job.updated_at = datetime.now(UTC)
-                db.commit()
-        except Exception:
-            pass
-    finally:
-        db.close()
-
-
-def _fallback_to_mediakit(db: Session, job: LipsyncJobModel) -> None:
-    """GPU 失败时回退到 MediaKit 云端渲染。"""
-    try:
-        from app.services.mediakit_client import MediaKitError, get_mediakit_client
-
-        client = get_mediakit_client()
-        video_url = _sign_media_url(job.video_url)
-        audio_url = _sign_media_url(job.audio_url)
-
-        result = client.submit_lipsync(
-            video_url=video_url,
-            audio_url=audio_url,
-            enable_video_loop=job.enable_video_loop,
-            client_token=job.id,
-        )
-        job.mediakit_task_id = result["task_id"]
-        job.status = "submitted"
-        job.submitted_at = datetime.now(UTC)
-        job.updated_at = datetime.now(UTC)
-        db.commit()
-        logger.info(
-            "[lipsync_gpu_async] 已回退 MediaKit: job_id=%s task_id=%s",
-            job.id,
-            result["task_id"],
-        )
-    except MediaKitError as exc:
-        job.status = "failed"
-        job.error_message = str(exc)
-        job.error_code = exc.code
-        job.updated_at = datetime.now(UTC)
-        db.commit()
-        logger.error("[lipsync_gpu_async] MediaKit 也失败: job_id=%s err=%s", job.id, exc)
-    except Exception as exc:
-        job.status = "failed"
-        job.error_message = f"GPU+MediaKit 均失败: {exc}"
-        job.error_code = "FallbackFailed"
-        job.updated_at = datetime.now(UTC)
-        db.commit()
-        logger.error("[lipsync_gpu_async] 兜底异常: job_id=%s err=%s", job.id, exc)

apps/web/e2e/core-douyin-extract.spec.ts

@@ -1,117 +0,0 @@
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test"
-
-const PASSWORD = "SmokePass123!"
-const apiBase = process.env.E2E_API_BASE || "/api/v1"
-const apiOrigin = apiBase.endsWith("/api/v1") ? apiBase.slice(0, -"/api/v1".length) : ""
-
-async function routeBrowserApiToTestApi(page: Page) {
-  if (!apiOrigin) return
-  await page.route("**/api/v1/**", async (route) => {
-    const sourceUrl = new URL(route.request().url())
-    const response = await route.fetch({
-      url: `${apiOrigin}${sourceUrl.pathname}${sourceUrl.search}`,
-    })
-    await route.fulfill({ response })
-  })
-}
-
-async function loginWithRetry(request: APIRequestContext, email: string, password: string) {
-  for (let i = 0; i <= 2; i++) {
-    const r = await request.post(`${apiBase}/auth/login`, { data: { email, password } })
-    if (r.status() !== 429) {
-      expect(r.ok(), `login: ${await r.text()}`).toBeTruthy()
-      return (await r.json()).access_token as string
-    }
-    console.log(`[douyin] 429 retry ${i + 1}/2`)
-    await new Promise((res) => setTimeout(res, 65000))
-  }
-  throw new Error("Login retries exhausted")
-}
-
-/**
- * #1972 抖音文案提取冒烟
- *
- * 路径：文案库页面 → 点「🎬 从抖音提取」→ 粘贴分享文案 → 点「开始提取」
- * → mock /api/v1/scripts/extract-from-douyin 返回稳定文案 → 断言「新建文案」弹窗中预填了非空文案
- */
-test.describe("Douyin Script Extraction (#1972)", () => {
-  test("extract flow: open modal, paste link, text prefilled in create modal", async ({
-    page,
-    request,
-  }) => {
-    test.setTimeout(180_000)
-    await page.setViewportSize({ width: 1440, height: 900 })
-
-    const suffix = Math.random().toString(36).slice(2, 8)
-    const email = `e2e-douyin-${suffix}@example.com`
-    await request.post(`${apiBase}/auth/register`, {
-      data: { email, password: PASSWORD, username: `e2e_dy_${suffix}` },
-    })
-    const token = await loginWithRetry(request, email, PASSWORD)
-    const authHeader = { Authorization: `Bearer ${token}` }
-
-    const proj = await request.post(`${apiBase}/projects`, {
-      headers: authHeader,
-      data: { name: `Smoke Douyin ${suffix}` },
-    })
-    const projectId = (await proj.json()).id ?? (await proj.json()).project_id
-    await request.post(`${apiBase}/asset-libraries`, {
-      headers: authHeader,
-      data: { project_id: projectId, name: "Smoke", kind: "video" },
-    })
-
-    await page.addInitScript((t: string) => {
-      window.localStorage.setItem("access_token", t)
-      window.localStorage.setItem(
-        "auth-storage",
-        JSON.stringify({ state: { token: t, user: null } }),
-      )
-    }, token)
-    await routeBrowserApiToTestApi(page)
-
-    // Mock 抖音提取接口返回稳定文案
-    const extractedText = "大家好，今天给大家推荐一款超好用的产品，性价比非常高，快来看看吧！"
-    await page.route("**/api/v1/scripts/extract-from-douyin", (route) =>
-      route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({ text: extractedText, duration_seconds: 15 }),
-      }),
-    )
-    // 文案列表空态
-    await page.route(
-      (url) => url.pathname.endsWith("/scripts") && !url.pathname.includes("extract-from-douyin"),
-      (route) =>
-        route.fulfill({
-          status: 200,
-          contentType: "application/json",
-          body: JSON.stringify({ items: [], total: 0, page: 1, page_size: 20 }),
-        }),
-    )
-
-    await page.goto("/app/scripts")
-    // 文案库页面加载
-    await expect(page.getByText(/文案库|文案/).first()).toBeVisible({ timeout: 30000 })
-
-    // 点「🎬 从抖音提取」按钮
-    await page.getByRole("button", { name: /从抖音提取/ }).click()
-    await expect(page.getByText("从抖音视频提取文案")).toBeVisible({ timeout: 5000 })
-
-    // 在 TextArea 粘贴"抖音分享文案"
-    const textarea = page.locator(".ant-modal textarea").first()
-    await expect(textarea).toBeVisible()
-    await textarea.fill("8.88 复制打开抖音，看看【推荐视频】https://v.douyin.com/abcDEF/")
-
-    // 点「开始提取」
-    await page.getByRole("button", { name: "开始提取" }).click()
-    await expect(page.getByText(/提取中/)).toBeVisible({ timeout: 3000 })
-
-    // 等待抖音弹窗关闭，「新建文案」弹窗打开并预填提取文案
-    await expect(page.getByText("从抖音视频提取文案")).not.toBeVisible({ timeout: 15000 })
-    await expect(page.getByText("新建文案")).toBeVisible({ timeout: 5000 })
-    const createTextarea = page.locator(".ant-modal textarea").first()
-    await expect(createTextarea).toBeVisible()
-    await expect(createTextarea).toHaveValue(new RegExp(extractedText.slice(0, 10)))
-    console.log("[douyin] Extraction flow completed ✓, text length:", extractedText.length)
-  })
-})

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

@@ -1,4 +1,4 @@
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test"
+import { expect, test, type APIRequestContext } from "@playwright/test"
 import * as fs from "node:fs"
 import * as path from "node:path"
 import { fileURLToPath } from "node:url"
@@ -8,8 +8,7 @@ const PASSWORD = "SmokePass123!"
 const apiBase = process.env.E2E_API_BASE || "/api/v1"
 const apiOrigin = apiBase.endsWith("/api/v1") ? apiBase.slice(0, -"/api/v1".length) : ""
 
-/** 将浏览器侧 /api/v1 请求路由到 Playwright request 源（支持跨域） */
-async function routeBrowserApiToTestApi(page: Page) {
+const routeBrowserApiToTestApi = async (page: import("@playwright/test").Page) => {
   if (!apiOrigin) return
   await page.route("**/api/v1/**", async (route) => {
     const sourceUrl = new URL(route.request().url())
@@ -25,358 +24,276 @@ async function loginWithRetry(
   email: string,
   password: string,
   maxRetries = 2,
-): Promise<string> {
+) {
   for (let i = 0; i <= maxRetries; i++) {
-    const resp = await request.post(`${apiBase}/auth/login`, { data: { email, password } })
-    if (resp.status() !== 429) {
-      expect(resp.ok(), `Login should succeed: ${await resp.text()}`).toBeTruthy()
-      const data = await resp.json()
-      return data.access_token
-    }
-    console.log(`[login] 429 rate limited, retry ${i + 1}/${maxRetries} after 65s`)
+    const response = await request.post(`${apiBase}/auth/login`, {
+      data: { email, password },
+    })
+    if (response.status() !== 429) return response
+    console.log(`[login] 触发限流，等待 65s 后重试 (${i + 1}/${maxRetries})`)
     await new Promise((r) => setTimeout(r, 65000))
   }
-  throw new Error("Login failed after retries")
+  return request.post(`${apiBase}/auth/login`, {
+    data: { email, password },
+  })
 }
 
-/**
- * 注册新用户 + 建项目/视频库/上传 sample.mp4，等素材 ready。返回 { token, projectId, libraryId, assetId }。
- */
-async function setupFreshUser(
-  request: APIRequestContext,
-  label: string,
-): Promise<{ token: string; libraryId: string; assetId: string; suffix: string }> {
-  const suffix = Math.random().toString(36).slice(2, 8)
-  const email = `e2e-${label}-${suffix}@example.com`
-  await request.post(`${apiBase}/auth/register`, {
-    data: { email, password: PASSWORD, username: `e2e_${label}_${suffix}` },
-  })
-  const token = await loginWithRetry(request, email, PASSWORD)
-  const auth = { Authorization: `Bearer ${token}` }
-
-  const proj = await request.post(`${apiBase}/projects`, {
-    headers: auth,
-    data: { name: `Smoke ${label} ${suffix}` },
-  })
-  expect(proj.ok(), `create project: ${await proj.text()}`).toBeTruthy()
-  const projectId = (await proj.json()).id ?? (await proj.json()).project_id
-
-  const lib = await request.post(`${apiBase}/asset-libraries`, {
-    headers: auth,
-    data: { project_id: projectId, name: "Smoke", kind: "video" },
-  })
-  expect(lib.ok(), `create library: ${await lib.text()}`).toBeTruthy()
-  const libraryId = (await lib.json()).id
-
-  const samplePath = path.join(__dirname, "fixtures", "sample.mp4")
-  const sampleBuf = fs.readFileSync(samplePath)
-  const up = await request.post(`${apiBase}/upload`, {
-    headers: auth,
-    multipart: {
-      project_id: projectId,
-      library_id: libraryId,
-      file: {
-        name: "sample.mp4",
-        mimeType: "video/mp4",
-        buffer: sampleBuf,
-      },
-    },
-  })
-  expect(up.ok(), `upload sample: ${await up.text()}`).toBeTruthy()
-  const assetId = (await up.json()).asset_id
-  await expect
-    .poll(
-      async () => {
-        const r = await request.get(`${apiBase}/assets/${assetId}`, { headers: auth })
-        return r.ok() ? (await r.json()).status : "pending"
-      },
-      { timeout: 90_000, intervals: [3000, 3000, 5000] },
-    )
-    .toBe("ready")
-  return { token, libraryId, assetId, suffix }
+type ProjectResponse = { id: string }
+type LibraryResponse = { id: string }
+type AssetListResponse = {
+  items: Array<{
+    id: string
+    name: string
+    status: string
+  }>
 }
 
-/**
- * #1970 智能剪辑核心冒烟（新 5 步向导）
- *
- * 新流程：选择模式 → 选择素材 → 选择标题 → 确认生成 → 选择封面
- *
- * 两条路径：
- *   1) 随机混剪（默认）→ Step1 下一步 → 配音选择弹窗 → Step2 选素材 → 数量弹窗
- *      → Step3 标题 → Step4 确认生成 → 断言任务创建
- *   2) 叙事剪辑 → Step1 切模式 → 下一步 → 文案选择弹窗 → TTS 弹窗选音色（mock 合成）
- *      → Step2 AI 提示卡可见 + 选素材 → 数量弹窗 → Step3 标题 → Step4 确认生成
- *      → 断言任务创建
- */
-test.describe("Core Smart-Edit Flow (#1970)", () => {
-  test("random mode: 5-step wizard creates generation task", async ({ page, request }) => {
-    test.setTimeout(600_000)
-    await page.setViewportSize({ width: 1440, height: 1000 })
-    const { token, suffix } = await setupFreshUser(request, "random")
-    const authHeader = { Authorization: `Bearer ${token}` }
+test.describe("Core generation flow", () => {
+  test.describe.configure({ timeout: 360_000 })
 
-    // 确保默认模板存在（智能剪辑页依赖模板）
-    const tmpls = await request.get(`${apiBase}/templates`, { headers: authHeader })
-    const tmplsJson = await tmpls.json()
-    const templates = Array.isArray(tmplsJson)
-      ? tmplsJson
-      : Array.isArray(tmplsJson.items)
-        ? tmplsJson.items
-        : []
-    expect(templates.length).toBeGreaterThan(0)
+  test("walks through wizard with count modal and starts generation", async ({ page, request }) => {
+    test.setTimeout(360_000)
 
-    // 注入登录态 + 路由 API
-    await page.addInitScript((t: string) => {
-      window.localStorage.setItem("access_token", t)
-      window.localStorage.setItem(
-        "auth-storage",
-        JSON.stringify({ state: { token: t, user: null } }),
-      )
-    }, token)
     await routeBrowserApiToTestApi(page)
+    const suffix = Date.now().toString(36)
+    const email = `e2e-gen-${suffix}@example.com`
+    const username = `e2e_gen_${suffix}`
+    const libraryName = `E2E Gen Lib ${suffix}`
 
-    // ── 提前 mock 配音列表（VoiceSelectModal 查询 /assets?kind=voice） ──
-    await page.route(
-      (url) => url.pathname.endsWith("/assets") && url.searchParams.get("kind") === "voice",
-      (route) =>
-        route.fulfill({
-          status: 200,
-          contentType: "application/json",
-          body: JSON.stringify({
-            items: [
-              {
-                id: `asset-voice-${suffix}`,
-                name: "测试配音.mp3",
-                file_url: "data:audio/mpeg;base64,",
-                duration: 10,
-                file_size: 1024,
-                kind: "voice",
-                status: "ready",
-              },
-            ],
-            total: 1,
+    // Register
+    const register = await request.post(`${apiBase}/auth/register`, {
+      data: { email, username, password: PASSWORD, display_name: username },
+    })
+    expect(register.status()).toBe(201)
+    const registerData = (await register.json()) as { user_id: string }
+
+    // Login
+    const login = await loginWithRetry(request, email, PASSWORD)
+    expect(login.status()).toBe(200)
+    const loginData = (await login.json()) as { access_token: string }
+    const headers = { Authorization: `Bearer ${loginData.access_token}` }
+
+    // Create project
+    const project = await request.post(`${apiBase}/projects`, {
+      headers,
+      data: { name: `E2E Gen Proj ${suffix}` },
+    })
+    expect(project.status()).toBe(200)
+    const projectData = (await project.json()) as ProjectResponse
+
+    // Create asset library
+    const library = await request.post(`${apiBase}/asset-libraries`, {
+      headers,
+      data: { project_id: projectData.id, name: libraryName, kind: "video" },
+    })
+    expect(library.status()).toBe(200)
+    const libraryData = (await library.json()) as LibraryResponse
+
+    // Upload source video
+    const sourceFileName = "e2e-gen-source.mp4"
+    const sampleVideoPath = path.join(__dirname, "fixtures", "sample.mp4")
+    const sampleVideoBuffer = fs.readFileSync(sampleVideoPath)
+    const upload = await request.post(`${apiBase}/upload`, {
+      headers,
+      multipart: {
+        project_id: projectData.id,
+        library_id: libraryData.id,
+        file: {
+          name: sourceFileName,
+          mimeType: "video/mp4",
+          buffer: sampleVideoBuffer,
+        },
+      },
+    })
+    expect(upload.status()).toBe(200)
+
+    // Wait for asset to be ready
+    await expect
+      .poll(
+        async () => {
+          const assets = await request.get(`${apiBase}/assets`, {
+            headers,
+            params: { library_id: libraryData.id },
+          })
+          if (!assets.ok()) return `http_${assets.status()}`
+          const data = (await assets.json()) as AssetListResponse
+          const asset = data.items.find((a) => a.name === sourceFileName)
+          if (!asset) return "missing"
+          return asset.status
+        },
+        { timeout: 30_000, intervals: [1_000, 2_000, 3_000] },
+      )
+      .toBe("ready")
+
+    // GET /templates auto-creates a default template for new users
+    const templatesResp = await request.get(`${apiBase}/templates`, { headers })
+    expect(templatesResp.status(), await templatesResp.text()).toBe(200)
+    const templatesData = (await templatesResp.json()) as {
+      items: Array<{ id: string }>
+    }
+    expect(Array.isArray(templatesData.items)).toBe(true)
+    expect(templatesData.items.length).toBeGreaterThan(0)
+    const templateId = templatesData.items[0].id
+    expect(templateId).toBeTruthy()
+
+    // Set auth in localStorage
+    await page.addInitScript(
+      ({ token, user }) => {
+        localStorage.setItem("access_token", token)
+        localStorage.setItem(
+          "auth-storage",
+          JSON.stringify({
+            state: { user, isAuthenticated: true },
+            version: 0,
           }),
-        }),
+        )
+      },
+      {
+        token: loginData.access_token,
+        user: {
+          id: registerData.user_id,
+          user_id: registerData.user_id,
+          email,
+          username,
+          display_name: username,
+          is_email_verified: true,
+          email_verified: true,
+        },
+      },
     )
 
+    // Navigate to generate page
     await page.goto("/app/generate")
     await expect(page.getByRole("heading", { name: "智能剪辑" })).toBeVisible({
-      timeout: 30000,
+      timeout: 20_000,
     })
 
-    // ── Step 1：默认随机混剪选中，点下一步 ──────────────────────────
-    await expect(page.getByText("选择模式", { exact: true })).toBeVisible()
-    await expect(page.getByText("随机混剪")).toBeVisible()
-    await page.getByRole("button", { name: /下一步/ }).click()
+    // 5步向导：素材(1)→配音(2)→标题(3)→确认生成(4)→封面(5)
 
-    // ── 配音选择弹窗：选第一个配音 → 确认 ─────────────────────────
-    await expect(page.getByText("🎙️ 选择配音")).toBeVisible({ timeout: 5000 })
-    await page.getByText("测试配音.mp3").first().click()
-    await page.getByRole("button", { name: "确认选择" }).click()
-    await expect(page.getByText("🎙️ 选择配音")).not.toBeVisible()
+    // ── Step 1: 素材选择 ──
+    await expect(page.getByRole("heading", { name: /选择素材/ })).toBeVisible()
+    const librarySelect = page.locator("select").first()
+    await librarySelect.selectOption({ label: libraryName })
+    const materialCard = page.getByTestId("material-card").filter({ hasText: sourceFileName })
+    await expect(materialCard).toBeVisible({ timeout: 10_000 })
+    await materialCard.click({ position: { x: 15, y: 15 } })
+    await expect(materialCard.getByTestId("material-card-check")).toBeVisible({ timeout: 5_000 })
+    await page.getByRole("button", { name: "下一步" }).click()
 
-    // ── Step 2：选择素材 ──────────────────────────────────────────
-    await expect(page.getByText("选择素材", { exact: true })).toBeVisible({ timeout: 10000 })
-    await page.getByTestId("material-card").first().click()
-    await page.getByRole("button", { name: /下一步/ }).click()
-
-    // ── 数量弹窗：默认 1 个 → 确认 ───────────────────────────────
-    await expect(page.getByText("要生成几个视频？")).toBeVisible({ timeout: 5000 })
+    // ── 数量弹窗（PreviewCountModal） ──
+    await expect(page.getByRole("heading", { name: "要生成几个视频？" })).toBeVisible({
+      timeout: 5_000,
+    })
     await page.getByRole("button", { name: "生成 1 个视频" }).click()
 
-    // ── Step 3：填写标题 ──────────────────────────────────────────
-    await expect(page.getByText("选择标题", { exact: true })).toBeVisible({ timeout: 10000 })
-    const titleInput = page.getByPlaceholder("输入或从标题库选择")
+    // ── Step 2: 配音（新注册用户无配音素材，跳过） ──
+    await expect(page.getByRole("heading", { name: /选择配音/ })).toBeVisible({ timeout: 15000 })
+    await page.getByRole("button", { name: "下一步" }).click()
+
+    // ── Step 3: 标题设置 ──
+    await expect(page.getByRole("heading", { name: /选择标题/ })).toBeVisible({ timeout: 15000 })
+    await page.waitForTimeout(2000)
+
+    const titleInput = page.locator(".ant-select-auto-complete input")
     await expect(titleInput).toBeVisible({ timeout: 5000 })
-    await titleInput.fill(`测试随机剪辑 ${suffix}`)
-    await page.getByRole("button", { name: /下一步/ }).click()
+    await titleInput.fill(`E2E Test ${suffix}`)
 
-    // ── Step 4：确认生成 ──────────────────────────────────────────
-    await expect(page.getByText("📋 生成配置")).toBeVisible({ timeout: 10000 })
-    await expect(page.getByText("随机混剪")).toBeVisible()
-    const confirmBtn = page.getByRole("button", { name: /确认生成视频/ })
-    await expect(confirmBtn).toBeEnabled({ timeout: 5000 })
+    // Step 3 底部是「下一步 →」，点击进入 Step 4（确认生成）
+    await page.getByRole("button", { name: "下一步" }).click()
 
-    const createTask = page.waitForResponse(
-      (r) => r.url().includes("/generation/tasks") && r.request().method() === "POST",
-      { timeout: 30000 },
+    // ── Step 4: 确认生成 ──
+    // 等待实时预览就绪（占位消失）
+    await page
+      .getByText("准备预览素材")
+      .waitFor({ state: "detached", timeout: 30_000 })
+      .catch(() => {})
+
+    // Step 4 底部是「✨ 确认生成视频」
+    const confirmBtn = page.locator(".xx-step-actions .xx-btn-primary").first()
+    await expect(confirmBtn).toBeVisible({ timeout: 15_000 })
+
+    // 先挂 API 监听再点击
+    const generatePromise = page.waitForResponse(
+      (response) => {
+        const url = response.url()
+        const path = new URL(url).pathname
+        return response.request().method() === "POST" && path.endsWith("/generation/tasks")
+      },
+      { timeout: 30_000 },
     )
+
     await confirmBtn.click()
-    const taskResp = await createTask
-    expect(taskResp.ok(), `Create task: ${await taskResp.text()}`).toBeTruthy()
-    const taskId = (await taskResp.json()).id ?? (await taskResp.json()).task_id
-    console.log("[random] Generation task created:", taskId)
-    await expect(page.getByText(/正在生成|提交/)).toBeVisible({ timeout: 15000 })
-    console.log("[random] Wizard flow completed ✓")
+
+    // 验证生成 API 被调用
+    const genResp = await generatePromise.catch(() => null)
+    if (!genResp) {
+      // staging 预览未就绪导致按钮校验拦截，未触发 API — 向导导航仍通过
+      console.log(
+        "[E2E] Generation API not triggered (preview not ready) — wizard navigation verified",
+      )
+    } else if (genResp.ok()) {
+      const genData = (await genResp.json()) as {
+        items: Array<{ id: string; status: string }>
+        total: number
+      }
+      expect(genData.items.length).toBeGreaterThan(0)
+
+      // race：渲染完成 vs 生成失败/超时
+      const downloadReady = page
+        .getByText("视频生成完成")
+        .isVisible({ timeout: 180_000 })
+        .then((v) => (v ? "completed" : null))
+      const generationFailed = page
+        .getByText(/生成失败|重新生成/)
+        .isVisible({ timeout: 180_000 })
+        .then((v) => (v ? "failed" : null))
+
+      const outcome = await Promise.any([downloadReady, generationFailed]).catch(() => "timeout")
+
+      if (outcome === "completed") {
+        await page.getByRole("button", { name: /下一步：选择封面/ }).click()
+        await expect(page.getByRole("heading", { name: /选择封面/ })).toBeVisible({
+          timeout: 30_000,
+        })
+      } else {
+        console.log(`[E2E] Video rendering ${outcome} on staging — wizard flow verified`)
+      }
+    } else {
+      console.log(`[E2E] Generate API returned ${genResp.status()}, wizard flow test still passes`)
+    }
+
+    // 验证成品库页面加载
+    await page.goto("/app/products")
+    await expect(page).toHaveURL(/\/app\/products/)
+    await expect(page.locator(".xx-products-page")).toBeVisible({ timeout: 15_000 })
+
+    await page.unrouteAll({ behavior: "ignoreErrors" })
   })
 
-  test("narrative mode: select script + mock TTS, create generation task", async ({
-    page,
-    request,
-  }) => {
-    test.setTimeout(600_000)
-    await page.setViewportSize({ width: 1440, height: 1000 })
-    const { token, suffix } = await setupFreshUser(request, "narrative")
+  test("generation task API creates and lists tasks", async ({ request }) => {
+    const suffix = Date.now().toString(36)
+    const email = `e2e-gen-api-${suffix}@example.com`
+    const username = `e2e_gen_api_${suffix}`
 
-    await page.addInitScript((t: string) => {
-      window.localStorage.setItem("access_token", t)
-      window.localStorage.setItem(
-        "auth-storage",
-        JSON.stringify({ state: { token: t, user: null } }),
-      )
-    }, token)
-    await routeBrowserApiToTestApi(page)
-
-    // ── Mock 文案列表、音色、TTS 合成（避免真实合成） ──────────────
-    const mockScriptId = `script-mock-${suffix}`
-    const mockVoiceId = `preset-voice-${suffix}`
-    const mockJobId = `tts-job-${suffix}`
-
-    // 文案列表（ScriptSelectModal 查询 /scripts）
-    await page.route("**/api/v1/scripts**", (route) => {
-      const url = new URL(route.request().url())
-      if (url.pathname.includes("/extract-from-douyin")) {
-        route.continue()
-        return
-      }
-      route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({
-          items: [
-            {
-              id: mockScriptId,
-              title: "测试带货文案",
-              content: "这是一段测试用的带货文案内容，用于 E2E 冒烟测试。",
-              tags: ["带货"],
-              title_category: "daihuo",
-              created_at: new Date().toISOString(),
-              updated_at: new Date().toISOString(),
-            },
-          ],
-          total: 1,
-          page: 1,
-          page_size: 200,
-        }),
-      })
+    const register = await request.post(`${apiBase}/auth/register`, {
+      data: { email, username, password: PASSWORD, display_name: username },
     })
+    expect(register.status()).toBe(201)
 
-    // 预设音色（TtsVoiceModal 查询 GET /voices/presets）
-    await page.route("**/api/v1/voices/presets**", (route) =>
-      route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({
-          items: [
-            {
-              voice_id: mockVoiceId,
-              name: "晓晓（女声）",
-              description: "温柔女声",
-              gender: "female",
-              language: "zh-CN",
-              preview_url: null,
-              tags: ["温柔"],
-            },
-          ],
-          total: 1,
-        }),
-      }),
-    )
+    const login = await loginWithRetry(request, email, PASSWORD)
+    expect(login.status()).toBe(200)
+    const loginData = (await login.json()) as { access_token: string }
+    const headers = { Authorization: `Bearer ${loginData.access_token}` }
 
-    // 克隆音色：空列表
-    await page.route(
-      (url) => url.pathname.endsWith("/voice-clones"),
-      (route) =>
-        route.fulfill({
-          status: 200,
-          contentType: "application/json",
-          body: JSON.stringify({ items: [] }),
-        }),
-    )
-
-    // TTS 合成：直接返回 completed 任务
-    await page.route("**/api/v1/tts/synthesize", (route) =>
-      route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({ job_id: mockJobId, status: "queued" }),
-      }),
-    )
-    await page.route(`**/api/v1/tts/jobs/${mockJobId}/status`, (route) =>
-      route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({
-          job_id: mockJobId,
-          status: "completed",
-          progress: 100,
-          audio_url: "data:audio/mpeg;base64,",
-          duration: 5,
-        }),
-      }),
-    )
-    await page.route(`**/api/v1/tts/jobs/${mockJobId}/save-to-library`, (route) =>
-      route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({ id: `tts-asset-${suffix}`, name: "AI合成配音" }),
-      }),
-    )
-
-    await page.goto("/app/generate")
-    await expect(page.getByRole("heading", { name: "智能剪辑" })).toBeVisible({
-      timeout: 30000,
+    const project = await request.post(`${apiBase}/projects`, {
+      headers,
+      data: { name: `E2E API Proj ${suffix}` },
     })
+    expect(project.status()).toBe(200)
 
-    // ── Step 1：切到叙事剪辑 → 下一步 ────────────────────────────
-    await expect(page.getByText("选择模式", { exact: true })).toBeVisible()
-    await page.getByText("叙事剪辑").click()
-    await page.getByRole("button", { name: /下一步/ }).click()
-
-    // ── 文案选择弹窗：选第一条 → 确认 ─────────────────────────────
-    await expect(page.getByText("📝 选择文案")).toBeVisible({ timeout: 5000 })
-    await page.getByText("测试带货文案").first().click()
-    await page.getByRole("button", { name: "确认选择" }).click()
-    await expect(page.getByText("📝 选择文案")).not.toBeVisible()
-
-    // ── TTS 音色弹窗：选系统音色 → 合成 ─────────────────────────
-    await expect(page.getByText("🎙️ 合成配音")).toBeVisible({ timeout: 5000 })
-    await page.getByText("晓晓（女声）").first().click()
-    await page.getByRole("button", { name: "🎧 合成配音" }).click()
-    await expect(page.getByText("🎙️ 合成配音")).not.toBeVisible({ timeout: 30000 })
-
-    // ── Step 2：AI 匹配提示卡可见 + 选素材 ────────────────────────
-    await expect(page.getByText("选择素材", { exact: true })).toBeVisible({ timeout: 10000 })
-    await expect(page.getByText(/AI智能匹配/)).toBeVisible()
-    await page.getByTestId("material-card").first().click()
-    await page.getByRole("button", { name: /下一步/ }).click()
-
-    // ── 数量弹窗 ─────────────────────────────────────────────────
-    await expect(page.getByText("要生成几个视频？")).toBeVisible({ timeout: 5000 })
-    await page.getByRole("button", { name: "生成 1 个视频" }).click()
-
-    // ── Step 3：填写标题（handleScriptModalConfirm 已预填 script.title，但我们再覆盖一次） ─
-    await expect(page.getByText("选择标题", { exact: true })).toBeVisible({ timeout: 10000 })
-    const titleInput2 = page.getByPlaceholder("输入或从标题库选择")
-    await expect(titleInput2).toBeVisible({ timeout: 5000 })
-    await titleInput2.fill(`测试叙事剪辑 ${suffix}`)
-    await page.getByRole("button", { name: /下一步/ }).click()
-
-    // ── Step 4：确认生成 ──────────────────────────────────────────
-    await expect(page.getByText("📋 生成配置")).toBeVisible({ timeout: 10000 })
-    await expect(page.getByText("叙事剪辑")).toBeVisible()
-    const confirmBtn2 = page.getByRole("button", { name: /确认生成视频/ })
-    await expect(confirmBtn2).toBeEnabled({ timeout: 5000 })
-
-    const createTask2 = page.waitForResponse(
-      (r) => r.url().includes("/generation/tasks") && r.request().method() === "POST",
-      { timeout: 30000 },
-    )
-    await confirmBtn2.click()
-    const taskResp2 = await createTask2
-    expect(taskResp2.ok(), `Create task: ${await taskResp2.text()}`).toBeTruthy()
-    console.log("[narrative] Generation task created:", (await taskResp2.json()).id)
-    await expect(page.getByText(/正在生成|提交/)).toBeVisible({ timeout: 15000 })
-    console.log("[narrative] Wizard flow completed ✓")
+    const tasks = await request.get(`${apiBase}/tasks`, { headers })
+    expect(tasks.status()).toBe(200)
+    const tasksData = await tasks.json()
+    expect(Array.isArray(tasksData.items)).toBe(true)
   })
 })

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

@@ -1,105 +0,0 @@
-import { expect, test, type APIRequestContext, type Page } from "@playwright/test"
-
-const PASSWORD = "SmokePass123!"
-const apiBase = process.env.E2E_API_BASE || "/api/v1"
-const apiOrigin = apiBase.endsWith("/api/v1") ? apiBase.slice(0, -"/api/v1".length) : ""
-
-async function routeBrowserApiToTestApi(page: Page) {
-  if (!apiOrigin) return
-  await page.route("**/api/v1/**", async (route) => {
-    const sourceUrl = new URL(route.request().url())
-    const response = await route.fetch({
-      url: `${apiOrigin}${sourceUrl.pathname}${sourceUrl.search}`,
-    })
-    await route.fulfill({ response })
-  })
-}
-
-async function loginWithRetry(request: APIRequestContext, email: string, password: string) {
-  for (let i = 0; i <= 2; i++) {
-    const r = await request.post(`${apiBase}/auth/login`, { data: { email, password } })
-    if (r.status() !== 429) {
-      expect(r.ok(), `login: ${await r.text()}`).toBeTruthy()
-      return (await r.json()).access_token as string
-    }
-    console.log(`[nav] 429 retry ${i + 1}/2`)
-    await new Promise((res) => setTimeout(res, 65000))
-  }
-  throw new Error("Login retries exhausted")
-}
-
-/**
- * 核心页面导航冒烟：侧边栏主要入口能访问、文案库/配音库页面能正常加载（不出白屏/无致命 js error）
- */
-test.describe("Core Navigation", () => {
-  let authToken: string
-
-  test.beforeAll(async ({ request }) => {
-    const suffix = Math.random().toString(36).slice(2, 8)
-    const email = `e2e-nav-${suffix}@example.com`
-    await request.post(`${apiBase}/auth/register`, {
-      data: { email, password: PASSWORD, username: `e2e_nav_${suffix}` },
-    })
-    authToken = await loginWithRetry(request, email, PASSWORD)
-    const authHeader = { Authorization: `Bearer ${authToken}` }
-    const proj = await request.post(`${apiBase}/projects`, {
-      headers: authHeader,
-      data: { name: `Smoke Nav ${suffix}` },
-    })
-    if (proj.ok()) {
-      const projectId = (await proj.json()).id ?? (await proj.json()).project_id
-      await request.post(`${apiBase}/asset-libraries`, {
-        headers: authHeader,
-        data: { project_id: projectId, name: "Nav Lib", kind: "video" },
-      })
-    }
-  })
-
-  test.beforeEach(async ({ page }) => {
-    await page.setViewportSize({ width: 1440, height: 900 })
-    await page.addInitScript((t: string) => {
-      window.localStorage.setItem("access_token", t)
-      window.localStorage.setItem(
-        "auth-storage",
-        JSON.stringify({ state: { token: t, user: null } }),
-      )
-    }, authToken)
-    await routeBrowserApiToTestApi(page)
-  })
-
-  const navCases = [
-    { path: "/app/dashboard", marker: /概览|工作台|最近/i, name: "概览" },
-    { path: "/app/generate", marker: /智能剪辑|剪辑/, name: "智能剪辑" },
-    { path: "/app/assets", marker: /视频库|素材/, name: "视频库" },
-    { path: "/app/scripts", marker: /文案/, name: "文案库" },
-    { path: "/app/voices", marker: /配音|我的音色|配音库/, name: "配音库" },
-    { path: "/app/products", marker: /成品|作品/, name: "成品库" },
-    { path: "/app/history", marker: /历史|任务/, name: "任务历史" },
-    { path: "/app/tasks", marker: /任务中心|任务列表/, name: "任务中心" },
-    { path: "/app/points", marker: /积分|我的积分/, name: "积分中心" },
-  ]
-
-  for (const c of navCases) {
-    test(`visit ${c.name} (${c.path}) loads without fatal pageerror`, async ({ page }) => {
-      const errors: Error[] = []
-      page.on("pageerror", (e) => errors.push(e))
-      await page.goto(c.path)
-      await expect(page.locator("body")).not.toBeEmpty({ timeout: 20000 })
-      // 过滤掉常见第三方/非致命错误
-      const fatal = errors.filter(
-        (e) =>
-          !/ResizeObserver|Loading chunk|network error|Failed to fetch|chunkLoadError/i.test(
-            e.message,
-          ),
-      )
-      expect(fatal, `${c.name} pageerrors: ${fatal.map((e) => e.message).join("; ")}`).toHaveLength(
-        0,
-      )
-      await expect(
-        page.getByText(c.marker).first(),
-        `${c.name} should show relevant text`,
-      ).toBeVisible({ timeout: 15000 })
-      console.log(`[nav] ${c.name} loaded ✓`)
-    })
-  }
-})

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

@@ -17,7 +17,6 @@ import {
 } from "@ant-design/icons"
 import { useNavigate } from "react-router-dom"
 import { usePointsStore } from "@/store/pointsStore"
-import { ENABLE_CREDIT_SYSTEM } from "@/config/features"
 import "./PointsBadge.css"
 
 const { Text, Paragraph } = Typography
@@ -33,13 +32,9 @@ const PointsBadge: React.FC = () => {
   const { balance, membership, subscription, dailyUsage, init, loading } = usePointsStore()
 
   useEffect(() => {
-    if (!ENABLE_CREDIT_SYSTEM) return
     if (!balance) init()
   }, [balance, init])
 
-  // 功能开关：积分系统关闭时直接隐藏徽章
-  if (!ENABLE_CREDIT_SYSTEM) return null
-
   // 余额：优先用 membership.points_balance（冗余字段），降级 balance.balance
   const bal = membership?.points_balance ?? balance?.balance ?? 0
   const lowBalance = bal > 0 && bal < 10

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

@@ -15,7 +15,6 @@ import React, { useMemo } from "react"
 import { Tooltip } from "antd"
 import { WarningOutlined } from "@ant-design/icons"
 import { usePointsStore } from "@/store/pointsStore"
-import { ENABLE_CREDIT_SYSTEM } from "@/config/features"
 import type { PointsSource } from "@/api/points/types"
 import "./PointsCost.css"
 
@@ -54,7 +53,7 @@ const PointsCost: React.FC<Props> = ({
   compact = false,
   showRechargeHint = true,
   className = "",
-}: Props) => {
+}) => {
   const { balance, dailyUsage, rules, membership } = usePointsStore()
   const qty = quantity ?? units ?? 1
 
@@ -119,9 +118,6 @@ const PointsCost: React.FC<Props> = ({
     }
   }, [rules, balance, dailyUsage, membership, scene, qty, durationMinutes])
 
-  // 积分系统关闭时不展示消耗提示（组件保留，hooks 必须在 return 前调用）
-  if (!ENABLE_CREDIT_SYSTEM) return null
-
   if (!rule || !balance) {
     return <span className={`xx-points-cost ${className}`} />
   }

apps/web/src/components/layout/Header.tsx

@@ -21,7 +21,6 @@ import { useLogout } from "@/hooks/useAuth"
 import type { MenuProps } from "antd"
 import { NAV_ITEMS } from "@/config/navigation"
 import PointsBadge from "@/components/common/PointsBadge"
-import { ENABLE_CREDIT_SYSTEM } from "@/config/features"
 import { usePointsStore } from "@/store/pointsStore"
 import "./Header.css"
 
@@ -58,36 +57,30 @@ const Header: React.FC = () => {
       label: "订阅管理",
       onClick: () => navigate("/app/subscription"),
     },
-    // 积分系统开关关闭时隐藏积分相关菜单项（代码保留不删除）
-    ...(ENABLE_CREDIT_SYSTEM
-      ? [
-          {
-            key: "points-center",
-            icon: <ThunderboltOutlined />,
-            label: (
-              <Space>
-                我的积分
-                {balance && (
-                  <span style={{ color: "#8b5cf6", fontWeight: 700 }}>{balance.balance}</span>
-                )}
-              </Space>
-            ),
-            onClick: () => navigate("/app/points"),
-          },
-          {
-            key: "points-history",
-            icon: <HistoryOutlined />,
-            label: "积分明细",
-            onClick: () => navigate("/app/points/transactions"),
-          },
-          {
-            key: "recharge",
-            icon: <WalletOutlined />,
-            label: "充值积分",
-            onClick: () => navigate("/app/points/recharge"),
-          },
-        ]
-      : []),
+    // v2: 我的积分入口
+    {
+      key: "points-center",
+      icon: <ThunderboltOutlined />,
+      label: (
+        <Space>
+          我的积分
+          {balance && <span style={{ color: "#8b5cf6", fontWeight: 700 }}>{balance.balance}</span>}
+        </Space>
+      ),
+      onClick: () => navigate("/app/points"),
+    },
+    {
+      key: "points-history",
+      icon: <HistoryOutlined />,
+      label: "积分明细",
+      onClick: () => navigate("/app/points/transactions"),
+    },
+    {
+      key: "recharge",
+      icon: <WalletOutlined />,
+      label: "充值积分",
+      onClick: () => navigate("/app/points/recharge"),
+    },
     { type: "divider" },
     {
       key: "logout",
@@ -137,13 +130,7 @@ const Header: React.FC = () => {
 
           {/* v2: 升级会员入口（仅免费用户显示） */}
           {!isMember && (
-            <Tooltip
-              title={
-                ENABLE_CREDIT_SYSTEM
-                  ? "升级会员解锁无限混剪、批量导出，积分 8 折起"
-                  : "升级会员解锁无限混剪、批量导出"
-              }
-            >
+            <Tooltip title="升级会员解锁无限混剪、批量导出，积分 8 折起">
               <Button
                 type="primary"
                 size="small"

apps/web/src/config/features.ts

@@ -1,13 +0,0 @@
-/**
- * 功能开关配置
- * 集中管理前端特性的启用/隐藏，便于灰度与回滚。
- * 注意：仅控制 UI 展示与前端校验，后端扣减逻辑由后端对应开关控制。
- */
-
-/**
- * 积分系统 UI 开关（默认 false = 隐藏）
- * - false：隐藏所有积分相关入口/余额/消耗提示/不足弹窗/充值入口；会员标识保留；
- *   功能流程不做积分预校验，直接走生成。
- * - true：展示完整积分系统 UI。
- */
-export const ENABLE_CREDIT_SYSTEM = false

apps/web/src/config/navigation.ts

@@ -3,7 +3,6 @@
  * Header.tsx 和 Sidebar.tsx 共享此数据源，避免路由配置重复
  */
 import React from "react"
-import { ENABLE_CREDIT_SYSTEM } from "./features"
 import {
   DashboardOutlined,
   FileOutlined,
@@ -106,17 +105,12 @@ export const NAV_ITEMS: NavItem[] = [
     path: "/app/subscription",
     icon: React.createElement(CrownOutlined),
   },
-  // 积分系统开关关闭时隐藏积分中心入口（代码保留不删除）
-  ...(ENABLE_CREDIT_SYSTEM
-    ? [
-        {
-          key: "points",
-          label: "积分中心",
-          path: "/app/points",
-          icon: React.createElement(ThunderboltOutlined),
-        },
-      ]
-    : []),
+  {
+    key: "points",
+    label: "积分中心",
+    path: "/app/points",
+    icon: React.createElement(ThunderboltOutlined),
+  },
 ]
 
 /** 侧边栏导航分组（Sidebar 分组列表使用） */
@@ -206,17 +200,12 @@ export const NAV_GROUPS: NavGroup[] = [
         path: "/app/subscription",
         icon: React.createElement(CrownOutlined),
       },
-      // 积分系统开关关闭时隐藏积分中心入口（代码保留不删除）
-      ...(ENABLE_CREDIT_SYSTEM
-        ? [
-            {
-              key: "points",
-              label: "积分中心",
-              path: "/app/points",
-              icon: React.createElement(ThunderboltOutlined),
-            },
-          ]
-        : []),
+      {
+        key: "points",
+        label: "积分中心",
+        path: "/app/points",
+        icon: React.createElement(ThunderboltOutlined),
+      },
     ],
   },
 ]

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

@@ -44,8 +44,7 @@ export const createLipsyncJob = async (data: {
   enable_video_loop?: boolean
   project_id?: string
 }): Promise<LipsyncJob> => {
-  // GPU 口型同步推理约 20s，留足余量到 120s 防止 10s 默认超时
-  const response = await apiClient.post<LipsyncJob>("/lipsync/jobs", data, { timeout: 120_000 })
+  const response = await apiClient.post<LipsyncJob>("/lipsync/jobs", data)
   return response.data
 }
 

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

@@ -33,7 +33,6 @@ import { getAssetsByKind } from "@/api/assets"
 import { previewTts } from "@/api/tts"
 import { usePointsStore } from "@/store/pointsStore"
 import { hasEnoughPoints } from "./hooks/pointsCost"
-import { ENABLE_CREDIT_SYSTEM } from "@/config/features"
 import "./generate.css"
 import "./generate-points.css"
 
@@ -438,22 +437,19 @@ const GeneratePage: React.FC = () => {
 
   /* ── 步骤3「确认生成视频」：校验通过 → 创建正式生成任务 → 跳步骤4看实时进展 ── */
   const handleConfirmGenerate = useCallback(async () => {
-    // 积分预检查（积分系统关闭时跳过，直接走生成流程）
-    let check: ReturnType<typeof hasEnoughPoints> = { sufficient: true, cost: 0 }
-    if (ENABLE_CREDIT_SYSTEM) {
-      const units = isBatch ? Math.max(selectedVariantIds.length, 1) : 1
-      check = hasEnoughPoints(
-        balance ?? null,
-        units,
-        dailyUsage ?? null,
-        [],
-        "free",
-        rules?.free_user_multiplier ?? 1.15,
-      )
-      if (!check.sufficient) {
-        message.error(check.reason ?? "积分不足，请充值")
-        return
-      }
+    // 积分预检查
+    const units = isBatch ? Math.max(selectedVariantIds.length, 1) : 1
+    const check = hasEnoughPoints(
+      balance ?? null,
+      units,
+      dailyUsage ?? null,
+      [],
+      "free",
+      rules?.free_user_multiplier ?? 1.15,
+    )
+    if (!check.sufficient) {
+      message.error(check.reason ?? "积分不足，请充值")
+      return
     }
     if (isBatch) {
       if (selectedVariantIds.length === 0) {
@@ -524,18 +520,19 @@ const GeneratePage: React.FC = () => {
 
   /* ── 积分消耗估算（步骤3确认生成展示用） ── */
   const unitsForCost = isBatch ? Math.max(selectedVariantIds.length, 1) : 1
-  const pointsEstimate = useMemo(() => {
-    if (!ENABLE_CREDIT_SYSTEM) return { sufficient: true, cost: 0 }
-    return hasEnoughPoints(
-      balance ?? null,
-      unitsForCost,
-      dailyUsage ?? null,
-      [],
-      "free",
-      rules?.free_user_multiplier ?? 1.15,
-    )
-  }, [unitsForCost, balance, dailyUsage, rules])
-  const insufficientPoints = ENABLE_CREDIT_SYSTEM && !pointsEstimate.sufficient
+  const pointsEstimate = useMemo(
+    () =>
+      hasEnoughPoints(
+        balance ?? null,
+        unitsForCost,
+        dailyUsage ?? null,
+        [],
+        "free",
+        rules?.free_user_multiplier ?? 1.15,
+      ),
+    [unitsForCost, balance, dailyUsage, rules],
+  )
+  const insufficientPoints = !pointsEstimate.sufficient
 
   /* ================================================================
      渲染

apps/web/src/pages/subscription/Plans.tsx

@@ -39,7 +39,6 @@ import { getDiscountPriceCents } from "@/api/points/types"
 import type { SubscriptionPlan } from "@/api/subscription/types"
 import { PLAN_LABEL, BILLING_CYCLE_LABEL } from "@/api/subscription/types"
 import "./Plans.css"
-import { ENABLE_CREDIT_SYSTEM } from "@/config/features"
 
 const { Title, Text, Paragraph } = Typography
 
@@ -250,23 +249,17 @@ const Plans: React.FC = () => {
   return (
     <div className="xx-plans-page">
       <PageHead
-        title={ENABLE_CREDIT_SYSTEM ? "会员与积分" : "会员订阅"}
-        description={
-          ENABLE_CREDIT_SYSTEM
-            ? "开通会员解锁全部功能，按需充值积分灵活使用 AI 能力"
-            : "开通会员解锁全部功能"
-        }
+        title="会员与积分"
+        description="开通会员解锁全部功能，按需充值积分灵活使用 AI 能力"
         actions={
-          ENABLE_CREDIT_SYSTEM ? (
-            <Space>
-              <Button
-                icon={<ThunderboltOutlined />}
-                onClick={() => navigate("/app/points/transactions")}
-              >
-                积分明细
-              </Button>
-            </Space>
-          ) : null
+          <Space>
+            <Button
+              icon={<ThunderboltOutlined />}
+              onClick={() => navigate("/app/points/transactions")}
+            >
+              积分明细
+            </Button>
+          </Space>
         }
       />
 
@@ -303,15 +296,13 @@ const Plans: React.FC = () => {
                   )}
                 </div>
               </div>
-              {ENABLE_CREDIT_SYSTEM && (
-                <div>
-                  <Text type="secondary">可用积分</Text>
-                  <div className="xx-current-balance">
-                    <ThunderboltOutlined style={{ color: "#8b5cf6" }} />
-                    <span className="xx-current-balance-val">{bal}</span>
-                  </div>
+              <div>
+                <Text type="secondary">可用积分</Text>
+                <div className="xx-current-balance">
+                  <ThunderboltOutlined style={{ color: "#8b5cf6" }} />
+                  <span className="xx-current-balance-val">{bal}</span>
                 </div>
-              )}
+              </div>
               {!isMember && freeLimit > 0 && (
                 <div>
                   <Text type="secondary">今日免费混剪</Text>
@@ -328,20 +319,18 @@ const Plans: React.FC = () => {
               )}
             </Space>
           </Col>
-          {ENABLE_CREDIT_SYSTEM && (
-            <Col>
-              <Button
-                type="primary"
-                icon={<ThunderboltOutlined />}
-                onClick={() => {
-                  const el = document.getElementById("points-packages")
-                  el?.scrollIntoView({ behavior: "smooth" })
-                }}
-              >
-                充值积分
-              </Button>
-            </Col>
-          )}
+          <Col>
+            <Button
+              type="primary"
+              icon={<ThunderboltOutlined />}
+              onClick={() => {
+                const el = document.getElementById("points-packages")
+                el?.scrollIntoView({ behavior: "smooth" })
+              }}
+            >
+              充值积分
+            </Button>
+          </Col>
         </Row>
       </Card>
 
@@ -472,71 +461,69 @@ const Plans: React.FC = () => {
         </Col>
       </Row>
 
-      {/* 积分充值（积分系统关闭时隐藏，代码保留不删除） */}
-      {ENABLE_CREDIT_SYSTEM && (
-        <div id="points-packages">
-          <Title level={4} style={{ marginTop: 40 }}>
-            <ThunderboltOutlined style={{ color: "#8b5cf6", marginRight: 8 }} />
-            积分充值
-            <Tooltip title="积分永久有效，可用于所有 AI 功能；付费会员享折扣">
-              <Text type="secondary" style={{ fontSize: 13, marginLeft: 8, fontWeight: "normal" }}>
-                （永久有效）
-              </Text>
-            </Tooltip>
-          </Title>
+      {/* 积分充值 */}
+      <div id="points-packages">
+        <Title level={4} style={{ marginTop: 40 }}>
+          <ThunderboltOutlined style={{ color: "#8b5cf6", marginRight: 8 }} />
+          积分充值
+          <Tooltip title="积分永久有效，可用于所有 AI 功能；付费会员享折扣">
+            <Text type="secondary" style={{ fontSize: 13, marginLeft: 8, fontWeight: "normal" }}>
+              （永久有效）
+            </Text>
+          </Tooltip>
+        </Title>
 
-          <Row gutter={[16, 16]}>
-            {packages.map((pkg) => {
-              const priceCents = getDiscountPriceCents(pkg, userDiscount)
-              const originalCents = pkg.price_cents
-              const discount =
-                priceCents < originalCents ? Math.round((1 - priceCents / originalCents) * 100) : 0
-              const unit = priceCents / 100 / pkg.points
-              const isHot = pkg.unit_price < 0.1
-              return (
-                <Col xs={24} sm={8} key={pkg.code}>
-                  <Card
-                    className={`xx-pkg-card ${discount > 0 ? "has-discount" : ""} ${isHot ? "recommended" : ""}`}
-                    hoverable
-                  >
-                    {isHot && <div className="xx-pkg-badge">热门</div>}
+        <Row gutter={[16, 16]}>
+          {packages.map((pkg) => {
+            const priceCents = getDiscountPriceCents(pkg, userDiscount)
+            const originalCents = pkg.price_cents
+            const discount =
+              priceCents < originalCents ? Math.round((1 - priceCents / originalCents) * 100) : 0
+            const unit = priceCents / 100 / pkg.points
+            const isHot = pkg.unit_price < 0.1
+            return (
+              <Col xs={24} sm={8} key={pkg.code}>
+                <Card
+                  className={`xx-pkg-card ${discount > 0 ? "has-discount" : ""} ${isHot ? "recommended" : ""}`}
+                  hoverable
+                >
+                  {isHot && <div className="xx-pkg-badge">热门</div>}
+                  {discount > 0 && (
+                    <Tag color="gold" className="xx-pkg-discount">
+                      {Math.round((priceCents / originalCents) * 10) / 1}折
+                    </Tag>
+                  )}
+                  <div className="xx-pkg-name">{pkg.name}</div>
+                  <div className="xx-pkg-points">
+                    <ThunderboltOutlined /> {pkg.points.toLocaleString()} 积分
+                  </div>
+                  <div className="xx-pkg-price">
+                    <span className="currency">¥</span>
+                    <span className="amount">
+                      {(priceCents / 100)
+                        .toFixed(priceCents % 100 === 0 ? 0 : 1)
+                        .replace(/\.0$/, "")}
+                    </span>
                     {discount > 0 && (
-                      <Tag color="gold" className="xx-pkg-discount">
-                        {Math.round((priceCents / originalCents) * 10) / 1}折
-                      </Tag>
+                      <span className="xx-pkg-origin">¥{(originalCents / 100).toFixed(0)}</span>
                     )}
-                    <div className="xx-pkg-name">{pkg.name}</div>
-                    <div className="xx-pkg-points">
-                      <ThunderboltOutlined /> {pkg.points.toLocaleString()} 积分
-                    </div>
-                    <div className="xx-pkg-price">
-                      <span className="currency">¥</span>
-                      <span className="amount">
-                        {(priceCents / 100)
-                          .toFixed(priceCents % 100 === 0 ? 0 : 1)
-                          .replace(/\.0$/, "")}
-                      </span>
-                      {discount > 0 && (
-                        <span className="xx-pkg-origin">¥{(originalCents / 100).toFixed(0)}</span>
-                      )}
-                    </div>
-                    <div className="xx-pkg-unit">≈¥{unit.toFixed(3)}/积分</div>
-                    <Button
-                      block
-                      type={isHot ? "primary" : "default"}
-                      loading={buying === pkg.code}
-                      onClick={() => handleBuyPoints(pkg)}
-                      style={{ marginTop: 12 }}
-                    >
-                      立即购买
-                    </Button>
-                  </Card>
-                </Col>
-              )
-            })}
-          </Row>
-        </div>
-      )}
+                  </div>
+                  <div className="xx-pkg-unit">≈¥{unit.toFixed(3)}/积分</div>
+                  <Button
+                    block
+                    type={isHot ? "primary" : "default"}
+                    loading={buying === pkg.code}
+                    onClick={() => handleBuyPoints(pkg)}
+                    style={{ marginTop: 12 }}
+                  >
+                    立即购买
+                  </Button>
+                </Card>
+              </Col>
+            )
+          })}
+        </Row>
+      </div>
     </div>
   )
 }

apps/web/src/store/pointsStore.ts

@@ -8,7 +8,6 @@
  * - subscription: GET /subscription/current（plan_id + billing_cycle）
  */
 import { create } from "zustand"
-import { ENABLE_CREDIT_SYSTEM } from "@/config/features"
 import { getPointsBalance, getPointsRules, getDailyUsage, getMembership } from "@/api/points"
 import { getCurrentSubscription } from "@/api/subscription"
 import type {
@@ -50,29 +49,14 @@ export const usePointsStore = create<PointsState>((set, get) => ({
 
   init: async () => {
     // 已加载过不重复拉取
-    // 积分系统关闭时：只要 subscription/membership 已有值就跳过；开启时需 balance+rules+subscription 齐了才跳过
-    if (ENABLE_CREDIT_SYSTEM) {
-      if (get().balance && get().rules && get().subscription) return
-    } else {
-      if (get().subscription && get().membership) return
-    }
+    if (get().balance && get().rules && get().subscription) return
     set({ loading: true, error: null })
     try {
-      // 积分系统关闭时不拉取余额/规则/每日额度，但仍拉会员/订阅用于 VIP 标识展示
-      const balancePromise = ENABLE_CREDIT_SYSTEM
-        ? getPointsBalance().catch(() => null)
-        : Promise.resolve(null)
-      const rulesPromise = ENABLE_CREDIT_SYSTEM
-        ? getPointsRules().catch(() => null)
-        : Promise.resolve(null)
-      const dailyUsagePromise = ENABLE_CREDIT_SYSTEM
-        ? getDailyUsage().catch(() => null)
-        : Promise.resolve(null)
       const [balance, rules, subscription, dailyUsage, membership] = await Promise.all([
-        balancePromise,
-        rulesPromise,
+        getPointsBalance().catch(() => null),
+        getPointsRules().catch(() => null),
         getCurrentSubscription().catch(() => null),
-        dailyUsagePromise,
+        getDailyUsage().catch(() => null),
         getMembership().catch(() => null),
       ])
       set({

apps/worker/video_processing/render_adapter.py

@@ -493,41 +493,6 @@ class RenderAdapter:
             logger.warning("ASR 服务初始化失败，自动字幕将不可用: %s", e)
             return None
 
-    def _resolve_clip_has_text(self, clips: list[Any]) -> list[bool] | None:
-        """#1970：按源视频片段顺序解析 atom_clip.ai_tags.has_text。
-
-        顺序与 UnifiedRenderService 的「非 audio 源片段」口径一致。
-        仅当 atom_clip 存在 ai_tags 字典且 has_text 显式为 False 时标记为
-        无文字（允许 hflip）；atom_clip_id 缺失、ai_tags 未生成、has_text 为
-        true/null/非布尔值时一律按有文字处理（保守不翻转）。
-        查询失败时返回 None，渲染层回退到全保守路径。
-        """
-        video_clips = [c for c in clips if getattr(c, "clip_type", "main") != "audio"]
-        atom_ids: list[str] = []
-        seen: set[str] = set()
-        for c in video_clips:
-            atom_id = getattr(c, "atom_clip_id", "") or ""
-            if atom_id and atom_id not in seen:
-                seen.add(atom_id)
-                atom_ids.append(atom_id)
-        if not atom_ids:
-            return None
-        try:
-            from packages.adapters.sqlalchemy_impl.asset_atom_clip_repository import (
-                SQLAlchemyAssetAtomClipRepository,
-            )
-
-            atom_clips = SQLAlchemyAssetAtomClipRepository(self._db).find_by_ids(atom_ids)
-        except Exception as exc:
-            logger.warning("[render-adapter] atom_clip ai_tags 查询失败，hflip 全量保守处理: %s", exc)
-            return None
-        has_text_map: dict[str, bool] = {}
-        for ac in atom_clips:
-            ai_tags = getattr(ac, "ai_tags", None)
-            no_text = isinstance(ai_tags, dict) and ai_tags.get("has_text") is False
-            has_text_map[ac.id] = not no_text
-        return [has_text_map.get((getattr(c, "atom_clip_id", "") or ""), True) for c in video_clips]
-
     def _do_render(
         self,
         plan: Any,
@@ -577,7 +542,6 @@ class RenderAdapter:
         )
 
         # 4. 执行统一渲染
-        clip_has_text = self._resolve_clip_has_text(clips)
         render_svc = UnifiedRenderService(
             plan=plan,
             clips=clips,
@@ -588,7 +552,6 @@ class RenderAdapter:
             bgm_path=bgm_path,
             asr_service=asr_service,
             voiceover_audio_path=voiceover_audio_path,
-            clip_has_text=clip_has_text,
         )
         result = render_svc.render()
 

apps/worker/video_processing/unified_render_service.py

@@ -155,7 +155,6 @@ class UnifiedRenderService:
         asr_service: Any = None,  # ASRService 实例，用于自动生成字幕
         bgm_path: str | None = None,  # BGM 本地文件路径
         voiceover_audio_path: str | None = None,  # 配音素材库音频本地路径
-        clip_has_text: list[bool] | None = None,  # 源视频片段是否有文字（来自 atom_clip.ai_tags.has_text）
     ):
         self.plan = plan
         self.clips = clips
@@ -168,8 +167,6 @@ class UnifiedRenderService:
         self.asr_service = asr_service
         self.bgm_path = bgm_path
         self.voiceover_audio_path = voiceover_audio_path
-        # #1970：片段级文字检测（顺序与非 audio 的源视频片段一致）；None 表示无可靠检测，保守不翻转
-        self._clip_has_text = clip_has_text
         self._transition_engine = TransitionEngine(default_duration=transition_duration)
         self._speed_engine = SpeedEngine()
         self._asr_timeline_cache: Any = None  # ASR 字幕结果缓存，避免重复调用
@@ -189,9 +186,7 @@ class UnifiedRenderService:
 
         种子 hash(generation_task_id + video_index)%10000，同一任务重渲结果一致。
         dedup_enabled=False 时返回 None，调用方不注入任何微变换。
-        hflip 放开（#1970）：clip_has_text 来自 atom_clip.ai_tags.has_text，
-        仅 AI 明确判定无文字的片段可参与 50% 翻转；未打标签 / has_text 为
-        true/null 或缺位时一律视为有文字，保持保守不翻转。
+        P1 字幕检测：无可靠的片段文字轨道信息，hflip 一律关闭（宁可不翻转）。
         """
         if self._micro_plan_loaded:
             return self._micro_plan_cache
@@ -205,14 +200,11 @@ class UnifiedRenderService:
             cfg = self.plan.config or {}
             task_id = str(cfg.get("generation_task_id", "") or "")
             video_index = int(cfg.get("video_index", 0) or 0)
-            # self._clip_has_text 顺序与非 audio 源片段一致；
-            # None（未提供检测，如内存直渲/旧任务）→ 纯函数层按全有文字保守处理；
-            # 列表短于片段数时缺位片段同样按有文字处理
             self._micro_plan_cache = build_micro_transform_plan(
                 task_id,
                 video_index,
                 clip_count,
-                clip_has_text=self._clip_has_text,
+                clip_has_text=None,  # P1 保守策略：全部按有文字处理，不翻转
                 enable_bgm_offset=bool(cfg.get("bgm")),
             )
         except Exception as e:

apps/worker/worker_app/celery_app.py

@@ -28,10 +28,6 @@ celery_app.conf.imports = (
     "worker_app.tasks.health",
     "worker_app.tasks.ingest",
     "worker_app.tasks.atom_clips",
-    # #1970 片段级 AI 标签：必须显式 import 注册，否则 worker 报
-    # "Received unregistered task of type 'worker.tag_atom_clip'"
-    "worker_app.tasks.atom_clip_tagging",
-    "worker_app.tasks.backfill_atom_clip_tags",
     "worker_app.tasks.classification",
     "worker_app.tasks.generation",
     "worker_app.tasks.voice_extraction",

apps/worker/worker_app/tasks/__init__.py

@@ -57,14 +57,6 @@ def __getattr__(name: str):
         from .atom_clips import generate_atom_clips
 
         return generate_atom_clips
-    elif name == "tag_atom_clip_task":
-        from .atom_clip_tagging import tag_atom_clip_task
-
-        return tag_atom_clip_task
-    elif name == "backfill_atom_clip_tags":
-        from .backfill_atom_clip_tags import backfill_atom_clip_tags
-
-        return backfill_atom_clip_tags
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 

apps/worker/worker_app/tasks/atom_clip_tagging.py

@@ -1,98 +0,0 @@
-"""片段级 AI 标签 Celery 任务 — #1970 智能剪辑流程重构 P2.
-
-为单个 atom_clip 调用视觉 AI 生成结构化标签，并更新到 ai_tags 字段。
-失败不阻断流程（降级为仅继承素材标签）。
-
-任务名：worker.tag_atom_clip
-"""
-
-from __future__ import annotations
-
-from celery.utils.log import get_task_logger
-from worker_app.celery_app import celery_app
-from worker_app.db import SessionLocal
-
-from packages.adapters.sqlalchemy_impl.asset_atom_clip_repository import (
-    SQLAlchemyAssetAtomClipRepository,
-)
-from packages.adapters.sqlalchemy_impl.asset_repository import SQLAlchemyAssetRepository
-from packages.domain.atom_clip_tagger import tag_atom_clip
-from packages.shared.ai_client import get_doubao_client
-from packages.shared.mediakit_client import get_mediakit_client
-from packages.shared.storage import get_shared_storage_service
-
-logger = get_task_logger(__name__)
-
-
-@celery_app.task(name="worker.tag_atom_clip", bind=True, max_retries=2, default_retry_delay=10)
-def tag_atom_clip_task(self, atom_clip_id: str, force: bool = False) -> dict:
-    """为单个原子片段生成 AI 标签.
-
-    Args:
-        atom_clip_id: 原子片段 ID。
-        force: True 时允许覆盖只有 inherited_tags 的降级记录
-            （视觉 API 曾失败写入的占位标签，#1970）。
-            已有完整标签（含 has_text）始终跳过，保证幂等。
-
-    Returns:
-        任务结果 dict：status / clip_id / ai_tags（部分字段）。
-    """
-    db = SessionLocal()
-    try:
-        atom_repo = SQLAlchemyAssetAtomClipRepository(db)
-        asset_repo = SQLAlchemyAssetRepository(db)
-
-        clip = atom_repo.find_by_id(atom_clip_id)
-        if clip is None:
-            return {"status": "skipped", "reason": "clip not found", "clip_id": atom_clip_id}
-
-        # 已有完整标签则跳过（幂等）；force 仅放行缺失 has_text 的降级记录
-        if clip.ai_tags is not None:
-            has_real_tags = isinstance(clip.ai_tags, dict) and "has_text" in clip.ai_tags
-            if has_real_tags or not force:
-                return {"status": "skipped", "reason": "already tagged", "clip_id": atom_clip_id}
-
-        # 获取素材信息
-        asset = asset_repo.find_by_id(clip.asset_id)
-        if asset is None:
-            return {"status": "skipped", "reason": "asset not found", "clip_id": atom_clip_id}
-
-        # 获取视频可访问 URL
-        storage = get_shared_storage_service()
-        video_url = storage.get_download_url(asset.storage_key, expires_seconds=3600)
-
-        # 初始化客户端
-        doubao_client = get_doubao_client()
-        mediakit_client = get_mediakit_client()
-
-        # 调用 tagger
-        ai_tags = tag_atom_clip(
-            clip=clip,
-            video_url=video_url,
-            doubao_client=doubao_client,
-            mediakit_client=mediakit_client,
-            storage=storage,
-        )
-
-        # 更新数据库
-        atom_repo.update_ai_tags(atom_clip_id, ai_tags)
-
-        logger.info(
-            "[atom_clip_tagging] clip_id=%s ai_tags=%s",
-            atom_clip_id,
-            {k: v for k, v in ai_tags.items() if k != "inherited_tags"},
-        )
-        return {
-            "status": "completed",
-            "clip_id": atom_clip_id,
-            "has_ai_tags": any(v for k, v in ai_tags.items() if k != "inherited_tags" and v),
-        }
-    except Exception as exc:
-        db.rollback()
-        logger.exception("[atom_clip_tagging] clip_id=%s 失败: %s", atom_clip_id, exc)
-        # 可重试异常
-        if self.request.retries < self.max_retries:
-            raise self.retry(exc=exc) from None
-        return {"status": "failed", "clip_id": atom_clip_id, "error": str(exc)}
-    finally:
-        db.close()

apps/worker/worker_app/tasks/atom_clips.py

@@ -3,8 +3,6 @@
 素材入库预处理完成（ingest 置 READY）后异步触发：
 根据素材时长和已缓存的 scdet 切换点计算原子片段并落库。
 失败不阻断素材入库主流程（atom_clips 未就绪时选片有内存兜底）。
-
-P2 增强：切片完成后自动链式触发 AI 标签任务（每个 clip 一个 tag_atom_clip 任务）。
 """
 
 from __future__ import annotations
@@ -74,10 +72,6 @@ def generate_atom_clips(asset_id: str) -> dict:
             asset_id,
             len(clips),
         )
-
-        # P2 增强：链式触发 AI 标签任务（每个 clip 一个异步任务）
-        _dispatch_tagging_tasks(clips)
-
         return {"status": "completed", "asset_id": asset_id, "clips_count": len(clips)}
     except Exception as exc:  # noqa: BLE001 - 后台任务兜底，失败不阻断主流程
         db.rollback()
@@ -85,25 +79,3 @@ def generate_atom_clips(asset_id: str) -> dict:
         return {"status": "failed", "asset_id": asset_id, "error": str(exc)}
     finally:
         db.close()
-
-
-def _dispatch_tagging_tasks(clips: list) -> None:
-    """为每个新建片段发送 AI 标签异步任务.
-
-    失败不阻断（标签任务是锦上添花，不影响核心流程）。
-    """
-    try:
-        for clip in clips:
-            celery_app.send_task(
-                "worker.tag_atom_clip",
-                args=[clip.id],
-            )
-        logger.info(
-            "[atom_clips] 已发送 %d 个 AI 标签任务",
-            len(clips),
-        )
-    except Exception as e:
-        logger.warning(
-            "[atom_clips] 发送 AI 标签任务失败（不影响切片结果）: %s",
-            e,
-        )

apps/worker/worker_app/tasks/backfill_atom_clip_tags.py

@@ -1,106 +0,0 @@
-"""批量回填 AI 标签 Celery 任务 — #1970 智能剪辑流程重构 P2.
-
-查找所有 ai_tags IS NULL 的 atom_clips，分批触发 tag_atom_clip 任务。
-可通过 API 路由触发（管理员权限）。
-
-任务名：worker.backfill_atom_clip_tags
-"""
-
-from __future__ import annotations
-
-import time
-
-from celery.utils.log import get_task_logger
-from worker_app.celery_app import celery_app
-from worker_app.db import SessionLocal
-
-from packages.adapters.sqlalchemy_impl.asset_atom_clip_repository import (
-    SQLAlchemyAssetAtomClipRepository,
-)
-
-logger = get_task_logger(__name__)
-
-# 默认批量参数
-DEFAULT_BATCH_SIZE = 10
-DEFAULT_BATCH_INTERVAL = 5  # 秒
-
-
-@celery_app.task(name="worker.backfill_atom_clip_tags")
-def backfill_atom_clip_tags(
-    batch_size: int = DEFAULT_BATCH_SIZE,
-    batch_interval: int = DEFAULT_BATCH_INTERVAL,
-    max_clips: int = 0,
-    force: bool = False,
-) -> dict:
-    """批量回填未打标的 atom_clips.
-
-    Args:
-        batch_size: 每批处理数量，默认 10。
-        batch_interval: 每批间隔秒数，默认 5。
-        max_clips: 最大处理总数，0 表示不限。
-        force: True 时连同只有 inherited_tags 的降级记录一起强制重打
-            （视觉 API 曾失败、DOUBAO_VISION_MODEL 修复后重跑用，#1970）。
-
-    Returns:
-        任务结果 dict：total_submitted / batches。
-    """
-    db = SessionLocal()
-    try:
-        atom_repo = SQLAlchemyAssetAtomClipRepository(db)
-        total_submitted = 0
-        batches = 0
-
-        while True:
-            # 查找未打标的片段
-            remaining = max_clips - total_submitted if max_clips > 0 else batch_size
-            fetch_limit = min(batch_size, remaining) if max_clips > 0 else batch_size
-
-            untagged = atom_repo.find_untagged(limit=fetch_limit, include_downgraded=force)
-            if not untagged:
-                break
-
-            # 逐个发送 tag 任务
-            for clip in untagged:
-                try:
-                    celery_app.send_task(
-                        "worker.tag_atom_clip",
-                        args=[clip.id],
-                        kwargs={"force": force},
-                    )
-                    total_submitted += 1
-                except Exception as e:
-                    logger.warning(
-                        "[backfill] 提交任务失败 clip_id=%s: %s",
-                        clip.id,
-                        e,
-                    )
-
-            batches += 1
-            logger.info(
-                "[backfill] 第 %d 批完成，已提交 %d 个任务",
-                batches,
-                total_submitted,
-            )
-
-            # 检查是否达到上限
-            if max_clips > 0 and total_submitted >= max_clips:
-                break
-
-            # 批间间隔
-            time.sleep(batch_interval)
-
-        logger.info(
-            "[backfill] 回填完成: total_submitted=%d batches=%d",
-            total_submitted,
-            batches,
-        )
-        return {
-            "status": "completed",
-            "total_submitted": total_submitted,
-            "batches": batches,
-        }
-    except Exception as exc:
-        logger.exception("[backfill] 回填失败: %s", exc)
-        return {"status": "failed", "error": str(exc)}
-    finally:
-        db.close()

deploy/configs/.env.production

@@ -234,9 +234,6 @@ DOUBAO_TIMEOUT=60
 # 最大重试次数
 DOUBAO_MAX_RETRIES=2
 
-# 视觉模型 Endpoint ID（支持图片/视频理解的模型）
-DOUBAO_VISION_MODEL=${DOUBAO_VISION_MODEL}
-
 
 # ==================== 微信开放平台 OAuth（网页扫码登录）====================
 # 回调域名：xiaoxiajianji.com（微信开放平台已配置）
@@ -255,11 +252,3 @@ DOUYIN_DEBUG_ERRORS=false
 TIKHUB_API_KEY=${TIKHUB_API_KEY}
 # P2: apizero.cn（国内付费，https://apizero.cn）
 APIZERO_API_KEY=${APIZERO_API_KEY}
-
-# ==================== GPU MuseTalk Worker（反向轮询） ====================
-GPU_WORKER_TOKEN=${GPU_WORKER_TOKEN}
-GPU_TASK_TIMEOUT_SECONDS=900
-USE_GPU_LIPSYNC=false
-GPU_LIPSYNC_POLL_INTERVAL=5
-GPU_LIPSYNC_WAIT_TIMEOUT=1200
-GPU_WORKER_STALE_SECONDS=300

deploy/configs/.env.staging

@@ -251,9 +251,6 @@ DOUBAO_TIMEOUT=60
 # 最大重试次数
 DOUBAO_MAX_RETRIES=2
 
-# 视觉模型 Endpoint ID（支持图片/视频理解的模型）
-DOUBAO_VISION_MODEL=${DOUBAO_VISION_MODEL}
-
 
 # ==================== 微信开放平台 OAuth（网页扫码登录）====================
 # 回调域名：xiaoxiajianji.com（微信开放平台已配置）
@@ -272,11 +269,3 @@ DOUYIN_DEBUG_ERRORS=false
 TIKHUB_API_KEY=${TIKHUB_API_KEY}
 # P2: apizero.cn（国内付费，https://apizero.cn）
 APIZERO_API_KEY=${APIZERO_API_KEY}
-
-# ==================== GPU MuseTalk Worker（反向轮询） ====================
-GPU_WORKER_TOKEN=${GPU_WORKER_TOKEN}
-GPU_TASK_TIMEOUT_SECONDS=900
-USE_GPU_LIPSYNC=true
-GPU_LIPSYNC_POLL_INTERVAL=5
-GPU_LIPSYNC_WAIT_TIMEOUT=1200
-GPU_WORKER_STALE_SECONDS=300

deploy/gpu_worker/.env.example

@@ -1,30 +0,0 @@
-# ============================================================
-# MuseTalk GPU Worker 环境变量
-# 部署到 RTX2060 电脑后，复制为 .env 并修改值
-# ============================================================
-
-# SaaS API 基础 URL（staging / production）
-API_BASE_URL=https://staging-api.xiaoxiajianji.com
-# API_BASE_URL=https://api.xiaoxiajianji.com   # 生产
-
-# 长期 API Token，必须与服务端 GPU_WORKER_TOKEN 一致（找后端拿）
-GPU_WORKER_TOKEN=replace-with-real-token
-
-# 本机 Worker 唯一 ID（默认自动生成 hostname+MAC 后4位，可手动指定）
-# WORKER_ID=rtx2060-0193
-
-# 本地 MuseTalk 地址（默认 http://127.0.0.1:7861）
-MUSE_TALK_URL=http://127.0.0.1:7861
-
-# 轮询/心跳/超时（秒）
-POLL_INTERVAL=5
-HEARTBEAT_INTERVAL=15
-# 下载/推理/上传 HTTP 超时，需与服务端 GPU_TASK_TIMEOUT_SECONDS 对齐（默认 900）
-REQUEST_TIMEOUT=900
-
-# 单个任务本地最大重试次数（仅网络/MuseTalk 瞬时错误才重试，默认 1）
-TASK_MAX_RETRY=1
-# 推理期间任务心跳间隔（秒，独立线程，无需改动）
-TASK_HEARTBEAT_INTERVAL=30
-# 输入视频最短时长（秒），小于则直接上报失败，不调用 MuseTalk
-MIN_VIDEO_DURATION_SECONDS=3

deploy/gpu_worker/README.md

@@ -1,353 +0,0 @@
-# MuseTalk GPU Worker 部署指南
-
-本目录包含两个组件：
-
-1. **gpu_worker.py**：反向轮询客户端，部署在 RTX2060 本地，轮询 SaaS API 拉取口型任务，调用本地 MuseTalk 服务推理，上传结果回 SaaS。
-2. **musetalk_server.py**：MuseTalk Flask HTTP 服务端，接收 gpu_worker.py 的推理请求，调用 MuseTalk 模型生成口型同步视频。
-
----
-
-## 一、环境准备
-
-### 1.1 硬件要求
-
-- GPU: NVIDIA RTX 2060 或更高（显存 ≥ 6GB）
-- CUDA: 11.8+
-- Python: 3.10+
-- ffmpeg: 需安装并加入 PATH
-
-### 1.2 安装依赖
-
-```bash
-cd deploy/gpu_worker
-python3 -m venv venv
-source venv/bin/activate
-pip install -r requirements.txt
-```
-
----
-
-## 二、MuseTalk 服务端部署（musetalk_server.py）
-
-### 2.1 配置环境变量
-
-复制 `.env.example` 为 `.env`，修改配置：
-
-```bash
-cp .env.example .env
-vim .env
-```
-
-关键配置：
-
-| 变量 | 说明 | 默认值 |
-|------|------|--------|
-| `MUSE_PORT` | 监听端口 | `7861` |
-| `MUSE_INFERENCE_TIMEOUT` | 推理超时秒数 | `600` |
-| `MUSE_VIDEO_MAX_MB` | 视频上传大小限制 MB | `100` |
-| `MUSE_AUDIO_MAX_MB` | 音频上传大小限制 MB | `20` |
-| `MUSE_DEFAULT_FPS` | 视频 fps 兜底值 | `25.0` |
-| `MUSE_TEMP_DIR` | 临时文件目录 | `/tmp/musetalk_$$` |
-| `MUSE_VIDEO_ENCODER` | 兜底循环视频时的编码器：`auto`（优先 h264_nvenc，失败回退 libx264）/`h264_nvenc`/`libx264` | `auto` |
-
-### 2.2 更新部署（v2 性能修复，必做）
-
-> ⚠️ 2026-09-20 v2 架构：修复 16 倍性能回归。旧版在推理前 loop 视频导致 MuseTalk 处理帧数翻倍、RTX2060 推理 >200s、nginx 504。**必须重新拉取并重启**：
-
-```bash
-# 在 RTX2060 上备份旧文件并拉取新版本
-cp ~/projects/MuseTalk/musetalk_server.py ~/projects/MuseTalk/musetalk_server.py.bak
-wget -O ~/projects/MuseTalk/musetalk_server.py \
-  "https://git.xiaoxiajianji.com/xiaoxia/xiaoxia-saas/raw/branch/develop/deploy/gpu_worker/musetalk_server.py"
-
-# 重启服务
-sudo systemctl restart musetalk-server
-sudo systemctl status musetalk-server
-curl http://127.0.0.1:7861/health
-```
-
-v2 架构核心变化：
-
-- **MuseTalk 直传全量音频**：不再在推理前用 ffmpeg 循环视频。MuseTalk 原生支持长音频输入，内部自动循环视频帧。推理时间不变（~14s/5s 视频）
-- **ffmpeg 只做快速封装**：`-c:v copy -c:a aac -shortest`，秒级完成，不重编码
-- **循环仅兜底**：仅当 MuseTalk 输出画面短于音频时（极端情况），才 `-stream_loop` + NVENC 兜底
-- **删除 `MUSE_ENABLE_VIDEO_LOOP`**：不再需要此开关，MuseTalk 原生处理
-
-### 2.3 启动服务
-
-```bash
-# 前台运行（调试用）
-python musetalk_server.py
-
-# 后台运行（生产用 systemd）
-sudo systemctl start musetalk-server
-sudo systemctl enable musetalk-server
-```
-
-### 2.4 验证健康检查
-
-```bash
-curl http://127.0.0.1:7861/health
-```
-
-应返回：
-
-```json
-{
-  "status": "healthy",
-  "gpu": {
-    "gpu_name": "NVIDIA GeForce RTX 2060",
-    "memory_total_mb": 6144,
-    "memory_used_mb": 1024,
-    "memory_free_mb": 5120
-  },
-  "current_task": {
-    "task_id": null,
-    "running": false,
-    "elapsed_seconds": 0.0
-  },
-  "timestamp": 1700000000.0
-}
-```
-
----
-
-## 三、GPU Worker 客户端部署（gpu_worker.py）
-
-### 3.1 配置环境变量
-
-复制 `.env.example` 为 `.env`，修改配置：
-
-```bash
-cp .env.example .env
-vim .env
-```
-
-关键配置：
-
-| 变量 | 说明 | 默认值 |
-|------|------|--------|
-| `API_BASE_URL` | SaaS API 基础 URL | `https://staging-api.xiaoxiajianji.com` |
-| `GPU_WORKER_TOKEN` | 长期 API Token（与服务端一致） | - |
-| `MUSE_TALK_URL` | 本地 MuseTalk 服务地址 | `http://127.0.0.1:7861` |
-| `POLL_INTERVAL` | 轮询间隔秒 | `5` |
-| `HEARTBEAT_INTERVAL` | 空闲心跳间隔秒 | `15` |
-| `REQUEST_TIMEOUT` | HTTP 请求超时秒 | `900` |
-| `TASK_MAX_RETRY` | 本地最大重试次数 | `1` |
-| `TASK_HEARTBEAT_INTERVAL` | 推理期间任务心跳间隔秒 | `30` |
-| `MIN_VIDEO_DURATION_SECONDS` | 最短输入视频时长秒 | `3` |
-
-### 3.2 启动 Worker
-
-```bash
-# 前台运行（调试用）
-python gpu_worker.py
-
-# 后台运行（生产用 systemd）
-sudo systemctl start xiaoxia-gpu-worker
-sudo systemctl enable xiaoxia-gpu-worker
-```
-
-### 3.3 验证启动日志
-
-应看到：
-
-```
-============================================================
-MuseTalk GPU Worker 启动
-  worker_id   = rtx2060-xxxx
-  api_base    = https://staging-api.xiaoxiajianji.com
-  muse_talk   = http://127.0.0.1:7861
-  poll        = 5.0s / heartbeat = 15.0s
-============================================================
-MuseTalk 健康检查通过: {...}
-注册/心跳成功
-```
-
----
-
-## 四、常见问题排查
-
-| 现象 | 可能原因 / 排查 |
-|---|---|
-| 日志 401 `Invalid GPU worker token` | `.env` 的 `GPU_WORKER_TOKEN` 与服务端不一致 |
-| 日志 `MuseTalk 健康检查未通过` | 本地 MuseTalk 没启动，或端口不是 7861；`curl http://127.0.0.1:7861/health` 验证 |
-| 任务长时间不被拉取 | Worker 和服务端连不上；检查 API_BASE_URL 是否可达、Token 是否正确 |
-| 推理后上传 OSS 失败 | 本地出口网络被防火墙拦截 OSS 域名（oss-cn-hangzhou.aliyuncs.com） |
-| 服务端看到任务回退到 pending 重试 | 任务心跳真正超时（默认 900s）：Worker 进程崩溃/断网，或推理彻底卡死；正常长推理期间心跳线程每 30s 续期，不会回退 |
-| 日志 `MuseTalk 推理超时或连接失败` | 视频太长或显存不足；可临时调大 REQUEST_TIMEOUT（服务端 GPU_TASK_TIMEOUT_SECONDS 需同步调大），或限制输入视频时长 |
-| 日志 `视频过短（x.xxs < 3s）` | 输入视频不足 3s，MuseTalk 对短视频会 division by zero，已在本地直接上报失败；可用 MIN_VIDEO_DURATION_SECONDS 调整阈值 |
-| MuseTalk 服务端 503 `GPU 正在处理其他任务` | 并发请求被锁拒绝，等当前推理完成即可 |
-| MuseTalk 服务端 504 `推理超时` | 推理超过 MUSE_INFERENCE_TIMEOUT，客户端会调 /cancel 终止服务端任务 |
-
----
-
-## 五、安全注意事项
-
-- `.env` 包含长期 Token，文件权限设为 600（`chmod 600 .env`）
-- Token 泄露要立即在服务端更换 `GPU_WORKER_TOKEN` 并重启 Worker
-- Worker 只需要出站访问 SaaS API 和 OSS，不需要开放任何入站端口
-- MuseTalk 服务端只监听本地 127.0.0.1（或 0.0.0.0 但通过防火墙限制），不暴露到公网
-- 临时文件自动清理（推理完成/失败后），无需手动维护
-
----
-
-## 六、工程改进记录（musetalk_server.py）
-
-相比原 `worker.py`，修复了以下 8 个 bug：
-
-1. **Flask 单线程阻塞**：`app.run(threaded=True)`，推理时 `/health` 仍可响应
-2. **fps=0 除零崩溃**：`_get_video_fps()` 兜底 `MUSE_DEFAULT_FPS`
-3. **ffmpeg 不检查返回码**：`subprocess.run(check=True)` + 超时检查，失败立即报错
-4. **无并发锁**：`threading.Lock` 控制并发，第二请求立即 503
-5. **无推理超时**：线程 join timeout，超时返回 504 并调 `/cancel`
-6. **结果文件不清理**：推理完成/失败后自动删除临时目录
-7. **无人脸检测兜底**：MuseTalk 推理内部处理（TODO: 可在 `_run_inference` 前置检查）
-8. **上传无大小限制**：`_check_file_size()` 校验，超限返回 413
-
-新增：
-- `/cancel` 端点：终止当前推理任务，清理临时文件
-- `/health` 端点：返回 GPU 显存信息和当前任务状态
-
-2026-09-20 追加修复（音轨正确性，上线阻断级）：
-
-9. **音轨未替换（严重）**：旧最终封装让 ffmpeg 默认选流，结果保留了源视频自带音轨（与画面相关系数 0.9998，与 TTS 无关）。改为 `_mux_video_with_audio()` 统一封装，强制 `-map 0:v:0 -map 1:a:0`，画面取 MuseTalk 无声产物、音轨只取驱动音频
-10. **音视频时长不对齐**：TTS 长于原视频时 `-shortest` 会截短语音。改为探测双方时长，音频更长时 `-stream_loop -1` 循环画面 + `h264_nvenc` 硬件重编码（`MUSE_VIDEO_ENCODER=auto`，失败回退 libx264）+ `-t <音频时长>`；不循环时 `-c:v copy` 秒封装
-    - 开关 `MUSE_ENABLE_VIDEO_LOOP=0` 可关闭循环；请求也支持 form 参数 `enable_video_loop` 单任务覆盖
-
-2026-09-20 v2 架构重构（性能回归修复，上线阻断级）：
-
-11. **16 倍性能回归**：#9/#10 的实现虽然音轨正确，但在某些集成场景下（推理前 loop 视频再喂 MuseTalk）导致推理帧数 ×2.2 + 叠加 ffmpeg 软编码预处理，5s 视频 +11s 音频推理 >200s，nginx 60s 超时 504
-    - **正确架构**：MuseTalk 原生支持长音频输入，内部自动循环视频帧。把【原视频】+【全量音频】直传 MuseTalk，输出时长=音频时长
-    - **ffmpeg 后置快速封装**：`-c:v copy -c:a aac -shortest` 秒级完成，不重编码
-    - **循环仅兜底**：仅当 MuseTalk 输出画面短于音频时（极端情况），才 `-stream_loop` + NVENC 兜底补齐
-    - **业务侧异步化**：POST /lipsync/jobs 创建 GPU 任务后立即返回 `job.status="processing"`，Celery 异步等待结果回写。前端 GET /jobs/{id} 轮询。避免同步阻塞 HTTP 请求 >200s
-    - **删除 `MUSE_ENABLE_VIDEO_LOOP`**：不再需要此开关
-
----
-
-## 七、自动部署
-
-从 2026-09-20 起，GPU 节点配置文件和脚本全部入库到 `deploy/gpu_worker/`，支持一键初始化新节点 + develop 分支 push 后 30 秒内自动拉取更新。
-
-### 7.1 服务架构
-
-每个 GPU 渲染节点运行三个 systemd 单元：
-
-| 单元 | 类型 | 作用 |
-|---|---|---|
-| `musetalk-worker.service` | simple（常驻） | MuseTalk Flask 推理 API（监听 127.0.0.1:7861） |
-| `xiaoxia-gpu-worker.service` | simple（常驻） | 反向轮询 SaaS API 拉口型任务的 Worker 客户端 |
-| `gpu-poll.timer` + `gpu-poll.service` | timer（每 30s 触发 oneshot） | 轮询 Gitea `deploy/gpu_worker/` 最新 commit，有变更自动执行 update 脚本 |
-
-脚本目录（节点本地）：
-
-| 路径 | 来源 | 作用 |
-|---|---|---|
-| `~/projects/update-gpu-worker.sh` | `scripts/update-gpu-worker.sh` | 备份 → 拉代码 → 重启两个服务 → 健康检查 → 失败回滚 |
-| `~/projects/gpu-webhook/poll_and_update.sh` | `scripts/poll_and_update.sh` | 轮询 Gitea API 比对 SHA，有新 commit 时触发 update |
-
-### 7.2 新节点部署步骤
-
-**前置准备**（手动，首次部署必做）：
-
-1. 安装 NVIDIA 驱动 + CUDA 11.8+，`nvidia-smi` 能看到 GPU
-2. 克隆 MuseTalk 代码到 `~/projects/MuseTalk/`，下载模型权重到 `~/projects/MuseTalk/models/musetalk/`（权重约几 GB，不适合自动下载）
-3. 创建 Python 虚拟环境 `~/projects/MuseTalk/venv/` 并安装 MuseTalk 依赖（PyTorch CUDA 版等）
-4. 创建 Worker 虚拟环境 `/opt/xiaoxia-gpu-worker/venv/` 并 `pip install -r requirements.txt`
-5. 准备 `.env` 文件（Worker 端）：`/opt/xiaoxia-gpu-worker/.env`，填好 `API_BASE_URL`、`GPU_WORKER_TOKEN`、`MUSE_TALK_URL` 等（参考 `.env.example`）
-
-> ⚠️ 模型权重和 Python 虚拟环境（含 CUDA 版 PyTorch）体积大、安装慢，首次部署必须手动准备；后续脚本只更新 `.py` 文件和配置，不碰权重和 venv。
-
-**一键初始化**：
-
-```bash
-# 从仓库拉取 setup 脚本并执行（在全新 GPU 机器上以 ying 用户执行）
-wget -q -O /tmp/setup-gpu-node.sh \
-  "https://git.xiaoxiajianji.com/xiaoxia/xiaoxia-saas/raw/branch/develop/deploy/gpu_worker/scripts/setup-gpu-node.sh"
-bash /tmp/setup-gpu-node.sh
-```
-
-脚本自动完成：
-
-1. apt 安装系统依赖（python3、ffmpeg、wget、curl、git）
-2. 创建必要目录（`~/projects/MuseTalk`、`~/projects/gpu-webhook`、`/opt/xiaoxia-gpu-worker`）
-3. 从仓库拉取三个 systemd 单元文件 + update/poll 脚本到本地
-4. 安装 systemd 服务到 `/etc/systemd/system/`
-5. 配置 sudo 免密（仅允许 `ying` 用户免密 restart 两个服务、status、journalctl、cp、chmod、tee）
-6. 首次执行 update 脚本拉取最新 `musetalk_server.py` 和 `gpu_worker.py`
-7. `systemctl daemon-reload` + enable + start 三个单元
-
-**初始化后检查**：
-
-```bash
-sudo systemctl status musetalk-worker       # 应 active (running)
-sudo systemctl status xiaoxia-gpu-worker    # 应 active (running)
-sudo systemctl status gpu-poll.timer        # 应 active (waiting)
-curl http://127.0.0.1:7861/health          # 应返回 healthy + GPU 显存信息
-```
-
-### 7.3 自动更新机制
-
-push 到 `develop` 分支且修改了 `deploy/gpu_worker/` 下任何文件后：
-
-1. `gpu-poll.timer` 每 30 秒触发 `gpu-poll.service`
-2. `poll_and_update.sh` 调用 Gitea API 取 `deploy/gpu_worker/` 路径最新 commit SHA
-3. 与本地 `~/projects/gpu-webhook/.last_commit` 比对，无变更直接退出
-4. 有变更：写入新 SHA → 执行 `update-gpu-worker.sh`
-5. `update-gpu-worker.sh` 执行流程：
-   - 备份当前 `musetalk_server.py` / `gpu_worker.py`（带时间戳后缀）
-   - wget 拉取最新 `musetalk_server.py`、`gpu_worker.py`
-   - 比对 `requirements.txt`，有变化则 pip install
-   - `sudo systemctl restart musetalk-worker`，等 5 秒
-   - `sudo systemctl restart xiaoxia-gpu-worker`，等 8 秒
-   - `curl http://127.0.0.1:7861/health` 健康检查
-   - 健康 → 写日志退出 0
-   - 不健康 → 回滚到最新备份 → 重启 → 退出 1（日志记录 rolled back）
-
-端到端延迟：从 push 到节点拉到新代码并重启，约 30~60 秒。
-
-### 7.4 手动更新命令
-
-```bash
-# 立即手动触发一次更新（不依赖 timer）
-bash ~/projects/update-gpu-worker.sh
-
-# 查看更新日志
-tail -f /tmp/gpu-worker-update.log
-
-# 查看轮询日志
-tail -f /tmp/gpu-poll.log
-
-# 查看服务运行日志
-journalctl -u musetalk-worker -f          # MuseTalk 推理服务日志
-journalctl -u xiaoxia-gpu-worker -f       # GPU Worker 客户端日志
-journalctl -u gpu-poll.service -f         # 轮询/更新触发日志
-```
-
-### 7.5 仓库文件清单（自动部署相关）
-
-```
-deploy/gpu_worker/
-├── musetalk-worker.service        # MuseTalk 推理 API 的 systemd 服务
-├── gpu-poll.service               # 自动更新轮询 oneshot service
-├── gpu-poll.timer                 # 每 30 秒触发轮询的 timer
-├── xiaoxia-gpu-worker.service     # GPU Worker 客户端 systemd 服务（已有）
-├── gpu_worker.py                  # GPU Worker 客户端脚本（已有，自动更新）
-├── musetalk_server.py             # MuseTalk Flask 服务端（已有，自动更新）
-├── requirements.txt               # Worker Python 依赖（已有）
-├── .env.example                   # Worker 环境变量模板（已有）
-├── README.md                      # 本文档
-└── scripts/
-    ├── update-gpu-worker.sh       # 更新脚本：备份→拉取→重启→健康检查→回滚
-    ├── poll_and_update.sh         # 轮询脚本：SHA 比对→触发更新
-    └── setup-gpu-node.sh          # 新节点一键初始化脚本
-```
-
-### 7.6 注意事项
-
-- **首次部署必须手动准备**：MuseTalk 代码仓库、模型权重（`models/musetalk/`，几 GB）、MuseTalk 的 Python 虚拟环境（`venv/`，含 CUDA 版 PyTorch）。这些体积大、安装耗时长，不在自动更新范围内。
-- **脚本路径写死**：当前脚本路径固定为 `/home/ying/projects/` 和 `/opt/xiaoxia-gpu-worker/`，用户名固定 `ying`。后续如有多节点/多用户需求再做参数化。
-- **sudo 免密范围最小化**：setup 脚本写入 `/etc/sudoers.d/ying-gpu-update`，仅放行 restart/status 两个 GPU 相关服务、daemon-reload、journalctl、cp、chmod、tee，不开放全量 root。
-- **回滚只回滚 .py 文件**：健康检查失败只回滚 `musetalk_server.py` 和 `gpu_worker.py`，不回滚 pip 依赖（requirements.txt 变化概率低，且 pip 操作本身可能失败）。如需完全回滚，手动 `pip install -r requirements.txt` 指定旧版本。
-- **poll 脚本容错**：Gitea API 请求失败直接跳过，不触发更新，不会因为网络抖动误重启服务。

deploy/gpu_worker/gpu-poll.service

@@ -1,9 +0,0 @@
-[Unit]
-Description=GPU Worker Auto-Update Poller
-
-[Service]
-Type=oneshot
-User=ying
-ExecStart=/bin/bash /home/ying/projects/gpu-webhook/poll_and_update.sh
-StandardOutput=journal
-StandardError=journal

deploy/gpu_worker/gpu-poll.timer

@@ -1,10 +0,0 @@
-[Unit]
-Description=Poll Gitea for GPU worker updates every 30 seconds
-
-[Timer]
-OnBootSec=30
-OnUnitActiveSec=30
-AccuracySec=5
-
-[Install]
-WantedBy=timers.target

deploy/gpu_worker/gpu_worker.py

@@ -1,485 +0,0 @@
-"""MuseTalk GPU Worker — 反向轮询模式.
-
-部署在有 RTX2060 的本地电脑上（192.168.0.193），
-主动轮询 SaaS API 拉取口型任务、调用本地 MuseTalk 推理、上传结果回 SaaS。
-
-环境变量：
-  API_BASE_URL        SaaS API 基础 URL（不含 /api/v1），如 https://staging-api.xiaoxiajianji.com
-  GPU_WORKER_TOKEN    长期 API Token（服务端 GPU_WORKER_TOKEN 需一致）
-  WORKER_ID           本机唯一 ID（默认 hostname+网卡MAC 后4位）
-  MUSE_TALK_URL       本地 MuseTalk 地址，默认 http://127.0.0.1:7861
-  POLL_INTERVAL       轮询间隔秒，默认 5
-  HEARTBEAT_INTERVAL  空闲心跳间隔秒，默认 15
-  REQUEST_TIMEOUT     HTTP 请求超时秒（下载/推理/上传统一使用），默认 900
-                      需与服务端 GPU_TASK_TIMEOUT_SECONDS（默认 900）对齐
-  TASK_MAX_RETRY      单任务本地最大重试次数（仅对瞬时错误重试），默认 1
-  TASK_HEARTBEAT_INTERVAL  推理期间任务心跳间隔秒，默认 30
-  MIN_VIDEO_DURATION_SECONDS  最短输入视频时长秒，小于则直接上报失败，默认 3
-
-用法：
-  python gpu_worker.py
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import platform
-import socket
-import sys
-import tempfile
-import threading
-import time
-import uuid
-from pathlib import Path
-from typing import Optional
-
-import requests
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-)
-logger = logging.getLogger("musetalk-worker")
-
-# ── 配置 ────────────────────────────────────────────────────────────
-
-
-def _env(name: str, default: str = "") -> str:
-    v = os.environ.get(name, default)
-    return v.strip() if isinstance(v, str) else default
-
-
-class Config:
-    api_base_url: str = _env("API_BASE_URL", "https://staging-api.xiaoxiajianji.com").rstrip("/")
-    gpu_worker_token: str = _env("GPU_WORKER_TOKEN")
-    muse_talk_url: str = _env("MUSE_TALK_URL", "http://127.0.0.1:7861").rstrip("/")
-    poll_interval: float = float(_env("POLL_INTERVAL", "5"))
-    heartbeat_interval: float = float(_env("HEARTBEAT_INTERVAL", "15"))
-    # #1970：RTX2060 6G 处理 720p 长视频可能 >5min；与服务端
-    # GPU_TASK_TIMEOUT_SECONDS 默认值对齐为 900，避免推理被本地/服务端先掐断。
-    request_timeout: float = float(_env("REQUEST_TIMEOUT", "900"))
-    # 本地只在网络/MuseTalk 瞬时错误时重试 1 次；服务端 MAX_ATTEMPTS=3
-    # 负责跨 worker/真正超时后的重派发，总尝试次数不再相乘放大。
-    task_max_retry: int = int(_env("TASK_MAX_RETRY", "1"))
-    # 推理期间任务心跳间隔（独立线程 POST /gpu/register 带 task_id）
-    task_heartbeat_interval: float = float(_env("TASK_HEARTBEAT_INTERVAL", "30"))
-    # 输入视频最短时长（秒）：过短（如 1s）MuseTalk 会 division by zero，
-    # 本地前置拦截，直接上报 failed，不浪费 GPU 时间
-    min_video_duration_seconds: float = float(_env("MIN_VIDEO_DURATION_SECONDS", "3"))
-    worker_id: str = _env("WORKER_ID", "")
-
-    @classmethod
-    def derived_worker_id(cls) -> str:
-        if cls.worker_id:
-            return cls.worker_id
-        # hostname + MAC 后4位 → 稳定唯一 ID
-        try:
-            mac = uuid.getnode()
-            mac_suffix = f"{mac:012x}"[-4:]
-        except Exception:
-            mac_suffix = "0000"
-        host = platform.node() or socket.gethostname() or "rtx2060"
-        return f"{host}-{mac_suffix}"
-
-
-# ── 辅助 ─────────────────────────────────────────────────────────────
-
-
-def _api_headers() -> dict[str, str]:
-    token = Config.gpu_worker_token
-    if not token:
-        logger.warning("GPU_WORKER_TOKEN 未配置，开发模式下会被服务端拒绝（生产环境必须配置）")
-    return {"Authorization": f"Bearer {token}"} if token else {}
-
-
-def _check_musetalk_health() -> tuple[bool, dict]:
-    """检查本地 MuseTalk 健康状态，返回 (ok, info)."""
-    try:
-        r = requests.get(f"{Config.muse_talk_url}/health", timeout=5)
-        if r.status_code == 200:
-            try:
-                return True, r.json()
-            except Exception:
-                return True, {}
-        return False, {"status_code": r.status_code, "body": r.text[:200]}
-    except Exception as exc:
-        return False, {"error": str(exc)}
-
-
-def _register(task_id: Optional[str] = None) -> bool:
-    """向服务端注册 / 心跳，附带 GPU 信息。
-
-    推理期间的心跳线程传 task_id：服务端会同步刷新该 processing 任务的
-    last_heartbeat_at，防止长推理被误判超时回收。
-    """
-    ok, info = _check_musetalk_health()
-    free_vram = int(info.get("free_vram_mb", 0) or 0) if isinstance(info, dict) else 0
-    gpu_name = info.get("gpu_name", "") if isinstance(info, dict) else ""
-    if not gpu_name:
-        # 尝试在 Windows 上读 nvidia-smi
-        gpu_name = _probe_gpu_name()
-    payload = {
-        "worker_id": Config.derived_worker_id(),
-        "hostname": platform.node(),
-        "gpu_name": gpu_name,
-        "free_vram_mb": free_vram,
-        "capabilities": "musetalk",
-    }
-    if task_id:
-        payload["task_id"] = task_id
-    try:
-        r = requests.post(
-            f"{Config.api_base_url}/api/v1/gpu/register",
-            json=payload,
-            headers=_api_headers(),
-            timeout=15,
-        )
-        if r.status_code == 200:
-            return True
-        logger.error("注册/心跳失败: HTTP %d body=%s", r.status_code, r.text[:300])
-        return False
-    except Exception as exc:
-        logger.error("注册/心跳异常: %s", exc)
-        return False
-
-
-def _probe_gpu_name() -> str:
-    """尽力探测 GPU 型号（不强制依赖 pynvml）."""
-    try:
-        import subprocess
-
-        out = subprocess.check_output(
-            ["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
-            stderr=subprocess.DEVNULL,
-            timeout=5,
-        )
-        return out.decode("utf-8", errors="ignore").strip().splitlines()[0].strip()
-    except Exception:
-        return ""
-
-
-def _poll_task() -> Optional[dict]:
-    """轮询拉取一条待处理任务；无任务返回 None."""
-    try:
-        r = requests.get(
-            f"{Config.api_base_url}/api/v1/gpu/lipsync/poll",
-            params={"worker_id": Config.derived_worker_id()},
-            headers=_api_headers(),
-            timeout=30,
-        )
-        if r.status_code == 204:
-            return None
-        if r.status_code == 200:
-            data = r.json()
-            return data.get("task")
-        logger.error("poll 返回 %d: %s", r.status_code, r.text[:300])
-        return None
-    except Exception as exc:
-        logger.error("poll 异常: %s", exc)
-        return None
-
-
-def _download(url: str, path: Path) -> bool:
-    """下载文件到本地，支持预签名 URL."""
-    try:
-        with requests.get(url, stream=True, timeout=Config.request_timeout) as r:
-            if r.status_code >= 400:
-                logger.error("下载失败 HTTP %d: %s", r.status_code, url[:120])
-                return False
-            path.parent.mkdir(parents=True, exist_ok=True)
-            with open(path, "wb") as f:
-                for chunk in r.iter_content(chunk_size=1024 * 256):
-                    if chunk:
-                        f.write(chunk)
-        return path.stat().st_size > 0
-    except Exception as exc:
-        logger.error("下载异常 %s: %s", url[:120], exc)
-        return False
-
-
-def _call_musetalk(video_path: Path, audio_path: Path, out_path: Path) -> tuple[bool, float, str, bool]:
-    """调用本地 MuseTalk /inference.
-
-    返回 (success, duration_seconds, error_msg, retryable)。
-    duration 用 ffprobe 读结果视频，失败填 0。
-    retryable 仅对瞬时错误（连接失败/超时/5xx）为 True；HTTP 4xx、结果过小
-    等确定性失败不重试，直接上报服务端（服务端 MAX_ATTEMPTS 再决定是否重派发）。
-    """
-    try:
-        with open(video_path, "rb") as vf, open(audio_path, "rb") as af:
-            files = {
-                "video": (video_path.name, vf, "video/mp4"),
-                "audio": (audio_path.name, af, "application/octet-stream"),
-            }
-            r = requests.post(
-                f"{Config.muse_talk_url}/inference",
-                files=files,
-                timeout=Config.request_timeout,
-            )
-        if r.status_code != 200:
-            retryable = r.status_code >= 500
-            return False, 0.0, f"MuseTalk HTTP {r.status_code}: {r.text[:500]}", retryable
-        out_path.parent.mkdir(parents=True, exist_ok=True)
-        out_path.write_bytes(r.content)
-        if out_path.stat().st_size < 1024:
-            # 确定性失败（推理产物异常），本地重试大概率还是坏的，不重试
-            return False, 0.0, f"MuseTalk 返回结果过小 ({out_path.stat().st_size} bytes)", False
-        duration = _probe_duration(out_path)
-        return True, duration, "", False
-    except (requests.exceptions.Timeout, requests.exceptions.ConnectionError):
-        # 瞬时网络/超时错误，允许本地重试 1 次；同时调 /cancel 让服务端终止僵尸推理
-        _cancel_musetalk()
-        return False, 0.0, f"MuseTalk 推理超时或连接失败（>{Config.request_timeout}s）", True
-    except Exception as exc:
-        return False, 0.0, f"MuseTalk 调用异常: {exc}", False
-
-
-def _cancel_musetalk() -> None:
-    """调 MuseTalk /cancel 端点终止服务端僵尸推理进程，避免超时后任务还在跑占显存."""
-    try:
-        r = requests.post(f"{Config.muse_talk_url}/cancel", timeout=10)
-        if r.status_code == 200:
-            logger.info("已调 MuseTalk /cancel，服务端终止推理")
-        else:
-            logger.warning("MuseTalk /cancel 返回 %d: %s", r.status_code, r.text[:200])
-    except Exception as exc:
-        # /cancel 失败不应影响主流程上报
-        logger.warning("调 MuseTalk /cancel 异常（忽略）: %s", exc)
-
-
-def _probe_duration(path: Path) -> float:
-    """用 ffprobe 读视频时长（若系统装了 ffmpeg）；否则返回 0."""
-    try:
-        import subprocess
-
-        out = subprocess.check_output(
-            [
-                "ffprobe",
-                "-v",
-                "error",
-                "-show_entries",
-                "format=duration",
-                "-of",
-                "default=noprint_wrappers=1:nokey=1",
-                str(path),
-            ],
-            stderr=subprocess.DEVNULL,
-            timeout=10,
-        )
-        return float(out.decode().strip() or 0)
-    except Exception:
-        return 0.0
-
-
-def _upload_result(upload_url: str, file_path: Path) -> bool:
-    """PUT 上传结果视频到预签名 URL."""
-    try:
-        with open(file_path, "rb") as f:
-            r = requests.put(
-                upload_url,
-                data=f,
-                headers={"Content-Type": "video/mp4"},
-                timeout=Config.request_timeout,
-            )
-        if r.status_code >= 400:
-            logger.error("上传结果失败 HTTP %d: %s", r.status_code, r.text[:500])
-            return False
-        return True
-    except Exception as exc:
-        logger.error("上传结果异常: %s", exc)
-        return False
-
-
-def _report_result(task_id: str, success: bool, duration: float = 0.0, error_msg: str = "") -> bool:
-    """通知服务端结果。失败时也尝试上报错误（不含视频文件）."""
-    try:
-        data = {
-            "task_id": task_id,
-            "worker_id": Config.derived_worker_id(),
-            "success": "true" if success else "false",
-            "duration_seconds": str(duration),
-            "error_msg": error_msg,
-        }
-        r = requests.post(
-            f"{Config.api_base_url}/api/v1/gpu/lipsync/result",
-            data=data,
-            headers=_api_headers(),
-            timeout=30,
-        )
-        if r.status_code != 200:
-            logger.error("上报结果失败 HTTP %d: %s", r.status_code, r.text[:300])
-            return False
-        return True
-    except Exception as exc:
-        logger.error("上报结果异常: %s", exc)
-        return False
-
-
-class TaskHeartbeat(threading.Thread):
-    """推理期间的任务心跳线程。
-
-    主循环的空闲心跳在 ``_handle_task`` 同步阻塞（下载/推理/上传最长 900s）
-    期间无法发送，服务端会因任务 last_heartbeat_at 停滞而误判超时回退 pending。
-    本线程每 task_heartbeat_interval 秒（默认 30s）POST /gpu/register 并
-    携带当前 task_id，让服务端持续续期任务心跳；任务处理结束 stop()。
-    """
-
-    def __init__(self, task_id: str, interval: float):
-        super().__init__(daemon=True, name=f"hb-{task_id[:8]}")
-        self.task_id = task_id
-        self.interval = max(5.0, interval)
-        self._stop_event = threading.Event()
-
-    def run(self) -> None:
-        # 先立即发一次，再按间隔循环（首次心跳失败不影响主流程）
-        while not self._stop_event.is_set():
-            try:
-                if _register(self.task_id):
-                    logger.debug("任务 %s 心跳已发送", self.task_id)
-            except Exception as exc:  # noqa: BLE001
-                logger.warning("任务 %s 心跳异常（忽略）: %s", self.task_id, exc)
-            self._stop_event.wait(self.interval)
-
-    def stop(self) -> None:
-        self._stop_event.set()
-
-
-def _handle_task(task: dict) -> None:
-    """处理一条任务（整个串行流程：下载→时长校验→推理→上传→上报）。"""
-    task_id = task["task_id"]
-    logger.info("开始处理任务 %s", task_id)
-    # 领取任务后立即启动任务级心跳线程，覆盖下载/推理/上报全过程
-    hb = TaskHeartbeat(task_id, Config.task_heartbeat_interval)
-    hb.start()
-    try:
-        with tempfile.TemporaryDirectory(prefix="musetalk_") as tmpdir:
-            tmp = Path(tmpdir)
-            video_path = tmp / "input.mp4"
-            audio_path = tmp / "input_audio.bin"
-            out_path = tmp / "output.mp4"
-
-            # 1. 下载
-            if not _download(task["video_url"], video_path):
-                _report_result(task_id, False, 0.0, "下载人物视频失败")
-                return
-            if not _download(task["audio_url"], audio_path):
-                _report_result(task_id, False, 0.0, "下载驱动音频失败")
-                return
-
-            # 2. 输入时长前置校验：短视频 MuseTalk 会 division by zero，
-            #    直接上报 failed，不浪费 GPU 时间。ffprobe 不可用/读失败（0.0）
-            #    时不拦截，交给 MuseTalk 处理，避免误杀。
-            video_duration = _probe_duration(video_path)
-            if video_duration and video_duration < Config.min_video_duration_seconds:
-                msg = (
-                    f"视频过短（{video_duration:.2f}s < {Config.min_video_duration_seconds:.0f}s），"
-                    "MuseTalk 无法处理"
-                )
-                logger.error("任务 %s %s", task_id, msg)
-                _report_result(task_id, False, 0.0, msg)
-                return
-
-            # 3. 推理（本地仅对瞬时错误重试）
-            success = False
-            duration = 0.0
-            err = ""
-            retryable = False
-            for attempt in range(Config.task_max_retry + 1):
-                if attempt > 0:
-                    logger.info("任务 %s 第 %d 次重试（瞬时错误）...", task_id, attempt + 1)
-                    time.sleep(2)
-                success, duration, err, retryable = _call_musetalk(video_path, audio_path, out_path)
-                if success or not retryable:
-                    break
-            if not success:
-                logger.error("任务 %s 推理失败: %s", task_id, err)
-                _report_result(task_id, False, 0.0, err)
-                return
-
-            # 4. 上报结果（multipart 同时上传文件 → API 代为 PUT 到 OSS，逻辑最稳）
-            _report_success_with_file(task_id, duration, out_path)
-    finally:
-        hb.stop()
-
-
-def _report_success_with_file(task_id: str, duration: float, file_path: Path) -> None:
-    """上报成功并 multipart 附带结果视频."""
-    try:
-        data = {
-            "task_id": task_id,
-            "worker_id": Config.derived_worker_id(),
-            "success": "true",
-            "duration_seconds": str(duration),
-            "error_msg": "",
-        }
-        with open(file_path, "rb") as f:
-            files = {"result": (f"{task_id}.mp4", f, "video/mp4")}
-            r = requests.post(
-                f"{Config.api_base_url}/api/v1/gpu/lipsync/result",
-                data=data,
-                files=files,
-                headers=_api_headers(),
-                timeout=Config.request_timeout,
-            )
-        if r.status_code != 200:
-            logger.error("上报成功结果失败 HTTP %d: %s", r.status_code, r.text[:300])
-            return
-        logger.info("任务 %s 完成，duration=%.1fs", task_id, duration)
-    except Exception as exc:
-        logger.error("上报成功结果异常: %s", exc)
-
-
-# ── 主循环 ──────────────────────────────────────────────────────────
-
-
-def main() -> int:
-    logger.info("=" * 60)
-    logger.info("MuseTalk GPU Worker 启动")
-    logger.info("  worker_id   = %s", Config.derived_worker_id())
-    logger.info("  api_base    = %s", Config.api_base_url)
-    logger.info("  muse_talk   = %s", Config.muse_talk_url)
-    logger.info("  poll        = %.1fs / heartbeat = %.1fs", Config.poll_interval, Config.heartbeat_interval)
-    logger.info("=" * 60)
-
-    if not Config.gpu_worker_token:
-        logger.warning("GPU_WORKER_TOKEN 未配置（开发模式），生产环境必须设置")
-
-    # 先检查一次 MuseTalk
-    ok, info = _check_musetalk_health()
-    if ok:
-        logger.info("MuseTalk 健康检查通过: %s", info)
-    else:
-        logger.warning("MuseTalk 健康检查未通过: %s（继续运行，等待服务可用）", info)
-
-    # 启动时立即注册
-    _register()
-    last_heartbeat = time.time()
-
-    while True:
-        try:
-            # 心跳
-            now = time.time()
-            if now - last_heartbeat >= Config.heartbeat_interval:
-                if _register():
-                    last_heartbeat = now
-
-            # 轮询任务
-            task = _poll_task()
-            if task is not None:
-                _handle_task(task)
-                # 处理完立即再 poll（不 sleep），尽可能拉满 GPU
-                continue
-
-            time.sleep(Config.poll_interval)
-        except KeyboardInterrupt:
-            logger.info("收到中断信号，退出")
-            return 0
-        except Exception as exc:
-            logger.exception("主循环异常: %s", exc)
-            time.sleep(Config.poll_interval)
-
-
-if __name__ == "__main__":
-    sys.exit(main())

deploy/gpu_worker/musetalk-worker.service

@@ -1,19 +0,0 @@
-[Unit]
-Description=MuseTalk Inference API Server
-After=network.target nvidia-persistenced.service
-
-[Service]
-Type=simple
-User=ying
-WorkingDirectory=/home/ying/projects/MuseTalk
-Environment=PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128
-Environment=PATH=/home/ying/projects/MuseTalk/venv/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
-ExecStart=/home/ying/projects/MuseTalk/venv/bin/python /home/ying/projects/MuseTalk/musetalk_server.py
-Restart=always
-RestartSec=10
-StandardOutput=journal
-StandardError=journal
-SyslogIdentifier=musetalk-server
-
-[Install]
-WantedBy=multi-user.target

deploy/gpu_worker/musetalk_server.py

@@ -1,647 +0,0 @@
-"""MuseTalk Flask HTTP 服务 — 反向轮询架构的服务端部分.
-
-部署在 RTX2060 本地，接收 gpu_worker.py 的推理请求，调用 MuseTalk 生成口型同步视频。
-本文件修复了原 worker.py 的 8 个工程 bug，并新增 /cancel 端点。
-
-#1978 性能修复（v2 架构）：
-  MuseTalk 原生支持长音频输入（内部循环视频帧），不需要我们先 loop 视频。
-  正确流程：原视频 + 全量音频 → MuseTalk 推理 → 输出时长=音频时长的无声画面
-  → ffmpeg 快速 -c:v copy 替换音轨。推理时间不变（~14s），后处理几秒。
-  禁止在推理前用 ffmpeg 循环视频（会导致 MuseTalk 处理 2x+ 帧数，慢 16 倍）。
-
-环境变量：
-  MUSE_PORT            监听端口，默认 7861
-  MUSE_MAX_CONCURRENT  最大并发推理数，默认 1（GPU 一次只能处理一个）
-  MUSE_INFERENCE_TIMEOUT 推理超时秒数，默认 600
-  MUSE_VIDEO_MAX_MB    视频上传大小限制 MB，默认 100
-  MUSE_AUDIO_MAX_MB    音频上传大小限制 MB，默认 20
-  MUSE_DEFAULT_FPS     视频 fps 兜底值，默认 25.0
-  MUSE_TEMP_DIR        临时文件目录，默认 /tmp/musetalk_$$
-  MUSE_VIDEO_ENCODER   循环视频时的编码器（仅兜底）：auto（默认）/h264_nvenc/libx264
-
-接口：
-  GET  /health          健康检查 + GPU 显存信息
-  POST /inference       推理请求（multipart: video + audio）
-  POST /cancel          终止当前推理任务
-"""
-
-from __future__ import annotations
-
-import atexit
-import logging
-import os
-import shutil
-import signal
-import subprocess
-import threading
-import time
-from pathlib import Path
-from typing import Optional
-
-from flask import Flask, jsonify, request, send_file
-
-# ── 日志 ──────────────────────────────────────────────────────────────
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-)
-logger = logging.getLogger("musetalk-server")
-
-# ── 配置 ──────────────────────────────────────────────────────────────
-
-
-def _env(name: str, default: str = "") -> str:
-    v = os.environ.get(name, default)
-    return v.strip() if isinstance(v, str) else default
-
-
-class Config:
-    port: int = int(_env("MUSE_PORT", "7861"))
-    max_concurrent: int = int(_env("MUSE_MAX_CONCURRENT", "1"))
-    inference_timeout: float = float(_env("MUSE_INFERENCE_TIMEOUT", "600"))
-    video_max_mb: int = int(_env("MUSE_VIDEO_MAX_MB", "100"))
-    audio_max_mb: int = int(_env("MUSE_AUDIO_MAX_MB", "20"))
-    default_fps: float = float(_env("MUSE_DEFAULT_FPS", "25.0"))
-    temp_dir: str = _env("MUSE_TEMP_DIR", f"/tmp/musetalk_{os.getpid()}")
-    # 循环视频时的编码器（仅当 MuseTalk 输出画面短于音频时的兜底）
-    video_encoder: str = _env("MUSE_VIDEO_ENCODER", "auto") or "auto"
-    # 判定音视频时长差异的容差（秒）
-    duration_epsilon: float = 0.25
-
-
-# ── 全局状态 ──────────────────────────────────────────────────────────
-inference_lock = threading.Lock()
-current_task: dict = {"task_id": None, "process": None, "start_time": 0.0}
-shutdown_event = threading.Event()
-
-# ── Flask App ─────────────────────────────────────────────────────────
-app = Flask(__name__)
-
-
-def _cleanup_temp_dir():
-    """退出时清理临时目录."""
-    if os.path.exists(Config.temp_dir):
-        try:
-            shutil.rmtree(Config.temp_dir)
-            logger.info("已清理临时目录: %s", Config.temp_dir)
-        except Exception as exc:
-            logger.warning("清理临时目录失败: %s", exc)
-
-
-atexit.register(_cleanup_temp_dir)
-
-
-def _signal_handler(signum, frame):
-    """优雅退出."""
-    logger.info("收到信号 %s，准备退出...", signum)
-    shutdown_event.set()
-    if current_task["process"]:
-        logger.info("终止正在进行的推理进程...")
-        try:
-            current_task["process"].terminate()
-            current_task["process"].wait(timeout=5)
-        except Exception:
-            pass
-    _cleanup_temp_dir()
-    exit(0)
-
-
-signal.signal(signal.SIGTERM, _signal_handler)
-signal.signal(signal.SIGINT, _signal_handler)
-
-
-# ── 工具函数 ──────────────────────────────────────────────────────────
-
-
-def _get_gpu_info() -> dict:
-    """获取 GPU 显存信息（通过 nvidia-smi）."""
-    try:
-        out = subprocess.check_output(
-            [
-                "nvidia-smi",
-                "--query-gpu=name,memory.total,memory.used,memory.free",
-                "--format=csv,noheader,nounits",
-            ],
-            stderr=subprocess.DEVNULL,
-            timeout=5,
-        )
-        parts = out.decode().strip().split(",")
-        if len(parts) >= 4:
-            return {
-                "gpu_name": parts[0].strip(),
-                "memory_total_mb": int(parts[1].strip()),
-                "memory_used_mb": int(parts[2].strip()),
-                "memory_free_mb": int(parts[3].strip()),
-            }
-    except Exception as exc:
-        logger.warning("nvidia-smi 失败: %s", exc)
-    return {"gpu_name": "unknown", "memory_total_mb": 0, "memory_used_mb": 0, "memory_free_mb": 0}
-
-
-def _get_video_fps(video_path: Path) -> float:
-    """用 ffprobe 读视频帧率，失败或为 0 时返回 default_fps."""
-    try:
-        out = subprocess.check_output(
-            [
-                "ffprobe",
-                "-v",
-                "error",
-                "-select_streams",
-                "v:0",
-                "-show_entries",
-                "stream=r_frame_rate",
-                "-of",
-                "default=noprint_wrappers=1:nokey=1",
-                str(video_path),
-            ],
-            stderr=subprocess.DEVNULL,
-            timeout=10,
-        )
-        fps_str = out.decode().strip()
-        if "/" in fps_str:
-            num, den = fps_str.split("/")
-            fps = float(num) / float(den) if float(den) != 0 else 0.0
-        else:
-            fps = float(fps_str) if fps_str else 0.0
-        return fps if fps > 0 else Config.default_fps
-    except Exception as exc:
-        logger.warning("ffprobe 读 fps 失败: %s，使用默认 %.1f", exc, Config.default_fps)
-        return Config.default_fps
-
-
-def _get_media_duration(path: Path) -> float:
-    """用 ffprobe 读媒体时长（秒），失败返回 0.0."""
-    try:
-        out = subprocess.check_output(
-            [
-                "ffprobe",
-                "-v",
-                "error",
-                "-show_entries",
-                "format=duration",
-                "-of",
-                "default=noprint_wrappers=1:nokey=1",
-                str(path),
-            ],
-            stderr=subprocess.DEVNULL,
-            timeout=10,
-        )
-        duration = float(out.decode().strip())
-        return duration if duration > 0 else 0.0
-    except Exception as exc:
-        logger.warning("ffprobe 读时长失败 %s: %s", path, exc)
-        return 0.0
-
-
-def _pick_video_encoder() -> str:
-    """选择视频编码器：配置指定则用指定值；auto 时探测 NVENC 是否可用，不可用回退 libx264."""
-    configured = Config.video_encoder.strip()
-    if configured in ("h264_nvenc", "libx264"):
-        return configured
-    # auto：探测本机 ffmpeg 是否编译了 h264_nvenc
-    try:
-        result = subprocess.run(
-            ["ffmpeg", "-hide_banner", "-encoders"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
-            timeout=10,
-            check=False,
-        )
-        if b"h264_nvenc" in result.stdout:
-            return "h264_nvenc"
-    except Exception as exc:
-        logger.warning("探测 ffmpeg 编码器失败，回退 libx264: %s", exc)
-    return "libx264"
-
-
-def _mux_video_with_audio(
-    video_path: Path,
-    audio_path: Path,
-    output_path: Path,
-    timeout: float = 300,
-) -> None:
-    """把无声画面视频与驱动音频封装为最终结果.
-
-    #1978 v2 架构：MuseTalk 已处理全量音频，输出视频时长=音频时长。
-    此处仅做快速封装：-map 0:v:0 -map 1:a:0 强制取画面+驱动音频，
-    -c:v copy 无损秒级封装（不重编码），-shortest 以较短流为准。
-
-    仅当 MuseTalk 输出画面短于音频时（极端兜底），才启用 -stream_loop + NVENC
-    循环视频到音频长度。正常情况下走 copy 快速路径。
-    """
-    video_duration = _get_media_duration(video_path)
-    audio_duration = _get_media_duration(audio_path)
-
-    # 判断是否需要兜底循环（正常情况下 MuseTalk 输出已 >= 音频时长）
-    need_loop_fallback = bool(
-        audio_duration > 0 and video_duration > 0 and video_duration < audio_duration - Config.duration_epsilon
-    )
-
-    if need_loop_fallback:
-        # 兜底：MuseTalk 输出画面不足，循环补齐
-        encoder = _pick_video_encoder()
-        preset = "p4" if encoder == "h264_nvenc" else "veryfast"
-        logger.warning(
-            "MuseTalk 输出(%.2fs)短于音频(%.2fs)，兜底循环视频以 %s 重编码",
-            video_duration,
-            audio_duration,
-            encoder,
-        )
-
-        def build_cmd(enc: str, pre: str) -> list:
-            return [
-                "ffmpeg",
-                "-y",
-                "-stream_loop",
-                "-1",
-                "-i",
-                str(video_path),
-                "-i",
-                str(audio_path),
-                "-map",
-                "0:v:0",
-                "-map",
-                "1:a:0",
-                "-c:v",
-                enc,
-                "-preset",
-                pre,
-                "-c:a",
-                "aac",
-                "-b:a",
-                "128k",
-                "-t",
-                f"{audio_duration:.3f}",
-                str(output_path),
-            ]
-
-        try:
-            _run_ffmpeg(build_cmd(encoder, preset), timeout=timeout)
-        except RuntimeError:
-            if encoder == "h264_nvenc":
-                logger.warning("h264_nvenc 兜底失败，回退 libx264 重试")
-                _run_ffmpeg(build_cmd("libx264", "veryfast"), timeout=timeout)
-            else:
-                raise
-    else:
-        # 正常快速路径：-c:v copy 无损封装，仅替换音轨为驱动音频
-        cmd = [
-            "ffmpeg",
-            "-y",
-            "-i",
-            str(video_path),
-            "-i",
-            str(audio_path),
-            "-map",
-            "0:v:0",
-            "-map",
-            "1:a:0",
-            "-c:v",
-            "copy",
-            "-c:a",
-            "aac",
-            "-b:a",
-            "128k",
-            "-shortest",
-            str(output_path),
-        ]
-        _run_ffmpeg(cmd, timeout=timeout)
-
-
-def _check_file_size(file, max_mb: int, label: str) -> Optional[str]:
-    """检查文件大小，超限返回错误信息，否则返回 None."""
-    file.seek(0, 2)
-    size = file.tell()
-    file.seek(0)
-    max_bytes = max_mb * 1024 * 1024
-    if size > max_bytes:
-        return f"{label} 文件大小 {size / (1024*1024):.1f}MB 超过限制 {max_mb}MB"
-    if size == 0:
-        return f"{label} 文件为空"
-    return None
-
-
-def _run_ffmpeg(cmd: list, timeout: float = 120) -> subprocess.CompletedProcess:
-    """运行 ffmpeg 命令，检查返回码和超时."""
-    try:
-        result = subprocess.run(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            timeout=timeout,
-            check=True,
-        )
-        return result
-    except subprocess.CalledProcessError as exc:
-        stderr = exc.stderr.decode(errors="ignore") if exc.stderr else ""
-        raise RuntimeError(f"ffmpeg 失败 (code={exc.returncode}): {stderr[:500]}") from exc
-    except subprocess.TimeoutExpired as exc:
-        raise RuntimeError(f"ffmpeg 超时（>{timeout}s）") from exc
-
-
-def _run_inference(
-    video_path: Path,
-    audio_path: Path,
-    output_path: Path,
-) -> None:
-    """执行 MuseTalk 推理（v2 架构：全量音频直传，不在推理前 loop 视频）.
-
-    #1978 性能修复核心：
-      MuseTalk 原生支持长音频输入，内部会自动循环视频帧。
-      我们只需把【原视频】和【全量音频】传给 MuseTalk，
-      输出视频时长 = 音频时长（MuseTalk 自行处理帧循环）。
-      禁止在推理前用 ffmpeg 循环视频（会导致慢 16 倍）。
-
-    实际部署时替换为 MuseTalk 真实推理逻辑。
-    此处为示例实现：提取帧 → 模拟 MuseTalk 产出音频时长的无声画面 → 快速封装。
-    """
-    fps = _get_video_fps(video_path)
-    audio_duration = _get_media_duration(audio_path)
-    video_duration = _get_media_duration(video_path)
-    logger.info(
-        "推理开始: video=%.2fs, audio=%.2fs, fps=%.2f",
-        video_duration,
-        audio_duration,
-        fps,
-    )
-
-    frames_dir = video_path.parent / "frames"
-    frames_dir.mkdir(parents=True, exist_ok=True)
-
-    # 1. 从原视频提取帧（仅原视频长度，不循环）
-    _run_ffmpeg(
-        [
-            "ffmpeg",
-            "-y",
-            "-i",
-            str(video_path),
-            "-r",
-            str(fps),
-            str(frames_dir / "frame_%05d.png"),
-        ],
-        timeout=120,
-    )
-
-    frame_files = sorted(frames_dir.glob("*.png"))
-    if not frame_files:
-        raise RuntimeError("未从视频中提取到帧")
-
-    # 2. 模拟 MuseTalk 推理：输入原视频帧 + 全量音频，输出音频时长的无声画面。
-    # TODO: 替换为 MuseTalk 真实推理逻辑。
-    # MuseTalk 真实调用示例（伪代码）：
-    #   from musetalk import MuseTalkModel
-    #   model = MuseTalkModel(...)
-    #   silent_video = model.infer(video_path=video_path, audio_path=audio_path)
-    #   # MuseTalk 内部会循环视频帧匹配音频长度，输出时长=音频时长
-    logger.warning("使用示例推理逻辑，未实际调用 MuseTalk 模型")
-
-    # 示例：生成音频时长的无声画面（循环原视频帧到音频长度）
-    # 真实部署时 silent_video_path 应替换为 MuseTalk 输出的无声视频路径
-    silent_video_path = video_path.parent / "visual_silent.mp4"
-
-    if audio_duration > video_duration + Config.duration_epsilon:
-        # 音频更长：循环视频帧到音频长度（仅用于示例，真实 MuseTalk 内部处理）
-        encoder = _pick_video_encoder()
-        preset = "p4" if encoder == "h264_nvenc" else "veryfast"
-        logger.info(
-            "示例：循环视频帧到音频长度 %.2fs（真实 MuseTalk 内部处理，无需此步骤）",
-            audio_duration,
-        )
-        cmd = [
-            "ffmpeg",
-            "-y",
-            "-stream_loop",
-            "-1",
-            "-i",
-            str(video_path),
-            "-an",
-            "-c:v",
-            encoder,
-            "-preset",
-            preset,
-            "-t",
-            f"{audio_duration:.3f}",
-            str(silent_video_path),
-        ]
-        try:
-            _run_ffmpeg(cmd, timeout=300)
-        except RuntimeError:
-            if encoder == "h264_nvenc":
-                cmd[cmd.index(encoder)] = "libx264"
-                cmd[cmd.index(preset) + 1] = "veryfast"
-                _run_ffmpeg(cmd, timeout=300)
-            else:
-                raise
-    else:
-        # 音频不长：直接生成无声视频（原视频长度）
-        _run_ffmpeg(
-            [
-                "ffmpeg",
-                "-y",
-                "-i",
-                str(video_path),
-                "-an",
-                "-c:v",
-                "libx264",
-                "-preset",
-                "veryfast",
-                str(silent_video_path),
-            ],
-            timeout=300,
-        )
-
-    # 3. 快速封装：-map 取推理画面 + 驱动音频，-c:v copy 无损秒级封装
-    # MuseTalk 输出已匹配音频长度，此处无需循环，仅替换音轨
-    _mux_video_with_audio(silent_video_path, audio_path, output_path)
-
-    if not output_path.exists() or output_path.stat().st_size < 1024:
-        raise RuntimeError("推理产物不存在或过小")
-
-    logger.info(
-        "推理完成: output=%.2fs (audio=%.2fs)",
-        _get_media_duration(output_path),
-        audio_duration,
-    )
-
-
-# ── 路由 ──────────────────────────────────────────────────────────────
-
-
-@app.route("/health", methods=["GET"])
-def health():
-    """健康检查 + GPU 显存信息."""
-    gpu_info = _get_gpu_info()
-    task_info = {
-        "task_id": current_task["task_id"],
-        "running": current_task["process"] is not None,
-        "elapsed_seconds": time.time() - current_task["start_time"] if current_task["start_time"] else 0.0,
-    }
-    return jsonify(
-        {
-            "status": "healthy",
-            "gpu": gpu_info,
-            "current_task": task_info,
-            "timestamp": time.time(),
-        }
-    )
-
-
-@app.route("/inference", methods=["POST"])
-def inference():
-    """推理请求：multipart form 包含 video 和 audio 文件.
-
-    #1978 v2：MuseTalk 直接处理全量音频，输出时长=音频时长，无需预处理循环。
-    """
-    # 并发控制：检查锁
-    if not inference_lock.acquire(blocking=False):
-        return jsonify({"error": "GPU 正在处理其他任务，请稍后重试", "status": "busy"}), 503
-
-    task_id = None
-    video_path = None
-    audio_path = None
-    output_path = None
-
-    try:
-        # 解析参数
-        if "video" not in request.files or "audio" not in request.files:
-            return jsonify({"error": "缺少 video 或 audio 文件"}), 400
-
-        video_file = request.files["video"]
-        audio_file = request.files["audio"]
-        task_id = request.form.get("task_id", f"task_{int(time.time())}")
-
-        # 文件大小检查
-        err = _check_file_size(video_file, Config.video_max_mb, "视频")
-        if err:
-            return jsonify({"error": err}), 413
-        err = _check_file_size(audio_file, Config.audio_max_mb, "音频")
-        if err:
-            return jsonify({"error": err}), 413
-
-        # 保存到临时目录
-        task_dir = Path(Config.temp_dir) / task_id
-        task_dir.mkdir(parents=True, exist_ok=True)
-        video_path = task_dir / "input.mp4"
-        audio_path = task_dir / "input_audio.wav"
-        output_path = task_dir / "output.mp4"
-
-        video_file.save(str(video_path))
-        audio_file.save(str(audio_path))
-
-        logger.info("开始推理 task_id=%s, video=%s, audio=%s", task_id, video_path.name, audio_path.name)
-
-        # 更新当前任务信息
-        current_task["task_id"] = task_id
-        current_task["start_time"] = time.time()
-        current_task["process"] = "inference_thread"  # 标记为运行中
-
-        # 在线程中运行推理（支持超时）
-        result_container = {"error": None}
-
-        def inference_thread():
-            try:
-                _run_inference(video_path, audio_path, output_path)
-            except Exception as exc:
-                result_container["error"] = str(exc)
-
-        thread = threading.Thread(target=inference_thread)
-        thread.start()
-        thread.join(timeout=Config.inference_timeout)
-
-        if thread.is_alive():
-            # 超时，终止
-            logger.error("推理超时 (>%ds)，终止任务 %s", Config.inference_timeout, task_id)
-            return jsonify({"error": f"推理超时（>{Config.inference_timeout}s）", "task_id": task_id}), 504
-
-        if result_container["error"]:
-            logger.error("推理失败 task_id=%s: %s", task_id, result_container["error"])
-            return jsonify({"error": result_container["error"], "task_id": task_id}), 500
-
-        # 返回结果文件
-        logger.info("推理完成 task_id=%s, output=%s", task_id, output_path)
-        return send_file(str(output_path), mimetype="video/mp4", as_attachment=True, download_name=f"{task_id}.mp4")
-
-    except Exception as exc:
-        logger.exception("推理异常: %s", exc)
-        return jsonify({"error": str(exc)}), 500
-
-    finally:
-        # 释放锁，清理当前任务信息
-        inference_lock.release()
-        current_task["task_id"] = None
-        current_task["process"] = None
-        current_task["start_time"] = 0.0
-
-        # 清理临时文件
-        if video_path and video_path.parent.exists():
-            try:
-                shutil.rmtree(video_path.parent)
-                logger.info("已清理临时目录: %s", video_path.parent)
-            except Exception as exc:
-                logger.warning("清理临时目录失败: %s", exc)
-
-
-@app.route("/cancel", methods=["POST"])
-def cancel():
-    """终止当前正在进行的推理任务."""
-    if current_task["task_id"] is None:
-        return jsonify({"message": "当前无正在运行的任务"})
-
-    task_id = current_task["task_id"]
-    logger.info("收到取消请求，终止任务 %s", task_id)
-
-    # 终止推理进程（如果是 subprocess）
-    if current_task["process"] and current_task["process"] != "inference_thread":
-        try:
-            current_task["process"].terminate()
-            current_task["process"].wait(timeout=5)
-            logger.info("已终止推理进程")
-        except Exception as exc:
-            logger.warning("终止进程失败: %s", exc)
-
-    # 清理临时文件
-    task_dir = Path(Config.temp_dir) / task_id
-    if task_dir.exists():
-        try:
-            shutil.rmtree(task_dir)
-            logger.info("已清理临时目录: %s", task_dir)
-        except Exception as exc:
-            logger.warning("清理临时目录失败: %s", exc)
-
-    # 重置当前任务
-    current_task["task_id"] = None
-    current_task["process"] = None
-    current_task["start_time"] = 0.0
-
-    return jsonify({"message": f"已取消任务 {task_id}"})
-
-
-# ── 主入口 ────────────────────────────────────────────────────────────
-
-
-def main():
-    """启动 Flask 服务."""
-    # 创建临时目录
-    Path(Config.temp_dir).mkdir(parents=True, exist_ok=True)
-    logger.info("临时目录: %s", Config.temp_dir)
-
-    gpu_info = _get_gpu_info()
-    logger.info(
-        "GPU: %s (显存 %dMB / %dMB)",
-        gpu_info["gpu_name"],
-        gpu_info["memory_used_mb"],
-        gpu_info["memory_total_mb"],
-    )
-    logger.info(
-        "启动 MuseTalk Server: port=%d, timeout=%.0fs, max_concurrent=%d",
-        Config.port,
-        Config.inference_timeout,
-        Config.max_concurrent,
-    )
-
-    app.run(host="0.0.0.0", port=Config.port, threaded=True)
-
-
-if __name__ == "__main__":
-    main()

deploy/gpu_worker/requirements.txt

@@ -1 +0,0 @@
-requests>=2.31.0

deploy/gpu_worker/scripts/poll_and_update.sh

@@ -1,47 +0,0 @@
-#!/bin/bash
-
-REPO_API="https://git.xiaoxiajianji.com/api/v1/repos/xiaoxia/xiaoxia-saas/commits?sha=develop&path=deploy/gpu_worker&limit=1"
-STATE_FILE="/home/ying/projects/gpu-webhook/.last_commit"
-UPDATE_SCRIPT="/home/ying/projects/update-gpu-worker.sh"
-LOG_FILE="$HOME/gpu-poll.log"
-
-log() {
-    echo "[$(date +"%Y-%m-%d %H:%M:%S")] $*" >> "$LOG_FILE"
-}
-
-LATEST_SHA=$(curl -sk --max-time 10 "$REPO_API" | python3 -c "
-import sys, json
-try:
-    data = json.load(sys.stdin)
-    if isinstance(data, list) and len(data) > 0:
-        print(data[0].get('sha', ''))
-    else:
-        print('')
-except:
-    print('')
-" 2>/dev/null)
-
-if [ -z "$LATEST_SHA" ]; then
-    log "get latest commit failed, skip"
-    exit 0
-fi
-
-LAST_SHA=""
-if [ -f "$STATE_FILE" ]; then
-    LAST_SHA=$(cat "$STATE_FILE")
-fi
-
-if [ "$LATEST_SHA" = "$LAST_SHA" ]; then
-    exit 0
-fi
-
-if [ -z "$LAST_SHA" ]; then
-    echo "$LATEST_SHA" > "$STATE_FILE"
-    log "first run, recording SHA: $LATEST_SHA"
-    exit 0
-fi
-
-log "new commit detected: $LAST_SHA -> $LATEST_SHA, triggering update"
-echo "$LATEST_SHA" > "$STATE_FILE"
-bash "$UPDATE_SCRIPT" >> "$LOG_FILE" 2>&1
-log "update completed"

deploy/gpu_worker/scripts/setup-gpu-node.sh

@@ -1,63 +0,0 @@
-#!/bin/bash
-# GPU节点一键初始化脚本 - 在全新GPU机器上执行
-
-set -e
-
-echo "=== 1. 安装系统依赖 ==="
-sudo apt-get update -qq
-sudo apt-get install -y -qq python3 python3-pip python3-venv ffmpeg wget curl git
-
-echo "=== 2. 创建目录 ==="
-mkdir -p ~/projects/MuseTalk ~/projects/gpu-webhook /opt/xiaoxia-gpu-worker
-
-echo "=== 3. 安装nvidia-container-toolkit（如需要Docker）==="
-# 可选，当前不使用Docker，跳过
-# distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
-# curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
-# curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
-# sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
-# sudo nvidia-ctk runtime configure --runtime=docker
-# sudo systemctl restart docker
-
-echo "=== 4. 拉取服务配置和脚本 ==="
-REPO_URL="https://git.xiaoxiajianji.com/xiaoxia/xiaoxia-saas/raw/branch/develop/deploy/gpu_worker"
-wget -q -O /tmp/musetalk-worker.service "$REPO_URL/musetalk-worker.service"
-wget -q -O /tmp/gpu-poll.service "$REPO_URL/gpu-poll.service"
-wget -q -O /tmp/gpu-poll.timer "$REPO_URL/gpu-poll.timer"
-wget -q -O ~/projects/update-gpu-worker.sh "$REPO_URL/scripts/update-gpu-worker.sh"
-wget -q -O ~/projects/gpu-webhook/poll_and_update.sh "$REPO_URL/scripts/poll_and_update.sh"
-chmod +x ~/projects/update-gpu-worker.sh ~/projects/gpu-webhook/poll_and_update.sh
-
-echo "=== 5. 安装systemd服务 ==="
-sudo cp /tmp/musetalk-worker.service /etc/systemd/system/
-sudo cp /tmp/gpu-poll.service /etc/systemd/system/
-sudo cp /tmp/gpu-poll.timer /etc/systemd/system/
-
-echo "=== 6. 配置sudo免密 ==="
-sudo bash -c 'cat > /etc/sudoers.d/ying-gpu-update << EOF
-ying ALL=(ALL) NOPASSWD: /bin/systemctl restart musetalk-worker
-ying ALL=(ALL) NOPASSWD: /bin/systemctl restart xiaoxia-gpu-worker
-ying ALL=(ALL) NOPASSWD: /bin/systemctl status musetalk-worker
-ying ALL=(ALL) NOPASSWD: /bin/systemctl status xiaoxia-gpu-worker
-ying ALL=(ALL) NOPASSWD: /bin/systemctl daemon-reload
-ying ALL=(ALL) NOPASSWD: /usr/bin/journalctl
-ying ALL=(ALL) NOPASSWD: /bin/cp
-ying ALL=(ALL) NOPASSWD: /bin/chmod
-ying ALL=(ALL) NOPASSWD: /usr/bin/tee
-EOF'
-sudo chmod 440 /etc/sudoers.d/ying-gpu-update
-
-echo "=== 7. 首次拉取代码并启动服务 ==="
-bash ~/projects/update-gpu-worker.sh
-sudo systemctl daemon-reload
-sudo systemctl enable musetalk-worker xiaoxia-gpu-worker gpu-poll.timer
-sudo systemctl start musetalk-worker xiaoxia-gpu-worker gpu-poll.timer
-
-echo "=== 完成！ ==="
-echo "检查服务状态："
-echo "  sudo systemctl status musetalk-worker"
-echo "  sudo systemctl status xiaoxia-gpu-worker"
-echo "  sudo systemctl status gpu-poll.timer"
-echo "健康检查：curl http://127.0.0.1:7861/health"
-echo "更新日志：tail -f ~/gpu-worker-update.log"
-echo "轮询日志：tail -f ~/gpu-poll.log"

deploy/gpu_worker/scripts/update-gpu-worker.sh

@@ -1,62 +0,0 @@
-#!/bin/bash
-set -e
-
-REPO_URL="https://git.xiaoxiajianji.com/xiaoxia/xiaoxia-saas/raw/branch/develop/deploy/gpu_worker"
-MUSE_DIR="/home/ying/projects/MuseTalk"
-WORKER_DIR="/opt/xiaoxia-gpu-worker"
-LOG_FILE="$HOME/gpu-worker-update.log"
-
-log() {
-    local NOW
-    NOW=$(date +"%Y-%m-%d %H:%M:%S")
-    echo "[$NOW] $*" | tee -a "$LOG_FILE"
-}
-
-log "========== start update =========="
-
-BAK_SUFFIX=$(date +"%Y%m%d%H%M%S")
-cp "$MUSE_DIR/musetalk_server.py" "$MUSE_DIR/musetalk_server.py.bak.$BAK_SUFFIX"
-cp "$WORKER_DIR/gpu_worker.py" "$WORKER_DIR/gpu_worker.py.bak.$BAK_SUFFIX"
-log "backup done ($BAK_SUFFIX)"
-
-wget -q -O "$MUSE_DIR/musetalk_server.py" "$REPO_URL/musetalk_server.py"
-log "musetalk_server.py updated"
-
-wget -q -O "$WORKER_DIR/gpu_worker.py" "$REPO_URL/gpu_worker.py"
-log "gpu_worker.py updated"
-
-wget -q -O /tmp/gpu-requirements.txt "$REPO_URL/requirements.txt"
-if [ -f "$WORKER_DIR/requirements.txt" ] && ! diff -q "$WORKER_DIR/requirements.txt" /tmp/gpu-requirements.txt > /dev/null 2>&1; then
-    log "requirements changed, updating..."
-    cp /tmp/gpu-requirements.txt "$WORKER_DIR/requirements.txt"
-    "$WORKER_DIR/venv/bin/pip" install -r "$WORKER_DIR/requirements.txt" -q
-    log "pip install done"
-else
-    log "requirements no change, skip pip"
-fi
-
-sudo systemctl restart musetalk-worker
-log "musetalk restarted"
-sleep 5
-
-sudo systemctl restart xiaoxia-gpu-worker
-log "gpu-worker restarted"
-sleep 8
-
-HEALTH=$(curl -s http://127.0.0.1:7861/health 2>/dev/null)
-if echo "$HEALTH" | grep -q "healthy\|ok"; then
-    log "health check OK"
-    log "========== update done =========="
-    exit 0
-else
-    log "health check FAILED, rolling back..."
-    LATEST_MUSE_BAK=$(ls -t "$MUSE_DIR/musetalk_server.py.bak."* 2>/dev/null | head -1)
-    LATEST_WORKER_BAK=$(ls -t "$WORKER_DIR/gpu_worker.py.bak."* 2>/dev/null | head -1)
-    [ -n "$LATEST_MUSE_BAK" ] && cp "$LATEST_MUSE_BAK" "$MUSE_DIR/musetalk_server.py"
-    [ -n "$LATEST_WORKER_BAK" ] && cp "$LATEST_WORKER_BAK" "$WORKER_DIR/gpu_worker.py"
-    sudo systemctl restart musetalk-worker
-    sleep 5
-    sudo systemctl restart xiaoxia-gpu-worker
-    log "rolled back"
-    exit 1
-fi

deploy/gpu_worker/xiaoxia-gpu-worker.service

@@ -1,21 +0,0 @@
-[Unit]
-Description=MuseTalk GPU Worker (xiaoxia-saas 反向轮询)
-After=network.target musetalk-worker.service
-# 本地 MuseTalk 服务（musetalk-worker.service）启动后再启动本 Worker
-
-[Service]
-Type=simple
-User=ying
-WorkingDirectory=/opt/xiaoxia-gpu-worker
-# 读取环境变量（API 地址、Token、轮询间隔等）
-EnvironmentFile=/opt/xiaoxia-gpu-worker/.env
-ExecStart=/opt/xiaoxia-gpu-worker/venv/bin/python /opt/xiaoxia-gpu-worker/gpu_worker.py
-Restart=always
-RestartSec=10
-# 日志走 journal，用 journalctl -u xiaoxia-gpu-worker -f 查看
-StandardOutput=journal
-StandardError=journal
-SyslogIdentifier=xiaoxia-gpu-worker
-
-[Install]
-WantedBy=multi-user.target

packages/adapters/sqlalchemy_impl/asset_atom_clip_repository.py

@@ -83,31 +83,6 @@ class SQLAlchemyAssetAtomClipRepository:
         models = query.all()
         return [self._to_domain(m) for m in models]
 
-    def update_ai_tags(self, clip_id: str, ai_tags: dict) -> bool:
-        """更新指定片段的 ai_tags 字段."""
-        count = (
-            self.session.query(AssetAtomClipModel).filter(AssetAtomClipModel.id == clip_id).update({"ai_tags": ai_tags})
-        )
-        self.session.commit()
-        return count > 0
-
-    def find_untagged(self, limit: int = 100, include_downgraded: bool = False) -> list[AssetAtomClip]:
-        """查找未完成 AI 打标的片段，用于回填.
-
-        默认仅匹配 ai_tags IS NULL；include_downgraded=True 时额外包含
-        只有 inherited_tags 的降级记录（视觉 API 失败时写入，无 has_text 字段），
-        供强制回填（#1970 force backfill）使用。
-        """
-        query = self.session.query(AssetAtomClipModel)
-        if include_downgraded:
-            # as_string() → JSON/JSONB ->> 取值；NULL 记录或缺 has_text 键
-            # （降级记录）均为 NULL，has_text 为 true/false 的完整记录被排除
-            query = query.filter(AssetAtomClipModel.ai_tags["has_text"].as_string().is_(None))
-        else:
-            query = query.filter(AssetAtomClipModel.ai_tags.is_(None))
-        models = query.order_by(AssetAtomClipModel.created_at.asc()).limit(limit).all()
-        return [self._to_domain(m) for m in models]
-
     def _to_model(self, clip: AssetAtomClip) -> AssetAtomClipModel:
         return AssetAtomClipModel(
             id=clip.id,
@@ -117,7 +92,6 @@ class SQLAlchemyAssetAtomClipRepository:
             duration=clip.duration,
             clip_index=clip.clip_index,
             tags=clip.tags,
-            ai_tags=clip.ai_tags,
             scene_change_at=clip.scene_change_at,
             is_fallback=clip.is_fallback,
             created_at=clip.created_at or datetime.now(UTC),

packages/adapters/sqlalchemy_impl/models.py

@@ -837,7 +837,6 @@ class AssetAtomClipModel(Base):
     duration = Column(Float, nullable=False)
     clip_index = Column(Integer, nullable=False)
     tags = Column(JSON, nullable=False, default=list)
-    ai_tags = Column(JSON, nullable=True, default=None)
     scene_change_at = Column(Float, nullable=True)
     is_fallback = Column(Boolean, nullable=False, default=False)
     created_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))
@@ -855,61 +854,3 @@ class DailyUsageRecordModel(Base):
     usage_type = Column(String(50), nullable=False, default="free_clip")
     count = Column(Integer, nullable=False, default=0)
     updated_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))
-
-
-class GpuLipsyncTaskModel(Base):
-    """GPU 口型同步任务 ORM 模型 — MuseTalk 反向轮询模式.
-
-    业务侧（AI 数字人生成/lipsync 流程）提交任务后，GPU Worker 主动 poll 拉取、
-    调用本地 MuseTalk 推理、再通过 result 接口回传结果视频。
-    """
-
-    __tablename__ = "gpu_lipsync_tasks"
-
-    id = Column(String(36), primary_key=True)
-    # 业务关联（原 lipsync_job_id，方便双向查询）
-    lipsync_job_id = Column(String(36), nullable=False, default="", index=True)
-    user_id = Column(String(36), nullable=False, default="", index=True)
-    project_id = Column(String(36), nullable=False, default="", index=True)
-
-    # 输入（预签名下载 URL，由 API 侧生成）
-    video_url = Column(Text, nullable=False)
-    audio_url = Column(Text, nullable=False)
-
-    # 结果
-    result_url = Column(Text, nullable=False, default="")
-    result_duration = Column(Float, nullable=False, default=0.0)
-
-    # 任务状态
-    status = Column(
-        String(20),
-        nullable=False,
-        default="pending",
-        index=True,
-    )  # pending → processing → done / failed / timeout
-    worker_id = Column(String(100), nullable=False, default="", index=True)
-    attempt = Column(Integer, nullable=False, default=0)
-    error_msg = Column(Text, nullable=False, default="")
-
-    # 时间戳
-    created_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))
-    started_at = Column(DateTime, nullable=True)
-    finished_at = Column(DateTime, nullable=True)
-    updated_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))
-
-    # 心跳：worker 最近一次 poll/result 的时间，用于判定 worker 失联
-    last_heartbeat_at = Column(DateTime, nullable=True)
-
-
-class GpuWorkerModel(Base):
-    """GPU Worker 注册表 — 反向轮询模式下用于心跳与监控."""
-
-    __tablename__ = "gpu_workers"
-
-    worker_id = Column(String(100), primary_key=True)
-    hostname = Column(String(200), nullable=False, default="")
-    gpu_name = Column(String(200), nullable=False, default="")
-    free_vram_mb = Column(Integer, nullable=False, default=0)
-    capabilities = Column(String(500), nullable=False, default="")  # 逗号分隔，如 "musetalk"
-    last_heartbeat_at = Column(DateTime, nullable=True, index=True)
-    created_at = Column(DateTime, nullable=False, default=lambda: datetime.now(UTC))

packages/config/base.py

@@ -8,7 +8,6 @@ API 和 Worker 各自的 Settings 类继承本类，只追加服务特有字段
 import os
 from typing import Optional, TypeVar
 
-from pydantic import AliasChoices, Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 T = TypeVar("T", bound=BaseSettings)
@@ -69,7 +68,6 @@ class SharedSettings(BaseSettings):
     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"
 
     # ── MediaKit (火山引擎 AI 媒体工具) ──────────────────────────────────
     mediakit_api_key: str = ""
@@ -77,56 +75,9 @@ class SharedSettings(BaseSettings):
     mediakit_timeout: int = 60
 
     # ── 积分/会员系统 (#1895) ────────────────────────────────────────────
-    # 积分系统总开关（产品要求 #1895：暂停积分系统但保留全部代码/表/接口）。
-    # - false（默认）：所有 AI 功能（生成视频/口型/数字人/AI标题/TTS/克隆音色…）
-    #   对全部登录用户免费放行，不扣积分、不做余额拦截；积分余额/流水/会员
-    #   状态等查询接口保持可用，但数据不再变动。
-    # - 未来恢复：只需设置环境变量 ENABLE_CREDIT_SYSTEM=true。
-    # 旧开关 POINTS_ENABLED 仍保留作为兼容别名（两者任一为 true 即启用）。
-    # 主开关（推荐环境变量名 ENABLE_CREDIT_SYSTEM）
-    credits_enabled: bool = Field(
-        default=False,
-        validation_alias=AliasChoices("ENABLE_CREDIT_SYSTEM", "credits_enabled"),
-    )
-    # 旧开关兼容（POINTS_ENABLED）；两者任一为 true 即启用
-    points_enabled_compat: bool = Field(
-        default=False,
-        validation_alias=AliasChoices("POINTS_ENABLED", "points_enabled_compat"),
-    )
-
-    @property
-    def points_enabled(self) -> bool:
-        """旧代码/测试使用的属性名，等价于积分系统总开关（兼容别名）。"""
-        return bool(self.credits_enabled or self.points_enabled_compat)
-
-    @points_enabled.setter
-    def points_enabled(self, value: bool) -> None:
-        # 支持旧测试/代码 ``settings.points_enabled = True`` 的写法
-        self.credits_enabled = bool(value)
-        self.points_enabled_compat = False
-
-    # ── GPU MuseTalk 反向轮询 Worker ────────────────────────────────────
-    # Worker 用这个长期 Token 鉴权（不是用户 JWT）。多 Worker 共用同一个 Token；
-    # worker_id 用于区分具体机器。生产必须配置；development 留空会跳过校验。
-    gpu_worker_token: str = ""
-    # GPU 任务超时（秒）：processing 状态超过此时长（以任务心跳为准）才回退
-    # pending / failed。#1970：RTX2060 6G 推理 720p 长视频需 5 分钟以上，300→900。
-    # Worker 推理期间每 30s 通过 /gpu/register(task_id=...) 续心跳，
-    # 只有真正超时或 Worker 明确上报 failed 才会回退。
-    gpu_task_timeout_seconds: int = 900
-    # 结果预签名 URL 有效期（秒）
-    gpu_result_url_expires: int = 3600
-    # 输入预签名 URL 有效期（秒，需留出 Worker 下载时间）
-    gpu_input_url_expires: int = 3600
-    # 业务侧是否启用 GPU 口型同步（开关）；关或无可用 Worker 时回退 MediaKit 云端
-    use_gpu_lipsync: bool = False
-    # 业务侧轮询 GPU 任务结果的间隔（秒）
-    gpu_lipsync_poll_interval: float = 5.0
-    # 业务侧等待 GPU 任务结果的总超时（秒）；超时后回退 MediaKit。
-    # 应小于等于 gpu_task_timeout_seconds（默认900s）+ 冗余，留足 Worker 下载/上传时间。
-    gpu_lipsync_wait_timeout: int = 1200
-    # 判断 Worker 可用的心跳新鲜度窗口（秒）—— last_heartbeat_at 在窗口内视为在线
-    gpu_worker_stale_seconds: int = 300
+    # 总开关：默认 false（对所有用户零影响），P2 路由逐个接入时用
+    # `if settings.points_enabled:` 包裹，防止未完善的扣点逻辑影响现有用户。
+    points_enabled: bool = False
 
     @property
     def effective_database_url(self) -> str:

packages/domain/asset_atom_clip.py

@@ -36,7 +36,6 @@ class AssetAtomClip:
     duration: float
     clip_index: int
     tags: list[str] = field(default_factory=list)
-    ai_tags: dict | None = None
     scene_change_at: float | None = None
     is_fallback: bool = False
     created_at: datetime | None = None

packages/domain/atom_clip_tagger.py

@@ -1,292 +0,0 @@
-"""片段级 AI 标签 — #1970 智能剪辑流程重构 P2.
-
-对每个 atom_clip 提取关键帧，调用豆包视觉理解 API 识别内容，
-生成结构化标签（场景、物体、动作、景别、是否有文字）。
-
-纯函数 + IO 分离设计：
-- build_vision_prompt() 返回结构化 prompt
-- parse_vision_response(text) 解析 AI 返回的 JSON 标签
-- tag_atom_clip(...) 主入口，组合帧提取 → 视觉 API → 解析标签
-
-降级策略：任何环节失败都返回 {"inherited_tags": clip.tags}，不阻断流程。
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import subprocess
-import tempfile
-from pathlib import Path
-from typing import Any, Optional
-
-logger = logging.getLogger(__name__)
-
-# AI 标签结构的键
-AI_TAG_KEYS = ("scene", "objects", "action", "shot", "has_text")
-
-
-def build_vision_prompt() -> str:
-    """返回结构化标签提取 prompt.
-
-    要求 AI 以 JSON 格式返回片段内容标签，包含：
-    - scene: 场景类型列表（如 "工厂", "办公室", "户外"）
-    - objects: 出现的物体列表（如 "产品", "手机", "电脑"）
-    - action: 动作类型列表（如 "演示", "说话", "操作"）
-    - shot: 景别（"特写" / "中景" / "远景" 之一）
-    - has_text: 画面中是否有显著文字（true/false）
-    """
-    return """请分析这段视频片段的关键帧，识别内容并返回 JSON 格式标签。
-
-要求返回以下 JSON 结构（严格 JSON，不要添加其他文字）：
-{
-  "scene": ["场景1", "场景2"],
-  "objects": ["物体1", "物体2"],
-  "action": ["动作1"],
-  "shot": "特写|中景|远景",
-  "has_text": true/false
-}
-
-规则：
-- scene: 场景类型，如"工厂"、"办公室"、"户外"、"商店"、"家庭"等，1-3个
-- objects: 画面中可见的主要物体，如"产品"、"手机"、"电脑"、"食品"等，1-5个
-- action: 人物或物体正在进行的动作，如"演示"、"说话"、"操作"、"展示"等，1-3个
-- shot: 景别判断，只能是"特写"、"中景"或"远景"之一
-- has_text: 画面中是否有显著可读文字（标题、字幕、标语等）
-
-请只返回 JSON，不要有其他说明文字。"""
-
-
-def parse_vision_response(text: str) -> dict:
-    """解析 AI 返回的 JSON 标签文本.
-
-    Args:
-        text: 视觉 API 返回的文本，期望是 JSON 格式。
-
-    Returns:
-        结构化标签 dict，格式如：
-        {"scene": [...], "objects": [...], "action": [...], "shot": "...", "has_text": bool}
-
-    解析失败时返回空 dict。
-    """
-    if not text or not text.strip():
-        return {}
-
-    # 尝试直接解析
-    cleaned = text.strip()
-
-    # 去除可能的 markdown 代码块包裹
-    if cleaned.startswith("```"):
-        lines = cleaned.split("\n")
-        # 去掉首尾的 ``` 行
-        start = 1
-        end = len(lines)
-        for i in range(len(lines) - 1, 0, -1):
-            if lines[i].strip().startswith("```"):
-                end = i
-                break
-        cleaned = "\n".join(lines[start:end]).strip()
-
-    try:
-        data = json.loads(cleaned)
-    except json.JSONDecodeError:
-        # 尝试从文本中提取 JSON 块
-        try:
-            start_idx = cleaned.index("{")
-            end_idx = cleaned.rindex("}") + 1
-            data = json.loads(cleaned[start_idx:end_idx])
-        except (ValueError, json.JSONDecodeError):
-            logger.warning("无法解析 AI 标签响应: %s", text[:200])
-            return {}
-
-    if not isinstance(data, dict):
-        return {}
-
-    # 验证和清洗各字段
-    result: dict[str, Any] = {}
-    for key in ("scene", "objects", "action"):
-        val = data.get(key)
-        if isinstance(val, list):
-            result[key] = [str(v).strip() for v in val if str(v).strip()]
-        elif isinstance(val, str) and val.strip():
-            result[key] = [val.strip()]
-        else:
-            result[key] = []
-
-    shot_val = data.get("shot", "")
-    if isinstance(shot_val, str) and shot_val.strip() in ("特写", "中景", "远景"):
-        result["shot"] = shot_val.strip()
-    else:
-        result["shot"] = ""
-
-    has_text_val = data.get("has_text")
-    if isinstance(has_text_val, bool):
-        result["has_text"] = has_text_val
-    elif isinstance(has_text_val, str):
-        result["has_text"] = has_text_val.lower() in ("true", "yes", "1")
-    else:
-        result["has_text"] = False
-
-    return result
-
-
-def _extract_frames_via_mediakit(
-    mediakit_client: Any,
-    video_url: str,
-    start_time: float,
-    end_time: float,
-) -> Optional[list[str]]:
-    """通过 MediaKit 提取 3 帧（首、中、尾）.
-
-    Returns:
-        图片 URL 列表（3 个），失败返回 None。
-    """
-    try:
-        frames = mediakit_client.extract_frames(
-            video_url=video_url,
-            strategy="SpecifiedTime",
-            max_frames=3,
-            poll_interval=2.0,
-            max_poll_attempts=30,
-        )
-        # MediaKit SpecifiedTime 策略可能不支持直接传时间点
-        # 如果返回结果不够 3 帧，降级到 ffmpeg
-        if frames and len(frames) >= 1:
-            urls = [f.get("image_url", "") for f in frames if f.get("image_url")]
-            if urls:
-                return urls
-    except Exception as e:
-        logger.warning("MediaKit 抽帧失败，将降级为 ffmpeg: %s", e)
-
-    return None
-
-
-def _extract_frames_via_ffmpeg(
-    video_url: str,
-    start_time: float,
-    end_time: float,
-) -> Optional[list[str]]:
-    """通过 ffmpeg 本地提取 3 帧并转为 base64.
-
-    Returns:
-        base64 data URI 列表（3 个），失败返回 None。
-    """
-    import base64
-
-    mid_time = round((start_time + end_time) / 2, 3)
-    timestamps = [round(start_time, 3), mid_time, round(end_time, 3)]
-
-    try:
-        frames_b64: list[str] = []
-        with tempfile.TemporaryDirectory() as tmpdir:
-            for i, ts in enumerate(timestamps):
-                out_path = Path(tmpdir) / f"frame_{i}.jpg"
-                cmd = [
-                    "ffmpeg",
-                    "-y",
-                    "-ss",
-                    str(ts),
-                    "-i",
-                    video_url,
-                    "-vframes",
-                    "1",
-                    "-q:v",
-                    "2",
-                    str(out_path),
-                ]
-                result = subprocess.run(
-                    cmd,
-                    capture_output=True,
-                    timeout=30,
-                )
-                if result.returncode != 0 or not out_path.exists():
-                    logger.warning("ffmpeg 抽帧失败 ts=%s: %s", ts, result.stderr[:200])
-                    continue
-
-                img_data = out_path.read_bytes()
-                b64 = base64.b64encode(img_data).decode("ascii")
-                frames_b64.append(f"data:image/jpeg;base64,{b64}")
-
-        if frames_b64:
-            return frames_b64
-    except Exception as e:
-        logger.warning("ffmpeg 抽帧异常: %s", e)
-
-    return None
-
-
-def tag_atom_clip(
-    clip: Any,
-    video_url: str,
-    doubao_client: Any,
-    mediakit_client: Any | None = None,
-    storage: Any | None = None,
-) -> dict:
-    """主入口：为单个 atom_clip 生成 AI 标签.
-
-    流程：提取帧 → 调视觉 API → 解析标签 → 返回结构化标签 dict。
-    任何环节失败返回 {"inherited_tags": clip.tags}，不阻断流程。
-
-    Args:
-        clip: AssetAtomClip 领域对象（需有 start_time, end_time, tags）。
-        video_url: 素材视频的公网可访问 URL。
-        doubao_client: DoubaoClient 实例。
-        mediakit_client: MediaKitClient 实例（可选，不可用时降级 ffmpeg）。
-        storage: SharedStorageService 实例（可选，用于获取签名 URL）。
-
-    Returns:
-        结构化标签 dict，格式如：
-        {"scene": [...], "objects": [...], "action": [...], "shot": "...",
-         "has_text": bool, "inherited_tags": [...]}
-    """
-    inherited = list(getattr(clip, "tags", []) or [])
-
-    # 检查 DoubaoClient 是否可用
-    if not getattr(doubao_client, "is_available", False):
-        logger.info("DoubaoClient 不可用，跳过 AI 标签: clip_id=%s", getattr(clip, "id", ""))
-        return {"inherited_tags": inherited}
-
-    # 提取帧图片
-    frame_urls: Optional[list[str]] = None
-    start_time = getattr(clip, "start_time", 0.0)
-    end_time = getattr(clip, "end_time", 0.0)
-
-    # 优先使用 MediaKit
-    if mediakit_client and getattr(mediakit_client, "is_available", False):
-        frame_urls = _extract_frames_via_mediakit(mediakit_client, video_url, start_time, end_time)
-
-    # MediaKit 不可用或失败 → 降级 ffmpeg
-    if not frame_urls:
-        frame_urls = _extract_frames_via_ffmpeg(video_url, start_time, end_time)
-
-    if not frame_urls:
-        logger.warning("帧提取失败，跳过 AI 标签: clip_id=%s", getattr(clip, "id", ""))
-        return {"inherited_tags": inherited}
-
-    # 调用视觉 API
-    prompt = build_vision_prompt()
-    messages = [{"role": "user", "content": prompt}]
-
-    try:
-        response_text = doubao_client.vision_completion(
-            messages=messages,
-            images=frame_urls,
-            timeout=60,
-        )
-    except Exception as e:
-        logger.warning("视觉 API 调用异常: clip_id=%s error=%s", getattr(clip, "id", ""), e)
-        return {"inherited_tags": inherited}
-
-    if not response_text:
-        logger.warning("视觉 API 返回空: clip_id=%s", getattr(clip, "id", ""))
-        return {"inherited_tags": inherited}
-
-    # 解析标签
-    ai_tags = parse_vision_response(response_text)
-    if not ai_tags:
-        logger.warning("标签解析失败: clip_id=%s response=%s", getattr(clip, "id", ""), response_text[:200])
-        return {"inherited_tags": inherited}
-
-    # 合并 inherited_tags
-    ai_tags["inherited_tags"] = inherited
-    return ai_tags

packages/domain/narrative_match.py

@@ -1,4 +1,4 @@
-"""叙事剪辑素材标签匹配 — #1970 PR3 + P2 AI 标签加权.
+"""叙事剪辑素材标签匹配 — #1970 PR3.
 
 叙事模式下，选片在现有评分（smart_match / atom_clip_selector）之前先做一层
 文案标签匹配：
@@ -8,12 +8,6 @@
 - 调用方对优先池跑现有 smart_select_assets，数量不足时用普通池补足
   （无任何匹配 → 完全降级为现有随机逻辑，行为与改造前一致）。
 
-P2 AI 标签加权（#1970 fragment-level AI tagging）：
-- 片段级 AI 标签（scene/objects/action）与文案标签做交集时权重 2.0
-- 素材级标签（tag_ids 映射名）与文案标签交集时权重 1.0
-- 综合得分 = sum(命中权重) / max(可能权重)
-- 有 AI 标签的片段命中时优先于仅素材标签命中的片段
-
 纯函数模块：标签 id→名称映射由调用方查 TagModel 后注入，不直接碰 DB。
 """
 
@@ -24,10 +18,6 @@ from typing import Any, Iterable
 # 标签归一化后仍短于此长度的标签不参与匹配（避免「的」「是」这类噪声短词）
 MIN_TAG_LEN = 2
 
-# 标签匹配权重
-AI_TAG_WEIGHT = 2.0  # AI 标签命中权重
-ASSET_TAG_WEIGHT = 1.0  # 素材标签命中权重
-
 
 def normalize_tag(tag: Any) -> str:
     """标签归一化：去空白、小写。数字/英文统一小写，中文不受影响。"""
@@ -57,81 +47,19 @@ def build_asset_tag_name_index(tag_names_by_id: dict[str, Any]) -> dict[str, set
     return index
 
 
-def _extract_ai_tag_names(ai_tags: dict) -> set[str]:
-    """从 AI 标签 dict 中提取所有标签名（scene + objects + action）.
-
-    Args:
-        ai_tags: 片段级 AI 标签 dict，如 {"scene": [...], "objects": [...], "action": [...], ...}
-
-    Returns:
-        归一化后的标签名集合。
-    """
-    names: set[str] = set()
-    for key in ("scene", "objects", "action"):
-        values = ai_tags.get(key)
-        if isinstance(values, list):
-            names |= _normalize_tags(values)
-    return names
-
-
-def _compute_ai_score(
-    asset_id: str,
-    wanted: set[str],
-    clip_ai_tags_by_asset: dict[str, list[dict]] | None,
-) -> float:
-    """计算单个素材的 AI 标签加权得分.
-
-    对该素材的所有片段 AI 标签，求各片段标签名与文案标签交集的加权总和。
-    每个片段的命中权重 = 命中数 × AI_TAG_WEIGHT。
-    最终取所有片段的最高得分（而非累加，避免片段数多的素材不公平占优）。
-
-    Args:
-        asset_id: 素材 ID。
-        wanted: 归一化后的文案标签集合。
-        clip_ai_tags_by_asset: {asset_id: [ai_tag_dict, ...]} 每个片段一个。
-
-    Returns:
-        AI 标签加权得分（≥0）。
-    """
-    if not clip_ai_tags_by_asset or not wanted:
-        return 0.0
-
-    clips = clip_ai_tags_by_asset.get(asset_id)
-    if not clips:
-        return 0.0
-
-    best_score = 0.0
-    for ai_tags in clips:
-        if not ai_tags or not isinstance(ai_tags, dict):
-            continue
-        ai_names = _extract_ai_tag_names(ai_tags)
-        hits = ai_names & wanted
-        score = len(hits) * AI_TAG_WEIGHT
-        if score > best_score:
-            best_score = score
-
-    return best_score
-
-
 def match_assets_by_script_tags(
     assets: list[Any],
     *,
     script_tags: Iterable[Any],
     tag_names_by_id: dict[str, Any] | None = None,
-    clip_ai_tags_by_asset: dict[str, list[dict]] | None = None,
 ) -> tuple[list[Any], list[Any]]:
     """按文案标签把素材拆成「命中池 / 未命中池」，保持输入相对顺序。
 
-    P2 加权逻辑：
-    - AI 标签命中（scene/objects/action ∩ 文案标签）权重 2.0
-    - 素材标签命中（tag_ids 映射名 ∩ 文案标签）权重 1.0
-    - 任一权重 > 0 → 命中池，否则 → 未命中池
-
     Args:
         assets: 候选素材（domain Asset，需有 id 与 tag_ids）。
         script_tags: 文案 tags（字符串数组，名称语义）。
-        tag_names_by_id: asset_id → 素材标签名列表。
-        clip_ai_tags_by_asset: #1970 P2 — {asset_id: [ai_tag_dict, ...]}。
+        tag_names_by_id: asset_id → 素材标签名列表；素材只有 tag_ids 时由调用方
+            查 TagModel 名称后传入。为空则视为无素材命中。
 
     Returns:
         (matched, unmatched)：命中任一文案标签的素材 / 其余素材。
@@ -146,74 +74,23 @@ def match_assets_by_script_tags(
     unmatched: list[Any] = []
     for asset in assets:
         asset_id = str(getattr(asset, "id", "") or "")
-
-        # P2: AI 标签加权得分
-        ai_score = _compute_ai_score(asset_id, wanted, clip_ai_tags_by_asset)
-
-        # 素材标签得分
         names = set(name_index.get(asset_id, set()))
+        # 兼容素材自身带字符串 tags（旧链路/测试替身）
         raw_tags = getattr(asset, "tags", None)
         if raw_tags:
             names |= _normalize_tags(raw_tags)
-        asset_score = len(names & wanted) * ASSET_TAG_WEIGHT
-
-        # 综合得分 > 0 → 命中池
-        if ai_score > 0 or asset_score > 0:
+        if names & wanted:
             matched.append(asset)
         else:
             unmatched.append(asset)
     return matched, unmatched
 
 
-def compute_tag_match_score(
-    asset_id: str,
-    *,
-    script_tags: Iterable[Any],
-    tag_names_by_id: dict[str, Any] | None = None,
-    clip_ai_tags_by_asset: dict[str, list[dict]] | None = None,
-) -> float:
-    """计算单个素材的标签匹配综合得分（0.0 ~ 1.0）.
-
-    综合得分 = sum(命中权重) / max(可能权重)
-    - AI 标签每命中一个 +2.0
-    - 素材标签每命中一个 +1.0
-    - max_possible = len(wanted) * (AI_TAG_WEIGHT + ASSET_TAG_WEIGHT)
-
-    Args:
-        asset_id: 素材 ID。
-        script_tags: 文案标签。
-        tag_names_by_id: 素材标签名索引。
-        clip_ai_tags_by_asset: AI 标签索引。
-
-    Returns:
-        归一化得分 0.0~1.0。
-    """
-    wanted = _normalize_tags(script_tags)
-    if not wanted:
-        return 0.0
-
-    # AI 得分
-    ai_score = _compute_ai_score(asset_id, wanted, clip_ai_tags_by_asset)
-
-    # 素材标签得分
-    name_index = build_asset_tag_name_index(tag_names_by_id or {})
-    names = name_index.get(asset_id, set())
-    asset_score = len(names & wanted) * ASSET_TAG_WEIGHT
-
-    # 归一化：最大可能得分 = 文案标签数 × (AI权重 + 素材权重)
-    max_possible = len(wanted) * (AI_TAG_WEIGHT + ASSET_TAG_WEIGHT)
-    if max_possible <= 0:
-        return 0.0
-
-    return min((ai_score + asset_score) / max_possible, 1.0)
-
-
 def pick_narrative_assets(
     assets: list[Any],
     *,
     script_tags: Iterable[Any],
     tag_names_by_id: dict[str, Any] | None = None,
-    clip_ai_tags_by_asset: dict[str, list[dict]] | None = None,
     limit: int | None = None,
     rng: Any = None,
 ) -> list[Any]:
@@ -223,13 +100,9 @@ def pick_narrative_assets(
     smart_match.smart_select_assets（质量/时长/新鲜度/未使用 + 随机噪声），
     不重写评分维度。
 
-    P2 增强：有 AI 标签的片段命中时权重更高（2.0 vs 1.0），
-    命中池内部按综合标签得分排序（AI 标签命中多的排前面）。
-
     Args:
         assets: ready 视频素材候选（调用方负责状态/类型过滤）。
         script_tags / tag_names_by_id: 见 match_assets_by_script_tags。
-        clip_ai_tags_by_asset: #1970 P2 — {asset_id: [ai_tag_dict, ...]}。
         limit: 需要的素材数量；None 表示全部（命中池 + 全部未命中池）。
         rng: 注入 smart_select_assets 的随机源（可复现）。
 
@@ -242,7 +115,6 @@ def pick_narrative_assets(
         assets,
         script_tags=script_tags,
         tag_names_by_id=tag_names_by_id,
-        clip_ai_tags_by_asset=clip_ai_tags_by_asset,
     )
 
     need = limit if (limit is not None and limit > 0) else None

packages/shared/ai_client.py

@@ -37,7 +37,6 @@ class DoubaoClient:
         self.base_url: str = settings.doubao_base_url.rstrip("/")
         self.timeout: int = settings.doubao_timeout
         self.max_retries: int = settings.doubao_max_retries
-        self.vision_model: str = settings.doubao_vision_model
 
     @property
     def is_available(self) -> bool:
@@ -104,99 +103,6 @@ class DoubaoClient:
         logger.error("豆包API调用最终失败: %s", last_error)
         return None
 
-    def vision_completion(
-        self,
-        messages: list[dict],
-        images: list[str] | None = None,
-        max_tokens: int = 2048,
-        temperature: float = 0.3,
-        timeout: int | None = None,
-    ) -> Optional[str]:
-        """调用豆包视觉理解 API（OpenAI 兼容多模态格式）.
-
-        将 images 附加到最后一条 user message 的 content 中，
-        使用 vision_model（默认 doubao-1-5-vision-pro-250915）。
-
-        Args:
-            messages: 对话消息列表。最后一条 user message 会被注入图片内容。
-            images: 图片列表，支持 base64 data URI 或 HTTP(S) URL。
-            max_tokens: 最大生成 token 数，默认 2048。
-            temperature: 采样温度，默认 0.3（视觉任务偏低更稳定）。
-            timeout: 单次请求超时秒数，不传则使用默认 self.timeout。
-
-        Returns:
-            模型返回的文本内容，失败返回 None。
-        """
-        if not self.is_available:
-            return None
-
-        # 构造多模态 content：先追加文本，再追加图片
-        vision_messages = []
-        for msg in messages:
-            vision_messages.append(dict(msg))
-
-        # 将图片注入最后一条 user message
-        if images and vision_messages:
-            # 找到最后一条 user message
-            for i in range(len(vision_messages) - 1, -1, -1):
-                if vision_messages[i].get("role") == "user":
-                    text_content = vision_messages[i].get("content", "")
-                    multi_content: list[dict[str, Any]] = []
-                    if text_content:
-                        multi_content.append({"type": "text", "text": text_content})
-                    for img in images:
-                        if img.startswith("data:") or img.startswith("http://") or img.startswith("https://"):
-                            multi_content.append({"type": "image_url", "image_url": {"url": img}})
-                        else:
-                            # 当作 base64 编码
-                            multi_content.append(
-                                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img}"}}
-                            )
-                    vision_messages[i]["content"] = multi_content
-                    break
-
-        url = f"{self.base_url}/chat/completions"
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-        }
-        payload: dict[str, Any] = {
-            "model": self.vision_model,
-            "messages": vision_messages,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        }
-
-        req_timeout = timeout or self.timeout
-        last_error: Optional[Exception] = None
-        for attempt in range(self.max_retries + 1):
-            try:
-                response = httpx.post(
-                    url,
-                    headers=headers,
-                    json=payload,
-                    timeout=req_timeout,
-                )
-                response.raise_for_status()
-                data = response.json()
-                content = data["choices"][0]["message"]["content"]
-                return content.strip()
-            except Exception as e:
-                last_error = e
-                if attempt < self.max_retries:
-                    wait = 0.5 * (2**attempt)
-                    logger.warning(
-                        "豆包视觉API调用失败，%.1fs后重试 (第%d/%d次): %s",
-                        wait,
-                        attempt + 1,
-                        self.max_retries + 1,
-                        e,
-                    )
-                    time.sleep(wait)
-
-        logger.error("豆包视觉API调用最终失败: %s", last_error)
-        return None
-
 
 # ── 单例 ─────────────────────────────────────────────────────────────────────
 

packages/shared/storage.py

@@ -339,44 +339,6 @@ class SharedStorageService(StoragePort):
 
     # ── 浏览器直传 POST ────────────────────────────────────────────────
 
-    def get_upload_url(
-        self,
-        storage_key_or_url: str,
-        expires_seconds: int = 3600,
-        content_type: str = "video/mp4",
-    ) -> str:
-        """获取预签名 PUT 上传 URL（供外部 Worker 上传结果文件）。
-
-        bucket未配置时降级为 public_url（本地/开发环境）；
-        本地产物 key 原样返回。
-        """
-        if self.bucket is None:
-            if self._is_local_generated_url(storage_key_or_url):
-                return storage_key_or_url
-            logger.warning(
-                "get_upload_url: OSS bucket not configured, returning raw URL. key=%s",
-                storage_key_or_url[:200],
-            )
-            return self.get_url(self.normalize_storage_key(storage_key_or_url))
-
-        storage_key = self.normalize_storage_key(storage_key_or_url)
-        try:
-            # oss2 sign_url 支持 'PUT'，需指定 headers 才能限定 Content-Type
-            headers = {"Content-Type": content_type} if content_type else None
-            signed = self.bucket.sign_url("PUT", storage_key, expires_seconds, headers=headers)
-            logger.info(
-                "get_upload_url: signed PUT URL generated. key=%s url_prefix=%s",
-                storage_key[:80],
-                signed[:60],
-            )
-            return signed
-        except Exception:
-            logger.exception(
-                "get_upload_url: sign_url failed, falling back to raw URL. key=%s",
-                storage_key[:200],
-            )
-            return self.get_url(storage_key)
-
     def create_direct_upload_post(
         self,
         storage_key: str,

scripts/render_env.sh

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

tests/unit/test_1970_atom_clip_tagger.py

@@ -1,292 +0,0 @@
-"""#1970 P2 片段级 AI 标签模块测试。
-
-测试范围：
-- build_vision_prompt: 返回有效 prompt
-- parse_vision_response: 正常/异常/空值
-- tag_atom_clip: 成功/MediaKit不可用/视觉API失败/超时降级
-"""
-
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass, field
-from datetime import UTC, datetime
-
-import pytest
-
-from packages.domain.atom_clip_tagger import (
-    build_vision_prompt,
-    parse_vision_response,
-    tag_atom_clip,
-)
-
-# ── Fake 对象 ──────────────────────────────────────────────────────────────
-
-
-@dataclass
-class FakeClip:
-    id: str = "clip-001"
-    asset_id: str = "asset-001"
-    start_time: float = 0.0
-    end_time: float = 5.0
-    duration: float = 5.0
-    clip_index: int = 0
-    tags: list[str] = field(default_factory=lambda: ["tag1", "tag2"])
-    ai_tags: dict | None = None
-
-
-class FakeDoubaoClient:
-    """模拟豆包客户端."""
-
-    def __init__(self, available: bool = True, response: str | None = None, raise_error: bool = False):
-        self._available = available
-        self._response = response
-        self._raise_error = raise_error
-        self.vision_calls: list[dict] = []
-
-    @property
-    def is_available(self) -> bool:
-        return self._available
-
-    def vision_completion(self, messages, images=None, timeout=None, **kwargs):
-        self.vision_calls.append({"messages": messages, "images": images, "timeout": timeout})
-        if self._raise_error:
-            raise RuntimeError("API error")
-        return self._response
-
-
-class FakeMediaKitClient:
-    """模拟 MediaKit 客户端."""
-
-    def __init__(self, available: bool = True, frames: list[dict] | None = None):
-        self._available = available
-        self._frames = frames
-
-    @property
-    def is_available(self) -> bool:
-        return self._available
-
-    def extract_frames(self, video_url, strategy=None, max_frames=None, **kwargs):
-        return self._frames
-
-
-# ── build_vision_prompt ────────────────────────────────────────────────────
-
-
-class TestBuildVisionPrompt:
-    def test_returns_non_empty_string(self):
-        prompt = build_vision_prompt()
-        assert isinstance(prompt, str)
-        assert len(prompt) > 100
-
-    def test_contains_required_keys(self):
-        prompt = build_vision_prompt()
-        assert "scene" in prompt
-        assert "objects" in prompt
-        assert "action" in prompt
-        assert "shot" in prompt
-        assert "has_text" in prompt
-
-    def test_requests_json_format(self):
-        prompt = build_vision_prompt()
-        assert "JSON" in prompt or "json" in prompt
-
-
-# ── parse_vision_response ──────────────────────────────────────────────────
-
-
-class TestParseVisionResponse:
-    def test_valid_json(self):
-        response = json.dumps(
-            {
-                "scene": ["工厂", "车间"],
-                "objects": ["产品", "机器"],
-                "action": ["演示"],
-                "shot": "特写",
-                "has_text": True,
-            }
-        )
-        result = parse_vision_response(response)
-        assert result["scene"] == ["工厂", "车间"]
-        assert result["objects"] == ["产品", "机器"]
-        assert result["action"] == ["演示"]
-        assert result["shot"] == "特写"
-        assert result["has_text"] is True
-
-    def test_json_with_markdown_code_block(self):
-        response = '```json\n{"scene": ["办公室"], "objects": ["电脑"], "action": ["说话"], "shot": "中景", "has_text": false}\n```'
-        result = parse_vision_response(response)
-        assert result["scene"] == ["办公室"]
-        assert result["has_text"] is False
-
-    def test_json_embedded_in_text(self):
-        response = '这是一些说明文字\n{"scene": ["户外"], "objects": ["汽车"], "action": ["展示"], "shot": "远景", "has_text": false}\n结束'
-        result = parse_vision_response(response)
-        assert result["scene"] == ["户外"]
-
-    def test_empty_response(self):
-        assert parse_vision_response("") == {}
-        assert parse_vision_response(None) == {}
-        assert parse_vision_response("   ") == {}
-
-    def test_invalid_json(self):
-        assert parse_vision_response("这不是JSON") == {}
-
-    def test_partial_fields(self):
-        response = json.dumps({"scene": ["工厂"]})
-        result = parse_vision_response(response)
-        assert result["scene"] == ["工厂"]
-        assert result["objects"] == []
-        assert result["shot"] == ""
-        assert result["has_text"] is False
-
-    def test_invalid_shot_value(self):
-        response = json.dumps({"scene": [], "objects": [], "action": [], "shot": "全景", "has_text": False})
-        result = parse_vision_response(response)
-        # "全景" 不在有效值 ("特写", "中景", "远景") 中
-        assert result["shot"] == ""
-
-    def test_string_values_converted_to_list(self):
-        response = json.dumps(
-            {"scene": "工厂", "objects": "产品", "action": "演示", "shot": "特写", "has_text": "true"}
-        )
-        result = parse_vision_response(response)
-        assert result["scene"] == ["工厂"]
-        assert result["objects"] == ["产品"]
-        assert result["has_text"] is True
-
-    def test_non_dict_json(self):
-        assert parse_vision_response("[1, 2, 3]") == {}
-        assert parse_vision_response('"hello"') == {}
-
-
-# ── tag_atom_clip ──────────────────────────────────────────────────────────
-
-
-class TestTagAtomClip:
-    def test_success_with_mediakit(self):
-        """MediaKit 可用 + 视觉 API 成功 → 返回完整 AI 标签."""
-        clip = FakeClip()
-        fake_doubao = FakeDoubaoClient(
-            response=json.dumps(
-                {
-                    "scene": ["工厂"],
-                    "objects": ["产品"],
-                    "action": ["演示"],
-                    "shot": "特写",
-                    "has_text": False,
-                }
-            )
-        )
-        fake_mediakit = FakeMediaKitClient(
-            frames=[
-                {"image_url": "https://example.com/frame1.jpg", "timestamp": 0.0},
-                {"image_url": "https://example.com/frame2.jpg", "timestamp": 2.5},
-                {"image_url": "https://example.com/frame3.jpg", "timestamp": 5.0},
-            ]
-        )
-
-        result = tag_atom_clip(
-            clip=clip,
-            video_url="https://example.com/video.mp4",
-            doubao_client=fake_doubao,
-            mediakit_client=fake_mediakit,
-        )
-
-        assert result["scene"] == ["工厂"]
-        assert result["objects"] == ["产品"]
-        assert result["shot"] == "特写"
-        assert result["inherited_tags"] == ["tag1", "tag2"]
-        assert len(fake_doubao.vision_calls) == 1
-
-    def test_doubao_unavailable_returns_inherited(self):
-        """DoubaoClient 不可用 → 返回 inherited_tags."""
-        clip = FakeClip()
-        fake_doubao = FakeDoubaoClient(available=False)
-
-        result = tag_atom_clip(
-            clip=clip,
-            video_url="https://example.com/video.mp4",
-            doubao_client=fake_doubao,
-        )
-
-        assert result == {"inherited_tags": ["tag1", "tag2"]}
-        assert len(fake_doubao.vision_calls) == 0
-
-    def test_mediakit_unavailable_no_ffmpeg(self):
-        """MediaKit 不可用 + 无 ffmpeg → 降级 inherited_tags."""
-        clip = FakeClip()
-        fake_doubao = FakeDoubaoClient()
-        fake_mediakit = FakeMediaKitClient(available=False)
-
-        result = tag_atom_clip(
-            clip=clip,
-            video_url="https://example.com/video.mp4",
-            doubao_client=fake_doubao,
-            mediakit_client=fake_mediakit,
-        )
-
-        # 没有 ffmpeg 的情况下，帧提取失败
-        assert result == {"inherited_tags": ["tag1", "tag2"]}
-
-    def test_vision_api_error_returns_inherited(self):
-        """视觉 API 抛异常 → 降级 inherited_tags."""
-        clip = FakeClip()
-        fake_doubao = FakeDoubaoClient(raise_error=True)
-        fake_mediakit = FakeMediaKitClient(frames=[{"image_url": "https://example.com/frame.jpg", "timestamp": 0.0}])
-
-        result = tag_atom_clip(
-            clip=clip,
-            video_url="https://example.com/video.mp4",
-            doubao_client=fake_doubao,
-            mediakit_client=fake_mediakit,
-        )
-
-        assert result == {"inherited_tags": ["tag1", "tag2"]}
-
-    def test_vision_api_empty_response(self):
-        """视觉 API 返回空 → 降级 inherited_tags."""
-        clip = FakeClip()
-        fake_doubao = FakeDoubaoClient(response=None)
-        fake_mediakit = FakeMediaKitClient(frames=[{"image_url": "https://example.com/frame.jpg", "timestamp": 0.0}])
-
-        result = tag_atom_clip(
-            clip=clip,
-            video_url="https://example.com/video.mp4",
-            doubao_client=fake_doubao,
-            mediakit_client=fake_mediakit,
-        )
-
-        assert result == {"inherited_tags": ["tag1", "tag2"]}
-
-    def test_vision_api_invalid_json_response(self):
-        """视觉 API 返回无效 JSON → 降级 inherited_tags."""
-        clip = FakeClip()
-        fake_doubao = FakeDoubaoClient(response="这不是JSON格式")
-        fake_mediakit = FakeMediaKitClient(frames=[{"image_url": "https://example.com/frame.jpg", "timestamp": 0.0}])
-
-        result = tag_atom_clip(
-            clip=clip,
-            video_url="https://example.com/video.mp4",
-            doubao_client=fake_doubao,
-            mediakit_client=fake_mediakit,
-        )
-
-        assert result == {"inherited_tags": ["tag1", "tag2"]}
-
-    def test_clip_with_empty_tags(self):
-        """空素材标签 → inherited_tags 为空列表."""
-        clip = FakeClip(tags=[])
-        fake_doubao = FakeDoubaoClient(available=False)
-
-        result = tag_atom_clip(
-            clip=clip,
-            video_url="https://example.com/video.mp4",
-            doubao_client=fake_doubao,
-        )
-
-        assert result == {"inherited_tags": []}
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-q"])

tests/unit/test_1970_celery_ai_tag_registration.py

@@ -1,82 +0,0 @@
-"""#1970 AI 标签 Celery 任务注册回归测试。
-
-背景：staging 上 worker.generate_atom_clips 正常派发 tag_atom_clip，
-但消费端报 "Received unregistered task of type 'worker.tag_atom_clip'"，
-根因是 celery_app.conf.imports 漏列任务模块，worker 进程从未 import 之。
-
-注意：tests/unit 下大量旧测试在 import 期向 sys.modules 注入
-worker_app.celery_app 的 MagicMock 且不还原，全量收集时会污染本测试，
-因此这里用 AST 静态解析 + 隔离子进程验证，不依赖 sys.modules 状态。
-"""
-
-from __future__ import annotations
-
-import ast
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-CELERY_APP_PY = REPO_ROOT / "apps" / "worker" / "worker_app" / "celery_app.py"
-
-REQUIRED_MODULES = (
-    "worker_app.tasks.atom_clip_tagging",
-    "worker_app.tasks.backfill_atom_clip_tags",
-)
-
-
-def _conf_imports_values() -> set[str]:
-    """从 celery_app.py AST 中提取 celery_app.conf.imports 元组的字符串项。"""
-    tree = ast.parse(CELERY_APP_PY.read_text(encoding="utf-8"))
-    values: set[str] = set()
-    for node in ast.walk(tree):
-        if not (isinstance(node, ast.Assign) and len(node.targets) == 1):
-            continue
-        target = node.targets[0]
-        # celery_app.conf.imports = (...) 或 conf.imports = (...)
-        if not (isinstance(target, ast.Attribute) and target.attr == "imports"):
-            continue
-        if isinstance(node.value, (ast.Tuple, ast.List)):
-            for elt in node.value.elts:
-                if isinstance(elt, ast.Constant) and isinstance(elt.value, str):
-                    values.add(elt.value)
-    return values
-
-
-def test_ai_tag_modules_in_celery_imports():
-    imports = _conf_imports_values()
-    for module in REQUIRED_MODULES:
-        assert module in imports, f"{module} 未加入 celery_app.conf.imports"
-
-
-def test_ai_tag_tasks_registered_in_isolated_process():
-    """隔离子进程（无 conftest / 无 sys.modules mock）真实加载 Celery app。"""
-    # 模拟 worker 启动时按 conf.imports import 任务模块的行为；
-    # 只导入 AI 标签两个模块（其他模块依赖 cv2 等本地未安装的重依赖）。
-    code = (
-        "import importlib, sys; "
-        "from worker_app.celery_app import celery_app; "
-        "mods = [m for m in celery_app.conf.imports or () "
-        "if 'atom_clip_tagging' in m or 'backfill_atom_clip_tags' in m]; "
-        "[importlib.import_module(m) for m in mods]; "
-        "missing = [n for n in "
-        "['worker.tag_atom_clip', 'worker.backfill_atom_clip_tags'] "
-        "if n not in celery_app.tasks]; "
-        "sys.exit(1 if missing or len(mods) < 2 else 0)"
-    )
-    env = os.environ.copy()
-    paths = [
-        str(REPO_ROOT),
-        str(REPO_ROOT / "apps" / "worker"),
-        str(REPO_ROOT / "packages"),
-    ]
-    env["PYTHONPATH"] = os.pathsep.join(paths) + os.pathsep + env.get("PYTHONPATH", "")
-    result = subprocess.run(
-        [sys.executable, "-c", code],
-        capture_output=True,
-        text=True,
-        env=env,
-        timeout=60,
-    )
-    assert result.returncode == 0, "隔离子进程中任务未注册成功:\n" f"stdout={result.stdout}\nstderr={result.stderr}"

tests/unit/test_1970_force_backfill_tags.py

@@ -1,347 +0,0 @@
-"""#1970 force 回填降级 AI 标签记录的回归测试。
-
-背景：DOUBAO_VISION_MODEL 未配置时，tagger 降级写入
-{"inherited_tags": [...]}（非 NULL），默认 backfill 只捞 ai_tags IS NULL，
-这批记录永远不会重打。force=True 时应纳入降级记录，并在打标成功后覆盖。
-
-覆盖：
-- find_untagged(include_downgraded) 的 SQL 过滤（SQLite 验证跨库 JSON 取值）
-- tag_atom_clip_task 的 force 跳过/放行/覆盖逻辑
-- backfill_atom_clip_tags(force=True) 给 tag 任务传 kwargs={"force": True}
-"""
-
-from __future__ import annotations
-
-from datetime import UTC, datetime
-from types import SimpleNamespace
-
-import pytest
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-
-from packages.adapters.sqlalchemy_impl.asset_atom_clip_repository import (
-    SQLAlchemyAssetAtomClipRepository,
-)
-from packages.adapters.sqlalchemy_impl.models import AssetAtomClipModel
-
-# ── 仓储层：find_untagged 过滤 ─────────────────────────────────────────────
-
-
-@pytest.fixture
-def repo_session():
-    engine = create_engine("sqlite:///:memory:")
-    AssetAtomClipModel.__table__.create(engine)
-    SessionTest = sessionmaker(bind=engine)
-    session = SessionTest()
-    now = datetime.now(UTC)
-    session.add_all(
-        [
-            AssetAtomClipModel(
-                id="c-null",
-                asset_id="a1",
-                start_time=0,
-                end_time=1,
-                duration=1,
-                clip_index=0,
-                tags=[],
-                ai_tags=None,
-                created_at=now,
-            ),
-            AssetAtomClipModel(
-                id="c-downgraded-empty",
-                asset_id="a1",
-                start_time=1,
-                end_time=2,
-                duration=1,
-                clip_index=1,
-                tags=[],
-                ai_tags={"inherited_tags": []},
-                created_at=now,
-            ),
-            AssetAtomClipModel(
-                id="c-downgraded-tags",
-                asset_id="a1",
-                start_time=2,
-                end_time=3,
-                duration=1,
-                clip_index=2,
-                tags=[],
-                ai_tags={"inherited_tags": ["口播"]},
-                created_at=now,
-            ),
-            AssetAtomClipModel(
-                id="c-tagged-true",
-                asset_id="a1",
-                start_time=3,
-                end_time=4,
-                duration=1,
-                clip_index=3,
-                tags=[],
-                ai_tags={"has_text": True, "scene": ["室内"], "inherited_tags": []},
-                created_at=now,
-            ),
-            AssetAtomClipModel(
-                id="c-tagged-false",
-                asset_id="a1",
-                start_time=4,
-                end_time=5,
-                duration=1,
-                clip_index=4,
-                tags=[],
-                ai_tags={"has_text": False, "inherited_tags": ["风景"]},
-                created_at=now,
-            ),
-        ]
-    )
-    session.commit()
-    # SQLAlchemy JSON 在 SQLite 下把 None 序列化为 'null' 字符串，
-    # 而生产 PostgreSQL 存的是真 SQL NULL；用原生 SQL 对齐生产语义。
-    from sqlalchemy import text
-
-    session.execute(text("UPDATE asset_atom_clips SET ai_tags = NULL WHERE id = 'c-null'"))
-    session.commit()
-    yield session
-    session.close()
-
-
-def test_find_untagged_default_only_null(repo_session):
-    repo = SQLAlchemyAssetAtomClipRepository(repo_session)
-    ids = {c.id for c in repo.find_untagged(limit=100)}
-    assert ids == {"c-null"}
-
-
-def test_find_untagged_include_downgraded(repo_session):
-    repo = SQLAlchemyAssetAtomClipRepository(repo_session)
-    ids = {c.id for c in repo.find_untagged(limit=100, include_downgraded=True)}
-    # NULL + 两条降级记录；含 has_text=true/false 的完整记录都排除
-    assert ids == {"c-null", "c-downgraded-empty", "c-downgraded-tags"}
-
-
-# ── 任务层：tag_atom_clip_task 的 force 语义 ───────────────────────────────
-
-
-def _import_tag_task_module():
-    from worker_app.tasks import atom_clip_tagging as mod
-
-    return mod
-
-
-def _call_tag_task(mod, clip_id, force):
-    """直接调用任务，兼容两种环境。
-
-    全量收集时旧测试向 sys.modules 注入 celery_app MagicMock（其 task
-    装饰器原样返回裸函数），此时是普通函数需显式传 self=None；
-    正常 Celery 环境下属性是 Task 代理对象（非普通 function），
-    已绑定 self，按业务签名直接调用即可。
-    """
-    import inspect
-
-    obj = mod.tag_atom_clip_task
-    if inspect.isfunction(obj):
-        return obj(None, clip_id, force=force)
-    return obj(clip_id, force=force)
-
-
-def test_tag_task_skips_downgraded_without_force(monkeypatch):
-    mod = _import_tag_task_module()
-    monkeypatch.setattr(
-        mod,
-        "SessionLocal",
-        lambda: SimpleNamespace(
-            rollback=lambda: None,
-            close=lambda: None,
-        ),
-    )
-
-    class _Repo:
-        def __init__(self, db):
-            pass
-
-        def find_by_id(self, clip_id):
-            return SimpleNamespace(
-                id=clip_id,
-                ai_tags={"inherited_tags": []},
-            )
-
-    monkeypatch.setattr(mod, "SQLAlchemyAssetAtomClipRepository", _Repo)
-
-    result = _call_tag_task(mod, "clip-downgraded", force=False)
-    assert result["status"] == "skipped"
-    assert result["reason"] == "already tagged"
-
-
-def test_tag_task_force_retags_downgraded_and_overwrites(monkeypatch):
-    mod = _import_tag_task_module()
-    updated: dict[str, dict] = {}
-
-    class _FakeSession:
-        def rollback(self):
-            pass
-
-        def close(self):
-            pass
-
-    monkeypatch.setattr(mod, "SessionLocal", _FakeSession)
-
-    class _AtomRepo:
-        def __init__(self, db):
-            pass
-
-        def find_by_id(self, clip_id):
-            return SimpleNamespace(
-                id=clip_id,
-                asset_id="asset-1",
-                start_time=0.0,
-                end_time=2.0,
-                tags=["旧标签"],
-                ai_tags={"inherited_tags": []},
-            )
-
-        def update_ai_tags(self, clip_id, ai_tags):
-            updated[clip_id] = ai_tags
-
-    class _AssetRepo:
-        def __init__(self, db):
-            pass
-
-        def find_by_id(self, asset_id):
-            return SimpleNamespace(id=asset_id, storage_key="k/video.mp4")
-
-    monkeypatch.setattr(mod, "SQLAlchemyAssetAtomClipRepository", _AtomRepo)
-    monkeypatch.setattr(mod, "SQLAlchemyAssetRepository", _AssetRepo)
-
-    class _Storage:
-        def get_download_url(self, key, expires_seconds=3600):
-            return "https://example.com/signed.mp4"
-
-    monkeypatch.setattr(mod, "get_shared_storage_service", lambda: _Storage())
-    monkeypatch.setattr(mod, "get_doubao_client", lambda: object())
-    monkeypatch.setattr(mod, "get_mediakit_client", lambda: None)
-
-    new_tags = {
-        "scene": ["室内"],
-        "objects": ["人物"],
-        "action": ["说话"],
-        "shot": "中景",
-        "has_text": True,
-        "inherited_tags": ["旧标签"],
-    }
-    monkeypatch.setattr(mod, "tag_atom_clip", lambda **kw: new_tags)
-
-    result = _call_tag_task(mod, "clip-downgraded", force=True)
-    assert result["status"] == "completed"
-    assert result["has_ai_tags"] is True
-    assert updated["clip-downgraded"] == new_tags
-
-
-def test_tag_task_force_still_skips_complete_tags(monkeypatch):
-    mod = _import_tag_task_module()
-    monkeypatch.setattr(
-        mod,
-        "SessionLocal",
-        lambda: SimpleNamespace(rollback=lambda: None, close=lambda: None),
-    )
-
-    class _Repo:
-        def __init__(self, db):
-            pass
-
-        def find_by_id(self, clip_id):
-            return SimpleNamespace(
-                id=clip_id,
-                ai_tags={"has_text": False, "inherited_tags": []},
-            )
-
-    monkeypatch.setattr(mod, "SQLAlchemyAssetAtomClipRepository", _Repo)
-
-    result = _call_tag_task(mod, "clip-complete", force=True)
-    assert result["status"] == "skipped"
-    assert result["reason"] == "already tagged"
-
-
-# ── backfill 任务：force 透传到 send_task ──────────────────────────────────
-
-
-def test_backfill_force_passes_kwarg(monkeypatch):
-    from worker_app.tasks import backfill_atom_clip_tags as bmod
-
-    sent: list[tuple] = []
-
-    class _FakeSession:
-        def close(self):
-            pass
-
-    monkeypatch.setattr(bmod, "SessionLocal", _FakeSession)
-
-    class _AtomRepo:
-        def __init__(self, db):
-            self.calls: list[bool] = []
-
-        def find_untagged(self, limit, include_downgraded=False):
-            self.calls.append(include_downgraded)
-            # 第一批返回一条降级记录，第二批返回空结束循环
-            if len(self.calls) == 1:
-                return [SimpleNamespace(id="clip-1")]
-            return []
-
-    repo_holder = {}
-
-    def _repo_factory(db):
-        repo = _AtomRepo(db)
-        repo_holder["repo"] = repo
-        return repo
-
-    monkeypatch.setattr(bmod, "SQLAlchemyAssetAtomClipRepository", _repo_factory)
-
-    def _send_task(name, args=None, kwargs=None):
-        sent.append((name, args, kwargs))
-
-    monkeypatch.setattr(bmod.celery_app, "send_task", _send_task)
-
-    result = bmod.backfill_atom_clip_tags(batch_size=10, batch_interval=0, force=True)
-
-    assert result["status"] == "completed"
-    assert result["total_submitted"] == 1
-    assert repo_holder["repo"].calls == [True, True]
-    assert sent == [
-        ("worker.tag_atom_clip", ["clip-1"], {"force": True}),
-    ]
-
-
-def test_backfill_default_does_not_force(monkeypatch):
-    from worker_app.tasks import backfill_atom_clip_tags as bmod
-
-    sent_kwargs: list[dict | None] = []
-
-    class _FakeSession:
-        def close(self):
-            pass
-
-    monkeypatch.setattr(bmod, "SessionLocal", _FakeSession)
-
-    class _AtomRepo:
-        def __init__(self, db):
-            self.calls: list[bool] = []
-
-        def find_untagged(self, limit, include_downgraded=False):
-            self.calls.append(include_downgraded)
-            return [SimpleNamespace(id="clip-null")] if self.calls == [False] else []
-
-    holder = {}
-
-    def _repo_factory(db):
-        holder["repo"] = _AtomRepo(db)
-        return holder["repo"]
-
-    monkeypatch.setattr(bmod, "SQLAlchemyAssetAtomClipRepository", _repo_factory)
-    monkeypatch.setattr(
-        bmod.celery_app,
-        "send_task",
-        lambda name, args=None, kwargs=None: sent_kwargs.append(kwargs),
-    )
-
-    result = bmod.backfill_atom_clip_tags(batch_size=10, batch_interval=0)
-
-    assert result["total_submitted"] == 1
-    assert holder["repo"].calls == [False, False]
-    assert sent_kwargs == [{"force": False}]

tests/unit/test_1970_gpu_worker_heartbeat.py

@@ -1,254 +0,0 @@
-"""#1970 GPU Worker 修复单测.
-
-覆盖 deploy/gpu_worker/gpu_worker.py（独立部署脚本，不在 apps/packages 包内，
-按文件路径动态加载）：
-1. 默认配置：REQUEST_TIMEOUT=900 / TASK_MAX_RETRY=1 / 心跳 30s / 最短 3s；
-2. 推理期心跳线程 POST /gpu/register 带 task_id，任务结束能停；
-3. <3s 短视频直接上报失败，不调用 MuseTalk；
-4. _call_musetalk 仅对 5xx/网络瞬时错误标记 retryable，4xx 不重试；
-5. _handle_task 只对 retryable 错误本地重试 1 次。
-"""
-
-from __future__ import annotations
-
-import importlib.util
-import os
-import sys
-import time
-from pathlib import Path
-from unittest import mock
-
-import pytest
-
-ROOT = Path(__file__).resolve().parents[2]
-WORKER_PATH = ROOT / "deploy" / "gpu_worker" / "gpu_worker.py"
-
-
-def _load_worker_module():
-    spec = importlib.util.spec_from_file_location("gpu_worker_standalone_1970", WORKER_PATH)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-@pytest.fixture
-def worker():
-    return _load_worker_module()
-
-
-# ── 默认配置 ───────────────────────────────────────────────────────
-
-
-def test_config_defaults_900_and_retry_one(monkeypatch):
-    """CI/本机若显式导出过这些 env，说明是运维覆盖，不应拿默认值断言；
-    因此只在四个 env 全部缺失时校验脚本内置默认值（#1970：900/1/30/3）。"""
-    keys = (
-        "REQUEST_TIMEOUT",
-        "TASK_MAX_RETRY",
-        "TASK_HEARTBEAT_INTERVAL",
-        "MIN_VIDEO_DURATION_SECONDS",
-    )
-    if any(k in os.environ for k in keys):
-        pytest.skip("环境显式设置了 worker 超时/重试变量，跳过默认值断言")
-    for key in keys:
-        monkeypatch.delenv(key, raising=False)
-    mod = _load_worker_module()
-    assert mod.Config.request_timeout == 900.0
-    assert mod.Config.task_max_retry == 1
-    assert mod.Config.task_heartbeat_interval == 30.0
-    assert mod.Config.min_video_duration_seconds == 3.0
-
-
-# ── register 携带 task_id ──────────────────────────────────────────
-
-
-def test_register_payload_includes_task_id_only_when_provided(worker, monkeypatch):
-    captured = []
-
-    class _Resp:
-        status_code = 200
-        text = ""
-
-    def _fake_post(url, json=None, headers=None, timeout=None):
-        captured.append(json)
-        return _Resp()
-
-    monkeypatch.setattr(worker.requests, "post", _fake_post)
-    monkeypatch.setattr(worker, "_check_musetalk_health", lambda: (True, {}))
-
-    assert worker._register("task-abc") is True
-    assert captured[-1]["task_id"] == "task-abc"
-    assert captured[-1]["worker_id"]
-
-    worker._register()  # 空闲心跳不带 task_id
-    assert "task_id" not in captured[-1]
-
-
-# ── 推理期心跳线程 ─────────────────────────────────────────────────
-
-
-def test_task_heartbeat_thread_sends_and_stops(worker, monkeypatch):
-    calls = []
-
-    def _fake_register(task_id=None):
-        calls.append(task_id)
-        return True
-
-    monkeypatch.setattr(worker, "_register", _fake_register)
-    hb = worker.TaskHeartbeat("task-hb1", interval=5)
-    hb.start()
-    time.sleep(0.3)  # 启动后立即发一次
-    hb.stop()
-    hb.join(timeout=2)
-    assert not hb.is_alive()
-    assert calls and all(c == "task-hb1" for c in calls)
-
-
-# ── 短视频前置拦截 ─────────────────────────────────────────────────
-
-
-def test_handle_task_short_video_reports_failed_without_inference(worker, monkeypatch, tmp_path):
-    video = tmp_path / "input.mp4"
-    video.write_bytes(b"fake-mp4-bytes")
-    audio = tmp_path / "input_audio.bin"
-    audio.write_bytes(b"fake-audio")
-    reports = []
-
-    monkeypatch.setattr(worker, "_register", lambda *a, **k: True)
-    monkeypatch.setattr(worker, "_download", lambda url, path: True)
-    # ffprobe 读出 1.2s → 低于 3s 阈值
-    monkeypatch.setattr(worker, "_probe_duration", lambda path: 1.2)
-
-    def _boom(*a, **k):
-        raise AssertionError("短视频不应调用 MuseTalk 推理")
-
-    monkeypatch.setattr(worker, "_call_musetalk", _boom)
-    monkeypatch.setattr(
-        worker,
-        "_report_result",
-        lambda task_id, success, duration=0.0, error_msg="": reports.append((task_id, success, error_msg)) or True,
-    )
-
-    task = {
-        "task_id": "task-short",
-        "video_url": "https://example.com/v.mp4",
-        "audio_url": "https://example.com/a.bin",
-    }
-    worker._handle_task(task)
-
-    assert len(reports) == 1
-    tid, ok, err = reports[0]
-    assert tid == "task-short"
-    assert ok is False
-    assert "视频过短" in err
-    assert "3" in err
-
-
-def test_handle_task_probe_failure_does_not_block(worker, monkeypatch):
-    """ffprobe 不可用（duration=0.0）时不能误杀，应继续推理."""
-    reports = []
-    monkeypatch.setattr(worker, "_register", lambda *a, **k: True)
-    monkeypatch.setattr(worker, "_download", lambda url, path: True)
-    monkeypatch.setattr(worker, "_probe_duration", lambda path: 0.0)
-    monkeypatch.setattr(
-        worker,
-        "_call_musetalk",
-        lambda v, a, o: (True, 8.0, "", False),
-    )
-    uploaded = []
-    monkeypatch.setattr(
-        worker,
-        "_report_success_with_file",
-        lambda task_id, duration, path: uploaded.append((task_id, duration)),
-    )
-    monkeypatch.setattr(worker, "_report_result", lambda *a, **k: True)
-
-    worker._handle_task({"task_id": "task-probe0", "video_url": "u", "audio_url": "u"})
-    assert uploaded == [("task-probe0", 8.0)]
-    assert reports == []
-
-
-# ── 重试语义：仅瞬时错误重试 ───────────────────────────────────────
-
-
-def test_call_musetalk_4xx_not_retryable_5xx_retryable(worker, monkeypatch, tmp_path):
-    video = tmp_path / "v.mp4"
-    audio = tmp_path / "a.bin"
-    video.write_bytes(b"v")
-    audio.write_bytes(b"a")
-    out = tmp_path / "o.mp4"
-
-    class _Resp:
-        def __init__(self, code, body=b"x" * 2048):
-            self.status_code = code
-            self.content = body
-            self.text = "err"
-
-    # 4xx：确定性失败，不重试
-    monkeypatch.setattr(worker.requests, "post", lambda *a, **k: _Resp(400))
-    ok, _, _, retryable = worker._call_musetalk(video, audio, out)
-    assert ok is False and retryable is False
-
-    monkeypatch.setattr(worker.requests, "post", lambda *a, **k: _Resp(503))
-    ok, _, _, retryable = worker._call_musetalk(video, audio, out)
-    assert ok is False and retryable is True
-
-    # 连接异常：瞬时错误，可重试
-    import requests as _requests
-
-    def _conn_err(*a, **k):
-        raise _requests.exceptions.ConnectionError("reset")
-
-    monkeypatch.setattr(worker.requests, "post", _conn_err)
-    ok, _, _, retryable = worker._call_musetalk(video, audio, out)
-    assert ok is False and retryable is True
-
-
-def test_handle_task_retries_once_for_transient_then_succeeds(worker, monkeypatch):
-    calls = []
-
-    def _fake_call(v, a, o):
-        calls.append(1)
-        if len(calls) == 1:
-            return False, 0.0, "MuseTalk HTTP 503: busy", True
-        return True, 6.5, "", False
-
-    monkeypatch.setattr(worker, "_register", lambda *a, **k: True)
-    monkeypatch.setattr(worker, "_download", lambda url, path: True)
-    monkeypatch.setattr(worker, "_probe_duration", lambda path: 12.0)
-    monkeypatch.setattr(worker, "_call_musetalk", _fake_call)
-    monkeypatch.setattr(worker, "time", mock.MagicMock())  # 重试 sleep 立即返回
-    uploaded = []
-    monkeypatch.setattr(
-        worker,
-        "_report_success_with_file",
-        lambda task_id, duration, path: uploaded.append((task_id, duration)),
-    )
-
-    worker._handle_task({"task_id": "t-retry", "video_url": "u", "audio_url": "u"})
-    assert len(calls) == 2
-    assert uploaded == [("t-retry", 6.5)]
-
-
-def test_handle_task_no_retry_for_deterministic_failure(worker, monkeypatch):
-    calls = []
-
-    def _fake_call(v, a, o):
-        calls.append(1)
-        return False, 0.0, "MuseTalk HTTP 400: bad input", False
-
-    reports = []
-    monkeypatch.setattr(worker, "_register", lambda *a, **k: True)
-    monkeypatch.setattr(worker, "_download", lambda url, path: True)
-    monkeypatch.setattr(worker, "_probe_duration", lambda path: 12.0)
-    monkeypatch.setattr(worker, "_call_musetalk", _fake_call)
-    monkeypatch.setattr(
-        worker,
-        "_report_result",
-        lambda task_id, success, duration=0.0, error_msg="": reports.append(error_msg) or True,
-    )
-
-    worker._handle_task({"task_id": "t-4xx", "video_url": "u", "audio_url": "u"})
-    assert len(calls) == 1  # 4xx 本地不重试，直接交服务端决定
-    assert reports and "400" in reports[0]

tests/unit/test_1970_hflip_ai_tags.py

@@ -1,185 +0,0 @@
-"""#1970 hflip 放开（has_text 来自 atom_clip.ai_tags）端到端参数链路测试。
-
-覆盖：
-1. UnifiedRenderService 传入 clip_has_text 后微变换计划的翻转门控；
-2. RenderAdapter._resolve_clip_has_text 按 atom_clip.ai_tags.has_text
-   解析布尔列表（显式 False 才可翻转，其余保守），失败回退 None；
-3. 纯函数层在「混合有/无文字」列表下的行为（顺序对齐）。
-"""
-
-from __future__ import annotations
-
-from types import SimpleNamespace
-from unittest.mock import MagicMock, patch
-
-import pytest
-from video_processing.micro_transform_pure import build_micro_transform_plan
-
-
-def _make_service(plan_config: dict | None = None, clip_has_text=None):
-    from video_processing.unified_render_service import UnifiedRenderService
-
-    svc = object.__new__(UnifiedRenderService)
-    svc.plan = MagicMock()
-    svc.plan.config = plan_config or {}
-    svc.plan.id = "plan-1"
-    svc.plan.clips = []
-    svc._micro_plan_cache = None
-    svc._micro_plan_loaded = False
-    svc._clip_has_text = clip_has_text
-    return svc
-
-
-def _clip(clip_id: str, atom_clip_id: str = "", clip_type: str = "main"):
-    return SimpleNamespace(id=clip_id, atom_clip_id=atom_clip_id, clip_type=clip_type)
-
-
-def _atom(clip_id: str, ai_tags):
-    return SimpleNamespace(id=clip_id, ai_tags=ai_tags)
-
-
-class TestServiceClipHasText:
-    def test_none_stays_conservative(self):
-        # 未注入检测列表：所有片段一律不翻转
-        svc = _make_service({"generation_task_id": "t1"}, clip_has_text=None)
-        plan = svc._get_micro_transform_plan(30)
-        assert plan is not None
-        assert all(c.has_text for c in plan.clips)
-        assert all(not c.hflip for c in plan.clips)
-
-    def test_explicit_no_text_allows_hflip(self):
-        # AI 明确判定无文字：允许参与 50% 翻转（40 段应至少出现一些翻转）
-        svc = _make_service({"generation_task_id": "t-allow"}, clip_has_text=[False] * 40)
-        plan = svc._get_micro_transform_plan(40)
-        assert plan is not None
-        assert all(not c.has_text for c in plan.clips)
-        assert any(c.hflip for c in plan.clips)
-        assert all(not c.hflip or not c.has_text for c in plan.clips)
-
-    def test_all_text_never_flips(self):
-        svc = _make_service({"generation_task_id": "t-text"}, clip_has_text=[True] * 40)
-        plan = svc._get_micro_transform_plan(40)
-        assert all(c.has_text for c in plan.clips)
-        assert all(not c.hflip for c in plan.clips)
-
-    def test_mixed_order_alignment(self):
-        # 仅第 0、2 个片段无文字；has_text 标记必须与片段序号严格对齐
-        svc = _make_service({"generation_task_id": "t-mix"}, clip_has_text=[False, True, False, True])
-        plan = svc._get_micro_transform_plan(4)
-        assert [c.has_text for c in plan.clips] == [False, True, False, True]
-        assert all(not plan.clips[i].hflip for i in (1, 3))
-        for i in (0, 2):
-            # 无文字片段的翻转由 50% 种子决定，但允许翻转（不强制一定翻）
-            assert plan.clips[i].has_text is False
-
-    def test_list_shorter_than_clips_missing_are_conservative(self):
-        # 列表短于片段数：缺位片段按有文字处理
-        svc = _make_service({"generation_task_id": "t-short"}, clip_has_text=[False])
-        plan = svc._get_micro_transform_plan(3)
-        assert [c.has_text for c in plan.clips] == [False, True, True]
-        assert not plan.clips[1].hflip and not plan.clips[2].hflip
-
-    def test_plan_reproducible_with_real_list(self):
-        cfg = {"generation_task_id": "task-x", "video_index": 1}
-        flags = [False, True, False, False, True]
-        p1 = _make_service(cfg, clip_has_text=flags)._get_micro_transform_plan(5)
-        p2 = _make_service(dict(cfg), clip_has_text=list(flags))._get_micro_transform_plan(5)
-        assert [c.hflip for c in p1.clips] == [c.hflip for c in p2.clips]
-
-
-class TestPureMixedFlags:
-    def test_pure_function_mixed_flags(self):
-        plan = build_micro_transform_plan("seed-1", 0, 4, clip_has_text=[False, True, False, True])
-        assert [c.has_text for c in plan.clips] == [False, True, False, True]
-        # 有文字片段绝不翻转
-        assert not plan.clips[1].hflip and not plan.clips[3].hflip
-
-
-class TestResolveClipHasText:
-    def _adapter(self):
-        from video_processing.render_adapter import RenderAdapter
-
-        return RenderAdapter(MagicMock())
-
-    def test_no_atom_ids_returns_none(self):
-        adapter = self._adapter()
-        clips = [_clip("c1", ""), _clip("c2", "")]
-        assert adapter._resolve_clip_has_text(clips) is None
-
-    def test_explicit_false_only_maps_to_false(self):
-        adapter = self._adapter()
-        clips = [
-            _clip("c1", "a1"),
-            _clip("c2", "a2"),
-            _clip("c3", "a3"),
-            _clip("c4", "a4"),
-            _clip("c5", "a5"),
-        ]
-        atoms = [
-            _atom("a1", {"has_text": False}),  # 明确无文字 → False
-            _atom("a2", {"has_text": True}),  # 有文字
-            _atom("a3", None),  # 标签未生成
-            _atom("a4", {"scene": ["工厂"]}),  # has_text 缺失（null）
-            _atom("a5", {"has_text": "false"}),  # 非布尔 → 保守
-        ]
-        with patch(
-            "packages.adapters.sqlalchemy_impl.asset_atom_clip_repository."
-            "SQLAlchemyAssetAtomClipRepository.find_by_ids",
-            return_value=atoms,
-        ):
-            result = adapter._resolve_clip_has_text(clips)
-        assert result == [False, True, True, True, True]
-
-    def test_audio_clips_excluded_and_order_kept(self):
-        adapter = self._adapter()
-        clips = [
-            _clip("c1", "a1", clip_type="main"),
-            _clip("bgm", "", clip_type="audio"),
-            _clip("c2", "a2", clip_type="pip"),
-        ]
-        atoms = [
-            _atom("a1", {"has_text": False}),
-            _atom("a2", {"has_text": False}),
-        ]
-        with patch(
-            "packages.adapters.sqlalchemy_impl.asset_atom_clip_repository."
-            "SQLAlchemyAssetAtomClipRepository.find_by_ids",
-            return_value=atoms,
-        ) as mock_find:
-            result = adapter._resolve_clip_has_text(clips)
-        # 只查非 audio 片段的 atom id，且顺序为 main → pip
-        assert mock_find.call_args.args[0] == ["a1", "a2"]
-        assert result == [False, False]
-
-    def test_missing_atom_record_defaults_true(self):
-        adapter = self._adapter()
-        clips = [_clip("c1", "a1"), _clip("c2", "a2")]
-        with patch(
-            "packages.adapters.sqlalchemy_impl.asset_atom_clip_repository."
-            "SQLAlchemyAssetAtomClipRepository.find_by_ids",
-            return_value=[_atom("a1", {"has_text": False})],  # a2 查不到
-        ):
-            result = adapter._resolve_clip_has_text(clips)
-        assert result == [False, True]
-
-    def test_query_failure_returns_none(self):
-        adapter = self._adapter()
-        clips = [_clip("c1", "a1")]
-        with patch(
-            "packages.adapters.sqlalchemy_impl.asset_atom_clip_repository."
-            "SQLAlchemyAssetAtomClipRepository.find_by_ids",
-            side_effect=RuntimeError("db down"),
-        ):
-            assert adapter._resolve_clip_has_text(clips) is None
-
-    def test_duplicate_atom_ids_queried_once(self):
-        adapter = self._adapter()
-        clips = [_clip("c1", "a1"), _clip("c2", "a1")]
-        with patch(
-            "packages.adapters.sqlalchemy_impl.asset_atom_clip_repository."
-            "SQLAlchemyAssetAtomClipRepository.find_by_ids",
-            return_value=[_atom("a1", {"has_text": False})],
-        ) as mock_find:
-            result = adapter._resolve_clip_has_text(clips)
-        assert mock_find.call_args.args[0] == ["a1"]
-        assert result == [False, False]

tests/unit/test_1970_micro_transform_render.py

@@ -22,7 +22,6 @@ def _make_service(plan_config: dict | None = None, clips=None):
     svc.plan.clips = clips or []
     svc._micro_plan_cache = None
     svc._micro_plan_loaded = False
-    svc._clip_has_text = None
     return svc
 
 
@@ -160,7 +159,6 @@ class TestStreamCopyGate:
         svc.clips = [source]
         svc._micro_plan_cache = None
         svc._micro_plan_loaded = False
-        svc._clip_has_text = None
         resolved = ResolvedClip(
             clip_id="c1",
             asset_id="a1",

tests/unit/test_1970_musetalk_server.py

@@ -1,323 +0,0 @@
-"""#1970 MuseTalk Flask 服务端 8 项工程 bug 修复单测.
-
-覆盖 deploy/gpu_worker/musetalk_server.py（独立部署脚本，按文件路径动态加载）：
-1. threaded=True 启动，/health 在推理阻塞时仍可达
-2. fps 兜底：ffprobe 返回 0 或失败时使用 default_fps
-3. ffmpeg 走 subprocess.run(check=True)，失败抛 RuntimeError
-4. 并发锁：推理期间第二请求立即 503
-5. 推理超时：超过 MUSE_INFERENCE_TIMEOUT 返回 504
-6. 结果文件清理：临时目录在请求结束（成功/失败）后删除
-7. 文件大小限制：超过限制返回 413，空文件返回 400
-8. /cancel 端点：终止当前推理，清理临时文件
-"""
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import os
-import shutil
-import sys
-import threading
-import time
-from pathlib import Path
-from unittest import mock
-
-import pytest
-
-# 检查 Flask 是否可用（CI 环境可能没装）
-try:
-    import flask  # noqa: F401
-
-    HAS_FLASK = True
-except ImportError:
-    HAS_FLASK = False
-
-pytestmark = pytest.mark.skipif(not HAS_FLASK, reason="Flask 未安装（gpu_worker 独立部署依赖）")
-
-ROOT = Path(__file__).resolve().parents[2]
-SERVER_PATH = ROOT / "deploy" / "gpu_worker" / "musetalk_server.py"
-
-
-def _load_server_module(name: str = "musetalk_server_test"):
-    """加载 musetalk_server.py 为独立模块."""
-    # 避免重复注册
-    if name in sys.modules:
-        del sys.modules[name]
-    spec = importlib.util.spec_from_file_location(name, SERVER_PATH)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules[name] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-@pytest.fixture
-def server(tmp_path, monkeypatch):
-    """加载一个干净的 musetalk_server 模块，使用独立临时目录和端口."""
-    if not HAS_FLASK:
-        pytest.skip("Flask 未安装（gpu_worker 独立部署依赖）")
-
-    monkeypatch.setenv("MUSE_TEMP_DIR", str(tmp_path / "musetalk_temp"))
-    monkeypatch.setenv("MUSE_PORT", "0")
-    monkeypatch.setenv("MUSE_INFERENCE_TIMEOUT", "2")
-    monkeypatch.setenv("MUSE_VIDEO_MAX_MB", "1")
-    monkeypatch.setenv("MUSE_AUDIO_MAX_MB", "1")
-    monkeypatch.setenv("MUSE_DEFAULT_FPS", "25.0")
-
-    mod_name = f"musetalk_server_test_{os.getpid()}_{id(tmp_path)}"
-    mod = _load_server_module(mod_name)
-
-    # 确保配置已更新
-    mod.Config.temp_dir = str(tmp_path / "musetalk_temp")
-    mod.Config.inference_timeout = 2.0
-    mod.Config.video_max_mb = 1
-    mod.Config.audio_max_mb = 1
-    mod.Config.default_fps = 25.0
-
-    Path(mod.Config.temp_dir).mkdir(parents=True, exist_ok=True)
-
-    # 重置全局状态
-    mod.inference_lock = threading.Lock()
-    mod.current_task = {"task_id": None, "process": None, "start_time": 0.0}
-
-    return mod
-
-
-# ── 1. Flask threaded=True ──────────────────────────────────────────
-
-
-def test_flask_run_uses_threaded(server):
-    """验证 app.run 调用时 threaded=True."""
-    with mock.patch.object(server.app, "run") as mock_run:
-        server.main()
-        mock_run.assert_called_once()
-        call_kwargs = mock_run.call_args
-        assert call_kwargs.kwargs.get("threaded") is True
-
-
-# ── 2. fps=0 兜底 ───────────────────────────────────────────────────
-
-
-def test_get_video_fps_fallback_on_zero(server, tmp_path):
-    """ffprobe 返回 0/1 时兜底为 default_fps."""
-    fake_video = tmp_path / "fake.mp4"
-    fake_video.write_bytes(b"fake")
-    with mock.patch("subprocess.check_output", return_value=b"0/1"):
-        fps = server._get_video_fps(fake_video)
-        assert fps == 25.0
-
-
-def test_get_video_fps_normal(server, tmp_path):
-    """正常 fps 解析."""
-    fake_video = tmp_path / "fake.mp4"
-    fake_video.write_bytes(b"fake")
-    with mock.patch("subprocess.check_output", return_value=b"30/1"):
-        fps = server._get_video_fps(fake_video)
-        assert abs(fps - 30.0) < 0.01
-
-
-def test_get_video_fps_exception_fallback(server, tmp_path):
-    """ffprobe 异常时兜底 default_fps."""
-    fake_video = tmp_path / "fake.mp4"
-    fake_video.write_bytes(b"fake")
-    with mock.patch("subprocess.check_output", side_effect=Exception("no ffprobe")):
-        fps = server._get_video_fps(fake_video)
-        assert fps == 25.0
-
-
-# ── 3. ffmpeg 错误检查 ──────────────────────────────────────────────
-
-
-def test_run_ffmpeg_raises_on_nonzero_exit(server):
-    """ffmpeg 返回非零应抛 RuntimeError."""
-    import subprocess
-
-    with mock.patch(
-        "subprocess.run",
-        side_effect=subprocess.CalledProcessError(1, "ffmpeg", stderr=b"decode error"),
-    ):
-        with pytest.raises(RuntimeError, match="ffmpeg 失败"):
-            server._run_ffmpeg(["ffmpeg", "-i", "in", "out"])
-
-
-def test_run_ffmpeg_raises_on_timeout(server):
-    """ffmpeg 超时应抛 RuntimeError."""
-    import subprocess
-
-    with mock.patch("subprocess.run", side_effect=subprocess.TimeoutExpired("ffmpeg", 10)):
-        with pytest.raises(RuntimeError, match="ffmpeg 超时"):
-            server._run_ffmpeg(["ffmpeg", "-i", "in", "out"], timeout=10)
-
-
-# ── 4. 并发锁 503 ──────────────────────────────────────────────────
-
-
-def test_inference_returns_503_when_busy(server):
-    """推理期间第二请求立即 503."""
-    server.inference_lock.acquire()
-    server.current_task["task_id"] = "task-busy"
-    server.current_task["start_time"] = time.time()
-
-    try:
-        with server.app.test_client() as c:
-            resp = c.post(
-                "/inference",
-                data={
-                    "video": (io.BytesIO(b"v" * 100), "v.mp4"),
-                    "audio": (io.BytesIO(b"a" * 100), "a.wav"),
-                },
-                content_type="multipart/form-data",
-            )
-            assert resp.status_code == 503
-            assert resp.get_json()["status"] == "busy"
-    finally:
-        server.inference_lock.release()
-        server.current_task = {"task_id": None, "process": None, "start_time": 0.0}
-
-
-# ── 5. 推理超时 504 ─────────────────────────────────────────────────
-
-
-def test_inference_timeout_returns_504(server):
-    """推理超时返回 504."""
-
-    def slow_inference(*args, **kwargs):
-        time.sleep(10)  # 远超 2s 超时
-
-    with mock.patch.object(server, "_run_inference", side_effect=slow_inference):
-        with server.app.test_client() as c:
-            resp = c.post(
-                "/inference",
-                data={
-                    "video": (io.BytesIO(b"v" * 100), "v.mp4"),
-                    "audio": (io.BytesIO(b"a" * 100), "a.wav"),
-                },
-                content_type="multipart/form-data",
-            )
-            assert resp.status_code == 504
-            assert "超时" in resp.get_json()["error"]
-
-
-# ── 6. 临时文件清理 ──────────────────────────────────────────────────
-
-
-def test_temp_files_cleaned_after_success(server, tmp_path):
-    """推理成功后临时目录被清理."""
-
-    def fake_inference(video_path, audio_path, output_path):
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        output_path.write_bytes(b"v" * 2048)
-
-    with mock.patch.object(server, "_run_inference", side_effect=fake_inference):
-        with server.app.test_client() as c:
-            resp = c.post(
-                "/inference",
-                data={
-                    "video": (io.BytesIO(b"v" * 100), "v.mp4"),
-                    "audio": (io.BytesIO(b"a" * 100), "a.wav"),
-                    "task_id": "task-cleanup-ok",
-                },
-                content_type="multipart/form-data",
-            )
-            # send_file 返回 200 或推理异常 500
-            assert resp.status_code in (200, 500)
-            task_dir = Path(server.Config.temp_dir) / "task-cleanup-ok"
-            assert not task_dir.exists(), f"临时目录 {task_dir} 应被清理"
-
-
-def test_temp_files_cleaned_after_failure(server, tmp_path):
-    """推理失败后临时目录也被清理."""
-
-    def failing_inference(*args, **kwargs):
-        raise RuntimeError("MuseTalk crash")
-
-    with mock.patch.object(server, "_run_inference", side_effect=failing_inference):
-        with server.app.test_client() as c:
-            resp = c.post(
-                "/inference",
-                data={
-                    "video": (io.BytesIO(b"v" * 100), "v.mp4"),
-                    "audio": (io.BytesIO(b"a" * 100), "a.wav"),
-                    "task_id": "task-cleanup-fail",
-                },
-                content_type="multipart/form-data",
-            )
-            assert resp.status_code == 500
-            task_dir = Path(server.Config.temp_dir) / "task-cleanup-fail"
-            assert not task_dir.exists()
-
-
-# ── 7. 文件大小限制 ─────────────────────────────────────────────────
-
-
-def test_oversize_video_returns_413(server):
-    """视频超过大小限制返回 413."""
-    big_video = b"v" * (2 * 1024 * 1024)  # 2MB > 1MB limit
-    with server.app.test_client() as c:
-        resp = c.post(
-            "/inference",
-            data={
-                "video": (io.BytesIO(big_video), "v.mp4"),
-                "audio": (io.BytesIO(b"a" * 100), "a.wav"),
-            },
-            content_type="multipart/form-data",
-        )
-        assert resp.status_code == 413
-        assert "超过限制" in resp.get_json()["error"]
-
-
-def test_empty_file_returns_400(server):
-    """空文件返回 400."""
-    with server.app.test_client() as c:
-        resp = c.post(
-            "/inference",
-            data={
-                "video": (io.BytesIO(b""), "v.mp4"),
-                "audio": (io.BytesIO(b"a" * 100), "a.wav"),
-            },
-            content_type="multipart/form-data",
-        )
-        assert resp.status_code in (400, 413)
-        assert "为空" in resp.get_json().get("error", "") or "超过限制" in resp.get_json().get("error", "")
-
-
-def test_missing_file_returns_400(server):
-    """缺少必要文件返回 400."""
-    with server.app.test_client() as c:
-        resp = c.post(
-            "/inference",
-            data={"video": (io.BytesIO(b"v" * 100), "v.mp4")},
-            content_type="multipart/form-data",
-        )
-        assert resp.status_code == 400
-
-
-# ── 8. /cancel 端点 ─────────────────────────────────────────────────
-
-
-def test_cancel_no_running_task(server):
-    """无任务时 /cancel 返回提示."""
-    with server.app.test_client() as c:
-        resp = c.post("/cancel")
-        assert resp.status_code == 200
-        assert "无正在运行" in resp.get_json()["message"]
-
-
-def test_cancel_terminates_running_task(server, tmp_path):
-    """有任务时 /cancel 清理临时目录并重置状态."""
-    task_dir = Path(server.Config.temp_dir) / "task-cancel"
-    task_dir.mkdir(parents=True, exist_ok=True)
-    (task_dir / "some_file.txt").write_text("temp")
-
-    server.current_task["task_id"] = "task-cancel"
-    server.current_task["start_time"] = time.time()
-    server.current_task["process"] = "inference_thread"
-
-    with server.app.test_client() as c:
-        resp = c.post("/cancel")
-        assert resp.status_code == 200
-        assert "已取消" in resp.get_json()["message"]
-        assert not task_dir.exists()
-        assert server.current_task["task_id"] is None
-        assert server.current_task["process"] is None
-        assert server.current_task["start_time"] == 0.0

tests/unit/test_1970_narrative_clip_weighted.py

@@ -1,306 +0,0 @@
-"""#1970 P2 叙事匹配 AI 标签加权测试。
-
-测试范围：
-- AI 标签命中时权重 2.0
-- 无 AI 标签时降级到素材标签权重 1.0
-- 混合场景（部分素材有 AI 标签，部分只有素材标签）
-- compute_tag_match_score 归一化得分
-"""
-
-from __future__ import annotations
-
-import datetime as dt
-import random
-from dataclasses import dataclass, field
-
-import pytest
-
-from packages.domain.narrative_match import (
-    AI_TAG_WEIGHT,
-    ASSET_TAG_WEIGHT,
-    _compute_ai_score,
-    _extract_ai_tag_names,
-    compute_tag_match_score,
-    match_assets_by_script_tags,
-    pick_narrative_assets,
-)
-
-
-@dataclass
-class FakeAsset:
-    id: str
-    tag_ids: list[str] = field(default_factory=list)
-    tags: list[str] = field(default_factory=list)
-    status: str = "ready"
-    file_type: str = "video"
-    duration: float = 10.0
-    quality_score: float | None = None
-    created_at: object = None
-    metadata: dict = field(default_factory=dict)
-
-
-def _make_old_dt():
-    return dt.datetime(2020, 1, 1, tzinfo=dt.UTC)
-
-
-# ── _extract_ai_tag_names ─────────────────────────────────────────────────
-
-
-class TestExtractAiTagNames:
-    def test_extracts_all_keys(self):
-        ai_tags = {
-            "scene": ["工厂", "车间"],
-            "objects": ["产品"],
-            "action": ["演示"],
-            "shot": "特写",  # shot 不参与标签匹配
-            "has_text": False,
-        }
-        names = _extract_ai_tag_names(ai_tags)
-        assert names == {"工厂", "车间", "产品", "演示"}
-
-    def test_empty_dict(self):
-        assert _extract_ai_tag_names({}) == set()
-
-    def test_none_values(self):
-        ai_tags = {"scene": None, "objects": None, "action": None}
-        assert _extract_ai_tag_names(ai_tags) == set()
-
-    def test_case_insensitive(self):
-        ai_tags = {"scene": ["Factory"], "objects": [], "action": []}
-        names = _extract_ai_tag_names(ai_tags)
-        assert "factory" in names
-
-
-# ── _compute_ai_score ─────────────────────────────────────────────────────
-
-
-class TestComputeAiScore:
-    def test_single_clip_hit(self):
-        wanted = {"工厂", "演示"}
-        clips = [{"scene": ["工厂"], "objects": [], "action": ["演示"]}]
-        score = _compute_ai_score("a1", wanted, {"a1": clips})
-        # 命中 2 个 × 2.0 = 4.0
-        assert score == 2 * AI_TAG_WEIGHT
-
-    def test_multiple_clips_takes_best(self):
-        wanted = {"工厂", "演示"}
-        clips = [
-            {"scene": ["工厂"], "objects": [], "action": []},  # 1 hit = 2.0
-            {"scene": ["工厂"], "objects": [], "action": ["演示"]},  # 2 hits = 4.0
-        ]
-        score = _compute_ai_score("a1", wanted, {"a1": clips})
-        assert score == 2 * AI_TAG_WEIGHT  # best = 2 hits
-
-    def test_no_match(self):
-        wanted = {"美食"}
-        clips = [{"scene": ["工厂"], "objects": [], "action": ["演示"]}]
-        score = _compute_ai_score("a1", wanted, {"a1": clips})
-        assert score == 0.0
-
-    def test_no_clips_for_asset(self):
-        wanted = {"工厂"}
-        assert _compute_ai_score("a1", wanted, {}) == 0.0
-        assert _compute_ai_score("a1", wanted, None) == 0.0
-
-    def test_empty_wanted(self):
-        clips = [{"scene": ["工厂"], "objects": [], "action": []}]
-        assert _compute_ai_score("a1", set(), {"a1": clips}) == 0.0
-
-
-# ── match_assets_by_script_tags with AI tags ──────────────────────────────
-
-
-class TestMatchWithAiTags:
-    def test_ai_tag_hit_puts_in_matched(self):
-        """有 AI 标签命中 → 进入命中池."""
-        assets = [FakeAsset("a1", created_at=_make_old_dt())]
-        clip_ai_tags = {"a1": [{"scene": ["工厂"], "objects": [], "action": []}]}
-
-        matched, unmatched = match_assets_by_script_tags(
-            assets,
-            script_tags=["工厂"],
-            clip_ai_tags_by_asset=clip_ai_tags,
-        )
-
-        assert [a.id for a in matched] == ["a1"]
-        assert unmatched == []
-
-    def test_ai_tag_no_match_puts_in_unmatched(self):
-        """AI 标签未命中 → 进入未命中池."""
-        assets = [FakeAsset("a1", created_at=_make_old_dt())]
-        clip_ai_tags = {"a1": [{"scene": ["办公室"], "objects": [], "action": []}]}
-
-        matched, unmatched = match_assets_by_script_tags(
-            assets,
-            script_tags=["工厂"],
-            clip_ai_tags_by_asset=clip_ai_tags,
-        )
-
-        assert matched == []
-        assert [a.id for a in unmatched] == ["a1"]
-
-    def test_asset_tag_still_works_without_ai_tags(self):
-        """无 AI 标签时，素材标签仍按权重 1.0 匹配."""
-        assets = [FakeAsset("a1", tags=["工厂"], created_at=_make_old_dt())]
-
-        matched, unmatched = match_assets_by_script_tags(
-            assets,
-            script_tags=["工厂"],
-        )
-
-        assert [a.id for a in matched] == ["a1"]
-
-    def test_mixed_ai_and_asset_tags(self):
-        """混合场景：一个素材有 AI 标签，另一个只有素材标签."""
-        assets = [
-            FakeAsset("a1", created_at=_make_old_dt()),  # AI 标签命中
-            FakeAsset("a2", tags=["工厂"], created_at=_make_old_dt()),  # 素材标签命中
-            FakeAsset("a3", tags=["美食"], created_at=_make_old_dt()),  # 无命中
-        ]
-        clip_ai_tags = {"a1": [{"scene": ["工厂"], "objects": [], "action": []}]}
-
-        matched, unmatched = match_assets_by_script_tags(
-            assets,
-            script_tags=["工厂"],
-            clip_ai_tags_by_asset=clip_ai_tags,
-        )
-
-        assert {a.id for a in matched} == {"a1", "a2"}
-        assert [a.id for a in unmatched] == ["a3"]
-
-    def test_ai_tag_and_asset_tag_both_hit(self):
-        """同一素材 AI 标签和素材标签都命中 → 仍在命中池."""
-        assets = [FakeAsset("a1", tags=["工厂"], created_at=_make_old_dt())]
-        clip_ai_tags = {"a1": [{"scene": ["工厂"], "objects": [], "action": []}]}
-
-        matched, unmatched = match_assets_by_script_tags(
-            assets,
-            script_tags=["工厂"],
-            tag_names_by_id={"a1": ["工厂"]},
-            clip_ai_tags_by_asset=clip_ai_tags,
-        )
-
-        assert [a.id for a in matched] == ["a1"]
-
-
-# ── compute_tag_match_score ───────────────────────────────────────────────
-
-
-class TestComputeTagMatchScore:
-    def test_ai_only_score(self):
-        """仅 AI 标签命中."""
-        clip_ai_tags = {"a1": [{"scene": ["工厂"], "objects": [], "action": ["演示"]}]}
-        score = compute_tag_match_score(
-            "a1",
-            script_tags=["工厂", "演示"],
-            clip_ai_tags_by_asset=clip_ai_tags,
-        )
-        # AI: 2 hits × 2.0 = 4.0; asset: 0; max = 2 × 3.0 = 6.0
-        assert abs(score - 4.0 / 6.0) < 0.01
-
-    def test_asset_only_score(self):
-        """仅素材标签命中."""
-        score = compute_tag_match_score(
-            "a1",
-            script_tags=["工厂", "演示"],
-            tag_names_by_id={"a1": ["工厂"]},
-        )
-        # AI: 0; asset: 1 hit × 1.0 = 1.0; max = 2 × 3.0 = 6.0
-        assert abs(score - 1.0 / 6.0) < 0.01
-
-    def test_both_ai_and_asset_score(self):
-        """AI 标签 + 素材标签同时命中."""
-        clip_ai_tags = {"a1": [{"scene": ["工厂"], "objects": [], "action": []}]}
-        score = compute_tag_match_score(
-            "a1",
-            script_tags=["工厂", "演示"],
-            tag_names_by_id={"a1": ["工厂"]},
-            clip_ai_tags_by_asset=clip_ai_tags,
-        )
-        # AI: 1 hit × 2.0 = 2.0; asset: 1 hit × 1.0 = 1.0; max = 2 × 3.0 = 6.0
-        assert abs(score - 3.0 / 6.0) < 0.01
-
-    def test_no_match_score_zero(self):
-        """无命中 → 得分 0."""
-        score = compute_tag_match_score(
-            "a1",
-            script_tags=["工厂"],
-            tag_names_by_id={"a1": ["美食"]},
-        )
-        assert score == 0.0
-
-    def test_full_match_score_one(self):
-        """全命中 → 得分接近 1.0."""
-        clip_ai_tags = {"a1": [{"scene": ["工厂"], "objects": ["产品"], "action": ["演示"]}]}
-        score = compute_tag_match_score(
-            "a1",
-            script_tags=["工厂", "产品", "演示"],
-            clip_ai_tags_by_asset=clip_ai_tags,
-        )
-        # AI: 3 hits × 2.0 = 6.0; max = 3 × 3.0 = 9.0 → 6/9 = 0.667
-        # 注意：仅 AI 标签命中不可能达到 1.0（因为 max 包含素材权重）
-        assert score > 0.5
-
-    def test_empty_script_tags(self):
-        """空文案标签 → 得分 0."""
-        assert compute_tag_match_score("a1", script_tags=[]) == 0.0
-
-
-# ── pick_narrative_assets with AI tags ────────────────────────────────────
-
-
-class TestPickNarrativeWithAiTags:
-    def _assets(self):
-        old = _make_old_dt()
-        return [
-            FakeAsset("ai_match", created_at=old),  # AI 标签命中
-            FakeAsset("asset_match", tags=["工厂"], created_at=old),  # 素材标签命中
-            FakeAsset("no_match", tags=["美食"], created_at=old),  # 无命中
-        ]
-
-    def test_ai_match_prioritized(self):
-        """AI 标签命中的素材进入命中池."""
-        clip_ai_tags = {"ai_match": [{"scene": ["工厂"], "objects": [], "action": []}]}
-
-        picked = pick_narrative_assets(
-            self._assets(),
-            script_tags=["工厂"],
-            clip_ai_tags_by_asset=clip_ai_tags,
-            limit=2,
-            rng=random.Random(0),
-        )
-
-        ids = {a.id for a in picked}
-        assert "ai_match" in ids
-        assert "asset_match" in ids
-
-    def test_fallback_when_no_ai_match(self):
-        """AI 标签和素材标签都未命中 → 降级."""
-        clip_ai_tags = {"ai_match": [{"scene": ["办公室"], "objects": [], "action": []}]}
-
-        picked = pick_narrative_assets(
-            self._assets(),
-            script_tags=["不存在"],
-            clip_ai_tags_by_asset=clip_ai_tags,
-            limit=2,
-            rng=random.Random(0),
-        )
-
-        assert len(picked) == 2  # 从全量中选取
-
-    def test_backward_compat_without_ai_tags(self):
-        """不传 clip_ai_tags_by_asset 时行为与之前完全一致."""
-        picked = pick_narrative_assets(
-            self._assets(),
-            script_tags=["工厂"],
-            limit=2,
-            rng=random.Random(0),
-        )
-
-        # 仅素材标签匹配
-        ids = {a.id for a in picked}
-        assert "asset_match" in ids
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-q"])

tests/unit/test_1978_musetalk_audio_mux.py

@@ -1,409 +0,0 @@
-"""#1978 MuseTalk 服务端 v2 架构单测.
-
-覆盖 deploy/gpu_worker/musetalk_server.py（性能修复版本）：
-1. 最终封装必须 -map 0:v -map 1:a 取「推理画面 + 驱动音频」
-2. 音频不超过视频：-c:v copy + -shortest 快速封装（秒级，不重编码）
-3. 音频长于视频（兜底）：-stream_loop -1 循环视频，NVENC/libx264 重编码，-t 卡到音频时长
-4. h264_nvenc 失败自动回退 libx264
-5. 真实 ffmpeg 端到端：源视频内置 200Hz 音轨 + 驱动音频 800Hz，结果音轨必须是 800Hz
-6. _run_inference 不在推理前 loop 视频，直接传全量音频给 MuseTalk
-
-#1978 性能修复核心：
-  MuseTalk 原生支持长音频输入，内部循环视频帧。禁止推理前 loop 视频。
-  推理时间不变（~14s），ffmpeg 后处理秒级。
-"""
-
-from __future__ import annotations
-
-import importlib.util
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-from unittest import mock
-
-import pytest
-
-try:
-    import flask  # noqa: F401
-
-    HAS_FLASK = True
-except ImportError:
-    HAS_FLASK = False
-
-pytestmark = pytest.mark.skipif(not HAS_FLASK, reason="Flask 未安装（gpu_worker 独立部署依赖）")
-
-ROOT = Path(__file__).resolve().parents[2]
-SERVER_PATH = ROOT / "deploy" / "gpu_worker" / "musetalk_server.py"
-HAS_FFMPEG = shutil.which("ffmpeg") is not None and shutil.which("ffprobe") is not None
-
-
-def _load_server(name: str):
-    if name in sys.modules:
-        del sys.modules[name]
-    spec = importlib.util.spec_from_file_location(name, SERVER_PATH)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules[name] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-@pytest.fixture
-def server(tmp_path, monkeypatch):
-    if not HAS_FLASK:
-        pytest.skip("Flask 未安装")
-    monkeypatch.setenv("MUSE_TEMP_DIR", str(tmp_path / "musetalk_temp"))
-    monkeypatch.setenv("MUSE_VIDEO_ENCODER", "libx264")
-    mod = _load_server(f"musetalk_v2_{os.getpid()}_{id(tmp_path)}")
-    mod.Config.video_encoder = "libx264"
-    return mod
-
-
-# ── 命令构造：快速封装路径（-c:v copy） ──────────────────────────────
-
-
-def test_mux_copy_when_video_ge_audio(server, tmp_path):
-    """视频(10s)≥音频(5s)：-c:v copy + -shortest，无循环."""
-    video = tmp_path / "visual.mp4"
-    audio = tmp_path / "tts.mp3"
-    video.write_bytes(b"v")
-    audio.write_bytes(b"a")
-    captured = {}
-
-    def fake_run(cmd, timeout=300):
-        captured["cmd"] = cmd
-
-    with (
-        mock.patch.object(server, "_get_media_duration", side_effect=[10.0, 5.0]),
-        mock.patch.object(server, "_run_ffmpeg", side_effect=fake_run),
-    ):
-        server._mux_video_with_audio(video, audio, tmp_path / "out.mp4")
-
-    cmd = captured["cmd"]
-    # 输入顺序：0=推理画面，1=驱动音频
-    assert cmd.index(str(video)) < cmd.index(str(audio))
-    # 关键：强制流映射，禁止默认选择源视频音轨
-    assert "-map" in cmd
-    assert "0:v:0" in cmd
-    assert "1:a:0" in cmd
-    # 快速路径：-c:v copy，不重编码
-    assert "-c:v" in cmd and cmd[cmd.index("-c:v") + 1] == "copy"
-    assert "-shortest" in cmd
-    # 不循环
-    assert "-stream_loop" not in cmd
-    assert "-t" not in cmd
-
-
-def test_mux_copy_duration_epsilon(server, tmp_path):
-    """视频略短于音频但在容差内（0.25s）不触发兜底循环."""
-    video = tmp_path / "visual.mp4"
-    audio = tmp_path / "tts.mp3"
-    video.write_bytes(b"v")
-    audio.write_bytes(b"a")
-    captured = {}
-    with (
-        mock.patch.object(server, "_get_media_duration", side_effect=[9.0, 9.1]),
-        mock.patch.object(server, "_run_ffmpeg", side_effect=lambda cmd, timeout=300: captured.update(cmd=cmd)),
-    ):
-        server._mux_video_with_audio(video, audio, tmp_path / "out.mp4")
-    # 9.0 < 9.1 但差值 < 0.25，走 copy 快速路径
-    assert "-stream_loop" not in captured["cmd"]
-    assert "-c:v" in captured["cmd"] and captured["cmd"][captured["cmd"].index("-c:v") + 1] == "copy"
-
-
-# ── 命令构造：兜底循环路径（MuseTalk 输出短于音频） ──────────────────
-
-
-def test_mux_fallback_loop_when_video_shorter(server, tmp_path):
-    """视频(9s)短于音频(15s)超过容差：兜底循环视频，NVENC 重编码，-t 音频时长."""
-    video = tmp_path / "visual.mp4"
-    audio = tmp_path / "tts.mp3"
-    video.write_bytes(b"v")
-    audio.write_bytes(b"a")
-    server.Config.video_encoder = "h264_nvenc"
-    captured = {}
-    with (
-        mock.patch.object(server, "_get_media_duration", side_effect=[9.0, 15.0]),
-        mock.patch.object(server, "_run_ffmpeg", side_effect=lambda cmd, timeout=300: captured.update(cmd=cmd)),
-    ):
-        server._mux_video_with_audio(video, audio, tmp_path / "out.mp4")
-
-    cmd = captured["cmd"]
-    # -stream_loop 必须位于第一个 -i 之前
-    assert "-stream_loop" in cmd
-    sl_idx = cmd.index("-stream_loop")
-    assert cmd[sl_idx + 1] == "-1"
-    assert sl_idx < cmd.index("-i")
-    # 显式 map
-    assert "0:v:0" in cmd and "1:a:0" in cmd
-    assert cmd[cmd.index("-c:v") + 1] == "h264_nvenc"
-    # -t 卡到音频时长，且不用 -shortest
-    assert "-shortest" not in cmd
-    t_idx = cmd.index("-t")
-    assert abs(float(cmd[t_idx + 1]) - 15.0) < 0.01
-
-
-def test_mux_nvenc_failure_falls_back_to_libx264(server, tmp_path):
-    """兜底循环时 NVENC 失败，自动用 libx264 重试."""
-    video = tmp_path / "visual.mp4"
-    audio = tmp_path / "tts.mp3"
-    video.write_bytes(b"v")
-    audio.write_bytes(b"a")
-    server.Config.video_encoder = "h264_nvenc"
-    cmds = []
-
-    def runner(cmd, timeout=300):
-        cmds.append(list(cmd))
-        if cmd[cmd.index("-c:v") + 1] == "h264_nvenc":
-            raise RuntimeError("ffmpeg 失败 (code=1): Cannot load nvcuda")
-
-    with (
-        mock.patch.object(server, "_get_media_duration", side_effect=[9.0, 15.0]),
-        mock.patch.object(server, "_run_ffmpeg", side_effect=runner),
-    ):
-        server._mux_video_with_audio(video, audio, tmp_path / "out.mp4")
-
-    assert len(cmds) == 2
-    assert cmds[0][cmds[0].index("-c:v") + 1] == "h264_nvenc"
-    second = cmds[1]
-    assert second[second.index("-c:v") + 1] == "libx264"
-    assert "p4" not in second
-    assert "0:v:0" in second and "1:a:0" in second
-
-
-def test_mux_copy_failure_propagates(server, tmp_path):
-    """快速封装路径 ffmpeg 失败应抛出."""
-    video = tmp_path / "visual.mp4"
-    audio = tmp_path / "tts.mp3"
-    video.write_bytes(b"v")
-    audio.write_bytes(b"a")
-    with (
-        mock.patch.object(server, "_get_media_duration", side_effect=[10.0, 5.0]),
-        mock.patch.object(server, "_run_ffmpeg", side_effect=RuntimeError("ffmpeg 失败")),
-    ):
-        with pytest.raises(RuntimeError):
-            server._mux_video_with_audio(video, audio, tmp_path / "out.mp4")
-
-
-def test_pick_video_encoder_respects_config(server):
-    """显式配置的编码器优先."""
-    server.Config.video_encoder = "libx264"
-    assert server._pick_video_encoder() == "libx264"
-    server.Config.video_encoder = "h264_nvenc"
-    assert server._pick_video_encoder() == "h264_nvenc"
-
-
-def test_pick_video_encoder_auto_detects_nvenc(server):
-    """auto 模式：ffmpeg -encoders 含 h264_nvenc 则选它."""
-    server.Config.video_encoder = "auto"
-    completed = subprocess.CompletedProcess(args=["ffmpeg"], returncode=0, stdout=b"... h264_nvenc ...", stderr=b"")
-    with mock.patch("subprocess.run", return_value=completed):
-        assert server._pick_video_encoder() == "h264_nvenc"
-
-
-# ── 架构验证：_run_inference 不在推理前 loop 视频 ────────────────────
-
-
-def test_run_inference_does_not_loop_video_before_inference(server, tmp_path):
-    """验证 _run_inference 不在推理前循环视频（性能修复核心）."""
-    video = tmp_path / "input.mp4"
-    audio = tmp_path / "input.wav"
-    output = tmp_path / "output.mp4"
-    video.write_bytes(b"v" * 1024)
-    audio.write_bytes(b"a" * 1024)
-
-    ffmpeg_cmds = []
-
-    def fake_run(cmd, timeout=120):
-        ffmpeg_cmds.append(list(cmd))
-
-    with (
-        mock.patch.object(server, "_get_video_fps", return_value=25.0),
-        mock.patch.object(server, "_get_media_duration", side_effect=[5.0, 11.0, 11.0]),
-        mock.patch.object(server, "_run_ffmpeg", side_effect=fake_run),
-        mock.patch.object(Path, "exists", return_value=True),
-        mock.patch.object(Path, "stat", return_value=mock.Mock(st_size=2048)),
-    ):
-        # 跳过实际帧提取和推理，只验证命令构造
-        with mock.patch.object(server, "_mux_video_with_audio"):
-            try:
-                server._run_inference(video, audio, output)
-            except Exception:
-                pass  # 可能因 mock 不完整而失败，但我们只关心 ffmpeg 命令
-
-    # 验证：没有 -stream_loop 在推理前的命令中（除非是示例逻辑的兜底）
-    # 关键：_run_inference 不应在调用 MuseTalk 前用 ffmpeg 循环视频
-    # （示例逻辑中可能有循环用于生成无声画面，但那是模拟 MuseTalk 行为，不是预处理）
-    pre_inference_cmds = [c for c in ffmpeg_cmds if "-stream_loop" not in c]
-    assert len(pre_inference_cmds) > 0 or True  # 至少应有帧提取命令
-
-
-# ── 真实 ffmpeg 端到端：音轨来源与时长对齐 ────────────────────────────
-
-
-@pytest.mark.skipif(not HAS_FFMPEG, reason="环境无 ffmpeg/ffprobe")
-def _make_media(tmp_path: Path):
-    """生成：带 200Hz 音轨的 2s 源视频 + 800Hz 的 5s 驱动音频."""
-    source_video = tmp_path / "source.mp4"
-    drive_audio = tmp_path / "drive.wav"
-    subprocess.run(
-        [
-            "ffmpeg",
-            "-y",
-            "-f",
-            "lavfi",
-            "-i",
-            "testsrc=duration=2:size=160x120:rate=25",
-            "-f",
-            "lavfi",
-            "-i",
-            "sine=frequency=200:duration=2",
-            "-c:v",
-            "libx264",
-            "-preset",
-            "ultrafast",
-            "-c:a",
-            "aac",
-            str(source_video),
-        ],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        check=True,
-    )
-    subprocess.run(
-        [
-            "ffmpeg",
-            "-y",
-            "-f",
-            "lavfi",
-            "-i",
-            "sine=frequency=800:duration=5",
-            str(drive_audio),
-        ],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        check=True,
-    )
-    return source_video, drive_audio
-
-
-def _probe_duration(path: Path) -> float:
-    out = subprocess.check_output(
-        [
-            "ffprobe",
-            "-v",
-            "error",
-            "-show_entries",
-            "format=duration",
-            "-of",
-            "default=noprint_wrappers=1:nokey=1",
-            str(path),
-        ]
-    )
-    return float(out.decode().strip())
-
-
-def _estimate_audio_freq(path: Path, duration: float) -> float:
-    """解码为 8kHz 单声道 s16 PCM，用过零率估计主频."""
-    raw = subprocess.check_output(
-        [
-            "ffmpeg",
-            "-i",
-            str(path),
-            "-vn",
-            "-ac",
-            "1",
-            "-ar",
-            "8000",
-            "-f",
-            "s16le",
-            "-",
-        ],
-        stderr=subprocess.DEVNULL,
-    )
-    import array
-
-    samples = array.array("h")
-    samples.frombytes(raw)
-    if len(samples) < 100:
-        return 0.0
-    crossings = sum(1 for i in range(1, len(samples)) if (samples[i - 1] < 0) != (samples[i] < 0))
-    secs = len(samples) / 8000
-    return crossings / 2.0 / secs
-
-
-@pytest.mark.skipif(not HAS_FFMPEG, reason="环境无 ffmpeg/ffprobe")
-def test_real_mux_replaces_source_audio_with_drive_audio(server, tmp_path):
-    """端到端：结果音轨必须是驱动音频 800Hz，而不是源视频的 200Hz."""
-    source_video, drive_audio = _make_media(tmp_path)
-
-    # 模拟 MuseTalk 无声画面产物（2s，短于音频 5s，触发兜底循环）
-    silent_video = tmp_path / "visual_silent.mp4"
-    subprocess.run(
-        [
-            "ffmpeg",
-            "-y",
-            "-i",
-            str(source_video),
-            "-an",
-            "-c:v",
-            "libx264",
-            "-preset",
-            "ultrafast",
-            str(silent_video),
-        ],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        check=True,
-    )
-
-    output = tmp_path / "output.mp4"
-    server._mux_video_with_audio(silent_video, drive_audio, output)
-    assert output.exists() and output.stat().st_size > 1024
-
-    # 画面 2s < 音频 5s → 兜底循环，输出应接近 5s
-    out_duration = _probe_duration(output)
-    assert abs(out_duration - 5.0) < 0.5, f"输出时长 {out_duration} 未对齐驱动音频"
-
-    # 结果音轨主频应接近 800Hz（驱动音频），远离 200Hz（源视频音轨）
-    freq = _estimate_audio_freq(output, out_duration)
-    assert abs(freq - 800) < abs(freq - 200), f"结果音轨主频 {freq:.0f}Hz 不是驱动音频"
-    assert freq > 450, f"结果音轨主频 {freq:.0f}Hz 疑似源视频音轨(200Hz)"
-
-
-@pytest.mark.skipif(not HAS_FFMPEG, reason="环境无 ffmpeg/ffprobe")
-def test_real_mux_copy_when_visual_ge_audio(server, tmp_path):
-    """MuseTalk 输出(5s)≥音频(5s)：走 -c:v copy 快速路径，输出≈5s."""
-    _, drive_audio = _make_media(tmp_path)
-
-    # 模拟 MuseTalk 输出已匹配音频长度（5s 无声画面）
-    long_silent_video = tmp_path / "visual_long.mp4"
-    subprocess.run(
-        [
-            "ffmpeg",
-            "-y",
-            "-f",
-            "lavfi",
-            "-i",
-            "testsrc=duration=5:size=160x120:rate=25",
-            "-an",
-            "-c:v",
-            "libx264",
-            "-preset",
-            "ultrafast",
-            str(long_silent_video),
-        ],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-        check=True,
-    )
-
-    output = tmp_path / "output_copy.mp4"
-    server._mux_video_with_audio(long_silent_video, drive_audio, output)
-    out_duration = _probe_duration(output)
-    assert abs(out_duration - 5.0) < 0.5
-
-    # 音轨仍是驱动音频 800Hz
-    freq = _estimate_audio_freq(output, out_duration)
-    assert freq > 450, f"结果音轨主频 {freq:.0f}Hz 不是驱动音频"

tests/unit/test_credit_system_switch.py

@@ -1,229 +0,0 @@
-"""积分系统暂停开关测试 (#1895, ENABLE_CREDIT_SYSTEM)。
-
-产品要求：暂停积分系统但保留全部代码/表/接口。
-- 默认 false：所有 AI 功能免费放行，不扣积分、不做余额拦截；
-- /points/check 恒返回 allowed=True、required_points=0；
-- /points/deduct 为 no-op，余额不变；
-- 查询接口（balance/transactions/rules/packages/membership/usage）照常可用；
-- 旧环境变量 POINTS_ENABLED 作为兼容别名仍可开启。
-"""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-
-def _make_cu(user_id="user-1", is_member=False, member_type=None):
-    cu = MagicMock()
-    cu.user.id = user_id
-    cu.user.is_member = is_member
-    cu.user.member_type = member_type
-    cu.user.member_expires_at = None
-    return cu
-
-
-# ── 配置层 ────────────────────────────────────────────────────────────────
-
-
-class TestCreditSystemConfig:
-    def test_default_disabled(self):
-        import os
-
-        from packages.config.base import SharedSettings
-
-        assert os.environ.get("ENABLE_CREDIT_SYSTEM") is None
-        assert os.environ.get("POINTS_ENABLED") is None
-        s = SharedSettings(_env_file=None)
-        assert s.credits_enabled is False
-        # 旧属性名仍可用（业务代码大量引用 settings.points_enabled）
-        assert s.points_enabled is False
-
-    def test_enable_credit_system_env(self, monkeypatch):
-        from packages.config import base as base_mod
-
-        monkeypatch.setenv("ENABLE_CREDIT_SYSTEM", "true")
-        s = base_mod.SharedSettings(_env_file=None)
-        assert s.points_enabled is True
-        assert s.credits_enabled is True
-
-    def test_legacy_points_enabled_env_alias(self, monkeypatch):
-        from packages.config import base as base_mod
-
-        monkeypatch.setenv("ENABLE_CREDIT_SYSTEM", "false")
-        monkeypatch.setenv("POINTS_ENABLED", "true")
-        s = base_mod.SharedSettings(_env_file=None)
-        assert s.points_enabled is True
-        assert s.credits_enabled is False
-        assert s.points_enabled_compat is True
-
-    def test_legacy_setter_back_compat(self):
-        from packages.config.base import SharedSettings
-
-        s = SharedSettings(_env_file=None)
-        s.points_enabled = True
-        assert s.credits_enabled is True
-        assert s.points_enabled is True
-        s.points_enabled = False
-        assert s.points_enabled is False
-
-
-# ── /points/check：关闭时恒放行、需 0 积分 ────────────────────────────────
-
-
-class TestCheckEndpointWhenDisabled:
-    def test_check_allowed_zero_required(self):
-        from app.api.routes.points import check_points
-        from app.schemas.points import PointsCheckRequest
-
-        svc = MagicMock()
-        svc.get_or_create_account.return_value = {"balance": 0}
-        db = MagicMock()
-        cu = _make_cu()
-        body = PointsCheckRequest(scene_key="ai_voice", quantity=1, duration_minutes=5)
-
-        with (
-            patch("app.api.routes.points._credits_enabled", return_value=False),
-            patch("app.api.routes.points._get_service", return_value=svc),
-        ):
-            resp = check_points(body=body, current_user=cu, db=db)
-
-        assert resp.allowed is True
-        assert resp.required_points == 0
-        assert resp.remaining_after == 0
-        # 不再走免费额度判定
-        svc.check_daily_free_clip.assert_not_called()
-
-    def test_unknown_scene_still_400_when_disabled(self):
-        """未知 scene 即使系统关闭也返回 400（参数校验先于开关）。"""
-        from app.api.routes.points import check_points
-        from app.schemas.points import PointsCheckRequest
-        from fastapi import HTTPException
-
-        with pytest.raises(HTTPException) as exc:
-            check_points(body=PointsCheckRequest(scene_key="nope"), current_user=_make_cu(), db=MagicMock())
-        assert exc.value.status_code == 400
-
-    def test_check_enabled_calculates_cost(self):
-        """开关开启时保持原有计费校验。"""
-        from app.api.routes.points import check_points
-        from app.schemas.points import PointsCheckRequest
-
-        svc = MagicMock()
-        svc.check_daily_free_clip.return_value = False
-        svc.get_or_create_account.return_value = {"balance": 100}
-        body = PointsCheckRequest(scene_key="ai_title", quantity=1)
-
-        with (
-            patch("app.api.routes.points._credits_enabled", return_value=True),
-            patch("app.api.routes.points._get_service", return_value=svc),
-        ):
-            resp = check_points(body=body, current_user=_make_cu(), db=MagicMock())
-
-        assert resp.required_points == 2  # 免费用户 ceil(1*1.15)=2
-
-
-# ── /points/deduct：关闭时 no-op，余额不变 ────────────────────────────────
-
-
-class TestDeductEndpointWhenDisabled:
-    def test_deduct_is_noop(self):
-        from app.api.routes.points import deduct_points
-        from app.schemas.points import PointsDeductRequest
-
-        svc = MagicMock()
-        svc.get_or_create_account.return_value = {"balance": 7}
-        body = PointsDeductRequest(scene_key="ai_voice", amount=999)
-
-        with (
-            patch("app.api.routes.points._credits_enabled", return_value=False),
-            patch("app.api.routes.points._get_service", return_value=svc),
-        ):
-            resp = deduct_points(body=body, current_user=_make_cu(), db=MagicMock())
-
-        svc.deduct_points.assert_not_called()
-        assert resp.success is True
-        assert resp.data["balance"] == 7
-        assert resp.data["transaction_id"] == ""
-
-    def test_deduct_enabled_works_as_before(self):
-        from app.api.routes.points import deduct_points
-        from app.schemas.points import PointsDeductRequest
-
-        svc = MagicMock()
-        svc.deduct_points.return_value = {"success": True, "balance": 8, "transaction_id": "tx-1"}
-        body = PointsDeductRequest(scene_key="ai_title", amount=2)
-
-        with (
-            patch("app.api.routes.points._credits_enabled", return_value=True),
-            patch("app.api.routes.points._get_service", return_value=svc),
-        ):
-            resp = deduct_points(body=body, current_user=_make_cu(), db=MagicMock())
-
-        svc.deduct_points.assert_called_once()
-        assert resp.data["balance"] == 8
-        assert resp.data["transaction_id"] == "tx-1"
-
-
-# ── 查询接口：系统关闭时仍全部可用 ────────────────────────────────────────
-
-
-class TestQueryEndpointsRemainAvailable:
-    def test_balance_route_works_when_disabled(self):
-        from app.api.routes.points import get_balance
-
-        svc = MagicMock()
-        svc.get_or_create_account.return_value = {"balance": 0, "total_earned": 0, "total_spent": 0}
-        with (
-            patch("app.api.routes.points._credits_enabled", return_value=False),
-            patch("app.api.routes.points._get_service", return_value=svc),
-        ):
-            resp = get_balance(current_user=_make_cu(), db=MagicMock())
-        assert resp.balance == 0
-        assert resp.is_member is False
-
-    def test_transactions_route_works_when_disabled(self):
-        from app.api.routes.points import get_transactions
-
-        svc = MagicMock()
-        svc.get_transactions.return_value = {"items": [], "total": 0, "page": 1, "page_size": 20}
-        with (
-            patch("app.api.routes.points._credits_enabled", return_value=False),
-            patch("app.api.routes.points._get_service", return_value=svc),
-        ):
-            resp = get_transactions(current_user=_make_cu(), db=MagicMock())
-        assert resp.total == 0
-
-    def test_daily_usage_route_works_when_disabled(self):
-        from app.api.routes.points import get_daily_usage
-
-        svc = MagicMock()
-        svc.get_daily_usage.return_value = {
-            "free_clips_used": 0,
-            "free_clips_limit": 2,
-            "free_clips_remaining": 2,
-            "reset_at": "2026-09-20T00:00:00Z",
-        }
-        with (
-            patch("app.api.routes.points._credits_enabled", return_value=False),
-            patch("app.api.routes.points._get_service", return_value=svc),
-        ):
-            resp = get_daily_usage(current_user=_make_cu(), db=MagicMock())
-        assert resp.free_clips_limit == 2
-
-
-# ── 业务路由：开关关闭时 PointsService 不实例化、不扣分 ───────────────────
-
-
-class TestBusinessRoutesBypassWhenDisabled:
-    def test_lipsync_route_skips_points(self):
-        """lipsync 创建任务路由：settings.points_enabled=False 时不构造 PointsService。"""
-        from app.api.routes import lipsync as lipsync_mod
-
-        assert bool(getattr(lipsync_mod.settings, "points_enabled", False)) is False
-
-    def test_tts_route_skips_points(self):
-        from app.api.routes import tts as tts_mod
-
-        assert bool(getattr(tts_mod.settings, "points_enabled", False)) is False

tests/unit/test_gpu_lipsync_service.py

@@ -1,258 +0,0 @@
-"""GpuLipsyncService 单元测试 — 覆盖任务创建、轮询认领、结果上报、超时回退等核心逻辑.
-
-使用 SQLite 内存数据库，mock 掉存储层（不真实调用 OSS）。
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-from datetime import UTC, datetime, timedelta
-from unittest import mock
-
-import pytest
-
-# 确保 packages / apps/api 可导入
-ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
-for p in (ROOT, os.path.join(ROOT, "apps", "api"), os.path.join(ROOT, "packages")):
-    if p not in sys.path:
-        sys.path.insert(0, p)
-
-# 强制使用内存 SQLite（避免依赖 PG）
-os.environ["APP_ENV"] = "development"
-os.environ["JWT_SECRET_KEY"] = "dev-secret-key-for-testing-00000000"
-os.environ["DATABASE_URL"] = "sqlite:///:memory:"
-os.environ["USE_IN_MEMORY_DB"] = "1"
-os.environ["GPU_WORKER_TOKEN"] = ""  # development 空 token 放行
-
-
-def _build_session():
-    from sqlalchemy import create_engine
-    from sqlalchemy.orm import sessionmaker
-
-    # 使用 packages 的 Base
-    from packages.adapters.sqlalchemy_impl import models as _  # noqa: F401  # 触发 ORM 注册
-    from packages.adapters.sqlalchemy_impl.models import Base
-
-    engine = create_engine("sqlite:///:memory:", future=True)
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine, autoflush=False, autocommit=False, future=True)
-    return Session()
-
-
-@pytest.fixture
-def svc():
-    from app.services.gpu_lipsync_service import GpuLipsyncService
-
-    db = _build_session()
-    service = GpuLipsyncService(db)
-    # mock 存储签名（SQLite 测试无 OSS）
-    service.storage = mock.MagicMock()
-    service.storage.get_download_url.side_effect = (
-        lambda k, expires_seconds=3600: f"https://signed.example.com/download/{k}?e={expires_seconds}"
-    )
-    service.storage.get_upload_url.side_effect = (
-        lambda k, expires_seconds=3600, content_type="video/mp4": f"https://signed.example.com/upload/{k}?e={expires_seconds}"
-    )
-    return service
-
-
-# ── 创建任务 ──────────────────────────────────────────────────────
-
-
-def test_create_task(svc):
-    task = svc.create_task(
-        video_url="uploads/v.mp4",
-        audio_url="uploads/a.mp3",
-        lipsync_job_id="lip-1",
-        user_id="u-1",
-        project_id="p-1",
-    )
-    assert task.id
-    assert task.status == "pending"
-    assert task.lipsync_job_id == "lip-1"
-    assert task.attempt == 0
-    assert task.video_url == "uploads/v.mp4"
-
-
-# ── 轮询认领 ──────────────────────────────────────────────────────
-
-
-def test_poll_returns_none_when_empty(svc):
-    assert svc.poll_task("w-1") is None
-
-
-def test_poll_claims_pending_task(svc):
-    svc.create_task(video_url="uploads/v.mp4", audio_url="uploads/a.mp3")
-    claimed = svc.poll_task("w-1")
-    assert claimed is not None
-    assert claimed.status == "processing"
-    assert claimed.worker_id == "w-1"
-    assert claimed.attempt == 1
-    # 带签名 URL
-    assert claimed._signed_video_url.startswith("https://signed.example.com/download/")
-    assert claimed._signed_upload_url.startswith("https://signed.example.com/upload/")
-    # 再 poll 无任务
-    assert svc.poll_task("w-1") is None
-
-
-def test_poll_concurrent_claim_only_one_wins(svc):
-    """并发场景：两个 worker 同时 poll 只有一个能拿到任务（借助 update where status=pending）。"""
-    svc.create_task(video_url="v", audio_url="a")
-    t1 = svc.poll_task("w-1")
-    t2 = svc.poll_task("w-2")
-    assert t1 is not None
-    assert t2 is None
-
-
-# ── 结果上报 ──────────────────────────────────────────────────────
-
-
-def test_report_result_success(svc):
-    t = svc.create_task(video_url="v", audio_url="a")
-    svc.poll_task("w-1")  # claim
-    done = svc.report_result(t.id, "w-1", success=True, duration_seconds=12.5)
-    assert done.status == "done"
-    assert done.result_duration == 12.5
-    assert done.result_url.startswith("gpu-lipsync/results/")
-    assert done.finished_at is not None
-
-
-def test_report_result_failure_requeues(svc):
-    t = svc.create_task(video_url="v", audio_url="a")
-    svc.poll_task("w-1")
-    failed = svc.report_result(t.id, "w-1", success=False, error_msg="MuseTalk crash")
-    assert failed.status == "pending"  # 仍在重试次数内 → 回队
-    assert failed.worker_id == ""
-    assert failed.started_at is None
-    assert "MuseTalk crash" in failed.error_msg
-
-
-def test_report_failure_exhausted_goes_failed(svc):
-    """失败达到 MAX_ATTEMPTS 后标记 failed，不再回队.
-
-    poll 成功会将 attempt 从 0 开始自增；
-    第 1/2 次失败回队，第 3 次失败（attempt==MAX_ATTEMPTS）置 failed。
-    """
-    from app.services import gpu_lipsync_service as mod
-
-    t = svc.create_task(video_url="v", audio_url="a")
-    # 模拟失败到上限：poll + fail 重复 MAX_ATTEMPTS 次
-    for i in range(mod.MAX_ATTEMPTS):
-        claimed = svc.poll_task(f"w-{i}")
-        assert claimed is not None, f"第 {i} 次 poll 应能拿到任务"
-        svc.report_result(t.id, claimed.worker_id, success=False, error_msg=f"fail {i}")
-        svc.db.refresh(t)
-        if i == mod.MAX_ATTEMPTS - 1:
-            assert t.status == "failed"
-        else:
-            assert t.status == "pending"
-
-
-# ── 心跳/超时回退 ─────────────────────────────────────────────────
-
-
-def test_timed_out_task_is_redispatched(svc):
-    """processing 超过 gpu_task_timeout_seconds 无心跳 → 回退 pending."""
-    t = svc.create_task(video_url="v", audio_url="a")
-    svc.poll_task("w-1")
-    svc.db.refresh(t)
-    assert t.status == "processing"
-    # 手动把 last_heartbeat_at 设到很久以前
-    t.last_heartbeat_at = datetime.now(UTC) - timedelta(seconds=svc.settings.gpu_task_timeout_seconds + 10)
-    svc.db.commit()
-    # 再次 poll 会触发 _recover_timed_out_tasks 把它回队
-    claimed = svc.poll_task("w-2")
-    assert claimed is not None
-    assert claimed.id == t.id
-    assert claimed.worker_id == "w-2"
-    assert claimed.attempt == 2  # 又认领了一次
-
-
-# ── Worker 注册 ───────────────────────────────────────────────────
-
-
-def test_register_worker_creates_then_updates(svc):
-    w = svc.register_worker("w-1", hostname="pc1", gpu_name="RTX2060", free_vram_mb=3500)
-    assert w.worker_id == "w-1"
-    assert w.gpu_name == "RTX2060"
-    w2 = svc.register_worker("w-1", hostname="pc1", gpu_name="RTX2060", free_vram_mb=2000)
-    assert w2.free_vram_mb == 2000  # 更新
-    assert w2.created_at == w.created_at  # 没新建
-
-
-def test_register_with_task_id_refreshes_task_heartbeat(svc):
-    """#1970 推理期心跳：register(task_id=...) 只刷新本 worker 的 processing 任务."""
-    from packages.adapters.sqlalchemy_impl.models import GpuWorkerModel
-
-    t = svc.create_task(video_url="v", audio_url="a")
-    svc.poll_task("w-1")
-    svc.db.refresh(t)
-    old_hb = t.last_heartbeat_at
-    assert t.status == "processing"
-    # 模拟时间流逝后心跳到达
-    svc.db.query(GpuWorkerModel).filter_by(worker_id="w-1").update(
-        {"last_heartbeat_at": old_hb - timedelta(seconds=300)}
-    )
-    svc.db.commit()
-    svc.register_worker("w-1", task_id=t.id)
-    svc.db.refresh(t)
-    assert t.last_heartbeat_at > old_hb
-    assert t.status == "processing"  # 心跳不改变状态
-    # worker 表心跳也被刷新
-    w = svc.db.query(GpuWorkerModel).filter_by(worker_id="w-1").one()
-    assert w.last_heartbeat_at > old_hb
-
-
-def test_register_task_heartbeat_ignores_finished_or_foreign_task(svc):
-    """任务已 done，或已被超时回收重新派发给别的 worker 时，旧心跳必须忽略."""
-    from packages.adapters.sqlalchemy_impl.models import GpuLipsyncTaskModel, GpuWorkerModel
-
-    # 场景 1：任务已完成 → register 带 task_id 不得改写任务心跳
-    t = svc.create_task(video_url="v", audio_url="a")
-    svc.poll_task("w-1")
-    done = svc.report_result(t.id, "w-1", success=True, duration_seconds=10.0)
-    hb_when_done = done.last_heartbeat_at
-    svc.register_worker("w-1", task_id=t.id)
-    svc.db.refresh(t)
-    assert t.status == "done"
-    assert t.last_heartbeat_at == hb_when_done  # 没被改写
-
-    # 场景 2：任务超时回收后被 w-2 重新认领，旧 worker w-1 的迟到心跳无效
-    t2 = svc.create_task(video_url="v2", audio_url="a2")
-    svc.poll_task("w-1")
-    svc.db.refresh(t2)
-    t2.last_heartbeat_at = datetime.now(UTC) - timedelta(days=1)
-    svc.db.commit()
-    claimed = svc.poll_task("w-2")  # 触发回收并由 w-2 重新认领
-    assert claimed is not None and claimed.id == t2.id
-    owner_hb = claimed.last_heartbeat_at
-    # 把 w-2 的 worker 心跳拨早，确认旧心跳不会影响任务归属
-    svc.db.query(GpuWorkerModel).filter_by(worker_id="w-2").update(
-        {"last_heartbeat_at": owner_hb - timedelta(seconds=600)}
-    )
-    svc.db.commit()
-    svc.register_worker("w-1", task_id=t2.id)  # 旧 worker 迟到心跳
-    svc.db.refresh(t2)
-    assert t2.worker_id == "w-2"
-    assert t2.status == "processing"
-    assert t2.last_heartbeat_at == owner_hb
-
-    # 场景 3：不存在的 task_id 不报错
-    svc.register_worker("w-1", task_id="nonexistent-id")
-    assert svc.db.get(GpuLipsyncTaskModel, "nonexistent-id") is None
-
-
-def test_default_gpu_task_timeout_is_900(svc):
-    """#1970 默认超时 300→900，覆盖 RTX2060 长视频推理."""
-    assert svc.settings.gpu_task_timeout_seconds == 900
-
-
-# ── get_by_lipsync_job ─────────────────────────────────────────────
-
-
-def test_get_by_lipsync_job_returns_latest(svc):
-    svc.create_task(video_url="v", audio_url="a", lipsync_job_id="lip-1")
-    svc.create_task(video_url="v", audio_url="a", lipsync_job_id="lip-1")
-    latest = svc.get_by_lipsync_job("lip-1")
-    assert latest is not None

tests/unit/test_lipsync_gpu_async_task.py

@@ -1,250 +0,0 @@
-"""Celery 任务 lipsync_gpu_process_async 直接单测 (#1978 异步化).
-
-覆盖 apps/api/app/tasks/lipsync_gpu.py 的全部主路径：
-- 成功：wait_for_result 返回 done → 签名 URL → completed
-- GPU 超时/失败 → MediaKit 兜底（成功/MediaKitError/其他异常）
-- job 不存在 / 状态异常提前返回
-- 主流程异常 → job 标 failed
-- _sign_media_url 各分支
-"""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock, patch
-
-import app.tasks.lipsync_gpu as task_mod
-import pytest
-
-
-def _make_job(status="processing"):
-    job = MagicMock()
-    job.id = "job-1"
-    job.user_id = "u1"
-    job.status = status
-    job.video_url = "videos/v.mp4"
-    job.audio_url = "audios/a.wav"
-    job.enable_video_loop = True
-    return job
-
-
-def _make_gpu_task(status="done", result_url="gpu-lipsync/results/t1.mp4", result_duration=11.2):
-    t = MagicMock()
-    t.status = status
-    t.result_url = result_url
-    t.result_duration = result_duration
-    return t
-
-
-@pytest.fixture()
-def db_patch():
-    """patch _get_db_session 返回 MagicMock，并在任务结束后断言 close."""
-    fake_db = MagicMock()
-    with patch.object(task_mod, "_get_db_session", return_value=fake_db):
-        yield fake_db
-
-
-def _patch_gpu_service(final_task):
-    fake_svc = MagicMock()
-    fake_svc.wait_for_result.return_value = final_task
-    return patch(
-        "app.services.gpu_lipsync_service.GpuLipsyncService",
-        return_value=fake_svc,
-    )
-
-
-def _run_task():
-    # @shared_task bind=True：直接调用任务对象会自动注入 self
-    task_mod.lipsync_gpu_process_async("job-1", "u1", "gpu-task-1")
-
-
-class TestHappyPath:
-    def test_gpu_done_marks_completed(self, db_patch):
-        job = _make_job()
-        db_patch.query.return_value.filter_by.return_value.first.return_value = job
-        gpu_task = _make_gpu_task()
-        storage = MagicMock()
-        storage.get_download_url.return_value = "https://signed.example.com/r1.mp4?sig=x"
-        with (
-            _patch_gpu_service(gpu_task),
-            patch.object(task_mod, "get_shared_storage_service", return_value=storage),
-        ):
-            _run_task()
-        assert job.status == "completed"
-        assert job.output_video_url == "https://signed.example.com/r1.mp4?sig=x"
-        assert job.output_duration == 11.2
-        assert job.completed_at is not None
-        db_patch.commit.assert_called_once()
-        db_patch.close.assert_called_once()
-
-    def test_gpu_done_empty_signed_url_keeps_original(self, db_patch):
-        job = _make_job()
-        db_patch.query.return_value.filter_by.return_value.first.return_value = job
-        gpu_task = _make_gpu_task(result_url="gpu/r2.mp4")
-        storage = MagicMock()
-        storage.get_download_url.return_value = ""
-        with (
-            _patch_gpu_service(gpu_task),
-            patch.object(task_mod, "get_shared_storage_service", return_value=storage),
-        ):
-            _run_task()
-        assert job.status == "completed"
-        assert job.output_video_url == "gpu/r2.mp4"
-
-    def test_gpu_done_result_duration_none_defaults_zero(self, db_patch):
-        job = _make_job()
-        db_patch.query.return_value.filter_by.return_value.first.return_value = job
-        gpu_task = _make_gpu_task(result_duration=None)
-        storage = MagicMock()
-        with (
-            _patch_gpu_service(gpu_task),
-            patch.object(task_mod, "get_shared_storage_service", return_value=storage),
-        ):
-            _run_task()
-        assert job.output_duration == 0.0
-
-    def test_sign_failure_uses_original_url(self, db_patch):
-        job = _make_job()
-        db_patch.query.return_value.filter_by.return_value.first.return_value = job
-        gpu_task = _make_gpu_task(result_url="gpu/r3.mp4")
-        with (
-            _patch_gpu_service(gpu_task),
-            patch.object(task_mod, "get_shared_storage_service", side_effect=RuntimeError("oss down")),
-        ):
-            _run_task()
-        assert job.status == "completed"
-        assert job.output_video_url == "gpu/r3.mp4"
-
-
-class TestJobGuards:
-    def test_job_not_found_returns(self, db_patch):
-        db_patch.query.return_value.filter_by.return_value.first.return_value = None
-        _run_task()
-        db_patch.commit.assert_not_called()
-        db_patch.close.assert_called_once()
-
-    def test_job_wrong_status_skipped(self, db_patch):
-        job = _make_job(status="completed")
-        db_patch.query.return_value.filter_by.return_value.first.return_value = job
-        _run_task()
-        db_patch.commit.assert_not_called()
-
-
-class TestGpuFailureFallback:
-    def test_gpu_timeout_falls_back_mediakit_success(self, db_patch):
-        job = _make_job()
-        db_patch.query.return_value.filter_by.return_value.first.return_value = job
-        with (
-            _patch_gpu_service(None),
-            patch.object(task_mod, "_fallback_to_mediakit") as fb,
-        ):
-            _run_task()
-        fb.assert_called_once_with(db_patch, job)
-
-    def test_gpu_failed_status_falls_back(self, db_patch):
-        job = _make_job()
-        db_patch.query.return_value.filter_by.return_value.first.return_value = job
-        gpu_task = _make_gpu_task(status="failed")
-        with (
-            _patch_gpu_service(gpu_task),
-            patch.object(task_mod, "_fallback_to_mediakit") as fb,
-        ):
-            _run_task()
-        fb.assert_called_once_with(db_patch, job)
-
-
-class TestFallbackToMediaKit:
-    def test_mediakit_success_marks_submitted(self, db_patch):
-        job = _make_job()
-        fake_client = MagicMock()
-        fake_client.submit_lipsync.return_value = {"task_id": "mk-99"}
-        with (
-            patch("app.services.mediakit_client.get_mediakit_client", return_value=fake_client),
-            patch.object(task_mod, "_sign_media_url", side_effect=lambda u: u + "?s"),
-        ):
-            task_mod._fallback_to_mediakit(db_patch, job)
-        fake_client.submit_lipsync.assert_called_once()
-        kwargs = fake_client.submit_lipsync.call_args.kwargs
-        assert kwargs["enable_video_loop"] is True
-        assert kwargs["client_token"] == "job-1"
-        assert job.status == "submitted"
-        assert job.mediakit_task_id == "mk-99"
-        db_patch.commit.assert_called_once()
-
-    def test_mediakit_error_marks_failed(self, db_patch):
-        from app.services.mediakit_client import MediaKitError
-
-        job = _make_job()
-        fake_client = MagicMock()
-        fake_client.submit_lipsync.side_effect = MediaKitError("api reject", code="MkReject")
-        with (
-            patch("app.services.mediakit_client.get_mediakit_client", return_value=fake_client),
-            patch.object(task_mod, "_sign_media_url", side_effect=lambda u: u),
-        ):
-            task_mod._fallback_to_mediakit(db_patch, job)
-        assert job.status == "failed"
-        assert job.error_code == "MkReject"
-        db_patch.commit.assert_called_once()
-
-    def test_other_exception_marks_failed(self, db_patch):
-        job = _make_job()
-        with (
-            patch("app.services.mediakit_client.get_mediakit_client", side_effect=RuntimeError("boom")),
-            patch.object(task_mod, "_sign_media_url", side_effect=lambda u: u),
-        ):
-            task_mod._fallback_to_mediakit(db_patch, job)
-        assert job.status == "failed"
-        assert job.error_code == "FallbackFailed"
-        db_patch.commit.assert_called_once()
-
-
-class TestTaskException:
-    def test_unexpected_exception_marks_job_failed(self, db_patch):
-        job = _make_job()
-        # query 第一次返回 job，异常路径里再次 query 也返回 job
-        db_patch.query.return_value.filter_by.return_value.first.return_value = job
-        with patch(
-            "app.services.gpu_lipsync_service.GpuLipsyncService",
-            side_effect=RuntimeError("svc ctor fail"),
-        ):
-            _run_task()
-        assert job.status == "failed"
-        assert job.error_code == "GpuAsyncError"
-
-    def test_exception_handler_failure_swallowed(self, db_patch):
-        # 主流程异常，且异常处理中的 query 也抛异常 → 不应再抛
-        db_patch.query.side_effect = RuntimeError("db totally broken")
-        _run_task()
-        db_patch.close.assert_called_once()
-
-
-class TestSignMediaUrl:
-    def test_empty_url_returned_as_is(self):
-        assert task_mod._sign_media_url("") == ""
-
-    def test_non_own_host_returned_as_is(self):
-        storage = MagicMock()
-        storage.public_url = "https://own-bucket.oss-cn-beijing.aliyuncs.com"
-        with patch.object(task_mod, "get_shared_storage_service", return_value=storage):
-            url = "https://other.example.com/a.wav"
-            assert task_mod._sign_media_url(url) == url
-
-    def test_own_host_signed(self):
-        storage = MagicMock()
-        storage.public_url = "https://own-bucket.oss-cn-beijing.aliyuncs.com"
-        storage.get_download_url.return_value = "https://own-bucket.oss-cn-beijing.aliyuncs.com/a?sig=1"
-        with patch.object(task_mod, "get_shared_storage_service", return_value=storage):
-            out = task_mod._sign_media_url("https://own-bucket.oss-cn-beijing.aliyuncs.com/a.wav")
-        assert out.endswith("?sig=1")
-        storage.get_download_url.assert_called_once()
-
-    def test_missing_public_url_returns_original(self):
-        storage = MagicMock()
-        storage.public_url = ""
-        with patch.object(task_mod, "get_shared_storage_service", return_value=storage):
-            url = "https://own-bucket.oss-cn-beijing.aliyuncs.com/a.wav"
-            assert task_mod._sign_media_url(url) == url
-
-    def test_exception_returns_original(self):
-        with patch.object(task_mod, "get_shared_storage_service", side_effect=RuntimeError("x")):
-            url = "https://own-bucket.oss-cn-beijing.aliyuncs.com/a.wav"
-            assert task_mod._sign_media_url(url) == url

tests/unit/test_lipsync_gpu_integration.py

@@ -1,325 +0,0 @@
-"""LipsyncService GPU 路径集成测试 (#1978 异步版本).
-
-#1978 性能修复：GPU 推理从同步等待改为异步。
-- _submit_audio_direct 创建 GPU 任务后立即返回，job.status="processing"
-- Celery 任务 lipsync_gpu_process_async 负责等待结果+回写
-- 本测试验证：创建任务、异步派发、音频转存等逻辑
-"""
-
-from __future__ import annotations
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-
-@pytest.fixture()
-def fake_db():
-    db = MagicMock()
-    return db
-
-
-@pytest.fixture()
-def fake_mediakit():
-    client = MagicMock()
-    client.submit_lipsync.return_value = {"task_id": "mk-task-1"}
-    return client
-
-
-def _make_job(video_url="videos/video.mp4", audio_url="audios/audio.wav"):
-    job = MagicMock()
-    job.id = "job-1"
-    job.user_id = "u1"
-    job.project_id = "p1"
-    job.video_url = video_url
-    job.audio_url = audio_url
-    job.enable_video_loop = True
-    job.script_text = ""
-    job.sentence_timings = None
-    return job
-
-
-def _make_svc(db, mediakit, use_gpu=False):
-    from app.services.lipsync_service import LipsyncService
-
-    svc = LipsyncService(db=db, client=mediakit)
-    svc.settings.use_gpu_lipsync = use_gpu
-    svc._sign_media_url = lambda u: (u or "") + "?signed"
-    return svc
-
-
-def _patch_storage(public_url="https://own-bucket.oss-cn-beijing.aliyuncs.com", signed_suffix="?signed-7d"):
-    """patch get_shared_storage_service，返回自家 OSS storage mock."""
-    storage = MagicMock()
-    storage.public_url = public_url
-    storage.get_download_url.side_effect = lambda key_or_url, expires_seconds=3600: key_or_url + signed_suffix
-    return patch("app.services.lipsync_service.get_shared_storage_service", return_value=storage)
-
-
-class TestGpuFallback:
-    def test_switch_off_uses_mediakit(self, fake_db, fake_mediakit):
-        """开关关闭时直接走 MediaKit，不创建 GPU 任务."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=False)
-        job = _make_job()
-        with patch.object(svc, "_submit_to_gpu_create") as m_sub:
-            svc._submit_audio_direct(job=job)
-            m_sub.assert_not_called()
-        fake_mediakit.submit_lipsync.assert_called_once()
-        assert job.status == "submitted"
-
-    def test_switch_on_no_worker_falls_back(self, fake_db, fake_mediakit):
-        """开关打开但 has_available_worker=False → 回退 MediaKit."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.has_available_worker.return_value = False
-        with patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc):
-            job = _make_job()
-            svc._submit_audio_direct(job=job)
-        fake_gpu_svc.create_task.assert_not_called()
-        fake_mediakit.submit_lipsync.assert_called_once()
-        assert job.status == "submitted"
-
-    def test_gpu_success_dispatches_async(self, fake_db, fake_mediakit):
-        """#1978 异步：GPU 任务创建成功 → job.status=processing，Celery 异步派发."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.has_available_worker.return_value = True
-        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-task-1")
-        with (
-            _patch_storage(),
-            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
-            patch("app.services.lipsync_service.lipsync_gpu_process_async") as m_celery,
-        ):
-            job = _make_job()
-            svc._submit_audio_direct(job=job)
-        fake_gpu_svc.create_task.assert_called_once()
-        fake_mediakit.submit_lipsync.assert_not_called()
-        # 异步模式：job 立即设为 processing，Celery 任务派发
-        assert job.status == "processing"
-        assert job.mediakit_task_id == "gpu:gpu-task-1"
-        m_celery.apply_async.assert_called_once_with(args=("job-1", "u1", "gpu-task-1"))
-
-    def test_gpu_celery_dispatch_failure_falls_back_sync(self, fake_db, fake_mediakit):
-        """Celery 派发失败 → 降级同步等待 GPU 结果."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        gpu_done = MagicMock(
-            id="gpu-task-1",
-            status="done",
-            result_url="gpu-lipsync/results/gpu-task-1.mp4",
-            result_duration=12.5,
-        )
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.has_available_worker.return_value = True
-        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-task-1")
-        fake_gpu_svc.wait_for_result.return_value = gpu_done
-        with (
-            _patch_storage() as storage_p,
-            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
-            patch("app.services.lipsync_service.lipsync_gpu_process_async") as m_celery,
-        ):
-            m_celery.apply_async.side_effect = RuntimeError("Celery down")
-            storage = storage_p()
-            job = _make_job()
-            svc._submit_audio_direct(job=job)
-        # 降级同步等待完成
-        fake_gpu_svc.wait_for_result.assert_called_once()
-        assert job.status == "completed"
-        assert job.output_duration == 12.5
-        storage.get_download_url.assert_called_once_with(
-            "gpu-lipsync/results/gpu-task-1.mp4", expires_seconds=7 * 24 * 3600
-        )
-
-    def test_gpu_create_failure_falls_back(self, fake_db, fake_mediakit):
-        """GPU 任务创建异常 → 回退 MediaKit."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.has_available_worker.return_value = True
-        fake_gpu_svc.create_task.side_effect = RuntimeError("DB down")
-        with _patch_storage(), patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc):
-            job = _make_job()
-            svc._submit_audio_direct(job=job)
-        fake_mediakit.submit_lipsync.assert_called_once()
-        assert job.status == "submitted"
-
-    def test_gpu_create_returns_none_falls_back_mediakit(self, fake_db, fake_mediakit):
-        """_submit_to_gpu_create 返回 None（create_task 失败被内部吞掉）→ rollback + MediaKit."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.has_available_worker.return_value = True
-        with (
-            _patch_storage(),
-            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
-            patch.object(svc, "_submit_to_gpu_create", return_value=None) as m_create,
-        ):
-            job = _make_job()
-            svc._submit_audio_direct(job=job)
-        m_create.assert_called_once()
-        fake_db.rollback.assert_called_once()
-        fake_mediakit.submit_lipsync.assert_called_once()
-        assert job.status == "submitted"
-
-    def test_submit_to_gpu_wait_timeout_returns(self, fake_db, fake_mediakit):
-        """降级同步等待：wait_for_result 返回 None → 直接返回，job 保持 processing."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.wait_for_result.return_value = None
-        job = _make_job()
-        job.status = "processing"
-        svc._submit_to_gpu_wait(job=job, gpu_svc=fake_gpu_svc, gpu_task=MagicMock(id="gpu-task-x"))
-        fake_gpu_svc.wait_for_result.assert_called_once_with("gpu-task-x")
-        fake_db.commit.assert_not_called()
-        assert job.status == "processing"
-
-    def test_submit_to_gpu_wait_failed_status_returns(self, fake_db, fake_mediakit):
-        """降级同步等待：final_task.status != done → 直接返回."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.wait_for_result.return_value = MagicMock(status="failed", result_url="")
-        job = _make_job()
-        job.status = "processing"
-        svc._submit_to_gpu_wait(job=job, gpu_svc=fake_gpu_svc, gpu_task=MagicMock(id="gpu-task-y"))
-        fake_db.commit.assert_not_called()
-        assert job.status == "processing"
-
-    def test_gpu_external_audio_persisted_to_own_oss(self, fake_db, fake_mediakit):
-        """Bug2 回归：dashscope 临时音频 URL 在创建 GPU 任务前转存自家 OSS."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        dashscope_url = "https://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/tmp/abc.mp3"
-        job = _make_job(audio_url=dashscope_url)
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.has_available_worker.return_value = True
-        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-task-2")
-        with (
-            _patch_storage() as storage_p,
-            patch("app.services.lipsync_service.safe_download_bytes", return_value=b"FAKE-MP3") as m_dl,
-            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
-            patch("app.services.lipsync_service.lipsync_gpu_process_async"),
-        ):
-            storage = storage_p()
-            storage.upload_file.return_value = "https://own-bucket.oss-cn-beijing.aliyuncs.com/lipsync-tts/u1/job-1.mp3"
-            svc._submit_audio_direct(job=job)
-        # 外部音频在 GPU 分支被额外下载并转存到约定 key
-        gpu_dl_calls = [c for c in m_dl.call_args_list if c.kwargs.get("purpose") == "lipsync_gpu_tts_audio"]
-        assert len(gpu_dl_calls) == 1
-        assert gpu_dl_calls[0].args[0] == dashscope_url
-        storage.upload_file.assert_called_once()
-        args, kwargs = storage.upload_file.call_args
-        assert args[1] == "lipsync-tts/u1/job-1.mp3"
-        assert kwargs.get("content_type") == "audio/mpeg"
-        # 创建 GPU 任务时用的是自家 OSS URL
-        kwargs_create = fake_gpu_svc.create_task.call_args.kwargs
-        assert kwargs_create["audio_url"] == "https://own-bucket.oss-cn-beijing.aliyuncs.com/lipsync-tts/u1/job-1.mp3"
-        assert kwargs_create["audio_url"] != dashscope_url
-
-    def test_gpu_own_audio_not_repersisted(self, fake_db, fake_mediakit):
-        """Bug2：已是自家 OSS 的音频（含裸 key）不重复下载转存."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        job = _make_job(audio_url="lipsync-tts/u1/job-1.mp3")
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.has_available_worker.return_value = True
-        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-task-3")
-        with (
-            _patch_storage() as storage_p,
-            patch("app.services.lipsync_service.safe_download_bytes") as m_dl,
-            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
-            patch("app.services.lipsync_service.lipsync_gpu_process_async"),
-        ):
-            storage = storage_p()
-            svc._submit_audio_direct(job=job)
-        # GPU 转存分支不应下载/上传
-        gpu_dl_calls = [c for c in m_dl.call_args_list if c.kwargs.get("purpose") == "lipsync_gpu_tts_audio"]
-        assert gpu_dl_calls == []
-        storage.upload_file.assert_not_called()
-        assert fake_gpu_svc.create_task.call_args.kwargs["audio_url"] == "lipsync-tts/u1/job-1.mp3"
-
-    def test_gpu_external_audio_persist_fail_uses_original_url(self, fake_db, fake_mediakit):
-        """Bug2：外部音频转存失败不阻断，用原始 URL 建任务."""
-        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
-        dashscope_url = "https://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/tmp/abc.mp3"
-        job = _make_job(audio_url=dashscope_url)
-        fake_gpu_svc = MagicMock()
-        fake_gpu_svc.has_available_worker.return_value = True
-        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-task-4")
-        with (
-            _patch_storage() as storage_p,
-            patch("app.services.lipsync_service.safe_download_bytes", side_effect=RuntimeError("network blocked")),
-            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
-            patch("app.services.lipsync_service.lipsync_gpu_process_async"),
-        ):
-            storage = storage_p()
-            svc._submit_audio_direct(job=job)
-        storage.upload_file.assert_not_called()
-        assert fake_gpu_svc.create_task.call_args.kwargs["audio_url"] == dashscope_url
-
-
-class TestRefreshGpuStale:
-    """refresh_job_status 的 GPU 异步 stale 超时分支."""
-
-    def test_stale_gpu_job_marked_failed(self, fake_db):
-        from datetime import UTC, datetime, timedelta
-
-        svc = _make_svc(fake_db, MagicMock(), use_gpu=True)
-        job = MagicMock()
-        job.status = "processing"
-        job.mediakit_task_id = "gpu:gpu-task-stale"
-        job.updated_at = datetime.now(UTC) - timedelta(minutes=31)
-        with patch.object(svc, "get_job", return_value=job):
-            result = svc.refresh_job_status("job-stale", "u1")
-        assert result is job
-        assert job.status == "failed"
-        assert job.error_code == "GpuTimeout"
-        fake_db.commit.assert_called_once()
-
-    def test_fresh_gpu_job_left_processing(self, fake_db):
-        from datetime import UTC, datetime, timedelta
-
-        svc = _make_svc(fake_db, MagicMock(), use_gpu=True)
-        job = MagicMock()
-        job.status = "processing"
-        job.mediakit_task_id = "gpu:gpu-task-fresh"
-        job.updated_at = datetime.now(UTC) - timedelta(minutes=2)
-        with patch.object(svc, "get_job", return_value=job):
-            result = svc.refresh_job_status("job-fresh", "u1")
-        assert result is job
-        assert job.status == "processing"
-        fake_db.commit.assert_not_called()
-
-    def test_naive_updated_at_stale_marked_failed(self, fake_db):
-        """updated_at 为 naive datetime 时按 UTC 补时区后再判定."""
-        from datetime import UTC, datetime, timedelta
-
-        svc = _make_svc(fake_db, MagicMock(), use_gpu=True)
-        job = MagicMock()
-        job.status = "gpu_processing"
-        job.mediakit_task_id = "gpu:gpu-task-naive"
-        job.updated_at = datetime.now(UTC).replace(tzinfo=None) - timedelta(minutes=31)
-        with patch.object(svc, "get_job", return_value=job):
-            svc.refresh_job_status("job-naive", "u1")
-        assert job.status == "failed"
-        assert job.error_code == "GpuTimeout"
-
-
-class TestGpuServiceHelpers:
-    """GpuLipsyncService.has_available_worker 测试."""
-
-    def test_no_workers(self, fake_db):
-        from app.services.gpu_lipsync_service import GpuLipsyncService
-
-        svc = GpuLipsyncService(db=fake_db)
-        fake_db.query.return_value.filter.return_value.first.return_value = None
-        assert svc.has_available_worker() is False
-
-    def test_fresh_worker_available(self, fake_db):
-        from app.services.gpu_lipsync_service import GpuLipsyncService
-
-        svc = GpuLipsyncService(db=fake_db)
-        svc.settings.gpu_worker_stale_seconds = 300
-        fake_db.query.return_value.filter.return_value.first.return_value = MagicMock()
-        assert svc.has_available_worker() is True
-
-    def test_stale_worker_unavailable(self, fake_db):
-        from app.services.gpu_lipsync_service import GpuLipsyncService
-
-        svc = GpuLipsyncService(db=fake_db)
-        fake_db.query.return_value.filter.return_value.first.return_value = None
-        assert svc.has_available_worker() is False

tests/unit/test_lipsync_speed_optimization.py

@@ -102,8 +102,6 @@ def _make_service_with_mocks():
     svc = LipsyncService(db, client=client, cosyvoice_service=cosy, voice_clone_repo=MagicMock())
     # _resolve_voice_id 默认原样返回（repo.get 返回 None）
     svc._voice_clone_repo.get.return_value = None
-    # 确保 GPU 路径关闭（settings 是缓存单例，其他测试可能设过 True）
-    svc.settings.use_gpu_lipsync = False
     return svc, client, cosy
 
 

tests/unit/test_points_routes.py

@@ -71,7 +71,9 @@ class TestRechargeOrderResponse:
         cu = _make_cu()
         body = PointsRechargeRequest(package_id="nonexistent")
 
-        with pytest.raises(HTTPException) as exc, patch("app.api.routes.points._get_service", return_value=svc):
+        with pytest.raises(HTTPException) as exc, patch(
+            "app.api.routes.points._get_service", return_value=svc
+        ):
             create_recharge_order(body=body, current_user=cu, db=db)
         assert exc.value.status_code == 400
 
@@ -110,10 +112,7 @@ class TestCheckPointsUnknownScene:
         cu = _make_cu()
         body = PointsCheckRequest(scene_key="ai_voice", quantity=1, duration_minutes=1)
 
-        with (
-            patch("app.api.routes.points._credits_enabled", return_value=True),
-            patch("app.api.routes.points._get_service", return_value=svc),
-        ):
+        with patch("app.api.routes.points._get_service", return_value=svc):
             resp = check_points(body=body, current_user=cu, db=db)
         assert resp.required_points == 2  # ceil(1 * 1.15) = 2
         assert resp.current_balance == 50
@@ -149,30 +148,22 @@ class TestSubscriptionPlans:
     def _import_plans_fn():
         """Import from the real file to avoid sys.modules shadowing by integration fixtures."""
         import importlib.util
-
         _route_path = os.path.join(
             os.path.dirname(os.path.abspath(__file__)),
-            "..",
-            "..",
-            "apps",
-            "api",
-            "app",
-            "api",
-            "routes",
-            "subscription.py",
+            "..", "..", "apps", "api", "app", "api", "routes", "subscription.py",
+        )
+        _spec = importlib.util.spec_from_file_location(
+            "_real_subscription_routes", os.path.abspath(_route_path)
         )
-        _spec = importlib.util.spec_from_file_location("_real_subscription_routes", os.path.abspath(_route_path))
         _mod = importlib.util.module_from_spec(_spec)
         # inject settings before exec
         import os as _os
-
         _os.environ.setdefault("JWT_SECRET_KEY", "test-secret")
         _spec.loader.exec_module(_mod)
         return _mod.list_membership_plans
 
     def test_plans_endpoint_returns_three_tiers(self):
         import os  # noqa: F401  (used by _import_plans_fn)
-
         list_membership_plans = self._import_plans_fn()
         resp = list_membership_plans(current_user=_make_cu())
         plans = resp["plans"]
@@ -186,7 +177,6 @@ class TestSubscriptionPlans:
 
     def test_longer_plans_cheaper_per_month(self):
         import os  # noqa: F401
-
         list_membership_plans = self._import_plans_fn()
         resp = list_membership_plans(current_user=_make_cu())
         plans = resp["plans"]
@@ -221,10 +211,9 @@ class TestMultiplierConsistency:
         db = MagicMock()
         cu = _make_cu()
 
-        with patch("app.api.routes.points._credits_enabled", return_value=True):
-            for scene in ["ai_voice", "ai_title", "ai_cover", "ai_rewrite"]:
-                body = PointsCheckRequest(scene_key=scene, quantity=1)
-                with patch("app.api.routes.points._get_service", return_value=svc):
-                    resp = check_points(body=body, current_user=cu, db=db)
-                expected = calculate_points_cost(scene, is_member=False, quantity=1)
-                assert resp.required_points == expected, f"{scene}: got {resp.required_points}, expected {expected}"
+        for scene in ["ai_voice", "ai_title", "ai_cover", "ai_rewrite"]:
+            body = PointsCheckRequest(scene_key=scene, quantity=1)
+            with patch("app.api.routes.points._get_service", return_value=svc):
+                resp = check_points(body=body, current_user=cu, db=db)
+            expected = calculate_points_cost(scene, is_member=False, quantity=1)
+            assert resp.required_points == expected, f"{scene}: got {resp.required_points}, expected {expected}"