Contents

Re-directing an episode from a moment

Status: designed 2026-10-15; slices 1 to 9 built (see "As built" and "Next steps"). EpisodeIR 1.66, session protocol 1.20.

The owner's ask, 2026-10-15: "does the feature exist to "re-direct" an episode? Like think deeply about how a user goes in to an episode at a given point and makes changes and implement this full feature set."

Someone watching their episode stops at a moment (a time, a shot or a line) and changes what is there: a line's words or how it is said, a beat of action ("she sits instead of standing"), where someone stands or goes, the camera (its size, its angle, a cut), or a performance (a gesture, a look, a feeling). Then the director makes that again, from that point on or over only that stretch. Everything they approved or fixed by hand anywhere else stays exactly as it was. They see only the changed stretch, played at once, against what was there before, and approve it, reject it or undo it. It works on the desktop and on the web, on a laptop and on a phone, in Spanish, and through the person's own Claude over MCP ("re-direct sc02 from Nell's line, make her angrier"), with no API key.

As built

Where the build differs from the design below, or has not reached it yet:

• The sheet is a dialog (RwRedirectSheet), on a phone the window's width as every dialog is, not a panel in the inspector's place. Its script field shows the stretch's screenplay lines; in the script editor it shows none and sends the editor's own text. There are no chips: the note's words say what the heuristic director reads instead. A new re-direction replaces one still waiting for the episode, as Direct does; "On top of it" is not offered.
• Who directs is the show's director, as Direct has it (Show settings). With Claude chosen and a daemon at 1.17 or later, the sheet asks the person's own Claude (waitForClaude), routed as Direct is: Claude Code on their plan, then a Claude connected to the show, then a runner or a key, else it waits for one. Where it was asked (the timeline, the review's Re-direction tab, the script editor) a bar says what it waits for (RwClaudeWait): the Claude connected now by name, then that it is re-directing it, or that it stopped with nothing proposed; Copy what to say, Re-direct without Claude, and Re-direct with your API key when a key could. What Claude proposes comes as a change: the timeline draws it as the ghost, the tab shows it, the script editor says to compare it on the timeline. A daemon before 1.17 with Claude chosen and no model: the heuristic director does it, and says so.
• Over MCP the waiting ask is the whole re-direction (from, to, the note, what is released), and studio_context says it as one ("re-direct ep.salvage_claim from sc02's line l03 through sc02's line l03 (its end) …"). Taken, the run gives Claude only the stretch's scenes, each perform and cover task with the stretch's brief, and splices what it sends as any re-direction. studio_context gives the episode, frame, shot and selection Studio is at; the timeline page's brief says to re-direct from {frame} or {scene, line}. The chat panel needs nothing of its own: the same tool.
• The timeline's ways in: R, the header's Re-direct…, a shot's menu ("Re-direct from this shot…"), and the inspector's "Re-direct from here…" on any block; In to Out is one of the choices.
• The compare is the ghost bar's: where it changes (episode.compare), Play it, Before / after, Voice its lines, Approve, Reject, and Review for the proposal view. Side by side, the ruler's band and the storyboard before over after are not built.
• The review finds its frame in the episode now by the words its render's captions say there (episode.span version, byWords), not through the render's inputs. Its Re-direction tab plays the stretch live, Before / after, voices, approves, rejects and undoes.
• The script editor re-directs from the caret's line (EpisodeMoment.scriptLine). "Direct what changed" is not built: an episode does not keep the text it was directed from, so what changed since cannot be told for certain once the script is saved.
• The model director is told the stretch (StretchBrief: its words, the scene as directed now, what is kept) and sends whole-scene drafts as before; only the stretch is taken from them. There are no span drafts, and a broken join is not sent back as a repair yet.
• A join that would leave a shot shorter than the style's shortest is not made.
• A note without Claude (slice 9): its words for how a line is said go into the stretch's script as the first speaker's parenthetical (director/note.ts), only where the script still says the line at its place, and only when the person left the stretch's script as it was; a (beat) above stays as it is. The heuristic director's parenthetical words are English, so a note in another language is not read: it is refused like any re-direction that would make the stretch as it is (director.nothing_changed), with what to do.
• Words: a stretch is said by the scene's number and its lines' speakers and first words ("scene 1: Barnaby Culpepper's “Lighthouses warn you away from things,…”", "scene 2 from … to the end of the scene"), a shot by its place in the cut, a kept change by whose and what kind it is: no id in what a person reads (check-plain-words). The model director is told the stretch by its ids (stretchIds), since those are what it answers with.

Next steps

The gaps left, in the order a person meets them:

1. A note without Claude is a dead end (slice 9, below). The sheet offers a note to everyone, and the heuristic director, the one a person has before connecting Claude, reads none. They stop at a line, write "angrier", press Re-direct, and get the store's "nothing to change: the show already has all of this", with no way on. It is the first re-direction most people try.
2. Direct what changed, from the script editor: after editing several lines, re-direct only the stretches whose words changed. The episode keeps each line's words and parenthetical, so changed dialogue can be found against the script; changed action paragraphs cannot (the episode does not keep their text). Worth a slice once the first is in; until then, Re-direct from here at each changed line does it.
3. Side by side, the ruler's band and the storyboard before over after in the compare; span drafts and joins sent back as repairs for the model director; "On top of it" for a waiting re-direction. Each is a refinement of something that works; none blocks a person.

Slice 9: the heuristic director takes a note

• A note's words that say how a line is said (a feeling, loudness or pace, by the heuristic director's own parenthetical words: "angrier", "quieter", "slower", "happier") go into the stretch's script as a parenthetical on the lines of the person whose line the stretch starts at, merged with one that is there ("(muffled, angrier)"), when the person did not change the stretch's script themselves. The proposal carries the script change, so the script and the episode agree, and the summary says what was written where.
• A note with none of those words, and nothing changed in the script, is refused before anything is directed, in plain words: the heuristic director reads the script, so write it there, or ask Claude (director.nothing_changed). So is any re-direction that comes out the same as the episode is, instead of the store's "nothing to change".
• The sheet says so under the note for the heuristic director. Claude reads the note as before.
• Proof: core tests for the note written in, the speaker's lines only, the refusal and the same-as-before refusal, each with a mutant; the web check's phone leg re-directs with a note alone and finds the parenthetical in the script on the service.

