luckiest-co 1.0.19 → 1.0.21

package/skills/luckiest-video-studio/scripts/analyze_music_cues.py

@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+"""Generate music cue metadata (tempo, beat grid, strong cues) for any track.
+
+Used two ways: (1) a maintainer tool to precompute the bundled-track cue
+presets, and (2) an optional runtime "extended" beat-sync path for /brag on
+any track when Python + librosa are available (see references/audio.md ->
+"Beat and cue sources"). When those deps are absent, /brag falls back to
+`npx hyperframes beats`. Takes any audio file as input.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+import librosa
+import numpy as np
+
+
+HOP_LENGTH = 512
+FRAME_LENGTH = 2048
+BASS_N_FFT = 4096
+BASS_MIN_HZ = 30.0
+BASS_MAX_HZ = 180.0
+
+
+def _as_float(value: Any) -> float:
+    array = np.asarray(value)
+    if array.size == 0:
+        return 0.0
+    return float(array.reshape(-1)[0])
+
+
+def _finite_round(value: float, digits: int = 4) -> float:
+    if not math.isfinite(value):
+        return 0.0
+    return round(float(value), digits)
+
+
+def _normalize(values: np.ndarray) -> np.ndarray:
+    values = np.asarray(values, dtype=float)
+    values = np.nan_to_num(values, nan=0.0, posinf=0.0, neginf=0.0)
+    if values.size == 0:
+        return values
+    values = np.maximum(values, 0.0)
+    high = np.percentile(values, 98)
+    if high <= 1e-12:
+        high = np.max(values)
+    if high <= 1e-12:
+        return np.zeros_like(values)
+    return np.clip(values / high, 0.0, 1.0)
+
+
+def _feature_at(feature: np.ndarray, frame: int) -> float:
+    if feature.size == 0:
+        return 0.0
+    index = int(np.clip(frame, 0, feature.size - 1))
+    return float(feature[index])
+
+
+def _local_contrast(onset_norm: np.ndarray, frame: int, sr: int) -> float:
+    radius = max(1, int(round(0.5 * sr / HOP_LENGTH)))
+    start = max(0, frame - radius)
+    end = min(onset_norm.size, frame + radius + 1)
+    local = onset_norm[start:end]
+    if local.size == 0:
+        return 0.0
+    median = float(np.median(local))
+    return max(0.0, _feature_at(onset_norm, frame) - median)
+
+
+def _score_frame(
+    frame: int,
+    onset_norm: np.ndarray,
+    contrast_norm: np.ndarray,
+    rms_norm: np.ndarray,
+    bass_norm: np.ndarray,
+) -> dict[str, float]:
+    onset = _feature_at(onset_norm, frame)
+    contrast = _feature_at(contrast_norm, frame)
+    rms = _feature_at(rms_norm, frame)
+    bass = _feature_at(bass_norm, frame)
+    intensity = 0.45 * onset + 0.25 * contrast + 0.20 * rms + 0.10 * bass
+    return {
+        "intensity": float(np.clip(intensity, 0.0, 1.0)),
+        "onsetStrength": onset,
+        "localOnsetContrast": contrast,
+        "rms": rms,
+        "bassEnergy": bass,
+    }
+
+
+def _dedupe_cues(cues: list[dict[str, Any]], min_gap: float = 0.18) -> list[dict[str, Any]]:
+    sorted_by_strength = sorted(cues, key=lambda item: item["intensity"], reverse=True)
+    accepted: list[dict[str, Any]] = []
+    for cue in sorted_by_strength:
+        if all(abs(cue["time"] - existing["time"]) >= min_gap for existing in accepted):
+            accepted.append(cue)
+    return sorted(accepted, key=lambda item: item["time"])
+
+
+def _compact_times(items: list[dict[str, Any]], max_items: int = 48) -> str:
+    subset = items[:max_items]
+    text = ", ".join(f"{item['time']:.2f}" for item in subset)
+    if len(items) > max_items:
+        text += f", ... (+{len(items) - max_items} more)"
+    return text or "none"
+
+
+def _format_cue(cue: dict[str, Any]) -> str:
+    return f"{cue['time']:.2f}s ({cue['intensity']:.2f}, {cue['kind']})"
+
+
+def analyze_track(
+    input_path: Path,
+    window_start: float,
+    window_duration: float,
+    top_cues: int,
+    sr: int,
+) -> tuple[dict[str, Any], str]:
+    y, actual_sr = librosa.load(input_path, sr=sr, mono=True)
+    duration = float(librosa.get_duration(y=y, sr=actual_sr))
+    window_end = min(duration, window_start + window_duration)
+
+    onset_env = librosa.onset.onset_strength(
+        y=y,
+        sr=actual_sr,
+        hop_length=HOP_LENGTH,
+    )
+    onset_norm = _normalize(onset_env)
+
+    local_contrast = np.array(
+        [_local_contrast(onset_norm, frame, actual_sr) for frame in range(onset_norm.size)]
+    )
+    contrast_norm = _normalize(local_contrast)
+
+    rms = librosa.feature.rms(
+        y=y,
+        frame_length=FRAME_LENGTH,
+        hop_length=HOP_LENGTH,
+    )[0]
+    rms_norm = _normalize(rms)
+
+    spectrum = np.abs(librosa.stft(y, n_fft=BASS_N_FFT, hop_length=HOP_LENGTH))
+    frequencies = librosa.fft_frequencies(sr=actual_sr, n_fft=BASS_N_FFT)
+    bass_mask = (frequencies >= BASS_MIN_HZ) & (frequencies <= BASS_MAX_HZ)
+    if np.any(bass_mask):
+        bass = np.mean(spectrum[bass_mask], axis=0)
+    else:
+        bass = np.zeros(spectrum.shape[1])
+    bass_norm = _normalize(bass)
+
+    tempo, beat_frames = librosa.beat.beat_track(
+        y=y,
+        sr=actual_sr,
+        onset_envelope=onset_env,
+        hop_length=HOP_LENGTH,
+        units="frames",
+    )
+    beat_frames = np.asarray(beat_frames, dtype=int)
+    beat_times = librosa.frames_to_time(beat_frames, sr=actual_sr, hop_length=HOP_LENGTH)
+
+    beats: list[dict[str, Any]] = []
+    cue_candidates: list[dict[str, Any]] = []
+    for frame, time in zip(beat_frames, beat_times):
+        score = _score_frame(frame, onset_norm, contrast_norm, rms_norm, bass_norm)
+        beat = {
+            "time": _finite_round(float(time)),
+            "intensity": _finite_round(score["intensity"]),
+            "features": {
+                "onsetStrength": _finite_round(score["onsetStrength"]),
+                "localOnsetContrast": _finite_round(score["localOnsetContrast"]),
+                "rms": _finite_round(score["rms"]),
+                "bassEnergy": _finite_round(score["bassEnergy"]),
+            },
+        }
+        beats.append(beat)
+        cue_candidates.append({**beat, "kind": "strong_beat"})
+
+    onset_frames = librosa.onset.onset_detect(
+        onset_envelope=onset_env,
+        sr=actual_sr,
+        hop_length=HOP_LENGTH,
+        backtrack=False,
+        units="frames",
+    )
+    for frame in np.asarray(onset_frames, dtype=int):
+        time = float(librosa.frames_to_time(frame, sr=actual_sr, hop_length=HOP_LENGTH))
+        score = _score_frame(frame, onset_norm, contrast_norm, rms_norm, bass_norm)
+        cue_candidates.append(
+            {
+                "time": _finite_round(time),
+                "intensity": _finite_round(score["intensity"]),
+                "kind": "onset_peak",
+                "features": {
+                    "onsetStrength": _finite_round(score["onsetStrength"]),
+                    "localOnsetContrast": _finite_round(score["localOnsetContrast"]),
+                    "rms": _finite_round(score["rms"]),
+                    "bassEnergy": _finite_round(score["bassEnergy"]),
+                },
+            }
+        )
+
+    strong_cues = [
+        cue
+        for cue in _dedupe_cues(cue_candidates)
+        if cue["intensity"] >= 0.45
+    ]
+    strongest = sorted(strong_cues, key=lambda cue: cue["intensity"], reverse=True)[:64]
+    strong_cues = sorted(strongest, key=lambda cue: cue["time"])
+
+    data = {
+        "schemaVersion": 1,
+        "source": {
+            "filename": input_path.name,
+            "trackStem": input_path.stem,
+        },
+        "duration": _finite_round(duration, 3),
+        "tempo": _finite_round(_as_float(tempo), 2),
+        "analysis": {
+            "sampleRate": actual_sr,
+            "hopLength": HOP_LENGTH,
+            "windowStart": _finite_round(window_start, 3),
+            "windowDuration": _finite_round(window_duration, 3),
+            "windowEnd": _finite_round(window_end, 3),
+        },
+        "scoring": {
+            "intensityFormula": "0.45*onset_strength + 0.25*local_onset_contrast + 0.20*rms + 0.10*bass_energy",
+            "features": ["onset_strength", "local_onset_contrast", "rms", "bass_energy"],
+            "normalization": "Per-track robust normalization to 0-1 using the 98th percentile, then clamped.",
+            "strongCueMinimumIntensity": 0.45,
+            "strongCueMaxCount": 64,
+        },
+        "beats": beats,
+        "strongCues": strong_cues,
+    }
+
+    window_beats = [
+        beat for beat in beats if window_start <= beat["time"] <= window_end
+    ]
+    window_cues = [
+        cue for cue in strong_cues if window_start <= cue["time"] <= window_end
+    ]
+    top_window_cues = sorted(window_cues, key=lambda cue: cue["intensity"], reverse=True)[:top_cues]
+    reveal_candidates = top_window_cues[: min(5, len(top_window_cues))]
+
+    markdown = "\n".join(
+        [
+            f"# Music Cues: {input_path.stem}",
+            "",
+            f"- Track: `{input_path.name}`",
+            f"- Duration: {duration:.2f}s",
+            f"- Estimated tempo: {_as_float(tempo):.2f} BPM",
+            f"- Planning window: {window_start:.2f}-{window_end:.2f}s",
+            "",
+            "## Useful Beat Grid",
+            "",
+            _compact_times(window_beats),
+            "",
+            "## Strong Cues In Window",
+            "",
+            "\n".join(f"- {_format_cue(cue)}" for cue in top_window_cues) or "- none",
+            "",
+            "## Reveal Candidates",
+            "",
+            "\n".join(f"- {_format_cue(cue)}" for cue in reveal_candidates) or "- none",
+            "",
+            "## Use Policy",
+            "",
+            "Use these as optional timing hints. Major reveals may move toward a nearby strong cue within about 0.15s; smaller entrances may align to nearby beats within about 0.10s. Ignore cues when they harm story, readability, or pacing.",
+            "",
+        ]
+    )
+
+    return data, markdown
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Analyze a bundled music track and write /brag cue presets."
+    )
+    parser.add_argument("input", type=Path, help="Input audio file.")
+    parser.add_argument("--output-json", type=Path, required=True)
+    parser.add_argument("--output-md", type=Path, required=True)
+    parser.add_argument("--window-start", type=float, default=0.0)
+    parser.add_argument("--window-duration", type=float, default=25.0)
+    parser.add_argument("--top-cues", type=int, default=10)
+    parser.add_argument("--sr", type=int, default=44100)
+    args = parser.parse_args()
+
+    data, markdown = analyze_track(
+        input_path=args.input,
+        window_start=args.window_start,
+        window_duration=args.window_duration,
+        top_cues=args.top_cues,
+        sr=args.sr,
+    )
+
+    args.output_json.parent.mkdir(parents=True, exist_ok=True)
+    args.output_md.parent.mkdir(parents=True, exist_ok=True)
+    args.output_json.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    args.output_md.write_text(markdown, encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

package/skills/luckiest-video-studio/scripts/assemble-diffusion.mjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+// Write a Diffusion Studio project for a rendered run: line-draw logo scenes become native, editable
+// Diffusion scenes; every other scene plays its rendered clip (demo scenes play the raw footage, trimmed).
+// Usage: node assemble-diffusion.mjs <run-dir> [--open] [--export [out.mp4]]
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const args = process.argv.slice(2);
+const runDir = resolve(args.find((a) => !a.startsWith("--") && !/\.(mp4|mov|webm)$/i.test(a)) ?? ".");
+const wantOpen = args.includes("--open") || args.includes("--export");
+const exportOut = args.includes("--export") ? resolve(args.find((a) => /\.(mp4|mov|webm)$/i.test(a)) ?? join(runDir, "final-diffusion.mp4")) : null;
+const skillDir = join(dirname(fileURLToPath(import.meta.url)), "..");
+const cli = process.env.DIFFUSION_CLI ?? "/Applications/Diffusion Studio.app/Contents/Resources/cli/bin/dapi";
+const fail = (m) => { console.error(`error: ${m}`); process.exit(1); };
+
+const sb = JSON.parse(readFileSync(join(runDir, "storyboard.json"), "utf8"));
+const brand = existsSync(join(runDir, "brand.json")) ? JSON.parse(readFileSync(join(runDir, "brand.json"), "utf8")) : {};
+const { width: W, height: H, fps } = sb.format;
+const proj = join(runDir, "diffusion");
+mkdirSync(join(proj, "logos"), { recursive: true });
+mkdirSync(join(proj, "assets"), { recursive: true });
+copyFileSync(join(skillDir, "templates", "diffusion", "line-draw.tsx"), join(proj, "line-draw.tsx"));
+
+// Media is linked into assets/ and named by library path, as Diffusion's editor guide asks.
+const link = (rel) => {
+  const src = join(runDir, rel);
+  if (!existsSync(src)) fail(`missing ${rel}`);
+  const dst = join(proj, "assets", rel);
+  mkdirSync(dirname(dst), { recursive: true });
+  rmSync(dst, { force: true });
+  symlinkSync(src, dst);
+  return rel;
+};
+
+// Minimal SVG reader: path data, its fill (attribute or class), and whether it sits under a clipPath.
+// ponytail: handles flat Illustrator-style exports; nested transforms are not applied, flatten those first.
+function readLogo(file) {
+  const svg = readFileSync(file, "utf8");
+  const classFill = Object.fromEntries([...svg.matchAll(/\.([\w-]+)\s*\{[^}]*?fill:\s*(#[0-9a-fA-F]{3,8}|[a-z]+)/g)].map((m) => [m[1], m[2]]));
+  const clipClasses = new Set([...svg.matchAll(/\.([\w-]+)\s*\{[^}]*?clip-path:/g)].map((m) => m[1]));
+  const clipRect = svg.match(/<clipPath[\s\S]*?<rect[^>]*?x="([-\d.]+)"[^>]*?y="([-\d.]+)"[^>]*?width="([\d.]+)"[^>]*?height="([\d.]+)"/);
+  const paths = [];
+  const stack = [];
+  for (const m of svg.matchAll(/<(\/?)(g|path|clipPath|defs)\b([^>]*?)(\/?)>/g)) {
+    const [, close, tag, attrs, self] = m;
+    const cls = (attrs.match(/class="([^"]+)"/) ?? [])[1]?.split(/\s+/) ?? [];
+    if (tag === "g" || tag === "clipPath" || tag === "defs") {
+      if (close) stack.pop();
+      else if (!self) stack.push({ tag, clip: /clip-path=/.test(attrs) || cls.some((c) => clipClasses.has(c)) });
+      continue;
+    }
+    if (close || stack.some((s) => s.tag === "defs" || s.tag === "clipPath")) continue;
+    const d = (attrs.match(/\sd="([^"]+)"/) ?? [])[1];
+    if (!d) continue;
+    const fill = (attrs.match(/fill="([^"]+)"/) ?? [])[1] ?? cls.map((c) => classFill[c]).find(Boolean) ?? "#000000";
+    if (fill === "none") continue;
+    paths.push({ d, fill, clip: stack.some((s) => s.clip) });
+  }
+  if (!paths.length) fail(`${file}: no filled paths found`);
+  return { paths, clip: clipRect ? clipRect.slice(1, 5).map(Number) : null };
+}
+
+const camel = (id) => id.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+const inspect = [];
+const imports = [];
+const nodes = [];
+let t = 0;
+for (const [i, s] of sb.scenes.entries()) {
+  const name = `${String(i + 1).padStart(2, "0")}-${s.id}.mp4`;
+  const start = +t.toFixed(3);
+  const end = +(t + s.duration).toFixed(3);
+  const svgRel = (s.assets ?? []).find((a) => a.toLowerCase().endsWith(".svg"));
+  if (s.kind === "logo" && s.recipe === "line-draw" && svgRel) {
+    const art = readLogo(join(runDir, svgRel));
+    const v = camel(s.id);
+    writeFileSync(join(proj, "logos", `${s.id}.ts`), `import type { LogoArt } from "../line-draw";\n\nconst art: LogoArt = ${JSON.stringify(art)};\nexport default art;\n`);
+    imports.push(`import ${v}Art from "./logos/${s.id}";`);
+    inspect.push(
+      `/** @inspect text path="${s.id}/Caption" */\nconst ${v}Caption = ${JSON.stringify(s.variables?.caption ?? "")};`,
+      `/** @inspect number path="${s.id}/Draw seconds" min=0.5 max=4 step=0.1 */\nconst ${v}DrawSeconds = ${s.variables?.drawSeconds ?? 1.9};`,
+      `/** @inspect number path="${s.id}/Logo size" min=200 max=${Math.min(W, H)} step=10 */\nconst ${v}LogoSize = ${s.variables?.logoSize ?? Math.round(Math.min(W, H) * 0.52)};`,
+    );
+    nodes.push(`        <LineDrawLogo id="${s.id}" art={${v}Art} start={${start}} duration={${s.duration}} width={${W}} height={${H}} caption={${v}Caption} ink={ink} font={font} drawSeconds={${v}DrawSeconds} logoSize={${v}LogoSize} />`);
+  } else if (s.kind === "demo") {
+    const src = link(s.source);
+    nodes.push(`        <video id="${s.id}" src="${src}" width={${W}} height={${H}} objectFit="contain" start={${start}} sourceIn={${s.sourceStart ?? 0}} end={${end}} />`);
+  } else {
+    const src = link(join("clips", name));
+    nodes.push(`        <video id="${s.id}" src="${src}" width={${W}} height={${H}} start={${start}} end={${end}} />`);
+  }
+  t = end;
+}
+if (sb.music?.file) {
+  const src = link(sb.music.file);
+  const db = (20 * Math.log10(sb.music.volume ?? 0.35)).toFixed(1);
+  nodes.push(`        <audio id="music" src="${src}" start={0} end={${+t.toFixed(3)}} volume={${db}} />`);
+}
+
+const tsx = `/* ${sb.title}: generated by luckiest-video-studio from storyboard.json. Edit here or in the inspector. */
+${imports.length ? `import { LineDrawLogo } from "./line-draw";\n${imports.join("\n")}\n` : ""}
+/** @inspect color path="Brand/Paper" */
+const paper = ${JSON.stringify(brand.paper ?? "#FFFFFF")};
+/** @inspect color path="Brand/Ink" */
+const ink = ${JSON.stringify(brand.ink ?? "#0A0A0A")};
+/** @inspect font path="Brand/Caption font" */
+const font = ${JSON.stringify(brand.text ?? "Inter")};
+
+${inspect.join("\n")}
+
+export default function Video() {
+  return (
+    <stage>
+      <scene id="main" name=${JSON.stringify(sb.title)} width={${W}} height={${H}} fill={paper} active>
+        <sequence id="spine">
+${nodes.join("\n")}
+        </sequence>
+      </scene>
+    </stage>
+  );
+}
+`;
+writeFileSync(join(proj, "index.tsx"), tsx);
+console.log(`wrote ${join(proj, "index.tsx")} (${sb.scenes.length} scenes, ${t.toFixed(2)}s, ${imports.length} native logo scene(s))`);
+
+if (!wantOpen) process.exit(0);
+if (!existsSync(cli)) fail(`Diffusion Studio CLI not found at ${cli}; install the app or set DIFFUSION_CLI`);
+const dapi = (...a) => {
+  const r = spawnSync(cli, a, { encoding: "utf8" });
+  if (r.status !== 0) fail(`dapi ${a[0]}: ${(r.stderr || r.stdout).trim()}`);
+  return r.stdout.trim();
+};
+dapi("open", proj);
+
+// Export settings live in the project's package.json, merged after open so Diffusion's own fields stay.
+const pkgPath = join(proj, "package.json");
+const pkg = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf8")) : {};
+pkg.diffusion = { ...(pkg.diffusion ?? {}), export: { ...(pkg.diffusion?.export ?? {}), main: {
+  format: "mp4",
+  video: { enabled: true, codec: "avc", bitrate: 12000000, fps, resolution: Math.min(W, H) },
+  audio: { enabled: true, codec: "aac", sampleRate: 48000, bitrate: 192000 },
+} } };
+writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+
+// Opening compiles in the background; wait until the scene exists before checking it.
+let check = null;
+for (let i = 0; i < 30 && !check; i++) {
+  const r = spawnSync(cli, ["check", "main"], { encoding: "utf8" });
+  if (r.status === 0) check = JSON.parse(r.stdout);
+  else spawnSync("sleep", ["1"]);
+}
+if (!check) fail(`scene "main" never compiled; run: ${basename(cli)} logs`);
+const errors = check.issues.filter((x) => x.severity === "error");
+console.log(`check: ${check.stats.nodes} nodes, ${check.issues.length} issue(s)${errors.length ? `, ${errors.length} error(s)` : ""}`);
+for (const x of check.issues) console.log(`  ${x.severity} ${x.node}: ${x.message}`);
+if (errors.length) process.exit(1);
+if (exportOut) {
+  const res = JSON.parse(dapi("export", "main", exportOut));
+  console.log(`exported ${res.path} (${res.width}x${res.height}, ${res.duration}s)`);
+}

package/skills/luckiest-video-studio/scripts/assemble-openscreen.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// Write an OpenScreen 1.13.0 timeline (schemaVersion 7) for a rendered run: motion and logo scenes as their
+// rendered clips, demo scenes as the raw footage with in/out points so trims can be widened in the editor.
+// Usage: node assemble-openscreen.mjs <run-dir> [--dest ~/Movies/Openscreen] [--name <slug>]
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+
+// ponytail: pinned to OpenScreen 1.13.0, which rejects schemaVersion 8. Bump with the next release after testing.
+const SCHEMA_VERSION = 7;
+
+const args = process.argv.slice(2);
+const opt = (k) => (args.includes(k) ? args[args.indexOf(k) + 1] : undefined);
+const runDir = resolve(args.find((a, i) => !a.startsWith("--") && !["--dest", "--name"].includes(args[i - 1])) ?? ".");
+const fail = (msg) => { console.error(`error: ${msg}`); process.exit(1); };
+
+const sb = JSON.parse(readFileSync(join(runDir, "storyboard.json"), "utf8"));
+const slug = (opt("--name") ?? sb.title).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "video";
+const destDir = join(resolve((opt("--dest") ?? "~/Movies/Openscreen").replace(/^~/, homedir())), slug);
+mkdirSync(destDir, { recursive: true });
+
+const probe = (file) => {
+  const r = spawnSync("ffprobe", ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=codec_name,width,height,r_frame_rate:format=duration", "-of", "json", file], { encoding: "utf8" });
+  if (r.status !== 0) fail(`ffprobe failed on ${file}`);
+  const j = JSON.parse(r.stdout);
+  const v = j.streams?.[0] ?? {};
+  const [n, d] = (v.r_frame_rate ?? "0/1").split("/").map(Number);
+  return { durationSec: Number(j.format?.duration ?? 0), video: { codec: v.codec_name ?? "unknown", width: v.width ?? 0, height: v.height ?? 0, fps: d ? n / d : 0 } };
+};
+
+// One asset per distinct media file; demo scenes that share footage share an asset.
+const assets = new Map();
+const assetFor = (src, label) => {
+  const key = resolve(src);
+  if (assets.has(key)) return assets.get(key);
+  if (!existsSync(src)) fail(`missing ${src}`);
+  const dest = join(destDir, basename(src));
+  if (resolve(src) !== resolve(dest)) copyFileSync(src, dest);
+  const cursor = src.replace(/\.[^.]+$/, ".cursor.json");
+  if (existsSync(cursor)) copyFileSync(cursor, dest.replace(/\.[^.]+$/, ".cursor.json"));
+  const a = { id: `a-${assets.size + 1}-${label}`, kind: "video", label, originalPath: dest, ...probe(dest) };
+  assets.set(key, a);
+  return a;
+};
+
+let t = 0;
+const clips = sb.scenes.map((s, i) => {
+  const name = `${String(i + 1).padStart(2, "0")}-${s.id}.mp4`;
+  const demo = s.kind === "demo";
+  const src = demo ? join(runDir, s.source) : join(runDir, "clips", name);
+  if (!demo && !existsSync(src)) fail(`scene ${s.id} has no clip; run render-scenes.mjs first`);
+  const asset = assetFor(src, demo ? s.id : name.replace(/\.mp4$/, ""));
+  const start = demo ? (s.sourceStart ?? 0) : 0;
+  const end = Math.min(start + s.duration, asset.durationSec || start + s.duration);
+  const clip = { id: `c-${s.id}`, assetId: asset.id, sourceStartSec: start, sourceEndSec: end, timelineStartSec: t, timelineEndSec: t + (end - start), wordRefs: [], origin: "agent", reason: s.line ?? s.kind };
+  t = clip.timelineEndSec;
+  return clip;
+});
+
+const now = new Date().toISOString();
+const doc = {
+  schemaVersion: SCHEMA_VERSION,
+  project: { id: `lvs-${slug}`, title: sb.title, createdAt: now, updatedAt: now, primaryAssetId: clips[0].assetId },
+  assets: [...assets.values()],
+  timeline: { clips, gaps: [], trimRanges: [], muteRanges: [], speedRanges: [], captionRanges: [] },
+  annotations: [],
+  zoomRanges: [],
+};
+const projectFile = join(destDir, `${slug}.openscreen`);
+writeFileSync(projectFile, JSON.stringify(doc, null, 2));
+writeFileSync(join(runDir, "project.openscreen.txt"), `${projectFile}\n`);
+console.log(`wrote ${projectFile}`);
+console.log(`${clips.length} clips, ${assets.size} media files, ${t.toFixed(2)}s. Open it in OpenScreen, edit, then click Export.`);

package/skills/luckiest-video-studio/scripts/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "brag"
+version = "0.1.0"
+description = "Development tooling for the /brag skill."
+requires-python = ">=3.11"
+dependencies = [
+  "librosa>=0.10.2",
+  "numpy>=1.26",
+  "scipy>=1.11",
+  "soundfile>=0.12",
+]
+
+[tool.uv]
+package = false