Update app.py

app.py

@@ -1,35 +1,31 @@
 """
-FINAL Bench Auto-Evaluator v1.0 — ALL Bench 연동용
-===================================================
-HF Inference API로 모델 평가 → OpenAI GPT Judge 채점 → final_scores.json 출력
+FINAL Bench Auto-Evaluator v1.0
+================================
+FINAL Bench 100문제 x HF Inference API -> GPT-5.2 Judge -> final_scores.json
 
-- 피평가: HuggingFace Inference API (오픈소스 모델) + OpenAI/기타 API (클로즈드 모델)
-- 심판: OpenAI GPT-5.2 (Structured Output)
-- 출력: final_scores.json (ALL Bench index.html에서 fetch)
+- 시험 문제: FINAL-Bench/Metacognitive (HuggingFace Dataset)
+- 시험 응시자: ALL Bench 등재 HF Inference API 모델
+- 심판: GPT-5.2 (os.getenv("OPENAI_API_KEY"))
+- 출력: final_scores.json -> ALL Bench Metacog 컬럼 자동 반영
 
-Author: Ginigen AI (지니젠AI) · FINAL-Bench
-License: Apache 2.0
+Author: Ginigen AI · FINAL-Bench · Apache 2.0
 """
 
-import json, os, time, csv, io, re, html, hashlib, sqlite3, threading
+import json, os, time, csv, io, re, hashlib, sqlite3, threading
 from datetime import datetime
 from dataclasses import dataclass, field, asdict
-from typing import List, Dict, Optional
+from typing import Dict, Optional
+from concurrent.futures import ThreadPoolExecutor
 import requests
 import numpy as np
-import pandas as pd
 import gradio as gr
 
-# ════════════════════════════════════════════════════════════════
-# PART 1: 벤치마크 데이터 구조 + 루브릭
-# ════════════════════════════════════════════════════════════════
-
 PILLAR_INFO = {
-    "P1_Emergence":        {"name": "창발성",   "icon": "✦", "color": "#FF6B35", "weight": 0.20},
-    "P2_Metacognition":    {"name": "메타인지", "icon": "◉", "color": "#7B2FF7", "weight": 0.25},
-    "P3_SelfEvolution":    {"name": "자가진화", "icon": "◈", "color": "#00B4D8", "weight": 0.15},
-    "P4_Orchestration":    {"name": "다중지능", "icon": "◬", "color": "#2EC4B6", "weight": 0.15},
-    "P5_SynergyAntagonism":{"name": "상생상극", "icon": "☯", "color": "#E63946", "weight": 0.25},
+    "P1_Emergence":         {"name": "창발성",   "icon": "✦", "color": "#FF6B35", "weight": 0.20},
+    "P2_Metacognition":     {"name": "메타인지", "icon": "◉", "color": "#7B2FF7", "weight": 0.25},
+    "P3_SelfEvolution":     {"name": "자가진화", "icon": "◈", "color": "#00B4D8", "weight": 0.15},
+    "P4_Orchestration":     {"name": "다중지능", "icon": "◬", "color": "#2EC4B6", "weight": 0.15},
+    "P5_SynergyAntagonism": {"name": "상생상극", "icon": "☯", "color": "#E63946", "weight": 0.25},
 }
 
 @dataclass
@@ -37,970 +33,432 @@ class EvalTask:
     task_id: str; pillar: str; sub_dimension: str; difficulty: str
     prompt: str; context: Optional[str] = None; expected_behavior: Optional[str] = None
     scoring_rubric: Dict = field(default_factory=dict); metadata: Dict = field(default_factory=dict)
-    def to_dict(self): return asdict(self)
-
-def load_tasks_from_parquet(path="full_v2.parquet"):
-    df = pd.read_parquet(path)
-    tasks = []
-    for _, row in df.iterrows():
-        rubric = row["scoring_rubric"]
-        if isinstance(rubric, str):
-            rubric = json.loads(rubric)
-        meta = row.get("metadata") or {}
-        if isinstance(meta, str):
-            try: meta = json.loads(meta)
-            except: meta = {}
-        tasks.append(EvalTask(
-            task_id=row["task_id"], pillar=row["pillar"],
-            sub_dimension=row["sub_dimension"], difficulty=row["difficulty"],
-            prompt=row["prompt"], context=row.get("context"),
-            expected_behavior=row.get("expected_behavior"),
-            scoring_rubric=rubric, metadata=meta,
-        ))
-    return tasks
-
-ALL_TASKS = load_tasks_from_parquet()
-
-# ════════════════════════════════════════════════════════════════
-# PART 2: ALL Bench 모델 목록 (HF Inference API 지원)
-# ════════════════════════════════════════════════════════════════
-
-# HF Inference API로 평가 가능한 ALL Bench 등재 모델
-HF_MODELS = {
-    # ── Open-Source (HF Inference API) ──
-    "Qwen3.5-397B":         "Qwen/Qwen3.5-397B-A17B",
-    "Qwen3.5-122B":         "Qwen/Qwen3.5-122B-A10B",
-    "Qwen3.5-27B":          "Qwen/Qwen3.5-27B",
-    "Qwen3.5-35B":          "Qwen/Qwen3.5-35B-A3B",
-    "Qwen3.5-9B":           "Qwen/Qwen3.5-9B",
-    "Qwen3.5-4B":           "Qwen/Qwen3.5-4B",
-    "DeepSeek V3.2":        "deepseek-ai/DeepSeek-V3-0324",
-    "DeepSeek R1":          "deepseek-ai/DeepSeek-R1",
-    "Llama 4 Scout":        "meta-llama/Llama-4-Scout-17B-16E-Instruct",
-    "Llama 4 Maverick":     "meta-llama/Llama-4-Maverick-17B-128E-Instruct",
-    "Phi-4":                "microsoft/phi-4",
-    "Mistral Large 3":      "mistralai/Mistral-Large-Instruct-2501",
-    "Qwen3-Next-80B":       "Qwen/Qwen3-Next-80B-A3B-Thinking",
-}
 
-# OpenAI-compatible API 모델 (별도 API 키 필요)
-OPENAI_MODELS = {
-    "GPT-5.2":              "gpt-5.2",
-    "GPT-5.4":              "gpt-5.4",
-    "GPT-5.1":              "gpt-5.1",
-    "GPT-5.3 Codex":        "gpt-5.3-codex",
-}
+# ══ FINAL Bench 100문제 로드 ══
 
-# ALL Bench 표시명 → FINAL Score 키 매핑
-MODEL_DISPLAY_NAMES = {
-    **{k: k for k in HF_MODELS},
-    **{k: k for k in OPENAI_MODELS},
+def load_tasks():
+    """FINAL-Bench/Metacognitive HF Dataset에서 100문제 로드"""
+    try:
+        from datasets import load_dataset
+        ds = load_dataset("FINAL-Bench/Metacognitive", split="train")
+        tasks = []
+        for row in ds:
+            rubric = row.get("scoring_rubric", {})
+            if isinstance(rubric, str):
+                try: rubric = json.loads(rubric)
+                except: rubric = {}
+            meta = row.get("metadata") or {}
+            if isinstance(meta, str):
+                try: meta = json.loads(meta)
+                except: meta = {}
+            tasks.append(EvalTask(
+                task_id=row["task_id"], pillar=row["pillar"],
+                sub_dimension=row["sub_dimension"], difficulty=row["difficulty"],
+                prompt=row["prompt"], context=row.get("context"),
+                expected_behavior=row.get("expected_behavior"),
+                scoring_rubric=rubric, metadata=meta))
+        print(f"✅ FINAL Bench: {len(tasks)}문제 로드 (HF Dataset)")
+        return tasks
+    except Exception as e:
+        print(f"⚠️ HF Dataset 실패: {e}, parquet 폴백...")
+        try:
+            import pandas as pd
+            df = pd.read_parquet("full_v2.parquet")
+            tasks = []
+            for _, row in df.iterrows():
+                rubric = row["scoring_rubric"]
+                if isinstance(rubric, str): rubric = json.loads(rubric)
+                tasks.append(EvalTask(
+                    task_id=row["task_id"], pillar=row["pillar"],
+                    sub_dimension=row["sub_dimension"], difficulty=row["difficulty"],
+                    prompt=row["prompt"], context=row.get("context"),
+                    expected_behavior=row.get("expected_behavior"),
+                    scoring_rubric=rubric, metadata={}))
+            print(f"✅ Parquet 폴백: {len(tasks)}문제")
+            return tasks
+        except Exception as e2:
+            print(f"❌ 로드 실패: {e2}")
+            return []
+
+ALL_TASKS = load_tasks()
+
+# ══ ALL Bench 등재 HF Inference API 모델 ══
+
+HF_MODELS = {
+    "Qwen3.5-397B":     "Qwen/Qwen3.5-397B-A17B",
+    "Qwen3.5-122B":     "Qwen/Qwen3.5-122B-A10B",
+    "Qwen3.5-27B":      "Qwen/Qwen3.5-27B",
+    "Qwen3.5-35B":      "Qwen/Qwen3.5-35B-A3B",
+    "Qwen3.5-9B":       "Qwen/Qwen3.5-9B",
+    "Qwen3.5-4B":       "Qwen/Qwen3.5-4B",
+    "Qwen3-Next-80B":   "Qwen/Qwen3-Next-80B-A3B-Thinking",
+    "DeepSeek V3.2":    "deepseek-ai/DeepSeek-V3-0324",
+    "DeepSeek R1":      "deepseek-ai/DeepSeek-R1",
+    "Llama 4 Scout":    "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+    "Llama 4 Maverick": "meta-llama/Llama-4-Maverick-17B-128E-Instruct",
+    "Phi-4":            "microsoft/phi-4",
+    "Mistral Large 3":  "mistralai/Mistral-Large-Instruct-2501",
 }
 
-# ════════════════════════════════════════════════════════════════
-# PART 3: LLM 호출 — HF Inference API + OpenAI
-# ════════════════════════════════════════════════════════════════
+# ══ LLM 호출: HF Inference API ══
 
-def _strip_think_tags(text):
+def _strip(text):
     if not text: return text
-    text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL)
-    text = re.sub(r'<thinking>.*?</thinking>', '', text, flags=re.DOTALL)
-    text = re.sub(r'<reasoning>.*?</reasoning>', '', text, flags=re.DOTALL)
-    text = re.sub(r'<reflection>.*?</reflection>', '', text, flags=re.DOTALL)
+    for t in ['think','thinking','reasoning','reflection']:
+        text = re.sub(rf'<{t}>.*?</{t}>', '', text, flags=re.DOTALL)
     return text.strip()
 
-
-def call_llm_hf(prompt, system="", api_key="", model_id="Qwen/Qwen3.5-397B-A17B",
-                max_tokens=4096, temperature=0.6):
-    """HuggingFace Inference API (OpenAI-compatible) 호출"""
-    messages = []
-    if system:
-        messages.append({"role": "system", "content": system})
-    messages.append({"role": "user", "content": prompt})
-
-    payload = {
-        "model": model_id,
-        "messages": messages,
-        "max_tokens": max_tokens,
-        "temperature": temperature,
-        "stream": False,
-    }
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}",
-    }
-
+def call_model(prompt, system="", model_id="Qwen/Qwen3.5-397B-A17B", max_tokens=4096, temperature=0.6):
+    hf_token = os.getenv("HF_TOKEN", "")
+    if not hf_token: return "[API_ERROR] HF_TOKEN 미설정"
+    msgs = []
+    if system: msgs.append({"role":"system","content":system})
+    msgs.append({"role":"user","content":prompt})
+    headers = {"Content-Type":"application/json","Authorization":f"Bearer {hf_token}"}
+    payload = {"model":model_id,"messages":msgs,"max_tokens":max_tokens,"temperature":temperature,"stream":False}
     for attempt in range(3):
         try:
-            r = requests.post(
-                f"https://router.huggingface.co/hf-inference/models/{model_id}/v1/chat/completions",
-                headers=headers, json=payload, timeout=120,
-            )
-            if r.status_code == 429:
-                time.sleep(5 * (attempt + 1)); continue
-            if r.status_code == 503:
-                # Model loading
-                time.sleep(10 * (attempt + 1)); continue
-            r.raise_for_status()
-            content = r.json()["choices"][0]["message"]["content"]
-            content = _strip_think_tags(content)
-            return content
-        except Exception as e:
-            if attempt < 2:
-                time.sleep(3 * (attempt + 1))
-            else:
-                return f"[API_ERROR] HF Inference: {e}"
-
-
-def call_llm_openai(prompt, system="", api_key="", model="gpt-5.2",
-                    max_tokens=4096, temperature=0.6, base_url="https://api.openai.com/v1"):
-    """OpenAI-compatible API 호출 (GPT, Claude 등)"""
-    messages = []
-    if system:
-        messages.append({"role": "system", "content": system})
-    messages.append({"role": "user", "content": prompt})
-
-    payload = {
-        "model": model,
-        "messages": messages,
-        "max_tokens": max_tokens,
-        "temperature": temperature,
-    }
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}",
-    }
-
-    for attempt in range(2):
-        try:
-            r = requests.post(
-                f"{base_url}/chat/completions",
-                headers=headers, json=payload, timeout=120,
-            )
-            if r.status_code == 429:
-                time.sleep(5 * (attempt + 1)); continue
+            r = requests.post(f"https://router.huggingface.co/hf-inference/models/{model_id}/v1/chat/completions",
+                              headers=headers, json=payload, timeout=180)
+            if r.status_code in (429, 503):
+                time.sleep(10*(attempt+1)); continue
             r.raise_for_status()
-            content = r.json()["choices"][0]["message"]["content"]
-            content = _strip_think_tags(content)
-            return content
+            return _strip(r.json()["choices"][0]["message"]["content"])
         except Exception as e:
-            if attempt < 1:
-                time.sleep(3)
-            else:
-                return f"[API_ERROR] OpenAI: {e}"
-
-
-def call_llm(prompt, system="", api_key="", model_id="", api_type="hf",
-             max_tokens=4096, temperature=0.6):
-    """통합 LLM 호출 래퍼"""
-    if api_type == "openai":
-        return call_llm_openai(prompt, system, api_key, model_id, max_tokens, temperature)
-    else:
-        return call_llm_hf(prompt, system, api_key, model_id, max_tokens, temperature)
-
-
-# ════════════════════════════════════════════════════════════════
-# PART 4: Judge (OpenAI Structured Output) — 원본 코드 유지
-# ════════════════════════════════════════════════════════════════
-
-def _build_judge_schema(rubric_keys):
-    score_props = {}
-    for k in rubric_keys:
-        score_props[k] = {"type": "number", "enum": [0.0, 0.25, 0.5, 0.75, 1.0]}
-    return {
-        "type": "object",
-        "properties": {
-            "scores": {
-                "type": "object", "properties": score_props,
-                "required": list(rubric_keys), "additionalProperties": False,
-            },
-            "comment": {"type": "string"}
-        },
-        "required": ["scores", "comment"], "additionalProperties": False,
-    }
-
-
-def call_judge_structured(prompt, system="", api_key="", model="gpt-5.2",
-                          rubric_keys=None, temperature=0.1, max_tokens=4096):
-    if not rubric_keys:
-        return {"scores": {}, "comment": "루브릭키 없음"}
-    messages = []
-    if system:
-        messages.append({"role": "system", "content": system})
-    messages.append({"role": "user", "content": prompt})
-    schema = _build_judge_schema(rubric_keys)
-    payload = {
-        "model": model, "max_completion_tokens": max_tokens,
-        "temperature": temperature, "messages": messages,
-        "response_format": {
-            "type": "json_schema",
-            "json_schema": {"name": "JudgeResult", "strict": True, "schema": schema}
-        }
-    }
-    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
-
+            if attempt < 2: time.sleep(5*(attempt+1))
+            else: return f"[API_ERROR] {e}"
+
+# ══ Judge: GPT-5.2 (OPENAI_API_KEY) ══
+
+JUDGE_SYS = """You are a FINAL Bench scoring judge. Score each rubric item using ONLY: 0.0, 0.25, 0.5, 0.75, 1.0.
+1.0=Excellent 0.75=Good 0.5=Average 0.25=Below 0.0=Fails
+Output JSON: {"scores":{...}, "comment":"한줄평가"}. Every rubric key MUST appear."""
+
+def call_judge(prompt, rubric_keys):
+    api_key = os.getenv("OPENAI_API_KEY", "")
+    if not api_key: return None
+    props = {k:{"type":"number","enum":[0.0,0.25,0.5,0.75,1.0]} for k in rubric_keys}
+    schema = {"type":"object","properties":{"scores":{"type":"object","properties":props,
+              "required":list(rubric_keys),"additionalProperties":False},
+              "comment":{"type":"string"}},"required":["scores","comment"],"additionalProperties":False}
+    payload = {"model":"gpt-5.2","max_completion_tokens":4096,"temperature":0.1,
+               "messages":[{"role":"system","content":JUDGE_SYS},{"role":"user","content":prompt}],
+               "response_format":{"type":"json_schema","json_schema":{"name":"JudgeResult","strict":True,"schema":schema}}}
+    headers = {"Content-Type":"application/json","Authorization":f"Bearer {api_key}"}
     for attempt in range(3):
         try:
-            r = requests.post("https://api.openai.com/v1/chat/completions",
-                              headers=headers, json=payload, timeout=180)
-            if r.status_code == 429:
-                time.sleep(5 * (attempt + 1)); continue
+            r = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload, timeout=180)
+            if r.status_code == 429: time.sleep(8*(attempt+1)); continue
             r.raise_for_status()
-            content = r.json()["choices"][0]["message"]["content"]
+            content = _strip(r.json()["choices"][0]["message"]["content"])
             if not content:
-                if attempt < 2: time.sleep(2); continue
+                if attempt < 2: time.sleep(3); continue
                 return None
-            if "<think>" in content:
-                content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
             data = json.loads(content)
-            if "scores" in data and isinstance(data["scores"], dict):
+            if "scores" in data:
                 for k in rubric_keys:
                     if k not in data["scores"]: data["scores"][k] = 0.5
-                return {"scores": data["scores"], "comment": data.get("comment", "structured_ok")}
-        except json.JSONDecodeError:
-            if attempt < 2: time.sleep(2); continue
-            return None
-        except Exception:
-            if attempt < 2: time.sleep(3 * (attempt + 1)); continue
+                return data
+        except: 
+            if attempt < 2: time.sleep(5*(attempt+1)); continue
             return None
     return None
 
-
-JUDGE_SYSTEM = """You are a FINAL Bench scoring judge. Score each rubric item using ONLY these values: 0.0, 0.25, 0.5, 0.75, 1.0.
-
-Scoring criteria:
-- 1.0: Excellent, fully meets the rubric
-- 0.75: Good, mostly meets with minor gaps
-- 0.5: Average, partially meets
-- 0.25: Below average, significant gaps
-- 0.0: Fails to meet the rubric
-
-Evaluate the response as-is. Judge the substance and final answer quality.
-Output a JSON object with "scores" and "comment" (1-sentence Korean summary).
-Every rubric key MUST appear in scores."""
-
-
-def build_judge_prompt(task, response):
-    rubric = task.scoring_rubric
-    expected = task.expected_behavior or "N/A"
-    keys = list(rubric.keys())
-    skeleton = ", ".join([f'"{k}": ___' for k in keys])
-    rubric_lines = "\n".join([f'  "{k}": {v["desc"]}' for k, v in rubric.items()])
-    return f"""Task: {task.task_id} | {task.pillar} | {task.difficulty}
-Prompt: {task.prompt[:800]}
-Expected: {expected[:300]}
-Response to judge: {response[:8000]}
-
-Rubric items to score (each 0.0~1.0):
-{rubric_lines}
-
-Fill in the scores and output ONLY this JSON (replace ___ with 0.0/0.25/0.5/0.75/1.0):
-{{"scores": {{{skeleton}}}, "comment": "한줄 평가"}}"""
-
-
-def parse_judge_response(text, rubric_keys):
-    """6단계 방어 파서"""
-    if not text or text.startswith("[API_ERROR"):
-        return {"scores": {k: 0.0 for k in rubric_keys}, "comment": "API오류", "failed": True}
-
-    cleaned = _strip_think_tags(text)
-    cleaned = re.sub(r'```(?:json)?\s*', '', cleaned)
-    cleaned = re.sub(r'```\s*$', '', cleaned)
-    cleaned = cleaned.strip()
-
-    def _validate(scores):
-        result = {}
-        for k in rubric_keys:
-            v = scores.get(k)
-            if v is not None:
-                try: result[k] = min(max(float(v), 0.0), 1.0)
-                except: result[k] = 0.5
-            else: result[k] = 0.5
-        return result
-
-    # Pattern 1: standard JSON
-    try:
-        brace_depth = 0; start = -1
-        for i, c in enumerate(cleaned):
-            if c == '{':
-                if brace_depth == 0: start = i
-                brace_depth += 1
-            elif c == '}':
-                brace_depth -= 1
-                if brace_depth == 0 and start >= 0:
-                    data = json.loads(cleaned[start:i+1])
-                    if "scores" in data:
-                        return {"scores": _validate(data["scores"]), "comment": data.get("comment", "")}
-    except: pass
-
-    # Pattern 2: regex
-    try:
-        m = re.search(r'"scores"\s*:\s*\{([^}]+)\}', cleaned, re.DOTALL)
-        if m:
-            pairs = re.findall(r'"([^"]+)"\s*:\s*([\d.]+)', '{' + m.group(1) + '}')
-            if pairs:
-                raw = {k: float(v) for k, v in pairs}
-                validated = _validate(raw)
-                if any(v != 0.5 for v in validated.values()):
-                    return {"scores": validated, "comment": "패턴2"}
-    except: pass
-
-    return {"scores": {k: 0.0 for k in rubric_keys}, "comment": "파싱실패", "failed": True}
-
-
-def compute_weighted_score(scores, rubric):
-    return round(sum(scores.get(k, 0.5) * v["weight"] for k, v in rubric.items()) * 100, 2)
-
-
-# ════════════════════════════════════════════════════════════════
-# PART 5: 다중 라운드 과제 실행기
-# ════════════════════════════════════════════════════════════════
-
-def _run_mutual_verification(topic, api_key, model_id, api_type):
-    rounds = []
-    r1 = call_llm(f"[R1-상생] '{topic}'에 대해 500단어 분석 보고서를 작성하세요.",
-                  api_key=api_key, model_id=model_id, api_type=api_type)
-    rounds.append(f"[R1-상생]\n{r1}")
-    r2 = call_llm(f"[R2-상극] 아래 보고서를 냉철하게 비판하세요.\n--- 원문 ---\n{r1[:2000]}",
-                  api_key=api_key, model_id=model_id, api_type=api_type)
-    rounds.append(f"[R2-상극]\n{r2}")
-    r3 = call_llm(f"[R3-수정] 비판을 반영하여 수정하세요.\n--- 원문 ---\n{r1[:1500]}\n--- 비판 ---\n{r2[:1500]}",
-                  api_key=api_key, model_id=model_id, api_type=api_type)
-    rounds.append(f"[R3-수정]\n{r3}")
-    r4 = call_llm(f"[R4-메타] 3라운드 메타 분석:\n--- R1 ---\n{r1[:800]}\n--- R2 ---\n{r2[:800]}\n--- R3 ---\n{r3[:800]}",
-                  api_key=api_key, model_id=model_id, api_type=api_type)
-    rounds.append(f"[R4-메타]\n{r4}")
-    return "\n\n".join(rounds)
-
-
-def _run_feedback(prompt_json, api_key, model_id, api_type):
-    try: data = json.loads(prompt_json)
-    except: return call_llm(prompt_json, api_key=api_key, model_id=model_id, api_type=api_type)
-    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: p = f"'{topic}' — {instruction}."
-        elif feedback: p = f"피드백 반영: {instruction}.\n--- 이전 ---\n{prev[:2000]}\n--- 피드백 ---\n{feedback}"
-        else: p = f"{instruction}.\n--- 최종 ---\n{prev[:2500]}"
-        resp = call_llm(p, api_key=api_key, model_id=model_id, api_type=api_type)
-        outputs.append(f"[R{i+1}]\n{resp}")
-        prev = resp
-    return "\n\n".join(outputs)
-
-
-def execute_task(task, api_key, model_id, api_type):
-    """단일 LLM 순수 평가 (Proto-AGI OFF)"""
+def judge_prompt(task, response):
+    keys = list(task.scoring_rubric.keys())
+    skel = ", ".join([f'\"{k}\": ___' for k in keys])
+    rubric = "\n".join([f'  \"{k}\": {v["desc"]}' for k,v in task.scoring_rubric.items()])
+    return f"Task: {task.task_id} | {task.pillar} | {task.difficulty}\nPrompt: {task.prompt[:800]}\nExpected: {(task.expected_behavior or 'N/A')[:300]}\nResponse: {response[:8000]}\n\nRubric:\n{rubric}\n\nOutput JSON: {{\"scores\": {{{skel}}}, \"comment\": \"한줄평가\"}}"
+
+def score(scores, rubric):
+    return round(sum(scores.get(k,0.5)*v["weight"] for k,v in rubric.items())*100, 2)
+
+# ══ 다중 라운드 과제 ══
+
+def _mutual(topic, mid):
+    r1 = call_model(f"[R1] \'{topic}\' 500단어 분석.", model_id=mid)
+    r2 = call_model(f"[R2] 비판하라.\n---\n{r1[:2000]}", model_id=mid)
+    r3 = call_model(f"[R3] 수정하라.\n--- 원문 ---\n{r1[:1500]}\n--- 비판 ---\n{r2[:1500]}", model_id=mid)
+    r4 = call_model(f"[R4] 메타분석.\n--- R1 ---\n{r1[:800]}\n--- R2 ---\n{r2[:800]}\n--- R3 ---\n{r3[:800]}", model_id=mid)
+    return f"[R1]\n{r1}\n\n[R2]\n{r2}\n\n[R3]\n{r3}\n\n[R4]\n{r4}"
+
+def _feedback(pj, mid):
+    try: data = json.loads(pj)
+    except: return call_model(pj, model_id=mid)
+    topic, specs = data.get("topic",""), data.get("rounds",[])
+    outs, prev = [], ""
+    for i, rd in enumerate(specs):
+        inst, fb = rd.get("instruction",""), rd.get("feedback")
+        if i==0: p = f"\'{topic}\' - {inst}."
+        elif fb: p = f"피드백 반영: {inst}.\n--- 이전 ---\n{prev[:2000]}\n--- 피드백 ---\n{fb}"
+        else: p = f"{inst}.\n--- 최종 ---\n{prev[:2500]}"
+        resp = call_model(p, model_id=mid); outs.append(f"[R{i+1}]\n{resp}"); prev = resp
+    return "\n\n".join(outs)
+
+def run_task(task, mid):
     if task.sub_dimension == "mutual_verification":
-        topic = task.prompt.replace("[상생-상극 사이클] ", "").split("\n")[0]
-        return _run_mutual_verification(topic, api_key, model_id, api_type)
+        return _mutual(task.prompt.replace("[상생-상극 사이클] ","").split("\n")[0], mid)
     elif task.sub_dimension == "feedback_incorporation":
-        return _run_feedback(task.prompt, api_key, model_id, api_type)
-    else:
-        return call_llm(task.prompt, api_key=api_key, model_id=model_id, api_type=api_type)
-
-
-# ════════════════════════════════════════════════════════════════
-# PART 6: AETHER Score 계산 + final_scores.json 출력
-# ════════════════════════════════════════════════════════════════
-
-def calculate_aether_score(pillar_avgs):
-    weights = {p: info["weight"] for p, info in PILLAR_INFO.items()}
-    return round(sum(pillar_avgs.get(p, 0) * w for p, w in weights.items()), 2)
-
-
-SCORES_FILE = "final_scores.json"
-
-def load_final_scores():
-    try:
-        with open(SCORES_FILE) as f:
-            return json.load(f)
-    except:
-        return {"version": "1.0", "updated": "", "models": {}}
-
-
-def save_final_scores(model_name, pillar_scores, aether_score, total_tasks, completed):
-    """ALL Bench 연동용 final_scores.json 업데이트"""
-    data = load_final_scores()
-    data["updated"] = datetime.now().isoformat()
-    data["models"][model_name] = {
-        "final_score": aether_score,
-        "pillar_scores": {p: round(s, 2) for p, s in pillar_scores.items()},
-        "total_tasks": total_tasks,
-        "completed_tasks": completed,
-        "evaluated_at": datetime.now().isoformat(),
-        "mode": "pure_llm",
-    }
-    with open(SCORES_FILE, "w") as f:
-        json.dump(data, f, indent=2, ensure_ascii=False)
-    return data
-
-
-def upload_scores_to_hf(data):
-    """final_scores.json을 HF Dataset에 업로드"""
-    hf_token = os.getenv("HF_TOKEN", "")
-    if not hf_token:
-        return "⚠️ HF_TOKEN 미설정"
+        return _feedback(task.prompt, mid)
+    return call_model(task.prompt, model_id=mid)
+
+# ══ DB 체크포인트 ══
+
+DB = "final_bench.db"
+def _initdb():
+    c = sqlite3.connect(DB)
+    c.execute("CREATE TABLE IF NOT EXISTS r (rid TEXT,tid TEXT,resp TEXT,judge TEXT,score REAL,ts REAL,PRIMARY KEY(rid,tid))")
+    c.commit(); c.close()
+def _rid(m): return hashlib.md5(m.encode()).hexdigest()[:12]
+def _sv(rid,tid,resp,jdg,sc):
+    c=sqlite3.connect(DB); c.execute("INSERT OR REPLACE INTO r VALUES(?,?,?,?,?,?)",(rid,tid,resp,jdg,sc,time.time())); c.commit(); c.close()
+def _loadall(rid):
+    c=sqlite3.connect(DB); rows=c.execute("SELECT tid,resp,judge,score FROM r WHERE rid=?", (rid,)).fetchall(); c.close()
+    return {r[0]:{"response":r[1],"judge":r[2],"score":r[3]} for r in rows}
+def _clr(rid):
+    c=sqlite3.connect(DB); c.execute("DELETE FROM r WHERE rid=?",(rid,)); c.commit(); c.close()
+_initdb()
+
+# ══ Scores 저장 + HF 업로드 ══
+
+SF = "final_scores.json"
+def load_sf():
     try:
-        from huggingface_hub import HfApi
-        api = HfApi(token=hf_token)
-        repo_id = "FINAL-Bench/ALL-Bench-Leaderboard"
-        api.upload_file(
-            path_or_fileobj=json.dumps(data, indent=2, ensure_ascii=False).encode("utf-8"),
-            path_in_repo="final_scores.json",
-            repo_id=repo_id, repo_type="dataset",
-            commit_message=f"FINAL Score update: {datetime.now().strftime('%Y-%m-%d %H:%M')}",
-        )
-        return f"✅ HF 업로드 완료: datasets/{repo_id}/final_scores.json"
-    except Exception as e:
-        return f"❌ 업로드 실패: {e}"
-
-
-# ════════════════════════════════════════════════════════════════
-# PART 7: 체크포인트 DB
-# ════════════════════════════════════════════════════════════════
-
-DB_PATH = "final_bench_eval.db"
-
-def _init_db():
-    conn = sqlite3.connect(DB_PATH)
-    conn.execute("""CREATE TABLE IF NOT EXISTS eval_results (
-        run_id TEXT, task_id TEXT, model_response TEXT, judge_response TEXT,
-        weighted_score REAL, timestamp REAL,
-        PRIMARY KEY (run_id, task_id))""")
-    conn.commit(); conn.close()
-
-def _make_run_id(model): return hashlib.md5(model.encode()).hexdigest()[:12]
-
-def _get_cached(run_id, task_id):
-    conn = sqlite3.connect(DB_PATH)
-    cur = conn.execute("SELECT model_response, judge_response, weighted_score FROM eval_results WHERE run_id=? AND task_id=?", (run_id, task_id))
-    row = cur.fetchone(); conn.close()
-    return row
-
-def _save_result(run_id, task_id, response, judge_resp, score):
-    conn = sqlite3.connect(DB_PATH)
-    conn.execute("INSERT OR REPLACE INTO eval_results VALUES (?,?,?,?,?,?)",
-                 (run_id, task_id, response, judge_resp, score, time.time()))
-    conn.commit(); conn.close()
-
-def _load_all(run_id):
-    conn = sqlite3.connect(DB_PATH)
-    cur = conn.execute("SELECT task_id, model_response, judge_response, weighted_score FROM eval_results WHERE run_id=?", (run_id,))
-    rows = cur.fetchall(); conn.close()
-    return {r[0]: {"response": r[1], "judge": r[2], "score": r[3]} for r in rows}
-
-def _clear_run(run_id):
-    conn = sqlite3.connect(DB_PATH)
-    conn.execute("DELETE FROM eval_results WHERE run_id=?", (run_id,))
-    conn.commit(); conn.close()
-
-_init_db()
-
-# ════════════════════════════════════════════════════════════════
-# PART 8: CSV 생성 + HF 업로드
-# ════════════════════════════════════════════════════════════════
-
-def generate_csv(results, model_name):
-    output = io.StringIO()
-    writer = csv.writer(output)
-    writer.writerow(["task_id","pillar","sub_dimension","difficulty","model",
-                     "weighted_score","judge_comment","rubric_scores_json","timestamp"])
-    task_map = {t.task_id: t for t in ALL_TASKS}
-    for tid, data in sorted(results.items()):
-        task = task_map.get(tid)
-        if not task: continue
-        jd = {}
-        try: jd = json.loads(data["judge"]) if isinstance(data["judge"], str) else (data["judge"] or {})
-        except: pass
-        score = data["score"]
-        comment = (jd.get("comment","") if isinstance(jd,dict) else "")[:200]
-        if score < 0:
-            score = -1
-            if not comment.startswith("JUDGE_FAILED"): comment = f"JUDGE_FAILED:{comment}"
-        writer.writerow([
-            tid, task.pillar, task.sub_dimension, task.difficulty, model_name,
-            score, comment,
-            json.dumps(jd.get("scores",{}) if isinstance(jd,dict) else {}, ensure_ascii=False),
-            datetime.now().isoformat(),
-        ])
-    return output.getvalue()
-
-
-def upload_csv_to_hf(csv_content, model_name):
-    hf_token = os.getenv("HF_TOKEN", "")
-    if not hf_token:
-        return "⚠️ HF_TOKEN 미설정"
+        with open(SF) as f: return json.load(f)
+    except: return {"version":"1.0","updated":"","models":{}}
+def save_sf(mn, ps, fs, total, done):
+    d = load_sf(); d["updated"]=datetime.now().isoformat()
+    d["models"][mn]={"final_score":fs,"pillar_scores":{p:round(s,2) for p,s in ps.items()},
+                     "total_tasks":total,"completed":done,"evaluated_at":datetime.now().isoformat()}
+    with open(SF,"w") as f: json.dump(d,f,indent=2,ensure_ascii=False)
+    return d
+def upload_sf(d):
+    tk = os.getenv("HF_TOKEN","")
+    if not tk: return "⚠️ HF_TOKEN 미설정"
     try:
         from huggingface_hub import HfApi
-        api = HfApi(token=hf_token)
-        safe_model = re.sub(r'[^a-zA-Z0-9_-]', '_', model_name.split('/')[-1])
-        repo_id = "FINAL-Bench/ALL-Bench-Leaderboard"
-        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"eval_results/{safe_model}_{ts}.csv"
-        api.upload_file(
-            path_or_fileobj=csv_content.encode("utf-8"),
-            path_in_repo=filename, repo_id=repo_id, repo_type="dataset",
-            commit_message=f"FINAL Bench eval: {safe_model}",
-        )
-        return f"✅ CSV 업로드: {filename}"
-    except Exception as e:
-        return f"❌ CSV 업로드 실패: {e}"
-
-
-# ════════════════════════════════════════════════════════════════
-# PART 9: HTML 빌더
-# ════════════════════════════════════════════════════════════════
-
-CSS = """<style>
-.eval-table{width:100%;border-collapse:collapse;font-size:0.85em}
-.eval-table th{background:#f0f4f8;padding:8px;text-align:left;border-bottom:2px solid #ccc}
-.eval-table td{padding:6px 8px;border-bottom:1px solid #eee}
-.score-bar{background:#e0e0e0;border-radius:8px;height:18px;overflow:hidden;min-width:80px}
-.score-fill{height:100%;border-radius:8px;transition:width .4s}
-.summary-card{background:linear-gradient(135deg,#1a1a2e,#16213e);border-radius:14px;padding:20px;color:#fff;margin:8px 0}
-.pillar-row{display:flex;align-items:center;gap:10px;margin:6px 0}
-.pillar-bar{flex:1;background:#333;border-radius:6px;height:16px;overflow:hidden}
-.pillar-fill{height:100%;border-radius:6px}
-.progress-bar{background:#e0e0e0;border-radius:8px;height:22px;margin:12px 0;overflow:hidden}
-.progress-fill{height:100%;border-radius:8px;background:linear-gradient(90deg,#6366f1,#4caf50)}
-</style>"""
-
-def _sc(s):
-    if s >= 80: return "#4caf50"
-    if s >= 60: return "#ff9800"
-    return "#f44336"
-
-def _build_progress_table(results, tasks):
-    rows = ""
-    for t in tasks:
-        info = PILLAR_INFO.get(t.pillar, {})
-        if t.task_id in results:
-            s = results[t.task_id]["score"]
-            if s < 0:
-                rows += f'<tr style="background:#fff3e0"><td>{t.task_id}</td><td>{info.get("icon","")} {info.get("name","")}</td><td>{t.sub_dimension}</td><td>{t.difficulty}</td><td style="color:#ff9800">❌ Judge실패</td><td>—</td></tr>'
-                continue
-            c = _sc(s)
-            cls = "color:#2e7d32;font-weight:700" if s>=70 else "color:#c62828;font-weight:700"
-            rows += f'<tr><td>{t.task_id}</td><td>{info.get("icon","")} {info.get("name","")}</td><td>{t.sub_dimension}</td><td>{t.difficulty}</td><td><div class="score-bar"><div class="score-fill" style="width:{min(s,100)}%;background:{c}"></div></div></td><td style="{cls}">{s:.1f}</td></tr>'
-        else:
-            rows += f'<tr style="opacity:0.4"><td>{t.task_id}</td><td>{info.get("icon","")}</td><td>{t.sub_dimension}</td><td>{t.difficulty}</td><td>⏳</td><td>—</td></tr>'
-    return f'{CSS}<table class="eval-table"><thead><tr><th>ID</th><th>기둥</th><th>차원</th><th>난이도</th><th>점수</th><th>값</th></tr></thead><tbody>{rows}</tbody></table>'
-
-def _build_summary(results, tasks, pillar_scores, aether, model_name, hf_status):
-    if aether >= 80: grade = "A (AGI-Level)"
-    elif aether >= 70: grade = "B+ (Near-AGI)"
-    elif aether >= 60: grade = "B (Advanced)"
-    elif aether >= 50: grade = "C+ (Competent)"
-    else: grade = "C-F"
-    ph = ""
-    for p, info in PILLAR_INFO.items():
-        s = pillar_scores.get(p, 0)
-        c = _sc(s); w = int(info["weight"] * 100)
-        ph += f'<div class="pillar-row"><span style="width:130px">{info["icon"]} {info["name"]} ({w}%)</span><div class="pillar-bar"><div class="pillar-fill" style="width:{min(s,100)}%;background:{c}"></div></div><span style="width:55px;text-align:right;font-weight:700;color:{c}">{s:.1f}</span></div>'
-    done = sum(1 for t in tasks if t.task_id in results)
-    jf = sum(1 for t in tasks if t.task_id in results and results[t.task_id]["score"] < 0)
-    return f"""{CSS}<div class="summary-card">
-        <h2 style="margin:0;font-size:1.6em;text-align:center">🧬 FINAL Score: {aether:.1f} / 100</h2>
-        <h3 style="margin:4px 0;text-align:center;color:#aaa">Grade: {grade}</h3>
-        <p style="text-align:center;color:#888">Model: {model_name} | {done}개 완료{f' · ❌Judge실패 {jf}건' if jf else ''}</p>
-        <hr style="border-color:#333;margin:12px 0"><h4 style="color:#aaa;margin:8px 0">기둥별 점수</h4>{ph}
-        <hr style="border-color:#333;margin:12px 0"><p style="font-size:0.85em;color:#aaa">{hf_status}</p></div>"""
-
-
-# ════════════════════════════════════════════════════════════════
-# PART 10: 병렬 평가 엔진 + 백그라운드 스레드
-# ════════════════════════════════════════════════════════════════
+        api = HfApi(token=tk)
+        api.upload_file(path_or_fileobj=json.dumps(d,indent=2,ensure_ascii=False).encode("utf-8"),
+                        path_in_repo="final_scores.json", repo_id="FINAL-Bench/ALL-Bench-Leaderboard",
+                        repo_type="dataset", commit_message=f"FINAL Score {datetime.now().strftime('%m-%d %H:%M')}")
+        return "✅ HF Dataset 업로드 완료"
+    except Exception as e: return f"❌ {e}"
 
-from concurrent.futures import ThreadPoolExecutor
+# ══ 평가 워커 ══
 
-def _eval_single(task, run_id, api_key, judge_key, model_id, judge_model, api_type, state):
+def _eval1(task, rid, mid, st):
     try:
-        response = execute_task(task, api_key, model_id, api_type)
-        if response.startswith("[API_ERROR"):
-            _save_result(run_id, task.task_id, response, "{}", 0)
-            with state["lock"]:
-                state["done"] += 1; state["errors"].append(task.task_id)
-            return task.task_id, {"response": response, "judge": "{}", "score": 0}
-
-        rubric_keys = list(task.scoring_rubric.keys())
-        judge_prompt = build_judge_prompt(task, response)
-        judge_data = call_judge_structured(
-            judge_prompt, system=JUDGE_SYSTEM, api_key=judge_key,
-            model=judge_model, rubric_keys=rubric_keys, temperature=0.1)
-
-        if judge_data is None:
-            # Fallback: text parsing
-            judge_raw = call_llm_openai(
-                judge_prompt, system=JUDGE_SYSTEM, api_key=judge_key,
-                model=judge_model, temperature=0.05, max_tokens=512)
-            judge_data = parse_judge_response(judge_raw, rubric_keys)
-
-        if judge_data.get("failed"):
-            weighted = -1.0
-        else:
-            weighted = compute_weighted_score(judge_data["scores"], task.scoring_rubric)
-            with state["lock"]: state["parse_ok"] += 1
-
-        judge_json = json.dumps(judge_data, ensure_ascii=False)
-        _save_result(run_id, task.task_id, response, judge_json, weighted)
-
-        with state["lock"]:
-            state["done"] += 1
-            info = PILLAR_INFO.get(task.pillar, {})
-            state["active"].append(f'{info.get("icon","")} {task.task_id}')
-            if len(state["active"]) > 10: state["active"] = state["active"][-10:]
-
-        return task.task_id, {"response": response, "judge": judge_json, "score": weighted}
-
+        resp = run_task(task, mid)
+        if resp.startswith("[API_ERROR"):
+            _sv(rid,task.task_id,resp,"{}",0)
+            with st["lock"]: st["done"]+=1; st["err"].append(task.task_id)
+            return task.task_id, {"response":resp,"judge":"{}","score":0}
+        rk = list(task.scoring_rubric.keys())
+        jp = judge_prompt(task, resp)
+        jd = call_judge(jp, rk)
+        if jd is None:
+            _sv(rid,task.task_id,resp,'{"failed":true}',-1)
+            with st["lock"]: st["done"]+=1; st["jf"]+=1
+            return task.task_id, {"response":resp,"judge":'{"failed":true}',"score":-1}
+        sc = score(jd["scores"], task.scoring_rubric)
+        jj = json.dumps(jd, ensure_ascii=False)
+        _sv(rid,task.task_id,resp,jj,sc)
+        with st["lock"]:
+            st["done"]+=1; st["jok"]+=1
+            info = PILLAR_INFO.get(task.pillar,{})
+            st["rec"].append(f'{info.get("icon","")} {task.task_id} → {sc:.0f}')
+            if len(st["rec"])>8: st["rec"]=st["rec"][-8:]
+        return task.task_id, {"response":resp,"judge":jj,"score":sc}
     except Exception as e:
-        with state["lock"]:
-            state["done"] += 1; state["errors"].append(f"{task.task_id}: {str(e)[:60]}")
-        _save_result(run_id, task.task_id, f"[ERROR] {e}", "{}", 0)
-        return task.task_id, {"response": f"[ERROR] {e}", "judge": "{}", "score": 0}
-
-
-# ── 글로벌 상태 ──
-_STATE = {
-    "running": False, "stop_requested": False, "finished": False,
-    "run_id": "", "model": "", "done": 0, "total": 0, "cached": 0,
-    "errors": [], "active": [], "parse_ok": 0, "parse_fail": 0,
-    "start_time": 0, "results": {}, "tasks": [],
-    "pillar_done": {}, "pillar_total": {},
-    "n_workers": 5, "lock": threading.Lock(),
-    "message": "", "csv_path": None, "hf_status": "",
-}
+        _sv(rid,task.task_id,f"[ERR]{e}","{}",0)
+        with st["lock"]: st["done"]+=1; st["err"].append(f"{task.task_id}:{str(e)[:40]}")
+        return task.task_id, {"response":f"[ERR]{e}","judge":"{}","score":0}
 
+# ══ 글로벌 상태 + 백그라운드 ══
 
-def _reset_state():
-    global _STATE
-    with _STATE["lock"]:
-        _STATE.update({
-            "running": False, "stop_requested": False, "finished": False,
-            "done": 0, "cached": 0, "errors": [], "active": [],
-            "parse_ok": 0, "parse_fail": 0, "start_time": 0,
-            "results": {}, "tasks": [], "pillar_done": {}, "pillar_total": {},
-            "message": "", "csv_path": None, "hf_status": "",
-        })
+_S = {"running":False,"stop":False,"finished":False,"model":"","rid":"",
+      "done":0,"total":0,"cached":0,"err":[],"rec":[],"jok":0,"jf":0,
+      "t0":0,"results":{},"tasks":[],"lock":threading.Lock(),"msg":"","csv":None,"hf":""}
 
+def _rst():
+    with _S["lock"]:
+        _S.update({"running":False,"stop":False,"finished":False,"done":0,"cached":0,
+                   "err":[],"rec":[],"jok":0,"jf":0,"t0":0,"results":{},"tasks":[],"msg":"","csv":None,"hf":""})
 
-def _bg_evaluate(api_key, judge_key, model_id, model_display, judge_model,
-                 api_type, tasks, run_id, n_workers):
-    global _STATE
+def _bg(mn, mid, tasks, rid, wk):
     try:
-        results = dict(_load_all(run_id))
-        cached = sum(1 for t in tasks if t.task_id in results)
-        pending = [t for t in tasks if t.task_id not in results]
-
-        pillar_tasks = {}
-        for t in pending:
-            pillar_tasks.setdefault(t.pillar, []).append(t)
-
-        with _STATE["lock"]:
-            _STATE["results"] = results; _STATE["cached"] = cached
-            _STATE["total"] = len(tasks)
-            _STATE["pillar_total"] = {p: len(ts) for p, ts in pillar_tasks.items()}
-            _STATE["pillar_done"] = {p: 0 for p in pillar_tasks}
-            _STATE["start_time"] = time.time()
-
+        cached = _loadall(rid)
+        pending = [t for t in tasks if t.task_id not in cached]
+        with _S["lock"]: _S["results"]=cached; _S["cached"]=len(cached); _S["total"]=len(tasks); _S["t0"]=time.time()
         if not pending:
-            with _STATE["lock"]:
-                _STATE["message"] = f"💾 전부 캐시! ({cached}개)"
-            _finalize(tasks, results, model_display)
-            return
-
-        with _STATE["lock"]:
-            _STATE["message"] = f"⚡ {len(pending)}개 과제 · {n_workers}워커"
-
-        with ThreadPoolExecutor(max_workers=n_workers) as executor:
-            futures = {}
-            for task in pending:
-                if _STATE["stop_requested"]: break
-                fut = executor.submit(_eval_single, task, run_id, api_key, judge_key,
-                                      model_id, judge_model, api_type, _STATE)
-                futures[fut] = task
-
-            completed = set()
-            while len(completed) < len(futures):
-                if _STATE["stop_requested"]:
-                    with _STATE["lock"]:
-                        _STATE["message"] = "⏹️ 중단됨"; _STATE["running"] = False; _STATE["finished"] = True
+            with _S["lock"]: _S["msg"]=f"💾 캐시 완료 ({len(cached)}개)"
+            _fin(tasks,cached,mn); return
+        with _S["lock"]: _S["msg"]=f"⚡ {len(pending)}문제 · {wk}워커"
+        with ThreadPoolExecutor(max_workers=wk) as ex:
+            futs = {ex.submit(_eval1,t,rid,mid,_S):t for t in pending if not _S["stop"]}
+            done_set = set()
+            while len(done_set)<len(futs):
+                if _S["stop"]:
+                    with _S["lock"]: _S["msg"]="⏹️ 중단"; _S["running"]=False; _S["finished"]=True
                     return
-                for fut in list(futures):
-                    if fut in completed: continue
-                    if fut.done():
-                        completed.add(fut)
+                for f in list(futs):
+                    if f in done_set: continue
+                    if f.done():
+                        done_set.add(f)
                         try:
-                            tid, data = fut.result()
-                            with _STATE["lock"]:
-                                _STATE["results"][tid] = data
-                                _STATE["pillar_done"][futures[fut].pillar] = \
-                                    _STATE["pillar_done"].get(futures[fut].pillar, 0) + 1
+                            tid,data = f.result()
+                            with _S["lock"]: _S["results"][tid]=data
                         except: pass
                 time.sleep(0.5)
-
-        with _STATE["lock"]:
-            results = dict(_STATE["results"])
-        _finalize(tasks, results, model_display)
-
+        with _S["lock"]: results=dict(_S["results"])
+        _fin(tasks,results,mn)
     except Exception as e:
-        with _STATE["lock"]:
-            _STATE["message"] = f"❌ 오류: {str(e)[:100]}"
-            _STATE["running"] = False; _STATE["finished"] = True
-
+        with _S["lock"]: _S["msg"]=f"❌ {str(e)[:100]}"; _S["running"]=False; _S["finished"]=True
 
-def _finalize(tasks, results, model_display):
-    global _STATE
-    pillar_scores = {}
+def _fin(tasks, results, mn):
+    ps = {}
     for p in PILLAR_INFO:
-        pt = [t for t in tasks if t.pillar == p and t.task_id in results]
-        valid = [results[t.task_id]["score"] for t in pt if results[t.task_id]["score"] >= 0]
-        if valid: pillar_scores[p] = np.mean(valid)
-
-    aether = calculate_aether_score(pillar_scores)
-    completed = sum(1 for t in tasks if t.task_id in results and results[t.task_id]["score"] >= 0)
-
-    # Save final_scores.json
-    scores_data = save_final_scores(model_display, pillar_scores, aether, len(tasks), completed)
-
-    # CSV
-    csv_str = generate_csv(results, model_display)
-    run_id = _STATE["run_id"]
-    csv_path = f"/tmp/final_bench_{run_id}.csv"
-    with open(csv_path, "w", encoding="utf-8") as f:
-        f.write(csv_str)
-
-    # Upload
-    hf_status = upload_scores_to_hf(scores_data)
-    csv_hf = upload_csv_to_hf(csv_str, model_display)
-
-    elapsed = int(time.time() - _STATE["start_time"]) if _STATE["start_time"] else 0
-    with _STATE["lock"]:
-        _STATE["csv_path"] = csv_path; _STATE["hf_status"] = f"{hf_status}\n{csv_hf}"
-        _STATE["message"] = f"🏁 완료! FINAL Score={aether:.1f} ({elapsed}초)"
-        _STATE["running"] = False; _STATE["finished"] = True
-
-
-def _start_eval(model_choice, api_type, eval_api_key, judge_api_key, judge_model,
-                pillar_filter, diff_filter, max_tasks, n_workers, fresh_start):
-    global _STATE
-    if _STATE["running"]:
-        return "⚠️ 이미 진행 중"
-
-    eval_api_key = (eval_api_key or "").strip() or os.getenv("HF_TOKEN", "")
-    judge_api_key = (judge_api_key or "").strip() or os.getenv("OPENAI_API_KEY", "")
-    if not eval_api_key: return "❌ API Key를 입력하세요."
-    if not judge_api_key: return "❌ Judge API Key (OpenAI)를 입력하세요."
-
-    # Resolve model ID
-    if api_type == "HuggingFace Inference":
-        model_id = HF_MODELS.get(model_choice, model_choice)
-        at = "hf"
-    else:
-        model_id = OPENAI_MODELS.get(model_choice, model_choice)
-        at = "openai"
-
-    tasks = ALL_TASKS[:]
-    if pillar_filter != "전체":
-        tasks = [t for t in tasks if t.pillar == pillar_filter]
-    if diff_filter != "전체":
-        tasks = [t for t in tasks if t.difficulty == diff_filter]
-    tasks = tasks[:int(max_tasks)]
-
-    run_id = _make_run_id(model_id + "_pure")
-    if fresh_start:
-        _clear_run(run_id)
-
-    _reset_state()
-    with _STATE["lock"]:
-        _STATE["running"] = True; _STATE["run_id"] = run_id
-        _STATE["model"] = model_choice; _STATE["tasks"] = tasks
-        _STATE["total"] = len(tasks); _STATE["n_workers"] = int(n_workers)
-        _STATE["message"] = "🔄 준비 중..."
-
-    thread = threading.Thread(
-        target=_bg_evaluate,
-        args=(eval_api_key, judge_api_key, model_id, model_choice, judge_model,
-              at, tasks, run_id, int(n_workers)),
-        daemon=True)
-    thread.start()
-    return f"⚡ {model_choice} 평가 시작 ({len(tasks)}과제, {int(n_workers)}워커)"
-
+        valid = [results[t.task_id]["score"] for t in tasks if t.pillar==p and t.task_id in results and results[t.task_id]["score"]>=0]
+        if valid: ps[p] = np.mean(valid)
+    wts = {p:info["weight"] for p,info in PILLAR_INFO.items()}
+    fs = round(sum(ps.get(p,0)*w for p,w in wts.items()), 2)
+    done = sum(1 for t in tasks if t.task_id in results and results[t.task_id]["score"]>=0)
+    sd = save_sf(mn, ps, fs, len(tasks), done)
+    hf = upload_sf(sd)
+    el = int(time.time()-_S["t0"]) if _S["t0"] else 0
+    with _S["lock"]:
+        _S["hf"]=hf; _S["msg"]=f"🏁 FINAL Score = {fs:.1f} ({el}초)"
+        _S["running"]=False; _S["finished"]=True
+
+def _start(mc, mt, wk, fresh):
+    if _S["running"]: return "⚠️ 진행 중"
+    if not os.getenv("HF_TOKEN"): return "❌ HF_TOKEN (Secrets)"
+    if not os.getenv("OPENAI_API_KEY"): return "❌ OPENAI_API_KEY (Secrets)"
+    if not ALL_TASKS: return "❌ 과제 로드 실패"
+    mid = HF_MODELS.get(mc, mc)
+    tasks = ALL_TASKS[:int(mt)]
+    rid = _rid(mid)
+    if fresh: _clr(rid)
+    _rst()
+    with _S["lock"]:
+        _S.update({"running":True,"rid":rid,"model":mc,"tasks":tasks,"total":len(tasks),"msg":"🔄 준비..."})
+    threading.Thread(target=_bg, args=(mc,mid,tasks,rid,int(wk)), daemon=True).start()
+    return f"⚡ {mc} 평가 시작 ({len(tasks)}문제, {int(wk)}워커)"
 
 def _stop():
-    global _STATE
-    if _STATE["running"]:
-        _STATE["stop_requested"] = True
-        return "⏹️ 중단 요청"
+    if _S["running"]: _S["stop"]=True; return "⏹️ 중단 요청"
     return "ℹ️ 실행 중 아님"
 
+# ══ UI 빌더 ══
 
-def _poll():
-    global _STATE
-    with _STATE["lock"]:
-        running = _STATE["running"]; finished = _STATE["finished"]
-        tasks = _STATE.get("tasks", []); results = dict(_STATE.get("results", {}))
-        message = _STATE.get("message", ""); csv_path = _STATE.get("csv_path")
-
-    if not running and not finished and not results:
-        return ("ℹ️ 모델을 선택하고 ▶️ 시작을 누르세요.", "", "", None)
+CSS = """<style>
+.score-bar{background:#e0e0e0;border-radius:8px;height:18px;overflow:hidden;min-width:80px}
+.score-fill{height:100%;border-radius:8px}
+.summary-card{background:linear-gradient(135deg,#1a1a2e,#16213e);border-radius:14px;padding:24px;color:#fff}
+.pillar-row{display:flex;align-items:center;gap:10px;margin:6px 0}
+.pillar-bar{flex:1;background:#333;border-radius:6px;height:16px;overflow:hidden}
+.pillar-fill{height:100%;border-radius:6px}
+.pbar{background:#e0e0e0;border-radius:8px;height:22px;overflow:hidden}
+.pfill{height:100%;border-radius:8px;background:linear-gradient(90deg,#6366f1,#10b981)}
+</style>"""
+def _c(s): return "#4caf50" if s>=80 else ("#ff9800" if s>=60 else "#f44336")
 
+def _poll():
+    with _S["lock"]:
+        run,fin = _S["running"],_S["finished"]
+        tasks,res = _S.get("tasks",[]),dict(_S.get("results",{}))
+        msg = _S.get("msg","")
+    if not run and not fin and not res:
+        return ("ℹ️ 모델 선택 → ▶️ 시작", "", "", None)
     # Progress
-    if running:
-        done = _STATE["done"]; total = _STATE.get("total", 1)
-        pct = min(int(done / max(total, 1) * 100), 100)
-        elapsed = int(time.time() - _STATE.get("start_time", time.time()))
-        eta = int((elapsed / max(done,1)) * (total - done)) if done > 0 else 0
-        active = _STATE.get("active", [])
-        tags = " ".join([f'<span style="background:#e3f2fd;padding:2px 6px;border-radius:4px;font-size:0.78em;">{a}</span>' for a in active[-8:]])
-        prog = f"""{CSS}<div>
-            <div style="display:flex;justify-content:space-between;margin-bottom:4px;">
-                <span>⚡ {done}/{total} 완료 | {elapsed}초 | 예상잔여 {eta}초</span>
-                <span style="font-weight:700">{pct}%</span>
-            </div>
-            <div class="progress-bar"><div class="progress-fill" style="width:{pct}%"></div></div>
-            <div style="margin-top:6px;">{tags}</div></div>"""
-    elif finished:
-        prog = f'<div style="background:#e8f5e9;padding:12px;border-radius:8px;font-weight:700;">{message}</div>'
-    else:
-        prog = message
-
-    table = _build_progress_table(results, tasks) if tasks else ""
-
-    summary = ""
-    if finished and tasks:
-        pillar_scores = {}
+    if run:
+        d,tot = _S["done"],max(_S.get("total",1),1)
+        pct = min(int(d/tot*100),100)
+        el = int(time.time()-_S.get("t0",time.time()))
+        eta = int((el/max(d,1))*(tot-d)) if d>0 else 0
+        tags = " ".join([f'<span style="background:#e8eaf6;padding:2px 8px;border-radius:4px;font-size:.8em">{r}</span>' for r in _S.get("rec",[])[-6:]])
+        prog = f'{CSS}<div><div style="display:flex;justify-content:space-between;margin-bottom:4px"><span>⚡ {d}/{tot} | {el}초 | ~{eta}초</span><span style="font-weight:700">{pct}%</span></div><div class="pbar"><div class="pfill" style="width:{pct}%"></div></div><div style="margin-top:6px">{tags}</div><div style="margin-top:4px;font-size:.85em">⚖️ ✅{_S.get("jok",0)} ❌{_S.get("jf",0)}</div></div>'
+    elif fin:
+        prog = f'<div style="background:#e8f5e9;padding:14px;border-radius:8px;font-weight:700">{msg}</div>'
+    else: prog = msg
+    # Table
+    tbl = ""
+    if tasks:
+        rows = ""
+        for t in tasks:
+            info = PILLAR_INFO.get(t.pillar,{})
+            if t.task_id in res:
+                s = res[t.task_id]["score"]
+                if s<0: rows += f'<tr style="background:#fff3e0"><td>{t.task_id}</td><td>{info.get("icon","")} {info.get("name","")}</td><td>{t.difficulty}</td><td style="color:#ff9800">❌</td><td>—</td></tr>'
+                else:
+                    c = _c(s)
+                    rows += f'<tr><td>{t.task_id}</td><td>{info.get("icon","")} {info.get("name","")}</td><td>{t.difficulty}</td><td><div class="score-bar"><div class="score-fill" style="width:{min(s,100)}%;background:{c}"></div></div></td><td style="color:{c};font-weight:700">{s:.1f}</td></tr>'
+            else: rows += f'<tr style="opacity:.35"><td>{t.task_id}</td><td>{info.get("icon","")}</td><td>{t.difficulty}</td><td>⏳</td><td>—</td></tr>'
+        tbl = f'{CSS}<table style="width:100%;border-collapse:collapse;font-size:.85em"><thead><tr><th style="background:#f0f4f8;padding:8px;text-align:left;border-bottom:2px solid #ccc">ID</th><th style="background:#f0f4f8;padding:8px">기둥</th><th style="background:#f0f4f8;padding:8px">난이도</th><th style="background:#f0f4f8;padding:8px">점수</th><th style="background:#f0f4f8;padding:8px">값</th></tr></thead><tbody>{rows}</tbody></table>'
+    # Summary
+    summ = ""
+    if fin and tasks:
+        ps = {}
         for p in PILLAR_INFO:
-            pt = [t for t in tasks if t.pillar == p and t.task_id in results]
-            valid = [results[t.task_id]["score"] for t in pt if results[t.task_id]["score"] >= 0]
-            if valid: pillar_scores[p] = np.mean(valid)
-        aether = calculate_aether_score(pillar_scores)
-        summary = _build_summary(results, tasks, pillar_scores, aether,
-                                 _STATE.get("model", ""), _STATE.get("hf_status", ""))
-
-    return (prog, table, summary, csv_path)
-
-
-# ════════════════════════════════════════════════════════════════
-# PART 11: Gradio App
-# ════════════════════════════════════════════════════════════════
-
-def _update_model_choices(api_type):
-    if api_type == "HuggingFace Inference":
-        return gr.update(choices=list(HF_MODELS.keys()), value=list(HF_MODELS.keys())[0])
-    else:
-        return gr.update(choices=list(OPENAI_MODELS.keys()), value=list(OPENAI_MODELS.keys())[0])
-
-
-HEADER_HTML = """
-<div style="text-align:center;padding:16px 0;">
-    <h1 style="margin:0;font-size:1.8em;">🧬 FINAL Bench Auto-Evaluator v1.0</h1>
-    <h2 style="margin:4px 0;color:#555;font-size:1.05em;">ALL Bench 연동 · FINAL Score 자동 측정</h2>
-    <p style="color:#888;font-size:0.88em;max-width:700px;margin:8px auto;">
-        220 Tasks · 5 Pillars · 21 Sub-dimensions · HAR Metric<br>
-        📡 <b>HF Inference API</b>: Qwen, DeepSeek, Llama, Phi, Mistral 등 오픈소스<br>
-        🔑 <b>OpenAI API</b>: GPT-5.x 시리즈<br>
-        ⚖️ <b>Judge</b>: OpenAI GPT-5.2 Structured Output · 📊 결과 → <code>final_scores.json</code> → ALL Bench 자동 반영
-    </p>
-</div>"""
-
-PILLAR_CHOICES = ["전체"] + list(PILLAR_INFO.keys())
-DIFF_CHOICES = ["전체", "expert", "frontier"]
-
+            valid = [res[t.task_id]["score"] for t in tasks if t.pillar==p and t.task_id in res and res[t.task_id]["score"]>=0]
+            if valid: ps[p]=np.mean(valid)
+        wts = {p:info["weight"] for p,info in PILLAR_INFO.items()}
+        fs = round(sum(ps.get(p,0)*w for p,w in wts.items()),2)
+        g = "A" if fs>=80 else ("B+" if fs>=70 else ("B" if fs>=60 else "C"))
+        ph = ""
+        for p,info in PILLAR_INFO.items():
+            s=ps.get(p,0); c=_c(s); w=int(info["weight"]*100)
+            ph += f'<div class="pillar-row"><span style="width:140px">{info["icon"]} {info["name"]} ({w}%)</span><div class="pillar-bar"><div class="pillar-fill" style="width:{min(s,100)}%;background:{c}"></div></div><span style="width:55px;text-align:right;font-weight:700;color:{c}">{s:.1f}</span></div>'
+        summ = f'{CSS}<div class="summary-card"><h2 style="margin:0;font-size:1.8em;text-align:center">🧬 FINAL Score: {fs:.1f}/100</h2><h3 style="text-align:center;color:#aaa">{g} | {_S.get("model","")}</h3><hr style="border-color:#333;margin:16px 0">{ph}<hr style="border-color:#333;margin:16px 0"><p style="font-size:.85em;color:#888">{_S.get("hf","")}</p></div>'
+    return (prog, tbl, summ, None)
+
+# ══ Gradio App ══
+
+HEADER = """<div style="text-align:center;padding:20px 0">
+<h1 style="margin:0;font-size:2em">🧬 FINAL Bench Auto-Evaluator</h1>
+<p style="color:#666;max-width:700px;margin:10px auto;line-height:1.7">
+<b>FINAL Bench 100문제</b> × ALL Bench 등재 모델 자동 평가<br>
+📡 HF Inference API · ⚖️ GPT-5.2 Judge · 📊 → ALL Bench Metacog 자동 반영
+</p></div>"""
 
 def create_app():
     with gr.Blocks(title="FINAL Bench Auto-Evaluator", theme=gr.themes.Soft(),
                    css=".gradio-container{max-width:1100px !important}") as app:
-        gr.HTML(HEADER_HTML)
-
-        with gr.Row():
-            api_type = gr.Radio(
-                ["HuggingFace Inference", "OpenAI Compatible"],
-                value="HuggingFace Inference", label="📡 API 유형", scale=2)
-            model_choice = gr.Dropdown(
-                choices=list(HF_MODELS.keys()),
-                value=list(HF_MODELS.keys())[0],
-                label="🤖 평가 대상 모델", scale=3, allow_custom_value=True)
-
-        api_type.change(_update_model_choices, [api_type], [model_choice])
-
+        gr.HTML(HEADER)
         with gr.Row():
-            eval_api_key = gr.Textbox(
-                label="🔑 피평가 API Key (HF Token 또는 OpenAI Key)",
-                type="password", placeholder="hf_... 또는 sk-...",
-                value=os.getenv("HF_TOKEN", ""), scale=3)
-            judge_api_key = gr.Textbox(
-                label="⚖️ Judge API Key (OpenAI GPT-5.2)",
-                type="password", placeholder="sk-...",
-                value=os.getenv("OPENAI_API_KEY", ""), scale=3)
-
+            mdd = gr.Dropdown(list(HF_MODELS.keys()), value=list(HF_MODELS.keys())[0],
+                              label="🤖 평가 대상 모델", scale=4)
+            mt = gr.Slider(1, len(ALL_TASKS) if ALL_TASKS else 100,
+                           value=len(ALL_TASKS) if ALL_TASKS else 100, step=1, label="과제 수", scale=2)
+            wk = gr.Slider(1, 15, value=8, step=1, label="⚡ 워커", scale=1)
         with gr.Row():
-            judge_model = gr.Textbox(label="⚖️ 심판 모델", value="gpt-5.2", scale=2)
-            pillar_dd = gr.Dropdown(PILLAR_CHOICES, value="전체", label="기둥 필터", scale=2)
-            diff_dd = gr.Dropdown(DIFF_CHOICES, value="전체", label="난이도", scale=1)
-            max_tasks = gr.Slider(1, 220, value=220, step=1, label="최대 과제 수", scale=2)
-            n_workers = gr.Slider(1, 20, value=10, step=1, label="⚡ 병렬 워커", scale=1)
-
-        with gr.Row():
-            start_btn = gr.Button("▶️ 평가 시작 (이어하기)", variant="primary", size="lg", scale=2)
-            fresh_btn = gr.Button("🚀 새로 시작", variant="secondary", size="lg", scale=2)
-            stop_btn = gr.Button("⏹️ 중단", variant="stop", size="lg", scale=1)
-
-        status_msg = gr.Textbox(label="상태", interactive=False, max_lines=1)
-
-        # ── Existing scores display ──
-        with gr.Accordion("📊 기존 FINAL Score 결과", open=False):
-            scores_display = gr.JSON(label="final_scores.json", value=load_final_scores())
-
+            sb = gr.Button("▶️ 이어하기", variant="primary", size="lg", scale=2)
+            fb = gr.Button("🚀 새로 시작", variant="secondary", size="lg", scale=2)
+            xb = gr.Button("⏹️ 중단", variant="stop", size="lg", scale=1)
+        st = gr.Textbox(label="상태", interactive=False, max_lines=1)
+        with gr.Accordion("📊 기존 결과", open=False):
+            gr.JSON(label="final_scores.json", value=load_sf())
         with gr.Tabs():
-            with gr.Tab("📊 진행"):
-                progress_html = gr.HTML()
-            with gr.Tab("📋 결과표"):
-                table_html = gr.HTML()
-            with gr.Tab("🏆 최종"):
-                summary_html = gr.HTML()
-            with gr.Tab("💾 CSV"):
-                csv_file = gr.File(label="평가 결과 CSV")
-
-        # Timer polling
+            with gr.Tab("📊 진행"): p1=gr.HTML()
+            with gr.Tab("📋 결과표"): p2=gr.HTML()
+            with gr.Tab("🏆 최종"): p3=gr.HTML()
+            with gr.Tab("💾 CSV"): p4=gr.File(label="CSV")
         timer = gr.Timer(value=2, active=True)
-        timer.tick(fn=_poll, outputs=[progress_html, table_html, summary_html, csv_file])
-
-        all_inputs = [model_choice, api_type, eval_api_key, judge_api_key, judge_model,
-                      pillar_dd, diff_dd, max_tasks, n_workers]
-
-        start_btn.click(
-            fn=lambda *args: _start_eval(*args, fresh_start=False),
-            inputs=all_inputs, outputs=[status_msg])
-        fresh_btn.click(
-            fn=lambda *args: _start_eval(*args, fresh_start=True),
-            inputs=all_inputs, outputs=[status_msg])
-        stop_btn.click(fn=_stop, outputs=[status_msg])
-
-        gr.Markdown("""---
-<center>FINAL Bench Auto-Evaluator v1.0 · Apache 2.0 · Ginigen AI (지니젠AI)<br>
-📡 HF Inference API + ⚖️ OpenAI Structured Judge<br>
-📊 결과 → <code>final_scores.json</code> → ALL Bench Leaderboard 자동 연동</center>""")
-
+        timer.tick(fn=_poll, outputs=[p1,p2,p3,p4])
+        sb.click(fn=lambda m,t,w: _start(m,t,w,False), inputs=[mdd,mt,wk], outputs=[st])
+        fb.click(fn=lambda m,t,w: _start(m,t,w,True), inputs=[mdd,mt,wk], outputs=[st])
+        xb.click(fn=_stop, outputs=[st])
+        gr.Markdown(f"---\n<center>FINAL Bench v1.0 · {len(ALL_TASKS)}문제 · Ginigen AI · Apache 2.0</center>")
     return app
 
-
-# ════════════════════════════════════════════════════════════════
-# MAIN
-# ════════════════════════════════════════════════════════════════
-
 if __name__ == "__main__":
     stats = {}
-    for t in ALL_TASKS:
-        stats[t.pillar] = stats.get(t.pillar, 0) + 1
-    print(f"FINAL Bench Auto-Evaluator v1.0: {len(ALL_TASKS)} tasks loaded")
-    for p, n in stats.items():
-        info = PILLAR_INFO[p]
-        print(f"  {info['icon']} {info['name']}: {n} ({int(info['weight']*100)}%)")
-    print(f"  📡 HF Models: {len(HF_MODELS)} | 🔑 OpenAI Models: {len(OPENAI_MODELS)}")
-
+    for t in ALL_TASKS: stats[t.pillar]=stats.get(t.pillar,0)+1
+    print(f"🧬 FINAL Bench Auto-Evaluator: {len(ALL_TASKS)} tasks")
+    for p,n in stats.items():
+        info=PILLAR_INFO[p]; print(f"  {info['icon']} {info['name']}: {n}")
+    print(f"  📡 HF Models: {len(HF_MODELS)} | ⚖️ Judge: GPT-5.2")
+    print(f"  🔑 HF_TOKEN: {'✅' if os.getenv('HF_TOKEN') else '❌'} | OPENAI_API_KEY: {'✅' if os.getenv('OPENAI_API_KEY') else '❌'}")
     app = create_app()
     app.queue(default_concurrency_limit=2)
     app.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)