What exists, and what is missing

The experience, screen by screen

1. Watching, and stopping at a moment

• The timeline (desktop and web, a laptop or wider). The person plays the episode (Space) and stops (K). "Re-direct…" is on the transport bar, under R, and in the menus of a line, a shot and any business: "Re-direct from this line…", "Re-direct this line…", "Re-cut this shot…". With In and Out marked (I, O), "Re-direct In to Out…". The inspector of a line, a shot or an action has the same button. Each opens the sheet at that moment.
• The Review view (every edition and size, the phone's way in). Watching a render, the person pauses on a frame. "Re-direct from here" sits beside "Note" on the player's bar. The frame is the version's own: the core maps it through that version's inputs to the scene and line it shows, and to the same scene and line in the episode as it is now (episode.span with version). An out of date version says so in the sheet ("This version is older than the episode: re-directing from the same line, now at 0:44").
• The script editor. With the caret on a line or an action, "Re-direct from here" in the line's menu and the toolbar. After editing a script whose episode exists, Direct offers "Direct what changed" (the stretches whose words changed, the rest kept) beside "Direct it all again". "Direct what changed" is the default.
• The chat, and any Claude connected to the show. "Re-direct from here, make her angrier" works from the place Studio is at (studio_context gives the moment, below).

2. The sheet

The sheet is a panel in the inspector's place on a laptop, and a sheet over the work on a phone, one column. From the top:

1. Where. "From Nell's line “You promised!” · sc02 · 0:42", with the still of that frame. A moment in the middle of a line or a pause starts at the line's boundary (below), and the sheet says where that is.
2. How far. One choice: "This line" (or "This beat" for an action, "This shot" for a camera re-cut), "To the end of the scene", "To the end of the episode", and "In to Out" when a range is marked. Under it the stretch in words and times: "l05 to l07 · 0:40 to 0:51 (11 s)". The timeline shades the stretch as the choice changes.
3. What changes.
   • The script of the stretch, as it reads on the page: its lines (their words and their parentheticals), its action and any shot line, editable in place. A change here is written into the screenplay with the re-direction, one change, one undo.
   • A note: "What should be different?" ("angrier", "she sits instead of standing", "closer on Nell, and cut to Otto on ‘promised’").
   • Only the camera: a switch for a re-cut. The performance stays as it is, frame for frame; only the shots of the stretch are made again.
4. Your changes here. What the person (or Claude, with their approval) changed by hand in the stretch since it was directed, one row each in plain words: "Nell's delivery of l05 (calm)", "sh040's camera (a close-up)", "The mouth drawn over “promised”". Each is kept unless its box is cleared. None: the row is not shown.
5. Who directs it. As Direct has it (director-over-mcp.md): "Claude (claude.ai) will direct it", "Claude Code on your plan", "Your API key", or "Without Claude (free)". Without Claude the note box says what the heuristic director reads instead: a parenthetical for how a line is said, an action line for what someone does, a shot line (CLOSE ON NELL) for the camera; three chips put each in the script at the moment.
6. Re-direct (Enter) and Cancel (Esc). When a re-direction of this episode is already waiting, the sheet says so and offers "On top of it" (the default: both in one proposal) or "Instead of it".

3. While it directs

The stretch stays shaded on the timeline with "Re-directing l05 to l07…" and its progress (staging, covering, a repair; "Claude (claude.ai) is directing this" when Claude has taken it). The person keeps working: an edit outside the stretch made meanwhile is kept in the proposal (Rebase, below). An edit inside it says that the re-direction will make that stretch again.

4. The compare

When the proposal comes (change.event), the timeline draws its ghost over the stretch only, and the ghost bar becomes the compare bar:

"Re-directed from Nell's line to the end of the scene · by Claude · 12.4 s, was 11.0 s" [Play it] [Before | After] [Side by side] [Approve] [Reject] [Details]

• Play it plays the stretch with a second before and after it, so both joins are seen, round and round, live, with its sound: no render. Lines the proposal says otherwise are voiced first ("Voicing 2 lines…": Kokoro, free, into the take store; episode.voice with change).
• Before | After (\) switches between the episode as it is and the proposal at the same moment of the stretch: the same line and word where both have it, else the same share of the stretch.
• Side by side plays both at once in sync, on a window wide enough for two pictures.
• Details opens the proposal view: the usual fields, and the storyboard panels of the stretch's shots, before over after.
• The ruler shows the stretch's band in both lengths, and the rest of the timeline is not ghosted at all, since nothing else changed.

5. Deciding

Approve applies it: the toast says "Re-direction applied" with Undo, and Ctrl+Z undoes it as any change. Reject drops it. A re-direction Claude made is approved by the person, never by Claude (the decide tools' rule). History lists it as "Re-direct sc02 from l05".

6. On a phone

Review, Re-direct from here, the sheet over the work, Re-direct. The Review view then holds a "Re-direction" card in its notes column's place: the progress, then one live player of the stretch with Before | After under it, and Approve, Reject and Undo, each a finger's target. Side by side is not offered. The script of the stretch is editable in the sheet, so a word can be changed on a phone too.

7. In Spanish

Every word Studio adds goes through RwLang with its Spanish in the catalog. What the core says about a moment and a stretch ("From Nell's line “You promised!”", "Nell keeps the mug now, so the rest of the scene is re-directed too") is a Saying template beside the English, as Studio's other core sentences are (session protocol 1.8), and the person's own names stay as written. A note may be written in Spanish: Claude reads it as written.

8. Through Claude

A connected Claude re-directs with the same tool and the same inputs as the sheet (direct_episode with from, to and note), so the result is the same proposal, compared and decided in Studio. "Re-direct from here" in chat or in Claude reads the moment from studio_context.

What "from here" means

Moments and boundaries

A scene is the screenplay's elements in order: its lines (l01, l02…) and its action paragraphs (a01…). Re-direction starts and ends on boundaries: where a line starts or ends, and the scene's start and end. A line's stretch runs from the end of the line before it (the scene's start for the first) to its own end, so it holds the pause before the line, the business between the two lines and the line itself. An action's stretch runs from the end of the line before it to the start of the line after it. Boundaries are read off the episode as compiled, its cues being kept in time order.

A moment is given as one of:

The end is given the same way and taken to the boundary at or after it, or as "the scene" or "the episode". With no end, a moment re-directs to the end of the episode ("from here on").

Frozen before the point

Everything before the point is not touched. In the IR: every earlier scene byte for byte, and in the point's scene its heading, set, lighting, opening blocking, axis, props, places, every cue that starts before the point and every shot whose cut is before it. Cues that start before the point and run on past it (a walk under way, a held gesture, music) run on as they were. A cue before the point timed from one at or after it (a turn timed with a line's word, before the line) is timed again from the frozen part, at the same frame, so it cannot move.

