Contents

Roadmap

The milestones follow the brief's order. Each ends with something you can watch or try. Where this plan changes the brief, the change is marked Change with the reason.

M0 Foundations (done 2026-09-29)

• Scaffold
  • core/: pnpm, TypeScript on Node 24, Vitest, Biome.
  • engine/: a Godot 4.7.2 project with the addons/reelwright skeleton, vendored gdUnit4, and the typed-warning settings from ADR-0010.
  • tools/: toolchain.json with versions and checksums, a Linux Godot installer, and rhubarb/install.sh.
  • LICENSE, CHANGELOG, CONTRIBUTING.
• Schemas v1.0: all of them.
  • Already drafted: Show, Theme, Style, CharacterPattern, Character, Set, EpisodeIR.
  • Still to write: SetPattern (kits as data, layout grammar), PropPattern and PropInstance, FXPattern and FxInstance, GraphicsPattern and GraphicInstance, Bible, Continuity, ChangeSet, Timeline, RigTemplate, PartLibrary, GestureLibrary.
• Codegen. Schemas generate TypeScript types and GDScript typed classes. CI fails if the generated files are stale.
• reelwright validate. Runs schema and semantic checks, with the canonical formatter, JCS hashing, and seed derivation plus PCG32 checked against cross-language test vectors.
• CI (GitHub Actions, ubuntu-24.04, pinned):
  • lint: Biome, tsc, GDScript formatter, schema lint, hidden-input grep;
  • core tests;
  • engine tests under xvfb;
  • a smoke render of a test stage, which becomes the demo render in M1.
• Try it: reelwright validate examples/shows/marigold passes, CI is green, and CI uploads a rendered smoke frame.

M1 Runtime proof: a ~30-second scene, no AI (done 2026-09-30)

• Engine
  • Set builder: the primitive pieces.
  • Character builder v1: biped_toon.v1, with the toon.v1 parts Otto and the Chief need, the 2.5D head, and front, three-quarter and profile bodies.
  • Style shaders v1: cel shading, ink silhouettes, grain.
  • Timeline player: evaluate(frame).
  • Frame server, plus the Movie Maker path.
  • Model sheets.
• Core: compiler (timing, blocking, framing solver, idle and blinks, Rhubarb visemes), the audio plan, the ffmpeg mix and encode, and reelwright render.
• Demo audio: Kokoro dialogue takes (FLAC) and sound effects synthesized with ffmpeg (original, CC0).
• Tests: golden frames, a purity test (seeking to frame N ≡ playing to frame N), and a parity test (frame server ≡ Movie Maker).
• Watch it: lighthouse.mp4. It is the "Lighthouse" cold open: about 30 s at 1080p24, with captions, 8 shots, lip sync, the Chief rising from behind the console, and a spark effect. Model sheets for Otto and the Chief come with it.
• Change: "hand-made simple assets" become hand-written instance specs built by the real builders, not throwaway art. M1 gets heavier, M2 gets lighter, and nothing is thrown away.

M2 Parametric generation (done 2026-09-30)

• Samplers: CharacterPattern (with ensemble constraints), SetPattern (kits as data and a layout grammar), and the OKLab palette solver.
• Styles: complete StyleSpec coverage, plus a second demo style to prove restyling end to end.
• Watch it: reelwright generate characters --pattern pattern.character.marigold_crew --count 6 produces six model sheets. The M1 scene is then re-rendered with a generated cast and set.

M3 Showrunner for world-building (done 2026-09-30)

• Agent: the loop (official Anthropic SDK, claude-opus-5-5), the tool registry (read, propose and decide tools, strict schemas), change sets with previews, variation groups, locks, undo and redo, the dependency graph (impact and status), recorded fixtures, and budgets per request, per month and per episode, kept in a spend ledger every process on a show shares.
• Change: the MCP server shipped first (reelwright mcp), and it is how the watch-it ran: headless Claude Code on a subscription, no API key.
• UI (ADR-0011): the session protocol and daemon (reelwright serve), the UI components in addons/reelwright/ui/, Reelwright Studio (tools/studio.sh) and the editor docks.
• Watch it: from an empty folder, Claude Code built Starship Dandelion in 59 turns: show, theme and style; a crew pattern; a crew of four; a bridge pattern and the bridge; then an older, grumpier engineer, approved and undone. Its stumbles became checks:
  • a pattern that leaves a required field unset is refused, and a part library, style or fixed color the engine would not draw as written is flagged, all at proposal time;
  • a character pattern previews as a line-up of samples;
  • casting by role;
  • every preview reaches the client, as a contact sheet when there are many;
  • cameras stay on the set's floor;
  • a doorless wall is flagged when the set pattern is proposed.
