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

package/assets/docs/PIPELINES.md

@@ -256,10 +256,13 @@ Start (Show route):
   exodus video start --show <id> --script <file> [--wait] [--json]     start an ad run; --wait stops at the storyboard gate
 Then, on either route:
   exodus video storyboard <runId> [--json]                             the scene cards
+  exodus video voices <runId> [--set <who>=<voiceId>] [--clear <who>] [--from <f>] [--json]  who speaks, with whose voice
   exodus video approve <runId> [--json]                                approve the storyboard, or the uploaded cut
   exodus video flag <runId> --note "<what is wrong>" [--json]          send the storyboard back — SHOW RUNS ONLY
+  exodus video retry-frame <runId> --node <nodeId> --scene <n> [--note "<t>"] [--json]  redo one still at the pixel gate
   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 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

@@ -75,6 +75,8 @@ exodus workflow list                                      the brand's workflows
 exodus workflow describe <workflowId|name>                what inputs it needs
 exodus workflow run <workflowId|name> --input <field>=@script.txt --wait
                                                           start, stop at the storyboard gate
+exodus workflow run <workflowId|name> --input <field>=@script.txt --voices @voices.json --wait
+                                                          same, with the brand's voices already chosen
 exodus video status <runId>                               where it is, per scene
 ```
 
@@ -96,6 +98,8 @@ exodus video flag <runId> --note "what's wrong"           send it back — SHOW
 exodus video retry-frame <runId> --node <nodeId> --scene <n>  redo one still at the pixel gate
 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
                                                           … 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
@@ -115,7 +119,8 @@ per-scene detail, and the checkpoint verbs cannot resolve a video park — see
 under it:
 
 - storyboard gate: needs `approve`, or `flag` on a Show run.
-- final watch: every piece is made; needs `pull`, a cut, and `upload`. A
+- final watch: every piece is made; needs `pull`, a cut, and `upload`. It is also
+  the one park where a finished clip can be redone, with `retry-clip`. A
   workflow run only reaches this park if its video node sets `finalWatch: true`
   — otherwise it skips straight to finished.
 - paused: a builder checkpoint neither video verb resolves —
@@ -170,6 +175,7 @@ Verified against the routes, not assumed. Everything here is admin-gated on top.
 | `video flag --note` | **refused** | works |
 | script-turn edits at the gate | **refused** | dashboard only |
 | `video retry-frame` | works | works |
+| `video retry-clip` | 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** |
@@ -218,11 +224,14 @@ Five consequences worth knowing before you promise a user anything:
   slots park is still not a landing: it prints its notice once and the loop
   keeps polling, so a resolve from another shell carries the run on. Do not read
   a park banner mid-poll as the wait having finished.
-- **The run's page link differs.** A Show run's `dashboardUrl` opens
-  `/video?show=…&ad=…`; a showless run gets `/runs/<runId>`, because the `/video`
-  page cannot render one (`convex/http.ts:9204-9211`). The manifest's
-  `dashboardUrl` is always `/video?ad=<runId>`, which is the Show-route shape —
-  on a workflow run, hand the user the link `upload` prints, not the manifest's.
+- **The run's page link differs, and every link the CLI prints follows the run.**
+  A Show ad opens on the `/video` page. A showless workflow run opens on
+  `/workflows/<workflowId>/runs/<runId>`, because `/video` answers "That ad isn't
+  here" for a run with no Show (`getAdDetail` rejects it;
+  `convex/http.ts:9204-9211`). Since #1851 the manifest's `dashboardUrl`, the
+  link in every park block and the link `upload` prints are all minted that way,
+  so they agree on both routes. When all the CLI holds is a run id it mints
+  `/runs/<runId>`, the canonical forwarder, which lands on the same page.
 
 ## The script file
 
@@ -248,8 +257,10 @@ THE SOFTGEL: Tap below and give your eyes ClearBlink.
 ## Reading the storyboard gate
 
 `storyboard <runId>` prints one card per scene on both routes: who speaks, the
-line, the planned duration, and whether its picture is drawn. Read it for the
-user, then ask one question.
+line, the planned duration, and whether its picture is drawn. Under the cards it
+also lists the voices — one line per character who speaks or already has a voice
+— so the user can see who sounds like whom before paying for the clips. Read it
+for the user, then ask one question.
 
 On a **workflow run** the question is approve or don't — there is no flag. If
 the storyboard is wrong, say so plainly and let the user decide between
@@ -302,6 +313,17 @@ on that account. Each refusal says the plain reason and saves nothing. If
 ElevenLabs simply cannot be reached, the choice IS saved and the output says the
 check could not be made — a provider outage never blocks the run.
 
+**Approving checks the voices one last time.** `video approve` re-checks every
+chosen voice before the clips are paid for. If ElevenLabs is certain one of them
+is gone — deleted from the account, or the account changed — the approve is
+refused in one plain sentence, nothing is approved and the command exits 1. Fix
+it by choosing another voice (`video voices <runId> --set <character>=<voiceId>`)
+or clearing that character (`--clear <character>`, which lets the clip keep the
+voice the video model makes), then approve again. When the approve goes through,
+the receipt lists each speaking character and the voice they got, plus any
+`Heads-up:` lines worth reading — that is the last moment a wrong voice is cheap
+to fix.
+
 **The voices file.** A plain JSON object, keyed by the names the script uses:
 
 ```json
