# YouTube 롱폼 자동화 파이프라인 설계 문서

> 작성일: 2026-03-26  
> 목적: 콘텐츠 유형·언어·카테고리에 무관한 범용 롱폼 YouTube 자동화 파이프라인 설계

---

## 1. 파이프라인 단계 수 결정: 비교 분석

### 1.1 레퍼런스 시스템 비교

| 항목 | rushindrasinha (Shorts) | darkzOGx (자동화 에이전트) | autoworker-youtube-test (레퍼런스) |
|------|------------------------|--------------------------|-----------------------------------|
| 단계/에이전트 수 | 3단계 (Draft→Produce→Upload) | 5에이전트 | 8단계 |
| 대상 포맷 | YouTube Shorts | 범용 (Shorts/Longform 불명확) | Longform (추정) |
| 내부 모듈 수 | ~10개 모듈 | 5개 에이전트 | 8단계 |
| 병렬 처리 | 미지원 | 미지원 | 미지원 (순차) |
| 인간 개입 지점 | 없음 (완전 자동) | 없음 | 없음 |
| 품질 게이트 | anti-hallucination gate | 없음 | script-reviewer QA |

### 1.2 단계 수별 장단점

**3단계 (Shorts 방식)**
- ✅ 단순, 운영 오버헤드 적음
- ❌ 롱폼의 복잡한 씬 구조를 처리하기 어려움
- ❌ 병렬화 불가, 오류 지점 특정 어려움
- ❌ 재실행 시 전체 단계를 다시 돌려야 함

**5단계 (에이전트 분리 방식)**  
- ✅ 에이전트 역할 분리 명확
- ❌ 시각/음성 프로덕션 단계 부재 (핵심 누락)
- ❌ 병렬 처리 고려 없음

**8단계 (레퍼런스 방식)**
- ✅ 각 단계 책임 명확, 재시작 용이
- ✅ 중간 산출물 검토 가능
- ⚠️ 일부 단계 병합 가능 (음성+자막, 이미지+비디오)
- ❌ 병렬 처리 없어 시간 낭비 (이미지 생성 4-8분이 병목)

### 1.3 결론: 롱폼 최적 단계 수 = **6단계**

8단계에서 논리적으로 묶을 수 있는 단계를 병합 + 병렬화 구조 추가:

```
8단계 → 6단계 변환:
- 벤치마킹 + 대본 → Stage 1 (Research & Script) 
  단, 대본은 독립 Stage 2로 분리 유지 (QA 게이트 위치)
- 음성 + 자막 → Stage 3-A (병렬 묶음의 한 트랙)
- 스토리보드 + 이미지+비디오 → Stage 3-B (병렬 묶음의 한 트랙)
- 편집 → Stage 4 (Assembly)
- 썸네일 → Stage 5 (Packaging, 메타데이터와 함께)
- 업로드 → Stage 6 (Publish)
```

**최종: 6단계 구조 (Stage 3은 2-트랙 병렬)**

---

## 2. 최적 파이프라인: 6단계 범용 구조

```
┌─────────────────────────────────────────────────────────────────┐
│                     ORCHESTRATOR (Claude Code)                   │
│                         workflow.json 기반                        │
└─────────────────────────────────────────────────────────────────┘
         │
         ▼
┌──────────────────┐    ┌──────────────────┐
│  Stage 1         │    │  Stage 2         │
│  RESEARCH        │───▶│  SCRIPT          │
│  리서치 & 전략    │    │  대본 & QA        │
│  [strategist]    │    │  [writer + QA]   │
└──────────────────┘    └────────┬─────────┘
                                 │
                    ┌────────────┤ 🔴 인간 개입 지점 (선택)
                    │            │
                    ▼            ▼
         ┌──────────────┐  ┌──────────────┐
         │  Stage 3-A   │  │  Stage 3-B   │  ← 병렬 실행
         │  AUDIO       │  │  VISUAL      │
         │  TTS + 자막   │  │  스토리보드   │
         │  [audio-pd]  │  │  + 이미지/영상│
         └──────┬───────┘  │  [visual-pd] │
                │           └──────┬───────┘
                └─────────┬────────┘
                          ▼
                ┌──────────────────┐
                │  Stage 4         │
                │  ASSEMBLY        │
                │  편집 & 합성      │
                │  [assembler]     │
                └────────┬─────────┘
                         ▼
                ┌──────────────────┐
                │  Stage 5         │
                │  PACKAGING       │
                │  썸네일 + 메타    │
                │  [packager]      │
                └────────┬─────────┘
                         ▼
                ┌──────────────────┐
                │  Stage 6         │
                │  PUBLISH         │
                │  업로드 & 스케줄  │
                │  [publisher]     │
                └──────────────────┘
```

### 2.1 각 Stage 상세 정의

#### Stage 1: RESEARCH (리서치 & 전략)

| 항목 | 내용 |
|------|------|
| **담당 에이전트** | strategist |
| **입력** | `settings.json` (채널 설정) + `topic` (주제 또는 키워드) |
| **처리** | 경쟁 영상 분석, 키워드 리서치, 콘셉트 확정, SEO 전략 수립 |
| **출력** | `concept.md` (주제, 각도, 타겟, 키워드, 경쟁 분석) |
| **자동화 가능** | ✅ 완전 자동 |
| **병렬 처리** | ❌ (Stage 2의 입력 의존) |
| **소요 시간** | ~2분 |

```
입력 → [web search + YouTube API] → 트렌드 분석
                                   → 경쟁 영상 3-5개 분석
                                   → concept.md 생성
```

#### Stage 2: SCRIPT (대본 & QA)

| 항목 | 내용 |
|------|------|
| **담당 에이전트** | writer + script-reviewer |
| **입력** | `concept.md` |
| **처리** | 아웃라인 생성 → 대본 작성 → QA 검토 → 스토리보드 힌트 삽입 |
| **출력** | `outline.md`, `script.txt` (씬 마커 포함), `storyboard_hints.json` |
| **자동화 가능** | ✅ 자동 (QA는 자동화된 reviewer 에이전트) |
| **병렬 처리** | ❌ (순차: outline → script → QA) |
| **소요 시간** | ~5분 |
| **🔴 인간 개입** | **선택적 게이트**: `settings.json`에서 `human_review: true`이면 대본 승인 후 Stage 3 진행 |

```
concept.md → [writer] → outline.md
outline.md → [writer] → script.txt (씬 분리된 대본)
script.txt → [reviewer] → QA 리포트 → 통과/재작성 판정
           → storyboard_hints.json (각 씬의 시각적 힌트)
```

**script.txt 씬 마커 포맷:**
```
[SCENE:intro duration:30s visual:establishing_shot emotion:energetic]
안녕하세요, 오늘은...

[SCENE:main_1 duration:120s visual:diagram emotion:informative]
첫 번째 핵심은...

[SCENE:outro duration:20s visual:cta_screen emotion:warm]
구독과 좋아요...
```

#### Stage 3-A: AUDIO (TTS + 자막) — 병렬 트랙 A

| 항목 | 내용 |
|------|------|
| **담당 에이전트** | audio-pd |
| **입력** | `script.txt` + `settings.json` (voice_id, tts_provider) |
| **처리** | 씬별 TTS 생성 → Whisper 자막 추출 → SRT/ASS 생성 |
| **출력** | `audio/scene_XX.mp3`, `captions/scene_XX.srt`, `captions/full.srt` |
| **자동화 가능** | ✅ 완전 자동 |
| **병렬 처리** | ✅ Stage 3-B와 동시 실행 가능 |
| **소요 시간** | ~3-8분 (대본 길이에 따라) |

#### Stage 3-B: VISUAL (스토리보드 + 이미지/비디오) — 병렬 트랙 B

| 항목 | 내용 |
|------|------|
| **담당 에이전트** | visual-pd |
| **입력** | `storyboard_hints.json` + `settings.json` (image_provider, style) |
| **처리** | 스토리보드 확정 → 씬별 이미지 생성 → Ken Burns 비디오 변환 |
| **출력** | `storyboard.json`, `images/scene_XX.png`, `clips/scene_XX.mp4` |
| **자동화 가능** | ✅ 완전 자동 |
| **병렬 처리** | ✅ Stage 3-A와 동시 실행, 내부 이미지 생성도 병렬화 가능 |
| **소요 시간** | ~5-15분 (씬 수, 이미지 API 속도에 따라) |

**Ken Burns 효과 (ffmpeg):**
```bash
ffmpeg -loop 1 -i scene_01.png \
  -vf "zoompan=z='zoom+0.0015':x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':d=150:s=1920x1080" \
  -t 5 -r 30 clips/scene_01.mp4
```

#### Stage 4: ASSEMBLY (편집 & 합성)

| 항목 | 내용 |
|------|------|
| **담당 에이전트** | assembler |
| **입력** | `audio/`, `clips/`, `captions/full.srt`, `settings.json` (music, transitions) |
| **처리** | 클립+오디오 싱크 → 자막 번인 → BGM 믹싱 → 최종 렌더링 |
| **출력** | `output/video_draft.mp4` |
| **자동화 가능** | ✅ 완전 자동 |
| **병렬 처리** | ❌ (Stage 3 완료 후 시작) |
| **소요 시간** | ~5-15분 (렌더링 시간) |

```bash
# ffmpeg 조립 예시
ffmpeg \
  -i clips/concat_list.txt \       # 비디오 클립 목록
  -i audio/full_voiceover.mp3 \    # TTS 오디오
  -i music/bgm.mp3 \               # BGM
  -filter_complex "[2:a]volume=0.15[bgm];[1:a][bgm]amix=inputs=2[audio]" \
  -vf "subtitles=captions/full.srt:force_style='FontSize=24'" \
  -map 0:v -map "[audio]" \
  -c:v libx264 -c:a aac \
  output/video_draft.mp4
```

#### Stage 5: PACKAGING (썸네일 + 메타데이터)

| 항목 | 내용 |
|------|------|
| **담당 에이전트** | packager |
| **입력** | `concept.md`, `script.txt`, `output/video_draft.mp4` |
| **처리** | 썸네일 생성 (이미지 + 텍스트 오버레이) → 제목/설명/태그 생성 → youtube.md 생성 |
| **출력** | `output/thumbnail.png`, `output/youtube.md` |
| **자동화 가능** | ✅ 완전 자동 |
| **소요 시간** | ~2-3분 |

**youtube.md 포맷:**
```markdown
# YouTube Metadata

title: "제목 (60자 이하)"
description: |
  영상 설명 (첫 2줄이 핵심)
  
  [챕터 마커]
  00:00 인트로
  00:30 본론 시작
  
  #태그1 #태그2
tags: [태그1, 태그2, 태그3]
category_id: 22
playlist_id: PLxxxxxxxx
scheduled_at: "2026-03-27T09:00:00+09:00"
```

#### Stage 6: PUBLISH (업로드 & 스케줄)

| 항목 | 내용 |
|------|------|
| **담당 에이전트** | publisher |
| **입력** | `output/video_draft.mp4`, `output/thumbnail.png`, `output/youtube.md` |
| **처리** | YouTube Data API v3 업로드 → 썸네일 설정 → 재생목록 추가 → 스케줄 설정 |
| **출력** | `output/publish_result.json` (video_id, url, scheduled_at) |
| **자동화 가능** | ✅ 완전 자동 |
| **소요 시간** | ~3-5분 (파일 크기 의존) |

---

## 3. 병렬 처리 & 인간 개입 분석

### 3.1 병렬 처리 가능 지점

```
Stage 1 ──▶ Stage 2 ──▶ Stage 3-A ─────┐
                    └──▶ Stage 3-B ─────┴──▶ Stage 4 ──▶ Stage 5 ──▶ Stage 6

병렬 가능:
  - Stage 3-A + Stage 3-B (가장 중요한 병렬화, 시간 절약 최대)
  - Stage 3-B 내부: 이미지 생성 씬별 병렬화 가능
  - Stage 5의 썸네일 생성: Stage 4와 일부 병렬 가능 (초안 기준)

순차 필수:
  - Stage 1 → Stage 2 (concept.md 필요)
  - Stage 2 → Stage 3 (script.txt 필요)
  - Stage 3 완료 → Stage 4 (모든 클립/오디오 필요)
  - Stage 4 → Stage 6 (최종 비디오 필요)
```

**병렬화 시간 절감 효과:**
- 직렬 실행: ~30-45분
- Stage 3 병렬화 적용: ~20-30분 (약 30% 단축)

### 3.2 인간 개입 필요 지점

| 지점 | 필요성 | 기본값 | settings.json 제어 |
|------|--------|--------|-------------------|
| Stage 2 후 대본 승인 | **강력 권장** | `true` (검토 필요) | `"human_review_script": true` |
| Stage 5 후 최종 확인 | 선택적 | `false` | `"human_review_final": false` |
| Stage 6 업로드 확인 | 선택적 | `false` | `"human_review_publish": false` |

**완전 자동화 운영 시:** 세 게이트 모두 `false` → 사람 개입 없이 end-to-end 실행  
**품질 관리 운영 시:** `human_review_script: true` → 대본만 검토 후 나머지 자동

---

## 4. 파이프라인 A/B/C 상세 설계

### 파이프라인 A: 최소 비용형 (무료/$0)

| Stage | 도구 | API/라이브러리 |
|-------|------|----------------|
| Stage 1: Research | Claude + DuckDuckGo | Anthropic API + ddgs |
| Stage 2: Script | Claude | Anthropic API |
| Stage 3-A: TTS | Google Cloud TTS 또는 Edge-TTS | `edge-tts` (무료, Microsoft) |
| Stage 3-A: 자막 | Whisper (로컬) | `openai-whisper` |
| Stage 3-B: 이미지 | Flux.1-schnell via Hugging Face Inference | HF free tier |
| Stage 3-B: 비디오 | ffmpeg Ken Burns | 로컬 ffmpeg |
| Stage 4: Assembly | ffmpeg | 로컬 ffmpeg |
| Stage 5: 썸네일 | Pillow + Claude (텍스트 레이아웃) | Python Pillow |
| Stage 6: Upload | YouTube Data API v3 | Google OAuth2 |

**비용 구조 (영상 1편, 10분 롱폼 기준):**
```
Claude API (Stage 1-2, 5):  ~$0.10-0.30  (claude-3.5-haiku 기준)
Edge-TTS:                   $0.00         (무료)
Whisper:                    $0.00         (로컬)
HF Flux.1-schnell:          $0.00-0.05    (무료 tier, 초과 시 소액)
ffmpeg:                     $0.00         (로컬)
YouTube API:                $0.00         (무료)
────────────────────────────────────────
영상당 총 비용:             ~$0.10-0.35
월 30편 기준:               ~$3-10
```

**예상 소요 시간:** 30-50분  
**구현 난이도:** ⭐⭐⭐ (3/5) — ffmpeg 숙련도 필요  
**장점:**
- 실질적으로 무료
- 완전 로컬 처리 (데이터 보안)
- API 한도 걱정 없음

**단점:**
- Edge-TTS 음질이 ElevenLabs 대비 낮음
- HF 무료 tier 속도 느림 (이미지당 10-30초)
- Flux 이미지 품질이 Imagen 대비 낮을 수 있음

---

### 파이프라인 B: 품질 균형형 (월 $20-50)

| Stage | 도구 | API |
|-------|------|-----|
| Stage 1: Research | Claude + 검색 | Anthropic API |
| Stage 2: Script | Claude 3.5 Sonnet | Anthropic API |
| Stage 3-A: TTS | ElevenLabs | ElevenLabs API |
| Stage 3-A: 자막 | Whisper (로컬) 또는 AssemblyAI | 로컬/AssemblyAI |
| Stage 3-B: 이미지 | Gemini Imagen 3 | Google AI API |
| Stage 3-B: 비디오 | ffmpeg Ken Burns | 로컬 ffmpeg |
| Stage 4: Assembly | ffmpeg | 로컬 ffmpeg |
| Stage 5: 썸네일 | Gemini Imagen + Pillow | Google AI API |
| Stage 6: Upload | YouTube Data API v3 | Google OAuth2 |

**비용 구조 (영상 1편, 10분 롱폼, 씬 15개 기준):**
```
Claude API (Stage 1-2, 5):        ~$0.20-0.50
ElevenLabs TTS (10분 오디오):      ~$0.30-0.80  (Starter $5/mo = 30,000자)
Gemini Imagen (15장):              ~$0.15-0.30  ($0.02/image)
ffmpeg:                            $0.00
YouTube API:                       $0.00
────────────────────────────────────────────
영상당 총 비용:                    ~$0.65-1.60
월 20편 기준:                      ~$13-32
```

