@aicopycoders/exodus 2026.9.2000-beta.8 → 2026.9.2000

package/dist/commands/video.js

@@ -7,11 +7,30 @@ import { missingRouteLine } from "../lib/route-support.js";
 import { hasBinary } from "../lib/preflight.js";
 import { ASSET_UPLOAD_POLICY, pauseAheadLine, } from "./workflow.js";
 import { HELPER_LEDGER_BASE, SET_OPTION_LEDGER_BASE } from "../lib/helperLedgerBase.js";
+import { customerAnswer, customerRunPage, customerStageIsWorking, customerStageLines, customerStatusLines, customerStoryboardLines, customerVoicesLines, } from "./video-customer.js";
+const CONCEIT_KEYS = ["podcast", "ugc", "stage", "street", "personification"];
+const VOICE_MODES = ["native", "voice-first"];
+const STYLE_SLUGS = [
+    "pixar-3d",
+    "claymation-stop-motion",
+    "lego-toy-brick",
+    "balloon",
+    "video-game-8bit",
+];
+function joinedOr(items) {
+    if (items.length <= 1)
+        return items[0] ?? "";
+    return `${items.slice(0, -1).join(", ")} or ${items[items.length - 1]}`;
+}
+function cantSayNames(names) {
+    return `the recorded voice can't say ${joinedOr(names.map((n) => `"${n}"`))}`;
+}
 export const helpText = `
 exodus video — make a video ad from a saved workflow, pull every piece, upload your cut
 
 The dashboard makes the PIECES of an ad: the storyboard, one picture per scene,
-one voice track per scene, one video clip per scene, plus the music bed. It does
+one voice track per scene, one video clip per scene, and a music bed if you
+asked for one with --music. It does
 not make the finished ad. You pull the pieces to a folder, cut them together
 with whatever editing tools you like, and upload the cut back.
 
@@ -55,7 +74,9 @@ The whole loop, in order:
 
      exodus video retry-clip <runId> --scene <n>
        Redo ONE finished clip while the run waits for the cut. Everything
-       else stays. A --note steers the motion, never the words.
+       else stays. A --note steers the motion, never the words. Add
+       --voice-first when the words came out wrong: the line is recorded in
+       the character's own voice first, then the clip is made to match it.
 
      exodus video revoice <runId> --all
        Redo only the VOICE on clips that kept the video model's own voice
@@ -66,7 +87,8 @@ The whole loop, in order:
   9. Make your cut from those files.
 
   10. exodus video upload <runId> --file cut.mp4
-      Attaches your cut to the run and prints the page to approve it on.
+      Attaches your cut to the run and prints the page to watch it on. On a
+      One-shot run the upload delivers the ad, so step 11 is not needed.
 
   11. exodus video approve <runId>
       Or click Approve on the page from step 10. If you redid a clip after
@@ -77,12 +99,14 @@ Usage:
   exodus video status <runId> [--rejected-draft] [--json]
   exodus video storyboard <runId> [--json]
   exodus video approve <runId> [--approve-stale-cut] [--json]
-  exodus video retry-frame <runId> --node <nodeId> --scene <n> [--note "..."] [--json]
-  exodus video retry-clip <runId> --scene <n> [--node <nodeId>] [--note "..."] [--json]
+  exodus video retry-frame <runId> [--node <nodeId>] --scene <n> [--note "..."] [--json]
+  exodus video retry-clip <runId> --scene <n> [--node <nodeId>] [--note "..."] [--voice-first] [--json]
   exodus video revoice <runId> (--scene <n> | --all) [--node <nodeId>] [--json]
   exodus video voices <runId> [--set <character>=<voiceId>] [--clear <character>] [--from <file.json>] [--json]
   exodus video pull <runId> --out <dir> [--json]
   exodus video upload <runId> --file <cut.mp4> [--duration <sec>] [--json]
+  exodus video start --script <file> --conceit <${CONCEIT_KEYS.join("|")}> --style <${STYLE_SLUGS.join("|")}> [--direction "<note>"] [--voice-path <path>] [--video-model <id>] [--voice <native|voice-first>] [--music] [--review-storyboard] [--director] [--wait] [--json]
+  exodus video director <runId> <on|off|follow> [--json]
 
 Options:
   --out <dir>          Folder to write the pulled pieces into (pull)
@@ -90,13 +114,17 @@ Options:
   --duration <sec>     How long your cut is, in seconds. Only needed when the
                        length can't be read off the file itself
   --note "<text>"      How to steer one redo (retry-frame, retry-clip)
-  --node <nodeId>      Which scene-frames node holds the still (retry-frame).
+  --node <nodeId>      Which scene-frames node holds the still (retry-frame;
+                       admins pass it, beta testers leave it off).
                        Which video step holds the clip, when a scene has one on
                        more than one step (retry-clip, revoice)
   --scene <n>          Which scene to redo. One scene only, a whole number
                        (retry-frame, retry-clip, revoice)
   --all                Every finished clip that kept the video model's voice
                        (revoice)
+  --voice-first        Record the scene's line in the character's own voice,
+                       then make the clip to match it (retry-clip). For a clip
+                       whose words came out wrong
   --approve-stale-cut  Deliver the cut you uploaded even though a clip changed
                        after you uploaded it (approve). Without it, approving
                        stops and names the scenes that changed
@@ -108,11 +136,41 @@ Options:
                        --clear win over the same name in the file
   --rejected-draft     Print the storyboard draft the system turned down
                        (status). It was thrown away — a record only
+  --script <file>      Text file of what the ad says (start)
+  --conceit <key>      Kind of ad: ${joinedOr(CONCEIT_KEYS)} (start)
+  --style <slug>       Look: ${joinedOr(STYLE_SLUGS)} (start)
+  --direction "<note>" Note for the whole ad (start)
+  --voice-path <path>  How the voices are made (start)
+  --video-model <id>   Which video model films this ad, instead of the kind of
+                       ad's own default (start, with --conceit)
+  --voice <mode>       voice-first (the default): the lines are recorded
+                       first. native: the video model speaks the lines
+                       (start, with --conceit)
+  --music              Put a music bed under the ad (start). An ad has no music
+                       unless you ask for it here
+  --no-music           Leave the music bed off (start), which it already is
+  --review-storyboard  Stop at the storyboard so you can approve it yourself
+                       (start, with --conceit). By default the app approves its
+                       own storyboard when its checks pass
+  --director           Turn the trial director on for this ad (start, with
+                       --conceit). Admins only. To switch it on or off later:
+                       exodus video director <runId> on|off|follow, where
+                       follow goes back to the brand's own setting
+  --wait               Wait until the run needs you (start): at the
+                       storyboard, or once every piece is made
   --json               Machine-readable output
   --help, -h           Print this help
 
-Video is admin-only. If every command here answers "video isn't enabled for
-this key", your dashboard user needs the admin role on this brand.
+Who can use what. Admins get every command here. Beta testers with video
+switched on get these, on their own brands: start (--script, --conceit,
+--style, --direction, --music, --review-storyboard), status, storyboard,
+approve (the storyboard), voices, retry-frame --scene <n> (redo one scene's
+picture while the storyboard waits), pull (the finished video, each scene's
+clip and voice, and the music) and upload. These stay admin-only:
+start --video-model / --voice / --voice-path / --director, director,
+status --rejected-draft, retry-clip and revoice.
+If a command answers "video isn't enabled for this key", the run id is wrong,
+the command is admin-only, or video isn't switched on for your dashboard user.
 
 Examples:
   exodus workflow list
@@ -122,17 +180,21 @@ Examples:
   exodus video approve run_123
   exodus video retry-frame run_123 --node frames-1 --scene 2
   exodus video retry-clip run_123 --scene 3 --note "keep the handshake in frame"
+  exodus video retry-clip run_123 --scene 3 --voice-first
   exodus video revoice run_123 --all
   exodus video voices run_123
   exodus video voices run_123 --set C1=abc123voiceid --set "HOST 2=def456voiceid"
   exodus video voices run_123 --from voices.json
   exodus video pull run_123 --out ./ad-run_123
   exodus video upload run_123 --file ./cut.mp4
+  exodus video director run_123 on
 `.trim();
 const SHOWS_PATH = "/api/v2/shows";
 const RUNS_PATH = "/api/v2/video/runs";
