@aicopycoders/exodus 2026.9.1700-beta.1 → 2026.9.1900-beta.0

package/dist/commands/video.js

@@ -25,24 +25,32 @@ The whole loop, in order:
   3. exodus video storyboard <runId>
      The scene cards: what each scene says and the picture it will look like.
 
-  4. exodus video approve <runId>          (looks right — keep going)
+  4. 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)
      exodus video retry-frame <runId> --node <nodeId> --scene <n>
        Redo ONE still at the pixel gate. Neighbours stay. The gate holds.
 
-  5. exodus video status <runId>
+  6. exodus video status <runId>
      Where the run is and how each scene's clip turned out.
 
-  6. exodus video pull <runId> --out ./ad
+  7. exodus video pull <runId> --out ./ad
      Writes every piece to that folder plus a manifest.json index.
 
-  7. Make your cut from those files.
+     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.
+
+  8. Make your cut from those files.
 
-  8. exodus video upload <runId> --file cut.mp4
+  9. exodus video upload <runId> --file cut.mp4
      Attaches your cut to the run and prints the page to approve it on.
 
-  9. exodus video approve <runId>
-     Or click Approve on the page from step 8.
+  10. exodus video approve <runId>
+      Or click Approve on the page from step 9.
 
 Usage:
   exodus video shows [--json]
@@ -52,6 +60,8 @@ Usage:
   exodus video approve <runId> [--json]
   exodus video flag <runId> --note "<what is wrong>" [--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 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]
 
@@ -67,9 +77,18 @@ Options:
   --duration <sec>     How long your cut is, in seconds. Only needed when the
                        length can't be read off the file itself
   --note "<text>"      What is wrong with the storyboard (flag), or how to
-                       steer one frame redo (retry-frame)
-  --node <nodeId>      Which scene-frames node holds the still (retry-frame)
-  --scene <n>          Which scene's frame to redo. One scene only (retry-frame)
+                       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)
+  --scene <n>          Which scene to redo. One scene only, a whole number
+                       (retry-frame, retry-clip)
+  --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
   --json               Machine-readable output
   --help, -h           Show this help
 
@@ -82,6 +101,10 @@ Examples:
   exodus video storyboard run_123
   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 voices run_123
