@kolbo/kolbo-code-linux-arm64-musl 2.0.0 → 2.0.2

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

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

@@ -0,0 +1,127 @@
+"""
+Export SRT subtitle files for each video and each individual chapter.
+- Full video SRT: placed next to the edited MP4
+- Per-chapter SRTs: placed in each chapter's subfolder, timestamps zeroed to chapter start
+"""
+import json, os
+
+def fmt_srt_time(seconds):
+    """Format seconds as SRT timestamp: HH:MM:SS,mmm"""
+    h = int(seconds // 3600)
+    m = int((seconds % 3600) // 60)
+    s = seconds % 60
+    return f"{h:02d}:{m:02d}:{s:06.3f}".replace('.', ',')
+
+
+def sentences_to_srt(sentences, offset=0.0):
+    """Convert sentence list to SRT text, subtracting offset from all timestamps."""
+    blocks = []
+    for i, s in enumerate(sentences, 1):
+        start = max(0.0, s['start'] - offset)
+        end = max(0.0, s['end'] - offset)
+        blocks.append(f"{i}\n{fmt_srt_time(start)} --> {fmt_srt_time(end)}\n{s['text']}\n")
+    return '\n'.join(blocks)
+
+
+def get_sentences_in_range(sentences, start_time, end_time):
+    """Get all sentences that overlap with the given time range."""
+    result = []
+    for s in sentences:
+        # Include sentence if it overlaps with the range
+        if s['end'] > start_time and s['start'] < end_time:
+            result.append(s)
+    return result
+
+
+JOBS = [
+    {
+        "name": "lior_course_01",
+        "transcript": r"G:\Projects\Master Agent\ytp_jobs\lior_course_01\transcript.json",
+        "chapters_json": r"G:\Projects\Master Agent\ytp_jobs\lior_course_01\chapters.json",
+        "full_srt_path": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\1 - היכרות עם Kolbo.AI - edited.srt",
+        "chapters_dir": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\1 - היכרות עם Kolbo.AI",
+        "video_duration": 540.2,
+    },
+    {
+        "name": "lior_course_02",
+        "transcript": r"G:\Projects\Master Agent\ytp_jobs\lior_course_02\transcript.json",
+        "chapters_json": r"G:\Projects\Master Agent\ytp_jobs\lior_course_02\chapters.json",
+        "full_srt_path": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\2 - הסבר על פרוייקטים - edited.srt",
+        "chapters_dir": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\2 - הסבר על פרוייקטים",
+        "video_duration": 1643.0,
+    },
+    {
+        "name": "lior_course_03",
+        "transcript": r"G:\Projects\Master Agent\ytp_jobs\lior_course_03\transcript.json",
+        "chapters_json": r"G:\Projects\Master Agent\ytp_jobs\lior_course_03\chapters.json",
+        "full_srt_path": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\3 - כלי הצאט - edited.srt",
+        "chapters_dir": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\3 - כלי הצאט",
+        "video_duration": 2789.4,
+    },
+]
+
+for job in JOBS:
+    print(f"\n{'='*60}")
+    print(f"SRT export: {job['name']}")
+    print('='*60)
+
+    with open(job['transcript'], encoding='utf-8') as f:
+        transcript = json.load(f)
+    sentences = transcript['sentences']
+
+    with open(job['chapters_json'], encoding='utf-8') as f:
+        chapters = json.load(f)
+
+    # Compute end times
+    for i, ch in enumerate(chapters):
+        ch['end_time'] = chapters[i + 1]['start_time'] if i + 1 < len(chapters) else job['video_duration']
+
+    # ── Full video SRT ────────────────────────────────────────────────────
+    # Note: the burned video has 4s divider cards inserted before each chapter.
+    # We need to offset all timestamps to account for the accumulated divider time.
+    full_blocks = []
+    block_num = 1
+    accumulated_divider_time = 0.0
+    DIVIDER_DURATION = 4.0
+
+    for ch in chapters:
+        ch_start = ch['start_time']
+        ch_end = ch['end_time']
+        ch_sentences = get_sentences_in_range(sentences, ch_start, ch_end)
+
+        # Each chapter is preceded by a 4s divider
+        accumulated_divider_time += DIVIDER_DURATION
+
+        for s in ch_sentences:
+            start = s['start'] + accumulated_divider_time
+            end = s['end'] + accumulated_divider_time
+            full_blocks.append(
+                f"{block_num}\n{fmt_srt_time(start)} --> {fmt_srt_time(end)}\n{s['text']}\n"
+            )
+            block_num += 1
+
+    with open(job['full_srt_path'], 'w', encoding='utf-8') as f:
+        f.write('\n'.join(full_blocks))
+    print(f"  Full SRT: {block_num - 1} blocks")
+
+    # ── Per-chapter SRTs ──────────────────────────────────────────────────
+    for ch in chapters:
+        n = ch['chapter_number']
+        title = ch['title']
+        safe_title = title.replace('/', '-').replace('\\', '-').replace(':', '-').replace('"', '').replace('?', '').replace('*', '').replace('<', '').replace('>', '').replace('|', '')
+
+        ch_start = ch['start_time']
+        ch_end = ch['end_time']
+        ch_sentences = get_sentences_in_range(sentences, ch_start, ch_end)
+
+        # Offset = chapter start time (zero the timestamps to chapter-local time)
+        # Add 4s for the divider card at the beginning of each chapter clip
+        srt_text = sentences_to_srt(ch_sentences, offset=ch_start - DIVIDER_DURATION)
+
+        srt_path = os.path.join(job['chapters_dir'], f"{n:02d} - {safe_title}.srt")
+        with open(srt_path, 'w', encoding='utf-8') as f:
+            f.write(srt_text)
+
+        print(f"  Ch {n:02d}: {len(ch_sentences)} blocks")
+
+print("\nAll SRTs exported!")

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

@@ -0,0 +1,42 @@
+"""Generate SRT from transcript.json and analyze chapters via Claude."""
+import json, os, sys
+
+# ── SRT generation ────────────────────────────────────────────────────────
+
+with open('ytp_jobs/sapir_test/transcript.json', encoding='utf-8') as f:
+    data = json.load(f)
+
+words = data['words']
+
+def fmt_time(s):
+    h = int(s // 3600)
+    m = int((s % 3600) // 60)
+    sec = s % 60
+    return f'{h:02d}:{m:02d}:{sec:06.3f}'.replace('.', ',')
+
+lines, current, cur_start = [], [], None
+for i, w in enumerate(words):
+    if not current:
+        cur_start = w['start']
+    current.append(w['text'])
+    gap = words[i + 1]['start'] - w['end'] if i + 1 < len(words) else 999
+    if len(current) >= 8 or gap > 1.5:
+        lines.append({'start': cur_start, 'end': w['end'], 'text': ' '.join(current)})
+        current, cur_start = [], None
+
+if current:
+    lines.append({'start': cur_start, 'end': words[-1]['end'], 'text': ' '.join(current)})
+
+srt_blocks = []
+for i, l in enumerate(lines, 1):
+    srt_blocks.append(f"{i}\n{fmt_time(l['start'])} --> {fmt_time(l['end'])}\n{l['text']}\n")
+
+srt_text = '\n'.join(srt_blocks)
+
+with open('ytp_jobs/sapir_test/sapir.srt', 'w', encoding='utf-8') as f:
+    f.write(srt_text)
+
+print(f"[srt] Written {len(lines)} subtitle blocks -> ytp_jobs/sapir_test/sapir.srt")
+print(f"[srt] First 3 blocks:")
+for l in lines[:3]:
+    print(f"  [{fmt_time(l['start'])} --> {fmt_time(l['end'])}] {l['text'][:70]}")