videoclaw 3.0.0-alpha.1

package/dist/cli/handlers/create.js

@@ -0,0 +1,635 @@
+/**
+ * `video create` command handler for `vclaw` (plus its auto/iterate/
+ * run-pipeline wrappers).
+ *
+ * Extracted verbatim from the monolithic `vclaw.ts`: the one-shot
+ * intent -> brief -> storyboard -> story-bible -> seed-assets pipeline,
+ * incl. create-time cast hydration (--gb-character /
+ * --import-library-characters / --auto-create-characters), director-mode
+ * genre defaults, the director review + preflight + cost-estimate +
+ * handoff block, and optional --execute. Helpers stay module-private.
+ * Dispatch stays in `vclaw.ts`.
+ */
+import { VclawError } from '../../video/errors.js';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { artifactPathFor, writeArtifact } from '../../video/artifact-store.js';
+import { appendProjectEvent } from '../../video/events.js';
+import { addCharacterProfile } from '../../video/characters.js';
+import { autoFixDirectorStoryboardContent, runDirectorPreflight } from '../../video/director-preflight.js';
+import { getBuiltinPipelineManifest } from '../../video/pipeline-manifest.js';
+import { writeStageCheckpoint } from '../../video/checkpoints.js';
+import { writeStoryboardMarkdownReview } from '../../video/storyboard-markdown.js';
+import { writeStoryBibleForProject } from '../../video/story-bible.js';
+import { parseFlagValue, parseProjectSlugFlag, parseRepeatableFlag, slugifyProject, shellQuote, parseExecutionProfileFlags, applyPlatformExecutionProfileDefaults, buildBriefEventPayload } from '../args.js';
+import { findLibraryCharactersByIntent } from '../../video/library-clean.js';
+import { appendVideoContextChangelog } from '../../video/video-context.js';
+import { buildExecutionPlan } from '../../video/execution-plan.js';
+import { scaffoldExecutionSeedAssetsFromStoryboard } from '../../video/execution-seed.js';
+import { executeProject } from '../../video/execute.js';
+import { parseClipDurationSeconds, resolveDirectorCreateDefaults } from '../../video/director-defaults.js';
+import { buildProjectCostEstimate } from '../../video/cost-estimate.js';
+import { autoCreateCharacters } from '../../video/character-auto-create.js';
+import { ensureProjectWorkspace, readProjectManifest, updateProjectManifestState, writeProjectManifest } from '../../video/workspace.js';
+import { createBriefArtifact, createStoryboardArtifact } from '../../video/artifacts.js';
+function deriveCreateTitle(intent) {
+    const normalized = intent
+        .trim()
+        .replace(/\s+/g, ' ')
+        .replace(/^["']|["']$/g, '');
+    if (!normalized)
+        return 'Untitled Video';
+    if (normalized.length <= 72)
+        return normalized;
+    return `${normalized.slice(0, 69).trimEnd()}...`;
+}
+function deriveCreateSlug(args, intent) {
+    const explicit = parseProjectSlugFlag(args) ?? parseFlagValue(args, '--slug');
+    if (explicit)
+        return explicit;
+    const title = parseFlagValue(args, '--title') ?? deriveCreateTitle(intent);
+    const slug = slugifyProject(title);
+    if (!slug) {
+        throw new Error('Could not derive a project slug from the create intent. Pass --project <slug>.');
+    }
+    return slug;
+}
+async function ensureProjectInitialized(slug, root, mode) {
+    const workspace = await ensureProjectWorkspace(slug, root);
+    const existingManifest = await readProjectManifest(workspace);
+    if (!existingManifest) {
+        const pipeline = getBuiltinPipelineManifest(mode);
+        const now = new Date().toISOString();
+        await writeProjectManifest(workspace, {
+            slug,
+            productionMode: mode,
+            createdAt: now,
+            updatedAt: now,
+            pipeline,
+            currentStage: 'brief',
+            lastCompletedStage: null,
+            lastCheckpointStatus: 'pending',
+        });
+        await writeStageCheckpoint(workspace, {
+            stage: 'brief',
+            status: 'pending',
+            generatedAt: now,
+            artifacts: {},
+            summary: 'Project initialized; brief not yet created.',
+            issues: [],
+            nextAction: 'Create the brief artifact.',
+        });
+        await appendProjectEvent(workspace, {
+            type: 'project.initialized',
+            recordedAt: now,
+            payload: { productionMode: mode, pipeline: pipeline.name },
+        });
+    }
+    return workspace;
+}
+function parseGbCharacters(args) {
+    return parseRepeatableFlag(args, '--gb-character').map((value) => {
+        const separatorIndex = value.lastIndexOf(':');
+        if (separatorIndex < 0) {
+            throw new Error(`Invalid --gb-character value: "${value}". Expected Name:ID`);
+        }
+        const name = value.slice(0, separatorIndex).trim();
+        const goBananasId = Number(value.slice(separatorIndex + 1));
+        if (!name || !Number.isInteger(goBananasId) || goBananasId <= 0) {
+            throw new Error(`Invalid --gb-character value: "${value}". Expected Name:ID`);
+        }
+        return { name, goBananasId };
+    });
+}
+function mergeGbCharacters(...groups) {
+    const merged = new Map();
+    for (const group of groups) {
+        for (const entry of group) {
+            const key = entry.name.trim().toLowerCase();
+            if (!key)
+                continue;
+            merged.set(key, entry);
+        }
+    }
+    return [...merged.values()];
+}
+function buildCreateStoryboardScenes(input) {
+    const describeBeatDirective = (beatLabel) => {
+        const normalized = beatLabel.toLowerCase();
+        if (/(escape|chase|flight|departure|pursuit)/.test(normalized)) {
+            return 'Break the geography open with pursuit, route changes, and visible momentum.';
+        }
+        if (/(choice|decision|agency|commitment)/.test(normalized)) {
+            return 'Stage a decision point where risk, hesitation, and agency are visibly in tension.';
+        }
+        if (/(clash|crisis|showdown|confrontation)/.test(normalized)) {
+            return 'Intensify the conflict with a sharper visual turn, but keep the action provider-safe.';
+        }
+        if (/(resolution|ending|aftermath|return)/.test(normalized)) {
+            return 'Collapse the tension into a clear after-image that shows what changed.';
+        }
+        if (/(hook|opening|world-establish|establishing)/.test(normalized)) {
+            return 'Anchor the world quickly with an image that makes the premise legible at a glance.';
+        }
+        return 'Change the visual logic enough that the next beat feels like a new piece of story.';
+    };
+    const styleNotes = [input.style, input.colorGrading].filter(Boolean).join(' + ');
+    const actStructure = input.actStructure && input.actStructure.length > 0
+        ? input.actStructure
+        : [
+            'opening image',
+            'escalation',
+            'proof beat',
+            'payoff setup',
+            'resolution',
+        ];
+    const pickSceneCharacters = (sceneIndex) => {
+        if (input.characterNames.length <= 1)
+            return [...input.characterNames];
+        if (sceneIndex === 0 || sceneIndex === input.sceneCount - 1) {
+            return [...input.characterNames];
+        }
+        const focusIndex = (sceneIndex - 1) % input.characterNames.length;
+        const focused = input.characterNames[focusIndex];
+        const support = input.characterNames[(focusIndex + 1) % input.characterNames.length];
+        if (!focused)
+            return [...input.characterNames];
+        if (input.characterNames.length === 2) {
+            return [focused];
+        }
+        return sceneIndex % 2 === 0 ? [focused] : [focused, support].filter(Boolean);
+    };
+    return Array.from({ length: input.sceneCount }, (_, sceneIndex) => {
+        const oneBased = sceneIndex + 1;
+        const beatIndex = Math.min(Math.floor((sceneIndex / Math.max(input.sceneCount, 1)) * actStructure.length), actStructure.length - 1);
+        const beatLabel = actStructure[beatIndex] ?? actStructure[0] ?? 'story beat';
+        const sceneCharacters = pickSceneCharacters(sceneIndex);
+        const characterNames = sceneCharacters.length > 0 ? sceneCharacters.join(', ') : null;
+        const beatNote = input.genre
+            ? `${input.genre} beat: ${beatLabel}.`
+            : `Beat focus: ${beatLabel}.`;
+        const beatDirective = describeBeatDirective(beatLabel);
+        const continuityNote = sceneIndex === 0
+            ? `Translate the brief "${input.intent}" into an immediately legible opening image.`
+            : sceneIndex === input.sceneCount - 1
+                ? 'Resolve the previous movement into a final image that completes the sequence cleanly.'
+                : `${beatDirective} Move beyond Scene ${sceneIndex} with a new reveal, geography change, or framing strategy.`;
+        const castNote = characterNames
+            ? (sceneIndex === 0
+                ? `Bring ${characterNames} into frame decisively.`
+                : sceneIndex === input.sceneCount - 1
+                    ? `Reunite ${characterNames} in the payoff image.`
+                    : `Center ${characterNames} in this transition.`)
+            : '';
+        const toneNote = input.tone
+            ? (sceneIndex === 0
+                ? `Set the emotional lane as ${input.tone}.`
+                : sceneIndex === input.sceneCount - 1
+                    ? `Let the ending still feel ${input.tone}.`
+                    : '')
+            : '';
+        const styleNote = styleNotes
+            ? (sceneIndex === 0
+                ? `Stage the opening with ${styleNotes}.`
+                : sceneIndex === input.sceneCount - 1
+                    ? `Close the sequence in ${styleNotes}.`
+                    : `Render this beat through ${styleNotes}.`)
+            : '';
+        return {
+            sceneIndex,
+            description: `Scene ${oneBased} of ${input.sceneCount}: ${beatNote} ${continuityNote} ${castNote} ${toneNote} ${styleNote}`.replace(/\s+/g, ' ').trim(),
+            ...(sceneCharacters.length > 0 ? { characters: sceneCharacters } : {}),
+            ...(input.mode === 'director' ? { durationSeconds: input.durationSeconds ?? 15 } : {}),
+        };
+    });
+}
+function buildStoryboardReviewCommand(projectSlug, root) {
+    return [
+        'vclaw',
+        'video',
+        'storyboard-review',
+        '--project',
+        shellQuote(projectSlug),
+        '--root',
+        shellQuote(root),
+        '--mode',
+        'director',
+    ].join(' ');
+}
+function buildStoryboardApprovalCommand(projectSlug, root) {
+    return [
+        'VIDEOCLAW_APPROVE_STORYBOARD=1',
+        'vclaw',
+        'video',
+        'execute',
+        '--project',
+        shellQuote(projectSlug),
+        '--root',
+        shellQuote(root),
+        '--mode',
+        'director',
+    ].join(' ');
+}
+function buildVerifyEnvCommand(root) {
+    return [
+        'vclaw',
+        'video',
+        'verify-env',
+        '--root',
+        shellQuote(root),
+    ].join(' ');
+}
+export async function handleVideoCreate(args) {
+    const intent = args.find((value) => !value.startsWith('--'))?.trim();
+    if (!intent) {
+        throw new VclawError('missing_required_flag', 'video create requires an intent string as the first positional argument');
+    }
+    const root = parseFlagValue(args, '--root') ?? process.cwd();
+    const mode = (parseFlagValue(args, '--production-mode') ?? parseFlagValue(args, '--mode') ?? 'director');
+    const title = parseFlagValue(args, '--title') ?? deriveCreateTitle(intent);
+    const slug = deriveCreateSlug(args, intent);
+    const sceneCountRaw = parseFlagValue(args, '--scenes');
+    const applyContentFixes = args.includes('--apply-content-fixes');
+    const execute = args.includes('--execute');
+    const dryRun = args.includes('--dry-run');
+    const explicitGbCharacters = parseGbCharacters(args).map((entry) => ({
+        ...entry,
+        sourceNote: 'Imported from `video create --gb-character`.',
+    }));
+    const importLibraryCharacters = args.includes('--import-library-characters');
+    const autoCreateCharactersPath = parseFlagValue(args, '--auto-create-characters');
+    const apiUrl = parseFlagValue(args, '--api-url') ?? process.env.GO_BANANAS_API_URL ?? 'https://gobananasai.com/api';
+    const workspace = await ensureProjectInitialized(slug, root, mode);
+    const existingBriefPath = artifactPathFor(workspace, 'brief');
+    const existingBriefMetadata = existsSync(existingBriefPath)
+        ? JSON.parse(await readFile(existingBriefPath, 'utf-8')).metadata ?? {}
+        : {};
+    const preservedGenre = typeof existingBriefMetadata.genre === 'string' ? existingBriefMetadata.genre : undefined;
+    const preservedPlatform = typeof existingBriefMetadata.platform === 'string' ? existingBriefMetadata.platform : undefined;
+    const preservedStyle = typeof existingBriefMetadata.style === 'string' ? existingBriefMetadata.style : undefined;
+    const preservedColorGrading = typeof existingBriefMetadata.colorGrading === 'string' ? existingBriefMetadata.colorGrading : undefined;
+    const preservedClipDurationSeconds = typeof existingBriefMetadata.clipDurationSeconds === 'number'
+        ? existingBriefMetadata.clipDurationSeconds
+        : undefined;
+    const clipDurationOverride = parseClipDurationSeconds(parseFlagValue(args, '--clip-duration')
+        ?? process.env.SEEDANCE_CLIP_DURATION_SEC
+        ?? (preservedClipDurationSeconds !== undefined ? String(preservedClipDurationSeconds) : undefined));
+    const genreDefaults = mode === 'director'
+        ? resolveDirectorCreateDefaults({
+            intent,
+            explicitGenre: parseFlagValue(args, '--genre') ?? preservedGenre,
+            explicitRuntime: parseFlagValue(args, '--runtime'),
+            explicitClipDurationSeconds: clipDurationOverride,
+            explicitSceneCount: sceneCountRaw ? Number(sceneCountRaw) : undefined,
+            explicitPlatform: parseFlagValue(args, '--platform') ?? preservedPlatform,
+            explicitStyle: parseFlagValue(args, '--style') ?? preservedStyle,
+            explicitColorGrading: parseFlagValue(args, '--color-grading') ?? preservedColorGrading,
+        })
+        : null;
+    const sceneCount = genreDefaults?.sceneCount ?? (sceneCountRaw ? Number(sceneCountRaw) : mode === 'director' ? 8 : 3);
+    if (!Number.isInteger(sceneCount) || sceneCount <= 0) {
+        throw new VclawError('missing_required_flag', 'video create requires --scenes to be a positive integer when provided');
+    }
+    const genre = genreDefaults?.genre;
+    const style = genreDefaults?.style ?? parseFlagValue(args, '--style');
+    const colorGrading = genreDefaults?.colorGrading ?? parseFlagValue(args, '--color-grading');
+    const platform = genreDefaults?.platform ?? parseFlagValue(args, '--platform');
+    const resolvedDefaults = mode === 'director'
+        ? {
+            ...(genre ? { genre } : {}),
+            ...(platform ? { platform } : {}),
+            ...(style ? { style } : {}),
+            ...(colorGrading ? { colorGrading } : {}),
+            ...(genreDefaults?.runtimeSeconds ? { targetRuntimeSeconds: genreDefaults.runtimeSeconds } : {}),
+            ...(genreDefaults?.durationSeconds ? { clipDurationSeconds: genreDefaults.durationSeconds } : {}),
+            sceneCount,
+        }
+        : null;
+    const importedGbCharacters = importLibraryCharacters
+        ? (await (async () => {
+            const apiKey = process.env.GO_BANANAS_API_KEY?.trim();
+            if (!apiKey) {
+                throw new Error('GO_BANANAS_API_KEY is required when using --import-library-characters');
+            }
+            const characters = await findLibraryCharactersByIntent(intent, apiKey, apiUrl);
+            for (const character of characters) {
+                await addCharacterProfile(workspace, {
+                    name: character.character_name,
+                    goBananasId: character.id,
+                    ...(character.description ? { description: character.description } : {}),
+                    referenceAssets: [`gobananas://character/${character.id}`],
+                    notes: ['Imported from `video create --import-library-characters`.'],
+                });
+            }
+            return characters.map((character) => ({
+                name: character.character_name,
+                goBananasId: character.id,
+                sourceNote: 'Imported from `video create --import-library-characters`.',
+            }));
+        })())
+        : [];
+    const autoCreatedGbCharacters = autoCreateCharactersPath
+        ? (await (async () => {
+            const inputs = JSON.parse(await readFile(autoCreateCharactersPath, 'utf-8'));
+            if (!Array.isArray(inputs)) {
+                throw new Error('--auto-create-characters must point to a JSON array');
+            }
+            const results = await autoCreateCharacters(inputs.flatMap((entry) => {
+                const name = entry.name?.trim();
+                const description = entry.description?.trim();
+                if (!name || !description)
+                    return [];
+                return [{
+                        name,
+                        description,
+                        ...(entry.style?.trim() ? { style: entry.style.trim() } : {}),
+                    }];
+            }), {
+                projectSlug: slug,
+                root,
+                apiUrl,
+                dryRun,
+            });
+            return Object.entries(results)
+                .filter(([, result]) => result.characterId > 0)
+                .map(([name, result]) => ({
+                name,
+                goBananasId: result.characterId,
+                sourceNote: 'Created via `video create --auto-create-characters`.',
+            }));
+        })())
+        : [];
+    const gbCharacters = mergeGbCharacters(explicitGbCharacters, importedGbCharacters, autoCreatedGbCharacters);
+    const characterNames = gbCharacters.map((entry) => entry.name);
+    const characterHydration = {
+        explicit: explicitGbCharacters,
+        imported: importedGbCharacters,
+        autoCreated: autoCreatedGbCharacters,
+        final: gbCharacters,
+    };
+    for (const character of gbCharacters) {
+        await addCharacterProfile(workspace, {
+            name: character.name,
+            goBananasId: character.goBananasId,
+            referenceAssets: [`gobananas://character/${character.goBananasId}`],
+            ...(character.sourceNote ? { notes: [character.sourceNote] } : {}),
+        });
+    }
+    if (gbCharacters.length > 0) {
+        await appendProjectEvent(workspace, {
+            type: 'character.hydrated',
+            payload: {
+                explicit: explicitGbCharacters.map((entry) => ({ name: entry.name, goBananasId: entry.goBananasId })),
+                imported: importedGbCharacters.map((entry) => ({ name: entry.name, goBananasId: entry.goBananasId })),
+                autoCreated: autoCreatedGbCharacters.map((entry) => ({ name: entry.name, goBananasId: entry.goBananasId })),
+                final: gbCharacters.map((entry) => ({ name: entry.name, goBananasId: entry.goBananasId })),
+            },
+        });
+    }
+    const executionProfile = applyPlatformExecutionProfileDefaults(platform ?? (typeof existingBriefMetadata.platform === 'string' ? existingBriefMetadata.platform : undefined), {
+        ...((existingBriefMetadata.executionProfile && typeof existingBriefMetadata.executionProfile === 'object')
+            ? existingBriefMetadata.executionProfile
+            : {}),
+        ...parseExecutionProfileFlags(args),
+    });
+    const briefArtifact = createBriefArtifact({
+        title,
+        intent,
+        productionMode: mode,
+        metadata: {
+            ...existingBriefMetadata,
+            ...(genre ? { genre } : {}),
+            ...(genreDefaults?.runtimeSeconds ? { targetRuntimeSeconds: genreDefaults.runtimeSeconds } : {}),
+            ...(genreDefaults?.durationSeconds ? { clipDurationSeconds: genreDefaults.durationSeconds } : {}),
+            ...((platform ?? existingBriefMetadata.platform) ? { platform: (platform ?? existingBriefMetadata.platform) } : {}),
+            ...((style ?? existingBriefMetadata.style) ? { style: (style ?? existingBriefMetadata.style) } : {}),
+            ...((colorGrading ?? existingBriefMetadata.colorGrading) ? { colorGrading: (colorGrading ?? existingBriefMetadata.colorGrading) } : {}),
+            ...((gbCharacters.length > 0
+                ? gbCharacters
+                : (Array.isArray(existingBriefMetadata.goBananasCharacters) ? existingBriefMetadata.goBananasCharacters : undefined))
+                ? {
+                    goBananasCharacters: (gbCharacters.length > 0
+                        ? gbCharacters
+                        : existingBriefMetadata.goBananasCharacters),
+                }
+                : {}),
+            ...(Object.keys(executionProfile).length > 0 ? { executionProfile } : {}),
+            sourceCommand: 'video create',
+        },
+    });
+    const briefPath = await writeArtifact(workspace, 'brief', briefArtifact);
+    await writeStageCheckpoint(workspace, {
+        stage: 'brief',
+        status: 'completed',
+        generatedAt: briefArtifact.createdAt,
+        artifacts: {
+            brief: briefPath,
+        },
+        summary: 'Brief artifact created from video create.',
+        issues: [],
+        nextAction: 'Draft the storyboard artifact.',
+    });
+    await appendProjectEvent(workspace, {
+        type: 'artifact.brief.written',
+        recordedAt: briefArtifact.createdAt,
+        payload: buildBriefEventPayload({
+            artifactPath: briefPath,
+            title: briefArtifact.title,
+            ...(typeof genreDefaults?.runtimeSeconds === 'number' ? { targetRuntimeSeconds: genreDefaults.runtimeSeconds } : {}),
+            ...(typeof genreDefaults?.durationSeconds === 'number' ? { clipDurationSeconds: genreDefaults.durationSeconds } : {}),
+            genre,
+            platform: platform ?? undefined,
+            executionProfile,
+            source: 'video-create',
+        }),
+    });
+    await updateProjectManifestState(workspace, {
+        updatedAt: briefArtifact.createdAt,
+        currentStage: 'storyboard',
+        lastCompletedStage: 'brief',
+        lastCheckpointStatus: 'completed',
+    });
+    const storyboardArtifact = createStoryboardArtifact({
+        projectSlug: slug,
+        productionMode: mode,
+        scenes: buildCreateStoryboardScenes({
+            intent,
+            sceneCount,
+            mode,
+            characterNames,
+            genre,
+            tone: genreDefaults?.tone,
+            actStructure: genreDefaults?.actStructure,
+            style: style ?? undefined,
+            colorGrading: colorGrading ?? undefined,
+            durationSeconds: genreDefaults?.durationSeconds,
+        }),
+    });
+    const storyboardPath = await writeArtifact(workspace, 'storyboard', storyboardArtifact);
+    let storyBible = await writeStoryBibleForProject(workspace);
+    await writeStageCheckpoint(workspace, {
+        stage: 'storyboard',
+        status: 'completed',
+        generatedAt: new Date().toISOString(),
+        artifacts: {
+            storyboard: storyboardPath,
+            ...(storyBible?.artifactPath ? { 'story-bible': storyBible.artifactPath } : {}),
+        },
+        summary: 'Storyboard artifact created from video create.',
+        issues: [],
+        nextAction: mode === 'director' ? 'Generate a storyboard review before approval.' : 'Create or attach scene assets.',
+    });
+    await appendProjectEvent(workspace, {
+        type: 'artifact.storyboard.written',
+        payload: {
+            artifactPath: storyboardPath,
+            sceneCount: storyboardArtifact.scenes.length,
+            source: 'video-create',
+            ...(storyBible?.artifactPath ? { storyBiblePath: storyBible.artifactPath } : {}),
+        },
+    });
+    await updateProjectManifestState(workspace, {
+        currentStage: 'assets',
+        lastCompletedStage: 'storyboard',
+        lastCheckpointStatus: 'completed',
+    });
+    const seedAssets = await scaffoldExecutionSeedAssetsFromStoryboard(slug, root);
+    await writeStageCheckpoint(workspace, {
+        stage: 'assets',
+        status: mode === 'director' ? 'pending' : 'completed',
+        generatedAt: new Date().toISOString(),
+        artifacts: {
+            'asset-manifest': seedAssets.artifactPath,
+        },
+        summary: 'Seed asset manifest scaffolded from storyboard scenes.',
+        issues: [],
+        nextAction: mode === 'director' ? 'Review the generated storyboard markdown before execution.' : 'Run execution planning or execute the project.',
+    });
+    if (mode !== 'director') {
+        await updateProjectManifestState(workspace, {
+            currentStage: 'assets',
+            lastCompletedStage: 'storyboard',
+            lastCheckpointStatus: 'completed',
+        });
+    }
+    let review = null;
+    let preflight = null;
+    let costEstimate = null;
+    let applied = null;
+    let execution = null;
+    let handoff = null;
+    if (mode === 'director') {
+        applied = applyContentFixes ? await autoFixDirectorStoryboardContent(slug, root) : null;
+        if (applied) {
+            storyBible = await writeStoryBibleForProject(workspace);
+        }
+        preflight = await runDirectorPreflight(slug, root);
+        const plan = await buildExecutionPlan(slug, root, mode);
+        costEstimate = await buildProjectCostEstimate({
+            projectSlug: slug,
+            root,
+            newCharacterCount: autoCreatedGbCharacters.length,
+        });
+        review = await writeStoryboardMarkdownReview({
+            projectSlug: slug,
+            root,
+            executionPlan: plan,
+            costEstimate,
+            preflight,
+        });
+        handoff = {
+            reviewCommand: buildStoryboardReviewCommand(slug, root),
+            approvalCommand: buildStoryboardApprovalCommand(slug, root),
+            verifyEnvCommand: buildVerifyEnvCommand(root),
+        };
+        const generatedAt = new Date().toISOString();
+        await writeStageCheckpoint(workspace, {
+            stage: 'storyboard',
+            status: preflight.pass ? 'awaiting-approval' : 'failed',
+            generatedAt,
+            artifacts: {
+                storyboard: artifactPathFor(workspace, 'storyboard'),
+                ...(storyBible?.artifactPath ? { 'story-bible': storyBible.artifactPath } : {}),
+            },
+            summary: preflight.pass
+                ? 'Storyboard review generated and awaiting approval.'
+                : 'Storyboard review generated, but director preflight failed.',
+            issues: preflight.errors.map((issue) => issue.message),
+            nextAction: preflight.pass
+                ? `Review ${review.markdownPath} and approve execution.`
+                : `Review ${review.markdownPath}, fix the preflight errors, and rerun storyboard-review.`,
+        });
+        await updateProjectManifestState(workspace, {
+            updatedAt: generatedAt,
+            currentStage: 'storyboard',
+            lastCompletedStage: 'brief',
+            lastCheckpointStatus: preflight.pass ? 'awaiting-approval' : 'failed',
+        });
+        await appendProjectEvent(workspace, {
+            type: 'storyboard.review.generated',
+            payload: {
+                markdownPath: review.markdownPath,
+                routeId: plan.recommendedRouteId,
+                mode,
+                preflightPass: preflight.pass,
+                appliedContentFixes: applied?.changeCount ?? 0,
+                source: 'video-create',
+            },
+        });
+    }
+    if (execute) {
+        execution = await executeProject(slug, {
+            root,
+            productionMode: mode,
+            dryRun,
+        });
+    }
+    await appendVideoContextChangelog(root, `${new Date().toISOString()} create: initialized ${slug} via video create (${mode}).`);
+    process.stdout.write(`${JSON.stringify({
+        workspace,
+        slug,
+        title,
+        ...(genre ? { genre } : {}),
+        sceneCount,
+        ...(resolvedDefaults ? { resolvedDefaults } : {}),
+        ...(gbCharacters.length > 0 ? { characterHydration } : {}),
+        briefPath,
+        storyboardPath,
+        ...(storyBible?.artifactPath ? { storyBiblePath: storyBible.artifactPath } : {}),
+        seedAssetManifestPath: seedAssets.artifactPath,
+        review,
+        preflight,
+        costEstimate,
+        handoff,
+        applied,
+        execution,
+    }, null, 2)}\n`);
+}
+export async function handleVideoAuto(args) {
+    const normalizedArgs = [...args];
+    if (!normalizedArgs.includes('--production-mode') && !normalizedArgs.includes('--mode')) {
+        normalizedArgs.push('--production-mode', 'director');
+    }
+    await handleVideoCreate(normalizedArgs);
+}
+export async function handleVideoIterate(args) {
+    const normalizedArgs = [...args];
+    if (!normalizedArgs.includes('--production-mode') && !normalizedArgs.includes('--mode')) {
+        normalizedArgs.push('--production-mode', 'director');
+    }
+    if (!normalizedArgs.includes('--execute')) {
+        normalizedArgs.push('--execute');
+    }
+    await handleVideoCreate(normalizedArgs);
+}
+export async function handleVideoRunPipeline(args) {
+    const normalizedArgs = [...args];
+    if (!normalizedArgs.includes('--production-mode') && !normalizedArgs.includes('--mode')) {
+        normalizedArgs.push('--production-mode', 'director');
+    }
+    if (!normalizedArgs.includes('--execute')) {
+        normalizedArgs.push('--execute');
+    }
+    await handleVideoCreate(normalizedArgs);
+}
+//# sourceMappingURL=create.js.map