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

package/assets/docs/CLAUDE.md

@@ -61,7 +61,7 @@ These are the **Exodus** pipelines — the automatic system that drives the Gene
 | **Meme** | `exodus-meme` | Meme ads — recommends formats for a brief, then one batched run renders AI-image and classic Imgflip-template memes server-side. |
 | **Workflow** | `exodus-workflow` | Run and build saved multi-node workflow automations from the CLI, resolve checkpoint/repair parks from the inbox, continue bot sessions, fire triggers, and read banks or promote winners. |
 | **Hooks** | `exodus-hooks` | Read the Scout library — the hook cards captured from Instagram outliers. Compose filters (score, lane, validation status, language, hook type, recency), inspect one card, find cards sharing a hook pattern, export to CSV. Read-only. |
-| **Video** | `exodus-video` | Make a video ad from a script. Main path: run a saved video workflow (`npx @aicopycoders/exodus workflow run`, no Show); starting from a Show (`video start --show`) is the other way in. Then read and approve the storyboard, `npx @aicopycoders/exodus video pull` every piece (per-scene clips, narration and per-scene voice, keyframes, cast stills, word timings, music bed) plus a manifest, cut them in whatever editor you use (a bundled script is one option), upload the cut and approve it. Admin-only. |
+| **Video** | `exodus-video` | Make a video ad from a script. Main path: run a saved video workflow (`npx @aicopycoders/exodus workflow run`, no Show); starting from a Show (`video start --show`) is the other way in. Choose the voices as the run starts: `--voices` gives each speaker an ElevenLabs voice, `--voice-treatment` says how the voices are made (including having the video model speak a voice you wrote). Then read and approve the storyboard, `npx @aicopycoders/exodus video pull` every piece (per-scene clips, narration and per-scene voice, keyframes, cast stills, word timings, music bed) plus a manifest, cut them in whatever editor you use (a bundled script is one option), upload the cut and approve it. Admin-only. |
 | **Browse** | `exodus-browse` | View history and retrieve past outputs |
 | **Drive** | `exodus-drive` | Read/write Google Docs, Sheets, and Drive files via `npx @aicopycoders/exodus drive` (uses the dashboard's Google OAuth — no local CLI) |
 | **Swipe / Mining** | (no skill; CLI only) | The competitor watch list behind the Mining page: `npx @aicopycoders/exodus swipe brands list`, `swipe brands bulk-import <csv>` (checks each brand and starts collecting its ads), `swipe brands add "<Name>" --fb <pageId>` (adds one brand and starts checking it the same way), `swipe run` / `swipe mine`. There is no `competitors` verb. |

package/assets/docs/PIPELINES.md

@@ -215,6 +215,13 @@ Representative commands:
   exodus session list | show | chat
   exodus bank list | show <key> | promote <key>
 Every workflow/session/bank verb takes --json — that output is the machine API.
+
+A video workflow whose Rig box points at a rig with saved format rules follows
+them — how many speakers the script may have, which checks run, how the cast is
+built. The start receipt and `workflow status` name the rulebook and its version;
+`video pull` writes the same facts into manifest.json. Every Rig box in the
+workflow has to point at the same saved rig, or the launch refuses and nothing
+is spent.
 ```
 
 ---
@@ -247,10 +254,14 @@ Returns: a table, --json data, or an exported CSV/JSON file
 
 **What it does:** Makes a video ad from a script, in pieces. Main path is a saved video workflow with no Show (`exodus workflow run <name> --input <field>=@script.txt`); a locked Show (`exodus video start --show`) is the other way in and is the only route with `video flag`. On the workflow route the run stops for your cut only if its video node sets `finalWatch: true` (defaults to off — check with `exodus workflow export`, not `describe`), and video gates are approved with `exodus video approve`, not `workflow checkpoint approve`. Either way the run writes the storyboard, draws a picture per scene, records the voice, renders a clip per scene and generates a music bed, then parks for a cut. The CLI pulls the pieces to a folder with a `manifest.json`; you cut them in whatever editor you use; the upload attaches the cut for approval. Admin-only.
 
+**Voices, on the workflow route.** Two separate choices, both made when the run starts and both refused before the run is created if anything is wrong, so a mistake costs nothing. `--voices @voices.json` says WHICH ElevenLabs voice each speaker gets, keyed by the names the script uses (`HOST 1`) — the same file `exodus video voices <run> --from` reads at the review, so one file per brand serves both moments. `--voice-treatment` says HOW the voices are made: a name on its own for a way of working that plays a voice you picked, or a `voice-treatment.json` shaped `{"path": "...", "describe": {"HOST 1": "Dry, tired baritone."}}` for the ways where the video model speaks the CAST's lines itself in voices you WROTE. A written voice needs one description per speaker, and it cannot be changed at the storyboard review — that is what the flag at launch is for. The two never combine: written voices plus `--voices` is refused, because those ElevenLabs voices would be paid for and never heard. A written voice covers the CAST's lines only: a narrated scene is still recorded by ElevenLabs on the member's own key, so a script with `NARRATOR:` turns still needs the key and still costs ElevenLabs money. Ways of working beyond the two shipped ones are switched on only on the test stack while they are being tried out.
+
 ```operator-guide
 Start (workflow route, no Show):
   exodus workflow list / describe <name>                               find it and see what it needs
   exodus workflow run <workflowId|name> --input <field>=@script.txt [--wait]   start it; --wait stops at the storyboard gate
+  exodus workflow run <workflowId|name> --input <field>=@script.txt --voices @voices.json   ... and give each speaker an ElevenLabs voice up front
+  exodus workflow run <workflowId|name> --input <field>=@script.txt --voice-treatment @voice-treatment.json   ... or have the video model speak voices you WROTE
 Start (Show route):
   exodus video shows [--json]                                          Shows and whether each is ready
   exodus video start --show <id> --script <file> [--wait] [--json]     start an ad run; --wait stops at the storyboard gate
@@ -263,6 +274,7 @@ Then, on either route:
   exodus video status <runId> [--json]                                 the park and each scene's clip/voice/picture
   exodus video pull <runId> --out <dir> [--json]                       every piece + manifest.json
   exodus video retry-clip <runId> --scene <n> [--node <nodeId>] [--note "<t>"] [--json]  redo one clip at the final watch
+  exodus video revoice <runId> (--scene <n> | --all) [--node <nodeId>] [--json]  redo only the voice on finished clips; no new video
   exodus video upload <runId> --file <cut.mp4> [--duration <s>] [--json]   attach the cut (MP4/MOV/WebM, 200 MB)
 Cut: your choice of tool — Exodus does not stitch or mix. One option ships with the skill:
   node .claude/skills/exodus-video/scripts/first-cut.mjs <dir> [--skip n,m] [--no-music] [--out f]

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

@@ -77,6 +77,8 @@ 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 workflow run <workflowId|name> --input <field>=@script.txt --voice-treatment @voice-treatment.json --wait
+                                                          same, with the video model speaking voices you WROTE
 exodus video status <runId>                               where it is, per scene
 ```
 
@@ -100,6 +102,7 @@ exodus video status <runId>                               where it is, per scene
 exodus video pull <runId> --out ./ad-<runId>              every piece + manifest.json
 exodus video retry-clip <runId> --scene <n> [--node <nodeId>] [--note "…"]
                                                           redo one clip at the final watch
+exodus video revoice <runId> --all | --scene <n>          redo only the voice; no new video
                                                           … make the cut (your choice of tool)
 exodus video upload <runId> --file ./ad-<runId>/cut.mp4   attach it
 exodus video approve <runId>                              make it the ad
@@ -176,6 +179,7 @@ Verified against the routes, not assumed. Everything here is admin-gated on top.
 | script-turn edits at the gate | **refused** | dashboard only |
 | `video retry-frame` | works | works |
 | `video retry-clip` | works | works |
+| `video revoice` | works | works |
 | `video pull` | works | works |
 | `video upload` | only if the video node sets `finalWatch: true` | works |
 | `workflow checkpoint approve` | **refused at a video gate** | **refused at a video gate** |
@@ -254,6 +258,13 @@ CTA:
 THE SOFTGEL: Tap below and give your eyes ClearBlink.
 ```
 
+**How many speakers you may have depends on the rig.** Three by default. A rig
+that carries saved format rules sets its own number: an ensemble rig seats more,
+a talking-head rig seats one. Over the number, the launch refuses before
+anything is spent and says both figures ("4 speakers — this format supports 3").
+The rulebook the run followed is on the start receipt, on `workflow status`, and
+in `manifest.json` under `provenance`.
+
 ## Reading the storyboard gate
 
 `storyboard <runId>` prints one card per scene on both routes: who speaks, the
@@ -277,9 +288,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.
 
 ```
@@ -353,6 +366,88 @@ 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.
 
+**Choosing how the voices are made.** `--voice-treatment` on `workflow run` says
+HOW a run makes its voices, and it is the only door on the workflow route. Two
+kinds of answer.
+
+A name on its own picks a way of working that plays a voice you already have,
+and still pairs with `--voices`:
+
+```
+exodus workflow run "Podcast Ad" --input script=@script.txt \
+  --voice-treatment lipsync-retarget --voices @voices.json
+```
+
+The other kind has the video model speak the CAST's lines itself, in voices you
+WRITE. Those take a `voice-treatment.json`, which is the whole request body:
+
+```json
+{
+  "path": "native-prompt",
+  "describe": {
+    "BUDGET": "Dry, tired middle-aged baritone. Slight rasp. Deadpan, unhurried.",
+    "PIGGY BANK": "Bright quick alto, a little smug, crisp consonants."
+  }
+}
+```
+
+```
+exodus workflow run "Podcast Ad" --input script=@script.txt \
+  --voice-treatment @voice-treatment.json
+```
+
+Every speaker in the script needs a description. One left out gets a voice the
+model invents afresh on every clip, and that drift only shows up once the clips
+are paid for, so the launch refuses instead.
+
+**The narration is not part of this.** A describing treatment changes how the
+CAST's lines are voiced. A scene with narration (`voText`) is still recorded by
+ElevenLabs on the member's own key by the Voiceover step, exactly as it always
+was — so a run with `NARRATOR:` turns still needs an ElevenLabs key, and still
+costs ElevenLabs money. `exodus video voices <runId>` says which of the two
+shapes a run is, and only claims nothing is sent to ElevenLabs when nothing is.
+
+**What refuses, all before the run is created, so nothing is spent.**
+
+- A treatment name that does not exist. The message lists the ones that do.
+- A describing treatment with a speaker undescribed, a speaker the script does
+  not have, the same speaker described twice, or an empty description.
+- Written voices plus `--voices`. The video model owns the voice on those runs,
+  so the ElevenLabs voices would be paid for and never heard.
+- Descriptions on a treatment that plays voices you picked instead.
+- A workflow whose script is written by a bot. Nobody knows the speaker names
+  yet, so there is nothing to describe.
+- A workflow with no Video step, a Video step whose model cannot do what was
+  asked, or a Video step with nothing wired into its voiceover port when the
+  treatment needs one.
+- No Google AI key on the account, for the treatment that renders through
+  Google directly.
+- A rig that shows every line on screen as text. No clip speaks, so there is no
+  voice to treat.
+
+**Still being tested.** Everything beyond the two shipped ways of working is
+switched on only on the test stack while it is being tried out. On the live
+stack those names refuse by name, and the message says which two to use
+instead. That is a property of the stack, not of the workflow, so the same
+saved workflow behaves differently on each — and a retry asks again rather than
+copying, so a run retried after a treatment was switched off refuses.
+
+**A sub-workflow chooses none of this.** When a Call box runs another workflow
+inside this one, the child run carries no voice treatment: it renders the
+shipped default, whatever the parent was started with. A treatment is a choice a
+person made at a keyboard for one run, and nobody made it for the sub-workflow.
+
+**Written voices cannot be changed at the review.** They are chosen when the run
+starts. `exodus video voices <runId>` on a described run names the treatment and
+prints each written voice, and says plainly that `--voice-treatment` at launch is
+what changes them. Do not tell anyone to create a Show for this, and do not set a
+voice path in node config — neither is a door.
+
+**Where it shows up afterwards.** The launch receipt and `exodus workflow status`
+both print one line naming the treatment and the speakers who got a written
+voice. `manifest.json` from `exodus video pull` carries the same under
+`provenance.voice`, and each cast entry carries its `voiceDescription`.
+
 **The JSON receipt** (`--json`), the same shape for reading and for setting:
 
 ```
@@ -361,9 +456,15 @@ runId
 changed[]             the characters whose voice actually moved (set only)
 canChange             false once the run has left the storyboard review
 whyNot                why, in one sentence, when canChange is false
+treatment.path        which way of making voices this run froze, or null
+treatment.kind        "performance-then-conversion" or "render-owns-voice"
 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
+  description         the WRITTEN voice, when the run was given one
   availability        { state: "available" | "missing" | "not-checked", … }
   spokenScenes        how many scenes this character speaks in
   spokenSeconds       those scenes' planned seconds — what ElevenLabs bills on
@@ -378,8 +479,8 @@ A failure is the same shape every `video` verb uses:
 `{ "ok": false, "status": 400, "error": "<one plain sentence>" }`, exit 1.
 
 **Before you approve, read `notices`.** The ones that cost the user something:
-a character who speaks but has no voice (those clips keep their generated
-voice), no ElevenLabs key saved on the run (no voice can be applied at all), and
+a character who speaks but has no voice of their own and no run default to fall
+back on (those clips keep their generated voice), no ElevenLabs key saved on the run (no voice can be applied at all), and
 a voice ElevenLabs no longer has.
 
 `estimatedCostUsd` is always null. Exodus cannot price a voice conversion yet;
@@ -445,6 +546,19 @@ 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
+provenance                           which saved rulebook this run followed:
+                                     {format: {via, nodeId, rigId, rigName,
+                                     rulesFrom, specVersion}}. Absent when the
+                                     run followed none. `nodeId` is the Rig box
+                                     that chose it (absent on a Show ad, which
+                                     has no box); `rulesFrom` names the rig the
+                                     rules were borrowed from when the picked
+                                     rig is a copy. Names, ids and a version
+                                     only — never the rules themselves
 failed[]                             files that did not download: {file, url, error}
 ```
 
@@ -493,13 +607,16 @@ own ElevenLabs render.
 **Which scenes carry their voice where.** A scene whose storyboard entry has a
 non-empty `voText` is a narrator scene: its clip is rendered silent and the
 voice arrives as a separate track. A scene with on-camera `dialogue[]` has the
-speech inside the clip — under the default voice path the video model's invented
-voice is then replaced, in place, with the cast member's pinned ElevenLabs voice
-(that is `revoiced: true`). Other voice paths leave the render owning its own
-audio, e.g. lip-sync retargeting a VO track onto the video. The path is frozen
-on the run — `--voice-path` on `video start` sets it on a Show run, the node
-config sets it on a workflow run. Read `wordsFrom` and `revoiced` per scene
-rather than assuming.
+speech inside the clip — under the default voice treatment the video model's
+invented voice is then replaced, in place, with the cast member's pinned
+ElevenLabs voice (that is `revoiced: true`). Other treatments leave the render
+owning its own audio, e.g. lip-sync retargeting a VO track onto the video. The
+treatment is frozen on the run when it starts, and there are exactly two doors
+that set one: `--voice-path` on `video start` for a Show run, and
+`--voice-treatment` on `workflow run` for a workflow run (see **Choosing how the
+voices are made**). Node config is never a door — nothing on the canvas sets a
+voice treatment, and a run that was given none renders the default. Read
+`wordsFrom` and `revoiced` per scene rather than assuming.
 
 **Word timings** (`scene-NN.words.json`). Seconds from the start of the file
 `wordsFrom` names, always. `wordsFrom: "clip"` is an ElevenLabs Scribe
@@ -610,6 +727,65 @@ and compare the file before and after.
 the CLI says so when that is the case. Pull again, re-cut and upload again before
 anyone approves.
 
+## Redoing only the voice on finished clips
+
+`revoice` puts clips that are already paid for back through the voice pass: the
+spoken words are checked against the script, the clip is trimmed to the speech,
+and the chosen voice is applied. It makes no new video, so the picture cannot
+change and no video credits are spent. ElevenLabs bills the voice work to the
+member's own key.
+
+```
+exodus video revoice <runId> --all
+exodus video revoice <runId> --scene 3
+```
+
+**When to reach for it.** `status` shows talking clips with `voice-unpinned` or
+`voice-not-applied` (usually next to `speech-check-skipped`), and the manifest
+shows `revoiced: false` with no words file. The usual cause is a run that had no ElevenLabs key when its
+clips were made. `voices <runId>` says so: "This run has no ElevenLabs key saved".
+
+**It finds the key by itself.** Before queuing anything, the server gives the run
+the ElevenLabs key saved on the run owner's account, if the run has none. When
+there is no saved key either, nothing is queued and the refusal says where to add
+one (Settings → Keys). Approving a storyboard does the same top-up, so an older
+run parked at its storyboard is fixed before any clip is paid for.
+
+**`--all` picks the clips that need it.** Every finished clip whose file is still
+the video model's own and whose findings carry `voice-unpinned` or
+`voice-not-applied`, the two codes that mean a voice change should have happened
+and did not. `speech-check-skipped` alone does not qualify: it also lands on
+clips whose sound the video model or a later step owns, where there is no voice
+to change and a pass would bill a transcription for nothing. `--scene <n>` is
+not filtered this way; the server decides. It sends one request per scene, tries
+every one, and reports each. Scenes refused with the same sentence share one
+line (a run with no key prints that sentence once); `--json` keeps one entry per
+scene.
+
+**What is refused.** A clip that already went through the voice pass (`revoiced`,
+`speechTrimmed` or a trimmed tail): the pass would trim or convert it twice. Use
+`retry-clip` to make that clip again from scratch. A failed clip, a scene already
+being redone, a step still rendering, and an ad already delivered.
+
+**An older server starts nothing.** The voice redo has its own server route and
+its own worker task. A server or worker from before it existed cannot run it, and
+the CLI never falls back to `retry-clip`'s route, which would make new paid video.
+You get one sentence saying the server does not have the voice redo yet, and
+nothing is queued or spent.
+
+**A clip is never lost.** The clip stays on its row the whole time. If the voice
+pass cannot finish, the clip, its findings and its cost are left as they were and
+one warning, `revoice-not-finished`, is added. Run it again. If ElevenLabs refuses
+the key, the clip comes back unchanged with `voice-not-applied`.
+
+**If the word check now fails.** The voiced clip is still delivered, and the scene
+is flagged with the finding, because the picture is the same one the ad already
+had. Decide from `status`: keep it, or `retry-clip` it.
+
+**Afterwards.** Pull again. Each voiced scene now has `revoiced: true`, a words
+file, and `rawStorageId` naming the original file. Re-cut and upload again if a
+cut was already uploaded; the CLI says so when that is the case.
+
 ## Cutting the ad
 
 Editing is the part every user does differently, and the team is deliberately

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

@@ -8,7 +8,7 @@ Core — discover & run:
   exodus workflow list [--json]                              List the brand's saved workflows
   exodus workflow describe <workflowId|name> [--json]        Inputs, prerequisites, outputs
   exodus workflow bots [--category <cat>] [--slug <slug>] [--json]   Bot catalog / one bot's spec
-  exodus workflow run <workflowId|name> [--input key=value ...] [--fill <name>] [--auto-approve] [--wait] [--out <dir>] [--json]   Run it
+  exodus workflow run <workflowId|name> [--input key=value ...] [--fill <name>] [--voices <json|@file>] [--voice-treatment <name|json|@file>] [--auto-approve] [--wait] [--out <dir>] [--json]   Run it
   exodus workflow status [--id <runId>] [--out <dir>] [--json]   Poll a run / read its outputs (no --id → the brand's 25 newest runs + their ids)
   exodus workflow cancel <runId> [--reason "..."] [--json]   Stop a run that hasn't finished — queued, running, or parked
   exodus workflow export <workflowId|name> [--version <n>] [--out <file>] [--json]   Dump the contract (YAML)
@@ -51,6 +51,24 @@ Flag notes that add agent-level guidance (everything else is in --help):
                        earlier upload is relayed as-is. Accepted: image PNG/JPEG/
                        WebP/GIF ≤15MB, video MP4/MOV/WebM ≤200MB, audio MP3/M4A/
                        WAV/OGG ≤50MB, document PDF/TXT/MD/DOC/DOCX ≤25MB.
+  --voices <v>         (run, video workflows) Give each speaker in the script an
+                       ElevenLabs voice from the moment the run starts, instead
+                       of at the storyboard review. A JSON object keyed by the
+                       names the SCRIPT uses ("HOST 1"), or @path to a file
+                       holding one — the same voices.json "exodus video voices
+                       <run> --from" reads, so a brand keeps one file for both.
+  --voice-treatment <v>  (run, video workflows) Say HOW the run makes its voices.
+                       A name on its own picks a way of working that plays a
+                       voice you already have (and still takes --voices); a JSON
+                       object, or @path to one, shaped {"path": "...",
+                       "describe": {"HOST 1": "..."}} has the video model speak
+                       the lines itself in a voice you WROTE, one description per
+                       speaker. Written voices and --voices are refused together:
+                       the ElevenLabs voices would be paid for and never heard.
+                       Chosen at launch only — the storyboard review can show a
+                       written voice but cannot change it. Anything the run could
+                       not do stops the launch before the run exists. The full
+                       flow is in the exodus-video skill.
   --auto-approve       (run) Send this ONE run off unattended: every Checkpoint it
                        reaches is approved for you, exactly as it stands, and the
                        run records that nobody looked. Without it a Checkpoint
@@ -145,6 +163,20 @@ Fill every required input. For a free-text brief you can compose a **bespoke bri
 
 **A brief wired straight into a Storyboard is a script, not a prompt.** On a video workflow whose Storyboard takes its `script` port from a Brief node, the text you pass for that brief boards VERBATIM, the same way a Show ad's pasted script does: one speaker per scene, every line rendered once in order, long lines split across clips, narrated lines rendered silent under the voice track. So it must be in the script form the `exodus-video` skill documents (an optional `CAST:` block of `NAME — description` lines, then `NAME:` turns, then a `CTA:` block; `NARRATOR:` lines only for Narrated Story and Explainer). A brief that is not a script, or one that does not fit the wired rig's family, is refused at launch with the parser's own message and nothing is spent. Write the script to a file and pass it with `--input script=@script.txt`. A Storyboard fed by a bot is unaffected.
 
+**A saved rig can bring a rulebook with it.** Some saved rigs carry saved format rules: how many speakers the script may have, which checks run on the clips, how the cast is built. Point a Rig box at one of those rigs and the run follows its rules — an ensemble rig seats more speakers than the usual three, a talking-head rig seats one. The start receipt says which rulebook ran:
+
+```
+Format rules: Ensemble Talking Head, version ensemble-e1-provisional-2026-07 (from the "rig_1" Rig box).
+```
+
+`workflow status` says the same line later, and `video pull` writes the same facts into `manifest.json` under `provenance`. Nothing prints the rules themselves — they are the house's, not the brand's — only whose they were and which version ran.
+
+Three things to know before you wire one:
+
+- **One run, one rulebook.** If any Rig box's rig carries rules, every Rig box in the workflow has to point at that same saved rig. A second box on a different rig, or a box with its knobs set in place, refuses the launch with a sentence naming every box. Nothing is spent.
+- **Some rulebooks aren't released yet.** A rig that is still being built refuses a member's launch and names itself. Only an admin can start a run on one. Duplicating that rig doesn't get around it — the copy still reads the original's rules, so the answer is the same.
+- **The rig's video model is advice, not a change.** When the rig is normally filmed with a different video model than the one your Video step is set to, the receipt says so in one line and the run uses YOUR setting. Change the Video step yourself if you want the rig's.
+
 For an **`asset` (file) input, pass the path to a local file** and the CLI does the uploading for you — mint, push the bytes, register, then start the run with the stored asset:
 
 ```bash

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,6 @@
 import { type ApiResponse } from "../lib/client.js";
+import type { FlagOccurrence } from "../lib/args.js";
+import { type RunProvenance } from "./workflow.js";
 export declare const helpText: string;
 export declare const VOICES_PATH = "/api/v2/video/voices";
 export interface ClipWord {
@@ -43,6 +45,8 @@ export type ArtifactSubset = {
     final?: boolean;
     revoiced?: boolean;
     speechTrimmed?: boolean;
+    tailTrimmed?: boolean;
+    rawStorageId?: string;
 } | {
     type: "audio";
     sceneIndex?: number;
@@ -97,6 +101,7 @@ export interface VideoRun {
     pausedNodeId?: string;
     nodes: VideoRunNode[];
     castLock?: PullCastLock | null;
+    provenance?: RunProvenance;
     workflowId?: string;
     moduleOwned?: boolean;
 }
@@ -202,6 +207,7 @@ export interface ManifestScene {
     qc: ClipQc | null;
     revoiced: boolean | null;
     speechTrimmed: boolean | null;
+    rawStorageId: string | null;
     clipStatus: string;
     error: string | null;
     flagged: boolean;
@@ -221,6 +227,7 @@ export interface ManifestCastRef {
     error: string | null;
     voiceId: string | null;
     voiceLabel: string | null;
+    voiceDescription: string | null;
 }
 export interface VideoManifest {
     runId: string;
@@ -236,6 +243,7 @@ export interface VideoManifest {
     } | null;
     scenes: ManifestScene[];
     failed: PullFailure[];
+    provenance?: RunProvenance;
 }
 export declare const CAST_LEDGER_BASE = 910000;
 export interface PullPlan {
@@ -288,6 +296,11 @@ export interface ClipRedoTarget {
 }
 export declare function planClipRedo(run: VideoRun, items: NodeItem[], target: ClipRedoTarget): ClipRedoPlan;
 export declare function retryClipFlow(runId: string, target: ClipRedoTarget, note: string | undefined, json: boolean, deps: VideoDeps): Promise<FlowResult>;
+export declare function planClipRevoice(run: VideoRun, items: NodeItem[], target: ClipRedoTarget): ClipRedoPlan;
+export type RevoiceTarget = ClipRedoTarget | {
+    all: true;
+};
+export declare function revoiceFlow(runId: string, target: RevoiceTarget, json: boolean, deps: VideoDeps): Promise<FlowResult>;
 export interface CastVoiceRow {
     characterId: string;
     name: string;
@@ -295,6 +308,7 @@ export interface CastVoiceRow {
         voiceId: string;
         label?: string;
     } | null;
+    voiceFrom?: "own-pin" | "run-default";
     availability?: {
         state: "available";
         providerName: string;
@@ -304,6 +318,7 @@ export interface CastVoiceRow {
         state: "not-checked";
         why: string;
     };
+    description?: string;
     spokenScenes: number;
     spokenSeconds: number;
 }
@@ -317,6 +332,9 @@ export interface CastVoiceSheet {
         label?: string;
     } | null;
     treatment: {
+        kind?: string;
+        path?: string | null;
+        usesElevenLabs?: boolean;
         summary: string;
         provider: string;
         model: string;
@@ -334,7 +352,7 @@ export type VoiceMap = Record<string, string | {
     voiceId: string;
     label?: string;
 } | null>;
-export declare function parseVoiceFlags(argv: readonly string[], readFile: (path: string) => string): VoiceMap | null;
+export declare function parseVoiceFlags(occurrences: FlagOccurrence[], readFile: (path: string) => string): VoiceMap | null;
 export declare function voicesFlow(runId: string, voices: VoiceMap | null, json: boolean, deps: VideoDeps): Promise<FlowResult>;
 export declare function voiceSheetLines(sheet: CastVoiceSheet): string[];
 export declare function pullFlow(runId: string, dir: string, json: boolean, deps: VideoDeps): Promise<FlowResult>;
@@ -343,4 +361,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>;