@vibeframe/mcp-server 0.48.6 → 0.49.1

package/dist/index.js

@@ -6751,14 +6751,14 @@ var init_output = __esm({
       return ExitCode2;
     })(ExitCode || {});
     PROVIDER_ERROR_HINTS = [
+      // Billing (must precede the 429 rate-limit pattern)
+      { pattern: /402|payment.*required|billing|INSUFFICIENT_BALANCE|insufficient.*(credit|funds|balance)|balance.*(not.*enough|insufficient)|credits?.*exhausted|account.*balance/i, suggestion: "Account balance or credits exhausted. Top up at the provider dashboard, or try -p <other-provider>.", retryable: false },
       // Rate limits / quota
       { pattern: /429|rate.?limit|too many requests/i, suggestion: "Rate limited. Wait 30-60 seconds and retry, or check your plan's rate limits.", retryable: true },
       { pattern: /RESOURCE_EXHAUSTED|quota.*exceeded|requests.*per.*(minute|day)/i, suggestion: "Quota exceeded. Wait for the quota window to reset, or upgrade your plan. Consider -p <other-provider> to use a different provider.", retryable: true },
       // Auth
       { pattern: /401|unauthorized|(invalid|incorrect).*api.?key|invalid_api_key|authentication.*(failed|error)|missing.*api.?key|did not start with 'key_'/i, suggestion: "API key is invalid or expired. Run 'vibe setup' to update, or check the key at the provider's dashboard.", retryable: false },
       { pattern: /403|forbidden|permission.*denied/i, suggestion: "Access denied. Your API key may lack required permissions, or the feature requires a paid plan.", retryable: false },
-      // Billing
-      { pattern: /402|payment.*required|billing|INSUFFICIENT_BALANCE|insufficient.*(credit|funds|balance)|credits?.*exhausted/i, suggestion: "Account balance or credits exhausted. Top up at the provider dashboard, or try -p <other-provider>.", retryable: false },
       // Server
       { pattern: /500|internal.*error|server.*error/i, suggestion: "Provider server error. Retry in a few minutes.", retryable: true },
       { pattern: /503|service.*unavailable|overloaded|overloaded_error/i, suggestion: "Provider is temporarily overloaded. Retry in 1-2 minutes, or switch provider with -p.", retryable: true },
@@ -12835,7 +12835,7 @@ var require_previous_map = __commonJS({
   "../../node_modules/.pnpm/postcss@8.5.6/node_modules/postcss/lib/previous-map.js"(exports, module) {
     "use strict";
     var { existsSync: existsSync35, readFileSync: readFileSync11 } = __require("fs");
-    var { dirname: dirname20, join: join23 } = __require("path");
+    var { dirname: dirname21, join: join23 } = __require("path");
     var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     function fromBase64(str) {
       if (Buffer) {
@@ -12854,7 +12854,7 @@ var require_previous_map = __commonJS({
         if (!this.mapFile && opts.from) {
           this.mapFile = opts.from;
         }
-        if (this.mapFile) this.root = dirname20(this.mapFile);
+        if (this.mapFile) this.root = dirname21(this.mapFile);
         if (text) this.text = text;
       }
       consumer() {
@@ -12896,7 +12896,7 @@ var require_previous_map = __commonJS({
         }
       }
       loadFile(path15) {
-        this.root = dirname20(path15);
+        this.root = dirname21(path15);
         if (existsSync35(path15)) {
           this.mapFile = path15;
           return readFileSync11(path15, "utf-8").toString().trim();
@@ -12933,7 +12933,7 @@ var require_previous_map = __commonJS({
           return this.decodeInline(this.annotation);
         } else if (this.annotation) {
           let map3 = this.annotation;
-          if (file) map3 = join23(dirname20(file), map3);
+          if (file) map3 = join23(dirname21(file), map3);
           return this.loadFile(map3);
         }
       }
@@ -13369,12 +13369,12 @@ var require_fromJSON = __commonJS({
 var require_map_generator = __commonJS({
   "../../node_modules/.pnpm/postcss@8.5.6/node_modules/postcss/lib/map-generator.js"(exports, module) {
     "use strict";
-    var { dirname: dirname20, relative: relative4, resolve: resolve35, sep } = __require("path");
+    var { dirname: dirname21, relative: relative4, resolve: resolve35, sep } = __require("path");
     var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     var { pathToFileURL } = __require("url");
     var Input2 = require_input();
     var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
-    var pathAvailable = Boolean(dirname20 && resolve35 && relative4 && sep);
+    var pathAvailable = Boolean(dirname21 && resolve35 && relative4 && sep);
     var MapGenerator = class {
       constructor(stringify5, root2, opts, cssString) {
         this.stringify = stringify5;
@@ -13406,7 +13406,7 @@ var require_map_generator = __commonJS({
       applyPrevMaps() {
         for (let prev of this.previous()) {
           let from3 = this.toUrl(this.path(prev.file));
-          let root2 = prev.root || dirname20(prev.file);
+          let root2 = prev.root || dirname21(prev.file);
           let map3;
           if (this.mapOpts.sourcesContent === false) {
             map3 = new SourceMapConsumer(prev.text);
@@ -13593,9 +13593,9 @@ var require_map_generator = __commonJS({
         if (/^\w+:\/\//.test(file)) return file;
         let cached = this.memoizedPaths.get(file);
         if (cached) return cached;
-        let from3 = this.opts.to ? dirname20(this.opts.to) : ".";
+        let from3 = this.opts.to ? dirname21(this.opts.to) : ".";
         if (typeof this.mapOpts.annotation === "string") {
-          from3 = dirname20(resolve35(from3, this.mapOpts.annotation));
+          from3 = dirname21(resolve35(from3, this.mapOpts.annotation));
         }
         let path15 = relative4(from3, file);
         this.memoizedPaths.set(file, path15);
@@ -443791,7 +443791,7 @@ var init_ai_helpers = __esm({
 
 // ../cli/src/commands/ai-script-pipeline.ts
 import { readFile as readFile9, writeFile as writeFile10, mkdir as mkdir9, unlink as unlink4, rename as rename4 } from "node:fs/promises";
-import { resolve as resolve20, basename as basename7, extname as extname7 } from "node:path";
+import { resolve as resolve20, basename as basename7, dirname as dirname14, extname as extname7 } from "node:path";
 import { existsSync as existsSync25 } from "node:fs";
 function sleep(ms) {
   return new Promise((resolve35) => setTimeout(resolve35, ms));
@@ -443819,6 +443819,73 @@ async function uploadToImgbb(imageBuffer, apiKey) {
     return { success: false, error: String(err) };
   }
 }
+async function extendVideoToTarget(videoPath, targetDuration, outputDir, sceneLabel, options) {
+  const actualDuration = await getVideoDuration(videoPath);
+  if (actualDuration >= targetDuration - 0.1) return;
+  const ratio = targetDuration / actualDuration;
+  const extendedPath = resolve20(outputDir, `${basename7(videoPath, ".mp4")}-extended.mp4`);
+  if (ratio > 1.4 && options?.kling && options?.videoId) {
+    try {
+      options.onProgress?.(`${sceneLabel}: Extending via Kling API...`);
+      const extendResult = await options.kling.extendVideo(options.videoId, {
+        duration: "5"
+      });
+      if (extendResult.status !== "failed" && extendResult.id) {
+        const waitResult = await options.kling.waitForExtendCompletion(
+          extendResult.id,
+          (status) => {
+            options.onProgress?.(`${sceneLabel}: extend ${status.status}...`);
+          },
+          6e5
+        );
+        if (waitResult.status === "completed" && waitResult.videoUrl) {
+          const extendedVideoPath = resolve20(outputDir, `${basename7(videoPath, ".mp4")}-kling-ext.mp4`);
+          const buffer = await downloadVideo(waitResult.videoUrl);
+          await writeFile10(extendedVideoPath, buffer);
+          const concatPath = resolve20(outputDir, `${basename7(videoPath, ".mp4")}-concat.mp4`);
+          const listPath = resolve20(outputDir, `${basename7(videoPath, ".mp4")}-concat.txt`);
+          await writeFile10(listPath, `file '${videoPath}'
+file '${extendedVideoPath}'`, "utf-8");
+          await execSafe("ffmpeg", ["-y", "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", concatPath]);
+          const concatDuration = await getVideoDuration(concatPath);
+          if (concatDuration > targetDuration + 0.5) {
+            await execSafe("ffmpeg", ["-y", "-i", concatPath, "-t", targetDuration.toFixed(2), "-c", "copy", extendedPath]);
+            await unlink4(concatPath);
+          } else {
+            await rename4(concatPath, extendedPath);
+          }
+          await unlink4(extendedVideoPath).catch(() => {
+          });
+          await unlink4(listPath).catch(() => {
+          });
+          await unlink4(videoPath);
+          await rename4(extendedPath, videoPath);
+          return;
+        }
+      }
+      options.onProgress?.(`${sceneLabel}: Kling extend failed, using FFmpeg fallback...`);
+    } catch {
+      options.onProgress?.(`${sceneLabel}: Kling extend error, using FFmpeg fallback...`);
+    }
+  }
+  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+  await unlink4(videoPath);
+  await rename4(extendedPath, videoPath);
+}
+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(source_default.dim(`
+  [${provider} ${sceneLabel}: ${msg}]`));
+}
 async function generateVideoWithRetryGrok(grok, segment, options, maxRetries, onProgress) {
   const prompt3 = segment.visualStyle ? `${segment.visuals}. Style: ${segment.visualStyle}` : segment.visuals;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -443832,9 +443899,13 @@ async function generateVideoWithRetryGrok(grok, segment, options, maxRetries, on
       if (result.status !== "failed" && result.id) {
         return { requestId: result.id };
       }
+      const providerErr = result.error || "Grok returned failed status";
       if (attempt < maxRetries) {
-        onProgress?.(`\u26A0 Retry ${attempt + 1}/${maxRetries}...`);
+        onProgress?.(`\u26A0 ${providerErr.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
         await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(source_default.dim(`
+  [Grok error: ${providerErr}]`));
       }
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -443868,9 +443939,13 @@ async function generateVideoWithRetryKling(kling, segment, options, maxRetries,
           type: options.referenceImage ? "image2video" : "text2video"
         };
       }
+      const providerErr = result.error || "Kling returned failed status";
       if (attempt < maxRetries) {
-        onProgress?.(`\u26A0 Retry ${attempt + 1}/${maxRetries}...`);
+        onProgress?.(`\u26A0 ${providerErr.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
         await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(source_default.dim(`
+  [Kling error: ${providerErr}]`));
       }
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -443897,9 +443972,13 @@ async function generateVideoWithRetryRunway(runway, segment, referenceImage, opt
       if (result.status !== "failed" && result.id) {
         return { taskId: result.id };
       }
+      const providerErr = result.error || "Runway returned failed status";
       if (attempt < maxRetries) {
-        onProgress?.(`\u26A0 Retry ${attempt + 1}/${maxRetries}...`);
+        onProgress?.(`\u26A0 ${providerErr.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
         await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(source_default.dim(`
+  [Runway error: ${providerErr}]`));
       }
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -443928,9 +444007,13 @@ async function generateVideoWithRetryVeo(gemini, segment, options, maxRetries, o
       if (result.status !== "failed" && result.id) {
         return { operationName: result.id };
       }
+      const providerErr = result.error || "Veo returned failed status";
       if (attempt < maxRetries) {
-        onProgress?.(`\u26A0 Retry ${attempt + 1}/${maxRetries}...`);
+        onProgress?.(`\u26A0 ${providerErr.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
         await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(source_default.dim(`
+  [Veo error: ${providerErr}]`));
       }
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -444063,13 +444146,42 @@ async function executeScriptToVideo(options) {
           });
           continue;
         }
-        const ttsResult = await elevenlabs.textToSpeech(narrationText, {
+        const wordCount = narrationText.split(/\s+/).filter(Boolean).length;
+        const maxWords = segment.duration > 5 ? 24 : 12;
+        if (wordCount > maxWords * 1.3) {
+          options.onProgress?.(
+            `\u26A0 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 = resolve20(absOutputDir, `narration-${i + 1}.mp3`);
           await writeFile10(audioPath, ttsResult.audioBuffer);
-          const actualDuration = await getAudioDuration(audioPath);
+          let actualDuration = await getAudioDuration(audioPath);
+          const videoBracket = segment.duration > 5 ? 10 : 5;
+          const overageRatio = actualDuration / videoBracket;
+          if (overageRatio > 1 && 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 writeFile10(audioPath, speedResult.audioBuffer);
+              actualDuration = await getAudioDuration(audioPath);
+              ttsResult = speedResult;
+            }
+          } else if (overageRatio > 1.35) {
+            options.onProgress?.(
+              `\u26A0 Scene ${i + 1} narration is ${((overageRatio - 1) * 100).toFixed(0)}% over target (${actualDuration.toFixed(1)}s vs ${videoBracket}s bracket)`
+            );
+          }
           segment.duration = actualDuration;
           result.narrations.push(audioPath);
           result.narrationEntries.push({
@@ -444120,6 +444232,7 @@ async function executeScriptToVideo(options) {
     for (let i = 0; i < segments.length; i++) {
       const segment = segments[i];
       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;
@@ -444191,6 +444304,7 @@ 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)...`);
           const imageBuffer = await readFile9(imagePaths[i]);
           const ext = extname7(imagePaths[i]).toLowerCase().slice(1);
           const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
@@ -444219,10 +444333,12 @@ async function executeScriptToVideo(options) {
                 videoPaths.push(videoPath);
                 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);
             }
@@ -444237,6 +444353,24 @@ 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" };
         }
+        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 readFile9(imagePaths[i]);
+                const uploadResult = await uploadToImgbb(imageBuffer, imgbbApiKey);
+                if (uploadResult.success && uploadResult.url) {
+                  imageUrls[i] = uploadResult.url;
+                }
+              } catch {
+                imageUrls[i] = void 0;
+              }
+            }
+          }
+        }
         for (let i = 0; i < segments.length; i++) {
           if (!imagePaths[i]) {
             videoPaths.push("");
@@ -444244,10 +444378,15 @@ async function executeScriptToVideo(options) {
           }
           const segment = segments[i];
           const videoDuration = segment.duration > 5 ? 10 : 5;
+          options.onProgress?.(`Scene ${i + 1}/${segments.length}: generating video (kling)...`);
           const taskResult = await generateVideoWithRetryKling(
             kling,
             segment,
-            { duration: videoDuration, aspectRatio: options.aspectRatio || "16:9" },
+            {
+              duration: videoDuration,
+              aspectRatio: options.aspectRatio || "16:9",
+              referenceImage: imageUrls[i]
+            },
             maxRetries
           );
           if (taskResult) {
@@ -444257,21 +444396,26 @@ async function executeScriptToVideo(options) {
                 const videoPath = resolve20(absOutputDir, `scene-${i + 1}.mp4`);
                 const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
                 await writeFile10(videoPath, buffer);
-                const targetDuration = segment.duration;
-                const actualVideoDuration = await getVideoDuration(videoPath);
-                if (actualVideoDuration < targetDuration - 0.1) {
-                  const extendedPath = resolve20(absOutputDir, `scene-${i + 1}-extended.mp4`);
-                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
-                  await unlink4(videoPath);
-                  await rename4(extendedPath, videoPath);
-                }
+                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);
             }
@@ -444290,6 +444434,7 @@ 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,
@@ -444314,10 +444459,12 @@ async function executeScriptToVideo(options) {
                 videoPaths.push(videoPath);
                 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);
             }
@@ -444341,6 +444488,7 @@ 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,
@@ -444366,10 +444514,12 @@ async function executeScriptToVideo(options) {
                 videoPaths.push(videoPath);
                 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);
             }
@@ -444474,7 +444624,11 @@ async function executeScriptToVideo(options) {
       });
       currentTime += actualDuration;
     }
-    const projectPath = resolve20(absOutputDir, "project.vibe.json");
+    const projectPath = options.projectFilePath ? resolve20(process.cwd(), options.projectFilePath) : resolve20(absOutputDir, "project.vibe.json");
+    const projectParentDir = dirname14(projectPath);
+    if (!existsSync25(projectParentDir)) {
+      await mkdir9(projectParentDir, { recursive: true });
+    }
     await writeFile10(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
     result.projectPath = projectPath;
     result.totalDuration = currentTime;
@@ -444536,6 +444690,8 @@ 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;
     let videoApiKey;
     if (regenerateVideo) {
       const generatorKeyMap = {
@@ -444554,11 +444710,163 @@ 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) ?? void 0;
+      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") ?? void 0;
+      if (!elevenlabsApiKey) {
+        return { ...result, error: "ElevenLabs API key required. Run 'vibe setup' or set ELEVENLABS_API_KEY in .env" };
+      }
+    }
+    let storyboardMutated = false;
     for (const sceneNum of options.scenes) {
       const segment = segments[sceneNum - 1];
+      const narrationPath = resolve20(outputDir, `narration-${sceneNum}.mp3`);
       const imagePath = resolve20(outputDir, `scene-${sceneNum}.png`);
       const videoPath = resolve20(outputDir, `scene-${sceneNum}.mp4`);
+      let sceneFailed = false;
+      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 writeFile10(narrationPath, ttsResult.audioBuffer);
+          segment.duration = await getAudioDuration(narrationPath);
+          storyboardMutated = true;
+        } else {
+          sceneFailed = true;
+        }
+      }
+      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}
+
+IMPORTANT - Character appearance must match exactly: ${characterDesc}`;
+        }
+        let referenceImageBuffer;
+        const refSceneNum = options.referenceScene;
+        if (refSceneNum && refSceneNum >= 1 && refSceneNum <= segments.length && refSceneNum !== sceneNum) {
+          const refImagePath = resolve20(outputDir, `scene-${refSceneNum}.png`);
+          if (existsSync25(refImagePath)) {
+            referenceImageBuffer = await readFile9(refImagePath);
+          }
+        } else if (!refSceneNum) {
+          for (let i = 1; i <= segments.length; i++) {
+            if (i !== sceneNum) {
+              const otherImagePath = resolve20(outputDir, `scene-${i}.png`);
+              if (existsSync25(otherImagePath)) {
+                referenceImageBuffer = await readFile9(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) {
+            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 writeFile10(imagePath, imageBuffer);
+        } else if (imageUrl) {
+          const response = await fetch(imageUrl);
+          const buffer = Buffer.from(await response.arrayBuffer());
+          await writeFile10(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 (!existsSync25(imagePath)) {
           result.failedScenes.push(sceneNum);
           continue;
@@ -444599,9 +444907,11 @@ 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);
             }
           } else {
@@ -444640,9 +444950,11 @@ 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);
             }
           } else {
@@ -444679,19 +444991,24 @@ async function executeRegenerateScene(options) {
               if (waitResult.status === "completed" && waitResult.videoUrl) {
                 const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
                 await writeFile10(videoPath, buffer);
-                const targetDuration = segment.duration;
-                const actualVideoDuration = await getVideoDuration(videoPath);
-                if (actualVideoDuration < targetDuration - 0.1) {
-                  const extendedPath = resolve20(outputDir, `scene-${sceneNum}-extended.mp4`);
-                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
-                  await unlink4(videoPath);
-                  await rename4(extendedPath, videoPath);
-                }
+                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);
             }
           } else {
@@ -444727,16 +445044,29 @@ 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);
             }
           } else {
             result.failedScenes.push(sceneNum);
           }
         }
+      } else if (!sceneFailed) {
+        result.regeneratedScenes.push(sceneNum);
+      }
+    }
+    if (storyboardMutated) {
+      let currentTime = 0;
+      for (const segment of segments) {
+        segment.startTime = currentTime;
+        currentTime += segment.duration;
       }
+      const serialized = storyboardPath.endsWith(".yaml") ? (0, import_yaml2.stringify)({ scenes: segments }, { indent: 2 }) : JSON.stringify(segments, null, 2);
+      await writeFile10(storyboardPath, serialized, "utf-8");
     }
     result.success = result.failedScenes.length === 0;
     return result;
@@ -447094,7 +447424,7 @@ __export(generate_exports, {
   executeStoryboard: () => executeStoryboard,
   generateCommand: () => generateCommand
 });
-import { resolve as resolve25, dirname as dirname15, basename as basename9, extname as extname9 } from "node:path";
+import { resolve as resolve25, dirname as dirname16, basename as basename9, extname as extname9 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { readFile as readFile13, writeFile as writeFile14, mkdir as mkdir11 } from "node:fs/promises";
 import { existsSync as existsSync28 } from "node:fs";
@@ -447360,7 +447690,7 @@ Examples:
               } else {
                 throw new Error("No image data available");
               }
-              await mkdir11(dirname15(outputPath), { recursive: true });
+              await mkdir11(dirname16(outputPath), { recursive: true });
               await writeFile14(outputPath, buffer);
             }
             outputResult({ success: true, provider: "openai", images: result.images.map((img) => ({ url: img.url, revisedPrompt: img.revisedPrompt })), outputPath });
@@ -447396,7 +447726,7 @@ Examples:
                 throw new Error("No image data available");
               }
               const outputPath = resolve25(process.cwd(), options.output);
-              await mkdir11(dirname15(outputPath), { recursive: true });
+              await mkdir11(dirname16(outputPath), { recursive: true });
               await writeFile14(outputPath, buffer);
               saveSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
             } catch (err) {
@@ -447446,7 +447776,7 @@ Examples:
             if (outputPath && result.images.length > 0) {
               const img = result.images[0];
               const buffer = Buffer.from(img.base64, "base64");
-              await mkdir11(dirname15(outputPath), { recursive: true });
+              await mkdir11(dirname16(outputPath), { recursive: true });
               await writeFile14(outputPath, buffer);
             }
             outputResult({ success: true, provider: "gemini", images: result.images.map((img) => ({ mimeType: img.mimeType })), outputPath });
@@ -447467,7 +447797,7 @@ Examples:
               const img = result.images[0];
               const buffer = Buffer.from(img.base64, "base64");
               const outputPath = resolve25(process.cwd(), options.output);
-              await mkdir11(dirname15(outputPath), { recursive: true });
+              await mkdir11(dirname16(outputPath), { recursive: true });
               await writeFile14(outputPath, buffer);
               saveSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
             } catch (err) {
@@ -447506,7 +447836,7 @@ Examples:
               } else {
                 throw new Error("No image data available");
               }
-              await mkdir11(dirname15(outputPath), { recursive: true });
+              await mkdir11(dirname16(outputPath), { recursive: true });
               await writeFile14(outputPath, buffer);
             }
             outputResult({ success: true, provider: "grok", images: result.images.map((img) => ({ url: img.url })), outputPath });
@@ -447539,7 +447869,7 @@ Examples:
                 throw new Error("No image data available");
               }
               const outputPath = resolve25(process.cwd(), options.output);
-              await mkdir11(dirname15(outputPath), { recursive: true });
+              await mkdir11(dirname16(outputPath), { recursive: true });
               await writeFile14(outputPath, buffer);
               saveSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
             } catch (err) {
@@ -447549,7 +447879,7 @@ Examples:
         } else if (provider === "runway") {
           const { spawn: spawn10 } = await import("child_process");
           const __filename2 = fileURLToPath5(import.meta.url);
-          const __dirname3 = dirname15(__filename2);
+          const __dirname3 = dirname16(__filename2);
           const scriptPath = resolve25(__dirname3, "../../../../.claude/skills/runway-video/scripts/image.py");
           if (!options.output) {
             spinner2.fail("Output path required for Runway");
@@ -448344,7 +448674,7 @@ Examples:
               throw new Error("No image data available");
             }
             outputPath = resolve25(process.cwd(), options.output);
-            await mkdir11(dirname15(outputPath), { recursive: true });
+            await mkdir11(dirname16(outputPath), { recursive: true });
             await writeFile14(outputPath, buffer);
           }
           outputResult({ success: true, imageUrl: img.url, outputPath });
@@ -448371,7 +448701,7 @@ Examples:
               throw new Error("No image data available");
             }
             const outputPath = resolve25(process.cwd(), options.output);
-            await mkdir11(dirname15(outputPath), { recursive: true });
+            await mkdir11(dirname16(outputPath), { recursive: true });
             await writeFile14(outputPath, buffer);
             saveSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
           } catch (err) {
@@ -448417,7 +448747,7 @@ Examples:
               throw new Error("No image data available");
             }
             outputPath = resolve25(process.cwd(), options.output);
-            await mkdir11(dirname15(outputPath), { recursive: true });
+            await mkdir11(dirname16(outputPath), { recursive: true });
             await writeFile14(outputPath, buffer);
           }
           outputResult({ success: true, imageUrl: img.url, outputPath });
@@ -448444,7 +448774,7 @@ Examples:
               throw new Error("No image data available");
             }
             const outputPath = resolve25(process.cwd(), options.output);
-            await mkdir11(dirname15(outputPath), { recursive: true });
+            await mkdir11(dirname16(outputPath), { recursive: true });
             await writeFile14(outputPath, buffer);
             saveSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
           } catch (err) {
@@ -449316,7 +449646,7 @@ var init_ai_edit_cli = __esm({
 
 // ../cli/src/commands/ai-fill-gaps.ts
 import { readFile as readFile14, writeFile as writeFile15, mkdir as mkdir12 } from "node:fs/promises";
-import { resolve as resolve27, dirname as dirname16 } from "node:path";
+import { resolve as resolve27, dirname as dirname17 } from "node:path";
 import { existsSync as existsSync30 } from "node:fs";
 function detectVideoGaps(videoClips, totalDuration) {
   const gaps = [];
@@ -449460,7 +449790,7 @@ function registerFillGapsCommand(aiCommand) {
       if (!kling.isConfigured()) {
         exitWithError(authError("KLING_API_KEY", "Kling"));
       }
-      const projectDir = dirname16(filePath);
+      const projectDir = dirname17(filePath);
       const footageDir = options.dir ? resolve27(process.cwd(), options.dir) : resolve27(projectDir, "footage");
       if (!existsSync30(footageDir)) {
         await mkdir12(footageDir, { recursive: true });
@@ -449709,7 +450039,7 @@ __export(edit_cmd_exports, {
   executeSpeedRamp: () => executeSpeedRamp,
   executeUpscale: () => executeUpscale
 });
-import { resolve as resolve28, dirname as dirname17 } from "node:path";
+import { resolve as resolve28, dirname as dirname18 } from "node:path";
 import { readFile as readFile15, writeFile as writeFile16, mkdir as mkdir13 } from "node:fs/promises";
 async function executeGrade(options) {
   const { videoPath, style, preset, output: output3, analyzeOnly, apiKey } = options;
@@ -450421,7 +450751,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         const img = result.images[0];
         const outputPath = resolve28(process.cwd(), options.output);
         const saveImage = async () => {
-          await mkdir13(dirname17(outputPath), { recursive: true });
+          await mkdir13(dirname18(outputPath), { recursive: true });
           if (img.base64) {
             const buffer = Buffer.from(img.base64, "base64");
             await writeFile16(outputPath, buffer);
@@ -450612,7 +450942,7 @@ __export(ai_audio_exports, {
   executeVoiceClone: () => executeVoiceClone,
   registerAudioCommands: () => registerAudioCommands
 });
-import { resolve as resolve29, dirname as dirname18, basename as basename11, extname as extname11 } from "node:path";
+import { resolve as resolve29, dirname as dirname19, basename as basename11, extname as extname11 } from "node:path";
 import { readFile as readFile16, writeFile as writeFile17 } from "node:fs/promises";
 import { existsSync as existsSync31 } from "node:fs";
 function _registerAudioCommands(aiCommand) {
@@ -451068,7 +451398,7 @@ function _registerAudioCommands(aiCommand) {
       const isVideo = [".mp4", ".mov", ".avi", ".mkv", ".webm"].includes(ext);
       let audioPath = absPath;
       if (isVideo) {
-        const tempAudioPath = resolve29(dirname18(absPath), `temp-audio-${Date.now()}.mp3`);
+        const tempAudioPath = resolve29(dirname19(absPath), `temp-audio-${Date.now()}.mp3`);
         try {
           execSafeSync("ffmpeg", ["-i", absPath, "-vn", "-acodec", "mp3", "-y", tempAudioPath]);
           audioPath = tempAudioPath;
@@ -451200,7 +451530,7 @@ ${segmentTexts}`,
       const combinedBuffer = Buffer.concat(dubbedAudioBuffers.map((a) => a.buffer));
       const outputExt = isVideo ? ".mp3" : extname11(absPath);
       const defaultOutputPath = resolve29(
-        dirname18(absPath),
+        dirname19(absPath),
         `${basename11(absPath, extname11(absPath))}-${options.language}${outputExt}`
       );
       const finalOutputPath = resolve29(process.cwd(), options.output || defaultOutputPath);
@@ -451363,7 +451693,7 @@ async function executeDub(options) {
     const isVideo = [".mp4", ".mov", ".avi", ".mkv", ".webm"].includes(ext);
     let audioPath = absPath;
     if (isVideo) {
-      const tempAudioPath = resolve29(dirname18(absPath), `temp-audio-${Date.now()}.mp3`);
+      const tempAudioPath = resolve29(dirname19(absPath), `temp-audio-${Date.now()}.mp3`);
       execSafeSync("ffmpeg", ["-i", absPath, "-vn", "-acodec", "mp3", "-y", tempAudioPath]);
       audioPath = tempAudioPath;
     }
@@ -451445,7 +451775,7 @@ ${segmentTexts}`,
     }
     const combinedBuffer = Buffer.concat(dubbedBuffers);
     const outputExt = isVideo ? ".mp3" : extname11(absPath);
-    const defaultOutputPath = resolve29(dirname18(absPath), `${basename11(absPath, extname11(absPath))}-${language}${outputExt}`);
+    const defaultOutputPath = resolve29(dirname19(absPath), `${basename11(absPath, extname11(absPath))}-${language}${outputExt}`);
     const finalOutputPath = resolve29(process.cwd(), output3 || defaultOutputPath);
     await writeFile17(finalOutputPath, combinedBuffer);
     if (isVideo && audioPath !== absPath) {
@@ -451482,7 +451812,7 @@ async function executeDuck(options) {
     const absVoicePath = resolve29(process.cwd(), voicePath);
     if (!existsSync31(absMusicPath)) return { success: false, error: `Music file not found: ${absMusicPath}` };
     if (!existsSync31(absVoicePath)) return { success: false, error: `Voice file not found: ${absVoicePath}` };
-    const defaultOutput = resolve29(dirname18(absMusicPath), `${basename11(absMusicPath, extname11(absMusicPath))}-ducked${extname11(absMusicPath)}`);
+    const defaultOutput = resolve29(dirname19(absMusicPath), `${basename11(absMusicPath, extname11(absMusicPath))}-ducked${extname11(absMusicPath)}`);
     const outputPath = resolve29(process.cwd(), output3 || defaultOutput);
     const filter4 = `[1:a]asplit=2[sc][mix];[0:a][sc]sidechaincompress=threshold=${threshold}dB:ratio=${ratio}:attack=${attack}:release=${release}[ducked];[ducked][mix]amix=inputs=2:duration=longest`;
     await execSafe("ffmpeg", [
@@ -453637,7 +453967,7 @@ import { join as join21 } from "node:path";
 
 // ../cli/src/commands/ai-highlights.ts
 import { readFile as readFile10, writeFile as writeFile11, mkdir as mkdir10 } from "node:fs/promises";
-import { resolve as resolve21, dirname as dirname14, basename as basename8, extname as extname8 } from "node:path";
+import { resolve as resolve21, dirname as dirname15, basename as basename8, extname as extname8 } from "node:path";
 import { existsSync as existsSync26 } from "node:fs";
 init_dist2();
 init_engine();
@@ -453999,7 +454329,7 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
         }))
       };
     }
-    const outputDir = options.outputDir ? resolve21(process.cwd(), options.outputDir) : dirname14(absPath);
+    const outputDir = options.outputDir ? resolve21(process.cwd(), options.outputDir) : dirname15(absPath);
     if (options.outputDir && !existsSync26(outputDir)) {
       await mkdir10(outputDir, { recursive: true });
     }
@@ -454785,7 +455115,7 @@ init_ai_edit();
 init_api_key();
 init_exec_safe();
 init_remotion();
-import { resolve as resolve33, dirname as dirname19, basename as basename13 } from "node:path";
+import { resolve as resolve33, dirname as dirname20, basename as basename13 } from "node:path";
 import { writeFile as writeFile21, mkdir as mkdir15, rm as rm5 } from "node:fs/promises";
 import { existsSync as existsSync34 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
@@ -454967,7 +455297,7 @@ async function executeAnimatedCaption(options) {
     }
     const groups = groupWords(transcript.words, { wordsPerGroup, maxChars });
     const absOutputPath = resolve33(process.cwd(), outputPath);
-    const outDir = dirname19(absOutputPath);
+    const outDir = dirname20(absOutputPath);
     if (!existsSync34(outDir)) {
       await mkdir15(outDir, { recursive: true });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeframe/mcp-server",
-  "version": "0.48.6",
+  "version": "0.49.1",
   "description": "VibeFrame MCP Server - AI-native video editing via Model Context Protocol",
   "type": "module",
   "bin": {
@@ -57,8 +57,8 @@
     "tsx": "^4.21.0",
     "typescript": "^5.3.3",
     "vitest": "^1.2.2",
-    "@vibeframe/cli": "0.48.6",
-    "@vibeframe/core": "0.48.6"
+    "@vibeframe/cli": "0.49.1",
+    "@vibeframe/core": "0.49.1"
   },
   "engines": {
     "node": ">=20"