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

fix: allow generation-completion to fill empty stills on locked shots (#12066)

Adam Eivy75bb367a7a4f
diff --git a/server/services/musicVideo/productionReview.js b/server/services/musicVideo/productionReview.js
index fd3a29edfa..0d0ba9a4ec 100644
--- a/server/services/musicVideo/productionReview.js
+++ b/server/services/musicVideo/productionReview.js
@@ -236,20 +236,48 @@ export function preserveAutomatedShotLocks(before, after, source) {
const locks = shotLocks(before) || {};
const locked = (before.scenes || []).filter(scene => locks[scene.sceneId] === 'locked');
if (!locked.length) return { project: after, rejected: false };
+ const textId = v => (typeof v === 'string' && v.trim() ? v.trim() : null);
+ const isAllowedStillFill = (scene, proposed) => {
+ if (source !== 'generation-completion' || !proposed) return false;
+ const refBefore = textId(scene.referenceImageId);
+ const refAfter = textId(proposed.referenceImageId);
+ const endBefore = textId(scene.endImageId);
+ const endAfter = textId(proposed.endImageId);
+ const fillsRef = !refBefore && Boolean(refAfter);
+ const fillsEnd = !endBefore && Boolean(endAfter);
+ if (!fillsRef && !fillsEnd) return false;
+ if (refBefore && refBefore !== refAfter) return false;
+ if (endBefore && endBefore !== endAfter) return false;
+ const synthetic = { ...scene, referenceImageId: proposed.referenceImageId, endImageId: proposed.endImageId };
+ return shotApprovalBasis(before, synthetic) === shotApprovalBasis(after, proposed);
+ };
const rejected = locked.filter(scene => {
const proposed = after.scenes?.find(next => next.sceneId === scene.sceneId);
// Repair notes feed generation too, but stay outside the persisted approval
// hash so existing shot locks keep their cross-version meaning.
const repairBasis = shot => hash({ stillFixes: shot.stillFixes, clipFixes: shot.clipFixes });
- return !proposed || shotApprovalBasis(before, scene) !== shotApprovalBasis(after, proposed)
- || repairBasis(scene) !== repairBasis(proposed)
- || (clipLocked(before, scene.sceneId) && proposed.videoHistoryId !== scene.videoHistoryId);
+ if (!proposed) return true;
+ if (repairBasis(scene) !== repairBasis(proposed)) return true;
+ if (clipLocked(before, scene.sceneId) && proposed.videoHistoryId !== scene.videoHistoryId) return true;
+ if (shotApprovalBasis(before, scene) === shotApprovalBasis(after, proposed)) return false;
+ return !isAllowedStillFill(scene, proposed);
});
// Materialize legacy whole-board locks before an open shot's edit can stale
// that approval. No new approval is granted: these shots were already locked.
+ // When a generated still fills an empty slot on a locked shot, re-bind that
+ // shot's lock to the new basis so it stays locked.
const shotApprovals = { ...after.productionReview?.shotApprovals };
- for (const scene of locked) shotApprovals[scene.sceneId] = before.productionReview?.shotApprovals?.[scene.sceneId]
- || stillLock(before, scene, { ...before.productionReview?.approvals?.storyboard, fromBoardApproval: true });
+ for (const scene of locked) {
+ const proposed = after.scenes?.find(next => next.sceneId === scene.sceneId);
+ const priorApproval = before.productionReview?.shotApprovals?.[scene.sceneId]
+ || { ...before.productionReview?.approvals?.storyboard, fromBoardApproval: true };
+ if (!rejected.length && proposed && isAllowedStillFill(scene, proposed)) {
+ shotApprovals[scene.sceneId] = stillLock(after, proposed, priorApproval);
+ } else {
+ shotApprovals[scene.sceneId] = before.productionReview?.shotApprovals?.[scene.sceneId]
+ || stillLock(before, scene, priorApproval);
+ }
+ }
let next = { ...after, productionReview: { ...after.productionReview, shotApprovals } };
if (!rejected.length) return { project: next, rejected: false };
// A merge/re-plan may replace IDs or spans. Refuse the whole board mutation
diff --git a/server/services/musicVideo/productionService.test.js b/server/services/musicVideo/productionService.test.js
index 30b4fccc87..b8f24699c2 100644
--- a/server/services/musicVideo/productionService.test.js
+++ b/server/services/musicVideo/productionService.test.js
@@ -52,19 +52,38 @@ const store = new Map();
const storeFault = { failOnList: false, failWrites: false };
let writeTail = Promise.resolve();
const clone = (v) => JSON.parse(JSON.stringify(v));
+const mutateMock = (id, transform, options = {}) => {
+ const run = writeTail.then(async () => {
+ if (!store.has(id)) throw Object.assign(new Error('Project not found'), { status: 404 });
+ if (storeFault.failWrites) throw new Error('store write failed');
+ const current = clone(store.get(id));
+ const out = transform(current);
+ if (options?.source) {
+ const { preserveAutomatedShotLocks } = await import('./productionReview.js');
+ const guarded = preserveAutomatedShotLocks(current, out.project, options.source);
+ out.project = guarded.project;
+ if (guarded.rejected) {
+ out.rejected = true;
+ if (out.scenes) out.scenes = guarded.project.scenes;
+ if (out.scene) out.scene = guarded.project.scenes.find(scene => scene.sceneId === out.scene?.sceneId) || null;
+ }
+ }
+ store.set(id, clone(out.project));
+ return out;
+ });
+ writeTail = run.catch(() => {});
+ return run;
+};
vi.mock('./projects.js', () => ({
getProject: async (id) => (store.has(id) ? clone(store.get(id)) : null),
listProjects: async () => [...store.values()].map(clone),
- mutateProjectRecord: (id, transform) => {
- const run = writeTail.then(() => {
- if (!store.has(id)) throw Object.assign(new Error('Project not found'), { status: 404 });
- if (storeFault.failWrites) throw new Error('store write failed');
- const out = transform(clone(store.get(id)));
- store.set(id, clone(out.project));
- return out;
+ mutateProjectRecord: mutateMock,
+ appendSceneTakes: async (id, sceneId, inputs) => {
+ const { appendSceneTakes: append } = await import('./takes.js');
+ const outcome = await mutateMock(id, current => append(current, sceneId, inputs), {
+ source: inputs.some(input => input.source === 'generated') ? 'generation-completion' : null,
});
- writeTail = run.catch(() => {});
- return run;
+ return { scene: outcome.project.scenes.find(scene => scene.sceneId === sceneId), appended: outcome.appended };
},
}));
@@ -149,6 +168,21 @@ function completeJob(jobId) {
musicVideoEvents.emit(job.kind === 'image' ? 'scene-image' : 'scene-video', { projectId: 'mv-example', sceneId: scene.sceneId });
}
+/** Complete a job through appendSceneTakes (with source: 'generation-completion'), as the real hook does. */
+async function completeJobThroughHook(jobId) {
+ const job = jobs.find((j) => j.id === jobId);
+ job.status = 'completed';
+ const sceneId = job.params.musicVideo.sceneId;
+ const { appendSceneTakes } = await import('./projects.js');
+ await appendSceneTakes('mv-example', sceneId, [{
+ kind: job.kind === 'image' ? (job.params?.musicVideo?.slot === 'end' ? 'endImage' : 'image') : 'video',
+ assetId: job.kind === 'image' ? `${jobId}.png` : jobId,
+ source: 'generated',
+ }]);
+ mediaJobEvents.emit('completed', job);
+ musicVideoEvents.emit(job.kind === 'image' ? 'scene-image' : 'scene-video', { projectId: 'mv-example', sceneId });
+}
+
const settle = async () => {
// Wait for every fire-and-forget continuation (not a guessed number of timer
// ticks, which a contended worker can outrun, #10629), take one more pass,
@@ -1489,3 +1523,65 @@ it('moves past the optional animated proof to review without rendering or waitin
expect(JSON.stringify(theRun())).not.toMatch(/animated proof/);
expect(startAutoReview).toHaveBeenCalled();
});
+
+it('allows production to fill still-less locked shots on an approved board and proceed to clips without re-dispatching', async () => {
+ creativeReview.real = true;
+ const { approveProductionStage, productionReviewBasis, shotLocks } = await vi.importActual('./productionReview.js');
+ const seeded = seedProject({
+ devArtifacts: [{ id: 'guide', version: 1, file: 'guide.html', mimeType: 'text/html' }],
+ });
+ seeded.productionReview = { draft: {
+ cast: 'Paper dancer', environments: 'Theatre', visualLanguage: 'Ink silhouettes', motionLanguage: 'Slow orbit',
+ guideArtifactId: 'guide', lyricsMode: 'instrumental', timingNotes: 'Synthetic instrumental master checked.',
+ storyboard: seeded.scenes.map(scene => ({ sceneId: scene.sceneId, lyricCueIds: [], action: 'Dancer unfolds', staging: 'Wide theatre', camera: 'Orbit', transition: 'Fade' })),
+ } };
+ await start();
+ expect(theRun().status).toBe('blocked');
+ for (const stage of ['art', 'storyboard']) {
+ const project = current();
+ store.set(project.id, approveProductionStage(project, { stage, basis: productionReviewBasis(project)[stage] }));
+ }
+
+ // Board approved with still-less shots: every shot is locked with empty referenceImageId
+ expect(shotLocks(current())).toEqual({ 'mvs-a': 'locked', 'mvs-b': 'locked' });
+ expect(current().scenes[0].referenceImageId).toBeFalsy();
+ expect(current().scenes[1].referenceImageId).toBeFalsy();
+
+ await service.resumeProduction('mv-example', theRun().id);
+ await settle();
+ expect(theRun().status).toBe('running');
+ // Frames are dispatched for both scenes
+ expect(jobs).toHaveLength(2);
+ expect(jobs.every(j => j.kind === 'image')).toBe(true);
+ const frameJobA = jobs.find(j => j.params.musicVideo.sceneId === 'mvs-a');
+ const frameJobB = jobs.find(j => j.params.musicVideo.sceneId === 'mvs-b');
+ expect(frameJobA).toBeDefined();
+ expect(frameJobB).toBeDefined();
+
+ // Complete first frame through hook (generation-completion)
+ await completeJobThroughHook(frameJobA.id);
+ await settle();
+
+ // Slot for scene A is filled, lock still locked!
+ let updated = current();
+ const sceneA = updated.scenes.find(s => s.sceneId === 'mvs-a');
+ expect(sceneA.referenceImageId).toBe(`${frameJobA.id}.png`);
+ expect(shotLocks(updated)['mvs-a']).toBe('locked');
+ // No re-dispatch of frame A!
+ expect(jobs.filter(j => j.params.musicVideo.sceneId === 'mvs-a' && j.kind === 'image')).toHaveLength(1);
+
+ // Complete second frame through hook
+ await completeJobThroughHook(frameJobB.id);
+ await settle();
+
+ updated = current();
+ const sceneB = updated.scenes.find(s => s.sceneId === 'mvs-b');
+ expect(sceneB.referenceImageId).toBe(`${frameJobB.id}.png`);
+ expect(shotLocks(updated)).toEqual({ 'mvs-a': 'locked', 'mvs-b': 'locked' });
+ // No re-dispatch of frame B!
+ expect(jobs.filter(j => j.params.musicVideo.sceneId === 'mvs-b' && j.kind === 'image')).toHaveLength(1);
+
+ // Now both frames are filled, production proceeds to clip dispatch (no re-dispatch loop)!
+ expect(jobs.length).toBeGreaterThanOrEqual(3);
+ expect(jobs.some(j => j.kind === 'video')).toBe(true);
+});
diff --git a/server/services/musicVideo/projects.test.js b/server/services/musicVideo/projects.test.js
index ef1e0f03a3..cf8a665565 100644
--- a/server/services/musicVideo/projects.test.js
+++ b/server/services/musicVideo/projects.test.js
@@ -291,18 +291,33 @@ describe('automation respects persisted shot locks (#11218)', () => {
it('checks fresh locks when an asynchronous repair lands and preserves generated clip output', async () => {
const { setShotLocks, shotLocks } = await import('./productionReview.js');
- const p = await projects.createProject({ name: 'Repair race' });
- const scene = await projects.addProjectScene(p.id, { startSec: 0, endSec: 2, prompt: 'Approved input' });
- await projects.mutateProjectRecord(p.id, current => ({ project: setShotLocks(current, { sceneIds: [scene.sceneId], locked: true }) }));
- const repair = await projects.mutateProjectRecord(p.id, current => ({ project: { ...current, scenes: current.scenes.map(s => ({ ...s, clipFixes: { text: 'New motion' } })) } }), { source: 'orchestrator' });
- expect(repair.project.scenes[0].clipFixes).toBeUndefined();
- const frame = await projects.appendSceneTakes(p.id, scene.sceneId, [{ kind: 'image', assetId: 'candidate.png', source: 'generated' }]);
- expect(frame.scene.referenceImageId).toBeNull();
- expect(frame.scene.takes.some(take => take.assetId === 'candidate.png')).toBe(true);
- expect(shotLocks(await projects.getProject(p.id))[scene.sceneId]).toBe('locked');
- const clip = await projects.mutateProjectRecord(p.id, current => ({ project: { ...current, scenes: current.scenes.map(s => ({ ...s, videoHistoryId: 'new-clip' })) } }), { source: 'production-run' });
- expect(clip.project.scenes[0].videoHistoryId).toBe('new-clip');
- expect(shotLocks(clip.project)[scene.sceneId]).toBe('locked');
+ const { PATHS } = await import('../../lib/paths.js');
+ const { writeFileSync, unlinkSync, mkdirSync } = await import('fs');
+ const { join } = await import('path');
+ mkdirSync(PATHS.images, { recursive: true });
+ writeFileSync(join(PATHS.images, 'candidate.png'), 'png');
+ writeFileSync(join(PATHS.images, 'candidate-2.png'), 'png');
+ try {
+ const p = await projects.createProject({ name: 'Repair race' });
+ const scene = await projects.addProjectScene(p.id, { startSec: 0, endSec: 2, prompt: 'Approved input' });
+ await projects.mutateProjectRecord(p.id, current => ({ project: setShotLocks(current, { sceneIds: [scene.sceneId], locked: true }) }));
+ const repair = await projects.mutateProjectRecord(p.id, current => ({ project: { ...current, scenes: current.scenes.map(s => ({ ...s, clipFixes: { text: 'New motion' } })) } }), { source: 'orchestrator' });
+ expect(repair.project.scenes[0].clipFixes).toBeUndefined();
+ const frame = await projects.appendSceneTakes(p.id, scene.sceneId, [{ kind: 'image', assetId: 'candidate.png', source: 'generated' }]);
+ expect(frame.scene.referenceImageId).toBe('candidate.png');
+ expect(frame.scene.takes.some(take => take.assetId === 'candidate.png')).toBe(true);
+ expect(shotLocks(await projects.getProject(p.id))[scene.sceneId]).toBe('locked');
+ const frame2 = await projects.appendSceneTakes(p.id, scene.sceneId, [{ kind: 'image', assetId: 'candidate-2.png', source: 'generated' }]);
+ expect(frame2.scene.referenceImageId).toBe('candidate.png');
+ expect(frame2.scene.takes.some(take => take.assetId === 'candidate-2.png')).toBe(true);
+ expect(shotLocks(await projects.getProject(p.id))[scene.sceneId]).toBe('locked');
+ const clip = await projects.mutateProjectRecord(p.id, current => ({ project: { ...current, scenes: current.scenes.map(s => ({ ...s, videoHistoryId: 'new-clip' })) } }), { source: 'production-run' });
+ expect(clip.project.scenes[0].videoHistoryId).toBe('new-clip');
+ expect(shotLocks(clip.project)[scene.sceneId]).toBe('locked');
+ } finally {
+ try { unlinkSync(join(PATHS.images, 'candidate.png')); } catch {}
+ try { unlinkSync(join(PATHS.images, 'candidate-2.png')); } catch {}
+ }
});
});