@vibeframe/mcp-server 0.114.0 → 0.115.0

package/dist/index.js

@@ -4871,11 +4871,11 @@ async function loadKokoroRuntime() {
 }
 async function loadKokoroFromWorkspace(baseDir = process.cwd()) {
   try {
-    const { readFile: readFile50 } = await import("node:fs/promises");
+    const { readFile: readFile48 } = await import("node:fs/promises");
     const { join: join78, resolve: resolve85 } = await import("node:path");
     const { pathToFileURL: pathToFileURL2 } = await import("node:url");
     const pkgDir = resolve85(baseDir, "node_modules", "kokoro-js");
-    const pkg = JSON.parse(await readFile50(join78(pkgDir, "package.json"), "utf-8"));
+    const pkg = JSON.parse(await readFile48(join78(pkgDir, "package.json"), "utf-8"));
     const entry = pkg.exports?.node?.import ?? pkg.exports?.default ?? pkg.module ?? pkg.main;
     if (!entry)
       return null;
@@ -4890,7 +4890,7 @@ async function loadBundledKokoroRuntime(runtimeDir = process.env.VIBE_KOKORO_RUN
   if (!base2)
     return null;
   try {
-    const { readFile: readFile50, writeFile: writeFile50, mkdir: mkdir29 } = await import("node:fs/promises");
+    const { readFile: readFile48, writeFile: writeFile51, mkdir: mkdir30 } = await import("node:fs/promises");
     const { join: join78, resolve: resolve85 } = await import("node:path");
     const { pathToFileURL: pathToFileURL2 } = await import("node:url");
     const { homedir: homedir8 } = await import("node:os");
@@ -4903,7 +4903,7 @@ async function loadBundledKokoroRuntime(runtimeDir = process.env.VIBE_KOKORO_RUN
     transformers.env.customCache = {
       async match(key2) {
         try {
-          return new Response(await readFile50(join78(cacheRoot, encodeURIComponent(String(key2)))));
+          return new Response(await readFile48(join78(cacheRoot, encodeURIComponent(String(key2)))));
         } catch {
           return void 0;
         }
@@ -4911,8 +4911,8 @@ async function loadBundledKokoroRuntime(runtimeDir = process.env.VIBE_KOKORO_RUN
       async put(key2, response) {
         try {
           const buf = Buffer.from(await response.arrayBuffer());
-          await mkdir29(cacheRoot, { recursive: true });
-          await writeFile50(join78(cacheRoot, encodeURIComponent(String(key2))), buf);
+          await mkdir30(cacheRoot, { recursive: true });
+          await writeFile51(join78(cacheRoot, encodeURIComponent(String(key2))), buf);
         } catch {
         }
       }
@@ -21945,12 +21945,29 @@ function parseBeatDuration(body) {
   const n2 = parseFloat(valueMatch[1]);
   return Number.isFinite(n2) && n2 > 0 ? n2 : void 0;
 }
-var import_yaml3, HEADING_RE, BEAT_PREFIX_RE, DURATION_SUBSECTION_RE, DURATION_VALUE_RE, BEAT_CUES_RE;
+var import_yaml3, STORYBOARD_CUE_KEYS, HEADING_RE, BEAT_PREFIX_RE, DURATION_SUBSECTION_RE, DURATION_VALUE_RE, BEAT_CUES_RE;
 var init_storyboard_parse = __esm({
   "../cli/src/commands/_shared/storyboard-parse.ts"() {
     "use strict";
     import_yaml3 = __toESM(require_dist3(), 1);
     init_frontmatter();
+    STORYBOARD_CUE_KEYS = [
+      "duration",
+      "narration",
+      "backdrop",
+      "video",
+      "keyframe",
+      "motion",
+      "voice",
+      "music",
+      "asset",
+      "characters",
+      "eyebrow",
+      "title",
+      "caption",
+      "kicker",
+      "sub"
+    ];
     HEADING_RE = /^##\s+(.+?)\s*$/gm;
     BEAT_PREFIX_RE = /^Beat\s+(.+?)\s+(?:—|:|-)\s+(.+)$/i;
     DURATION_SUBSECTION_RE = /###\s+Beat\s+duration\s*\n([\s\S]*?)(?=\n###\s|\n##\s|$)/i;
@@ -21959,22 +21976,509 @@ var init_storyboard_parse = __esm({
   }
 });
 
+// ../cli/src/commands/_shared/storyboard-edit.ts
+function validateStoryboardMarkdown(markdown) {
+  const parsed = parseStoryboard(markdown);
+  const sections = splitBeatSections(markdown);
+  const issues = [];
+  if (parsed.beats.length === 0) {
+    issues.push({
+      severity: "error",
+      code: "NO_BEATS",
+      message: "STORYBOARD.md must contain at least one `## Beat ...` heading."
+    });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const beat of parsed.beats) {
+    seen.set(beat.id, (seen.get(beat.id) ?? 0) + 1);
+  }
+  for (const [id, count] of seen.entries()) {
+    if (count > 1) {
+      issues.push({
+        severity: "error",
+        code: "DUPLICATE_BEAT_ID",
+        beatId: id,
+        message: `Beat id "${id}" appears ${count} times. Beat ids must be unique.`
+      });
+    }
+  }
+  for (const section of sections) {
+    const cueBlock = readLeadingCueBlock(section.body);
+    if (cueBlock?.error) {
+      issues.push({
+        severity: "error",
+        code: "MALFORMED_CUE_YAML",
+        beatId: section.id,
+        message: `Beat "${section.id}" has malformed YAML cues: ${cueBlock.error}`
+      });
+    }
+  }
+  const characterPool = new Set(
+    Object.keys(
+      parsed.frontmatter?.characters ?? {}
+    )
+  );
+  for (const beat of parsed.beats) {
+    const cues = beat.cues ?? {};
+    for (const [key2, value] of Object.entries(cues)) {
+      if (!ALLOWED_CUE_KEYS.has(key2)) {
+        issues.push({
+          severity: "warning",
+          code: "UNKNOWN_CUE",
+          beatId: beat.id,
+          message: `Beat "${beat.id}" uses unknown cue "${key2}". Supported cues: ${STORYBOARD_CUE_KEYS.join(", ")}.`
+        });
+        continue;
+      }
+      if (key2 === "characters") {
+        const validShape = typeof value === "string" || Array.isArray(value) && value.every((v4) => typeof v4 === "string");
+        if (!validShape) {
+          issues.push({
+            severity: "error",
+            code: "INVALID_CHARACTERS_VALUE",
+            beatId: beat.id,
+            message: `Beat "${beat.id}" cue "characters" must be a character name or a list of names.`
+          });
+          continue;
+        }
+        for (const name of beatCharacterNames({ characters: value })) {
+          if (!characterPool.has(name)) {
+            issues.push({
+              severity: "warning",
+              code: "UNKNOWN_CHARACTER",
+              beatId: beat.id,
+              message: `Beat "${beat.id}" references character "${name}" not defined in the frontmatter \`characters:\` pool.`
+            });
+          }
+        }
+        continue;
+      }
+      if (key2 === "duration") {
+        if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+          issues.push({
+            severity: "error",
+            code: "INVALID_DURATION",
+            beatId: beat.id,
+            message: `Beat "${beat.id}" cue "duration" must be a positive number of seconds.`
+          });
+        }
+        continue;
+      }
+      if (STRING_CUE_KEYS.has(key2) && typeof value !== "string") {
+        issues.push({
+          severity: "error",
+          code: "INVALID_CUE_VALUE",
+          beatId: beat.id,
+          message: `Beat "${beat.id}" cue "${key2}" must be a string.`
+        });
+      }
+    }
+  }
+  for (const beat of parsed.beats) {
+    if (beat.duration !== void 0 && beat.duration > MAX_RECOMMENDED_BEAT_SEC) {
+      issues.push({
+        severity: "warning",
+        code: "BEAT_DURATION_TOO_LONG",
+        beatId: beat.id,
+        message: `Beat "${beat.id}" is ${beat.duration}s \u2014 beats longer than ${MAX_RECOMMENDED_BEAT_SEC}s render static and overstuffed. Split it into 6-15s beats (a 90s video should have 6-8 beats).`
+      });
+    }
+  }
+  return {
+    ok: !issues.some((i3) => i3.severity === "error"),
+    beats: parsed.beats,
+    issues
+  };
+}
+function getStoryboardBeat(markdown, beatId) {
+  return parseStoryboard(markdown).beats.find((beat) => beat.id === beatId) ?? null;
+}
+function upsertStoryboardBeat(markdown, opts) {
+  const beatId = normalizeBeatId(opts.beatId);
+  const sections = splitBeatSections(markdown);
+  const existing = sections.find((section2) => section2.id === beatId);
+  const cues = storyboardCuesFromInput(opts);
+  if (existing) {
+    let next = markdown;
+    for (const [key2, value] of Object.entries(cues)) {
+      next = setStoryboardCue(next, { beatId, key: key2, value });
+    }
+    return { markdown: next, action: "updated" };
+  }
+  const section = buildStoryboardBeatSection({ ...opts, beatId, cues });
+  if (sections.length > 0 && isStarterStoryboard(markdown)) {
+    const global3 = markdown.slice(0, sections[0].start).trimEnd();
+    return {
+      markdown: `${global3}
+
+${section}`,
+      action: "replaced-starter"
+    };
+  }
+  const prefix = markdown.trimEnd();
+  return {
+    markdown: `${prefix}${prefix ? "\n\n" : ""}${section}`,
+    action: "appended"
+  };
+}
+function setStoryboardCue(markdown, opts) {
+  const section = findBeatSection(markdown, opts.beatId);
+  if (!section) {
+    throw new Error(`Beat "${opts.beatId}" not found.`);
+  }
+  if (!ALLOWED_CUE_KEYS.has(opts.key)) {
+    throw new Error(`Unsupported cue "${opts.key}". Supported cues: ${STORYBOARD_CUE_KEYS.join(", ")}.`);
+  }
+  const cue = readLeadingCueBlock(section.body);
+  if (cue?.error) {
+    throw new Error(`Cannot edit malformed YAML cues for beat "${opts.beatId}": ${cue.error}`);
+  }
+  const cues = cue?.value ? { ...cue.value } : {};
+  if (opts.unset) {
+    delete cues[opts.key];
+  } else {
+    cues[opts.key] = normalizeCueValue(opts.key, opts.value);
+  }
+  const remainingBody = cue ? section.body.slice(cue.full.length).replace(/^\s*\n/, "") : section.body.replace(/^\s*\n/, "");
+  const cueBlock = Object.keys(cues).length > 0 ? "```yaml\n" + (0, import_yaml4.stringify)(cues, { lineWidth: 0 }).trimEnd() + "\n```\n\n" : "";
+  const nextBody = cueBlock + remainingBody.trimStart();
+  const nextSection = section.raw.slice(0, section.headingEnd - section.start) + "\n\n" + nextBody.trimEnd() + "\n";
+  return markdown.slice(0, section.start) + nextSection + markdown.slice(section.end);
+}
+function moveStoryboardBeat(markdown, opts) {
+  if (opts.beatId === opts.afterBeatId) return markdown;
+  const sections = splitBeatSections(markdown);
+  const movingIndex = sections.findIndex((section) => section.id === opts.beatId);
+  if (movingIndex === -1) throw new Error(`Beat "${opts.beatId}" not found.`);
+  const afterIndex = sections.findIndex((section) => section.id === opts.afterBeatId);
+  if (afterIndex === -1) throw new Error(`Beat "${opts.afterBeatId}" not found.`);
+  const global3 = sections.length > 0 ? markdown.slice(0, sections[0].start) : markdown;
+  const chunks = sections.map((section) => section.raw);
+  const [moving] = chunks.splice(movingIndex, 1);
+  const adjustedAfterIndex = movingIndex < afterIndex ? afterIndex - 1 : afterIndex;
+  chunks.splice(adjustedAfterIndex + 1, 0, moving);
+  return global3 + normalizeBeatChunks(chunks);
+}
+function normalizeBeatChunks(chunks) {
+  return chunks.map((chunk) => chunk.trim()).filter(Boolean).join("\n\n") + "\n";
+}
+function normalizeBeatId(id) {
+  return deriveBeatId(id);
+}
+function storyboardCuesFromInput(opts) {
+  const cues = {};
+  if (opts.duration !== void 0) cues.duration = opts.duration;
+  if (opts.narration && opts.narration.trim()) cues.narration = opts.narration.trim();
+  if (opts.backdrop && opts.backdrop.trim()) cues.backdrop = opts.backdrop.trim();
+  return cues;
+}
+function buildStoryboardBeatSection(opts) {
+  const title = normalizeTitle(opts.title ?? humanizeBeatId(opts.beatId));
+  const cueBlock = Object.keys(opts.cues).length > 0 ? "```yaml\n" + (0, import_yaml4.stringify)(opts.cues, { lineWidth: 0 }).trimEnd() + "\n```\n\n" : "";
+  const body = opts.body?.trim() || "Scene created with `vibe scene add`. Edit this body if the build flow should recompose it.";
+  return `## Beat ${opts.beatId} - ${title}
+
+${cueBlock}${body.trimEnd()}
+`;
+}
+function normalizeTitle(value) {
+  return value.replace(/\s+/g, " ").trim() || "Scene";
+}
+function humanizeBeatId(id) {
+  return id.split(/[-_]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ") || "Scene";
+}
+function isStarterStoryboard(markdown) {
+  const parsed = parseStoryboard(markdown);
+  if (parsed.beats.length !== 3) return false;
+  const ids = parsed.beats.map((beat) => beat.id);
+  if (ids.join(",") !== "hook,proof,close") return false;
+  return markdown.includes("Introduce the promise in one crisp sentence.") && markdown.includes("Show the mechanism or proof point that makes the promise believable.") && markdown.includes("Close with the action the viewer should remember.");
+}
+function normalizeCueValue(key2, value) {
+  if (key2 === "duration") {
+    const n2 = typeof value === "number" ? value : Number.parseFloat(String(value ?? ""));
+    if (!Number.isFinite(n2) || n2 <= 0) {
+      throw new Error("Cue duration must be a positive number.");
+    }
+    return n2;
+  }
+  if (typeof value !== "string") return value;
+  return value.trim();
+}
+function splitBeatSections(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n");
+  const headings = [];
+  HEADING_RE2.lastIndex = 0;
+  let match2;
+  while ((match2 = HEADING_RE2.exec(normalized)) !== null) {
+    headings.push({ start: match2.index, end: match2.index + match2[0].length, line: match2[1].trim() });
+  }
+  return headings.map((heading, index) => {
+    const end = index + 1 < headings.length ? headings[index + 1].start : normalized.length;
+    return {
+      id: deriveBeatId(heading.line),
+      heading: heading.line,
+      start: heading.start,
+      headingEnd: heading.end,
+      end,
+      raw: normalized.slice(heading.start, end),
+      body: normalized.slice(heading.end, end).trim()
+    };
+  });
+}
+function findBeatSection(markdown, beatId) {
+  return splitBeatSections(markdown).find((section) => section.id === beatId) ?? null;
+}
+function readLeadingCueBlock(body) {
+  const match2 = body.match(LEADING_CUE_RE);
+  if (!match2) return null;
+  try {
+    const parsed = (0, import_yaml4.parse)(match2[2]);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { full: match2[0], error: "cue block must parse to a YAML object" };
+    }
+    return { full: match2[0], value: parsed };
+  } catch (error) {
+    return { full: match2[0], error: error instanceof Error ? error.message : String(error) };
+  }
+}
+var import_yaml4, HEADING_RE2, LEADING_CUE_RE, ALLOWED_CUE_KEYS, STRING_CUE_KEYS, MAX_RECOMMENDED_BEAT_SEC;
+var init_storyboard_edit = __esm({
+  "../cli/src/commands/_shared/storyboard-edit.ts"() {
+    "use strict";
+    import_yaml4 = __toESM(require_dist3(), 1);
+    init_storyboard_parse();
+    init_storyboard_parse();
+    HEADING_RE2 = /^##\s+(.+?)\s*$/gm;
+    LEADING_CUE_RE = /^(\s*)```ya?ml\s*\n([\s\S]*?)\n```\s*(?:\n|$)/;
+    ALLOWED_CUE_KEYS = new Set(STORYBOARD_CUE_KEYS);
+    STRING_CUE_KEYS = /* @__PURE__ */ new Set(["narration", "backdrop", "video", "keyframe", "motion", "voice", "music", "asset", "eyebrow", "title", "caption", "kicker", "sub"]);
+    MAX_RECOMMENDED_BEAT_SEC = 15;
+  }
+});
+
+// ../cli/src/commands/_shared/storyboard-source.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir3, readdir, readFile as readFile4, rename, rm, writeFile as writeFile6 } from "node:fs/promises";
+import { basename, join as join3 } from "node:path";
+function sceneFileFrom(dir, filename) {
+  const stem = filename.replace(/\.mdx?$/i, "");
+  const match2 = stem.match(ORDER_PREFIX_RE);
+  const order = match2 ? Number.parseInt(match2[1], 10) : null;
+  const idSource = match2 ? match2[2] : stem;
+  return { id: deriveBeatId(idSource), path: join3(dir, filename), filename, order };
+}
+async function listSceneFiles(projectDir) {
+  const dir = join3(projectDir, SCENES_DIRNAME);
+  if (!existsSync2(dir)) return [];
+  const entries2 = await readdir(dir, { withFileTypes: true });
+  const files = entries2.filter((e2) => e2.isFile() && /\.mdx?$/i.test(e2.name) && !e2.name.startsWith("_")).map((e2) => sceneFileFrom(dir, e2.name));
+  return files.sort((a4, b4) => {
+    if (a4.order !== null && b4.order !== null) return a4.order - b4.order;
+    if (a4.order !== null) return -1;
+    if (b4.order !== null) return 1;
+    return a4.filename.localeCompare(b4.filename);
+  });
+}
+function detectStoryboardLayout(projectDir, sceneCount) {
+  if (sceneCount > 0) return "bundle";
+  if (existsSync2(join3(projectDir, STORYBOARD_FILENAME))) return "single";
+  return "missing";
+}
+function humanise(id) {
+  return id.split(/[-_]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ") || "Scene";
+}
+function sceneToBeatSection(scene, contents) {
+  const { data: data2, body } = extractFrontmatter(contents);
+  const cues = { ...data2 ?? {} };
+  delete cues.type;
+  const cueBlock = Object.keys(cues).length > 0 ? "```yaml\n" + (0, import_yaml5.stringify)(cues, { lineWidth: 0 }).trimEnd() + "\n```\n\n" : "";
+  const prose = body.trim();
+  return `## Beat ${scene.id} - ${humanise(scene.id)}
+
+${cueBlock}${prose}
+`;
+}
+async function loadStoryboard(projectDir) {
+  const storyboardPath = join3(projectDir, STORYBOARD_FILENAME);
+  const scenes = await listSceneFiles(projectDir);
+  const layout = detectStoryboardLayout(projectDir, scenes.length);
+  if (layout === "missing") {
+    return { layout, markdown: "", scenes: [], storyboardPath, strayBeatIds: [] };
+  }
+  const head = existsSync2(storyboardPath) ? await readFile4(storyboardPath, "utf-8") : "";
+  if (layout === "single") {
+    return { layout, markdown: head, scenes: [], storyboardPath, strayBeatIds: [] };
+  }
+  const headingAt = head.search(FIRST_HEADING_RE);
+  const strayBeatIds = headingAt === -1 ? [] : parseStoryboard(head.slice(headingAt)).beats.map((b4) => b4.id);
+  const preamble = headingAt === -1 ? head : head.slice(0, headingAt);
+  const sections = await Promise.all(
+    scenes.map(async (scene) => sceneToBeatSection(scene, await readFile4(scene.path, "utf-8")))
+  );
+  const prefix = preamble.trimEnd();
+  return {
+    layout,
+    markdown: `${prefix}${prefix ? "\n\n" : ""}${sections.join("\n")}`,
+    scenes,
+    storyboardPath,
+    strayBeatIds
+  };
+}
+async function loadStoryboardMarkdown(projectDir) {
+  return (await loadStoryboard(projectDir)).markdown;
+}
+function sceneFilename(order, id) {
+  const width = order >= 100 ? 3 : 2;
+  return `${String(order).padStart(width, "0")}-${basename(id)}.md`;
+}
+function beatToSceneFile(beat, order) {
+  const cues = { type: "Scene", ...beat.cues ?? {} };
+  if (cues.duration === void 0 && beat.duration !== void 0) {
+    cues.duration = beat.duration;
+  }
+  const front = (0, import_yaml5.stringify)(cues, { lineWidth: 0 }).trimEnd();
+  const body = beat.body.trim();
+  return {
+    path: `${SCENES_DIRNAME}/${sceneFilename(order, beat.id)}`,
+    contents: `---
+${front}
+---
+
+${body}
+`
+  };
+}
+function planMigration(markdown) {
+  const parsed = parseStoryboard(markdown);
+  const data2 = extractFrontmatter(markdown).data ?? {};
+  const scenes = parsed.beats.map((beat, index) => beatToSceneFile(beat, index + 1));
+  const frontBlock = Object.keys(data2).length > 0 ? `---
+${(0, import_yaml5.stringify)(data2, { lineWidth: 0 }).trimEnd()}
+---
+
+` : "";
+  const prose = parsed.global.trim();
+  const note = "Scenes live in `scenes/`, one file per scene, and play in filename order.";
+  const storyboardBody = [prose, note].filter(Boolean).join("\n\n");
+  return {
+    scenes,
+    storyboard: {
+      path: STORYBOARD_FILENAME,
+      contents: `${frontBlock}${storyboardBody}
+`
+    },
+    beatIds: parsed.beats.map((beat) => beat.id)
+  };
+}
+async function writeMigration(projectDir, plan2) {
+  await mkdir3(join3(projectDir, SCENES_DIRNAME), { recursive: true });
+  for (const file of plan2.scenes) {
+    await writeFile6(join3(projectDir, file.path), file.contents, "utf-8");
+  }
+  await writeFile6(join3(projectDir, plan2.storyboard.path), plan2.storyboard.contents, "utf-8");
+}
+async function writeStoryboardAsBundle(projectDir, markdown) {
+  const plan2 = planMigration(markdown);
+  await writeMigration(projectDir, plan2);
+  return plan2;
+}
+function strayBeatIssues(strayBeatIds) {
+  return strayBeatIds.map((beatId) => ({
+    severity: "error",
+    code: "STRAY_BEATS_IN_STORYBOARD",
+    beatId,
+    message: `STORYBOARD.md still contains a "## Beat ${beatId}" section, but this project uses scenes/. That heading is ignored. Move it to scenes/ as its own file, or delete it from STORYBOARD.md.`
+  }));
+}
+async function upsertScene(projectDir, opts) {
+  const beatId = deriveBeatId(opts.beatId);
+  const dir = join3(projectDir, SCENES_DIRNAME);
+  await mkdir3(dir, { recursive: true });
+  const cues = {};
+  if (opts.duration !== void 0) cues.duration = opts.duration;
+  if (opts.narration?.trim()) cues.narration = opts.narration.trim();
+  if (opts.backdrop?.trim()) cues.backdrop = opts.backdrop.trim();
+  if (opts.title?.trim()) cues.title = opts.title.trim();
+  const scenes = await listSceneFiles(projectDir);
+  const existing = scenes.find((s2) => s2.id === beatId);
+  if (existing) {
+    const raw2 = await readFile4(existing.path, "utf-8");
+    const { data: data2, body: body2 } = extractFrontmatter(raw2);
+    const merged = { type: "Scene", ...data2 ?? {}, ...cues };
+    const nextBody = opts.body?.trim() || body2.trim();
+    await writeFile6(
+      existing.path,
+      `---
+${(0, import_yaml5.stringify)(merged, { lineWidth: 0 }).trimEnd()}
+---
+
+${nextBody}
+`,
+      "utf-8"
+    );
+    return { action: "updated", path: existing.path };
+  }
+  const starter = scenes.length > 0 && isStarterStoryboard((await loadStoryboard(projectDir)).markdown);
+  if (starter) {
+    for (const scene of scenes) await rm(scene.path);
+  }
+  const order = starter ? 1 : scenes.length + 1;
+  const path16 = join3(dir, sceneFilename(order, beatId));
+  const front = { type: "Scene", ...cues };
+  const body = opts.body?.trim() || "Scene created with `vibe scene add`. Edit this body if the build flow should recompose it.";
+  await writeFile6(
+    path16,
+    `---
+${(0, import_yaml5.stringify)(front, { lineWidth: 0 }).trimEnd()}
+---
+
+${body}
+`,
+    "utf-8"
+  );
+  return { action: starter ? "replaced-starter" : "appended", path: path16 };
+}
+async function rewriteBundleFromMarkdown(projectDir, markdown) {
+  const plan2 = planMigration(markdown);
+  const keep = new Set(plan2.scenes.map((file) => basename(file.path)));
+  for (const scene of await listSceneFiles(projectDir)) {
+    if (!keep.has(scene.filename)) await rm(scene.path);
+  }
+  await writeMigration(projectDir, plan2);
+  return plan2;
+}
+var import_yaml5, SCENES_DIRNAME, STORYBOARD_FILENAME, ORDER_PREFIX_RE, FIRST_HEADING_RE;
+var init_storyboard_source = __esm({
+  "../cli/src/commands/_shared/storyboard-source.ts"() {
+    "use strict";
+    import_yaml5 = __toESM(require_dist3(), 1);
+    init_frontmatter();
+    init_storyboard_parse();
+    init_storyboard_edit();
+    SCENES_DIRNAME = "scenes";
+    STORYBOARD_FILENAME = "STORYBOARD.md";
+    ORDER_PREFIX_RE = /^(\d+)[-_.]\s*(.+)$/;
+    FIRST_HEADING_RE = /^## .*/m;
+  }
+});
+
 // ../cli/src/commands/_shared/status-jobs.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync2, statSync } from "node:fs";
-import { copyFile, mkdir as mkdir3, readFile as readFile4, readdir, rename, stat, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname3, join as join3, parse as parse2, relative, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync3, statSync } from "node:fs";
+import { copyFile, mkdir as mkdir4, readFile as readFile5, readdir as readdir2, rename as rename2, stat, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname3, join as join4, parse as parse2, relative, resolve as resolve5 } from "node:path";
 function isLocalJob(record) {
   return record.jobType === "build" || record.jobType === "render";
 }
 function findProjectRoot(start = process.cwd()) {
   let dir = resolve5(start);
   try {
-    if (existsSync2(dir) && statSync(dir).isFile()) dir = dirname3(dir);
+    if (existsSync3(dir) && statSync(dir).isFile()) dir = dirname3(dir);
   } catch {
   }
   for (; ; ) {
-    if (existsSync2(join3(dir, "vibe.config.json")) || existsSync2(join3(dir, "STORYBOARD.md"))) {
+    if (existsSync3(join4(dir, "vibe.config.json")) || existsSync3(join4(dir, "STORYBOARD.md"))) {
       return dir;
     }
     const parent = dirname3(dir);
@@ -21983,7 +22487,7 @@ function findProjectRoot(start = process.cwd()) {
   }
 }
 function jobsDir(projectDir) {
-  return join3(resolve5(projectDir), ".vibeframe", "jobs");
+  return join4(resolve5(projectDir), ".vibeframe", "jobs");
 }
 function normalizeJobStatus(status) {
   const value = String(status ?? "").toLowerCase();
@@ -22044,28 +22548,28 @@ async function createAndWriteJobRecord(opts) {
 }
 async function writeJobRecord(record) {
   const dir = jobsDir(record.projectDir);
-  await mkdir3(dir, { recursive: true });
+  await mkdir4(dir, { recursive: true });
   const path16 = jobRecordPath(record.id, record.projectDir);
   const tmp = `${path16}.${randomUUID2()}.tmp`;
-  await writeFile6(tmp, JSON.stringify(stripUndefined2(record), null, 2) + "\n", "utf-8");
-  await rename(tmp, path16);
+  await writeFile7(tmp, JSON.stringify(stripUndefined2(record), null, 2) + "\n", "utf-8");
+  await rename2(tmp, path16);
 }
 async function readJobRecord(jobId, projectDir) {
   const id = normalizeJobId(jobId);
   const project = resolve5(projectDir ?? findProjectRoot());
   const path16 = jobRecordPath(id, project);
-  if (!existsSync2(path16)) return null;
-  return parseJobRecord(await readFile4(path16, "utf-8"));
+  if (!existsSync3(path16)) return null;
+  return parseJobRecord(await readFile5(path16, "utf-8"));
 }
 async function listJobRecords(projectDir) {
   const dir = jobsDir(projectDir);
-  if (!existsSync2(dir)) return [];
-  const entries2 = await readdir(dir, { withFileTypes: true });
+  if (!existsSync3(dir)) return [];
+  const entries2 = await readdir2(dir, { withFileTypes: true });
   const records = [];
   for (const entry of entries2) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
     try {
-      const parsed = parseJobRecord(await readFile4(join3(dir, entry.name), "utf-8"));
+      const parsed = parseJobRecord(await readFile5(join4(dir, entry.name), "utf-8"));
       if (parsed) records.push(parsed);
     } catch {
     }
@@ -22092,7 +22596,7 @@ async function refreshJobRecord(record, opts = {}) {
   try {
     if (record.jobType === "generate-video") {
       const output3 = resolveRefreshOutput(record, opts);
-      if (output3) await mkdir3(dirname3(output3), { recursive: true });
+      if (output3) await mkdir4(dirname3(output3), { recursive: true });
       const result = await executeVideoStatus({
         taskId: record.providerTaskId,
         provider: record.provider,
@@ -22159,7 +22663,7 @@ async function refreshLocalJobRecord(record, opts) {
     const heartbeatAge = record.heartbeatAt ? Date.now() - new Date(record.heartbeatAt).getTime() : Number.POSITIVE_INFINITY;
     const orphaned = !isPidAlive(record.pid) || heartbeatAge > LOCAL_JOB_ORPHAN_AFTER_MS;
     if (orphaned) {
-      const hint = `The process that ran this ${record.jobType} job is gone. Check ${join3(record.projectDir, record.jobType === "render" ? "render-report.json" : "build-report.json")} \u2014 the work may have completed before the process exited.`;
+      const hint = `The process that ran this ${record.jobType} job is gone. Check ${join4(record.projectDir, record.jobType === "render" ? "render-report.json" : "build-report.json")} \u2014 the work may have completed before the process exited.`;
       warnings.push(hint);
       updated = stripUndefined2({
         ...record,
@@ -22322,7 +22826,7 @@ function normalizeJobId(jobId) {
   return id;
 }
 function jobRecordPath(jobId, projectDir) {
-  return join3(jobsDir(projectDir), `${normalizeJobId(jobId)}.json`);
+  return join4(jobsDir(projectDir), `${normalizeJobId(jobId)}.json`);
 }
 function parseJobRecord(raw2) {
   const parsed = JSON.parse(raw2);
@@ -22375,21 +22879,21 @@ async function downloadUrl(url, outputPath) {
   const response = await fetch(url);
   if (!response.ok) throw new Error(`Download failed: HTTP ${response.status}`);
   const buffer = Buffer.from(await response.arrayBuffer());
-  await mkdir3(dirname3(outputPath), { recursive: true });
-  await writeFile6(outputPath, buffer);
+  await mkdir4(dirname3(outputPath), { recursive: true });
+  await writeFile7(outputPath, buffer);
   return outputPath;
 }
 async function maybeCacheOutput(record) {
   if (record.status !== "completed" || !record.outputPath || !record.cachePath) return;
   try {
-    await mkdir3(dirname3(record.cachePath), { recursive: true });
+    await mkdir4(dirname3(record.cachePath), { recursive: true });
     await copyFile(record.outputPath, record.cachePath);
   } catch {
   }
 }
 async function maybeWriteCompletedAssetMetadata(record) {
   const kind3 = assetKindForJob(record);
-  if (record.status !== "completed" || !kind3 || !record.beatId || !record.assetCue || !record.cacheKey || !record.outputPath || !existsSync2(record.outputPath)) {
+  if (record.status !== "completed" || !kind3 || !record.beatId || !record.assetCue || !record.cacheKey || !record.outputPath || !existsSync3(record.outputPath)) {
     return;
   }
   try {
@@ -22408,7 +22912,7 @@ async function maybeWriteCompletedAssetMetadata(record) {
   }
 }
 async function refreshBuildReportFromJobs(projectDir, records) {
-  const reportPath = join3(projectDir, "build-report.json");
+  const reportPath = join4(projectDir, "build-report.json");
   const report = await readJson(reportPath);
   if (!report || !Array.isArray(report.beats)) return;
   let changed = false;
@@ -22456,12 +22960,12 @@ async function refreshBuildReportFromJobs(projectDir, records) {
   }
   if (!changed) return;
   try {
-    await writeFile6(reportPath, JSON.stringify(stripUndefined2(report), null, 2) + "\n", "utf-8");
+    await writeFile7(reportPath, JSON.stringify(stripUndefined2(report), null, 2) + "\n", "utf-8");
   } catch {
   }
 }
 async function readBuildSummary(projectDir) {
-  const reportPath = join3(projectDir, "build-report.json");
+  const reportPath = join4(projectDir, "build-report.json");
   const report = await readJson(reportPath);
   if (!report) return null;
   const info = await statOrNull(reportPath);
@@ -22484,7 +22988,7 @@ async function readBuildSummary(projectDir) {
   });
 }
 async function readReviewSummary(projectDir) {
-  const reportPath = join3(projectDir, "review-report.json");
+  const reportPath = join4(projectDir, "review-report.json");
   const report = await readJson(reportPath);
   if (!report) return null;
   const info = await statOrNull(reportPath);
@@ -22573,16 +23077,16 @@ async function readProjectBeatReadiness(projectDir, build, records) {
     if (fromBeats) return fromBeats;
     if (build.beats) return augmentBeatReadinessFromJobs(build.beats, records, report?.jobs);
   }
-  const storyboardPath = join3(projectDir, "STORYBOARD.md");
-  if (!existsSync2(storyboardPath)) {
+  const storyboardPath = join4(projectDir, "STORYBOARD.md");
+  if (!existsSync3(storyboardPath)) {
     return { total: 0, assetsReady: 0, compositionsReady: 0, needsAuthor: [] };
   }
   try {
-    const parsed = parseStoryboard(await readFile4(storyboardPath, "utf-8"));
+    const parsed = parseStoryboard(await loadStoryboardMarkdown(projectDir));
     const needsAuthor = [];
     let compositionsReady = 0;
     for (const beat of parsed.beats) {
-      if (existsSync2(join3(projectDir, "compositions", `scene-${beat.id}.html`))) {
+      if (existsSync3(join4(projectDir, "compositions", `scene-${beat.id}.html`))) {
         compositionsReady += 1;
       } else {
         needsAuthor.push(beat.id);
@@ -22600,7 +23104,7 @@ async function readProjectBeatReadiness(projectDir, build, records) {
 }
 function deriveProjectWorkflow(opts) {
   const retryWith = [];
-  const hasStoryboard = existsSync2(join3(opts.project, "STORYBOARD.md"));
+  const hasStoryboard = existsSync3(join4(opts.project, "STORYBOARD.md"));
   if (!hasStoryboard && !opts.build) {
     retryWith.push(`vibe init ${opts.project} --from "<brief>" --json`);
     return { status: "empty", currentStage: "init", retryWith };
@@ -22696,7 +23200,7 @@ function beatReadinessFromBuildBeats(projectDir, beats, records = [], reportJobs
     if (buildBeatAssetsReady(record) || (id ? buildBeatJobsReady(id, records, reportJobs) : false))
       assetsReady += 1;
     const compositionPath = typeof record.compositionPath === "string" ? record.compositionPath : id ? `compositions/scene-${id}.html` : void 0;
-    if (compositionPath && existsSync2(resolve5(projectDir, compositionPath))) {
+    if (compositionPath && existsSync3(resolve5(projectDir, compositionPath))) {
       compositionsReady += 1;
     } else if (id) {
       needsAuthor.push(id);
@@ -22804,7 +23308,7 @@ function projectRelativePath(projectDir, path16) {
 }
 async function readJson(path16) {
   try {
-    return JSON.parse(await readFile4(path16, "utf-8"));
+    return JSON.parse(await readFile5(path16, "utf-8"));
   } catch {
     return null;
   }
@@ -22836,13 +23340,14 @@ var init_status_jobs = __esm({
     init_build_asset_metadata();
     init_review_report();
     init_storyboard_parse();
+    init_storyboard_source();
     LOCAL_JOB_ORPHAN_AFTER_MS = 9e4;
   }
 });
 
 // ../cli/src/commands/_shared/project-config.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
 import { resolve as resolve6 } from "node:path";
 function defaultProjectConfig(opts) {
   return {
@@ -22899,9 +23404,9 @@ async function readProjectConfig(projectDir) {
   const dir = resolve6(projectDir);
   const canonicalPath = resolve6(dir, VIBE_CONFIG_FILENAME);
   const legacyPath = resolve6(dir, LEGACY_VIBE_PROJECT_FILENAME);
-  if (existsSync3(canonicalPath)) {
+  if (existsSync4(canonicalPath)) {
     try {
-      const raw2 = await readFile5(canonicalPath, "utf-8");
+      const raw2 = await readFile6(canonicalPath, "utf-8");
       const parsed = JSON.parse(raw2);
       const name = typeof parsed.name === "string" && parsed.name ? parsed.name : dir.split(/[\\/]/).filter(Boolean).pop() ?? "video";
       const fallback2 = defaultProjectConfig({
@@ -22919,10 +23424,10 @@ async function readProjectConfig(projectDir) {
     } catch {
     }
   }
-  if (existsSync3(legacyPath)) {
+  if (existsSync4(legacyPath)) {
     try {
-      const raw2 = await readFile5(legacyPath, "utf-8");
-      const legacy = (0, import_yaml4.parse)(raw2);
+      const raw2 = await readFile6(legacyPath, "utf-8");
+      const legacy = (0, import_yaml6.parse)(raw2);
       const name = legacy?.name ?? dir.split(/[\\/]/).filter(Boolean).pop() ?? "video";
       const config4 = defaultProjectConfig({
         name,
@@ -22954,19 +23459,19 @@ async function readProjectConfig(projectDir) {
     legacy: false
   };
 }
-var import_yaml4, VIBE_CONFIG_FILENAME, LEGACY_VIBE_PROJECT_FILENAME;
+var import_yaml6, VIBE_CONFIG_FILENAME, LEGACY_VIBE_PROJECT_FILENAME;
 var init_project_config = __esm({
   "../cli/src/commands/_shared/project-config.ts"() {
     "use strict";
-    import_yaml4 = __toESM(require_dist3(), 1);
+    import_yaml6 = __toESM(require_dist3(), 1);
     VIBE_CONFIG_FILENAME = "vibe.config.json";
     LEGACY_VIBE_PROJECT_FILENAME = "vibe.project.yaml";
   }
 });
 
 // ../cli/src/commands/_shared/scene-project.ts
-import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile7, access as access3 } from "node:fs/promises";
-import { resolve as resolve7, basename } from "node:path";
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile8, access as access3 } from "node:fs/promises";
+import { resolve as resolve7, basename as basename2 } from "node:path";
 function isSceneKind(value) {
   return VALID_SCENE_KINDS.includes(value);
 }
@@ -23313,15 +23818,25 @@ media in \`references/\`; older VibeFrame versions vendored composition rules
 there, and current installs keep the rules under \`.agents/skills/hyperframes/\`
 via \`vibe scene install-skill\`.
 
-When a beat should reuse a local file, reference it from \`STORYBOARD.md\`
-with a project-relative path:
+Scenes live in \`scenes/\`, one file per scene, and play in filename order.
+Each scene is a markdown file whose frontmatter carries its cues:
 
-\`\`\`yaml
-backdrop: "media/product-shot.png" # existing still image
-video: "media/broll.mp4"           # existing video/B-roll
-narration: "media/voice.wav"       # existing recorded narration
-asset: "media/logo.png"            # generic local asset reference
-\`\`\`
+    ---
+    type: Scene
+    duration: 5
+    narration: "One crisp sentence."
+    backdrop: "Clean editorial background plate, generous negative space"
+    ---
+
+    Direction prose for this scene goes in the body.
+
+When a scene should reuse a local file, give the cue a project-relative path
+instead of a prompt:
+
+    backdrop: "media/product-shot.png"   # existing still image
+    video: "media/broll.mp4"             # existing video/B-roll
+    narration: "media/voice.wav"         # existing recorded narration
+    asset: "media/logo.png"              # generic local asset reference
 
 Use text cues when you want VibeFrame to generate an asset. Use path cues
 when you want VibeFrame to reuse a local file. Avoid absolute paths or parent
@@ -23561,17 +24076,17 @@ async function pathExists(p2) {
 }
 async function scaffoldSceneProject(opts) {
   const dir = resolve7(opts.dir);
-  const name = opts.name ?? basename(dir);
+  const name = opts.name ?? basename2(dir);
   const aspect = opts.aspect ?? "16:9";
   const duration = opts.duration ?? 10;
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const profile = opts.profile ?? "full";
   const kind3 = opts.kind ?? DEFAULT_SCENE_KIND;
-  await mkdir4(dir, { recursive: true });
+  await mkdir5(dir, { recursive: true });
   if (profile === "full") {
-    await mkdir4(resolve7(dir, "compositions"), { recursive: true });
-    await mkdir4(resolve7(dir, "assets"), { recursive: true });
-    await mkdir4(resolve7(dir, "renders"), { recursive: true });
+    await mkdir5(resolve7(dir, "compositions"), { recursive: true });
+    await mkdir5(resolve7(dir, "assets"), { recursive: true });
+    await mkdir5(resolve7(dir, "renders"), { recursive: true });
   }
   const created = [];
   const skipped2 = [];
@@ -23580,20 +24095,20 @@ async function scaffoldSceneProject(opts) {
     const hfPath = resolve7(dir, "hyperframes.json");
     const hfDefaults = buildHyperframesConfig();
     if (await pathExists(hfPath)) {
-      const existingRaw = await readFile6(hfPath, "utf-8");
+      const existingRaw = await readFile7(hfPath, "utf-8");
       const existing = JSON.parse(existingRaw);
       const mergedConfig = mergeHyperframesConfig(existing, hfDefaults);
-      await writeFile7(hfPath, JSON.stringify(mergedConfig, null, 2) + "\n", "utf-8");
+      await writeFile8(hfPath, JSON.stringify(mergedConfig, null, 2) + "\n", "utf-8");
       merged.push(hfPath);
     } else {
-      await writeFile7(hfPath, JSON.stringify(hfDefaults, null, 2) + "\n", "utf-8");
+      await writeFile8(hfPath, JSON.stringify(hfDefaults, null, 2) + "\n", "utf-8");
       created.push(hfPath);
     }
     const metaPath = resolve7(dir, "meta.json");
     if (await pathExists(metaPath)) {
       skipped2.push(metaPath);
     } else {
-      await writeFile7(
+      await writeFile8(
         metaPath,
         JSON.stringify(buildHyperframesMeta(name, now), null, 2) + "\n",
         "utf-8"
@@ -23604,7 +24119,7 @@ async function scaffoldSceneProject(opts) {
     if (await pathExists(rootPath)) {
       skipped2.push(rootPath);
     } else {
-      await writeFile7(rootPath, buildEmptyRootHtml({ aspect, duration }), "utf-8");
+      await writeFile8(rootPath, buildEmptyRootHtml({ aspect, duration }), "utf-8");
       created.push(rootPath);
     }
   }
@@ -23612,7 +24127,7 @@ async function scaffoldSceneProject(opts) {
   if (await pathExists(vibeConfigJsonPath)) {
     skipped2.push(vibeConfigJsonPath);
   } else {
-    await writeFile7(vibeConfigJsonPath, projectConfigJson({ name, aspect, kind: kind3 }), "utf-8");
+    await writeFile8(vibeConfigJsonPath, projectConfigJson({ name, aspect, kind: kind3 }), "utf-8");
     created.push(vibeConfigJsonPath);
   }
   if (profile === "agent" || profile === "full") {
@@ -23620,22 +24135,22 @@ async function scaffoldSceneProject(opts) {
     if (await pathExists(agentsPath)) {
       skipped2.push(agentsPath);
     } else {
-      await writeFile7(agentsPath, buildProjectAgentsMd(name), "utf-8");
+      await writeFile8(agentsPath, buildProjectAgentsMd(name), "utf-8");
       created.push(agentsPath);
     }
     const claudePath = resolve7(dir, "CLAUDE.md");
     if (await pathExists(claudePath)) {
-      const existing = await readFile6(claudePath, "utf-8");
+      const existing = await readFile7(claudePath, "utf-8");
       if (existing.includes("@AGENTS.md")) {
         skipped2.push(claudePath);
       } else {
-        await writeFile7(claudePath, `@AGENTS.md
+        await writeFile8(claudePath, `@AGENTS.md
 
 ${existing}`, "utf-8");
         merged.push(claudePath);
       }
     } else {
-      await writeFile7(claudePath, buildProjectClaudeMd(name), "utf-8");
+      await writeFile8(claudePath, buildProjectClaudeMd(name), "utf-8");
       created.push(claudePath);
     }
   }
@@ -23643,21 +24158,22 @@ ${existing}`, "utf-8");
   if (await pathExists(designPath)) {
     skipped2.push(designPath);
   } else {
-    await writeFile7(designPath, buildDesignMd({ name, style: opts.visualStyle }), "utf-8");
+    await writeFile8(designPath, buildDesignMd({ name, style: opts.visualStyle }), "utf-8");
     created.push(designPath);
   }
   const storyboardPath = resolve7(dir, "STORYBOARD.md");
   if (await pathExists(storyboardPath)) {
     skipped2.push(storyboardPath);
   } else {
-    await writeFile7(storyboardPath, buildStoryboardMd(name, duration), "utf-8");
+    const plan2 = await writeStoryboardAsBundle(dir, buildStoryboardMd(name, duration));
     created.push(storyboardPath);
+    for (const file of plan2.scenes) created.push(resolve7(dir, file.path));
   }
   const scriptPath = resolve7(dir, "SCRIPT.md");
   if (await pathExists(scriptPath)) {
     skipped2.push(scriptPath);
   } else {
-    await writeFile7(scriptPath, buildScriptMd(name, kind3), "utf-8");
+    await writeFile8(scriptPath, buildScriptMd(name, kind3), "utf-8");
     created.push(scriptPath);
   }
   if (kindHasCast(kind3)) {
@@ -23665,7 +24181,7 @@ ${existing}`, "utf-8");
     if (await pathExists(charactersPath)) {
       skipped2.push(charactersPath);
     } else {
-      await writeFile7(charactersPath, buildCharactersMd(name), "utf-8");
+      await writeFile8(charactersPath, buildCharactersMd(name), "utf-8");
       created.push(charactersPath);
     }
   }
@@ -23673,7 +24189,7 @@ ${existing}`, "utf-8");
   if (await pathExists(gitignorePath)) {
     skipped2.push(gitignorePath);
   } else {
-    await writeFile7(gitignorePath, buildSceneGitignore(), "utf-8");
+    await writeFile8(gitignorePath, buildSceneGitignore(), "utf-8");
     created.push(gitignorePath);
   }
   return { created, skipped: skipped2, merged, groups: describeSceneScaffold({ dir, profile }) };
@@ -23682,6 +24198,7 @@ var VALID_SCENE_KINDS, DEFAULT_SCENE_KIND, ASPECT_DIMS;
 var init_scene_project = __esm({
   "../cli/src/commands/_shared/scene-project.ts"() {
     "use strict";
+    init_storyboard_source();
     init_project_config();
     VALID_SCENE_KINDS = [
       "cinema",
@@ -35218,7 +35735,7 @@ var require_source_map = __commonJS({
 var require_previous_map = __commonJS({
   "../../node_modules/.pnpm/postcss@8.5.6/node_modules/postcss/lib/previous-map.js"(exports, module) {
     "use strict";
-    var { existsSync: existsSync85, readFileSync: readFileSync23 } = __require("fs");
+    var { existsSync: existsSync86, readFileSync: readFileSync23 } = __require("fs");
     var { dirname: dirname40, join: join78 } = __require("path");
     var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     function fromBase64(str2) {
@@ -35281,7 +35798,7 @@ var require_previous_map = __commonJS({
       }
       loadFile(path16) {
         this.root = dirname40(path16);
-        if (existsSync85(path16)) {
+        if (existsSync86(path16)) {
           this.mapFile = path16;
           return readFileSync23(path16, "utf-8").toString().trim();
         }
@@ -87270,7 +87787,7 @@ var require_yauzl = __commonJS({
 // ../../node_modules/.pnpm/@puppeteer+browsers@3.0.6_yauzl@2.10.0/node_modules/@puppeteer/browsers/lib/fileUtil.js
 import { spawnSync, spawn, execFile as execFile2 } from "node:child_process";
 import { constants as constants2, createReadStream, createWriteStream as createWriteStream2 } from "node:fs";
-import { mkdir as mkdir6, readdir as readdir3, symlink as symlink2 } from "node:fs/promises";
+import { mkdir as mkdir7, readdir as readdir4, symlink as symlink2 } from "node:fs/promises";
 import * as path9 from "node:path";
 import { Stream, Writable as Writable2 } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -87280,12 +87797,12 @@ async function unpackArchive(archivePath, folderPath) {
     folderPath = path9.resolve(process.cwd(), folderPath);
   }
   if (archivePath.endsWith(".zip")) {
-    await mkdir6(folderPath, { recursive: true });
+    await mkdir7(folderPath, { recursive: true });
     await extractZip(archivePath, folderPath);
   } else if (archivePath.endsWith(".tar.bz2")) {
     await extractTar(archivePath, folderPath, "bzip2");
   } else if (archivePath.endsWith(".dmg")) {
-    await mkdir6(folderPath);
+    await mkdir7(folderPath);
     await installDMG(archivePath, folderPath);
   } else if (archivePath.endsWith(".exe")) {
     const result = spawnSync(archivePath, [`/ExtractDir=${folderPath}`], {
@@ -87374,7 +87891,7 @@ async function installDMG(dmgPath, folderPath) {
   }
   const mountPath = volumes[0];
   try {
-    const fileNames = await readdir3(mountPath);
+    const fileNames = await readdir4(mountPath);
     const appName = fileNames.find((item) => {
       return typeof item === "string" && item.endsWith(".app");
     });
@@ -87473,10 +87990,10 @@ async function extractZipEntry(zipFile, entry, folderPath) {
   const mode = unixMode === 0 ? isDirectory2 ? 493 : 420 : unixMode & 511;
   const destination = path9.join(folderPath, entry.fileName);
   if (isDirectory2) {
-    await mkdir6(destination, { recursive: true, mode });
+    await mkdir7(destination, { recursive: true, mode });
     return;
   }
-  await mkdir6(path9.dirname(destination), { recursive: true });
+  await mkdir7(path9.dirname(destination), { recursive: true });
   const readStream = await promisify2(zipFile.openReadStream.bind(zipFile))(entry);
   if (isSymlink) {
     const chunks = [];
@@ -87643,8 +88160,8 @@ var init_ProgressBar = __esm({
 // ../../node_modules/.pnpm/@puppeteer+browsers@3.0.6_yauzl@2.10.0/node_modules/@puppeteer/browsers/lib/install.js
 import assert3 from "node:assert";
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync2 } from "node:fs";
-import { mkdir as mkdir7, unlink } from "node:fs/promises";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
+import { mkdir as mkdir8, unlink } from "node:fs/promises";
 import os6 from "node:os";
 import path10 from "node:path";
 function debugTime(label) {
@@ -87696,8 +88213,8 @@ async function installWithProviders(options) {
         continue;
       }
       debugInstall?.(`Successfully got URL from ${provider.getName()}: ${url}`);
-      if (!existsSync4(browserRoot)) {
-        await mkdir7(browserRoot, { recursive: true });
+      if (!existsSync5(browserRoot)) {
+        await mkdir8(browserRoot, { recursive: true });
       }
       return await installUrl(url, options, provider);
     } catch (err) {
@@ -87728,7 +88245,7 @@ async function installDeps(installedBrowser) {
     return;
   }
   const depsPath = path10.join(path10.dirname(installedBrowser.executablePath), "deb.deps");
-  if (!existsSync4(depsPath)) {
+  if (!existsSync5(depsPath)) {
     debugInstall?.(`deb.deps file was not found at ${depsPath}`);
     return;
   }
@@ -87769,14 +88286,14 @@ async function installUrl(url, options, provider) {
   const cache = new Cache(options.cacheDir);
   const browserRoot = cache.browserRoot(options.browser);
   const archivePath = path10.join(browserRoot, `${options.buildId}-${fileName}`);
-  if (!existsSync4(browserRoot)) {
-    await mkdir7(browserRoot, { recursive: true });
+  if (!existsSync5(browserRoot)) {
+    await mkdir8(browserRoot, { recursive: true });
   }
   if (options.expectedHash) {
     debugInstall?.(`Using provided checksum for ${fileName}: ${options.expectedHash}`);
   }
   if (!options.unpack) {
-    if (existsSync4(archivePath)) {
+    if (existsSync5(archivePath)) {
       return archivePath;
     }
     debugInstall?.(`Downloading binary from ${url}`);
@@ -87797,8 +88314,8 @@ async function installUrl(url, options, provider) {
     cache.writeExecutablePath(options.browser, options.platform, options.buildId, relativeExecutablePath7);
   }
   try {
-    if (existsSync4(outputPath)) {
-      if (!existsSync4(installedBrowser.executablePath)) {
+    if (existsSync5(outputPath)) {
+      if (!existsSync5(installedBrowser.executablePath)) {
         throw new Error(`The browser folder (${outputPath}) exists but the executable (${installedBrowser.executablePath}) is missing`);
       }
       await runSetup(installedBrowser);
@@ -87807,7 +88324,7 @@ async function installUrl(url, options, provider) {
       }
       return installedBrowser;
     }
-    if (!existsSync4(archivePath)) {
+    if (!existsSync5(archivePath)) {
       debugInstall?.(`Downloading binary from ${url}`);
       try {
         debugTime("download");
@@ -87836,7 +88353,7 @@ async function installUrl(url, options, provider) {
     }
     return installedBrowser;
   } finally {
-    if (existsSync4(archivePath)) {
+    if (existsSync5(archivePath)) {
       await unlink(archivePath);
     }
   }
@@ -87847,7 +88364,7 @@ async function runSetup(installedBrowser) {
       debugTime("permissions");
       const browserDir = path10.dirname(installedBrowser.executablePath);
       const setupExePath = path10.join(browserDir, "setup.exe");
-      if (!existsSync4(setupExePath)) {
+      if (!existsSync5(setupExePath)) {
         return;
       }
       spawnSync2(path10.join(browserDir, "setup.exe"), [`--configure-browser-in-directory=` + browserDir], {
@@ -89611,7 +90128,7 @@ var init_process_argv = __esm({
 });
 
 // ../../node_modules/.pnpm/y18n@5.0.8/node_modules/y18n/build/lib/platform-shims/node.js
-import { readFileSync as readFileSync4, statSync as statSync3, writeFile as writeFile8 } from "fs";
+import { readFileSync as readFileSync4, statSync as statSync3, writeFile as writeFile9 } from "fs";
 import { format as format2 } from "util";
 import { resolve as resolve12 } from "path";
 var node_default;
@@ -89620,7 +90137,7 @@ var init_node = __esm({
     node_default = {
       fs: {
         readFileSync: readFileSync4,
-        writeFile: writeFile8
+        writeFile: writeFile9
       },
       format: format2,
       resolve: resolve12,
@@ -89841,7 +90358,7 @@ var require_get_caller_file = __commonJS({
 import { notStrictEqual, strictEqual } from "assert";
 import { inspect } from "util";
 import { fileURLToPath } from "url";
-import { basename as basename3, dirname as dirname7, extname as extname2, relative as relative3, resolve as resolve13, join as join6 } from "path";
+import { basename as basename4, dirname as dirname7, extname as extname2, relative as relative3, resolve as resolve13, join as join7 } from "path";
 import { createRequire as createRequire2 } from "node:module";
 import { readFileSync as readFileSync5, readdirSync as readdirSync2 } from "node:fs";
 var import_get_caller_file, __dirname2, mainFilename, require3, esm_default;
@@ -89873,12 +90390,12 @@ var init_esm2 = __esm({
       mainFilename: mainFilename || process.cwd(),
       Parser: lib_default,
       path: {
-        basename: basename3,
+        basename: basename4,
         dirname: dirname7,
         extname: extname2,
         relative: relative3,
         resolve: resolve13,
-        join: join6
+        join: join7
       },
       process: {
         argv: () => process.argv,
@@ -94128,9 +94645,9 @@ var init_PipeTransport = __esm({
 });
 
 // ../../node_modules/.pnpm/puppeteer-core@25.3.0_yauzl@2.10.0/node_modules/puppeteer-core/lib/puppeteer/node/BrowserLauncher.js
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function getBrowserTypeDisplayName(browserType) {
   switch (browserType) {
     case Browser3.FIREFOX:
@@ -94187,7 +94704,7 @@ var init_BrowserLauncher = __esm({
           ...options,
           protocol
         });
-        if (!existsSync5(launchArgs.executablePath)) {
+        if (!existsSync6(launchArgs.executablePath)) {
           throw new Error(`Browser was not found at the configured executablePath (${launchArgs.executablePath})`);
         }
         const usePipe = launchArgs.args.includes("--remote-debugging-pipe");
@@ -94264,7 +94781,7 @@ var init_BrowserLauncher = __esm({
           const logs = browserProcess.getRecentLogs().join("\n");
           if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || // On Windows we will not get logs due to the singleton process handover. See
           // https://source.chromium.org/chromium/chromium/src/+/main:chrome/browser/process_singleton_win.cc;l=46;drc=fc7952f0422b5073515a205a04ec9c3a1ae81658
-          process.platform === "win32" && existsSync5(join7(launchArgs.userDataDir, "lockfile"))) {
+          process.platform === "win32" && existsSync6(join8(launchArgs.userDataDir, "lockfile"))) {
             throw new Error(`The browser is already running for ${launchArgs.userDataDir}. Use a different \`userDataDir\` or stop the running browser first.`);
           }
           if (logs.includes("Missing X server") && options.headless === false) {
@@ -94395,7 +94912,7 @@ var init_BrowserLauncher = __esm({
        */
       async getProfilePath() {
         const config4 = await this.puppeteer.configuration();
-        return join7(config4.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
+        return join8(config4.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
       }
       /**
        * @internal
@@ -94404,7 +94921,7 @@ var init_BrowserLauncher = __esm({
         const config4 = await this.puppeteer.configuration();
         let executablePath4 = config4.executablePath;
         if (executablePath4) {
-          if (validatePath && !existsSync5(executablePath4)) {
+          if (validatePath && !existsSync6(executablePath4)) {
             throw new Error(`Tried to find the browser at the configured path (${executablePath4}), but no executable was found.`);
           }
           return executablePath4;
@@ -94429,7 +94946,7 @@ var init_BrowserLauncher = __esm({
           browser: browserType,
           buildId: browserVersion
         });
-        if (validatePath && !existsSync5(executablePath4)) {
+        if (validatePath && !existsSync6(executablePath4)) {
           const configVersion = config4?.[this.browser]?.version;
           if (configVersion) {
             throw new Error(`Tried to find the browser at the configured path (${executablePath4}) for version ${configVersion}, but no executable was found.`);
@@ -94447,7 +94964,7 @@ For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides
 
 // ../../node_modules/.pnpm/puppeteer-core@25.3.0_yauzl@2.10.0/node_modules/puppeteer-core/lib/puppeteer/node/util/fs.js
 import fs6 from "node:fs";
-async function rm3(path16) {
+async function rm4(path16) {
   await fs6.promises.rm(path16, rmOptions);
 }
 var rmOptions;
@@ -94577,7 +95094,7 @@ var init_ChromeLauncher = __esm({
       async cleanUserDataDir(path16, opts) {
         if (opts.isTemp) {
           try {
-            await rm3(path16);
+            await rm4(path16);
           } catch (error) {
             debugError?.(error);
             throw error;
@@ -94693,7 +95210,7 @@ var init_ChromeLauncher = __esm({
 
 // ../../node_modules/.pnpm/puppeteer-core@25.3.0_yauzl@2.10.0/node_modules/puppeteer-core/lib/puppeteer/node/FirefoxLauncher.js
 import fs7 from "node:fs";
-import { rename as rename2, unlink as unlink2, mkdtemp as mkdtemp2 } from "node:fs/promises";
+import { rename as rename3, unlink as unlink2, mkdtemp as mkdtemp2 } from "node:fs/promises";
 import os9 from "node:os";
 import path13 from "node:path";
 var FirefoxLauncher;
@@ -94781,7 +95298,7 @@ var init_FirefoxLauncher = __esm({
       async cleanUserDataDir(userDataDir, opts) {
         if (opts.isTemp) {
           try {
-            await rm3(userDataDir);
+            await rm4(userDataDir);
           } catch (error) {
             debugError?.(error);
             throw error;
@@ -94795,7 +95312,7 @@ var init_FirefoxLauncher = __esm({
               if (fs7.existsSync(prefsBackupPath)) {
                 const prefsPath = path13.join(userDataDir, file);
                 await unlink2(prefsPath);
-                await rename2(prefsBackupPath, prefsPath);
+                await rename3(prefsBackupPath, prefsPath);
               }
             }));
             for (const result of results) {
@@ -95800,7 +96317,7 @@ var require_src2 = __commonJS({
 
 // ../../node_modules/.pnpm/puppeteer@25.3.0_yauzl@2.10.0/node_modules/puppeteer/lib/puppeteer/getConfiguration.js
 import { homedir as homedir3 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function getBooleanEnvVar(name) {
   const env4 = process.env[name];
   if (env4 === void 0) {
@@ -95887,7 +96404,7 @@ var init_getConfiguration = __esm({
       configuration.firefox = getBrowserSetting("firefox", configuration, {
         skipDownload: true
       });
-      configuration.cacheDirectory = process.env["PUPPETEER_CACHE_DIR"] ?? configuration.cacheDirectory ?? join8(homedir3(), ".cache", "puppeteer");
+      configuration.cacheDirectory = process.env["PUPPETEER_CACHE_DIR"] ?? configuration.cacheDirectory ?? join9(homedir3(), ".cache", "puppeteer");
       configuration.temporaryDirectory = process.env["PUPPETEER_TMP_DIR"] ?? configuration.temporaryDirectory;
       configuration.experiments ??= {};
       return configuration;
@@ -96246,7 +96763,7 @@ import { pipeline as pipeline2 } from "node:stream/promises";
 import { promisify as promisify3 } from "node:util";
 import assert32 from "node:assert";
 import { spawnSync as spawnSync22 } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync22 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync22 } from "node:fs";
 import { mkdir as mkdir32, unlink as unlink3 } from "node:fs/promises";
 import os52 from "node:os";
 import path102 from "node:path";
@@ -96256,7 +96773,7 @@ import { format as format3 } from "util";
 import { normalize as normalize2, resolve as resolve52 } from "path";
 import { readFileSync as readFileSync32 } from "fs";
 import { createRequire as createRequire3 } from "node:module";
-import { readFileSync as readFileSync42, statSync as statSync22, writeFile as writeFile9 } from "fs";
+import { readFileSync as readFileSync42, statSync as statSync22, writeFile as writeFile10 } from "fs";
 import { format as format22 } from "util";
 import { resolve as resolve62 } from "path";
 import { notStrictEqual as notStrictEqual2, strictEqual as strictEqual2 } from "assert";
@@ -96279,7 +96796,7 @@ import { mkdtemp as mkdtemp3 } from "node:fs/promises";
 import os72 from "node:os";
 import path122 from "node:path";
 import fs72 from "node:fs";
-import { rename as rename3, unlink as unlink22, mkdtemp as mkdtemp22 } from "node:fs/promises";
+import { rename as rename4, unlink as unlink22, mkdtemp as mkdtemp22 } from "node:fs/promises";
 import os82 from "node:os";
 import path132 from "node:path";
 import { spawn as spawn32, spawnSync as spawnSync32 } from "node:child_process";
@@ -96302,7 +96819,7 @@ import { spawn as spawn5 } from "child_process";
 import { spawn as spawn6 } from "child_process";
 import { readFileSync as readFileSync62 } from "fs";
 import { extname as extname22 } from "path";
-import { copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync2, readdirSync as readdirSync4, statSync as statSync32, writeFileSync as writeFileSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync72, mkdirSync as mkdirSync2, readdirSync as readdirSync4, statSync as statSync32, writeFileSync as writeFileSync2 } from "fs";
 import { join as join102, dirname as dirname72, extname as extname32 } from "path";
 import { spawn as spawn7 } from "child_process";
 import { once } from "events";
@@ -96310,7 +96827,7 @@ import { existsSync as existsSync8, mkdirSync as mkdirSync3, statSync as statSyn
 import { dirname as dirname82 } from "path";
 import { createWriteStream as createWriteStream32, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
 import { createHash as createHash22 } from "crypto";
-import { join as join11, extname as extname4 } from "path";
+import { join as join112, extname as extname4 } from "path";
 import { Readable as Readable22 } from "stream";
 import { finished } from "stream/promises";
 import { createHash as createHash32, randomUUID as randomUUID3 } from "node:crypto";
@@ -96413,7 +96930,7 @@ import {
   renameSync as renameSync3,
   rmSync as rmSync5
 } from "node:fs";
-import { basename as basename5, dirname as dirname12, extname as extname7, join as join222, resolve as resolve132 } from "node:path";
+import { basename as basename52, dirname as dirname12, extname as extname7, join as join222, resolve as resolve132 } from "node:path";
 import { join as join23 } from "node:path";
 import { createHash as createHash5 } from "node:crypto";
 import { join as join29 } from "node:path";
@@ -106982,7 +107499,7 @@ async function installWithProviders2(options) {
         continue;
       }
       debugInstall2?.(`Successfully got URL from ${provider.getName()}: ${url}`);
-      if (!existsSync6(browserRoot)) {
+      if (!existsSync7(browserRoot)) {
         await mkdir32(browserRoot, { recursive: true });
       }
       return await installUrl2(url, options, provider);
@@ -107014,7 +107531,7 @@ async function installDeps2(installedBrowser) {
     return;
   }
   const depsPath = path102.join(path102.dirname(installedBrowser.executablePath), "deb.deps");
-  if (!existsSync6(depsPath)) {
+  if (!existsSync7(depsPath)) {
     debugInstall2?.(`deb.deps file was not found at ${depsPath}`);
     return;
   }
@@ -107055,14 +107572,14 @@ async function installUrl2(url, options, provider) {
   const cache = new Cache2(options.cacheDir);
   const browserRoot = cache.browserRoot(options.browser);
   const archivePath = path102.join(browserRoot, `${options.buildId}-${fileName}`);
-  if (!existsSync6(browserRoot)) {
+  if (!existsSync7(browserRoot)) {
     await mkdir32(browserRoot, { recursive: true });
   }
   if (options.expectedHash) {
     debugInstall2?.(`Using provided checksum for ${fileName}: ${options.expectedHash}`);
   }
   if (!options.unpack) {
-    if (existsSync6(archivePath)) {
+    if (existsSync7(archivePath)) {
       return archivePath;
     }
     debugInstall2?.(`Downloading binary from ${url}`);
@@ -107083,8 +107600,8 @@ async function installUrl2(url, options, provider) {
     cache.writeExecutablePath(options.browser, options.platform, options.buildId, relativeExecutablePath62);
   }
   try {
-    if (existsSync6(outputPath)) {
-      if (!existsSync6(installedBrowser.executablePath)) {
+    if (existsSync7(outputPath)) {
+      if (!existsSync7(installedBrowser.executablePath)) {
         throw new Error(`The browser folder (${outputPath}) exists but the executable (${installedBrowser.executablePath}) is missing`);
       }
       await runSetup2(installedBrowser);
@@ -107093,7 +107610,7 @@ async function installUrl2(url, options, provider) {
       }
       return installedBrowser;
     }
-    if (!existsSync6(archivePath)) {
+    if (!existsSync7(archivePath)) {
       debugInstall2?.(`Downloading binary from ${url}`);
       try {
         debugTime2("download");
@@ -107122,7 +107639,7 @@ async function installUrl2(url, options, provider) {
     }
     return installedBrowser;
   } finally {
-    if (existsSync6(archivePath)) {
+    if (existsSync7(archivePath)) {
       await unlink3(archivePath);
     }
   }
@@ -107133,7 +107650,7 @@ async function runSetup2(installedBrowser) {
       debugTime2("permissions");
       const browserDir = path102.dirname(installedBrowser.executablePath);
       const setupExePath = path102.join(browserDir, "setup.exe");
-      if (!existsSync6(setupExePath)) {
+      if (!existsSync7(setupExePath)) {
         return;
       }
       spawnSync22(path102.join(browserDir, "setup.exe"), [`--configure-browser-in-directory=` + browserDir], {
@@ -108832,7 +109349,7 @@ function getBrowserTypeDisplayName2(browserType) {
       return browserType;
   }
 }
-async function rm4(path142) {
+async function rm5(path142) {
   await fs62.promises.rm(path142, rmOptions2);
 }
 function getFeatures2(flag, options = []) {
@@ -114040,7 +114557,7 @@ function buildEncoderArgs(options, inputArgs, outputPath, gpuEncoder = null) {
 async function encodeFramesFromDir(framesDir, framePattern, outputPath, options, signal, config22) {
   const startTime = Date.now();
   const outputDir = dirname72(outputPath);
-  if (!existsSync7(outputDir)) mkdirSync2(outputDir, { recursive: true });
+  if (!existsSync72(outputDir)) mkdirSync2(outputDir, { recursive: true });
   const files = readdirSync4(framesDir).filter((f2) => f2.match(/\.(jpg|jpeg|png)$/i));
   const frameCount = files.length;
   if (frameCount === 0) {
@@ -114086,7 +114603,7 @@ async function encodeFramesFromDir(framesDir, framePattern, outputPath, options,
       )
     };
   }
-  const fileSize = existsSync7(outputPath) ? statSync32(outputPath).size : 0;
+  const fileSize = existsSync72(outputPath) ? statSync32(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -114111,7 +114628,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
   const chunkSize = Math.max(30, Math.floor(chunkSizeFrames));
   const chunkCount = Math.ceil(files.length / chunkSize);
   const chunkDir = join102(dirname72(outputPath), "chunk-encode");
-  if (!existsSync7(chunkDir)) mkdirSync2(chunkDir, { recursive: true });
+  if (!existsSync72(chunkDir)) mkdirSync2(chunkDir, { recursive: true });
   const chunkPaths = [];
   for (let i3 = 0; i3 < chunkCount; i3++) {
     if (signal?.aborted) {
@@ -114199,7 +114716,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
       error: concatResult.error
     };
   }
-  const fileSize = existsSync7(outputPath) ? statSync32(outputPath).size : 0;
+  const fileSize = existsSync72(outputPath) ? statSync32(outputPath).size : 0;
   return {
     success: true,
     outputPath,
@@ -114210,7 +114727,7 @@ async function encodeFramesChunkedConcat(framesDir, framePattern, outputPath, op
 }
 async function muxVideoWithAudio(videoPath, audioPath, outputPath, signal, config22, fps) {
   const outputDir = dirname72(outputPath);
-  if (!existsSync7(outputDir)) mkdirSync2(outputDir, { recursive: true });
+  if (!existsSync72(outputDir)) mkdirSync2(outputDir, { recursive: true });
   const isWebm = outputPath.endsWith(".webm");
   const isMov = outputPath.endsWith(".mov");
   const shouldCopyAudio = isWebm ? false : await shouldCopyAacSidecar(audioPath, config22);
@@ -114716,7 +115233,7 @@ async function downloadToTemp(url, destDir, timeoutMs = 3e5) {
     mkdirSync4(destDir, { recursive: true });
   }
   const filename = getFilenameFromUrl(url);
-  const localPath = join11(destDir, filename);
+  const localPath = join112(destDir, filename);
   if (existsSync9(localPath)) {
     downloadPathCache.set(url, localPath);
     return localPath;
@@ -123899,7 +124416,7 @@ function composeSignal(signal, deadlineAtMs) {
 function createSiblingTransactionDirectory(destination) {
   const parent = dirname12(destination);
   const extension2 = extname7(destination);
-  const stem = extension2 ? basename5(destination, extension2) : basename5(destination);
+  const stem = extension2 ? basename52(destination, extension2) : basename52(destination);
   return mkdtempSync2(join222(parent, `.${stem}.hf-transaction-`));
 }
 function assertReadableNonEmptyFile(path142) {
@@ -247165,7 +247682,7 @@ If you think this is a bug, please report it on the Puppeteer issue tracker.`;
         node_default2 = {
           fs: {
             readFileSync: readFileSync42,
-            writeFile: writeFile9
+            writeFile: writeFile10
           },
           format: format22,
           resolve: resolve62,
@@ -250761,7 +251278,7 @@ For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides
           async cleanUserDataDir(path142, opts) {
             if (opts.isTemp) {
               try {
-                await rm4(path142);
+                await rm5(path142);
               } catch (error) {
                 debugError2?.(error);
                 throw error;
@@ -250958,7 +251475,7 @@ For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides
           async cleanUserDataDir(userDataDir, opts) {
             if (opts.isTemp) {
               try {
-                await rm4(userDataDir);
+                await rm5(userDataDir);
               } catch (error) {
                 debugError2?.(error);
                 throw error;
@@ -250972,7 +251489,7 @@ For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides
                   if (fs72.existsSync(prefsBackupPath)) {
                     const prefsPath = path132.join(userDataDir, file);
                     await unlink22(prefsPath);
-                    await rename3(prefsBackupPath, prefsPath);
+                    await rename4(prefsBackupPath, prefsPath);
                   }
                 }));
                 for (const result of results) {
@@ -266625,7 +267142,7 @@ ${allInlineStyles}`.replace(/\/\*[\s\S]*?\*\//g, "");
         this.fileSystem = fileSystem;
         this.destinationPath = resolve132(destinationPath);
         this.transactionDirectory = createSiblingTransactionDirectory(this.destinationPath);
-        this.stagingPath = join222(this.transactionDirectory, basename5(this.destinationPath));
+        this.stagingPath = join222(this.transactionDirectory, basename52(this.destinationPath));
         this.backupPath = join222(this.transactionDirectory, "backup");
       }
       destinationPath;
@@ -267495,7 +268012,7 @@ Check that each file referenced by data-composition-src contains valid HTML with
 });
 
 // ../cli/src/commands/_shared/scene-lint.ts
-import { readdir as readdir5, readFile as readFile8, writeFile as writeFile10, stat as stat4 } from "node:fs/promises";
+import { readdir as readdir6, readFile as readFile9, writeFile as writeFile11, stat as stat4 } from "node:fs/promises";
 import { existsSync as existsSync38 } from "node:fs";
 import { resolve as resolve21, relative as relative5, join as join53 } from "node:path";
 async function discoverSceneFiles(opts) {
@@ -267511,7 +268028,7 @@ async function discoverSceneFiles(opts) {
   return { root: root2, subs };
 }
 async function collectHtmlRecursive(dir, into) {
-  const entries2 = await readdir5(dir, { withFileTypes: true });
+  const entries2 = await readdir6(dir, { withFileTypes: true });
   for (const entry of entries2) {
     const full = join53(dir, entry.name);
     if (entry.isDirectory()) {
@@ -267597,7 +268114,7 @@ async function runProjectLint(opts) {
   for (const sub of subs) targets.push({ abs: sub, isSub: true });
   for (const { abs, isSub } of targets) {
     const rel = relative5(projectDir, abs) || abs;
-    const html = await readFile8(abs, "utf-8");
+    const html = await readFile9(abs, "utf-8");
     const prepared = {
       html,
       entryFile: rel,
@@ -267612,7 +268129,7 @@ async function runProjectLint(opts) {
     if (opts.fix && findings.length > 0) {
       const { html: nextHtml, fixedCodes } = applyMechanicalFixes(html, findings);
       if (fixedCodes.length > 0) {
-        await writeFile10(abs, nextHtml, "utf-8");
+        await writeFile11(abs, nextHtml, "utf-8");
         fixed.push({ file: rel, codes: fixedCodes });
         const reLinted = await runHyperframeLint({ ...prepared, html: nextHtml });
         files.push({
@@ -268213,7 +268730,7 @@ var init_compose_beat_prompt = __esm({
 
 // ../cli/src/commands/_shared/root-sync.ts
 import { existsSync as existsSync40 } from "node:fs";
-import { readFile as readFile9, writeFile as writeFile11 } from "node:fs/promises";
+import { readFile as readFile10, writeFile as writeFile12 } from "node:fs/promises";
 import { join as join55, resolve as resolve24 } from "node:path";
 async function createRootSyncPlan(opts) {
   const projectDir = resolve24(opts.projectDir);
@@ -268222,7 +268739,7 @@ async function createRootSyncPlan(opts) {
   if (!existsSync40(rootPath)) {
     return { rootPath, rootRel, exists: false, changed: false, fixCodes: [], issues: [] };
   }
-  const html = await readFile9(rootPath, "utf-8");
+  const html = await readFile10(rootPath, "utf-8");
   if (opts.beats.length === 0) {
     return { rootPath, rootRel, exists: true, changed: false, fixCodes: [], issues: [] };
   }
@@ -268276,14 +268793,14 @@ async function createProjectRootSyncPlan(opts) {
 }
 async function syncRootComposition(opts) {
   const plan2 = await createRootSyncPlan(opts);
-  if (plan2.nextHtml) await writeFile11(plan2.rootPath, plan2.nextHtml, "utf-8");
+  if (plan2.nextHtml) await writeFile12(plan2.rootPath, plan2.nextHtml, "utf-8");
   return plan2;
 }
 async function loadProjectRootSyncBeats(projectDir) {
   const root2 = resolve24(projectDir);
   const storyboardPath = join55(root2, "STORYBOARD.md");
   if (!existsSync40(storyboardPath)) return [];
-  const parsed = parseStoryboard(await readFile9(storyboardPath, "utf-8"));
+  const parsed = parseStoryboard(await loadStoryboardMarkdown(root2));
   const reportBeats = await readBuildReportBeats(root2);
   return parsed.beats.map((beat) => {
     const reportBeat = reportBeats.find((item) => item.id === beat.id);
@@ -268511,7 +269028,7 @@ async function readBuildReportBeats(projectDir) {
   const reportPath = join55(projectDir, "build-report.json");
   if (!existsSync40(reportPath)) return [];
   try {
-    const report = JSON.parse(await readFile9(reportPath, "utf-8"));
+    const report = JSON.parse(await readFile10(reportPath, "utf-8"));
     return Array.isArray(report.beats) ? report.beats : [];
   } catch {
     return [];
@@ -268541,6 +269058,7 @@ var init_root_sync = __esm({
     "use strict";
     init_audio();
     init_storyboard_parse();
+    init_storyboard_source();
     ROOT_SYNC_FIX_CODES = {
       clipRefs: "root_clip_refs_synced",
       duration: "root_duration_synced",
@@ -268553,13 +269071,13 @@ var init_root_sync = __esm({
 
 // ../cli/src/commands/_shared/transcribe-narration.ts
 import { existsSync as existsSync41 } from "node:fs";
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import { join as join56 } from "node:path";
 async function transcribeNarrationWords(audioAbsPath, opts) {
   try {
     const whisper = new WhisperProvider();
     await whisper.initialize({ apiKey: opts.apiKey });
-    const audioBytes = await readFile10(audioAbsPath);
+    const audioBytes = await readFile11(audioAbsPath);
     const audioBlob = new Blob([new Uint8Array(audioBytes)]);
     const transcript = await whisper.transcribe(audioBlob, void 0, {
       granularity: "word",
@@ -268580,7 +269098,7 @@ async function readBeatTranscript(projectDir, beatId) {
   const abs = join56(projectDir, beatTranscriptRelPath(beatId));
   if (!existsSync41(abs)) return void 0;
   try {
-    const parsed = JSON.parse(await readFile10(abs, "utf-8"));
+    const parsed = JSON.parse(await readFile11(abs, "utf-8"));
     if (!Array.isArray(parsed)) return void 0;
     const words = parsed.filter(
       (w4) => typeof w4 === "object" && w4 !== null && typeof w4.text === "string" && Number.isFinite(w4.start) && Number.isFinite(w4.end)
@@ -268599,7 +269117,6 @@ var init_transcribe_narration = __esm({
 
 // ../cli/src/commands/_shared/compose-prompts.ts
 import { existsSync as existsSync43 } from "node:fs";
-import { readFile as readFile11 } from "node:fs/promises";
 import { join as join57, relative as relative6, resolve as resolve25 } from "node:path";
 async function getComposePrompts(opts) {
   const projectDir = resolve25(opts.projectDir);
@@ -268633,7 +269150,7 @@ async function getComposePrompts(opts) {
       `Hyperframes composition rules are not installed \u2014 you will be authoring without them in context. Run \`vibe scene install-skill\` (or \`${HYPERFRAMES_SKILL_INSTALL_COMMAND}\`) first.`
     );
   }
-  const storyboardMd = await readFile11(storyboardPath, "utf-8");
+  const storyboardMd = await loadStoryboardMarkdown(projectDir);
   const parsed = parseStoryboard(storyboardMd);
   if (parsed.beats.length === 0) {
     return baseError(`STORYBOARD.md has no \`## Beat \u2026\` headings.`);
@@ -268714,7 +269231,8 @@ function buildInstructions(args) {
   if (args.compositionRef) {
     lines.push(`2b. Read \`${args.compositionRef}\` for the project STRUCTURAL contract (layout system, GSAP timeline conventions, element/track rules) \u2014 a HARD-GATE parallel to DESIGN.md; every composition must satisfy it.`);
   }
-  lines.push(`3. For each beat in the \`beats\` array below, author HTML at \`outputPath\` matching the \`userPrompt\`. The beat \`body\` carries the narrative + visual + animation intent; \`cues\` carries machine-readable per-beat overrides (narration, duration, backdrop, voice).`);
+  lines.push(`3. For each beat in the \`beats\` array below, author HTML at \`outputPath\` matching the \`userPrompt\`. The beat \`body\` carries the narrative intent; \`cues\` carries machine-readable per-beat overrides (${STORYBOARD_CUE_KEYS.join(", ")}).`);
+  lines.push(`   The \`motion\` cue, when present, is the animation direction for this beat - treat it as binding on how elements enter, hold, and leave, the same way \`narration\` is binding on the audio.`);
   lines.push(`3b. Use each beat's \`finalDurationSec\` (narration-synced) for \`data-duration\` and timeline anchors when present \u2014 NOT the storyboard \`duration\`, which is only the minimum. Scenes composed at the storyboard duration end early and render black tails.`);
   lines.push(`3c. Never give inner \`.clip\` elements a non-zero \`data-start\` \u2014 the renderer does not toggle internal clip visibility inside sub-compositions, so phased clips render all phases at once (overlapping text). Use full-window clips and GSAP autoAlpha phase transitions instead. Also keep beats 6-15s; split anything longer in the storyboard first.`);
   lines.push(`3d. If your environment cannot write files (e.g. Claude Desktop / MCP-only hosts), author each beat's HTML and submit it with the \`scene_submit\` tool (beat id + html). It validates with the same Hyperframes lint and writes the file for you; on lint errors it returns the findings without writing \u2014 fix and resubmit.`);
@@ -268734,6 +269252,7 @@ var init_compose_prompts = __esm({
   "../cli/src/commands/_shared/compose-prompts.ts"() {
     "use strict";
     init_storyboard_parse();
+    init_storyboard_source();
     init_compose_beat_prompt();
     init_root_sync();
     init_install_skill();
@@ -268743,7 +269262,7 @@ var init_compose_prompts = __esm({
 
 // ../cli/src/commands/_shared/sub-comp-duration-sync.ts
 import { existsSync as existsSync45 } from "node:fs";
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 import { join as join59, resolve as resolve27 } from "node:path";
 function syncSubCompositionDurationHtml(html, beatId, newDurationSec, fileRel) {
   const compositionId = `scene-${beatId}`;
@@ -268844,7 +269363,7 @@ async function createSubCompDurationSyncPlans(opts) {
       narrationPath: beat.narrationPath,
       sceneDurationSec: beat.sceneDurationSec
     });
-    const html = await readFile13(filePath, "utf-8");
+    const html = await readFile12(filePath, "utf-8");
     const outcome = syncSubCompositionDurationHtml(html, beat.id, newDurationSec, fileRel);
     results.push({ ...outcome, file: fileRel, beatId: beat.id });
   }
@@ -268868,7 +269387,7 @@ var init_sub_comp_duration_sync = __esm({
 });
 
 // ../cli/src/commands/_shared/scene-repair.ts
-import { readFile as readFile14, writeFile as writeFile13 } from "node:fs/promises";
+import { readFile as readFile13, writeFile as writeFile14 } from "node:fs/promises";
 import { relative as relative7, resolve as resolve28 } from "node:path";
 async function executeSceneRepair(opts) {
   const projectDir = resolve28(opts.projectDir);
@@ -268888,7 +269407,7 @@ async function executeSceneRepair(opts) {
       if (dryRun) {
         wouldFix.push(item);
       } else {
-        await writeFile13(rootSync.rootPath, rootSync.nextHtml, "utf-8");
+        await writeFile14(rootSync.rootPath, rootSync.nextHtml, "utf-8");
         fixed.push(item);
       }
     } else if (rootSync.issues.length > 0) {
@@ -268904,7 +269423,7 @@ async function executeSceneRepair(opts) {
         if (dryRun) {
           wouldFix.push(item);
         } else {
-          await writeFile13(resolve28(projectDir, plan2.file), plan2.nextHtml, "utf-8");
+          await writeFile14(resolve28(projectDir, plan2.file), plan2.nextHtml, "utf-8");
           fixed.push(item);
         }
       }
@@ -268913,7 +269432,7 @@ async function executeSceneRepair(opts) {
   }
   for (const target of targets) {
     const rel = relative7(projectDir, target.abs) || target.abs;
-    const html = await readFile14(target.abs, "utf-8");
+    const html = await readFile13(target.abs, "utf-8");
     const findings = await lintHtml(html, rel, target.isSub);
     const { html: nextHtml, fixedCodes } = applyMechanicalFixes(html, findings);
     if (fixedCodes.length > 0) {
@@ -268921,7 +269440,7 @@ async function executeSceneRepair(opts) {
       if (dryRun) {
         wouldFix.push(item);
       } else {
-        await writeFile13(target.abs, nextHtml, "utf-8");
+        await writeFile14(target.abs, nextHtml, "utf-8");
         fixed.push(item);
       }
       files.push({
@@ -268993,303 +269512,6 @@ var init_scene_repair = __esm({
   }
 });
 
-// ../cli/src/commands/_shared/storyboard-edit.ts
-function validateStoryboardMarkdown(markdown) {
-  const parsed = parseStoryboard(markdown);
-  const sections = splitBeatSections(markdown);
-  const issues = [];
-  if (parsed.beats.length === 0) {
-    issues.push({
-      severity: "error",
-      code: "NO_BEATS",
-      message: "STORYBOARD.md must contain at least one `## Beat ...` heading."
-    });
-  }
-  const seen = /* @__PURE__ */ new Map();
-  for (const beat of parsed.beats) {
-    seen.set(beat.id, (seen.get(beat.id) ?? 0) + 1);
-  }
-  for (const [id, count] of seen.entries()) {
-    if (count > 1) {
-      issues.push({
-        severity: "error",
-        code: "DUPLICATE_BEAT_ID",
-        beatId: id,
-        message: `Beat id "${id}" appears ${count} times. Beat ids must be unique.`
-      });
-    }
-  }
-  for (const section of sections) {
-    const cueBlock = readLeadingCueBlock(section.body);
-    if (cueBlock?.error) {
-      issues.push({
-        severity: "error",
-        code: "MALFORMED_CUE_YAML",
-        beatId: section.id,
-        message: `Beat "${section.id}" has malformed YAML cues: ${cueBlock.error}`
-      });
-    }
-  }
-  const characterPool = new Set(
-    Object.keys(
-      parsed.frontmatter?.characters ?? {}
-    )
-  );
-  for (const beat of parsed.beats) {
-    const cues = beat.cues ?? {};
-    for (const [key2, value] of Object.entries(cues)) {
-      if (!ALLOWED_CUE_KEYS.has(key2)) {
-        issues.push({
-          severity: "warning",
-          code: "UNKNOWN_CUE",
-          beatId: beat.id,
-          message: `Beat "${beat.id}" uses unknown cue "${key2}". Supported cues: ${STORYBOARD_CUE_KEYS.join(", ")}.`
-        });
-        continue;
-      }
-      if (key2 === "characters") {
-        const validShape = typeof value === "string" || Array.isArray(value) && value.every((v4) => typeof v4 === "string");
-        if (!validShape) {
-          issues.push({
-            severity: "error",
-            code: "INVALID_CHARACTERS_VALUE",
-            beatId: beat.id,
-            message: `Beat "${beat.id}" cue "characters" must be a character name or a list of names.`
-          });
-          continue;
-        }
-        for (const name of beatCharacterNames({ characters: value })) {
-          if (!characterPool.has(name)) {
-            issues.push({
-              severity: "warning",
-              code: "UNKNOWN_CHARACTER",
-              beatId: beat.id,
-              message: `Beat "${beat.id}" references character "${name}" not defined in the frontmatter \`characters:\` pool.`
-            });
-          }
-        }
-        continue;
-      }
-      if (key2 === "duration") {
-        if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-          issues.push({
-            severity: "error",
-            code: "INVALID_DURATION",
-            beatId: beat.id,
-            message: `Beat "${beat.id}" cue "duration" must be a positive number of seconds.`
-          });
-        }
-        continue;
-      }
-      if (STRING_CUE_KEYS.has(key2) && typeof value !== "string") {
-        issues.push({
-          severity: "error",
-          code: "INVALID_CUE_VALUE",
-          beatId: beat.id,
-          message: `Beat "${beat.id}" cue "${key2}" must be a string.`
-        });
-      }
-    }
-  }
-  for (const beat of parsed.beats) {
-    if (beat.duration !== void 0 && beat.duration > MAX_RECOMMENDED_BEAT_SEC) {
-      issues.push({
-        severity: "warning",
-        code: "BEAT_DURATION_TOO_LONG",
-        beatId: beat.id,
-        message: `Beat "${beat.id}" is ${beat.duration}s \u2014 beats longer than ${MAX_RECOMMENDED_BEAT_SEC}s render static and overstuffed. Split it into 6-15s beats (a 90s video should have 6-8 beats).`
-      });
-    }
-  }
-  return {
-    ok: !issues.some((i3) => i3.severity === "error"),
-    beats: parsed.beats,
-    issues
-  };
-}
-function getStoryboardBeat(markdown, beatId) {
-  return parseStoryboard(markdown).beats.find((beat) => beat.id === beatId) ?? null;
-}
-function upsertStoryboardBeat(markdown, opts) {
-  const beatId = normalizeBeatId(opts.beatId);
-  const sections = splitBeatSections(markdown);
-  const existing = sections.find((section2) => section2.id === beatId);
-  const cues = storyboardCuesFromInput(opts);
-  if (existing) {
-    let next = markdown;
-    for (const [key2, value] of Object.entries(cues)) {
-      next = setStoryboardCue(next, { beatId, key: key2, value });
-    }
-    return { markdown: next, action: "updated" };
-  }
-  const section = buildStoryboardBeatSection({ ...opts, beatId, cues });
-  if (sections.length > 0 && isStarterStoryboard(markdown)) {
-    const global3 = markdown.slice(0, sections[0].start).trimEnd();
-    return {
-      markdown: `${global3}
-
-${section}`,
-      action: "replaced-starter"
-    };
-  }
-  const prefix = markdown.trimEnd();
-  return {
-    markdown: `${prefix}${prefix ? "\n\n" : ""}${section}`,
-    action: "appended"
-  };
-}
-function setStoryboardCue(markdown, opts) {
-  const section = findBeatSection(markdown, opts.beatId);
-  if (!section) {
-    throw new Error(`Beat "${opts.beatId}" not found.`);
-  }
-  if (!ALLOWED_CUE_KEYS.has(opts.key)) {
-    throw new Error(`Unsupported cue "${opts.key}". Supported cues: ${STORYBOARD_CUE_KEYS.join(", ")}.`);
-  }
-  const cue = readLeadingCueBlock(section.body);
-  if (cue?.error) {
-    throw new Error(`Cannot edit malformed YAML cues for beat "${opts.beatId}": ${cue.error}`);
-  }
-  const cues = cue?.value ? { ...cue.value } : {};
-  if (opts.unset) {
-    delete cues[opts.key];
-  } else {
-    cues[opts.key] = normalizeCueValue(opts.key, opts.value);
-  }
-  const remainingBody = cue ? section.body.slice(cue.full.length).replace(/^\s*\n/, "") : section.body.replace(/^\s*\n/, "");
-  const cueBlock = Object.keys(cues).length > 0 ? "```yaml\n" + (0, import_yaml5.stringify)(cues, { lineWidth: 0 }).trimEnd() + "\n```\n\n" : "";
-  const nextBody = cueBlock + remainingBody.trimStart();
-  const nextSection = section.raw.slice(0, section.headingEnd - section.start) + "\n\n" + nextBody.trimEnd() + "\n";
-  return markdown.slice(0, section.start) + nextSection + markdown.slice(section.end);
-}
-function moveStoryboardBeat(markdown, opts) {
-  if (opts.beatId === opts.afterBeatId) return markdown;
-  const sections = splitBeatSections(markdown);
-  const movingIndex = sections.findIndex((section) => section.id === opts.beatId);
-  if (movingIndex === -1) throw new Error(`Beat "${opts.beatId}" not found.`);
-  const afterIndex = sections.findIndex((section) => section.id === opts.afterBeatId);
-  if (afterIndex === -1) throw new Error(`Beat "${opts.afterBeatId}" not found.`);
-  const global3 = sections.length > 0 ? markdown.slice(0, sections[0].start) : markdown;
-  const chunks = sections.map((section) => section.raw);
-  const [moving] = chunks.splice(movingIndex, 1);
-  const adjustedAfterIndex = movingIndex < afterIndex ? afterIndex - 1 : afterIndex;
-  chunks.splice(adjustedAfterIndex + 1, 0, moving);
-  return global3 + normalizeBeatChunks(chunks);
-}
-function normalizeBeatChunks(chunks) {
-  return chunks.map((chunk) => chunk.trim()).filter(Boolean).join("\n\n") + "\n";
-}
-function normalizeBeatId(id) {
-  return deriveBeatId(id);
-}
-function storyboardCuesFromInput(opts) {
-  const cues = {};
-  if (opts.duration !== void 0) cues.duration = opts.duration;
-  if (opts.narration && opts.narration.trim()) cues.narration = opts.narration.trim();
-  if (opts.backdrop && opts.backdrop.trim()) cues.backdrop = opts.backdrop.trim();
-  return cues;
-}
-function buildStoryboardBeatSection(opts) {
-  const title = normalizeTitle(opts.title ?? humanizeBeatId(opts.beatId));
-  const cueBlock = Object.keys(opts.cues).length > 0 ? "```yaml\n" + (0, import_yaml5.stringify)(opts.cues, { lineWidth: 0 }).trimEnd() + "\n```\n\n" : "";
-  const body = opts.body?.trim() || "Scene created with `vibe scene add`. Edit this body if the build flow should recompose it.";
-  return `## Beat ${opts.beatId} - ${title}
-
-${cueBlock}${body.trimEnd()}
-`;
-}
-function normalizeTitle(value) {
-  return value.replace(/\s+/g, " ").trim() || "Scene";
-}
-function humanizeBeatId(id) {
-  return id.split(/[-_]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ") || "Scene";
-}
-function isStarterStoryboard(markdown) {
-  const parsed = parseStoryboard(markdown);
-  if (parsed.beats.length !== 3) return false;
-  const ids = parsed.beats.map((beat) => beat.id);
-  if (ids.join(",") !== "hook,proof,close") return false;
-  return markdown.includes("Introduce the promise in one crisp sentence.") && markdown.includes("Show the mechanism or proof point that makes the promise believable.") && markdown.includes("Close with the action the viewer should remember.");
-}
-function normalizeCueValue(key2, value) {
-  if (key2 === "duration") {
-    const n2 = typeof value === "number" ? value : Number.parseFloat(String(value ?? ""));
-    if (!Number.isFinite(n2) || n2 <= 0) {
-      throw new Error("Cue duration must be a positive number.");
-    }
-    return n2;
-  }
-  if (typeof value !== "string") return value;
-  return value.trim();
-}
-function splitBeatSections(markdown) {
-  const normalized = markdown.replace(/\r\n/g, "\n");
-  const headings = [];
-  HEADING_RE2.lastIndex = 0;
-  let match2;
-  while ((match2 = HEADING_RE2.exec(normalized)) !== null) {
-    headings.push({ start: match2.index, end: match2.index + match2[0].length, line: match2[1].trim() });
-  }
-  return headings.map((heading, index) => {
-    const end = index + 1 < headings.length ? headings[index + 1].start : normalized.length;
-    return {
-      id: deriveBeatId(heading.line),
-      heading: heading.line,
-      start: heading.start,
-      headingEnd: heading.end,
-      end,
-      raw: normalized.slice(heading.start, end),
-      body: normalized.slice(heading.end, end).trim()
-    };
-  });
-}
-function findBeatSection(markdown, beatId) {
-  return splitBeatSections(markdown).find((section) => section.id === beatId) ?? null;
-}
-function readLeadingCueBlock(body) {
-  const match2 = body.match(LEADING_CUE_RE);
-  if (!match2) return null;
-  try {
-    const parsed = (0, import_yaml5.parse)(match2[2]);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return { full: match2[0], error: "cue block must parse to a YAML object" };
-    }
-    return { full: match2[0], value: parsed };
-  } catch (error) {
-    return { full: match2[0], error: error instanceof Error ? error.message : String(error) };
-  }
-}
-var import_yaml5, STORYBOARD_CUE_KEYS, HEADING_RE2, LEADING_CUE_RE, ALLOWED_CUE_KEYS, STRING_CUE_KEYS, MAX_RECOMMENDED_BEAT_SEC;
-var init_storyboard_edit = __esm({
-  "../cli/src/commands/_shared/storyboard-edit.ts"() {
-    "use strict";
-    import_yaml5 = __toESM(require_dist3(), 1);
-    init_storyboard_parse();
-    STORYBOARD_CUE_KEYS = [
-      "duration",
-      "narration",
-      "backdrop",
-      "video",
-      "keyframe",
-      "motion",
-      "voice",
-      "music",
-      "asset",
-      "characters",
-      "eyebrow",
-      "title",
-      "caption",
-      "kicker",
-      "sub"
-    ];
-    HEADING_RE2 = /^##\s+(.+?)\s*$/gm;
-    LEADING_CUE_RE = /^(\s*)```ya?ml\s*\n([\s\S]*?)\n```\s*(?:\n|$)/;
-    ALLOWED_CUE_KEYS = new Set(STORYBOARD_CUE_KEYS);
-    STRING_CUE_KEYS = /* @__PURE__ */ new Set(["narration", "backdrop", "video", "keyframe", "motion", "voice", "music", "asset", "eyebrow", "title", "caption", "kicker", "sub"]);
-    MAX_RECOMMENDED_BEAT_SEC = 15;
-  }
-});
-
 // ../cli/src/pipeline/renderers/chrome.ts
 import { existsSync as existsSync47 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
@@ -269365,7 +269587,7 @@ var init_ffmpeg_gate = __esm({
 });
 
 // ../cli/src/commands/_shared/scene-audio-scan.ts
-import { readFile as readFile16 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import { resolve as resolve30 } from "node:path";
 function parseRootClips(rootHtml) {
   const clips = [];
@@ -269406,7 +269628,7 @@ function makeFsCompositionReader(projectDir) {
   return async (compositionSrcRel) => {
     const abs = resolve30(projectDir, compositionSrcRel);
     try {
-      return await readFile16(abs, "utf-8");
+      return await readFile15(abs, "utf-8");
     } catch {
       return null;
     }
@@ -269472,7 +269694,7 @@ var init_scene_audio_scan = __esm({
 });
 
 // ../cli/src/commands/_shared/scene-audio-mux.ts
-import { rename as rename4, unlink as unlink4 } from "node:fs/promises";
+import { rename as rename5, unlink as unlink4 } from "node:fs/promises";
 import { resolve as resolve31, dirname as dirname25, extname as extname10, basename as basename7 } from "node:path";
 function buildAudioMuxFilter(audios) {
   if (audios.length === 0) return null;
@@ -269581,7 +269803,7 @@ async function muxAudioIntoVideo(opts) {
       error: `ffmpeg mux failed: ${msg}`
     };
   }
-  await rename4(tmpPath, opts.videoPath);
+  await rename5(tmpPath, opts.videoPath);
   return {
     success: true,
     outputPath: opts.videoPath,
@@ -269597,7 +269819,7 @@ var init_scene_audio_mux = __esm({
 
 // ../cli/src/commands/_shared/scene-assemble.ts
 import { existsSync as existsSync48 } from "node:fs";
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 import { resolve as resolve32, isAbsolute as isAbsolute7 } from "node:path";
 async function executeSceneAssemble(opts) {
   const projectDir = resolve32(opts.projectDir);
@@ -269628,7 +269850,7 @@ async function executeSceneAssemble(opts) {
   let audioMuxWarning;
   try {
     opts.onProgress?.(0.1, "Scanning audio");
-    const rootHtml = await readFile17(rootPath, "utf-8");
+    const rootHtml = await readFile16(rootPath, "utf-8");
     const audios = await scanSceneAudio({ projectDir, rootHtml });
     audioCount = audios.length;
     if (audios.length > 0) {
@@ -269682,7 +269904,7 @@ __export(scene_render_exports, {
 });
 import { execFile as execFile4 } from "node:child_process";
 import { existsSync as existsSync49 } from "node:fs";
-import { mkdir as mkdir11, readFile as readFile18, stat as stat5, writeFile as writeFile15 } from "node:fs/promises";
+import { mkdir as mkdir12, readFile as readFile17, stat as stat5, writeFile as writeFile16 } from "node:fs/promises";
 import { resolve as resolve33, relative as relative9, dirname as dirname26, basename as basename8, join as join61, isAbsolute as isAbsolute8 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 function qualityToCrf(quality = "standard") {
@@ -269828,7 +270050,7 @@ async function executeSceneRender(opts = {}) {
   }
   const projectName = projectConfig.config.name;
   const outputPath = opts.output ? resolve33(projectDir, opts.output) : defaultOutputPath({ projectDir, projectName, format: opts.format, beatId: opts.beatId });
-  await mkdir11(dirname26(outputPath), { recursive: true });
+  await mkdir12(dirname26(outputPath), { recursive: true });
   const config4 = buildRenderConfig({
     fps: opts.fps,
     quality: opts.quality,
@@ -269955,7 +270177,7 @@ async function prepareBeatRenderRoot(opts) {
   }
   let report;
   try {
-    report = JSON.parse(await readFile18(reportPath, "utf-8"));
+    report = JSON.parse(await readFile17(reportPath, "utf-8"));
   } catch (error) {
     return {
       success: false,
@@ -270024,8 +270246,8 @@ async function prepareBeatRenderRoot(opts) {
     durationSec,
     narrationPath
   });
-  await mkdir11(dirname26(join61(opts.projectDir, root2)), { recursive: true });
-  await writeFile15(join61(opts.projectDir, root2), html, "utf-8");
+  await mkdir12(dirname26(join61(opts.projectDir, root2)), { recursive: true });
+  await writeFile16(join61(opts.projectDir, root2), html, "utf-8");
   return {
     success: true,
     root: root2,
@@ -270091,7 +270313,7 @@ function reportedBeatAssetPaths(beat) {
 async function writeRenderReport(projectDir, result) {
   const reportPath = join61(projectDir, "render-report.json");
   try {
-    await writeFile15(
+    await writeFile16(
       reportPath,
       JSON.stringify(
         {
@@ -270254,7 +270476,7 @@ function validateDesignMarkdown(md) {
   const fm = raw2.match(DESIGN_FRONTMATTER_RE);
   if (fm) {
     try {
-      const parsed = (0, import_yaml6.parse)(fm[1]);
+      const parsed = (0, import_yaml7.parse)(fm[1]);
       if (!isPlainObject5(parsed)) {
         issues.push({
           severity: "warning",
@@ -270295,11 +270517,11 @@ function validateDesignMarkdown(md) {
   }
   return issues;
 }
-var import_yaml6, DESIGN_FRONTMATTER_RE, SECTION_RE, HEX_RE;
+var import_yaml7, DESIGN_FRONTMATTER_RE, SECTION_RE, HEX_RE;
 var init_design_parse = __esm({
   "../cli/src/commands/_shared/design-parse.ts"() {
     "use strict";
-    import_yaml6 = __toESM(require_dist3(), 1);
+    import_yaml7 = __toESM(require_dist3(), 1);
     init_frontmatter();
     DESIGN_FRONTMATTER_RE = /^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/;
     SECTION_RE = /^##\s+(.+?)\s*$/gm;
@@ -270309,21 +270531,21 @@ var init_design_parse = __esm({
 
 // ../cli/src/commands/_shared/compose-aivideo.ts
 import { existsSync as existsSync50 } from "node:fs";
-import { mkdir as mkdir12, readFile as readFile19, writeFile as writeFile16 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile18, writeFile as writeFile17 } from "node:fs/promises";
 import { join as join63, resolve as resolve34 } from "node:path";
 function headingDescriptor(heading) {
   const stripped = heading.replace(/^\s*beat\s+/i, "");
   const m2 = stripped.match(/^[A-Za-z0-9][\w-]*(?:\s*[—:]\s*|\s+-\s+)(.+)$/);
   const desc = clean2(m2 ? m2[1] : stripped);
-  return /\s/.test(desc) || !/[-_]/.test(desc) ? desc : humanise2(desc);
+  return /\s/.test(desc) || !/[-_]/.test(desc) ? desc : humanise3(desc);
 }
-function humanise2(id) {
+function humanise3(id) {
   return id.split(/[-_\s]+/).filter(Boolean).map((w4) => w4.charAt(0).toUpperCase() + w4.slice(1)).join(" ");
 }
 function beatOverlayText(beat) {
   const cues = beat.cues ?? {};
   const descriptor = headingDescriptor(beat.heading);
-  const idHuman = humanise2(beat.id);
+  const idHuman = humanise3(beat.id);
   const titleCue = clean2(cues.title);
   const title = titleCue || descriptor || idHuman;
   const kickerCue = clean2(
@@ -270459,8 +270681,7 @@ async function composeAiVideo(opts) {
   if (!commandExists("ffmpeg")) {
     throw new Error("ffmpeg not found in PATH \u2014 required to concatenate AI-video clips.");
   }
-  const storyboardPath = join63(projectDir, "STORYBOARD.md");
-  const md = await readFile19(storyboardPath, "utf-8");
+  const md = await loadStoryboardMarkdown(projectDir);
   const beats = parseStoryboard(md).beats;
   if (beats.length === 0) throw new Error("STORYBOARD.md has no beats to compose.");
   const tokens = opts.tokens ?? await loadProjectTokens(projectDir);
@@ -270473,7 +270694,7 @@ async function composeAiVideo(opts) {
     }
     clipRels.push(rel);
   }
-  await mkdir12(join63(projectDir, "assets"), { recursive: true });
+  await mkdir13(join63(projectDir, "assets"), { recursive: true });
   const bgRel = "assets/bg-full.mp4";
   const concatArgs = buildBgConcatArgs(
     clipRels.map((r2) => join63(projectDir, r2)),
@@ -270481,7 +270702,7 @@ async function composeAiVideo(opts) {
   );
   await execSafe("ffmpeg", concatArgs, { timeout: 6e5 });
   const totalDurationSec = await probeDurationSec(join63(projectDir, bgRel));
-  await mkdir12(join63(projectDir, "compositions"), { recursive: true });
+  await mkdir13(join63(projectDir, "compositions"), { recursive: true });
   const sceneFiles = [];
   for (let i3 = 0; i3 < beats.length; i3++) {
     const beat = beats[i3];
@@ -270498,12 +270719,12 @@ async function composeAiVideo(opts) {
       isLast: i3 === beats.length - 1
     });
     const rel = `compositions/scene-${beat.id}.html`;
-    await writeFile16(join63(projectDir, rel), html, "utf-8");
+    await writeFile17(join63(projectDir, rel), html, "utf-8");
     sceneFiles.push(rel);
   }
   const indexPath = join63(projectDir, "index.html");
-  const next = existsSync50(indexPath) ? injectBgVideo(await readFile19(indexPath, "utf-8"), bgRel, totalDurationSec) : buildRootShell(tokens, bgRel, totalDurationSec);
-  await writeFile16(indexPath, next, "utf-8");
+  const next = existsSync50(indexPath) ? injectBgVideo(await readFile18(indexPath, "utf-8"), bgRel, totalDurationSec) : buildRootShell(tokens, bgRel, totalDurationSec);
+  await writeFile17(indexPath, next, "utf-8");
   return { bgVideoRel: bgRel, sceneFiles, totalDurationSec, beats: beats.length };
 }
 function buildRootShell(tokens, bgRel, totalDuration) {
@@ -270554,7 +270775,7 @@ async function loadProjectTokens(projectDir) {
   const designPath = join63(projectDir, "DESIGN.md");
   if (!existsSync50(designPath)) return DEFAULT_AIVIDEO_TOKENS;
   try {
-    return extractDesignTokens(await readFile19(designPath, "utf-8"));
+    return extractDesignTokens(await readFile18(designPath, "utf-8"));
   } catch {
     return DEFAULT_AIVIDEO_TOKENS;
   }
@@ -270613,6 +270834,7 @@ var init_compose_aivideo = __esm({
     "use strict";
     init_exec_safe();
     init_storyboard_parse();
+    init_storyboard_source();
     init_design_parse();
     BG_VIDEO_TRACK = 9;
     DEFAULT_AIVIDEO_TOKENS = {
@@ -270906,7 +271128,6 @@ var init_composer_resolve = __esm({
 
 // ../cli/src/commands/_shared/build-plan.ts
 import { existsSync as existsSync53 } from "node:fs";
-import { readFile as readFile20 } from "node:fs/promises";
 import { dirname as dirname27, join as join64, resolve as resolve36 } from "node:path";
 function backdropCostUsd(quality) {
   return quality === "hd" ? 0.2 : 0.05;
@@ -270958,9 +271179,13 @@ async function createBuildPlan(opts) {
       validation: validation4
     });
   }
-  const storyboardMd = await readFile20(storyboardPath, "utf-8");
+  const loaded = await loadStoryboard(projectDir);
+  const storyboardMd = loaded.markdown;
   const validation3 = validateStoryboardMarkdown(storyboardMd);
-  const validationIssues = [...validation3.issues];
+  const validationIssues = [
+    ...strayBeatIssues(loaded.strayBeatIds),
+    ...validation3.issues
+  ];
   const parsed = parseStoryboard(storyboardMd);
   let sourceBeats = parsed.beats;
   if (opts.beat) {
@@ -271618,6 +271843,7 @@ var init_build_plan = __esm({
     init_build_backdrop_prompt();
     init_composer_resolve();
     init_storyboard_parse();
+    init_storyboard_source();
     init_project_config();
     init_scene_project();
     init_storyboard_edit();
@@ -271661,7 +271887,7 @@ var init_validate = __esm({
 
 // ../cli/src/commands/generate/music.ts
 import { resolve as resolve38 } from "node:path";
-import { writeFile as writeFile17 } from "node:fs/promises";
+import { writeFile as writeFile18 } from "node:fs/promises";
 import { existsSync as existsSync54 } from "node:fs";
 async function executeMusic(options) {
   try {
@@ -271684,7 +271910,7 @@ async function executeMusic(options) {
         return { success: false, error: result2.error || "Music generation failed" };
       }
       const outputPath2 = resolve38(process.cwd(), options.output || "music.mp3");
-      await writeFile17(outputPath2, result2.audioBuffer);
+      await writeFile18(outputPath2, result2.audioBuffer);
       return { success: true, outputPath: outputPath2, provider: "elevenlabs", duration: duration2 };
     }
     const apiKey = await getConfiguredApiKey("REPLICATE_API_TOKEN");
@@ -271718,7 +271944,7 @@ async function executeMusic(options) {
       return { success: false, error: "Failed to download generated audio" };
     const audioBuffer = Buffer.from(await response.arrayBuffer());
     const outputPath = resolve38(process.cwd(), options.output || "music.mp3");
-    await writeFile17(outputPath, audioBuffer);
+    await writeFile18(outputPath, audioBuffer);
     return { success: true, outputPath, provider: "replicate", duration };
   } catch (error) {
     return {
@@ -271782,7 +272008,7 @@ function registerMusicCommand(parent) {
           exitWithError(apiError(result.error || "Music generation failed", true));
         }
         const outputPath = resolve38(process.cwd(), options.output);
-        await writeFile17(outputPath, result.audioBuffer);
+        await writeFile18(outputPath, result.audioBuffer);
         spinner2.succeed(source_default.green("Music generated successfully"));
         if (isJsonMode()) {
           outputSuccess({
@@ -271868,7 +272094,7 @@ function registerMusicCommand(parent) {
         }
         const audioBuffer = Buffer.from(await response.arrayBuffer());
         const outputPath = resolve38(process.cwd(), options.output);
-        await writeFile17(outputPath, audioBuffer);
+        await writeFile18(outputPath, audioBuffer);
         spinner2.succeed(source_default.green("Music generated successfully"));
         if (isJsonMode()) {
           outputSuccess({
@@ -271946,7 +272172,7 @@ __export(scene_build_exports, {
   resolveSceneBuildMode: () => resolveSceneBuildMode
 });
 import { existsSync as existsSync55, readFileSync as readFileSync21 } from "node:fs";
-import { copyFile as copyFile4, mkdir as mkdir13, readFile as readFile21, rm as rm5, writeFile as writeFile18 } from "node:fs/promises";
+import { copyFile as copyFile4, mkdir as mkdir14, readFile as readFile19, rm as rm6, writeFile as writeFile19 } from "node:fs/promises";
 import { dirname as dirname28, join as join65, resolve as resolve39 } from "node:path";
 function readProjectKindSync(projectDir) {
   try {
@@ -272033,7 +272259,7 @@ async function executeSceneBuild(opts) {
   if (!buildPlan.validation.ok) {
     let invalidBeats = [];
     if (existsSync55(storyboardPath)) {
-      invalidBeats = parseStoryboard(await readFile21(storyboardPath, "utf-8")).beats;
+      invalidBeats = parseStoryboard(await loadStoryboardMarkdown(projectDir)).beats;
     }
     return finishBuildResult({
       success: false,
@@ -272071,7 +272297,7 @@ async function executeSceneBuild(opts) {
       totalLatencyMs: Date.now() - startedAt
     });
   }
-  const storyboardMd = await readFile21(storyboardPath, "utf-8");
+  const storyboardMd = await loadStoryboardMarkdown(projectDir);
   const parsed = parseStoryboard(storyboardMd);
   if (parsed.beats.length === 0) {
     return finishBuildResult({
@@ -272730,7 +272956,7 @@ async function dispatchNarration(beat, ctx) {
     };
   }
   if (existsSync55(cacheAbs) && !ctx.force) {
-    await mkdir13(dirname28(abs), { recursive: true });
+    await mkdir14(dirname28(abs), { recursive: true });
     await copyFile4(cacheAbs, abs);
     await writeAssetMetadata({
       projectDir: ctx.projectDir,
@@ -272761,14 +272987,14 @@ async function dispatchNarration(beat, ctx) {
     ctx.onProgress({ type: "narration-failed", beatId: beat.id, error });
     return { status: "failed", error };
   }
-  await mkdir13(dirname28(abs), { recursive: true });
-  await writeFile18(abs, result.audioBuffer);
+  await mkdir14(dirname28(abs), { recursive: true });
+  await writeFile19(abs, result.audioBuffer);
   for (const otherExt of ["mp3", "wav"]) {
     const sibling = join65(ctx.projectDir, `assets/narration-${beat.id}.${otherExt}`);
-    if (sibling !== abs && existsSync55(sibling)) await rm5(sibling, { force: true });
+    if (sibling !== abs && existsSync55(sibling)) await rm6(sibling, { force: true });
   }
-  await mkdir13(dirname28(cacheAbs), { recursive: true });
-  await writeFile18(cacheAbs, result.audioBuffer);
+  await mkdir14(dirname28(cacheAbs), { recursive: true });
+  await writeFile19(cacheAbs, result.audioBuffer);
   await writeAssetMetadata({
     projectDir: ctx.projectDir,
     kind: "narration",
@@ -272824,8 +273050,8 @@ async function dispatchTranscript(beat, narrationPath, narrationFresh, ctx) {
     return "skipped";
   }
   try {
-    await mkdir13(dirname28(abs), { recursive: true });
-    await writeFile18(abs, JSON.stringify(words, null, 2), "utf-8");
+    await mkdir14(dirname28(abs), { recursive: true });
+    await writeFile19(abs, JSON.stringify(words, null, 2), "utf-8");
   } catch (err) {
     ctx.onProgress({
       type: "transcript-skipped",
@@ -272912,7 +273138,7 @@ async function buildCharacters(characters, ctx) {
     }
     const cacheAbs = join65(ctx.projectDir, cache.path);
     if (existsSync55(cacheAbs) && !ctx.force) {
-      await mkdir13(dirname28(abs), { recursive: true });
+      await mkdir14(dirname28(abs), { recursive: true });
       await copyFile4(cacheAbs, abs);
       await writeAssetMetadata({
         projectDir: ctx.projectDir,
@@ -272944,10 +273170,10 @@ async function buildCharacters(characters, ctx) {
       ctx.onProgress({ type: "character-failed", name: character.name, error: generated.error });
       continue;
     }
-    await mkdir13(dirname28(abs), { recursive: true });
-    await writeFile18(abs, generated.buffer);
-    await mkdir13(dirname28(cacheAbs), { recursive: true });
-    await writeFile18(cacheAbs, generated.buffer);
+    await mkdir14(dirname28(abs), { recursive: true });
+    await writeFile19(abs, generated.buffer);
+    await mkdir14(dirname28(cacheAbs), { recursive: true });
+    await writeFile19(cacheAbs, generated.buffer);
     await writeAssetMetadata({
       projectDir: ctx.projectDir,
       kind: "character",
@@ -273015,7 +273241,7 @@ async function dispatchBackdrop(beat, ctx) {
   }
   const cacheAbs = join65(ctx.projectDir, cache.path);
   if (existsSync55(cacheAbs) && !ctx.force) {
-    await mkdir13(dirname28(abs), { recursive: true });
+    await mkdir14(dirname28(abs), { recursive: true });
     await copyFile4(cacheAbs, abs);
     await writeAssetMetadata({
       projectDir: ctx.projectDir,
@@ -273045,11 +273271,11 @@ async function dispatchBackdrop(beat, ctx) {
     ctx.onProgress({ type: "backdrop-failed", beatId: beat.id, error });
     return { status: "failed", error };
   }
-  await mkdir13(dirname28(abs), { recursive: true });
+  await mkdir14(dirname28(abs), { recursive: true });
   const buffer = generated.buffer;
-  await writeFile18(abs, buffer);
-  await mkdir13(dirname28(cacheAbs), { recursive: true });
-  await writeFile18(cacheAbs, buffer);
+  await writeFile19(abs, buffer);
+  await mkdir14(dirname28(cacheAbs), { recursive: true });
+  await writeFile19(cacheAbs, buffer);
   await writeAssetMetadata({
     projectDir: ctx.projectDir,
     kind: "backdrop",
@@ -273175,7 +273401,7 @@ async function ensureKeyframe(beat, ctx, keyframeCue, characterRefsRel) {
   }
   const cacheAbs = join65(ctx.projectDir, cache.path);
   if (existsSync55(cacheAbs) && !ctx.force) {
-    await mkdir13(dirname28(abs), { recursive: true });
+    await mkdir14(dirname28(abs), { recursive: true });
     await copyFile4(cacheAbs, abs);
     await writeAssetMetadata({
       projectDir: ctx.projectDir,
@@ -273193,7 +273419,7 @@ async function ensureKeyframe(beat, ctx, keyframeCue, characterRefsRel) {
   const sheetBuffers = [];
   for (const relPath of characterRefsRel) {
     const sheetAbs = join65(ctx.projectDir, relPath);
-    if (existsSync55(sheetAbs)) sheetBuffers.push(await readFile21(sheetAbs));
+    if (existsSync55(sheetAbs)) sheetBuffers.push(await readFile19(sheetAbs));
   }
   const imgCtx = {
     projectDir: ctx.projectDir,
@@ -273204,10 +273430,10 @@ async function ensureKeyframe(beat, ctx, keyframeCue, characterRefsRel) {
   const identityLock = "Keep the EXACT same person and face as the reference image(s): identical facial features (eyes, nose shape, jawline), skin tone and complexion, hairstyle, hair color, and wardrobe. Do not restyle or change the face. Change only the scene, pose, framing, and lighting. ";
   const generated = sheetBuffers.length > 0 ? await editKeyframeImage(`${identityLock}${keyframeCue}`, sheetBuffers, imgCtx, ratio) : await generateBackdropImage(keyframeCue, imgCtx, ratio);
   if (!generated.success) return { status: "failed", error: generated.error };
-  await mkdir13(dirname28(abs), { recursive: true });
-  await writeFile18(abs, generated.buffer);
-  await mkdir13(dirname28(cacheAbs), { recursive: true });
-  await writeFile18(cacheAbs, generated.buffer);
+  await mkdir14(dirname28(abs), { recursive: true });
+  await writeFile19(abs, generated.buffer);
+  await mkdir14(dirname28(cacheAbs), { recursive: true });
+  await writeFile19(cacheAbs, generated.buffer);
   await writeAssetMetadata({
     projectDir: ctx.projectDir,
     kind: "keyframe",
@@ -273301,7 +273527,7 @@ async function dispatchVideo(beat, ctx, keyframe) {
   }
   const cacheAbs = join65(ctx.projectDir, cache.path);
   if (existsSync55(cacheAbs) && !ctx.force) {
-    await mkdir13(dirname28(abs), { recursive: true });
+    await mkdir14(dirname28(abs), { recursive: true });
     await copyFile4(cacheAbs, abs);
     await writeAssetMetadata({
       projectDir: ctx.projectDir,
@@ -273356,7 +273582,7 @@ async function dispatchVideo(beat, ctx, keyframe) {
     return { status: "failed", error };
   }
   if (result.status === "completed" && existsSync55(abs)) {
-    await mkdir13(dirname28(cacheAbs), { recursive: true });
+    await mkdir14(dirname28(cacheAbs), { recursive: true });
     await copyFile4(abs, cacheAbs);
     await writeAssetMetadata({
       projectDir: ctx.projectDir,
@@ -273458,7 +273684,7 @@ async function dispatchMusic(beat, ctx) {
   }
   const cacheAbs = join65(ctx.projectDir, cache.path);
   if (existsSync55(cacheAbs) && !ctx.force) {
-    await mkdir13(dirname28(abs), { recursive: true });
+    await mkdir14(dirname28(abs), { recursive: true });
     await copyFile4(cacheAbs, abs);
     await writeAssetMetadata({
       projectDir: ctx.projectDir,
@@ -273536,7 +273762,7 @@ async function dispatchMusic(beat, ctx) {
     ctx.onProgress({ type: "music-failed", beatId: beat.id, error });
     return { status: "failed", error };
   }
-  await mkdir13(dirname28(cacheAbs), { recursive: true });
+  await mkdir14(dirname28(cacheAbs), { recursive: true });
   await copyFile4(abs, cacheAbs);
   await writeAssetMetadata({
     projectDir: ctx.projectDir,
@@ -273836,7 +274062,7 @@ async function finalizeBuildResult(projectDir, startedAt, result) {
     totalLatencyMs: Date.now() - startedAt
   };
   try {
-    await writeFile18(
+    await writeFile19(
       reportPath,
       JSON.stringify(toBuildReport(projectDir, withMeta), null, 2) + "\n",
       "utf-8"
@@ -274074,6 +274300,7 @@ var init_scene_build = __esm({
     init_transcribe_narration();
     init_scene_render();
     init_storyboard_parse();
+    init_storyboard_source();
     init_scene_project();
     init_build_plan();
     init_build_asset_reference();
@@ -274200,7 +274427,7 @@ __export(ai_audio_exports, {
   executeVoiceClone: () => executeVoiceClone
 });
 import { resolve as resolve41, dirname as dirname29, basename as basename9, extname as extname12 } from "node:path";
-import { readFile as readFile23, writeFile as writeFile19 } from "node:fs/promises";
+import { readFile as readFile20, writeFile as writeFile20 } from "node:fs/promises";
 import { existsSync as existsSync56 } from "node:fs";
 async function executeTranscribe(options) {
   const { audioPath, language, output: output3, format: format4, apiKey } = options;
@@ -274211,7 +274438,7 @@ async function executeTranscribe(options) {
     if (!existsSync56(absPath)) return { success: false, error: `File not found: ${absPath}` };
     const whisper = new WhisperProvider();
     await whisper.initialize({ apiKey: key2 });
-    const audioBuffer = await readFile23(absPath);
+    const audioBuffer = await readFile20(absPath);
     const audioBlob = new Blob([audioBuffer]);
     const result = await whisper.transcribe(audioBlob, language);
     if (result.status === "failed") {
@@ -274222,7 +274449,7 @@ async function executeTranscribe(options) {
       outputPath = resolve41(process.cwd(), output3);
       const fmt = detectFormat(output3, format4);
       const content = formatTranscript(result, fmt);
-      await writeFile19(outputPath, content, "utf-8");
+      await writeFile20(outputPath, content, "utf-8");
     }
     return {
       success: true,
@@ -274242,7 +274469,7 @@ async function executeIsolate(options) {
     if (!key2) return { success: false, error: "ELEVENLABS_API_KEY required" };
     const absPath = resolve41(process.cwd(), audioPath);
     if (!existsSync56(absPath)) return { success: false, error: `File not found: ${absPath}` };
-    const audioBuffer = await readFile23(absPath);
+    const audioBuffer = await readFile20(absPath);
     const elevenlabs = new ElevenLabsProvider();
     await elevenlabs.initialize({ apiKey: key2 });
     const result = await elevenlabs.isolateVocals(audioBuffer);
@@ -274250,7 +274477,7 @@ async function executeIsolate(options) {
       return { success: false, error: result.error || "Audio isolation failed" };
     }
     const outputPath = resolve41(process.cwd(), output3);
-    await writeFile19(outputPath, result.audioBuffer);
+    await writeFile20(outputPath, result.audioBuffer);
     return { success: true, outputPath };
   } catch (error) {
     return { success: false, error: `Audio isolation failed: ${error instanceof Error ? error.message : String(error)}` };
@@ -274268,7 +274495,7 @@ async function executeVoiceClone(options) {
     for (const samplePath of samplePaths) {
       const absPath = resolve41(process.cwd(), samplePath);
       if (!existsSync56(absPath)) return { success: false, error: `File not found: ${samplePath}` };
-      const buffer = await readFile23(absPath);
+      const buffer = await readFile20(absPath);
       audioBuffers.push(buffer);
     }
     const elevenlabs = new ElevenLabsProvider();
@@ -274306,7 +274533,7 @@ async function executeDub(options) {
     }
     const whisper = new WhisperProvider();
     await whisper.initialize({ apiKey: openaiKey });
-    const audioBuffer = await readFile23(audioPath);
+    const audioBuffer = await readFile20(audioPath);
     const audioBlob = new Blob([audioBuffer]);
     const transcriptResult = await whisper.transcribe(audioBlob, source3);
     if (transcriptResult.status === "failed" || !transcriptResult.segments) {
@@ -274361,7 +274588,7 @@ ${segmentTexts}`,
             translated: translatedSegments[i3]?.text || s2.text
           }))
         };
-        await writeFile19(timingPath, JSON.stringify(timingData, null, 2));
+        await writeFile20(timingPath, JSON.stringify(timingData, null, 2));
       }
       return {
         success: true,
@@ -274384,7 +274611,7 @@ ${segmentTexts}`,
     const outputExt = isVideo ? ".mp3" : extname12(absPath);
     const defaultOutputPath2 = resolve41(dirname29(absPath), `${basename9(absPath, extname12(absPath))}-${language}${outputExt}`);
     const finalOutputPath = resolve41(process.cwd(), output3 || defaultOutputPath2);
-    await writeFile19(finalOutputPath, combinedBuffer);
+    await writeFile20(finalOutputPath, combinedBuffer);
     if (isVideo && audioPath !== absPath) {
       try {
         const { unlink: unlink6 } = await import("node:fs/promises");
@@ -274449,7 +274676,7 @@ var init_ai_audio = __esm({
 
 // ../cli/src/commands/_shared/edit/silence-cut.ts
 import { existsSync as existsSync57 } from "node:fs";
-import { readFile as readFile24 } from "node:fs/promises";
+import { readFile as readFile21 } from "node:fs/promises";
 async function detectSilencePeriods(videoPath, noiseThreshold, minDuration) {
   const totalDuration = await getVideoDuration(videoPath);
   const { stdout, stderr } = await execSafe(
@@ -274499,7 +274726,7 @@ async function detectSilencePeriodsWithGemini(videoPath, minDuration, options) {
   }
   const gemini = new GeminiProvider();
   await gemini.initialize({ apiKey: geminiApiKey });
-  const videoBuffer = await readFile24(videoPath);
+  const videoBuffer = await readFile21(videoPath);
   const modelId = options.model ? resolveGeminiTextModel(options.model) : void 0;
   const prompt3 = `Analyze this video and identify all silent or dead segments where there is NO meaningful content.
 
@@ -274684,10 +274911,10 @@ var init_silence_cut = __esm({
 
 // ../cli/src/commands/_shared/edit/jump-cut.ts
 import { existsSync as existsSync58 } from "node:fs";
-import { readFile as readFile25, writeFile as writeFile20, mkdir as mkdir14 } from "node:fs/promises";
+import { readFile as readFile23, writeFile as writeFile21, mkdir as mkdir15 } from "node:fs/promises";
 import { join as join66 } from "node:path";
 async function transcribeWithWords(audioPath, apiKey, language) {
-  const audioBuffer = await readFile25(audioPath);
+  const audioBuffer = await readFile23(audioPath);
   const audioBlob = new Blob([audioBuffer]);
   const formData = new FormData();
   formData.append("file", audioBlob, "audio.wav");
@@ -274764,7 +274991,7 @@ async function executeJumpCut(options) {
   }
   try {
     const tmpDir = `/tmp/vibe_jumpcut_${Date.now()}`;
-    await mkdir14(tmpDir, { recursive: true });
+    await mkdir15(tmpDir, { recursive: true });
     const audioPath = join66(tmpDir, "audio.wav");
     try {
       await execSafe(
@@ -274843,7 +275070,7 @@ async function executeJumpCut(options) {
       }
       const concatList = segmentPaths.map((p2) => `file '${p2}'`).join("\n");
       const listPath = join66(tmpDir, "concat.txt");
-      await writeFile20(listPath, concatList);
+      await writeFile21(listPath, concatList);
       await execSafe(
         "ffmpeg",
         [
@@ -274870,8 +275097,8 @@ async function executeJumpCut(options) {
       };
     } finally {
       try {
-        const { rm: rm9 } = await import("node:fs/promises");
-        await rm9(tmpDir, { recursive: true, force: true });
+        const { rm: rm10 } = await import("node:fs/promises");
+        await rm10(tmpDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -274948,7 +275175,7 @@ __export(remotion_exports, {
   wrapComponentWithImage: () => wrapComponentWithImage,
   wrapComponentWithVideo: () => wrapComponentWithVideo
 });
-import { writeFile as writeFile21, mkdir as mkdir15, rm as rm6, copyFile as copyFile5 } from "node:fs/promises";
+import { writeFile as writeFile23, mkdir as mkdir16, rm as rm7, copyFile as copyFile5 } from "node:fs/promises";
 import { existsSync as existsSync59 } from "node:fs";
 import { join as join67 } from "node:path";
 import { tmpdir as tmpdir9 } from "node:os";
@@ -274970,7 +275197,7 @@ async function ensureRemotionInstalled() {
 }
 async function scaffoldRemotionProject(componentCode, componentName, opts) {
   const dir = join67(tmpdir9(), `vibe_motion_${Date.now()}`);
-  await mkdir15(dir, { recursive: true });
+  await mkdir16(dir, { recursive: true });
   const deps = {
     remotion: REMOTION_VERSION,
     "@remotion/cli": REMOTION_VERSION,
@@ -274988,7 +275215,7 @@ async function scaffoldRemotionProject(componentCode, componentName, opts) {
     dependencies: deps
   };
   const packageJsonStr = JSON.stringify(packageJson, null, 2);
-  await writeFile21(join67(dir, "package.json"), packageJsonStr);
+  await writeFile23(join67(dir, "package.json"), packageJsonStr);
   const tsconfig = {
     compilerOptions: {
       target: "ES2020",
@@ -275000,8 +275227,8 @@ async function scaffoldRemotionProject(componentCode, componentName, opts) {
       skipLibCheck: true
     }
   };
-  await writeFile21(join67(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2));
-  await writeFile21(join67(dir, "Component.tsx"), componentCode);
+  await writeFile23(join67(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2));
+  await writeFile23(join67(dir, "Component.tsx"), componentCode);
   const rootCode = `import { registerRoot, Composition } from "remotion";
 import { ${componentName} } from "./Component";
 
@@ -275020,7 +275247,7 @@ const Root = () => {
 
 registerRoot(Root);
 `;
-  await writeFile21(join67(dir, "Root.tsx"), rootCode);
+  await writeFile23(join67(dir, "Root.tsx"), rootCode);
   const depsHash = createHash11("md5").update(packageJsonStr).digest("hex").slice(0, 12);
   const cacheMarker = join67(REMOTION_CACHE_DIR, `.deps-${depsHash}`);
   const cachedModules = join67(REMOTION_CACHE_DIR, "node_modules");
@@ -275034,15 +275261,15 @@ registerRoot(Root);
   } else {
     await this_npmInstall(dir);
     try {
-      await mkdir15(REMOTION_CACHE_DIR, { recursive: true });
-      await writeFile21(join67(REMOTION_CACHE_DIR, "package.json"), packageJsonStr);
+      await mkdir16(REMOTION_CACHE_DIR, { recursive: true });
+      await writeFile23(join67(REMOTION_CACHE_DIR, "package.json"), packageJsonStr);
       if (existsSync59(join67(dir, "node_modules"))) {
-        const { rename: rename6, symlink: symlink4 } = await import("node:fs/promises");
-        await rename6(join67(dir, "node_modules"), cachedModules).catch(() => {
+        const { rename: rename7, symlink: symlink4 } = await import("node:fs/promises");
+        await rename7(join67(dir, "node_modules"), cachedModules).catch(() => {
         });
         await symlink4(cachedModules, join67(dir, "node_modules"), "dir").catch(() => {
         });
-        await writeFile21(cacheMarker, depsHash);
+        await writeFile23(cacheMarker, depsHash);
       }
     } catch {
     }
@@ -275142,7 +275369,7 @@ async function renderMotion(options) {
   stderr: ${stderr}` : ""}`);
     return { success: false, error: `Remotion render failed: ${msg}` };
   } finally {
-    await rm6(dir, { recursive: true, force: true }).catch(() => {
+    await rm7(dir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -275211,7 +275438,7 @@ async function renderWithEmbeddedImage(options) {
   );
   try {
     const publicDir = join67(dir, "public");
-    await mkdir15(publicDir, { recursive: true });
+    await mkdir16(publicDir, { recursive: true });
     await copyFile5(options.imagePath, join67(publicDir, options.imageFileName));
     const entryPoint = join67(dir, "Root.tsx");
     const mp4Out = options.outputPath.replace(/\.\w+$/, ".mp4");
@@ -275234,7 +275461,7 @@ async function renderWithEmbeddedImage(options) {
     const msg = error instanceof Error ? error.message : String(error);
     return { success: false, error: `Remotion image embed render failed: ${msg}` };
   } finally {
-    await rm6(dir, { recursive: true, force: true }).catch(() => {
+    await rm7(dir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -275275,7 +275502,7 @@ async function renderWithEmbeddedVideo(options) {
   );
   try {
     const publicDir = join67(dir, "public");
-    await mkdir15(publicDir, { recursive: true });
+    await mkdir16(publicDir, { recursive: true });
     await copyFile5(options.videoPath, join67(publicDir, options.videoFileName));
     const entryPoint = join67(dir, "Root.tsx");
     const mp4VideoOnly = options.outputPath.replace(/\.\w+$/, "_video_only.mp4");
@@ -275311,14 +275538,14 @@ async function renderWithEmbeddedVideo(options) {
       "-shortest",
       mp4Out
     ], { timeout: 12e4 });
-    await rm6(mp4VideoOnly, { force: true }).catch(() => {
+    await rm7(mp4VideoOnly, { force: true }).catch(() => {
     });
     return { success: true, outputPath: mp4Out };
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     return { success: false, error: `Remotion video embed render failed: ${msg}` };
   } finally {
-    await rm6(dir, { recursive: true, force: true }).catch(() => {
+    await rm7(dir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
@@ -275699,7 +275926,7 @@ var init_remotion = __esm({
 
 // ../cli/src/commands/_shared/edit/caption.ts
 import { existsSync as existsSync60 } from "node:fs";
-import { readFile as readFile26, writeFile as writeFile23, mkdir as mkdir16 } from "node:fs/promises";
+import { readFile as readFile24, writeFile as writeFile24, mkdir as mkdir17 } from "node:fs/promises";
 import { dirname as dirname30, basename as basename10, extname as extname13, join as join68 } from "node:path";
 function getCaptionForceStyle(style, fontSize, fontColor, position) {
   const alignment = position === "top" ? 8 : position === "center" ? 5 : 2;
@@ -275746,7 +275973,7 @@ async function executeCaption(options) {
   }
   try {
     const tmpDir = `/tmp/vibe_caption_${Date.now()}`;
-    await mkdir16(tmpDir, { recursive: true });
+    await mkdir17(tmpDir, { recursive: true });
     const audioPath = join68(tmpDir, "audio.wav");
     const srtPath = join68(tmpDir, "captions.srt");
     try {
@@ -275769,7 +275996,7 @@ async function executeCaption(options) {
       );
       const whisper = new WhisperProvider();
       await whisper.initialize({ apiKey: openaiKey });
-      const audioBuffer = await readFile26(audioPath);
+      const audioBuffer = await readFile24(audioPath);
       const audioBlob = new Blob([audioBuffer]);
       const transcriptResult = await whisper.transcribe(audioBlob, language);
       if (transcriptResult.status === "failed" || !transcriptResult.segments || transcriptResult.segments.length === 0) {
@@ -275779,7 +276006,7 @@ async function executeCaption(options) {
         };
       }
       const srtContent = formatSRT(transcriptResult.segments);
-      await writeFile23(srtPath, srtContent);
+      await writeFile24(srtPath, srtContent);
       const { width, height } = await getVideoResolution(videoPath);
       const fontSize = customFontSize || Math.round(height / 18);
       let hasSubtitles = false;
@@ -275821,7 +276048,7 @@ async function executeCaption(options) {
             outputDir2,
             basename10(outputPath, extname13(outputPath)) + ".srt"
           );
-          await writeFile23(outputSrtPath2, srtContent);
+          await writeFile24(outputSrtPath2, srtContent);
           return { success: false, error: `${remotionErr}
 SRT saved to: ${outputSrtPath2}` };
         }
@@ -275860,7 +276087,7 @@ SRT saved to: ${outputSrtPath2}` };
             outputDir2,
             basename10(outputPath, extname13(outputPath)) + ".srt"
           );
-          await writeFile23(outputSrtPath2, srtContent);
+          await writeFile24(outputSrtPath2, srtContent);
           return {
             success: false,
             error: `${renderResult.error}
@@ -275873,7 +276100,7 @@ SRT saved to: ${outputSrtPath2}`
         outputDir,
         basename10(outputPath, extname13(outputPath)) + ".srt"
       );
-      await writeFile23(outputSrtPath, srtContent);
+      await writeFile24(outputSrtPath, srtContent);
       return {
         success: true,
         outputPath,
@@ -275882,8 +276109,8 @@ SRT saved to: ${outputSrtPath2}`
       };
     } finally {
       try {
-        const { rm: rm9 } = await import("node:fs/promises");
-        await rm9(tmpDir, { recursive: true, force: true });
+        const { rm: rm10 } = await import("node:fs/promises");
+        await rm10(tmpDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -276044,7 +276271,7 @@ var init_fade = __esm({
 
 // ../cli/src/commands/_shared/edit/translate-srt.ts
 import { existsSync as existsSync64 } from "node:fs";
-import { readFile as readFile27, writeFile as writeFile24 } from "node:fs/promises";
+import { readFile as readFile25, writeFile as writeFile25 } from "node:fs/promises";
 async function executeTranslateSrt(options) {
   const {
     srtPath,
@@ -276058,7 +276285,7 @@ async function executeTranslateSrt(options) {
     return { success: false, error: `SRT file not found: ${srtPath}` };
   }
   try {
-    const srtContent = await readFile27(srtPath, "utf-8");
+    const srtContent = await readFile25(srtPath, "utf-8");
     const segments = parseSRT(srtContent);
     if (segments.length === 0) {
       return { success: false, error: "No subtitle segments found in SRT file" };
@@ -276148,7 +276375,7 @@ ${textsToTranslate}`;
       }
     }
     const translatedSrt = formatSRT(translatedSegments);
-    await writeFile24(outputPath, translatedSrt);
+    await writeFile25(outputPath, translatedSrt);
     return {
       success: true,
       outputPath,
@@ -277312,7 +277539,7 @@ var init_project_resolver = __esm({
 
 // ../cli/src/commands/_shared/execute-fill-gaps.ts
 import { existsSync as existsSync67 } from "node:fs";
-import { readFile as readFile28, writeFile as writeFile25, mkdir as mkdir17, rename as renameFs } from "node:fs/promises";
+import { readFile as readFile26, writeFile as writeFile26, mkdir as mkdir18, rename as renameFs } from "node:fs/promises";
 import { resolve as resolve46, dirname as dirname31 } from "node:path";
 function detectVideoGaps(videoClips, totalDuration) {
   const gaps = [];
@@ -277369,7 +277596,7 @@ function analyzeGapFillability(gaps, videoClips, sources) {
 }
 async function uploadFrameToImgbb(framePath, imgbbApiKey) {
   try {
-    const frameBuffer = await readFile28(framePath);
+    const frameBuffer = await readFile26(framePath);
     const frameBase64 = frameBuffer.toString("base64");
     const formData = new FormData();
     formData.append("key", imgbbApiKey);
@@ -277401,7 +277628,7 @@ async function executeFillGaps(options) {
         humanLines
       };
     }
-    const content = await readFile28(filePath, "utf-8");
+    const content = await readFile26(filePath, "utf-8");
     const data2 = JSON.parse(content);
     const project = Project.fromJSON(data2);
     const clips = project.getClips().sort((a4, b4) => a4.startTime - b4.startTime);
@@ -277530,7 +277757,7 @@ async function executeFillGaps(options) {
     const projectDir = dirname31(filePath);
     const footageDir = options.dir ? resolve46(process.cwd(), options.dir) : resolve46(projectDir, "footage");
     if (!existsSync67(footageDir)) {
-      await mkdir17(footageDir, { recursive: true });
+      await mkdir18(footageDir, { recursive: true });
     }
     humanLines.push("Generating AI Videos");
     const imgbbApiKey = options.imgbbApiKey || await getApiKey("IMGBB_API_KEY", "imgbb", void 0);
@@ -277624,7 +277851,7 @@ async function executeFillGaps(options) {
       const videoPath = resolve46(footageDir, videoFileName);
       onProgress("Downloading generated video...");
       const videoBuffer = await downloadVideo(finalResult.videoUrl);
-      await writeFile25(videoPath, videoBuffer);
+      await writeFile26(videoPath, videoBuffer);
       generatedDuration = finalResult.duration || parseInt(klingDuration);
       generatedVideos.push(videoPath);
       humanLines.push(`  Generated: ${videoFileName} (${generatedDuration}s)`);
@@ -277694,11 +277921,11 @@ async function executeFillGaps(options) {
           `gap-fill-${gap.start.toFixed(2)}-${gap.end.toFixed(2)}-seg${segmentIndex}.mp4`
         );
         const segVideoBuffer = await downloadVideo(segFinalResult.videoUrl);
-        await writeFile25(segVideoPath, segVideoBuffer);
+        await writeFile26(segVideoPath, segVideoBuffer);
         const concatListPath = resolve46(footageDir, `concat-${gap.start.toFixed(2)}.txt`);
         const concatList = generatedVideos.map((v4) => `file '${v4}'`).join("\n") + `
 file '${segVideoPath}'`;
-        await writeFile25(concatListPath, concatList);
+        await writeFile26(concatListPath, concatList);
         const concatOutputPath = resolve46(
           footageDir,
           `gap-fill-${gap.start.toFixed(2)}-${gap.end.toFixed(2)}-merged.mp4`
@@ -277756,7 +277983,7 @@ file '${segVideoPath}'`;
     let outputPath = filePath;
     if (generatedCount > 0) {
       outputPath = options.output ? resolve46(process.cwd(), options.output) : filePath;
-      await writeFile25(outputPath, JSON.stringify(project.toJSON(), null, 2));
+      await writeFile26(outputPath, JSON.stringify(project.toJSON(), null, 2));
       humanLines.push(`\u2714 Filled ${generatedCount} gap(s) with AI-generated video`);
       humanLines.push(`Project saved: ${outputPath}`);
     } else {
@@ -277850,7 +278077,7 @@ __export(ai_motion_exports, {
 });
 import { resolve as resolve47 } from "node:path";
 import { existsSync as existsSync68 } from "node:fs";
-import { readFile as readFile29, writeFile as writeFile26 } from "node:fs/promises";
+import { readFile as readFile27, writeFile as writeFile27 } from "node:fs/promises";
 async function getOptionalGoogleApiKey() {
   const configKey = await getApiKeyFromConfig("google");
   if (configKey) return configKey;
@@ -277897,7 +278124,7 @@ async function executeMotion(options) {
       };
     }
     const imagePath = resolve47(process.cwd(), options.image);
-    const imageBuffer = await readFile29(imagePath);
+    const imageBuffer = await readFile27(imagePath);
     const gemini = new GeminiProvider();
     await gemini.initialize({ apiKey: geminiApiKey });
     const analysisResult = await gemini.analyzeImage(
@@ -277934,7 +278161,7 @@ Use this image analysis to inform the color palette, typography placement, and o
     }
     if (geminiApiKey) {
       const videoPath = resolve47(process.cwd(), options.video);
-      const videoBuffer = await readFile29(videoPath);
+      const videoBuffer = await readFile27(videoPath);
       const gemini = new GeminiProvider();
       await gemini.initialize({ apiKey: geminiApiKey });
       const analysisPrompt = options.understandingPrompt || `Analyze this video for motion graphics composition. Return concise production guidance:
@@ -277968,7 +278195,7 @@ Use this video understanding to place motion graphics in safe zones, match the c
     if (!existsSync68(tsxPath)) {
       return { success: false, error: `TSX file not found: ${tsxPath}` };
     }
-    const existingCode = await readFile29(tsxPath, "utf-8");
+    const existingCode = await readFile27(tsxPath, "utf-8");
     if (useGemini) {
       const gemini = new GeminiProvider();
       await gemini.initialize({ apiKey });
@@ -278020,7 +278247,7 @@ Use this video understanding to place motion graphics in safe zones, match the c
   const defaultOutput = options.video || options.image ? "motion-output.mp4" : options.render ? "motion.webm" : "motion.tsx";
   const outputPath = resolve47(process.cwd(), options.output || defaultOutput);
   const codePath = outputPath.replace(/\.\w+$/, ".tsx");
-  await writeFile26(codePath, component.code, "utf-8");
+  await writeFile27(codePath, component.code, "utf-8");
   const shouldRender = options.render || !!options.video || !!options.image;
   if (!shouldRender) {
     return { success: true, codePath, componentName: component.name };
@@ -278499,7 +278726,7 @@ __export(project_builder_exports, {
   buildTempProject: () => buildTempProject,
   resolveSourceUrl: () => resolveSourceUrl
 });
-import { mkdtemp as mkdtemp5, mkdir as mkdir18, copyFile as copyFile6, writeFile as writeFile27, rm as rm7, readdir as readdir6 } from "node:fs/promises";
+import { mkdtemp as mkdtemp5, mkdir as mkdir19, copyFile as copyFile6, writeFile as writeFile28, rm as rm8, readdir as readdir7 } from "node:fs/promises";
 import { existsSync as existsSync69 } from "node:fs";
 import { tmpdir as tmpdir10 } from "node:os";
 import { createRequire as createRequire4 } from "node:module";
@@ -278507,7 +278734,7 @@ import * as path15 from "node:path";
 async function buildTempProject(state, projectFileDir) {
   const dir = await mkdtemp5(path15.join(tmpdir10(), "vibeframe-hf-"));
   const assetsDir = path15.join(dir, "assets");
-  await mkdir18(assetsDir, { recursive: true });
+  await mkdir19(assetsDir, { recursive: true });
   const copied = /* @__PURE__ */ new Map();
   for (const source3 of state.sources) {
     if (copied.has(source3.id)) continue;
@@ -278523,10 +278750,10 @@ async function buildTempProject(state, projectFileDir) {
     await copyLottieRuntime(dir);
   }
   const html = generateCompositionHtml(state);
-  await writeFile27(path15.join(dir, "index.html"), html, "utf-8");
+  await writeFile28(path15.join(dir, "index.html"), html, "utf-8");
   return {
     dir,
-    cleanup: () => rm7(dir, { recursive: true, force: true })
+    cleanup: () => rm8(dir, { recursive: true, force: true })
   };
 }
 async function copyLottieRuntime(tempDir) {
@@ -278537,8 +278764,8 @@ async function copyLottieRuntime(tempDir) {
   const wasmSrc = path15.join(path15.dirname(webEntry), "dotlottie-player.wasm");
   const vendorDir = path15.join(tempDir, "vendor");
   const wcDest = path15.join(vendorDir, "dotlottie-wc");
-  await mkdir18(wcDest, { recursive: true });
-  for (const file of await readdir6(wcDistDir)) {
+  await mkdir19(wcDest, { recursive: true });
+  for (const file of await readdir7(wcDistDir)) {
     if (file.endsWith(".map") || file.endsWith(".d.ts")) continue;
     await copyFile6(path15.join(wcDistDir, file), path15.join(wcDest, file));
   }
@@ -278645,7 +278872,7 @@ __export(motion_overlay_exports, {
   executeMotionOverlay: () => executeMotionOverlay,
   registerMotionOverlayCommand: () => registerMotionOverlayCommand
 });
-import { mkdir as mkdir19 } from "node:fs/promises";
+import { mkdir as mkdir20 } from "node:fs/promises";
 import { existsSync as existsSync70 } from "node:fs";
 import { basename as basename13, dirname as dirname33, extname as extname15, resolve as resolve49 } from "node:path";
 function normalizeUnderstand2(value) {
@@ -278793,7 +279020,7 @@ async function executeMotionOverlay(options) {
     const scale = Math.max(0.01, Math.min(2, numberOption(options.scale, position === "full" ? 1 : 0.25)));
     const opacity = Math.max(0, Math.min(1, numberOption(options.opacity, 1)));
     const loop = options.loop ?? true;
-    await mkdir19(dirname33(outputPath), { recursive: true });
+    await mkdir20(dirname33(outputPath), { recursive: true });
     const backend = createHyperframesBackend();
     const result2 = await backend.render({
       projectState: buildLottieTimelineState({
@@ -278819,7 +279046,7 @@ async function executeMotionOverlay(options) {
     return { success: true, outputPath, provider: "lottie" };
   }
   const duration = options.duration ?? await ffprobeDuration(absVideo).catch(() => void 0);
-  await mkdir19(dirname33(outputPath), { recursive: true });
+  await mkdir20(dirname33(outputPath), { recursive: true });
   const result = await executeMotion({
     description: options.description.trim(),
     video: absVideo,
@@ -278948,7 +279175,7 @@ __export(edit_cmd_exports, {
   executeUpscale: () => executeUpscale
 });
 import { resolve as resolve50, dirname as dirname34 } from "node:path";
-import { readFile as readFile30, writeFile as writeFile28, mkdir as mkdir20 } from "node:fs/promises";
+import { readFile as readFile28, writeFile as writeFile29, mkdir as mkdir21 } from "node:fs/promises";
 async function executeGrade(options) {
   const { videoPath, style, preset: preset3, output: output3, analyzeOnly, apiKey } = options;
   try {
@@ -278989,7 +279216,7 @@ async function executeSpeedRamp(options) {
     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 readFile30(tempAudio);
+    const audioBuffer = await readFile28(tempAudio);
     const transcript = await whisper.transcribe(new Blob([audioBuffer]), language);
     try {
       const { unlink: unlink6 } = await import("node:fs/promises");
@@ -279383,7 +279610,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 readFile30(tempAudio);
+        const audioBuffer = await readFile28(tempAudio);
         const audioBlob = new Blob([audioBuffer]);
         const transcript = await whisper.transcribe(audioBlob, options.language);
         if (!transcript.segments || transcript.segments.length === 0) {
@@ -279516,7 +279743,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         for (let i3 = 1; i3 <= numKeyframes && i3 <= 30; i3++) {
           const framePath = `${tempDir}/frame-${i3.toString().padStart(4, "0")}.jpg`;
           try {
-            const frameBuffer = await readFile30(framePath);
+            const frameBuffer = await readFile28(framePath);
             const frameBase64 = frameBuffer.toString("base64");
             const result = await claude.analyzeFrameForReframe(frameBase64, options.aspect, {
               focusMode: options.focus,
@@ -279576,7 +279803,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         console.log();
         if (options.keyframes) {
           const keyframesPath = resolve50(process.cwd(), options.keyframes);
-          await writeFile28(keyframesPath, JSON.stringify(cropKeyframes, null, 2));
+          await writeFile29(keyframesPath, JSON.stringify(cropKeyframes, null, 2));
           console.log(source_default.green(`Keyframes saved to: ${keyframesPath}`));
         }
         if (options.analyzeOnly) {
@@ -279645,7 +279872,7 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         const imageBuffers = [];
         for (const imagePath of imagePaths) {
           const absPath = resolve50(process.cwd(), imagePath);
-          const buffer = await readFile30(absPath);
+          const buffer = await readFile28(absPath);
           imageBuffers.push(buffer);
         }
         let result;
@@ -279695,14 +279922,14 @@ Run 'vibe schema edit.<command>' for structured parameter info.
         const img = result.images[0];
         const outputPath = resolve50(process.cwd(), options.output);
         const saveImage = async () => {
-          await mkdir20(dirname34(outputPath), { recursive: true });
+          await mkdir21(dirname34(outputPath), { recursive: true });
           if (img.base64) {
             const buffer = Buffer.from(img.base64, "base64");
-            await writeFile28(outputPath, buffer);
+            await writeFile29(outputPath, buffer);
           } else if (img.url) {
             const resp = await fetch(img.url);
             const arrayBuf = await resp.arrayBuffer();
-            await writeFile28(outputPath, Buffer.from(arrayBuf));
+            await writeFile29(outputPath, Buffer.from(arrayBuf));
           }
         };
         const resultModel = result.model;
@@ -279922,8 +280149,8 @@ __export(ai_image_exports, {
   executeThumbnailBestFrame: () => executeThumbnailBestFrame
 });
 import { resolve as resolve53, dirname as dirname36 } from "node:path";
-import { readFile as readFile31, writeFile as writeFile30, mkdir as mkdir23 } from "node:fs/promises";
-import { existsSync as existsSync72 } from "node:fs";
+import { readFile as readFile29, writeFile as writeFile31, mkdir as mkdir24 } from "node:fs/promises";
+import { existsSync as existsSync73 } from "node:fs";
 async function executeImageGenerate(options) {
   const {
     prompt: prompt3,
@@ -279965,8 +280192,8 @@ async function executeImageGenerate(options) {
           return { success: false, error: "No image data available" };
         }
         outputPath = resolve53(process.cwd(), output3);
-        await mkdir23(dirname36(outputPath), { recursive: true });
-        await writeFile30(outputPath, buffer);
+        await mkdir24(dirname36(outputPath), { recursive: true });
+        await writeFile31(outputPath, buffer);
       }
       return {
         success: true,
@@ -280000,8 +280227,8 @@ async function executeImageGenerate(options) {
         const img = result.images[0];
         if (img.base64) {
           outputPath = resolve53(process.cwd(), output3);
-          await mkdir23(dirname36(outputPath), { recursive: true });
-          await writeFile30(outputPath, Buffer.from(img.base64, "base64"));
+          await mkdir24(dirname36(outputPath), { recursive: true });
+          await writeFile31(outputPath, Buffer.from(img.base64, "base64"));
         }
       }
       return {
@@ -280036,8 +280263,8 @@ async function executeImageGenerate(options) {
           return { success: false, error: "No image data available" };
         }
         outputPath = resolve53(process.cwd(), output3);
-        await mkdir23(dirname36(outputPath), { recursive: true });
-        await writeFile30(outputPath, buffer);
+        await mkdir24(dirname36(outputPath), { recursive: true });
+        await writeFile31(outputPath, buffer);
       }
       return {
         success: true,
@@ -280067,10 +280294,10 @@ async function executeGeminiEdit(options) {
     const imageBuffers = [];
     for (const imagePath of imagePaths) {
       const absPath = resolve53(process.cwd(), imagePath);
-      if (!existsSync72(absPath)) {
+      if (!existsSync73(absPath)) {
         return { success: false, error: `Image not found: ${absPath}` };
       }
-      const buffer = await readFile31(absPath);
+      const buffer = await readFile29(absPath);
       imageBuffers.push(buffer);
     }
     const gemini = new GeminiProvider();
@@ -280095,8 +280322,8 @@ async function executeGeminiEdit(options) {
     let outputPath;
     if (img.base64) {
       outputPath = resolve53(process.cwd(), output3);
-      await mkdir23(dirname36(outputPath), { recursive: true });
-      await writeFile30(outputPath, Buffer.from(img.base64, "base64"));
+      await mkdir24(dirname36(outputPath), { recursive: true });
+      await writeFile31(outputPath, Buffer.from(img.base64, "base64"));
     }
     return {
       success: true,
@@ -280115,7 +280342,7 @@ async function executeThumbnailBestFrame(options) {
     model = "flash",
     apiKey
   } = options;
-  if (!existsSync72(videoPath)) {
+  if (!existsSync73(videoPath)) {
     return { success: false, error: `Video not found: ${videoPath}` };
   }
   if (!commandExists("ffmpeg")) {
@@ -280128,7 +280355,7 @@ async function executeThumbnailBestFrame(options) {
   try {
     const gemini = new GeminiProvider();
     await gemini.initialize({ apiKey: googleKey });
-    const videoData = await readFile31(videoPath);
+    const videoData = await readFile29(videoPath);
     const analysisPrompt = prompt3 || 'Analyze this video and find the single best frame for a thumbnail. Look for frames that are visually striking, well-composed, emotionally engaging, and representative of the video content. Avoid blurry frames, transitions, or dark scenes. Return ONLY a JSON object: {"timestamp": <seconds as number>, "reason": "<brief explanation>"}';
     const modelId = resolveGeminiTextModel(model);
     const result = await gemini.analyzeVideo(videoData, analysisPrompt, {
@@ -280149,7 +280376,7 @@ async function executeThumbnailBestFrame(options) {
       reason = reasonMatch[1];
     }
     await execSafe("ffmpeg", ["-ss", String(timestamp), "-i", videoPath, "-frames:v", "1", "-q:v", "2", outputPath, "-y"], { timeout: 6e4, maxBuffer: 50 * 1024 * 1024 });
-    if (!existsSync72(outputPath)) {
+    if (!existsSync73(outputPath)) {
       return { success: false, error: "FFmpeg failed to extract frame" };
     }
     return {
@@ -280180,9 +280407,9 @@ __export(ai_analyze_exports, {
   executeGeminiVideo: () => executeGeminiVideo,
   registerAnalyzeCommands: () => registerAnalyzeCommands
 });
-import { readFile as readFile33 } from "node:fs/promises";
+import { readFile as readFile30 } from "node:fs/promises";
 import { extname as extname16, resolve as resolve54 } from "node:path";
-import { existsSync as existsSync73 } from "node:fs";
+import { existsSync as existsSync74 } from "node:fs";
 async function executeGeminiVideo(options) {
   try {
     const apiKey = await getApiKey("GOOGLE_API_KEY", "Google");
@@ -280196,10 +280423,10 @@ async function executeGeminiVideo(options) {
       videoData = options.source;
     } else {
       const absPath = resolve54(process.cwd(), options.source);
-      if (!existsSync73(absPath)) {
+      if (!existsSync74(absPath)) {
         return { success: false, error: `File not found: ${absPath}` };
       }
-      videoData = await readFile33(absPath);
+      videoData = await readFile30(absPath);
     }
     const gemini = new GeminiProvider();
     await gemini.initialize({ apiKey });
@@ -280264,10 +280491,10 @@ async function executeAnalyze(options) {
         imageBuffer = Buffer.from(await response.arrayBuffer());
       } else {
         const absPath = resolve54(process.cwd(), source3);
-        if (!existsSync73(absPath)) {
+        if (!existsSync74(absPath)) {
           return { success: false, error: `File not found: ${absPath}` };
         }
-        imageBuffer = await readFile33(absPath);
+        imageBuffer = await readFile30(absPath);
       }
       const result2 = await gemini.analyzeImage(imageBuffer, options.prompt, {
         model: modelId,
@@ -280299,10 +280526,10 @@ async function executeAnalyze(options) {
       videoData = Buffer.from(await response.arrayBuffer());
     } else {
       const absPath = resolve54(process.cwd(), source3);
-      if (!existsSync73(absPath)) {
+      if (!existsSync74(absPath)) {
         return { success: false, error: `File not found: ${absPath}` };
       }
-      videoData = await readFile33(absPath);
+      videoData = await readFile30(absPath);
     }
     const result = await gemini.analyzeVideo(videoData, options.prompt, {
       model: modelId,
@@ -280435,9 +280662,9 @@ var ai_review_exports = {};
 __export(ai_review_exports, {
   executeReview: () => executeReview
 });
-import { readFile as readFile36, rename as rename5 } from "node:fs/promises";
+import { readFile as readFile34, rename as rename6 } from "node:fs/promises";
 import { resolve as resolve57 } from "node:path";
-import { existsSync as existsSync75 } from "node:fs";
+import { existsSync as existsSync76 } from "node:fs";
 function parseReviewFeedback(response) {
   let cleaned = response.trim();
   if (cleaned.startsWith("```json")) {
@@ -280469,7 +280696,7 @@ async function executeReview(options) {
     model = "flash"
   } = options;
   const absVideoPath = resolve57(process.cwd(), videoPath);
-  if (!existsSync75(absVideoPath)) {
+  if (!existsSync76(absVideoPath)) {
     return { success: false, error: `Video not found: ${absVideoPath}` };
   }
   const apiKey = process.env.GOOGLE_API_KEY || await getApiKey("GOOGLE_API_KEY", "Google");
@@ -280482,8 +280709,8 @@ async function executeReview(options) {
   let storyboardContext = "";
   if (storyboardPath) {
     const absStoryboardPath = resolve57(process.cwd(), storyboardPath);
-    if (existsSync75(absStoryboardPath)) {
-      const content = await readFile36(absStoryboardPath, "utf-8");
+    if (existsSync76(absStoryboardPath)) {
+      const content = await readFile34(absStoryboardPath, "utf-8");
       storyboardContext = `
 
 Original storyboard for reference:
@@ -280525,7 +280752,7 @@ ${projectContext}` : "";
 Score each category 1-10. Prefer beatIssues when you can map a problem to a storyboard beat or timestamp. Use the exact beatId values from the storyboard or beat timing summary, and include timeRange in seconds for every localized finding. In particular, flag narration/visual mismatches, overly static holds, and audio-visual sync problems as beatIssues. Use category issue arrays only for problems that cannot be localized to a beat. For fixable issues, provide an FFmpeg filter in autoFixable. Be specific and practical.${storyboardContext}${extraProjectContext}`;
   const gemini = new GeminiProvider();
   await gemini.initialize({ apiKey });
-  const videoData = await readFile36(absVideoPath);
+  const videoData = await readFile34(absVideoPath);
   const analysisResult = await gemini.analyzeVideo(videoData, reviewPrompt, {
     model: modelId
   });
@@ -280572,7 +280799,7 @@ Score each category 1-10. Prefer beatIssues when you can map a problem to a stor
     if (currentInput !== absVideoPath) {
       const finalOutput = outputBase;
       try {
-        await rename5(currentInput, finalOutput);
+        await rename6(currentInput, finalOutput);
         result.outputPath = finalOutput;
       } catch {
         result.outputPath = currentInput;
@@ -280580,7 +280807,7 @@ Score each category 1-10. Prefer beatIssues when you can map a problem to a stor
     }
   }
   if (verify && result.outputPath) {
-    const verifyVideoData = await readFile36(result.outputPath);
+    const verifyVideoData = await readFile34(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>}',
@@ -280611,7 +280838,7 @@ var init_ai_review = __esm({
 
 // ../cli/src/commands/generate/sound-effect.ts
 import { resolve as resolve60 } from "node:path";
-import { writeFile as writeFile33 } from "node:fs/promises";
+import { writeFile as writeFile34 } from "node:fs/promises";
 async function executeSoundEffect(options) {
   try {
     const apiKey = await getConfiguredApiKey("ELEVENLABS_API_KEY");
@@ -280636,7 +280863,7 @@ async function executeSoundEffect(options) {
       process.cwd(),
       options.output || "sound-effect.mp3"
     );
-    await writeFile33(outputPath, result.audioBuffer);
+    await writeFile34(outputPath, result.audioBuffer);
     return { success: true, outputPath };
   } catch (error) {
     return {
@@ -280688,7 +280915,7 @@ function registerSoundEffectCommand(parent) {
         );
       }
       const outputPath = resolve60(process.cwd(), options.output);
-      await writeFile33(outputPath, result.audioBuffer);
+      await writeFile34(outputPath, result.audioBuffer);
       spinner2.succeed(source_default.green("Sound effect generated"));
       if (isJsonMode()) {
         outputSuccess({
@@ -280855,7 +281082,7 @@ var init_tty = __esm({
 
 // ../cli/src/commands/generate/speech.ts
 import { resolve as resolve61 } from "node:path";
-import { writeFile as writeFile34 } from "node:fs/promises";
+import { writeFile as writeFile35 } from "node:fs/promises";
 async function executeSpeech(options) {
   try {
     const apiKey = await getConfiguredApiKey("ELEVENLABS_API_KEY");
@@ -280873,7 +281100,7 @@ async function executeSpeech(options) {
       return { success: false, error: result.error || "TTS generation failed" };
     }
     const outputPath = resolve61(process.cwd(), options.output || "output.mp3");
-    await writeFile34(outputPath, result.audioBuffer);
+    await writeFile35(outputPath, result.audioBuffer);
     return { success: true, outputPath, characterCount: result.characterCount };
   } catch (error) {
     return {
@@ -280947,8 +281174,8 @@ var init_speech = __esm({
 
 // ../cli/src/commands/generate/thumbnail.ts
 import { resolve as resolve63, dirname as dirname37, basename as basename17, extname as extname17 } from "node:path";
-import { existsSync as existsSync77 } from "node:fs";
-import { writeFile as writeFile35, mkdir as mkdir24 } from "node:fs/promises";
+import { existsSync as existsSync78 } from "node:fs";
+import { writeFile as writeFile36, mkdir as mkdir25 } from "node:fs/promises";
 function registerThumbnailCommand(parent) {
   parent.command("thumbnail").description("Generate video thumbnail (DALL-E) or extract best frame from video (Gemini)").argument("[description]", "Thumbnail description (for DALL-E generation)").option("-k, --api-key <key>", "API key (OpenAI for generation, Google for best-frame)").option("-o, --output <path>", "Output file path").option("--style <style>", "Platform style: youtube, instagram, tiktok, twitter").option("--best-frame <video>", "Extract best thumbnail frame from video using Gemini AI").option("--prompt <prompt>", "Custom prompt for best-frame analysis").option("--model <model>", `Gemini model: ${GEMINI_TEXT_MODEL_HELP}`, "flash").action(async (description, options) => {
     const startedAt = Date.now();
@@ -280959,7 +281186,7 @@ function registerThumbnailCommand(parent) {
       }
       if (options.bestFrame) {
         const absVideoPath = resolve63(process.cwd(), options.bestFrame);
-        if (!existsSync77(absVideoPath)) {
+        if (!existsSync78(absVideoPath)) {
           exitWithError(notFoundError(absVideoPath));
         }
         if (!commandExists("ffmpeg")) {
@@ -281039,8 +281266,8 @@ function registerThumbnailCommand(parent) {
             throw new Error("No image data available");
           }
           outputPath = resolve63(process.cwd(), options.output);
-          await mkdir24(dirname37(outputPath), { recursive: true });
-          await writeFile35(outputPath, buffer);
+          await mkdir25(dirname37(outputPath), { recursive: true });
+          await writeFile36(outputPath, buffer);
         }
         outputSuccess({
           command: "generate thumbnail",
@@ -281070,8 +281297,8 @@ function registerThumbnailCommand(parent) {
             throw new Error("No image data available");
           }
           const outputPath = resolve63(process.cwd(), options.output);
-          await mkdir24(dirname37(outputPath), { recursive: true });
-          await writeFile35(outputPath, buffer);
+          await mkdir25(dirname37(outputPath), { recursive: true });
+          await writeFile36(outputPath, buffer);
           saveSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
         } catch {
           saveSpinner.fail(source_default.red("Failed to save thumbnail"));
@@ -281099,7 +281326,7 @@ var init_thumbnail = __esm({
 
 // ../cli/src/commands/generate/video-extend.ts
 import { resolve as resolve64 } from "node:path";
-import { writeFile as writeFile36 } from "node:fs/promises";
+import { writeFile as writeFile37 } from "node:fs/promises";
 function registerVideoExtendCommand(parent) {
   parent.command("video-extend", { hidden: true }).description("Extend video duration (Kling by video ID, Veo by operation name)").argument("<id>", "Kling video ID or Veo operation name").option("-p, --provider <provider>", "Provider: kling, veo", "kling").option("-k, --api-key <key>", "API key (KLING_API_KEY or GOOGLE_API_KEY)").option("-o, --output <path>", "Output file path").option("--prompt <text>", "Continuation prompt").option("-d, --duration <sec>", "Duration: 5 or 10 (Kling), 4/6/8 (Veo)", "5").option("--negative <prompt>", "Negative prompt (what to avoid, Kling only)").option("--veo-model <model>", "Veo model: 3.0, 3.1, 3.1-fast", "3.1").option("--no-wait", "Start extension and return task ID without waiting").option("--dry-run", "Preview parameters without executing").action(async (id, options) => {
     const startedAt = Date.now();
@@ -281176,7 +281403,7 @@ function registerVideoExtendCommand(parent) {
           if (options.output && finalResult.videoUrl) {
             const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
             outputPath = resolve64(process.cwd(), options.output);
-            await writeFile36(outputPath, buffer);
+            await writeFile37(outputPath, buffer);
           }
           outputSuccess({
             command: "generate video-extend",
@@ -281204,7 +281431,7 @@ function registerVideoExtendCommand(parent) {
           try {
             const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
             const outputPath = resolve64(process.cwd(), options.output);
-            await writeFile36(outputPath, buffer);
+            await writeFile37(outputPath, buffer);
             downloadSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
           } catch (err) {
             downloadSpinner.fail(
@@ -281265,7 +281492,7 @@ function registerVideoExtendCommand(parent) {
           if (options.output && finalResult.videoUrl) {
             const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
             outputPath = resolve64(process.cwd(), options.output);
-            await writeFile36(outputPath, buffer);
+            await writeFile37(outputPath, buffer);
           }
           outputSuccess({
             command: "generate video-extend",
@@ -281290,7 +281517,7 @@ function registerVideoExtendCommand(parent) {
           try {
             const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
             const outputPath = resolve64(process.cwd(), options.output);
-            await writeFile36(outputPath, buffer);
+            await writeFile37(outputPath, buffer);
             downloadSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
           } catch (err) {
             downloadSpinner.fail(
@@ -281414,7 +281641,7 @@ var init_openai_image2 = __esm({
 // ../cli/src/commands/generate/image.ts
 import { resolve as resolve65, dirname as dirname38 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
-import { writeFile as writeFile37, mkdir as mkdir25 } from "node:fs/promises";
+import { writeFile as writeFile38, mkdir as mkdir26 } 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>",
@@ -281551,8 +281778,8 @@ Examples:
             } else {
               throw new Error("No image data available");
             }
-            await mkdir25(dirname38(outputPath), { recursive: true });
-            await writeFile37(outputPath, buffer);
+            await mkdir26(dirname38(outputPath), { recursive: true });
+            await writeFile38(outputPath, buffer);
           }
           outputSuccess({
             command: "generate image",
@@ -281598,8 +281825,8 @@ Examples:
               throw new Error("No image data available");
             }
             const outputPath = resolve65(process.cwd(), options.output);
-            await mkdir25(dirname38(outputPath), { recursive: true });
-            await writeFile37(outputPath, buffer);
+            await mkdir26(dirname38(outputPath), { recursive: true });
+            await writeFile38(outputPath, buffer);
             saveSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
           } catch (err) {
             saveSpinner.fail(
@@ -281673,8 +281900,8 @@ Examples:
           if (outputPath && result.images.length > 0) {
             const img = result.images[0];
             const buffer = Buffer.from(img.base64, "base64");
-            await mkdir25(dirname38(outputPath), { recursive: true });
-            await writeFile37(outputPath, buffer);
+            await mkdir26(dirname38(outputPath), { recursive: true });
+            await writeFile38(outputPath, buffer);
           }
           outputSuccess({
             command: "generate image",
@@ -281706,8 +281933,8 @@ Examples:
             const img = result.images[0];
             const buffer = Buffer.from(img.base64, "base64");
             const outputPath = resolve65(process.cwd(), options.output);
-            await mkdir25(dirname38(outputPath), { recursive: true });
-            await writeFile37(outputPath, buffer);
+            await mkdir26(dirname38(outputPath), { recursive: true });
+            await writeFile38(outputPath, buffer);
             saveSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
           } catch (err) {
             saveSpinner.fail(
@@ -281766,8 +281993,8 @@ Examples:
             } else {
               throw new Error("No image data available");
             }
-            await mkdir25(dirname38(outputPath), { recursive: true });
-            await writeFile37(outputPath, buffer);
+            await mkdir26(dirname38(outputPath), { recursive: true });
+            await writeFile38(outputPath, buffer);
           }
           outputSuccess({
             command: "generate image",
@@ -281807,8 +282034,8 @@ Examples:
               throw new Error("No image data available");
             }
             const outputPath = resolve65(process.cwd(), options.output);
-            await mkdir25(dirname38(outputPath), { recursive: true });
-            await writeFile37(outputPath, buffer);
+            await mkdir26(dirname38(outputPath), { recursive: true });
+            await writeFile38(outputPath, buffer);
             saveSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
           } catch (err) {
             saveSpinner.fail(
@@ -282838,7 +283065,7 @@ var init_dist5 = __esm({
 
 // ../cli/src/commands/generate/video.ts
 import { resolve as resolve66 } from "node:path";
-import { readFile as readFile38, writeFile as writeFile38 } from "node:fs/promises";
+import { readFile as readFile36, writeFile as writeFile39 } from "node:fs/promises";
 function registerVideoCommand(parent) {
   parent.command("video").alias("vid").description("Generate video using AI (Seedance, Grok, Kling, Runway, Veo, or Gemini Omni)").argument("[prompt]", "Text prompt describing the video (interactive if omitted)").option(
     "-p, --provider <provider>",
@@ -282950,7 +283177,7 @@ Examples:
       let isImageToVideo = false;
       if (options.image) {
         const imagePath = resolve66(process.cwd(), options.image);
-        const imageBuffer = await readFile38(imagePath);
+        const imageBuffer = await readFile36(imagePath);
         const ext = options.image.toLowerCase().split(".").pop();
         const mimeTypes = {
           jpg: "image/jpeg",
@@ -283192,7 +283419,7 @@ Examples:
         let lastFrame;
         if (options.lastFrame) {
           const lastFramePath = resolve66(process.cwd(), options.lastFrame);
-          const lastFrameBuffer = await readFile38(lastFramePath);
+          const lastFrameBuffer = await readFile36(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")}`;
@@ -283202,7 +283429,7 @@ Examples:
           refImages = [];
           for (const refPath of options.refImages.slice(0, 3)) {
             const absRefPath = resolve66(process.cwd(), refPath);
-            const refBuffer = await readFile38(absRefPath);
+            const refBuffer = await readFile36(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 });
@@ -283334,7 +283561,7 @@ Examples:
         if (seedanceEndImagePath && seedanceReferences.length === 0) {
           try {
             const absEndImagePath = resolve66(process.cwd(), seedanceEndImagePath);
-            const endImageBuffer = await readFile38(absEndImagePath);
+            const endImageBuffer = await readFile36(absEndImagePath);
             const ext = seedanceEndImagePath.toLowerCase().split(".").pop();
             const mimeType = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : `image/${ext || "png"}`;
             const uploadHost = await resolveUploadHost();
@@ -283390,7 +283617,7 @@ Examples:
         if (options.output && finalResult.videoUrl) {
           const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
           outputPath = resolve66(process.cwd(), options.output);
-          await writeFile38(outputPath, buffer);
+          await writeFile39(outputPath, buffer);
         }
         outputSuccess({
           command: "generate video",
@@ -283418,7 +283645,7 @@ Examples:
         try {
           const buffer = await downloadVideo(finalResult.videoUrl, apiKey);
           const outputPath = resolve66(process.cwd(), options.output);
-          await writeFile38(outputPath, buffer);
+          await writeFile39(outputPath, buffer);
           downloadSpinner.succeed(source_default.green(`Saved to: ${outputPath}`));
         } catch (err) {
           downloadSpinner.fail(
@@ -283461,7 +283688,7 @@ async function fileInputToUrlOrDataUri2(input3, fallbackMimeType) {
     return input3;
   }
   const absPath = resolve66(process.cwd(), input3);
-  const buffer = await readFile38(absPath);
+  const buffer = await readFile36(absPath);
   return `data:${mimeTypeForPath2(input3, fallbackMimeType)};base64,${buffer.toString("base64")}`;
 }
 function mimeTypeForPath2(path16, fallback2) {
@@ -283542,7 +283769,7 @@ var init_sanitize = __esm({
 
 // ../cli/src/commands/generate/storyboard.ts
 import { resolve as resolve67 } from "node:path";
-import { writeFile as writeFile39 } from "node:fs/promises";
+import { writeFile as writeFile40 } from "node:fs/promises";
 async function executeStoryboard(options) {
   const { content, duration, creativity = "low", output: output3, apiKey } = options;
   try {
@@ -283561,7 +283788,7 @@ async function executeStoryboard(options) {
     let outputPath;
     if (output3) {
       outputPath = resolve67(process.cwd(), output3);
-      await writeFile39(outputPath, JSON.stringify(segments, null, 2), "utf-8");
+      await writeFile40(outputPath, JSON.stringify(segments, null, 2), "utf-8");
     }
     return { success: true, segments, segmentCount: segments.length, outputPath };
   } catch (error) {
@@ -302590,7 +302817,7 @@ __export(detect_exports, {
   executeDetectScenes: () => executeDetectScenes,
   executeDetectSilence: () => executeDetectSilence
 });
-import { readFile as readFile43, writeFile as writeFile43 } from "node:fs/promises";
+import { readFile as readFile41, writeFile as writeFile44 } from "node:fs/promises";
 import { resolve as resolve73, basename as basename20 } from "node:path";
 async function executeDetectScenes(options) {
   try {
@@ -302629,7 +302856,7 @@ async function executeDetectScenes(options) {
     }));
     if (options.outputPath) {
       const outputPath = resolve73(process.cwd(), options.outputPath);
-      await writeFile43(outputPath, JSON.stringify({ source: absPath, totalDuration, threshold, scenes: result }, null, 2), "utf-8");
+      await writeFile44(outputPath, JSON.stringify({ source: absPath, totalDuration, threshold, scenes: result }, null, 2), "utf-8");
     }
     return { success: true, scenes: result, totalDuration };
   } catch (error) {
@@ -302676,7 +302903,7 @@ async function executeDetectSilence(options) {
     }
     if (options.outputPath) {
       const outputPath = resolve73(process.cwd(), options.outputPath);
-      await writeFile43(outputPath, JSON.stringify({ source: absPath, silences }, null, 2), "utf-8");
+      await writeFile44(outputPath, JSON.stringify({ source: absPath, silences }, null, 2), "utf-8");
     }
     return { success: true, silences };
   } catch (error) {
@@ -302725,7 +302952,7 @@ async function executeDetectBeats(options) {
     }
     if (options.outputPath) {
       const outputPath = resolve73(process.cwd(), options.outputPath);
-      await writeFile43(outputPath, JSON.stringify({ source: absPath, beatCount: beats.length, beats }, null, 2), "utf-8");
+      await writeFile44(outputPath, JSON.stringify({ source: absPath, beatCount: beats.length, beats }, null, 2), "utf-8");
     }
     return { success: true, beats, beatCount: beats.length };
   } catch (error) {
@@ -302829,12 +303056,12 @@ var init_detect = __esm({
               duration: (i3 < scenes.length - 1 ? scenes[i3 + 1].timestamp : totalDuration) - s2.timestamp
             }))
           };
-          await writeFile43(outputPath, JSON.stringify(result, null, 2), "utf-8");
+          await writeFile44(outputPath, JSON.stringify(result, null, 2), "utf-8");
           console.log(source_default.green(`Saved to: ${outputPath}`));
         }
         if (options.project) {
           const projectPath = resolve73(process.cwd(), options.project);
-          const content = await readFile43(projectPath, "utf-8");
+          const content = await readFile41(projectPath, "utf-8");
           const data2 = JSON.parse(content);
           const project = Project.fromJSON(data2);
           let source3 = project.getSources().find((s2) => s2.url === absPath);
@@ -302859,7 +303086,7 @@ var init_detect = __esm({
               sourceEndOffset: end
             });
           }
-          await writeFile43(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+          await writeFile44(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
           console.log(source_default.green(`Added ${scenes.length} clips to project`));
         }
       } catch (error) {
@@ -302941,7 +303168,7 @@ var init_detect = __esm({
         console.log();
         if (options.output) {
           const outputPath = resolve73(process.cwd(), options.output);
-          await writeFile43(
+          await writeFile44(
             outputPath,
             JSON.stringify({ source: absPath, silences }, null, 2),
             "utf-8"
@@ -303026,7 +303253,7 @@ var init_detect = __esm({
         console.log();
         if (options.output) {
           const outputPath = resolve73(process.cwd(), options.output);
-          await writeFile43(
+          await writeFile44(
             outputPath,
             JSON.stringify({ source: absPath, beatCount: beats.length, beats }, null, 2),
             "utf-8"
@@ -303620,7 +303847,7 @@ init_scene_project();
 init_project_config();
 init_cost_tier();
 import { resolve as resolve29, relative as relative8, dirname as dirname24 } from "node:path";
-import { mkdir as mkdir10, readFile as readFile15, writeFile as writeFile14, access as access4, copyFile as copyFile3 } from "node:fs/promises";
+import { mkdir as mkdir11, readFile as readFile14, writeFile as writeFile15, access as access4, copyFile as copyFile3 } from "node:fs/promises";
 import { existsSync as existsSync46 } from "node:fs";
 
 // ../cli/src/commands/_shared/scene-html-emit.ts
@@ -303646,7 +303873,7 @@ function esc(text) {
 function clean(text) {
   return (text ?? "").replace(/\s+/g, " ").trim();
 }
-function humanise(id) {
+function humanise2(id) {
   return id.split(/[-_]+/).filter(Boolean).map((w4) => w4.charAt(0).toUpperCase() + w4.slice(1)).join(" ");
 }
 function sceneCompositionId(beatId) {
@@ -303698,7 +303925,7 @@ function buildPreset(input3) {
   const id = input3.id;
   const scope = `[data-composition-id="${id}"]`;
   const displayId = input3.beatId ?? id;
-  const headline = clean(input3.headline) || humanise(displayId);
+  const headline = clean(input3.headline) || humanise2(displayId);
   const subhead = clean(input3.subhead);
   const kicker = clean(input3.kicker);
   const dur = input3.duration;
@@ -303807,7 +304034,7 @@ function buildPreset(input3) {
       };
     }
     case "explainer": {
-      const k2 = kicker || humanise(displayId).toUpperCase();
+      const k2 = kicker || humanise2(displayId).toUpperCase();
       const sub = subhead || "";
       const transcript = input3.transcript;
       const useWordSync = !!(transcript && transcript.length > 0 && sub);
@@ -303895,7 +304122,7 @@ function buildPreset(input3) {
       };
     }
     case "product-shot": {
-      const label = kicker || humanise(displayId);
+      const label = kicker || humanise2(displayId);
       const headlineFontPx = fitFontSize(headline, 72, 40, 50);
       return {
         css: `${scope} {
@@ -304097,9 +304324,10 @@ init_transcribe_narration();
 // ../cli/src/commands/_shared/scene-submit.ts
 init_scene_lint();
 init_storyboard_parse();
+init_storyboard_source();
 init_root_sync();
 import { existsSync as existsSync44 } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile12, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir10, writeFile as writeFile13 } from "node:fs/promises";
 import { join as join58, resolve as resolve26 } from "node:path";
 async function executeSceneSubmit(opts) {
   const projectDir = resolve26(opts.projectDir);
@@ -304122,7 +304350,7 @@ async function executeSceneSubmit(opts) {
       error: `STORYBOARD.md not found at ${storyboardPath}. Run \`vibe init <dir>\` first.`
     };
   }
-  const parsed = parseStoryboard(await readFile12(storyboardPath, "utf-8"));
+  const parsed = parseStoryboard(await loadStoryboardMarkdown(projectDir));
   const beat = parsed.beats.find((b4) => b4.id === beatId);
   if (!beat) {
     const available = parsed.beats.map((b4) => b4.id).join(", ") || "(none)";
@@ -304193,8 +304421,8 @@ async function executeSceneSubmit(opts) {
     return { ...base2, success: true };
   }
   const absPath = join58(projectDir, scenePath);
-  await mkdir9(join58(projectDir, "compositions"), { recursive: true });
-  await writeFile12(absPath, html.endsWith("\n") ? html : `${html}
+  await mkdir10(join58(projectDir, "compositions"), { recursive: true });
+  await writeFile13(absPath, html.endsWith("\n") ? html : `${html}
 `, "utf-8");
   return {
     ...base2,
@@ -304211,6 +304439,7 @@ async function executeSceneSubmit(opts) {
 init_scene_repair();
 init_root_sync();
 init_storyboard_edit();
+init_storyboard_source();
 function validateDuration(value) {
   const n2 = parseFloat(value);
   if (!Number.isFinite(n2) || n2 <= 0 || n2 > 3600) {
@@ -304387,7 +304616,7 @@ sceneCommand.command("submit").description(
     }
     html = Buffer.concat(chunks).toString("utf-8");
   } else if (options.file) {
-    html = await readFile15(resolve29(String(options.file)), "utf-8");
+    html = await readFile14(resolve29(String(options.file)), "utf-8");
   } else {
     exitWithError(
       usageError(
@@ -304718,7 +304947,7 @@ async function resolveNarrationText(value) {
   if (!value) return void 0;
   const looksLikePath = /\.[a-z]{2,4}$/i.test(value) || value.includes("/") || value.includes("\\");
   if (looksLikePath && existsSync46(value)) {
-    return (await readFile15(value, "utf-8")).trim();
+    return (await readFile14(value, "utf-8")).trim();
   }
   return value.trim();
 }
@@ -304759,7 +304988,7 @@ async function executeSceneAdd(opts) {
   if (!opts.force && await pathExists2(scenePath)) {
     return errResult(`Scene already exists: ${sceneRel}. Re-run with --force to overwrite.`);
   }
-  const rootHtmlBefore = await readFile15(rootPath, "utf-8");
+  const rootHtmlBefore = await readFile14(rootPath, "utf-8");
   let dims = readRootDims(rootHtmlBefore);
   if (!dims) {
     const cfg2 = await loadVibeProjectConfig(projectDir);
@@ -304783,7 +305012,7 @@ async function executeSceneAdd(opts) {
     }
     audioRelPath = `assets/narration-${id}.${ext}`;
     audioAbsPath = resolve29(projectDir, audioRelPath);
-    await mkdir10(dirname24(audioAbsPath), { recursive: true });
+    await mkdir11(dirname24(audioAbsPath), { recursive: true });
     await copyFile3(sourceAbs, audioAbsPath);
     try {
       narrationDuration = await getAudioDuration(audioAbsPath);
@@ -304816,8 +305045,8 @@ async function executeSceneAdd(opts) {
     }
     audioRelPath = `assets/narration-${id}.${resolution.audioExtension}`;
     audioAbsPath = resolve29(projectDir, audioRelPath);
-    await mkdir10(dirname24(audioAbsPath), { recursive: true });
-    await writeFile14(audioAbsPath, tts.audioBuffer);
+    await mkdir11(dirname24(audioAbsPath), { recursive: true });
+    await writeFile15(audioAbsPath, tts.audioBuffer);
     try {
       narrationDuration = await getAudioDuration(audioAbsPath);
     } catch {
@@ -304842,7 +305071,7 @@ async function executeSceneAdd(opts) {
       if (words.length > 0) {
         transcriptRelPath = beatTranscriptRelPath(id);
         const transcriptAbs = resolve29(projectDir, transcriptRelPath);
-        await writeFile14(transcriptAbs, JSON.stringify(words, null, 2), "utf-8");
+        await writeFile15(transcriptAbs, JSON.stringify(words, null, 2), "utf-8");
         transcriptWordCount = words.length;
         transcriptWords = words;
       } else {
@@ -304879,7 +305108,7 @@ async function executeSceneAdd(opts) {
       const img = imageResult.images[0];
       imageRelPath = `assets/scene-${id}.png`;
       imageAbsPath = resolve29(projectDir, imageRelPath);
-      await mkdir10(dirname24(imageAbsPath), { recursive: true });
+      await mkdir11(dirname24(imageAbsPath), { recursive: true });
       let buffer;
       if (img.base64) {
         buffer = Buffer.from(img.base64, "base64");
@@ -304889,7 +305118,7 @@ async function executeSceneAdd(opts) {
       } else {
         return errResult("OpenAI returned no image data");
       }
-      await writeFile14(imageAbsPath, buffer);
+      await writeFile15(imageAbsPath, buffer);
     } else {
       const googleKey = await getApiKey("GOOGLE_API_KEY", "Google");
       if (!googleKey) {
@@ -304906,9 +305135,9 @@ async function executeSceneAdd(opts) {
       }
       imageRelPath = `assets/scene-${id}.png`;
       imageAbsPath = resolve29(projectDir, imageRelPath);
-      await mkdir10(dirname24(imageAbsPath), { recursive: true });
+      await mkdir11(dirname24(imageAbsPath), { recursive: true });
       const buffer = Buffer.from(imageResult.images[0].base64, "base64");
-      await writeFile14(imageAbsPath, buffer);
+      await writeFile15(imageAbsPath, buffer);
     }
   }
   let lottieRelPath;
@@ -304925,7 +305154,7 @@ async function executeSceneAdd(opts) {
     }
     lottieRelPath = `assets/lottie-${id}.${ext}`;
     lottieAbsPath = resolve29(projectDir, lottieRelPath);
-    await mkdir10(dirname24(lottieAbsPath), { recursive: true });
+    await mkdir11(dirname24(lottieAbsPath), { recursive: true });
     await copyFile3(sourceAbs, lottieAbsPath);
     lottieInput = {
       src: lottieRelPath,
@@ -304956,21 +305185,29 @@ async function executeSceneAdd(opts) {
   let storyboardAction = "skipped";
   const shouldSyncStoryboard = opts.syncStoryboard !== false && await pathExists2(storyboardAbsPath);
   if (shouldSyncStoryboard) {
-    opts.onProgress?.("Syncing STORYBOARD.md...");
-    const before2 = await readFile15(storyboardAbsPath, "utf-8");
-    const synced = upsertStoryboardBeat(before2, {
+    const upsert = {
       beatId: id,
       title: opts.headline,
       duration,
       narration: narrationText && !opts.skipAudio ? narrationText : void 0,
       backdrop: opts.visuals && !opts.skipImage ? opts.visuals : void 0
-    });
-    if (synced.markdown !== before2) {
-      await writeFile14(storyboardAbsPath, synced.markdown, "utf-8");
+    };
+    if ((await loadStoryboard(projectDir)).layout === "bundle") {
+      opts.onProgress?.("Syncing scenes/...");
+      const synced = await upsertScene(projectDir, upsert);
+      storyboardPath = relative8(process.cwd(), synced.path) || synced.path;
+      storyboardAction = synced.action;
+    } else {
+      opts.onProgress?.("Syncing STORYBOARD.md...");
+      const before2 = await readFile14(storyboardAbsPath, "utf-8");
+      const synced = upsertStoryboardBeat(before2, upsert);
+      if (synced.markdown !== before2) {
+        await writeFile15(storyboardAbsPath, synced.markdown, "utf-8");
+      }
+      storyboardPath = relative8(process.cwd(), storyboardAbsPath) || storyboardAbsPath;
+      storyboardAction = synced.action;
     }
-    storyboardPath = relative8(process.cwd(), storyboardAbsPath) || storyboardAbsPath;
     storyboardSynced = true;
-    storyboardAction = synced.action;
   }
   opts.onProgress?.("Emitting scene HTML...");
   const sceneHtml = emitSceneHtml({
@@ -304987,8 +305224,8 @@ async function executeSceneAdd(opts) {
     transcript: transcriptWords,
     lottie: lottieInput
   });
-  await mkdir10(dirname24(scenePath), { recursive: true });
-  await writeFile14(scenePath, sceneHtml, "utf-8");
+  await mkdir11(dirname24(scenePath), { recursive: true });
+  await writeFile15(scenePath, sceneHtml, "utf-8");
   opts.onProgress?.("Updating root composition...");
   let start = 0;
   if (storyboardSynced) {
@@ -304999,14 +305236,14 @@ async function executeSceneAdd(opts) {
     });
     const blockingIssue = syncPlan.issues.find((issue) => issue.severity === "error");
     if (blockingIssue) return errResult(blockingIssue.message);
-    const rootHtmlAfterSync = await readFile15(rootPath, "utf-8");
+    const rootHtmlAfterSync = await readFile14(rootPath, "utf-8");
     start = readClipStart(rootHtmlAfterSync, id) ?? 0;
   } else {
     start = nextSceneStart(rootHtmlBefore, SCENE_OVERLAP_SECONDS);
     const existingClipCount = (rootHtmlBefore.match(/<div\s+class="clip"/g) || []).length;
     const trackIndex = existingClipCount % 2 + 1;
     const updated = insertClipIntoRoot(rootHtmlBefore, { id, start, duration, trackIndex });
-    await writeFile14(rootPath, updated, "utf-8");
+    await writeFile15(rootPath, updated, "utf-8");
   }
   const transcriptAbsPath = transcriptRelPath ? resolve29(projectDir, transcriptRelPath) : void 0;
   return {
@@ -306037,7 +306274,7 @@ init_api_key();
 init_exec_safe();
 init_remotion();
 import { resolve as resolve51, dirname as dirname35, basename as basename14 } from "node:path";
-import { writeFile as writeFile29, mkdir as mkdir21, rm as rm8 } from "node:fs/promises";
+import { writeFile as writeFile30, mkdir as mkdir23, rm as rm9 } from "node:fs/promises";
 import { existsSync as existsSync71 } from "node:fs";
 import { tmpdir as tmpdir11 } from "node:os";
 var ASS_STYLES = ["karaoke-sweep", "typewriter"];
@@ -306189,7 +306426,7 @@ async function executeAnimatedCaption(options) {
     }
     const effectiveFontSize = fontSize ?? Math.round(height * 0.04);
     const tmpAudioDir = resolve51(tmpdir11(), `vf-ac-${Date.now()}`);
-    await mkdir21(tmpAudioDir, { recursive: true });
+    await mkdir23(tmpAudioDir, { recursive: true });
     const audioPath = resolve51(tmpAudioDir, "audio.wav");
     await execSafe("ffmpeg", [
       "-y",
@@ -306206,13 +306443,13 @@ async function executeAnimatedCaption(options) {
     ], { timeout: 12e4 });
     const apiKey = await getApiKey("OPENAI_API_KEY", "OpenAI");
     if (!apiKey) {
-      await rm8(tmpAudioDir, { recursive: true, force: true }).catch(() => {
+      await rm9(tmpAudioDir, { recursive: true, force: true }).catch(() => {
       });
       return { success: false, error: "OPENAI_API_KEY required for Whisper transcription. Run 'vibe setup' or set OPENAI_API_KEY in .env" };
     }
     const transcript = await transcribeWithWords(audioPath, apiKey, language);
     if (!transcript.words || transcript.words.length === 0) {
-      await rm8(tmpAudioDir, { recursive: true, force: true }).catch(() => {
+      await rm9(tmpAudioDir, { recursive: true, force: true }).catch(() => {
       });
       return { success: false, error: "No words detected in transcription" };
     }
@@ -306220,7 +306457,7 @@ async function executeAnimatedCaption(options) {
     const absOutputPath = resolve51(process.cwd(), outputPath);
     const outDir = dirname35(absOutputPath);
     if (!existsSync71(outDir)) {
-      await mkdir21(outDir, { recursive: true });
+      await mkdir23(outDir, { recursive: true });
     }
     if (tier === "ass") {
       const assContent = generateASS(
@@ -306229,7 +306466,7 @@ async function executeAnimatedCaption(options) {
         { highlightColor, fontSize: effectiveFontSize, position, width, height }
       );
       const assPath = resolve51(tmpAudioDir, "captions.ass");
-      await writeFile29(assPath, assContent, "utf-8");
+      await writeFile30(assPath, assContent, "utf-8");
       const escapedAssPath = assPath.replace(/\\/g, "\\\\").replace(/:/g, "\\:");
       await execSafe("ffmpeg", [
         "-y",
@@ -306266,12 +306503,12 @@ async function executeAnimatedCaption(options) {
         outputPath: absOutputPath
       });
       if (!renderResult.success) {
-        await rm8(tmpAudioDir, { recursive: true, force: true }).catch(() => {
+        await rm9(tmpAudioDir, { recursive: true, force: true }).catch(() => {
         });
         return { success: false, error: renderResult.error };
       }
     }
-    await rm8(tmpAudioDir, { recursive: true, force: true }).catch(() => {
+    await rm9(tmpAudioDir, { recursive: true, force: true }).catch(() => {
     });
     return {
       success: true,
@@ -306766,14 +307003,14 @@ init_ai_analyze();
 init_dist();
 init_engine();
 init_ai_helpers();
-import { readFile as readFile34, writeFile as writeFile31 } from "node:fs/promises";
+import { readFile as readFile31, writeFile as writeFile33 } from "node:fs/promises";
 import { resolve as resolve55 } from "node:path";
 async function executeSuggestEdit(options) {
   try {
     const apiKey = options.apiKey ?? process.env.GOOGLE_API_KEY;
     if (!apiKey) return { success: false, error: "GOOGLE_API_KEY required for suggest" };
     const filePath = resolve55(process.cwd(), options.projectPath);
-    const content = await readFile34(filePath, "utf-8");
+    const content = await readFile31(filePath, "utf-8");
     const data2 = JSON.parse(content);
     const project = Project.fromJSON(data2);
     const gemini = new GeminiProvider();
@@ -306784,7 +307021,7 @@ async function executeSuggestEdit(options) {
       const first3 = suggestions[0];
       const applied = applySuggestion(project, first3);
       if (applied) {
-        await writeFile31(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+        await writeFile33(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
         return {
           success: true,
           suggestions,
@@ -306810,8 +307047,8 @@ init_project_config();
 init_scene_lint();
 init_root_sync();
 init_review_report();
-import { existsSync as existsSync74 } from "node:fs";
-import { readdir as readdir7, readFile as readFile35, stat as stat7 } from "node:fs/promises";
+import { existsSync as existsSync75 } from "node:fs";
+import { readdir as readdir8, readFile as readFile33, stat as stat7 } from "node:fs/promises";
 import { basename as basename15, isAbsolute as isAbsolute12, join as join70, relative as relative13, resolve as resolve56 } from "node:path";
 async function inspectProject(opts) {
   const projectDir = resolve56(opts.projectDir);
@@ -306826,7 +307063,7 @@ async function inspectProject(opts) {
     assets: { checked: 0, missing: [], stale: [], unknownFreshness: [] },
     rootSync: { ok: null, issueCount: 0, issues: [] }
   };
-  if (!existsSync74(projectDir) || !await isDirectory(projectDir)) {
+  if (!existsSync75(projectDir) || !await isDirectory(projectDir)) {
     issues.push({
       severity: "error",
       code: "PROJECT_NOT_FOUND",
@@ -306849,7 +307086,7 @@ async function inspectProject(opts) {
     root: join70(projectDir, "index.html")
   };
   for (const [name, path16] of Object.entries(coreFiles)) {
-    checks.files[name] = existsSync74(path16);
+    checks.files[name] = existsSync75(path16);
   }
   let beatIds = [];
   let inspectedBeatIds = [];
@@ -306863,7 +307100,7 @@ async function inspectProject(opts) {
     });
     retryWith.push(`vibe init ${projectDir} --from "<brief>" --json`);
   } else {
-    const storyboard = await readFile35(coreFiles.storyboard, "utf-8");
+    const storyboard = await readFile33(coreFiles.storyboard, "utf-8");
     const validation3 = validateStoryboardMarkdown(storyboard);
     storyboardBeats = validation3.beats;
     beatIds = validation3.beats.map((beat) => beat.id);
@@ -306905,7 +307142,7 @@ async function inspectProject(opts) {
       suggestedFix: "Create DESIGN.md or rerun `vibe init --from` in a new project."
     });
   } else {
-    const design = await readFile35(coreFiles.design, "utf-8");
+    const design = await readFile33(coreFiles.design, "utf-8");
     for (const issue of designPlaceholderIssues(design)) {
       issues.push(issue);
     }
@@ -306931,7 +307168,7 @@ async function inspectProject(opts) {
     retryWith.push(`vibe build ${projectDir} --stage sync --json`);
   }
   const compositionsDir = join70(projectDir, "compositions");
-  const existingComps = existsSync74(compositionsDir) ? new Set(await listHtmlBasenames(compositionsDir)) : /* @__PURE__ */ new Set();
+  const existingComps = existsSync75(compositionsDir) ? new Set(await listHtmlBasenames(compositionsDir)) : /* @__PURE__ */ new Set();
   checks.compositions.expected = inspectedBeatIds.length;
   for (const beatId of inspectedBeatIds) {
     const file = `scene-${beatId}.html`;
@@ -307151,7 +307388,7 @@ function projectSourceReports(checks) {
 async function inspectBuildReport(projectDir, reportPath, beatId, checks, issues, retryWith, storyboardBeats) {
   checks.buildReport.exists = true;
   try {
-    const report = JSON.parse(await readFile35(reportPath, "utf-8"));
+    const report = JSON.parse(await readFile33(reportPath, "utf-8"));
     if (typeof report.outputPath === "string") checks.buildReport.outputPath = report.outputPath;
     const reportBeats = report.beats ?? [];
     const selectedReportBeats = reportBeats.filter((item) => !beatId || item.id === beatId);
@@ -307288,7 +307525,7 @@ function inspectReportedAsset(opts) {
   opts.checks.assets.checked++;
   if (isExternalRef2(opts.value)) return;
   const abs = isAbsolute12(opts.value) ? opts.value : resolve56(opts.projectDir, opts.value);
-  if (existsSync74(abs)) return;
+  if (existsSync75(abs)) return;
   opts.checks.assets.missing.push(opts.value);
   opts.issues.push({
     severity: "warning",
@@ -307369,7 +307606,7 @@ async function isDirectory(path16) {
   }
 }
 async function listHtmlBasenames(dir) {
-  const entries2 = await readdir7(dir, { withFileTypes: true });
+  const entries2 = await readdir8(dir, { withFileTypes: true });
   return entries2.filter((entry) => entry.isFile() && entry.name.endsWith(".html")).map((entry) => entry.name);
 }
 function isExternalRef2(value) {
@@ -307382,8 +307619,8 @@ init_exec_safe();
 init_project_config();
 init_storyboard_parse();
 init_review_report();
-import { existsSync as existsSync76 } from "node:fs";
-import { readdir as readdir8, readFile as readFile37, stat as stat8 } from "node:fs/promises";
+import { existsSync as existsSync77 } from "node:fs";
+import { readdir as readdir9, readFile as readFile35, stat as stat8 } from "node:fs/promises";
 import { basename as basename16, isAbsolute as isAbsolute13, join as join71, relative as relative14, resolve as resolve58 } from "node:path";
 var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".mov", ".webm", ".m4v"]);
 var DEFAULT_AI_MODEL = "flash";
@@ -307900,7 +308137,7 @@ async function renderExpectsAudio(projectDir, beatId) {
         `assets/narration-${beat.id}.wav`,
         `assets/music-${beat.id}.mp3`,
         `assets/music-${beat.id}.wav`
-      ].some((asset) => existsSync76(join71(root2, asset)))
+      ].some((asset) => existsSync77(join71(root2, asset)))
     );
   } catch {
     return false;
@@ -308008,8 +308245,8 @@ async function maybeWriteRenderReport(projectDir, opts, result) {
 }
 function renderSourceReports(projectDir, videoPath, checks) {
   const reports = [];
-  if (existsSync76(join71(projectDir, "build-report.json"))) reports.push("build-report.json");
-  if (existsSync76(join71(projectDir, "render-report.json"))) reports.push("render-report.json");
+  if (existsSync77(join71(projectDir, "build-report.json"))) reports.push("build-report.json");
+  if (existsSync77(join71(projectDir, "render-report.json"))) reports.push("render-report.json");
   if (videoPath) reports.push(displayPath(videoPath));
   if (checks.durationSec !== void 0 || checks.width !== void 0 || checks.height !== void 0) {
     reports.push("ffprobe");
@@ -308022,32 +308259,32 @@ function renderSourceReports(projectDir, videoPath, checks) {
 async function resolveRenderVideoPath(projectDir, explicit, beatId) {
   if (explicit) {
     const candidate = resolve58(process.cwd(), explicit);
-    return existsSync76(candidate) ? candidate : null;
+    return existsSync77(candidate) ? candidate : null;
   }
   const renderReportPath = join71(projectDir, "render-report.json");
-  if (existsSync76(renderReportPath)) {
+  if (existsSync77(renderReportPath)) {
     try {
-      const report = JSON.parse(await readFile37(renderReportPath, "utf-8"));
+      const report = JSON.parse(await readFile35(renderReportPath, "utf-8"));
       const reportBeat = typeof report.beat === "string" ? report.beat : null;
       if (!beatId && reportBeat === null || beatId && reportBeat === beatId) {
         const candidate = resolveReportedPath(projectDir, report.outputPath);
-        if (candidate && existsSync76(candidate)) return candidate;
+        if (candidate && existsSync77(candidate)) return candidate;
       }
     } catch {
     }
   }
   const reportPath = join71(projectDir, "build-report.json");
-  if (!beatId && existsSync76(reportPath)) {
+  if (!beatId && existsSync77(reportPath)) {
     try {
-      const report = JSON.parse(await readFile37(reportPath, "utf-8"));
+      const report = JSON.parse(await readFile35(reportPath, "utf-8"));
       const candidate = resolveReportedPath(projectDir, report.outputPath);
-      if (candidate && existsSync76(candidate)) return candidate;
+      if (candidate && existsSync77(candidate)) return candidate;
     } catch {
     }
   }
   const rendersDir = join71(projectDir, "renders");
-  if (!existsSync76(rendersDir)) return null;
-  const entries2 = await readdir8(rendersDir, { withFileTypes: true });
+  if (!existsSync77(rendersDir)) return null;
+  const entries2 = await readdir9(rendersDir, { withFileTypes: true });
   const candidates = [];
   for (const entry of entries2) {
     if (!entry.isFile()) continue;
@@ -308073,13 +308310,13 @@ async function runAiRenderReview(projectDir, videoPath, model) {
 }
 function resolveStoryboardPath(projectDir) {
   const storyboardPath = join71(projectDir, "STORYBOARD.md");
-  return existsSync76(storyboardPath) ? storyboardPath : null;
+  return existsSync77(storyboardPath) ? storyboardPath : null;
 }
 async function expectedDurationFromBuildReport(projectDir, beatId) {
   const reportPath = join71(projectDir, "build-report.json");
-  if (!existsSync76(reportPath)) return void 0;
+  if (!existsSync77(reportPath)) return void 0;
   try {
-    const report = JSON.parse(await readFile37(reportPath, "utf-8"));
+    const report = JSON.parse(await readFile35(reportPath, "utf-8"));
     const beats = beatId ? (report.beats ?? []).filter((beat) => beat.id === beatId) : report.beats ?? [];
     const durations = beats.map(
       (beat) => parseOptionalNumber2(beat.sceneDurationSec) ?? parseOptionalNumber2(beat.narration?.sceneDurationSec)
@@ -308092,9 +308329,9 @@ async function expectedDurationFromBuildReport(projectDir, beatId) {
 }
 async function beatTimingsFromBuildReport(projectDir, beatId) {
   const reportPath = join71(projectDir, "build-report.json");
-  if (!existsSync76(reportPath)) return [];
+  if (!existsSync77(reportPath)) return [];
   try {
-    const report = JSON.parse(await readFile37(reportPath, "utf-8"));
+    const report = JSON.parse(await readFile35(reportPath, "utf-8"));
     const source3 = report.beats ?? [];
     const selected = beatId ? source3.filter((beat) => beat.id === beatId) : source3;
     let cursor = 0;
@@ -308158,9 +308395,9 @@ function storyboardBeatCueSummary(storyboard) {
   }
 }
 async function readTextIfExists(path16) {
-  if (!existsSync76(path16)) return null;
+  if (!existsSync77(path16)) return null;
   try {
-    return await readFile37(path16, "utf-8");
+    return await readFile35(path16, "utf-8");
   } catch {
     return null;
   }
@@ -308782,16 +309019,16 @@ var generateTools = [
 ];
 
 // ../cli/src/tools/manifest/storyboard.ts
-import { existsSync as existsSync79 } from "node:fs";
-import { readFile as readFile40, writeFile as writeFile41 } from "node:fs/promises";
+import { existsSync as existsSync80 } from "node:fs";
+import { readFile as readFile38, writeFile as writeFile42 } from "node:fs/promises";
 import { resolve as resolve69 } from "node:path";
 import { z as z9 } from "zod";
 init_storyboard_parse();
 init_storyboard_edit();
 
 // ../cli/src/commands/_shared/storyboard-revise.ts
-import { existsSync as existsSync78 } from "node:fs";
-import { readFile as readFile39, writeFile as writeFile40 } from "node:fs/promises";
+import { existsSync as existsSync79 } from "node:fs";
+import { readFile as readFile37, writeFile as writeFile41 } from "node:fs/promises";
 import { join as join73, resolve as resolve68 } from "node:path";
 
 // ../cli/src/agent/adapters/index.ts
@@ -308841,12 +309078,13 @@ async function createAdapter(provider) {
 init_composer_resolve();
 init_project_config();
 init_storyboard_parse();
+init_storyboard_source();
 init_storyboard_edit();
 async function executeStoryboardRevision(opts) {
   const projectDir = resolve68(opts.projectDir);
   const storyboardPath = join73(projectDir, "STORYBOARD.md");
   const retryWith = [`vibe storyboard revise ${projectDir} --from "<request>" --dry-run --json`];
-  if (!existsSync78(storyboardPath)) {
+  if (!existsSync79(storyboardPath)) {
     return failureResult({
       projectDir,
       storyboardPath,
@@ -308856,7 +309094,8 @@ async function executeStoryboardRevision(opts) {
       retryWith: [`vibe init ${projectDir} --from "<brief>" --json`]
     });
   }
-  const currentStoryboard = await readFile39(storyboardPath, "utf-8");
+  const loaded = await loadStoryboard(projectDir);
+  const currentStoryboard = loaded.markdown;
   const projectConfig = await readProjectConfig(projectDir);
   const explicitComposer = opts.composer ?? projectConfig.config.providers.composer ?? void 0;
   let provider = explicitComposer ?? "claude";
@@ -308955,7 +309194,11 @@ async function executeStoryboardRevision(opts) {
   }
   const storyboardMd = normalizeMarkdown(payload.storyboardMd);
   if (!opts.dryRun) {
-    await writeFile40(storyboardPath, storyboardMd, "utf-8");
+    if (loaded.layout === "bundle") {
+      await rewriteBundleFromMarkdown(projectDir, storyboardMd);
+    } else {
+      await writeFile41(storyboardPath, storyboardMd, "utf-8");
+    }
   }
   const changedBeats = unique5([...diffChangedBeats(currentStoryboard, storyboardMd), ...payload.changedBeats]);
   return stripUndefined4({
@@ -308990,7 +309233,10 @@ function revisionMessages(opts) {
     "Return exactly one JSON object, with no markdown fence and no prose outside JSON.",
     "The JSON object must have: storyboardMd string, summary string, changedBeats string[], warnings string[].",
     "Preserve existing frontmatter, beat ids, cue YAML keys, and useful prose unless the user asks to change structure.",
-    "Keep cue YAML valid. Allowed cue keys are duration, narration, backdrop, video, motion, voice, music, asset.",
+    // Rendered from the SSOT: this list used to be a hand-typed subset of 8,
+    // so a revise pass could silently drop `characters`, `keyframe`, and the
+    // lower-third cues it had never been told about.
+    `Keep cue YAML valid. Allowed cue keys are ${STORYBOARD_CUE_KEYS.join(", ")}.`,
     "If a target duration is supplied, every beat must have a positive duration cue and durations must sum to that target.",
     "Aim for 6-15 seconds per beat and never exceed ~15s \u2014 long beats render as static, overstuffed scenes. A 90-second video should have 6-8 beats."
   ].join("\n");
@@ -309084,13 +309330,13 @@ async function readRevisionContext(projectDir) {
   return { designMd, buildReportJson };
 }
 async function readOptionalText(path16) {
-  if (!existsSync78(path16)) return null;
-  return readFile39(path16, "utf-8");
+  if (!existsSync79(path16)) return null;
+  return readFile37(path16, "utf-8");
 }
 async function readOptionalJsonText(path16) {
-  if (!existsSync78(path16)) return null;
+  if (!existsSync79(path16)) return null;
   try {
-    const parsed = JSON.parse(await readFile39(path16, "utf-8"));
+    const parsed = JSON.parse(await readFile37(path16, "utf-8"));
     return JSON.stringify(parsed, null, 2);
   } catch {
     return null;
@@ -309135,8 +309381,8 @@ var projectDirSchema = z9.object({
 });
 async function readStoryboard(projectDir) {
   const path16 = resolve69(projectDir, "STORYBOARD.md");
-  if (!existsSync79(path16)) return null;
-  return { path: path16, markdown: await readFile40(path16, "utf-8") };
+  if (!existsSync80(path16)) return null;
+  return { path: path16, markdown: await readFile38(path16, "utf-8") };
 }
 var storyboardListTool = defineTool({
   name: "storyboard_list",
@@ -309249,7 +309495,7 @@ var storyboardSetTool = defineTool({
         value,
         unset: args.unset
       });
-      await writeFile41(file.path, next, "utf-8");
+      await writeFile42(file.path, next, "utf-8");
       return {
         success: true,
         data: { beat: args.beat, key: args.key },
@@ -309281,7 +309527,7 @@ var storyboardMoveTool = defineTool({
         beatId: args.beat,
         afterBeatId: args.after
       });
-      await writeFile41(file.path, next, "utf-8");
+      await writeFile42(file.path, next, "utf-8");
       return {
         success: true,
         data: { beat: args.beat, after: args.after },
@@ -309393,8 +309639,8 @@ var storyboardTools = [
 ];
 
 // ../cli/src/tools/manifest/design.ts
-import { existsSync as existsSync80 } from "node:fs";
-import { readFile as readFile41 } from "node:fs/promises";
+import { existsSync as existsSync81 } from "node:fs";
+import { readFile as readFile39 } from "node:fs/promises";
 import { resolve as resolve70, join as join74 } from "node:path";
 import { z as z10 } from "zod";
 init_design_parse();
@@ -309413,8 +309659,8 @@ var designValidateTool = defineTool({
   async execute(args, ctx) {
     const projectDir = args.projectDir ? resolve70(ctx.workingDirectory, args.projectDir) : ctx.workingDirectory;
     const path16 = join74(projectDir, "DESIGN.md");
-    if (!existsSync80(path16)) return { success: false, error: `DESIGN.md not found in ${projectDir}` };
-    const md = await readFile41(path16, "utf-8");
+    if (!existsSync81(path16)) return { success: false, error: `DESIGN.md not found in ${projectDir}` };
+    const md = await readFile39(path16, "utf-8");
     const issues = validateDesignMarkdown(md);
     const design = parseDesign(md);
     const ok = !issues.some((issue) => issue.severity === "error");
@@ -309435,15 +309681,15 @@ var designValidateTool = defineTool({
 var designTools = [designValidateTool];
 
 // ../cli/src/tools/manifest/remix.ts
-import { writeFile as writeFile45 } from "node:fs/promises";
+import { writeFile as writeFile46 } from "node:fs/promises";
 import { tmpdir as tmpdir12 } from "node:os";
 import { join as join75 } from "node:path";
 import { z as z11 } from "zod";
 
 // ../cli/src/commands/ai-highlights.ts
-import { readFile as readFile42, writeFile as writeFile42, mkdir as mkdir26 } from "node:fs/promises";
+import { readFile as readFile40, writeFile as writeFile43, mkdir as mkdir27 } from "node:fs/promises";
 import { resolve as resolve71, dirname as dirname39, basename as basename19, extname as extname18 } from "node:path";
-import { existsSync as existsSync81 } from "node:fs";
+import { existsSync as existsSync82 } from "node:fs";
 init_dist();
 init_engine();
 init_api_key();
@@ -309474,7 +309720,7 @@ function filterHighlights(highlights, options) {
 async function executeHighlights(options) {
   try {
     const absPath = resolve71(process.cwd(), options.media);
-    if (!existsSync81(absPath)) {
+    if (!existsSync82(absPath)) {
       return { success: false, highlights: [], totalDuration: 0, totalHighlightDuration: 0, error: `File not found: ${absPath}` };
     }
     const ext = extname18(absPath).toLowerCase();
@@ -309493,7 +309739,7 @@ async function executeHighlights(options) {
       sourceDuration = await ffprobeDuration(absPath);
       const gemini = new GeminiProvider();
       await gemini.initialize({ apiKey: geminiApiKey });
-      const videoBuffer = await readFile42(absPath);
+      const videoBuffer = await readFile40(absPath);
       const criteriaText = options.criteria === "all" || !options.criteria ? "emotional, informative, and funny moments" : `${options.criteria} moments`;
       const durationText = targetDuration ? `Target a total highlight duration of ${targetDuration} seconds.` : "";
       const countText = maxCount ? `Find up to ${maxCount} highlights.` : "";
@@ -309587,10 +309833,10 @@ Analyze both what is SHOWN (visual cues, actions, expressions) and what is SAID
       }
       const whisper = new WhisperProvider();
       await whisper.initialize({ apiKey: openaiApiKey });
-      const audioBuffer = await readFile42(audioPath);
+      const audioBuffer = await readFile40(audioPath);
       const audioBlob = new Blob([audioBuffer]);
       const transcriptResult = await whisper.transcribe(audioBlob, options.language);
-      if (tempAudioPath && existsSync81(tempAudioPath)) {
+      if (tempAudioPath && existsSync82(tempAudioPath)) {
         const { unlink: unlinkFile } = await import("node:fs/promises");
         await unlinkFile(tempAudioPath).catch(() => {
         });
@@ -309622,7 +309868,7 @@ Analyze both what is SHOWN (visual cues, actions, expressions) and what is SAID
     };
     if (options.output) {
       const outputPath = resolve71(process.cwd(), options.output);
-      await writeFile42(outputPath, JSON.stringify({
+      await writeFile43(outputPath, JSON.stringify({
         sourceFile: absPath,
         totalDuration: sourceDuration,
         criteria: options.criteria || "all",
@@ -309657,7 +309903,7 @@ Analyze both what is SHOWN (visual cues, actions, expressions) and what is SAID
         }
       }
       const projectPath = resolve71(process.cwd(), options.project);
-      await writeFile42(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+      await writeFile43(projectPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
       extractResult.projectPath = projectPath;
     }
     return extractResult;
@@ -309677,7 +309923,7 @@ async function executeAutoShorts(options) {
       return { success: false, shorts: [], error: "FFmpeg not found" };
     }
     const absPath = resolve71(process.cwd(), options.video);
-    if (!existsSync81(absPath)) {
+    if (!existsSync82(absPath)) {
       return { success: false, shorts: [], error: `File not found: ${absPath}` };
     }
     const targetDuration = options.duration ?? 60;
@@ -309690,7 +309936,7 @@ async function executeAutoShorts(options) {
       }
       const gemini = new GeminiProvider();
       await gemini.initialize({ apiKey: geminiApiKey });
-      const videoBuffer = await readFile42(absPath);
+      const videoBuffer = await readFile40(absPath);
       const geminiPrompt = `Analyze this video to find the BEST moments for short-form vertical video content (TikTok, YouTube Shorts, Instagram Reels).
 
 Find ${shortCount * 3} potential clips that are ${targetDuration} seconds or shorter each.
@@ -309767,7 +310013,7 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
       await execSafe("ffmpeg", ["-i", absPath, "-vn", "-acodec", "libmp3lame", "-q:a", "2", tempAudio, "-y"]);
       const whisper = new WhisperProvider();
       await whisper.initialize({ apiKey: openaiApiKey });
-      const audioBuffer = await readFile42(tempAudio);
+      const audioBuffer = await readFile40(tempAudio);
       const audioBlob = new Blob([audioBuffer]);
       const transcript = await whisper.transcribe(audioBlob, options.language);
       try {
@@ -309805,8 +310051,8 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
       };
     }
     const outputDir = options.outputDir ? resolve71(process.cwd(), options.outputDir) : dirname39(absPath);
-    if (options.outputDir && !existsSync81(outputDir)) {
-      await mkdir26(outputDir, { recursive: true });
+    if (options.outputDir && !existsSync82(outputDir)) {
+      await mkdir27(outputDir, { recursive: true });
     }
     const result = {
       success: true,
@@ -309882,10 +310128,10 @@ Analyze both VISUALS (expressions, actions, scene changes) and AUDIO (speech, re
 }
 
 // ../cli/src/pipeline/executor.ts
-var import_yaml7 = __toESM(require_dist3(), 1);
+var import_yaml8 = __toESM(require_dist3(), 1);
 import { resolve as resolve74 } from "node:path";
-import { readFile as readFile44, writeFile as writeFile44, mkdir as mkdir27 } from "node:fs/promises";
-import { existsSync as existsSync82 } from "node:fs";
+import { readFile as readFile42, writeFile as writeFile45, mkdir as mkdir28 } from "node:fs/promises";
+import { existsSync as existsSync83 } from "node:fs";
 
 // ../cli/src/pipeline/resolver.ts
 function resolveStepParams(params, completedSteps) {
@@ -310275,11 +310521,11 @@ async function ensureActionsRegistered() {
 }
 async function loadPipeline(filePath) {
   const absPath = resolve74(process.cwd(), filePath);
-  if (!existsSync82(absPath)) {
+  if (!existsSync83(absPath)) {
     throw new Error(`Pipeline file not found: ${absPath}`);
   }
-  const content = await readFile44(absPath, "utf-8");
-  const manifest2 = (0, import_yaml7.parse)(content);
+  const content = await readFile42(absPath, "utf-8");
+  const manifest2 = (0, import_yaml8.parse)(content);
   if (!manifest2.name) throw new Error("Pipeline missing 'name' field");
   if (!manifest2.steps || !Array.isArray(manifest2.steps)) throw new Error("Pipeline missing 'steps' array");
   const ids = /* @__PURE__ */ new Set();
@@ -310295,15 +310541,15 @@ var CHECKPOINT_FILE = ".pipeline-state.yaml";
 async function executePipeline(manifest2, options = {}) {
   await ensureActionsRegistered();
   const outputDir = resolve74(process.cwd(), options.outputDir || `${manifest2.name}-output`);
-  await mkdir27(outputDir, { recursive: true });
+  await mkdir28(outputDir, { recursive: true });
   const completedSteps = /* @__PURE__ */ new Map();
   const results = [];
   const startTime = Date.now();
   if (options.resume) {
     const checkpointPath = resolve74(outputDir, CHECKPOINT_FILE);
-    if (existsSync82(checkpointPath)) {
-      const checkpointContent = await readFile44(checkpointPath, "utf-8");
-      const checkpoint = (0, import_yaml7.parse)(checkpointContent);
+    if (existsSync83(checkpointPath)) {
+      const checkpointContent = await readFile42(checkpointPath, "utf-8");
+      const checkpoint = (0, import_yaml8.parse)(checkpointContent);
       for (const cs of checkpoint.completedSteps) {
         completedSteps.set(cs.id, {
           id: cs.id,
@@ -310420,9 +310666,9 @@ async function executePipeline(manifest2, options = {}) {
           data: s2.data
         }))
       };
-      await writeFile44(
+      await writeFile45(
         resolve74(outputDir, CHECKPOINT_FILE),
-        (0, import_yaml7.stringify)(checkpoint, { indent: 2 }),
+        (0, import_yaml8.stringify)(checkpoint, { indent: 2 }),
         "utf-8"
       );
     } else {
@@ -310575,7 +310821,7 @@ var pipelineRunTool = defineTool({
     let tempPath;
     if (args.pipelineYaml) {
       tempPath = join75(tmpdir12(), `vibe-mcp-pipeline-${Date.now()}.yaml`);
-      await writeFile45(tempPath, args.pipelineYaml, "utf-8");
+      await writeFile46(tempPath, args.pipelineYaml, "utf-8");
       resolvedPath = tempPath;
     }
     try {
@@ -310712,7 +310958,7 @@ var detectTools = [
 
 // ../cli/src/tools/manifest/timeline.ts
 import { z as z13 } from "zod";
-import { mkdir as mkdir28, writeFile as writeFile47 } from "node:fs/promises";
+import { mkdir as mkdir29, writeFile as writeFile48 } from "node:fs/promises";
 import { basename as basename21, resolve as resolve75 } from "node:path";
 init_engine();
 init_project_resolver();
@@ -310720,15 +310966,15 @@ init_project_resolver();
 // ../cli/src/tools/manifest/_project-io.ts
 init_engine();
 init_project_resolver();
-import { readFile as readFile45, writeFile as writeFile46 } from "node:fs/promises";
+import { readFile as readFile43, writeFile as writeFile47 } from "node:fs/promises";
 async function loadProject(projectPath, cwd) {
   const absPath = await resolveTimelineFile(projectPath, cwd);
-  const content = await readFile45(absPath, "utf-8");
+  const content = await readFile43(absPath, "utf-8");
   const data2 = JSON.parse(content);
   return { project: Project.fromJSON(data2), absPath };
 }
 async function saveProject(absPath, project) {
-  await writeFile46(absPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+  await writeFile47(absPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
 }
 
 // ../cli/src/tools/manifest/timeline.ts
@@ -310768,10 +311014,10 @@ var timelineCreateTool = defineTool({
       outputPath = resolve75(ctx.workingDirectory, args.outputPath);
     } else {
       const dirPath = resolve75(ctx.workingDirectory, args.name);
-      await mkdir28(dirPath, { recursive: true });
+      await mkdir29(dirPath, { recursive: true });
       outputPath = resolve75(dirPath, TIMELINE_FILENAME);
     }
-    await writeFile47(outputPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+    await writeFile48(outputPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
     return {
       success: true,
       data: { name: projectName, outputPath },
@@ -311069,17 +311315,18 @@ var timelineTools = [
 // ../cli/src/tools/manifest/project.ts
 import { z as z14 } from "zod";
 import { resolve as resolve77 } from "node:path";
-import { writeFile as writeFile48 } from "node:fs/promises";
+import { writeFile as writeFile49 } from "node:fs/promises";
 init_engine();
 
 // ../cli/src/commands/_shared/project-list.ts
 init_storyboard_parse();
-import { readdir as readdir9, readFile as readFile46, stat as stat9 } from "node:fs/promises";
-import { existsSync as existsSync83 } from "node:fs";
+init_storyboard_source();
+import { readdir as readdir10, readFile as readFile44, stat as stat9 } from "node:fs/promises";
+import { existsSync as existsSync84 } from "node:fs";
 import { join as join76, resolve as resolve76 } from "node:path";
 async function executeProjectList(opts = {}) {
   const workspaceDir = resolve76(opts.workspaceDir ?? ".");
-  if (!existsSync83(workspaceDir)) {
+  if (!existsSync84(workspaceDir)) {
     return {
       success: false,
       workspaceDir,
@@ -311088,7 +311335,7 @@ async function executeProjectList(opts = {}) {
       error: `Workspace directory not found: ${workspaceDir}`
     };
   }
-  const entries2 = await readdir9(workspaceDir, { withFileTypes: true });
+  const entries2 = await readdir10(workspaceDir, { withFileTypes: true });
   const projects = [];
   let archivedCount = 0;
   for (const entry of entries2) {
@@ -311100,7 +311347,7 @@ async function executeProjectList(opts = {}) {
       continue;
     }
     const projectDir = join76(workspaceDir, entry.name);
-    if (!existsSync83(join76(projectDir, "STORYBOARD.md"))) continue;
+    if (!existsSync84(join76(projectDir, "STORYBOARD.md"))) continue;
     projects.push(await describeProject(entry.name, projectDir));
   }
   projects.sort((a4, b4) => b4.updatedAt.localeCompare(a4.updatedAt));
@@ -311108,9 +311355,9 @@ async function executeProjectList(opts = {}) {
 }
 async function countProjects(dir) {
   try {
-    const entries2 = await readdir9(dir, { withFileTypes: true });
+    const entries2 = await readdir10(dir, { withFileTypes: true });
     return entries2.filter(
-      (e2) => e2.isDirectory() && existsSync83(join76(dir, e2.name, "STORYBOARD.md"))
+      (e2) => e2.isDirectory() && existsSync84(join76(dir, e2.name, "STORYBOARD.md"))
     ).length;
   } catch {
     return 0;
@@ -311122,7 +311369,7 @@ async function describeProject(name, projectDir) {
   const timestamps = [];
   try {
     const storyboardPath = join76(projectDir, "STORYBOARD.md");
-    const parsed = parseStoryboard(await readFile46(storyboardPath, "utf-8"));
+    const parsed = parseStoryboard(await loadStoryboardMarkdown(projectDir));
     beats = parsed.beats.length;
     storyboardDurationSec = Number(
       parsed.beats.reduce((sum, beat) => sum + (beat.duration ?? 0), 0).toFixed(2)
@@ -311134,7 +311381,7 @@ async function describeProject(name, projectDir) {
   let buildUpdatedAt;
   try {
     const reportPath = join76(projectDir, "build-report.json");
-    const report = JSON.parse(await readFile46(reportPath, "utf-8"));
+    const report = JSON.parse(await readFile44(reportPath, "utf-8"));
     buildStatus = report.status ?? report.phase;
     buildUpdatedAt = report.updatedAt;
     timestamps.push((await stat9(reportPath)).mtimeMs);
@@ -311143,7 +311390,7 @@ async function describeProject(name, projectDir) {
   let latestRender;
   try {
     const rendersDir = join76(projectDir, "renders");
-    const files = await readdir9(rendersDir);
+    const files = await readdir10(rendersDir);
     let newest;
     for (const file of files) {
       if (!/\.(mp4|webm|mov)$/i.test(file)) continue;
@@ -311226,7 +311473,7 @@ var projectCreateTool = defineTool({
     const outputPath = resolve77(ctx.workingDirectory, args.outputPath ?? `${args.name}.vibe.json`);
     const project = new Project(args.name);
     if (args.fps) project.setFrameRate(args.fps);
-    await writeFile48(outputPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+    await writeFile49(outputPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
     return {
       success: true,
       data: { name: args.name, outputPath },
@@ -311277,7 +311524,7 @@ import { resolve as resolve79 } from "node:path";
 init_engine();
 init_exec_safe();
 init_project_resolver();
-import { readFile as readFile47, access as access6 } from "node:fs/promises";
+import { readFile as readFile45, access as access6 } from "node:fs/promises";
 import { resolve as resolve78 } from "node:path";
 import { spawn as spawn9 } from "node:child_process";
 async function getMediaDuration(filePath, mediaType, defaultImageDuration = 5) {
@@ -311348,7 +311595,7 @@ async function runExport(projectPath, outputPath, options = {}) {
       };
     }
     const filePath = await resolveTimelineFile(projectPath);
-    const content = await readFile47(filePath, "utf-8");
+    const content = await readFile45(filePath, "utf-8");
     const data2 = JSON.parse(content);
     const project = Project.fromJSON(data2);
     const summary = project.getSummary();
@@ -311947,7 +312194,7 @@ var exportVideoTool = defineTool({
 var exportTools = [exportVideoTool];
 
 // ../cli/src/tools/manifest/agent-only.ts
-import { readFile as readFile48, writeFile as writeFile49, readdir as readdir10, stat as stat10, access as access7, unlink as unlink5 } from "node:fs/promises";
+import { readFile as readFile46, writeFile as writeFile50, readdir as readdir11, stat as stat10, access as access7, unlink as unlink5 } from "node:fs/promises";
 import { resolve as resolve80, join as join77, basename as basename23, extname as extname19 } from "node:path";
 import { z as z16 } from "zod";
 init_engine();
@@ -312023,7 +312270,7 @@ var fsListTool = defineTool({
     const dirPath = args.path ?? ".";
     try {
       const absPath = resolve80(ctx.workingDirectory, dirPath);
-      const entries2 = await readdir10(absPath, { withFileTypes: true });
+      const entries2 = await readdir11(absPath, { withFileTypes: true });
       const results = [];
       for (const entry of entries2) {
         if (args.pattern && !matchPattern(entry.name, args.pattern)) continue;
@@ -312056,7 +312303,7 @@ var fsReadTool = defineTool({
   async execute(args, ctx) {
     try {
       const absPath = resolve80(ctx.workingDirectory, args.path);
-      const content = await readFile48(absPath, "utf-8");
+      const content = await readFile46(absPath, "utf-8");
       const maxLength = 4e3;
       const truncated = content.length > maxLength;
       const output3 = truncated ? content.substring(0, maxLength) + "\n... (truncated)" : content;
@@ -312081,7 +312328,7 @@ var fsWriteTool = defineTool({
   async execute(args, ctx) {
     try {
       const absPath = resolve80(ctx.workingDirectory, args.path);
-      await writeFile49(absPath, args.content, "utf-8");
+      await writeFile50(absPath, args.content, "utf-8");
       return { success: true, data: { bytes: args.content.length }, humanLines: [`File written: ${args.path} (${formatSize(args.content.length)})`] };
     } catch (error) {
       return { success: false, error: `Failed to write file: ${error instanceof Error ? error.message : String(error)}` };
@@ -312129,7 +312376,7 @@ var batchImportTool = defineTool({
   async execute(args, ctx) {
     try {
       const filePath = resolve80(ctx.workingDirectory, args.project);
-      const content = await readFile48(filePath, "utf-8");
+      const content = await readFile46(filePath, "utf-8");
       const data2 = JSON.parse(content);
       const project = Project.fromJSON(data2);
       const dirPath = resolve80(ctx.workingDirectory, args.directory);
@@ -312138,7 +312385,7 @@ var batchImportTool = defineTool({
       const recursive = args.recursive ?? false;
       const mediaFiles = [];
       const scanDir = async (dir) => {
-        const entries2 = await readdir10(dir, { withFileTypes: true });
+        const entries2 = await readdir11(dir, { withFileTypes: true });
         for (const entry of entries2) {
           const entryPath = join77(dir, entry.name);
           if (entry.isDirectory() && recursive) {
@@ -312167,7 +312414,7 @@ var batchImportTool = defineTool({
         const source3 = project.addSource({ name: mediaName, type: mediaType, url: mediaFile, duration });
         addedSources.push({ id: source3.id, name: mediaName, type: mediaType });
       }
-      await writeFile49(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+      await writeFile50(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
       return {
         success: true,
         data: { count: addedSources.length, sources: addedSources },
@@ -312201,7 +312448,7 @@ var batchConcatTool = defineTool({
   async execute(args, ctx) {
     try {
       const filePath = resolve80(ctx.workingDirectory, args.project);
-      const content = await readFile48(filePath, "utf-8");
+      const content = await readFile46(filePath, "utf-8");
       const data2 = JSON.parse(content);
       const project = Project.fromJSON(data2);
       const sourceIds = args.sourceIds ?? [];
@@ -312237,7 +312484,7 @@ var batchConcatTool = defineTool({
         createdClips.push({ id: clip.id, sourceName: source3.name, startTime: currentTime, duration: source3.duration });
         currentTime += source3.duration + gap;
       }
-      await writeFile49(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+      await writeFile50(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
       const totalDuration = currentTime - gap - startTime;
       return {
         success: true,
@@ -312272,7 +312519,7 @@ var batchApplyEffectTool = defineTool({
   async execute(args, ctx) {
     try {
       const filePath = resolve80(ctx.workingDirectory, args.project);
-      const content = await readFile48(filePath, "utf-8");
+      const content = await readFile46(filePath, "utf-8");
       const data2 = JSON.parse(content);
       const project = Project.fromJSON(data2);
       const clipIds = args.clipIds ?? [];
@@ -312300,7 +312547,7 @@ var batchApplyEffectTool = defineTool({
         });
         if (effect) appliedEffects.push({ clipId: clip.id, effectId: effect.id });
       }
-      await writeFile49(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+      await writeFile50(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
       return {
         success: true,
         data: { applied: appliedEffects.length, effectType: args.effectType },
@@ -312327,7 +312574,7 @@ var timelineClearTool = defineTool({
   async execute(args, ctx) {
     try {
       const filePath = await resolveTimelineFile(args.project, ctx.workingDirectory);
-      const content = await readFile48(filePath, "utf-8");
+      const content = await readFile46(filePath, "utf-8");
       const data2 = JSON.parse(content);
       const project = Project.fromJSON(data2);
       const what = args.what ?? "clips";
@@ -312369,7 +312616,7 @@ var timelineClearTool = defineTool({
           removed.sources++;
         }
       }
-      await writeFile49(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+      await writeFile50(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
       const parts = [];
       if (removed.clips > 0) parts.push(`${removed.clips} clips`);
       if (removed.tracks > 0) parts.push(`${removed.tracks} tracks`);
@@ -312404,7 +312651,7 @@ var projectSetTool = defineTool({
   async execute(args, ctx) {
     try {
       const filePath = await resolveTimelineFile(args.projectPath, ctx.workingDirectory);
-      const content = await readFile48(filePath, "utf-8");
+      const content = await readFile46(filePath, "utf-8");
       const data2 = JSON.parse(content);
       const project = Project.fromJSON(data2);
       const updates = [];
@@ -312420,7 +312667,7 @@ var projectSetTool = defineTool({
         project.setFrameRate(args.fps);
         updates.push(`Frame Rate: ${args.fps} fps`);
       }
-      await writeFile49(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+      await writeFile50(filePath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
       return {
         success: true,
         data: { updates },
@@ -312678,8 +312925,8 @@ var mediaCompressTool = defineTool({
         ],
         { maxBuffer: 50 * 1024 * 1024 }
       );
-      const inputBuf = await readFile48(absInput);
-      const outputBuf = await readFile48(outputPath);
+      const inputBuf = await readFile46(absInput);
+      const outputBuf = await readFile46(outputPath);
       const inputSize = inputBuf.length;
       const outputSize = outputBuf.length;
       const reduction = (inputSize - outputSize) / inputSize * 100;
@@ -312790,7 +313037,7 @@ var mediaConcatTool = defineTool({
       } else {
         const tempList = resolve80(ctx.workingDirectory, `concat-list-${Date.now()}.txt`);
         const listContent = args.inputs.map((i3) => `file '${resolve80(ctx.workingDirectory, i3)}'`).join("\n");
-        await writeFile49(tempList, listContent, "utf-8");
+        await writeFile50(tempList, listContent, "utf-8");
         try {
           await execSafe(
             "ffmpeg",
@@ -313703,7 +313950,7 @@ async function handleToolCall(name, args, extra) {
 
 // src/resources/index.ts
 init_engine();
-import { readFile as readFile49 } from "node:fs/promises";
+import { readFile as readFile47 } from "node:fs/promises";
 import { resolve as resolve83 } from "node:path";
 var resources = [
   {
@@ -313740,7 +313987,7 @@ var resources = [
 var currentProjectPath = process.env.VIBE_PROJECT_PATH || null;
 async function loadProject2(projectPath) {
   const absPath = resolve83(process.cwd(), projectPath);
-  const content = await readFile49(absPath, "utf-8");
+  const content = await readFile47(absPath, "utf-8");
   const data2 = JSON.parse(content);
   return Project.fromJSON(data2);
 }
@@ -314132,14 +314379,14 @@ This creates a music video-style edit where cuts happen in rhythm with the music
 }
 
 // src/instructions.ts
-import { existsSync as existsSync84, mkdirSync as mkdirSync23 } from "node:fs";
+import { existsSync as existsSync85, mkdirSync as mkdirSync23 } from "node:fs";
 import { delimiter as delimiter2, isAbsolute as isAbsolute14, resolve as resolve84 } from "node:path";
 var DEFAULT_EXTRA_PATH_DIRS = process.platform === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin", "/opt/local/bin"] : ["/usr/local/bin"];
 function ensureSystemPath(env4 = process.env, extraDirs = DEFAULT_EXTRA_PATH_DIRS) {
   const current = (env4.PATH ?? "").split(delimiter2).filter(Boolean);
   const added = [];
   for (const dir of extraDirs) {
-    if (!current.includes(dir) && existsSync84(dir)) {
+    if (!current.includes(dir) && existsSync85(dir)) {
       current.push(dir);
       added.push(dir);
     }
@@ -314242,7 +314489,7 @@ function handleCliFlags(argv, version2) {
 }
 
 // src/index.ts
-if (handleCliFlags(process.argv.slice(2), "0.114.0")) {
+if (handleCliFlags(process.argv.slice(2), "0.115.0")) {
   process.exit(0);
 }
 console.log = (...args) => console.error(...args);
@@ -314255,7 +314502,7 @@ var server = new Server(
   {
     name: "vibeframe",
     // Stamped with the package version by build.js at bundle time.
-    version: "0.114.0"
+    version: "0.115.0"
   },
   {
     capabilities: {