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

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) {
@@ -393,10 +407,15 @@ function castVoicePins(artifact) {
     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)
+        const description = typeof member.voiceDescription === "string" ? member.voiceDescription.trim() : "";
+        if (!characterId || (!voiceId && !description))
             continue;
         const label = typeof member.voiceLabel === "string" ? member.voiceLabel.trim() : "";
-        pins.set(characterId, { voiceId, voiceLabel: label ? label : null });
+        pins.set(characterId, {
+            voiceId: voiceId ? voiceId : null,
+            voiceLabel: voiceId && label ? label : null,
+            voiceDescription: description ? description : null,
+        });
     }
     return pins;
 }
@@ -473,6 +492,7 @@ function planCastRefs(run, items, pins) {
             error: row.error,
             voiceId: pin?.voiceId ?? null,
             voiceLabel: pin?.voiceLabel ?? null,
+            voiceDescription: pin?.voiceDescription ?? null,
         });
         if (file && row.url)
             downloads.push({ file, url: row.url });
@@ -653,6 +673,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,
@@ -686,6 +707,9 @@ export function planPull(run, items, opts) {
                 : null,
             scenes,
             failed: [],
+            ...(run.provenance?.format || run.provenance?.voice
+                ? { provenance: run.provenance }
+                : {}),
         },
     };
 }
@@ -710,6 +734,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 +1171,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 +1218,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 +1292,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 +1463,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));
@@ -1337,7 +1509,7 @@ export async function voicesFlow(runId, voices, json, deps) {
 }
 function availabilityWords(row) {
     if (!row.voice)
-        return "no voice yet";
+        return row.description ? "voice written below" : "no voice yet";
     switch (row.availability?.state) {
         case "available":
             return "ElevenLabs has it";
@@ -1349,10 +1521,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 +1534,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)
@@ -1369,12 +1543,17 @@ function voiceSummaryLines(cast, notices) {
 }
 export function voiceSheetLines(sheet) {
     const lines = [`Voices for run ${sheet.runId}`];
+    if (typeof sheet.treatment.path === "string" && sheet.treatment.path !== "") {
+        lines.push(`  Treatment: ${sheet.treatment.path}`);
+    }
     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`);
+        if (row.description)
+            lines.push(`      written voice: ${row.description}`);
     }
     if (sheet.narrator) {
         const label = sheet.narrator.label ? `${sheet.narrator.label} ` : "";
@@ -1386,9 +1565,16 @@ export function voiceSheetLines(sheet) {
             : "Nothing changed — those voices were already set. Pictures and script were not touched.");
     }
     lines.push(`How voices are applied: ${sheet.treatment.summary}${sheet.treatment.speedChange ? "" : " No speed change."}`);
-    lines.push(`Cost: billed to your own ElevenLabs key. ${sheet.treatment.costNote} ` +
-        `About ${sheet.treatment.usage.seconds} seconds of speech across ` +
-        `${sheet.treatment.usage.clips} clips will be converted.`);
+    const rendersOwnVoice = sheet.treatment.kind === "render-owns-voice";
+    if (!rendersOwnVoice || sheet.treatment.usesElevenLabs === undefined) {
+        lines.push(`Cost: billed to your own ElevenLabs key. ${sheet.treatment.costNote} ` +
+            `About ${sheet.treatment.usage.seconds} seconds of speech across ` +
+            `${sheet.treatment.usage.clips} clips will be converted.`);
+    }
+    else if (sheet.treatment.usesElevenLabs) {
+        lines.push("Cost: the narration on this run is voiced by ElevenLabs and billed to your own key. " +
+            `${sheet.treatment.costNote} The clips themselves are not converted.`);
+    }
     for (const notice of sheet.notices)
         lines.push(notice);
     lines.push(sheet.canChange
@@ -1738,7 +1924,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 +1957,7 @@ export async function run(flags) {
         "flag",
         "retry-frame",
         "retry-clip",
+        "revoice",
         "voices",
         "pull",
         "upload",
@@ -1815,10 +2002,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";
@@ -289,6 +290,11 @@ export interface WorkflowRunOutput {
     durationSec?: number;
     sceneIndex?: number;
     final?: boolean;
+    words?: Array<{
+        w: string;
+        s: number;
+        e: number;
+    }>;
     frames?: Array<{
         sceneIndex: number;
         imageUrl?: string;
@@ -346,6 +352,36 @@ export interface WorkflowPendingSlot {
     value?: string;
     hint?: string;
 }
+export interface RunFormatProvenance {
+    via: "show" | "rig-node";
+    nodeId?: string;
+    rigId: string;
+    rigName: string;
+    rulesFrom?: {
+        rigId: string;
+        rigName: string;
+    };
+    specVersion: string | null;
+}
+export type VoicePath = "sts-revoice" | "lipsync-retarget" | "native-prompt" | "omni-audio-ids" | "gemini-direct";
+export type RunVoiceProvenance = {
+    source: "show";
+    path: VoicePath;
+} | {
+    source: "launch";
+    path: VoicePath;
+    descriptions: {
+        speaker: string;
+        description: string;
+    }[];
+} | {
+    source: "unreadable";
+};
+export interface RunProvenance {
+    format: RunFormatProvenance | null;
+    voice: RunVoiceProvenance | null;
+}
+export declare function formatRulesLine(provenance: unknown): string | undefined;
 export interface WorkflowRun {
     _id: string;
     workflowId: string;
@@ -371,6 +407,7 @@ export interface WorkflowRun {
         nodeId: string;
         approvedAt: number;
     }[];
+    provenance?: RunProvenance;
 }
 export type WorkflowRunProjection = Omit<WorkflowRun, "nodes"> & {
     nodes?: never;
@@ -409,6 +446,7 @@ interface RunFlowOptions {
     autoApprove?: boolean;
     imageRigOverrides?: Record<string, unknown>;
     voices?: VoiceMap;
+    voiceTreatment?: VoiceTreatmentBody;
     wait: boolean;
     json: boolean;
     out?: string;
@@ -416,8 +454,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 +464,16 @@ 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 interface VoiceTreatmentBody {
+    path: string;
+    describe?: Record<string, string>;
+}
+export declare function parseVoiceTreatmentFlag(occurrences: FlagOccurrence[], readFile?: (path: string) => string): VoiceTreatmentBody | 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;
@@ -463,6 +506,7 @@ export declare function botsFlow(opts: {
     slug?: string;
     json: boolean;
 }, deps: WorkflowRunDeps): Promise<FlowResult>;
+export declare function voiceTreatmentLine(provenance: unknown): string | undefined;
 export declare function runFlow(workflowRef: string, opts: RunFlowOptions, deps: WorkflowRunDeps): Promise<FlowResult>;
 export declare function statusFlow(opts: {
     id?: string;
@@ -586,9 +630,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 {};