Update app-backup.py

app-backup.py

@@ -16,11 +16,11 @@ from contextlib import contextmanager
 from dataclasses import dataclass, field
 from collections import defaultdict
 
-# 로깅 설정
-logging.basicConfig(level=logging.INFO)
+# --- 로깅 설정 ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Document export imports
+# --- Document export imports ---
 try:
     from docx import Document
     from docx.shared import Inches, Pt, RGBColor
@@ -31,46 +31,44 @@ except ImportError:
     DOCX_AVAILABLE = False
     logger.warning("python-docx not installed. DOCX export will be disabled.")
 
-# 환경 변수에서 토큰 가져오기
+# --- 환경 변수 및 상수 ---
 FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN", "")
 BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
 API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"
 MODEL_ID = "dep89a2fld32mcm"
+DB_PATH = "novel_sessions_v2.db"
 
-# 환경 변수 검증
+# --- 환경 변수 검증 ---
 if not FRIENDLI_TOKEN:
     logger.error("FRIENDLI_TOKEN not set. Application will not work properly.")
-    FRIENDLI_TOKEN = "dummy_token"
+    # 실제 환경에서는 여기서 프로그램을 종료해야 하지만, 데모를 위해 더미 토큰을 사용합니다.
+    FRIENDLI_TOKEN = "dummy_token_for_testing"
 
 if not BRAVE_SEARCH_API_KEY:
     logger.warning("BRAVE_SEARCH_API_KEY not set. Web search features will be disabled.")
 
-# 전역 변수
-conversation_history = []
-selected_language = "English"
-
-# DB 경로
-DB_PATH = "novel_sessions.db"
+# --- 전역 변수 ---
 db_lock = threading.Lock()
 
-# 최적화된 단계 구성 (30단계)
+# 최적화된 단계 구성 (25단계로 압축 및 강화)
 OPTIMIZED_STAGES = [
-    ("director", "🎬 감독자: 초기 기획"),
-    ("critic", "📝 비평가: 기획 검토"),
+    ("director", "🎬 감독자: 초기 기획 (웹 검색 포함)"),
+    ("critic", "📝 비평가: 기획 검토 (테마 및 일관성)"),
     ("director", "🎬 감독자: 수정된 마스터플랜"),
 ] + [
     (f"writer{i}", f"✍️ 작가 {i}: 초안 (페이지 {(i-1)*3+1}-{i*3})")
     for i in range(1, 11)
 ] + [
-    ("critic", f"📝 비평가: 일관성 검토"),
+    ("critic", "📝 비평가: 중간 검토 (일관성 및 테마 유지)"),
 ] + [
     (f"writer{i}", f"✍️ 작가 {i}: 수정본 (페이지 {(i-1)*3+1}-{i*3})")
     for i in range(1, 11)
 ] + [
-    ("critic", f"📝 비평가: 최종 검토"),
+    ("critic", f"📝 비평가: 최종 검토 및 종합 보고서 작성"),
 ]
 
 
+# --- 데이터 클래스 ---
 @dataclass
 class CharacterState:
     """캐릭터의 현재 상태를 나타내는 데이터 클래스"""
@@ -84,7 +82,6 @@ class CharacterState:
     description: str = ""
     role: str = ""
 
-
 @dataclass
 class PlotPoint:
     """플롯 포인트를 나타내는 데이터 클래스"""
@@ -95,7 +92,6 @@ class PlotPoint:
     impact_level: int
     timestamp: str = ""
 
-
 @dataclass
 class TimelineEvent:
     """시간선 이벤트를 나타내는 데이터 클래스"""
@@ -106,274 +102,153 @@ class TimelineEvent:
     relative_time: str = ""
 
 
+# --- 핵심 로직 클래스 ---
 class ConsistencyTracker:
     """일관성 추적 시스템"""
-    
     def __init__(self):
         self.character_states: Dict[str, CharacterState] = {}
         self.plot_points: List[PlotPoint] = []
         self.timeline_events: List[TimelineEvent] = []
         self.locations: Dict[str, str] = {}
         self.established_facts: List[str] = []
-        self.content_hashes: set = set()
-        
+        self.content_hashes: Dict[str, int] = {}  # 해시와 해당 챕터 번호를 저장
+
     def register_character(self, character: CharacterState):
         """새 캐릭터 등록"""
         self.character_states[character.name] = character
         logger.info(f"Character registered: {character.name}")
-        
+
     def update_character_state(self, name: str, chapter: int, updates: Dict[str, Any]):
         """캐릭터 상태 업데이트"""
         if name not in self.character_states:
             self.register_character(CharacterState(name=name, last_seen_chapter=chapter))
-            
         char = self.character_states[name]
         for key, value in updates.items():
             if hasattr(char, key):
                 setattr(char, key, value)
-        
         char.last_seen_chapter = chapter
-        
+
     def add_plot_point(self, plot_point: PlotPoint):
         """플롯 포인트 추가"""
         plot_point.timestamp = datetime.now().isoformat()
         self.plot_points.append(plot_point)
-        
-    def add_timeline_event(self, event: TimelineEvent):
-        """시간선 이벤트 추가"""
-        self.timeline_events.append(event)
-        
-    def check_repetition(self, content: str) -> Tuple[bool, str]:
-        """반복 내용 검사"""
-        # 내용 해시 생성
-        content_hash = hashlib.md5(content.encode()).hexdigest()
-        
-        if content_hash in self.content_hashes:
-            return True, "완전 동일한 내용 반복"
-            
-        # 문장 수준 반복 검사
+
+    def check_repetition(self, content: str, current_chapter: int) -> Tuple[bool, str]:
+        """향상된 반복 내용 검사"""
         sentences = re.split(r'[.!?]+', content)
         for sentence in sentences:
-            if len(sentence.strip()) > 20:
-                sentence_hash = hashlib.md5(sentence.strip().encode()).hexdigest()
+            sentence_strip = sentence.strip()
+            if len(sentence_strip) > 20:  # 너무 짧은 문장은 무시
+                sentence_hash = hashlib.md5(sentence_strip.encode('utf-8')).hexdigest()
                 if sentence_hash in self.content_hashes:
-                    return True, f"문장 반복: {sentence.strip()[:50]}..."
-        
-        # 해시 저장
-        self.content_hashes.add(content_hash)
+                    previous_chapter = self.content_hashes[sentence_hash]
+                    # 바로 이전 챕터와의 반복은 허용할 수 있으므로, 2챕터 이상 차이날 때만 오류로 간주
+                    if current_chapter > previous_chapter + 1:
+                        return True, f"문장 반복 (챕터 {previous_chapter}과 유사): {sentence_strip[:50]}..."
+        # 새 내용의 해시 추가
         for sentence in sentences:
-            if len(sentence.strip()) > 20:
-                sentence_hash = hashlib.md5(sentence.strip().encode()).hexdigest()
-                self.content_hashes.add(sentence_hash)
-        
+            sentence_strip = sentence.strip()
+            if len(sentence_strip) > 20:
+                sentence_hash = hashlib.md5(sentence_strip.encode('utf-8')).hexdigest()
+                self.content_hashes[sentence_hash] = current_chapter
         return False, ""
-        
+
     def validate_consistency(self, chapter: int, content: str) -> List[str]:
         """일관성 검증"""
         errors = []
-        
-        # 캐릭터 일관성 검사
+        # 사망한 캐릭터 등장 검사
         for char_name, char_state in self.character_states.items():
-            if char_name.lower() in content.lower():
-                # 사망한 캐릭터 등장 검사
-                if not char_state.alive:
-                    errors.append(f"⚠️ 사망한 캐릭터 '{char_name}'이 등장함")
-                
-                # 부상 상태 연속성 검사
-                if char_state.injuries and "완전히 회복" not in content:
-                    recent_injuries = [inj for inj in char_state.injuries if "중상" in inj or "심각" in inj]
-                    if recent_injuries:
-                        errors.append(f"⚠️ '{char_name}'의 부상 상태가 언급되지 않음")
-        
-        # 반복 검사
-        is_repetition, repeat_msg = self.check_repetition(content)
+            if char_name.lower() in content.lower() and not char_state.alive:
+                errors.append(f"⚠️ 사망한 캐릭터 '{char_name}'이(가) 등장했습니다.")
+        # 내용 반복 검사
+        is_repetition, repeat_msg = self.check_repetition(content, chapter)
         if is_repetition:
             errors.append(f"🔄 {repeat_msg}")
-        
-        # 시간선 일관성 검사
-        time_references = re.findall(r'(어제|오늘|내일|지금|방금|곧|나중에|이전에|다음에)', content)
-        if time_references:
-            # 최근 시간 참조와 비교
-            recent_events = [e for e in self.timeline_events if e.chapter >= chapter - 1]
-            if recent_events and time_references:
-                # 간단한 시간 일관성 검사
-                pass  # 복잡한 로직은 생략
-        
         return errors
-    
+
     def get_character_summary(self, chapter: int) -> str:
         """현재 챕터 기준 캐릭터 요약"""
-        summary = "\n=== 캐릭터 현황 ===\n"
-        
-        active_chars = [char for char in self.character_states.values() 
-                       if char.last_seen_chapter >= chapter - 2]
-        
+        summary = "\n=== 캐릭터 현황 요약 (이전 2개 챕터 기준) ===\n"
+        active_chars = [char for char in self.character_states.values() if char.last_seen_chapter >= chapter - 2]
+        if not active_chars:
+            return "\n(아직 주요 캐릭터 정보가 없습니다.)\n"
         for char in active_chars:
             status = "생존" if char.alive else "사망"
             summary += f"• {char.name}: {status}"
-            if char.alive:
-                if char.location:
-                    summary += f" (위치: {char.location})"
-                if char.injuries:
-                    summary += f" (부상: {', '.join(char.injuries[-1:])})"
+            if char.alive and char.location: summary += f" (위치: {char.location})"
+            if char.injuries: summary += f" (부상: {', '.join(char.injuries[-1:])})"
             summary += "\n"
-            
         return summary
-    
+
     def get_plot_summary(self, chapter: int) -> str:
         """플롯 요약"""
-        summary = "\n=== 주요 사건 ===\n"
-        
+        summary = "\n=== 최근 주요 사건 요약 ===\n"
         recent_events = [p for p in self.plot_points if p.chapter >= chapter - 2]
-        for event in recent_events[-5:]:
-            summary += f"• 챕터 {event.chapter}: {event.description}\n"
-            
+        if not recent_events:
+            return "\n(아직 주요 사건이 없습니다.)\n"
+        for event in recent_events[-3:]: # 최근 3개만 표시
+            summary += f"• [챕터 {event.chapter}] {event.description}\n"
         return summary
 
 
-class ConsistencyValidator:
-    """일관성 검증 시스템"""
-    
-    def __init__(self, consistency_tracker: ConsistencyTracker):
-        self.tracker = consistency_tracker
-        
-    def validate_writer_content(self, writer_num: int, content: str, 
-                              all_previous_content: str) -> List[str]:
-        """작가 내용 일관성 검증"""
-        errors = []
-        
-        # 기본 일관성 검증
-        basic_errors = self.tracker.validate_consistency(writer_num, content)
-        errors.extend(basic_errors)
-        
-        # 캐릭터 추출 및 상태 업데이트
-        characters = self.extract_characters(content)
-        for char_name in characters:
-            self.tracker.update_character_state(char_name, writer_num, {})
-            
-        # 새로운 사실 추출
-        new_facts = self.extract_facts(content)
-        for fact in new_facts:
-            if fact not in self.tracker.established_facts:
-                self.tracker.established_facts.append(fact)
-        
-        return errors
-    
-    def extract_characters(self, content: str) -> List[str]:
-        """캐릭터 이름 추출"""
-        # 간단한 캐릭터 추출 로직
-        potential_names = re.findall(r'\b[A-Z][a-z]+\b', content)
-        # 일반적인 단어 제외
-        common_words = {'The', 'This', 'That', 'They', 'Then', 'There', 'When', 'Where', 'What', 'Who', 'How', 'Why'}
-        characters = [name for name in potential_names if name not in common_words]
-        return list(set(characters))
-    
-    def extract_facts(self, content: str) -> List[str]:
-        """확립된 사실 추출"""
-        # 간단한 사실 추출 로직
-        sentences = re.split(r'[.!?]+', content)
-        facts = []
-        
-        for sentence in sentences:
-            sentence = sentence.strip()
-            if len(sentence) > 10:
-                # 확정적인 표현이 있는 문장들
-                definitive_patterns = [
-                    r'.*is.*',
-                    r'.*was.*',
-                    r'.*has.*',
-                    r'.*had.*',
-                    r'.*died.*',
-                    r'.*killed.*',
-                    r'.*destroyed.*',
-                    r'.*created.*'
-                ]
-                
-                for pattern in definitive_patterns:
-                    if re.match(pattern, sentence, re.IGNORECASE):
-                        facts.append(sentence)
-                        break
-        
-        return facts
-
-
 class WebSearchIntegration:
     """웹 검색 기능 (감독자 단계에서만 사용)"""
-    
     def __init__(self):
         self.brave_api_key = BRAVE_SEARCH_API_KEY
         self.search_url = "https://api.search.brave.com/res/v1/web/search"
         self.enabled = bool(self.brave_api_key)
-        
+
     def search(self, query: str, count: int = 3, language: str = "en") -> List[Dict]:
         """웹 검색 수행"""
         if not self.enabled:
             return []
-            
         headers = {
             "Accept": "application/json",
             "X-Subscription-Token": self.brave_api_key
         }
-        
-        search_lang = "ko" if language == "Korean" else "en"
-        
         params = {
             "q": query,
             "count": count,
-            "search_lang": search_lang,
+            "search_lang": "ko" if language == "Korean" else "en",
             "text_decorations": False,
             "safesearch": "moderate"
         }
-        
         try:
             response = requests.get(self.search_url, headers=headers, params=params, timeout=10)
-            if response.status_code == 200:
-                results = response.json()
-                web_results = results.get("web", {}).get("results", [])
-                logger.info(f"Search successful: Found {len(web_results)} results for '{query}'")
-                return web_results
-            else:
-                logger.error(f"Search API error: {response.status_code}")
-                return []
-        except Exception as e:
-            logger.error(f"Search error: {str(e)}")
+            response.raise_for_status()
+            results = response.json().get("web", {}).get("results", [])
+            logger.info(f"웹 검색 성공: '{query}'에 대해 {len(results)}개 결과 발견")
+            return results
+        except requests.exceptions.RequestException as e:
+            logger.error(f"웹 검색 API 오류: {e}")
             return []
-    
-    def extract_relevant_info(self, results: List[Dict], max_chars: int = 2000) -> str:
+
+    def extract_relevant_info(self, results: List[Dict], max_chars: int = 1500) -> str:
         """검색 결과에서 관련 정보 추출"""
         if not results:
             return ""
-            
         extracted = []
         total_chars = 0
-        
         for i, result in enumerate(results[:3], 1):
             title = result.get("title", "")
             description = result.get("description", "")
             url = result.get("url", "")
-            
-            info = f"[{i}] {title}\n{description}\n출처: {url}\n"
-            
+            info = f"[{i}] {title}\n{description}\nSource: {url}\n"
             if total_chars + len(info) < max_chars:
                 extracted.append(info)
                 total_chars += len(info)
             else:
                 break
-                
         return "\n---\n".join(extracted)
 
 
 class NovelDatabase:
     """소설 세션 관리 데이터베이스"""
-    
     @staticmethod
     def init_db():
-        """데이터베이스 초기화"""
         with sqlite3.connect(DB_PATH) as conn:
             conn.execute("PRAGMA journal_mode=WAL")
             cursor = conn.cursor()
-            
-            # 세션 테이블
             cursor.execute('''
                 CREATE TABLE IF NOT EXISTS sessions (
                     session_id TEXT PRIMARY KEY,
@@ -387,8 +262,6 @@ class NovelDatabase:
                     consistency_report TEXT
                 )
             ''')
-            
-            # 단계 테이블
             cursor.execute('''
                 CREATE TABLE IF NOT EXISTS stages (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -406,8 +279,6 @@ class NovelDatabase:
                     UNIQUE(session_id, stage_number)
                 )
             ''')
-            
-            # 캐릭터 상태 테이블
             cursor.execute('''
                 CREATE TABLE IF NOT EXISTS character_states (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -423,19 +294,15 @@ class NovelDatabase:
                     FOREIGN KEY (session_id) REFERENCES sessions(session_id)
                 )
             ''')
-            
-            # 인덱스 생성
             cursor.execute('CREATE INDEX IF NOT EXISTS idx_session_id ON stages(session_id)')
             cursor.execute('CREATE INDEX IF NOT EXISTS idx_stage_number ON stages(stage_number)')
             cursor.execute('CREATE INDEX IF NOT EXISTS idx_char_session ON character_states(session_id)')
             cursor.execute('CREATE INDEX IF NOT EXISTS idx_session_status ON sessions(status)')
-            
             conn.commit()
-    
+
     @staticmethod
     @contextmanager
     def get_db():
-        """데이터베이스 연결 컨텍스트 매니저"""
         with db_lock:
             conn = sqlite3.connect(DB_PATH, timeout=30.0)
             conn.row_factory = sqlite3.Row
@@ -443,773 +310,422 @@ class NovelDatabase:
                 yield conn
             finally:
                 conn.close()
-    
+
     @staticmethod
     def create_session(user_query: str, language: str) -> str:
-        """새 세션 생성"""
         session_id = hashlib.md5(f"{user_query}{datetime.now()}".encode()).hexdigest()
-        
         with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                INSERT INTO sessions (session_id, user_query, language)
-                VALUES (?, ?, ?)
-            ''', (session_id, user_query, language))
+            conn.cursor().execute(
+                'INSERT INTO sessions (session_id, user_query, language) VALUES (?, ?, ?)',
+                (session_id, user_query, language)
+            )
             conn.commit()
-        
         return session_id
-    
+
     @staticmethod
-    def save_stage(session_id: str, stage_number: int, stage_name: str, 
-                   role: str, content: str, status: str = 'complete', 
+    def save_stage(session_id: str, stage_number: int, stage_name: str,
+                   role: str, content: str, status: str = 'complete',
                    consistency_score: float = 0.0):
-        """단계 저장"""
         word_count = len(content.split()) if content else 0
-        
         with NovelDatabase.get_db() as conn:
             cursor = conn.cursor()
-            
             cursor.execute('''
                 INSERT INTO stages (session_id, stage_number, stage_name, role, content, word_count, status, consistency_score)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(session_id, stage_number) 
+                ON CONFLICT(session_id, stage_number)
                 DO UPDATE SET content=?, word_count=?, status=?, stage_name=?, consistency_score=?, updated_at=datetime('now')
             ''', (session_id, stage_number, stage_name, role, content, word_count, status, consistency_score,
                   content, word_count, status, stage_name, consistency_score))
-            
-            cursor.execute('''
-                UPDATE sessions 
-                SET updated_at = datetime('now'), current_stage = ?
-                WHERE session_id = ?
-            ''', (stage_number, session_id))
-            
+            cursor.execute(
+                "UPDATE sessions SET updated_at = datetime('now'), current_stage = ? WHERE session_id = ?",
+                (stage_number, session_id)
+            )
             conn.commit()
-    
+
     @staticmethod
     def get_session(session_id: str) -> Optional[Dict]:
-        """세션 정보 가져오기"""
         with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('SELECT * FROM sessions WHERE session_id = ?', (session_id,))
-            row = cursor.fetchone()
+            row = conn.cursor().execute('SELECT * FROM sessions WHERE session_id = ?', (session_id,)).fetchone()
             return dict(row) if row else None
-    
+
     @staticmethod
     def get_latest_active_session() -> Optional[Dict]:
-        """최근 활성 세션 가져오기"""
         with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                SELECT * FROM sessions 
-                WHERE status = 'active' 
-                ORDER BY updated_at DESC 
-                LIMIT 1
-            ''')
-            row = cursor.fetchone()
+            row = conn.cursor().execute("SELECT * FROM sessions WHERE status = 'active' ORDER BY updated_at DESC LIMIT 1").fetchone()
             return dict(row) if row else None
-    
+
     @staticmethod
     def get_stages(session_id: str) -> List[Dict]:
-        """세션의 모든 단계 가져오기"""
         with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                SELECT * FROM stages 
-                WHERE session_id = ? 
-                ORDER BY stage_number
-            ''', (session_id,))
-            return [dict(row) for row in cursor.fetchall()]
-    
+            rows = conn.cursor().execute('SELECT * FROM stages WHERE session_id = ? ORDER BY stage_number', (session_id,)).fetchall()
+            return [dict(row) for row in rows]
+
     @staticmethod
     def get_writer_content(session_id: str) -> str:
-        """모든 작가의 최종 내용 가져오기"""
         with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            
             all_content = []
-            
-            # 작가 1-10의 수정본 가져오기
             for writer_num in range(1, 11):
-                cursor.execute('''
-                    SELECT content FROM stages 
-                    WHERE session_id = ? AND role = ? 
-                    AND stage_name LIKE '%수정본%'
-                    ORDER BY stage_number DESC
-                    LIMIT 1
-                ''', (session_id, f'writer{writer_num}'))
-                
-                row = cursor.fetchone()
+                row = conn.cursor().execute(
+                    "SELECT content FROM stages WHERE session_id = ? AND role = ? AND stage_name LIKE '%수정본%' ORDER BY stage_number DESC LIMIT 1",
+                    (session_id, f'writer{writer_num}')
+                ).fetchone()
                 if row and row['content']:
-                    content = row['content'].strip()
-                    if content:
-                        all_content.append(content)
-            
+                    all_content.append(row['content'].strip())
             return '\n\n'.join(all_content)
-    
+
     @staticmethod
     def update_final_novel(session_id: str, final_novel: str, consistency_report: str = ""):
-        """최종 소설 업데이트"""
         with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                UPDATE sessions 
-                SET final_novel = ?, status = 'complete', updated_at = datetime('now'), consistency_report = ?
-                WHERE session_id = ?
-            ''', (final_novel, consistency_report, session_id))
+            conn.cursor().execute(
+                "UPDATE sessions SET final_novel = ?, status = 'complete', updated_at = datetime('now'), consistency_report = ? WHERE session_id = ?",
+                (final_novel, consistency_report, session_id)
+            )
             conn.commit()
-    
+
     @staticmethod
     def get_active_sessions() -> List[Dict]:
-        """활성 세션 목록 가져오기"""
         with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                SELECT session_id, user_query, language, created_at, current_stage
-                FROM sessions 
-                WHERE status = 'active'
-                ORDER BY updated_at DESC
-                LIMIT 10
-            ''')
-            return [dict(row) for row in cursor.fetchall()]
+            rows = conn.cursor().execute(
+                "SELECT session_id, user_query, language, created_at, current_stage FROM sessions WHERE status = 'active' ORDER BY updated_at DESC LIMIT 10"
+            ).fetchall()
+            return [dict(row) for row in rows]
 
 
 class NovelWritingSystem:
     """최적화된 소설 생성 시스템"""
-    
     def __init__(self):
         self.token = FRIENDLI_TOKEN
         self.api_url = API_URL
         self.model_id = MODEL_ID
-        
-        # 핵심 시스템 컴포넌트
         self.consistency_tracker = ConsistencyTracker()
-        self.consistency_validator = ConsistencyValidator(self.consistency_tracker)
         self.web_search = WebSearchIntegration()
-        
-        # 세션 관리
         self.current_session_id = None
-        
-        # 데이터베이스 초기화
         NovelDatabase.init_db()
-    
+
     def create_headers(self):
         """API 헤더 생성"""
-        return {
-            "Authorization": f"Bearer {self.token}",
-            "Content-Type": "application/json"
-        }
-    
-    def create_director_initial_prompt(self, user_query: str, language: str = "English") -> str:
-        """감독자 초기 프롬프트 (웹 검색 포함)"""
-        
-        # 웹 검색 수행
-        search_results = ""
-        if self.web_search.enabled:
-            search_queries = []
-            if language == "Korean":
-                search_queries = [
-                    f"{user_query} 소설 설정",
-                    f"{user_query} 배경 정보",
-                    f"{user_query} 관련 자료"
-                ]
-            else:
-                search_queries = [
-                    f"{user_query} novel setting",
-                    f"{user_query} background information",
-                    f"{user_query} related material"
-                ]
-            
-            for query in search_queries[:2]:  # 2개 쿼리만 사용
-                results = self.web_search.search(query, count=2, language=language)
-                if results:
-                    search_info = self.web_search.extract_relevant_info(results)
-                    search_results += f"\n### {query}\n{search_info}\n"
-        
-        if language == "Korean":
-            base_prompt = f"""당신은 30페이지 중편 소설을 기획하는 문학 감독자입니다.
-
-사용자 주제: {user_query}
-
-{search_results if search_results else ""}
-
-다음 요소들을 포함한 상세한 소설 기획을 작성하세요:
-
-1. **주제와 장르 설정**
-   - 핵심 주제와 메시지
-   - 장르 및 분위기
-   - 독자층 고려사항
-
-2. **주요 등장인물** (3-5명)
-   | 이름 | 역할 | 성격 | 배경 | 목표 | 갈등 |
-   |------|------|------|------|------|------|
-
-3. **배경 설정**
-   - 시공간적 배경
-   - 사회적/문화적 환경
-   - 주요 장소들
-
-4. **플롯 구조** (10개 파트, 각 3페이지)
-   | 파트 | 페이지 | 주요 사건 | 긴장도 | 캐릭터 발전 |
-   |------|--------|-----------|---------|-----------|
-   | 1 | 1-3 | | | |
-   | 2 | 4-6 | | | |
-   | 3 | 7-9 | | | |
-   | 4 | 10-12 | | | |
-   | 5 | 13-15 | | | |
-   | 6 | 16-18 | | | |
-   | 7 | 19-21 | | | |
-   | 8 | 22-24 | | | |
-   | 9 | 25-27 | | | |
-   | 10 | 28-30 | | | |
-
-5. **작가별 지침**
-   - 각 작가가 담당할 내용과 주의사항
-   - 일관성 유지를 위한 핵심 설정
-   - 문체와 톤 가이드라인
-
-창의적이고 흥미로운 소설이 될 수 있도록 상세하게 기획하세요."""
-        else:
-            base_prompt = f"""You are a literary director planning a 30-page novella.
-
-User Theme: {user_query}
-
-{search_results if search_results else ""}
-
-Create a detailed novel plan including:
-
-1. **Theme and Genre Setting**
-   - Core theme and message
-   - Genre and atmosphere
-   - Target audience considerations
-
-2. **Main Characters** (3-5 characters)
-   | Name | Role | Personality | Background | Goal | Conflict |
-   |------|------|-------------|------------|------|----------|
-
-3. **Setting**
-   - Temporal and spatial background
-   - Social/cultural environment
-   - Key locations
-
-4. **Plot Structure** (10 parts, 3 pages each)
-   | Part | Pages | Main Events | Tension | Character Development |
-   |------|-------|-------------|---------|---------------------|
-   | 1 | 1-3 | | | |
-   | 2 | 4-6 | | | |
-   | 3 | 7-9 | | | |
-   | 4 | 10-12 | | | |
-   | 5 | 13-15 | | | |
-   | 6 | 16-18 | | | |
-   | 7 | 19-21 | | | |
-   | 8 | 22-24 | | | |
-   | 9 | 25-27 | | | |
-   | 10 | 28-30 | | | |
-
-5. **Guidelines for Writers**
-   - Content and precautions for each writer
-   - Key settings for consistency
-   - Style and tone guidelines
-
-Plan creatively for an engaging novel."""
-        
-        return base_prompt
-    
-    def create_critic_director_prompt(self, director_plan: str, language: str = "English") -> str:
-        """비평가의 감독자 기획 검토"""
-        if language == "Korean":
-            return f"""당신은 문학 비평가입니다. 감독자의 소설 기획을 일관성 관점에서 검토하세요.
-
-감독자 기획:
-{director_plan}
+        return {"Authorization": f"Bearer {self.token}", "Content-Type": "application/json"}
 
-다음 관점에서 검토하고 개선안을 제시하세요:
-
-1. **일관성 잠재 위험**
-   - 캐릭터 설정의 모순 가능성
-   - 플롯 전개의 논리적 허점
-   - 시간선/공간 설정의 문제점
-
-2. **캐릭터 연속성**
-   - 각 캐릭터의 동기와 행동 일관성
-   - 관계 설정의 지속성
-   - 성격 변화의 자연스러움
-
-3. **서사 구조 검토**
-   - 플롯 포인트 간의 연결성
-   - 긴장 곡선의 적절성
-   - 결말까지의 논리적 흐름
-
-4. **작가별 가이드라인 보완**
-   - 일관성 유지를 위한 추가 지침
-   - 주의해야 할 함정들
-   - 체크해야 할 핵심 요소들
-
-일관성 유지에 중점을 둔 구체적인 개선안을 제시하세요."""
-        else:
-            return f"""You are a literary critic. Review the director's novel plan from a consistency perspective.
-
-Director's Plan:
-{director_plan}
-
-Review and provide improvements focusing on:
-
-1. **Consistency Risk Assessment**
-   - Potential contradictions in character settings
-   - Logical gaps in plot development
-   - Timeline/spatial setting issues
-
-2. **Character Continuity**
-   - Consistency of character motivations and actions
-   - Relationship sustainability
-   - Natural character development
-
-3. **Narrative Structure Review**
-   - Connectivity between plot points
-   - Appropriate tension curve
-   - Logical flow to conclusion
-
-4. **Writer Guidelines Enhancement**
-   - Additional guidelines for consistency
-   - Potential pitfalls to avoid
-   - Key elements to check
-
-Provide specific improvements focused on maintaining consistency."""
-    
-    def create_director_revision_prompt(self, initial_plan: str, critic_feedback: str, language: str = "English") -> str:
-        """감독자 수정 프롬프트"""
-        if language == "Korean":
-            return f"""감독자로서 비평가의 일관성 검토를 반영하여 소설 기획을 수정합니다.
-
-초기 기획:
-{initial_plan}
-
-비평가 피드백:
-{critic_feedback}
-
-다음을 포함한 수정된 최종 기획을 제시하세요:
-
-1. **보완된 캐릭터 설정**
-   - 일관성 문제가 해결된 캐릭터들
-   - 명확한 동기와 성격 특성
-   - 관계 설정의 지속성 확보
-
-2. **개선된 플롯 구조**
-   - 논리적 허점이 수정된 서사
-   - 자연스러운 사건 전개
-   - 일관된 시간선과 공간 설정
-
-3. **작가별 상세 지침**
-   - 각 작가가 담당할 구체적 내용
-   - 일관성 유지를 위한 필수 체크리스트
-   - 캐릭터 상태 및 설정 정보
-
-4. **일관성 관리 시스템**
-   - 캐릭터 추적 방법
-   - 플롯 연속성 체크 포인트
-   - 문체 및 톤 통일 방안
-
-10명의 작가가 일관성 있는 소설을 만들 수 있는 완벽한 마스터플랜을 제시하세요."""
-        else:
-            return f"""As director, revise the novel plan reflecting the critic's consistency review.
-
-Initial Plan:
-{initial_plan}
-
-Critic Feedback:
-{critic_feedback}
-
-Present the revised final plan including:
-
-1. **Enhanced Character Settings**
-   - Characters with resolved consistency issues
-   - Clear motivations and personality traits
-   - Sustained relationship settings
-
-2. **Improved Plot Structure**
-   - Narrative with logical gaps fixed
-   - Natural event progression
-   - Consistent timeline and spatial settings
+    # --- 프롬프트 생성 함수들 (Thematic Guardian 개념 통합) ---
+    def create_director_initial_prompt(self, user_query: str, language: str) -> str:
+        """감독자 초기 기획 프롬프트 (웹 검색 및 테마 제약 조건 강화)"""
+        search_results_str = ""
+        if self.web_search.enabled:
+            queries = [f"{user_query} novel setting", f"{user_query} background information"]
+            search_results = self.web_search.search(queries[0], count=2, language=language)
+            if search_results:
+                search_results_str = self.web_search.extract_relevant_info(search_results)
+
+        lang_prompts = {
+            "Korean": {
+                "title": "당신은 30페이지 분량의 중편 소설을 기획하는 문학 감독자입니다.",
+                "user_theme": "사용자 주제",
+                "plan_instruction": "다음 요소들을 포함한 상세한 소설 기획을 작성하세요:",
+                "theme_section": "1. **주제와 장르 설정**\n   - 핵심 주제와 메시지 (사용자 의도 깊이 반영)\n   - 장르 및 분위기\n   - 독자층 고려사항",
+                "char_section": "2. **주요 등장인물** (3-5명)\n   | 이름 | 역할 | 성격 | 배경 | 목표 | 갈등 |",
+                "setting_section": "3. **배경 설정**\n   - 시공간적 배경\n   - 사회적/문화적 환경\n   - 주요 장소들",
+                "plot_section": "4. **플롯 구조** (10개 파트, 각 3페이지 분량)\n   | 파트 | 페이지 | 주요 사건 | 긴장도 | ��릭터 발전 |",
+                "guideline_section": "5. **작가별 지침**\n   - 일관성 유지를 위한 핵심 설정\n   - 문체와 톤 가이드라인",
+                "constraint_title": "⚠️매우 중요한 지시사항: 핵심 제약 조건⚠️",
+                "constraint_body": "이 소설은 **AI로 인해 모든 것이 쉽게 해결되는 긍정적이고 단순한 이야기가 아닙니다.**\n반드시 사용자의 주제인 '{query}'에 담긴 **핵심 감정(예: 불안, 소외감, 상실감, 세대 갈등 등)을 중심으로 서사를 전개해야 합니다.**\nAI나 특정 기술은 편리한 도구가 아니라, 주인공에게 **갈등과 상실감을 안겨주는 핵심 원인**으로 작용해야 합니다.\n이 제약 조건을 절대 벗어나지 마십시오.",
+                "final_instruction": "창의적이고 깊이 있는 소설이 될 수 있도록 상세하게 기획하세요."
+            },
+            "English": {
+                "title": "You are a literary director planning a 30-page novella.",
+                "user_theme": "User Theme",
+                "plan_instruction": "Create a detailed novel plan including:",
+                "theme_section": "1. **Theme and Genre**\n   - Core theme and message (Deeply reflect user's intent)\n   - Genre and atmosphere",
+                "char_section": "2. **Main Characters** (3-5)\n   | Name | Role | Personality | Background | Goal | Conflict |",
+                "setting_section": "3. **Setting**\n   - Time and place\n   - Social/cultural environment",
+                "plot_section": "4. **Plot Structure** (10 parts, ~3 pages each)\n   | Part | Pages | Main Events | Tension | Character Development |",
+                "guideline_section": "5. **Writer Guidelines**\n   - Key settings for consistency\n   - Style and tone guidelines",
+                "constraint_title": "⚠️CRITICAL INSTRUCTION: CORE CONSTRAINTS⚠️",
+                "constraint_body": "This is **NOT a simple, positive story where AI solves everything.**\nYou must develop the narrative around the core emotions of the user's theme: '{query}' (e.g., anxiety, alienation, loss, generational conflict).\nAI or specific technology should be the **root cause of the protagonist's conflict and loss**, not a convenient tool.\nDo not deviate from this constraint.",
+                "final_instruction": "Plan in detail for a creative and profound novel."
+            }
+        }
+        p = lang_prompts[language]
+        return f"{p['title']}\n\n{p['user_theme']}: {user_query}\n\n{search_results_str}\n\n{p['plan_instruction']}\n\n{p['theme_section']}\n\n{p['char_section']}\n\n{p['setting_section']}\n\n{p['plot_section']}\n\n{p['guideline_section']}\n\n---\n{p['constraint_title']}\n{p['constraint_body'].format(query=user_query)}\n---\n\n{p['final_instruction']}"
+
+    def create_critic_director_prompt(self, director_plan: str, user_query: str, language: str) -> str:
+        """비평가의 감독자 기획 검토 프롬프트 (테마 일관성 강화)"""
+        lang_prompts = {
+            "Korean": {
+                "title": "당신은 문학 비평가입니다. 감독자의 소설 기획을 '주제 일관성'과 '기술적 일관성' 관점에서 검토하세요.",
+                "theme_check": f"**1. 주제 일관성 (가장 중요)**\n   - **원래 주제:** '{user_query}'\n   - 기획안이 주제의 핵심 감정(불안, 상실감 등)에서 벗어나 긍정적이거나 단순한 방향으로 흐르지 않았습니까?\n   - AI나 기술이 갈등의 원인이 아닌, 단순 해결사로 묘사되지 않았습니까?",
+                "consistency_check": "**2. 기술적 일관성**\n   - 캐릭터 설정의 모순, 플롯의 논리적 허점, 시간선/공간 설정의 문제점을 검토하세요.",
+                "instruction": "위 항목들을 중심으로 구체적인 문제점과 개선안을 제시하세요."
+            },
+            "English": {
+                "title": "You are a literary critic. Review the director's plan from the perspectives of 'Thematic Consistency' and 'Technical Consistency'.",
+                "theme_check": f"**1. Thematic Consistency (Most Important)**\n   - **Original Theme:** '{user_query}'\n   - Does the plan drift from the core emotions (e.g., anxiety, loss) towards an overly positive or simplistic narrative?\n   - Is AI depicted as a simple problem-solver instead of the root of the conflict?",
+                "consistency_check": "**2. Technical Consistency**\n   - Review for character contradictions, plot holes, and timeline/setting issues.",
+                "instruction": "Provide specific problems and suggestions for improvement based on the above."
+            }
+        }
+        p = lang_prompts[language]
+        return f"{p['title']}\n\n**감독자 기획:**\n{director_plan}\n\n---\n**검토 항목:**\n{p['theme_check']}\n\n{p['consistency_check']}\n\n{p['instruction']}"
 
-3. **Detailed Guidelines for Writers**
-   - Specific content for each writer
-   - Essential checklist for consistency
-   - Character state and setting information
+    def create_director_revision_prompt(self, initial_plan: str, critic_feedback: str, user_query: str, language: str) -> str:
+        """감독자 수정 프롬프트 (테마 제약 조건 재강조)"""
+        return f"""감독자로서 비평가의 피드백을 반영하여 소설 기획을 수정합니다.
+        
+        **원래 주제:** {user_query}
+        **초기 기획:**\n{initial_plan}
+        **비평가 피드백:**\n{critic_feedback}
 
-4. **Consistency Management System**
-   - Character tracking methods
-   - Plot continuity checkpoints
-   - Style and tone unification methods
+        **수정 지침:**
+        - 비평가가 지적한 모든 일관성 문제와 주제 이탈 문제를 해결하세요.
+        - **핵심 제약 조건**을 다시 한번 상기하고, 소설 전체가 '불안'과 '상실감'의 톤을 유지하도록 플롯을 구체화하세요.
+        - 10명의 작가가 혼동 없이 작업할 수 있도록 명확하고 상세한 최종 마스터플랜을 작성하세요.
+        """
 
-Present a perfect masterplan for 10 writers to create a consistent novel."""
-    
-    def create_writer_prompt(self, writer_number: int, director_plan: str, previous_content: str, language: str = "English") -> str:
-        """작가 프롬프트 생성"""
+    def create_writer_prompt(self, writer_number: int, director_plan: str, previous_content_summary: str, user_query: str, language: str) -> str:
+        """작가 프롬프트 (테마 리마인더 포함)"""
         pages_start = (writer_number - 1) * 3 + 1
         pages_end = writer_number * 3
         
-        # 일관성 정보 추가
-        consistency_info = self.consistency_tracker.get_character_summary(writer_number)
-        consistency_info += self.consistency_tracker.get_plot_summary(writer_number)
+        lang_prompts = {
+            "Korean": {
+                "title": f"당신은 작가 {writer_number}번입니다. 소설의 {pages_start}-{pages_end} 페이지를 작성하세요.",
+                "plan": "감독자 마스터플랜",
+                "prev_summary": "이전 내용 요약",
+                "guidelines": "**작성 지침:**\n1. **분량**: 1,400-1,500 단어 내외\n2. **연결성**: 요약된 이전 내용과 자연스럽게 연결\n3. **일관성**: 캐릭터 설정과 상태, 플롯 구조를 반드시 따를 것",
+                "reminder_title": "⭐ 잊지 마세요 (테마 리마인더)",
+                "reminder_body": f"이 소설의 핵심은 '{user_query}'에 담긴 **불안, 소외, 상실감**입니다. 긍정적인 해결을 서두르지 말고, 주인공의 내면 갈등을 심도 있게 묘사하는 데 집중하세요.",
+                "final_instruction": "창의적이면서도 주제와 일관성을 절대 잃지 마십시오."
+            },
+            "English": {
+                "title": f"You are Writer #{writer_number}. Write pages {pages_start}-{pages_end} of the novella.",
+                "plan": "Director's Masterplan",
+                "prev_summary": "Previous Content Summary",
+                "guidelines": "**Writing Guidelines:**\n1. **Length**: Approx. 1,400-1,500 words\n2. **Connectivity**: Connect naturally with the summarized previous content.\n3. **Consistency**: Strictly follow character settings, states, and plot structure.",
+                "reminder_title": "⭐ REMINDER (THEME)",
+                "reminder_body": f"The core of this novel is the **anxiety, alienation, and loss** from the theme '{user_query}'. Do not rush to a positive resolution; focus on deeply describing the protagonist's internal conflict.",
+                "final_instruction": "Be creative, but never lose consistency and the core theme."
+            }
+        }
         
-        if language == "Korean":
-            return f"""당신은 작가 {writer_number}번입니다. 30페이지 중편 소설의 {pages_start}-{pages_end}페이지를 작성하세요.
-
-감독자 마스터플랜:
-{director_plan}
-
-{consistency_info}
-
-{'이전 내용 요약:' if previous_content else ''}
-{previous_content[-1500:] if previous_content else ''}
-
-**작성 지침:**
-1. **분량**: 정확히 1,400-1,500단어 (약 3페이지)
-2. **일관성**: 이전 내용과 자연스럽게 연결
-3. **캐릭터**: 기존 설정과 상태 유지
-4. **플롯**: 마스터플랜의 해당 부분 충실히 구현
-5. **문체**: 전체 소설의 톤과 일치
-
-창의적이고 흥미로운 내용을 작성하되, 일관성을 절대 잃지 마세요."""
-        else:
-            return f"""You are Writer #{writer_number}. Write pages {pages_start}-{pages_end} of the 30-page novella.
-
-Director's Masterplan:
-{director_plan}
-
-{consistency_info}
-
-{'Previous Content Summary:' if previous_content else ''}
-{previous_content[-1500:] if previous_content else ''}
-
-**Writing Guidelines:**
-1. **Length**: Exactly 1,400-1,500 words (about 3 pages)
-2. **Consistency**: Connect naturally with previous content
-3. **Characters**: Maintain existing settings and states
-4. **Plot**: Faithfully implement the relevant part of the masterplan
-5. **Style**: Match the tone of the entire novel
-
-Write creatively and engagingly, but never lose consistency."""
-    
-    def create_critic_consistency_prompt(self, all_content: str, language: str = "English") -> str:
-        """비평가 일관성 검토 프롬프트"""
-        if language == "Korean":
-            return f"""당신은 일관성 검토 전문 비평가입니다. 지금까지 작성된 모든 내용을 검토하세요.
-
-현재까지 작성된 내용:
-{all_content[-3000:]}  # 최근 3000자만 표시
-
-다음 항목들을 철저히 검토하세요:
-
-1. **캐릭터 일관성**
-   - 인물 설정의 일관성
-   - 성격과 행동의 연속성
-   - 관계 설정의 지속성
-
-2. **플롯 연속성**
-   - 사건의 논리적 연결
-   - 시간선의 일관성
-   - 공간 설정의 지속성
-
-3. **반복 내용 검사**
-   - 동일한 내용의 반복
-   - 유사한 표현의 과도한 사용
-   - 중복되는 장면이나 설명
-
-4. **설정 충돌**
-   - 이전에 확립된 설정과의 모순
-   - 세계관 설정의 일관성
-   - 기술적/사회적 배경의 연속성
-
-**검토 결과:**
-- 발견된 문제점들을 구체적으로 나열
-- 각 문제점에 대한 수정 방향 제시
-- 앞으로 주의해야 할 사항들 안내
-
-일관성 유지를 위한 구체적이고 실용적인 피드백을 제공하세요."""
-        else:
-            return f"""You are a consistency review specialist critic. Review all content written so far.
-
-Current Content:
-{all_content[-3000:]}  # Show only recent 3000 characters
-
-Thoroughly review these items:
-
-1. **Character Consistency**
-   - Character setting consistency
-   - Personality and behavior continuity
-   - Relationship sustainability
-
-2. **Plot Continuity**
-   - Logical connection of events
-   - Timeline consistency
-   - Spatial setting sustainability
+        p = lang_prompts[language]
+        consistency_info = self.consistency_tracker.get_character_summary(writer_number) + self.consistency_tracker.get_plot_summary(writer_number)
+        
+        return f"{p['title']}\n\n**{p['plan']}:**\n{director_plan}\n\n{consistency_info}\n\n**{p['prev_summary']}:**\n{previous_content_summary}\n\n---\n{p['guidelines']}\n\n**{p['reminder_title']}**\n{p['reminder_body']}\n---\n\n{p['final_instruction']}"
 
-3. **Repetition Check**
-   - Repetition of identical content
-   - Excessive use of similar expressions
-   - Duplicate scenes or descriptions
+    def create_critic_consistency_prompt(self, all_content: str, user_query: str, language: str) -> str:
+        """비평가 중간 검토 프롬프트 (테마 검토 강화)"""
+        return f"""당신은 일관성 검토 전문 비평가입니다. 지금까지 작성된 내용을 검토하세요.
+        
+        **원래 주제:** {user_query}
+        **현재까지 작성된 내용 (최근 3000자):**\n{all_content[-3000:]}
 
-4. **Setting Conflicts**
-   - Contradictions with previously established settings
-   - Worldbuilding consistency
-   - Technical/social background continuity
+        **검토 항목:**
+        1. **주제 일관성 (가장 중요):** 내용이 원래 주제의 어두운 감정선에서 벗어나지 않았는지 확인하고, 벗어났다면 수정 방향을 제시하세요.
+        2. **기술적 일관성:** 캐릭터, 플롯, 설정의 연속성과 논리적 오류를 찾아내세요.
+        3. **반복 내용:** 의미적으로 중복되는 장면이나 표현이 없는지 확인하세요.
 
-**Review Results:**
-- Specifically list discovered problems
-- Provide correction directions for each problem
-- Guide precautions for the future
+        **결과:** 발견된 문제점과 구체적인 수정 제안을 목록으로 제시하세요.
+        """
 
-Provide specific and practical feedback for maintaining consistency."""
-    
-    def create_writer_revision_prompt(self, writer_number: int, initial_content: str, 
-                                    consistency_feedback: str, language: str = "English") -> str:
+    def create_writer_revision_prompt(self, writer_number: int, initial_content: str, consistency_feedback: str, language: str) -> str:
         """작가 수정 프롬프트"""
-        if language == "Korean":
-            return f"""작가 {writer_number}번으로서 일관성 검토 결과를 반영하여 수정하세요.
-
-초기 작성 내용:
-{initial_content}
-
-일관성 검토 피드백:
-{consistency_feedback}
-
-다음 사항을 반영하여 수정하세요:
-
-1. **일관성 문제 수정**
-   - 지적된 모든 일관성 문제 해결
-   - 캐릭터 설정 및 상태 정확히 반영
-   - 플롯 연속성 확보
-
-2. **반복 내용 제거**
-   - 중복되는 표현이나 장면 삭제
-   - 새로운 표현과 관점으로 대체
-   - 창의적이고 다양한 문장 구조 사용
-
-3. **설정 충돌 해결**
-   - 이전 설정과의 모순 제거
-   - 세계관 일관성 유지
-   - 시간선과 공간 ��정 정확히 반영
-
-4. **분량 유지**
-   - 1,400-1,500단어 정확히 유지
-   - 수정 과정에서 내용 품질 향상
-
-수정된 최종 버전을 제시하세요. 창의성은 유지하되 일관성을 절대 놓치지 마세요."""
-        else:
-            return f"""As Writer #{writer_number}, revise reflecting the consistency review results.
-
-Initial Content:
-{initial_content}
-
-Consistency Review Feedback:
-{consistency_feedback}
-
-Revise reflecting these points:
-
-1. **Fix Consistency Issues**
-   - Resolve all pointed consistency problems
-   - Accurately reflect character settings and states
-   - Ensure plot continuity
-
-2. **Remove Repetitive Content**
-   - Delete duplicate expressions or scenes
-   - Replace with new expressions and perspectives
-   - Use creative and varied sentence structures
-
-3. **Resolve Setting Conflicts**
-   - Remove contradictions with previous settings
-   - Maintain worldbuilding consistency
-   - Accurately reflect timeline and spatial settings
-
-4. **Maintain Length**
-   - Keep exactly 1,400-1,500 words
-   - Improve content quality during revision
-
-Present the revised final version. Maintain creativity but never miss consistency."""
-    
-    def create_critic_final_prompt(self, complete_novel: str, language: str = "English") -> str:
-        """최종 비평가 검토"""
-        if language == "Korean":
-            return f"""완성된 소설의 최종 일관성 검토를 수행하세요.
-
-완성된 소설:
-{complete_novel[-2000:]}  # 마지막 2000자 표시
-
-**최종 검토 항목:**
-
-1. **전체 일관성 평가**
-   - 캐릭터 일관성 점수 (1-10)
-   - 플롯 연속성 점수 (1-10)
-   - 설정 일관성 점수 (1-10)
-   - 전반적 통일성 점수 (1-10)
-
-2. **발견된 문제점**
-   - 남아있는 일관성 문제들
-   - 반복이나 중복 내용
-   - 설정 충돌 사항들
-
-3. **성공 요소**
-   - 잘 유지된 일관성 부분
-   - 훌륭한 캐릭터 연속성
-   - 효과적인 플롯 전개
-
-4. **최종 평가**
-   - 전체적인 소설의 완성도
-   - 일관성 관점에서의 품질
-   - 독자에게 미칠 영향
-
-**일관성 보고서**를 작성하여 이 소설의 일관성 수준을 종합적으로 평가하세요."""
-        else:
-            return f"""Perform final consistency review of the completed novel.
-
-Completed Novel:
-{complete_novel[-2000:]}  # Show last 2000 characters
-
-**Final Review Items:**
-
-1. **Overall Consistency Evaluation**
-   - Character consistency score (1-10)
-   - Plot continuity score (1-10)
-   - Setting consistency score (1-10)
-   - Overall unity score (1-10)
-
-2. **Problems Found**
-   - Remaining consistency issues
-   - Repetitive or duplicate content
-   - Setting conflicts
-
-3. **Success Elements**
-   - Well-maintained consistency parts
-   - Excellent character continuity
-   - Effective plot development
-
-4. **Final Assessment**
-   - Overall completion of the novel
-   - Quality from consistency perspective
-   - Impact on readers
-
-Write a **Consistency Report** to comprehensively evaluate this novel's consistency level."""
-    
-    def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, 
-                          language: str = "English") -> Generator[str, None, None]:
-        """LLM 스트리밍 호출"""
+        return f"""작가 {writer_number}번으로서 비평가의 피드백을 반영하여 내용을 수정하세요.
+
+        **초기 작성 내용:**\n{initial_content}
+        **비평가 피드백:**\n{consistency_feedback}
+
+        **수정 지침:**
+        - 지적된 모든 주제 이탈 및 일관성 문제를 해결하세요.
+        - 분량(1,400-1,500 단어)을 유지하면서 내용의 질을 높이세요.
+        - 수정된 최종 버전을 제시하세요.
+        """
+
+    def create_critic_final_prompt(self, complete_novel: str, language: str) -> str:
+        """최종 비평가 검토 및 보고서 작성 프롬프트"""
+        return f"""완성된 소설의 최종 일관성 및 완성도에 대한 종합 보고서를 작성하세요.
+
+        **완성된 소설 (마지막 2000자):**\n{complete_novel[-2000:]}
+
+        **보고서 포함 항목:**
+        1. **전체 일관성 평가:** 캐릭터, 플롯, 설정, 주제 유지에 대한 점수(1-10)와 총평.
+        2. **최종 발견된 문제점:** 남아있는 사소한 문제점들.
+        3. **성공 요소:** 특히 잘 유지된 일관성 부분이나 주제 표현이 뛰어난 부분.
+        4. **최종 평가:** 소설의 전반적인 완성도와 독자에게 미칠 영향에 대한 평가.
+        """
+
+    # --- LLM 호출 함수들 ---
+    def call_llm_sync(self, messages: List[Dict[str, str]], role: str, language: str) -> str:
+        """LLM 동기식 호출 (요약 등 내부용)"""
+        full_content = ""
+        for chunk in self.call_llm_streaming(messages, role, language):
+            full_content += chunk
+        if full_content.startswith("❌"):
+            raise Exception(f"LLM Sync Call Failed: {full_content}")
+        return full_content
+
+    def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, language: str) -> Generator[str, None, None]:
+        """LLM 스트리밍 호출 (완전한 에러 처리 및 디버깅)"""
         try:
             system_prompts = self.get_system_prompts(language)
-            
-            full_messages = [
-                {"role": "system", "content": system_prompts.get(role, "")},
-                *messages
-            ]
-            
-            # 역할별 토큰 할당
-            if role.startswith("writer"):
-                max_tokens = 10000
-                temperature = 0.8
-            elif role == "critic":
-                max_tokens = 8000
-                temperature = 0.6
-            else:  # director
-                max_tokens = 12000
-                temperature = 0.7
+            full_messages = [{"role": "system", "content": system_prompts.get(role, "You are a helpful assistant.")}, *messages]
             
             payload = {
                 "model": self.model_id,
                 "messages": full_messages,
-                "max_tokens": max_tokens,
-                "temperature": temperature,
+                "max_tokens": 10000,
+                "temperature": 0.75,
                 "top_p": 0.9,
+                "presence_penalty": 0.3,
+                "frequency_penalty": 0.2,
                 "stream": True,
                 "stream_options": {"include_usage": True}
             }
             
+            logger.info(f"[{role}] API 스트리밍 시작")
+            
+            # API 호출
             response = requests.post(
-                self.api_url,
-                headers=self.create_headers(),
-                json=payload,
-                stream=True,
-                timeout=120
+                self.api_url, 
+                headers=self.create_headers(), 
+                json=payload, 
+                stream=True, 
+                timeout=180
             )
             
+            # 상태 코드 확인
             if response.status_code != 200:
-                logger.error(f"API error: {response.status_code}")
-                yield f"❌ API 오류 ({response.status_code}): {response.text[:200]}"
+                logger.error(f"API 응답 오류: {response.status_code}")
+                logger.error(f"응답 내용: {response.text[:500]}")
+                yield f"❌ API 오류 (상태 코드: {response.status_code})"
                 return
             
+            response.raise_for_status()
+        
+        # 스트리밍 처리
             buffer = ""
             total_content = ""
-            
+            chunk_count = 0
+            error_count = 0
+        
             for line in response.iter_lines():
-                if line:
-                    line = line.decode('utf-8')
-                    if line.startswith("data: "):
-                        data = line[6:]
-                        if data == "[DONE]":
-                            if buffer:
-                                yield buffer
-                            break
-                            
-                        try:
-                            chunk = json.loads(data)
-                            if "choices" in chunk and chunk["choices"]:
-                                content = chunk["choices"][0].get("delta", {}).get("content", "")
-                                if content:
-                                    buffer += content
-                                    total_content += content
-                                    
-                                    if len(buffer) > 100:
-                                        yield buffer
-                                        buffer = ""
-                        except json.JSONDecodeError:
-                            continue
+                if not line:
+                    continue
+                
+                try:
+                    line_str = line.decode('utf-8').strip()
+                
+                # SSE 형식 확인
+                    if not line_str.startswith("data: "):
+                        continue
+                    
+                    data_str = line_str[6:]  # "data: " 제거
+                
+                # 스트림 종료 확인
+                    if data_str == "[DONE]":
+                        logger.info(f"[{role}] 스트리밍 완료 - 총 {len(total_content)} 문자")
+                        break
+                
+                # JSON 파싱
+                    try:
+                        data = json.loads(data_str)
+                    except json.JSONDecodeError:
+                        logger.warning(f"JSON 파싱 실패: {data_str[:100]}")
+                        continue
+                
+                # choices 배열 안전하게 확인
+                    choices = data.get("choices", None)
+                    if not choices or not isinstance(choices, list) or len(choices) == 0:
+                        # 에러 응답 확인
+                        if "error" in data:
+                            error_msg = data.get("error", {}).get("message", "Unknown error")
+                            logger.error(f"API 에러: {error_msg}")
+                            yield f"❌ API 에러: {error_msg}"
+                            return
+                        continue
+                    
+                    # delta에서 content 추출
+                    delta = choices[0].get("delta", {})
+                    content = delta.get("content", "")
+                    
+                    if content:
+                        buffer += content
+                        total_content += content
+                        chunk_count += 1
+                        
+                        # 100자 또는 줄바꿈마다 yield
+                        if len(buffer) >= 100 or '\n' in buffer:
+                            yield buffer
+                            buffer = ""
+                            time.sleep(0.01)  # UI 업데이트를 위한 짧은 대기
+                    
+                except Exception as e:
+                    error_count += 1
+                    logger.error(f"청크 처리 오류 #{error_count}: {str(e)}")
+                    if error_count > 10:  # 너무 많은 에러시 중단
+                        yield f"❌ 스트리밍 중 과도한 오류 발생"
+                        return
+                    continue
             
+            # 남은 버퍼 처리
             if buffer:
                 yield buffer
+            
+        # 결과 확인
+            if chunk_count == 0:
+                logger.error(f"[{role}] 콘텐츠가 전혀 수신되지 않음")
+                yield "❌ API로부터 응답을 받지 못했습니다."
+            else:
+                logger.info(f"[{role}] 성공적으로 {chunk_count}개 청크, 총 {len(total_content)}자 수신")
                 
+        except requests.exceptions.Timeout:
+            logger.error("API 요청 시간 초과")
+            yield "❌ API 요청 시간이 초과되었습니다."
+        except requests.exceptions.ConnectionError:
+            logger.error("API 연결 실패")
+            yield "❌ API 서버에 연결할 수 없습니다."
         except Exception as e:
-            logger.error(f"스트리밍 중 오류: {str(e)}")
+            logger.error(f"예기치 않은 오류: {type(e).__name__}: {str(e)}", exc_info=True)
             yield f"❌ 오류 발생: {str(e)}"
-    
+
+
+
+
+
     def get_system_prompts(self, language: str) -> Dict[str, str]:
-        """시스템 프롬프트 생성"""
-        if language == "Korean":
-            return {
+        """역할별 시스템 프롬프트 생성"""
+        base_prompts = {
+            "Korean": {
                 "director": "당신은 창의적이고 체계적인 소설 기획 전문가입니다. 흥미롭고 일관성 있는 스토리를 설계하세요.",
                 "critic": "당신은 일관성 검토 전문 비평가입니다. 캐릭터, 플롯, 설정의 일관성을 철저히 점검하고 개선방안을 제시하세요.",
-                "writer1": "당신은 소설의 매력적인 시작을 담당하는 작가입니다. 독자를 사로잡는 도입부를 만드세요.",
-                "writer2": "당신은 이야기를 발전시키는 작가입니다. 등장인물과 갈등을 깊이 있게 전개하세요.",
-                "writer3": "당신은 갈등을 심화시키는 작가입니다. 긴장감과 흥미를 높여가세요.",
-                "writer4": "당신은 전환점을 만드는 작가입니다. 이야기에 새로운 전개를 가져오세요.",
-                "writer5": "당신은 중반부를 담당하는 작가입니다. 복잡성과 깊이를 더해가세요.",
-                "writer6": "당신은 클라이맥스를 준비하는 작가입니다. 긴장감을 최고조로 끌어올리세요.",
-                "writer7": "당신은 클라이맥스를 담당하는 작가입니다. 모든 갈등이 폭발하는 순간을 그려내세요.",
-                "writer8": "당신은 해결 과정을 담당하는 작가입니다. 갈등을 해결해나가는 과정을 보여주세요.",
-                "writer9": "당신은 결말을 준비하는 작가입니다. 이야기를 자연스럽게 마무리로 이끌어가세요.",
-                "writer10": "당신은 완벽한 결말을 만드는 작가입니다. 독자에게 깊은 여운을 남기는 마무리를 하세요."
-            }
-        else:
-            return {
+                "writer_base": "당신은 전문 소설 작가입니다. 주어진 지침에 따라 몰입감 있고 일관성 있는 내용을 작성하세요."
+            },
+            "English": {
                 "director": "You are a creative and systematic novel planning expert. Design engaging and consistent stories.",
                 "critic": "You are a consistency review specialist critic. Thoroughly check character, plot, and setting consistency and suggest improvements.",
-                "writer1": "You are a writer responsible for the captivating beginning. Create an opening that hooks readers.",
-                "writer2": "You are a writer who develops the story. Deeply develop characters and conflicts.",
-                "writer3": "You are a writer who intensifies conflicts. Increase tension and interest.",
-                "writer4": "You are a writer who creates turning points. Bring new developments to the story.",
-                "writer5": "You are a writer responsible for the middle part. Add complexity and depth.",
-                "writer6": "You are a writer preparing for the climax. Raise tension to its peak.",
-                "writer7": "You are a writer responsible for the climax. Depict the moment when all conflicts explode.",
-                "writer8": "You are a writer responsible for the resolution process. Show the process of resolving conflicts.",
-                "writer9": "You are a writer preparing for the ending. Lead the story naturally to its conclusion.",
-                "writer10": "You are a writer who creates the perfect ending. Create a conclusion that leaves readers with deep resonance."
+                "writer_base": "You are a professional novel writer. Write immersive and consistent content according to the given guidelines."
             }
-    
-    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]:
-        """소설 생성 스트리밍 프로세스"""
+        }
+        
+        prompts = base_prompts[language].copy()
+        
+        # 작가별 특수 프롬프트
+        if language == "Korean":
+            prompts["writer1"] = "당신은 소설의 매력적인 시작을 담당하는 작가입니다. 독자를 사로잡는 도입부를 만드세요."
+            prompts["writer10"] = "당신은 완벽한 결말을 만드는 작가입니다. 독자에게 깊은 여운을 남기는 마무리를 하세요."
+        else:
+            prompts["writer1"] = "You are a writer responsible for the captivating beginning. Create an opening that hooks readers."
+            prompts["writer10"] = "You are a writer who creates the perfect ending. Create a conclusion that leaves readers with deep resonance."
+        
+        # writer2-9는 기본 프롬프트 사용
+        for i in range(2, 10):
+            prompts[f"writer{i}"] = prompts["writer_base"]
+        
+        return prompts
+
+    # --- 메인 프로세스 ---
+    def process_novel_stream(self, query: str, language: str, session_id: Optional[str] = None) -> Generator[Tuple[str, List[Dict[str, Any]], str], None, None]:
+        """소설 생성 스트리밍 프로세스 (강화된 로직)"""
         try:
-            global conversation_history
-            
-            # 세션 생성 또는 복구
+            resume_from_stage = 0
             if session_id:
                 self.current_session_id = session_id
                 session = NovelDatabase.get_session(session_id)
@@ -1220,364 +736,251 @@ Write a **Consistency Report** to comprehensively evaluate this novel's consiste
                     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}")
-            
-            # 대화 기록 초기화
-            conversation_history = [{
-                "role": "human",
-                "content": query,
-                "timestamp": datetime.now()
-            }]
-            
-            # 기존 단계 로드
+
             stages = []
             if resume_from_stage > 0:
-                existing_stages = NovelDatabase.get_stages(self.current_session_id)
-                for stage_data in existing_stages:
-                    stages.append({
-                        "name": stage_data['stage_name'],
-                        "status": stage_data['status'],
-                        "content": stage_data['content'] or "",
-                        "consistency_score": stage_data.get('consistency_score', 0.0)
-                    })
-            
-            # 단계 처리
+                stages = [{
+                    "name": s['stage_name'], "status": s['status'], "content": s.get('content', ''),
+                    "consistency_score": s.get('consistency_score', 0.0)
+                } for s in NovelDatabase.get_stages(self.current_session_id)]
+
             for stage_idx in range(resume_from_stage, len(OPTIMIZED_STAGES)):
                 role, stage_name = OPTIMIZED_STAGES[stage_idx]
-                
-                # 단계 추가
                 if stage_idx >= len(stages):
-                    stages.append({
-                        "name": stage_name,
-                        "status": "active",
-                        "content": "",
-                        "consistency_score": 0.0
-                    })
+                    stages.append({"name": stage_name, "status": "active", "content": "", "consistency_score": 0.0})
                 else:
                     stages[stage_idx]["status"] = "active"
-                
-                yield "", stages
-                
-                # 프롬프트 생성
+
+                yield "", stages, self.current_session_id
                 prompt = self.get_stage_prompt(stage_idx, role, query, language, stages)
-                
-                # 스트리밍 생성
                 stage_content = ""
-                for chunk in self.call_llm_streaming(
-                    [{"role": "user", "content": prompt}],
-                    role,
-                    language
-                ):
+                for chunk in self.call_llm_streaming([{"role": "user", "content": prompt}], role, language):
                     stage_content += chunk
                     stages[stage_idx]["content"] = stage_content
-                    yield "", stages
-                
-                # 일관성 검증 (작가 단계)
+                    yield "", stages, self.current_session_id
+
                 consistency_score = 0.0
                 if role.startswith("writer"):
-                    writer_num = int(role.replace("writer", ""))
-                    all_previous = self.get_previous_content(stages, stage_idx)
-                    
-                    errors = self.consistency_validator.validate_writer_content(
-                        writer_num, stage_content, all_previous
-                    )
-                    
-                    consistency_score = max(0, 10 - len(errors))
+                    writer_num = int(re.search(r'\d+', role).group())
+                    all_previous = self.get_all_content(stages, stage_idx)
+                    errors = self.consistency_tracker.validate_consistency(writer_num, stage_content)
+                    consistency_score = max(0, 10 - len(errors) * 2)
                     stages[stage_idx]["consistency_score"] = consistency_score
-                    
-                    if errors:
-                        logger.warning(f"Writer {writer_num} consistency issues: {errors}")
-                
-                # 단계 완료
+
                 stages[stage_idx]["status"] = "complete"
-                
-                # DB 저장
                 NovelDatabase.save_stage(
-                    self.current_session_id,
-                    stage_idx,
-                    stage_name,
-                    role,
-                    stage_content,
-                    "complete",
-                    consistency_score
+                    self.current_session_id, stage_idx, stage_name, role,
+                    stage_content, "complete", consistency_score
                 )
-                
-                yield "", stages
-            
-            # 최종 소설 생성
-            complete_novel = NovelDatabase.get_writer_content(self.current_session_id)
-            
-            # 최종 일관성 보고서 생성
-            final_report = self.generate_consistency_report(complete_novel, language)
-            
-            # 최종 저장
-            NovelDatabase.update_final_novel(self.current_session_id, complete_novel, final_report)
-            
-            # 완료 메시지
-            final_message = f"✅ 소설 완성! 총 {len(complete_novel.split())}단어\n\n{final_report}"
-            yield final_message, stages
-            
+                yield "", stages, self.current_session_id
+
+            final_novel = NovelDatabase.get_writer_content(self.current_session_id)
+            final_report = self.generate_consistency_report(final_novel, language)
+            NovelDatabase.update_final_novel(self.current_session_id, final_novel, final_report)
+            yield f"✅ 소설 완성! 총 {len(final_novel.split())}단어", stages, self.current_session_id
+
         except Exception as e:
-            logger.error(f"Error in process_novel_stream: {str(e)}", exc_info=True)
-            error_stage = {
-                "name": "❌ 오류",
-                "status": "error",
-                "content": str(e),
-                "consistency_score": 0.0
-            }
-            stages.append(error_stage)
-            yield f"오류 발생: {str(e)}", stages
-    
-    def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
-                        language: str, stages: List[Dict]) -> str:
-        """단계별 프롬프트 생성"""
-        if stage_idx == 0:  # 감독자 초기
+            logger.error(f"소설 생성 프로세스 오류: {e}", exc_info=True)
+            yield f"❌ 오류 발생: {e}", stages if 'stages' in locals() else [], self.current_session_id
+
+    def get_stage_prompt(self, stage_idx: int, role: str, query: str, language: str, stages: List[Dict]) -> str:
+        """단계별 프롬프트 생성 (요약 기능 및 주제 전달 강화)"""
+        if stage_idx == 0:
             return self.create_director_initial_prompt(query, language)
-        elif stage_idx == 1:  # 비평가 기획 검토
-            return self.create_critic_director_prompt(stages[0]["content"], language)
-        elif stage_idx == 2:  # 감독자 수정
-            return self.create_director_revision_prompt(
-                stages[0]["content"], stages[1]["content"], language)
-        elif 3 <= stage_idx <= 12:  # 작가 초안
+        if stage_idx == 1:
+            return self.create_critic_director_prompt(stages[0]["content"], query, language)
+        if stage_idx == 2:
+            return self.create_director_revision_prompt(stages[0]["content"], stages[1]["content"], query, language)
+
+        master_plan = stages[2]["content"]
+        
+        if 3 <= stage_idx <= 12: # 작가 초안
             writer_num = stage_idx - 2
-            final_plan = stages[2]["content"]
-            previous_content = self.get_previous_content(stages, stage_idx)
-            return self.create_writer_prompt(writer_num, final_plan, previous_content, language)
-        elif stage_idx == 13:  # 일관성 검토
+            previous_content = self.get_all_content(stages, stage_idx)
+            summary = self.create_summary(previous_content, language)
+            return self.create_writer_prompt(writer_num, master_plan, summary, query, language)
+        
+        if stage_idx == 13: # 비평가 중간 검토
             all_content = self.get_all_content(stages, stage_idx)
-            return self.create_critic_consistency_prompt(all_content, language)
-        elif 14 <= stage_idx <= 23:  # 작가 수정
+            return self.create_critic_consistency_prompt(all_content, query, language)
+            
+        if 14 <= stage_idx <= 23: # 작가 수정
             writer_num = stage_idx - 13
             initial_content = stages[2 + writer_num]["content"]
-            consistency_feedback = stages[13]["content"]
-            return self.create_writer_revision_prompt(
-                writer_num, initial_content, consistency_feedback, language)
-        elif stage_idx == 24:  # 최종 검토
+            feedback = stages[13]["content"]
+            return self.create_writer_revision_prompt(writer_num, initial_content, feedback, language)
+        
+        if stage_idx == 24: # 최종 검토
             complete_novel = self.get_all_writer_content(stages)
             return self.create_critic_final_prompt(complete_novel, language)
         
         return ""
-    
-    def get_previous_content(self, stages: List[Dict], current_stage: int) -> str:
-        """이전 내용 가져오기"""
-        content = ""
-        for i in range(max(0, current_stage - 3), current_stage):
-            if i < len(stages) and stages[i]["content"]:
-                content += stages[i]["content"] + "\n\n"
-        return content
-    
+
+    def create_summary(self, content: str, language: str) -> str:
+        """LLM을 이용해 이전 내용을 요약"""
+        if not content.strip():
+            return "이전 내용이 없습니다." if language == "Korean" else "No previous content."
+        
+        prompt_text = "다음 소설 내용을 3~5개의 핵심적인 문장으로 요약해줘. 다음 작가가 이야기를 이어가는 데 필요한 핵심 정보(등장인물의 현재 상황, 감정, 마지막 사건)를 포함해야 해."
+        if language != "Korean":
+            prompt_text = "Summarize the following novel content in 3-5 key sentences. Include crucial information for the next writer to continue the story (characters' current situation, emotions, and the last major event)."
+        
+        summary_prompt = f"{prompt_text}\n\n---\n{content[-2000:]}"
+        try:
+            summary = self.call_llm_sync([{"role": "user", "content": summary_prompt}], "critic", language)
+            return summary
+        except Exception as e:
+            logger.error(f"요약 생성 실패: {e}")
+            return content[-1000:]
+
     def get_all_content(self, stages: List[Dict], current_stage: int) -> str:
-        """모든 내용 가져오기"""
-        content = ""
-        for i in range(current_stage):
-            if i < len(stages) and stages[i]["content"]:
-                content += stages[i]["content"] + "\n\n"
-        return content
-    
+        """현재까지의 모든 내용 가져오기"""
+        return "\n\n".join(s["content"] for i, s in enumerate(stages) if i < current_stage and s["content"])
+
     def get_all_writer_content(self, stages: List[Dict]) -> str:
-        """모든 작가 내용 가져오기"""
-        content = ""
-        for i in range(14, 24):  # 작가 수정본들
-            if i < len(stages) and stages[i]["content"]:
-                content += stages[i]["content"] + "\n\n"
-        return content
-    
+        """모든 작가 최종 수정본 내용 가져오기"""
+        return "\n\n".join(s["content"] for i, s in enumerate(stages) if 14 <= i <= 23 and s["content"])
+
     def generate_consistency_report(self, complete_novel: str, language: str) -> str:
-        """일관성 보고서 생���"""
-        if language == "Korean":
-            return f"""📊 일관성 보고서
-- 전체 길이: {len(complete_novel.split())} 단어
-- 캐릭터 수: {len(self.consistency_tracker.character_states)}
-- 플롯 포인트: {len(self.consistency_tracker.plot_points)}
-- 일관성 점수: 양호"""
-        else:
-            return f"""📊 Consistency Report
-- Total Length: {len(complete_novel.split())} words
-- Characters: {len(self.consistency_tracker.character_states)}
-- Plot Points: {len(self.consistency_tracker.plot_points)}
-- Consistency Score: Good"""
+        """최종 보고서 생성 (LLM 호출)"""
+        prompt = self.create_critic_final_prompt(complete_novel, language)
+        try:
+            report = self.call_llm_sync([{"role": "user", "content": prompt}], "critic", language)
+            return report
+        except Exception as e:
+            logger.error(f"최종 보고서 생성 실패: {e}")
+            return "보고서 생성 중 오류 발생"
 
 
-# Gradio 인터페이스 함수들
-def process_query(query: str, language: str, session_id: str = None) -> Generator[Tuple[str, str, str, str], None, None]:
-    """쿼리 처리 및 업데이트"""
-    if not query.strip() and not session_id:
-        if language == "Korean":
-            yield "", "", "❌ 소설 주제를 입력해주세요.", None
-        else:
-            yield "", "", "❌ Please enter a novel theme.", None
+# --- 유틸리티 함수들 ---
+def process_query(query: str, language: str, session_id: Optional[str] = None) -> Generator[Tuple[str, str, str, str], None, None]:
+    """메인 쿼리 처리 함수"""
+    if not query.strip():
+        yield "", "", "❌ 주제를 입력해주세요.", session_id
         return
     
     system = NovelWritingSystem()
+    stages_markdown = ""
+    novel_content = ""
     
-    try:
-        for final_novel, stages in system.process_novel_stream(query, language, session_id):
-            # 단계 표시 형식화
-            stages_display = format_stages_display(stages, language)
-            
-            # 진행률 계산
-            completed = sum(1 for s in stages if s.get("status") == "complete")
-            total = len(stages)
-            progress_percent = (completed / total * 100) if total > 0 else 0
-            
-            if "✅ 소설 완성!" in str(final_novel):
-                status = "✅ 완료! 다운로드 가능합니다."
-            else:
-                if language == "Korean":
-                    status = f"🔄 진행중... ({completed}/{total} - {progress_percent:.1f}%)"
-                else:
-                    status = f"🔄 Processing... ({completed}/{total} - {progress_percent:.1f}%)"
-            
-            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)}", None
-        else:
-            yield "", "", f"❌ Error occurred: {str(e)}", None
-
-
-def format_stages_display(stages: List[Dict[str, str]], language: str) -> str:
-    """단계 표시 형식화"""
-    display = ""
-    
-    for idx, stage in enumerate(stages):
-        status_icon = "✅" if stage.get("status") == "complete" else ("⏳" if stage.get("status") == "active" else "❌")
+    for status, stages, current_session_id in system.process_novel_stream(query, language, session_id):
+        stages_markdown = format_stages_display(stages)
         
-        # 일관성 점수 표시
-        consistency_indicator = ""
-        if stage.get("consistency_score", 0) > 0:
-            score = stage["consistency_score"]
-            if score >= 8:
-                consistency_indicator = " 🟢"
-            elif score >= 6:
-                consistency_indicator = " 🟡"
-            else:
-                consistency_indicator = " 🔴"
+        # 최종 소설 내용 가져오기
+        if stages and all(s.get("status") == "complete" for s in stages[-10:]):
+            novel_content = NovelDatabase.get_writer_content(current_session_id)
+            novel_content = format_novel_display(novel_content)
         
-        # 활성 단계는 내용 표시, 다른 단계는 상태만 표시
-        if stage.get("status") == "active":
-            display += f"\n\n{status_icon} **{stage['name']}**{consistency_indicator}\n"
-            display += f"```\n{stage.get('content', '')[-800:]}\n```"
-        else:
-            display += f"\n{status_icon} {stage['name']}{consistency_indicator}"
-    
-    return display
-
+        yield stages_markdown, novel_content, status or "🔄 처리 중...", current_session_id
 
-def get_active_sessions(language: str) -> List[Tuple[str, str]]:
+def get_active_sessions(language: str) -> List[str]:
     """활성 세션 목록 가져오기"""
-    try:
-        sessions = NovelDatabase.get_active_sessions()
-        
-        choices = []
-        for session in sessions:
-            created = datetime.fromisoformat(session['created_at'])
-            date_str = created.strftime("%Y-%m-%d %H:%M")
-            query_preview = session['user_query'][:50] + "..." if len(session['user_query']) > 50 else session['user_query']
-            label = f"[{date_str}] {query_preview} (Stage {session['current_stage']})"
-            choices.append((label, session['session_id']))
-        
-        return choices
-    except Exception as e:
-        logger.error(f"Error getting active sessions: {str(e)}")
-        return []
+    sessions = NovelDatabase.get_active_sessions()
+    return [f"{s['session_id'][:8]}... - {s['user_query'][:50]}... ({s['created_at']})" 
+            for s in sessions]
 
+def auto_recover_session(language: str) -> Tuple[Optional[str], str]:
+    """가장 최근 활성 세션 자동 복구"""
+    latest_session = NovelDatabase.get_latest_active_session()
+    if latest_session:
+        return latest_session['session_id'], f"세션 {latest_session['session_id'][:8]}... 복구됨"
+    return None, "복구할 세션이 없습니다."
 
 def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str, str, str], None, None]:
-    """세션 재개"""
+    """세션 재개 함수"""
     if not session_id:
-        if language == "Korean":
-            yield "", "", "❌ 세션을 선택해주세요.", None
-        else:
-            yield "", "", "❌ Please select a session.", None
+        yield "", "", "❌ 세션 ID가 없습니다.", session_id
         return
     
-    yield from process_query("", language, session_id)
-
+    # 드롭다운에서 세션 ID 추출
+    if "..." in session_id:
+        session_id = session_id.split("...")[0]
+    
+    session = NovelDatabase.get_session(session_id)
+    if not session:
+        yield "", "", "❌ 세션을 찾을 수 없습니다.", None
+        return
+    
+    # process_query를 통해 재개
+    yield from process_query(session['user_query'], session['language'], session_id)
 
-def auto_recover_session(language: str) -> Tuple[str, str]:
-    """자동 세션 복구"""
+def download_novel(novel_text: str, format_type: str, language: str, session_id: str) -> Optional[str]:
+    """소설 다운로드 파일 생성"""
+    if not novel_text or not session_id:
+        return None
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"novel_{session_id[:8]}_{timestamp}"
+    
     try:
-        latest_session = NovelDatabase.get_latest_active_session()
-        if latest_session:
-            if language == "Korean":
-                message = f"✅ 자동 복구: '{latest_session['user_query'][:30]}...' (Stage {latest_session['current_stage']})"
-            else:
-                message = f"✅ Auto recovered: '{latest_session['user_query'][:30]}...' (Stage {latest_session['current_stage']})"
-            return latest_session['session_id'], message
+        if format_type == "DOCX" and DOCX_AVAILABLE:
+            return export_to_docx(novel_text, filename, language)
         else:
-            return None, ""
+            return export_to_txt(novel_text, filename)
     except Exception as e:
-        logger.error(f"Error in auto recovery: {str(e)}")
-        return None, ""
+        logger.error(f"파일 생성 실패: {e}")
+        return None
 
+def format_stages_display(stages: List[Dict]) -> str:
+    """단계별 진행 상황 마크다운 포맷팅"""
+    markdown = "## 🎬 진행 상황\n\n"
+    for i, stage in enumerate(stages):
+        status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
+        markdown += f"{status_icon} **{stage['name']}**"
+        if stage.get('consistency_score', 0) > 0:
+            markdown += f" (일관성: {stage['consistency_score']:.1f}/10)"
+        markdown += "\n"
+        if stage['content']:
+            preview = stage['content'][:200] + "..." if len(stage['content']) > 200 else stage['content']
+            markdown += f"> {preview}\n\n"
+    return markdown
+
+def format_novel_display(novel_text: str) -> str:
+    """소설 내용 마크다운 포맷팅"""
+    if not novel_text:
+        return "아직 완성된 내용이 없습니다."
+    
+    # 페이지 구분 추가
+    pages = novel_text.split('\n\n')
+    formatted = "# 📖 완성된 소설\n\n"
+    
+    for i, page in enumerate(pages):
+        if page.strip():
+            formatted += f"### 페이지 {i+1}\n\n{page}\n\n---\n\n"
+    
+    return formatted
 
-def download_novel(novel_text: str, format: str, language: str, session_id: str = None) -> str:
-    """소설 다운로드"""
-    if not session_id:
-        logger.error("No session_id provided for download")
-        return None
+def export_to_docx(content: str, filename: str, language: str) -> str:
+    """DOCX 파일로 내보내기"""
+    doc = Document()
     
-    # 세션 정보 가져오기
-    session = NovelDatabase.get_session(session_id)
-    if not session:
-        logger.error(f"Session not found: {session_id}")
-        return None
+    # 제목 추가
+    title = doc.add_heading('AI 협업 소설', 0)
+    title.alignment = WD_ALIGN_PARAGRAPH.CENTER
     
-    # 완성된 소설 가져오기
-    complete_novel = NovelDatabase.get_writer_content(session_id)
-    if not complete_novel:
-        logger.error("No complete novel found")
-        return None
+    # 메타데이터
+    doc.add_paragraph(f"생성일: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    doc.add_paragraph(f"언어: {language}")
+    doc.add_page_break()
     
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    temp_dir = tempfile.gettempdir()
-    safe_filename = re.sub(r'[^\w\s-]', '', session['user_query'][:30]).strip()
+    # 본문 추가
+    paragraphs = content.split('\n\n')
+    for para in paragraphs:
+        if para.strip():
+            doc.add_paragraph(para.strip())
     
-    if format == "DOCX" and DOCX_AVAILABLE:
-        # DOCX 생성
-        doc = Document()
-        
-        # 제목 추가
-        title = doc.add_heading('AI 협업 소설' if language == 'Korean' else 'AI Collaborative Novel', 0)
-        
-        # 메타정보 추가
-        doc.add_paragraph(f"주제: {session['user_query']}" if language == 'Korean' else f"Theme: {session['user_query']}")
-        doc.add_paragraph(f"생성일: {datetime.now().strftime('%Y-%m-%d')}" if language == 'Korean' else f"Created: {datetime.now().strftime('%Y-%m-%d')}")
-        doc.add_paragraph(f"단어 수: {len(complete_novel.split())}" if language == 'Korean' else f"Word Count: {len(complete_novel.split())}")
-        doc.add_paragraph()
-        
-        # 소설 내용 추가
-        paragraphs = complete_novel.split('\n\n')
-        for para in paragraphs:
-            if para.strip():
-                doc.add_paragraph(para.strip())
-        
-        # 파일 저장
-        filename = f"Novel_{safe_filename}_{timestamp}.docx"
-        filepath = os.path.join(temp_dir, filename)
-        doc.save(filepath)
-        
-        return filepath
-    else:
-        # TXT 생성
-        filename = f"Novel_{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(f"AI 협업 소설\n" if language == 'Korean' else f"AI COLLABORATIVE NOVEL\n")
-            f.write("=" * 60 + "\n\n")
-            f.write(f"주제: {session['user_query']}\n" if language == 'Korean' else f"Theme: {session['user_query']}\n")
-            f.write(f"생성일: {datetime.now()}\n" if language == 'Korean' else f"Created: {datetime.now()}\n")
-            f.write(f"단어 수: {len(complete_novel.split())}\n" if language == 'Korean' else f"Word Count: {len(complete_novel.split())}\n")
-            f.write("=" * 60 + "\n\n")
-            f.write(complete_novel)
-        
-        return filepath
+    # 파일 저장
+    filepath = f"{filename}.docx"
+    doc.save(filepath)
+    return filepath
+
+def export_to_txt(content: str, filename: str) -> str:
+    """TXT 파일로 내보내기"""
+    filepath = f"{filename}.txt"
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(content)
+    return filepath
 
 
 # CSS 스타일