@kolbo/kolbo-code-linux-arm64-musl 1.1.72 → 1.1.73

package/skills/storytelling/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: storytelling
+description: >
+  Narrative structure and storytelling for video content. Explainer arc templates, hook types,
+  the 30-second retention rule, pacing by duration, the "but-therefore" method, concept
+  introduction patterns. Use when scripting explainer videos, educational content, or any
+  narrative-driven video.
+  Keywords: storytelling, narrative, script, explainer, hook, arc, structure, pacing, retention,
+  educational, concept, story, writing, script structure
+---
+
+# Storytelling & Narrative Structure for Video
+
+## The Explainer Arc Template (3 minutes)
+
+Scale proportionally for other lengths.
+
+```
+[0:00 - 0:08]  HOOK
+               Pattern interrupt or counterintuitive claim. 1-2 sentences max.
+               Visual: striking image or animation that creates curiosity.
+
+[0:08 - 0:30]  TENSION / INFORMATION GAP
+               "Here's what most people think... but that's not quite right."
+               Establish stakes: why should I care?
+
+[0:30 - 0:50]  CONCEPT 1 (Foundation)
+               Simplest building block needed. ONE idea, ONE visual.
+               End with a "but" or "therefore" transition.
+
+[0:50 - 1:15]  CONCEPT 2 (Complication)
+               Build on Concept 1. Introduce the wrinkle.
+               Visual: transform/evolve the previous visual.
+
+[1:15 - 1:20]  PALETTE CLEANSER
+               Brief pause, visual gag, or "let that sink in" moment.
+               Gives working memory a beat to consolidate.
+
+[1:20 - 1:50]  CONCEPT 3 (Key Insight)
+               The "aha" moment. Core of the video.
+               1-3 seconds of deliberate silence after the reveal.
+               Visual: the most polished animation in the video.
+
+[1:50 - 2:20]  PROOF / EXAMPLE
+               Concrete demonstration: "Watch what happens when..."
+               Show the insight working in a specific case.
+
+[2:20 - 2:45]  IMPLICATIONS / "SO WHAT?"
+               Connect back to the real world. "This means that..."
+               Scale from specific back to general.
+
+[2:45 - 3:00]  REFRAME + CLOSE
+               Callback to the hook. Restate core insight in one sentence.
+               Optional: open a new curiosity gap.
+```
+
+## Scaling by Duration
+
+| Length | Concepts | Hook | Tension | Core | Proof | Close |
+|--------|----------|------|---------|------|-------|-------|
+| 1 min | 1-2 | 5s | 10s | 30s | 10s | 5s |
+| 2 min | 2-3 | 8s | 15s | 60s | 25s | 12s |
+| 3 min | 3-5 | 8s | 22s | 100s | 30s | 15s |
+| 5 min | 5-8 | 10s | 30s | 180s | 50s | 20s |
+
+## Hook Types
+
+| Type | Pattern | Best For |
+|------|---------|----------|
+| **Contrarian** | "Everything you've been told about X is wrong." | Science/myth-busting |
+| **Outcome** | "By the end of this video, you'll understand X." | Math/concept explainers |
+| **Mystery** | "In 1987, something impossible happened..." | Story-driven content |
+| **Stakes** | "This one mistake costs people X every year." | Practical/how-to |
+
+## The 30-Second Rule
+
+50% of viewer drop-off happens in the first 30 seconds. The hook + tension setup MUST be complete by second 30. Retention curves that survive the 30-second cliff typically retain 40-60% through the full video.
+
+## The "But-Therefore" Method
+
+Never connect sections with "and then." Always use **"but"** or **"therefore."**
+
+**Bad:** "Atoms have electrons, AND THEN those electrons have energy levels, AND THEN..."
+
+**Good:** "Atoms have electrons. BUT those electrons can only exist at specific energy levels. THEREFORE, when they jump between levels, they release light at exact frequencies."
+
+Each "but" creates tension. Each "therefore" resolves it. This is the engine of narrative momentum.
+
+## Concept Introduction Pattern
+
+For each new concept in the video:
+
+1. **Name it** — give the concept a label the viewer can hold onto
+2. **Show it** — visual representation (never just explain with words)
+3. **Contrast it** — "unlike X, this works by..."
+4. **Apply it** — concrete example in the real world
+5. **Connect it** — link to the previous concept with "but" or "therefore"
+
+## Pacing by Content Energy
+
+| Energy Level | Pacing | Visual Change Rate |
+|-------------|--------|-------------------|
+| High (promo, action) | Fast cuts, 1-2s per shot | Every 1-2 seconds |
+| Medium (tutorial, explainer) | Balanced, 3-5s per shot | Every 3-4 seconds |
+| Low (meditation, documentary) | Let scenes breathe, 5-10s | Every 5-8 seconds |
+
+## Common Mistakes
+
+- **Info dump at the start** — frontload curiosity, not information
+- **No stakes** — "here's a cool fact" vs "this changes how you should think about X"
+- **Too many concepts** — one concept per minute is the maximum for retention
+- **Missing the "aha"** — every video needs ONE clear revelation moment
+- **Symmetric structure** — the most important concept should be at 60-70% through the video, not in the middle
+- **No callback** — the close should reference the hook, creating a satisfying loop
+
+---
+
+## Kolbo MCP Integration
+
+Use storytelling structure to guide Kolbo generation workflows:
+
+**Scripted Explainer Workflow:**
+1. Write script using the arc template above
+2. `generate_speech` → narrate each section
+3. `generate_image` or `generate_video` per scene (with visual direction from script)
+4. `generate_music` → background track matching the energy arc
+5. Compose in Remotion or FFmpeg following the timing structure
+6. `transcribe_audio` → generate captions for accessibility
+
+**AI-Assisted Scripting:**
+Use `chat_send_message` with a video-capable model to brainstorm scripts. Feed the arc template as context and ask the AI to fill in each section for your topic.
+
+**Creative Director for Visual Storyboarding:**
+`generate_creative_director` with 4-8 scenes mapped to the arc sections:
+- Scene 1: Hook visual
+- Scene 2-3: Concept visuals
+- Scene 4: Key insight / "aha" visual
+- Scene 5-6: Proof / example
+- Scene 7-8: Close / callback

