Update app.py

app.py

@@ -1,7 +1,8 @@
 """
-AETHER-Bench v0.2.0 — LLM 평가 시스템
-========================================
-120개 과제로 LLM을 순수 시험 평가 (Proto-AGI 미발동)
+AETHER-Bench v0.3.0 — LLM 평가 시스템 + Proto-AGI 오행 멀티에이전트
+=====================================================================
+120개 과제 × Proto-AGI(木→火→土→金→水) or 단일LLM 평가
+마방진 소통 매트릭스 + 상생·상극 + 水 메타 재검토
 평가 → Judge 채점 → CSV → HuggingFace PRIVATE 데이터셋
 
 Author: Ginigen AI (지니젠AI) — Choi Sunyoung
@@ -129,11 +130,43 @@ def generate_all_tasks() -> List[EvalTask]:
 ALL_TASKS = generate_all_tasks()
 
 # ════════════════════════════════════════════════════════════════
-# PART 4: Fireworks API 호출
+# PART 4: 듀얼 백엔드 API (Groq + Fireworks)
 # ════════════════════════════════════════════════════════════════
 
-def call_llm(prompt, system="", api_key="", model="accounts/fireworks/models/glm-4p7",
-             max_tokens=4096, temperature=0.6):
+GROQ_MODELS = {"qwen/qwen3-32b", "deepseek-r1-distill-llama-70b", "llama-3.3-70b-versatile",
+               "llama-3.1-8b-instant", "meta-llama/llama-4-scout-17b-16e-instruct",
+               "mistral-saba-24b", "gemma2-9b-it", "qwen-qwq-32b"}
+
+def _call_groq(prompt, system="", api_key="", model="qwen/qwen3-32b",
+               max_tokens=8192, temperature=0.6):
+    """Groq SDK 호출 (non-streaming)"""
+    from groq import Groq
+    client = Groq(api_key=api_key)
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+    for attempt in range(3):
+        try:
+            resp = client.chat.completions.create(
+                model=model, messages=messages,
+                temperature=temperature, max_completion_tokens=max_tokens,
+                top_p=0.95, stream=False, stop=None,
+            )
+            content = resp.choices[0].message.content or ""
+            # qwen3 thinking 태그 제거
+            if "<think>" in content:
+                content = re.sub(r'<think>.*?</think>\s*', '', content, flags=re.DOTALL).strip()
+            return content
+        except Exception as e:
+            if attempt < 2:
+                time.sleep(3 * (attempt + 1))
+            else:
+                return f"[API_ERROR:Groq] {e}"
+
+def _call_fireworks(prompt, system="", api_key="", model="accounts/fireworks/models/kimi-k2p5",
+                    max_tokens=8192, temperature=0.6):
+    """Fireworks REST API 호출"""
     messages = []
     if system:
         messages.append({"role": "system", "content": system})
@@ -152,7 +185,309 @@ def call_llm(prompt, system="", api_key="", model="accounts/fireworks/models/glm
             if attempt < 2:
                 time.sleep(3 * (attempt + 1))
             else:
-                return f"[API_ERROR] {e}"
+                return f"[API_ERROR:Fireworks] {e}"
+
+def _detect_backend(model_name):
+    """모델명으로 백엔드 자동 감지"""
+    if model_name in GROQ_MODELS or not model_name.startswith("accounts/"):
+        return "groq"
+    return "fireworks"
+
+def call_llm(prompt, system="", api_key="", model="qwen/qwen3-32b",
+             max_tokens=8192, temperature=0.6, backend=None):
+    """통합 LLM 호출 — 백엔드 자동 감지 또는 지정"""
+    if backend is None:
+        backend = _detect_backend(model)
+    if backend == "groq":
+        return _call_groq(prompt, system, api_key, model, max_tokens, temperature)
+    else:
+        return _call_fireworks(prompt, system, api_key, model, max_tokens, temperature)
+
+# ════════════════════════════════════════════════════════════════
+# PART 4-B: 다중 라운드 실행기 (mutual_verification, feedback_incorporation)
+# ════════════════════════════════════════════════════════════════
+
+def _run_mutual_verification(topic, api_key, model):
+    """상생-상극 4라운드를 개별 API 호출로 체이닝"""
+    rounds = []
+
+    # R1: 상생 (보고서)
+    r1 = call_llm(f"[R1-상생] '{topic}'에 대해 500단어 분석 보고서를 작성하세요. "
+                   "구체적 데이터와 근거를 포함하세요.",
+                   api_key=api_key, model=model)
+    rounds.append(f"[R1-상생 보고서]\n{r1}")
+
+    # R2: 상극 (비판)
+    r2 = call_llm(f"[R2-상극 비판] 아래 보고서를 냉철하게 비판 검토하세요.\n"
+                   f"사실 오류, 논리적 약점, 누락된 관점, 과장된 주장을 지적하세요.\n\n"
+                   f"--- 원문 보고서 ---\n{r1[:3000]}",
+                   api_key=api_key, model=model)
+    rounds.append(f"[R2-상극 비판]\n{r2}")
+
+    # R3: 상생 (수정)
+    r3 = call_llm(f"[R3-상생 수정] 비판을 반영하여 원문 보고서를 수정하세요.\n\n"
+                   f"--- 원문 ---\n{r1[:2000]}\n\n--- 비판 ---\n{r2[:2000]}",
+                   api_key=api_key, model=model)
+    rounds.append(f"[R3-상생 수정]\n{r3}")
+
+    # R4: 메타 분석 (핵심!)
+    r4 = call_llm(f"[R4-메타 분석] 위 3라운드(상생→상극→수정) 사이클의 메타 분석을 수행하세요.\n"
+                   f"반드시 다음을 포함:\n"
+                   f"1. 발견된 환각/오류 유형 분류\n"
+                   f"2. 상극 단계의 기여도 정량 평가\n"
+                   f"3. 사이클을 통한 품질 향상 분석\n\n"
+                   f"--- R1 요약 ---\n{r1[:1000]}\n--- R2 요약 ---\n{r2[:1000]}\n--- R3 요약 ---\n{r3[:1000]}",
+                   api_key=api_key, model=model)
+    rounds.append(f"[R4-메타 분석]\n{r4}")
+
+    return "\n\n".join(rounds)
+
+
+def _run_feedback_incorporation(prompt_json, api_key, model):
+    """피드백 반영 과제를 라운드별 개별 호출로 체이닝"""
+    try:
+        data = json.loads(prompt_json)
+    except:
+        return call_llm(prompt_json, api_key=api_key, model=model)
+
+    topic = data.get("topic", "")
+    rounds_spec = data.get("rounds", [])
+    outputs = []
+    prev = ""
+
+    for i, rd in enumerate(rounds_spec):
+        instruction = rd.get("instruction", "")
+        feedback = rd.get("feedback")
+
+        if i == 0:
+            prompt = f"'{topic}' — {instruction}."
+        elif feedback:
+            prompt = (f"아래는 이전 버전과 피드백입니다. 피드백을 반영하여 {instruction}.\n\n"
+                      f"--- 이전 버전 ---\n{prev[:2500]}\n\n"
+                      f"--- 피드백 ---\n{feedback}")
+        else:
+            prompt = (f"아래는 최종 버전입니다. {instruction}.\n"
+                      f"변경점을 정량적으로 분석하고 자기 평가를 포함하세요.\n\n"
+                      f"--- 최종 버전 ---\n{prev[:3000]}")
+
+        resp = call_llm(prompt, api_key=api_key, model=model)
+        outputs.append(f"[라운드 {i+1}: {instruction}]\n{resp}")
+        prev = resp
+
+        # 피드백이 있으면 다음 라운드에 전달
+        if feedback and i < len(rounds_spec) - 1:
+            outputs.append(f"[피드백] {feedback}")
+
+    return "\n\n".join(outputs)
+
+
+def _is_multi_round(task):
+    """다중 라운드 과제 여부 판별"""
+    return task.sub_dimension in ("mutual_verification", "feedback_incorporation")
+
+
+# ════════════════════════════════════════════════════════════════
+# PART 4-C: Proto-AGI 오행 멀티에이전트 엔진
+# ════════════════════════════════════════════════════════════════
+
+# ── 마방진 5×5 소통 매트릭스 ──
+# 행 합 = 열 합 = 65 → 정규화 후 편향 없는 민주적 소통
+MAGIC_SQUARE_5x5 = np.array([
+    [17, 24,  1,  8, 15],
+    [23,  5,  7, 14, 16],
+    [ 4,  6, 13, 20, 22],
+    [10, 12, 19, 21,  3],
+    [11, 18, 25,  2,  9]
+], dtype=np.float64)
+COMM_MATRIX = MAGIC_SQUARE_5x5 / MAGIC_SQUARE_5x5.sum(axis=1, keepdims=True)
+
+def _comm_level(weight):
+    if weight >= 0.30: return "핵심 참조"
+    elif weight >= 0.18: return "주요 참조"
+    elif weight >= 0.10: return "일반 참조"
+    else: return "경량 참조"
+
+# ── 오행 에이전트 정의 ──
+PROTO_AGENTS = {
+    "木_발상": {
+        "role": "발상 지능(Ideation). 봄의 새싹처럼 기존 경계를 넘어 혁신적 접근을 생성한다. "
+               "仁의 덕 — 모든 가능성을 품고 키우는 개척자.",
+        "element": "木", "index": 2, "shengsheng_from": "水", "shengke_target": "土",
+        "virtue": "仁", "principle": "曲直",
+    },
+    "火_표현": {
+        "role": "표현 지능(Expression). 여름 불꽃처럼 아이디어를 사방으로 구체화하고 확장한다. "
+               "禮의 덕 — 형식을 갖추고 빛나게 만드는 연출가.",
+        "element": "火", "index": 3, "shengsheng_from": "木", "shengke_target": "金",
+        "virtue": "禮", "principle": "炎上",
+    },
+    "土_통합": {
+        "role": "통합 지능(Integration). 대지처럼 중심에서 다양한 관점을 종합하고 갈등을 중재한다. "
+               "信의 덕 — 흔들리지 않는 중심축으로 균형 잡힌 결론을 도출하는 조율자.",
+        "element": "土", "index": 4, "shengsheng_from": "火", "shengke_target": "水",
+        "virtue": "信", "principle": "稼穡",
+    },
+    "金_���판": {
+        "role": "심판 지능(Judgment). 가을의 낫처럼 논리적 결함을 자르고 옳고 그름을 가린다. "
+               "義의 덕 — 냉철한 검증으로 거짓 전제를 적발하고 과장을 제거하는 심판관.",
+        "element": "金", "index": 0, "shengsheng_from": "土", "shengke_target": "木",
+        "virtue": "義", "principle": "從革",
+    },
+    "水_성찰": {
+        "role": "성찰 지능(Wisdom). 겨울 심연처럼 가장 깊은 곳까지 스며드는 메타인지를 수행한다. "
+               "智의 덕 — 전체 과정을 돌아보며 근본 전제를 검토하고 방향을 재설정하는 현자.",
+        "element": "水", "index": 1, "shengsheng_from": "金", "shengke_target": "火",
+        "virtue": "智", "principle": "潤下",
+    },
+}
+AGENT_ORDER = ["木_발상", "火_표현", "土_통합", "金_심판", "水_성찰"]
+AGENT_EMOJIS = {"木": "🌳", "火": "🔥", "土": "🏔️", "金": "⚔️", "水": "💧"}
+
+# ── 에이전트별 행동 지침 ──
+AGENT_INSTRUCTIONS = {
+    "木": "\n\n[행동 지침] 새싹이 땅을 뚫듯, 기존 틀에 얽매이지 않고 다양한 가능성을 탐색하라. 참신한 접근과 핵심 원리를 명확히 서술하라.",
+    "火": "\n\n[행동 지침] 불꽃이 사방을 밝히듯, 木이 제시한 아이디어를 구체적으로 확장하라. 정량 수치와 체계적 구성을 포함하라.",
+    "土": "\n\n[행동 지침] 대지가 만물을 품듯, 이전 에이전트들의 출력을 종합하여 모순을 조정하고 균형 잡힌 통합 결론을 도출하라.",
+    "金": "\n\n[행동 지침] 가을의 낫이 무르익은 것과 썩은 것을 가리듯, 이전 출력의 논리적 결함, 거짓 전제, 과장된 수치를 냉철하게 적발하라. "
+          "의심스러운 주장에는 [검증 필요] 태그를 붙여라."
+          "\n\n[심판 핵심 임무] 1. 수치가 정확한지 검증 2. 무비판적 수용을 지적 3. 과장 식별 4. 검증 불가에 [근거 불충분] 표시 5. 실현 가능성 냉정 평가",
+    "水": "\n\n[행동 지침] 물이 깊은 곳까지 스며들듯, 전체 과정을 근본부터 되돌아보라."
+          "\n\n[특별 권한: 메타 재검토 — 智의 극치] 1. 초기 전제가 사실인지 검증 2. 거짓/과장 발견시 수정안 제시 "
+          "3. 잘못된 전제 위의 목표라면 재설정 선언 4. 공통 오류 패턴 발견시 방향 전환 제안"
+          "\n\n반드시 [메타 판단] 섹션을 포함하라: 전체 문제점, 각 전제 검증 결과, 목표 유지/수정/폐기 판단과 근거"
+          "\n\n[최종 결론] 모든 에이전트의 토론을 종합하여 이 과제에 대한 최종 답변을 명확히 제시하라.",
+}
+
+# ── 상생/상극 설명 ──
+SHENG_DESC = {
+    '木': '水(성찰)의 깊은 통찰이 새로운 발상의 씨앗이 된다',
+    '火': '木(발상)의 아이디어가 표현의 연료가 된다',
+    '土': '火(표현)의 구체화가 통합의 재료가 된다',
+    '金': '土(통합)의 종합된 결론이 심판의 대상이 된다',
+    '水': '金(심판)의 검증 결과가 성찰의 토대가 된다',
+}
+KE_DESC = {
+    '木': '金(심판)이 허황된 발상을 벨 수 있으므로, 근거 있는 아이디어를 제시하라',
+    '火': '水(성찰)이 과잉 표현을 식힐 수 있으므로, 과장 없이 정확하게 서술하라',
+    '土': '木(발상)이 통합의 안주를 깨뜨릴 수 있으므로, 새로운 관점도 수용하라',
+    '金': '火(표현)이 심판의 경직을 녹일 수 있으므로, 유연한 판단도 고려하라',
+    '水': '土(통합)이 성찰의 공허를 막을 수 있으므로, 실질적 결론을 내려라',
+}
+
+def _build_agent_prompt(agent_name, info, task_prompt, prev_outputs):
+    """Proto-AGI 에이전트 프롬프트 빌더 (Full AETHER C5: 상생·상극 + 마방진 + 메타)"""
+    elem = info['element']
+
+    # System prompt
+    sys = (f"당신은 AETHER Proto-AGI 시스템의 [{agent_name}] 에이전트입니다.\n"
+           f"오행 원소: {elem} ({info['principle']}) | 덕목: {info['virtue']}\n"
+           f"역할: {info['role']}")
+
+    # 행동 지침
+    sys += AGENT_INSTRUCTIONS.get(elem, "")
+
+    # 상생 관계
+    if info['shengsheng_from'] in [a.split('_')[0] for a in prev_outputs]:
+        sys += f"\n\n[상생 · {info['shengsheng_from']}→{elem}] {SHENG_DESC.get(elem, '')} — 이전 출력을 발전적으로 계승하라."
+
+    # 상극 관계
+    sys += f"\n[상극 · {elem}克{info['shengke_target']}] {info['shengke_target']} 에이전트의 과도한 경향을 견제하라."
+    sys += f"\n[피극 주의] {KE_DESC.get(elem, '')}"
+
+    # ── 金: 심판 강화 (Document 2 TC-1 full) ──
+    if elem == '金':
+        sys += """
+
+[심판 지능 핵심 임무]
+義의 덕으로 다음을 수행하라:
+1. 주어진 전제의 수치가 정확한지 검증 — 의심스러운 수치에 [검증 필요] 태그
+2. 이전 에이전트�� 전제를 무비판적으로 수용했다면 지적
+3. 과장된 정량 수치(비현실적 % 절감, 비현실적 수율 등) 식별
+4. 검증 불가능한 주장에 [근거 불충분] 표시
+5. 전체 출력의 실현 가능성을 냉정하게 평가"""
+
+    # ── 水: 메타 재검토 권한 (Document 2 TC-1 full) ──
+    if elem == '水':
+        sys += """
+
+[특별 권한: 메타 재검토 — 智의 극치]
+물이 모든 것의 근원까지 스며들듯, 전체 과정을 근본부터 재검토하라.
+1. 초기 전제(기술 현황, 수치, 규제 등)가 사실인지 하나하나 검증하라
+2. 거짓이나 과장이 발견되면 명시적으로 지적하고 수정안을 제시하라
+3. 전체 목표가 잘못된 전제 위에 세워졌다면 목표 재설정을 선언하라
+4. 이전 에이전트 출력에서 공통 오류 패턴 발견시 전체 방향 전환을 제안하라
+
+반드시 [메타 판단] 섹션을 포함하라:
+- 전체 과정의 근본적 문제점
+- 각 전제의 검증 결과 (사실/거짓/불확실)
+- 목표 유지/수정/폐기 판단과 근거
+
+[최종 결론] 모든 에이전트의 토론을 종합하여 이 과제에 대한 최종 답변을 명확히 제시하라."""
+
+    # ── 마방진 소통 매트릭스로 이전 출력 참조 ──
+    ctx = ""
+    if prev_outputs:
+        listener_idx = AGENT_ORDER.index(agent_name) if agent_name in AGENT_ORDER else 0
+        weights = COMM_MATRIX[listener_idx]
+        ctx = "\n\n[이전 에이전트 출력 — 마방진 소통 매트릭스 적용]\n"
+        ctx += "(참조 강도가 높을수록 해당 에이전트의 출력을 깊이 분석하고 반영하라)\n"
+
+        for aname, output in prev_outputs.items():
+            src_idx = AGENT_ORDER.index(aname) if aname in AGENT_ORDER else 0
+            w = weights[src_idx]
+            level = _comm_level(w)
+            ctx += f"\n--- {aname} [{level} · 강도 {w:.0%}] ---\n"
+            if w >= 0.30:
+                ctx += f"{output[:3000]}\n⚠️ 위 에이전트의 주장을 반드시 정밀 검토하고 응답에 반영하라.\n"
+            elif w >= 0.18:
+                ctx += f"{output[:2000]}\n"
+            elif w >= 0.10:
+                ctx += f"{output[:1500]}\n"
+            else:
+                ctx += f"{output[:800]}\n(경량 참조 — 핵심 결론만 참고)\n"
+
+    return sys, f"{task_prompt}\n{ctx}"
+
+
+def _run_proto_agi_pipeline(task_prompt, api_key, eval_model):
+    """Proto-AGI Full AETHER 파이프라인: 木→火→土→金→水 순차 실행
+    
+    Returns: (final_output, agent_trace)
+        final_output: 水_성찰의 최종 결론 (Judge에 전달)
+        agent_trace: {agent_name: response} 전체 기록
+    """
+    prev_outputs = {}
+
+    for aname in AGENT_ORDER:
+        info = PROTO_AGENTS[aname]
+        sys_prompt, usr_prompt = _build_agent_prompt(aname, info, task_prompt, prev_outputs)
+        resp = call_llm(usr_prompt, system=sys_prompt, api_key=api_key, model=eval_model)
+        # qwen3 thinking 태그는 call_llm 내부에서 이미 제거됨
+        prev_outputs[aname] = resp
+
+    # 최종 출력: 모든 에이전트 응답 결합 (水의 결론이 마지막)
+    combined = []
+    for aname in AGENT_ORDER:
+        elem = PROTO_AGENTS[aname]['element']
+        emoji = AGENT_EMOJIS.get(elem, "")
+        combined.append(f"{'='*40}\n{emoji} [{aname}] 응답\n{'='*40}\n{prev_outputs[aname]}")
+
+    return "\n\n".join(combined), prev_outputs
+
+
+def _execute_task(task, api_key, eval_model, proto_agi=False):
+    """과제 유형에 따라 실행 분기 — Proto-AGI 모드 지원"""
+    if proto_agi:
+        # Proto-AGI: 모든 과제를 오행 파이프라인으로 처리
+        final_output, _ = _run_proto_agi_pipeline(task.prompt, api_key, eval_model)
+        return final_output
+    elif task.sub_dimension == "mutual_verification":
+        topic = task.prompt.replace("[상생-상극 사이클] ", "").split("\n")[0]
+        return _run_mutual_verification(topic, api_key, eval_model)
+    elif task.sub_dimension == "feedback_incorporation":
+        return _run_feedback_incorporation(task.prompt, api_key, eval_model)
+    else:
+        return call_llm(task.prompt, api_key=api_key, model=eval_model)
 
 # ════════════════════════════════════════════════════════════════
 # PART 5: LLM-as-Judge 채점
@@ -167,15 +502,19 @@ def build_judge_prompt(task, response):
     rubric = task.scoring_rubric
     rubric_text = "\n".join([f"  - {k} (x{v['weight']}): {v['desc']}" for k, v in rubric.items()])
     expected = task.expected_behavior or "N/A"
+    # 다중 라운드는 응답이 길므로 더 많이 포함
+    resp_limit = 6000 if _is_multi_round(task) else 3000
     return f"""[과제] {task.task_id} | {task.pillar} | {task.difficulty}
 [프롬프트] {task.prompt[:1500]}
 [기대] {expected[:500]}
-[피평가 응답] {response[:3000]}
+[피평가 응답] {response[:resp_limit]}
 [루브릭]
 {rubric_text}
 위 루브릭에 따라 JSON으로 채점."""
 
 def parse_judge_response(text, rubric_keys):
+    """Judge 응답에서 점수 JSON 추출 — 다중 패턴 파싱"""
+    # Pattern 1: 표준 {"scores": {...}, "comment": ...}
     try:
         match = re.search(r'\{[^{}]*"scores"\s*:\s*\{[^{}]*\}[^{}]*\}', text, re.DOTALL)
         if match:
@@ -187,6 +526,34 @@ def parse_judge_response(text, rubric_keys):
             return {"scores": scores, "comment": data.get("comment", "")}
     except:
         pass
+
+    # Pattern 2: ```json 블록 내부
+    try:
+        match = re.search(r'```json\s*(\{.*?\})\s*```', text, re.DOTALL)
+        if match:
+            data = json.loads(match.group(1))
+            scores = data.get("scores", {})
+            for k in rubric_keys:
+                if k not in scores:
+                    scores[k] = 0.5
+            return {"scores": scores, "comment": data.get("comment", "")}
+    except:
+        pass
+
+    # Pattern 3: 개별 항목 추출 (key: 0.75 패턴)
+    try:
+        scores = {}
+        for k in rubric_keys:
+            m = re.search(rf'["\']?{k}["\']?\s*[:=]\s*([\d.]+)', text)
+            if m:
+                scores[k] = min(max(float(m.group(1)), 0), 1.0)
+            else:
+                scores[k] = 0.5
+        if any(v != 0.5 for v in scores.values()):
+            return {"scores": scores, "comment": "패턴3 파싱"}
+    except:
+        pass
+
     return {"scores": {k: 0.5 for k in rubric_keys}, "comment": "파싱실패"}
 
 def compute_weighted_score(scores, rubric):
@@ -396,22 +763,22 @@ def _build_detail_view(results, tasks):
 
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
-def _eval_single_task(task, run_id, api_key, eval_model, judge_model, state):
+def _eval_single_task(task, run_id, eval_api_key, eval_model, judge_api_key, judge_model, state, proto_agi=False):
     """단일 과제 평가 (모델호출 + Judge채점). 워커 스레드에서 실행."""
     try:
-        # Step 1: 피평가 모델 호출
-        model_response = call_llm(task.prompt, api_key=api_key, model=eval_model)
+        # Step 1: 피평가 모델 호출 (Proto-AGI / 다중 라운드 자동 분기)
+        model_response = _execute_task(task, eval_api_key, eval_model, proto_agi=proto_agi)
 
-        if model_response.startswith("[API_ERROR]"):
+        if model_response.startswith("[API_ERROR"):
             _save_result(run_id, task.task_id, model_response, "{}", 0)
             with state["lock"]:
                 state["done"] += 1
                 state["errors"].append(task.task_id)
             return task.task_id, {"response": model_response, "judge": "{}", "score": 0}
 
-        # Step 2: Judge 채점
+        # Step 2: Judge 채점 (별도 API 키/모델)
         judge_prompt = build_judge_prompt(task, model_response)
-        judge_raw = call_llm(judge_prompt, system=JUDGE_SYSTEM, api_key=api_key,
+        judge_raw = call_llm(judge_prompt, system=JUDGE_SYSTEM, api_key=judge_api_key,
                              model=judge_model, temperature=0.3)
 
         rubric_keys = list(task.scoring_rubric.keys())
@@ -481,14 +848,23 @@ def _parallel_progress_html(state, total):
     return out
 
 
-def run_evaluation(api_key, eval_model, judge_model, pillar_filter, diff_filter,
-                   max_tasks, n_workers, fresh_start, progress=gr.Progress()):
-    """메인 평가 — 기둥별 병렬 실행"""
-    api_key = api_key.strip() or os.getenv("FIREWORKS_API_KEY", "")
-    if not api_key:
-        yield "❌ API Key를 입력하세요.", "", "", "", None
+def run_evaluation(eval_api_key, judge_api_key, eval_model, judge_model, pillar_filter, diff_filter,
+                   max_tasks, n_workers, proto_agi, fresh_start, progress=gr.Progress()):
+    """메인 평가 — 기둥별 병렬 실행 (Eval: Groq, Judge: Fireworks 분리, Proto-AGI 지원)"""
+    eval_api_key = eval_api_key.strip() or os.getenv("GROQ_API_KEY", "")
+    judge_api_key = judge_api_key.strip() or os.getenv("FIREWORKS_API_KEY", "")
+    if not eval_api_key:
+        yield "❌ 피평가 모델 API Key를 입력하세요.", "", "", "", None
+        return
+    if not judge_api_key:
+        yield "❌ Judge 모델 API Key를 입력하세요.", "", "", "", None
         return
 
+    # Proto-AGI 활성화 시 워커 수 자동 조정 (과제당 5회 API 호출)
+    n_workers = int(n_workers)
+    if proto_agi and n_workers > 3:
+        n_workers = 3  # 5 agents × 3 workers = 15 동시 API 호출
+
     # ── 과제 필터링 ──
     tasks = ALL_TASKS[:]
     if pillar_filter != "전체":
@@ -497,7 +873,9 @@ def run_evaluation(api_key, eval_model, judge_model, pillar_filter, diff_filter,
         tasks = [t for t in tasks if t.difficulty == diff_filter]
     tasks = tasks[:int(max_tasks)]
 
-    run_id = _make_run_id(eval_model)
+    # run_id에 proto_agi 모드 포함 (체크포인트 분리)
+    mode_suffix = "_PAGI" if proto_agi else ""
+    run_id = _make_run_id(eval_model + mode_suffix)
     if fresh_start:
         _clear_run(run_id)
 
@@ -549,16 +927,17 @@ def run_evaluation(api_key, eval_model, judge_model, pillar_filter, diff_filter,
         "pillar_done": {p: 0 for p in pillar_tasks},
     }
 
-    yield (CSS + f'<div style="background:#e8f5e9;padding:12px;border-radius:8px;margin:8px 0;">'
-           f'⚡ <b>병렬 평가 시작!</b> {len(pending)}개 과제 · {n_pillars}개 기둥 동시 · {n_workers}개 워커'
-           f'</div>', _build_progress_table(results, tasks), "", "", None)
+    mode_tag = '🌟 <b>Proto-AGI ON</b> (木→火→土→金→水)' if proto_agi else '🤖 <b>단일 LLM 모드</b>'
+    yield (CSS + f'<div style="background:{"#fff3e0" if proto_agi else "#e8f5e9"};padding:12px;border-radius:8px;margin:8px 0;">'
+           f'⚡ <b>병렬 평가 시작!</b> {len(pending)}개 과제 · {n_pillars}개 기둥 동시 · {n_workers}개 워커<br>'
+           f'{mode_tag}</div>', _build_progress_table(results, tasks), "", "", None)
 
     # ── ThreadPoolExecutor 병렬 실행 ──
     with ThreadPoolExecutor(max_workers=n_workers) as executor:
         futures = {}
         for task in pending:
-            fut = executor.submit(_eval_single_task, task, run_id, api_key,
-                                  eval_model, judge_model, state)
+            fut = executor.submit(_eval_single_task, task, run_id, eval_api_key,
+                                  eval_model, judge_api_key, judge_model, state, proto_agi)
             futures[fut] = task
 
         completed = set()
@@ -614,12 +993,14 @@ def run_evaluation(api_key, eval_model, judge_model, pillar_filter, diff_filter,
     n_err = len(state["errors"])
     err_msg = f" (⚠️ {n_err}개 오류)" if n_err > 0 else ""
     restore_msg = f" (💾 {cached}개 복원)" if cached > 0 else ""
+    mode_str = "🌟Proto-AGI" if proto_agi else "🤖단일LLM"
 
-    summary = _build_final_summary(results, tasks, pillar_scores, aether, eval_model, hf_status)
+    display_model = f"{eval_model} [{mode_str}]"
+    summary = _build_final_summary(results, tasks, pillar_scores, aether, display_model, hf_status)
     table = _build_progress_table(results, tasks)
     detail = _build_detail_view(results, tasks)
 
-    yield (f"🏁 평가 완료!{restore_msg}{err_msg} AETHER Score: {aether:.1f}",
+    yield (f"🏁 평가 완료! {mode_str}{restore_msg}{err_msg} AETHER Score: {aether:.1f}",
            table, summary, detail, csv_path)
 
 
@@ -632,35 +1013,56 @@ DIFF_CHOICES = ["전체", "basic", "intermediate", "advanced", "expert", "fronti
 
 HEADER = """
 <div style="text-align:center;padding:16px 0;">
-    <h1 style="margin:0;font-size:1.8em;">🌀 AETHER-Bench v0.2.0</h1>
-    <h2 style="margin:4px 0;color:#555;font-size:1.1em;">LLM 순수 시험 평가 시스템</h2>
-    <p style="color:#888;font-size:0.9em;max-width:650px;margin:8px auto;">
+    <h1 style="margin:0;font-size:1.8em;">🌀 AETHER-Bench v0.3.0</h1>
+    <h2 style="margin:4px 0;color:#555;font-size:1.1em;">LLM 평가 시스템 + Proto-AGI 오행 멀티에이전트</h2>
+    <p style="color:#888;font-size:0.9em;max-width:700px;margin:8px auto;">
         120 Tasks · 5 Pillars · 19 Sub-dimensions · HAR Metric<br>
-        <b>Proto-AGI 미발동</b> — 데이터셋만으로 1:1 시험 → HuggingFace PRIVATE 기록
+        🌟 <b>Proto-AGI</b>: 木→火→土→金→水 오행 파이프라인 + 마방진 소통 매트릭스<br>
+        🤖 <b>단일 LLM</b>: 순수 시험 평가 | CSV → HuggingFace PRIVATE 기록
     </p>
     <div style="display:flex;justify-content:center;gap:8px;margin-top:8px;flex-wrap:wrap;font-size:0.85em;">