In the picture: every frame before the point is the same frame. The compiler solves a shot's framing at its cut, so shortening the shot playing at the point does not change it; a camera move that ran over that shot's whole length keeps the length it had (its own durationSec). The scene's axis, when it was inferred, is written into the scene, so a stretch cannot turn the line the frozen shots keep to.

The stretch

The stretch is what the director makes of it now: the script as it reads (with the sheet's changes), the note, and the scene as it stands at the point. Its cues are the new direction's cues that start inside it. Its lines keep their ids; a new cue takes a free id in the scene, as a paste does. A line whose words are unchanged keeps its recorded take, its drawn mouths and its sung settings; one whose words changed is voiced again.

The director continues from where everyone is at the point. Blocking is written as destinations (a walk goes to a mark, a piece of the set or someone), so a walk in the stretch starts from where the frozen part left them. What cannot play from there (putting down a mug nobody picked up, a walk off by someone already gone) is a compile error in the stretch: the model director repairs it; the heuristic director's cue is dropped and the proposal says which.

After the stretch: what may move

With "To the end of the scene" or "of the episode", there is no after. With a stretch that ends inside a scene, everything after it is kept: every later scene byte for byte, and in this scene every cue and every cut after the stretch, with what it says unchanged. It may only:

• move in time, by however much longer or shorter the stretch now runs: what follows is timed from lines, so it follows them; a cue placed at a time in the scene (atSec) moves by the same amount;
• be timed from the stretch's last line instead of a cue the stretch no longer has, at the same distance it had;
• change its line ids, when the stretch has a line more or fewer (l06 becomes l07): every reference to it moves with it (timings, cuts, captions, markers, takes, mouths);
• play from where the stretch leaves people: someone standing elsewhere at the stretch's end walks to their next mark from there.

Continuity is checked at the end of the stretch: who is on stage, what each holds and where, and whether what is kept after it compiles clean. When someone's presence or what they hold differs, or what follows does not compile, the stretch reaches to the end of the scene instead, and the proposal says why before it is approved: "Nell keeps the mug now, so the rest of the scene is re-directed too." Where only someone's place or posture differs, what follows plays on from there, and the proposal says that too ("Nell is sitting after it: what follows plays from there").

Cuts at the joins

At the point the frozen shot plays on until the stretch's first shot cuts in. When the director's shot at the point is that same camera, nothing cuts there, and the frozen shot plays on to the director's next cut. At the end of a stretch, the shot that was playing there before cuts in again (it starts at the end of the stretch), unless the stretch's last shot is the same camera. A join that would leave a shot shorter than the style's shortest (camera.cutting.minShotSec) is not made: the shot beside it plays on to the next cut instead. Film grammar then checks both joins like any cut, and the model director repairs a broken one.

Only the camera

A re-cut of a stretch (recut with a span) keeps the whole performance frame for frame and makes only the shots whose cuts are in the stretch again, its ends at the cuts. Nothing can break continuity, so the stretch never reaches further.

Several stretches at once

"Direct what changed" compares the script with the episode scene by scene and line by line (the words, speakers and order sceneMatches already compares) and re-directs, in each scene that differs, the stretch from the first element that changed to the last one. Scenes that did not change are kept byte for byte. A scene added, removed, moved or given another place is directed whole.

Cases

• The point at a scene's start: the opening blocking and the scene's props are the stretch's.
• An intercut or a montage: its places share one performance, so a stretch inside it widens to the whole scene, and the sheet says so.
• A title, a lower third or a marker in the stretch is a cue like any other; a marker kept after the stretch stays on its word.
• Nothing changed: the heuristic director with no change to the script makes the same of it; the proposal is not made, and the answer says so, with what to do (write it into the script, or ask Claude).

Keeping what the person approved and fixed

• Outside the stretch, by construction (above).
• Inside it, the person's changes are known from the episode itself. Every change edit_episode makes (the timeline, the stage, previs, the inspector, and Claude's edits once approved) marks what it changed on its scene: Scene.edited lists the cues, shots and opening places changed by hand since the scene was directed (EpisodeIR 1.66). The director's own passes never mark anything; a fresh direction of a scene starts with no marks; what is kept keeps its mark.
• Re-directing keeps what is marked. A marked cue in the stretch is kept as it is, timed as it was, and the director's new cues of the same kind for the same person on the same line (or within half a second, for one placed on no line) are left out; a marked line keeps its delivery when its words are unchanged; a marked shot keeps its camera and its cuts, the new shots fitting round it. One whose anchor is gone (a gesture on a word no longer said) is dropped, and the proposal says which, as a drawn mouth is today. The sheet's "Your changes here" lists them; a cleared box sends the cue in release, and it is directed again. Directing a whole scene or episode keeps them in the same way (keep: false directs everything afresh).
• Drawn mouths, keyed poses, sung lines and recorded takes are kept as they are today.
• Locks. A locked subtree of the episode is never changed: a stretch that would change one is refused when it is asked for, naming the lock, as any proposal is.
• Rebase. An edit applied to the episode while it directs would make the proposal stale. When the stretch and its joins are as they were, the stretch is put into the episode as it is now instead, so the edit is kept; otherwise the answer says the stretch was changed meanwhile.
• A waiting re-direction. "On top of it" re-directs the proposal's own version of the episode and supersedes it (change, as edit_episode has), so both stretches are one proposal.

The span preview and the compare

• episode.compare {episode, change} (session protocol 1.20) says where a proposal's episode differs from the episode: per scene, the first and last frames that differ in each, from the two IRs (the longest common start and end of each scene's cues and shots) and their compiles. It works for any proposal of an episode, an edit as much as a re-direction, and its words name the stretch ("sc02 from l05 to l07").
• episode.voice takes change and lines: it voices a proposal's lines into the take store, where every compile looks, so playing the proposal plays its voices, and nothing in the show is written.
• Studio plays both with two RwLivePlayers over episode.playback (one with change), each between its stretch's frames with a second either side. The switch maps a moment through the lines both have. Nothing is rendered; on the web it runs in the page.
• The proposal view's storyboard panels (previews.get panels of the change) draw the stretch's shots, under the same shots of the episode as it is.

Claude

The model director over a stretch

A stretch is directed with two drafts of its own (director.schema.json):

• SpanPerformanceDraft: the deliveries of the stretch's lines and its cues, in the order they happen. The request shows the whole scene: the skeleton, the scene as directed now (its performance as a draft, the stretch marked), where everyone is at the point (snapshotsOf), what is kept by hand in it, and the note. "Change only what happens from the end of l04 to the end of l07. Everything before and after is kept as it is."
• SpanCoverageDraft: the stretch's shots, the first cutting in at the point; the request shows the frozen shot before it and the kept one after it.

The core puts the scene together from the frozen part, the drafts and what is kept after (assemblePerformance over the whole scene), and judges it as it judges a scene: schema, names, assembly, validation, a provisional compile, film grammar. A problem in the stretch, at a join, or in what is kept after it because of the stretch goes back as a repair, its pointer in the draft. After three rounds the stretch falls back to the heuristic director's, and says so. Whatever the model sends, nothing outside the stretch is taken from it.

Over MCP, with no key

Over MCP the calling Claude is the model (director-over-mcp.md): direct_episode with a span answers at once with the stretch's perform task, plan_submit answers it, and the last answer names the proposal, waiting in Studio, its provenance "Claude, through claude-ai". Nothing in Reelwright reads a key or calls a model.

• The tool: direct_episode with episode, from ({scene, line}, {scene, cue}, {scene, shot} or {frame}), to (the same, or "scene", or "episode"), note, recut, fountain (the script with its changes), release, change. Its description gives the example: re-direct sc02 from Nell's line, angrier, to the end of the scene, is {"episode": "ep.salvage_claim", "from": {"scene": "sc02", "line": "l05"}, "to": "scene", "note": "angrier"}.
• The moment: studio_context at the timeline or a review gives the episode, the frame, the shot, the line there in words, and the from that names it, so "from here" is one call.
• Studio's sheet routes as Direct does: Claude Code on the plan first, then a Claude connected now (the waiting ask carries the span and the note: "Re-direct the episode waiting in Reelwright"), then a runner or a key, else it waits, with Re-direct without Claude beside it.
• Deciding stays the person's: Claude names the proposal and says to compare it in Studio; it approves only when the person asks it to, by the decide tools' rule.
• The chat panel (being rebuilt around the connected Claude by showrunner) sends "Re-direct from here" with the place's context and needs nothing of its own: the same tool, the same proposal.

Without Claude

The heuristic director re-directs a stretch from the script, free: a changed word, a parenthetical, an action line or a shot line. It reads no note; the sheet says so, and the answer to a re-direction with nothing changed says to write it into the script or to ask Claude.

Schema and protocol

