Update app-backup.py

app-backup.py

@@ -309,6 +309,8 @@ class NovelDatabase:
         """Save stage content with word count"""
         word_count = len(content.split()) if content else 0
         
+        logger.info(f"Saving stage: session={session_id}, stage_num={stage_number}, role={role}, stage_name={stage_name}, words={word_count}")
+        
         with NovelDatabase.get_db() as conn:
             cursor = conn.cursor()
             
@@ -331,7 +333,7 @@ class NovelDatabase:
             ''', (stage_number, stage_number, session_id))
             
             conn.commit()
-            logger.info(f"Saved stage {stage_number} for session {session_id}, content length: {len(content)}, words: {word_count}")
+            logger.info(f"Stage saved successfully")
     
     @staticmethod
     def get_session(session_id: str) -> Optional[Dict]:
@@ -367,8 +369,8 @@ class NovelDatabase:
             return cursor.fetchall()
     
     @staticmethod
-    def get_all_writer_content(session_id: str) -> str:
-        """모든 작가의 수정본 내용을 가져와서 합치기 - 10명 작가"""
+    def get_all_writer_content(session_id: str, test_mode: bool = False) -> str:
+        """모든 작가의 수정본 내용을 가져와서 합치기"""
         with NovelDatabase.get_db() as conn:
             cursor = conn.cursor()
             
@@ -376,15 +378,18 @@ class NovelDatabase:
             writer_count = 0
             total_word_count = 0
             
-            for stage_num in WRITER_REVISION_STAGES:
+            if test_mode:
+                # 테스트 모드: writer1 revision + writer10 content
+                # Writer 1 수정본 - 언어 무관
                 cursor.execute('''
                     SELECT content, stage_name, word_count FROM stages 
-                    WHERE session_id = ? AND stage_number = ?
-                ''', (session_id, stage_num))
+                    WHERE session_id = ? AND role = 'writer1' 
+                    AND (stage_name LIKE '%Revision%' OR stage_name LIKE '%수정본%')
+                ''', (session_id,))
+                
                 
                 row = cursor.fetchone()
                 if row and row['content']:
-                    # 페이지 마크 완전 제거
                     clean_content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', row['content'])
                     clean_content = re.sub(r'(?:페이지|Page)\s*\d+:', '', clean_content)
                     clean_content = clean_content.strip()
@@ -394,14 +399,58 @@ class NovelDatabase:
                         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")
+                        logger.info(f"Test mode - Writer 1: {word_count} words")
+                
+                # Writer 10 content (나머지 챕터들)
+                cursor.execute('''
+                    SELECT content, stage_name, word_count FROM stages 
+                    WHERE session_id = ? AND role = 'writer10'
+                ''', (session_id,))
+                
+                row = cursor.fetchone()
+                if row and row['content']:
+                    # Writer 10은 이미 여러 챕터를 포함하고 있으므로 그대로 추가
+                    clean_content = row['content'].strip()
+                    if clean_content:
+                        word_count = row['word_count'] or len(clean_content.split())
+                        total_word_count += word_count
+                        all_content.append(clean_content)
+                        writer_count = 10  # 테스트 모드에서는 총 10개 챕터
+                        logger.info(f"Test mode - Writer 10 (Chapters 2-10): {word_count} words")
+            else:
+                # 일반 모드: 모든 작가의 수정본
+                writer_stages_to_check = WRITER_REVISION_STAGES
+                
+                for stage_num in writer_stages_to_check:
+                    cursor.execute('''
+                        SELECT content, stage_name, word_count FROM stages 
+                        WHERE session_id = ? AND stage_number = ?
+                    ''', (session_id, stage_num))
+                    
+                    row = cursor.fetchone()
+                    if row and row['content']:
+                        # 페이지 마크 완전 제거
+                        clean_content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', row['content'])
+                        clean_content = re.sub(r'(?:페이지|Page)\s*\d+:', '', clean_content)
+                        clean_content = clean_content.strip()
+                        
+                        if clean_content:
+                            writer_count += 1
+                            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")
             
-            # 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")
+            if test_mode:
+                logger.info(f"Test mode - Total: {writer_count} chapters, {total_word_count} words")
+                if total_word_count < 2800:  # 최소 예상치
+                    logger.warning(f"Test mode content short! Only {total_word_count} words")
+            else:
+                logger.info(f"Total: {writer_count} writers, {total_word_count} words")
+                if total_word_count < 12000:  
+                    logger.warning(f"Content too short! Only {total_word_count} words instead of ~14,500")
             
             return full_content
     
@@ -418,6 +467,52 @@ class NovelDatabase:
             conn.commit()
             logger.info(f"Updated final novel for session {session_id}, length: {len(final_novel)}")
     
+    @staticmethod
+    def verify_novel_content(session_id: str) -> Dict[str, Any]:
+        """세션의 전체 소설 내용 검증"""
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            
+            # 모든 작가 수정본 확인
+            cursor.execute(f'''
+                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
+            ''', (session_id,))
+            
+            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,
+                    'words': row['word_count'] or 0
+                })
+                total_length += row['content_length'] or 0
+                total_words += row['word_count'] or 0
+            
+            # 최종 소설 확인
+            cursor.execute('''
+                SELECT LENGTH(final_novel) as final_length
+                FROM sessions
+                WHERE session_id = ?
+            ''', (session_id,))
+            
+            final_row = cursor.fetchone()
+            final_length = final_row['final_length'] if final_row else 0
+            
+            return {
+                'writer_stages': results,
+                'total_writer_content': total_length,
+                'total_words': total_words,
+                'final_novel_length': final_length,
+                'expected_words': 14500  # 10 작가 * 1450 평균
+            }
+    
     @staticmethod
     def get_active_sessions() -> List[Dict]:
         """Get all active sessions"""
