Tiktok Workflow E2e

TikTok E2E Workflow

Single command to process products from start to finish.

Quick Start

# Process single product
/workflow 1729607303430380470

# Process batch from CSV
/workflow --batch products.csv

# Resume from specific phase
/workflow --batch products.csv --start-phase analysis

Workflow Phases

┌────────────────────────────────────────────────────────────────┐
│  PHASE 1: SCRAPING (Python)                                    │
│  Skill: tiktok_product_scraper.md                              │
│  Agent: Python script                                          │
│  Parallel: Yes (across products)                               │
│  Output: tabcut_data.json, product_images/, ref_video/*.mp4    │
└────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌────────────────────────────────────────────────────────────────┐
│  PHASE 2A: VIDEO ANALYSIS (Python Async)                       │
│  Skill: tiktok_ad_analysis.md                                  │
│  Agent: Python (3-phase pipeline: extract → transcribe → API)  │
│  Parallel: 5 products at once (5 Gemini CLI threads max)       │
│  Internal: Each product analyzes 5 videos in parallel          │
│  Output: video_N_analysis.md (5 files per product)             │
│  OPTIMIZED v4.4.0: 8 products in 4 min (was 16 min) - 4x faster│
└────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌────────────────────────────────────────────────────────────────┐
│  PHASE 2B+2C: ANALYSIS + SYNTHESIS (Gemini MCP Async)          │
│  Skill: tiktok_product_analysis.md                             │
│  Agent: Gemini CLI MCP (async)                                 │
│  Parallel: SEQUENTIAL across products (5 MCP task limit)       │
│           Within each product: Videos(5) → Image(1) ∥ Synth(1) │
│  Output: image_analysis.md + video_synthesis.md                │
│  OPTIMIZED: 2B+2C run in parallel after 2A ⭐ ~3min savings    │
└────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌────────────────────────────────────────────────────────────────┐
│  QUALITY GATE                                                  │
│  Check: video_synthesis.md exists (80+ lines minimum)          │
│  Block: Cannot proceed to Phase 3 if missing                   │
└────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌────────────────────────────────────────────────────────────────┐
│  PHASE 3: SCRIPT GENERATION (Claude)                           │
│  Skill: tiktok_script_generator.md                             │
│  Agent: Claude (direct writing from synthesis)                 │
│  Parallel: Yes - batch Write calls (3 scripts + summary/product)│
│  Output: 3 scripts + Campaign_Summary.md                       │
│  OPTIMIZED v2.3.0: 2-3 min/product (was 5-8 min) - 2x faster  │
└────────────────────────────────────────────────────────────────┘

Phase 1: Scraping

Output Folder (Dated Batches)

This vault organizes runs under product_list/YYYYMMDD/<product_id>/ (see existing folders like product_list/20260103/).

Set a date folder for the current run:

DATE=YYYYMMDD
OUT="../product_list/$DATE"
mkdir -p "$OUT"

Execute:

cd /Users/lxt/Movies/TikTok/WZ/lukas_9688/scripts
source venv/bin/activate

# Single product
python run_scraper.py --product-id {product_id} --download-videos --output-dir "$OUT"

# Batch (from products.csv)
python run_scraper.py --batch-file products.csv --download-videos --output-dir "$OUT"

Output per product:

product_list/YYYYMMDD/{product_id}/
├── tabcut_data.json       # Product metadata
├── tabcut_data.md         # Markdown version
├── product_images/        # 5-9 product images
│   └── *.webp
└── ref_video/             # Top 5 videos
    └── *.mp4

Gate: Check all products have tabcut_data.json

Phase 2: Analysis

⚠️ IMPORTANT: Video analysis now runs with cross-product parallelism (up to 5 products simultaneously via Gemini CLI background tasks).

Concurrency Model (v4.4.0 Optimized)

Video Analysis (Python async - PARALLELIZED):

• Uses gemini_cli_execute_async to launch up to 5 products in parallel
• Each product uses Python's internal pipeline:
  • asyncio with Semaphore(5) for 5 concurrent Gemini API calls
  • ThreadPoolExecutor(5) for parallel FFmpeg frame extraction
  • Cached Whisper model (loads once per product)
• Execution: Launch 5 async tasks → wait → launch next batch
• Result: 8 products analyzed in ~4 minutes (was 16 min sequential)

Image + Synthesis (Gemini MCP async):

• ⚠️ CRITICAL: 5 MCP task limit (per tiktok_product_analysis.md)
• Process products SEQUENTIALLY (one at a time)
• Within each product: Stage 1 (5 videos parallel) → Stage 2 (image) → Stage 3 (synthesis)
• Never try to parallelize multiple products for image+synthesis

Model Policy (MANDATORY)

Run analysis prompts with:

• Primary: -m gemini-3-pro-preview
• Fallback (only if capacity/quota hit): -m gemini-3-flash-preview

2A: Video Analysis (Python - PARALLEL v4.4.0)

Execute with parallelism (up to 5 products at once):

cd scripts
source venv/bin/activate

# Launch 5 products in parallel using Gemini CLI async
# Product IDs: 1729671956792187076, 1729480049905277853, 1729637085247609526, etc.

# Example: Batch 1 (5 products in parallel)
for pid in 1729671956792187076 1729480049905277853 1729637085247609526 1729697087571270361 1729630936525936882; do
  python analyze_video_batch.py $pid --date YYYYMMDD &
done
wait

# Batch 2 (remaining 3 products)
for pid in 1729607303430380470 1729607478878640746 1729489298386491816; do
  python analyze_video_batch.py $pid --date YYYYMMDD &
done
wait

What happens per product (3-phase pipeline):

📦 PHASE 1: Parallel frame extraction (ThreadPoolExecutor, 5 workers)
  → All 5 videos extract frames simultaneously (~10-15s)

🎤 PHASE 2: Sequential transcription (cached Whisper model)
  → Model loads once, transcribes all 5 videos (~30-50s)

🤖 PHASE 3: Parallel Gemini analysis (asyncio.Semaphore(5))
  → 5 async subprocess calls to gemini-cli (~60-120s)

Total per product: ~80-120s (was ~4-5 min)

Performance (v4.4.0 - PARALLELIZED):

• Single product (5 videos): 80-120 seconds
• 8 products sequentially: 16 minutes
• 8 products in 2 batches (5+3): ~4 minutes ⭐ 4x faster
• Key: Gemini CLI limit = 5 concurrent threads max

Output: ref_video/video_N_analysis.md (bilingual, per video)

2B+2C: Image Analysis + Video Synthesis (Gemini MCP Async - PARALLEL ⭐)

✅ OPTIMIZED MODEL (v1.5.0):

Uses Gemini CLI MCP async (NOT Claude). Process products SEQUENTIALLY, but 2B and 2C run in parallel after 2A completes.

Pipeline per product (2 stages: sequential 2A, then parallel 2B+2C):

┌─────────────────────────────────────────────────────────────┐
│ Stage 1: Video Analysis (5 tasks in parallel - fills limit) │
│ └─ video_1..5_analysis.md → Wait for all 5                  │
└─────────────────────────────────────────────────────────────┘
                              ↓
              ┌───────────────┴───────────────┐
              ↓                               ↓
┌──────────────────────────────┐ ┌──────────────────────────────┐
│ Stage 2: Image Analysis (1)  │ │ Stage 3: Synthesis (1)       │
│ └─ image_analysis.md         │ │ └─ video_synthesis.md        │
└──────────────────────────────┘ └──────────────────────────────┘
              ↓                               ↓
              └───────────────┬───────────────┘
                              ↓ wait for both
Then proceed to next product...

Key Optimization: Image analysis and synthesis have no dependency on each other:

• Image reads: product_images/*.webp
• Synthesis reads: ref_video/video_*_analysis.md (from Stage 1)
• Can safely run in parallel using only 2 of 5 available MCP slots

Execution:

# Process products sequentially with optimized pipeline
for product_id in $products; do
  # Stage 1: Launch 5 video analyses (parallel, fills 5 MCP slots)
  python analyze_video_batch.py $product_id --date YYYYMMDD &
  wait  # Wait for video analysis to complete
  
  # Stage 2+3: Launch image + synthesis in parallel (uses 2 slots)
  python analyze_product_images.py $product_id --date YYYYMMDD &
  python create_video_synthesis.py $product_id --date YYYYMMDD &
  wait  # Wait for both to complete
done

Performance (8 products):

• Per product: Videos (2min) + max(Image 3min, Synthesis 3min) = ~5 min
• 8 products sequential: ~40 min
• Old model: Videos (2min) + Image (3min) + Synthesis (3min) = ~8 min → ~64 min total
• Savings: 24 minutes for 8 products ⭐ **3 min per product**

Output per product:

• product_images/image_analysis.md
• ref_video/video_synthesis.md (CRITICAL)

Quality Gate - ENHANCED

Before Phase 3, verify analysis quality and compliance:

Option 1: Enhanced Quality Gate (Recommended)

Use the updated verify_gate.sh script with integrated quality validators:

# Comprehensive gate: file existence + bilingual coverage + compliance + ElevenLabs cues
bash scripts/verify_gate.sh --date YYYYMMDD --csv scripts/products.csv --phase all

The enhanced gate now validates:

• Phase 1: File Existence (existing checks)

  • tabcut_data.json/md presence
  • image_analysis.md (200+ lines, no meta preamble)
  • video_synthesis.md (150+ lines, no meta preamble)
  • Video analysis files count
  • Script files count (4+)

• Phase 2: Quality Standards (NEW)

  • Bilingual Coverage: DE/ZH pairs (30+), bilingual headers (10+), Chinese ratio (8-25%)
  • Compliance Flags: Risky claims properly flagged in analysis, absent from scripts
  • ElevenLabs Cues: Density (≥0.3), variety (≥8 unique), valid cues only

Option 2: Manual Verification (Basic)

If you need a quick check without quality validators:

#!/bin/bash
# verify_ready_for_scripts.sh

date="YYYYMMDD"
products="1729607303430380470 1729607478878640746 ..."  # Your product IDs

for pid in $products; do
  echo "=== $pid ==="

  # MANDATORY: Synthesis must exist
  if [ ! -f "product_list/$date/$pid/ref_video/video_synthesis.md" ]; then
    echo "❌ BLOCKED: video_synthesis.md missing"
    exit 1
  fi

  lines=$(wc -l < "product_list/$date/$pid/ref_video/video_synthesis.md" | tr -d ' ')
  if [ "$lines" -lt 150 ]; then
    echo "❌ BLOCKED: synthesis only $lines lines (need 150+)"
    exit 1
  fi

  # NEW: Quality validators (optional but recommended)
  echo "Checking quality standards..."
  python3 scripts/validate_bilingual_coverage.py "product_list/$date/$pid/ref_video/video_synthesis.md" || echo "⚠️ Bilingual coverage below standards"
  python3 scripts/validate_compliance_flags.py "product_list/$date/$pid/ref_video/video_synthesis.md" || echo "⚠️ Compliance issues found"

  echo "✅ Ready for scripts"
done

echo ""
echo "=== ALL PRODUCTS READY FOR PHASE 3 ==="

Individual Validator Usage

Run validators individually for debugging:

# Bilingual coverage
python3 scripts/validate_bilingual_coverage.py product_list/YYYYMMDD/{product_id}/ref_video/video_synthesis.md

# Compliance flags
python3 scripts/validate_compliance_flags.py product_list/YYYYMMDD/{product_id}/ref_video/video_synthesis.md

# ElevenLabs cues (for scripts)
python3 scripts/validate_elevenlabs_cues.py product_list/YYYYMMDD/{product_id}/scripts/Script_Name.md

Phase 3: Script Generation (BATCHED v2.3.0)

⚠️ CRITICAL FORMAT REQUIREMENT - ElevenLabs v3 Inline Cues:

• MANDATORY: Emotion cues MUST be inline: [emotion] Text here.
• FORBIDDEN: Broken lines format with cue on separate line from text
• WRONG: [frustrated] followed by Du kennst das? on next line ❌
• CORRECT: [frustrated] Du kennst das? on same line ✅
• See tiktok_script_generator.md lines 285-311 for full format specification

Execute (Claude Code with batch Write calls):

For each product, Claude reads analysis files and writes ALL 4 FILES IN ONE MESSAGE:

1. Script_1_[Angle].md - Hook/Challenge angle
2. Script_2_[Angle].md - Feature Demo angle
3. Script_3_[Angle].md - Social Proof angle
4. Campaign_Summary.md - Executive summary

CRITICAL OPTIMIZATION: Use 4 parallel Write tool calls in a single message:

[Read synthesis, image analysis, tabcut data]
[Generate all 3 scripts + Campaign Summary]
[Call Write tool 4 times in parallel in single message]

Performance:

• Old (sequential): 5-8 min per product (read → write → read → write → ...)
• New (batched): 2-3 min per product (read all → write all) ⭐ 2x faster
• 8 products: 16-24 min (was 40-50 min)

Output location: product_list/YYYYMMDD/{product_id}/scripts/

Key rules:

• Claude writes ALL scripts (not Gemini)
• Read ALL analysis files in parallel (5+ Read calls at once)
• Write ALL 4 files in parallel (4 Write calls in one message)
• Campaign Summary references files (no duplication)

Retry / Stop Rules

• If the gate fails (missing files or below line thresholds), retry the failed stage once with the strict output contract prompts.
• If it fails again, mark that product as BLOCKED and continue to the next product (do not generate scripts with incomplete analysis).

Autonomous Batch Execution

To run the full workflow autonomously:

User prompt to Claude:

"Run the e2e workflow for these products autonomously:
- products.csv contains 8 product IDs
- Don't pause for approval between phases
- If something fails, retry once then skip and continue
- Report failures at the end"

Claude will:

1. Run Phase 1 (scraping) - wait for completion
2. Run Phase 2A (video analysis) - parallel via Python (bash bg, 5 products max)
3. Run Phase 2B+2C (image + synthesis) - SEQUENTIAL via Gemini MCP (per tiktok_product_analysis.md)
4. Verify quality gate
5. Run Phase 3 (scripts) - sequential with batched writes
6. Report completion status

Time Estimates

Updated for v4.4.0 parallel video analysis + v2.3.0 batched scripts

Performance Notes

Phase 2A Video Analysis (8 products) - PARALLELIZED:

• Old (v4.3.0 sequential): 8 × 2 min = 16 min
• New (v4.4.0 parallel): Batch1(5): 2min + Batch2(3): 2min = 4 min
• Savings: ~12 minutes ⭐ 4x faster

Phase 2B+2C Image+Synthesis (8 products) - PARALLEL WITHIN PRODUCT ⭐:

• Optimized v1.5.0: Image and Synthesis run in parallel after videos complete
• Why it works: No dependency between image analysis and synthesis
• Time: 8 × max(3min, 3min) = ~24 min (was ~32 min sequential)
• Savings: 8 minutes for 8 products (1 min per product)

Phase 3 Scripts (8 products) - BATCHED:

• Old (sequential writes): 8 × 5 min = 40 min
• New (batched writes): 8 × 2.5 min = 20 min
• Savings: ~20 minutes ⭐ 2x faster

Total Workflow (Optimized v1.5.0):

• Phase 1: 5 min
• Phase 2A: 4 min (parallel video analysis)
• Phase 2B+2C: 24 min (parallel image + synthesis per product) ⭐
• Phase 3: 20 min (batched script writes)
• Total: ~53 min for 8 products (was ~61 min)

Pipeline Strategy (8 Products - PARALLELIZED)

Phase 2A: Video Analysis (Parallel batches of 5):

┌─────────────────────────────────────────────────────────────┐
│ BATCH 1 (5 products in parallel) - 2 minutes               │
├─────────────────────────────────────────────────────────────┤
│ Product 1: [Videos: 5 parallel Gemini calls] → 2 min       │
│ Product 2: [Videos: 5 parallel Gemini calls] → 2 min       │
│ Product 3: [Videos: 5 parallel Gemini calls] → 2 min       │ All running
│ Product 4: [Videos: 5 parallel Gemini calls] → 2 min       │ simultaneously
│ Product 5: [Videos: 5 parallel Gemini calls] → 2 min       │ (max 5 threads)
└─────────────────────────────────────────────────────────────┘
                              ↓ wait for completion
┌─────────────────────────────────────────────────────────────┐
│ BATCH 2 (3 products in parallel) - 2 minutes               │
├─────────────────────────────────────────────────────────────┤
│ Product 6: [Videos: 5 parallel Gemini calls] → 2 min       │
│ Product 7: [Videos: 5 parallel Gemini calls] → 2 min       │ Running
│ Product 8: [Videos: 5 parallel Gemini calls] → 2 min       │ simultaneously
└─────────────────────────────────────────────────────────────┘

Total: ~4 min (was 16 min sequential) ⭐ 4x faster

Phase 2B+2C: Image + Synthesis (PARALLEL WITHIN PRODUCT ⭐ v1.5.0):

✅ OPTIMIZED: 2B and 2C run in parallel after 2A completes

Product 1: [Videos: 5 parallel] → [Image ∥ Synthesis] → ~5 min
Product 2: [Videos: 5 parallel] → [Image ∥ Synthesis] → ~5 min
Product 3: [Videos: 5 parallel] → [Image ∥ Synthesis] → ~5 min
...
Product 8: [Videos: 5 parallel] → [Image ∥ Synthesis] → ~5 min

Total: ~40 min (was ~64 min sequential 2B→2C) ⭐ ~3 min savings per product

Why parallel 2B+2C works:

• Image analysis reads: product_images/*.webp
• Synthesis reads: ref_video/video_*_analysis.md (from 2A)
• No dependency between them → safe to run concurrently
• Uses only 2 of 5 available MCP slots (well within limits)

Phase 3: Scripts (Batched Write calls per product):

Product 1: [Read all files parallel] → [Write 4 files parallel] → 2.5 min
Product 2: [Read all files parallel] → [Write 4 files parallel] → 2.5 min
...
Product 8: [Read all files parallel] → [Write 4 files parallel] → 2.5 min
Total: ~20 min (was 40 min) ⭐ 2x faster

Error Handling

Resume Points

If workflow interrupted:

# Check current state
./check_workflow_status.sh products.csv

# Resume from Phase 2
/workflow --batch products.csv --start-phase analysis

# Resume from Phase 3 only
/workflow --batch products.csv --start-phase scripts

Skill Dependency Map

tiktok_product_scraper.md (v2.0.0)
│  Agent: Python script
│  Output: tabcut_data.json, product_images/, ref_video/*.mp4
│
├──────────────────────────────────────────────────┐
│                                                  │
▼                                                  ▼
tiktok_ad_analysis.md (v4.4.0)        tiktok_product_analysis.md (v1.0.0)
│  Agent: Python + Gemini CLI          │  Agent: Gemini MCP async
│  Parallel: 5 products via bash bg    │  Sequential: 1 product at a time
│  Output: video_N_analysis.md         │  Output: image_analysis.md
│                                      │
└──────────────┬───────────────────────┘
               │
               ▼
    tiktok_product_analysis.md (v1.0.0)
    │  Agent: Gemini MCP async
    │  Output: video_synthesis.md (CRITICAL)
    │
    ▼
    tiktok_script_generator.md (v2.3.0)
    │  Agent: Claude Code
    │  Batched: 4 Write calls per product
    │  Output: Script_1/2/3.md + Campaign_Summary.md

Agent Assignment Summary:

Example: Full Batch Run

User: Run e2e workflow for products.csv autonomously

Claude:
1. Starting Phase 1: Scraping 8 products...
   ✅ 8/8 products scraped (5 min)

2. Starting Phase 2: Analysis (PARALLELIZED v4.4.0)...

   === Phase 2A: Video Analysis (Batch 1 - 5 products in parallel) ===
   🚀 Launching 5 parallel video analysis tasks...
   - Product 1: [Videos: 5 parallel Gemini calls]
   - Product 2: [Videos: 5 parallel Gemini calls]
   - Product 3: [Videos: 5 parallel Gemini calls]
   - Product 4: [Videos: 5 parallel Gemini calls]
   - Product 5: [Videos: 5 parallel Gemini calls]
   ⏳ Waiting for batch completion...
   ✅ Batch 1 complete (2 min)

   === Phase 2A: Video Analysis (Batch 2 - 3 products in parallel) ===
   🚀 Launching 3 parallel video analysis tasks...
   - Product 6: [Videos: 5 parallel Gemini calls]
   - Product 7: [Videos: 5 parallel Gemini calls]
   - Product 8: [Videos: 5 parallel Gemini calls]
   ⏳ Waiting for batch completion...
   ✅ Batch 2 complete (2 min)

   ✅ All 8 products - videos analyzed (4 min total, was 16 min) ⭐ 4x faster

   === Phase 2B+2C: Image Analysis + Synthesis (PARALLEL 2B∥2C - v1.5.0) ===
   📦 Product 1: [Videos 5∥] → [Image ∥ Synthesis] ✅ (5 min)
   📦 Product 2: [Videos 5∥] → [Image ∥ Synthesis] ✅ (5 min)
   📦 Product 3: [Videos 5∥] → [Image ∥ Synthesis] ✅ (5 min)
   📦 Product 4: [Videos 5∥] → [Image ∥ Synthesis] ✅ (5 min)
   📦 Product 5: [Videos 5∥] → [Image ∥ Synthesis] ✅ (5 min)
   📦 Product 6: [Videos 5∥] → [Image ∥ Synthesis] ✅ (5 min)
   📦 Product 7: [Videos 5∥] → [Image ∥ Synthesis] ✅ (5 min)
   📦 Product 8: [Videos 5∥] → [Image ∥ Synthesis] ✅ (5 min)
   ✅ All 8 products analyzed (40 min total - 2B+2C parallel per product) ⭐

3. Quality Gate...
   ✅ 8/8 products have valid synthesis files

4. Starting Phase 3: Script Generation (BATCHED v2.3.0)...
   - Product 1/8: [Read all] → [Write 4 files in parallel] ✅ (2.5 min)
   - Product 2/8: [Read all] → [Write 4 files in parallel] ✅ (2 min)
   - Product 3/8: [Read all] → [Write 4 files in parallel] ✅ (2.5 min)
   - Product 4/8: [Read all] → [Write 4 files in parallel] ✅ (3 min)
   - Product 5/8: [Read all] → [Write 4 files in parallel] ✅ (2 min)
   - Product 6/8: [Read all] → [Write 4 files in parallel] ✅ (2.5 min)
   - Product 7/8: [Read all] → [Write 4 files in parallel] ✅ (3 min)
   - Product 8/8: [Read all] → [Write 4 files in parallel] ✅ (2.5 min)
   ✅ All scripts generated (20 min, was 40 min) ⭐ 2x faster

=== WORKFLOW COMPLETE ===
Total time: ~61 minutes (corrected model per tiktok_product_analysis.md)
Products processed: 8/8
Scripts generated: 24 (3 per product)
Campaign summaries: 8

Performance Breakdown:
- Phase 1 (Scraping): 5 min
- Phase 2A (Videos): 4 min ⭐ (was 16 min - 4x faster via bash parallel batches)
- Phase 2B+2C (Image+Synthesis): 24 min ⭐ (was 32 min - parallel 2B∥2C optimization)
- Phase 3 (Scripts): 20 min ⭐ (was 40 min - 2x faster via batched writes)

Ready for video production!

Version: 1.5.0 Last Updated: 2026-01-21 Changelog:

• v1.5.0 (2026-01-21): OPTIMIZED PHASE 2B+2C PARALLEL EXECUTION ⭐
  • NEW: Image analysis and synthesis run in parallel after video analysis
  • Why: No dependency between 2B (images) and 2C (synthesis from videos)
  • Execution: python analyze_product_images.py $pid & python create_video_synthesis.py $pid & wait
  • Performance: ~3 min savings per product (5 min vs 8 min)
  • 8 products: ~53 min (was ~61 min) - saves ~8 minutes total
  • Updated all workflow diagrams, time tables, and execution examples
  • MCP slot usage: Only 2 of 5 slots for 2B+2C (safe and efficient)
• v1.4.0 (2026-01-20): ALIGNED WITH UNDERLYING SKILLS
  • CORRECTED: Phase 2B+2C uses Gemini MCP async (NOT Claude)
  • Aligned with tiktok_product_analysis.md v1.0.0 concurrency constraints
  • Phase 2A (videos): Parallel via bash bg
  • Updated pipeline diagrams to show correct execution model
• v1.3.0 (2026-01-18): Parallel video analysis + batched scripts
  • Parallel video analysis across products (5 Gemini CLI threads max)
  • Batched script generation (4 Write calls per product in one message)
  • Phase 2A: 4 min (was 16 min) via parallel batches of 5 products
  • Phase 3: 20 min (was 40 min) via batched Write tool calls
• v1.2.0 (2026-01-07): Parallel image+synthesis execution (NOTE: was incorrect)
• v1.1.0 (2026-01-07): Updated for v4.3.0 video analysis optimizations
  • 3-5x faster video analysis (Python async + ThreadPoolExecutor)
  • Clarified that video analysis uses Python async, not MCP slots
• v1.0.0 (2026-01-01): Initial e2e workflow documentation