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:

Script_1_[Angle].md - Hook/Challenge angle
Script_2_[Angle].md - Feature Demo angle
Script_3_[Angle].md - Social Proof angle
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:

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

Time Estimates

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

| Phase | Single Product | 8 Products | Scaling Notes | |:------|:---------------|:-----------|:--------------| | 1. Scraping | 2-3 min | 5 min | Parallel across products | | 2A. Video Analysis | 1.5-2 min | 4 min | v4.4.0: 5 products parallel (bash bg) ⭐ | | 2B+2C. Image+Synthesis | ~3 min | ~24 min | PARALLEL 2B∥2C (v1.5.0 optimized) ⭐ | | - Image (Gemini MCP) | 3 min | - | Parallel with Synthesis ∥ | | - Synthesis (Gemini MCP) | 3 min | - | Parallel with Image ∥ | | 3. Scripts | 2-3 min | 16-24 min | Batched Write calls ⭐ | | Total | ~8-10 min | ~49-57 min | Optimized model |

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

| Error | Action | |:------|:-------| | Scraping fails | Retry once, then skip product | | No videos downloaded | Skip video analysis, continue with images | | Video analysis fails | Retry with single video, mark incomplete | | Image analysis fails | Continue without (not mandatory) | | Synthesis fails | BLOCK - retry until success or manual intervention | | Script generation fails | Retry, check for generic placeholders |

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: | Phase | Agent | Why | |:------|:------|:----| | 1. Scraping | Python | Playwright automation | | 2A. Video Analysis | Python + Gemini CLI | Bash background parallelism | | 2B. Image Analysis | Gemini MCP async | Sequential, 5 task limit | | 2C. Synthesis | Gemini MCP async | Sequential, 5 task limit | | 3. Scripts | Claude Code | Better creative quality |

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