@@ -978,6 +1073,69 @@ Write a revision reflecting:
 Present the revised final version. Never use page markers.
 You MUST maintain 1,400-1,500 words."""
     
+    def create_test_writer_remaining_prompt(self, director_plan: str, writer1_content: str, language: str) -> str:
+        """Test mode - Writer 10 writes remaining novel (chapters 2-10)"""
+        if language == "Korean":
+            return f"""[테스트 모드] 당신은 나머지 9개 챕터(Chapter 2-10)를 작성하는 특별 작가입니다.
+
+감독자의 마스터플랜:
+{director_plan}
+
+작성자 1이 이미 작성한 Chapter 1:
+{writer1_content[-1000:] if writer1_content else '(첫 번째 챕터가 없습니다)'}
+
+**중요 지침:**
+1. Chapter 2부터 Chapter 10까지 9개 챕터를 작성하세요
+2. 각 챕터는 약 1,400-1,500 단어로 작성하세요
+3. 총 12,600-13,500 단어 (9개 챕터)
+4. Chapter 1과 자연스럽게 이어지도록 작성하세요
+5. 마스터플랜의 모든 요소를 포함하여 완결된 이야기를 만드세요
+
+**필수 형식:**
+반드시 아래와 같이 챕터를 명확히 구분하세요:
+
+[Chapter 2]
+(1,400-1,500 단어의 내용)
+
+[Chapter 3]
+(1,400-1,500 단어의 내용)
+
+...이런 식으로 [Chapter 10]까지...
+
+각 챕터는 반드시 [Chapter 숫자] 형식으로 시작해야 합니다.
+챕터 사이에는 빈 줄을 넣어 구분하세요.
+Chapter 2부터 10까지 작성하세요."""
+        else:
+            return f"""[TEST MODE] You are a special writer creating the remaining 9 chapters (Chapters 2-10).
+
+Director's Masterplan:
+{director_plan}
+
+Writer 1 has already written Chapter 1:
+{writer1_content[-1000:] if writer1_content else '(No first chapter available)'}
+
+**CRITICAL INSTRUCTIONS:**
+1. Write Chapters 2 through 10 (9 chapters total)
+2. Each chapter should be ~1,400-1,500 words
+3. Total 12,600-13,500 words (9 chapters)
+4. Continue naturally from Chapter 1
+5. Include all elements from the masterplan to create a complete story
+
+**MANDATORY FORMAT:**
+You MUST clearly separate chapters as follows:
+
+[Chapter 2]
+(1,400-1,500 words of content)
+
+[Chapter 3]
+(1,400-1,500 words of content)
+
+...continue this way until [Chapter 10]...
+
+Each chapter MUST start with [Chapter number] format.
+Leave blank lines between chapters for separation.
+Write Chapters 2-10 now."""
+    
     def simulate_streaming(self, text: str, role: str) -> Generator[str, None, None]:
         """Simulate streaming in test mode"""
         words = text.split()
@@ -1030,7 +1188,11 @@ You MUST maintain 1,400-1,500 words."""
             ]
             
             # 작성자들에게는 적절한 토큰 할당
-            if role.startswith("writer"):
+            if role == "writer10" and stage_info and stage_info.get('test_mode'):
+                max_tokens = 30000  # 테스트 모드: 9개 챕터 작성 (충분한 토큰)
+                temperature = 0.8   
+                top_p = 0.95
+            elif role.startswith("writer"):
                 max_tokens = 10000  # 충분한 토큰
                 temperature = 0.8   
                 top_p = 0.95       
@@ -1162,11 +1324,12 @@ You MUST maintain 1,400-1,500 words."""
             yield f"❌ Error occurred: {str(e)}"
     
     def get_system_prompts(self, language: str) -> Dict[str, str]:
-        """Get system prompts for all 10 writers"""
+        """Get system prompts for all writers including test mode"""
         if language == "Korean":
             prompts = {
                 "director": "당신은 30페이지 중편 소설을 기획하고 감독하는 문학 감독자입니다. 체계적이고 창의적인 스토리 구조를 만들어냅니다.",
-                "critic": "당신은 날카로운 통찰력을 가진 문학 비평가입니다. 건설적이고 구체적인 피드백을 제공합니다."
+                "critic": "당신은 날카로운 통찰력을 가진 문학 비평가입니다. 건설적이고 구체적인 피드백을 제공합니다.",
+                "writer10": "[테스트 모드] 당신은 챕터 2-10을 작성하는 특별 작가입니다. 9개 챕터로 구성된 나머지 소설을 작성하세요. 각 챕터는 반드시 1,400-1,500단어로 작성하세요."
             }
             
             # 10명의 작가 프롬프트
@@ -1190,7 +1353,8 @@ You MUST maintain 1,400-1,500 words."""
         else:
             prompts = {
                 "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."
+                "critic": "You are a literary critic with sharp insights. You provide constructive and specific feedback.",
+                "writer10": "[TEST MODE] You are a special writer creating chapters 2-10. Write the remaining novel organized into 9 chapters. Each chapter MUST be 1,400-1,500 words."
             }
             
             # 10 writer prompts
@@ -1213,7 +1377,7 @@ You MUST maintain 1,400-1,500 words."""
             return prompts
     
     def get_test_response(self, role: str, language: str) -> str:
-        """Get test response based on role"""
+        """Get test response based on role - updated for writer10 chapters 2-10"""
         if language == "Korean":
             return self.get_korean_test_response(role)
         else:
@@ -1291,6 +1455,19 @@ You MUST maintain 1,400-1,500 words."""
                 writer_content += "\n\n"
             
             test_responses[f"writer{i}"] = writer_content
+        
+        # 테스트 모드용 writer10 응답
+        if role == "writer10":
+            full_novel = ""
+            for i in range(2, 11):  # Chapter 2부터 10까지
+                full_novel += f"[Chapter {i}]\n\n"
+                # 각 챕터마다 약 300단어씩 5단락
+                for j in range(5):
+                    full_novel += sample_story + f"\n\n그것은 챕터 {i}의 {j+1}번째 단락이었다. "
+                    full_novel += "이야기는 계속 전개되었고, 인물들의 감정은 점점 더 복잡해졌다. " * 20
+                    full_novel += "\n\n"
+                full_novel += "\n\n"  # 챕터 간 구분
+            test_responses["writer10"] = full_novel
             
         return test_responses.get(role, "테스트 응답입니다.")
     
@@ -1359,12 +1536,26 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                 writer_content += "\n\n"
             
             test_responses[f"writer{i}"] = writer_content
+        
+        # Test mode writer10 response
+        if role == "writer10":
+            full_novel = ""
+            for i in range(2, 11):  # Chapters 2-10
+                full_novel += f"[Chapter {i}]\n\n"
+                # About 300 words per paragraph, 5 paragraphs per chapter
+                for j in range(5):
+                    full_novel += sample_story + f"\n\nThis was paragraph {j+1} of chapter {i}. "
+                    full_novel += "The story continued to unfold, and the characters' emotions grew increasingly complex. " * 20
+                    full_novel += "\n\n"
+                full_novel += "\n\n"  # Chapter separation
+            test_responses["writer10"] = full_novel
             
         return test_responses.get(role, "Test response.")
     
     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]:
+                           resume_from_stage: int = 0,
+                           test_quick_mode: bool = False) -> Generator[Tuple[str, List[Dict[str, str]]], None, None]:
         """Process novel writing with streaming updates - 최종 Director/Critic 제거"""
         try:
             global conversation_history
@@ -1377,11 +1568,13 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                     query = session['user_query']
                     language = session['language']
                     resume_from_stage = session['current_stage'] + 1
+                    logger.info(f"Resuming session {session_id} from stage {resume_from_stage}")
             else:
                 self.current_session_id = NovelDatabase.create_session(query, language)
                 resume_from_stage = 0
+                logger.info(f"Created new session: {self.current_session_id}")
             
-            logger.info(f"Processing novel for session {self.current_session_id}, starting from stage {resume_from_stage}")
+            logger.info(f"Processing novel for session {self.current_session_id}, starting from stage {resume_from_stage}, test_mode={test_quick_mode}")
             
             # Initialize conversation
             conversation_history = [{
@@ -1402,19 +1595,31 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                     })
             
             # 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 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'}"),
-                    (f"writer{writer_num}", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} {writer_num}: {'수정본' if language == 'Korean' else 'Revision'}")
-                ])
+            if test_quick_mode:
+                # 테스트 모드: 1,2,3단계 + Writer 1 + Writer 10
+                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'}"),
+                    ("writer1", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} 1: {'초안' if language == 'Korean' else 'Draft'}"),
+                    ("critic", f"📝 {'비평가: 작성자' if language == 'Korean' else 'Critic: Writer'} 1 {'검토' if language == 'Korean' else 'Review'}"),
+                    ("writer1", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} 1: {'수정본' if language == 'Korean' else 'Revision'}"),
+                    ("writer10", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} 10 (TEST): {'나머지 소설' if language == 'Korean' else 'Remaining Novel'}"),
+                ]
+            else:
+                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 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'}"),
+                        (f"writer{writer_num}", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} {writer_num}: {'수정본' if language == 'Korean' else 'Revision'}")
+                    ])
             
             # 최종 Director와 Critic 단계 제거
             
@@ -1442,13 +1647,14 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                 yield "", stages
                 
                 # Get appropriate prompt based on stage
-                prompt = self.get_stage_prompt(stage_idx, role, query, language, stages)
+                prompt = self.get_stage_prompt(stage_idx, role, query, language, stages, test_quick_mode)
                 
                 # Create stage info for web search
                 stage_info = {
                     'stage_idx': stage_idx,
                     'query': query,
-                    'stage_name': stage_name
+                    'stage_name': stage_name,
+                    'test_mode': test_quick_mode
                 }
                 
                 stage_content = ""
@@ -1466,6 +1672,9 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                 
                 # Mark stage complete and save to DB
                 stages[stage_idx]["status"] = "complete"
+                
+                # Test mode에서는 writer1과 writer2만 처리
+                # writer10 관련 특별 처리 제거 - 일반 프로세스와 동일
                 NovelDatabase.save_stage(
                     self.current_session_id,
                     stage_idx,
@@ -1485,19 +1694,29 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
             # Verify content after completion
             if self.current_session_id:
                 verification = NovelDatabase.verify_novel_content(self.current_session_id)
-                logger.info(f"Content verification: {verification}")
+                if test_quick_mode:
+                    logger.info(f"[TEST MODE] Content verification: {verification}")
+                else:
+                    logger.info(f"Content verification: {verification}")
                 
-                if verification['total_words'] < 12000:
+                if verification['total_words'] < 12000 and not test_quick_mode:
                     logger.error(f"Final novel too short! Only {verification['total_words']} words")
             
             # Get complete novel from DB
-            complete_novel = NovelDatabase.get_all_writer_content(self.current_session_id)
+            complete_novel = NovelDatabase.get_all_writer_content(self.current_session_id, test_quick_mode)
+            
+            # 테스트 모드면 완료 상태 업데이트
+            if test_quick_mode and self.current_session_id:
+                NovelDatabase.update_final_novel(self.current_session_id, complete_novel)
             
             # Save final novel to DB
             NovelDatabase.update_final_novel(self.current_session_id, complete_novel)
             
             # Final yield - 화면에는 완료 메시지만 표시
-            final_message = f"✅ Novel complete! {len(complete_novel.split())} words total. Click Download to save."
+            if test_quick_mode:
+                final_message = f"✅ [TEST MODE] Novel complete! 2 chapters, {len(complete_novel.split())} words total. Click Download to save."
+            else:
+                final_message = f"✅ Novel complete! {len(complete_novel.split())} words total. Click Download to save."
             yield final_message, stages
             
         except Exception as e:
@@ -1522,8 +1741,53 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
             stages.append(error_stage)
             yield f"Error occurred: {str(e)}", stages
     
+    def create_test_writer_complete_prompt(self, director_plan: str, language: str = "English") -> str:
+        """Test mode - Writer 10 writes complete novel"""
+        if language == "Korean":
+            return f"""[테스트 모드] 당신은 전체 30페이지 소설을 한 번에 작성하는 특별 작가입니다.
+
+감독자의 마스터플랜:
+{director_plan}
+
+**중요 지침:**
+1. 전체 30페이지 분량의 완성된 소설을 작성하세요
+2. 총 14,000-15,000 단어로 작성하세요
+3. 10개의 자연스러운 챕터로 구성하세요 (각 챕터 약 1,400-1,500 단어)
+4. 시작부터 결말까지 완전한 이야기를 만드세요
+5. 마스터플랜의 모든 요소를 포함하세���
+
+챕터 구분은 다음과 같이 표시하세요:
+[Chapter 1]
+내용...
+
+[Chapter 2]
+내용...
+
+완성도 높은 전체 소설을 작성하세요."""
+        else:
+            return f"""[TEST MODE] You are a special writer creating the complete 30-page novel at once.
+
+Director's Masterplan:
+{director_plan}
+
+**CRITICAL INSTRUCTIONS:**
+1. Write a complete 30-page novel
+2. Total 14,000-15,000 words
+3. Organize into 10 natural chapters (each chapter ~1,400-1,500 words)
+4. Create a complete story from beginning to end
+5. Include all elements from the masterplan
+
+Mark chapters as follows:
+[Chapter 1]
+content...
+
+[Chapter 2]
+content...
+
+Write a high-quality complete novel."""
+    
     def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
-                        language: str, stages: List[Dict]) -> str:
+                        language: str, stages: List[Dict], test_mode: bool = False) -> str:
         """Get appropriate prompt for each stage"""
         # Stage 0: Director Initial
         if stage_idx == 0:
@@ -1543,6 +1807,16 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
             writer_num = int(role.replace("writer", ""))
             final_plan = stages[2]["content"]  # Director's final plan
             
+            # Test mode special writer10
+            if role == "writer10" and test_mode:
+                # Get writer1's revision content
+                writer1_content = ""
+                for i, stage in enumerate(stages):
+                    if "Writer 1: Revision" in stage["name"] or "작성자 1: 수정본" in stage["name"]:
+                        writer1_content = stage["content"]
+                        break
+                return self.create_test_writer_remaining_prompt(final_plan, writer1_content, language)
+            
             # Initial draft or revision?
             if "초안" in stages[stage_idx]["name"] or "Draft" in stages[stage_idx]["name"]:
                 # Get accumulated content from DB
@@ -1581,27 +1855,32 @@ 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, str], None, None]:
-    """Process query and yield updates with recovery status"""
+def process_query(query: str, language: str, session_id: str = None, test_mode: bool = False) -> Generator[Tuple[str, str, str, str], None, None]:
+    """Process query and yield updates with session ID"""
     if not query.strip() and not session_id:
         if language == "Korean":
-            yield "", "", "❌ 소설 주제를 입력해주세요.", ""
+            yield "", "", "❌ 소설 주제를 입력해주세요.", None
         else:
-            yield "", "", "❌ Please enter a novel theme.", ""
+            yield "", "", "❌ Please enter a novel theme.", None
         return
     
     system = NovelWritingSystem()
     
     try:
-        # Recovery status message
-        recovery_status = ""
+        # Status message with mode indicator
+        mode_status = ""
         if session_id:
             if language == "Korean":
-                recovery_status = "♻️ 이전 세션을 복구하여 계속 진행합니다..."
+                mode_status = " [♻️ 복구 모드]"
+            else:
+                mode_status = " [♻️ Recovery Mode]"
+        elif test_mode:
+            if language == "Korean":
+                mode_status = " [🧪 테스트 모드: 7단계]"
             else:
-                recovery_status = "♻️ Recovering previous session and continuing..."
+                mode_status = " [🧪 Test Mode: 7 stages]"
         
-        for final_novel, stages in system.process_novel_stream(query, language, session_id):
+        for final_novel, stages in system.process_novel_stream(query, language, session_id, test_quick_mode=test_mode):
             # Format stages for display
             stages_display = format_stages_display(stages, language)
             
@@ -1610,22 +1889,23 @@ def process_query(query: str, language: str, session_id: str = None) -> Generato
             total = len(stages)
             progress_percent = (completed / total * 100) if total > 0 else 0
             
