@aicopycoders/exodus 2026.9.2000-beta.2 → 2026.9.2000-beta.20

package/dist/commands/video.js

@@ -6,11 +6,30 @@ import { displayRunStatus, formatApiError } from "../lib/format.js";
 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";
+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.
 
@@ -41,14 +60,22 @@ The whole loop, in order:
        Redo ONE still at the pixel gate. Neighbours stay. The gate holds.
 
   7. exodus video status <runId>
-     Where the run is and how each scene's clip turned out.
+     Where the run is and how each scene's clip turned out. If the storyboard
+     failed, it also says which parts of it were accepted and why the next one
+     was turned down.
+
+     exodus video status <runId> --rejected-draft
+       Prints the storyboard draft that was turned down. A record of what
+       happened, thrown away by the system — never something to act on.
 
   8. exodus video pull <runId> --out ./ad
      Writes every piece to that folder plus a manifest.json index.
 
      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
@@ -62,18 +89,21 @@ The whole loop, in order:
       Attaches your cut to the run and prints the page to approve it on.
 
   11. exodus video approve <runId>
-      Or click Approve on the page from step 10.
+      Or click Approve on the page from step 10. If you redid a clip after
+      uploading, this stops and says which scenes changed. Upload a fresh cut,
+      or add --approve-stale-cut to deliver the cut you already uploaded.
 
 Usage:
-  exodus video status <runId> [--json]
+  exodus video status <runId> [--rejected-draft] [--json]
   exodus video storyboard <runId> [--json]
-  exodus video approve <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-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] [--wait] [--json]
 
 Options:
   --out <dir>          Folder to write the pulled pieces into (pull)
