@remixmate/cli 0.1.0

package/skills/gen-script/scripts/gen_script.py

@@ -0,0 +1,1208 @@
+#!/usr/bin/env python3
+"""
+Video script generator — turns a topic into Video DSL v1alpha1 JSON.
+
+Default behavior:
+  Produces a structured Video DSL JSON to stdout based on the topic, platform,
+  duration, and other constraints.
+
+Usage:
+  python gen_script.py --topic "3 AI hacks that double study efficiency" --duration 30 --ratio "9:16"
+  python gen_script.py --validate --input my-video.dsl.json
+
+Environment variables:
+  VIDEO_DSL_SCHEMA_PATH - DSL schema file path
+    (default: skills/template-bind/video_dsl/schema/video-dsl-v1alpha1.json)
+"""
+
+import argparse
+import json
+import math
+import os
+import sys
+import uuid
+
+SCHEMA_PATH = os.environ.get(
+    "VIDEO_DSL_SCHEMA_PATH",
+    "skills/template-bind/video_dsl/schema/video-dsl-v1alpha1.json",
+)
+
+# prompt_enhancer 路径动态添加
+_TEMPLATE_DSL_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "template-bind", "video_dsl")
+if os.path.isdir(_TEMPLATE_DSL_DIR):
+    sys.path.insert(0, os.path.abspath(os.path.join(_TEMPLATE_DSL_DIR, "..")))
+
+# Shared Python lib lives under skills/template-bind/scripts/ — the de-facto
+# cross-skill module location (registry_loader, template_paths, etc.). Named
+# generically here so its host skill could be renamed without touching every
+# caller. See AGENTS.md for the convention.
+_SHARED_SCRIPTS_DIR = os.path.join(
+    os.path.dirname(__file__), "..", "..", "template-bind", "scripts"
+)
+if os.path.isdir(_SHARED_SCRIPTS_DIR):
+    sys.path.insert(0, os.path.abspath(_SHARED_SCRIPTS_DIR))
+
+try:
+    from video_dsl.runtime.prompt_enhancer import build_enhanced_prompt
+    _HAS_ENHANCER = True
+except ImportError:
+    _HAS_ENHANCER = False
+
+try:
+    from registry_loader import (
+        load_registry_data as _load_registry_data,
+        get_template as _get_template,
+    )
+    _HAS_REGISTRY_LOADER = True
+except ImportError:
+    _HAS_REGISTRY_LOADER = False
+
+try:
+    # Centralized monorepo-path resolver living in template-bind/scripts/;
+    # the import works because the same sys.path.insert above pointed at it.
+    from template_paths import monorepo_template_src_dir as _monorepo_template_src_dir
+except ImportError:
+    _monorepo_template_src_dir = None
+
+VALID_PLATFORMS = ["douyin", "xiaohongshu", "bilibili", "wechat", "youtube", "generic"]
+VALID_RATIOS = ["16:9", "9:16", "1:1", "4:3", "3:4", "21:9"]
+VALID_PURPOSES = ["opening", "point", "example", "explanation", "highlight", "cta", "ending"]
+
+CHARS_PER_SECOND = 5.0  # 与 timeline_compiler.py 保持一致（中文约 5 字/秒）
+
+# ── Language contract (mirrors apps/ab-skill/src/handlers/template-meta.ts) ──
+# template.json may declare:
+#   - outputLanguage: "en" | "zh"   default "zh" when missing/invalid
+#   - defaultVoiceId: string        default None when missing/empty
+# Read tolerantly: any failure returns the legacy zh defaults plus a stderr warning.
+
+DEFAULT_LANGUAGE = "zh"
+LANGUAGE_TO_META = {"en": "en-US", "zh": "zh-CN"}
+
+# Fallback voices keyed by output language. Mirrors voice-resolver.ts FALLBACK_VOICE.
+# zh keeps the legacy default that's been used everywhere; en is a placeholder
+# until the gen-voice service confirms the right English voice id.
+FALLBACK_VOICE = {
+    "zh": "Chinese (Mandarin)_Male_Announcer",
+    # TODO: confirm an English voice id against gen-voice service before shipping.
+    "en": "english-male-friendly-01",
+}
+
+
+def _resolve_template_language_meta(template_config):
+    """Tolerant reader for outputLanguage / defaultVoiceId on a template dict.
+
+    Returns (language, default_voice_id). Never raises. Logs a single stderr
+    warning when fields are present but malformed.
+    """
+    if not isinstance(template_config, dict):
+        return DEFAULT_LANGUAGE, None
+    raw_lang = template_config.get("outputLanguage")
+    if raw_lang in ("en", "zh"):
+        language = raw_lang
+    else:
+        if raw_lang is not None:
+            print(
+                f"⚠️  unrecognized outputLanguage={raw_lang!r} on template; defaulting to {DEFAULT_LANGUAGE}",
+                file=sys.stderr,
+            )
+        language = DEFAULT_LANGUAGE
+    raw_voice = template_config.get("defaultVoiceId")
+    if isinstance(raw_voice, str) and raw_voice.strip():
+        default_voice_id = raw_voice.strip()
+    else:
+        default_voice_id = None
+    return language, default_voice_id
+
+
+def _resolve_voice_id(cli_voice_id, template_default_voice_id, language):
+    """Mirror of voice-resolver.ts resolveVoiceId. Total function.
+
+    Order: explicit CLI override → template defaultVoiceId → language fallback.
+    """
+    if isinstance(cli_voice_id, str) and cli_voice_id.strip():
+        return cli_voice_id.strip()
+    if isinstance(template_default_voice_id, str) and template_default_voice_id.strip():
+        return template_default_voice_id.strip()
+    return FALLBACK_VOICE.get(language, FALLBACK_VOICE[DEFAULT_LANGUAGE])
+
+
+def _check_narration_language(narrations, expected):
+    """Non-blocking sanity check: warn when narration looks like the wrong language.
+
+    Skips strings that start with NARRATION_SKELETON_MARKER or its English variant —
+    those are gen_script placeholders the agent will replace with real narration
+    before sending to prepare_video_assets, so a language mismatch on them is expected.
+    """
+    cjk_re = __import__("re").compile(r"[\u4e00-\u9fff]")
+    latin_re = __import__("re").compile(r"[A-Za-z]")
+    skeleton_prefixes = (NARRATION_SKELETON_MARKER, "[skeleton placeholder]")
+    for text in narrations:
+        if not isinstance(text, str) or not text.strip():
+            continue
+        if text.lstrip().startswith(skeleton_prefixes):
+            continue
+        has_cjk = bool(cjk_re.search(text))
+        has_latin = bool(latin_re.search(text))
+        if expected == "en" and has_cjk:
+            print(
+                "⚠️  narration contains CJK characters but template outputLanguage=en",
+                file=sys.stderr,
+            )
+            break
+        if expected == "zh" and has_latin and not has_cjk:
+            print(
+                "⚠️  narration looks non-Chinese but template outputLanguage=zh",
+                file=sys.stderr,
+            )
+            break
+
+
+def _localize_label(language, key, **fmt):
+    """Tiny localization helper for the on-screen / narration default strings.
+
+    Keeps the template-driven outputLanguage as the single source of truth: zh
+    templates keep their legacy Chinese phrasing, en templates emit English. We
+    deliberately keep the table small — anything more elaborate belongs in the
+    LLM prompt, not in this fallback skeleton.
+    """
+    table = {
+        "label_opening": {"zh": "开场 Hook", "en": "Opening hook"},
+        "label_point":   {"zh": "内容要点 {n}", "en": "Point {n}"},
+        "label_cta":     {"zh": "结尾 CTA", "en": "Closing CTA"},
+        "narration_opening": {
+            "zh": "[骨架待填充] 关于{topic}的开场 Hook({duration}s)",
+            "en": "[skeleton placeholder] Opening hook about {topic} ({duration}s)",
+        },
+        "narration_point": {
+            "zh": "[骨架待填充] {label}:关于{topic}的一个要点({duration}s)",
+            "en": "[skeleton placeholder] {label}: a point about {topic} ({duration}s)",
+        },
+        "narration_cta": {
+            "zh": "[骨架待填充] 关于{topic}的 CTA 结尾({duration}s)",
+            "en": "[skeleton placeholder] Closing CTA about {topic} ({duration}s)",
+        },
+        "narration_default": {
+            "zh": "[骨架待填充] 关于{topic}的内容({duration}s)",
+            "en": "[skeleton placeholder] Content about {topic} ({duration}s)",
+        },
+        "point_description": {
+            "zh": "关于{topic}的要点内容",
+            "en": "A key point about {topic}",
+        },
+        "follow_us": {"zh": "关注我们", "en": "Follow us"},
+        "more_about": {"zh": "更多关于{topic}的内容", "en": "More about {topic}"},
+        "video_description": {
+            "zh": "关于「{topic}」的{duration}秒短视频",
+            "en": "A {duration}s short video about \"{topic}\"",
+        },
+    }
+    entry = table.get(key, {})
+    template = entry.get(language) or entry.get(DEFAULT_LANGUAGE) or ""
+    return template.format(**fmt)
+
+
+def load_schema():
+    if not os.path.exists(SCHEMA_PATH):
+        return None
+    with open(SCHEMA_PATH, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def validate_dsl(dsl: dict) -> list:
+    """Structural DSL validation — delegates to the unified validator.
+
+    Historical rule set (preserved verbatim by ``validate_structural``):
+      version + meta(title) + global presence + scene count 1–20 + each
+      scene's ``id`` and ``purpose``. Asset integrity, enum membership and
+      picture-book-en checks are intentionally NOT enforced here — those
+      live in ``validate_dsl`` / ``validate_integrity`` and only run at
+      their respective historical call sites.
+    """
+    from video_dsl.runtime.dsl_validator import (  # noqa: E402
+        validate_structural,
+        errors_as_strings,
+    )
+    return errors_as_strings(validate_structural(dsl))
+
+
+def plan_scenes(topic: str, duration: int, scene_count: int | None, allow_digital_human: bool, language: str = DEFAULT_LANGUAGE) -> list:
+    """Plan scene structure based on topic and constraints."""
+    if scene_count is None:
+        if duration <= 15:
+            scene_count = 3
+        elif duration <= 30:
+            scene_count = 5
+        elif duration <= 60:
+            scene_count = 7
+        else:
+            scene_count = min(10, duration // 8)
+
+    scene_count = max(3, min(scene_count, 20))
+
+    scenes = []
+    content_scenes = scene_count - 2
+
+    opening_duration = max(3, round(duration * 0.12))
+    ending_duration = max(3, round(duration * 0.12))
+    content_total = duration - opening_duration - ending_duration
+    per_content = max(3, round(content_total / content_scenes))
+
+    scenes.append({
+        "purpose": "opening",
+        "duration": opening_duration,
+        "label": _localize_label(language, "label_opening"),
+    })
+
+    for i in range(content_scenes):
+        scenes.append({
+            "purpose": "point",
+            "duration": per_content,
+            "label": _localize_label(language, "label_point", n=i + 1),
+        })
+
+    scenes.append({
+        "purpose": "cta",
+        "duration": ending_duration,
+        "label": _localize_label(language, "label_cta"),
+    })
+
+    return scenes
+
+
+def estimate_narration_text(label: str, purpose: str, duration: int, topic: str, language: str = DEFAULT_LANGUAGE) -> str:
+    """Generate a short skeleton narration hint for a scene.
+
+    This returns a *skeleton only* — the agent is expected to replace this
+    text with real narration before submitting DSL to prepare_video_assets. We
+    deliberately return a short, clearly-placeholder-looking string rather
+    than padding to duration × CHARS_PER_SECOND, because padding with a
+    repeating filler sentence historically caused the skeleton to be
+    submitted verbatim to TTS (audio narration mismatch bug).
+    """
+    fmt = {"label": label, "topic": topic, "duration": duration}
+    if purpose == "opening":
+        return _localize_label(language, "narration_opening", **fmt)
+    if purpose == "point":
+        return _localize_label(language, "narration_point", **fmt)
+    if purpose == "cta":
+        return _localize_label(language, "narration_cta", **fmt)
+    return _localize_label(language, "narration_default", **fmt)
+
+
+# 骨架标记：出现此前缀说明 narration 仍是 gen_script 原始骨架，未被 agent 填充真实内容
+NARRATION_SKELETON_MARKER = "[骨架待填充]"
+
+
+def generate_image_prompt(
+        purpose: str, topic: str, style: str, narration_text: str = "", style_guide: dict | None = None
+) -> dict:
+    """Generate image prompt for a scene.
+
+    Returns dict with keys: prompt, and optionally negativePrompt, guidanceScale.
+    """
+    if _HAS_ENHANCER:
+        return build_enhanced_prompt(
+            purpose=purpose,
+            topic=topic,
+            style=style,
+            narration_text=narration_text,
+            style_guide=style_guide,
+        )
+
+    # 降级：无 enhancer 时使用原逻辑
+    style_suffix = f"，{style}风格" if style else ""
+    prompts = {
+        "opening": f"{topic}主题概念图，吸引眼球的视觉效果{style_suffix}，高清大图",
+        "point": f"与{topic}相关的场景插画{style_suffix}，信息图表风格",
+        "cta": f"关注点赞互动图标{style_suffix}，简洁现代设计",
+    }
+    return {"prompt": prompts.get(purpose, f"{topic}相关配图{style_suffix}")}
+
+
+def _load_template_config(template_id: str) -> dict | None:
+    """Load template definition for the given template ID.
+
+    解析顺序（与 match_template / template_binder 保持一致）：
+      1. 通过 registry_loader 从 monorepo template-library/packages/metadata/registry.json
+         （或 VIDEO_TEMPLATE_REGISTRY[_URL] 环境变量）加载，并按 templateId 匹配。
+      2. 兜底：旧路径 apps/ab-skill/skills/template-bind/video_dsl/templates/<id>/template.json
+         （仅在仓库还残留旧目录时使用）。
+    返回完整 template dict（含 supportedAspectRatios / assetRequirements / slotMapping 等），
+    找不到时返回 None。
+    """
+    # 优先使用 registry_loader（这是模板元数据的唯一权威来源）
+    if _HAS_REGISTRY_LOADER:
+        try:
+            return _get_template(template_id)
+        except Exception as exc:
+            print(
+                f"⚠️  registry_loader failed, falling back to local template.json: {exc}",
+                file=sys.stderr,
+            )
+
+    # 兜底：旧的本地目录布局
+    legacy_dir = os.path.join(
+        os.path.dirname(__file__), "..", "..", "template-bind", "video_dsl", "templates"
+    )
+    legacy_file = os.path.join(legacy_dir, template_id, "template.json")
+    if os.path.isfile(legacy_file):
+        with open(legacy_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return None
+
+
+def _template_supported_ratio(template_config: dict | None) -> str | None:
+    """Return template 的首选宽高比。
+
+    如果模板声明了 supportedAspectRatios，返回数组首项作为推荐值；
+    否则返回 None，由调用方使用全局默认（16:9）。
+    """
+    if not template_config:
+        return None
+    ratios = template_config.get("supportedAspectRatios") or []
+    for r in ratios:
+        if isinstance(r, str) and r in VALID_RATIOS:
+            return r
+    return None
+
+
+def _template_primary_visual_type(template_config: dict | None) -> str:
+    """从模板的 assetRequirements 推导每个 scene 的主要视觉素材类型。
+
+    返回值之一：
+      - "image" : 模板要求图片素材（默认通用 DSL 也是图片）
+      - "video" : 模板要求视频素材（assetRequirements 含 video 但不含 image）
+      - "none"  : 模板不需要任何视觉素材（如 html-slide 仅 audio）
+    """
+    if not template_config:
+        return "image"  # 默认：通用 DSL 走图片
+    requirements = template_config.get("assetRequirements") or []
+    if "image" in requirements:
+        return "image"
+    if "video" in requirements:
+        return "video"
+    return "none"
+
+
+def _template_needs_image(template_config: dict | None) -> bool:
+    """Check if a template requires image assets.
+
+    If assetRequirements is defined and does NOT include 'image', images are not needed.
+    """
+    if template_config is None:
+        return True  # default: generate images for generic DSL
+    requirements = template_config.get("assetRequirements", [])
+    return "image" in requirements
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Template-as-Contract: input-schema driven DSL assembly
+# ═══════════════════════════════════════════════════════════════════════════════
+#
+# 当模板目录下存在 input-schema.json 时，gen_script 用该 schema 动态组装 DSL，
+# 无需为每个模板写 if-else 分支。模板作者只需维护 input-schema.json + dsl-example.json。
+
+
+def _locate_template_dir(template_id: str) -> str | None:
+    """定位模板源码目录（template-library/packages/templates/src/<id>/）。
+
+    路径解析已集中到 ``template_paths.monorepo_template_src_dir``；
+    当 helper 不可用（template-bind/scripts/ 不在 sys.path）时回退到 None,
+    与原始函数"找不到就返回 None"的语义一致。
+    """
+    if _monorepo_template_src_dir is None:
+        return None
+    return _monorepo_template_src_dir(template_id)
+
+
+def _plain_len(text: str) -> int:
+    """剥离 **强调** 标记后的纯字符数（与渲染端 emphasis.plainLength 等价）。"""
+    return len((text or "").replace("**", ""))
+
+
+# fit-caption 时长估算常量 —— 与 template-library spotlight-card/utils/timing.ts
+# + estimateDuration.ts 保持同一套数值，避免上游估时与组件实际耗时漂移。
+_MAX_CPS_CAP = 60
+_DEFAULT_TAIL_HOLD_SEC = 1.5
+_TAIL_PADDING_SEC = 1.0
+_HEADLINE_INTRO_SEC = 1.0
+_CAROUSEL_MIN_PER_ITEM_SEC = 2.0
+_CAROUSEL_MIN_PER_VIDEO_SEC = 3.5
+
+
+def _estimate_caption_natural_sec(caption: dict) -> float:
+    """打字机自然节奏耗时（startDelay + 打字 + 行间停顿 + 收尾），秒。"""
+    lines = (caption.get("lines") or [])[:10]
+    if not lines:
+        return 0.0
+    natural_cps = max(4, min(80, caption.get("charsPerSec", 28)))
+    line_gap_sec = caption.get("lineGapMs", 350) / 1000.0
+    start_delay_sec = caption.get("startDelayMs", 600) / 1000.0
+    total_chars = sum(_plain_len(t) for t in lines)
+    inter_line_sec = line_gap_sec * max(0, len(lines) - 1)
+    fixed_overhead = start_delay_sec + inter_line_sec + _DEFAULT_TAIL_HOLD_SEC
+    return fixed_overhead + total_chars / natural_cps
+
+
+def _estimate_carousel_min_sec(carousel: dict) -> float:
+    """轮播至少需要的秒数（每张图/视频的最小停留，减去重叠的过渡）。"""
+    items = carousel.get("items") or []
+    n = len(items)
+    if n == 0:
+        return 0.0
+    transition_sec = carousel.get("transitionMs", 400) / 1000.0
+    explicit_pacing = carousel.get("pacing")
+    any_explicit = any(it.get("holdSec") is not None for it in items)
+    has_default_hold = carousel.get("defaultHoldSec") is not None
+    pacing = explicit_pacing or ("fixed" if (any_explicit or has_default_hold) else "auto")
+    if pacing == "fixed":
+        default_hold = carousel.get("defaultHoldSec", 3.0)
+        total = sum(it.get("holdSec", default_hold) for it in items)
+        return total - (n - 1) * transition_sec
+    total = sum(
+        _CAROUSEL_MIN_PER_VIDEO_SEC if it.get("kind") == "video" else _CAROUSEL_MIN_PER_ITEM_SEC
+        for it in items
+    )
+    return total - (n - 1) * transition_sec
+
+
+def _estimate_fit_caption_duration(custom_payload: dict) -> float:
+    """fit-caption 策略：按打字机 + 轮播 + 标题入场推算建议时长（秒）。
+
+    等价于 template-library 的 estimateSpotlightCardDuration().recommendedSec：
+    各组件并行，取 max 再加收尾留白。
+    """
+    caption = custom_payload.get("caption") or {}
+    carousel = custom_payload.get("carousel") or {}
+    caption_sec = _estimate_caption_natural_sec(caption)
+    carousel_sec = _estimate_carousel_min_sec(carousel)
+    recommended = max(_HEADLINE_INTRO_SEC, caption_sec, carousel_sec) + _TAIL_PADDING_SEC
+    return recommended
+
+
+def _load_input_schema(template_id: str) -> dict | None:
+    """Load input-schema.json for a template. Returns None if not found."""
+    tpl_dir = _locate_template_dir(template_id)
+    if not tpl_dir:
+        return None
+    schema_file = os.path.join(tpl_dir, "input-schema.json")
+    if not os.path.isfile(schema_file):
+        return None
+    try:
+        with open(schema_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (OSError, json.JSONDecodeError) as exc:
+        print(f"⚠️  failed to load input-schema.json for {template_id}: {exc}", file=sys.stderr)
+        return None
+
+
+def _build_dsl_from_input_schema(
+    *,
+    template_id: str,
+    template_config: dict,
+    input_schema: dict,
+    topic: str,
+    headline: str,
+    subheadline: str,
+    carousel_items: list[str],
+    caption_lines: list[str],
+    duration: int,
+    platform: str,
+    style: str,
+    ratio: str,
+    resolution: str,
+    voice_id: str,
+    output_language: str,
+    resolved_voice_id: str,
+) -> dict:
+    """Schema-driven DSL assembly.
+
+    Uses the template's input-schema.json + defaults to build a complete DSL
+    with the correct customPayload structure. No template-specific if-else.
+    """
+    defaults = input_schema.get("defaults", {})
+
+    # 旁白开关：部分模板（如 spotlight-card）是打字机 / 画面驱动，刻意无配音。
+    # 由 input-schema.json 的 narration.enabled 声明，缺省 True 保持其它 schema
+    # 模板的向后兼容。关闭时不产出 gen-voice 音频资产，scene 也不带 audio.narration，
+    # 这样 prepare_video_assets 不会触发 TTS、render_video 也不会按 TTS 拉长场景时长。
+    narration_enabled = bool(input_schema.get("narration", {}).get("enabled", True))
+
+    # ── Build assets from carousel_items ──────────────────────────────────
+    assets = []
+    carousel_asset_ids = []
+    for idx, url in enumerate(carousel_items):
+        asset_id = f"carousel-img-{idx + 1:02d}"
+        # Determine if URL is a video (basic heuristic on extension)
+        is_video = any(url.lower().endswith(ext) for ext in (".mp4", ".mov", ".webm", ".avi"))
+        assets.append({
+            "assetId": asset_id,
+            "type": "video" if is_video else "image",
+            "source": "existing",
+            "status": "generated",
+            "url": url,
+        })
+        carousel_asset_ids.append((asset_id, "video" if is_video else "image"))
+
+    # ── Narration asset (可选；仅在模板声明 narration.enabled 时产出) ───────
+    narration_asset_id = "narration-scene-01"
+    if narration_enabled:
+        assets.append({
+            "assetId": narration_asset_id,
+            "type": "audio",
+            "source": "gen-voice",
+            "status": "planned",
+            "payload": {
+                "voiceId": resolved_voice_id,
+            },
+        })
+
+    # ── Build carousel config ─────────────────────────────────────────────
+    carousel_defaults = defaults.get("carousel", {})
+    carousel_config = {
+        "items": [],
+        **carousel_defaults,
+    }
+    for asset_id, kind in carousel_asset_ids:
+        item = {
+            "assetRef": asset_id,
+            "entrance": carousel_defaults.get("defaultEntrance", "random"),
+            "exit": carousel_defaults.get("defaultExit", "random"),
+        }
+        if kind == "video":
+            item["kind"] = "video"
+            item["muted"] = True
+        carousel_config["items"].append(item)
+
+    # ── Build caption config ──────────────────────────────────────────────
+    caption_defaults = defaults.get("caption", {})
+    caption_config = {
+        "lines": caption_lines if caption_lines else [],
+        **caption_defaults,
+    }
+    # Override lines explicitly (defaults shouldn't clobber user-provided lines)
+    if caption_lines:
+        caption_config["lines"] = caption_lines
+
+    # ── Build customPayload ───────────────────────────────────────────────
+    custom_payload = {
+        "background": defaults.get("background", {"preset": "grid-particles"}),
+        "headlineStyle": defaults.get("headlineStyle", {"pill": True}),
+        "carousel": carousel_config,
+        "caption": caption_config,
+    }
+
+    # ── Narration skeleton ────────────────────────────────────────────────
+    narration_text = _localize_label(output_language, "narration_opening",
+                                     label="", topic=topic, duration=duration)
+
+    # ── Effective scene duration ──────────────────────────────────────────
+    # fit-caption 策略（input-schema.sceneStrategy.fixedScenes[].durationStrategy）：
+    # 时长由打字机自然节奏决定，而不是盲取调用方传入的 targetDuration。
+    # 这是 spotlight-card 这类打字机/画面驱动模板的核心——没有旁白来"撑"时长，
+    # 必须由 caption 自己定，否则文字打完后画面会静止到 targetDuration。
+    scene_strategy = input_schema.get("sceneStrategy", {})
+    fixed_scenes = scene_strategy.get("fixedScenes", [])
+    duration_strategy = (
+        fixed_scenes[0].get("durationStrategy") if fixed_scenes else None
+    )
+    effective_duration = duration
+    if duration_strategy == "fit-caption":
+        est = _estimate_fit_caption_duration(custom_payload)
+        if est > 0:
+            effective_duration = int(math.ceil(est))
+            print(
+                f"ℹ️  fit-caption: scene duration {effective_duration}s "
+                f"(estimated from caption/carousel; ignoring target {duration}s)",
+                file=sys.stderr,
+            )
+
+    # ── Build scene (spotlight-card uses a single scene) ──────────────────
+    text_layers = [
+        {"role": "headline", "content": headline, "animation": "slide-up"},
+    ]
+    if subheadline:
+        text_layers.append({"role": "subheadline", "content": subheadline, "animation": "fade-in"})
+
+    scene = {
+        "id": "scene-01",
+        "purpose": "opening",
+        "duration": effective_duration,
+        "layout": template_id,
+        "textLayers": text_layers,
+        "customPayload": custom_payload,
+    }
+    if narration_enabled:
+        scene["audio"] = {
+            "narration": {
+                "text": narration_text,
+                "assetRef": narration_asset_id,
+                "needsFill": True,
+            },
+        }
+
+    # ── Assemble full DSL ─────────────────────────────────────────────────
+    effective_headline = headline or topic
+    effective_subheadline = subheadline or ""
+
+    dsl = {
+        "version": "v1alpha1",
+        "meta": {
+            "title": topic,
+            "topic": topic,
+            "headline": effective_headline,
+            "subheadline": effective_subheadline,
+            "platform": platform,
+            "targetDuration": effective_duration,
+            "language": LANGUAGE_TO_META.get(output_language, "zh-CN"),
+            "outputLanguage": output_language,
+            "style": style or "",
+            "description": _localize_label(output_language, "video_description", topic=topic, duration=duration),
+            "templateId": template_id,
+        },
+        "global": {
+            "aspectRatio": ratio,
+            "resolution": resolution,
+            "fps": 30,
+            # 无配音模板：关闭 CC 字幕（字幕段是 narration→TTS 的派生物），
+            # 并省略 global.narration，避免下游误判存在旁白。
+            "subtitle": {"enabled": narration_enabled, "style": "bottom"},
+            **({"narration": {"voiceId": resolved_voice_id, "speed": 1.0}} if narration_enabled else {}),
+            "bgm": {"enabled": True, "volume": 0.12},
+        },
+        "assets": assets,
+        "scenes": [scene],
+        "transitions": {"default": "fade", "duration": 0.5},
+    }
+
+    return dsl
+
+
+def _build_custom_payload(purpose: str, topic: str, label: str, idx: int, total_scenes: int, language: str = DEFAULT_LANGUAGE) -> dict:
+    """Build customPayload with slideId and templateData for template-native scenes."""
+    if purpose == "opening":
+        return {
+            "slideId": "demo-concept-overview",
+            "templateData": {
+                "title": topic,
+            },
+        }
+    elif purpose == "cta":
+        return {
+            "slideId": "demo-concept-overview",
+            "templateData": {
+                "title": topic,
+            },
+        }
+    else:
+        palette = ["#6C5CE7", "#00B894", "#E17055", "#0984E3", "#FDCB6E", "#A29BFE", "#FF7675"]
+        return {
+            "slideId": "demo-single-concept",
+            "templateData": {
+                "icon": "💡",
+                "title": label,
+                "description": _localize_label(language, "point_description", topic=topic),
+                "accentColor": palette[idx % len(palette)],
+            },
+        }
+
+
+def build_dsl(
+        topic: str,
+        platform: str,
+        duration: int,
+        style: str,
+        ratio: str,
+        resolution: str,
+        voice_id: str,
+        scene_count: int | None,
+        allow_digital_human: bool,
+        allow_ai_video: bool,
+        template_id: str | None = None,
+        stub_image_url: str = "",
+        stub_video_url: str = "",
+        headline: str | None = None,
+        subheadline: str | None = None,
+        carousel_items: list[str] | None = None,
+        caption_lines: list[str] | None = None,
+) -> dict:
+    """Build a complete Video DSL JSON.
+
+    When template_id is provided, loads the template config and adapts the DSL
+    structure to match the template's assetRequirements and scene patterns.
+
+    If the template has an input-schema.json AND the caller provides structured
+    inputs (carousel_items / caption_lines), the schema-driven assembly path is
+    used — producing a template-native DSL without any template-specific if-else.
+
+    headline / subheadline 让作者显式提供画面上的"短主标题 + 副标题"。
+    DSL 元字段命名约定：
+      - meta.headline    画面上的主标题（建议 4-12 字）。默认退回 topic
+      - meta.subheadline 画面上的副标题（项目名 / 一句标语 / 来源）。默认 ""
+    模板的 textLayers[role=headline|subheadline] 会取这两个字段，propExtractors
+    通过 role=headline / role=subheadline 抽出对应的 props（如 titleText / projectName）。
+    注意：subtitle（CC 字幕）由 global.subtitle 与 render-plan.subtitleSegments
+    单独承载，与 subheadline 完全是两个东西，命名上刻意分开避免歧义。
+    """
+    # Load template config to determine asset requirements
+    template_config = _load_template_config(template_id) if template_id else None
+
+    # ── Schema-driven path: if input-schema.json exists AND structured inputs provided ──
+    if template_id and (carousel_items or caption_lines):
+        input_schema = _load_input_schema(template_id)
+        if input_schema and template_config:
+            # Resolve language + voice (same logic as generic path)
+            output_language, template_default_voice_id = _resolve_template_language_meta(template_config)
+            resolved_voice_id = _resolve_voice_id(voice_id, template_default_voice_id, output_language)
+            if resolved_voice_id != voice_id:
+                print(
+                    f"ℹ️  voice resolution: cli={voice_id!r} → resolved={resolved_voice_id!r} "
+                    f"(templateDefault={template_default_voice_id!r}, language={output_language})",
+                    file=sys.stderr,
+                )
+            effective_headline = (headline or "").strip() or topic
+            effective_subheadline = (subheadline or "").strip()
+            print(
+                f"ℹ️  using input-schema driven assembly for template {template_id}",
+                file=sys.stderr,
+            )
+            return _build_dsl_from_input_schema(
+                template_id=template_id,
+                template_config=template_config,
+                input_schema=input_schema,
+                topic=topic,
+                headline=effective_headline,
+                subheadline=effective_subheadline,
+                carousel_items=carousel_items or [],
+                caption_lines=caption_lines or [],
+                duration=duration,
+                platform=platform,
+                style=style,
+                ratio=ratio,
+                resolution=resolution,
+                voice_id=voice_id,
+                output_language=output_language,
+                resolved_voice_id=resolved_voice_id,
+            )
+    primary_visual_type = _template_primary_visual_type(template_config)
+    has_visual = primary_visual_type in ("image", "video")
+
+    # ── Resolve template-driven output language + voice ────────────────────
+    # outputLanguage is owned by the template (template.json). Missing/invalid
+    # values fall back to "zh" so old templates keep their current behavior.
+    output_language, template_default_voice_id = _resolve_template_language_meta(template_config)
+    resolved_voice_id = _resolve_voice_id(voice_id, template_default_voice_id, output_language)
+    if resolved_voice_id != voice_id:
+        print(
+            f"ℹ️  voice resolution: cli={voice_id!r} → resolved={resolved_voice_id!r} "
+            f"(templateDefault={template_default_voice_id!r}, language={output_language})",
+            file=sys.stderr,
+        )
+
+    # 缺省值：headline 退回 topic（向后兼容），subheadline 默认空字符串
+    effective_headline = (headline or "").strip() or topic
+    effective_subheadline = (subheadline or "").strip()
+
+    scene_plans = plan_scenes(topic, duration, scene_count, allow_digital_human, language=output_language)
+
+    assets = []
+    scenes = []
+
+    for idx, plan in enumerate(scene_plans):
+        scene_id = f"scene-{idx + 1:02d}"
+        # 视觉素材的 assetId 命名遵循类型前缀：image → img-，video → video-
+        if primary_visual_type == "video":
+            visual_asset_id = f"video-{scene_id}"
+        else:
+            visual_asset_id = f"img-{scene_id}"
+        narration_asset_id = f"narration-{scene_id}"
+        narration_text = estimate_narration_text(plan["label"], plan["purpose"], plan["duration"], topic, language=output_language)
+
+        # 根据模板 assetRequirements 生成对应类型的视觉素材
+        if primary_visual_type == "image":
+            if stub_image_url:
+                assets.append({
+                    "assetId": visual_asset_id,
+                    "type": "image",
+                    "source": "existing",
+                    "status": "generated",
+                    "url": stub_image_url,
+                })
+            else:
+                image_result = generate_image_prompt(plan["purpose"], topic, style, narration_text=narration_text)
+
+                img_payload = {
+                    "prompt": image_result["prompt"],
+                    "model": os.environ.get("DEFAULT_IMAGE_MODEL", "doubao/doubao-seedream-5-0-260128"),
+                    "ratio": ratio,
+                }
+                if "negativePrompt" in image_result:
+                    img_payload["negativePrompt"] = image_result["negativePrompt"]
+                if "guidanceScale" in image_result:
+                    img_payload["guidanceScale"] = image_result["guidanceScale"]
+
+                assets.append({
+                    "assetId": visual_asset_id,
+                    "type": "image",
+                    "source": "gen-image",
+                    "status": "planned",
+                    "payload": img_payload,
+                })
+        elif primary_visual_type == "video":
+            if stub_video_url:
+                assets.append({
+                    "assetId": visual_asset_id,
+                    "type": "video",
+                    "source": "existing",
+                    "status": "generated",
+                    "url": stub_video_url,
+                })
+            else:
+                # 视频素材：复用 image prompt 生成器作为兜底，再追加 "视频/动态" 关键词
+                # 模型 / 时长 / 比例都遵循 gen-video 校验规则（Seedance 4-12s、Veo 4/6/8s）
+                image_result = generate_image_prompt(plan["purpose"], topic, style, narration_text=narration_text)
+                video_prompt = image_result["prompt"]
+                # 视频时长上限按 gen-video Seedance 模型的 12s 截断，下限 4s
+                video_duration = max(4, min(int(plan["duration"]), 12))
+                vid_payload = {
+                    "prompt": video_prompt,
+                    "model": os.environ.get("DEFAULT_VIDEO_MODEL", "doubao-seedance-1-5-pro-251215"),
+                    "ratio": ratio,
+                    "duration": video_duration,
+                }
+                assets.append({
+                    "assetId": visual_asset_id,
+                    "type": "video",
+                    "source": "gen-video",
+                    "status": "planned",
+                    "payload": vid_payload,
+                })
+
+        # narration text 不再在 audio asset 的 payload 里冗余存放——
+        # 唯一来源是下游 scenes[].audio.narration.text，render_video 在
+        # 调用 TTS skill 前会按 assetRef 回查 scene 文本注入。
+        assets.append({
+            "assetId": narration_asset_id,
+            "type": "audio",
+            "source": "gen-voice",
+            "status": "planned",
+            "payload": {
+                "voiceId": resolved_voice_id,
+            },
+        })
+
+        if has_visual:
+            layout = "text-overlay" if plan["purpose"] in ("opening", "cta") else "full-visual"
+            text_layers = []
+            if plan["purpose"] == "opening":
+                text_layers = [
+                    {"role": "headline", "content": effective_headline, "animation": "slide-up"},
+                ]
+                if effective_subheadline:
+                    text_layers.append({"role": "subheadline", "content": effective_subheadline, "animation": "fade-in"})
+            elif plan["purpose"] == "point":
+                text_layers = [
+                    {"role": "badge", "content": plan["label"], "animation": "slide-up"},
+                ]
+                # 给所有 point 场景补一个 headline textLayer，让 screen-walkthrough
+                # 等模板的 propExtractors 直接拿到主标题，不再依赖 binding 兜底逻辑。
+                text_layers.insert(0, {"role": "headline", "content": effective_headline, "animation": "fade-in"})
+                if effective_subheadline:
+                    text_layers.append({"role": "subheadline", "content": effective_subheadline, "animation": "fade-in"})
+            elif plan["purpose"] == "cta":
+                text_layers = [
+                    {"role": "headline", "content": _localize_label(output_language, "follow_us"), "animation": "fade-in"},
+                ]
+                if effective_subheadline:
+                    text_layers.append({"role": "subheadline", "content": effective_subheadline, "animation": "fade-in"})
+
+            scenes.append({
+                "id": scene_id,
+                "purpose": plan["purpose"],
+                "duration": plan["duration"],
+                "layout": layout,
+                "visuals": {"background": {"assetRef": visual_asset_id}},
+                "audio": {
+                    "narration": {
+                        "text": narration_text,
+                        "assetRef": narration_asset_id,
+                        # 骨架标记：scenes[].audio.narration.text 同样需要被真实旁白替换
+                        "needsFill": True,
+                    },
+                },
+                "textLayers": text_layers,
+                "animationHints": {
+                    "entrance": "fade",
+                    "motion": "kenburns-in" if idx % 2 == 0 else "kenburns-out",
+                },
+            })
+        else:
+            # The "no-visual" branch labels each scene with a layout hint.
+            # Historical fallback was hardcoded "html-slide" — when no template
+            # was specified, every audio-only scene defaulted to html-slide
+            # styling. We replace the hardcoded fallback chain with:
+            #   1. template.capabilities.defaultLayout   ⇐ the template tells
+            #      ab-skill what layout name it wants on its no-visual scenes
+            #   2. template_id                            ⇐ legacy: pass id as
+            #      layout name (existing behavior when no capability declared)
+            #   3. "html-slide"                           ⇐ absolute fallback
+            #      for the no-template case (preserves prior behavior)
+            _layout_cfg = (template_config or {}).get("capabilities") or {}
+            layout = _layout_cfg.get("defaultLayout") or template_id or "html-slide"
+            text_layers = []
+            if plan["purpose"] == "opening":
+                text_layers = [
+                    {"role": "headline", "content": topic, "animation": "fade-in"},
+                ]
+            elif plan["purpose"] == "point":
+                text_layers = [
+                    {"role": "headline", "content": plan["label"], "animation": "slide-up"},
+                ]
+            elif plan["purpose"] == "cta":
+                text_layers = [
+                    {"role": "headline", "content": _localize_label(output_language, "follow_us"), "animation": "zoom-in"},
+                    {"role": "subheadline", "content": _localize_label(output_language, "more_about", topic=topic), "animation": "fade-in"},
+                ]
+
+            custom_payload = _build_custom_payload(plan["purpose"], topic, plan["label"], idx, len(scene_plans), language=output_language)
+
+            scenes.append({
+                "id": scene_id,
+                "purpose": plan["purpose"],
+                "duration": plan["duration"],
+                "layout": layout,
+                "audio": {
+                    "narration": {
+                        "text": narration_text,
+                        "assetRef": narration_asset_id,
+                        # 骨架标记：scenes[].audio.narration.text 同样需要被真实旁白替换
+                        "needsFill": True,
+                    },
+                },
+                "textLayers": text_layers,
+                "customPayload": custom_payload,
+            })
+
+    dsl = {
+        "version": "v1alpha1",
+        "meta": {
+            "title": topic,
+            "topic": topic,
+            "headline": effective_headline,
+            "subheadline": effective_subheadline,
+            "platform": platform,
+            "targetDuration": duration,
+            "language": LANGUAGE_TO_META[output_language],
+            "outputLanguage": output_language,
+            "style": style or "",
+            "description": _localize_label(output_language, "video_description", topic=topic, duration=duration),
+        },
+        "global": {
+            "aspectRatio": ratio,
+            "resolution": resolution,
+            "fps": 30,
+            "subtitle": {"enabled": True, "style": "bottom"},
+            "narration": {"voiceId": resolved_voice_id, "speed": 1.0},
+            "bgm": {"enabled": True, "volume": 0.12},
+        },
+        "assets": assets,
+        "scenes": scenes,
+        "transitions": {"default": "fade", "duration": 0.5},
+    }
+
+    if template_id:
+        dsl["meta"]["templateId"] = template_id
+
+    return dsl
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Video script generator — produces Video DSL v1alpha1 JSON",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python gen_script.py --topic "3 AI study hacks" --duration 30 --ratio "9:16"
+  python gen_script.py --validate --input my-video.dsl.json
+        """,
+    )
+    parser.add_argument("--topic", help="Video topic (required for generation mode)")
+    parser.add_argument(
+        "--platform",
+        default="generic",
+        choices=VALID_PLATFORMS,
+        help="Target platform (default: generic)",
+    )
+    parser.add_argument("--duration", type=int, default=30, help="Target duration in seconds (default: 30)")
+    parser.add_argument("--style", default="", help="Style tag")
+    parser.add_argument("--ratio", default=None, choices=VALID_RATIOS, help="Aspect ratio. When omitted: if --template-id is set, use the template's supportedAspectRatios[0]; otherwise default 16:9.")
+    parser.add_argument("--resolution", default="1080p", help="Resolution (default: 1080p)")
+    parser.add_argument("--scenes", type=int, default=None, help="Scene count (default: auto-planned)")
+    parser.add_argument("--voice-id", default=None, help="Narration voice id. When omitted, the resolver picks template.defaultVoiceId, then the language-keyed fallback (zh→Chinese (Mandarin)_Male_Announcer, en→TBD English voice). gen_voice --list-voices --local prints the language-tagged catalog.")
+    parser.add_argument("--allow-digital-human", action="store_true", help="Allow digital-human assets")
+    parser.add_argument("--allow-ai-video", action="store_true", help="Allow AI-generated video assets")
+    parser.add_argument("--template-id", default=None, help="Template id. The template owns outputLanguage and may declare a defaultVoiceId.")
+    parser.add_argument("--validate", action="store_true", help="Validate-only mode: only validate the input DSL")
+    parser.add_argument("--input", "-i", help="Input DSL file path (required for validate mode)")
+    parser.add_argument(
+        "--headline",
+        default=None,
+        help="On-screen headline (recommended 4-12 chars / ~3 words). Stored at meta.headline and pushed into textLayers[role=headline]. Falls back to topic when not provided.",
+    )
+    parser.add_argument(
+        "--subheadline",
+        default=None,
+        help="On-screen subheadline / project name (e.g. 'Pixelle-Video'). Stored at meta.subheadline and pushed into textLayers[role=subheadline]. Independent from CC subtitles (global.subtitle).",
+    )
+    parser.add_argument(
+        "--stub-image-url",
+        default=None,
+        help="Test mode: every image AssetRef is written as source=existing, status=generated, url=<this URL> (no prompt; no gen-image call). STUB_IMAGE_URL env var also works but the CLI flag is preferred to avoid cross-session leakage.",
+    )
+    parser.add_argument(
+        "--stub-video-url",
+        default=None,
+        help="Test mode: every video AssetRef is written as source=existing, status=generated, url=<this URL> (no prompt; no gen-video call). STUB_VIDEO_URL env var also works but the CLI flag is preferred to avoid cross-session leakage.",
+    )
+    parser.add_argument(
+        "--carousel-items",
+        action="append",
+        default=None,
+        help="Media URL for the template's carousel/gallery. Can be repeated: "
+             "--carousel-items url1 --carousel-items url2. "
+             "For templates with input-schema.json (e.g. spotlight-card), these URLs "
+             "are placed directly into customPayload.carousel.items as existing assets, "
+             "bypassing AI image generation entirely.",
+    )
+    parser.add_argument(
+        "--caption-lines",
+        action="append",
+        default=None,
+        help="Bottom typewriter text line. Can be repeated: "
+             "--caption-lines 'line1' --caption-lines 'line2'. "
+             "For templates with input-schema.json (e.g. spotlight-card), these are placed "
+             "into customPayload.caption.lines. Supports **emphasis** syntax.",
+    )
+
+    args = parser.parse_args()
+
+    if args.validate:
+        if not args.input:
+            print("❌ validate mode requires --input", file=sys.stderr)
+            sys.exit(1)
+        if not os.path.exists(args.input):
+            print(f"❌ file not found: {args.input}", file=sys.stderr)
+            sys.exit(1)
+        with open(args.input, "r", encoding="utf-8") as f:
+            dsl = json.load(f)
+        errors = validate_dsl(dsl)
+        if errors:
+            print("❌ DSL validation failed:", file=sys.stderr)
+            for err in errors:
+                print(f"   - {err}", file=sys.stderr)
+            sys.exit(1)
+        else:
+            print("✅ DSL validation passed")
+            return
+
+    if not args.topic:
+        print("❌ please provide --topic", file=sys.stderr)
+        parser.print_help()
+        sys.exit(1)
+
+    # ── 模板感知的 ratio 自动推导 ────────────────────────────────────────────
+    # 用户没显式传 --ratio 时：
+    #   1. 若指定了 --template-id，取模板 supportedAspectRatios[0]（避免横竖屏不匹配）
+    #   2. 否则回退默认 16:9
+    resolved_ratio = args.ratio
+    if resolved_ratio is None:
+        if args.template_id:
+            tpl_cfg = _load_template_config(args.template_id)
+            preferred = _template_supported_ratio(tpl_cfg)
+            if preferred:
+                resolved_ratio = preferred
+                print(
+                    f"ℹ️  using aspect ratio {preferred} from template {args.template_id}",
+                    file=sys.stderr,
+                )
+            else:
+                resolved_ratio = "16:9"
+                if tpl_cfg is None:
+                    print(
+                        f"⚠️  template {args.template_id} not found; falling back to 16:9",
+                        file=sys.stderr,
+                    )
+        else:
+            resolved_ratio = "16:9"
+    args.ratio = resolved_ratio
+
+    print(f"📝 generating video script...", file=sys.stderr)
+    print(f"   topic: {args.topic}", file=sys.stderr)
+    print(f"   platform: {args.platform}", file=sys.stderr)
+    print(f"   duration: {args.duration}s", file=sys.stderr)
+    print(f"   ratio: {args.ratio}", file=sys.stderr)
+
+    # 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:
+        env_v = os.environ.get("STUB_IMAGE_URL", "")
+        if env_v:
+            print(f"⚠️  STUB_IMAGE_URL env var detected ({env_v}); using it as the image stub. Prefer passing --stub-image-url explicitly, or unset the env var.", file=sys.stderr)
+        stub_image_url = env_v
+    if stub_video_url is None:
+        env_v = os.environ.get("STUB_VIDEO_URL", "")
+        if env_v:
+            print(f"⚠️  STUB_VIDEO_URL env var detected ({env_v}); using it as the video stub. Prefer passing --stub-video-url explicitly, or unset the env var.", file=sys.stderr)
+        stub_video_url = env_v
+
+    dsl = build_dsl(
+        topic=args.topic,
+        platform=args.platform,
+        duration=args.duration,
+        style=args.style,
+        ratio=args.ratio,
+        resolution=args.resolution,
+        voice_id=args.voice_id,
+        scene_count=args.scenes,
+        allow_digital_human=args.allow_digital_human,
+        allow_ai_video=args.allow_ai_video,
+        template_id=args.template_id,
+        stub_image_url=stub_image_url,
+        stub_video_url=stub_video_url,
+        headline=args.headline,
+        subheadline=args.subheadline,
+        carousel_items=args.carousel_items,
+        caption_lines=args.caption_lines,
+    )
+
+    errors = validate_dsl(dsl)
+    if errors:
+        print("❌ generated DSL failed validation:", file=sys.stderr)
+        for err in errors:
+            print(f"   - {err}", file=sys.stderr)
+        sys.exit(1)
+
+    # Non-blocking language sanity check — only narrations from scenes[].
+    expected_language = dsl.get("meta", {}).get("outputLanguage", DEFAULT_LANGUAGE)
+    if expected_language in ("en", "zh"):
+        narrations_for_check = [
+            ((scene.get("audio") or {}).get("narration") or {}).get("text", "")
+            for scene in dsl.get("scenes", [])
+        ]
+        _check_narration_language(narrations_for_check, expected_language)
+
+    output_json = json.dumps(dsl, ensure_ascii=False, indent=2)
+    print(output_json)
+
+    scene_count = len(dsl["scenes"])
+    asset_count = len(dsl["assets"])
+    total_duration = sum(s.get("duration", 0) for s in dsl["scenes"])
+    print(f"\n📊 script summary: {scene_count} scenes, {asset_count} assets, total {total_duration}s", file=sys.stderr)
+    print("🎬 script generation complete!", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()