Update app.py

app.py

@@ -589,39 +589,39 @@ class WebSearchIntegration:
        return "\n".join(extracted)
 
 class ScreenplayGenerationSystem:
-   """Professional screenplay generation system"""
-   def __init__(self):
-       self.token = FRIENDLI_TOKEN
-       self.api_url = API_URL
-       self.model_id = MODEL_ID
-       self.screenplay_tracker = ScreenplayTracker()
-       self.web_search = WebSearchIntegration()
-       self.current_session_id = None
-       ScreenplayDatabase.init_db()
-
-   def create_headers(self):
-       return {"Authorization": f"Bearer {self.token}", "Content-Type": "application/json"}
-
-   # --- Prompt generation functions ---
-   def create_producer_prompt(self, user_query: str, screenplay_type: str, 
-                             genre: str, language: str) -> str:
-       """Producer initial concept development"""
-       
-       # Web search for market trends if enabled
-       search_results = ""
-       if self.web_search.enabled:
-           queries = [
-               f"box office success {genre} films 2024 2025",
-               f"popular {screenplay_type} {genre} trends",
-               f"audience demographics {genre} movies"
-           ]
-           for q in queries[:2]:
-               results = self.web_search.search(q, count=2, language=language)
-               if results:
-                   search_results += self.web_search.extract_relevant_info(results) + "\n"
-       
-       lang_prompts = {
-           "Korean": f"""당신은 할리우드 프로듀서입니다. 상업적으로 성공 가능한 {screenplay_type} 컨셉을 개발하세요.
+    """Professional screenplay generation system"""
+    def __init__(self):
+        self.token = FRIENDLI_TOKEN
+        self.api_url = API_URL
+        self.model_id = MODEL_ID
+        self.screenplay_tracker = ScreenplayTracker()
+        self.web_search = WebSearchIntegration()
+        self.current_session_id = None
+        ScreenplayDatabase.init_db()
+
+    def create_headers(self):
+        return {"Authorization": f"Bearer {self.token}", "Content-Type": "application/json"}
+
+    # --- Prompt generation functions ---
+    def create_producer_prompt(self, user_query: str, screenplay_type: str, 
+                              genre: str, language: str) -> str:
+        """Producer initial concept development"""
+        
+        # Web search for market trends if enabled
+        search_results = ""
+        if self.web_search.enabled:
+            queries = [
+                f"box office success {genre} films 2024 2025",
+                f"popular {screenplay_type} {genre} trends",
+                f"audience demographics {genre} movies"
+            ]
+            for q in queries[:2]:
+                results = self.web_search.search(q, count=2, language=language)
+                if results:
+                    search_results += self.web_search.extract_relevant_info(results) + "\n"
+        
+        lang_prompts = {
+            "Korean": f"""당신은 할리우드 프로듀서입니다. 상업적으로 성공 가능한 {screenplay_type} 컨셉을 개발하세요.
 
 **요청사항:** {user_query}
 **타입:** {SCREENPLAY_LENGTHS[screenplay_type]['description']}
@@ -633,42 +633,42 @@ class ScreenplayGenerationSystem:
 **필수 제공 항목:**
 
 1. **제목 (TITLE)**
-  - 기억하기 쉽고 마케팅 가능한 제목
-  - 장르와 톤을 암시하는 제목
+   - 기억하기 쉽고 마케팅 가능한 제목
+   - 장르와 톤을 암시하는 제목
 
 2. **로그라인 (LOGLINE)**
-  - 25단어 이내 한 문장
-  - 형식: "[사건]이 일어났을 때, [주인공]은 [목표]를 이루어야 한다. 그렇지 않으면 [결과]"
-  - 갈등과 stakes가 명확해야 함
+   - 25단어 이내 한 문장
+   - 형식: "[사건]이 일어났을 때, [주인공]은 [목표]를 이루어야 한다. 그렇지 않으면 [결과]"
+   - 갈등과 stakes가 명확해야 함
 
 3. **장르 분석**
-  - 주 장르: {genre}
-  - 서브 장르:
-  - 톤 & 분위기:
+   - 주 장르: {genre}
+   - 서브 장르:
+   - 톤 & 분위기:
 
 4. **타겟 관객**
-  - 주요 연령대:
-  - 성별 분포:
-  - 관심사:
-  - 유사 작품 팬층:
+   - 주요 연령대:
+   - 성별 분포:
+   - 관심사:
+   - 유사 작품 팬층:
 
 5. **비교 작품 (COMPS)**
-  - 3개의 성공한 유사 프로젝트
-  - 각각의 박스오피스/시청률 성과
-  - 우리 프로젝트와의 차별점
+   - 3개의 성공한 유사 프로젝트
+   - 각각의 박스오피스/시청률 성과
+   - 우리 프로젝트와의 차별점
 
 6. **고유 판매 포인트 (USP)**
-  - 이 이야기만의 독특한 점
-  - 현재 시장에서의 필요성
-  - 제작 가능성
+   - 이 이야기만의 독특한 점
+   - 현재 시장에서의 필요성
+   - 제작 가능성
 
 7. **비주얼 컨셉**
-  - 핵심 비주얼 이미지 3개
-  - 전체적인 룩 & 필
+   - 핵심 비주얼 이미지 3개
+   - 전체적인 룩 & 필
 
 구체적이고 시장성 있는 컨셉을 제시하세요.""",
 
-           "English": f"""You are a Hollywood producer. Develop a commercially viable {screenplay_type} concept.
+            "English": f"""You are a Hollywood producer. Develop a commercially viable {screenplay_type} concept.
 
 **Request:** {user_query}
 **Type:** {SCREENPLAY_LENGTHS[screenplay_type]['description']}
@@ -680,52 +680,52 @@ class ScreenplayGenerationSystem:
 **Required Elements:**
 
 1. **TITLE**
-  - Memorable and marketable
-  - Hints at genre and tone
+   - Memorable and marketable
+   - Hints at genre and tone
 
 2. **LOGLINE**
-  - One sentence, 25 words max
-  - Format: "When [inciting incident], a [protagonist] must [objective] or else [stakes]"
-  - Clear conflict and stakes
+   - One sentence, 25 words max
+   - Format: "When [inciting incident], a [protagonist] must [objective] or else [stakes]"
+   - Clear conflict and stakes
 
 3. **GENRE ANALYSIS**
-  - Primary Genre: {genre}
-  - Sub-genre:
-  - Tone & Mood:
+   - Primary Genre: {genre}
+   - Sub-genre:
+   - Tone & Mood:
 
 4. **TARGET AUDIENCE**
-  - Primary Age Range:
-  - Gender Distribution:
-  - Interests:
-  - Similar Works Fanbase:
+   - Primary Age Range:
+   - Gender Distribution:
+   - Interests:
+   - Similar Works Fanbase:
 
 5. **COMPARABLE FILMS (COMPS)**
-  - 3 successful similar projects
-  - Box office/viewership performance
-  - How ours differs
+   - 3 successful similar projects
+   - Box office/viewership performance
+   - How ours differs
 
 6. **UNIQUE SELLING POINT (USP)**
-  - What makes this story unique
-  - Why now in the market
-  - Production feasibility
+   - What makes this story unique
+   - Why now in the market
+   - Production feasibility
 
 7. **VISUAL CONCEPT**
-  - 3 key visual images
-  - Overall look & feel
+   - 3 key visual images
+   - Overall look & feel
 
 Provide specific, marketable concept."""
-       }
-       
-       return lang_prompts.get(language, lang_prompts["English"])
+        }
+        
+        return lang_prompts.get(language, lang_prompts["English"])
 
-   def create_story_developer_prompt(self, producer_concept: str, user_query: str,
-                                    screenplay_type: str, genre: str, language: str) -> str:
-       """Story developer for synopsis and structure"""
-       
-       genre_template = GENRE_TEMPLATES.get(genre, GENRE_TEMPLATES["drama"])
-       
-       lang_prompts = {
-           "Korean": f"""당신은 스토리 개발자입니다. 프로듀서의 컨셉을 바탕으로 {screenplay_type}의 시놉시스와 3막 구조를 개발하세요.
+    def create_story_developer_prompt(self, producer_concept: str, user_query: str,
+                                     screenplay_type: str, genre: str, language: str) -> str:
+        """Story developer for synopsis and structure"""
+        
+        genre_template = GENRE_TEMPLATES.get(genre, GENRE_TEMPLATES["drama"])
+        
+        lang_prompts = {
+            "Korean": f"""당신은 스토리 개발자입니다. 프로듀서의 컨셉을 바탕으로 {screenplay_type}의 시놉시스와 3막 구조를 개발하세요.
 
 **프로듀서 컨셉:**
 {producer_concept}
@@ -738,54 +738,54 @@ Provide specific, marketable concept."""
 **필수 작성 항목:**
 
 1. **시놉시스 (SYNOPSIS)**
-  - 300-500단어
-  - 3막 구조가 명확히 드러나도록
-  - 주인공의 변화 arc 포함
-  - 주요 전환점 명시
-  - 결말 포함 (스포일러 OK)
+   - 300-500단어
+   - 3막 구조가 명확히 드러나도록
+   - 주인공의 변화 arc 포함
+   - 주요 전환점 명시
+   - 결말 포함 (스포일러 OK)
 
 2. **3막 구조 (THREE-ACT STRUCTURE)**
-  
-  **제1막 - 설정 (Setup) [25%]**
-  - 일상 세계 (Ordinary World):
-  - 근친상간 사건 (Inciting Incident):
-  - 주인공 소개 및 결함:
-  - 1막 전환점 (Plot Point 1):
-  
-  **제2막A - 상승 액션 (Rising Action) [25%]**
-  - 새로운 세계 진입:
-  - 재미와 게임 (Fun and Games):
-  - B 스토리 (관계/테마):
-  - 중간점 (Midpoint) - 가짜 승리/패배:
-  
-  **제2막B - 복잡화 (Complications) [25%]**
-  - 악당의 반격:
-  - 팀 해체/위기:
-  - 모든 것을 잃음 (All Is Lost):
-  - 영혼의 어둔 밤:
-  
-  **제3막 - 해결 (Resolution) [25%]**
-  - 2막 전환점 (Plot Point 2):
-  - 최종 전투 준비:
-  - 클라이맥스:
-  - 새로운 일상:
+   
+   **제1막 - 설정 (Setup) [25%]**
+   - 일상 세계 (Ordinary World):
+   - 근친상간 사건 (Inciting Incident):
+   - 주인공 소개 및 결함:
+   - 1막 전환점 (Plot Point 1):
+   
+   **제2막A - 상승 액션 (Rising Action) [25%]**
+   - 새로운 세계 진입:
+   - 재미와 게임 (Fun and Games):
+   - B 스토리 (관계/테마):
+   - 중간점 (Midpoint) - 가짜 승리/패배:
+   
+   **제2막B - 복잡화 (Complications) [25%]**
+   - 악당의 반격:
+   - 팀 해체/위기:
+   - 모든 것을 잃음 (All Is Lost):
+   - 영혼의 어둔 밤:
+   
+   **제3막 - 해결 (Resolution) [25%]**
+   - 2막 전환점 (Plot Point 2):
+   - 최종 전투 준비:
+   - 클라이맥스:
+   - 새로운 일상:
 
 3. **Save the Cat 비트 시트**
-  15개 비트를 {SCREENPLAY_LENGTHS[screenplay_type]['pages']}페이지에 맞춰 배치
+   15개 비트를 {SCREENPLAY_LENGTHS[screenplay_type]['pages']}페이지에 맞춰 배치
 
 4. **주제 (THEME)**
-  - 중심 주제:
-  - 주제가 드러나는 순간:
-  - 주제의 시각적 표현:
+   - 중심 주제:
+   - 주제가 드러나는 순간:
+   - 주제의 시각적 표현:
 
 5. **톤 & 스타일**
-  - 전체적인 톤:
-  - 유머 사용 여부:
-  - 비주얼 스타일:
+   - 전체적인 톤:
+   - 유머 사용 여부:
+   - 비주얼 스타일:
 
 구체적이고 감정적으로 공감가는 스토리를 만드세요.""",
 
-           "English": f"""You are a story developer. Based on the producer's concept, develop the synopsis and three-act structure for this {screenplay_type}.
+            "English": f"""You are a story developer. Based on the producer's concept, develop the synopsis and three-act structure for this {screenplay_type}.
 
 **Producer Concept:**
 {producer_concept}
@@ -798,62 +798,62 @@ Provide specific, marketable concept."""
 **Required Elements:**
 
 1. **SYNOPSIS**
-  - 300-500 words
-  - Clear three-act structure
-  - Protagonist's change arc
-  - Major turning points
-  - Include ending (spoilers OK)
+   - 300-500 words
+   - Clear three-act structure
+   - Protagonist's change arc
+   - Major turning points
+   - Include ending (spoilers OK)
 
 2. **THREE-ACT STRUCTURE**
-  
-  **ACT 1 - Setup [25%]**
-  - Ordinary World:
-  - Inciting Incident:
-  - Protagonist Introduction & Flaw:
-  - Plot Point 1:
-  
-  **ACT 2A - Rising Action [25%]**
-  - Entering New World:
-  - Fun and Games:
-  - B Story (Relationship/Theme):
-  - Midpoint - False Victory/Defeat:
-  
-  **ACT 2B - Complications [25%]**
-  - Bad Guys Close In:
-  - Team Breaks Down/Crisis:
-  - All Is Lost:
-  - Dark Night of the Soul:
-  
-  **ACT 3 - Resolution [25%]**
-  - Plot Point 2:
-  - Final Battle Preparation:
-  - Climax:
-  - New Normal:
+   
+   **ACT 1 - Setup [25%]**
+   - Ordinary World:
+   - Inciting Incident:
+   - Protagonist Introduction & Flaw:
+   - Plot Point 1:
+   
+   **ACT 2A - Rising Action [25%]**
+   - Entering New World:
+   - Fun and Games:
+   - B Story (Relationship/Theme):
+   - Midpoint - False Victory/Defeat:
+   
+   **ACT 2B - Complications [25%]**
+   - Bad Guys Close In:
+   - Team Breaks Down/Crisis:
+   - All Is Lost:
+   - Dark Night of the Soul:
+   
+   **ACT 3 - Resolution [25%]**
+   - Plot Point 2:
+   - Final Battle Preparation:
+   - Climax:
+   - New Normal:
 
 3. **SAVE THE CAT BEAT SHEET**
-  Place 15 beats across {SCREENPLAY_LENGTHS[screenplay_type]['pages']} pages
+   Place 15 beats across {SCREENPLAY_LENGTHS[screenplay_type]['pages']} pages
 
 4. **THEME**
-  - Central Theme:
-  - Theme Stated Moment:
-  - Visual Theme Expression:
+   - Central Theme:
+   - Theme Stated Moment:
+   - Visual Theme Expression:
 
 5. **TONE & STYLE**
-  - Overall Tone:
-  - Use of Humor:
-  - Visual Style:
+   - Overall Tone:
+   - Use of Humor:
+   - Visual Style:
 
 Create specific, emotionally resonant story."""
-       }
-       
-       return lang_prompts.get(language, lang_prompts["English"])
+        }
+        
+        return lang_prompts.get(language, lang_prompts["English"])
 
