Update app.py

app.py

@@ -52,9 +52,10 @@ selected_language = "English"  # 기본 언어
 DB_PATH = "novel_sessions.db"
 db_lock = threading.Lock()
 
-# Stage 번호 상수 - 16명의 작가 반영
-WRITER_DRAFT_STAGES = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48]  # 작가 초안
-WRITER_REVISION_STAGES = [5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50]  # 작가 수정본
+# Stage 번호 상수 - 10명의 작가로 변경
+WRITER_DRAFT_STAGES = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]  # 작가 초안
+WRITER_REVISION_STAGES = [5, 8, 11, 14, 17, 20, 23, 26, 29, 32]  # 작가 수정본
+TOTAL_WRITERS = 10  # 총 작가 수
 
 class WebSearchIntegration:
     """Brave Search API integration for research"""
@@ -149,7 +150,7 @@ Source: {url}
                         f"{topic} 구체적 장면 묘사",
                         f"{topic} 전문 용어 설명"
                     ]
-                elif writer_num <= 8:  # 중반부 작가
+                elif writer_num <= 6:  # 중반부 작가
                     queries = [
                         f"{topic} 갈등 상황 사례",
                         f"{topic} 심리적 측면"
@@ -178,7 +179,7 @@ Source: {url}
                         f"{topic} vivid scene descriptions",
                         f"{topic} technical terminology explained"
                     ]
-                elif writer_num <= 8:  # Middle writers
+                elif writer_num <= 6:  # Middle writers
                     queries = [
                         f"{topic} conflict scenarios",
                         f"{topic} psychological aspects"
@@ -197,7 +198,7 @@ Source: {url}
         return queries
 
 class NovelDatabase:
-    """Novel session management database with search history"""
+    """Novel session management database with enhanced recovery features"""
     
     @staticmethod
     def init_db():
@@ -208,7 +209,7 @@ class NovelDatabase:
             
             cursor = conn.cursor()
             
-            # Sessions table
+            # Sessions table with enhanced recovery fields
             cursor.execute('''
                 CREATE TABLE IF NOT EXISTS sessions (
                     session_id TEXT PRIMARY KEY,
@@ -218,6 +219,8 @@ class NovelDatabase:
                     updated_at TEXT DEFAULT (datetime('now')),
                     status TEXT DEFAULT 'active',
                     current_stage INTEGER DEFAULT 0,
+                    last_saved_stage INTEGER DEFAULT -1,
+                    recovery_data TEXT,
                     final_novel TEXT
                 )
             ''')
@@ -231,6 +234,7 @@ class NovelDatabase:
                     stage_name TEXT NOT NULL,
                     role TEXT NOT NULL,
                     content TEXT,
+                    word_count INTEGER DEFAULT 0,
                     status TEXT DEFAULT 'pending',
                     created_at TEXT DEFAULT (datetime('now')),
                     updated_at TEXT DEFAULT (datetime('now')),
@@ -257,6 +261,7 @@ class NovelDatabase:
             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)')
             cursor.execute('CREATE INDEX IF NOT EXISTS idx_search_session ON search_history(session_id)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_session_status ON sessions(status)')
             
             conn.commit()
     
@@ -271,7 +276,6 @@ class NovelDatabase:
             ''', (session_id, stage_number, role, query, results))
             conn.commit()
     
-    # ... (이전의 모든 NovelDatabase 메서드들은 동일)
     @staticmethod
     @contextmanager
     def get_db():
@@ -302,28 +306,32 @@ class NovelDatabase:
     @staticmethod
     def save_stage(session_id: str, stage_number: int, stage_name: str, 
                    role: str, content: str, status: str = 'complete'):
-        """Save stage content - 전체 내용 저장"""
+        """Save stage content with word count"""
+        word_count = len(content.split()) if content else 0
+        
         with NovelDatabase.get_db() as conn:
             cursor = conn.cursor()
             
             # UPSERT operation
             cursor.execute('''
-                INSERT INTO stages (session_id, stage_number, stage_name, role, content, status)
-                VALUES (?, ?, ?, ?, ?, ?)
+                INSERT INTO stages (session_id, stage_number, stage_name, role, content, word_count, status)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT(session_id, stage_number) 
-                DO UPDATE SET content=?, status=?, stage_name=?, updated_at=datetime('now')
-            ''', (session_id, stage_number, stage_name, role, content, status,
-                  content, status, stage_name))
+                DO UPDATE SET content=?, word_count=?, status=?, stage_name=?, updated_at=datetime('now')
+            ''', (session_id, stage_number, stage_name, role, content, word_count, status,
+                  content, word_count, status, stage_name))
             
             # Update session
             cursor.execute('''
                 UPDATE sessions 
-                SET updated_at = datetime('now'), current_stage = ?
+                SET updated_at = datetime('now'), 
+                    current_stage = ?,
+                    last_saved_stage = ?
                 WHERE session_id = ?
-            ''', (stage_number, session_id))
+            ''', (stage_number, stage_number, session_id))
             
             conn.commit()
-            logger.info(f"Saved stage {stage_number} for session {session_id}, content length: {len(content)}")
+            logger.info(f"Saved stage {stage_number} for session {session_id}, content length: {len(content)}, words: {word_count}")
     
     @staticmethod
     def get_session(session_id: str) -> Optional[Dict]:
@@ -333,6 +341,19 @@ class NovelDatabase:
             cursor.execute('SELECT * FROM sessions WHERE session_id = ?', (session_id,))
             return cursor.fetchone()
     
+    @staticmethod
+    def get_latest_active_session() -> Optional[Dict]:
+        """Get the most recent active session"""
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT * FROM sessions 
+                WHERE status = 'active' 
+                ORDER BY updated_at DESC 
+                LIMIT 1
+            ''')
+            return cursor.fetchone()
+    
     @staticmethod
     def get_stages(session_id: str) -> List[Dict]:
         """Get all stages for a session"""
@@ -347,7 +368,7 @@ class NovelDatabase:
     
     @staticmethod
     def get_all_writer_content(session_id: str) -> str:
-        """모든 작가의 수정본 내용을 가져와서 합치기 - 48페이지 전체"""
+        """모든 작가의 수정본 내용을 가져와서 합치기 - 10명 작가"""
         with NovelDatabase.get_db() as conn:
             cursor = conn.cursor()
             
@@ -357,7 +378,7 @@ class NovelDatabase:
             
             for stage_num in WRITER_REVISION_STAGES:
                 cursor.execute('''
-                    SELECT content, stage_name FROM stages 
+                    SELECT content, stage_name, word_count FROM stages 
                     WHERE session_id = ? AND stage_number = ?
                 ''', (session_id, stage_num))
                 
@@ -370,17 +391,17 @@ class NovelDatabase:
                     
                     if clean_content:
                         writer_count += 1
-                        word_count = len(clean_content.split())
+                        word_count = row['word_count'] or len(clean_content.split())
                         total_word_count += word_count
                         all_content.append(clean_content)
                         logger.info(f"Writer {writer_count} (stage {stage_num}): {word_count} words")
             
             full_content = '\n\n'.join(all_content)
-            logger.info(f"Total: {writer_count} writers, {total_word_count} words, {total_word_count/500:.1f} pages")
+            logger.info(f"Total: {writer_count} writers, {total_word_count} words")
             
-            # 내용이 너무 짧으면 경고
-            if total_word_count < 20000:  # 48페이지는 약 24000 단어
-                logger.warning(f"Content too short! Only {total_word_count} words instead of ~24000")
+            # 10명 작가 * 1,450 평균 = 14,500 단어 목표
+            if total_word_count < 12000:  
+                logger.warning(f"Content too short! Only {total_word_count} words instead of ~14,500")
             
             return full_content
     