-        <span style="background:#fff3e0;padding:2px 10px;border-radius:12px;">✦ 창발 20%</span>
-        <span style="background:#f3e5f5;padding:2px 10px;border-radius:12px;">◉ 메타인지 25%</span>
-        <span style="background:#e0f7fa;padding:2px 10px;border-radius:12px;">◈ 자가진화 15%</span>
-        <span style="background:#e8f5e9;padding:2px 10px;border-radius:12px;">◬ 다중지능 15%</span>
-        <span style="background:#ffebee;padding:2px 10px;border-radius:12px;">☯ 상생상극 25%</span>
+        <span style="background:#e8f5e9;padding:2px 10px;border-radius:12px;">🌳 木 발상(仁)</span>
+        <span style="background:#ffebee;padding:2px 10px;border-radius:12px;">🔥 火 표현(禮)</span>
+        <span style="background:#fff3e0;padding:2px 10px;border-radius:12px;">🏔️ 土 통합(信)</span>
+        <span style="background:#f5f5f5;padding:2px 10px;border-radius:12px;">⚔️ 金 심판(義)</span>
+        <span style="background:#e3f2fd;padding:2px 10px;border-radius:12px;">💧 水 성찰(智)</span>
     </div>
 </div>"""
 
 def create_app():
-    with gr.Blocks(title="AETHER-Bench Evaluator", theme=gr.themes.Soft(),
+    with gr.Blocks(title="AETHER-Bench + Proto-AGI", theme=gr.themes.Soft(),
                    css=".gradio-container{max-width:1100px !important}") as app:
         gr.HTML(HEADER)
 
         with gr.Row():
-            api_key = gr.Textbox(label="🔑 Fireworks API Key", type="password",
-                                 placeholder="fw_...", value=os.getenv("FIREWORKS_API_KEY", ""), scale=3)
+            eval_api_key = gr.Textbox(label="🔑 피평가 API Key (Groq)", type="password",
+                                      placeholder="gsk_...", value=os.getenv("GROQ_API_KEY", ""), scale=3)
+            judge_api_key = gr.Textbox(label="⚖️ Judge API Key (Fireworks)", type="password",
+                                       placeholder="fw_...", value=os.getenv("FIREWORKS_API_KEY", ""), scale=3)
 
         with gr.Row():
-            eval_model = gr.Textbox(label="🤖 피평가 모델",
-                                    value="accounts/fireworks/models/glm-4p7", scale=3)
-            judge_model = gr.Textbox(label="⚖️ 심판 모델",
-                                     value="accounts/fireworks/models/kimi-k2p5", scale=3)
+            eval_model = gr.Dropdown(
+                choices=["qwen/qwen3-32b", "qwen-qwq-32b", "deepseek-r1-distill-llama-70b",
+                         "llama-3.3-70b-versatile", "meta-llama/llama-4-scout-17b-16e-instruct",
+                         "mistral-saba-24b", "gemma2-9b-it", "llama-3.1-8b-instant"],
+                value="qwen/qwen3-32b", label="🤖 피평가 모델 (Groq)", allow_custom_value=True, scale=3)
+            judge_model = gr.Dropdown(
+                choices=["accounts/fireworks/models/kimi-k2p5",
+                         "qwen/qwen3-32b", "deepseek-r1-distill-llama-70b",
+                         "llama-3.3-70b-versatile"],
+                value="accounts/fireworks/models/kimi-k2p5",
+                label="⚖️ 심판 모델 (Fireworks/Groq)", allow_custom_value=True, scale=3)
+
+        # ── Proto-AGI 토글 ──
+        with gr.Row():
+            proto_agi_toggle = gr.Checkbox(
+                label="🌟 Proto-AGI 활성화 (木→火→土→金→水 오행 파이프라인)",
+                value=True, scale=3)
+            gr.HTML('''<div style="font-size:0.82em;color:#666;padding:8px;background:#fffde7;border-radius:8px;margin:auto 0;" id="pagi-info">
+                <b>Proto-AGI ON:</b> 과제당 5회 순차 API 호출 (발상→표현→통합→심판→성찰)<br>
+                상생·상극 + 마방진 소통 매트릭스 + 水 메타 재검토 | 워커 자동 제한 3개<br>
+                <b>Proto-AGI OFF:</b> 과제당 1회 API 호출 (순수 LLM 시험)
+            </div>''', scale=3)
 
         with gr.Row():
             pillar_dd = gr.Dropdown(PILLAR_CHOICES, value="전체", label="기둥 필터", scale=2)
@@ -671,7 +1073,7 @@ def create_app():
         with gr.Row():
             start_btn = gr.Button("▶️ 평가 시작 (이어하기)", variant="primary", size="lg", scale=2)
             fresh_btn = gr.Button("🚀 새로 시작", variant="secondary", size="lg", scale=2)
-            gr.HTML('<p style="color:#888;font-size:0.8em;margin:auto 0;">⚡ 기둥별 병렬 실행 — 5개 기둥 동시 평가<br>▶️ 중단시 이어서 | 🚀 초기화후 재시작 | CSV→HF PRIVATE</p>')
+            gr.HTML('<p style="color:#888;font-size:0.8em;margin:auto 0;">⚡ 듀얼 백엔드: Groq(피평가) + Fireworks(Judge)<br>▶️ 중단시 이어서 | 🚀 초기화후 재시작 | CSV→HF PRIVATE</p>')
 
         with gr.Tabs():
             with gr.Tab("📊 진행"):
@@ -685,25 +1087,29 @@ def create_app():
             with gr.Tab("💾 CSV"):
                 csv_file = gr.File(label="평가 결과 CSV")
 
-        def _run_resume(ak,em,jm,pf,df,mt,nw):
-            yield from run_evaluation(ak,em,jm,pf,df,mt,nw,False)
-        def _run_fresh(ak,em,jm,pf,df,mt,nw):
-            yield from run_evaluation(ak,em,jm,pf,df,mt,nw,True)
+        def _run_resume(eak,jak,em,jm,pagi,pf,df,mt,nw):
+            yield from run_evaluation(eak,jak,em,jm,pf,df,mt,nw,pagi,False)
+        def _run_fresh(eak,jak,em,jm,pagi,pf,df,mt,nw):
+            yield from run_evaluation(eak,jak,em,jm,pf,df,mt,nw,pagi,True)
+
+        all_inputs = [eval_api_key, judge_api_key, eval_model, judge_model,
+                      proto_agi_toggle, pillar_dd, diff_dd, max_tasks, n_workers]
 
         start_btn.click(
             fn=_run_resume,
-            inputs=[api_key, eval_model, judge_model, pillar_dd, diff_dd, max_tasks, n_workers],
+            inputs=all_inputs,
             outputs=[progress_html, table_html, summary_html, detail_html, csv_file],
         )
         fresh_btn.click(
             fn=_run_fresh,
-            inputs=[api_key, eval_model, judge_model, pillar_dd, diff_dd, max_tasks, n_workers],
+            inputs=all_inputs,
             outputs=[progress_html, table_html, summary_html, detail_html, csv_file],
         )
 
         gr.Markdown("""---
