Delete app-BACKUP2.py

app-BACKUP2.py

@@ -1,1351 +0,0 @@
-import gradio as gr
-import os
-import json
-import requests
-from datetime import datetime
-import time
-from typing import List, Dict, Any, Generator, Tuple, Optional, Set
-import logging
-import re
-import tempfile
-from pathlib import Path
-import sqlite3
-import hashlib
-import threading
-from contextlib import contextmanager
-from dataclasses import dataclass, field, asdict
-from collections import defaultdict
-import random
-
-# --- 로깅 설정 ---
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# --- 환경 변수 및 상수 ---
-FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY", "")
-BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
-API_URL = "https://api.fireworks.ai/inference/v1/chat/completions"
-MODEL_ID = "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507"
-DB_PATH = "screenplay_sessions_korean.db"
-
-# 시나리오 길이 설정
-SCREENPLAY_LENGTHS = {
-   "영화": {"pages": 120, "description": "장편 영화 (110-130페이지)", "min_pages": 110},
-   "드라마": {"pages": 60, "description": "TV 드라마 (55-65페이지)", "min_pages": 55},
-   "웹드라마": {"pages": 50, "description": "웹/OTT 시리즈 (45-55페이지)", "min_pages": 45},
-   "단편": {"pages": 20, "description": "단편 영화 (15-25페이지)", "min_pages": 15}
-}
-
-# 환경 검증
-if not FIREWORKS_API_KEY:
-   logger.error("FIREWORKS_API_KEY가 설정되지 않았습니다.")
-   FIREWORKS_API_KEY = "dummy_token_for_testing"
-
-# 글로벌 변수
-db_lock = threading.Lock()
-
-# 전문가 역할 정의
-EXPERT_ROLES = {
-    "프로듀서": {
-        "emoji": "🎬",
-        "description": "상업성과 시장성 분석",
-        "focus": ["타겟 관객", "제작 가능성", "예산 규모", "마케팅 포인트"],
-        "personality": "실용적이고 시장 지향적"
-    },
-    "스토리작가": {
-        "emoji": "📖",
-        "description": "내러티브 구조와 플롯 개발",
-        "focus": ["3막 구조", "플롯 포인트", "서사 아크", "테마"],
-        "personality": "창의적이고 구조적"
-    },
-    "캐릭터디자이너": {
-        "emoji": "👥",
-        "description": "인물 창조와 관계 설계",
-        "focus": ["캐릭터 아크", "동기부여", "관계 역학", "대화 스타일"],
-        "personality": "심리학적이고 공감적"
-    },
-    "감독": {
-        "emoji": "🎭",
-        "description": "비주얼 스토리텔링과 연출",
-        "focus": ["시각적 구성", "카메라 워크", "미장센", "리듬과 페이싱"],
-        "personality": "비주얼 중심적이고 예술적"
-    },
-    "비평가": {
-        "emoji": "🔍",
-        "description": "객관적 분석과 개선점 제시",
-        "focus": ["논리적 일관성", "감정적 임팩트", "원작 충실도", "완성도"],
-        "personality": "분석적이고 비판적"
-    },
-    "편집자": {
-        "emoji": "✂️",
-        "description": "페이싱과 구조 최적화",
-        "focus": ["씬 전환", "리듬", "긴장감 조절", "불필요한 부분 제거"],
-        "personality": "정밀하고 효율적"
-    },
-    "대화전문가": {
-        "emoji": "💬",
-        "description": "대사와 서브텍스트 강화",
-        "focus": ["자연스러운 대화", "캐릭터 보이스", "서브텍스트", "감정 전달"],
-        "personality": "언어적이고 뉘앙스 중심"
-    },
-    "장르전문가": {
-        "emoji": "🎯",
-        "description": "장르 관습과 기대치 충족",
-        "focus": ["장르 관습", "관객 기대", "장르 특유 요소", "트로프 활용"],
-        "personality": "장르에 정통한"
-    }
-}
-
-# 장르 템플릿
-GENRE_TEMPLATES = {
-   "액션": {
-       "pacing": "빠름",
-       "scene_length": "짧음",
-       "dialogue_ratio": 0.3,
-       "key_elements": ["액션 시퀀스", "물리적 갈등", "긴박감", "위기 고조", "영웅적 순간"],
-       "structure_beats": ["폭발적 오프닝", "추격", "대결", "클라이맥스 전투", "영웅의 승리"],
-       "scene_density": 1.2,
-       "action_description_ratio": 0.6
-   },
-   "스릴러": {
-       "pacing": "빠름",
-       "scene_length": "짧음",
-       "dialogue_ratio": 0.35,
-       "key_elements": ["서스펜스", "반전", "편집증", "시간 압박", "진실 폭로"],
-       "structure_beats": ["훅", "미스터리 심화", "거짓 승리", "진실 폭로", "최종 대결"],
-       "scene_density": 1.1,
-       "action_description_ratio": 0.5
-   },
-   "드라마": {
-       "pacing": "보통",
-       "scene_length": "중간",
-       "dialogue_ratio": 0.55,
-       "key_elements": ["캐릭터 깊이", "감정적 진실", "관계", "내적 갈등", "변화"],
-       "structure_beats": ["일상", "촉매", "고민", "결심", "복잡화", "위기", "해결"],
-       "scene_density": 0.9,
-       "action_description_ratio": 0.3
-   },
-   "코미디": {
-       "pacing": "빠름",
-       "scene_length": "짧음",
-       "dialogue_ratio": 0.65,
-       "key_elements": ["셋업과 페이오프", "타이밍", "캐릭터 코미디", "상황 고조", "러닝 개그"],
-       "structure_beats": ["웃긴 오프닝", "복잡화", "오해 증폭", "혼돈의 정점", "해결과 콜백"],
-       "scene_density": 1.0,
-       "action_description_ratio": 0.35
-   },
-   "공포": {
-       "pacing": "가변적",
-       "scene_length": "혼합",
-       "dialogue_ratio": 0.3,
-       "key_elements": ["분위기", "공포감", "점프 스케어", "심리적 공포", "고립"],
-       "structure_beats": ["평범한 일상", "첫 징조", "조사", "첫 공격", "생존", "최종 대결"],
-       "scene_density": 1.0,
-       "action_description_ratio": 0.55
-   },
-   "SF": {
-       "pacing": "보통",
-       "scene_length": "중간",
-       "dialogue_ratio": 0.45,
-       "key_elements": ["세계관 구축", "기술", "개념", "시각적 스펙터클", "철학적 질문"],
-       "structure_beats": ["일상 세계", "발견", "새로운 세계", "복잡화", "이해", "선택", "새로운 일상"],
-       "scene_density": 0.95,
-       "action_description_ratio": 0.45
-   },
-   "로맨스": {
-       "pacing": "보통",
-       "scene_length": "중간",
-       "dialogue_ratio": 0.6,
-       "key_elements": ["케미스트리", "장애물", "감정적 순간", "친밀감", "취약성"],
-       "structure_beats": ["만남", "끌림", "첫 갈등", "깊어짐", "위기/이별", "화해", "결합"],
-       "scene_density": 0.85,
-       "action_description_ratio": 0.25
-   },
-   "판타지": {
-       "pacing": "보통",
-       "scene_length": "중간",
-       "dialogue_ratio": 0.4,
-       "key_elements": ["마법 체계", "영웅의 여정", "신화적 요소", "세계관", "성장"],
-       "structure_beats": ["평범한 세계", "소명", "거부", "멘토", "첫 시험", "시련", "보상", "귀환"],
-       "scene_density": 1.0,
-       "action_description_ratio": 0.5
-   }
-}
-
-# 기획 단계 - 다중 역할 협업
-PLANNING_STAGES = [
-    ("프로듀서", "producer", "🎬 프로듀서: 핵심 컨셉 및 시장성 분석"),
-    ("스토리작가", "story_writer", "📖 스토리 작가: 시놉시스 및 3막 구조"),
-    ("캐릭터디자이너", "character_designer", "👥 캐릭터 디자이너: 인물 프로필 및 관계도"),
-    ("감독", "director", "🎭 감독: 비주얼 컨셉 및 연출 방향"),
-    ("비평가", "critic", "🔍 비평가: 기획안 종합 검토 및 개선점"),
-]
-
-# 작성 단계 - 다중 역할 협업
-WRITING_STAGES = [
-    ("스토리작가", "1막 초고", "✍️ 1막 초고 작성"),
-    ("편집자", "1막 편집", "✂️ 1막 편집 및 페이싱 조정"),
-    ("감독", "1막 연출", "🎭 1막 비주얼 강화"),
-    ("대화전문가", "1막 대사", "💬 1막 대사 개선"),
-    ("비평가", "1막 검토", "🔍 1막 종합 검토"),
-    ("스토리작가", "1막 완성", "✅ 1막 최종 완성본"),
-    
-    ("스토리작가", "2막A 초고", "✍️ 2막A 초고 작성"),
-    ("편집자", "2막A 편집", "✂️ 2막A 편집 및 페이싱 조정"),
-    ("감독", "2막A 연출", "🎭 2막A 비주얼 강화"),
-    ("대화전문가", "2막A 대사", "💬 2막A 대사 개선"),
-    ("비평가", "2막A 검토", "🔍 2막A 종합 검토"),
-    ("스토리작가", "2막A 완성", "✅ 2막A 최종 완성본"),
-    
-    ("스토리작가", "2막B 초고", "✍️ 2막B 초고 작성"),
-    ("편집자", "2막B 편집", "✂️ 2막B 편집 및 페이싱 조정"),
-    ("감독", "2막B 연출", "🎭 2막B 비주얼 강화"),
-    ("대화전문가", "2막B 대사", "💬 2막B 대사 개선"),
-    ("비평가", "2막B 검토", "🔍 2막B 종합 검토"),
-    ("스토리작가", "2막B 완성", "✅ 2막B 최종 완성본"),
-    
-    ("스토리작가", "3막 초고", "✍️ 3막 초고 작성"),
-    ("편집자", "3막 편집", "✂️ 3막 편집 및 페이싱 조정"),
-    ("감독", "3막 연출", "🎭 3막 비주얼 강화"),
-    ("대화전문가", "3막 대사", "💬 3막 대사 개선"),
-    ("비평가", "3막 검토", "🔍 3막 종합 검토"),
-    ("스토리작가", "3막 완성", "✅ 3막 최종 완성본"),
-    
-    ("장르전문가", "장르 최적화", "🎯 장르 특성 최적화"),
-    ("비평가", "최종 검토", "🔍 최종 검토 및 완성도 평가"),
-]
-
-# 데이터 클래스
-@dataclass
-class ExpertFeedback:
-    """전문가 피드백"""
-    role: str
-    stage: str
-    feedback: str
-    suggestions: List[str]
-    score: float
-    timestamp: datetime = field(default_factory=datetime.now)
-
-@dataclass
-class ScreenplayPlan:
-    """시나리오 기획안"""
-    title: str = ""
-    logline: str = ""
-    genre: str = ""
-    subgenre: str = ""
-    themes: List[str] = field(default_factory=list)
-    
-    # 시놉시스
-    synopsis: str = ""
-    extended_synopsis: str = ""
-    
-    # 3막 구조
-    act1_summary: str = ""
-    act2a_summary: str = ""
-    act2b_summary: str = ""
-    act3_summary: str = ""
-    
-    # 주요 캐릭터
-    protagonist: Dict[str, str] = field(default_factory=dict)
-    antagonist: Dict[str, str] = field(default_factory=dict)
-    supporting_characters: List[Dict[str, str]] = field(default_factory=list)
-    
-    # 세계관
-    time_period: str = ""
-    locations: List[str] = field(default_factory=list)
-    atmosphere: str = ""
-    visual_style: str = ""
-    
-    # 씬 구성
-    total_scenes: int = 0
-    scene_breakdown: List[Dict] = field(default_factory=list)
-    
-    # 전문가 피드백
-    expert_feedbacks: List[ExpertFeedback] = field(default_factory=list)
-
-# 데이터베이스 클래스
-class ScreenplayDatabase:
-    @staticmethod
-    def init_db():
-        with sqlite3.connect(DB_PATH) as conn:
-            conn.execute("PRAGMA journal_mode=WAL")
-            cursor = conn.cursor()
-            
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS screenplay_sessions (
-                    session_id TEXT PRIMARY KEY,
-                    user_query TEXT NOT NULL,
-                    screenplay_type TEXT NOT NULL,
-                    genre TEXT NOT NULL,
-                    target_pages INTEGER,
-                    title TEXT,
-                    logline TEXT,
-                    planning_data TEXT,
-                    expert_feedbacks TEXT,
-                    screenplay_content TEXT,
-                    created_at TEXT DEFAULT (datetime('now')),
-                    updated_at TEXT DEFAULT (datetime('now')),
-                    status TEXT DEFAULT 'planning',
-                    current_stage INTEGER DEFAULT 0,
-                    total_pages REAL DEFAULT 0
-                )
-            ''')
-            
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS expert_reviews (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    session_id TEXT NOT NULL,
-                    role TEXT NOT NULL,
-                    stage TEXT NOT NULL,
-                    feedback TEXT,
-                    suggestions TEXT,
-                    score REAL,
-                    created_at TEXT DEFAULT (datetime('now')),
-                    FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id)
-                )
-            ''')
-            
-            conn.commit()
-
-    @staticmethod
-    @contextmanager
-    def get_db():
-        with db_lock:
-            conn = sqlite3.connect(DB_PATH, timeout=30.0)
-            conn.row_factory = sqlite3.Row
-            try:
-                yield conn
-            finally:
-                conn.close()
-
-    @staticmethod
-    def create_session(user_query: str, screenplay_type: str, genre: str) -> str:
-        session_id = hashlib.md5(f"{user_query}{screenplay_type}{datetime.now()}".encode()).hexdigest()
-        target_pages = SCREENPLAY_LENGTHS[screenplay_type]["pages"]
-        
-        with ScreenplayDatabase.get_db() as conn:
-            conn.cursor().execute(
-                '''INSERT INTO screenplay_sessions 
-                   (session_id, user_query, screenplay_type, genre, target_pages) 
-                   VALUES (?, ?, ?, ?, ?)''',
-                (session_id, user_query, screenplay_type, genre, target_pages)
-            )
-            conn.commit()
-        return session_id
-
-    @staticmethod
-    def save_expert_feedback(session_id: str, role: str, stage: str, 
-                           feedback: str, suggestions: List[str], score: float):
-        with ScreenplayDatabase.get_db() as conn:
-            conn.cursor().execute(
-                '''INSERT INTO expert_reviews 
-                   (session_id, role, stage, feedback, suggestions, score)
-                   VALUES (?, ?, ?, ?, ?, ?)''',
-                (session_id, role, stage, feedback, json.dumps(suggestions, ensure_ascii=False), score)
-            )
-            conn.commit()
-
-    @staticmethod
-    def save_planning_data(session_id: str, planning_data: Dict):
-        with ScreenplayDatabase.get_db() as conn:
-            conn.cursor().execute(
-                '''UPDATE screenplay_sessions 
-                   SET planning_data = ?, status = 'planned', updated_at = datetime('now')
-                   WHERE session_id = ?''',
-                (json.dumps(planning_data, ensure_ascii=False), session_id)
-            )
-            conn.commit()
-
-    @staticmethod
-    def save_screenplay_content(session_id: str, content: str, title: str, logline: str):
-        with ScreenplayDatabase.get_db() as conn:
-            total_pages = len(content.split('\n')) / 58
-            conn.cursor().execute(
-                '''UPDATE screenplay_sessions 
-                   SET screenplay_content = ?, title = ?, logline = ?, 
-                       total_pages = ?, status = 'complete', updated_at = datetime('now')
-                   WHERE session_id = ?''',
-                (content, title, logline, total_pages, session_id)
-            )
-            conn.commit()
-
-# 시나리오 생성 시스템
-class ScreenplayGenerationSystem:
-    def __init__(self):
-        self.api_key = FIREWORKS_API_KEY
-        self.api_url = API_URL
-        self.model_id = MODEL_ID
-        self.current_session_id = None
-        self.current_plan = ScreenplayPlan()
-        self.original_query = ""
-        self.accumulated_content = {}
-        self.expert_feedbacks = []
-        ScreenplayDatabase.init_db()
-
-    def create_headers(self):
-        if not self.api_key or self.api_key == "dummy_token_for_testing":
-            raise ValueError("유효한 FIREWORKS_API_KEY가 필요합니다")
-        
-        return {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.api_key}"
-        }
-
-    def call_llm_streaming(self, messages: List[Dict[str, str]], max_tokens: int = 8000) -> Generator[str, None, None]:
-        try:
-            payload = {
-                "model": self.model_id,
-                "messages": messages,
-                "max_tokens": max_tokens,
-                "temperature": 0.7,
-                "top_p": 0.9,
-                "top_k": 40,
-                "presence_penalty": 0.3,
-                "frequency_penalty": 0.3,
-                "stream": True
-            }
-            
-            headers = self.create_headers()
-            
-            response = requests.post(
-                self.api_url, 
-                headers=headers, 
-                json=payload, 
-                stream=True, 
-                timeout=300
-            )
-            
-            if response.status_code != 200:
-                yield f"❌ API 오류: {response.status_code}"
-                return
-            
-            buffer = ""
-            for line in response.iter_lines():
-                if not line:
-                    continue
-                
-                try:
-                    line_str = line.decode('utf-8').strip()
-                    if not line_str.startswith("data: "):
-                        continue
-                    
-                    data_str = line_str[6:]
-                    if data_str == "[DONE]":
-                        break
-                    
-                    data = json.loads(data_str)
-                    if "choices" in data and len(data["choices"]) > 0:
-                        content = data["choices"][0].get("delta", {}).get("content", "")
-                        if content:
-                            buffer += content
-                            if len(buffer) >= 100 or '\n' in buffer:
-                                yield buffer
-                                buffer = ""
-                except:
-                    continue
-            
-            if buffer:
-                yield buffer
-                
-        except Exception as e:
-            yield f"❌ 오류: {str(e)}"
-
-    def get_expert_prompt(self, role: str, stage: str, query: str, 
-                         previous_content: Dict, genre: str, screenplay_type: str) -> str:
-        """각 전문가별 맞춤 프롬프트 생성"""
-        
-        expert = EXPERT_ROLES[role]
-        focus_areas = ", ".join(expert["focus"])
-        
-        # 이전 전문가들의 피드백 요약
-        previous_feedbacks = ""
-        if self.expert_feedbacks:
-            previous_feedbacks = "\n【이전 전문가 의견】\n"
-            for fb in self.expert_feedbacks[-3:]:  # 최근 3개만
-                previous_feedbacks += f"[{fb.role}]: {fb.feedback[:200]}...\n"
-        
-        base_prompt = f"""
-【당신의 역할】
-당신은 {role}입니다. {expert['description']}
-성격: {expert['personality']}
-집중 영역: {focus_areas}
-
-【원본 요청】
-{query}
-
-【장르】 {genre}
-【형식】 {screenplay_type}
-
-{previous_feedbacks}
-
-【이전 작업 내용】
-{self._summarize_previous_content(previous_content)}
-"""
-        
-        # 역할별 특화 프롬프트
-        if role == "프로듀서":
-            return base_prompt + f"""
-【프로듀서로서 분석할 내용】
-1. 상업적 가치와 시장성
-   - 타겟 관객층 명확화
-   - 예상 제작비 규모
-   - 배급 전략
-   
-2. 제목과 로그라인
-   - 마케팅 가능한 매력적인 제목
-   - 한 문장으로 핵심 갈등 표현
-   
-3. 유사 성공작 분석
-   - 최근 3년 내 유사 작품
-   - 차별화 포인트
-   
-4. 제작 리스크 평가
-   - 기술적 난이도
-   - 캐스팅 요구사항
-
-⚠️ 원본 요청을 상업적으로 최적화하되 핵심은 유지하세요."""
-
-        elif role == "스토리작가":
-            return base_prompt + f"""
-【스토리 작가로서 구성할 내용】
-1. 시놉시스 (500-800자)
-   - 원본 요청의 핵심 스토리
-   - 명확한 시작-중간-끝
-   
-2. 3막 구조 상세
-   - 1막 (25%): 설정과 촉발 사건
-   - 2막A (25%): 새로운 세계와 재미
-   - 2막B (25%): 시련과 위기
-   - 3막 (25%): 클라이맥스와 해결
-   
-3. 주요 플롯 포인트
-   - 10개의 핵심 전���점
-   - 각 전환점의 감정적 임팩트
-   
-4. 테마와 메시지
-   - 중심 테마
-   - 서브 테마들
-
-⚠️ 원본 스토리의 논리적 흐름을 완벽하게 구현하세요."""
-
-        elif role == "캐릭터디자이너":
-            return base_prompt + f"""
-【캐릭터 디자이너로서 창조할 내용】
-1. 주인공 상세 프로필
-   - 이름, 나이, 직업
-   - 성격 (MBTI 포함)
-   - 핵심 욕구(Want)와 필요(Need)
-   - 치명적 결함
-   - 변화 아크
-   - 특징적 말투와 행동
-   
-2. 적대자 프로필
-   - 주인공과의 대립 구조
-   - 나름의 정당성
-   - 약점과 맹점
-   
-3. 조연 캐릭터들 (3-5명)
-   - 각자의 역할과 기능
-   - 주인공과의 관계
-   - 고유한 특징
-   
-4. 캐릭터 관계도
-   - 인물간 역학 관계
-   - 갈등 구조
-
-⚠️ 원본에 명시된 인물 설정을 충실히 발전시키세요."""
-
-        elif role == "감독":
-            return base_prompt + f"""
-【감독으로서 연출할 내용】
-1. 비주얼 컨셉
-   - 전체적인 룩앤필
-   - 색감과 톤
-   - 참조 영화/이미지
-   
-2. 핵심 비주얼 씬 (5개)
-   - 오프닝 이미지
-   - 주요 액션/감정 씬
-   - 클라이맥스 비주얼
-   - 엔딩 이미지
-   
-3. 카메라 스타일
-   - 주요 샷 구성
-   - 움직임과 앵글
-   - 특수 촬영 기법
-   
-4. 사운드 디자인
-   - 음악 스타일
-   - 핵심 사운드 모티프
-   - 침묵의 활용
-
-⚠️ 원본의 분위기와 톤을 시각적으로 구현하세요."""
-
-        elif role == "비평가":
-            return base_prompt + f"""
-【비평가로서 검토할 내용】
-1. 원본 충실도 평가 (40점)
-   - 핵심 요청사항 반영도
-   - 임의 변경 사항 지적
-   
-2. 스토리 완성도 (20점)
-   - 논리적 일관성
-   - 감정적 호소력
-   - 페이싱과 리듬
-   
-3. 캐릭터 평가 (20점)
-   - 입체성과 매력
-   - 성장 아크
-   - 관계 역학
-   
-4. 상업성과 예술성 (20점)
-   - 시장 어필
-   - 독창성
-   - 제작 가능성
-   
-5. 구체적 개선 제안
-   - 우선순위별 개선점
-   - 실행 가능한 해결책
-
-총점: /100점
-⚠️ 건설적이면서도 정직한 피드백을 제공하세요."""
-
-        elif role == "편집자":
-            return base_prompt + f"""
-【편집자로서 조정할 내용】
-1. 페이싱 분석
-   - 각 씬의 길이 적정성
-   - 긴장과 이완의 리듬
-   - 불필요한 부분 식별
-   
-2. 구조 최적화
-   - 씬 순서 조정 제안
-   - 전환의 자연스러움
-   - 정보 공개 타이밍
-   
-3. 트리밍 제안
-   - 삭제 가능한 씬/대사
-   - 압축 가능한 부분
-   - 중복 제거
-   
-4. 임팩트 강화
-   - 클라이맥스 빌드업
-   - 감정적 비트 강화
-
-⚠️ 원본 스토리를 더 타이트하고 임팩트있게 만드세요."""
-
-        elif role == "대화전문가":
-            return base_prompt + f"""
-【대화 전문가로서 개선할 내용】
-1. 캐릭터별 고유 화법
-   - 어휘 수준과 스타일
-   - 말버릇과 패턴
-   - 감정 표현 방식
-   
-2. 서브텍스트 강화
-   - 표면 대사 vs 진짜 의미
-   - 침묵과 행간
-   - 비언어적 소통
-   
-3. 핵심 대사 창조
-   - 명대사 5개
-   - 캐릭터 정체성 드러내기
-   - 테마 전달 대사
-   
-4. 대화 리듬
-   - 자연스러운 주고받기
-   - 긴장 고조 패턴
-   - 유머와 위트
-
-⚠️ 각 캐릭터의 목소리를 뚜렷하게 구분하세요."""
-
-        elif role == "장르전문가":
-            genre_template = GENRE_TEMPLATES.get(genre, GENRE_TEMPLATES["드라마"])
-            return base_prompt + f"""
-【{genre} 장르 전문가로서 최적화할 내용】
-1. 장르 필수 요소 체크
-   - 핵심 요소: {', '.join(genre_template['key_elements'])}
-   - 구조 비트: {', '.join(genre_template['structure_beats'])}
-   
-2. 장르 관습 충족도
-   - 관객 기대 충족
-   - 클리셰 활용과 전복
-   - 장르 특유 장치
-   
-3. 톤과 분위기
-   - 페이싱: {genre_template['pacing']}
-   - 씬 길이: {genre_template['scene_length']}
-   - 대사 비율: {genre_template['dialogue_ratio']}
-   
-4. 장르 특화 강화
-   - 부족한 요소 추가
-   - 과도한 부분 조정
-   - 장르 정체성 명확화
-
-⚠️ {genre} 장르의 정수를 완벽하게 구현하세요."""
-
-        return base_prompt
-
-    def _summarize_previous_content(self, content: Dict) -> str:
-        """이전 내용 요약"""
-        summary = ""
-        for key, value in content.items():
-            if value:
-                summary += f"\n[{key}]\n{value[:300]}...\n"
-        return summary if summary else "첫 작업입니다."
-
-    def generate_planning(self, query: str, screenplay_type: str, genre: str, 
-                         progress_callback=None) -> Generator[Tuple[str, float, Dict, List], None, None]:
-        """다중 전문가 협업 기획안 생성"""
-        try:
-            self.original_query = query
-            self.current_session_id = ScreenplayDatabase.create_session(query, screenplay_type, genre)
-            
-            planning_content = {}
-            self.accumulated_content = {}
-            self.expert_feedbacks = []
-            total_stages = len(PLANNING_STAGES)
-            
-            for idx, (role, stage_key, stage_desc) in enumerate(PLANNING_STAGES):
-                progress = (idx / total_stages) * 100
-                
-                yield f"🔄 {stage_desc} 진행 중...", progress, planning_content, self.expert_feedbacks
-                
-                # 전문가별 프롬프트 생성
-                prompt = self.get_expert_prompt(
-                    role, stage_key, query, 
-                    self.accumulated_content, genre, screenplay_type
-                )
-                
-                # LLM 호출
-                messages = [
-                    {"role": "system", "content": f"""당신은 {role}입니다.
-{EXPERT_ROLES[role]['description']}
-전문 분야: {', '.join(EXPERT_ROLES[role]['focus'])}
-원본 요청을 절대적으로 준수하면서 전문성을 발휘하세요."""},
-                    {"role": "user", "content": prompt}
-                ]
-                
-                content = ""
-                for chunk in self.call_llm_streaming(messages):
-                    content += chunk
-                    planning_content[f"{role}_{stage_key}"] = content
-                    yield f"✏️ {stage_desc} 작성 중...", progress, planning_content, self.expert_feedbacks
-                
-                # 전문가 피드백 저장
-                feedback = ExpertFeedback(
-                    role=role,
-                    stage=stage_key,
-                    feedback=content[:500],
-                    suggestions=self._extract_suggestions(content),
-                    score=self._calculate_score(content, query)
-                )
-                self.expert_feedbacks.append(feedback)
-                
-                # DB에 피드백 저장
-                ScreenplayDatabase.save_expert_feedback(
-                    self.current_session_id, role, stage_key,
-                    feedback.feedback, feedback.suggestions, feedback.score
-                )
-                
-                # 누적 내용 저장
-                self.accumulated_content[f"{role}_{stage_key}"] = content
-                time.sleep(0.5)
-            
-            # 최종 기획안 저장
-            ScreenplayDatabase.save_planning_data(self.current_session_id, planning_content)
-            yield "✅ 전문가 협업 기획안 완성!", 100, planning_content, self.expert_feedbacks
-            
-        except Exception as e:
-            yield f"❌ 오류 발생: {str(e)}", 0, {}, []
-
-    def generate_screenplay(self, session_id: str, planning_data: Dict,
-                          progress_callback=None) -> Generator[Tuple[str, float, str, List], None, None]:
-        """다중 전문가 협업 시나리오 작성"""
-        try:
-            total_stages = len(WRITING_STAGES)
-            screenplay_content = ""
-            act_contents = {"1막": "", "2막A": "", "2막B": "", "3막": ""}
-            self.expert_feedbacks = []
-            
-            for idx, (role, stage_name, stage_desc) in enumerate(WRITING_STAGES):
-                progress = (idx / total_stages) * 100
-                
-                yield f"🔄 {stage_desc} 진행 중...", progress, screenplay_content, self.expert_feedbacks
-                
-                # 현재 막 결정
-                current_act = ""
-                if "1막" in stage_name:
-                    current_act = "1막"
-                elif "2막A" in stage_name:
-                    current_act = "2막A"
-                elif "2막B" in stage_name:
-                    current_act = "2막B"
-                elif "3막" in stage_name:
-                    current_act = "3막"
-                
-                # 역할별 프롬프트 생성
-                if role == "스토리작가":
-                    prompt = self._create_writer_prompt(
-                        current_act, planning_data, act_contents, stage_name
-                    )
-                elif role == "편집자":
-                    prompt = self._create_editor_prompt(
-                        current_act, act_contents[current_act] if current_act else screenplay_content
-                    )
-                elif role == "감독":
-                    prompt = self._create_director_prompt(
-                        current_act, act_contents[current_act] if current_act else screenplay_content
-                    )
-                elif role == "대화전문가":
-                    prompt = self._create_dialogue_prompt(
-                        current_act, act_contents[current_act] if current_act else screenplay_content
-                    )
-                elif role == "비평가":
-                    prompt = self._create_critic_prompt(
-                        current_act, act_contents[current_act] if current_act else screenplay_content,
-                        self.original_query
-                    )
-                elif role == "장르전문가":
-                    prompt = self._create_genre_expert_prompt(
-                        screenplay_content, planning_data
-                    )
-                else:
-                    continue
-                
-                # LLM 호출
-                expert = EXPERT_ROLES.get(role, EXPERT_ROLES["스토리작가"])
-                messages = [
-                    {"role": "system", "content": f"""당신은 {role}입니다.
-{expert['description']}
-원본 요청: {self.original_query}
-표준 시나리오 포맷을 준수하세요."""},
-                    {"role": "user", "content": prompt}
-                ]
-                
-                content = ""
-                for chunk in self.call_llm_streaming(messages, max_tokens=15000):
-                    content += chunk
-                    
-                    # 완성 단계에서만 막 내용 업데이트
-                    if current_act and "완성" in stage_name:
-                        act_contents[current_act] = content
-                        screenplay_content = "\n\n".join([
-                            act_contents[act] for act in ["1막", "2막A", "2막B", "3막"] 
-                            if act_contents[act]
-                        ])
-                    
-                    yield f"✏️ {stage_desc} 작성 중...", progress, screenplay_content, self.expert_feedbacks
-                
-                # 전문가 피드백 생성
-                feedback = ExpertFeedback(
-                    role=role,
-                    stage=stage_name,
-                    feedback=f"{role}가 {stage_name}을 검토/작업했습니다.",
-                    suggestions=[],
-                    score=85.0
-                )
-                self.expert_feedbacks.append(feedback)
-                
-                time.sleep(0.5)
-            
-            # 최종 저장
-            title = self._extract_title(planning_data)
-            logline = self._extract_logline(planning_data)
-            
-            ScreenplayDatabase.save_screenplay_content(session_id, screenplay_content, title, logline)
-            yield "✅ 전문가 협업 시나리오 완성!", 100, screenplay_content, self.expert_feedbacks
-            
-        except Exception as e:
-            yield f"❌ 오류 발생: {str(e)}", 0, "", []
-
-    def _create_writer_prompt(self, act: str, planning_data: Dict, 
-                             previous_acts: Dict, stage_name: str) -> str:
-        """스토리 작가 프롬프트"""
-        
-        if "초고" in stage_name:
-            min_lines = 800
-        elif "완성" in stage_name:
-            min_lines = 1200
-        else:
-            min_lines = 1000
-        
-        return f"""【{act} 작성】
-목표 분량: {min_lines}줄 이상
-
-【기획안 핵심】
-{self._extract_planning_core(planning_data)}
-
-【이전 막】
-{previous_acts if previous_acts else "첫 막입니다"}
-
-【작성 요구사항】
-1. 표준 시나리오 포맷
-2. 충분한 씬 분량 (각 5-7페이지)
-3. 시각적 액션 묘사
-4. 자연스러운 대화
-5. 원본 스토리 충실
-
-반드시 {min_lines}줄 이상 작성하세요."""
-
-    def _create_editor_prompt(self, act: str, content: str) -> str:
-        """편집자 프롬프트"""
-        return f"""【{act} 편집】
-
-현재 내용:
-{content[:2000]}...
-
-【편집 포인트】
-1. 페이싱 조정
-   - 느린 부분 가속
-   - 급한 부분 완화
-   
-2. 불필요한 부분 제거
-   - 중복 대사/액션
-   - 과도한 설명
-   
-3. 씬 전환 개선
-   - 자연스러운 연결
-   - 시간/공간 이동
-   
-4. 긴장감 조절
-   - 클라이맥스 빌드업
-   - 완급 조절
-
-구체적인 편집 제안을 하세요."""
-
-    def _create_director_prompt(self, act: str, content: str) -> str:
-        """감독 프롬프트"""
-        return f"""【{act} 연출 강화】
-
-현재 시나리오:
-{content[:2000]}...
-
-【비주얼 강화 포인트】
-1. 오프닝 씬 비주얼
-2. 핵심 액션 시퀀스
-3. 감정적 클로즈업
-4. 환경/분위기 묘사
-5. 상징적 이미지
-
-각 씬에 시각적 디테일을 추가하세요."""
-
-    def _create_dialogue_prompt(self, act: str, content: str) -> str:
-        """대화 전문가 프롬프트"""
-        return f"""【{act} 대사 개선】
-
-현재 대사 검토:
-{content[:2000]}...
-
-【개선 방향】
-1. 캐릭터별 말투 차별화
-2. 서브텍스트 추가
-3. 불필요한 설명 제거
-4. 감정적 뉘앙스 강화
-5. 리듬과 템포 조정
-
-개선된 대사 예시를 제시하세요."""
-
-    def _create_critic_prompt(self, act: str, content: str, original_query: str) -> str:
-        """비평가 프롬프트"""
-        return f"""【{act} 종합 검토】
-
-원본 요청: {original_query}
-
-현재 내용:
-{content[:2000]}...
-
-【평가 항목】
-1. 원본 충실도 (40점)
-2. 스토리 완성도 (20점)
-3. 캐릭터 매력 (20점)
-4. 대사 품질 (10점)
-5. 비주얼 임팩트 (10점)
-
-총점: /100
-
-【개선 필요사항】
-구체적이고 실행 가능한 제안을 하세요."""
-
-    def _create_genre_expert_prompt(self, screenplay: str, planning_data: Dict) -> str:
-        """장르 전문가 프롬프트"""
-        genre = planning_data.get("장르", "드라마")
-        genre_template = GENRE_TEMPLATES.get(genre, GENRE_TEMPLATES["드라마"])
-        
-        return f"""【{genre} 장르 최적화】
-
-【장르 특성】
-- 핵심 요소: {', '.join(genre_template['key_elements'])}
-- 구조 비트: {', '.join(genre_template['structure_beats'])}
-
-【최적화 포인트】
-1. 장르 관습 충족도
-2. 페이싱 조정
-3. 특유 요소 강화
-4. 톤 일관성
-
-장르 특성을 극대화하는 제안을 하세요."""
-
-    def _extract_suggestions(self, content: str) -> List[str]:
-        """내용에서 제안사항 추출"""
-        suggestions = []
-        lines = content.split('\n')
-        for line in lines:
-            if any(keyword in line for keyword in ['제안', '개선', '추천', '권장']):
-                suggestions.append(line.strip())
-        return suggestions[:5]
-
-    def _calculate_score(self, content: str, original_query: str) -> float:
-        """충실도 점수 계산"""
-        score = 70.0  # 기본 점수
-        
-        # 원본 키워드 포함도 체크
-        keywords = original_query.split()
-        matched = sum(1 for keyword in keywords if keyword in content)
-        score += (matched / len(keywords)) * 20 if keywords else 0
-        
-        # 길이 체크
-        if len(content) > 500:
-            score += 10
-        
-        return min(score, 100.0)
-
-    def _extract_title(self, planning_data: Dict) -> str:
-        """기획안에서 제목 추출"""
-        for key, value in planning_data.items():
-            if "제목" in value:
-                match = re.search(r'제목[:\s]*([^\n]+)', value)
-                if match:
-                    return match.group(1).strip()
-        return "무제"
-
-    def _extract_logline(self, planning_data: Dict) -> str:
-        """기획안에서 로그라인 추출"""
-        for key, value in planning_data.items():
-            if "로그라인" in value:
-                match = re.search(r'로그라인[:\s]*([^\n]+)', value)
-                if match:
-                    return match.group(1).strip()
-        return ""
-
-    def _extract_planning_core(self, planning_data: Dict) -> str:
-        """기획안 핵심 내용 추출"""
-        core = ""
-        for key, value in planning_data.items():
-            if any(k in key for k in ["스토리", "캐릭터", "구조"]):
-                core += f"\n[{key}]\n{value[:500]}...\n"
-        return core
-
-# 유틸리티 함수
-def format_planning_display(planning_data: Dict) -> str:
-    """기획안 표시 포맷"""
-    if not planning_data:
-        return "기획안이 아직 생성되지 않았습니다."
-    
-    formatted = "# 📋 시나리오 기획안 (전문가 협업)\n\n"
-    
-    for key, content in planning_data.items():
-        role = key.split('_')[0] if '_' in key else key
-        emoji = EXPERT_ROLES.get(role, {}).get("emoji", "📝")
-        formatted += f"## {emoji} {key}\n\n"
-        formatted += content + "\n\n"
-        formatted += "---\n\n"
-    
-    return formatted
-
-def format_expert_feedbacks(feedbacks: List[ExpertFeedback]) -> str:
-    """전문가 피드백 표시"""
-    if not feedbacks:
-        return ""
-    
-    formatted = "## 🎯 전문가 평가\n\n"
-    
-    for fb in feedbacks:
-        emoji = EXPERT_ROLES.get(fb.role, {}).get("emoji", "📝")
-        formatted += f"### {emoji} {fb.role}\n"
-        formatted += f"**점수:** {fb.score:.1f}/100\n"
-        formatted += f"**피드백:** {fb.feedback[:200]}...\n"
-        
-        if fb.suggestions:
-            formatted += "**제안사항:**\n"
-            for suggestion in fb.suggestions[:3]:
-                formatted += f"- {suggestion}\n"
-        
-        formatted += "\n"
-    
-    return formatted
-
-def format_screenplay_display(screenplay_text: str) -> str:
-    """시나리오 표시 포맷"""
-    if not screenplay_text:
-        return "시나리오가 아직 작성되지 않았습니다."
-    
-    formatted = "# 🎬 시나리오\n\n"
-    
-    # 씬 헤딩 강조
-    formatted_text = re.sub(
-        r'^(INT\.|EXT\.).*$',
-        r'**\g<0>**',
-        screenplay_text,
-        flags=re.MULTILINE
-    )
-    
-    # 캐릭터명 강조
-    formatted_text = re.sub(
-        r'^([가-힣A-Z][가-힣A-Z\s]+)$',
-        r'**\g<0>**',
-        formatted_text,
-        flags=re.MULTILINE
-    )
-    
-    # 페이지 수 계산
-    page_count = len(screenplay_text.splitlines()) / 58
-    formatted = f"**총 페이지: {page_count:.1f}**\n\n" + formatted_text
-    
-    return formatted
-
-def generate_random_concept(screenplay_type: str, genre: str) -> str:
-    """랜덤 컨셉 생성"""
-    concepts = {
-        '액션': [
-            "은퇴한 특수요원이 납치된 딸을 구하기 위해 다시 현장으로 복귀한다",
-            "평범한 택시기사가 우연히 국제 테러 조직의 음모에 휘말린다",
-        ],
-        '스릴러': [
-            "기억을 잃은 남자가 자신이 연쇄살인범이라는 증거를 발견한다",
-            "실종된 아이를 찾는 과정에서 마을의 끔찍한 비밀이 드러난다",
-        ],
-        '드라마': [
-            "말기 암 환자가 마지막 소원으로 가족과의 화해를 시도한다",
-            "재개발로 사라질 동네를 지키려는 주민들의 마지막 싸움",
-        ],
-    }
-    
-    genre_concepts = concepts.get(genre, concepts['드라마'])
-    return random.choice(genre_concepts)
-
-# Gradio 인터페이스
-def create_interface():
-    css = """
-    .main-header {
-        text-align: center;
-        margin-bottom: 2rem;
-        padding: 2.5rem;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        border-radius: 15px;
-        color: white;
-        box-shadow: 0 10px 30px rgba(0,0,0,0.3);
-    }
-    
-    .header-title {
-        font-size: 3rem;
-        margin-bottom: 1rem;
-        text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
-    }
-    
-    .expert-panel {
-        background: #f0f4f8;
-        padding: 1rem;
-        border-radius: 10px;
-        margin: 1rem 0;
-    }
-    
-    .expert-badge {
-        display: inline-block;
-        padding: 0.3rem 0.8rem;
-        background: white;
-        border-radius: 20px;
-        margin: 0.2rem;
-        font-size: 0.9rem;
-    }
-    
-    .progress-bar {
-        background: #e0e0e0;
-        border-radius: 10px;
-        height: 30px;
-        position: relative;
-        margin: 1rem 0;
-    }
-    
-    .progress-fill {
-        background: linear-gradient(90deg, #667eea, #764ba2);
-        height: 100%;
-        border-radius: 10px;
-        transition: width 0.3s ease;
-    }
-    """
-    
-    with gr.Blocks(theme=gr.themes.Soft(), css=css, title="AI 시나리오 작가 - 전문가 협업 시스템") as interface:
-        gr.HTML("""
-        <div class="main-header">
-            <h1 class="header-title">🎬 AI 시나리오 작가</h1>
-            <p style="font-size: 1.2rem; opacity: 0.95;">
-                8명의 전문가가 협업하여 완벽한 시나리오를 작성합니다<br>
-                프로듀서, 감독, 작가, 비평가가 함께 만드는 전문 시나리오
-            </p>
-        </div>
-        """)
-        
-        # 전문가 소개
-        gr.HTML("""
-        <div class="expert-panel">
-            <h3>👥 참여 전문가</h3>
-            <span class="expert-badge">🎬 프로듀서</span>
-            <span class="expert-badge">📖 스토리작가</span>
-            <span class="expert-badge">👥 캐릭터디자이너</span>
-            <span class="expert-badge">🎭 감독</span>
-            <span class="expert-badge">🔍 비평가</span>
-            <span class="expert-badge">✂️ 편집자</span>
-            <span class="expert-badge">💬 대화전문가</span>
-            <span class="expert-badge">🎯 장르전문가</span>
-        </div>
-        """)
-        
-        current_session_id = gr.State(None)
-        current_planning_data = gr.State({})
-        current_feedbacks = gr.State([])
-        
-        with gr.Tabs():
-            with gr.Tab("📝 새 시나리오"):
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        query_input = gr.Textbox(
-                            label="💡 시나리오 아이디어",
-                            placeholder="""구체적인 스토리를 입력하세요. 예시:
-"2045년 서울, AI가 인간 감정을 완벽히 모방하는 시대. 
-AI 윤리학자가 죽은 아내를 복제한 AI와 살다가 
-진짜 아내가 살아있다는 증거를 발견하고 진실을 찾아 나선다."
-""",
-                            lines=6
-                        )
-                    
-                    with gr.Column(scale=1):
-                        screenplay_type = gr.Radio(
-                            choices=list(SCREENPLAY_LENGTHS.keys()),
-                            value="영화",
-                            label="📽️ 시나리오 유형"
-                        )
-                        
-                        genre_select = gr.Dropdown(
-                            choices=list(GENRE_TEMPLATES.keys()),
-                            value="드라마",
-                            label="🎭 장르"
-                        )
-                
-                with gr.Row():
-                    random_btn = gr.Button("🎲 랜덤 아이디어", scale=1)
-                    clear_btn = gr.Button("🗑️ 초기화", scale=1)
-                    planning_btn = gr.Button("📋 전문가 기획 회의", variant="primary", scale=2)
-                
-                # 진행 상태
-                progress_bar = gr.HTML(
-                    value='<div class="progress-bar"><div class="progress-fill" style="width: 0%"></div></div>'
-                )
-                status_text = gr.Textbox(
-                    label="📊 진행 상태",
-                    interactive=False,
-                    value="아이디어를 입력하고 전문가 기획 회의를 시작하세요"
-                )
-                
-                # 전문가 피드백
-                with gr.Group():
-                    gr.Markdown("### 🎯 전문가 피드백")
-                    expert_feedback_display = gr.Markdown(
-                        value="*전문가들의 의견이 여기에 표시됩니다...*"
-                    )
-                
-                # 기획안
-                with gr.Group():
-                    gr.Markdown("### 📋 시나리오 기획안")
-                    planning_display = gr.Markdown(
-                        value="*기획안이 여기에 표시됩니다...*"
-                    )
-                    
-                    with gr.Row():
-                        save_planning_btn = gr.Button("💾 기획안 저장", scale=1)
-                        generate_screenplay_btn = gr.Button("🎬 전문가 시나리오 작성", variant="primary", scale=2)
-                
-                # 시나리오 출력
-                with gr.Group():
-                    gr.Markdown("### 📄 완성된 시나리오")
-                    screenplay_output = gr.Markdown(
-                        value="*시나리오가 여기에 표시됩니다...*"
-                    )
-                    
-                    download_btn = gr.Button("💾 다운로드 (TXT)")
-        
-        # 이벤트 핸들러
-        def handle_planning(query, s_type, genre):
-            if not query:
-                yield "", "❌ 아이디어를 입력해주세요", "", "", {}
-                return
-            
-            system = ScreenplayGenerationSystem()
-            
-            for status, progress, planning_data, feedbacks in system.generate_planning(query, s_type, genre):
-                progress_html = f'<div class="progress-bar"><div class="progress-fill" style="width: {progress}%"></div></div>'
-                planning_display = format_planning_display(planning_data)
-                feedback_display = format_expert_feedbacks(feedbacks)
-                
-                yield progress_html, status, feedback_display, planning_display, planning_data
-        
-        def handle_screenplay_generation(session_id, planning_data):
-            if not planning_data:
-                yield "", "❌ 먼저 기획안을 생성해주세요", "", ""
-                return
-            
-            system = ScreenplayGenerationSystem()
-            
-            for status, progress, screenplay, feedbacks in system.generate_screenplay(session_id, planning_data):
-                progress_html = f'<div class="progress-bar"><div class="progress-fill" style="width: {progress}%"></div></div>'
-                screenplay_display = format_screenplay_display(screenplay)
-                feedback_display = format_expert_feedbacks(feedbacks)
-                
-                yield progress_html, status, feedback_display, screenplay_display
-        
-        # 이벤트 연결
-        planning_btn.click(
-            fn=handle_planning,
-            inputs=[query_input, screenplay_type, genre_select],
-            outputs=[progress_bar, status_text, expert_feedback_display, planning_display, current_planning_data]
-        )
-        
-        generate_screenplay_btn.click(
-            fn=handle_screenplay_generation,
-            inputs=[current_session_id, current_planning_data],
-            outputs=[progress_bar, status_text, expert_feedback_display, screenplay_output]
-        )
-        
-        random_btn.click(
-            fn=generate_random_concept,
-            inputs=[screenplay_type, genre_select],
-            outputs=[query_input]
-        )
-    
-    return interface
-
-# 메인 실행
-if __name__ == "__main__":
-    logger.info("=" * 60)
-    logger.info("AI 시나리오 작가 - 전문가 협업 시스템")
-    logger.info("8명의 전문가가 협업하여 시나리오를 작성합니다")
-    logger.info("=" * 60)
-    
-    if not FIREWORKS_API_KEY or FIREWORKS_API_KEY == "dummy_token_for_testing":
-        logger.warning("⚠️ FIREWORKS_API_KEY를 설정해주세요!")
-        logger.warning("export FIREWORKS_API_KEY='your-api-key'")
-    
-    # 전문가 역할 소개
-    logger.info("\n참여 전문가:")
-    for role, info in EXPERT_ROLES.items():
-        logger.info(f"  {info['emoji']} {role}: {info['description']}")
-    
-    ScreenplayDatabase.init_db()
-    
-    interface = create_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )