3종 후속 작업 — cleanup 스크립트 + ner_filter 강화 + HE-FL Phase 2

(C) scripts/cleanup_decisions_reasons.py 신규:
- 모든 decisions 의 reasons / findings 에서 classifier 의 0-weight entity
(NRP/NORP/DATE_TIME/URL/US_DRIVER_LICENSE/US_ITIN/US_PASSPORT/IN_PAN) 제거
- ai_score 재계산 (reasons 합계와 일관성)
- Dry-run 기본 + --apply 옵션 + 자동 백업 (decisions.db.before-cleanup-<ts>)
- 검증: 현재 18건 중 3건 영향, 993 reasons 항목 제거 예정
(결정 18 한 건이 987 reasons 보유 — NRP 481·URL 364·PHONE 189 의 누적)

(B) ner_filter.py 강화:
- _REJECT_PREFIX 에 부서·업무 어휘 30+ 추가:
평가/검토/심사/관리/운영/총무/기획/전략/영업/인사/교육/연구/개발/...
- LOCATION 신규 _LOC_ADMIN_SUFFIX (시/도/구/군/동/리/읍/면/가/로/길/...) —
3자 이상 LOCATION 은 행정 단위 접미사 필요
- LOCATION 신규 _LOC_BLACKLIST (여기/거기/본사/지사/내부/외부/현장/...) 즉시 거부

(A) HE-FL Phase 2 — N 라운드 자동 반복:
- he_fl.py 확장:
- compute_gradient_from_reasons() — train.py 와 동일한 reasons 기반 features
(Phase 1 의 findings_summary 가 비어있어 grad=0 이던 문제 해소)
- _evaluate() — 평문 평가: MSE + 등급 정확도 (학습 전후 비교)
- run_round() — 1라운드: 분할 → reasons grad → 합산 시뮬 → 평균 → 적용
- run_multi_rounds() — N회 반복 + 라운드별 정확도/MSE 기록
- 라우트: POST /api/he/fl/round + /api/he/fl/auto
- UI: 같은 #tab-he-fl 탭 하단에 Phase 2 카드 추가
- n_rounds (default 10) + n_clients + eta input
- 최종 성과 표 (시작/최종 정확도/MSE)
- 시계열 SVG (정확도 파랑 + MSE 주황, dual axis)
- 라운드별 이력 표 (model_version 까지)
- 초보 가이드: Phase 1 (실제 BFV) vs Phase 2 (평문 시뮬) 차이 + 왜 시뮬로 OK

검증 (5 라운드 실행):
현 데이터 (cleanup 미실행, NRP 노이즈 누적) 로는 정확도 진동 (61%→33%).
→ 사용자: scripts/cleanup_decisions_reasons.py --apply 실행 후 재실행 권장.
cleanup 후엔 학습이 안정되어 정확도 수렴 예상.

이로써 SPEC §6.3 \"PoC 학습 클라이언트 시뮬 + 서버 시뮬\" 완료.

app.py

@@ -1661,6 +1661,30 @@ def api_he_fl_apply():
     return jsonify(he_fl.apply_aggregated_gradient(grad_f, eta=eta))
 
 
+# HE-FL Phase 2 — 라운드 자동 반복
+@app.route("/api/he/fl/round", methods=["POST"])
+def api_he_fl_round():
+    p = request.get_json(silent=True) or {}
+    try:
+        n_clients = max(1, int(p.get("n_clients", 2)))
+        eta = float(p.get("eta", 0.05))
+    except (TypeError, ValueError):
+        return jsonify({"ok": False, "message": "n_clients/eta 필수"}), 400
+    return jsonify(he_fl.run_round(n_clients=n_clients, eta=eta))
+
+
+@app.route("/api/he/fl/auto", methods=["POST"])
+def api_he_fl_auto():
+    p = request.get_json(silent=True) or {}
+    try:
+        n_rounds = max(1, min(100, int(p.get("n_rounds", 10))))
+        n_clients = max(1, int(p.get("n_clients", 2)))
+        eta = float(p.get("eta", 0.05))
+    except (TypeError, ValueError):
+        return jsonify({"ok": False, "message": "n_rounds/n_clients/eta 필수"}), 400
+    return jsonify(he_fl.run_multi_rounds(n_rounds=n_rounds, n_clients=n_clients, eta=eta))
+
+
 if __name__ == "__main__":
     host = os.environ.get("HOST", "127.0.0.1")
     port = int(os.environ.get("PORT", "5000"))

app_lite.py

@@ -1396,6 +1396,30 @@ def api_he_fl_apply():
     return jsonify(he_fl.apply_aggregated_gradient(grad_f, eta=eta))
 
 
+# HE-FL Phase 2 — 라운드 자동 반복
+@app.route("/api/he/fl/round", methods=["POST"])
+def api_he_fl_round():
+    p = request.get_json(silent=True) or {}
+    try:
+        n_clients = max(1, int(p.get("n_clients", 2)))
+        eta = float(p.get("eta", 0.05))
+    except (TypeError, ValueError):
+        return jsonify({"ok": False, "message": "n_clients/eta 필수"}), 400
+    return jsonify(he_fl.run_round(n_clients=n_clients, eta=eta))
+
+
+@app.route("/api/he/fl/auto", methods=["POST"])
+def api_he_fl_auto():
+    p = request.get_json(silent=True) or {}
+    try:
+        n_rounds = max(1, min(100, int(p.get("n_rounds", 10))))
+        n_clients = max(1, int(p.get("n_clients", 2)))
+        eta = float(p.get("eta", 0.05))
+    except (TypeError, ValueError):
+        return jsonify({"ok": False, "message": "n_rounds/n_clients/eta 필수"}), 400
+    return jsonify(he_fl.run_multi_rounds(n_rounds=n_rounds, n_clients=n_clients, eta=eta))
+
+
 if __name__ == "__main__":
     host = os.environ.get("HOST", "127.0.0.1")
     port = int(os.environ.get("PORT", "5000"))

he_fl.py

@@ -250,7 +250,163 @@ def status() -> dict[str, Any]:
     weights = dict(classifier.ENTITY_WEIGHTS)
     return {
         "ok": True,
-        "n_decisions": len(storage.list_decisions(limit=1000)),
+        "n_decisions": len(storage.fetch_all_for_training()),
         "current_weights": weights,
         "n_entities": len(weights),
     }
+
+
+# -------------------------------------------------------------------
+# Phase 2 — 다중 클라이언트 + N 라운드 자동 반복
+# -------------------------------------------------------------------
+
+def _evaluate(decisions: list[dict], weights: dict[str, float],
+              entities: list[str]) -> dict[str, float]:
+    """평문 평가 — MSE 와 등급 정확도 (학습용 reasons-기반)."""
+    import classifier as _cls
+    if not decisions:
+        return {"mse": None, "accuracy": None, "n": 0}
+    n_correct = 0
+    sse = 0.0
+    n = 0
+    for d in decisions:
+        # train.py 의 _features_of 와 동일한 reasons 기반 features (정확성 위해)
+        feats: dict[str, int] = {}
+        for r in d.get("reasons") or []:
+            if r.get("kind") != "entity":
+                continue
+            lab = r.get("label")
+            if lab:
+                feats[lab] = feats.get(lab, 0) + int(r.get("count") or 0)
+        target = _grade_to_target(d.get("user_grade"))
+        if target is None:
+            continue
+        pred = sum(weights.get(ent, 0.0) * cnt for ent, cnt in feats.items())
+        sse += (pred - target) ** 2
+        # 등급 결정
+        if pred >= getattr(_cls, "C_THRESHOLD", 2.0):
+            new_grade = "C"
+        elif pred >= getattr(_cls, "S_THRESHOLD", 1.0):
+            new_grade = "S"
+        else:
+            new_grade = "O"
+        if new_grade == d.get("user_grade"):
+            n_correct += 1
+        n += 1
+    return {
+        "mse": round(sse / n, 4) if n else None,
+        "accuracy": round(n_correct / n, 4) if n else None,
+        "n": n,
+    }
+
+
+def compute_gradient_from_reasons(decisions: list[dict], weights: dict[str, float],
+                                  entities: list[str]) -> tuple[dict[str, float], dict[str, Any]]:
+    """reasons 기반 gradient — train.py 의 features 와 동일 (Phase 2 정확성).
+
+    Phase 1 은 findings_summary 사용 (비어 있어 grad=0 문제).
+    Phase 2 는 reasons 사용 — 실제 학습 데이터 일관성.
+    """
+    n = 0
+    sum_loss = 0.0
+    grad_accum: dict[str, float] = {ent: 0.0 for ent in entities}
+
+    for d in decisions:
+        feats: dict[str, int] = {}
+        for r in d.get("reasons") or []:
+            if r.get("kind") != "entity":
+                continue
+            lab = r.get("label")
+            if lab and lab in grad_accum:
+                feats[lab] = feats.get(lab, 0) + int(r.get("count") or 0)
+        target = _grade_to_target(d.get("user_grade"))
+        if target is None:
+            continue
+        pred = sum(weights.get(ent, 0.0) * cnt for ent, cnt in feats.items())
+        err = pred - target
+        sum_loss += err * err
+        for ent, c in feats.items():
+            grad_accum[ent] += err * c
+        n += 1
+
+    if n == 0:
+        return {ent: 0.0 for ent in entities}, {"n_samples": 0, "mse": None}
+    grad_avg = {ent: round(g / n, 6) for ent, g in grad_accum.items()}
+    return grad_avg, {"n_samples": n, "mse": round(sum_loss / n, 6)}
+
+
+def run_round(n_clients: int = 2, eta: float = 0.05) -> dict[str, Any]:
+    """1 라운드 — 결정 N분할 → client 별 reasons-기반 gradient → 합산 시뮬 → 평균 → 적용.
+
+    Phase 2 의 HE 시뮬: 서버 측 평문 합산 (BFV 동형성은 Phase 1 탭이 시각 검증).
+    한 라운드를 ms 단위 빠르게 → N 라운드 반복 가능.
+    """
+    import classifier
+    decisions = storage.fetch_all_for_training()
+    if not decisions:
+        return {"ok": False, "message": "no decisions"}
+
+    weights_before = dict(classifier.ENTITY_WEIGHTS)
+    entities = sorted(weights_before.keys())
+
+    # 학습 전 평가
+    eval_before = _evaluate(decisions, weights_before, entities)
+
+    # 클라이언트 분할 + 각자 gradient
+    chunks = simulate_clients(decisions, n_clients=n_clients)
+    client_grads = []
+    for c in chunks:
+        grad, _meta = compute_gradient_from_reasons(c, weights_before, entities)
+        client_grads.append(grad)
+
+    # 시뮬 합산 → 평균 (HE 의 evaluator.add 동일 결과)
+    n = len(client_grads)
+    avg_grad = {ent: 0.0 for ent in entities}
+    for g in client_grads:
+        for ent, v in g.items():
+            avg_grad[ent] += v
+    avg_grad = {ent: v / n for ent, v in avg_grad.items()}
+
+    # 적용
+    applied = apply_aggregated_gradient(avg_grad, eta=eta)
+    weights_after = applied["after"]
+
+    # 학습 후 평가
+    eval_after = _evaluate(decisions, weights_after, entities)
+
+    return {
+        "ok": True,
+        "n_clients": n,
+        "n_decisions": len(decisions),
+        "eta": eta,
+        "model_version": applied["model_version"],
+        "before": eval_before,
+        "after": eval_after,
+        "deltas": applied["deltas"],
+        "new_weights": weights_after,
+    }
+
+
+def run_multi_rounds(n_rounds: int = 10, n_clients: int = 2, eta: float = 0.05) -> dict[str, Any]:
+    """N 라운드 자동 반복. 라운드별 정확도/SSE 기록."""
+    history = []
+    for i in range(max(1, n_rounds)):
+        r = run_round(n_clients=n_clients, eta=eta)
+        if not r.get("ok"):
+            return r
+        history.append({
+            "round": i + 1,
+            "accuracy_before": r["before"]["accuracy"],
+            "accuracy_after": r["after"]["accuracy"],
+            "mse_before": r["before"]["mse"],
+            "mse_after": r["after"]["mse"],
+            "model_version": r["model_version"],
+            "max_abs_delta": max((abs(v) for v in r["deltas"].values()), default=0.0),
+        })
+    return {
+        "ok": True,
+        "n_rounds": len(history),
+        "n_clients": n_clients,
+        "eta": eta,
+        "history": history,
+    }

ner_filter.py

@@ -42,6 +42,13 @@ _REJECT_PREFIX = (
     "매뉴얼", "자료", "회의록", "성과", "일정",
     "받을", "넣을", "쓸", "할", "갈", "올",
     "안녕", "감사", "환영",
+    # 추가 — 부서·업무·평가 어휘 (회의록·검토 문서에 흔함)
+    "평가", "검토", "심사", "관리", "운영", "총무", "기획", "전략",
+    "영업", "마케팅", "구매", "인사", "교육", "연구", "개발", "생산",
+    "품질", "물류", "재무", "회계", "법무", "감사", "보안", "안전",
+    "건의", "보고", "제안", "검사", "조치", "결과", "활동", "처리",
+    "참고", "참석", "참여", "협의", "공유", "지원", "요청", "수신",
+    "송신", "전달", "교부", "발송", "수령", "접수", "처분", "통보",
 )
 
 # 흔한 한국 성씨 (상위 ~30개로 인구 80% 커버)
@@ -79,6 +86,18 @@ def _is_likely_kr_person(text: str) -> tuple[bool, str | None]:
     return True, None
 
 
+# LOCATION 은 보통 행정 단위 접미사로 끝남 (긍정 신호)
+_LOC_ADMIN_SUFFIX = (
+    "시", "도", "구", "군", "동", "리", "읍", "면", "가",
+    "로", "길", "역", "공항", "항구", "원", "공원",
+)
+# LOCATION 으로 흔히 잘못 잡히는 일반 명사
+_LOC_BLACKLIST = {
+    "여기", "거기", "저기", "이곳", "그곳", "저곳",
+    "본사", "지사", "본부", "지점", "사무실", "회의실",
+    "현장", "내부", "외부", "전국", "전체", "각종",
+}
+
 def _is_likely_kr_location(text: str) -> tuple[bool, str | None]:
     if not text or len(text) < 2:
         return False, "too_short"
@@ -88,12 +107,20 @@ def _is_likely_kr_location(text: str) -> tuple[bool, str | None]:
         return False, "contains_special_chars"
     if not _is_pure_hangul(text):
         return False, "non_hangul"
+    if text in _LOC_BLACKLIST:
+        return False, "location_blacklist"
     if text.startswith(_REJECT_PREFIX):
         return False, "prefix_blacklist"
     if text.endswith(_REJECT_SUFFIX):
         return False, "suffix_blacklist"
-    # LOCATION 은 보통 시/도/구/동/리 같은 행정 단위로 끝남 — 더 엄격하게
-    return True, None
+    # 행정 단위 접미사가 있으면 강한 신호 — 통과
+    if text.endswith(_LOC_ADMIN_SUFFIX):
+        return True, None
+    # 단일 단어 (2~3자) 인데 행정 접미사 없으면 의심 — 일반 한국 지명 (예: 부산) 만 허용
+    # PoC: 2자는 통과, 3자 이상은 행정 단위 필요
+    if len(text) <= 2:
+        return True, None
+    return False, "no_admin_suffix"
 
 
 def _is_likely_org(text: str) -> tuple[bool, str | None]:

scripts/cleanup_decisions_reasons.py