@@ -88,12 +118,33 @@ Options:
                        (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
   --set <who>=<id>     Give a character an ElevenLabs voice (voices). Name the
                        character by its ID or by the name your script uses.
                        Repeat it once per character
   --clear <who>        Take a character's voice off again (voices). Repeatable
   --from <file.json>   A file of characters and voice IDs (voices). --set and
                        --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>       native: the video model speaks the lines. voice-first:
+                       the lines are recorded first (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
+  --wait               Wait until the storyboard needs a yes (start)
   --json               Machine-readable output
   --help, -h           Print this help
 
@@ -108,6 +159,7 @@ 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"
@@ -117,13 +169,20 @@ Examples:
 `.trim();
 const SHOWS_PATH = "/api/v2/shows";
 const RUNS_PATH = "/api/v2/video/runs";
+const SCRIPT_RUNS_PATH = "/api/v2/video/script-runs";
 const RUN_PATH = "/api/v2/workflow";
 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.";
 const STORYBOARD_PATH = "/api/v2/video/storyboard";
 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";
@@ -133,6 +192,51 @@ const ASSETS_PATH = "/api/v2/workflows/assets";
 function withoutJudgeFields({ judgeDetail: _d, judgeSeverity: _s, ...rest }) {
     return rest;
 }
+export function qcWithoutJudgeWording(qc) {
+    if (!qc.takes)
+        return qc;
+    return {
+        ...qc,
+        takes: qc.takes.map(({ judgeWording: _w, heardText: _h, ...rest }) => rest),
+    };
+}
+export const NO_TAKE_HISTORY_LINE = "no history recorded for this clip";
+const TAKE_NEIGHBOUR_SENTENCE = {
+    "not-applicable": () => "never compared",
+    "not-attached": () => "no neighbours attached",
+    "none-accepted": () => "no accepted neighbours yet",
+    attached: ({ scenes }) => `compared against scene${scenes.length === 1 ? "" : "s"} ${scenes.join(", ")}`,
+};
+export function renderQcTakeHistory(takes) {
+    if (!takes || takes.length === 0)
+        return [NO_TAKE_HISTORY_LINE];
+    const lines = [];
+    takes.forEach((take, index) => {
+        const say = TAKE_NEIGHBOUR_SENTENCE[take.neighbours.state];
+        const parts = [
+            take.failCodes.length ? `failed ${take.failCodes.join(", ")}` : "passed",
+            ...(take.warnCodes.length ? [`warned ${take.warnCodes.join(", ")}`] : []),
+            say(take.neighbours),
+        ];
+        const bonus = take.kind === "soft-retry" ? " (bonus take)" : "";
+        lines.push(`take ${index + 1}${bonus}: ${parts.join("; ")}`);
+        for (const { code, wording } of take.judgeWording ?? []) {
+            lines.push(`  checker said (${code}): ${wording}`);
+        }
+    });
+    return lines;
+}
+function redoLine(lastRedo) {
+    return lastRedo.reason ? `${lastRedo.label}: ${lastRedo.reason}` : lastRedo.label;
+}
+function printDisplacedHistory(lines, lastRedo) {
+    const history = lastRedo.displacedHistory;
+    if (!history)
+        return;
+    lines.push(`       ${history.title}`);
+    for (const line of history.lines)
+        lines.push(`         ${line}`);
+}
 export function asVideoRun(data) {
     const run = (data ?? {});
     return { ...run, nodes: Array.isArray(run.nodes) ? run.nodes : [] };
@@ -245,10 +349,20 @@ export function classifyRun(run) {
                 ...(pausedNode.kind === "scene-frames"
                     ? { framesNodeId: pausedNode.nodeId }
                     : {}),
+                ...(isShowAd(run) ? { showAd: true } : {}),
+            };
+        }
+        if (parkedAtFinalWatch(run)) {
+            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");
@@ -260,7 +374,7 @@ export function hasAttachedCut(items) {
 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")
@@ -295,27 +409,57 @@ export function stepName(kind) {
         return "A step in this run";
     return STEP_NAMES[kind] ?? `The ${kind} step`;
 }
+export function isShowAd(run) {
+    return run.moduleOwned === true;
+}
 export function reviewUrl(dashboardUrl, run) {
-    if (run.moduleOwned === true)
-        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 = [
             "Parked: the storyboard is waiting for your yes.",
             `Read it:    exodus video storyboard ${runId}`,
             `Approve it: exodus video approve ${runId}`,
-            `Send back:  exodus video flag ${runId} --note "what's wrong"`,
         ];
+        if (stop.showAd) {
+            lines.push(`Send back:  exodus video flag ${runId} --note "what's wrong"`);
+        }
         if (stop.framesNodeId) {
             lines.push(`Redo one frame: exodus video retry-frame ${runId} --node ${stop.framesNodeId} --scene <n>`);
         }
         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.",
@@ -341,6 +485,13 @@ export function stopLines(stop, runId, runUrl) {
     }
     if (stop.at === "failed") {
         if (stop.repair) {
+            if (!stop.step) {
+                return [
+                    "This run stopped at a step that can't be picked back up from here.",
+                    "Start a fresh run to get this ad made.",
+                    `Open the run:        ${runUrl}`,
+                ];
+            }
             return [
                 `${stepName(stop.step)} failed${stop.error ? `: ${stop.error}` : "."}`,
                 `Try that step again: exodus workflow repair ${runId} retry`,
@@ -366,7 +517,40 @@ export function stopLines(stop, runId, runUrl) {
     }
     return [`Working: ${stageWord(stop.stage)}.`];
 }
-export const CAST_LEDGER_BASE = 910000;
+export function failedStoryboardNode(run) {
+    return run.nodes.find((n) => n.kind === "storyboard" && n.status === "failed");
+}
+export function errorEchoesReasons(error, record) {
+    if (!error || record?.kind !== "rejected")
+        return false;
+    const reasons = record.reasons ?? [];
+    return reasons.length > 0 && reasons.every((reason) => error.includes(reason));
+}
+export function planFailureLines(node, runId) {
+    const record = node?.planFailure;
+    if (!record || !Array.isArray(record.lines) || !node)
+        return [];
+    const reasons = record.kind === "rejected" ? (record.reasons ?? []) : [];
+    const bodyCount = Math.max(0, record.lines.length - reasons.length);
+    const lines = [`What happened to the storyboard step (${node.nodeId}):`];
+    record.lines.forEach((line, i) => {
+        lines.push(i < bodyCount ? `  ${line}` : `    - ${line}`);
+    });
+    if (node?.hasRejectedDraft === true) {
+        lines.push("  A rejected draft is on file. The system threw it away, so it is a record of what happened and nothing to act on.", `  Read it: exodus video status ${runId} --rejected-draft`);
+    }
+    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;
+}
 const FALLBACK_EXT = {
     image: "png",
     video: "mp4",
@@ -383,6 +567,10 @@ function extFor(url, family) {
 export function scenePrefix(sceneIndex) {
     return `scene-${String(sceneIndex).padStart(2, "0")}`;
 }
+function clipQcOf(item) {
+    const artifact = item?.artifact;
+    return artifact && artifact.type === "video" ? artifact.qc?.takes : undefined;
+}
 function outputsOfNodeKind(run, kind) {
     return run.nodes.filter((n) => n.kind === kind).flatMap((n) => n.outputs ?? []);
 }
@@ -401,6 +589,8 @@ function clipFromArtifact(sceneIndex, artifact) {
         revoiced: artifact.revoiced === true,
         speechTrimmed: artifact.speechTrimmed === true,
         rawStorageId: artifact.rawStorageId ?? null,
+        voiceMode: artifact.voiceMode ?? null,
+        voiceFirstBlockedBy: artifact.voiceFirstBlockedBy ?? null,
     };
 }
 function keyframeDownload(sceneIndex, imageUrl) {
@@ -412,7 +602,9 @@ function keyframeDownload(sceneIndex, imageUrl) {
 function reservedCastFrames(items) {
     const byIndex = new Map();
     for (const item of items) {
-        if (item.itemKind === "frame" && item.sceneIndex >= CAST_LEDGER_BASE) {
+        if (item.itemKind === "frame" &&
+            item.sceneIndex >= CAST_LEDGER_BASE &&
+            item.sceneIndex < SET_OPTION_LEDGER_BASE) {
             byIndex.set(item.sceneIndex, item);
         }
     }
@@ -565,6 +757,8 @@ export function planPull(run, items, opts) {
         for (const frame of artifact.frames ?? []) {
             if (!frame.imageUrl)
                 continue;
+            if (!isPullSceneIndex(frame.sceneIndex))
+                continue;
             keyframeByScene.set(frame.sceneIndex, keyframeDownload(frame.sceneIndex, frame.imageUrl));
         }
     }
@@ -582,7 +776,7 @@ export function planPull(run, items, opts) {
             };
             continue;
         }
-        if (typeof artifact.sceneIndex !== "number" || artifact.sceneIndex < 0)
+        if (typeof artifact.sceneIndex !== "number" || !isPullSceneIndex(artifact.sceneIndex))
             continue;
         voiceByScene.set(artifact.sceneIndex, {
             download: {
@@ -623,6 +817,8 @@ export function planPull(run, items, opts) {
         }
         if (artifact.type !== "video" || typeof artifact.sceneIndex !== "number")
             continue;
+        if (!isPullSceneIndex(artifact.sceneIndex))
+            continue;
         const clip = clipFromArtifact(artifact.sceneIndex, artifact);
         if (!clip)
             continue;
@@ -632,6 +828,8 @@ export function planPull(run, items, opts) {
     const frameItemByScene = new Map();
     const sceneFrameNodeIds = new Set(run.nodes.filter((n) => n.kind === "scene-frames").map((n) => n.nodeId));
     for (const item of items) {
+        if (!isPullSceneIndex(item.sceneIndex))
+            continue;
         if (item.itemKind === "clip")
             clipItemByScene.set(item.sceneIndex, item);
         if (item.itemKind === "frame" && sceneFrameNodeIds.has(item.nodeId)) {
@@ -663,7 +861,7 @@ export function planPull(run, items, opts) {
             ...frameItemByScene.keys(),
         ]),
     ]
-        .filter((sceneIndex) => sceneIndex >= 0 && sceneIndex < CAST_LEDGER_BASE)
+        .filter((sceneIndex) => isPullSceneIndex(sceneIndex))
         .sort((a, b) => a - b);
     const scenes = sceneIndexes.map((sceneIndex) => {
         const clip = clipByScene.get(sceneIndex);
@@ -698,10 +896,12 @@ export function planPull(run, items, opts) {
                     : "this-file",
             voice: voice?.download.file ?? null,
             keyframe: keyframeByScene.get(sceneIndex)?.file ?? null,
-            qc: clip?.qc ?? null,
+            qc: clip?.qc ? qcWithoutJudgeWording(clip.qc) : null,
             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,
             clipStatus: item?.status ?? "missing",
             error: item?.error ?? null,
             flagged: item?.flagged === true,
@@ -729,6 +929,10 @@ export function planPull(run, items, opts) {
             storyboard,
             reference: reference?.file ?? null,
             music: music?.file ?? null,
+            musicBed: musicBedState(run),
+            musicHeardScenes: scenes
+                .filter((scene) => scene.findings.some((f) => f.code === MUSIC_HEARD_CODE))
+                .map((scene) => scene.sceneIndex),
             cast,
             narration: narrationDownload
                 ? { file: narrationDownload.file, timing: "narration.json" }
@@ -738,6 +942,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,
+                    },
+                }
+                : {}),
         },
     };
 }
@@ -763,6 +975,8 @@ export function markPullFailure(manifest, failure) {
             scene.revoiced = null;
             scene.speechTrimmed = null;
             scene.rawStorageId = null;
+            scene.voiceMode = null;
+            scene.voiceFirstBlockedBy = null;
         }
         if (scene.voice === failure.file)
             scene.voice = null;
@@ -868,7 +1082,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);
@@ -897,6 +1111,264 @@ 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;
+    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;
+    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) {
+    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}`] : []),
+        `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 } : {}),
+    });
+    if (!res.ok)
+        return errorResult(res, opts.json);
+    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),
+                    "",
+                    "Wait for the storyboard here instead: 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), "", ...waited.lines],
+    };
+}
 const POLL_INTERVAL_MS = 5000;
 const MAX_POLLS = 720;
 export async function waitFlow(runId, opts, deps) {
@@ -956,6 +1428,11 @@ function itemWord(item) {
         return "flagged";
     return ITEM_STATUS_WORD[item.status] ?? item.status;
 }
+const CARRYING_ON_LINE = "Waiting for a worker to carry on. Everything finished so far is kept — the run picks up from there by itself.";
+function carryingOn(run) {
+    return (run.status === "queued" &&
+        run.nodes.some((n) => n.status !== "idle" && n.status !== "out-of-scope"));
+}
 export async function statusFlow(runId, json, deps) {
     const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!runRes.ok)
@@ -967,7 +1444,10 @@ export async function statusFlow(runId, json, deps) {
     const items = itemsRes.data.items ?? [];
     const hasFinal = hasAttachedCut(items);
     const stop = resolveStop(classifyRun(run), hasFinal);
-    const guidance = stopLines(stop, runId, reviewUrl(deps.dashboardUrl, run));
+    const failedStoryboard = failedStoryboardNode(run);
+    const guidance = stopLines(stop.at === "failed" && errorEchoesReasons(stop.error, failedStoryboard?.planFailure)
+        ? { ...stop, error: undefined }
+        : stop, runId, reviewUrl(deps.dashboardUrl, run));
     const warnings = run.nodes
         .filter((n) => n.warning)
         .map((n) => ({ nodeId: n.nodeId, step: n.kind, warning: n.warning }));
@@ -975,13 +1455,39 @@ export async function statusFlow(runId, json, deps) {
         return {
             code: 0,
             lines: [
-                JSON.stringify({ runId, status: run.status, stop, items, hasFinal, warnings, guidance }),
+                JSON.stringify({
+                    runId,
+                    status: run.status,
+                    stop,
+                    items,
+                    hasFinal,
+                    warnings,
+                    guidance,
+                    ...(run.musicBed === undefined ? {} : { musicBed: run.musicBed }),
+                    ...(failedStoryboard?.planFailure ? { planFailure: failedStoryboard.planFailure } : {}),
+                    ...(failedStoryboard?.planFailure
+                        ? { storyboardNodeId: failedStoryboard.nodeId }
+                        : {}),
+                    ...(failedStoryboard?.hasRejectedDraft === true ? { hasRejectedDraft: true } : {}),
+                }),
             ],
         };
     }
     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)
@@ -1007,8 +1513,10 @@ export async function statusFlow(runId, json, deps) {
         : `Ad run ${runId} — ${displayRunStatus(run.status)}`;
     const lines = [
         headline,
+        ...(carryingOn(run) ? [CARRYING_ON_LINE] : []),
         ...guidance,
         ...(stop.at === "running" && run.pauseAhead ? [pauseAheadLine(run.pauseAhead)] : []),
+        ...planFailureLines(failedStoryboard, runId),
         ...warnings.map((w) => `Heads-up (${w.step}): ${w.warning}`),
     ];
     if (byScene.size === 0) {
@@ -1019,10 +1527,19 @@ export async function statusFlow(runId, json, deps) {
         for (const sceneIndex of [...byScene.keys()].sort((a, b) => a - b)) {
             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}`);
