Upload report_enhancement.py

report_enhancement.py

@@ -0,0 +1,1829 @@
+"""
+AETHER Proto-AGI v2.2 - Report Enhancement Module
+출처 관리, 유형별 포맷터, 전문 보고서 생성기
+
+이 파일의 클래스들을 core.py에 통합하세요.
+기존 ReportGenerator 클래스를 아래 ProfessionalReportGenerator로 교체하세요.
+"""
+
+import json
+import re
+from datetime import datetime
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict, Any, Tuple
+from enum import Enum
+
+
+# ==================== SourceManager (P0-2) ====================
+
+@dataclass
+class WebSource:
+    """웹 검색 출처"""
+    title: str
+    url: str
+    snippet: str
+    element: str  # 어느 오행 단계에서 사용되었는지
+    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
+    relevance_score: float = 0.0
+
+@dataclass
+class KnowledgeSource:
+    """지식 DB 출처"""
+    knowledge_id: str
+    goal: str
+    quality_score: float
+    element: str
+    created_at: str
+    snippet: str
+
+@dataclass
+class CrawlSource:
+    """URL 크롤링 출처"""
+    url: str
+    title: str
+    content_preview: str
+    crawled_at: str
+    success: bool
+
+
+class SourceManager:
+    """
+    출처/인용 통합 관리 시스템
+    
+    모든 분석 과정에서 사용된 출처를 추적하고
+    최종 보고서에 체계적으로 표시합니다.
+    """
+    
+    def __init__(self):
+        self.web_sources: List[WebSource] = []
+        self.knowledge_sources: List[KnowledgeSource] = []
+        self.crawl_sources: List[CrawlSource] = []
+        self._citation_counter = 0
+        self._citation_map: Dict[str, int] = {}  # url/id -> citation number
+    
+    def reset(self):
+        """새 분석 세션 시작 시 초기화"""
+        self.web_sources = []
+        self.knowledge_sources = []
+        self.crawl_sources = []
+        self._citation_counter = 0
+        self._citation_map = {}
+    
+    # ===== 출처 추가 =====
+    
+    def add_web_source(self, title: str, url: str, snippet: str, 
+                       element: str, relevance_score: float = 0.0) -> int:
+        """웹 검색 결과 출처 추가"""
+        if url in self._citation_map:
+            return self._citation_map[url]
+        
+        self._citation_counter += 1
+        citation_num = self._citation_counter
+        self._citation_map[url] = citation_num
+        
+        source = WebSource(
+            title=title[:100] if title else "Unknown",
+            url=url,
+            snippet=snippet[:300] if snippet else "",
+            element=element,
+            relevance_score=relevance_score
+        )
+        self.web_sources.append(source)
+        return citation_num
+    
+    def add_knowledge_source(self, knowledge_id: str, goal: str, 
+                            quality_score: float, element: str,
+                            created_at: str, snippet: str) -> int:
+        """지식 DB 출처 추가"""
+        if knowledge_id in self._citation_map:
+            return self._citation_map[knowledge_id]
+        
+        self._citation_counter += 1
+        citation_num = self._citation_counter
+        self._citation_map[knowledge_id] = citation_num
+        
+        source = KnowledgeSource(
+            knowledge_id=knowledge_id,
+            goal=goal[:100] if goal else "",
+            quality_score=quality_score,
+            element=element,
+            created_at=created_at,
+            snippet=snippet[:200] if snippet else ""
+        )
+        self.knowledge_sources.append(source)
+        return citation_num
+    
+    def add_crawl_source(self, url: str, title: str, 
+                        content_preview: str, crawled_at: str,
+                        success: bool = True) -> int:
+        """크롤링 출처 추가"""
+        if url in self._citation_map:
+            return self._citation_map[url]
+        
+        self._citation_counter += 1
+        citation_num = self._citation_counter
+        self._citation_map[url] = citation_num
+        
+        source = CrawlSource(
+            url=url,
+            title=title[:100] if title else url[:50],
+            content_preview=content_preview[:200] if content_preview else "",
+            crawled_at=crawled_at,
+            success=success
+        )
+        self.crawl_sources.append(source)
+        return citation_num
+    
+    def add_from_search_result(self, search_result: Dict, element: str):
+        """Brave 검색 결과에서 출처 일괄 추가"""
+        if not search_result or not search_result.get("success"):
+            return
+        
+        for result in search_result.get("results", []):
+            self.add_web_source(
+                title=result.get("title", ""),
+                url=result.get("url", ""),
+                snippet=result.get("description", ""),
+                element=element
+            )
+    
+    # ===== 출처 조회 =====
+    
+    def get_citation_number(self, url_or_id: str) -> Optional[int]:
+        """URL 또는 ID로 인용 번호 조회"""
+        return self._citation_map.get(url_or_id)
+    
+    def get_total_sources(self) -> Dict[str, int]:
+        """출처 유형별 개수"""
+        return {
+            "web": len(self.web_sources),
+            "knowledge": len(self.knowledge_sources),
+            "crawl": len(self.crawl_sources),
+            "total": len(self.web_sources) + len(self.knowledge_sources) + len(self.crawl_sources)
+        }
+    
+    def get_sources_by_element(self) -> Dict[str, List]:
+        """오행 단계별 사용된 출처"""
+        by_element = {"土": [], "金": [], "水": [], "木": [], "火": []}
+        
+        for src in self.web_sources:
+            if src.element in by_element:
+                by_element[src.element].append({
+                    "type": "web",
+                    "title": src.title,
+                    "url": src.url
+                })
+        
+        for src in self.knowledge_sources:
+            if src.element in by_element:
+                by_element[src.element].append({
+                    "type": "knowledge",
+                    "id": src.knowledge_id,
+                    "quality": src.quality_score
+                })
+        
+        return by_element
+    
+    # ===== 출력 포맷팅 =====
+    
+    def format_references_section(self, language: str = "EN") -> str:
+        """최종 보고서용 출처 섹션 생성"""
+        if language == "KR":
+            return self._format_references_kr()
+        return self._format_references_en()
+    
+    def _format_references_en(self) -> str:
+        """영어 출처 섹션"""
+        lines = ["## 📚 Sources & References", ""]
+        
+        total = self.get_total_sources()
+        if total["total"] == 0:
+            lines.append("*No external sources used in this analysis.*")
+            return "\n".join(lines)
+        
+        # 요약 통계
+        lines.append(f"**Total Sources**: {total['total']} "
+                    f"(Web: {total['web']}, Knowledge DB: {total['knowledge']}, Crawl: {total['crawl']})")
+        lines.append("")
+        
+        # 웹 출처
+        if self.web_sources:
+            lines.append("### 🌐 Web Sources")
+            lines.append("| # | Title | Source | Element |")
+            lines.append("|---|-------|--------|---------|")
+            for i, src in enumerate(self.web_sources[:10], 1):
+                domain = self._extract_domain(src.url)
+                lines.append(f"| [{i}] | {src.title[:40]}{'...' if len(src.title) > 40 else ''} | [{domain}]({src.url}) | {src.element} |")
+            if len(self.web_sources) > 10:
+                lines.append(f"| ... | *+{len(self.web_sources) - 10} more sources* | | |")
+            lines.append("")
+        
+        # 지식 DB 출처
+        if self.knowledge_sources:
+            lines.append("### 🧠 Knowledge Database")
+            lines.append("| # | Related Goal | Quality | Element |")
+            lines.append("|---|--------------|---------|---------|")
+            for i, src in enumerate(self.knowledge_sources[:5], 1):
+                quality_bar = '█' * int(src.quality_score * 5) + '░' * (5 - int(src.quality_score * 5))
+                lines.append(f"| [K{i}] | {src.goal[:35]}{'...' if len(src.goal) > 35 else ''} | {quality_bar} {src.quality_score:.0%} | {src.element} |")
+            lines.append("")
+        
+        # 크롤링 출처
+        if self.crawl_sources:
+            lines.append("### 🔗 Crawled Pages")
+            for i, src in enumerate(self.crawl_sources[:5], 1):
+                status = "✅" if src.success else "⚠️"
+                lines.append(f"- {status} [{src.title[:50]}]({src.url})")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _format_references_kr(self) -> str:
+        """한국어 출처 섹션"""
+        lines = ["## 📚 출처 및 참고자료", ""]
+        
+        total = self.get_total_sources()
+        if total["total"] == 0:
+            lines.append("*이 분석에 사용된 외부 출처가 없습니다.*")
+            return "\n".join(lines)
+        
+        # 요약 통계
+        lines.append(f"**총 출처**: {total['total']}건 "
+                    f"(웹: {total['web']}, 지식DB: {total['knowledge']}, 크롤링: {total['crawl']})")
+        lines.append("")
+        
+        # 웹 출처
+        if self.web_sources:
+            lines.append("### 🌐 웹 검색 출처")
+            lines.append("| # | 제목 | 출처 | 단계 |")
+            lines.append("|---|------|------|------|")
+            for i, src in enumerate(self.web_sources[:10], 1):
+                domain = self._extract_domain(src.url)
+                element_name = {"土": "감독", "金": "비평", "水": "리서치", "木": "창발", "火": "실행"}.get(src.element, src.element)
+                lines.append(f"| [{i}] | {src.title[:40]}{'...' if len(src.title) > 40 else ''} | [{domain}]({src.url}) | {src.element}({element_name}) |")
+            if len(self.web_sources) > 10:
+                lines.append(f"| ... | *+{len(self.web_sources) - 10}건 추가* | | |")
+            lines.append("")
+        
+        # 지식 DB 출처
+        if self.knowledge_sources:
+            lines.append("### 🧠 지식 데이터베이스")
+            lines.append("| # | 관련 목표 | 품질 | 단계 |")
+            lines.append("|---|----------|------|------|")
+            for i, src in enumerate(self.knowledge_sources[:5], 1):
+                quality_bar = '█' * int(src.quality_score * 5) + '░' * (5 - int(src.quality_score * 5))
+                lines.append(f"| [K{i}] | {src.goal[:35]}{'...' if len(src.goal) > 35 else ''} | {quality_bar} {src.quality_score:.0%} | {src.element} |")
+            lines.append("")
+        
+        # 크롤링 출처
+        if self.crawl_sources:
+            lines.append("### 🔗 크롤링 페이지")
+            for i, src in enumerate(self.crawl_sources[:5], 1):
+                status = "✅" if src.success else "⚠️"
+                lines.append(f"- {status} [{src.title[:50]}]({src.url})")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    def format_inline_citation(self, url_or_id: str) -> str:
+        """본문 내 인라인 인용 형식 생성 [1], [K2] 등"""
+        num = self._citation_map.get(url_or_id)
+        if num is None:
+            return ""
+        
+        # 지식 DB 출처인지 확인
+        for src in self.knowledge_sources:
+            if src.knowledge_id == url_or_id:
+                return f"[K{num}]"
+        
+        return f"[{num}]"
+    
+    def _extract_domain(self, url: str) -> str:
+        """URL에서 도메인 추출"""
+        try:
+            from urllib.parse import urlparse
+            parsed = urlparse(url)
+            domain = parsed.netloc
+            # www. 제거
+            if domain.startswith("www."):
+                domain = domain[4:]
+            return domain[:30]
+        except:
+            return url[:30]
+    
+    def to_dict(self) -> Dict:
+        """직렬화용 딕셔너리 변환"""
+        return {
+            "web_sources": [
+                {"title": s.title, "url": s.url, "element": s.element, "snippet": s.snippet}
+                for s in self.web_sources
+            ],
+            "knowledge_sources": [
+                {"id": s.knowledge_id, "goal": s.goal, "quality": s.quality_score, "element": s.element}
+                for s in self.knowledge_sources
+            ],
+            "crawl_sources": [
+                {"url": s.url, "title": s.title, "success": s.success}
+                for s in self.crawl_sources
+            ],
+            "total": self.get_total_sources()
+        }
+
+
+# ==================== TypedOutputFormatter (P1-1) ====================
+
+class TypedOutputFormatter:
+    """
+    질문 유형별 맞춤 출력 포맷터
+    
+    예측, 비교, 전략, 분석, 발명, 스토리, 레시피 등
+    각 유형에 최적화된 출력 구조를 제공합니다.
+    """
+    
+    # 질문 유형별 아이콘
+    TYPE_ICONS = {
+        "prediction": "🔮",
+        "comparison": "⚖️",
+        "strategy": "🎯",
+        "analysis": "🔬",
+        "invention": "💡",
+        "story": "📖",
+        "recipe": "🍳",
+        "general": "📋"
+    }
+    
+    # 한국어 유형명
+    TYPE_NAMES_KR = {
+        "prediction": "예측 분석",
+        "comparison": "비교 분석",
+        "strategy": "전략 수립",
+        "analysis": "심층 분석",
+        "invention": "발명/특허",
+        "story": "스토리/창작",
+        "recipe": "레시피/요리",
+        "general": "일반 분석"
+    }
+    
+    TYPE_NAMES_EN = {
+        "prediction": "Prediction Analysis",
+        "comparison": "Comparative Analysis",
+        "strategy": "Strategic Planning",
+        "analysis": "In-depth Analysis",
+        "invention": "Invention/Patent",
+        "story": "Story/Creative",
+        "recipe": "Recipe/Cooking",
+        "general": "General Analysis"
+    }
+    
+    @classmethod
+    def format(cls, question_type: str, data: Dict, language: str = "EN") -> str:
+        """질문 유형에 맞는 포맷 적용"""
+        formatters = {
+            "prediction": cls.format_prediction,
+            "comparison": cls.format_comparison,
+            "strategy": cls.format_strategy,
+            "analysis": cls.format_analysis,
+            "invention": cls.format_invention,
+            "story": cls.format_story,
+            "recipe": cls.format_recipe,
+            "general": cls.format_general
+        }
+        
+        formatter = formatters.get(question_type, cls.format_general)
+        return formatter(data, language)
+    
+    @classmethod
+    def get_type_header(cls, question_type: str, language: str = "EN") -> str:
+        """질문 유형 헤더 생성"""
+        icon = cls.TYPE_ICONS.get(question_type, "📋")
+        if language == "KR":
+            name = cls.TYPE_NAMES_KR.get(question_type, "일반 분석")
+            return f"{icon} **분석 유형**: {name}"
+        else:
+            name = cls.TYPE_NAMES_EN.get(question_type, "General Analysis")
+            return f"{icon} **Analysis Type**: {name}"
+    
+    # ===== 예측 분석 포맷 =====
+    
+    @classmethod
+    def format_prediction(cls, data: Dict, language: str = "EN") -> str:
+        """예측 분석용 포맷 - 시나리오, 확률, 변수"""
+        if language == "KR":
+            return cls._format_prediction_kr(data)
+        return cls._format_prediction_en(data)
+    
+    @classmethod
+    def _format_prediction_en(cls, data: Dict) -> str:
+        lines = ["### 🔮 Prediction Framework", ""]
+        
+        # 시나리오 테이블
+        scenarios = data.get("scenarios", [])
+        if scenarios:
+            lines.append("#### Scenario Analysis")
+            lines.append("| Scenario | Probability | Key Drivers | Timeline |")
+            lines.append("|----------|-------------|-------------|----------|")
+            for i, s in enumerate(scenarios[:4], 1):
+                prob = s.get("probability", "?")
+                drivers = s.get("drivers", "-")[:30]
+                timeline = s.get("timeline", "-")
+                lines.append(f"| **{s.get('name', f'Scenario {i}')}** | {prob} | {drivers} | {timeline} |")
+            lines.append("")
+        
+        # 핵심 변수
+        variables = data.get("key_variables", [])
+        if variables:
+            lines.append("#### Key Variables & Uncertainties")
+            for v in variables[:5]:
+                impact = v.get("impact", "medium")
+                icon = "🔴" if impact == "high" else "🟡" if impact == "medium" else "🟢"
+                lines.append(f"- {icon} **{v.get('name', 'Variable')}**: {v.get('description', '')[:60]}")
+            lines.append("")
+        
+        # 예측 신뢰도
+        confidence = data.get("prediction_confidence", 0)
+        if confidence:
+            bar = '█' * int(confidence * 10) + '░' * (10 - int(confidence * 10))
+            lines.append(f"**Prediction Confidence**: {bar} {confidence:.0%}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    @classmethod
+    def _format_prediction_kr(cls, data: Dict) -> str:
+        lines = ["### 🔮 예측 프레임워크", ""]
+        
+        # 시나리오 테이블
+        scenarios = data.get("scenarios", [])
+        if scenarios:
+            lines.append("#### 시나리오 분석")
+            lines.append("| 시나리오 | 확률 | 핵심 동인 | 시점 |")
+            lines.append("|----------|------|----------|------|")
+            for i, s in enumerate(scenarios[:4], 1):
+                prob = s.get("probability", "?")
+                drivers = s.get("drivers", "-")[:30]
+                timeline = s.get("timeline", "-")
+                lines.append(f"| **{s.get('name', f'시나리오 {i}')}** | {prob} | {drivers} | {timeline} |")
+            lines.append("")
+        
+        # 핵심 변수
+        variables = data.get("key_variables", [])
+        if variables:
+            lines.append("#### 핵심 변수 및 불확실성")
+            for v in variables[:5]:
+                impact = v.get("impact", "medium")
+                icon = "🔴" if impact == "high" else "🟡" if impact == "medium" else "🟢"
+                lines.append(f"- {icon} **{v.get('name', '변수')}**: {v.get('description', '')[:60]}")
+            lines.append("")
+        
+        # 예측 신뢰도
+        confidence = data.get("prediction_confidence", 0)
+        if confidence:
+            bar = '█' * int(confidence * 10) + '░' * (10 - int(confidence * 10))
+            lines.append(f"**예측 신뢰도**: {bar} {confidence:.0%}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    # ===== 비교 분석 포맷 =====
+    
+    @classmethod
+    def format_comparison(cls, data: Dict, language: str = "EN") -> str:
+        """비교 분석용 포맷 - 매트릭스, 장단점, 권장"""
+        if language == "KR":
+            return cls._format_comparison_kr(data)
+        return cls._format_comparison_en(data)
+    
+    @classmethod
+    def _format_comparison_en(cls, data: Dict) -> str:
+        lines = ["### ⚖️ Comparison Matrix", ""]
+        
+        # 비교 대상
+        items = data.get("comparison_items", [])
+        criteria = data.get("criteria", [])
+        
+        if items and criteria:
+            # 헤더 생성
+            header = "| Criteria |"
+            separator = "|----------|"
+            for item in items[:4]:
+                header += f" {item.get('name', 'Option')[:15]} |"
+                separator += "--------|"
+            lines.append(header)
+            lines.append(separator)
+            
+            # 각 기준별 비교
+            for crit in criteria[:6]:
+                row = f"| **{crit.get('name', 'Criterion')[:20]}** |"
+                for item in items[:4]:
+                    score = item.get("scores", {}).get(crit.get("name", ""), "-")
+                    if isinstance(score, (int, float)):
+                        score = f"{'⭐' * int(score)}" if score <= 5 else str(score)
+                    row += f" {str(score)[:10]} |"
+                lines.append(row)
+            lines.append("")
+        
+        # 장단점
+        pros_cons = data.get("pros_cons", {})
+        if pros_cons:
+            lines.append("#### Pros & Cons Summary")
+            for item_name, pc in pros_cons.items():
+                lines.append(f"**{item_name}**")
+                if pc.get("pros"):
+                    lines.append(f"  - ✅ Pros: {', '.join(pc['pros'][:3])}")
+                if pc.get("cons"):
+                    lines.append(f"  - ❌ Cons: {', '.join(pc['cons'][:3])}")
+            lines.append("")
+        
+        # 권장사항
+        recommendation = data.get("recommendation", "")
+        if recommendation:
+            lines.append(f"#### 💡 Recommendation")
+            lines.append(f"> {recommendation}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    @classmethod
+    def _format_comparison_kr(cls, data: Dict) -> str:
+        lines = ["### ⚖️ 비교 매트릭스", ""]
+        
+        # 비교 대상
+        items = data.get("comparison_items", [])
+        criteria = data.get("criteria", [])
+        
+        if items and criteria:
+            header = "| 기준 |"
+            separator = "|------|"
+            for item in items[:4]:
+                header += f" {item.get('name', '옵션')[:15]} |"
+                separator += "--------|"
+            lines.append(header)
+            lines.append(separator)
+            
+            for crit in criteria[:6]:
+                row = f"| **{crit.get('name', '기준')[:20]}** |"
+                for item in items[:4]:
+                    score = item.get("scores", {}).get(crit.get("name", ""), "-")
+                    if isinstance(score, (int, float)):
+                        score = f"{'⭐' * int(score)}" if score <= 5 else str(score)
+                    row += f" {str(score)[:10]} |"
+                lines.append(row)
+            lines.append("")
+        
+        # 장단점
+        pros_cons = data.get("pros_cons", {})
+        if pros_cons:
+            lines.append("#### 장단점 요약")
+            for item_name, pc in pros_cons.items():
+                lines.append(f"**{item_name}**")
+                if pc.get("pros"):
+                    lines.append(f"  - ✅ 장점: {', '.join(pc['pros'][:3])}")
+                if pc.get("cons"):
+                    lines.append(f"  - ❌ 단점: {', '.join(pc['cons'][:3])}")
+            lines.append("")
+        
+        # 권장사항
+        recommendation = data.get("recommendation", "")
+        if recommendation:
+            lines.append(f"#### 💡 권장사항")
+            lines.append(f"> {recommendation}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    # ===== 전략 분석 포맷 =====
+    
+    @classmethod
+    def format_strategy(cls, data: Dict, language: str = "EN") -> str:
+        """전략 분석용 포맷 - 목표, 로드맵, KPI"""
+        if language == "KR":
+            return cls._format_strategy_kr(data)
+        return cls._format_strategy_en(data)
+    
+    @classmethod
+    def _format_strategy_en(cls, data: Dict) -> str:
+        lines = ["### 🎯 Strategic Framework", ""]
+        
+        # 전략 목표
+        objectives = data.get("objectives", [])
+        if objectives:
+            lines.append("#### Strategic Objectives")
+            for i, obj in enumerate(objectives[:5], 1):
+                lines.append(f"{i}. **{obj.get('name', 'Objective')}**: {obj.get('description', '')[:60]}")
+            lines.append("")
+        
+        # 실행 로드맵
+        roadmap = data.get("roadmap", [])
+        if roadmap:
+            lines.append("#### Implementation Roadmap")
+            lines.append("| Phase | Timeline | Key Actions | Deliverables |")
+            lines.append("|-------|----------|-------------|--------------|")
+            for phase in roadmap[:5]:
+                actions = phase.get("actions", ["-"])
+                deliverables = phase.get("deliverables", ["-"])
+                lines.append(f"| {phase.get('name', 'Phase')} | {phase.get('timeline', '-')} | {', '.join(actions[:2])} | {', '.join(deliverables[:2])} |")
+            lines.append("")
+        
+        # KPI
+        kpis = data.get("kpis", [])
+        if kpis:
+            lines.append("#### Key Performance Indicators")
+            for kpi in kpis[:5]:
+                target = kpi.get("target", "TBD")
+                lines.append(f"- 📊 **{kpi.get('name', 'KPI')}**: Target {target}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    @classmethod
+    def _format_strategy_kr(cls, data: Dict) -> str:
+        lines = ["### 🎯 전략 프레임워크", ""]
+        
+        # 전략 목표
+        objectives = data.get("objectives", [])
+        if objectives:
+            lines.append("#### 전략 목표")
+            for i, obj in enumerate(objectives[:5], 1):
+                lines.append(f"{i}. **{obj.get('name', '목표')}**: {obj.get('description', '')[:60]}")
+            lines.append("")
+        
+        # 실행 로드맵
+        roadmap = data.get("roadmap", [])
+        if roadmap:
+            lines.append("#### 실행 로드맵")
+            lines.append("| 단계 | 기간 | 주요 활동 | 산출물 |")
+            lines.append("|------|------|----------|--------|")
+            for phase in roadmap[:5]:
+                actions = phase.get("actions", ["-"])
+                deliverables = phase.get("deliverables", ["-"])
+                lines.append(f"| {phase.get('name', '단계')} | {phase.get('timeline', '-')} | {', '.join(actions[:2])} | {', '.join(deliverables[:2])} |")
+            lines.append("")
+        
+        # KPI
+        kpis = data.get("kpis", [])
+        if kpis:
+            lines.append("#### 핵심 성과 지표 (KPI)")
+            for kpi in kpis[:5]:
+                target = kpi.get("target", "TBD")
+                lines.append(f"- 📊 **{kpi.get('name', 'KPI')}**: 목표 {target}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    # ===== 일반 분석 포맷 =====
+    
+    @classmethod
+    def format_analysis(cls, data: Dict, language: str = "EN") -> str:
+        """일반 분석용 포맷"""
+        if language == "KR":
+            return cls._format_analysis_kr(data)
+        return cls._format_analysis_en(data)
+    
+    @classmethod
+    def _format_analysis_en(cls, data: Dict) -> str:
+        lines = ["### 🔬 Analysis Framework", ""]
+        
+        # 주요 발견
+        findings = data.get("findings", [])
+        if findings:
+            lines.append("#### Key Findings")
+            for i, f in enumerate(findings[:5], 1):
+                lines.append(f"{i}. {f}")
+            lines.append("")
+        
+        # 원인 분석
+        causes = data.get("causes", [])
+        if causes:
+            lines.append("#### Root Cause Analysis")
+            for c in causes[:4]:
+                lines.append(f"- **{c.get('cause', 'Cause')}** → {c.get('effect', 'Effect')[:50]}")
+            lines.append("")
+        
+        # 데이터 포인트
+        data_points = data.get("data_points", [])
+        if data_points:
+            lines.append("#### Supporting Data")
+            for dp in data_points[:5]:
+                lines.append(f"- 📈 {dp}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    @classmethod
+    def _format_analysis_kr(cls, data: Dict) -> str:
+        lines = ["### 🔬 분석 프레임워크", ""]
+        
+        # 주요 발견
+        findings = data.get("findings", [])
+        if findings:
+            lines.append("#### 주요 발견사항")
+            for i, f in enumerate(findings[:5], 1):
+                lines.append(f"{i}. {f}")
+            lines.append("")
+        
+        # 원인 분석
+        causes = data.get("causes", [])
+        if causes:
+            lines.append("#### 원인 분석")
+            for c in causes[:4]:
+                lines.append(f"- **{c.get('cause', '원인')}** → {c.get('effect', '결과')[:50]}")
+            lines.append("")
+        
+        # 데이터 포인트
+        data_points = data.get("data_points", [])
+        if data_points:
+            lines.append("#### 근거 데이터")
+            for dp in data_points[:5]:
+                lines.append(f"- 📈 {dp}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    # ===== 발명/특허 포맷 =====
+    
+    @classmethod
+    def format_invention(cls, data: Dict, language: str = "EN") -> str:
+        """발명/특허용 포맷"""
+        if language == "KR":
+            lines = ["### 💡 발명 개요", ""]
+            
+            if data.get("invention_name"):
+                lines.append(f"**발명의 명칭**: {data['invention_name']}")
+                lines.append("")
+            
+            if data.get("problem"):
+                lines.append("#### 해결하고자 하는 과제")
+                lines.append(data["problem"])
+                lines.append("")
+            
+            if data.get("solution"):
+                lines.append("#### 과제 해결 수단")
+                lines.append(data["solution"])
+                lines.append("")
+            
+            claims = data.get("claims", [])
+            if claims:
+                lines.append("#### 청구항 초안")
+                for i, claim in enumerate(claims[:5], 1):
+                    lines.append(f"**청구항 {i}**: {claim}")
+                    lines.append("")
+            
+            if data.get("advantages"):
+                lines.append("#### 발명의 효과")
+                for adv in data["advantages"][:5]:
+                    lines.append(f"- {adv}")
+                lines.append("")
+        else:
+            lines = ["### 💡 Invention Overview", ""]
+            
+            if data.get("invention_name"):
+                lines.append(f"**Title**: {data['invention_name']}")
+                lines.append("")
+            
+            if data.get("problem"):
+                lines.append("#### Problem to Solve")
+                lines.append(data["problem"])
+                lines.append("")
+            
+            if data.get("solution"):
+                lines.append("#### Solution")
+                lines.append(data["solution"])
+                lines.append("")
+            
+            claims = data.get("claims", [])
+            if claims:
+                lines.append("#### Draft Claims")
+                for i, claim in enumerate(claims[:5], 1):
+                    lines.append(f"**Claim {i}**: {claim}")
+                    lines.append("")
+            
+            if data.get("advantages"):
+                lines.append("#### Advantages")
+                for adv in data["advantages"][:5]:
+                    lines.append(f"- {adv}")
+                lines.append("")
+        
+        return "\n".join(lines)
+    
+    # ===== 스토리/창작 포맷 =====
+    
+    @classmethod
+    def format_story(cls, data: Dict, language: str = "EN") -> str:
+        """스토리/창작용 포맷"""
+        if language == "KR":
+            lines = ["### 📖 스토리 구조", ""]
+            
+            if data.get("logline"):
+                lines.append(f"**로그라인**: {data['logline']}")
+                lines.append("")
+            
+            characters = data.get("characters", [])
+            if characters:
+                lines.append("#### 등장인물")
+                for char in characters[:5]:
+                    lines.append(f"- **{char.get('name', '캐릭터')}**: {char.get('description', '')[:60]}")
+                lines.append("")
+            
+            structure = data.get("structure", {})
+            if structure:
+                lines.append("#### 플롯 구조")
+                for key, value in [("setup", "발단"), ("conflict", "갈등"), ("climax", "절정"), ("resolution", "결말")]:
+                    if structure.get(key):
+                        lines.append(f"- **{value}**: {structure[key][:80]}")
+                lines.append("")
+            
+            if data.get("theme"):
+                lines.append(f"#### 주제")
+                lines.append(data["theme"])
+                lines.append("")
+        else:
+            lines = ["### 📖 Story Structure", ""]
+            
+            if data.get("logline"):
+                lines.append(f"**Logline**: {data['logline']}")
+                lines.append("")
+            
+            characters = data.get("characters", [])
+            if characters:
+                lines.append("#### Characters")
+                for char in characters[:5]:
+                    lines.append(f"- **{char.get('name', 'Character')}**: {char.get('description', '')[:60]}")
+                lines.append("")
+            
+            structure = data.get("structure", {})
+            if structure:
+                lines.append("#### Plot Structure")
+                for key in ["setup", "conflict", "climax", "resolution"]:
+                    if structure.get(key):
+                        lines.append(f"- **{key.capitalize()}**: {structure[key][:80]}")
+                lines.append("")
+            
+            if data.get("theme"):
+                lines.append(f"#### Theme")
+                lines.append(data["theme"])
+                lines.append("")
+        
+        return "\n".join(lines)
+    
+    # ===== 레시피 포맷 =====
+    
+    @classmethod
+    def format_recipe(cls, data: Dict, language: str = "EN") -> str:
+        """레시피용 포맷"""
+        if language == "KR":
+            lines = ["### 🍳 레시피", ""]
+            
+            if data.get("dish_name"):
+                lines.append(f"**요리명**: {data['dish_name']}")
+            if data.get("servings"):
+                lines.append(f"**분량**: {data['servings']}")
+            if data.get("time"):
+                lines.append(f"**조리시간**: {data['time']}")
+            lines.append("")
+            
+            ingredients = data.get("ingredients", [])
+            if ingredients:
+                lines.append("#### 재료")
+                for ing in ingredients:
+                    lines.append(f"- {ing}")
+                lines.append("")
+            
+            steps = data.get("steps", [])
+            if steps:
+                lines.append("#### 조리 순서")
+                for i, step in enumerate(steps, 1):
+                    lines.append(f"{i}. {step}")
+                lines.append("")
+            
+            tips = data.get("tips", [])
+            if tips:
+                lines.append("#### 💡 요리 팁")
+                for tip in tips[:3]:
+                    lines.append(f"- {tip}")
+                lines.append("")
+        else:
+            lines = ["### 🍳 Recipe", ""]
+            
+            if data.get("dish_name"):
+                lines.append(f"**Dish**: {data['dish_name']}")
+            if data.get("servings"):
+                lines.append(f"**Servings**: {data['servings']}")
+            if data.get("time"):
+                lines.append(f"**Time**: {data['time']}")
+            lines.append("")
+            
+            ingredients = data.get("ingredients", [])
+            if ingredients:
+                lines.append("#### Ingredients")
+                for ing in ingredients:
+                    lines.append(f"- {ing}")
+                lines.append("")
+            
+            steps = data.get("steps", [])
+            if steps:
+                lines.append("#### Instructions")
+                for i, step in enumerate(steps, 1):
+                    lines.append(f"{i}. {step}")
+                lines.append("")
+            
+            tips = data.get("tips", [])
+            if tips:
+                lines.append("#### 💡 Tips")
+                for tip in tips[:3]:
+                    lines.append(f"- {tip}")
+                lines.append("")
+        
+        return "\n".join(lines)
+    
+    # ===== 일반 포맷 =====
+    
+    @classmethod
+    def format_general(cls, data: Dict, language: str = "EN") -> str:
+        """일반 분석용 기본 포맷"""
+        lines = []
+        
+        # 주요 내용이 있으면 그대로 출력
+        main_content = data.get("main_content", data.get("result", ""))
+        if main_content:
+            lines.append(main_content)
+            lines.append("")
+        
+        # 핵심 포인트
+        key_points = data.get("key_points", data.get("deliverables", []))
+        if key_points:
+            header = "#### 핵심 포인트" if language == "KR" else "#### Key Points"
+            lines.append(header)
+            for point in key_points[:5]:
+                lines.append(f"- {point}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    # ===== 유틸리티 =====
+    
+    @classmethod
+    def extract_typed_data(cls, element_outputs: Dict, question_type: str) -> Dict:
+        """
+        Element 출력에서 질문 유형에 맞는 구조화된 데이터 추출
+        
+        실제 LLM 응답에서 패턴을 인식하여 구조화합니다.
+        """
+        typed_data = {}
+        
+        fire_data = element_outputs.get("火", {})
+        water_data = element_outputs.get("水", {})
+        wood_data = element_outputs.get("木", {})
+        metal_data = element_outputs.get("金", {})
+        
+        # 공통 데이터
+        typed_data["main_content"] = fire_data.get("result", "")
+        typed_data["key_points"] = fire_data.get("deliverables", [])
+        typed_data["findings"] = water_data.get("findings", [])
+        typed_data["risks"] = metal_data.get("risks", [])
+        
+        # 예측 유형 특화
+        if question_type == "prediction":
+            # 시나리오 추출 시도
+            result_text = str(fire_data.get("result", ""))
+            scenarios = cls._extract_scenarios(result_text)
+            if scenarios:
+                typed_data["scenarios"] = scenarios
+            
+            # 변수 추출
+            variables = []
+            for risk in metal_data.get("risks", []):
+                variables.append({
+                    "name": str(risk)[:30],
+                    "description": str(risk),
+                    "impact": "high" if any(kw in str(risk).lower() for kw in ["중요", "핵심", "critical", "major"]) else "medium"
+                })
+            typed_data["key_variables"] = variables
+        
+        # 비교 유형 특화
+        elif question_type == "comparison":
+            # 비교 항목 추출 시도
+            typed_data["comparison_items"] = []
+            typed_data["criteria"] = []
+            typed_data["recommendation"] = wood_data.get("key_insight", "")
+        
+        # 전략 유형 특화
+        elif question_type == "strategy":
+            # 목표 추출
+            objectives = []
+            for idea in wood_data.get("ideas", []):
+                objectives.append({
+                    "name": str(idea)[:50],
+                    "description": str(idea)
+                })
+            typed_data["objectives"] = objectives
+            typed_data["kpis"] = []
+        
+        return typed_data
+    
+    @classmethod
+    def _extract_scenarios(cls, text: str) -> List[Dict]:
+        """텍스트에서 시나리오 패턴 추출"""
+        scenarios = []
+        
+        # 시나리오 패턴 매칭
+        patterns = [
+            r'시나리오\s*[A-Za-z0-9가-힣]+[:\s]+(.{10,100})',
+            r'Scenario\s*[A-Za-z0-9]+[:\s]+(.{10,100})',
+            r'(\d+)\s*[%]?\s*확률[로으]?\s+(.{10,80})',
+            r'(\d+)\s*[%]\s*probability[:\s]+(.{10,80})',
+        ]
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            for match in matches[:4]:
+                if isinstance(match, tuple):
+                    scenarios.append({
+                        "name": f"Scenario",
+                        "probability": match[0] if match[0].isdigit() else "?",
+                        "description": match[-1] if len(match) > 1 else match[0],
+                        "drivers": "-",
+                        "timeline": "-"
+                    })
+                else:
+                    scenarios.append({
+                        "name": "Scenario",
+                        "description": match,
+                        "probability": "?",
+                        "drivers": "-",
+                        "timeline": "-"
+                    })
+        
+        return scenarios[:4]
+
+
+# ==================== ProfessionalReportGenerator (P0-3) ====================
+
+class ProfessionalReportGenerator:
+    """
+    전문 보고서 생성기 (ReportGenerator 대체)
+    
+    기존 ReportGenerator를 확장하여:
+    - Executive Summary 추가
+    - 질문 유형별 맞춤 포맷
+    - 출처 관리 통합
+    - 품질 대시보드 상단 배치
+    """
+    
+    def __init__(self, source_manager: Optional[SourceManager] = None):
+        self.source_manager = source_manager or SourceManager()
+    
+    def generate(self, state, stats: Dict, source_manager: Optional[SourceManager] = None) -> str:
+        """
+        전문 보고서 생성
+        
+        Args:
+            state: CycleState 객체
+            stats: 메모리 통계
+            source_manager: 출처 관리자 (선택)
+            
+        Returns:
+            마크다운 형식의 전문 보고서
+        """
+        if source_manager:
+            self.source_manager = source_manager
+        
+        language = getattr(state, 'language', 'EN')
+        
+        # 데이터 추출
+        goal = state.goal
+        score = state.satisfaction_score
+        iterations = state.iteration
+        element_outputs = state.element_outputs
+        question_type = getattr(state, 'goal_clarity', None)
+        if question_type and hasattr(question_type, 'goal_type'):
+            question_type = question_type.goal_type
+        else:
+            question_type = self._detect_question_type(goal)
+        
+        # Element 데이터
+        earth_data = element_outputs.get("土", {})
+        metal_data = element_outputs.get("金", {})
+        water_data = element_outputs.get("水", {})
+        wood_data = element_outputs.get("木", {})
+        fire_data = element_outputs.get("火", {})
+        
+        # 메타인지 데이터
+        metacog_assessments = getattr(state, 'metacog_assessments', [])
+        
+        # 보고서 생성
+        if language == "KR":
+            return self._generate_korean(
+                goal, score, iterations, question_type,
+                earth_data, metal_data, water_data, wood_data, fire_data,
+                metacog_assessments, state.session_id
+            )
+        else:
+            return self._generate_english(
+                goal, score, iterations, question_type,
+                earth_data, metal_data, water_data, wood_data, fire_data,
+                metacog_assessments, state.session_id
+            )
+    
+    def _generate_english(self, goal, score, iterations, question_type,
+                         earth_data, metal_data, water_data, wood_data, fire_data,
+                         metacog_assessments, session_id) -> str:
+        """영어 보고서 생성"""
+        sections = []
+        
+        # ===== 1. HEADER =====
+        sections.append(self._header_section_en(goal, question_type))
+        
+        # ===== 2. EXECUTIVE SUMMARY =====
+        sections.append(self._executive_summary_en(
+            goal, score, iterations, fire_data, wood_data, metacog_assessments
+        ))
+        
+        # ===== 3. QUALITY DASHBOARD =====
+        sections.append(self._quality_dashboard_en(metacog_assessments, score))
+        
+        # ===== 4. MAIN ANALYSIS RESULT =====
+        sections.append(self._main_result_en(fire_data, earth_data))
+        
+        # ===== 5. TYPE-SPECIFIC FORMATTED DATA =====
+        typed_data = TypedOutputFormatter.extract_typed_data(
+            {"土": earth_data, "金": metal_data, "水": water_data, "木": wood_data, "火": fire_data},
+            question_type
+        )
+        type_section = TypedOutputFormatter.format(question_type, typed_data, "EN")
+        if type_section.strip():
+            sections.append(type_section)
+        
+        # ===== 6. KEY INSIGHTS =====
+        sections.append(self._insights_section_en(wood_data))
+        
+        # ===== 7. VERIFIED FACTS & RISKS =====
+        sections.append(self._facts_risks_section_en(metal_data))
+        
+        # ===== 8. RESEARCH FINDINGS =====
+        sections.append(self._findings_section_en(water_data))
+        
+        # ===== 9. SOURCES & REFERENCES =====
+        sections.append(self.source_manager.format_references_section("EN"))
+        
+        # ===== 10. ANALYSIS METADATA =====
+        sections.append(self._metadata_section_en(session_id, iterations, score))
+        
+        return "\n".join(filter(None, sections))
+    
+    def _generate_korean(self, goal, score, iterations, question_type,
+                        earth_data, metal_data, water_data, wood_data, fire_data,
+                        metacog_assessments, session_id) -> str:
+        """한국어 보고서 생성"""
+        sections = []
+        
+        # ===== 1. HEADER =====
+        sections.append(self._header_section_kr(goal, question_type))
+        
+        # ===== 2. EXECUTIVE SUMMARY =====
+        sections.append(self._executive_summary_kr(
+            goal, score, iterations, fire_data, wood_data, metacog_assessments
+        ))
+        
+        # ===== 3. QUALITY DASHBOARD =====
+        sections.append(self._quality_dashboard_kr(metacog_assessments, score))
+        
+        # ===== 4. MAIN ANALYSIS RESULT =====
+        sections.append(self._main_result_kr(fire_data, earth_data))
+        
+        # ===== 5. TYPE-SPECIFIC FORMATTED DATA =====
+        typed_data = TypedOutputFormatter.extract_typed_data(
+            {"土": earth_data, "金": metal_data, "水": water_data, "木": wood_data, "火": fire_data},
+            question_type
+        )
+        type_section = TypedOutputFormatter.format(question_type, typed_data, "KR")
+        if type_section.strip():
+            sections.append(type_section)
+        
+        # ===== 6. KEY INSIGHTS =====
+        sections.append(self._insights_section_kr(wood_data))
+        
+        # ===== 7. VERIFIED FACTS & RISKS =====
+        sections.append(self._facts_risks_section_kr(metal_data))
+        
+        # ===== 8. RESEARCH FINDINGS =====
+        sections.append(self._findings_section_kr(water_data))
+        
+        # ===== 9. SOURCES & REFERENCES =====
+        sections.append(self.source_manager.format_references_section("KR"))
+        
+        # ===== 10. ANALYSIS METADATA =====
+        sections.append(self._metadata_section_kr(session_id, iterations, score))
+        
+        return "\n".join(filter(None, sections))
+    
+    # ===== Section Generators (English) =====
+    
+    def _header_section_en(self, goal: str, question_type: str) -> str:
+        type_header = TypedOutputFormatter.get_type_header(question_type, "EN")
+        return f"""# 🎯 Analysis Report
+
+---
+
+## 📋 Question
+> **{goal}**
+
+{type_header}
+
+---
+"""
+    
+    def _executive_summary_en(self, goal, score, iterations, fire_data, wood_data, metacog_assessments) -> str:
+        """Executive Summary 섹션"""
+        lines = ["## 📊 Executive Summary", ""]
+        
+        # 핵심 결론 추출 (3줄)
+        main_result = fire_data.get("result", "")
+        key_insight = wood_data.get("key_insight", wood_data.get("reframe", ""))
+        deliverables = fire_data.get("deliverables", [])
+        
+        conclusions = []
+        if main_result:
+            # 첫 문장 또는 핵심 부분 추출
+            first_sentence = main_result.split('.')[0][:150] if main_result else ""
+            if first_sentence:
+                conclusions.append(first_sentence)
+        if key_insight:
+            conclusions.append(str(key_insight)[:100])
+        if deliverables and len(conclusions) < 3:
+            for d in deliverables[:2]:
+                if len(conclusions) >= 3:
+                    break
+                conclusions.append(str(d)[:80])
+        
+        if conclusions:
+            lines.append("### 🎯 Key Conclusions")
+            for i, c in enumerate(conclusions[:3], 1):
+                lines.append(f"{i}. {c}{'...' if len(c) >= 80 else ''}")
+            lines.append("")
+        
+        # 신뢰도 바
+        score_bar = '█' * int(score * 10) + '░' * (10 - int(score * 10))
+        avg_quality = 0
+        if metacog_assessments:
+            avg_quality = sum(a.overall_score for a in metacog_assessments) / len(metacog_assessments)
+        quality_bar = '█' * int(avg_quality * 10) + '░' * (10 - int(avg_quality * 10))
+        
+        lines.append("### 📈 Analysis Metrics")
+        lines.append(f"| Metric | Score |")
+        lines.append(f"|--------|-------|")
+        lines.append(f"| Confidence | {score_bar} **{score:.0%}** |")
+        lines.append(f"| Quality | {quality_bar} **{avg_quality:.0%}** |")
+        lines.append(f"| Iterations | **{iterations}** cycles |")
+        lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _quality_dashboard_en(self, metacog_assessments, score) -> str:
+        """품질 대시보드 섹션"""
+        if not metacog_assessments:
+            return ""
+        
+        lines = ["## 🧠 Quality Dashboard", ""]
+        
+        # 평균 계산
+        avg_factual = sum(a.factual_confidence for a in metacog_assessments) / len(metacog_assessments)
+        avg_logic = sum(a.logical_coherence for a in metacog_assessments) / len(metacog_assessments)
+        avg_complete = sum(a.completeness for a in metacog_assessments) / len(metacog_assessments)
+        avg_specific = sum(a.specificity for a in metacog_assessments) / len(metacog_assessments)
+        
+        lines.append("| Dimension | Score | Status |")
+        lines.append("|-----------|-------|--------|")
+        
+        for name, val in [
+            ("Factual Grounding", avg_factual),
+            ("Logical Coherence", avg_logic),
+            ("Completeness", avg_complete),
+            ("Specificity", avg_specific)
+        ]:
+            bar = '█' * int(val * 10) + '░' * (10 - int(val * 10))
+            status = "✅" if val >= 0.7 else "⚠️" if val >= 0.5 else "❌"
+            lines.append(f"| {name} | {bar} {val:.0%} | {status} |")
+        
+        lines.append("")
+        
+        # 개선 권장사항
+        all_recommendations = []
+        for a in metacog_assessments[-3:]:  # 최근 3개
+            all_recommendations.extend(a.recommendations)
+        
+        if all_recommendations:
+            unique_recs = list(dict.fromkeys(all_recommendations))[:3]
+            lines.append("### 💡 Improvement Suggestions")
+            for rec in unique_recs:
+                lines.append(f"- {rec}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _main_result_en(self, fire_data, earth_data) -> str:
+        """메인 결과 섹션"""
+        lines = ["## 💡 Main Analysis Result", ""]
+        
+        main_result = fire_data.get("result", "")
+        if main_result:
+            lines.append(main_result)
+            lines.append("")
+        else:
+            assessment = earth_data.get("assessment", "")
+            if assessment:
+                lines.append(assessment)
+                lines.append("")
+            else:
+                lines.append("*Analysis not completed. Please increase iteration count and try again.*")
+                lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _insights_section_en(self, wood_data) -> str:
+        """인사이트 섹션"""
+        lines = []
+        
+        key_insight = wood_data.get("key_insight", wood_data.get("reframe", ""))
+        top3 = wood_data.get("selected_top3", wood_data.get("ideas", []))
+        
+        if key_insight or top3:
+            lines.append("## 🔑 Key Insights")
+            lines.append("")
+            
+            if key_insight:
+                lines.append(f"> 💡 **Core Insight**: {key_insight}")
+                lines.append("")
+            
+            if top3:
+                lines.append("### Top Ideas")
+                for i, idea in enumerate(top3[:3], 1):
+                    lines.append(f"**{i}.** {idea}")
+                    lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _facts_risks_section_en(self, metal_data) -> str:
+        """검증된 사실 및 리스크 섹션"""
+        lines = []
+        
+        verified = metal_data.get("verified_facts", [])
+        risks = metal_data.get("risks", [])
+        critiques = metal_data.get("critiques", [])
+        
+        if verified or risks or critiques:
+            lines.append("## ⚖️ Verification & Risks")
+            lines.append("")
+            
+            if verified:
+                lines.append("### ✅ Verified Facts")
+                for fact in verified[:5]:
+                    lines.append(f"- {fact}")
+                lines.append("")
+            
+            if risks:
+                lines.append("### ⚠️ Identified Risks")
+                for risk in risks[:4]:
+                    lines.append(f"- 🔸 {risk}")
+                lines.append("")
+            
+            if critiques:
+                lines.append("### 🔍 Critical Points")
+                for critique in critiques[:3]:
+                    lines.append(f"- {critique}")
+                lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _findings_section_en(self, water_data) -> str:
+        """연구 발견 섹션"""
+        lines = []
+        
+        findings = water_data.get("findings", [])
+        key_data = water_data.get("key_data", [])
+        expert_views = water_data.get("expert_views", [])
+        
+        if findings or key_data:
+            lines.append("## 📊 Research Findings")
+            lines.append("")
+            
+            if findings:
+                lines.append("### Key Findings")
+                for finding in findings[:5]:
+                    lines.append(f"- {finding}")
+                lines.append("")
+            
+            if key_data:
+                lines.append("### Supporting Data")
+                for data in key_data[:3]:
+                    lines.append(f"- 📈 {data}")
+                lines.append("")
+            
+            if expert_views:
+                lines.append("### Expert Perspectives")
+                for view in expert_views[:2]:
+                    lines.append(f"- 💬 {view}")
+                lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _metadata_section_en(self, session_id, iterations, score) -> str:
+        """메타데이터 섹션"""
+        from datetime import datetime
+        
+        return f"""---
+
+## 📋 Analysis Information
+
+| Item | Value |
+|------|-------|
+| Session ID | `{session_id}` |
+| Iterations | {iterations} cycles |
+| Final Confidence | {score:.0%} |
+| Generated At | {datetime.now().strftime("%Y-%m-%d %H:%M:%S")} |
+| Engine | AETHER Proto-AGI v2.2 |
+
+---
+
+*This report was generated by AETHER Proto-AGI (SOMA Five Elements · SLAI Self-Learning · MAIA Emergence)*
+"""
+    
+    # ===== Section Generators (Korean) =====
+    
+    def _header_section_kr(self, goal: str, question_type: str) -> str:
+        type_header = TypedOutputFormatter.get_type_header(question_type, "KR")
+        return f"""# 🎯 분석 보고서
+
+---
+
+## 📋 질문
+> **{goal}**
+
+{type_header}
+
+---
+"""
+    
+    def _executive_summary_kr(self, goal, score, iterations, fire_data, wood_data, metacog_assessments) -> str:
+        """Executive Summary 섹션 (한국어)"""
+        lines = ["## 📊 핵심 요약 (Executive Summary)", ""]
+        
+        # 핵심 결론 추출 (3줄)
+        main_result = fire_data.get("result", "")
+        key_insight = wood_data.get("key_insight", wood_data.get("reframe", ""))
+        deliverables = fire_data.get("deliverables", [])
+        
+        conclusions = []
+        if main_result:
+            first_sentence = main_result.split('.')[0][:150] if main_result else ""
+            if first_sentence:
+                conclusions.append(first_sentence)
+        if key_insight:
+            conclusions.append(str(key_insight)[:100])
+        if deliverables and len(conclusions) < 3:
+            for d in deliverables[:2]:
+                if len(conclusions) >= 3:
+                    break
+                conclusions.append(str(d)[:80])
+        
+        if conclusions:
+            lines.append("### 🎯 핵심 결론")
+            for i, c in enumerate(conclusions[:3], 1):
+                lines.append(f"{i}. {c}{'...' if len(c) >= 80 else ''}")
+            lines.append("")
+        
+        # 신뢰도 바
+        score_bar = '█' * int(score * 10) + '░' * (10 - int(score * 10))
+        avg_quality = 0
+        if metacog_assessments:
+            avg_quality = sum(a.overall_score for a in metacog_assessments) / len(metacog_assessments)
+        quality_bar = '█' * int(avg_quality * 10) + '░' * (10 - int(avg_quality * 10))
+        
+        lines.append("### 📈 분석 지표")
+        lines.append(f"| 지표 | 점수 |")
+        lines.append(f"|------|------|")
+        lines.append(f"| 신뢰도 | {score_bar} **{score:.0%}** |")
+        lines.append(f"| 품질 | {quality_bar} **{avg_quality:.0%}** |")
+        lines.append(f"| 순환 | **{iterations}**회 |")
+        lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _quality_dashboard_kr(self, metacog_assessments, score) -> str:
+        """품질 대시보드 섹션 (한국어)"""
+        if not metacog_assessments:
+            return ""
+        
+        lines = ["## 🧠 품질 대시보드", ""]
+        
+        avg_factual = sum(a.factual_confidence for a in metacog_assessments) / len(metacog_assessments)
+        avg_logic = sum(a.logical_coherence for a in metacog_assessments) / len(metacog_assessments)
+        avg_complete = sum(a.completeness for a in metacog_assessments) / len(metacog_assessments)
+        avg_specific = sum(a.specificity for a in metacog_assessments) / len(metacog_assessments)
+        
+        lines.append("| 차원 | 점수 | 상태 |")
+        lines.append("|------|------|------|")
+        
+        for name, val in [
+            ("사실 근거", avg_factual),
+            ("논리적 일관성", avg_logic),
+            ("완성도", avg_complete),
+            ("구체성", avg_specific)
+        ]:
+            bar = '█' * int(val * 10) + '░' * (10 - int(val * 10))
+            status = "✅" if val >= 0.7 else "⚠️" if val >= 0.5 else "❌"
+            lines.append(f"| {name} | {bar} {val:.0%} | {status} |")
+        
+        lines.append("")
+        
+        # 개선 권장사항
+        all_recommendations = []
+        for a in metacog_assessments[-3:]:
+            all_recommendations.extend(a.recommendations)
+        
+        if all_recommendations:
+            unique_recs = list(dict.fromkeys(all_recommendations))[:3]
+            lines.append("### 💡 개선 권장사항")
+            for rec in unique_recs:
+                lines.append(f"- {rec}")
+            lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _main_result_kr(self, fire_data, earth_data) -> str:
+        """메인 결과 섹션 (한국어)"""
+        lines = ["## 💡 핵심 분석 결과", ""]
+        
+        main_result = fire_data.get("result", "")
+        if main_result:
+            lines.append(main_result)
+            lines.append("")
+        else:
+            assessment = earth_data.get("assessment", "")
+            if assessment:
+                lines.append(assessment)
+                lines.append("")
+            else:
+                lines.append("*분석이 완료되지 않았습니다. 순환 횟수를 ��려 다시 시도해주세요.*")
+                lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _insights_section_kr(self, wood_data) -> str:
+        """인사이트 섹션 (한국어)"""
+        lines = []
+        
+        key_insight = wood_data.get("key_insight", wood_data.get("reframe", ""))
+        top3 = wood_data.get("selected_top3", wood_data.get("ideas", []))
+        
+        if key_insight or top3:
+            lines.append("## 🔑 핵심 인사이트")
+            lines.append("")
+            
+            if key_insight:
+                lines.append(f"> 💡 **핵심 통찰**: {key_insight}")
+                lines.append("")
+            
+            if top3:
+                lines.append("### 주요 아이디어")
+                for i, idea in enumerate(top3[:3], 1):
+                    lines.append(f"**{i}.** {idea}")
+                    lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _facts_risks_section_kr(self, metal_data) -> str:
+        """검증된 사실 및 리스크 섹션 (한국어)"""
+        lines = []
+        
+        verified = metal_data.get("verified_facts", [])
+        risks = metal_data.get("risks", [])
+        critiques = metal_data.get("critiques", [])
+        
+        if verified or risks or critiques:
+            lines.append("## ⚖️ 검증 및 리스크")
+            lines.append("")
+            
+            if verified:
+                lines.append("### ✅ 검증된 사실")
+                for fact in verified[:5]:
+                    lines.append(f"- {fact}")
+                lines.append("")
+            
+            if risks:
+                lines.append("### ⚠️ 식별된 리스크")
+                for risk in risks[:4]:
+                    lines.append(f"- 🔸 {risk}")
+                lines.append("")
+            
+            if critiques:
+                lines.append("### 🔍 비판적 검토")
+                for critique in critiques[:3]:
+                    lines.append(f"- {critique}")
+                lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _findings_section_kr(self, water_data) -> str:
+        """연구 발견 섹션 (한국어)"""
+        lines = []
+        
+        findings = water_data.get("findings", [])
+        key_data = water_data.get("key_data", [])
+        expert_views = water_data.get("expert_views", [])
+        
+        if findings or key_data:
+            lines.append("## 📊 연구 발견")
+            lines.append("")
+            
+            if findings:
+                lines.append("### 주요 발견")
+                for finding in findings[:5]:
+                    lines.append(f"- {finding}")
+                lines.append("")
+            
+            if key_data:
+                lines.append("### 근거 데이터")
+                for data in key_data[:3]:
+                    lines.append(f"- 📈 {data}")
+                lines.append("")
+            
+            if expert_views:
+                lines.append("### 전문가 의견")
+                for view in expert_views[:2]:
+                    lines.append(f"- 💬 {view}")
+                lines.append("")
+        
+        return "\n".join(lines)
+    
+    def _metadata_section_kr(self, session_id, iterations, score) -> str:
+        """메타데이터 섹션 (한국어)"""
+        from datetime import datetime
+        
+        return f"""---
+
+## 📋 분석 정보
+
+| 항목 | 값 |
+|------|-----|
+| 세션 ID | `{session_id}` |
+| 분석 순환 | {iterations}회 |
+| 최종 신뢰도 | {score:.0%} |
+| 생성 시간 | {datetime.now().strftime("%Y년 %m월 %d일 %H:%M:%S")} |
+| 엔진 | AETHER Proto-AGI v2.2 |
+
+---
+
+*이 보고서는 AETHER Proto-AGI (SOMA 오행 순환 · SLAI 자기학습 · MAIA 창발)에 의해 자동 생성되었습니다.*
+"""
+    
+    # ===== Utility Methods =====
+    
+    def _detect_question_type(self, goal: str) -> str:
+        """질문 유형 감지"""
+        goal_lower = goal.lower()
+        
+        if any(kw in goal_lower for kw in ['예측', '전망', '될까', '될 것', '미래', '2025', '2026', '2027', '2028', 'predict', 'forecast']):
+            return "prediction"
+        elif any(kw in goal_lower for kw in ['전략', '방법', '어떻게', '방안', '계획', '수립', 'strategy', 'how to', 'plan']):
+            return "strategy"
+        elif any(kw in goal_lower for kw in ['비교', '차이', 'vs', 'VS', '대', '어느 것', 'compare', 'versus', 'difference']):
+            return "comparison"
+        elif any(kw in goal_lower for kw in ['분석', '왜', '원인', '영향', '현황', 'analyze', 'why', 'cause', 'impact']):
+            return "analysis"
+        elif any(kw in goal_lower for kw in ['특허', '발명', '아이디어', '혁신', 'patent', 'invention', 'innovate']):
+            return "invention"
+        elif any(kw in goal_lower for kw in ['소설', '스토리', '시나리오', '웹툰', 'story', 'novel', 'script']):
+            return "story"
+        elif any(kw in goal_lower for kw in ['요리', '레시피', '음식', 'recipe', 'cook', 'dish']):
+            return "recipe"
+        else:
+            return "general"
+    
+    @staticmethod
+    def generate_progress(state) -> str:
+        """진행 중 보고서 (기존 호환)"""
+        progress_bar = '█' * int(state.satisfaction_score * 10) + '░' * (10 - int(state.satisfaction_score * 10))
+        
+        current_element = ""
+        if state.history:
+            last = state.history[-1]
+            elem_name = last.get("element", "")
+            elem_map = {
+                "土": "🟤 土 감독", "金": "⚪ 金 비평", "水": "🔵 水 리서치",
+                "木": "🟢 木 창발", "火": "🔴 火 실행"
+            }
+            current_element = elem_map.get(elem_name, elem_name)
+        
+        language = getattr(state, 'language', 'EN')
+        
+        if language == "KR":
+            return f"""# ⏳ 분석 진행 중...
+
+## 📋 질문
+> **{state.goal}**
+
+## 📊 현재 상태
+| 항목 | 상태 |
+|------|------|
+| 진행 순환 | {state.iteration}회 |
+| 현재 단계 | {current_element} |
+| 진행도 | {progress_bar} {state.satisfaction_score:.0%} |
+
+---
+💡 **오케스트레이션 로그**를 펼쳐서 실시간 분석 과정을 확인하세요.
+
+*土(감독) → 金(비평) → 水(리서치) → 木(창발) → 火(실행) 순환 중...*
+"""
+        else:
+            return f"""# ⏳ Analysis in Progress...
+
+## 📋 Question
+> **{state.goal}**
+
+## 📊 Current Status
+| Item | Status |
+|------|--------|
+| Iteration | {state.iteration} |
+| Current Stage | {current_element} |
+| Progress | {progress_bar} {state.satisfaction_score:.0%} |
+
+---
+💡 Expand **Orchestration Log** to see real-time analysis progress.
+
+*Earth → Metal → Water → Wood → Fire cycle in progress...*
+"""
+
+
+# ==================== 기존 ReportGenerator와의 호환성 ====================
+
+# 기존 코드에서 ReportGenerator를 사용하는 부분을 위한 래퍼
+class ReportGenerator:
+    """
+    기존 호환성을 위한 래퍼 클래스
+    ProfessionalReportGenerator로 위임합니다.
+    """
+    
+    _instance = None
+    _professional_generator = None
+    
+    @classmethod
+    def _get_generator(cls):
+        if cls._professional_generator is None:
+            cls._professional_generator = ProfessionalReportGenerator()
+        return cls._professional_generator
+    
+    @staticmethod
+    def generate(state, stats: Dict) -> str:
+        """기존 호출 방식 호환"""
+        generator = ReportGenerator._get_generator()
+        return generator.generate(state, stats)
+    
+    @staticmethod
+    def generate_progress(state) -> str:
+        """진행 중 보고서 (기존 호환)"""
+        return ProfessionalReportGenerator.generate_progress(state)
+
+
+# ==================== 사용 예시 ====================
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("AETHER Proto-AGI v2.2 - Report Enhancement Module")
+    print("=" * 60)
+    print()
+    print("이 모듈의 클래스들을 core.py에 통합하세요:")
+    print()
+    print("1. SourceManager - 출처/인용 관리")
+    print("   - add_web_source(), add_knowledge_source()")
+    print("   - format_references_section()")
+    print()
+    print("2. TypedOutputFormatter - 질문 유형별 포맷")
+    print("   - format_prediction(), format_comparison(), etc.")
+    print()
+    print("3. ProfessionalReportGenerator - 전문 보고서 생성")
+    print("   - Executive Summary")
+    print("   - Quality Dashboard")
+    print("   - Type-specific formatting")
+    print("   - Source references")
+    print()
+    print("=" * 60)
+    
+    # 테스트 데이터
+    print("\n[TypedOutputFormatter 테스트]")
+    test_data = {
+        "scenarios": [
+            {"name": "Scenario A", "probability": "60%", "drivers": "Strong growth", "timeline": "2025 Q2"},
+            {"name": "Scenario B", "probability": "30%", "drivers": "Moderate", "timeline": "2025 Q4"},
+        ],
+        "key_variables": [
+            {"name": "Interest Rate", "description": "Fed policy changes", "impact": "high"},
+            {"name": "Tech Innovation", "description": "AI disruption", "impact": "medium"},
+        ]
+    }
+    print(TypedOutputFormatter.format_prediction(test_data, "EN"))
+    
+    print("\n[SourceManager 테스트]")
+    sm = SourceManager()
+    sm.add_web_source("Example Article", "https://example.com/article", "This is a test", "水")
+    sm.add_web_source("Another Source", "https://test.com/page", "More content here", "金")
+    print(sm.format_references_section("EN"))