luckiest-co 1.0.30 → 1.0.32

package/skills/luckiest-video-studio-review/editor/serve.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// Motion OS player server. Serves the player page plus one project folder (reel.json, the video, assets/)
+// on localhost and opens it in the browser. No dependencies.
+//   node serve.mjs <project-dir> [--port 4321] [--no-open]
+//   node serve.mjs --selftest
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import {fileURLToPath} from 'node:url';
+import {exec, spawn} from 'node:child_process';
+
+const TYPES = {
+  '.html': 'text/html; charset=utf-8', '.json': 'application/json', '.js': 'text/javascript', '.css': 'text/css',
+  '.mp4': 'video/mp4', '.webm': 'video/webm', '.mov': 'video/quicktime',
+  '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png', '.webp': 'image/webp', '.gif': 'image/gif', '.svg': 'image/svg+xml',
+  '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.m4a': 'audio/mp4',
+};
+
+// "bytes=0-99" / "bytes=100-" / "bytes=-100" -> [start, end] inclusive, or null if unusable.
+export function parseRange(header, size) {
+  const m = /^bytes=(\d*)-(\d*)$/.exec(header || '');
+  if (!m || (m[1] === '' && m[2] === '')) return null;
+  const start = m[1] === '' ? Math.max(0, size - Number(m[2])) : Number(m[1]);
+  const end = m[1] === '' || m[2] === '' ? size - 1 : Math.min(Number(m[2]), size - 1);
+  return start <= end && start < size ? [start, end] : null;
+}
+
+if (process.argv[2] === '--selftest') {
+  const eq = (a, b) => { if (JSON.stringify(a) !== JSON.stringify(b)) throw new Error(`${JSON.stringify(a)} != ${JSON.stringify(b)}`); };
+  eq(parseRange('bytes=0-99', 1000), [0, 99]);
+  eq(parseRange('bytes=900-', 1000), [900, 999]);
+  eq(parseRange('bytes=-100', 1000), [900, 999]);
+  eq(parseRange('bytes=0-5000', 1000), [0, 999]);
+  eq(parseRange('bytes=1000-', 1000), null);
+  eq(parseRange('bytes=-', 1000), null);
+  eq(parseRange(undefined, 1000), null);
+  console.log('selftest ok');
+  process.exit(0);
+}
+
+const args = process.argv.slice(2);
+const flag = (name) => { const i = args.indexOf(name); return i < 0 ? null : args.splice(i, name === '--no-open' ? 1 : 2)[1] ?? true; };
+const noOpen = flag('--no-open');
+let port = Number(flag('--port') || process.env.PORT || 4321);
+const dir = path.resolve(args[0] || '.');
+const page = path.join(path.dirname(fileURLToPath(import.meta.url)), 'index.html');
+if (!fs.existsSync(path.join(dir, 'reel.json'))) { console.error(`Motion OS: no reel.json in ${dir}`); process.exit(1); }
+
+// Export: reel.json "export": {"cwd": build folder, "cmd": shell command}. The command gets $PROPS (a JSON file with the
+// user's edits), $RAW (temp render path), $OUT (final mp4 in <project>/exports/) and $PROJECT. One export at a time.
+let job = {state: 'idle'};
+function startExport(props) {
+  const reel = JSON.parse(fs.readFileSync(path.join(dir, 'reel.json'), 'utf8')), ex = reel.export;
+  if (!ex) return {state: 'error', line: 'This project has no "export" in reel.json.'};
+  if (job.state === 'running') return job;
+  const stamp = new Date().toISOString().slice(0, 19).replace(/[-:]/g, '').replace('T', '-');
+  fs.mkdirSync(path.join(dir, 'exports'), {recursive: true});
+  const out = path.join(dir, 'exports', `${reel.id}-${stamp}.mp4`), tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'motionos-'));
+  const env = {...process.env, PROJECT: dir, OUT: out, RAW: path.join(tmp, 'raw.mp4'), PROPS: path.join(tmp, 'props.json')};
+  fs.writeFileSync(env.PROPS, JSON.stringify({...ex.props, ...props}));
+  job = {state: 'running', pct: 0, line: 'Starting', out: path.relative(dir, out)};
+  const p = spawn('sh', ['-c', ex.cmd], {cwd: ex.cwd || dir, env});
+  const onData = (d) => {
+    const text = String(d), m = [...text.matchAll(/(\d+)\/(\d+)/g)].pop();
+    if (m && +m[2] > 0) job.pct = Math.min(99, Math.round(+m[1] / +m[2] * 100));
+    const last = text.trim().split(/[\r\n]+/).pop(); if (last) job.line = last.slice(0, 200);
+  };
+  p.stdout.on('data', onData); p.stderr.on('data', onData);
+  p.on('close', (code) => { job = code === 0 ? {...job, state: 'done', pct: 100} : {...job, state: 'error'}; fs.rmSync(tmp, {recursive: true, force: true}); });
+  return job;
+}
+
+const server = http.createServer((req, res) => {
+  const url = decodeURIComponent(new URL(req.url, 'http://localhost').pathname);
+  if (url === '/export') {
+    // Only our own page may start a render (blocks other websites posting to localhost).
+    if (req.method === 'POST' && req.headers.origin && !/^http:\/\/(localhost|127\.0\.0\.1):\d+$/.test(req.headers.origin)) return res.writeHead(403).end();
+    const send = (j) => res.writeHead(200, {'Content-Type': 'application/json'}).end(JSON.stringify(j));
+    if (req.method !== 'POST') return send(job);
+    let body = ''; req.on('data', (c) => body += c);
+    return req.on('end', () => { try { send(startExport(JSON.parse(body || '{}'))); } catch (e) { send({state: 'error', line: e.message}); } });
+  }
+  let file = url === '/' ? page : path.resolve(dir, '.' + url);
+  if (file !== page && !file.startsWith(dir + path.sep)) return res.writeHead(403).end('Forbidden');
+  // Remotion's staticFile() paths point at the site root; serve them from public/.
+  if (file !== page && !fs.existsSync(file) && fs.existsSync(path.join(dir, 'public', '.' + url))) file = path.join(dir, 'public', '.' + url);
+  fs.stat(file, (err, stat) => {
+    if (err || !stat.isFile()) return res.writeHead(404).end('Not found');
+    const head = {'Content-Type': TYPES[path.extname(file).toLowerCase()] || 'application/octet-stream', 'Accept-Ranges': 'bytes', 'Cache-Control': 'no-store'};
+    if (req.headers.range) {  // video seeking needs byte ranges
+      const r = parseRange(req.headers.range, stat.size);
+      if (!r) return res.writeHead(416, {'Content-Range': `bytes */${stat.size}`}).end();
+      res.writeHead(206, {...head, 'Content-Range': `bytes ${r[0]}-${r[1]}/${stat.size}`, 'Content-Length': r[1] - r[0] + 1});
+      return req.method === 'HEAD' ? res.end() : fs.createReadStream(file, {start: r[0], end: r[1]}).pipe(res);
+    }
+    res.writeHead(200, {...head, 'Content-Length': stat.size});
+    req.method === 'HEAD' ? res.end() : fs.createReadStream(file).pipe(res);
+  });
+});
+
+server.on('error', (e) => {
+  if (e.code !== 'EADDRINUSE') throw e;
+  port += 1; server.listen(port, '127.0.0.1');  // try the next port
+});
+server.on('listening', () => {
+  const url = `http://localhost:${port}`;
+  console.log(`Motion OS: ${url}  (project: ${dir})  Ctrl+C to stop`);
+  if (!noOpen) exec(`${process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start ""' : 'xdg-open'} ${url}`);
+});
+server.listen(port, '127.0.0.1');