**예상 소요 시간:** 20-35분 (Stage 3 병렬화 시)  
**구현 난이도:** ⭐⭐⭐ (3/5)  
**장점:**
- ElevenLabs 음질로 시청 경험 향상
- Gemini Imagen 고품질 이미지
- 이미 보유한 API로 즉시 구현 가능
- 월 비용 예측 가능

**단점:**
- ElevenLabs 월 한도 관리 필요
- Gemini Imagen API 한국어 프롬프트 품질 편차

---

### 파이프라인 C: 고품질형 (월 $100-200)

| Stage | 도구 | API |
|-------|------|-----|
| Stage 1: Research | Claude 3.5 Sonnet + Perplexity | Anthropic + Perplexity |
| Stage 2: Script | Claude 3.5 Sonnet (extended thinking) | Anthropic API |
| Stage 3-A: TTS | ElevenLabs (고품질 모델) | ElevenLabs API |
| Stage 3-A: 자막 | AssemblyAI | AssemblyAI API |
| Stage 3-B: 이미지 | Flux Pro 또는 DALL-E 3 | fal.ai / OpenAI |
| Stage 3-B: 비디오 | Kling (키 씬만) + Ken Burns (나머지) | Kling API |
| Stage 4: Assembly | Remotion 또는 ffmpeg | Node.js/로컬 |
| Stage 5: 썸네일 | Flux Pro + Pillow | fal.ai |
| Stage 6: Upload | YouTube Data API v3 | Google OAuth2 |

**비용 구조 (영상 1편, 10분 롱폼, 씬 15개 기준):**
```
Claude API (Sonnet):               ~$0.50-1.50
ElevenLabs (Pro tier):             ~$1.00-2.00
Flux Pro 이미지 (15장):            ~$0.75-1.50  ($0.05/image)
Kling 비디오 (3개 키 씬, 5초):     ~$1.50-3.00  ($0.50/5sec)
AssemblyAI 자막:                   ~$0.20
────────────────────────────────────────────
영상당 총 비용:                    ~$4.00-8.00
월 20편 기준:                      ~$80-160
```

**예상 소요 시간:** 25-45분  
**구현 난이도:** ⭐⭐⭐⭐ (4/5) — Kling API 통합 복잡성  
**장점:**
- 방송 수준에 근접하는 시각적 품질
- Kling 실사 영상으로 차별화

**단점:**
- Kling API 비용 폭발 위험 (씬 수 늘면 비례 증가)
- 복잡한 API 통합
- 비용 ROI 검증 필요

---

## 5. 채널 설정 구조

### 5.1 settings.json (채널 설정 마스터)

```json
{
  "channel": {
    "id": "UCxxxxxxxxxxxxxxxx",
    "name": "MyChannel",
    "description": "채널 설명",
    "default_language": "ko",
    "default_category_id": "27",
    "default_playlist_id": "PLxxxxxxxxxxxxxxxx"
  },

  "content": {
    "type": "educational",
    "format": "longform",
    "target_duration_min": 10,
    "target_scene_count": 15,
    "style_guide": "authoritative yet approachable. Use data and examples.",
    "hook_style": "question",
    "cta_style": "subscribe_and_comment",
    "topics_auto_discover": true,
    "topics_sources": ["google_trends", "reddit", "youtube_trending"]
  },

  "pipeline": {
    "variant": "B",
    "parallel_stage3": true,
    "human_review_script": false,
    "human_review_final": false,
    "human_review_publish": false,
    "resume_on_failure": true,
    "max_retries": 3
  },

  "tts": {
    "provider": "elevenlabs",
    "voice_id": "pNInz6obpgDQGcFmaJgB",
    "model": "eleven_multilingual_v2",
    "stability": 0.5,
    "similarity_boost": 0.75,
    "speed": 1.0,
    "fallback_provider": "edge-tts",
    "fallback_voice": "ko-KR-InJoonNeural"
  },

  "image": {
    "provider": "gemini_imagen",
    "model": "imagen-3.0-generate-001",
    "style_preset": "photorealistic",
    "aspect_ratio": "16:9",
    "resolution": "1920x1080",
    "negative_prompt": "text, watermark, blurry, low quality",
    "fallback_provider": "flux_schnell"
  },

  "video": {
    "provider": "ffmpeg_ken_burns",
    "resolution": "1920x1080",
    "fps": 30,
    "zoom_speed": 0.0015,
    "transition": "crossfade",
    "transition_duration": 0.5
  },

  "audio": {
    "bgm_enabled": true,
    "bgm_volume": 0.12,
    "bgm_style": "calm_instrumental",
    "bgm_library": "local",
    "voiceover_volume": 1.0
  },

  "captions": {
    "enabled": true,
    "burn_in": false,
    "provider": "whisper",
    "language": "auto",
    "style": {
      "font_size": 24,
      "font_color": "white",
      "outline": true
    }
  },

  "thumbnail": {
    "style": "bold_text_overlay",
    "font": "NotoSansKR-Bold",
    "template": "default",
    "text_position": "bottom",
    "overlay_opacity": 0.6,
    "generate_variants": 2
  },

  "seo": {
    "title_max_length": 60,
    "description_min_length": 300,
    "tag_count": 15,
    "include_chapters": true,
    "chapters_min_scenes": 5
  },

  "publish": {
    "privacy": "public",
    "notify_subscribers": true,
    "schedule_enabled": true,
    "schedule_time": "09:00",
    "schedule_timezone": "Asia/Seoul",
    "schedule_days": ["monday", "wednesday", "friday"],
    "add_to_playlist": true,
    "end_screen_enabled": true
  },

  "paths": {
    "base": "channels/mychannel",
    "projects": "channels/mychannel/projects",
    "music": "channels/mychannel/_assets/music",
    "fonts": "channels/mychannel/_assets/fonts"
  }
}
```

---

## 6. 프로젝트 폴더 구조

```
channels/
└── {channel-name}/
    ├── settings.json              # 채널 설정 (마스터)
    ├── _assets/
    │   ├── music/                 # BGM 파일 (.mp3)
    │   ├── fonts/                 # 자막/썸네일 폰트
    │   ├── intro.mp4              # 인트로 클립 (선택)
    │   └── outro.mp4              # 아웃트로 클립 (선택)
    └── projects/
        └── {project-id}/          # e.g., "20260326_ai_economy"
            ├── workflow.json      # 파이프라인 실행 상태
            ├── _refs/             # Stage 1 산출물
            │   ├── concept.md
            │   └── research.json
            ├── _script/           # Stage 2 산출물
            │   ├── outline.md
            │   ├── script.txt
            │   ├── storyboard_hints.json
            │   └── qa_report.md
            ├── _audio/            # Stage 3-A 산출물
            │   ├── scene_01.mp3
            │   ├── scene_02.mp3
            │   ├── ...
            │   ├── full_voiceover.mp3
            │   └── captions/
            │       ├── scene_01.srt
            │       └── full.srt
            ├── _visual/           # Stage 3-B 산출물
            │   ├── storyboard.json
            │   ├── images/
            │   │   ├── scene_01.png
            │   │   └── scene_02.png
            │   └── clips/
            │       ├── scene_01.mp4
            │       └── scene_02.mp4
            └── output/            # Stage 4-6 산출물
                ├── video_draft.mp4
                ├── thumbnail.png
                ├── thumbnail_v2.png
                ├── youtube.md
                └── publish_result.json
```

**프로젝트 ID 형식:** `YYYYMMDD_{slug}` (예: `20260326_ai_economy_collapse`)

---

## 7. workflow.json 형식

```json
{
  "project_id": "20260326_ai_economy_collapse",
  "channel": "mychannel",
  "topic": "AI 경제 붕괴 시나리오",
  "pipeline_variant": "B",
  "created_at": "2026-03-26T10:00:00+09:00",
  "updated_at": "2026-03-26T10:45:00+09:00",
  
  "status": "completed",
  "current_stage": "stage_6",
  
  "stages": {
    "stage_1_research": {
      "status": "completed",
      "started_at": "2026-03-26T10:00:00+09:00",
      "completed_at": "2026-03-26T10:02:30+09:00",
      "duration_sec": 150,
      "outputs": ["_refs/concept.md", "_refs/research.json"],
      "retry_count": 0
    },
    "stage_2_script": {
      "status": "completed",
      "started_at": "2026-03-26T10:02:30+09:00",
      "completed_at": "2026-03-26T10:08:00+09:00",
      "duration_sec": 330,
      "human_review": {
        "required": false,
        "approved": null,
        "approved_at": null
      },
      "outputs": ["_script/outline.md", "_script/script.txt", "_script/storyboard_hints.json"],
      "qa_passed": true,
      "retry_count": 0
    },
    "stage_3a_audio": {
      "status": "completed",
      "started_at": "2026-03-26T10:08:00+09:00",
      "completed_at": "2026-03-26T10:14:00+09:00",
      "duration_sec": 360,
      "parallel_with": "stage_3b_visual",
      "outputs": ["_audio/full_voiceover.mp3", "_audio/captions/full.srt"],
      "scene_count": 15,
      "total_duration_sec": 612,
      "retry_count": 0
    },
    "stage_3b_visual": {
      "status": "completed",
      "started_at": "2026-03-26T10:08:00+09:00",
      "completed_at": "2026-03-26T10:19:00+09:00",
      "duration_sec": 660,
      "parallel_with": "stage_3a_audio",
      "outputs": ["_visual/storyboard.json", "_visual/clips/"],
      "scene_count": 15,
      "images_generated": 15,
      "retry_count": 1
    },
    "stage_4_assembly": {
      "status": "completed",
      "started_at": "2026-03-26T10:19:00+09:00",
      "completed_at": "2026-03-26T10:28:00+09:00",
      "duration_sec": 540,
      "outputs": ["output/video_draft.mp4"],
      "file_size_mb": 312,
      "retry_count": 0
    },
    "stage_5_packaging": {
      "status": "completed",
      "started_at": "2026-03-26T10:28:00+09:00",
      "completed_at": "2026-03-26T10:31:00+09:00",
      "duration_sec": 180,
      "outputs": ["output/thumbnail.png", "output/youtube.md"],
      "retry_count": 0
    },
    "stage_6_publish": {
      "status": "completed",
      "started_at": "2026-03-26T10:31:00+09:00",
      "completed_at": "2026-03-26T10:34:00+09:00",
      "duration_sec": 180,
      "outputs": ["output/publish_result.json"],
      "video_id": "dQw4w9WgXcQ",
      "video_url": "https://youtu.be/dQw4w9WgXcQ",
      "scheduled_at": "2026-03-27T09:00:00+09:00",
      "retry_count": 0
    }
  },

  "cost": {
    "claude_api_usd": 0.32,
    "elevenlabs_chars": 4821,
    "gemini_imagen_calls": 16,
    "total_estimated_usd": 0.89
  },

  "total_duration_sec": 2070,
  "total_duration_human": "34분 30초"
}
```

---

## 8. 에이전트 역할 분담

### 8.1 에이전트 구성 (최소 구성)

```
오케스트레이터 (Claude Code / 메인 스크립트)
├── strategist          # Stage 1: 리서치 & 전략
├── writer              # Stage 2: 대본 작성
├── script-reviewer     # Stage 2: QA (writer의 서브에이전트)
├── audio-pd            # Stage 3-A: 오디오 프로덕션
├── visual-pd           # Stage 3-B: 비주얼 프로덕션
├── assembler           # Stage 4: 편집 합성
├── packager            # Stage 5: 패키징
└── publisher           # Stage 6: 업로드
```

### 8.2 에이전트 프롬프트 시스템

각 에이전트는 두 개의 컨텍스트를 받음:
1. **시스템 컨텍스트**: 에이전트 역할 + 도구 목록 + 출력 형식
2. **채널 컨텍스트**: `settings.json`에서 주입된 채널별 가이드라인

```python
# 에이전트 초기화 패턴
agent_context = {
    "role": "You are the Script Writer agent...",
    "channel_settings": settings_json,
    "project_paths": project_paths,
    "inputs": {
        "concept_md": read_file("_refs/concept.md"),
        "outline_md": read_file("_script/outline.md")  # 있을 경우
    },
    "output_schema": {
        "script_txt": "씬 마커 포함 대본",
        "storyboard_hints_json": "각 씬의 시각적 힌트"
    }
}
```

### 8.3 오케스트레이터 실행 흐름