-            if "✅ Novel complete!" in str(final_novel):
-                status = "✅ Complete! Ready to download."
+            if "✅ Novel complete!" in str(final_novel) or "✅ [TEST MODE] Novel complete!" in str(final_novel):
+                status = f"✅ Complete! Ready to download.{mode_status}"
             else:
                 if language == "Korean":
-                    status = f"🔄 진행중... ({completed}/{total} - {progress_percent:.1f}%)"
+                    status = f"🔄 진행중... ({completed}/{total} - {progress_percent:.1f}%){mode_status}"
                 else:
-                    status = f"🔄 Processing... ({completed}/{total} - {progress_percent:.1f}%)"
+                    status = f"🔄 Processing... ({completed}/{total} - {progress_percent:.1f}%){mode_status}"
             
-            yield stages_display, final_novel, status, recovery_status
+            # Return current session ID
+            yield stages_display, final_novel, status, system.current_session_id
                     
     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)}", None
         else:
-            yield "", "", f"❌ Error occurred: {str(e)}", ""
+            yield "", "", f"❌ Error occurred: {str(e)}", None
 
 def format_stages_display(stages: List[Dict[str, str]], language: str) -> str:
     """Format stages into simple display with writer save status"""
@@ -1666,17 +1946,17 @@ 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, test_mode: bool = False) -> Generator[Tuple[str, str, str, str], None, None]:
     """Resume an existing session"""
     if not session_id:
         if language == "Korean":
-            yield "", "", "❌ 세션을 선택해주세요."
+            yield "", "", "❌ 세션을 선택해주세요.", None
         else:
-            yield "", "", "❌ Please select a session."
+            yield "", "", "❌ Please select a session.", None
         return
     
     # Process with existing session ID
-    yield from process_query("", language, session_id)
+    yield from process_query("", language, session_id, test_mode)
 
 def auto_recover_session(language: str) -> Tuple[str, str]:
     """Auto recover the latest active session"""
@@ -1700,14 +1980,39 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         logger.error("No session_id provided for download")
         return None
     
+    logger.info(f"Starting download for session: {session_id}, format: {format}")
+    
     # DB에서 세션 정보 가져오기
     session = NovelDatabase.get_session(session_id)
     if not session:
         logger.error(f"Session not found: {session_id}")
         return None
     
+    # 세션의 실제 언어 사용 (파라미터로 받은 language 대신)
+    actual_language = session['language']
+    logger.info(f"Using session language: {actual_language} (parameter was: {language})")
+    
     # DB에서 모든 스테이지 가져오기
     stages = NovelDatabase.get_stages(session_id)
+    logger.info(f"Found {len(stages)} stages in database")
+    
+    # 디버깅: 모든 stage 정보 출력
+    for i, stage in enumerate(stages):
+        role = stage['role'] if 'role' in stage.keys() else 'None'
+        stage_name = stage['stage_name'] if 'stage_name' in stage.keys() else 'None'
+        content_len = len(stage['content']) if 'content' in stage.keys() and stage['content'] else 0
+        status = stage['status'] if 'status' in stage.keys() else 'None'
+        logger.debug(f"Stage {i}: role={role}, stage_name={stage_name}, content_length={content_len}, status={status}")
+    
+    # 테스트 모드 감지 - writer10이 있으면 테스트 모드
+    is_test_mode = False
+    has_writer10 = any(stage['role'] == 'writer10' for stage in stages if 'role' in stage.keys())
+    has_writer1 = any(stage['role'] == 'writer1' for stage in stages if 'role' in stage.keys())
+    has_writer3 = any(stage['role'] == 'writer3' for stage in stages if 'role' in stage.keys())
+    
+    if has_writer10 and has_writer1 and not has_writer3:
+        is_test_mode = True
+        logger.info("Test mode detected - writer1 + writer10 mode")
     
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     
@@ -1717,7 +2022,7 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         
         # 제목 페이지
         title_para = doc.add_paragraph()
-        title_run = title_para.add_run('AI Collaborative Novel')
+        title_run = title_para.add_run('AI Collaborative Novel' + (' - Test Mode' if is_test_mode else ''))
         title_run.font.size = Pt(24)
         title_run.font.bold = True
         title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
@@ -1745,59 +2050,147 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         
         # 각 작가의 수정본만 수집
         writer_contents = []
-        for stage in stages:
-            if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
-                writer_count += 1
-                content = stage['content'] or ""
-                # 페이지 마크 제거
-                content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
-                content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
-                content = content.strip()
+        
+        if is_test_mode:
+            # 테스트 모드: writer1 revision + writer10 내용 처리
+            for stage in stages:
+                role = stage['role'] if 'role' in stage.keys() else None
+                stage_name = stage['stage_name'] if 'stage_name' in stage.keys() else ''
+                content = stage['content'] if 'content' in stage.keys() else ''
                 
