@vibeframe/mcp-server 0.60.0 → 0.63.0

package/dist/index.js

@@ -461339,189 +461339,817 @@ var init_compose_scenes_skills = __esm({
   }
 });
 
-// src/index.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-
-// src/tools/project.ts
-init_engine();
-import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-async function loadProject(projectPath) {
-  const absPath = resolve(process.cwd(), projectPath);
-  const content = await readFile(absPath, "utf-8");
-  const data = JSON.parse(content);
-  return Project.fromJSON(data);
-}
-async function saveProject(projectPath, project) {
-  const absPath = resolve(process.cwd(), projectPath);
-  await writeFile(absPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
-}
-var projectTools = [
-  {
-    name: "project_create",
-    description: "Create a new VibeFrame project file",
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "Project name" },
-        outputPath: { type: "string", description: "Output file path (defaults to {name}.vibe.json)" },
-        width: { type: "number", description: "Video width in pixels (default: 1920)" },
-        height: { type: "number", description: "Video height in pixels (default: 1080)" },
-        fps: { type: "number", description: "Frames per second (default: 30)" }
-      },
-      required: ["name"]
-    }
-  },
-  {
-    name: "project_info",
-    description: "Get information about a VibeFrame project",
-    inputSchema: {
-      type: "object",
-      properties: {
-        projectPath: { type: "string", description: "Path to the .vibe.json project file" }
-      },
-      required: ["projectPath"]
+// ../cli/src/commands/_shared/scene-audio-scan.ts
+import { readFile as readFile22 } from "node:fs/promises";
+import { resolve as resolve36 } from "node:path";
+function parseRootClips(rootHtml) {
+  const clips = [];
+  const clipRegex = /<div\b[^>]*class="clip"[^>]*>/gi;
+  let match2;
+  while ((match2 = clipRegex.exec(rootHtml)) !== null) {
+    const tag = match2[0];
+    const compositionId = pickAttr(tag, "data-composition-id");
+    const compositionSrc = pickAttr(tag, "data-composition-src");
+    const start = pickNumberAttr(tag, "data-start");
+    const duration = pickNumberAttr(tag, "data-duration");
+    const trackIndex = pickNumberAttr(tag, "data-track-index") ?? 1;
+    if (!compositionId || !compositionSrc || start === null || duration === null) {
+      continue;
     }
+    clips.push({ compositionId, compositionSrc, start, duration, trackIndex });
   }
-];
-async function handleProjectToolCall(name, args) {
-  switch (name) {
-    case "project_create": {
-      const projectName = args.name;
-      const outputPath = args.outputPath || `${projectName}.vibe.json`;
-      const project = new Project(projectName);
-      if (args.fps) {
-        project.setFrameRate(args.fps);
-      }
-      await saveProject(outputPath, project);
-      return `Created project "${projectName}" at ${outputPath}`;
+  return clips;
+}
+function parseSceneAudios(compositionHtml) {
+  const out = [];
+  const audioRegex = /<audio\b([^>]*)>/gi;
+  let match2;
+  while ((match2 = audioRegex.exec(compositionHtml)) !== null) {
+    const attrs = match2[1];
+    const src = pickAttr(attrs, "src");
+    if (!src) continue;
+    const localStart = pickNumberAttr(attrs, "data-start") ?? 0;
+    const durationRaw = pickAttr(attrs, "data-duration");
+    const durationHint = !durationRaw || durationRaw === "auto" ? "auto" : Number(durationRaw);
+    const volume = pickNumberAttr(attrs, "data-volume") ?? 1;
+    const trackIndex = pickNumberAttr(attrs, "data-track-index") ?? 2;
+    out.push({ srcRel: src, localStart, durationHint, volume, trackIndex });
+  }
+  return out;
+}
+function makeFsCompositionReader(projectDir) {
+  return async (compositionSrcRel) => {
+    const abs = resolve36(projectDir, compositionSrcRel);
+    try {
+      return await readFile22(abs, "utf-8");
+    } catch {
+      return null;
     }
-    case "project_info": {
-      const project = await loadProject(args.projectPath);
-      const meta = project.getMeta();
-      const info = {
-        name: meta.name,
-        aspectRatio: meta.aspectRatio,
-        frameRate: meta.frameRate,
-        duration: meta.duration,
-        sources: project.getSources().length,
-        tracks: project.getTracks().length,
-        clips: project.getClips().length
-      };
-      return JSON.stringify(info, null, 2);
+  };
+}
+async function scanSceneAudio(opts) {
+  const reader = opts.readComposition ?? makeFsCompositionReader(opts.projectDir);
+  const clips = parseRootClips(opts.rootHtml);
+  const out = [];
+  for (const clip of clips) {
+    const html = await reader(clip.compositionSrc);
+    if (!html) continue;
+    const audios = parseSceneAudios(html);
+    for (const audio of audios) {
+      out.push({
+        srcRel: audio.srcRel,
+        srcAbs: resolve36(opts.projectDir, audio.srcRel),
+        absoluteStart: clip.start + audio.localStart,
+        durationHint: audio.durationHint,
+        clipDurationCap: clip.duration - audio.localStart,
+        volume: audio.volume,
+        trackIndex: audio.trackIndex,
+        compositionSrc: clip.compositionSrc
+      });
     }
-    default:
-      throw new Error(`Unknown project tool: ${name}`);
   }
+  out.sort((a, b) => a.absoluteStart - b.absoluteStart);
+  return out;
+}
+function pickAttr(tag, name) {
+  const re = new RegExp(`\\b${escapeRegex3(name)}\\s*=\\s*("([^"]*)"|'([^']*)')`);
+  const m = tag.match(re);
+  if (!m) return null;
+  return m[2] ?? m[3] ?? null;
+}
+function pickNumberAttr(tag, name) {
+  const raw2 = pickAttr(tag, name);
+  if (raw2 === null) return null;
+  const n = Number(raw2);
+  return Number.isFinite(n) ? n : null;
 }
+function escapeRegex3(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var init_scene_audio_scan = __esm({
+  "../cli/src/commands/_shared/scene-audio-scan.ts"() {
+    "use strict";
+  }
+});
 
-// src/tools/timeline.ts
-import { resolve as resolve2 } from "node:path";
-var timelineTools = [
-  {
-    name: "timeline_add_source",
-    description: "Add a media source (video, audio, image) to the project",
-    inputSchema: {
-      type: "object",
-      properties: {
-        projectPath: { type: "string", description: "Path to the project file" },
-        mediaPath: { type: "string", description: "Path to the media file" },
-        name: { type: "string", description: "Optional name for the source" },
-        duration: { type: "number", description: "Duration of the media in seconds (default: 10)" }
-      },
-      required: ["projectPath", "mediaPath"]
-    }
-  },
-  {
-    name: "timeline_add_clip",
-    description: "Add a clip to the timeline from an existing source",
-    inputSchema: {
-      type: "object",
-      properties: {
-        projectPath: { type: "string", description: "Path to the project file" },
-        sourceId: { type: "string", description: "ID of the media source" },
-        trackId: { type: "string", description: "ID of the track to add clip to (optional, uses first video track)" },
-        startTime: { type: "number", description: "Start time on timeline in seconds (default: 0)" },
-        duration: { type: "number", description: "Clip duration in seconds (optional, uses source duration)" }
-      },
-      required: ["projectPath", "sourceId"]
-    }
-  },
-  {
-    name: "timeline_split_clip",
-    description: "Split a clip at a specific time",
-    inputSchema: {
-      type: "object",
-      properties: {
-        projectPath: { type: "string", description: "Path to the project file" },
-        clipId: { type: "string", description: "ID of the clip to split" },
-        splitTime: { type: "number", description: "Time to split at (relative to clip start) in seconds" }
-      },
-      required: ["projectPath", "clipId", "splitTime"]
-    }
-  },
-  {
-    name: "timeline_trim_clip",
-    description: "Trim a clip by adjusting its start or end",
-    inputSchema: {
-      type: "object",
-      properties: {
-        projectPath: { type: "string", description: "Path to the project file" },
-        clipId: { type: "string", description: "ID of the clip to trim" },
-        trimStart: { type: "number", description: "New source start offset in seconds" },
-        trimEnd: { type: "number", description: "New duration in seconds" }
-      },
-      required: ["projectPath", "clipId"]
-    }
-  },
-  {
-    name: "timeline_move_clip",
-    description: "Move a clip to a new position or track",
-    inputSchema: {
-      type: "object",
-      properties: {
-        projectPath: { type: "string", description: "Path to the project file" },
-        clipId: { type: "string", description: "ID of the clip to move" },
-        newStartTime: { type: "number", description: "New start time on timeline in seconds" },
-        newTrackId: { type: "string", description: "ID of the target track (optional)" }
-      },
-      required: ["projectPath", "clipId"]
-    }
-  },
-  {
-    name: "timeline_delete_clip",
-    description: "Delete a clip from the timeline",
-    inputSchema: {
-      type: "object",
-      properties: {
-        projectPath: { type: "string", description: "Path to the project file" },
-        clipId: { type: "string", description: "ID of the clip to delete" }
-      },
-      required: ["projectPath", "clipId"]
-    }
-  },
-  {
-    name: "timeline_duplicate_clip",
-    description: "Duplicate a clip",
-    inputSchema: {
-      type: "object",
-      properties: {
-        projectPath: { type: "string", description: "Path to the project file" },
-        clipId: { type: "string", description: "ID of the clip to duplicate" },
-        newStartTime: { type: "number", description: "Start time for the duplicated clip (optional, places after original)" }
-      },
-      required: ["projectPath", "clipId"]
-    }
-  },
+// ../cli/src/commands/_shared/scene-audio-mux.ts
+import { rename as rename6, unlink as unlink5 } from "node:fs/promises";
+import { resolve as resolve37, dirname as dirname23, extname as extname12, basename as basename15 } from "node:path";
+function buildAudioMuxFilter(audios) {
+  if (audios.length === 0) return null;
+  const labels = [];
+  const stages = [];
+  audios.forEach((a, i) => {
+    const inputIdx = i + 1;
+    const delayMs = Math.max(0, Math.round(a.absoluteStart * 1e3));
+    const volume = Number.isFinite(a.volume) ? a.volume : 1;
+    const trimSec = Math.max(0, a.clipDurationCap);
+    const label = `a${i}`;
+    const stage = [
+      `[${inputIdx}:a]`,
+      `atrim=duration=${trimSec.toFixed(3)},`,
+      `asetpts=PTS-STARTPTS,`,
+      `adelay=${delayMs}:all=1,`,
+      `volume=${volume}`,
+      `[${label}]`
+    ].join("");
+    stages.push(stage);
+    labels.push(`[${label}]`);
+  });
+  if (audios.length === 1) {
+    return {
+      filterComplex: stages.join(";"),
+      outLabel: labels[0],
+      inputCount: 1
+    };
+  }
+  const mix = `${labels.join("")}amix=inputs=${audios.length}:dropout_transition=0:normalize=0[mixed]`;
+  return {
+    filterComplex: `${stages.join(";")};${mix}`,
+    outLabel: "[mixed]",
+    inputCount: audios.length
+  };
+}
+function audioCodecForFormat(format4) {
+  if (format4 === "webm") return "libopus";
+  if (format4 === "mov") return "pcm_s16le";
+  return "aac";
+}
+async function muxAudioIntoVideo(opts) {
+  if (opts.audios.length === 0) {
+    return { success: true, outputPath: opts.videoPath, audioCount: 0 };
+  }
+  if (!commandExists("ffmpeg")) {
+    return {
+      success: false,
+      outputPath: opts.videoPath,
+      audioCount: opts.audios.length,
+      error: "ffmpeg not found in PATH \u2014 install via `brew install ffmpeg` (mac) or your package manager"
+    };
+  }
+  const filter4 = buildAudioMuxFilter(opts.audios);
+  if (!filter4) {
+    return { success: true, outputPath: opts.videoPath, audioCount: 0 };
+  }
+  const ext = extname12(opts.videoPath) || `.${opts.format}`;
+  const tmpPath = resolve37(
+    dirname23(opts.videoPath),
+    `.${basename15(opts.videoPath, ext)}.muxing${ext}`
+  );
+  const args = ["-y", "-loglevel", "error", "-i", opts.videoPath];
+  for (const a of opts.audios) {
+    args.push("-i", a.srcAbs);
+  }
+  args.push(
+    "-filter_complex",
+    filter4.filterComplex,
+    "-map",
+    "0:v",
+    "-map",
+    filter4.outLabel,
+    "-c:v",
+    "copy",
+    "-c:a",
+    audioCodecForFormat(opts.format),
+    // Cap on the video duration so audio that overruns the producer's render
+    // (e.g. a long Kokoro wav on a short scene) doesn't extend the output.
+    // Video drives the timeline because the producer already counted frames.
+    "-t",
+    opts.totalDuration && opts.totalDuration > 0 ? opts.totalDuration.toFixed(3) : opts.videoDuration?.toFixed(3) ?? ""
+  );
+  if (args[args.length - 1] === "") {
+    args.pop();
+    args.pop();
+  }
+  args.push("-movflags", "+faststart", tmpPath);
+  try {
+    const { stderr } = await execSafe("ffmpeg", args);
+    if (stderr && opts.onProgress) {
+      stderr.split(/\r?\n/).forEach((line) => opts.onProgress?.(line));
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    try {
+      await unlink5(tmpPath);
+    } catch {
+    }
+    return {
+      success: false,
+      outputPath: opts.videoPath,
+      audioCount: opts.audios.length,
+      error: `ffmpeg mux failed: ${msg}`
+    };
+  }
+  await rename6(tmpPath, opts.videoPath);
+  return {
+    success: true,
+    outputPath: opts.videoPath,
+    audioCount: opts.audios.length
+  };
+}
+var init_scene_audio_mux = __esm({
+  "../cli/src/commands/_shared/scene-audio-mux.ts"() {
+    "use strict";
+    init_exec_safe();
+  }
+});
+
+// ../cli/src/commands/_shared/scene-render.ts
+var scene_render_exports = {};
+__export(scene_render_exports, {
+  buildRenderConfig: () => buildRenderConfig,
+  defaultOutputPath: () => defaultOutputPath,
+  executeSceneRender: () => executeSceneRender,
+  qualityToCrf: () => qualityToCrf2
+});
+import { mkdir as mkdir17, readFile as readFile23, stat as stat3 } from "node:fs/promises";
+import { existsSync as existsSync36 } from "node:fs";
+import { resolve as resolve38, relative as relative6, dirname as dirname24, basename as basename16 } from "node:path";
+function qualityToCrf2(quality = "standard") {
+  return quality === "draft" ? 28 : quality === "high" ? 18 : 23;
+}
+function defaultOutputPath(opts) {
+  const fmt = opts.format ?? "mp4";
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const stamp = now.toISOString().replace(/[:T]/g, "-").replace(/\..+$/, "");
+  const name = (opts.projectName ?? basename16(resolve38(opts.projectDir))) || "scene";
+  return resolve38(opts.projectDir, "renders", `${name}-${stamp}.${fmt}`);
+}
+async function readProjectName(projectDir) {
+  const cfgPath = resolve38(projectDir, "vibe.project.yaml");
+  if (!existsSync36(cfgPath)) return void 0;
+  try {
+    const raw2 = await (await import("node:fs/promises")).readFile(cfgPath, "utf-8");
+    const parsed = (0, import_yaml5.parse)(raw2);
+    return parsed?.name ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function buildRenderConfig(opts) {
+  const quality = opts.quality ?? "standard";
+  return {
+    fps: opts.fps ?? 30,
+    quality,
+    format: opts.format ?? "mp4",
+    entryFile: opts.entryFile ?? "index.html",
+    crf: qualityToCrf2(quality),
+    workers: opts.workers ?? 1
+  };
+}
+async function executeSceneRender(opts = {}) {
+  const projectDir = resolve38(opts.projectDir ?? ".");
+  const root2 = opts.root ?? "index.html";
+  const projectStat = await safeStat(projectDir);
+  if (!projectStat || !projectStat.isDirectory()) {
+    return { success: false, error: `Project directory not found: ${projectDir}` };
+  }
+  if (!await rootExists(projectDir, root2)) {
+    return {
+      success: false,
+      error: `Root composition not found: ${resolve38(projectDir, root2)}. Run \`vibe scene init\` first.`
+    };
+  }
+  const chrome2 = await preflightChrome();
+  if (!chrome2.ok) {
+    return { success: false, error: chrome2.reason };
+  }
+  const projectName = await readProjectName(projectDir);
+  const outputPath = opts.output ? resolve38(projectDir, opts.output) : defaultOutputPath({ projectDir, projectName, format: opts.format });
+  await mkdir17(dirname24(outputPath), { recursive: true });
+  const config4 = buildRenderConfig({
+    fps: opts.fps,
+    quality: opts.quality,
+    format: opts.format,
+    workers: opts.workers,
+    entryFile: root2
+  });
+  const job = createRenderJob(config4);
+  const start = Date.now();
+  try {
+    await executeRenderJob(
+      job,
+      projectDir,
+      outputPath,
+      (j, msg) => opts.onProgress?.(j.progress, j.currentStage ?? msg),
+      opts.signal
+    );
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  let audioCount = 0;
+  let audioMuxApplied = false;
+  let audioMuxWarning;
+  try {
+    opts.onProgress?.(0.95, "Mixing audio");
+    const rootHtml = await readFile23(resolve38(projectDir, root2), "utf-8");
+    const audios = await scanSceneAudio({ projectDir, rootHtml });
+    audioCount = audios.length;
+    if (audios.length > 0) {
+      const videoDuration = job.totalFrames && config4.fps ? job.totalFrames / config4.fps : void 0;
+      const mux = await muxAudioIntoVideo({
+        videoPath: outputPath,
+        audios,
+        format: config4.format ?? "mp4",
+        videoDuration,
+        onProgress: (line) => {
+          if (line) opts.onProgress?.(0.97, line);
+        }
+      });
+      if (mux.success) {
+        audioMuxApplied = true;
+      } else {
+        audioMuxWarning = mux.error;
+      }
+    }
+  } catch (err) {
+    audioMuxWarning = err instanceof Error ? err.message : String(err);
+  }
+  return {
+    success: true,
+    outputPath: relative6(process.cwd(), outputPath) || outputPath,
+    durationMs: Date.now() - start,
+    framesRendered: job.framesRendered,
+    totalFrames: job.totalFrames,
+    fps: config4.fps,
+    quality: config4.quality,
+    format: config4.format,
+    audioCount,
+    audioMuxApplied,
+    audioMuxWarning
+  };
+}
+async function safeStat(p) {
+  try {
+    return await stat3(p);
+  } catch {
+    return null;
+  }
+}
+var import_yaml5;
+var init_scene_render = __esm({
+  "../cli/src/commands/_shared/scene-render.ts"() {
+    "use strict";
+    import_yaml5 = __toESM(require_dist16(), 1);
+    init_dist();
+    init_chrome();
+    init_scene_lint();
+    init_scene_audio_scan();
+    init_scene_audio_mux();
+  }
+});
+
+// ../cli/src/commands/_shared/tts-resolve.ts
+async function resolveTtsProvider(preferred = "auto") {
+  const choice = preferred === "auto" ? hasApiKey("ELEVENLABS_API_KEY") ? "elevenlabs" : "kokoro" : preferred;
+  if (choice === "elevenlabs") {
+    return buildElevenLabs();
+  }
+  return buildKokoro();
+}
+async function buildElevenLabs() {
+  const key2 = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs");
+  if (!key2) {
+    throw new TtsKeyMissingError("elevenlabs");
+  }
+  const provider = new ElevenLabsProvider();
+  await provider.initialize({ apiKey: key2 });
+  const call = async (text, opts) => provider.textToSpeech(text, {
+    voiceId: opts?.voice,
+    speed: opts?.speed
+  });
+  return { provider: "elevenlabs", audioExtension: "mp3", call };
+}
+async function buildKokoro() {
+  const provider = new KokoroProvider();
+  await provider.initialize({});
+  const call = async (text, opts) => provider.textToSpeech(text, {
+    voice: opts?.voice,
+    speed: opts?.speed,
+    onProgress: opts?.onProgress
+  });
+  return { provider: "kokoro", audioExtension: "wav", call };
+}
+function parseTtsProviderName(value) {
+  if (!value) return "auto";
+  if (value === "auto" || value === "elevenlabs" || value === "kokoro") {
+    return value;
+  }
+  throw new Error(
+    `Invalid --tts: ${value}. Valid: auto, elevenlabs, kokoro.`
+  );
+}
+var TtsKeyMissingError;
+var init_tts_resolve = __esm({
+  "../cli/src/commands/_shared/tts-resolve.ts"() {
+    "use strict";
+    init_dist2();
+    init_api_key();
+    init_api_key();
+    TtsKeyMissingError = class extends Error {
+      constructor(provider) {
+        super(
+          provider === "elevenlabs" ? "ElevenLabs API key required (ELEVENLABS_API_KEY). Run 'vibe setup', set ELEVENLABS_API_KEY in .env, or pass --tts kokoro for local synthesis." : `Provider ${provider} is unavailable.`
+        );
+        this.provider = provider;
+        this.name = "TtsKeyMissingError";
+      }
+    };
+  }
+});
+
+// ../cli/src/commands/_shared/scene-build.ts
+var scene_build_exports = {};
+__export(scene_build_exports, {
+  executeSceneBuild: () => executeSceneBuild
+});
+import { existsSync as existsSync37 } from "node:fs";
+import { mkdir as mkdir18, readFile as readFile24, writeFile as writeFile23 } from "node:fs/promises";
+import { dirname as dirname25, join as join24, resolve as resolve39 } from "node:path";
+async function executeSceneBuild(opts) {
+  const startedAt = Date.now();
+  const projectDir = resolve39(opts.projectDir);
+  const onProgress = opts.onProgress ?? (() => {
+  });
+  const storyboardPath = join24(projectDir, "STORYBOARD.md");
+  if (!existsSync37(storyboardPath)) {
+    return failBeforePrimitives(`STORYBOARD.md not found at ${storyboardPath}`, startedAt);
+  }
+  const storyboardMd = await readFile24(storyboardPath, "utf-8");
+  const parsed = parseStoryboard(storyboardMd);
+  if (parsed.beats.length === 0) {
+    return failBeforePrimitives(
+      `STORYBOARD.md at ${storyboardPath} has no \`## Beat \u2026\` headings.`,
+      startedAt
+    );
+  }
+  const ttsProvider = opts.ttsProvider ?? parsed.frontmatter?.providers?.tts ?? "auto";
+  const imageProvider = opts.imageProvider ?? parsed.frontmatter?.providers?.image ?? "openai";
+  const voice = opts.voice ?? parsed.frontmatter?.voice;
+  onProgress({ type: "phase-start", phase: "primitives" });
+  const beatOutcomes = await Promise.all(
+    parsed.beats.map((beat) => buildBeatPrimitives(beat, {
+      projectDir,
+      ttsProvider,
+      voice,
+      imageProvider,
+      imageQuality: opts.imageQuality ?? "hd",
+      imageSize: opts.imageSize ?? "1536x1024",
+      skipNarration: opts.skipNarration ?? false,
+      skipBackdrop: opts.skipBackdrop ?? false,
+      force: opts.force ?? false,
+      onProgress
+    }))
+  );
+  onProgress({ type: "phase-start", phase: "compose" });
+  const composeResult = await executeComposeScenesWithSkills(
+    {
+      project: ".",
+      effort: opts.effort,
+      cacheDir: opts.cacheDir,
+      onProgress: (e) => onProgress(e)
+    },
+    projectDir
+  );
+  if (!composeResult.success) {
+    return {
+      success: false,
+      error: `compose failed: ${composeResult.error ?? "unknown"}`,
+      beats: beatOutcomes,
+      composeData: composeResult.data,
+      totalLatencyMs: Date.now() - startedAt
+    };
+  }
+  let outputPath;
+  let renderResult;
+  if (!opts.skipRender) {
+    onProgress({ type: "phase-start", phase: "render" });
+    onProgress({ type: "render-start" });
+    renderResult = await executeSceneRender({ projectDir });
+    if (!renderResult.success) {
+      return {
+        success: false,
+        error: `render failed: ${renderResult.error ?? "unknown"}`,
+        beats: beatOutcomes,
+        composeData: composeResult.data,
+        renderResult,
+        totalLatencyMs: Date.now() - startedAt
+      };
+    }
+    outputPath = renderResult.outputPath;
+    if (outputPath) onProgress({ type: "render-done", outputPath });
+  }
+  return {
+    success: true,
+    beats: beatOutcomes,
+    outputPath,
+    composeData: composeResult.data,
+    renderResult,
+    totalLatencyMs: Date.now() - startedAt
+  };
+}
+async function buildBeatPrimitives(beat, ctx) {
+  const [narration, backdrop] = await Promise.all([
+    ctx.skipNarration ? skipped("narration", beat.id, "--skip-narration", ctx) : dispatchNarration(beat, ctx),
+    ctx.skipBackdrop ? skipped("backdrop", beat.id, "--skip-backdrop", ctx) : dispatchBackdrop(beat, ctx)
+  ]);
+  return {
+    beatId: beat.id,
+    narrationStatus: narration.status,
+    narrationPath: narration.path,
+    narrationError: narration.error,
+    backdropStatus: backdrop.status,
+    backdropPath: backdrop.path,
+    backdropError: backdrop.error
+  };
+}
+async function dispatchNarration(beat, ctx) {
+  const text = beat.cues?.narration;
+  if (!text) return { status: "no-cue" };
+  for (const ext of ["mp3", "wav"]) {
+    const rel2 = `assets/narration-${beat.id}.${ext}`;
+    if (existsSync37(join24(ctx.projectDir, rel2)) && !ctx.force) {
+      ctx.onProgress({ type: "narration-cached", beatId: beat.id, path: rel2 });
+      return { status: "cached", path: rel2 };
+    }
+  }
+  let resolution;
+  try {
+    resolution = await resolveTtsProvider(ctx.ttsProvider);
+  } catch (err) {
+    const error = err instanceof TtsKeyMissingError ? err.message : err.message;
+    ctx.onProgress({ type: "narration-failed", beatId: beat.id, error });
+    return { status: "failed", error };
+  }
+  const result = await resolution.call(text, { voice: ctx.voice });
+  if (!result.success || !result.audioBuffer) {
+    const error = result.error ?? "unknown TTS failure";
+    ctx.onProgress({ type: "narration-failed", beatId: beat.id, error });
+    return { status: "failed", error };
+  }
+  const rel = `assets/narration-${beat.id}.${resolution.audioExtension}`;
+  const abs = join24(ctx.projectDir, rel);
+  await mkdir18(dirname25(abs), { recursive: true });
+  await writeFile23(abs, result.audioBuffer);
+  ctx.onProgress({
+    type: "narration-generated",
+    beatId: beat.id,
+    path: rel,
+    provider: resolution.provider
+  });
+  return { status: "generated", path: rel };
+}
+async function dispatchBackdrop(beat, ctx) {
+  const prompt3 = beat.cues?.backdrop;
+  if (!prompt3) return { status: "no-cue" };
+  if (ctx.imageProvider !== "openai") {
+    const error = `image provider "${ctx.imageProvider}" not yet supported (use openai)`;
+    ctx.onProgress({ type: "backdrop-failed", beatId: beat.id, error });
+    return { status: "failed", error };
+  }
+  const rel = `assets/backdrop-${beat.id}.png`;
+  const abs = join24(ctx.projectDir, rel);
+  if (existsSync37(abs) && !ctx.force) {
+    ctx.onProgress({ type: "backdrop-cached", beatId: beat.id, path: rel });
+    return { status: "cached", path: rel };
+  }
+  const apiKey = process.env.OPENAI_API_KEY ?? "";
+  if (!apiKey) {
+    const error = "OPENAI_API_KEY not set \u2014 cannot dispatch backdrop";
+    ctx.onProgress({ type: "backdrop-failed", beatId: beat.id, error });
+    return { status: "failed", error };
+  }
+  const provider = new OpenAIImageProvider();
+  await provider.initialize({ apiKey });
+  const result = await provider.generateImage(prompt3, {
+    model: "gpt-image-2",
+    size: ctx.imageSize,
+    quality: ctx.imageQuality
+  });
+  if (!result.success || !result.images?.[0]?.base64) {
+    const error = result.error ?? "no image data returned";
+    ctx.onProgress({ type: "backdrop-failed", beatId: beat.id, error });
+    return { status: "failed", error };
+  }
+  await mkdir18(dirname25(abs), { recursive: true });
+  await writeFile23(abs, Buffer.from(result.images[0].base64, "base64"));
+  ctx.onProgress({
+    type: "backdrop-generated",
+    beatId: beat.id,
+    path: rel,
+    provider: "openai"
+  });
+  return { status: "generated", path: rel };
+}
+async function skipped(kind, beatId, reason, ctx) {
+  ctx.onProgress({ type: `${kind}-skipped`, beatId, reason });
+  return { status: "skipped" };
+}
+function failBeforePrimitives(error, startedAt) {
+  return {
+    success: false,
+    error,
+    beats: [],
+    totalLatencyMs: Date.now() - startedAt
+  };
+}
+var init_scene_build = __esm({
+  "../cli/src/commands/_shared/scene-build.ts"() {
+    "use strict";
+    init_dist2();
+    init_compose_scenes_skills();
+    init_scene_render();
+    init_storyboard_parse();
+    init_tts_resolve();
+  }
+});
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/project.ts
+init_engine();
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+async function loadProject(projectPath) {
+  const absPath = resolve(process.cwd(), projectPath);
+  const content = await readFile(absPath, "utf-8");
+  const data = JSON.parse(content);
+  return Project.fromJSON(data);
+}
+async function saveProject(projectPath, project) {
+  const absPath = resolve(process.cwd(), projectPath);
+  await writeFile(absPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+}
+var projectTools = [
+  {
+    name: "project_create",
+    description: "Create a new VibeFrame project file",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Project name" },
+        outputPath: { type: "string", description: "Output file path (defaults to {name}.vibe.json)" },
+        width: { type: "number", description: "Video width in pixels (default: 1920)" },
+        height: { type: "number", description: "Video height in pixels (default: 1080)" },
+        fps: { type: "number", description: "Frames per second (default: 30)" }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "project_info",
+    description: "Get information about a VibeFrame project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Path to the .vibe.json project file" }
+      },
+      required: ["projectPath"]
+    }
+  }
+];
+async function handleProjectToolCall(name, args) {
+  switch (name) {
+    case "project_create": {
+      const projectName = args.name;
+      const outputPath = args.outputPath || `${projectName}.vibe.json`;
+      const project = new Project(projectName);
+      if (args.fps) {
+        project.setFrameRate(args.fps);
+      }
+      await saveProject(outputPath, project);
+      return `Created project "${projectName}" at ${outputPath}`;
+    }
+    case "project_info": {
+      const project = await loadProject(args.projectPath);
+      const meta = project.getMeta();
+      const info = {
+        name: meta.name,
+        aspectRatio: meta.aspectRatio,
+        frameRate: meta.frameRate,
+        duration: meta.duration,
+        sources: project.getSources().length,
+        tracks: project.getTracks().length,
+        clips: project.getClips().length
+      };
+      return JSON.stringify(info, null, 2);
+    }
+    default:
+      throw new Error(`Unknown project tool: ${name}`);
+  }
+}
+
+// src/tools/timeline.ts
+import { resolve as resolve2 } from "node:path";
+var timelineTools = [
+  {
+    name: "timeline_add_source",
+    description: "Add a media source (video, audio, image) to the project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Path to the project file" },
+        mediaPath: { type: "string", description: "Path to the media file" },
+        name: { type: "string", description: "Optional name for the source" },
+        duration: { type: "number", description: "Duration of the media in seconds (default: 10)" }
+      },
+      required: ["projectPath", "mediaPath"]
+    }
+  },
+  {
+    name: "timeline_add_clip",
+    description: "Add a clip to the timeline from an existing source",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Path to the project file" },
+        sourceId: { type: "string", description: "ID of the media source" },
+        trackId: { type: "string", description: "ID of the track to add clip to (optional, uses first video track)" },
+        startTime: { type: "number", description: "Start time on timeline in seconds (default: 0)" },
+        duration: { type: "number", description: "Clip duration in seconds (optional, uses source duration)" }
+      },
+      required: ["projectPath", "sourceId"]
+    }
+  },
+  {
+    name: "timeline_split_clip",
+    description: "Split a clip at a specific time",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Path to the project file" },
+        clipId: { type: "string", description: "ID of the clip to split" },
+        splitTime: { type: "number", description: "Time to split at (relative to clip start) in seconds" }
+      },
+      required: ["projectPath", "clipId", "splitTime"]
+    }
+  },
+  {
+    name: "timeline_trim_clip",
+    description: "Trim a clip by adjusting its start or end",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Path to the project file" },
+        clipId: { type: "string", description: "ID of the clip to trim" },
+        trimStart: { type: "number", description: "New source start offset in seconds" },
+        trimEnd: { type: "number", description: "New duration in seconds" }
+      },
+      required: ["projectPath", "clipId"]
+    }
+  },
+  {
+    name: "timeline_move_clip",
+    description: "Move a clip to a new position or track",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Path to the project file" },
+        clipId: { type: "string", description: "ID of the clip to move" },
+        newStartTime: { type: "number", description: "New start time on timeline in seconds" },
+        newTrackId: { type: "string", description: "ID of the target track (optional)" }
+      },
+      required: ["projectPath", "clipId"]
+    }
+  },
+  {
+    name: "timeline_delete_clip",
+    description: "Delete a clip from the timeline",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Path to the project file" },
+        clipId: { type: "string", description: "ID of the clip to delete" }
+      },
+      required: ["projectPath", "clipId"]
+    }
+  },
+  {
+    name: "timeline_duplicate_clip",
+    description: "Duplicate a clip",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Path to the project file" },
+        clipId: { type: "string", description: "ID of the clip to duplicate" },
+        newStartTime: { type: "number", description: "Start time for the duplicated clip (optional, places after original)" }
+      },
+      required: ["projectPath", "clipId"]
+    }
+  },
   {
     name: "timeline_add_effect",
     description: "Add an effect to a clip",
@@ -463006,9 +463634,9 @@ async function handleAiAnalysisToolCall(name, args) {
 
 // src/tools/ai-pipelines.ts
 init_ai_script_pipeline();
-import { writeFile as writeFile24 } from "node:fs/promises";
+import { writeFile as writeFile25 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 
 // ../cli/src/commands/ai-highlights.ts
 import { readFile as readFile13, writeFile as writeFile14, mkdir as mkdir12 } from "node:fs/promises";
@@ -463452,10 +464080,10 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
 }
 
 // ../cli/src/pipeline/executor.ts
-var import_yaml5 = __toESM(require_dist16(), 1);
-import { resolve as resolve36 } from "node:path";
-import { readFile as readFile22, writeFile as writeFile23, mkdir as mkdir17 } from "node:fs/promises";
-import { existsSync as existsSync36 } from "node:fs";
+var import_yaml6 = __toESM(require_dist16(), 1);
+import { resolve as resolve40 } from "node:path";
+import { readFile as readFile25, writeFile as writeFile24, mkdir as mkdir19 } from "node:fs/promises";
+import { existsSync as existsSync38 } from "node:fs";
 
 // ../cli/src/pipeline/resolver.ts
 function resolveStepParams(params, completedSteps) {
@@ -463555,9 +464183,9 @@ function registerAction(action, handler4) {
 }
 function getOutput(params, outputDir, defaultName) {
   if (params.output && typeof params.output === "string") {
-    return resolve36(outputDir, params.output);
+    return resolve40(outputDir, params.output);
   }
-  return resolve36(outputDir, defaultName);
+  return resolve40(outputDir, defaultName);
 }
 async function ensureActionsRegistered() {
   if (Object.keys(ACTION_HANDLERS).length > 0) return;
@@ -463697,14 +464325,64 @@ async function ensureActionsRegistered() {
       error: r.error
     };
   });
+  registerAction("scene-build", async (params, outputDir) => {
+    const { executeSceneBuild: executeSceneBuild2 } = await Promise.resolve().then(() => (init_scene_build(), scene_build_exports));
+    const projectRel = params.project ?? ".";
+    const r = await executeSceneBuild2({
+      projectDir: resolve40(outputDir, projectRel),
+      effort: params.effort,
+      skipNarration: params.skipNarration,
+      skipBackdrop: params.skipBackdrop,
+      skipRender: params.skipRender,
+      ttsProvider: params.tts,
+      voice: params.voice,
+      imageProvider: params.imageProvider,
+      imageQuality: params.quality,
+      force: params.force
+    });
+    return {
+      id: "",
+      action: "scene-build",
+      success: r.success,
+      output: r.outputPath,
+      data: { beats: r.beats, totalLatencyMs: r.totalLatencyMs, composeData: r.composeData ?? null },
+      error: r.error
+    };
+  });
+  registerAction("scene-render", async (params, outputDir) => {
+    const { executeSceneRender: executeSceneRender2 } = await Promise.resolve().then(() => (init_scene_render(), scene_render_exports));
+    const projectRel = params.project ?? ".";
+    const r = await executeSceneRender2({
+      projectDir: resolve40(outputDir, projectRel),
+      root: params.root,
+      output: params.output,
+      fps: params.fps,
+      quality: params.quality,
+      format: params.format,
+      workers: params.workers
+    });
+    return {
+      id: "",
+      action: "scene-render",
+      success: r.success,
+      output: r.outputPath,
+      data: {
+        durationMs: r.durationMs,
+        framesRendered: r.framesRendered,
+        audioCount: r.audioCount,
+        audioMuxApplied: r.audioMuxApplied
+      },
+      error: r.error
+    };
+  });
 }
 async function loadPipeline(filePath) {
-  const absPath = resolve36(process.cwd(), filePath);
-  if (!existsSync36(absPath)) {
+  const absPath = resolve40(process.cwd(), filePath);
+  if (!existsSync38(absPath)) {
     throw new Error(`Pipeline file not found: ${absPath}`);
   }
-  const content = await readFile22(absPath, "utf-8");
-  const manifest = (0, import_yaml5.parse)(content);
+  const content = await readFile25(absPath, "utf-8");
+  const manifest = (0, import_yaml6.parse)(content);
   if (!manifest.name) throw new Error("Pipeline missing 'name' field");
   if (!manifest.steps || !Array.isArray(manifest.steps)) throw new Error("Pipeline missing 'steps' array");
   const ids = /* @__PURE__ */ new Set();
@@ -463719,16 +464397,16 @@ async function loadPipeline(filePath) {
 var CHECKPOINT_FILE = ".pipeline-state.yaml";
 async function executePipeline(manifest, options = {}) {
   await ensureActionsRegistered();
-  const outputDir = resolve36(process.cwd(), options.outputDir || `${manifest.name}-output`);
-  await mkdir17(outputDir, { recursive: true });
+  const outputDir = resolve40(process.cwd(), options.outputDir || `${manifest.name}-output`);
+  await mkdir19(outputDir, { recursive: true });
   const completedSteps = /* @__PURE__ */ new Map();
   const results = [];
   const startTime = Date.now();
   if (options.resume) {
-    const checkpointPath = resolve36(outputDir, CHECKPOINT_FILE);
-    if (existsSync36(checkpointPath)) {
-      const checkpointContent = await readFile22(checkpointPath, "utf-8");
-      const checkpoint = (0, import_yaml5.parse)(checkpointContent);
+    const checkpointPath = resolve40(outputDir, CHECKPOINT_FILE);
+    if (existsSync38(checkpointPath)) {
+      const checkpointContent = await readFile25(checkpointPath, "utf-8");
+      const checkpoint = (0, import_yaml6.parse)(checkpointContent);
       for (const cs of checkpoint.completedSteps) {
         completedSteps.set(cs.id, {
           id: cs.id,
@@ -463845,9 +464523,9 @@ async function executePipeline(manifest, options = {}) {
           data: s.data
         }))
       };
-      await writeFile23(
-        resolve36(outputDir, CHECKPOINT_FILE),
-        (0, import_yaml5.stringify)(checkpoint, { indent: 2 }),
+      await writeFile24(
+        resolve40(outputDir, CHECKPOINT_FILE),
+        (0, import_yaml6.stringify)(checkpoint, { indent: 2 }),
         "utf-8"
       );
     } else {
@@ -464094,8 +464772,8 @@ async function handleAiPipelineToolCall(name, args) {
       let resolvedPath = pipelinePath;
       let tempPath;
       if (pipelineYaml) {
-        tempPath = join24(tmpdir5(), `vibe-mcp-pipeline-${Date.now()}.yaml`);
-        await writeFile24(tempPath, pipelineYaml, "utf-8");
+        tempPath = join25(tmpdir5(), `vibe-mcp-pipeline-${Date.now()}.yaml`);
+        await writeFile25(tempPath, pipelineYaml, "utf-8");
         resolvedPath = tempPath;
       }
       try {
@@ -464181,9 +464859,9 @@ init_ai_edit();
 init_api_key();
 init_exec_safe();
 init_remotion();
-import { resolve as resolve37, dirname as dirname23, basename as basename15 } from "node:path";
-import { writeFile as writeFile25, mkdir as mkdir18, rm as rm5 } from "node:fs/promises";
-import { existsSync as existsSync37 } from "node:fs";
+import { resolve as resolve41, dirname as dirname26, basename as basename17 } from "node:path";
+import { writeFile as writeFile26, mkdir as mkdir20, rm as rm5 } from "node:fs/promises";
+import { existsSync as existsSync39 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
 var ASS_STYLES = ["karaoke-sweep", "typewriter"];
 var SENTENCE_BREAKS = /[.!?]/;
@@ -464333,9 +465011,9 @@ async function executeAnimatedCaption(options) {
     } catch {
     }
     const effectiveFontSize = fontSize ?? Math.round(height * 0.04);
-    const tmpAudioDir = resolve37(tmpdir6(), `vf-ac-${Date.now()}`);
-    await mkdir18(tmpAudioDir, { recursive: true });
-    const audioPath = resolve37(tmpAudioDir, "audio.wav");
+    const tmpAudioDir = resolve41(tmpdir6(), `vf-ac-${Date.now()}`);
+    await mkdir20(tmpAudioDir, { recursive: true });
+    const audioPath = resolve41(tmpAudioDir, "audio.wav");
     await execSafe("ffmpeg", [
       "-y",
       "-i",
@@ -464362,10 +465040,10 @@ async function executeAnimatedCaption(options) {
       return { success: false, error: "No words detected in transcription" };
     }
     const groups = groupWords(transcript.words, { wordsPerGroup, maxChars });
-    const absOutputPath = resolve37(process.cwd(), outputPath);
-    const outDir = dirname23(absOutputPath);
-    if (!existsSync37(outDir)) {
-      await mkdir18(outDir, { recursive: true });
+    const absOutputPath = resolve41(process.cwd(), outputPath);
+    const outDir = dirname26(absOutputPath);
+    if (!existsSync39(outDir)) {
+      await mkdir20(outDir, { recursive: true });
     }
     if (tier === "ass") {
       const assContent = generateASS(
@@ -464373,8 +465051,8 @@ async function executeAnimatedCaption(options) {
         effectiveStyle,
         { highlightColor, fontSize: effectiveFontSize, position, width, height }
       );
-      const assPath = resolve37(tmpAudioDir, "captions.ass");
-      await writeFile25(assPath, assContent, "utf-8");
+      const assPath = resolve41(tmpAudioDir, "captions.ass");
+      await writeFile26(assPath, assContent, "utf-8");
       const escapedAssPath = assPath.replace(/\\/g, "\\\\").replace(/:/g, "\\:");
       await execSafe("ffmpeg", [
         "-y",
@@ -464396,7 +465074,7 @@ async function executeAnimatedCaption(options) {
         width,
         height,
         fps: videoFps,
-        videoFileName: basename15(videoPath)
+        videoFileName: basename17(videoPath)
       });
       const durationInFrames = Math.ceil(duration * videoFps);
       const renderResult = await renderWithEmbeddedVideo({
@@ -464407,7 +465085,7 @@ async function executeAnimatedCaption(options) {
         fps: videoFps,
         durationInFrames,
         videoPath,
-        videoFileName: basename15(videoPath),
+        videoFileName: basename17(videoPath),
         outputPath: absOutputPath
       });
       if (!renderResult.success) {
@@ -465083,654 +465761,261 @@ var aiAudioTools = [
         threshold: { type: "string", description: "Sidechain threshold in dB (default: -30)" },
         ratio: { type: "string", description: "Compression ratio (default: 3)" }
       },
-      required: ["musicPath", "voicePath"]
-    }
-  }
-];
-async function handleAiAudioToolCall(name, args) {
-  switch (name) {
-    case "audio_transcribe": {
-      const result = await executeTranscribe({
-        audioPath: args.audioPath,
-        language: args.language,
-        output: args.output,
-        format: args.format
-      });
-      if (!result.success) return `Transcription failed: ${result.error}`;
-      return JSON.stringify({
-        success: true,
-        text: result.text?.slice(0, 500),
-        segmentCount: result.segments?.length,
-        detectedLanguage: result.detectedLanguage,
-        outputPath: result.outputPath
-      });
-    }
-    case "audio_isolate": {
-      const result = await executeIsolate({
-        audioPath: args.audioPath,
-        output: args.output
-      });
-      if (!result.success) return `Audio isolation failed: ${result.error}`;
-      return JSON.stringify({ success: true, outputPath: result.outputPath });
-    }
-    case "audio_voice_clone": {
-      const result = await executeVoiceClone({
-        samplePaths: args.samplePaths,
-        name: args.name,
-        description: args.description,
-        removeNoise: args.removeNoise
-      });
-      if (!result.success) return `Voice cloning failed: ${result.error}`;
-      return JSON.stringify({ success: true, voiceId: result.voiceId, name: result.name });
-    }
-    case "audio_dub": {
-      const result = await executeDub({
-        mediaPath: args.mediaPath,
-        language: args.language,
-        source: args.source,
-        voice: args.voice,
-        analyzeOnly: args.analyzeOnly,
-        output: args.output
-      });
-      if (!result.success) return `Dubbing failed: ${result.error}`;
-      return JSON.stringify({
-        success: true,
-        outputPath: result.outputPath,
-        sourceLanguage: result.sourceLanguage,
-        targetLanguage: result.targetLanguage,
-        segmentCount: result.segmentCount
-      });
-    }
-    case "audio_duck": {
-      const result = await executeDuck({
-        musicPath: args.musicPath,
-        voicePath: args.voicePath,
-        output: args.output,
-        threshold: args.threshold,
-        ratio: args.ratio
-      });
-      if (!result.success) return `Audio ducking failed: ${result.error}`;
-      return JSON.stringify({ success: true, outputPath: result.outputPath });
-    }
-    default:
-      throw new Error(`Unknown AI audio tool: ${name}`);
-  }
-}
-
-// src/tools/ai-edit-advanced.ts
-init_edit_cmd();
-var aiEditAdvancedTools = [
-  {
-    name: "edit_grade",
-    description: "Apply AI-generated color grading using Claude + FFmpeg. Use preset for free built-in grades, or style for custom AI-generated grades (needs ANTHROPIC_API_KEY).",
-    inputSchema: {
-      type: "object",
-      properties: {
-        videoPath: { type: "string", description: "Input video file path" },
-        style: { type: "string", description: "Custom style description (e.g., 'cinematic warm sunset')" },
-        preset: {
-          type: "string",
-          enum: ["film-noir", "vintage", "cinematic-warm", "cool-tones", "high-contrast", "pastel", "cyberpunk", "horror"],
-          description: "Built-in preset (no API key needed)"
-        },
-        output: { type: "string", description: "Output video file path" },
-        analyzeOnly: { type: "boolean", description: "Show FFmpeg filter without applying" }
-      },
-      required: ["videoPath"]
-    }
-  },
-  {
-    name: "edit_speed_ramp",
-    description: "Apply content-aware speed ramping. Analyzes speech with Whisper, plans speed changes with Claude, applies with FFmpeg. Requires OPENAI_API_KEY + ANTHROPIC_API_KEY.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        videoPath: { type: "string", description: "Input video file path (must have audio)" },
-        output: { type: "string", description: "Output video file path" },
-        style: {
-          type: "string",
-          enum: ["dramatic", "smooth", "action"],
-          description: "Speed ramp style (default: dramatic)"
-        },
-        minSpeed: { type: "number", description: "Minimum speed factor (default: 0.25)" },
-        maxSpeed: { type: "number", description: "Maximum speed factor (default: 4.0)" },
-        analyzeOnly: { type: "boolean", description: "Show keyframes without applying" },
-        language: { type: "string", description: "Language code for transcription" }
-      },
-      required: ["videoPath"]
-    }
-  },
-  {
-    name: "edit_reframe",
-    description: "Auto-reframe video to a different aspect ratio using smart cropping. Free (FFmpeg only).",
-    inputSchema: {
-      type: "object",
-      properties: {
-        videoPath: { type: "string", description: "Input video file path" },
-        aspect: { type: "string", description: "Target aspect ratio: 9:16, 1:1, 4:5 (default: 9:16)" },
-        focus: {
-          type: "string",
-          enum: ["auto", "face", "center", "action"],
-          description: "Focus mode (default: auto)"
-        },
-        output: { type: "string", description: "Output video file path" },
-        analyzeOnly: { type: "boolean", description: "Show crop region without applying" }
-      },
-      required: ["videoPath"]
-    }
-  },
-  {
-    name: "edit_interpolate",
-    description: "Create slow motion with AI frame interpolation using FFmpeg minterpolate. Free, no API key needed.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        videoPath: { type: "string", description: "Input video file path" },
-        output: { type: "string", description: "Output video file path" },
-        factor: { type: "number", description: "Slow motion factor: 2, 4, or 8 (default: 2)" },
-        fps: { type: "number", description: "Target output FPS (default: auto)" },
-        quality: {
-          type: "string",
-          enum: ["fast", "quality"],
-          description: "Interpolation quality (default: quality)"
-        }
-      },
-      required: ["videoPath"]
-    }
-  },
-  {
-    name: "edit_upscale",
-    description: "Upscale video resolution using FFmpeg (Lanczos scaling). Free, no API key needed.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        videoPath: { type: "string", description: "Input video file path" },
-        output: { type: "string", description: "Output video file path" },
-        scale: { type: "number", description: "Scale factor: 2 or 4 (default: 2)" },
-        quality: {
-          type: "string",
-          enum: ["fast", "quality"],
-          description: "Scaling quality (default: quality, uses Lanczos)"
-        }
-      },
-      required: ["videoPath"]
-    }
-  }
-];
-async function handleAiEditAdvancedToolCall(name, args) {
-  switch (name) {
-    case "edit_grade": {
-      const result = await executeGrade({
-        videoPath: args.videoPath,
-        style: args.style,
-        preset: args.preset,
-        output: args.output,
-        analyzeOnly: args.analyzeOnly
-      });
-      if (!result.success) return `Color grading failed: ${result.error}`;
-      return JSON.stringify({ success: true, outputPath: result.outputPath, style: result.style, description: result.description, ffmpegFilter: result.ffmpegFilter });
-    }
-    case "edit_speed_ramp": {
-      const result = await executeSpeedRamp({
-        videoPath: args.videoPath,
-        output: args.output,
-        style: args.style,
-        minSpeed: args.minSpeed,
-        maxSpeed: args.maxSpeed,
-        analyzeOnly: args.analyzeOnly,
-        language: args.language
-      });
-      if (!result.success) return `Speed ramping failed: ${result.error}`;
-      return JSON.stringify({ success: true, outputPath: result.outputPath, keyframeCount: result.keyframes?.length, avgSpeed: result.avgSpeed });
-    }
-    case "edit_reframe": {
-      const result = await executeReframe({
-        videoPath: args.videoPath,
-        aspect: args.aspect,
-        focus: args.focus,
-        output: args.output,
-        analyzeOnly: args.analyzeOnly
-      });
-      if (!result.success) return `Reframe failed: ${result.error}`;
-      return JSON.stringify({ success: true, outputPath: result.outputPath, sourceAspect: result.sourceAspect, targetAspect: result.targetAspect });
-    }
-    case "edit_interpolate": {
-      const result = await executeInterpolate({
-        videoPath: args.videoPath,
-        output: args.output,
-        factor: args.factor,
-        fps: args.fps,
-        quality: args.quality
-      });
-      if (!result.success) return `Interpolation failed: ${result.error}`;
-      return JSON.stringify({ success: true, outputPath: result.outputPath, originalFps: result.originalFps, targetFps: result.targetFps, factor: result.factor });
-    }
-    case "edit_upscale": {
-      const result = await executeUpscale({
-        videoPath: args.videoPath,
-        output: args.output,
-        scale: args.scale,
-        quality: args.quality
-      });
-      if (!result.success) return `Upscale failed: ${result.error}`;
-      return JSON.stringify({ success: true, outputPath: result.outputPath, originalRes: result.originalRes, targetRes: result.targetRes });
+      required: ["musicPath", "voicePath"]
     }
-    default:
-      throw new Error(`Unknown advanced edit tool: ${name}`);
   }
-}
-
-// src/tools/scene.ts
-init_scene_project();
-init_scene_lint();
-import { resolve as resolve44 } from "node:path";
-
-// ../cli/src/commands/_shared/scene-render.ts
-var import_yaml6 = __toESM(require_dist16(), 1);
-init_dist();
-init_chrome();
-init_scene_lint();
-import { mkdir as mkdir19, readFile as readFile24, stat as stat3 } from "node:fs/promises";
-import { existsSync as existsSync38 } from "node:fs";
-import { resolve as resolve40, relative as relative6, dirname as dirname25, basename as basename17 } from "node:path";
-
-// ../cli/src/commands/_shared/scene-audio-scan.ts
-import { readFile as readFile23 } from "node:fs/promises";
-import { resolve as resolve38 } from "node:path";
-function parseRootClips(rootHtml) {
-  const clips = [];
-  const clipRegex = /<div\b[^>]*class="clip"[^>]*>/gi;
-  let match2;
-  while ((match2 = clipRegex.exec(rootHtml)) !== null) {
-    const tag = match2[0];
-    const compositionId = pickAttr(tag, "data-composition-id");
-    const compositionSrc = pickAttr(tag, "data-composition-src");
-    const start = pickNumberAttr(tag, "data-start");
-    const duration = pickNumberAttr(tag, "data-duration");
-    const trackIndex = pickNumberAttr(tag, "data-track-index") ?? 1;
-    if (!compositionId || !compositionSrc || start === null || duration === null) {
-      continue;
+];
+async function handleAiAudioToolCall(name, args) {
+  switch (name) {
+    case "audio_transcribe": {
+      const result = await executeTranscribe({
+        audioPath: args.audioPath,
+        language: args.language,
+        output: args.output,
+        format: args.format
+      });
+      if (!result.success) return `Transcription failed: ${result.error}`;
+      return JSON.stringify({
+        success: true,
+        text: result.text?.slice(0, 500),
+        segmentCount: result.segments?.length,
+        detectedLanguage: result.detectedLanguage,
+        outputPath: result.outputPath
+      });
     }
-    clips.push({ compositionId, compositionSrc, start, duration, trackIndex });
-  }
-  return clips;
-}
-function parseSceneAudios(compositionHtml) {
-  const out = [];
-  const audioRegex = /<audio\b([^>]*)>/gi;
-  let match2;
-  while ((match2 = audioRegex.exec(compositionHtml)) !== null) {
-    const attrs = match2[1];
-    const src = pickAttr(attrs, "src");
-    if (!src) continue;
-    const localStart = pickNumberAttr(attrs, "data-start") ?? 0;
-    const durationRaw = pickAttr(attrs, "data-duration");
-    const durationHint = !durationRaw || durationRaw === "auto" ? "auto" : Number(durationRaw);
-    const volume = pickNumberAttr(attrs, "data-volume") ?? 1;
-    const trackIndex = pickNumberAttr(attrs, "data-track-index") ?? 2;
-    out.push({ srcRel: src, localStart, durationHint, volume, trackIndex });
-  }
-  return out;
-}
-function makeFsCompositionReader(projectDir) {
-  return async (compositionSrcRel) => {
-    const abs = resolve38(projectDir, compositionSrcRel);
-    try {
-      return await readFile23(abs, "utf-8");
-    } catch {
-      return null;
+    case "audio_isolate": {
+      const result = await executeIsolate({
+        audioPath: args.audioPath,
+        output: args.output
+      });
+      if (!result.success) return `Audio isolation failed: ${result.error}`;
+      return JSON.stringify({ success: true, outputPath: result.outputPath });
     }
-  };
-}
-async function scanSceneAudio(opts) {
-  const reader = opts.readComposition ?? makeFsCompositionReader(opts.projectDir);
-  const clips = parseRootClips(opts.rootHtml);
-  const out = [];
-  for (const clip of clips) {
-    const html = await reader(clip.compositionSrc);
-    if (!html) continue;
-    const audios = parseSceneAudios(html);
-    for (const audio of audios) {
-      out.push({
-        srcRel: audio.srcRel,
-        srcAbs: resolve38(opts.projectDir, audio.srcRel),
-        absoluteStart: clip.start + audio.localStart,
-        durationHint: audio.durationHint,
-        clipDurationCap: clip.duration - audio.localStart,
-        volume: audio.volume,
-        trackIndex: audio.trackIndex,
-        compositionSrc: clip.compositionSrc
+    case "audio_voice_clone": {
+      const result = await executeVoiceClone({
+        samplePaths: args.samplePaths,
+        name: args.name,
+        description: args.description,
+        removeNoise: args.removeNoise
       });
+      if (!result.success) return `Voice cloning failed: ${result.error}`;
+      return JSON.stringify({ success: true, voiceId: result.voiceId, name: result.name });
     }
-  }
-  out.sort((a, b) => a.absoluteStart - b.absoluteStart);
-  return out;
-}
-function pickAttr(tag, name) {
-  const re = new RegExp(`\\b${escapeRegex3(name)}\\s*=\\s*("([^"]*)"|'([^']*)')`);
-  const m = tag.match(re);
-  if (!m) return null;
-  return m[2] ?? m[3] ?? null;
-}
-function pickNumberAttr(tag, name) {
-  const raw2 = pickAttr(tag, name);
-  if (raw2 === null) return null;
-  const n = Number(raw2);
-  return Number.isFinite(n) ? n : null;
-}
-function escapeRegex3(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// ../cli/src/commands/_shared/scene-audio-mux.ts
-init_exec_safe();
-import { rename as rename6, unlink as unlink5 } from "node:fs/promises";
-import { resolve as resolve39, dirname as dirname24, extname as extname12, basename as basename16 } from "node:path";
-function buildAudioMuxFilter(audios) {
-  if (audios.length === 0) return null;
-  const labels = [];
-  const stages = [];
-  audios.forEach((a, i) => {
-    const inputIdx = i + 1;
-    const delayMs = Math.max(0, Math.round(a.absoluteStart * 1e3));
-    const volume = Number.isFinite(a.volume) ? a.volume : 1;
-    const trimSec = Math.max(0, a.clipDurationCap);
-    const label = `a${i}`;
-    const stage = [
-      `[${inputIdx}:a]`,
-      `atrim=duration=${trimSec.toFixed(3)},`,
-      `asetpts=PTS-STARTPTS,`,
-      `adelay=${delayMs}:all=1,`,
-      `volume=${volume}`,
-      `[${label}]`
-    ].join("");
-    stages.push(stage);
-    labels.push(`[${label}]`);
-  });
-  if (audios.length === 1) {
-    return {
-      filterComplex: stages.join(";"),
-      outLabel: labels[0],
-      inputCount: 1
-    };
-  }
-  const mix = `${labels.join("")}amix=inputs=${audios.length}:dropout_transition=0:normalize=0[mixed]`;
-  return {
-    filterComplex: `${stages.join(";")};${mix}`,
-    outLabel: "[mixed]",
-    inputCount: audios.length
-  };
-}
-function audioCodecForFormat(format4) {
-  if (format4 === "webm") return "libopus";
-  if (format4 === "mov") return "pcm_s16le";
-  return "aac";
-}
-async function muxAudioIntoVideo(opts) {
-  if (opts.audios.length === 0) {
-    return { success: true, outputPath: opts.videoPath, audioCount: 0 };
-  }
-  if (!commandExists("ffmpeg")) {
-    return {
-      success: false,
-      outputPath: opts.videoPath,
-      audioCount: opts.audios.length,
-      error: "ffmpeg not found in PATH \u2014 install via `brew install ffmpeg` (mac) or your package manager"
-    };
-  }
-  const filter4 = buildAudioMuxFilter(opts.audios);
-  if (!filter4) {
-    return { success: true, outputPath: opts.videoPath, audioCount: 0 };
-  }
-  const ext = extname12(opts.videoPath) || `.${opts.format}`;
-  const tmpPath = resolve39(
-    dirname24(opts.videoPath),
-    `.${basename16(opts.videoPath, ext)}.muxing${ext}`
-  );
-  const args = ["-y", "-loglevel", "error", "-i", opts.videoPath];
-  for (const a of opts.audios) {
-    args.push("-i", a.srcAbs);
-  }
-  args.push(
-    "-filter_complex",
-    filter4.filterComplex,
-    "-map",
-    "0:v",
-    "-map",
-    filter4.outLabel,
-    "-c:v",
-    "copy",
-    "-c:a",
-    audioCodecForFormat(opts.format),
-    // Cap on the video duration so audio that overruns the producer's render
-    // (e.g. a long Kokoro wav on a short scene) doesn't extend the output.
-    // Video drives the timeline because the producer already counted frames.
-    "-t",
-    opts.totalDuration && opts.totalDuration > 0 ? opts.totalDuration.toFixed(3) : opts.videoDuration?.toFixed(3) ?? ""
-  );
-  if (args[args.length - 1] === "") {
-    args.pop();
-    args.pop();
-  }
-  args.push("-movflags", "+faststart", tmpPath);
-  try {
-    const { stderr } = await execSafe("ffmpeg", args);
-    if (stderr && opts.onProgress) {
-      stderr.split(/\r?\n/).forEach((line) => opts.onProgress?.(line));
+    case "audio_dub": {
+      const result = await executeDub({
+        mediaPath: args.mediaPath,
+        language: args.language,
+        source: args.source,
+        voice: args.voice,
+        analyzeOnly: args.analyzeOnly,
+        output: args.output
+      });
+      if (!result.success) return `Dubbing failed: ${result.error}`;
+      return JSON.stringify({
+        success: true,
+        outputPath: result.outputPath,
+        sourceLanguage: result.sourceLanguage,
+        targetLanguage: result.targetLanguage,
+        segmentCount: result.segmentCount
+      });
     }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    try {
-      await unlink5(tmpPath);
-    } catch {
+    case "audio_duck": {
+      const result = await executeDuck({
+        musicPath: args.musicPath,
+        voicePath: args.voicePath,
+        output: args.output,
+        threshold: args.threshold,
+        ratio: args.ratio
+      });
+      if (!result.success) return `Audio ducking failed: ${result.error}`;
+      return JSON.stringify({ success: true, outputPath: result.outputPath });
     }
-    return {
-      success: false,
-      outputPath: opts.videoPath,
-      audioCount: opts.audios.length,
-      error: `ffmpeg mux failed: ${msg}`
-    };
+    default:
+      throw new Error(`Unknown AI audio tool: ${name}`);
   }
-  await rename6(tmpPath, opts.videoPath);
-  return {
-    success: true,
-    outputPath: opts.videoPath,
-    audioCount: opts.audios.length
-  };
 }
 
-// ../cli/src/commands/_shared/scene-render.ts
-function qualityToCrf2(quality = "standard") {
-  return quality === "draft" ? 28 : quality === "high" ? 18 : 23;
-}
-function defaultOutputPath(opts) {
-  const fmt = opts.format ?? "mp4";
-  const now = opts.now ?? /* @__PURE__ */ new Date();
-  const stamp = now.toISOString().replace(/[:T]/g, "-").replace(/\..+$/, "");
-  const name = (opts.projectName ?? basename17(resolve40(opts.projectDir))) || "scene";
-  return resolve40(opts.projectDir, "renders", `${name}-${stamp}.${fmt}`);
-}
-async function readProjectName(projectDir) {
-  const cfgPath = resolve40(projectDir, "vibe.project.yaml");
-  if (!existsSync38(cfgPath)) return void 0;
-  try {
-    const raw2 = await (await import("node:fs/promises")).readFile(cfgPath, "utf-8");
-    const parsed = (0, import_yaml6.parse)(raw2);
-    return parsed?.name ?? void 0;
-  } catch {
-    return void 0;
-  }
-}
-function buildRenderConfig(opts) {
-  const quality = opts.quality ?? "standard";
-  return {
-    fps: opts.fps ?? 30,
-    quality,
-    format: opts.format ?? "mp4",
-    entryFile: opts.entryFile ?? "index.html",
-    crf: qualityToCrf2(quality),
-    workers: opts.workers ?? 1
-  };
-}
-async function executeSceneRender(opts = {}) {
-  const projectDir = resolve40(opts.projectDir ?? ".");
-  const root2 = opts.root ?? "index.html";
-  const projectStat = await safeStat(projectDir);
-  if (!projectStat || !projectStat.isDirectory()) {
-    return { success: false, error: `Project directory not found: ${projectDir}` };
-  }
-  if (!await rootExists(projectDir, root2)) {
-    return {
-      success: false,
-      error: `Root composition not found: ${resolve40(projectDir, root2)}. Run \`vibe scene init\` first.`
-    };
-  }
-  const chrome2 = await preflightChrome();
-  if (!chrome2.ok) {
-    return { success: false, error: chrome2.reason };
-  }
-  const projectName = await readProjectName(projectDir);
-  const outputPath = opts.output ? resolve40(projectDir, opts.output) : defaultOutputPath({ projectDir, projectName, format: opts.format });
-  await mkdir19(dirname25(outputPath), { recursive: true });
-  const config4 = buildRenderConfig({
-    fps: opts.fps,
-    quality: opts.quality,
-    format: opts.format,
-    workers: opts.workers,
-    entryFile: root2
-  });
-  const job = createRenderJob(config4);
-  const start = Date.now();
-  try {
-    await executeRenderJob(
-      job,
-      projectDir,
-      outputPath,
-      (j, msg) => opts.onProgress?.(j.progress, j.currentStage ?? msg),
-      opts.signal
-    );
-  } catch (err) {
-    return {
-      success: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-  let audioCount = 0;
-  let audioMuxApplied = false;
-  let audioMuxWarning;
-  try {
-    opts.onProgress?.(0.95, "Mixing audio");
-    const rootHtml = await readFile24(resolve40(projectDir, root2), "utf-8");
-    const audios = await scanSceneAudio({ projectDir, rootHtml });
-    audioCount = audios.length;
-    if (audios.length > 0) {
-      const videoDuration = job.totalFrames && config4.fps ? job.totalFrames / config4.fps : void 0;
-      const mux = await muxAudioIntoVideo({
-        videoPath: outputPath,
-        audios,
-        format: config4.format ?? "mp4",
-        videoDuration,
-        onProgress: (line) => {
-          if (line) opts.onProgress?.(0.97, line);
+// src/tools/ai-edit-advanced.ts
+init_edit_cmd();
+var aiEditAdvancedTools = [
+  {
+    name: "edit_grade",
+    description: "Apply AI-generated color grading using Claude + FFmpeg. Use preset for free built-in grades, or style for custom AI-generated grades (needs ANTHROPIC_API_KEY).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        videoPath: { type: "string", description: "Input video file path" },
+        style: { type: "string", description: "Custom style description (e.g., 'cinematic warm sunset')" },
+        preset: {
+          type: "string",
+          enum: ["film-noir", "vintage", "cinematic-warm", "cool-tones", "high-contrast", "pastel", "cyberpunk", "horror"],
+          description: "Built-in preset (no API key needed)"
+        },
+        output: { type: "string", description: "Output video file path" },
+        analyzeOnly: { type: "boolean", description: "Show FFmpeg filter without applying" }
+      },
+      required: ["videoPath"]
+    }
+  },
+  {
+    name: "edit_speed_ramp",
+    description: "Apply content-aware speed ramping. Analyzes speech with Whisper, plans speed changes with Claude, applies with FFmpeg. Requires OPENAI_API_KEY + ANTHROPIC_API_KEY.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        videoPath: { type: "string", description: "Input video file path (must have audio)" },
+        output: { type: "string", description: "Output video file path" },
+        style: {
+          type: "string",
+          enum: ["dramatic", "smooth", "action"],
+          description: "Speed ramp style (default: dramatic)"
+        },
+        minSpeed: { type: "number", description: "Minimum speed factor (default: 0.25)" },
+        maxSpeed: { type: "number", description: "Maximum speed factor (default: 4.0)" },
+        analyzeOnly: { type: "boolean", description: "Show keyframes without applying" },
+        language: { type: "string", description: "Language code for transcription" }
+      },
+      required: ["videoPath"]
+    }
+  },
+  {
+    name: "edit_reframe",
+    description: "Auto-reframe video to a different aspect ratio using smart cropping. Free (FFmpeg only).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        videoPath: { type: "string", description: "Input video file path" },
+        aspect: { type: "string", description: "Target aspect ratio: 9:16, 1:1, 4:5 (default: 9:16)" },
+        focus: {
+          type: "string",
+          enum: ["auto", "face", "center", "action"],
+          description: "Focus mode (default: auto)"
+        },
+        output: { type: "string", description: "Output video file path" },
+        analyzeOnly: { type: "boolean", description: "Show crop region without applying" }
+      },
+      required: ["videoPath"]
+    }
+  },
+  {
+    name: "edit_interpolate",
+    description: "Create slow motion with AI frame interpolation using FFmpeg minterpolate. Free, no API key needed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        videoPath: { type: "string", description: "Input video file path" },
+        output: { type: "string", description: "Output video file path" },
+        factor: { type: "number", description: "Slow motion factor: 2, 4, or 8 (default: 2)" },
+        fps: { type: "number", description: "Target output FPS (default: auto)" },
+        quality: {
+          type: "string",
+          enum: ["fast", "quality"],
+          description: "Interpolation quality (default: quality)"
         }
-      });
-      if (mux.success) {
-        audioMuxApplied = true;
-      } else {
-        audioMuxWarning = mux.error;
-      }
+      },
+      required: ["videoPath"]
+    }
+  },
+  {
+    name: "edit_upscale",
+    description: "Upscale video resolution using FFmpeg (Lanczos scaling). Free, no API key needed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        videoPath: { type: "string", description: "Input video file path" },
+        output: { type: "string", description: "Output video file path" },
+        scale: { type: "number", description: "Scale factor: 2 or 4 (default: 2)" },
+        quality: {
+          type: "string",
+          enum: ["fast", "quality"],
+          description: "Scaling quality (default: quality, uses Lanczos)"
+        }
+      },
+      required: ["videoPath"]
     }
-  } catch (err) {
-    audioMuxWarning = err instanceof Error ? err.message : String(err);
   }
-  return {
-    success: true,
-    outputPath: relative6(process.cwd(), outputPath) || outputPath,
-    durationMs: Date.now() - start,
-    framesRendered: job.framesRendered,
-    totalFrames: job.totalFrames,
-    fps: config4.fps,
-    quality: config4.quality,
-    format: config4.format,
-    audioCount,
-    audioMuxApplied,
-    audioMuxWarning
-  };
-}
-async function safeStat(p) {
-  try {
-    return await stat3(p);
-  } catch {
-    return null;
+];
+async function handleAiEditAdvancedToolCall(name, args) {
+  switch (name) {
+    case "edit_grade": {
+      const result = await executeGrade({
+        videoPath: args.videoPath,
+        style: args.style,
+        preset: args.preset,
+        output: args.output,
+        analyzeOnly: args.analyzeOnly
+      });
+      if (!result.success) return `Color grading failed: ${result.error}`;
+      return JSON.stringify({ success: true, outputPath: result.outputPath, style: result.style, description: result.description, ffmpegFilter: result.ffmpegFilter });
+    }
+    case "edit_speed_ramp": {
+      const result = await executeSpeedRamp({
+        videoPath: args.videoPath,
+        output: args.output,
+        style: args.style,
+        minSpeed: args.minSpeed,
+        maxSpeed: args.maxSpeed,
+        analyzeOnly: args.analyzeOnly,
+        language: args.language
+      });
+      if (!result.success) return `Speed ramping failed: ${result.error}`;
+      return JSON.stringify({ success: true, outputPath: result.outputPath, keyframeCount: result.keyframes?.length, avgSpeed: result.avgSpeed });
+    }
+    case "edit_reframe": {
+      const result = await executeReframe({
+        videoPath: args.videoPath,
+        aspect: args.aspect,
+        focus: args.focus,
+        output: args.output,
+        analyzeOnly: args.analyzeOnly
+      });
+      if (!result.success) return `Reframe failed: ${result.error}`;
+      return JSON.stringify({ success: true, outputPath: result.outputPath, sourceAspect: result.sourceAspect, targetAspect: result.targetAspect });
+    }
+    case "edit_interpolate": {
+      const result = await executeInterpolate({
+        videoPath: args.videoPath,
+        output: args.output,
+        factor: args.factor,
+        fps: args.fps,
+        quality: args.quality
+      });
+      if (!result.success) return `Interpolation failed: ${result.error}`;
+      return JSON.stringify({ success: true, outputPath: result.outputPath, originalFps: result.originalFps, targetFps: result.targetFps, factor: result.factor });
+    }
+    case "edit_upscale": {
+      const result = await executeUpscale({
+        videoPath: args.videoPath,
+        output: args.output,
+        scale: args.scale,
+        quality: args.quality
+      });
+      if (!result.success) return `Upscale failed: ${result.error}`;
+      return JSON.stringify({ success: true, outputPath: result.outputPath, originalRes: result.originalRes, targetRes: result.targetRes });
+    }
+    default:
+      throw new Error(`Unknown advanced edit tool: ${name}`);
   }
 }
 
+// src/tools/scene.ts
+init_scene_project();
+init_scene_lint();
+init_scene_render();
+import { resolve as resolve44 } from "node:path";
+
 // ../cli/src/commands/scene.ts
 init_esm();
 init_source();
 init_ora();
 var import_yaml7 = __toESM(require_dist16(), 1);
 init_dist2();
+init_tts_resolve();
+init_scene_project();
 import { basename as basename18, resolve as resolve43, relative as relative7, dirname as dirname27 } from "node:path";
 import { mkdir as mkdir21, readFile as readFile26, writeFile as writeFile27, access as access5, copyFile as copyFile4 } from "node:fs/promises";
 import { existsSync as existsSync40 } from "node:fs";
 
-// ../cli/src/commands/_shared/tts-resolve.ts
-init_dist2();
-init_api_key();
-init_api_key();
-async function resolveTtsProvider(preferred = "auto") {
-  const choice = preferred === "auto" ? hasApiKey("ELEVENLABS_API_KEY") ? "elevenlabs" : "kokoro" : preferred;
-  if (choice === "elevenlabs") {
-    return buildElevenLabs();
-  }
-  return buildKokoro();
-}
-async function buildElevenLabs() {
-  const key2 = await getApiKey("ELEVENLABS_API_KEY", "ElevenLabs");
-  if (!key2) {
-    throw new TtsKeyMissingError("elevenlabs");
-  }
-  const provider = new ElevenLabsProvider();
-  await provider.initialize({ apiKey: key2 });
-  const call = async (text, opts) => provider.textToSpeech(text, {
-    voiceId: opts?.voice,
-    speed: opts?.speed
-  });
-  return { provider: "elevenlabs", audioExtension: "mp3", call };
-}
-async function buildKokoro() {
-  const provider = new KokoroProvider();
-  await provider.initialize({});
-  const call = async (text, opts) => provider.textToSpeech(text, {
-    voice: opts?.voice,
-    speed: opts?.speed,
-    onProgress: opts?.onProgress
-  });
-  return { provider: "kokoro", audioExtension: "wav", call };
-}
-var TtsKeyMissingError = class extends Error {
-  constructor(provider) {
-    super(
-      provider === "elevenlabs" ? "ElevenLabs API key required (ELEVENLABS_API_KEY). Run 'vibe setup', set ELEVENLABS_API_KEY in .env, or pass --tts kokoro for local synthesis." : `Provider ${provider} is unavailable.`
-    );
-    this.provider = provider;
-    this.name = "TtsKeyMissingError";
-  }
-};
-function parseTtsProviderName(value) {
-  if (!value) return "auto";
-  if (value === "auto" || value === "elevenlabs" || value === "kokoro") {
-    return value;
-  }
-  throw new Error(
-    `Invalid --tts: ${value}. Valid: auto, elevenlabs, kokoro.`
-  );
-}
-
-// ../cli/src/commands/scene.ts
-init_scene_project();
-
 // ../cli/src/commands/_shared/visual-styles.ts
 var STYLES = [
   {
@@ -465902,203 +466187,8 @@ function visualStyleNames() {
 // ../cli/src/commands/scene.ts
 init_scene_html_emit();
 init_scene_lint();
-
-// ../cli/src/commands/_shared/scene-build.ts
-init_dist2();
-init_compose_scenes_skills();
-import { existsSync as existsSync39 } from "node:fs";
-import { mkdir as mkdir20, readFile as readFile25, writeFile as writeFile26 } from "node:fs/promises";
-import { dirname as dirname26, join as join25, resolve as resolve41 } from "node:path";
-init_storyboard_parse();
-async function executeSceneBuild(opts) {
-  const startedAt = Date.now();
-  const projectDir = resolve41(opts.projectDir);
-  const onProgress = opts.onProgress ?? (() => {
-  });
-  const storyboardPath = join25(projectDir, "STORYBOARD.md");
-  if (!existsSync39(storyboardPath)) {
-    return failBeforePrimitives(`STORYBOARD.md not found at ${storyboardPath}`, startedAt);
-  }
-  const storyboardMd = await readFile25(storyboardPath, "utf-8");
-  const parsed = parseStoryboard(storyboardMd);
-  if (parsed.beats.length === 0) {
-    return failBeforePrimitives(
-      `STORYBOARD.md at ${storyboardPath} has no \`## Beat \u2026\` headings.`,
-      startedAt
-    );
-  }
-  const ttsProvider = opts.ttsProvider ?? parsed.frontmatter?.providers?.tts ?? "auto";
-  const imageProvider = opts.imageProvider ?? parsed.frontmatter?.providers?.image ?? "openai";
-  const voice = opts.voice ?? parsed.frontmatter?.voice;
-  onProgress({ type: "phase-start", phase: "primitives" });
-  const beatOutcomes = await Promise.all(
-    parsed.beats.map((beat) => buildBeatPrimitives(beat, {
-      projectDir,
-      ttsProvider,
-      voice,
-      imageProvider,
-      imageQuality: opts.imageQuality ?? "hd",
-      imageSize: opts.imageSize ?? "1536x1024",
-      skipNarration: opts.skipNarration ?? false,
-      skipBackdrop: opts.skipBackdrop ?? false,
-      force: opts.force ?? false,
-      onProgress
-    }))
-  );
-  onProgress({ type: "phase-start", phase: "compose" });
-  const composeResult = await executeComposeScenesWithSkills(
-    {
-      project: ".",
-      effort: opts.effort,
-      cacheDir: opts.cacheDir,
-      onProgress: (e) => onProgress(e)
-    },
-    projectDir
-  );
-  if (!composeResult.success) {
-    return {
-      success: false,
-      error: `compose failed: ${composeResult.error ?? "unknown"}`,
-      beats: beatOutcomes,
-      composeData: composeResult.data,
-      totalLatencyMs: Date.now() - startedAt
-    };
-  }
-  let outputPath;
-  let renderResult;
-  if (!opts.skipRender) {
-    onProgress({ type: "phase-start", phase: "render" });
-    onProgress({ type: "render-start" });
-    renderResult = await executeSceneRender({ projectDir });
-    if (!renderResult.success) {
-      return {
-        success: false,
-        error: `render failed: ${renderResult.error ?? "unknown"}`,
-        beats: beatOutcomes,
-        composeData: composeResult.data,
-        renderResult,
-        totalLatencyMs: Date.now() - startedAt
-      };
-    }
-    outputPath = renderResult.outputPath;
-    if (outputPath) onProgress({ type: "render-done", outputPath });
-  }
-  return {
-    success: true,
-    beats: beatOutcomes,
-    outputPath,
-    composeData: composeResult.data,
-    renderResult,
-    totalLatencyMs: Date.now() - startedAt
-  };
-}
-async function buildBeatPrimitives(beat, ctx) {
-  const [narration, backdrop] = await Promise.all([
-    ctx.skipNarration ? skipped("narration", beat.id, "--skip-narration", ctx) : dispatchNarration(beat, ctx),
-    ctx.skipBackdrop ? skipped("backdrop", beat.id, "--skip-backdrop", ctx) : dispatchBackdrop(beat, ctx)
-  ]);
-  return {
-    beatId: beat.id,
-    narrationStatus: narration.status,
-    narrationPath: narration.path,
-    narrationError: narration.error,
-    backdropStatus: backdrop.status,
-    backdropPath: backdrop.path,
-    backdropError: backdrop.error
-  };
-}
-async function dispatchNarration(beat, ctx) {
-  const text = beat.cues?.narration;
-  if (!text) return { status: "no-cue" };
-  for (const ext of ["mp3", "wav"]) {
-    const rel2 = `assets/narration-${beat.id}.${ext}`;
-    if (existsSync39(join25(ctx.projectDir, rel2)) && !ctx.force) {
-      ctx.onProgress({ type: "narration-cached", beatId: beat.id, path: rel2 });
-      return { status: "cached", path: rel2 };
-    }
-  }
-  let resolution;
-  try {
-    resolution = await resolveTtsProvider(ctx.ttsProvider);
-  } catch (err) {
-    const error = err instanceof TtsKeyMissingError ? err.message : err.message;
-    ctx.onProgress({ type: "narration-failed", beatId: beat.id, error });
-    return { status: "failed", error };
-  }
-  const result = await resolution.call(text, { voice: ctx.voice });
-  if (!result.success || !result.audioBuffer) {
-    const error = result.error ?? "unknown TTS failure";
-    ctx.onProgress({ type: "narration-failed", beatId: beat.id, error });
-    return { status: "failed", error };
-  }
-  const rel = `assets/narration-${beat.id}.${resolution.audioExtension}`;
-  const abs = join25(ctx.projectDir, rel);
-  await mkdir20(dirname26(abs), { recursive: true });
-  await writeFile26(abs, result.audioBuffer);
-  ctx.onProgress({
-    type: "narration-generated",
-    beatId: beat.id,
-    path: rel,
-    provider: resolution.provider
-  });
-  return { status: "generated", path: rel };
-}
-async function dispatchBackdrop(beat, ctx) {
-  const prompt3 = beat.cues?.backdrop;
-  if (!prompt3) return { status: "no-cue" };
-  if (ctx.imageProvider !== "openai") {
-    const error = `image provider "${ctx.imageProvider}" not yet supported (use openai)`;
-    ctx.onProgress({ type: "backdrop-failed", beatId: beat.id, error });
-    return { status: "failed", error };
-  }
-  const rel = `assets/backdrop-${beat.id}.png`;
-  const abs = join25(ctx.projectDir, rel);
-  if (existsSync39(abs) && !ctx.force) {
-    ctx.onProgress({ type: "backdrop-cached", beatId: beat.id, path: rel });
-    return { status: "cached", path: rel };
-  }
-  const apiKey = process.env.OPENAI_API_KEY ?? "";
-  if (!apiKey) {
-    const error = "OPENAI_API_KEY not set \u2014 cannot dispatch backdrop";
-    ctx.onProgress({ type: "backdrop-failed", beatId: beat.id, error });
-    return { status: "failed", error };
-  }
-  const provider = new OpenAIImageProvider();
-  await provider.initialize({ apiKey });
-  const result = await provider.generateImage(prompt3, {
-    model: "gpt-image-2",
-    size: ctx.imageSize,
-    quality: ctx.imageQuality
-  });
-  if (!result.success || !result.images?.[0]?.base64) {
-    const error = result.error ?? "no image data returned";
-    ctx.onProgress({ type: "backdrop-failed", beatId: beat.id, error });
-    return { status: "failed", error };
-  }
-  await mkdir20(dirname26(abs), { recursive: true });
-  await writeFile26(abs, Buffer.from(result.images[0].base64, "base64"));
-  ctx.onProgress({
-    type: "backdrop-generated",
-    beatId: beat.id,
-    path: rel,
-    provider: "openai"
-  });
-  return { status: "generated", path: rel };
-}
-async function skipped(kind, beatId, reason, ctx) {
-  ctx.onProgress({ type: `${kind}-skipped`, beatId, reason });
-  return { status: "skipped" };
-}
-function failBeforePrimitives(error, startedAt) {
-  return {
-    success: false,
-    error,
-    beats: [],
-    totalLatencyMs: Date.now() - startedAt
-  };
-}
-
-// ../cli/src/commands/scene.ts
+init_scene_render();
+init_scene_build();
 init_output();
 init_api_key();
 init_audio();