Update app.py

app.py

@@ -44,6 +44,58 @@ if not FIREWORKS_API_KEY:
 # 글로벌 변수
 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 = {
    "액션": {
@@ -120,41 +172,60 @@ GENRE_TEMPLATES = {
    }
 }
 
-# 시나리오 단계 (기획 단계와 작성 단계 분리)
+# 기획 단계 - 다중 역할 협업
 PLANNING_STAGES = [
-    ("컨셉 개발", "🎬 프로듀서: 핵심 컨셉 및 시장성 분석"),
-    ("스토리 구성", "📖 스토리 개발: 시놉시스 및 3막 구조"),
-    ("캐릭터 설계", "👥 캐릭터 디자이너: 인물 프로필 및 관계도"),
-    ("세계관 구축", "🌍 세계관: 배경, 분위기, 비주얼 설정"),
-    ("씬 구성", "🎯 씬 플래너: 상세 씬 브레이크다운"),
+    ("프로듀서", "producer", "🎬 프로듀서: 핵심 컨셉 및 시장성 분석"),
+    ("스토리작가", "story_writer", "📖 스토리 작가: 시놉시스 및 3막 구조"),
+    ("캐릭터디자이너", "character_designer", "👥 캐릭터 디자이너: 인물 프로필 및 관계도"),
+    ("감독", "director", "🎭 감독: 비주얼 컨셉 및 연출 방향"),
+    ("비평가", "critic", "🔍 비평가: 기획안 종합 검토 및 개선점"),
 ]
 
+# 작성 단계 - 다중 역할 협업
 WRITING_STAGES = [
-    ("1막 초고", "✍️ 1막 - 설정 (25%) - 초고 작성"),
-    ("1막 수정", "📝 1막 - 확장 및 다듬기"),
-    ("1막 검토", "🔧 1막 - 전문가 검토"),
-    ("1막 완성", "✅ 1막 - 최종 완성본"),
+    ("스토리작가", "1막 초고", "✍️ 1막 초고 작성"),
+    ("편집자", "1막 편집", "✂️ 1막 편집 및 페이싱 조정"),
+    ("감독", "1막 연출", "🎭 1막 비주얼 강화"),
+    ("대화전문가", "1막 대사", "💬 1막 대사 개선"),
+    ("비평가", "1막 검토", "🔍 1막 종합 검토"),
+    ("스토리작가", "1막 완성", "✅ 1막 최종 완성본"),
     
-    ("2막A 초고", "✍️ 2막A - 상승 (25%) - 초고 작성"),
-    ("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막A 대사", "💬 2막A 대사 개선"),
+    ("비평가", "2막A 검토", "🔍 2막A 종합 검토"),
+    ("스토리작가", "2막A 완성", "✅ 2막A 최종 완성본"),
     
-    ("2막B 초고", "✍️ 2막B - 복잡화 (25%) - 초고 작성"),
-    ("2막B 수정", "📝 2막B - 확장 및 다듬기"),
-    ("2막B 검토", "🔧 2막B - 전문가 검토"),
-    ("2막B 완성", "✅ 2막B - 최종 완성본"),
+    ("스토리작가", "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막 - 해결 (25%) - 초고 작성"),
-    ("3막 수정", "📝 3막 - 확장 및 다듬기"),
-    ("3막 검토", "🔧 3막 - 전문가 검토"),
-    ("3막 완성", "✅ 3막 - 최종 완성본"),
+    ("스토리작가", "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:
     """시나리오 기획안"""
@@ -188,23 +259,9 @@ class ScreenplayPlan:
     # 씬 구성
     total_scenes: int = 0
     scene_breakdown: List[Dict] = field(default_factory=list)
-
-@dataclass
-class ScreenplayBible:
-    """시나리오 바이블"""
-    title: str = ""
-    logline: str = ""
-    genre: str = ""
-    subgenre: str = ""
-    tone: str = ""
-    themes: List[str] = field(default_factory=list)
-    protagonist: Dict[str, Any] = field(default_factory=dict)
-    antagonist: Dict[str, Any] = field(default_factory=dict)
-    supporting_cast: Dict[str, Dict[str, Any]] = field(default_factory=dict)
-    three_act_structure: Dict[str, str] = field(default_factory=dict)
-    time_period: str = ""
-    primary_locations: List[Dict[str, str]] = field(default_factory=list)
-    visual_style: str = ""
+    
+    # 전문가 피드백
+    expert_feedbacks: List[ExpertFeedback] = field(default_factory=list)
 
 # 데이터베이스 클래스
 class ScreenplayDatabase:
@@ -224,6 +281,7 @@ class ScreenplayDatabase:
                     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')),
@@ -234,18 +292,16 @@ class ScreenplayDatabase:
             ''')
             
             cursor.execute('''
-                CREATE TABLE IF NOT EXISTS screenplay_stages (
+                CREATE TABLE IF NOT EXISTS expert_reviews (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     session_id TEXT NOT NULL,
-                    stage_type TEXT NOT NULL,
-                    stage_number INTEGER NOT NULL,
-                    stage_name TEXT NOT NULL,
-                    content TEXT,
-                    page_count REAL DEFAULT 0,
-                    status TEXT DEFAULT 'pending',
+                    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),
-                    UNIQUE(session_id, stage_type, stage_number)
+                    FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id)
                 )
             ''')
             
@@ -277,6 +333,18 @@ class ScreenplayDatabase:
             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:
@@ -288,17 +356,6 @@ class ScreenplayDatabase:
             )
             conn.commit()
 
-    @staticmethod
-    def get_planning_data(session_id: str) -> Optional[Dict]:
-        with ScreenplayDatabase.get_db() as conn:
-            row = conn.cursor().execute(
-                'SELECT planning_data FROM screenplay_sessions WHERE session_id = ?',
-                (session_id,)
-            ).fetchone()
-            if row and row['planning_data']:
-                return json.loads(row['planning_data'])
-        return None
-
     @staticmethod
     def save_screenplay_content(session_id: str, content: str, title: str, logline: str):
         with ScreenplayDatabase.get_db() as conn:
@@ -320,8 +377,9 @@ class ScreenplayGenerationSystem:
         self.model_id = MODEL_ID
         self.current_session_id = None
         self.current_plan = ScreenplayPlan()
-        self.original_query = ""  # 원본 요청 저장
-        self.accumulated_content = {}  # 누적 내용 저장
+        self.original_query = ""
+        self.accumulated_content = {}
+        self.expert_feedbacks = []
         ScreenplayDatabase.init_db()
 
     def create_headers(self):
@@ -340,10 +398,10 @@ class ScreenplayGenerationSystem:
                 "model": self.model_id,
                 "messages": messages,
                 "max_tokens": max_tokens,
-                "temperature": 0.7,  # 온도를 낮춰서 일관성 향상
-                "top_p": 0.9,  # top_p도 조정
+                "temperature": 0.7,
+                "top_p": 0.9,
                 "top_k": 40,
-                "presence_penalty": 0.3,  # 반복 방지
+                "presence_penalty": 0.3,
                 "frequency_penalty": 0.3,
                 "stream": True
             }
@@ -393,185 +451,330 @@ class ScreenplayGenerationSystem:
         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], None, None]:
-        """기획안 생성 - 원본 요청 유지"""
+                         progress_callback=None) -> Generator[Tuple[str, float, Dict, List], None, None]:
+        """다중 전문가 협업 기획안 생성"""
         try:
-            self.original_query = query  # 원본 저장
+            self.original_query = query
             self.current_session_id = ScreenplayDatabase.create_session(query, screenplay_type, genre)
             
             planning_content = {}
-            self.accumulated_content = {}  # 누적 내용 초기화
+            self.accumulated_content = {}
+            self.expert_feedbacks = []
             total_stages = len(PLANNING_STAGES)
             
-            # 원본 요청을 명확히 정리
-            core_request = f"""
-【핵심 요청사항】
-{query}
-
-【필수 준수사항】
-- 위 요청사항을 절대적으로 준수할 것
-- 요청된 설정, 인물, 스토리를 그대로 사용할 것
-- 임의로 내용을 변경하거나 다른 이야기로 바꾸지 말 것
-- 장르: {genre}
-- 형식: {screenplay_type}
-"""
-            
-            for idx, (stage_name, stage_desc) in enumerate(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
+                yield f"🔄 {stage_desc} 진행 중...", progress, planning_content, self.expert_feedbacks
                 
-                # 이전 단계 내용 요약
-                previous_content = ""
-                if self.accumulated_content:
-                    previous_content = "\n【이전 단계 내용】\n"
-                    for key, value in self.accumulated_content.items():
-                        previous_content += f"\n[{key}]\n{value[:500]}...\n"
+                # 전문가별 프롬프트 생성
+                prompt = self.get_expert_prompt(
+                    role, stage_key, query, 
+                    self.accumulated_content, genre, screenplay_type
+                )
                 
-                # 각 단계별 프롬프트 생성
-                if stage_name == "컨셉 개발":
-                    prompt = f"""{core_request}
-
-당신은 할리우드 프로듀서입니다. 위 요청사항에 정확히 맞는 {screenplay_type} 시나리오 컨셉을 개발하세요.
-
-【작성 항목】
-1. 제목: (요청 내용을 반영한 제목)
-2. 로그라인: (위 요청의 핵심 스토리를 한 문장으로)
-3. 핵심 테마: (요청에서 다루고자 하는 주제)
-4. 타겟 관객: (이 스토리가 어필할 관객층)
-5. 유사 작품 3개와 차별점
-6. 상업적 매력 포인트
-
-⚠️ 중요: 반드시 "{query}"의 내용을 그대로 사용하세요."""
-
-                elif stage_name == "스토리 구성":
-                    prompt = f"""{core_request}
-{previous_content}
-
-이전 컨셉을 바탕으로 스토리 구조를 만드세요.
-⚠️ 반드시 원본 요청 "{query}"의 스토리라인을 유지하세요.
-
-【작성 항목】
-1. 시놉시스 (500자): 원본 요청의 스토리를 충실히 반영
-2. 확장 시놉시스 (1000자): 세부 사건과 전개 추가
-3. 3막 구조:
-   - 1막: 요청된 설정과 인물 소개
-   - 2막A: 요청된 갈등의 시작
-   - 2막B: 요청된 위기의 심화
-   - 3막: 요청된 방식의 해결
-
-절대 다른 이야기로 바뀌지 않도록 주의하세요."""
-
-                elif stage_name == "캐릭터 설계":
-                    prompt = f"""{core_request}
-{previous_content}
-
-원본 요청에 나온 캐릭터들을 설계하세요.
-⚠️ 요청에 명시된 인물 설정을 절대 변경하지 마세요.
-
-【작성 항목】
-주인공: (요청에 나온 주인공 그대로)
-- 이름과 나이
-- 외모와 성격 (요청 내용 반영)
-- 목표 (요청된 목표)
-- 필요 (내적 성장)
-- 성장 아크
-
-적대자: (요청에 나온 대립 인물/세력)
-- 이름과 역할
-- 동기와 목표
-- 주인공과의 관계
-
-조연들: (요청에 언급된 인물들)
-- 각자의 역할과 특징
-
-새로운 인물을 임의로 추가하지 마세요."""
-
-                elif stage_name == "세계관 구축":
-                    prompt = f"""{core_request}
-{previous_content}
-
-원본 요청의 배경과 세계관을 구축하세요.
-⚠️ 요청에 명시된 시대, 장소, 분위기를 그대로 사용하세요.
-
-【작성 항목】
-1. 시대 배경: (요청된 시대)
-2. 주요 장소: (요청에 나온 장소들)
-3. 전체적 분위기: (요청된 톤)
-4. 시각적 스타일
-5. 음향/음악 스타일
-
-임의로 배경을 바꾸지 마세요."""
-
-                elif stage_name == "씬 구성":
-                    prompt = f"""{core_request}
-{previous_content}
-
-원본 요청의 스토리를 씬으로 구성하세요.
-⚠️ 반드시 요청된 사건들이 모두 포함되어야 합니다.
-
-{SCREENPLAY_LENGTHS[screenplay_type]['pages']}페이지 분량으로:
-- 1막: 요청된 설정과 시작 (약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지)
-- 2막A: 요청된 갈등 전개 (약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지)
-- 2막B: 요청된 위기 심화 (약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지)
-- 3막: 요청된 해결 (약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지)
-
-각 씬마다:
-- 장소와 시간
-- 등장인물
-- 핵심 사건 (요청 내용 반영)
-- 예상 페이지
-
-스토리가 다른 방향으로 가지 않도록 주의하세요."""
-
                 # LLM 호출
                 messages = [
-                    {"role": "system", "content": f"""당신은 전문 시나리오 작가입니다. 
-사용자의 원본 요청을 절대적으로 준수하여 작성하세요.
-절대 임의로 스토리를 변경하거나 다른 이야기를 만들지 마세요.
-원본 요청: {query}"""},
+                    {"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[stage_name] = content
-                    yield f"✅ {stage_desc} 완료", progress, planning_content
+                    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[stage_name] = content
-                time.sleep(0.5)  # API 제한 고려
+                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
+            yield "✅ 전문가 협업 기획안 완성!", 100, planning_content, self.expert_feedbacks
             
         except Exception as e:
-            yield f"❌ 오류 발생: {str(e)}", 0, {}
+            yield f"❌ 오류 발생: {str(e)}", 0, {}, []
 
     def generate_screenplay(self, session_id: str, planning_data: Dict,
-                          progress_callback=None) -> Generator[Tuple[str, float, str], None, None]:
-        """시나리오 작성 - 기획안 충실히 반영"""
+                          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 = []
             
-            # 기획안에서 핵심 정보 추출
-            concept = planning_data.get("컨셉 개발", "")
-            story = planning_data.get("스토리 구성", "")
-            characters = planning_data.get("캐릭터 설계", "")
-            world = planning_data.get("세계관 구축", "")
-            scenes = planning_data.get("씬 구성", "")
-            
-            for idx, (stage_name, stage_desc) in enumerate(WRITING_STAGES):
+            for idx, (role, stage_name, stage_desc) in enumerate(WRITING_STAGES):
                 progress = (idx / total_stages) * 100
                 
-                yield f"🔄 {stage_desc} 진행 중...", progress, screenplay_content
+                yield f"🔄 {stage_desc} 진행 중...", progress, screenplay_content, self.expert_feedbacks
                 
-                # 막 결정
+                # 현재 막 결정
                 current_act = ""
                 if "1막" in stage_name:
                     current_act = "1막"
@@ -582,40 +785,42 @@ class ScreenplayGenerationSystem:
                 elif "3막" in stage_name:
                     current_act = "3막"
                 
-                # 작성 단계별 프롬프트
-                if "초고" in stage_name:
-                    prompt = self._create_writing_prompt(
-                        current_act, planning_data, act_contents, "초고",
-                        self.original_query
+                # 역할별 프롬프트 생성
+                if role == "스토리작가":
+                    prompt = self._create_writer_prompt(
+                        current_act, planning_data, act_contents, stage_name
                     )
-                elif "수정" in stage_name:
-                    prompt = self._create_writing_prompt(
-                        current_act, planning_data, act_contents, "수정",
-                        self.original_query
+                elif role == "편집자":
+                    prompt = self._create_editor_prompt(
+                        current_act, act_contents[current_act] if current_act else screenplay_content
                     )
-                elif "검토" in stage_name:
-                    prompt = self._create_review_prompt(
-                        current_act, act_contents[current_act],
-                        self.original_query
+                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 "완성" in stage_name:
-                    prompt = self._create_writing_prompt(
-                        current_act, planning_data, act_contents, "완성",
+                elif role == "비평가":
+                    prompt = self._create_critic_prompt(
+                        current_act, act_contents[current_act] if current_act else screenplay_content,
                         self.original_query
                     )
-                elif "대사 강화" in stage_name:
-                    prompt = self._create_dialogue_prompt(screenplay_content)
-                elif "최종 검토" in stage_name:
-                    prompt = self._create_final_review_prompt(screenplay_content)
+                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"""당신은 전문 시나리오 작가입니다. 
-표준 시나리오 포맷으로 작성하세요.
-기획안과 원본 요청을 충실히 반영하세요.
-원본 요청: {self.original_query}"""},
+                    {"role": "system", "content": f"""당신은 {role}입니다.
+{expert['description']}
+원본 요청: {self.original_query}
+표준 시나리오 포맷을 준수하세요."""},
                     {"role": "user", "content": prompt}
                 ]
                 
@@ -623,142 +828,214 @@ class ScreenplayGenerationSystem:
                 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]])
+                        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
+                    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 = planning_data.get("컨셉 개발", "").split("제목")[1].split("\n")[0].strip() if "컨셉 개발" in planning_data else "무제"
-            logline = planning_data.get("컨셉 개발", "").split("로그라인")[1].split("\n")[0].strip() if "컨셉 개발" in planning_data else ""
+            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
+            yield "✅ 전문가 협업 시나리오 완성!", 100, screenplay_content, self.expert_feedbacks
             
         except Exception as e:
-            yield f"❌ 오류 발생: {str(e)}", 0, ""
+            yield f"❌ 오류 발생: {str(e)}", 0, "", []
 
-    def _create_writing_prompt(self, act: str, planning_data: Dict, 
-                              previous_acts: Dict, phase: str, original_query: str) -> str:
-        """작성 프롬프트 생성 - 원본 충실"""
+    def _create_writer_prompt(self, act: str, planning_data: Dict, 
+                             previous_acts: Dict, stage_name: str) -> str:
+        """스토리 작가 프롬프트"""
         
-        story_structure = planning_data.get("스토리 구성", "")
-        characters = planning_data.get("캐릭터 설계", "")
-        scenes = planning_data.get("씬 구성", "")
-        world = planning_data.get("세계관 구축", "")
-        
-        if phase == "초고":
+        if "초고" in stage_name:
             min_lines = 800
-            instruction = "초고를 작성하세요"
-        elif phase == "수정":
-            min_lines = 1000
-            instruction = "내용을 확장하고 다듬으세요"
-        else:  # 완성
+        elif "완성" in stage_name:
             min_lines = 1200
-            instruction = "최종 완성본을 작성하세요"
+        else:
+            min_lines = 1000
         
-        prompt = f"""【원본 요청】
-{original_query}
-
-【{act} {instruction}】
-
-목표 분량: 최소 {min_lines}줄
+        return f"""【{act} 작성】
+목표 분량: {min_lines}줄 이상
 
-【기획안 내용】
-스토리 구조:
-{story_structure[:1000]}
+【기획안 핵심】
+{self._extract_planning_core(planning_data)}
 
-캐릭터:
-{characters[:1000]}
-
-세계관:
-{world[:500]}
-
-씬 구성:
-{scenes[:1000]}
-
-【이전 막 내용】
+【이전 막】
 {previous_acts if previous_acts else "첫 막입니다"}
 
-【필수 요구사항】
-1. 원본 요청과 기획안을 충실히 반영
-2. 표준 시나리오 포맷 사용
-   - INT./EXT. 장소 - 시간
-   - 캐릭터명은 대문자
-   - 대사는 캐릭터 아래 들여쓰기
-3. 시각적 묘사는 현재형으로
-4. 각 씬마다 충분한 분량 (5-7페이지)
-5. 절대 다른 이야기로 변경하지 말 것
-
-⚠️ 중요: 반드시 원본 요청 "{original_query}"의 스토리를 그대로 구현하세요.
-임의로 스토리를 바꾸지 마세요.
+【작성 요구사항】
+1. 표준 시나리오 포맷
+2. 충분한 씬 분량 (각 5-7페이지)
+3. 시각적 액션 묘사
+4. 자연스러운 대화
+5. 원본 스토리 충실
 
-{min_lines}줄 이상 작성하세요."""
-        
-        return prompt
+반드시 {min_lines}줄 이상 작성하세요."""
 
-    def _create_review_prompt(self, act: str, content: str, original_query: str) -> str:
-        """검토 프롬프트"""
-        return f"""【원본 요청】
-{original_query}
+    def _create_editor_prompt(self, act: str, content: str) -> str:
+        """편집자 프롬프트"""
+        return f"""【{act} 편집】
 
-【{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. 페이싱과 리듬
+【비주얼 강화 포인트】
+1. 오프닝 씬 비주얼
+2. 핵심 액션 시퀀스
+3. 감정적 클로즈업
+4. 환경/분위기 묘사
+5. 상징적 이미지
 
-【필수 확인사항】
-- 원본 요청의 스토리가 제대로 구현되었는가?
-- 임의로 변경된 부분은 없는가?
-- 기획안과 일치하는가?
+각 씬에 시각적 디테일을 추가하세요."""
 
-구체적인 개선 제안을 하세요."""
+    def _create_dialogue_prompt(self, act: str, content: str) -> str:
+        """대화 전문가 프롬프트"""
+        return f"""【{act} 대사 개선】
 
-    def _create_dialogue_prompt(self, screenplay: str) -> str:
-        """대사 강화 프롬프트"""
-        return f"""전체 시나리오의 대사를 검토하고 개선하세요.
+현재 대사 검토:
+{content[:2000]}...
 
-【개선 포인트】
-1. 캐릭터별 고유한 말투 확립
+【개선 방향】
+1. 캐릭터별 말투 차별화
 2. 서브텍스트 추가
-3. 불필요한 설명 대사 제거
-4. 감정적 진정성 강화
-5. 장르에 맞는 톤 유지
+3. 불필요한 설명 제거
+4. 감정적 뉘앙스 강화
+5. 리듬과 템포 조정
 
-【원본 유지】
-- 스토리와 설정은 절대 변경하지 마세요
-- 대사만 개선하세요
+개선된 대사 예시를 제시하세요."""
 
-주요 개선이 필요한 대사들을 찾아 수정안을 제시하세요."""
+    def _create_critic_prompt(self, act: str, content: str, original_query: str) -> str:
+        """비평가 프롬프트"""
+        return f"""【{act} 종합 검토】
 
-    def _create_final_review_prompt(self, screenplay: str) -> str:
-        """최종 검토 프롬프트"""
-        return f"""완성된 시나리오를 최종 검토하세요.
+원본 요청: {original_query}
+
+현재 내용:
+{content[:2000]}...
 
 【평가 항목】
-1. 원본 요청 충실도 (최우선)
-2. 전체 구조와 페이싱
-3. 캐릭터 아크 완성도
-4. 테마 전달력
-5. 상업성과 완성도
+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:
@@ -766,15 +1043,39 @@ def format_planning_display(planning_data: Dict) -> str:
     if not planning_data:
         return "기획안이 아직 생성되지 않았습니다."
     
-    formatted = "# 📋 시나리오 기획안\n\n"
+    formatted = "# 📋 시나리오 기획안 (전문가 협업)\n\n"
     
-    for stage_name, content in planning_data.items():
-        formatted += f"## {stage_name}\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:
@@ -810,43 +1111,15 @@ def generate_random_concept(screenplay_type: str, genre: str) -> str:
         '액션': [
             "은퇴한 특수요원이 납치된 딸을 구하기 위해 다시 현장으로 복귀한다",
             "평범한 택시기사가 우연히 국제 테러 조직의 음모에 휘말린다",
-            "부패 경찰과 맞서 싸우는 정의로운 형사의 고독한 싸움"
         ],
         '스릴러': [
             "기억을 잃은 남자가 자신이 연쇄살인범이라는 증거를 발견한다",
             "실종된 아이를 찾는 과정에서 마을의 끔찍한 비밀이 드러난다",
-            "완벽한 알리바이를 가진 용의자를 쫓는 검사의 집요한 추적"
         ],
         '드라마': [
             "말기 암 환자가 마지막 소원으로 가족과의 화해를 시도한다",
             "재개발로 사라질 동네를 지키려는 주민들의 마지막 싸움",
-            "입양아가 생모를 찾아가는 가슴 아픈 여정"
-        ],
-        '코미디': [
-            "결혼식장을 운영하는 커플이 자신들의 이혼을 숨기며 일한다",
-            "복권에 당첨된 가족이 서로 돈을 차지하려 음모를 꾸민다",
-            "실수로 대통령 경호원이 된 평범한 회사원의 좌충우돌 이야기"
-        ],
-        '공포': [
-            "폐병원에서 밤새 생존해야 하는 의대생들의 공포 체험",
-            "거울 속에서 나타나는 또 다른 자신과 마주한 여자",
-            "저주받은 골동품을 판매한 후 벌어지는 기이한 사건들"
         ],
-        'SF': [
-            "시간 여행으로 과거를 바꾸려다 더 큰 재앙을 만든 과학자",
-            "인공지능이 인간의 감정을 학습하며 벌어지는 예상치 못한 사건",
-            "외계 신호를 해독한 언어학자가 인류의 운명을 결정해야 한다"
-        ],
-        '로맨스': [
-            "첫사랑과 20년 만에 재회한 두 사람의 두 번째 기회",
-            "계약결혼으로 시작했다가 진짜 사랑에 빠진 커플",
-            "서로 다른 시대를 살아가는 두 사람의 편지를 통한 사랑"
-        ],
-        '판타지': [
-            "평범한 고등학생이 판타지 세계의 선택받은 용사가 된다",
-            "도시에 나타난 용과 소통할 수 있는 유일한 사람",
-            "마법이 사라진 세계에서 마지막 마법사가 되어버린 청년"
-        ]
     }
     
     genre_concepts = concepts.get(genre, concepts['드라마'])
@@ -871,24 +1144,20 @@ def create_interface():
         text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
     }
     
-    .planning-section {
-        background: #f8f9fa;
-        padding: 1.5rem;
+    .expert-panel {
+        background: #f0f4f8;
+        padding: 1rem;
         border-radius: 10px;
         margin: 1rem 0;
-        max-height: 600px;
-        overflow-y: auto;
     }
     
-    .screenplay-output {
-        font-family: 'Nanum Gothic Coding', 'Courier New', monospace;
-        white-space: pre-wrap;
+    .expert-badge {
+        display: inline-block;
+        padding: 0.3rem 0.8rem;
         background: white;
-        padding: 2rem;
-        border: 2px solid #e0e0e0;
-        border-radius: 10px;
-        max-height: 800px;
-        overflow-y: auto;
+        border-radius: 20px;
+        margin: 0.2rem;
+        font-size: 0.9rem;
     }
     
     .progress-bar {
@@ -905,55 +1174,50 @@ def create_interface():
         border-radius: 10px;
         transition: width 0.3s ease;
     }
-    
-    .warning-box {
-        background: #fff3cd;
-        border: 1px solid #ffc107;
-        border-radius: 5px;
-        padding: 1rem;
-        margin: 1rem 0;
-    }
     """
     
-    with gr.Blocks(theme=gr.themes.Soft(), css=css, title="AI 시나리오 작가") as interface:
+    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;">
-                전문가 수준의 한국어 시나리오를 AI가 작성합니다<br>
-                입력한 아이디어를 충실히 반영하여 완벽한 시나리오를 생성합니다
+                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("📝 새 시나리오"):
-                # 주의사항
-                gr.HTML("""
-                <div class="warning-box">
-                    <strong>💡 팁:</strong> 구체적이고 명확한 설정을 입력할수록 원하는 스토리가 정확히 구현됩니다.<br>
-                    주인공, 배경, 핵심 갈등, 결말 방향을 구체적으로 제시해주세요.
-                </div>
-                """)
-                
                 with gr.Row():
                     with gr.Column(scale=2):
                         query_input = gr.Textbox(
-                            label="💡 시나리오 아이디어 (구체적으로 작성하세요)",
-                            placeholder="""원하는 시나리오를 구체적으로 설명하세요. 예시:
-
-"2045년 서울, AI가 인간의 감정을 완벽히 모방하는 시대. 
-주인공 김민준(35세, AI 윤리학자)은 자신의 죽은 아내를 복제한 AI와 살고 있다.
-어느 날 진짜 아내가 살아있다는 증거를 발견하고, 
-AI 아내와 함께 진실을 찾아 나선다.
-결말에서 진짜와 가짜의 경계가 무너지며 
-사랑의 본질에 대해 질문을 던진다."
-
-구체적인 설정일수록 원하는 결과를 얻을 수 있습니다.""",
-                            lines=8
+                            label="💡 시나리오 아이디어",
+                            placeholder="""구체적인 스토리를 입력하세요. 예시:
+"2045년 서울, AI가 인간 감정을 완벽히 모방하는 시대. 
+AI 윤리학자가 죽은 아내를 복제한 AI와 살다가 
+진짜 아내가 살아있다는 증거를 발견하고 진실을 찾아 나선다."
+""",
+                            lines=6
                         )
                     
                     with gr.Column(scale=1):
@@ -972,7 +1236,7 @@ AI 아내와 함께 진실을 찾아 나선다.
                 with gr.Row():
                     random_btn = gr.Button("🎲 랜덤 아이디어", scale=1)
                     clear_btn = gr.Button("🗑️ 초기화", scale=1)
-                    planning_btn = gr.Button("📋 기획안 생성", variant="primary", scale=2)
+                    planning_btn = gr.Button("📋 전문가 기획 회의", variant="primary", scale=2)
                 
                 # 진행 상태
                 progress_bar = gr.HTML(
@@ -981,157 +1245,102 @@ AI 아내와 함께 진실을 찾아 나선다.
                 status_text = gr.Textbox(
                     label="📊 진행 상태",
                     interactive=False,
-                    value="아이디어를 입력하고 기획안 생성을 시작하세요"
+                    value="아이디어를 입력하고 전문가 기획 회의를 시작하세요"
                 )
                 
-                # 기획안 섹션
+                # 전문가 피드백
+                with gr.Group():
+                    gr.Markdown("### 🎯 전문가 피드백")
+                    expert_feedback_display = gr.Markdown(
+                        value="*전문가들의 의견이 여기에 표시됩니다...*"
+                    )
+                
+                # 기획안
                 with gr.Group():
                     gr.Markdown("### 📋 시나리오 기획안")
                     planning_display = gr.Markdown(
-                        value="*기획안이 여기에 표시됩니다...*",
-                        elem_classes=["planning-section"]
+                        value="*기획안이 여기에 표시됩니다...*"
                     )
                     
                     with gr.Row():
-                        edit_planning_btn = gr.Button("✏️ 기획안 수정", scale=1)
                         save_planning_btn = gr.Button("💾 기획안 저장", scale=1)
-                        generate_screenplay_btn = gr.Button("🎬 시나리오 작성 시작", variant="primary", scale=2)
+                        generate_screenplay_btn = gr.Button("🎬 전문가 시나리오 작성", variant="primary", scale=2)
                 
                 # 시나리오 출력
                 with gr.Group():
                     gr.Markdown("### 📄 완성된 시나리오")
                     screenplay_output = gr.Markdown(
-                        value="*시나리오가 여기에 표시됩니다...*",
-                        elem_classes=["screenplay-output"]
+                        value="*시나리오가 여기에 표시됩니다...*"
                     )
                     
-                    with gr.Row():
-                        download_btn = gr.Button("💾 다운로드 (TXT)", scale=1)
-                        pdf_btn = gr.Button("📑 PDF 변환", scale=1)
-                
-                # 예시
-                gr.Examples(
-                    examples=[
-                        ["2045년 서울, AI가 인간 감정을 완벽히 모방하는 시대. AI 윤리학자가 죽은 아내를 복제한 AI와 살다가 진짜 아내가 살아있다는 증거를 발견하고 진실을 찾아 나선다."],
-                        ["조선시대 한양, 신분을 숨긴 왕세자가 저잣거리에서 의녀를 만나 사랑에 빠진다. 역모 사건에 휘말려 함께 진실을 밝혀야 한다."],
-                        ["작은 해안 마을, 10년 전 실종된 딸이 갑자기 돌아온다. 하지만 그녀는 10년 전 모습 그대로다. 마을의 숨겨진 비밀이 드러나기 시작한다."],
-                        ["대기업 법무팀 변호사가 회사의 불법을 고발하려다 모함을 받는다. 숨어서 증거를 모으며 거대한 음모와 맞선다."]
-                    ],
-                    inputs=query_input,
-                    label="💡 예시 아이디어 (구체적인 설정 참고)"
-                )
-            
-            with gr.Tab("📚 내 작품"):
-                gr.Markdown("""
-                ### 📁 저장된 시나리오
-                
-                작업 중이거나 완성된 시나리오를 관리합니다.
-                """)
-                
-                saved_list = gr.Dataframe(
-                    headers=["제목", "장르", "유형", "페이지", "상태", "수정일"],
-                    value=[],
-                    label="저장된 작품 목록"
-                )
-                
-                with gr.Row():
-                    refresh_btn = gr.Button("🔄 새로고침")
-                    load_btn = gr.Button("📂 불러오기")
-                    delete_btn = gr.Button("🗑️ 삭제")
+                    download_btn = gr.Button("💾 다운로드 (TXT)")
         
         # 이벤트 핸들러
         def handle_planning(query, s_type, genre):
             if not query:
-                yield "", "❌ 아이디어를 입력해주세요", "", {}
+                yield "", "❌ 아이디어를 입력해주세요", "", "", {}
                 return
             
             system = ScreenplayGenerationSystem()
             
-            for status, progress, planning_data in system.generate_planning(query, s_type, genre):
+            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, planning_display, planning_data
+                yield progress_html, status, feedback_display, planning_display, planning_data
         
         def handle_screenplay_generation(session_id, planning_data):
             if not planning_data:
-                yield "", "❌ 먼저 기획안을 생성해주세요", ""
+                yield "", "❌ 먼저 기획안을 생성해주세요", "", ""
                 return
             
             system = ScreenplayGenerationSystem()
             
-            for status, progress, screenplay in system.generate_screenplay(session_id, planning_data):
+            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, screenplay_display
-        
-        def handle_random(s_type, genre):
-            return generate_random_concept(s_type, genre)
-        
-        def handle_clear():
-            empty_progress = '<div class="progress-bar"><div class="progress-fill" style="width: 0%"></div></div>'
-            return "", empty_progress, "준비됨", "", "", None, {}
-        
-        def handle_download(screenplay_text):
-            if not screenplay_text or screenplay_text == "*시나리오가 여기에 표시됩니다...*":
-                return None
-            
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            filename = f"시나리오_{timestamp}.txt"
-            
-            with open(filename, 'w', encoding='utf-8') as f:
-                # 마크다운 제거
-                clean_text = re.sub(r'\*\*([^*]+)\*\*', r'\1', screenplay_text)
-                clean_text = re.sub(r'^#+ ', '', clean_text, flags=re.MULTILINE)
-                f.write(clean_text)
-            
-            return filename
+                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, planning_display, current_planning_data]
+            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, screenplay_output]
+            outputs=[progress_bar, status_text, expert_feedback_display, screenplay_output]
         )
         
         random_btn.click(
-            fn=handle_random,
+            fn=generate_random_concept,
             inputs=[screenplay_type, genre_select],
             outputs=[query_input]
         )
-        
-        clear_btn.click(
-            fn=handle_clear,
-            outputs=[query_input, progress_bar, status_text, planning_display, 
-                    screenplay_output, current_session_id, current_planning_data]
-        )
-        
-        download_btn.click(
-            fn=handle_download,
-            inputs=[screenplay_output],
-            outputs=[gr.File(label="다운로드")]
-        )
     
     return interface
 
 # 메인 실행
 if __name__ == "__main__":
     logger.info("=" * 60)
-    logger.info("AI 시나리오 작가 시작...")
-    logger.info("원본 요청 충실도 강화 버전")
+    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()