-                if content:
-                    word_count = stage['word_count'] or len(content.split())
-                    total_words += word_count
-                    writer_contents.append({
-                        'writer_num': writer_count,
-                        'content': content,
-                        'word_count': word_count
-                    })
+                logger.info(f"[TEST MODE] Checking stage: role={role}, name={stage_name}, status={stage['status'] if 'status' in stage.keys() else 'None'}")
+                
+                # Writer 1 수정본
+                if role == 'writer1' and stage_name and ('Revision' in stage_name or '수정본' in stage_name):
+                    content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
+                    content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
+                    content = content.strip()
+                    
+                    if content:
+                        word_count = stage['word_count'] if 'word_count' in stage.keys() else len(content.split())
+                        total_words += word_count
+                        writer_contents.append({
+                            'writer_num': 1,
+                            'content': content,
+                            'word_count': word_count
+                        })
+                        writer_count = 1
+                        logger.info(f"Added writer 1 (Chapter 1): {word_count} words")
+                
+                # Writer 10 (테스트 모드에서 나머지 챕터들)
+                elif role == 'writer10':
+                    logger.info(f"Processing writer10 content: {len(content)} chars")
+                    
+                    # [Chapter X] 패턴으로 챕터 분리
+                    chapters = re.split(r'\[Chapter\s+(\d+)\]', content)
+                    
+                    # chapters는 ['', '2', 'content2', '3', 'content3', ...] 형태
+                    for i in range(1, len(chapters), 2):
+                        if i+1 < len(chapters):
+                            chapter_num = int(chapters[i])
+                            chapter_content = chapters[i+1].strip()
+                            
+                            if chapter_content:
+                                word_count = len(chapter_content.split())
+                                total_words += word_count
+                                writer_contents.append({
+                                    'writer_num': chapter_num,
+                                    'content': chapter_content,
+                                    'word_count': word_count
+                                })
+                                writer_count = max(writer_count, chapter_num)
+                                logger.info(f"Added Chapter {chapter_num}: {word_count} words")
+        else:
+            # 일반 모드: 모든 작가 수정본 처리
+            logger.info("[NORMAL MODE] Processing all writer revisions...")
+            
+            for stage in stages:
+                role = stage['role'] if 'role' in stage.keys() else None
+                stage_name = stage['stage_name'] if 'stage_name' in stage.keys() else ''
+                content = stage['content'] if 'content' in stage.keys() else ''
+                status = stage['status'] if 'status' in stage.keys() else ''
+                
+                # 디버깅 정보
+                logger.debug(f"[NORMAL MODE] Checking: role={role}, name={stage_name}, status={status}, content_len={len(content)}")
+                
+                # 언어에 상관없이 작가 수정본 찾기
+                is_writer = role and role.startswith('writer')
+                is_revision = stage_name and ('Revision' in stage_name or '수정본' in stage_name)
+                
+                if is_writer and is_revision:
+                    # 작가 번호 추출
+                    try:
+                        writer_num = int(role.replace('writer', ''))
+                        logger.info(f"Found writer {writer_num} revision - stage_name: {stage_name}")
+                    except:
+                        logger.warning(f"Could not extract writer number from role: {role}")
+                        continue
+                    
+                    # 페이지 마크 제거
+                    content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
+                    content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
+                    content = content.strip()
+                    
+                    if content:
+                        word_count = stage['word_count'] if 'word_count' in stage.keys() else len(content.split())
+                        total_words += word_count
+                        writer_contents.append({
+                            'writer_num': writer_num,
+                            'content': content,
+                            'word_count': word_count
+                        })
+                        writer_count += 1  # 실제 작가 수 카운트
+                        logger.info(f"Added writer {writer_num}: {word_count} words, content length: {len(content)}")
+                    else:
+                        logger.warning(f"Writer {writer_num} has empty content after cleaning")
+        
+        logger.info(f"Total writers collected: {writer_count}, Total words: {total_words}")
+        logger.info(f"Writer contents: {len(writer_contents)} entries")
         
         # 통계 페이지
         doc.add_heading('Novel Statistics', 1)
-        doc.add_paragraph(f'Total Writers: {writer_count}')
+        doc.add_paragraph(f'Mode: {"Test Mode (Actual chapters written)" if is_test_mode else "Full Mode (10 chapters)"}')
+        doc.add_paragraph(f'Total Chapters: {writer_count}')
         doc.add_paragraph(f'Total Words: {total_words:,}')
         doc.add_paragraph(f'Estimated Pages: ~{total_words/500:.0f}')
-        doc.add_paragraph(f'Language: {session["language"]}')
+        doc.add_paragraph(f'Language: {actual_language}')
         doc.add_page_break()
         
         # 목차
-        doc.add_heading('Table of Contents', 1)
-        for i in range(1, writer_count + 1):
-            doc.add_paragraph(f'Chapter {i}: Pages {(i-1)*3+1}-{i*3}')
-        doc.add_page_break()
-        
-        # 각 작가의 내용 추가
-        for writer_data in writer_contents:
-            writer_num = writer_data['writer_num']
-            content = writer_data['content']
-            word_count = writer_data['word_count']
-            
-            # 챕터 헤더
-            doc.add_heading(f'Chapter {writer_num}', 1)
-            doc.add_paragraph(f'Pages {(writer_num-1)*3+1}-{writer_num*3}')
-            doc.add_paragraph(f'Word Count: {word_count:,}')
-            doc.add_paragraph()
-            
-            # 작가 내용 추가
-            paragraphs = content.split('\n\n')
-            for para_text in paragraphs:
-                if para_text.strip():
-                    para = doc.add_paragraph(para_text.strip())
-                    para.style.font.size = Pt(11)
-            
-            if writer_num < writer_count:  # 마지막 작가 후에는 페이지 구분 없음
-                doc.add_page_break()
+        if writer_contents:
+            doc.add_heading('Table of Contents', 1)
+            # writer_contents를 writer_num으로 정렬
+            sorted_contents = sorted(writer_contents, key=lambda x: x['writer_num'])
+            
+            for item in sorted_contents:
+                chapter_num = item['writer_num']
+                doc.add_paragraph(f'Chapter {chapter_num}: Pages {(chapter_num-1)*3+1}-{chapter_num*3}')
+            doc.add_page_break()
+            
+            # 각 작가의 내용 추가 (정렬된 순서대로)
+            for idx, writer_data in enumerate(sorted_contents):
+                writer_num = writer_data['writer_num']
+                content = writer_data['content']
+                word_count = writer_data['word_count']
+                
+                # 챕터 헤더
+                doc.add_heading(f'Chapter {writer_num}', 1)
+                doc.add_paragraph(f'Pages {(writer_num-1)*3+1}-{writer_num*3}')
+                doc.add_paragraph(f'Word Count: {word_count:,}')
+                doc.add_paragraph()
+                
+                # 작가 내용 추가
+                paragraphs = content.split('\n\n')
+                for para_text in paragraphs:
+                    if para_text.strip():
+                        para = doc.add_paragraph(para_text.strip())
+                        para.style.font.size = Pt(11)
+                
+                if idx < len(sorted_contents) - 1:  # 마지막 챕터 후에는 페이지 구분 없음
+                    doc.add_page_break()
+        else:
+            logger.warning("No writer contents found! Creating empty document.")
+            doc.add_paragraph("No content found. Please check if the novel generation completed successfully.")
         
         # 페이지 설정
         for section in doc.sections:
