Update app.py

app.py

@@ -4,11 +4,15 @@ import json
 import requests
 from datetime import datetime
 import time
-from typing import List, Dict, Any, Generator, Tuple
+from typing import List, Dict, Any, Generator, Tuple, Optional
 import logging
 import re
 import tempfile
 from pathlib import Path
+import sqlite3
+import hashlib
+import threading
+from contextlib import contextmanager
 
 # 로깅 설정
 logging.basicConfig(level=logging.INFO)
@@ -36,6 +40,186 @@ conversation_history = []
 selected_language = "English"  # 기본 언어
 novel_context = {}  # 소설 컨텍스트 저장
 
+# DB 경로
+DB_PATH = "novel_sessions.db"
+db_lock = threading.Lock()
+
+class NovelDatabase:
+    """Novel session management database"""
+    
+    @staticmethod
+    def init_db():
+        """Initialize database tables"""
+        with sqlite3.connect(DB_PATH) as conn:
+            cursor = conn.cursor()
+            
+            # Sessions table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS sessions (
+                    session_id TEXT PRIMARY KEY,
+                    user_query TEXT NOT NULL,
+                    language TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    status TEXT DEFAULT 'active',
+                    current_stage INTEGER DEFAULT 0,
+                    final_novel TEXT
+                )
+            ''')
+            
+            # Stages table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS stages (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    stage_number INTEGER NOT NULL,
+                    stage_name TEXT NOT NULL,
+                    role TEXT NOT NULL,
+                    content TEXT,
+                    status TEXT DEFAULT 'pending',
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+                )
+            ''')
+            
+            # Create indices
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_session_id ON stages(session_id)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_stage_number ON stages(stage_number)')
+            
+            conn.commit()
+    
+    @staticmethod
+    @contextmanager
+    def get_db():
+        """Database connection context manager"""
+        with db_lock:
+            conn = sqlite3.connect(DB_PATH)
+            conn.row_factory = sqlite3.Row
+            try:
+                yield conn
+            finally:
+                conn.close()
+    
+    @staticmethod
+    def create_session(user_query: str, language: str) -> str:
+        """Create new session"""
+        session_id = hashlib.md5(f"{user_query}{datetime.now()}".encode()).hexdigest()
+        
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                INSERT INTO sessions (session_id, user_query, language)
+                VALUES (?, ?, ?)
+            ''', (session_id, user_query, language))
+            conn.commit()
+        
+        return session_id
+    
+    @staticmethod
+    def save_stage(session_id: str, stage_number: int, stage_name: str, 
+                   role: str, content: str, status: str = 'complete'):
+        """Save stage content"""
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            
+            # Check if stage exists
+            cursor.execute('''
+                SELECT id FROM stages 
+                WHERE session_id = ? AND stage_number = ?
+            ''', (session_id, stage_number))
+            
+            existing = cursor.fetchone()
+            
+            if existing:
+                # Update existing stage
+                cursor.execute('''
+                    UPDATE stages 
+                    SET content = ?, status = ?, stage_name = ?
+                    WHERE session_id = ? AND stage_number = ?
+                ''', (content, status, stage_name, session_id, stage_number))
+            else:
+                # Insert new stage
+                cursor.execute('''
+                    INSERT INTO stages (session_id, stage_number, stage_name, role, content, status)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                ''', (session_id, stage_number, stage_name, role, content, status))
+            
+            # Update session
+            cursor.execute('''
+                UPDATE sessions 
+                SET updated_at = CURRENT_TIMESTAMP, current_stage = ?
+                WHERE session_id = ?
+            ''', (stage_number, session_id))
+            
+            conn.commit()
+    
+    @staticmethod
+    def get_session(session_id: str) -> Optional[Dict]:
+        """Get session info"""
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute('SELECT * FROM sessions WHERE session_id = ?', (session_id,))
+            return cursor.fetchone()
+    
+    @staticmethod
+    def get_stages(session_id: str) -> List[Dict]:
+        """Get all stages for a session"""
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT * FROM stages 
+                WHERE session_id = ? 
+                ORDER BY stage_number
+            ''', (session_id,))
+            return cursor.fetchall()
+    
+    @staticmethod
+    def get_completed_content(session_id: str, up_to_stage: int) -> str:
+        """Get all completed content up to specified stage"""
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT content FROM stages 
+                WHERE session_id = ? 
+                AND stage_number < ?
+                AND status = 'complete'
+                AND role LIKE 'writer%'
+                ORDER BY stage_number
+            ''', (session_id, up_to_stage))
+            
+            contents = []
+            for row in cursor.fetchall():
+                if row['content']:
+                    contents.append(row['content'])
+            
+            return '\n\n'.join(contents)
+    
+    @staticmethod
+    def update_final_novel(session_id: str, final_novel: str):
+        """Update final novel content"""
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                UPDATE sessions 
+                SET final_novel = ?, status = 'complete', updated_at = CURRENT_TIMESTAMP
+                WHERE session_id = ?
+            ''', (final_novel, session_id))
+            conn.commit()
+    
+    @staticmethod
+    def get_active_sessions() -> List[Dict]:
+        """Get all active sessions"""
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT session_id, user_query, language, created_at, current_stage
+                FROM sessions 
+                WHERE status = 'active'
+                ORDER BY updated_at DESC
+                LIMIT 10
+            ''')
+            return cursor.fetchall()
+
 class NovelWritingSystem:
     def __init__(self):
         self.token = FRIENDLI_TOKEN
@@ -46,6 +230,13 @@ class NovelWritingSystem:
         if self.test_mode:
             logger.warning("Running in test mode.")
         
+        # Initialize database
+        NovelDatabase.init_db()
+        
+        # Session management
+        self.current_session_id = None
+        self.auto_scroll = False  # Auto-scroll control
+        
         # 소설 작성 진행 상태
         self.novel_state = {
             "theme": "",
@@ -1258,11 +1449,25 @@ Last page content from Writer {writer_num}..."""
         
         return test_responses.get(role, "Test response.")
     
-    def process_novel_stream(self, query: str, language: str = "English") -> Generator[Tuple[str, List[Dict[str, str]]], None, None]:
+    def process_novel_stream(self, query: str, language: str = "English", 
+                           session_id: Optional[str] = None, 
+                           resume_from_stage: int = 0) -> Generator[Tuple[str, List[Dict[str, str]]], None, None]:
         """Process novel writing with streaming updates"""
         try:
             global conversation_history, novel_context
             
+            # Create or resume session
+            if session_id:
+                self.current_session_id = session_id
+                session = NovelDatabase.get_session(session_id)
+                if session:
+                    query = session['user_query']
+                    language = session['language']
+                    resume_from_stage = session['current_stage'] + 1
+            else:
+                self.current_session_id = NovelDatabase.create_session(query, language)
+                resume_from_stage = 0
+            
             # Initialize conversation
             conversation_history = [{
                 "role": "human",
@@ -1270,203 +1475,116 @@ Last page content from Writer {writer_num}..."""
                 "timestamp": datetime.now()
             }]
             
+            # Load existing stages if resuming
             stages = []
-            accumulated_content = ""
-            
-            # 1. Director Initial Planning
-            stages.append({
-                "name": f"🎬 {'감독자: 초기 기획' if language == 'Korean' else 'Director: Initial Planning'}",
-                "status": "active",
-                "content": ""
-            })
-            yield "", stages
-            
-            director_prompt = self.create_director_initial_prompt(query, language)
-            director_plan = ""
-            
-            for chunk in self.call_llm_streaming(
-                [{"role": "user", "content": director_prompt}],
-                "director",
-                language
-            ):
-                director_plan += chunk
-                stages[0]["content"] = director_plan
-                yield "", stages
-            
-            stages[0]["status"] = "complete"
-            self.novel_state["theme"] = director_plan
-            
-            # 2. Critic Review of Plan
-            stages.append({
-                "name": f"📝 {'비평가: 기획 검토' if language == 'Korean' else 'Critic: Plan Review'}",
-                "status": "active",
-                "content": ""
-            })
-            yield "", stages
-            
-            critic_prompt = self.create_critic_director_prompt(director_plan, language)
-            critic_feedback = ""
-            
-            for chunk in self.call_llm_streaming(
-                [{"role": "user", "content": critic_prompt}],
-                "critic",
-                language
-            ):
-                critic_feedback += chunk
-                stages[1]["content"] = critic_feedback
-                yield "", stages
-            
-            stages[1]["status"] = "complete"
+            if resume_from_stage > 0:
+                existing_stages = NovelDatabase.get_stages(self.current_session_id)
+                for stage_data in existing_stages:
+                    stages.append({
+                        "name": stage_data['stage_name'],
+                        "status": stage_data['status'],
+                        "content": stage_data['content'] or ""
+                    })
             
-            # 3. Director Revision
-            stages.append({
-                "name": f"🎬 {'감독자: 수정된 마스터플랜' if language == 'Korean' else 'Director: Revised Masterplan'}",
-                "status": "active",
-                "content": ""
-            })
-            yield "", stages
+            accumulated_content = ""
+            if resume_from_stage > 0:
+                accumulated_content = NovelDatabase.get_completed_content(
+                    self.current_session_id, 
+                    resume_from_stage
+                )
             
-            revision_prompt = self.create_director_revision_prompt(director_plan, critic_feedback, language)
-            final_plan = ""
+            # Define all stages
+            stage_definitions = [
+                ("director", f"🎬 {'감독자: 초기 기획' if language == 'Korean' else 'Director: Initial Planning'}"),
+                ("critic", f"📝 {'비평가: 기획 검토' if language == 'Korean' else 'Critic: Plan Review'}"),
+                ("director", f"🎬 {'감독자: 수정된 마스터플랜' if language == 'Korean' else 'Director: Revised Masterplan'}"),
+            ]
             
-            for chunk in self.call_llm_streaming(
-                [{"role": "user", "content": revision_prompt}],
-                "director",
-                language
-            ):
-                final_plan += chunk
-                stages[2]["content"] = final_plan
-                yield "", stages
+            # Add writer stages
+            for writer_num in range(1, 11):
+                stage_definitions.extend([
+                    (f"writer{writer_num}", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} {writer_num}: {'초안' if language == 'Korean' else 'Draft'}"),
+                    ("critic", f"📝 {'비평가: 작성자' if language == 'Korean' else 'Critic: Writer'} {writer_num} {'검토' if language == 'Korean' else 'Review'}"),
+                    (f"writer{writer_num}", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} {writer_num}: {'수정본' if language == 'Korean' else 'Revision'}")
+                ])
             
-            stages[2]["status"] = "complete"
-            self.novel_state["plot_outline"] = final_plan
+            stage_definitions.extend([
+                ("critic", f"📝 {'비평가: 최종 평가' if language == 'Korean' else 'Critic: Final Evaluation'}"),
+                ("director", f"🎬 {'감독자: 최종 완성본' if language == 'Korean' else 'Director: Final Version'}")
+            ])
             
-            # 4-23. Writers 1-10 with critic reviews
-            for writer_num in range(1, 11):
-                # Writer's initial draft
-                writer_stage_idx = 3 + (writer_num - 1) * 2
-                stages.append({
-                    "name": f"✍️ {'작성자' if language == 'Korean' else 'Writer'} {writer_num}: {'초안' if language == 'Korean' else 'Draft'}",
-                    "status": "active",
-                    "content": ""
-                })
-                yield "", stages
+            # Process stages starting from resume point
+            for stage_idx in range(resume_from_stage, len(stage_definitions)):
+                role, stage_name = stage_definitions[stage_idx]
                 
-                writer_prompt = self.create_writer_prompt(writer_num, final_plan, accumulated_content, language)
-                writer_content = ""
+                # Add stage if not already present
+                if stage_idx >= len(stages):
+                    stages.append({
+                        "name": stage_name,
+                        "status": "active",
+                        "content": ""
+                    })
+                else:
+                    stages[stage_idx]["status"] = "active"
                 
-                for chunk in self.call_llm_streaming(
-                    [{"role": "user", "content": writer_prompt}],
-                    f"writer{writer_num}",
-                    language
-                ):
-                    writer_content += chunk
-                    stages[writer_stage_idx]["content"] = writer_content
-                    yield "", stages
-                
-                stages[writer_stage_idx]["status"] = "complete"
-                
-                # Critic review of writer's work
-                critic_stage_idx = writer_stage_idx + 1
-                stages.append({
-                    "name": f"📝 {'비평가: 작성자' if language == 'Korean' else 'Critic: Writer'} {writer_num} {'검토' if language == 'Korean' else 'Review'}",
-                    "status": "active",
-                    "content": ""
-                })
                 yield "", stages
                 
-                critic_writer_prompt = self.create_critic_writer_prompt(writer_num, writer_content, final_plan, accumulated_content, language)
-                critic_writer_feedback = ""
+                # Get appropriate prompt based on stage
+                prompt = self.get_stage_prompt(stage_idx, role, query, language, 
+                                             stages, accumulated_content)
                 
-                for chunk in self.call_llm_streaming(
-                    [{"role": "user", "content": critic_writer_prompt}],
-                    "critic",
-                    language
-                ):
-                    critic_writer_feedback += chunk
-                    stages[critic_stage_idx]["content"] = critic_writer_feedback
-                    yield "", stages
-                
-                stages[critic_stage_idx]["status"] = "complete"
-                
-                # Writer revision
-                revision_stage_idx = critic_stage_idx + 1
-                stages.append({
-                    "name": f"✍️ {'작성자' if language == 'Korean' else 'Writer'} {writer_num}: {'수정본' if language == 'Korean' else 'Revision'}",
-                    "status": "active",
-                    "content": ""
-                })
-                yield "", stages
-                
-                writer_revision_prompt = self.create_writer_revision_prompt(writer_num, writer_content, critic_writer_feedback, language)
-                revised_content = ""
+                stage_content = ""
                 
+                # Stream content generation
                 for chunk in self.call_llm_streaming(
-                    [{"role": "user", "content": writer_revision_prompt}],
-                    f"writer{writer_num}",
+                    [{"role": "user", "content": prompt}],
+                    role,
                     language
                 ):
-                    revised_content += chunk
-                    stages[revision_stage_idx]["content"] = revised_content
+                    stage_content += chunk
+                    stages[stage_idx]["content"] = stage_content
                     yield "", stages
                 
-                stages[revision_stage_idx]["status"] = "complete"
+                # Mark stage complete and save to DB
+                stages[stage_idx]["status"] = "complete"
+                NovelDatabase.save_stage(
+                    self.current_session_id,
+                    stage_idx,
+                    stage_name,
+                    role,
+                    stage_content,
+                    "complete"
+                )
+                
+                # Accumulate writer content
+                if role.startswith("writer") and "수정본" in stage_name or "Revision" in stage_name:
+                    accumulated_content += f"\n\n{stage_content}"
                 
-                # Add to accumulated content
-                accumulated_content += f"\n\n{revised_content}"
-                self.novel_state[f"writer{writer_num}_final"] = revised_content
-            
-            # 24. Critic Final Evaluation
-            final_critic_idx = len(stages)
-            stages.append({
-                "name": f"📝 {'비평가: 최종 평가' if language == 'Korean' else 'Critic: Final Evaluation'}",
-                "status": "active",
-                "content": ""
-            })
-            yield "", stages
-            
-            critic_final_prompt = self.create_critic_final_prompt(accumulated_content, final_plan, language)
-            critic_final = ""
-            
-            for chunk in self.call_llm_streaming(
-                [{"role": "user", "content": critic_final_prompt}],
-                "critic",
-                language
-            ):
-                critic_final += chunk
-                stages[final_critic_idx]["content"] = critic_final
                 yield "", stages
             
-            stages[final_critic_idx]["status"] = "complete"
-            
-            # 25. Director Final Compilation
-            final_director_idx = len(stages)
-            stages.append({
-                "name": f"🎬 {'감독자: 최종 완성본' if language == 'Korean' else 'Director: Final Version'}",
-                "status": "active",
-                "content": ""
-            })
-            yield "", stages
+            # Get final novel from last stage
+            final_novel = stages[-1]["content"] if stages else ""
             
-            director_final_prompt = self.create_director_final_prompt(accumulated_content, critic_final, language)
-            final_novel = ""
-            
-            for chunk in self.call_llm_streaming(
-                [{"role": "user", "content": director_final_prompt}],
-                "director",
-                language
-            ):
-                final_novel += chunk
-                stages[final_director_idx]["content"] = final_novel
-                yield "", stages
-            
-            stages[final_director_idx]["status"] = "complete"
+            # Save final novel to DB
+            NovelDatabase.update_final_novel(self.current_session_id, final_novel)
             
             # Final yield
             yield final_novel, stages
             
         except Exception as e:
             logger.error(f"Error in process_novel_stream: {str(e)}")
+            
+            # Save error state to DB
+            if self.current_session_id:
+                NovelDatabase.save_stage(
+                    self.current_session_id,
+                    stage_idx if 'stage_idx' in locals() else 0,
+                    "Error",
+                    "error",
+                    str(e),
+                    "error"
+                )
+            
             error_stage = {
                 "name": "❌ Error",
                 "status": "error",
@@ -1474,11 +1592,80 @@ Last page content from Writer {writer_num}..."""
             }
             stages.append(error_stage)
             yield f"Error occurred: {str(e)}", stages
+    
+    def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
+                        language: str, stages: List[Dict], 
+                        accumulated_content: str) -> str:
+        """Get appropriate prompt for each stage"""
+        # Stage 0: Director Initial
+        if stage_idx == 0:
+            return self.create_director_initial_prompt(query, language)
+        
+        # Stage 1: Critic reviews Director's plan
+        elif stage_idx == 1:
+            return self.create_critic_director_prompt(stages[0]["content"], language)
+        
+        # Stage 2: Director revision
+        elif stage_idx == 2:
+            return self.create_director_revision_prompt(
+                stages[0]["content"], stages[1]["content"], language)
+        
+        # Writer stages
+        elif role.startswith("writer"):
+            writer_num = int(role.replace("writer", ""))
+            final_plan = stages[2]["content"]  # Director's final plan
+            
+            # Initial draft or revision?
+            if "초안" in stages[stage_idx]["name"] or "Draft" in stages[stage_idx]["name"]:
+                return self.create_writer_prompt(writer_num, final_plan, accumulated_content, language)
+            else:  # Revision
+                # Find the initial draft and critic feedback
+                initial_draft_idx = stage_idx - 2
+                critic_feedback_idx = stage_idx - 1
+                return self.create_writer_revision_prompt(
+                    writer_num, 
+                    stages[initial_draft_idx]["content"],
+                    stages[critic_feedback_idx]["content"],
+                    language
+                )
+        
+        # Critic stages
+        elif role == "critic":
+            final_plan = stages[2]["content"]
+            
+            # Final evaluation
+            if "최종" in stages[stage_idx]["name"] or "Final" in stages[stage_idx]["name"]:
+                return self.create_critic_final_prompt(accumulated_content, final_plan, language)
+            
+            # Writer review
+            else:
+                # Find which writer we're reviewing
+                for i in range(1, 11):
+                    if f"작성자 {i}" in stages[stage_idx]["name"] or f"Writer {i}" in stages[stage_idx]["name"]:
+                        writer_content_idx = stage_idx - 1
+                        return self.create_critic_writer_prompt(
+                            i,
+                            stages[writer_content_idx]["content"],
+                            final_plan,
+                            accumulated_content,
+                            language
+                        )
+        
+        # Director final
+        elif stage_idx == len(stages) - 1:
+            critic_final_idx = stage_idx - 1
+            return self.create_director_final_prompt(
+                accumulated_content,
+                stages[critic_final_idx]["content"],
+                language
+            )
+        
+        return ""
 
 # Gradio Interface Functions
-def process_query(query: str, language: str) -> Generator[Tuple[str, str, str], None, None]:
+def process_query(query: str, language: str, session_id: str = None) -> Generator[Tuple[str, str, str], None, None]:
     """Process query and yield updates"""
-    if not query.strip():
+    if not query.strip() and not session_id:
         if language == "Korean":
             yield "", "", "❌ 소설 주제를 입력해주세요."
         else:
@@ -1488,9 +1675,9 @@ def process_query(query: str, language: str) -> Generator[Tuple[str, str, str],
     system = NovelWritingSystem()
     
     try:
-        for final_novel, stages in system.process_novel_stream(query, language):
-            # Format stages for display
-            stages_html = format_stages_html(stages, language)
+        for final_novel, stages in system.process_novel_stream(query, language, session_id):
+            # Format stages for display with scroll control
+            stages_html = format_stages_html(stages, language, system.auto_scroll)
             
             status = "🔄 Processing..." if not final_novel else "✅ Complete!"
             
@@ -1503,16 +1690,19 @@ def process_query(query: str, language: str) -> Generator[Tuple[str, str, str],
         else:
             yield "", "", f"❌ Error occurred: {str(e)}"
 
-def format_stages_html(stages: List[Dict[str, str]], language: str) -> str:
-    """Format stages into HTML"""
-    html = '<div class="stages-container">'
+def format_stages_html(stages: List[Dict[str, str]], language: str, auto_scroll: bool = False) -> str:
+    """Format stages into HTML with scroll control"""
+    scroll_behavior = "auto" if auto_scroll else "manual"
+    
+    html = f'<div class="stages-container" data-scroll="{scroll_behavior}">'
     
-    for stage in stages:
+    for idx, stage in enumerate(stages):
         status_icon = "✅" if stage.get("status") == "complete" else ("⏳" if stage.get("status") == "active" else "❌")
         
         # Create collapsible section for each stage
+        is_active = stage.get("status") == "active"
         html += f'''
-        <details class="stage-section" {"open" if stage.get("status") == "active" else ""}>
+        <details class="stage-section" {"open" if is_active else ""} id="stage-{idx}">
             <summary class="stage-header">
                 <span class="status-icon">{status_icon}</span>
                 <span class="stage-name">{stage["name"]}</span>
@@ -1524,8 +1714,58 @@ def format_stages_html(stages: List[Dict[str, str]], language: str) -> str:
         '''
     
     html += '</div>'
+    
+    # Add JavaScript for scroll control
+    if not auto_scroll:
+        html += '''
+        <script>
+        // Prevent auto-scrolling when content updates
+        const container = document.querySelector('.stages-container[data-scroll="manual"]');
+        if (container) {
+            let userScrolled = false;
+            container.addEventListener('scroll', () => {
+                userScrolled = true;
+            });
+            
+            // Override scroll behavior on content update
+            const observer = new MutationObserver(() => {
+                if (!userScrolled) {
+                    // Don't auto-scroll
+                }
+            });
+            observer.observe(container, { childList: true, subtree: true });
+        }
+        </script>
+        '''
+    
     return html
 
+def get_active_sessions(language: str) -> List[Tuple[str, str, str]]:
+    """Get list of active sessions"""
+    sessions = NovelDatabase.get_active_sessions()
+    
+    choices = []
+    for session in sessions:
+        created = datetime.fromisoformat(session['created_at'])
+        date_str = created.strftime("%Y-%m-%d %H:%M")
+        query_preview = session['user_query'][:50] + "..." if len(session['user_query']) > 50 else session['user_query']
+        label = f"[{date_str}] {query_preview} (Stage {session['current_stage']})"
+        choices.append((label, session['session_id']))
+    
+    return choices
+
+def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str, str], None, None]:
+    """Resume an existing session"""
+    if not session_id:
+        return
+    
+    # Process with existing session ID
+    yield from process_query("", language, session_id)
+
+def toggle_auto_scroll(current_state: bool) -> bool:
+    """Toggle auto-scroll state"""
+    return not current_state
+
 def download_novel(novel_text: str, format: str, language: str) -> str:
     """Download novel in specified format"""
     if not novel_text:
@@ -1565,7 +1805,7 @@ def download_novel(novel_text: str, format: str, language: str) -> str:
         
         return filepath
 
-# Custom CSS
+# Custom CSS with improved scroll handling
 custom_css = """
 .gradio-container {
     background: linear-gradient(135deg, #1e3c72, #2a5298);
@@ -1579,6 +1819,13 @@ custom_css = """
     background-color: rgba(255, 255, 255, 0.05);
     border-radius: 12px;
     backdrop-filter: blur(10px);
+    scroll-behavior: smooth;
+    position: relative;
+}
+
+/* Disable auto-scroll when user has scrolled */
+.stages-container[data-scroll="manual"] {
+    scroll-behavior: auto;
 }
 
 .stage-section {
@@ -1622,6 +1869,7 @@ custom_css = """
     color: #e0e0e0;
     font-family: 'Courier New', monospace;
     line-height: 1.6;
+    margin: 0;
 }
 
 #novel-output {
@@ -1657,6 +1905,27 @@ custom_css = """
     border-radius: 8px;
     margin-top: 20px;
 }
+
+.session-section {
+    background-color: rgba(255, 255, 255, 0.1);
+    backdrop-filter: blur(10px);
+    padding: 15px;
+    border-radius: 8px;
+    margin-top: 20px;
+    color: white;
+}
+
+/* Scroll position indicator */
+.scroll-indicator {
+    position: absolute;
+    right: 5px;
+    top: 5px;
+    background: rgba(255, 255, 255, 0.2);
+    padding: 5px 10px;
+    border-radius: 15px;
+    font-size: 0.8em;
+    color: white;
+}
 """
 
 # Create Gradio Interface
@@ -1673,10 +1942,15 @@ def create_interface():
             <p style="font-size: 1.1em; color: #ddd; max-width: 800px; margin: 0 auto;">
                 Enter a theme or prompt, and watch as 13 AI agents collaborate to create a complete 50-page novella.
                 The system includes 1 Director, 1 Critic, and 10 Writers working in harmony.
+                All progress is automatically saved and can be resumed anytime.
             </p>
         </div>
         """)
         
+        # State management
+        auto_scroll_state = gr.State(False)
+        current_session_id = gr.State(None)
+        
         with gr.Row():
             with gr.Column(scale=1):
                 with gr.Group(elem_classes=["input-section"]):
@@ -1702,6 +1976,24 @@ def create_interface():
                         value="🔄 Ready"
                     )
                     
+                    # Session management
+                    with gr.Group(elem_classes=["session-section"]):
+                        gr.Markdown("### 💾 Resume Previous Session / 이전 세션 재개")
+                        session_dropdown = gr.Dropdown(
+                            label="Select Session / 세션 선택",
+                            choices=[],
+                            interactive=True
+                        )
+                        with gr.Row():
+                            refresh_btn = gr.Button("🔄 Refresh / 새로고침", scale=1)
+                            resume_btn = gr.Button("▶️ Resume / 재개", variant="secondary", scale=1)
+                    
+                    # Scroll control
+                    auto_scroll_checkbox = gr.Checkbox(
+                        label="Auto-scroll / 자동 스크롤",
+                        value=False
+                    )
+                    
                     gr.HTML("""
                     <div style="margin-top: 20px; padding: 15px; background: rgba(255,255,255,0.1); border-radius: 8px; color: white;">
                         <h4>Writing Process:</h4>
@@ -1714,6 +2006,7 @@ def create_interface():
                             <li>Writers revise based on feedback</li>
                             <li>Final compilation by Director</li>
                         </ol>
+                        <p style="margin-top: 10px;"><strong>Note:</strong> All progress is automatically saved to database.</p>
                     </div>
                     """)
         
@@ -1766,9 +2059,13 @@ def create_interface():
         def update_novel_state(process, novel, status):
             return process, novel, status, novel
         
+        def refresh_sessions():
+            sessions = get_active_sessions("English")
+            return gr.update(choices=sessions)
+        
         submit_btn.click(
             fn=process_query,
-            inputs=[query_input, language_select],
+            inputs=[query_input, language_select, current_session_id],
             outputs=[process_display, novel_output, status_text]
         ).then(
             fn=update_novel_state,
@@ -1776,9 +2073,30 @@ def create_interface():
             outputs=[process_display, novel_output, status_text, novel_text_state]
         )
         
+        resume_btn.click(
+            fn=lambda x: x,
+            inputs=[session_dropdown],
+            outputs=[current_session_id]
+        ).then(
+            fn=resume_session,
+            inputs=[current_session_id, language_select],
+            outputs=[process_display, novel_output, status_text]
+        )
+        
+        refresh_btn.click(
+            fn=refresh_sessions,
+            outputs=[session_dropdown]
+        )
+        
         clear_btn.click(
-            fn=lambda: ("", "", "🔄 Ready", ""),
-            outputs=[process_display, novel_output, status_text, novel_text_state]
+            fn=lambda: ("", "", "🔄 Ready", "", None),
+            outputs=[process_display, novel_output, status_text, novel_text_state, current_session_id]
+        )
+        
+        auto_scroll_checkbox.change(
+            fn=toggle_auto_scroll,
+            inputs=[auto_scroll_state],
+            outputs=[auto_scroll_state]
         )
         
         def handle_download(novel_text, format_type, language):
@@ -1796,6 +2114,12 @@ def create_interface():
             inputs=[novel_text_state, format_select, language_select],
             outputs=[download_file]
         )
+        
+        # Load sessions on startup
+        interface.load(
+            fn=refresh_sessions,
+            outputs=[session_dropdown]
+        )
     
     return interface