@slatesvideo/shared 0.6.1 → 0.6.3

package/skills/slates-dialogue-blocking.md

@@ -0,0 +1,134 @@
+---
+name: slates-dialogue-blocking
+description: Keep multiple characters spatially consistent across cuts — seating, screen direction, eyelines, the 180-degree rule — by blocking the scene in 3D first. Use for any multi-character dialogue scene, conversations around a table or in a car, or when generated characters swap seats, change sides, or look the wrong way between shots.
+---
+
+# Dialogue blocking — six people who stay where you put them
+
+The hardest thing to generate, and the case where previs beats raw prompting by the widest margin.
+
+## Why this is hard
+
+Every cut is an independent guess unless something forces agreement. Prompt a six-person conversation four times and you get four different seating charts: characters swap places, the 180-degree line breaks, and nothing cuts together. The failure is not aesthetic — the shots are simply unusable as an edit, and you find out only after paying for all four.
+
+**The blocking fixes it structurally.** Positions exist in 3D, so every camera sees the same arrangement, and consistency stops being something the model has to remember.
+
+## Build
+
+Follow `slates-previs-blocking` and add these.
+
+### Seated proxies, colour-coded
+
+Simple seated shapes. **Do not animate the heads** — a proxy head turning the wrong way is worse than one that never turns.
+
+Give each character a distinct viewport colour and write the mapping down. This is the identity channel:
+
+> red = the boss · green = the kid · blue = the driver · yellow = the fixer · purple = the cousin · cyan = the nephew
+
+That mapping goes verbatim into the generation prompt. It is what lets the model bind a grey body to a character sheet across four cuts.
+
+Give every proxy a material and set `mat.diffuse_color` to its identity colour — the blocking render pins Workbench to `MATERIAL` shading, so **the material's `diffuse_color` is what reaches the clip**. Set `object.color` to the same value too, so the user's viewport matches what renders. See `slates-previs-blocking` for the snippet.
+
+### Fix the geography, then never move it
+
+Place people once. Write down who sits where relative to the camera's opening position, in words, because that sentence is going into the prompt:
+
+> Across the table, facing camera: yellow dead centre, purple far left, blue and green to the right.
+
+### The camera plan
+
+Per `slates-camera-language`, with two things specific to dialogue:
+
+- **Below shoulder height, slow rail glides.** Eye-level-and-above reads as surveillance.
+- **Decide who owns the near foreground in each cut and honour it.** A shoulder in frame is a spatial anchor; a different shoulder in the next cut relocates the whole room.
+
+The move that earns the most: **a gaze handoff without a cut** — the camera keeps gliding while the target hands off across the table, face to face, slowing on each but never stopping. Build it by keyframing the Track To target's position between subjects.
+
+### Crossing behind someone
+
+A head wiping frame during a move is a strong depth cue. It is also a spatial claim, so pick who gets crossed and say so — *the camera crosses directly behind cyan's back mid-shot and his head wipes the frame once.*
+
+## The prompt
+
+Everything in `slates-blocking-to-prompt`, plus these blocks.
+
+### Geography — restate it as a rule
+
+> TABLE GEOGRAPHY — do not deviate: the camera is never parked behind red. Only in the opening seconds does his dark shoulder hang at the near frame RIGHT edge, and it slides out as the camera travels LEFT. The true near-foreground of this shot is cyan: the camera crosses directly behind him mid-shot. After the opening seconds red is gone from the foreground, and the camera never travels behind anyone except cyan.
+
+### Screen direction, and the mirror that is not a swap
+
+The 180-degree rule survives on its own in the blocking. What breaks is the model **"correcting" a legitimate mirror** — when the camera faces back through a scene, sides invert, and that inversion is correct. Say so explicitly or it gets flipped:
+
+> The driver's seat is on the LEFT for the entire timeline; this layout never mirrors or flips. When a camera faces BACKWARD into the car, screen sides mirror naturally: the driver reads on the RIGHT of frame, the passenger on the LEFT — that is correct left-hand drive, not a swap. They never swap seats or roles anywhere in the timeline.
+
+Then compress it into the HOLD block: *(backward camera mirrors them: he right of frame, she left)*.
+
+### Presence
+
+> A seated person stays drawn even when partially occluded — in every interior frame some part of each seat's owner is visible: a hand, an arm, a shoulder, a head above the bolster. Every occupied seat visibly holds its person.
+
+### Keep everyone alive
+
+Three orthogonal layers. Without them, whoever is not speaking freezes:
+
+- **ONGOING BUSINESS** — a small continuous physical action per character, running whether or not they are speaking. *turns his glass a quarter every few seconds · thumbs a lighter without lighting it.*
+- **BACKGROUND LIFE** — soft-focus, low contrast, never pulls attention, never crosses in front of a speaking face.
+- **SCENE EVENT** — the unnamed thing everyone is playing but nobody says. One line, repeated verbatim in every character's direction: *keep tomorrow sounding like a fishing trip.*
+
+### Acting, per character
+
+Same six slots each. Terse:
+
+```
+ACTING TASK — <character>
+  SCENE DIRECTION (shared, unspoken): <the same line for everyone>
+  MOTIVE (his fuel): <what he wants underneath>
+  GOAL: <what he wants in this scene>
+  OBSTACLE: <what is in the way>
+  TACTIC: <how he goes about it>
+  Moment to moment: <2-3 beats keyed to timestamps>
+  (Safety: gaze always engaged in the task — never a frozen, glassy,
+   unfocused stare; natural blink cadence.)
+```
+
+That safety line is not filler. Dead eyes are the characteristic failure of generated faces in dialogue, and naming it is what prevents it.
+
+### Split any strong emotion into phases
+
+The other characteristic failure is a face that strikes one extreme expression and holds it for the whole shot — a mouth stuck open for three seconds. Give the beat two phases with a hinge, and name the failure you are excluding:
+
+> PHASE 1 (17.3-18.6s) — she SCREAMS at him, mouth wide, eyes huge, hand clamped on the grab handle. PHASE 2 (18.6-19.9s) — the scream breaks off: she shuts her eyes tight and CLOSES her mouth, both hands now on the handle, head ducked, braced. Scream, then brace — never one frozen open mouth held through the whole shot.
+
+The hinge timestamp is what makes it a performance instead of a pose.
+
+### Dialogue must not restructure the edit
+
+Both of these, verbatim, every time:
+
+> DIALOGUE NEVER CREATES SHOTS: spoken lines happen inside the reference's takes exactly as blocked — no cutaways to a speaker, no reverse shots, no added close-ups. If a line plays while the camera is elsewhere, the line stays off-screen audio.
+
+> OFF-SCREEN VOICES RULE: a line marked off-screen must STAY off-screen — never show the speaker, never move him into frame, never route the camera behind him because he spoke.
+
+A sentence may cross a cut. Say so where it does: *the sentence does not pause for the edit.*
+
+## Model routing
+
+Dialogue directed as separate layers (voices, scene sound, score) is **minimax-h3**'s seat; it also takes declared reference relationships, which suits a colour-coded cast. Native synced audio is **Veo**'s niche. seedance-2.5 carries the reference-video capacity. Route per `slates-model-selection` and read the chosen model's prompting skill before writing the audio block.
+
+## Checklist
+
+- [ ] Colour→character mapping written down and pasted into the prompt
+- [ ] Heads not animated in the blocking
+- [ ] Seating stated as a geography rule
+- [ ] Foreground owner named per cut
+- [ ] Mirror-is-not-a-swap clause present if any camera faces back through the scene
+- [ ] Presence rule present
+- [ ] Ongoing business, background life and scene event all specified
+- [ ] Acting task per character, safety line included
+- [ ] Any strong emotion split into phases with a hinge timestamp
+- [ ] Dialogue-never-creates-shots and off-screen-voices rules present
+
+## Related
+
+`slates-previs-blocking` · `slates-camera-language` · `slates-blocking-to-prompt` · `slates-character-identity` (the sheets) · `slates-prompting-minimax-h3`

package/skills/slates-previs-blocking.md

@@ -0,0 +1,153 @@
+---
+name: slates-previs-blocking
+description: Build a 3D blocking pass in Blender, render it grey-box, and use it as a reference video so the generated shot follows a camera path you designed instead of one the model invented. Use when the user wants precise camera control, a multi-cut sequence, a one-take move, spatial consistency across shots, or says the camera keeps drifting / they keep burning credits re-rolling.
+---
+
+# Previs blocking — design the shot, then generate it
+
+The spine of the whole workflow. Read this first; the other four previs skills are branches off it.
+
+## The mechanism (why this works at all)
+
+A text prompt asks the model to *invent* camera motion, so it invents differently every roll. You cannot iterate on a variable you do not control, so you re-roll and pay again.
+
+A **reference video** removes the invention. You build the shot in Blender as untextured proxies — a neutral grey set with colour-coded figures, free, instant, deterministic — render the camera's path to mp4, and hand the model that clip alongside the prompt. **Blender locks the motion; the model builds the world.** Iteration moves to the free half, and the paid half usually lands first try.
+
+Two halves, and keeping them separate is the whole discipline:
+
+| Half | Lives in | Changes when |
+|---|---|---|
+| **Structure** — cuts, camera, timing, who is where | the blocking clip | you re-block |
+| **Style** — what any of it looks like | references + prompt text | you restyle (see `slates-restyle-from-blocking`) |
+
+## Before you start
+
+1. `slates_blender_status` — confirms the bridge is up and returns fps, frame range, existing camera. If it reports `connected: false`, relay its hint and stop; nothing else here works.
+2. Settle **format first**, because the blocking render *is* the film's format: fps, aspect, duration. 24fps is the default and makes cut times land on clean frames. Duration ≤ 30s (seedance-2.5's reference-video ceiling; 15s on the others).
+3. Know the shot count. "One take" and "19 cuts" are different builds.
+
+## Build order
+
+Do these in order. Each stage is verifiable on its own, and a camera built before the geometry has nothing to frame.
+
+### 1. Set the format
+
+```python
+scene = bpy.context.scene
+scene.render.fps = 24
+scene.render.fps_base = 1.0
+scene.render.resolution_x, scene.render.resolution_y = 1920, 1080
+scene.frame_start, scene.frame_end = 1, 720   # 30s at 24fps
+result = {"seconds": 720 / 24}
+```
+
+Frame maths, stated once so you never redo it in your head: **frame = seconds × fps + 1**. A cut at 7.79s is frame 188.
+
+### 2. Geometry and light — grey set, coded figures, named
+
+Proxies only. A person is a box or a capsule with a sphere head. A car is a stretched cube. A can is a cylinder. **The SET is neutral grey — one light, a floor and enough wall that the space reads.** Colour is reserved for the figures, where it carries meaning (below); a grey set is what makes those few colours legible as notation rather than décor. Anything you spend on materials here you pay for twice, because the model repaints every surface anyway.
+
+**Name every object for what it *is* in the story**, not `Cube.003`. The name is how you refer to it later, and it is how you keep your own timeline honest.
+
+Two conventions that cost nothing now and save a re-roll later:
+
+- **Colour is identity.** Give each character a distinct viewport colour and *write the mapping down* — `red = the boss, green = the kid, blue = the driver`. The generation prompt will restate that mapping so the model knows which grey body is which person across cuts. Without it, characters swap.
+- **Encode facing on featureless proxies.** A box has no front. Mark one face red, the back black, the sides green, and say so in the prompt: `RED face = the direction he faces`. Otherwise the model guesses which way people are looking.
+- **Checker a surface when SCALE or SPEED has to read.** Flat grey gives a model no parallax cue, so a fast move over a featureless floor reads as slow, and a big room reads as a small one. A black-and-white checker on the ground (or the wall a camera races past) gives it something to measure against. ⚠️ **Build it as GEOMETRY, never as a Checker Texture node.** The blocking render is Workbench, which draws one flat colour per material and never evaluates a shader node tree — a `TEX_CHECKER` comes out flat grey and you lose the cue without being told. Subdivide the plane and alternate `material_index` per face. Like every other colour here it is notation, so it goes in the translation list and gets dressed over.
+
+```python
+# Two materials, alternated per face. `TILE` is the square size in metres.
+dark = bpy.data.materials.new("Checker_Dark")
+dark.diffuse_color = (0.05, 0.05, 0.05, 1.0)
+light = bpy.data.materials.new("Checker_Light")
+light.diffuse_color = (0.80, 0.80, 0.80, 1.0)
+floor.data.materials.append(dark)    # material_index 0
+floor.data.materials.append(light)   # material_index 1
+# Subdivide first (edit mode or a Subdivide modifier applied) so there ARE
+# faces to alternate — a 2-triangle plane can only ever be one colour.
+for face in floor.data.polygons:
+    cx, cy = face.center.x, face.center.y
+    face.material_index = (int(cx // TILE) + int(cy // TILE)) % 2
+```
+
+And the identity colour on each proxy:
+
+```python
+mat = bpy.data.materials.new("ID_Red")
+mat.diffuse_color = (0.8, 0.1, 0.1, 1.0)   # what the blocking render draws
+obj.data.materials.append(mat)
+obj.color = (0.8, 0.1, 0.1, 1.0)           # same value, for viewport parity
+```
+
+The blocking render pins Workbench to `MATERIAL` shading, so **`mat.diffuse_color` is the value that reaches the clip** — and an object with no material at all falls back to a neutral grey, which is why an unpainted set still reads correctly. Set `obj.color` to the same value anyway: it costs one line, it makes the user's viewport match what renders, and keeping the two equal means you never have to remember which one is authoritative.
+
+### 3. Camera
+
+The whole of `slates-camera-language`. Build the rig, then keyframe it. Then **read back what you built** with `slates_blender_scene` — its `cutSeconds` is your cut list, and it is the number you will write timings against. That field is the authoritative one on EITHER rig — marker frames when cameras are bound to markers, the active camera's own keyframes when they are not. `camera.keyframeSeconds` is empty on a marker-bound edit, which is the rig `slates-camera-language` recommends for anything past a handful of cuts.
+
+### 4. Handheld, last
+
+Add it after the moves are right, never before — noise on top of a wrong path just hides the wrong path.
+
+### 5. Verify the cuts
+
+The one check that catches the most damage: on a multi-cut blocking, camera position, target and focal length must all change **exactly on the cut frame, with no transition frame between**. One interpolated frame reads as a whip-pan the model will faithfully reproduce.
+
+```python
+# Every camera f-curve keyframe on a cut frame must be CONSTANT out of the
+# previous key, or the cut smears.
+for fc in cam.animation_data.action.fcurves:
+    for kp in fc.keyframe_points:
+        if int(kp.co[0]) in CUT_FRAMES:
+            kp.interpolation = 'CONSTANT'
+```
+
+Also check nothing interpenetrates — proxies through floors, clones through the hero object, letters through each other. The model renders intersections as faithfully as it renders everything else.
+
+### 6. Save a backup after every stage
+
+Cheap, and blocking is iterative by nature.
+
+```python
+bpy.ops.wm.save_as_mainfile(filepath=path, copy=True)
+```
+
+## Render and generate
+
+```
+slates_blender_render_blocking { projectId, fps: 24 }
+```
+
+Renders the **scene camera** through scene settings — never the user's viewport, so the result does not depend on where they left their mouse — imports the mp4 into the project, and returns `assetId` + `durationSeconds`.
+
+Then:
+
+```
+slates_generate_video {
+  model: "seedance-2.5",
+  videoReferenceAssetIds: [<the blocking asset>],
+  videoReferenceSecondsEach: [<durationSeconds>],
+  characterAssetIds: [...], environmentAssetIds: [...], styleAssetIds: [...],
+  prompt: <written per slates-blocking-to-prompt>
+}
+```
+
+**Four inputs, and that is the entire stack:** a character sheet each, one location/style reference, the blocking clip, and a prompt written against the blocking. Resist adding a fifth.
+
+Model note: seedance-2.5 is the seat for this — 10 reference videos at up to 30s each. seedance-2 and minimax-h3 take 3 at 15s. Route per `slates-model-selection`.
+
+## Leaving holes on purpose
+
+Where the model outperforms any blockout you could build — liquid, smoke, fire, cloth — **block a black gap instead** and say so in the prompt: `CUT 7 (14.5-17.0, black gap in the reference)`. You are reserving a slot, not forgetting one.
+
+## What not to do
+
+- **Don't texture, light or material the blocking.** Grey is the specification. The reference supplies motion; the references supply look.
+- **Don't animate what you don't need.** Heads especially — a proxy head turning wrong is worse than one that never turns.
+- **Don't build the camera before the geometry.** It has nothing to aim at, and every value you set gets redone.
+- **Don't skip reading the scene back.** Write timings from `slates_blender_scene`'s `cutSeconds`, never from what you intended to build.
+- **Don't exceed the model's reference-video ceiling.** A 40s blocking against a 30s cap silently truncates.
+
+## Related
+
+`slates-camera-language` (rigs and moves) · `slates-blocking-to-prompt` (writing the prompt against the clip) · `slates-dialogue-blocking` (multi-character continuity) · `slates-restyle-from-blocking` (one blocking, many worlds) · `slates-model-selection` (routing)

package/skills/slates-prompting-ltx-2-5.md

@@ -0,0 +1,180 @@
+---
+name: slates-prompting-ltx-2-5
+description: How to prompt LTX-2.5 and LTX-2.5 Pro. Read before calling slates_generate_video with model ltx-2-5 or ltx-2-5-pro. LTX scores the picture on the same pass that draws it, so SOUND IS THE FIRST THING YOU WRITE — Lightricks ranks the prompt sound, camera, character detail, shot type and scene, then scene dressing, all in one flowing paragraph. It is also the catalogue's native MULTISHOT seat: one generation carries two to four connected shots holding character, light and voice across the cuts. Base ltx-2-5 is the distilled build — 720p/1080p/1440p/4K, clips of 6 to 20 seconds in EVEN steps, and the cheapest native 1080p second in Slates; ltx-2-5-pro is the full diffusion build and is NOT a superset, reaching only 1080p and 10 seconds for about a third more money. Three hazards live here: durations are even numbers only from six (there is no 5s or 7s clip), the model has NO reference endpoint at all so identity references are unavailable, and any sound not anchored to something in frame gets invented for you.
+---
+
+# LTX-2.5 — prompting
+
+LTX-2.5 generates picture and sound **in a single pass**, with a Gemma-4 12B text encoder reading
+one flowing paragraph. That single fact drives everything below: the prompt is not a shot
+description with audio bolted on, it is **a scene where the sound is load-bearing** — and
+Lightricks' own priority order puts sound first, ahead of the camera.
+
+Two seats, and the naming is a trap:
+
+| | `ltx-2-5` (base) | `ltx-2-5-pro` |
+|---|---|---|
+| Build | Distilled, 8-step | Full diffusion ("Diffusion Fidelity Rendering") |
+| Resolutions | 720p / 1080p / **1440p** / 4K | 720p / 1080p |
+| Durations | 6–20s, even steps | 6 / 8 / 10s |
+| Price | $0.09–$0.30 per second | $0.12–$0.17 per second |
+| Reach for it when | iterating, long takes, 4K delivery, batch volume | one dense final render inside 1080p and 10s |
+
+**Pro is not "base plus more."** It buys picture quality on a *narrower* envelope — it cannot make
+a 1440p frame and it cannot make a 12-second clip. Reaching for it out of habit costs a third more
+*and* takes away the reach.
+
+---
+
+## 1. The six parts, in priority order, in one paragraph
+
+Lightricks ranks the elements of an LTX prompt like this. When a prompt sprawls, **cut from the
+bottom.**
+
+1. **Sound** — highest priority; the model scores the picture as it draws it.
+2. **Camera** — framing decides visual weight and the feel of the shot.
+3. **Character detail** — expressed as physical action.
+4. **Shot type and scene** — the action itself.
+5. **Scene dressing** — the first thing to trim.
+
+Write it as **one flowing paragraph**, not a list of labelled sections. LTX is not Seedance (eight
+engineering slots) and not H3 (three separate audio layers) — it wants continuous prose.
+
+---
+
+## 2. Sound: anchor it or it gets invented
+
+**Write the audio line last, then go back and check every cue has a source you could point at.**
+Anything unanchored, the model invents for you.
+
+The test is **"visible, or at least locatable."** A distant whistle is fine *if* you have named the
+marshal's post it comes from. A "distant whistle" with nothing to attach to is a coin flip.
+
+> the rope creaks against the cleat as she leans back, gulls calling somewhere off the port bow,
+> the hull knocking hollow against the fenders
+
+**Never write mood adjectives as sound.** "Tense atmosphere", "a sense of dread" and "ominous
+ambience" produce nothing usable. If a scene feels thin, the fix is **one more moving object in
+frame with a sound attached to it** — never another adjective.
+
+### Dialogue
+
+Quote it, and name the language and accent:
+
+> "We should not have come back," in English with a slight German accent.
+
+Two rules that decide whether the lip sync lands:
+
+- **Give the character a beat of stillness before they speak.** The sync needs something to lock
+  against; a character already mid-motion when the line starts drifts.
+- **Describe the beat structure** — when they look, how long they wait, when they speak, where they
+  look afterwards.
+
+Slates pins the frame rate at 25fps, which is also what Lightricks recommends for dialogue: at 50fps
+the performance "pulls toward a video look."
+
+---
+
+## 3. Character emotion is physical
+
+The model renders actions. It does not render adjectives.
+
+| Instead of | Write |
+|---|---|
+| she looks anxious | her jaw sets, she turns the ring on her finger twice |
+| he seems exhausted | he blinks slowly and lets his shoulder take the doorframe |
+| a tense standoff | neither moves; his thumb finds the strap and stays there |
+
+---
+
+## 4. Multishot — the thing this model is uniquely for
+
+**One LTX generation can carry several connected shots**, holding character, environment, lighting,
+voice and style across every cut. Nothing else in the catalogue does this natively; everywhere else
+you generate separate clips and stitch them, and identity drifts between them.
+
+**Working range is two to four shots.** Three is the comfortable stopping point.
+
+At **every** transition you must supply four things:
+
+1. **Name the edit in the prose** — "hard cut", "dissolve", "match cut".
+2. **Re-establish the shot completely** — scale, angle, lens and light all reset at a cut. A cut is
+   not a continuation.
+3. **Re-identify recurring characters by their original descriptor.** "The woman in the bronze
+   gown", never "she". Pronouns lose the character across a cut — this is the single most common
+   multishot failure.
+4. **State what the sound does at the cut.** Silence is not assumed; if the room tone should drop
+   out, say so.
+
+A shape that works:
+
+> Wide establishing shot of the workshop, dust in the window light, a lathe turning somewhere off
+> frame — hard cut — macro close-up of the brass fitting as it seats, the turning noise gone,
+> replaced by a single dry click — match cut — medium shot of the woman in the bronze gown stepping
+> back, the room tone returning underneath her.
+
+---
+
+## 5. Camera: write it, don't enumerate it
+
+fal exposes a `camera_motion` enum (dolly in/out/left/right, jib up/down, static, focus shift).
+**Slates does not surface it, deliberately** — and prose is the better instrument anyway:
+
+- **A written move can be tied to a specific moment.** "A slow push-in that settles as she reaches
+  the door, then holds" is not expressible as an enum value.
+- **For multishot it would be actively wrong** — one enum value would impose a single camera
+  behaviour on three shots that each want their own.
+
+So name the lens, the framing, the move, and **the moment the move resolves**.
+
+---
+
+## 6. The hard constraints
+
+### Durations are even numbers only, starting at six
+
+**6, 8, 10, 12, 14, 16, 18, 20.** There is no 5-second LTX clip and no odd duration of any length.
+Asking for 7s is not a rounding matter — that generation does not exist.
+
+**And the long end is 1080p-and-below only.** At 1440p and 4K the ceiling drops to **6, 8 or 10**.
+
+fal's own default is `auto`, which lets the model pick the length from the described action.
+**Slates always sends an explicit length instead**, so what you choose is what you are billed for.
+Choose the length the beat needs.
+
+### Aspect ratios: 16:9 and 9:16, and nothing else
+
+The narrowest set in the catalogue alongside Veo. Square, 4:5 and 21:9 are not available on this
+model at any resolution.
+
+### Frames, not references
+
+LTX takes a **start frame** and an **optional end frame** (which generates a transition between the
+two). It has **no reference-to-video endpoint at all** — no identity references, no style
+references, no environment references, no reference video, no reference audio.
+
+**For character consistency across separate shots, use MiniMax H3 or Kling.** Within a single LTX
+generation, use multishot instead — that is precisely the gap it fills.
+
+In image-to-video, **do not cut away from the opening frame too early.** You have paid for that
+frame; let it play before the first move.
+
+### Do not ask for text on screen
+
+Neither the spelling nor its stability from frame to frame can be relied on. Signage, labels,
+captions and lower-thirds belong in post.
+
+---
+
+## 7. Audio is free here, and that changes the routing
+
+Native synchronised audio is **included at every resolution on both seats**, with no surcharge and
+no toggle that costs money — unlike Kling, where sound is a paid dimension. A 6-second 1080p LTX
+clip **with sound** is 39 credits.
+
+Combined with 1080p at $0.13/s — the cheapest native 1080p second in Slates — this makes LTX **the
+coverage seat**: the one to reach for when the job is many takes rather than one hero shot, when a
+sequence needs its own sound, or when the credit budget is the binding constraint.
+
+Route away from it when you need identity references (H3, Kling), a ratio other than 16:9 or 9:16
+(Seedance, Kling), or authored multi-layer audio direction (H3).

package/skills/slates-prompting-nano-banana-2.md

@@ -78,6 +78,15 @@ Film still from [DIRECTOR] [GENRE]. Shot on [CAMERA] with [LENS]. [SUBJECT and a
 
 These are Stable-Diffusion-era tag soup. The model treats them as low-signal noise. Measured success rate: ~60-70% with these vs ~95%+ with positive description.
 
+<!-- @banned:start -->
+<!-- slates-only -->
+<!-- MACHINE-READ. Every `backticked` token between the @banned markers is extracted
+     by src/prompts/banned-tokens.ts, inlined verbatim into the slates_generate_image
+     op description (always in context on both surfaces), and matched against every
+     submitted prompt. Editing this list changes what the agent is told AND what it
+     is warned about — keep every entry backticked, and keep prose outside the
+     backticks. -->
+<!-- /slates-only -->
 **Never use:**
 - `8k`, `4k` (as a quality token)
 - `hyperrealistic`, `ultra-realistic`, `photorealistic` standing alone
@@ -86,6 +95,7 @@ These are Stable-Diffusion-era tag soup. The model treats them as low-signal noi
 - `perfect skin`, `flawless`, `airbrushed`, `smooth skin`
 - `cinematic` standing alone — always specify *which cinema* (director, lens, era, stock)
 - `not anime, not cartoon, not 3D` — negation tag soup, replace with a positive style cue
+<!-- @banned:end -->
 
 ## Negative prompting — there is no field
 

package/skills/slates-prompting-seedance.md

@@ -339,7 +339,16 @@ Speed ramps and slow-motion are supported in natural language, and `fast` is wid
 the lid opens in slow-motion · the blade whips through the air
 ```
 
-**Slop tokens to avoid:** `epic`, `amazing`, `beautiful`, `lots of movement`, `8K`, `masterpiece`, `trending on artstation`. These are quality *incantations* — the officially sanctioned way to ask for quality is the image-quality slot vocabulary in Part 1 (`HD`, `rich details`, `cinematic texture`, `natural colors`, `soft lighting`).
+<!-- @banned:start -->
+<!-- slates-only -->
+<!-- MACHINE-READ — same contract as the anti-list in slates-prompting-nano-banana-2.
+     Extracted by src/prompts/banned-tokens.ts into the slates_generate_video op
+     description and matched against submitted prompts. The RECOMMENDED vocabulary
+     below sits OUTSIDE the markers on purpose — it is backticked too. -->
+<!-- /slates-only -->
+**Slop tokens to avoid:** `epic`, `amazing`, `beautiful`, `lots of movement`, `8K`, `masterpiece`, `trending on artstation`.
+<!-- @banned:end -->
+These are quality *incantations* — the officially sanctioned way to ask for quality is the image-quality slot vocabulary in Part 1 (`HD`, `rich details`, `cinematic texture`, `natural colors`, `soft lighting`).
 
 ## Style block at the end
 

package/skills/slates-restyle-from-blocking.md

@@ -0,0 +1,121 @@
+---
+name: slates-restyle-from-blocking
+description: Render one blocking pass as several different visual worlds — live action, 2.5D painted, 2D ink, toybox — matching cut for cut. Use when a client needs style options, when someone wants to see the same edit in another look, or when an approved edit needs a new treatment without re-blocking.
+---
+
+# Restyle — one edit, many worlds
+
+The commercial payoff of the whole previs workflow, and the reason a blocking file is an asset rather than a step.
+
+## The idea
+
+Every prompt has two halves:
+
+- **Structure** — cuts, camera, timing, who is where. Lives in the blocking clip. **Never changes.**
+- **Style** — what any of it looks like. Lives in the references and the prompt text. **Changes freely.**
+
+Hold the structure, swap the style, and the same edit comes back as live action, painted 2.5D, ink on paper or a toybox — **matching frame for frame across all of them.** Cuts land on the same frames, the car drifts at the same moment, the same head turns at the same beat.
+
+For anyone pitching work: three visual worlds in a day, off one edit the client has already approved. The foundation is not up for renegotiation, so the conversation is only about look.
+
+## Before you restyle
+
+You need a blocking clip whose structure you are happy with, and a finished prompt for at least one style (per `slates-blocking-to-prompt`). The first style is the expensive one; every later style is an edit of its text.
+
+## What stays fixed
+
+Copy these across every style **verbatim**. Changing them is what desynchronises the outputs:
+
+- The blocking reference's own contract — that it is the master for all movement, the placement-only clause, the tie-break clause, the disambiguation clause
+- The shot count and every timestamp
+- Every shot's camera position, angle, framing and cut point
+- Screen direction and seating
+- The `HOLD FOR THE FULL TIMELINE` block
+- `videoReferenceAssetIds` and `videoReferenceSecondsEach`
+
+Lead each style's prompt with a lock so the style layer cannot leak into the structure:
+
+> VIDEO LOCK — the dominant rule of this prompt: the reference defines 100% of the motion, editing and object choreography. The text below defines only look, materials, locations and effects layered onto that motion. Wherever the text and the video could be read differently about motion, the video decides.
+
+## What changes
+
+| Layer | What you swap |
+|---|---|
+| Rendering style | photoreal · painted 2.5D · 2D ink · miniature/toybox |
+| Characters | different sheets entirely — a couple, grandparents, a robot and a cat |
+| Locations | the same four beats set in a different world |
+| Time of day / weather | night after rain · golden hour · hard noon |
+| Lighting and colour | per style |
+| Audio | SFX-only, or scored, or lip-synced dialogue |
+
+Characters can change species and still land, because the blocking only supplies where a body is and how it moves.
+
+## Dummy mapping — the mechanism that makes it work
+
+Each style needs its own explicit mapping from grey proxy to real object. The proxy is a slot; the style fills it:
+
+> DUMMY MAPPING: the front-LEFT sphere-head dummy (with its grey arm at the shifter and grey leg at the pedals) is THE GRANDPA; the front-RIGHT sphere-head dummy is THE GRANDMA; a front-seat dummy together with its loose blocks is that ONE whole person. Blocks on the rear bench are the luggage. The low-poly flying model in SHOT 18 is THE HELICOPTER. The two vehicles behind the hero car in SHOT 19 are THE POLICE CARS.
+
+Same clause per style, different right-hand side. And restate the placement-only rule in style terms:
+
+> The source defines only placement and motion, never appearance: every placeholder becomes the real object its position implies — spheres are always people, cabin blocks are always cases and bags, fully drawn.
+
+## Location continuity
+
+If the piece travels, name the places and pin each shot to one. Reusing labels across styles keeps the four prompts diffable:
+
+```
+LOCATION CONTINUITY — one journey through four fixed places; each looks
+identical in every shot where it appears:
+  LOC-A <opening>   LOC-B <middle>   LOC-C <turn>   LOC-D <finale>
+```
+
+Then tag every beat: `SHOT 9 — 7.79-9.33s — LOCKED, LOC-B: <description>`.
+
+**On a piece that visits many places, make the map absolute and countable** — otherwise the model reuses a room it liked and you get the same interior three times:
+
+> The location map is absolute — SEVEN locations, each appearing EXACTLY ONCE, in this exact order: 1) yard 00:00-00:03.3 … 7) rooftop 00:20-00:30. No location ever appears twice, and the three interiors are three COMPLETELY DIFFERENT rooms — different walls, furniture, people and light — never the same room repeated.
+
+## Style references
+
+A style reference is **not a keyframe**, and saying so prevents the model reproducing its composition as a shot:
+
+> STYLE MASTER — defines the painting and rendering style only: hand-painted look with visible brushstrokes, sculpted painterly volumes, textured matte surfaces, dramatic coloured rim light, deep moody shadows. NOT a keyframe, NOT a location to reproduce, NOT a frame that ever appears in the film. Its own subject, framing and composition are never seen in any shot.
+
+A style can also be **text-only** — no reference image at all. Ink and toybox looks usually specify better in words than they match from a still.
+
+## Keep performance inside the existing shots
+
+Style changes tempt the model to earn new coverage. Refuse it:
+
+> ACTING — inside the existing shots only: performance is visible only at the size and distance the reference already gives it, only where the source already shows a face; everywhere else it reads through posture and hands alone. The performance NEVER earns a new shot, a new angle or a closer framing.
+
+## Text-free worlds
+
+Stylised worlds are where invented signage and garbled lettering appear. One clause kills it:
+
+> TEXT-FREE WORLD: every sign is a blank painted shape, every gauge face carries tick marks only, every licence plate is a blank plate.
+
+## Running it
+
+Generate each style as its own `slates_generate_video` call against the **same** `videoReferenceAssetIds`. Keep them in one project so they sit side by side; name assets by style so the comparison reads at a glance.
+
+Quote the whole set before firing — `slates_estimate_generation_cost` per style — and confirm. Four styles is four generations, not one.
+
+🚨 Never fire a batch of style variants without showing the user the prompts and the total cost first.
+
+## Checklist per style
+
+- [ ] Same blocking asset, same `videoReferenceSecondsEach`
+- [ ] VIDEO LOCK leads the prompt
+- [ ] Every timestamp and shot count identical to style 1
+- [ ] Dummy mapping written for this style's cast
+- [ ] Style reference declared as style-only, or none used
+- [ ] Location labels reused; on a travelling piece the map is absolute and countable
+- [ ] Acting-inside-existing-shots clause present
+- [ ] HOLD block copied verbatim
+- [ ] Cost quoted and confirmed
+
+## Related
+
+`slates-previs-blocking` · `slates-blocking-to-prompt` · `slates-style-prompting` (style vocabulary per model) · `slates-cost-discipline` (batch quoting)