Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

Merge the Storyboard and Make steps into Plan and Shots (#11238)

[._.]/3a2f3eabecb5
diff --git a/client/src/components/musicVideo/MusicVideoLayout.test.jsx b/client/src/components/musicVideo/MusicVideoLayout.test.jsx
index f84a3865b6..825a2e82e1 100644
--- a/client/src/components/musicVideo/MusicVideoLayout.test.jsx
+++ b/client/src/components/musicVideo/MusicVideoLayout.test.jsx
@@ -24,8 +24,8 @@ describe('music-video step navigation', () => {
expect(steps.map((step) => step.textContent)).toEqual([
'Song' + 'Done' + '4:40 · 70 lyric lines',
'Look' + 'Done',
- '3Storyboard' + 'Needs you' + '26 shots',
- '4Make' + 'Not started',
+ '3Plan' + 'Needs you' + '26 shots',
+ '4Shots' + 'Not started',
'5Final render' + 'Not started',
'6Publish' + 'Not started',
]);
@@ -34,11 +34,11 @@ describe('music-video step navigation', () => {
expect(onStageChange).toHaveBeenCalledWith('produce');
// The phone bar says each state to screen readers, since it shows only icons.
expect(within(phoneBar()).getAllByRole('tab').map((tab) => tab.textContent)).toEqual([
- 'Song, Done', 'Look, Done', 'Storyboard, Needs you', 'Make, Not started', 'Final render, Not started', 'Publish, Not started',
+ 'Song, Done', 'Look, Done', 'Plan, Needs you', 'Shots, Not started', 'Final render, Not started', 'Publish, Not started',
]);
// The step names what "done" means under its title, and labels the panel.
- expect(screen.getByRole('tabpanel', { name: 'Storyboard' })).toBeInTheDocument();
- expect(screen.getByRole('heading', { level: 3, name: 'Storyboard' })).toBeInTheDocument();
+ expect(screen.getByRole('tabpanel', { name: 'Plan' })).toBeInTheDocument();
+ expect(screen.getByRole('heading', { level: 3, name: 'Plan' })).toBeInTheDocument();
expect(screen.getByText(MUSIC_VIDEO_STAGES[2].doneWhen)).toBeInTheDocument();
// The track, version and spend stay in the header.
expect(screen.getByText('Example Track')).toBeInTheDocument();
diff --git a/client/src/components/musicVideo/MusicVideoProjectCard.test.jsx b/client/src/components/musicVideo/MusicVideoProjectCard.test.jsx
index 0dd4203bb6..840256d2ba 100644
--- a/client/src/components/musicVideo/MusicVideoProjectCard.test.jsx
+++ b/client/src/components/musicVideo/MusicVideoProjectCard.test.jsx
@@ -84,7 +84,7 @@ describe('MusicVideoProjectCard', () => {
preview: { kind: 'none', label: 'No render yet' },
};
render(<MusicVideoProjectCard project={summary} onSelect={vi.fn()} />);
- expect(screen.getByText('Storyboard')).toBeInTheDocument();
+ expect(screen.getByText('Plan')).toBeInTheDocument();
expect(screen.getByText('128 BPM')).toBeInTheDocument();
expect(screen.getByText(/2 scenes · 1 clip/)).toBeInTheDocument();
expect(screen.getByTitle('50% clips rendered')).toBeInTheDocument();
diff --git a/client/src/components/musicVideo/ProductionReviewPanel.jsx b/client/src/components/musicVideo/ProductionReviewPanel.jsx
index fc1364b6aa..0ebbc9620e 100644
--- a/client/src/components/musicVideo/ProductionReviewPanel.jsx
+++ b/client/src/components/musicVideo/ProductionReviewPanel.jsx
@@ -14,7 +14,9 @@ const labels = { art: 'Art direction', storyboard: 'Lyric-timed storyboard', pro
// The proof is an optional check (the final render doesn't wait on it), so its heading says so.
const OPTIONAL = { proof: true };
// Each approval closes the step that owns its work (#10151); the page passes that step's `stage`.
-const STAGE_TABS = { art: 'cast-sets', storyboard: 'board', proof: 'produce' };
+const STAGE_TABS = { art: 'cast-sets', storyboard: 'produce', proof: 'produce' };
+// Approving the storyboard locks every shot's still, so its box says so.
+const HEADINGS = { storyboard: { open: 'Lock all stills', approved: 'All stills locked' } };
const EMPTY_PLAYBACK = { method: 'playback', timecodedNotes: '', visualReview: '', audioReview: '', limitations: '' };
const FOLD_STYLE = { scrollMarginTop: 'calc(var(--mv-header-h, 9rem) + 1rem)' };
@@ -23,11 +25,11 @@ const FOLD_STYLE = { scrollMarginTop: 'calc(var(--mv-header-h, 9rem) + 1rem)' };
* Approve / Request changes, highlighted until approved. A `waiting` box has
* nothing to review yet, so it is not highlighted either.
*/
-function ApprovalBox({ id, label, approved, optional = false, waiting = false, children }) {
+function ApprovalBox({ id, stage, label, approved, optional = false, waiting = false, children }) {
return <section id={id} tabIndex={-1} aria-label={`Approve: ${label}`} style={FOLD_STYLE}
className={`rounded-lg border p-3 focus:outline focus:outline-2 focus:outline-port-accent ${approved || optional || waiting ? 'border-port-border' : 'border-port-accent bg-port-accent/5'}`}>
{/* An optional check isn't highlighted: it never competes with the step's real next action. */}
- <h4 className="text-sm font-semibold">{approved ? `${label} approved` : optional ? label : `Approve the ${label.toLowerCase()}`}{optional && !approved && <span className="ml-2 font-normal text-port-text-muted">Optional</span>}</h4>
+ <h4 className="text-sm font-semibold">{HEADINGS[stage]?.[approved ? 'approved' : 'open'] || (approved ? `${label} approved` : optional ? label : `Approve the ${label.toLowerCase()}`)}{optional && !approved && <span className="ml-2 font-normal text-port-text-muted">Optional</span>}</h4>
{children}
</section>;
}
@@ -153,7 +155,7 @@ export default function ProductionReviewPanel({ project, review, onOpenArtifact,
const proofContent = <>
{!excerpt && <div className="space-y-1 text-sm" aria-label="Proof approval prerequisites">
{!ready?.art.approved && <p><a href="#mv-review-art" onClick={jump('cast-sets', 'mv-review-art')} className="text-port-accent underline">Approve the art direction</a> first.</p>}
- {ready?.art.approved && !ready?.storyboard.approved && <p><a href="#mv-review-storyboard" onClick={jump('board', 'mv-review-storyboard')} className="text-port-accent underline">Approve the storyboard</a> first.</p>}
+ {ready?.art.approved && !ready?.storyboard.approved && <p><a href="#mv-review-storyboard" onClick={jump('produce', 'mv-review-storyboard')} className="text-port-accent underline">Lock the stills</a> first.</p>}
</div>}
{excerpt && <p className="text-xs text-port-text-muted break-words">{excerpt.filename || excerpt.status} · {project.productionReview?.proof?.basis === ready?.basis.proof ? 'Current source revision' : 'Source changed — render a new proof'}</p>}
{excerpt?.status === 'error' && excerpt.error && <p role="alert" className="text-sm text-port-error break-words">{excerpt.error}</p>}
@@ -216,7 +218,7 @@ export default function ProductionReviewPanel({ project, review, onOpenArtifact,
const artWaiting = key === 'art' && !!ready && !ready.art.approved && !ready.art.stale && !artDirectionGaps(project).ready;
return <section id="mv-production-review" aria-label="Production review" className="space-y-3">
{review.error && <p role="alert" className="text-port-error">{review.error}</p>}
- <ApprovalBox id={`mv-review-${key}`} label={label} optional={!!OPTIONAL[key]} approved={!!ready?.[key].approved} waiting={artWaiting}>
+ <ApprovalBox id={`mv-review-${key}`} stage={key} label={label} optional={!!OPTIONAL[key]} approved={!!ready?.[key].approved} waiting={artWaiting}>
{artWaiting ? <p role="status" className="mt-1 text-sm text-port-text-muted">Opens once the art direction is written and a visual guide is chosen.</p> : <>
{/* The decision comes first, at the top of the box, with one line on what it still needs. */}
{key === 'proof' && proofNeedsRender && !ready?.[key].approved && <div className="mt-2">{renderControls}</div>}
@@ -225,7 +227,7 @@ export default function ProductionReviewPanel({ project, review, onOpenArtifact,
aria-describedby={approvalHelp(key) ? fieldId(`${key}-approval-help`) : undefined}
disabled={blocked || (key === 'art' && visibleArt !== artIdentity) || ready?.[key].approved || !!ready?.[key].problems.length
|| (key === 'proof' && (playbackBlocked || !evidenceComplete))}>
- {key === 'proof' ? machineReview ? 'Approve proof with machine evidence' : 'Approve proof — watched with sound' : `Approve ${label.toLowerCase()}`}
+ {key === 'proof' ? machineReview ? 'Approve proof with machine evidence' : 'Approve proof — watched with sound' : HEADINGS[key]?.open || `Approve ${label.toLowerCase()}`}
</button>}
<button type="button" className={buttonClass} onClick={() => {
setFeedback({ ...feedback, stage: key, decision: 'request-changes' });
diff --git a/client/src/components/musicVideo/ProductionReviewPanel.test.jsx b/client/src/components/musicVideo/ProductionReviewPanel.test.jsx
index 6a06f68b95..744594daaf 100644
--- a/client/src/components/musicVideo/ProductionReviewPanel.test.jsx
+++ b/client/src/components/musicVideo/ProductionReviewPanel.test.jsx
@@ -402,12 +402,12 @@ describe('Per-stage approval sections (#10151)', () => {
const box = screen.getByRole('region', { name: 'Approve: Lyric-timed storyboard' });
expect(box.id).toBe('mv-review-storyboard');
expect(box.tagName).toBe('SECTION');
- expect(within(box).getByRole('heading', { name: 'Approve the lyric-timed storyboard' })).toBeTruthy();
- expect(within(box).getByRole('button', { name: 'Approve lyric-timed storyboard' })).toBeTruthy();
+ expect(within(box).getByRole('heading', { name: 'Lock all stills' })).toBeTruthy();
+ expect(within(box).getByRole('button', { name: 'Lock all stills' })).toBeTruthy();
expect(within(box).getByRole('button', { name: 'Request changes' })).toBeTruthy();
expect(container.querySelector('details#mv-review-storyboard')).toBeNull();
// The decision sits at the top of the box, before the shots it is about.
- const approveButton = within(box).getByRole('button', { name: 'Approve lyric-timed storyboard' });
+ const approveButton = within(box).getByRole('button', { name: 'Lock all stills' });
expect(approveButton.compareDocumentPosition(within(box).getByRole('region', { name: 'Storyboard review content' })) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
expect(screen.queryByText('About production approvals')).toBeNull();
});
@@ -421,7 +421,7 @@ describe('storyboard camera notes (#10589)', () => {
render(<ProductionReviewPanel project={project} review={review} onOpenArtifact={vi.fn()} stage="storyboard" />);
const notes = screen.getByRole('note', { name: 'Camera variety notes' });
expect(within(notes).getByText(note)).toBeTruthy();
- expect(screen.getByRole('button', { name: 'Approve lyric-timed storyboard' }).disabled).toBe(false);
+ expect(screen.getByRole('button', { name: 'Lock all stills' }).disabled).toBe(false);
});
it('shows nothing when the camera plan is varied', () => {
diff --git a/client/src/components/musicVideo/TreatmentPanel.jsx b/client/src/components/musicVideo/TreatmentPanel.jsx
index 4acbd89a57..5bb51a582b 100644
--- a/client/src/components/musicVideo/TreatmentPanel.jsx
+++ b/client/src/components/musicVideo/TreatmentPanel.jsx
@@ -67,7 +67,7 @@ export function treatmentSummary(project) {
*
* The brief (what the planner reads) needs no scenes, so it is always shown;
* compile / arc / shot direction / Apply need them and wait until shots are
- * planned. The Storyboard step supplies the collapsible section, so there is
+ * planned. The Plan step supplies the collapsible section, so there is
* no fold of its own here.
* `storyboardApproved` (from the server's readiness) warns that any treatment
* edit will need the storyboard re-approved (#10141).
diff --git a/client/src/components/musicVideo/stages/BoardStage.jsx b/client/src/components/musicVideo/stages/BoardStage.jsx
index f805b4821d..b7aee91459 100644
--- a/client/src/components/musicVideo/stages/BoardStage.jsx
+++ b/client/src/components/musicVideo/stages/BoardStage.jsx
@@ -1,16 +1,11 @@
import { useContext, useEffect, useLayoutEffect, useRef } from 'react';
import { useSearchParams } from 'react-router';
import { Plus, Image as ImageIcon, Film, Code2, Type, FlagTriangleRight, Lock, LockOpen } from 'lucide-react';
-import BeatTimeline from '../BeatTimeline.jsx';
import ContactSheetButton from '../ContactSheetButton.jsx';
import SceneCard from '../SceneCard.jsx';
import ScenePoster from '../ScenePoster.jsx';
import { ShotLockContext, SHOT_LOCK_LABELS, overallShotLock } from '../ShotLock.jsx';
import { shotNumbers } from '../ShotStepper.jsx';
-import TreatmentPanel, { treatmentSummary } from '../TreatmentPanel.jsx';
-import StageSection from '../StageSection.jsx';
-import { PlanActions } from '../ProjectActionGroups.jsx';
-import ShotPacingFields from '../ShotPacingFields.jsx';
import { previousShot } from '../../../../../server/lib/musicVideoHandoffFrame.js';
import { isLayeredComposition } from '../../../lib/musicVideoLayers.js';
import { FOOTAGE_OPTIONAL_MODES } from '../../../lib/musicVideoStages.js';
@@ -52,14 +47,14 @@ function SceneLockBadge({ sceneId, state }) {
}
/**
- * Storyboard: the treatment (the brief the planner reads, then per-shot
- * direction), planning tools, the beat timeline, and the scene cards —
+ * The scene board on Shots: a thumbnail per shot with its lock and media marks,
+ * and the open shot's card, where its still and clip are made and locked —
* one column on a phone, two and three as the column widens (a container
* query, so the docked preview narrowing the column is accounted for). Cards
* are collapsed to a thumbnail, lyric and status until tapped.
*/
export default function BoardStage({ board }) {
- const { project, locked, busy, sceneMedia, videoSettings, takes, treatment, activeSceneId, onToggleSceneExpand } = board;
+ const { project, locked, sceneMedia, videoSettings, takes, activeSceneId, onToggleSceneExpand } = board;
const scenes = project.scenes || [];
const lockValue = useContext(ShotLockContext);
const shotLocks = Object.fromEntries(Object.entries(lockValue?.locks || {}).map(([id, still]) => [id, overallShotLock(still, lockValue.clips?.[id])]));
@@ -137,26 +132,6 @@ export default function BoardStage({ board }) {
}
return (
<fieldset disabled={locked} className="min-w-0 space-y-3">
- <StageSection title="Planning tools">
- <PlanActions project={project} busy={busy} onPlan={board.onPlan} onAutoArrange={board.onAutoArrange} />
- <ShotPacingFields project={project} onEditLocal={board.editProjectLocal} onSave={board.saveProjectFields} />
- </StageSection>
-
- {/* The brief feeds the shot planner; the direction is applied per shot once they exist. */}
- <StageSection id="mv-board-treatment" title="Treatment" summary={scenes.length ? treatmentSummary(project) : 'Write the brief the shot planner follows'}>
- <div id="mv-setup-treatment">
- <TreatmentPanel key={`treatment-${project.id}`} project={project} treatment={treatment}
- storyboardApproved={!!board.productionReadiness?.storyboard?.approved} />
- </div>
- </StageSection>
-
- {project.audioAnalysis && scenes.length > 0 && (
- <StageSection title="Beat timeline">
- <BeatTimeline audioAnalysis={project.audioAnalysis} scenes={scenes} lyricCues={project.lyricCues} narrativeEvents={project.composition?.narrativeEvents}
- onSeek={(startSec) => board.seekToScene({ startSec })} onCommit={board.commitSceneTiming} />
- </StageSection>
- )}
-
<div id="mv-scene-board" className="flex items-center justify-between">
<h3 className="text-sm font-medium">Scene board</h3>
<div className="flex items-center gap-2">
diff --git a/client/src/components/musicVideo/stages/PlanStage.jsx b/client/src/components/musicVideo/stages/PlanStage.jsx
new file mode 100644
index 0000000000..512958b63f
--- /dev/null
+++ b/client/src/components/musicVideo/stages/PlanStage.jsx
@@ -0,0 +1,39 @@
+import BeatTimeline from '../BeatTimeline.jsx';
+import TreatmentPanel, { treatmentSummary } from '../TreatmentPanel.jsx';
+import StageSection from '../StageSection.jsx';
+import { PlanActions } from '../ProjectActionGroups.jsx';
+import ShotPacingFields from '../ShotPacingFields.jsx';
+
+/**
+ * Plan: the shot list before any shot is made — planning tools, the
+ * treatment (the brief the planner reads, then per-shot
+ * direction) and the beat timeline. Each shot's still, clip and locks are on
+ * Shots.
+ */
+export default function PlanStage({ board }) {
+ const { project, locked, busy, treatment } = board;
+ const scenes = project.scenes || [];
+ return (
+ <fieldset disabled={locked} className="min-w-0 space-y-3">
+ <StageSection title="Planning tools">
+ <PlanActions project={project} busy={busy} onPlan={board.onPlan} onAutoArrange={board.onAutoArrange} />
+ <ShotPacingFields project={project} onEditLocal={board.editProjectLocal} onSave={board.saveProjectFields} />
+ </StageSection>
+
+ {/* The brief feeds the shot planner; the direction is applied per shot once they exist. */}
+ <StageSection id="mv-board-treatment" title="Treatment" summary={scenes.length ? treatmentSummary(project) : 'Write the brief the shot planner follows'}>
+ <div id="mv-setup-treatment">
+ <TreatmentPanel key={`treatment-${project.id}`} project={project} treatment={treatment}
+ storyboardApproved={!!board.productionReadiness?.storyboard?.approved} />
+ </div>
+ </StageSection>
+
+ {project.audioAnalysis && scenes.length > 0 && (
+ <StageSection title="Beat timeline">
+ <BeatTimeline audioAnalysis={project.audioAnalysis} scenes={scenes} lyricCues={project.lyricCues} narrativeEvents={project.composition?.narrativeEvents}
+ onSeek={(startSec) => board.seekToScene({ startSec })} onCommit={board.commitSceneTiming} />
+ </StageSection>
+ )}
+ </fieldset>
+ );
+}
diff --git a/client/src/components/musicVideo/stages/ProduceStage.jsx b/client/src/components/musicVideo/stages/ProduceStage.jsx
index 6aba639c77..85163244b5 100644
--- a/client/src/components/musicVideo/stages/ProduceStage.jsx
+++ b/client/src/components/musicVideo/stages/ProduceStage.jsx
@@ -1,3 +1,4 @@
+import BoardStage from './BoardStage.jsx';
import ContactSheetButton from '../ContactSheetButton.jsx';
import StageSection from '../StageSection.jsx';
import { GenerationActions } from '../ProjectActionGroups.jsx';
@@ -7,11 +8,14 @@ import { isLayeredComposition } from '../../../lib/musicVideoLayers.js';
import { FOOTAGE_OPTIONAL_MODES } from '../../../lib/musicVideoStages.js';
/**
- * Make: the picture for every shot, then the composition over it. A render
- * style that draws its own picture (code, document, Eidoverse) keeps the
- * footage tools folded, since footage is optional there. The optional animated proof shows at the bottom of
- * the page only while a production run's pilot or open feedback needs it; the autopilot and production runs live in
- * Project settings › Autopilot.
+ * Shots: the scene board, where each shot's still and clip are made and locked
+ * (a video shot locks its still, then its clip), the footage tools for making
+ * many at once, then the composition over them. A render style that draws its
+ * own picture (code, document, Eidoverse) keeps the footage tools folded, since
+ * footage is optional there. The approvals sit at the bottom of the page (Lock
+ * all stills, and the animated proof only while a production run's pilot or
+ * open feedback needs it); the autopilot and production runs live in Project
+ * settings › Autopilot.
*/
export default function ProduceStage({ board }) {
const { project, locked, videoSettings, sceneMedia } = board;
@@ -19,6 +23,7 @@ export default function ProduceStage({ board }) {
const hasScenes = (project.scenes || []).length > 0;
return (
<div className="min-w-0 space-y-3">
+ <BoardStage board={board} />
<fieldset disabled={locked} className="min-w-0 space-y-3">
<StageSection id="mv-generation" title="Footage" defaultOpen={!footageOptional}
summary={footageOptional ? 'Optional for this render style: frames and clips the composition can use' : 'Make the frames and clips each shot still needs'}>
diff --git a/client/src/lib/musicVideoStages.js b/client/src/lib/musicVideoStages.js
index 33ebb69422..558f2002c3 100644
--- a/client/src/lib/musicVideoStages.js
+++ b/client/src/lib/musicVideoStages.js
@@ -18,22 +18,22 @@ import { FINISHED_OUTSIDE_RERENDER_NOTE, finishedOutside, finishedOutsideCovers
/**
* The six steps of a music video, in the order the director decides them. The
* ids are the route's `:stage` values and stay stable across the relabel
- * (#10297 follow-up): Song is `setup`, Look is `cast-sets`, Storyboard is
- * `board`, Make is `produce` (footage and the composition over it; an
- * animated proof is an optional check) and Final render is `review`. `doneWhen` is the one line a step
- * shows under its title.
+ * (#10297 follow-up): Song is `setup`, Look is `cast-sets`, Plan (once
+ * Storyboard) is `board`, Shots (once Make) is `produce` — each shot's still,
+ * clip and locks, then the composition over them — and Final render is
+ * `review`. `doneWhen` is the one line a step shows under its title.
*/
export const MUSIC_VIDEO_STAGES = [
{ id: 'setup', label: 'Song', title: 'Song', doneWhen: 'Done when the track is analyzed and every lyric word is timed to the vocal.' },
{ id: 'cast-sets', label: 'Look', title: 'Look', doneWhen: 'Done when the art direction is written, a visual guide is chosen, and you approve it.' },
- { id: 'board', label: 'Storyboard', title: 'Storyboard', doneWhen: 'Done when shots cover the whole song and you approve the timed storyboard.' },
- { id: 'produce', label: 'Make', title: 'Make', doneWhen: 'Done when every shot has its picture and the composition is ready.' },
+ { id: 'board', label: 'Plan', title: 'Plan', doneWhen: 'Done when timed shots cover the whole song, each with its action, staging, camera and lyric.' },
+ { id: 'produce', label: 'Shots', title: 'Shots', doneWhen: 'Done when every shot is locked (a video shot: its still, then its clip) and the composition is ready.' },
{ id: 'review', label: 'Final render', title: 'Final render', doneWhen: 'Done when the full video is rendered from the approved plan and is up to date.' },
{ id: 'publish', label: 'Publish', title: 'Publish', doneWhen: 'Done when every platform you turned on has a post.' },
];
-// Old links name the Compose tab, which is now part of Make.
-const LEGACY_STAGE_IDS = { compose: 'produce' };
+// Old links name the Compose tab, which is now part of Shots; the new names work as links too.
+const LEGACY_STAGE_IDS = { compose: 'produce', plan: 'board', shots: 'produce' };
export const isStageId = (value) => MUSIC_VIDEO_STAGES.some((stage) => stage.id === value);
@@ -342,6 +342,15 @@ const composeDone = (project, mode) => {
return true;
};
+/**
+ * Clip locks count toward Shots once the director has started using them: a
+ * board where no clip was ever locked (an autopilot run, say) is not held open.
+ */
+function clipsLockedDone(readiness) {
+ const clips = Object.values(readiness?.storyboard?.clipLocks || {});
+ return !clips.some((state) => state === 'locked' || state === 'changed') || !(readiness.storyboard.clipsUnlocked || []).length;
+}
+
/**
* Lyric half of Setup: storyboard approval needs lyrics imported and their word
* timings verified (or an explicit instrumental exception). `readiness.alignment`
@@ -365,9 +374,11 @@ export function lyricSetupState(project, readiness = project?.productionReadines
* changed since — plus `current`, the first stage that is not done. A live production
* run owns the project, so it pins `current` to Produce.
*
- * Make (`produce`) holds the footage and the composition over it. Its animated
- * proof is an optional check: the composition preview already shows the
- * picture, so neither Make nor the final render waits on a proof approval.
+ * Plan (`board`) is done once timed shots cover the song. Shots (`produce`)
+ * is done once every still is locked (the storyboard approval), every clip is
+ * locked once the director has started locking clips, the footage is in and the
+ * composition is ready. Its animated proof is an optional check: neither Shots
+ * nor the final render waits on a proof approval.
*/
export function deriveStages(project, readiness = project?.productionReadiness, publish = {}) {
const mode = project?.composition?.mode || 'concat';
@@ -375,15 +386,16 @@ export function deriveStages(project, readiness = project?.productionReadiness,
const run = currentProductionRun(project);
const liveRun = !!run && RESUMABLE_RUN_STATUSES.has(run.status);
const planned = !!readiness?.storyboard.approved;
+ const shotsPlanned = (project?.scenes || []).length > 0 && !!readiness && !readiness.storyboard.problems?.length;
const castStopped = castSetsPhase(cast) === 'stopped';
const castDone = !!readiness?.art.approved;
// Code and document renders draw the picture themselves; scene footage is optional there.
- const produceDone = planned && footageReady(project);
+ const produceDone = planned && clipsLockedDone(readiness) && footageReady(project);
const done = {
setup: projectHasAudio(project) && !!project?.audioAnalysis && lyricSetupState(project, readiness).ok,
'cast-sets': castDone,
- board: planned,
+ board: planned || shotsPlanned,
produce: produceDone && composeDone(project || {}, mode),
// A render made before later scene edits no longer counts as the final video.
review: !!project?.renderHistoryId && !isFinalRenderStale(project),
@@ -401,7 +413,7 @@ export function deriveStages(project, readiness = project?.productionReadiness,
// reading as never done. The check-in sheet stays approved while stale.
const stale = external ? {} : {
'cast-sets': !!readiness?.art?.stale || !!readiness?.castAndSets?.stale,
- board: !!readiness?.storyboard?.stale,
+ produce: !!readiness?.storyboard?.stale,
};
const current = liveRun
? 'produce'
@@ -418,10 +430,10 @@ export function deriveStages(project, readiness = project?.productionReadiness,
// The approval panel the header sends the director to: unwritten art direction is written on the step, not approved.
function reviewProductionAction({ art, board, artUnwritten }) {
if (artUnwritten) return { id: 'review-production', kind: 'goto', stage: 'cast-sets', anchor: ART_DIRECTION_ANCHOR, label: 'Write art direction', shortLabel: 'Write art' };
- return { id: 'review-production', kind: 'goto', stage: art ? 'cast-sets' : board ? 'board' : 'produce',
+ return { id: 'review-production', kind: 'goto', stage: art ? 'cast-sets' : 'produce',
anchor: art ? 'mv-review-art' : board ? 'mv-review-storyboard' : 'mv-review-proof',
- label: art ? 'Review art direction' : board ? 'Review timed storyboard' : 'Review pilot proof',
- shortLabel: art ? 'Review art' : board ? 'Review storyboard' : 'Review proof' };
+ label: art ? 'Review art direction' : board ? 'Lock the stills' : 'Review pilot proof',
+ shortLabel: art ? 'Review art' : board ? 'Lock stills' : 'Review proof' };
}
// A live or parked production run offers Stop while it works, else Resume.
@@ -500,6 +512,11 @@ export function deriveNextAction(project, {
// The animated proof is optional, so the header sends the director to it only
// when a production run is parked on its pilot proof before paid bulk generation.
const pilotParked = !!run && RESUMABLE_RUN_STATUSES.has(run.status) && !!run.pilot?.scenes?.length && !readiness?.proof?.approved;
+ // Shots planned with gaps (timing, staging, lyric anchors) are finished on Plan before their stills are locked.
+ const planUnfinished = !art && board && scenes.length > 0 && !documentShots && (readiness?.storyboard?.problems || []).some(notFeedback);
+ if (planUnfinished && !renderActive && !kickoffRunning && !(run && RESUMABLE_RUN_STATUSES.has(run.status))) {
+ return { id: 'finish-plan', kind: 'goto', stage: 'board', label: 'Finish the plan', shortLabel: 'Plan' };
+ }
if (shouldJumpToReview(project, { run, art, board, pilotParked, busy: renderActive || kickoffRunning, ownAction: castNeedsOwnAction || boardNeedsOwnAction })) {
return reviewProductionAction({ art, board, artUnwritten });
}
@@ -538,6 +555,10 @@ export function deriveNextAction(project, {
case 'produce': {
if (run?.status === 'needs-human') return { id: 'goto-review', kind: 'goto', stage: 'review', label: 'Review the draft', shortLabel: 'Review' };
if (!footageReady(project)) return { id: 'goto-produce', kind: 'goto', stage: 'produce', anchor: 'mv-generation', label: 'Make the footage', shortLabel: 'Make' };
+ if (!clipsLockedDone(readiness)) {
+ const left = readiness.storyboard.clipsUnlocked.length;
+ return { id: 'lock-clips', kind: 'goto', stage: 'produce', anchor: 'mv-scene-board', label: `Lock ${formatCount(left)} video${left === 1 ? '' : 's'}`, shortLabel: 'Lock videos' };
+ }
const label = { document: 'Attach a composition', eidoverse: 'Save the Eidoverse scene', code: 'Generate the code video' }[project.composition?.mode] || 'Add typography';
const shortLabel = { document: 'Attach', eidoverse: 'Save', code: 'Generate' }[project.composition?.mode] || 'Type';
return { id: 'goto-compose', kind: 'goto', stage: 'produce', anchor: 'mv-composition', label, shortLabel };
@@ -606,7 +627,7 @@ export function changedFieldsText(changedFields, limit = 4) {
return `${text.slice(0, limit).join(', ')}${more}`;
}
const APPROVAL_ANCHORS = { art: 'mv-review-art', storyboard: 'mv-review-storyboard', proof: 'mv-review-proof' };
-const APPROVAL_STAGES = { art: 'cast-sets', storyboard: 'board', proof: 'produce' };
+const APPROVAL_STAGES = { art: 'cast-sets', storyboard: 'produce', proof: 'produce' };
const PUBLISH_ANCHOR = 'mv-publish-kit';
/** The anchor of one platform's row in the posting panel. */
export const publishRowAnchor = (target) => `mv-post-${target}`;
@@ -639,7 +660,7 @@ function unlockedDetail(readiness, item) {
if (!left) return item;
const count = `${formatCount(left)} shot${left === 1 ? '' : 's'} not locked yet.`;
// A stale board keeps its "changed since" text (and Keep approved) after the count.
- return { ...item, detail: item.stale ? `${count} ${item.detail}` : `${count} Lock each on its card, or approve them all here.` };
+ return { ...item, detail: item.stale ? `${count} ${item.detail}` : `${count} Lock each on its card, or lock them all below.` };
}
// The server names each open change request as a readiness problem; the
@@ -841,20 +862,16 @@ export function stageChecklist(stageId, project, readiness = project?.production
const planned = scenes.length > 0 || (draft.storyboard || []).length > 0;
const feedback = feedbackItem(project, 'storyboard', readiness);
const problems = [...storyboardProblemItems(readiness), ...(feedback ? [feedback] : [])];
- const storyboardApproval = approval('storyboard', 'Timed storyboard', 'Ready for your review below.');
return [
{ id: 'shots', label: 'Shots planned', done: planned, detail: planned ? null : 'Plan the shots from the header, or add scenes by hand.',
action: planned ? null : { label: 'Open the treatment', anchor: 'mv-board-treatment' } },
...problems,
- // The problems are listed above, one row per group; the approval row need not repeat the first.
- // A stale approval keeps its "changed since" text: it is the only place the checklist names what changed.
- problems.length && !storyboardApproval.stale ? { ...storyboardApproval, detail: 'Approve once the items above are done.' }
- : unlockedDetail(readiness, storyboardApproval),
];
}
case 'produce': {
- // Make: footage (unless the render style draws its own picture), the
- // composition over it, then the optional proof while a run needs it (see proofReviewInUse).
+ // Shots: the footage (unless the render style draws its own picture), every
+ // still locked (the storyboard approval), every clip locked once clip locks are
+ // in use, the composition over them, then the optional proof while a run needs it.
const items = [];
if (!FOOTAGE_OPTIONAL_MODES.has(mode)) {
const layered = isLayeredComposition(project);
@@ -863,6 +880,20 @@ export function stageChecklist(stageId, project, readiness = project?.production
items.push({ id: 'footage', label: `Footage for every shot (${formatCount(ready)} of ${formatCount(scenes.length)})`, done: footageDone,
action: footageDone ? null : { label: 'Make the footage', anchor: 'mv-generation' } });
}
+ // A document storyboard is approved whole; Board shots lock their stills one by one or all at once.
+ const documentBoard = draft.storyboardSource === 'document';
+ const reviewed = approval('storyboard', 'Timed storyboard', documentBoard ? 'Ready for your review below.' : 'Lock each still on its card, or lock them all below.');
+ const planOpen = (readiness?.storyboard?.problems || []).some(notFeedback) && !reviewed.stale;
+ const stills = documentBoard ? reviewed : { ...unlockedDetail(readiness, reviewed), label: 'Every still locked',
+ ...(reviewed.action && !reviewed.action.run ? { action: { ...reviewed.action, label: 'Lock the stills' } } : {}) };
+ items.push(planOpen && !reviewed.done ? { ...stills, detail: 'Finish the plan first.', action: { label: 'Open the plan', stage: 'board' } } : stills);
+ const clips = Object.values(readiness?.storyboard?.clipLocks || {});
+ if (clips.some((state) => state === 'locked' || state === 'changed')) {
+ const left = (readiness.storyboard.clipsUnlocked || []).length;
+ items.push({ id: 'lock-clips', label: 'Every video locked', done: !left,
+ detail: left ? `${formatCount(left)} video${left === 1 ? '' : 's'} not locked yet. Lock each on its card once its clip is right.` : null,
+ action: left ? { label: 'Open the shots', anchor: 'mv-scene-board' } : null });
+ }
const proofApproval = approval('proof', 'Animated proof', null);
// Optional: never counted toward the step being done.
const proof = proofReviewInUse(project, readiness)
diff --git a/client/src/lib/musicVideoStages.test.js b/client/src/lib/musicVideoStages.test.js
index a22e016614..29b3d20b54 100644
--- a/client/src/lib/musicVideoStages.test.js
+++ b/client/src/lib/musicVideoStages.test.js
@@ -64,7 +64,7 @@ describe('deriveStages / deriveNextAction', () => {
const unplanned = { ...waiting, castAndSets: { status: 'approved' }, productionReadiness: { art: { approved: true }, storyboard: { approved: false }, proof: { approved: false }, readyForProduction: false } };
expect(deriveNextAction(unplanned)).toMatchObject({ id: 'plan' });
- expect(deriveNextAction({ ...unplanned, scenes: [{ id: 's1' }] })).toMatchObject({ id: 'review-production', stage: 'board' });
+ expect(deriveNextAction({ ...unplanned, scenes: [{ id: 's1' }] })).toMatchObject({ id: 'review-production', stage: 'produce', label: 'Lock the stills' });
const interrupted = { ...waiting, castAndSets: { status: 'imaging', interrupted: true } };
expect(stateOf(interrupted)['cast-sets']).toBe('blocked');
@@ -159,15 +159,15 @@ describe('deriveStages / deriveNextAction', () => {
expect(deriveStages(withMode({ mode: 'composed', textCues: [] })).current).toBe('produce');
// Eidoverse needs no footage; Make waits on a saved scene.
expect(deriveStages(withMode({ mode: 'eidoverse' })).current).toBe('produce');
- expect(stageChecklist('produce', withMode({ mode: 'eidoverse' }), APPROVED).map((i) => [i.id, i.done])).toEqual([['composition', false]]);
- expect(stageChecklist('produce', withMode({ mode: 'eidoverse' }), APPROVED)[0])
+ expect(stageChecklist('produce', withMode({ mode: 'eidoverse' }), APPROVED).map((i) => [i.id, i.done])).toEqual([['approve-storyboard', true], ['composition', false]]);
+ expect(stageChecklist('produce', withMode({ mode: 'eidoverse' }), APPROVED).at(-1))
.toMatchObject({ label: 'Save the Eidoverse scene', done: false, action: { anchor: 'mv-eidoverse-scene' } });
const saved = withMode({ mode: 'eidoverse', eidoverseScene: { inlineScript: 'scene()' } });
expect(deriveStages(saved).current).toBe('review');
- expect(stageChecklist('produce', saved, APPROVED)[0].done).toBe(true);
+ expect(stageChecklist('produce', saved, APPROVED).at(-1).done).toBe(true);
// Code: composed only once generated (or sections exist).
expect(deriveStages(withMode({ mode: 'code' })).current).toBe('produce');
- expect(stageChecklist('produce', withMode({ mode: 'code' }), APPROVED)[0]).toMatchObject({ id: 'composition', done: false });
+ expect(stageChecklist('produce', withMode({ mode: 'code' }), APPROVED).at(-1)).toMatchObject({ id: 'composition', done: false });
expect(deriveStages(withMode({ mode: 'code', codeVideo: { generatedAt: '2026-01-01T00:00:00.000Z', sections: [] } })).current).toBe('review');
// Document: composed once the document is attached.
expect(deriveStages(withMode({ mode: 'document' })).current).toBe('produce');
@@ -183,7 +183,7 @@ describe('deriveStages / deriveNextAction', () => {
it('does not require scene footage for code-rendered or document projects', () => {
const bare = { productionReadiness: APPROVED, id: 'p', trackId: 't1', audioAnalysis: ANALYSIS, scenes: [scene({ referenceImageId: null, videoHistoryId: null })] };
// Make lists no footage row for them; only the composition and its proof remain.
- expect(stageChecklist('produce', { ...bare, composition: { mode: 'code' } }, APPROVED).map((i) => i.id)).toEqual(['composition']);
+ expect(stageChecklist('produce', { ...bare, composition: { mode: 'code' } }, APPROVED).map((i) => i.id)).toEqual(['approve-storyboard', 'composition']);
const doc = { ...bare, composition: { mode: 'document' } };
expect(deriveStages(doc).current).toBe('produce');
expect(deriveNextAction(doc).label).toBe('Attach a composition');
@@ -256,7 +256,7 @@ describe('following the tab order', () => {
.toMatchObject({ board: 'done', produce: 'done', review: 'active' });
expect(deriveNextAction(edited, { readiness })).toMatchObject({ id: 'render-final' });
expect(stageChecklist('produce', edited, readiness).map((i) => [i.id, i.done, !!i.optional, i.label]))
- .toEqual([['footage', true, false, 'Footage for every shot (1 of 1)'], ['composition', true, false, 'Timed typography added']]);
+ .toEqual([['footage', true, false, 'Footage for every shot (1 of 1)'], ['approve-storyboard', true, false, 'Every still locked'], ['composition', true, false, 'Timed typography added']]);
});
it('keeps the header on the footage until it is in, unless a run is parked on its pilot proof', () => {
@@ -324,9 +324,11 @@ describe('stage route param', () => {
expect(resolveStageParam(undefined)).toBeNull();
});
- it('opens Make for an old Compose link, and lists six steps each saying what done means', () => {
+ it('opens Shots for an old Compose link and the new step names, and lists six steps each saying what done means', () => {
expect(resolveStageParam('compose')).toBe('produce');
- expect(MUSIC_VIDEO_STAGES.map((stage) => stage.label)).toEqual(['Song', 'Look', 'Storyboard', 'Make', 'Final render', 'Publish']);
+ expect(resolveStageParam('shots')).toBe('produce');
+ expect(resolveStageParam('plan')).toBe('board');
+ expect(MUSIC_VIDEO_STAGES.map((stage) => stage.label)).toEqual(['Song', 'Look', 'Plan', 'Shots', 'Final render', 'Publish']);
for (const stage of MUSIC_VIDEO_STAGES) expect(stage.doneWhen).toMatch(/^Done when /);
});
@@ -369,7 +371,7 @@ describe('describeProjectStatus', () => {
expect(status).toEqual({ headline: 'Step 2 of 6: Look needs you', tone: 'warn', needsYouStage: 'cast-sets' });
// A blocked step needs the director even with no approval to give.
expect(describeProjectStatus({}, { progress: stages('produce', { produce: 'blocked' }) }))
- .toMatchObject({ headline: 'Step 4 of 6: Make needs you', needsYouStage: 'produce' });
+ .toMatchObject({ headline: 'Step 4 of 6: Shots needs you', needsYouStage: 'produce' });
});
it('names the step an approval sits on, even when an earlier step is still open', () => {
@@ -471,7 +473,9 @@ describe('stageChecklist', () => {
expect(stageChecklist('setup', { id: 'p', autonomousRun: { status: 'stopped' } })[0].detail).toBe('The autonomous run is paused. Resume it to make the song.');
expect(stageChecklist('setup', { id: 'p', autonomousRun: { status: 'awaiting-approval' } })[0].detail).toBe('The autonomous run is waiting for your approval.');
expect(stageChecklist('board', castProject({ scenes: [scene()] }), NOT_APPROVED).map((i) => [i.id, i.done]))
- .toEqual([['shots', true], ['board-art', false], ['approve-storyboard', false]]);
+ .toEqual([['shots', true], ['board-art', false]]);
+ expect(stageChecklist('produce', castProject({ scenes: [scene()] }), NOT_APPROVED).find((i) => i.id === 'approve-storyboard'))
+ .toMatchObject({ done: false, detail: 'Finish the plan first.', action: { stage: 'board' } });
expect(stageChecklist('produce', castProject({ scenes: [scene(), scene({ sceneId: 's2', videoHistoryId: null })] }), APPROVED)[0])
.toMatchObject({ id: 'footage', label: 'Footage for every shot (1 of 2)', done: false,
action: { label: 'Make the footage', anchor: 'mv-generation' } });
@@ -479,16 +483,16 @@ describe('stageChecklist', () => {
expect(stageChecklist('produce', castProject({ composition: { mode: 'composed' }, scenes: [scene(), scene({ sceneId: 's2', videoHistoryId: null, visualLayer: 'code', startSec: 0, endSec: 2 })] }), APPROVED)[0])
.toMatchObject({ id: 'footage', label: 'Footage for every shot (2 of 2)', done: true });
// A code render draws its own picture: no footage row, just its composition and proof.
- expect(stageChecklist('produce', castProject({ composition: { mode: 'code' } }), APPROVED).map((i) => i.id)).toEqual(['composition']);
+ expect(stageChecklist('produce', castProject({ composition: { mode: 'code' } }), APPROVED).map((i) => i.id)).toEqual(['approve-storyboard', 'composition']);
// The proof closes Make, after the composition work it is judged over.
expect(stageChecklist('produce', castProject({ scenes: [scene()], composition: { mode: 'composed', textCues: [] } }), APPROVED).map((i) => [i.id, i.done]))
- .toEqual([['footage', true], ['composition', false]]);
+ .toEqual([['footage', true], ['approve-storyboard', true], ['composition', false]]);
});
it('asks for the storyboard review, not a board plan, when a document storyboard brings its own shots', () => {
const project = { id: 'p', trackId: 't1', audioAnalysis: ANALYSIS, ...LYRICS, scenes: [], composition: { mode: 'document', document: { directory: 'd' } },
productionReview: { draft: { ...LYRICS.productionReview.draft, storyboardSource: 'document', storyboard: [{ id: 'shot-1' }] } } };
const readiness = { ...APPROVED, storyboard: { approved: false, problems: ['Import a shot manifest from the current authored document and master audio.'] }, proof: { approved: false, problems: [] }, readyForProduction: false };
- expect(deriveNextAction(project, { readiness })).toMatchObject({ id: 'review-production', stage: 'board', anchor: 'mv-review-storyboard' });
+ expect(deriveNextAction(project, { readiness })).toMatchObject({ id: 'review-production', stage: 'produce', anchor: 'mv-review-storyboard' });
expect(deriveNextAction({ ...project, productionReview: { draft: LYRICS.productionReview.draft } }, { readiness })).toMatchObject({ id: 'plan' });
});
@@ -497,18 +501,19 @@ describe('stageChecklist', () => {
const items = stageChecklist('board', castProject({ scenes: [scene()] }), readiness);
expect(items.find((i) => i.id === 'board-manifest')).toMatchObject({ label: 'Document shot manifest', action: { label: 'Import the shot manifest', anchor: 'mv-review-planning' } });
expect(items.some((i) => i.id === 'board-timing')).toBe(false);
- // The approval row points at the items above instead of repeating the first problem.
- expect(items.at(-1)).toMatchObject({ id: 'approve-storyboard', detail: 'Approve once the items above are done.' });
- // A stale approval keeps naming what changed, even with an art problem listed above it.
+ // Shots' approval row sends an unfinished plan back to Plan instead of repeating its first problem.
+ const shots = stageChecklist('produce', castProject({ scenes: [scene()] }), readiness);
+ expect(shots.find((i) => i.id === 'approve-storyboard')).toMatchObject({ detail: 'Finish the plan first.' });
+ // A stale approval keeps naming what changed, even with an art problem listed on Plan.
const stale = { ...readiness, storyboard: { approved: false, problems: ['Review and approve the current art direction first.'], stale: { changedFields: ['art direction', 'cast'] } } };
- expect(stageChecklist('board', castProject({ scenes: [scene()] }), stale).at(-1).detail).toMatch(/changed since: art direction, cast/);
+ expect(stageChecklist('produce', castProject({ scenes: [scene()] }), stale).find((i) => i.id === 'approve-storyboard').detail).toMatch(/changed since: art direction, cast/);
});
it('counts the shots left to lock once shots are locked one at a time', () => {
const readiness = { ...NOT_APPROVED, art: { approved: true, problems: [] }, storyboard: { approved: false, problems: [], unlocked: ['s2', 's3'] } };
- expect(stageChecklist('board', castProject({ scenes: [scene()] }), readiness).at(-1))
- .toMatchObject({ id: 'approve-storyboard', detail: '2 shots not locked yet. Lock each on its card, or approve them all here.' });
+ const stills = (r) => stageChecklist('produce', castProject({ scenes: [scene()] }), r).find((i) => i.id === 'approve-storyboard');
+ expect(stills(readiness)).toMatchObject({ label: 'Every still locked', detail: '2 shots not locked yet. Lock each on its card, or lock them all below.' });
const stale = { ...readiness, storyboard: { ...readiness.storyboard, stale: { changedFields: ['scene 2 prompt'] } } };
- expect(stageChecklist('board', castProject({ scenes: [scene()] }), stale).at(-1).detail).toMatch(/^2 shots not locked yet\. .*changed since: scene 2 prompt/);
+ expect(stills(stale).detail).toMatch(/^2 shots not locked yet\. .*changed since: scene 2 prompt/);
});
it('counts per-scene changes in a stale approval instead of naming every scene', () => {
const prompts = Array.from({ length: 26 }, (_, i) => `scene ${i + 1} prompt`);
@@ -518,12 +523,14 @@ describe('stageChecklist', () => {
it('offers Keep approved on a stale approval nothing else blocks, and files feedback on its own row', () => {
const feedback = [{ id: 'fb-1', stage: 'storyboard', target: 'Chorus', text: 'More lyrics on screen', decision: 'request-changes' }];
const stale = { ...NOT_APPROVED, storyboard: { approved: false, problems: [], stale: { changedFields: ['cast'] } } };
- expect(stageChecklist('board', castProject({ scenes: [scene()] }), stale).at(-1).action).toEqual({ label: 'Keep approved', run: 'keep-approval', stage: 'storyboard' });
+ const stills = (r, p = castProject({ scenes: [scene()] })) => stageChecklist('produce', p, r).find((i) => i.id === 'approve-storyboard');
+ expect(stills(stale).action).toEqual({ label: 'Keep approved', run: 'keep-approval', stage: 'storyboard' });
const blocked = { ...NOT_APPROVED, storyboard: { approved: false, problems: ['Resolve storyboard feedback for Chorus: More lyrics on screen'], stale: { changedFields: ['cast'] } } };
- const items = stageChecklist('board', castProject({ scenes: [scene()], productionReview: { feedback } }), blocked);
- expect(items.map((i) => i.id)).toEqual(['shots', 'feedback-storyboard', 'approve-storyboard']);
+ const project = castProject({ scenes: [scene()], productionReview: { feedback } });
+ const items = stageChecklist('board', project, blocked);
+ expect(items.map((i) => i.id)).toEqual(['shots', 'feedback-storyboard']);
expect(items[1]).toMatchObject({ label: 'Feedback', notes: [{ id: 'fb-1', target: 'Chorus', text: 'More lyrics on screen' }], action: { run: 'revise-feedback', stage: 'storyboard' } });
- expect(items.at(-1).action.run).toBeUndefined();
+ expect(stills(blocked, project).action.run).toBeUndefined();
});
it('keeps Setup open until lyrics are imported and their timing verified, unless the song is instrumental', () => {
const base = { id: 'p', trackId: 't1', audioAnalysis: ANALYSIS };
diff --git a/client/src/pages/MusicVideo.jsx b/client/src/pages/MusicVideo.jsx
index 7e4a94070a..c6d044d971 100644
--- a/client/src/pages/MusicVideo.jsx
+++ b/client/src/pages/MusicVideo.jsx
@@ -77,7 +77,7 @@ import NeedsAttentionBanner from '../components/musicVideo/NeedsAttentionBanner.
import SetupStage from '../components/musicVideo/stages/SetupStage.jsx';
import StageChecklist from '../components/musicVideo/StageChecklist.jsx';
import CastSetsStage from '../components/musicVideo/stages/CastSetsStage.jsx';
-import BoardStage from '../components/musicVideo/stages/BoardStage.jsx';
+import PlanStage from '../components/musicVideo/stages/PlanStage.jsx';
import ProduceStage from '../components/musicVideo/stages/ProduceStage.jsx';
import ReviewStage from '../components/musicVideo/stages/ReviewStage.jsx';
import { PUBLISH_TARGETS } from '../components/musicVideo/PublishPostingPanel.jsx';
@@ -127,11 +127,16 @@ function autopilotBlocker(project) {
const EMPTY_PRODUCTION_DRAFT = { cast: '', environments: '', visualLanguage: '', motionLanguage: '', guideArtifactId: null,
lyricsMode: 'vocal', timingStatus: 'provisional', timingNotes: '', storyboard: [] };
// The step each production approval closes (#10151); it sits at the bottom of that step.
-const APPROVAL_STAGE_BY_TAB = { 'cast-sets': 'art', board: 'storyboard', produce: 'proof' };
+// Shots closes with Lock all stills (the storyboard approval); once the stills are locked, a
+// production run parked on its pilot shows its optional animated proof there instead.
+const APPROVAL_STAGE_BY_TAB = { 'cast-sets': 'art', produce: 'storyboard' };
+const approvalStageFor = (tab, project, readiness, proofActive) => (tab === 'produce' && readiness?.storyboard?.approved
+ ? (proofReviewInUse(project, readiness, { proofActive }) ? 'proof' : null)
+ : APPROVAL_STAGE_BY_TAB[tab] || null);
// Steps reviewed by watching: the player leads them, with the approval beside it.
const PLAYER_FIRST_STAGES = new Set(['board', 'produce', 'review']);
const STAGE_VIEWS = {
- setup: SetupStage, 'cast-sets': CastSetsStage, board: BoardStage, produce: ProduceStage, review: ReviewStage, publish: PublishStage,
+ setup: SetupStage, 'cast-sets': CastSetsStage, board: PlanStage, produce: ProduceStage, review: ReviewStage, publish: PublishStage,
};
@@ -316,11 +321,12 @@ export default function MusicVideo() {
const statusKnown = !!productionReview.readiness || !!productionReview.readinessError;
if (selected && statusKnown && openedStage.id !== selected.id) setOpenedStage({ id: selected.id, stage: latestMusicVideoReviewDraft(selected) && !selected.renderHistoryId ? 'review' : progress.current });
const pinnedStage = openedStage.id === selected?.id ? openedStage.stage : null;
- const activeStage = resolveStageParam(routeStage) || (routeSceneId ? 'board' : (pinnedStage || progress.current));
+ // A shot's card lives on Shots, including links made when it lived on the Storyboard.
+ const activeStage = routeSceneId ? 'produce' : (resolveStageParam(routeStage) || pinnedStage || progress.current);
const handleToggleSceneExpand = (sceneId, isExpanded) => {
if (!selected) return;
- const stage = activeStage || 'board';
+ const stage = 'produce';
if (isExpanded) {
navigate(`/music-video/${selected.id}/${stage}/scene/${sceneId}`, { replace: true });
} else if (routeSceneId === sceneId) {
@@ -1313,7 +1319,8 @@ export default function MusicVideo() {
? { headline: `Status unavailable: ${productionReview.readinessError}`, tone: 'warn', needsYouStage: null }
: { headline: 'Loading status…', tone: 'muted', needsYouStage: null };
- const previewSources = selected ? listPreviewSources(selected, { finalVideoSrc: finalVideo.src, liveFirst: activeStage === 'produce', draftsFirst: activeStage === 'review', storyboardFirst: activeStage === 'board' }) : [];
+ const reviewStage = selected ? approvalStageFor(activeStage, selected, productionReview.readiness, productionReview.proof.active) : null;
+ const previewSources = selected ? listPreviewSources(selected, { finalVideoSrc: finalVideo.src, draftsFirst: activeStage === 'review', storyboardFirst: activeStage === 'board' || activeStage === 'produce' }) : [];
return (
// Below md the whole page scrolls (title bar and project header with it), so the step gets the screen.
@@ -1575,15 +1582,13 @@ export default function MusicVideo() {
headerAnchor={nextAction?.kind === 'goto' ? nextAction.anchor : null}
/>
)}
- // Make shows the optional proof only while a run's pilot or open feedback needs it.
- review={APPROVAL_STAGE_BY_TAB[activeStage] && (activeStage !== 'produce'
- || proofReviewInUse(selected, productionReview.readiness, { proofActive: productionReview.proof.active })) ? (
+ review={reviewStage ? (
<ProductionReviewPanel
key={`${selected.id}-${activeStage}`}
project={selected}
review={productionReview}
onOpenArtifact={openArtifact}
- stage={APPROVAL_STAGE_BY_TAB[activeStage]}
+ stage={reviewStage}
planning={planningDraft}
onNavigate={goToStage}
onSeek={(startSec) => seekToScene({ startSec }, { play: true })}
diff --git a/client/src/pages/MusicVideo.test.jsx b/client/src/pages/MusicVideo.test.jsx
index e0f5e4cd5d..9dc71b97d1 100644
--- a/client/src/pages/MusicVideo.test.jsx
+++ b/client/src/pages/MusicVideo.test.jsx
@@ -355,9 +355,9 @@ const selectProject = async (projectId) => {
// The page is a set of steps (deep-linked as /music-video/:id/:stage); a
// control is only on screen while its step is open, so tests say which one.
-// Compose is part of Make now. The phone's step bar is the tablist.
+// Compose is part of Shots now; Plan holds the planning tools. The phone's step bar is the tablist.
const STAGE_TABS = {
- setup: /^Song/, 'cast-sets': /^Look/, board: /^Storyboard/, produce: /^Make/, compose: /^Make/, review: /^Final render/, publish: /^Publish/,
+ setup: /^Song/, 'cast-sets': /^Look/, board: /^Plan/, produce: /^Shots/, compose: /^Shots/, review: /^Final render/, publish: /^Publish/,
};
// Project settings (render style, audio tools, autopilot, files) is a drawer over the step.
const openSettings = async (tab = 'Project') => {
@@ -372,7 +372,7 @@ const openStage = async (stage, selectFirstScene = true) => {
await waitFor(() => expect(screen.getByRole('tab', { name: STAGE_TABS[stage] })).toHaveAttribute('aria-selected', 'true'));
// Scene controls now belong to one URL-selected inspector. The existing
// generation/edit tests enter it through the visible thumbnail first.
- if (stage === 'board' && selectFirstScene) {
+ if (stage === 'produce' && selectFirstScene) {
const thumbnails = screen.getByLabelText('Storyboard thumbnails');
const first = within(thumbnails).queryAllByRole('button')[0];
if (first) await act(async () => { fireEvent.click(first); });
@@ -493,7 +493,7 @@ describe('MusicVideo project load recovery (#9761)', () => {
expect(screen.getByTestId('mv-project-grid')).toHaveTextContent(PROJECT_NO_CLIP.name);
} else {
expect(screen.getByRole('heading', { level: 2, name: PROJECT_NO_CLIP.name })).toBeInTheDocument();
- expect(screen.getByRole('tab', { name: /^Storyboard/ })).toHaveAttribute('aria-selected', 'true');
+ expect(screen.getByRole('tab', { name: /^Plan/ })).toHaveAttribute('aria-selected', 'true');
}
});
@@ -847,7 +847,7 @@ describe('MusicVideo needs-attention banner (#9940)', () => {
it('keeps a stranded revision\'s Resume and Cancel in the header on every stage after a reload', async () => {
resumeMusicVideoRevision.mockResolvedValue({ project: stranded, revision: stranded.revisions[0], needsGeneration: [], generating: [] });
cancelMusicVideoRevision.mockResolvedValue({ project: { ...stranded, revisions: [{ ...stranded.revisions[0], status: 'canceled' }] }, canceledJobIds: [] });
- await openProject(stranded, 'board');
+ await openProject(stranded, 'produce');
const banner = await screen.findByRole('region', { name: 'Needs attention' });
expect(banner).toHaveTextContent('A section revision is open');
await openStage('review');
@@ -862,7 +862,7 @@ describe('MusicVideo needs-attention banner (#9940)', () => {
});
it('shows no banner for a healthy project', async () => {
- await openProject(PROJECT_WITH_CLIP, 'board');
+ await openProject(PROJECT_WITH_CLIP, 'produce');
expect(screen.queryByRole('region', { name: 'Needs attention' })).not.toBeInTheDocument();
});
});
@@ -1036,7 +1036,7 @@ describe('MusicVideo project video renderer', () => {
expect(await screen.findByLabelText('Scene video renderer')).toHaveProperty('value', '');
closeSettings();
- await openStage('board');
+ await openStage('produce');
fireEvent.click(screen.getByRole('button', { name: /^Generate video$/ }));
await waitFor(() => expect(generateVideo).toHaveBeenCalled());
expect(generateVideo.mock.calls.at(-1)[0]).not.toHaveProperty('backend');
@@ -1072,7 +1072,7 @@ describe('MusicVideo project video renderer', () => {
));
closeSettings();
- await openStage('board');
+ await openStage('produce');
fireEvent.click(screen.getByRole('button', { name: /^Generate video$/ }));
await waitFor(() => expect(generateVideo).toHaveBeenCalledWith(expect.objectContaining({
backend: 'local',
@@ -1084,7 +1084,7 @@ describe('MusicVideo project video renderer', () => {
it('continues an existing scene through the local model native extend mode', async () => {
generateVideo.mockResolvedValue({ jobId: 'video-job-2' });
- await openProject(PROJECT_WITH_CLIP, 'board');
+ await openProject(PROJECT_WITH_CLIP, 'produce');
fireEvent.click(await screen.findByRole('button', { name: /^Continue shot$/ }));
@@ -1119,7 +1119,7 @@ describe('MusicVideo project video renderer', () => {
));
closeSettings();
- await openStage('board');
+ await openStage('produce');
fireEvent.click(screen.getByRole('button', { name: /^Generate video$/ }));
await waitFor(() => expect(generateVideo).toHaveBeenCalledWith(expect.objectContaining({
backend: 'local',
@@ -1186,7 +1186,7 @@ describe('MusicVideo project video renderer', () => {
actions: [{ startSec: 0, endSec: 1, subject: 'Singer', description: 'Offers a hand' }],
reactions: [{ startSec: 1, endSec: 2, subject: 'Listener', description: 'Turns back' }] };
await openProject({ ...PROJECT_NO_CLIP, videoSettings: { backend: 'fal', falDuration: 6 },
- scenes: [{ ...PROJECT_NO_CLIP.scenes[0], startSec: 0, endSec: 4, direction: { actionContract } }] }, 'board');
+ scenes: [{ ...PROJECT_NO_CLIP.scenes[0], startSec: 0, endSec: 4, direction: { actionContract } }] }, 'produce');
fireEvent.click(await findEnabledByRole('button', { name: /^Generate video$/ }));
await waitFor(() => expect(generateVideo).toHaveBeenCalled());
const prompt = generateVideo.mock.calls.at(-1)[0].prompt;
@@ -1210,7 +1210,7 @@ describe('MusicVideo project video renderer', () => {
expect(await screen.findByLabelText('fal.ai scene clip duration')).toHaveProperty('value', '6');
closeSettings();
- await openStage('board');
+ await openStage('produce');
// No model pin: the default Hailuo-02 image-to-video take, priced before it is paid for.
expect((await screen.findByTestId('fal-cutaway-plan')).textContent).toContain('est. $0.27 (6s at 768P)');
fireEvent.click(await findEnabledByRole('button', { name: /^Generate video$/ }));
@@ -1233,7 +1233,7 @@ describe('MusicVideo project video renderer', () => {
...PROJECT_NO_CLIP,
videoSettings: { backend: 'fal', falModelId: 'minimax/h3-max/image-to-video', falResolution: '1080P' },
scenes: [{ ...PROJECT_NO_CLIP.scenes[0], startSec: 0, endSec: 7.2 }],
- }, 'board');
+ }, 'produce');
// A 7.2s shot on H3 Max (5–15s whole seconds) renders 8s at $0.16/s.
expect((await screen.findByTestId('fal-cutaway-plan')).textContent).toContain('est. $1.28 (8s at 1080P)');
@@ -1257,7 +1257,7 @@ describe('MusicVideo project video renderer', () => {
it('blocks fal.ai scene generation with a clear preflight reason when no API key is configured', async () => {
// getVideoGenStatus's default mock omits falEnabled, so it resolves false —
// exactly the "no fal.ai API key configured" install this covers.
- await openProject({ ...PROJECT_NO_CLIP, videoSettings: { backend: 'fal' } }, 'board');
+ await openProject({ ...PROJECT_NO_CLIP, videoSettings: { backend: 'fal' } }, 'produce');
const generate = await screen.findByRole('button', { name: /^Generate video$/ });
expect(generate).toBeDisabled();
@@ -1284,7 +1284,7 @@ describe('MusicVideo project video renderer', () => {
expect(await screen.findByRole('option', { name: 'Grok video (cutaway only)' })).toBeTruthy();
closeSettings();
- await openStage('board');
+ await openStage('produce');
expect(await screen.findByText(/Grok video is cutaway-only/)).toBeTruthy();
const generate = await screen.findByRole('button', { name: /^Generate video$/ });
expect(generate).toBeDisabled();
@@ -1298,7 +1298,7 @@ describe('MusicVideo project video renderer', () => {
models: [{ id: 'ltx23_distilled_q4', name: 'LTX-2.3 Distilled Q4', runtime: 'ltx2' }],
});
generateVideo.mockResolvedValue({ jobId: 'fal-lipsync-job' });
- await openProject(performanceProject({ backend: 'fal', falDuration: 6 }), 'board');
+ await openProject(performanceProject({ backend: 'fal', falDuration: 6 }), 'produce');
const plan = await screen.findByTestId('performance-plan');
expect(plan.textContent).toContain('minimax/h3-max/lip-sync/image-to-video');
@@ -1315,7 +1315,7 @@ describe('MusicVideo project video renderer', () => {
it('persists a scene switched to a performance shot', async () => {
updateMusicVideoScene.mockResolvedValue({ ...PROJECT_NO_CLIP.scenes[0], shotMode: 'performance' });
- await openProject(PROJECT_NO_CLIP, 'board');
+ await openProject(PROJECT_NO_CLIP, 'produce');
fireEvent.change(await screen.findByLabelText('Shot'), { target: { value: 'performance' } });
await waitFor(() => expect(updateMusicVideoScene).toHaveBeenCalledWith(
@@ -1333,14 +1333,14 @@ describe('MusicVideo project video renderer', () => {
{ ...longShot, sceneId: 's1b', order: 1, label: 'Verse · 2/2', startSec: 21, videoHistoryId: null },
];
splitMusicVideoScene.mockResolvedValue({ project: { ...project, scenes: pieces }, scenes: pieces });
- await openProject(project, 'board');
+ await openProject(project, 'produce');
// The too-long refusal stays, now with a way out that never loops or stretches.
expect(await screen.findByText(/Split the scene on a lyric or phrase boundary/)).toBeTruthy();
fireEvent.click(await screen.findByRole('button', { name: /Split on lyric boundaries/ }));
await waitFor(() => expect(splitMusicVideoScene).toHaveBeenCalledWith('mv-2', 's1', 'fal', expect.anything()));
// The new scene shows on the Board and in the storyboard approval's shot list.
- expect((await screen.findAllByText('Verse · 2/2', { selector: ':not(option)' })).length).toBeGreaterThan(0);
+ expect((await screen.findAllByText(/Verse · 2\/2$/, { selector: ':not(option)' })).length).toBeGreaterThan(0);
expect(screen.queryByRole('button', { name: /Split on lyric boundaries/ })).toBeNull();
});
@@ -1351,7 +1351,7 @@ describe('MusicVideo project video renderer', () => {
videoSettings: { backend: 'grok', grokDuration: 6 },
phrases: [{ id: 'p1', startSec: 12, endSec: 15, intent: 'camera pushes in' }],
scenes: [{ ...PROJECT_NO_CLIP.scenes[0], startSec: 10, endSec: 17.2 }],
- }, 'board');
+ }, 'produce');
expect(await screen.findByText(/Grok renders a 10s clip for this 7\.2s cutaway/)).toBeTruthy();
fireEvent.click(await findEnabledByRole('button', { name: /^Generate video$/ }));
@@ -1394,7 +1394,7 @@ describe('MusicVideo restricted-model license gate', () => {
models: [{ id: 'gated_model', name: 'Gated Model', runtime: 'ltx2', termsGate: GATE }],
});
generateVideo.mockResolvedValue({ jobId: 'gated-job' });
- await openProject(PROJECT_NO_CLIP, 'board');
+ await openProject(PROJECT_NO_CLIP, 'produce');
const generate = await findEnabledByRole('button', { name: /^Generate video$/ });
expect(screen.queryByRole('checkbox', { name: /I am eligible/ })).toBeNull();
@@ -1699,7 +1699,7 @@ describe('MusicVideo lyrics and shot coverage (#8964)', () => {
],
};
updateMusicVideoScene.mockResolvedValue({});
- await openProject(project, 'board');
+ await openProject(project, 'produce');
// The card's summary row and its editor both quote the lyric.
expect(screen.getAllByText(/first line/).length).toBeGreaterThan(0);
@@ -1770,7 +1770,7 @@ describe('MusicVideo section layers (#8985)', () => {
const renderBtn = await screen.findByRole('button', { name: /^Render final$/ });
expect(renderBtn).toBeDisabled();
- await openStage('board');
+ await openStage('produce');
await act(async () => fireEvent.click(screen.getByRole('button', { name: 'Open Shot 2' })));
const layer = document.getElementById('mv-scene-s2-layer');
fireEvent.change(layer, { target: { value: 'card' } });
@@ -1787,7 +1787,7 @@ describe('MusicVideo section layers (#8985)', () => {
});
it('keeps a plain render on footage and says the layer only applies to composed renders', async () => {
- await openProject({ ...PROJECT_WITH_CLIP, scenes: [scenes[0], { ...scenes[1], visualLayer: 'card' }], composition: composition('concat') }, 'board');
+ await openProject({ ...PROJECT_WITH_CLIP, scenes: [scenes[0], { ...scenes[1], visualLayer: 'card' }], composition: composition('concat') }, 'produce');
await act(async () => fireEvent.click(screen.getByRole('button', { name: 'Open Shot 2' })));
expect(await screen.findByText(/Title card sections render in composed or document mode/)).toBeTruthy();
await openStage('review');
@@ -2307,7 +2307,7 @@ describe('MusicVideo media lightbox (#3718)', () => {
);
it('opens the lightbox from a reference-frame thumbnail click', async () => {
- await openProject(PROJECT_WITH_CLIP, 'board');
+ await openProject(PROJECT_WITH_CLIP, 'produce');
fireEvent.click(await screen.findByRole('button', { name: 'View scene 1 reference frame full size' }));
const dialog = await screen.findByRole('dialog', { name: /Media viewer/i });
expect(dialog).toBeTruthy();
@@ -2317,7 +2317,7 @@ describe('MusicVideo media lightbox (#3718)', () => {
});
it('opens the lightbox from a scene-clip expand control without hijacking play/pause', async () => {
- await openProject(PROJECT_WITH_CLIP, 'board');
+ await openProject(PROJECT_WITH_CLIP, 'produce');
// Inline thumb keeps its own controls attribute for native play/pause.
const inlineVideo = document.querySelector('video[src="/data/videos/h1.mp4"]');
expect(inlineVideo).toBeTruthy();
@@ -2347,7 +2347,7 @@ describe('MusicVideo media lightbox (#3718)', () => {
// the image model never saw. The sidecar is the only record of the real
// one — and it also carries the `cleanedFrom` lineage the hand-rolled item
// shape used to drop.
- await openProject(PROJECT_WITH_CLIP, 'board');
+ await openProject(PROJECT_WITH_CLIP, 'produce');
fireEvent.click(await screen.findByRole('button', { name: 'View scene 1 reference frame full size' }));
const dialog = await screen.findByRole('dialog', { name: /Media viewer/i });
await waitFor(() => {
@@ -2409,7 +2409,7 @@ describe('MusicVideo visual spec, takes and handoff (#8965)', () => {
universeStyle: 'Ink silhouettes', moodBoardStyle: 'Watercolor', subjects: [
{ id: 'lead', kind: 'character', role: 'protagonist', name: 'Example singer', description: 'Silver coat' },
],
- } }, 'board');
+ } }, 'produce');
fireEvent.click(screen.getByRole('button', { name: /^Generate frame$/ }));
await waitFor(() => expect(generateImage).toHaveBeenCalledWith(expect.objectContaining({
prompt: expect.stringContaining('character (protagonist): Example singer — Silver coat'),
@@ -2423,7 +2423,7 @@ describe('MusicVideo visual spec, takes and handoff (#8965)', () => {
new Error('Reference images are only supported for FLUX.2 and Qwen Image 2.1 models on the local backend'),
{ code: 'REFERENCE_IMAGES_FLUX2_ONLY', status: 400 },
));
- await openProject(SPEC_PROJECT, 'board');
+ await openProject(SPEC_PROJECT, 'produce');
fireEvent.click(screen.getByRole('button', { name: /^Generate frame$/ }));
await waitFor(() => expect(generateImage).toHaveBeenCalledWith({
prompt: 'harbor at dawn, grainy 16mm, color palette #112233; camera: locked-off wides',
@@ -2448,7 +2448,7 @@ describe('MusicVideo visual spec, takes and handoff (#8965)', () => {
{ id: 'mvr-cs-set-harbor', imageId: 'harbor.png', condition: true },
{ id: 'mvr-cs-set-roof', imageId: 'roof.png', condition: false },
] },
- }, 'board');
+ }, 'produce');
fireEvent.click(screen.getByRole('button', { name: /^Generate frame$/ }));
await waitFor(() => expect(generateImage).toHaveBeenCalledWith(expect.objectContaining({
referenceImageFiles: ['character.png', 'roof.png'],
@@ -2470,7 +2470,7 @@ describe('MusicVideo visual spec, takes and handoff (#8965)', () => {
referenceImageId: 'take-b.png',
takes: [{ ...scene.takes[0], status: 'rejected' }, scene.takes[1]],
});
- await openProject({ ...PROJECT_NO_CLIP, id: 'mv-takes', name: 'Takes Project', scenes: [scene] }, 'board');
+ await openProject({ ...PROJECT_NO_CLIP, id: 'mv-takes', name: 'Takes Project', scenes: [scene] }, 'produce');
const strip = screen.getByRole('list', { name: /Frame takes/ });
expect(within(strip).getByText(/imported · midjourney/)).toBeTruthy();
@@ -2508,7 +2508,7 @@ describe('MusicVideo visual spec, takes and handoff (#8965)', () => {
await waitFor(() => expect(toast.success).toHaveBeenCalledWith('Imported 1 take from midjourney'));
closeSettings();
// The imported take filled the empty slot on the board.
- await openStage('board');
+ await openStage('produce');
expect(await screen.findByRole('button', { name: 'View scene 1 reference frame full size' })).toBeTruthy();
});
@@ -2607,7 +2607,7 @@ describe('MusicVideo per-scene clip import (#8978)', () => {
addMusicVideoSceneTake.mockResolvedValueOnce({
scene: { ...PROJECT_NO_CLIP.scenes[0], videoHistoryId: 'rh-9', takes: [{ takeId: 't1', kind: 'video', assetId: 'rh-9', status: 'candidate' }] },
});
- await openProject(PROJECT_NO_CLIP, 'board');
+ await openProject(PROJECT_NO_CLIP, 'produce');
fireEvent.click(await screen.findByRole('button', { name: /^Import clip take$/ }));
const dialog = await screen.findByRole('dialog', { name: /Pick a video from your gallery/i });
@@ -2633,7 +2633,7 @@ describe('MusicVideo scene clip non-MP4 playback (#8978)', () => {
getVideoHistoryItem.mockImplementation((id) => (id === 'h1'
? Promise.resolve({ id: 'h1', filename: 'h1.mov' })
: Promise.reject(Object.assign(new Error('Not found'), { status: 404 }))));
- await openProject(PROJECT_WITH_CLIP, 'board');
+ await openProject(PROJECT_WITH_CLIP, 'produce');
await waitFor(() => expect(document.querySelector('video[src="/data/videos/h1.mov"]')).toBeTruthy());
expect(document.querySelector('video[src="/data/videos/h1.mp4"]')).toBeNull();
@@ -2674,7 +2674,7 @@ describe('MusicVideo stage tabs (#9243)', () => {
await waitFor(() => expect(document.getElementById('mv-auto-edit')).toHaveFocus());
});
- // Uniquely catches the opening title card form leaving the Look step or reappearing on Storyboard/Make.
+ // Uniquely catches the opening title card form leaving the Look step or reappearing on Plan/Shots.
it('edits the opening title card on the Look step only, right under the preview', async () => {
listMusicVideoProjects.mockResolvedValue([PROJECT_WITH_CLIP]);
renderAt('/music-video/mv-1/cast-sets');
@@ -2688,9 +2688,11 @@ describe('MusicVideo stage tabs (#9243)', () => {
}
});
- it('leads Storyboard with the player and its approval, leaves an unused proof off Make, closes Look with its approval, keeps the run in Project settings and unsaved planning edits across steps', async () => {
+ it('leads Shots with the player and Lock all stills, keeps approvals off Plan, closes Look with its approval, keeps the run in Project settings and unsaved planning edits across steps', async () => {
+ // Stills not yet locked, so Shots offers Lock all stills beside the player.
listMusicVideoProjects.mockResolvedValue([{ ...PROJECT_WITH_CLIP,
autonomousRun: { status: 'needs-human', stage: 'video', output: {}, brief: {} },
+ productionReadiness: { readyForProduction: false, basis: {}, art: { approved: true, problems: [] }, storyboard: { approved: false, problems: [] }, proof: { approved: true, problems: [] } },
}]);
renderAt('/music-video/mv-1/cast-sets');
await screen.findByRole('heading', { level: 2, name: PROJECT_WITH_CLIP.name });
@@ -2701,7 +2703,7 @@ describe('MusicVideo stage tabs (#9243)', () => {
const castDraft = within(review).getByLabelText('Cast guide');
fireEvent.change(castDraft, { target: { value: 'Example unsaved cast direction' } });
- const approvals = { 'cast-sets': 'Art direction', board: 'Lyric-timed storyboard' };
+ const approvals = { 'cast-sets': 'Art direction', produce: 'Lyric-timed storyboard' };
for (const stage of ['board', 'produce', 'cast-sets']) {
await openStage(stage);
const panel = screen.getByRole('tabpanel');
@@ -2709,8 +2711,8 @@ describe('MusicVideo stage tabs (#9243)', () => {
const title = selectedTab().textContent.split(',')[0];
expect(within(panel).getByRole('heading', { level: 3, name: title })).toBeInTheDocument();
expect(panel).toHaveAccessibleName(title);
- // Make shows the optional proof only while a production run needs it.
- if (stage === 'produce') {
+ // Plan has no approval: its shots are locked on Shots.
+ if (stage === 'board') {
expect(within(panel).queryByRole('region', { name: 'Production review' })).toBeNull();
continue;
}
@@ -2719,7 +2721,7 @@ describe('MusicVideo stage tabs (#9243)', () => {
// Look is reviewed through its visual guide: the step's work comes first and the approval closes it.
expect(panel.lastElementChild).toBe(stageReview);
} else {
- // Storyboard and Make are reviewed by watching: the player leads, the approval beside it, then the work.
+ // Shots is reviewed by watching: the player leads, the approval beside it, then the work.
const player = within(panel).getByRole('complementary', { name: 'Preview' });
expect(player.compareDocumentPosition(stageReview) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
expect(stageReview.parentElement).toBe(player.parentElement.parentElement);
@@ -2766,13 +2768,14 @@ describe('MusicVideo stage tabs (#9243)', () => {
listMusicVideoProjects.mockResolvedValue([PROJECT_WITH_CLIP]);
renderAt('/music-video/mv-1/produce');
await screen.findByRole('heading', { level: 2, name: PROJECT_WITH_CLIP.name });
- expect(selectedTab()).toHaveTextContent(/^Make/);
+ expect(selectedTab()).toHaveTextContent(/^Shots/);
expect(screen.getByRole('region', { name: 'Composition' })).toBeTruthy();
+ expect(screen.getByRole('button', { name: /Add scene/ })).toBeTruthy();
fireEvent.click(screen.getByRole('tab', { name: STAGE_TABS.board }));
await waitFor(() => expect(screen.getByTestId('loc').textContent).toBe('/music-video/mv-1/board'));
- expect(selectedTab()).toHaveTextContent(/^Storyboard/);
- expect(screen.getByRole('button', { name: /Add scene/ })).toBeTruthy();
+ expect(selectedTab()).toHaveTextContent(/^Plan/);
+ expect(screen.getByRole('button', { name: /AI Plan/ })).toBeTruthy();
});
it('falls back to the stage the project is in when the URL names no stage or an unknown one', async () => {
@@ -2810,9 +2813,10 @@ describe('MusicVideo stage tabs (#9243)', () => {
// Creative direction is what the cast and sets are built from.
Concept: (root) => root.queryByLabelText('Concept'),
},
- board: { 'AI Plan': (root) => root.queryByRole('button', { name: /AI Plan/ }), 'Add scene': (root) => root.queryByRole('button', { name: /Add scene/ }), 'Shot prompt': (root) => root.queryByLabelText('Shot prompt') },
- // Make: the footage, then the composition over it.
- produce: { Footage: () => document.getElementById('mv-generation'), Typography: (root) => root.queryByText(/^Typography —/) },
+ board: { 'AI Plan': (root) => root.queryByRole('button', { name: /AI Plan/ }) },
+ // Shots: the scene board, the footage, then the composition over it.
+ produce: { 'Add scene': (root) => root.queryByRole('button', { name: /Add scene/ }), 'Shot prompt': (root) => root.queryByLabelText('Shot prompt'),
+ Footage: () => document.getElementById('mv-generation'), Typography: (root) => root.queryByText(/^Typography —/) },
review: { 'Render final': (root) => root.queryByRole('button', { name: /^Render final$/ }), 'Render excerpt': (root) => root.queryByRole('button', { name: /Render excerpt/ }) },
};
const settings = {
@@ -2892,7 +2896,7 @@ describe('MusicVideo stage tabs (#9243)', () => {
};
const project = { ...PROJECT_ANALYZED, productionRuns: [run] };
stopMusicVideoProduction.mockResolvedValue({ project, run });
- await openProject(project, 'board');
+ await openProject(project, 'produce');
expect(screen.getByText('$4.50 / $20.00')).toBeTruthy();
fireEvent.click(screen.getByRole('button', { name: 'Stop production' }));
await waitFor(() => expect(stopMusicVideoProduction).toHaveBeenCalledWith('mv-3', 'run-1', { silent: true }));
@@ -2903,14 +2907,14 @@ describe('MusicVideo stage tabs (#9243)', () => {
id: 'run-2', status: 'needs-human', interrupted: false, directive: '', stopReason: 'Example stop reason', error: null, pool: [],
limits: { maxGenerations: 12, maxReviewAttempts: 3, spendCapUsd: 20 }, usage: { generations: 3, spentUsd: 4.5 }, steps: [],
};
- await openProject({ ...PROJECT_ANALYZED, productionRuns: [run] }, 'board');
+ await openProject({ ...PROJECT_ANALYZED, productionRuns: [run] }, 'produce');
// "needs-human" has no Resume and the header's Autopilot button stays plain, so the row is the only signal.
const banner = screen.getByRole('region', { name: 'Needs attention' });
expect(within(banner).getByText('Production needs you')).toBeTruthy();
});
it('takes a finished project on to its release (#9281)', async () => {
- await openProject({ ...PROJECT_WITH_CLIP, audioAnalysis: PROJECT_ANALYZED.audioAnalysis, renderHistoryId: 'rh-9' }, 'board');
+ await openProject({ ...PROJECT_WITH_CLIP, audioAnalysis: PROJECT_ANALYZED.audioAnalysis, renderHistoryId: 'rh-9' }, 'produce');
fireEvent.click(screen.getByRole('button', { name: 'Build the publishing kit' }));
await waitFor(() => expect(selectedTab()).toHaveTextContent(/^Publish/));
expect(screen.getByRole('region', { name: 'Release assets' })).toBeTruthy();
@@ -2937,7 +2941,7 @@ describe('MusicVideo stage tabs (#9243)', () => {
await openProject(docProject, 'setup');
expect(await screen.findByTitle('Composition document preview')).toBeTruthy();
- await openStage('board');
+ await openStage('produce');
expect(screen.getByTitle('Composition document preview')).toBeTruthy();
await waitFor(() => expect(screen.getByText('0.00s / 60.0s')).toBeTruthy());
fireEvent.click(screen.getByRole('button', { name: 'Open Shot 2' }));
@@ -3016,7 +3020,7 @@ describe('MusicVideo stage tabs (#9243)', () => {
});
it('keeps the dock with an empty state when there is nothing to play yet', async () => {
- await openProject({ ...PROJECT_WITH_CLIP, trackId: null, uploadedAudioFilename: null }, 'board');
+ await openProject({ ...PROJECT_WITH_CLIP, trackId: null, uploadedAudioFilename: null }, 'produce');
const dock = screen.getByRole('complementary', { name: 'Preview' });
expect(dock).toHaveTextContent('Nothing to play yet');
expect(within(dock).queryByLabelText('Preview source')).toBeNull();
@@ -3025,7 +3029,7 @@ describe('MusicVideo stage tabs (#9243)', () => {
});
it('plays the storyboard animatic when the project has a track and shots but no document or finished excerpt', async () => {
- await openProject(PROJECT_WITH_CLIP, 'board');
+ await openProject(PROJECT_WITH_CLIP, 'produce');
const dock = screen.getByRole('complementary', { name: 'Preview' });
expect(dock).toHaveTextContent('Storyboard animatic');
expect(dock).not.toHaveTextContent('Nothing to play yet');
@@ -3263,11 +3267,13 @@ describe('stage checklist and project options', () => {
expect(within(checklist).queryByRole('button', { name: /Import lyrics/ })).toBeNull();
const requests = within(checklist).getByRole('list', { name: 'Open change requests' });
expect(requests).toHaveTextContent('Chorus: Put the lyrics on the wall, not the screen');
- expect(screen.getByRole('region', { name: 'Approve: Lyric-timed storyboard' })).toHaveTextContent('Resolve the change request on Chorus first.');
fireEvent.click(within(checklist).getByRole('button', { name: /Revise from feedback/ }));
await waitFor(() => expect(feedbackCalls.revise).toHaveBeenCalledWith('storyboard'));
fireEvent.click(within(requests).getByRole('button', { name: 'Mark resolved: Chorus' }));
expect(feedbackCalls.resolveFeedback).toHaveBeenCalledWith('fb-a', '');
+ // Lock all stills, on Shots, waits on the same request.
+ await openStage('produce', false);
+ expect(screen.getByRole('region', { name: 'Approve: Lyric-timed storyboard' })).toHaveTextContent('Resolve the change request on Chorus first.');
});
it('builds the cast & sets from the Look checklist when nothing is written yet', async () => {
@@ -3375,27 +3381,27 @@ describe('MusicVideo deep-linking and drawer URL routing (#10168)', () => {
it('updates the URL when a scene is expanded and removes it when collapsed', async () => {
listMusicVideoProjects.mockResolvedValue([PROJECT_WITH_CLIP]);
render(
- <MemoryRouter initialEntries={[`/music-video/${PROJECT_WITH_CLIP.id}/board`]}>
+ <MemoryRouter initialEntries={[`/music-video/${PROJECT_WITH_CLIP.id}/produce`]}>
<LocationProbe />
{MV_ROUTES}
</MemoryRouter>
);
await screen.findByRole('heading', { level: 2, name: PROJECT_WITH_CLIP.name });
- expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/board`);
+ expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/produce`);
expect(document.getElementById('scene-s1')).toBeNull();
- const thumbnail = screen.getByRole('button', { name: 'Open Scene 1' });
+ const thumbnail = screen.getByRole('button', { name: /^Open (Shot 1|Scene 1)/ });
await act(async () => fireEvent.click(thumbnail));
const details = document.getElementById('scene-s1');
expect(details).toBeInTheDocument();
- expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/board/scene/s1`);
+ expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/produce/scene/s1`);
details.querySelector('summary').focus();
await act(async () => {
details.open = false;
fireEvent(details, new Event('toggle'));
});
- expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/board`);
+ expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/produce`);
expect(document.getElementById('scene-s1')).toBeNull();
expect(thumbnail).toHaveFocus();
await settle();
@@ -3404,18 +3410,18 @@ describe('MusicVideo deep-linking and drawer URL routing (#10168)', () => {
it('keeps scene routing and focus together when j/k switches the inspector', async () => {
const first = { ...PROJECT_WITH_CLIP.scenes[0], sceneId: 's1', order: 0 };
listMusicVideoProjects.mockResolvedValue([{ ...PROJECT_WITH_CLIP, scenes: [first, { ...first, sceneId: 's2', order: 1 }] }]);
- render(<MemoryRouter initialEntries={[`/music-video/${PROJECT_WITH_CLIP.id}/board/scene/s1`]}><LocationProbe />{MV_ROUTES}</MemoryRouter>);
+ render(<MemoryRouter initialEntries={[`/music-video/${PROJECT_WITH_CLIP.id}/produce/scene/s1`]}><LocationProbe />{MV_ROUTES}</MemoryRouter>);
await screen.findByRole('heading', { level: 2, name: PROJECT_WITH_CLIP.name });
// The heading can land a commit before the inspector; wait for the scene the keys act on.
await waitFor(() => expect(document.querySelector('#scene-s1 summary')).not.toBeNull());
document.querySelector('#scene-s1 summary').focus();
await act(async () => fireEvent.keyDown(document.activeElement, { key: 'j' }));
- expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/board/scene/s2`);
+ expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/produce/scene/s2`);
expect(document.querySelector('#scene-s1')).toBeNull();
expect(document.querySelector('#scene-s2 summary')).toHaveFocus();
expect(document.querySelectorAll('video[src^="/data/videos/"]')).toHaveLength(1);
await act(async () => fireEvent.keyDown(document.activeElement, { key: 'k' }));
- expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/board/scene/s1`);
+ expect(screen.getByTestId('loc')).toHaveTextContent(`/music-video/${PROJECT_WITH_CLIP.id}/produce/scene/s1`);
expect(document.querySelector('#scene-s2')).toBeNull();
expect(document.querySelector('#scene-s1 summary')).toHaveFocus();
});
diff --git a/server/lib/navManifest.js b/server/lib/navManifest.js
index b9206487ef..8dbf73fe4c 100644
--- a/server/lib/navManifest.js
+++ b/server/lib/navManifest.js
@@ -64,8 +64,8 @@ const RAW_NAV_COMMANDS = [
{ id: 'nav.create.music-video.new', path: '/music-video?new=project', label: 'New Music Video', section: 'Create', aliases: ['new-music-video', 'create-music-video', 'new music video', 'create music video'], keywords: ['music video', 'new', 'create', 'project', 'draft'] },
{ id: 'nav.create.music-video.setup', path: '/music-video/setup', label: 'Music Video Song', section: 'Create', aliases: ['music-video-setup', 'mv-setup', 'music video setup', 'music-video-song', 'mv-song'], keywords: ['music video', 'song', 'setup', 'track', 'audio', 'lyrics'] },
{ id: 'nav.create.music-video.cast-sets', path: '/music-video/cast-sets', label: 'Music Video Look', section: 'Create', aliases: ['cast-and-sets', 'cast-sets', 'cast and sets', 'music-video-cast-sets', 'music-video-look', 'mv-look'], keywords: ['music video', 'look', 'cast', 'sets', 'characters', 'visual spec', 'art direction'] },
- { id: 'nav.create.music-video.board', path: '/music-video/board', label: 'Music Video Storyboard', section: 'Create', aliases: ['board', 'open-the-board', 'open the board', 'music-video-board', 'scene-board', 'music-video-storyboard'], keywords: ['music video', 'storyboard', 'board', 'scenes', 'timeline', 'shots', 'treatment'] },
- { id: 'nav.create.music-video.produce', path: '/music-video/produce', label: 'Music Video Make', section: 'Create', aliases: ['produce', 'music-video-produce', 'mv-produce', 'music-video-make', 'mv-make', 'compose', 'music-video-compose', 'mv-compose'], keywords: ['music video', 'make', 'produce', 'compose', 'footage', 'typography', 'proof', 'takes', 'production'] },
+ { id: 'nav.create.music-video.board', path: '/music-video/board', label: 'Music Video Plan', section: 'Create', aliases: ['music-video-plan', 'mv-plan', 'board', 'open-the-board', 'open the board', 'music-video-board', 'music-video-storyboard'], keywords: ['music video', 'plan', 'storyboard', 'timeline', 'treatment', 'beat timeline'] },
+ { id: 'nav.create.music-video.produce', path: '/music-video/produce', label: 'Music Video Shots', section: 'Create', aliases: ['music-video-shots', 'mv-shots', 'scene-board', 'produce', 'music-video-produce', 'mv-produce', 'music-video-make', 'mv-make', 'compose', 'music-video-compose', 'mv-compose'], keywords: ['music video', 'shots', 'scenes', 'stills', 'clips', 'locks', 'make', 'footage', 'typography', 'takes', 'production'] },
{ id: 'nav.create.music-video.review', path: '/music-video/review', label: 'Music Video Final Render', section: 'Create', aliases: ['music-video-review', 'mv-review', 'music video review', 'music-video-render', 'mv-render'], keywords: ['music video', 'final render', 'render', 'review', 'export', 'drafts'] },
{ id: 'nav.create.music-video.publish', path: '/music-video/publish', label: 'Music Video Publish', section: 'Create', aliases: ['music-video-publish', 'mv-publish', 'music video publish'], keywords: ['music video', 'publish', 'release', 'kit', 'social'] },
{ id: 'nav.create.decks', path: '/decks', label: 'Decks', section: 'Create', aliases: ['decks', 'deck', 'card-deck', 'playing-cards', 'tarot', 'tarot-deck', 'cards'], keywords: ['playing cards', 'tarot', 'card deck', 'card design', 'suits', 'arcana', 'style guide', 'batch render', 'card art'] },
diff --git a/server/routes/musicVideoProductionReview.browser.test.js b/server/routes/musicVideoProductionReview.browser.test.js
index 75aeb8f658..234cf37f7b 100644
--- a/server/routes/musicVideoProductionReview.browser.test.js
+++ b/server/routes/musicVideoProductionReview.browser.test.js
@@ -117,14 +117,14 @@ describe.skipIf(!canRun)('production review in a real browser (Chrome, ffmpeg an
await page.getByLabel('Requested change').fill('Move the operator behind the threshold at the exit.');
await page.getByRole('button', { name: 'Save revision feedback' }).click();
await page.getByText('Move the operator behind the threshold at the exit.', { exact: true }).waitFor();
- expect(await page.getByRole('button', { name: 'Approve lyric-timed storyboard' }).isDisabled()).toBe(true);
+ expect(await page.getByRole('button', { name: 'Lock all stills' }).isDisabled()).toBe(true);
await page.getByLabel('How it was resolved (optional)').fill('Reviewed the updated staging in the storyboard.');
await page.getByRole('button', { name: 'Mark resolved' }).click();
await page.getByText('Resolution: Reviewed the updated staging in the storyboard.', { exact: true }).waitFor();
const beforeBoard = await page.evaluate(async id => (await fetch('/api/music-video/' + id + '/production-review')).json(), p.id);
expect(beforeBoard.readiness.storyboard.problems).toEqual([]);
- await page.getByRole('button', { name: 'Approve lyric-timed storyboard' }).click();
- await page.getByRole('heading', { name: 'Lyric-timed storyboard approved', exact: true }).waitFor();
+ await page.getByRole('button', { name: 'Lock all stills' }).click();
+ await page.getByRole('heading', { name: 'All stills locked', exact: true }).waitFor();
await page.getByRole('button', { name: 'Make step', exact: true }).click();
await page.getByRole('button', { name: 'Render animated proof' }).click();
await page.locator('video').waitFor({ timeout: 120000 });
diff --git a/server/routes/musicVideoRichAuthoring.browser.test.js b/server/routes/musicVideoRichAuthoring.browser.test.js
index aa24f21177..906340f625 100644
--- a/server/routes/musicVideoRichAuthoring.browser.test.js
+++ b/server/routes/musicVideoRichAuthoring.browser.test.js
@@ -162,13 +162,13 @@ describe.skipIf(!canRun)('rich document authoring in a real browser (Chrome, ffm
await page.getByLabel('Requested change').fill('Move the operator behind the threshold at the exit.');
await page.getByRole('button', { name: 'Save revision feedback' }).click();
await page.getByText('Move the operator behind the threshold at the exit.', { exact: true }).waitFor();
- expect(await page.getByRole('button', { name: 'Approve lyric-timed storyboard' }).isDisabled()).toBe(true);
+ expect(await page.getByRole('button', { name: 'Lock all stills' }).isDisabled()).toBe(true);
await page.getByLabel('How it was resolved (optional)').fill('Reviewed the updated staging in the storyboard.');
await page.getByRole('button', { name: 'Mark resolved' }).click();
await page.getByText('Resolution: Reviewed the updated staging in the storyboard.', { exact: true }).waitFor();
const beforeBoard = await page.evaluate(async id => (await fetch('/api/music-video/' + id + '/production-review')).json(), p.id);
expect(beforeBoard.readiness.storyboard.problems).toEqual([]);
- await approve('Approve lyric-timed storyboard');
+ await approve('Lock all stills');
await page.getByRole('button', { name: 'Make step', exact: true }).click();
// Generation response, then the candidate the panel fetches in response to the updated project.
// Observing both names the failing hop, and they also assert the candidate pointer is the one just staged.
diff --git a/server/services/voice/tools/ui.js b/server/services/voice/tools/ui.js
index 22678d7b17..f5713e692e 100644
--- a/server/services/voice/tools/ui.js
+++ b/server/services/voice/tools/ui.js
@@ -56,7 +56,11 @@ export const UI_TOOLS = [
board: 'board',
'the-board': 'board',
'open-the-board': 'board',
- 'scene-board': 'board',
+ plan: 'board',
+ 'the-plan': 'board',
+ 'scene-board': 'produce',
+ shots: 'produce',
+ 'the-shots': 'produce',
produce: 'produce',
compose: 'compose',
review: 'review',