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

package/assets/docs/PIPELINES.md

@@ -256,10 +256,14 @@ 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 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

@@ -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,9 @@ 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
+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
@@ -115,7 +120,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 +176,8 @@ 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 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** |
@@ -218,11 +226,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 +259,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
@@ -266,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.
 
 ```
@@ -302,6 +317,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 +345,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:
 
 ```
@@ -329,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
@@ -344,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;
@@ -378,18 +419,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}
@@ -401,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}
 ```
 
@@ -466,6 +521,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 +554,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 +578,108 @@ 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.
+
+## 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;
@@ -70,6 +73,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 +100,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 +183,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,11 +199,13 @@ 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;
     revoiced: boolean | null;
     speechTrimmed: boolean | null;
+    rawStorageId: string | null;
     clipStatus: string;
     error: string | null;
     flagged: boolean;
@@ -214,6 +223,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 +276,27 @@ 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 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;
@@ -272,6 +304,7 @@ export interface CastVoiceRow {
         voiceId: string;
         label?: string;
     } | null;
+    voiceFrom?: "own-pin" | "run-default";
     availability?: {
         state: "available";
         providerName: string;
@@ -311,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>;
@@ -320,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>;