@@ -319,6 +341,18 @@ flag says `C2`, that is one character named two ways, and the whole request is
 refused with a sentence saying so. Voice IDs belong to the user's own ElevenLabs account and to that brand's
 folder — never put a brand's voice IDs in a shared workflow or template.
 
+**One file, two moments.** A brand keeps a single `voices.json` in its own
+folder. Hand it to the run at the start with `exodus workflow run <workflow>
+--voices @voices.json` when the script is one the user supplied (it names its
+speakers, so `HOST 1` means something before the planner has run), or hand it in
+at the storyboard review with `exodus video voices <runId> --from voices.json`.
+Launching with voices refuses before the run is created — nothing is spent — if
+a speaker is not in the script, the same speaker is named twice, or ElevenLabs
+is certain it does not have one of the voices; a workflow whose script is
+written by a bot is refused with a pointer at the review-time command, because
+nobody knows the speaker names yet. When the storyboard arrives, the voices are
+already set and `exodus video voices <runId>` shows them.
+
 **The JSON receipt** (`--json`), the same shape for reading and for setting:
 
 ```
@@ -378,18 +412,28 @@ manifest.json            the index below
 `manifest.json`:
 
 ```
-runId, pulledAt, dashboardUrl        the run and its page (/video?ad=<runId>)
+runId, pulledAt, dashboardUrl        the run and the page that opens it:
+                                     /video?ad=<runId> for a Show ad,
+                                     /workflows/<workflowId>/runs/<runId> for a
+                                     workflow run
 storyboard, reference, music         filenames, or null when not delivered
 narration                            { file, timing }, or null on a per-scene run
 cast[]                               one per identity still
   characterId, name                  from the run's cast lock; null for an
                                      unclaimed ledger still
   file, status, error
+  voiceId, voiceLabel                the ElevenLabs voice this character was
+                                     given before the clips were made; null when
+                                     nobody chose one
 scenes[]                             one per scene, in order
   sceneIndex, durationSec            the run's number and the clip's real length
   clip, voice, keyframe, words       filenames, or null
   wordsFrom                          clip | voice — which file the word times are
                                      measured against; null when none came
+  wordsDescribe                      this-file | original-performance — whether
+                                     those times were measured on the file you
+                                     have, or on the take a cast voice replaced;
+                                     null when no words came
   clipStatus                         done | failed | running | pending | missing
   error                              why the clip failed, when it did
   flagged, findings[]                QC verdict: {check, code, severity: fail|warn, detail}
@@ -466,6 +510,18 @@ re-based to the start of that scene's cut; on a per-scene run it is instead a
 blind Scribe pass over that scene's own voice track. Nothing is aligned to the
 finished ad — that timeline does not exist until you make it.
 
