@remixmate/cli 0.13.6 → 0.13.7

package/dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "0.13.6",
-  "generatedAt": "2026-10-30T07:14:13.248Z",
+  "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.6",
+  "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

@@ -510,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/version.json

@@ -2,6 +2,6 @@
   "skillName": "gen-script",
   "repoName": "agent-skill-media-maker",
   "skillId": "474",
-  "version": "V24",
+  "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/render-video/scripts/_narration_alignment.py

@@ -11,6 +11,8 @@ 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)
@@ -86,3 +88,41 @@ def align_narration_lines(
         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/render_video.py

@@ -880,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
 
 
 
@@ -1397,6 +1400,8 @@ 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)
@@ -1628,6 +1633,8 @@ 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)
@@ -1990,32 +1997,38 @@ def _template_default_tail_pad_frames(tpl: dict, fps: int) -> int | None:
 
 def _structured_narration_subtitles(entry: dict, asset: dict, render_plan: dict) -> list[dict]:
 
-    from _narration_alignment import align_narration_lines
+    from _narration_alignment import align_narration_lines, restore_narration_sentences
 
     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"
+    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"
+            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")

package/skills/render-video/version.json

@@ -2,6 +2,6 @@
   "skillName": "render-video",
   "repoName": "agent-skill-media-maker",
   "skillId": "473",
-  "version": "V42",
+  "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: