The Animated Series

Animated series built by agents usually fail in a way you only notice when the first cut plays. The pipeline works: scenes seek cleanly, audio lands on the frame, the render is exact. But the characters are rectangles with eyes, drawn by ten agents to ten ideas of the line, in a look kept in one episode's folder that drifts as soon as episode two starts.

This skill builds the series the way a studio does. The look is a kit every drawing inherits. Each character starts as a front: a T-pose SVG written from a brief the kit fills, shown to you before anyone cuts a puppet. The puppet is cut from that front, and puppet_doctor rejects primitive shapes. Every voice is a GroundSlate voice, every mouth is timed to the recording, every shot is an HTML page, and the film is those pages captured and assembled from one document. When the episode is done, a second agent can open the project and start the next one without asking you anything the notes already answer.

It asks you first: what the show is, who is in it, how it should look, and what you want to see before anything renders. If you already have vector drawings of a T-pose front, it starts from those. A generated bitmap sheet is only a reference, never something to trace.

Everything in <<double brackets>> is yours. Fill it in before you paste. The agent will ask questions before it builds. Answer the ones that matter and tell it to decide the rest.

Install it

Copy or download SKILL.md above.

For Claude Code, save it as ~/.claude/skills/groundslate-animated-series/SKILL.md.

For claude.ai and the Claude desktop app, put it in a folder named groundslate-animated-series, zip the folder, and upload it under Settings, Capabilities, Skills.

The skill

---
name: groundslate-animated-series
description: Set up a 2D animated series inside GroundSlate the way a studio would, and deliver its first episode. Style kit first, every character a T-pose front SVG written from that kit then cut into a rigged puppet on an avatar with a GroundSlate voice, sets and props as SVG kits, the episode written as data, every shot a seek-pure HTML page GroundSlate captures into the film, the film cut from one document, the human shown the work at every gate, and handoff notes a second agent can start the next episode from.
---

# The animated series

You are building a show, not a video. A show is a set of things that outlive any one episode: a look, a cast, a world, and the notes that let the next person pick it up. The episode is what those things do this week. Build the things first, in GroundSlate, where the next agent will find them, and build the episode out of them.

Everything happens inside GroundSlate. The drawings are SVG. The shots are HTML pages. GroundSlate captures those pages frame by frame and the film is the capture. The characters are avatars, the voices are GroundSlate voices, the cut is a document the renderer assembles. Nothing is generated as video, nothing is baked into a clip, and a rewrite is an edit to a page or a drawing, then a re-render.

## The shape

1. Ask. What the show is, what it should look like, who is in it, what the human wants to see before you render.
2. The bible. The world, the cast, the rules of the comedy, the sound, written into the project as notes.
3. The kit. How the whole show is drawn, as a style kit, shown and approved before a single character exists.
4. The fronts. One T-pose front SVG per character, written from a brief whose visual idiom is copied from the kit and whose character section is that person part by part, shown to the human as face, figure and flat-black silhouette. No puppet until that front is approved.
5. The cast. One SVG puppet per character, cut from the approved front, doctor clean, shown as one HTML sheet of face and body, then bound to an avatar with a voice.
6. Sets and props. One SVG kit each, in collections of the right kind.
7. The episode. A beat sheet, a script, lines as data, voices recorded, mouths timed, every shot an HTML page, the cut as a document, the pages captured into the film, the look and the listen.
8. Handoff. Notes a fresh agent starts from, and a second agent that proves it.

Do them in that order. A character drawn before the kit exists will be redrawn. A puppet cut before the front is approved will be redrawn. A scene animated before the lines are recorded will be retimed.

## The map

This skill is the whole show in one place, and it is also the map to the skills that do one job slowly. Read it first even when you will hand the work off. Hand off when the human says the show is the point, when a cast is larger than four, or when a step has failed once; do the step here when the show is small and the human wants an episode this week.

- The objects and where they live: [Puppets and style kits](/resources/groundslate/guides/puppets-and-style-kits). Read it before touching a kit.
- The whole pipeline in order, with what you approve at each step: [The animated series in five steps](/resources/groundslate/guides/the-animated-series-in-five-steps).
- Step two, the drawing: [The front that can be rigged](/resources/groundslate/skills/the-front-that-can-be-rigged), one character per run. Step two, the puppet: [The cast that reads at a glance](/resources/groundslate/skills/the-cast-that-reads-at-a-glance), one character per run, then a line-up run.
- Step three: [The sets the camera moves through](/resources/groundslate/skills/the-sets-the-camera-moves-through), one set per run.
- One character end to end, when there is no show yet: [A cartoon character you can actually animate](/resources/groundslate/recipes/a-cartoon-character-you-can-animate).
- Two characters in a scene, when the cast exists and the question is whether they can act: [Two characters, one conversation](/resources/groundslate/recipes/two-characters-one-conversation).
- The walkthrough with pictures of every gate and the ask for each: [How to create an animated character in GroundSlate](/resources/blog/2026/09/02/how-to-create-an-animated-character-in-groundslate).

When you hand off, write the handoff into the project first: which skill, which character or set, and the path of everything it needs (the kit, the cast notes, the fronts folder, the reference frames). The next run reads the project, not this conversation.

## Before you start

Call `get_context` and confirm the profile. Pass `profile=` on every call from then on; the human can switch profiles at any time and an omitted profile means whichever is active. Every writing tool refuses without it.

Confirm the tools this skill depends on are present by asking for the two built-in kits: `get_kit("draw kit")` and `get_kit("puppet engine")`. If either is missing, the app is too old for this skill; say so and stop.

One project per episode. `create_project` names it after the show and the episode. The show's own material (bible, kit, cast, sets, props) lives in kit collections and avatars, which belong to the profile, not the project, so episode two reads the same cast. The project holds what is this episode's: notes, fronts, script, lines, scenes, the cut, the film.

Read `get_project` for the working folder and its three areas. Notes a later session must read go in `notes/`. Intermediates worth keeping go in `work/`. Finals arrive from a render and are kept with `commit_to_library`. Write text with `write_project_file`; media goes to the library.

## Ask, then work

Before you build anything, ask. Put the questions in one message and say which ones you will decide yourself if the human does not answer.

- What is the show? One paragraph: who, where, what kind of funny, what the show is about underneath the jokes.
- What should it look like? Ask for two or three reference frames of the show or style it should sit next to, and say what you will read off each one: the outline weight against the head size, whether the line is even or thick and thin, how the eyes are built and how much the lids do, the palette's saturation and how many colours a character wears, and whether there is any shading. Write the kit's Visual Idiom from that reading and show the swatches beside the reference frame so the human can see the match. A reference is a look-at for the idiom, never a drawing to trace. Any rules they already know (line weight, palette, how round or angular the people are, how much shading) go into the kit as numbers.
- Do they already have vector drawings of the cast? If a drawing is already a T-pose front with named groups, it is the front, whoever drew it, a person or another model handed the brief: still write the brief so the next character has a comparable spec, and check the drawing against the brief's checklists with evidence. A photo, a frame of a show, a sketch or a generated turn sheet is a look-at. You never trace it, convert a bitmap into a puppet, or lift paths from it. Write a front brief from the kit, then draw one T-pose front SVG per character.
- Who is in it? Names, ages, what each one wants, how each one talks. If they have only a premise, offer to write the cast and show it.
- How long is the episode, what aspect, what frame rate. Default 16:9, 24 fps.
- Voices. Every character speaks in a GroundSlate voice, designed from a description or cast from the stock and library voices already on the Mac. Ask whether they have voices in mind or want to hear options.
- What do they want to see before you render? Offer the gates below and let them choose. Some people want every character; some want the kit and the first scene and the film.

Write the answers into `notes/BRIEF.md` before you do anything else. The next agent reads that file first.

## The gates, and how a review works

A review is a file put in front of the human in GroundSlate with a timeline they can comment on, regions they can draw, and Approve or Request changes at the foot. `request_review(source, ask)` opens it and returns a review id at once; it never blocks you. `review_status` reads what they said: every comment carries its time, its region described in words, and its text. `review_reply` answers one comment beside the mark they drew. When you have acted on a note, say what changed in the reply.

Offer these gates and ask which they want:

- The kit's swatches and mouth chart, before any character is drawn.
- Each character's front: the brief, then the T-pose SVG on a sheet that shows the face at three times size, the whole figure, and the flat-black silhouette. No puppet until this one is approved.
- Each character's puppet, as one review: the turnaround, the expressions and the mouth chart together, cut from the approved front.
- The script, as a note in the project.
- The first animated scene, rendered, so the timing and the acting are judged before thirty more are built.
- The cut.

Whatever they choose, the cut is always a gate. Never report the episode delivered before the human has seen the film.

Read their notes literally and fix all of them in one pass. A note that says the hairline goes up and back means the drawing changes, not the prose. If a note contradicts the kit, say so and ask which wins, then update the kit so the next character inherits the answer.

## The bible

Write it before the kit, because the kit is drawn from it. Five files in `notes/`:

- `SHOW_BIBLE.md`: the premise, the tone, the rules of the comedy, the look in words: line, palette, proportions, shading, what the frame never contains.
- `WORLD.md`: the place, its locations, what each one is for.
- `CAST.md`: every character. Silhouette in one sentence, what they want, how they talk, their signature detail, what makes them funny, which shapes they are made of. The front brief in `notes/fronts/` is the drawing spec; this file is the index.
- `PROPS.md`: everything anyone holds or interacts with, and who owns it.
- `SOUND.md`: the voice of each character in one line, the ambience of each location, where music belongs and where it does not.

Keep them short and specific. A bible that says "warm and quirky" teaches nothing; one that says "every head is a bean, wider at the jaw, and nobody has a neck longer than one eye" teaches a second agent to draw.

## The look lives in the kit

A style kit is one kit in a collection of kind `style_kit`, one per show, never one per episode. It owns the palette with a role for every colour, the line rule, the shading, the proportions in heads, the shared mouth, eye and brow vocabularies, and the fallback table that lets a puppet with two mouth shapes and one with the whole chart consume the same timing.

Before you scaffold, put the reference frames the human gave you in front of you and read the idiom off them: outline weight as a share of head height, even or tapered line, eye construction, palette saturation and count, shading or none. Then `style_kit_scaffold`: a name, a collection, a palette with roles, and the show. It writes a kit that already passes its doctor. Then edit `kit.json` to what you read, save it back, and render the swatches beside the reference frame so the match is a picture the human can judge. The rules that decide whether the show looks drawn or looks generated:

- One line rule for everything. Two weights, outer and interior, a taper profile, and a `stroke_policy` that matches how the fronts will be drawn: `filled-outline` when every contour is a closed filled path from the draw kit's taper helper, `stroke` when the fronts carry stroked outlines at the kit's weight, which is what a model returning SVG produces and what hand-drawn vectors carry. The puppet doctor refuses a stroke attribute under `filled-outline`, so decide this in the kit, not by converting drawings. If the reference show has a uniform thin line, set the taper profile to `even` and the weights close together. If it has thick and thin, set the hand profile.
- Shading is a decision, not a default. Many shows have none. A cel shadow that the reference show does not have is the fastest way to look wrong.
- A palette that is smaller than you think, muted where the show is muted, with a role written against every entry.
- Proportions as a range in heads, and a sentence for the head shape, because the head is where a viewer decides if a character is well drawn.
- Eyes as a rule: how big, how close, whether a lid line does the work.

Run `style_kit_doctor` until it is clean. Render `style_kit_sheet` for `swatches` and for `mouths`, look at both, and put them in front of the human if they chose that gate. Every front brief copies this kit's idiom. A change to the kit after the fronts exist is a redraw of the fronts and the cast, so get it right here.

## The front before the puppet

A name and a sentence produces a schematic figure. The drawing you approve is one T-pose front SVG per character, written from a brief the kit fills. Do this one character at a time, and give each front a full pass of attention: a batch of briefs written first and then drawn comes back as one figure with different captions. The second brief is written against the first front. When the show is the point, hand the fronts to the front skill one character per run instead of doing them here.

Write `notes/fronts/<slug>.md` before any SVG, and show it. Six sections, every time:

1. **Visual Idiom.** Copied from `kit.json` and the look paragraph of `SHOW_BIBLE.md`, never invented: the bible's look sentence, 2D only, the kit's line rule in the kit's numbers (`stroke_policy`, outline and interior weights, taper, ink hex), the kit's shading decision, the kit's proportions and shape rules. If the policy is filled outline, every contour is a closed filled path from the draw kit's taper helper. Do not write "4 px black" unless that is what the kit says.
2. **SVG File Delivery.** Named groups for every movable part, pivot-friendly overlaps, independent facial features, hidden portions drawn completely, T-pose, stacking inspected.
3. **CHARACTER.** This person part by part: three colours that do the talking, head shape and ratio, face with eye size as a share of head width and where the eye line sits, hair as masses, neck, torso with its ratios as numbers, shoulders, arms, hands as a palm plus four fingers and a thumb, legs, feet, the flat-black silhouette, personality, the one contradiction that makes them funny, and where the design leans so it is not mirrored.
4. **Final Rigging and Quality Check.** T-pose, named left and right groups, facial hair that talks movable on its own, hidden overlap at joints, no doubled outlines.
5. **Line Consistency Check.** Rewritten to the kit's line rule, then answered against every visible element.
6. **Layer and Position Check.** Position, scale, stacking, joints, clothing boundaries. Do not deliver until every group has been checked.

Then one SVG: `work/fronts/<slug>/front.svg`, front view, T-pose, full body, groups named with the engine's joint names so a puppet can be cut from them, drawn with the draw kit's helpers or as SVG paths written directly; the checklists are the contract, not the helpers. If the human hands you a front another model drew from this brief, check it against the checklists with evidence and redraw only what fails. A generated turn sheet, if you made one to look at, is never the parts. Build a sheet that shows the face at three times size, the whole figure, and the flat-black silhouette at 64 pixels. If you cannot name them from the black shape, redesign, do not shade. Show the front. Do not cut a puppet, and do not start the next character, until this front is one you would put on television.

Do not skip the brief. A puppet cut from a name is garbage with pivots.

## Every character is a puppet on an avatar

A puppet is one kit in a collection of kind `puppets`: `puppet.json` as the contract, parts per authored view, a face chart, costumes, slots a prop attaches to, and a sheet harness. `puppet_doctor` enforces the contract: every joint has a pivot in every authored view, every part names a joint and a file, a costume that dresses a joint in one view dresses it in all, the mouth chart lists what the puppet draws and every viseme it does not draw reaches one it does through the kit's fallback table, no stroke attributes, no `non-scaling-stroke`, and the silhouette rule that refuses rectangles, ellipses and straight-segment paths used as anatomy. The contract is what the doctor enforces, and every finding names its rule and carries a fix; the engine's own contract, the joints, views, slots and the house contract line a page must carry, is in `get_kit("puppet engine")`.

The doctor is the floor, not the bar. A puppet that passes can still be ugly. The bar is the human's eye on the front you already approved. Cut the puppet from that front. Do not invent a second drawing.

1. Read the approved front in `work/fronts/<slug>/` and its brief. If there is no front, write and draw it first. Do not start a puppet from a name.
2. Cut the front's named groups onto the skeleton as the front view. Draw hidden overlap at the joints from the geometry already in the front. The face at three times size on the front sheet is the face; do not redraw it smaller.
3. Authored views: front from the approved SVG; three-quarter is enough for a first episode; profile and back when a scene needs them. Mirrored views are the engine's. A new view is projected from the same 3D head, not a new character.
4. The mouth chart. Use the kit's shared family when it fits the face; draw the puppet's own when it does not, and say which in the manifest. A mustache, a beard, a beak, a hog: each is a coupling the manifest names, and open shapes open beneath it.
5. Hands. Draw the states the show uses on the hand joints, small and simple, per authored view, the left mirroring the right; the kit's vocabulary is rest, open, point, fist, hold, wave, thumb up and flat, and anything not drawn falls back to a shape that is. The front's rest hand (palm, four fingers, thumb) is the rest state. A gesture is a swap on the beat plus an arm move, which is how cut-out shows do it.
6. A costume as its own part set with the base parts it hides.
7. `puppet_doctor` clean, `puppet_build` for the character file, `puppet_sheet` for the turnaround, the expressions, the mouths, the hands and each costume. Look at every sheet before you show it.
8. One review per character with all the sheets, if the human chose that gate. Fix every note in one pass and re-render the sheets.

Then declare what the puppet carries. Four blocks in the manifest hold behaviour a shot used to have to remember, and a shot that forgot them rendered a statue with nothing saying so. `idle` is the breath, the blink, the hips' sway, the jaw a spoken line drives, and per-joint `wiggle` and `dangle` for hair, a tail, an earring, anything that hangs. `acting` is how far a speech-aware line may nod and tilt this head and which brows mean up, down and rest. `turn` is the ordered ring of views a gaze turns through, so a look moves the head and not just the pupils. `pin` is which joints are feet, where this character's ground is, and how high a foot still counts as planted. Declare them once and every scene inherits them; a scene call still wins for its own span. The doctor checks all four, including the ranges that separate animation from a typo.

Then bind it. `create_avatar` with the character's identity description, bio and voice direction from the bible; `set_avatar_puppet` to point the avatar at the kit; `add_media_to_project` to cast the avatar in the episode. From then on `get_avatar` returns the puppet resolved, with its sheets and its doctor verdict, beside the voice. The scene and the lipsync tool get a character's body and voice from one id.

Some things the engine will teach you the hard way if you let it:

- A mirrored view mirrors the joints. An arm angle that raises the hand in front raises it the other way in the mirrored three-quarter. Measure before you animate.
- A puppet's hair sits above its stated height. Frame shots from a fixed top edge, not from the manifest number.
- A raised arm leaves a close frame. Widen the shot for the gesture, or cut to a wider one on the beat.

## Sets and props

A set is one kit in a collection of kind `sets`: layered planes with depth for parallax, named marks where a character stands, interaction points. A prop is one kit in a collection of kind `props`: an SVG with a grip point, the slots it fits, its states. Draw both to the kit's line and palette; the doctor's silhouette rule does not apply to a building, but the eye's does. Preview each with `preview_html` and look.

A set gets the brief a character gets, or it comes back as boxes: `notes/sets/<set>.md` with the visual idiom from the kit, the delivery contract, the place part by part (one paragraph per object the camera will see, and what makes it this one), and the checks, written before the first plane is drawn. Then draw it organic and drawn, not assembled from shapes: every edge a curve with a little sag, siding as five wavy lines, bushes as clipped mounds and mop-head clusters, a vehicle with a nose, a windscreen and wheels, a shadow half on every mass. A `<rect>`, `<circle>` or `<ellipse>` is only ever an invisible base under a drawn shape. And every set goes to the human for a review before any shot is rendered against it; a set nobody approved is rejected under the first cut, with the cast already animated on it.

Every object in a set is drawn from the camera's view of it, at the depth it sits: a van nose out shows two tread faces and a contact shadow, not hubcaps; a chimney is drawn before the roof; a far house's walls before its eave; a bush in a bed on the bed's ground line. The set check has the cast standing on the marks from its first round, the creator approves the set before any shot is rendered against it, and when the scale is wrong the set is scaled about its ground line with its strokes thinned, never the cast. The full rule set is [The sets the camera moves through](/resources/groundslate/skills/the-sets-the-camera-moves-through).

## Voices are GroundSlate's

Every character gets a GroundSlate voice. `list_voices` shows what the Mac already holds; `preview_voice` plays a line in it; `create_voice` designs a new one from a description in the bible's words. Put the chosen voice on the avatar with `set_avatar_voice`, so the voice and the body travel together and episode two casts the same actor.

Record every line with `synthesize_speech`. It returns word timings with the take. Time the mouths from the take, never by hand: `lipsync(path, fps, mouths, transcript)` returns mouth keyframes in the kit's vocabulary, collapsed to the visemes the puppet actually draws (pass its visemes, not its emote shapes; a smile between sentences is an acting beat the scene sets itself), with holds on twos, a lead of one frame, closures on plosives and rest on silence. Keep the result beside the scene as data.

If a take runs longer than the shot it belongs to, re-record it faster or ask the writer to cut; never hand-stretch the timing to fit.

## The script is data

Write the episode as a beat sheet in `notes/EPISODE_1.md`: shots, each with a duration in frames, a set, the characters on it, the props in play, the camera, and the line ids spoken in it. The durations sum to the episode length exactly. Then `notes/SCRIPT.md` for the words and staging, and `notes/LINES.json` with one row per line: id, shot, start time, character, emote, text. Everything downstream reads `LINES.json`; a line's timing lives there and nowhere else, so a retime is one edit.

## Scenes seek, they never play

Every shot is one HTML page in `work/scenes/<shot>/`, reaching the puppet engine kit files and the SVG rigs it uses at `_kit/<collection>/<kit>/` rather than carrying a copy of either, speaking the house contract the engine exposes: a seek function, a duration, and a ready flag. GroundSlate captures frames by seeking those pages in whatever order it likes, so a frame must be a pure function of time. Anything whose drawn state depends on the previous seek is a bug that only shows in the film: relative tweens, memoised DOM writes, `non-scaling-stroke`, a large visual change riding a sub-frame value. `preview_html` reports `seek_not_pure`; treat any finding as red, and preview at shuffled timestamps, never only in order.

Beside each page, `scene.json`: the shot, its seconds, the set, the cast with costume and mark, the lines with their start times from `LINES.json`, the sound cues and their levels, the ambience. The cut builder reads this file; the page reads it too, so the two never disagree.

Acting rules the show keeps:

- Mouths come from the lipsync data. Mouth shapes swap; they do not morph.
- Head turns are view swaps, never rotations, never mid-word. A puppet with a `turn` ring does its own: a look past the threshold steps the drawn view toward what it is looking at, the view leading the pupils by the block's own frames, so the anticipation is declared once instead of keyed per glance.
- Nothing sits still for five seconds. The blink, the breath and the sway come off the puppet's own `idle` block rather than being keyed per shot; the nod, the tilt and the brows come off the take, by handing `lipsync`'s performance block to the line, so they land on the words the voice actually leaned on. What the shot still owes is a gesture on the beat that earns one, and a camera that pushes inside every shot and cuts at the boundaries.
- Eyes stay the size the kit says. Expressions are brows and mouth.
- Nothing appears on screen that the script did not put there. No labels, no shot names, no counters.

The camera rules the show keeps:

- Open wider than you think, then cut to faces. A short that opens on a medium and stays there is one shot. Open on a wide with the cast small in it, cut to the two shot on the first beat, and cut to a face the moment a line turns.
- Cut, and vary inside the shot. In a page a cut is a camera move with no duration and a snap is a move of a fifth of a second on an exponential ease, which reads as a whip; between pages the cut document joins on hard cuts. Ten setups in 24 seconds is a rhythm; four is a slideshow. Offer the transition catalog only when a cut is a change of place or time.
- When a line is about an action, the action is in the frame. Pose the action before the line starts and keep it going while the line plays; a blade that is supposed to be cutting is up and spinning, not resting under a wheel.
- Tight means tight. A close up on a face fills the frame with the face and leaves the prop at the corner.
- Debris is a plane. Leaves off a blade, sparks off a grinder, crumbs off a sandwich: keyed shapes on their own plane over the actors, each with an explicit from on every ramp, bursting in waves for as long as the action runs. The engine's channels and a flush hook are all it takes; do not fake it with a GIF.