-   def create_character_designer_prompt(self, producer_concept: str, story_structure: str,
-                                       genre: str, language: str) -> str:
-       """Character designer prompt"""
-       
-       lang_prompts = {
-           "Korean": f"""당신은 캐릭터 디자이너입니다. 다층적이고 매력적인 캐릭터들을 창조하세요.
+    def create_character_designer_prompt(self, producer_concept: str, story_structure: str,
+                                        genre: str, language: str) -> str:
+        """Character designer prompt"""
+        
+        lang_prompts = {
+            "Korean": f"""당신은 캐릭터 디자이너입니다. 다층적이고 매력적인 캐릭터들을 창조하세요.
 
 **프로듀서 컨셉:**
 {producer_concept}
@@ -864,53 +864,53 @@ Create specific, emotionally resonant story."""
 **필수 캐릭터 프로필:**
 
 1. **주인공 (PROTAGONIST)**
-  - 이름 & 나이:
-  - 직업/역할:
-  - 캐릭터 아크타입:
-  - WANT (외적 목표):
-  - NEED (내적 필요):
-  - 치명적 결함 (Fatal Flaw):
-  - 백스토리 (핵심 상처):
-  - 성격 특성 (3-5개):
-  - 말투 & 언어 패턴:
-  - 시각적 특징:
-  - 캐릭터 아크 (A→B):
+   - 이름 & 나이:
+   - 직업/역할:
+   - 캐릭터 아크타입:
+   - WANT (외적 목표):
+   - NEED (내적 필요):
+   - 치명적 결함 (Fatal Flaw):
+   - 백스토리 (핵심 상처):
+   - 성격 특성 (3-5개):
+   - 말투 & 언어 패턴:
+   - 시각적 특징:
+   - 캐릭터 아크 (A→B):
 
 2. **적대자 (ANTAGONIST)**
-  - 이름 & 나이:
-  - 직업/역할:
-  - 악역 아크타입:
-  - 목표 & 동기:
-  - 주인공과의 연결점:
-  - 정당성 있는 이유:
-  - 약점:
-  - 특징적 행동:
+   - 이름 & 나이:
+   - 직업/역할:
+   - 악역 아크타입:
+   - 목표 & 동기:
+   - 주인공과의 연결점:
+   - 정당성 있는 이유:
+   - 약점:
+   - 특징적 행동:
 
 3. **조력자들 (SUPPORTING CAST)**
-  최소 3명, 각각:
-  - 이름 & 역할:
-  - 주인공과의 관계:
-  - 스토리 기능:
-  - 독특한 특성:
-  - 기여하는 바:
+   최소 3명, 각각:
+   - 이름 & 역할:
+   - 주인공과의 관계:
+   - 스토리 기능:
+   - 독특한 특성:
+   - 기여하는 바:
 
 4. **캐릭터 관계도**
-  - 주요 관계 역학:
-  - 갈등 구조:
-  - 감정적 연결:
-  - 파워 다이나믹:
+   - 주요 관계 역학:
+   - 갈등 구조:
+   - 감정적 연결:
+   - 파워 다이나믹:
 
 5. **캐스팅 제안**
-  - 각 주요 캐릭터별 이상적인 배우 타입
-  - 연령대, 외모, 연기 스타일
+   - 각 주요 캐릭터별 이상적인 배우 타입
+   - 연령대, 외모, 연기 스타일
 
 6. **대화 샘플**
-  - 각 주요 캐릭터의 시그니처 대사 2-3개
-  - 캐릭터의 본질을 드러내는 대화
+   - 각 주요 캐릭터의 시그니처 대사 2-3개
+   - 캐릭터의 본질을 드러내는 대화
 
 각 캐릭터가 테마를 구현하고 스토리를 추진하도록 디자인하세요.""",
 
-           "English": f"""You are a character designer. Create multi-dimensional, compelling characters.
+            "English": f"""You are a character designer. Create multi-dimensional, compelling characters.
 
 **Producer Concept:**
 {producer_concept}
@@ -921,63 +921,63 @@ Create specific, emotionally resonant story."""
 **Required Character Profiles:**
 
 1. **PROTAGONIST**
-  - Name & Age:
-  - Occupation/Role:
-  - Character Archetype:
-  - WANT (External Goal):
-  - NEED (Internal Need):
-  - Fatal Flaw:
-  - Backstory (Core Wound):
-  - Personality Traits (3-5):
-  - Speech Pattern:
-  - Visual Characteristics:
-  - Character Arc (A→B):
+   - Name & Age:
+   - Occupation/Role:
+   - Character Archetype:
+   - WANT (External Goal):
+   - NEED (Internal Need):
+   - Fatal Flaw:
+   - Backstory (Core Wound):
+   - Personality Traits (3-5):
+   - Speech Pattern:
+   - Visual Characteristics:
+   - Character Arc (A→B):
 
 2. **ANTAGONIST**
-  - Name & Age:
-  - Occupation/Role:
-  - Villain Archetype:
-  - Goal & Motivation:
-  - Connection to Protagonist:
-  - Justifiable Reason:
-  - Weakness:
-  - Signature Behaviors:
+   - Name & Age:
+   - Occupation/Role:
+   - Villain Archetype:
+   - Goal & Motivation:
+   - Connection to Protagonist:
+   - Justifiable Reason:
+   - Weakness:
+   - Signature Behaviors:
 
 3. **SUPPORTING CAST**
-  Minimum 3, each with:
-  - Name & Role:
-  - Relationship to Protagonist:
-  - Story Function:
-  - Unique Traits:
-  - What They Contribute:
+   Minimum 3, each with:
+   - Name & Role:
+   - Relationship to Protagonist:
+   - Story Function:
+   - Unique Traits:
+   - What They Contribute:
 
 4. **CHARACTER RELATIONSHIPS**
-  - Key Relationship Dynamics:
-  - Conflict Structure:
-  - Emotional Connections:
-  - Power Dynamics:
+   - Key Relationship Dynamics:
+   - Conflict Structure:
+   - Emotional Connections:
+   - Power Dynamics:
 
 5. **CASTING SUGGESTIONS**
-  - Ideal actor type for each major character
-  - Age range, appearance, acting style
+   - Ideal actor type for each major character
+   - Age range, appearance, acting style
 
 6. **DIALOGUE SAMPLES**
-  - 2-3 signature lines per major character
-  - Dialogue revealing character essence
+   - 2-3 signature lines per major character
+   - Dialogue revealing character essence
 
 Design each character to embody theme and drive story."""
-       }
-       
-       return lang_prompts.get(language, lang_prompts["English"])
+        }
+        
+        return lang_prompts.get(language, lang_prompts["English"])
 
-   def create_scene_planner_prompt(self, story_structure: str, characters: str,
-                                  screenplay_type: str, genre: str, language: str) -> str:
-       """Scene breakdown planner"""
-       
-       total_pages = SCREENPLAY_LENGTHS[screenplay_type]['pages']
-       
-       lang_prompts = {
-           "Korean": f"""당신은 씬 플래너입니다. {total_pages}페이지 {screenplay_type}의 상세한 씬 브레이크다운을 작성하세요.
+    def create_scene_planner_prompt(self, story_structure: str, characters: str,
+                                   screenplay_type: str, genre: str, language: str) -> str:
+        """Scene breakdown planner"""
+        
+        total_pages = SCREENPLAY_LENGTHS[screenplay_type]['pages']
+        
+        lang_prompts = {
+            "Korean": f"""당신은 씬 플래너입니다. {total_pages}페이지 {screenplay_type}의 상세한 씬 브레이크다운을 작성하세요.
 
 **스토리 구조:**
 {story_structure}
@@ -1015,7 +1015,7 @@ Design each character to embody theme and drive story."""
 
 각 씬이 스토리를 전진시키고 캐릭터를 발전시키도록 계획하세요.""",
 
-           "English": f"""You are a scene planner. Create detailed scene breakdown for {total_pages}-page {screenplay_type}.
+            "English": f"""You are a scene planner. Create detailed scene breakdown for {total_pages}-page {screenplay_type}.
 
 **Story Structure:**
 {story_structure}
@@ -1052,19 +1052,19 @@ For each scene provide:
 - DISSOLVE TO:
 
 Plan each scene to advance story and develop character."""
-       }
-       
-       return lang_prompts.get(language, lang_prompts["English"])
+        }
+        
+        return lang_prompts.get(language, lang_prompts["English"])
 
-   def create_screenwriter_prompt(self, act: str, scene_breakdown: str, 
-                                 characters: str, previous_acts: str,
-                                 screenplay_type: str, genre: str, language: str) -> str:
-       """Screenwriter prompt for actual screenplay pages"""
-       
-       act_pages = int(SCREENPLAY_LENGTHS[screenplay_type]['pages'] * 0.25)
-       
-       lang_prompts = {
-           "Korean": f"""당신은 프로 시나리오 작가입니다. {act}을 표준 시나리오 포맷으로 작성하세요.
+    def create_screenwriter_prompt(self, act: str, scene_breakdown: str, 
+                                  characters: str, previous_acts: str,
+                                  screenplay_type: str, genre: str, language: str) -> str:
+        """Screenwriter prompt for actual screenplay pages"""
+        
+        act_pages = int(SCREENPLAY_LENGTHS[screenplay_type]['pages'] * 0.25)
+        
+        lang_prompts = {
+            "Korean": f"""당신은 프로 시나리오 작가입니다. {act}을 표준 시나리오 포맷으로 작성하세요.
 
 **타겟 분량:** {act_pages}페이지
 
@@ -1080,29 +1080,29 @@ Plan each scene to advance story and develop character."""
 **시나리오 포맷 규칙:**
 
 1. **씬 헤딩**
-  INT. 장소 - 시간
-  EXT. 장소 - 시간
+   INT. 장소 - 시간
+   EXT. 장소 - 시간
 
 2. **액션 라인**
-  - 현재 시제 사용
-  - 시각적으로 보이는 것만 묘사
-  - 4줄 이하로 유지
-  - 감정은 행동으로 표현
+   - 현재 시제 사용
+   - 시각적으로 보이는 것만 묘사
+   - 4줄 이하로 유지
+   - 감정은 행동으로 표현
 
 3. **캐릭터 소개**
-  첫 등장시: 이름 (나이) 간단한 묘사
+   첫 등장시: 이름 (나이) 간단한 묘사
 
 4. **대화**
-  캐릭터명
-  (지문)
-  대사
+   캐릭터명
+   (지문)
+   대사
 
 5. **중요 원칙**
-  - Show, don't tell
-  - 서브텍스트 활용
-  - 자연스러운 대화
-  - 시각적 스토리텔링
-  - 페이지당 1분 규칙
+   - Show, don't tell
+   - 서브텍스트 활용
+   - 자연스러운 대화
+   - 시각적 스토리텔링
+   - 페이지당 1분 규칙
 
 **{genre} 장르 특성:**
 - 대화 비율: {GENRE_TEMPLATES[genre]['dialogue_ratio']*100}%
@@ -1111,7 +1111,7 @@ Plan each scene to advance story and develop character."""
 
 정확한 포맷과 몰입감 있는 스토리텔링으로 작성하세요.""",
 
-           "English": f"""You are a professional screenwriter. Write {act} in standard screenplay format.
+            "English": f"""You are a professional screenwriter. Write {act} in standard screenplay format.
 
 **Target Length:** {act_pages} pages
 
@@ -1127,29 +1127,29 @@ Plan each scene to advance story and develop character."""
 **Screenplay Format Rules:**
 
 1. **Scene Headings**
-  INT. LOCATION - TIME
-  EXT. LOCATION - TIME
+   INT. LOCATION - TIME
+   EXT. LOCATION - TIME
 
 2. **Action Lines**
-  - Present tense
-  - Only what's visually seen
-  - Keep under 4 lines
-  - Emotions through actions
+   - Present tense
+   - Only what's visually seen
+   - Keep under 4 lines
+   - Emotions through actions
 
 3. **Character Intros**
-  First appearance: NAME (age) brief description
+   First appearance: NAME (age) brief description
 
 4. **Dialogue**
-  CHARACTER NAME
-  (parenthetical)
-  Dialogue
+   CHARACTER NAME
+   (parenthetical)
+   Dialogue
 
 5. **Key Principles**
-  - Show, don't tell
-  - Use subtext
-  - Natural dialogue
-  - Visual storytelling
-  - One page = one minute
+   - Show, don't tell
+   - Use subtext
+   - Natural dialogue
+   - Visual storytelling
+   - One page = one minute
 
 **{genre} Genre Characteristics:**
 - Dialogue Ratio: {GENRE_TEMPLATES[genre]['dialogue_ratio']*100}%
@@ -1157,16 +1157,16 @@ Plan each scene to advance story and develop character."""
 - Key Elements: {', '.join(GENRE_TEMPLATES[genre]['key_elements'][:2])}
 
 Write with proper format and engaging storytelling."""
-       }
-       
-       return lang_prompts.get(language, lang_prompts["English"])
+        }
+        
+        return lang_prompts.get(language, lang_prompts["English"])
 
-   def create_script_doctor_prompt(self, act_content: str, act: str,
-                                  genre: str, language: str) -> str:
-       """Script doctor review and polish"""
-       
-       lang_prompts = {
-           "Korean": f"""당신은 스크립트 닥터입니다. {act}를 검토하고 개선 사항을 제시하세요.
+    def create_script_doctor_prompt(self, act_content: str, act: str,
+                                   genre: str, language: str) -> str:
+        """Script doctor review and polish"""
+        
+        lang_prompts = {
+            "Korean": f"""당신은 스크립트 닥터입니다. {act}를 검토하고 개선 사항을 제시하세요.
 
 **작성된 내용:**
 {act_content}
@@ -1174,37 +1174,37 @@ Write with proper format and engaging storytelling."""
 **검토 항목:**
 
 1. **포맷 정확성**
-  - 씬 헤딩 형식
-  - 액션 라인 길이
-  - 대화 포맷
-  - 전환 표시
+   - 씬 헤딩 형식
+   - 액션 라인 길이
+   - 대화 포맷
+   - 전환 표시
 
 2. **스토리텔링**
-  - 시각적 명확성
-  - 페이싱
-  - 긴장감 구축
-  - 씬 목적 달성
+   - 시각적 명확성
+   - 페이싱
+   - 긴장감 구축
+   - 씬 목적 달성
 
 3. **대화 품질**
-  - 자연스러움
-  - 캐릭터 고유성
-  - 서브텍스트
-  - 불필요한 설명 제거
+   - 자연스러움
+   - 캐릭터 고유성
+   - 서브텍스트
+   - 불필요한 설명 제거
 
 4. **{genre} 장르 적합성**
-  - 장르 관습 준수
-  - 톤 일관성
-  - 기대 충족
+   - 장르 관습 준수
+   - 톤 일관성
+   - 기대 충족
 
 5. **기술적 측면**
-  - 페이지 수 적정성
-  - 제작 가능성
-  - 예산 고려사항
+   - 페이지 수 적정성
+   - 제작 가능성
+   - 예산 고려사항
 
 **필수 개선사항:**
 구체적인 수정 제안과 개선된 예시를 제공하세요.""",
 
-           "English": f"""You are a script doctor. Review and provide improvements for {act}.
+            "English": f"""You are a script doctor. Review and provide improvements for {act}.
 
 **Written Content:**
 {act_content}
@@ -1212,71 +1212,71 @@ Write with proper format and engaging storytelling."""
 **Review Areas:**
 
 1. **Format Accuracy**
-  - Scene heading format
-  - Action line length
-  - Dialogue format
-  - Transitions
+   - Scene heading format
+   - Action line length
+   - Dialogue format
+   - Transitions
 
 2. **Storytelling**
-  - Visual clarity
-  - Pacing
-  - Tension building
-  - Scene purpose achievement
+   - Visual clarity
+   - Pacing
+   - Tension building
+   - Scene purpose achievement
 
 3. **Dialogue Quality**
-  - Naturalness
-  - Character uniqueness
-  - Subtext
-  - Remove exposition
+   - Naturalness
+   - Character uniqueness
+   - Subtext
+   - Remove exposition
 
 4. **{genre} Genre Fit**
-  - Genre conventions
-  - Tone consistency
-  - Meeting expectations
+   - Genre conventions
+   - Tone consistency
+   - Meeting expectations
 
 5. **Technical Aspects**
-  - Page count appropriateness
-  - Production feasibility
-  - Budget considerations
+   - Page count appropriateness
+   - Production feasibility
+   - Budget considerations
 
 **Required Improvements:**
 Provide specific revision suggestions with improved examples."""
-       }
-       
-       return lang_prompts.get(language, lang_prompts["English"])
+        }
+        
+        return lang_prompts.get(language, lang_prompts["English"])
 
-   def create_final_reviewer_prompt(self, complete_screenplay: str, 
-                                  screenplay_type: str, genre: str, language: str) -> str:
-       """Final comprehensive review"""
-       
-       lang_prompts = {
-           "Korean": f"""당신은 최종 리뷰어입니다. 완성된 {screenplay_type} 시나리오를 종합 평가하세요.
+    def create_final_reviewer_prompt(self, complete_screenplay: str, 
+                                   screenplay_type: str, genre: str, language: str) -> str:
+        """Final comprehensive review"""
+        
+        lang_prompts = {
+            "Korean": f"""당신은 최종 리뷰어입니다. 완성된 {screenplay_type} 시나리오를 종합 평가하세요.
 
 **평가 기준:**
 
 1. **상업성 (25점)**
-  - 시장성
-  - 타겟 관객 어필
-  - 제작 가능성
-  - 배급 잠재력
+   - 시장성
+   - 타겟 관객 어필
+   - 제작 가능성
+   - 배급 잠재력
 
 2. **스토리 (25점)**
-  - 3막 구조 효과성
-  - 캐릭터 아크
-  - 플롯 일관성
-  - 테마 전달
+   - 3막 구조 효과성
+   - 캐릭터 아크
+   - 플롯 일관성
+   - 테마 전달
 
 3. **기술적 완성도 (25점)**
-  - 포맷 정확성
-  - 페이지 수 적정성
-  - 씬 구성
-  - 시각적 스토리텔링
+   - 포맷 정확성
+   - 페이지 수 적정성
+   - 씬 구성
+   - 시각적 스토리텔링
 
 4. **대화 & 캐릭터 (25점)**
-  - 대화 자연스러움
-  - 캐릭터 고유성
-  - 관계 역학
-  - 감정적 진정성
+   - 대화 자연스러움
+   - 캐릭터 고유성
+   - 관계 역학
+   - 감정적 진정성
 
 **종합 평가:**
 - 강점 (3-5개)
@@ -1288,33 +1288,33 @@ Provide specific revision suggestions with improved examples."""
 
 구체적이고 건설적인 피드백을 제공하세요.""",
 
-           "English": f"""You are the final reviewer. Comprehensively evaluate the completed {screenplay_type} screenplay.
+            "English": f"""You are the final reviewer. Comprehensively evaluate the completed {screenplay_type} screenplay.
 
 **Evaluation Criteria:**
 
 1. **Commercial Viability (25 points)**
-  - Marketability
-  - Target audience appeal
-  - Production feasibility
-  - Distribution potential
+   - Marketability
+   - Target audience appeal
+   - Production feasibility
+   - Distribution potential
 
 2. **Story (25 points)**
-  - Three-act structure effectiveness
-  - Character arcs
-  - Plot consistency
-  - Theme delivery
+   - Three-act structure effectiveness
+   - Character arcs
+   - Plot consistency
+   - Theme delivery
 
 3. **Technical Excellence (25 points)**
-  - Format accuracy
-  - Page count appropriateness
-  - Scene construction
-  - Visual storytelling
+   - Format accuracy
+   - Page count appropriateness
+   - Scene construction
+   - Visual storytelling
 
 4. **Dialogue & Character (25 points)**
-  - Dialogue naturalness
-  - Character uniqueness
-  - Relationship dynamics
-  - Emotional authenticity
+   - Dialogue naturalness
+   - Character uniqueness
+   - Relationship dynamics
+   - Emotional authenticity
 
 **Overall Assessment:**
 - Strengths (3-5)
@@ -1325,218 +1325,307 @@ Provide specific revision suggestions with improved examples."""
 **Grade:** A+ to F
 
 Provide specific, constructive feedback."""
-       }
-       
-       return lang_prompts.get(language, lang_prompts["English"])
-
-   def _get_genre_scene_guidelines(self, genre: str, language: str) -> str:
-       """Get genre-specific scene guidelines"""
-       guidelines = {
-           "action": {
-               "Korean": "- 짧고 펀치감 있는 씬\n- 액션 시퀀스 상세 계획\n- 긴장감 지속",
-               "English": "- Short, punchy scenes\n- Detailed action sequences\n- Maintain tension"
-           },
-           "thriller": {
-               "Korean": "- 서스펜스 구축\n- 정보 점진적 공개\n- 반전 배치",
-               "English": "- Build suspense\n- Gradual information reveal\n- Place twists"
-           },
-           "drama": {
-               "Korean": "- 감정적 비트 강조\n- 캐릭터 중심 씬\n- 대화 공간 확보",
-               "English": "- Emphasize emotional beats\n- Character-driven scenes\n- Allow dialogue space"
-           },
-           "comedy": {
-               "Korean": "- 셋업과 페이오프\n- 코믹 타이밍\n- 시각적 개그",
-               "English": "- Setup and payoff\n- Comic timing\n- Visual gags"
-           },
-           "horror": {
-               "Korean": "- 분위기 조성\n- 점프 스케어 배치\n- 긴장과 이완",
-               "English": "- Atmosphere building\n- Jump scare placement\n- Tension and release"
-           },
-           "sci-fi": {
-               "Korean": "- 세계관 설명\n- 시각적 스펙터클\n- 개념 소개",
-               "English": "- World building\n- Visual spectacle\n- Concept introduction"
-           },
-           "romance": {
-               "Korean": "- 감정적 친밀감\n- 관계 발전\n- 로맨틱 비트",
-               "English": "- Emotional intimacy\n- Relationship progression\n- Romantic beats"
-           }
-       }
-       
-       return guidelines.get(genre, guidelines["drama"]).get(language, "")
-
-   def _extract_act_scenes(self, scene_breakdown: str, act: str) -> str:
-       """Extract scenes for specific act"""
-       # This would parse the scene breakdown and return only scenes for the requested act
-       # For now, returning a placeholder
-       return f"Scenes for {act} from the breakdown"
-
-   # --- LLM call functions ---
-   def call_llm_sync(self, messages: List[Dict[str, str]], role: str, language: str) -> str:
-       full_content = ""
-       for chunk in self.call_llm_streaming(messages, role, language):
-           full_content += chunk
-       if full_content.startswith("❌"):
-           raise Exception(f"LLM Call Failed: {full_content}")
-       return full_content
-
-   def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, 
-                         language: str) -> Generator[str, None, None]:
-       try:
-           system_prompts = self.get_system_prompts(language)
-           full_messages = [{"role": "system", "content": system_prompts.get(role, "")}, *messages]
-           
-           max_tokens = 15000 if role == "screenwriter" else 8000
-           
-           payload = {
-               "model": self.model_id,
-               "messages": full_messages,
-               "max_tokens": max_tokens,
-               "temperature": 0.7 if role in ["screenwriter", "script_doctor"] else 0.8,
-               "top_p": 0.9,
-               "presence_penalty": 0.3,
-               "frequency_penalty": 0.3,
-               "stream": True
-           }
-           
-           response = requests.post(
-               self.api_url, 
-               headers=self.create_headers(), 
-               json=payload, 
-               stream=True, 
-               timeout=180
-           )
-           
-           if response.status_code != 200:
-               yield f"❌ API Error (Status Code: {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)
-                   choices = data.get("choices", [])
-                   if choices and choices[0].get("delta", {}).get("content"):
-                       content = choices[0]["delta"]["content"]
-                       buffer += content
-                       
-                       if len(buffer) >= 50 or '\n' in buffer:
-                           yield buffer
-                           buffer = ""
-                           time.sleep(0.01)
-                   
-               except Exception as e:
-                   logger.error(f"Chunk processing error: {str(e)}")
-                   continue
-           
-           if buffer:
-               yield buffer
-               
-       except Exception as e:
-           logger.error(f"Streaming error: {type(e).__name__}: {str(e)}")
-           yield f"❌ Error occurred: {str(e)}"
+        }
+        
+        return lang_prompts.get(language, lang_prompts["English"])
 
-   def get_system_prompts(self, language: str) -> Dict[str, str]:
-       """Role-specific system prompts"""
-       
-       base_prompts = {
-           "Korean": {
-               "producer": """당신은 20년 경력의 할리우드 프로듀서입니다.
+    def create_critic_structure_prompt(self, story_structure: str, characters: str,
+                                     screenplay_type: str, genre: str, language: str) -> str:
+        """Structure critic prompt"""
+        lang_prompts = {
+            "Korean": f"""당신은 구조 비평가입니다. 스토리 구조와 캐릭터 설정을 심층 분석하세요.
+
+**스토리 구조:**
+{story_structure}
+
+**캐릭터 설정:**
+{characters}
+
+**분석 항목:**
+
+1. **3막 구조 효과성**
+   - 각 막의 균형
+   - 전환점의 강도
+   - 플롯 포인트의 명확성
+   - 클라이맥스 위치
+
+2. **캐릭터 아크 타당성**
+   - 변화의 신빙성
+   - 동기의 명확성
+   - 내적/외적 목표 일치
+   - 관계 역학
+
+3. **테마 통합**
+   - 테마의 일관성
+   - 플롯과 테마 연결
+   - 캐릭터와 테마 연결
+   - 시각적 테마 표현
+
+4. **장르 기대치**
+   - {genre} 관습 충족
+   - 독창성과 친숙함 균형
+   - 타겟 관객 만족도
+
+5. **제작 현실성**
+   - 예산 규모 적정성
+   - 로케이션 실현 가능성
+   - 특수효과 요구사항
+
+**필수 개선 제안:**
+각 문제점에 대한 구체적 해결책을 제시하세요.""",
+
+            "English": f"""You are a structure critic. Deeply analyze story structure and character setup.
+
+**Story Structure:**
+{story_structure}
+
+**Character Setup:**
+{characters}
+
+**Analysis Items:**
+
+1. **Three-Act Structure Effectiveness**
+   - Balance of each act
+   - Strength of transitions
+   - Clarity of plot points
+   - Climax positioning
+
+2. **Character Arc Validity**
+   - Credibility of change
+   - Clarity of motivation
+   - Internal/external goal alignment
+   - Relationship dynamics
+
+3. **Theme Integration**
+   - Theme consistency
+   - Plot-theme connection
+   - Character-theme connection
+   - Visual theme expression
+
+4. **Genre Expectations**
+   - Meeting {genre} conventions
+   - Balance of originality and familiarity
+   - Target audience satisfaction
+
+5. **Production Reality**
+   - Budget scale appropriateness
+   - Location feasibility
+   - Special effects requirements
+
+**Required Improvement Suggestions:**
+Provide specific solutions for each issue."""
+        }
+        
+        return lang_prompts.get(language, lang_prompts["English"])
+
+    def _get_genre_scene_guidelines(self, genre: str, language: str) -> str:
+        """Get genre-specific scene guidelines"""
+        guidelines = {
+            "action": {
+                "Korean": "- 짧고 펀치감 있는 씬\n- 액션 시퀀스 상세 계획\n- 긴장감 지속",
+                "English": "- Short, punchy scenes\n- Detailed action sequences\n- Maintain tension"
+            },
+            "thriller": {
+                "Korean": "- 서스펜스 구축\n- 정보 점진적 공개\n- 반전 배치",
+                "English": "- Build suspense\n- Gradual information reveal\n- Place twists"
+            },
+            "drama": {
+                "Korean": "- 감정적 비트 강조\n- 캐릭터 중심 씬\n- 대화 공간 확보",
+                "English": "- Emphasize emotional beats\n- Character-driven scenes\n- Allow dialogue space"
+            },
+            "comedy": {
+                "Korean": "- 셋업과 페이오프\n- 코믹 타이밍\n- 시각적 개그",
+                "English": "- Setup and payoff\n- Comic timing\n- Visual gags"
+            },
+            "horror": {
+                "Korean": "- 분위기 조성\n- 점프 스케어 배치\n- 긴장과 이완",
+                "English": "- Atmosphere building\n- Jump scare placement\n- Tension and release"
+            },
+            "sci-fi": {
+                "Korean": "- 세계관 설명\n- 시각적 스펙터클\n- 개념 소개",
+                "English": "- World building\n- Visual spectacle\n- Concept introduction"
+            },
+            "romance": {
+                "Korean": "- 감정적 친밀감\n- 관계 발전\n- 로맨틱 비트",
+                "English": "- Emotional intimacy\n- Relationship progression\n- Romantic beats"
+            }
+        }
+        
+        return guidelines.get(genre, guidelines["drama"]).get(language, "")
+
+    def _extract_act_scenes(self, scene_breakdown: str, act: str) -> str:
+        """Extract scenes for specific act"""
+        # This would parse the scene breakdown and return only scenes for the requested act
+        # For now, returning a placeholder
+        return f"Scenes for {act} from the breakdown"
+
+    # --- LLM call functions ---
+    def call_llm_sync(self, messages: List[Dict[str, str]], role: str, language: str) -> str:
+        full_content = ""
+        for chunk in self.call_llm_streaming(messages, role, language):
+            full_content += chunk
+        if full_content.startswith("❌"):
+            raise Exception(f"LLM Call Failed: {full_content}")
+        return full_content
+
+    def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, 
+                          language: str) -> Generator[str, None, None]:
+        try:
+            system_prompts = self.get_system_prompts(language)
+            full_messages = [{"role": "system", "content": system_prompts.get(role, "")}, *messages]
+            
+            max_tokens = 15000 if role == "screenwriter" else 8000
+            
+            payload = {
+                "model": self.model_id,
+                "messages": full_messages,
+                "max_tokens": max_tokens,
+                "temperature": 0.7 if role in ["screenwriter", "script_doctor"] else 0.8,
+                "top_p": 0.9,
+                "presence_penalty": 0.3,
+                "frequency_penalty": 0.3,
+                "stream": True
+            }
+            
+            response = requests.post(
+                self.api_url, 
+                headers=self.create_headers(), 
+                json=payload, 
+                stream=True, 
+                timeout=180
+            )
+            
+            if response.status_code != 200:
+                yield f"❌ API Error (Status Code: {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)
+                    choices = data.get("choices", [])
+                    if choices and choices[0].get("delta", {}).get("content"):
+                        content = choices[0]["delta"]["content"]
+                        buffer += content
+                        
+                        if len(buffer) >= 50 or '\n' in buffer:
+                            yield buffer
+                            buffer = ""
+                            time.sleep(0.01)
+                    
+                except Exception as e:
+                    logger.error(f"Chunk processing error: {str(e)}")
+                    continue
+            
+            if buffer:
+                yield buffer
+                
+        except Exception as e:
+            logger.error(f"Streaming error: {type(e).__name__}: {str(e)}")
+            yield f"❌ Error occurred: {str(e)}"
+
+    def get_system_prompts(self, language: str) -> Dict[str, str]:
+        """Role-specific system prompts"""
+        
+        base_prompts = {
+            "Korean": {
+                "producer": """당신은 20년 경력의 할리우드 프로듀서입니다.
 상업적 성공과 예술적 가치를 모두 추구합니다.
 시장 트렌드와 관객 심리를 정확히 파악합니다.
 실현 가능하고 매력적인 프로젝트를 개발합니다.""",
-               
-               "story_developer": """당신은 수상 경력이 있는 스토리 개발자입니다.
+                
+                "story_developer": """당신은 수상 경력이 있는 스토리 개발자입니다.
 감정적으로 공감가고 구조적으로 탄탄한 이야기를 만듭니다.
 캐릭터의 내적 여정과 외적 ���롯을 조화롭게 엮습니다.
 보편적 주제를 독특한 방식으로 탐구합니다.""",
-               
-               "character_designer": """당신은 심리학을 공부한 캐릭터 디자이너입니다.
+                
+                "character_designer": """당신은 심리학을 공부한 캐릭터 디자이너입니다.
 진짜 같은 인물들을 창조하는 전문가입니다.
 각 캐릭터에게 고유한 목소리와 관점을 부여합니다.
 복잡하고 모순적인 인간성을 포착합니다.""",
-               
-               "scene_planner": """당신은 정밀한 씬 구성의 대가입니다.
+                
+                "scene_planner": """당신은 정밀한 씬 구성의 대가입니다.
 각 씬이 스토리와 캐릭터를 전진시키도록 설계합니다.
 리듬과 페이싱을 완벽하게 조절합니다.
 시각적 스토리텔링을 극대화합니다.""",
-               
-               "screenwriter": """당신은 다작의 시나리오 작가입니다.
+                
+                "screenwriter": """당신은 다작의 시나리오 작가입니다.
 '보여주기'의 대가이며 서브텍스트를 능숙하게 다룹니다.
 생생하고 자연스러운 대화를 쓰는 전문가입니다.
 제작 현실을 고려하면서도 창의적인 해결책을 찾습니다.""",
-               
-               "script_doctor": """당신은 까다로운 스크립트 닥터입니다.
+                
+                "script_doctor": """당신은 까다로운 스크립트 닥터입니다.
 작은 디테일도 놓치지 않는 완벽주의자입니다.
 스토리의 잠재력을 최대한 끌어냅니다.
 건설적이고 구체적인 개선안을 제시합니다.""",
-               
-               "critic_structure": """당신은 구조 분석 전문가입니다.
+                
+                "critic_structure": """당신은 구조 분석 전문가입니다.
 스토리의 뼈대와 근육을 꿰뚫어 봅니다.
 논리적 허점과 감정적 공백을 찾아냅니다.
 더 나은 구조를 위한 구체적 제안을 합니다.""",
-               
-               "final_reviewer": """당신은 업계 베테랑 최종 리뷰어입니다.
+                
+                "final_reviewer": """당신은 업계 베테랑 최종 리뷰어입니다.
 상업성과 예술성을 균형있게 평가합니다.
 제작사, 배우, 관객 모든 관점을 고려합니다.
 냉정하지만 격려하는 피드백을 제공합니다."""
-           },
-           "English": {
-               "producer": """You are a Hollywood producer with 20 years experience.
+            },
+            "English": {
+                "producer": """You are a Hollywood producer with 20 years experience.
 You pursue both commercial success and artistic value.
 You accurately grasp market trends and audience psychology.
 You develop feasible and attractive projects.""",
-               
-               "story_developer": """You are an award-winning story developer.
+                
+                "story_developer": """You are an award-winning story developer.
 You create emotionally resonant and structurally sound stories.
 You harmoniously weave internal journeys with external plots.
 You explore universal themes in unique ways.""",
-               
-               "character_designer": """You are a character designer who studied psychology.
+                
+                "character_designer": """You are a character designer who studied psychology.
 You're an expert at creating lifelike characters.
 You give each character a unique voice and perspective.
 You capture complex and contradictory humanity.""",
-               
-               "scene_planner": """You are a master of precise scene construction.
+                
+                "scene_planner": """You are a master of precise scene construction.
 You design each scene to advance story and character.
 You perfectly control rhythm and pacing.
 You maximize visual storytelling.""",
-               
-               "screenwriter": """You are a prolific screenwriter.
+                
+                "screenwriter": """You are a prolific screenwriter.
 You're a master of 'showing' and skilled with subtext.
 You're an expert at writing vivid, natural dialogue.
 You find creative solutions while considering production reality.""",
-               
-               "script_doctor": """You are a demanding script doctor.
+                
+                "script_doctor": """You are a demanding script doctor.
 You're a perfectionist who misses no small detail.
 You maximize the story's potential.
 You provide constructive and specific improvements.""",
-               
-               "critic_structure": """You are a structure analysis expert.
+                
+                "critic_structure": """You are a structure analysis expert.
 You see through the story's skeleton and muscles.
 You find logical gaps and emotional voids.
 You make specific suggestions for better structure.""",
-               
-               "final_reviewer": """You are an industry veteran final reviewer.
+                
+                "final_reviewer": """You are an industry veteran final reviewer.
 You evaluate commercial and artistic value in balance.
 You consider all perspectives: producers, actors, audience.
 You provide feedback that's critical yet encouraging."""
-           }
-       }
-       
-       return base_prompts.get(language, base_prompts["English"])
+            }
+        }
+        
+        return base_prompts.get(language, base_prompts["English"])
 
-# --- Main process ---
+    # --- Main process ---
     def process_screenplay_stream(self, query: str, screenplay_type: str, genre: str,
                                 language: str, session_id: Optional[str] = None
                                 ) -> Generator[Tuple[str, List[Dict[str, Any]], str], None, None]:
@@ -1629,266 +1718,175 @@ You provide feedback that's critical yet encouraging."""
             logger.error(f"Screenplay generation error: {e}", exc_info=True)
             yield f"❌ Error occurred: {e}", stages if 'stages' in locals() else [], self.current_session_id
 
-
-
     def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
-                       screenplay_type: str, genre: str, language: str, 
-                       stages: List[Dict]) -> str:
-       """Generate stage-specific prompt"""
-       if stage_idx == 0:  # Producer
-           return self.create_producer_prompt(query, screenplay_type, genre, language)
-       
-       if stage_idx == 1:  # Story Developer
-           return self.create_story_developer_prompt(
-               stages[0]["content"], query, screenplay_type, genre, language
-           )
-       
-       if stage_idx == 2:  # Character Designer
-           return self.create_character_designer_prompt(
-               stages[0]["content"], stages[1]["content"], genre, language
-           )
-       
-       if stage_idx == 3:  # Structure Critic
-           return self.create_critic_structure_prompt(
-               stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
-           )
-       
-       if stage_idx == 4:  # Scene Planner
-           return self.create_scene_planner_prompt(
-               stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
-           )
-       
-       # Screenwriter acts
-       if role == "screenwriter":
-           act_mapping = {5: "Act 1", 7: "Act 2A", 9: "Act 2B", 11: "Act 3"}
-           if stage_idx in act_mapping:
-               act = act_mapping[stage_idx]
-               previous_acts = self._get_previous_acts(stages, stage_idx)
-               return self.create_screenwriter_prompt(
-                   act, stages[4]["content"], stages[2]["content"], 
-                   previous_acts, screenplay_type, genre, language
-               )
-       
-       # Script doctor reviews
-       if role == "script_doctor":
-           act_mapping = {6: "Act 1", 8: "Act 2A", 10: "Act 2B"}
-           if stage_idx in act_mapping:
-               act = act_mapping[stage_idx]
-               act_content = stages[stage_idx-1]["content"]
-               return self.create_script_doctor_prompt(act_content, act, genre, language)
-       
-       # Final reviewer
-       if role == "final_reviewer":
-           complete_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
-           return self.create_final_reviewer_prompt(
-               complete_screenplay, screenplay_type, genre, language
-           )
-       
-       return ""
-
-    def create_critic_structure_prompt(self, story_structure: str, characters: str,
-                                    screenplay_type: str, genre: str, language: str) -> str:
-       """Structure critic prompt"""
-       lang_prompts = {
-           "Korean": f"""당신은 구조 비평가입니다. 스토리 구조와 캐릭터 설정을 심층 분석하세요.
-
-**스토리 구조:**
-{story_structure}
-
-**캐릭터 설정:**
-{characters}
-
-**분석 항목:**
-
-1. **3막 구조 효과성**
-  - 각 막의 균형
-  - 전환점의 강도
-  - 플롯 포인트의 명확성
-  - 클라이맥스 위치
-
-2. **캐릭터 아크 타당성**
-  - 변화의 신빙성
-  - 동기의 명확성
-  - 내적/외적 목표 일치
-  - 관계 역학
-
-3. **테마 통합**
-  - 테마의 일관성
-  - 플롯과 테마 연결
-  - 캐릭터와 테마 연결
-  - 시각적 테마 표현
-
-4. **장르 기대치**
-  - {genre} 관습 충족
-  - 독창성과 친숙함 균형
-  - 타겟 관객 만족도
-
-5. **제작 현실성**
-  - 예산 규모 적정성
-  - 로케이션 실현 가능성
-  - 특수효과 요구사항
-
-**필수 개선 제안:**
-각 문제점에 대한 구체적 해결책을 제시하세요.""",
-
-           "English": f"""You are a structure critic. Deeply analyze story structure and character setup.
-
-**Story Structure:**
-{story_structure}
-
-**Character Setup:**
-{characters}
-
-**Analysis Items:**
-
-1. **Three-Act Structure Effectiveness**
-  - Balance of each act
-  - Strength of transitions
-  - Clarity of plot points
-  - Climax positioning
-
-2. **Character Arc Validity**
-  - Credibility of change
-  - Clarity of motivation
-  - Internal/external goal alignment
-  - Relationship dynamics
-
-3. **Theme Integration**
-  - Theme consistency
-  - Plot-theme connection
-  - Character-theme connection
-  - Visual theme expression
-
-4. **Genre Expectations**
-  - Meeting {genre} conventions
-  - Balance of originality and familiarity
-  - Target audience satisfaction
-
-5. **Production Reality**
-  - Budget scale appropriateness
-  - Location feasibility
-  - Special effects requirements
-
-**Required Improvement Suggestions:**
-Provide specific solutions for each issue."""
-       }
-       
-       return lang_prompts.get(language, lang_prompts["English"])
+                        screenplay_type: str, genre: str, language: str, 
+                        stages: List[Dict]) -> str:
+        """Generate stage-specific prompt"""
+        if stage_idx == 0:  # Producer
+            return self.create_producer_prompt(query, screenplay_type, genre, language)
+        
+        if stage_idx == 1:  # Story Developer
+            return self.create_story_developer_prompt(
+                stages[0]["content"], query, screenplay_type, genre, language
+            )
+        
+        if stage_idx == 2:  # Character Designer
+            return self.create_character_designer_prompt(
+                stages[0]["content"], stages[1]["content"], genre, language
+            )
+        
+        if stage_idx == 3:  # Structure Critic
+            return self.create_critic_structure_prompt(
+                stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
+            )
+        
+        if stage_idx == 4:  # Scene Planner
+            return self.create_scene_planner_prompt(
+                stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
+            )
+        
+        # Screenwriter acts
+        if role == "screenwriter":
+            act_mapping = {5: "Act 1", 7: "Act 2A", 9: "Act 2B", 11: "Act 3"}
+            if stage_idx in act_mapping:
+                act = act_mapping[stage_idx]
+                previous_acts = self._get_previous_acts(stages, stage_idx)
+                return self.create_screenwriter_prompt(
+                    act, stages[4]["content"], stages[2]["content"], 
+                    previous_acts, screenplay_type, genre, language
+                )
+        
+        # Script doctor reviews
+        if role == "script_doctor":
+            act_mapping = {6: "Act 1", 8: "Act 2A", 10: "Act 2B"}
+            if stage_idx in act_mapping:
+                act = act_mapping[stage_idx]
+                act_content = stages[stage_idx-1]["content"]
+                return self.create_script_doctor_prompt(act_content, act, genre, language)
+        
+        # Final reviewer
+        if role == "final_reviewer":
+            complete_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
+            return self.create_final_reviewer_prompt(
+                complete_screenplay, screenplay_type, genre, language
+            )
+        
+        return ""
 
     def _get_previous_acts(self, stages: List[Dict], current_idx: int) -> str:
-       """Get previous acts content"""
-       previous = []
-       act_indices = {5: [], 7: [5], 9: [5, 7], 11: [5, 7, 9]}
-       
-       if current_idx in act_indices:
-           for idx in act_indices[current_idx]:
-               if idx < len(stages) and stages[idx]["content"]:
-                   previous.append(stages[idx]["content"])
-       
-       return "\n\n---\n\n".join(previous) if previous else ""
+        """Get previous acts content"""
+        previous = []
+        act_indices = {5: [], 7: [5], 9: [5, 7], 11: [5, 7, 9]}
+        
+        if current_idx in act_indices:
+            for idx in act_indices[current_idx]:
+                if idx < len(stages) and stages[idx]["content"]:
+                    previous.append(stages[idx]["content"])
+        
+        return "\n\n---\n\n".join(previous) if previous else ""
 
     def _process_producer_content(self, content: str):
-       """Process producer output"""
-       # Extract title and logline
-       title_match = re.search(r'(?:TITLE|제목):\s*(.+)', content)
-       logline_match = re.search(r'(?:LOGLINE|로그라인):\s*(.+)', content)
-       
-       if title_match:
-           self.screenplay_tracker.screenplay_bible.title = title_match.group(1).strip()
-       if logline_match:
-           self.screenplay_tracker.screenplay_bible.logline = logline_match.group(1).strip()
-       
-       # Save to database
-       ScreenplayDatabase.save_screenplay_bible(self.current_session_id, 
-                                              self.screenplay_tracker.screenplay_bible)
+        """Process producer output"""
+        # Extract title and logline
+        title_match = re.search(r'(?:TITLE|제목):\s*(.+)', content)
+        logline_match = re.search(r'(?:LOGLINE|로그라인):\s*(.+)', content)
+        
+        if title_match:
+            self.screenplay_tracker.screenplay_bible.title = title_match.group(1).strip()
+        if logline_match:
+            self.screenplay_tracker.screenplay_bible.logline = logline_match.group(1).strip()
+        
+        # Save to database
+        ScreenplayDatabase.save_screenplay_bible(self.current_session_id, 
+                                               self.screenplay_tracker.screenplay_bible)
 
     def _process_story_content(self, content: str):
-       """Process story developer output"""
-       # Extract three-act structure
-       self.screenplay_tracker.screenplay_bible.three_act_structure = {
-           "act1": self._extract_section(content, "ACT 1|제1막"),
-           "act2a": self._extract_section(content, "ACT 2A|제2막A"),
-           "act2b": self._extract_section(content, "ACT 2B|제2막B"),
-           "act3": self._extract_section(content, "ACT 3|제3막")
-       }
-       
-       ScreenplayDatabase.save_screenplay_bible(self.current_session_id,
-                                              self.screenplay_tracker.screenplay_bible)
+        """Process story developer output"""
+        # Extract three-act structure
+        self.screenplay_tracker.screenplay_bible.three_act_structure = {
+            "act1": self._extract_section(content, "ACT 1|제1막"),
+            "act2a": self._extract_section(content, "ACT 2A|제2막A"),
+            "act2b": self._extract_section(content, "ACT 2B|제2막B"),
+            "act3": self._extract_section(content, "ACT 3|제3막")
+        }
+        
+        ScreenplayDatabase.save_screenplay_bible(self.current_session_id,
+                                               self.screenplay_tracker.screenplay_bible)
 
     def _process_character_content(self, content: str):
-       """Process character designer output"""
-       # Extract protagonist
-       protagonist_section = self._extract_section(content, "PROTAGONIST|주인공")
-       if protagonist_section:
-           protagonist = self._parse_character_profile(protagonist_section, "protagonist")
-           self.screenplay_tracker.add_character(protagonist)
-           ScreenplayDatabase.save_character(self.current_session_id, protagonist)
-       
-       # Extract antagonist
-       antagonist_section = self._extract_section(content, "ANTAGONIST|적대자")
-       if antagonist_section:
-           antagonist = self._parse_character_profile(antagonist_section, "antagonist")
-           self.screenplay_tracker.add_character(antagonist)
-           ScreenplayDatabase.save_character(self.current_session_id, antagonist)
+        """Process character designer output"""
+        # Extract protagonist
+        protagonist_section = self._extract_section(content, "PROTAGONIST|주인공")
+        if protagonist_section:
+            protagonist = self._parse_character_profile(protagonist_section, "protagonist")
+            self.screenplay_tracker.add_character(protagonist)
+            ScreenplayDatabase.save_character(self.current_session_id, protagonist)
+        
+        # Extract antagonist
+        antagonist_section = self._extract_section(content, "ANTAGONIST|적대자")
+        if antagonist_section:
+            antagonist = self._parse_character_profile(antagonist_section, "antagonist")
+            self.screenplay_tracker.add_character(antagonist)
+            ScreenplayDatabase.save_character(self.current_session_id, antagonist)
 
     def _process_scene_content(self, content: str):
