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

package/assets/docs/PIPELINES.md

@@ -263,6 +263,7 @@ Then, on either route:
   exodus video status <runId> [--json]                                 the park and each scene's clip/voice/picture
   exodus video pull <runId> --out <dir> [--json]                       every piece + manifest.json
   exodus video retry-clip <runId> --scene <n> [--node <nodeId>] [--note "<t>"] [--json]  redo one clip at the final watch
+  exodus video revoice <runId> (--scene <n> | --all) [--node <nodeId>] [--json]  redo only the voice on finished clips; no new video
   exodus video upload <runId> --file <cut.mp4> [--duration <s>] [--json]   attach the cut (MP4/MOV/WebM, 200 MB)
 Cut: your choice of tool — Exodus does not stitch or mix. One option ships with the skill:
   node .claude/skills/exodus-video/scripts/first-cut.mjs <dir> [--skip n,m] [--no-music] [--out f]

package/assets/skills/exodus-video/SKILL.md

@@ -100,6 +100,7 @@ exodus video status <runId>                               where it is, per scene
 exodus video pull <runId> --out ./ad-<runId>              every piece + manifest.json
 exodus video retry-clip <runId> --scene <n> [--node <nodeId>] [--note "…"]
                                                           redo one clip at the final watch
+exodus video revoice <runId> --all | --scene <n>          redo only the voice; no new video
                                                           … make the cut (your choice of tool)
 exodus video upload <runId> --file ./ad-<runId>/cut.mp4   attach it
 exodus video approve <runId>                              make it the ad
@@ -176,6 +177,7 @@ Verified against the routes, not assumed. Everything here is admin-gated on top.
 | script-turn edits at the gate | **refused** | dashboard only |
 | `video retry-frame` | works | works |
 | `video retry-clip` | works | works |
+| `video revoice` | works | works |
 | `video pull` | works | works |
 | `video upload` | only if the video node sets `finalWatch: true` | works |
 | `workflow checkpoint approve` | **refused at a video gate** | **refused at a video gate** |
@@ -277,9 +279,11 @@ whole loop unattended.
 
 ## Giving the characters voices
 
-By default a workflow run's characters have no voice chosen, so every clip keeps
-the voice the video model invents. `exodus video voices` is where that gets
-fixed, and it only works **before** the storyboard is approved — once clips start
+By default a workflow run's characters have no voice of their own. A character
+without one gets the run's default voice (the workflow's narrator voice) when the
+run has one; with no default either, the clip keeps the voice the video model
+invents. `exodus video voices` shows which of the three applies and is where it
+gets fixed, and it only works **before** the storyboard is approved — once clips start
 it refuses.
 
 ```
@@ -363,7 +367,10 @@ canChange             false once the run has left the storyboard review
 whyNot                why, in one sentence, when canChange is false
 cast[]                one per character
   characterId, name
-  voice               { voiceId, label } or null
+  voice               { voiceId, label }: the voice this character's clips are
+                      converted to. null only when they have no voice of their
+                      own AND the run has no default voice
+  voiceFrom           "own-pin" or "run-default"; absent when voice is null
   availability        { state: "available" | "missing" | "not-checked", … }
   spokenScenes        how many scenes this character speaks in
   spokenSeconds       those scenes' planned seconds — what ElevenLabs bills on
@@ -378,8 +385,8 @@ A failure is the same shape every `video` verb uses:
 `{ "ok": false, "status": 400, "error": "<one plain sentence>" }`, exit 1.
 
 **Before you approve, read `notices`.** The ones that cost the user something:
-a character who speaks but has no voice (those clips keep their generated
-voice), no ElevenLabs key saved on the run (no voice can be applied at all), and
+a character who speaks but has no voice of their own and no run default to fall
+back on (those clips keep their generated voice), no ElevenLabs key saved on the run (no voice can be applied at all), and
 a voice ElevenLabs no longer has.
 
 `estimatedCostUsd` is always null. Exodus cannot price a voice conversion yet;
@@ -445,6 +452,10 @@ scenes[]                             one per scene, in order
   speechTrimmed                      the clip was re-cut to its spoken words
                                      (0.5 s before the first, 0.8 s after the
                                      last); null when there is no clip
+  rawStorageId                       the stored file the video model made, kept
+                                     on record when the voice pass replaced the
+                                     clip with a new file; null when the clip IS
+                                     that file, or there is no clip
 failed[]                             files that did not download: {file, url, error}
 ```
 