package/skills/luckiest-video-studio-review/references/apply-feedback.md

@@ -0,0 +1,71 @@
+# Applying a review player prompt
+
+A pasted prompt starts with `Motion OS feedback for "<title>" v<N>` (the player
+is Motion OS underneath) and has up to four parts: Edits, Notes, Links, and
+Scenes.
+
+## Before anything
+
+- **Version.** Compare `v<N>` with `version` in `<run-dir>/reel.json`. If the
+  prompt is older, say so in one line: the user reviewed an earlier render, so
+  check every edit's "before" value (below) instead of trusting its timing.
+- **Run.** The `Project:` line is the run folder. Work only there.
+
+## Edits
+
+Each line reads:
+
+```
+- [00:01.2 · hook · Your invoices, done] Headline (storyboard.json scenes[0] · composition/compositions/hook.html): "Invoices, done" -> "Invoices, handled"
+```
+
+| Field label | Change |
+|---|---|
+| A variable's label (Headline, Value, ...) | `scenes[N].variables.<key>` to the new value exactly. The label is the key with its first letter capitalized and hyphens shown as spaces (`cta-text` shows as `Cta text`). |
+| Footage | `scenes[N].source` |
+| Timing (`[start, end]`) | the scene's `duration` (end minus start). Only for the scene named; later scenes shift on their own. |
+| `Style · <color name>` (`#old -> #new`) | every variable holding `#old`, in every scene that is not approved |
+
+Rules:
+
+- Apply an edit only when the storyboard's current value equals the "before"
+  value. If it does not, skip it and list it as changed since that render.
+- An edit naming a scene id that is no longer in `storyboard.json` is skipped and
+  reported, never guessed onto another scene.
+- If the composition hardcodes the text instead of reading `variables`, move the
+  text into `variables` first, then edit it.
+
+## Notes
+
+Each note has a timestamp, a scene, an x/y position in percent of the frame, and
+the element it sits on. Notes starting with "Claude:" are your own pre-pinned
+notes the user kept: treat them as agreed.
+
+1. Grab the frame and look at it before deciding what the note means:
+   `ffmpeg -v error -ss <t> -i <run-dir>/final.mp4 -frames:v 1 <run-dir>/qa/note-<i>.jpg`
+2. Motion, pacing, and placement notes change the scene's composition or its
+   `duration`.
+3. A note on a demo scene about the footage itself (a typo in the product, a
+   cursor jump) cannot be fixed by re-rendering. Say so, and offer a new
+   recording or a trim through `sourceStart` and `duration`. For talking-head
+   footage, hand it to `luckiest-video-studio-cuts`.
+
+## Links
+
+Download links into `assets/` only when they are clearly the user's own files.
+Ask first otherwise.
+
+## Scenes
+
+The last block lists each scene as `in review`, `needs changes`, or `approved`.
+Never touch an approved scene, even when an edit or note seems to point at it;
+list those as skipped.
+
+## After the changes
+
+Re-render the touched scenes with `render-scenes.mjs --scene <id>` for each, then
+look at a contact sheet before showing anything:
+`ffmpeg -v error -y -i <run-dir>/final.mp4 -vf "fps=1,scale=320:-1,tile=6x6" -frames:v 1 <run-dir>/qa/sheet.jpg`.
+Then rerun `build-reel.mjs`. The prompt
+asks for version `N+1`; `build-reel.mjs` sets it. Reply with what changed, what
+was skipped and why, and anything you could not do.