-            if (row.voiceover?.lastRedo)
-                lines.push(`       voice: ${row.voiceover.lastRedo.label}`);
+            if (row.clip?.lastRedo) {
+                lines.push(`       clip: ${redoLine(row.clip.lastRedo)}`);
+                printDisplacedHistory(lines, row.clip.lastRedo);
+            }
+            if (row.clip?.lastRedo || row.clip?.flagged) {
+                for (const line of renderQcTakeHistory(clipQcOf(row.clip))) {
+                    lines.push(`       ${line}`);
+                }
+            }
+            if (row.voiceover?.lastRedo) {
+                lines.push(`       voice: ${redoLine(row.voiceover.lastRedo)}`);
+                printDisplacedHistory(lines, row.voiceover.lastRedo);
+            }
             if (row.frame?.lastRedo)
                 lines.push(`       picture: ${row.frame.lastRedo.label}`);
             for (const finding of row.clip?.findings ?? []) {
@@ -1039,6 +1556,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)");
             }
@@ -1057,6 +1580,45 @@ export async function statusFlow(runId, json, deps) {
             : "Final cut: not uploaded yet.");
     return { code: 0, lines };
 }
+export async function rejectedDraftFlow(runId, json, deps) {
+    const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
+    if (!runRes.ok)
+        return errorResult(runRes, 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.";
+        return {
+            code: 0,
+            lines: json ? [JSON.stringify({ runId, nodeId: null, draft: null })] : [note],
+        };
+    }
+    const res = await deps.get(`${REJECTED_DRAFT_PATH}?runId=${encodeURIComponent(runId)}&nodeId=${encodeURIComponent(node.nodeId)}`);
+    if (missingRouteLine(res, "exodus video status --rejected-draft")) {
+        return {
+            code: 1,
+            lines: json
+                ? [JSON.stringify({ ok: false, status: 404, error: REJECTED_DRAFT_NOT_ON_THIS_SERVER })]
+                : [REJECTED_DRAFT_NOT_ON_THIS_SERVER],
+        };
+    }
+    if (!res.ok)
+        return errorResult(res, json);
+    const draft = res.data.draft ?? null;
+    if (json)
+        return { code: 0, lines: [JSON.stringify({ runId, nodeId: node.nodeId, draft })] };
+    if (!draft)
+        return { code: 0, lines: ["No rejected draft was kept for this attempt."] };
+    return {
+        code: 0,
+        lines: [
+            `REJECTED DRAFT — ad run ${runId}, step ${node.nodeId}`,
+            "The system turned this draft down and threw it away. It is kept only as a record of what happened.",
+            "Nothing in it is part of your ad. There is nothing here to act on or edit.",
+            "",
+            ...draft.split("\n"),
+        ],
+    };
+}
 export async function storyboardFlow(runId, json, deps) {
     const res = await deps.get(`${STORYBOARD_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!res.ok)
@@ -1108,7 +1670,14 @@ export async function storyboardFlow(runId, json, deps) {
             }
         }
     }
-    lines.push("", `approve with: exodus video approve ${runId}`, `send it back: exodus video flag ${runId} --note "what's wrong"`);
+    const runRes = await deps
+        .get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`)
+        .catch(() => null);
+    const showAd = runRes?.ok === true && isShowAd(asVideoRun(runRes.data));
+    lines.push("", `approve with: exodus video approve ${runId}`);
+    if (showAd) {
+        lines.push(`send it back: exodus video flag ${runId} --note "what's wrong"`);
+    }
     if (cards.framesNodeId) {
         lines.push(`redo one frame: exodus video retry-frame ${runId} --node ${cards.framesNodeId} --scene <n>`);
     }
@@ -1136,14 +1705,30 @@ function sceneCardLines(scene) {
         lines.push(`    picture: ${scene.frame.status}`);
     return lines;
 }
-export async function approveFlow(runId, json, deps) {
-    const res = await deps.post(APPROVE_PATH, { runId });
-    if (!res.ok)
-        return errorResult(res, json);
-    if (json)
-        return { code: 0, lines: [JSON.stringify({ ok: true, runId, data: res.data })] };
-    const voices = res.data
-        ?.voices;
+export async function approveFlow(runId, opts, deps) {
+    const res = await deps.post(APPROVE_PATH, {
+        runId,
+        ...(opts.approveStaleCut ? { approveStaleCut: true } : {}),
+    });
+    if (!res.ok) {
+        const refusal = errorResult(res, opts.json);
+        const staleCut = !opts.json && videoApiError(res).includes("approve this cut anyway");
+        return staleCut
+            ? {
+                ...refusal,
+                lines: [
+                    ...refusal.lines,
+                    `To deliver it anyway: exodus video approve ${runId} --approve-stale-cut`,
+                ],
+            }
+            : refusal;
+    }
+    const data = res.data;
+    const warnings = Array.isArray(data?.warnings) ? data.warnings : [];
+    if (opts.json) {
+        return { code: 0, lines: [JSON.stringify({ ok: true, runId, warnings, data: res.data })] };
+    }
+    const voices = data?.voices;
     const summary = voices
         ? voiceSummaryLines(Array.isArray(voices.cast) ? voices.cast : [], Array.isArray(voices.notices) ? voices.notices : [])
         : [];
@@ -1151,6 +1736,7 @@ export async function approveFlow(runId, json, deps) {
         code: 0,
         lines: [
             "Approved.",
+            ...warnings,
             ...(summary.length > 0 ? ["", ...summary, ""] : []),
             `See what happens next: exodus video status ${runId}`,
         ],
@@ -1208,8 +1794,9 @@ export async function retryFrameFlow(runId, nodeId, sceneIndex, note, json, deps
         ],
     };
 }
-const UPLOADED_CUT_WARNING = "The cut you already uploaded will not include the new clip. Pull the pieces again, " +
-    "re-cut, and upload again.";
+const UPLOADED_CUT_WARNING = "The cut you already uploaded will not include the new clip. If this redo replaces the clip, " +
+    "exodus video approve stops until you pull the pieces again, re-cut and upload again, " +
+    "or pass --approve-stale-cut to deliver the cut you uploaded as it is.";
 export function planClipRedo(run, items, target) {
     const stop = classifyRun(run);
     const found = findClipRow(run, items, target);
@@ -1275,7 +1862,7 @@ 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);
@@ -1291,12 +1878,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;
@@ -1315,6 +1910,7 @@ export async function retryClipFlow(runId, target, note, json, deps) {
                     reviewUrl: review,
                     warnings: plan.warnings,
                     ...(note ? { note } : {}),
+                    ...(voiceFirst ? { voiceMode: "voice-first" } : {}),
                 }),
             ],
         };
@@ -1322,9 +1918,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."]
                 : []),
@@ -1641,6 +2247,13 @@ 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 async function pullFlow(runId, dir, json, deps) {
     const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!runRes.ok)
@@ -1684,7 +2297,20 @@ 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),
     ];
+    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:`);
@@ -1940,7 +2566,12 @@ export async function uploadFlow(runId, filePath, durationFlag, json, deps) {
 const VALUE_FLAGS = new Set([
     "show",
     "script",
+    "conceit",
+    "style",
+    "direction",
     "voice-path",
+    "video-model",
+    "voice",
     "note",
     "out",
     "file",
@@ -1993,20 +2624,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 = [
@@ -2024,12 +2647,17 @@ export async function run(flags, occurrences) {
     if (needsRunId.includes(sub) && !runId) {
         usage(`video ${sub} needs a run id: exodus video ${sub} <runId>`);
     }
-    if (sub === "status")
+    if (sub === "status") {
+        if (flags["rejected-draft"] !== undefined && flags["rejected-draft"] !== false) {
+            return printResult(await rejectedDraftFlow(runId, json, defaultDeps));
+        }
         return printResult(await statusFlow(runId, json, defaultDeps));
+    }
     if (sub === "storyboard")
         return printResult(await storyboardFlow(runId, json, defaultDeps));
-    if (sub === "approve")
-        return printResult(await approveFlow(runId, json, defaultDeps));
+    if (sub === "approve") {
+        return printResult(await approveFlow(runId, { json, approveStaleCut: flags["approve-stale-cut"] === true }, defaultDeps));
+    }
     if (sub === "flag") {
         const note = flagString(flags, "note");
         if (!note)
@@ -2059,7 +2687,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");