@vibeframe/cli 0.48.6 → 0.49.1

package/dist/commands/ai-script-pipeline.js

@@ -16,7 +16,7 @@
  *              Kling/Runway (video), FFmpeg (assembly/extension)
  */
 import { readFile, writeFile, mkdir, unlink, rename } from "node:fs/promises";
-import { resolve, basename, extname } from "node:path";
+import { resolve, basename, dirname, extname } from "node:path";
 import { existsSync } from "node:fs";
 import { stringify as yamlStringify, parse as yamlParse } from "yaml";
 import chalk from "chalk";
@@ -131,6 +131,27 @@ export async function extendVideoToTarget(videoPath, targetDuration, outputDir,
     await unlink(videoPath);
     await rename(extendedPath, videoPath);
 }
+/**
+ * Log a provider failure to stderr. Centralizes the "what went wrong" output
+ * so call sites stop silently dropping provider errors into failedScenes.
+ * Safe to call with unknown errors, string messages, or VideoResult shapes.
+ */
+export function logSceneFailure(provider, sceneLabel, err) {
+    let msg;
+    if (err instanceof Error) {
+        msg = err.message;
+    }
+    else if (typeof err === "string") {
+        msg = err;
+    }
+    else if (err && typeof err === "object" && "error" in err && typeof err.error === "string") {
+        msg = err.error;
+    }
+    else {
+        msg = String(err);
+    }
+    console.error(chalk.dim(`\n  [${provider} ${sceneLabel}: ${msg}]`));
+}
 /**
  * Generate video with retry logic for Grok provider
  */
@@ -149,10 +170,16 @@ export async function generateVideoWithRetryGrok(grok, segment, options, maxRetr
             if (result.status !== "failed" && result.id) {
                 return { requestId: result.id };
             }
+            // Provider returned status: "failed" with an error message — don't
+            // discard it. Surface via onProgress + stderr so the caller can see WHY.
+            const providerErr = result.error || "Grok returned failed status";
             if (attempt < maxRetries) {
-                onProgress?.(`⚠ Retry ${attempt + 1}/${maxRetries}...`);
+                onProgress?.(`⚠ ${providerErr.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
                 await sleep(RETRY_DELAY_MS);
             }
+            else {
+                console.error(chalk.dim(`\n  [Grok error: ${providerErr}]`));
+            }
         }
         catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
@@ -192,10 +219,14 @@ export async function generateVideoWithRetryKling(kling, segment, options, maxRe
                     type: options.referenceImage ? "image2video" : "text2video",
                 };
             }
+            const providerErr = result.error || "Kling returned failed status";
             if (attempt < maxRetries) {
-                onProgress?.(`⚠ Retry ${attempt + 1}/${maxRetries}...`);
+                onProgress?.(`⚠ ${providerErr.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
                 await sleep(RETRY_DELAY_MS);
             }
+            else {
+                console.error(chalk.dim(`\n  [Kling error: ${providerErr}]`));
+            }
         }
         catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
@@ -204,7 +235,6 @@ export async function generateVideoWithRetryKling(kling, segment, options, maxRe
                 await sleep(RETRY_DELAY_MS);
             }
             else {
-                // Log the final error on last attempt
                 console.error(chalk.dim(`\n  [Kling error: ${errMsg}]`));
             }
         }
@@ -226,10 +256,14 @@ export async function generateVideoWithRetryRunway(runway, segment, referenceIma
             if (result.status !== "failed" && result.id) {
                 return { taskId: result.id };
             }
+            const providerErr = result.error || "Runway returned failed status";
             if (attempt < maxRetries) {
-                onProgress?.(`⚠ Retry ${attempt + 1}/${maxRetries}...`);
+                onProgress?.(`⚠ ${providerErr.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
                 await sleep(RETRY_DELAY_MS);
             }
+            else {
+                console.error(chalk.dim(`\n  [Runway error: ${providerErr}]`));
+            }
         }
         catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
@@ -263,10 +297,14 @@ export async function generateVideoWithRetryVeo(gemini, segment, options, maxRet
             if (result.status !== "failed" && result.id) {
                 return { operationName: result.id };
             }
+            const providerErr = result.error || "Veo returned failed status";
             if (attempt < maxRetries) {
-                onProgress?.(`⚠ Retry ${attempt + 1}/${maxRetries}...`);
+                onProgress?.(`⚠ ${providerErr.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
                 await sleep(RETRY_DELAY_MS);
             }
+            else {
+                console.error(chalk.dim(`\n  [Veo error: ${providerErr}]`));
+            }
         }
         catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
@@ -461,14 +499,42 @@ export async function executeScriptToVideo(options) {
                     });
                     continue;
                 }
-                const ttsResult = await elevenlabs.textToSpeech(narrationText, {
+                // Pre-TTS word-count heuristic (warn only; narration may still fit)
+                const wordCount = narrationText.split(/\s+/).filter(Boolean).length;
+                const maxWords = segment.duration > 5 ? 24 : 12;
+                if (wordCount > maxWords * 1.3) {
+                    options.onProgress?.(`⚠ Scene ${i + 1} narration has ${wordCount} words (target ~${maxWords} for ${segment.duration}s); speech may rush.`);
+                }
+                options.onProgress?.(`Scene ${i + 1}/${segments.length}: generating narration...`);
+                let ttsResult = await elevenlabs.textToSpeech(narrationText, {
                     voiceId: options.voice,
                 });
                 if (ttsResult.success && ttsResult.audioBuffer) {
                     const audioPath = resolve(absOutputDir, `narration-${i + 1}.mp3`);
                     await writeFile(audioPath, ttsResult.audioBuffer);
                     // Get actual audio duration
-                    const actualDuration = await getAudioDuration(audioPath);
+                    let actualDuration = await getAudioDuration(audioPath);
+                    // Auto speed-adjust if narration exceeds video bracket (5s or 10s).
+                    // Pick the bracket from the pre-TTS segment.duration (the storyboard
+                    // estimate), not actualDuration — actualDuration IS the overage.
+                    const videoBracket = segment.duration > 5 ? 10 : 5;
+                    const overageRatio = actualDuration / videoBracket;
+                    if (overageRatio > 1.0 && overageRatio <= 1.35) {
+                        const adjustedSpeed = Math.min(1.35, parseFloat(overageRatio.toFixed(2)));
+                        options.onProgress?.(`Scene ${i + 1}: adjusting narration speed to ${adjustedSpeed}x...`);
+                        const speedResult = await elevenlabs.textToSpeech(narrationText, {
+                            voiceId: options.voice,
+                            speed: adjustedSpeed,
+                        });
+                        if (speedResult.success && speedResult.audioBuffer) {
+                            await writeFile(audioPath, speedResult.audioBuffer);
+                            actualDuration = await getAudioDuration(audioPath);
+                            ttsResult = speedResult;
+                        }
+                    }
+                    else if (overageRatio > 1.35) {
+                        options.onProgress?.(`⚠ Scene ${i + 1} narration is ${((overageRatio - 1) * 100).toFixed(0)}% over target (${actualDuration.toFixed(1)}s vs ${videoBracket}s bracket)`);
+                    }
                     segment.duration = actualDuration;
                     // Add to both arrays for backwards compatibility
                     result.narrations.push(audioPath);
@@ -528,6 +594,7 @@ export async function executeScriptToVideo(options) {
             const imagePrompt = segment.visualStyle
                 ? `${segment.visuals}. Style: ${segment.visualStyle}`
                 : segment.visuals;
+            options.onProgress?.(`Scene ${i + 1}/${segments.length}: generating image...`);
             try {
                 let imageBuffer;
                 let imageUrl;
@@ -613,6 +680,7 @@ export async function executeScriptToVideo(options) {
                     }
                     const segment = segments[i];
                     const videoDuration = Math.min(15, Math.max(1, segment.duration));
+                    options.onProgress?.(`Scene ${i + 1}/${segments.length}: generating video (grok)...`);
                     // Image-to-video: encode image as data URI
                     const imageBuffer = await readFile(imagePaths[i]);
                     const ext = extname(imagePaths[i]).toLowerCase().slice(1);
@@ -638,11 +706,13 @@ export async function executeScriptToVideo(options) {
                                 result.videos.push(videoPath);
                             }
                             else {
+                                logSceneFailure("Grok", `scene ${i + 1}`, waitResult);
                                 videoPaths.push("");
                                 result.failedScenes.push(i + 1);
                             }
                         }
-                        catch {
+                        catch (err) {
+                            logSceneFailure("Grok", `scene ${i + 1}`, err);
                             videoPaths.push("");
                             result.failedScenes.push(i + 1);
                         }
@@ -659,6 +729,28 @@ export async function executeScriptToVideo(options) {
                 if (!kling.isConfigured()) {
                     return { success: false, outputDir: absOutputDir, scenes: segments.length, error: "Invalid Kling API key format. Use ACCESS_KEY:SECRET_KEY" };
                 }
+                // Kling image2video requires a public image URL (not base64). When an
+                // ImgBB key is configured, upload each scene image once and pass the
+                // URL as referenceImage; otherwise fall through to text2video.
+                const imgbbApiKey = (await getApiKeyFromConfig("imgbb")) || process.env.IMGBB_API_KEY;
+                const imageUrls = new Array(segments.length);
+                if (imgbbApiKey) {
+                    options.onProgress?.("Uploading scene images for Kling image-to-video...");
+                    for (let i = 0; i < imagePaths.length; i++) {
+                        if (imagePaths[i]) {
+                            try {
+                                const imageBuffer = await readFile(imagePaths[i]);
+                                const uploadResult = await uploadToImgbb(imageBuffer, imgbbApiKey);
+                                if (uploadResult.success && uploadResult.url) {
+                                    imageUrls[i] = uploadResult.url;
+                                }
+                            }
+                            catch {
+                                imageUrls[i] = undefined;
+                            }
+                        }
+                    }
+                }
                 for (let i = 0; i < segments.length; i++) {
                     if (!imagePaths[i]) {
                         videoPaths.push("");
@@ -666,8 +758,12 @@ export async function executeScriptToVideo(options) {
                     }
                     const segment = segments[i];
                     const videoDuration = (segment.duration > 5 ? 10 : 5);
-                    // Using text2video since Kling's image2video requires URL (not base64)
-                    const taskResult = await generateVideoWithRetryKling(kling, segment, { duration: videoDuration, aspectRatio: (options.aspectRatio || "16:9") }, maxRetries);
+                    options.onProgress?.(`Scene ${i + 1}/${segments.length}: generating video (kling)...`);
+                    const taskResult = await generateVideoWithRetryKling(kling, segment, {
+                        duration: videoDuration,
+                        aspectRatio: (options.aspectRatio || "16:9"),
+                        referenceImage: imageUrls[i],
+                    }, maxRetries);
                     if (taskResult) {
                         try {
                             const waitResult = await kling.waitForCompletion(taskResult.taskId, taskResult.type, undefined, 600000);
@@ -675,25 +771,25 @@ export async function executeScriptToVideo(options) {
                                 const videoPath = resolve(absOutputDir, `scene-${i + 1}.mp4`);
                                 const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
                                 await writeFile(videoPath, buffer);
-                                // Extend video to match narration duration if needed
-                                const targetDuration = segment.duration; // Already updated to narration length
-                                const actualVideoDuration = await getVideoDuration(videoPath);
-                                if (actualVideoDuration < targetDuration - 0.1) {
-                                    const extendedPath = resolve(absOutputDir, `scene-${i + 1}-extended.mp4`);
-                                    await extendVideoNaturally(videoPath, targetDuration, extendedPath);
-                                    // Replace original with extended version
-                                    await unlink(videoPath);
-                                    await rename(extendedPath, videoPath);
-                                }
+                                // Extend video to match narration duration. Use extendVideoToTarget
+                                // so large gaps (ratio > 1.4) can use Kling's own extend API for
+                                // natural continuation instead of freeze-frame padding.
+                                await extendVideoToTarget(videoPath, segment.duration, absOutputDir, `Scene ${i + 1}`, {
+                                    kling,
+                                    videoId: waitResult.videoId,
+                                    onProgress: options.onProgress,
+                                });
                                 videoPaths.push(videoPath);
                                 result.videos.push(videoPath);
                             }
                             else {
+                                logSceneFailure("Kling", `scene ${i + 1}`, waitResult);
                                 videoPaths.push("");
                                 result.failedScenes.push(i + 1);
                             }
                         }
-                        catch {
+                        catch (err) {
+                            logSceneFailure("Kling", `scene ${i + 1}`, err);
                             videoPaths.push("");
                             result.failedScenes.push(i + 1);
                         }
@@ -715,6 +811,7 @@ export async function executeScriptToVideo(options) {
                     }
                     const segment = segments[i];
                     const veoDuration = (segment.duration > 6 ? 8 : segment.duration > 4 ? 6 : 4);
+                    options.onProgress?.(`Scene ${i + 1}/${segments.length}: generating video (veo)...`);
                     const taskResult = await generateVideoWithRetryVeo(veo, segment, { duration: veoDuration, aspectRatio: (options.aspectRatio || "16:9") }, maxRetries);
                     if (taskResult) {
                         try {
@@ -736,11 +833,13 @@ export async function executeScriptToVideo(options) {
                                 result.videos.push(videoPath);
                             }
                             else {
+                                logSceneFailure("Veo", `scene ${i + 1}`, waitResult);
                                 videoPaths.push("");
                                 result.failedScenes.push(i + 1);
                             }
                         }
-                        catch {
+                        catch (err) {
+                            logSceneFailure("Veo", `scene ${i + 1}`, err);
                             videoPaths.push("");
                             result.failedScenes.push(i + 1);
                         }
@@ -767,6 +866,7 @@ export async function executeScriptToVideo(options) {
                     const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
                     const videoDuration = (segment.duration > 5 ? 10 : 5);
                     const aspectRatio = options.aspectRatio === "1:1" ? "16:9" : (options.aspectRatio || "16:9");
+                    options.onProgress?.(`Scene ${i + 1}/${segments.length}: generating video (runway)...`);
                     const taskResult = await generateVideoWithRetryRunway(runway, segment, referenceImage, { duration: videoDuration, aspectRatio }, maxRetries);
                     if (taskResult) {
                         try {
@@ -788,11 +888,13 @@ export async function executeScriptToVideo(options) {
                                 result.videos.push(videoPath);
                             }
                             else {
+                                logSceneFailure("Runway", `scene ${i + 1}`, waitResult);
                                 videoPaths.push("");
                                 result.failedScenes.push(i + 1);
                             }
                         }
-                        catch {
+                        catch (err) {
+                            logSceneFailure("Runway", `scene ${i + 1}`, err);
                             videoPaths.push("");
                             result.failedScenes.push(i + 1);
                         }
@@ -912,8 +1014,15 @@ export async function executeScriptToVideo(options) {
             });
             currentTime += actualDuration;
         }
-        // Save project file
-        const projectPath = resolve(absOutputDir, "project.vibe.json");
+        // Save project file. Default is `{outputDir}/project.vibe.json`; callers
+        // can override via projectFilePath (used by the CLI's `-o` handling).
+        const projectPath = options.projectFilePath
+            ? resolve(process.cwd(), options.projectFilePath)
+            : resolve(absOutputDir, "project.vibe.json");
+        const projectParentDir = dirname(projectPath);
+        if (!existsSync(projectParentDir)) {
+            await mkdir(projectParentDir, { recursive: true });
+        }
         await writeFile(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
         result.projectPath = projectPath;
         result.totalDuration = currentTime;
@@ -995,6 +1104,8 @@ export async function executeRegenerateScene(options) {
             }
         }
         const regenerateVideo = options.videoOnly || (!options.narrationOnly && !options.imageOnly);
+        const regenerateNarration = options.narrationOnly || (!options.videoOnly && !options.imageOnly);
+        const regenerateImage = options.imageOnly || (!options.videoOnly && !options.narrationOnly);
         // Get API keys
         let videoApiKey;
         if (regenerateVideo) {
@@ -1014,12 +1125,183 @@ export async function executeRegenerateScene(options) {
                 return { ...result, error: `${genInfo.name} API key required. Run 'vibe setup' or set ${genInfo.envVar} in .env` };
             }
         }
+        let imageApiKey;
+        if (regenerateImage) {
+            const imageProvider = options.imageProvider || "openai";
+            const imageKeyMap = {
+                openai: { envVar: "OPENAI_API_KEY", name: "OpenAI" },
+                gemini: { envVar: "GOOGLE_API_KEY", name: "Google" },
+                grok: { envVar: "XAI_API_KEY", name: "xAI" },
+            };
+            const info = imageKeyMap[imageProvider];
+            if (!info) {
+                return { ...result, error: `Invalid imageProvider: ${imageProvider}` };
+            }
+            imageApiKey = (await getApiKey(info.envVar, info.name)) ?? undefined;
+            if (!imageApiKey) {
+                return { ...result, error: `${info.name} API key required. Run 'vibe setup' or set ${info.envVar} in .env` };
+            }
+        }
+        let elevenlabsApiKey;
+        if (regenerateNarration) {
+            elevenlabsApiKey = (await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs")) ?? undefined;
+            if (!elevenlabsApiKey) {
+                return { ...result, error: "ElevenLabs API key required. Run 'vibe setup' or set ELEVENLABS_API_KEY in .env" };
+            }
+        }
+        // Track storyboard mutations so we only rewrite when segment durations change.
+        let storyboardMutated = false;
         // Process each scene
         for (const sceneNum of options.scenes) {
             const segment = segments[sceneNum - 1];
+            const narrationPath = resolve(outputDir, `narration-${sceneNum}.mp3`);
             const imagePath = resolve(outputDir, `scene-${sceneNum}.png`);
             const videoPath = resolve(outputDir, `scene-${sceneNum}.mp4`);
+            let sceneFailed = false;
+            // Narration regeneration
+            if (regenerateNarration && elevenlabsApiKey) {
+                options.onProgress?.(`Scene ${sceneNum}: regenerating narration...`);
+                const elevenlabs = new ElevenLabsProvider();
+                await elevenlabs.initialize({ apiKey: elevenlabsApiKey });
+                const narrationText = segment.narration || segment.description;
+                const ttsResult = await elevenlabs.textToSpeech(narrationText, {
+                    voiceId: options.voice,
+                });
+                if (ttsResult.success && ttsResult.audioBuffer) {
+                    await writeFile(narrationPath, ttsResult.audioBuffer);
+                    segment.duration = await getAudioDuration(narrationPath);
+                    storyboardMutated = true;
+                }
+                else {
+                    sceneFailed = true;
+                }
+            }
+            // Image regeneration (with character-consistency reference when available)
+            if (!sceneFailed && regenerateImage && imageApiKey) {
+                options.onProgress?.(`Scene ${sceneNum}: regenerating image...`);
+                const imageProvider = options.imageProvider || "openai";
+                const characterDesc = segment.characterDescription || segments[0]?.characterDescription;
+                let imagePrompt = segment.visualStyle
+                    ? `${segment.visuals}. Style: ${segment.visualStyle}`
+                    : segment.visuals;
+                if (characterDesc) {
+                    imagePrompt = `${imagePrompt}\n\nIMPORTANT - Character appearance must match exactly: ${characterDesc}`;
+                }
+                // Pick a reference image for character consistency: caller-specified,
+                // else auto-detect the first existing scene image that isn't this scene.
+                let referenceImageBuffer;
+                const refSceneNum = options.referenceScene;
+                if (refSceneNum && refSceneNum >= 1 && refSceneNum <= segments.length && refSceneNum !== sceneNum) {
+                    const refImagePath = resolve(outputDir, `scene-${refSceneNum}.png`);
+                    if (existsSync(refImagePath)) {
+                        referenceImageBuffer = await readFile(refImagePath);
+                    }
+                }
+                else if (!refSceneNum) {
+                    for (let i = 1; i <= segments.length; i++) {
+                        if (i !== sceneNum) {
+                            const otherImagePath = resolve(outputDir, `scene-${i}.png`);
+                            if (existsSync(otherImagePath)) {
+                                referenceImageBuffer = await readFile(otherImagePath);
+                                break;
+                            }
+                        }
+                    }
+                }
+                const dalleImageSizes = {
+                    "16:9": "1536x1024",
+                    "9:16": "1024x1536",
+                    "1:1": "1024x1024",
+                };
+                let imageBuffer;
+                let imageUrl;
+                if (imageProvider === "openai") {
+                    const openaiImage = new OpenAIImageProvider();
+                    await openaiImage.initialize({ apiKey: imageApiKey });
+                    const imageResult = await openaiImage.generateImage(imagePrompt, {
+                        size: dalleImageSizes[options.aspectRatio || "16:9"] || "1536x1024",
+                        quality: "standard",
+                    });
+                    if (imageResult.success && imageResult.images?.[0]) {
+                        const img = imageResult.images[0];
+                        if (img.base64)
+                            imageBuffer = Buffer.from(img.base64, "base64");
+                        else if (img.url)
+                            imageUrl = img.url;
+                    }
+                }
+                else if (imageProvider === "gemini") {
+                    const gemini = new GeminiProvider();
+                    await gemini.initialize({ apiKey: imageApiKey });
+                    if (referenceImageBuffer) {
+                        // Gemini edit-with-reference path — pulls the character forward
+                        // while describing the new action. Simplified visuals pick the
+                        // first recognised action verb to reduce prompt bleed.
+                        const simplifiedVisuals = segment.visuals.split(/[,.]/).find((part) => part.includes("standing") || part.includes("sitting") || part.includes("walking") ||
+                            part.includes("lying") || part.includes("reaching") || part.includes("looking") ||
+                            part.includes("working") || part.includes("coding") || part.includes("typing")) || segment.visuals.split(".")[0];
+                        const editPrompt = `Generate a new image showing the SAME SINGLE person from the reference image in a new scene.
+
+REFERENCE: Look at the person in the reference image - their face, hair, build, and overall appearance.
+
+NEW SCENE: ${simplifiedVisuals}
+
+CRITICAL RULES:
+1. Show ONLY ONE person - the exact same individual from the reference image
+2. The person must have the IDENTICAL face, hair style, and body type
+3. Do NOT show multiple people or duplicate the character
+4. Create a single moment in time, one pose, one action
+5. Match the art style and quality of the reference image
+
+Generate the single-person scene image now.`;
+                        const imageResult = await gemini.editImage([referenceImageBuffer], editPrompt, {
+                            aspectRatio: (options.aspectRatio || "16:9"),
+                        });
+                        if (imageResult.success && imageResult.images?.[0]?.base64) {
+                            imageBuffer = Buffer.from(imageResult.images[0].base64, "base64");
+                        }
+                    }
+                    else {
+                        const imageResult = await gemini.generateImage(imagePrompt, {
+                            aspectRatio: (options.aspectRatio || "16:9"),
+                        });
+                        if (imageResult.success && imageResult.images?.[0]?.base64) {
+                            imageBuffer = Buffer.from(imageResult.images[0].base64, "base64");
+                        }
+                    }
+                }
+                else if (imageProvider === "grok") {
+                    const grok = new GrokProvider();
+                    await grok.initialize({ apiKey: imageApiKey });
+                    const imageResult = await grok.generateImage(imagePrompt, {
+                        aspectRatio: options.aspectRatio || "16:9",
+                    });
+                    if (imageResult.success && imageResult.images?.[0]) {
+                        const img = imageResult.images[0];
+                        if (img.base64)
+                            imageBuffer = Buffer.from(img.base64, "base64");
+                        else if (img.url)
+                            imageUrl = img.url;
+                    }
+                }
+                if (imageBuffer) {
+                    await writeFile(imagePath, imageBuffer);
+                }
+                else if (imageUrl) {
+                    const response = await fetch(imageUrl);
+                    const buffer = Buffer.from(await response.arrayBuffer());
+                    await writeFile(imagePath, buffer);
+                }
+                else {
+                    sceneFailed = true;
+                }
+            }
+            if (sceneFailed) {
+                result.failedScenes.push(sceneNum);
+                continue;
+            }
             if (regenerateVideo && videoApiKey) {
+                options.onProgress?.(`Scene ${sceneNum}: regenerating video (${options.generator || "grok"})...`);
                 if (!existsSync(imagePath)) {
                     result.failedScenes.push(sceneNum);
                     continue;
@@ -1057,10 +1339,12 @@ export async function executeRegenerateScene(options) {
                                 result.regeneratedScenes.push(sceneNum);
                             }
                             else {
+                                logSceneFailure("Grok", `scene ${sceneNum}`, waitResult);
                                 result.failedScenes.push(sceneNum);
                             }
                         }
-                        catch {
+                        catch (err) {
+                            logSceneFailure("Grok", `scene ${sceneNum}`, err);
                             result.failedScenes.push(sceneNum);
                         }
                     }
@@ -1098,10 +1382,12 @@ export async function executeRegenerateScene(options) {
                                 result.regeneratedScenes.push(sceneNum);
                             }
                             else {
+                                logSceneFailure("Veo", `scene ${sceneNum}`, waitResult);
                                 result.failedScenes.push(sceneNum);
                             }
                         }
-                        catch {
+                        catch (err) {
+                            logSceneFailure("Veo", `scene ${sceneNum}`, err);
                             result.failedScenes.push(sceneNum);
                         }
                     }
@@ -1136,22 +1422,22 @@ export async function executeRegenerateScene(options) {
                             if (waitResult.status === "completed" && waitResult.videoUrl) {
                                 const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
                                 await writeFile(videoPath, buffer);
-                                // Extend video to match narration duration if needed
-                                const targetDuration = segment.duration;
-                                const actualVideoDuration = await getVideoDuration(videoPath);
-                                if (actualVideoDuration < targetDuration - 0.1) {
-                                    const extendedPath = resolve(outputDir, `scene-${sceneNum}-extended.mp4`);
-                                    await extendVideoNaturally(videoPath, targetDuration, extendedPath);
-                                    await unlink(videoPath);
-                                    await rename(extendedPath, videoPath);
-                                }
+                                // Extend via extendVideoToTarget so Kling's own extend API can
+                                // be used for large gaps (ratio > 1.4) instead of freeze frames.
+                                await extendVideoToTarget(videoPath, segment.duration, outputDir, `Scene ${sceneNum}`, {
+                                    kling,
+                                    videoId: waitResult.videoId,
+                                    onProgress: options.onProgress,
+                                });
                                 result.regeneratedScenes.push(sceneNum);
                             }
                             else {
+                                logSceneFailure("Kling", `scene ${sceneNum}`, waitResult);
                                 result.failedScenes.push(sceneNum);
                             }
                         }
-                        catch {
+                        catch (err) {
+                            logSceneFailure("Kling", `scene ${sceneNum}`, err);
                             result.failedScenes.push(sceneNum);
                         }
                     }
@@ -1186,10 +1472,12 @@ export async function executeRegenerateScene(options) {
                                 result.regeneratedScenes.push(sceneNum);
                             }
                             else {
+                                logSceneFailure("Runway", `scene ${sceneNum}`, waitResult);
                                 result.failedScenes.push(sceneNum);
                             }
                         }
-                        catch {
+                        catch (err) {
+                            logSceneFailure("Runway", `scene ${sceneNum}`, err);
                             result.failedScenes.push(sceneNum);
                         }
                     }
@@ -1198,6 +1486,23 @@ export async function executeRegenerateScene(options) {
                     }
                 }
             }
+            else if (!sceneFailed) {
+                // narration-only / image-only / both: no video pass, so record success here
+                result.regeneratedScenes.push(sceneNum);
+            }
+        }
+        // Persist storyboard if narration regeneration changed segment durations.
+        // Preserve the on-disk format (yaml vs json) so no silent downgrades.
+        if (storyboardMutated) {
+            let currentTime = 0;
+            for (const segment of segments) {
+                segment.startTime = currentTime;
+                currentTime += segment.duration;
+            }
+            const serialized = storyboardPath.endsWith(".yaml")
+                ? yamlStringify({ scenes: segments }, { indent: 2 })
+                : JSON.stringify(segments, null, 2);
+            await writeFile(storyboardPath, serialized, "utf-8");
         }
         result.success = result.failedScenes.length === 0;
         return result;