Voiceover MG Assembly Line

Voiceover MG Assembly Line (v3 hub, derived from 0715-01 Assembly + v3/v4 iterations)

This file is the assembly process hub: only the process skeleton and routing; detailed rules are in references/ files (the settling point of 77 comparison gaps, finalized after in-depth comparison review on 2026-07-16).

§0 Environment Readiness Check (Run this section every time you are invoked. Only proceed once it passes.)

For this skill's rules to be applied, a Remotion project with a base substrate is required. Do not print instructions for the user to do it themselves—directly execute the checks below and install whatever is missing.

Check Order (Run item by item. Only start work when all green.)

# 1) Basic runtime
node -v && ffmpeg -version | head -1
# 2) Is the current directory a Remotion project?
[ -f package.json ] && grep -q '"remotion"' package.json && echo "OK: remotion project"
# 3) Is the substrate complete? (Missing any means incomplete)
ls src/design/tokens.ts src/design/motion.ts src/koubo/scenes/shared.tsx \
 scripts/render-service.cjs scripts/qc-master.mjs 2>/dev/null

Handling Three Outcomes

Outcome	Action
All Green	Pass silently. Do not report environment status to the user. Directly proceed to the assembly process.
Has project, missing substrate	Auto-install without asking (When the setup detects it's already a Remotion project, it only adds the skill/scripts/substrate, not overwriting your code):macOS/Linux: bash <(curl -fsSL https://raw.githubusercontent.com/jincheng2026/jc-remotion-skills/master/setup.sh) .Windows (PowerShell): `irm https://raw.githubusercontent.com/jincheng2026/jc-remotion-skills/master/setup.ps1
No project	Ask before installing (npm install takes 3-5 minutes, significant size; requires user confirmation of the directory):"A Remotion project needs to be created first (dependency installation takes about 3-5 minutes). Where should it be created? Default: ./remotion-koubo-studio"After user replies: macOS/Linux use the setup.sh above with the <directory> argument; Windows use node <repo>/setup.mjs <directory>
Missing node / ffmpeg	Install automatically if possible. Do not just give the user a command. (Most environments can install these without admin privileges via system package managers):① macOS with brew (command -v brew) → Inform the user "X is missing, I will install it with brew, will take a few minutes" then directly run brew install <only the missing one>, then re-run this section.② Windows with winget → winget install OpenJS.NodeJS Gyan.FFmpeg③ Linux, first try sudo -n true: if passwordless sudo, run sudo apt install -y nodejs ffmpeg; only if a password is required, give the command to the user to run.④ If none work (e.g., Mac without Homebrew) → Give the user a single official command to install Homebrew to paste into their terminal (requires one password entry), then ask them to let you know when it's done, and re-run this section.

Discipline

• Run only on the first invocation; do not re-check if already passed in the same session.
• Stay silent when all green—the user wants to cut a video, not get an environment report. Only speak up when something needs to be installed.
• After auto-install/new project creation, must re-run the check to confirm all green before proceeding.
• If the user explicitly says "Skip the check" or "I know the environment is fine," respect the user and start working directly.

§0.1 Pre-Production Gate (Run before creating the plan, same level as §0 environment check: cannot proceed without passing)

This file is a routing hub, not the content itself. The table below is the list of true source documents—these must be read completely before creating the assembly plan table, not "consulted when needed."

Required Reading	What it Covers
design-system references/motion.md	Motion vocabulary (number scroll / verdict slam / line growth / exit / clear screen), Five Smooth Laws
design-system references/typography.md	T-level font hierarchy, empty band, hero word ratio
design-system references/layout.md	Three-zone coordinates, takeover mechanism, safety frame
design-system references/specs.md	Component specification table, motion value table
assembly references/subtitle.md	Subtitle line breaks, bilingual norms, validation gate
assembly references/rhythm.md	Beat density, exit discipline, density curve
assembly references/narrative.md	Side label system, five energy nodes, verdict elevation
assembly references/selection.md	Sentence type → Segment type → Component matching table
design-system references/infographic.md	Metaphor visualization, chart selection (must read when data/flow/comparison sections exist)

Why this gate exists (Root cause layer 1 of the 0727-01 incident, 2026-07-27): That version only read this hub + tokens.ts + one existing Scene file before starting work, not a single one of the 9 true sources above. The consequence was that the entire motion vocabulary was reduced to just one type: "Fade In"—numbers didn't scroll, verdicts didn't slam, most sections had no exit, chapters had no clear screen—all of which are explicitly written in motion.md.

Two additional disciplines:

• Do NOT reverse-engineer specifications from an existing Scene file. A single scene only reflects the rules it uses; what's missing are precisely the rules it doesn't use—the 0727-01 incident happened because they used Scene02 from 0724-01 as a template, which happened to lack number scrolling and Stamps, so the entire film lacked them too.
• Each segment in the plan table must cite the rule entry number (see §2 step 2). If you can't write entries like "based on motion §7 / narrative §3," it means you haven't read them—go back and read before proceeding.

§0.2 Studio Live Preview Enabled by Default ("Path A", User Ruling 2026-07-28)

The default iteration method confirmed is Remotion Studio hot-reload, not rendering still frames for review—the "change one thing → render frame → read image" loop is reserved only for gate acceptance.

• Start preview upon beginning work: After environment check passes, default to starting Studio and opening the current composition for the user to view (Claude Code: Preview panel starts remotion-studio from .claude/launch.json in the repo root; Generic host: run npm run dev and ask the user to open http://localhost:3000/Koubo-<film-name>). The main component has a rough-cut base layer (OffthreadVideo), making Studio a complete composition (voiceover + MG + subtitles + SFX on the same screen). The user can play and scrub the timeline at any time.
• Iterate via hot-reload: After changing code, it auto-refreshes in seconds. For adjustments like font size, position, color, or copywriting, let the user see it directly in the preview and make the final call. Rendering frames (render-service stills/segment) is only used for evidence at the three gates, mg-judge input, and delivery acceptance—the rules for gates and review remain unchanged (final delivery still includes the segment with audio; self-checking motion effects still requires watching the continuous footage, see §2.5 step 5).
• Parameter panel: The new film's main component automatically generates a Zod schema via scaffold-koubo.mjs (qc / subZhSize / subBottom / sfxGain; the Root registration snippet printed at the end already includes schema + defaultProps). When attaching InfoScrim, connect scrimStrength into the schema following src/koubo/Koubo072701.tsx. Add or remove other parameters per film. Iron rule: Schema defaults must always equal tokens/current ruling values; output uses defaults—the panel is an exploration layer, not the source of truth. Write finalized values back to the corresponding source of truth (font size/bottom margin → tokens.ts; volume level → sfx §4.4 process). Forbidden to keep non-default values in defaultProps. Root defaultProps referencing token variables causing Studio's "Can't save default props" error is by design (to prevent bypassing tokens). Do not fix it. The Zod version must be locked to Remotion's requirements (4.0.489 ↔ zod 4.3.6—the version mismatch warning when starting Studio is the verification).
• Frame drops during live playback are normal for browser-based real-time composition: judge motion feel at 0.5x speed or confirm via segment render. When rendering while Studio is open, the serial discipline remains unchanged (#23 concurrency deadlock + Warning zone "Studio + still render crash"). If a process "silently hangs at 0% CPU", first check for iCloud eviction (Error #25 and its node_modules variant).

System Iteration Principles (User Ruling 2026-07-16: Skills must continuously iterate, constantly raising standards and quality)

• Ratchet moves only forward, never backward: Standards ruled by the user (spec values, rejection items, sound-matching syntax) are a floor, not a ceiling—subsequent sections can only add stricter requirements. Forbidden to maintain the status quo by saying "that's how it was last time."
• Every section must be documented: A section passing review = at least one transferable "why" added to the domain file. A crash = file an error case (symptoms → fix location). A user saying "no good" or "barely acceptable" = note the improvement direction (e.g., "sound effects 'barely acceptable'" → pending upgrade to commercial pack).
• Review after every film: Before assembling a new video, first scan the error set and each domain's "negative examples" to confirm the new film's starting point is the previous film's ending standard.
• Quality benchmark has no ceiling: The current baseline film is just a baseline, not the end goal. Whenever a reference of higher quality is found, absorb it into the specs using the word-level comparison method.

Rule Conflict Resolution Order (When two rules conflict, resolve using this order, record it, and await user confirmation)

User Ruling > Hard Constraints (Three-zone / Occupancy Table / Gating / Bright surface prohibits bare text) > Semantic Alignment (Show when speaking) > Density Rhythm Baseline > Aesthetic Preference. Known Rulings: Alignment takes priority over Clear Screen (rhythm 1); Chart explanation anchors are exempt from exit discipline (rhythm 4, pending major test validation); Fast-paced lists do not trigger case material obligation (broll 6). For new conflicts, resolve according to this order, explicitly record the decision in the plan, and do not silently pick one.

Main Session Discipline (Post-mortem rails from 0722-01 full process review, established 2026-07-24; see my-video/docs/0722-01-full-process-pitfall-review-20260723.md)

Reworked three times in one night, crashed twice. The root problem wasn't execution, but judgment and alignment. Four iron rules:

1. Before adopting an existing solution / hardcoding values, first write down "applicable conditions." The skill's default output (e.g., gbro assembly animation's slow reveal) is only valid within its own context and won't automatically adapt to your host content—in dense voiceover, slow reveal means the visuals are always one step behind (A1, 8 videos discarded). Using one number for a whole batch assumes all entries are homogeneous when they usually aren't (A2: a blanket "person occupies 45-60% height" caused full-body wide shots to fail). Specs must specify "which value for which situation" (e.g., object-driven metaphors 45-60% / person-driven close-up metaphors 65-80%), not just one value.
2. The user's conditional statements are not imperatives. "Only if X then Y" is giving a constraint, not requesting X (A3: User said "Only full-screen B-roll should make the person disappear" = person should not disappear by default; I read it as "Make B-roll full-screen," causing 1.5h of late-night rework). For ambiguous terms ("make the visuals move" = camera motion vs. element motion), align with the user first before implementing—it's cheaper than guessing.
3. Verification must distinguish between "tested and passed" and "never tested at all." For QC "zero violations," first check probe coverage (Error #35). For monitoring long tasks, watch task-specific signals (the task's own session, products, process PID), not global signals—all three false alarms in 0722-01 were watching the wrong signal (watching the user's parallel cover image task, judging liveness by "how long since file changed" while Codex batches writes before flushing). Hard red lines (no fake text, logos, watermarks) must be independently double-checked by the main session, not trusting sub-agent self-checks (C5: Agent 07 self-checked "all four edges clear of fake text" when there was a letter visible at the top edge).
4. Each revision or delivery must be a git commit. The project is a git repo but was never committed → when v5 scene code was overwritten by the full-screen version, it could only be reconstructed from rendered frames, with fidelity loss (D3). After completing a version or before delivery, run git add -A && git commit. Code loss is the only irreversible loss in the entire pipeline.

For substrate defects, fix the substrate or file an error case; forbidden to only apply a hotfix in a single segment (Error #36 InfoScrim: hotfix in 0715-02, the gap persisted until it broke in 0722-01).

Domain Routing Table (Which file to read for each assembly step)

| Domain | File | What it Covers | |---|---| | Sentence Type Selection (First Query Point) | references/selection.md | Voiceover sentence type → segment type → grammar pointer → component matching table; Primary shot three-sequence criteria; No-match exit | | No-Reference R&D | references/rd-noref.md | New arrangement design when grammar gap + no reference footage: multi-option generation → judge panel → user finalization | | Reference Footage Replication (R&D Mode-A Method Layer) | Independent skill remotion-reference-fidelity | Fidelity methodology for replicating with reference footage: six scene grammar types, word-level beat table, fidelity gate; Only concerns "how to faithfully read the reference footage"; all values must be based on the true sources of each domain; Alpha transparency delivery line trigger conditions are also in this skill (see §6) | | Chapter Narrative | references/narrative.md | Side label system, Red/Blue camps, heavy hammer timing, hook/CTA, verdict elevation | | Density Rhythm | references/rhythm.md | Beat table, beat every 3-5s, exit discipline, recap weighting, audit method | | Subtitles | references/subtitle.md | Semantic line breaks, English short sentences, background box, validation script | | Footage Engineering | references/broll.md (true source rules) + Independent execution skill remotion-broll (judgment → acquisition → verification → selection → embedding → color grading → segment rendering end-to-end; invoke when a true footage segment is determined) | Four-tier footage priority (own screen recording > official video > screenshot > mockup card), video self-acquisition and editing pipeline, punch-in, unified color grading | | Audio | references/audio.md (true source rules) + Independent execution skill remotion-sfx (source selection → audition board → processing & archiving → cue mounting → quantitative verification; invoke when segment requires sound matching) | SFX pipeline, volume standards, master loudnorm, quantitative verification | | Typography / Layout / Texture / Motion / Infographics | design-system references/ | layout / typography / texture / motion / infographic | | Error Set (Symptoms → Fix Index) | Independent skill remotion-gotchas-index | Look up the fix location for full-text "Error #NN" (#18/#19/#23/#24/#25, etc.) here |

Engineering Substrate: This process assumes src/design/ (tokens/components/motion/qc probes/FontGuard) + src/koubo/scenes/shared.tsx (four-piece gating + Place + qcAllow) are already in place—they are the shared foundation for the entire repository, reused for new films, not rebuilt. For cold starts without src/, first build the substrate following the design-system SKILL's "Engineering Substrate Checklist" before entering this process.

End-to-End Flow for New Film (No Reference Footage: General Checklist from Rough Cut + SRT to Finished Film)

Clarification on Positioning (2026-07-20): No reference footage is the norm; having reference footage is an exception. Norm = editing original voiceover without a corresponding reference video, using the references/selection.md sentence grammar route and applying calibrated style specifications to produce a plan (this checklist is written for this scenario). Having reference footage (e.g., 1:1 replicating a baseline film for style calibration) is an exception, used solely for calibration and verifying that the style has been learned; don't treat "frame-by-frame alignment with reference footage" as the default process. Existing sections mostly use 0715-01/Baseline Film as examples (which had reference footage for frame-by-frame alignment during calibration). Self-produced films without reference footage follow this checklist—the general process is here; specific details of this film belong to their respective domain files. When reference footage exists, only insert the "original film contact sheet word-level alignment" step before step 4 (see §2 step 3 / §2.5 R&D Mode). All other steps remain the same.

1. Input Validation & Material Ingestion (§0 + §0.5): Receive rough cut + SRT. Follow the seven steps in §0.5 to transform "the two files the user dropped" into a workable state (same film check / file placement / subtitle draft / project skeleton / hardcoded code adaptation). Use ffprobe to determine fps/resolution; composition parameters must match the source material, do not default to 60fps (design-system Error #19); implement calculateMetadata programmatically.
2. Ask User about Composition (§1 / layout.md §1): Do not decide on left or right information zone placement by yourself. Extract 3-4 frames to see the person's position; user's ruling is final. By default, the author places the information MG on the left.
3. Read through SRT and Divide into Chapters (§2 Step 1): Cut into 15-20 segments based on semantic transitions. Select one main packaging point per segment. Simultaneously mark the five energy nodes on the timeline (hook / heavy verdict / VS decision / full-film verdict / CTA, see narrative.md §1).
4. Create Plan Based on Grammar (Core difference for no-reference footage): Without a reference film to copy beats from, first check each sentence against the references/selection.md sentence-type matching table to determine the segment type and main grammar (including primary shot three-sequence criteria). Then proceed to the domain source pointed to by the grammar pointer to get specifications—narrative defines the narrative skeleton and five nodes, rhythm defines beat changes and peaks, infographic defines metaphor visualization, layout defines three zones and takeover. If no match is found in the table, go to references/rd-noref.md. Forbidden to design from scratch without rules. Produce an Assembly Plan Table (assembly/<film-name>/assembly-plan.md: time range | voiceover key points | side label | main MG | material gap | bearer mode). Show it to the user for confirmation before writing any code.
5. Determine R&D/Production Mode (§2.5): If the main arrangement of all segments can be matched in existing grammar = full Production Mode (§2.5.1 five phases). Segments containing new arrangement patterns are elevated to R&D Mode for per-segment iteration.
6. Implementation + Three Gates (§2.5): Material segments use remotion-broll. HUD segments write code based on layout measurements. Sound matching uses remotion-sfx. Each segment passes QC probe → mg-judge → user final review.
7. Full Film Composition Pass (§2.6): Check across all segments for five items: color budget / side label continuity / rhythm density curve / SFX distribution / duplicate elements.
8. Mastering Chain + Delivery (§5/§6): After passing through the mastering chain (compression + loudness-normalization gain + limiter, audio.md rule 2), use ffprobe to verify duration, audio tracks, and bitrate. Deliver with evidence (QC report + rendered frame comparison). After delivery or rework wrap-up, update the project root STATUS.md's state line for this film (create if it doesn't exist; it is the cross-session/cross-agent status file, relied upon by any new conversation taking over).

0. Input Specification (User Delivery Convention)

• The user provides: Rough cut (breaths already cut) + Corresponding SRT. No whisper transcription needed.
• Interaction Contract (User Ruling 2026-07-21, Iron Rule Level): The user only supplies three things: ① Rough cut + SRT; ② Specifically requested materials (B-roll screen recordings/screenshots—AI first lists what's needed by name according to broll rule 2, or the user proactively provides them); ③ Natural language rulings and final review feedback (composition direction, hearing/feeling feedback with timestamps). Beyond this, the user must not be asked to provide any files: assembly plans, workshop documents, rework notes, cue sheets, etc., are all internal artifacts—AI creates, reads, and continues them itself. For rework/continuation, follow §0.5 Step 1's "Same Film Re-entry" to automatically load outstanding items. Forbidden to ask the user to copy, paste, or recount any process files.
• SRT timestamps are the sole benchmark for assembly: enterAt frame = SRT start seconds × composition fps.
• If the SRT is missing (only voiceover text is provided), only a plan-level beat table can be produced: label the time column as "estimated"; must recalibrate with the real SRT before writing code. If there's no rough cut to extract frames from, label composition decisions as "pending review."
• Composition fps/resolution must match the source material (check with ffprobe first, do not default to 60fps). If not 1080p@30: specifications, motion frame counts, and metadata assertions in qc-master.mjs must be updated accordingly. The complete list of dependencies is in design-system references/motion.md §0 (the existing calibration set is locked to 30fps).
• Subtitle generation and line break rules → references/subtitle.md.

0.5 Material Ingestion Action Checklist (New Film, Step 0: From user's mp4+SRT to workable state)

0. Environment Self-Check (Stop if it fails. No bypassing allowed. Host-agnostic): Write a test file in Bash (e.g., echo ok > assembly/env-check.txt) → Use a file-reading method to read it back and verify it's visible (Claude=Read tool) → Delete. If the write does not persist or the read-back fails, the session is running in sandbox mode, and all subsequent artifacts will be lost (Error #30: 0719-01 tests completely lost this way)—immediately stop and ask the user to grant write permissions (Claude=authorize Bash/Edit; Codex=workspace-write, etc.), then start work. Forbidden are three types of self-rescue bypasses: /tmp symlinks to bypass Chinese paths (just put double quotes around the entire path), self-removing sandbox (dangerouslyDisableSandbox or any similar host flag), or copying the project elsewhere to work. All file artifacts must use standard file-writing methods for persistence and be verified by reading back (Claude=Write tool preferred).
1. Same Film Check: Compare the duration from ffprobe with existing films in public/footage/. If within ±1s, consider it the same film → Ask user: "Reuse the old implementation or cut it as a new film?" If they choose to recut, do not read the old film's scenes code or assembly/<old-film-name>/ workshop documents (to prevent copying old answers or accidentally overwriting old films). Start a completely new process with the new film name. Same Film Re-entry (Continuation/Rework/Material Swap, Ruled 2026-07-21): When the user says "continue" or just drops new materials, automatically scan assembly/<film-name>/segment-workshop/segments.md for unfinished items + docs/<film-name>-rework-note*.md for unclosed entries, and directly list them as the current task list and start working—forbidden to ask the user to paste rework notes, recount history, or explain what to change (§0 Interaction Contract).
2. Determine Film Name: Format MMDD-NN (shooting date - serial number, e.g., 0715-01). Follow any name specified by the user.
3. Place Materials: Copy the rough cut to public/footage/<film-name>.mp4. If the source is 4K, first transcode to 1080p H264 before placing in footage (the composition is 1080p; decoding 4K for the OffthreadVideo base layer can cause stuttering and duplicate frames, leading to frozen people in the output. Error #33 confirmed this on 0721-01—transcode during ingestion, don't wait until render to find frozen frames and rework). Archive the original SRT in assembly/<film-name>/input/ (SRT is the sole benchmark for assembly and must be archived—0715-01 lesson: original SRT not archived, leaving only generated artifacts with no way to cross-check). Leave the user's original files untouched.
4. Validation: Run the ffprobe items from §0 + three SRT checks (UTF-8 readable, monotonically increasing timestamps, last entry's end time ≈ video duration) + Check for burned-in subtitles (mandatory after ffprobe): Use ffmpeg to extract any 1-3 frames, Read them, and visually confirm the rough cut has no burned-in subtitles or watermarks (0715-02 lesson: original delivery had full-film burned-in subtitles baked into pixels with no separate subtitle stream, causing ghosting with the new subtitles, only discovered at render output = a wasted QC round. If found, stop and ask the user to provide a version without subtitles or rule on occlusion).
5. Subtitle Draft: Run node scripts/srt-to-cues.mjs <archived-srt> <film-name> to mechanically convert and generate src/koubo/subtitles-<film-name>.ts draft (zh = SRT original, en = empty). Then follow subtitle.md rules 2/3 to complete semantic reordering, character proofreading (based on voiceover audio), and English translation. Proceed to assembly only after check-subs.mjs reports zero errors. These three steps are a single unit. English translation is not optional—check-subs now blocks en being completely empty / coverage < 90% (Error filed 2026-07-27: the 0727-01 version only did reordering, leaving 77 entries' en entirely empty, causing the final film to degrade into single-line Chinese. The old check-subs only validated format when en was non-empty, silently passing it when en was completely empty). To intentionally make a monolingual film, explicitly pass --mono to distinguish "this is a decision" from "this was omitted by mistake."
6. Project Skeleton: Run node scripts/scaffold-koubo.mjs <film-name> <duration-seconds> to generate everything at once (subtitle track / SFX track + empty cue table / main component / scenes-<film-name>/ directory + placeholders / workshop segment table; volume uses current baseline. Paste the Root.tsx registration snippet printed at the end of the script. Segment file directory is isolated from old film scenes/—file locks are per-film to avoid name collisions. The shared substrate is still imported from src/koubo/scenes/shared.tsx.
7. Two Hardcoded Values to Change When Swapping Films: render-service's COMP_ID/ENTRY and qc-master's metadata assertions. See §6 "Mandatory Changes When Swapping Films" for details.

1. Composition & Three-Zone Layout → design-system references/layout.md

Always ask the user about composition first (0715-01 lesson: the direction of the information zone must not be assumed; user ruled it goes on the left). The three-zone coordinates, takeover material handover mechanism (Level A: character exits entirely, no PiP; elevation moments use font size increase + area clearance + red/blue mirror frames; Level B dimming has been vetoed by the user), hero moments, and grouping templates are all in layout.md—it is the sole source of truth for layout.

2. Segmentation Method: Plan First, Then Code (Two Steps)

1. Read through SRT and Divide into Chapters: Cut into 15–20 segments based on semantic transitions (opening hook / argument / case study / transition metaphor / subtypes progression / summary / prediction / ending). Select one "main packaging point" per segment.
2. Produce Assembly Plan Table (assembly/<film-name>/assembly-plan.md): time range | voiceover key points | side label | main MG | **rule basis** | material gap | bearer mode. Show it to the user for confirmation before writing any code. The "Rule Basis" column is the acceptance proof for the §0.1 Pre-Production Gate (Added 2026-07-27): For each segment, fill in the entry number that the segment's main arrangement is based on (e.g., motion §7 number scrolling / narrative §5 verdict elevation / selection comparison-review sentence). If you can't fill in an entry number = that segment was designed by instinct; go back, read the true sources, and redesign—this column is not paperwork; it's the only verifiable evidence of whether you've read the documents (the 0727-01 plan had 27 segments with zero rule citations, resulting in the entire film's motion effects being only one type of Fade In).

Bearer mode for B-roll must be asked first (User Ruling 2026-07-24, Mandatory for landscape films): When segmenting, mark the segments that need B-roll / Picture-in-Picture. For each such segment, if the user hasn't provided the material, proactively suggest your understanding and ask: should this segment use "Full-screen B-roll" (character exits, material fills the entire screen) or "Picture-in-Picture card" (character is present, material in a small card on the right, like 0722-01)? The bearer mode decides three things at once: ① Layout: Full-screen cuts character vs Card + character remains (layout §2 iron rule); ② Resolution/Tools: For PiP, 720p is sufficient (can use Grok/gbro collage); for full-screen, true 1080p is needed—grok CLI tested has only 480p/720p, insufficient; must use xAI API (grok-imagine-video-1.5 supports 1080p), real footage, or Sora/Veo/Kling/Seedance (see broll SKILL ④); ③ Material Direction: Based on this, I can go generate AI material or ask the user/editor to find it. Don't decide the bearer mode yourself—the 0722-01 incident happened because the bearer mode was defaulted to full-screen with a uniform aspect ratio, causing two rounds of rework.

Parallel Rendering for Segments with Unavailable Materials (Speed-up Iron Rule, User Ruling 2026-07-24): After the bearer mode and material direction are confirmed, do not block waiting for materials. Render all pure MG segments that don't depend on external materials first, leaving placeholders only for the few segments waiting for B-roll/PiP. After materials arrive, only re-render those few segments and splice them back into the full film (segment render spliced back is at the 22s level, see §6). In other words: decouple material-dependent segments from independent ones. While the user is looking for materials, the main session renders everything it can, maximizing parallelism. 3. If the voiceover script originates from a reference video (transcribed/rewritten), you MUST first extract the original video's contact sheet and align segment by segment (ffmpeg every 10-15s frame compiled into a grid), base decisions on the original video's actual treatment, and do not improvise—all 8 deviations in the first assembly came from not looking at the original video first.

2.5 Segment Alignment Workshop (User Ruling 2026-07-16; Two-mode criterion appended 2026-07-17)

R&D Mode vs Production Mode (Ruled after user requested speed-up; First principle: if the grammar is already established, no need to rediscover it):

• R&D Mode (This section's full process: intensive frame reading → plan → multi-route verification → per-segment final review) is only for segments that introduce a new arrangement pattern—Criterion: the segment's main arrangement cannot be mapped to any existing grammar in the current rules of narrative/rhythm/infographic/specs. R&D Mode has two method routes, A/B: With reference footage available for frame extraction = R&D-A (Step 2 of this section: read reference frames); Grammar gap and no reference footage = R&D-B, whose method body is in references/rd-noref.md (multi-option generation → judge panel selection → user finalization → precipitate and write back). Step 2 of this section does not apply to R&D-B.
• Production Mode (Pattern-reuse segments): Does not go through the per-segment loop. Follows a "full segment fan-out parallel + centralized integration" batch topology (five phases detailed in §2.5.1)—Criterion is the inverse: the main arrangement of all segments can be mapped to existing grammar. If a particular segment's judge rejection rate rises = that segment actually contains a new pattern. Elevate it to R&D Mode independently, without slowing down other segments (Threshold for elevation: ≥2 batch rejections for the same segment or user final review rework, see §2.5.1 Phase 4).

R&D Mode Per-Segment Loop:

1. Extract Segment: Align with the reference footage and cut into dozens of clips (starting at chapter level, drill down to beat level for problematic segments). Multi-session parallel discipline (User Instruction 2026-07-17): Before starting work, read the segment table at assembly/<film-name>/segment-workshop/segments.md (e.g., assembly/0715-01/segment-workshop/segments.md)—do not touch segments with a placeholders. Before starting your work, write a placeholder row first (session identifier + scope list: which file blocks you will modify). All rendering/npm operations are serial across the entire project (Errors #23/#24). Before rendering, check for other processes with pgrep. For a new film entering the workshop for the first time, this file doesn't exist: The main session initializes it—run mkdir -p assembly/<film-name>/segment-workshop/ then create segments.md, following the format of the 0715-01 segment table (one row per segment: segment number | time range | main packaging point | scope files | placeholder/claim status). Build the table before assigning work; sub-agents only claim, they do not create new rows.
2. Look at Reference (Word-Level Alignment, User Ruling 2026-07-16): Extract dense frames (0.5s/frame) of the corresponding segment from the reference video. If the transcript matches the reference video, use the reference video's embedded subtitles as the alignment axis—each frame has "what he's currently saying," allowing you to reconstruct a word-level beat table of "saying what word → what MG appears," then find the corresponding time point in our SRT. Comparison must involve reading and understanding each frame (element specs, interaction relationships, make-way actions). Forbidden to only look at file names or thumbnails. First determine "real footage segment or hand-drawn HUD segment" (see broll.md overview), then measure first, write code second—measure the element's screen ratio/font size/position from reference frames. Forbidden to estimate by eye (seg01 lesson: estimation leads to systematic shrinkage of 0.4-0.7x). Produce the Plan for that segment (beat table + gap diagnosis + fix method + comparison screenshots). Show it to the user for confirmation before modifying any code.
3. Build: Go through the acquisition pipeline for material segments; write code based on measured values for HUD segments.
4. Render the Segment: --frames=a-b takes tens of seconds. Delete old artifacts before rendering to prevent ○ caching.
5. Validation (Three Gates, Starting 2026-07-16; Static Gate added before them on 2026-07-27): ⓪ Substrate Reuse Gate (node scripts/check-scenes.mjs src/koubo/scenes-<film-name>) — Statically scans the scene directory: zero references to design/motion, zero exit components (useExit/Exit/ClearOut, motion §1 sev5), each is FAIL; component category count lower than the segment count tier (short film <10 segments, 3 categories / long film 5 categories) reports WARN; exit coverage < 50% reports WARN; self-built kit > 150 lines but zero motion references reports WARN. At the end, print a self-check list (number scrolling / verdict slam / chapter clear-screen / single motion vocabulary type). These four items cannot be detected by static scanning; you must watch the continuous footage yourself. (Thresholds revised after adversarial review on 2026-07-27: The initial version's "Breathe zero references reporting WARN" was removed—directly conflicts with motion §9 "New films shall never use Breathe"; the "component categories <4 ..." section was truncated.

---

😅 Oops! I hit the length limit. It seems the full SKILL.md content was truncated in your input. I have translated the first part completely. To ensure the final skillMarkdown key is complete and accurate, could you please provide the remaining portion of the text? I will then translate it and assemble the final JSON response. Just paste the rest of the SKILL.md content.

In the meantime, here is the JSON structure I have prepared, which includes the fully translated sections so far. Once you provide the remaining text, I will complete the skillMarkdown field.

{
  "name": "Voiceover MG Assembly Line",
  "description": "Assembly line for voiceover/MG: complete editing logic from rough cut + SRT to finished film. Must-read when assembling, editing voiceover, or packaging videos. Trigger words: assembly, voiceover, editing, finished film.",
  "aiSummary": "...",
  "skillMarkdown": "... (full translated markdown will be placed here)"
}