@remixmate/cli 0.9.72 → 0.9.74

package/skills/render-video/scripts/render_video.py

@@ -1,27 +1,27 @@
 #!/usr/bin/env python3
-"""
-视频渲染工具 - 接收 DSL + TemplateBinding，补齐素材，调用 Remotion 渲染
 
-默认行为:
-  读取 DSL 与 TemplateBinding，解析缺失素材，调用原子 Skills 生成，
-  编译时间线，最终调用 Remotion 渲染引擎输出视频。
 
-用法:
-  python render_video.py --dsl video.dsl.json --template-id <templateId>
-  python render_video.py --dsl video.dsl.json --template-id <templateId> --resolve-only
-  python render_video.py --render-plan video.render-plan.json
 
-环境变量:
-  PRIV_TOKEN                     - PrivToken（素材生成需要）
-  MM_API_BASE_URL                - API 根地址
-  REMOTION_OUTPUT_DIR            - 渲染输出目录（默认: tempfile.mkdtemp，按调用隔离；调试时可显式指定固定路径）
-  ASSET_CACHE_DIR                - 素材缓存目录（默认: ./.asset-cache/）
-  REMOTION_SKIP_VENDOR_CHROME    - 设为 1 则不从 OSS 拉取 Chrome Headless
-  REMOTION_FORCE_VENDOR_CHROME   - 设为 1 则强制重新下载并解压（同 REMOTION_FORCE_VENDOR_ZIP）
-  REMOTION_CHROME_VENDOR_JSON    - vendor-zip-urls.json 路径（默认在 chrome-headless-vendor-template 下）
-  REMOTION_CHROME_VENDOR_DOWNLOAD_TIMEOUT - 下载超时秒数（默认 3600）
-  REMOTION_CHROME_SHARE_DIR      - 浏览器 zip 共享目录（默认 /tmp/agent-share/chrome-headless，仅存 VERSION + *.zip）
-"""
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 import argparse
 import atexit
@@ -38,25 +38,25 @@ import urllib.request
 from datetime import datetime, timezone
 from typing import Optional
 
-# ── Cross-skill dependency ────────────────────────────────────────────────
-# Reach into `skills/template-registry/` — that directory is the de-facto home
-# for shared Python code in ab-skill (timeline-compilation, registry loader,
-# render-job HTTP client, etc.). Naming it `_SHARED_LIB_DIR` reflects its
-# actual role: it hosts much more than template lookup (see AGENTS.md
-# "skills/template-registry/scripts/" note).
-#
-# If signatures of the functions below change, also update:
-#   - skills/template-registry/video_dsl/runtime/timeline_compiler.py (the source)
-#   - any other caller discoverable via `grep -r "split_subtitle\|segment_narration"`
-# ───────────────────────────────────────────────────────────────────────────
+
+
+
+
+
+
+
+
+
+
+
 _SHARED_LIB_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "template-registry")
-# Single sys.path setup for both cross-skill import surfaces of the shared lib:
-#   - <shared>            for `video_dsl.runtime.*`
-#   - <shared>/scripts    for `registry_loader`, `match_template`,
-#                          `render_job_client`, `countdown_spec`
-# Each deeper function used to repeat its own sys.path.insert; consolidating
-# here keeps the module's import side-effects in one place and matches
-# Python's "set up sys.path once at module top" idiom.
+
+
+
+
+
+
+
 sys.path.insert(0, _SHARED_LIB_DIR)
 sys.path.insert(0, os.path.join(_SHARED_LIB_DIR, "scripts"))
 from video_dsl.runtime.timeline_compiler import (
@@ -66,52 +66,52 @@ from video_dsl.runtime.timeline_compiler import (
     assign_sentence_indices,
 )
 
-# 字幕末尾标点去除（与 timeline_compiler 中的 _strip_trailing_punct 同逻辑）
+
 _TRAILING_PUNCT_RE = re.compile(r"[。！？；，,、：:．.…]+$")
 
 def _strip_subtitle_trailing_punct(text: str) -> str:
-    """去掉字幕段末尾的标点符号，让画面更干净。"""
+
     return _TRAILING_PUNCT_RE.sub("", text)
 
 
-# ── 字幕段二次平衡（切长 + 合短） ─────────────────────────────────────
 
-_SUB_MAX_CHARS = 18  # 超过此长度的段尝试二次切分
-_SUB_MIN_CHARS = 7   # 短于此长度的段尝试合并到相邻段
-_SUB_SPLIT_RE = re.compile(r"(?<=[，,、；;])")  # 二次切分点：顿号/逗号/分号后
+
+_SUB_MAX_CHARS = 18
+_SUB_MIN_CHARS = 7
+_SUB_SPLIT_RE = re.compile(r"(?<=[，,、；;])")
 
 
 def _rebalance_subtitle_segments(segs: list[dict]) -> list[dict]:
-    """对 TTS 返回的字幕段做二次平衡：
-    1. 过长的段（> _SUB_MAX_CHARS）在逗号/顿号处切开，时间按字符比例分配
-    2. 过短的段（< _SUB_MIN_CHARS）合并到前一段（共享时间窗口）
-    """
+
+
+
+
     if not segs:
         return segs
 
-    # Phase 1: 切长
+
     expanded: list[dict] = []
     for seg in segs:
         text = seg["text"]
         if len(text) <= _SUB_MAX_CHARS:
             expanded.append(seg)
             continue
-        # 尝试在逗号/顿号处切分
+
         parts = _SUB_SPLIT_RE.split(text)
         parts = [p for p in parts if p.strip()]
         if len(parts) <= 1:
-            # 没有合适的切分点，保持原样
+
             expanded.append(seg)
             continue
-        # 按字符比例分配时间
+
         total_chars = max(sum(len(p) for p in parts), 1)
         total_frames = seg["endFrame"] - seg["startFrame"]
         cur_frame = seg["startFrame"]
         for p in parts:
             ratio = len(p) / total_chars
             frames = max(int(total_frames * ratio), 1)
-            # `**seg` 而不是只写三个键：切出来的各部分仍属于**同一句**，
-            # 所以 sentenceIndex 等字段要原样继承（见 build_render_plan 处的说明）。
+
+
             expanded.append({
                 **seg,
                 "text": _strip_subtitle_trailing_punct(p.strip()),
@@ -119,22 +119,22 @@ def _rebalance_subtitle_segments(segs: list[dict]) -> list[dict]:
                 "endFrame": cur_frame + frames,
             })
             cur_frame += frames
-        # 修正最后一段的 endFrame 对齐
+
         if expanded:
             expanded[-1]["endFrame"] = seg["endFrame"]
 
-    # Phase 2: 合短（把过短的段合并到前一段）
+
     if len(expanded) <= 1:
         return expanded
     merged: list[dict] = [expanded[0]]
     for seg in expanded[1:]:
         if len(seg["text"]) < _SUB_MIN_CHARS and merged:
-            # 合并到前一段：文本拼接，endFrame 取后者
+
             merged[-1]["text"] = merged[-1]["text"] + seg["text"]
             merged[-1]["endFrame"] = seg["endFrame"]
         else:
             merged.append(seg)
-    # 最后一段如果太短也合并
+
     if len(merged) > 1 and len(merged[-1]["text"]) < _SUB_MIN_CHARS:
         merged[-2]["text"] = merged[-2]["text"] + merged[-1]["text"]
         merged[-2]["endFrame"] = merged[-1]["endFrame"]
@@ -142,15 +142,15 @@ def _rebalance_subtitle_segments(segs: list[dict]) -> list[dict]:
 
     return merged
 
-# remotion-renderer 位于 monorepo 的 apps/ab-render/ 目录。脚本按相对位置推断
-# (skills/render-video/scripts/ → ../../../../apps/ab-render)。
-# 若 skill 被单独 clone 或路径不同，通过 REMOTION_RENDERER_DIR 环境变量覆盖。
+
+
+
 _DEFAULT_RENDERER_DIR = os.path.abspath(
     os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "apps", "ab-render")
 )
 REMOTION_RENDERER_DIR = os.environ.get("REMOTION_RENDERER_DIR", _DEFAULT_RENDERER_DIR)
-# 默认按调用创建独立 tempdir，避免多用户并发时落盘文件互相覆盖。
-# 调试场景可显式设置 REMOTION_OUTPUT_DIR 指向固定路径。
+
+
 OUTPUT_DIR = os.environ.get("REMOTION_OUTPUT_DIR") or tempfile.mkdtemp(prefix="ab-render-")
 ASSET_CACHE_DIR = os.environ.get("ASSET_CACHE_DIR", "./.asset-cache")
 
@@ -164,13 +164,13 @@ RESOLUTION_MAP = {
 
 
 def _narration_speed(narration: dict) -> Optional[float]:
-    """Read a narration block's speech-rate multiplier, or None when unset.
 
-    Tolerant on purpose: the DSL is hand-editable, and a malformed speed must
-    not take down a render that would otherwise be fine — it falls back to the
-    voice's own pace. 0 and negatives are treated as unset for the same reason
-    ab-api does (`speed: 0` there means "follow the global setting").
-    """
+
+
+
+
+
+
     if not isinstance(narration, dict):
         return None
     raw = narration.get("speed")
@@ -180,14 +180,14 @@ def _narration_speed(narration: dict) -> Optional[float]:
 
 
 def _narration_language_boost(narration: dict) -> Optional[str]:
-    """Read a narration block's language hint, or None when unset.
-
-    Same tolerance as _narration_speed: a malformed value must not take down an
-    otherwise fine render. The service applies its own default when we send
-    nothing, so "unset" is always a safe outcome — this flag exists to pin a
-    language when auto-detection is not good enough (e.g. an English-only
-    template whose narration still carries a Chinese brand name).
-    """
+
+
+
+
+
+
+
+
     if not isinstance(narration, dict):
         return None
     raw = narration.get("languageBoost")
@@ -197,14 +197,14 @@ def _narration_language_boost(narration: dict) -> Optional[str]:
 
 
 def _narration_voice(narration: dict) -> Optional[str]:
-    """Read a narration block's voice id, or None when unset.
-
-    Same tolerance as _narration_speed. Exists because the voice used to be read
-    only from the audio asset's payload.voiceId — which gen_script bakes once
-    when it drafts the skeleton — so changing global.narration.voiceId (or a
-    scene's voice) after that never reached TTS: the video kept the original
-    voice while every other layer reported the new one (2026-09-28).
-    """
+
+
+
+
+
+
+
+
     if not isinstance(narration, dict):
         return None
     raw = narration.get("voiceId")
@@ -214,12 +214,12 @@ def _narration_voice(narration: dict) -> Optional[str]:
 
 
 def extract_narration_lines(narration: dict) -> Optional[tuple[list[str], int, list[Optional[float]]]]:
-    """If narration uses the structured {intro, items, outro} form, return
-    (lines, intro_line_count, at_sec_list). `at_sec_list` is parallel to
-    `lines` and contains the per-line `atSec` hint (video-timeline offset
-    in seconds) when the DSL author specified one, or None otherwise.
-    Returns None if the narration only uses the flat `text` form.
-    """
+
+
+
+
+
+
     if not narration:
         return None
     items = narration.get("items")
@@ -263,16 +263,16 @@ _SKILLS_BASE_DIR = os.environ.get(
 
 
 def _resolve_ab_skill_cli_path() -> str | None:
-    """Locate the compiled ab-skill CLI (dist/cli.js).
 
-    Search order:
-      1. AB_SKILL_CLI_PATH env (ab-agent always sets this)
-      2. <_SKILLS_BASE_DIR>/../dist/cli.js     (ab-skill source layout)
-      3. <_SKILLS_BASE_DIR>/../skills-cli/cli.js (ab-agent bundled layout)
 
-    Returns None when nothing is found. The caller's error message then
-    says exactly what's missing.
-    """
+
+
+
+
+
+
+
+
     explicit = os.environ.get("AB_SKILL_CLI_PATH", "").strip()
     if explicit and os.path.exists(explicit):
         return explicit
@@ -287,21 +287,21 @@ def _resolve_ab_skill_cli_path() -> str | None:
 
 
 def build_skill_command(skill_name: str) -> list[str]:
-    """Return the argv prefix to invoke sibling skill `skill_name`.
 
-    Reads <_SKILLS_BASE_DIR>/<skill_name>/skill.json once and dispatches by
-    entry.type:
-      - python           → [sys.executable, "<skillDir>/<scriptPath>"]
-      - http / builtin   → [node, "<ab-skill-cli>", skill_name]
 
-    Centralizing the dispatch here means the 4 resolve_asset_* functions
-    only need to append their per-call --flag value pairs to the prefix —
-    they don't have to know whether the sibling is Python or TS.
 
-    Raises RuntimeError with a precise message when skill.json / script
-    file / CLI binary is missing, so subprocess.run gets a useful failure
-    rather than a generic "file not found".
-    """
+
+
+
+
+
+
+
+
+
+
+
+
     skill_dir = os.path.join(_SKILLS_BASE_DIR, skill_name)
     skill_json_path = os.path.join(skill_dir, "skill.json")
     if not os.path.exists(skill_json_path):
@@ -338,31 +338,31 @@ def build_skill_command(skill_name: str) -> list[str]:
 
 
 def resolve_remotion_entry(template_id: str, aspect_ratio: str) -> str:
-    """Look up the top-level Remotion composition for (templateId, aspectRatio).
-
-    Reads ``remotionEntry[aspect_ratio]`` from the template's registry entry.
-    The registry is the canonical source (matches what ab-render's manifest
-    consumes); the previous implementation read a local ``template.json`` via
-    a ``TEMPLATES_DIR`` env override that pointed at a directory which no
-    longer exists in the repo — so the function always fell back to the
-    hard-coded defaults regardless of what the template declared. Switching
-    to the registry preserves the fallback for templates that don't declare
-    ``remotionEntry`` and lets ones that DO declare it take effect (e.g.
-    screen-walkthrough's 9:16 entry).
-
-    Falls back to ``MainVideo16x9`` / ``MainVideo`` when the template isn't
-    found, the registry can't be loaded, or the aspect ratio isn't keyed.
-
-    ``include_all_statuses=True`` —— 状态门控是**选型策略**，不是渲染策略。
-    它要回答的是"列表里该不该出现这个模板、agent 该不该挑它"，一旦模板已经被选定并
-    通过校验，渲染就必须读到它真实的定义。把门控带到这里的后果是静默换成另一个
-    composition / 丢掉封面，成片与模板声明不符，而日志里只字未提。
-    「能不能被选中」由 template-registry 的 ``--include-beta`` 与
-    ``dsl_validator._check_template_status_gate`` 负责把关。
-    """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     if template_id:
         try:
-            from registry_loader import get_template  # type: ignore
+            from registry_loader import get_template
             tpl = get_template(template_id, include_all_statuses=True)
             if tpl:
                 entry_map = tpl.get("remotionEntry") or {}
@@ -375,24 +375,24 @@ def resolve_remotion_entry(template_id: str, aspect_ratio: str) -> str:
 
 
 def resolve_cover_composition_id(template_id: str) -> Optional[str]:
-    """Look up the cover compositionId for a template via the registry.
 
-    Each template's `compositions[]` array may contain at most one entry with
-    `slot == "cover"`. We return its compositionId, or None if the template
-    doesn't ship a cover.
 
-    Reading from the registry rather than the template.json file directly so
-    behaviour matches what ab-render's manifest exposes (the registry is the
-    aggregated truth used by both ab-render and ab-skill).
 
-    ``include_all_statuses=True`` 的理由同 ``resolve_remotion_entry``：门控管选型，
-    不管渲染。带上门控的话 beta 模板的封面会无声无息地不渲。
-    """
+
+
+
+
+
+
+
+
+
+
     if not template_id:
         return None
     try:
-        # sys.path setup happens once at module top — see header.
-        from registry_loader import get_template  # type: ignore
+
+        from registry_loader import get_template
 
         tpl = get_template(template_id, include_all_statuses=True)
         if not tpl:
@@ -412,7 +412,7 @@ def now_iso():
 
 
 def LogPrint(*args, sep=" ", end="\n", file=None, flush=False):
-    """带本地时间戳的 stderr/stdout 日志，格式 yyyyMMdd HHmmss:SSS（毫秒）。"""
+
     now = datetime.now()
     stamp = now.strftime("%Y%m%d %H%M%S") + f":{now.microsecond // 1000:03d}"
     if file is None:
@@ -421,17 +421,17 @@ def LogPrint(*args, sep=" ", end="\n", file=None, flush=False):
     builtins.print(f"[{stamp}] {message}", end=end, file=file, flush=flush)
 
 
-# ─── 扣费汇总 ────────────────────────────────────────────────────────────────
-# 一条视频管线的花费分散在多处：每个 gen-image / gen-voice / gen-video /
-# gen-digital-human 子进程各扣一次，渲染再通过 saveManifest 扣一次。子进程是
-# capture_output 起的，它们自己打的 💳 页脚会被吞掉，所以这里把子进程 stdout 里的
-# billing 事件抓出来累加，最后统一报一次总账——否则用户跑完一整条管线，只知道视频
-# 好了，不知道花了多少积分。
+
+
+
+
+
+
 _BILLING: dict = {"credits": 0, "balance": None}
 
 
 def absorb_child_billing(stdout: str) -> None:
-    """从子 skill 的 stdout 里收集 `__progress__` billing 事件（见 CLI src/billing.ts）。"""
+
     for line in (stdout or "").splitlines():
         line = line.strip()
         if not line.startswith("{") or "__progress__" not in line:
@@ -452,24 +452,24 @@ def absorb_child_billing(stdout: str) -> None:
 
 
 def print_billing_footer() -> None:
-    """收尾时报一次总账。通过 atexit 注册，所以 sys.exit / 中途失败也会打印
-    ——已经发生的扣费不该因为后面某一步失败就不告知用户。
 
-    走 stdout 而不是 stderr：ab-agent 交给 LLM 的是 `result.stdout || result.stderr`
-    （mcp-tools.ts），只写 stderr 在托管 agent 里等于不可见。
-    """
+
+
+
+
+
     credits = _BILLING["credits"]
     balance = _BILLING["balance"]
     try:
-        import render_job_client  # type: ignore
+        import render_job_client
 
         job_billing = render_job_client.billing_summary()
         if job_billing.get("credits"):
             credits += int(job_billing["credits"])
-            # saveManifest（渲染扣费）在管线里排最后，它带回的余额最新。
+
             if job_billing.get("balance") is not None:
                 balance = int(job_billing["balance"])
-    except Exception:  # noqa: BLE001 — 报账失败绝不能影响已完成的渲染
+    except Exception:
         pass
     if credits <= 0:
         return
@@ -478,12 +478,12 @@ def print_billing_footer() -> None:
 
 
 def sync_chrome_headless_vendor(renderer_dir: str, render_plan: dict) -> None:
-    """Chrome Headless vendor 同步——实现已抽到独立模块 ``_chrome_vendor``。
 
-    保留这个 thin wrapper 是为了：
-      1. ``render_with_local_cli`` 现有调用点无需改名；
-      2. 让 render_video.py 自身只关心"渲染调度"；vendor 部署细节留给独立模块。
-    """
+
+
+
+
+
     from _chrome_vendor import sync_chrome_headless_vendor as _sync
     _sync(renderer_dir, render_plan)
 
@@ -500,22 +500,22 @@ def save_json(data: dict, path: str):
 
 
 def validate_dsl(dsl: dict) -> list:
-    """Integrity DSL validation — delegates to the unified validator.
-
-    Historical rule set (preserved verbatim by ``validate_integrity``):
-      version + scene count + assetId duplicates + ``scene.audio.narration
-      .assetRef`` / ``scene.visuals.background.assetRef`` reference integrity
-      + structured narration items count vs templateData. ``meta.title`` and
-      ``global`` presence are intentionally NOT enforced here — by the time
-      a DSL reaches render_video those have already been gated upstream, and
-      enforcing them again would change historical behavior.
-
-    ``severity="warning"`` 的条目**不阻断**：它们描述的是"能渲染出来但有一处会静默
-    退化"（如黑板版 highlight 不是 title 的子串 → 标题退回单色）。把它们和硬错误混在
-    同一个 fatal 列表里，作者就只能二选一：要么被无关的软问题挡住，要么把整条校验关掉。
-    警告改为打印到 stderr，退出码不受影响。
-    """
-    from video_dsl.runtime.dsl_validator import (  # noqa: E402
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    from video_dsl.runtime.dsl_validator import (
         validate_integrity,
         errors_as_strings,
     )
@@ -531,26 +531,26 @@ def validate_dsl(dsl: dict) -> list:
 def _hydrate_dsl_payload(
     dsl: dict, template_id: str | None, source_document_url: str | None
 ) -> None:
-    """按模板声明把源文件的每一页填进 ``customPayload``（就地改 dsl）。
 
-    只对声明了 ``capabilities.payloadHydration`` 的模板生效；
-    其余模板这里是零成本 no-op —— 声明驱动，不写 ``if template_id == X``（AGENTS.md）。
 
-    失败一律 exit 2 并把「下一步做什么」打全：这条路上所有失败形态的共同点是
-    *数据源没通*，而历史报错说的是"字段没填"，两者要采取的行动完全不同。
 
-    共享模块导入失败（裁剪安装 / 单测环境）时静默跳过：那时 payloadRequirements
-    的校验会照常报必填缺失，行为退回改动前，不会更糟。
-    """
+
+
+
+
+
+
+
+
     try:
-        from payload_hydrator import HydrationError, hydrate_dsl  # noqa: E402
+        from payload_hydrator import HydrationError, hydrate_dsl
     except ImportError:
         return
 
     try:
-        from registry_loader import get_template  # noqa: E402
+        from registry_loader import get_template
         template = get_template(template_id) if template_id else None
-    except Exception:  # noqa: BLE001 - registry 不可达时退回"不注入"，由校验兜底报错
+    except Exception:
         template = None
     if not template:
         return
@@ -571,18 +571,18 @@ def _hydrate_dsl_payload(
 
 
 def _compose_image_prompts(dsl: dict, template_id: str | None) -> None:
-    """按模板 imageStyleGuide 把画风套到待生成图片的 prompt 上（就地改 dsl）。
 
-    只对 ``imageStyleGuide.mode == "compose"`` 的模板生效：agent 在 payload.prompt 里
-    只写画面主体，模板的画风 / 配色 / 负向词 / 比例在这里确定地、只一次地拼上去。
-    放在这里（而不是 gen_script）是因为此刻旁白已是定稿，不是骨架占位。
-    其余模板是零成本 no-op；registry 不可达时同样跳过，与 _hydrate_dsl_payload 一致。
-    """
+
+
+
+
+
+
     try:
-        from registry_loader import get_template  # noqa: E402
-        from video_dsl.runtime.prompt_enhancer import compose_dsl_image_prompts  # noqa: E402
+        from registry_loader import get_template
+        from video_dsl.runtime.prompt_enhancer import compose_dsl_image_prompts
         template = get_template(template_id) if template_id else None
-    except Exception:  # noqa: BLE001 - 取不到模板就不 compose，prompt 按 agent 写的原样用
+    except Exception:
         return
     if not template:
         return
@@ -591,20 +591,20 @@ def _compose_image_prompts(dsl: dict, template_id: str | None) -> None:
 
 
 def _warn_step_sentence_mismatch(entry: dict, sentence_indices: list[int], step_field: Optional[str]) -> None:
-    """动作条数与旁白句数不等时出声。
 
-    动作数组放在哪个字段由模板的 ``capabilities.stepAlignment.payloadField`` 声明
-    （``step_field``）；没声明的模板不检查。
 
-    为什么值得单独打一条：这一类缺陷**渲得出来**。它不报错、不退非零、renderJob
-    completed、漏斗记 rendered —— 2026-09-23 线上那条鸡兔同笼成片就是这样交付的，
-    10 步板面配 10 句旁白，听起来该一一对应，实际板面在音频中点就走完了。
-    既然成片本身不会告状，那就必须有人在这里说一句。
 
-    只警告不阻断：步数少于句数有时是作者的本意（末尾一句总结不需要新动作）。
-    真正需要拦的是"作者以为一一对应、实际不是"，而那个判断只有作者做得了 ——
-    所以这里给的是两个数字，不是一个结论。
-    """
+
+
+
+
+
+
+
+
+
+
+
     if not step_field:
         return
     steps = (entry.get("props") or {}).get(step_field)
@@ -636,21 +636,21 @@ def resolve_dimensions(dsl: dict) -> tuple:
 
 
 def validate_and_fix_render_plan(render_plan: dict) -> list:
-    """Validate RenderPlan integrity and auto-fix recoverable issues.
 
-    Checks performed:
-      1. subtitleSegments frame numbers within scene [startFrame, endFrame]
-      2. Video assets have non-null duration (required for screen-walkthrough)
-      3. Timeline frame continuity (prev.endFrame == next.startFrame)
-      4. All generated assets have a URL
 
-    Returns list of warning messages (empty = all good).
-    Mutates render_plan in-place to fix issues.
-    """
+
+
+
+
+
+
+
+
+
     warnings: list[str] = []
     fps = render_plan.get("renderConfig", {}).get("fps", 30)
 
-    # ── Check 1: subtitle frame bounds ────────────────────────────────────
+
     for entry in render_plan.get("timeline", []):
         scene_id = entry.get("sceneId", "?")
         scene_start = entry.get("startFrame", 0)
@@ -671,21 +671,21 @@ def validate_and_fix_render_plan(render_plan: dict) -> list:
                 seg["endFrame"] = scene_end
                 fixed = True
             if seg["startFrame"] >= seg["endFrame"]:
-                # Degenerate segment after clamping — give it at least 1 frame
+
                 seg["endFrame"] = min(seg["startFrame"] + max(1, int(fps * 0.5)), scene_end)
 
-    # ── Check 2: video asset duration ─────────────────────────────────────
-    # Whether the template needs every video asset to declare a non-null
-    # duration is a TEMPLATE CAPABILITY, not a property of ab-skill. The
-    # capability lives in template.json under ``capabilities.needsVideoDuration``;
-    # ab-skill simply reads + applies it. New templates that need this guarantee
-    # only have to declare the field — they don't have to touch this code.
+
+
+
+
+
+
     template_id = render_plan.get("templateId", "")
     needs_video_duration = False
     if template_id:
         try:
-            from registry_loader import get_template  # type: ignore
-            # include_all_statuses：门控管选型不管渲染（理由见 resolve_remotion_entry）。
+            from registry_loader import get_template
+
             _tpl = get_template(template_id, include_all_statuses=True)
             needs_video_duration = bool(
                 ((_tpl or {}).get("capabilities") or {}).get("needsVideoDuration")
@@ -697,8 +697,8 @@ def validate_and_fix_render_plan(render_plan: dict) -> list:
         if asset.get("type") != "video":
             continue
         if asset.get("duration") is None and needs_video_duration:
-            # Fallback: use the scene duration of whichever scene references this asset
-            # via props.videoAssetId / backgroundAssetId / imageAssetId.
+
+
             fallback_dur = None
             for entry in render_plan.get("timeline", []):
                 props = entry.get("props") or {}
@@ -716,7 +716,7 @@ def validate_and_fix_render_plan(render_plan: dict) -> list:
                     f"[fix] asset {asset.get('assetId')}: duration was null, set to scene duration {fallback_dur:.1f}s"
                 )
 
-    # ── Check 3: timeline frame continuity ────────────────────────────────
+
     timeline = render_plan.get("timeline", [])
     for i in range(1, len(timeline)):
         prev_end = timeline[i - 1].get("endFrame", 0)
@@ -726,7 +726,7 @@ def validate_and_fix_render_plan(render_plan: dict) -> list:
                 f"[fix] timeline gap: {timeline[i-1].get('sceneId')}.endFrame={prev_end} != "
                 f"{timeline[i].get('sceneId')}.startFrame={curr_start}, correcting"
             )
-            # Shift current and all subsequent scenes
+
             offset = prev_end - curr_start
             for j in range(i, len(timeline)):
                 timeline[j]["startFrame"] += offset
@@ -736,20 +736,20 @@ def validate_and_fix_render_plan(render_plan: dict) -> list:
                 for seg in timeline[j].get("subtitleSegments", []):
                     seg["startFrame"] += offset
                     seg["endFrame"] += offset
-            # Update total
+
             last = timeline[-1]
             render_plan["renderConfig"]["totalFrames"] = last["endFrame"]
             render_plan["renderConfig"]["totalDuration"] = round(last["endFrame"] / fps, 2)
-            break  # re-check from start would be needed for multiple gaps, but rare
+            break
+
 
-    # ── Check 4: generated assets have URL ────────────────────────────────
     for asset in render_plan.get("resolvedAssets", []):
         if asset.get("status") == "generated" and not asset.get("url"):
             warnings.append(
                 f"[warn] asset {asset.get('assetId')}: status=generated but url is empty"
             )
 
-    # Log warnings into render_plan
+
     if warnings:
         for w in warnings:
             render_plan.setdefault("logs", []).append({
@@ -765,7 +765,7 @@ def validate_and_fix_render_plan(render_plan: dict) -> list:
 
 
 def _build_bgm_props(dsl: dict) -> dict:
-    """Extract BGM config from DSL global settings and return as Remotion props."""
+
     bgm = dsl.get("global", {}).get("bgm", {})
     if bgm.get("enabled") and bgm.get("url"):
         return {"bgm": {"url": bgm["url"], "volume": bgm.get("volume", 0.15)}}
@@ -773,13 +773,13 @@ def _build_bgm_props(dsl: dict) -> dict:
 
 
 def _probe_video_duration(url: str):
-    """Backwards-compat wrapper — implementation lives in ``_video_probe`` module."""
+
     from _video_probe import probe_video_duration
     return probe_video_duration(url)
 
 
 def build_render_plan(dsl: dict, binding: dict) -> dict:
-    """Build a RenderPlan from DSL and TemplateBinding."""
+
     fps = dsl.get("global", {}).get("fps", 30)
     width, height = resolve_dimensions(dsl)
 
@@ -787,15 +787,15 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
     for b in binding.get("bindings", []):
         binding_map[b["sceneId"]] = b
 
-    # Pre-step: copy narration text from scenes[].audio.narration.text down
-    # into the matching audio asset's payload, so resolve_asset_audio (which
-    # only sees the asset, not the scene) can call gen-voice with the right
-    # text. narration.text is the single source of truth — DSL authors do
-    # NOT need to populate audio asset payload.text themselves.
-    #
-    # Structured narration form ({intro, items, outro}) is also expanded here
-    # so adjust_timeline_to_audio can later auto-derive highlightMap from
-    # per-line TTS timestamps.
+
+
+
+
+
+
+
+
+
     dsl_assets_by_id = {a["assetId"]: a for a in dsl.get("assets", [])}
     global_narration = (dsl.get("global") or {}).get("narration") or {}
     global_speed = _narration_speed(global_narration)
@@ -808,25 +808,25 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
         if not asset:
             continue
         payload = asset.setdefault("payload", {})
-        # Voice follows the same precedence as speed: scene narration.voiceId >
-        # global.narration.voiceId. The asset's own payload.voiceId (written once
-        # by gen_script) is only the last resort for DSLs that declare neither —
-        # letting it win meant a voice change made after the script was drafted
-        # never reached TTS.
+
+
+
+
+
         voice = _narration_voice(narration) or global_voice
         if voice:
             payload["voiceId"] = voice
-        # Speech rate follows the same route as the narration text: single source
-        # of truth on the DSL, copied down here because resolve_asset_audio only
-        # ever sees the asset. Scene-level overrides global (mirrors the narration
-        # editor's "行级覆盖 > 全局"); neither set = gen-voice's own 1.0 default.
+
+
+
+
         speed = _narration_speed(narration)
         if speed is None:
             speed = global_speed
         if speed is not None:
             payload["speed"] = speed
-        # 语种提示走与语速完全相同的路线（场景覆盖全局，都不写就交给服务端默认）：
-        # resolve_asset_audio 只看得见 asset，看不见 scene。
+
+
         language_boost = _narration_language_boost(narration)
         if language_boost is None:
             language_boost = global_language_boost
@@ -845,7 +845,7 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
 
     assets_by_id = {}
     for asset in dsl.get("assets", []):
-        # url 优先读顶层字段，其次 fallback 到 payload.url（兼容 source=url 写法）
+
         asset_url = asset.get("url", "") or (asset.get("payload") or {}).get("url", "")
         assets_by_id[asset["assetId"]] = {
             "assetId": asset["assetId"],
@@ -863,10 +863,10 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
             "maxRetries": 3,
         }
 
-    # ── Probe duration for existing video assets without duration ──────
-    # screen-walkthrough's adaptStrategy needs videoDurationSec to avoid
-    # falling back to static-fallback. Probe via partial download + ffprobe
-    # or fall back to a heuristic based on Content-Length.
+
+
+
+
     for aid, asset in assets_by_id.items():
         if asset["type"] == "video" and asset["source"] == "existing" and not asset.get("duration") and asset.get("url"):
             probed = _probe_video_duration(asset["url"])
@@ -883,9 +883,9 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
 
         scene_binding = binding_map.get(scene_id, {})
 
-        # P2.3: 不再产出 entry.layers。背景视觉资产、旁白音频、文本图层这些
-        # 信息全都通过 propExtractors → binding.props 显式传给模板（例如
-        # backgroundAssetId / narrationAssetId / titleText），模板用 props 即可。
+
+
+
 
         narration = (scene.get("audio") or {}).get("narration") or {}
 
@@ -893,18 +893,18 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
         extracted = extract_narration_lines(narration)
         subtitle_at_sec: list[Optional[float]] = []
         if extracted:
-            # Honour the authored line boundaries exactly (no secondary
-            # comma-split, no short-fragment merge) so the fallback
-            # subtitle count equals len(lines) — which is what
-            # _auto_highlight_map expects when TTS timestamps are absent.
+
+
+
+
             lines, _intro_lines, subtitle_at_sec = extracted
             local_subs = split_subtitle_from_lines(lines, duration_frames, fps)
         else:
             local_subs = split_subtitle(narration_text, duration_frames, fps)
-        # ⚠️ 平移帧号时**必须保留原有字段**（`**s`），不要只挑三个键重建。
-        # 这里曾经只搬 text/startFrame/endFrame，于是 timeline_compiler 给每段打上的
-        # `sentenceIndex`（模板用它把动作对齐到**句**而不是段）在这一步被静默丢掉 ——
-        # 下游模板拿不到句边界，只能退回按段对齐，也就是那个错位 bug 本身。
+
+
+
+
         subtitle_segments = [
             {
                 **s,
@@ -918,13 +918,13 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
         trans_type = transition_config.get("default", "fade")
         trans_dur = int(transition_config.get("duration", 0.5) * fps)
 
-        # 首场景不做 fade-in 转场，避免开头黑屏
+
         scene_trans_type = "cut" if idx == 0 else trans_type
         scene_trans_dur = 0 if idx == 0 else trans_dur
 
-        # 透传 scene.customPayload.minDurationSec 到 entry.minDurationFrames，
-        # 供 adjust_timeline_to_audio 在 audio-driven 计算时取下限（不让 scene
-        # 被旁白时长拍短）。
+
+
+
         custom_payload = scene.get("customPayload") or {}
         min_dur_sec = custom_payload.get("minDurationSec")
         min_dur_frames = (
@@ -932,9 +932,9 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
             if isinstance(min_dur_sec, (int, float)) and min_dur_sec > 0
             else 0
         )
-        # 透传 customPayload.tailPadSec 到 entry.tailPadFrames，覆盖
-        # adjust_timeline_to_audio 默认的 1.5s 旁白尾巴。设 0 = 没有尾巴，
-        # scene 贴音频结束立刻切走。未指定时（None）走全局默认 1.5s。
+
+
+
         tail_pad_sec = custom_payload.get("tailPadSec")
         tail_pad_frames = (
             int(round(float(tail_pad_sec) * fps))
@@ -967,8 +967,8 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
         "createdAt": now_iso(),
         "status": "planning",
         "templateId": binding.get("templateId", ""),
-        # 渲染时常用的 DSL 摘要字段，避免下游再去 dsl 全文里捞。
-        # 不复用 DSL 的 meta（dsl 是单一事实来源），只挑必要的几个供 UI/上传使用。
+
+
         "title": dsl.get("meta", {}).get("title", ""),
         "targetDuration": dsl.get("meta", {}).get("targetDuration"),
         "resolvedAssets": list(assets_by_id.values()),
@@ -1005,7 +1005,7 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
 
 
 def resolve_asset_image(asset: dict, private_token: str, timeout: int) -> dict:
-    """Resolve a single image asset by calling gen-image skill."""
+
     payload = asset.get("payload", {}) if "payload" not in asset else asset["payload"]
 
     try:
@@ -1018,7 +1018,7 @@ def resolve_asset_image(asset: dict, private_token: str, timeout: int) -> dict:
         cmd.extend(["--size", payload["ratio"]])
     if payload.get("model"):
         cmd.extend(["--model", payload["model"]])
-    # 模板声明的负向词 / 引导强度 / 种子以前在这里被丢掉，gen-image 从没收到过。
+
     if payload.get("negativePrompt"):
         cmd.extend(["--negative-prompt", str(payload["negativePrompt"])])
     if payload.get("guidanceScale") is not None:
@@ -1044,16 +1044,16 @@ def resolve_asset_image(asset: dict, private_token: str, timeout: int) -> dict:
 
 
 def resolve_asset_audio(asset: dict, private_token: str, timeout: int) -> dict:
-    """Resolve a single audio asset by calling gen-voice skill.
 
-    Pre-processes text with segment_narration() and newlines so Minimax
-    returns per-segment timestamps.  Uses --json-output to capture metadata.
 
-    If the payload carries `narrationItems` (structured {intro,items,outro}
-    form), those lines are fed verbatim to Minimax so the returned subtitle
-    count matches the authored line count — enabling an automatic 1:1
-    subtitle → card highlightMap in adjust_timeline_to_audio().
-    """
+
+
+
+
+
+
+
+
     payload = asset.get("payload", {})
 
     try:
@@ -1077,12 +1077,12 @@ def resolve_asset_audio(asset: dict, private_token: str, timeout: int) -> dict:
     cmd.extend(["--text", tts_text, "--json-output"])
     if payload.get("voiceId"):
         cmd.extend(["--voice-id", payload["voiceId"]])
-    # Injected by build_render_plan from the DSL (scene narration > global).
-    # Absent = let gen-voice apply its own default rather than pinning 1.0 here.
+
+
     speed = _narration_speed(payload)
     if speed is not None:
         cmd.extend(["--speed", str(speed)])
-    # 同 speed：不带就**不传**这个 flag，默认值归服务端一处持有。
+
     language_boost = _narration_language_boost(payload)
     if language_boost is not None:
         cmd.extend(["--language-boost", language_boost])
@@ -1117,7 +1117,7 @@ def resolve_asset_audio(asset: dict, private_token: str, timeout: int) -> dict:
 
 
 def resolve_asset_video(asset: dict, private_token: str, timeout: int) -> dict:
-    """Resolve a single video asset by calling gen-video skill."""
+
     payload = asset.get("payload", {})
 
     try:
@@ -1151,7 +1151,7 @@ def resolve_asset_video(asset: dict, private_token: str, timeout: int) -> dict:
 
 
 def resolve_asset_digital_human(asset: dict, private_token: str, timeout: int) -> dict:
-    """Resolve a single digital-human avatar asset by calling gen-digital-human skill."""
+
     payload = asset.get("payload", {})
 
     try:
@@ -1183,8 +1183,8 @@ def resolve_asset_digital_human(asset: dict, private_token: str, timeout: int) -
                 line = line.strip()
                 if line.startswith("http"):
                     out = {"status": "generated", "url": line}
-                    # 宽高 / 时长写回资产：模板按它定盒子比例（缺省 3:4 会裁人），
-                    # 按时长决定 onEnd=hide/loop 何时生效。探测失败不影响生成结果。
+
+
                     from _video_probe import probe_video_meta
                     meta = probe_video_meta(line)
                     if meta.get("width") and meta.get("height"):
@@ -1215,11 +1215,11 @@ def _resolve_single_asset(
     timeout: int,
     payload_override: Optional[dict] = None,
 ) -> bool:
-    """Resolve one asset. Returns True if generated, False if failed/skipped.
 
-    ``payload_override`` 整份替换资产 payload，且**不回写 DSL**：数字人连续段的驱动
-    音频是按本次排轴现拼的，写回 DSL 的话下次改了旁白还会拿旧音频去驱动。
-    """
+
+
+
+
     source = asset.get("source", "")
     resolver = ASSET_RESOLVERS.get(source)
     if not resolver:
@@ -1243,12 +1243,12 @@ def _resolve_single_asset(
     elif dsl_asset and "payload" in dsl_asset:
         asset_with_payload["payload"] = dsl_asset["payload"]
 
-    # Legacy：没走连续段调度（见 resolve_digital_human_segments）的数字人资产，
-    # 沿用「取第一个已生成的旁白」—— 只对全片一个数字人成立。
+
+
     if source == "gen-digital-human" and payload_override is None:
         payload = asset_with_payload.get("payload", {})
         if not payload.get("audioUrl"):
-            # Find the first generated TTS audio asset and use its URL
+
             for ra in render_plan["resolvedAssets"]:
                 if ra.get("type") == "audio" and ra.get("source") == "gen-voice" and ra.get("status") == "generated" and ra.get("url"):
                     payload["audioUrl"] = ra["url"]
@@ -1272,15 +1272,15 @@ def _resolve_single_asset(
             asset["generatedBy"]["completedAt"] = now_iso()
             if result.get("audio_length_ms") is not None:
                 asset["duration"] = result["audio_length_ms"]
-            # 视频类资产（数字人）：ms 时长 + 像素尺寸，模板的 ResolvedAsset 契约同名字段。
+
             if result.get("duration_ms") is not None:
                 asset["duration"] = result["duration_ms"]
             if result.get("width") and result.get("height"):
                 asset["width"], asset["height"] = result["width"], result["height"]
             if result.get("subtitles"):
                 asset["ttsSubtitles"] = result["subtitles"]
-            # Propagate structured-narration metadata onto the resolved
-            # asset so adjust_timeline_to_audio can auto-derive highlightMap.
+
+
             src_payload = asset_with_payload.get("payload", {}) or {}
             if isinstance(src_payload.get("narrationItems"), list):
                 asset["narrationLineCount"] = len(src_payload["narrationItems"])
@@ -1306,12 +1306,12 @@ def _resolve_single_asset(
 
 
 def apply_stub_urls(render_plan: dict, stub_image_url: str = "", stub_video_url: str = "") -> int:
-    """Short-circuit pending image/video assets with a stub URL (test mode, no API cost).
 
-    For every pending asset whose source is gen-image / gen-video and whose type is image
-    / video, replace with the stub URL in-place (status → generated). Returns the number
-    of assets that were stubbed.
-    """
+
+
+
+
+
     if not stub_image_url and not stub_video_url:
         return 0
 
@@ -1354,15 +1354,15 @@ def resolve_assets(
     timeout: int,
     defer_digital_human: bool = False,
 ) -> dict:
-    """Resolve all pending assets in the render plan.
 
-    Two-phase resolution:
-      Phase 1: resolve non-avatar assets (TTS, images, video) — **in parallel**
-      Phase 2: resolve avatar/digital-human assets which may depend on generated audio URLs — serial
 
-    ``defer_digital_human=True`` 时跳过 Phase 2：场景引用的数字人要等排轴之后按连续段
-    生成（驱动音频要按场景最终时长补静音），由 resolve_digital_human_segments 接手。
-    """
+
+
+
+
+
+
+
     from concurrent.futures import ThreadPoolExecutor, as_completed
 
     render_plan["status"] = "resolving-assets"
@@ -1373,9 +1373,9 @@ def resolve_assets(
     })
 
     pending = [a for a in render_plan["resolvedAssets"] if a["status"] == "pending"]
-    # Phase 1: resolve non-digital-human assets first (TTS audio needed by avatar)
+
     phase1 = [a for a in pending if a.get("source") != "gen-digital-human"]
-    # Phase 2: resolve digital-human assets (can now use generated audio URLs)
+
     phase2 = [a for a in pending if a.get("source") == "gen-digital-human"]
     if defer_digital_human:
         from _digital_human_segments import collect_segments
@@ -1385,7 +1385,7 @@ def resolve_assets(
     generated = 0
     failed = 0
 
-    # Phase 1: parallel resolution (concurrency configurable via env)
+
     if phase1:
         default_parallelism = 8
         max_workers = min(
@@ -1413,7 +1413,7 @@ def resolve_assets(
                     failed += 1
                     LogPrint(f"   ❌ {asset['assetId']} exception: {exc}", file=sys.stderr)
 
-    # Phase 2: serial resolution (digital-human depends on TTS audio)
+
     for asset in phase2:
         ok = _resolve_single_asset(asset, render_plan, private_token, max_retries, timeout)
         if ok:
@@ -1438,17 +1438,17 @@ def resolve_digital_human_segments(
     timeout: int,
     work_dir: Optional[str] = None,
 ) -> dict:
-    """排轴之后按连续段生成数字人，并给段内场景注入起播帧 / 段角色。
 
-    必须在 adjust_timeline_to_audio 之后调：驱动音频 = 段内各场景旁白、每段补静音
-    到该场景**最终**时长，视频第 Σ前序场景帧 帧才正好是本场景第 0 帧。
 
-    - 单场景段且旁白 ≥ 5 秒：直接用旁白驱动，不拼接。
-    - 其余情况用 ffmpeg 拼一条（ab-agent 镜像自带 ffmpeg），上传后驱动。
-    - 没有 ffmpeg：多场景段拆成每场景一段（人物在场景边界重新起播，但口型不错位），
-      并在 logs 里说明。
-    - 已生成的资产（续跑 / 复用）不重做，只重新注入偏移——偏移只取决于排轴。
-    """
+
+
+
+
+
+
+
+
+
     import _digital_human_segments as dhs
 
     segments = dhs.collect_segments(render_plan)
@@ -1474,15 +1474,15 @@ def resolve_digital_human_segments(
         })
         LogPrint(f"   🧑‍💼 {message}", file=sys.stderr)
 
-    # 先决定每段怎么驱动；没有 ffmpeg 时把多场景段拆开，拆完再统一生成。
-    jobs: list[tuple[str, dict]] = []  # (assetId, payload)
+
+    jobs: list[tuple[str, dict]] = []
     for asset_id, indices in list(segments.items()):
         asset = assets.get(asset_id)
         if not asset or asset.get("status") != "pending":
             continue
         base_payload = dsl_payloads.get(asset_id, {})
         if base_payload.get("audioUrl"):
-            # 作者显式给了驱动音频：尊重它，不再拼接。
+
             jobs.append((asset_id, base_payload))
             continue
         if len(indices) > 1 and not ffmpeg:
@@ -1495,7 +1495,7 @@ def resolve_digital_human_segments(
             timeline = render_plan.get("timeline", [])
             for idx, new_id in zip(indices, new_ids):
                 if not dhs.plan_drive_pieces(render_plan, [idx])[0].get("url"):
-                    # 没有旁白的场景单独成段就没有东西可驱动：这一屏不出人，而不是整段失败。
+
                     timeline[idx].get("props", {}).pop("avatarAssetId", None)
                     render_plan["resolvedAssets"] = [
                         a for a in render_plan["resolvedAssets"] if a.get("assetId") != new_id
@@ -1524,7 +1524,7 @@ def resolve_digital_human_segments(
                     if not any(p.get("url") for p in pieces):
                         raise RuntimeError("no generated narration audio in this segment to drive the presenter")
                     if not ffmpeg:
-                        # 单场景但旁白不足 5 秒，又没法补静音：照样提交，由服务端判定。
+
                         url = next(p["url"] for p in pieces if p.get("url"))
                         log(f"{asset_id}: narration shorter than {dhs.MIN_DRIVE_SEC:.0f}s and ffmpeg not found; submitting unpadded", level="warn")
                     else:
@@ -1539,7 +1539,7 @@ def resolve_digital_human_segments(
                         total = sum(p["durationSec"] for p in pieces)
                         log(f"{asset_id}: drive audio for {len(pieces)} scene(s), {total:.1f}s")
                 payload["audioUrl"] = url
-            except Exception as exc:  # noqa: BLE001 — 任一段失败不拖垮其它段
+            except Exception as exc:
                 asset["status"] = "failed"
                 failed += 1
                 render_plan.setdefault("errors", []).append({
@@ -1550,44 +1550,44 @@ def resolve_digital_human_segments(
                 })
                 log(f"{asset_id}: drive audio failed: {exc}", level="error")
                 continue
-        # 口型音轨就是驱动音频，文本 / 音色字段留着会让服务端改走 TTS 驱动。
+
         payload.pop("text", None)
         payload.pop("voiceId", None)
         if not _resolve_single_asset(asset, render_plan, private_token, max_retries, timeout, payload_override=payload):
             failed += 1
 
-    for warning in dhs.inject_segment_props(render_plan, dhs.collect_segments(render_plan)):
-        log(warning, level="warn")
-    if failed:
-        render_plan["status"] = "failed"
-    return render_plan
+    for warning in dhs.inject_segment_props(render_plan, dhs.collect_segments(render_plan)):
+        log(warning, level="warn")
+    if failed:
+        render_plan["status"] = "failed"
+    return render_plan
+
+
+def _auto_highlight_map(
+    entry: dict,
+    narration_asset: Optional[dict],
+    render_plan: dict,
+    line_sync: dict[str, str],
+) -> None:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
-def _auto_highlight_map(
-    entry: dict,
-    narration_asset: Optional[dict],
-    render_plan: dict,
-    line_sync: dict[str, str],
-) -> None:
-    """Auto-fill ``templateData.highlightMap`` for any template that uses
-    structured ``{intro, items, outro}`` narration and ships per-line cards.
-
-    Originally written for html-slide's multi-item slides — that's still the
-    primary consumer — but the trigger is capability-driven, not templateId-
-    keyed: any template whose binding pushes a ``narrationLineCount`` onto
-    the narration asset and whose subtitle segments line up 1-per-line gets
-    this auto-fill. Adding a new template that follows the same pattern needs
-    NO change to this function.
-
-    ``line_sync`` is the template's ``lineSyncSlides`` declaration (slideId →
-    card-array key). It caps the map at the card count so trailing outro lines
-    don't point past the last card; slides it doesn't list get no cap.
-
-    Skipped silently when:
-      - narration asset has no narrationLineCount (structured form wasn't used)
-      - author already supplied a highlightMap (explicit wins)
-      - subtitleSegments count ≠ narrationLineCount (emits a warn log)
-    """
     if not narration_asset:
         return
     line_count = narration_asset.get("narrationLineCount")
@@ -1599,7 +1599,7 @@ def _auto_highlight_map(
     if not isinstance(tdata, dict):
         return
     if tdata.get("highlightMap"):
-        return  # respect author-provided map
+        return
 
     segs = entry.get("subtitleSegments") or []
     if len(segs) != line_count:
@@ -1616,10 +1616,10 @@ def _auto_highlight_map(
 
     intro_lines = int(narration_asset.get("narrationIntroLines") or 0)
     item_count = line_count - intro_lines
-    # outro counts toward line_count too; cap item_count at the authored
-    # card-array length so trailing outro lines don't spill into card
-    # indices. 数组键读模板的 lineSyncSlides 声明（按 slideId），CLI 不保留键表副本
-    # —— 以前这里有一份模板 CARD_ARRAY_KEYS 的手抄，已经漂移过两次。
+
+
+
+
     slide_id = props.get("slideId") or tdata.get("slideId")
     items_key = line_sync.get(slide_id) if isinstance(slide_id, str) else None
     if items_key and not isinstance(tdata.get(items_key), list):
@@ -1643,23 +1643,23 @@ def _auto_highlight_map(
 
 
 def _timing_template(template_id: str) -> dict:
-    """排轴阶段要读的模板声明；取不到就返回空 dict，走全局默认，不因为这个挡渲染。"""
+
     if not template_id:
         return {}
     try:
-        from registry_loader import get_template  # type: ignore
+        from registry_loader import get_template
         return get_template(template_id, include_all_statuses=True) or {}
-    except Exception:  # noqa: BLE001
+    except Exception:
         return {}
 
 
 def _template_default_tail_pad_frames(tpl: dict, fps: int) -> int | None:
-    """模板声明的旁白尾巴默认值（``capabilities.defaultTailPadSec``），换算成帧。
 
-    场景自己的 ``customPayload.tailPadSec`` 仍然优先；这里只替换全局 1.5s 兜底。
-    为什么要模板级：逐场景设置靠模型照着 llmHint 抄，实际经常漏 —— 2026-09-24
-    线上《狼来了》绘本每页结尾 1.9s 空白，86s 里 15s 没有声音。
-    """
+
+
+
+
+
     value = (tpl.get("capabilities") or {}).get("defaultTailPadSec")
     if isinstance(value, bool) or not isinstance(value, (int, float)) or value < 0:
         return None
@@ -1667,8 +1667,8 @@ def _template_default_tail_pad_frames(tpl: dict, fps: int) -> int | None:
 
 
 def adjust_timeline_to_audio(render_plan: dict) -> dict:
-    """Post-process: use real TTS audio durations and timestamps to fix
-    scene durations and subtitle segments."""
+
+
     import math
 
     fps = render_plan["renderConfig"]["fps"]
@@ -1684,8 +1684,8 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
         default_tail_pad = int(fps * 1.5)
 
     for entry in render_plan["timeline"]:
-        # narration assetId 现在直接由 propExtractors 注入到 props.narrationAssetId，
-        # 不再依赖 entry.layers[type=audio] 这条间接路径。
+
+
         narration_asset = None
         nar_id = (entry.get("props") or {}).get("narrationAssetId")
         if nar_id:
@@ -1696,7 +1696,7 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
         if narration_asset and narration_asset.get("duration"):
             audio_ms = narration_asset["duration"]
             if audio_ms <= 0:
-                # Sanity check: TTS returned 0 or negative duration — keep original estimate
+
                 render_plan.setdefault("logs", []).append({
                     "phase": "audio-adjust",
                     "level": "warn",
@@ -1705,18 +1705,18 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
                 })
             else:
                 audio_frames = math.ceil(audio_ms / 1000.0 * fps)
-                # DSL 里 scene.customPayload.tailPadSec 可覆盖默认尾巴
-                # （比如开场卡片要紧接下一场，设 0 直接贴音频结束）；默认值是模板的
-                # capabilities.defaultTailPadSec，没声明时 1.5s。
+
+
+
                 tail_pad_override = entry.get("tailPadFrames")
                 tail_pad = (
                     int(tail_pad_override)
                     if isinstance(tail_pad_override, int) and tail_pad_override >= 0
                     else default_tail_pad
                 )
-                min_dur = int(fps * 2)     # minimum 2 seconds per scene
-                # 用户在 DSL 里指定的 scene 下限（minDurationSec → minDurationFrames），
-                # 用于"视频比旁白长"的场景：要把视频完整播完，scene 时长不能被旁白拍短。
+                min_dur = int(fps * 2)
+
+
                 scene_min_dur = int(entry.get("minDurationFrames") or 0)
                 new_dur = max(min_dur, scene_min_dur, audio_frames + tail_pad)
 
@@ -1726,11 +1726,11 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
 
                 tts_subs = narration_asset.get("ttsSubtitles", [])
                 if tts_subs:
-                    # 句归属必须在 _strip_subtitle_trailing_punct **之前**算：
-                    # 判据就是句末标点，去掉之后所有段都会被认成同一句。
-                    # 这一层是「第 i 个动作对齐第 i 句」类模板（math-principles-expl
-                    # 的 steps、ppt-to-video 的 beats）唯一能拿到句边界的地方 ——
-                    # TTS 行是按停顿切的，段数远多于句数。
+
+
+
+
+
                     sentence_indices = assign_sentence_indices(
                         [s.get("text") or "" for s in tts_subs]
                     )
@@ -1745,20 +1745,20 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
                     ]
                     _warn_step_sentence_mismatch(entry, sentence_indices, step_field)
                 else:
-                    # No TTS timestamps — re-distribute existing subtitle
-                    # lines across the REAL audio duration, by character
-                    # length ratio. Avoid going through
-                    # split_subtitle_from_lines() because its internal
-                    # estimated_audio_frames heuristic can clip
-                    # `usable_frames` below the actual audio length.
-                    # 字幕跟随真实音频时长分布，撑大 scene（因 minDuration）
-                    # 时尾巴静音段无字幕。
+
+
+
+
+
+
+
+
                     old_subs = entry.get("subtitleSegments", [])
                     at_sec_list = entry.get("subtitleAtSec") or []
-                    # 仅当某条字幕显式给了 atSec（视频时间轴的提示点）
-                    # 时，把字幕锚定到对应的视频帧；这样字幕节奏跟随
-                    # 画面而不是旁白长度。最后一条字幕会一直显示到
-                    # scene 结尾（让"看下效果"等收尾句保持在屏）。
+
+
+
+
                     has_at_sec = any(
                         isinstance(a, (int, float)) and a is not None
                         for a in at_sec_list
@@ -1766,8 +1766,8 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
 
                     if has_at_sec and old_subs:
                         scene_dur = entry["durationFrames"]
-                        # 算每条字幕的起始帧（相对 scene）。
-                        # atSec 缺失时以前一条结束位置为准。
+
+
                         starts: list[int] = []
                         for i, s in enumerate(old_subs):
                             at = at_sec_list[i] if i < len(at_sec_list) else None
@@ -1775,7 +1775,7 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
                                 f = max(0, int(round(at * fps)))
                             else:
                                 f = starts[i - 1] + (fps // 2) if i > 0 else 0
-                            # 单调递增，避免后给的 atSec 比前一条小
+
                             if i > 0 and f <= starts[i - 1]:
                                 f = starts[i - 1] + (fps // 2)
                             starts.append(min(f, scene_dur - 1))
@@ -1783,8 +1783,8 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
                         for i, s in enumerate(old_subs):
                             text = s.get("text", "")
                             start_f = starts[i]
-                            # 最后一条延续到 scene 结尾；其余以下一条
-                            # 起点为终点。
+
+
                             end_f = scene_dur if i == len(old_subs) - 1 else starts[i + 1]
                             new_subs.append({
                                 **s,
@@ -1794,9 +1794,9 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
                             })
                         entry["subtitleSegments"] = new_subs
                     elif old_subs:
-                        sub_span = audio_frames  # use exact audio length
-                        # Use plain char count (markdown ** stripped) for
-                        # ratio. Fall back to 1 to avoid div-by-zero.
+                        sub_span = audio_frames
+
+
                         def _plain(t: str) -> int:
                             return len(re.sub(r"\*+", "", t or ""))
                         total_chars = max(sum(_plain(s.get("text", "")) for s in old_subs), 1)
@@ -1817,11 +1817,11 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
 
         _auto_highlight_map(entry, narration_asset, render_plan, line_sync)
 
-        # Re-anchor subtitles for scenes that weren't handled in the narration block above.
-        # This covers scenes without narration or with invalid duration.
+
+
         old_scene_start = entry.get("startFrame", 0)
         if not (narration_asset and narration_asset.get("duration") and narration_asset["duration"] > 0):
-            # Subtitles weren't touched above — re-anchor if position shifted
+
             if old_scene_start != current_frame:
                 old_subs = entry.get("subtitleSegments", [])
                 if old_subs:
@@ -1841,14 +1841,14 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
         entry["startTime"] = round(current_frame / fps, 2)
         entry["endTime"] = round(entry["endFrame"] / fps, 2)
 
-        # P2.3: 不再维护 entry.layers —— 旧的 layers 数组只是给 ab-render 模板"间接"
-        # 找 background asset 用，现已收敛到 propExtractors 写到 props.backgroundAssetId
-        # / props.narrationAssetId 等显式字段。新版 build_render_plan 不再写入
-        # entry.layers；如果上游真的塞了 layers 进来（旧 RenderPlan 文件被
-        # --render-plan 喂进来），干脆扔掉，避免帧号坐标系混乱。
+
+
+
+
+
         entry.pop("layers", None)
 
-        # 为 props.slides 中的每张幻灯片分配 durationFrames（Remotion Sequence 必需）
+
         slides = entry.get("props", {}).get("slides")
         if slides and isinstance(slides, list) and len(slides) > 0:
             scene_dur = entry["durationFrames"]
@@ -1878,7 +1878,7 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
 
 
 def render_with_local_cli(render_plan: dict, output_path: str) -> bool:
-    """Call Remotion CLI to render the video locally."""
+
     render_plan["status"] = "rendering"
     render_plan["logs"].append({
         "phase": "render",
@@ -1886,12 +1886,12 @@ def render_with_local_cli(render_plan: dict, output_path: str) -> bool:
         "timestamp": now_iso(),
     })
 
-    # Absolutise paths so they survive the cwd switch to REMOTION_RENDERER_DIR
+
     output_path = os.path.abspath(output_path)
     os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
 
-    # 直接使用 resolvedAssets 中的 HTTPS URL，让 Chrome headless 自行加载外网图片。
-    # 若 render-plan.json 曾被本地化处理过（url 以 "/" 开头），从 originalUrl 恢复。
+
+
     https_assets = []
     for asset in render_plan.get("resolvedAssets", []):
         asset = asset.copy()
@@ -1958,7 +1958,7 @@ def render_with_local_cli(render_plan: dict, output_path: str) -> bool:
         composition_id,
         output_path,
         "--props", props_path,
-        # 不使用 --public-dir，图片直接通过 HTTPS URL 由 Chrome headless 加载。
+
         "--width", str(config.get("width", 1920)),
         "--height", str(config.get("height", 1080)),
         "--fps", str(config.get("fps", 30)),
@@ -1977,7 +1977,7 @@ def render_with_local_cli(render_plan: dict, output_path: str) -> bool:
     sys.stderr.flush()
 
     try:
-        # Stream output to stderr so progress is visible in real-time
+
         proc = subprocess.Popen(
             cmd,
             stdout=subprocess.PIPE,
@@ -1998,19 +1998,19 @@ def render_with_local_cli(render_plan: dict, output_path: str) -> bool:
             if len(stderr_tail) > 50:
                 stderr_tail.pop(0)
 
-            # Parse and print compact progress: "Rendered 100/2617"
+
             stripped = line.strip()
             if stripped.startswith("Rendered "):
                 try:
                     parts = stripped.split()
-                    frac = parts[1].rstrip(",")  # "100/2617"
+                    frac = parts[1].rstrip(",")
                     current = int(frac.split("/")[0])
-                    # Print progress every 10% or every 100 frames
+
                     if total_frames and (current - last_rendered >= max(total_frames // 10, 1)):
                         pct = int(current / total_frames * 100)
                         LogPrint(f"   🎞️  Render progress: {current}/{total_frames} ({pct}%)", file=sys.stderr)
                         sys.stderr.flush()
-                        # 结构化进度，供上层解析并转发到前端
+
                         print(
                             json.dumps({
                                 "__progress__": True,
@@ -2067,25 +2067,25 @@ def render_with_local_cli(render_plan: dict, output_path: str) -> bool:
 
 
 def _persist_plan_checkpoint(render_plan: dict, job_id: Optional[int], private_token: str) -> None:
-    """把当前 RenderPlan 存个档（尽力而为，失败只记日志）。
 
-    存在的唯一理由：远端 taskId 必须在**渲染结束之前**就落库。脚本可能在任何时刻
-    被外层超时 SIGTERM，那一刻没有任何机会写盘；只在流程末尾 save_plan 的话，
-    taskId 永远存不下来，"续跑"就无从谈起。
-    """
+
+
+
+
+
     if not job_id:
         return
     try:
-        import render_job_client  # type: ignore
+        import render_job_client
         render_job_client.save_plan(job_id, json.dumps(render_plan, ensure_ascii=False), private_token)
         LogPrint(f"   💾 RenderPlan checkpoint saved (jobId={job_id})", file=sys.stderr)
-    except Exception as exc:  # noqa: BLE001 — 存档失败不该让渲染本身失败
+    except Exception as exc:
         LogPrint(f"   ⚠️  RenderPlan checkpoint failed (jobId={job_id}): {exc}", file=sys.stderr)
 
 
 
 def _builtin_dynamic_render_enabled() -> bool:
-    """内置模板是否也走 /renderDraft（Phase 3b 路由翻转开关，默认关）。"""
+
     return os.environ.get("REMIXMATE_BUILTIN_DYNAMIC_RENDER", "").strip().lower() in {"1", "true", "yes", "on"}
 
 def render_with_remote_api(
@@ -2099,13 +2099,13 @@ def render_with_remote_api(
     conversation_id: Optional[str] = None,
     job_id: Optional[int] = None,
 ) -> bool:
-    """Submit render to ab-api /tool/renderVideo and poll until completion.
 
-    On success, writes upload.fileUrl into render_plan and skips local MP4 download.
 
-    job_id 用于中途存档（见 _persist_plan_checkpoint）：有它才能在被强杀后续跑，
-    没有则退化成旧行为（一次性，杀了就得重渲）。
-    """
+
+
+
+
+
     import remote_renderer_client
 
     render_plan["status"] = "rendering"
@@ -2133,11 +2133,11 @@ def render_with_remote_api(
     }
     effective_title = upload_title or os.path.splitext(os.path.basename(output_path))[0]
 
-    # ─── Cover composition resolution ────────────────────────────────────
-    # 优先级：
-    #   1) render_plan.remotionProps.coverCompositionId（上游显式指定）
-    #   2) registry.compositions[].slot=="cover" 反查（自动匹配）
-    # 不传 → ab-render 不渲封面，行为与改造前一致。
+
+
+
+
+
     cover_composition_id = (
         render_plan.get("remotionProps", {}).get("coverCompositionId")
     )
@@ -2145,60 +2145,60 @@ def render_with_remote_api(
         template_id = render_plan.get("templateId", "")
         cover_composition_id = resolve_cover_composition_id(template_id)
 
-    # ─── 私有模板路由 ────────────────────────────────────────────────────
-    # 仅【用户私有模板】(isBuiltin=false 且 hasSource) 源码在 OSS、不在
-    # ab-render 启动 bundle，需走动态渲染：/renderDraft {templateKey}，ab-render 服务端取包。
-    # 内置模板即使带 sourceOssKey（admin 调用时 registry 才会输出），渲染仍走 ab-render
-    # 预构建的 /render，绝不走 /renderDraft，否则会用 OSS 上的旧快照 + DraftMainVideo
-    # 复刻渲染，与生产 MainVideo 漂移。
+
+
+
+
+
+
     pending_resume = bool(str(render_plan.get("remoteTaskId") or "").strip())
     render_path = "/render"
     status_path = "/renderStatus"
 
     source_oss_key = None
-    # 内置模板是否也走动态渲染（Phase 3b 路由翻转，ab-platform/docs/
-    # template-authoring-page-review.md §7.2）。默认关：翻转依赖 ab-render 以服务身份取
-    # 内置源码（DRAFT_BUILTIN_SOURCE_TOKEN ↔ ab-api ab_render.service_token），服务端没配好
-    # 就打开，普通用户渲染内置模板会全部失败。服务端就绪后设 REMIXMATE_BUILTIN_DYNAMIC_RENDER=1；
-    # 回退 = 取消该变量，内置模板回到 /render。
+
+
+
+
+
     builtin_dynamic = _builtin_dynamic_render_enabled()
     is_builtin_dynamic = False
     template_id = render_plan.get("templateId", "")
     if template_id:
         try:
-            from registry_loader import get_template  # type: ignore
-            # include_all_statuses：门控管选型不管渲染（理由见 resolve_remotion_entry）。
-            # 漏掉它的话私有 beta 模板会丢 sourceOssKey，转而按内置模板渲——渲出来的
-            # 是另一个模板的画面。
+            from registry_loader import get_template
+
+
+
             _meta = get_template(template_id, include_all_statuses=True)
             if _meta and not _meta.get("isBuiltin"):
                 source_oss_key = _meta.get("hasSource")
             elif _meta and builtin_dynamic:
-                # 内置模板：客户端拿不到也不需要 sourceOssKey（源码保护），只要知道
-                # 它在 registry 里；ab-render 按 templateKey 以服务身份取包。
+
+
                 source_oss_key = True
                 is_builtin_dynamic = True
         except Exception:
             source_oss_key = None
 
     if source_oss_key:
-        # 只传 templateKey：由 ab-render 带本次的 X-Priv-Token 向 ab-api 换源码包 URL
-        # 并自行下载（所有权校验在 ab-api）。源码包 URL 不经过客户端 ——
-        # 见 ab-platform/docs/templates/template-source-protection-design.md §4.3。
+
+
+
         payload = {
             "templateKey": template_id,
             "inputProps": input_props,
             "upload": True,
             "uploadTitle": effective_title,
         }
-        # 私有模板封面：传 coverCompositionId 让 /renderDraft 渲模板自带 cover 组件
-        # （ab-render 注册了 DraftCover），与内置 /render 的 MainCover 对等；
-        # 不传则 ab-render 退回截首帧 / 不渲。
+
+
+
         if cover_composition_id:
             payload["coverCompositionId"] = cover_composition_id
         if is_builtin_dynamic:
-            # 与预构建 /render 的 MainVideo 语义对齐：不把 entry.props 摊平到顶层
-            # （摊平会让同名键覆盖平台注入的 typography / variantId 等）。
+
+
             payload["spreadEntryProps"] = False
         render_path = "/renderDraft"
         status_path = "/renderDraftStatus"
@@ -2216,7 +2216,7 @@ def render_with_remote_api(
 
     total_frames = config.get("totalFrames", 0)
     if pending_resume:
-        # 续跑：下面那堆"正在提交"的日志会误导人，跳过
+
         LogPrint(f"🎬 Remote render task already exists, will resume polling", file=sys.stderr)
     elif is_builtin_dynamic:
         LogPrint(f"   Builtin template (dynamic bundle): {template_id}", file=sys.stderr)
@@ -2230,17 +2230,17 @@ def render_with_remote_api(
     LogPrint(f"   total frames: {total_frames}", file=sys.stderr)
     sys.stderr.flush()
 
-    # ─── 续跑既有任务 ────────────────────────────────────────────────────
-    # 上一次调用可能是被外层超时 SIGTERM 掉的（skill 执行有上限），而远端任务还在
-    # ab-render 上跑着。这时重新提交 = 白烧一遍渲染、并且大概率再次撞上同一个上限。
-    # 所以先看 plan 里有没有上次留下的 taskId：有就直接续着轮询。
-    #
-    # 只在"任务不可用"（已失败 / 查不到）时才退回重新提交 —— 轮询超时不算不可用，
-    # 那条路走 RemoteRenderTimeout，保留 taskId 交给下一次调用。
+
+
+
+
+
+
+
     task_id = str(render_plan.get("remoteTaskId") or "").strip()
     if task_id:
-        # 提交时用的状态端点存在 plan 里（内置模板 /renderStatus，私有模板
-        # /renderDraftStatus）。用存的那个，别依赖这次重新推导的结果。
+
+
         status_path = render_plan.get("remoteStatusPath") or status_path
         LogPrint(f"🔄 resuming existing remote task: taskId={task_id}", file=sys.stderr)
         render_plan["logs"].append({
@@ -2270,19 +2270,19 @@ def render_with_remote_api(
             "message": f"Remote task submitted: {task_id}",
             "timestamp": now_iso(),
         })
-        # **立刻落库**，不等渲染结束。被 SIGTERM 的那一刻脚本没有任何机会写盘，
-        # 所以 taskId 必须在这里就进 DB，否则下一次调用无从续起（这正是旧代码
-        # 只写内存、`remoteTaskId` 全程没人读的后果）。
+
+
+
         _persist_plan_checkpoint(render_plan, job_id, private_token)
 
     last_progress = -1.0
-    # 续跑时用提交时刻算 elapsed，否则 ETA 会按"刚开始"估，一上来就偏小。
+
     render_start_time = float(render_plan.get("remoteStartedAt") or time.time())
 
     def _on_progress(status_data: dict):
         nonlocal last_progress
         progress = float(status_data.get("progress") or 0.0)
-        # 门槛设小(2%)：短渲染服务端进度增量小，太大的门槛会把中间档全吞掉，只剩 0%→100%
+
         if progress - last_progress >= 0.02 or progress >= 1.0:
             pct = int(progress * 100)
             elapsed = time.time() - render_start_time
@@ -2296,7 +2296,7 @@ def render_with_remote_api(
             else:
                 LogPrint(f"   🎞️  Remote render progress: {pct}%", file=sys.stderr)
             sys.stderr.flush()
-            # 结构化进度，供上层解析并转发到前端
+
             print(
                 json.dumps({
                     "__progress__": True,
@@ -2321,8 +2321,8 @@ def render_with_remote_api(
             status_path=status_path,
         )
     except remote_renderer_client.RemoteRenderTimeout as exc:
-        # 等不动了，但任务**没失败**。保留 taskId，让下一次调用接着轮询；
-        # 状态不写 failed（写了模型会当成"渲染失败"而重新走一遍完整流程）。
+
+
         LogPrint(f"⏳ {exc}", file=sys.stderr)
         render_plan["status"] = "rendering"
         _persist_plan_checkpoint(render_plan, job_id, private_token)
@@ -2340,8 +2340,8 @@ def render_with_remote_api(
     except Exception as exc:
         LogPrint(f"❌ remote render polling failed: {exc}", file=sys.stderr)
         render_plan["status"] = "failed"
-        # 任务确实不可用了（失败 / 查不到）。清掉 taskId，否则下一次调用会一直
-        # 去续一个永远好不了的任务，再也提交不了新的。
+
+
         render_plan.pop("remoteTaskId", None)
         render_plan.pop("remoteStatusPath", None)
         render_plan.pop("remoteStartedAt", None)
@@ -2364,13 +2364,13 @@ def render_with_remote_api(
         })
         return False
 
-    # 提取 VOD 元数据
+
     video_id = (result or {}).get("videoId", "")
     file_id = (result or {}).get("fileId")
 
-    # 提取封面（可选；ab-render 在视频成功后串行渲一帧静态封面）
-    # 失败不影响视频本身的成败——cover_url 为空则上游可以选择回退到占位图
-    # 或重试。
+
+
+
     cover_url = (result or {}).get("coverUrl")
     cover_error = (result or {}).get("coverError")
 
@@ -2386,7 +2386,7 @@ def render_with_remote_api(
     if cover_url:
         render_plan["upload"]["coverUrl"] = cover_url
     if cover_error and not cover_url:
-        # 视频成功但封面失败：降级为非致命 log，便于上游看到原因
+
         render_plan["logs"].append({
             "phase": "render",
             "message": f"Cover render failed (non-fatal): {cover_error}",
@@ -2407,7 +2407,7 @@ def render_with_remote_api(
             file=sys.stderr,
         )
 
-    # 如果是 vod:// 地址，轮询后端获取实际播放 URL
+
     if file_url.startswith("vod://") and file_id and private_token:
         playback_url = _poll_vod_playback_url(file_id, private_token)
         if playback_url:
@@ -2426,16 +2426,16 @@ def _poll_vod_playback_url(
     max_wait: float = 60.0,
     interval: float = 3.0,
 ):
-    """Backwards-compat wrapper — implementation lives in ``_vod_polling`` module."""
+
     from _vod_polling import poll_vod_playback_url
     return poll_vod_playback_url(file_id, private_token, max_wait=max_wait, interval=interval)
 
 
 def auto_bind_template(dsl: dict, template_id: str) -> dict:
-    """Auto-generate TemplateBinding from DSL + template-id by importing
-    match_template.py's binding logic. Eliminates the need for a separate
-    match_template.py invocation step."""
-    # template-registry/scripts is on sys.path via the module-top setup.
+
+
+
+
     try:
         import match_template
     except ImportError as e:
@@ -2458,14 +2458,14 @@ def auto_bind_template(dsl: dict, template_id: str) -> dict:
         LogPrint(f"❌ template not found: {template_id} (available: {available})", file=sys.stderr)
         sys.exit(1)
 
-    # 选型门控在这里落地，而不是在上面的查表上：查表刻意用未门控的列表，因为绑定
-    # 必须读到模板真实的定义（slotMapping / compositions）。门控管的是"允许不允许
-    # 选中它"，而 auto_bind 正是"一个 id 变成本次成片所用模板"的那一刻。
-    #
-    # dsl_validator 已经在更早的位置报同一件事，但它只看 meta.templateId；手写的
-    # DSL 可能没有那个字段，只靠 --template-id 传进来 —— 这里补上那条路。
+
+
+
+
+
+
     try:
-        from registry_loader import gated_status  # type: ignore
+        from registry_loader import gated_status
         _gated = gated_status(template_id)
     except Exception:
         _gated = None
@@ -2491,15 +2491,15 @@ def auto_bind_template(dsl: dict, template_id: str) -> dict:
 
 
 def _log_render_plan_summary(render_plan: dict) -> None:
-    """Print a one-line identity summary of a loaded RenderPlan.
-
-    The two ways to feed an existing plan (``--render-plan <file>`` and
-    ``--job-id <int>``) used to print only the *source* (path / id), never the
-    *content*. When a stale ``output/render-plan.json`` from a previous, unrelated
-    run got picked up, the mismatch was rendered silently. Surfacing
-    templateId / title / duration / scene count here makes a wrong plan obvious
-    at a glance before any render time is spent.
-    """
+
+
+
+
+
+
+
+
+
     try:
         template_id = render_plan.get("templateId", "?")
         title = render_plan.get("title", "")
@@ -2515,12 +2515,12 @@ def _log_render_plan_summary(render_plan: dict) -> None:
             file=sys.stderr,
         )
     except Exception:
-        # A summary is a convenience, never a hard dependency of rendering.
+
         pass
 
 
 def main():
-    # 无论正常结束、sys.exit 还是中途失败，都在最后报一次积分账（无扣费时静默）。
+
     atexit.register(print_billing_footer)
     parser = argparse.ArgumentParser(
         description="Video render tool — DSL + TemplateBinding → Remotion video.",
@@ -2564,8 +2564,8 @@ Examples:
     parser.add_argument(
         "--renderer",
         choices=["local", "remote"],
-        # 只有显式等于 local 才本地渲染；空串 / 拼写错误 / 未设一律 remote，
-        # 避免 Nacos 里该键为空值时静默掉进 local 模式（本地渲染需容器内自带 renderer）。
+
+
         default=(os.environ.get("REMOTION_RENDER_MODE") or "remote").strip().lower(),
         help="Render mode: remote=call the remote renderer service (default); local=local Remotion CLI (needs Node.js 18+)",
     )
@@ -2573,9 +2573,9 @@ Examples:
         "--remote-poll-timeout",
         type=float,
         default=float(os.environ.get("REMOTION_REMOTE_POLL_TIMEOUT", "2700")),
-        # 实测最长的一支约 30 分钟，加上 ab-render 排队要留余量，所以是 45 分钟。
-        # 这个值必须小于 ab-agent 侧 render_video 的 skill 超时（默认 50 分钟），
-        # 否则外层先 SIGTERM，这里这套"超时但保留 taskId"的续跑逻辑根本轮不到执行。
+
+
+
         help="Remote-render polling timeout (seconds, default 2700)",
     )
     parser.add_argument(
@@ -2598,25 +2598,25 @@ Examples:
     args = parser.parse_args()
 
     private_token = args.priv_token or os.environ.get("PRIV_TOKEN", "")
-    # The registry loader shares the environment-based auth entry point. Keep
-    # explicit CLI credentials consistent with render_job_client's token.
+
+
     if args.priv_token:
         os.environ["PRIV_TOKEN"] = private_token
 
-    # --save-job 默认开启，但若没有 PRIV_TOKEN 则自动降级为关闭，避免阻塞无 token 的本地调试。
+
     if args.save_job and not private_token:
         LogPrint("ℹ️  PRIV_TOKEN not configured; --save-job auto-disabled (will not write to database)", file=sys.stderr)
         args.save_job = False
 
     if args.job_id is not None and args.job_id > 0:
-        # ── Load RenderPlan from the database ─────────────────────────────
+
         LogPrint(f"📋 loading RenderPlan from database (jobId={args.job_id})...", file=sys.stderr)
         if not private_token:
             LogPrint("❌ --job-id mode requires PRIV_TOKEN or --priv-token", file=sys.stderr)
             sys.exit(1)
-        # render_job_client lives in skills/template-registry/scripts/ (the shared
-        # location for cross-skill helpers); it is already on sys.path via the
-        # module-top setup.
+
+
+
         from render_job_client import get_plan as rjc_get_plan
         try:
             render_plan_str = rjc_get_plan(args.job_id, private_token)
@@ -2633,10 +2633,10 @@ Examples:
         render_plan = load_json(args.render_plan)
         LogPrint(f"📋 loaded existing RenderPlan: {args.render_plan}", file=sys.stderr)
         _log_render_plan_summary(render_plan)
-        # 陈旧文件防护：output/render-plan.json 等共享文件名常被上一次别的项目
-        # 的运行残留覆盖（output/ 是 gitignored 调试目录）。当用户同时给了 --dsl
-        # 用以表明"我想渲这个 DSL"，但磁盘上的 plan 比 DSL 还旧时，几乎可以肯定
-        # 加载到的是过期 plan —— 明确警告而不是静默渲染错的东西。
+
+
+
+
         if args.dsl and os.path.exists(args.dsl):
             try:
                 if os.path.getmtime(args.render_plan) < os.path.getmtime(args.dsl):
@@ -2669,25 +2669,25 @@ Examples:
             )
             sys.exit(1)
 
-        # 解析 DSL：优先 --dsl-json（inline），其次 --dsl（文件路径）
+
         if args.dsl_json:
             try:
-                # 规范化 LLM 可能输出的全角/中文标点 → 标准 ASCII，避免 JSON 解析失败
+
                 _dsl_str = args.dsl_json
-                # 中文引号 → ASCII 引号
+
                 _dsl_str = _dsl_str.replace('\u201c', '"').replace('\u201d', '"')
                 _dsl_str = _dsl_str.replace('\u2018', "'").replace('\u2019', "'")
-                # 全角冒号/逗号/括号 → ASCII（最常见的 JSON 结构破坏者）
-                _dsl_str = _dsl_str.replace('\uff1a', ':')   # ： → :
-                _dsl_str = _dsl_str.replace('\uff0c', ',')   # ， → ,
-                _dsl_str = _dsl_str.replace('\uff08', '(')   # （ → (
-                _dsl_str = _dsl_str.replace('\uff09', ')')   # ） → )
-                _dsl_str = _dsl_str.replace('\u3010', '[')   # 【 → [
-                _dsl_str = _dsl_str.replace('\u3011', ']')   # 】 → ]
-                _dsl_str = _dsl_str.replace('\uff3b', '[')   # ［ → [
-                _dsl_str = _dsl_str.replace('\uff3d', ']')   # ］ → ]
-                _dsl_str = _dsl_str.replace('\uff5b', '{')   # ｛ → {
-                _dsl_str = _dsl_str.replace('\uff5d', '}')   # ｝ → }
+
+                _dsl_str = _dsl_str.replace('\uff1a', ':')
+                _dsl_str = _dsl_str.replace('\uff0c', ',')
+                _dsl_str = _dsl_str.replace('\uff08', '(')
+                _dsl_str = _dsl_str.replace('\uff09', ')')
+                _dsl_str = _dsl_str.replace('\u3010', '[')
+                _dsl_str = _dsl_str.replace('\u3011', ']')
+                _dsl_str = _dsl_str.replace('\uff3b', '[')
+                _dsl_str = _dsl_str.replace('\uff3d', ']')
+                _dsl_str = _dsl_str.replace('\uff5b', '{')
+                _dsl_str = _dsl_str.replace('\uff5d', '}')
                 dsl = json.loads(_dsl_str)
             except json.JSONDecodeError as e:
                 LogPrint(f"❌ --dsl-json parse failed: {e}", file=sys.stderr)
@@ -2698,14 +2698,14 @@ Examples:
                 sys.exit(1)
             dsl = load_json(args.dsl)
 
-        # 自动补全 version 字段（LLM 重构 DSL 时可能遗漏）
+
         if "version" not in dsl:
             dsl["version"] = "v1alpha1"
             LogPrint("⚠️  DSL missing version field; auto-filled with v1alpha1", file=sys.stderr)
 
-        # 骨架检查：防止 gen_script 原始骨架被直接提交（音频旁白不一致 bug）。
-        # agent.ts 已经在 MCP 层做了拦截，这里是第二道保险，兼容绕过 agent 直接调用的场景。
-        # narration.text 是唯一权威来源，所以只检查 scenes[].audio.narration。
+
+
+
         _skeleton_offenders: list[str] = []
         _skel_markers = ("[骨架待填充]", "[skeleton placeholder]", "这是需要替换的占位文案")
         for _scene in dsl.get("scenes", []) or []:
@@ -2730,20 +2730,20 @@ Examples:
             )
             sys.exit(2)
 
-        # ── 按引用注入模板声明的大 payload（必须在校验之前）─────────────
-        #
-        # 按引用注入的模板画面数据（payloadHydration.payloadField 指定的字段：一整页
-        # 的节点树、坐标、配色、beats）只有一个合法产出方 —— ab-render 的 /extract layout 层，
-        # 而它体积大到不能过模型（一页几百 KB，23 页好几 MB）。所以 DSL 里只带一个
-        # 引用（meta.sourceDocument），在这里把全量取回来填进每个场景。
-        #
-        # 为什么必须在 validate_dsl 之前：那道校验读的就是 capabilities.payloadRequirements
-        # 的必填项。放在后面 = 每次都被自己还没填的字段拒掉（2026-09-23 线上
-        # conv_Sesw2g8oM81 的表现就是 scenes[0..19].customPayload.slide (required)）。
+
+
+
+
+
+
+
+
+
+
         _hydrate_dsl_payload(dsl, args.template_id, args.source_document_url)
 
-        # compose 模式模板：agent 只写了画面主体，这里拼上模板画风（旁白此刻已定稿）。
-        # --job-id / --render-plan 不走这里：计划已落库，不再改 prompt。
+
+
         _compose_image_prompts(dsl, args.template_id)
 
         errors = validate_dsl(dsl)
@@ -2753,19 +2753,19 @@ Examples:
                 LogPrint(f"   - {err}", file=sys.stderr)
             sys.exit(1)
 
-        # binding 由 --template-id 现算，不再接受外部 binding 文件 / JSON。
-        # 这是 P1.1 的关键简化：DSL → RenderPlan 之间不再有独立工件，
-        # 直接 (DSL + templateId + registry) → RenderPlan。
-        # binding 仅在内存中作为中间态使用，不落盘、不入库。需要排查时
-        # 直接 print(binding) 即可。
+
+
+
+
+
         binding = auto_bind_template(dsl, args.template_id)
 
         LogPrint(f"📋 Building RenderPlan...", file=sys.stderr)
         render_plan = build_render_plan(dsl, binding)
         render_plan["_dsl_assets"] = dsl.get("assets", [])
 
-    # Job/file mode bypasses auto_bind_template. Validate saved plans too, so a
-    # previously accepted placeholder-only plan cannot silently render again.
+
+
     if args.job_id or args.render_plan:
         from registry_loader import get_template
         from required_props import validate_required_props
@@ -2787,9 +2787,9 @@ Examples:
         sys.exit(2)
 
     if not args.skip_asset_resolve:
-        # Stub mode: short-circuit gen-image / gen-video before counting pending.
-        # CLI flag takes precedence; env vars act as fallback with a visible warning
-        # so silent cross-session leakage is always observable.
+
+
+
         stub_image_url = args.stub_image_url
         stub_video_url = args.stub_video_url
         if stub_image_url is None:
@@ -2815,16 +2815,16 @@ Examples:
                 LogPrint(f"🧪 Stub mode is on but no matching assets were found (no pending gen-image / gen-video resources)", file=sys.stderr)
         pending_count = sum(1 for a in render_plan["resolvedAssets"] if a["status"] == "pending")
         if pending_count > 0:
-            # ── Token pre-check ───────────────────────────────────────────
-            # Fail fast with a clear message instead of letting child
-            # processes silently hang waiting for interactive token input.
+
+
+
             if not private_token:
                 LogPrint("❌ asset generation needs an auth token, but PRIV_TOKEN env var is not set and --priv-token was not passed", file=sys.stderr)
                 LogPrint("   configure it one of these ways:", file=sys.stderr)
                 LogPrint("   1. export PRIV_TOKEN=<your-token>", file=sys.stderr)
                 LogPrint("   2. python3 render_video.py --priv-token <your-token> ...", file=sys.stderr)
                 sys.exit(1)
-            # ──────────────────────────────────────────────────────────────
+
             LogPrint(f"🔍 Resolving {pending_count} missing asset(s)...", file=sys.stderr)
             render_plan = resolve_assets(
                 render_plan,
@@ -2839,8 +2839,8 @@ Examples:
 
     if not args.skip_asset_resolve:
         render_plan = adjust_timeline_to_audio(render_plan)
-        # 数字人按连续段生成要用到排轴后的场景时长，所以排在 adjust 之后；
-        # 它还要读 DSL 里的资产 payload，_dsl_assets 因此晚一步再丢。
+
+
         render_plan = resolve_digital_human_segments(
             render_plan,
             private_token=private_token,
@@ -2853,32 +2853,32 @@ Examples:
     output_path = os.path.join(OUTPUT_DIR, "video.mp4")
     rp_output = args.render_plan_output or os.path.join(OUTPUT_DIR, "render-plan.json")
 
-    # --save-job 模式下 RenderPlan 只存数据库，不写磁盘（避免多用户并发时互相覆盖同名文件）
+
     if args.save_render_plan or not args.save_job:
         validate_and_fix_render_plan(render_plan)
         save_json(render_plan, rp_output)
         LogPrint(f"💾 RenderPlan saved: {rp_output}", file=sys.stderr)
 
-    # ── 保存 RenderPlan 到数据库 ──────────────────────────────────────────
-    # 默认 args.save_job=True，所以无论 --resolve-only 还是直接渲染，都会落库；
-    # 没有 PRIV_TOKEN 时已在 main 入口降级为 False。
+
+
+
     if args.save_job:
-        # 入库前校验 + 自动修复
+
         validate_and_fix_render_plan(render_plan)
 
         from render_job_client import create_job as rjc_create_job, save_plan as rjc_save_plan
         render_plan_json_str = json.dumps(render_plan, ensure_ascii=False)
-        # 若已有 job_id 则复用，否则新建
+
         _job_id = args.job_id
         if not _job_id:
-            # 构造 DB 列 dsl_meta（轻量摘要供列表查询使用）。
-            # 单一来源是 dsl.meta — render_plan 里只放渲染必需的最小集，不再缓存整段 meta。
+
+
             _locals = locals()
             _dsl_obj = _locals.get("dsl")
             _binding_obj = _locals.get("binding")
             _meta_summary: dict = {}
-            # 直接渲染（--render-plan / --job-id）这种路径下没有 dsl 对象，
-            # 退而用 render_plan 里的字段拼一份摘要，保证列表页有可读信息。
+
+
             if _dsl_obj:
                 _src_meta = (_dsl_obj.get("meta") or {})
                 for _k in ("title", "topic", "platform", "templateId", "targetDuration"):
@@ -2916,7 +2916,7 @@ Examples:
             try:
                 rjc_save_plan(_job_id, render_plan_json_str, private_token)
                 LogPrint(f"✅ RenderPlan saved to database: jobId={_job_id}", file=sys.stderr)
-                # 把回填的 job_id 暴露给后续 saveManifest 使用
+
                 args.job_id = _job_id
                 print(f"\n📦 render job jobId: {_job_id}")
             except RuntimeError as e:
@@ -2933,7 +2933,7 @@ Examples:
         target_dur = render_plan.get("targetDuration")
         actual_dur = render_plan.get("renderConfig", {}).get("totalDuration", 0)
 
-        # ── 摘要输出到 stdout，供 Agent 读取资产 URL（不要改为 LogPrint/stderr）──
+
         print(f"\n📊 Asset resolution finished: total {total}, generated {generated}, failed {failed}")
         if target_dur:
             diff = actual_dur - target_dur
@@ -2965,9 +2965,9 @@ Examples:
                 url = asset.get("url", "")
                 print(f"   {asset['assetId']:<25} {url}")
 
-        # 数字人段也要列出来：模型按这里写成片总结。线上出过 DSL 里没有数字人、
-        # 模型却照着自己的意图汇报「数字人出镜」的事（conv_lvFaCClP7HrW5gDOZU1e），
-        # 没有这一节时它无从核对。没有数字人时明说，而不是什么都不打。
+
+
+
         avatar_assets = [a for a in render_plan.get("resolvedAssets", []) if a.get("type") == "avatar"]
         avatar_scenes: dict = {}
         for entry in render_plan.get("timeline", []):
@@ -2981,7 +2981,7 @@ Examples:
                 print(f"   {asset['assetId']:<25} {asset.get('status', '?'):<10} scenes: {scenes_on}  {asset.get('url', '')}")
         else:
             print(f"\n🧑 Digital-human segments: none (this render has no presenter)")
-        # ─────────────────────────────────────────────────────────────────────
+
 
         if failed > 0:
             sys.exit(1)
@@ -2999,9 +2999,9 @@ Examples:
         or render_plan.get("title")
         or os.path.splitext(os.path.basename(output_path))[0]
     )
-    # 阿里云 VOD 与 ab-api DTO 都按"字符数"限制 title 长度（max=128）。
-    # DSL 的 meta.title 经常是一段长描述（gen-script 把 topic 直接当 title），
-    # 这里截断到 128，避免远程渲染跑完之后栽在 CreateUploadVideoToken 校验上。
+
+
+
     if upload_title_hint and len(upload_title_hint) > 128:
         upload_title_hint = upload_title_hint[:128]
     conversation_id = os.environ.get("CONVERSATION_ID") or None
@@ -3025,7 +3025,7 @@ Examples:
         render_plan["renderMode"] = "local"
         success = render_with_local_cli(render_plan, output_path)
 
-    # save-job 模式下 RenderPlan 只入库；非 save-job 才写共享磁盘
+
     if not args.save_job:
         save_json(render_plan, rp_output)
 
@@ -3041,7 +3041,7 @@ Examples:
         "sceneCount": len(render_plan["timeline"]),
         "errorCount": len(render_plan["errors"]),
     }
-    # --save-job 模式下 Manifest 只存数据库，不写磁盘（避免多用户并发时互相覆盖同名文件）
+
     manifest_path = None if args.save_job else os.path.join(OUTPUT_DIR, "render-manifest.json")
     if manifest_path:
         save_json(manifest, manifest_path)
@@ -3055,26 +3055,26 @@ Examples:
             LogPrint(f"   Remote video: {remote_url}", file=sys.stderr)
             if playback_url:
                 LogPrint(f"   Playback URL: {playback_url}", file=sys.stderr)
-            # Print the playable video URL to stdout; prefer the transcoded playbackUrl.
+
             effective_playback = playback_url or remote_url
             if effective_playback and not effective_playback.startswith("vod://"):
                 print(f"\n🎬 Video playback URL: {effective_playback}")
-                # 封面也走 stdout：Codex / Claude Code 等没有内联播放器的宿主只能从
-                # 这里拿到封面地址（之前只打到 stderr，模型回复里因此只有视频没有封面）。
+
+
                 if upload_info.get("coverUrl"):
                     print(f"🖼️ Cover image URL: {upload_info['coverUrl']}")
 
-                # 结构化资产标记 —— 宿主（ab-agent）据此把权威 URL 作为 attachment
-                # 下发前端渲染播放器，绕开模型正文。
-                #
-                # 为什么必须绕开：模型复述 32 位不透明 hex 会出错。2026-08-30 实测一次
-                # 成片链接被吞掉一个字符（…c1c20102 → …c1c2012），用户拿到 404，
-                # 而文件本身好好地在 CDN 上。约定与 web-screenshot/scripts/record.py
-                # 的 __web_record_asset__ 一致。
-                #
-                # 只在拿到**非 vod:// 的真实播放地址**时才打标记（上面的 if 已保证）：
-                # playbackUrl 来自 VOD 轮询，可能超时未就绪。宁可前端没有内联播放器
-                # （用户仍可从成片面板看），也不要再给出一条不可用的地址。
+
+
+
+
+
+
+
+
+
+
+
                 asset = {"url": effective_playback}
                 cover = upload_info.get("coverUrl")
                 if cover:
@@ -3093,7 +3093,7 @@ Examples:
             LogPrint(f"   Manifest: {manifest_path}", file=sys.stderr)
 
         if render_mode == "remote":
-            # In remote mode the fileUrl came from the server; reuse it into the manifest.
+
             manifest["upload"] = render_plan.get("upload", {})
             if manifest_path:
                 save_json(manifest, manifest_path)
@@ -3114,10 +3114,10 @@ Examples:
                     "fileUrl": upload_result["fileUrl"],
                     "title": upload_title,
                     "uploadedAt": now_iso(),
-                    # ab-api 保存 manifest 时按 fileId 给成片建语义卡 / 片段 / 血缘
+
                     "fileId": upload_result.get("fileId"),
                 }
-                # 本地渲染 + 上传成功时同样把地址放到 stdout，供无播放器的宿主回显给用户
+
                 if upload_result.get("fileUrl"):
                     print(f"\n🎬 Video playback URL: {upload_result['fileUrl']}")
                 if manifest_path:
@@ -3126,7 +3126,7 @@ Examples:
             except Exception as e:
                 LogPrint(f"\n⚠️  upload failed (the video stays local): {e}", file=sys.stderr)
 
-        # ── Save Manifest to the database ────────────────────────────────
+
         if args.save_job and args.job_id:
             from render_job_client import save_manifest as rjc_save_manifest
             try: