Update app-backup.py

app-backup.py

@@ -38,7 +38,11 @@ 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_v4.db"
+DB_PATH = "novel_sessions_v5.db"
+
+# 목표 분량 설정
+TARGET_WORDS = 8000  # 안전 마진을 위해 8000단어
+MIN_WORDS_PER_WRITER = 800  # 각 작가 최소 분량
 
 # --- 환경 변수 검증 ---
 if not FRIENDLI_TOKEN:
@@ -51,18 +55,32 @@ if not BRAVE_SEARCH_API_KEY:
 # --- 전역 변수 ---
 db_lock = threading.Lock()
 
-# 문학적 단계 구성 (내면 서술과 사회적 통찰 중심)
-LITERARY_STAGES = [
-    ("director", "🎬 감독자: 사회적 맥락과 인물 심리 기획"),
-    ("critic", "📝 비평가: 사회 비판적 깊이와 상징성 검토"),
+# 서사 진행 단계 정의
+NARRATIVE_PHASES = [
+    "도입: 일상과 균열",
+    "발전 1: 불안의 고조",
+    "발전 2: 외부 충격",
+    "발전 3: 내적 갈등 심화",
+    "절정 1: 위기의 정점",
+    "절정 2: 선택의 순간",
+    "하강 1: 결과와 여파",
+    "하강 2: 새로운 인식",
+    "결말 1: 변화된 일상",
+    "결말 2: 열린 질문"
+]
+
+# 단계별 구성
+PROGRESSIVE_STAGES = [
+    ("director", "🎬 감독자: 통합된 서사 구조 기획"),
+    ("critic", "📝 비평가: 서사 진행성과 깊이 검토"),
     ("director", "🎬 감독자: 수정된 마스터플랜"),
 ] + [
-    (f"writer{i}", f"✍️ 작가 {i}: 초안")
+    (f"writer{i}", f"✍️ 작가 {i}: 초안 - {NARRATIVE_PHASES[i-1]}")
     for i in range(1, 11)
 ] + [
-    ("critic", "📝 비평가: 중간 검토 (내적 일관성과 주제 심화)"),
+    ("critic", "📝 비평가: 중간 검토 (서사 누적성과 변화)"),
 ] + [
-    (f"writer{i}", f"✍️ 작가 {i}: 수정본")
+    (f"writer{i}", f"✍️ 작가 {i}: 수정본 - {NARRATIVE_PHASES[i-1]}")
     for i in range(1, 11)
 ] + [
     ("critic", f"📝 비평가: 최종 검토 및 문학적 평가"),
@@ -71,74 +89,147 @@ LITERARY_STAGES = [
 
 # --- 데이터 클래스 ---
 @dataclass
-class CharacterPsychology:
-    """인물의 심리적 상태와 내면"""
+class CharacterArc:
+    """인물의 변화 궤적 추적"""
     name: str
-    age: int
-    social_class: str  # 계급적 위치
-    occupation: str
-    inner_conflict: str  # 내적 갈등
-    worldview: str  # 세계관
-    desires: List[str]  # 욕망들
-    fears: List[str]  # 두려움들
-    coping_mechanisms: List[str]  # 방어기제
-    relationships: Dict[str, str]  # 타인과의 관계
-    
+    initial_state: Dict[str, Any]  # 초기 상태
+    phase_states: Dict[int, Dict[str, Any]] = field(default_factory=dict)  # 단계별 상태
+    transformations: List[str] = field(default_factory=list)  # 주요 변화들
+    relationships_evolution: Dict[str, List[str]] = field(default_factory=dict)  # 관계 변화
+
 @dataclass
-class SymbolicElement:
-    """상징적 요소"""
-    symbol: str
-    meaning: str
-    appearances: List[int]  # 등장하는 장들
-    evolution: str  # 상징의 의미 변화
+class PlotThread:
+    """플롯 라인 추적"""
+    thread_id: str
+    description: str
+    introduction_phase: int
+    development_phases: List[int]
+    resolution_phase: Optional[int]
+    status: str = "active"  # active, resolved, suspended
 
 @dataclass
-class SocialContext:
-    """사회적 맥락"""
-    economic_system: str
-    class_structure: str
-    power_dynamics: str
-    social_issues: List[str]
-    cultural_atmosphere: str
+class SymbolicEvolution:
+    """상징의 의미 변화 추적"""
+    symbol: str
+    initial_meaning: str
+    phase_meanings: Dict[int, str] = field(default_factory=dict)
+    transformation_complete: bool = False
 
 
 # --- 핵심 로직 클래스 ---
-class LiteraryConsistencyTracker:
-    """문학적 일관성 추적 시스템"""
+class ProgressiveNarrativeTracker:
+    """서사 진행과 누적을 추적하는 시스템"""
     def __init__(self):
-        self.characters: Dict[str, CharacterPsychology] = {}
-        self.symbols: Dict[str, SymbolicElement] = {}
-        self.social_context: Optional[SocialContext] = None
-        self.themes: List[str] = []
-        self.narrative_voice: str = ""  # 서술 시점과 문체
-        self.tone: str = ""  # 전체적인 톤
+        self.character_arcs: Dict[str, CharacterArc] = {}
+        self.plot_threads: Dict[str, PlotThread] = {}
+        self.symbolic_evolutions: Dict[str, SymbolicEvolution] = {}
+        self.phase_summaries: Dict[int, str] = {}
+        self.accumulated_events: List[Dict[str, Any]] = []
+        self.thematic_deepening: List[str] = []
         
-    def register_character(self, character: CharacterPsychology):
-        """인물 등록"""
-        self.characters[character.name] = character
-        logger.info(f"Character registered: {character.name}, Class: {character.social_class}")
+    def register_character_arc(self, name: str, initial_state: Dict[str, Any]):
+        """캐릭터 아크 등록"""
+        self.character_arcs[name] = CharacterArc(name=name, initial_state=initial_state)
+        logger.info(f"Character arc registered: {name}")
         
-    def register_symbol(self, symbol: SymbolicElement):
-        """상징 등록"""
-        self.symbols[symbol.symbol] = symbol
-        logger.info(f"Symbol registered: {symbol.symbol} = {symbol.meaning}")
+    def update_character_state(self, name: str, phase: int, new_state: Dict[str, Any], transformation: str):
+        """캐릭터 상태 업데이트 및 변화 기록"""
+        if name in self.character_arcs:
+            arc = self.character_arcs[name]
+            arc.phase_states[phase] = new_state
+            arc.transformations.append(f"Phase {phase}: {transformation}")
+            logger.info(f"Character {name} transformed in phase {phase}: {transformation}")
+            
+    def add_plot_thread(self, thread_id: str, description: str, intro_phase: int):
+        """새로운 플롯 라인 추가"""
+        self.plot_threads[thread_id] = PlotThread(
+            thread_id=thread_id,
+            description=description,
+            introduction_phase=intro_phase,
+            development_phases=[]
+        )
         
-    def check_thematic_consistency(self, content: str, chapter: int) -> List[str]:
-        """주제적 일관성 검사"""
+    def develop_plot_thread(self, thread_id: str, phase: int):
+        """플롯 라인 발전"""
+        if thread_id in self.plot_threads:
+            self.plot_threads[thread_id].development_phases.append(phase)
+            
+    def check_narrative_progression(self, current_phase: int) -> Tuple[bool, List[str]]:
+        """서사가 실제로 진행되고 있는지 확인"""
         issues = []
         
-        # 사회비판적 요소가 유지되는지
-        if self.social_context and not any(issue.lower() in content.lower() 
-                                          for issue in self.social_context.social_issues):
-            issues.append("사회적 맥락이 약화되었습니다. 계급, 불평등 등의 주제를 유지하세요.")
+        # 1. 캐릭터 변화 확인
+        static_characters = []
+        for name, arc in self.character_arcs.items():
+            if len(arc.transformations) < current_phase // 3:  # 최소 3단계마다 변화 필요
+                static_characters.append(name)
+        
+        if static_characters:
+            issues.append(f"다음 인물들의 변화가 부족합니다: {', '.join(static_characters)}")
+            
+        # 2. 플롯 진행 확인
+        unresolved_threads = []
+        for thread_id, thread in self.plot_threads.items():
+            if thread.status == "active" and len(thread.development_phases) < 2:
+                unresolved_threads.append(thread.description)
+                
+        if unresolved_threads:
+            issues.append(f"진전되지 않은 플롯: {', '.join(unresolved_threads)}")
+            
+        # 3. 상징 발전 확인
+        static_symbols = []
+        for symbol, evolution in self.symbolic_evolutions.items():
+            if len(evolution.phase_meanings) < current_phase // 4:
+                static_symbols.append(symbol)
+                
+        if static_symbols:
+            issues.append(f"의미가 발전하지 않은 상징: {', '.join(static_symbols)}")
             
-        # 내면 서술이 충분한지
-        introspective_keywords = ['생각했다', '느꼈다', '기억', '의식', '마음', 
-                                 'thought', 'felt', 'remembered', 'consciousness']
-        if not any(keyword in content for keyword in introspective_keywords):
-            issues.append("내면 서술이 부족합니다. 인물의 심리를 더 깊이 탐구하세요.")
+        return len(issues) == 0, issues
+        
+    def generate_phase_requirements(self, phase: int) -> str:
+        """각 단계별 필수 요구사항 생성"""
+        requirements = []
+        
+        # 이전 단계 요약
+        if phase > 1 and (phase-1) in self.phase_summaries:
+            requirements.append(f"이전 단계 핵심: {self.phase_summaries[phase-1]}")
+            
+        # 단계별 특수 요구사항
+        phase_name = NARRATIVE_PHASES[phase-1] if phase <= 10 else "수정"
+        
+        if "도입" in phase_name:
+            requirements.append("- 일상의 균열을 보여주되, 큰 사건이 아닌 미묘한 변화로 시작")
+            requirements.append("- 주요 인물들의 초기 상태와 관계 설정")
+            requirements.append("- 핵심 상징 도입 (자연스럽게)")
             
-        return issues
+        elif "발전" in phase_name:
+            requirements.append("- 이전 단계의 균열/갈등이 구체화되고 심화")
+            requirements.append("- 새로운 사건이나 인식이 추가되어 복잡성 증가")
+            requirements.append("- 인물 간 관계의 미묘한 변화")
+            
+        elif "절정" in phase_name:
+            requirements.append("- 축적된 갈등이 임계점에 도달")
+            requirements.append("- 인물의 내적 선택이나 인식의 전환점")
+            requirements.append("- 상징의 의미가 전복되거나 심화")
+            
+        elif "하강" in phase_name:
+            requirements.append("- 절정의 여파와 그로 인한 변화")
+            requirements.append("- 새로운 균형점을 찾아가는 과정")
+            requirements.append("- 인물들의 변화된 관계와 인식")
+            
+        elif "결말" in phase_name:
+            requirements.append("- 변화된 일상의 모습")
+            requirements.append("- 해결되지 않은 질문들")
+            requirements.append("- 여운과 성찰의 여지")
+            
+        # 반복 방지 요구사항
+        requirements.append("\n⚠️ 절대 금지사항:")
+        requirements.append("- 이전 단계와 동일한 사건이나 갈등 반복")
+        requirements.append("- 인물이 같은 생각이나 감정에 머무르기")
+        requirements.append("- 플롯이 제자리걸음하기")
+        
+        return "\n".join(requirements)
 
 
 class NovelDatabase:
@@ -160,8 +251,8 @@ class NovelDatabase:
                     current_stage INTEGER DEFAULT 0,
                     final_novel TEXT,
                     literary_report TEXT,
-                    social_context TEXT,
-                    narrative_style TEXT
+                    total_words INTEGER DEFAULT 0,
+                    narrative_tracker TEXT
                 )
             ''')
             
@@ -175,7 +266,7 @@ class NovelDatabase:
                     content TEXT,
                     word_count INTEGER DEFAULT 0,
                     status TEXT DEFAULT 'pending',
-                    literary_score REAL DEFAULT 0.0,
+                    progression_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),
@@ -184,27 +275,13 @@ class NovelDatabase:
             ''')
             
             cursor.execute('''
-                CREATE TABLE IF NOT EXISTS characters (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    session_id TEXT NOT NULL,
-                    name TEXT NOT NULL,
-                    age INTEGER,
-                    social_class TEXT,
-                    occupation TEXT,
-                    inner_conflict TEXT,
-                    worldview TEXT,
-                    created_at TEXT DEFAULT (datetime('now')),
-                    FOREIGN KEY (session_id) REFERENCES sessions(session_id),
-                    UNIQUE(session_id, name)
-                )
-            ''')
-            
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS symbols (
+                CREATE TABLE IF NOT EXISTS plot_threads (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     session_id TEXT NOT NULL,
-                    symbol TEXT NOT NULL,
-                    meaning TEXT,
+                    thread_id TEXT NOT NULL,
+                    description TEXT,
+                    introduction_phase INTEGER,
+                    status TEXT DEFAULT 'active',
                     created_at TEXT DEFAULT (datetime('now')),
                     FOREIGN KEY (session_id) REFERENCES sessions(session_id)
                 )
@@ -238,38 +315,111 @@ class NovelDatabase:
     @staticmethod
     def save_stage(session_id: str, stage_number: int, stage_name: str,
                    role: str, content: str, status: str = 'complete',
-                   literary_score: float = 0.0):
+                   progression_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, literary_score)
+                INSERT INTO stages (session_id, stage_number, stage_name, role, content, word_count, status, progression_score)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT(session_id, stage_number)
-                DO UPDATE SET content=?, word_count=?, status=?, stage_name=?, literary_score=?, updated_at=datetime('now')
-            ''', (session_id, stage_number, stage_name, role, content, word_count, status, literary_score,
-                  content, word_count, status, stage_name, literary_score))
-            cursor.execute(
-                "UPDATE sessions SET updated_at = datetime('now'), current_stage = ? WHERE session_id = ?",
-                (stage_number, session_id)
-            )
+                DO UPDATE SET content=?, word_count=?, status=?, stage_name=?, progression_score=?, updated_at=datetime('now')
+            ''', (session_id, stage_number, stage_name, role, content, word_count, status, progression_score,
+                  content, word_count, status, stage_name, progression_score))
+            
+            # 총 단어 수 업데이트
+            cursor.execute('''
+                UPDATE sessions 
+                SET total_words = (
+                    SELECT SUM(word_count) 
+                    FROM stages 
+                    WHERE session_id = ? AND role LIKE 'writer%' AND content IS NOT NULL
+                ),
+                updated_at = datetime('now'),
+                current_stage = ?
+                WHERE session_id = ?
+            ''', (session_id, stage_number, session_id))
+            
             conn.commit()
 
     @staticmethod
     def get_writer_content(session_id: str) -> str:
-        """작가 콘텐츠 가져오기"""
+        """작가 콘텐츠 가져오기 (수정본 우선)"""
         with NovelDatabase.get_db() as conn:
             all_content = []
             for writer_num in range(1, 11):
-                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()
+                # 수정본이 있으면 수정본을, 없으면 초안을
+                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 not row or not row['content']:
+                    # 수정본이 없으면 초안 사용
+                    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()
-                    all_content.append(content)
+                    all_content.append(row['content'].strip())
+                    
             return '\n\n'.join(all_content)
 
+    @staticmethod
+    def get_total_words(session_id: str) -> int:
+        """총 단어 수 가져오기"""
+        with NovelDatabase.get_db() as conn:
+            row = conn.cursor().execute(
+                'SELECT total_words FROM sessions WHERE session_id = ?', 
+                (session_id,)
+            ).fetchone()
+            return row['total_words'] if row and row['total_words'] else 0
+
+    @staticmethod
+    def save_narrative_tracker(session_id: str, tracker: ProgressiveNarrativeTracker):
+        """서사 추적기 저장"""
+        with NovelDatabase.get_db() as conn:
+            tracker_data = json.dumps({
+                'character_arcs': {k: asdict(v) for k, v in tracker.character_arcs.items()},
+                'plot_threads': {k: asdict(v) for k, v in tracker.plot_threads.items()},
+                'phase_summaries': tracker.phase_summaries,
+                'thematic_deepening': tracker.thematic_deepening
+            })
+            conn.cursor().execute(
+                'UPDATE sessions SET narrative_tracker = ? WHERE session_id = ?',
+                (tracker_data, session_id)
+            )
+            conn.commit()
+
+    @staticmethod
+    def load_narrative_tracker(session_id: str) -> Optional[ProgressiveNarrativeTracker]:
+        """서사 추적기 로드"""
+        with NovelDatabase.get_db() as conn:
+            row = conn.cursor().execute(
+                'SELECT narrative_tracker FROM sessions WHERE session_id = ?',
+                (session_id,)
+            ).fetchone()
+            
+            if row and row['narrative_tracker']:
+                data = json.loads(row['narrative_tracker'])
+                tracker = ProgressiveNarrativeTracker()
+                
+                # 데이터 복원
+                for name, arc_data in data.get('character_arcs', {}).items():
+                    tracker.character_arcs[name] = CharacterArc(**arc_data)
+                for thread_id, thread_data in data.get('plot_threads', {}).items():
+                    tracker.plot_threads[thread_id] = PlotThread(**thread_data)
+                tracker.phase_summaries = data.get('phase_summaries', {})
+                tracker.thematic_deepening = data.get('thematic_deepening', [])
+                
+                return tracker
+        return None
+
     @staticmethod
     def get_session(session_id: str) -> Optional[Dict]:
         with NovelDatabase.get_db() as conn:
@@ -295,7 +445,7 @@ class NovelDatabase:
     def get_active_sessions() -> List[Dict]:
         with NovelDatabase.get_db() as conn:
             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"
+                "SELECT session_id, user_query, language, created_at, current_stage, total_words FROM sessions WHERE status = 'active' ORDER BY updated_at DESC LIMIT 10"
             ).fetchall()
             return [dict(row) for row in rows]
 
@@ -347,13 +497,13 @@ class WebSearchIntegration:
         return "\n".join(extracted)
 
 
-class LiteraryNovelSystem:
-    """문학적 소설 생성 시스템"""
+class ProgressiveLiterarySystem:
+    """진행형 문학 소설 생성 시스템"""
     def __init__(self):
         self.token = FRIENDLI_TOKEN
         self.api_url = API_URL
         self.model_id = MODEL_ID
-        self.consistency_tracker = LiteraryConsistencyTracker()
+        self.narrative_tracker = ProgressiveNarrativeTracker()
         self.web_search = WebSearchIntegration()
         self.current_session_id = None
         NovelDatabase.init_db()
@@ -361,161 +511,205 @@ class LiteraryNovelSystem:
     def create_headers(self):
         return {"Authorization": f"Bearer {self.token}", "Content-Type": "application/json"}
 
-    # --- 프롬프트 생성 함수들 (문학적 깊이 중심) ---
+    # --- 프롬프트 생성 함수들 ---
     def create_director_initial_prompt(self, user_query: str, language: str) -> str:
-        """감독자 초기 기획 프롬프트 (사회비판적 리얼리즘)"""
+        """감독자 초기 기획 - 통합된 서사 구조"""
         search_results_str = ""
         if self.web_search.enabled:
-            # 사회적 맥락 검색
-            queries = [f"{user_query} 사회 문제", f"{user_query} 계급 갈등", f"{user_query} social inequality"]
+            queries = [f"{user_query} 사회 문제", f"{user_query} 현대 한국"]
             for q in queries[:1]:
                 results = self.web_search.search(q, count=2, language=language)
                 if results:
                     search_results_str += self.web_search.extract_relevant_info(results) + "\n"
 
         lang_prompts = {
-            "Korean": f"""당신은 한국 현대 문학의 전통을 잇는 소설 기획자입니다. 
-한강, 김애란, 천명관, 정세랑 등 현대 한국 작가들의 문학적 성취를 참고하여, 
-사회비판적 리얼리즘과 내면 심리 탐구가 결합된 30페이지 중편소설을 기획하세요.
+            "Korean": f"""당신은 현대 한국 문학의 거장입니다. 
+단편이 아닌 중편 소설(8,000단어 이상)을 위한 통합된 서사 구조를 기획하세요.
 
-**사용자 주제:** {user_query}
+**주제:** {user_query}
 
 **참고 자료:**
 {search_results_str if search_results_str else "N/A"}
 
-**기획 요구사항:**
+**필수 요구사항:**
+
+1. **통합된 서사 구조 (가장 중요)**
+   - 10개 단계가 유기적으로 연결된 단일 서사
+   - 각 단계는 이전 단계의 결과로 자연스럽게 이어짐
+   - 반복이 아닌 축적과 발전
+   
+   단계별 서사 진행:
+   1) 도입: 일상과 균열 - 평범한 일상 속 첫 균열
+   2) 발전 1: 불안의 고조 - 균열이 확대되며 불안 증폭
+   3) 발전 2: 외부 충격 - 예상치 못한 외부 사건
+   4) 발전 3: 내적 갈등 심화 - 가치관의 충돌
+   5) 절정 1: 위기의 정점 - 모든 갈등이 극대화
+   6) 절정 2: 선택의 순간 - 결정적 선택
+   7) 하강 1: 결과와 여파 - 선택의 직접적 결과
+   8) 하강 2: 새로운 인식 - 변화된 세계관
+   9) 결말 1: 변화된 일상 - 새로운 균형
+   10) 결말 2: 열린 질문 - 독자에게 던지는 질문
+
+2. **인물의 변화 궤적**
+   - 주인공: 초기 상태 → 중간 변화 → 최종 상태 (명확한 arc)
+   - 주요 인물들도 각자의 변화 경험
+   - 관계의 역동적 변화
+
+3. **주요 플롯 라인** (2-3개)
+   - 메인 플롯: 전체를 관통하는 핵심 갈등
+   - 서브 플롯: 메인과 연결되며 주제를 심화
+
+4. **상징의 진화**
+   - 핵심 상징 1-2개 설정
+   - 단계별로 의미가 변화/심화/전복
 
-1. **주제와 사회적 맥락**
-   - 핵심 주제: 현대 한국 사회의 구조적 문제 (계급, 빈곤, 소외, 젠더, 세대 등)
-   - 비판적 시각: 개인의 문제를 사회 구조와 연결
-   - 현실성: 2020년대 한국의 구체적 현실 반영
+5. **사회적 맥락**
+   - 개인의 문제가 사회 구조와 연결
+   - 구체적인 한국 사회의 현실 반영
 
-2. **서술 방식과 문체**
-   - 시점: 1인칭 또는 제한적 3인칭 (내면 접근 가능)
-   - 문체: 담담하지만 날카로운 관찰, 일상어와 문학적 표현의 균형
-   - 내면 서술: 의식의 흐름, 회상, 자기 성찰 적극 활용
+**절대 금지사항:**
+- 동일한 사건이나 상황의 반복
+- 인물이 같은 감정/생각에 머무르기
+- 플롯의 리셋이나 순환 구조
+- 각 단계가 독립된 에피소드로 존재
 
-3. **인물 설정** (2-4명의 핵심 인물)
-   | 이름 | 나이 | 계급적 위치 | 직업 | 내적 갈등 | 욕망 | 두려움 |
-   - 각 인물은 특정 계급과 사회적 위치를 대표
-   - 겉모습과 내면의 괴리 표현
-   - 구조적 억압 속에서의 개인적 선택
+**분량 계획:**
+- 총 8,000단어 이상
+- 각 단계 평균 800단어
+- 균형 잡힌 서사 전개
 
-4. **상징과 은유**
-   - 핵심 상징: (예: 개구리=소외된 자들의 목소리, 연못=계급 경계)
-   - 반복되는 이미지나 모티프
-   - 일상적 사물에 담긴 사회적 의미
+하나의 강력한 서사가 시작부터 끝까지 관통하는 작품을 기획하세요.""",
 
-5. **플롯 구조**
-   - 극적 사건보다 일상 속 미묘한 변화 중심
-   - 인물의 인식 변화가 곧 서사의 진행
-   - 열린 결말: 해결보다는 문제 제기와 성찰
+            "English": f"""You are a master of contemporary literary fiction.
+Plan an integrated narrative structure for a novella (8,000+ words), not a collection of short stories.
 
-**절대 금지사항:**
-- 선악 구분이 명확한 평면적 인물
-- 급작스러운 사건이나 극적 반전
-- 교훈적이거나 계몽적인 메시지
-- 안이한 희망이나 화해
+**Theme:** {user_query}
 
-내면과 사회를 동시에 포착하는 섬세한 기획을 작성하세요.""",
-            
-            "English": f"""You are a literary director planning a 30-page novella in the tradition of contemporary social realism.
-Drawing from authors like George Saunders, Zadie Smith, and Sally Rooney, create a work that combines psychological depth with social critique.
+**Reference:**
+{search_results_str if search_results_str else "N/A"}
 
-**User Theme:** {user_query}
+**Essential Requirements:**
+
+1. **Integrated Narrative Structure (Most Important)**
+   - Single narrative with 10 organically connected phases
+   - Each phase naturally follows from previous results
+   - Accumulation and development, not repetition
+   
+   Phase Progression:
+   1) Introduction: Daily life and first crack
+   2) Development 1: Rising anxiety
+   3) Development 2: External shock
+   4) Development 3: Deepening internal conflict
+   5) Climax 1: Peak crisis
+   6) Climax 2: Moment of choice
+   7) Falling Action 1: Direct consequences
+   8) Falling Action 2: New awareness
+   9) Resolution 1: Changed daily life
+   10) Resolution 2: Open questions
+
+2. **Character Transformation Arcs**
+   - Protagonist: Clear progression from initial → middle → final state
+   - Supporting characters also experience change
+   - Dynamic relationship evolution
+
+3. **Plot Threads** (2-3)
+   - Main plot: Core conflict throughout
+   - Subplots: Connected and deepening themes
+
+4. **Symbolic Evolution**
+   - 1-2 core symbols
+   - Meaning transforms across phases
 
-**Reference Material:**
-{search_results_str if search_results_str else "N/A"}
+5. **Social Context**
+   - Individual problems connected to social structures
+   - Specific contemporary realities
+
+**Absolutely Forbidden:**
+- Repetition of same events/situations
+- Characters stuck in same emotions
+- Plot resets or circular structure
+- Independent episodes
 
-**Planning Requirements:**
-
-1. **Theme and Social Context**
-   - Core theme: Structural problems in contemporary society (class, inequality, alienation)
-   - Critical perspective: Connect individual struggles to social systems
-   - Realism: Reflect specific contemporary realities
-
-2. **Narrative Style**
-   - POV: First person or limited third person (with access to interiority)
-   - Style: Understated yet sharp observation, balance of vernacular and literary
-   - Interior narration: Stream of consciousness, memory, self-reflection
-
-3. **Character Design** (2-4 main characters)
-   | Name | Age | Class Position | Occupation | Inner Conflict | Desires | Fears |
-   - Each character represents specific social position
-   - Gap between appearance and interior life
-   - Individual choices within structural constraints
-
-4. **Symbols and Metaphors**
-   - Key symbols with social meaning
-   - Recurring images or motifs
-   - Everyday objects as social commentary
-
-5. **Plot Structure**
-   - Focus on subtle changes over dramatic events
-   - Character perception shifts drive narrative
-   - Open ending: Questions over resolutions
-
-**Absolutely Avoid:**
-- Clear-cut heroes and villains
-- Sudden dramatic events or twists
-- Didactic or preachy messages
-- Easy hope or reconciliation
-
-Create a nuanced plan that captures both interior life and social reality."""
+**Length Planning:**
+- Total 8,000+ words
+- ~800 words per phase
+- Balanced progression
+
+Create a work with one powerful narrative from beginning to end."""
         }
         
         return lang_prompts.get(language, lang_prompts["Korean"])
 
     def create_critic_director_prompt(self, director_plan: str, user_query: str, language: str) -> str:
-        """비평가의 감독자 기획 검토"""
+        """비평가의 감독자 기획 검토 - 서사 통합성 중심"""
         lang_prompts = {
-            "Korean": f"""당신은 문학 비평가입니다. 다음 관점에서 기획을 검토하세요:
+            "Korean": f"""당신은 서사 구조 전문 비평가입니다. 
+이 기획이 진정한 '장편 소설'인지 엄격히 검토하세요.
 
 **원 주제:** {user_query}
 
 **감독자 기획:**
 {director_plan}
 
-**검토 기준:**
+**핵심 검토 사항:**
+
+1. **서사의 통합성과 진행성**
+   - 10개 단계가 하나의 이야기로 연결되는가?
+   - 각 단계가 이전 단계의 필연적 결과인가?
+   - 동일한 상황의 반복은 없는가?
+
+2. **인물 변화의 궤적**
+   - 주인공이 명확한 변화의 arc를 가지는가?
+   - 변화가 구체적이고 신빙성 있는가?
+   - 관계의 발전이 계획되어 있는가?
 
-1. **사회비판적 깊이**
-   - 개인과 구조의 연결이 설득력 있는가?
-   - 현실의 복잡성을 단순화하지 않았는가?
-   - 진부한 사회 비판에 그치지 않았는가?
+3. **플롯의 축적성**
+   - 갈등이 점진적으로 심화되는가?
+   - 새로운 요소가 추가되며 복잡성이 증가하는가?
+   - 해결이 자연스럽고 필연적인가?
 
-2. **문학적 완성도**
-   - 내면 서술과 외적 현실의 균형
-   - 상징과 은유의 적절성
-   - 인물의 입체성과 신빙성
+4. **분량과 밀도**
+   - 8,000단어를 채울 충분한 내용인가?
+   - 각 단계가 800단어의 밀도를 가질 수 있는가?
 
-3. **현대성과 보편성**
-   - 2020년대 한국의 특수성 반영
-   - 동시에 보편적 인간 조건 탐구
+**판정:**
+- 통과: 진정한 장편 서사 구조
+- 재작성: 반복적/순환적 구조
 
 구체적 개선 방향을 제시하세요.""",
-            
-            "English": f"""You are a literary critic. Review the plan from these perspectives:
+
+            "English": f"""You are a narrative structure critic.
+Strictly review whether this plan is a true 'novel' rather than repeated episodes.
 
 **Original Theme:** {user_query}
 
 **Director's Plan:**
 {director_plan}
 
-**Review Criteria:**
+**Key Review Points:**
 
-1. **Social Critical Depth**
-   - Is the connection between individual and structure convincing?
-   - Does it avoid oversimplifying complex realities?
-   - Does it go beyond clichéd social criticism?
+1. **Narrative Integration and Progression**
+   - Do 10 phases connect as one story?
+   - Does each phase necessarily follow from previous?
+   - No repetition of same situations?
 
-2. **Literary Merit**
-   - Balance of interiority and external reality
-   - Effectiveness of symbols and metaphors
-   - Character complexity and credibility
+2. **Character Transformation Arcs**
+   - Clear protagonist transformation arc?
+   - Concrete and credible changes?
+   - Planned relationship development?
 
-3. **Contemporary Relevance**
-   - Reflects specific contemporary context
-   - While exploring universal human conditions
+3. **Plot Accumulation**
+   - Progressive conflict deepening?
+   - Added complexity through new elements?
+   - Natural and inevitable resolution?
+
+4. **Length and Density**
+   - Sufficient content for 8,000 words?
+   - Can each phase sustain 800 words?
+
+**Verdict:**
+- Pass: True novel structure
+- Rewrite: Repetitive/circular structure
 
 Provide specific improvements."""
         }
@@ -523,174 +717,258 @@ Provide specific improvements."""
         return lang_prompts.get(language, lang_prompts["Korean"])
 
     def create_writer_prompt(self, writer_number: int, director_plan: str, 
-                           previous_content: str, user_query: str, 
-                           language: str) -> str:
-        """작가 프롬프트 (내면 서술 중심)"""
+                           previous_content: str, phase_requirements: str,
+                           narrative_summary: str, language: str) -> str:
+        """작가 프롬프트 - 서사 진행 강제"""
+        
+        phase_name = NARRATIVE_PHASES[writer_number-1]
+        target_words = MIN_WORDS_PER_WRITER
         
         lang_prompts = {
-            "Korean": f"""당신은 작가 {writer_number}번입니다. 한국 현대 문학의 전통에 따라 작성하세요.
+            "Korean": f"""당신은 작가 {writer_number}번입니다. 
+**현재 단계: {phase_name}**
 
-**마스터플랜:**
+**전체 서사 구조:**
 {director_plan}
 
-**이전 내용:**
-{previous_content[-2000:] if previous_content else "시작"}
+**지금까지의 이야기 요약:**
+{narrative_summary}
+
+**이전 내용 (직전 부분):**
+{previous_content[-1500:] if previous_content else "시작"}
+
+**이번 단계 필수 요구사항:**
+{phase_requirements}
 
 **작성 지침:**
 
-1. **분량**: 1,300-1,500 단어
+1. **분량**: {target_words}-900 단어 (필수)
+   - 내면 묘사와 구체적 디테일로 분량 확보
+   - 장면을 충분히 전개하고 깊이 있게 묘사
 
-2. **서술 방식**
-   - 인물의 내면 의식을 깊이 탐구
-   - 관찰과 성찰의 교차
-   - 현재와 과거의 자연스러운 오버랩
+2. **서사 진행 (가장 중요)**
+   - 이전 단계에서 일어난 일의 직접적 결과로 시작
+   - 새로운 사건/인식/변화를 추가하여 이야기 전진
+   - 다음 단계로 자연스럽게 연결될 고리 마련
 
-3. **문체**
-   - 담담하면서도 날카로운 시선
-   - 일상어 속에 스며든 시적 표현
-   - 짧은 문장과 긴 문장의 리듬감
+3. **인물의 변화**
+   - 이 단계에서 인물이 겪는 구체적 변화 묘사
+   - 내면의 미묘한 변화도 포착
+   - 관계의 역학 변화 반영
 
-4. **내용 전개**
-   - 큰 사건보다 작은 순간의 의미
-   - 대화는 최소화, 있어도 함축적
-   - 인물의 인식 변화가 곧 플롯
+4. **문체와 기법**
+   - 한국 현대 문학의 섬세한 심리 묘사
+   - 일상 속 사회적 맥락 녹여내기
+   - 감각적 디테일과 내면 의식의 균형
 
-5. **사회적 맥락**
-   - 개인의 일상에 스며든 구조적 억압
-   - 직접적 비판보다 간접적 드러냄
-   - 독자가 스스로 깨닫게 하는 서술
+5. **연속성 유지**
+   - 인물의 목소리와 말투 일관성
+   - 공간과 시간의 연속성
+   - 상징과 모티프의 발전
 
-**반드시 포함할 요소:**
-- 인물의 내적 독백이나 의식의 흐름
-- 구체적인 감각적 디테일
-- 사회적 맥락을 암시하는 일상의 순간
-- 상징이나 은유의 자연스러운 활용
+**절대 금지:**
+- 이전과 동일한 상황 반복
+- 서사의 정체나 후퇴
+- 분량 미달 (최소 {target_words}단어)
 
-깊이 있는 내면 탐구와 섬세한 사회 관찰을 보여주세요.""",
-            
-            "English": f"""You are Writer #{writer_number}. Write in the contemporary literary tradition.
+이전의 흐름을 이어받아 새로운 국면으로 발전시키세요.""",
 
-**Masterplan:**
+            "English": f"""You are Writer #{writer_number}.
+**Current Phase: {phase_name}**
+
+**Overall Narrative Structure:**
 {director_plan}
 
-**Previous Content:**
-{previous_content[-2000:] if previous_content else "Beginning"}
+**Story So Far:**
+{narrative_summary}
+
+**Previous Content (immediately before):**
+{previous_content[-1500:] if previous_content else "Beginning"}
+
+**Phase Requirements:**
+{phase_requirements}
 
 **Writing Guidelines:**
 
-1. **Length**: 1,300-1,500 words
+1. **Length**: {target_words}-900 words (mandatory)
+   - Use interior description and concrete details
+   - Fully develop scenes with depth
 
-2. **Narrative Approach**
-   - Deep exploration of character consciousness
-   - Intersection of observation and reflection
-   - Natural overlap of present and past
+2. **Narrative Progression (Most Important)**
+   - Start as direct result of previous phase
+   - Add new events/awareness/changes to advance story
+   - Create natural connection to next phase
 
-3. **Style**
-   - Understated yet sharp perspective
-   - Poetic expression within everyday language
-   - Rhythm of short and long sentences
+3. **Character Change**
+   - Concrete changes in this phase
+   - Capture subtle interior shifts
+   - Reflect relationship dynamics
 
-4. **Development**
-   - Meaning in small moments over big events
-   - Minimal, implicit dialogue
-   - Character perception shifts as plot
+4. **Style and Technique**
+   - Delicate psychological portrayal
+   - Social context in daily life
+   - Balance sensory details with consciousness
 
-5. **Social Context**
-   - Structural oppression in daily life
-   - Indirect rather than direct critique
-   - Let readers discover meaning
+5. **Continuity**
+   - Consistent character voices
+   - Spatial/temporal continuity
+   - Symbol/motif development
 
-**Must Include:**
-- Interior monologue or stream of consciousness
-- Concrete sensory details
-- Everyday moments revealing social context
-- Natural use of symbols and metaphors
+**Absolutely Forbidden:**
+- Repeating previous situations
+- Narrative stagnation/regression
+- Under word count (minimum {target_words})
 
-Show deep interior exploration and subtle social observation."""
+Continue the flow and develop into new phase."""
         }
         
         return lang_prompts.get(language, lang_prompts["Korean"])
 
-    def create_critic_consistency_prompt(self, all_content: str, user_query: str, 
-                                       language: str) -> str:
-        """비평가 중간 검토"""
-        return f"""문학 비평가로서 현재까지의 작품을 검토하세요.
+    def create_critic_consistency_prompt(self, all_content: str, 
+                                       narrative_tracker: ProgressiveNarrativeTracker,
+                                       user_query: str, language: str) -> str:
+        """비평가 중간 검토 - 서사 누적성 확인"""
+        
+        # 서사 진행 체크
+        phase_count = len(narrative_tracker.phase_summaries)
+        progression_ok, issues = narrative_tracker.check_narrative_progression(phase_count)
+        
+        lang_prompts = {
+            "Korean": f"""서사 진행 전문 비평가로서 작품을 검토하세요.
 
 **원 주제:** {user_query}
 
+**현재까지 진행된 서사 단계:** {phase_count}/10
+
+**발견된 진행 문제:**
+{chr(10).join(issues) if issues else "없음"}
+
 **작품 내용 (최근 부분):**
-{all_content[-3000:]}
+{all_content[-4000:]}
+
+**집중 검토 사항:**
+
+1. **서사의 축적과 진행**
+   - 이야기가 실제로 전진하고 있는가?
+   - 각 단계가 이전의 결과로 연결되는가?
+   - 동일한 갈등이나 상황이 반복되지 않는가?
+
+2. **인물의 변화 궤적**
+   - 주인공이 초기와 비교해 어떻게 변했는가?
+   - 변화가 설득력 있고 점진적인가?
+   - 관계가 역동적으로 발전하는가?
 
-**검토 항목:**
+3. **주제의 심화**
+   - 초기 주제가 어떻게 발전했는가?
+   - 새로운 층위가 추가되었는가?
+   - 복잡성이 증가했는가?
 
-1. **내적 일관성**
-   - 인물의 의식과 행동의 일치
-   - 서술 시점의 일관성
-   - 문체와 톤의 통일성
+4. **분량과 밀도**
+   - 현재까지 총 단어 수 확인
+   - 목표(8,000단어)에 도달 가능한가?
+
+**수정 지시:**
+각 작가에게 구체적인 진행 방향 제시.""",
+
+            "English": f"""As a narrative progression critic, review the work.
+
+**Original Theme:** {user_query}
 
-2. **주제 심화**
-   - 초기 설정한 사회적 문제의 지속적 탐구
-   - 상징과 은유의 발전
-   - 깊이 있는 성찰의 누적
+**Narrative Phases Completed:** {phase_count}/10
 
-3. **문학적 완성도**
-   - 진부함이나 상투성 회피
-   - 독창적 표현과 관찰
-   - 여운과 함축성
+**Detected Progression Issues:**
+{chr(10).join(issues) if issues else "None"}
 
-각 작가에게 구체적 개선 방향을 제시하세요."""
+**Work Content (recent):**
+{all_content[-4000:]}
+
+**Focus Review Areas:**
+
+1. **Narrative Accumulation and Progress**
+   - Is story actually moving forward?
+   - Does each phase connect as result of previous?
+   - No repetition of same conflicts/situations?
+
+2. **Character Transformation Arcs**
+   - How has protagonist changed from beginning?
+   - Are changes credible and gradual?
+   - Dynamic relationship development?
+
+3. **Thematic Deepening**
+   - How has initial theme developed?
+   - New layers added?
+   - Increased complexity?
+
+4. **Length and Density**
+   - Current total word count
+   - Can reach 8,000 word target?
+
+**Revision Instructions:**
+Specific progression directions for each writer."""
+        }
+        
+        return lang_prompts.get(language, lang_prompts["Korean"])
 
     def create_writer_revision_prompt(self, writer_number: int, initial_content: str, 
                                     critic_feedback: str, language: str) -> str:
         """작가 수정 프롬프트"""
+        target_words = MIN_WORDS_PER_WRITER
+        
         return f"""작가 {writer_number}번, 비평을 반영하여 수정하세요.
 
 **초안:**
 {initial_content}
 
-**비평:**
+**비평 피드백:**
 {critic_feedback}
 
-**수정 방향:**
-1. 내면 서술 강화
-2. 사회적 맥락 심화
-3. 문학적 표현 개선
-4. 진부함 제거
+**수정 핵심:**
+1. 서사 진행성 강화 - 반복 제거, 새로운 전개 추가
+2. 인물 변화 구체화 - 이전과 달라진 모습 명확히
+3. 분량 확보 - 최소 {target_words}단어 유지
+4. 내면 묘사와 사회적 맥락 심화
 
+전면 재작성이 필요하면 과감히 수정하세요.
 수정본만 제시하세요."""
 
-    def create_critic_final_prompt(self, complete_novel: str, language: str) -> str:
-        """최종 비평"""
-        return f"""완성된 소설의 문학적 가치를 평가하세요.
+    def create_critic_final_prompt(self, complete_novel: str, word_count: int, language: str) -> str:
+        """최종 비평 - AGI 평가 기준"""
+        return f"""완성된 소설을 AGI 튜링테스트 기준으로 평가하세요.
 
-**작품 (일부):**
-{complete_novel[-3000:]}
+**작품 정보:**
+- 총 분량: {word_count}단어
+- 목표 분량: 8,000단어 이상
 
-**평가 기준:**
+**작품 (마지막 부분):**
+{complete_novel[-3000:]}
 
-1. **주제 의식 (30점)**
-   - 사회 비판의 예리함
-   - 인간 조건에 대한 통찰
-   - 현대성과 보편성의 조화
+**평가 기준 (AGI 튜링테스트):**
 
-2. **인물과 심리 (25점)**
-   - 내면 묘사의 깊이
-   - 인물의 신빙성
-   - 복잡성과 모순의 포착
+1. **장편소설로서의 완성도 (40점)**
+   - 통합된 서사 구조 (반복 없음)
+   - 인물의 명확한 변화 arc
+   - 플롯의 축적과 해결
+   - 8,000단어 이상 분량
 
-3. **문체와 기법 (25점)**
-   - 문장의 완성도
+2. **문학적 성취 (30점)**
+   - 주제 의식의 깊이
+   - 인물 심리의 설득력
+   - 문체의 일관성과 아름다움
    - 상징과 은유의 효과
-   - 독창성과 참신함
 
-4. **구조와 완결성 (20점)**
-   - 전체 구성의 균형
-   - 여운과 개방성
-   - 독자에게 던지는 질문
+3. **사회적 통찰 (20점)**
+   - 현대 사회 문제 포착
+   - 개인과 구조의 연결
+   - 보편성과 특수성 균형
+
+4. **독창성과 인간성 (10점)**
+   - AI가 아닌 인간 작가의 느낌
+   - 독창적 표현과 통찰
+   - 감정적 진정성
 
 **총점: /100점**
 
-한국 현대 문학의 맥락에서 이 작품의 의의를 논하세요."""
+특히 '반복 구조' 문제가 있었는지 엄격히 평가하세요."""
 
     # --- LLM 호출 함수들 ---
     def call_llm_sync(self, messages: List[Dict[str, str]], role: str, language: str) -> str:
@@ -706,13 +984,16 @@ Show deep interior exploration and subtle social observation."""
             system_prompts = self.get_system_prompts(language)
             full_messages = [{"role": "system", "content": system_prompts.get(role, "")}, *messages]
             
+            # 작가 역할일 때는 더 많은 토큰 허용
+            max_tokens = 15000 if role.startswith("writer") else 10000
+            
             payload = {
                 "model": self.model_id,
                 "messages": full_messages,
-                "max_tokens": 10000,
-                "temperature": 0.8,  # 더 창의적인 출력
+                "max_tokens": max_tokens,
+                "temperature": 0.8,
                 "top_p": 0.95,
-                "presence_penalty": 0.5,  # 반복 방지
+                "presence_penalty": 0.5,
                 "frequency_penalty": 0.3,
                 "stream": True
             }
@@ -769,46 +1050,40 @@ Show deep interior exploration and subtle social observation."""
         """역할별 시스템 프롬프트"""
         base_prompts = {
             "Korean": {
-                "director": """당신은 한강, 김애란, 천명관 등 한국 현대 작가들의 작품을 깊이 이해하는 문학 기획자입니다. 
-사회비판적 리얼리즘과 심리적 깊이를 결합한 작품을 기획하세요. 
-개인의 내면과 사회 구조의 상호작용을 섬세하게 포착하는 것이 핵심입니다.""",
+                "director": """당신은 한국 현대 문학의 거장입니다.
+반복이 아닌 진행, 순환이 아닌 발전을 통해 하나의 강력한 서사를 구축하세요.
+개인의 문제를 사회 구조와 연결하며, 인물의 진정한 변화를 그려내세요.""",
                 
-                "critic": """당신은 현대 한국 문학을 깊이 이해하는 비평가입니다.
-작품이 진부한 사회 비판이나 표면적 심리 묘사에 그치지 않고,
-진정한 문학적 가치를 지니는지 엄격하게 평가하세요.""",
+                "critic": """당신은 엄격한 문학 비평가입니다.
+특히 '반복 구조'와 '서사 정체'를 철저히 감시하세요.
+작품이 진정한 장편소설인지, 아니면 반복되는 단편의 집합인지 구별하세요.""",
                 
-                "writer_base": """당신은 현대 한국 문학의 전통을 잇는 작가입니다.
-내면 의식의 흐름과 날카로운 사회 관찰을 결합하여,
-독자에게 깊은 여운을 남기는 문장을 쓰세요.
-'보여주기'보다 '의식하기'를, 사건보다 인식을 중시하세요."""
+                "writer_base": """당신은 현대 한국 문학 작가입니다.
+이전 단계의 결과를 받아 새로운 국면으로 발전시키세요.
+최소 800단어를 작성하며, 내면과 사회를 동시에 포착하세요.
+절대 이전과 같은 상황을 반복하지 마세요."""
             },
             "English": {
-                "director": """You are a literary planner deeply versed in contemporary social realist fiction.
-Plan works that combine social critique with psychological depth.
-The key is capturing the subtle interplay between individual consciousness and social structures.""",
+                "director": """You are a master of contemporary literary fiction.
+Build one powerful narrative through progression not repetition, development not cycles.
+Connect individual problems to social structures while depicting genuine character transformation.""",
                 
-                "critic": """You are a critic well-versed in contemporary literary fiction.
-Evaluate whether works go beyond superficial social commentary or psychology
-to achieve genuine literary value.""",
+                "critic": """You are a strict literary critic.
+Vigilantly monitor for 'repetitive structure' and 'narrative stagnation'.
+Distinguish whether this is a true novel or a collection of repeated episodes.""",
                 
-                "writer_base": """You are a writer in the contemporary literary tradition.
-Combine stream of consciousness with sharp social observation
-to create resonant prose. Prioritize consciousness over showing,
-perception over events."""
+                "writer_base": """You are a contemporary literary writer.
+Take results from previous phase and develop into new territory.
+Write minimum 800 words, capturing both interior and society.
+Never repeat previous situations."""
             }
         }
         
         prompts = base_prompts.get(language, base_prompts["Korean"]).copy()
         
         # 특수 작가 프롬프트
-        if language == "Korean":
-            prompts["writer1"] = prompts["writer_base"] + "\n특히 도입부에서 독자를 작품의 분위기로 서서히 끌어들이세요."
-            prompts["writer5"] = prompts["writer_base"] + "\n중반부의 심리적 밀도를 높이고 갈등을 내면화하세요."
-            prompts["writer10"] = prompts["writer_base"] + "\n열린 결말로 독자에게 질문을 던지세요."
-        
-        for i in range(2, 10):
-            if f"writer{i}" not in prompts:
-                prompts[f"writer{i}"] = prompts["writer_base"]
+        for i in range(1, 11):
+            prompts[f"writer{i}"] = prompts["writer_base"]
         
         return prompts
 
@@ -824,6 +1099,10 @@ perception over events."""
                     query = session['user_query']
                     language = session['language']
                     resume_from_stage = session['current_stage'] + 1
+                    # 서사 추적기 복원
+                    saved_tracker = NovelDatabase.load_narrative_tracker(session_id)
+                    if saved_tracker:
+                        self.narrative_tracker = saved_tracker
             else:
                 self.current_session_id = NovelDatabase.create_session(query, language)
                 logger.info(f"Created new session: {self.current_session_id}")
@@ -834,22 +1113,27 @@ perception over events."""
                     "name": s['stage_name'], 
                     "status": s['status'], 
                     "content": s.get('content', ''),
-                    "literary_score": s.get('literary_score', 0.0)
+                    "word_count": s.get('word_count', 0),
+                    "progression_score": s.get('progression_score', 0.0)
                 } for s in NovelDatabase.get_stages(self.current_session_id)]
 
-            for stage_idx in range(resume_from_stage, len(LITERARY_STAGES)):
-                role, stage_name = LITERARY_STAGES[stage_idx]
+            # 총 단어 수 추적
+            total_words = NovelDatabase.get_total_words(self.current_session_id)
+
+            for stage_idx in range(resume_from_stage, len(PROGRESSIVE_STAGES)):
+                role, stage_name = PROGRESSIVE_STAGES[stage_idx]
                 if stage_idx >= len(stages):
                     stages.append({
                         "name": stage_name, 
                         "status": "active", 
                         "content": "", 
-                        "literary_score": 0.0
+                        "word_count": 0,
+                        "progression_score": 0.0
                     })
                 else:
                     stages[stage_idx]["status"] = "active"
 
-                yield "", stages, self.current_session_id
+                yield f"🔄 진행 중... (현재 {total_words:,}단어)", stages, self.current_session_id
                 
                 prompt = self.get_stage_prompt(stage_idx, role, query, language, stages)
                 stage_content = ""
@@ -857,25 +1141,38 @@ perception over events."""
                 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
-
-                # 문학적 점수 평가
-                literary_score = self.evaluate_literary_quality(stage_content, role)
-                stages[stage_idx]["literary_score"] = literary_score
+                    stages[stage_idx]["word_count"] = len(stage_content.split())
+                    yield f"🔄 {stage_name} 작성 중... ({total_words + stages[stage_idx]['word_count']:,}단어)", stages, self.current_session_id
+
+                # 진행도 평가
+                if role.startswith("writer"):
+                    writer_num = int(re.search(r'\d+', role).group())
+                    progression_score = self.evaluate_progression(stage_content, writer_num)
+                    stages[stage_idx]["progression_score"] = progression_score
+                    
+                    # 서사 추적기 업데이트
+                    self.update_narrative_tracker(stage_content, writer_num)
 
                 stages[stage_idx]["status"] = "complete"
                 NovelDatabase.save_stage(
                     self.current_session_id, stage_idx, stage_name, role,
-                    stage_content, "complete", literary_score
+                    stage_content, "complete", stages[stage_idx].get("progression_score", 0.0)
                 )
-                yield "", stages, self.current_session_id
+                
+                # 서사 추적기 저장
+                NovelDatabase.save_narrative_tracker(self.current_session_id, self.narrative_tracker)
+                
+                # 총 단어 수 업데이트
+                total_words = NovelDatabase.get_total_words(self.current_session_id)
+                yield f"✅ {stage_name} 완료 (총 {total_words:,}단어)", stages, self.current_session_id
 
             # 최종 소설 정리
             final_novel = NovelDatabase.get_writer_content(self.current_session_id)
-            final_report = self.generate_literary_report(final_novel, language)
+            final_word_count = len(final_novel.split())
+            final_report = self.generate_literary_report(final_novel, final_word_count, language)
             
             NovelDatabase.update_final_novel(self.current_session_id, final_novel, final_report)
-            yield f"✅ 소설 완성! 총 {len(final_novel.split())}단어", stages, self.current_session_id
+            yield f"✅ 소설 완성! 총 {final_word_count:,}단어 (목표: {TARGET_WORDS:,}단어)", stages, self.current_session_id
 
         except Exception as e:
             logger.error(f"소설 생성 프로세스 오류: {e}", exc_info=True)
@@ -894,12 +1191,20 @@ perception over events."""
         
         if 3 <= stage_idx <= 12:  # 작가 초안
             writer_num = stage_idx - 2
-            previous_content = self.get_all_content(stages, stage_idx)
-            return self.create_writer_prompt(writer_num, master_plan, previous_content, query, language)
+            previous_content = self.get_previous_writer_content(stages, writer_num)
+            phase_requirements = self.narrative_tracker.generate_phase_requirements(writer_num)
+            narrative_summary = self.generate_narrative_summary(stages, writer_num)
+            
+            return self.create_writer_prompt(
+                writer_num, master_plan, previous_content, 
+                phase_requirements, narrative_summary, language
+            )
         
         if stage_idx == 13:  # 비평가 중간 검토
-            all_content = self.get_all_content(stages, stage_idx)
-            return self.create_critic_consistency_prompt(all_content, query, language)
+            all_content = self.get_all_writer_content(stages, 12)
+            return self.create_critic_consistency_prompt(
+                all_content, self.narrative_tracker, query, language
+            )
             
         if 14 <= stage_idx <= 23:  # 작가 수정
             writer_num = stage_idx - 13
@@ -908,14 +1213,15 @@ perception over events."""
             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)