@@ -610,6 +621,65 @@ and compare the file before and after.
 the CLI says so when that is the case. Pull again, re-cut and upload again before
 anyone approves.
 
+## Redoing only the voice on finished clips
+
+`revoice` puts clips that are already paid for back through the voice pass: the
+spoken words are checked against the script, the clip is trimmed to the speech,
+and the chosen voice is applied. It makes no new video, so the picture cannot
+change and no video credits are spent. ElevenLabs bills the voice work to the
+member's own key.
+
+```
+exodus video revoice <runId> --all
+exodus video revoice <runId> --scene 3
+```
+
+**When to reach for it.** `status` shows talking clips with `voice-unpinned` or
+`voice-not-applied` (usually next to `speech-check-skipped`), and the manifest
+shows `revoiced: false` with no words file. The usual cause is a run that had no ElevenLabs key when its
+clips were made. `voices <runId>` says so: "This run has no ElevenLabs key saved".
+
+**It finds the key by itself.** Before queuing anything, the server gives the run
+the ElevenLabs key saved on the run owner's account, if the run has none. When
+there is no saved key either, nothing is queued and the refusal says where to add
+one (Settings → Keys). Approving a storyboard does the same top-up, so an older
+run parked at its storyboard is fixed before any clip is paid for.
+
+**`--all` picks the clips that need it.** Every finished clip whose file is still
+the video model's own and whose findings carry `voice-unpinned` or
+`voice-not-applied`, the two codes that mean a voice change should have happened
+and did not. `speech-check-skipped` alone does not qualify: it also lands on
+clips whose sound the video model or a later step owns, where there is no voice
+to change and a pass would bill a transcription for nothing. `--scene <n>` is
+not filtered this way; the server decides. It sends one request per scene, tries
+every one, and reports each. Scenes refused with the same sentence share one
+line (a run with no key prints that sentence once); `--json` keeps one entry per
+scene.
+
+**What is refused.** A clip that already went through the voice pass (`revoiced`,
+`speechTrimmed` or a trimmed tail): the pass would trim or convert it twice. Use
+`retry-clip` to make that clip again from scratch. A failed clip, a scene already
+being redone, a step still rendering, and an ad already delivered.
+
+**An older server starts nothing.** The voice redo has its own server route and
+its own worker task. A server or worker from before it existed cannot run it, and
+the CLI never falls back to `retry-clip`'s route, which would make new paid video.
+You get one sentence saying the server does not have the voice redo yet, and
+nothing is queued or spent.
+
+**A clip is never lost.** The clip stays on its row the whole time. If the voice
+pass cannot finish, the clip, its findings and its cost are left as they were and
+one warning, `revoice-not-finished`, is added. Run it again. If ElevenLabs refuses
+the key, the clip comes back unchanged with `voice-not-applied`.
+
+**If the word check now fails.** The voiced clip is still delivered, and the scene
+is flagged with the finding, because the picture is the same one the ad already
+had. Decide from `status`: keep it, or `retry-clip` it.
+
+**Afterwards.** Pull again. Each voiced scene now has `revoiced: true`, a words
+file, and `rawStorageId` naming the original file. Re-cut and upload again if a
+cut was already uploaded; the CLI says so when that is the case.
+
 ## Cutting the ad
 
 Editing is the part every user does differently, and the team is deliberately

package/dist/bin/exodus.js

@@ -5,6 +5,7 @@ import { readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { getVersion } from "../lib/version.js";
+import { parseArgs } from "../lib/args.js";
 const OTHER_COMMANDS = new Set([
     "browse",
     "status",
@@ -113,42 +114,8 @@ async function buildHelp() {
     ];
     return sections.filter((s) => s.trim() !== "").join("\n\n");
 }
-function parseArgs(argv) {
-    const [, , rawCommand = "help", ...rest] = argv;
-    const command = ["--help", "-h", "-help"].includes(rawCommand) ? "help" : rawCommand;
-    const flags = {};
-    let i = 0;
-    while (i < rest.length) {
-        const arg = rest[i];
-        if (arg === "--help" || arg === "-h") {
-            flags["help"] = true;
-            i++;
-            continue;
-        }
-        if (arg.startsWith("--")) {
-            const key = arg.slice(2);
-            const next = rest[i + 1];
-            if (key.startsWith("no-")) {
-                flags[key.slice(3)] = false;
-                i++;
-            }
-            else if (next !== undefined && !next.startsWith("--")) {
-                flags[key] = next;
-                i += 2;
-            }
-            else {
-                flags[key] = true;
-                i++;
-            }
-        }
-        else {
-            i++;
-        }
-    }
-    return { command, flags };
-}
 async function main() {
-    const { command, flags } = parseArgs(process.argv);
+    const { command, flags, occurrences } = parseArgs(process.argv);
     if (["--version", "-v", "-V", "version"].includes(command)) {
         console.log(getVersion());
         process.exit(0);
@@ -180,7 +147,7 @@ async function main() {
         console.error(`Command "${command}" does not export a run() function.`);
         process.exit(1);
     }
-    await commandModule.run(flags);
+    await commandModule.run(flags, occurrences);
 }
 main().catch((err) => {
     console.error("Fatal error:", err instanceof Error ? err.message : String(err));

package/dist/commands/video.d.ts

@@ -1,4 +1,5 @@
 import { type ApiResponse } from "../lib/client.js";
+import type { FlagOccurrence } from "../lib/args.js";
 export declare const helpText: string;
 export declare const VOICES_PATH = "/api/v2/video/voices";
 export interface ClipWord {
@@ -43,6 +44,8 @@ export type ArtifactSubset = {
     final?: boolean;
     revoiced?: boolean;
     speechTrimmed?: boolean;
+    tailTrimmed?: boolean;
+    rawStorageId?: string;
 } | {
     type: "audio";
     sceneIndex?: number;
@@ -202,6 +205,7 @@ export interface ManifestScene {
     qc: ClipQc | null;
     revoiced: boolean | null;
     speechTrimmed: boolean | null;
+    rawStorageId: string | null;
     clipStatus: string;
     error: string | null;
     flagged: boolean;
@@ -288,6 +292,11 @@ export interface ClipRedoTarget {
 }
 export declare function planClipRedo(run: VideoRun, items: NodeItem[], target: ClipRedoTarget): ClipRedoPlan;
 export declare function retryClipFlow(runId: string, target: ClipRedoTarget, note: string | undefined, json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export declare function planClipRevoice(run: VideoRun, items: NodeItem[], target: ClipRedoTarget): ClipRedoPlan;
+export type RevoiceTarget = ClipRedoTarget | {
+    all: true;
+};
+export declare function revoiceFlow(runId: string, target: RevoiceTarget, json: boolean, deps: VideoDeps): Promise<FlowResult>;
 export interface CastVoiceRow {
     characterId: string;
     name: string;
@@ -295,6 +304,7 @@ export interface CastVoiceRow {
         voiceId: string;
         label?: string;
     } | null;
+    voiceFrom?: "own-pin" | "run-default";
     availability?: {
         state: "available";
         providerName: string;
@@ -334,7 +344,7 @@ export type VoiceMap = Record<string, string | {
     voiceId: string;
     label?: string;
 } | null>;
-export declare function parseVoiceFlags(argv: readonly string[], readFile: (path: string) => string): VoiceMap | null;
+export declare function parseVoiceFlags(occurrences: FlagOccurrence[], readFile: (path: string) => string): VoiceMap | null;
 export declare function voicesFlow(runId: string, voices: VoiceMap | null, json: boolean, deps: VideoDeps): Promise<FlowResult>;
 export declare function voiceSheetLines(sheet: CastVoiceSheet): string[];
 export declare function pullFlow(runId: string, dir: string, json: boolean, deps: VideoDeps): Promise<FlowResult>;
@@ -343,4 +353,4 @@ export declare const NO_DURATION_MESSAGE: string;
 export declare function describeFetchFailure(err: unknown): string;
 export declare function uploadFlow(runId: string, filePath: string, durationFlag: string | undefined, json: boolean, deps: VideoDeps): Promise<FlowResult>;
 export declare function parsePositional(args?: string[]): string[];
-export declare function run(flags: Record<string, string | boolean>): Promise<void>;
+export declare function run(flags: Record<string, string | boolean>, occurrences: FlagOccurrence[]): Promise<void>;

package/dist/commands/video.js

@@ -44,6 +44,12 @@ The whole loop, in order:
        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
@@ -61,6 +67,7 @@ Usage:
   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]
@@ -80,9 +87,11 @@ Options:
                        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)
+                       more than one step (retry-clip, revoice)
   --scene <n>          Which scene to redo. One scene only, a whole number
-                       (retry-frame, retry-clip)
+                       (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
@@ -102,6 +111,7 @@ Examples:
   exodus video approve run_123
   exodus video retry-frame run_123 --node frames-1 --scene 2
   exodus video retry-clip run_123 --scene 3 --note "keep the handshake in frame"
+  exodus video 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
@@ -116,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";
@@ -359,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) {
@@ -653,6 +667,7 @@ export function planPull(run, items, opts) {
             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,
@@ -710,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;
@@ -1146,17 +1162,45 @@ const UPLOADED_CUT_WARNING = "The cut you already uploaded will not include the
     "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 { ok: false, reason: `Scene ${target.sceneIndex} has no clip to redo.` };
+        return { 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>.",
         };
@@ -1165,44 +1209,20 @@ export function planClipRedo(run, items, target) {
     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.` };
+        return { 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] : [],
-    };
+    return { row, uploadedCut };
 }
 export async function retryClipFlow(runId, target, note, json, deps) {
     const runRes = await deps.get(`${RUN_PATH}?runId=${encodeURIComponent(runId)}`);
@@ -1263,24 +1283,169 @@ export async function retryClipFlow(runId, target, note, json, deps) {
         ],
     };
 }
-export function parseVoiceFlags(argv, readFile) {
+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 " +
@@ -1289,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));
@@ -1349,10 +1512,12 @@ function availabilityWords(row) {
             return "not checked";
     }
 }
-function voiceWords(voice) {
+function voiceWords(row) {
+    const voice = row.voice;
     if (!voice)
         return "—";
-    return voice.label ? `${voice.label} (${voice.voiceId})` : voice.voiceId;
+    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);
@@ -1360,7 +1525,7 @@ function voiceSummaryLines(cast, notices) {
     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)}  →  ${voiceWords(row)}  ${availabilityWords(row)}`
             : `  ${row.name.padEnd(width)}  →  no voice chosen (keeps the generated voice)`);
     }
     for (const notice of notices)
@@ -1372,7 +1537,7 @@ export function voiceSheetLines(sheet) {
     if (sheet.cast.length === 0)
         lines.push("  Nobody is in this ad yet.");
     for (const row of sheet.cast) {
-        const voice = voiceWords(row.voice);
+        const voice = voiceWords(row);
         lines.push(`  ${row.characterId}  ${row.name}  ${voice}  ${availabilityWords(row)}  ` +
             `speaks in ${row.spokenScenes} scenes, about ${row.spokenSeconds}s`);
     }
@@ -1738,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) {
@@ -1771,6 +1936,7 @@ export async function run(flags) {
         "flag",
         "retry-frame",
         "retry-clip",
+        "revoice",
         "voices",
         "pull",
         "upload",
@@ -1815,10 +1981,24 @@ export async function run(flags) {
         }
         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);

package/dist/commands/workflow.d.ts

@@ -1,4 +1,5 @@
 import { type ApiResponse } from "../lib/client.js";
+import type { FlagOccurrence } from "../lib/args.js";
 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";
@@ -416,8 +417,8 @@ interface RunFlowOptions {
     onWarningLine?: (line: string) => void;
 }
 export declare function formatPauseNotice(pauseReason: WorkflowPauseReason | undefined, runId: string, dashboardUrl: string): string[];
-export declare function parseRawInputFlags(args: string[]): Record<string, string>;
-export declare function parseInputFlags(args: string[], readFile?: (path: string) => string): Record<string, string>;
+export declare function parseRawInputFlags(occurrences: FlagOccurrence[]): Record<string, string>;
+export declare function parseInputFlags(occurrences: FlagOccurrence[], readFile?: (path: string) => string): Record<string, string>;
 export declare const ASSET_UPLOAD_POLICY: Record<WorkflowMediaType, {
     mimeByExtension: Record<string, string>;
     maxBytes: number;
@@ -426,11 +427,11 @@ export declare const ASSET_UPLOAD_POLICY: Record<WorkflowMediaType, {
 export declare const NO_DELIVERIES_WARNING: string;
 export declare function noDeliveriesWarning(described: unknown): string | undefined;
 export declare function serverWarningsToPrint(serverWarnings: unknown, alreadyPrinted: string[]): string[];
-export declare function rejectTerminalFlag(args: string[]): void;
+export declare function rejectTerminalFlag(occurrences: FlagOccurrence[]): 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 parseRigOverridesFlag(occurrences: FlagOccurrence[], readFile?: (path: string) => string): Record<string, unknown> | undefined;
+export declare function parseVoicesFlag(occurrences: FlagOccurrence[], readFile?: (path: string) => string): VoiceMap | undefined;
+export declare function parseFillFlag(occurrences: FlagOccurrence[]): string | undefined;
 export declare function formatWorkflowList(workflows: WorkflowListItem[]): string;
 export declare function formatRecentRuns(runs: WorkflowRunProjection[]): string;
 export declare function formatWorkflowVersions(versions: WorkflowVersion[]): string;
@@ -586,9 +587,9 @@ export declare function repairFlow(runId: string, action: "retry" | "skip" | "ki
     json: boolean;
     onProgressLine?: (line: string) => void;
 }, deps: WorkflowRunDeps): Promise<FlowResult>;
-export declare function parseSlotFlags(args: string[]): Record<string, string>;
+export declare function parseSlotFlags(occurrences: FlagOccurrence[]): Record<string, string>;
 export declare function answerFlow(runId: string, values: Record<string, string>, opts: {
     json: boolean;
 }, deps: WorkflowRunDeps): Promise<FlowResult>;
-export declare function run(flags: Record<string, string | boolean>): Promise<void>;
+export declare function run(flags: Record<string, string | boolean>, occurrences: FlagOccurrence[]): Promise<void>;
 export {};

package/dist/commands/workflow.js

@@ -552,35 +552,25 @@ function normalizeMultiValue(value) {
         .filter((p) => p.length > 0)
         .join(", ");
 }
-export function parseRawInputFlags(args) {
+export function parseRawInputFlags(occurrences) {
     const inputs = {};
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        let raw;
-        if (arg === "--input") {
-            raw = args[i + 1];
-            i++;
-        }
-        else if (arg.startsWith("--input=")) {
-            raw = arg.slice("--input=".length);
-        }
-        else {
+    for (const { flag, value } of occurrences) {
+        if (flag !== "input")
             continue;
-        }
-        if (!raw)
+        if (!value)
             throw new Error("--input requires key=value");
-        const eq = raw.indexOf("=");
+        const eq = value.indexOf("=");
         if (eq <= 0)
-            throw new Error(`--input must be key=value (got "${raw}")`);
-        const key = raw.slice(0, eq).trim();
+            throw new Error(`--input must be key=value (got "${value}")`);
+        const key = value.slice(0, eq).trim();
         if (!key)
-            throw new Error(`--input must include a key (got "${raw}")`);
-        inputs[key] = raw.slice(eq + 1);
+            throw new Error(`--input must include a key (got "${value}")`);
+        inputs[key] = value.slice(eq + 1);
     }
     return inputs;
 }
-export function parseInputFlags(args, readFile) {
-    const inputs = parseRawInputFlags(args);
+export function parseInputFlags(occurrences, readFile) {
+    const inputs = parseRawInputFlags(occurrences);
     for (const [key, value] of Object.entries(inputs)) {
         inputs[key] = expandInputValue(key, value, readFile);
     }
@@ -876,12 +866,10 @@ async function prepareRunInputs(workflowId, raw, deps, note) {
     }
     return { inputs: prepared, warnings };
 }
-export function rejectTerminalFlag(args) {
-    for (const arg of args) {
-        if (arg === "--terminal" || arg.startsWith("--terminal=")) {
-            throw new Error("--terminal is no longer supported: a run now executes the whole " +
-                "workflow or it doesn't start. Re-run without --terminal.");
-        }
+export function rejectTerminalFlag(occurrences) {
+    if (occurrences.some((o) => o.flag === "terminal")) {
+        throw new Error("--terminal is no longer supported: a run now executes the whole " +
+            "workflow or it doesn't start. Re-run without --terminal.");
     }
 }
 export function parseAutoApproveFlag(args) {
@@ -894,21 +882,11 @@ export function parseAutoApproveFlag(args) {
     }
     return false;
 }
-export function parseRigOverridesFlag(args, readFile) {
+export function parseRigOverridesFlag(occurrences, readFile) {
     let raw;
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        let value;
-        if (arg === "--rig-overrides") {
-            value = args[i + 1];
-            i++;
-        }
-        else if (arg.startsWith("--rig-overrides=")) {
-            value = arg.slice("--rig-overrides=".length);
-        }
-        else {
+    for (const { flag, value } of occurrences) {
+        if (flag !== "rig-overrides")
             continue;
-        }
         if (value === undefined || value.startsWith("--")) {
             throw new Error("--rig-overrides requires JSON or @path/to/file.json");
         }
@@ -951,21 +929,11 @@ export function parseRigOverridesFlag(args, readFile) {
     }
     return parsed;
 }
-export function parseVoicesFlag(args, readFile) {
+export function parseVoicesFlag(occurrences, readFile) {
     let raw;
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        let value;
-        if (arg === "--voices") {
-            value = args[i + 1];
-            i++;
-        }
-        else if (arg.startsWith("--voices=")) {
-            value = arg.slice("--voices=".length);
-        }
-        else {
+    for (const { flag, value } of occurrences) {
+        if (flag !== "voices")
             continue;
-        }
         if (value === undefined || value.startsWith("--")) {
             throw new Error("--voices requires JSON or @path/to/voices.json");
         }
@@ -1008,25 +976,15 @@ export function parseVoicesFlag(args, readFile) {
     }
     return parsed;
 }
-export function parseFillFlag(args) {
+export function parseFillFlag(occurrences) {
     let name;
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        let raw;
-        if (arg === "--fill") {
-            raw = args[i + 1];
-            i++;
-        }
-        else if (arg.startsWith("--fill=")) {
-            raw = arg.slice("--fill=".length);
-        }
-        else {
+    for (const { flag, value } of occurrences) {
+        if (flag !== "fill")
             continue;
-        }
-        if (raw === undefined || raw.startsWith("--")) {
+        if (value === undefined || value.startsWith("--")) {
             throw new Error("--fill requires a saved fill's name");
         }
-        const trimmed = raw.trim();
+        const trimmed = value.trim();
         if (!trimmed)
             throw new Error("--fill requires a saved fill's name");
         name = trimmed;
@@ -2858,30 +2816,20 @@ async function resumeAndMaybeWait(runId, triggerRunId, headline, opts, deps, lan
     const prefix = opts.onProgressLine ? [] : startLines;
     return { code: waited.code, lines: [...prefix, ...waited.lines] };
 }
-export function parseSlotFlags(args) {
+export function parseSlotFlags(occurrences) {
     const values = {};
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        let raw;
-        if (arg === "--slot") {
-            raw = args[i + 1];
-            i++;
-        }
-        else if (arg.startsWith("--slot=")) {
-            raw = arg.slice("--slot=".length);
-        }
-        else {
+    for (const { flag, value } of occurrences) {
+        if (flag !== "slot")
             continue;
-        }
-        if (!raw)
+        if (!value)
             throw new Error("--slot requires key=value");
-        const eq = raw.indexOf("=");
+        const eq = value.indexOf("=");
         if (eq <= 0)
-            throw new Error(`--slot must be key=value (got "${raw}")`);
-        const key = raw.slice(0, eq).trim();
+            throw new Error(`--slot must be key=value (got "${value}")`);
+        const key = value.slice(0, eq).trim();
         if (!key)
-            throw new Error(`--slot must include a key (got "${raw}")`);
-        values[key] = raw.slice(eq + 1);
+            throw new Error(`--slot must include a key (got "${value}")`);
+        values[key] = value.slice(eq + 1);
     }
     return values;
 }
@@ -2953,7 +2901,7 @@ async function maybeReadStdin(flags) {
         return undefined;
     return raw.endsWith("\n") ? raw.slice(0, -1) : raw;
 }
-export async function run(flags) {
+export async function run(flags, occurrences) {
     const positional = parsePositional();
     const [sub, ...rest] = positional;
     const json = !!flags["json"];
@@ -3018,12 +2966,12 @@ export async function run(flags) {
         let imageRigOverrides;
         let voices;
         try {
-            inputs = parseRawInputFlags(process.argv.slice(3));
-            rejectTerminalFlag(process.argv.slice(3));
-            fill = parseFillFlag(process.argv.slice(3));
+            inputs = parseRawInputFlags(occurrences);
+            rejectTerminalFlag(occurrences);
+            fill = parseFillFlag(occurrences);
             autoApprove = parseAutoApproveFlag(process.argv.slice(3));
-            imageRigOverrides = parseRigOverridesFlag(process.argv.slice(3), defaultDeps.readFile);
-            voices = parseVoicesFlag(process.argv.slice(3), defaultDeps.readFile);
+            imageRigOverrides = parseRigOverridesFlag(occurrences, defaultDeps.readFile);
+            voices = parseVoicesFlag(occurrences, defaultDeps.readFile);
         }
         catch (e) {
             console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
@@ -3167,7 +3115,7 @@ export async function run(flags) {
         }
         let values;
         try {
-            values = parseSlotFlags(process.argv.slice(3));
+            values = parseSlotFlags(occurrences);
         }
         catch (e) {
             console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
@@ -3205,7 +3153,7 @@ export async function run(flags) {
             }
             let fireOverrides;
             try {
-                fireOverrides = parseRigOverridesFlag(process.argv.slice(3), defaultDeps.readFile);
+                fireOverrides = parseRigOverridesFlag(occurrences, defaultDeps.readFile);
             }
             catch (e) {
                 console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);

package/dist/lib/args.d.ts

@@ -0,0 +1,10 @@
+export interface FlagOccurrence {
+    flag: string;
+    value: string | undefined;
+}
+export interface ParsedArgs {
+    command: string;
+    flags: Record<string, string | boolean>;
+    occurrences: FlagOccurrence[];
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;

package/dist/lib/args.js

@@ -0,0 +1,39 @@
+export function parseArgs(argv) {
+    const [, , rawCommand = "help", ...rest] = argv;
+    const command = ["--help", "-h", "-help"].includes(rawCommand) ? "help" : rawCommand;
+    const flags = {};
+    const occurrences = [];
+    let i = 0;
+    while (i < rest.length) {
+        const arg = rest[i];
+        if (arg === "--help" || arg === "-h") {
+            flags["help"] = true;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = rest[i + 1];
+            const eq = key.indexOf("=");
+            occurrences.push(eq === -1
+                ? { flag: key, value: next }
+                : { flag: key.slice(0, eq), value: key.slice(eq + 1) });
+            if (key.startsWith("no-")) {
+                flags[key.slice(3)] = false;
+                i++;
+            }
+            else if (next !== undefined && !next.startsWith("--")) {
+                flags[key] = next;
+                i += 2;
+            }
+            else {
+                flags[key] = true;
+                i++;
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return { command, flags, occurrences };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicopycoders/exodus",
-  "version": "2026.9.1900-beta.0",
+  "version": "2026.9.1900-beta.1",
   "description": "CLI + Claude Code skills for the Copycoders Exodus ad pipeline",
   "repository": {
     "type": "git",