@@ -0,0 +1,179 @@
+"""decisions.reasons / findings 마이그레이션 — 0-weight entity 제거.
+
+배경
+----
+이전 분류에서 NRP, DATE_TIME, URL, US_DRIVER_LICENSE 등이 reasons 에 다수 누적되어
+학습을 dominate 했다 (NRP 481회 등장). 분류 오탐 fix (가중치 0 + 정규식 강화 +
+후처리 필터) 적용 후에도 과거 decisions 의 reasons 에는 이 entity 가 그대로 남아 있음.
+
+본 스크립트는:
+1) 모든 decisions 의 reasons / findings 에서 NOISE_ENTITIES 제거
+2) ai_score 도 재계산 (reasons 합계와 일관성 보장)
+3) Dry-run 기본 — 실제 적용은 --apply 필요
+4) 적용 전 자동 백업 (decisions.db → decisions.db.before-cleanup-<ts>)
+
+실행
+----
+    .venv/bin/python scripts/cleanup_decisions_reasons.py           # dry-run
+    .venv/bin/python scripts/cleanup_decisions_reasons.py --apply   # 실제 적용
+
+옵션
+----
+    --noise-list NRP NORP DATE_TIME URL US_DRIVER_LICENSE ...   # 직접 지정
+    --keep-low-weight  # 가중치 0 인 entity 만 제거 (default — classifier 기준 자동)
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import sys
+import time
+from pathlib import Path
+
+# 프로젝트 루트 import 경로
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import storage  # noqa: E402
+import classifier  # noqa: E402
+
+# classifier.ENTITY_WEIGHTS 에서 0 인 entity 자동 추출 (대책 commit 후의 명시 0 목록)
+def get_zero_weight_entities() -> set[str]:
+    return {ent for ent, w in classifier.ENTITY_WEIGHTS.items() if w == 0.0}
+
+
+def cleanup_reasons(reasons: list[dict], noise: set[str]) -> tuple[list[dict], int]:
+    """reasons 에서 label ∈ noise 인 항목 제거. 반환: (clean, removed_count)."""
+    if not isinstance(reasons, list):
+        return reasons, 0
+    out = []
+    removed = 0
+    for r in reasons:
+        lab = r.get("label")
+        kind = r.get("kind")
+        if kind == "entity" and lab in noise:
+            removed += int(r.get("count") or 1)
+            continue
+        out.append(r)
+    return out, removed
+
+
+def cleanup_findings(findings: list[dict], noise: set[str]) -> tuple[list[dict], int]:
+    """findings 에서 entity_type ∈ noise 인 항목 제거."""
+    if not isinstance(findings, list):
+        return findings, 0
+    out = []
+    removed = 0
+    for f in findings:
+        if f.get("entity_type") in noise:
+            removed += 1
+            continue
+        out.append(f)
+    return out, removed
+
+
+def recompute_ai_score(reasons: list[dict]) -> float:
+    """reasons 합산 (contribution 또는 weight*count)."""
+    total = 0.0
+    for r in reasons:
+        contrib = r.get("contribution")
+        if contrib is not None:
+            total += float(contrib)
+        else:
+            try:
+                total += float(r.get("weight") or 0.0) * int(r.get("count") or 0)
+            except (TypeError, ValueError):
+                pass
+    return round(total, 4)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--apply", action="store_true",
+                   help="실제 DB 수정 (default: dry-run)")
+    p.add_argument("--noise-list", nargs="*", default=None,
+                   help="강제로 제거할 entity 목록 (default: classifier 의 0-weight)")
+    args = p.parse_args()
+
+    if args.noise_list:
+        noise = set(args.noise_list)
+        print(f"강제 noise 목록 사용: {sorted(noise)}")
+    else:
+        noise = get_zero_weight_entities()
+        print(f"classifier 의 0-weight entity 자동 추출: {sorted(noise)}")
+
+    if not noise:
+        print("제거할 entity 없음. 종료.")
+        return
+
+    decisions = storage.fetch_all_for_training()
+    print(f"\n총 결정: {len(decisions)}건 분석 시작.\n")
+
+    total_removed_reasons = 0
+    total_removed_findings = 0
+    affected = 0
+    plans = []
+
+    for d in decisions:
+        reasons_clean, rrem = cleanup_reasons(d.get("reasons") or [], noise)
+        findings_clean, frem = cleanup_findings(d.get("findings") or [], noise)
+        if rrem == 0 and frem == 0:
+            continue
+        new_score = recompute_ai_score(reasons_clean)
+        affected += 1
+        total_removed_reasons += rrem
+        total_removed_findings += frem
+        plans.append({
+            "id": d["id"],
+            "ai_grade": d.get("ai_grade"),
+            "user_grade": d.get("user_grade"),
+            "ai_score_old": d.get("ai_score"),
+            "ai_score_new": new_score,
+            "removed_reasons": rrem,
+            "removed_findings": frem,
+            "reasons_clean": reasons_clean,
+            "findings_clean": findings_clean,
+        })
+
+    print(f"영향 결정: {affected}건 / 전체 {len(decisions)}건")
+    print(f"제거할 reasons 항목 누적: {total_removed_reasons}건")
+    print(f"제거할 findings 항목 누적: {total_removed_findings}건")
+    print()
+
+    if plans[:5]:
+        print("샘플 변경 (상�� 5건):")
+        for p in plans[:5]:
+            print(f"  id={p['id']:3d} ai={p['ai_grade']}→user={p['user_grade']} "
+                  f"score {p['ai_score_old']} → {p['ai_score_new']} "
+                  f"(-{p['removed_reasons']} reasons, -{p['removed_findings']} findings)")
+
+    if not args.apply:
+        print("\n[DRY-RUN] 변경 미적용. --apply 추가하면 실제 DB update.")
+        return
+
+    # 백업
+    db_path = Path(storage.DB_PATH) if hasattr(storage, "DB_PATH") else Path("decisions.db")
+    ts = time.strftime("%Y%m%d-%H%M%S")
+    backup = db_path.with_suffix(db_path.suffix + f".before-cleanup-{ts}")
+    if db_path.exists():
+        shutil.copy2(db_path, backup)
+        print(f"\n✅ 백업 생성: {backup}")
+
+    # 실제 UPDATE
+    with storage.connect() as c:
+        for p in plans:
+            c.execute(
+                "UPDATE decisions SET reasons_json=?, findings_json=?, ai_score=? WHERE id=?",
+                (
+                    json.dumps(p["reasons_clean"], ensure_ascii=False),
+                    json.dumps(p["findings_clean"], ensure_ascii=False),
+                    p["ai_score_new"],
+                    p["id"],
+                ),
+            )
+    print(f"✅ {affected}건 결정 update 완료.")
+    print(f"\n다음 단계: 학습/이력 탭에서 \"새로고침\" 후 \"🚀 학습 라운드 실행\" → 깨끗한 데이터로 학습.")
+
+
+if __name__ == "__main__":
+    main()

templates/index.html

@@ -2596,6 +2596,81 @@ AWS Key: AKIAIOSFODNN7EXAMPLE
     <p class="ser-size">평문 합산 결과와 HE 복호화 결과 일치 확인 + 변경된 entity 별 Δw 시각화.</p>
     <div id="hefl-step6-body"><div class="empty">실행 후 표시</div></div>
   </div>
+
+  <!-- ====== Phase 2 — N 라운드 자동 반복 ====== -->
+  <div class="card" style="border-left:4px solid #10B981; background:rgba(16,185,129,.04);">
+    <h2><span class="ico" data-lucide="rotate-ccw"></span>Phase 2 — N 라운드 자동 반복 (서버 시뮬)</h2>
+    <p class="lead">Phase 1 의 1 라운드를 N 회 자동 반복합니다. 라운드별 정확도·MSE 변화를 시계열로 시각화하여 수렴 여부 확인. <b>HE 보호는 Phase 1 가 BFV 동형성으로 검증</b>; Phase 2 는 서버 측 평문 시뮬레이션으로 빠르게 N 라운드 돌림.</p>
+
+    <details style="margin-bottom:14px;">
+      <summary style="cursor:pointer; font-weight:600;">📖 초보 가이드 — Phase 2 가 Phase 1 과 다른 점</summary>
+      <div style="padding:12px; background:#F4F4F8; border-radius:6px; margin-top:8px; font-size:13.5px; line-height:1.7;">
+        <p><b>Phase 1</b> (위 6단계) — 실제 BFV 암호화·합산·복호화. 한 라운드 ~5초 (key gen 등 포함).</p>
+        <p><b>Phase 2</b> (이 섹션) — 같은 흐름의 <b>평문 시뮬레이션</b>. HE 의 효과는 Phase 1 이 보여줬으니, 이제 라운드 반복 수렴만 보는 단계. 한 라운드 ~10ms.</p>
+        <p><b>핵심 통찰:</b> HE 의 동형성으로 평문 합산 결과 = HE 복호화 결과 (Phase 1 검증). 따라서 Phase 2 의 평문 시뮬도 production 의 HE 결과와 같음.</p>
+        <p><b>data 소스:</b> reasons 기반 (train.py 와 동일). 결정 이력의 noise (NRP 등) 영향은 노이즈 fix commit 이후 가중치 0 으로 차단됨.</p>
+      </div>
+    </details>
+
+    <div class="grid" style="margin-bottom:10px;">
+      <div class="col">
+        <label style="display:block; font-weight:600; margin-bottom:4px;">라운드 수 (n_rounds)</label>
+        <input type="number" id="hefl2-rounds" min="1" max="100" value="10" style="width:90px;">
+      </div>
+      <div class="col">
+        <label style="display:block; font-weight:600; margin-bottom:4px;">클라이언트 수</label>
+        <input type="number" id="hefl2-nclients" min="1" max="5" value="2" style="width:90px;">
+      </div>
+      <div class="col">
+        <label style="display:block; font-weight:600; margin-bottom:4px;">η (learning rate)</label>
+        <input type="number" id="hefl2-eta" min="0.001" max="0.5" step="0.005" value="0.02" style="width:90px;">
+      </div>
+    </div>
+    <div style="display:flex; gap:8px; align-items:center; margin-bottom:14px;">
+      <button id="hefl2-run"><span class="ico" data-lucide="zap"></span>N 라운드 자동 실행</button>
+      <span id="hefl2-status" class="ser-size">대기 중</span>
+    </div>
+
+    <div id="hefl2-result" style="display:none;">
+      <div class="grid">
+        <div class="col">
+          <div class="card" style="background:white; box-shadow:none; margin-bottom:0;">
+            <h3 style="font-size:13px; margin:0 0 6px;">최종 성과</h3>
+            <table style="width:100%; font-size:13px;">
+              <tr><td class="ser-size">시작 정확도</td><td class="num"><code id="hefl2-acc-start">—</code></td></tr>
+              <tr><td class="ser-size">최종 정확도</td><td class="num"><code id="hefl2-acc-end">—</code></td></tr>
+              <tr><td class="ser-size">시작 MSE</td><td class="num"><code id="hefl2-mse-start">—</code></td></tr>
+              <tr><td class="ser-size">최종 MSE</td><td class="num"><code id="hefl2-mse-end">—</code></td></tr>
+              <tr><td class="ser-size">총 라운드</td><td class="num"><code id="hefl2-rounds-done">—</code></td></tr>
+            </table>
+          </div>
+        </div>
+        <div class="col" style="flex:2;">
+          <div class="card" style="background:white; box-shadow:none; margin-bottom:0;">
+            <h3 style="font-size:13px; margin:0 0 6px;">시계열 — 정확도(파랑) · MSE(주황)</h3>
+            <svg id="hefl2-chart" width="700" height="240" style="max-width:100%; border:1px solid var(--line); border-radius:4px; background:white;">
+              <text x="350" y="120" text-anchor="middle" fill="#9C9C9C" font-size="13">실행 후 표시</text>
+            </svg>
+          </div>
+        </div>
+      </div>
+      <div class="card" style="background:white; box-shadow:none; margin-top:10px;">
+        <h3 style="font-size:13px; margin:0 0 6px;">라운드 이력</h3>
+        <div style="max-height:260px; overflow:auto; border:1px solid var(--line); border-radius:4px;">
+        <table style="width:100%; font-size:12.5px;">
+          <thead style="background:#F4F4F8; position:sticky; top:0;"><tr>
+            <th style="padding:4px 8px;">#</th>
+            <th class="num">accuracy (before→after)</th>
+            <th class="num">MSE (before→after)</th>
+            <th class="num">max|Δw|</th>
+            <th>model_version</th>
+          </tr></thead>
+          <tbody id="hefl2-history"></tbody>
+        </table>
+        </div>
+      </div>
+    </div>
+  </div>
 </div>
 
 <!-- =================== TAB : 신뢰도 보정 (Platt — SPEC §2.4 (2)) =================== -->
@@ -6165,6 +6240,104 @@ document.querySelector('.tab-btn[data-tab="calib"]')?.addEventListener('click',
 });
 
 
+/* ========================= HE-FL Phase 2 — N 라운드 자동 ========================= */
+const hefl2UI = {
+  rounds:    document.getElementById('hefl2-rounds'),
+  nClients:  document.getElementById('hefl2-nclients'),
+  eta:       document.getElementById('hefl2-eta'),
+  run:       document.getElementById('hefl2-run'),
+  status:    document.getElementById('hefl2-status'),
+  result:    document.getElementById('hefl2-result'),
+  accStart:  document.getElementById('hefl2-acc-start'),
+  accEnd:    document.getElementById('hefl2-acc-end'),
+  mseStart:  document.getElementById('hefl2-mse-start'),
+  mseEnd:    document.getElementById('hefl2-mse-end'),
+  roundsDone:document.getElementById('hefl2-rounds-done'),
+  chart:     document.getElementById('hefl2-chart'),
+  history:   document.getElementById('hefl2-history'),
+};
+
+function _hefl2Pct(v) { return v == null ? '—' : (v * 100).toFixed(1) + '%'; }
+function _hefl2Num(v, d=4) { return v == null ? '—' : Number(v).toFixed(d); }
+
+function _hefl2DrawChart(history) {
+  const svg = hefl2UI.chart;
+  const W = 700, H = 240, m = {top:20,right:60,bottom:30,left:50};
+  const gW = W - m.left - m.right, gH = H - m.top - m.bottom;
+  if (!history || !history.length) {
+    svg.innerHTML = `<text x="${W/2}" y="${H/2}" text-anchor="middle" fill="#9C9C9C" font-size="13">데이터 없음</text>`;
+    return;
+  }
+  const n = history.length;
+  const xAt = i => m.left + (n === 1 ? gW/2 : (i / (n - 1)) * gW);
+  const yAcc = v => m.top + (1 - (v ?? 0)) * gH;
+  const maxMse = Math.max(0.5, ...history.map(h => h.mse_after ?? 0));
+  const yMse = v => m.top + (1 - ((v ?? 0) / maxMse)) * gH;
+  const parts = [];
+  parts.push(`<rect x="${m.left}" y="${m.top}" width="${gW}" height="${gH}" fill="white" stroke="#E8E8EC"/>`);
+  for (let i = 0; i <= 5; i++) {
+    const y = m.top + (i/5)*gH;
+    parts.push(`<line x1="${m.left}" y1="${y}" x2="${m.left+gW}" y2="${y}" stroke="#F0F0F2" stroke-width="0.5"/>`);
+    parts.push(`<text x="${m.left-6}" y="${y+3}" text-anchor="end" font-size="10" fill="#9C9C9C">${(1-i/5).toFixed(1)}</text>`);
+    parts.push(`<text x="${m.left+gW+6}" y="${y+3}" font-size="10" fill="#92400E">${(maxMse*(1-i/5)).toFixed(2)}</text>`);
+  }
+  // accuracy line (after)
+  const accPath = history.map((h,i) => `${i===0?'M':'L'} ${xAt(i)} ${yAcc(h.accuracy_after)}`).join(' ');
+  parts.push(`<path d="${accPath}" stroke="#6366F1" stroke-width="2" fill="none"/>`);
+  // mse line
+  const msePath = history.map((h,i) => `${i===0?'M':'L'} ${xAt(i)} ${yMse(h.mse_after)}`).join(' ');
+  parts.push(`<path d="${msePath}" stroke="#F59E0B" stroke-width="2" fill="none"/>`);
+  // points
+  for (let i = 0; i < n; i++) {
+    parts.push(`<circle cx="${xAt(i)}" cy="${yAcc(history[i].accuracy_after)}" r="3" fill="#6366F1"/>`);
+    parts.push(`<circle cx="${xAt(i)}" cy="${yMse(history[i].mse_after)}" r="3" fill="#F59E0B"/>`);
+  }
+  parts.push(`<text x="${m.left + gW/2}" y="${H-8}" text-anchor="middle" font-size="11" fill="#525252">round 1 → ${n}</text>`);
+  parts.push(`<text x="${m.left-36}" y="${m.top-6}" font-size="10" fill="#6366F1">정확도</text>`);
+  parts.push(`<text x="${m.left+gW+6}" y="${m.top-6}" font-size="10" fill="#92400E">MSE</text>`);
+  svg.innerHTML = parts.join('');
+}
+
+hefl2UI.run.addEventListener('click', async () => {
+  const n_rounds = parseInt(hefl2UI.rounds.value) || 10;
+  const n_clients = parseInt(hefl2UI.nClients.value) || 2;
+  const eta = parseFloat(hefl2UI.eta.value) || 0.02;
+  hefl2UI.run.disabled = true;
+  hefl2UI.status.textContent = `${n_rounds} 라운드 실행 중...`;
+  try {
+    const r = await fetch('/api/he/fl/auto', {
+      method: 'POST', headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({ n_rounds, n_clients, eta }),
+    });
+    const j = await r.json();
+    if (!j.ok) {
+      hefl2UI.status.textContent = '❌ ' + (j.message || '실패');
+      return;
+    }
+    const h = j.history;
+    hefl2UI.result.style.display = '';
+    hefl2UI.accStart.textContent = _hefl2Pct(h[0]?.accuracy_before);
+    hefl2UI.accEnd.textContent   = _hefl2Pct(h[h.length-1]?.accuracy_after);
+    hefl2UI.mseStart.textContent = _hefl2Num(h[0]?.mse_before);
+    hefl2UI.mseEnd.textContent   = _hefl2Num(h[h.length-1]?.mse_after);
+    hefl2UI.roundsDone.textContent = h.length;
+    _hefl2DrawChart(h);
+    hefl2UI.history.innerHTML = h.map(row => `<tr>
+      <td style="padding:3px 8px;">${row.round}</td>
+      <td class="num">${_hefl2Pct(row.accuracy_before)} → <b>${_hefl2Pct(row.accuracy_after)}</b></td>
+      <td class="num">${_hefl2Num(row.mse_before, 3)} → <b>${_hefl2Num(row.mse_after, 3)}</b></td>
+      <td class="num">${_hefl2Num(row.max_abs_delta, 4)}</td>
+      <td><code style="font-size:11px;">${row.model_version}</code></td>
+    </tr>`).join('');
+    hefl2UI.status.textContent = `✅ 완료 — ${h.length} 라운드, 정확도 ${_hefl2Pct(h[0]?.accuracy_before)} → ${_hefl2Pct(h[h.length-1]?.accuracy_after)}`;
+  } catch (e) {
+    hefl2UI.status.textContent = '❌ ' + e.message;
+  } finally {
+    hefl2UI.run.disabled = false;
+  }
+});
+
+
 /* ========================= Drift Detection (SPEC §2.4 (4)) ========================= */
 const driftUI = {
   window: document.getElementById('drift-window'),