-const RUN_PATH = "/api/v2/workflow";
-const ITEMS_PATH = "/api/v2/workflow/items";
+const SCRIPT_RUNS_PATH = "/api/v2/video/script-runs";
+const DIRECTOR_PATH = "/api/v2/video/director";
+export const RUN_PATH = "/api/v2/workflow";
+export const ITEMS_PATH = "/api/v2/workflow/items";
 const REJECTED_DRAFT_PATH = "/api/v2/workflow/rejected-draft";
 const REJECTED_DRAFT_NOT_ON_THIS_SERVER = "This Exodus server does not keep rejected drafts yet, so there is nothing to read. It arrives " +
     "with the next server update.";
@@ -141,12 +203,15 @@ const FLAG_PATH = "/api/v2/video/storyboard/flag";
 const APPROVE_PATH = "/api/v2/workflow/approve";
 const SCENE_RETRY_PATH = "/api/v2/workflow/scene/retry";
 const SCENE_REVOICE_PATH = "/api/v2/workflow/scene/revoice";
+const SCENE_VOICE_FIRST_PATH = "/api/v2/workflow/scene/voice-first";
+const VOICE_FIRST_NOT_ON_THIS_SERVER = "This Exodus server cannot redo a clip voice first yet, so nothing was started and nothing " +
+    "was spent. It arrives with the next server update.";
 const REVOICE_NOT_ON_THIS_SERVER = "This Exodus server does not have the voice redo yet, so nothing was started and nothing " +
     "was spent. It arrives with the next server update.";
-const FINAL_PATH = "/api/v2/video/final";
+export const FINAL_PATH = "/api/v2/video/final";
 export const VOICES_PATH = "/api/v2/video/voices";
-const ASSET_UPLOAD_URL_PATH = "/api/v2/workflows/asset-upload-url";
-const ASSETS_PATH = "/api/v2/workflows/assets";
+export const ASSET_UPLOAD_URL_PATH = "/api/v2/workflows/asset-upload-url";
+export const ASSETS_PATH = "/api/v2/workflows/assets";
 function withoutJudgeFields({ judgeDetail: _d, judgeSeverity: _s, ...rest }) {
     return rest;
 }
@@ -155,7 +220,7 @@ export function qcWithoutJudgeWording(qc) {
         return qc;
     return {
         ...qc,
-        takes: qc.takes.map(({ judgeWording: _w, ...rest }) => rest),
+        takes: qc.takes.map(({ judgeWording: _w, heardText: _h, ...rest }) => rest),
     };
 }
 export const NO_TAKE_HISTORY_LINE = "no history recorded for this clip";
@@ -184,6 +249,9 @@ export function renderQcTakeHistory(takes) {
     });
     return lines;
 }
