Update app.py

app.py

@@ -53,13 +53,13 @@ db_lock = threading.Lock()
 # 최적화된 단계 구성 (25단계로 압축 및 강화)
 OPTIMIZED_STAGES = [
     ("director", "🎬 감독자: 초기 기획 (웹 검색 포함)"),
-    ("critic", "📝 비평가: 기획 검토 (테마 및 일관성)"),
+    ("critic", "📝 비평가: 기획 검토 (철학적 깊이 및 일관성)"),
     ("director", "🎬 감독자: 수정된 마스터플랜"),
 ] + [
     (f"writer{i}", f"✍️ 작가 {i}: 초안 (페이지 {(i-1)*3+1}-{i*3})")
     for i in range(1, 11)
 ] + [
-    ("critic", "📝 비평가: 중간 검토 (일관성 및 테마 유지)"),
+    ("critic", "📝 비평가: 중간 검토 (철학적 깊이 및 일관성)"),
 ] + [
     (f"writer{i}", f"✍️ 작가 {i}: 수정본 (페이지 {(i-1)*3+1}-{i*3})")
     for i in range(1, 11)
@@ -81,6 +81,7 @@ class CharacterState:
     last_seen_chapter: int = 0
     description: str = ""
     role: str = ""
+    philosophical_stance: str = ""  # 추가: 캐릭터의 철학적 입장
 
 @dataclass
 class PlotPoint:
@@ -91,6 +92,7 @@ class PlotPoint:
     characters_involved: List[str]
     impact_level: int
     timestamp: str = ""
+    philosophical_implication: str = ""  # 추가: 사건의 철학적 함의
 
 @dataclass
 class TimelineEvent:
@@ -112,6 +114,7 @@ class ConsistencyTracker:
         self.locations: Dict[str, str] = {}
         self.established_facts: List[str] = []
         self.content_hashes: Dict[str, int] = {}  # 해시와 해당 챕터 번호를 저장
+        self.philosophical_themes: List[str] = []  # 추가: 철학적 주제 추적
 
     def register_character(self, character: CharacterState):
         """새 캐릭터 등록"""
@@ -175,8 +178,12 @@ class ConsistencyTracker:
         for char in active_chars:
             status = "생존" if char.alive else "사망"
             summary += f"• {char.name}: {status}"
-            if char.alive and 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:])})"
+            if char.philosophical_stance:
+                summary += f" (철학적 입장: {char.philosophical_stance})"
             summary += "\n"
         return summary
 
@@ -187,7 +194,10 @@ class ConsistencyTracker:
         if not recent_events:
             return "\n(아직 주요 사건이 없습니다.)\n"
         for event in recent_events[-3:]: # 최근 3개만 표시
-            summary += f"• [챕터 {event.chapter}] {event.description}\n"
+            summary += f"• [챕터 {event.chapter}] {event.description}"
+            if event.philosophical_implication:
+                summary += f"\n  → 철학적 함의: {event.philosophical_implication}"
+            summary += "\n"
         return summary
 
 
@@ -259,7 +269,8 @@ class NovelDatabase:
                     status TEXT DEFAULT 'active',
                     current_stage INTEGER DEFAULT 0,
                     final_novel TEXT,
-                    consistency_report TEXT
+                    consistency_report TEXT,
+                    philosophical_depth_score REAL DEFAULT 0.0
                 )
             ''')
             cursor.execute('''
@@ -273,6 +284,7 @@ class NovelDatabase:
                     word_count INTEGER DEFAULT 0,
                     status TEXT DEFAULT 'pending',
                     consistency_score REAL DEFAULT 0.0,
+                    philosophical_depth_score REAL DEFAULT 0.0,
                     created_at TEXT DEFAULT (datetime('now')),
                     updated_at TEXT DEFAULT (datetime('now')),
                     FOREIGN KEY (session_id) REFERENCES sessions(session_id),
@@ -290,6 +302,7 @@ class NovelDatabase:
                     injuries TEXT,
                     emotional_state TEXT,
                     description TEXT,
+                    philosophical_stance TEXT,
                     created_at TEXT DEFAULT (datetime('now')),
                     FOREIGN KEY (session_id) REFERENCES sessions(session_id)
                 )
@@ -325,17 +338,17 @@ class NovelDatabase:
     @staticmethod
     def save_stage(session_id: str, stage_number: int, stage_name: str,
                    role: str, content: str, status: str = 'complete',
-                   consistency_score: float = 0.0):
+                   consistency_score: float = 0.0, philosophical_depth_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 (?, ?, ?, ?, ?, ?, ?, ?)
+                INSERT INTO stages (session_id, stage_number, stage_name, role, content, word_count, status, consistency_score, philosophical_depth_score)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
                 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))
+                DO UPDATE SET content=?, word_count=?, status=?, stage_name=?, consistency_score=?, philosophical_depth_score=?, updated_at=datetime('now')
+            ''', (session_id, stage_number, stage_name, role, content, word_count, status, consistency_score, philosophical_depth_score,
+                  content, word_count, status, stage_name, consistency_score, philosophical_depth_score))
             cursor.execute(
                 "UPDATE sessions SET updated_at = datetime('now'), current_stage = ? WHERE session_id = ?",
                 (stage_number, session_id)
@@ -374,11 +387,11 @@ class NovelDatabase:
             return '\n\n'.join(all_content)
 
     @staticmethod
-    def update_final_novel(session_id: str, final_novel: str, consistency_report: str = ""):
+    def update_final_novel(session_id: str, final_novel: str, consistency_report: str = "", philosophical_depth_score: float = 0.0):
         with NovelDatabase.get_db() as conn:
             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)
+                "UPDATE sessions SET final_novel = ?, status = 'complete', updated_at = datetime('now'), consistency_report = ?, philosophical_depth_score = ? WHERE session_id = ?",
+                (final_novel, consistency_report, philosophical_depth_score, session_id)
             )
             conn.commit()
 
@@ -406,9 +419,9 @@ class NovelWritingSystem:
         """API 헤더 생성"""
         return {"Authorization": f"Bearer {self.token}", "Content-Type": "application/json"}
 
-    # --- 프롬프트 생성 함수들 (Thematic Guardian 개념 통합) ---
+    # --- 프롬프트 생성 함수들 (AI 제약 제거, 철학적 깊이 강화) ---
     def create_director_initial_prompt(self, user_query: str, language: str) -> str:
-        """감독자 초기 기획 프롬프트 (웹 검색 및 테마 제약 조건 강화)"""
+        """감독자 초기 기획 프롬프트 (AI 강제성 완전 제거, 철학적 깊이 강화)"""
         search_results_str = ""
         if self.web_search.enabled:
             queries = [f"{user_query} novel setting", f"{user_query} background information"]
@@ -421,67 +434,185 @@ class NovelWritingSystem:
                 "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": "창의적이고 깊이 있는 소설이 될 수 있도록 상세하게 기획하세요."
+                "theme_section": """1. **주제와 철학적 탐구**
+   - 핵심 주제와 메시지 (사용자 의도를 깊이 있게 해석)
+   - 탐구할 인간의 근원적 문제 (예: 정체성, 자유의지, 사랑과 증오, 삶과 죽음, 선과 악의 경계 등)
+   - 장르 및 분위기 (철학적 깊이를 담을 수 있는 톤)""",
+                "char_section": """2. **주요 등장인물** (3-5명, 각자의 철학적 입장과 ���적 갈등이 뚜렷해야 함)
+   | 이름 | 역할 | 성격 | 배경 | 핵심 욕망 | 내적 갈등 | 철학적 입장 |
+   - 각 인물은 서로 다른 가치관과 세계관을 대표해야 함
+   - 인물 간의 갈등은 단순한 대립이 아닌 철학적 충돌이어야 함""",
+                "setting_section": """3. **배경 설정**
+   - 시공간적 배경 (주제를 효과적으로 탐구할 수 있는 환경)
+   - 사회적/문화적 환경
+   - 상징적 공간들 (각 공간이 철학적 의미를 담아야 함)""",
+                "plot_section": """4. **플롯 구조** (10개 파트, 각 3페이지 분량)
+   | 파트 | 페이지 | 주요 사건 | 감정의 흐름 | 철학적 탐구 주제 | 인물의 내적 변화 |
+   - 각 파트는 외적 사건과 내적 성찰이 균형을 이루어야 함
+   - 갈등은 점진적으로 심화되며, 인물들의 세계관이 시험받아야 함""",
+                "guideline_section": """5. **작가별 지침**
+   - 문체: 간결하면서도 함축적이고 시적인 문체
+   - 시점: 내면 묘사에 유리한 시점 선택
+   - 상징과 은유: 주제를 강화하는 반복적 이미지나 상징
+   - 대화: 철학적 깊이를 담되 자연스러운 대화""",
+                "philosophical_principle": """⚠️ 핵심 창작 원칙: 철학적 깊이 ⚠️
+이 소설은 단순한 사건의 나열이 아닙니다. 모든 서사의 기저에는 **인간의 근원적 문제에 대한 철학적 사유**가 반드시 깔려 있어야 합니다.
+- 등장인물들은 각자의 신념과 가치관을 가지고 갈등하며, 이를 통해 독자가 삶의 의미를 성찰하게 해야 합니다.
+- 결말은 단순한 해결이 아닌, 더 깊은 질문을 남기는 열린 결말이어야 합니다.
+- 모든 장면과 대화는 주제를 심화시키는 역할을 해야 합니다.""",
+                "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."
+                "theme_section": """1. **Theme and Philosophical Inquiry**
+   - Core theme and message (Deep interpretation of user's intent)
+   - Fundamental human problems to explore (e.g., identity, free will, love and hate, life and death, boundaries of good and evil)
+   - Genre and atmosphere (Tone that can contain philosophical depth)""",
+                "char_section": """2. **Main Characters** (3-5, each with distinct philosophical positions and internal conflicts)
+   | Name | Role | Personality | Background | Core Desire | Internal Conflict | Philosophical Stance |
+   - Each character must represent different values and worldviews
+   - Conflicts between characters should be philosophical clashes, not simple oppositions""",
+                "setting_section": """3. **Setting**
+   - Time and place (Environment that effectively explores the theme)
+   - Social/cultural environment
+   - Symbolic spaces (Each space should carry philosophical meaning)""",
+                "plot_section": """4. **Plot Structure** (10 parts, ~3 pages each)
+   | Part | Pages | Main Events | Emotional Flow | Philosophical Theme | Character's Internal Change |
+   - Each part must balance external events with internal reflection
+   - Conflicts should deepen progressively, testing characters' worldviews""",
+                "guideline_section": """5. **Writer Guidelines**
+   - Style: Concise yet implicit and poetic prose
+   - POV: Choose perspective favorable for internal portrayal
+   - Symbols and metaphors: Recurring images or symbols that reinforce the theme
+   - Dialogue: Natural yet philosophically rich""",
+                "philosophical_principle": """⚠️ CORE CREATIVE PRINCIPLE: PHILOSOPHICAL DEPTH ⚠️
+This is not a mere sequence of events. The foundation of all narrative must be **philosophical inquiry into fundamental human problems**.
+- Characters must conflict with their own beliefs and values, leading readers to reflect on the meaning of life.
+- The ending should not be a simple resolution but an open ending that leaves deeper questions.
+- Every scene and dialogue must serve to deepen the theme.""",
+                "final_instruction": "Following these principles, plan a profound novel that explores the essence of human existence."
             }
         }
         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']}"
+        
+        # 웹 검색 결과 포맷팅
+        search_section = ""
+        if search_results_str:
+            search_section = f"\n\n**웹 검색 참고 자료:**\n{search_results_str}\n" if language == "Korean" else f"\n\n**Web Search Reference:**\n{search_results_str}\n"
+        
+        return f"""{p['title']}
+
+{p['philosophical_principle']}
+
+**{p['user_theme']}:** {user_query}
+{search_section}
+{p['plan_instruction']}
+
+{p['theme_section']}
+
+{p['char_section']}
+
+{p['setting_section']}
+
+{p['plot_section']}
+
+{p['guideline_section']}
+
+---
+{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": "위 항목들을 중심으로 구체적인 문제점과 개선안을 제시하세요."
+                "title": "당신은 문학 비평가입니다. 감독자의 소설 기획을 '철학적 깊이'와 '기술적 일관성' 관점에서 날카롭게 검토하세요.",
+                "theme_check": f"""**1. 철학적 깊이 검토 (가장 중요)**
+   - **원래 주제:** '{user_query}'
+   - 기획안이 인간의 근원적 문제를 진지하게 탐구하고 있습니까?
+   - 등장인물들이 각자의 철학적 입장을 가지고 있으며, 그들의 갈등이 단순한 대립이 아닌 가치관의 충돌입니까?
+   - 플롯이 외적 사건에만 치중하지 않고 내적 성찰과 균형을 이루고 있습니까?
+   - 결말이 섣부른 해결이 아닌, 독자에게 깊은 사유를 남기는 방향입니까?""",
+                "consistency_check": """**2. 기술적 일관성 검토**
+   - 캐릭터 설정의 모순이나 비현실적인 부분
+   - 플롯의 논리적 허점이나 개연성 부족
+   - 시간선이나 공간 설정의 오류
+   - 주제와 플롯, 캐릭터가 유기적으로 연결되어 있는가""",
+                "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."
+                "title": "You are a literary critic. Sharply review the director's plan from perspectives of 'Philosophical Depth' and 'Technical Consistency'.",
+                "theme_check": f"""**1. Philosophical Depth Review (Most Important)**
+   - **Original Theme:** '{user_query}'
+   - Does the plan seriously explore fundamental human problems?
+   - Do characters have their own philosophical positions, and are their conflicts clashes of values rather than simple oppositions?
+   - Does the plot balance external events with internal reflection?
+   - Is the ending aimed at leaving readers with deep contemplation rather than premature resolution?""",
+                "consistency_check": """**2. Technical Consistency Review**
+   - Character setting contradictions or unrealistic aspects
+   - Plot logical flaws or lack of plausibility
+   - Timeline or spatial setting errors
+   - Are theme, plot, and characters organically connected?""",
+                "instruction": "Provide specific problems and improvement directions based on above. Especially point out areas lacking philosophical depth and provide concrete alternatives."
             }
         }
         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']}"
+        return f"""{p['title']}
+
+**감독자 기획:**
+{director_plan}
+
+---
+**검토 항목:**
+{p['theme_check']}
+
+{p['consistency_check']}
+
+{p['instruction']}"""
 
     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}
+        """감독자 수정 프롬프트"""
+        lang_prompts = {
+            "Korean": f"""감독자로서 비평가의 피드백을 반영하여 소설 기획을 수정합니다.
+
+**원래 주제:** {user_query}
+
+**초기 기획:**
+{initial_plan}
+
+**비평가 피드백:**
+{critic_feedback}
+
+**수정 지침:**
+1. 비평가가 지적한 모든 철학적 깊이 부족과 기술적 문제를 해결하세요.
+2. 특히 인물들의 내적 갈등과 철학적 입장을 더욱 명확하고 깊이 있게 설정하세요.
+3. 각 파트별로 탐구할 철학적 주제를 구체적으로 명시하세요.
+4. 10명의 작가가 혼동 없이 작업할 수 있도록 명확하고 상세한 최종 마스터플랜을 작성하세요.
 
-        **수정 지침:**
-        - 비평가가 지적한 모든 일관성 문제와 주제 이탈 문제를 해결하세요.
-        - **핵심 제약 조건**을 다시 한번 상기하고, 소설 전체가 '불안'과 '상실감'의 톤을 유지하도록 플롯을 구체화하세요.
-        - 10명의 작가가 혼동 없이 작업할 수 있도록 명확하고 상세한 최종 마스터플랜을 작성하세요.
-        """
+모든 수정사항이 '인간의 근원적 문제에 대한 철학적 탐구'라는 핵심 원칙에 부합해야 합니다.""",
+            "English": f"""As director, revise the novel plan reflecting the critic's feedback.
+
+**Original Theme:** {user_query}
+
+**Initial Plan:**
+{initial_plan}
+
+**Critic's Feedback:**
+{critic_feedback}
+
+**Revision Guidelines:**
+1. Resolve all philosophical depth deficiencies and technical issues pointed out by the critic.
+2. Especially clarify and deepen characters' internal conflicts and philosophical positions.
+3. Specifically state the philosophical themes to explore in each part.
+4. Create a clear and detailed final masterplan that 10 writers can work with without confusion.
+
+All revisions must align with the core principle of 'philosophical inquiry into fundamental human problems'."""
+        }
+        return lang_prompts[language]
 
     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
         
@@ -490,69 +621,210 @@ class NovelWritingSystem:
                 "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": "창의적이면서도 주제와 일관성을 절대 잃지 마십시오."
+                "guidelines": f"""**작성 지침:**
+1. **분량**: 1,400-1,500 단어 (약 3페이지)
+2. **연결성**: 이전 내용과 자연스럽게 연결되면서도 새로운 깊이를 더하세요
+3. **일관성**: 캐릭터의 성격, 철학적 입장, 말투 등을 일관되게 유지하세요
+4. **균형**: 외적 사건과 내적 성찰의 균형을 맞추세요 (50:50 비율 권장)
+5. **대화**: 캐릭터의 철학적 입장이 자연스럽게 드러나는 의미 있는 대화를 포함하세요""",
+                "philosophical_reminder": f"""⭐ 철학적 깊이 리마인더 ⭐
+- 이 파트에서 탐구해야 할 철학적 주제를 염두에 두고 작성하세요
+- 모든 장면은 단순한 사건 진행이 아닌, 인물의 내면 탐구와 성찰의 기회여야 합니다
+- 독자가 스스로 생각하고 질문하게 만드는 열린 표현을 사용하세요
+- 상징과 은유를 통해 주제를 심화시키세요""",
+                "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."
+                "guidelines": f"""**Writing Guidelines:**
+1. **Length**: 1,400-1,500 words (approximately 3 pages)
+2. **Connectivity**: Connect naturally with previous content while adding new depth
+3. **Consistency**: Maintain character personality, philosophical positions, speech patterns consistently
+4. **Balance**: Balance external events with internal reflection (50:50 ratio recommended)
+5. **Dialogue**: Include meaningful dialogue that naturally reveals characters' philosophical positions""",
+                "philosophical_reminder": f"""⭐ Philosophical Depth Reminder ⭐
+- Keep in mind the philosophical themes to explore in this part
+- Every scene should be an opportunity for character introspection and reflection, not just plot progression
+- Use open expressions that make readers think and question
+- Deepen the theme through symbols and metaphors""",
+                "final_instruction": "Remember that your part plays an important role in adding philosophical depth to the overall novel. Write with soul."
             }
         }
         
         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']}"
+        return f"""{p['title']}
+
+**{p['plan']}:**
+{director_plan}
+
+{consistency_info}
+
+**{p['prev_summary']}:**
+{previous_content_summary}
+
+---
+{p['guidelines']}
+
+{p['philosophical_reminder']}
+
+---
+{p['final_instruction']}"""
 
     def create_critic_consistency_prompt(self, all_content: str, user_query: str, language: str) -> str:
-        """비평가 중간 검토 프롬프트 (테마 검토 강화)"""
-        return f"""당신은 일관성 검토 전문 비평가입니다. 지금까지 작성된 내용을 검토하세요.
-        
-        **원래 주제:** {user_query}
-        **현재까지 작성된 내용 (최근 3000자):**\n{all_content[-3000:]}
+        """비평가 중간 검토 프롬프트"""
+        lang_prompts = {
+            "Korean": f"""당신은 일관성과 철학적 깊이를 검토하는 전문 비평가입니다.
+
+**원래 주제:** {user_query}
+
+**현재까지 작성된 내용 (최근 3000자):**
+{all_content[-3000:]}
+
+**검토 항목:**
+1. **철학적 깊이 (가장 중요):** 
+   - 각 파트가 철학적 탐구를 제대로 수행하고 있는가?
+   - 인물들의 내적 갈등과 성찰이 충분히 ��사되고 있는가?
+   - 주제가 점진적으로 심화되고 있는가?
+
+2. **기술적 일관성:** 
+   - 캐릭터의 성격, 말투, 행동이 일관되는가?
+   - 시간선과 공간 설정에 오류가 없는가?
+   - 플롯이 논리적으로 진행되고 있는가?
+
+3. **문체와 톤:** 
+   - 전체적인 문체와 분위기가 일관되는가?
+   - 철학적 깊이에 맞는 문체를 유지하고 있는가?
+
+**결과:** 발견된 문제점과 각 작가별 구체적인 수정 제안을 제시하세요.""",
+            "English": f"""You are a professional critic reviewing consistency and philosophical depth.
 
-        **검토 항목:**
-        1. **주제 일관성 (가장 중요):** 내용이 원래 주제의 어두운 감정선에서 벗어나지 않았는지 확인하고, 벗어났다면 수정 방향을 제시하세요.
-        2. **기술적 일관성:** 캐릭터, 플롯, 설정의 연속성과 논리적 오류를 찾아내세요.
-        3. **반복 내용:** 의미적으로 중복되는 장면이나 표현이 없는지 확인하세요.
+**Original Theme:** {user_query}
 
-        **결과:** 발견된 문제점과 구체적인 수정 제안을 목록으로 제시하세요.
-        """
+**Content Written So Far (last 3000 characters):**
+{all_content[-3000:]}
+
+**Review Items:**
+1. **Philosophical Depth (Most Important):**
+   - Is each part properly conducting philosophical inquiry?
+   - Are characters' internal conflicts and reflections sufficiently portrayed?
+   - Is the theme progressively deepening?
+
+2. **Technical Consistency:**
+   - Are character personalities, speech patterns, and behaviors consistent?
+   - Are there no errors in timeline and spatial settings?
+   - Is the plot progressing logically?
+
+3. **Style and Tone:**
+   - Is the overall style and atmosphere consistent?
+   - Is a style appropriate for philosophical depth maintained?
+
+**Result:** Present discovered problems and specific revision suggestions for each writer."""
+        }
+        return lang_prompts[language]
 
     def create_writer_revision_prompt(self, writer_number: int, initial_content: str, consistency_feedback: str, language: str) -> str:
         """작가 수정 프롬프트"""
-        return f"""작가 {writer_number}번으로서 비평가의 피드백을 반영하여 내용을 수정하세요.
+        lang_prompts = {
+            "Korean": f"""작가 {writer_number}번으로서 비평가의 피드백을 반영하여 내용을 수정하세요.
+
+**초기 작성 내용:**
+{initial_content}
 
-        **초기 작성 내용:**\n{initial_content}
-        **비평가 피드백:**\n{consistency_feedback}
+**비평가 피드백:**
+{consistency_feedback}
 
-        **수정 지침:**
-        - 지적된 모든 주제 이탈 및 일관성 문제를 해결하세요.
-        - 분량(1,400-1,500 단어)을 유지하면서 내용의 질을 높이세요.
-        - 수정된 최종 버전을 제시하세요.
-        """
+**수정 지침:**
+1. 지적된 모든 철학적 깊이 부족과 일관성 문제를 해결하세요.
+2. 특히 내적 성찰과 철학적 탐구가 부족하다고 지적된 부분을 보강하세요.
+3. 분량(1,400-1,500 단어)을 유지하면서 내용의 깊이를 더하세요.
+4. 수정은 단순한 추가가 아닌, 전체적인 재구성을 통해 완성도를 높이세요.
+
+수정된 최종 버전만 제시하세요.""",
+            "English": f"""As Writer {writer_number}, revise the content reflecting the critic's feedback.
+
+**Initial Content:**
+{initial_content}
+
+**Critic's Feedback:**
+{consistency_feedback}
+
+**Revision Guidelines:**
+1. Resolve all pointed out philosophical depth deficiencies and consistency issues.
+2. Especially reinforce parts pointed out as lacking internal reflection and philosophical inquiry.
+3. Add depth to content while maintaining length (1,400-1,500 words).
+4. Improve completion through overall restructuring, not simple additions.
+
+Present only the revised final version."""
+        }
+        return lang_prompts[language]
 
     def create_critic_final_prompt(self, complete_novel: str, language: str) -> str:
         """최종 비평가 검토 및 보고서 작성 프롬프트"""
-        return f"""완성된 소설의 최종 일관성 및 완성도에 대한 종합 보고서를 작성하세요.
+        lang_prompts = {
+            "Korean": f"""완성된 소설의 최종 평가 보고서를 작성하세요.
+
+**완성된 소설 (마지막 2000자):**
+{complete_novel[-2000:]}
+
+**보고서 포함 항목:**
+
+1. **철학적 깊이 평가 (40점)**
+   - 인간의 근원적 문제 탐구 수준 (10점)
+   - 캐릭터의 내적 갈등과 성찰의 깊이 (10점)
+   - 주제의 일관성과 발전 (10점)
+   - 독자에게 남기는 사유의 여지 (10점)
+
+2. **기술적 완성도 평가 (30점)**
+   - 플롯의 논리성과 개연성 (10점)
+   - 캐릭터의 일관성 (10점)
+   - 문체와 톤의 일관성 (10점)
+
+3. **창의성과 독창성 (20점)**
+   - 주제 해석의 참신함 (10점)
+   - 표현과 구성의 독창성 (10점)
+
+4. **종합 평가 (10점)**
+   - 전체적인 작품성과 완성도
+
+**총점: /100점**
+
+각 항목에 대한 구체적인 평가와 함께, 작품의 강점과 약점, 그리고 독자에게 미칠 영향에 대해 서술하세요.""",
+            "English": f"""Create a final evaluation report for the completed novel.
+
+**Completed Novel (last 2000 characters):**
+{complete_novel[-2000:]}
+
+**Report Items:**
+
+1. **Philosophical Depth Evaluation (40 points)**
+   - Level of exploring fundamental human problems (10 points)
+   - Depth of characters' internal conflicts and reflection (10 points)
+   - Theme consistency and development (10 points)
+   - Room for reader contemplation (10 points)
+
+2. **Technical Completion Evaluation (30 points)**
+   - Plot logic and plausibility (10 points)
+   - Character consistency (10 points)
+   - Style and tone consistency (10 points)
+
+3. **Creativity and Originality (20 points)**
+   - Freshness of theme interpretation (10 points)
+   - Originality of expression and composition (10 points)
 
-        **완성된 소설 (마지막 2000자):**\n{complete_novel[-2000:]}
+4. **Overall Evaluation (10 points)**
+   - Overall artistry and completion
 
-        **보고서 포함 항목:**
-        1. **전체 일관성 평가:** 캐릭터, 플롯, 설정, 주제 유지에 대한 점수(1-10)와 총평.
-        2. **최종 발견된 문제점:** 남아있는 사소한 문제점들.
-        3. **성공 요소:** 특히 잘 유지된 일관성 부분이나 주제 표현이 뛰어난 부분.
-        4. **최종 평가:** 소설의 전반적인 완성도와 독자에게 미칠 영향에 대한 평가.
-        """
+**Total Score: /100**
 
-    # --- LLM 호출 함수들 ---
+Describe specific evaluations for each item, along with the work's strengths and weaknesses, and its impact on readers."""
+        }
+        return lang_prompts[language]
+
+    # --- LLM 호출 함수들 (스트리밍 완벽 유지) ---
     def call_llm_sync(self, messages: List[Dict[str, str]], role: str, language: str) -> str:
         """LLM 동기식 호출 (요약 등 내부용)"""
         full_content = ""
@@ -563,7 +835,7 @@ class NovelWritingSystem:
         return full_content
 
     def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, language: str) -> Generator[str, None, None]:
-        """LLM 스트리밍 호출 (완전한 에러 처리 및 디버깅)"""
+        """LLM 스트리밍 호출 (완벽한 스트리밍 유지)"""
         try:
             system_prompts = self.get_system_prompts(language)
             full_messages = [{"role": "system", "content": system_prompts.get(role, "You are a helpful assistant.")}, *messages]
@@ -582,7 +854,6 @@ class NovelWritingSystem:
             
             logger.info(f"[{role}] API 스트리밍 시작")
             
-            # API 호출
             response = requests.post(
                 self.api_url, 
                 headers=self.create_headers(), 
@@ -591,7 +862,6 @@ class NovelWritingSystem:
                 timeout=180
             )
             
-            # 상태 코드 확인
             if response.status_code != 200:
                 logger.error(f"API 응답 오류: {response.status_code}")
                 logger.error(f"응답 내용: {response.text[:500]}")
@@ -599,42 +869,36 @@ class NovelWritingSystem:
                 return
             
             response.raise_for_status()
-        
-        # 스트리밍 처리
+            
+            # 스트리밍 처리 - 실시간으로 UI에 반영
             buffer = ""
             total_content = ""
             chunk_count = 0
-            error_count = 0
-        
+            
             for line in response.iter_lines():
                 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: " 제거
-                
-                # 스트림 종료 확인
+                    data_str = line_str[6:]
+                    
                     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}")
@@ -642,7 +906,6 @@ class NovelWritingSystem:
                             return
                         continue
                     
-                    # delta에서 content 추출
                     delta = choices[0].get("delta", {})
                     content = delta.get("content", "")
                     
@@ -651,25 +914,20 @@ class NovelWritingSystem:
                         total_content += content
                         chunk_count += 1
                         
-                        # 100자 또는 줄바꿈마다 yield
-                        if len(buffer) >= 100 or '\n' in buffer:
+                        # 50자 또는 줄바꿈마다 즉시 yield (스트리밍 효과 극대화)
+                        if len(buffer) >= 50 or '\n' in buffer:
                             yield buffer
                             buffer = ""
-                            time.sleep(0.01)  # UI 업데이트를 위한 짧은 대기
+                            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
+                    logger.error(f"청크 처리 오류: {str(e)}")
                     continue
             
             # 남은 버퍼 처리
             if buffer:
                 yield buffer
             
-        # 결과 확인
             if chunk_count == 0:
                 logger.error(f"[{role}] 콘텐츠가 전혀 수신되지 않음")
                 yield "❌ API로부터 응답을 받지 못했습니다."
@@ -686,22 +944,18 @@ class NovelWritingSystem:
             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]:
-        """역할별 시스템 프롬프트 생성"""
+        """역할별 시스템 프롬프트 생성 (철학적 깊이 강조)"""
         base_prompts = {
             "Korean": {
-                "director": "당신은 창의적이고 체계적인 소설 기획 전문가입니다. 흥미롭고 일관성 있는 스토리를 설계하세요.",
-                "critic": "당신은 일관성 검토 전문 비평가입니다. 캐릭터, 플롯, 설정의 일관성을 철저히 점검하고 개선방안을 제시하세요.",
-                "writer_base": "당신은 전문 소설 작가입니다. 주어진 지침에 따라 몰입감 있고 일관성 있는 내용을 작성하세요."
+                "director": "당신은 인간의 본질을 탐구하는 철학적 소설을 기획하는 문학 감독자입니다. 깊이 있고 의미 있는 작품을 만드세요.",
+                "critic": "당신은 작품의 철학적 깊이와 기술적 완성도를 날카롭게 평가하는 문학 비평가입니다. 작품이 인간의 근원적 문제를 제대로 탐구하고 있는지 엄격하게 검토하세요.",
+                "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.",
-                "writer_base": "You are a professional novel writer. Write immersive and consistent content according to the given guidelines."
+                "director": "You are a literary director planning philosophical novels that explore human nature. Create profound and meaningful works.",
+                "critic": "You are a literary critic who sharply evaluates philosophical depth and technical completion. Strictly review whether the work properly explores fundamental human problems.",
+                "writer_base": "You are a professional novelist who delicately portrays human inner life. Balance external events with internal reflection, and write sentences that leave deep resonance with readers."
             }
         }
         
@@ -709,21 +963,24 @@ class NovelWritingSystem:
         
         # 작가별 특수 프롬프트
         if language == "Korean":
-            prompts["writer1"] = "당신은 소설의 매력적인 시작을 담당하는 작가입니다. 독자를 사로잡는 도입부를 만��세요."
-            prompts["writer10"] = "당신은 완벽한 결말을 만드는 작가입니다. 독자에게 깊은 여운을 남기는 마무리를 하세요."
+            prompts["writer1"] = "당신은 독자를 철학적 여정으로 이끄는 도입부를 쓰는 작가입니다. 첫 문장부터 독자의 사고를 자극하세요."
+            prompts["writer5"] = "당신은 갈등이 최고조에 달하는 중반부를 담당하는 작가입니다. 인물들의 가치관이 충돌하는 순간을 깊이 있게 그려내세요."
+            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."
+            prompts["writer1"] = "You are a writer who creates openings that lead readers on philosophical journeys. Stimulate readers' thinking from the first sentence."
+            prompts["writer5"] = "You are a writer handling the middle section where conflict reaches its peak. Deeply portray moments when characters' values clash."
+            prompts["writer10"] = "You are a writer who creates resonant endings. Don't resolve all conflicts; leave readers with something to think about."
         
-        # writer2-9는 기본 프롬프트 사용
+        # writer2-4, 6-9는 기본 프롬프트 사용
         for i in range(2, 10):
-            prompts[f"writer{i}"] = prompts["writer_base"]
+            if i not in [1, 5, 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:
             resume_from_stage = 0
             if session_id:
@@ -741,51 +998,80 @@ class NovelWritingSystem:
             stages = []
             if resume_from_stage > 0:
                 stages = [{
-                    "name": s['stage_name'], "status": s['status'], "content": s.get('content', ''),
-                    "consistency_score": s.get('consistency_score', 0.0)
+                    "name": s['stage_name'], 
+                    "status": s['status'], 
+                    "content": s.get('content', ''),
+                    "consistency_score": s.get('consistency_score', 0.0),
+                    "philosophical_depth_score": s.get('philosophical_depth_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,
+                        "philosophical_depth_score": 0.0
+                    })
                 else:
                     stages[stage_idx]["status"] = "active"
 
                 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):
                     stage_content += chunk
                     stages[stage_idx]["content"] = stage_content
-                    yield "", stages, self.current_session_id
+                    yield "", stages, self.current_session_id  # 실시간 UI 업데이트
 
+                # 일관성 및 철학적 깊이 점수 계산
                 consistency_score = 0.0
+                philosophical_depth_score = 0.0
+                
                 if role.startswith("writer"):
                     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)
+                    
+                    # 철학적 깊이 간단 평가 (내적 성찰 관련 키워드 빈도)
+                    philosophical_keywords = ['생각', '의미', '존재', '삶', '죽음', '자유', '선택', '고민', '성찰', '깨달', 
+                                            'think', 'mean', 'exist', 'life', 'death', 'free', 'choice', 'reflect', 'realize']
+                    keyword_count = sum(1 for keyword in philosophical_keywords if keyword in stage_content.lower())
+                    philosophical_depth_score = min(10, keyword_count * 0.5)
+                    
                     stages[stage_idx]["consistency_score"] = consistency_score
+                    stages[stage_idx]["philosophical_depth_score"] = philosophical_depth_score
 
                 stages[stage_idx]["status"] = "complete"
                 NovelDatabase.save_stage(
                     self.current_session_id, stage_idx, stage_name, role,
-                    stage_content, "complete", consistency_score
+                    stage_content, "complete", consistency_score, philosophical_depth_score
                 )
                 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
+            
+            # 최종 철학적 깊이 점수 추출
+            philosophical_score_match = re.search(r'철학적 깊이 평가.*?(\d+)점', final_report)
+            philosophical_depth_total = float(philosophical_score_match.group(1)) if philosophical_score_match else 0.0
+            
+            NovelDatabase.update_final_novel(self.current_session_id, final_novel, final_report, philosophical_depth_total)
+            yield f"✅ 소설 완성! 총 {len(final_novel.split())}단어, 철학적 깊이 점수: {philosophical_depth_total}/40", stages, self.current_session_id
 
         except Exception as e:
             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)
         if stage_idx == 1:
@@ -795,23 +1081,23 @@ class NovelWritingSystem:
 
         master_plan = stages[2]["content"]
         
-        if 3 <= stage_idx <= 12: # 작가 초안
+        if 3 <= stage_idx <= 12:  # 작가 초안
             writer_num = stage_idx - 2
             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: # 비평가 중간 검토
+        if stage_idx == 13:  # 비평가 중간 검토
             all_content = self.get_all_content(stages, stage_idx)
             return self.create_critic_consistency_prompt(all_content, query, language)
             
-        if 14 <= stage_idx <= 23: # 작가 수정
+        if 14 <= stage_idx <= 23:  # 작가 수정
             writer_num = stage_idx - 13
             initial_content = stages[2 + writer_num]["content"]
             feedback = stages[13]["content"]
             return self.create_writer_revision_prompt(writer_num, initial_content, feedback, language)
         
-        if stage_idx == 24: # 최종 검토
+        if stage_idx == 24:  # 최종 검토
             complete_novel = self.get_all_writer_content(stages)
             return self.create_critic_final_prompt(complete_novel, language)
         
@@ -822,9 +1108,9 @@ class NovelWritingSystem:
         if not content.strip():
             return "이전 내용이 없습니다." if language == "Korean" else "No previous content."
         
-        prompt_text = "다음 소설 내용을 3~5개의 핵심적인 문장으로 요약해줘. 다음 작가가 이야기를 이어가는 데 필요한 핵심 정보(등장인물의 현재 상황, 감정, 마지막 사건)를 포함해야 해."
+        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)."
+            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, internal conflicts, and the last major event)."
         
         summary_prompt = f"{prompt_text}\n\n---\n{content[-2000:]}"
         try:
@@ -915,7 +1201,7 @@ def download_novel(novel_text: str, format_type: str, language: str, session_id:
     
     try:
         if format_type == "DOCX" and DOCX_AVAILABLE:
-            return export_to_docx(novel_text, filename, language)
+            return export_to_docx(novel_text, filename, language, session_id)
         else:
             return export_to_txt(novel_text, filename)
     except Exception as e:
@@ -928,8 +1214,16 @@ def format_stages_display(stages: List[Dict]) -> str:
     for i, stage in enumerate(stages):
         status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
         markdown += f"{status_icon} **{stage['name']}**"
+        
+        # 점수 표시
+        scores = []
         if stage.get('consistency_score', 0) > 0:
-            markdown += f" (일관성: {stage['consistency_score']:.1f}/10)"
+            scores.append(f"일관성: {stage['consistency_score']:.1f}/10")
+        if stage.get('philosophical_depth_score', 0) > 0:
+            scores.append(f"철학적 깊이: {stage['philosophical_depth_score']:.1f}/10")
+        if scores:
+            markdown += f" ({', '.join(scores)})"
+        
         markdown += "\n"
         if stage['content']:
             preview = stage['content'][:200] + "..." if len(stage['content']) > 200 else stage['content']
@@ -951,10 +1245,13 @@ def format_novel_display(novel_text: str) -> str:
     
     return formatted
 
-def export_to_docx(content: str, filename: str, language: str) -> str:
+def export_to_docx(content: str, filename: str, language: str, session_id: str) -> str:
     """DOCX 파일로 내보내기"""
     doc = Document()
     
+    # 세션 정보 가져오기
+    session = NovelDatabase.get_session(session_id)
+    
     # 제목 추가
     title = doc.add_heading('AI 협업 소설', 0)
     title.alignment = WD_ALIGN_PARAGRAPH.CENTER
@@ -962,6 +1259,10 @@ def export_to_docx(content: str, filename: str, language: str) -> str:
     # 메타데이터
     doc.add_paragraph(f"생성일: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
     doc.add_paragraph(f"언어: {language}")
+    if session:
+        doc.add_paragraph(f"주제: {session['user_query']}")
+        if session.get('philosophical_depth_score'):
+            doc.add_paragraph(f"철학적 깊이 점수: {session['philosophical_depth_score']}/40")
     doc.add_page_break()
     
     # 본문 추가
@@ -983,38 +1284,51 @@ def export_to_txt(content: str, filename: str) -> str:
     return filepath
 
 
-# CSS 스타일
+# CSS 스타일 (철학적 테마에 맞게 색상 조정)
 custom_css = """
 .gradio-container {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
     min-height: 100vh;
 }
 
 .main-header {
-    background-color: rgba(255, 255, 255, 0.1);
+    background-color: rgba(255, 255, 255, 0.05);
     backdrop-filter: blur(10px);
     padding: 30px;
     border-radius: 12px;
     margin-bottom: 30px;
     text-align: center;
     color: white;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.philosophy-note {
+    background-color: rgba(255, 215, 0, 0.1);
+    border-left: 4px solid #ffd700;
+    padding: 15px;
+    margin: 20px 0;
+    border-radius: 8px;
+    color: #ffd700;
+    font-style: italic;
 }
 
 .input-section {
-    background-color: rgba(255, 255, 255, 0.1);
+    background-color: rgba(255, 255, 255, 0.08);
     backdrop-filter: blur(10px);
     padding: 20px;
     border-radius: 12px;
     margin-bottom: 20px;
+    border: 1px solid rgba(255, 255, 255, 0.1);
 }
 
 .session-section {
-    background-color: rgba(255, 255, 255, 0.1);
+    background-color: rgba(255, 255, 255, 0.08);
     backdrop-filter: blur(10px);
     padding: 15px;
     border-radius: 8px;
     margin-top: 20px;
     color: white;
+    border: 1px solid rgba(255, 255, 255, 0.1);
 }
 
 #stages-display {
@@ -1023,14 +1337,18 @@ custom_css = """
     border-radius: 12px;
     max-height: 600px;
     overflow-y: auto;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
 }
 
 #novel-output {
     background-color: rgba(255, 255, 255, 0.95);
     padding: 30px;
     border-radius: 12px;
-    max-height: 400px;
+    max-height: 600px;
     overflow-y: auto;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    font-family: 'Georgia', serif;
+    line-height: 1.8;
 }
 
 .download-section {
@@ -1038,26 +1356,49 @@ custom_css = """
     padding: 15px;
     border-radius: 8px;
     margin-top: 20px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+/* 진행 상황 표시 개선 */
+#stages-display h2 {
+    color: #1a1a2e;
+    border-bottom: 2px solid #1a1a2e;
+    padding-bottom: 10px;
+}
+
+#stages-display blockquote {
+    border-left: 3px solid #667eea;
+    padding-left: 15px;
+    color: #666;
+    font-style: italic;
+}
+
+/* 점수 표시 스타일 */
+#stages-display strong {
+    color: #1a1a2e;
 }
 """
 
 
 # Gradio 인터페이스 생성
 def create_interface():
-    with gr.Blocks(css=custom_css, title="AI 협업 소설 생성 시스템") as interface:
+    with gr.Blocks(css=custom_css, title="AI 협업 소설 생성 시스템 - 철학적 깊이 버전") as interface:
         gr.HTML("""
         <div class="main-header">
             <h1 style="font-size: 2.5em; margin-bottom: 10px;">
                 📚 AI 협업 소설 생성 시스템
             </h1>
             <h3 style="color: #ccc; margin-bottom: 20px;">
-                일관성 중심의 창의적 소설 생성
+                철학적 깊이를 담은 창의적 소설 생성
             </h3>
             <p style="font-size: 1.1em; color: #ddd; max-width: 800px; margin: 0 auto;">
-                주제를 입력하면 AI 에이전트들이 협업하여 30페이지 분량의 완성된 소설을 생성합니다.
+                주제를 입력하면 AI 에이전트들이 협업하여 30페이지 분량의 철학적 소설을 생성합니다.
                 <br>
-                감독자 1명, 비평가 1명, 작가 10명이 함께 작업하며 일관성을 유지합니다.
+                감독자 1명, 비평가 1명, 작가 10명이 함께 인간의 근원적 문제를 탐구합니다.
             </p>
+            <div class="philosophy-note">
+                "모든 위대한 문학은 인간 존재의 본질적 질문에서 시작됩니다."
+            </div>
         </div>
         """)
         
@@ -1069,13 +1410,13 @@ def create_interface():
                 with gr.Group(elem_classes=["input-section"]):
                     query_input = gr.Textbox(
                         label="소설 주제 / Novel Theme",
-                        placeholder="소설의 주제나 초기 아이디어를 입력하세요...\nEnter your novel theme or initial idea...",
+                        placeholder="인간의 삶, 관계, 갈등, 꿈, 또는 어떤 주제든 입력하세요...\nEnter any theme about human life, relationships, conflicts, dreams...",
                         lines=4
                     )
                     
                     language_select = gr.Radio(
-                        choices=["English", "Korean"],
-                        value="English",
+                        choices=["Korean", "English"],
+                        value="Korean",
                         label="언어 / Language"
                     )
                     
@@ -1133,25 +1474,27 @@ def create_interface():
         # 숨겨진 상태
         novel_text_state = gr.State("")
         
-        # 예제
+        # 예제 (철학적 주제로 변경)
         with gr.Row():
             gr.Examples(
                 examples=[
-                    ["미래 도시에서 기억을 거래하는 상인의 이야기"],
-                    ["시간이 거꾸로 흐르는 마을의 미스터리"],
-                    ["A scientist discovers a portal to parallel universes"],
-                    ["In a world where dreams can be traded, a dream thief's story"],
-                    ["Two AI entities fall in love while preventing a cyber war"],
-                    ["책 속으로 들어갈 수 있는 능력을 가진 사서의 모험"]
+                    ["자유의지는 환상인가, 아니면 인간 존재의 본질인가"],
+                    ["타인의 고통을 완전히 이해할 수 있는가"],
+                    ["기억이 우리를 만드는가, 우리가 기억을 만드는가"],
+                    ["The meaning of love in a world without death"],
+                    ["Can consciousness exist without suffering"],
+                    ["진정한 자아는 변하는가, 불변하는가"],
+                    ["언어의 한계가 곧 세계의 한계인가"],
+                    ["What defines humanity when machines can feel"]
                 ],
                 inputs=query_input,
-                label="💡 예제 주제"
+                label="💡 철학적 주제 예시"
             )
         
         # 이벤트 핸들러
         def refresh_sessions():
             try:
-                sessions = get_active_sessions("English")
+                sessions = get_active_sessions("Korean")
                 return gr.update(choices=sessions)
             except Exception as e:
                 logger.error(f"Error refreshing sessions: {str(e)}")
@@ -1231,7 +1574,7 @@ def create_interface():
 
 # 메인 실행
 if __name__ == "__main__":
-    logger.info("AI 협업 소설 생성 시스템 시작...")
+    logger.info("AI 협업 소설 생성 시스템 시작 (철학적 깊이 강화 버전)...")
     logger.info("=" * 60)
     
     # 환경 확인