@remixmate/cli 0.13.5 → 0.13.7

package/dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "0.13.5",
-  "generatedAt": "2026-10-28T14:51:31.746Z",
+  "version": "0.13.7",
+  "generatedAt": "2026-10-30T09:41:49.930Z",
   "skills": [
     {
       "id": "doc-parse",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixmate/cli",
-  "version": "0.13.5",
+  "version": "0.13.7",
   "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.
 
@@ -508,6 +510,8 @@ python3 <SkillDir>/scripts/gen_script.py \
 
 Values written by `--background-preset`, `--background-asset`, `--payload`, `--ending-payload`, `--avatar-id` and `--motion` are listed in `meta.lockedScenePaths` (scene-relative paths such as `customPayload.<object>.<field>`, `animationHints.motion`). When the agent later saves its own `dsl_json` in merge mode, ab-agent restores those paths from this skeleton after merging, so a model-written `customPayload` object cannot wipe a card choice. Do not hand-write these keys in `dsl_json`; pass the flag. Templates that author their own scenes (`meta.authoredScenes`) are not merged: there ab-agent writes each locked value that the skeleton holds on every scene (with one value) onto every submitted scene, and adds the skeleton assets those values reference (`asset-background`, `asset-avatar`) when the submitted `assets` lacks them.
 
+For image-to-video replicate cards, map **转场效果 / Transition effect** to both `--payload sequence.defaultEffect=<id>` and `--payload sequence.overrideItemEffects=true`. Use the id in parentheses (`fade`, `wipe-left`, `slide-left`, `none`), preserving the chosen preset and all typography. **跟随样片 / Follow example (`follow`)** omits both overrides; `follow` is not a valid effect. Map **转场时长 / Transition duration** to `--payload sequence.transitionMs=<milliseconds>` (e.g. `0.6 秒（600）` → `600`); omit when following the sample or using `none`. These payload keys are locked into every generated scene, so do not re-author them in a saved DSL.
+
 ## DSL generation principles
 
 Apply the following principles when producing the DSL:

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": "V25",
   "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,128 @@
+
+
+
+
+
+
+
+from __future__ import annotations
+
+import math
+import re
+import unicodedata
+
+from video_dsl.runtime.timeline_compiler import assign_sentence_indices, split_narration_sentences
+
+
+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"
+
+
+def restore_narration_sentences(
+    text: str, subtitles: list[dict], duration_ms: float, speech_span_ms=None,
+) -> tuple[list[dict], str]:
+
+
+
+
+
+
+    sentences = split_narration_sentences(text)
+    if not subtitles:
+        if len(sentences) > 1:
+            return align_narration_lines(sentences, [], duration_ms, speech_span_ms)
+        return [], "tts-unchanged"
+
+    result = []
+    method = "tts-unchanged"
+    for sub in subtitles:
+        parts = split_narration_sentences(sub.get("text") or "")
+        if len(parts) <= 1:
+            result.append(sub)
+            continue
+        split, timing = align_narration_lines(parts, [sub], duration_ms, speech_span_ms)
+        result.extend(split)
+        if method != "estimated":
+            method = "estimated" if timing == "estimated" else "tts-interpolated"
+
+    if len(sentences) > 1:
+        if _normalized(text) != _normalized("".join(s.get("text") or "" for s in subtitles)):
+            return result, "tts-text-mismatch"
+        indices = assign_sentence_indices([s.get("text") or "" for s in result])
+        if len(set(indices)) != len(sentences):
+
+
+            return align_narration_lines(sentences, subtitles, duration_ms, speech_span_ms)
+    return result, method

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
@@ -879,6 +880,9 @@ def build_render_plan(dsl: dict, binding: dict) -> dict:
             "retryCount": 0,
             "maxRetries": 3,
         }
+        narration_text = (asset.get("payload") or {}).get("text")
+        if asset.get("type") == "audio" and isinstance(narration_text, str) and narration_text.strip():
+            assets_by_id[asset["assetId"]]["narrationText"] = narration_text
 
 
 
@@ -921,7 +925,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, {})
 
@@ -1396,9 +1400,12 @@ def _resolve_single_asset(
 
 
             src_payload = asset_with_payload.get("payload", {}) or {}
+            if source == "gen-voice" and isinstance(src_payload.get("text"), str):
+                asset["narrationText"] = src_payload["text"]
             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:
@@ -1626,9 +1633,12 @@ def resolve_narration_run(
         if per_scene_subs[k]:
             asset["ttsSubtitles"] = per_scene_subs[k]
         payload = payloads.get(c["assetId"]) or {}
+        if isinstance(payload.get("text"), str):
+            asset["narrationText"] = payload["text"]
         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 +1924,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 +1957,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 +1995,55 @@ 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, restore_narration_sentences
+
+    subtitles = asset.get("ttsSubtitles") or []
+    line_count = asset.get("narrationLineCount")
+
+    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 []
+
+    if not isinstance(line_count, int) or isinstance(line_count, bool) or line_count <= 0:
+        text = asset.get("narrationText") or ""
+        subtitles, method = restore_narration_sentences(
+            text, subtitles, asset["duration"], asset.get("speechSpanMs"),
+        )
+        if method == "tts-unchanged":
+            return subtitles
+        message = f"Restored narration sentence boundaries using {method} timing"
+    else:
+        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 +2109,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 +3442,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 +3501,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 +3736,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": "V43",
   "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."
 }

package/skills/template-registry/version.json

@@ -2,6 +2,6 @@
   "skillName": "template-registry",
   "repoName": "agent-skill-media-maker",
   "skillId": "475",
-  "version": "V30",
+  "version": "V31",
   "skillDescription": "Video-template registry skill. Stores every video-template definition and lists the available templates (templateId / name / aspect ratio / style tags).\n\nUse this skill as soon as the user mentions any of these intents:\n- View available templates / list every template\n\nNote: DSL→TemplateBinding is no longer a separate exposed step — once prepare_video_assets receives a template_id it builds the binding internally."
 }

package/skills/template-registry/video_dsl/runtime/timeline_compiler.py

@@ -213,15 +213,19 @@ def assign_sentence_indices(raw_texts: list[str]) -> list[int]:
     return indices
 
 
+def split_narration_sentences(text: str) -> list[str]:
+
+
+
+    return [part.strip(" \t\r") for part in _PRIMARY_BREAK.split(text.strip()) if part.strip()] if text else []
+
+
 def count_narration_sentences(text: str) -> int:
 
 
 
 
-    if not text or not text.strip():
-        return 0
-    chunks = [s for s in _PRIMARY_BREAK.split(text.strip()) if s.strip()]
-    return len(chunks)
+    return len(split_narration_sentences(text))
 
 
 def _plain_len(text: str) -> int: