kaizen-agent 1.48.0 → 1.49.0

package/skills/media/kaizen-video/scripts/make_film.py

@@ -0,0 +1,263 @@
+"""Build (and optionally render) a film made from nothing: narration, pictures, music, sound effects.
+
+    python3 scripts/make_film.py videos/<name> [--render] [--format 9x16|16x9|4x5]
+
+Run from the project folder. videos/<name>/ holds film.json (storyboard + brand), lines.json (the script),
+words.json (word timings from vo.py), the voice files vNN.mp3 and the pictures. Writes the HyperFrames project
+into videos/<name>/film/; with --render, scripts/master.sh renders it, masters the loudness and writes
+output/<name>/<preset>/<name>.mp4 with the .srt, thumbnail and credits.
+
+film.json: "preset" (a folder under presets/ with a style.json, e.g. film-cinematic-drama), "format"
+("9x16" default, "16x9", or "4x5" for an Instagram feed post), "beats", "brand", "labels", "cta", "logo", "qr", "music" (a bundled track name;
+without it videos/<name>/music.mp3 is used). The preset is found in ./presets/, $KAIZEN_VIDEO_PRESETS
+(default ~/.kaizen/video-presets/), then the skill's presets/, like make_tiktok.py.
+--format overrides film.json's format for one build and adds -<format> to the output name, so one film can be
+rendered for several shapes (the Video page in kaizen web does this) without one render replacing another.
+"""
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+SKILL = Path(__file__).resolve().parent.parent
+WORK = Path.cwd()
+HF = "hyperframes@0.8.176"
+FPS = 30
+HOME = Path(os.environ.get("KAIZEN_VIDEO_HOME", Path.home() / ".kaizen/kaizen-video"))
+SIZES = {"9x16": (1080, 1920, "portrait"), "16x9": (1920, 1080, "landscape"), "4x5": (1080, 1350, "portrait")}
+
+vdir = Path(sys.argv[1]).resolve()
+proj = vdir / "film"
+film = json.loads((vdir / "film.json").read_text())
+words = json.loads((vdir / "words.json").read_text())
+forced = sys.argv[sys.argv.index("--format") + 1] if "--format" in sys.argv[:-1] else None
+fmt = forced or film.get("format", "9x16")
+if fmt not in SIZES:
+    sys.exit(f"film.json format {fmt!r} must be one of {', '.join(SIZES)}")
+W, H, RES = SIZES[fmt]
+LANG = film.get("language", "id")
+
+# 1. Preset: a folder with style.json.
+dirs = [WORK / "presets", Path(os.environ.get("KAIZEN_VIDEO_PRESETS", Path.home() / ".kaizen/video-presets")), SKILL / "presets"]
+want = film["preset"]
+preset = next((d / n for n in (want, "film-" + want) for d in dirs if (d / n / "style.json").exists()), None)
+if not preset:
+    names = sorted({p.parent.name for d in dirs if d.exists() for p in d.glob("*/style.json")})
+    sys.exit(f"preset {want!r} not found in {', '.join(map(str, dirs))}; available: {', '.join(names)}")
+print(f"preset {preset}")
+style = json.loads((preset / "style.json").read_text())
+brand = film.get("brand", {})
+style["palette"] = {**style["palette"], **brand.get("palette", {})}
+style["fonts"] = {**style["fonts"], **brand.get("fonts", {})}
+pace = style["pace"]
+shutil.rmtree(proj / "assets", ignore_errors=True)
+for d in ("img", "video", "sfx", "fonts"):
+    (proj / "assets" / d).mkdir(parents=True)
+
+
+def probe(f, entry, kind="format"):
+    out = subprocess.check_output(["ffprobe", "-v", "error", "-show_entries", f"{kind}={entry}", "-of", "csv=p=0", str(f)])
+    return out.decode().strip()
+
+
+def run(*cmd, cwd=proj):
+    subprocess.run(cmd, check=True, cwd=cwd)
+
+
+# 2. Timeline: every beat is lead + its voice line + tail (+ hold), in whole frames, one after another.
+t, beats = 0, []
+for n, b in enumerate(film["beats"]):
+    v = b.get("vo")
+    if v and v not in words:
+        sys.exit(f"beat {n + 1}: voice {v!r} is not in words.json; run vo.py first")
+    frames = round(((pace["lead"] + words[v]["dur"] + pace["tail"]) if v else 0) * FPS + b.get("hold", 0) * FPS)
+    if frames:
+        beats.append({**b, "n": n, "start": t / FPS, "len": frames / FPS, "dur": words[v]["dur"] if v else 0})
+    else:
+        print(f"warning: beat {n + 1} ({b['kind']}) has no voice and no hold, so it is skipped")
+    t += frames
+total = t / FPS
+reveal = next((b["start"] for b in beats if b["kind"] == "reveal"), total / 2)
+
+# 3. Pictures, footage, logo, QR into the project (a photo name may be a stem: intake writes <stem>-9x16.jpg).
+def stage(name, sub):
+    if not name:
+        return name
+    src = vdir / name
+    for tag in (fmt, "9x16") if fmt == "4x5" else (fmt,):   # a film intaken before 4x5 existed uses its 9x16 crops
+        if not src.exists():
+            src = vdir / f"{Path(name).stem}-{tag}.jpg"
+    if not src.exists():
+        sys.exit(f"file {name!r} not found in {vdir}")
+    flat = re.sub(r"[\\/]", "_", str(src.relative_to(vdir)))
+    shutil.copy(src, proj / "assets" / sub / flat)
+    return f"assets/{sub}/{flat}"
+
+
+for b in beats:
+    b["img"], b["video"] = stage(b.get("img"), "img"), stage(b.get("video"), "video")
+    if b.get("panels"):
+        b["panels"] = [{**p, "img": stage(p["img"], "img")} for p in b["panels"]]
+    if b["kind"] == "shot" and b["img"] and not b.get("shotRatio"):
+        b["shotRatio"] = round(int(probe(proj / b["img"], "width", "stream")) / int(probe(proj / b["img"], "height", "stream")), 3)
+labels = {"source": "Sumber" if LANG == "id" else "Source", "next": "Langkah berikutnya" if LANG == "id" else "Next step", **film.get("labels", {})}
+
+# 4. Captions: subtitle chunks of up to 7 words (also the .srt cues), or kinetic groups of 2-3 words.
+def chunks(ws):
+    out, cur = [], []
+    for w in ws:
+        cur.append(w)
+        if len(cur) >= 7 or re.search(r"[.,?!]$", w["w"]):
+            out.append(cur)
+            cur = []
+    return out + ([cur] if cur else [])
+
+
+def groups(ws):
+    out, i = [], 0
+    while i < len(ws):
+        k = 2 if len("".join(w["w"] for w in ws[i:i + 3])) > 16 else 3
+        out.append(ws[i:i + k])
+        i += k
+    return out
+
+
+captions, cues = [], []
+for b in beats:
+    if not b.get("vo"):
+        continue
+    t0 = b["start"] + pace["lead"]
+    ws = [{"w": w["w"], "s": round(t0 + w["s"], 3), "e": round(t0 + w["e"], 3)} for w in words[b["vo"]]["words"]]
+    cues += [[c[0]["s"], c[-1]["e"] + 0.2, " ".join(w["w"] for w in c)] for c in chunks(ws)]
+    if b["kind"] == "cta" or style["captions"] == "none":
+        continue
+    gs = chunks(ws) if style["captions"] == "subtitle" else groups(ws)
+    for i, g in enumerate(gs):
+        nxt = gs[i + 1][0]["s"] if i + 1 < len(gs) else min(g[-1]["e"] + 0.4, b["start"] + b["len"])
+        captions.append({"s": round(max(b["start"], g[0]["s"] - (0.05 if i == 0 else 0)), 3), "e": round(nxt, 3), "words": g})
+for a, c in zip(cues, cues[1:]):
+    a[1] = round(min(a[1], c[0] - 0.02), 3)  # no overlapping cues
+proj.mkdir(exist_ok=True)
+(proj / "cues.json").write_text(json.dumps(cues, ensure_ascii=False))
+
+film_data = {"fmt": fmt, "W": W, "H": H, "language": LANG, "style": style, "labels": labels, "total": total, "beats": beats, "captions": captions,
+             "cta": film.get("cta"), "logo": stage(film.get("logo"), "img"), "logoOnLight": stage(film.get("logoOnLight"), "img"), "qr": stage(film.get("qr"), "img")}
+(proj / "film-data.js").write_text("window.FILM = " + json.dumps(film_data, ensure_ascii=False) + ";\n")
+
+# 5. Audio: the voice lines on one track, the music bed with the style's levels, sound effects and room tone.
+def ffmpeg(*args):
+    run("ffmpeg", "-v", "error", "-y", *args)
+
+
+ins, graph = [], []
+for i, b in enumerate(x for x in beats if x.get("vo")):
+    ins += ["-i", str(vdir / f"{b['vo']}.mp3")]
+    ms = round((b["start"] + pace["lead"]) * 1000)
+    graph.append(f"[{i}:a]aformat=sample_rates=48000:channel_layouts=stereo,atrim=start={words[b['vo']]['offset']},asetpts=PTS-STARTPTS,adelay={ms}|{ms}[a{i}]")
+if not graph:
+    sys.exit("no beat has a voice line (vo); a film needs narration")
+mix = "".join(f"[a{i}]" for i in range(len(graph)))
+ffmpeg(*ins, "-filter_complex", ";".join(graph) + f";{mix}amix=inputs={len(graph)}:normalize=0:duration=longest,apad[o]",
+       "-map", "[o]", "-t", str(total), "-ar", "48000", "assets/vo.wav")
+
+music = style["music"]
+track = vdir / music["track"]
+if film.get("music"):
+    track = SKILL / "assets/music" / f"{film['music']}.mp3"
+if not track.exists():
+    sys.exit(f"no music: put {music['track']} in {vdir} (scripts/music.sh) or set film.json \"music\" to one of: "
+             + ", ".join(sorted(p.stem for p in (SKILL / "assets/music").glob("*.mp3"))))
+pts = [(0, 0), (1, music["base"]), (max(1, reveal - 0.5), music["base"]), (reveal + 1 / 3, music["lift"]), (reveal + 3, music["base"] + 0.04),
+       (total - 2, music["base"] + 0.04), (total, 0)]
+pts = [p for i, p in enumerate(pts) if i == 0 or p[0] > pts[i - 1][0]]  # a short film can fold the points back on themselves
+expr = f"{pts[-1][1]}"
+for (t0, a0), (t1, a1) in reversed(list(zip(pts, pts[1:]))):
+    expr = f"if(lt(t,{t1}),{a0}+({a1}-{a0})*(t-{t0})/({t1}-{t0}),{expr})"
+ffmpeg("-i", str(track), "-af", f"aloop=loop=-1:size=2e9,atrim=0:{total},loudnorm=I=-16:TP=-1.5,volume='{expr}':eval=frame,aformat=sample_rates=48000:channel_layouts=stereo", "assets/music.wav")
+
+LIB = HOME / "sfx"
+
+
+def sound(name):
+    def find():
+        return next((f for d in (vdir / "sfx", preset / "assets/sfx", LIB) for e in (".wav", ".mp3") if (f := d / (name + e)).exists()), None)
+    if not find() and not (LIB / "whoosh.mp3").exists():  # make the shared library once, synthesized (no ElevenLabs credits spent unless SFX_PROVIDER says so)
+        run("python3", str(SKILL / "scripts/sfx.py"), "--provider", os.environ.get("SFX_PROVIDER", "synth"))
+    f = find()
+    if not f:
+        sys.exit(f"sound {name!r} not found in {vdir / 'sfx'}, {preset / 'assets/sfx'} or {LIB}")
+    shutil.copy(f, proj / "assets/sfx" / f.name)
+    return f.name
+
+
+fx = style["sfx"]
+sfx, amb = [], []   # (file, start, volume)
+for i, b in enumerate(beats):
+    cut = fx["reveal"] if b["kind"] == "reveal" else fx["question"] if b["kind"] == "question" else fx["cut"] if i else ""
+    if cut:
+        sfx.append((sound(cut), b["start"], 0.7 if b["kind"] == "reveal" else 0.35))
+    sfx += [(sound(s), b["start"] + pace["lead"], 0.45) for s in b.get("sfx", [])]
+    if fx["text"] and b.get("title") and i:
+        sfx.append((sound(fx["text"]), b["start"] + pace["lead"] + 0.2, 0.25))
+    if b.get("ambience"):
+        a = sound(b["ambience"])
+        ffmpeg("-stream_loop", "-1", "-i", f"assets/sfx/{a}", "-t", str(b["len"]), "-af", f"afade=t=in:d=0.3,afade=t=out:st={max(0, b['len'] - 0.3)}:d=0.3,aformat=sample_rates=48000:channel_layouts=stereo", f"assets/amb-{i}.wav")
+        amb.append((f"amb-{i}.wav", b["start"], b["len"]))
+tracks, tags = {}, []   # greedy track numbers from 3, so no two sounds overlap on one track (HyperFrames lint)
+
+
+def place(tag, start, dur):
+    k = next(k for k in range(3, 99) if tracks.get(k, -1) <= start)
+    tracks[k] = start + dur
+    tags.append(tag.replace("TRACK", str(k)))
+
+
+for i, (name, start, vol) in enumerate(sorted(sfx, key=lambda x: x[1])):
+    d = round(float(probe(proj / "assets/sfx" / name, "duration")), 2)
+    place(f'<audio id="sfx-{i}" src="assets/sfx/{name}" data-start="{start:.2f}" data-duration="{d}" data-track-index="TRACK" data-volume="{vol}"></audio>', start, d)
+for i, (name, start, dur) in enumerate(amb):
+    place(f'<audio id="amb-{i}" src="assets/{name}" data-start="{start:.2f}" data-duration="{dur}" data-track-index="TRACK" data-volume="0.18"></audio>', start, dur)
+audio = "\n      ".join([f'<audio id="vo" src="assets/vo.wav" data-start="0" data-duration="{total}" data-track-index="1"></audio>',
+                        f'<audio id="music" src="assets/music.wav" data-start="0" data-duration="{total}" data-track-index="2"></audio>'] + tags)
+
+# 6. Fonts (the style's, plus Inter for kinetic captions), the page, carve the music around the voice, check.
+faces = []
+fonts = set(style["fonts"].values()) | ({"Inter"} if style["captions"] == "kinetic" else set())
+for fam in sorted(fonts):
+    stem = fam.replace(" ", "")
+    for suffix, slant in (("", "normal"), ("-Italic", "italic")):
+        src = next((f for d in (preset / "assets/fonts", SKILL / "assets/film-fonts", SKILL / "assets/fonts") if (f := d / f"{stem}{suffix}.ttf").exists()), None)
+        if src:
+            shutil.copy(src, proj / "assets/fonts" / src.name)
+            faces.append(f'@font-face {{ font-family: "{fam}"; src: url("assets/fonts/{src.name}"); font-weight: 100 900; font-style: {slant}; }}')
+        elif not suffix:
+            sys.exit(f"font {fam!r} not found: add {stem}.ttf to the preset's assets/fonts or the skill's assets/film-fonts")
+page = (SKILL / "film.html").read_text()
+for k, v in {"W": W, "H": H, "RES": RES, "DURATION": total, "LANG": LANG}.items():
+    page = page.replace("{{" + k + "}}", str(v))
+page = page.replace("/*FONTS*/", "\n      ".join(faces)).replace("<!-- AUDIO -->", audio)
+(proj / "index.html").write_text(page)
+shutil.copy(SKILL / "hyperframes.json", proj / "hyperframes.json")
+(proj / "package.json").write_text(json.dumps({"name": "kaizen-film", "private": True, "type": "module", "devDependencies": {"@hyperframes/core": HF.split("@")[1]}}, indent=2))
+if not (proj / "node_modules/@hyperframes/core").exists():
+    run("npm", "install", "--silent")
+run("node", str(SKILL / "tools/carve.mjs"), "--comp", "index.html", "--bed", "music", "--voice", "vo")
+run("npx", "--yes", HF, "check")
+print(f"{len(beats)} beats, {len(captions)} caption groups, {len(sfx)} sfx, {fmt}, {total}s")
+
+# 7. Credits and master data, then render + master with --render.
+name = film.get("name", vdir.name) + (f"-{fmt}" if forced else "")
+line = re.compile(rf"^- {re.escape(music['track'] if not film.get('music') else film['music'])}\.mp3: (.+)$", re.M)
+bundled = (SKILL / "assets/CREDITS.txt").read_text() if (SKILL / "assets/CREDITS.txt").exists() else ""
+credits = [f.read_text().strip() for f in [vdir / "CREDITS.txt", *sorted(vdir.glob("CREDITS-*.txt"))] if f.exists()]
+if film.get("music") and (m := line.search(bundled)):
+    credits.append("Music: " + m.group(1))
+credits += [f.read_text().strip() for f in (preset / "CREDITS.txt",) if f.exists()]
+credits.append("Voice and sound effects: see the voice provider in film.json (ElevenLabs commercial use requires a paid plan).")
+(proj / "CREDITS.txt").write_text("\n\n".join(credits) + "\n")
+(proj / "meta.json").write_text(json.dumps({"name": name, "folder": film.get("name", vdir.name), "preset": preset.name, "loudness": style["loudness"]}))
+if "--render" in sys.argv:
+    run("bash", str(SKILL / "scripts/master.sh"), str(vdir), cwd=WORK)

