@aicopycoders/exodus 2026.9.2000-beta.20 → 2026.9.2000-beta.21

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

@@ -32,7 +32,8 @@ workflow run`. From there the same nodes render, `video status` reads the run,
 `video pull` writes the folder, and `video upload` and `approve` finish it.
 
 A Show is no longer required. `exodus video start` starts from a script, a
-conceit, and a style, and the same parks follow. The full line is under
+conceit, and a style. The same parks follow, except that the app approves the
+storyboard itself when its checks pass (see "What costs money"). The full line is under
 "Starting a run". An optional `--direction` note is whole-ad rules, and that
 note cannot contain a colon. "The script file" shows the right form and the
 wrong one.
@@ -84,9 +85,14 @@ exodus workflow run <workflowId|name> --input <field>=@script.txt --voices @voic
 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
-exodus video start --script <file> --conceit <podcast|ugc|stage|street|personification> --style <slug> [--direction "…"] [--voice-path <path>] [--video-model <id>] [--voice native] [--music] [--wait]
+exodus video start --script <file> --conceit <podcast|ugc|stage|street|personification> --style <slug> [--direction "…"] [--voice-path <path>] [--video-model <id>] [--voice native] [--music] [--review-storyboard] [--wait]
                                                           start from a script, a conceit and a look.
                                                           No music bed unless you pass --music.
+                                                          The app approves its own storyboard when its
+                                                          checks pass and goes straight on to the clips,
+                                                          which is the part that costs. It stops at the
+                                                          gate only when a check finds a problem, and says
+                                                          why. --review-storyboard always stops there.
                                                           Each conceit has its own video model and voice;
                                                           --video-model / --voice override them for one run
 ```
@@ -169,18 +175,31 @@ minutes with "Still running after 60 minutes" and exit 0; that is not done, so
 check `status` before treating it as finished. Do not poll `status` in a tight
 loop; a full run is several minutes.
 
-**What costs money.** Starting the run writes the storyboard and then draws the
-reference, cast and scene pictures, and only then pauses. Each picture is a few
-cents and each scene draws a few to choose from: about 25 cents on a small test,
-and it can approach a dollar on a longer ad. Approving releases the expensive
-part: the voices and the clips. So a run that has not paused yet is already
-spending a little, and a run still drawing pictures is healthy. `exodus workflow
-status` and `exodus video status` both print "This run will pause for your
-approval once the frames are ready" on a run that is headed for the gate. Do not
-cancel it because the pause has not arrived. `workflow list`, `workflow describe`, `video status`,
-`storyboard` and `pull` are free reads; run them as often as you like. Never
-start a second run to "retry" without the user asking; tell them what failed
-instead.
+**What costs money.** Every run writes the storyboard first and then draws the
+reference, cast and scene pictures. Each picture is a few cents and each scene
+draws a few to choose from: about 25 cents on a small test, and it can approach
+a dollar on a longer ad. The expensive part comes after the storyboard: the
+voices and the clips. What happens at that point depends on how the run
+started.
+
+- A paste-a-script run (`exodus video start --conceit …`) checks its own
+  storyboard once the pictures are drawn. When every check passes, the app
+  approves the storyboard itself and goes straight on to the voices and the
+  clips, with no stop. It stops for the user only when a check finds a problem,
+  and the stop block says why in plain words. Started with
+  `--review-storyboard`, it always stops at the storyboard instead. `status`
+  prints "the app checks the storyboard and approves it itself if the checks
+  pass" on a run headed that way.
+- A Show run (`video start --show`) and a saved workflow run (`workflow run`)
+  still pause at the storyboard for approval. Approving is what releases the
+  voices and the clips. `status` prints "This run will pause for your approval
+  once the frames are ready" on a run headed for that pause.
+
+Either way, a run still drawing pictures is healthy and already spending a
+little. Do not cancel it because nothing has happened yet. `workflow list`,
+`workflow describe`, `video status`, `storyboard` and `pull` are free reads; run
+them as often as you like. Never start a second run to "retry" without the user
+asking; tell them what failed instead.
 
 **`--auto-approve` does not cover either video gate.** It releases Checkpoint
 boxes only (`convex/workflows.ts:7266` keys on `pauseReason === "checkpoint"`),
@@ -574,6 +593,11 @@ musicHeardScenes[]                   scene numbers whose clip came back with
                                      music the video model baked in. A run with
                                      the bed off can still list scenes here, and
                                      those are the ones to listen to
+pendingRedo[]                        scene numbers the app is redoing right
+                                     now. Their clip and words are left out,
+                                     because the file on the run is the take
+                                     being replaced: run `exodus video wait`,
+                                     then pull again
 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

package/dist/commands/video.d.ts

@@ -118,6 +118,7 @@ export interface VideoRunNode {
     hasRejectedDraft?: boolean;
     outputs?: ArtifactSubset[];
     missingScenes?: MissingScene[];
+    autoRedoScenes?: number[];
 }
 export interface MissingScene {
     sceneIndex: number;
@@ -151,6 +152,11 @@ export interface VideoRun {
     provenance?: RunProvenance;
     musicBed?: boolean;
     videoChoice?: RunVideoChoice;
+    storyboardAutoApproval?: {
+        outcome: "approved" | "held";
+        at: number;
+        reason?: string;
+    };
     workflowId?: string;
     moduleOwned?: boolean;
 }
@@ -222,11 +228,13 @@ export declare function videoApiError(res: ApiResponse<unknown>): string;
 export type RunStop = {
     at: "running";
     stage: string;
+    autoRedoScenes?: number[];
 } | {
     at: "storyboard-gate";
     nodeId?: string;
     framesNodeId?: string;
     showAd?: true;
+    heldReason?: string;
 } | {
     at: "final-watch";
     missingScenes?: MissingScene[];
@@ -254,6 +262,7 @@ export type ResolvedStop = Exclude<RunStop, {
 });
 export declare function classifyRun(run: VideoRun): RunStop;
 export declare function hasAttachedCut(items: NodeItem[]): boolean;
+export declare function scenesBeingRedone(run: VideoRun, items: NodeItem[]): number[];
 export declare function resolveStop(stop: RunStop, cutAttached: boolean | null): ResolvedStop;
 export declare function resolveStopAtPark(stop: RunStop, runId: string, deps: Pick<VideoDeps, "get">): Promise<ResolvedStop>;
 export declare function stageWord(stage: string): string;
@@ -325,6 +334,7 @@ export interface VideoManifest {
     music: string | null;
     musicBed: MusicBedState;
     musicHeardScenes: number[];
+    pendingRedo: number[];
     cast: ManifestCastRef[];
     narration: {
         file: string;
@@ -371,6 +381,7 @@ export interface ScriptStartOptions {
     videoModel?: string;
     voiceMode?: VoiceMode;
     music?: boolean;
+    reviewStoryboard?: true;
     wait: boolean;
     json: boolean;
 }

package/dist/commands/video.js

@@ -103,7 +103,7 @@ Usage:
   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]
-  exodus video start --script <file> --conceit <${CONCEIT_KEYS.join("|")}> --style <${STYLE_SLUGS.join("|")}> [--direction "<note>"] [--voice-path <path>] [--video-model <id>] [--voice <native|voice-first>] [--music] [--wait] [--json]
+  exodus video start --script <file> --conceit <${CONCEIT_KEYS.join("|")}> --style <${STYLE_SLUGS.join("|")}> [--direction "<note>"] [--voice-path <path>] [--video-model <id>] [--voice <native|voice-first>] [--music] [--review-storyboard] [--wait] [--json]
 
 Options:
   --out <dir>          Folder to write the pulled pieces into (pull)
@@ -144,7 +144,11 @@ Options:
   --music              Put a music bed under the ad (start). An ad has no music
                        unless you ask for it here
   --no-music           Leave the music bed off (start), which it already is
-  --wait               Wait until the storyboard needs a yes (start)
+  --review-storyboard  Stop at the storyboard so you can approve it yourself
+                       (start, with --conceit). By default the app approves its
+                       own storyboard when its checks pass
+  --wait               Wait until the run needs you (start): at the
+                       storyboard, or once every piece is made
   --json               Machine-readable output
   --help, -h           Print this help
 
@@ -324,6 +328,14 @@ function parkedAtFinalWatch(run) {
     return (!parkedByBuilderCheckpoint(run) &&
         run.nodes.some((n) => n.kind === "video" && n.status === "done"));
 }
+function heldReason(run) {
+    const verdict = run.storyboardAutoApproval;
+    if (verdict?.outcome !== "held")
+        return undefined;
+    const reason = verdict.reason?.trim() ||
+        "The app didn't approve this storyboard by itself because its checks found a problem.";
+    return `${reason} (checked ${new Date(verdict.at).toISOString()})`;
+}
 export function classifyRun(run) {
     if (run.status === "failed")
         return { at: "failed", error: run.error };
@@ -343,6 +355,7 @@ export function classifyRun(run) {
         }
         const pausedNode = run.nodes.find((n) => n.nodeId === run.pausedNodeId);
         if (pausedNode && parkedAtStoryboardGate(run, pausedNode)) {
+            const held = heldReason(run);
             return {
                 at: "storyboard-gate",
                 nodeId: pausedNode.nodeId,
@@ -350,9 +363,15 @@ export function classifyRun(run) {
                     ? { framesNodeId: pausedNode.nodeId }
                     : {}),
                 ...(isShowAd(run) ? { showAd: true } : {}),
+                ...(held ? { heldReason: held } : {}),
             };
         }
         if (parkedAtFinalWatch(run)) {
+            const autoRedoScenes = run.nodes
+                .filter((n) => n.kind === "video")
+                .flatMap((n) => n.autoRedoScenes ?? []);
+            if (autoRedoScenes.length > 0)
+                return { at: "running", stage: "video", autoRedoScenes };
             const missingScenes = run.nodes
                 .filter((n) => n.kind === "video")
                 .flatMap((n) => n.missingScenes ?? []);
@@ -371,6 +390,18 @@ export function classifyRun(run) {
 export function hasAttachedCut(items) {
     return items.some((i) => i.itemKind === "final" && i.status === "done");
 }
+export function scenesBeingRedone(run, items) {
+    const scenes = new Set(run.nodes.filter((n) => n.kind === "video").flatMap((n) => n.autoRedoScenes ?? []));
+    for (const i of items) {
+        if (i.itemKind === "clip" &&
+            i.status === "running" &&
+            (i.attempt ?? 1) > 1 &&
+            i.staleClaim !== true) {
+            scenes.add(i.sceneIndex);
+        }
+    }
+    return [...scenes].sort((a, b) => a - b);
+}
 export function resolveStop(stop, cutAttached) {
     if (stop.at !== "final-watch")
         return stop;
@@ -444,6 +475,7 @@ function missingSceneLines(missing, framesNodeId, runId, runUrl) {
 export function stopLines(stop, runId, runUrl) {
     if (stop.at === "storyboard-gate") {
         const lines = [
+            ...(stop.heldReason ? [stop.heldReason] : []),
             "Parked: the storyboard is waiting for your yes.",
             `Read it:    exodus video storyboard ${runId}`,
             `Approve it: exodus video approve ${runId}`,
@@ -515,8 +547,15 @@ export function stopLines(stop, runId, runUrl) {
             `Open it: ${runUrl}`,
         ];
     }
+    if (stop.autoRedoScenes?.length)
+        return [autoRedoLine(stop.autoRedoScenes)];
     return [`Working: ${stageWord(stop.stage)}.`];
 }
+function autoRedoLine(scenes) {
+    const one = scenes.length === 1;
+    return (`Working: the app is redoing ${scenesPhrase(scenes)} on ${one ? "its" : "their"} own because ` +
+        `${one ? "it" : "they"} repeated words. The ad isn't ready to watch until ${one ? "it lands" : "they land"}.`);
+}
 export function failedStoryboardNode(run) {
     return run.nodes.find((n) => n.kind === "storyboard" && n.status === "failed");
 }
@@ -852,6 +891,9 @@ export function planPull(run, items, opts) {
             continue;
         keyframeByScene.set(sceneIndex, keyframeDownload(sceneIndex, artifact.imageUrl));
     }
+    const pendingRedo = scenesBeingRedone(run, items);
+    for (const sceneIndex of pendingRedo)
+        clipByScene.delete(sceneIndex);
     const sceneIndexes = [
         ...new Set([
             ...clipByScene.keys(),
@@ -933,6 +975,7 @@ export function planPull(run, items, opts) {
             musicHeardScenes: scenes
                 .filter((scene) => scene.findings.some((f) => f.code === MUSIC_HEARD_CODE))
                 .map((scene) => scene.sceneIndex),
+            pendingRedo,
             cast,
             narration: narrationDownload
                 ? { file: narrationDownload.file, timing: "narration.json" }
@@ -1188,6 +1231,13 @@ export function planVideoStart(flags, occurrences) {
         return { kind: "usage", line: voiceFlag.line };
     const videoModel = videoModelFlag.value;
     const voiceMode = voiceFlag.value;
+    const reviewStoryboard = occurrences.some((o) => o.flag === "review-storyboard");
+    if (showId && reviewStoryboard) {
+        return {
+            kind: "usage",
+            line: "--review-storyboard works with --conceit, not --show. A Show's ad always stops at the storyboard for you.",
+        };
+    }
     if (showId && (videoModel || voiceMode)) {
         return {
             kind: "usage",
@@ -1250,6 +1300,8 @@ export function planVideoStart(flags, occurrences) {
         opts.voiceMode = voiceMode;
     if (musicChoice.music !== undefined)
         opts.music = musicChoice.music;
+    if (reviewStoryboard)
+        opts.reviewStoryboard = true;
     return { kind: "script", opts };
 }
 function isRecord(value) {
@@ -1337,6 +1389,7 @@ export async function startScriptFlow(opts, deps) {
         ...(opts.videoModel ? { videoModel: opts.videoModel } : {}),
         ...(opts.voiceMode ? { voiceMode: opts.voiceMode } : {}),
         ...(opts.music === true ? { music: true } : {}),
+        ...(opts.reviewStoryboard ? { reviewStoryboard: true } : {}),
     });
     if (!res.ok)
         return errorResult(res, opts.json);
@@ -1356,7 +1409,12 @@ export async function startScriptFlow(opts, deps) {
                 : [
                     ...scriptStartedLines(runId, url, card, video),
                     "",
-                    "Wait for the storyboard here instead: exodus video start … --wait",
+                    ...(opts.reviewStoryboard
+                        ? ["Wait for the storyboard here instead: exodus video start … --wait"]
+                        : [
+                            "The app approves the storyboard itself if its checks pass. It only stops for you if they find a problem.",
+                            "Wait here until it needs you:        exodus video start … --wait",
+                        ]),
                     `Or check in whenever:                exodus video status ${runId}`,
                 ],
         };
@@ -1375,7 +1433,8 @@ export async function waitFlow(runId, opts, deps) {
     const interval = opts.intervalMs ?? POLL_INTERVAL_MS;
     const maxPolls = opts.maxPolls ?? MAX_POLLS;
     const lines = [];
-    let lastStage = null;
+    let lastProgress = null;
+    let redoSeen = false;
     for (let poll = 0; poll < maxPolls; poll++) {
         if (poll > 0)
             await deps.sleep(interval);
@@ -1387,14 +1446,35 @@ export async function waitFlow(runId, opts, deps) {
         const run = asVideoRun(res.data);
         const stop = classifyRun(run);
         if (stop.at === "running") {
-            if (stop.stage !== lastStage) {
-                lastStage = stop.stage;
+            const progress = stop.autoRedoScenes?.length
+                ? autoRedoLine(stop.autoRedoScenes)
+                : `Working: ${stageWord(stop.stage)}…`;
+            if (progress !== lastProgress) {
+                lastProgress = progress;
                 if (!opts.json)
-                    lines.push(`Working: ${stageWord(stop.stage)}…`);
+                    lines.push(progress);
             }
             continue;
         }
-        const resolved = await resolveStopAtPark(stop, runId, deps);
+        let items = null;
+        if (stop.at === "final-watch") {
+            const itemsRes = await deps.get(`${ITEMS_PATH}?runId=${encodeURIComponent(runId)}`);
+            items = itemsRes.ok ? (itemsRes.data.items ?? []) : null;
+            if (items === null && redoSeen)
+                continue;
+            const redoing = items ? scenesBeingRedone(run, items) : [];
+            redoSeen = redoing.length > 0;
+            if (redoSeen) {
+                const progress = `Working: redoing scene${redoing.length === 1 ? "" : "s"} ${redoing.join(", ")}…`;
+                if (progress !== lastProgress) {
+                    lastProgress = progress;
+                    if (!opts.json)
+                        lines.push(progress);
+                }
+                continue;
+            }
+        }
+        const resolved = resolveStop(stop, items ? hasAttachedCut(items) : null);
         if (opts.json) {
             return {
                 code: stop.at === "failed" ? 1 : 0,
@@ -1805,7 +1885,10 @@ export function planClipRedo(run, items, target) {
     const { row, uploadedCut } = found;
     const redoable = row.status === "failed" ||
         row.staleClaim === true ||
-        (row.status === "done" && (row.flagged === true || stop.at === "final-watch"));
+        (row.status === "done" &&
+            (row.flagged === true ||
+                stop.at === "final-watch" ||
+                (stop.at === "running" && stop.autoRedoScenes !== undefined)));
     if (!redoable) {
         if (row.status === "done") {
             return {
@@ -2299,6 +2382,9 @@ export async function pullFlow(runId, dir, json, deps) {
         `Every piece is indexed in ${path.join(dir, "manifest.json")} — scene numbers there are the run's own.`,
         ...musicLines(plan.manifest),
     ];
+    for (const sceneIndex of plan.manifest.pendingRedo) {
+        lines.push("", `Scene ${sceneIndex} is being redone right now; its file will change. Run \`exodus video wait ${runId}\`, then pull again.`);
+    }
     const voiceFirst = plan.manifest.scenes.filter((s) => s.voiceMode === "voice-first");
     if (voiceFirst.length > 0) {
         lines.push("", `Redone voice first (the line recorded, then the clip made to match it): ` +

package/dist/commands/workflow.d.ts

@@ -460,6 +460,7 @@ export interface WorkflowRun {
     pauseAhead?: {
         nodeId: string;
         after: "frames" | "storyboard";
+        selfApproves?: true;
     };
 }
 export declare function pauseAheadLine(ahead: NonNullable<WorkflowRun["pauseAhead"]>): string;

package/dist/commands/workflow.js

@@ -378,6 +378,9 @@ export function formatRulesLine(provenance) {
     return `Format rules: ${rigName}${version}${where}.${borrowed}`;
 }
 export function pauseAheadLine(ahead) {
+    if (ahead.after === "frames" && ahead.selfApproves) {
+        return "When the frames are ready, the app checks the storyboard and approves it itself if the checks pass, then goes on to the voices and clips. It only stops for your approval if a check finds a problem. The reference, cast and scene pictures are made first (a few cents each).";
+    }
     return ahead.after === "frames"
         ? "This run will pause for your approval once the frames are ready. The reference, cast and scene pictures are made first (a few cents each). Nothing bigger is spent until you approve."
         : "This run will pause for your approval once the storyboard is written. Nothing is spent on pictures, voices or clips until you approve.";
@@ -2088,6 +2091,7 @@ function videoParkStop(raw) {
 async function waitForRun(runId, opts, deps) {
     const seen = new Map();
     let pausedNotified = false;
+    let autoRedoNotified;
     const landOnPark = opts.landOnPark;
     const isLandingPark = (raw) => (landOnPark !== undefined && raw["pauseReason"] === landOnPark.pauseReason) ||
         videoParkStop(raw) !== undefined;
@@ -2105,7 +2109,15 @@ async function waitForRun(runId, opts, deps) {
                 return;
             const parked = isParkedSnapshot(raw);
             const isLanding = isLandingPark(raw);
-            if (parked && !pausedNotified && !isLanding) {
+            const autoRedo = parked ? classifyRun(asVideoRun(raw)) : undefined;
+            if (autoRedo?.at === "running" && autoRedo.autoRedoScenes) {
+                const line = `  ${stopLines(autoRedo, runId, "")[0]}`;
+                if (line !== autoRedoNotified) {
+                    autoRedoNotified = line;
+                    opts.onProgressLine(line);
+                }
+            }
+            else if (parked && !pausedNotified && !isLanding) {
                 pausedNotified = true;
                 const dashboardUrl = deps.dashboardUrl ?? getDashboardUrl();
                 const pauseReason = raw["pauseReason"];
@@ -2113,7 +2125,9 @@ async function waitForRun(runId, opts, deps) {
                     opts.onProgressLine(line);
                 }
             }
-            const parkedNodeId = gateParkedNodeId(raw["status"], raw["pauseReason"], raw["pausedNodeId"]);
+            const parkedNodeId = autoRedo?.at === "running"
+                ? undefined
+                : gateParkedNodeId(raw["status"], raw["pauseReason"], raw["pausedNodeId"]);
             const nodes = Array.isArray(raw["nodes"]) ? raw["nodes"] : [];
             for (const node of nodes) {
                 const isParked = parkedNodeId !== undefined && node.nodeId === parkedNodeId;

package/package.json

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