+**How far to trust them** (`wordsDescribe`). `"this-file"` means the times were
+measured on the very file `wordsFrom` names, so they hold to the frame: cut
+captions and cue points straight off them. `"original-performance"` means the
+scene's clip was re-voiced *after* its words were timed — the times describe the
+take the cast voice replaced. The words and their order are right and the timing
+is close, but nothing re-measures it, so check any cut that has to land on a
+single frame. A clip carrying a `voice-timing-shifted` warning is the same thing
+with a measured gap: the swapped audio came back a different length, so treat
+that scene's times as a rough guide and watch it before you trust it. Nothing in
+the pipeline speeds audio or video up or slows it down to make the two agree —
+the timings are reported honestly instead.
+
 **Cast identity stills** (`cast-*.<ext>`). A full-body identity still per cast
 member, on a plain neutral background in the run's style, minted once and
 frozen onto the run as its cast lock. Every scene picture was anchored to these,
@@ -487,14 +543,19 @@ music failure degrades to a warning rather than blocking the run.
 - `wordsFrom: "voice"`, or a scene whose storyboard entry has `voText` and no
   on-camera line: the clip is picture only and the voice track is the sound.
   Do not use that clip's own audio.
+- `wordsDescribe: "original-performance"`: the word times were measured before
+  that clip's cast voice was swapped in. Close, not frame-exact — say so if the
+  user is cutting captions to the frame.
 - `manifest.narration` present: listen to `narration.mp3` end to end, then the
   joins between adjacent `scene-NN.voice` files, before you trust the cut.
   Matching voice IDs and a one-speaker diarization result do not prove
   continuity (#1802).
 - `flagged: true` is a warning, not a block. The clip was delivered anyway; the
   findings say what the QC model saw (`wrong-character`, `eyeline-off`,
-  `set-drift`, `speech-cutoff`, `framing-off`). Tell the user which scenes are
-  flagged and why, and let them decide whether to keep, trim, or drop each one.
+  `set-drift`, `speech-cutoff`, `framing-off`, `voice-timing-shifted`). Tell the
+  user which scenes are flagged and why, and let them decide whether to keep,
+  trim, drop or redo each one (`retry-clip`, see "Redoing one clip at the final
+  watch").
   A `speech-cutoff` on the CTA scene is the one to worry about; the ad's last
   words are missing. `status` shows the checker's own wording behind each
   finding; the manifest carries only the verdict.
@@ -506,6 +567,49 @@ music failure degrades to a warning rather than blocking the run.
   the run parks at the final watch, which means nothing is still rendering.
 - `failed[]` non-empty: run the same `pull` again.
 
+## Redoing one clip at the final watch
+
+`retry-clip` re-renders ONE scene's clip on the run that already made it. There
+is no second run, no new storyboard and no re-render of anything else.
+
+```
+exodus video retry-clip <runId> --scene 3
+exodus video retry-clip <runId> --scene 3 --note "keep both hands in frame on the handshake"
+exodus video retry-clip <runId> --scene 3 --node video-2
+```
+
+`--node` is only needed when a run has clips for that scene on two video steps;
+the CLI asks for it by name when it does.
+
+**When it is allowed.** A failed clip, once the step that made it has finished. A
+finished clip, only while the run is parked at the final watch, or when QC
+flagged it (`flagged: true` in `status` and in the manifest). Everything else is
+refused in one plain sentence before any task is queued: a step still rendering
+its other scenes or one that failed outright, a scene already being redone, a
+finished clip on a run that is not at its final watch. An ad that is already
+delivered is refused by the server, in its own sentence.
+
+**What stays untouched.** Every other scene's clip, every keyframe, the cast
+pins, the voices and the approved script. The redone clip re-renders from the
+same keyframe with the same voice path the first take used, so it comes back
+revoiced and trimmed the same way, with fresh findings and fresh word timings.
+
+**A `--note` steers the motion, never the words.** It is folded into that
+scene's motion prompt only (`withRedoDirection`,
+`scout/src/trigger/workflow-scene-retry.ts`); the spoken line still comes from
+the approved storyboard. Asking for different words in a note will not change
+them. If the words are wrong, that is a storyboard flag or a new run.
+
+**A redo whose take fails the checks keeps the original clip.** On a finished
+clip the row stays `done` with the ORIGINAL take and only its findings are
+refreshed, because a worse take must never replace a delivered one. So never
+report that the clip changed. Read `status` again for the new findings, then pull
+and compare the file before and after.
+
+**Re-cut afterwards.** A cut you already uploaded still holds the old clip, and
+the CLI says so when that is the case. Pull again, re-cut and upload again before
+anyone approves.
+
 ## Cutting the ad
 
 Editing is the part every user does differently, and the team is deliberately

