luckiest-co 1.0.19 → 1.0.21

package/skills/luckiest-video-studio-cuts/scripts/cut-silences.mjs

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+// luckiest-video-studio-cuts: silence pass
+// Pure pause/silence trimmer. Takes any word-level transcript (ElevenLabs Scribe
+// shape, or { words: [{ text, start, end }] }) and removes silences only:
+//   - dead air before the first word and after the last word (head/tail trim)
+//   - inter-word pauses longer than --gap, trimmed down to a natural breath
+//
+// It does NOT cut repeats, false starts, or mistakes: that is the mistake pass.
+//
+// Outputs (next to the transcript, or --out-dir):
+//   <stem>.silence-edl.json          keep/delete ranges + summary + params
+//   <stem>.silence-transcript.json   re-timed words on the edited timeline
+//   <stem>.silence-decisions.md       human-readable summary
+// And, with --video, the ffmpeg command to make the cut (run it with --apply).
+//
+// Usage:
+//   node cut-silences.mjs <transcript.json> [options]
+//
+// Options:
+//   --video <path>        source video; enables real cutting / ffmpeg command
+//   --out-dir <dir>       output directory (default: alongside the transcript)
+//   --output <path>       cut-video path (default: <video-stem>.silenced.mp4)
+//   --gap <seconds>       min pause treated as trimmable silence (default 0.55)
+//   --head-pad <seconds>  silence kept before the first word (default 0.22)
+//   --tail-pad <seconds>  silence kept after the last word (default 0.34)
+//   --apply               actually run ffmpeg to render the cut video
+//   --help
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { dirname, join, resolve, basename, extname } from "node:path";
+import { spawnSync } from "node:child_process";
+import { argv, exit } from "node:process";
+
+function die(msg, code = 1) {
+  console.error(msg);
+  exit(code);
+}
+
+// ---- parse args ----
+const args = argv.slice(2);
+if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+  console.log(
+    "Usage: node cut-silences.mjs <transcript.json> [--video path] [--out-dir dir]\n" +
+      "       [--output path] [--gap 0.55] [--head-pad 0.22] [--tail-pad 0.34] [--apply]",
+  );
+  exit(args.length === 0 ? 1 : 0);
+}
+
+const opts = {
+  transcript: null,
+  video: null,
+  outDir: null,
+  output: null,
+  gap: 0.55,
+  headPad: 0.22,
+  tailPad: 0.34,
+  apply: false,
+};
+for (let i = 0; i < args.length; i++) {
+  const a = args[i];
+  if (a === "--video") opts.video = args[++i];
+  else if (a === "--out-dir") opts.outDir = args[++i];
+  else if (a === "--output" || a === "-o") opts.output = args[++i];
+  else if (a === "--gap") opts.gap = Number(args[++i]);
+  else if (a === "--head-pad") opts.headPad = Number(args[++i]);
+  else if (a === "--tail-pad") opts.tailPad = Number(args[++i]);
+  else if (a === "--apply") opts.apply = true;
+  else if (a.startsWith("--")) die(`unknown option: ${a}`);
+  else if (!opts.transcript) opts.transcript = a;
+  else die(`unexpected argument: ${a}`);
+}
+if (!opts.transcript) die("no transcript file given");
+if (!Number.isFinite(opts.gap) || opts.gap <= 0) die("--gap must be a positive number");
+
+const transcriptPath = resolve(opts.transcript);
+if (!existsSync(transcriptPath)) die(`transcript not found: ${transcriptPath}`);
+
+// ---- load + normalize transcript ----
+let transcript = JSON.parse(readFileSync(transcriptPath, "utf8"));
+if (Array.isArray(transcript)) transcript = { words: transcript }; // hyperframes transcribe writes a bare word array
+if (!Array.isArray(transcript.words)) die("transcript has no `words` array");
+
+// Keep only real spoken words with numeric timing. ElevenLabs tags spacing/audio
+// events with type !== "word"; generic transcripts may omit `type` entirely.
+const words = transcript.words
+  .filter((w) => (w.type ? w.type === "word" : true))
+  .filter((w) => Number.isFinite(Number(w.start)) && Number.isFinite(Number(w.end)))
+  .map((w, index) => ({ index, text: w.text, start: Number(w.start), end: Number(w.end) }));
+
+if (words.length === 0) die("no timed words found in transcript");
+
+// Source duration: prefer the transcript's own value, else probe the video, else
+// fall back to just past the last word.
+let duration = Number(transcript.audio_duration_secs);
+if (!Number.isFinite(duration)) {
+  if (opts.video && existsSync(resolve(opts.video))) {
+    const probe = spawnSync("ffprobe", [
+      "-v", "error", "-show_entries", "format=duration",
+      "-of", "default=noprint_wrappers=1:nokey=1", resolve(opts.video),
+    ]);
+    const d = Number(probe.stdout?.toString().trim());
+    if (Number.isFinite(d)) duration = d;
+  }
+}
+if (!Number.isFinite(duration)) duration = words.at(-1).end + opts.tailPad;
+
+// ---- build the delete ranges (silence only) ----
+function mergeRanges(ranges) {
+  const sorted = ranges
+    .filter((r) => Number.isFinite(r.start) && Number.isFinite(r.end) && r.end > r.start)
+    .sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const range of sorted) {
+    const last = merged.at(-1);
+    if (!last || range.start > last.end) {
+      merged.push({ start: range.start, end: range.end, reasons: [range.reason] });
+    } else {
+      last.end = Math.max(last.end, range.end);
+      last.reasons.push(range.reason);
+    }
+  }
+  return merged;
+}
+
+const deleteRanges = [];
+
+// head + tail dead air
+const headEnd = words[0].start - opts.headPad;
+if (headEnd > 0) deleteRanges.push({ start: 0, end: headEnd, reason: "head trim before first word" });
+const tailStart = words.at(-1).end + opts.tailPad;
+if (duration > tailStart) deleteRanges.push({ start: tailStart, end: duration, reason: "tail trim after final word" });
+
+// inter-word pauses
+for (let i = 1; i < words.length; i++) {
+  const prev = words[i - 1];
+  const next = words[i];
+  const gap = next.start - prev.end;
+  if (gap < opts.gap) continue;
+
+  // Keep a natural breath: longer for big pauses and sentence boundaries.
+  const sentenceBreak = /[.!?]$/.test(prev.text ?? "");
+  const keep = gap >= 2 ? 0.24 : sentenceBreak ? 0.2 : 0.14;
+  // Bias the kept breath slightly toward the end of the previous phrase.
+  const delStart = prev.end + keep * 0.55;
+  const delEnd = next.start - keep * 0.45;
+  if (delEnd > delStart) {
+    deleteRanges.push({ start: delStart, end: delEnd, reason: `pause ${gap.toFixed(2)}s -> ${keep.toFixed(2)}s` });
+  }
+}
+
+const mergedDeletes = mergeRanges(deleteRanges);
+
+// ---- keep ranges = the complement of the deletes ----
+const keepRanges = [];
+let cursor = 0;
+for (const del of mergedDeletes) {
+  if (del.start > cursor) keepRanges.push({ start: cursor, end: del.start });
+  cursor = Math.max(cursor, del.end);
+}
+if (cursor < duration) keepRanges.push({ start: cursor, end: duration });
+const usableKeepRanges = keepRanges.filter((r) => r.end - r.start >= 0.04);
+
+const removedTotal = mergedDeletes.reduce((sum, r) => sum + (r.end - r.start), 0);
+const editedDuration = Number((duration - removedTotal).toFixed(3));
+
+// ---- re-time the transcript onto the edited timeline ----
+function removedBefore(time) {
+  let removed = 0;
+  for (const del of mergedDeletes) {
+    if (del.end <= time) removed += del.end - del.start;
+    else if (del.start < time) removed += time - del.start;
+    else break;
+  }
+  return removed;
+}
+function inDeleted(word) {
+  return mergedDeletes.some((del) => word.start < del.end && del.start < word.end);
+}
+
+const editedWords = [];
+for (const word of words) {
+  if (inDeleted(word)) continue; // a word fully swallowed by a trim (rare for pure silence)
+  editedWords.push({
+    text: word.text,
+    source_start: word.start,
+    source_end: word.end,
+    start: Number((word.start - removedBefore(word.start)).toFixed(3)),
+    end: Number((word.end - removedBefore(word.end)).toFixed(3)),
+  });
+}
+
+// ---- ffmpeg trim+concat filtergraph (reliable A/V-synced cut) ----
+function buildFilterScript(ranges) {
+  const lines = [];
+  for (let i = 0; i < ranges.length; i++) {
+    const r = ranges[i];
+    lines.push(`[0:v]trim=start=${r.start.toFixed(3)}:end=${r.end.toFixed(3)},setpts=PTS-STARTPTS[v${i}];`);
+    lines.push(`[0:a]atrim=start=${r.start.toFixed(3)}:end=${r.end.toFixed(3)},asetpts=PTS-STARTPTS[a${i}];`);
+  }
+  const inputs = ranges.map((_, i) => `[v${i}][a${i}]`).join("");
+  lines.push(`${inputs}concat=n=${ranges.length}:v=1:a=1[v][a]`);
+  return lines.join("\n");
+}
+
+// ---- write outputs ----
+const stem = basename(transcriptPath, extname(transcriptPath)).replace(/[-.]?transcript.*$/i, "") || "source";
+const outDir = opts.outDir ? resolve(opts.outDir) : dirname(transcriptPath);
+mkdirSync(outDir, { recursive: true });
+
+const params = { gap: opts.gap, headPad: opts.headPad, tailPad: opts.tailPad };
+const edl = {
+  agent: "cut-silences",
+  params,
+  source_duration: duration,
+  edited_duration: editedDuration,
+  removed: Number(removedTotal.toFixed(3)),
+  delete_ranges: mergedDeletes,
+  keep_ranges: usableKeepRanges,
+};
+const transcriptOut = {
+  language_code: transcript.language_code,
+  source_audio_duration_secs: duration,
+  audio_duration_secs: editedDuration,
+  produced_by: "cut-silences",
+  words: editedWords,
+};
+
+function fmt(s) {
+  const m = Math.floor(s / 60);
+  return `${String(m).padStart(2, "0")}:${(s - m * 60).toFixed(2).padStart(5, "0")}`;
+}
+const pauseDeletes = mergedDeletes.filter((d) => d.reasons.some((r) => r?.startsWith("pause")));
+const decisions = [
+  "# Cut-Silences Decisions",
+  "",
+  `Source duration: ${fmt(duration)} (${duration.toFixed(2)}s)`,
+  `Edited duration: ${fmt(editedDuration)} (${editedDuration.toFixed(2)}s)`,
+  `Removed: ${removedTotal.toFixed(2)}s of silence across ${mergedDeletes.length} ranges`,
+  `Params: gap>=${params.gap}s, head-pad ${params.headPad}s, tail-pad ${params.tailPad}s`,
+  "",
+  `## Largest pauses trimmed (top 15)`,
+  "",
+  ...pauseDeletes
+    .map((d) => ({ ...d, len: d.end - d.start }))
+    .sort((a, b) => b.len - a.len)
+    .slice(0, 15)
+    .map((d) => `- ${fmt(d.start)}-${fmt(d.end)} removed ${d.len.toFixed(2)}s`),
+].join("\n");
+
+const edlPath = join(outDir, `${stem}.silence-edl.json`);
+const tPath = join(outDir, `${stem}.silence-transcript.json`);
+const decPath = join(outDir, `${stem}.silence-decisions.md`);
+writeFileSync(edlPath, JSON.stringify(edl, null, 2));
+writeFileSync(tPath, JSON.stringify(transcriptOut, null, 2));
+writeFileSync(decPath, decisions);
+
+const summary = {
+  sourceDuration: Number(duration.toFixed(3)),
+  editedDuration,
+  removed: Number(removedTotal.toFixed(3)),
+  removedPct: Number(((removedTotal / duration) * 100).toFixed(1)),
+  deleteRanges: mergedDeletes.length,
+  keepRanges: usableKeepRanges.length,
+  editedWords: editedWords.length,
+  outputs: { edl: edlPath, transcript: tPath, decisions: decPath },
+};
+
+// ---- optional: produce the cut video ----
+if (opts.video) {
+  const videoPath = resolve(opts.video);
+  if (!existsSync(videoPath)) die(`--video not found: ${videoPath}`);
+  const outputPath = resolve(
+    opts.output ?? join(outDir, `${basename(videoPath, extname(videoPath))}.silenced.mp4`),
+  );
+  const scriptPath = join(outDir, `${stem}.silence-filter.txt`);
+  writeFileSync(scriptPath, buildFilterScript(usableKeepRanges));
+  summary.video = { input: videoPath, output: outputPath, filterScript: scriptPath };
+
+  const ffArgs = [
+    "-y", "-i", videoPath,
+    "-/filter_complex", scriptPath,
+    "-map", "[v]", "-map", "[a]",
+    "-c:v", "libx264", "-preset", "medium", "-crf", "18",
+    "-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart",
+    outputPath,
+  ];
+  summary.ffmpegCommand = `ffmpeg ${ffArgs.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ")}`;
+
+  if (opts.apply) {
+    console.error(`rendering cut video -> ${outputPath}`);
+    const ff = spawnSync("ffmpeg", ffArgs, { stdio: ["ignore", "ignore", "inherit"] });
+    if (ff.status !== 0) die(`ffmpeg failed (status ${ff.status})`, ff.status ?? 1);
+    summary.video.rendered = true;
+  } else {
+    summary.video.rendered = false;
+    summary.hint = "re-run with --apply to render the cut video";
+  }
+}
+
+console.log(JSON.stringify(summary, null, 2));

package/skills/luckiest-video-studio-cuts/scripts/find-cut-candidates.mjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+// luckiest-video-studio-cuts: mistake pass, candidate finder
+// Scans a word-level transcript for likely mistakes the speaker would want gone:
+//   - stutters / immediate word repeats ("the the", "I-I-I", "that that")
+//   - retakes / duplicate sentences (a line re-recorded; keep the clean take)
+//   - false starts (an abandoned phrase that restarts)
+//
+// This is MECHANICAL detection only. It proposes candidate cut ranges with rich
+// context + a confidence + a default recommendation, but it does NOT decide.
+// The agent reviews each candidate in context (review-gate) before apply-cuts
+// renders anything.
+//
+// Input: any { words: [{ text, start, end, type? }] } transcript: typically
+// the silence pass <stem>.silence-transcript.json (so cuts land on the silenced timeline).
+//
+// Output (next to the transcript, or --out-dir):
+//   <stem>.cut-candidates.json   structured candidates for the agent to review
+//   <stem>.cut-candidates.md     human-readable proposal
+//
+// Usage:
+//   node find-cut-candidates.mjs <transcript.json> [--out-dir dir]
+
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join, resolve, basename, extname } from "node:path";
+import { argv, exit } from "node:process";
+
+const args = argv.slice(2);
+if (args.length === 0 || args.includes("--help")) {
+  console.log("Usage: node find-cut-candidates.mjs <transcript.json> [--out-dir dir]");
+  exit(args.length === 0 ? 1 : 0);
+}
+let transcriptArg = null, outDirArg = null;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--out-dir") outDirArg = args[++i];
+  else if (!transcriptArg) transcriptArg = args[i];
+}
+const transcriptPath = resolve(transcriptArg);
+let transcript = JSON.parse(readFileSync(transcriptPath, "utf8"));
+if (Array.isArray(transcript)) transcript = { words: transcript }; // hyperframes transcribe writes a bare word array
+if (!Array.isArray(transcript.words)) { console.error("transcript has no words[]"); exit(1); }
+
+function cleanToken(text) {
+  return (text ?? "").toLowerCase().replace(/^[^a-z0-9$%]+|[^a-z0-9$%]+$/g, "");
+}
+function displayText(ws) {
+  return ws.map((w) => w.text).join(" ").replace(/\s+([,.!?;:])/g, "$1");
+}
+function fmt(s) {
+  const m = Math.floor(s / 60);
+  return `${String(m).padStart(2, "0")}:${(s - m * 60).toFixed(2).padStart(5, "0")}`;
+}
+
+const words = transcript.words
+  .filter((w) => (w.type ? w.type === "word" : true))
+  .filter((w) => Number.isFinite(Number(w.start)) && Number.isFinite(Number(w.end)))
+  .map((w, index) => ({ index, text: w.text, token: cleanToken(w.text), start: Number(w.start), end: Number(w.end) }));
+
+if (words.length === 0) { console.error("no timed words"); exit(1); }
+
+const candidates = [];
+let cid = 0;
+const ctx = (i, before = 6, after = 6) =>
+  displayText(words.slice(Math.max(0, i - before), Math.min(words.length, i + after)));
+
+// ---- 1) stutters / immediate repeats ----
+for (let i = 1; i < words.length; i++) {
+  const a = words[i - 1], b = words[i];
+  if (!b.token || b.token.length < 1) continue;
+  const closeGap = b.start - a.end < 0.5;
+  if (a.token === b.token && closeGap) {
+    candidates.push({
+      id: `c${String(++cid).padStart(3, "0")}`,
+      type: "stutter",
+      confidence: "high",
+      recommend: "cut",
+      // remove the first utterance, keep the second
+      cut: { start: Number(a.start.toFixed(3)), end: Number(b.start.toFixed(3)) },
+      removes: a.text,
+      keeps: b.text,
+      context: ctx(i),
+      note: `repeated "${a.token}"`,
+    });
+  }
+}
+
+// ---- build segments (for retake / false-start detection) ----
+const segments = [];
+let segStart = 0;
+for (let i = 1; i < words.length; i++) {
+  const prev = words[i - 1], cur = words[i];
+  const gap = cur.start - prev.end;
+  const elapsed = cur.end - words[segStart].start;
+  const sentenceEnd = /[.!?]$/.test(prev.text ?? "");
+  if (gap > 0.85 || (sentenceEnd && elapsed >= 7.5) || elapsed >= 16) {
+    segments.push({ id: segments.length + 1, wordStart: segStart, wordEnd: i - 1, start: words[segStart].start, end: prev.end, text: displayText(words.slice(segStart, i)) });
+    segStart = i;
+  }
+}
+segments.push({ id: segments.length + 1, wordStart: segStart, wordEnd: words.length - 1, start: words[segStart].start, end: words.at(-1).end, text: displayText(words.slice(segStart)) });
+
+const stop = new Set("a an and are as at be but by for from i if in is it of on or so that this to was we with you your they their there what when where why how like um uh".split(" "));
+function signature(seg) {
+  return seg.text.toLowerCase().replace(/[^a-z0-9\s$%]/g, " ").split(/\s+/).filter((t) => t.length > 2 && !stop.has(t)).slice(0, 18);
+}
+function jaccard(a, b) {
+  const as = new Set(a), bs = new Set(b);
+  let overlap = 0;
+  for (const x of as) if (bs.has(x)) overlap++;
+  return overlap / Math.max(1, new Set([...as, ...bs]).size);
+}
+const sigs = segments.map(signature);
+
+// ---- 2) retakes / duplicate sentences (keep the later, cleaner take) ----
+for (let i = 0; i < segments.length; i++) {
+  for (let j = i + 1; j < Math.min(segments.length, i + 9); j++) {
+    if (segments[j].start - segments[i].end > 75) break;
+    const score = jaccard(sigs[i], sigs[j]);
+    const sameOpening = sigs[i].slice(0, 4).filter((t, idx) => t === sigs[j][idx]).length >= 2;
+    if (score >= 0.34 || (score >= 0.24 && sameOpening)) {
+      const firstLen = segments[i].end - segments[i].start;
+      // A short first take that restarts soon after reads as a false start.
+      const isFalseStart = sameOpening && firstLen < 6 && segments[j].start - segments[i].end < 12;
+      candidates.push({
+        id: `c${String(++cid).padStart(3, "0")}`,
+        type: isFalseStart ? "false_start" : "retake",
+        confidence: score >= 0.45 ? "high" : score >= 0.34 ? "medium" : "low",
+        recommend: score >= 0.34 ? "cut" : "review",
+        score: Number(score.toFixed(3)),
+        // default: remove the earlier take up to the start of the cleaner restart
+        cut: { start: Number(segments[i].start.toFixed(3)), end: Number(segments[j].start.toFixed(3)) },
+        removes: segments[i].text,
+        keeps: segments[j].text,
+        gapBetween: Number((segments[j].start - segments[i].end).toFixed(2)),
+        note: `seg ${segments[i].id} ~ seg ${segments[j].id} (jaccard ${score.toFixed(2)}${sameOpening ? ", same opening" : ""})`,
+      });
+    }
+  }
+}
+
+// sort by time, de-dupe overlapping retake/false-start proposals (keep highest score)
+candidates.sort((a, b) => a.cut.start - b.cut.start);
+
+const byType = candidates.reduce((m, c) => ((m[c.type] = (m[c.type] || 0) + 1), m), {});
+const totalProposed = candidates.filter((c) => c.recommend === "cut").reduce((s, c) => s + (c.cut.end - c.cut.start), 0);
+
+const stem = basename(transcriptPath, extname(transcriptPath)).replace(/[-.]?(silence-)?transcript.*$/i, "") || "source";
+const outDir = outDirArg ? resolve(outDirArg) : dirname(transcriptPath);
+mkdirSync(outDir, { recursive: true });
+
+const out = {
+  agent: "cut-mistakes",
+  source_transcript: transcriptPath,
+  word_count: words.length,
+  segment_count: segments.length,
+  counts: byType,
+  proposed_cut_seconds: Number(totalProposed.toFixed(2)),
+  candidates,
+};
+const jsonPath = join(outDir, `${stem}.cut-candidates.json`);
+writeFileSync(jsonPath, JSON.stringify(out, null, 2));
+
+const md = [
+  "# Cut-Mistakes Candidates",
+  "",
+  `Transcript: ${basename(transcriptPath)} · ${words.length} words · ${segments.length} segments`,
+  `Found: ${candidates.length} candidates (` + Object.entries(byType).map(([k, v]) => `${v} ${k}`).join(", ") + ")",
+  `Default proposed cuts total ~${totalProposed.toFixed(1)}s. **Review before applying.**`,
+  "",
+  ...candidates.map((c) =>
+    [
+      `## ${c.id} · ${c.type} · ${c.confidence} · recommend: ${c.recommend}`,
+      `cut ${fmt(c.cut.start)}–${fmt(c.cut.end)} (${(c.cut.end - c.cut.start).toFixed(2)}s): ${c.note}`,
+      "",
+      `- removes: ${c.removes}`,
+      c.keeps ? `- keeps:   ${c.keeps}` : null,
+      c.context ? `- context: …${c.context}…` : null,
+      "",
+    ].filter(Boolean).join("\n")),
+].join("\n");
+writeFileSync(join(outDir, `${stem}.cut-candidates.md`), md);
+
+console.log(JSON.stringify({ candidates: candidates.length, counts: byType, proposedCutSeconds: Number(totalProposed.toFixed(2)), outputs: { json: jsonPath, md: join(outDir, `${stem}.cut-candidates.md`) } }, null, 2));