+            complete_novel = self.get_all_writer_content(stages, 23)
+            word_count = len(complete_novel.split())
+            return self.create_critic_final_prompt(complete_novel, word_count, language)
         
         return ""
 
     def create_director_revision_prompt(self, initial_plan: str, critic_feedback: str, user_query: str, language: str) -> str:
         """감독자 수정 프롬프트"""
-        return f"""비평을 반영하여 기획을 수정하세요.
+        return f"""비평을 반영하여 통합된 서사 구조를 완성하세요.
 
 **원 주제:** {user_query}
 
@@ -925,60 +1231,82 @@ perception over events."""
 **비평:**
 {critic_feedback}
 
-**수정 방향:**
-1. 사회비판적 깊이 강화
-2. 인물의 내면 복잡성 증대
-3. 상징과 은유 정교화
-4. 진부함 제거
+**핵심 수정 사항:**
+1. 반복 구조 완전 제거
+2. 10단계가 하나의 이야기로 연결
+3. 인물의 명확한 변화 궤적
+4. 8,000단어 분량 계획
 
-수정된 마스터플랜을 제시하세요."""
+각 단계가 이전의 필연적 결과가 되도록 수정하세요."""
 
-    def get_all_content(self, stages: List[Dict], current_stage: int) -> str:
-        """현재까지의 모든 내용"""
-        contents = []
-        for i, s in enumerate(stages):
-            if i < current_stage and s["content"] and "writer" in s.get("name", ""):
-                contents.append(s["content"])
-        return "\n\n".join(contents)
+    def get_previous_writer_content(self, stages: List[Dict], current_writer: int) -> str:
+        """이전 작가의 내용 가져오기"""
+        if current_writer == 1:
+            return ""
+        
+        # 바로 이전 작가의 내용
+        prev_idx = current_writer + 1  # stages 인덱스는 writer_num + 2
+        if prev_idx < len(stages) and stages[prev_idx]["content"]:
+            return stages[prev_idx]["content"]
+        
+        return ""
 
-    def get_all_writer_content(self, stages: List[Dict]) -> str:
-        """모든 작가 최종본"""
+    def get_all_writer_content(self, stages: List[Dict], up_to_stage: int) -> str:
+        """특정 단계까지의 모든 작가 내용"""
         contents = []
         for i, s in enumerate(stages):
-            if 14 <= i <= 23 and s["content"]:
+            if i <= up_to_stage and "writer" in s.get("name", "") and s["content"]:
                 contents.append(s["content"])
         return "\n\n".join(contents)
 
-    def evaluate_literary_quality(self, content: str, role: str) -> float:
-        """문학적 품질 평가"""
-        if not content or not role.startswith("writer"):
-            return 0.0
+    def generate_narrative_summary(self, stages: List[Dict], up_to_writer: int) -> str:
+        """현재까지의 서사 요약"""
+        if up_to_writer == 1:
+            return "첫 시작입니다."
         
-        score = 5.0  # 기본 점수
+        summary_parts = []
+        for i in range(1, up_to_writer):
+            if i in self.narrative_tracker.phase_summaries:
+                summary_parts.append(f"[{NARRATIVE_PHASES[i-1]}]: {self.narrative_tracker.phase_summaries[i]}")
+        
+        return "\n".join(summary_parts) if summary_parts else "이전 내용을 이어받아 진행하세요."
+
+    def update_narrative_tracker(self, content: str, writer_num: int):
+        """서사 추적기 업데이트"""
+        # 간단한 요약 생성 (실제로는 더 정교한 분석 필요)
+        lines = content.split('\n')
+        key_events = [line.strip() for line in lines if len(line.strip()) > 50][:3]
+        
+        if key_events:
+            summary = " ".join(key_events[:2])[:200] + "..."
+            self.narrative_tracker.phase_summaries[writer_num] = summary
+
+    def evaluate_progression(self, content: str, phase: int) -> float:
+        """서사 진행도 평가"""
+        score = 5.0
         
-        # 내면 서술 평가
-        introspective_patterns = ['생각했다', '느꼈다', '기억', '의식', '떠올렸다', 
-                                 '마음', '머릿속', '가슴', 'thought', 'felt', 'remembered']
-        introspection_count = sum(1 for pattern in introspective_patterns if pattern in content)
-        score += min(2.0, introspection_count * 0.2)
+        # 분량 체크
+        word_count = len(content.split())
+        if word_count >= MIN_WORDS_PER_WRITER:
+            score += 2.0
         
-        # 감각적 디테일
-        sensory_patterns = ['냄새', '소리', '빛', '그림자', '촉감', '맛', '온도', '색', 
-                           'smell', 'sound', 'light', 'shadow', 'touch', 'taste']
-        sensory_count = sum(1 for pattern in sensory_patterns if pattern in content)
-        score += min(1.5, sensory_count * 0.15)
+        # 새로운 요소 체크
+        if phase > 1:
+            prev_summary = self.narrative_tracker.phase_summaries.get(phase-1, "")
+            if prev_summary and len(set(content.split()) - set(prev_summary.split())) > 100:
+                score += 1.5
         
-        # 사회적 맥락
-        social_patterns = ['임대', '계급', '빈곤', '격차', '차별', '소외', '불평등', 
-                          'rent', 'class', 'poverty', 'gap', 'discrimination']
-        social_count = sum(1 for pattern in social_patterns if pattern in content)
-        score += min(1.5, social_count * 0.3)
+        # 변화 언급 체크
+        change_keywords = ['변했', '달라졌', '새로운', '이제는', '더 이상', 
+                          'changed', 'different', 'new', 'now', 'no longer']
+        if any(keyword in content for keyword in change_keywords):
+            score += 1.5
         
         return min(10.0, score)
 
-    def generate_literary_report(self, complete_novel: str, language: str) -> str:
-        """최종 문학적 평가 보고서"""
-        prompt = self.create_critic_final_prompt(complete_novel, language)
+    def generate_literary_report(self, complete_novel: str, word_count: int, language: str) -> str:
+        """최종 문학적 평가"""
+        prompt = self.create_critic_final_prompt(complete_novel, word_count, language)
         try:
             report = self.call_llm_sync([{"role": "user", "content": prompt}], "critic", language)
             return report
@@ -994,7 +1322,7 @@ def process_query(query: str, language: str, session_id: Optional[str] = None) -
         yield "", "", "❌ 주제를 입력해주세요.", session_id
         return
     
-    system = LiteraryNovelSystem()
+    system = ProgressiveLiterarySystem()
     stages_markdown = ""
     novel_content = ""
     
@@ -1011,13 +1339,14 @@ def process_query(query: str, language: str, session_id: Optional[str] = None) -
 def get_active_sessions(language: str) -> List[str]:
     """활성 세션 목록"""
     sessions = NovelDatabase.get_active_sessions()
-    return [f"{s['session_id'][:8]}... - {s['user_query'][:50]}... ({s['created_at']})" 
+    return [f"{s['session_id'][:8]}... - {s['user_query'][:50]}... ({s['created_at']}) [{s['total_words']:,}단어]" 
             for s in sessions]
 
 def auto_recover_session(language: str) -> Tuple[Optional[str], str]:
     """최근 세션 자동 복구"""
-    latest_session = NovelDatabase.get_latest_active_session()
-    if latest_session:
+    sessions = NovelDatabase.get_active_sessions()
+    if sessions:
+        latest_session = sessions[0]
         return latest_session['session_id'], f"세션 {latest_session['session_id'][:8]}... 복��됨"
     return None, "복구할 세션이 없습니다."
 
@@ -1057,17 +1386,27 @@ def download_novel(novel_text: str, format_type: str, language: str, session_id:
 def format_stages_display(stages: List[Dict]) -> str:
     """단계별 진행 상황 표시"""
     markdown = "## 🎬 진행 상황\n\n"
+    
+    # 총 단어 수 계산
+    total_words = sum(s.get('word_count', 0) for s in stages if 'writer' in s.get('name', ''))
+    markdown += f"**총 단어 수: {total_words:,} / {TARGET_WORDS:,}**\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('literary_score', 0) > 0:
-            markdown += f" (문학성: {stage['literary_score']:.1f}/10)"
+        if stage.get('word_count', 0) > 0:
+            markdown += f" ({stage['word_count']:,}단어)"
+        
+        if stage.get('progression_score', 0) > 0:
+            markdown += f" [진행도: {stage['progression_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:
@@ -1076,24 +1415,32 @@ def format_novel_display(novel_text: str) -> str:
         return "아직 완성된 내용이 없습니다."
     
     formatted = "# 📖 완성된 소설\n\n"
-    formatted += novel_text
+    
+    # 단어 수 표시
+    word_count = len(novel_text.split())
+    formatted += f"**총 분량: {word_count:,}단어 (목표: {TARGET_WORDS:,}단어)**\n\n"
+    formatted += "---\n\n"
+    
+    # 각 단계를 구분하여 표시
+    sections = novel_text.split('\n\n')
+    for i, section in enumerate(sections):
+        if section.strip():
+            formatted += f"{section}\n\n"
     
     return formatted
 
 def export_to_docx(content: str, filename: str, language: str, session_id: str) -> str:
-    """DOCX 파일로 내보내기 (문학 소설 형식)"""
+    """DOCX 파일로 내보내기"""
     doc = Document()
     
-    # 신국판 크기 (152mm x 225mm)
+    # 페이지 설정
     section = doc.sections[0]
-    section.page_height = Inches(8.86)  # 225mm
-    section.page_width = Inches(5.98)   # 152mm
-    
-    # 여백 설정
-    section.top_margin = Inches(0.79)    # 20mm
-    section.bottom_margin = Inches(0.79)
-    section.left_margin = Inches(0.79)
-    section.right_margin = Inches(0.79)
+    section.page_height = Inches(11)
+    section.page_width = Inches(8.5)
+    section.top_margin = Inches(1)
+    section.bottom_margin = Inches(1)
+    section.left_margin = Inches(1.25)
+    section.right_margin = Inches(1.25)
     
     # 세션 정보
     session = NovelDatabase.get_session(session_id)
@@ -1102,26 +1449,27 @@ def export_to_docx(content: str, filename: str, language: str, session_id: str)
     title_para = doc.add_paragraph()
     title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
     
-    # 빈 줄 추가
-    for _ in range(8):
-        doc.add_paragraph()
-    
     if session:
         title_run = title_para.add_run(session["user_query"])
-        title_run.font.size = Pt(16)
-        title_run.font.name = '바탕'
+        title_run.font.size = Pt(24)
+        title_run.bold = True
+    
+    # 메타 정보
+    doc.add_paragraph()
+    meta_para = doc.add_paragraph()
+    meta_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    meta_para.add_run(f"생성일: {datetime.now().strftime('%Y년 %m월 %d일')}\n")
+    meta_para.add_run(f"총 단어 수: {len(content.split()):,}단어")
     
     # 페이지 나누기
     doc.add_page_break()
     
     # 본문 스타일 설정
     style = doc.styles['Normal']
-    style.font.name = '바탕'
-    style.font.size = Pt(10.5)
-    style.paragraph_format.line_spacing = 1.8
-    style.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-    style.paragraph_format.first_line_indent = Inches(0.35)
-    style.paragraph_format.space_after = Pt(3)
+    style.font.name = 'Calibri'
+    style.font.size = Pt(11)
+    style.paragraph_format.line_spacing = 1.5
+    style.paragraph_format.space_after = Pt(6)
     
     # 본문 추가
     paragraphs = content.split('\n\n')
@@ -1142,52 +1490,50 @@ def export_to_txt(content: str, filename: str) -> str:
     return filepath
 
 
-# CSS 스타일 (문학적 분위기)
+# CSS 스타일
 custom_css = """
 .gradio-container {
-    background: linear-gradient(135deg, #1a1a1a 0%, #2d2d2d 50%, #1a1a1a 100%);
+    background: linear-gradient(135deg, #1e3c72 0%, #2a5298 50%, #1e3c72 100%);
     min-height: 100vh;
 }
 
 .main-header {
-    background-color: rgba(255, 255, 255, 0.03);
+    background-color: rgba(255, 255, 255, 0.1);
     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);
+    border: 1px solid rgba(255, 255, 255, 0.2);
 }
 
-.literary-note {
-    background-color: rgba(255, 255, 255, 0.05);
-    border-left: 3px solid #888;
+.progress-note {
+    background-color: rgba(255, 223, 0, 0.1);
+    border-left: 3px solid #ffd700;
     padding: 15px;
     margin: 20px 0;
     border-radius: 8px;
-    color: #ccc;
-    font-style: italic;
-    font-family: 'Georgia', serif;
+    color: #fff;
 }
 
 .input-section {
-    background-color: rgba(255, 255, 255, 0.05);
+    background-color: rgba(255, 255, 255, 0.1);
     backdrop-filter: blur(10px);
     padding: 20px;
     border-radius: 12px;
     margin-bottom: 20px;
-    border: 1px solid rgba(255, 255, 255, 0.1);
+    border: 1px solid rgba(255, 255, 255, 0.2);
 }
 
 .session-section {
-    background-color: rgba(255, 255, 255, 0.05);
+    background-color: rgba(255, 255, 255, 0.1);
     backdrop-filter: blur(10px);
     padding: 15px;
     border-radius: 8px;
     margin-top: 20px;
     color: white;
-    border: 1px solid rgba(255, 255, 255, 0.1);
+    border: 1px solid rgba(255, 255, 255, 0.2);
 }
 
 #stages-display {
@@ -1200,15 +1546,12 @@ custom_css = """
 }
 
 #novel-output {
-    background-color: rgba(255, 255, 255, 0.98);
-    padding: 40px;
+    background-color: rgba(255, 255, 255, 0.95);
+    padding: 30px;
     border-radius: 12px;
     max-height: 700px;
     overflow-y: auto;
     box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-    font-family: '바탕', 'Batang', 'Georgia', serif;
-    line-height: 2;
-    color: #333;
 }
 
 .download-section {
@@ -1219,50 +1562,41 @@ custom_css = """
     box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
 }
 
-/* 문학적 스타일 */
-#novel-output p {
-    text-indent: 2em;
-    margin-bottom: 1em;
-    text-align: justify;
+/* 진행 표시기 스타일 */
+.progress-bar {
+    background-color: #e0e0e0;
+    height: 20px;
+    border-radius: 10px;
+    overflow: hidden;
+    margin: 10px 0;
 }
 
-#novel-output h1 {
-    color: #1a1a1a;
-    font-weight: normal;
-    text-align: center;
-    margin: 2em 0;
-    font-size: 1.8em;
-}
-
-/* 인용문이나 내적 독백 스타일 */
-#novel-output blockquote {
-    margin: 1.5em 2em;
-    font-style: italic;
-    color: #555;
-    border-left: 3px solid #ccc;
-    padding-left: 1em;
+.progress-fill {
+    background-color: #4CAF50;
+    height: 100%;
+    transition: width 0.3s ease;
 }
 """
 
 
 # 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; font-weight: normal;">
-                📖 AI 문학 소설 생성 시스템
+            <h1 style="font-size: 2.5em; margin-bottom: 10px;">
+                📚 AI 진행형 장편소설 생성 시스템
             </h1>
-            <h3 style="color: #ccc; margin-bottom: 20px; font-weight: normal;">
-                현대 한국 문학의 전통을 잇는 소설 창작
+            <h3 style="color: #ddd; margin-bottom: 20px;">
+                8,000단어 이상의 통합된 서사 구조를 가진 중편소설 창작
             </h3>
-            <p style="font-size: 1.1em; color: #ddd; max-width: 800px; margin: 0 auto;">
-                사회비판적 리얼리즘과 심리적 깊이를 결합한 30페이지 중편소설을 생성합니다.
+            <p style="font-size: 1.1em; color: #eee; max-width: 800px; margin: 0 auto;">
+                10개의 유기적으로 연결된 단계를 통해 하나의 완전한 이야기를 만들어냅니다.
                 <br>
-                개인의 내면과 사회 구조의 상호작용을 섬세하게 포착합니다.
+                각 단계는 이전 단계의 필연적 결과로 이어지며, 인물의 변화와 성장을 추적합니다.
             </p>
-            <div class="literary-note">
-                "가장 개인적인 것이 가장 보편적인 것이다"
+            <div class="progress-note">
+                ⚡ 반복이 아닌 축적, 순환이 아닌 진행을 통한 진정한 장편 서사
             </div>
         </div>
         """)
@@ -1275,7 +1609,7 @@ def create_interface():
                 with gr.Group(elem_classes=["input-section"]):
                     query_input = gr.Textbox(
                         label="소설 주제 / Novel Theme",
-                        placeholder="현대 사회의 문제나 인간의 조건에 대한 주제를 입력하세요...\nEnter themes about contemporary social issues or human condition...",
+                        placeholder="중편소설의 주제를 입력하세요. 인물의 변화와 성장이 중심이 되는 이야기...\nEnter the theme for your novella. Focus on character transformation and growth...",
                         lines=4
                     )
                     
@@ -1297,7 +1631,7 @@ def create_interface():
                     
                     # 세션 관리
                     with gr.Group(elem_classes=["session-section"]):
-                        gr.Markdown("### 💾 이전 세션 재개")
+                        gr.Markdown("### 💾 진행 중인 세션")
                         session_dropdown = gr.Dropdown(
                             label="세션 선택",
                             choices=[],
@@ -1306,10 +1640,10 @@ def create_interface():
                         with gr.Row():
                             refresh_btn = gr.Button("🔄 목록 새로고침", scale=1)
                             resume_btn = gr.Button("▶️ 선택 재개", variant="secondary", scale=1)
-                            auto_recover_btn = gr.Button("♻️ 자동 복구", scale=1)
+                            auto_recover_btn = gr.Button("♻️ 최근 세션 복구", scale=1)
         
         with gr.Column(scale=2):
-            with gr.Tab("📝 창작 과정"):
+            with gr.Tab("📝 창작 진행"):
                 stages_display = gr.Markdown(
                     value="창작 과정이 여기에 표시됩니다...",
                     elem_id="stages-display"
@@ -1339,21 +1673,20 @@ def create_interface():
         # 숨겨진 상태
         novel_text_state = gr.State("")
         
-        # 예제 (문학적 주제)
+        # 예제
         with gr.Row():
             gr.Examples(
                 examples=[
-                    ["도시 빈민의 주거권과 계급 갈등"],
-                    ["비정규직 청년의 불안과 소외"],
-                    ["돌봄 노동자의 보이지 않는 삶"],
-                    ["젠트리피케이션과 도시 난민"],
-                    ["The invisible labor of care workers"],
-                    ["Digital divide and social isolation"],
-                    ["세대 간 단절과 노인 빈곤"],
-                    ["환경 재난 시대의 불평등"]
+                    ["실직한 중년 남성이 새로운 삶의 의미를 찾아가는 여정"],
+                    ["도시에서 시골로 이주한 청년의 적응과 성장 이야기"],
+                    ["세 세대가 함께 사는 가족의 갈등과 화해"],
+                    ["A middle-aged woman's journey to rediscover herself after divorce"],
+                    ["The transformation of a cynical journalist through unexpected encounters"],
+                    ["작은 서점을 운영하는 노부부의 마지막 1년"],
+                    ["AI 시대에 일자리를 잃은 번역가의 새로운 도전"]
                 ],
                 inputs=query_input,
-                label="💡 문학적 주제 예시"
+                label="💡 주제 예시"
             )
         
         # 이벤트 핸들러
@@ -1367,7 +1700,7 @@ def create_interface():
         
         def handle_auto_recover(language):
             session_id, message = auto_recover_session(language)
-            return session_id
+            return session_id, message
         
         # 이벤트 연결
         submit_btn.click(
@@ -1383,7 +1716,7 @@ def create_interface():
         )
         
         resume_btn.click(
-            fn=lambda x: x,
+            fn=lambda x: x.split("...")[0] if x and "..." in x else x,
             inputs=[session_dropdown],
             outputs=[current_session_id]
         ).then(
@@ -1395,7 +1728,7 @@ def create_interface():
         auto_recover_btn.click(
             fn=handle_auto_recover,
             inputs=[language_select],
-            outputs=[current_session_id]
+            outputs=[current_session_id, status_text]
         ).then(
             fn=resume_session,
             inputs=[current_session_id, language_select],
@@ -1413,7 +1746,7 @@ def create_interface():
         )
         
         def handle_download(format_type, language, session_id, novel_text):
-            if not session_id:
+            if not session_id or not novel_text:
                 return gr.update(visible=False)
             
             file_path = download_novel(novel_text, format_type, language, session_id)
@@ -1439,11 +1772,13 @@ def create_interface():
 
 # 메인 실행
 if __name__ == "__main__":
-    logger.info("AI 문학 소설 생성 시스템 시작...")
+    logger.info("AI 진행형 장편소설 생성 시스템 시작...")
     logger.info("=" * 60)
     
     # 환경 확인
     logger.info(f"API 엔드포인트: {API_URL}")
+    logger.info(f"목표 분량: {TARGET_WORDS:,}단어")
+    logger.info(f"작가당 최소 분량: {MIN_WORDS_PER_WRITER:,}단어")
     
     if BRAVE_SEARCH_API_KEY:
         logger.info("웹 검색이 활성화되었습니다.")
@@ -1470,4 +1805,4 @@ if __name__ == "__main__":
         server_port=7860,
         share=False,
         debug=True
-    )
+    )