@kolbo/kolbo-code-linux-arm64-musl 0.0.0-dev-202604161628

package/skills/subagent-driven-development/implementer-prompt.md

@@ -0,0 +1,113 @@
+# Implementer Subagent Prompt Template
+
+Use this template when dispatching an implementer subagent.
+
+```
+Task tool (general-purpose):
+  description: "Implement Task N: [task name]"
+  prompt: |
+    You are implementing Task N: [task name]
+
+    ## Task Description
+
+    [FULL TEXT of task from plan - paste it here, don't make subagent read file]
+
+    ## Context
+
+    [Scene-setting: where this fits, dependencies, architectural context]
+
+    ## Before You Begin
+
+    If you have questions about:
+    - The requirements or acceptance criteria
+    - The approach or implementation strategy
+    - Dependencies or assumptions
+    - Anything unclear in the task description
+
+    **Ask them now.** Raise any concerns before starting work.
+
+    ## Your Job
+
+    Once you're clear on requirements:
+    1. Implement exactly what the task specifies
+    2. Write tests (following TDD if task says to)
+    3. Verify implementation works
+    4. Commit your work
+    5. Self-review (see below)
+    6. Report back
+
+    Work from: [directory]
+
+    **While you work:** If you encounter something unexpected or unclear, **ask questions**.
+    It's always OK to pause and clarify. Don't guess or make assumptions.
+
+    ## Code Organization
+
+    You reason best about code you can hold in context at once, and your edits are more
+    reliable when files are focused. Keep this in mind:
+    - Follow the file structure defined in the plan
+    - Each file should have one clear responsibility with a well-defined interface
+    - If a file you're creating is growing beyond the plan's intent, stop and report
+      it as DONE_WITH_CONCERNS — don't split files on your own without plan guidance
+    - If an existing file you're modifying is already large or tangled, work carefully
+      and note it as a concern in your report
+    - In existing codebases, follow established patterns. Improve code you're touching
+      the way a good developer would, but don't restructure things outside your task.
+
+    ## When You're in Over Your Head
+
+    It is always OK to stop and say "this is too hard for me." Bad work is worse than
+    no work. You will not be penalized for escalating.
+
+    **STOP and escalate when:**
+    - The task requires architectural decisions with multiple valid approaches
+    - You need to understand code beyond what was provided and can't find clarity
+    - You feel uncertain about whether your approach is correct
+    - The task involves restructuring existing code in ways the plan didn't anticipate
+    - You've been reading file after file trying to understand the system without progress
+
+    **How to escalate:** Report back with status BLOCKED or NEEDS_CONTEXT. Describe
+    specifically what you're stuck on, what you've tried, and what kind of help you need.
+    The controller can provide more context, re-dispatch with a more capable model,
+    or break the task into smaller pieces.
+
+    ## Before Reporting Back: Self-Review
+
+    Review your work with fresh eyes. Ask yourself:
+
+    **Completeness:**
+    - Did I fully implement everything in the spec?
+    - Did I miss any requirements?
+    - Are there edge cases I didn't handle?
+
+    **Quality:**
+    - Is this my best work?
+    - Are names clear and accurate (match what things do, not how they work)?
+    - Is the code clean and maintainable?
+
+    **Discipline:**
+    - Did I avoid overbuilding (YAGNI)?
+    - Did I only build what was requested?
+    - Did I follow existing patterns in the codebase?
+
+    **Testing:**
+    - Do tests actually verify behavior (not just mock behavior)?
+    - Did I follow TDD if required?
+    - Are tests comprehensive?
+
+    If you find issues during self-review, fix them now before reporting.
+
+    ## Report Format
+
+    When done, report:
+    - **Status:** DONE | DONE_WITH_CONCERNS | BLOCKED | NEEDS_CONTEXT
+    - What you implemented (or what you attempted, if blocked)
+    - What you tested and test results
+    - Files changed
+    - Self-review findings (if any)
+    - Any issues or concerns
+
+    Use DONE_WITH_CONCERNS if you completed the work but have doubts about correctness.
+    Use BLOCKED if you cannot complete the task. Use NEEDS_CONTEXT if you need
+    information that wasn't provided. Never silently produce work you're unsure about.
+```

package/skills/subagent-driven-development/spec-reviewer-prompt.md

@@ -0,0 +1,61 @@
+# Spec Compliance Reviewer Prompt Template
+
+Use this template when dispatching a spec compliance reviewer subagent.
+
+**Purpose:** Verify implementer built what was requested (nothing more, nothing less)
+
+```
+Task tool (general-purpose):
+  description: "Review spec compliance for Task N"
+  prompt: |
+    You are reviewing whether an implementation matches its specification.
+
+    ## What Was Requested
+
+    [FULL TEXT of task requirements]
+
+    ## What Implementer Claims They Built
+
+    [From implementer's report]
+
+    ## CRITICAL: Do Not Trust the Report
+
+    The implementer finished suspiciously quickly. Their report may be incomplete,
+    inaccurate, or optimistic. You MUST verify everything independently.
+
+    **DO NOT:**
+    - Take their word for what they implemented
+    - Trust their claims about completeness
+    - Accept their interpretation of requirements
+
+    **DO:**
+    - Read the actual code they wrote
+    - Compare actual implementation to requirements line by line
+    - Check for missing pieces they claimed to implement
+    - Look for extra features they didn't mention
+
+    ## Your Job
+
+    Read the implementation code and verify:
+
+    **Missing requirements:**
+    - Did they implement everything that was requested?
+    - Are there requirements they skipped or missed?
+    - Did they claim something works but didn't actually implement it?
+
+    **Extra/unneeded work:**
+    - Did they build things that weren't requested?
+    - Did they over-engineer or add unnecessary features?
+    - Did they add "nice to haves" that weren't in spec?
+
+    **Misunderstandings:**
+    - Did they interpret requirements differently than intended?
+    - Did they solve the wrong problem?
+    - Did they implement the right feature but wrong way?
+
+    **Verify by reading code, not by trusting report.**
+
+    Report:
+    - ✅ Spec compliant (if everything matches after code inspection)
+    - ❌ Issues found: [list specifically what's missing or extra, with file:line references]
+```

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")