@@ -1811,54 +2204,117 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         # Save
         temp_dir = tempfile.gettempdir()
         safe_filename = re.sub(r'[^\w\s-]', '', session['user_query'][:30]).strip()
-        filename = f"Novel_Complete_{safe_filename}_{timestamp}.docx"
+        mode_suffix = "_TestMode" if is_test_mode else "_Complete"
+        filename = f"Novel{mode_suffix}_{safe_filename}_{timestamp}.docx"
         filepath = os.path.join(temp_dir, filename)
         doc.save(filepath)
         
-        logger.info(f"DOCX saved successfully: {filepath} ({total_words} words)")
+        logger.info(f"DOCX saved successfully: {filepath} ({total_words} words, {writer_count} writers)")
         return filepath
     else:
-        # TXT format
+        # TXT format - 동일한 수정 적용
         temp_dir = tempfile.gettempdir()
         safe_filename = re.sub(r'[^\w\s-]', '', session['user_query'][:30]).strip()
-        filename = f"Novel_Complete_{safe_filename}_{timestamp}.txt"
+        mode_suffix = "_TestMode" if is_test_mode else "_Complete"
+        filename = f"Novel{mode_suffix}_{safe_filename}_{timestamp}.txt"
         filepath = os.path.join(temp_dir, filename)
         
         with open(filepath, 'w', encoding='utf-8') as f:
             f.write("="*60 + "\n")
-            f.write("AI COLLABORATIVE NOVEL - COMPLETE VERSION\n")
+            f.write(f"AI COLLABORATIVE NOVEL - {'TEST MODE' if is_test_mode else 'COMPLETE VERSION'}\n")
             f.write("="*60 + "\n")
             f.write(f"Theme: {session['user_query']}\n")
-            f.write(f"Language: {session['language']}\n")
+            f.write(f"Language: {actual_language}\n")
             f.write(f"Created: {datetime.now()}\n")
+            f.write(f"Mode: {'Test Mode (Actual chapters)' if is_test_mode else 'Full Mode (10 chapters)'}\n")
             f.write("="*60 + "\n\n")
             
             total_words = 0
             writer_count = 0
             
-            # 각 작가의 수정본만 출력
-            for stage in stages:
-                if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
-                    writer_count += 1
-                    content = stage['content'] or ""
-                    # 페이지 마크 제거
-                    content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
-                    content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
-                    content = content.strip()
+            if is_test_mode:
+                # 테스트 모드: writer1 + writer10 처리
+                for stage in stages:
+                    role = stage['role'] if 'role' in stage.keys() else None
+                    stage_name = stage['stage_name'] if 'stage_name' in stage.keys() else ''
+                    content = stage['content'] if 'content' in stage.keys() else ''
                     
-                    if content:
-                        word_count = stage['word_count'] or len(content.split())
-                        total_words += word_count
+                    # Writer 1 수정본
+                    if role == 'writer1' and stage_name and ('Revision' in stage_name or '수정본' in stage_name):
+                        content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
+                        content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
+                        content = content.strip()
+                        
+                        if content:
+                            word_count = stage['word_count'] if 'word_count' in stage.keys() else len(content.split())
+                            total_words += word_count
+                            writer_count = 1
+                            
+                            f.write(f"\n{'='*40}\n")
+                            f.write(f"CHAPTER 1 (Pages 1-3)\n")
+                            f.write(f"Word Count: {word_count:,}\n")
+                            f.write(f"{'='*40}\n\n")
+                            f.write(content)
+                            f.write("\n\n")
+                    
+                    # Writer 10
+                    elif role == 'writer10':
+                        # [Chapter X] 패턴으로 챕터 분리
+                        chapters = re.split(r'\[Chapter\s+(\d+)\]', content)
                         
-                        f.write(f"\n{'='*40}\n")
-                        f.write(f"CHAPTER {writer_count} (Pages {(writer_count-1)*3+1}-{writer_count*3})\n")
-                        f.write(f"Word Count: {word_count:,}\n")
-                        f.write(f"{'='*40}\n\n")
-                        f.write(content)
-                        f.write("\n\n")
+                        for i in range(1, len(chapters), 2):
+                            if i+1 < len(chapters):
+                                chapter_num = int(chapters[i])
+                                chapter_content = chapters[i+1].strip()
+                                
+                                if chapter_content:
+                                    word_count = len(chapter_content.split())
+                                    total_words += word_count
+                                    writer_count = max(writer_count, chapter_num)
+                                    
+                                    f.write(f"\n{'='*40}\n")
+                                    f.write(f"CHAPTER {chapter_num} (Pages {(chapter_num-1)*3+1}-{chapter_num*3})\n")
+                                    f.write(f"Word Count: {word_count:,}\n")
+                                    f.write(f"{'='*40}\n\n")
+                                    f.write(chapter_content)
+                                    f.write("\n\n")
+            else:
+                # 일반 모드 - 수정된 로직
+                for stage in stages:
+                    role = stage['role'] if 'role' in stage.keys() else None
+                    stage_name = stage['stage_name'] if 'stage_name' in stage.keys() else ''
+                    content = stage['content'] if 'content' in stage.keys() else ''
+                    
+                    # 언어에 상관없이 작가 수정본 찾기
+                    is_writer = role and role.startswith('writer')
+                    is_revision = stage_name and ('Revision' in stage_name or '수정본' in stage_name)
+                    
+                    if is_writer and is_revision:
+                        # 작가 번호 추출
+                        try:
+                            writer_num = int(role.replace('writer', ''))
+                        except:
+                            continue
+                        
+                        # 페이지 마크 제거
+                        content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
+                        content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
+                        content = content.strip()
+                        
+                        if content:
+                            word_count = stage['word_count'] if 'word_count' in stage.keys() else len(content.split())
+                            total_words += word_count
+                            writer_count += 1
+                            
+                            f.write(f"\n{'='*40}\n")
+                            f.write(f"CHAPTER {writer_num} (Pages {(writer_num-1)*3+1}-{writer_num*3})\n")
+                            f.write(f"Word Count: {word_count:,}\n")
+                            f.write(f"{'='*40}\n\n")
+                            f.write(content)
+                            f.write("\n\n")
             
             f.write(f"\n{'='*60}\n")
-            f.write(f"TOTAL: {writer_count} writers, {total_words:,} words\n")
+            f.write(f"TOTAL: {writer_count} chapters, {total_words:,} words\n")
             f.write(f"{'='*60}\n")
         
         logger.info(f"TXT saved successfully: {filepath} ({total_words} words)")
@@ -1950,7 +2406,8 @@ def create_interface():
                 <br><br>
                 <span class="search-indicator">🔍 Web search enabled</span> | 
                 <span class="auto-save-indicator">💾 Auto-save to database</span> | 
-                <span style="color: #FF9800;">♻️ Resume anytime</span>
+                <span style="color: #FF9800;">♻️ Resume anytime</span> |
+                <span style="color: #FFC107;">🧪 Test mode: 7 stages (Writer 1 + Writer 10)</span>
             </p>
         </div>
         """)
@@ -1973,6 +2430,13 @@ def create_interface():
                         label="Language / 언어"
                     )
                     
+                    # Test mode checkbox
+                    test_mode_check = gr.Checkbox(
+                        label="🧪 Test Mode (Quick: Writer 1 & 10 only) / 테스트 모드 (빠른 생성: 작가 1, 10만)",
+                        value=False,
+                        info="Complete Writer 1 & 10 process for 10 chapters / 작가 1, 10만 작성하여 10개 챕터 생성"
+                    )
+                    
                     # Web search status indicator
                     web_search_status = gr.Markdown(
                         value=f"🔍 **Web Search:** {'Enabled' if WebSearchIntegration().enabled else 'Disabled (Set BRAVE_SEARCH_API_KEY)'}"
@@ -2063,8 +2527,8 @@ def create_interface():
         # Connect event handlers
         submit_btn.click(
             fn=process_query,
-            inputs=[query_input, language_select, current_session_id],
-            outputs=[stages_display, novel_output, status_text]
+            inputs=[query_input, language_select, current_session_id, test_mode_check],
+            outputs=[stages_display, novel_output, status_text, current_session_id]
         )
         
         # Update novel text state and session ID when novel output changes
@@ -2080,8 +2544,8 @@ def create_interface():
             outputs=[current_session_id]
         ).then(
             fn=resume_session,
-            inputs=[current_session_id, language_select],
-            outputs=[stages_display, novel_output, status_text]
+            inputs=[current_session_id, language_select, test_mode_check],
+            outputs=[stages_display, novel_output, status_text, current_session_id]
         )
         
         auto_recover_btn.click(
@@ -2090,8 +2554,8 @@ def create_interface():
             outputs=[current_session_id]
         ).then(
             fn=resume_session,
-            inputs=[current_session_id, language_select],
-            outputs=[stages_display, novel_output, status_text]
+            inputs=[current_session_id, language_select, test_mode_check],
+            outputs=[stages_display, novel_output, status_text, current_session_id]
         )
         
         refresh_btn.click(
@@ -2100,18 +2564,24 @@ 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, False),
+            outputs=[stages_display, novel_output, status_text, novel_text_state, current_session_id, test_mode_check]
         )
         
         def handle_download(format_type, language, session_id, novel_text):
+            logger.info(f"Download requested: format={format_type}, session_id={session_id}, language={language}")
+            logger.info(f"Session ID type: {type(session_id)}, value: {repr(session_id)}")
+            
             if not session_id:
+                logger.error("No session_id available for download")
                 return gr.update(visible=False)
             
             file_path = download_novel(novel_text, format_type, language, session_id)
             if file_path:
+                logger.info(f"Download successful: {file_path}")
                 return gr.update(value=file_path, visible=True)
             else:
+                logger.error("Download failed - no file generated")
                 return gr.update(visible=False)
         
         download_btn.click(