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

package/dist/commands/video.js

@@ -40,6 +40,16 @@ The whole loop, in order:
   7. 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.
+
+     exodus video revoice <runId> --all
+       Redo only the VOICE on clips that kept the video model's own voice
+       (for example, the run had no ElevenLabs key when they were made). The
+       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. exodus video upload <runId> --file cut.mp4
@@ -56,6 +66,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 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]
@@ -72,9 +84,14 @@ 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, revoice)
+  --scene <n>          Which scene to redo. One scene only, a whole number
+                       (retry-frame, retry-clip, revoice)
+  --all                Every finished clip that kept the video model's voice
+                       (revoice)
   --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
@@ -93,6 +110,8 @@ 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 revoice run_123 --all
   exodus video voices run_123
   exodus video voices run_123 --set C1=abc123voiceid --set "HOST 2=def456voiceid"
   exodus video voices run_123 --from voices.json
@@ -107,6 +126,9 @@ 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 REVOICE_NOT_ON_THIS_SERVER = "This Exodus server does not have the voice redo yet, so nothing was started and nothing " +
+    "was spent. It arrives with the next server update.";
 const FINAL_PATH = "/api/v2/video/final";
 export const VOICES_PATH = "/api/v2/video/voices";
 const ASSET_UPLOAD_URL_PATH = "/api/v2/workflows/asset-upload-url";
@@ -260,7 +282,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.",
@@ -278,6 +307,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") {
@@ -285,7 +316,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 [
@@ -302,7 +333,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)}.`];
@@ -341,6 +372,7 @@ function clipFromArtifact(sceneIndex, artifact) {
         words: artifact.words ?? null,
         revoiced: artifact.revoiced === true,
         speechTrimmed: artifact.speechTrimmed === true,
+        rawStorageId: artifact.rawStorageId ?? null,
     };
 }
 function keyframeDownload(sceneIndex, imageUrl) {
@@ -358,7 +390,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;
@@ -422,12 +478,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 });
@@ -598,11 +657,17 @@ 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,
             revoiced: clip ? clip.revoiced : null,
             speechTrimmed: clip ? clip.speechTrimmed : null,
+            rawStorageId: clip ? clip.rawStorageId : null,
             clipStatus: item?.status ?? "missing",
             error: item?.error ?? null,
             flagged: item?.flagged === true,
@@ -610,7 +675,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(),
@@ -626,7 +691,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,
@@ -660,6 +725,7 @@ export function markPullFailure(manifest, failure) {
             scene.clip = null;
             scene.revoiced = null;
             scene.speechTrimmed = null;
+            scene.rawStorageId = null;
         }
         if (scene.voice === failure.file)
             scene.voice = null;
@@ -668,6 +734,7 @@ export function markPullFailure(manifest, failure) {
         if (scene.words === failure.file || lostWordsSource) {
             scene.words = null;
             scene.wordsFrom = null;
+            scene.wordsDescribe = null;
         }
     }
 }
@@ -773,7 +840,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}`,
@@ -826,7 +893,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}`;
@@ -860,13 +927,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();
@@ -886,7 +962,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.");
     }
@@ -909,6 +989,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}`);
             }
@@ -958,6 +1041,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>`);
@@ -992,10 +1092,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}`,
         ],
     };
@@ -1052,24 +1158,294 @@ export async function retryFrameFlow(runId, nodeId, sceneIndex, note, json, deps
         ],
     };
 }
-export function parseVoiceFlags(argv, readFile) {
+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 found = findClipRow(run, items, target);
+    if ("reason" in found)
+        return { ok: false, reason: found.reason };
+    const { row, uploadedCut } = found;
+    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] : [],
+    };
+}
+function findClipRow(run, items, target) {
+    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 { reason: `Scene ${target.sceneIndex} has no clip to redo.` };
+    }
+    const nodeIds = [...new Set(rows.map((r) => r.nodeId))];
+    if (nodeIds.length > 1) {
+        return {
+            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 {
+            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 {
+            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 { reason: `Scene ${target.sceneIndex} is already being redone.` };
+    }
+    return { row, uploadedCut };
+}
+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,
+        ],
+    };
+}
+function clipIsStillRaw(item) {
+    const a = item.artifact;
+    return (item.status === "done" &&
+        a?.type === "video" &&
+        a.revoiced !== true &&
+        a.speechTrimmed !== true &&
+        a.tailTrimmed !== true);
+}
+const VOICE_NOT_CHANGED_CODES = new Set(["voice-unpinned", "voice-not-applied"]);
+export function planClipRevoice(run, items, target) {
+    const found = findClipRow(run, items, target);
+    if ("reason" in found)
+        return { ok: false, reason: found.reason };
+    const { row, uploadedCut } = found;
+    const remake = `To make the clip again from scratch: exodus video retry-clip ${run._id} --scene ${target.sceneIndex}`;
+    if (row.status !== "done" || row.artifact?.type !== "video") {
+        return {
+            ok: false,
+            reason: `Scene ${target.sceneIndex} has no finished clip, so there is no voice to redo. ${remake}`,
+        };
+    }
+    if (!clipIsStillRaw(row)) {
+        return {
+            ok: false,
+            reason: `Scene ${target.sceneIndex}'s clip has already been through the voice pass, ` +
+                `so it cannot go through it again. ${remake}`,
+        };
+    }
+    return {
+        ok: true,
+        nodeId: row.nodeId,
+        sceneIndex: target.sceneIndex,
+        attempt: row.attempt ?? 0,
+        warnings: uploadedCut ? [UPLOADED_CUT_WARNING] : [],
+    };
+}
+function sceneListWords(sceneIndexes) {
+    if (sceneIndexes.length === 1)
+        return `Scene ${sceneIndexes[0]}`;
+    return `Scenes ${sceneIndexes.slice(0, -1).join(", ")} and ${sceneIndexes[sceneIndexes.length - 1]}`;
+}
+export async function revoiceFlow(runId, target, json, deps) {
+    const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
+    if (!runRes.ok)
+        return errorResult(runRes, json);
+    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 targets = "all" in target
+        ? items
+            .filter((i) => i.itemKind === "clip" &&
+            clipIsStillRaw(i) &&
+            (i.findings ?? []).some((f) => VOICE_NOT_CHANGED_CODES.has(f.code)))
+            .sort((a, b) => a.sceneIndex - b.sceneIndex)
+            .map((i) => ({ sceneIndex: i.sceneIndex, nodeId: i.nodeId }))
+        : [target];
+    if (targets.length === 0) {
+        const nothing = "No clip on this run is waiting for a voice pass, so nothing was started.";
+        return {
+            code: 0,
+            lines: json ? [JSON.stringify({ ok: true, runId, scenes: [], note: nothing })] : [nothing],
+        };
+    }
+    const scenes = [];
+    const warnings = new Set();
+    for (const one of targets) {
+        const plan = planClipRevoice(run, items, one);
+        if (!plan.ok) {
+            scenes.push({ sceneIndex: one.sceneIndex, nodeId: one.nodeId, ok: false, error: plan.reason });
+            continue;
+        }
+        const res = await deps.post(SCENE_REVOICE_PATH, {
+            runId,
+            nodeId: plan.nodeId,
+            sceneIndex: plan.sceneIndex,
+        });
+        if (missingRouteLine(res, "exodus video revoice")) {
+            return {
+                code: 1,
+                lines: json
+                    ? [JSON.stringify({ ok: false, status: 404, error: REVOICE_NOT_ON_THIS_SERVER })]
+                    : [REVOICE_NOT_ON_THIS_SERVER],
+            };
+        }
+        if (res.ok) {
+            plan.warnings.forEach((w) => warnings.add(w));
+            scenes.push({
+                sceneIndex: plan.sceneIndex,
+                nodeId: plan.nodeId,
+                ok: true,
+                triggerRunId: res.data.triggerRunId,
+            });
+            continue;
+        }
+        scenes.push({
+            sceneIndex: plan.sceneIndex,
+            nodeId: plan.nodeId,
+            ok: false,
+            error: videoApiError(res),
+        });
+    }
+    const queued = scenes.filter((r) => r.ok).length;
+    const code = scenes.every((r) => r.ok) ? 0 : 1;
+    const review = reviewUrl(deps.dashboardUrl, run);
+    if (json) {
+        return {
+            code,
+            lines: [
+                JSON.stringify({
+                    ok: code === 0,
+                    runId,
+                    scenes,
+                    reviewUrl: review,
+                    warnings: [...warnings],
+                }),
+            ],
+        };
+    }
+    const refusedWith = new Map();
+    for (const r of scenes) {
+        if (!r.ok)
+            refusedWith.set(r.error, [...(refusedWith.get(r.error) ?? []), r.sceneIndex]);
+    }
+    const sceneLines = scenes.flatMap((r) => {
+        if (r.ok) {
+            return [
+                `Scene ${r.sceneIndex}: redoing the voice on ${r.nodeId}. triggerRunId: ${r.triggerRunId ?? "-"}`,
+            ];
+        }
+        const sharing = refusedWith.get(r.error) ?? [];
+        if (sharing[0] !== r.sceneIndex)
+            return [];
+        return [`${sceneListWords(sharing)}: not started. ${r.error}`];
+    });
+    if (queued === 0)
+        return { code, lines: sceneLines };
+    return {
+        code,
+        lines: [
+            ...sceneLines,
+            "The picture in each clip stays exactly as it is. No new video is made.",
+            "The words are checked against the script, the clip is trimmed to the speech, and the chosen voice is applied. ElevenLabs bills that to your own key.",
+            "If the voice pass cannot finish on a clip, that clip is kept as it was.",
+            `Watch them land: exodus video status ${runId}`,
+            `Review the run: ${review}`,
+            ...warnings,
+        ],
+    };
+}
+export function parseVoiceFlags(occurrences, 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];
+    const valueFor = (occurrence) => {
+        if (occurrence.value === undefined)
+            throw new Error(`--${occurrence.flag} needs a value.`);
+        return occurrence.value;
     };
-    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;
+    for (const occurrence of occurrences) {
+        if (occurrence.flag === "set") {
+            const raw = valueFor(occurrence);
             const eq = raw.lastIndexOf("=");
             if (eq <= 0 || eq === raw.length - 1) {
                 throw new Error("--set must look like <character>=<voice id>, for example " +
@@ -1078,17 +1454,15 @@ export function parseVoiceFlags(argv, readFile) {
             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;
+        else if (occurrence.flag === "clear") {
+            const raw = valueFor(occurrence);
             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;
+        else if (occurrence.flag === "from") {
+            const file = valueFor(occurrence);
             let parsed;
             try {
                 parsed = JSON.parse(readFile(file));
@@ -1138,14 +1512,32 @@ function availabilityWords(row) {
             return "not checked";
     }
 }
+function voiceWords(row) {
+    const voice = row.voice;
+    if (!voice)
+        return "—";
+    const words = voice.label ? `${voice.label} (${voice.voiceId})` : voice.voiceId;
+    return row.voiceFrom === "run-default" ? `${words}, the run's default voice` : words;
+}
+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)}  ${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 = row.voice
-            ? `${row.voice.label ? `${row.voice.label} (${row.voice.voiceId})` : row.voice.voiceId}`
-            : "—";
+        const voice = voiceWords(row);
         lines.push(`  ${row.characterId}  ${row.name}  ${voice}  ${availabilityWords(row)}  ` +
             `speaks in ${row.spokenScenes} scenes, about ${row.spokenSeconds}s`);
     }
@@ -1449,7 +1841,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,
@@ -1511,7 +1903,7 @@ function usage(line) {
     console.error(`Error: ${line}`);
     process.exit(1);
 }
-export async function run(flags) {
+export async function run(flags, occurrences) {
     const [sub, ...rest] = parsePositional();
     const json = flags["json"] === true;
     if (!sub) {
@@ -1543,6 +1935,8 @@ export async function run(flags) {
         "approve",
         "flag",
         "retry-frame",
+        "retry-clip",
+        "revoice",
         "voices",
         "pull",
         "upload",
@@ -1576,10 +1970,35 @@ 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 === "revoice") {
+        const sceneRaw = flagString(flags, "scene");
+        const all = flags["all"] === true;
+        if (all === (sceneRaw !== undefined)) {
+            usage("video revoice needs one of --scene <n> (one clip) or --all (every clip that kept the video model's voice).");
+        }
+        if (all)
+            return printResult(await revoiceFlow(runId, { all: true }, json, defaultDeps));
+        const sceneIndex = Number(sceneRaw);
+        if (!Number.isInteger(sceneIndex)) {
+            usage(`video revoice --scene must be a whole scene number, not "${sceneRaw}".`);
+        }
+        return printResult(await revoiceFlow(runId, { sceneIndex, nodeId: flagString(flags, "node") }, json, defaultDeps));
+    }
     if (sub === "voices") {
         let voices;
         try {
-            voices = parseVoiceFlags(process.argv.slice(3), defaultDeps.readFile);
+            voices = parseVoiceFlags(occurrences, defaultDeps.readFile);
         }
         catch (err) {
             usage(err.message);