Showrunner tools

show_summary read

Show summary

Summarize the open show: its theme and active style, the cast (id, name, role, lock state), sets, props and patterns, the proposals waiting for the person's decision, and anything that has drifted (instances whose pattern changed, proposals gone stale). Call it at the start of a conversation and whenever you need to know what exists before proposing something; the ids it returns are what the other tools take. On a folder with no show yet it says so, and create_show is the next step. It never changes anything.

No input.

get_document read

Get document

Read one document by id (char.otto, set.marigold_bridge, style.saturday_morning, theme.marigold, pattern.character.marigold_crew, bible.marigold) and get its full JSON, its path and its lock state. Read a document before revising it, so your pointer edits address fields that exist and leave locked pointers alone. It never changes anything.

list_documents read

List documents

List the show's documents, optionally of one kind, each with id, kind, name, path, status and lock state. Use it to find the id of something the person names. It never changes anything.

search_canon read

Search canon

Search what the show has established (the bible, character personas, the theme, episode screenplays) for words, and get the best-matching passages with their document id and where in it they are. Use it before inventing lore, to keep new material consistent with canon, and to find who or what the person means. It matches words, not meanings: use the distinctive words. It never changes anything.

impact read

Impact

List what re-derives, re-renders or re-checks if one document changes: the instances drawn from a pattern, everything drawn in the active style, the episodes that use a character or set, and documents that name it. Use it before proposing a change that many documents depend on, and tell the person what it would touch. It never changes anything.

render_preview read

Render preview

Render preview images through the engine: a character's model sheet or line-up (model_sheet, lineup), a character pattern's line-up of sample characters, one per archetype (lineup; check a pattern with it before generating from it), a set's camera views (set_view), a style swatch (style_swatch), stills of an episode at given frames (still), or an episode's storyboard (storyboard: the middle of every shot, one row per scene, captioned with shot ids and sizes, on one sheet; it times unvoiced lines from estimates, so a directed episode can be checked before it is voiced), a prop drawn from its recipe (prop: held by the show's first character, then set down on a table, each from the front and the side, on one sheet), a restyle proposal's before and after (restyle, target the change id: every character's model sheet in the current style beside the new one, captioned with what the restyle does to it), a sound pictured (sound, target sfx.* or a create_sound change: its waveform over its spectrogram, in Hz against seconds, to check pitch, envelope and noise without hearing it), or an effect played (fx, target fx.* or a create_fx change: from the top of a 1.2 m post on a plain dark stage, the camera as far back as it reaches, in six frames across its length, to check it reads before an episode uses it). target is a document id, or a change id to see a proposal before the person approves it. Returns image files. The first render of something takes seconds to a minute; asking again is cached. It never changes the show.

No input.

drift_report read

Drift report

Draw every character that has an approved model sheet again and compare it with that sheet, pixel by pixel: which moved since the person approved them, by how much, and the likely cause (the show's style changed since, the character changed since, or neither, so the renderer did). Locked characters that moved are canon drift to raise with the person. Each mover gets an approved | now | difference sheet. Use it after a restyle or an engine update, or when asked what changed. It never changes the show (its sheets go in .reelwright/drift/).

No input.

list_kits read

List kits

Browse the set pieces a show can build from: its own kits (pieces made in the piece maker, models and pictures brought in) and Reelwright's library of kits, each a shelf of parametric pieces that take the show's style (interiors of several eras, a 1940s jazz club, a diner, an office, a castle; the street, a park, a forest; a reef and kelp forest; spaceship corridors and stations; industrial yards; stage dressing and light fittings). Each piece is named kit.<kit>.<piece>, with its role, size, dressing rule (floor, wall, ceiling, surface) and params. It also lists the set patterns that build whole places (build_set chooses one by a place's words), the lighting looks add_lighting makes presets from, and the pictures a preset's gobo can cut into the light (cookie image with one's image: stained glass, a leafy canopy, a window's mullions, a cell's bars; and the show's own pictures), a library one carried into the show when a set names it. kit names one kit, to read its pieces' recipes in full (as a starting point for save_piece); category and words narrow the list. It never changes the show.

episode_needs read

Episode needs

What an episode needs from the show (the missing-asset pass), from its outline and, once there is one, its screenplay: every character, set and prop, each either one the show has (with its id), or one a pattern can make (the generate_characters, build_set or generate_props proposal that would make it, named and seeded from the outline; a prop is drawn as what it is, a plain box where nothing draws it), or one left for you (a set type no pattern builds, a speaker or location the screenplay names that the outline does not). Call fill_needs to propose everything a pattern can make. This never changes anything.

show_memory read

Show memory

What the show remembers of everything written so far, for writing the next scene, outline or episode: its tone and humor rules and never list, every pinned entry, the characters in play (how they talk, their catchphrases, relationships, what they know), the running gags and callbacks (relevant first; a resting one says so: leave it alone), the story so far (latest episodes in detail, earlier seasons summed up), open threads and world facts, within a token budget. Give the scene's characters, or the scene itself, for what matters to it. Keep to it as you write. Entry ids in brackets are for edit_memory. This never changes anything.

find_uses read

Find uses

What uses a document or a sound: every other document that names it by id (an episode's cast and cues, a set's props, the bible's links, memory), with the JSON Pointers where, and for a character or a set every screenplay line that calls it by its cue or scene heading. Read it before removing or renaming something, and tell the person what would be affected. Never changes anything.

list_versions read

List versions

Lists the show's saved versions, newest first: the ones people named ("Locked for table read") and the restore points Reelwright took before risky changes (a restyle, a removal, a bulk edit, an import), with who saved each and when. Use before compare_versions or restore_version, to name a version by its id. It never changes the show.

No input.

compare_versions read

Compare versions

What changed between two versions of the show, or a version and now (from or to "now"): each document or script added, removed or changed, with how many fields; with document (an id), that document field by field. It never changes the show.

screenplay_needs read

What a screenplay needs

Before directing a screenplay, list what it needs from the show: every speaker and every location, each resolved to the show's character or set the way direct_episode will, and what is missing, with did-you-mean candidates. Create what is missing (generate_characters with roles, build_set) or map a name (the episode's castMap or sceneSets, or a set alias) first. `screenplay` is the .fountain path in the show; give `fountain` (the text) for one the show does not have yet. It changes nothing.

try_action read

Try action on the director

Stage a few paragraphs of screenplay on one of the show's sets with the heuristic director, and see what it made of each: who goes where, sits or lies down, what they do with their hands and the props, which sounds and effects play and from where, and what it could not stage. Use it while writing to find wording the director reads ("They grip hands", "The galley clock TICKS") before write_screenplay; a paragraph with nothing staged under it is one the director did not act on. A shot written as a paragraph of its own in capitals is a camera direction the coverage honours: "CLOSE ON THE KETTLE", "INSERT - THE NOTE", "EXTREME CLOSE-UP ON HER EYES", "ANGLE ON OTTO", "ON THE CHIEF", "WIDE SHOT", "TWO SHOT OF OTTO AND THE CHIEF", "OTTO'S POV", "BACK TO SCENE"; the result says what each became. `text` is the scene in Fountain without its heading; characters and props are the show's. It changes nothing and costs nothing.

episode_timing read

Episode timing

When each shot and cue of an episode plays, in seconds from the episode's start, as it compiles now (lines not yet voiced are timed from estimates), or a proposal's version of it with change; one scene with scene. Each cue says what it does ("char.otto pick_up prop.pillow at element:bunk_top"). Use it before edit_episode to find the cue to change, time a cue after the right one or move a cut to a moment, rather than reading Timeline or episode files.

estimate_cost read chat only

Estimate cost

Estimate what planned showrunner work will cost before doing it, and how much of the show's budget is left. Use it before expensive work: many options, several whole documents, or long batches. `calls` is how many model calls the work needs; `outputTokens` is the expected output per call. Returns a low (warm cache) and high (cold cache) estimate in USD. It changes nothing.

create_show propose

Create show

Start a new show in an empty folder: propose show.json, its ThemeSpec (what exists: premise, tone and its never-list, setting, world rules, catalog) and its StyleSpec (how it looks and moves) together as one change set. Use it once, when show_summary says the folder has no show yet and the person has described the show they want. Write the theme and style as complete documents; describe the look by its qualities (line, shading, palette, timing), never by naming copyrighted works or studios as targets. Leave theme.defaults.characterPattern and catalog pattern references out until those patterns exist. meta.provenance is filled in by the tool. Returns a proposal (a change id) for the person to review; nothing is written until they approve it.

create_theme propose

Create theme

Propose a complete ThemeSpec: what exists in the world (premise, genres, tone with its never-list, setting, world rules, in-world language, and the catalog of set types, costume, prop, FX and graphics families and archetypes). Use it when the person wants a new or re-imagined world; for adjustments to the existing theme use revise_theme. A theme with the same id is rewritten whole. meta.provenance is filled in by the tool. Returns a proposal (a change id) for the person to review; nothing is written until they approve it.

create_style propose

Create style

Propose a complete StyleSpec: how the show looks and moves (line, shading, color and palette rules, texture, motion, camera, timing, and design transforms). Describe qualities; never name copyrighted works or studios as targets. Set makeActive to also switch the show to it (restyle_show does that for an existing style). A style with the same id is rewritten whole; for adjustments use revise_style. meta.provenance is filled in by the tool. Returns a proposal (a change id) for the person to review; nothing is written until they approve it.

create_character_pattern propose

Create character pattern

Propose a complete CharacterPattern: the seeded distribution characters are drawn from (param rules addressed by JSON Pointer into a CharacterInstance, archetypes, costume and palette plans, persona and voice rules, ensemble constraints). Its archetypes and costume families must be in the theme's catalog. Use it before generate_characters when the show has no pattern for the kind of character asked for. A pattern with the same id is rewritten whole. meta.provenance is filled in by the tool. Returns a proposal (a change id) for the person to review; nothing is written until they approve it.

create_set_pattern propose

Create set pattern

Propose a complete SetPattern: a kit of parametric pieces and the layout grammar build_set samples rooms from (room, zones, placements, marks, camera setups, lighting). Its set types must be in the theme's catalog. Use it before build_set when no pattern fits the place asked for. A pattern with the same id is rewritten whole. meta.provenance is filled in by the tool. Returns a proposal (a change id) for the person to review; nothing is written until they approve it.

create_graphic propose

Create graphic

Propose a complete GraphicInstance: an in-world sign, screen, label, poster, logo or badge, as layout blocks on a canvas (text in the show's in-world language, fonts from the style's typography; screens may animate, looping every loopSec). Reference it from a set element (its graphic, for a console's screen or a sign) or from a costume layer (its emblem, for a badge or patch). A graphic with the same id is rewritten whole. meta.provenance is filled in by the tool. Returns a proposal (a change id) for the person to review; nothing is written until they approve it.

create_sound propose

Create sound

Propose a sound effect as a SoundRecipe: layers of tones (a pitch, a glide to another, vibrato, partials for bells and metal), sequences of notes (a chime, something that sings) and filtered noise (hiss, rush, rumble), each with an envelope, plus an optional echo. Reelwright synthesizes it, the same bytes on every machine, and it is the sound sfx.<slug> exactly as a recorded audio/sfx/<slug>.flac would be: name it with the word the screenplay uses, so "The comm CHIMES" finds sfx.comm_chime. Music is the same, with the id music.<slug> (audio/music/<slug>.sound.json): a tune a music cue starts, loops while it plays and stops, so "a scratchy old WALTZ crackles out" finds music.waltz; make it a whole number of bars that loops cleanly. It is synthesized before it is proposed, so a recipe that comes out silent is refused; the answer gives its length and peak, and a picture of it (its waveform over its spectrogram, in Hz against seconds) to check its pitch, envelope and noise against what was asked. A sound with the same id is rewritten whole. meta.provenance is filled in by the tool. Returns a proposal (a change id) for the person to review; nothing is written until they approve it.

create_fx propose

Create effect

Propose a visual effect as an FxInstance: particle emitters (each with a look: sparks, smoke, steam, streaks, debris, rain, snow, dust, bubbles or confetti), soft glows, and an optional flash that lights whoever is near. It is a pure function of time with a seed, so it renders the same every time. An fx cue plays it from an element (its kit piece's fx anchor, else the middle of its top: a porthole's top rim, so lower the emitters' originM to bring it down the glass), a mark, or a character (from the chest, also for what they hold); the cue's toward turns the first particle emitter's directionM at its target, so author that direction as "away from the source" and let the cue aim it (smoke in someone's face, confetti over a crowd). Sparks, streaks, debris, confetti and rain are drawn as four-point stars stretched along their flight; smoke, steam, dust, snow and bubbles as soft puffs. Name it with the screenplay's word, so "a puff of black smoke" finds fx.black_smoke. Beams and shockwaves are not drawn yet: build them from particles. render_preview with kind fx and this change's id shows it played from the top of a post, in six frames across its length: check that it reads before an episode uses it. An effect with the same id is rewritten whole. meta.provenance is filled in by the tool. Returns a proposal (a change id) for the person to review; nothing is written until they approve it.

create_props propose

Create props

Propose complete PropInstances (1 to 24), each with its parametric recipe, params, palette, how it is held, and whether it lies on its side when set down (rest lying, for a wrench, a broom or a pipe), as one change set. A thing that gives light (a flashlight, a lantern, a headlamp) has a recipe anchor of kind light with a light (color, intensity, rangeM, coneDeg, expressions of its params so a state can switch it off) and a pitchDeg to aim it down: it lights the set and props in its cone. A beam or a glow in the air takes a material slot of finish haze, drawn see-through and unlit (its emissive and its color's alpha set how strong). A thing other props go in (a toaster's slots, a vase, a holster) has a recipe anchor of kind seat for each, where the base of what goes in it stands: one in each slot, low enough that a slice pokes out of the top; a pan, a plate or a tray needs none: things rest on its floor, side by side where there is room. Use it when a scene or set needs objects the show does not have. Props with ids that already exist are rewritten whole. meta.provenance is filled in by the tool. Returns a proposal (a change id) for the person to review; nothing is written until they approve it.

save_gesture propose

Save gesture

Keep a gesture in the show's own gesture library for a rig template (gestures/<slug>.gestures.json), laid over Reelwright's by id: one the show already has is rewritten, one Reelwright has (wave, shrug) is taken over for this show, any other is added, and from then on a gesture cue of that id plays it. A gesture is keyed tracks on the template's bones: rotationDeg [frontal, sagittal] on a limb bone or [yaw, pitch] on a center bone, offsetCm [x, y], scale; keys at normalized times 0..1 with an ease, usually rest at 0 and 1 and the pose at the stroke (strokeSec over durationSec). Studio's pose editor makes these. Returns a proposal (a change id); nothing is written until it is approved.

remove_gesture propose

Remove gesture

Take one of the show's own gestures out of its library for a rig template; Reelwright's own gesture of that id plays again if it has one, and a library left empty is deleted. Returns a proposal (a change id); nothing is removed until it is approved.

revise_theme propose

Revise theme

Propose edits to the show's ThemeSpec: premise, tone, never-list, setting, world rules, catalog entries. Use it for adjustments; create_theme rewrites the whole theme. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_style propose

Revise style

Propose edits to a StyleSpec: line weight, shading, palette and color rules, motion, camera, timing, design transforms. Editing the active style re-renders everything drawn in it; check impact first when the change is large. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_character propose

Revise character

Propose edits to one character: body (/body/heightCm), head, hair, costume, palette, persona, voice. Use it for requests like "make the engineer older and grumpier" or "the second one, but taller". Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_set propose

Revise set

Propose edits to one set: its elements, marks, walkways (/paths), camera setups, lighting and palette; also its name, its setType (or remove it, for a place the theme has no type for), its pieces (remove a recipe no element uses: a set built from another type keeps that type's) and its room tone (/ambience: {} for Reelwright's own, {"sound": "sfx.<slug>", "gainDb": -6} for a sound of the show's, null for none). /stage/seeThrough makes it a see-through stage for characters over footage: no walls, floor or backdrop, and transparent behind what it draws in a render with alpha (an empty object keeps the characters' blob shadows; shadows false leaves them out). Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_kit propose

Revise kit

Propose edits to one of the show's kits of set pieces (kits/): a piece's parts (/pieces/0/nodes), params, materials, anchors, footprint, tags or dressing rules (/pieces/0/place), the kit's palette or its looks. save_piece adds or replaces a whole piece; Reelwright's library kits are not the show's to edit. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_prop propose

Revise prop

Propose edits to one prop: its name and description, its recipe (params, nodes, anchors), its palette colors, how it is held (/holding: grips, heldScale, view) and its states. Use it to adjust a prop a few fields at a time (a fuller fern, a handle to carry it by); create_props makes new ones; render_preview with kind prop shows the result. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_fx propose

Revise fx

Propose edits to one visual effect: its length and whether it loops, its seed, each emitter (its look, rate, speed, spread, size, colors, lifetime, where it starts) and its flash. Use it to adjust an effect a few fields at a time; create_fx makes new ones; render_preview with kind fx shows the result. Returns a proposal for the person to approve. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_graphic propose

Revise gfx

Propose edits to one graphic (a sign, a screen, a label, a poster, a logo, a badge): its canvas, palette, blocks of text and shapes, and how a screen loops. Use it to adjust a graphic a few fields at a time; create_graphic makes new ones. Returns a proposal for the person to approve. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_outline propose

Revise outline

Propose edits to one episode outline from the writers' room: its title, premise and logline, its target length, its cast, and its beats and scenes. Use it to adjust an outline a few fields at a time; write_outline writes a whole checkpoint. Returns a proposal for the person to approve. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_sound propose

Revise sound

Propose edits to one sound recipe (sfx.* or music.*): its length, peak and echo, and each layer (a tone's pitch, glide, vibrato and partials; a sequence's notes; noise's color and filter; every layer's envelope). It is synthesized before it is proposed, so a recipe that comes out silent is refused. create_sound makes new ones. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

revise_pattern propose

Revise pattern

Propose edits to a pattern (pattern.character.*, pattern.set.*, pattern.prop.* and the others): a param's range or choices, an archetype, a palette rule, a kit piece or its params, a placement, a mark, a camera setup. Use it to fix or adjust a pattern a few fields at a time; create_character_pattern and create_set_pattern rewrite a whole one. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

write_bible_entry propose

Write bible entry

Propose additions or edits to the series bible (bible.*): lore (/lore/-), relationships, running gags, tone rules, arcs and open story threads. Use it when a conversation establishes something that should stay canon. Keep entries short and specific; search_canon first so they do not contradict what exists. If the show has no bible yet, the edits start from an empty one with the id you give. Each edit sets one field: pointer is a JSON Pointer into the document (read it first with get_document), value is the new value as JSON text (162, "bob", {...}); /- appends to an array and the literal null removes an optional field. Returns a proposal (a change id) for the person to review; nothing is written until they approve it. Locked pointers are refused, and an invalid result comes back with the edit that caused it.

restyle_show propose

Restyle show

Propose switching the show's active style to another StyleSpec that already exists (create_style makes new ones). Everything drawn re-renders in it; story data is untouched. When the new style's design transforms or frame rate would change how locked characters look, the proposal lists them as canon drift for the person to check before approving. Returns a proposal; nothing changes until the person approves it.

propose_styles propose

Propose styles

Propose two to four distinct directions for one of the show's styles, as one variation group: each option rewrites the style whole (its id kept), with its own line, shading, palette and color rules, texture, grade, post effects, design transforms and typography, and a name and a reference in words. Use it for "show me four directions", for a new show's look from the person's words or pictures, or when the person wants to see very different looks before tuning one with revise_style. words is what the person said they want; the theme's premise, genres, setting and tone are read too, and the style's reference pictures (references) set the palette. from starts the directions from another style of the show or one of Reelwright's built-in styles. Called over MCP, you are the model: it answers with your task, for plan_submit, and nothing is charged. Else the person's Claude, or a configured model, proposes them; otherwise Reelwright's own rules draw them, the same for the same seed. Every option keeps the slots of the style's palette, which the show's documents may use. Returns the options' change ids; approving one rejects the others, blend_styles mixes two or more of them, and nothing is written until the person picks.

blend_styles propose

Blend styles

Propose one revision of a style that blends two to four looks by weight: numbers mixed, colors mixed in OKLab, palettes mixed slot by slot, and switches and choices taken from the heaviest look. The looks are proposals still waiting (the options propose_styles gave: the style each would write) or styles of the show. Use it when the person likes parts of several directions ("the line of the second with the colors of the third": weight them). The style keeps its own id, name, references and palette slots. Returns a proposal; nothing is written until the person approves it, and the options it blends stay waiting until they are approved or rejected.

generate_props propose

Generate props

Draw props from prop patterns with the seeded sampler, one for each thing named as a scene calls it: the show's own prop patterns first, then Reelwright's library (a paper lantern, an oil lantern, an umbrella, a phone, a mug or cup, a spoon, a crate, a book, a bag, a bottle, a box, a note or letter, a kettle, a candle, a chest, a shop's roll-up shutter). A thing is the pattern whose name or tags its last words are, the longest match winning ("a camping lantern" is the oil lantern); a color its words give is its main color ("red lantern"), "big" or "small" draws it so, and a word naming one of the pattern's variants picks it ("a gift box", "a ladle"). Each is sized as what it is, and held where its grips are. A thing no pattern answers to is the kind of thing it is, built from parts (a thermos, a coin, a flashlight, a jug, a plate, a wrench, a pillow, a ball and nearly a hundred more), or the kit piece it is, a kit the show's sets are built from first ("a counter" the diner's, "a lamp", "a telephone"). Its words shape it ("a tall jar", "a flat stone", "a jar with a lid") and say what it is made of ("a brass whistle", "a wooden spoon"); a thing only its shape words describe is built from them ("a round metal gadget"), and a thing nothing describes is a plain box to shape in Fields. The same name and seed always draw the same prop. Use it for the things a scene handles that the show has no props for; create_props writes a prop whole. Returns one proposal; nothing is written until the person approves it, and render_preview with kind prop shows each.

generate_characters propose

Generate characters

Draw new characters from a CharacterPattern with the seeded sampler: count characters, selected as an ensemble that reads apart (silhouette, color, height, hair). roles casts one character per listed archetype, in order, for "a captain, a pilot and an engineer" (count equals its length); archetypes only limits which archetypes a draw may use, so several characters can share one. replace gives existing characters a new look instead, keeping their id, name, persona, voice and locked parts (count must equal the number replaced). options > 1 proposes that many alternative casts as one variation group, for "give me 4 options". The same seed always draws the same cast; change seed for different ones. Returns proposals with the characters' ids and names; nothing is written until the person approves one, and render_preview with the change id shows their model sheets.

create_character propose

Create character

Make one character of any kind from words (docs/design/m16-any-character.md): a person, a four-legged animal (quadruped: a cat, a dog, a horse), a serpent (a snake, a slug, a worm), a blob (a slime, a ghost, a round bird), a robot (on wheels, treads, a hover pad or legs, with or without arms) or a talking object (a kettle, a teapot, a mug, a lamp, a toaster, a crate, a book). Reelwright reads the description itself, with no model: the kind and shape from its noun ("space slug" is a slug), features from its words ("three-eyed", "on treads", "spotted", "horned", "fluffy"), its size ("tiny", "giant"), colors by name, the persona from the rest ("grumpy … who runs the cargo bay"), and a voice to match; the summary says what it read. A person is one of the show's people, at the age the words give ("sixteen-year-old", "in his seventies", "grandfather"), with the pronouns they give ("girl", "he"), tall or short as said, dressed in each garment named (a yellow rain slicker, a wool cap, overalls, a dress) over the show's own clothes and never unclothed; a colour goes to the garment, hair or eyes it is said of, and skin comes only from skin words ("pale", "green-skinned"). No two characters in a show get one voice, or one hair style and face. Say more where you know better: kind, a whole plan (kind, shape, locomotion, drive, legs, arms, tail, markings, extras, accent, glow), name and shortName, and edits by pointer as revise_character takes them (e.g. /head/eyes/count, /palette/0/color), which win over what it read. Use it for any new character a show needs that its patterns do not draw, and for "a ship's cat that talks". options > 1 proposes that many as one variation group (seeds differ), for "show me a few". Returns a proposal; nothing is written until the person approves it, and render_preview model_sheet with the change id shows it.

vary propose

Vary

Propose count alternatives of one character that differ only at the given pointers (/head/hair/style, /palette, /costume, /body/heightCm), re-drawn from its pattern, as one variation group. Use it for "show me some other hairstyles" or "a few palettes for Otto". Everything else stays byte for byte; locked pointers are refused. Returns the options' change ids; approving one rejects the others, and nothing is written until the person picks.

build_set propose

Build set

Draw a set (a room with its pieces, marks, camera setups and lighting) from a SetPattern with the seeded sampler: one of the show's, or one of Reelwright's library (a 1940s jazz club, a diner, an office, a castle hall, a spaceship corridor, a city street, a forest, a kelp forest, a reef; list_kits lists them). With no pattern, the set's name and description choose one as episode_needs does: the one the place is, by the kind of place it is or a word only that pattern's name or tags have, never one word another's description says in passing, nor a table, a lamp or a radio (of setType when given); else setType does (one no room of that type looks like yet, built or waiting in a proposal, else the theme catalog's); else Reelwright's plain room or open air, indoors or out as the words say, dressed with the library's pieces the description names (a ship's wheel, a chart table with a radio on it, windows all round, a hanging lamp) and what such a place has where it names none, and the proposal says what no piece is. A description also lights the set (the night, rain, snow or fog it says, from the library's looks) and, with a pattern, places what it names that the pattern leaves out. The proposal says which pattern and why. setType picks one of the pattern's set types, id names the set (by default its name as a slug, set.rooftop for "Rooftop", with a number after it where a set has that id, else set.<pattern name>_<seed>; an existing unlocked set with the id given is rebuilt, and keeps its name; a set given an id and no name is called by the id, "Boxwood Bridge" for set.boxwood_bridge). options > 1 proposes alternative layouts as one variation group. Returns proposals; nothing is written until the person approves one, and render_preview (set_view) with the change id shows its camera views.

import_asset propose

Import asset

Bring in an image the person has (a painting, a photo, a CC0 download: a PNG or JPEG file on this machine) as a set backdrop. license is the image's SPDX license (CC0-1.0, CC-BY-4.0, …) and attribution the credit it asks for; ask the person rather than guess. for names the set and backdrop: an existing backdrop keeps its id, distance and drift and draws the image instead of its generator; a new id adds one. A backdrop is an equirectangular panorama, 2:1, drawn all the way around the set. It runs the Tier 2 pipeline: the image becomes an sRGB PNG at most 4096 px on its long side, is pulled toward the set's and the style's palette when the style snaps (color.rules.snapToPalette), and passes QA (palette compliance, and a backdrop's 2:1 equirectangular aspect and size) or is refused with the report. The frozen file is stored at once under assets/<sha256>.png with its provenance (license included); it does nothing until the person approves the set change that names it. The answer gives the QA report and, when the studio can render, the set's wide view as the change would leave it. Returns a proposal (a change id) for the person to approve.

import_clip propose

Import clip

Bring in a clip of footage Cutwright cut (its clip export: a folder holding clip.json, the frames and the sound) so a screen in a set can play it: a TV, a monitor, the bridge's viewscreen. dir is that folder (on this machine, absolute or relative to the show folder). license is what the show may do with the footage (an SPDX id or LicenseRef-…; ask the person rather than guess) and attribution the credit it asks for. Every frame and the sound are checked against the hashes clip.json names, each frame against the clip's size and the sound against its rate and length, or the clip is refused with what is wrong. They are frozen under assets/ as they came, at once, each with its provenance: Cutwright and its version, and the clip's own record of the project, the words it was cut between and its sources' hashes. The ClipInstance (clips/<slug>.clip.json, clip.<slug>) that names them waits for the person to approve it; then edit_episode adds a screen cue that plays it on a set element, one clip frame per frame, so the episode should be compiled at the clip's rate. Returns a proposal (a change id) and the clip's id, frames and rate.

paint_sky propose

Paint sky

Paint a sky all the way round a set, for an exterior (a hilltop, a beach, a moon) or a window onto one: its color straight up and at the horizon, far land below the horizon, far hills along it, suns, moons and planets (banded, ringed, lit from the sun), clouds and stars. Azimuth 0 is straight upstage, behind the set, where the cameras mostly look; ±90 the sides. Reelwright paints it (flat, stepped color, as the show's cel style draws), at 2048×1024, so it needs no image provider and is CC0. for names the set and backdrop: an existing backdrop keeps its id, distance and drift and draws the sky instead; a new id adds one. It runs the Tier 2 pipeline: the image becomes an sRGB PNG at most 4096 px on its long side, is pulled toward the set's and the style's palette when the style snaps (color.rules.snapToPalette), and passes QA (palette compliance, and a backdrop's 2:1 equirectangular aspect and size) or is refused with the report. The frozen file is stored at once under assets/<sha256>.png with its provenance (license included); it does nothing until the person approves the set change that names it. Returns a proposal (a change id) for the person to approve.

generate_image propose

Generate image

Generate a set backdrop from a prompt with the show's image provider (show.json providers.image, in order), at 4096×2048, an equirectangular panorama drawn all the way around the set. No provider ships yet: each needs an account and an API key the person sets up, and until then this says so and changes nothing; use import_asset with art the person has instead. It runs the Tier 2 pipeline: the image becomes an sRGB PNG at most 4096 px on its long side, is pulled toward the set's and the style's palette when the style snaps (color.rules.snapToPalette), and passes QA (palette compliance, and a backdrop's 2:1 equirectangular aspect and size) or is refused with the report. The frozen file is stored at once under assets/<sha256>.png with its provenance (license included); it does nothing until the person approves the set change that names it. Returns a proposal (a change id) for the person to approve.

add_piece propose

Add piece

Stand a set piece in a set: a piece of the show's kits, of Reelwright's library (list_kits), or of a set pattern's own kit. It goes where its dressing rules say: on the floor at positionM (the floor's middle by default), hung on the wall nearest positionM, hanging from the ceiling, or on the top of the element under it (a lamp on a table, standing on `on`); it turns toward the cameras' side, the room's middle or away from its wall, unless yawDeg says; a piece that comes in clumps (kelp, rocks) is scattered round the point, `count` of them. The set gets the piece's recipe (once), the palette colors it needs that the set lacks (from its kit's palette), and a mark at each seat and stand of it. Returns a proposal: nothing changes until the person approves it, and render_preview (set_view) with its change id shows it.