+  exodus video voices run_123 --set C1=abc123voiceid --set "HOST 2=def456voiceid"
+  exodus video voices run_123 --from voices.json
   exodus video pull run_123 --out ./ad-run_123
   exodus video upload run_123 --file ./cut.mp4
 `.trim();
@@ -94,6 +117,7 @@ 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 FINAL_PATH = "/api/v2/video/final";
+export const VOICES_PATH = "/api/v2/video/voices";
 const ASSET_UPLOAD_URL_PATH = "/api/v2/workflows/asset-upload-url";
 const ASSETS_PATH = "/api/v2/workflows/assets";
 function withoutJudgeFields({ judgeDetail: _d, judgeSeverity: _s, ...rest }) {
@@ -245,7 +269,14 @@ export function stepName(kind) {
         return "A step in this run";
     return STEP_NAMES[kind] ?? `The ${kind} step`;
 }
-export function stopLines(stop, runId, dashboardUrl) {
+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}`;
+}
+export function stopLines(stop, runId, runUrl) {
     if (stop.at === "storyboard-gate") {
         const lines = [
             "Parked: the storyboard is waiting for your yes.",
@@ -263,6 +294,8 @@ export function stopLines(stop, runId, dashboardUrl) {
             "Parked: every piece is made and the run is waiting for a cut.",
             `Pull the pieces: exodus video pull ${runId} --out ./ad-${runId}`,
             `Then upload:     exodus video upload ${runId} --file cut.mp4`,
+            `Redo one clip:   exodus video retry-clip ${runId} --scene <n>`,
+            `Watch it here:   ${runUrl}`,
         ];
     }
     if (stop.at === "failed") {
@@ -270,7 +303,7 @@ export function stopLines(stop, runId, dashboardUrl) {
             return [
                 `${stepName(stop.step)} failed${stop.error ? `: ${stop.error}` : "."}`,
                 `Try that step again: exodus workflow repair ${runId} retry`,
-                `Or open the run:     ${dashboardUrl}/video?ad=${runId}`,
+                `Or open the run:     ${runUrl}`,
             ];
         }
         return [
@@ -287,7 +320,7 @@ export function stopLines(stop, runId, dashboardUrl) {
     if (stop.at === "paused") {
         return [
             `Parked: this run is waiting on someone${stop.reason ? ` (${stop.reason})` : ""}.`,
-            `Open it: ${dashboardUrl}/video?ad=${runId}`,
+            `Open it: ${runUrl}`,
         ];
     }
     return [`Working: ${stageWord(stop.stage)}.`];
@@ -343,7 +376,31 @@ function reservedCastFrames(items) {
     }
     return byIndex;
 }
-function planCastRefs(run, items) {
+function castVoicePins(artifact) {
+    const pins = new Map();
+    let envelope = artifact?.storyboard;
+    if (envelope === undefined && typeof artifact?.storyboardJson === "string") {
+        try {
+            envelope = JSON.parse(artifact.storyboardJson);
+        }
+        catch {
+            return pins;
+        }
+    }
+    const cast = envelope?.cast;
+    if (!Array.isArray(cast))
+        return pins;
+    for (const member of cast) {
+        const characterId = typeof member.characterId === "string" ? member.characterId.trim() : "";
+        const voiceId = typeof member.voiceId === "string" ? member.voiceId.trim() : "";
+        if (!characterId || !voiceId)
+            continue;
+        const label = typeof member.voiceLabel === "string" ? member.voiceLabel.trim() : "";
+        pins.set(characterId, { voiceId, voiceLabel: label ? label : null });
+    }
+    return pins;
+}
+function planCastRefs(run, items, pins) {
     const ledger = reservedCastFrames(items);
     const ledgerRows = [...ledger.entries()].sort(([a], [b]) => a - b);
     const locked = run.castLock?.cast;
@@ -407,12 +464,15 @@ function planCastRefs(run, items) {
     const downloads = [];
     for (const row of rows) {
         const file = row.url ? `${row.stem}.${extFor(row.url, "image")}` : null;
+        const pin = row.characterId ? pins.get(row.characterId) : undefined;
         cast.push({
             characterId: row.characterId,
             name: row.name,
             file,
             status: row.status,
             error: row.error,
+            voiceId: pin?.voiceId ?? null,
+            voiceLabel: pin?.voiceLabel ?? null,
         });
         if (file && row.url)
             downloads.push({ file, url: row.url });
@@ -583,6 +643,11 @@ export function planPull(run, items, opts) {
             clip: clip?.download.file ?? null,
             words,
             wordsFrom,
+            wordsDescribe: wordsFrom === null
+                ? null
+                : clip?.revoiced === true && wordsFrom === "clip"
+                    ? "original-performance"
+                    : "this-file",
             voice: voice?.download.file ?? null,
             keyframe: keyframeByScene.get(sceneIndex)?.file ?? null,
             qc: clip?.qc ?? null,
@@ -595,7 +660,7 @@ export function planPull(run, items, opts) {
             keyframeFindings: frameItem?.findings?.map(withoutJudgeFields) ?? null,
         };
     });
-    const { cast, downloads: castDownloads } = planCastRefs(run, items);
+    const { cast, downloads: castDownloads } = planCastRefs(run, items, castVoicePins(storyboardArtifact));
     const downloads = [
         ...(reference ? [reference] : []),
         ...keyframeByScene.values(),
@@ -611,7 +676,7 @@ export function planPull(run, items, opts) {
         manifest: {
             runId: run._id,
             pulledAt: opts.pulledAt,
-            dashboardUrl: `${opts.dashboardUrl}/video?ad=${run._id}`,
+            dashboardUrl: reviewUrl(opts.dashboardUrl, run),
             storyboard,
             reference: reference?.file ?? null,
             music: music?.file ?? null,
@@ -653,6 +718,7 @@ export function markPullFailure(manifest, failure) {
         if (scene.words === failure.file || lostWordsSource) {
             scene.words = null;
             scene.wordsFrom = null;
+            scene.wordsDescribe = null;
         }
     }
 }
@@ -758,7 +824,7 @@ export async function startFlow(opts, deps) {
         return { code: 1, lines: ["The server started the ad but did not say which run it is."] };
     }
     const runId = started.runId;
-    const url = started.url ?? `${deps.dashboardUrl}/video?ad=${runId}`;
+    const url = started.url ?? reviewUrl(deps.dashboardUrl, { _id: runId });
     if (!opts.wait) {
         const lines = [
             `Started ad run ${runId}`,
@@ -811,7 +877,7 @@ export async function waitFlow(runId, opts, deps) {
         }
         return {
             code: stop.at === "failed" ? 1 : 0,
-            lines: [...lines, ...stopLines(stop, runId, deps.dashboardUrl)],
+            lines: [...lines, ...stopLines(stop, runId, reviewUrl(deps.dashboardUrl, run))],
         };
     }
     const timeoutLine = `Still running after ${Math.round((maxPolls * interval) / 60000)} minutes. Check in with: exodus video status ${runId}`;
@@ -845,13 +911,22 @@ export async function statusFlow(runId, json, deps) {
     const items = itemsRes.data.items ?? [];
     const stop = classifyRun(run);
     const hasFinal = items.some((i) => i.itemKind === "final" && i.status === "done");
+    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 })] };
+        return {
+            code: 0,
+            lines: [JSON.stringify({ runId, status: run.status, stop, items, hasFinal, warnings })],
+        };
     }
     const revoicedByScene = new Set();
+    const timedOnOriginalVoice = new Set();
     for (const artifact of outputsOfNodeKind(run, "video")) {
         if (artifact.type === "video" && artifact.revoiced === true && typeof artifact.sceneIndex === "number") {
             revoicedByScene.add(artifact.sceneIndex);
+            if ((artifact.words?.length ?? 0) > 0)
+                timedOnOriginalVoice.add(artifact.sceneIndex);
         }
     }
     const byScene = new Map();
@@ -871,7 +946,11 @@ export async function statusFlow(runId, json, deps) {
     const headline = stop.at === "failed" && stop.repair
         ? `Ad run ${runId} — Stopped, a step failed`
         : `Ad run ${runId} — ${displayRunStatus(run.status)}`;
-    const lines = [headline, ...stopLines(stop, runId, deps.dashboardUrl)];
+    const lines = [
+        headline,
+        ...stopLines(stop, runId, reviewUrl(deps.dashboardUrl, run)),
+        ...warnings.map((w) => `Heads-up (${w.step}): ${w.warning}`),
+    ];
     if (byScene.size === 0) {
         lines.push("", "No scenes yet — this run hasn't made anything to look at.");
     }
@@ -894,6 +973,9 @@ export async function statusFlow(runId, json, deps) {
                 lines.push(`       ${row.clip.error}`);
             if (revoicedByScene.has(sceneIndex))
                 lines.push("       voice: cast voice applied");
+            if (timedOnOriginalVoice.has(sceneIndex)) {
+                lines.push("       word timings: measured on the original voice (close, not frame-exact)");
+            }
             for (const finding of row.frame?.findings ?? []) {
                 lines.push(`       picture: ${finding.code} (${finding.severity}): ${finding.detail}`);
             }
@@ -943,6 +1025,23 @@ export async function storyboardFlow(runId, json, deps) {
         for (const scene of loose)
             lines.push(...sceneCardLines(scene));
     }
+    const voiceRes = await deps
+        .get(`${VOICES_PATH}?runId=${encodeURIComponent(runId)}`)
+        .catch(() => null);
+    if (voiceRes?.ok) {
+        const sheet = (voiceRes.data ?? {});
+        const cast = Array.isArray(sheet.cast) ? sheet.cast : [];
+        const canChange = sheet.canChange !== false;
+        if (canChange || cast.some((row) => row.voice !== null)) {
+            const summary = voiceSummaryLines(cast, Array.isArray(sheet.notices) ? sheet.notices : []);
+            if (summary.length > 0) {
+                lines.push("", ...summary);
+                if (canChange) {
+                    lines.push(`set voices with: exodus video voices ${runId} --set <character>=<voiceId>`);
+                }
+            }
+        }
+    }
     lines.push("", `approve with: exodus video approve ${runId}`, `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>`);
@@ -977,10 +1076,16 @@ export async function approveFlow(runId, json, deps) {
         return errorResult(res, json);
     if (json)
         return { code: 0, lines: [JSON.stringify({ ok: true, runId, data: res.data })] };
+    const voices = res.data
+        ?.voices;
+    const summary = voices
+        ? voiceSummaryLines(Array.isArray(voices.cast) ? voices.cast : [], Array.isArray(voices.notices) ? voices.notices : [])
+        : [];
     return {
         code: 0,
         lines: [
             "Approved.",
+            ...(summary.length > 0 ? ["", ...summary, ""] : []),
             `See what happens next: exodus video status ${runId}`,
         ],
     };
@@ -1037,6 +1142,260 @@ 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.";
+export function planClipRedo(run, items, target) {
+    const stop = classifyRun(run);
+    const uploadedCut = items.some((i) => i.itemKind === "final" && i.status === "done");
+    const rows = items.filter((i) => i.itemKind === "clip" &&
+        i.sceneIndex === target.sceneIndex &&
+        (target.nodeId === undefined || i.nodeId === target.nodeId));
+    if (rows.length === 0) {
+        return { ok: false, reason: `Scene ${target.sceneIndex} has no clip to redo.` };
+    }
+    const nodeIds = [...new Set(rows.map((r) => r.nodeId))];
+    if (nodeIds.length > 1) {
+        return {
+            ok: false,
+            reason: `Scene ${target.sceneIndex} has a clip on more than one step (${nodeIds.join(", ")}), ` +
+                "so say which one: --node <nodeId>.",
+        };
+    }
+    const row = rows[0];
+    const node = run.nodes.find((n) => n.nodeId === row.nodeId);
+    if (node?.status === "running") {
+        return {
+            ok: false,
+            reason: `The "${row.nodeId}" step is still making other scenes. Try again once it has finished ` +
+                `(exodus video status ${run._id}).`,
+        };
+    }
+    if (node && node.status !== "done") {
+        return {
+            ok: false,
+            reason: `The "${row.nodeId}" step did not finish (it is "${node.status}"), ` +
+                "and one clip can only be redone on a step that finished.",
+        };
+    }
+    if (row.status === "running") {
+        return { ok: false, reason: `Scene ${target.sceneIndex} is already being redone.` };
+    }
+    const redoable = row.status === "failed" ||
+        (row.status === "done" && (row.flagged === true || stop.at === "final-watch"));
+    if (!redoable) {
+        if (row.status === "done") {
+            return {
+                ok: false,
+                reason: `Scene ${target.sceneIndex}'s clip is finished and nothing flagged it. A finished clip ` +
+                    "can only be redone while the run is waiting for the final cut.",
+            };
+        }
+        const word = ITEM_STATUS_WORD[row.status] ?? row.status;
+        return {
+            ok: false,
+            reason: `Scene ${target.sceneIndex}'s clip is ${word}, so there is nothing to redo yet.`,
+        };
+    }
+    return {
+        ok: true,
+        nodeId: row.nodeId,
+        sceneIndex: target.sceneIndex,
+        attempt: row.attempt ?? 0,
+        warnings: uploadedCut ? [UPLOADED_CUT_WARNING] : [],
+    };
+}
+export async function retryClipFlow(runId, target, note, json, deps) {
+    const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
+    if (!runRes.ok)
+        return errorResult(runRes, json);
+    const run = asVideoRun(runRes.data);
+    const itemsRes = await deps.get(`${ITEMS_PATH}?runId=${encodeURIComponent(runId)}`);
+    if (!itemsRes.ok)
+        return errorResult(itemsRes, json);
+    const items = itemsRes.data.items ?? [];
+    const plan = planClipRedo(run, items, target);
+    if (!plan.ok) {
+        return {
+            code: 1,
+            lines: json ? [JSON.stringify({ ok: false, error: plan.reason })] : [plan.reason],
+        };
+    }
+    const res = await deps.post(SCENE_RETRY_PATH, {
+        runId,
+        nodeId: plan.nodeId,
+        sceneIndex: plan.sceneIndex,
+        ...(note ? { note } : {}),
+    });
+    if (!res.ok)
+        return errorResult(res, json);
+    const triggerRunId = res.data.triggerRunId;
+    const review = reviewUrl(deps.dashboardUrl, run);
+    if (json) {
+        return {
+            code: 0,
+            lines: [
+                JSON.stringify({
+                    ok: true,
+                    runId,
+                    nodeId: plan.nodeId,
+                    sceneIndex: plan.sceneIndex,
+                    triggerRunId,
+                    attemptBefore: plan.attempt,
+                    reviewUrl: review,
+                    warnings: plan.warnings,
+                    ...(note ? { note } : {}),
+                }),
+            ],
+        };
+    }
+    return {
+        code: 0,
+        lines: [
+            `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.",
+            ...(note
+                ? ["Your note steers how this clip moves. It never changes the words that are spoken."]
+                : []),
+            `Watch it land: exodus video status ${runId}`,
+            `Review the run: ${review}`,
+            ...plan.warnings,
+        ],
+    };
+}
+export function parseVoiceFlags(argv, readFile) {
+    const fromFile = {};
+    const typed = {};
+    let asked = false;
+    const valueFor = (i, flag) => {
+        const arg = argv[i];
+        if (arg.startsWith(`${flag}=`))
+            return [arg.slice(flag.length + 1), i];
+        const next = argv[i + 1];
+        if (next === undefined)
+            throw new Error(`${flag} needs a value.`);
+        return [next, i + 1];
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--set" || arg.startsWith("--set=")) {
+            const [raw, next] = valueFor(i, "--set");
+            i = next;
+            const eq = raw.lastIndexOf("=");
+            if (eq <= 0 || eq === raw.length - 1) {
+                throw new Error("--set must look like <character>=<voice id>, for example " +
+                    `--set C1=abc123voiceid (got "${raw}").`);
+            }
+            typed[raw.slice(0, eq).trim()] = raw.slice(eq + 1).trim();
+            asked = true;
+        }
+        else if (arg === "--clear" || arg.startsWith("--clear=")) {
+            const [raw, next] = valueFor(i, "--clear");
+            i = next;
+            if (!raw.trim())
+                throw new Error("--clear needs a character, for example --clear C1.");
+            typed[raw.trim()] = null;
+            asked = true;
+        }
+        else if (arg === "--from" || arg.startsWith("--from=")) {
+            const [file, next] = valueFor(i, "--from");
+            i = next;
+            let parsed;
+            try {
+                parsed = JSON.parse(readFile(file));
+            }
+            catch {
+                throw new Error(`Could not read ${file} as a list of characters and voice IDs.`);
+            }
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                throw new Error(`Could not read ${file} as a list of characters and voice IDs.`);
+            }
+            Object.assign(fromFile, parsed);
+            asked = true;
+        }
+    }
+    if (!asked)
+        return null;
+    const sameName = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
+    const merged = {};
+    for (const [who, choice] of Object.entries(fromFile)) {
+        if (!Object.keys(typed).some((t) => sameName(t, who)))
+            merged[who] = choice;
+    }
+    return { ...merged, ...typed };
+}
+export async function voicesFlow(runId, voices, json, deps) {
+    const res = voices
+        ? await deps.post(VOICES_PATH, { runId, voices })
+        : await deps.get(`${VOICES_PATH}?runId=${encodeURIComponent(runId)}`);
+    if (!res.ok)
+        return errorResult(res, json);
+    const sheet = res.data;
+    if (json)
+        return { code: 0, lines: [JSON.stringify({ ok: true, ...sheet })] };
+    return { code: 0, lines: voiceSheetLines(sheet) };
+}
+function availabilityWords(row) {
+    if (!row.voice)
+        return "no voice yet";
+    switch (row.availability?.state) {
+        case "available":
+            return "ElevenLabs has it";
+        case "missing":
+            return "ElevenLabs does not have it";
+        case "not-checked":
+            return "not checked just now";
+        default:
+            return "not checked";
+    }
+}
+function voiceWords(voice) {
+    if (!voice)
+        return "—";
+    return voice.label ? `${voice.label} (${voice.voiceId})` : voice.voiceId;
+}
+function voiceSummaryLines(cast, notices) {
+    const rows = cast.filter((row) => row.spokenScenes > 0 || row.voice !== null);
+    const width = Math.max(0, ...rows.map((row) => row.name.length));
+    const lines = rows.length > 0 ? ["Voices"] : [];
+    for (const row of rows) {
+        lines.push(row.voice
+            ? `  ${row.name.padEnd(width)}  →  ${voiceWords(row.voice)}  ${availabilityWords(row)}`
+            : `  ${row.name.padEnd(width)}  →  no voice chosen (keeps the generated voice)`);
+    }
+    for (const notice of notices)
+        lines.push(`Heads-up: ${notice}`);
+    return lines;
+}
+export function voiceSheetLines(sheet) {
+    const lines = [`Voices for run ${sheet.runId}`];
+    if (sheet.cast.length === 0)
+        lines.push("  Nobody is in this ad yet.");
+    for (const row of sheet.cast) {
+        const voice = voiceWords(row.voice);
+        lines.push(`  ${row.characterId}  ${row.name}  ${voice}  ${availabilityWords(row)}  ` +
+            `speaks in ${row.spokenScenes} scenes, about ${row.spokenSeconds}s`);
+    }
+    if (sheet.narrator) {
+        const label = sheet.narrator.label ? `${sheet.narrator.label} ` : "";
+        lines.push(`  Narrator  ${label}(${sheet.narrator.voiceId})  set on the workflow, not here`);
+    }
+    if (sheet.changed) {
+        lines.push(sheet.changed.length > 0
+            ? `Changed: ${sheet.changed.join(", ")}. Pictures and script were not touched.`
+            : "Nothing changed — those voices were already set. Pictures and script were not touched.");
+    }
+    lines.push(`How voices are applied: ${sheet.treatment.summary}${sheet.treatment.speedChange ? "" : " No speed change."}`);
+    lines.push(`Cost: billed to your own ElevenLabs key. ${sheet.treatment.costNote} ` +
+        `About ${sheet.treatment.usage.seconds} seconds of speech across ` +
+        `${sheet.treatment.usage.clips} clips will be converted.`);
+    for (const notice of sheet.notices)
+        lines.push(notice);
+    lines.push(sheet.canChange
+        ? "You can still change voices until you approve the storyboard."
+        : (sheet.whyNot ?? "Voices can no longer be changed on this run."));
+    return lines;
+}
 export async function pullFlow(runId, dir, json, deps) {
     const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
     if (!runRes.ok)
@@ -1317,7 +1676,7 @@ export async function uploadFlow(runId, filePath, durationFlag, json, deps) {
     if (!attached.ok)
         return errorResult(attached, json);
     const final = attached.data;
-    const finalWatchUrl = final.finalWatchUrl ?? `${deps.dashboardUrl}/video?ad=${runId}`;
+    const finalWatchUrl = final.finalWatchUrl ?? reviewUrl(deps.dashboardUrl, { _id: runId });
     if (json) {
         return {
             code: 0,
@@ -1343,6 +1702,9 @@ const VALUE_FLAGS = new Set([
     "duration",
     "node",
     "scene",
+    "set",
+    "clear",
+    "from",
 ]);
 export function parsePositional(args = process.argv.slice(3)) {
     const out = [];
@@ -1402,7 +1764,17 @@ export async function run(flags) {
         }, defaultDeps));
     }
     const runId = rest[0];
-    const needsRunId = ["status", "storyboard", "approve", "flag", "retry-frame", "pull", "upload"];
+    const needsRunId = [
+        "status",
+        "storyboard",
+        "approve",
+        "flag",
+        "retry-frame",
+        "retry-clip",
+        "voices",
+        "pull",
+        "upload",
+    ];
     if (needsRunId.includes(sub) && !runId) {
         usage(`video ${sub} needs a run id: exodus video ${sub} <runId>`);
     }
@@ -1432,6 +1804,27 @@ export async function run(flags) {
         }
         return printResult(await retryFrameFlow(runId, nodeId, sceneIndex, flagString(flags, "note"), json, defaultDeps));
     }
+    if (sub === "retry-clip") {
+        const sceneRaw = flagString(flags, "scene");
+        if (sceneRaw === undefined) {
+            usage("video retry-clip needs --scene <n>, the scene whose clip to redo.");
+        }
+        const sceneIndex = Number(sceneRaw);
+        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));
+    }
+    if (sub === "voices") {
+        let voices;
+        try {
+            voices = parseVoiceFlags(process.argv.slice(3), defaultDeps.readFile);
+        }
+        catch (err) {
+            usage(err.message);
+        }
+        return printResult(await voicesFlow(runId, voices, json, defaultDeps));
+    }
     if (sub === "pull") {
         const dir = flagString(flags, "out");
         if (!dir)

package/dist/commands/workflow.d.ts

@@ -3,6 +3,7 @@ import { type PollOptions, type PollResult } from "../lib/poll.js";
 import { LEGACY_WORKFLOW_RUN_STATUS_VALUES, type RunStatus } from "../lib/runStatus.js";
 import { type RunDeliverySummary } from "../lib/runVerdict.js";
 import { type Channel } from "../lib/channel.js";
+import { type VoiceMap } from "./video.js";
 export declare const helpText: string;
 export type WorkflowNodeKind = "brief" | "brief-form" | "asset" | "bot" | "primer" | "image" | "image-rig" | "rig" | "storyboard" | "reference" | "scene-frames" | "video" | "voiceover" | "output" | "call" | "show-set" | "show-cast" | "show-voices" | "product-truth" | "transform" | "formatter" | "splitter" | "collector" | "checkpoint" | "prompt";
 export type WorkflowSlotState = "locked" | "auto" | "ask" | "inferred";
@@ -407,6 +408,7 @@ interface RunFlowOptions {
     fill?: string;
     autoApprove?: boolean;
     imageRigOverrides?: Record<string, unknown>;
+    voices?: VoiceMap;
     wait: boolean;
     json: boolean;
     out?: string;
@@ -427,6 +429,7 @@ export declare function serverWarningsToPrint(serverWarnings: unknown, alreadyPr
 export declare function rejectTerminalFlag(args: string[]): void;
 export declare function parseAutoApproveFlag(args: string[]): boolean;
 export declare function parseRigOverridesFlag(args: string[], readFile?: (path: string) => string): Record<string, unknown> | undefined;
+export declare function parseVoicesFlag(args: string[], readFile?: (path: string) => string): VoiceMap | undefined;
 export declare function parseFillFlag(args: string[]): string | undefined;
 export declare function formatWorkflowList(workflows: WorkflowListItem[]): string;
 export declare function formatRecentRuns(runs: WorkflowRunProjection[]): string;