@vibeframe/cli 0.91.9 → 0.92.0

package/dist/index.js

@@ -14443,8 +14443,8 @@ var init_api_keys = __esm({
       configKey: "imgbb",
       envVar: "IMGBB_API_KEY",
       label: "ImgBB",
-      showInSetup: false,
-      // not prompted in setup wizard — internal upload host
+      showInSetup: true,
+      setupDescription: "image hosting for Seedance/Kling image-to-video uploads",
       envExampleComment: "ImgBB API Key (image hosting \u2014 used by Kling and Seedance for image-to-video uploads)",
       envExampleUrl: "https://api.imgbb.com/",
       // ImgBB issues 32-character lowercase hex keys. Soft-warn if a pasted
@@ -14453,9 +14453,7 @@ var init_api_keys = __esm({
       keyFormat: { prefix: /^[a-f0-9]{32}$/, example: "32-char hex" },
       // ImgBB has no provider class (envvar-only); doctor still shows what it
       // unlocks at the apiKey level.
-      commandsUnlocked: [
-        "generate video -p kling/seedance (image-to-video upload host)"
-      ]
+      commandsUnlocked: ["generate video -p kling/seedance (image-to-video upload host)"]
     });
     defineProvider({
       id: "openrouter",
@@ -25677,6 +25675,13 @@ function createDefaultConfig() {
       aspectRatio: "16:9",
       exportQuality: "standard"
     },
+    upload: {
+      provider: "imgbb",
+      ttlSeconds: 3600,
+      s3: {
+        prefix: "vibeframe/tmp"
+      }
+    },
     repl: {
       autoSave: true
     }
@@ -25700,6 +25705,26 @@ var init_schema = __esm({
 });
 
 // src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  CONFIG_DIR: () => CONFIG_DIR,
+  CONFIG_PATH: () => CONFIG_PATH,
+  PROVIDER_ENV_VARS: () => PROVIDER_ENV_VARS,
+  PROVIDER_NAMES: () => PROVIDER_NAMES,
+  USER_CONFIG_DIR: () => USER_CONFIG_DIR,
+  USER_CONFIG_PATH: () => USER_CONFIG_PATH,
+  createDefaultConfig: () => createDefaultConfig,
+  getActiveScope: () => getActiveScope,
+  getApiKeyFromConfig: () => getApiKeyFromConfig,
+  getConfigDir: () => getConfigDir,
+  getConfigPath: () => getConfigPath,
+  getProjectConfigDir: () => getProjectConfigDir,
+  getProjectConfigPath: () => getProjectConfigPath,
+  isConfigured: () => isConfigured,
+  loadConfig: () => loadConfig,
+  saveConfig: () => saveConfig,
+  updateProviderKey: () => updateProviderKey
+});
 import { resolve as resolve4 } from "node:path";
 import { homedir } from "node:os";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access as access2 } from "node:fs/promises";
@@ -25734,6 +25759,11 @@ function applyDefaults(parsed) {
     llm: { ...defaults.llm, ...parsed.llm },
     providers: { ...defaults.providers, ...parsed.providers },
     defaults: { ...defaults.defaults, ...parsed.defaults },
+    upload: {
+      ...defaults.upload,
+      ...parsed.upload,
+      s3: { ...defaults.upload.s3, ...parsed.upload?.s3 }
+    },
     repl: { ...defaults.repl, ...parsed.repl }
   };
 }
@@ -25761,6 +25791,11 @@ async function loadConfig(options = {}) {
       llm: { ...user.llm, ...project2.llm },
       providers: { ...user.providers, ...project2.providers },
       defaults: { ...user.defaults, ...project2.defaults },
+      upload: {
+        ...user.upload,
+        ...project2.upload,
+        s3: { ...user.upload.s3, ...project2.upload.s3 }
+      },
       repl: { ...user.repl, ...project2.repl }
     };
   }
@@ -25802,7 +25837,14 @@ async function getApiKeyFromConfig(providerKey) {
   if (envVar) return process.env[envVar];
   return void 0;
 }
-var import_yaml, USER_CONFIG_DIR, USER_CONFIG_PATH, CONFIG_PATH;
+async function updateProviderKey(providerKey, apiKey, options = {}) {
+  const scope = options.scope ?? await getActiveScope(options.cwd);
+  let config2 = await loadConfig({ scope, cwd: options.cwd });
+  if (!config2) config2 = createDefaultConfig();
+  config2.providers[providerKey] = apiKey;
+  await saveConfig(config2, { scope, cwd: options.cwd });
+}
+var import_yaml, USER_CONFIG_DIR, USER_CONFIG_PATH, CONFIG_DIR, CONFIG_PATH;
 var init_config = __esm({
   "src/config/index.ts"() {
     "use strict";
@@ -25811,6 +25853,7 @@ var init_config = __esm({
     init_schema();
     USER_CONFIG_DIR = resolve4(homedir(), ".vibeframe");
     USER_CONFIG_PATH = resolve4(USER_CONFIG_DIR, "config.yaml");
+    CONFIG_DIR = USER_CONFIG_DIR;
     CONFIG_PATH = USER_CONFIG_PATH;
   }
 });
@@ -25910,7 +25953,9 @@ async function getApiKey(envVar, providerName, optionValue) {
   }
   console.log();
   console.log(source_default.yellow(`${providerName} API key not found.`));
-  console.log(source_default.dim(`Set ${envVar} in .env (current directory), run 'vibe setup', or enter below.`));
+  console.log(
+    source_default.dim(`Set ${envVar} in .env (current directory), run 'vibe setup', or enter below.`)
+  );
   console.log();
   const apiKey = await prompt(source_default.cyan(`Enter ${providerName} API key: `), true);
   if (!apiKey || apiKey.trim() === "") {
@@ -25969,7 +26014,8 @@ var init_api_key = __esm({
       ELEVENLABS_API_KEY: "https://elevenlabs.io/app/settings/api-keys",
       RUNWAY_API_SECRET: "https://app.runwayml.com/settings/api-keys",
       KLING_API_KEY: "https://klingai.com/dev",
-      REPLICATE_API_TOKEN: "https://replicate.com/account/api-tokens"
+      REPLICATE_API_TOKEN: "https://replicate.com/account/api-tokens",
+      IMGBB_API_KEY: "https://api.imgbb.com/"
     };
     ApiKeyError = class extends Error {
       envVar;
@@ -33353,29 +33399,61 @@ var init_video_extend = __esm({
 });
 
 // src/utils/provider-resolver.ts
+function loadProviderDefaultsFromConfig(config2) {
+  configDefaults = {};
+  if (config2?.defaults.imageProvider) configDefaults.image = config2.defaults.imageProvider;
+  if (config2?.defaults.videoProvider) configDefaults.video = config2.defaults.videoProvider;
+  configProviderKeys = new Set(
+    Object.entries(config2?.providers ?? {}).filter(([, value]) => Boolean(value)).map(([key]) => key)
+  );
+}
+async function loadProviderDefaults() {
+  try {
+    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig2();
+    loadProviderDefaultsFromConfig(config2);
+  } catch {
+    configDefaults = null;
+    configProviderKeys = null;
+  }
+}
+function providerKeyForEnvVar(envVar) {
+  const envVars = getProviderEnvVars();
+  for (const [providerKey, candidateEnvVar] of Object.entries(envVars)) {
+    if (candidateEnvVar === envVar) return providerKey;
+  }
+  return null;
+}
+function hasCandidateKey(candidate) {
+  if (candidate.envVar === null) return true;
+  if (hasApiKey(candidate.envVar)) return true;
+  const providerKey = providerKeyForEnvVar(candidate.envVar);
+  return providerKey ? Boolean(configProviderKeys?.has(providerKey)) : false;
+}
 function resolveProvider(category) {
   const candidates = getProvidersFor(category);
   if (candidates.length === 0) return null;
   if (configDefaults?.[category]) {
     const preferred = candidates.find((c) => c.name === configDefaults[category]);
-    if (preferred && (preferred.envVar === null || hasApiKey(preferred.envVar))) {
+    if (preferred && hasCandidateKey(preferred)) {
       return { name: preferred.name, label: preferred.label };
     }
   }
   for (const candidate of candidates) {
-    if (candidate.envVar === null || hasApiKey(candidate.envVar)) {
+    if (hasCandidateKey(candidate)) {
       return { name: candidate.name, label: candidate.label };
     }
   }
   return null;
 }
-var configDefaults;
+var configDefaults, configProviderKeys;
 var init_provider_resolver = __esm({
   "src/utils/provider-resolver.ts"() {
     "use strict";
     init_dist2();
     init_api_key();
     configDefaults = null;
+    configProviderKeys = null;
   }
 });
 
@@ -33412,13 +33490,26 @@ import { resolve as resolve23, dirname as dirname7 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { writeFile as writeFile21, mkdir as mkdir11 } from "node:fs/promises";
 function registerImageCommand(parent) {
-  parent.command("image").alias("img").description("Generate image using AI (Gemini, OpenAI gpt-image, Grok, or Runway)").argument("[prompt]", "Image description prompt (interactive if omitted)").option("-p, --provider <provider>", "Provider: openai (default when OPENAI_API_KEY set), gemini, grok, runway").option("-k, --api-key <key>", "API key (or set env: OPENAI_API_KEY, GOOGLE_API_KEY)").option("-o, --output <path>", "Output file path (downloads image)").option("--size <size>", "Image size (openai: 1024x1024, 1536x1024, 1024x1536)", "1024x1024").option("-r, --ratio <ratio>", "Aspect ratio (gemini: 1:1, 1:4, 1:8, 4:1, 8:1, 16:9, 9:16, 3:4, 4:3, etc.)", "1:1").option("--quality <quality>", "Quality: standard, hd (openai only)", "standard").option("--style <style>", "Style: vivid, natural (openai only)", "vivid").option("--count <n>", "Number of images to generate", "1").option("-m, --model <model>", "Model. Gemini: flash, 3.1-flash, latest, pro. OpenAI: 1.5 (default), 2 (gpt-image-2)").option("--dry-run", "Preview parameters without executing").addHelpText("after", `
+  parent.command("image").alias("img").description("Generate image using AI (Gemini, OpenAI gpt-image, Grok, or Runway)").argument("[prompt]", "Image description prompt (interactive if omitted)").option(
+    "-p, --provider <provider>",
+    "Provider: openai (default when OPENAI_API_KEY set), gemini, grok, runway"
+  ).option("-k, --api-key <key>", "API key (or set env: OPENAI_API_KEY, GOOGLE_API_KEY)").option("-o, --output <path>", "Output file path (downloads image)").option("--size <size>", "Image size (openai: 1024x1024, 1536x1024, 1024x1536)", "1024x1024").option(
+    "-r, --ratio <ratio>",
+    "Aspect ratio (gemini: 1:1, 1:4, 1:8, 4:1, 8:1, 16:9, 9:16, 3:4, 4:3, etc.)",
+    "1:1"
+  ).option("--quality <quality>", "Quality: standard, hd (openai only)", "standard").option("--style <style>", "Style: vivid, natural (openai only)", "vivid").option("--count <n>", "Number of images to generate", "1").option(
+    "-m, --model <model>",
+    "Model. Gemini: flash, 3.1-flash, latest, pro. OpenAI: 1.5 (default), 2 (gpt-image-2)"
+  ).option("--dry-run", "Preview parameters without executing").addHelpText(
+    "after",
+    `
 Examples:
   $ vibe generate image "a sunset over the ocean" -o sunset.png
   $ vibe gen img "logo design" -o logo.png -p openai
   $ vibe gen img "landscape photo" -o wide.png -r 16:9
   $ vibe gen img "portrait" -o portrait.png -p gemini -m pro
-  $ vibe gen img "product shot" --dry-run --json`).action(async (prompt3, options) => {
+  $ vibe gen img "product shot" --dry-run --json`
+  ).action(async (prompt3, options) => {
     const startedAt = Date.now();
     try {
       if (!prompt3) {
@@ -33429,10 +33520,7 @@ Examples:
           }
         } else {
           exitWithError(
-            usageError(
-              "Prompt argument is required.",
-              "Usage: vibe generate image <prompt>"
-            )
+            usageError("Prompt argument is required.", "Usage: vibe generate image <prompt>")
           );
         }
       }
@@ -33440,13 +33528,16 @@ Examples:
       if (options.output) {
         validateOutputPath(options.output);
       }
+      await loadProviderDefaults();
       if (options.count !== void 0) {
         const n = parseInt(options.count, 10);
         if (!Number.isFinite(n) || n < 1 || n > 10) {
-          exitWithError(usageError(
-            `Invalid --count: ${options.count}`,
-            "Must be an integer between 1 and 10."
-          ));
+          exitWithError(
+            usageError(
+              `Invalid --count: ${options.count}`,
+              "Must be an integer between 1 and 10."
+            )
+          );
         }
       }
       const imageRegistry = getProvidersFor("image");
@@ -33511,11 +33602,9 @@ Examples:
       const apiKey = await requireApiKey(envKey, providerName, options.apiKey);
       const spinner2 = ora(`Generating image with ${providerName}...`).start();
       if (provider === "openai") {
-        const { result, modelLabel } = await executeOpenAIImageGenerate(
-          prompt3,
-          options,
-          { apiKey }
-        );
+        const { result, modelLabel } = await executeOpenAIImageGenerate(prompt3, options, {
+          apiKey
+        });
         if (!result.success || !result.images) {
           spinner2.fail(result.error || "Image generation failed");
           exitWithError(apiError(result.error || "Image generation failed", true));
@@ -33737,9 +33826,7 @@ Examples:
           spinner2.fail(result.error || "Image generation failed");
           exitWithError(apiError(result.error || "Image generation failed", true));
         }
-        spinner2.succeed(
-          source_default.green(`Generated ${result.images.length} image(s) with xAI Grok`)
-        );
+        spinner2.succeed(source_default.green(`Generated ${result.images.length} image(s) with xAI Grok`));
         if (isJsonMode()) {
           const outputPath = options.output ? resolve23(process.cwd(), options.output) : void 0;
           if (outputPath && result.images.length > 0) {
@@ -34972,606 +35059,206 @@ var init_video_utils = __esm({
   }
 });
 
-// src/commands/_shared/video-providers.ts
-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++) {
-    try {
-      const result = await grok.generateVideo(prompt3, {
-        prompt: prompt3,
-        duration: options.duration,
-        aspectRatio: options.aspectRatio,
-        referenceImage: options.referenceImage
-      });
-      if (result.status !== "failed" && result.id) {
-        return { requestId: result.id };
-      }
-      const providerErr = result.error || "Grok returned failed status";
-      if (attempt < 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);
-      if (attempt < maxRetries) {
-        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
-        await sleep(RETRY_DELAY_MS);
-      } else {
-        console.error(source_default.dim(`
-  [Grok error: ${errMsg}]`));
-      }
-    }
-  }
-  return null;
+// src/utils/upload-host.ts
+import { createHash as createHash4, createHmac as createHmac2, randomUUID } from "node:crypto";
+import { extname as extname3 } from "node:path";
+function envNumber(name) {
+  const value = process.env[name];
+  if (!value) return void 0;
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
 }
-async function generateVideoWithRetryKling(kling, segment, options, maxRetries, onProgress) {
-  const prompt3 = segment.visualStyle ? `${segment.visuals}. Style: ${segment.visualStyle}` : segment.visuals;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      const result = await kling.generateVideo(prompt3, {
-        prompt: prompt3,
-        // Pass reference image (base64 or URL) - KlingProvider handles v1.5 fallback for base64
-        referenceImage: options.referenceImage,
-        duration: options.duration,
-        aspectRatio: options.aspectRatio,
-        mode: "std"
-        // std mode for faster generation
-      });
-      if (result.status !== "failed" && result.id) {
-        return {
-          taskId: result.id,
-          type: options.referenceImage ? "image2video" : "text2video"
-        };
-      }
-      const providerErr = result.error || "Kling returned failed status";
-      if (attempt < 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);
-      if (attempt < maxRetries) {
-        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
-        await sleep(RETRY_DELAY_MS);
-      } else {
-        console.error(source_default.dim(`
-  [Kling error: ${errMsg}]`));
-      }
-    }
-  }
-  return null;
+function safePrefix(prefix) {
+  return (prefix ?? "vibeframe/tmp").replace(/^\/+|\/+$/g, "");
 }
-async function generateVideoWithRetryRunway(runway, segment, referenceImage, options, maxRetries, onProgress) {
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      const result = await runway.generateVideo(segment.visuals, {
-        prompt: segment.visuals,
-        referenceImage,
-        duration: options.duration,
-        aspectRatio: options.aspectRatio
-      });
-      if (result.status !== "failed" && result.id) {
-        return { taskId: result.id };
-      }
-      const providerErr = result.error || "Runway returned failed status";
-      if (attempt < 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);
-      if (attempt < maxRetries) {
-        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
-        await sleep(RETRY_DELAY_MS);
-      } else {
-        console.error(source_default.dim(`
-  [Runway error: ${errMsg}]`));
-      }
-    }
-  }
-  return null;
+function extensionFor(opts) {
+  const fromName = opts?.filename ? extname3(opts.filename).replace(/^\./, "") : "";
+  if (fromName) return fromName.toLowerCase();
+  const mime = opts?.mimeType ?? "image/png";
+  if (mime === "image/jpeg") return "jpg";
+  if (mime === "image/webp") return "webp";
+  if (mime === "image/gif") return "gif";
+  return "png";
 }
-async function generateVideoWithRetryVeo(gemini, segment, options, maxRetries, onProgress) {
-  const prompt3 = segment.visualStyle ? `${segment.visuals}. Style: ${segment.visualStyle}` : segment.visuals;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      const result = await gemini.generateVideo(prompt3, {
-        prompt: prompt3,
-        referenceImage: options.referenceImage,
-        duration: options.duration,
-        aspectRatio: options.aspectRatio,
-        model: "veo-3.1-fast-generate-preview"
-      });
-      if (result.status !== "failed" && result.id) {
-        return { operationName: result.id };
-      }
-      const providerErr = result.error || "Veo returned failed status";
-      if (attempt < 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);
-      if (attempt < maxRetries) {
-        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
-        await sleep(RETRY_DELAY_MS);
-      } else {
-        console.error(source_default.dim(`
-  [Veo error: ${errMsg}]`));
-      }
-    }
-  }
-  return null;
+function hmac(key, value) {
+  return createHmac2("sha256", key).update(value).digest();
 }
-var init_video_providers = __esm({
-  "src/commands/_shared/video-providers.ts"() {
-    "use strict";
-    init_source();
-    init_video_utils();
-  }
-});
-
-// src/commands/ai-script-pipeline.ts
-import { readFile as readFile13, writeFile as writeFile23, unlink as unlink2, rename as rename2 } from "node:fs/promises";
-import { resolve as resolve25, extname as extname3 } from "node:path";
-import { existsSync as existsSync14 } from "node:fs";
-async function executeRegenerateScene(options) {
-  const result = {
-    success: false,
-    regeneratedScenes: [],
-    failedScenes: []
+function sha256Hex(value) {
+  return createHash4("sha256").update(value).digest("hex");
+}
+function awsEncode(value) {
+  return encodeURIComponent(value).replace(
+    /[!'()*]/g,
+    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+}
+function presignS3PutUrl(params) {
+  const now = /* @__PURE__ */ new Date();
+  const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
+  const dateStamp = amzDate.slice(0, 8);
+  const host = `${params.bucket}.s3.${params.region}.amazonaws.com`;
+  const credentialScope = `${dateStamp}/${params.region}/s3/aws4_request`;
+  const canonicalUri = `/${params.key.split("/").map(awsEncode).join("/")}`;
+  const query = {
+    "X-Amz-Algorithm": "AWS4-HMAC-SHA256",
+    "X-Amz-Credential": `${params.accessKeyId}/${credentialScope}`,
+    "X-Amz-Date": amzDate,
+    "X-Amz-Expires": String(params.ttlSeconds),
+    "X-Amz-SignedHeaders": "host"
   };
-  try {
-    const outputDir = resolve25(process.cwd(), options.projectDir);
-    if (!existsSync14(outputDir)) {
-      return { ...result, error: `Project directory not found: ${outputDir}` };
-    }
-    const yamlPath = resolve25(outputDir, "storyboard.yaml");
-    const jsonPath = resolve25(outputDir, "storyboard.json");
-    const storyboardPath = existsSync14(yamlPath) ? yamlPath : existsSync14(jsonPath) ? jsonPath : null;
-    if (!storyboardPath) {
-      return { ...result, error: `Storyboard not found in: ${outputDir} (expected storyboard.yaml or storyboard.json)` };
-    }
-    const storyboardContent = await readFile13(storyboardPath, "utf-8");
-    const segments = storyboardPath.endsWith(".yaml") ? (0, import_yaml5.parse)(storyboardContent).scenes : JSON.parse(storyboardContent);
-    for (const sceneNum of options.scenes) {
-      if (sceneNum < 1 || sceneNum > segments.length) {
-        return { ...result, error: `Scene ${sceneNum} does not exist. Storyboard has ${segments.length} scenes.` };
-      }
-    }
-    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 = {
-        grok: { envVar: "XAI_API_KEY", name: "xAI (Grok)" },
-        kling: { envVar: "KLING_API_KEY", name: "Kling" },
-        runway: { envVar: "RUNWAY_API_SECRET", name: "Runway" },
-        veo: { envVar: "GOOGLE_API_KEY", name: "Google (Veo)" }
-      };
-      const generator = options.generator || "grok";
-      const genInfo = generatorKeyMap[generator];
-      if (!genInfo) {
-        return { ...result, error: `Invalid generator: ${generator}. Available: ${Object.keys(generatorKeyMap).join(", ")}` };
-      }
-      videoApiKey = await getApiKey(genInfo.envVar, genInfo.name) ?? void 0;
-      if (!videoApiKey) {
-        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` };
-      }
+  if (params.sessionToken) {
+    query["X-Amz-Security-Token"] = params.sessionToken;
+  }
+  const canonicalQuery = Object.entries(query).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${awsEncode(key)}=${awsEncode(value)}`).join("&");
+  const canonicalRequest = [
+    "PUT",
+    canonicalUri,
+    canonicalQuery,
+    `host:${host}`,
+    "",
+    "host",
+    "UNSIGNED-PAYLOAD"
+  ].join("\n");
+  const stringToSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    credentialScope,
+    sha256Hex(canonicalRequest)
+  ].join("\n");
+  const dateKey = hmac(`AWS4${params.secretAccessKey}`, dateStamp);
+  const regionKey = hmac(dateKey, params.region);
+  const serviceKey = hmac(regionKey, "s3");
+  const signingKey = hmac(serviceKey, "aws4_request");
+  const signature = createHmac2("sha256", signingKey).update(stringToSign).digest("hex");
+  return `https://${host}${canonicalUri}?${canonicalQuery}&X-Amz-Signature=${signature}`;
+}
+function publicS3Url(params) {
+  if (params.publicBaseUrl) {
+    return `${params.publicBaseUrl.replace(/\/+$/g, "")}/${params.key.split("/").map(awsEncode).join("/")}`;
+  }
+  return `https://${params.bucket}.s3.${params.region}.amazonaws.com/${params.key.split("/").map(awsEncode).join("/")}`;
+}
+async function resolveUploadSettings() {
+  const config2 = await loadConfig();
+  const provider = process.env.VIBE_UPLOAD_PROVIDER ?? config2?.upload.provider ?? "imgbb";
+  return {
+    provider,
+    ttlSeconds: envNumber("VIBE_UPLOAD_TTL_SECONDS") ?? config2?.upload.ttlSeconds ?? 3600,
+    s3: {
+      bucket: process.env.VIBE_UPLOAD_S3_BUCKET ?? config2?.upload.s3?.bucket,
+      region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? config2?.upload.s3?.region,
+      prefix: process.env.VIBE_UPLOAD_S3_PREFIX ?? config2?.upload.s3?.prefix,
+      publicBaseUrl: process.env.VIBE_UPLOAD_PUBLIC_BASE_URL ?? config2?.upload.s3?.publicBaseUrl
     }
-    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" };
-      }
+  };
+}
+async function resolveUploadHost() {
+  const settings = await resolveUploadSettings();
+  if (settings.provider === "s3") {
+    const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
+    const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+    const sessionToken = process.env.AWS_SESSION_TOKEN;
+    const { bucket, region } = settings.s3;
+    if (!accessKeyId || !secretAccessKey || !bucket || !region) {
+      throw new Error(
+        "S3 upload host requires AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION, and VIBE_UPLOAD_S3_BUCKET."
+      );
     }
-    let storyboardMutated = false;
-    for (const sceneNum of options.scenes) {
-      const segment = segments[sceneNum - 1];
-      const narrationPath = resolve25(outputDir, `narration-${sceneNum}.mp3`);
-      const imagePath = resolve25(outputDir, `scene-${sceneNum}.png`);
-      const videoPath = resolve25(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
+    return {
+      provider: "s3",
+      async uploadImage(imageBuffer, opts) {
+        const ext = extensionFor(opts);
+        const prefix = safePrefix(settings.s3.prefix);
+        const key = `${prefix}/${Date.now()}-${randomUUID()}.${ext}`;
+        const presignedUrl = presignS3PutUrl({
+          accessKeyId,
+          secretAccessKey,
+          sessionToken,
+          region,
+          bucket,
+          key,
+          ttlSeconds: settings.ttlSeconds
         });
-        if (ttsResult.success && ttsResult.audioBuffer) {
-          await writeFile23(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 = resolve25(outputDir, `scene-${refSceneNum}.png`);
-          if (existsSync14(refImagePath)) {
-            referenceImageBuffer = await readFile13(refImagePath);
-          }
-        } else if (!refSceneNum) {
-          for (let i = 1; i <= segments.length; i++) {
-            if (i !== sceneNum) {
-              const otherImagePath = resolve25(outputDir, `scene-${i}.png`);
-              if (existsSync14(otherImagePath)) {
-                referenceImageBuffer = await readFile13(otherImagePath);
-                break;
-              }
-            }
-          }
+        const response = await fetch(presignedUrl, {
+          method: "PUT",
+          headers: {
+            "content-type": opts?.mimeType ?? "application/octet-stream"
+          },
+          body: new Uint8Array(imageBuffer)
+        });
+        if (!response.ok) {
+          throw new Error(`S3 upload failed (${response.status}): ${response.statusText}`);
         }
-        const dalleImageSizes = {
-          "16:9": "1536x1024",
-          "9:16": "1024x1536",
-          "1:1": "1024x1024"
+        return {
+          provider: "s3",
+          url: publicS3Url({ region, bucket, key, publicBaseUrl: settings.s3.publicBaseUrl }),
+          expiresAt: new Date(Date.now() + settings.ttlSeconds * 1e3).toISOString()
         };
-        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 writeFile23(imagePath, imageBuffer);
-        } else if (imageUrl) {
-          const response = await fetch(imageUrl);
-          const buffer = Buffer.from(await response.arrayBuffer());
-          await writeFile23(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 (!existsSync14(imagePath)) {
-          result.failedScenes.push(sceneNum);
-          continue;
-        }
-        const imageBuffer = await readFile13(imagePath);
-        const videoDuration = segment.duration > 5 ? 10 : 5;
-        const maxRetries = options.retries ?? DEFAULT_VIDEO_RETRIES;
-        if (options.generator === "grok") {
-          const grok = new GrokProvider();
-          await grok.initialize({ apiKey: videoApiKey });
-          const ext = extname3(imagePath).toLowerCase().slice(1);
-          const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
-          const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
-          const grokDuration = Math.min(15, Math.max(1, segment.duration));
-          const taskResult = await generateVideoWithRetryGrok(
-            grok,
-            segment,
-            {
-              duration: grokDuration,
-              aspectRatio: options.aspectRatio || "16:9",
-              referenceImage
-            },
-            maxRetries
-          );
-          if (taskResult) {
-            try {
-              const waitResult = await grok.waitForCompletion(taskResult.requestId, void 0, 3e5);
-              if (waitResult.status === "completed" && waitResult.videoUrl) {
-                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
-                await writeFile23(videoPath, buffer);
-                const targetDuration = segment.duration;
-                const actualVideoDuration = await getVideoDuration(videoPath);
-                if (actualVideoDuration < targetDuration - 0.1) {
-                  const extendedPath = resolve25(outputDir, `scene-${sceneNum}-extended.mp4`);
-                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
-                  await unlink2(videoPath);
-                  await rename2(extendedPath, videoPath);
-                }
-                result.regeneratedScenes.push(sceneNum);
-              } else {
-                logSceneFailure("Grok", `scene ${sceneNum}`, waitResult);
-                result.failedScenes.push(sceneNum);
-              }
-            } catch (err) {
-              logSceneFailure("Grok", `scene ${sceneNum}`, err);
-              result.failedScenes.push(sceneNum);
-            }
-          } else {
-            result.failedScenes.push(sceneNum);
-          }
-        } else if (options.generator === "veo") {
-          const veo = new GeminiProvider();
-          await veo.initialize({ apiKey: videoApiKey });
-          const ext = extname3(imagePath).toLowerCase().slice(1);
-          const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
-          const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
-          const veoDuration = segment.duration > 6 ? 8 : segment.duration > 4 ? 6 : 4;
-          const taskResult = await generateVideoWithRetryVeo(
-            veo,
-            segment,
-            {
-              duration: veoDuration,
-              aspectRatio: options.aspectRatio || "16:9",
-              referenceImage
-            },
-            maxRetries
-          );
-          if (taskResult) {
-            try {
-              const waitResult = await veo.waitForVideoCompletion(taskResult.operationName, void 0, 3e5);
-              if (waitResult.status === "completed" && waitResult.videoUrl) {
-                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
-                await writeFile23(videoPath, buffer);
-                const targetDuration = segment.duration;
-                const actualVideoDuration = await getVideoDuration(videoPath);
-                if (actualVideoDuration < targetDuration - 0.1) {
-                  const extendedPath = resolve25(outputDir, `scene-${sceneNum}-extended.mp4`);
-                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
-                  await unlink2(videoPath);
-                  await rename2(extendedPath, videoPath);
-                }
-                result.regeneratedScenes.push(sceneNum);
-              } else {
-                logSceneFailure("Veo", `scene ${sceneNum}`, waitResult);
-                result.failedScenes.push(sceneNum);
-              }
-            } catch (err) {
-              logSceneFailure("Veo", `scene ${sceneNum}`, err);
-              result.failedScenes.push(sceneNum);
-            }
-          } else {
-            result.failedScenes.push(sceneNum);
-          }
-        } else if (options.generator === "kling" || !options.generator) {
-          const kling = new KlingProvider();
-          await kling.initialize({ apiKey: videoApiKey });
-          if (!kling.isConfigured()) {
-            result.failedScenes.push(sceneNum);
-            continue;
-          }
-          const imgbbApiKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
-          let imageUrl;
-          if (imgbbApiKey) {
-            const uploadResult = await uploadToImgbb(imageBuffer, imgbbApiKey);
-            if (uploadResult.success && uploadResult.url) {
-              imageUrl = uploadResult.url;
-            }
-          }
-          const taskResult = await generateVideoWithRetryKling(
-            kling,
-            segment,
-            {
-              duration: videoDuration,
-              aspectRatio: options.aspectRatio || "16:9",
-              referenceImage: imageUrl
-            },
-            maxRetries
-          );
-          if (taskResult) {
-            try {
-              const waitResult = await kling.waitForCompletion(taskResult.taskId, taskResult.type, void 0, 6e5);
-              if (waitResult.status === "completed" && waitResult.videoUrl) {
-                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
-                await writeFile23(videoPath, buffer);
-                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 (err) {
-              logSceneFailure("Kling", `scene ${sceneNum}`, err);
-              result.failedScenes.push(sceneNum);
-            }
-          } else {
-            result.failedScenes.push(sceneNum);
-          }
-        } else {
-          const runway = new RunwayProvider();
-          await runway.initialize({ apiKey: videoApiKey });
-          const ext = extname3(imagePath).toLowerCase().slice(1);
-          const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
-          const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
-          const aspectRatio = options.aspectRatio === "1:1" ? "16:9" : options.aspectRatio || "16:9";
-          const taskResult = await generateVideoWithRetryRunway(
-            runway,
-            segment,
-            referenceImage,
-            { duration: videoDuration, aspectRatio },
-            maxRetries
-          );
-          if (taskResult) {
-            try {
-              const waitResult = await runway.waitForCompletion(taskResult.taskId, void 0, 3e5);
-              if (waitResult.status === "completed" && waitResult.videoUrl) {
-                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
-                await writeFile23(videoPath, buffer);
-                const targetDuration = segment.duration;
-                const actualVideoDuration = await getVideoDuration(videoPath);
-                if (actualVideoDuration < targetDuration - 0.1) {
-                  const extendedPath = resolve25(outputDir, `scene-${sceneNum}-extended.mp4`);
-                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
-                  await unlink2(videoPath);
-                  await rename2(extendedPath, videoPath);
-                }
-                result.regeneratedScenes.push(sceneNum);
-              } else {
-                logSceneFailure("Runway", `scene ${sceneNum}`, waitResult);
-                result.failedScenes.push(sceneNum);
-              }
-            } catch (err) {
-              logSceneFailure("Runway", `scene ${sceneNum}`, err);
-              result.failedScenes.push(sceneNum);
-            }
-          } else {
-            result.failedScenes.push(sceneNum);
-          }
-        }
-      } else if (!sceneFailed) {
-        result.regeneratedScenes.push(sceneNum);
+    };
+  }
+  return {
+    provider: "imgbb",
+    async uploadImage(imageBuffer) {
+      const imgbbKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
+      if (!imgbbKey) {
+        throw new Error("IMGBB_API_KEY required for image-to-video uploads.");
       }
-    }
-    if (storyboardMutated) {
-      let currentTime = 0;
-      for (const segment of segments) {
-        segment.startTime = currentTime;
-        currentTime += segment.duration;
+      const result = await uploadToImgbb(imageBuffer, imgbbKey);
+      if (!result.success || !result.url) {
+        throw new Error(`ImgBB upload failed: ${result.error ?? "unknown error"}`);
       }
-      const serialized = storyboardPath.endsWith(".yaml") ? (0, import_yaml5.stringify)({ scenes: segments }, { indent: 2 }) : JSON.stringify(segments, null, 2);
-      await writeFile23(storyboardPath, serialized, "utf-8");
+      return { provider: "imgbb", url: result.url };
     }
-    result.success = result.failedScenes.length === 0;
-    return result;
-  } catch (error) {
-    return {
-      ...result,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
+  };
 }
-var import_yaml5;
-var init_ai_script_pipeline = __esm({
-  "src/commands/ai-script-pipeline.ts"() {
+var init_upload_host = __esm({
+  "src/utils/upload-host.ts"() {
     "use strict";
-    import_yaml5 = __toESM(require_dist(), 1);
-    init_dist2();
-    init_api_key();
     init_config();
-    init_audio();
-    init_ai_helpers();
     init_video_utils();
-    init_video_providers();
   }
 });
 
 // src/commands/generate/video.ts
-import { resolve as resolve26 } from "node:path";
-import { readFile as readFile14, writeFile as writeFile24 } from "node:fs/promises";
+import { resolve as resolve25 } from "node:path";
+import { readFile as readFile13, writeFile as writeFile23 } from "node:fs/promises";
 function registerVideoCommand(parent) {
-  parent.command("video").alias("vid").description("Generate video using AI (Seedance, Grok, Kling, Runway, or Veo)").argument("[prompt]", "Text prompt describing the video (interactive if omitted)").option("-p, --provider <provider>", "Provider: seedance (ByteDance Seedance 2.0 via fal.ai), grok, kling, runway, veo. `fal` is a deprecated v0.x alias for seedance and will be removed in 1.0.").option("-k, --api-key <key>", "API key (or set FAL_KEY / XAI_API_KEY / RUNWAY_API_SECRET / KLING_API_KEY / GOOGLE_API_KEY env)").option("-o, --output <path>", "Output file path (downloads video)").option("-i, --image <path>", "Reference image for image-to-video").option(
+  parent.command("video").alias("vid").description("Generate video using AI (Seedance, Grok, Kling, Runway, or Veo)").argument("[prompt]", "Text prompt describing the video (interactive if omitted)").option(
+    "-p, --provider <provider>",
+    "Provider: seedance (ByteDance Seedance 2.0 via fal.ai), grok, kling, runway, veo. `fal` is a deprecated v0.x alias for seedance and will be removed in 1.0."
+  ).option(
+    "-k, --api-key <key>",
+    "API key (or set FAL_KEY / XAI_API_KEY / RUNWAY_API_SECRET / KLING_API_KEY / GOOGLE_API_KEY env)"
+  ).option("-o, --output <path>", "Output file path (downloads video)").option("-i, --image <path>", "Reference image for image-to-video").option(
     "-d, --duration <sec>",
     "Duration in seconds. Seedance accepts 4-15; Kling accepts 5 or 10; Veo maps to 6 or 8.",
     "5"
-  ).option("-r, --ratio <ratio>", "Aspect ratio: 16:9, 9:16, or 1:1 (auto-detected from image if omitted)").option("--seed <number>", "Random seed for reproducibility (Runway only)").option("--mode <mode>", "Generation mode: std or pro (Kling only)", "std").option("--seedance-model <model>", "Seedance variant: quality or fast (fal.ai only)", "quality").option("--negative <prompt>", "Negative prompt - what to avoid (Kling/Veo)").option("--resolution <res>", "Video resolution: 720p, 1080p, 4k (Veo only)").option("--last-frame <path>", "Last frame image for frame interpolation (Veo only)").option("--ref-images <paths...>", "Reference images for character consistency (Veo 3.1 only, max 3)").option("--person <mode>", "Person generation: allow_all, allow_adult (Veo only)").option("--veo-model <model>", "Veo model: 3.0, 3.1, 3.1-fast (default: 3.1-fast)", "3.1-fast").option("--runway-model <model>", "Runway model: gen4.5 (default, text+image-to-video), gen4_turbo (image-to-video only)", "gen4.5").option("--no-wait", "Start generation and return task ID without waiting").option("--dry-run", "Preview parameters without executing").addHelpText("after", `
+  ).option(
+    "-r, --ratio <ratio>",
+    "Aspect ratio: 16:9, 9:16, or 1:1 (auto-detected from image if omitted)"
+  ).option("--seed <number>", "Random seed for reproducibility (Runway only)").option("--mode <mode>", "Generation mode: std or pro (Kling only)", "std").option(
+    "--seedance-model <model>",
+    "Seedance variant: quality or fast (fal.ai only)",
+    "quality"
+  ).option("--negative <prompt>", "Negative prompt - what to avoid (Kling/Veo)").option("--resolution <res>", "Video resolution: 720p, 1080p, 4k (Veo only)").option("--last-frame <path>", "Last frame image for frame interpolation (Veo only)").option(
+    "--ref-images <paths...>",
+    "Reference images for character consistency (Veo 3.1 only, max 3)"
+  ).option("--person <mode>", "Person generation: allow_all, allow_adult (Veo only)").option("--veo-model <model>", "Veo model: 3.0, 3.1, 3.1-fast (default: 3.1-fast)", "3.1-fast").option(
+    "--runway-model <model>",
+    "Runway model: gen4.5 (default, text+image-to-video), gen4_turbo (image-to-video only)",
+    "gen4.5"
+  ).option("--no-wait", "Start generation and return task ID without waiting").option("--dry-run", "Preview parameters without executing").addHelpText(
+    "after",
+    `
 Examples:
   $ vibe generate video "dancing cat" -o cat.mp4                      # Seedance when FAL_KEY is set
   $ vibe gen vid "cinematic city timelapse" -o city.mp4 -p seedance   # Seedance via fal.ai
   $ vibe gen vid "city timelapse" -o city.mp4 -p kling                # Kling
   $ vibe gen vid "epic scene" -i frame.png -o out.mp4 -p runway       # Image-to-video
   $ vibe gen vid "ocean waves" -o waves.mp4 -p veo --resolution 1080p # Veo
-  $ vibe gen vid "sunset" -o sun.mp4 -d 10 --dry-run --json`).action(async (prompt3, options) => {
+  $ vibe gen vid "sunset" -o sun.mp4 -d 10 --dry-run --json`
+  ).action(async (prompt3, options) => {
     const startedAt = Date.now();
     try {
       if (!prompt3) {
@@ -35582,10 +35269,7 @@ Examples:
           }
         } else {
           exitWithError(
-            usageError(
-              "Prompt argument is required.",
-              "Usage: vibe generate video <prompt>"
-            )
+            usageError("Prompt argument is required.", "Usage: vibe generate video <prompt>")
           );
         }
       }
@@ -35593,13 +35277,16 @@ Examples:
       if (options.output) {
         validateOutputPath(options.output);
       }
+      await loadProviderDefaults();
       if (options.duration !== void 0) {
         const d = parseFloat(options.duration);
         if (!Number.isFinite(d) || d <= 0 || d > 60) {
-          exitWithError(usageError(
-            `Invalid --duration: ${options.duration}`,
-            "Must be a positive number \u2264 60 seconds."
-          ));
+          exitWithError(
+            usageError(
+              `Invalid --duration: ${options.duration}`,
+              "Must be a positive number \u2264 60 seconds."
+            )
+          );
         }
       }
       const validProviders = ["runway", "kling", "veo", "grok", "seedance", "fal"];
@@ -35641,10 +35328,12 @@ Examples:
         provider = resolved?.name ?? "grok";
       }
       let referenceImage;
+      let referenceImageBuffer;
+      let referenceImageMimeType;
       let isImageToVideo = false;
       if (options.image) {
-        const imagePath = resolve26(process.cwd(), options.image);
-        const imageBuffer = await readFile14(imagePath);
+        const imagePath = resolve25(process.cwd(), options.image);
+        const imageBuffer = await readFile13(imagePath);
         const ext = options.image.toLowerCase().split(".").pop();
         const mimeTypes2 = {
           jpg: "image/jpeg",
@@ -35654,6 +35343,8 @@ Examples:
           webp: "image/webp"
         };
         const mimeType = mimeTypes2[ext || "png"] || "image/png";
+        referenceImageBuffer = imageBuffer;
+        referenceImageMimeType = mimeType;
         referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
         isImageToVideo = true;
         if (!options.ratio) {
@@ -35778,20 +35469,22 @@ Examples:
         }
         let klingImage = referenceImage;
         if (klingImage && klingImage.startsWith("data:")) {
-          spinner2.text = "Uploading image to ImgBB for Kling...";
-          const imgbbKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
-          if (!imgbbKey) {
-            spinner2.fail("ImgBB API key required");
-            exitWithError(authError("IMGBB_API_KEY", "ImgBB"));
-          }
-          const base64Data = klingImage.split(",")[1];
-          const imageBuffer = Buffer.from(base64Data, "base64");
-          const uploadResult = await uploadToImgbb(imageBuffer, imgbbKey);
-          if (!uploadResult.success || !uploadResult.url) {
-            spinner2.fail("ImgBB upload failed");
-            exitWithError(apiError(`ImgBB upload failed: ${uploadResult.error}`, true));
-          }
-          klingImage = uploadResult.url;
+          try {
+            const uploadHost = await resolveUploadHost();
+            spinner2.text = `Uploading image via ${uploadHost.provider} for Kling...`;
+            const upload = await uploadHost.uploadImage(referenceImageBuffer, {
+              filename: options.image,
+              mimeType: referenceImageMimeType
+            });
+            klingImage = upload.url;
+          } catch (err) {
+            spinner2.fail("Image upload failed");
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes("IMGBB_API_KEY")) {
+              exitWithError(authError("IMGBB_API_KEY", "ImgBB"));
+            }
+            exitWithError(apiError(message, true));
+          }
           spinner2.text = "Starting video generation...";
         }
         result = await kling.generateVideo(prompt3, {
@@ -35846,8 +35539,8 @@ Examples:
         const veoDuration = parseInt(options.duration) <= 6 ? 6 : 8;
         let lastFrame;
         if (options.lastFrame) {
-          const lastFramePath = resolve26(process.cwd(), options.lastFrame);
-          const lastFrameBuffer = await readFile14(lastFramePath);
+          const lastFramePath = resolve25(process.cwd(), options.lastFrame);
+          const lastFrameBuffer = await readFile13(lastFramePath);
           const ext = options.lastFrame.toLowerCase().split(".").pop();
           const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : `image/${ext || "png"}`;
           lastFrame = `data:${mimeType};base64,${lastFrameBuffer.toString("base64")}`;
@@ -35856,8 +35549,8 @@ Examples:
         if (options.refImages && options.refImages.length > 0) {
           refImages = [];
           for (const refPath of options.refImages.slice(0, 3)) {
-            const absRefPath = resolve26(process.cwd(), refPath);
-            const refBuffer = await readFile14(absRefPath);
+            const absRefPath = resolve25(process.cwd(), refPath);
+            const refBuffer = await readFile13(absRefPath);
             const ext = refPath.toLowerCase().split(".").pop();
             const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : `image/${ext || "png"}`;
             refImages.push({ base64: refBuffer.toString("base64"), mimeType });
@@ -35938,20 +35631,22 @@ Examples:
         await fal.initialize({ apiKey });
         let falImage = referenceImage;
         if (falImage && falImage.startsWith("data:")) {
-          spinner2.text = "Uploading image to ImgBB for Seedance...";
-          const imgbbKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
-          if (!imgbbKey) {
-            spinner2.fail("ImgBB API key required for Seedance image-to-video");
-            exitWithError(authError("IMGBB_API_KEY", "ImgBB"));
-          }
-          const base64Data = falImage.split(",")[1];
-          const imageBuffer = Buffer.from(base64Data, "base64");
-          const uploadResult = await uploadToImgbb(imageBuffer, imgbbKey);
-          if (!uploadResult.success || !uploadResult.url) {
-            spinner2.fail("ImgBB upload failed");
-            exitWithError(apiError(`ImgBB upload failed: ${uploadResult.error}`, true));
+          try {
+            const uploadHost = await resolveUploadHost();
+            spinner2.text = `Uploading image via ${uploadHost.provider} for Seedance...`;
+            const upload = await uploadHost.uploadImage(referenceImageBuffer, {
+              filename: options.image,
+              mimeType: referenceImageMimeType
+            });
+            falImage = upload.url;
+          } catch (err) {
+            spinner2.fail("Image upload failed");
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes("IMGBB_API_KEY")) {
+              exitWithError(authError("IMGBB_API_KEY", "ImgBB"));
+            }
+            exitWithError(apiError(message, true));
           }
-          falImage = uploadResult.url;
         }
         spinner2.text = "Generating video with fal.ai Seedance 2.0 (this may take 1-3 minutes)...";
         const seedanceModel = String(options.seedanceModel ?? "quality").toLowerCase();
@@ -35975,8 +35670,8 @@ Examples:
         let outputPath;
         if (options.output && finalResult.videoUrl) {
           const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
-          outputPath = resolve26(process.cwd(), options.output);
-          await writeFile24(outputPath, buffer);
+          outputPath = resolve25(process.cwd(), options.output);
+          await writeFile23(outputPath, buffer);
         }
         outputSuccess({
           command: "generate video",
@@ -36003,14 +35698,12 @@ Examples:
         const downloadSpinner = ora("Downloading video...").start();
         try {
           const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
-          const outputPath = resolve26(process.cwd(), options.output);
-          await writeFile24(outputPath, buffer);
+          const outputPath = resolve25(process.cwd(), options.output);
+          await writeFile23(outputPath, buffer);
           downloadSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
         } catch (err) {
           downloadSpinner.fail(
-            source_default.red(
-              `Failed to download video: ${err instanceof Error ? err.message : err}`
-            )
+            source_default.red(`Failed to download video: ${err instanceof Error ? err.message : err}`)
           );
         }
       }
@@ -36028,11 +35721,10 @@ var init_video = __esm({
     init_dist2();
     init_api_key();
     init_tty();
-    init_config();
     init_output();
     init_validate();
     init_provider_resolver();
-    init_ai_script_pipeline();
+    init_upload_host();
     init_ai_helpers();
   }
 });
@@ -36137,8 +35829,8 @@ Run 'vibe schema generate.<command>' for structured parameter info.
 });
 
 // src/commands/_shared/edit/silence-cut.ts
-import { existsSync as existsSync15 } from "node:fs";
-import { readFile as readFile15 } from "node:fs/promises";
+import { existsSync as existsSync14 } from "node:fs";
+import { readFile as readFile14 } from "node:fs/promises";
 async function detectSilencePeriods(videoPath, noiseThreshold, minDuration) {
   const totalDuration = await getVideoDuration(videoPath);
   const { stdout, stderr } = await execSafe(
@@ -36188,7 +35880,7 @@ async function detectSilencePeriodsWithGemini(videoPath, minDuration, options) {
   }
   const gemini = new GeminiProvider();
   await gemini.initialize({ apiKey: geminiApiKey });
-  const videoBuffer = await readFile15(videoPath);
+  const videoBuffer = await readFile14(videoPath);
   const modelMap = {
     flash: "gemini-3-flash-preview",
     "flash-2.5": "gemini-2.5-flash",
@@ -36269,7 +35961,7 @@ async function executeSilenceCut(options) {
     analyzeOnly = false,
     useGemini = false
   } = options;
-  if (!existsSync15(videoPath)) {
+  if (!existsSync14(videoPath)) {
     return { success: false, error: `Video not found: ${videoPath}` };
   }
   if (!commandExists("ffmpeg")) {
@@ -36377,11 +36069,11 @@ var init_silence_cut = __esm({
 });
 
 // src/commands/_shared/edit/jump-cut.ts
-import { existsSync as existsSync16 } from "node:fs";
-import { readFile as readFile16, writeFile as writeFile25, mkdir as mkdir12 } from "node:fs/promises";
+import { existsSync as existsSync15 } from "node:fs";
+import { readFile as readFile15, writeFile as writeFile24, mkdir as mkdir12 } from "node:fs/promises";
 import { join as join8 } from "node:path";
 async function transcribeWithWords(audioPath, apiKey, language) {
-  const audioBuffer = await readFile16(audioPath);
+  const audioBuffer = await readFile15(audioPath);
   const audioBlob = new Blob([audioBuffer]);
   const formData = new FormData();
   formData.append("file", audioBlob, "audio.wav");
@@ -36440,7 +36132,7 @@ async function executeJumpCut(options) {
     analyzeOnly = false,
     apiKey
   } = options;
-  if (!existsSync16(videoPath)) {
+  if (!existsSync15(videoPath)) {
     return { success: false, error: `Video not found: ${videoPath}` };
   }
   if (!commandExists("ffmpeg")) {
@@ -36537,7 +36229,7 @@ async function executeJumpCut(options) {
       }
       const concatList = segmentPaths.map((p) => `file '${p}'`).join("\n");
       const listPath = join8(tmpDir, "concat.txt");
-      await writeFile25(listPath, concatList);
+      await writeFile24(listPath, concatList);
       await execSafe(
         "ffmpeg",
         [
@@ -36726,8 +36418,8 @@ var init_helpers = __esm({
 });
 
 // src/commands/_shared/edit/caption.ts
-import { existsSync as existsSync17 } from "node:fs";
-import { readFile as readFile17, writeFile as writeFile26, mkdir as mkdir13 } from "node:fs/promises";
+import { existsSync as existsSync16 } from "node:fs";
+import { readFile as readFile16, writeFile as writeFile25, mkdir as mkdir13 } from "node:fs/promises";
 import { dirname as dirname8, basename as basename6, extname as extname4, join as join9 } from "node:path";
 function getCaptionForceStyle(style, fontSize, fontColor, position) {
   const alignment = position === "top" ? 8 : position === "center" ? 5 : 2;
@@ -36756,7 +36448,7 @@ async function executeCaption(options) {
     position = "bottom",
     apiKey
   } = options;
-  if (!existsSync17(videoPath)) {
+  if (!existsSync16(videoPath)) {
     return { success: false, error: `Video not found: ${videoPath}` };
   }
   if (!commandExists("ffmpeg")) {
@@ -36797,7 +36489,7 @@ async function executeCaption(options) {
       );
       const whisper = new WhisperProvider();
       await whisper.initialize({ apiKey: openaiKey });
-      const audioBuffer = await readFile17(audioPath);
+      const audioBuffer = await readFile16(audioPath);
       const audioBlob = new Blob([audioBuffer]);
       const transcriptResult = await whisper.transcribe(audioBlob, language);
       if (transcriptResult.status === "failed" || !transcriptResult.segments || transcriptResult.segments.length === 0) {
@@ -36807,7 +36499,7 @@ async function executeCaption(options) {
         };
       }
       const srtContent = formatSRT(transcriptResult.segments);
-      await writeFile26(srtPath, srtContent);
+      await writeFile25(srtPath, srtContent);
       const { width, height } = await getVideoResolution(videoPath);
       const fontSize = customFontSize || Math.round(height / 18);
       let hasSubtitles = false;
@@ -36849,7 +36541,7 @@ async function executeCaption(options) {
             outputDir2,
             basename6(outputPath, extname4(outputPath)) + ".srt"
           );
-          await writeFile26(outputSrtPath2, srtContent);
+          await writeFile25(outputSrtPath2, srtContent);
           return { success: false, error: `${remotionErr}
 SRT saved to: ${outputSrtPath2}` };
         }
@@ -36888,7 +36580,7 @@ SRT saved to: ${outputSrtPath2}` };
             outputDir2,
             basename6(outputPath, extname4(outputPath)) + ".srt"
           );
-          await writeFile26(outputSrtPath2, srtContent);
+          await writeFile25(outputSrtPath2, srtContent);
           return {
             success: false,
             error: `${renderResult.error}
@@ -36901,7 +36593,7 @@ SRT saved to: ${outputSrtPath2}`
         outputDir,
         basename6(outputPath, extname4(outputPath)) + ".srt"
       );
-      await writeFile26(outputSrtPath, srtContent);
+      await writeFile25(outputSrtPath, srtContent);
       return {
         success: true,
         outputPath,
@@ -36934,10 +36626,10 @@ var init_caption = __esm({
 });
 
 // src/commands/_shared/edit/noise-reduce.ts
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 async function executeNoiseReduce(options) {
   const { inputPath, outputPath, strength = "medium", noiseFloor } = options;
-  if (!existsSync18(inputPath)) {
+  if (!existsSync17(inputPath)) {
     return { success: false, error: `File not found: ${inputPath}` };
   }
   if (!commandExists("ffmpeg")) {
@@ -36994,7 +36686,7 @@ var init_noise_reduce = __esm({
 });
 
 // src/commands/_shared/edit/fade.ts
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 async function executeFade(options) {
   const {
     videoPath,
@@ -37004,7 +36696,7 @@ async function executeFade(options) {
     audioOnly = false,
     videoOnly = false
   } = options;
-  if (!existsSync19(videoPath)) {
+  if (!existsSync18(videoPath)) {
     return { success: false, error: `Video not found: ${videoPath}` };
   }
   if (!commandExists("ffmpeg")) {
@@ -37071,8 +36763,8 @@ var init_fade = __esm({
 });
 
 // src/commands/_shared/edit/translate-srt.ts
-import { existsSync as existsSync20 } from "node:fs";
-import { readFile as readFile18, writeFile as writeFile27 } from "node:fs/promises";
+import { existsSync as existsSync19 } from "node:fs";
+import { readFile as readFile17, writeFile as writeFile26 } from "node:fs/promises";
 async function executeTranslateSrt(options) {
   const {
     srtPath,
@@ -37082,11 +36774,11 @@ async function executeTranslateSrt(options) {
     sourceLanguage,
     apiKey
   } = options;
-  if (!existsSync20(srtPath)) {
+  if (!existsSync19(srtPath)) {
     return { success: false, error: `SRT file not found: ${srtPath}` };
   }
   try {
-    const srtContent = await readFile18(srtPath, "utf-8");
+    const srtContent = await readFile17(srtPath, "utf-8");
     const segments = parseSRT(srtContent);
     if (segments.length === 0) {
       return { success: false, error: "No subtitle segments found in SRT file" };
@@ -37176,7 +36868,7 @@ ${textsToTranslate}`;
       }
     }
     const translatedSrt = formatSRT(translatedSegments);
-    await writeFile27(outputPath, translatedSrt);
+    await writeFile26(outputPath, translatedSrt);
     return {
       success: true,
       outputPath,
@@ -37199,8 +36891,8 @@ var init_translate_srt = __esm({
 });
 
 // src/commands/_shared/edit/text-overlay.ts
-import { existsSync as existsSync21 } from "node:fs";
-import { resolve as resolve27 } from "node:path";
+import { existsSync as existsSync20 } from "node:fs";
+import { resolve as resolve26 } from "node:path";
 function detectSystemFont() {
   const platform3 = process.platform;
   if (platform3 === "darwin") {
@@ -37210,7 +36902,7 @@ function detectSystemFont() {
       "/Library/Fonts/Arial.ttf"
     ];
     for (const f of candidates) {
-      if (existsSync21(f)) return f;
+      if (existsSync20(f)) return f;
     }
   } else if (platform3 === "linux") {
     const candidates = [
@@ -37219,7 +36911,7 @@ function detectSystemFont() {
       "/usr/share/fonts/TTF/DejaVuSans-Bold.ttf"
     ];
     for (const f of candidates) {
-      if (existsSync21(f)) return f;
+      if (existsSync20(f)) return f;
     }
   } else if (platform3 === "win32") {
     const candidates = [
@@ -37227,7 +36919,7 @@ function detectSystemFont() {
       "C:\\Windows\\Fonts\\segoeui.ttf"
     ];
     for (const f of candidates) {
-      if (existsSync21(f)) return f;
+      if (existsSync20(f)) return f;
     }
   }
   return null;
@@ -37246,9 +36938,9 @@ async function applyTextOverlays(options) {
   if (!texts || texts.length === 0) {
     return { success: false, error: "No texts provided" };
   }
-  const absVideoPath = resolve27(process.cwd(), videoPath);
-  const absOutputPath = resolve27(process.cwd(), outputPath);
-  if (!existsSync21(absVideoPath)) {
+  const absVideoPath = resolve26(process.cwd(), videoPath);
+  const absOutputPath = resolve26(process.cwd(), outputPath);
+  if (!existsSync20(absVideoPath)) {
     return { success: false, error: `Video not found: ${absVideoPath}` };
   }
   if (!commandExists("ffmpeg")) {
@@ -37428,8 +37120,8 @@ var init_ai_edit = __esm({
 });
 
 // src/commands/ai-edit-cli.ts
-import { resolve as resolve28, extname as extname5, basename as basename7 } from "node:path";
-import { existsSync as existsSync22 } from "node:fs";
+import { resolve as resolve27, extname as extname5, basename as basename7 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
 function registerEditCommands(aiCommand) {
   aiCommand.command("silence-cut").alias("sc").description("Remove silent segments from video (FFmpeg default, or Gemini for smart detection)").argument("<video>", "Video file path").option("-o, --output <path>", "Output file path (default: <name>-cut.<ext>)").option("--noise <dB>", "Silence threshold in dB (default: -30)", "-30").option("-d, --min-duration <seconds>", "Minimum silence duration to cut (default: 0.5)", "0.5").option("--padding <seconds>", "Padding around non-silent segments (default: 0.1)", "0.1").option("--analyze-only", "(deprecated \u2014 use `vibe detect silence`) Only detect silence, don't cut").option("--use-gemini", "Use Gemini Video Understanding for context-aware silence detection").option("-m, --model <model>", "Gemini model (default: flash)").option("--low-res", "Low resolution mode for longer videos (Gemini only)").option("-k, --api-key <key>", "Google API key override (or set GOOGLE_API_KEY env)").option("--dry-run", "Preview parameters without executing").addHelpText("after", `
 Examples:
@@ -37445,8 +37137,8 @@ No API key needed (FFmpeg only). Use --use-gemini for smart detection (requires
       if (options.output) {
         validateOutputPath(options.output);
       }
-      const absVideoPath = resolve28(process.cwd(), videoPath);
-      if (!existsSync22(absVideoPath)) {
+      const absVideoPath = resolve27(process.cwd(), videoPath);
+      if (!existsSync21(absVideoPath)) {
         exitWithError(notFoundError(absVideoPath));
       }
       if (!commandExists("ffmpeg")) {
@@ -37485,7 +37177,7 @@ No API key needed (FFmpeg only). Use --use-gemini for smart detection (requires
       const spinner2 = ora(spinnerText).start();
       const result = await executeSilenceCut({
         videoPath: absVideoPath,
-        outputPath: resolve28(process.cwd(), outputPath),
+        outputPath: resolve27(process.cwd(), outputPath),
         noiseThreshold: parseFloat(options.noise),
         minDuration: parseFloat(options.minDuration),
         padding: parseFloat(options.padding),
@@ -37553,8 +37245,8 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
       if (options.output) {
         validateOutputPath(options.output);
       }
-      const absVideoPath = resolve28(process.cwd(), videoPath);
-      if (!existsSync22(absVideoPath)) {
+      const absVideoPath = resolve27(process.cwd(), videoPath);
+      if (!existsSync21(absVideoPath)) {
         exitWithError(notFoundError(absVideoPath));
       }
       if (!commandExists("ffmpeg")) {
@@ -37588,7 +37280,7 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
       const spinner2 = ora("Starting caption process...").start();
       const result = await executeCaption({
         videoPath: absVideoPath,
-        outputPath: resolve28(process.cwd(), outputPath),
+        outputPath: resolve27(process.cwd(), outputPath),
         style: options.style,
         fontSize: options.fontSize ? parseInt(options.fontSize) : void 0,
         fontColor: options.color,
@@ -37634,8 +37326,8 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
       if (options.output) {
         validateOutputPath(options.output);
       }
-      const absInputPath = resolve28(process.cwd(), inputPath);
-      if (!existsSync22(absInputPath)) {
+      const absInputPath = resolve27(process.cwd(), inputPath);
+      if (!existsSync21(absInputPath)) {
         exitWithError(notFoundError(absInputPath));
       }
       if (!commandExists("ffmpeg")) {
@@ -37662,7 +37354,7 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
       const spinner2 = ora("Applying noise reduction...").start();
       const result = await executeNoiseReduce({
         inputPath: absInputPath,
-        outputPath: resolve28(process.cwd(), outputPath),
+        outputPath: resolve27(process.cwd(), outputPath),
         strength: options.strength,
         noiseFloor: options.noiseFloor ? parseFloat(options.noiseFloor) : void 0
       });
@@ -37700,8 +37392,8 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
       if (options.output) {
         validateOutputPath(options.output);
       }
-      const absVideoPath = resolve28(process.cwd(), videoPath);
-      if (!existsSync22(absVideoPath)) {
+      const absVideoPath = resolve27(process.cwd(), videoPath);
+      if (!existsSync21(absVideoPath)) {
         exitWithError(notFoundError(absVideoPath));
       }
       if (!commandExists("ffmpeg")) {
@@ -37730,7 +37422,7 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
       const spinner2 = ora("Applying fade effects...").start();
       const result = await executeFade({
         videoPath: absVideoPath,
-        outputPath: resolve28(process.cwd(), outputPath),
+        outputPath: resolve27(process.cwd(), outputPath),
         fadeIn: parseFloat(options.fadeIn),
         fadeOut: parseFloat(options.fadeOut),
         audioOnly: options.audioOnly || false,
@@ -37775,8 +37467,8 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
       if (!options.target) {
         exitWithError(usageError("Target language required. Use -t or --target"));
       }
-      const absSrtPath = resolve28(process.cwd(), srtPath);
-      if (!existsSync22(absSrtPath)) {
+      const absSrtPath = resolve27(process.cwd(), srtPath);
+      if (!existsSync21(absSrtPath)) {
         exitWithError(notFoundError(absSrtPath));
       }
       if (options.dryRun) {
@@ -37808,7 +37500,7 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
       const spinner2 = ora(`Translating to ${options.target}...`).start();
       const result = await executeTranslateSrt({
         srtPath: absSrtPath,
-        outputPath: resolve28(process.cwd(), outputPath),
+        outputPath: resolve27(process.cwd(), outputPath),
         targetLanguage: options.target,
         provider,
         sourceLanguage: options.source,
@@ -37851,8 +37543,8 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
         validateOutputPath(options.output);
       }
       if (options.fillers) rejectControlChars(options.fillers);
-      const absVideoPath = resolve28(process.cwd(), videoPath);
-      if (!existsSync22(absVideoPath)) {
+      const absVideoPath = resolve27(process.cwd(), videoPath);
+      if (!existsSync21(absVideoPath)) {
         exitWithError(notFoundError(absVideoPath));
       }
       if (!commandExists("ffmpeg")) {
@@ -37887,7 +37579,7 @@ Requires: OPENAI_API_KEY (Whisper transcription) + FFmpeg`).action(async (videoP
       const spinner2 = ora("Transcribing with word-level timestamps...").start();
       const result = await executeJumpCut({
         videoPath: absVideoPath,
-        outputPath: resolve28(process.cwd(), outputPath),
+        outputPath: resolve27(process.cwd(), outputPath),
         fillers,
         padding: parseFloat(options.padding),
         language: options.language,
@@ -37952,9 +37644,9 @@ var init_ai_edit_cli = __esm({
 });
 
 // src/commands/_shared/execute-fill-gaps.ts
-import { existsSync as existsSync23 } from "node:fs";
-import { readFile as readFile19, writeFile as writeFile28, mkdir as mkdir14, rename as renameFs } from "node:fs/promises";
-import { resolve as resolve29, dirname as dirname9 } from "node:path";
+import { existsSync as existsSync22 } from "node:fs";
+import { readFile as readFile18, writeFile as writeFile27, mkdir as mkdir14, rename as renameFs } from "node:fs/promises";
+import { resolve as resolve28, dirname as dirname9 } from "node:path";
 function detectVideoGaps(videoClips, totalDuration) {
   const gaps = [];
   const sortedClips = [...videoClips].sort((a, b) => a.startTime - b.startTime);
@@ -38010,7 +37702,7 @@ function analyzeGapFillability(gaps, videoClips, sources) {
 }
 async function uploadFrameToImgbb(framePath, imgbbApiKey) {
   try {
-    const frameBuffer = await readFile19(framePath);
+    const frameBuffer = await readFile18(framePath);
     const frameBase64 = frameBuffer.toString("base64");
     const formData = new FormData();
     formData.append("key", imgbbApiKey);
@@ -38035,14 +37727,14 @@ async function executeFillGaps(options) {
   try {
     onProgress("Loading timeline...");
     const filePath = await resolveTimelineFile(options.projectPath);
-    if (!existsSync23(filePath)) {
+    if (!existsSync22(filePath)) {
       return {
         success: false,
         error: `Timeline file not found: ${filePath}`,
         humanLines
       };
     }
-    const content = await readFile19(filePath, "utf-8");
+    const content = await readFile18(filePath, "utf-8");
     const data = JSON.parse(content);
     const project = Project.fromJSON(data);
     const clips = project.getClips().sort((a, b) => a.startTime - b.startTime);
@@ -38169,8 +37861,8 @@ async function executeFillGaps(options) {
       };
     }
     const projectDir = dirname9(filePath);
-    const footageDir = options.dir ? resolve29(process.cwd(), options.dir) : resolve29(projectDir, "footage");
-    if (!existsSync23(footageDir)) {
+    const footageDir = options.dir ? resolve28(process.cwd(), options.dir) : resolve28(projectDir, "footage");
+    if (!existsSync22(footageDir)) {
       await mkdir14(footageDir, { recursive: true });
     }
     humanLines.push("Generating AI Videos");
@@ -38201,7 +37893,7 @@ async function executeFillGaps(options) {
       }
       onProgress("Extracting frame from preceding clip...");
       const frameOffset = clipBefore.sourceStartOffset + clipBefore.duration - 0.1;
-      const framePath = resolve29(footageDir, `frame-${gap.start.toFixed(2)}.png`);
+      const framePath = resolve28(footageDir, `frame-${gap.start.toFixed(2)}.png`);
       try {
         await execSafe("ffmpeg", [
           "-i",
@@ -38262,10 +37954,10 @@ async function executeFillGaps(options) {
         continue;
       }
       const videoFileName = `gap-fill-${gap.start.toFixed(2)}-${gap.end.toFixed(2)}.mp4`;
-      const videoPath = resolve29(footageDir, videoFileName);
+      const videoPath = resolve28(footageDir, videoFileName);
       onProgress("Downloading generated video...");
       const videoBuffer = await downloadVideo(finalResult.videoUrl);
-      await writeFile28(videoPath, videoBuffer);
+      await writeFile27(videoPath, videoBuffer);
       generatedDuration = finalResult.duration || parseInt(klingDuration);
       generatedVideos.push(videoPath);
       humanLines.push(`  Generated: ${videoFileName} (${generatedDuration}s)`);
@@ -38274,7 +37966,7 @@ async function executeFillGaps(options) {
         const remainingNeeded = targetDuration - generatedDuration;
         const segmentDuration = remainingNeeded > 5 ? "10" : "5";
         onProgress(`Generating additional ${segmentDuration}s segment...`);
-        const lastFramePath = resolve29(
+        const lastFramePath = resolve28(
           footageDir,
           `frame-extend-${gap.start.toFixed(2)}-${segmentIndex}.png`
         );
@@ -38330,17 +38022,17 @@ async function executeFillGaps(options) {
           );
           break;
         }
-        const segVideoPath = resolve29(
+        const segVideoPath = resolve28(
           footageDir,
           `gap-fill-${gap.start.toFixed(2)}-${gap.end.toFixed(2)}-seg${segmentIndex}.mp4`
         );
         const segVideoBuffer = await downloadVideo(segFinalResult.videoUrl);
-        await writeFile28(segVideoPath, segVideoBuffer);
-        const concatListPath = resolve29(footageDir, `concat-${gap.start.toFixed(2)}.txt`);
+        await writeFile27(segVideoPath, segVideoBuffer);
+        const concatListPath = resolve28(footageDir, `concat-${gap.start.toFixed(2)}.txt`);
         const concatList = generatedVideos.map((v) => `file '${v}'`).join("\n") + `
 file '${segVideoPath}'`;
-        await writeFile28(concatListPath, concatList);
-        const concatOutputPath = resolve29(
+        await writeFile27(concatListPath, concatList);
+        const concatOutputPath = resolve28(
           footageDir,
           `gap-fill-${gap.start.toFixed(2)}-${gap.end.toFixed(2)}-merged.mp4`
         );
@@ -38396,8 +38088,8 @@ file '${segVideoPath}'`;
     humanLines.push("");
     let outputPath = filePath;
     if (generatedCount > 0) {
-      outputPath = options.output ? resolve29(process.cwd(), options.output) : filePath;
-      await writeFile28(outputPath, JSON.stringify(project.toJSON(), null, 2));
+      outputPath = options.output ? resolve28(process.cwd(), options.output) : filePath;
+      await writeFile27(outputPath, JSON.stringify(project.toJSON(), null, 2));
       humanLines.push(`\u2714 Filled ${generatedCount} gap(s) with AI-generated video`);
       humanLines.push(`Project saved: ${outputPath}`);
     } else {
@@ -38493,14 +38185,14 @@ __export(edit_cmd_exports, {
   executeSpeedRamp: () => executeSpeedRamp,
   executeUpscale: () => executeUpscale
 });
-import { resolve as resolve30, dirname as dirname10 } from "node:path";
-import { readFile as readFile20, writeFile as writeFile29, mkdir as mkdir15 } from "node:fs/promises";
+import { resolve as resolve29, dirname as dirname10 } from "node:path";
+import { readFile as readFile19, writeFile as writeFile28, mkdir as mkdir15 } from "node:fs/promises";
 async function executeGrade(options) {
   const { videoPath, style, preset, output, analyzeOnly, apiKey } = options;
   try {
     if (!style && !preset) return { success: false, error: "Either style or preset is required" };
     if (!commandExists("ffmpeg")) return { success: false, error: "FFmpeg not found" };
-    const absPath = resolve30(process.cwd(), videoPath);
+    const absPath = resolve29(process.cwd(), videoPath);
     let gradeResult;
     if (preset) {
       const claude = new ClaudeProvider();
@@ -38515,7 +38207,7 @@ async function executeGrade(options) {
     if (analyzeOnly) {
       return { success: true, style: preset || style, description: gradeResult.description, ffmpegFilter: gradeResult.ffmpegFilter };
     }
-    const outputPath = output ? resolve30(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, "-graded$1");
+    const outputPath = output ? resolve29(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, "-graded$1");
     await execSafe("ffmpeg", ["-i", absPath, "-vf", gradeResult.ffmpegFilter, "-c:a", "copy", outputPath, "-y"], { timeout: 6e5 });
     return { success: true, outputPath, style: preset || style, description: gradeResult.description, ffmpegFilter: gradeResult.ffmpegFilter };
   } catch (error) {
@@ -38530,12 +38222,12 @@ async function executeSpeedRamp(options) {
     const claudeKey = apiKey || process.env.ANTHROPIC_API_KEY;
     if (!openaiKey) return { success: false, error: "OPENAI_API_KEY required for Whisper transcription" };
     if (!claudeKey) return { success: false, error: "ANTHROPIC_API_KEY required for Claude analysis" };
-    const absPath = resolve30(process.cwd(), videoPath);
+    const absPath = resolve29(process.cwd(), videoPath);
     const tempAudio = absPath.replace(/(\.[^.]+)$/, "-temp-audio.mp3");
     await execSafe("ffmpeg", ["-i", absPath, "-vn", "-acodec", "libmp3lame", "-q:a", "2", tempAudio, "-y"]);
     const whisper = new WhisperProvider();
     await whisper.initialize({ apiKey: openaiKey });
-    const audioBuffer = await readFile20(tempAudio);
+    const audioBuffer = await readFile19(tempAudio);
     const transcript = await whisper.transcribe(new Blob([audioBuffer]), language);
     try {
       const { unlink: unlink5 } = await import("node:fs/promises");
@@ -38555,7 +38247,7 @@ async function executeSpeedRamp(options) {
     if (speedResult.keyframes.length < 2) {
       return { success: false, error: "Not enough keyframes for speed ramping" };
     }
-    const outputPath = output ? resolve30(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, "-ramped$1");
+    const outputPath = output ? resolve29(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, "-ramped$1");
     const setpts = `setpts=${(1 / avgSpeed).toFixed(3)}*PTS`;
     const atempo = avgSpeed >= 0.5 && avgSpeed <= 2 ? `atempo=${avgSpeed.toFixed(3)}` : "";
     if (atempo) {
@@ -38572,7 +38264,7 @@ async function executeReframe(options) {
   const { videoPath, aspect = "9:16", output, analyzeOnly } = options;
   try {
     if (!commandExists("ffmpeg")) return { success: false, error: "FFmpeg not found" };
-    const absPath = resolve30(process.cwd(), videoPath);
+    const absPath = resolve29(process.cwd(), videoPath);
     const { stdout: probeOut } = await execSafe("ffprobe", [
       "-v",
       "error",
@@ -38607,7 +38299,7 @@ async function executeReframe(options) {
         keyframeCount: 1
       };
     }
-    const outputPath = output ? resolve30(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, `-${aspect.replace(":", "x")}$1`);
+    const outputPath = output ? resolve29(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, `-${aspect.replace(":", "x")}$1`);
     await execSafe("ffmpeg", ["-i", absPath, "-vf", `crop=${cropWidth}:${cropHeight}:${cropX}:${cropY}`, "-c:a", "copy", outputPath, "-y"], { timeout: 6e5 });
     return { success: true, outputPath, sourceAspect: `${sourceWidth}:${sourceHeight}`, targetAspect: aspect };
   } catch (error) {
@@ -38619,7 +38311,7 @@ async function executeInterpolate(options) {
   try {
     if (!commandExists("ffmpeg")) return { success: false, error: "FFmpeg not found" };
     if (![2, 4, 8].includes(factor)) return { success: false, error: "Factor must be 2, 4, or 8" };
-    const absPath = resolve30(process.cwd(), videoPath);
+    const absPath = resolve29(process.cwd(), videoPath);
     const { stdout: fpsOut } = await execSafe("ffprobe", [
       "-v",
       "error",
@@ -38635,7 +38327,7 @@ async function executeInterpolate(options) {
     const originalFps = num / (den || 1);
     const targetFps = options.fps || originalFps * factor;
     const mi = quality === "fast" ? "mi_mode=mci" : "mi_mode=mci:mc_mode=aobmc:me_mode=bidir:vsbmc=1";
-    const outputPath = output ? resolve30(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, `-slow${factor}x$1`);
+    const outputPath = output ? resolve29(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, `-slow${factor}x$1`);
     await execSafe("ffmpeg", ["-i", absPath, "-filter:v", `minterpolate='${mi}:fps=${targetFps}',setpts=${factor}*PTS`, "-an", outputPath, "-y"], { timeout: 6e5 });
     return { success: true, outputPath, originalFps, targetFps, factor };
   } catch (error) {
@@ -38646,7 +38338,7 @@ async function executeUpscale(options) {
   const { videoPath, output, scale = 2, quality = "quality" } = options;
   try {
     if (!commandExists("ffmpeg")) return { success: false, error: "FFmpeg not found" };
-    const absPath = resolve30(process.cwd(), videoPath);
+    const absPath = resolve29(process.cwd(), videoPath);
     const { stdout: probeOut } = await execSafe("ffprobe", [
       "-v",
       "error",
@@ -38662,7 +38354,7 @@ async function executeUpscale(options) {
     const targetW = w * scale;
     const targetH = h * scale;
     const scaleFilter = quality === "quality" ? `scale=${targetW}:${targetH}:flags=lanczos` : `scale=${targetW}:${targetH}`;
-    const outputPath = output ? resolve30(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, `-${scale}x$1`);
+    const outputPath = output ? resolve29(process.cwd(), output) : absPath.replace(/(\.[^.]+)$/, `-${scale}x$1`);
     await execSafe("ffmpeg", ["-i", absPath, "-vf", scaleFilter, "-c:a", "copy", outputPath, "-y"], { timeout: 6e5 });
     return { success: true, outputPath, originalRes: `${w}x${h}`, targetRes: `${targetW}x${targetH}` };
   } catch (error) {
@@ -38735,7 +38427,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
             dryRun: true,
             data: {
               params: {
-                videoPath: resolve30(process.cwd(), videoPath),
+                videoPath: resolve29(process.cwd(), videoPath),
                 style: options.style || options.preset,
                 analyzeOnly: options.analyzeOnly || false
               }
@@ -38762,8 +38454,8 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         }
         spinner2.succeed(source_default.green("Color grade analyzed"));
         if (isJsonMode()) {
-          const absPath2 = resolve30(process.cwd(), videoPath);
-          const gradeOutputPath = options.output ? resolve30(process.cwd(), options.output) : absPath2.replace(/(\.[^.]+)$/, "-graded$1");
+          const absPath2 = resolve29(process.cwd(), videoPath);
+          const gradeOutputPath = options.output ? resolve29(process.cwd(), options.output) : absPath2.replace(/(\.[^.]+)$/, "-graded$1");
           outputSuccess({
             command: "edit grade",
             startedAt,
@@ -38789,8 +38481,8 @@ Run 'vibe schema edit.<command>' for structured parameter info.
           console.log(source_default.dim("Use without --analyze-only to apply the grade."));
           return;
         }
-        const absPath = resolve30(process.cwd(), videoPath);
-        const outputPath = options.output ? resolve30(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, "-graded$1");
+        const absPath = resolve29(process.cwd(), videoPath);
+        const outputPath = options.output ? resolve29(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, "-graded$1");
         spinner2.start("Applying color grade...");
         await execSafe("ffmpeg", ["-i", absPath, "-vf", gradeResult.ffmpegFilter, "-c:a", "copy", outputPath, "-y"], { timeout: 6e5 });
         spinner2.succeed(source_default.green("Color grade applied"));
@@ -38820,7 +38512,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
             dryRun: true,
             data: {
               params: {
-                videoPath: resolve30(process.cwd(), videoPath),
+                videoPath: resolve29(process.cwd(), videoPath),
                 texts: options.text,
                 style: options.style,
                 fontSize: options.fontSize ? parseInt(options.fontSize) : void 0,
@@ -38833,8 +38525,8 @@ Run 'vibe schema edit.<command>' for structured parameter info.
           });
           return;
         }
-        const absPath = resolve30(process.cwd(), videoPath);
-        const outputPath = options.output ? resolve30(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, "-overlay$1");
+        const absPath = resolve29(process.cwd(), videoPath);
+        const outputPath = options.output ? resolve29(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, "-overlay$1");
         const spinner2 = ora("Applying text overlays...").start();
         const result = await applyTextOverlays({
           videoPath: absPath,
@@ -38892,7 +38584,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
             dryRun: true,
             data: {
               params: {
-                videoPath: resolve30(process.cwd(), videoPath),
+                videoPath: resolve29(process.cwd(), videoPath),
                 style: options.style,
                 minSpeed: parseFloat(options.minSpeed),
                 maxSpeed: parseFloat(options.maxSpeed),
@@ -38904,7 +38596,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         }
         const openaiApiKey = await requireApiKey("OPENAI_API_KEY", "OpenAI");
         const claudeApiKey = await requireApiKey("ANTHROPIC_API_KEY", "Anthropic", options.apiKey);
-        const absPath = resolve30(process.cwd(), videoPath);
+        const absPath = resolve29(process.cwd(), videoPath);
         const spinner2 = ora("Extracting audio...").start();
         const { stdout: speedRampProbe } = await execSafe("ffprobe", [
           "-v",
@@ -38926,7 +38618,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         spinner2.text = "Transcribing audio...";
         const whisper = new WhisperProvider();
         await whisper.initialize({ apiKey: openaiApiKey });
-        const audioBuffer = await readFile20(tempAudio);
+        const audioBuffer = await readFile19(tempAudio);
         const audioBlob = new Blob([audioBuffer]);
         const transcript = await whisper.transcribe(audioBlob, options.language);
         if (!transcript.segments || transcript.segments.length === 0) {
@@ -38949,7 +38641,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         spinner2.succeed(source_default.green(`Found ${speedResult.keyframes.length} speed keyframes`));
         if (isJsonMode()) {
           const avgSpeed2 = speedResult.keyframes.reduce((sum, kf) => sum + kf.speed, 0) / speedResult.keyframes.length;
-          const speedRampOutputPath = options.output ? resolve30(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, "-ramped$1");
+          const speedRampOutputPath = options.output ? resolve29(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, "-ramped$1");
           outputSuccess({
             command: "edit speed-ramp",
             startedAt,
@@ -38978,7 +38670,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
           return;
         }
         spinner2.start("Applying speed ramps...");
-        const outputPath = options.output ? resolve30(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, "-ramped$1");
+        const outputPath = options.output ? resolve29(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, "-ramped$1");
         const avgSpeed = speedResult.keyframes.reduce((sum, kf) => sum + kf.speed, 0) / speedResult.keyframes.length;
         const setpts = `setpts=${(1 / avgSpeed).toFixed(3)}*PTS`;
         const atempo = avgSpeed >= 0.5 && avgSpeed <= 2 ? `atempo=${avgSpeed.toFixed(3)}` : "";
@@ -39012,7 +38704,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
             dryRun: true,
             data: {
               params: {
-                videoPath: resolve30(process.cwd(), videoPath),
+                videoPath: resolve29(process.cwd(), videoPath),
                 aspect: options.aspect,
                 focus: options.focus,
                 analyzeOnly: options.analyzeOnly || false
@@ -39021,7 +38713,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
           });
           return;
         }
-        const absPath = resolve30(process.cwd(), videoPath);
+        const absPath = resolve29(process.cwd(), videoPath);
         const spinner2 = ora("Analyzing video...").start();
         const { stdout: probeOut } = await execSafe("ffprobe", [
           "-v",
@@ -39059,7 +38751,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         for (let i = 1; i <= numKeyframes && i <= 30; i++) {
           const framePath = `${tempDir}/frame-${i.toString().padStart(4, "0")}.jpg`;
           try {
-            const frameBuffer = await readFile20(framePath);
+            const frameBuffer = await readFile19(framePath);
             const frameBase64 = frameBuffer.toString("base64");
             const result = await claude.analyzeFrameForReframe(frameBase64, options.aspect, {
               focusMode: options.focus,
@@ -39083,7 +38775,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         }
         spinner2.succeed(source_default.green(`Analyzed ${cropKeyframes.length} keyframes`));
         if (isJsonMode()) {
-          const reframeOutputPath = options.output ? resolve30(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, `-${options.aspect.replace(":", "x")}$1`);
+          const reframeOutputPath = options.output ? resolve29(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, `-${options.aspect.replace(":", "x")}$1`);
           outputSuccess({
             command: "edit reframe",
             startedAt,
@@ -39118,8 +38810,8 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         }
         console.log();
         if (options.keyframes) {
-          const keyframesPath = resolve30(process.cwd(), options.keyframes);
-          await writeFile29(keyframesPath, JSON.stringify(cropKeyframes, null, 2));
+          const keyframesPath = resolve29(process.cwd(), options.keyframes);
+          await writeFile28(keyframesPath, JSON.stringify(cropKeyframes, null, 2));
           console.log(source_default.green(`Keyframes saved to: ${keyframesPath}`));
         }
         if (options.analyzeOnly) {
@@ -39130,7 +38822,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         const avgCropY = Math.round(cropKeyframes.reduce((sum, kf) => sum + kf.cropY, 0) / cropKeyframes.length);
         const cropWidth = cropKeyframes[0]?.cropWidth || sourceWidth;
         const cropHeight = cropKeyframes[0]?.cropHeight || sourceHeight;
-        const outputPath = options.output ? resolve30(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, `-${options.aspect.replace(":", "x")}$1`);
+        const outputPath = options.output ? resolve29(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, `-${options.aspect.replace(":", "x")}$1`);
         spinner2.start("Applying reframe...");
         await execSafe("ffmpeg", ["-i", absPath, "-vf", `crop=${cropWidth}:${cropHeight}:${avgCropX}:${avgCropY}`, "-c:a", "copy", outputPath, "-y"], { timeout: 6e5 });
         spinner2.succeed(source_default.green("Reframe applied"));
@@ -39166,7 +38858,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
             dryRun: true,
             data: {
               params: {
-                imagePaths: imagePaths.map((p) => resolve30(process.cwd(), p)),
+                imagePaths: imagePaths.map((p) => resolve29(process.cwd(), p)),
                 prompt: prompt3,
                 provider,
                 model: options.model,
@@ -39187,8 +38879,8 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         const spinner2 = ora(`Reading ${imagePaths.length} image(s)...`).start();
         const imageBuffers = [];
         for (const imagePath of imagePaths) {
-          const absPath = resolve30(process.cwd(), imagePath);
-          const buffer = await readFile20(absPath);
+          const absPath = resolve29(process.cwd(), imagePath);
+          const buffer = await readFile19(absPath);
           imageBuffers.push(buffer);
         }
         let result;
@@ -39236,16 +38928,16 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         }
         spinner2.succeed(source_default.green("Image edited"));
         const img = result.images[0];
-        const outputPath = resolve30(process.cwd(), options.output);
+        const outputPath = resolve29(process.cwd(), options.output);
         const saveImage = async () => {
           await mkdir15(dirname10(outputPath), { recursive: true });
           if (img.base64) {
             const buffer = Buffer.from(img.base64, "base64");
-            await writeFile29(outputPath, buffer);
+            await writeFile28(outputPath, buffer);
           } else if (img.url) {
             const resp = await fetch(img.url);
             const arrayBuf = await resp.arrayBuffer();
-            await writeFile29(outputPath, Buffer.from(arrayBuf));
+            await writeFile28(outputPath, Buffer.from(arrayBuf));
           }
         };
         const resultModel = result.model;
@@ -39278,7 +38970,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         if (options.output) {
           validateOutputPath(options.output);
         }
-        const absPath = resolve30(process.cwd(), videoPath);
+        const absPath = resolve29(process.cwd(), videoPath);
         const factor = parseInt(options.factor);
         if (![2, 4, 8].includes(factor)) {
           exitWithError(usageError("Factor must be 2, 4, or 8"));
@@ -39299,7 +38991,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
           });
           return;
         }
-        const outputPath = options.output ? resolve30(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, `-slow${factor}x$1`);
+        const outputPath = options.output ? resolve29(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, `-slow${factor}x$1`);
         const spinner2 = ora(`Creating ${factor}x slow motion...`).start();
         try {
           const { stdout: fpsOut } = await execSafe("ffprobe", [
@@ -39360,7 +39052,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         if (options.output) {
           validateOutputPath(options.output);
         }
-        const absPath = resolve30(process.cwd(), videoPath);
+        const absPath = resolve29(process.cwd(), videoPath);
         const scale = parseInt(options.scale);
         if (scale !== 2 && scale !== 4) {
           exitWithError(usageError("Scale must be 2 or 4"));
@@ -39382,7 +39074,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
           return;
         }
         if (options.ffmpeg) {
-          const outputPath = options.output ? resolve30(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, `-upscaled-${scale}x$1`);
+          const outputPath = options.output ? resolve29(process.cwd(), options.output) : absPath.replace(/(\.[^.]+)$/, `-upscaled-${scale}x$1`);
           const spinner3 = ora(`Upscaling video with FFmpeg (${scale}x)...`).start();
           try {
             const { stdout: probeOut } = await execSafe("ffprobe", [
@@ -39463,9 +39155,9 @@ __export(ai_analyze_exports, {
   executeGeminiVideo: () => executeGeminiVideo,
   registerAnalyzeCommands: () => registerAnalyzeCommands
 });
-import { readFile as readFile21 } from "node:fs/promises";
-import { extname as extname6, resolve as resolve31 } from "node:path";
-import { existsSync as existsSync24 } from "node:fs";
+import { readFile as readFile20 } from "node:fs/promises";
+import { extname as extname6, resolve as resolve30 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
 async function executeGeminiVideo(options) {
   try {
     const apiKey = await getApiKey("GOOGLE_API_KEY", "Google");
@@ -39483,11 +39175,11 @@ async function executeGeminiVideo(options) {
     if (isYouTube) {
       videoData = options.source;
     } else {
-      const absPath = resolve31(process.cwd(), options.source);
-      if (!existsSync24(absPath)) {
+      const absPath = resolve30(process.cwd(), options.source);
+      if (!existsSync23(absPath)) {
         return { success: false, error: `File not found: ${absPath}` };
       }
-      videoData = await readFile21(absPath);
+      videoData = await readFile20(absPath);
     }
     const gemini = new GeminiProvider();
     await gemini.initialize({ apiKey });
@@ -39556,11 +39248,11 @@ async function executeAnalyze(options) {
         }
         imageBuffer = Buffer.from(await response.arrayBuffer());
       } else {
-        const absPath = resolve31(process.cwd(), source);
-        if (!existsSync24(absPath)) {
+        const absPath = resolve30(process.cwd(), source);
+        if (!existsSync23(absPath)) {
           return { success: false, error: `File not found: ${absPath}` };
         }
-        imageBuffer = await readFile21(absPath);
+        imageBuffer = await readFile20(absPath);
       }
       const result2 = await gemini.analyzeImage(imageBuffer, options.prompt, {
         model: modelId,
@@ -39591,11 +39283,11 @@ async function executeAnalyze(options) {
       }
       videoData = Buffer.from(await response.arrayBuffer());
     } else {
-      const absPath = resolve31(process.cwd(), source);
-      if (!existsSync24(absPath)) {
+      const absPath = resolve30(process.cwd(), source);
+      if (!existsSync23(absPath)) {
         return { success: false, error: `File not found: ${absPath}` };
       }
-      videoData = await readFile21(absPath);
+      videoData = await readFile20(absPath);
     }
     const result = await gemini.analyzeVideo(videoData, options.prompt, {
       model: modelId,
@@ -39729,9 +39421,9 @@ __export(ai_review_exports, {
   executeReview: () => executeReview,
   registerReviewCommand: () => registerReviewCommand
 });
-import { readFile as readFile22, rename as rename3 } from "node:fs/promises";
-import { resolve as resolve32 } from "node:path";
-import { existsSync as existsSync25 } from "node:fs";
+import { readFile as readFile21, rename as rename2 } from "node:fs/promises";
+import { resolve as resolve31 } from "node:path";
+import { existsSync as existsSync24 } from "node:fs";
 function parseReviewFeedback(response) {
   let cleaned = response.trim();
   if (cleaned.startsWith("```json")) {
@@ -39755,8 +39447,8 @@ function parseReviewFeedback(response) {
 }
 async function executeReview(options) {
   const { videoPath, storyboardPath, autoApply = false, verify = false, model = "flash" } = options;
-  const absVideoPath = resolve32(process.cwd(), videoPath);
-  if (!existsSync25(absVideoPath)) {
+  const absVideoPath = resolve31(process.cwd(), videoPath);
+  if (!existsSync24(absVideoPath)) {
     return { success: false, error: `Video not found: ${absVideoPath}` };
   }
   const apiKey = process.env.GOOGLE_API_KEY || await getApiKey("GOOGLE_API_KEY", "Google");
@@ -39765,9 +39457,9 @@ async function executeReview(options) {
   }
   let storyboardContext = "";
   if (storyboardPath) {
-    const absStoryboardPath = resolve32(process.cwd(), storyboardPath);
-    if (existsSync25(absStoryboardPath)) {
-      const content = await readFile22(absStoryboardPath, "utf-8");
+    const absStoryboardPath = resolve31(process.cwd(), storyboardPath);
+    if (existsSync24(absStoryboardPath)) {
+      const content = await readFile21(absStoryboardPath, "utf-8");
       storyboardContext = `
 
 Original storyboard for reference:
@@ -39800,7 +39492,7 @@ ${content}`;
 Score each category 1-10. For fixable issues, provide an FFmpeg filter in autoFixable. Be specific and practical.${storyboardContext}`;
   const gemini = new GeminiProvider();
   await gemini.initialize({ apiKey });
-  const videoData = await readFile22(absVideoPath);
+  const videoData = await readFile21(absVideoPath);
   const analysisResult = await gemini.analyzeVideo(videoData, reviewPrompt, {
     model: modelId
   });
@@ -39821,7 +39513,7 @@ Score each category 1-10. For fixable issues, provide an FFmpeg filter in autoFi
   };
   if (autoApply && feedback.autoFixable.length > 0) {
     let currentInput = absVideoPath;
-    const outputBase = options.outputPath ? resolve32(process.cwd(), options.outputPath) : absVideoPath.replace(/(\.[^.]+)$/, "-reviewed$1");
+    const outputBase = options.outputPath ? resolve31(process.cwd(), options.outputPath) : absVideoPath.replace(/(\.[^.]+)$/, "-reviewed$1");
     for (const fix of feedback.autoFixable) {
       if (fix.type === "color_grade" && fix.ffmpegFilter) {
         try {
@@ -39838,7 +39530,7 @@ Score each category 1-10. For fixable issues, provide an FFmpeg filter in autoFi
     if (currentInput !== absVideoPath) {
       const finalOutput = outputBase;
       try {
-        await rename3(currentInput, finalOutput);
+        await rename2(currentInput, finalOutput);
         result.outputPath = finalOutput;
       } catch {
         result.outputPath = currentInput;
@@ -39846,7 +39538,7 @@ Score each category 1-10. For fixable issues, provide an FFmpeg filter in autoFi
     }
   }
   if (verify && result.outputPath) {
-    const verifyVideoData = await readFile22(result.outputPath);
+    const verifyVideoData = await readFile21(result.outputPath);
     const verifyResult = await gemini.analyzeVideo(
       verifyVideoData,
       'Rate this video overall quality on a scale of 1-10. Return ONLY a JSON object: {"score": <number>}',
@@ -39905,73 +39597,657 @@ function registerReviewCommand(aiCommand) {
         spinner2.fail(result.error || "Video review failed");
         exitWithError(apiError(result.error || "Video review failed", true));
       }
-      spinner2.succeed(source_default.green("Video review complete"));
-      console.log();
-      const fb = result.feedback;
-      console.log(source_default.bold.cyan("Video Review"));
-      console.log(source_default.dim("\u2500".repeat(60)));
-      console.log(`Overall Score: ${source_default.bold(fb.overallScore >= 7 ? source_default.green(String(fb.overallScore)) : fb.overallScore >= 5 ? source_default.yellow(String(fb.overallScore)) : source_default.red(String(fb.overallScore)))}/10`);
-      console.log();
-      const categories = [
-        ["Pacing", fb.categories.pacing],
-        ["Color", fb.categories.color],
-        ["Text Readability", fb.categories.textReadability],
-        ["Audio-Visual Sync", fb.categories.audioVisualSync],
-        ["Composition", fb.categories.composition]
-      ];
-      for (const [name, cat] of categories) {
-        const scoreColor = cat.score >= 7 ? source_default.green : cat.score >= 5 ? source_default.yellow : source_default.red;
-        const fixable = cat.fixable ? source_default.dim(" [fixable]") : "";
-        console.log(`  ${name.padEnd(20)} ${scoreColor(String(cat.score).padStart(2))}/10${fixable}`);
-        if (cat.issues.length > 0) {
-          for (const issue of cat.issues) {
-            console.log(source_default.dim(`    - ${issue}`));
+      spinner2.succeed(source_default.green("Video review complete"));
+      console.log();
+      const fb = result.feedback;
+      console.log(source_default.bold.cyan("Video Review"));
+      console.log(source_default.dim("\u2500".repeat(60)));
+      console.log(`Overall Score: ${source_default.bold(fb.overallScore >= 7 ? source_default.green(String(fb.overallScore)) : fb.overallScore >= 5 ? source_default.yellow(String(fb.overallScore)) : source_default.red(String(fb.overallScore)))}/10`);
+      console.log();
+      const categories = [
+        ["Pacing", fb.categories.pacing],
+        ["Color", fb.categories.color],
+        ["Text Readability", fb.categories.textReadability],
+        ["Audio-Visual Sync", fb.categories.audioVisualSync],
+        ["Composition", fb.categories.composition]
+      ];
+      for (const [name, cat] of categories) {
+        const scoreColor = cat.score >= 7 ? source_default.green : cat.score >= 5 ? source_default.yellow : source_default.red;
+        const fixable = cat.fixable ? source_default.dim(" [fixable]") : "";
+        console.log(`  ${name.padEnd(20)} ${scoreColor(String(cat.score).padStart(2))}/10${fixable}`);
+        if (cat.issues.length > 0) {
+          for (const issue of cat.issues) {
+            console.log(source_default.dim(`    - ${issue}`));
+          }
+        }
+      }
+      if (result.appliedFixes && result.appliedFixes.length > 0) {
+        console.log();
+        console.log(source_default.bold.green("Applied Fixes:"));
+        for (const fix of result.appliedFixes) {
+          console.log(source_default.green(`  + ${fix}`));
+        }
+        if (result.outputPath) {
+          console.log(source_default.green(`  Output: ${result.outputPath}`));
+        }
+      }
+      if (result.verificationScore !== void 0) {
+        console.log();
+        console.log(source_default.bold(`Verification Score: ${result.verificationScore}/10`));
+      }
+      if (fb.recommendations.length > 0) {
+        console.log();
+        console.log(source_default.bold("Recommendations:"));
+        for (const rec of fb.recommendations) {
+          console.log(source_default.dim(`  * ${rec}`));
+        }
+      }
+      console.log();
+    } catch (error) {
+      exitWithError(generalError(error instanceof Error ? error.message : "Video review failed"));
+    }
+  });
+}
+var init_ai_review = __esm({
+  "src/commands/ai-review.ts"() {
+    "use strict";
+    init_source();
+    init_ora();
+    init_dist2();
+    init_api_key();
+    init_exec_safe();
+    init_output();
+    init_validate();
+  }
+});
+
+// src/commands/_shared/video-providers.ts
+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++) {
+    try {
+      const result = await grok.generateVideo(prompt3, {
+        prompt: prompt3,
+        duration: options.duration,
+        aspectRatio: options.aspectRatio,
+        referenceImage: options.referenceImage
+      });
+      if (result.status !== "failed" && result.id) {
+        return { requestId: result.id };
+      }
+      const providerErr = result.error || "Grok returned failed status";
+      if (attempt < 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);
+      if (attempt < maxRetries) {
+        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
+        await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(source_default.dim(`
+  [Grok error: ${errMsg}]`));
+      }
+    }
+  }
+  return null;
+}
+async function generateVideoWithRetryKling(kling, segment, options, maxRetries, onProgress) {
+  const prompt3 = segment.visualStyle ? `${segment.visuals}. Style: ${segment.visualStyle}` : segment.visuals;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await kling.generateVideo(prompt3, {
+        prompt: prompt3,
+        // Pass reference image (base64 or URL) - KlingProvider handles v1.5 fallback for base64
+        referenceImage: options.referenceImage,
+        duration: options.duration,
+        aspectRatio: options.aspectRatio,
+        mode: "std"
+        // std mode for faster generation
+      });
+      if (result.status !== "failed" && result.id) {
+        return {
+          taskId: result.id,
+          type: options.referenceImage ? "image2video" : "text2video"
+        };
+      }
+      const providerErr = result.error || "Kling returned failed status";
+      if (attempt < 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);
+      if (attempt < maxRetries) {
+        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
+        await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(source_default.dim(`
+  [Kling error: ${errMsg}]`));
+      }
+    }
+  }
+  return null;
+}
+async function generateVideoWithRetryRunway(runway, segment, referenceImage, options, maxRetries, onProgress) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await runway.generateVideo(segment.visuals, {
+        prompt: segment.visuals,
+        referenceImage,
+        duration: options.duration,
+        aspectRatio: options.aspectRatio
+      });
+      if (result.status !== "failed" && result.id) {
+        return { taskId: result.id };
+      }
+      const providerErr = result.error || "Runway returned failed status";
+      if (attempt < 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);
+      if (attempt < maxRetries) {
+        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
+        await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(source_default.dim(`
+  [Runway error: ${errMsg}]`));
+      }
+    }
+  }
+  return null;
+}
+async function generateVideoWithRetryVeo(gemini, segment, options, maxRetries, onProgress) {
+  const prompt3 = segment.visualStyle ? `${segment.visuals}. Style: ${segment.visualStyle}` : segment.visuals;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await gemini.generateVideo(prompt3, {
+        prompt: prompt3,
+        referenceImage: options.referenceImage,
+        duration: options.duration,
+        aspectRatio: options.aspectRatio,
+        model: "veo-3.1-fast-generate-preview"
+      });
+      if (result.status !== "failed" && result.id) {
+        return { operationName: result.id };
+      }
+      const providerErr = result.error || "Veo returned failed status";
+      if (attempt < 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);
+      if (attempt < maxRetries) {
+        onProgress?.(`\u26A0 Error: ${errMsg.slice(0, 50)}... retry ${attempt + 1}/${maxRetries}`);
+        await sleep(RETRY_DELAY_MS);
+      } else {
+        console.error(source_default.dim(`
+  [Veo error: ${errMsg}]`));
+      }
+    }
+  }
+  return null;
+}
+var init_video_providers = __esm({
+  "src/commands/_shared/video-providers.ts"() {
+    "use strict";
+    init_source();
+    init_video_utils();
+  }
+});
+
+// src/commands/ai-script-pipeline.ts
+import { readFile as readFile24, writeFile as writeFile31, unlink as unlink2, rename as rename3 } from "node:fs/promises";
+import { resolve as resolve34, extname as extname8 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
+async function executeRegenerateScene(options) {
+  const result = {
+    success: false,
+    regeneratedScenes: [],
+    failedScenes: []
+  };
+  try {
+    const outputDir = resolve34(process.cwd(), options.projectDir);
+    if (!existsSync26(outputDir)) {
+      return { ...result, error: `Project directory not found: ${outputDir}` };
+    }
+    const yamlPath = resolve34(outputDir, "storyboard.yaml");
+    const jsonPath = resolve34(outputDir, "storyboard.json");
+    const storyboardPath = existsSync26(yamlPath) ? yamlPath : existsSync26(jsonPath) ? jsonPath : null;
+    if (!storyboardPath) {
+      return { ...result, error: `Storyboard not found in: ${outputDir} (expected storyboard.yaml or storyboard.json)` };
+    }
+    const storyboardContent = await readFile24(storyboardPath, "utf-8");
+    const segments = storyboardPath.endsWith(".yaml") ? (0, import_yaml5.parse)(storyboardContent).scenes : JSON.parse(storyboardContent);
+    for (const sceneNum of options.scenes) {
+      if (sceneNum < 1 || sceneNum > segments.length) {
+        return { ...result, error: `Scene ${sceneNum} does not exist. Storyboard has ${segments.length} scenes.` };
+      }
+    }
+    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 = {
+        grok: { envVar: "XAI_API_KEY", name: "xAI (Grok)" },
+        kling: { envVar: "KLING_API_KEY", name: "Kling" },
+        runway: { envVar: "RUNWAY_API_SECRET", name: "Runway" },
+        veo: { envVar: "GOOGLE_API_KEY", name: "Google (Veo)" }
+      };
+      const generator = options.generator || "grok";
+      const genInfo = generatorKeyMap[generator];
+      if (!genInfo) {
+        return { ...result, error: `Invalid generator: ${generator}. Available: ${Object.keys(generatorKeyMap).join(", ")}` };
+      }
+      videoApiKey = await getApiKey(genInfo.envVar, genInfo.name) ?? void 0;
+      if (!videoApiKey) {
+        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 = resolve34(outputDir, `narration-${sceneNum}.mp3`);
+      const imagePath = resolve34(outputDir, `scene-${sceneNum}.png`);
+      const videoPath = resolve34(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 writeFile31(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 = resolve34(outputDir, `scene-${refSceneNum}.png`);
+          if (existsSync26(refImagePath)) {
+            referenceImageBuffer = await readFile24(refImagePath);
+          }
+        } else if (!refSceneNum) {
+          for (let i = 1; i <= segments.length; i++) {
+            if (i !== sceneNum) {
+              const otherImagePath = resolve34(outputDir, `scene-${i}.png`);
+              if (existsSync26(otherImagePath)) {
+                referenceImageBuffer = await readFile24(otherImagePath);
+                break;
+              }
+            }
           }
         }
-      }
-      if (result.appliedFixes && result.appliedFixes.length > 0) {
-        console.log();
-        console.log(source_default.bold.green("Applied Fixes:"));
-        for (const fix of result.appliedFixes) {
-          console.log(source_default.green(`  + ${fix}`));
+        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 (result.outputPath) {
-          console.log(source_default.green(`  Output: ${result.outputPath}`));
+        if (imageBuffer) {
+          await writeFile31(imagePath, imageBuffer);
+        } else if (imageUrl) {
+          const response = await fetch(imageUrl);
+          const buffer = Buffer.from(await response.arrayBuffer());
+          await writeFile31(imagePath, buffer);
+        } else {
+          sceneFailed = true;
         }
       }
-      if (result.verificationScore !== void 0) {
-        console.log();
-        console.log(source_default.bold(`Verification Score: ${result.verificationScore}/10`));
+      if (sceneFailed) {
+        result.failedScenes.push(sceneNum);
+        continue;
       }
-      if (fb.recommendations.length > 0) {
-        console.log();
-        console.log(source_default.bold("Recommendations:"));
-        for (const rec of fb.recommendations) {
-          console.log(source_default.dim(`  * ${rec}`));
+      if (regenerateVideo && videoApiKey) {
+        options.onProgress?.(`Scene ${sceneNum}: regenerating video (${options.generator || "grok"})...`);
+        if (!existsSync26(imagePath)) {
+          result.failedScenes.push(sceneNum);
+          continue;
+        }
+        const imageBuffer = await readFile24(imagePath);
+        const videoDuration = segment.duration > 5 ? 10 : 5;
+        const maxRetries = options.retries ?? DEFAULT_VIDEO_RETRIES;
+        if (options.generator === "grok") {
+          const grok = new GrokProvider();
+          await grok.initialize({ apiKey: videoApiKey });
+          const ext = extname8(imagePath).toLowerCase().slice(1);
+          const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
+          const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
+          const grokDuration = Math.min(15, Math.max(1, segment.duration));
+          const taskResult = await generateVideoWithRetryGrok(
+            grok,
+            segment,
+            {
+              duration: grokDuration,
+              aspectRatio: options.aspectRatio || "16:9",
+              referenceImage
+            },
+            maxRetries
+          );
+          if (taskResult) {
+            try {
+              const waitResult = await grok.waitForCompletion(taskResult.requestId, void 0, 3e5);
+              if (waitResult.status === "completed" && waitResult.videoUrl) {
+                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                await writeFile31(videoPath, buffer);
+                const targetDuration = segment.duration;
+                const actualVideoDuration = await getVideoDuration(videoPath);
+                if (actualVideoDuration < targetDuration - 0.1) {
+                  const extendedPath = resolve34(outputDir, `scene-${sceneNum}-extended.mp4`);
+                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                  await unlink2(videoPath);
+                  await rename3(extendedPath, videoPath);
+                }
+                result.regeneratedScenes.push(sceneNum);
+              } else {
+                logSceneFailure("Grok", `scene ${sceneNum}`, waitResult);
+                result.failedScenes.push(sceneNum);
+              }
+            } catch (err) {
+              logSceneFailure("Grok", `scene ${sceneNum}`, err);
+              result.failedScenes.push(sceneNum);
+            }
+          } else {
+            result.failedScenes.push(sceneNum);
+          }
+        } else if (options.generator === "veo") {
+          const veo = new GeminiProvider();
+          await veo.initialize({ apiKey: videoApiKey });
+          const ext = extname8(imagePath).toLowerCase().slice(1);
+          const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
+          const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
+          const veoDuration = segment.duration > 6 ? 8 : segment.duration > 4 ? 6 : 4;
+          const taskResult = await generateVideoWithRetryVeo(
+            veo,
+            segment,
+            {
+              duration: veoDuration,
+              aspectRatio: options.aspectRatio || "16:9",
+              referenceImage
+            },
+            maxRetries
+          );
+          if (taskResult) {
+            try {
+              const waitResult = await veo.waitForVideoCompletion(taskResult.operationName, void 0, 3e5);
+              if (waitResult.status === "completed" && waitResult.videoUrl) {
+                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                await writeFile31(videoPath, buffer);
+                const targetDuration = segment.duration;
+                const actualVideoDuration = await getVideoDuration(videoPath);
+                if (actualVideoDuration < targetDuration - 0.1) {
+                  const extendedPath = resolve34(outputDir, `scene-${sceneNum}-extended.mp4`);
+                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                  await unlink2(videoPath);
+                  await rename3(extendedPath, videoPath);
+                }
+                result.regeneratedScenes.push(sceneNum);
+              } else {
+                logSceneFailure("Veo", `scene ${sceneNum}`, waitResult);
+                result.failedScenes.push(sceneNum);
+              }
+            } catch (err) {
+              logSceneFailure("Veo", `scene ${sceneNum}`, err);
+              result.failedScenes.push(sceneNum);
+            }
+          } else {
+            result.failedScenes.push(sceneNum);
+          }
+        } else if (options.generator === "kling" || !options.generator) {
+          const kling = new KlingProvider();
+          await kling.initialize({ apiKey: videoApiKey });
+          if (!kling.isConfigured()) {
+            result.failedScenes.push(sceneNum);
+            continue;
+          }
+          const imgbbApiKey = await getApiKeyFromConfig("imgbb") || process.env.IMGBB_API_KEY;
+          let imageUrl;
+          if (imgbbApiKey) {
+            const uploadResult = await uploadToImgbb(imageBuffer, imgbbApiKey);
+            if (uploadResult.success && uploadResult.url) {
+              imageUrl = uploadResult.url;
+            }
+          }
+          const taskResult = await generateVideoWithRetryKling(
+            kling,
+            segment,
+            {
+              duration: videoDuration,
+              aspectRatio: options.aspectRatio || "16:9",
+              referenceImage: imageUrl
+            },
+            maxRetries
+          );
+          if (taskResult) {
+            try {
+              const waitResult = await kling.waitForCompletion(taskResult.taskId, taskResult.type, void 0, 6e5);
+              if (waitResult.status === "completed" && waitResult.videoUrl) {
+                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                await writeFile31(videoPath, buffer);
+                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 (err) {
+              logSceneFailure("Kling", `scene ${sceneNum}`, err);
+              result.failedScenes.push(sceneNum);
+            }
+          } else {
+            result.failedScenes.push(sceneNum);
+          }
+        } else {
+          const runway = new RunwayProvider();
+          await runway.initialize({ apiKey: videoApiKey });
+          const ext = extname8(imagePath).toLowerCase().slice(1);
+          const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : "image/png";
+          const referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
+          const aspectRatio = options.aspectRatio === "1:1" ? "16:9" : options.aspectRatio || "16:9";
+          const taskResult = await generateVideoWithRetryRunway(
+            runway,
+            segment,
+            referenceImage,
+            { duration: videoDuration, aspectRatio },
+            maxRetries
+          );
+          if (taskResult) {
+            try {
+              const waitResult = await runway.waitForCompletion(taskResult.taskId, void 0, 3e5);
+              if (waitResult.status === "completed" && waitResult.videoUrl) {
+                const buffer = await downloadVideo(waitResult.videoUrl, videoApiKey);
+                await writeFile31(videoPath, buffer);
+                const targetDuration = segment.duration;
+                const actualVideoDuration = await getVideoDuration(videoPath);
+                if (actualVideoDuration < targetDuration - 0.1) {
+                  const extendedPath = resolve34(outputDir, `scene-${sceneNum}-extended.mp4`);
+                  await extendVideoNaturally(videoPath, targetDuration, extendedPath);
+                  await unlink2(videoPath);
+                  await rename3(extendedPath, videoPath);
+                }
+                result.regeneratedScenes.push(sceneNum);
+              } else {
+                logSceneFailure("Runway", `scene ${sceneNum}`, waitResult);
+                result.failedScenes.push(sceneNum);
+              }
+            } catch (err) {
+              logSceneFailure("Runway", `scene ${sceneNum}`, err);
+              result.failedScenes.push(sceneNum);
+            }
+          } else {
+            result.failedScenes.push(sceneNum);
+          }
         }
+      } else if (!sceneFailed) {
+        result.regeneratedScenes.push(sceneNum);
       }
-      console.log();
-    } catch (error) {
-      exitWithError(generalError(error instanceof Error ? error.message : "Video review failed"));
     }
-  });
+    if (storyboardMutated) {
+      let currentTime = 0;
+      for (const segment of segments) {
+        segment.startTime = currentTime;
+        currentTime += segment.duration;
+      }
+      const serialized = storyboardPath.endsWith(".yaml") ? (0, import_yaml5.stringify)({ scenes: segments }, { indent: 2 }) : JSON.stringify(segments, null, 2);
+      await writeFile31(storyboardPath, serialized, "utf-8");
+    }
+    result.success = result.failedScenes.length === 0;
+    return result;
+  } catch (error) {
+    return {
+      ...result,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
 }
-var init_ai_review = __esm({
-  "src/commands/ai-review.ts"() {
+var import_yaml5;
+var init_ai_script_pipeline = __esm({
+  "src/commands/ai-script-pipeline.ts"() {
     "use strict";
-    init_source();
-    init_ora();
+    import_yaml5 = __toESM(require_dist(), 1);
     init_dist2();
     init_api_key();
-    init_exec_safe();
-    init_output();
-    init_validate();
+    init_config();
+    init_audio();
+    init_ai_helpers();
+    init_video_utils();
+    init_video_providers();
   }
 });
 
 // src/commands/ai-highlights.ts
 import { readFile as readFile26, writeFile as writeFile33, mkdir as mkdir16 } from "node:fs/promises";
-import { resolve as resolve36, dirname as dirname12, basename as basename9, extname as extname8 } from "node:path";
+import { resolve as resolve36, dirname as dirname12, basename as basename9, extname as extname9 } from "node:path";
 import { existsSync as existsSync28 } from "node:fs";
 function filterHighlights(highlights, options) {
   let filtered = highlights.filter((h) => h.confidence >= options.threshold);
@@ -40015,7 +40291,7 @@ async function executeHighlights(options) {
     if (!existsSync28(absPath)) {
       return { success: false, highlights: [], totalDuration: 0, totalHighlightDuration: 0, error: `File not found: ${absPath}` };
     }
-    const ext = extname8(absPath).toLowerCase();
+    const ext = extname9(absPath).toLowerCase();
     const videoExtensions = [".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v"];
     const isVideo = videoExtensions.includes(ext);
     const targetDuration = options.duration;
@@ -40352,7 +40628,7 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
     };
     for (let i = 0; i < selectedHighlights.length; i++) {
       const h = selectedHighlights[i];
-      const baseName = basename9(absPath, extname8(absPath));
+      const baseName = basename9(absPath, extname9(absPath));
       const outputPath = resolve36(outputDir, `${baseName}-short-${i + 1}.mp4`);
       const { stdout: probeOut } = await execSafe("ffprobe", [
         "-v",
@@ -40451,7 +40727,7 @@ function registerHighlightsCommands(aiCommand) {
         });
         return;
       }
-      const ext = extname8(absPath).toLowerCase();
+      const ext = extname9(absPath).toLowerCase();
       const videoExtensions = [".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v"];
       const isVideo = videoExtensions.includes(ext);
       console.log();
@@ -40929,11 +41205,11 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
         let outputPath;
         if (shortCount === 1 && options.output) {
           outputPath = resolve36(process.cwd(), options.output);
-          if (!extname8(outputPath)) {
+          if (!extname9(outputPath)) {
             outputPath += ".mp4";
           }
         } else {
-          const baseName = basename9(absPath, extname8(absPath));
+          const baseName = basename9(absPath, extname9(absPath));
           outputPath = resolve36(outputDir, `${baseName}-short-${i + 1}.mp4`);
         }
         const parentDir = dirname12(outputPath);
@@ -51819,7 +52095,7 @@ var init_scene_audio_scan = __esm({
 
 // src/commands/_shared/scene-audio-mux.ts
 import { rename as rename4, unlink as unlink3 } from "node:fs/promises";
-import { resolve as resolve45, dirname as dirname15, extname as extname11, basename as basename16 } from "node:path";
+import { resolve as resolve45, dirname as dirname15, extname as extname12, basename as basename16 } from "node:path";
 function buildAudioMuxFilter(audios) {
   if (audios.length === 0) return null;
   const labels = [];
@@ -51878,7 +52154,7 @@ async function muxAudioIntoVideo(opts) {
   if (!filter) {
     return { success: true, outputPath: opts.videoPath, audioCount: 0 };
   }
-  const ext = extname11(opts.videoPath) || `.${opts.format}`;
+  const ext = extname12(opts.videoPath) || `.${opts.format}`;
   const tmpPath = resolve45(
     dirname15(opts.videoPath),
     `.${basename16(opts.videoPath, ext)}.muxing${ext}`
@@ -52536,12 +52812,22 @@ async function executeVideoGenerate(options) {
     const key = apiKey || process.env[envKeyMap[provider] || ""];
     if (!key) return { success: false, error: `${envKeyMap[provider]} required for ${provider}` };
     let referenceImage;
+    let referenceImageBuffer;
+    let referenceImageMimeType;
     if (image) {
       const imagePath = resolve53(process.cwd(), image);
       const imageBuffer = await readFile35(imagePath);
       const ext = image.toLowerCase().split(".").pop();
-      const mimeTypes2 = { jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", gif: "image/gif", webp: "image/webp" };
+      const mimeTypes2 = {
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        webp: "image/webp"
+      };
       const mimeType = mimeTypes2[ext || "png"] || "image/png";
+      referenceImageBuffer = imageBuffer;
+      referenceImageMimeType = mimeType;
       referenceImage = `data:${mimeType};base64,${imageBuffer.toString("base64")}`;
     }
     if (provider === "seedance" || provider === "fal") {
@@ -52549,12 +52835,12 @@ async function executeVideoGenerate(options) {
       await fal.initialize({ apiKey: key });
       let falImage = referenceImage;
       if (falImage && falImage.startsWith("data:")) {
-        const imgbbKey = process.env.IMGBB_API_KEY;
-        if (!imgbbKey) return { success: false, error: "IMGBB_API_KEY required for Seedance image-to-video" };
-        const base64Data = falImage.split(",")[1];
-        const uploadResult = await uploadToImgbb(Buffer.from(base64Data, "base64"), imgbbKey);
-        if (!uploadResult.success || !uploadResult.url) return { success: false, error: `ImgBB upload failed: ${uploadResult.error}` };
-        falImage = uploadResult.url;
+        const uploadHost = await resolveUploadHost();
+        const upload = await uploadHost.uploadImage(referenceImageBuffer, {
+          filename: image,
+          mimeType: referenceImageMimeType
+        });
+        falImage = upload.url;
       }
       const model = seedanceModel === "fast" || seedanceModel === "seedance-2.0-fast" ? "seedance-2.0-fast" : "seedance-2.0";
       const result = await fal.generateVideo(prompt3, {
@@ -52565,14 +52851,22 @@ async function executeVideoGenerate(options) {
         negativePrompt: negative,
         model
       });
-      if (result.status === "failed") return { success: false, error: result.error || "Seedance generation failed" };
+      if (result.status === "failed")
+        return { success: false, error: result.error || "Seedance generation failed" };
       let outputPath;
       if (output && result.videoUrl) {
         const buffer = await downloadVideo(result.videoUrl, key);
         outputPath = resolve53(process.cwd(), output);
         await writeFile39(outputPath, buffer);
       }
-      return { success: true, taskId: result.id, status: "completed", videoUrl: result.videoUrl, outputPath, provider: "seedance" };
+      return {
+        success: true,
+        taskId: result.id,
+        status: "completed",
+        videoUrl: result.videoUrl,
+        outputPath,
+        provider: "seedance"
+      };
     } else if (provider === "runway") {
       const runway = new RunwayProvider();
       await runway.initialize({ apiKey: key });
@@ -52583,30 +52877,41 @@ async function executeVideoGenerate(options) {
         aspectRatio: ratio,
         seed
       });
-      if (result.status === "failed") return { success: false, error: result.error || "Runway generation failed" };
-      if (!wait) return { success: true, taskId: result.id, status: "processing", provider: "runway" };
+      if (result.status === "failed")
+        return { success: false, error: result.error || "Runway generation failed" };
+      if (!wait)
+        return { success: true, taskId: result.id, status: "processing", provider: "runway" };
       const finalResult = await runway.waitForCompletion(result.id, () => {
       }, 3e5);
-      if (finalResult.status !== "completed") return { success: false, error: finalResult.error || "Runway generation failed" };
+      if (finalResult.status !== "completed")
+        return { success: false, error: finalResult.error || "Runway generation failed" };
       let outputPath;
       if (output && finalResult.videoUrl) {
         const buffer = await downloadVideo(finalResult.videoUrl, key);
         outputPath = resolve53(process.cwd(), output);
         await writeFile39(outputPath, buffer);
       }
-      return { success: true, taskId: result.id, status: "completed", videoUrl: finalResult.videoUrl, duration: finalResult.duration, outputPath, provider: "runway" };
+      return {
+        success: true,
+        taskId: result.id,
+        status: "completed",
+        videoUrl: finalResult.videoUrl,
+        duration: finalResult.duration,
+        outputPath,
+        provider: "runway"
+      };
     } else if (provider === "kling") {
       const kling = new KlingProvider();
       await kling.initialize({ apiKey: key });
       if (!kling.isConfigured()) return { success: false, error: "Invalid Kling API key format" };
       let klingImage = referenceImage;
       if (klingImage && klingImage.startsWith("data:")) {
-        const imgbbKey = process.env.IMGBB_API_KEY;
-        if (!imgbbKey) return { success: false, error: "IMGBB_API_KEY required for Kling image-to-video" };
-        const base64Data = klingImage.split(",")[1];
-        const uploadResult = await uploadToImgbb(Buffer.from(base64Data, "base64"), imgbbKey);
-        if (!uploadResult.success || !uploadResult.url) return { success: false, error: `ImgBB upload failed: ${uploadResult.error}` };
-        klingImage = uploadResult.url;
+        const uploadHost = await resolveUploadHost();
+        const upload = await uploadHost.uploadImage(referenceImageBuffer, {
+          filename: image,
+          mimeType: referenceImageMimeType
+        });
+        klingImage = upload.url;
       }
       const result = await kling.generateVideo(prompt3, {
         prompt: prompt3,
@@ -52616,23 +52921,38 @@ async function executeVideoGenerate(options) {
         negativePrompt: negative,
         mode
       });
-      if (result.status === "failed") return { success: false, error: result.error || "Kling generation failed" };
+      if (result.status === "failed")
+        return { success: false, error: result.error || "Kling generation failed" };
       const taskType = referenceImage ? "image2video" : "text2video";
-      if (!wait) return { success: true, taskId: result.id, status: "processing", provider: "kling" };
+      if (!wait)
+        return { success: true, taskId: result.id, status: "processing", provider: "kling" };
       const finalResult = await kling.waitForCompletion(result.id, taskType, () => {
       }, 6e5);
-      if (finalResult.status !== "completed") return { success: false, error: finalResult.error || "Kling generation failed" };
+      if (finalResult.status !== "completed")
+        return { success: false, error: finalResult.error || "Kling generation failed" };
       let outputPath;
       if (output && finalResult.videoUrl) {
         const buffer = await downloadVideo(finalResult.videoUrl, key);
         outputPath = resolve53(process.cwd(), output);
         await writeFile39(outputPath, buffer);
       }
-      return { success: true, taskId: result.id, status: "completed", videoUrl: finalResult.videoUrl, duration: finalResult.duration, outputPath, provider: "kling" };
+      return {
+        success: true,
+        taskId: result.id,
+        status: "completed",
+        videoUrl: finalResult.videoUrl,
+        duration: finalResult.duration,
+        outputPath,
+        provider: "kling"
+      };
     } else if (provider === "veo") {
       const gemini = new GeminiProvider();
       await gemini.initialize({ apiKey: key });
-      const veoModelMap = { "3.0": "veo-3.0-generate-preview", "3.1": "veo-3.1-generate-preview", "3.1-fast": "veo-3.1-fast-generate-preview" };
+      const veoModelMap = {
+        "3.0": "veo-3.0-generate-preview",
+        "3.1": "veo-3.1-generate-preview",
+        "3.1-fast": "veo-3.1-fast-generate-preview"
+      };
       const model = veoModelMap[veoModel] || "veo-3.1-fast-generate-preview";
       const veoDuration = duration <= 6 ? 6 : 8;
       const result = await gemini.generateVideo(prompt3, {
@@ -52644,18 +52964,27 @@ async function executeVideoGenerate(options) {
         negativePrompt: negative,
         resolution
       });
-      if (result.status === "failed") return { success: false, error: result.error || "Veo generation failed" };
+      if (result.status === "failed")
+        return { success: false, error: result.error || "Veo generation failed" };
       if (!wait) return { success: true, taskId: result.id, status: "processing", provider: "veo" };
       const finalResult = await gemini.waitForVideoCompletion(result.id, () => {
       }, 3e5);
-      if (finalResult.status !== "completed") return { success: false, error: finalResult.error || "Veo generation failed" };
+      if (finalResult.status !== "completed")
+        return { success: false, error: finalResult.error || "Veo generation failed" };
       let outputPath;
       if (output && finalResult.videoUrl) {
         const buffer = await downloadVideo(finalResult.videoUrl, key);
         outputPath = resolve53(process.cwd(), output);
         await writeFile39(outputPath, buffer);
       }
-      return { success: true, taskId: result.id, status: "completed", videoUrl: finalResult.videoUrl, outputPath, provider: "veo" };
+      return {
+        success: true,
+        taskId: result.id,
+        status: "completed",
+        videoUrl: finalResult.videoUrl,
+        outputPath,
+        provider: "veo"
+      };
     } else if (provider === "grok") {
       const grok = new GrokProvider();
       await grok.initialize({ apiKey: key });
@@ -52665,28 +52994,52 @@ async function executeVideoGenerate(options) {
         duration,
         aspectRatio: ratio
       });
-      if (result.status === "failed") return { success: false, error: result.error || "Grok generation failed" };
-      if (!wait) return { success: true, taskId: result.id, status: "processing", provider: "grok" };
+      if (result.status === "failed")
+        return { success: false, error: result.error || "Grok generation failed" };
+      if (!wait)
+        return { success: true, taskId: result.id, status: "processing", provider: "grok" };
       const finalResult = await grok.waitForCompletion(result.id, () => {
       }, 3e5);
-      if (finalResult.status !== "completed") return { success: false, error: finalResult.error || "Grok generation failed" };
+      if (finalResult.status !== "completed")
+        return { success: false, error: finalResult.error || "Grok generation failed" };
       let outputPath;
       if (output && finalResult.videoUrl) {
         const buffer = await downloadVideo(finalResult.videoUrl, key);
         outputPath = resolve53(process.cwd(), output);
         await writeFile39(outputPath, buffer);
       }
-      return { success: true, taskId: result.id, status: "completed", videoUrl: finalResult.videoUrl, duration: finalResult.duration, outputPath, provider: "grok" };
+      return {
+        success: true,
+        taskId: result.id,
+        status: "completed",
+        videoUrl: finalResult.videoUrl,
+        duration: finalResult.duration,
+        outputPath,
+        provider: "grok"
+      };
     }
     return { success: false, error: `Unsupported provider: ${provider}` };
   } catch (error) {
-    return { success: false, error: `Video generation failed: ${error instanceof Error ? error.message : String(error)}` };
+    return {
+      success: false,
+      error: `Video generation failed: ${error instanceof Error ? error.message : String(error)}`
+    };
   }
 }
 async function executeVideoStatus(options) {
-  const { taskId, provider = "runway", taskType = "text2video", wait = false, output, apiKey } = options;
+  const {
+    taskId,
+    provider = "runway",
+    taskType = "text2video",
+    wait = false,
+    output,
+    apiKey
+  } = options;
   try {
-    const envKeyMap = { runway: "RUNWAY_API_SECRET", kling: "KLING_API_KEY" };
+    const envKeyMap = {
+      runway: "RUNWAY_API_SECRET",
+      kling: "KLING_API_KEY"
+    };
     const key = apiKey || process.env[envKeyMap[provider] || ""];
     if (!key) return { success: false, error: `${envKeyMap[provider]} required` };
     if (provider === "runway") {
@@ -52703,7 +53056,14 @@ async function executeVideoStatus(options) {
         outputPath = resolve53(process.cwd(), output);
         await writeFile39(outputPath, buffer);
       }
-      return { success: true, taskId, status: result.status, progress: result.progress, videoUrl: result.videoUrl, outputPath };
+      return {
+        success: true,
+        taskId,
+        status: result.status,
+        progress: result.progress,
+        videoUrl: result.videoUrl,
+        outputPath
+      };
     } else if (provider === "kling") {
       const kling = new KlingProvider();
       await kling.initialize({ apiKey: key });
@@ -52718,11 +53078,21 @@ async function executeVideoStatus(options) {
         outputPath = resolve53(process.cwd(), output);
         await writeFile39(outputPath, buffer);
       }
-      return { success: true, taskId, status: result.status, videoUrl: result.videoUrl, duration: result.duration, outputPath };
+      return {
+        success: true,
+        taskId,
+        status: result.status,
+        videoUrl: result.videoUrl,
+        duration: result.duration,
+        outputPath
+      };
     }
     return { success: false, error: `Unsupported provider: ${provider}` };
   } catch (error) {
-    return { success: false, error: `Status check failed: ${error instanceof Error ? error.message : String(error)}` };
+    return {
+      success: false,
+      error: `Status check failed: ${error instanceof Error ? error.message : String(error)}`
+    };
   }
 }
 async function executeVideoCancel(options) {
@@ -52735,11 +53105,24 @@ async function executeVideoCancel(options) {
     const success = await runway.cancelGeneration(taskId);
     return { success };
   } catch (error) {
-    return { success: false, error: `Cancel failed: ${error instanceof Error ? error.message : String(error)}` };
+    return {
+      success: false,
+      error: `Cancel failed: ${error instanceof Error ? error.message : String(error)}`
+    };
   }
 }
 async function executeVideoExtend(options) {
-  const { videoId, provider = "kling", prompt: prompt3, duration = 5, negative, veoModel = "3.1", output, wait = true, apiKey } = options;
+  const {
+    videoId,
+    provider = "kling",
+    prompt: prompt3,
+    duration = 5,
+    negative,
+    veoModel = "3.1",
+    output,
+    wait = true,
+    apiKey
+  } = options;
   try {
     if (provider === "kling") {
       const key = apiKey || process.env.KLING_API_KEY;
@@ -52752,52 +53135,76 @@ async function executeVideoExtend(options) {
         negativePrompt: negative,
         duration: String(duration)
       });
-      if (result.status === "failed") return { success: false, error: result.error || "Kling extension failed" };
+      if (result.status === "failed")
+        return { success: false, error: result.error || "Kling extension failed" };
       if (!wait) return { success: true, taskId: result.id, status: "processing" };
       const finalResult = await kling.waitForExtendCompletion(result.id, () => {
       }, 6e5);
-      if (finalResult.status !== "completed") return { success: false, error: finalResult.error || "Kling extension failed" };
+      if (finalResult.status !== "completed")
+        return { success: false, error: finalResult.error || "Kling extension failed" };
       let outputPath;
       if (output && finalResult.videoUrl) {
         const buffer = await downloadVideo(finalResult.videoUrl, key);
         outputPath = resolve53(process.cwd(), output);
         await writeFile39(outputPath, buffer);
       }
-      return { success: true, taskId: result.id, status: "completed", videoUrl: finalResult.videoUrl, duration: finalResult.duration, outputPath };
+      return {
+        success: true,
+        taskId: result.id,
+        status: "completed",
+        videoUrl: finalResult.videoUrl,
+        duration: finalResult.duration,
+        outputPath
+      };
     } else if (provider === "veo") {
       const key = apiKey || process.env.GOOGLE_API_KEY;
       if (!key) return { success: false, error: "GOOGLE_API_KEY required" };
       const gemini = new GeminiProvider();
       await gemini.initialize({ apiKey: key });
-      const veoModelMap = { "3.0": "veo-3.0-generate-preview", "3.1": "veo-3.1-generate-preview", "3.1-fast": "veo-3.1-fast-generate-preview" };
+      const veoModelMap = {
+        "3.0": "veo-3.0-generate-preview",
+        "3.1": "veo-3.1-generate-preview",
+        "3.1-fast": "veo-3.1-fast-generate-preview"
+      };
       const model = veoModelMap[veoModel] || "veo-3.1-generate-preview";
       const result = await gemini.extendVideo(videoId, prompt3, {
         duration,
         model
       });
-      if (result.status === "failed") return { success: false, error: result.error || "Veo extension failed" };
+      if (result.status === "failed")
+        return { success: false, error: result.error || "Veo extension failed" };
       if (!wait) return { success: true, taskId: result.id, status: "processing" };
       const finalResult = await gemini.waitForVideoCompletion(result.id, () => {
       }, 3e5);
-      if (finalResult.status !== "completed") return { success: false, error: finalResult.error || "Veo extension failed" };
+      if (finalResult.status !== "completed")
+        return { success: false, error: finalResult.error || "Veo extension failed" };
       let outputPath;
       if (output && finalResult.videoUrl) {
         const buffer = await downloadVideo(finalResult.videoUrl, key);
         outputPath = resolve53(process.cwd(), output);
         await writeFile39(outputPath, buffer);
       }
-      return { success: true, taskId: result.id, status: "completed", videoUrl: finalResult.videoUrl, outputPath };
+      return {
+        success: true,
+        taskId: result.id,
+        status: "completed",
+        videoUrl: finalResult.videoUrl,
+        outputPath
+      };
     }
     return { success: false, error: `Unsupported provider: ${provider}` };
   } catch (error) {
-    return { success: false, error: `Video extension failed: ${error instanceof Error ? error.message : String(error)}` };
+    return {
+      success: false,
+      error: `Video extension failed: ${error instanceof Error ? error.message : String(error)}`
+    };
   }
 }
 var init_ai_video = __esm({
   "src/commands/ai-video.ts"() {
     "use strict";
     init_dist2();
-    init_ai_script_pipeline();
+    init_upload_host();
     init_ai_helpers();
   }
 });
@@ -52811,7 +53218,7 @@ __export(ai_audio_exports, {
   executeTranscribe: () => executeTranscribe,
   executeVoiceClone: () => executeVoiceClone
 });
-import { resolve as resolve54, dirname as dirname19, basename as basename18, extname as extname12 } from "node:path";
+import { resolve as resolve54, dirname as dirname19, basename as basename18, extname as extname13 } from "node:path";
 import { readFile as readFile36, writeFile as writeFile40 } from "node:fs/promises";
 import { existsSync as existsSync38 } from "node:fs";
 async function executeTranscribe(options) {
@@ -52908,7 +53315,7 @@ async function executeDub(options) {
     if (!openaiKey) return { success: false, error: "OPENAI_API_KEY required for Whisper transcription" };
     if (!anthropicKey) return { success: false, error: "ANTHROPIC_API_KEY required for Claude translation" };
     if (!analyzeOnly && !elevenlabsKey) return { success: false, error: "ELEVENLABS_API_KEY required for TTS" };
-    const ext = extname12(absPath).toLowerCase();
+    const ext = extname13(absPath).toLowerCase();
     const isVideo = [".mp4", ".mov", ".avi", ".mkv", ".webm"].includes(ext);
     let audioPath = absPath;
     if (isVideo) {
@@ -52993,8 +53400,8 @@ ${segmentTexts}`,
       }
     }
     const combinedBuffer = Buffer.concat(dubbedBuffers);
-    const outputExt = isVideo ? ".mp3" : extname12(absPath);
-    const defaultOutputPath2 = resolve54(dirname19(absPath), `${basename18(absPath, extname12(absPath))}-${language}${outputExt}`);
+    const outputExt = isVideo ? ".mp3" : extname13(absPath);
+    const defaultOutputPath2 = resolve54(dirname19(absPath), `${basename18(absPath, extname13(absPath))}-${language}${outputExt}`);
     const finalOutputPath = resolve54(process.cwd(), output || defaultOutputPath2);
     await writeFile40(finalOutputPath, combinedBuffer);
     if (isVideo && audioPath !== absPath) {
@@ -53031,7 +53438,7 @@ async function executeDuck(options) {
     const absVoicePath = resolve54(process.cwd(), voicePath);
     if (!existsSync38(absMusicPath)) return { success: false, error: `Music file not found: ${absMusicPath}` };
     if (!existsSync38(absVoicePath)) return { success: false, error: `Voice file not found: ${absVoicePath}` };
-    const defaultOutput = resolve54(dirname19(absMusicPath), `${basename18(absMusicPath, extname12(absMusicPath))}-ducked${extname12(absMusicPath)}`);
+    const defaultOutput = resolve54(dirname19(absMusicPath), `${basename18(absMusicPath, extname13(absMusicPath))}-ducked${extname13(absMusicPath)}`);
     const outputPath = resolve54(process.cwd(), output || defaultOutput);
     const filter = `[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", [
@@ -59608,11 +60015,17 @@ var init_generate2 = __esm({
       }),
       async execute(args) {
         const result = await executeMotion(args);
-        if (!result.success) return { success: false, error: result.error ?? "Motion generation failed" };
+        if (!result.success)
+          return { success: false, error: result.error ?? "Motion generation failed" };
         const out = result.compositedPath ?? result.renderedPath ?? result.codePath;
         return {
           success: true,
-          data: { codePath: result.codePath, renderedPath: result.renderedPath, compositedPath: result.compositedPath, componentName: result.componentName },
+          data: {
+            codePath: result.codePath,
+            renderedPath: result.renderedPath,
+            compositedPath: result.compositedPath,
+            componentName: result.componentName
+          },
           humanLines: [`\u2705 Motion generated \u2192 ${out}`]
         };
       }
@@ -59676,7 +60089,9 @@ var init_generate2 = __esm({
         return {
           success: true,
           data: { outputPath: result.outputPath, provider: result.provider, duration: result.duration },
-          humanLines: [`\u2705 Music${result.provider ? ` (${result.provider})` : ""} \u2192 ${result.outputPath ?? "(async)"}`]
+          humanLines: [
+            `\u2705 Music${result.provider ? ` (${result.provider})` : ""} \u2192 ${result.outputPath ?? "(async)"}`
+          ]
         };
       }
     });
@@ -59693,7 +60108,12 @@ var init_generate2 = __esm({
         if (!result.success) return { success: false, error: result.error ?? "Music status failed" };
         return {
           success: true,
-          data: { taskId: result.taskId, status: result.status, audioUrl: result.audioUrl, error: result.error },
+          data: {
+            taskId: result.taskId,
+            status: result.status,
+            audioUrl: result.audioUrl,
+            error: result.error
+          },
           humanLines: [`Music task ${result.taskId}: ${result.status}`]
         };
       }
@@ -59705,7 +60125,9 @@ var init_generate2 = __esm({
       description: "Generate an image using AI. Supports Gemini (free), OpenAI GPT Image, or Grok Imagine. Requires GOOGLE_API_KEY (Gemini), OPENAI_API_KEY (OpenAI), or XAI_API_KEY (Grok).",
       schema: external_exports.object({
         prompt: external_exports.string().describe("Image description prompt"),
-        provider: external_exports.enum(["gemini", "openai", "grok"]).optional().describe("Image provider (default: gemini)"),
+        provider: external_exports.enum(["gemini", "openai", "grok"]).optional().describe(
+          "Image provider (default: openai when OPENAI_API_KEY is configured, otherwise first configured provider)"
+        ),
         output: external_exports.string().optional().describe("Output file path"),
         size: external_exports.string().optional().describe("Image size for OpenAI (1024x1024, 1536x1024, 1024x1536)"),
         ratio: external_exports.string().optional().describe("Aspect ratio for Gemini (1:1, 16:9, 9:16, 4:3, 3:4, etc.)"),
@@ -59715,10 +60137,16 @@ var init_generate2 = __esm({
       }),
       async execute(args) {
         const result = await executeImageGenerate(args);
-        if (!result.success) return { success: false, error: result.error ?? "Image generation failed" };
+        if (!result.success)
+          return { success: false, error: result.error ?? "Image generation failed" };
         return {
           success: true,
-          data: { outputPath: result.outputPath, provider: result.provider, model: result.model, imageCount: result.images?.length },
+          data: {
+            outputPath: result.outputPath,
+            provider: result.provider,
+            model: result.model,
+            imageCount: result.images?.length
+          },
           humanLines: [`\u2705 Image (${result.provider}) \u2192 ${result.outputPath}`]
         };
       }
@@ -59740,7 +60168,9 @@ var init_generate2 = __esm({
         return {
           success: true,
           data: { segmentCount: result.segmentCount, outputPath: result.outputPath },
-          humanLines: [`\u2705 Storyboard: ${result.segmentCount} segments${result.outputPath ? ` \u2192 ${result.outputPath}` : ""}`]
+          humanLines: [
+            `\u2705 Storyboard: ${result.segmentCount} segments${result.outputPath ? ` \u2192 ${result.outputPath}` : ""}`
+          ]
         };
       }
     });
@@ -59759,7 +60189,11 @@ var init_generate2 = __esm({
         if (!result.success) return { success: false, error: result.error ?? "Background failed" };
         return {
           success: true,
-          data: { imageUrl: result.imageUrl, outputPath: result.outputPath, revisedPrompt: result.revisedPrompt },
+          data: {
+            imageUrl: result.imageUrl,
+            outputPath: result.outputPath,
+            revisedPrompt: result.revisedPrompt
+          },
           humanLines: [`\u2705 Background \u2192 ${result.outputPath ?? result.imageUrl}`]
         };
       }
@@ -59817,7 +60251,9 @@ var init_generate2 = __esm({
             outputPath: result.outputPath,
             provider: result.provider
           },
-          humanLines: [`\u2705 Video (${result.provider}, ${result.status})${result.outputPath ? ` \u2192 ${result.outputPath}` : ""}`]
+          humanLines: [
+            `\u2705 Video (${result.provider}, ${result.status})${result.outputPath ? ` \u2192 ${result.outputPath}` : ""}`
+          ]
         };
       }
     });
@@ -59838,8 +60274,16 @@ var init_generate2 = __esm({
         if (!result.success) return { success: false, error: result.error ?? "Status check failed" };
         return {
           success: true,
-          data: { taskId: result.taskId, status: result.status, progress: result.progress, videoUrl: result.videoUrl, outputPath: result.outputPath },
-          humanLines: [`Task ${result.taskId}: ${result.status}${result.progress !== void 0 ? ` (${result.progress}%)` : ""}`]
+          data: {
+            taskId: result.taskId,
+            status: result.status,
+            progress: result.progress,
+            videoUrl: result.videoUrl,
+            outputPath: result.outputPath
+          },
+          humanLines: [
+            `Task ${result.taskId}: ${result.status}${result.progress !== void 0 ? ` (${result.progress}%)` : ""}`
+          ]
         };
       }
     });
@@ -59881,8 +60325,16 @@ var init_generate2 = __esm({
         if (!result.success) return { success: false, error: result.error ?? "Extend failed" };
         return {
           success: true,
-          data: { taskId: result.taskId, status: result.status, videoUrl: result.videoUrl, duration: result.duration, outputPath: result.outputPath },
-          humanLines: [`\u2705 Video extended (${result.status})${result.outputPath ? ` \u2192 ${result.outputPath}` : ""}`]
+          data: {
+            taskId: result.taskId,
+            status: result.status,
+            videoUrl: result.videoUrl,
+            duration: result.duration,
+            outputPath: result.outputPath
+          },
+          humanLines: [
+            `\u2705 Video extended (${result.status})${result.outputPath ? ` \u2192 ${result.outputPath}` : ""}`
+          ]
         };
       }
     });
@@ -61813,7 +62265,7 @@ var init_export2 = __esm({
 
 // src/tools/manifest/agent-only.ts
 import { readFile as readFile41, writeFile as writeFile48, readdir as readdir4, stat as stat6, access as access9, unlink as unlink4 } from "node:fs/promises";
-import { resolve as resolve63, join as join16, basename as basename22, extname as extname13 } from "node:path";
+import { resolve as resolve63, join as join16, basename as basename22, extname as extname14 } from "node:path";
 function matchPattern(filename, pattern) {
   const regex2 = new RegExp(
     "^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".") + "$",
@@ -61832,7 +62284,7 @@ function formatSize(bytes) {
   return `${size.toFixed(1)}${units2[unit]}`;
 }
 function detectMediaType4(filePath) {
-  const ext = extname13(filePath).toLowerCase();
+  const ext = extname14(filePath).toLowerCase();
   if ([".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v"].includes(ext)) return "video";
   if ([".mp3", ".wav", ".aac", ".flac", ".ogg", ".m4a"].includes(ext)) return "audio";
   if ([".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"].includes(ext)) return "image";
@@ -61859,7 +62311,7 @@ function isMediaFile2(filePath) {
     ".webp",
     ".bmp"
   ];
-  return mediaExts.includes(extname13(filePath).toLowerCase());
+  return mediaExts.includes(extname14(filePath).toLowerCase());
 }
 async function getMediaDuration2(filePath) {
   try {
@@ -62005,7 +62457,7 @@ var init_agent_only = __esm({
               if (entry.isDirectory() && recursive) {
                 await scanDir(entryPath);
               } else if (entry.isFile()) {
-                const ext = extname13(entry.name).toLowerCase();
+                const ext = extname14(entry.name).toLowerCase();
                 const matchesFilter = !filterExts || filterExts.includes(ext);
                 if (matchesFilter && isMediaFile2(entryPath)) mediaFiles.push(entryPath);
               }
@@ -62973,7 +63425,7 @@ init_source();
 // package.json
 var package_default = {
   name: "@vibeframe/cli",
-  version: "0.91.9",
+  version: "0.92.0",
   description: "VibeFrame CLI - natural language video editing from the terminal",
   private: false,
   license: "MIT",
@@ -64159,8 +64611,8 @@ init_output();
 init_sanitize();
 init_validate();
 init_cost_tier();
-import { readFile as readFile23, writeFile as writeFile30 } from "node:fs/promises";
-import { resolve as resolve33 } from "node:path";
+import { readFile as readFile22, writeFile as writeFile29 } from "node:fs/promises";
+import { resolve as resolve32 } from "node:path";
 var inspectCommand = new Command("inspect").description("Inspect media using AI (images, videos, YouTube URLs)").addHelpText(
   "after",
   `
@@ -64357,8 +64809,8 @@ inspectCommand.command("suggest").description("Get AI edit suggestions using Gem
     }
     const apiKey = await requireApiKey("GOOGLE_API_KEY", "Google", options.apiKey);
     const spinner2 = ora("Initializing Gemini...").start();
-    const filePath = resolve33(process.cwd(), projectPath);
-    const content = await readFile23(filePath, "utf-8");
+    const filePath = resolve32(process.cwd(), projectPath);
+    const content = await readFile22(filePath, "utf-8");
     const data = JSON.parse(content);
     const project = Project.fromJSON(data);
     const gemini = new GeminiProvider();
@@ -64395,7 +64847,7 @@ inspectCommand.command("suggest").description("Get AI edit suggestions using Gem
       const sug = suggestions[0];
       const applied = applySuggestion(project, sug);
       if (applied) {
-        await writeFile30(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+        await writeFile29(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
         spinner2.succeed(source_default.green("Suggestion applied"));
       } else {
         spinner2.warn(source_default.yellow("Could not apply suggestion automatically"));
@@ -64420,9 +64872,9 @@ init_cost_tier();
 init_ai_helpers();
 init_output();
 init_validate();
-import { resolve as resolve34, dirname as dirname11, basename as basename8, extname as extname7 } from "node:path";
-import { readFile as readFile24, writeFile as writeFile31 } from "node:fs/promises";
-import { existsSync as existsSync26 } from "node:fs";
+import { resolve as resolve33, dirname as dirname11, basename as basename8, extname as extname7 } from "node:path";
+import { readFile as readFile23, writeFile as writeFile30 } from "node:fs/promises";
+import { existsSync as existsSync25 } from "node:fs";
 var audioCommand = new Command("audio").alias("au").description("Audio operations (transcribe, TTS, voice clone, ducking)").addHelpText(
   "after",
   `
@@ -64455,8 +64907,8 @@ audioCommand.command("transcribe").description("Transcribe audio using Whisper")
     const whisper = new WhisperProvider();
     await whisper.initialize({ apiKey });
     spinner2.text = "Reading audio file...";
-    const absPath = resolve34(process.cwd(), audioPath);
-    const audioBuffer = await readFile24(absPath);
+    const absPath = resolve33(process.cwd(), audioPath);
+    const audioBuffer = await readFile23(absPath);
     const audioBlob = new Blob([audioBuffer]);
     spinner2.text = "Transcribing...";
     const result = await whisper.transcribe(audioBlob, options.language);
@@ -64473,7 +64925,7 @@ audioCommand.command("transcribe").description("Transcribe audio using Whisper")
           fullText: result.fullText,
           segments: result.segments,
           language: result.detectedLanguage,
-          outputPath: options.output ? resolve34(process.cwd(), options.output) : void 0
+          outputPath: options.output ? resolve33(process.cwd(), options.output) : void 0
         }
       });
       return;
@@ -64493,10 +64945,10 @@ audioCommand.command("transcribe").description("Transcribe audio using Whisper")
       console.log();
     }
     if (options.output) {
-      const outputPath = resolve34(process.cwd(), options.output);
+      const outputPath = resolve33(process.cwd(), options.output);
       const format = detectFormat(options.output, options.format);
       const content = formatTranscript(result, format);
-      await writeFile31(outputPath, content, "utf-8");
+      await writeFile30(outputPath, content, "utf-8");
       console.log(source_default.green(`Saved ${format.toUpperCase()} to: ${outputPath}`));
     }
   } catch (error) {
@@ -64554,8 +65006,8 @@ audioCommand.command("isolate").description("Isolate vocals from audio using Ele
     }
     const apiKey = await requireApiKey("ELEVENLABS_API_KEY", "ElevenLabs", options.apiKey);
     const spinner2 = ora("Reading audio file...").start();
-    const absPath = resolve34(process.cwd(), audioPath);
-    const audioBuffer = await readFile24(absPath);
+    const absPath = resolve33(process.cwd(), audioPath);
+    const audioBuffer = await readFile23(absPath);
     spinner2.text = "Isolating vocals...";
     const elevenlabs = new ElevenLabsProvider();
     await elevenlabs.initialize({ apiKey });
@@ -64564,8 +65016,8 @@ audioCommand.command("isolate").description("Isolate vocals from audio using Ele
       spinner2.fail(result.error || "Audio isolation failed");
       exitWithError(apiError(result.error || "Audio isolation failed", true));
     }
-    const outputPath = resolve34(process.cwd(), options.output);
-    await writeFile31(outputPath, result.audioBuffer);
+    const outputPath = resolve33(process.cwd(), options.output);
+    await writeFile30(outputPath, result.audioBuffer);
     spinner2.succeed(source_default.green("Vocals isolated"));
     if (isJsonMode()) {
       outputSuccess({
@@ -64625,12 +65077,12 @@ audioCommand.command("clone-voice").description("Clone a voice from audio sample
     const spinner2 = ora("Reading audio samples...").start();
     const audioBuffers = [];
     for (const samplePath of samples) {
-      const absPath = resolve34(process.cwd(), samplePath);
-      if (!existsSync26(absPath)) {
+      const absPath = resolve33(process.cwd(), samplePath);
+      if (!existsSync25(absPath)) {
         spinner2.fail(`File not found: ${samplePath}`);
         exitWithError(notFoundError(samplePath));
       }
-      const buffer = await readFile24(absPath);
+      const buffer = await readFile23(absPath);
       audioBuffers.push(buffer);
     }
     spinner2.text = `Cloning voice from ${audioBuffers.length} sample(s)...`;
@@ -64686,8 +65138,8 @@ audioCommand.command("dub").description("Dub audio/video to another language (tr
     if (!options.language) {
       exitWithError(usageError("Target language is required. Use -l or --language"));
     }
-    const absPath = resolve34(process.cwd(), mediaPath);
-    if (!existsSync26(absPath)) {
+    const absPath = resolve33(process.cwd(), mediaPath);
+    if (!existsSync25(absPath)) {
       exitWithError(notFoundError(mediaPath));
     }
     const openaiKey = await requireApiKey("OPENAI_API_KEY", "OpenAI");
@@ -64698,7 +65150,7 @@ audioCommand.command("dub").description("Dub audio/video to another language (tr
     const isVideo = [".mp4", ".mov", ".avi", ".mkv", ".webm"].includes(ext);
     let audioPath = absPath;
     if (isVideo) {
-      const tempAudioPath = resolve34(dirname11(absPath), `temp-audio-${Date.now()}.mp3`);
+      const tempAudioPath = resolve33(dirname11(absPath), `temp-audio-${Date.now()}.mp3`);
       try {
         execSafeSync("ffmpeg", ["-i", absPath, "-vn", "-acodec", "mp3", "-y", tempAudioPath]);
         audioPath = tempAudioPath;
@@ -64710,7 +65162,7 @@ audioCommand.command("dub").description("Dub audio/video to another language (tr
     spinner2.text = "Transcribing audio...";
     const whisper = new WhisperProvider();
     await whisper.initialize({ apiKey: openaiKey });
-    const audioBuffer = await readFile24(audioPath);
+    const audioBuffer = await readFile23(audioPath);
     const audioBlob = new Blob([audioBuffer]);
     const transcriptResult = await whisper.transcribe(audioBlob, options.source);
     if (transcriptResult.status === "failed" || !transcriptResult.segments) {
@@ -64791,7 +65243,7 @@ ${segmentTexts}`,
       console.log();
       console.log(source_default.dim("Use without --analyze-only to generate dubbed audio"));
       if (options.output) {
-        const timingPath = resolve34(process.cwd(), options.output);
+        const timingPath = resolve33(process.cwd(), options.output);
         const timingData = {
           sourcePath: absPath,
           sourceLanguage: transcriptResult.detectedLanguage || options.source || "auto",
@@ -64804,7 +65256,7 @@ ${segmentTexts}`,
             translated: translatedSegments[i]?.text || s.text
           }))
         };
-        await writeFile31(timingPath, JSON.stringify(timingData, null, 2));
+        await writeFile30(timingPath, JSON.stringify(timingData, null, 2));
         console.log(`Timing saved to: ${source_default.bold(timingPath)}`);
       }
       return;
@@ -64829,12 +65281,12 @@ ${segmentTexts}`,
     spinner2.text = "Combining audio...";
     const combinedBuffer = Buffer.concat(dubbedAudioBuffers.map((a) => a.buffer));
     const outputExt = isVideo ? ".mp3" : extname7(absPath);
-    const defaultOutputPath2 = resolve34(
+    const defaultOutputPath2 = resolve33(
       dirname11(absPath),
       `${basename8(absPath, extname7(absPath))}-${options.language}${outputExt}`
     );
-    const finalOutputPath = resolve34(process.cwd(), options.output || defaultOutputPath2);
-    await writeFile31(finalOutputPath, combinedBuffer);
+    const finalOutputPath = resolve33(process.cwd(), options.output || defaultOutputPath2);
+    await writeFile30(finalOutputPath, combinedBuffer);
     spinner2.succeed(source_default.green("Dubbing complete"));
     if (isJsonMode()) {
       outputSuccess({
@@ -64890,9 +65342,9 @@ audioCommand.command("duck").description("Auto-duck background music when voice
       exitWithError(generalError("FFmpeg not found", "Install with: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)"));
     }
     const spinner2 = ora("Processing audio ducking...").start();
-    const absMusic = resolve34(process.cwd(), musicPath);
-    const absVoice = resolve34(process.cwd(), options.voice);
-    const outputPath = options.output ? resolve34(process.cwd(), options.output) : absMusic.replace(/(\.[^.]+)$/, "-ducked$1");
+    const absMusic = resolve33(process.cwd(), musicPath);
+    const absVoice = resolve33(process.cwd(), options.voice);
+    const outputPath = options.output ? resolve33(process.cwd(), options.output) : absMusic.replace(/(\.[^.]+)$/, "-ducked$1");
     const thresholdDb = parseFloat(options.threshold);
     const thresholdLinear = Math.pow(10, thresholdDb / 20);
     const ratio = parseFloat(options.ratio);
@@ -65500,7 +65952,7 @@ init_esm();
 init_source();
 init_ora();
 import { stat as stat4 } from "node:fs/promises";
-import { resolve as resolve39, extname as extname9, basename as basename12 } from "node:path";
+import { resolve as resolve39, extname as extname10, basename as basename12 } from "node:path";
 
 // ../../node_modules/.pnpm/music-metadata@11.11.1/node_modules/music-metadata/lib/index.js
 init_lib();
@@ -69377,7 +69829,7 @@ mediaCommand.command("info").description("Get media file information").argument(
   const spinner2 = ora("Analyzing media...").start();
   try {
     const filePath = resolve39(process.cwd(), file);
-    const ext = extname9(filePath).toLowerCase();
+    const ext = extname10(filePath).toLowerCase();
     const fileName = basename12(filePath);
     const fileStat = await stat4(filePath);
     const mediaType = detectMediaType2(ext);
@@ -69519,10 +69971,10 @@ init_engine();
 init_output();
 init_cost_tier();
 import { readFile as readFile27, writeFile as writeFile35, readdir as readdir2 } from "node:fs/promises";
-import { resolve as resolve40, basename as basename13, extname as extname10, join as join10 } from "node:path";
+import { resolve as resolve40, basename as basename13, extname as extname11, join as join10 } from "node:path";
 var batchCommand = new Command("batch").description("Batch operations for processing multiple items");
 function detectMediaType3(filePath) {
-  const ext = extname10(filePath).toLowerCase();
+  const ext = extname11(filePath).toLowerCase();
   const videoExts = [".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v"];
   const audioExts = [".mp3", ".wav", ".aac", ".flac", ".ogg", ".m4a"];
   const imageExts = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"];
@@ -69532,7 +69984,7 @@ function detectMediaType3(filePath) {
   return "video";
 }
 function isMediaFile(filePath) {
-  const ext = extname10(filePath).toLowerCase();
+  const ext = extname11(filePath).toLowerCase();
   const mediaExts = [
     ".mp4",
     ".mov",
@@ -69590,7 +70042,7 @@ batchCommand.command("import").description("Import multiple media files from a d
         if (entry.isDirectory() && options.recursive) {
           await scanDir(entryPath);
         } else if (entry.isFile()) {
-          const ext = extname10(entry.name).toLowerCase();
+          const ext = extname11(entry.name).toLowerCase();
           const matchesFilter = !filterExts || filterExts.includes(ext);
           if (matchesFilter && isMediaFile(entryPath)) {
             mediaFiles.push(entryPath);
@@ -70058,6 +70510,7 @@ var AI_FEATURES = [
     desc: "generate + edit",
     defaultProvider: "OpenAI gpt-image-2 (Artificial Analysis #1, since v0.56)",
     alsoAvailable: "Gemini Nano Banana, Grok Imagine",
+    keyHint: "1 key",
     keys: [
       {
         configKey: "openai",
@@ -70112,6 +70565,7 @@ var AI_FEATURES = [
     desc: "generate + extend",
     defaultProvider: "Seedance 2.0 via fal.ai (Artificial Analysis #2 t2v + i2v, since v0.57)",
     alsoAvailable: "Grok Imagine, Kling, Runway Gen-4.5, Google Veo",
+    keyHint: "1-2 keys",
     keys: [
       {
         configKey: "fal",
@@ -70132,6 +70586,15 @@ var AI_FEATURES = [
           url: "https://fal.ai/dashboard/keys",
           what: "ByteDance Seedance 2.0 text-to-video and image-to-video"
         },
+        extraKeys: [
+          {
+            configKey: "imgbb",
+            envVar: "IMGBB_API_KEY",
+            name: "ImgBB",
+            url: "https://api.imgbb.com/",
+            what: "Image hosting for Seedance image-to-video uploads"
+          }
+        ],
         defaultFor: { kind: "video", value: "seedance" }
       },
       {
@@ -70156,6 +70619,15 @@ var AI_FEATURES = [
           url: "https://platform.klingai.com/",
           what: "Kling video generation"
         },
+        extraKeys: [
+          {
+            configKey: "imgbb",
+            envVar: "IMGBB_API_KEY",
+            name: "ImgBB",
+            url: "https://api.imgbb.com/",
+            what: "Image hosting for Kling image-to-video uploads"
+          }
+        ],
         defaultFor: { kind: "video", value: "kling" }
       },
       {
@@ -70190,6 +70662,7 @@ var AI_FEATURES = [
     desc: "TTS, SFX, music, voice clone",
     defaultProvider: "ElevenLabs (paid, premium quality) \u2014 falls back to local Kokoro when no key (free, since v0.54)",
     alsoAvailable: "Replicate MusicGen (music only)",
+    keyHint: "0-1 key",
     keys: [
       {
         configKey: "elevenlabs",
@@ -70235,6 +70708,7 @@ var AI_FEATURES = [
     desc: "captions, grade, reframe, motion graphics",
     defaultProvider: "Whisper (transcription) + Claude (reasoning)",
     alsoAvailable: "",
+    keyHint: "2 keys",
     keys: [
       {
         configKey: "openai",
@@ -70268,8 +70742,11 @@ function applyProviderDefault(config2, choice) {
   }
 }
 function isProviderChoiceConfigured(config2, choice) {
-  if (choice.key) {
-    const value = config2.providers[choice.key.configKey];
+  const keys = [choice.key, ...getChoiceExtraKeys(config2, choice)].filter(
+    (keyDef) => Boolean(keyDef)
+  );
+  for (const keyDef of keys) {
+    const value = config2.providers[keyDef.configKey];
     if (value) return true;
   }
   if (choice.defaultFor?.kind === "image") {
@@ -70280,6 +70757,96 @@ function isProviderChoiceConfigured(config2, choice) {
   }
   return false;
 }
+function getConfiguredUploadProvider(config2) {
+  return process.env.VIBE_UPLOAD_PROVIDER?.toLowerCase() === "s3" || config2.upload.provider === "s3" ? "s3" : "imgbb";
+}
+function hasVideoFeature(features) {
+  return features.some((feature) => feature.label === "Videos");
+}
+async function promptOptionalValue(label, currentValue) {
+  const suffix = currentValue ? source_default.dim(` [${currentValue}]`) : "";
+  const value = await prompt2(source_default.cyan(`  ${label}${suffix}: `));
+  const trimmed = value.trim();
+  return trimmed || currentValue;
+}
+async function configureUploadHost(config2) {
+  console.log(source_default.dim("2b. Upload host"));
+  console.log(source_default.bold("Where should image-to-video upload reference images?"));
+  console.log(
+    source_default.dim(
+      "  Seedance and Kling need a temporary HTTPS image URL when you start from a local image."
+    )
+  );
+  console.log();
+  const currentProvider = getConfiguredUploadProvider(config2);
+  const selected = await promptSelect(
+    source_default.cyan("  Upload host [1-3]: "),
+    [
+      `ImgBB ${source_default.dim("- easiest setup, third-party image hosting (default)")}`,
+      `S3 ${source_default.dim("- your own bucket, better control/privacy")}`,
+      `Back ${source_default.dim("(choose different features)")}`
+    ],
+    currentProvider === "s3" ? 1 : 0,
+    { backIndex: 2 }
+  );
+  console.log();
+  if (selected === 2) {
+    return "back";
+  }
+  if (selected === 0) {
+    config2.upload.provider = "imgbb";
+    process.env.VIBE_UPLOAD_PROVIDER = "imgbb";
+    console.log(source_default.dim("  ImgBB selected. Seedance/Kling setup will ask for IMGBB_API_KEY."));
+    console.log();
+    return "continue";
+  }
+  config2.upload.provider = "s3";
+  process.env.VIBE_UPLOAD_PROVIDER = "s3";
+  config2.upload.s3 = config2.upload.s3 ?? {};
+  const envBucket = process.env.VIBE_UPLOAD_S3_BUCKET;
+  const envRegion = process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;
+  const envPrefix = process.env.VIBE_UPLOAD_S3_PREFIX;
+  const envTtl = process.env.VIBE_UPLOAD_TTL_SECONDS;
+  console.log(source_default.dim("  S3 selected. AWS credentials stay in your shell/.env/AWS profile."));
+  console.log(source_default.dim("  Required at runtime: AWS credentials, region, and bucket."));
+  console.log();
+  const bucket = await promptOptionalValue("S3 bucket", envBucket ?? config2.upload.s3.bucket);
+  const region = await promptOptionalValue("AWS region", envRegion ?? config2.upload.s3.region);
+  const prefix = await promptOptionalValue(
+    "S3 prefix",
+    envPrefix ?? config2.upload.s3.prefix ?? "vibeframe/tmp"
+  );
+  const ttlValue = await promptOptionalValue(
+    "Upload URL TTL seconds",
+    envTtl ?? String(config2.upload.ttlSeconds ?? 3600)
+  );
+  if (bucket) config2.upload.s3.bucket = bucket;
+  if (region) config2.upload.s3.region = region;
+  if (prefix) config2.upload.s3.prefix = prefix;
+  const ttlSeconds = ttlValue ? Number.parseInt(ttlValue, 10) : NaN;
+  if (Number.isFinite(ttlSeconds) && ttlSeconds > 0) {
+    config2.upload.ttlSeconds = ttlSeconds;
+  }
+  if (!config2.upload.s3.bucket || !config2.upload.s3.region) {
+    console.log(
+      source_default.yellow(
+        "  \u26A0 S3 selected, but bucket/region is incomplete. Set VIBE_UPLOAD_S3_BUCKET and AWS_REGION before image-to-video."
+      )
+    );
+  } else {
+    console.log(
+      `  ${source_default.green("\u2713")} S3 upload host configured ${source_default.dim(`(${config2.upload.s3.bucket}/${config2.upload.s3.prefix ?? "vibeframe/tmp"})`)}`
+    );
+  }
+  console.log();
+  return "continue";
+}
+function getChoiceExtraKeys(config2, choice) {
+  if (config2.upload.provider === "s3") {
+    return [];
+  }
+  return choice.extraKeys ?? [];
+}
 function isFeatureConfigured(config2, feature) {
   if (feature.providerChoices?.some((choice) => isProviderChoiceConfigured(config2, choice))) {
     return true;
@@ -70389,6 +70956,7 @@ async function runNonInteractiveSetup(opts) {
 }
 async function runSetupWizard(fullSetup = false, scope = "user") {
   console.log();
+  loadEnv();
   const cfgPath = getConfigPath(scope).replace(homedir5(), "~");
   const scopeNote = scope === "project" ? "applies to this project only \xB7 add .vibeframe/ to .gitignore" : "applies to every project for this user";
   console.log(source_default.bold.magenta("VibeFrame Setup") + source_default.bold(` \u2014 ${scope} scope`));
@@ -70540,8 +71108,7 @@ async function runAIFeaturesSetup(config2, _scope) {
     const backIndex = AI_FEATURES.length;
     const featureLabels = [
       ...AI_FEATURES.map((f) => {
-        const keyCount = f.keys.length;
-        const tag = source_default.dim(`${keyCount} key${keyCount > 1 ? "s" : ""}`);
+        const tag = source_default.dim(f.keyHint ?? `${f.keys.length} key${f.keys.length > 1 ? "s" : ""}`);
         return `${f.label} ${source_default.dim(`(${f.desc})`)} ${tag}`;
       }),
       `Back ${source_default.dim("(return to setup checkpoint)")}`
@@ -70564,6 +71131,13 @@ async function runAIFeaturesSetup(config2, _scope) {
       console.log();
       return { tryCommand: "vibe --help", selectedFeatures: [] };
     }
+    if (hasVideoFeature(selectedFeatures)) {
+      const uploadResult = await configureUploadHost(config2);
+      if (uploadResult === "back") {
+        console.log();
+        continue featureSelection;
+      }
+    }
     const plannedKeys = /* @__PURE__ */ new Map();
     console.log(source_default.dim("3. Providers"));
     console.log(source_default.bold("Choose providers for each selected feature"));
@@ -70586,7 +71160,12 @@ async function runAIFeaturesSetup(config2, _scope) {
           (choice) => isProviderChoiceConfigured(config2, choice)
         );
         const providerLabels = feature.providerChoices.map((choice) => {
-          const keyHint = choice.keyless ? source_default.dim("no key") : choice.key ? source_default.dim(choice.key.envVar) : source_default.dim("no key");
+          const keyHint = choice.keyless ? source_default.dim("no key") : choice.key ? source_default.dim(
+            [
+              choice.key.envVar,
+              ...getChoiceExtraKeys(config2, choice).map((keyDef) => keyDef.envVar)
+            ].filter(Boolean).join(" + ")
+          ) : source_default.dim("no key");
           const defaultHint = choice === feature.providerChoices?.[0] ? source_default.dim("recommended default") : "";
           return [choice.label, defaultHint, source_default.dim(`- ${choice.desc}`), keyHint].filter(Boolean).join(" ");
         });
@@ -70612,6 +71191,9 @@ async function runAIFeaturesSetup(config2, _scope) {
         }
         for (const choice of selectedChoices) {
           if (choice.key) addUniqueKey(keysForFeature, choice.key);
+          for (const keyDef of getChoiceExtraKeys(config2, choice)) {
+            addUniqueKey(keysForFeature, keyDef);
+          }
         }
         if (selectedChoices.some((choice) => choice.keyless)) {
           console.log(source_default.dim("  No API key needed for selected local provider(s)."));
@@ -71266,10 +71848,21 @@ OPENROUTER_API_KEY=                   # multiplexes any provider above
 # \u2500\u2500 Media providers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
 ELEVENLABS_API_KEY=                   # paid TTS / SFX / music (Kokoro is the free fallback)
 FAL_KEY=                              # Seedance 2.0 \u2014 default video provider since v0.57
+IMGBB_API_KEY=                        # image hosting for Seedance/Kling image-to-video
 RUNWAY_API_SECRET=                    # Runway Gen-4.5 video
 KLING_API_KEY=                        # Kling video
 REPLICATE_API_TOKEN=                  # MusicGen, real-esrgan, etc.
-IMGBB_API_KEY=                        # public image hosting (rare \u2014 some Replicate flows need it)
+
+# \u2500\u2500 Optional private upload host for image-to-video \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# Default is ImgBB. Set these only if you want temporary URLs from your own S3 bucket.
+# VIBE_UPLOAD_PROVIDER=s3             # imgbb | s3
+# VIBE_UPLOAD_TTL_SECONDS=3600
+# VIBE_UPLOAD_S3_BUCKET=
+# VIBE_UPLOAD_S3_PREFIX=vibeframe/tmp
+# AWS_REGION=
+# AWS_ACCESS_KEY_ID=
+# AWS_SECRET_ACCESS_KEY=
+# AWS_SESSION_TOKEN=
 `;
 }
 var GITIGNORE_ADDITIONS = `