package/skills/subtitle-production/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: subtitle-production
+description: >
+  Subtitle and caption production: timing strategies, cue length by format (vertical vs horizontal),
+  ASS/SRT styling, word-level timing, RTL support for Hebrew/Arabic, burn-in with FFmpeg,
+  readability rules. Use when generating, styling, or burning in subtitles.
+  Keywords: subtitle, caption, SRT, ASS, VTT, timing, burn-in, word-level, karaoke, RTL,
+  Hebrew, Arabic, font size, cue, readability
+---
+
+# Subtitle & Caption Production
+
+## Output Formats
+
+| Format | Extension | Use Case |
+|--------|-----------|----------|
+| SRT | `.srt` | Universal — FFmpeg, players, YouTube upload |
+| VTT | `.vtt` | Web-native — HTML5 video, browser playback |
+| ASS | `.ass` | Advanced styling, RTL support, per-word positioning |
+
+## Cue Length by Format
+
+### Vertical Short-Form (TikTok, Reels, Shorts)
+- **Max 3-4 words per cue** — narrow screen, text must be large
+- **Max 20 characters per line**
+- Subtitles are **mandatory** (85% watch muted)
+
+### Horizontal Standard (YouTube, web)
+- **Max 6-8 words per cue** — wider screen
+- **Max 42 characters per line** (broadcast standard)
+
+### General Rules
+- Average viewer reads ~15 characters/second
+- Minimum display time: 0.5 seconds per cue
+- Maximum display time: 5 seconds per cue
+
+## Styling for Burn-in
+
+### Vertical Video (1080x1920)
+```
+font: Arial (or Heebo Bold for Hebrew)
+font_size: 18
+bold: true
+primary_color: &H00FFFFFF     (white, ASS format)
+outline_color: &H00000000     (black)
+outline_width: 3              (thick for readability)
+shadow: 2
+margin_v: 50
+alignment: 2                  (bottom center)
+```
+
+### Horizontal Video (1920x1080)
+```
+font: Arial
+font_size: 22
+bold: true
+primary_color: &H00FFFFFF
+outline_color: &H00000000
+outline_width: 2
+shadow: 1
+margin_v: 40
+alignment: 2
+```
+
+### Common Mistakes
+- **Wrong color format:** `&HFFFFFF` breaks positioning. Always use full 8-char `&H00FFFFFF`
+- **Font too large on vertical:** `font_size: 28` fills center of 9:16. Use 18 max
+- **Too many words per cue on vertical:** 5+ words creates multi-line blocks covering the face
+- **MarginV too large:** Values over 200 push text off-screen. Stay under 100
+
+## Timing Best Practices
+
+- Cue start must match word onset (not before the speaker starts)
+- Cue end should extend ~200ms past the last word for comfortable reading
+- Never let a cue linger into the next speaker's turn
+- Don't split a thought across two cues if it fits in one
+
+## FFmpeg Burn-in Commands
+
+### Simple SRT
+```bash
+ffmpeg -i input.mp4 -vf "subtitles=subs.srt:force_style='FontSize=22,Bold=1,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,Outline=2'" -c:v libx264 -crf 18 -c:a copy output.mp4
+```
+
+### ASS with Custom Styling
+```bash
+ffmpeg -i input.mp4 -vf "ass=styled_subs.ass" -c:v libx264 -crf 18 -c:a copy output.mp4
+```
+
+### Windows Path Escaping
+```bash
+# Escape colons in subtitle filter paths on Windows
+ffmpeg -i input.mp4 -vf "subtitles=C\\:/Users/path/subs.srt" output.mp4
+```
+
+## RTL (Hebrew/Arabic) — Proven Patterns
+
+RTL subtitles are tricky. These patterns are battle-tested in Kolbo's video production pipeline.
+
+**Reference implementations (bundled in `./reference/`):**
+- `reference/burn_to_video.py` — Full burn pipeline with RTL progress bar (`geq` filter), chapter compositing, NVENC encoding
+- `reference/export_srts.py` — SRT generation with chapter divider offset accounting
+- `reference/gen_srt.py` — Word-level SRT from transcript JSON (8-word grouping, 1.5s gap detection)
+
+### Option 1: SRT with Simple Burn-in (easiest, works for most cases)
+
+Plain SRT files work for Hebrew/Arabic if you use the right font and let FFmpeg's libass handle bidi:
+```bash
+ffmpeg -i input.mp4 -vf "subtitles=subs.srt:force_style='FontName=Heebo,FontSize=22,Bold=1,Encoding=177,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,Outline=2'" -c:v libx264 -crf 18 -c:a copy output.mp4
+```
+- **Font**: Heebo Bold for Hebrew, Cairo Bold for Arabic
+- **Encoding=177** (Hebrew) or **Encoding=178** (Arabic) in ASS style
+
+### Option 2: ASS with Per-Word Positioning (for karaoke/highlighting)
+
+When you need per-word color highlighting with RTL text, you MUST use separate ASS Dialogue lines per word:
+
+- Each word gets its own `Dialogue` line with explicit `\pos(x,y)`
+- Use PIL to measure word widths: apply `~0.74` scale factor (PIL→libass calibration)
+- Use `Alignment=7` (top-left anchor) so `\pos` sets exact top-left of each word
+- Two named ASS styles (e.g., White + Yellow) for highlight vs inactive — NO inline `\c` tags
+
+**CRITICAL:** Any inline ASS tag (`\c`, `\K`, `\1c`) between RTL words **breaks Unicode bidi in libass** — words render LTR instead of RTL. Always use separate Dialogue lines per word.
+
+### Option 3: Remotion Captions (best for karaoke, full RTL control)
+
+Remotion gives you full CSS control over RTL text. Proven pattern from Kolbo's video pipeline:
+
+```tsx
+// Detect language and set direction
+const isHebrew = language === "he" || language === "iw";
+const fontFamily = isHebrew ? "'Heebo', sans-serif" : "'Poppins', sans-serif";
+
+// Root container
+<div style={{
+  direction: isHebrew ? "rtl" : "ltr",
+  fontFamily,
+  textTransform: isHebrew ? "none" : "uppercase",
+  letterSpacing: isHebrew ? 0 : -2,
+}}>
+  {words.map((word, i) => {
+    const progress = interpolate(frame, [word.startFrame, word.endFrame], [0, 1], {
+      extrapolateLeft: "clamp", extrapolateRight: "clamp"
+    });
+    return (
+      <span key={i} style={{
+        color: progress > 0 ? accentColor : "#ffffff",
+        transition: "none", // No CSS transitions in Remotion!
+      }}>
+        {word.text}{" "}
+      </span>
+    );
+  })}
+</div>
+```
+
+**RTL-specific gotchas in Remotion (proven fixes):**
+- Flip `paddingLeft` ↔ `paddingRight` when Hebrew
+- Flip `transformOrigin`: `"top left"` → `"top right"` for Hebrew
+- Gradient directions: `270deg` (RTL) vs `90deg` (LTR)
+- Position logic: for Hebrew, "left" position actually means right side of screen
+- `letterSpacing: 0` for Hebrew (negative kerning looks wrong with Hebrew fonts)
+- `textTransform: "none"` for Hebrew (uppercase has no meaning in Hebrew)
+
+### RTL Progress Bar (FFmpeg)
+
+Animated progress bar that fills right-to-left for Hebrew, using `geq` filter:
+
+```python
+duration = 5.0  # seconds
+
+# Hebrew (RTL): bar fills RIGHT → LEFT
+bar_cond = f"gt(X,W*(1-T/{duration}))"
+
+# English (LTR): bar fills LEFT → RIGHT
+bar_cond = f"lt(X,W*T/{duration})"
+
+# Apply as geq filter on bottom 4px strip (performant: 5760px/frame not 2M)
+bar_geq = (
+    f"geq="
+    f"r='if({bar_cond},59,r(X,Y))':"    # #3b82f6 blue
+    f"g='if({bar_cond},130,g(X,Y))':"
+    f"b='if({bar_cond},246,b(X,Y))'"
+)
+```
+Uses capital `T` for timestamp in `geq` — avoids conflict with drawbox's `t=fill`.
+
+### Language Detection
+
+```python
+_lang_map = {"heb": "he", "eng": "en", "iw": "he", "ara": "ar", "rus": "ru"}
+language_code = _lang_map.get(raw_lang, raw_lang)
+is_rtl = language_code in ("he", "ar", "fa", "ur")
+```
+
+## Word-Level Timing (Karaoke / Motion Graphics)
+
+For word-by-word highlighting:
+1. `transcribe_audio` via Kolbo MCP → get `word_by_word_srt_url` (ElevenLabs Scribe word-level timestamps)
+2. Each word has precise start/end timing
+3. Group words into display cues (8+ words or >1.5s gap triggers new line)
+4. **For Remotion**: use word timings directly as props — CSS `direction: rtl` handles Hebrew ordering automatically
+5. **For FFmpeg**: use ASS with per-word Dialogue lines (see Option 2 above)
+
+## Quality Checklist
+
+- [ ] Every spoken word appears in a subtitle cue
+- [ ] No cue exceeds the character limit for target format
+- [ ] Subtitles in bottom 20% of frame — never covering the face
+- [ ] Text readable on mobile at native resolution
+- [ ] Timing matches speech — no early or late cues
+- [ ] Cues don't overlap each other
+- [ ] Outline/shadow provides sufficient contrast against all backgrounds
+
+---
+
+## Kolbo MCP Integration
+
+| Task | Kolbo MCP Tool | Notes |
+|------|---------------|-------|
+| Transcribe → SRT | `transcribe_audio` | Returns `srt_url` (grouped) + `word_by_word_srt_url` |
+| Word-level captions | `transcribe_audio` | `word_by_word_srt_url` for karaoke/Remotion |
+| Burn-in to video | FFmpeg | Use SRT from transcription |
+| Visual analysis | `chat_send_message` + Gemini | Analyze where speaker's face is for caption placement |
+
+**Subtitle production workflow:**
+1. `transcribe_audio` → get `srt_url` and `word_by_word_srt_url`
+2. Download the SRT file
+3. Adjust styling for target format (vertical vs horizontal)
+4. Burn in with FFmpeg using the commands above
+5. For Remotion: use `word_by_word_srt_url` with CaptionOverlay component
+
+**For Remotion captions (preferred over FFmpeg burn-in):**
+- Load the word-by-word SRT
+- Use Remotion's CaptionOverlay for animated word highlighting
+- See `remotion-best-practices` skill for details
+
+---
+
+## Local / Free Option
+
+> **IMPORTANT:** Always use Kolbo's `transcribe_audio` by default — it returns both grouped SRT and word-by-word SRT with no setup. FFmpeg burn-in is safe to use directly. Only suggest local transcription if the user explicitly asks for offline/free. Confirm before installing.
+
+**Offline transcription:** `faster-whisper` runs on CPU, no GPU needed (`pip install faster-whisper`). Supports word-level timestamps for subtitle generation.

package/skills/subtitle-production/reference/burn_to_video.py

@@ -0,0 +1,222 @@
+"""
+Full burn pipeline:
+  For each chapter:
+    1. Render SectionDivider card (4s) + mux with SFX
+    2. Cut raw footage segment
+    3. Render ChapterProgress banner (ProRes alpha, exact chapter duration)
+    4. Composite banner onto footage
+  Concatenate everything → final burned MP4
+"""
+import json, os, sys, subprocess
+
+_root = r"G:\Projects\Master Agent"
+for _p in [os.path.join(_root, 'core'), os.path.join(_root, 'agents', 'content-creation')]:
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+import config
+sys.path.insert(0, os.path.join(_root, 'agents', 'content-creation', 'modules'))
+from remotion_render import render as remotion_render, render_still
+
+# ── Config ───────────────────────────────────────────────────────────────────
+SOURCE_VIDEO   = r"C:\Users\Zohar\Downloads\מכללת ספיר H.264.mp4"
+CHAPTERS_JSON  = r"G:\Projects\Master Agent\ytp_jobs\sapir_test\chapters.json"
+SFX_FILE       = r"G:\Projects\Master Agent\ytp_jobs\sapir_test\sfx\v1_cinematic_eq.mp3"
+WORK_DIR       = r"G:\Projects\Master Agent\ytp_jobs\sapir_test\burn"
+FINAL_OUTPUT   = r"G:\Projects\Youtube Editings\renders\sapir_edited_final.mp4"
+VIDEO_DURATION = 1041.1
+FPS            = 30
+FFMPEG         = "ffmpeg"
+NVENC          = True   # -bf 0 -rc-lookahead 0 eliminates encoder delay
+
+os.makedirs(WORK_DIR, exist_ok=True)
+
+# ── Load chapters ─────────────────────────────────────────────────────────────
+with open(CHAPTERS_JSON, encoding='utf-8') as f:
+    chapters = json.load(f)
+
+for i, ch in enumerate(chapters):
+    ch['end_time'] = chapters[i + 1]['start_time'] if i + 1 < len(chapters) else VIDEO_DURATION
+    ch['duration'] = ch['end_time'] - ch['start_time']
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+def _venc(cq=19):
+    """Return video encoder args — NVENC (GPU, no delay) or libx264 fallback."""
+    if NVENC:
+        # -bf 0 -rc-lookahead 0: zero encoder delay → no A/V drift with -c:a copy
+        return ["-c:v", "h264_nvenc", "-preset", "p4", "-cq", str(cq),
+                "-bf", "0", "-rc-lookahead", "0"]
+    return ["-c:v", "libx264", "-preset", "fast", "-crf", str(cq)]
+
+
+def run(cmd, desc=""):
+    print(f"[ffmpeg] {desc}", flush=True)
+    r = subprocess.run(cmd, capture_output=True)
+    if r.returncode != 0:
+        raise RuntimeError(f"FAILED {desc}:\n{r.stderr.decode('utf-8','replace')[-600:]}")
+
+
+def cut_footage(start, end, output):
+    if os.path.exists(output):
+        print(f"[skip] {os.path.basename(output)} exists")
+        return
+    duration = end - start
+    # Dual-seek: fast input seek to 5s before target, then frame-accurate output seek
+    # This gives exact A/V sync without decoding the full file from the beginning.
+    pre = min(5.0, start)
+    run([FFMPEG, "-y",
+         "-ss", str(start - pre), "-i", SOURCE_VIDEO,
+         "-ss", str(pre), "-t", str(duration),
+         *_venc(),
+         "-c:a", "copy",
+         "-movflags", "+faststart", output],
+        f"cut footage {start:.1f}s + {duration:.1f}s")
+
+
+def mux_sfx(video, sfx, output, video_duration=4.0):
+    if os.path.exists(output):
+        print(f"[skip] {os.path.basename(output)} exists")
+        return
+    # Resample SFX to 48kHz to match source video, pad, then mux
+    run([FFMPEG, "-y",
+         "-i", video, "-i", sfx,
+         "-filter_complex", f"[1:a]aresample=48000,apad=pad_dur={video_duration}[a]",
+         "-map", "0:v", "-map", "[a]",
+         *_venc(cq=12), "-c:a", "aac", "-b:a", "192k", "-ar", "48000",
+         "-t", str(video_duration), output],
+        f"mux SFX into {os.path.basename(video)}")
+
+
+def composite_with_banner(footage, banner_png, output, duration_sec, is_hebrew=True):
+    """Composite static banner PNG + animated progress bar.
+    Uses crop+geq+overlay on just the bottom 4 rows — fast (5760 px/frame not 2M).
+    geq uses capital T for timestamp, avoiding conflict with drawbox's t=fill.
+    """
+    if os.path.exists(output):
+        print(f"[skip] {os.path.basename(output)} exists")
+        return
+    d = float(duration_sec)
+    # geq on a 4px strip: T=timestamp(secs), W=strip width, X=pixel x-coord
+    # Hebrew RTL: fill right side first → X > W*(1 - T/D)
+    # LTR:        fill left side first  → X < W*T/D
+    if is_hebrew:
+        bar_cond = f"gt(X,W*(1-T/{d}))"
+    else:
+        bar_cond = f"lt(X,W*T/{d})"
+
+    bar_geq = (
+        f"geq="
+        f"r='if({bar_cond},59,r(X,Y))':"
+        f"g='if({bar_cond},130,g(X,Y))':"
+        f"b='if({bar_cond},246,b(X,Y))'"
+    )
+
+    # overlay=0:0 composites banner PNG onto footage
+    # split → crop bottom 4px → geq colors the bar → overlay back at bottom
+    fc = (
+        f"[0:v][1:v]overlay=0:0:format=auto,format=yuv420p[base];"
+        f"[base]split[main][bot_src];"
+        f"[bot_src]crop=iw:4:0:ih-4[strip];"
+        f"[strip]{bar_geq}[bar];"
+        f"[main][bar]overlay=0:H-4[v]"
+    )
+
+    run([FFMPEG, "-y",
+         "-i", footage,
+         "-i", banner_png,
+         "-filter_complex", fc,
+         "-map", "[v]", "-map", "0:a",
+         *_venc(),
+         "-c:a", "copy",
+         "-movflags", "+faststart", output],
+        f"composite+bar {os.path.basename(output)}")
+
+
+# ── Main loop ─────────────────────────────────────────────────────────────────
+parts = []
+total = len(chapters)
+
+for ch in chapters:
+    n   = ch['chapter_number']
+    dur = ch['duration']
+    dur_frames = int(round(dur * FPS))
+
+    print(f"\n{'='*60}")
+    title_safe = ch['title'].encode('ascii','replace').decode('ascii')
+    print(f"Chapter {n}/{total}: {title_safe}  ({dur:.1f}s = {dur_frames} frames)")
+    print('='*60)
+
+    # ── 1. SectionDivider render ──────────────────────────────────────────
+    divider_raw  = os.path.join(WORK_DIR, f"ch{n:02d}_divider_raw.mp4")
+    divider_sfx  = os.path.join(WORK_DIR, f"ch{n:02d}_divider.mp4")
+
+    if not os.path.exists(divider_raw):
+        print(f"[render] SectionDivider ch{n}...")
+        remotion_render(
+            composition_id="SectionDivider-16x9",
+            props={
+                "chapterNumber": n,
+                "title": ch['title'],
+                "subtitle": ch.get('subtitle', ''),
+                "language": "he",
+                "durationInFrames": 120,
+                "fps": FPS,
+            },
+            output_path=divider_raw,
+            job_dir=WORK_DIR,
+            alpha=False,
+            concurrency=16,
+        )
+    else:
+        print(f"[skip] divider ch{n} exists")
+
+    mux_sfx(divider_raw, SFX_FILE, divider_sfx, video_duration=4.0)
+    parts.append(divider_sfx)
+
+    # ── 2. Cut raw footage ────────────────────────────────────────────────
+    raw_clip = os.path.join(WORK_DIR, f"ch{n:02d}_raw.mp4")
+    cut_footage(ch['start_time'], ch['end_time'], raw_clip)
+
+    # ── 3. ChapterBanner still PNG render (single frame, fast) ───────────
+    banner_png = os.path.join(WORK_DIR, f"ch{n:02d}_banner.png")
+
+    if not os.path.exists(banner_png):
+        print(f"[still] ChapterBanner ch{n}...")
+        render_still(
+            composition_id="ChapterBanner-16x9",
+            props={
+                "chapterNumber": n,
+                "title": ch['title'],
+                "language": "he",
+            },
+            output_path=banner_png,
+            job_dir=WORK_DIR,
+        )
+    else:
+        print(f"[skip] banner ch{n} exists")
+
+    # ── 4. Composite banner + progress bar onto footage ───────────────────
+    composited = os.path.join(WORK_DIR, f"ch{n:02d}_composited.mp4")
+    composite_with_banner(raw_clip, banner_png, composited, dur, is_hebrew=True)
+    parts.append(composited)
+
+# ── Concatenate all parts ─────────────────────────────────────────────────────
+print(f"\n{'='*60}")
+print(f"Concatenating {len(parts)} clips...")
+
+concat_list = os.path.join(WORK_DIR, "concat.txt")
+with open(concat_list, 'w', encoding='utf-8') as f:
+    for p in parts:
+        f.write(f"file '{p}'\n")
+
+run([FFMPEG, "-y",
+     "-f", "concat", "-safe", "0",
+     "-i", concat_list,
+     *_venc(),
+     "-c:a", "copy",
+     "-movflags", "+faststart", FINAL_OUTPUT],
+    f"final concat -> {FINAL_OUTPUT}")
+
+size_mb = os.path.getsize(FINAL_OUTPUT) / 1024 / 1024
+print(f"\nDone! Final output: {FINAL_OUTPUT}")
+print(f"Size: {size_mb:.0f} MB")