package/skills/luckiest-video-studio-review/scripts/build-reel.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+// Write reel.json for the review player (editor/, Motion OS) from a rendered luckiest-video-studio run: one scene
+// per storyboard scene, in storyboard order, with each scene's variables as editable fields. Rerunning bumps
+// "version" so an open player reloads itself. <run-dir>/qa/review-notes.json ([{ t, x, y, text, scene? }]), when
+// present, is pinned on the frame as Claude's own notes. Then serve it: node <skill-dir>/editor/serve.mjs <run-dir>
+// Usage: node build-reel.mjs <run-dir>
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const MEDIA = { image: /\.(png|jpe?g|webp|gif|svg)$/i, video: /\.(mp4|mov|webm)$/i, audio: /\.(mp3|wav|m4a)$/i };
+const mediaType = (v) => Object.keys(MEDIA).find((k) => MEDIA[k].test(v));
+const slug = (v) => v.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+const words = (id) => id.replace(/-/g, " ").replace(/^./, (c) => c.toUpperCase());
+
+// One field per variable: hex -> color, file path -> media, number -> number, other strings -> text.
+// ponytail: nested objects and arrays are skipped (no field). Map them to "list" if storyboards start using them.
+function field(k, v) {
+  const label = words(k);
+  if (typeof v === "number") return { type: "number", label, v };
+  if (typeof v !== "string") return null;
+  if (/^#[0-9a-f]{3,8}$/i.test(v)) return { type: "color", label, v };
+  if (mediaType(v)) return { type: "media", label, v };
+  return { type: v.length > 60 ? "longtext" : "text", label, v };
+}
+
+// Pure: the reel for a storyboard. prevVersion is the version of the reel.json already in the run, or 0.
+export function buildReel(sb, runDir, prevVersion = 0, duration = 0, qaNotes = []) {
+  const assets = new Map();
+  // The player's color fields pick from the brand palette, so every distinct hex becomes a palette entry and the
+  // field links to it. Editing a palette color in the Style tab then changes every scene that uses it.
+  const colors = new Map();
+  const paletteId = (hex, k) => {
+    const key = hex.toLowerCase();
+    if (!colors.has(key)) colors.set(key, { id: `c${colors.size + 1}`, name: words(k), v: hex });
+    return `brand.${colors.get(key).id}`;
+  };
+  const asset = (id, from) => { const type = mediaType(id); if (type && !assets.has(id)) assets.set(id, { id, name: basename(id), type, from }); };
+  let t = 0;
+  const scenes = sb.scenes.map((s, i) => {
+    const range = [+t.toFixed(3), +(t += s.duration).toFixed(3)];
+    const props = {};
+    for (const [k, v] of Object.entries(s.variables ?? {})) {
+      const f = field(k, v);
+      if (!f) continue;
+      if (f.type === "color") f.v = paletteId(v, k);
+      props[k] = f;
+      if (f.type === "media") asset(v, "Run");
+    }
+    if (s.kind === "demo" && s.source) { props.source = { type: "media", label: "Footage", v: s.source }; asset(s.source, "Footage"); }
+    for (const a of s.assets ?? []) asset(a, "Run");
+    props.motion = { type: "motion", label: "Motion", v: [s.kind, s.recipe].filter(Boolean).join(", ") };
+    const src = s.kind === "demo" ? s.source : `composition/${s.composition ?? `compositions/${s.id}.html`}`;
+    return {
+      id: s.id, name: words(s.id), t: range,
+      els: [{ id: s.id, label: s.line || words(s.id), t: range, box: null, src: `storyboard.json scenes[${i}] · ${src}`, props }],
+    };
+  });
+  if (sb.music?.file) asset(sb.music.file, "Music");
+  return {
+    // The player stores unsent edits per id: title plus run folder keeps two projects from sharing them.
+    id: `${slug(sb.title)}-${slug(basename(runDir))}`,
+    title: sb.title,
+    version: prevVersion + 1,
+    path: runDir,
+    src: "final.mp4",
+    w: sb.format.width, h: sb.format.height, fps: sb.format.fps,
+    // The joined file can run a frame or two off the storyboard sum; trust the file when it was probed.
+    duration: duration || +t.toFixed(3),
+    brand: { colors: [...colors.values()], fonts: [], logo: null },
+    audio: { music: sb.music?.file ?? null, bpm: null, drop: null, musicVol: sb.music?.volume ?? 0.35, sfxVol: 0.8 },
+    assets: [...assets.values()],
+    scenes,
+    // ponytail: the player seeds notes only on a project's first open (later opens keep the browser's state),
+    // so these show once. Write them into the prompt by hand if a later version needs them.
+    notes: qaNotes.map((n, i) => ({ id: i + 1, t: n.t, x: n.x ?? 50, y: n.y ?? 50, el: n.scene ?? null, text: `Claude: ${n.text}` })),
+  };
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const runDir = resolve(process.argv[2] ?? ".");
+  const fail = (m) => { console.error(`error: ${m}`); process.exit(1); };
+  if (!existsSync(join(runDir, "storyboard.json"))) fail(`no storyboard.json in ${runDir}`);
+  if (!existsSync(join(runDir, "final.mp4"))) fail(`no final.mp4 in ${runDir}; run render-scenes.mjs first`);
+  const sb = JSON.parse(readFileSync(join(runDir, "storyboard.json"), "utf8"));
+  const reelFile = join(runDir, "reel.json");
+  const prev = existsSync(reelFile) ? JSON.parse(readFileSync(reelFile, "utf8")).version ?? 0 : 0;
+  const probe = spawnSync("ffprobe", ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", join(runDir, "final.mp4")], { encoding: "utf8" });
+  const notesFile = join(runDir, "qa", "review-notes.json");
+  const qaNotes = existsSync(notesFile) ? JSON.parse(readFileSync(notesFile, "utf8")) : [];
+  const reel = buildReel(sb, runDir, prev, +(Number(probe.stdout?.trim()) || 0).toFixed(3), qaNotes);
+  writeFileSync(reelFile, JSON.stringify(reel, null, 1) + "\n");
+  const serve = join(dirname(fileURLToPath(import.meta.url)), "..", "editor", "serve.mjs");
+  console.log(`wrote ${reelFile} v${reel.version} (${reel.scenes.length} scenes, ${reel.duration}s). Open it: node "${resolve(serve)}" "${runDir}"`);
+}

package/skills/luckiest-video-studio-review/scripts/build-reel.test.mjs

@@ -0,0 +1,62 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildReel } from "./build-reel.mjs";
+
+const sb = {
+  title: "Acme launch",
+  format: { width: 1920, height: 1080, fps: 30 },
+  music: { file: "audio/bed.mp3", volume: 0.3 },
+  scenes: [
+    { id: "hook", kind: "motion", duration: 2.5, line: "Your invoices, done", variables: { headline: "Done in one click", accent: "#5B5BF7", logo: "brand/logo.svg", nested: { a: 1 } } },
+    { id: "create-invoice", kind: "demo", duration: 6, source: "demo/create.mp4" },
+    { id: "logo-close", kind: "logo", recipe: "piece-assembly", duration: 3, assets: ["brand/logo.svg"] },
+  ],
+};
+
+test("scenes keep storyboard ids and cover 0 to duration with no gaps", () => {
+  const reel = buildReel(sb, "/runs/Video-Studio-Output");
+  assert.equal(reel.id, "acme-launch-video-studio-output");
+  assert.equal(reel.src, "final.mp4");
+  assert.deepEqual([reel.w, reel.h, reel.fps], [1920, 1080, 30]);
+  assert.deepEqual(reel.scenes.map((s) => [s.id, s.t]), [["hook", [0, 2.5]], ["create-invoice", [2.5, 8.5]], ["logo-close", [8.5, 11.5]]]);
+  assert.equal(reel.duration, 11.5);
+  assert.equal(buildReel(sb, "/r", 0, 11.533).duration, 11.533);
+});
+
+test("variables become typed fields, nested values are skipped", () => {
+  const { props, label, box } = buildReel(sb, "/r").scenes[0].els[0];
+  assert.equal(label, "Your invoices, done");
+  assert.equal(box, null);
+  assert.deepEqual(Object.fromEntries(Object.entries(props).map(([k, p]) => [k, p.type])), { headline: "text", accent: "color", logo: "media", motion: "motion" });
+  assert.equal(props.headline.v, "Done in one click");
+  assert.equal(props.accent.v, "brand.c1");
+});
+
+test("hex values become one shared palette entry each", () => {
+  const two = { ...sb, scenes: [sb.scenes[0], { id: "cta", kind: "motion", duration: 2, variables: { bg: "#5b5bf7", ink: "#111111" } }] };
+  const reel = buildReel(two, "/r");
+  assert.deepEqual(reel.brand.colors, [{ id: "c1", name: "Accent", v: "#5B5BF7" }, { id: "c2", name: "Ink", v: "#111111" }]);
+  assert.deepEqual(Object.values(reel.scenes[1].els[0].props).filter((p) => p.type === "color").map((p) => p.v), ["brand.c1", "brand.c2"]);
+});
+
+test("demo footage, scene assets and music are listed once as assets", () => {
+  const reel = buildReel(sb, "/r");
+  assert.deepEqual(reel.assets.map((a) => [a.id, a.type]), [["brand/logo.svg", "image"], ["demo/create.mp4", "video"], ["audio/bed.mp3", "audio"]]);
+  assert.equal(reel.scenes[1].els[0].props.source.v, "demo/create.mp4");
+  assert.equal(reel.scenes[2].els[0].props.motion.v, "logo, piece-assembly");
+  assert.equal(reel.audio.music, "audio/bed.mp3");
+});
+
+test("Claude's review notes are pinned with ids and a Claude: prefix", () => {
+  const { notes } = buildReel(sb, "/r", 0, 0, [{ t: 1.2, x: 30, y: 70, text: "Headline sits on the logo", scene: "hook" }, { t: 9, text: "Outro feels long" }]);
+  assert.deepEqual(notes, [
+    { id: 1, t: 1.2, x: 30, y: 70, el: "hook", text: "Claude: Headline sits on the logo" },
+    { id: 2, t: 9, x: 50, y: 50, el: null, text: "Claude: Outro feels long" },
+  ]);
+  assert.deepEqual(buildReel(sb, "/r").notes, []);
+});
+
+test("rerunning bumps the version so an open player reloads", () => {
+  assert.equal(buildReel(sb, "/r").version, 1);
+  assert.equal(buildReel(sb, "/r", 4).version, 5);
+});

package/skills/luckiest-video-studio-cuts/scripts/build-edl-review.mjs

@@ -1,114 +0,0 @@
-#!/usr/bin/env node
-// Build a self-contained review page for an edit decision list (EDL).
-// Visualizes kept (green) vs cut (red) regions on a timeline, lists the biggest
-// cuts, and embeds the original + edited videos side by side so you can scrub,
-// click any cut to hear what was removed, and watch the result.
-//
-// Reusable across pipeline agents that emit an EDL with { source_duration,
-// edited_duration, removed, keep_ranges, delete_ranges }.
-//
-// Usage:
-//   node build-edl-review.mjs <edl.json> --original <video> --edited <video> [--output review.html]
-
-import { readFileSync, writeFileSync } from "node:fs";
-import { resolve, dirname, join, relative, basename } 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 build-edl-review.mjs <edl.json> --original <video> --edited <video> [--output review.html]");
-  exit(args.length === 0 ? 1 : 0);
-}
-const opts = { edl: null, original: null, edited: null, output: null };
-for (let i = 0; i < args.length; i++) {
-  const a = args[i];
-  if (a === "--original") opts.original = args[++i];
-  else if (a === "--edited") opts.edited = args[++i];
-  else if (a === "--output" || a === "-o") opts.output = args[++i];
-  else if (!opts.edl) opts.edl = a;
-}
-if (!opts.edl) { console.error("no edl.json given"); exit(1); }
-
-const edlPath = resolve(opts.edl);
-const edl = JSON.parse(readFileSync(edlPath, "utf8"));
-const outPath = resolve(opts.output ?? join(dirname(edlPath), "silence-review.html"));
-const outDir = dirname(outPath);
-const rel = (p) => (p ? encodeURI(relative(outDir, resolve(p))) : null);
-const esc = (s) => String(s).replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
-const edlName = esc(basename(edlPath));
-
-const dur = edl.source_duration;
-const deletes = (edl.delete_ranges ?? []).map((d) => ({
-  start: d.start, end: d.end, len: d.end - d.start,
-  reasons: d.reasons ?? (d.reason ? [d.reason] : []),
-}));
-const keeps = edl.keep_ranges ?? [];
-
-function fmt(s) {
-  const m = Math.floor(s / 60);
-  return `${m}:${(s - m * 60).toFixed(2).padStart(5, "0")}`;
-}
-const pct = (s) => (s / dur) * 100;
-
-const keepRects = keeps.map((k) =>
-  `<div class="seg keep" style="left:${pct(k.start)}%;width:${pct(k.end - k.start)}%" title="keep ${fmt(k.start)}-${fmt(k.end)}"></div>`).join("");
-const cutRects = deletes.map((d, i) =>
-  `<div class="seg cut" style="left:${pct(d.start)}%;width:${Math.max(pct(d.len), 0.12)}%" data-start="${d.start}" data-len="${d.len.toFixed(2)}" title="cut #${i + 1}: ${fmt(d.start)}-${fmt(d.end)} (${d.len.toFixed(2)}s)"></div>`).join("");
-
-const topCuts = [...deletes].sort((a, b) => b.len - a.len).slice(0, 20);
-const rows = topCuts.map((d, i) =>
-  `<tr><td>${i + 1}</td><td><button class="jump" data-t="${Math.max(0, d.start - 0.5).toFixed(2)}">${fmt(d.start)}</button></td><td>${fmt(d.end)}</td><td><b>${d.len.toFixed(2)}s</b></td><td class="reason">${esc(d.reasons[0] ?? "")}</td></tr>`).join("");
-
-const removed = edl.removed ?? (dur - edl.edited_duration);
-const html = `<!doctype html><html><head><meta charset="utf-8"><title>Silence cut review: ${edlName}</title>
-<style>
-  :root{--bg:#0d1117;--panel:#161b22;--line:#30363d;--green:#3fb950;--red:#f85149;--text:#e6edf3;--dim:#8b949e}
-  *{box-sizing:border-box} body{margin:0;background:var(--bg);color:var(--text);font:14px/1.5 -apple-system,Inter,Segoe UI,sans-serif;padding:24px}
-  h1{font-size:18px;margin:0 0 4px} .sub{color:var(--dim);margin-bottom:20px}
-  .stats{display:flex;gap:24px;margin:0 0 20px;flex-wrap:wrap}
-  .stat{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:12px 18px}
-  .stat .n{font-size:22px;font-weight:700} .stat .l{color:var(--dim);font-size:12px}
-  .stat .n.red{color:var(--red)} .stat .n.green{color:var(--green)}
-  .timeline{position:relative;height:46px;background:#21262d;border:1px solid var(--line);border-radius:8px;overflow:hidden;margin-bottom:6px}
-  .seg{position:absolute;top:0;height:100%} .seg.keep{background:var(--green);opacity:.55} .seg.cut{background:var(--red);cursor:pointer} .seg.cut:hover{opacity:.8;outline:1px solid #fff}
-  .axis{display:flex;justify-content:space-between;color:var(--dim);font-size:11px;margin-bottom:24px}
-  .legend{display:flex;gap:16px;font-size:12px;color:var(--dim);margin-bottom:24px}
-  .swatch{display:inline-block;width:12px;height:12px;border-radius:3px;vertical-align:-1px;margin-right:5px}
-  .videos{display:grid;grid-template-columns:1fr 1fr;gap:18px;margin-bottom:28px}
-  .vid{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:12px}
-  .vid h3{margin:0 0 8px;font-size:13px;color:var(--dim);font-weight:600} video{width:100%;border-radius:6px;background:#000}
-  table{border-collapse:collapse;width:100%;background:var(--panel);border:1px solid var(--line);border-radius:10px;overflow:hidden}
-  th,td{padding:7px 12px;text-align:left;border-bottom:1px solid var(--line);font-size:13px} th{color:var(--dim);font-weight:600}
-  td .reason{color:var(--dim)} button.jump{background:#21262d;color:var(--text);border:1px solid var(--line);border-radius:5px;padding:2px 8px;cursor:pointer;font:inherit}
-  button.jump:hover{border-color:var(--green)}
-  .hint{color:var(--dim);font-size:12px;margin:6px 0 18px}
-</style></head><body>
-<h1>Cut-Silences review</h1>
-<div class="sub">${edlName} · params: gap≥${edl.params?.gap ?? "?"}s, head-pad ${edl.params?.headPad ?? "?"}s, tail-pad ${edl.params?.tailPad ?? "?"}s</div>
-<div class="stats">
-  <div class="stat"><div class="n">${fmt(dur)}</div><div class="l">original</div></div>
-  <div class="stat"><div class="n green">${fmt(edl.edited_duration)}</div><div class="l">edited</div></div>
-  <div class="stat"><div class="n red">−${removed.toFixed(1)}s</div><div class="l">silence removed</div></div>
-  <div class="stat"><div class="n">${((removed / dur) * 100).toFixed(1)}%</div><div class="l">tightened</div></div>
-  <div class="stat"><div class="n">${deletes.length}</div><div class="l">cuts</div></div>
-</div>
-<div class="timeline" id="tl">${keepRects}${cutRects}</div>
-<div class="axis"><span>0:00</span><span>${fmt(dur / 2)}</span><span>${fmt(dur)}</span></div>
-<div class="legend"><span><span class="swatch" style="background:var(--green)"></span>kept speech</span><span><span class="swatch" style="background:var(--red)"></span>silence cut</span><span>· click a red mark (or a row below) to jump the ORIGINAL player to just before that pause</span></div>
-<div class="videos">
-  <div class="vid"><h3>ORIGINAL (with silences)</h3><video id="orig" src="${rel(opts.original) ?? ""}" controls preload="metadata"></video></div>
-  <div class="vid"><h3>EDITED (silences cut)</h3><video id="edit" src="${rel(opts.edited) ?? ""}" controls preload="metadata"></video></div>
-</div>
-<div class="hint">Tip: play the EDITED one straight through to judge pacing. Use the cut markers + ORIGINAL player to spot-check that no words were clipped at a cut boundary.</div>
-<h3 style="font-size:14px">20 largest pauses removed</h3>
-<table><thead><tr><th>#</th><th>from</th><th>to</th><th>removed</th><th>reason</th></tr></thead><tbody>${rows}</tbody></table>
-<script>
-  const orig = document.getElementById('orig');
-  function jump(t){ orig.currentTime = Math.max(0, t); orig.play(); orig.scrollIntoView({behavior:'smooth',block:'center'}); }
-  document.querySelectorAll('.seg.cut').forEach(s => s.addEventListener('click', () => jump(parseFloat(s.dataset.start) - 0.5)));
-  document.querySelectorAll('button.jump').forEach(b => b.addEventListener('click', () => jump(parseFloat(b.dataset.t))));
-</script>
-</body></html>`;
-
-writeFileSync(outPath, html);
-console.log(JSON.stringify({ review: outPath, cuts: deletes.length, removed: Number(removed.toFixed(2)) }, null, 2));