Update app.py

app.py

@@ -24,190 +24,190 @@ logger = logging.getLogger(__name__)
 
 # --- Document export imports ---
 try:
-   from docx import Document
-   from docx.shared import Inches, Pt, RGBColor, Mm
-   from docx.enum.text import WD_ALIGN_PARAGRAPH
-   from docx.enum.style import WD_STYLE_TYPE
-   from docx.oxml.ns import qn
-   from docx.oxml import OxmlElement
-   DOCX_AVAILABLE = True
+    from docx import Document
+    from docx.shared import Inches, Pt, RGBColor, Mm
+    from docx.enum.text import WD_ALIGN_PARAGRAPH
+    from docx.enum.style import WD_STYLE_TYPE
+    from docx.oxml.ns import qn
+    from docx.oxml import OxmlElement
+    DOCX_AVAILABLE = True
 except ImportError:
-   DOCX_AVAILABLE = False
-   logger.warning("python-docx not installed. DOCX export will be disabled.")
+    DOCX_AVAILABLE = False
+    logger.warning("python-docx not installed. DOCX export will be disabled.")
 
 # --- Environment variables and constants ---
 FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN", "")
 BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
 API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"
 MODEL_ID = "dep86pjolcjjnv8"
-DB_PATH = "screenplay_sessions_v1.db"
+DB_PATH = "screenplay_sessions_v2.db"
 
 # Screenplay length settings
 SCREENPLAY_LENGTHS = {
-   "movie": {"pages": 110, "description": "Feature Film (90-120 pages)"},
-   "tv_drama": {"pages": 55, "description": "TV Drama Episode (50-60 pages)"},
-   "ott_series": {"pages": 45, "description": "OTT Series Episode (30-60 pages)"},
-   "short_film": {"pages": 15, "description": "Short Film (10-20 pages)"}
+    "movie": {"pages": 110, "description": "Feature Film (90-120 pages)"},
+    "tv_drama": {"pages": 55, "description": "TV Drama Episode (50-60 pages)"},
+    "ott_series": {"pages": 45, "description": "OTT Series Episode (30-60 pages)"},
+    "short_film": {"pages": 15, "description": "Short Film (10-20 pages)"}
 }
 
 # --- Environment validation ---
 if not FRIENDLI_TOKEN:
-   logger.error("FRIENDLI_TOKEN not set. Application will not work properly.")
-   FRIENDLI_TOKEN = "dummy_token_for_testing"
+    logger.error("FRIENDLI_TOKEN not set. Application will not work properly.")
+    FRIENDLI_TOKEN = "dummy_token_for_testing"
 
 if not BRAVE_SEARCH_API_KEY:
-   logger.warning("BRAVE_SEARCH_API_KEY not set. Web search features will be disabled.")
+    logger.warning("BRAVE_SEARCH_API_KEY not set. Web search features will be disabled.")
 
 # --- Global variables ---
 db_lock = threading.Lock()
 
 # Genre templates
 GENRE_TEMPLATES = {
-   "action": {
-       "pacing": "fast",
-       "scene_length": "short",
-       "dialogue_ratio": 0.3,
-       "key_elements": ["set pieces", "physical conflict", "urgency", "stakes escalation"],
-       "structure_beats": ["explosive opening", "pursuit/chase", "confrontation", "climactic battle"]
-   },
-   "thriller": {
-       "pacing": "fast",
-       "scene_length": "short",
-       "dialogue_ratio": 0.35,
-       "key_elements": ["suspense", "twists", "paranoia", "time pressure"],
-       "structure_beats": ["hook", "mystery deepens", "false victory", "revelation", "final confrontation"]
-   },
-   "drama": {
-       "pacing": "moderate",
-       "scene_length": "medium",
-       "dialogue_ratio": 0.5,
-       "key_elements": ["character depth", "emotional truth", "relationships", "internal conflict"],
-       "structure_beats": ["status quo", "catalyst", "debate", "commitment", "complications", "crisis", "resolution"]
-   },
-   "comedy": {
-       "pacing": "fast",
-       "scene_length": "short",
-       "dialogue_ratio": 0.6,
-       "key_elements": ["setup/payoff", "timing", "character comedy", "escalation"],
-       "structure_beats": ["funny opening", "complication", "misunderstandings multiply", "chaos peak", "resolution with callback"]
-   },
-   "horror": {
-       "pacing": "variable",
-       "scene_length": "mixed",
-       "dialogue_ratio": 0.3,
-       "key_elements": ["atmosphere", "dread", "jump scares", "gore/psychological"],
-       "structure_beats": ["normal world", "first sign", "investigation", "first attack", "survival", "final girl/boy"]
-   },
-   "sci-fi": {
-       "pacing": "moderate",
-       "scene_length": "medium",
-       "dialogue_ratio": 0.4,
-       "key_elements": ["world building", "technology", "concepts", "visual spectacle"],
-       "structure_beats": ["ordinary world", "discovery", "new world", "complications", "understanding", "choice", "new normal"]
-   },
-   "romance": {
-       "pacing": "moderate",
-       "scene_length": "medium",
-       "dialogue_ratio": 0.55,
-       "key_elements": ["chemistry", "obstacles", "emotional moments", "intimacy"],
-       "structure_beats": ["meet cute", "attraction", "first conflict", "deepening", "crisis/breakup", "grand gesture", "together"]
-   }
+    "action": {
+        "pacing": "fast",
+        "scene_length": "short",
+        "dialogue_ratio": 0.3,
+        "key_elements": ["set pieces", "physical conflict", "urgency", "stakes escalation"],
+        "structure_beats": ["explosive opening", "pursuit/chase", "confrontation", "climactic battle"]
+    },
+    "thriller": {
+        "pacing": "fast",
+        "scene_length": "short",
+        "dialogue_ratio": 0.35,
+        "key_elements": ["suspense", "twists", "paranoia", "time pressure"],
+        "structure_beats": ["hook", "mystery deepens", "false victory", "revelation", "final confrontation"]
+    },
+    "drama": {
+        "pacing": "moderate",
+        "scene_length": "medium",
+        "dialogue_ratio": 0.5,
+        "key_elements": ["character depth", "emotional truth", "relationships", "internal conflict"],
+        "structure_beats": ["status quo", "catalyst", "debate", "commitment", "complications", "crisis", "resolution"]
+    },
+    "comedy": {
+        "pacing": "fast",
+        "scene_length": "short",
+        "dialogue_ratio": 0.6,
+        "key_elements": ["setup/payoff", "timing", "character comedy", "escalation"],
+        "structure_beats": ["funny opening", "complication", "misunderstandings multiply", "chaos peak", "resolution with callback"]
+    },
+    "horror": {
+        "pacing": "variable",
+        "scene_length": "mixed",
+        "dialogue_ratio": 0.3,
+        "key_elements": ["atmosphere", "dread", "jump scares", "gore/psychological"],
+        "structure_beats": ["normal world", "first sign", "investigation", "first attack", "survival", "final girl/boy"]
+    },
+    "sci-fi": {
+        "pacing": "moderate",
+        "scene_length": "medium",
+        "dialogue_ratio": 0.4,
+        "key_elements": ["world building", "technology", "concepts", "visual spectacle"],
+        "structure_beats": ["ordinary world", "discovery", "new world", "complications", "understanding", "choice", "new normal"]
+    },
+    "romance": {
+        "pacing": "moderate",
+        "scene_length": "medium",
+        "dialogue_ratio": 0.55,
+        "key_elements": ["chemistry", "obstacles", "emotional moments", "intimacy"],
+        "structure_beats": ["meet cute", "attraction", "first conflict", "deepening", "crisis/breakup", "grand gesture", "together"]
+    }
 }
 
 # Screenplay stages definition
 SCREENPLAY_STAGES = [
-   ("producer", "🎬 Producer: Concept Development & Market Analysis"),
-   ("story_developer", "📖 Story Developer: Synopsis & Three-Act Structure"),
-   ("character_designer", "👥 Character Designer: Cast & Relationships"),
-   ("critic_structure", "🔍 Structure Critic: Story & Character Review"),
-   ("scene_planner", "🎯 Scene Planner: Detailed Scene Breakdown"),
-   ("screenwriter", "✍️ Screenwriter: Act 1 - Setup (25%)"),
-   ("script_doctor", "🔧 Script Doctor: Act 1 Review & Polish"),
-   ("screenwriter", "✍️ Screenwriter: Act 2A - Rising Action (25%)"),
-   ("script_doctor", "🔧 Script Doctor: Act 2A Review & Polish"),
-   ("screenwriter", "✍️ Screenwriter: Act 2B - Complications (25%)"),
-   ("script_doctor", "🔧 Script Doctor: Act 2B Review & Polish"),
-   ("screenwriter", "✍️ Screenwriter: Act 3 - Resolution (25%)"),
-   ("final_reviewer", "🎭 Final Review: Complete Screenplay Analysis"),
+    ("producer", "🎬 Producer: Concept Development & Market Analysis"),
+    ("story_developer", "📖 Story Developer: Synopsis & Three-Act Structure"),
+    ("character_designer", "👥 Character Designer: Cast & Relationships"),
+    ("critic_structure", "🔍 Structure Critic: Story & Character Review"),
+    ("scene_planner", "🎯 Scene Planner: Detailed Scene Breakdown"),
+    ("screenwriter", "✍️ Screenwriter: Act 1 - Setup (25%)"),
+    ("script_doctor", "🔧 Script Doctor: Act 1 Review & Polish"),
+    ("screenwriter", "✍️ Screenwriter: Act 2A - Rising Action (25%)"),
+    ("script_doctor", "🔧 Script Doctor: Act 2A Review & Polish"),
+    ("screenwriter", "✍️ Screenwriter: Act 2B - Complications (25%)"),
+    ("script_doctor", "🔧 Script Doctor: Act 2B Review & Polish"),
+    ("screenwriter", "✍️ Screenwriter: Act 3 - Resolution (25%)"),
+    ("final_reviewer", "🎭 Final Review: Complete Screenplay Analysis"),
 ]
 
 # Save the Cat Beat Sheet
 SAVE_THE_CAT_BEATS = {
-   1: "Opening Image (0-1%)",
-   2: "Setup (1-10%)",
-   3: "Theme Stated (5%)",
-   4: "Catalyst (10%)",
-   5: "Debate (10-20%)",
-   6: "Break into Two (20%)",
-   7: "B Story (22%)",
-   8: "Fun and Games (20-50%)",
-   9: "Midpoint (50%)",
-   10: "Bad Guys Close In (50-75%)",
-   11: "All Is Lost (75%)",
-   12: "Dark Night of the Soul (75-80%)",
-   13: "Break into Three (80%)",
-   14: "Finale (80-99%)",
-   15: "Final Image (99-100%)"
+    1: "Opening Image (0-1%)",
+    2: "Setup (1-10%)",
+    3: "Theme Stated (5%)",
+    4: "Catalyst (10%)",
+    5: "Debate (10-20%)",
+    6: "Break into Two (20%)",
+    7: "B Story (22%)",
+    8: "Fun and Games (20-50%)",
+    9: "Midpoint (50%)",
+    10: "Bad Guys Close In (50-75%)",
+    11: "All Is Lost (75%)",
+    12: "Dark Night of the Soul (75-80%)",
+    13: "Break into Three (80%)",
+    14: "Finale (80-99%)",
+    15: "Final Image (99-100%)"
 }
 
 # --- Data classes ---
 @dataclass
 class ScreenplayBible:
-   """Screenplay bible for maintaining consistency"""
-   title: str = ""
-   logline: str = ""
-   genre: str = ""
-   subgenre: str = ""
-   tone: str = ""
-   themes: List[str] = field(default_factory=list)
-   
-   # Characters
-   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)
-   
-   # Structure
-   three_act_structure: Dict[str, str] = field(default_factory=dict)
-   save_the_cat_beats: Dict[int, str] = field(default_factory=dict)
-   
-   # World
-   time_period: str = ""
-   primary_locations: List[Dict[str, str]] = field(default_factory=list)
-   world_rules: List[str] = field(default_factory=list)
-   
-   # Visual style
-   visual_style: str = ""
-   key_imagery: List[str] = field(default_factory=list)
+    """Screenplay bible for maintaining consistency"""
+    title: str = ""
+    logline: str = ""
+    genre: str = ""
+    subgenre: str = ""
+    tone: str = ""
+    themes: List[str] = field(default_factory=list)
+    
+    # Characters
+    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)
+    
+    # Structure
+    three_act_structure: Dict[str, str] = field(default_factory=dict)
+    save_the_cat_beats: Dict[int, str] = field(default_factory=dict)
+    
+    # World
+    time_period: str = ""
+    primary_locations: List[Dict[str, str]] = field(default_factory=list)
+    world_rules: List[str] = field(default_factory=list)
+    
+    # Visual style
+    visual_style: str = ""
+    key_imagery: List[str] = field(default_factory=list)
 
 @dataclass
 class SceneBreakdown:
-   """Individual scene information"""
-   scene_number: int
-   act: int
-   location: str
-   time_of_day: str
-   characters: List[str]
-   purpose: str
-   conflict: str
-   page_count: float
-   beat: str = ""
-   transition: str = "CUT TO:"
+    """Individual scene information"""
+    scene_number: int
+    act: int
+    location: str
+    time_of_day: str
+    characters: List[str]
+    purpose: str
+    conflict: str
+    page_count: float
+    beat: str = ""
+    transition: str = "CUT TO:"
 
 @dataclass
 class CharacterProfile:
-   """Detailed character profile"""
-   name: str
-   age: int
-   role: str  # protagonist, antagonist, supporting, etc.
-   archetype: str
-   want: str  # External goal
-   need: str  # Internal need
-   backstory: str
-   personality: List[str]
-   speech_pattern: str
-   character_arc: str
-   relationships: Dict[str, str] = field(default_factory=dict)
-   first_appearance: str = ""
+    """Detailed character profile"""
+    name: str
+    age: int
+    role: str  # protagonist, antagonist, supporting, etc.
+    archetype: str
+    want: str  # External goal
+    need: str  # Internal need
+    backstory: str
+    personality: List[str]
+    speech_pattern: str
+    character_arc: str
+    relationships: Dict[str, str] = field(default_factory=dict)
+    first_appearance: str = ""
 
 # --- Core logic classes ---
 class ScreenplayTracker:
@@ -537,63 +537,51 @@ class ScreenplayDatabase:
         
         return theme_id
 
-    @staticmethod
-    def get_stages(session_id: str) -> List[Dict]:
-        """Get all stages for a session"""
-        with ScreenplayDatabase.get_db() as conn:
-            rows = conn.cursor().execute(
-                '''SELECT * FROM screenplay_stages 
-                   WHERE session_id = ? 
-                   ORDER BY stage_number''', 
-                (session_id,)
-            ).fetchall()
-            return [dict(row) for row in rows]
-
 class WebSearchIntegration:
-   """Web search functionality for screenplay research"""
-   def __init__(self):
-       self.brave_api_key = BRAVE_SEARCH_API_KEY
-       self.search_url = "https://api.search.brave.com/res/v1/web/search"
-       self.enabled = bool(self.brave_api_key)
-
-   def search(self, query: str, count: int = 3, language: str = "en") -> List[Dict]:
-       if not self.enabled:
-           return []
-       headers = {
-           "Accept": "application/json",
-           "X-Subscription-Token": self.brave_api_key
-       }
-       params = {
-           "q": query,
-           "count": count,
-           "search_lang": "ko" if language == "Korean" else "en",
-           "text_decorations": False,
-           "safesearch": "moderate"
-       }
-       try:
-           response = requests.get(self.search_url, headers=headers, params=params, timeout=10)
-           response.raise_for_status()
-           results = response.json().get("web", {}).get("results", [])
-           return results
-       except requests.exceptions.RequestException as e:
-           logger.error(f"Web search API error: {e}")
-           return []
-
-   def extract_relevant_info(self, results: List[Dict], max_chars: int = 1500) -> str:
-       if not results:
-           return ""
-       extracted = []
-       total_chars = 0
-       for i, result in enumerate(results[:3], 1):
-           title = result.get("title", "")
-           description = result.get("description", "")
-           info = f"[{i}] {title}: {description}"
-           if total_chars + len(info) < max_chars:
-               extracted.append(info)
-               total_chars += len(info)
-           else:
-               break
-       return "\n".join(extracted)
+    """Web search functionality for screenplay research"""
+    def __init__(self):
+        self.brave_api_key = BRAVE_SEARCH_API_KEY
+        self.search_url = "https://api.search.brave.com/res/v1/web/search"
+        self.enabled = bool(self.brave_api_key)
+
+    def search(self, query: str, count: int = 3, language: str = "en") -> List[Dict]:
+        if not self.enabled:
+            return []
+        headers = {
+            "Accept": "application/json",
+            "X-Subscription-Token": self.brave_api_key
+        }
+        params = {
+            "q": query,
+            "count": count,
+            "search_lang": "ko" if language == "Korean" else "en",
+            "text_decorations": False,
+            "safesearch": "moderate"
+        }
+        try:
+            response = requests.get(self.search_url, headers=headers, params=params, timeout=10)
+            response.raise_for_status()
+            results = response.json().get("web", {}).get("results", [])
+            return results
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Web search API error: {e}")
+            return []
+
+    def extract_relevant_info(self, results: List[Dict], max_chars: int = 1500) -> str:
+        if not results:
+            return ""
+        extracted = []
+        total_chars = 0
+        for i, result in enumerate(results[:3], 1):
+            title = result.get("title", "")
+            description = result.get("description", "")
+            info = f"[{i}] {title}: {description}"
+            if total_chars + len(info) < max_chars:
+                extracted.append(info)
+                total_chars += len(info)
+            else:
+                break
+        return "\n".join(extracted)
 
 class ScreenplayGenerationSystem:
     """Professional screenplay generation system"""
@@ -878,7 +866,7 @@ Create specific, emotionally resonant story."""
 **필수 캐릭터 프로필:**
 
 1. **주인공 (PROTAGONIST)**
-   - 이름 & 나이:
+   - 이름, 나이:
    - 직업/역할:
    - 캐릭터 아크타입:
    - WANT (외적 목표):
@@ -891,7 +879,7 @@ Create specific, emotionally resonant story."""
    - 캐릭터 아크 (A→B):
 
 2. **적대자 (ANTAGONIST)**
-   - 이름 & 나이:
+   - 이름, 나이:
    - 직업/역할:
    - 악역 아크타입:
    - 목표 & 동기:
@@ -902,7 +890,7 @@ Create specific, emotionally resonant story."""
 
 3. **조력자들 (SUPPORTING CAST)**
    최소 3명, 각각:
-   - 이름 & 역할:
+   - 이름, 역할:
    - 주인공과의 관계:
    - 스토리 기능:
    - 독특한 특성:
@@ -935,7 +923,7 @@ Create specific, emotionally resonant story."""
 **Required Character Profiles:**
 
 1. **PROTAGONIST**
-   - Name & Age:
+   - Name, Age:
    - Occupation/Role:
    - Character Archetype:
    - WANT (External Goal):
@@ -948,7 +936,7 @@ Create specific, emotionally resonant story."""
    - Character Arc (A→B):
 
 2. **ANTAGONIST**
-   - Name & Age:
+   - Name, Age:
    - Occupation/Role:
    - Villain Archetype:
    - Goal & Motivation:
@@ -959,7 +947,7 @@ Create specific, emotionally resonant story."""
 
 3. **SUPPORTING CAST**
    Minimum 3, each with:
-   - Name & Role:
+   - Name, Role:
    - Relationship to Protagonist:
    - Story Function:
    - Unique Traits:
@@ -1482,8 +1470,6 @@ Provide specific solutions for each issue."""
             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:
@@ -1634,8 +1620,6 @@ Provide specific solutions for each issue."""
             logger.error(traceback.format_exc())
             yield f"❌ Unexpected error: {str(e)}"
 
-
-
     def get_system_prompts(self, language: str) -> Dict[str, str]:
         """Role-specific system prompts"""
         
@@ -1726,9 +1710,7 @@ You provide feedback that's critical yet encouraging."""
         
         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]:
@@ -1888,9 +1870,8 @@ You provide feedback that's critical yet encouraging."""
         
         return "\n\n---\n\n".join(previous) if previous else ""
 
-
     def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
-        """Parse character profile from content"""
+        """Parse character profile from content with improved error handling"""
         # Debug logging
         logger.debug(f"Parsing character profile for role: {role}")
         logger.debug(f"Content preview: {content[:200]}...")
@@ -1898,9 +1879,9 @@ You provide feedback that's critical yet encouraging."""
         # Extract name first - handle various formats
         name = f"Character_{role}"  # default
         name_patterns = [
-            r'(?:이름|Name)[:\s]*([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?',
-            r'^\s*[-*•]\s*([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?',
-            r'^([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?'
+            r'(?:이름|Name)[:\s]*([^,\n]+?)(?:\s*\([^)]+\))?\s*[,:]?\s*(?:\d+세)?',
+            r'^\s*[-*•]\s*([^,\n]+?)(?:\s*\([^)]+\))?\s*[,:]?\s*(?:\d+세)?',
+            r'^([^,\n]+?)(?:\s*\([^)]+\))?\s*[,:]?\s*(?:\d+세)?'
         ]
         
         for pattern in name_patterns:
@@ -1908,21 +1889,23 @@ You provide feedback that's critical yet encouraging."""
             if name_match:
                 extracted_name = name_match.group(1).strip()
                 # Remove markdown and extra characters
-                extracted_name = re.sub(r'[*:\s]+$', '', extracted_name)
+                extracted_name = re.sub(r'[*:\s]+, '', extracted_name)
                 extracted_name = re.sub(r'^[*:\s]+', '', extracted_name)
+                # Remove age if it's part of the name
+                extracted_name = re.sub(r'\s*,?\s*\d+\s*(?:세|살)?, '', extracted_name)
                 if extracted_name and len(extracted_name) > 1:
                     name = extracted_name
                     break
         
-        # Extract age with multiple patterns
+        # Extract age with multiple patterns - FIXED VERSION
         age = 30  # default age
         age_patterns = [
             r'(\d+)\s*세',
             r'(\d+)\s*살',
-            r',\s*(\d+)\s*[,\s]',
+            r'(?:나이|Age)[:\s]*(\d+)',
+            r',\s*(\d+)\s*(?:세|살)?(?:\s|,|$)',
             r'\((\d+)\)',
-            r'Age[:\s]*(\d+)',
-            r'나이[:\s]*(\d+)'
+            r':\s*\w+\s*,?\s*(\d+)(?:\s|,|$)'
         ]
         
         for pattern in age_patterns:
@@ -1934,16 +1917,18 @@ You provide feedback that's critical yet encouraging."""
                         age = extracted_age
                         logger.debug(f"Extracted age: {age}")
                         break
-                except ValueError:
+                except (ValueError, AttributeError):
                     continue
         
         # Helper function to extract clean fields
-        def extract_clean_field(patterns):
+        def extract_clean_field(patterns, multiline=False):
             if isinstance(patterns, str):
                 patterns = [patterns]
             
+            flags = re.IGNORECASE | re.DOTALL if multiline else re.IGNORECASE
+            
             for pattern in patterns:
-                match = re.search(rf'{pattern}[:\s]*([^\n*]+?)(?=\n|$)', content, re.IGNORECASE | re.DOTALL)
+                match = re.search(rf'{pattern}[:\s]*([^\n*]+?)(?=\n|$)', content, flags)
                 if match:
                     value = match.group(1).strip()
                     # Clean up the value
@@ -1982,7 +1967,7 @@ You provide feedback that's critical yet encouraging."""
                 r"Backstory",
                 r"핵심 상처",
                 r"Core Wound"
-            ]),
+            ], multiline=True),
             personality=self._extract_personality_traits(content),
             speech_pattern=extract_clean_field([
                 r"말투.*?패턴",
@@ -2003,165 +1988,181 @@ You provide feedback that's critical yet encouraging."""
 
     def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
         """Extract field value from content with improved parsing"""
-        # Use word boundary to prevent partial matches
-        pattern = rf'\b{field_pattern}\b[:\s]*([^\n]+?)(?=\n|$)'
-        match = re.search(pattern, content, re.IGNORECASE)
-        if match:
-            value = match.group(1).strip()
-            # Remove markdown formatting
-            value = re.sub(r'\*+', '', value)
-            # Remove list markers
-            value = re.sub(r'^\s*[-•*]\s*', '', value)
-            # Remove trailing punctuation
-            value = re.sub(r'[,.:;]$', '', value)
-            return value.strip()
+        # More flexible pattern that handles various formats
+        patterns = field_pattern.split('|')
+        
+        for pattern in patterns:
+            # Try different regex patterns
+            regex_patterns = [
+                rf'\b{pattern}\b[:\s]*([^\n]+?)(?=\n[A-Z가-힣]|$)',
+                rf'{pattern}[:\s]*([^\n]+)',
+                rf'{pattern}.*?[:\s]+([^\n]+)'
+            ]
+            
+            for regex in regex_patterns:
+                match = re.search(regex, content, re.IGNORECASE | re.DOTALL)
+                if match:
+                    value = match.group(1).strip()
+                    # Remove markdown formatting if present
+                    value = re.sub(r'\*\*', '', value)
+                    value = re.sub(r'^\s*[-•*]\s*', '', value)
+                    # Remove trailing punctuation
+                    value = re.sub(r'[,.:;], '', value)
+                    cleaned = value.strip()
+                    if cleaned:
+                        return cleaned
+        
         return None
 
     def _extract_personality_traits(self, content: str) -> List[str]:
-       """Extract personality traits from content"""
-       traits = []
-       # Look for personality section
-       personality_section = self._extract_field(content, r"(?:Personality|성격)[:\s]*")
-       if personality_section:
-           # Extract individual traits (usually listed)
-           trait_lines = personality_section.split('\n')
-           for line in trait_lines:
-               line = line.strip()
-               if line and not line.endswith(':'):
-                   # Remove list markers
-                   trait = re.sub(r'^\s*[-•*]\s*', '', line)
-                   if trait:
-                       traits.append(trait)
-       return traits[:5]  # Limit to 5 traits
+        """Extract personality traits from content"""
+        traits = []
+        # Look for personality section
+        personality_patterns = [
+            r"(?:Personality|성격)[:\s]*([^\n]+(?:\n\s*[-•*][^\n]+)*)",
+            r"성격 특성[:\s]*([^\n]+(?:\n\s*[-•*][^\n]+)*)",
+            r"Personality Traits[:\s]*([^\n]+(?:\n\s*[-•*][^\n]+)*)"
+        ]
+        
+        for pattern in personality_patterns:
+            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+            if match:
+                personality_section = match.group(1)
+                # Extract individual traits
+                trait_lines = personality_section.split('\n')
+                for line in trait_lines:
+                    line = line.strip()
+                    if line and not line.endswith(':'):
+                        # Remove list markers
+                        trait = re.sub(r'^\s*[-•*]\s*', '', line)
+                        trait = re.sub(r'^\d+\.\s*', '', trait)
+                        if trait and len(trait) > 2:
+                            traits.append(trait)
+                break
+        
+        return traits[:5]  # Limit to 5 traits
 
     def _process_character_content(self, content: str):
-       """Process character designer output with better error handling"""
-       try:
-           # Extract protagonist
-           protagonist_section = self._extract_section(content, r"(?: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, r"(?: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)
-           
-           # Extract supporting characters
-           supporting_section = self._extract_section(content, r"(?:SUPPORTING CAST|조력자들)")
-           if supporting_section:
-               # Parse multiple supporting characters
-               self._parse_supporting_characters(supporting_section)
-               
-       except Exception as e:
-           logger.error(f"Error processing character content: {e}")
-           # Continue with default values rather than failing
+        """Process character designer output with better error handling"""
+        try:
+            # Extract protagonist
+            protagonist_section = self._extract_section(content, r"(?: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, r"(?: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)
+            
+            # Extract supporting characters
+            supporting_section = self._extract_section(content, r"(?:SUPPORTING CAST|조력자들)")
+            if supporting_section:
+                # Parse multiple supporting characters
+                self._parse_supporting_characters(supporting_section)
+                
+        except Exception as e:
+            logger.error(f"Error processing character content: {e}")
+            # Continue with default values rather than failing
 
     def _parse_supporting_characters(self, content: str):
-       """Parse supporting characters from content"""
-       # Split by character markers (numbers or bullets)
-       char_sections = re.split(r'\n(?:\d+\.|[-•*])\s*', content)
-       
-       for i, section in enumerate(char_sections[1:], 1):  # Skip first empty split
-           if section.strip():
-               try:
-                   name = self._extract_field(section, r"(?:Name|이름)[:\s]*") or f"Supporting_{i}"
-                   role = self._extract_field(section, r"(?:Role|역할)[:\s]*") or "supporting"
-                   
-                   character = CharacterProfile(
-                       name=name,
-                       age=30,  # Default age for supporting characters
-                       role="supporting",
-                       archetype=role,
-                       want="",
-                       need="",
-                       backstory=self._extract_field(section, r"(?:Backstory|백스토리)[:\s]*") or "",
-                       personality=[],
-                       speech_pattern="",
-                       character_arc=""
-                   )
-                   
-                   self.screenplay_tracker.add_character(character)
-                   ScreenplayDatabase.save_character(self.current_session_id, character)
-                   
-               except Exception as e:
-                   logger.warning(f"Error parsing supporting character {i}: {e}")
-                   continue
+        """Parse supporting characters from content"""
+        # Split by character markers (numbers or bullets)
+        char_sections = re.split(r'\n(?:\d+\.|[-•*])\s*', content)
+        
+        for i, section in enumerate(char_sections[1:], 1):  # Skip first empty split
+            if section.strip():
+                try:
+                    name = self._extract_field(section, r"(?:Name|이름)") or f"Supporting_{i}"
+                    role = self._extract_field(section, r"(?:Role|역할)") or "supporting"
+                    
+                    character = CharacterProfile(
+                        name=name,
+                        age=30,  # Default age for supporting characters
+                        role="supporting",
+                        archetype=role,
+                        want="",
+                        need="",
+                        backstory=self._extract_field(section, r"(?:Backstory|백스토리)") or "",
+                        personality=[],
+                        speech_pattern="",
+                        character_arc=""
+                    )
+                    
+                    self.screenplay_tracker.add_character(character)
+                    ScreenplayDatabase.save_character(self.current_session_id, character)
+                    
+                except Exception as e:
+                    logger.warning(f"Error parsing supporting character {i}: {e}")
+                    continue
 
     def _extract_section(self, content: str, section_pattern: str) -> str:
-       """Extract section from content with improved pattern matching"""
-       # More flexible section extraction
-       pattern = rf'{section_pattern}[:\s]*\n?(.*?)(?=\n\n[A-Z가-힣]{{2,}}[:\s]|\n\n\d+\.|$)'
-       match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-       if match:
-           return match.group(1).strip()
-       
-       # Try alternative pattern
-       pattern2 = rf'{section_pattern}.*?\n((?:.*\n)*?)(?=\n[A-Z가-힣]{{2,}}:|$)'
-       match2 = re.search(pattern2, content, re.IGNORECASE | re.DOTALL)
-       if match2:
-           return match2.group(1).strip()
-       
-       return ""
+        """Extract section from content with improved pattern matching"""
+        # More flexible section extraction
+        patterns = [
+            rf'{section_pattern}[:\s]*\n?(.*?)(?=\n\n[A-Z가-힣]{{2,}}[:\s]|\n\n\d+\.|$)',
+            rf'{section_pattern}.*?\n((?:.*\n)*?)(?=\n[A-Z가-힣]{{2,}}:|$)',
+            rf'{section_pattern}[:\s]*((?:[^\n]+\n?)*?)(?=\n\n|\Z)'
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+            if match:
+                return match.group(1).strip()
+        
+        return ""
 
     def _process_producer_content(self, content: str):
-       """Process producer output with better extraction"""
-       try:
-           # Extract title with various formats
-           title_patterns = [
-               r'(?:TITLE|제목)[:\s]*\*?\*?([^\n*]+)\*?\*?',
-               r'\*\*(?:TITLE|제목)\*\*[:\s]*([^\n]+)',
-               r'Title[:\s]*([^\n]+)'
-           ]
-           
-           for pattern in title_patterns:
-               title_match = re.search(pattern, content, re.IGNORECASE)
-               if title_match:
-                   self.screenplay_tracker.screenplay_bible.title = title_match.group(1).strip()
-                   break
-           
-           # Extract logline with various formats
-           logline_patterns = [
-               r'(?:LOGLINE|로그라인)[:\s]*\*?\*?([^\n]+)',
-               r'\*\*(?:LOGLINE|로그라인)\*\*[:\s]*([^\n]+)',
-               r'Logline[:\s]*([^\n]+)'
-           ]
-           
-           for pattern in logline_patterns:
-               logline_match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-               if logline_match:
-                   # Get full logline (might be multi-line)
-                   logline_text = logline_match.group(1).strip()
-                   # Continue reading if it's incomplete
-                   if not logline_text.endswith('.'):
-                       next_lines = content[logline_match.end():].split('\n')
-                       for line in next_lines[:3]:  # Check next 3 lines
-                           if line.strip() and not re.match(r'^[A-Z가-힣\d]', line.strip()):
-                               logline_text += ' ' + line.strip()
-                           else:
-                               break
-                   self.screenplay_tracker.screenplay_bible.logline = logline_text
-                   break
-           
-           # Extract genre
-           genre_match = re.search(r'(?:Primary Genre|주 장르)[:\s]*([^\n]+)', content, re.IGNORECASE)
-           if genre_match:
-               self.screenplay_tracker.screenplay_bible.genre = genre_match.group(1).strip()
-           
-           # Save to database
-           ScreenplayDatabase.save_screenplay_bible(self.current_session_id, 
-                                                  self.screenplay_tracker.screenplay_bible)
-                                                  
-       except Exception as e:
-           logger.error(f"Error processing producer content: {e}")
-
-
-
-
+        """Process producer output with better extraction"""
+        try:
+            # Extract title with various formats
+            title_patterns = [
+                r'(?:TITLE|제목)[:\s]*\*?\*?([^\n*]+)\*?\*?',
+                r'\*\*(?:TITLE|제목)\*\*[:\s]*([^\n]+)',
+                r'Title[:\s]*([^\n]+)',
+                r'1\.\s*\*?\*?(?:TITLE|제목).*?[:\s]*([^\n]+)'
+            ]
+            
+            for pattern in title_patterns:
+                title_match = re.search(pattern, content, re.IGNORECASE)
+                if title_match:
+                    self.screenplay_tracker.screenplay_bible.title = title_match.group(1).strip()
+                    break
+            
+            # Extract logline with various formats
+            logline_patterns = [
+                r'(?:LOGLINE|로그라인)[:\s]*\*?\*?([^\n]+(?:\n(?!\s*\n)[^\n]+)*)',
+                r'\*\*(?:LOGLINE|로그라인)\*\*[:\s]*([^\n]+(?:\n(?!\s*\n)[^\n]+)*)',
+                r'Logline[:\s]*([^\n]+(?:\n(?!\s*\n)[^\n]+)*)',
+                r'2\.\s*\*?\*?(?:LOGLINE|로그라인).*?[:\s]*([^\n]+(?:\n(?!\s*\n)[^\n]+)*)'
+            ]
+            
+            for pattern in logline_patterns:
+                logline_match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+                if logline_match:
+                    # Get full logline (might be multi-line)
+                    logline_text = logline_match.group(1).strip()
+                    # Clean up the logline
+                    logline_text = re.sub(r'\s+', ' ', logline_text)
+                    logline_text = re.sub(r'^[-•*]\s*', '', logline_text)
+                    self.screenplay_tracker.screenplay_bible.logline = logline_text
+                    break
+            
+            # Extract genre
+            genre_match = re.search(r'(?:Primary Genre|주 장르)[:\s]*([^\n]+)', content, re.IGNORECASE)
+            if genre_match:
+                self.screenplay_tracker.screenplay_bible.genre = genre_match.group(1).strip()
+            
+            # Save to database
+            ScreenplayDatabase.save_screenplay_bible(self.current_session_id, 
+                                                   self.screenplay_tracker.screenplay_bible)
+                                                   
+        except Exception as e:
+            logger.error(f"Error processing producer content: {e}")
 
     def _process_story_content(self, content: str):
         """Process story developer output"""
@@ -2176,22 +2177,6 @@ You provide feedback that's critical yet encouraging."""
         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)
-
     def _process_scene_content(self, content: str):
         """Process scene planner output"""
         # Parse scene breakdown
@@ -2220,46 +2205,6 @@ You provide feedback that's critical yet encouraging."""
             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 ""
-
-    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 ""
-        )
-
-    def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
-        """Extract field value from content with improved parsing"""
-        # More flexible pattern that handles various formats
-        pattern = rf'{field_pattern}(.+?)(?=\n[A-Z가-힣]|$)'
-        match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-        if match:
-            value = match.group(1).strip()
-            # Remove markdown formatting if present
-            value = re.sub(r'\*\*', '', value)
-            value = re.sub(r'^\s*[-•]\s*', '', value)
-            # Remove trailing punctuation
-            value = re.sub(r'[,.:;]$', '', value)
-            return value.strip()
-        return None
-
 # --- Utility functions ---
 def generate_random_screenplay_theme(screenplay_type: str, genre: str, language: str) -> str:
     """Generate random screenplay theme"""
@@ -2400,530 +2345,530 @@ def get_fallback_theme(screenplay_type: str, genre: str, language: str,
 **Unique Element:** A fresh take on {genre} genre conventions with contemporary relevance."""
 
 def load_screenplay_themes_data() -> Dict:
-   """Load screenplay themes data"""
-   return {
-       'situations': {
-           'action': ['hostage crisis', 'heist gone wrong', 'revenge mission', 'race against time'],
-           'thriller': ['false accusation', 'witness protection', 'conspiracy uncovered', 'identity theft'],
-           'drama': ['family reunion', 'terminal diagnosis', 'divorce proceedings', 'career crossroads'],
-           'comedy': ['mistaken identity', 'wedding disaster', 'workplace chaos', 'odd couple roommates'],
-           'horror': ['isolated location', 'ancient curse', 'home invasion', 'supernatural investigation'],
-           'sci-fi': ['first contact', 'time loop', 'AI awakening', 'space colony crisis'],
-           'romance': ['second chance', 'enemies to lovers', 'long distance', 'forbidden love']
-       },
-       'protagonists': {
-           'action': ['ex-soldier', 'undercover cop', 'skilled thief', 'reluctant hero'],
-           'thriller': ['investigative journalist', 'wrongly accused person', 'FBI agent', 'whistleblower'],
-           'drama': ['single parent', 'recovering addict', 'immigrant', 'caregiver'],
-           'comedy': ['uptight professional', 'slacker', 'fish out of water', 'eccentric artist'],
-           'horror': ['skeptical scientist', 'final girl', 'paranormal investigator', 'grieving parent'],
-           'sci-fi': ['astronaut', 'AI researcher', 'time traveler', 'colony leader'],
-           'romance': ['workaholic', 'hopeless romantic', 'cynical divorce lawyer', 'small town newcomer']
-       },
-       'conflicts': {
-           'action': ['stop the villain', 'save the hostages', 'prevent disaster', 'survive pursuit'],
-           'thriller': ['prove innocence', 'expose truth', 'stay alive', 'protect loved ones'],
-           'drama': ['reconcile past', 'find purpose', 'heal relationships', 'accept change'],
-           'comedy': ['save the business', 'win the competition', 'fool everyone', 'find love'],
-           'horror': ['survive the night', 'break the curse', 'escape the monster', 'save the town'],
-           'sci-fi': ['save humanity', 'prevent paradox', 'stop the invasion', 'preserve identity'],
-           'romance': ['overcome differences', 'choose between options', 'trust again', 'follow heart']
-       }
-   }
+    """Load screenplay themes data"""
+    return {
+        'situations': {
+            'action': ['hostage crisis', 'heist gone wrong', 'revenge mission', 'race against time'],
+            'thriller': ['false accusation', 'witness protection', 'conspiracy uncovered', 'identity theft'],
+            'drama': ['family reunion', 'terminal diagnosis', 'divorce proceedings', 'career crossroads'],
+            'comedy': ['mistaken identity', 'wedding disaster', 'workplace chaos', 'odd couple roommates'],
+            'horror': ['isolated location', 'ancient curse', 'home invasion', 'supernatural investigation'],
+            'sci-fi': ['first contact', 'time loop', 'AI awakening', 'space colony crisis'],
+            'romance': ['second chance', 'enemies to lovers', 'long distance', 'forbidden love']
+        },
+        'protagonists': {
+            'action': ['ex-soldier', 'undercover cop', 'skilled thief', 'reluctant hero'],
+            'thriller': ['investigative journalist', 'wrongly accused person', 'FBI agent', 'whistleblower'],
+            'drama': ['single parent', 'recovering addict', 'immigrant', 'caregiver'],
+            'comedy': ['uptight professional', 'slacker', 'fish out of water', 'eccentric artist'],
+            'horror': ['skeptical scientist', 'final girl', 'paranormal investigator', 'grieving parent'],
+            'sci-fi': ['astronaut', 'AI researcher', 'time traveler', 'colony leader'],
+            'romance': ['workaholic', 'hopeless romantic', 'cynical divorce lawyer', 'small town newcomer']
+        },
+        'conflicts': {
+            'action': ['stop the villain', 'save the hostages', 'prevent disaster', 'survive pursuit'],
+            'thriller': ['prove innocence', 'expose truth', 'stay alive', 'protect loved ones'],
+            'drama': ['reconcile past', 'find purpose', 'heal relationships', 'accept change'],
+            'comedy': ['save the business', 'win the competition', 'fool everyone', 'find love'],
+            'horror': ['survive the night', 'break the curse', 'escape the monster', 'save the town'],
+            'sci-fi': ['save humanity', 'prevent paradox', 'stop the invasion', 'preserve identity'],
+            'romance': ['overcome differences', 'choose between options', 'trust again', 'follow heart']
+        }
+    }
 
 def extract_title_from_theme(theme_text: str) -> str:
-   """Extract title from generated theme"""
-   match = re.search(r'\*\*(?:Title|제목):\*\*\s*(.+)', theme_text, re.IGNORECASE)
-   return match.group(1).strip() if match else ""
+    """Extract title from generated theme"""
+    match = re.search(r'\*\*(?:Title|제목):\*\*\s*(.+)', theme_text, re.IGNORECASE)
+    return match.group(1).strip() if match else ""
 
 def extract_logline_from_theme(theme_text: str) -> str:
-   """Extract logline from generated theme"""
-   match = re.search(r'\*\*(?:Logline|로그라인):\*\*\s*(.+)', theme_text, re.IGNORECASE)
-   return match.group(1).strip() if match else ""
+    """Extract logline from generated theme"""
+    match = re.search(r'\*\*(?:Logline|로그라인):\*\*\s*(.+)', theme_text, re.IGNORECASE)
+    return match.group(1).strip() if match else ""
 
 def format_screenplay_display(screenplay_text: str) -> str:
-   """Format screenplay for display"""
-   if not screenplay_text:
-       return "No screenplay content yet."
-   
-   formatted = "# 🎬 Screenplay\n\n"
-   
-   # Format scene headings
-   formatted_text = re.sub(
-       r'^(INT\.|EXT\.)(.*?)$',
-       r'**\1\2**',
-       screenplay_text,
-       flags=re.MULTILINE
-   )
-   
-   # Format character names (all caps on their own line)
-   formatted_text = re.sub(
-       r'^([A-Z][A-Z\s]+)$',
-       r'**\1**',
-       formatted_text,
-       flags=re.MULTILINE
-   )
-   
-   # Add spacing for readability
-   lines = formatted_text.split('\n')
-   formatted_lines = []
-   
-   for i, line in enumerate(lines):
-       formatted_lines.append(line)
-       # Add extra space after scene headings
-       if line.startswith('**INT.') or line.startswith('**EXT.'):
-           formatted_lines.append('')
-   
-   formatted += '\n'.join(formatted_lines)
-   
-   # Add page count
-   page_count = len(screenplay_text.split('\n')) / 55
-   formatted = f"**Total Pages: {page_count:.1f}**\n\n" + formatted
-   
-   return formatted
+    """Format screenplay for display"""
+    if not screenplay_text:
+        return "No screenplay content yet."
+    
+    formatted = "# 🎬 Screenplay\n\n"
+    
+    # Format scene headings
+    formatted_text = re.sub(
+        r'^(INT\.|EXT\.)(.*?),
+        r'**\1\2**',
+        screenplay_text,
+        flags=re.MULTILINE
+    )
+    
+    # Format character names (all caps on their own line)
+    formatted_text = re.sub(
+        r'^([A-Z][A-Z\s]+),
+        r'**\1**',
+        formatted_text,
+        flags=re.MULTILINE
+    )
+    
+    # Add spacing for readability
+    lines = formatted_text.split('\n')
+    formatted_lines = []
+    
+    for i, line in enumerate(lines):
+        formatted_lines.append(line)
+        # Add extra space after scene headings
+        if line.startswith('**INT.') or line.startswith('**EXT.'):
+            formatted_lines.append('')
+    
+    formatted += '\n'.join(formatted_lines)
+    
+    # Add page count
+    page_count = len(screenplay_text.split('\n')) / 55
+    formatted = f"**Total Pages: {page_count:.1f}**\n\n" + formatted
+    
+    return formatted
 
 def format_stages_display(stages: List[Dict]) -> str:
-   """Format stages display for screenplay"""
-   markdown = "## 🎬 Production Progress\n\n"
-   
-   # Progress summary
-   completed = sum(1 for s in stages if s.get('status') == 'complete')
-   total = len(stages)
-   markdown += f"**Progress: {completed}/{total} stages complete**\n\n"
-   
-   # Page count if available
-   total_pages = sum(s.get('page_count', 0) for s in stages if s.get('page_count'))
-   if total_pages > 0:
-       markdown += f"**Current Page Count: {total_pages:.1f} pages**\n\n"
-   
-   markdown += "---\n\n"
-   
-   # Stage details
-   current_act = None
-   for i, stage in enumerate(stages):
-       status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
-       
-       # Group by acts
-       if 'Act' in stage.get('name', ''):
-           act_match = re.search(r'Act (\w+)', stage['name'])
-           if act_match and act_match.group(1) != current_act:
-               current_act = act_match.group(1)
-               markdown += f"\n### 📄 Act {current_act}\n\n"
-       
-       markdown += f"{status_icon} **{stage['name']}**"
-       
-       if stage.get('page_count', 0) > 0:
-           markdown += f" ({stage['page_count']:.1f} pages)"
-       
-       markdown += "\n"
-       
-       if stage['content'] and stage['status'] == 'complete':
-           preview_length = 200
-           preview = stage['content'][:preview_length] + "..." if len(stage['content']) > preview_length else stage['content']
-           markdown += f"> {preview}\n\n"
-       elif stage['status'] == 'active':
-           markdown += "> *In progress...*\n\n"
-   
-   return markdown
+    """Format stages display for screenplay"""
+    markdown = "## 🎬 Production Progress\n\n"
+    
+    # Progress summary
+    completed = sum(1 for s in stages if s.get('status') == 'complete')
+    total = len(stages)
+    markdown += f"**Progress: {completed}/{total} stages complete**\n\n"
+    
+    # Page count if available
+    total_pages = sum(s.get('page_count', 0) for s in stages if s.get('page_count'))
+    if total_pages > 0:
+        markdown += f"**Current Page Count: {total_pages:.1f} pages**\n\n"
+    
+    markdown += "---\n\n"
+    
+    # Stage details
+    current_act = None
+    for i, stage in enumerate(stages):
+        status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
+        
+        # Group by acts
+        if 'Act' in stage.get('name', ''):
+            act_match = re.search(r'Act (\w+)', stage['name'])
+            if act_match and act_match.group(1) != current_act:
+                current_act = act_match.group(1)
+                markdown += f"\n### 📄 Act {current_act}\n\n"
+        
+        markdown += f"{status_icon} **{stage['name']}**"
+        
+        if stage.get('page_count', 0) > 0:
+            markdown += f" ({stage['page_count']:.1f} pages)"
+        
+        markdown += "\n"
+        
+        if stage['content'] and stage['status'] == 'complete':
+            preview_length = 200
+            preview = stage['content'][:preview_length] + "..." if len(stage['content']) > preview_length else stage['content']
+            markdown += f"> {preview}\n\n"
+        elif stage['status'] == 'active':
+            markdown += "> *In progress...*\n\n"
+    
+    return markdown
 
 def process_query(query: str, screenplay_type: str, genre: str, language: str, 
                 session_id: Optional[str] = None) -> Generator[Tuple[str, str, str, str], None, None]:
-   """Main query processing function"""
-   if not query.strip():
-       yield "", "", "❌ Please enter a screenplay concept.", session_id
-       return
-   
-   system = ScreenplayGenerationSystem()
-   stages_markdown = ""
-   screenplay_display = ""
-   
-   for status, stages, current_session_id in system.process_screenplay_stream(
-       query, screenplay_type, genre, language, session_id
-   ):
-       stages_markdown = format_stages_display(stages)
-       
-       # Get screenplay content when available
-       if stages and all(s.get("status") == "complete" for s in stages[-4:]):
-           screenplay_text = ScreenplayDatabase.get_screenplay_content(current_session_id)
-           screenplay_display = format_screenplay_display(screenplay_text)
-       
-       yield stages_markdown, screenplay_display, status or "🔄 Processing...", current_session_id
+    """Main query processing function"""
+    if not query.strip():
+        yield "", "", "❌ Please enter a screenplay concept.", session_id
+        return
+    
+    system = ScreenplayGenerationSystem()
+    stages_markdown = ""
+    screenplay_display = ""
+    
+    for status, stages, current_session_id in system.process_screenplay_stream(
+        query, screenplay_type, genre, language, session_id
+    ):
+        stages_markdown = format_stages_display(stages)
+        
+        # Get screenplay content when available
+        if stages and all(s.get("status") == "complete" for s in stages[-4:]):
+            screenplay_text = ScreenplayDatabase.get_screenplay_content(current_session_id)
+            screenplay_display = format_screenplay_display(screenplay_text)
+        
+        yield stages_markdown, screenplay_display, status or "🔄 Processing...", current_session_id
 
 def get_active_sessions() -> List[str]:
-   """Get active screenplay sessions"""
-   sessions = ScreenplayDatabase.get_active_sessions()
-   return [
-       f"{s['session_id'][:8]}... - {s.get('title', s['user_query'][:30])}... "
-       f"({s['screenplay_type']}/{s['genre']}) [{s['total_pages']:.1f} pages]"
-       for s in sessions
-   ]
+    """Get active screenplay sessions"""
+    sessions = ScreenplayDatabase.get_active_sessions()
+    return [
+        f"{s['session_id'][:8]}... - {s.get('title', s['user_query'][:30])}... "
+        f"({s['screenplay_type']}/{s['genre']}) [{s['total_pages']:.1f} pages]"
+        for s in sessions
+    ]
 
 def export_screenplay_pdf(screenplay_text: str, title: str, session_id: str) -> str:
-   """Export screenplay to PDF format"""
-   # This would use a library like reportlab to create industry-standard PDF
-   # For now, returning a placeholder
-   pdf_path = f"screenplay_{session_id[:8]}.pdf"
-   # PDF generation logic would go here
-   return pdf_path
+    """Export screenplay to PDF format"""
+    # This would use a library like reportlab to create industry-standard PDF
+    # For now, returning a placeholder
+    pdf_path = f"screenplay_{session_id[:8]}.pdf"
+    # PDF generation logic would go here
+    return pdf_path
 
 def export_screenplay_fdx(screenplay_text: str, title: str, session_id: str) -> str:
-   """Export to Final Draft format"""
-   # This would create .fdx XML format
-   fdx_path = f"screenplay_{session_id[:8]}.fdx"
-   # FDX generation logic would go here
-   return fdx_path
+    """Export to Final Draft format"""
+    # This would create .fdx XML format
+    fdx_path = f"screenplay_{session_id[:8]}.fdx"
+    # FDX generation logic would go here
+    return fdx_path
 
 def download_screenplay(screenplay_text: str, format_type: str, title: str, 
                       session_id: str) -> Optional[str]:
-   """Generate screenplay download file"""
-   if not screenplay_text or not session_id:
-       return None
-   
-   timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-   
-   try:
-       if format_type == "PDF":
-           return export_screenplay_pdf(screenplay_text, title, session_id)
-       elif format_type == "FDX":
-           return export_screenplay_fdx(screenplay_text, title, session_id)
-       elif format_type == "FOUNTAIN":
-           filepath = f"screenplay_{session_id[:8]}_{timestamp}.fountain"
-           with open(filepath, 'w', encoding='utf-8') as f:
-               f.write(screenplay_text)
-           return filepath
-       else:  # TXT
-           filepath = f"screenplay_{session_id[:8]}_{timestamp}.txt"
-           with open(filepath, 'w', encoding='utf-8') as f:
-               f.write(f"Title: {title}\n")
-               f.write("=" * 50 + "\n\n")
-               f.write(screenplay_text)
-           return filepath
-   except Exception as e:
-       logger.error(f"Download generation failed: {e}")
-       return None
+    """Generate screenplay download file"""
+    if not screenplay_text or not session_id:
+        return None
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    try:
+        if format_type == "PDF":
+            return export_screenplay_pdf(screenplay_text, title, session_id)
+        elif format_type == "FDX":
+            return export_screenplay_fdx(screenplay_text, title, session_id)
+        elif format_type == "FOUNTAIN":
+            filepath = f"screenplay_{session_id[:8]}_{timestamp}.fountain"
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(screenplay_text)
+            return filepath
+        else:  # TXT
+            filepath = f"screenplay_{session_id[:8]}_{timestamp}.txt"
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(f"Title: {title}\n")
+                f.write("=" * 50 + "\n\n")
+                f.write(screenplay_text)
+            return filepath
+    except Exception as e:
+        logger.error(f"Download generation failed: {e}")
+        return None
 
 # Create Gradio interface
 def create_interface():
-   """Create Gradio interface for screenplay generation"""
-   
-   css = """
-   .main-header {
-       text-align: center;
-       margin-bottom: 2rem;
-       padding: 2rem;
-       background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
-       border-radius: 10px;
-       color: white;
-   }
-   
-   .header-title {
-       font-size: 3rem;
-       margin-bottom: 1rem;
-       background: linear-gradient(45deg, #f39c12, #e74c3c);
-       -webkit-background-clip: text;
-       -webkit-text-fill-color: transparent;
-   }
-   
-   .header-description {
-       font-size: 1.1rem;
-       opacity: 0.9;
-       line-height: 1.6;
-   }
-   
-   .type-selector {
-       display: flex;
-       gap: 1rem;
-       margin: 1rem 0;
-   }
-   
-   .type-card {
-       flex: 1;
-       padding: 1rem;
-       border: 2px solid #ddd;
-       border-radius: 8px;
-       cursor: pointer;
-       transition: all 0.3s;
-   }
-   
-   .type-card:hover {
-       border-color: #f39c12;
-       transform: translateY(-2px);
-   }
-   
-   .type-card.selected {
-       border-color: #e74c3c;
-       background: #fff5f5;
-   }
-   
-   #stages-display {
-       max-height: 600px;
-       overflow-y: auto;
-       padding: 1rem;
-       background: #f8f9fa;
-       border-radius: 8px;
-   }
-   
-   #screenplay-output {
-       font-family: 'Courier New', monospace;
-       white-space: pre-wrap;
-       background: white;
-       padding: 2rem;
-       border: 1px solid #ddd;
-       border-radius: 8px;
-       max-height: 800px;
-       overflow-y: auto;
-   }
-   
-   .genre-grid {
-       display: grid;
-       grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-       gap: 0.5rem;
-       margin: 1rem 0;
-   }
-   
-   .genre-btn {
-       padding: 0.75rem;
-       border: 2px solid #e0e0e0;
-       background: white;
-       border-radius: 8px;
-       cursor: pointer;
-       transition: all 0.3s;
-       text-align: center;
-   }
-   
-   .genre-btn:hover {
-       border-color: #f39c12;
-       background: #fffbf0;
-   }
-   
-   .genre-btn.selected {
-       border-color: #e74c3c;
-       background: #fff5f5;
-       font-weight: bold;
-   }
-   """
-   
-   with gr.Blocks(theme=gr.themes.Soft(), css=css, title="Screenplay Generator") as interface:
-       gr.HTML("""
-       <div class="main-header">
-           <h1 class="header-title">🎬 AI Screenplay Generator</h1>
-           <p class="header-description">
-               Transform your ideas into professional screenplays for films, TV shows, and streaming series.
-               Using industry-standard format and story structure to create compelling, producible scripts.
-           </p>
-       </div>
-       """)
-       
-       # State management
-       current_session_id = gr.State(None)
-       
-       with gr.Tabs():
-           # Main Writing Tab
-           with gr.Tab("✍️ Write Screenplay"):
-               with gr.Row():
-                   with gr.Column(scale=3):
-                       query_input = gr.Textbox(
-                           label="Screenplay Concept",
-                           placeholder="""Describe your screenplay idea. For example:
+    """Create Gradio interface for screenplay generation"""
+    
+    css = """
+    .main-header {
+        text-align: center;
+        margin-bottom: 2rem;
+        padding: 2rem;
+        background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+        border-radius: 10px;
+        color: white;
+    }
+    
+    .header-title {
+        font-size: 3rem;
+        margin-bottom: 1rem;
+        background: linear-gradient(45deg, #f39c12, #e74c3c);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+    }
+    
+    .header-description {
+        font-size: 1.1rem;
+        opacity: 0.9;
+        line-height: 1.6;
+    }
+    
+    .type-selector {
+        display: flex;
+        gap: 1rem;
+        margin: 1rem 0;
+    }
+    
+    .type-card {
+        flex: 1;
+        padding: 1rem;
+        border: 2px solid #ddd;
+        border-radius: 8px;
+        cursor: pointer;
+        transition: all 0.3s;
+    }
+    
+    .type-card:hover {
+        border-color: #f39c12;
+        transform: translateY(-2px);
+    }
+    
+    .type-card.selected {
+        border-color: #e74c3c;
+        background: #fff5f5;
+    }
+    
+    #stages-display {
+        max-height: 600px;
+        overflow-y: auto;
+        padding: 1rem;
+        background: #f8f9fa;
+        border-radius: 8px;
+    }
+    
+    #screenplay-output {
+        font-family: 'Courier New', monospace;
+        white-space: pre-wrap;
+        background: white;
+        padding: 2rem;
+        border: 1px solid #ddd;
+        border-radius: 8px;
+        max-height: 800px;
+        overflow-y: auto;
+    }
+    
+    .genre-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+        gap: 0.5rem;
+        margin: 1rem 0;
+    }
+    
+    .genre-btn {
+        padding: 0.75rem;
+        border: 2px solid #e0e0e0;
+        background: white;
+        border-radius: 8px;
+        cursor: pointer;
+        transition: all 0.3s;
+        text-align: center;
+    }
+    
+    .genre-btn:hover {
+        border-color: #f39c12;
+        background: #fffbf0;
+    }
+    
+    .genre-btn.selected {
+        border-color: #e74c3c;
+        background: #fff5f5;
+        font-weight: bold;
+    }
+    """
+    
+    with gr.Blocks(theme=gr.themes.Soft(), css=css, title="Screenplay Generator") as interface:
+        gr.HTML("""
+        <div class="main-header">
+            <h1 class="header-title">🎬 AI Screenplay Generator</h1>
+            <p class="header-description">
+                Transform your ideas into professional screenplays for films, TV shows, and streaming series.
+                Using industry-standard format and story structure to create compelling, producible scripts.
+            </p>
+        </div>
+        """)
+        
+        # State management
+        current_session_id = gr.State(None)
+        
+        with gr.Tabs():
+            # Main Writing Tab
+            with gr.Tab("✍️ Write Screenplay"):
+                with gr.Row():
+                    with gr.Column(scale=3):
+                        query_input = gr.Textbox(
+                            label="Screenplay Concept",
+                            placeholder="""Describe your screenplay idea. For example:
 - A detective with memory loss must solve their own attempted murder
 - Two rival food truck owners forced to work together to save the city food festival  
 - A space station AI develops consciousness during a critical mission
 - A family reunion turns into a murder mystery during a hurricane
 
 The more specific your concept, the better the screenplay will be tailored to your vision.""",
-                           lines=6
-                       )
-                   
-                   with gr.Column(scale=1):
-                       screenplay_type = gr.Radio(
-                           choices=list(SCREENPLAY_LENGTHS.keys()),
-                           value="movie",
-                           label="Screenplay Type",
-                           info="Choose your format"
-                       )
-                       
-                       genre_select = gr.Dropdown(
-                           choices=list(GENRE_TEMPLATES.keys()),
-                           value="drama",
-                           label="Primary Genre",
-                           info="Select main genre"
-                       )
-                       
-                       language_select = gr.Radio(
-                           choices=["English", "Korean"],
-                           value="English",
-                           label="Language"
-                       )
-               
-               with gr.Row():
-                   random_btn = gr.Button("🎲 Random Concept", scale=1)
-                   clear_btn = gr.Button("🗑️ Clear", scale=1)
-                   submit_btn = gr.Button("🎬 Start Writing", variant="primary", scale=2)
-               
-               status_text = gr.Textbox(
-                   label="Status",
-                   interactive=False,
-                   value="Ready to create your screenplay"
-               )
-               
-               # Session management
-               with gr.Group():
-                   gr.Markdown("### 📁 Saved Projects")
-                   with gr.Row():
-                       session_dropdown = gr.Dropdown(
-                           label="Active Sessions",
-                           choices=[],
-                           interactive=True,
-                           scale=3
-                       )
-                       refresh_btn = gr.Button("🔄", scale=1)
-                       resume_btn = gr.Button("📂 Load", scale=1)
-               
-               # Output displays
-               with gr.Row():
-                   with gr.Column():
-                       with gr.Tab("🎭 Writing Progress"):
-                           stages_display = gr.Markdown(
-                               value="*Your screenplay journey will unfold here...*",
-                               elem_id="stages-display"
-                           )
-                       
-                       with gr.Tab("📄 Screenplay"):
-                           screenplay_output = gr.Markdown(
-                               value="*Your formatted screenplay will appear here...*",
-                               elem_id="screenplay-output"
-                           )
-                           
-                           with gr.Row():
-                               format_select = gr.Radio(
-                                   choices=["PDF", "FDX", "FOUNTAIN", "TXT"],
-                                   value="PDF",
-                                   label="Export Format"
-                               )
-                               download_btn = gr.Button("📥 Download Screenplay", variant="secondary")
-                           
-                           download_file = gr.File(
-                               label="Download",
-                               visible=False
-                           )
-               
-               # Examples
-               gr.Examples(
-                   examples=[
-                       ["A burned-out teacher discovers her students are being replaced by AI duplicates"],
-                       ["Two funeral home employees accidentally release a ghost who helps them solve murders"],
-                       ["A time-loop forces a wedding planner to relive the worst wedding until they find true love"],
-                       ["An astronaut returns to Earth to find everyone has forgotten space exists"],
-                       ["A support group for reformed villains must save the city when heroes disappear"],
-                       ["A food critic loses their sense of taste and teams up with a street food vendor"]
-                   ],
-                   inputs=query_input,
-                   label="💡 Example Concepts"
-               )
-           
-           # Screenplay Library Tab
-           with gr.Tab("📚 Concept Library"):
-               gr.Markdown("""
-               ### 🎲 Random Screenplay Concepts
-               
-               Browse through AI-generated screenplay concepts. Each concept includes a title, logline, and brief setup.
-               """)
-               
-               library_display = gr.HTML(
-                   value="<p>Library feature coming soon...</p>"
-               )
-       
-       # Event handlers
-       def handle_submit(query, s_type, genre, lang, session_id):
-           if not query:
-               yield "", "", "❌ Please enter a concept", session_id
-               return
-           
-           yield from process_query(query, s_type, genre, lang, session_id)
-       
-       def handle_random(s_type, genre, lang):
-           return generate_random_screenplay_theme(s_type, genre, lang)
-       
-       def handle_download(screenplay_text, format_type, session_id):
-           if not screenplay_text or not session_id:
-               return gr.update(visible=False)
-           
-           # Get title from database
-           session = ScreenplayDatabase.get_session(session_id)
-           title = session.get('title', 'Untitled') if session else 'Untitled'
-           
-           file_path = download_screenplay(screenplay_text, format_type, title, session_id)
-           if file_path and os.path.exists(file_path):
-               return gr.update(value=file_path, visible=True)
-           return gr.update(visible=False)
-       
-       # Connect events
-       submit_btn.click(
-           fn=handle_submit,
-           inputs=[query_input, screenplay_type, genre_select, language_select, current_session_id],
-           outputs=[stages_display, screenplay_output, status_text, current_session_id]
-       )
-       
-       random_btn.click(
-           fn=handle_random,
-           inputs=[screenplay_type, genre_select, language_select],
-           outputs=[query_input]
-       )
-       
-       clear_btn.click(
-           fn=lambda: ("", "", "Ready to create your screenplay", None),
-           outputs=[stages_display, screenplay_output, status_text, current_session_id]
-       )
-       
-       refresh_btn.click(
-           fn=get_active_sessions,
-           outputs=[session_dropdown]
-       )
-       
-       download_btn.click(
-           fn=handle_download,
-           inputs=[screenplay_output, format_select, current_session_id],
-           outputs=[download_file]
-       )
-       
-       # Load sessions on start
-       interface.load(
-           fn=get_active_sessions,
-           outputs=[session_dropdown]
-       )
-   
-   return interface
+                            lines=6
+                        )
+                    
+                    with gr.Column(scale=1):
+                        screenplay_type = gr.Radio(
+                            choices=list(SCREENPLAY_LENGTHS.keys()),
+                            value="movie",
+                            label="Screenplay Type",
+                            info="Choose your format"
+                        )
+                        
+                        genre_select = gr.Dropdown(
+                            choices=list(GENRE_TEMPLATES.keys()),
+                            value="drama",
+                            label="Primary Genre",
+                            info="Select main genre"
+                        )
+                        
+                        language_select = gr.Radio(
+                            choices=["English", "Korean"],
+                            value="English",
+                            label="Language"
+                        )
+                
+                with gr.Row():
+                    random_btn = gr.Button("🎲 Random Concept", scale=1)
+                    clear_btn = gr.Button("🗑️ Clear", scale=1)
+                    submit_btn = gr.Button("🎬 Start Writing", variant="primary", scale=2)
+                
+                status_text = gr.Textbox(
+                    label="Status",
+                    interactive=False,
+                    value="Ready to create your screenplay"
+                )
+                
+                # Session management
+                with gr.Group():
+                    gr.Markdown("### 📁 Saved Projects")
+                    with gr.Row():
+                        session_dropdown = gr.Dropdown(
+                            label="Active Sessions",
+                            choices=[],
+                            interactive=True,
+                            scale=3
+                        )
+                        refresh_btn = gr.Button("🔄", scale=1)
+                        resume_btn = gr.Button("📂 Load", scale=1)
+                
+                # Output displays
+                with gr.Row():
+                    with gr.Column():
+                        with gr.Tab("🎭 Writing Progress"):
+                            stages_display = gr.Markdown(
+                                value="*Your screenplay journey will unfold here...*",
+                                elem_id="stages-display"
+                            )
+                        
+                        with gr.Tab("📄 Screenplay"):
+                            screenplay_output = gr.Markdown(
+                                value="*Your formatted screenplay will appear here...*",
+                                elem_id="screenplay-output"
+                            )
+                            
+                            with gr.Row():
+                                format_select = gr.Radio(
+                                    choices=["PDF", "FDX", "FOUNTAIN", "TXT"],
+                                    value="PDF",
+                                    label="Export Format"
+                                )
+                                download_btn = gr.Button("📥 Download Screenplay", variant="secondary")
+                            
+                            download_file = gr.File(
+                                label="Download",
+                                visible=False
+                            )
+                
+                # Examples
+                gr.Examples(
+                    examples=[
+                        ["A burned-out teacher discovers her students are being replaced by AI duplicates"],
+                        ["Two funeral home employees accidentally release a ghost who helps them solve murders"],
+                        ["A time-loop forces a wedding planner to relive the worst wedding until they find true love"],
+                        ["An astronaut returns to Earth to find everyone has forgotten space exists"],
+                        ["A support group for reformed villains must save the city when heroes disappear"],
+                        ["A food critic loses their sense of taste and teams up with a street food vendor"]
+                    ],
+                    inputs=query_input,
+                    label="💡 Example Concepts"
+                )
+            
+            # Screenplay Library Tab
+            with gr.Tab("📚 Concept Library"):
+                gr.Markdown("""
+                ### 🎲 Random Screenplay Concepts
+                
+                Browse through AI-generated screenplay concepts. Each concept includes a title, logline, and brief setup.
+                """)
+                
+                library_display = gr.HTML(
+                    value="<p>Library feature coming soon...</p>"
+                )
+        
+        # Event handlers
+        def handle_submit(query, s_type, genre, lang, session_id):
+            if not query:
+                yield "", "", "❌ Please enter a concept", session_id
+                return
+            
+            yield from process_query(query, s_type, genre, lang, session_id)
+        
+        def handle_random(s_type, genre, lang):
+            return generate_random_screenplay_theme(s_type, genre, lang)
+        
+        def handle_download(screenplay_text, format_type, session_id):
+            if not screenplay_text or not session_id:
+                return gr.update(visible=False)
+            
+            # Get title from database
+            session = ScreenplayDatabase.get_session(session_id)
+            title = session.get('title', 'Untitled') if session else 'Untitled'
+            
+            file_path = download_screenplay(screenplay_text, format_type, title, session_id)
+            if file_path and os.path.exists(file_path):
+                return gr.update(value=file_path, visible=True)
+            return gr.update(visible=False)
+        
+        # Connect events
+        submit_btn.click(
+            fn=handle_submit,
+            inputs=[query_input, screenplay_type, genre_select, language_select, current_session_id],
+            outputs=[stages_display, screenplay_output, status_text, current_session_id]
+        )
+        
+        random_btn.click(
+            fn=handle_random,
+            inputs=[screenplay_type, genre_select, language_select],
+            outputs=[query_input]
+        )
+        
+        clear_btn.click(
+            fn=lambda: ("", "", "Ready to create your screenplay", None),
+            outputs=[stages_display, screenplay_output, status_text, current_session_id]
+        )
+        
+        refresh_btn.click(
+            fn=get_active_sessions,
+            outputs=[session_dropdown]
+        )
+        
+        download_btn.click(
+            fn=handle_download,
+            inputs=[screenplay_output, format_select, current_session_id],
+            outputs=[download_file]
+        )
+        
+        # Load sessions on start
+        interface.load(
+            fn=get_active_sessions,
+            outputs=[session_dropdown]
+        )
+    
+    return interface
 
 # Main function
 if __name__ == "__main__":
-   logger.info("Screenplay Generator Starting...")
-   logger.info("=" * 60)
-   
-   # Environment check
-   logger.info(f"API Endpoint: {API_URL}")
-   logger.info("Screenplay Types Available:")
-   for s_type, info in SCREENPLAY_LENGTHS.items():
-       logger.info(f"  - {s_type}: {info['description']}")
-   logger.info(f"Genres: {', '.join(GENRE_TEMPLATES.keys())}")
-   
-   if BRAVE_SEARCH_API_KEY:
-       logger.info("Web search enabled for market research.")
-   else:
-       logger.warning("Web search disabled.")
-   
-   logger.info("=" * 60)
-   
-   # Initialize database
-   logger.info("Initializing database...")
-   ScreenplayDatabase.init_db()
-   logger.info("Database initialization complete.")
-   
-   # Create and launch interface
-   interface = create_interface()
-   
-   interface.launch(
-       server_name="0.0.0.0",
-       server_port=7860,
-       share=False,
-       debug=True
-   )               
+    logger.info("Screenplay Generator Starting...")
+    logger.info("=" * 60)
+    
+    # Environment check
+    logger.info(f"API Endpoint: {API_URL}")
+    logger.info("Screenplay Types Available:")
+    for s_type, info in SCREENPLAY_LENGTHS.items():
+        logger.info(f"  - {s_type}: {info['description']}")
+    logger.info(f"Genres: {', '.join(GENRE_TEMPLATES.keys())}")
+    
+    if BRAVE_SEARCH_API_KEY:
+        logger.info("Web search enabled for market research.")
+    else:
+        logger.warning("Web search disabled.")
+    
+    logger.info("=" * 60)
+    
+    # Initialize database
+    logger.info("Initializing database...")
+    ScreenplayDatabase.init_db()
+    logger.info("Database initialization complete.")
+    
+    # Create and launch interface
+    interface = create_interface()
+    
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True
+    )