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

31.0 KB
Raw Blame
/**
 * Music Video selective section revision (#8987), through the real router,
 * revisionService.js, excerptRender.js and the real file-backed project store.
 * Only the process boundaries are doubled: the ffmpeg child (a fake emitter
 * the test finishes), the render prep that needs a real ffmpeg + song, and the
 * media-job queue — whose `enqueueJob` is the PAID generation sink, asserted
 * never to be reached, and whose `listJobs` feeds the in-flight check.
 */

import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
import express from 'express';
import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
import { join } from 'path';
import { request } from '../lib/testHelper.js';
import { errorMiddleware } from '../lib/errorHandler.js';
import { makePathsProxy, lazyTempDataRoot, cleanupTempDataRoots } from '../lib/mockPathsDataRoot.js';

const ROOT = () => lazyTempDataRoot('mv-revision-route-test-');
vi.mock('../lib/paths.js', async (importOriginal) => makePathsProxy(await importOriginal(), { dataRoot: ROOT }));

const h = vi.hoisted(() => {
  const procs = [];
  const makeEmitter = () => {
    const listeners = {};
    return {
      on(ev, fn) { (listeners[ev] ||= []).push(fn); return this; },
      emit(ev, ...args) { for (const fn of listeners[ev] || []) fn(...args); },
    };
  };
  const spawn = (_cmd, args) => {
    const p = makeEmitter();
    p.args = args;
    p.stderr = makeEmitter();
    p.kill = () => {};
    procs.push(p);
    return p;
  };
  return { procs, spawn, jobs: [], enqueueJob: vi.fn(), cancelJob: vi.fn(async () => {}) };
});

vi.mock('../lib/childProcess.js', async (importOriginal) => ({ ...(await importOriginal()), spawn: h.spawn }));
vi.mock('../services/musicVideo/performanceShot.js', () => ({ assertCurrentPerformanceTakes: vi.fn(async () => {}) }));
vi.mock('../services/videoGen/local.js', () => ({ loadHistory: vi.fn(async () => []), getHistoryItem: vi.fn(async () => ({ filename: 'accepted.mp4', fps: 24 })) }));
vi.mock('../lib/ffmpeg.js', async (original) => ({ ...(await original()), findFfmpeg: vi.fn(async () => 'ffmpeg'),
  runFfmpegProcess: vi.fn(async ({ args }) => { writeFileSync(args.at(-1), 'synthetic-boundary-frame'); return { ok: true }; }),
}));
vi.mock('../lib/sseUtils.js', () => ({ broadcastSse: vi.fn(), attachSseClient: vi.fn(() => true), closeJobAfterDelay: vi.fn() }));
// The draft render stamps this install's id on its in-flight mark (#9010).
vi.mock('../services/instanceIdentity.js', () => ({ ensureInstanceId: vi.fn(async () => 'inst-test') }));
vi.mock('../lib/killWithEscalation.js', () => ({ killWithEscalation: vi.fn((proc) => proc.emit('close', null, 'SIGTERM')) }));
vi.mock('../services/htmlComposition/encode.js', () => ({ encodeFileContactSheetAtTimes: vi.fn(async () => {}) }));
vi.mock('../services/mediaJobQueue/index.js', () => ({
  listJobs: vi.fn(({ kind } = {}) => h.jobs.filter((j) => !kind || j.kind === kind)),
  enqueueJob: h.enqueueJob,
  cancelJob: h.cancelJob,
}));
// Three 10s sections: footage s1, footage s2, still s3 (a composed render).
const CLIPS = [
  { sceneId: 's1', videoPath: '/v/a.mp4', width: 640, height: 360, fps: 24, inSec: 0, outSec: 10, duration: 10, sourceSec: 10, loop: true },
  { sceneId: 's2', videoPath: '/v/b.mp4', width: 640, height: 360, fps: 24, inSec: 0, outSec: 10, duration: 10, sourceSec: 10, loop: true },
  { sceneId: 's3', layer: 'still', imagePath: '/i/c.png', move: 'hold', inSec: 0, outSec: 10, duration: 10, sourceSec: 10 },
];
vi.mock('../services/musicVideo/render.js', async (importOriginal) => ({
  ...(await importOriginal()),
  resolveMasterAudioPath: vi.fn(async () => '/example/song.wav'),
  planMusicVideoRender: vi.fn(async () => ({ ffmpeg: 'ffmpeg', audioPath: '/a/song.wav', composed: true, clips: CLIPS, audioDurationSec: 30 })),
}));