@@ -429,7 +450,7 @@ class NovelDatabase:
             
             # 모든 작가 수정본 확인
             cursor.execute(f'''
-                SELECT stage_number, stage_name, LENGTH(content) as content_length
+                SELECT stage_number, stage_name, LENGTH(content) as content_length, word_count
                 FROM stages
                 WHERE session_id = ? AND stage_number IN ({','.join(map(str, WRITER_REVISION_STAGES))})
                 ORDER BY stage_number
@@ -437,14 +458,17 @@ class NovelDatabase:
             
             results = []
             total_length = 0
+            total_words = 0
             
             for row in cursor.fetchall():
                 results.append({
                     'stage': row['stage_number'],
                     'name': row['stage_name'],
-                    'length': row['content_length'] or 0
+                    'length': row['content_length'] or 0,
+                    'words': row['word_count'] or 0
                 })
                 total_length += row['content_length'] or 0
+                total_words += row['word_count'] or 0
             
             # 최종 소설 확인
             cursor.execute('''
@@ -459,8 +483,9 @@ class NovelDatabase:
             return {
                 'writer_stages': results,
                 'total_writer_content': total_length,
+                'total_words': total_words,
                 'final_novel_length': final_length,
-                'expected_length': 120000  # 48페이지 * 2500자
+                'expected_words': 14500  # 10 작가 * 1450 평균
             }
 
 class NovelWritingSystem:
@@ -550,15 +575,14 @@ Balance real facts with creative fiction to create an immersive story for reader
         
         return original_prompt + "\n\n" + research_section
     
-    # ... (이전의 모든 프롬프트 생성 메서드들은 동일)
     def create_director_initial_prompt(self, user_query: str, language: str = "English") -> str:
-        """Director AI initial prompt - Novel planning for 16 writers"""
+        """Director AI initial prompt - Novel planning for 10 writers"""
         if language == "Korean":
-            return f"""당신은 48페이지 분량의 중편 소설을 기획하는 문학 감독자입니다.
+            return f"""당신은 30페이지 분량의 중편 소설을 기획하는 문학 감독자입니다.
 
 사용자 요청: {user_query}
 
-다음 요소들을 체계적으로 구성하여 48페이지 중편 소설의 기초를 만드세요:
+다음 요소들을 체계적으로 구성하여 30페이지 중편 소설의 기초를 만드세요:
 
 1. **주제와 장르**
    - 핵심 주제와 메시지
@@ -574,13 +598,13 @@ Balance real facts with creative fiction to create an immersive story for reader
    - 갈등 구조
    - 감정적 연결고리
 
-4. **서사 구조** (48페이지를 16개 파트로 나누어 각 3페이지)
+4. **서사 구조** (30페이지를 10개 파트로 나누어 각 3페이지)
    | 파트 | 페이지 | 주요 사건 | 긴장도 | 인물 발전 |
    |------|--------|-----------|---------|-----------|
    | 1 | 1-3 | | | |
    | 2 | 4-6 | | | |
    | ... | ... | | | |
-   | 16 | 46-48 | | | |
+   | 10 | 28-30 | | | |
 
 5. **세계관 설정**
    - 시공간적 배경
@@ -589,11 +613,11 @@ Balance real facts with creative fiction to create an immersive story for reader
 
 각 작성자가 3페이지씩 작성할 수 있도록 명확한 가이드라인을 제시하세요."""
         else:
-            return f"""You are a literary director planning a 48-page novella.
+            return f"""You are a literary director planning a 30-page novella.
 
 User Request: {user_query}
 
-Systematically compose the following elements to create the foundation for a 48-page novella:
+Systematically compose the following elements to create the foundation for a 30-page novella:
 
 1. **Theme and Genre**
    - Core theme and message
@@ -609,13 +633,13 @@ Systematically compose the following elements to create the foundation for a 48-
    - Conflict structure
    - Emotional connections
 
-4. **Narrative Structure** (divide 48 pages into 16 parts, 3 pages each)
+4. **Narrative Structure** (divide 30 pages into 10 parts, 3 pages each)
    | Part | Pages | Main Events | Tension | Character Development |
    |------|-------|-------------|---------|---------------------|
    | 1 | 1-3 | | | |
    | 2 | 4-6 | | | |
    | ... | ... | | | |
-   | 16 | 46-48 | | | |
+   | 10 | 28-30 | | | |
 
 5. **World Building**
    - Temporal and spatial setting
@@ -644,7 +668,7 @@ Provide clear guidelines for each writer to compose 3 pages."""
    |------|------|------|-----------|
 
 3. **구조적 균형**
-   - 16개 파트별 분량 배분
+   - 10개 파트별 분량 배분
    - 긴장과 이완의 리듬
    - 전체적인 흐름
 
@@ -654,7 +678,7 @@ Provide clear guidelines for each writer to compose 3 pages."""
    - 기대치 충족도
 
 5. **실행 가능성**
-   - 16명의 작성자를 위한 가이드라인의 명확성
+   - 10명의 작성자를 위한 가이드라인의 명확성
    - 일관성 유지 방안
    - 잠재적 문제점
 
@@ -677,7 +701,7 @@ Critique from the following perspectives and provide specific improvements:
    |-----------|-----------|------------|-------------|
 
 3. **Structural Balance**
-   - Distribution across 16 parts
+   - Distribution across 10 parts
    - Rhythm of tension and relief
    - Overall flow
 
@@ -687,7 +711,7 @@ Critique from the following perspectives and provide specific improvements:
    - Expectation fulfillment
 
 5. **Feasibility**
-   - Clarity of guidelines for 16 writers
+   - Clarity of guidelines for 10 writers
    - Consistency maintenance
    - Potential issues
 
@@ -706,7 +730,7 @@ Provide specific and constructive feedback."""
 
 다음을 포함한 수정된 최종 기획을 제시하세요:
 
-1. **수정된 서사 구조** (16개 파트)
+1. **수정된 서사 구조** (10개 파트)
    | 파트 | 페이지 | 주요 사건 | 작성 지침 | 주의사항 |
    |------|--------|-----------|-----------|----------|
 
@@ -715,7 +739,7 @@ Provide specific and constructive feedback."""
    - 인물 간 갈등의 구체화
    - 감정선의 변화 추이
 
-3. **각 작성자를 위한 상세 가이드** (16명)
+3. **각 작성자를 위한 상세 가이드** (10명)
    - 파트별 시작과 끝 지점
    - 필수 포함 요소
    - 문체와 톤 지침
@@ -732,7 +756,7 @@ Provide specific and constructive feedback."""
    - 전체적 통일성
    - 독자 몰입 유지 방안
 
-16명의 작성자가 명확히 이해할 수 있는 최종 마스터플랜을 작성하세요."""
+10명의 작성자가 명확히 이해할 수 있는 최종 마스터플랜을 작성하세요."""
         else:
             return f"""As director, revise the novel plan reflecting the critic's feedback.
 
@@ -744,7 +768,7 @@ Critic Feedback:
 
 Present the revised final plan including:
 
-1. **Revised Narrative Structure** (16 parts)
+1. **Revised Narrative Structure** (10 parts)
    | Part | Pages | Main Events | Writing Guidelines | Cautions |
    |------|-------|-------------|-------------------|----------|
 
@@ -753,7 +777,7 @@ Present the revised final plan including:
    - Concrete conflicts between characters
    - Emotional arc progression
 
-3. **Detailed Guide for Each Writer** (16 writers)
+3. **Detailed Guide for Each Writer** (10 writers)
    - Start and end points for each part
    - Essential elements to include
    - Style and tone guidelines
@@ -770,15 +794,15 @@ Present the revised final plan including:
    - Overall unity
    - Reader engagement maintenance
 
-Create a final masterplan that all 16 writers can clearly understand."""
+Create a final masterplan that all 10 writers can clearly understand."""
     
     def create_writer_prompt(self, writer_number: int, director_plan: str, previous_content: str, language: str = "English") -> str:
-        """Individual writer prompt - 강화된 길이 요구사항"""
+        """Individual writer prompt - 1,400-1,500 단어"""
         pages_start = (writer_number - 1) * 3 + 1
         pages_end = writer_number * 3
         
         if language == "Korean":
-            return f"""당신은 작성자 {writer_number}번입니다. 48페이지 중편 소설의 {pages_start}-{pages_end}페이지(3페이지)를 작성하세요.
+            return f"""당신은 작성자 {writer_number}번입니다. 30페이지 중편 소설의 {pages_start}-{pages_end}페이지(3페이지)를 작성하세요.
 
 감독자의 마스터플랜:
 {director_plan}
@@ -789,9 +813,9 @@ Create a final masterplan that all 16 writers can clearly understand."""
 **중요 지침:**
 
 1. **필수 분량**: 
-   - 최소 1500단어, 최대 1800단어
-   - 대략 7500-9000자 (공백 포함)
-   - 3페이지 분량을 반드시 채워야 합니다
+   - 최소 1,400단어, 최대 1,500단어
+   - 대략 7000-7500자 (공백 포함)
+   - 3페이지 분량을 정확히 채워야 합니다
 
 2. **분량 확보 전략**:
    - 상세한 장면 묘사 포함
@@ -811,9 +835,9 @@ Create a final masterplan that all 16 writers can clearly understand."""
    - 독자의 관심 유지
 
 **작성 시작:**
-이제 1500-1800단어 분량의 소설을 작성하세요. 페이지 구분 표시는 하지 마세요."""
+이제 1,400-1,500단어 분량의 소설을 작성하세요. 페이지 구분 표시는 하지 마세요."""
         else:
-            return f"""You are Writer #{writer_number}. Write pages {pages_start}-{pages_end} (3 pages) of the 48-page novella.
+            return f"""You are Writer #{writer_number}. Write pages {pages_start}-{pages_end} (3 pages) of the 30-page novella.
 
 Director's Masterplan:
 {director_plan}
@@ -824,9 +848,9 @@ Director's Masterplan:
 **CRITICAL INSTRUCTIONS:**
 
 1. **MANDATORY LENGTH**: 
-   - Minimum 1500 words, Maximum 1800 words
-   - Approximately 7500-9000 characters
-   - You MUST fill 3 full pages
+   - Minimum 1,400 words, Maximum 1,500 words
+   - Approximately 7000-7500 characters
+   - You MUST fill exactly 3 pages
 
 2. **LENGTH STRATEGIES**:
    - Include detailed scene descriptions
@@ -846,7 +870,7 @@ Director's Masterplan:
    - Maintain reader interest
 
 **BEGIN WRITING:**
-Now write your 1500-1800 word section. Do not use any page markers."""
+Now write your 1,400-1,500 word section. Do not use any page markers."""
     
     def create_critic_writer_prompt(self, writer_number: int, writer_content: str, director_plan: str, all_previous_content: str, language: str = "English") -> str:
         """Critic's review of individual writer's work"""
@@ -959,7 +983,7 @@ Clearly distinguish between mandatory revisions and optional improvements."""
    - 묘사와 대화 개선
 
 3. **분량 유지**
-   - 여전히 정확히 3페이지 (1500-1800단어)
+   - 여전히 정확히 3페이지 (1,400-1,500단어)
    - 페이지 구분 표시 절대 금지
 
 4. **연속성 확보**
@@ -967,7 +991,7 @@ Clearly distinguish between mandatory revisions and optional improvements."""
    - 수정으로 인한 새로운 모순 방지
 
 수정된 최종본을 제시하세요. 페이지 마크는 절대 사용하지 마세요.
-반드시 1500-1800단어 분량을 유지하세요."""
+반드시 1,400-1,500단어 분량을 유지하세요."""
         else:
             return f"""As Writer #{writer_number}, revise based on critic's feedback.
 
@@ -990,7 +1014,7 @@ Write a revision reflecting:
    - Improve descriptions and dialogue
 
 3. **Maintain Length**
-   - Still exactly 3 pages (1500-1800 words)
+   - Still exactly 3 pages (1,400-1,500 words)
    - Absolutely no page markers
 
 4. **Ensure Continuity**
@@ -998,14 +1022,14 @@ Write a revision reflecting:
    - Prevent new contradictions from revisions
 
 Present the revised final version. Never use page markers.
-You MUST maintain 1500-1800 words."""
+You MUST maintain 1,400-1,500 words."""
     
     def create_critic_final_prompt(self, all_content: str, director_plan: str, language: str = "English") -> str:
         """Final critic evaluation of complete novel"""
         content_preview = all_content[:3000] + "\n...\n" + all_content[-3000:] if len(all_content) > 6000 else all_content
         
         if language == "Korean":
-            return f"""전체 48페이지 소설을 최종 평가합니다.
+            return f"""전체 30페이지 소설을 최종 평가합니다.
 
 감독자의 마스터플랜:
 {director_plan}
@@ -1048,7 +1072,7 @@ You MUST maintain 1500-1800 words."""
 
 감독자가 최종 수정할 수 있도록 구체적이고 실행 가능한 피드백을 제공하세요."""
         else:
-            return f"""Final evaluation of the complete 48-page novel.
+            return f"""Final evaluation of the complete 30-page novel.
 
 Director's Masterplan:
 {director_plan}
@@ -1094,12 +1118,12 @@ Provide specific and actionable feedback for the director's final revision."""
     def create_director_final_prompt(self, all_content: str, critic_final_feedback: str, language: str = "English") -> str:
         """Director's final compilation and polish - 모든 작가 내용 포함"""
         word_count = len(all_content.split())
-        expected_words = 24000  # 48페이지 * 500단어
+        expected_words = 14500  # 30페이지 * 500단어
         
         if language == "Korean":
             return f"""감독자로서 비평가의 최종 평가를 반영하여 완성본을 제작합니다.
 
-전체 작가들의 작품 (48페이지 전체, {word_count}단어):
+전체 작가들의 작품 (30페이지 전체, {word_count}단어):
 {all_content}
 
 비평가 최종 평가:
@@ -1111,7 +1135,7 @@ Provide specific and actionable feedback for the director's final revision."""
 
 ## 작품 정보
 - 장르: 
-- 분량: 48페이지 ({word_count}단어)
+- 분량: 30페이지 ({word_count}단어)
 - 주제: 
 - 한 줄 요약: 
 
@@ -1122,7 +1146,7 @@ Provide specific and actionable feedback for the director's final revision."""
 
 ## 본문
 
-[16명의 작가가 작성한 전체 48페이지 내용을 다음 기준으로 통합]
+[10명의 작가가 작성한 전체 30페이지 내용을 다음 기준으로 통합]
 1. 중대 오류 수정 완료
 2. 파트 간 연결 매끄럽게 조정
 3. 문체와 톤 통일
@@ -1130,18 +1154,18 @@ Provide specific and actionable feedback for the director's final revision."""
 5. 페이지 구분 표시 완전 제거
 6. 자연스러운 흐름으로 재구성
 
-[전체 48페이지 분량의 완성된 소설 본문]
+[전체 30페이지 분량의 완성된 소설 본문]
 
 ---
 
 ## 작가의 말
 [작품에 대한 간단한 해설이나 의도]
 
-모든 작가의 기여를 통합한 완전한 48페이지 소설을 제시하세요."""
+모든 작가의 기여를 통합한 완전한 30페이지 소설을 제시하세요."""
         else:
             return f"""As director, create the final version reflecting the critic's final evaluation.
 
-Complete Writers' Work (Full 48 pages, {word_count} words):
+Complete Writers' Work (Full 30 pages, {word_count} words):
 {all_content}
 
 Critic's Final Evaluation:
@@ -1153,7 +1177,7 @@ Present the final version including:
 
 ## Work Information
 - Genre: 
-- Length: 48 pages ({word_count} words)
+- Length: 30 pages ({word_count} words)
 - Theme: 
 - One-line summary: 
 
@@ -1164,7 +1188,7 @@ Present the final version including:
 
 ## Main Text
 
-[Integrate all 48 pages written by 16 writers with these criteria]
+[Integrate all 30 pages written by 10 writers with these criteria]
 1. Critical errors corrected
 2. Smooth transitions between parts
 3. Unified style and tone
@@ -1172,14 +1196,14 @@ Present the final version including:
 5. Complete removal of page markers
 6. Reorganized for natural flow
 
-[Complete 48-page novel text]
+[Complete 30-page novel text]
 
 ---
 
 ## Author's Note
 [Brief commentary or intention about the work]
 
-Present a complete 48-page novel integrating all writers' contributions."""
+Present a complete 30-page novel integrating all writers' contributions."""
     
     def simulate_streaming(self, text: str, role: str) -> Generator[str, None, None]:
         """Simulate streaming in test mode"""
@@ -1223,26 +1247,26 @@ Present a complete 48-page novel integrating all writers' contributions."""
             # 작가에게 더 강한 시스템 프롬프트 추가
             if role.startswith("writer"):
                 if language == "Korean":
-                    system_prompts[role] += "\n\n**절대적 요구사항**: 당신은 반드시 1500-1800단어를 작성해야 합니다. 이것은 협상 불가능한 요구사항입니다. 짧은 응답은 허용되지 않습니다."
+                    system_prompts[role] += "\n\n**절대적 요구사항**: 당신은 반드시 1,400-1,500단어를 작성해야 합니다. 이것은 협상 불가능한 요구사항입니다. 짧은 응답은 허용되지 않습니다."
                 else:
-                    system_prompts[role] += "\n\n**ABSOLUTE REQUIREMENT**: You MUST write 1500-1800 words. This is non-negotiable. Short responses are not acceptable."
+                    system_prompts[role] += "\n\n**ABSOLUTE REQUIREMENT**: You MUST write 1,400-1,500 words. This is non-negotiable. Short responses are not acceptable."
             
             full_messages = [
                 {"role": "system", "content": system_prompts.get(role, "")},
                 *messages
             ]
             
-            # 작성자들에게는 더 많은 토큰 할당
+            # 작성자들에게는 적절한 토큰 할당
             if role.startswith("writer"):
-                max_tokens = 12000  # 증가
-                temperature = 0.8   # 약간 증가
-                top_p = 0.95       # 약간 증가
+                max_tokens = 10000  # 충분한 토큰
+                temperature = 0.8   
+                top_p = 0.95       
             elif role == "director" and ("최종" in str(messages) or "final" in str(messages)):
-                max_tokens = 40000  # 증가
+                max_tokens = 30000  # 최종 통합을 위한 충분한 토큰
                 temperature = 0.6
                 top_p = 0.9
             else:
-                max_tokens = 10000
+                max_tokens = 8000
                 temperature = 0.6
                 top_p = 0.9
             
@@ -1263,7 +1287,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
                 headers=self.create_headers(),
                 json=payload,
                 stream=True,
-                timeout=60  # 타임아웃 증가
+                timeout=60  
             )
             
             if response.status_code != 200:
@@ -1307,14 +1331,14 @@ Present a complete 48-page novel integrating all writers' contributions."""
             # 작가의 경우 내용 길이 확인 및 재시도
             if role.startswith("writer"):
                 word_count = len(total_content.split())
-                if word_count < 1400:
+                if word_count < 1350:  # 1,400 미만
                     logger.warning(f"Writer {role} produced only {word_count} words! Requesting continuation...")
                     
                     # 추가 요청
-                    continuation_prompt = f"Continue writing to reach the required 1500-1800 words. You have written {word_count} words so far. Write {1500 - word_count} more words to complete your section."
+                    continuation_prompt = f"Continue writing to reach the required 1,400-1,500 words. You have written {word_count} words so far. Write {1400 - word_count} more words to complete your section."
                     
                     if language == "Korean":
-                        continuation_prompt = f"필수 분량 1500-1800단어를 채우기 위해 계속 작성하세요. 지금까지 {word_count}단어를 작성했습니다. {1500 - word_count}단어를 더 작성하여 섹션을 완성하세요."
+                        continuation_prompt = f"필수 분량 1,400-1,500단어를 채우기 위해 계속 작성하세요. 지금까지 {word_count}단어를 작성했습니다. {1400 - word_count}단어를 더 작성하여 섹션을 완성하세요."
                     
                     full_messages.append({"role": "assistant", "content": total_content})
                     full_messages.append({"role": "user", "content": continuation_prompt})
@@ -1323,7 +1347,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
                     continuation_payload = {
                         "model": self.model_id,
                         "messages": full_messages,
-                        "max_tokens": 6000,
+                        "max_tokens": 5000,
                         "temperature": temperature,
                         "top_p": top_p,
                         "stream": True
@@ -1368,67 +1392,54 @@ Present a complete 48-page novel integrating all writers' contributions."""
             logger.error(f"Error during streaming: {str(e)}")
             yield f"❌ Error occurred: {str(e)}"
     
-    # ... (나머지 메서드들은 동일)
     def get_system_prompts(self, language: str) -> Dict[str, str]:
-        """Get system prompts for all 16 writers with enhanced length requirements"""
+        """Get system prompts for all 10 writers"""
         if language == "Korean":
             prompts = {
-                "director": "당신은 48페이지 중편 소설을 기획하고 감독하는 문학 감독자입니다. 체계적이고 창의적인 스토리 구조를 만들어냅니다.",
+                "director": "당신은 30페이지 중편 소설을 기��하고 감독하는 문학 감독자입니다. 체계적이고 창의적인 스토리 구조를 만들어냅니다.",
                 "critic": "당신은 날카로운 통찰력을 가진 문학 비평가입니다. 건설적이고 구체적인 피드백을 제공합니다."
             }
             
-            # 16명의 작가 프롬프트
+            # 10명의 작가 프롬프트
             writer_roles = [
                 "소설의 도입부를 담당하는 작가입니다. 독자를 사로잡는 시작을 만듭니다.",
                 "초반 전개를 담당하는 작가입니다. 인물과 상황을 깊이 있게 발전시킵니다.",
                 "갈등 도입을 담당하는 작가입니다. 이야기의 핵심 갈등을 제시합니다.",
                 "갈등 상승을 담당하는 작가입니다. 긴장감을 높이고 복잡성을 더합니다.",
-                "초반 전환점을 담당하는 작가입니다. 첫 번째 중요한 변화를 만듭니다.",
-                "중반부 진입을 담당하는 작가입니다. 이야기의 중심축을 견고하게 만듭니다.",
-                "깊이 탐구를 담당하는 작가입니다. 인물과 주제를 깊이 탐색합니다.",
-                "중반 전환점을 담당하는 작가입니다. 예상치 못한 변화를 만들어냅니다.",
-                "갈등 심화를 담당하는 작가입니다. 위기를 극대화합니다.",
+                "중반부 전환점을 담당하는 작가입니다. 중요한 변화를 만듭니다.",
+                "중반부 심화를 담당하는 작가입니다. 이야기의 중심축을 견고하게 만듭니다.",
                 "클라이맥스 준비를 담당하는 작가입니다. 최고조를 향해 나아갑니다.",
                 "클라이맥스를 담당하는 작가입니다. 모든 갈등이 폭발하는 순간을 그립니다.",
-                "클라이맥스 후반을 담당하는 작가입니다. 긴장의 정점을 마무리합니다.",
                 "해결 시작을 담당하는 작가입니다. 매듭을 풀어나가기 시작합니다.",
-                "해결 진행을 담당하는 작가입니다. 모든 갈등을 정리합니다.",
-                "결말 준비를 담당하는 작가입니다. 마지막을 향해 나아갑니다.",
                 "최종 결말을 담당하는 작가입니다. 여운이 남는 마무리를 만듭니다."
             ]
             
             for i, role_desc in enumerate(writer_roles, 1):
-                prompts[f"writer{i}"] = f"당신은 {role_desc} 반드시 1500-1800단어를 작성하세요. 이는 절대적인 요구사항입니다."
+                prompts[f"writer{i}"] = f"당신은 {role_desc} 반드시 1,400-1,500단어를 작성하세요. 이는 절대적인 요구사항입니다."
                 
             return prompts
         else:
             prompts = {
-                "director": "You are a literary director planning and supervising a 48-page novella. You create systematic and creative story structures.",
+                "director": "You are a literary director planning and supervising a 30-page novella. You create systematic and creative story structures.",
                 "critic": "You are a literary critic with sharp insights. You provide constructive and specific feedback."
             }
             
-            # 16 writer prompts
+            # 10 writer prompts
             writer_roles = [
                 "the writer responsible for the introduction. You create a captivating beginning.",
                 "the writer responsible for early development. You deepen characters and situations.",
                 "the writer responsible for conflict introduction. You present the core conflict.",
                 "the writer responsible for rising conflict. You increase tension and add complexity.",
-                "the writer responsible for the first turning point. You create the first major change.",
-                "the writer responsible for entering the middle section. You solidify the story's central axis.",
-                "the writer responsible for depth exploration. You deeply explore characters and themes.",
-                "the writer responsible for the mid-point turn. You create unexpected changes.",
-                "the writer responsible for deepening conflict. You maximize the crisis.",
+                "the writer responsible for the midpoint turn. You create important changes.",
+                "the writer responsible for deepening the middle. You solidify the story's central axis.",
                 "the writer responsible for climax preparation. You move toward the peak.",
                 "the writer responsible for the climax. You depict the moment when all conflicts explode.",
-                "the writer responsible for climax conclusion. You complete the tension's peak.",
                 "the writer responsible for resolution beginning. You start untangling the knots.",
-                "the writer responsible for resolution progress. You resolve all conflicts.",
-                "the writer responsible for ending preparation. You move toward the final moments.",
                 "the writer responsible for the final ending. You create a lingering conclusion."
             ]
             
             for i, role_desc in enumerate(writer_roles, 1):
-                prompts[f"writer{i}"] = f"You are {role_desc} You MUST write 1500-1800 words. This is an absolute requirement."
+                prompts[f"writer{i}"] = f"You are {role_desc} You MUST write 1,400-1,500 words. This is an absolute requirement."
                 
             return prompts
     
@@ -1442,7 +1453,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
     def get_korean_test_response(self, role: str) -> str:
         """Korean test responses with appropriate length"""
         test_responses = {
-            "director": """48페이지 중편 소설 기획안을 제시합니다.
+            "director": """30페이지 중편 소설 기획안을 제시합니다.
 
 ## 1. 주제와 장르
 - **핵심 주제**: 인간 본성과 기술의 충돌 속에서 찾는 진정한 연결
@@ -1458,7 +1469,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
 | 민준 | 조력자 | 따뜻함, 직관적 | 심리상담사 | 서연을 도와 균형 찾기 | 기술 수용과 조화 |
 | ARIA | 대립자→동반자 | 논리적→감성 학습 | AI 프로토타입 | 진정한 존재 되기 | 자아 정체성 확립 |
 
-## 3. 서사 구조 (16개 파트, 각 3페이지)
+## 3. 서사 구조 (10개 파트, 각 3페이지)
 
 | 파트 | 페이지 | 주요 사건 | 긴장도 | 인물 발전 |
 |------|--------|-----------|---------|-----------|
@@ -1468,16 +1479,10 @@ Present a complete 48-page novel integrating all writers' contributions."""
 | 4 | 10-12 | ARIA의 자아 인식 징후 | 5/10 | 갈등의 씨앗 |
 | 5 | 13-15 | 첫 번째 위기 | 6/10 | 선택의 순간 |
 | 6 | 16-18 | 윤리위원회 개입 | 7/10 | 외부 압력 |
-| 7 | 19-21 | 서연의 고민 심화 | 6/10 | 내적 갈등 |
-| 8 | 22-24 | ARIA의 변화 | 7/10 | 전환점 |
-| 9 | 25-27 | 탈출 시도 | 8/10 | 관계의 시험 |
-| 10 | 28-30 | 대화와 이해 | 6/10 | 상호 인정 |
-| 11 | 31-33 | 외부 위협 등장 | 9/10 | 연대의 필요 |
-| 12 | 34-36 | 준비와 결의 | 8/10 | 힘을 모음 |
-| 13 | 37-39 | 최후의 대결 | 10/10 | 클라이맥스 |
-| 14 | 40-42 | 선택의 결과 | 7/10 | 변화 수용 |
-| 15 | 43-45 | 새로운 길 | 5/10 | 화해와 성장 |
-| 16 | 46-48 | 공존의 시작 | 4/10 | 새로운 관계 |""",
+| 7 | 19-21 | 대화와 이해 | 6/10 | 상호 인정 |
+| 8 | 22-24 | 최후의 대결 준비 | 8/10 | 연대의 필요 |
+| 9 | 25-27 | 클라이맥스 | 10/10 | 모든 갈등 폭발 |
+| 10 | 28-30 | 새로운 시작 | 4/10 | 공존과 화해 |""",
             
             "critic": """감독자의 기획을 검토했습니다.
 
@@ -1485,7 +1490,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
 
 ### 1. 서사적 완성도
 - **강점**: AI와 인간의 관계라는 시의적절한 주제
-- **개선점**: 16개 파트 구성이 다소 세분화되어 있음. 각 파트의 독립성 확보 필요
+- **개선점**: 10개 파트 구성이 적절하며 각 파트의 독립성과 연결성이 잘 균형잡혀 있음
 
 ### 2. 인물 설정 검토
 
@@ -1500,18 +1505,18 @@ Present a complete 48-page novel integrating all writers' contributions."""
 - 파트 간 연결성 가이드라인 보강 필요""",
         }
         
-        # 작가 응답 - 1500-1800 단어
+        # 작가 응답 - 1,400-1,500 단어
         sample_story = """서연은 연구실의 차가운 형광등 아래에서 또 다른 밤을 보내고 있었다. 모니터의 푸른 빛이 그녀의 창백한 얼굴을 비추고 있었고, 수십 개의 코드 라인이 끊임없이 스크롤되고 있었다. ARIA 프로젝트는 그녀의 삶 전부였다. 3년이라는 시간 동안 그녀는 이 인공지능에 모든 것을 쏟아부었다.
 
 "시스템 체크 완료. 모든 파라미터 정상." 기계적인 음성이 스피커를 통해 흘러나왔다.
 
 서연은 잠시 의자에 기대어 눈을 감았다. 피로가 뼈 속까지 파고들었지만, 멈출 수 없었다. ARIA는 단순한 프로젝트가 아니었다. 그것은 그녀가 잃어버린 것들을 되찾을 수 있는 유일한 희망이었다."""
         
-        for i in range(1, 17):
-            # 각 작가마다 1500-1800단어 생성
+        for i in range(1, 11):
+            # 각 작가마다 1,400-1,500단어 생성
             writer_content = f"작성자 {i}번의 파트입니다.\n\n"
-            # 약 300단어씩 5-6번 반복하여 1500-1800단어 달성
-            for j in range(6):
+            # 약 300단어씩 5번 반복하여 1,400-1,500단어 달성
+            for j in range(5):
                 writer_content += sample_story + f"\n\n그것은 작가 {i}의 {j+1}번째 단락이었다. "
                 writer_content += "이���기는 계속 전개되었고, 인물들의 감정은 점점 더 복잡해졌다. " * 15
                 writer_content += "\n\n"
@@ -1523,7 +1528,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
     def get_english_test_response(self, role: str) -> str:
         """English test responses with appropriate length"""
         test_responses = {
-            "director": """I present the 48-page novella plan.
+            "director": """I present the 30-page novella plan.
 
 ## 1. Theme and Genre
 - **Core Theme**: Finding true connection in the collision of human nature and technology
@@ -1539,13 +1544,13 @@ Present a complete 48-page novel integrating all writers' contributions."""
 | Minjun | Helper | Warm, intuitive | Psychologist | Help Seoyeon find balance | Accept and harmonize with technology |
 | ARIA | Antagonist→Companion | Logical→Learning emotion | AI prototype | Become truly existent | Establish self-identity |
 
-## 3. Narrative Structure (16 parts, 3 pages each)
+## 3. Narrative Structure (10 parts, 3 pages each)
 
 | Part | Pages | Main Events | Tension | Character Development |
 |------|-------|-------------|---------|---------------------|
 | 1 | 1-3 | Seoyeon's lonely lab, ARIA's first awakening | 3/10 | Seoyeon's obsession revealed |
 | 2 | 4-6 | ARIA's anomalies begin | 4/10 | Questions arise |
-[... continues for all 16 parts ...]""",
+[... continues for all 10 parts ...]""",
             
             "critic": """I have reviewed the director's plan.
 
@@ -1553,7 +1558,7 @@ Present a complete 48-page novel integrating all writers' contributions."""
 
 ### 1. Narrative Completeness
 - **Strength**: Timely theme of AI-human relationships
-- **Improvement**: 16-part structure may be overly segmented. Need to ensure independence of each part
+- **Improvement**: 10-part structure is well-balanced. Each part maintains independence while connecting seamlessly.
 
 ### 2. Character Review
 
@@ -1568,18 +1573,18 @@ Present a complete 48-page novel integrating all writers' contributions."""
 - Need to strengthen inter-part connectivity guidelines""",
         }
         
-        # Writer responses - 1500-1800 words each
+        # Writer responses - 1,400-1,500 words each
         sample_story = """Seoyeon spent another night under the cold fluorescent lights of her laboratory. The blue glow from the monitor illuminated her pale face, and dozens of lines of code scrolled endlessly. The ARIA project was her entire life. For three years, she had poured everything into this artificial intelligence.
 
 "System check complete. All parameters normal." The mechanical voice flowed through the speakers.
 
 Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penetrated to her bones, but she couldn't stop. ARIA wasn't just a project. It was her only hope to reclaim what she had lost."""
         
-        for i in range(1, 17):
-            # Each writer produces 1500-1800 words
+        for i in range(1, 11):
+            # Each writer produces 1,400-1,500 words
             writer_content = f"Writer {i} begins their section here.\n\n"
-            # About 300 words repeated 5-6 times to achieve 1500-1800 words
-            for j in range(6):
+            # About 300 words repeated 5 times to achieve 1,400-1,500 words
+            for j in range(5):
                 writer_content += sample_story + f"\n\nThis was writer {i}'s paragraph {j+1}. "
                 writer_content += "The story continued to unfold, and the characters' emotions grew increasingly complex. " * 15
                 writer_content += "\n\n"
@@ -1627,15 +1632,15 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                         "content": stage_data['content'] or ""
                     })
             
-            # Define all stages
+            # Define all stages for 10 writers
             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'}"),
             ]
             
-            # Add writer stages for 16 writers
-            for writer_num in range(1, 17):
+            # Add writer stages for 10 writers
+            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'}"),
@@ -1704,6 +1709,11 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                     "complete"
                 )
                 
+                # Auto-save notification
+                if role.startswith("writer"):
+                    writer_num = int(role.replace("writer", ""))
+                    logger.info(f"✅ Writer {writer_num} content auto-saved to database")
+                
                 yield "", stages
             
             # Verify content after completion
@@ -1711,8 +1721,8 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                 verification = NovelDatabase.verify_novel_content(self.current_session_id)
                 logger.info(f"Content verification: {verification}")
                 
-                if verification['final_novel_length'] < verification['expected_length'] * 0.5:
-                    logger.error(f"Final novel too short! Only {verification['final_novel_length']} chars")
+                if verification['total_words'] < 12000:
+                    logger.error(f"Final novel too short! Only {verification['total_words']} words")
             
             # Get final novel from last stage
             final_novel = stages[-1]["content"] if stages else ""
@@ -1796,7 +1806,7 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
             # Writer review
             else:
                 # Find which writer we're reviewing
-                for i in range(1, 17):
+                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
                         # Get previous writers' content from DB
@@ -1822,47 +1832,71 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
         
         return ""
 
-# Gradio Interface Functions (동일)
-def process_query(query: str, language: str, session_id: str = None) -> Generator[Tuple[str, str, str], None, None]:
-    """Process query and yield updates"""
+# Gradio Interface Functions
+def process_query(query: str, language: str, session_id: str = None) -> Generator[Tuple[str, str, str, str], None, None]:
+    """Process query and yield updates with recovery status"""
     if not query.strip() and not session_id:
         if language == "Korean":
-            yield "", "", "❌ 소설 주제를 입력해주세요."
+            yield "", "", "❌ 소설 주제를 입력해주세요.", ""
         else:
-            yield "", "", "❌ Please enter a novel theme."
+            yield "", "", "❌ Please enter a novel theme.", ""
         return
     
     system = NovelWritingSystem()
     
     try:
+        # Recovery status message
+        recovery_status = ""
+        if session_id:
+            if language == "Korean":
+                recovery_status = "♻️ 이전 세션을 복구하여 계속 진행합니다..."
+            else:
+                recovery_status = "♻️ Recovering previous session and continuing..."
+        
         for final_novel, stages in system.process_novel_stream(query, language, session_id):
             # Format stages for display
             stages_display = format_stages_display(stages, language)
             
-            status = "🔄 Processing..." if not final_novel else "✅ Complete!"
+            # Progress calculation
+            completed = sum(1 for s in stages if s.get("status") == "complete")
+            total = len(stages)
+            progress_percent = (completed / total * 100) if total > 0 else 0
+            
+            if not final_novel:
+                if language == "Korean":
+                    status = f"🔄 진행중... ({completed}/{total} - {progress_percent:.1f}%)"
+                else:
+                    status = f"🔄 Processing... ({completed}/{total} - {progress_percent:.1f}%)"
+            else:
+                status = "✅ Complete!"
             
-            yield stages_display, final_novel, status
+            yield stages_display, final_novel, status, recovery_status
                     
     except Exception as e:
         logger.error(f"Error in process_query: {str(e)}", exc_info=True)
         if language == "Korean":
-            yield "", "", f"❌ 오류 발생: {str(e)}"
+            yield "", "", f"❌ 오류 발생: {str(e)}", ""
         else:
-            yield "", "", f"❌ Error occurred: {str(e)}"
+            yield "", "", f"❌ Error occurred: {str(e)}", ""
 
 def format_stages_display(stages: List[Dict[str, str]], language: str) -> str:
-    """Format stages into simple display without complex scrolling"""
+    """Format stages into simple display with writer save status"""
     display = ""
     
     for idx, stage in enumerate(stages):
         status_icon = "✅" if stage.get("status") == "complete" else ("⏳" if stage.get("status") == "active" else "❌")
         
+        # Add save indicator for completed writers
+        save_indicator = ""
+        if "Writer" in stage['name'] and "Revision" in stage['name'] and stage.get("status") == "complete":
+            save_indicator = " 💾"
+        
         # Show only active stage content in detail, others just show status
         if stage.get("status") == "active":
             display += f"\n\n{status_icon} **{stage['name']}**\n"
-            display += f"```\n{stage.get('content', '')[-1000:]}\n```"  # Show last 1000 chars
+            display += f"```\n{stage.get('content', '')[-1000:]}\n```"  
         else:
-            display += f"\n{status_icon} {stage['name']}"
+            display += f"\n{status_icon} {stage['name']}{save_indicator}"
     
     return display
 
@@ -1884,7 +1918,7 @@ def get_active_sessions(language: str) -> List[Tuple[str, str]]:
         logger.error(f"Error getting active sessions: {str(e)}", exc_info=True)
         return []
 
-def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str, str], None, None]:
+def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str, str, str], None, None]:
     """Resume an existing session"""
     if not session_id:
         return
@@ -1892,8 +1926,33 @@ def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str,
     # Process with existing session ID
     yield from process_query("", language, session_id)
 
-def download_novel(novel_text: str, format: str, language: str) -> str:
-    """Download novel in specified format"""
+def auto_recover_session(language: str) -> Tuple[str, str]:
+    """Auto recover the latest active session"""
+    try:
+        latest_session = NovelDatabase.get_latest_active_session()
+        if latest_session:
+            if language == "Korean":
+                message = f"✅ 자동 복구: '{latest_session['user_query'][:30]}...' (Stage {latest_session['current_stage']})"
+            else:
+                message = f"✅ Auto recovered: '{latest_session['user_query'][:30]}...' (Stage {latest_session['current_stage']})"
+            return latest_session['session_id'], message
+        else:
+            return None, ""
+    except Exception as e:
+        logger.error(f"Error in auto recovery: {str(e)}")
+        return None, ""
+
+def download_novel(novel_text: str, format: str, language: str, session_id: str = None) -> str:
+    """Download novel in specified format - enhanced for 10 writers"""
+    if not novel_text and not session_id:
+        return None
+    
+    # If session_id provided, get all writer content
+    if session_id:
+        all_writer_content = NovelDatabase.get_all_writer_content(session_id)
+        if all_writer_content:
+            novel_text = all_writer_content
+    
     if not novel_text:
         return None
     
@@ -1911,29 +1970,76 @@ def download_novel(novel_text: str, format: str, language: str) -> str:
         # Create DOCX
         doc = Document()
         
+        # Title page
+        title_para = doc.add_paragraph()
+        title_run = title_para.add_run('AI Collaborative Novel')
+        title_run.font.size = Pt(24)
+        title_run.font.bold = True
+        title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        
+        doc.add_paragraph()
+        
         # 문서 정보 추가
-        doc.add_heading('Novel Export Information', 0)
-        doc.add_paragraph(f'Total words: {word_count:,}')
-        doc.add_paragraph(f'Total characters: {char_count:,}')
-        doc.add_paragraph(f'Estimated pages: {word_count/500:.1f}')
-        doc.add_paragraph(f'Export date: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}')
+        info_para = doc.add_paragraph()
+        info_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        info_run = info_para.add_run(f'10 Writers Collaboration\n')
+        info_run.font.size = Pt(14)
+        
+        stats_para = doc.add_paragraph()
+        stats_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        stats_run = stats_para.add_run(
+            f'Total words: {word_count:,}\n'
+            f'Total pages: ~{word_count/500:.0f}\n'
+            f'Export date: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}'
+        )
+        stats_run.font.size = Pt(12)
+        
         doc.add_page_break()
         
-        # Parse and add content
-        lines = novel_text.split('\n')
-        for line in lines:
-            if line.startswith('#'):
-                # Safe heading level extraction
-                level = min(len(line.split()[0].strip('#')), 9)
-                text = line.lstrip('#').strip()
-                if text:
-                    doc.add_heading(text, level)
-            elif line.strip():
-                # 긴 단락도 제대로 추가
-                para = doc.add_paragraph(line)
-                # 폰트 크기 조정 (가독성)
-                if hasattr(para.style, 'font'):
-                    para.style.font.size = Pt(11)
+        # Table of Contents
+        doc.add_heading('Table of Contents', 1)
+        for i in range(1, 11):
+            doc.add_paragraph(f'Writer {i}: Pages {(i-1)*3+1}-{i*3}')
+        
+        doc.add_page_break()
+        
+        # Parse and add content with writer sections
+        if session_id:
+            # Get individual writer contents from DB
+            stages = NovelDatabase.get_stages(session_id)
+            writer_num = 0
+            
+            for stage in stages:
+                if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
+                    writer_num += 1
+                    # Add writer header
+                    doc.add_heading(f'Writer {writer_num}', 1)
+                    doc.add_paragraph(f'Pages {(writer_num-1)*3+1}-{writer_num*3}')
+                    doc.add_paragraph()
+                    
+                    # Add writer content
+                    content = stage['content'] or ""
+                    paragraphs = content.split('\n\n')
+                    for para_text in paragraphs:
+                        if para_text.strip():
+                            para = doc.add_paragraph(para_text)
+                            para.style.font.size = Pt(11)
+                    
+                    if writer_num < 10:  # Don't add page break after last writer
+                        doc.add_page_break()
+        else:
+            # If no session_id, add content as is
+            lines = novel_text.split('\n')
+            for line in lines:
+                if line.startswith('#'):
+                    level = min(len(line.split()[0].strip('#')), 9)
+                    text = line.lstrip('#').strip()
+                    if text:
+                        doc.add_heading(text, level)
+                elif line.strip():
+                    para = doc.add_paragraph(line)
+                    if hasattr(para.style, 'font'):
+                        para.style.font.size = Pt(11)
         
         # 페이지 설정
         section = doc.sections[0]
@@ -1946,7 +2052,7 @@ def download_novel(novel_text: str, format: str, language: str) -> str:
         
         # Save
         temp_dir = tempfile.gettempdir()
-        filename = f"Novel_{timestamp}_{word_count}words.docx"
+        filename = f"Novel_10Writers_{timestamp}_{word_count}words.docx"
         filepath = os.path.join(temp_dir, filename)
         doc.save(filepath)
         
@@ -1955,23 +2061,40 @@ def download_novel(novel_text: str, format: str, language: str) -> str:
     else:
         # TXT format
         temp_dir = tempfile.gettempdir()
-        filename = f"Novel_{timestamp}_{word_count}words.txt"
+        filename = f"Novel_10Writers_{timestamp}_{word_count}words.txt"
         filepath = os.path.join(temp_dir, filename)
         
         # 파일 시작 부분에 정보 추가
         with open(filepath, 'w', encoding='utf-8') as f:
-            f.write(f"=== Novel Export ===\n")
+            f.write("="*60 + "\n")
+            f.write("AI COLLABORATIVE NOVEL - 10 WRITERS\n")
+            f.write("="*60 + "\n")
             f.write(f"Total words: {word_count:,}\n")
             f.write(f"Total characters: {char_count:,}\n")
             f.write(f"Estimated pages: {word_count/500:.1f}\n")
             f.write(f"Export date: {datetime.now()}\n")
-            f.write("="*50 + "\n\n")
-            f.write(novel_text)
+            f.write("="*60 + "\n\n")
+            
+            if session_id:
+                # Get individual writer contents
+                stages = NovelDatabase.get_stages(session_id)
+                writer_num = 0
+                
+                for stage in stages:
+                    if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
+                        writer_num += 1
+                        f.write(f"\n{'='*40}\n")
+                        f.write(f"WRITER {writer_num} (Pages {(writer_num-1)*3+1}-{writer_num*3})\n")
+                        f.write(f"{'='*40}\n\n")
+                        f.write(stage['content'] or "")
+                        f.write("\n\n")
+            else:
+                f.write(novel_text)
         
         logger.info(f"TXT saved: {filepath}")
         return filepath
 
-# Custom CSS
+# Custom CSS with enhanced recovery status
 custom_css = """
 .gradio-container {
     background: linear-gradient(135deg, #1e3c72, #2a5298);
@@ -2005,6 +2128,15 @@ custom_css = """
     color: white;
 }
 
+.recovery-status {
+    background-color: rgba(76, 175, 80, 0.2);
+    border: 1px solid #4CAF50;
+    padding: 10px;
+    border-radius: 5px;
+    margin: 10px 0;
+    color: #4CAF50;
+}
+
 #stages-display {
     background-color: rgba(255, 255, 255, 0.95);
     padding: 20px;
@@ -2033,6 +2165,11 @@ custom_css = """
     color: #4CAF50;
     font-weight: bold;
 }
+
+.auto-save-indicator {
+    color: #2196F3;
+    font-weight: bold;
+}
 """
 
 # Create Gradio Interface
@@ -2044,13 +2181,15 @@ def create_interface():
                 📚 SOMA Novel Writing System
             </h1>
             <h3 style="color: #ccc; margin-bottom: 20px;">
-                AI Collaborative Novel Generation with Web Research - 48 Page Novella Creator
+                AI Collaborative Novel Generation - 10 Writers Edition
             </h3>
             <p style="font-size: 1.1em; color: #ddd; max-width: 800px; margin: 0 auto;">
-                Enter a theme or prompt, and watch as 19 AI agents collaborate to create a complete 48-page novella.
-                The system includes 1 Director, 1 Critic, and 16 Writers (each writing 3 pages) working in harmony.
-                <span class="search-indicator">🔍 Web search enabled</span> - agents will research relevant information for more realistic content.
-                All progress is automatically saved and can be resumed anytime.
+                Enter a theme or prompt, and watch as 13 AI agents collaborate to create a complete 30-page novella.
+                The system includes 1 Director, 1 Critic, and 10 Writers (each writing 3 pages) working in harmony.
+                <br><br>
+                <span class="search-indicator">🔍 Web search enabled</span> | 
+                <span class="auto-save-indicator">💾 Auto-save enabled</span> | 
+                <span style="color: #FF9800;">♻️ Auto-recovery on refresh</span>
             </p>
         </div>
         """)
@@ -2058,6 +2197,13 @@ def create_interface():
         # State management
         current_session_id = gr.State(None)
         
+        # Recovery status display
+        recovery_status = gr.Markdown(
+            value="",
+            elem_classes=["recovery-status"],
+            visible=False
+        )
+        
         with gr.Row():
             with gr.Column(scale=1):
                 with gr.Group(elem_classes=["input-section"]):
@@ -2097,8 +2243,9 @@ def create_interface():
                             interactive=True
                         )
                         with gr.Row():
-                            refresh_btn = gr.Button("🔄 Refresh / 새로고침", scale=1)
-                            resume_btn = gr.Button("▶️ Resume / 재개", variant="secondary", scale=1)
+                            refresh_btn = gr.Button("🔄 Refresh List / 목록 새로고침", scale=1)
+                            resume_btn = gr.Button("▶️ Resume Selected / 선택 재개", variant="secondary", scale=1)
+                            auto_recover_btn = gr.Button("♻️ Auto Recover Latest / 최신 자동복구", scale=1)
         
         with gr.Column(scale=2):
             with gr.Tab("📝 Writing Process / 작성 과정"):
@@ -2114,14 +2261,14 @@ def create_interface():
                 )
                 
                 with gr.Group(elem_classes=["download-section"]):
-                    gr.Markdown("### 📥 Download Novel / 소설 다운로드")
+                    gr.Markdown("### 📥 Download Complete Novel / 전체 소설 다운로드")
                     with gr.Row():
                         format_select = gr.Radio(
                             choices=["DOCX", "TXT"],
                             value="DOCX" if DOCX_AVAILABLE else "TXT",
                             label="Format / 형식"
                         )
-                        download_btn = gr.Button("⬇️ Download / 다운로드", variant="secondary")
+                        download_btn = gr.Button("⬇️ Download All 10 Writers / 10명 작가 전체 다운로드", variant="secondary")
                     
                     download_file = gr.File(
                         label="Downloaded File / 다운로드된 파일",
@@ -2147,8 +2294,8 @@ def create_interface():
             )
         
         # Event handlers
-        def update_novel_state(stages, novel, status):
-            return stages, novel, status, novel
+        def update_novel_state(stages, novel, status, recovery_msg):
+            return stages, novel, status, novel, recovery_msg
         
         def refresh_sessions():
             try:
@@ -2158,14 +2305,25 @@ def create_interface():
                 logger.error(f"Error refreshing sessions: {str(e)}", exc_info=True)
                 return gr.update(choices=[])
         
+        def handle_auto_recover(language):
+            session_id, message = auto_recover_session(language)
+            if session_id:
+                return session_id, gr.update(value=message, visible=True)
+            else:
+                if language == "Korean":
+                    message = "❌ 복구할 세션이 없습니다."
+                else:
+                    message = "❌ No session to recover."
+                return None, gr.update(value=message, visible=True)
+        
         submit_btn.click(
             fn=process_query,
             inputs=[query_input, language_select, current_session_id],
-            outputs=[stages_display, novel_output, status_text]
+            outputs=[stages_display, novel_output, status_text, recovery_status.value]
         ).then(
             fn=update_novel_state,
-            inputs=[stages_display, novel_output, status_text],
-            outputs=[stages_display, novel_output, status_text, novel_text_state]
+            inputs=[stages_display, novel_output, status_text, recovery_status.value],
+            outputs=[stages_display, novel_output, status_text, novel_text_state, recovery_status]
         )
         
         resume_btn.click(
@@ -2175,7 +2333,17 @@ def create_interface():
         ).then(
             fn=resume_session,
             inputs=[current_session_id, language_select],
-            outputs=[stages_display, novel_output, status_text]
+            outputs=[stages_display, novel_output, status_text, recovery_status.value]
+        )
+        
+        auto_recover_btn.click(
+            fn=handle_auto_recover,
+            inputs=[language_select],
+            outputs=[current_session_id, recovery_status]
+        ).then(
+            fn=resume_session,
+            inputs=[current_session_id, language_select],
+            outputs=[stages_display, novel_output, status_text, recovery_status.value]
         )
         
         refresh_btn.click(
@@ -2184,15 +2352,15 @@ def create_interface():
         )
         
         clear_btn.click(
-            fn=lambda: ("", "", "🔄 Ready", "", None),
-            outputs=[stages_display, novel_output, status_text, novel_text_state, current_session_id]
+            fn=lambda: ("", "", "🔄 Ready", "", None, gr.update(visible=False)),
+            outputs=[stages_display, novel_output, status_text, novel_text_state, current_session_id, recovery_status]
         )
         
-        def handle_download(novel_text, format_type, language):
-            if not novel_text:
+        def handle_download(novel_text, format_type, language, session_id):
+            if not novel_text and not session_id:
                 return gr.update(visible=False)
             
-            file_path = download_novel(novel_text, format_type, language)
+            file_path = download_novel(novel_text, format_type, language, session_id)
             if file_path:
                 return gr.update(value=file_path, visible=True)
             else:
@@ -2200,52 +2368,33 @@ def create_interface():
         
         download_btn.click(
             fn=handle_download,
-            inputs=[novel_text_state, format_select, language_select],
+            inputs=[novel_text_state, format_select, language_select, current_session_id],
             outputs=[download_file]
         )
         
-        # Load sessions on startup
+        # Load sessions and check for auto-recovery on startup
+        def on_load():
+            sessions = get_active_sessions("English")
+            # Check for latest session
+            latest_session = NovelDatabase.get_latest_active_session()
+            if latest_session:
+                recovery_msg = f"💡 Found active session: '{latest_session['user_query'][:30]}...' - Click 'Auto Recover Latest' to continue"
+                return gr.update(choices=sessions), gr.update(value=recovery_msg, visible=True)
+            else:
+                return gr.update(choices=sessions), gr.update(visible=False)
+        
         interface.load(
-            fn=refresh_sessions,
-            outputs=[session_dropdown]
+            fn=on_load,
+            outputs=[session_dropdown, recovery_status]
         )
     
     return interface
 
-# 빠른 테스트를 위한 축소 버전 추가
-def create_quick_test_interface():
-    """빠른 테스트를 위한 간단한 인터페이스"""
-    with gr.Blocks(title="Novel Writing System - Quick Test") as interface:
-        gr.Markdown("# 🚀 Quick Test Mode - 3 Writers Only")
-        
-        with gr.Row():
-            query_input = gr.Textbox(label="Novel Theme", placeholder="Enter theme...")
-            language = gr.Radio(["English", "Korean"], value="English", label="Language")
-            submit_btn = gr.Button("Start Quick Test")
-        
-        output = gr.Textbox(label="Output", lines=20)
-        
-        def quick_test(query, lang):
-            system = NovelWritingSystem()
-            # 3명의 작가만 테스트
-            stages = ["Director Plan", "Writer 1", "Writer 2", "Writer 3", "Final"]
-            result = f"Testing with theme: {query}\n\n"
-            
-            for stage in stages:
-                result += f"Processing {stage}...\n"
-                time.sleep(1)  # 시뮬레이션
-                
-            return result + "\nQuick test complete!"
-        
-        submit_btn.click(quick_test, inputs=[query_input, language], outputs=output)
-    
-    return interface
-
 # Main execution
 if __name__ == "__main__":
     import sys
     
-    logger.info("Starting SOMA Novel Writing System...")
+    logger.info("Starting SOMA Novel Writing System - 10 Writers Edition...")
     
     # Check environment
     if TEST_MODE:
@@ -2264,13 +2413,7 @@ if __name__ == "__main__":
     NovelDatabase.init_db()
     logger.info("Database initialized successfully.")
     
-    # 빠른 테스트 모드 옵션
-    if "--quick-test" in sys.argv:
-        logger.info("Running in QUICK TEST mode")
-        interface = create_quick_test_interface()
-    else:
-        logger.info("Running in FULL mode")
-        interface = create_interface()
+    interface = create_interface()
     
     interface.launch(
         server_name="0.0.0.0",