Update app.py

app.py

@@ -441,52 +441,6 @@ class NovelDatabase:
         except:
             # Fallback to SQLite default format
             return datetime.strptime(datetime_str, "%Y-%m-%d %H:%M:%S")
-    
-    @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 평균
-            }
 
 class NovelWritingSystem:
     def __init__(self):
@@ -1024,149 +978,6 @@ Write a revision reflecting:
 Present the revised final version. Never use page markers.
 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"""전체 30페이지 소설을 최종 평가합니다.
-
-감독자의 마스터플랜:
-{director_plan}
-
-완성된 전체 소설 (미리보기):
-{content_preview}
-
-총 분량: {len(all_content.split())} 단어
-
-종합적인 평가와 최종 개선 제안을 제시하세요:
-
-1. **전체적 완성도 평가**
-   | 항목 | 점수(10점) | 평가 | 개선 필요 |
-   |------|-----------|------|----------|
-   | 플롯 일관성 | | | |
-   | 인물 발전 | | | |
-   | 주제 전달 | | | |
-   | 문체 통일성 | | | |
-   | 독자 몰입도 | | | |
-
-2. **강점 분석**
-   - 가장 효과적인 부분
-   - 뛰어난 장면이나 대화
-   - 성공적인 인물 묘사
-
-3. **약점 및 개선점**
-   - 전체적 흐름의 문제
-   - 미해결 플롯
-   - 캐릭터 일관성 이슈
-   - 페이싱 문제
-
-4. **파트별 연결성**
-   | 연결부 | 자연스러움 | 문제점 | 개선 제안 |
-   |--------|-----------|--------|----------|
-
-5. **최종 권고사항**
-   - 즉시 수정이 필요한 중대 오류
-   - 전체적 품질 향상을 위한 제안
-   - 출판 가능성 평가
-
-감독자가 최종 수정할 수 있도록 구체적이고 실행 가능한 피드백을 제공하세요."""
-        else:
-            return f"""Final evaluation of the complete 30-page novel.
-
-Director's Masterplan:
-{director_plan}
-
-Complete Novel (Preview):
-{content_preview}
-
-Total length: {len(all_content.split())} words
-
-Provide comprehensive evaluation and final improvement suggestions:
-
-1. **Overall Completion Assessment**
-   | Item | Score(10) | Evaluation | Improvement Needed |
-   |------|-----------|------------|-------------------|
-   | Plot Consistency | | | |
-   | Character Development | | | |
-   | Theme Delivery | | | |
-   | Style Unity | | | |
-   | Reader Engagement | | | |
-
-2. **Strength Analysis**
-   - Most effective parts
-   - Outstanding scenes or dialogue
-   - Successful character portrayal
-
-3. **Weaknesses and Improvements**
-   - Overall flow issues
-   - Unresolved plots
-   - Character consistency issues
-   - Pacing problems
-
-4. **Part Connectivity**
-   | Connection | Smoothness | Issues | Suggestions |
-   |------------|------------|--------|-------------|
-
-5. **Final Recommendations**
-   - Critical errors needing immediate fix
-   - Suggestions for overall quality improvement
-   - Publication readiness assessment
-
-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 - 메타데이터만 생성"""
-        word_count = len(all_content.split())
-        
-        # 전체 내용은 포함하지 않고 메타데이터만 요청
-        if language == "Korean":
-            return f"""감독자로서 비평가의 최종 평가를 반영하여 소설의 메타데이터를 작성합니다.
-
-총 단어 수: {word_count}단어
-
-비평가 최종 평가:
-{critic_final_feedback[:1000]}
-
-다음 정보만 간단히 제공하세요:
-
-# 소설 정보
-- 제목: [소설 제목]
-- 장르: [장르]
-- 주제: [핵심 주제]
-- 한 줄 요약: [간단한 요약]
-
-## 등장인물 소개
-[주요 인물 3-4명의 간단한 소개 - 각 2-3줄]
-
-## 작가의 말
-[작품에 대한 간단한 해설 - 5줄 이내]
-
-주의: 본문은 작성하지 마세요. 메타데이터만 제공하세요."""
-        else:
-            return f"""As director, create metadata for the final novel reflecting the critic's evaluation.
-
-Total word count: {word_count} words
-
-Critic's Final Evaluation:
-{critic_final_feedback[:1000]}
-
-Provide only the following information briefly:
-
-# Novel Information
-- Title: [Novel Title]
-- Genre: [Genre]
-- Theme: [Core Theme]
-- One-line summary: [Brief summary]
-
-## Character Introduction
-[Brief introduction of 3-4 main characters - 2-3 lines each]
-
-## Author's Note
-[Brief commentary about the work - within 5 lines]
-
-Note: Do not write the main text. Provide metadata only."""
-    
     def simulate_streaming(self, text: str, role: str) -> Generator[str, None, None]:
         """Simulate streaming in test mode"""
         words = text.split()
@@ -1223,10 +1034,6 @@ Note: Do not write the main text. Provide metadata only."""
                 max_tokens = 10000  # 충분한 토큰
                 temperature = 0.8   
                 top_p = 0.95       
-            elif role == "director" and ("최종" in str(messages) or "final" in str(messages)):
-                max_tokens = 30000  # 최종 통합을 위한 충분한 토큰
-                temperature = 0.6
-                top_p = 0.9
             else:
                 max_tokens = 8000
                 temperature = 0.6
@@ -1558,7 +1365,7 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
     def process_novel_stream(self, query: str, language: str = "English", 
                            session_id: Optional[str] = None, 
                            resume_from_stage: int = 0) -> Generator[Tuple[str, List[Dict[str, str]]], None, None]:
-        """Process novel writing with streaming updates and web search"""
+        """Process novel writing with streaming updates - 최종 Director/Critic 제거"""
         try:
             global conversation_history
             
@@ -1594,7 +1401,7 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                         "content": stage_data['content'] or ""
                     })
             
-            # Define all stages for 10 writers
+            # 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'}"),
@@ -1609,10 +1416,7 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                     (f"writer{writer_num}", f"✍️ {'작성자' if language == 'Korean' else 'Writer'} {writer_num}: {'수정본' if language == 'Korean' else 'Revision'}")
                 ])
             
-            stage_definitions.extend([
-                ("critic", f"📝 {'비평가: 최종 평가' if language == 'Korean' else 'Critic: Final Evaluation'}"),
-                ("director", f"🎬 {'감독자: 최종 완성본' if language == 'Korean' else 'Director: Final Version'}")
-            ])
+            # 최종 Director와 Critic 단계 제거
             
             # Store total stages for get_stage_prompt
             self.total_stages = len(stage_definitions)
@@ -1686,23 +1490,15 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                 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_metadata = stages[-1]["content"] if stages else ""
-            
             # Get complete novel from DB
             complete_novel = NovelDatabase.get_all_writer_content(self.current_session_id)
             
-            # Combine metadata and complete content for display
-            if final_novel_metadata and complete_novel:
-                final_novel = f"{final_novel_metadata}\n\n---\n\n## Complete Novel\n\n{complete_novel}"
-            else:
-                final_novel = complete_novel or final_novel_metadata
-            
             # Save final novel to DB
             NovelDatabase.update_final_novel(self.current_session_id, complete_novel)
             
-            # Final yield
-            yield final_novel, stages
+            # Final yield - 화면에는 완료 메시지만 표시
+            final_message = f"✅ Novel complete! {len(complete_novel.split())} words total. Click Download to save."
+            yield final_message, stages
             
         except Exception as e:
             logger.error(f"Error in process_novel_stream: {str(e)}", exc_info=True)
@@ -1763,43 +1559,24 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                     language
                 )
         
-        # Critic stages
+        # Critic stages for writers
         elif role == "critic":
             final_plan = stages[2]["content"]
             
-            # Final evaluation
-            if "최종" in stages[stage_idx]["name"] or "Final" in stages[stage_idx]["name"]:
-                # Get all writer content from DB
-                all_writer_content = NovelDatabase.get_all_writer_content(self.current_session_id)
-                logger.info(f"Final evaluation with {len(all_writer_content)} characters of content")
-                return self.create_critic_final_prompt(all_writer_content, final_plan, language)
-            
             # Writer review
-            else:
-                # Find which writer we're reviewing
-                for i in range(1, 11):
-                    if f"작성자 {i}" in stages[stage_idx]["name"] or f"Writer {i}" in stages[stage_idx]["name"]:
-                        writer_content_idx = stage_idx - 1
-                        # Get previous writers' content from DB
-                        previous_content = NovelDatabase.get_all_writer_content(self.current_session_id)
-                        return self.create_critic_writer_prompt(
-                            i,
-                            stages[writer_content_idx]["content"],
-                            final_plan,
-                            previous_content,
-                            language
-                        )
-        
-        # Director final - DB에서 모든 작가 내용 가져오기
-        elif stage_idx == self.total_stages - 1:
-            critic_final_idx = stage_idx - 1
-            all_writer_content = NovelDatabase.get_all_writer_content(self.current_session_id)
-            logger.info(f"Final director compilation with {len(all_writer_content)} characters of content")
-            return self.create_director_final_prompt(
-                all_writer_content,
-                stages[critic_final_idx]["content"],
-                language
-            )
+            # Find which writer we're reviewing
+            for i in range(1, 11):
+                if f"작성자 {i}" in stages[stage_idx]["name"] or f"Writer {i}" in stages[stage_idx]["name"]:
+                    writer_content_idx = stage_idx - 1
+                    # Get previous writers' content from DB
+                    previous_content = NovelDatabase.get_all_writer_content(self.current_session_id)
+                    return self.create_critic_writer_prompt(
+                        i,
+                        stages[writer_content_idx]["content"],
+                        final_plan,
+                        previous_content,
+                        language
+                    )
         
         return ""
 
@@ -1833,13 +1610,13 @@ 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 not final_novel:
+            if "✅ Novel complete!" in str(final_novel):
+                status = "✅ Complete! Ready to download."
+            else:
                 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, recovery_status
                     
@@ -1889,165 +1666,6 @@ def get_active_sessions(language: str) -> List[Tuple[str, str]]:
         logger.error(f"Error getting active sessions: {str(e)}", exc_info=True)
         return []
 
-def get_chapter_content(session_id: str, chapter: str) -> str:
-    """Get content of a specific chapter"""
-    if not session_id or not chapter:
-        return "No session or chapter selected"
-    
-    try:
-        chapter_num = int(chapter.split()[-1])
-        
-        with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            # Get the writer's revision (final version)
-            cursor.execute('''
-                SELECT content, word_count, updated_at 
-                FROM stages 
-                WHERE session_id = ? 
-                AND role = ? 
-                AND stage_name LIKE '%Revision%'
-                ORDER BY stage_number DESC 
-                LIMIT 1
-            ''', (session_id, f'writer{chapter_num}'))
-            
-            row = cursor.fetchone()
-            if row and row['content']:
-                content = row['content']
-                word_count = row['word_count'] or len(content.split())
-                updated = row['updated_at']
-                
-                # 페이지 마크 제거
-                content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
-                content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
-                
-                return f"""## Chapter {chapter_num} (Pages {(chapter_num-1)*3+1}-{chapter_num*3})
-                
-**Word Count:** {word_count:,} words  
-**Last Updated:** {updated}
-
----
-
-{content}"""
-            else:
-                return f"Chapter {chapter_num} not found or not yet written"
-    except Exception as e:
-        logger.error(f"Error getting chapter content: {str(e)}")
-        return f"Error: {str(e)}"
-
-def get_db_sessions_detailed() -> List[Tuple[str, str]]:
-    """Get detailed list of all sessions for DB explorer"""
-    try:
-        with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                SELECT 
-                    s.session_id, 
-                    s.user_query, 
-                    s.language, 
-                    s.created_at, 
-                    s.updated_at,
-                    s.status,
-                    s.current_stage,
-                    COUNT(st.id) as total_stages,
-                    SUM(CASE WHEN st.status = 'complete' THEN 1 ELSE 0 END) as completed_stages
-                FROM sessions s
-                LEFT JOIN stages st ON s.session_id = st.session_id
-                GROUP BY s.session_id
-                ORDER BY s.updated_at DESC
-            ''')
-            
-            sessions = cursor.fetchall()
-            
-            choices = []
-            for session in sessions:
-                created = NovelDatabase.parse_datetime(session['created_at'])
-                updated = NovelDatabase.parse_datetime(session['updated_at'])
-                query_preview = session['user_query'][:40] + "..." if len(session['user_query']) > 40 else session['user_query']
-                
-                label = (f"[{session['status'].upper()}] {query_preview} | "
-                        f"Created: {created.strftime('%Y-%m-%d %H:%M')} | "
-                        f"Progress: {session['completed_stages']}/{session['total_stages']}")
-                
-                choices.append((label, session['session_id']))
-            
-            return choices
-    except Exception as e:
-        logger.error(f"Error getting detailed sessions: {str(e)}")
-        return []
-
-def get_session_details(session_id: str) -> str:
-    """Get detailed information about a session"""
-    if not session_id:
-        return "No session selected"
-    
-    try:
-        session = NovelDatabase.get_session(session_id)
-        if not session:
-            return "Session not found"
-        
-        # Get stages information
-        stages = NovelDatabase.get_stages(session_id)
-        
-        # Calculate statistics
-        total_words = 0
-        completed_writers = 0
-        writer_stats = []
-        
-        for stage in stages:
-            if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
-                completed_writers += 1
-                word_count = stage['word_count'] or 0
-                total_words += word_count
-                writer_num = int(stage['role'].replace('writer', ''))
-                writer_stats.append(f"- Writer {writer_num}: {word_count:,} words")
-        
-        # Build detailed info
-        info = f"""# Session Details
-
-**Session ID:** `{session_id}`  
-**Theme:** {session['user_query']}  
-**Language:** {session['language']}  
-**Status:** {session['status']}  
-**Created:** {session['created_at']}  
-**Last Updated:** {session['updated_at']}  
-
-## Progress
-- **Current Stage:** {session['current_stage']}
-- **Completed Writers:** {completed_writers}/10
-- **Total Words:** {total_words:,}
-- **Estimated Pages:** ~{total_words/500:.0f}
-
-## Writer Statistics
-{"".join(writer_stats) if writer_stats else "No writers completed yet"}
-
-## Search History
-"""
-        
-        # Add search history
-        with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                SELECT role, query, created_at
-                FROM search_history
-                WHERE session_id = ?
-                ORDER BY created_at DESC
-                LIMIT 10
-            ''', (session_id,))
-            
-            searches = cursor.fetchall()
-            if searches:
-                info += "\nRecent searches:\n"
-                for search in searches:
-                    info += f"- [{search['role']}] {search['query']} ({search['created_at']})\n"
-            else:
-                info += "\nNo search history available."
-        
-        return info
-        
-    except Exception as e:
-        logger.error(f"Error getting session details: {str(e)}")
-        return f"Error: {str(e)}"
-
 def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str, str], None, None]:
     """Resume an existing session"""
     if not session_id:
@@ -2088,100 +1706,98 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         logger.error(f"Session not found: {session_id}")
         return None
     
-    # 모든 작가의 최종본 가져오기
-    all_writer_content = NovelDatabase.get_all_writer_content(session_id)
-    
-    # 최종 감독자의 메타데이터 가져오기
-    metadata = ""
-    with NovelDatabase.get_db() as conn:
-        cursor = conn.cursor()
-        cursor.execute('''
-            SELECT content FROM stages 
-            WHERE session_id = ? AND role = 'director' AND stage_name LIKE '%Final%'
-            ORDER BY stage_number DESC LIMIT 1
-        ''', (session_id,))
-        row = cursor.fetchone()
-        if row and row['content']:
-            metadata = row['content']
+    # DB에서 모든 스테이지 가져오기
+    stages = NovelDatabase.get_stages(session_id)
     
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     
-    # 통계 정보
-    word_count = len(all_writer_content.split())
-    char_count = len(all_writer_content)
-    
-    logger.info(f"Exporting novel: {word_count} words, {char_count} characters from DB")
-    
     if format == "DOCX" and DOCX_AVAILABLE:
         # Create DOCX
         doc = Document()
         
-        # 메타데이터 추가 (있는 경우)
-        if metadata:
-            # 메타데이터 파싱 및 추가
-            lines = metadata.split('\n')
-            for line in lines:
-                if line.startswith('#'):
-                    level = len(line.split()[0].strip('#'))
-                    text = line.lstrip('#').strip()
-                    if text and level <= 2:  # 제목과 주요 섹션만
-                        doc.add_heading(text, level)
-                elif line.strip() and not line.startswith('['):
-                    doc.add_paragraph(line)
-            
-            doc.add_page_break()
-        else:
-            # 기본 제목
-            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_page_break()
+        # 제목 페이지
+        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_heading('Novel Statistics', 1)
-        doc.add_paragraph(f'Total Writers: 10')
-        doc.add_paragraph(f'Total Words: {word_count:,}')
-        doc.add_paragraph(f'Total Pages: ~{word_count/500:.0f}')
-        doc.add_paragraph(f'Export Date: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}')
-        doc.add_paragraph(f'Session ID: {session_id[:8]}...')
-        doc.add_page_break()
+        doc.add_paragraph()
+        doc.add_paragraph()
+        
+        theme_para = doc.add_paragraph()
+        theme_run = theme_para.add_run(f'Theme: {session["user_query"]}')
+        theme_run.font.size = Pt(14)
+        theme_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        
+        doc.add_paragraph()
+        
+        date_para = doc.add_paragraph()
+        date_run = date_para.add_run(f'Created: {datetime.now().strftime("%Y-%m-%d")}')
+        date_run.font.size = Pt(12)
+        date_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
         
-        # 목차
-        doc.add_heading('Table of Contents', 1)
-        for i in range(1, 11):
-            doc.add_paragraph(f'Chapter {i}: Pages {(i-1)*3+1}-{i*3}')
         doc.add_page_break()
         
-        # 각 작가의 최종본 추가
-        stages = NovelDatabase.get_stages(session_id)
-        writer_num = 0
+        # 전체 통계
+        total_words = 0
+        writer_count = 0
         
+        # 각 작가의 수정본만 수집
+        writer_contents = []
         for stage in stages:
             if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
-                writer_num += 1
-                
-                # 챕터 헤더
-                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: {stage["word_count"] or "N/A"}')
-                doc.add_paragraph()
-                
-                # 작가 내용
+                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()
                 
-                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:  # 마지막 작가 후에는 페이지 구분 없음
-                    doc.add_page_break()
+                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
+                    })
+        
+        # 통계 페이지
+        doc.add_heading('Novel Statistics', 1)
+        doc.add_paragraph(f'Total Writers: {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_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()
         
         # 페이지 설정
         for section in doc.sections:
@@ -2194,16 +1810,18 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
         
         # Save
         temp_dir = tempfile.gettempdir()
-        filename = f"Novel_Complete_{session['user_query'][:20].replace(' ', '_')}_{timestamp}.docx"
+        safe_filename = re.sub(r'[^\w\s-]', '', session['user_query'][:30]).strip()
+        filename = f"Novel_Complete_{safe_filename}_{timestamp}.docx"
         filepath = os.path.join(temp_dir, filename)
         doc.save(filepath)
         
-        logger.info(f"DOCX saved successfully: {filepath}")
+        logger.info(f"DOCX saved successfully: {filepath} ({total_words} words)")
         return filepath
     else:
         # TXT format
         temp_dir = tempfile.gettempdir()
-        filename = f"Novel_Complete_{session['user_query'][:20].replace(' ', '_')}_{timestamp}.txt"
+        safe_filename = re.sub(r'[^\w\s-]', '', session['user_query'][:30]).strip()
+        filename = f"Novel_Complete_{safe_filename}_{timestamp}.txt"
         filepath = os.path.join(temp_dir, filename)
         
         with open(filepath, 'w', encoding='utf-8') as f:
@@ -2211,40 +1829,39 @@ def download_novel(novel_text: str, format: str, language: str, session_id: str
             f.write("AI COLLABORATIVE NOVEL - COMPLETE VERSION\n")
             f.write("="*60 + "\n")
             f.write(f"Theme: {session['user_query']}\n")
-            f.write(f"Total Writers: 10\n")
-            f.write(f"Total Words: {word_count:,}\n")
-            f.write(f"Total Pages: ~{word_count/500:.0f}\n")
-            f.write(f"Export Date: {datetime.now()}\n")
-            f.write(f"Session ID: {session_id}\n")
+            f.write(f"Language: {session['language']}\n")
+            f.write(f"Created: {datetime.now()}\n")
             f.write("="*60 + "\n\n")
             
-            # 메타데이터 추가
-            if metadata:
-                f.write("=== METADATA ===\n")
-                f.write(metadata)
-                f.write("\n\n" + "="*60 + "\n\n")
-            
-            # 각 작가의 최종본
-            stages = NovelDatabase.get_stages(session_id)
-            writer_num = 0
+            total_words = 0
+            writer_count = 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"CHAPTER {writer_num} (Pages {(writer_num-1)*3+1}-{writer_num*3})\n")
-                    f.write(f"Word Count: {stage['word_count'] or 'N/A'}\n")
-                    f.write(f"{'='*40}\n\n")
-                    
+                    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()
                     
-                    f.write(content)
-                    f.write("\n\n")
-        
-        logger.info(f"TXT saved successfully: {filepath}")
+                    if content:
+                        word_count = stage['word_count'] or len(content.split())
+                        total_words += word_count
+                        
+                        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")
+            
+            f.write(f"\n{'='*60}\n")
+            f.write(f"TOTAL: {writer_count} writers, {total_words:,} words\n")
+            f.write(f"{'='*60}\n")
+        
+        logger.info(f"TXT saved successfully: {filepath} ({total_words} words)")
         return filepath
 
 # Custom CSS
@@ -2294,21 +1911,10 @@ custom_css = """
     padding: 30px;
     border-radius: 12px;
     box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
-    max-height: 800px;
+    max-height: 400px;
     overflow-y: auto;
 }
 
-#chapter-content {
-    background-color: rgba(255, 255, 255, 0.95);
-    padding: 30px;
-    border-radius: 12px;
-    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
-    max-height: 800px;
-    overflow-y: auto;
-    font-family: Georgia, serif;
-    line-height: 1.8;
-}
-
 .download-section {
     background-color: rgba(255, 255, 255, 0.9);
     padding: 15px;
@@ -2339,12 +1945,12 @@ def create_interface():
                 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 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.
+                Enter a theme or prompt, and watch as AI agents collaborate to create a complete 30-page novella.
+                The system includes 1 Director, 1 Critic, and 10 Writers 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>
+                <span class="auto-save-indicator">💾 Auto-save to database</span> | 
+                <span style="color: #FF9800;">♻️ Resume anytime</span>
             </p>
         </div>
         """)
@@ -2404,7 +2010,7 @@ def create_interface():
             
             with gr.Tab("📖 Final Novel / 최종 소설"):
                 novel_output = gr.Markdown(
-                    value="",
+                    value="Complete novel will be available for download after all writers finish.",
                     elem_id="novel-output"
                 )
                 
@@ -2416,42 +2022,12 @@ def create_interface():
                             value="DOCX" if DOCX_AVAILABLE else "TXT",
                             label="Format / 형식"
                         )
-                        download_btn = gr.Button("⬇️ Download All 10 Writers / 10명 작가 전체 다운로드", variant="secondary")
+                        download_btn = gr.Button("⬇️ Download Complete Novel / 완성된 소설 다운로드", variant="secondary")
                     
                     download_file = gr.File(
                         label="Downloaded File / 다운로드된 파일",
                         visible=False
                     )
-            
-            with gr.Tab("📑 Chapter View / 챕터별 보기"):
-                chapter_select = gr.Dropdown(
-                    label="Select Chapter / 챕터 선택",
-                    choices=[f"Chapter {i}" for i in range(1, 11)],
-                    value="Chapter 1"
-                )
-                chapter_content = gr.Markdown(
-                    value="Select a chapter to view its content / 챕터를 선택하여 내용을 확인하세요",
-                    elem_id="chapter-content"
-                )
-                
-            with gr.Tab("🔍 Database Explorer / DB 탐색"):
-                with gr.Row():
-                    db_session_select = gr.Dropdown(
-                        label="Select Session / 세션 선택",
-                        choices=[],
-                        interactive=True
-                    )
-                    db_refresh_btn = gr.Button("🔄 Refresh / 새로고침")
-                
-                db_info = gr.Markdown(
-                    value="Select a session to view details / 세션을 선택하여 상세 정보를 확인하세요"
-                )
-                
-                db_export_btn = gr.Button("📤 Export Selected Session / 선택된 세션 내보내기", visible=False)
-                db_export_file = gr.File(
-                    label="Exported File / 내보낸 파일",
-                    visible=False
-                )
         
         # Hidden state for novel text
         novel_text_state = gr.State("")
@@ -2484,29 +2060,6 @@ def create_interface():
             session_id, message = auto_recover_session(language)
             return session_id
         
-        def update_chapter_content(chapter, session_id):
-            if session_id:
-                return get_chapter_content(session_id, chapter)
-            else:
-                return "Please complete or select a session first / 먼저 세션을 완료하거나 선택하세요"
-        
-        def refresh_db_sessions():
-            sessions = get_db_sessions_detailed()
-            return gr.update(choices=sessions)
-        
-        def show_session_details(session_id):
-            if session_id:
-                return get_session_details(session_id), gr.update(visible=True)
-            else:
-                return "Select a session to view details", gr.update(visible=False)
-        
-        def export_db_session(session_id, format_type):
-            if session_id:
-                file_path = download_novel("", format_type, "English", session_id)
-                if file_path:
-                    return gr.update(value=file_path, visible=True)
-            return gr.update(visible=False)
-        
         # Connect event handlers
         submit_btn.click(
             fn=process_query,
@@ -2514,7 +2067,7 @@ def create_interface():
             outputs=[stages_display, novel_output, status_text]
         )
         
-        # Update novel text state and chapter dropdown when novel output changes
+        # Update novel text state and session ID when novel output changes
         novel_output.change(
             fn=lambda x: x,
             inputs=[novel_output],
@@ -2567,47 +2120,14 @@ def create_interface():
             outputs=[download_file]
         )
         
-        # Chapter view handlers
-        chapter_select.change(
-            fn=update_chapter_content,
-            inputs=[chapter_select, current_session_id],
-            outputs=[chapter_content]
-        )
-        
-        # Update chapter content when session changes
-        current_session_id.change(
-            fn=update_chapter_content,
-            inputs=[chapter_select, current_session_id],
-            outputs=[chapter_content]
-        )
-        
-        # DB Explorer handlers
-        db_refresh_btn.click(
-            fn=refresh_db_sessions,
-            outputs=[db_session_select]
-        )
-        
-        db_session_select.change(
-            fn=show_session_details,
-            inputs=[db_session_select],
-            outputs=[db_info, db_export_btn]
-        )
-        
-        db_export_btn.click(
-            fn=lambda session_id: export_db_session(session_id, "DOCX"),
-            inputs=[db_session_select],
-            outputs=[db_export_file]
-        )
-        
         # Load sessions on startup
         def on_load():
             sessions = refresh_sessions()
-            db_sessions = refresh_db_sessions()
-            return sessions, db_sessions
+            return sessions
         
         interface.load(
             fn=on_load,
-            outputs=[session_dropdown, db_session_select]
+            outputs=[session_dropdown]
         )
     
     return interface