const { default: musicVideoRoutes } = await import('./musicVideo.js');
const projects = await import('../services/musicVideo/projects.js');
const { recoverStuckMusicVideoExcerpts } = await import('../services/musicVideo/excerptRender.js');
const { captureMusicVideoEvidence } = await import('../lib/musicVideoDependencies.js');
const { assertRevisionOpen, assertPerformanceRepairDispatch } = await import('../services/musicVideo/revisionService.js');

const app = express();
app.use(express.json());
app.use('/api/music-video', musicVideoRoutes);
app.use(errorMiddleware);

const base = (id) => `/api/music-video/${id}`;
const tick = () => new Promise((r) => setTimeout(r, 0));
const lastProc = () => h.procs[h.procs.length - 1];
const settle = async () => { for (let i = 0; i < 5; i += 1) await tick(); };
// The ffmpeg `close` handler settles the render through several awaited store
// writes; a fixed tick count races them under full-suite CPU load (#9017), so
// assertions on the post-close record poll until it converges instead.
const settledProject = (projectId, check) => vi.waitFor(async () => {
  const project = await projects.getProject(projectId);
  check(project);
  return project;
}, { timeout: 5000, interval: 20 });

beforeEach(() => {
  rmSync(join(ROOT(), 'music-video-projects.json'), { force: true });
  mkdirSync(join(ROOT(), 'images'), { recursive: true });
  for (const file of ['f1.png', 'f2.png', 'still-3.png', 'frame.png']) writeFileSync(join(ROOT(), 'images', file), 'synthetic still');
  writeFileSync(join(ROOT(), 'video-history.json'), JSON.stringify(
    ['clip-1', 'clip-2', 'clip-2b', 'another-take', 'accepted'].map(id => ({ id, filename: `${id}.mp4` })),
  ));
  h.procs.length = 0;
  h.jobs.length = 0;
  vi.clearAllMocks();
});
afterAll(cleanupTempDataRoots);

const scene = (sceneId, order, media) => ({ sceneId, order, prompt: `shot ${sceneId}`, takes: [], ...media });

// A reviewed draft of [5, 25): s1 [5,10), s2 [10,20), s3 [20,25). One flagged
// note lands in s2 (excerpt time 8 → song time 13), one approval in s1.
async function reviewedProject(noteOverrides = []) {
  const project = await projects.createProject({ name: 'Example Video' });
  return projects.updateProject(project.id, {
    scenes: [
      scene('s1', 0, { referenceImageId: 'f1.png', videoHistoryId: 'clip-1' }),
      scene('s2', 1, { referenceImageId: 'f2.png', videoHistoryId: 'clip-2' }),
      scene('s3', 2, { referenceImageId: 'still-3.png', visualLayer: 'still' }),
    ],
    excerpts: [{
      id: 'mve-draft', startSec: 5, endSec: 25, status: 'complete', jobId: null,
      filename: 'music-video-excerpt-draft.mp4', contactSheetFilename: null, partialFilename: null, error: null,
      sections: [
        { sceneId: 's1', layer: 'footage', startSec: 5, endSec: 10 },
        { sceneId: 's2', layer: 'footage', startSec: 10, endSec: 20 },
        { sceneId: 's3', layer: 'still', startSec: 20, endSec: 25 },
      ],
      notes: [
        { id: 'mvn-bad', atSec: 8, note: 'the camera jitters', verdict: 'flagged' },
        { id: 'mvn-good', atSec: 1, note: 'great open', verdict: 'approved' },
        ...noteOverrides,
      ],
      createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-01-01T00:00:00.000Z',
    }],
  });
}

// What the scene-video completion hook does when a regenerated clip lands.
const landNewTake = (projectId, sceneId, assetId) =>
  projects.appendSceneTakes(projectId, sceneId, [{ kind: 'video', assetId, source: 'generated', provider: 'portos', jobId: `job-${assetId}` }]);

describe('selective section revision (#8987)', () => {
  it('rejects only the flagged section and leaves every approved section untouched', async () => {
    const project = await reviewedProject();
    const r = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
    expect(r.status).toBe(201);
    const { revision } = r.body;
    expect(revision.sections.map((s) => [s.sceneId, s.verdict])).toEqual([['s1', 'approved'], ['s2', 'rejected'], ['s3', 'approved']]);
    expect(revision.sections[1]).toMatchObject({ kind: 'video', rejectedAssetId: 'clip-2', noteIds: ['mvn-bad'] });

    const reloaded = await projects.getProject(project.id);
    const [s1, s2, s3] = reloaded.scenes;
    expect(s2.videoHistoryId).toBeNull(); // the rejected clip no longer fills the slot
    expect(s2.referenceImageId).toBe('f2.png'); // its reference frame is kept for the regeneration
    expect(s2.takes.find((t) => t.assetId === 'clip-2').status).toBe('rejected');
    // Approved sections: byte-identical to before the revision.
    expect(s1).toEqual(project.scenes[0]);
    expect(s3).toEqual(project.scenes[2]);
  });

  it('resumes to generate only the rejected section, and never hands a section out twice', async () => {
    const project = await reviewedProject();
    const { body: { revision } } = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});

    // Two overlapping resumes (two tabs, a double submit): exactly one hands
    // s2 out for generation; the other sees it claimed.
    const [a, b] = await Promise.all([
      request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`),
      request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`),
    ]);
    expect([a.status, b.status]).toEqual([200, 200]);
    expect([a.body.needsGeneration, b.body.needsGeneration]).toContainEqual([{ sceneId: 's2', kind: 'video' }]);
    expect([a.body.needsGeneration, b.body.needsGeneration]).toContainEqual([]);
    expect(a.body.render).toBeNull();
    expect(b.body.render).toBeNull();
    expect(h.procs).toHaveLength(0); // nothing renders until every rejected section has a take
    expect(h.enqueueJob).not.toHaveBeenCalled();
  });

  it('re-offers a claimed section only once its lease lapses with no job in the queue', async () => {
    vi.useFakeTimers({ toFake: ['Date'] });
    try {
      const project = await reviewedProject();
      const { body: { revision } } = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
      await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);

      // The board submitted s2; while its job is live, a resume long after the
      // lease (e.g. after a restart) still asks for nothing new.
      vi.setSystemTime(Date.now() + 10 * 60_000);
      h.jobs.push({ id: 'job-live', kind: 'video', status: 'running', queuedAt: new Date().toISOString(), params: { musicVideo: { projectId: project.id, sceneId: 's2' } } });
      const live = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
      expect(live.body.needsGeneration).toEqual([]);
      expect(live.body.generating).toEqual([{ sceneId: 's2', kind: 'video' }]);

      // That job failed and produced nothing: s2 is offered again.
      h.jobs[0].status = 'failed';
      const failed = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
      expect(failed.body.needsGeneration).toEqual([{ sceneId: 's2', kind: 'video' }]);
    } finally {
      vi.useRealTimers();
    }
  });

  it('retries a failed render without re-submitting any generation, then completes', async () => {
    const project = await reviewedProject();
    const { body: { revision } } = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
    await landNewTake(project.id, 's2', 'clip-2b');

    const renderStart = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
    expect(renderStart.status).toBe(200);
    expect(renderStart.body.needsGeneration).toEqual([]);
    expect(renderStart.body.render.excerptId).toMatch(/^mve-/);
    expect(renderStart.body.revision.status).toBe('rendering');
    // The draft re-renders the same window through the same clips.
    const firstRender = renderStart.body.render.excerptId;
    const proc = lastProc();
    proc.emit('spawn');
    proc.emit('close', 1, null); // ffmpeg fails

    let reloaded = await settledProject(project.id, (p) => {
      expect(p.revisions[0]).toMatchObject({ status: 'open', renderAttempts: 1 });
      expect(p.excerpts.find((e) => e.id === firstRender)).toMatchObject({ status: 'error', partialFilename: null });
    });

    // Retry: s2 already holds its new take, so the retry renders straight away.
    const retry = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
    expect(retry.body.needsGeneration).toEqual([]);
    expect(retry.body.generating).toEqual([]);
    expect(h.procs).toHaveLength(2);
    lastProc().emit('spawn');
    lastProc().emit('close', 0, null);

    reloaded = await settledProject(project.id, (p) => {
      expect(p.revisions[0]).toMatchObject({ status: 'complete', renderAttempts: 2 });
    });
    expect(reloaded.scenes[1].videoHistoryId).toBe('clip-2b');
    expect(reloaded.scenes[0].videoHistoryId).toBe('clip-1'); // approved section still untouched
    expect(h.enqueueJob).not.toHaveBeenCalled(); // zero paid (re)submissions across the retry
  });

  it('after a restart mid-draft, deletes the partial output and resumes from the checkpoint', async () => {
    const project = await reviewedProject();
    const { body: { revision } } = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
    await landNewTake(project.id, 's2', 'clip-2b');
    // The record exactly as a process killed mid-encode left it: the draft
    // re-render still 'rendering' with its partial file on disk, the revision
    // 'rendering' — and (being a fresh process) no live job for either.
    const partial = 'music-video-excerpt-crashed.mp4';
    mkdirSync(join(ROOT(), 'videos'), { recursive: true });
    writeFileSync(join(ROOT(), 'videos', partial), 'half-an-mp4');
    await projects.mutateProjectRecord(project.id, (current) => ({
      project: {
        ...current,
        excerpts: [...current.excerpts, { id: 'mve-crashed', startSec: 5, endSec: 25, status: 'rendering', jobId: 'mve-crashed', filename: null, contactSheetFilename: null, partialFilename: partial, sections: null, error: null, notes: [] }],
        revisions: current.revisions.map((r) => ({ ...r, status: 'rendering', renderExcerptId: 'mve-crashed', renderAttempts: 1 })),
      },
    }));

    await recoverStuckMusicVideoExcerpts();

    expect(existsSync(join(ROOT(), 'videos', partial))).toBe(false);
    let reloaded = await projects.getProject(project.id);
    expect(reloaded.excerpts.find((e) => e.id === 'mve-crashed')).toMatchObject({ status: 'error', partialFilename: null });
    expect(reloaded.revisions[0]).toMatchObject({ status: 'open', error: expect.stringMatching(/restart/) });

    const resumed = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
    expect(resumed.body.needsGeneration).toEqual([]);
    expect(resumed.body.render).toBeTruthy();
    reloaded = await projects.getProject(project.id);
    expect(reloaded.revisions[0]).toMatchObject({ status: 'rendering', renderAttempts: 2 });
    expect(h.enqueueJob).not.toHaveBeenCalled();
    lastProc().emit('spawn');
    lastProc().emit('close', 0, null);
    await settle();
  });

  it('cancels a rendering revision, stopping its draft render and removing the partial output', async () => {
    const project = await reviewedProject();
    const { body: { revision } } = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
    await landNewTake(project.id, 's2', 'clip-2b');
    const { body: { render } } = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
    lastProc().emit('spawn');

    const canceled = await request(app).post(`${base(project.id)}/revisions/${revision.id}/cancel`);
    expect(canceled.status).toBe(200);
    expect(canceled.body.revision.status).toBe('canceled');

    const reloaded = await settledProject(project.id, (p) => {
      expect(p.excerpts.find((e) => e.id === render.excerptId)).toMatchObject({ status: 'canceled', partialFilename: null });
    });
    expect(reloaded.revisions[0].status).toBe('canceled'); // the render's own cancel doesn't reopen it
    const resume = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
    expect(resume.status).toBe(409);
  });

  it('cancelling an open revision stops the generation it started, and only that', async () => {
    const project = await reviewedProject();
    const earlier = new Date(Date.now() - 60_000).toISOString();
    const { body: { revision } } = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
    const tag = (sceneId) => ({ musicVideo: { projectId: project.id, sceneId } });
    const now = new Date().toISOString();
    h.jobs.push(
      { id: 'job-s2', kind: 'video', status: 'running', queuedAt: now, params: tag('s2') },
      { id: 'job-s1', kind: 'video', status: 'queued', queuedAt: now, params: tag('s1') }, // an approved section: not the revision's
      { id: 'job-old', kind: 'video', status: 'running', queuedAt: earlier, params: tag('s2') }, // predates the revision
    );
    const r = await request(app).post(`${base(project.id)}/revisions/${revision.id}/cancel`);
    expect(r.status).toBe(200);
    expect(r.body.canceledJobIds).toEqual(['job-s2']);
    expect(h.cancelJob).toHaveBeenCalledTimes(1);
  });

  it('cancelling an open revision leaves a same-scene job tagged for a different revision running (#9011)', async () => {
    const project = await reviewedProject();
    const { body: { revision } } = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
    const now = new Date().toISOString();
    h.jobs.push(
      { id: 'job-this-revision', kind: 'video', status: 'running', queuedAt: now, params: { musicVideo: { projectId: project.id, sceneId: 's2', revisionId: revision.id } } },
      // A hand-started board render tagged with a DIFFERENT (e.g. superseded) revision for the
      // same scene: cancelling THIS revision must never touch it, exact revisionId match or not.
      { id: 'job-other-revision', kind: 'video', status: 'running', queuedAt: now, params: { musicVideo: { projectId: project.id, sceneId: 's2', revisionId: 'mvr-some-other-revision' } } },
    );
    const r = await request(app).post(`${base(project.id)}/revisions/${revision.id}/cancel`);
    expect(r.status).toBe(200);
    expect(r.body.canceledJobIds).toEqual(['job-this-revision']);
    expect(h.cancelJob).toHaveBeenCalledTimes(1);
  });

  it('release clears a claimed section so the very next resume hands it out again immediately (#9011)', async () => {
    const project = await reviewedProject();
    const { body: { revision } } = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
    const first = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
    expect(first.body.needsGeneration).toEqual([{ sceneId: 's2', kind: 'video' }]);

    // A resume right away sees s2 claimed — nothing left to hand out, since the
    // kickoff is presumed already on its way to the queue.
    const claimed = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
    expect(claimed.body.needsGeneration).toEqual([]);
    expect(claimed.body.generating).toEqual([{ sceneId: 's2', kind: 'video' }]);

    // The kickoff never reached the queue (e.g. a network error): release the
    // claim, and the very next resume offers s2 again without waiting out the lease.
    const released = await request(app).post(`${base(project.id)}/revisions/${revision.id}/release`).send({ sceneId: 's2' });
    expect(released.status).toBe(200);
    const again = await request(app).post(`${base(project.id)}/revisions/${revision.id}/resume`);
    expect(again.body.needsGeneration).toEqual([{ sceneId: 's2', kind: 'video' }]);
  });

  it('refuses a generation kickoff tagged for a revision that is no longer open (#9011)', async () => {
    const project = await reviewedProject();
    const { body: { revision } } = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
    await expect(assertRevisionOpen(project.id, revision.id)).resolves.toBeUndefined();
    await expect(assertRevisionOpen(project.id, undefined)).resolves.toBeUndefined(); // no tag → no-op

    await request(app).post(`${base(project.id)}/revisions/${revision.id}/cancel`);
    await expect(assertRevisionOpen(project.id, revision.id)).rejects.toMatchObject({ status: 409, code: 'REVISION_CLOSED' });
  });

  it('enforces code-first video share and a concurrent policy edit at the revision submission boundary', async () => {
    const created = await projects.createProject({ name: 'Example Video' });
    await projects.mutateProjectRecord(created.id, (current) => ({ project: {
      ...current,
      productionPolicy: { strategy: 'code-first', maxGeneratedVideoPercent: 0 },
      audioAnalysis: { durationSec: 100 },
      scenes: [{ sceneId: 'selected', startSec: 0, endSec: 20 }],
      treatment: { shotDirections: [{ sceneId: 'selected', medium: 'generated-footage', mediumRationale: 'Selected payoff.' }] },
      excerpts: [{ id: 'mve-code', status: 'complete', startSec: 0, endSec: 20,
        sections: [{ sceneId: 'selected', startSec: 0, endSec: 20 }] }],
    } }));
    const path = `${base(created.id)}/excerpt/mve-code/revisions`;
    const forbidden = await request(app).post(path).send({ sceneIds: ['selected'] });
    expect(forbidden.status).toBe(409);
    expect(forbidden.body.code).toBe('REVISION_MEDIUM_PLAN_CONFLICT');
    expect(h.enqueueJob).not.toHaveBeenCalled();

    await projects.mutateProjectRecord(created.id, (current) => ({ project: {
      ...current, productionPolicy: { strategy: 'code-first', maxGeneratedVideoPercent: 20 },
    } }));
    const allowed = await request(app).post(path).send({ sceneIds: ['selected'] });
    expect(allowed.status).toBe(201);
    const revisionId = allowed.body.revision.id;
    await projects.mutateProjectRecord(created.id, (current) => ({ project: {
      ...current, productionPolicy: { strategy: 'code-first', maxGeneratedVideoPercent: 0 },
    } }));
    await expect(assertRevisionOpen(created.id, revisionId, { sceneId: 'selected', kind: 'video' }))
      .rejects.toMatchObject({ code: 'REVISION_MEDIUM_PLAN_CHANGED' });
    expect(h.enqueueJob).not.toHaveBeenCalled();
  });

  it('refuses a second open revision, a section outside the draft, and a draft without a section map', async () => {
    const project = await reviewedProject();
    const first = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({ sceneIds: ['s1'] });
    expect(first.status).toBe(201);
    const second = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({});
    expect(second.status).toBe(409);
    expect(second.body.code).toBe('REVISION_IN_PROGRESS');
    // Every refusal names the blocking revision so the board can link to it (#9940).
    expect(second.body.context).toEqual({ revisionId: first.body.revision.id });
    const repair = await request(app).post(`${base(project.id)}/dependency-repairs`).send({ basis: 'basis-example' });
    expect(repair.status).toBe(409);
    expect(repair.body.code).toBe('REVISION_IN_PROGRESS');
    expect(repair.body.context).toEqual({ revisionId: first.body.revision.id });

    const outside = await request(app).post(`${base(project.id)}/revisions/${first.body.revision.id}/cancel`);
    expect(outside.status).toBe(200);
    const notInDraft = await request(app).post(`${base(project.id)}/excerpt/mve-draft/revisions`).send({ sceneIds: ['s9'] });
    expect(notInDraft.status).toBe(422);

    const legacy = await projects.createProject({ name: 'Legacy' });
    await projects.updateProject(legacy.id, {
      excerpts: [{ id: 'mve-old', startSec: 0, endSec: 5, status: 'complete', notes: [{ id: 'n', atSec: 1, note: 'x', verdict: 'flagged' }] }],
    });
    const noMap = await request(app).post(`${base(legacy.id)}/excerpt/mve-old/revisions`).send({});
    expect(noMap.status).toBe(422);
    expect(noMap.body.code).toBe('EXCERPT_SECTIONS_UNKNOWN');
  });
});

// This regression uniquely pins accepted-prefix persistence and a durable paid
// submission reservation through the real HTTP revision boundary and store.
async function performanceProject() {
  const created = await projects.createProject({ name: 'Example Performance' });
  const instruction = { shotMode: 'performance', songInterval: { startSec: 10, endSec: 24 },
    audio: { songDurationSec: 30 }, audioWindow: { startSec: 10, endSec: 24, durationSec: 14 },
    edit: { inSec: 0, outSec: 14, targetSec: 14 },
    cues: [{ startSec: 0, endSec: 14, words: [{ text: 'one', startSec: 0, endSec: 3.8 }, { text: 'two', startSec: 4.2, endSec: 14 }] }] };
  mkdirSync(join(ROOT(), 'videos'), { recursive: true });
  writeFileSync(join(ROOT(), 'videos', 'accepted.mp4'), 'synthetic-source');
  await projects.updateProject(created.id, {
    videoSettings: { backend: 'fal' },
    scenes: [{ sceneId: 'performance', order: 0, shotMode: 'performance', startSec: 10, endSec: 24,
      referenceImageId: 'frame.png', videoHistoryId: 'accepted', takes: [{ takeId: 'take-original', kind: 'video', assetId: 'accepted', shotInstruction: instruction }] }],
    excerpts: [{ id: 'mve-performance', startSec: 8, endSec: 24, status: 'complete',
      sections: [{ sceneId: 'performance', layer: 'footage', startSec: 10, endSec: 24, performance: { takeId: 'accepted' } }], notes: [] }],
    autoReviews: [{ id: 'review-example', status: 'needs-human', attempts: [{ excerptId: 'mve-performance', review: {
      evidence: { excerptStartSec: 8, temporal: { status: 'verified', analyzer: { id: 'synthetic', version: '1' },
        shots: [{ sceneId: 'performance', takeId: 'accepted', spans: [
          { startSec: 2, endSec: 6, status: 'verified', offsetSec: 0.01, confidence: 0.95 },
          { startSec: 6, endSec: 16, status: 'verified', offsetSec: 0.3, confidence: 0.95 },
        ] }] } } } }] }],
  });
  const current = await projects.getProject(created.id);
  const dependencies = captureMusicVideoEvidence(current, { startSec: 8, endSec: 24 });
  // Persist provenance without the derived read projection, as older rows do.
  await projects.updateProject(created.id, {
    excerpts: current.excerpts.map(({ dependencyState, ...excerpt }) => ({ ...excerpt, dependencies })),
    autoReviews: current.autoReviews.map((r) => ({ ...r, attempts: r.attempts.map((a) => ({ ...a, review: { ...a.review, dependencies } })) })),
  });
  return projects.getProject(created.id);
}
const repairInput = { excerptId: 'mve-performance', sourceAssetId: 'accepted', boundarySec: 14 };
describe('accepted-prefix performance repair (#9348)', () => {
  it('persists only a suffix revision, preserves draft provenance, and never pays twice after a restart or cancellation', async () => {
    const project = await performanceProject();
    const path = `${base(project.id)}/scenes/performance/performance-repair`;
    const [a, b] = await Promise.all([request(app).post(path).send(repairInput), request(app).post(path).send(repairInput)]);
    expect([a.status, b.status].sort()).toEqual([201, 409]);
    const repaired = (a.status === 201 ? a : b).body;
    const [prefix, suffix] = repaired.project.scenes;
    expect(prefix).toMatchObject({ videoHistoryId: 'accepted', startSec: 10, endSec: 14 });
    expect(prefix.takes[0].shotInstruction.edit).toEqual({ inSec: 0, outSec: 4, targetSec: 4 });
    // The historical draft/provenance stays immutable; its new stale projection
    // correctly reflects the composition split added by this repair.
    const withoutState = (excerpt) => { const { dependencyState, ...stored } = excerpt; return stored; };
    expect(repaired.project.excerpts.map(withoutState)).toEqual(project.excerpts.map(withoutState));
    expect(repaired.project.excerpts[0].dependencyState.status).toBe('stale');
    expect(repaired.revision.repair).toMatchObject({ originalTake: project.scenes[0].takes[0], generations: 0, maxGenerations: 1 });
    const revisionId = repaired.revision.id;
    const resumed = await request(app).post(`${base(project.id)}/revisions/${revisionId}/resume`);
    expect(resumed.body.needsGeneration).toEqual([{ sceneId: suffix.sceneId, kind: 'video' }]);
    const guard = () => assertRevisionOpen(project.id, revisionId, { sceneId: suffix.sceneId, kind: 'video' });
    const results = await Promise.allSettled([guard(), guard()]);
    expect(results.map((r) => r.status).sort()).toEqual(['fulfilled', 'rejected']);
    expect(results.find((r) => r.status === 'rejected').reason.code).toBe('PERFORMANCE_REPAIR_SPEND_LIMIT');
    // As on a restart, the queue knows no job, but the durable reservation
    // survives. Even lease expiry must not create another paid request.
    await projects.mutateProjectRecord(project.id, (current) => ({ project: { ...current,
      revisions: current.revisions.map((r) => ({ ...r, sections: r.sections.map((section) => ({ ...section, claimedAt: null })) })),
    } }));
    const restart = await request(app).post(`${base(project.id)}/revisions/${revisionId}/resume`);
    expect(restart.body.needsGeneration).toEqual([]);
    expect(restart.body.render).toBeNull();
    expect(restart.body.revision.sections.find((s) => s.sceneId === suffix.sceneId).state).toBe('review-needed');
    await request(app).post(`${base(project.id)}/revisions/${revisionId}/cancel`);
    await expect(guard()).rejects.toMatchObject({ code: 'REVISION_CLOSED' });
    await expect(assertPerformanceRepairDispatch({ projectId: project.id, revisionId, sceneId: suffix.sceneId })).rejects.toMatchObject({ code: 'REVISION_CLOSED' });
    expect(h.enqueueJob).not.toHaveBeenCalled();
  });

  it('refuses inconclusive evidence, stale boundaries/dependencies, and attempts to bypass an existing run budget without changing the scene', async () => {
    const project = await performanceProject();
    const path = `${base(project.id)}/scenes/performance/performance-repair`;
    const stale = await request(app).post(path).send({ ...repairInput, boundarySec: 14.1 });
    expect(stale.status).toBe(409);
    await projects.mutateProjectRecord(project.id, (current) => ({ project: { ...current, autoReviews: current.autoReviews.map((r) => ({ ...r, status: 'limit-reached' })) } }));
    expect((await request(app).post(path).send(repairInput)).status).toBe(409);
    await projects.mutateProjectRecord(project.id, (current) => ({ project: { ...current, autoReviews: current.autoReviews.map((r) => ({ ...r, status: 'needs-human', attempts: r.attempts.map((a) => ({ ...a,
      review: { ...a.review, evidence: { ...a.review.evidence, temporal: { ...a.review.evidence.temporal, status: 'unverified' } } },
    })) })) } }));
    expect((await request(app).post(path).send(repairInput)).status).toBe(409);
    expect((await projects.getProject(project.id)).scenes).toEqual(project.scenes);
    const changed = await projects.mutateProjectRecord(project.id, (current) => ({ project: { ...current,
      scenes: current.scenes.map((scene) => ({ ...scene, loop: true })),
      autoReviews: current.autoReviews.map((r) => ({ ...r, attempts: r.attempts.map((a) => ({ ...a,
        review: { ...a.review, evidence: { ...a.review.evidence, temporal: { ...a.review.evidence.temporal, status: 'verified' } } },
      })) })),
    } }));
    const staleDependencies = await request(app).post(path).send(repairInput);
    expect(staleDependencies.status).toBe(409);
    expect(staleDependencies.body.error).toContain('dependencies changed');
    expect((await projects.getProject(project.id)).scenes).toEqual(changed.project.scenes);
    expect(h.enqueueJob).not.toHaveBeenCalled();
  });
});