@remixmate/cli 0.13.5 → 0.13.6

package/dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "0.13.5",
-  "generatedAt": "2026-10-28T14:51:31.746Z",
+  "version": "0.13.6",
+  "generatedAt": "2026-10-30T07:14:13.248Z",
   "skills": [
     {
       "id": "doc-parse",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixmate/cli",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "description": "AI media generation skills for Claude Code / Codex — 12 skills covering image, video, voice, digital human, web screenshot, web recording, script, template registry, rendering, Jianying export, and video deconstruction.",
   "type": "module",
   "main": "dist/index.js",

package/skills/gen-script/SKILL.md

@@ -32,6 +32,8 @@ Turns a user-supplied **topic** into a **Video DSL v1alpha1** JSON describing wh
 
 - **Video DSL**: a declarative description language for videos — describes the final structure, not the orchestration calls.
 - **AssetRef**: an asset reference declaring which images / audio / video clips are needed; the downstream Render Skill is responsible for producing them.
+
+Templates may declare `capabilities.mediaBinding.sceneMode=per-item`: the returned skeleton then contains one scene per input media item, with durations allocated from the complete sequence's existing timing model. Keep those scenes, media references and timing values; fill each scene's narration separately. Captions describe the visuals and are not automatically narration. Continuous TTS can synthesize adjacent scenes together and cut the result back into their separate audio assets; it does not merge the script's scenes.
 - **Scene**: the unit cell of the video timeline.
 - **Image `payload.model`**: must match the `gen-image` skill and the backend `ModelGenImgDTO`. **Only** values from the LiteLLM `model` allowlist below may be used. When editing narration or prompts you **must not** rewrite this field.
 

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

@@ -1129,8 +1129,8 @@ def _sequence_floor_frames(sequence: dict, preset_timing: dict, text: str, fps:
     return math.floor(min_sec * fps + 0.5)
 
 
-def _estimate_fit_images_duration(custom_payload: dict, model: dict | None, fps: int = 30,
-                                  headline: str = "") -> float:
+def _fit_images_hold_frames(custom_payload: dict, model: dict | None, fps: int = 30,
+                            headline: str = "") -> list[int]:
 
 
 
@@ -1183,8 +1183,46 @@ def _estimate_fit_images_duration(custom_payload: dict, model: dict | None, fps:
             if rate is None:
                 raise ValueError(f"fit-images with a floor requires durationModel.{key}.floorMinVideoRate")
             floor_frames = min(floor_frames, sum(math.floor(f / rate) for f in frames))
-        natural = max(natural, floor_frames)
-    return natural / fps
+
+
+
+        target = max(natural, floor_frames)
+        original = list(frames)
+        images = [item.get("type") != "video" for item in sequence["items"]]
+
+        def grow(eligible, caps):
+            need = target - sum(frames)
+            room = [max(0, caps[i] - frames[i]) if eligible[i] else 0 for i in range(len(frames))]
+            capacity = sum(room)
+            if need > 0 and capacity > 0:
+                take = min(need, capacity)
+                for i, r in enumerate(room):
+                    frames[i] += math.floor(r * take / capacity)
+
+        def uncapped(eligible):
+            need = target - sum(frames)
+            base = sum(f for i, f in enumerate(frames) if eligible[i])
+            if need > 0 and base > 0:
+                for i, f in enumerate(list(frames)):
+                    if eligible[i]:
+                        frames[i] += math.floor(f * need / base)
+
+        videos = [not image for image in images]
+        grow(images, [math.floor(f * 2.5 + 0.5) for f in original])
+        if any(videos):
+            rate = timing.get("floorMinVideoRate")
+            if not rate:
+                raise ValueError(f"fit-images with a floor requires durationModel.{key}.floorMinVideoRate")
+            grow(videos, [math.floor(f / rate) for f in original])
+        uncapped(images)
+        uncapped(videos)
+        frames[-1] += target - sum(frames)
+    return frames
+
+
+def _estimate_fit_images_duration(custom_payload: dict, model: dict | None, fps: int = 30,
+                                  headline: str = "") -> float:
+    return sum(_fit_images_hold_frames(custom_payload, model, fps, headline)) / fps
 
 
 def _probe_sequence_video_duration(url: str) -> float | None:
@@ -1535,6 +1573,71 @@ def _build_carousel_caption_dsl(
     for path in narration_locks:
         _lock_scene_path(dsl, path)
 
+    scene_mode = binding.get("sceneMode", "single")
+    if scene_mode not in ("single", "per-item"):
+        raise ValueError("mediaBinding.sceneMode must be single or per-item")
+    if scene_mode == "per-item":
+        if duration_strategy != "fit-images":
+            raise ValueError("mediaBinding.sceneMode=per-item requires durationStrategy=fit-images")
+        holds = _fit_images_hold_frames(custom_payload, duration_model, headline=headline)
+        dsl["assets"] = [a for a in assets if a["source"] != "gen-voice"]
+        dsl["scenes"] = []
+
+
+        scene_defaults = [(path.split("."), value) for path, value in binding.get("sceneDefaults", {}).items()]
+        for index, (item, frames) in enumerate(zip(container[items_parts[-1]], holds)):
+            current = deepcopy(scene)
+            current["id"] = f"scene-{index + 1:02d}"
+            current["purpose"] = "opening" if index == 0 else "point"
+            current["duration"] = frames / 30
+            payload = current["customPayload"]
+            _write_payload(payload, scene_defaults)
+            _write_payload(payload, payload_writes or [])
+            pinned = {**item, "holdSec": frames / 30}
+            hold_schema = (_schema_at(template_config, items_parts).get("items", {}).get("properties", {}).get("holdSec", {}))
+            if not hold_schema.get("minimum", 0) <= frames / 30 <= hold_schema.get("maximum", float("inf")):
+
+
+
+                pinned.pop("holdSec", None)
+            _write_payload(payload, [(items_parts, [pinned])])
+            default_hold_schema = _schema_at(template_config, container_parts + ["defaultHoldSec"])
+            if default_hold_schema and default_hold_schema.get("minimum", 0) <= frames / 30 <= default_hold_schema.get("maximum", float("inf")):
+                _write_payload(payload, [(container_parts + ["defaultHoldSec"], frames / 30)])
+
+
+            if _schema_at(template_config, container_parts + ["minSec"]):
+                minimum = _schema_at(template_config, container_parts + ["minSec"]).get("minimum", 0)
+                if frames / 30 >= minimum:
+                    _write_payload(payload, [(container_parts + ["minSec"], frames / 30)])
+                else:
+                    _get_path(payload, container_parts).pop("minSec", None)
+            if narration_enabled:
+                if "minDurationSec" in payload:
+                    payload["minDurationSec"] = frames / 30
+                ref = f"narration-{current['id']}"
+                current["audio"]["narration"].update(
+                    assetRef=ref,
+                    text=_localize_label(
+                        output_language, "narration_opening", label="", topic=_clip(topic, _PLACEHOLDER_TOPIC_CHARS),
+                        duration=frames / 30,
+                        budget=_budget_suffix(frames / 30, output_language, narration_speed, None),
+                    ),
+                )
+                dsl["assets"].append({"assetId": ref, "type": "audio", "source": "gen-voice",
+                                      "status": "planned", "payload": {"voiceId": resolved_voice_id}})
+            dsl["scenes"].append(current)
+
+
+        if container_parts:
+            dsl["meta"]["mergeScenePaths"] = ["customPayload." + ".".join(container_parts)]
+        if _schema_at(template_config, container_parts + ["defaultHoldSec"]):
+            _lock_scene_path(dsl, "customPayload." + ".".join(container_parts + ["defaultHoldSec"]))
+        for parts, _ in scene_defaults:
+            _lock_scene_path(dsl, "customPayload." + ".".join(parts))
+        if _schema_at(template_config, container_parts + ["minSec"]):
+            _lock_scene_path(dsl, "customPayload." + ".".join(container_parts + ["minSec"]))
+
     return dsl
 
 
@@ -1918,6 +2021,13 @@ def _apply_scene_payload(
         raise ValueError("--payload / --motion need --template-id: the allowed keys come from the template.")
 
     writes = _parse_payload_specs(template_config, payload_specs)
+    binding = _resolve_media_binding(template_config)
+    if binding.get("sceneMode") == "per-item":
+
+
+        item_path = binding["itemsPath"].split(".")
+        allocated = (item_path, item_path[:-1] + ["minSec"])
+        writes = [(parts, value) for parts, value in writes if parts not in allocated]
     if motion:
         allowed = ("auto", "static", "kenburns-in", "kenburns-out", "pan-left", "pan-right", "float")
         if motion not in allowed:

package/skills/gen-script/version.json

@@ -2,6 +2,6 @@
   "skillName": "gen-script",
   "repoName": "agent-skill-media-maker",
   "skillId": "474",
-  "version": "V23",
+  "version": "V24",
   "skillDescription": "Video-script generation skill. Turns a user-supplied topic into a structured Video DSL (JSON) that describes the full video — scene structure, asset requirements, and narrative flow.\n\nUse this skill as soon as the user mentions any of these intents:\n- Write a video script, generate a video script, plan a video, write storyboards\n- Create a short video, plan video content, generate a Video DSL\n- Turn a topic into a video structure / video content plan\n\nEven when the user does not say \"generate the DSL\", use this skill whenever they want to turn a topic into a structured video plan.\n\n⚠️ Stop-and-confirm gate: after this skill returns a DSL, show the full script and wait for the user's explicit confirmation. Never call `prepare_video_assets` in the same turn."
 }

package/skills/prepare-video-assets/SKILL.md

@@ -112,6 +112,8 @@ This skill is the **first half** of a two-phase user-confirmation flow. After it
 
 Read the `job_id` from the stdout line `📦 render job jobId: N` and remember it; asset URLs come from the `🔊 TTS audio:` and `🖼  Image assets:` sections. Show images inline (`![name](https://...)`) and audio as links (`[🔊 listen](http://cdn.../x.mp3)`) so the user can actually review them. The recommended summary format:
 
+When `__scene_assets__` is present, the web UI renders the full scene preview from that structured timeline: all visuals, scene times and each scene's audio slice. Give a brief overview/status and request confirmation; do not duplicate the preview or copy URLs into prose. For CLI clients without this UI, render every referenced visual and the corresponding audio per scene from the marker. With older outputs, use the fallback table below, including **all** visuals in each scene rather than one representative image. Scene count is independent of the number of TTS synthesis calls. Visual captions must not automatically become narration.
+
 ```markdown
 ## Render confirmation
 

package/skills/prepare-video-assets/version.json

@@ -2,6 +2,6 @@
   "skillName": "prepare-video-assets",
   "repoName": "agent-skill-media-maker",
   "skillId": "476",
-  "version": "V7",
+  "version": "V8",
   "skillDescription": "Asset-preparation skill: resolves and generates every asset (image / audio / video) referenced by a Video DSL, persists a RenderPlan to the database, and returns a `job_id` for the subsequent `render_video` call.\n\nUse this skill as soon as the user mentions any of these intents:\n- Generate / prepare video assets, resolve assets, render-ready\n- \"Make me a video about X\" (the agent calls gen_script → prepare_video_assets → render_video)\n- Regenerate one asset (image / audio) for a specific scene\n\nNext step: after the user confirms the resolved assets, call `render_video` with the `job_id` returned by this skill.\n\n⚠️ Stop-and-confirm gate: this skill runs only after the user has confirmed the script, and after it returns you must show the resolved assets and wait for the user's explicit confirmation. Never call `render_video` in the same turn."
 }

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

@@ -50,6 +50,15 @@ _NATURAL_PAUSE_SEC = 0.45
 
 _MIN_BOUNDARY_PAUSE_RATIO = 0.75
 
+
+
+
+_MIN_BOUNDARY_PAUSE_SEC = 0.6
+
+
+def _min_boundary_ms(pause_sec: float) -> float:
+    return max(_MIN_BOUNDARY_PAUSE_SEC, pause_sec * _MIN_BOUNDARY_PAUSE_RATIO) * 1000
+
 _SILENCE_NOISE_DB = -40
 _SILENCE_MIN_SEC = 0.25
 
@@ -282,7 +291,7 @@ def cuts_from_silences(
         return None
     longest = sorted(inner, key=lambda s: s[1] - s[0], reverse=True)[:need]
     longest.sort(key=lambda s: s[0])
-    min_len = pause_sec * _MIN_BOUNDARY_PAUSE_RATIO * 1000
+    min_len = _min_boundary_ms(pause_sec)
     if any(end - start < min_len for start, end in longest):
         return None
     cuts = [(start + end) / 2 for start, end in longest]
@@ -308,8 +317,7 @@ def _durations_plausible(cuts: list[float], texts: list[str], total_ms: float, p
 def _cuts_on_boundary_pauses(cuts: list[float], silences: list[tuple[float, float]], pause_sec: float) -> bool:
 
 
-
-    min_len = pause_sec * _MIN_BOUNDARY_PAUSE_RATIO * 1000
+    min_len = _min_boundary_ms(pause_sec)
     tol = 100.0
     return all(
         any(end - start >= min_len and start - tol <= c <= end + tol for start, end in silences)

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

@@ -0,0 +1,88 @@
+
+
+
+
+
+
+
+from __future__ import annotations
+
+import math
+import re
+import unicodedata
+
+
+def _normalized(text: str) -> str:
+    text = re.sub(r"<#\s*\d+(?:\.\d+)?\s*#>", "", text)
+    return "".join(c for c in unicodedata.normalize("NFKC", text).casefold() if c.isalnum())
+
+
+def _number(value) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value)
+
+
+def align_narration_lines(
+    lines: list[str], subtitles: list[dict], duration_ms: float, speech_span_ms=None,
+) -> tuple[list[dict], str]:
+
+
+
+
+
+
+    normalized = [_normalized(line) for line in lines]
+    weights = [max(len(text), 1) for text in normalized]
+    start_ms, end_ms = 0.0, float(duration_ms)
+    if (isinstance(speech_span_ms, list) and len(speech_span_ms) == 2
+            and all(_number(v) for v in speech_span_ms)
+            and 0 <= speech_span_ms[0] < speech_span_ms[1] <= duration_ms):
+        start_ms, end_ms = map(float, speech_span_ms)
+
+    anchors = []
+    offset = 0
+    previous_end = 0.0
+    for sub in subtitles:
+        if not isinstance(sub, dict) or not isinstance(sub.get("text"), str):
+            anchors = []
+            break
+        text = _normalized(sub["text"])
+        if not text:
+            continue
+        begin, end = sub.get("timeBegin"), sub.get("timeEnd")
+        if not (_number(begin) and _number(end) and previous_end <= begin < end <= duration_ms):
+            anchors = []
+            break
+        anchors.append((offset, offset + len(text), float(begin), float(end), text))
+        offset += len(text)
+        previous_end = end
+
+    matches = (anchors and all(normalized)
+               and "".join(normalized) == "".join(a[4] for a in anchors))
+    result = []
+    interpolated = False
+    if matches:
+        offset = 0
+        anchor_index = 0
+        for line, text in zip(lines, normalized):
+            line_end = offset + len(text)
+            while anchors[anchor_index][1] <= offset:
+                anchor_index += 1
+            first = anchors[anchor_index]
+            while anchors[anchor_index][1] < line_end:
+                anchor_index += 1
+            last = anchors[anchor_index]
+            begin = first[2] + (first[3] - first[2]) * (offset - first[0]) / (first[1] - first[0])
+            end = last[2] + (last[3] - last[2]) * (line_end - last[0]) / (last[1] - last[0])
+            interpolated |= offset != first[0] or line_end != last[1]
+            result.append({"text": line, "timeBegin": begin, "timeEnd": end})
+            offset = line_end
+        return result, "tts-interpolated" if interpolated else "tts-boundaries"
+
+    total = sum(weights)
+    offset = 0
+    for line, weight in zip(lines, weights):
+        begin = start_ms + (end_ms - start_ms) * offset / total
+        offset += weight
+        end = start_ms + (end_ms - start_ms) * offset / total
+        result.append({"text": line, "timeBegin": begin, "timeEnd": end})
+    return result, "estimated"

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

@@ -0,0 +1,39 @@
+
+from __future__ import annotations
+
+
+def scene_assets(plan: dict, narration_texts: dict[str, str] | None = None) -> list[dict]:
+    assets = {a.get("assetId"): a for a in plan.get("resolvedAssets", [])}
+    fps = (plan.get("renderConfig") or {}).get("fps", 30)
+    out = []
+
+    def refs(value):
+        if isinstance(value, dict):
+            for key, child in value.items():
+                if isinstance(child, str) and key.lower().endswith(("assetref", "assetid")) and child in assets:
+                    yield child
+                else:
+                    yield from refs(child)
+        elif isinstance(value, list):
+            for child in value:
+                yield from refs(child)
+
+    for entry in plan.get("timeline", []):
+        narration = "".join(s.get("text", "") for s in entry.get("subtitleSegments", []))
+        narration = (narration_texts or {}).get(entry.get("sceneId"), narration)
+        for ref in dict.fromkeys(refs(entry.get("props") or {})):
+            asset = assets[ref]
+            if asset.get("type") not in ("image", "video", "audio") or asset.get("status") != "generated" or not asset.get("url"):
+                continue
+            item = {
+                "type": asset["type"], "url": asset["url"], "label": ref,
+                "sceneId": entry["sceneId"],
+                "sceneStartSec": entry.get("startFrame", 0) / fps,
+                "sceneEndSec": entry.get("endFrame", 0) / fps,
+                "narrationText": narration,
+            }
+            if asset.get("duration"):
+
+                item["durationSec"] = asset["duration"] / (1000 if asset["type"] == "audio" else 1)
+            out.append(item)
+    return out

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

@@ -27,6 +27,7 @@ import argparse
 import atexit
 import builtins
 import json
+import math
 import os
 import re
 import signal
@@ -921,7 +922,7 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
     for idx, scene in enumerate(dsl.get("scenes", [])):
         scene_id = scene.get("id") or scene.get("sceneId") or f"scene-{idx:03d}"
         duration = scene.get("duration", 5)
-        duration_frames = int(duration * fps)
+        duration_frames = math.floor(duration * fps + 0.5)
 
         scene_binding = binding_map.get(scene_id, {})
 
@@ -1399,6 +1400,7 @@ def _resolve_single_asset(
             if isinstance(src_payload.get("narrationItems"), list):
                 asset["narrationLineCount"] = len(src_payload["narrationItems"])
                 asset["narrationIntroLines"] = int(src_payload.get("narrationIntroLines") or 0)
+                asset["narrationLines"] = list(src_payload["narrationItems"])
             LogPrint(f"   ✅ {asset['assetId']} generated", file=sys.stderr)
             return True
         else:
@@ -1629,6 +1631,7 @@ def resolve_narration_run(
         if isinstance(payload.get("narrationItems"), list):
             asset["narrationLineCount"] = len(payload["narrationItems"])
             asset["narrationIntroLines"] = int(payload.get("narrationIntroLines") or 0)
+            asset["narrationLines"] = list(payload["narrationItems"])
     log(f"continuous narration: {len(run)} scenes in one TTS call, {total_ms / 1000:.1f}s, cut by {method}")
     return True
 
@@ -1914,9 +1917,8 @@ def _auto_highlight_map(
         return
 
     props = entry.get("props") or {}
-    tdata = props.get("templateData")
-    if not isinstance(tdata, dict):
-        return
+    nested = isinstance(props.get("templateData"), dict)
+    tdata = props["templateData"] if nested else props
     if tdata.get("highlightMap"):
         return
 
@@ -1948,7 +1950,8 @@ def _auto_highlight_map(
 
     highlight_map = {str(intro_lines + i): i for i in range(item_count) if item_count > 0}
     tdata["highlightMap"] = highlight_map
-    props["templateData"] = tdata
+    if nested:
+        props["templateData"] = tdata
     entry["props"] = props
 
     render_plan.setdefault("logs", []).append({
@@ -1985,6 +1988,49 @@ def _template_default_tail_pad_frames(tpl: dict, fps: int) -> int | None:
     return int(round(float(value) * fps))
 
 
+def _structured_narration_subtitles(entry: dict, asset: dict, render_plan: dict) -> list[dict]:
+
+    from _narration_alignment import align_narration_lines
+
+    subtitles = asset.get("ttsSubtitles") or []
+    line_count = asset.get("narrationLineCount")
+    if not isinstance(line_count, int) or isinstance(line_count, bool) or line_count <= 0:
+        return subtitles
+
+
+    old_subs = entry.get("subtitleSegments") or []
+    at_sec = entry.get("subtitleAtSec") or []
+    if len(at_sec) == len(old_subs) and any(isinstance(v, (int, float)) for v in at_sec):
+        return []
+
+    lines = asset.get("narrationLines")
+    if not isinstance(lines, list) or len(lines) != line_count:
+        lines = [s.get("text") for s in old_subs] if len(old_subs) == line_count else []
+    if len(lines) != line_count or any(not isinstance(v, str) or not v.strip() for v in lines):
+        method = "authored-lines-unavailable"
+        message = "Authored narration lines unavailable; cannot restore per-line timing"
+    else:
+
+        asset["narrationLines"] = list(lines)
+        subtitles, method = align_narration_lines(
+            lines, subtitles, asset["duration"], asset.get("speechSpanMs"),
+        )
+        message = f"Preserved {line_count} narration lines using {method} timing"
+
+    logs = render_plan.setdefault("logs", [])
+    if not any(l.get("phase") == "narration-align" and l.get("sceneId") == entry.get("sceneId")
+               and l.get("method") == method for l in logs):
+        logs.append({
+            "phase": "narration-align",
+            "sceneId": entry.get("sceneId"),
+            "method": method,
+            "level": "info" if method == "tts-boundaries" else "warn",
+            "message": message,
+            "timestamp": now_iso(),
+        })
+    return subtitles
+
+
 def adjust_timeline_to_audio(render_plan: dict) -> dict:
 
 
@@ -2050,7 +2096,7 @@ def adjust_timeline_to_audio(render_plan: dict) -> dict:
                     entry["durationFrames"] = new_dur
                     adjusted += 1
 
-                tts_subs = narration_asset.get("ttsSubtitles", [])
+                tts_subs = _structured_narration_subtitles(entry, narration_asset, render_plan)
                 if tts_subs:
 
 
@@ -3383,7 +3429,7 @@ def _persist_render_plan(render_plan: dict, args, private_token: str, dsl: dict
             args.save_job = False
 
 
-def _print_resolve_only_summary(render_plan: dict) -> int:
+def _print_resolve_only_summary(render_plan: dict, dsl: dict | None = None) -> int:
 
     generated = sum(1 for a in render_plan["resolvedAssets"] if a["status"] == "generated")
     failed = sum(1 for a in render_plan["resolvedAssets"] if a["status"] == "failed")
@@ -3442,6 +3488,16 @@ def _print_resolve_only_summary(render_plan: dict) -> int:
             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)")
+    from _scene_assets import scene_assets
+    narration_texts = {}
+    for scene in (dsl or {}).get("scenes", []):
+        authored = (scene.get("audio") or {}).get("narration") or {}
+        lines = extract_narration_lines(authored)
+        if lines:
+            narration_texts[scene["id"]] = "\n".join(lines[0])
+        elif isinstance(authored.get("text"), str):
+            narration_texts[scene["id"]] = authored["text"]
+    print("__scene_assets__ " + json.dumps(scene_assets(render_plan, narration_texts), ensure_ascii=False))
 
     return failed
 
@@ -3667,7 +3723,7 @@ def main():
             LogPrint(f"💾 RenderPlan saved: {rp_output}", file=sys.stderr)
 
     if args.resolve_only:
-        if _print_resolve_only_summary(render_plan) > 0:
+        if _print_resolve_only_summary(render_plan, dsl) > 0:
             sys.exit(1)
         return
 

package/skills/render-video/version.json

@@ -2,6 +2,6 @@
   "skillName": "render-video",
   "repoName": "agent-skill-media-maker",
   "skillId": "473",
-  "version": "V40",
+  "version": "V42",
   "skillDescription": "Final-render skill: loads a persisted RenderPlan by `job_id` and drives the Remotion engine to produce the final video.\n\nUse this skill as soon as the user mentions any of these intents (after assets are already prepared):\n- Render the video, composite the video, export the video\n- Turn the prepared assets into the final clip\n- Render with Remotion\n\nPrerequisite: assets must already be generated via `prepare_video_assets`. This skill never resolves or regenerates assets — pass it a `job_id` from a previous `prepare_video_assets` call.\n\n⚠️ Stop-and-confirm gate: never call this skill until the user has explicitly confirmed the assets prepared by `prepare_video_assets`. If those assets were prepared in the current turn and the user has not replied since, stop and ask instead of rendering."
 }