Brief du réalisateur (étape 10 du cours)
Les films longs sont des productions. Les briefs derrière les films de nuit du cours ne décrivent pas une vidéo ; ils engagent une
équipe : une logline pour vérifier chaque décision, des références, des outils et un budget, une bible des personnages, une feuille de rythme,
des règles pour le texte à l'écran, des portes, une boucle de critique et des livrables. Cette compétence transforme l'idée de l'utilisateur en ce brief
et exécute la production à travers ses portes. Pour des clips jusqu'à environ 45 secondes sans chapitres, utilisez
/motion-studio:motion-reel à la place (le même seuil que cette compétence utilise pour confier un film plus long à celle-ci).
Arguments, affichés une fois :
Les fichiers de cette compétence se trouvent dans ${CLAUDE_SKILL_DIR} (le template du brief est
${CLAUDE_SKILL_DIR}/assets/brief-template.md, assets/brief-template.md).
Coût de cette compétence
Elle s'exécute avec l'effort max : le raisonnement le plus profond et l'utilisation de jetons la plus élevée de toutes les compétences motion-studio. Les
erreurs de planification se cumulent sur des heures de travail autonome, donc le plan est l'endroit où cette dépense porte ses fruits. Définissez les attentes avec
l'utilisateur avant de commencer. Points de données rapportés du cours : un clip musical de nuit a duré environ 12 heures et utilisé environ
80% de l'utilisation d'un forfait Max plus 75 $ de crédit API image/vidéo ; un court métrage peint à la main de 45 secondes a pris 163 appels de modèle,
62,7 M de jetons (96 % de lectures de cache), environ 34 $ aux prix catalogue de l'API et environ 6,75 heures. Gardez le reste moins cher : les animateurs
de chapitre fonctionnent avec leur propre effort (élevé), et les corrections et re-rendus sont des travaux d'effort moyen. Dites à l'utilisateur de baisser
l'effort de la session avec /model une fois le plan approuvé si le budget compte.
1. Collecter les entrées
Seule la session principale peut poser des questions à l'utilisateur (les sous-agents ne le peuvent pas). Si l'utilisateur a dicté un long brief, analysez-le autrement que de re-demander. Sinon, demandez une fois, dans un seul message, ce qui manque :
| Entrée | Pourquoi |
|---|---|
| logline, et ce que le spectateur devrait ressentir à la fin | chaque décision est vérifiée par rapport à elle |
| durée, formats, où il sera publié | nombre de chapitres, temps de rendu, zones de sécurité |
| références (vidéo, images, bibliothèque d'images, dépôt antérieur) | grammaire à adopter, contenu à éviter |
| musique : un morceau (et sa licence) ou "synthétiser" | la grille rythmique sur laquelle tout se cale |
| itinéraire (A par défaut ; B seulement s'ils nomment Remotion/HyperFrames ; C générer puis tracer) et clés API par nom de variable | outils et dépenses |
| budget : utilisation du modèle, API payantes, temps réel | quand arrêter de générer |
| mode : PLAN FIRST ou GO | s'arrêter après le plan ou non |
2. Écrire docs/brief.md
- S'il n'y a pas de
studio.json, exécutez/motion-studio:studio-initd'abord (définissez--duration,--bpm,--formats). - Copiez
${CLAUDE_SKILL_DIR}/assets/brief-template.mdversdocs/brief.md. Remplissez la partie A avec les réponses de l'utilisateur ; gardez la partie B telle quelle. - Mettez à jour
studio.jsonpour qu'il corresponde (titre, durée, fps, bpm, formats, marque,loop). - PLAN FIRST : montrez le brief rempli et arrêtez-vous jusqu'à ce que l'utilisateur approuve. GO : enregistrez chaque décision que vous avez prise pour
l'utilisateur dans
docs/decisions.mdet continuez.
3. Porte 1 : documents de planification
| Fichier | Contenu | Qui l'écrit |
|---|---|---|
docs/style_guide.md | palette, typographie, rythme, transitions, texture, looks interdits | sous-agent style-analyst à partir des références (/motion-studio:reference-style), ou vous |
docs/STORYBOARD.md | l'idée, le casting, ce qui lie le tout, chapitres avec plans minutés et transitions | sous-agent motion-director, ou vous |
docs/shotlist.md | chaque plan sur la grille rythmique (mesures), caméra, texte, SFX | motion-director |
| plan des chapitres (dans STORYBOARD) | limites des chapitres sur les temps forts, propriétaire par chapitre | vous |
Mesurez ou synthétisez la musique avant de minuter quoi que ce soit (/motion-studio:sound-design) : les temps des chapitres et des plans sont
des valeurs grid.bar(n), pas des estimations. Gardez les chapitres de 8 à 30 secondes pour qu'un sous-agent puisse en terminer un et le vérifier dans une session.
Le motion-director écrit seulement dans docs/** (le hook role-guard l'applique).
4. Porte 2 : montage et guide
- Écrivez
docs/ANIMATION_GUIDE.mdà partir du template dans ledocs/du projet avant que tout animateur de chapitre ne commence, afin que chaque chapitre soit codé dans le même style : comment fonctionne un chapitre, propriété, disposition et bandes réservées, l'API partagée, éléments partagés, règles de style avec un budget de temps de peinture, et les commandes de vérification exactes. - Construisez vous-même les éléments partagés (personnage principal, kit UI, aides de palette) dans
film/scenes/shared_<nom>.js. Les animateurs de chapitre les importent et ne les modifient jamais. Rendez des images fixes de chaque élément dans chaque état. - Créez une ébauche de chaque chapitre pour que le film soit rendu de bout en bout pendant que les chapitres sont en cours :
// film/scenes/ch03_build.js (ébauche écrite par la session principale ; l'animateur du chapitre remplace les plans)
import { chapter } from '../../lib/timeline.js';
export const BARS = [12, 20]; // étendue en mesures depuis docs/STORYBOARD.md (null = jusqu'à la fin)
export default function ch03(ctx) {
const FROM = BARS[0] === 0 ? 0 : ctx.grid.bar(BARS[0]);
const TO = BARS[1] == null ? ctx.dur : ctx.grid.bar(BARS[1]);
return chapter({ name: 'ch03_build', from: FROM, to: TO, shots: [], cues: [] }); // pas de plans = carte de remplacement
}
- Câblez
film/film.jsune fois.buildFilmaccepte les résultatschapter()à l'intérieur descenes, aplatit leurs scènes et fusionne leurs cues. Les calques à l'échelle du film (sous-titres, transitions de jointure) vont dans lesoverlays: Scene[]de l'usine : ils peignent après chaque scène, dans l'ordre du tableau, sur la même règlefrom <= t < to(inclusif à la fin à la dernière image du film), et ils ne comptent jamais comme des plans, donc les étiquettes d'images fixes, les limites de plans de la critique et la liste des aperçus listent uniquement les plans des chapitres. Le code des chapitres reste intact ; n'enveloppez pas et ne patchez pas les fonctionsdrawdes chapitres. Les tableaux imbriqués,nullet les résultatschapter()sont également acceptés dansoverlays, donc un chapitre peut fournir ses propres scènes de superposition. Pour empiler des scènes ordinaires, donnez à une scène un numéro delayer(0 par défaut) : les scènes peignent par(couche, from).
import { defineFilm, scene } from '../lib/timeline.js';
import ch01 from './scenes/ch01_hook.js';
import ch02 from './scenes/ch02_problem.js';
import ch03 from './scenes/ch03_build.js';
const CHAPTERS = [ch01, ch02, ch03];
export default defineFilm((ctx) => ({
scenes: CHAPTERS.map((make) => make(ctx)),
overlays: [
scene(0, ctx.dur, 'captions', (g, lt, c) => { /* sous-titres à l'échelle du film : dessiner à partir du temps de film c.t */ }),
// une courte scène par jointure de chapitre qui nécessite une transition, minutée à partir de la grille
scene(ctx.grid.bar(12) - 0.2, ctx.grid.bar(12) + 0.2, 'seam-ch02-ch03', (g, lt, c) => { /* fondu ou flash */ }),
],
cues: (grid) => [{ t: grid.bar(0), type: 'hit' }], // cues au niveau du film ; les cues des chapitres sont fusionnées automatiquement
}));
5. Distribuer les chapitres
Lancez un sous-agent chapter-animator (motion-studio:chapter-animator) par chapitre, plusieurs en parallèle. Briefez
chacun avec : son fichier (film/scenes/chNN_<nom>.js), son étendue (l'export BARS dans son ébauche, plus la même étendue en
secondes pour les commandes de vérification), sa section STORYBOARD, et "suivez
docs/ANIMATION_GUIDE.md". Le hook role-guard permet à un animateur de chapitre d'écrire seulement dans film/scenes/** (sauf
film/scenes/shared_*, qui restent en lecture seule pour les animateurs de chapitre, qui signalent les bogues des fichiers partagés) et
out/check/**. Chacun retourne un rapport : ce qu'il a construit, images fixes de vérification, problèmes connus, et bogues qu'il a trouvés dans les fichiers
partagés. Vous corrigez les fichiers partagés, relancez les vérifications sur l'ensemble du film, et rebriefez un chapitre lorsque son rapport montre un
problème.
Les étendues des chapitres sont en mesures, calculées avec ctx.grid à l'intérieur de l'usine du chapitre, donc les chapitres consécutifs se rejoignent toujours et
suivent une piste mesurée. Les temps des plans sont des secondes de film absolues prises de la grille
(shots: [{ at: grid.bar(13), name: 'assemble', draw }, ...]) ; chaque plan s'exécute jusqu'au at du suivant, et son
draw(g, lt, c) reçoit lt depuis le début du plan. Un plan en dehors de l'étendue de son chapitre fait lever une exception par chapter() et le film cesse de
se charger (par exemple, un TO = 4 littéral rejette un plan à grid.bar(1) = 4,003 s une fois qu'une piste mesurée place
le premier temps fort à 2,0 s).
6. Portes 3 à 8
| Porte | Faire | Vérifier |
|---|---|---|
| 3 images fixes | node tools/stills.mjs --shots (une image fixe par plan) | tour de critique (/motion-studio:critique-loop) |
| 4 animatique | npm run animatic (demi-échelle, 30 ips, sans flou) avec la piste réelle ou de remplacement | rythme : chaque lecture arrive avant le prochain temps fort |
| 5 échantillon le plus difficile | node tools/render.mjs --from A --to B --out out/check sur les 2 à 4 s les plus difficiles | node tools/critique.mjs --strip-at <t> ; déterminisme ; synchronisation |
| 6 passage complet | aucun remplacement restant (aucune étiquette de plan dans node tools/stills.mjs --shots ne se termine par /placeholder) | tour de critique sur l'ensemble du film |
| 7 polissage et son | /motion-studio:sound-design : partition ou beats, cues, SFX, voix | métrique de synchronisation, axe sonore |
| 8 final | npm run build | la définition du terminé dans le brief B6 |
Les films longs sont rendus en segments repris en cas d'interruption : node tools/render.mjs --format all --final --chunk 10 écrit
out/<fmt>/.parts/seg_<a>_<b>.mp4 et saute les segments terminés lors d'une ré-exécution après une interruption. Exécutez les rendus longs en
arrière-plan (l'outil Bash run_in_background, ou un fichier journal que vous interrogez) au lieu de bloquer la session, et n'attendez jamais
au premier plan plus d'environ 2 minutes. Prévoyez environ 20 secondes de temps réel par seconde de film pour trois
formats à 60 ips et 4 sous-images (un film de 2 minutes représente environ 40 minutes de rendu) ; le manuel du pipeline de
/motion-studio:motion-reel contient le modèle et le temps prévu de chaque autre commande. Un animateur de chapitre ou tout
autre sous-agent ne doit pas retourner tant qu'une commande qu'il a lancée est encore en cours d'exécution.
7. Itinéraire C : générer puis tracer (optionnel)
Uniquement lorsque le brief sélectionne l'itinéraire C et liste les clés (par nom de variable : FAL_KEY, ELEVENLABS_API_KEY dans .env)
et un budget. Les modèles vidéo donnent la physique, le timing et les visages qui sont difficiles à coder à la main ; la couche de code donne un aspect
cohérent que l'utilisateur possède. Les spectateurs voient la couche de code.
- Générez des feuilles de personnages et des plans de base avec le service choisi par l'utilisateur, en suivant sa propre documentation. Sauvegardez chaque résultat
sous
refs/base/avec une ligne de manifeste (service, modèle, prompt, seed, coût, licence). Arrêtez-vous au budget. - Extrayez des images à étudier :
node tools/refs.mjs extract refs/base/shot01.mp4 --every 0.1 --out refs/base/shot01. - Redessinez chaque plan en code par-dessus ce timing (regardez les images, reconstruisez le mouvement avec des ressorts et des pistes).
Les images de base ne sont jamais chargées depuis le réseau au moment du rendu ; si un plan compose une image de base, chargez-la depuis un fichier
local dans
setup(). - Vérifiez la synchronisation : images fixes de la couche de code à côté des images de base aux mêmes instants, et les cues audio sur la grille. Re-exécutez l'étape pour tout plan qui dérive.
Clés : ne les imprimez, écho, journalisez ou collez jamais. Les outils lisent .env eux-mêmes ; nommez la variable dans les invites et les docs.
8. Définition du terminé et rapport
Le B6 du brief est le contrat : sonie -14 LUFS +-0,5 et <= -1 dBTP sur le MP4 livré, au moins 3 tours de
critique avec chaque axe >= 8 et pas de P0 (npm run gate), un re-rendu donne des images identiques (vérification de déterminisme de la critique
plus valeurs framesDigest égales venant de deux rendus --hash), durée et images exactes dans chaque format, et tous les livrables présents
(npm run deliver vérifie la plupart de cela et écrit docs/production.json). Terminez avec le rapport B7 : livrables,
scores par tour, dépenses réelles, défauts connus, ce que vous amélioreriez ensuite.
Crédits : le squelette du brief suit l'étape 10 du cours ; la répartition remplir / garder tel quel, PLAN FIRST vs GO et une
définition du terminé suivent un modèle de template public par @pradeepXkapoor (reformulé) ; les portes d'acceptation sont adaptées
de athemeroy/awesome-opus-5-5-videos docs/production-brief.md (CC BY 4.0) ; le motif de sous-agent guide-plus-storyboard
a été étudié dans JohnHeibel/PDoomVideo (idées uniquement, aucun texte réutilisé).
Suite : /motion-studio:critique-loop après chaque porte à partir de 3, puis /motion-studio:ship-formats pour livrer.