publishers-build-trailer

/publishers-build-trailer

Build a finished trailer MP4 from a production doc.

What this does

This skill is a thin orchestrator around great-filmmakers' three render scripts (scripts/render_keyframes.py, scripts/render_kling.py, scripts/render_veo.py), copied into the project by /filmmakers-project-init (v1.6+ of great-filmmakers). It:

1. Reads .great-authors/project.md to determine genre and surface content-policy implications.
2. Locates the production doc (film/screenplay/<slug>.veo3.md or <slug>.kling.md).
3. Runs the matching render-script chain end-to-end:
   • For Kling: render_keyframes.py → render_kling.py (image-to-video)
   • For Veo: render_veo.py (text-to-video)
4. Assembles the rendered shots into a single trailer MP4 via ffmpeg.
5. Outputs film/render/<slug>-trailer.mp4.

The skill does not invent the engine choice or rewrite the production doc. If you need a different engine, run /filmmakers-crew --backend <name> first to regenerate the doc, then run this skill.

When to use

• A production doc has been generated by /filmmakers-crew and reviewed.
• The render scripts (scripts/render_*.py) have been copied into the project by /filmmakers-project-init (v1.6+ of great-filmmakers).
• API keys are funded and sourced from ~/.config/dev-secrets/secrets.env.
• You want a finished trailer in one command.

Not for: the first render of a new project (run /filmmakers-crew and the individual render scripts manually first to validate); experimentation with engine choices (use the individual scripts directly with --only and --dry-run).

Instructions for Claude

When this skill is invoked with a <project> argument (or no argument):

1. Resolve the project root the same way /publishers-build-book-site does. Verify .great-authors/project.md, film/, and scripts/render_*.py all exist. If any are missing, report and stop.

2. Read the bible for content-policy signals:

   • .great-authors/project.md — genre field
   • If genre includes mystery, thriller, crime, horror, or violence-adjacent terms, prepare a content-policy warning before submission

3. Locate the production doc. Look for film/screenplay/<slug>.veo3.md or film/screenplay/<slug>.kling.md. Determine engine from filename. If both exist, ask the user which to use. If neither exists, report and stop with a recommendation to run /filmmakers-crew first.

4. Pre-flight: surface the content-policy implications.

   For Veo (*.veo3.md):

   • Veo refuses prompts that name bodies, violence, or graphic content
   • If the project genre is crime / thriller / horror / mystery, the user should review the production doc for prompts that may be refused
   • Print: "⚠️ This production doc targets Veo. The project genre is <genre>. Veo content policy refuses prompts naming bodies, blood, violence, or weapons. Review <doc> for refusal-prone prompts before continuing — the render will fail mid-pipeline if any shot is rejected. Continue? (y/N)"

   For Kling (*.kling.md):

   • Kling is more permissive but has its own constraints (model-name drift, aspect-ratio defaults)
   • Print a lighter advisory: "Kling backend chosen — generally more permissive on stylized animation. Submitting shots."

5. Verify API credentials are sourced:

   • For Veo: GEMINI_API_KEY (or GOOGLE_API_KEY)
   • For Kling: KLING_ACCESS_KEY and KLING_SECRET_KEY
   • For keyframes (always): OPENAI_API_KEY
   • If any are missing, instruct the user to source canonical secrets and re-run:

     set -a && source ~/.config/dev-secrets/secrets.env && set +a
     

6. Run the keyframe pass (always, for both engines if the production doc has keyframes):

   • Look for film/render/kling/keyframes/PROMPTS.md (the director's keyframe prompt set, generated by Hitchcock-persona or another visual director in great-filmmakers' pipeline)
   • If it exists, run: python3 scripts/render_keyframes.py
   • If it doesn't exist, skip the keyframe pass and proceed (the production doc may not need keyframes — Veo text-to-video doesn't, Kling image-to-video does)

7. Run the engine-specific render:

   • For Kling: python3 scripts/render_kling.py film/screenplay/<slug>.kling.md
   • For Veo: python3 scripts/render_veo.py film/screenplay/<slug>.veo3.md
   • These scripts are idempotent — completed shots are skipped on re-run.

8. Assemble the trailer:

   • Read the shot order from the production doc (shots are H3 headings in order)
   • Build an ffmpeg concat list of film/render/<engine>/<shot-id>.mp4 for each shot
   • Run: ffmpeg -f concat -safe 0 -i <concat-list> -c copy film/render/<slug>-trailer.mp4
   • If any shot MP4 is missing, report which one and stop with a recommendation to re-run the render with --only <shot-id>

9. Report:

   🎬 Trailer rendered.
   
   Source doc:    film/screenplay/<slug>.<engine>.md
   Engine:        <Kling 2.5 / Veo 3.0 Fast>
   Shots:         <N>
   Total length:  <M>s
   Output:        film/render/<slug>-trailer.mp4 (<size>)
   
   Next:
   - Review locally: open film/render/<slug>-trailer.mp4
   - Embed in book site: copy into <project>-book/public/clips/<slug>-trailer.mp4
   - Save trailer concept brief: /publishers-channel chip → "save as trailer concept"
   

Cross-plugin orchestration

This skill consumes great-filmmakers' artifacts. The dependency chain:

/filmmakers-crew <source>            → produces .veo3.md or .kling.md production doc
/filmmakers-channel hitchcock  → produces PROMPTS.md keyframe set (when image-to-video)
/filmmakers-project-init             → copies render scripts into <project>/scripts/
/publishers-build-trailer      → composes the renders into a finished trailer

If the user invokes this skill before any of those upstream pieces are in place, the skill reports what's missing and points them at the right upstream command. It does not try to substitute for them.

Content-policy awareness

The pre-flight content-policy check is non-negotiable. Hitting MOVIO_PAYMENT_INSUFFICIENT_CREDIT or Veo's content-policy refusal mid-render after the user has already paid for half the shots is the worst outcome. Surface the risk before submission. The user should make an informed choice, not discover the constraint at render time.

What the skill does NOT do

• Does not write the production doc. That's /filmmakers-crew.
• Does not generate the keyframe prompts. Those come from a director persona in great-filmmakers (Hitchcock, Deakins).
• Does not invent shot durations. The production doc carries them.
• Does not switch engines mid-pipeline. If you want both Veo and Kling shots in the same trailer, the production doc has to be authored for that — currently a manual edit, may become a --mixed-engine flag in v1.x.
• Does not deploy or upload. The trailer lands as a file; what happens to it is up to the user (book-site embed, social rollout, festival submission — all separate).

Notes

• The trailer-build is intentionally a thin orchestrator. The render scripts are the work; this skill composes them and surfaces the trade-offs. When the underlying scripts evolve, this skill rides those changes for free.
• If the user wants to render only some shots (for cost or iteration), they should use the individual render scripts with --only rather than this skill. This skill assumes a full-trailer build.
• The output file name uses the production doc's slug. If the user wants a different name, they can copy the file after the build (cp film/render/<slug>-trailer.mp4 film/render/launch-trailer.mp4).