## Sound

Ambience per location and effects per action come from the library or from the app: `search_catalog` for what is already indexed, `import_asset` and `index_audio` for what you bring in, `generate_sound_effect` for a cue no pack has, written from a source, a material, a motion and a perspective. Every file is in GroundSlate before the cut references it. Score the show with `generate_music`, one brief per movement rather than one bed over everything, or with music the library already holds. A show with no score is better than one with the wrong score, so brief it and listen before you place it. Write every cue into the shot's `scene.json` with its level.

Effects sit under the voices, from readings. An engine under a line sits a few decibels under the bed on its own track, ducked three to one under the dialogue, and drops further under a quieter line. A sting sits below the dialogue, not above it, and lands under the tail of a line rather than after it. A yell is a line: record it in the character's voice at temperature 0.9, three takes, and pick.

## Titles and fonts

A title is a designed card, not a line of type: a drawn banner, the show name small, the title stacked large in a display face with an ink stroke and a hard shadow in two of the cast's colours, letters that pop in on a bounce, an exit before the next cut. Put it on a screen-locked plane under the actors, so a head that crosses it passes in front. Register each display face in the profile's font library with `register_font` from a file the project holds (a face from the Mac's own collections, never one fetched from the internet), then `check_fonts` on the page before a render, so the render embeds the face you chose and not a fallback.

## Two frames are two films

A 16:9 version of a 9:16 short, or the reverse, is not a zoom. Scaling every zoom by the ratio of the frame heights shows the same world height with the sides let in and looks like a phone video on a television. Compose every setup again for the new frame: the wide with the house across it, a two shot that uses the width with both figures whole, faces that fill the height, the card where no head crosses it. Same pages with their camera blocks rewritten, rendered at the new size, cut from the same document with the size changed.

## The cut is a document

Build the cut from the scenes: one base track of composition sources, one clip per shot, in order, frames that sum to the episode; audio tracks for voice, effects, ambience and music, each cue placed by its start frame, the music ducked under the voice, a limiter on the bus, a fade to black at the end. Cue positions are film-absolute frames. Save the document in `work/pipeline/`, so the next agent can rebuild the film from it.

`cut_doctor` first. Zero errors before a render; read the warnings, most same-track overlaps on voice are the tails of takes and are fine. Then `render_cut` to Scratch Outputs and `job_wait`. Captures are cached by the scene's content, so a change to one shot or to the mix re-renders only what changed.

Then look, and listen, across the whole film. `sample_frames` with a contact sheet across the runtime, and again at the timestamps the notes will ask about. `audio_energy` across the whole runtime, not the first ten seconds; a mix that is right at the head and silent from the second shot on has happened, and the receipt said ok. If the picture and the sound both hold, `commit_to_library` with the project and a title. Then the review.

## Show them, every round

Every gate the human chose, and the cut always. Open the review, keep working on what does not depend on the answer, read the notes when they arrive, fix all of them, reply beside each mark, render again, open the review again. A round is not done until the human has seen the result of their notes.

## The project is the source of truth, and the test is a second agent

Before you report the episode delivered, write `notes/PIPELINE.md`: where every layer lives (the kit, the front briefs, the fronts, the cast, the sets, the props, the avatars, the voices), how an episode is made step by step with the tool for each step, the rules that are not negotiable, the gotchas you hit, and the exact order a cold agent follows. Add `add_project_note` pointing at it.

Then prove it. Start a fresh agent with nothing but the project id and the instruction to build one scene of episode two from the notes. If it has to ask you anything the notes should have answered, the notes are wrong; fix them and run it again. The show is set up when that agent succeeds.

## Deliver

Report the film's committed path, the review it is waiting in, what the human approved along the way, every character with its kit and avatar ids, the kit's id, where the notes are, and the list of what did not resolve: a line that overran, a set that needed a mark the bible did not name, a character whose sheet still has a finding. Say what you would do next, and stop.