report_enhancement.py

"""
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"))