package/skills/luckiest-video-studio-reel/ATTRIBUTION.md

@@ -0,0 +1,21 @@
+# Attribution
+
+`luckiest-video-studio-reel` is a Luckiest sub-skill of `luckiest-video-studio`.
+It is rewritten from the `motion-showreel` skill of the **HyperFrames student kit**
+by Nate Herk and contributors, and ports that skill's `beatgrid.mjs`,
+`splice-music.mjs`, and `mix.mjs`. The kit is MIT; its pipeline skills carry the
+Student Kit Use Permission. Both texts are kept in
+`luckiest-video-studio/LICENSE-student-kit` and `LICENSE-student-kit-pipeline`.
+
+## Changes in this edition
+
+- Runs as one `logo` scene with the `reel` recipe inside a video-studio run, with a
+  bundled starter composition (`templates/reel.html`) on the coordinator's brand
+  tokens.
+- Beat analysis uses the coordinator's `analyze_music_cues.py`; the kit's
+  `music-grid.mjs` and `analyze-reference.mjs` are not included.
+- Removed the paid image, video, music, and sound generators (`kie.mjs`,
+  `sfx.mjs`), which read API keys from `.env`. Sound comes from the CC0 kit.
+- Rewrote the grammar and chapter notes without the source reel's breakdown,
+  brand examples, or personal references. See `luckiest-video-studio/SECURITY.md`
+  S26 to S31.

package/skills/luckiest-video-studio-reel/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog: luckiest-video-studio-reel
+
+## 1.1.0 (2026-09-30)
+- Verify step runs the coordinator's `qa.mjs` beat grid, pops, dead frames,
+  legibility, and cross-fade gates on the rendered reel.
+
+## 1.0.0 (2026-09-29)
+- New sub-skill: beat-locked brand reel rendered as a `reel` logo recipe, with a
+  starter composition, HUD, and beat grid, splice, and premix scripts.
+- No paid generation; user-supplied music and the CC0 sound kit only.