package/skills/{kaizen-video → media/kaizen-video}/scripts/make_tiktok.py

@@ -158,7 +158,7 @@ tags = "\n".join(f'      <audio id="sfx-{i}" src="assets/sfx/{n}.wav" data-start
 src, key = rel(cfg["video"]), proj / "source.key"
 vf = "scale=1080:1920:flags=lanczos,unsharp=5:5:0.6:5:5:0,fps=30,format=yuv420p"
 af = "afftdn=nf=-28,deesser=i=0.35,aformat=sample_rates=48000:channel_layouts=stereo"
-k = json.dumps([str(src), src.stat().st_mtime, co_a, co_b, vf, af])
+k = json.dumps([str(src), src.stat().st_mtime, co_a, co_b, vf, af, "g30"])
 if not (proj / "source.mp4").exists() or not key.exists() or key.read_text() != k:
     if co:
         graph = (f"[0:v]split[v1][v2];[0:a]asplit[a1][a2];"
@@ -167,7 +167,7 @@ if not (proj / "source.mp4").exists() or not key.exists() or key.read_text() !=
     else:
         graph = f"[0:v]{vf}[v];[0:a]{af}[a]"
     run("ffmpeg", "-v", "error", "-y", "-i", str(src), "-filter_complex", graph, "-map", "[v]", "-map", "[a]",
-        "-c:v", "libx264", "-crf", "14", "-preset", "medium", "-c:a", "aac", "-b:a", "256k", "source.mp4")
+        "-c:v", "libx264", "-crf", "14", "-preset", "medium", "-g", "30", "-c:a", "aac", "-b:a", "256k", "source.mp4")
     key.write_text(k)
 
 # 5. Music bed trimmed to length, then the composition from the template.
@@ -191,7 +191,12 @@ print(f"{len(chunks)} caption chunks, {len(beats)} beats, {len(sfx)} sfx, {durat
 if "--render" in sys.argv:
     out = WORK / "output" / cfg["name"] / cfg["preset"] / f"{cfg['name']}.mp4"
     out.parent.mkdir(parents=True, exist_ok=True)
-    run("npx", "--yes", HF, "render", "--crf", str(cfg.get("crf", 23)), "-o", str(out))  # CRF 23: ~1/3 the size of the default 16, same resolution
+    # Frame extraction writes gigabytes of temp files; /tmp is often a small tmpfs, which fails as VIDEO_SOURCE_UNRENDERABLE.
+    tmp = proj / ".render-tmp"
+    tmp.mkdir(exist_ok=True)
+    run("npx", "--yes", HF, "render", "--crf", str(cfg.get("crf", 23)), "-o", str(out),  # CRF 23: ~1/3 the size of the default 16, same resolution
+        env={**os.environ, "TMPDIR": str(tmp)})
+    shutil.rmtree(tmp, ignore_errors=True)
     shutil.rmtree(proj / "renders", ignore_errors=True)
     # The video's own credits (images, footage), the music bed actually used, then the preset's (fonts, sound effects).
     # A music credit is the line "- <music>.mp3: ..." in the preset's CREDITS.txt, else in the shared assets/CREDITS.txt.

package/skills/{story-video → media/kaizen-video}/scripts/master.sh

@@ -1,26 +1,27 @@
 #!/usr/bin/env bash
-# Render one format of a film, master loudness (two-pass), write .srt + thumbnail + credits.
-# Earlier deliveries move to out/previous/ (never overwritten).
-# Usage: scripts/master.sh <film-dir> <16x9|9x16> <out-name> [lufs: -14 social | -16 presentation] [thumb-second]
+# Render a built film (make_film.py), master loudness (two-pass), write .srt + thumbnail + credits.
+# Run from the project folder. Earlier deliveries move to output/<name>/<preset>/previous/ (never overwritten).
+# Usage: scripts/master.sh <film-dir> [lufs: default from the style, -14 social | -16 presentation] [thumb-second]
+# Writes output/<film>/<preset>/<name>.mp4; <name> is <film>-<shape> when make_film.py ran with --format.
 set -euo pipefail
-DIR=$(cd "${1:?film dir}" && pwd); FMT=${2:?format}; NAME=${3:?name}; LUFS=${4:--16}; THUMB=${5:-3}
+DIR=$(cd "${1:?film dir}" && pwd); THUMB=${3:-3}
 SKILL=$(cd "$(dirname "$0")/.." && pwd)
-ENGINE=${STORY_VIDEO_ENGINE:-$HOME/.kaizen/story-video/engine}
-OUT="$DIR/out"; mkdir -p "$OUT/previous"
+m(){ python3 -c "import json;print(json.load(open('$DIR/film/meta.json')).get('$1',''))"; }
+# folder: the film's name; name: the file's, which make_film.py --format suffixes (gerbang-4x5) so shapes sit side by side.
+NAME=$(m name); FOLDER=$(m folder); PRESET=$(m preset); LUFS=${2:-$(m loudness)}
+OUT="$PWD/output/${FOLDER:-$NAME}/$PRESET"; mkdir -p "$OUT/previous"
 if [ -f "$OUT/$NAME.mp4" ]; then
   stamp=$(date +%Y%m%d-%H%M%S)
   for x in "$OUT/$NAME".mp4 "$OUT/$NAME".srt "$OUT/$NAME"-thumb.jpg; do [ -f "$x" ] && mv "$x" "$OUT/previous/$(basename "${x%.*}")-$stamp.${x##*.}"; done
 fi
-python3 -c "import json,sys; json.dump({'film': json.load(open('$DIR/film.json')), 'words': json.load(open('$DIR/words.json'))}, open('$DIR/.props.json','w'))"
-(cd "$ENGINE" && npx remotion render src/index.ts "Film-$FMT" "$OUT/$NAME.raw.mp4" --props="$DIR/.props.json" --public-dir="$DIR" --log=error 2>&1 | grep -v "network requests" || true)
+(cd "$DIR/film" && npx --yes hyperframes@0.8.176 render --crf 20 -o "$OUT/$NAME.raw.mp4" >/dev/null)
 J=$(ffmpeg -hide_banner -i "$OUT/$NAME.raw.mp4" -af loudnorm=I=$LUFS:TP=-1.5:LRA=11:print_format=json -f null - 2>&1 | sed -n '/{/,/}/p')
 g(){ echo "$J" | python3 -c "import sys,json;print(json.load(sys.stdin)['$1'])"; }
 ffmpeg -v error -y -i "$OUT/$NAME.raw.mp4" -c:v copy -c:a aac -b:a 192k \
   -af "loudnorm=I=$LUFS:TP=-1.5:LRA=11:measured_I=$(g input_i):measured_TP=$(g input_tp):measured_LRA=$(g input_lra):measured_thresh=$(g input_thresh):offset=$(g target_offset):linear=true" \
   "$OUT/$NAME.mp4"
-rm "$OUT/$NAME.raw.mp4" "$DIR/.props.json"
+rm "$OUT/$NAME.raw.mp4"; rm -rf "$DIR/film/renders"
 python3 "$SKILL/scripts/srt.py" "$DIR" "$OUT/$NAME.srt"
 ffmpeg -v error -y -ss "$THUMB" -i "$OUT/$NAME.mp4" -frames:v 1 -q:v 2 "$OUT/$NAME-thumb.jpg"
-cat "$DIR"/CREDITS-*.txt > "$OUT/$NAME-credits.txt" 2>/dev/null || true
-echo "Voice & sound effects: see the voice provider in film.json (ElevenLabs commercial use requires a paid plan)." >> "$OUT/$NAME-credits.txt"
+cp "$DIR/film/CREDITS.txt" "$OUT/CREDITS.txt"
 ffprobe -v error -show_entries format=duration -of csv=p=0 "$OUT/$NAME.mp4" | xargs -I{} echo "done: $OUT/$NAME.mp4 ({} s, $LUFS LUFS)"

package/skills/{story-video → media/kaizen-video}/scripts/sfx.py

@@ -1,8 +1,8 @@
-"""Build the sound-effect / room-tone library into the shared engine (~/.kaizen/story-video/engine/sfx/).
+"""Build the sound-effect / room-tone library on this machine (~/.kaizen/kaizen-video/sfx/; override KAIZEN_VIDEO_HOME).
 Usage: python3 scripts/sfx.py [--provider synth|elevenlabs] [--force]
   synth       (default without ELEVENLABS_API_KEY) — synthesized locally with ffmpeg; free, no licence limits.
   elevenlabs  (default with a key) — generated sound effects; commercial use needs a paid ElevenLabs plan.
-Only missing files are made unless --force. Names are what presets.json and beats (sfx/ambience) use.
+Only missing files are made unless --force. Names are what a film preset's style.json and beats (sfx/ambience) use.
 No sound files ship with the skill: every machine makes its own."""
 import json, os, subprocess, sys, urllib.request
 
@@ -43,7 +43,7 @@ SYNTH = {
 args = sys.argv[1:]
 force = "--force" in args
 provider = args[args.index("--provider") + 1] if "--provider" in args else ("elevenlabs" if os.environ.get("ELEVENLABS_API_KEY") else "synth")
-SFX = os.path.expanduser(os.environ.get("STORY_VIDEO_ENGINE", "~/.kaizen/story-video/engine")) + "/sfx"
+SFX = os.path.expanduser(os.environ.get("KAIZEN_VIDEO_HOME", "~/.kaizen/kaizen-video")) + "/sfx"
 os.makedirs(SFX, exist_ok=True)
 H = {"xi-api-key": os.environ.get("ELEVENLABS_API_KEY", ""), "Content-Type": "application/json"}
 print("sfx provider:", provider)

package/skills/media/kaizen-video/scripts/srt.py

@@ -0,0 +1,9 @@
+"""Write an .srt from the cues make_film.py computed (<film-dir>/film/cues.json: [[start, end, text], ...]).
+Usage: python3 scripts/srt.py <film-dir> <out.srt>"""
+import json, sys
+cues = json.load(open(f"{sys.argv[1]}/film/cues.json"))
+def ts(sec):
+    ms = int(round(sec * 1000)); h, ms = divmod(ms, 3600000); m, ms = divmod(ms, 60000); s, ms = divmod(ms, 1000)
+    return f"{h:02}:{m:02}:{s:02},{ms:03}"
+open(sys.argv[2], "w").write("\n".join(f"{i}\n{ts(s)} --> {ts(e)}\n{t}\n" for i, (s, e, t) in enumerate(cues, 1)))
+print("srt", len(cues), "cues")

package/skills/media/kaizen-video/scripts/still.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Quick check frames of a built film: scripts/still.sh <film-dir> <second> [<second>...]
+# -> <film-dir>/film/check/at-<second>s.png (run make_film.py first; delete the folder after looking)
+set -euo pipefail
+DIR=$(cd "$1" && pwd); shift
+IFS=,; (cd "$DIR/film" && npx --yes hyperframes@0.8.176 snapshot --at "$*" --no-end -o check >/dev/null)
+ls "$DIR"/film/check/*.png

package/web/board/views.ts

@@ -58,7 +58,7 @@ export function go(v, push) {
 
 export function initViews() {
   document.querySelectorAll(".rail a[data-view]").forEach((a) => {
-    if (a.dataset.view === "notes") return;
+    if (a.dataset.view === "notes" || a.dataset.view === "video") return;
     a.onclick = (e) => {
       if (e.ctrlKey || e.metaKey || e.shiftKey || e.button) return;
       e.preventDefault();

package/web/board.html

@@ -539,6 +539,7 @@ a.schip:hover{color:var(--ink);border-color:color-mix(in srgb,var(--line) 60%,va
 <symbol id="i-x" viewBox="0 0 24 24"><path d="M18 6L6 18M6 6l12 12"/></symbol>
 <symbol id="i-filter" viewBox="0 0 24 24"><path d="M4 5h16l-6 8v6l-4-2v-4z"/></symbol>
 <symbol id="i-note" viewBox="0 0 24 24"><path d="M6 3h9l4 4v14H6z"/><path d="M14 3v5h5M9 13h6M9 17h6"/></symbol>
+<symbol id="i-video" viewBox="0 0 24 24"><rect x="3" y="6" width="13" height="12" rx="2"/><path d="M16 10.5l5-3v9l-5-3z"/></symbol>
 <symbol id="i-trash" viewBox="0 0 24 24"><path d="M3 6h18M8 6V4h8v2M6 6l1 14h10l1-14M10 11v6M14 11v6"/></symbol>
 <symbol id="i-ask" viewBox="0 0 24 24"><path d="M21 12a8 8 0 0 1-11.6 7.1L4 20l1-4.6A8 8 0 1 1 21 12z"/><path d="M9.8 9.5a2.3 2.3 0 0 1 4.4.8c0 1.5-2.2 2-2.2 3.2M12 16.5h.01"/></symbol>
 <symbol id="i-term" viewBox="0 0 24 24"><path d="M4 17l6-5-6-5M12 19h8"/></symbol>
@@ -590,6 +591,7 @@ a.schip:hover{color:var(--ink);border-color:color-mix(in srgb,var(--line) 60%,va
   <a class="it" href="/?view=icebox" data-view="sources" title="Icebox: requests gathered from your sources"><svg><use href="#i-inbox"/></svg><span class="lbl">Icebox</span></a>
   <a class="it" href="/" data-view="board" title="Board"><svg><use href="#i-board"/></svg><span class="lbl">Board</span></a>
   <a class="it" href="/notebook" data-view="notes" title="Notes"><svg><use href="#i-note"/></svg><span class="lbl">Notes</span></a>
+  <a class="it" href="/video" data-view="video" title="Video: make and edit videos"><svg><use href="#i-video"/></svg><span class="lbl">Video</span></a>
   <a class="it" href="/?view=terminal" data-view="terminal" title="Terminal: every agent running in its card"><svg><use href="#i-term"/></svg><span class="lbl">Terminal</span></a>
   <a class="it" href="/?view=settings" data-view="settings" title="Settings"><svg><use href="#i-gear"/></svg><span class="lbl">Settings</span></a>
   <span class="end"></span>