• EpisodeIR 1.66: Scene.edited {cues?, shots?, blocking?}: ids of the cues and shots, and the characters whose opening place, changed by hand since the scene was directed. It changes nothing that plays; the Timeline is as it was.
• Timeline: no change (1.40 is not needed).
• Tools (tools.schema.json), DirectEpisodeInput: from, to (a Moment, or "scene" or "episode"), only: "changed" (Direct what changed), keep (default true), release (ids of marked cues and shots to direct again), change (a waiting proposal to build on). recut with a span re-cuts the stretch. The result's data says the stretch, as it was and as it is, in frames and words, and anything that widened it.
• Director drafts (director.schema.json): SpanPerformanceDraft, SpanCoverageDraft.
• Session protocol 1.20:
  • episode.span {episode, at, to?, version?, change?} (read): the moment in words (and its Saying), the stretch each choice of the sheet would make (frames, words), whether it widens and why, and the changes by hand in each, so Studio holds no span logic;
  • episode.compare {episode, change} (read), above;
  • episode.voice takes change and lines;
  • with director-over-mcp-2's asks (1.17), a waiting ask carries its span and note, and session.asks names the stretch. A Studio before 1.20 never offers the sheet; a daemon before 1.20 is never asked.
• CLI: reelwright direct --from sc02/l05 [--to scene|episode|sc02/l07] [--note …] [--recut] [--changed].

Build slices

Each slice is proved on its own: the core tests it touches, an engine test where Studio changes, the web check that covers it, and one mutation per guarantee (each taken out, its test seen to fail). Spanish, the CHANGELOG, the verify features and the site docs go with each.

1. A stretch, re-directed by the heuristic director (core). director/span.ts reads a moment and a stretch off the episode; director/splice.ts puts the new direction of a stretch into the episode (frozen before, the stretch, kept after, the joins, ids, the after part's timing, continuity and widening). direct_episode and reelwright direct take from and to. Guarantees, each a test over the demo's episodes and a mutation: (G1) before the point, the IR and the compiled Timeline are the same; (G2) after a stretch, the IR is the same but for its time, and the Timeline's entries after it are the same, moved by the stretch's change in length; (G3) the stretch is the new direction; (G5) a stretch whose end breaks continuity widens to the scene's end and says why.
2. Changes by hand are kept (core, EpisodeIR 1.66). edit_episode marks what it changes; re-direction, of a stretch or a whole scene, keeps what is marked unless released; (G4) a hand edit in the stretch survives it, released it does not; a director's own pass marks nothing.
3. The model director over a stretch (core). The span drafts, the requests and the repairs, proved with hand-written replies as the salvage claim's are (no key, no model call): the stretch's request shows the frozen part and the note; a draft that changes the frozen part cannot; a broken join goes back as a repair.
4. Where, and what changed (core and protocol 1.20). episode.span, episode.compare, episode.voice with change and lines, rebase onto edits made meanwhile, and "Direct what changed" (only: "changed"); (G6) an edit made meanwhile survives; (G7) the compare names the stretch exactly.
5. The sheet (Studio, the timeline). R, the menus, the inspector, In to Out; the moment and its choices from episode.span; the script of the stretch, the note, the camera switch, your changes, who directs it; Spanish. Engine tests on recorded answers; a web check at 1440×900 that re-directs a stretch of the demo without Claude and sees the proposal.
6. The compare (Studio, the timeline). The stretch's band and ghost, Play it, Before | After, Side by side, voicing first, Approve, Reject, Undo. Engine tests; the web check carries on from slice 5 to approve and undo it.
7. On a phone, and from the script (Studio). Re-direct from here in the Review view, the sheet over the work, the Re-direction card with its player; the script editor's Re-direct from here and Direct what changed. A web check at 390×844 from a review frame to an approval.
8. Through the connected Claude (after director-over-mcp-2 is in the batch). The span in the plan tasks and in a waiting ask, studio_context's moment, the tool's description; with showrunner for the chat. (G8) A scripted MCP client re-directs a stretch with no key and no model call; a web check with a scripted claude.ai takes the sheet's waiting re-direction and Studio shows the compare.

Slices 1 to 4 are the core and can merge as they land; 5 and 6 need 4; 7 needs 6; 8 needs 3 and director-over-mcp-2.

Not in this

• Re-directing across a scene's places one by one (an intercut is re-directed whole).
• A render of only the stretch: the compare plays live, which needs no render.
• Choosing among several directions of one stretch (variations); a stretch can be re-directed again, on top of the waiting one, until it is right.