package/dist/commands/video.d.ts

@@ -70,6 +70,7 @@ export interface VideoRunNode {
     kind: string;
     status: "idle" | "running" | "done" | "failed" | "skipped";
     error?: string;
+    warning?: string;
     outputs?: ArtifactSubset[];
 }
 export type BuilderPauseReason = "taste" | "repair" | "slots" | "call" | "checkpoint";
@@ -96,6 +97,8 @@ export interface VideoRun {
     pausedNodeId?: string;
     nodes: VideoRunNode[];
     castLock?: PullCastLock | null;
+    workflowId?: string;
+    moduleOwned?: boolean;
 }
 export declare function asVideoRun(data: unknown): VideoRun;
 export interface NodeItem {
@@ -177,7 +180,8 @@ export type RunStop = {
 export declare function classifyRun(run: VideoRun): RunStop;
 export declare function stageWord(stage: string): string;
 export declare function stepName(kind: string | undefined): string;
-export declare function stopLines(stop: RunStop, runId: string, dashboardUrl: string): string[];
+export declare function reviewUrl(dashboardUrl: string, run: Pick<VideoRun, "_id" | "workflowId" | "moduleOwned">): string;
+export declare function stopLines(stop: RunStop, runId: string, runUrl: string): string[];
 export interface PullDownload {
     file: string;
     url: string;
@@ -192,6 +196,7 @@ export interface ManifestScene {
     clip: string | null;
     words: string | null;
     wordsFrom: "clip" | "voice" | null;
+    wordsDescribe: "original-performance" | "this-file" | null;
     voice: string | null;
     keyframe: string | null;
     qc: ClipQc | null;
@@ -214,6 +219,8 @@ export interface ManifestCastRef {
     file: string | null;
     status: string;
     error: string | null;
+    voiceId: string | null;
+    voiceLabel: string | null;
 }
 export interface VideoManifest {
     runId: string;
@@ -265,6 +272,22 @@ export declare function storyboardFlow(runId: string, json: boolean, deps: Video
 export declare function approveFlow(runId: string, json: boolean, deps: VideoDeps): Promise<FlowResult>;
 export declare function flagFlow(runId: string, note: string, json: boolean, deps: VideoDeps): Promise<FlowResult>;
 export declare function retryFrameFlow(runId: string, nodeId: string, sceneIndex: number, note: string | undefined, json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export type ClipRedoPlan = {
+    ok: true;
+    nodeId: string;
+    sceneIndex: number;
+    attempt: number;
+    warnings: string[];
+} | {
+    ok: false;
+    reason: string;
+};
+export interface ClipRedoTarget {
+    sceneIndex: number;
+    nodeId?: string;
+}
+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 interface CastVoiceRow {
     characterId: string;
     name: string;

package/dist/commands/video.js

@@ -40,6 +40,10 @@ 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.
+
   8. Make your cut from those files.
 
   9. exodus video upload <runId> --file cut.mp4
@@ -56,6 +60,7 @@ 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]
@@ -72,9 +77,12 @@ 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
@@ -93,6 +101,7 @@ 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
@@ -260,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.",
@@ -278,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") {
@@ -285,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 [
@@ -302,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)}.`];
@@ -358,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;
@@ -422,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 });
@@ -598,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,
@@ -610,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(),
@@ -626,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,
@@ -668,6 +718,7 @@ export function markPullFailure(manifest, failure) {
         if (scene.words === failure.file || lostWordsSource) {
             scene.words = null;
             scene.wordsFrom = null;
+            scene.wordsDescribe = null;
         }
     }
 }
@@ -773,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}`,
@@ -826,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}`;
@@ -860,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();
@@ -886,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.");
     }
@@ -909,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}`);
             }
@@ -958,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>`);
@@ -992,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}`,
         ],
     };
@@ -1052,6 +1142,127 @@ 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 = {};
@@ -1138,14 +1349,30 @@ function availabilityWords(row) {
             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 = row.voice
-            ? `${row.voice.label ? `${row.voice.label} (${row.voice.voiceId})` : row.voice.voiceId}`
-            : "—";
+        const voice = voiceWords(row.voice);
         lines.push(`  ${row.characterId}  ${row.name}  ${voice}  ${availabilityWords(row)}  ` +
             `speaks in ${row.spokenScenes} scenes, about ${row.spokenSeconds}s`);
     }
@@ -1449,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,
@@ -1543,6 +1770,7 @@ export async function run(flags) {
         "approve",
         "flag",
         "retry-frame",
+        "retry-clip",
         "voices",
         "pull",
         "upload",
@@ -1576,6 +1804,17 @@ 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 {

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;

package/dist/commands/workflow.js

@@ -9,7 +9,7 @@ import { runVerdict } from "../lib/runVerdict.js";
 import { workflowToYaml, parseWorkflowText } from "../lib/workflowText.js";
 import { missingRouteLine } from "../lib/route-support.js";
 import { getChannel } from "../lib/channel.js";
-import { asVideoRun, classifyRun, stopLines } from "./video.js";
+import { asVideoRun, classifyRun, reviewUrl, stopLines, } from "./video.js";
 export const helpText = `
 exodus workflow — List, describe, run, inspect, import, and export saved workflows
 
@@ -20,7 +20,7 @@ Usage:
   exodus workflow templates [list] [--json]
   exodus workflow templates export <key> [--out <file>] [--json]
   exodus workflow schema [--kind <kind>] [--face <face>] [--json]
-  exodus workflow run <workflowId|name> [--fill <name>] [--input key=value ...] [--input <fileField>=<path> ...] [--rig-overrides <json|@file>] [--auto-approve] [--wait] [--out <dir>] [--json]
+  exodus workflow run <workflowId|name> [--fill <name>] [--input key=value ...] [--input <fileField>=<path> ...] [--rig-overrides <json|@file>] [--voices <json|@voices.json>] [--auto-approve] [--wait] [--out <dir>] [--json]
   exodus workflow status [--json]
   exodus workflow status --id <runId> [--out <dir>] [--json]
   exodus workflow cancel <runId> [--reason "..."] [--json]
@@ -83,6 +83,25 @@ Flags:
                          before anything runs, and the error names it. On
                          "triggers fire" it REPLACES the schedule's own
                          overrides for that one test fire.
+  --voices <json>        (run) Give the ad's characters their voices at the
+                         moment the run starts, instead of at the storyboard
+                         review. Keyed by the names the SCRIPT uses for its
+                         speakers ("HOST 1") — the planner's character ids
+                         (C1, C2) do not exist yet when a run starts. Takes a
+                         JSON object, or @path to a .json file holding one:
+                           --voices @voices.json
+                           --voices '{"HOST 1":"<voiceId>"}'
+                         Same file "exodus video voices <run> --from" reads at
+                         the review, so a brand keeps ONE voices.json for both.
+                         A speaker the script does not have, the same speaker
+                         named twice, or a voice ElevenLabs does not have stops
+                         the launch before the run is created — nothing is
+                         spent, and the message says which one. A workflow whose
+                         script is written by a bot (so nobody knows the speaker
+                         names at the start) is told to use "exodus video voices
+                         <run>" at the storyboard review instead. Voice ids
+                         belong to the brand's own folder — never put them in a
+                         shared workflow or template.
   --auto-approve         (run) Deliberately unattended launch: every Checkpoint
                          box this run stops at is approved automatically, with
                          whatever it was holding left exactly as it is, and the
@@ -174,6 +193,7 @@ Examples:
   exodus workflow run "Launch Flow" --auto-approve --wait
   exodus workflow run "Product Shots" --rig-overrides '{"rig_1":{"lines":{"line_1":{"count":3}}}}'
   exodus workflow run "Product Shots" --rig-overrides @rig.json --wait
+  exodus workflow run "Podcast Ad" --input script=@script.txt --voices @voices.json --wait
   exodus workflow run "Launch Flow" --wait --out ./deliverables
   exodus workflow status                      # recent runs + their ids
   exodus workflow status --id wr_123
@@ -235,6 +255,19 @@ Notes:
   message says which key was wrong. A trigger can carry the same payload in its
   YAML ("imageRigOverrides:" beside its schedule), so a Monday schedule and a
   Friday one can fire the same workflow at different sizes.
+  "workflow run --voices" hands a video run its voices at the start, so a brand
+  that always uses the same hosts stops choosing them by hand on every run. The
+  file is keyed by the names the script uses for its speakers, because that is
+  all that exists before the planner has run — it is the SAME voices.json
+  "exodus video voices <run> --from" reads at the storyboard review, so one file
+  per brand serves both moments. A speaker the script does not have, the same
+  speaker named twice, or a voice ElevenLabs does not have stops the launch
+  before the run exists and nothing is spent. When the storyboard is planned,
+  each named speaker's character already has their voice, and "exodus video
+  voices <run>" shows them set. A workflow whose script is written by a bot has
+  no speaker names to key on at the start, so it is refused with a pointer at
+  the review-time command. Keep voice ids in the brand's own folder, never in a
+  shared workflow or template. (#1846)
   workflow triggers are addressed by 1-based position — a trigger carries no id,
   so the CLI reads the live list from the export contract and sends a fingerprint
   of the trigger's fields as the guard; a concurrent edit fails loud rather than
@@ -320,6 +353,7 @@ const VALUE_FLAGS = new Set([
     "slot",
     "reject",
     "rig-overrides",
+    "voices",
     "note",
 ]);
 function defaultMkdirp(dir) {
@@ -917,6 +951,63 @@ export function parseRigOverridesFlag(args, readFile) {
     }
     return parsed;
 }
+export function parseVoicesFlag(args, 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 {
+            continue;
+        }
+        if (value === undefined || value.startsWith("--")) {
+            throw new Error("--voices requires JSON or @path/to/voices.json");
+        }
+        raw = value;
+    }
+    if (raw === undefined)
+        return undefined;
+    let text = raw.trim();
+    if (!text)
+        throw new Error("--voices requires JSON or @path/to/voices.json");
+    if (text.startsWith("@@")) {
+        text = text.slice(1);
+    }
+    else if (text.startsWith("@")) {
+        const filePath = text.slice(1);
+        if (!filePath) {
+            throw new Error("--voices @<file> needs a file path after \"@\"");
+        }
+        if (!readFile) {
+            throw new Error(`--voices: cannot load @${filePath} here (no file access)`);
+        }
+        try {
+            text = readFile(filePath);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`--voices: could not read file "${filePath}": ${msg}`);
+        }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`--voices is not valid JSON: ${msg}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("--voices must be a JSON object keyed by the script's speaker names, e.g. {\"HOST 1\":\"<voiceId>\"}");
+    }
+    return parsed;
+}
 export function parseFillFlag(args) {
     let name;
     for (let i = 0; i < args.length; i++) {
@@ -1723,6 +1814,20 @@ export async function botsFlow(opts, deps) {
         return { code: 0, lines: [JSON.stringify(catalog)] };
     return { code: 0, lines: [formatBotsList(catalog, opts.category)] };
 }
+function launchVoicesLine(attached) {
+    if (!Array.isArray(attached))
+        return undefined;
+    const said = [];
+    for (const raw of attached) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const { speaker, voiceId, label } = raw;
+        if (typeof speaker !== "string" || typeof voiceId !== "string")
+            continue;
+        said.push(`${speaker} → ${typeof label === "string" && label !== "" ? label : voiceId}`);
+    }
+    return said.length > 0 ? `Voices: ${said.join(", ")}` : undefined;
+}
 export async function runFlow(workflowRef, opts, deps) {
     let workflowId;
     try {
@@ -1765,6 +1870,7 @@ export async function runFlow(workflowRef, opts, deps) {
         ...(opts.fill && opts.fill.trim() !== "" ? { fill: opts.fill.trim() } : {}),
         ...(opts.autoApprove === true ? { autoApprove: true } : {}),
         ...(opts.imageRigOverrides ? { imageRigOverrides: opts.imageRigOverrides } : {}),
+        ...(opts.voices ? { voices: opts.voices } : {}),
         launchedVia: "cli",
     };
     const start = await deps.post(RUN_PATH, body);
@@ -1778,6 +1884,7 @@ export async function runFlow(workflowRef, opts, deps) {
     const base = { ...data, workflowId };
     if (opts.json && !opts.wait)
         return { code: 0, lines: [JSON.stringify(base)] };
+    const voicesLine = launchVoicesLine(data?.launchVoices);
     const lines = opts.json
         ? []
         : [
@@ -1785,6 +1892,7 @@ export async function runFlow(workflowRef, opts, deps) {
             "Workflow run started.",
             `runId:        ${data.runId}`,
             `triggerRunId: ${data.triggerRunId}`,
+            ...(voicesLine ? [voicesLine] : []),
             `Poll: exodus workflow status --id ${data.runId}`,
         ];
     if (!opts.wait) {
@@ -1903,7 +2011,8 @@ async function waitForRun(runId, opts, deps) {
         lines.push("", landOnPark.headline, ...formatPauseNotice(landOnPark.pauseReason, runId, dashboardUrl).slice(1));
     }
     if (videoStop) {
-        lines.push("", ...stopLines(videoStop, runId, deps.dashboardUrl ?? getDashboardUrl()));
+        const review = reviewUrl(deps.dashboardUrl ?? getDashboardUrl(), asVideoRun(pollResult.data));
+        lines.push("", ...stopLines(videoStop, runId, review));
     }
     return { code: pollResult.ok ? 0 : 1, lines };
 }
@@ -2900,19 +3009,21 @@ export async function run(flags) {
         const workflowRef = rest[0];
         if (!workflowRef) {
             console.error("Error: workflow run requires <workflowId|name>.");
-            console.log("Usage: exodus workflow run <workflowId|name> [--fill <name>] [--input key=value ...] [--input <fileField>=./path/to/file ...] [--auto-approve] [--wait] [--json]");
+            console.log("Usage: exodus workflow run <workflowId|name> [--fill <name>] [--input key=value ...] [--input <fileField>=./path/to/file ...] [--rig-overrides <json|@file>] [--voices <json|@voices.json>] [--auto-approve] [--wait] [--json]");
             process.exit(1);
         }
         let inputs;
         let fill;
         let autoApprove;
         let imageRigOverrides;
+        let voices;
         try {
             inputs = parseRawInputFlags(process.argv.slice(3));
             rejectTerminalFlag(process.argv.slice(3));
             fill = parseFillFlag(process.argv.slice(3));
             autoApprove = parseAutoApproveFlag(process.argv.slice(3));
             imageRigOverrides = parseRigOverridesFlag(process.argv.slice(3), defaultDeps.readFile);
+            voices = parseVoicesFlag(process.argv.slice(3), defaultDeps.readFile);
         }
         catch (e) {
             console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
@@ -2923,6 +3034,7 @@ export async function run(flags) {
             fill,
             autoApprove,
             imageRigOverrides,
+            voices,
             wait: flags["wait"] === true,
             json,
             out: flagString(flags, "out"),

package/package.json

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