save_piece propose

Save piece

Keep a set piece in one of the show's kits (its own, kit.<show>, by default, made the first time): a new piece, or a new version of one with the same id. A piece is a parametric recipe (recipe nodes: box, rounded_box, cylinder, ring, extrude, lathe, panel, decal, array, subtract) with params, material slots that default to palette @slots, anchors (seat, stand…), a footprint and dressing rules (place: floor, wall, ceiling or surface; against a wall; in clumps). list_kits with a kit gives library pieces to start from. Returns a proposal: nothing changes until the person approves it; add_piece then stands it in a set.

add_lighting propose

Add lighting

Add a lighting preset to a set from one of the library's looks (list_kits lists them): times of day (dawn, noon, golden hour, dusk, night), interiors (lamp-lit, fluorescent office), moods (noir, neon night, horror, dream, firelight, stage spotlight), weather (rain, storm, snowfall, windy, misty morning) and places (underwater with caustics, deep sea, space). The look's key, fill, ambient, rim, fog, caustics, haze, gobo, sky and weather (rain, snow, wind, fog banks) come as they are, and its practicals light the set's own pieces that fit them (every neon sign, every lamp, every candle). Returns a proposal: nothing changes until the person approves it, then the set explorer's lighting menu switches to it.

import_lut propose

Import LUT

Bring in a LUT the person has (a 3D .cube file, as a colorist or DaVinci Resolve exports one) to grade the whole show (its style, after the style's grade) or one scene (episode and scene: after the scene's grade, before its shots'). The file is file, a path on this machine (absolute or relative to the show folder; on the web service, inside the show), or upload, the id Studio's takes.upload gave its bytes, with fileName. license is its SPDX license (CC0-1.0, CC-BY-4.0, …) and attribution the credit it asks for: ask the person rather than guess. It is checked before anything is stored: a 3D table (not 1D) of 2 to 65 points a side over the domain 0 to 1, every row three numbers in 0 to 1, size³ rows; or refused, saying why. The file is frozen under assets/ as it came, and the style or scene change that names it waits for the person to approve it. strength is how much of it shows (1, all of it, by default); edit_episode's set_grade changes a scene's later. Returns a proposal (a change id) and the LUT.

import_model propose

Import model

Bring in a 3D model the person has (a .glb, a .gltf with its buffers beside it, or an .obj with its .mtl) as a piece of the show's kit, in the show's style. The file is file, a path on this machine (absolute or relative to the show folder; on the web service, inside the show), or upload, the id Studio's takes.upload gave its bytes, with fileName. license is its SPDX license (CC0-1.0, CC-BY-4.0, …) and attribution the credit it asks for: ask the person rather than guess. It is read in meters (or units: cm, mm, in; by default judged by its size, so a 180-unit chair is 180 cm) or scaled to heightM, set on the floor and centered, its front +Z, a part per material. Each part becomes a material slot whose color is pulled to the nearest palette color when the style snaps (color.rules.snapToPalette), its finish from the material (metal, gloss, glass…); the style's shading and ink do the rest. QA refuses a model with no triangles, over 60 000 triangles, smaller than 1 cm or larger than 60 m (with the units to try), or Draco or meshopt compressed; it reports how much of it was on the palette. The mesh and the file are frozen under assets/ at once; the piece (a scale param to resize it, its footprint, a stand mark in front) waits for the person to approve the kit change, then add_piece stands it in a set. Returns a proposal (a change id), its piece ref and the QA report.

import_art propose

Import art

Bring in a picture the person has (a PNG or JPEG) as a piece of the show's kit: as card, a cut-out standing on the floor (1.6 m tall by default; its see-through pixels cut away); as decal, a picture hung on a wall (a poster, a painting, a sign; 0.8 m tall by default, its middle at 1.5 m); as backdrop, a painted flat against the back wall (as wide as the set, or 8 m) or, for a 2:1 equirectangular panorama, the backdrop drawn all the way round set (its first backdrop, or a new one). widthM and heightM size it, keeping its shape when one is given. The file is file, a path on this machine (absolute or relative to the show folder; on the web service, inside the show), or upload, the id Studio's takes.upload gave its bytes, with fileName. license is its SPDX license (CC0-1.0, CC-BY-4.0, …) and attribution the credit it asks for: ask the person rather than guess. It runs the Tier 2 pipeline: an sRGB PNG at most 4096 px on its long side, pulled toward the palette when the style snaps, and QA (palette compliance; a panorama's aspect and size) or refused with the report. The picture is frozen under assets/ at once; the piece waits for the person to approve the kit change (a panorama, the set change), then add_piece stands it in a set. Returns a proposal (a change id), its piece ref and the QA report.

record_continuity propose

Record continuity

After an episode is approved, record what it established, so later episodes keep to it: facts it put on screen (one checkable sentence each, with the scene and cue or shot as evidence, 'established' if shown or said, 'implied' if suggested) and lasting state changes (a prop broke, someone learned something; persistent if it carries into later episodes). From the episode's outline the tool adds the gags it used and the threads it moved, and keeps the bible's books in the same change set: gag usage, arc beats landed, threads opened or resolved. Recording an episode again replaces its record and moves nothing twice. Nothing is written until the person approves.

fill_needs propose

Fill needs

Propose everything a pattern can make that an episode needs (see episode_needs): each new character the outline describes, drawn from its role's pattern and named as the outline names them, and each new set, built from its set type's pattern with the outline's id and name, so the screenplay's cues and headings resolve to them, and each prop the outline or the screenplay's action needs, drawn as what it is and named as it is called (generate_props). One proposal per need, so each can be approved or rejected on its own; a need already waiting in a proposal is not proposed again. Returns what is left for you to write. Nothing is written until the person approves.

write_outline propose

Write outline

Propose an episode's outline (EpisodeOutline), or a new version of it, before any screenplay. Grow it in three checkpoints, each approved before the next: (1) premise and logline, with the cast; (2) the beats, in order, each one turn (setup, inciting, complication, turn, climax, resolution, button), with what they serve in the bible (a gag, an arc's next beat, a thread); (3) the scenes, each landing beats in one place, with the Fountain heading the screenplay will use. Use the show's characters and sets by id; describe a new character (name, catalog archetype, description) or a new set (id, name as the heading names it, catalog set type, description) for the missing-asset pass to make. Respect the theme's world rules and its never list. The outline is checked against the show and the bible when proposed. Always send the whole outline; the same id rewrites it.

order_episodes propose

Order the season

Propose the season's running order (show.json's season): every episode in the order it airs, each numbered by its place. Keep every episode the season lists now, ideas too; episodes it did not list yet may join it. episodes.status and show_summary give the order now. Nothing changes until the person approves it.

add_episode_idea propose

Add an episode idea

Propose an episode idea for the season, before any outline: a working title and a logline, after an episode or at the season's end. It gets the episode id its outline and script will use (ep. and its title as a slug). Nothing changes until the person approves it.

draft_screenplay propose

Draft the script from the outline

Propose an episode's script drafted from its outline, with no model: each scene's heading, its summary as a synopsis, who is in it as a note, and the beats it lands as action, act breaks as sections, beside the outline's writers' room. A start to write over with write_screenplay, never over a script the episode has. Nothing is written until the person approves it.

remember_episode propose

Remember episodes

Propose memory's updates from episodes: a synopsis, each speaker's voice, catchphrases and callbacks with every line they play, the bible's gags each time they are used, house style, threads opened and resolved, and the continuity log's facts, each entry with the episode lines it comes from. The deterministic pass reads the scripts for free; then (unless memory's settings turn it off) the model pass reads each episode too and writes a real synopsis and voice notes. Called over MCP, you are that model: it answers with your first task, for plan_submit, and nothing is charged. Else the person's Claude, or a configured model at a cost. Pinned, locked and retired entries are never changed; what a pass wanted of them is a note in the proposal. Default: every episode memory has not remembered yet. Studio runs it on its own after an episode is directed. Nothing is written until the person approves.

edit_memory propose

Edit memory

Change what the show remembers: add an entry (a tone rule, a never, a voice note, a gag, a fact, a thread), rewrite one, pin it (always in every writer's context), rest a gag that is getting old, retire one (kept for history, never read) or forget it, move an episode in the story (place), or change memory's settings (review or auto-apply after each directed episode, which kinds to remember, the token budget, how many episodes the story tells in detail, when gags rest, whether the model pass runs). Read show_memory first for entry ids. Locking an entry against the passes is the person's: a locked entry is never changed here. Nothing is written until the person approves.

remove_document propose

Remove document

Remove a document or a sound from the show: a character, set, prop, effect, graphic, sound, style, theme, pattern, outline, bible or episode (an episode goes with its folder: its screenplay and its writers' room). When anything still uses it (find_uses says what), it is refused with the list, unless replaceWith names another document of the same kind to take its place everywhere (screenplay cues and scene headings follow a replaced character or set), or anyway drops it from the lists that name it (an episode's cast, an entry's about) and leaves the rest for validation to judge. A locked document, or a locked reference to it, is refused with the lock named. The show's active style is switched with restyle_show first. Returns one change set for the person to approve; undo brings everything back.

rename_document propose

Rename document

Rename a document or a sound: a new name (an episode's or outline's title; a recorded sound's title, kept in its file; a character's shortName too, the name scripts call them by, which follows a new name when it was only the old name or first name), a new id (to, keeping its kind's prefix: char.otto → char.ottoline), or both. Everything follows in the same change set: every document that names the id, the files that move (an episode's folder and screenplay, a sound's file), and the screenplays' character cues, scene headings and a character's names in action lines and parentheticals (a cue written with the old name says the new one; a cue through the episode's castMap stays; what is spoken stays as recorded). A locked document, or a locked reference to it, is refused with the lock named. Returns one change set for the person to approve; undo puts every name back.

duplicate_document propose

Duplicate document

Copy a document or a sound under a new id (to; default <id>_copy) and name (default "<name> copy"): a character to vary, a set to dress differently, a prop, an effect, a sound, a pattern, an outline or a whole episode with its screenplay. The copy names itself by its new id, keeps where it was drawn from, and has no locks: it is not canon until the person locks it. Returns one change set for the person to approve; undo removes the copy.

import_sound propose

Import sound

Bring in a sound file the person has (a WAV, Ogg, MP3 or FLAC: a foghorn they recorded, a CC0 download, a song) as a sound effect (sfx) or music of the show. It is kept as audio/<family>/<slug>.flac, 48 kHz 24-bit, with its channels and loudness as they came, and is the sound sfx.<slug> (music.<slug>) a cue plays, as a recipe of that name would be: name it with the word the screenplay uses. Ask the person for the file's license rather than guess, and say it in the rationale. Returns a proposal for the person to approve; undo removes the file again.

restore_version propose

Restore a version

Puts the whole show, or one document (document: its id), back as a saved version has it, as one change set: the files that differ are written back, and restoring the whole show removes documents made since. Locks hold. Proposes it for the person to approve; nothing changes until they do, and it can be undone. Only when the person asked to go back to a version; list_versions gives the ids, compare_versions what would change.

direct_episode propose

Direct an episode

Direct a screenplay into an episode (EpisodeIR) and propose it for the person to approve. The model director stages each scene (blocking, line delivery, looks, gestures, sound) and covers it (shots and cuts), checked against film grammar and repaired; a scene it cannot get clean falls back to the heuristic director, and the result says so. `screenplay` is the .fountain file's path in the show; give `fountain` (the text) for a screenplay the show does not have yet, and it is proposed with the episode. Give `episode` to re-direct an existing one (it keeps its title, overrides and recorded takes), `scenes` to redo only some scenes, `recut: true` to redo only the coverage (the performance stays byte for byte, edits included), and `note` for a director's note such as 'tighter'. Give `from` (and `to`) to re-direct from a moment the person stopped at: everything before it stays exactly as it is, and with `to` everything after the stretch is kept too, moved only in time; e.g. re-direct sc02 from Nell's line l05 to the end of the scene, angrier: {episode, from: {scene: 'sc02', line: 'l05'}, to: 'scene', note: 'angrier'}. studio_context gives the moment Studio is at. `heuristic: true` directs without the model and costs nothing, a re-cut too. Directing costs model calls: check with estimate_cost first. It writes nothing: the episode is a proposal; render_preview storyboard with its change id shows every shot.

write_screenplay propose

Write screenplay

Propose a screenplay (Fountain text) at a path in the show, new or replacing one. The proposal notes every speaker and location the show does not have yet (as screenplay_needs would), and the answer gives its running time as the heuristic director would cut it, against the outline's target, and its longest paragraphs and lines with their seconds, so a draft too long is cut where the time goes before it is directed. While writing, try_action shows what the heuristic director makes of an action line on a set, so wording it cannot stage is found before the draft. Direct it with direct_episode once it is approved, or pass the text to direct_episode as fountain to do both at once. Nothing is written until the person approves it.

edit_episode propose

Edit episode

Re-direct an episode by small edits, as a timeline does: move_cut (move a shot's start by bySec, later when positive, against what it is anchored on), roll_cut (roll the cut into a shot to toSec into the scene or by bySec, landing on that very frame and anchored on the word or cue there: the shot before gets longer and this one shorter, the performance stays; trimming a shot's head or tail is rolling its cut in or out), slip_shot (show a later or earlier part of the performance in a shot: both its cuts roll by bySec, its length kept), set_camera (another framing size for a framed shot, or one of the set's setups; subjects with a size make a setup's shot a framed one of them; yawOffsetDeg turns a framed shot's camera round its subject, as when it shows the back of a head; move sets its camera move whole, a push in, a pan, an orbit…, with its easing and timing, or with to a keyframed move from the shot's framing to another (size, subjects, turn, height); crossesAxis: true with a note crosses the 180-degree line on purpose, when the reversal is the point, and the refusal for axis_crossed says so; newSetup puts the shot on a new setup of the scene's set, where a view's camera stands, written into the set in the same change, the shot's move dropped unless one is given; focus where its lens focuses, on a character or at distanceM, at an fStop, or none; handheld its own handheld noise; overShoulderOf frames a single over someone else's shoulder, or none), set_camera_key (a shot's camera keys: add one at atSec into the shot, change its size, subjects, turn, height, lens, focus (a rack focus from the key before), move and easing, move it with toSec, or remove it: the camera passes through the keys' framings, zooming evenly between keyed lenses; on a setup or an insert keys rack the focus alone), pause_before (hold gapSec before a cue, or change its pause by bySec), set_mark (a character's starting mark in a scene, trading places with whoever starts there, or offstage to walk them on, or a move cue's destination; newMark makes it a new mark of the set, written into the set in the same change), delete_shot (remove a shot and its cut: the shot before runs on, or with fill: after the shot after starts where it did), set_timing (re-time any cue, keeping what it is timed from: bySec moves it later or earlier against its anchor, a word it is timed from included; at times it afresh, after or with another cue or at a time; what is timed from it moves with it; durationSec sets how long it lasts where it has a length of its own, a gesture's hold, a posture change, an effect, a shake, a float, a drift, a flight, a beat or a lighting change's fade), and split_shot (a new cut inside a shot at a cue or at atSec into the scene, with its own size, setup or insert, for a long take or a reaction; with none it frames what the shot does, a razor cut), set_caption (a line's caption: text with a newline for a new row and a blank line for a new card, saying the line's words; startOffsetSec and endOffsetSec nudge when it shows), set_mouth (a mouth shape drawn by hand over a line from fromSec to toSec seconds into it, A to H or X, or rhubarb for Rhubarb's own; kept by the words it is over), set_gain (an effect's or music cue's gain in dB; a line's loudness is its delivery volume), set_fade (a music cue's fade in seconds, or any clip's fade in and out: a line, a sound, a foley sound or a play of music, inSec and outSec), set_mix (the episode's mix, one track at a time, dialogue, sfx, foley, music or ambience: its level in dB, muted, or soloed; it names no scene), paste (cues and shots copied on the timeline, pasted into a scene at atSec, from this episode or another), lift and extract (take out what starts between fromSec and toSec of a scene, lines out of the screenplay too: lift keeps the time, extract closes it up), set_prop (add a prop cue: who picks up, puts down, hands over, uses, throws or holds which prop, when, and to whom or where, and the state it is in from then (action state changes only that: the kettle starts boiling, the drone's eyes go dark); or move or change one by its cue id) and place_prop (stand a prop in a scene from its start, on an element or at a mark, without changing the set, which other episodes share), set_float (gravity lets go: who floats (everyone on stage when none are named), how high, for how long or until which cue they land on, dropping or settling, whether loose props float too, and when; or change or remove one by its cue id), set_delivery (how a line is said, which the voice follows: its emotion, intensity, volume, pace, a note to the actor (angrily, slowly, flat, questioning; stress 'never'; pause after 'wait'), pitchSemitones, emphasis (words to stress) and pauses, and variant (which take); the line is voiced again, so a "serenely" or "quietly" the director missed can still come through), set_sung (a line sung: on an imported vocal, from fromSec to toSec of it, timed with the song's cue; to a melody of notes like A3 C4 E4:2 at a bpm; to a tune of its own; or spoken again), lay_lyrics (a scene's sung lines laid on an imported vocal in order, each given the stretch of it where it is sung: the vocal's phrases are found and shared out by syllables; inMusic times each line in the song playing), set_sound (add a sound cue: which of the show's sounds, from where, how loud, repeating or not, and when; or change or remove one by its cue id), set_music (start or stop one of the show's music tracks (music.<slug>), looping until stopped or not, playing on across scene cuts (continues) between in and out points (inSec, outSec), dipping under dialogue (duckDb), with a fade and a gain, and when; duck or swell one playing; or change or remove one by its cue id), set_ambience (a scene's room tone: a sound, Reelwright's own, none, or its set's again), set_foley (the footsteps, clothes, props and doors made from a scene: off for the scene, or one sound by its event id muted, played as another sound, louder or softer, or as made again), set_fx (add an effect cue: which effect, the show's fx.<id> or a built-in, on what, toward whom or what it is aimed, how long, and when; or change or remove one by its cue id), set_gesture (add a gesture cue: who, which of their library's gestures, at whom, and when, held until a cue or for seconds if it is holdable, such as hand_out or arms_folded; or change, release or remove one by its cue id), set_expression (add a face someone pulls: who, which emotion, how strongly, and when; or change or remove one by its cue id), set_mess (something on someone's face: soot, dust, sand, mud, paint, snow or cream, how much of it, and when; cover 0 wipes it off; or change or remove one by its cue id), set_shake (everything shaking, a blast or a meteor strike: how hard, how long, and when; or change or remove one by its cue id), set_screen (footage on a screen: a clip the show has, brought in with import_clip, on a set element's screen, frame for frame with its sound, and when; or change or remove one by its cue id), set_posture (the posture someone opens a scene in, or a posture cue: who sits, stands, crouches, leans or lies down, over how long, eased how, and when; or change or remove one by its cue id), set_look (add a look: who, at whom or what, eyes, head or body, and when; change or remove one by its cue id; or, naming a line, who it is said to), set_move (add a walk: who, to which mark, entrance or character, at what gait and speed, in through an entrance, and when; or change, retime or remove one by its cue id; what is timed from a removed cue is timed from what it was timed from; newMark walks them to a spot no mark stands on, a new mark of the set written into it in the same change), set_lighting (which of its set's lighting presets a scene is lit with, or, timed after or with a cue, a change to another mid-scene, as when every light dies and comes back on; revise_set adds one; durationSec makes the change a fade, easing how it goes, and level how bright the preset is, 0.3 dimmed, 0 out: the lights slowly dim is level 0.3 over durationSec 4, the preset left out; or change or remove one by its cue id), set_grade (a scene's or, naming a shot, a shot's own grade over the style's, as a flashback, a dream or a night exterior is graded on its own: look starts it from one of the style's looks or Reelwright's, flashback, flash_forward, dream, night, golden_hour or noir, and exposure, contrast, saturation, temperature, tint, the split toning tints, lift, gamma and gain set those dials over it; look none keeps the dials alone, clear takes the grade away; a scene's lut, a .cube import_lut brought in, with lutStrength, or noLut), set_transition (how a shot comes in: a cut, or a dissolve, wipe, iris, whip or dip to black from the shot before over durationSec, among the style's allowed transitions), set_marker (a named marker on a moment of a scene, a note for whoever edits it, at atSec and pinned to the word or cue there; or rename, move or remove one by its id), set_pose_key (a pose keyed by hand on a character over what the director made, one of their poses from the pose maker or Reelwright's, reached at atSec after blending in over inFrames, held holdFrames, blended out over outFrames, pinned to the word, line or beat there and kept by it; or change, move or remove one by its key), set_lower_third (a lower third naming someone on screen: a name and a line under it, over a shot from just after its cut, or timed from a cue; give the character and it takes their name and role; change its words, design or length, move it, or remove it by its cue id), set_dub (the episode dubbed into another language than the show's: each line's words there, by scene and cue, and its caption when not as the compiler cuts it, written into that dub and keeping its other lines; a render in that language voices, lip-syncs and captions them; remove: true takes the dub away) and set_titles (the opening title card, with the show's and the episode's titles, and the end credits: add or remove either, set their lengths in seconds, or the credit lines; it names no scene). Scenes, shots and cues are named by id (read the episode first; episode_timing says when each plays). Give change to edit a proposal still waiting (a direct_episode or an earlier edit not yet approved): the result is its revision, carrying its other files, and approving it rejects the one it revises; without change the edit is of the episode on disk, and it replaces any proposal still waiting for that episode the same way. The edited episode is compiled before it is proposed: the proposal says how the running time moved and what film grammar finds, and an edit that breaks the cut is refused. Give recut: true with blocking edits (set_move, set_mark, set_posture) whose old shots no longer fit: the scenes they touch are covered again around the new blocking, the performance as edited. Use direct_episode with recut for a whole new coverage instead.

import_otio propose

Import an editor's cut

Bring an episode's cut back from an editor: the .otio that reelwright export otio wrote, after the cut was trimmed in DaVinci Resolve, Premiere or any OpenTimelineIO editor. Cuts moved by trimming become move_cut and lifted shots delete_shot, and a trimmed or lifted title card (the opening card, the credits) set_titles, proposed through edit_episode, so the proposal compiles the episode and says how the running time moved. What edits cannot carry (shots reordered or repeated, foreign clips, a scene made longer or shorter) is listed, not imported. Nothing is written until the person approves.

approve_change decide

Approve change

Apply a proposed change set to the show, atomically, and commit it when the show is a git repository. Only call this after the person has explicitly asked for this decision in their own words; never on your own judgment, and never to tidy up. Approving one option of a variation group rejects the others. A proposal whose files changed since it was made is marked stale and not applied. Returns the applied change and its commit.

reject_change decide

Reject change

Decline a proposed change set; the show is untouched and the proposal stays in history as rejected. Only call this after the person has explicitly asked for this decision in their own words; never on your own judgment, and never to tidy up.

undo decide

Undo

Undo an applied change set by applying its inverse as a new change set (history is never rewritten), and commit it when the show is a git repository. Undoing an undo re-applies the change it undid. Undoing the person's own rejection puts the proposal back to wait for their decision. Refused when the files have changed since. Only call this after the person has explicitly asked for this decision in their own words; never on your own judgment, and never to tidy up. Returns the change now in effect.

redo decide

Redo

Re-apply a change set that was undone, if its files are still as it expects; a proposal whose rejection was undone is rejected again. Takes the id of the undone change, not of its undo. Only call this after the person has explicitly asked for this decision in their own words; never on your own judgment, and never to tidy up.

lock decide

Lock

Lock a document as canon (no pointers: the whole document, meta.status "locked") or some of its subtrees (/head keeps the face while the costume can still change). Locked parts are never regenerated or changed without the person unlocking them first. Applied at once as its own change set, so it can be undone. Only call this after the person has explicitly asked for this decision in their own words; never on your own judgment, and never to tidy up.

unlock decide

Unlock

Remove locks from a document (no pointers: every lock, and meta.status "locked" becomes "approved"), so it can change again. Applied at once as its own change set, so it can be undone. Only call this after the person has explicitly asked for this decision in their own words; never on your own judgment, and never to tidy up.