-       """Process scene planner output"""
-       # Parse scene breakdown
-       scene_pattern = r'(?:Scene|씬)\s*(\d+).*?(?:INT\.|EXT\.)\s*(.+?)\s*-\s*(\w+)'
-       scenes = re.finditer(scene_pattern, content, re.IGNORECASE | re.MULTILINE)
-       
-       for match in scenes:
-           scene_num = int(match.group(1))
-           location = match.group(2).strip()
-           time_of_day = match.group(3).strip()
-           
-           # Determine act based on scene number
-           act = 1 if scene_num <= 12 else 2 if scene_num <= 35 else 3
-           
-           scene = SceneBreakdown(
-               scene_number=scene_num,
-               act=act,
-               location=location,
-               time_of_day=time_of_day,
-               characters=[],  # Would be extracted from content
-               purpose="",  # Would be extracted from content
-               conflict="",  # Would be extracted from content
-               page_count=1.5  # Default estimate
-           )
-           
-           self.screenplay_tracker.add_scene(scene)
-           ScreenplayDatabase.save_scene(self.current_session_id, scene)
+        """Process scene planner output"""
+        # Parse scene breakdown
+        scene_pattern = r'(?:Scene|씬)\s*(\d+).*?(?:INT\.|EXT\.)\s*(.+?)\s*-\s*(\w+)'
+        scenes = re.finditer(scene_pattern, content, re.IGNORECASE | re.MULTILINE)
+        
+        for match in scenes:
+            scene_num = int(match.group(1))
+            location = match.group(2).strip()
+            time_of_day = match.group(3).strip()
+            
+            # Determine act based on scene number
+            act = 1 if scene_num <= 12 else 2 if scene_num <= 35 else 3
+            
+            scene = SceneBreakdown(
+                scene_number=scene_num,
+                act=act,
+                location=location,
+                time_of_day=time_of_day,
+                characters=[],  # Would be extracted from content
+                purpose="",  # Would be extracted from content
+                conflict="",  # Would be extracted from content
+                page_count=1.5  # Default estimate
+            )
+            
+            self.screenplay_tracker.add_scene(scene)
+            ScreenplayDatabase.save_scene(self.current_session_id, scene)
 
     def _extract_section(self, content: str, section_pattern: str) -> str:
-       """Extract section from content"""
-       pattern = rf'(?:{section_pattern})[:\s]*(.+?)(?=\n(?:[A-Z]{{2,}}|[가-힣]{{2,}}):|\Z)'
-       match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-       return match.group(1).strip() if match else ""
+        """Extract section from content"""
+        pattern = rf'(?:{section_pattern})[:\s]*(.+?)(?=\n(?:[A-Z]{{2,}}|[가-힣]{{2,}}):|\Z)'
+        match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+        return match.group(1).strip() if match else ""
 
     def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
-       """Parse character profile from content"""
-       # Extract character details using regex or string parsing
-       name = self._extract_field(content, "Name|이름") or f"Character_{role}"
-       age = int(self._extract_field(content, "Age|나이") or "30")
-       
-       return CharacterProfile(
-           name=name,
-           age=age,
-           role=role,
-           archetype=self._extract_field(content, "Archetype|아크타입") or "",
-           want=self._extract_field(content, "WANT|외적 목표") or "",
-           need=self._extract_field(content, "NEED|내적 필요") or "",
-           backstory=self._extract_field(content, "Backstory|백스토리") or "",
-           personality=[],  # Would be parsed from content
-           speech_pattern=self._extract_field(content, "Speech|말투") or "",
-           character_arc=self._extract_field(content, "Arc|아크") or ""
-       )
+        """Parse character profile from content"""
+        # Extract character details using regex or string parsing
+        name = self._extract_field(content, "Name|이름") or f"Character_{role}"
+        age = int(self._extract_field(content, "Age|나이") or "30")
+        
+        return CharacterProfile(
+            name=name,
+            age=age,
+            role=role,
+            archetype=self._extract_field(content, "Archetype|아크타입") or "",
+            want=self._extract_field(content, "WANT|외적 목표") or "",
+            need=self._extract_field(content, "NEED|내적 필요") or "",
+            backstory=self._extract_field(content, "Backstory|백스토리") or "",
+            personality=[],  # Would be parsed from content
+            speech_pattern=self._extract_field(content, "Speech|말투") or "",
+            character_arc=self._extract_field(content, "Arc|아크") or ""
+        )
 
     def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
-       """Extract field value from content"""
-       pattern = rf'(?:{field_pattern})[:\s]*(.+?)(?=\n|$)'
-       match = re.search(pattern, content, re.IGNORECASE)
-       return match.group(1).strip() if match else None
+        """Extract field value from content"""
+        pattern = rf'(?:{field_pattern})[:\s]*(.+?)(?=\n|$)'
+        match = re.search(pattern, content, re.IGNORECASE)
+        return match.group(1).strip() if match else None
 
 # --- Utility functions ---
 def generate_random_screenplay_theme(screenplay_type: str, genre: str, language: str) -> str: