@aicopycoders/exodus 2026.9.2000-beta.0 → 2026.9.2000-beta.10

package/dist/commands/video.js

@@ -6,38 +6,66 @@ 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]}`;
+}
 export const helpText = `
-exodus video — make an ad from a Show, pull every piece, upload your cut
+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.
 
 The whole loop, in order:
 
-  1. exodus video shows
-     Which Shows exist and which are ready to make ads.
+  1. exodus workflow list
+     Which workflows this brand has saved. A video workflow is one that makes
+     ads.
+
+  2. exodus workflow describe <workflowId|name>
+     What that workflow needs before it can run, and what it gives back.
 
-  2. exodus video start --show <id> --script script.txt --wait
-     Starts an ad and waits. It stops when the storyboard needs your yes.
+  3. exodus workflow run <workflowId|name> --input <field>=@script.txt --wait
+     Starts the ad on your script and waits. It stops when the storyboard
+     needs your yes. "describe" names the field your script goes in. You can
+     also settle the voices here, at the launch, instead of at step 5 — the
+     launch flags all live in: exodus workflow --help
 
-  3. exodus video storyboard <runId>
+  4. exodus video storyboard <runId>
      The scene cards: what each scene says and the picture it will look like.
 
-  4. exodus video voices <runId>
+  5. exodus video voices <runId>
      Who is in the ad, which voice each one has, how the voices get applied
      and who pays. Add --set to give someone a voice, before any clip is made.
 
-  5. exodus video approve <runId>          (looks right — keep going)
-     exodus video flag <runId> --note "…"  (something is wrong — send it back)
+  6. exodus video approve <runId>          (looks right — keep going)
      exodus video retry-frame <runId> --node <nodeId> --scene <n>
        Redo ONE still at the pixel gate. Neighbours stay. The gate holds.
 
-  6. exodus video status <runId>
-     Where the run is and how each scene's clip turned out.
+  7. exodus video status <runId>
+     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.
 
-  7. exodus video pull <runId> --out ./ad
+     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>
@@ -50,41 +78,34 @@ The whole loop, in order:
        picture stays, no new video is made, and a clip whose voice pass
        cannot finish is kept as it was. Use --scene <n> for one clip.
 
-  8. Make your cut from those files.
+  9. Make your cut from those files.
 
-  9. exodus video upload <runId> --file cut.mp4
-     Attaches your cut to the run and prints the page to approve it on.
+  10. exodus video upload <runId> --file cut.mp4
+      Attaches your cut to the run and prints the page to approve it on.
 
-  10. exodus video approve <runId>
-      Or click Approve on the page from step 9.
+  11. exodus video approve <runId>
+      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 shows [--json]
-  exodus video start --show <id> --script <file> [--voice-path <v>] [--no-music] [--wait] [--json]
-  exodus video status <runId> [--json]
+  exodus video status <runId> [--rejected-draft] [--json]
   exodus video storyboard <runId> [--json]
-  exodus video approve <runId> [--json]
-  exodus video flag <runId> --note "<what is wrong>" [--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 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:
-  --show <id>          Which Show the ad belongs to (from: exodus video shows)
-  --script <file>      A text file with the words you want the ad to say
-  --voice-path <v>     Override the Show's voice path for this ad
-  --no-music           Skip the music bed
-  --wait               Stay open and report as the run moves; stops at every
-                       point that needs you
   --out <dir>          Folder to write the pulled pieces into (pull)
   --file <cut.mp4>     Your finished cut (upload). MP4, MOV or WebM, up to 200MB
   --duration <sec>     How long your cut is, in seconds. Only needed when the
                        length can't be read off the file itself
-  --note "<text>"      What is wrong with the storyboard (flag), or how to
-                       steer one redo (retry-frame, retry-clip)
+  --note "<text>"      How to steer one redo (retry-frame, retry-clip)
   --node <nodeId>      Which scene-frames node holds the still (retry-frame).
                        Which video step holds the clip, when a scene has one on
                        more than one step (retry-clip, revoice)
@@ -92,21 +113,40 @@ Options:
                        (retry-frame, retry-clip, revoice)
   --all                Every finished clip that kept the video model's voice
                        (revoice)
+  --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           Show this help
+  --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.
 
 Examples:
-  exodus video shows
-  exodus video start --show k57abc --script ./script.txt --wait
+  exodus workflow list
+  exodus workflow describe "Video Ad"
+  exodus workflow run "Video Ad" --input script=@./script.txt --wait
   exodus video storyboard run_123
   exodus video approve run_123
   exodus video retry-frame run_123 --node frames-1 --scene 2
@@ -120,8 +160,12 @@ 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";
@@ -136,6 +180,48 @@ 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, ...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 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 : [] };
@@ -248,6 +334,7 @@ export function classifyRun(run) {
                 ...(pausedNode.kind === "scene-frames"
                     ? { framesNodeId: pausedNode.nodeId }
                     : {}),
+                ...(isShowAd(run) ? { showAd: true } : {}),
             };
         }
         if (parkedAtFinalWatch(run))
@@ -257,6 +344,22 @@ export function classifyRun(run) {
     const active = run.nodes.find((n) => n.status === "running");
     return { at: "running", stage: active?.kind ?? "starting" };
 }
+export function hasAttachedCut(items) {
+    return items.some((i) => i.itemKind === "final" && i.status === "done");
+}
+export function resolveStop(stop, cutAttached) {
+    if (stop.at !== "final-watch")
+        return stop;
+    return { at: "final-watch", cutAttached };
+}
+export async function resolveStopAtPark(stop, runId, deps) {
+    if (stop.at !== "final-watch")
+        return stop;
+    const res = await deps.get(`${ITEMS_PATH}?runId=${encodeURIComponent(runId)}`);
+    if (!res.ok)
+        return resolveStop(stop, null);
+    return resolveStop(stop, hasAttachedCut(res.data.items ?? []));
+}
 const STAGE_WORDS = {
     brief: "reading the script",
     storyboard: "writing the storyboard",
@@ -282,8 +385,11 @@ 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)
+    if (isShowAd(run))
         return `${dashboardUrl}/video?ad=${run._id}`;
     if (run.workflowId)
         return `${dashboardUrl}/workflows/${run.workflowId}/runs/${run._id}`;
@@ -295,14 +401,31 @@ export function stopLines(stop, runId, runUrl) {
             "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.cutAttached === null) {
+            return [
+                "Parked: every piece is made.",
+                `Couldn't check whether a cut is already uploaded. See where it stands: exodus video status ${runId}`,
+                `Watch it here:   ${runUrl}`,
+            ];
+        }
+        if (stop.cutAttached) {
+            return [
+                "Parked: your cut is uploaded and waiting for your approval.",
+                `Approve it:      exodus video approve ${runId}`,
+                `Watch it here:   ${runUrl}`,
+                "Changed your mind? You can still redo a clip and upload a new cut.",
+            ];
+        }
         return [
             "Parked: every piece is made and the run is waiting for a cut.",
             `Pull the pieces: exodus video pull ${runId} --out ./ad-${runId}`,
@@ -313,6 +436,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`,
@@ -338,7 +468,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",
@@ -355,6 +518,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 ?? []);
 }
@@ -384,7 +551,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);
         }
     }
@@ -537,6 +706,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));
         }
     }
@@ -554,7 +725,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: {
@@ -595,6 +766,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;
@@ -604,6 +777,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)) {
@@ -635,7 +810,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);
@@ -670,7 +845,7 @@ 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,
@@ -701,6 +876,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" }
@@ -710,6 +889,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,
+                    },
+                }
+                : {}),
         },
     };
 }
@@ -840,7 +1027,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);
@@ -869,6 +1056,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) {
@@ -894,15 +1339,16 @@ export async function waitFlow(runId, opts, deps) {
             }
             continue;
         }
+        const resolved = await resolveStopAtPark(stop, runId, deps);
         if (opts.json) {
             return {
                 code: stop.at === "failed" ? 1 : 0,
-                lines: [JSON.stringify({ runId, stop, status: run.status, url: opts.url })],
+                lines: [JSON.stringify({ runId, stop: resolved, status: run.status, url: opts.url })],
             };
         }
         return {
             code: stop.at === "failed" ? 1 : 0,
-            lines: [...lines, ...stopLines(stop, runId, reviewUrl(deps.dashboardUrl, run))],
+            lines: [...lines, ...stopLines(resolved, runId, reviewUrl(deps.dashboardUrl, run))],
         };
     }
     const timeoutLine = `Still running after ${Math.round((maxPolls * interval) / 60000)} minutes. Check in with: exodus video status ${runId}`;
@@ -927,6 +1373,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)
@@ -936,15 +1387,35 @@ export async function statusFlow(runId, json, deps) {
     if (!itemsRes.ok)
         return errorResult(itemsRes, json);
     const items = itemsRes.data.items ?? [];
-    const stop = classifyRun(run);
-    const hasFinal = items.some((i) => i.itemKind === "final" && i.status === "done");
+    const hasFinal = hasAttachedCut(items);
+    const stop = resolveStop(classifyRun(run), hasFinal);
+    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 }));
     if (json) {
         return {
             code: 0,
-            lines: [JSON.stringify({ runId, status: run.status, stop, items, hasFinal, warnings })],
+            lines: [
+                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();
@@ -975,8 +1446,10 @@ export async function statusFlow(runId, json, deps) {
         : `Ad run ${runId} — ${displayRunStatus(run.status)}`;
     const lines = [
         headline,
-        ...stopLines(stop, runId, reviewUrl(deps.dashboardUrl, run)),
+        ...(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) {
@@ -987,6 +1460,21 @@ 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}`);
+                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: ${row.voiceover.lastRedo.label}`);
+                printDisplacedHistory(lines, row.voiceover.lastRedo);
+            }
+            if (row.frame?.lastRedo)
+                lines.push(`       picture: ${row.frame.lastRedo.label}`);
             for (const finding of row.clip?.findings ?? []) {
                 lines.push(`       ${finding.code} (${finding.severity}): ${finding.detail}`);
                 const judgeSeverity = finding.judgeSeverity ?? finding.severity;
@@ -1019,6 +1507,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)
@@ -1070,7 +1597,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>`);
     }
@@ -1098,14 +1632,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 : [])
         : [];
@@ -1113,6 +1663,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}`,
         ],
@@ -1170,8 +1721,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);
@@ -1204,7 +1756,7 @@ export function planClipRedo(run, items, target) {
     };
 }
 function findClipRow(run, items, target) {
-    const uploadedCut = items.some((i) => i.itemKind === "final" && i.status === "done");
+    const uploadedCut = hasAttachedCut(items);
     const rows = items.filter((i) => i.itemKind === "clip" &&
         i.sceneIndex === target.sceneIndex &&
         (target.nodeId === undefined || i.nodeId === target.nodeId));
@@ -1603,6 +2155,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)
@@ -1646,6 +2205,7 @@ 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 flagged = plan.manifest.scenes.filter((s) => s.flagged);
     if (flagged.length > 0) {
@@ -1902,7 +2462,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",
@@ -1955,20 +2520,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 = [
@@ -1986,12 +2543,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)