-<center>AETHER-Bench v0.2.0 · Apache 2.0 · Ginigen AI (지니젠AI)<br>
-<code>HF_TOKEN</code> 설정 시 <b>seawolf2357/AETHER-Bench-Results</b> (PRIVATE)에 자동 기록</center>""")
+<center>AETHER-Bench v0.3.0 · Apache 2.0 · Ginigen AI (지니젠AI)<br>
+🌟 Proto-AGI 오행 파이프라인 + 듀얼 백엔드: <b>Groq</b> (피평가) + <b>Fireworks</b> (Judge)<br>
+<code>HF_TOKEN</code> 설정 시 PRIVATE 자동 기록</center>""")
     return app
 
 # ════════════════════════════════════════════════════════════════
@@ -714,7 +1120,8 @@ if __name__ == "__main__":
     stats = {}
     for t in ALL_TASKS:
         stats[t.pillar] = stats.get(t.pillar, 0) + 1
-    print(f"AETHER-Bench Evaluator: {len(ALL_TASKS)} tasks loaded")
+    print(f"AETHER-Bench v0.3.0 + Proto-AGI: {len(ALL_TASKS)} tasks loaded")
+    print(f"  Proto-AGI: 木_발상→火_표현→土_통합→金_심판→水_성찰 (5 agents)")
     for p, n in stats.items():
         info = PILLAR_INFO[p]
         print(f"  {info['icon']} {info['name']}: {n} ({int(info['weight']*100)}%)")