• Second watch-it, after those fixes (Starship Percolator): 47 turns instead of 59; the crew pattern was approved once, fixed before approval; the crew of four was cast by role in one call; every bridge camera arrived on one contact sheet. Its own findings became revise_pattern, create_graphic and a check on where a wall can cut its door.
• Left for later: recording the watch-it as replay fixtures, and the same conversation in Studio's chat, both of which need an API key.

M4 Director AI

• Fountain → EpisodeIR, with a repair loop over schema, semantic and film-grammar diagnostics.
• Change: pull a minimal voice stage into M4, using local Kokoro takes generated per line, so M4's output has voices. The brief's order would make M4 and M5 produce silent episodes until M6.
• Watch it: a hand-written screenplay becomes a directed, voiced video.
• So far: the Fountain parser and resolver, a deterministic heuristic director, the model director (perform and cover stages, repaired against film grammar, falling back to the heuristic), local Kokoro voicing (reelwright voice), and direct and direct_episode proposing the episode as a change set, with a storyboard of every shot to review it by. CI directs, voices and renders The Salvage Claim with the heuristic director on every push. The model director's watch-it waits for an API key.
• Three-handed scenes (from the sixth and seventh watch-its): the sixth's showrunner rewrote Many Happy Returns seven times around the heuristic director, which showed the Captain's back, looked at whoever spoke last, stood a muffled Chief up behind his console, and widened shots across the axis. Singles now play on the eyeline of whoever their subject faces, a "(to the Chief)" or a name called out sets the look, a muffled voice stays down, a negated action makes no cue, a return to a set starts everyone where they were, and no picture's edge cuts through a face (grammar.face_cut). The seventh (The Surprise Inspection, 74 turns) directed clean the first time, and re-directed with these fixes it has no grammar findings at all.
• Staging from the watch-its (eighth to eleventh): a walk to a character walks up beside them where no free mark is near (EpisodeIR 1.8), round the furniture and the people, and stops at their side as the room's camera sees them, hiding no one from it; a walk between places no walkway joins is planned round the furniture; a scene everyone walks on to has no blocking (1.9); an entrance goes where its sentence sends it after the way in, or up beside whoever it comes in after, and never into a seat unasked. The camera keeps to the room: the axis is read where the pair first stands on stage, a walker stays in the picture (the shot pans with them where the style allows), a close insert frames a thing the set has no close camera on (1.10), and coverage prefers angles with room to stand back, turning or widening a shot crammed against a wall. The eleventh watch-it's music box crowded three people into the bridge's back corner; re-directed, no camera stands at less than 45% of its distance, none inside anyone, and it compiles with no warnings.
• The talent show (the thirteenth watch-it): juggling, a magic trick and scorecards. The director reads bounds, hops and pockets, whose scorecard "she" holds up, and a walker arrives before walking on; edit_episode can add, retime or remove a walk (set_move). A trick's teacup vanishes in one hand and comes out of another's pocket (place: "self", 1.14), and a sip reaches the lips (lift, 1.15). The camera reads the axis from the establishing wide, keeps eyelines opposed, keeps a group's edge off faces, and keeps a face in sight: grammar.subject_hidden warns of one the set or someone else hides, and the director turns or comes in to see it. Its showrunner had found the Chief behind the Captain's scorecards in three singles only by rendering stills.

M5 Writers' room and missing-asset pass (done 2026-09-30)