+function redoLine(lastRedo) {
+    return lastRedo.reason ? `${lastRedo.label}: ${lastRedo.reason}` : lastRedo.label;
+}
 function printDisplacedHistory(lines, lastRedo) {
     const history = lastRedo.displacedHistory;
     if (!history)
@@ -248,7 +316,9 @@ export const defaultDeps = {
     dashboardUrl: getDashboardUrl(),
 };
 export const VIDEO_NOT_FOUND_MESSAGE = "video isn't enabled for this key\n" +
-    "Either your dashboard user needs the admin role on this brand (video is admin-only), or that run id doesn't exist here. Check the id, then ask Brad about the role.";
+    "One of three things: that run id doesn't exist on this brand, this command is for admins only " +
+    "(director, status --rejected-draft, retry-clip, revoice), or video isn't " +
+    "switched on for your dashboard user on this brand. Check the id first, then ask Brad.";
 export function videoApiError(res) {
     const behind = missingRouteLine(res, "exodus video");
     if (behind)
@@ -257,6 +327,9 @@ export function videoApiError(res) {
         return VIDEO_NOT_FOUND_MESSAGE;
     return formatApiError(res);
 }
+function adminOnlyResult(line, json) {
+    return { code: 1, lines: json ? [JSON.stringify({ ok: false, error: line })] : [line] };
+}
 function errorResult(res, json) {
     return {
         code: 1,
@@ -279,6 +352,14 @@ function parkedAtFinalWatch(run) {
     return (!parkedByBuilderCheckpoint(run) &&
         run.nodes.some((n) => n.kind === "video" && n.status === "done"));
 }
+function heldReason(run) {
+    const verdict = run.storyboardAutoApproval;
+    if (verdict?.outcome !== "held")
+        return undefined;
+    const reason = verdict.reason?.trim() ||
+        "The app didn't approve this storyboard by itself because its checks found a problem.";
+    return `${reason} (checked ${new Date(verdict.at).toISOString()})`;
+}
 export function classifyRun(run) {
     if (run.status === "failed")
         return { at: "failed", error: run.error };
@@ -298,6 +379,7 @@ export function classifyRun(run) {
         }
         const pausedNode = run.nodes.find((n) => n.nodeId === run.pausedNodeId);
         if (pausedNode && parkedAtStoryboardGate(run, pausedNode)) {
+            const held = heldReason(run);
             return {
                 at: "storyboard-gate",
                 nodeId: pausedNode.nodeId,
@@ -305,10 +387,31 @@ export function classifyRun(run) {
                     ? { framesNodeId: pausedNode.nodeId }
                     : {}),
                 ...(isShowAd(run) ? { showAd: true } : {}),
+                ...(held ? { heldReason: held } : {}),
+            };
+        }
+        if (parkedAtFinalWatch(run)) {
+            const videoNodes = run.nodes.filter((n) => n.kind === "video");
+            const autoRedoScenes = videoNodes.flatMap((n) => n.autoRedoScenes ?? []);
+            const autoRedoReasons = videoNodes.flatMap((n) => n.autoRedoReasons ?? []);
+            if (autoRedoScenes.length > 0) {
+                return {
+                    at: "running",
+                    stage: "video",
+                    autoRedoScenes,
+                    ...(autoRedoReasons.length > 0 ? { autoRedoReasons } : {}),
+                };
+            }
+            const missingScenes = run.nodes
+                .filter((n) => n.kind === "video")
+                .flatMap((n) => n.missingScenes ?? []);
+            const framesNodeId = run.nodes.find((n) => n.kind === "scene-frames")?.nodeId;
+            return {
+                at: "final-watch",
+                ...(missingScenes.length > 0 ? { missingScenes } : {}),
+                ...(missingScenes.length > 0 && framesNodeId ? { framesNodeId } : {}),
             };
         }
-        if (parkedAtFinalWatch(run))
-            return { at: "final-watch" };
         return { at: "paused", nodeId: run.pausedNodeId, reason: run.pauseReason };
     }
     const active = run.nodes.find((n) => n.status === "running");
@@ -317,10 +420,22 @@ export function classifyRun(run) {
 export function hasAttachedCut(items) {
     return items.some((i) => i.itemKind === "final" && i.status === "done");
 }
+export function scenesBeingRedone(run, items) {
+    const scenes = new Set(run.nodes.filter((n) => n.kind === "video").flatMap((n) => n.autoRedoScenes ?? []));
+    for (const i of items) {
+        if (i.itemKind === "clip" &&
+            i.status === "running" &&
+            (i.attempt ?? 1) > 1 &&
+            i.staleClaim !== true) {
+            scenes.add(i.sceneIndex);
+        }
+    }
+    return [...scenes].sort((a, b) => a - b);
+}
 export function resolveStop(stop, cutAttached) {
     if (stop.at !== "final-watch")
         return stop;
-    return { at: "final-watch", cutAttached };
+    return { ...stop, cutAttached };
 }
 export async function resolveStopAtPark(stop, runId, deps) {
     if (stop.at !== "final-watch")
@@ -359,15 +474,38 @@ export function isShowAd(run) {
     return run.moduleOwned === true;
 }
 export function reviewUrl(dashboardUrl, run) {
-    if (isShowAd(run))
-        return `${dashboardUrl}/video?ad=${run._id}`;
     if (run.workflowId)
         return `${dashboardUrl}/workflows/${run.workflowId}/runs/${run._id}`;
     return `${dashboardUrl}/runs/${run._id}`;
 }
+function scenesPhrase(scenes) {
+    if (scenes.length === 1)
+        return `scene ${scenes[0]}`;
+    return `scenes ${scenes.slice(0, -1).join(", ")} and ${scenes[scenes.length - 1]}`;
+}
+function missingSceneLines(missing, framesNodeId, runId, runUrl) {
+    const scenes = missing.map((m) => m.sceneIndex);
+    const lines = [
+        `Parked: ${scenesPhrase(scenes)} ${scenes.length === 1 ? "has" : "have"} no clip yet, so the ad isn't complete.`,
+    ];
+    for (const { sceneIndex, pictureRefused } of missing) {
+        if (!pictureRefused) {
+            lines.push(`Redo clip ${sceneIndex}:     exodus video retry-clip ${runId} --scene ${sceneIndex}`);
+            continue;
+        }
+        lines.push(`Scene ${sceneIndex}'s picture was refused by the video service as too close to an existing character, so redraw it before redoing the clip.`);
+        lines.push(framesNodeId
+            ? `Redraw frame ${sceneIndex}:  exodus video retry-frame ${runId} --node ${framesNodeId} --scene ${sceneIndex} --note "<what to change>"`
+            : `Redraw frame ${sceneIndex}:  on the run page, ${runUrl}`);
+        lines.push(`Then redo clip ${sceneIndex}: exodus video retry-clip ${runId} --scene ${sceneIndex}`);
+    }
+    lines.push("The ad can't be approved until every scene has a clip.", `Watch it here:   ${runUrl}`);
+    return lines;
+}
 export function stopLines(stop, runId, runUrl) {
     if (stop.at === "storyboard-gate") {
         const lines = [
+            ...(stop.heldReason ? [stop.heldReason] : []),
             "Parked: the storyboard is waiting for your yes.",
             `Read it:    exodus video storyboard ${runId}`,
             `Approve it: exodus video approve ${runId}`,
@@ -381,6 +519,9 @@ export function stopLines(stop, runId, runUrl) {
         return lines;
     }
     if (stop.at === "final-watch") {
+        if (stop.missingScenes?.length) {
+            return missingSceneLines(stop.missingScenes, stop.framesNodeId, runId, runUrl);
+        }
         if (stop.cutAttached === null) {
             return [
                 "Parked: every piece is made.",
@@ -436,8 +577,28 @@ export function stopLines(stop, runId, runUrl) {
             `Open it: ${runUrl}`,
         ];
     }
+    if (stop.autoRedoScenes?.length)
+        return [autoRedoLine(stop.autoRedoScenes, stop.autoRedoReasons)];
     return [`Working: ${stageWord(stop.stage)}.`];
 }
+function autoRedoLine(scenes, reasons = []) {
+    const reasonOf = new Map(reasons.map((r) => [r.sceneIndex, r.reason]));
+    const groups = new Map();
+    for (const scene of [...scenes].sort((a, b) => a - b)) {
+        const reason = reasonOf.get(scene);
+        groups.set(reason, [...(groups.get(reason) ?? []), scene]);
+    }
+    const one = scenes.length === 1;
+    const clauses = [...groups].map(([reason, group], i) => {
+        const own = i === 0 ? ` on ${group.length === 1 ? "its" : "their"} own` : "";
+        return `${scenesPhrase(group)}${own}${reason ? ` because ${reason}` : ""}`;
+    });
+    const listed = clauses.length === 1
+        ? clauses[0]
+        : `${clauses.slice(0, -1).join(", ")}, and ${clauses[clauses.length - 1]}`;
+    return (`Working: the app is redoing ${listed}. ` +
+        `The ad isn't ready to watch until ${one ? "it lands" : "they land"}.`);
+}
 export function failedStoryboardNode(run) {
     return run.nodes.find((n) => n.kind === "storyboard" && n.status === "failed");
 }
@@ -462,7 +623,13 @@ export function planFailureLines(node, runId) {
     }
     return lines;
 }
+export const MUSIC_HEARD_CODE = "music-heard";
 export const CAST_LEDGER_BASE = HELPER_LEDGER_BASE + 10000;
+export function musicBedState(run) {
+    if (run.musicBed === undefined)
+        return "unknown";
+    return run.musicBed ? "on" : "off";
+}
 function isPullSceneIndex(sceneIndex) {
     return sceneIndex >= 0 && sceneIndex < HELPER_LEDGER_BASE;
 }
@@ -504,6 +671,10 @@ function clipFromArtifact(sceneIndex, artifact) {
         revoiced: artifact.revoiced === true,
         speechTrimmed: artifact.speechTrimmed === true,
         rawStorageId: artifact.rawStorageId ?? null,
+        voiceMode: artifact.voiceMode ?? null,
+        voiceFirstBlockedBy: artifact.voiceFirstBlockedBy ?? null,
+        voicePitchHz: artifact.voicePitchHz ?? null,
+        voicePitchMethod: artifact.voicePitchMethod ?? null,
     };
 }
 function keyframeDownload(sceneIndex, imageUrl) {
@@ -655,14 +826,36 @@ export function planPull(run, items, opts) {
         }
     }
     let reference = null;
+    let productSheet = null;
+    let setPlate = null;
+    const filledByStage = new Map();
     for (const artifact of outputsOfNodeKind(run, "reference")) {
         if (artifact.type !== "image" || !artifact.imageUrl)
             continue;
-        reference = {
-            file: `reference.${extFor(artifact.imageUrl, "image")}`,
-            url: artifact.imageUrl,
-        };
-    }
+        if (artifact.anchor === "filled-plate") {
+            const holds = artifact.holds ?? [];
+            const lid = artifact.lid;
+            filledByStage.set(JSON.stringify([holds, lid ?? null]), { holds, url: artifact.imageUrl, ...(lid ? { lid } : {}) });
+            continue;
+        }
+        const stem = artifact.anchor ?? "reference";
+        const download = { file: `${stem}.${extFor(artifact.imageUrl, "image")}`, url: artifact.imageUrl };
+        if (artifact.anchor === "product-sheet")
+            productSheet = download;
+        else if (artifact.anchor === "set-plate")
+            setPlate = download;
+        else if (!artifact.anchor)
+            reference = download;
+    }
+    const stageKeys = [...new Set([...filledByStage.values()].map((plate) => JSON.stringify(plate.holds)))];
+    const filledPlates = [...filledByStage.values()].map((plate) => ({
+        holds: plate.holds,
+        ...(plate.lid ? { lid: plate.lid } : {}),
+        download: {
+            file: `filled-plate-${stageKeys.indexOf(JSON.stringify(plate.holds)) + 1}${plate.lid ? "-lid-closed" : ""}.${extFor(plate.url, "image")}`,
+            url: plate.url,
+        },
+    }));
     const keyframeByScene = new Map();
     for (const artifact of run.nodes.flatMap((n) => n.outputs ?? [])) {
         if (artifact.type !== "frames")
@@ -765,6 +958,9 @@ export function planPull(run, items, opts) {
             continue;
         keyframeByScene.set(sceneIndex, keyframeDownload(sceneIndex, artifact.imageUrl));
     }
+    const pendingRedo = scenesBeingRedone(run, items);
+    for (const sceneIndex of pendingRedo)
+        clipByScene.delete(sceneIndex);
     const sceneIndexes = [
         ...new Set([
             ...clipByScene.keys(),
@@ -813,6 +1009,10 @@ export function planPull(run, items, opts) {
             revoiced: clip ? clip.revoiced : null,
             speechTrimmed: clip ? clip.speechTrimmed : null,
             rawStorageId: clip ? clip.rawStorageId : null,
+            voiceMode: clip ? clip.voiceMode : null,
+            voiceFirstBlockedBy: clip ? clip.voiceFirstBlockedBy : null,
+            voicePitchHz: clip ? clip.voicePitchHz : null,
+            voicePitchMethod: clip ? clip.voicePitchMethod : null,
             clipStatus: item?.status ?? "missing",
             error: item?.error ?? null,
             flagged: item?.flagged === true,
@@ -823,6 +1023,9 @@ export function planPull(run, items, opts) {
     const { cast, downloads: castDownloads } = planCastRefs(run, items, castVoicePins(storyboardArtifact));
     const downloads = [
         ...(reference ? [reference] : []),
+        ...(productSheet ? [productSheet] : []),
+        ...(setPlate ? [setPlate] : []),
+        ...filledPlates.map((p) => p.download),
         ...keyframeByScene.values(),
         ...[...voiceByScene.values()].map((v) => v.download),
         ...(narrationDownload ? [narrationDownload] : []),
@@ -839,7 +1042,15 @@ export function planPull(run, items, opts) {
             dashboardUrl: reviewUrl(opts.dashboardUrl, run),
             storyboard,
             reference: reference?.file ?? null,
+            productSheet: productSheet?.file ?? null,
+            setPlate: setPlate?.file ?? null,
+            filledPlates: filledPlates.map((p) => ({ file: p.download.file, holds: p.holds, ...(p.lid ? { lid: p.lid } : {}) })),
             music: music?.file ?? null,
+            musicBed: musicBedState(run),
+            musicHeardScenes: scenes
+                .filter((scene) => scene.findings.some((f) => f.code === MUSIC_HEARD_CODE))
+                .map((scene) => scene.sceneIndex),
+            pendingRedo,
             cast,
             narration: narrationDownload
                 ? { file: narrationDownload.file, timing: "narration.json" }
@@ -849,6 +1060,14 @@ export function planPull(run, items, opts) {
             ...(run.provenance?.format || run.provenance?.voice
                 ? { provenance: run.provenance }
                 : {}),
+            ...(run.videoChoice
+                ? {
+                    videoChoice: {
+                        videoModel: run.videoChoice.videoModel,
+                        voiceMode: run.videoChoice.voiceMode,
+                    },
+                }
+                : {}),
         },
     };
 }
@@ -858,6 +1077,14 @@ export function markPullFailure(manifest, failure) {
         manifest.storyboard = null;
     if (manifest.reference === failure.file)
         manifest.reference = null;
+    if (manifest.productSheet === failure.file)
+        manifest.productSheet = null;
+    if (manifest.setPlate === failure.file)
+        manifest.setPlate = null;
+    for (const plate of manifest.filledPlates) {
+        if (plate.file === failure.file)
+            plate.file = null;
+    }
     if (manifest.music === failure.file)
         manifest.music = null;
     for (const ref of manifest.cast) {
@@ -874,6 +1101,10 @@ export function markPullFailure(manifest, failure) {
             scene.revoiced = null;
             scene.speechTrimmed = null;
             scene.rawStorageId = null;
+            scene.voiceMode = null;
+            scene.voiceFirstBlockedBy = null;
+            scene.voicePitchHz = null;
+            scene.voicePitchMethod = null;
         }
         if (scene.voice === failure.file)
             scene.voice = null;
@@ -979,7 +1210,7 @@ export async function startFlow(opts, deps) {
         showId: opts.showId,
         script,
         ...(opts.voicePath ? { voicePath: opts.voicePath } : {}),
-        ...(opts.music === false ? { music: false } : {}),
+        ...(opts.music === undefined ? {} : { music: opts.music }),
     });
     if (!res.ok)
         return errorResult(res, opts.json);
@@ -1008,13 +1239,329 @@ export async function startFlow(opts, deps) {
         lines: opts.json ? waited.lines : [`Started ad run ${runId}`, `Watch it: ${url}`, "", ...waited.lines],
     };
 }
+function nonBlank(value) {
+    if (value === undefined || value.trim().length === 0)
+        return undefined;
+    return value;
+}
+function isVoiceMode(value) {
+    return VOICE_MODES.some((mode) => mode === value);
+}
+function isConceit(value) {
+    return CONCEIT_KEYS.some((key) => key === value);
+}
+export function planMusicChoice(occurrences) {
+    let music;
+    for (const { flag, value } of occurrences) {
+        if (flag === "no-music") {
+            music = false;
+            continue;
+        }
+        if (flag !== "music")
+            continue;
+        if (value === undefined || value.startsWith("--")) {
+            music = true;
+            continue;
+        }
+        const word = value.trim().toLowerCase();
+        const literal = word === "true" ? true : word === "false" ? false : undefined;
+        if (literal === undefined) {
+            return {
+                ok: false,
+                line: `video start --music takes true or false, or no value at all (got "${value}").`,
+            };
+        }
+        music = literal;
+    }
+    return { ok: true, music };
+}
+function planValueFlag(occurrences, name) {
+    let value;
+    for (const occurrence of occurrences) {
+        if (occurrence.flag !== name)
+            continue;
+        const given = occurrence.value;
+        if (given === undefined || given.startsWith("--") || given.trim().length === 0) {
+            return { ok: false, line: `video start --${name} needs a value.` };
+        }
+        value = given.trim();
+    }
+    return { ok: true, value };
+}
+export function planVideoStart(flags, occurrences) {
+    const showId = nonBlank(flagString(flags, "show"));
+    const scriptFile = nonBlank(flagString(flags, "script"));
+    const conceit = nonBlank(flagString(flags, "conceit"));
+    const style = nonBlank(flagString(flags, "style"));
+    if (showId && (conceit || style)) {
+        return {
+            kind: "usage",
+            line: "Pass either --show <id>, or --conceit and --style. Not both.",
+        };
+    }
+    if (!scriptFile) {
+        return {
+            kind: "usage",
+            line: "video start needs --script <file>, a text file of what the ad says.",
+        };
+    }
+    const musicChoice = planMusicChoice(occurrences);
+    if (!musicChoice.ok)
+        return { kind: "usage", line: musicChoice.line };
+    const videoModelFlag = planValueFlag(occurrences, "video-model");
+    if (!videoModelFlag.ok)
+        return { kind: "usage", line: videoModelFlag.line };
+    const voiceFlag = planValueFlag(occurrences, "voice");
+    if (!voiceFlag.ok)
+        return { kind: "usage", line: voiceFlag.line };
+    const videoModel = videoModelFlag.value;
+    const voiceMode = voiceFlag.value;
+    const reviewStoryboard = occurrences.some((o) => o.flag === "review-storyboard");
+    if (showId && reviewStoryboard) {
+        return {
+            kind: "usage",
+            line: "--review-storyboard works with --conceit, not --show. A Show's ad always stops at the storyboard for you.",
+        };
+    }
+    const directorFlags = occurrences.filter((o) => o.flag === "director");
+    if (directorFlags.some((o) => o.value !== undefined && !o.value.startsWith("--"))) {
+        return {
+            kind: "usage",
+            line: "--director takes no value. Leave it off to start without the director.",
+        };
+    }
+    const director = directorFlags.length > 0;
+    if (showId && director) {
+        return {
+            kind: "usage",
+            line: "--director works with --conceit, not --show.",
+        };
+    }
+    if (showId && (videoModel || voiceMode)) {
+        return {
+            kind: "usage",
+            line: "--video-model and --voice work with --conceit, not --show. A Show films on its own model.",
+        };
+    }
+    if (voiceMode && !isVoiceMode(voiceMode)) {
+        return {
+            kind: "usage",
+            line: `video start --voice must be native or voice-first (got "${voiceMode}").`,
+        };
+    }
+    if (showId) {
+        return {
+            kind: "show",
+            opts: {
+                showId,
+                scriptFile,
+                voicePath: flagString(flags, "voice-path"),
+                music: musicChoice.music,
+                wait: flags["wait"] === true,
+                json: flags["json"] === true,
+            },
+        };
+    }
+    if (!conceit) {
+        return {
+            kind: "usage",
+            line: `video start needs --conceit <${CONCEIT_KEYS.join("|")}>.`,
+        };
+    }
+    if (!isConceit(conceit)) {
+        return {
+            kind: "usage",
+            line: `video start --conceit must be one of ${joinedOr(CONCEIT_KEYS)}.`,
+        };
+    }
+    if (!style) {
+        return {
+            kind: "usage",
+            line: `video start needs --style <${STYLE_SLUGS.join("|")}>.`,
+        };
+    }
+    const direction = nonBlank(flagString(flags, "direction"));
+    const voicePath = nonBlank(flagString(flags, "voice-path"));
+    const opts = {
+        scriptFile,
+        conceit,
+        style,
+        wait: flags["wait"] === true,
+        json: flags["json"] === true,
+    };
+    if (direction)
+        opts.direction = direction;
+    if (voicePath)
+        opts.voicePath = voicePath;
+    if (videoModel)
+        opts.videoModel = videoModel;
+    if (voiceMode && isVoiceMode(voiceMode))
+        opts.voiceMode = voiceMode;
+    if (musicChoice.music !== undefined)
+        opts.music = musicChoice.music;
+    if (reviewStoryboard)
+        opts.reviewStoryboard = true;
+    if (director)
+        opts.director = true;
+    return { kind: "script", opts };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isResolvedCard(value) {
+    if (!isRecord(value))
+        return false;
+    if (!isRecord(value.conceit) || !isRecord(value.style))
+        return false;
+    if (typeof value.conceit.key !== "string" || typeof value.conceit.label !== "string")
+        return false;
+    if (typeof value.family !== "string")
+        return false;
+    if (!("wrapper" in value))
+        return false;
+    if (value.wrapper !== null && typeof value.wrapper !== "string")
+        return false;
+    if (typeof value.style.slug !== "string" || typeof value.style.label !== "string")
+        return false;
+    return true;
+}
+function startedVideoChoice(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.videoModel !== "string" || typeof value.voiceMode !== "string")
+        return null;
+    return { videoModel: value.videoModel, voiceMode: value.voiceMode };
+}
+function scriptStartedLines(runId, url, card, video, director) {
+    return [
+        `Started ad run ${runId}`,
+        ...(card
+            ? [
+                `Conceit: ${card.conceit.label}`,
+                `Family: ${card.family}`,
+                `Wrapper: ${card.wrapper ?? ""}`,
+                `Style: ${card.style.label}`,
+            ]
+            : ["The server did not include a resolved card."]),
+        ...(video ? [`Video model: ${video.videoModel}`, `Voice: ${video.voiceMode}`] : []),
+        ...(director ? ["Director: on for this ad"] : []),
+        `Watch it: ${url}`,
+    ];
+}
+function waitJsonWithCard(waited, card, video) {
+    const first = waited.lines[0];
+    if (typeof first !== "string")
+        return waited;
+    let parsed;
+    try {
+        parsed = JSON.parse(first);
+    }
+    catch {
+        return waited;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        return waited;
+    return {
+        code: waited.code,
+        lines: [JSON.stringify({ ...parsed, card, ...(video ? { videoChoice: video } : {}) })],
+    };
+}
+export async function startScriptFlow(opts, deps) {
+    let script;
+    try {
+        script = deps.readFile(opts.scriptFile);
+    }
+    catch (e) {
+        return {
+            code: 1,
+            lines: [
+                `Can't read the script file "${opts.scriptFile}": ${e instanceof Error ? e.message : String(e)}`,
+            ],
+        };
+    }
+    if (script.trim().length === 0) {
+        return { code: 1, lines: [`The script file "${opts.scriptFile}" is empty.`] };
+    }
+    const res = await deps.post(SCRIPT_RUNS_PATH, {
+        script,
+        conceit: opts.conceit,
+        style: opts.style,
+        ...(opts.direction ? { direction: opts.direction } : {}),
+        ...(opts.voicePath ? { voicePath: opts.voicePath } : {}),
+        ...(opts.videoModel ? { videoModel: opts.videoModel } : {}),
+        ...(opts.voiceMode ? { voiceMode: opts.voiceMode } : {}),
+        ...(opts.music === true ? { music: true } : {}),
+        ...(opts.reviewStoryboard ? { reviewStoryboard: true } : {}),
+        ...(opts.director ? { director: true } : {}),
+    });
+    if (!res.ok)
+        return errorResult(res, opts.json);
+    const customerStart = customerAnswer(res.data);
+    if (customerStart)
+        return customerStartedResult(customerStart, opts, deps);
+    const started = res.data;
+    if (!started.runId) {
+        return { code: 1, lines: ["The server started the ad but did not say which run it is."] };
+    }
+    const runId = started.runId;
+    const url = typeof started.url === "string" ? started.url : "";
+    const card = isResolvedCard(started.card) ? started.card : null;
+    const video = startedVideoChoice(started.videoChoice);
+    if (!opts.wait) {
+        return {
+            code: 0,
+            lines: opts.json
+                ? [JSON.stringify({ runId, url, card, ...(video ? { videoChoice: video } : {}) })]
+                : [
+                    ...scriptStartedLines(runId, url, card, video, opts.director === true),
+                    "",
+                    ...(opts.reviewStoryboard
+                        ? ["Wait for the storyboard here instead: exodus video start … --wait"]
+                        : [
+                            "The app approves the storyboard itself if its checks pass. It only stops for you if they find a problem.",
+                            "Wait here until it needs you:        exodus video start … --wait",
+                        ]),
+                    `Or check in whenever:                exodus video status ${runId}`,
+                ],
+        };
+    }
+    const waited = await waitFlow(runId, { json: opts.json, url }, deps);
+    if (opts.json)
+        return waitJsonWithCard(waited, card, video);
+    return {
+        code: waited.code,
+        lines: [...scriptStartedLines(runId, url, card, video, opts.director === true), "", ...waited.lines],
+    };
+}
+async function customerStartedResult(started, opts, deps) {
+    const { runId, dashboardUrl } = started;
+    const head = [`Started video ${runId}`, `Watch it: ${dashboardUrl}`];
+    if (opts.wait) {
+        const waited = await waitFlow(runId, { json: opts.json, url: dashboardUrl }, deps);
+        return opts.json ? waited : { code: waited.code, lines: [...head, "", ...waited.lines] };
+    }
+    if (opts.json)
+        return { code: 0, lines: [JSON.stringify(started)] };
+    return {
+        code: 0,
+        lines: [
+            ...head,
+            "",
+            opts.reviewStoryboard
+                ? "It stops at the storyboard for you to approve."
+                : "The app approves the storyboard itself if its checks pass. It only stops for you if they find a problem.",
+            `Check in whenever: exodus video status ${runId}`,
+        ],
+    };
+}
 const POLL_INTERVAL_MS = 5000;
 const MAX_POLLS = 720;
 export async function waitFlow(runId, opts, deps) {
     const interval = opts.intervalMs ?? POLL_INTERVAL_MS;
     const maxPolls = opts.maxPolls ?? MAX_POLLS;
     const lines = [];
-    let lastStage = null;
+    let lastProgress = null;
+    let redoSeen = false;
     for (let poll = 0; poll < maxPolls; poll++) {
         if (poll > 0)
             await deps.sleep(interval);
@@ -1023,17 +1570,57 @@ export async function waitFlow(runId, opts, deps) {
             const failed = errorResult(res, opts.json);
             return { code: failed.code, lines: [...lines, ...failed.lines] };
         }
+        const customer = customerAnswer(res.data);
+        if (customer) {
+            const page = customerRunPage(deps.dashboardUrl, runId);
+            if (customerStageIsWorking(customer.stage)) {
+                const progress = customerStageLines(customer, page)[0];
+                if (progress !== lastProgress) {
+                    lastProgress = progress;
+                    if (!opts.json)
+                        lines.push(progress);
+                }
+                continue;
+            }
+            return {
+                code: customer.stage === "failed" ? 1 : 0,
+                lines: opts.json
+                    ? [JSON.stringify(customer)]
+                    : [...lines, ...customerStageLines(customer, page), `Watch it on the dashboard: ${page}`],
+            };
+        }
         const run = asVideoRun(res.data);
         const stop = classifyRun(run);
         if (stop.at === "running") {
-            if (stop.stage !== lastStage) {
-                lastStage = stop.stage;
+            const progress = stop.autoRedoScenes?.length
+                ? autoRedoLine(stop.autoRedoScenes, stop.autoRedoReasons)
+                : `Working: ${stageWord(stop.stage)}…`;
+            if (progress !== lastProgress) {
+                lastProgress = progress;
                 if (!opts.json)
-                    lines.push(`Working: ${stageWord(stop.stage)}…`);
+                    lines.push(progress);
             }
             continue;
         }
-        const resolved = await resolveStopAtPark(stop, runId, deps);
+        let items = null;
+        if (stop.at === "final-watch") {
+            const itemsRes = await deps.get(`${ITEMS_PATH}?runId=${encodeURIComponent(runId)}`);
+            items = itemsRes.ok ? (itemsRes.data.items ?? []) : null;
+            if (items === null && redoSeen)
+                continue;
+            const redoing = items ? scenesBeingRedone(run, items) : [];
+            redoSeen = redoing.length > 0;
+            if (redoSeen) {
+                const progress = `Working: redoing scene${redoing.length === 1 ? "" : "s"} ${redoing.join(", ")}…`;
+                if (progress !== lastProgress) {
+                    lastProgress = progress;
+                    if (!opts.json)
+                        lines.push(progress);
+                }
+                continue;
+            }
+        }
+        const resolved = resolveStop(stop, items ? hasAttachedCut(items) : null);
         if (opts.json) {
             return {
                 code: stop.at === "failed" ? 1 : 0,
@@ -1076,6 +1663,13 @@ export async function statusFlow(runId, json, deps) {
     const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!runRes.ok)
         return errorResult(runRes, json);
+    const customer = customerAnswer(runRes.data);
+    if (customer) {
+        return {
+            code: 0,
+            lines: json ? [JSON.stringify(customer)] : customerStatusLines(customer, deps.dashboardUrl),
+        };
+    }
     const run = asVideoRun(runRes.data);
     const itemsRes = await deps.get(`${ITEMS_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!itemsRes.ok)
@@ -1102,18 +1696,32 @@ export async function statusFlow(runId, json, deps) {
                     hasFinal,
                     warnings,
                     guidance,
+                    ...(run.musicBed === undefined ? {} : { musicBed: run.musicBed }),
                     ...(failedStoryboard?.planFailure ? { planFailure: failedStoryboard.planFailure } : {}),
                     ...(failedStoryboard?.planFailure
                         ? { storyboardNodeId: failedStoryboard.nodeId }
                         : {}),
                     ...(failedStoryboard?.hasRejectedDraft === true ? { hasRejectedDraft: true } : {}),
+                    ...(run.director ? { director: run.director } : {}),
                 }),
             ],
         };
     }
     const revoicedByScene = new Set();
+    const voiceFirstByScene = new Set();
+    const voiceFirstBlockedByScene = new Map();
     const timedOnOriginalVoice = new Set();
     for (const artifact of outputsOfNodeKind(run, "video")) {
+        if (artifact.type === "video" &&
+            artifact.voiceMode === "voice-first" &&
+            typeof artifact.sceneIndex === "number") {
+            voiceFirstByScene.add(artifact.sceneIndex);
+        }
+        if (artifact.type === "video" &&
+            artifact.voiceFirstBlockedBy?.length &&
+            typeof artifact.sceneIndex === "number") {
+            voiceFirstBlockedByScene.set(artifact.sceneIndex, artifact.voiceFirstBlockedBy);
+        }
         if (artifact.type === "video" && artifact.revoiced === true && typeof artifact.sceneIndex === "number") {
             revoicedByScene.add(artifact.sceneIndex);
             if ((artifact.words?.length ?? 0) > 0)
@@ -1144,6 +1752,7 @@ export async function statusFlow(runId, json, deps) {
         ...(stop.at === "running" && run.pauseAhead ? [pauseAheadLine(run.pauseAhead)] : []),
         ...planFailureLines(failedStoryboard, runId),
         ...warnings.map((w) => `Heads-up (${w.step}): ${w.warning}`),
+        ...(run.director ? ["", ...directorLines(run.director)] : []),
     ];
     if (byScene.size === 0) {
         lines.push("", "No scenes yet — this run hasn't made anything to look at.");
@@ -1154,7 +1763,7 @@ export async function statusFlow(runId, json, deps) {
             const row = byScene.get(sceneIndex);
             lines.push(`${String(sceneIndex).padEnd(5)}  ${itemWord(row.clip).padEnd(8)}  ${itemWord(row.voiceover).padEnd(8)}  ${itemWord(row.frame)}`);
             if (row.clip?.lastRedo) {
-                lines.push(`       clip: ${row.clip.lastRedo.label}`);
+                lines.push(`       clip: ${redoLine(row.clip.lastRedo)}`);
                 printDisplacedHistory(lines, row.clip.lastRedo);
             }
             if (row.clip?.lastRedo || row.clip?.flagged) {
@@ -1163,7 +1772,7 @@ export async function statusFlow(runId, json, deps) {
                 }
             }
             if (row.voiceover?.lastRedo) {
-                lines.push(`       voice: ${row.voiceover.lastRedo.label}`);
+                lines.push(`       voice: ${redoLine(row.voiceover.lastRedo)}`);
                 printDisplacedHistory(lines, row.voiceover.lastRedo);
             }
             if (row.frame?.lastRedo)
@@ -1182,6 +1791,12 @@ export async function statusFlow(runId, json, deps) {
                 lines.push(`       ${row.clip.error}`);
             if (revoicedByScene.has(sceneIndex))
                 lines.push("       voice: cast voice applied");
+            if (voiceFirstByScene.has(sceneIndex))
+                lines.push("       clip: redone voice first");
+            const blockedBy = voiceFirstBlockedByScene.get(sceneIndex);
+            if (blockedBy) {
+                lines.push(`       clip: redone the usual way — ${cantSayNames(blockedBy)}`);
+            }
             if (timedOnOriginalVoice.has(sceneIndex)) {
                 lines.push("       word timings: measured on the original voice (close, not frame-exact)");
             }
@@ -1200,10 +1815,79 @@ export async function statusFlow(runId, json, deps) {
             : "Final cut: not uploaded yet.");
     return { code: 0, lines };
 }
+const DIRECTOR_STATUS_WORDS = {
+    reviewing: "Watching this run",
+    waiting: "Waiting for redos to finish",
+    done: "Done: ready for your approval",
+    stopped: "Stopped: see the last note",
+};
+const DIRECTOR_PHASE_WORDS = {
+    storyboard: "Storyboard",
+    "final-watch": "Final watch",
+};
+const DIRECTOR_LOG_LINES = 3;
+export function directorLines(director) {
+    const switchWords = director.runSetting === null
+        ? `following the brand's setting (${director.workspaceOn ? "on" : "off"})`
+        : "switched for this ad";
+    const log = director.log.slice(-DIRECTOR_LOG_LINES);
+    return [
+        `Director: ${director.on ? "on" : "off"}, ${switchWords}`,
+        ...(director.on
+            ? [`  ${DIRECTOR_STATUS_WORDS[director.status ?? "reviewing"]}`]
+            : []),
+        `  Redos: ${director.redosUsed} of ${director.redoCap}. Spent: $${director.spendUsd.toFixed(2)} of $${director.spendCapUsd.toFixed(2)}`,
+        ...(log.length > 0
+            ? [
+                "  Latest notes:",
+                ...log.map((entry) => `    ${DIRECTOR_PHASE_WORDS[entry.phase]}: ${entry.text}`),
+            ]
+            : []),
+    ];
+}
+export function parseDirectorSwitch(word) {
+    if (word === "on")
+        return { on: true };
+    if (word === "off")
+        return { on: false };
+    if (word === "follow")
+        return { on: null };
+    return null;
+}
+export async function directorFlow(runId, on, json, deps) {
+    const res = await deps.post(DIRECTOR_PATH, { runId, on });
+    const behind = missingRouteLine(res, "exodus video director");
+    if (behind) {
+        return {
+            code: 1,
+            lines: json ? [JSON.stringify({ ok: false, status: 404, error: behind })] : [behind],
+        };
+    }
+    if (!res.ok)
+        return errorResult(res, json);
+    if (json)
+        return { code: 0, lines: [JSON.stringify({ runId, on })] };
+    const said = on === null
+        ? `The director on ad run ${runId} now follows the brand's own setting.`
+        : `The director is ${on ? "on" : "off"} for ad run ${runId}.`;
+    return {
+        code: 0,
+        lines: [
+            said,
+            ...(on === true
+                ? ["If the ad is already waiting at the storyboard or the final watch, a review starts now."]
+                : []),
+            `See what it is doing: exodus video status ${runId}`,
+        ],
+    };
+}
 export async function rejectedDraftFlow(runId, json, deps) {
     const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!runRes.ok)
         return errorResult(runRes, json);
+    if (customerAnswer(runRes.data)) {
+        return adminOnlyResult("exodus video status --rejected-draft is for admins.", json);
+    }
     const node = failedStoryboardNode(asVideoRun(runRes.data));
     if (!node) {
         const note = "The storyboard on this run didn't fail, so there is no rejected draft to read.";
@@ -1243,6 +1927,10 @@ export async function storyboardFlow(runId, json, deps) {
     const res = await deps.get(`${STORYBOARD_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!res.ok)
         return errorResult(res, json);
+    const board = customerAnswer(res.data);
+    if (board) {
+        return { code: 0, lines: json ? [JSON.stringify(board)] : customerStoryboardLines(board) };
+    }
     const cards = res.data;
     if (json)
         return { code: 0, lines: [JSON.stringify(cards)] };
@@ -1381,14 +2069,34 @@ export async function flagFlow(runId, note, json, deps) {
     };
 }
 export async function retryFrameFlow(runId, nodeId, sceneIndex, note, json, deps) {
+    if (nodeId === undefined) {
+        const board = await deps.get(`${STORYBOARD_PATH}?runId=${encodeURIComponent(runId)}`);
+        if (!board.ok)
+            return errorResult(board, json);
+        if (!customerAnswer(board.data)) {
+            return { code: 1, lines: ["video retry-frame needs --node <nodeId>."] };
+        }
+    }
     const res = await deps.post(SCENE_RETRY_PATH, {
         runId,
-        nodeId,
+        ...(nodeId === undefined ? {} : { nodeId }),
         sceneIndex,
         ...(note ? { note } : {}),
     });
     if (!res.ok)
         return errorResult(res, json);
+    if (customerAnswer(res.data)) {
+        if (json)
+            return { code: 0, lines: [JSON.stringify({ ok: true, runId, sceneIndex })] };
+        return {
+            code: 0,
+            lines: [
+                `Redrawing scene ${sceneIndex}'s picture. The other scenes stay as they are.`,
+                ...(note ? ["Your note isn't used on this redo."] : []),
+                `See it when it's done: exodus video storyboard ${runId}`,
+            ],
+        };
+    }
     const triggerRunId = res.data.triggerRunId;
     if (json) {
         return {
@@ -1425,7 +2133,10 @@ export function planClipRedo(run, items, target) {
     const { row, uploadedCut } = found;
     const redoable = row.status === "failed" ||
         row.staleClaim === true ||
-        (row.status === "done" && (row.flagged === true || stop.at === "final-watch"));
+        (row.status === "done" &&
+            (row.flagged === true ||
+                stop.at === "final-watch" ||
+                (stop.at === "running" && stop.autoRedoScenes !== undefined)));
     if (!redoable) {
         if (row.status === "done") {
             return {
@@ -1482,10 +2193,14 @@ function findClipRow(run, items, target) {
     }
     return { row, uploadedCut };
 }
-export async function retryClipFlow(runId, target, note, json, deps) {
+export async function retryClipFlow(runId, target, { note, voiceFirst = false }, json, deps) {
     const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!runRes.ok)
         return errorResult(runRes, json);
+    if (customerAnswer(runRes.data)) {
+        return adminOnlyResult("Redoing a finished clip is for admins. To redo a scene's picture while your storyboard " +
+            `waits for you: exodus video retry-frame ${runId} --scene <n>`, json);
+    }
     const run = asVideoRun(runRes.data);
     const itemsRes = await deps.get(`${ITEMS_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!itemsRes.ok)
@@ -1498,12 +2213,20 @@ export async function retryClipFlow(runId, target, note, json, deps) {
             lines: json ? [JSON.stringify({ ok: false, error: plan.reason })] : [plan.reason],
         };
     }
-    const res = await deps.post(SCENE_RETRY_PATH, {
+    const res = await deps.post(voiceFirst ? SCENE_VOICE_FIRST_PATH : SCENE_RETRY_PATH, {
         runId,
         nodeId: plan.nodeId,
         sceneIndex: plan.sceneIndex,
         ...(note ? { note } : {}),
     });
+    if (voiceFirst && missingRouteLine(res, "exodus video retry-clip --voice-first")) {
+        return {
+            code: 1,
+            lines: json
+                ? [JSON.stringify({ ok: false, status: 404, error: VOICE_FIRST_NOT_ON_THIS_SERVER })]
+                : [VOICE_FIRST_NOT_ON_THIS_SERVER],
+        };
+    }
     if (!res.ok)
         return errorResult(res, json);
     const triggerRunId = res.data.triggerRunId;
@@ -1522,6 +2245,7 @@ export async function retryClipFlow(runId, target, note, json, deps) {
                     reviewUrl: review,
                     warnings: plan.warnings,
                     ...(note ? { note } : {}),
+                    ...(voiceFirst ? { voiceMode: "voice-first" } : {}),
                 }),
             ],
         };
@@ -1529,9 +2253,19 @@ export async function retryClipFlow(runId, target, note, json, deps) {
     return {
         code: 0,
         lines: [
-            `Redoing scene ${plan.sceneIndex}'s clip on ${plan.nodeId}.`,
+            voiceFirst
+                ? `Redoing scene ${plan.sceneIndex}'s clip on ${plan.nodeId}, voice first: the line is ` +
+                    "recorded in the character's own voice, then the clip is made to match it. " +
+                    "If the line has a made-up name the recorded voice can't say, the clip may be made " +
+                    `the usual way instead, and exodus video status ${runId} will say so.`
+                : `Redoing scene ${plan.sceneIndex}'s clip on ${plan.nodeId}.`,
             `triggerRunId: ${triggerRunId ?? "-"}`,
-            "Every other scene stays as it is, and so do the pictures, the voices and the script.",
+            ...(voiceFirst
+                ? [
+                    "Every other scene stays as it is, and so do the pictures and the script.",
+                    "A speaking character with no voice yet gets one picked and saved for the whole run.",
+                ]
+                : ["Every other scene stays as it is, and so do the pictures, the voices and the script."]),
             ...(note
                 ? ["Your note steers how this clip moves. It never changes the words that are spoken."]
                 : []),
@@ -1600,6 +2334,9 @@ export async function revoiceFlow(runId, target, json, deps) {
     const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!runRes.ok)
         return errorResult(runRes, json);
+    if (customerAnswer(runRes.data)) {
+        return adminOnlyResult("exodus video revoice is for admins.", json);
+    }
     const run = asVideoRun(runRes.data);
     const itemsRes = await deps.get(`${ITEMS_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!itemsRes.ok)
@@ -1766,6 +2503,10 @@ export async function voicesFlow(runId, voices, json, deps) {
         : await deps.get(`${VOICES_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!res.ok)
         return errorResult(res, json);
+    const customer = customerAnswer(res.data);
+    if (customer) {
+        return { code: 0, lines: json ? [JSON.stringify(customer)] : customerVoicesLines(customer) };
+    }
     const sheet = res.data;
     if (json)
         return { code: 0, lines: [JSON.stringify({ ok: true, ...sheet })] };
@@ -1848,10 +2589,112 @@ export function voiceSheetLines(sheet) {
         : (sheet.whyNot ?? "Voices can no longer be changed on this run."));
     return lines;
 }
+function musicLines(manifest) {
+    const lines = [`music: ${manifest.musicBed}`];
+    if (manifest.musicHeardScenes.length > 0) {
+        lines.push(`music heard in scene ${manifest.musicHeardScenes.join(", ")}`);
+    }
+    return lines;
+}
+export function planCustomerPull(run, items, meta) {
+    const downloads = [];
+    const take = (file, url) => {
+        downloads.push({ file, url });
+        return file;
+    };
+    const scenes = new Map();
+    let music = null;
+    for (const item of items) {
+        if (item.kind === "music") {
+            if (music === null && item.url)
+                music = take(`music.${extFor(item.url, "audio")}`, item.url);
+            continue;
+        }
+        if (!isPullSceneIndex(item.sceneIndex))
+            continue;
+        const scene = scenes.get(item.sceneIndex) ?? { index: item.sceneIndex, clip: null, voice: null };
+        if (item.url && item.kind === "clip" && scene.clip === null) {
+            scene.clip = take(`${scenePrefix(item.sceneIndex)}.${extFor(item.url, "video")}`, item.url);
+        }
+        if (item.url && item.kind === "voice" && scene.voice === null) {
+            scene.voice = take(`${scenePrefix(item.sceneIndex)}.voice.${extFor(item.url, "audio")}`, item.url);
+        }
+        scenes.set(item.sceneIndex, scene);
+    }
+    const videoUrl = run.video?.url;
+    const video = videoUrl ? take(`video.${extFor(videoUrl, "video")}`, videoUrl) : null;
+    return {
+        downloads,
+        manifest: {
+            runId: run.runId,
+            pulledAt: meta.pulledAt,
+            dashboardUrl: customerRunPage(meta.dashboardUrl, run.runId),
+            scenes: [...scenes.values()].sort((a, b) => a.index - b.index),
+            music,
+            video,
+        },
+    };
+}
+async function customerPullFlow(run, dir, json, deps) {
+    const runId = run.runId;
+    const itemsRes = await deps.get(`${ITEMS_PATH}?runId=${encodeURIComponent(runId)}`);
+    if (!itemsRes.ok)
+        return errorResult(itemsRes, json);
+    const items = customerAnswer(itemsRes.data)?.items ?? [];
+    const { downloads, manifest } = planCustomerPull(run, items, {
+        pulledAt: new Date(deps.now()).toISOString(),
+        dashboardUrl: deps.dashboardUrl,
+    });
+    deps.mkdirp(dir);
+    const failures = (await runPool(downloads.map((download) => () => downloadWithRetry(download, dir, deps)), PULL_CONCURRENCY)).filter((f) => f !== null);
+    const landed = (file) => file !== null && !failures.some((f) => f.file === file) ? file : null;
+    for (const scene of manifest.scenes) {
+        scene.clip = landed(scene.clip);
+        scene.voice = landed(scene.voice);
+    }
+    manifest.music = landed(manifest.music);
+    manifest.video = landed(manifest.video);
+    const manifestPath = path.join(dir, "manifest.json");
+    deps.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    const code = failures.length > 0 ? 1 : 0;
+    if (json) {
+        return { code, lines: [JSON.stringify({ runId, dir, wrote: downloads.length - failures.length + 1, manifest })] };
+    }
+    if (downloads.length === 0) {
+        return {
+            code: 0,
+            lines: [
+                "Nothing to download yet. This video hasn't made any pieces.",
+                `Check where it is: exodus video status ${runId}`,
+            ],
+        };
+    }
+    return {
+        code,
+        lines: [
+            `Pulled ${downloads.length - failures.length + 1} files into ${dir}`,
+            `Every piece is listed in ${manifestPath}.`,
+            ...(manifest.video ? [] : ["The finished video isn't ready yet, so only the scene pieces came down."]),
+            ...(failures.length > 0
+                ? [
+                    "",
+                    `${failures.length} file${failures.length === 1 ? "" : "s"} did not download:`,
+                    ...failures.map((f) => `  ${f.file}: ${f.error}`),
+                    "Run the same command again to retry.",
+                ]
+                : []),
+            "",
+            `When your cut is ready: exodus video upload ${runId} --file cut.mp4`,
+        ],
+    };
+}
 export async function pullFlow(runId, dir, json, deps) {
     const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!runRes.ok)
         return errorResult(runRes, json);
+    const customer = customerAnswer(runRes.data);
+    if (customer)
+        return customerPullFlow(customer, dir, json, deps);
     const run = asVideoRun(runRes.data);
     const itemsRes = await deps.get(`${ITEMS_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!itemsRes.ok)
@@ -1891,7 +2734,23 @@ export async function pullFlow(runId, dir, json, deps) {
     const lines = [
         `Pulled ${wrote} files into ${dir}`,
         `Every piece is indexed in ${path.join(dir, "manifest.json")} — scene numbers there are the run's own.`,
+        ...musicLines(plan.manifest),
     ];
+    for (const sceneIndex of plan.manifest.pendingRedo) {
+        lines.push("", `Scene ${sceneIndex} is being redone right now; its file will change. Run \`exodus video wait ${runId}\`, then pull again.`);
+    }
+    const voiceFirst = plan.manifest.scenes.filter((s) => s.voiceMode === "voice-first");
+    if (voiceFirst.length > 0) {
+        lines.push("", `Redone voice first (the line recorded, then the clip made to match it): ` +
+            `scene${voiceFirst.length === 1 ? "" : "s"} ${voiceFirst.map((s) => s.sceneIndex).join(", ")}`);
+    }
+    const redoneUsualWay = plan.manifest.scenes.filter((s) => s.voiceFirstBlockedBy?.length);
+    if (redoneUsualWay.length > 0) {
+        lines.push("", "Asked for voice first, but redone the usual way:");
+        for (const scene of redoneUsualWay) {
+            lines.push(`  scene ${scene.sceneIndex}: ${cantSayNames(scene.voiceFirstBlockedBy ?? [])}`);
+        }
+    }
     const flagged = plan.manifest.scenes.filter((s) => s.flagged);
     if (flagged.length > 0) {
         lines.push("", `${flagged.length} clip${flagged.length === 1 ? "" : "s"} came back flagged — usable, but look before you cut:`);
@@ -2127,27 +2986,53 @@ export async function uploadFlow(runId, filePath, durationFlag, json, deps) {
     const attached = attaching.value;
     if (!attached.ok)
         return errorResult(attached, json);
+    const customerFinal = customerAnswer(attached.data);
+    if (customerFinal) {
+        const { finalWatchUrl, delivered } = customerFinal;
+        if (json) {
+            return {
+                code: 0,
+                lines: [JSON.stringify({ ok: true, runId, assetId, durationSec, finalWatchUrl, delivered })],
+            };
+        }
+        return {
+            code: 0,
+            lines: [
+                `Uploaded your cut (${durationSec.toFixed(1)}s).${delivered ? " Your video is delivered." : ""}`,
+                `Watch it here: ${finalWatchUrl}`,
+            ],
+        };
+    }
     const final = attached.data;
     const finalWatchUrl = final.finalWatchUrl ?? reviewUrl(deps.dashboardUrl, { _id: runId });
+    const delivered = final.delivered === true;
     if (json) {
         return {
             code: 0,
-            lines: [JSON.stringify({ ok: true, runId, assetId, durationSec, finalWatchUrl })],
+            lines: [JSON.stringify({ ok: true, runId, assetId, durationSec, finalWatchUrl, delivered })],
         };
     }
+    const uploaded = `Uploaded your cut (${durationSec.toFixed(1)}s).`;
     return {
         code: 0,
-        lines: [
-            `Uploaded your cut (${durationSec.toFixed(1)}s).`,
-            `Watch it here: ${finalWatchUrl}`,
-            `Approve it there, or run: exodus video approve ${runId}`,
-        ],
+        lines: delivered
+            ? [`${uploaded} Your ad is delivered.`, `Watch it here: ${finalWatchUrl}`]
+            : [
+                uploaded,
+                `Watch it here: ${finalWatchUrl}`,
+                `Approve it there, or run: exodus video approve ${runId}`,
+            ],
     };
 }
 const VALUE_FLAGS = new Set([
     "show",
     "script",
+    "conceit",
+    "style",
+    "direction",
     "voice-path",
+    "video-model",
+    "voice",
     "note",
     "out",
     "file",
@@ -2200,20 +3085,12 @@ export async function run(flags, occurrences) {
     if (sub === "shows")
         return printResult(await showsFlow(json, defaultDeps));
     if (sub === "start") {
-        const showId = flagString(flags, "show");
-        const scriptFile = flagString(flags, "script");
-        if (!showId)
-            usage("video start needs --show <id>. List them with: exodus video shows");
-        if (!scriptFile)
-            usage("video start needs --script <file>, a text file of what the ad says.");
-        return printResult(await startFlow({
-            showId,
-            scriptFile,
-            voicePath: flagString(flags, "voice-path"),
-            music: flags["music"] === false ? false : undefined,
-            wait: flags["wait"] === true,
-            json,
-        }, defaultDeps));
+        const plan = planVideoStart(flags, occurrences);
+        if (plan.kind === "usage")
+            usage(plan.line);
+        if (plan.kind === "show")
+            return printResult(await startFlow(plan.opts, defaultDeps));
+        return printResult(await startScriptFlow(plan.opts, defaultDeps));
     }
     const runId = rest[0];
     const needsRunId = [
@@ -2227,6 +3104,7 @@ export async function run(flags, occurrences) {
         "voices",
         "pull",
         "upload",
+        "director",
     ];
     if (needsRunId.includes(sub) && !runId) {
         usage(`video ${sub} needs a run id: exodus video ${sub} <runId>`);
@@ -2239,6 +3117,12 @@ export async function run(flags, occurrences) {
     }
     if (sub === "storyboard")
         return printResult(await storyboardFlow(runId, json, defaultDeps));
+    if (sub === "director") {
+        const choice = parseDirectorSwitch(rest[1]);
+        if (!choice)
+            usage(`video director needs on, off or follow: exodus video director ${runId} on`);
+        return printResult(await directorFlow(runId, choice.on, json, defaultDeps));
+    }
     if (sub === "approve") {
         return printResult(await approveFlow(runId, { json, approveStaleCut: flags["approve-stale-cut"] === true }, defaultDeps));
     }
@@ -2249,9 +3133,7 @@ export async function run(flags, occurrences) {
         return printResult(await flagFlow(runId, note, json, defaultDeps));
     }
     if (sub === "retry-frame") {
-        const nodeId = flagString(flags, "node");
-        if (!nodeId)
-            usage("video retry-frame needs --node <nodeId>.");
+        const nodeId = nonBlank(flagString(flags, "node"));
         const sceneRaw = flagString(flags, "scene");
         if (sceneRaw === undefined) {
             usage("video retry-frame needs --scene <n>, the scene index to redo.");
@@ -2271,7 +3153,7 @@ export async function run(flags, occurrences) {
         if (!Number.isInteger(sceneIndex)) {
             usage(`video retry-clip --scene must be a whole scene number, not "${sceneRaw}".`);
         }
-        return printResult(await retryClipFlow(runId, { sceneIndex, nodeId: flagString(flags, "node") }, flagString(flags, "note"), json, defaultDeps));
+        return printResult(await retryClipFlow(runId, { sceneIndex, nodeId: flagString(flags, "node") }, { note: flagString(flags, "note"), voiceFirst: flags["voice-first"] === true }, json, defaultDeps));
     }
     if (sub === "revoice") {
         const sceneRaw = flagString(flags, "scene");