```python
# orchestrator.py 핵심 로직
async def run_pipeline(project_id: str, settings: dict):
    workflow = load_or_create_workflow(project_id)
    
    # Stage 1: Research
    if not workflow.is_completed("stage_1"):
        await run_agent("strategist", inputs={"topic": topic, "settings": settings})
        workflow.mark_completed("stage_1")
    
    # Stage 2: Script
    if not workflow.is_completed("stage_2"):
        await run_agent("writer", inputs={"concept": load("_refs/concept.md")})
        await run_agent("script-reviewer", inputs={"script": load("_script/script.txt")})
        
        if settings["pipeline"]["human_review_script"]:
            await wait_for_human_approval(workflow, "stage_2")
        
        workflow.mark_completed("stage_2")
    
    # Stage 3: 병렬 실행
    if not workflow.is_completed("stage_3"):
        await asyncio.gather(
            run_agent("audio-pd", inputs={"script": load("_script/script.txt")}),
            run_agent("visual-pd", inputs={"storyboard_hints": load("_script/storyboard_hints.json")})
        )
        workflow.mark_completed("stage_3")
    
    # Stage 4-6: 순차 실행
    for stage, agent in [("stage_4", "assembler"), ("stage_5", "packager"), ("stage_6", "publisher")]:
        if not workflow.is_completed(stage):
            await run_agent(agent)
            workflow.mark_completed(stage)
```

---

## 9. 파이프라인 선택 가이드

```
채널 초기 단계 (검증 중)?
  └─▶ 파이프라인 A (최소 비용, 월 $3-10)
      채널 성장 확인?
        └─▶ 파이프라인 B (품질 균형, 월 $20-50)
            월 수익 > $200?
              └─▶ 파이프라인 C (고품질, 월 $100-200)
```

| 기준 | A 추천 | B 추천 | C 추천 |
|------|--------|--------|--------|
| 월 예산 | ~$0-10 | $20-50 | $100-200 |
| 채널 구독자 | 0-1,000 | 1,000-10,000 | 10,000+ |
| 업로드 빈도 | 주 1회 | 주 2-3회 | 주 3-5회 |
| 콘텐츠 유형 | 정보성 | 스토리텔링 | 고퀄 브랜드 |
| 기술 수준 | 중급 | 중급 | 고급 |

---

## 10. 구현 우선순위 로드맵

### Phase 1 (즉시 시작): 파이프라인 B 뼈대
```
Week 1:
  ✅ settings.json 스키마 확정
  ✅ 프로젝트 폴더 구조 생성 스크립트
  ✅ workflow.json 상태 관리 모듈
  ✅ Stage 1: Research 에이전트 (Claude + 검색)
  ✅ Stage 2: Writer 에이전트 (Claude)

Week 2:
  ✅ Stage 3-A: ElevenLabs TTS + Whisper 자막
  ✅ Stage 3-B: Gemini Imagen + ffmpeg Ken Burns
  ✅ 병렬 실행 (asyncio.gather)
  ✅ Stage 4: ffmpeg Assembly

Week 3:
  ✅ Stage 5: 썸네일 생성 + youtube.md
  ✅ Stage 6: YouTube Data API v3 업로드
  ✅ 에러 처리 + 재시작 (resume_on_failure)
  ✅ End-to-end 테스트
```

### Phase 2: 파이프라인 A 추가 (비용 최적화)
```
Week 4-5:
  ✅ Edge-TTS 통합 (ElevenLabs 대체)
  ✅ Flux.1-schnell via HF 통합
  ✅ settings.json 스위칭으로 A/B 전환
```

### Phase 3: 다채널 병렬 운영
```
Week 6-7:
  ✅ 채널별 settings.json 관리
  ✅ 멀티채널 스케줄러 (cron 통합)
  ✅ 비용 트래킹 대시보드
  ✅ 성과 피드백 루프 (조회수 → 콘텐츠 전략 반영)
```

---

## 11. 핵심 설계 원칙 요약

1. **파이프라인 구조는 고정, 콘텐츠는 변수** — `settings.json`이 유일한 콘텐츠 구성 지점
2. **6단계가 롱폼 최적** — 8단계 대비 운영 단순화, 3단계 대비 제어 세분화
3. **Stage 3 병렬화가 핵심** — TTS와 이미지 생성이 가장 시간 소모적, 동시 실행으로 30% 단축
4. **인간 개입은 Stage 2 이후 단 한 번** — 대본 승인만 하면 나머지 완전 자동
5. **Resume-first 설계** — 모든 단계 실패 시 해당 단계부터 재시작 (비용 낭비 방지)
6. **Provider 추상화** — TTS/이미지/비디오 provider를 settings로만 전환, 코드 수정 불필요