• Premise → logline → beats → scenes → Fountain, with checkpoints in chat. The missing-asset pass turns what the script needs into Layer 1 proposals.
• Built: the design (docs/design/m5-writers-room.md); the EpisodeOutline and write_outline, grown in checkpoints (premise and logline, beats, scenes) and checked against the show, the catalog and the bible's books; the missing-asset pass (episode_needs, fill_needs), which proposes the characters and sets an outline describes, named and voiced as it describes them, and lists the props and sounds left to make; the screenplay and the directed episode held to the outline (its scenes, its cast, its target running time).
• Watch it: one prompt to headless Claude Code over MCP ("the crew salvages a buoy that sings") made The Singing Buoy in 56 turns and 10 minutes, on the subscription: three outline checkpoints, a new captain and a second ship's bridge from fill_needs, a prop, the screenplay, heuristic direction with a storyboard, 12 approved change sets committed as the show's own history. reelwright render voiced its 15 lines with Kokoro and rendered 76.5 s (docs/images/m5/singing-buoy-frames.jpg). Its stumbles became fixes: a garment the color of the skin, a new character's pronouns and voice, sounds the pass did not list, an establishing shot asked for on a return. Still open: sound effects cannot be made yet, and long speeches get over-long shots. Props never appeared on screen (#18 in the work list); they do since M6 (docs/design/m6-props.md).
• Since: the season and the room without a model (the product audit's #14 and #15): the season's running order in show.json, each episode numbered with how far it has got and the bible's arcs and threads it moves, on a board in Episodes to drag into order, ideas on it; the writers' room on cards (beats with act breaks and what they serve, scenes on the show's sets), saved as the person's own change; and "Write the script" drafting it from the outline, its scenes as headings and its beats as action.

M6 Performance

• Cloud TTS adapters with emotion control and alignment, and alignment-based lip sync.
• A larger gesture library, emotion-driven expressions and gestures, and more idle life.
• So far: the offline half's design (docs/design/m6-performance.md); held gestures (a cue's hold, until a cue or for seconds, released by a move or posture change); twelve new gestures, five holdable; and a heuristic director that performs: gestures and faces from the action, beats by a line's emotion, nods and shakes, listeners who react, two seconds between gestures, and no reaction on a cut; and the motion style: limb speed from the drawing before, smears on a limb over the style's threshold, and fast actions on ones while characters stay on twos.
• Props on screen (docs/design/m6-props.md): who holds which prop when, compiled from prop cues (Timeline 1.5), with props standing where the set dresses them or where they were put; the engine draws each from its recipe in the style and puts it in the hand the card drew, with the hand reaching, gripping and letting go; the heuristic director reads picking up, putting down, handing over, using and holding from the action and reports a thing the show has no prop for; prop states switched by a cue (the kettle boils, the drone's eyes go dark); props a scene stands without changing its set; edit_episode's set_prop and place_prop; and the prop preview. Watched on lavapipe: the Chief takes the kettle from its shelf and hands it to Otto.
• Floats (docs/design/m6-float.md): a float cue (EpisodeIR and Timeline 1.7) lifts everyone on stage, or whoever it names, eased up, hanging with a bob and a drift, and drops them on the cue they land on, feet on the floor on that frame, with a squash the style allows; the engine lifts the card and leaves its shadow on the floor, smaller and fainter, with weightless arms and dangling legs; held props go with the hand and loose ones float off their place; the heuristic director reads "everyone floats" and "Gravity THUDS back" and goes wide; set_float. Watched on lavapipe: the kettle boils, the gravity hiccups, all three float a foot off the deck, kettle and all, and gravity THUDS back.
• In the air (docs/design/m6-float.md, "Drifting"): while a float lasts, someone can push off someone or something, drift over to them, or spin (a drift cue, EpisodeIR 1.11); both who push and who is pushed drift apart, they come to rest clear of each other, and they land where they drifted. The axis lapses while they float and is drawn again where they land. A held prop can slip out of a hand (a let_go prop cue, 1.12): it hangs where the hand was, bobbing, and falls to the floor when gravity is back. A prop the action handles that the set does not dress stands where the action handles it. Watched on lavapipe: the tenth watch-it's push-off and spin, and the eleventh's music box bobbing out of the Captain's hands.
• Flying (docs/design/m6-props.md, "Flying"): a prop flies on its own (a fly prop cue with no character, EpisodeIR 1.13) from wherever it is to a place, out through an entrance, into a hand, or to hang beside a head, bobbing where it hangs, and comes in through an entrance from off stage; the heuristic director reads "zips out through the hatch" and "settles into her palm". Watched on lavapipe: the twelfth watch-it's drone, re-directed, rises out of its crate, flies in to the Chief and hangs beside his head, and flies to the Captain's palm.
• Pockets (docs/design/m6-props.md, "Pockets"): a prop comes out of a pocket, or goes into one (place: "self" on a pick_up, hold or put_down, EpisodeIR 1.14), with no reach across the room, out of someone else's hand if it must. "The teacup is gone" finds its vanished state, and it comes out of the pocket seen. A use lifts a prop to the lips, the eyes or over the head (lift, 1.15), so a sip reaches the mouth. Watched on lavapipe: the thirteenth watch-it's teacup trick, re-directed, and the Captain's sip.
• Things on things: someone walks up to a piece of the set when no mark stands by it (a move to element:<id>, EpisodeIR 1.16); a thing set down keeps clear of what already stands there and goes beside the last thing put there, on the level parts of a top only (a sloped console's flat back, not its screen); and a lamp or a screen lights a prop or a 3D figure that comes up close no more than at 0.6 m. Watched on lavapipe: the fourteenth watch-it's kitten climbs out of Otto's pocket onto the helm console, and the Captain walks up and sets a saucer of milk down beside it.
• Effects: a show's own effects (FxInstance: particles in ten looks, glows, a flash), drawn by the engine as a pure function of time and aimed at someone's eyes, an element or a mark (an FX cue's toward, EpisodeIR 1.17), played from a character, a piece of the set or a prop, out of its mouth wherever it is (EpisodeIR 1.21); create_fx makes one, checked for emitters that emit nothing or that the engine cannot draw; the heuristic director plays "the kettle sprays steam in Otto's face" and "Confetti showers down over all three of them" from what sprays them. Watched on lavapipe: steam crossing the bridge to Otto, and a confetti cannon bursting over the crew.
• Lights and the dark: a scene's lights change mid-scene (a lighting cue, EpisodeIR 1.18): every light on the ship dies, and comes back on with a THUNK. A prop can give light: a flashlight's light anchor casts a spot that lights the deck it points at, its beam a see-through haze, switched off with its state. The heuristic director reads the lights going out and coming on. Watched on lavapipe: the nineteenth watch-it's search of the dark cargo hold by Otto's flashlight, and its lights coming back on.
• On a head: a prop can be worn, put on one's own head or flown or thrown onto someone else's, and taken off again (a place head, EpisodeIR 1.22; Timeline 1.12 Actor.worn); the engine stands it on the head as drawn. (implementation) Or perch on a shoulder (a place shoulder, EpisodeIR 1.26; Timeline 1.13 worn[].on), on the side it comes from; the heuristic director reads "settles on the Chief's shoulder". Or lie over the face of someone lying (Timeline 1.14 worn[].on face), there as they get up: a pillow dropped on the sleeping Chief.
• A sound from a prop: an sfx cue's source may be a prop (prop.<name>, EpisodeIR 1.23), panned from wherever the prop is as it starts; the heuristic director sounds the night watch's CLINK and BONK from the mugs that make them.
• Voice actors (docs/design/m6-recording.md): Studio's booth records an episode's lines from the microphone (on the desktop and in a browser), with a prompter, a count-in and a level meter; takes are kept with the show by hash, trimmed, gained, normalised or cleaned from the recording, and the one chosen plays in place of the synthetic voice, lip sync and timing following it (takes.* in the session protocol).
• Props on props: a prop can go in or on another, which carries it in a hand, through the air or on a set piece (a place prop.<name>, EpisodeIR 1.19; Timeline 1.10 rides): at one of its seats (a toaster's slots), else on its top, on the floor of a pan's bowl, stacked on what is there already. The heuristic director reads "a frying pan with a pancake in it", "puts the mug back on the tray" and "drops onto his plate". Watched on lavapipe: the twentieth watch-it's toast in its slot, the pancake flipped out of the pan and lying on the Chief's plate.
• Not yet: a card character is not lit by a lamp or a flashlight (only the set's key, fill and ambient tint it).
• Not yet: beams and shockwaves are not drawn.
• Not yet: creatures as characters. The character pattern makes only humans, so the fourteenth watch-it's kitten was a prop that flies; a creature that walks, sits and reacts needs its own rig.

M7 Re-direction

• A timeline component with tracks for shots, dialogue, camera, music and FX, hosted in Studio and in the editor's bottom dock.
• Chat edits become IR diffs, with undo and redo.
• Add: OpenTimelineIO export and caption editing.
• So far: edit_episode (move a cut, re-frame a shot, hold a pause, drop a shot, split a shot with a new cut, each compiled before it is proposed, with the running time and film grammar in the answer), the operations the timeline makes; reelwright export otio, and import otio (the import_otio tool), which brings an editor's trims back as those edits; the session methods the timeline is built on, episode.timeline and tools.call (docs/design/m7-redirection.md); and the timeline itself, in Studio's Timeline section and the editor's bottom panel: drag a cut or a line, re-frame or delete a shot, each a proposal drawn as a ghost until it is decided, with the still at the playhead. Caption editing: a long line's caption is cut into readable cards (two rows of 42 characters, broken at sentences, clauses, then words, timed by the take's words), and a person can re-break and nudge a line's caption from the timeline (set_caption); effects and music show their gain and take a new one from their menu (set_gain, and set_fade for music through chat). Watched against the real daemon: the cut into the Chief's reply dragged half a second later, approved, and undone byte for byte; then "Chief!" given a card of its own and the scanner ping turned down 6 dB, both approved and rendered (tools/timeline-watch.sh). From the watch-its: edit_episode can revise a proposal still waiting (change), and a revision or a re-direct supersedes the one it replaces, so no stale proposals pile up; set_mark re-blocks a scene; and set_camera can cross the axis on purpose, with a note saying why, or turn a framed shot round its subject (yawOffsetDeg). A sound can repeat (SfxCue.repeat), and the directors repeat one the action says goes on, or a hum by its nature. Titles and credits (docs/design/m7-titles.md): an opening title card and end credits in the show's style, given by both directors to a screenplay with a title page, edited with set_titles, and cut as clips of their own in the OpenTimelineIO export. More from the watch-its: edit_episode's set_delivery changes how a line is said (and voices it again), set_sound adds, changes, repeats or removes a sound, and set_mark can send someone up to a character; revise_prop changes a prop as revise_character does a character. From a Studio audit (2026-10-03): the person's own edits are applied as made and undone with Ctrl+Z (only the showrunner's wait as a ghost); Space plays the episode live with its sound (episode.playback); lines with no take are voiced from the timeline (episode.voice, Kokoro, free); a script editor writes and directs an episode with the heuristic director (screenplays.list/get); and Ctrl+K finds anything. The timeline is a precise editor: an inspector shows what a selected block is and every property an edit can change, someone's business and sounds are dragged along time or nudged a frame (snapping to cuts, the playhead and the lines), and set_timing re-times any cue against what it is timed from. Still to come: a cue's anchor chosen in the inspector, curves, camera keyframes, ripple, roll and slip, and transitions.

M8 Restyling

• "Restyle the whole show" re-derives every asset. Design transforms arrive as change sets with before/after model sheets, and a canon-drift report shows what moved.
• So far: the design (docs/design/m8-restyling.md); restyle_show re-derives the palettes of generated, unlocked characters for the new style in the same change set, never one edited by hand, and flags locked characters the new style's colors reject; the restyle preview shows every character before and after, and approving it approves what it showed; reelwright drift (the drift_report tool) draws every approved character again and reports who moved, how much and why, with difference sheets. Watched on lavapipe: restyled to Bright Modern with its preview, nothing had drifted; restyled back unseen, all four moved, each with its cause.

M9 Tier 2 generative adapters

• Starting candidates from the September 2026 survey, to be re-checked at build time:
  • Transparent images: OpenAI gpt-image-2.5, Ideogram.
  • Reference-consistent characters: FLUX.2 [klein] (Apache-2.0), Qwen-Image-Edit-2511.
  • Layered output: Qwen-Image-Layered, See-through.
  • Vectorizing: VTracer (MIT).
  • Rig-part segmentation: SAM 2 (Apache-2.0), BiRefNet.
  • 3D: TRELLIS.2 with UniRig (MIT).
  • Music: ACE-Step 1.5 (MIT), Stable Audio 3.0.
  • SFX: ElevenLabs SFX v2.
• Pipeline: post-processing, then asset QA, then frozen, content-addressed assets with full provenance.
• So far: the design (docs/design/m9-tier2.md); the asset store (assets/<sha256>.png with a provenance sidecar, validated: pinned by hash, intact, licensed); the pipeline for images (normalize to sRGB, snap to the palette when the style snaps, QA for palette compliance and a backdrop's aspect and size, deterministic freeze); reelwright asset import and import_asset, which propose the set change with the QA report and the wide view; painted backdrops, which the engine draws all the way around at their distance; and generate_image behind an ImageAdapter registry, waiting for a provider and its key; and paint_sky, which paints a sky panorama itself (planets, rings, suns, clouds, stars, far hills) for an exterior, with no provider. Watched on lavapipe: a procedural CC0 starfield imported as the Marigold bridge's backdrop snapped to its palette (99.1% compliant), and shows through the porthole in the wide view and in the Lighthouse.
• Groundwork: procedural sound effects already exist: a SoundRecipe of tones, note sequences and filtered noise, synthesized deterministically (create_sound). Generative SFX adapters add what a recipe cannot describe.

M10 Continuity, 3D, performance, docs

• Continuity log across episodes, fed back into the writers' room.
• So far: the design (docs/design/m10-continuity.md); record_continuity, which records an approved episode's facts and lasting changes, adds the gags and threads its outline served, and keeps the bible's books in the same change set; write_outline tells the writers' room what earlier episodes established; the show's memory (docs/design/m10-show-memory.md): a notebook of every episode written, remembered as each is directed (a free deterministic pass, then the model's), edited, pinned and locked by the person in Studio's Memory section, and read by every writer within a budget; the docs site at reelwright.diy/docs, generated from the repository; render farm chunking (render --farm), whose assembled cut is byte-identical to a local render.
• 3D character patterns: a card swap, per ADR-0004.
• So far (3D): the swap itself (docs/design/m10-3d-characters.md). A character on rig template biped_3d.v1 is drawn as a stylized 3D figure: lathed torso, capsule limbs, an ellipsoid head with its face, in its costume's colors, cel-shaded and inked in the style. It poses on the card's own skeleton and pose solver, so every posture, walk, gesture, look, float and held prop carries over, and staging, framing and gesture timing do not change. A show can mix figures and cards. Watched on lavapipe: Otto as a figure beside the 2D Chief in the Lighthouse and The Salvage Claim. Its mouth draws every Rhubarb shape: the upper teeth, the tongue, a rounded O and pucker, a band of teeth for F and V. Its model sheet draws the figure, not the card. Not yet: hand shapes, costume details, hair styles, smears.
• Render farm chunking, and a docs site.
• So far (docs): the docs site at reelwright.diy/docs, generated by tools/site/docs.ts from these documents (architecture, roadmap, design notes, ADRs, getting started), with reference pages generated from the code: the CLI's help, every showrunner tool and its input, every document kind and where it lives. CI fails when it is stale.

M11 Release: an installable Studio for macOS, Windows and Linux

The owner's order (2026-10-02): an installable, versioned, supported edition comes first, and the web version after it. Reelwright Studio (ADR-0011) is that edition. (So far) Release 0.1.0 is out for Linux (2026-10-04): an AppImage and a .tar.xz on reelwright.diy/download, each smoke-tested as downloaded. Windows (an installer and a .zip) and macOS (one universal .dmg) now build from the same commit: a v* tag runs .github/workflows/release.yml, which builds every package and smoke-tests each on its own platform; they are unsigned until the owner's certificates are in. A first-time user can try the demo or make a show of their own from the Marigold kit (New show), then its cast, sets and episodes with no API key (New character, New set, New episode, Direct, Voice lines), and play and render them: tools/script-watch.sh runs that whole path against the real daemon.

• Export: Godot export presets for Studio on all three platforms, with the export templates pinned in tools/toolchain.json.
• The core, bundled: reelwright as a single-file executable (Node SEA) per platform, which Studio starts and supervises, so users install no Node, Godot or Python. The local voices, lip sync and ffmpeg it needs come with it or are fetched on first run, checksummed.
• Installers: a .dmg for macOS (universal), an installer for Windows, and an AppImage and a .tar.gz for Linux. Each is signed: Apple notarization and a Windows code-signing certificate are owner actions.
• Versions: semantic versions shared by Studio, the core and the document schemas. A release says which schema versions it reads and writes, migrates older shows, and has a changelog entry. An update check tells users when a newer release is out.
• Support: a supported-platform matrix, a "Report a problem" bundle (logs, versions, the show's hashes, no API keys), and a release checklist.
• CI: every tag builds, signs and smoke-tests each platform's package (launch, start the core, open the Marigold, render one still), and publishes it with its checksums on reelwright.diy.

M12 Reelwright as a service: the web version

• Studio as a Godot web export on reelwright.diy, talking to the core as a hosted service over the same session protocol, since browsers cannot start processes (ADR-0011).
• Accounts, a per-show workspace, render queues on the farm (render --farm), and the same change sets, approvals and versions as the desktop edition.
• Comes after M11: the desktop edition settles the protocol, the versions and the support story the service will share.
• So far: the service itself, reelwright host at reelwright.diy/app (docs/design/m12-web-service.md): invited accounts signed in by emailed code, a workspace of shows each, a daemon per show, the web export of Studio, and Claude on each person's own key with a monthly cap. Sharing a show with other accounts (docs/design/m12-sharing.md): owners, editors and viewers, one daemon per show for everyone in it, the service naming who is on each socket, and each person's model calls paid with their own key. In Studio, "Shared with you" in the show menu, People… (the menu, the palette and the show's settings), a viewer's View only with every writing control gone, the initials of the others in the show, and someone removed told so and taken to their own show; proved live on a real host (an editor's edit seen by the owner, a viewer refused, a removal cutting the socket). An admin console for the service's owners (/admin, ADMIN_EMAILS only): the service at a glance, every account and show with what it uses, the daemons and renders running, and settings that apply at once (sign-ups, maintenance, a banner, feature switches, spending caps and a ceiling, quotas, daemon and sign-in limits), every action audited. Claude on a person's own plan (docs/design/m12-remote-mcp.md): the service's own MCP endpoint at reelwright.diy/app/mcp, which Claude Code (claude mcp add --transport http) and the Claude apps' custom connectors sign in to through an OAuth 2.1 server (PKCE, dynamic registration, rotating refresh tokens, revocation) or a personal token, working on the person's shows through each show's daemon with their role, its proposals appearing in their Studio for review. Studio's own chat on the web on a person's plan, opt-in, through the bridge on their computer (reelwright claude bridge, docs/design/m12-plan-bridge.md): the service hands their turns to it and streams the chat's events back.

M13 Working on a show together

• Sharing as a whole way of working, the same in the installed Studio and on reelwright.diy/app (docs/design/m13-shared-shows.md): four roles (owner, editor, reviewer, viewer), invitations people accept, requests from a link, comments pinned to the work, presence, merged script saves, notifications, and the installed Studio signed in to the service, putting a show on it and taking a copy away.
• Three phases: the service; the daemon (comments, three-way merge, presence, live change notes); Studio, both editions.
• So far: phase 1 on the service. The four roles, M12's shares migrated; invitations (hashed single-use tokens, 14 days, a note, resend, revoke, decline, accepted only by the invited address, an account made on accepting when the service lets invitations bring people), "Editors can invite", requests for access with a note, leaving, transfer (offer and accept; the folder moves and old keys still find it) and deleting; each person's notifications, their email at once, in a daily digest or not at all, and a signed link in every email that stops its kind; device tokens for the installed Studio (hashed, listed in the person's sessions, revocable, never the admin console); a show put on the service as a checked, checksummed pack of its history and loose files (host pack), and downloaded as a Show Pack. Proved live with tools/web/collab-check.ts on a real host. The service owner's switches are the admin console's settings (sharing on in Features; invitations bringing new people, link requests and people per show in Sharing), and the console lists and revokes each person's installed Studios. Phase 2 in the daemon: roles held by method class (reviewers comment, viewers read), comments pinned to a script's lines, a frame, a document or the show, script saves merged line by line with a conflict where both changed the same lines, everyone's place and colour, and who changed what with each change. The service hears the daemon: a mention or a reply in a comment, and a render someone started finishing, reach that person's notifications. History in both editions (the product audit's #20): named versions of the whole show, saying who saved each; any two compared, a document field by field; the whole show or one document restored as one change Ctrl+Z takes back; restore points taken before a restyle, an import, a removal or a bulk edit; and Ctrl+Z that outlasts a restart. Viewers browse, owners and editors restore, and the showrunner's restore is a proposal. The review loop in both editions (the product audit's #16, docs/design/review-loop.md):
  • every render kept as a numbered version of its episode, with what changed since the one before (the script, the director's scenes, the documents), and one approved;
  • Watch a player built on a review copy read by byte range: frame-accurate, J, K and L, timecode, In and Out looped, speeds, meters, fullscreen;
  • two versions compared side by side or as a wipe;
  • notes on a frame or a range with marks drawn on it, threaded, mentioned, resolved, or sent to the showrunner;
  • a version shared with a reviewer, who lands on it;
  • the notes exported as a CSV with thumbnails or a PDF.

M14 Immersive editors

• World, Cast and Sets as live views of the show in the engine, the same in the installed Studio and on the web, instead of forms with one still on top (docs/design/m14-immersive-editors.md): a set explorer to orbit, fly and look through any camera setup, then move marks, elements, setups and lights with gizmos; a character studio with a live turntable, expressions, poses, wardrobe and props in hand; previs of the episode at the playhead from any angle; a look book that shows a style on the show's own cast and sets; voice auditions; the bible as a story map; and comment pins in 3D.
• Eight phases, in order of what a showrunner gets from each: set explorer, character studio, set editing, previs, look book and style lab, voice audition, story map, working together in 3D. Each edit goes through the tools the showrunner uses, applied as made and undone with Ctrl+Z, and each editor tells the chat what is in view.
• So far: the design, with today's views and the timings that set its budgets; and phase 1, the set explorer, in both editions: every set live in 3D from scenes.get, to orbit, fly and look through each camera setup (the same frame its set view draws, byte for byte), with overlays for marks, walkways, entrances, cameras with their frustums and lights, any of its lighting presets, the cast standing on its marks, and an inspector that edits any field by hand through revise_set, undone with Ctrl+Z. Phase 2, the character studio, in both editions: every character live from scenes.get, on a turntable that keeps each 15° step it draws, the model sheet's turnaround pixel for pixel with the approved sheet laid over it as canon, expressions and mouth shapes on sliders that save on release, postures, gestures and walks played live, a wardrobe with a try-on strip and the palette, props held as an episode holds them, and variations kept back (tools.call keep) to pick in place. Phase 3, editing a set in 3D, in both editions: marks, pieces of the set, cameras, entrances, walkway points and the key light moved and turned by their handles or by G and R, on a 5 cm grid and 15° steps (Ctrl for none), with a number typed for an exact move, several at once with Shift and Ctrl; the view saved as a new setup; a proposal drawn as a ghost to accept or reject in place; walls up, cut away or down; each set opened where it was left. A move builds only what it moved (RwSetBuilder.place_element and rebuild_element), and an edit raced by someone else's change is refused and said so, or sent again where its thing went (Edit.was). The core of phase 5, ahead of its turn because a show's look is part of making the show (#224): New show starts a style of the show's own from words, pictures, a blank or a built-in style, and the style lab, in both editions, draws it live on the show's cast and set or on stand-ins, with a before and after split, a control for every field of the StyleSpec saved through revise_style, try-ons kept back, and four directions (propose_styles) to pick or blend (blend_styles). Left of phase 5: the look book (each set, hero frames, two styles split on an episode) and Apply-as-proposal on the active style. Phase 4, previs, in both editions: the episode at the playhead in 3D over the timeline, drawn by its own player, through the shot's camera (the timeline's frame to the bit), the shot's camera taken over and moved, or from a free camera; "Use this view for this shot" as one change that writes the set and the episode (set_camera newSetup), the compiled frame the piloted one; someone dragged to a mark, beside a piece of the set or onto a new mark (newMark), the stage's own edit; the timeline and 3D in step both ways, and a showrunner's proposal drawn as a ghost; then what it left: a facing knob, the shot's camera dragged round its subject, walls cut away in a free view, props placed from a shelf, and a pilot that carries on across a cut. With it, adding on the timeline (the product audit's finding 7): A and a letter, a right-click on a row, the corner's "+" or the library adds a sound, music, an effect, a gesture, a face, a look, a posture, a lighting change, a camera move, a shot, a title card or a line (add_line, written into the screenplay too) at the playhead. And camera keys (the product audit's finding 12): a framed shot's camera through several framings keyed on the camera strip, lenses that zoom evenly between keys, focus on someone or at a distance with a rack focus between keys (depth of field drawn alike on desktop and in the browser), and handheld per shot (EpisodeIR 1.50, set_camera_key). Next: the look book (the rest of phase 5), then voice audition (phase 6).

M15 Reelwright Runner: the heavy work on your own machine

• The web Studio from anywhere, with the heavy work done on a machine of the person's own (docs/design/m15-runners.md): reelwright runner, paired once with a code from Studio, connects outward to the service and says what its machine can do; the service sends it the person's renders and voicing of shows on the service (their files moved both ways as content-addressed chunks that resume), or relays a session to a show on the runner's own disk, whose files never rest on the service. The plan bridge becomes one capability of it.
• Six phases: the runner registered and seen (with the plan bridge folded in); jobs for service shows; shows on the runner's disk; stills and previews; the director's and memory's runs on the plan; a farm of the person's own machines.
• So far: all six phases. reelwright runner (pairing, its own token, the capability report, --accept, --shows, --token-stdin --json for the installed Studio), the service's hub (routes per person, show and job; fallback and queueing; owners' consent for shared shows; signed jobs; scoped chunks; results landing in the show; the chat's per-show credential), Your computers in both editions and the installed Studio's one switch, Episodes saying where a render runs, the console's Runners page with each person's own, and the owners' switch for runners on the whole service. Proved live with tools/web/runner-check.ts: a render sent from the web export in Chromium to a headless runner on the dev box, played in the browser, the runner stopped and the next render falling back to the service, and a show on the box opened and rendered there; and with tools/web/studio-runner-check.ts: the installed Studio, signed in, its switch turned on, rendering the web export's preview. Phase 4: previews of service shows drawn on the person's runner (model sheets, set views, swatches, stills, storyboards, prop and effect sheets, the restyle's before and after, and so the canon a proposal's model sheet becomes), routed as renders are, batched, their files back in the show's preview folder, where it ran under each picture, the service drawing them when the runner is off or fails. Phase 5: the model director's and memory's runs on the person's Claude plan, Claude Code on their runner answering the director's tasks through the run's own two tools with the per-show credential, the results proposals, falling back to their API key or the heuristic. Phase 6: a render spread over the person's runners, the lead drawing its share and the others drawing the rest from each chunk's engine job sent by content, shares by what each machine draws at once, the GPU leading and a machine in software helping only another in software, a part left by a machine that stops drawn by the lead; then its parts sent back encoded as segments and joined with the picture copied, a late part drawn by the lead too, helpers chosen by their measured uplink, and a direction on the plan naming the person's Claude Code in its provenance. Proved live with tools/web/runner-work-check.ts.

M16 Any character

• Characters of any kind, not only cartoon humans (docs/design/m16-any-character.md): a body plan on the character (CharacterInstance 1.1: a quadruped, a serpent, a blob or ghost, a robot on wheels, treads or a hover pad, a talking object; birds and insects next), each with its own rig template, locomotion, postures and gesture library whose gestures stand in for a person's, while faces, expressions and lip sync are shared by every plan and staging goes through metrics that know the plan. Made from words with create_character ("a grumpy three-eyed space slug who runs the cargo bay"), with no model or with one, or from a pattern per kind; New character offers any kind in both editions, and the character studio shows them.
• Three phases: the five plans in 2D with everything around them; birds, insects, carrying in mouths and claws, voice effects; plans in 3D, centaurs and riding.
• So far: phase 1. CharacterInstance 1.1 and its checks; the five plans drawn in 2D with shared faces, every mouth's lip sync, gaits, postures and gesture libraries that stand in for all of a person's gestures; metrics per plan held to testdata/plans.json on both sides; each kind's pace; create_character from words; a starter pattern per kind; the director's creature verbs, kind nouns and director.no_hands; New character for any kind in Studio and the cast list's kind badges (tools/crew-watch.sh). Phase 2, most of it: CharacterInstance 1.2's birds (flying across a room, perching, pecking, gesturing with their wings) and insects and spiders (scuttling on six or eight legs); carrying in a mouth or a beak (Timeline 1.23); creature voices shifted in pitch and put through an effect; "it" for creatures; looks that follow someone still on their way; stalk eyes framed; a small creature followed in from the door; a snake's curved neck; kind icons. Phase 3, sea life (CharacterInstance 1.5): fish, sharks, whales, dolphins, seahorses and sea turtles that swim; octopuses, squid and jellyfish; crabs that scuttle sideways and lobsters; claws and tentacles that hold and gesture; garments read with their own colours; the audit's crab, octopus and whale made from its own words. Next in phase 2: creature postures (beg, pounce, coil to strike), ears and tails by emotion everywhere, a robot's screen face, smears and boil on plans, perching up on things, sightlines and footprints, giants in small sets.