Update app.py

app.py

@@ -1,11 +1,3 @@
-"""
-AI 글 판별기 v5.1 — 5축+Perplexity+Humanizer+모델추정 + 품질 + LLM교차검증 + 표절
-═══════════════════════════════════════════════════════════════════════════
-★ v5.1 3대 킬러: Perplexity 확률분석 · Humanizer/Bypasser 탐지 · AI 모델 추정
-★ 5축 AI 탐지 | 6항목 품질 | LLM 교차검증 (GPT-OSS-120B · Qwen3-32B · Kimi-K2)
-★ 표절: Brave Search 병렬(최대20) + KCI/RISS/ARXIV + Gemini + CopyKiller 보고서
-★ 문서: PDF·DOCX·HWP·HWPX·TXT 업로드 → 섹션별 히트맵 + PDF 보고서
-"""
 import gradio as gr
 import math, re, os, json, random, time, hashlib, zlib, zipfile, tempfile
 from collections import Counter
@@ -14,7 +6,6 @@ from pathlib import Path
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from xml.etree import ElementTree as ET
 from kiwipiepy import Kiwi
-
 KIWI = Kiwi()
 try:
     import httpx; HAS_HTTPX = True
@@ -26,8 +17,6 @@ try:
     HAS_GENAI = True
 except ImportError:
     HAS_GENAI = False
-
-# ── 문서 추출 라이브러리 ──
 try:
     import olefile; HAS_OLEFILE = True
 except ImportError:
@@ -44,15 +33,9 @@ try:
     from docx import Document as DocxDocument; HAS_DOCX = True
 except ImportError:
     HAS_DOCX = False
-
 GROQ_KEY = os.getenv("GROQ_API_KEY", "")
 GEMINI_KEY = os.getenv("GEMINI_API_KEY", "")
 BRAVE_KEY = os.getenv("BRAVE_API_KEY", "")
-
-# ═══════════════════════════════════════════════
-# 문서 텍스트 추출 엔진
-# ═══════════════════════════════════════════════
-
 def extract_text_from_pdf(file_path):
     """PDF → 텍스트 (페이지별 분리)"""
     pages = []
@@ -76,7 +59,6 @@ def extract_text_from_pdf(file_path):
         except Exception as e:
             print(f"PyPDF2: {e}")
     return None, "PDF 추출 실패 (pdfplumber, PyPDF2 없음)"
-
 def extract_text_from_docx(file_path):
     """DOCX → 텍스트 (문단별 분리)"""
     if not HAS_DOCX: return None, "python-docx 없음"
@@ -97,7 +79,6 @@ def extract_text_from_docx(file_path):
         return None, "DOCX 텍스트 없음"
     except Exception as e:
         return None, f"DOCX 오류: {e}"
-
 def extract_text_from_txt(file_path):
     """TXT/MD/CSV 등 → 텍스트"""
     for enc in ['utf-8', 'euc-kr', 'cp949', 'utf-16', 'latin-1']:
@@ -105,12 +86,10 @@ def extract_text_from_txt(file_path):
             with open(file_path, 'r', encoding=enc) as f:
                 text = f.read()
             if text.strip():
-                # 빈 줄 기준으로 섹션 분리
                 sections = [s.strip() for s in re.split(r'\n{2,}', text) if s.strip()]
                 return sections if sections else [text], None
         except: continue
     return None, "텍스트 인코딩 감지 실패"
-
 def extract_text_from_hwpx(file_path):
     """HWPX (ZIP 기반) → 텍스트"""
     try:
@@ -149,7 +128,6 @@ def extract_text_from_hwpx(file_path):
         return None, "유효하지 않은 HWPX"
     except Exception as e:
         return None, f"HWPX 오류: {e}"
-
 def _decode_hwp_para(data):
     """HWP 바이너리 → 문단 텍스트"""
     result = []
@@ -171,7 +149,6 @@ def _decode_hwp_para(data):
     text = re.sub(r'[ \t]+', ' ', text)
     text = re.sub(r'\n{3,}', '\n\n', text)
     return text if len(text) > 2 else None
-
 def _extract_hwp_section(data):
     """HWP 섹션 바이너리 → 텍스트"""
     texts = []
@@ -195,7 +172,6 @@ def _extract_hwp_section(data):
         except:
             pos += 1
     return '\n'.join(texts) if texts else None
-
 def extract_text_from_hwp(file_path):
     """HWP (OLE 기반) → 텍스트"""
     if not HAS_OLEFILE: return None, "olefile 없음"
@@ -224,7 +200,6 @@ def extract_text_from_hwp(file_path):
         return None, "HWP 텍스트 없음"
     except Exception as e:
         return None, f"HWP 오류: {e}"
-
 def extract_text_from_file(file_path):
     """
     만능 문서 추출: PDF/DOCX/HWP/HWPX/TXT → (sections_list, full_text, error)
@@ -235,7 +210,6 @@ def extract_text_from_file(file_path):
         return None, None, "파일 없음"
     ext = Path(file_path).suffix.lower()
     sections, error = None, None
-
     if ext == '.pdf':
         sections, error = extract_text_from_pdf(file_path)
     elif ext == '.docx':
@@ -248,32 +222,24 @@ def extract_text_from_file(file_path):
         sections, error = extract_text_from_txt(file_path)
     else:
         return None, None, f"지원하지 않는 형식: {ext}"
-
     if sections:
         full = '\n\n'.join(sections)
         return sections, full, None
     return None, None, error or "텍스트 추출 실패"
-
-# ════════════════════════════════════════���══════
-# 유틸리티
-# ═══════════════════════════════════════════════
 def split_sentences(text):
     try:
         s = [x.text.strip() for x in KIWI.split_into_sents(text) if x.text.strip()]
         if s: return s
     except: pass
     return [x.strip() for x in re.split(r'(?<=[.!?。])\s+', text) if x.strip()]
-
 def split_words(text):
     return [w for w in re.findall(r'[가-힣a-zA-Z0-9]+', text) if w]
-
 def get_morphemes(text):
     try:
         r = KIWI.analyze(text)
         if r and r[0]: return [(m.form, m.tag) for m in r[0][0]]
     except: pass
     return []
-
 def http_get(url, headers=None, timeout=15):
     try:
         if HAS_HTTPX:
@@ -285,7 +251,6 @@ def http_get(url, headers=None, timeout=15):
             with urllib.request.urlopen(req, timeout=timeout) as resp:
                 return resp.read().decode('utf-8', errors='replace')
     except: return None
-
 def http_post_json(url, body, headers=None, timeout=30):
     try:
         h = headers or {}
@@ -300,7 +265,6 @@ def http_post_json(url, body, headers=None, timeout=30):
             with urllib.request.urlopen(req, timeout=timeout, context=ssl.create_default_context()) as resp:
                 return json.loads(resp.read())
     except: return None
-
 def call_groq(model, prompt, max_tokens=800, temperature=0.1):
     if not GROQ_KEY: return None, "NO_KEY"
     url = "https://api.groq.com/openai/v1/chat/completions"
@@ -317,32 +281,23 @@ def call_groq(model, prompt, max_tokens=800, temperature=0.1):
             with urllib.request.urlopen(req, timeout=45, context=ssl.create_default_context()) as resp:
                 return json.loads(resp.read())["choices"][0]["message"]["content"], None
     except Exception as e: return None, str(e)[:150]
-
-# ═══════════════════════════════════════════════
-# ★ 통합 문장 점수 (탭1 + 탭2 공유) — v5.0 대폭 강화
-# ═══════════════════════════════════════════════
 AI_ENDINGS = ['합니다','입니다','됩니다','습니다','있습니다','했습니다','겠습니다']
-# 비격식이지만 AI적인 종결 패턴
 AI_CASUAL_ENDINGS = ['라고 할 수 있다','라고 볼 수 있다','다고 생각한다','다고 판단된다',
     '인 셈이다','인 것이다','는 것이다','는 셈이다','ㄹ 것이다','을 것이다',
     '라 할 수 있다','로 보인다','로 판단된다','고 있다','는 추세다','는 상황이다',
     '지 않을 수 없다','라 하겠다','음을 알 수 있다','할 필요가 있다']
 AI_CONNS = ['또한','따라서','그러므로','이에 따라','한편','더불어','아울러','뿐만 아니라',
     '이를 통해','이에','결과적으로','궁극적으로','특히','나아가','이러한']
-# 자연어에서도 쓰이지만 AI가 과도하게 쓰는 접속사
 AI_SOFT_CONNS = ['물론','그러나','하지만','이처럼','이와 같이','이를 바탕으로']
 AI_FILLER = ['것으로 보','것으로 나타','것으로 예상','할 수 있','볼 수 있','주목할 만',
     '중요한 역할','중요한 의미','긍정적인 영향','부정적인 영향','필요합니다','필요하다',
     '중요합니다','중요하다','역할을 하','영향을 미','기대된다','예상됩니다','부각되고',
     '대두되고','다양한 분야','다양한 산업','눈부신 성과','획기적인 변화','혁신적인',
     '점에서','측면에서','관점에서']
-# 비격식 AI 상투표현 (비격식체로 써도 AI적)
 AI_CASUAL_FILLER = ['무궁무진하다','무궁무진한','과언이 아니','돌파구가 될','전환점이 될',
     '기반으로','발판으로','원동력이','초석이 될','가속화되','급부상','패러다임',
     '지평을 열','새로운 장을','대전환','본격화되','고도화','이정표']
-# 양보-주장 패턴 (AI 특유: "물론 X하지만, Y" 구조)
 AI_CONCESSION = re.compile(r'물론.{2,20}(하지만|그러나|그렇지만|다만)|.{2,15}(이긴 하지만|기는 하지만|수 있지만|수는 있지만)')
-# 영어 AI 패턴
 EN_AI_MARKERS = ['furthermore','additionally','moreover','it is worth noting','in conclusion',
     'it is important to','plays a crucial role','significant impact','various aspects',
     'in this regard','consequently','nevertheless','integral part of','led to remarkable',
@@ -369,23 +324,16 @@ FP = {
     "Perplexity": {"m":['검색 결과에 따르면','보도에 따르면','연구에 따르면','밝혔다','전했다',
                        '것으로 나타났다','것으로 조사됐다','것으로 집계됐다','발표했다'],"e":['밝혔다','나타났다','전했다'],"lp":re.compile(r'\[\d+\]',re.M)},
 }
-
 def score_sentence(sent):
     """단일 문장 AI 점수 (0~100). 탭1·탭2 공유. v5.0 대폭 강화."""
     sc = 0; reasons = []
     sl = sent.lower().strip()
     sr = sent.rstrip('.!?。')
-
-    # ── 격식 종결어미 ──
     for e in AI_ENDINGS:
         if sr.endswith(e): sc += 22; reasons.append(f"격식어미(-{e})"); break
-
-    # ── 비격식 AI 종결 패턴 ──
     if sc == 0:  # 격식이 아닌 경우만
         for e in AI_CASUAL_ENDINGS:
             if sr.endswith(e): sc += 15; reasons.append(f"비격식AI(-{e})"); break
-
-    # ── 문두 접속사 ──
     stripped = sent.strip()
     for c in AI_CONNS:
         if stripped.startswith(c):
@@ -393,36 +341,24 @@ def score_sentence(sent):
     else:
         for c in AI_SOFT_CONNS:
             if stripped.startswith(c): sc += 8; reasons.append(f"약한접속사({c})"); break
-
-    # ── 상투적 표현 (클래식 + 비격식) ──
     filler_found = sum(1 for f in AI_FILLER if f in sent)
     casual_filler = sum(1 for f in AI_CASUAL_FILLER if f in sent)
     total_filler = filler_found + casual_filler
     if total_filler >= 3: sc += 25; reasons.append(f"상투표현×{total_filler}")
     elif total_filler == 2: sc += 18; reasons.append(f"상투표현×2")
     elif total_filler == 1: sc += 10; reasons.append(f"상투표현×1")
-
-    # ── 양보-주장 패턴 (Claude/GPT 특유) ──
     if AI_CONCESSION.search(sent): sc += 10; reasons.append("양보패턴")
-
-    # ── 모델 지문 ──
     for mn, fp in FP.items():
         for m in fp["m"]:
             if m in sent: sc += 8; reasons.append(f"{mn}지문"); break
-
-    # ── 영어 AI 패턴 (복수 누적) ──
     en_count = sum(1 for em in EN_AI_MARKERS if em in sl)
     if en_count >= 3: sc += 25; reasons.append(f"영어AI×{en_count}")
     elif en_count >= 2: sc += 18; reasons.append(f"영어AI×{en_count}")
     elif en_count >= 1: sc += 12; reasons.append(f"영어AI×1")
-
-    # ── 복합 보너스: 격식+상투+접속 동시 → 거의 확실 AI ──
     has_formal = any(sr.endswith(e) for e in AI_ENDINGS)
     has_conn = any(stripped.startswith(c) for c in AI_CONNS)
     if has_formal and total_filler >= 1 and has_conn: sc += 8; reasons.append("복합AI")
     elif has_formal and total_filler >= 2: sc += 5; reasons.append("격식+상투")
-
-    # ── 인간 마커 (감점) — 세분화 ──
     for n, p in HUMAN_MARKERS.items():
         matches = p.findall(sent)
         if matches:
@@ -430,22 +366,13 @@ def score_sentence(sent):
             elif n in ('비격식종결','구어축약'): sc -= 18; reasons.append(f"구어체({n})")
             elif n == '맞춤법오류': sc -= 12; reasons.append("맞춤법오류")
             elif n in ('느낌표','말줄임표'): sc -= 10; reasons.append(f"인간({n})")
-
     return max(0, min(100, sc)), reasons
-
-# ═══════════════════════════════════════════════
-# 축① 통계 — v5.0: Burstiness + 조건부 엔트로피 추가
-# ═══════════════════════════════════════════════
 def analyze_statistics(text, sentences, words):
     sl = [len(s) for s in sentences]
     if len(sl) < 2: return {"score":50}
-
-    # 1. CV (문장 길이 변동 계수)
     avg = sum(sl)/len(sl); std = math.sqrt(sum((l-avg)**2 for l in sl)/len(sl))
     cv = std/avg if avg > 0 else 0
     cv_score = 85 if cv<0.20 else 70 if cv<0.30 else 50 if cv<0.45 else 30 if cv<0.60 else 15
-
-    # 2. Burstiness — 연속 문장 길이차 변동
     diffs = [abs(sl[i]-sl[i-1]) for i in range(1,len(sl))]
     burst_score = 50
     if diffs:
@@ -453,21 +380,14 @@ def analyze_statistics(text, sentences, words):
         max_d = max(diffs)
         burst_ratio = max_d / (avg_d + 1)
         burst_score = 85 if burst_ratio < 1.8 else 65 if burst_ratio < 2.5 else 40 if burst_ratio < 3.5 else 20
-
-    # 3. ★ 표준 길이 비율 — AI는 대부분 25~60자, 인간은 극단 outlier 있음
     standard_ratio = sum(1 for l in sl if 20 <= l <= 60) / len(sl)
     std_score = 80 if standard_ratio > 0.8 else 60 if standard_ratio > 0.6 else 40 if standard_ratio > 0.4 else 20
-    # 극단 문장(10자 미만 or 80자 초과) 있으면 인간적
     extreme = sum(1 for l in sl if l < 10 or l > 80)
     if extreme >= 2: std_score = max(10, std_score - 20)
     elif extreme >= 1: std_score = max(15, std_score - 10)
-
-    # 4. 어휘 다양성
     wf = Counter(words); t = len(words)
     ttr = len(wf)/t if t>0 else 0
     vocab_score = 70 if ttr<0.45 else 55 if ttr<0.55 else 35 if ttr<0.65 else 20
-
-    # 5. 문장 복잡도 균일성
     wpc = [len(split_words(s)) for s in sentences]
     complex_score = 50
     if len(wpc) >= 3:
@@ -475,108 +395,72 @@ def analyze_statistics(text, sentences, words):
         wpc_std = math.sqrt(sum((w-wpc_avg)**2 for w in wpc)/len(wpc))
         wpc_cv = wpc_std/wpc_avg if wpc_avg > 0 else 0
         complex_score = 80 if wpc_cv < 0.20 else 60 if wpc_cv < 0.35 else 35 if wpc_cv < 0.50 else 15
-
     final = int(cv_score*0.20 + burst_score*0.20 + std_score*0.25 + vocab_score*0.15 + complex_score*0.20)
     return {"score":final,"cv":round(cv,3),"ttr":round(ttr,3)}
-
-# ═══════════════════════════════════════════════
-# 축② 문체 — v5.0: 양보패턴 + 비격식AI + 접속사 위치패턴
-# ═══════════════════════════════════════════════
 def analyze_korean_style(text, sentences, morphemes):
     if not sentences: return {"score":50}
-
-    # 1. 종결어미 분석 (격식 + 비격식AI)
     formal_cnt = sum(1 for s in sentences if any(s.rstrip('.!?').endswith(e) for e in AI_ENDINGS))
     casual_ai = sum(1 for s in sentences if any(s.rstrip('.!?').endswith(e) for e in AI_CASUAL_ENDINGS))
     fr = formal_cnt/len(sentences)
     car = casual_ai/len(sentences)
-    # 격식 비율 높으면 AI적, 비격식AI도 가산
     ending_score = 85 if fr>0.7 else 65 if fr>0.5 else 45 if fr>0.3 else 25 if fr>0.1 else 10
     ending_score = min(90, ending_score + int(car * 25))  # 비격식AI 보너스
-
-    # 2. 접속사 밀도 + ★ 위치 패턴
     conn_positions = []
     for i, s in enumerate(sentences):
         for c in AI_CONNS:
             if s.strip().startswith(c): conn_positions.append(i); break
     conn_density = len(conn_positions)/len(sentences) if sentences else 0
     conn_score = 85 if conn_density>0.4 else 65 if conn_density>0.25 else 40 if conn_density>0.1 else 15
-    # AI는 접속사를 규칙적 간격으로 배치 (2-3문장마다)
     if len(conn_positions) >= 2:
         gaps = [conn_positions[i]-conn_positions[i-1] for i in range(1,len(conn_positions))]
         gap_cv = (math.sqrt(sum((g-sum(gaps)/len(gaps))**2 for g in gaps)/len(gaps))/(sum(gaps)/len(gaps)+0.01))
         if gap_cv < 0.5: conn_score = min(90, conn_score + 10)  # 매우 규칙적 → AI 보너스
-
-    # 3. 상투표현 (클래식 + 비격식)
     filler_cnt = sum(1 for f in AI_FILLER if f in text) + sum(1 for f in AI_CASUAL_FILLER if f in text)
     filler_score = 90 if filler_cnt>=6 else 75 if filler_cnt>=4 else 55 if filler_cnt>=2 else 30 if filler_cnt>=1 else 10
-
-    # 4. ★ 양보-주장 구문 (AI 특유: "물론~하지만~" 패턴)
     concession_cnt = len(AI_CONCESSION.findall(text))
     conc_score = 80 if concession_cnt >= 2 else 55 if concession_cnt >= 1 else 20
-
-    # 5. 인간 마커 감점
     human_count = sum(len(p.findall(text)) for p in HUMAN_MARKERS.values())
     human_penalty = min(35, human_count * 8)
-
-    # 6. 품사 비율 (명사 과다 = AI적)
     pos_score = 45
     if morphemes:
         pc = Counter(t for _,t in morphemes); tm = sum(pc.values())
         noun_r = sum(pc.get(t,0) for t in ['NNG','NNP','NNB','NR'])/tm if tm else 0
         pos_score = 70 if noun_r>0.42 else 55 if noun_r>0.38 else 35 if noun_r>0.32 else 20
-
     final = max(5, int(ending_score*0.25 + conn_score*0.20 + filler_score*0.20 +
                        conc_score*0.10 + pos_score*0.15 + 10*0.10) - human_penalty)
     return {"score":final,"formal":f"{fr:.0%}","conn":f"{conn_density:.2f}","filler":filler_cnt,"human":human_count}
-
-# ═══════════════════════════════════════════════
-# 축③ 반복 — v5.0: 문두 N-어절 + 구문 템플릿 + 의미 반복
-# ═══════════════════════════════════════════════
 def analyze_repetition(text, sentences, words):
     if not sentences or len(sentences) < 2: return {"score":35}
-
-    # 1. N-gram 반복 (3-gram)
     tr = 0
     if len(words)>=5:
         tg = Counter(tuple(words[i:i+3]) for i in range(len(words)-2))
         tr = sum(1 for c in tg.values() if c>1)/len(tg) if tg else 0
     ngram_score = 80 if tr>0.15 else 60 if tr>0.08 else 35 if tr>0.03 else 15
-
-    # 2. ★ 문두 2-3어절 다양성 (첫 단어만이 아닌 첫 2-3어절)
     openers_2 = []
     openers_3 = []
     for s in sentences:
         ws = split_words(s)
         if len(ws) >= 2: openers_2.append(tuple(ws[:2]))
         if len(ws) >= 3: openers_3.append(tuple(ws[:3]))
-
     opener2_score = 50
     if openers_2:
         unique2 = len(set(openers_2))/len(openers_2)
         opener2_score = 80 if unique2 < 0.5 else 60 if unique2 < 0.7 else 35 if unique2 < 0.85 else 15
-
-    # 3. AI 접속사 문두 반복
     ai_only_conns = ['또한','따라서','그러므로','이에 따라','더불어','아울러','뿐만 아니라',
                      '이를 통해','이에','결과적으로','궁극적으로','나아가','이러한']
     cr = sum(1 for s in sentences if any(s.strip().startswith(c) for c in ai_only_conns))
     crr = cr/len(sentences) if sentences else 0
     ai_conn_score = 85 if crr>0.35 else 65 if crr>0.2 else 40 if crr>0.08 else 15
-
-    # 4. ★ 구문 템플릿 반복 (주어+조사+...+종결 패턴)
     templates = []
     for s in sentences:
         ws = split_words(s)
         if len(ws) >= 4:
-            # 첫 어절 + 마지막 어절 패턴
             templates.append((ws[0], ws[-1]))
     template_rep = 0
     if templates:
         tc = Counter(templates)
         template_rep = sum(1 for c in tc.values() if c > 1) / len(tc) if tc else 0
     template_score = 80 if template_rep > 0.3 else 55 if template_rep > 0.1 else 25
-
-    # 5. ★ 종결어미 다양성 (AI는 같은 종결어미 반복)
     endings = []
     for s in sentences:
         sr = s.rstrip('.!?。')
@@ -586,36 +470,23 @@ def analyze_repetition(text, sentences, words):
     if endings:
         unique_e = len(set(endings))/len(endings)
         ending_div = 80 if unique_e < 0.3 else 60 if unique_e < 0.5 else 35 if unique_e < 0.7 else 15
-
     final = int(ngram_score*0.15 + opener2_score*0.20 + ai_conn_score*0.25 +
                 template_score*0.15 + ending_div*0.25)
     return {"score":final}
-
-# ═══════════════════════════════════════════════
-# 축④ 구조 — v5.0: 추상성/구체성 + 문장다양성 + 구두점
-# ═══════════════════════════════════════════════
-# AI 추상 수식어 (구체 명사 없이 쓰이는 AI적 형용사)
 AI_VAGUE = re.compile(r'다양한|중요한|긍정적인|부정적인|획기적인|혁신적인|효율적인|체계적인|종합적인|전반적인|지속적인|적극적인|상당한|주요한')
-# 구체성 지표 (인간적 — 고유명사, 숫자+단위, 인용/출처)
 CONCRETE_PROPER = re.compile(r'삼성|LG|현대|SK|카카오|네이버|넷플릭스|구글|애플|테슬라|아마존|마이크로소프트|[가-힣]{2,}대학|[가-힣]{2,}병원|[가-힣]{1,3}시[는을이가]|[가-힣]{1,3}구[는을이가]|[가-힣]{2,}동[에서]')
 CONCRETE_NUMBER = re.compile(r'\d{2,}[만억조원달러%개년월일위등호]|\d+\.\d+%|\d{4}년|\d{1,2}월')
 CONCRETE_QUOTE = re.compile(r'에 따르면|발표했|밝혔다|보도했|전했다|라고 말|인터뷰|설문|조사|통계청|보고서')
-
 def analyze_structure(text, sentences):
     if not sentences: return {"score":35}
-
-    # 1. 마크다운/리스트
     lt = (len(re.findall(r'^\d+[.)]\s',text,re.M)) + len(re.findall(r'^[-•*]\s',text,re.M)) +
          len(re.findall(r'^#+\s',text,re.M)) + len(re.findall(r'\*\*[^*]+\*\*',text)))
     list_score = 90 if lt>=5 else 70 if lt>=3 else 45 if lt>=1 else 10
-
-    # 2. ★ 추상성 vs 구체성 (핵심 판별 — 40% 가중치)
     vague_cnt = len(AI_VAGUE.findall(text))
     proper_cnt = len(CONCRETE_PROPER.findall(text))
     number_cnt = len(CONCRETE_NUMBER.findall(text))
     quote_cnt = len(CONCRETE_QUOTE.findall(text))
     concrete_total = proper_cnt + number_cnt + quote_cnt
-
     if vague_cnt >= 3 and concrete_total == 0: abstract_score = 90
     elif vague_cnt >= 2 and concrete_total <= 1: abstract_score = 70
     elif vague_cnt >= 1 and concrete_total == 0: abstract_score = 55
@@ -623,20 +494,14 @@ def analyze_structure(text, sentences):
     elif concrete_total >= 2: abstract_score = 20
     elif concrete_total >= 1: abstract_score = 30
     else: abstract_score = 45
-
-    # 3. 문장 유형 다양성 (AI=서술문만, 인간=의문/감탄 혼용)
     has_question = any(s.strip().endswith('?') for s in sentences)
     has_exclaim = any(s.strip().endswith('!') for s in sentences)
     has_ellipsis = any('...' in s or '…' in s for s in sentences)
     variety = sum([has_question, has_exclaim, has_ellipsis])
     type_score = 15 if variety >= 2 else 40 if variety >= 1 else 65
-
-    # 4. 구두점 단조로움
     puncts = re.findall(r'[!?,;:…—\-~]', text)
     unique_punct = len(set(puncts))
     punct_score = 65 if unique_punct <= 1 else 45 if unique_punct <= 3 else 20
-
-    # 5. 문단 구조 (다문단인 경우)
     paras = [p.strip() for p in text.split('\n\n') if p.strip()]
     para_score = 35
     if len(paras) >= 2:
@@ -647,13 +512,8 @@ def analyze_structure(text, sentences):
             para_score = 75 if pcv < 0.2 else 55 if pcv < 0.35 else 30
         if len(paras) >= 3 and pl[0] < avg_p and pl[-1] < avg_p:
             para_score = min(85, para_score + 10)
-
     final = int(list_score*0.10 + abstract_score*0.40 + type_score*0.20 + punct_score*0.10 + para_score*0.20)
     return {"score":final}
-
-# ═══════════════════════════════════════════════
-# 축⑤ 지문 — v5.0: Perplexity + 비격식AI + 영어 패턴
-# ═══════════════════════════════════════════════
 def analyze_model_fingerprint(text, sentences):
     ms = {}
     sl = text.lower()
@@ -664,39 +524,22 @@ def analyze_model_fingerprint(text, sentences):
         em = sum(1 for s in sentences if any(s.rstrip('.!?').endswith(e) for e in fp.get("e",[])))
         if sentences: sc += int((em/len(sentences))*20)
         ms[mn] = min(100,sc)
-
-    # ★ 비격식 AI 일반 지문 (특정 모델 불문)
     general_ai = 0
-    # 비격식 AI 상투
     general_ai += sum(5 for f in AI_CASUAL_FILLER if f in text)
-    # 비격식 AI 종결
     casual_end_cnt = sum(1 for s in sentences if any(s.rstrip('.!?').endswith(e) for e in AI_CASUAL_ENDINGS))
     general_ai += casual_end_cnt * 5
-    # 양보 패턴
     general_ai += len(AI_CONCESSION.findall(text)) * 8
     ms["비격식AI"] = min(100, general_ai)
-
-    # ★ 영어 AI 지문
     en_score = sum(5 for em in EN_AI_MARKERS if em in sl)
     ms["영어AI"] = min(100, en_score)
-
     mx = max(ms.values()) if ms else 0
-    # 복수 모델에서 점수가 나오면 더 AI적
     multi = sum(1 for v in ms.values() if v >= 10)
     multi_bonus = 10 if multi >= 3 else 5 if multi >= 2 else 0
-
     base = 85 if mx>=50 else 65 if mx>=35 else 45 if mx>=20 else 25 if mx>=10 else 10
     return {"score":min(95, base + multi_bonus),"model_scores":{k:v for k,v in ms.items() if k not in ("비격식AI","영어AI") or v > 0}}
-
-# ═══════════════════════════════════════════════
-# ★★★ 킬러 기능 ① — Perplexity 기반 AI 확률 (v5.1)
-# ═══════════════════════════════════════════════
-# AI 텍스트는 예측 가능도가 높음 (낮은 Perplexity) → 문자/형태소 n-gram 기반
 def analyze_perplexity(text, sentences, morphemes):
     """한국어 특화 Perplexity + Burstiness — 문자 엔트로피 보정"""
     if len(sentences) < 2: return {"score": 40, "entropy": 0, "variance": 0, "order": 0, "zipf": 0}
-
-    # === 1. 문자 바이그램 엔트로피 (형태소보다 안정적) ===
     chars = [c for c in text if c.strip()]
     char_score = 45
     if len(chars) >= 30:
@@ -704,14 +547,11 @@ def analyze_perplexity(text, sentences, morphemes):
         cb_freq = Counter(cbigrams)
         total_cb = len(cbigrams)
         char_entropy = -sum((cnt/total_cb)*math.log2(cnt/total_cb) for cnt in cb_freq.values())
-        # AI 한국어: ~7~9비트, 인간: ~9~12비트
         if char_entropy < 7.5: char_score = 78
         elif char_entropy < 8.5: char_score = 62
         elif char_entropy < 9.5: char_score = 42
         elif char_entropy < 10.5: char_score = 25
         else: char_score = 12
-
-    # === 2. 문장 길이 Burstiness (CV) ===
     sl = [len(s) for s in sentences]
     burst_score = 45
     if len(sl) >= 3:
@@ -723,8 +563,6 @@ def analyze_perplexity(text, sentences, morphemes):
         elif cv < 0.40: burst_score = 38
         elif cv < 0.60: burst_score = 20
         else: burst_score = 8
-
-    # === 3. 문장간 어휘밀도(TTR) 편차 ===
     sent_ttr = []
     for s in sentences:
         sw = split_words(s)
@@ -738,8 +576,6 @@ def analyze_perplexity(text, sentences, morphemes):
         elif std_ttr < 0.08: ttr_score = 55
         elif std_ttr < 0.15: ttr_score = 35
         else: ttr_score = 15
-
-    # === 4. 종결어미 엔트로피 ===
     endings = [s.rstrip('.!?\u2026')[-3:] for s in sentences if len(s) >= 5]
     end_score = 40
     if len(endings) >= 3:
@@ -751,55 +587,32 @@ def analyze_perplexity(text, sentences, morphemes):
         elif norm_ent < 0.7: end_score = 50
         elif norm_ent < 0.85: end_score = 32
         else: end_score = 15
-
     final = int(char_score * 0.30 + burst_score * 0.30 + ttr_score * 0.20 + end_score * 0.20)
     return {"score": final, "entropy": char_score, "variance": burst_score, "order": ttr_score, "zipf": end_score}
-
-
-# ═══════════════════════════════════════════════
-# ★★★ 킬러 기능 ② — Humanizer/Bypasser 탐지 (v5.1)
-# ═══════════════════════════════════════════════
-# 패러프레이즈 도구(QuillBot 등)로 수정된 AI 글의 잔존 흔적 탐지
-
-# Humanizer 특유 패턴
 HUMANIZER_OVERSUBST = re.compile(r'활용하다|이용하다|사용하다|적용하다|도입하다|채택하다|수행하다|진행하다|실시하다|실행하다')
 HUMANIZER_AWKWARD = re.compile(r'그것은|이것은|저것은|해당 사항|앞서 언급한|전술한|상기한|기술된')
 HUMANIZER_PASSIVE = re.compile(r'되어지[고는며]|하게 되었[다습]|수행되[었어]|진행되[었어]|실시되[었어]|활용되[었어]')
-
 def analyze_humanizer(text, sentences, words, morphemes):
     """Humanizer/Bypasser 탐지 — AI 원문 패러프레이즈 흔적 분석"""
     if len(sentences) < 2: return {"score": 20, "signals": []}
     signals = []
-
-    # === 1. 동의어 과다 치환 패턴 ===
-    # Humanizer는 같은 의미를 다양한 동의어로 바꿈 → 비자연적 어휘 분산
     content_words = [f for f, t in morphemes if t in ('NNG', 'NNP', 'VV', 'VA')]
     if len(content_words) >= 10:
         cw_freq = Counter(content_words)
-        # Hapax ratio 극단적으로 높으면 동의어 치환 의심
         hapax = sum(1 for c in cw_freq.values() if c == 1)
         hapax_ratio = hapax / len(cw_freq) if cw_freq else 0
-        # 자연어: 0.4~0.7, Humanizer: 0.8+ (모든 단어를 다 바꿔서)
         if hapax_ratio > 0.95 and len(content_words) >= 30:
             signals.append(("동의어과다치환", 20, "핵심 어휘가 과도하게 분산"))
         elif hapax_ratio > 0.90 and len(content_words) >= 25:
             signals.append(("동의어치환의심", 12, "어휘 반복 회피 패턴"))
-
-    # === 2. 구조 보존 + 어휘만 변경 패턴 ===
-    # 원문 AI의 문장 구조(길이, 어순)는 유지되면서 단어만 바뀜
     sl = [len(s) for s in sentences]
     if len(sl) >= 4:
         avg = sum(sl) / len(sl)
         cv = math.sqrt(sum((l - avg)**2 for l in sl) / len(sl)) / (avg + 1e-10)
-        # 문장 길이 균일 + 어휘 다양 = Humanizer 패턴
         unique_ratio = len(set(words)) / len(words) if words else 0
         if cv < 0.20 and unique_ratio > 0.80 and len(sentences) >= 5:
             signals.append(("구조보존어휘변경", 18, "문장 구조 균일 + 비정상적 어휘 다양성"))
-
-    # === 3. 잔존 AI 패턴 ===
-    # Humanizer가 놓치기 쉬운 AI 흔적
     residual = 0
-    # 접속사 위치 규칙성 (Humanizer는 접속사를 잘 안 바꿈)
     conn_positions = []
     for i, s in enumerate(sentences):
         stripped = s.strip()
@@ -808,13 +621,10 @@ def analyze_humanizer(text, sentences, words, morphemes):
                 conn_positions.append(i)
                 break
     if len(conn_positions) >= 2:
-        # 등간격 접속사 = AI 원문 구조 잔존
         gaps = [conn_positions[i] - conn_positions[i-1] for i in range(1, len(conn_positions))]
         if gaps and max(gaps) - min(gaps) <= 1:  # 거의 등간격
             signals.append(("접속사등간격잔존", 15, "접속사 배치가 규칙적 (AI 원문 구조 잔존)"))
             residual += 15
-
-    # === 4. 부자연스러운 대체 표현 ===
     oversubst = len(HUMANIZER_OVERSUBST.findall(text))
     awkward = len(HUMANIZER_AWKWARD.findall(text))
     passive = len(HUMANIZER_PASSIVE.findall(text))
@@ -824,11 +634,6 @@ def analyze_humanizer(text, sentences, words, morphemes):
         signals.append(("어색한지시어", 10, f"해당/전술/상기 등 {awkward}개"))
     if passive >= 3:
         signals.append(("이중피동과다", 15, f"되어지/수행되 등 {passive}개"))
-
-    # === 5. 문장 유형 단조 + 어미 다양 = Humanizer 시그니처 ===
-    # AI 원문: 문장유형 단조 + 어미 단조
-    # 인간: 문장유형 다양 + 어미 다양
-    # Humanizer: 문장유형 단조(바꿀 수 없음) + 어미 다양(바꿈) → 부조화
     endings = [s.rstrip('.!?')[-2:] for s in sentences if len(s) >= 4]
     end_types = len(set(endings)) / len(endings) if endings else 0
     has_question = any(s.strip().endswith('?') for s in sentences)
@@ -836,29 +641,17 @@ def analyze_humanizer(text, sentences, words, morphemes):
     sent_type_variety = sum([has_question, has_exclaim])
     if sent_type_variety == 0 and end_types > 0.85 and len(sentences) >= 6:
         signals.append(("유형단조어미다양", 12, "서술문만 + 종결어미 과다 다양 = Humanizer 패턴"))
-
-    # === 6. 문장 시작 패턴 불일치 ===
-    # Humanizer는 문두를 다양하게 바꾸려 하나, 한국어에서는 부자연스러움 유발
     starters = [s.strip()[:3] for s in sentences if len(s) >= 6]
     starter_unique = len(set(starters)) / len(starters) if starters else 0
     if starter_unique >= 0.98 and len(sentences) >= 7:
         signals.append(("문두과다다양", 8, "모든 문장 시작이 다름 (자연스럽지 않은 다양성)"))
-
     total = sum(s[1] for s in signals)
-    # 점수화
     if total >= 45: score = 85
     elif total >= 30: score = 68
     elif total >= 20: score = 52
     elif total >= 10: score = 35
     else: score = 15
-
     return {"score": score, "signals": signals, "total_evidence": total}
-
-# ═══════════════════════════════════════════════
-# ★★★ 킬러 기능 ③ — AI 모델 추정 (v5.1)
-# ═══════════════════════════════════════════════
-# 모델별 고유 특성으로 작성 모델 추정
-
 MODEL_PROFILES = {
     "GPT": {
         "style": ["격식체 ~습니다", "또한/특히 접속사", "~에 대해", "~것으로 예상됩니다"],
@@ -889,27 +682,19 @@ MODEL_PROFILES = {
         "connectors": ["한편", "또한", "이에"],
     },
 }
-
 def estimate_model(text, sentences, morphemes, model_scores):
     """AI 모델 추정 — 복합 증거 기반"""
     evidence = {m: {"score": 0, "reasons": []} for m in MODEL_PROFILES}
-
     sl = text.lower()
-
     for model, profile in MODEL_PROFILES.items():
-        # 1. FP 점수 반영 (기존 지문 분석)
         fp_score = model_scores.get(model, 0)
         evidence[model]["score"] += fp_score * 0.4
         if fp_score >= 20:
             evidence[model]["reasons"].append(f"지문 매칭 {fp_score}점")
-
-        # 2. 마커 매칭
         marker_cnt = sum(1 for m in profile["markers"] if m in text)
         if marker_cnt >= 2:
             evidence[model]["score"] += marker_cnt * 8
             evidence[model]["reasons"].append(f"특유 표현 {marker_cnt}개")
-
-        # 3. 종결어미 패턴
         end_match = 0
         for s in sentences:
             for e in profile["endings"]:
@@ -920,34 +705,23 @@ def estimate_model(text, sentences, morphemes, model_scores):
             if end_ratio > 0.7:
                 evidence[model]["score"] += 12
                 evidence[model]["reasons"].append(f"종결어미 {end_ratio:.0%} 일치")
-
-        # 4. 접속사 패턴
         conn_match = sum(1 for s in sentences if any(s.strip().startswith(c) for c in profile["connectors"]))
         if conn_match >= 2:
             evidence[model]["score"] += conn_match * 4
             evidence[model]["reasons"].append(f"접속사 패턴 {conn_match}회")
-
-    # Perplexity 특화: 수치 + 출처 인용
     number_citations = len(re.findall(r'\d+[%만억조]|에 따르면|것으로 나타났|발표했', text))
     if number_citations >= 3:
         evidence["Perplexity"]["score"] += number_citations * 5
         evidence["Perplexity"]["reasons"].append(f"수치/인용 {number_citations}회")
-
-    # Claude 특화: 양보-주장 구문
     concession_cnt = len(AI_CONCESSION.findall(text))
     if concession_cnt >= 1:
         evidence["Claude"]["score"] += concession_cnt * 10
         evidence["Claude"]["reasons"].append(f"양보-주장 구문 {concession_cnt}회")
-
-    # 정렬 및 판정
     ranked = sorted(evidence.items(), key=lambda x: x[1]["score"], reverse=True)
     top = ranked[0]
     second = ranked[1] if len(ranked) > 1 else None
-
     if top[1]["score"] < 10:
         return {"model": "특정 불가", "confidence": "낮음", "detail": evidence, "ranked": ranked}
-
-    # 신뢰도 계산
     gap = top[1]["score"] - (second[1]["score"] if second else 0)
     if gap >= 20 and top[1]["score"] >= 30:
         conf = "높음"
@@ -955,7 +729,6 @@ def estimate_model(text, sentences, morphemes, model_scores):
         conf = "중간"
     else:
         conf = "낮음"
-
     return {
         "model": top[0],
         "confidence": conf,
@@ -964,10 +737,6 @@ def estimate_model(text, sentences, morphemes, model_scores):
         "detail": evidence,
         "ranked": ranked
     }
-
-# ═══════════════════════════════════════════════
-# 품질
-# ═══════════════════════════════════════════════
 def analyze_quality(text, sentences, words, morphemes):
     qs = {}; sl = [len(s) for s in sentences]; tw = len(words)
     ideal = sum(1 for l in sl if 15<=l<=70)/len(sentences) if sentences else 0
@@ -998,24 +767,16 @@ def analyze_quality(text, sentences, words, morphemes):
     total = int(sum(qs[k]*wq[k] for k in wq))
     grade = "S" if total>=85 else "A" if total>=72 else "B" if total>=58 else "C" if total>=42 else "D" if total>=28 else "F"
     return {"score":total,"grade":grade,"sub_scores":qs}
-
-# ═══════════════════════════════════════════════
-# LLM 교차검증
-# ═══════════════════════════════════════════════
 LLM_JUDGES = [("openai/gpt-oss-120b","GPT-OSS 120B"),("qwen/qwen3-32b","Qwen3 32B"),("moonshotai/kimi-k2-instruct-0905","Kimi-K2")]
-
 def _parse_ai_probability(raw_resp):
     """LLM 응답에서 AI 확률(0~100)을 추출. 한국어/영어 다양한 형식 대응."""
     if not raw_resp: return -1
-    # 1. <think> 태그 분리
     think_content = ''
     think_m = re.search(r'<think>(.*?)</think>', raw_resp, flags=re.S)
     if think_m: think_content = think_m.group(1)
     resp = re.sub(r'<think>.*?</think>', '', raw_resp, flags=re.S).strip()
     if not resp or len(resp) < 5:
         resp = raw_resp  # think만 있으면 원본 포함
-
-    # 2. 특정 키워드 패턴 (높은 우선순위 — 첫 매칭)
     specific_patterns = [
         r'AI\s*확률\s*[:：]\s*(?:약\s*)?(\d+)\s*%?',
         r'AI\s*[Pp]robability\s*[:：]\s*(?:about|approximately?\s*)?(\d+)\s*%?',
@@ -1031,11 +792,8 @@ def _parse_ai_probability(raw_resp):
         if m:
             v = int(m.group(1))
             if 0 <= v <= 100: return v
-
-    # 3. 범용 패턴 — 마지막 5줄에서만 검색 (통계 수치 오탐 방지)
     lines = [l.strip() for l in resp.strip().split('\n') if l.strip()]
     for line in reversed(lines[-5:]):
-        # 라인에 AI/확률/probability 키워드가 있으면 우선
         if re.search(r'AI|확률|[Pp]robab|신뢰|판[정단]', line):
             nums = re.findall(r'(\d+)\s*%', line)
             if nums:
@@ -1045,54 +803,39 @@ def _parse_ai_probability(raw_resp):
             if nums:
                 v = int(nums[-1])
                 if 0 <= v <= 100: return v
-
-    # 4. 전체 텍스트에서 마지막 XX% (단, AI/확률 근처만)
     all_pcts = list(re.finditer(r'(\d+)\s*(?:%|퍼센트|percent)', resp, re.I))
     for m in reversed(all_pcts):
         v = int(m.group(1))
-        # 주변 50자 내에 AI/확률 키워드 있는지
         ctx_start = max(0, m.start()-50)
         ctx = resp[ctx_start:m.end()+20]
         if re.search(r'AI|확률|[Pp]robab|신뢰|판[정단]|가능성|likelihood', ctx, re.I):
             if 0 <= v <= 100: return v
-
-    # 5. 최후 수단: 전체에서 마지막 XX%
     if all_pcts:
         v = int(all_pcts[-1].group(1))
         if 5 <= v <= 99: return v  # 100% 제외 (통계 수치 오탐 방지)
-
-    # 6. think 내부 폴백 (본문 파싱 실패 시)
     if think_content:
         for pat in specific_patterns:
             m = re.search(pat, think_content, re.I)
             if m:
                 v = int(m.group(1))
                 if 0 <= v <= 100: return v
-        # think 내부 마지막 XX%
         think_pcts = re.findall(r'(\d+)\s*%', think_content)
         if think_pcts:
             v = int(think_pcts[-1])
             if 5 <= v <= 99: return v
-
     return -1
-
 def llm_cross_check(text):
     if not GROQ_KEY: return {"score":-1,"detail":{}}
-    # 한국어+영어 병행 프롬프트 (GPT-OSS는 영어 모델이므로)
     prompt = f"""Analyze whether this text was written by AI.
-
 [Instructions]
 1. Determine AI vs Human with 3 brief reasons
 2. IMPORTANT - Your LAST line MUST be exactly this format:
 AI확률: XX%
 (Replace XX with your estimated probability 0-100)
-
 Example of correct last line:
 AI확률: 75%
-
 [Text to analyze]
 {text[:2000]}"""
-
     votes=[]; rpt={}
     for mid,mn in LLM_JUDGES:
         resp,err = call_groq(mid,prompt)
@@ -1101,52 +844,34 @@ AI확률: 75%
             if p >= 0:
                 votes.append(p); rpt[mn]=f"{p}%"
             else:
-                # 디버그: think 제거 후 응답 끝부분
                 cleaned = re.sub(r'<think>.*?</think>', '', resp, flags=re.S).strip()
                 tail = cleaned[-60:].replace('\n',' ') if len(cleaned) > 60 else cleaned.replace('\n',' ')
                 rpt[mn]=f"파싱실패({tail[:40]})"
         else: rpt[mn]=f"ERR:{err[:30] if err else '?'}"
     if votes: return {"score":int(sum(votes)/len(votes)),"detail":rpt}
     return {"score":-1,"detail":rpt}
-
-# ═══════════════════════════════════════════════
-# 종합 판정 (일관된 기준)
-# ═══════════════════════════════════════════════
 def compute_verdict(scores, llm_score=-1, sent_avg=-1, ppx_score=-1, hum_score=-1):
     w={"통계":.06,"문체":.25,"반복성":.10,"구조":.12,"지문":.30}
     ws=sum(scores[k]*w[k] for k in w)
-
-    # ★ Perplexity 축 통합 (17%)
     if ppx_score >= 0: ws += ppx_score * 0.17
-
-    # ★ 교차 신호 부스트
     style=scores["문체"]; fp=scores["지문"]; rep=scores["반복성"]; struct=scores["구조"]
     if style>=35 and fp>=35: ws+=8
     elif style>=30 and fp>=25: ws+=4
     if style>=30 and rep>=25 and fp>=20: ws+=4
     if fp>=45: ws+=3
     if struct>=50 and style>=30: ws+=3
-    # Perplexity + 지문 동시 부스트
     if ppx_score>=55 and fp>=35: ws+=5
     if ppx_score>=65 and style>=35: ws+=3
-
-    # ★ Humanizer 탐지 시 특별 부스트
     if hum_score>=50:
         ws=max(ws, 45)  # Humanizer 확인 → 최소 AI 의심 중간
         ws += (hum_score-50)*0.15
-
-    # ★ 문장 수준 부스트
     if sent_avg>=0 and sent_avg>ws: ws=ws*0.80+sent_avg*0.20
-
     hi=sum(1 for v in scores.values() if v>=50)
     if hi>=4: ws+=8
     elif hi>=3: ws+=5
     elif hi>=2: ws+=2
-
-    # ★ 인간 격식문 할인
     if style<40 and fp<=20 and rep<22 and struct<35 and (ppx_score<0 or ppx_score<40):
         ws-=5
-
     lo=sum(1 for v in scores.values() if v<20)
     if lo>=3: ws-=8
     elif lo>=2: ws-=3
@@ -1157,7 +882,6 @@ def compute_verdict(scores, llm_score=-1, sent_avg=-1, ppx_score=-1, hum_score=-
     if fs>=45: return fs,"AI 의심 중간","ai_low"
     if fs>=30: return fs,"판단 유보","uncertain"
     return fs,"인간 작성 추정","human"
-
 def quick_score(text):
     sents=split_sentences(text); words=split_words(text); morphs=get_morphemes(text)
     sc={"통계":analyze_statistics(text,sents,words)["score"],"문체":analyze_korean_style(text,sents,morphs)["score"],
@@ -1169,10 +893,6 @@ def quick_score(text):
     hum=analyze_humanizer(text,sents,words,morphs)
     fs,v,lv=compute_verdict(sc, sent_avg=sent_avg, ppx_score=ppx["score"], hum_score=hum["score"])
     return fs,v,lv,sc,ppx,hum
-
-# ═══════════════════════════════════════════════
-# ═══════════════════════════════════════════════
-# ★ 표절 검사 (Brave Search 병렬 + KCI/RISS/ARXIV + Gemini)
 def brave_search(query, count=5):
     """Brave Search API — 단일 쿼리"""
     if not BRAVE_KEY: return []
@@ -1188,7 +908,6 @@ def brave_search(query, count=5):
                 return results
     except: pass
     return []
-
 def search_kci(query):
     """KCI(한국학술지인용색인) 검색"""
     try:
@@ -1201,7 +920,6 @@ def search_kci(query):
             return results[:3]
     except: pass
     return []
-
 def search_riss(query):
     """RISS(학술연구정보서비스) — 간접 검색"""
     results = []
@@ -1215,7 +933,6 @@ def search_riss(query):
                     results.append({"title": title, "url": "https://www.riss.kr" + m.group(1), "snippet": "", "source": "RISS"})
     except: pass
     return results[:3]
-
 def search_arxiv(query):
     """arXiv API 검색"""
     results = []
@@ -1231,7 +948,6 @@ def search_arxiv(query):
     except Exception as e:
         pass
     return results[:3]
-
 def gemini_plagiarism_check(text_chunk):
     """Gemini + Google Search Grounding으로 표절 검사"""
     if not HAS_GENAI or not GEMINI_KEY: return None
@@ -1241,7 +957,6 @@ def gemini_plagiarism_check(text_chunk):
         prompt = f"""다음 텍스트가 인터넷에 존재하는지 Google Search로 확인하세요.
 유사한 문장이 발견되면 출처 URL과 유사도(%)를 보고하세요.
 마지막 줄에 "유사도: XX%" 형식으로 작성.
-
 [텍스트]
 {text_chunk[:1000]}"""
         resp = client.models.generate_content(
@@ -1262,7 +977,6 @@ def gemini_plagiarism_check(text_chunk):
         return {"pct": pct, "response": text_resp, "sources": sources}
     except Exception as e:
         return {"pct": 0, "response": str(e)[:100], "sources": []}
-
 def parallel_brave_search(queries, max_workers=10):
     """Brave Search 병렬 실행 (최대 20개)"""
     all_results = {}
@@ -1275,7 +989,6 @@ def parallel_brave_search(queries, max_workers=10):
                 all_results[q] = results
             except: all_results[q] = []
     return all_results
-
 def duckduckgo_search(query, max_results=5):
     """DuckDuckGo HTML 스크래핑 — API 키 불필요 폴백"""
     results = []
@@ -1290,7 +1003,6 @@ def duckduckgo_search(query, max_results=5):
                 href = m.group(1)
                 title = re.sub(r'<[^>]+>', '', m.group(2)).strip()
                 snippet = re.sub(r'<[^>]+>', '', m.group(3)).strip()
-                # DuckDuckGo redirect URL 파싱
                 real_url = href
                 if 'uddg=' in href:
                     um = re.search(r'uddg=([^&]+)', href)
@@ -1300,41 +1012,31 @@ def duckduckgo_search(query, max_results=5):
                 if len(results) >= max_results: break
     except: pass
     return results
-
 def self_crawl_search(query, max_results=3):
     """httpx 기반 자체 크롤링 (DuckDuckGo + 학술 사이트)"""
     all_results = []
-    # DuckDuckGo
     all_results.extend(duckduckgo_search(query, max_results))
-    # 학술 키워드 추가 검색
     if '논문' not in query and 'paper' not in query.lower():
         all_results.extend(duckduckgo_search(f"{query} 논문 학술", 2))
     return all_results
-
 def run_plagiarism(text, progress=gr.Progress()):
     if not text or len(text.strip())<50:
         return "<div style='padding:20px;text-align:center;color:#888;'>⚠️ 최소 50자 이상</div>", ""
     text = text.strip()
     sents = split_sentences(text)
     now = datetime.now().strftime("%Y-%m-%d %H:%M")
-
     has_brave = bool(BRAVE_KEY)
     has_gemini = bool(HAS_GENAI and GEMINI_KEY)
-
     progress(0.05, "문장 분리...")
-    # 문장을 3~5문장 단위로 블록화
     blocks = []
     for i in range(0, len(sents), 4):
         block = ' '.join(sents[i:i+4])
         if len(block) > 20:
             blocks.append({"text": block, "sent_indices": list(range(i, min(i+4, len(sents))))})
-
     all_sources = []
     sent_matches = {i: [] for i in range(len(sents))}  # 문장별 매칭 정보
     block_results = []
     log_lines = []
-
-    # Phase 1: 웹 검색 (Brave Search 병렬 or 자체 크롤링)
     if has_brave:
         progress(0.15, f"Brave Search 병렬 검색 ({len(blocks)}블록)...")
         queries = []
@@ -1351,7 +1053,6 @@ def run_plagiarism(text, progress=gr.Progress()):
                             sent_matches[si].append({"source": r["title"], "url": r["url"], "type": "Brave"})
         log_lines.append(f"Brave Search: {len(queries)}쿼리 → {sum(len(v) for v in brave_results.values())}건")
     else:
-        # 자체 크롤링 폴백 (DuckDuckGo + 병렬)
         progress(0.15, f"자체 웹 검색 ({len(blocks)}블록)...")
         crawl_queries = []
         for b in blocks[:10]:  # 최대 10블록
@@ -1369,15 +1070,11 @@ def run_plagiarism(text, progress=gr.Progress()):
                             sent_matches[si].append({"source": r["title"], "url": r["url"], "type": r.get("source","Web")})
                 except: pass
         log_lines.append(f"자체 웹검색: {len(crawl_queries)}쿼리 (DuckDuckGo)")
-
-    # Phase 2: 학술 DB (KCI, RISS, arXiv) — 키워드 추출 후 검색
     progress(0.40, "학술 DB 검색 (KCI/RISS/arXiv)...")
-    # 핵심 키워드 추출
     words = split_words(text)
     wf = Counter(words)
     keywords = [w for w, c in wf.most_common(20) if len(w) >= 2 and c >= 2][:5]
     kw_query = ' '.join(keywords[:3])
-
     academic_results = []
     with ThreadPoolExecutor(max_workers=3) as executor:
         futures = [
@@ -1392,8 +1089,6 @@ def run_plagiarism(text, progress=gr.Progress()):
                 all_sources.extend(results)
             except: pass
     log_lines.append(f"학술DB: KCI/RISS/arXiv → {len(academic_results)}건")
-
-    # Phase 3: Gemini Google Search Grounding
     gemini_results = []
     if has_gemini:
         progress(0.60, "Gemini + Google Search...")
@@ -1406,22 +1101,15 @@ def run_plagiarism(text, progress=gr.Progress()):
                     for si in b["sent_indices"]:
                         sent_matches[si].append({"source": src.get("title",""), "url": src.get("url",""), "type": "Google"})
         log_lines.append(f"Gemini: {len(blocks[:5])}블록 → {sum(len(r.get('sources',[])) for r in gemini_results)}출처")
-
     progress(0.80, "보고서 생성...")
-
-    # 유사도 계산
     matched_sents = sum(1 for si, matches in sent_matches.items() if matches)
     total_sents = len(sents)
     plag_pct = int(matched_sents / total_sents * 100) if total_sents > 0 else 0
-
-    # Gemini 유사도도 반영
     if gemini_results:
         gemini_pcts = [r["pct"] for r in gemini_results if r["pct"] > 0]
         if gemini_pcts:
             gemini_avg = sum(gemini_pcts) / len(gemini_pcts)
             plag_pct = int(plag_pct * 0.5 + gemini_avg * 0.5)
-
-    # 출처 중복 제거
     seen_urls = set()
     unique_sources = []
     for s in all_sources:
@@ -1429,16 +1117,11 @@ def run_plagiarism(text, progress=gr.Progress()):
         if url and url not in seen_urls:
             seen_urls.add(url)
             unique_sources.append(s)
-
-    # 등급
     if plag_pct >= 50: grade, grade_color, grade_bg = "표절 의심", "#FF4444", "#FFE0E0"
     elif plag_pct >= 30: grade, grade_color, grade_bg = "주의 필요", "#FF8800", "#FFF0DD"
     elif plag_pct >= 15: grade, grade_color, grade_bg = "유사 표현 일부", "#DDAA00", "#FFFBE0"
     elif plag_pct >= 5: grade, grade_color, grade_bg = "양호", "#4ECDC4", "#E0FFF8"
     else: grade, grade_color, grade_bg = "우수 (원본성 높음)", "#22AA44", "#E0FFE8"
-
-
-    # ═══ CopyKiller 정밀 재현 보고서 HTML ═══
     sent_analysis = []
     for i, s in enumerate(sents):
         matches = sent_matches.get(i, [])
@@ -1448,8 +1131,6 @@ def run_plagiarism(text, progress=gr.Progress()):
         else:
             sent_analysis.append({"idx":i, "text":s, "matched":False})
     sim_sents = [s for s in sent_analysis if s["matched"]]
-
-    # 출처 그룹핑
     src_groups = {}
     for src in unique_sources:
         key = src.get("url","")[:80]
@@ -1457,29 +1138,23 @@ def run_plagiarism(text, progress=gr.Progress()):
             src_groups[key] = {"title":src.get("title",""), "url":src.get("url",""), "source":src.get("source",""), "count":0}
         src_groups[key]["count"] += 1
     src_list = sorted(src_groups.values(), key=lambda x: -x["count"])
-
     methods_used = []
     if has_brave: methods_used.append("Brave Search(병렬)")
     elif all_sources: methods_used.append("DuckDuckGo(자체크롤링)")
     methods_used.append("KCI · RISS · arXiv")
     if has_gemini: methods_used.append("Gemini+Google Search")
     method_str = " + ".join(methods_used)
-
     gc = grade_color
     word_count = len(split_words(text))
     char_count = len(text)
     doc_id = hashlib.md5(text[:100].encode()).hexdigest()[:8].upper()
     similarity_pct = plag_pct
     citation_pct = 0
-
-    # 문장 카테고리 분류 (CopyKiller 스타일)
     cat_suspect = len(sim_sents)  # 의심
     cat_cited = 0                  # 인용 (형식적 인용 감지)
     cat_normal = total_sents - cat_suspect - cat_cited  # 일반
     cat_suspect_pct = int(cat_suspect / max(1, total_sents) * 100)
     cat_normal_pct = 100 - cat_suspect_pct
-
-    # 출처 유형 아이콘
     def src_icon(s):
         src = s.get("source","").lower()
         if "kci" in src: return "📚", "KCI"
@@ -1488,8 +1163,6 @@ def run_plagiarism(text, progress=gr.Progress()):
         if "google" in src: return "🔍", "Google"
         if "brave" in src: return "🌐", "Brave"
         return "🌐", "Web"
-
-    # 출처 테이블 행
     src_rows = ""
     for i, sg in enumerate(src_list[:15]):
         pct = min(100, int(sg["count"] / max(1, total_sents) * 100 * 3))
@@ -1503,8 +1176,6 @@ def run_plagiarism(text, progress=gr.Progress()):
           <td style="padding:6px 8px;font-size:12px;text-align:center;border:1px solid #D5D5D5;font-weight:800;color:#D63031;">{pct}%</td>
           <td style="padding:6px 10px;border:1px solid #D5D5D5;"><div style="background:#EDEDED;height:14px;border-radius:2px;overflow:hidden;"><div style="background:linear-gradient(90deg,#D63031,#FF7675);height:100%;width:{max(3,pct)}%;border-radius:2px;"></div></div></td>
         </tr>"""
-
-    # 의심 문장 대비 행
     suspect_rows = ""
     for i, sa in enumerate(sim_sents[:15]):
         suspect_rows += f"""<tr>
@@ -1513,8 +1184,6 @@ def run_plagiarism(text, progress=gr.Progress()):
           <td style="padding:8px;font-size:10px;line-height:1.6;border:1px solid #D5D5D5;vertical-align:top;color:#555;"><span style="background:#FFE0E0;border-bottom:2px solid #E74C3C;padding:1px 3px;">{sa["text"][:70]}...</span></td>
           <td style="padding:8px;font-size:10px;border:1px solid #D5D5D5;vertical-align:top;"><a href="{sa.get('url','#')}" target="_blank" style="color:#2E86C1;text-decoration:none;font-weight:600;">{sa["source"][:28]}</a><br><span style="font-size:8px;color:#AAA;">{sa.get('type','')}</span></td>
         </tr>"""
-
-    # 전체 텍스트 하이라이트 (CopyKiller 스타일 - 문장번호 + 색상)
     full_hl = ""
     for sa in sent_analysis:
         sidx = sa["idx"] + 1
@@ -1522,21 +1191,15 @@ def run_plagiarism(text, progress=gr.Progress()):
             full_hl += f'<span style="background:#FFD6D6;border-bottom:2px solid #E74C3C;padding:1px 2px;cursor:pointer;" title="[의심 #{sidx}] 출처: {sa.get("source","")}">{sa["text"]}</span> '
         else:
             full_hl += f'<span style="color:#333;">{sa["text"]}</span> '
-
-    # 카테고리 바 너비
     bar_suspect_w = max(2, cat_suspect_pct) if cat_suspect > 0 else 0
     bar_normal_w = 100 - bar_suspect_w
-
-    # CSS 상수
     HDR_BG = '#3B7DD8'
     HDR_BG2 = '#4A8DE0'
     TH = 'padding:8px 10px;font-size:10px;font-weight:700;color:#fff;background:{};text-align:center;border:1px solid {};'.format(HDR_BG, HDR_BG)
     TL = 'padding:7px 10px;font-size:11px;color:#444;font-weight:600;background:#EDF2FA;border:1px solid #D5D5D5;'
     TV = 'padding:7px 10px;font-size:12px;color:#333;border:1px solid #D5D5D5;'
     SEC = 'font-size:13px;font-weight:800;color:#1A3C6E;margin:0 0 10px 0;padding:8px 12px;background:#EDF2FA;border-left:4px solid {};border-bottom:1px solid #D5D5D5;'.format(HDR_BG)
-
     html = f"""<div style="font-family:'Noto Sans KR','Malgun Gothic','Apple SD Gothic Neo',sans-serif;max-width:780px;margin:0 auto;background:#fff;border:2px solid #3B7DD8;box-shadow:0 2px 12px rgba(0,0,0,0.08);">
-
     <!-- ═══════ 헤더 (CopyKiller 스타일) ═══════ -->
     <div style="background:linear-gradient(135deg,{HDR_BG},{HDR_BG2});padding:18px 24px;color:#fff;">
       <table style="width:100%;"><tr>
@@ -1550,7 +1213,6 @@ def run_plagiarism(text, progress=gr.Progress()):
         </td>
       </tr></table>
     </div>
-
     <!-- ═══════ 제출 정보 테이블 ═══════ -->
     <div style="padding:16px 24px 0;">
       <div style="{SEC}">📋 검사 정보</div>
@@ -1575,7 +1237,6 @@ def run_plagiarism(text, progress=gr.Progress()):
         </tr>
       </table>
     </div>
-
     <!-- ═══════ 검사 결과 (도넛 + 바) ═══════ -->
     <div style="padding:18px 24px 0;">
       <div style="{SEC}">📊 검사 결과</div>
@@ -1597,7 +1258,6 @@ def run_plagiarism(text, progress=gr.Progress()):
               <span style="font-size:11px;font-weight:800;color:{gc};">{grade}</span>
             </div>
           </td>
-
           <!-- 상세 결과 -->
           <td style="padding:0;border:1px solid #D5D5D5;vertical-align:top;">
             <!-- 카테고리 바 (CopyKiller 핵심) -->
@@ -1613,7 +1273,6 @@ def run_plagiarism(text, progress=gr.Progress()):
                 <span style="display:flex;align-items:center;gap:3px;"><span style="display:inline-block;width:10px;height:10px;background:#E8ECF0;border:1px solid #CCC;border-radius:2px;"></span> 일반 <b>{cat_normal}</b>건</span>
               </div>
             </div>
-
             <!-- 비율 바 3줄 -->
             <div style="padding:12px 18px;">
               <div style="margin-bottom:10px;">
@@ -1629,7 +1288,6 @@ def run_plagiarism(text, progress=gr.Progress()):
                 <div style="background:#EDEDED;height:16px;border-radius:3px;overflow:hidden;border:1px solid #DDD;"><div style="background:linear-gradient(90deg,#3498DB,#85C1E9);height:100%;width:{max(1,citation_pct)}%;transition:width 0.5s;"></div></div>
               </div>
             </div>
-
             <!-- 요약 수치 -->
             <div style="padding:8px 18px;background:#F8F9FB;border-top:1px solid #E8E8E8;">
               <table style="width:100%;border-collapse:collapse;">
@@ -1647,7 +1305,6 @@ def run_plagiarism(text, progress=gr.Progress()):
         </tr>
       </table>
     </div>
-
     <!-- ═══════ 전체 텍스트 분석 ═══════ -->
     <div style="padding:18px 24px 0;">
       <div style="{SEC}">📝 전체 텍스트 분석</div>
@@ -1660,7 +1317,6 @@ def run_plagiarism(text, progress=gr.Progress()):
       </div>
       <div style="padding:14px;background:#FAFBFC;border:1px solid #D5D5D5;line-height:2.1;font-size:13px;max-height:300px;overflow-y:auto;">{full_hl}</div>
     </div>
-
     <!-- ═══════ 표절 의심 출처 ═══════ -->
     <div style="padding:18px 24px 0;">
       <div style="{SEC}">🔗 표절 의심 출처 ({len(src_list)}건)</div>
@@ -1675,7 +1331,6 @@ def run_plagiarism(text, progress=gr.Progress()):
         {src_rows if src_rows else '<tr><td colspan="5" style="padding:18px;text-align:center;color:#999;font-size:11px;border:1px solid #D5D5D5;background:#FAFBFC;">발견된 유사 출처가 없습니다.</td></tr>'}
       </table>
     </div>
-
     <!-- ═══════ 의심 문장 비교 ═══════ -->
     <div style="padding:18px 24px 0;">
       <div style="{SEC}">⚠️ 의심 문장 비교 ({len(sim_sents)}건)</div>
@@ -1689,7 +1344,6 @@ def run_plagiarism(text, progress=gr.Progress()):
         {suspect_rows if suspect_rows else '<tr><td colspan="4" style="padding:18px;text-align:center;color:#999;font-size:11px;border:1px solid #D5D5D5;background:#FAFBFC;">유사 의심 문장이 발견되지 않았습니다.</td></tr>'}
       </table>
     </div>
-
     <!-- ═══════ 검사 안내 ═══════ -->
     <div style="margin:18px 24px;padding:12px 14px;background:#F5F8FC;border:1px solid #D0DAEA;border-radius:4px;font-size:9px;color:#555;line-height:1.8;">
       <b style="color:#333;">📌 검사 안내</b><br>
@@ -1698,7 +1352,6 @@ def run_plagiarism(text, progress=gr.Progress()):
       · 유사도는 문장 단위 매칭 기반이며, 최종 판정은 교수자/검토자의 확인이 필요합니다.<br>
       · 인용 표기(따옴표, 각주 등)가 포함된 문장은 인용으로 분류될 수 있습니다.
     </div>
-
     <!-- ═══════ 푸터 (CopyKiller 스타일) ═══════ -->
     <div style="padding:10px 24px;background:#F0F3F8;border-top:2px solid {HDR_BG};display:flex;justify-content:space-between;align-items:center;">
       <div>
@@ -1711,13 +1364,8 @@ def run_plagiarism(text, progress=gr.Progress()):
       </div>
     </div>
     </div>"""
-
     log = '\n'.join(log_lines) + f"\n\n종합: {plag_pct}% {grade} | 출처 {len(unique_sources)}건 | 유사문장 {matched_sents}/{total_sents}"
     return html, log
-
-# ═══════════════════════════════════════════════
-# 탭1: 분석 (명확한 출력)
-# ═══════════════════════════════════════════════
 def run_detection(text, progress=gr.Progress()):
     if not text or len(text.strip())<50: return "<div style='padding:20px;text-align:center;color:#888;'>⚠️ 최소 50자</div>",""
     text=text.strip()
@@ -1734,17 +1382,12 @@ def run_detection(text, progress=gr.Progress()):
     sc={"통계":s1["score"],"문체":s2["score"],"반복성":s3["score"],"구조":s4["score"],"지문":s5["score"]}
     sent_scores=[score_sentence(s)[0] for s in sents]
     sent_avg=sum(sent_scores)/len(sent_scores) if sent_scores else -1
-
-    # ★ 모델 추정
     ms_raw=s5.get("model_scores",{})
     model_est=estimate_model(text,sents,morphs,ms_raw)
-
     fs,verdict,level=compute_verdict(sc,lr["score"],sent_avg=sent_avg,ppx_score=ppx["score"],hum_score=hum["score"])
     progress(0.95)
     cm={"ai_high":("#FF4444","#FFE0E0","높음"),"ai_medium":("#FF8800","#FFF0DD","중간~높음"),"ai_low":("#DDAA00","#FFFBE0","중간"),"uncertain":("#888","#F0F0F0","낮음"),"human":("#22AA44","#E0FFE8","매우 낮음")}
     fg,bg,conf=cm.get(level,("#888","#F0F0F0","?"))
-
-    # 모델 추정 표시
     est_model=model_est.get("model","특정 불가")
     est_conf=model_est.get("confidence","낮음")
     est_reasons=model_est.get("reasons",[])
@@ -1754,41 +1397,30 @@ def run_detection(text, progress=gr.Progress()):
         mt=f"{est_model} (참고)"
     else:
         mt="특정 불가"
-
     ai_sents=sum(1 for s in sent_scores if s>=40)
     human_sents=sum(1 for s in sent_scores if s<20)
-
     def gb(l,s,w="",desc=""):
         c="#FF4444" if s>=70 else "#FF8800" if s>=50 else "#DDAA00" if s>=35 else "#22AA44"
         wt=f"<span style='color:#999;font-size:9px;'> ×{w}</span>" if w else ""
         dt=f"<div style='font-size:9px;color:#888;margin-top:1px;'>{desc}</div>" if desc else ""
         return f"<div style='margin:4px 0;'><div style='display:flex;justify-content:space-between;'><span style='font-size:11px;font-weight:600;'>{l}{wt}</span><span style='font-size:11px;font-weight:700;color:{c};'>{s}</span></div><div style='background:#E8E8E8;border-radius:4px;height:7px;'><div style='background:{c};height:100%;width:{s}%;border-radius:4px;'></div></div>{dt}</div>"
-
-    # 모델 지문 바
     mb=""
     for mn in ["GPT","Claude","Gemini","Perplexity"]:
         s=ms_raw.get(mn,0); mc="#FF4444" if s>=40 else "#FF8800" if s>=20 else "#CCC"
-        # 추정 모델 표시
         tag=""
         if mn==est_model and est_conf!="낮음":
             tag=f" <span style='background:#FF4444;color:white;font-size:7px;padding:0 3px;border-radius:3px;'>추정</span>"
         mb+=f"<div style='display:flex;align-items:center;gap:4px;margin:2px 0;'><span style='width:66px;font-size:10px;font-weight:600;'>{mn}{tag}</span><div style='flex:1;background:#E8E8E8;border-radius:3px;height:5px;'><div style='background:{mc};height:100%;width:{s}%;'></div></div><span style='font-size:9px;width:18px;text-align:right;color:{mc};'>{s}</span></div>"
-
-    # LLM 섹션
     ls=""
     if lr["score"]>=0:
         lsc=lr["score"]
         lr_rows="".join(f"<div style='font-size:9px;color:#555;'>{mn}: {lr['detail'].get(mn,'—')}</div>" for _,mn in LLM_JUDGES)
         ls=f"<div style='margin-top:8px;padding:8px;background:#F8F8FF;border-radius:6px;border:1px solid #E0E0FF;'><div style='font-size:10px;font-weight:700;margin-bottom:3px;'>🤖 LLM 교차검증 (평균 {lsc}%)</div>{lr_rows}</div>"
     else: ls="<div style='margin-top:6px;padding:4px 8px;background:#F5F5F5;border-radius:4px;color:#999;font-size:9px;'>🤖 GROQ_API_KEY 미설정</div>"
-
-    # 품질
     qs=qr["sub_scores"]; gc={"S":"#FF6B6B","A":"#4ECDC4","B":"#45B7D1","C":"#DDAA00","D":"#FF8800","F":"#FF4444"}.get(qr["grade"],"#888")
     def qgb(l,s):
         c="#22AA44" if s>=70 else "#4ECDC4" if s>=55 else "#DDAA00" if s>=40 else "#FF8800"
         return f"<div style='margin:2px 0;display:flex;align-items:center;gap:4px;'><span style='width:50px;font-size:10px;'>{l}</span><div style='flex:1;background:#E8E8E8;border-radius:3px;height:5px;'><div style='background:{c};height:100%;width:{s}%;'></div></div><span style='font-size:9px;color:{c};width:18px;text-align:right;'>{s}</span></div>"
-
-    # ★ 판정 이유 (3대 킬러 통합)
     reasons=[]
     if sc["문체"]>=70: reasons.append("격식체 종결어미가 대부분, AI형 접속사·상투표현 다수 감지")
     elif sc["문체"]>=50: reasons.append("격식체와 AI형 표현이 혼재")
@@ -1805,8 +1437,6 @@ def run_detection(text, progress=gr.Progress()):
         reasons.append(f"🔍 추정 모델: <b>{est_model}</b> ({est_why})")
     if not reasons: reasons.append("인간적 표현이 우세하며 AI 패턴이 약함")
     reason_html='<br>'.join(f"• {r}" for r in reasons)
-
-    # ★ Perplexity 카드
     ppx_c="#FF4444" if ppx["score"]>=65 else "#FF8800" if ppx["score"]>=50 else "#DDAA00" if ppx["score"]>=35 else "#22AA44"
     ppx_html=f"""<div style='margin-top:8px;padding:8px;background:linear-gradient(135deg,#FFF8F0,#FFF0FF);border-radius:6px;border:1px solid #E8D0FF;'>
         <div style='font-size:10px;font-weight:700;margin-bottom:4px;'>🧠 Perplexity 분석 <span style='color:{ppx_c};font-size:12px;font-weight:900;'>{ppx["score"]}점</span></div>
@@ -1817,8 +1447,6 @@ def run_detection(text, progress=gr.Progress()):
             <span style='font-size:9px;color:#777;'>Zipf적합: {ppx.get("zipf",0)}</span>
         </div>
     </div>"""
-
-    # ★ Humanizer 탐지 카드
     hum_html=""
     if hum["score"]>=30:
         hc="#FF4444" if hum["score"]>=65 else "#FF8800" if hum["score"]>=50 else "#DDAA00"
@@ -1827,8 +1455,6 @@ def run_detection(text, progress=gr.Progress()):
             <div style='font-size:10px;font-weight:700;margin-bottom:3px;'>🛡️ Humanizer 탐지 <span style='color:{hc};font-size:12px;font-weight:900;'>{hum["score"]}점</span></div>
             {sig_rows}
         </div>"""
-
-    # ★ 모델 추정 카드
     est_html=""
     if est_model!="특정 불가":
         ec="#FF4444" if est_conf=="높음" else "#FF8800" if est_conf=="중간" else "#DDAA00"
@@ -1842,7 +1468,6 @@ def run_detection(text, progress=gr.Progress()):
             {ranked_html}
             <div style='font-size:8px;color:#999;margin-top:2px;'>근거: {", ".join(est_reasons[:3]) if est_reasons else "복합 지표"}</div>
         </div>"""
-
     html=f"""<div style="font-family:'Pretendard','Noto Sans KR',sans-serif;max-width:720px;margin:0 auto;">
         <div style="background:{bg};border:2px solid {fg};border-radius:14px;padding:20px;margin-bottom:12px;">
             <div style="display:flex;align-items:center;gap:16px;">
@@ -1864,7 +1489,6 @@ def run_detection(text, progress=gr.Progress()):
                 <div style="font-size:11px;color:#555;line-height:1.7;">{reason_html}</div>
             </div>
         </div>
-
         <div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;">
             <div style="background:#FAFAFA;border-radius:8px;padding:10px;">
                 <div style="font-size:10px;font-weight:700;margin-bottom:4px;">📊 AI 탐지 5축 + Perplexity</div>
@@ -1891,23 +1515,17 @@ def run_detection(text, progress=gr.Progress()):
     </div>"""
     log=f"AI:{fs}점 [{verdict}] 신뢰:{conf} | 모델:{mt} | PPX:{ppx['score']} HUM:{hum['score']} | 품질:{qr['grade']}({qr['score']})\n축: 통계{sc['통계']} 문체{sc['문체']} 반복{sc['반복성']} 구조{sc['구조']} 지문{sc['지문']} PPX{ppx['score']} HUM{hum['score']}"
     return html, log
-
-# ═══════════════════════════════════════════════
-# 탭2: 하이라이트 (탭1과 동일 기준)
-# ═══════════════════════════════════════════════
 def run_highlight(text):
     if not text or len(text.strip())<30: return "<div style='color:#888;'>텍스트 필요</div>"
     sents=split_sentences(text)
     hl=[]
     for s in sents:
         sc, reasons = score_sentence(s)
-        # 5단계 색상
         if sc >= 60: bg="rgba(220,38,38,0.35)"; level="AI확신"
         elif sc >= 40: bg="rgba(249,115,22,0.30)"; level="AI의심"
         elif sc >= 25: bg="rgba(234,179,8,0.25)"; level="주의"
         elif sc >= 10: bg="rgba(132,204,22,0.15)"; level="인간추정"
         else: bg="rgba(34,197,94,0.20)"; level="인간"
-        # 근거 상세
         detail_parts = []
         for r in reasons:
             if '격식' in r or '비격식AI' in r: detail_parts.append(f"🔤 {r}")
@@ -1918,13 +1536,11 @@ def run_highlight(text):
             else: detail_parts.append(r)
         tt = ' | '.join(detail_parts) if detail_parts else '특이 패턴 없음'
         hl.append(f'<span style="background:{bg};padding:2px 4px;border-radius:4px;display:inline;line-height:2.2;border-bottom:2px solid {"#DC2626" if sc>=60 else "#F97316" if sc>=40 else "#EAB308" if sc>=25 else "#84CC16" if sc>=10 else "#22C55E"};" title="[{level}] {tt} ({sc}점)">{s}</span>')
-
     total_scores = [score_sentence(s)[0] for s in sents]
     avg_sc = sum(total_scores)/len(total_scores) if total_scores else 0
     ai_high = sum(1 for s in total_scores if s >= 60)
     ai_mid = sum(1 for s in total_scores if 40 <= s < 60)
     human_cnt = sum(1 for s in total_scores if s < 25)
-
     return f"""<div style='font-family:Pretendard,sans-serif;'>
         <div style='margin-bottom:10px;padding:10px;background:#F8F8FF;border-radius:8px;'>
             <div style='display:flex;gap:8px;align-items:center;font-size:11px;margin-bottom:6px;flex-wrap:wrap;'>
@@ -1938,30 +1554,16 @@ def run_highlight(text):
         </div>
         <div style='line-height:2.4;font-size:14px;'>{'  '.join(hl)}</div>
     </div>"""
-
-# ═══════════════════════════════════════════════
-# GRADIO UI
-# ═══════════════════════════════════════════════
 SAMPLE_AI = """인공지능 기술은 현대 사회에서 매우 중요한 역할을 하고 있습니다. 특히 자연어 처리 분야에서의 발전은 눈부신 성과를 거두고 있습니다. 이러한 기술의 발전은 다양한 산업 분야에 긍정적인 영향을 미치고 있으며, 향후 더욱 발전할 것으로 예상됩니다.
-
 또한 생성형 AI의 등장으로 콘텐츠 제작 방식이 크게 변화하고 있습니다. 이를 통해 기업들은 효율적인 콘텐츠 생산이 가능해졌으며, 개인 사용자들도 다양한 창작 활동에 AI를 활용할 수 있게 되었습니다. 따라서 AI 리터러시의 중요성이 더욱 부각되고 있습니다.
-
 나아가 AI 윤리와 규제에 대한 논의도 활발히 진행되고 있습니다. 특히 AI가 생성한 콘텐츠의 저작권 문제는 중요한 의미를 가지며, 이에 대한 법적 프레임워크 구축이 필요합니다. 결과적으로 기술 발전과 함께 사회적 합의를 이루는 것이 중요합니다."""
-
 SAMPLE_HUMAN = """아 진짜 요즘 AI 때문에 머리 아프다ㅋㅋㅋ 어제 chatgpt한테 레포트 써달라고 했는데 완전 교과서 같은 글만 써줘서 그냥 내가 다시 썼음;;
-
 근데 생각해보면 AI가 쓴 글이랑 사람이 쓴 글이 확실히 다르긴 해. 뭔가... 너무 깔끔하달까? 사람은 이렇게 횡설수설도 하고 맞춤법도 틀리고 그러잖아.
-
 교수님이 AI 탐지기 돌린다고 해서 좀 무서운데 ㅠㅠ 나는 진짜 직접 쓴 건데 혹시 오탐 나면 어쩌지... 걱정된다 진심으로."""
-
-# ═══════════════════════════════════════════════
-# 탭5: 문서 업로드 → 섹션별 히트맵 분석 + PDF 보고서
-# ═══════════════════════════════════════════════
 def run_document_analysis(file, progress=gr.Progress()):
     """문서 파일 업로드 → 섹션별 AI 탐지 히트맵 + PDF 보고서 생성"""
     if file is None:
         return "<div style='padding:20px;text-align:center;color:#888;'>📄 파일을 업로드하세요 (PDF, DOCX, HWP, HWPX, TXT)</div>", "", None
-
     if hasattr(file, 'path'):
         file_path = file.path
     elif hasattr(file, 'name'):
@@ -1970,30 +1572,23 @@ def run_document_analysis(file, progress=gr.Progress()):
         file_path = str(file)
     fname = os.path.basename(file_path)
     progress(0.05, f"📄 {fname} 읽는 중...")
-
     sections, full_text, error = extract_text_from_file(file_path)
     if error:
         return f"<div style='padding:20px;text-align:center;color:#E44;'>⚠️ {error}</div>", "", None
     if not sections or not full_text or len(full_text.strip()) < 50:
         return "<div style='padding:20px;text-align:center;color:#E44;'>⚠️ 텍스트가 충분하지 않습니다 (50자 미만)</div>", "", None
-
     progress(0.15, "전체 텍스트 분석...")
-    # 전체 분석
     sents_all = split_sentences(full_text)
     words_all = split_words(full_text)
     morphs_all = get_morphemes(full_text)
     total_score, total_verdict, total_level, total_axes, total_ppx, total_hum = quick_score(full_text)
     quality = analyze_quality(full_text, sents_all, words_all, morphs_all)
-
-    # LLM 교차검증 (전체)
     progress(0.30, "LLM 교차검증...")
     llm_result = llm_cross_check(full_text[:3000])
     if llm_result["score"] >= 0:
         _sent_scores = [score_sentence(s)[0] for s in sents_all]
         _sent_avg = sum(_sent_scores)/len(_sent_scores) if _sent_scores else -1
         total_score, total_verdict, total_level = compute_verdict(total_axes, llm_result["score"], sent_avg=_sent_avg, ppx_score=total_ppx["score"], hum_score=total_hum["score"])
-
-    # 섹션별 분석
     progress(0.45, f"{len(sections)}개 섹션 분석...")
     section_results = []
     for i, sec in enumerate(sections):
@@ -2001,7 +1596,6 @@ def run_document_analysis(file, progress=gr.Progress()):
             section_results.append({"idx": i+1, "text": sec, "score": -1, "verdict": "너무 짧음", "skipped": True})
             continue
         s_score, s_verdict, s_level, s_axes, _, _ = quick_score(sec)
-        # 문장별 하이라이트
         sec_sents = split_sentences(sec)
         sent_scores = []
         for sent in sec_sents:
@@ -2014,15 +1608,11 @@ def run_document_analysis(file, progress=gr.Progress()):
         })
         pct = 0.45 + (i / max(len(sections), 1)) * 0.30
         progress(pct, f"섹션 {i+1}/{len(sections)}")
-
-    # ═══ HTML 히트맵 보고서 ═══
     now = datetime.now().strftime("%Y-%m-%d %H:%M")
     ext = Path(file_path).suffix.upper()
     cm_map = {"ai_high": ("#FF4444", "#FFE0E0"), "ai_medium": ("#FF8800", "#FFF0DD"),
               "ai_low": ("#DDAA00", "#FFFBE0"), "uncertain": ("#888", "#F5F5F5"), "human": ("#22AA44", "#E0FFE8")}
     tc, tbg = cm_map.get(total_level, ("#888", "#F5F5F5"))
-
-    # 섹션별 히트맵 바 HTML
     heatmap_cells = []
     for sr in section_results:
         sidx = sr["idx"]
@@ -2033,13 +1623,10 @@ def run_document_analysis(file, progress=gr.Progress()):
             ssc = sr["score"]; svd = sr["verdict"]
             heatmap_cells.append(f"<div style='flex:1;min-width:18px;height:28px;background:{sc};border-radius:3px;opacity:0.8;cursor:pointer;' title='섹션{sidx}: AI {ssc}점 ({svd})'></div>")
     heatmap_bar = f"<div style='display:flex;gap:3px;margin:12px 0;'>" + ''.join(heatmap_cells) + "</div>"
-
-    # 섹션 상세 카드
     section_cards = []
     for sr in section_results:
         if sr["skipped"]: continue
         sc, sbg = cm_map.get(sr.get("level", "uncertain"), ("#888", "#F5F5F5"))
-        # 문장 하이라이트 (score_sentence 기반)
         sent_html = ""
         for ss in sr.get("sent_scores", []):
             s = ss["score"]
@@ -2048,14 +1635,12 @@ def run_document_analysis(file, progress=gr.Progress()):
             elif s >= 25: sclr = "background:rgba(221,170,0,0.08);border-bottom:1px solid #DDAA00;"
             else: sclr = ""
             sent_html += f"<span style='{sclr}padding:1px 2px;border-radius:2px;' title='AI {s}점'>{ss['text']}</span> "
-
         axes_html = ""
         if "axes" in sr:
             ax = sr["axes"]
             for k, v in ax.items():
                 axc = "#FF4444" if v >= 50 else "#FF8800" if v >= 30 else "#22AA44"
                 axes_html += f"<span style='display:inline-block;margin:1px 3px;padding:2px 8px;background:{axc}22;border:1px solid {axc}44;border-radius:10px;font-size:9px;color:{axc};'>{k} {v}</span>"
-
         section_cards.append(f"""
         <div style="border:1px solid #E0E0E0;border-left:4px solid {sc};border-radius:8px;padding:14px;margin-bottom:10px;background:white;">
             <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:8px;">
@@ -2065,19 +1650,14 @@ def run_document_analysis(file, progress=gr.Progress()):
             <div style="margin-bottom:6px;">{axes_html}</div>
             <div style="font-size:12px;line-height:1.8;color:#333;">{sent_html}</div>
         </div>""")
-
-    # AI 비율 분포
     ai_high = sum(1 for s in section_results if not s["skipped"] and s["score"] >= 60)
     ai_med = sum(1 for s in section_results if not s["skipped"] and 35 <= s["score"] < 60)
     ai_low = sum(1 for s in section_results if not s["skipped"] and s["score"] < 35)
     valid_sections = [s for s in section_results if not s["skipped"]]
-
-    # LLM 교차검증 정보
     llm_info = ""
     if llm_result["score"] >= 0:
         llm_rows = ''.join(f"<span style='margin-right:8px;font-size:10px;color:#555;'>{mn}: {llm_result['detail'].get(mn,'—')}</span>" for _, mn in LLM_JUDGES)
         llm_info = f"<div style='margin-top:8px;padding:8px 12px;background:#F8F8FF;border-radius:6px;border:1px solid #E0E0FF;font-size:10px;'><b>🤖 LLM 교차검증:</b> 평균 {llm_result['score']}% | {llm_rows}</div>"
-
     html = f"""<div style="font-family:'Pretendard','Noto Sans KR',sans-serif;max-width:800px;margin:0 auto;background:#FAFBFC;border-radius:12px;border:1px solid #E0E0E0;overflow:hidden;">
     <!-- 헤더 -->
     <div style="background:linear-gradient(135deg,#1A1F36,#2D3561);padding:20px 24px;color:white;">
@@ -2092,7 +1672,6 @@ def run_document_analysis(file, progress=gr.Progress()):
             </div>
         </div>
     </div>
-
     <!-- 요약 -->
     <div style="padding:16px 24px;">
         <div style="display:grid;grid-template-columns:repeat(4,1fr);gap:10px;margin-bottom:12px;">
@@ -2113,7 +1692,6 @@ def run_document_analysis(file, progress=gr.Progress()):
                 <div style="font-size:10px;color:#888;">품질 등급</div>
             </div>
         </div>
-
         <!-- 히트맵 바 -->
         <div style="background:white;border:1px solid #E0E0E0;border-radius:8px;padding:12px;">
             <div style="font-size:11px;font-weight:700;margin-bottom:6px;">🗺️ 섹션별 AI 히트맵 (빨강=AI의심, 초록=인간)</div>
@@ -2127,25 +1705,20 @@ def run_document_analysis(file, progress=gr.Progress()):
         </div>
         {llm_info}
     </div>
-
     <!-- 섹션 상세 -->
     <div style="padding:0 24px 20px;">
         <div style="font-size:13px;font-weight:700;margin-bottom:10px;">📊 섹션별 상세 분석 ({len(valid_sections)}개)</div>
         {''.join(section_cards)}
     </div>
-
     <!-- 푸터 -->
     <div style="padding:10px 24px;background:#F0F3F8;border-top:1px solid #E0E0E0;display:flex;justify-content:space-between;">
         <span style="font-size:11px;font-weight:800;color:#1A1F36;">AI Detector v4.0</span>
         <span style="font-size:9px;color:#AAA;">{now} · 5축 앙상블 + LLM 교차검증</span>
     </div>
     </div>"""
-
-    # ═══ PDF 보고서 생성 ═══
     progress(0.90, "PDF 보고서 생성...")
     pdf_path = _generate_pdf_report(fname, total_score, total_verdict, total_level,
                                      total_axes, quality, section_results, llm_result, now)
-
     log = f"파일: {fname} ({ext})\n"
     log += f"섹션: {len(sections)}개 | 전체: {len(full_text)}자\n"
     log += f"총점: {total_score} ({total_verdict})\n"
@@ -2154,23 +1727,17 @@ def run_document_analysis(file, progress=gr.Progress()):
     if llm_result["score"] >= 0:
         log += f"LLM 교차검증: {llm_result['score']}%\n"
     return html, log, pdf_path
-
-
 def _generate_pdf_report(fname, score, verdict, level, axes, quality, sections, llm_result, now):
     """HTML → PDF 변환으로 보고서 생성"""
     try:
         cm = {"ai_high":"#FF4444","ai_medium":"#FF8800","ai_low":"#DDAA00","uncertain":"#888","human":"#22AA44"}
         tc = cm.get(level, "#888")
-
-        # 섹션 테이블 행
         sec_rows = ""
         for sr in sections:
             if sr["skipped"]: continue
             sc = cm.get(sr.get("level","uncertain"),"#888")
             sec_rows += f"<tr><td style='padding:6px 10px;border:1px solid #DDD;text-align:center;'>{sr['idx']}</td><td style='padding:6px 10px;border:1px solid #DDD;'>{sr['text'][:80]}...</td><td style='padding:6px 10px;border:1px solid #DDD;text-align:center;color:{sc};font-weight:700;'>{sr['score']}</td><td style='padding:6px 10px;border:1px solid #DDD;text-align:center;'>{sr['verdict']}</td></tr>"
-
         ax_rows = ''.join(f"<tr><td style='padding:4px 10px;border:1px solid #DDD;'>{k}</td><td style='padding:4px 10px;border:1px solid #DDD;text-align:center;font-weight:700;'>{v}/100</td></tr>" for k, v in axes.items())
-
         html_content = f"""<!DOCTYPE html><html><head><meta charset="UTF-8">
         <style>
             body{{font-family:sans-serif;margin:30px;font-size:12px;color:#333;}}
@@ -2183,28 +1750,22 @@ def _generate_pdf_report(fname, score, verdict, level, axes, quality, sections,
         </style></head><body>
         <h1>📄 AI 글 판별 보고서</h1>
         <p><b>파일:</b> {fname} | <b>생성:</b> {now} | <b>엔진:</b> AI Detector v4.0</p>
-
         <h2>종합 결과</h2>
         <div class="score-box">{score}점</div>
         <span style="margin-left:12px;font-size:16px;font-weight:700;">{verdict}</span>
         <p><b>품질:</b> {quality['grade']} ({quality['score']}점)</p>
-
         <h2>5축 분석</h2>
         <table><tr><th>축</th><th>점수</th></tr>{ax_rows}</table>
-
         <h2>섹션별 분석 ({len([s for s in sections if not s['skipped']])}개)</h2>
         <table>
             <tr><th>No</th><th>내용 (발췌)</th><th>AI 점수</th><th>판정</th></tr>
             {sec_rows}
         </table>
-
         <div class="footer">
             AI Detector v4.0 — 5축 앙상블 + LLM 교차검증 | {now}<br>
             본 보고서는 AI 판별 참고 자료이며, 최종 판단은 검토자의 확인이 필요합니다.
         </div>
         </body></html>"""
-
-        # HTML 파일 저장 → 다운로드용
         report_dir = tempfile.mkdtemp()
         html_path = os.path.join(report_dir, f"AI_Report_{fname}.html")
         with open(html_path, 'w', encoding='utf-8') as f:
@@ -2213,13 +1774,10 @@ def _generate_pdf_report(fname, score, verdict, level, axes, quality, sections,
     except Exception as e:
         print(f"PDF 보고서 생성 오류: {e}")
         return None
-
-
 def extract_file_text_api(file):
     """파일 업로드 → 텍스트 추출 API (탭1~4용)"""
     if file is None:
         return "⚠️ 파일이 없습니다."
-    # Gradio 6.x: FileData 객체 / NamedString / str 모두 처리
     if hasattr(file, 'path'):
         file_path = file.path
     elif hasattr(file, 'name'):
@@ -2235,8 +1793,6 @@ def extract_file_text_api(file):
     if not full_text or len(full_text.strip()) < 10:
         return f"⚠️ {fname}: 텍스트 추출 결과 없음"
     return full_text.strip()
-
-
 with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
     gr.Markdown("# 🔎 AI 글 판별기 v5.1\n**5축+Perplexity+Humanizer탐지+모델추정 · 품질 측정 · LLM 교차검증 · 표절 검사**")
     with gr.Tab("🏆 경쟁력 비교"):
@@ -2252,9 +1808,7 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
 @keyframes glow { 0%,100% { box-shadow:0 0 8px rgba(99,102,241,0.3); } 50% { box-shadow:0 0 20px rgba(99,102,241,0.6); } }
 @keyframes borderPulse { 0%,100% { border-color:rgba(99,102,241,0.3); } 50% { border-color:rgba(99,102,241,0.8); } }
 @keyframes checkPop { from { transform:scale(0) rotate(-180deg); opacity:0; } to { transform:scale(1) rotate(0deg); opacity:1; } }
-
 .comp-wrap { font-family:'Pretendard','Noto Sans KR',system-ui,sans-serif; max-width:860px; margin:0 auto; padding:8px; }
-
 /* 히어로 배너 */
 .hero-banner {
   background: linear-gradient(135deg, #1e1b4b 0%, #312e81 30%, #4338ca 60%, #6366f1 100%);
@@ -2273,7 +1827,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
   font-size:11px; font-weight:800; padding:4px 12px; border-radius:20px; margin-top:10px;
   animation: pulse 2s ease-in-out infinite; position:relative;
 }
-
 /* 핵심 수치 */
 .stats-row { display:grid; grid-template-columns:repeat(4,1fr); gap:10px; margin-bottom:18px; animation:fadeInUp 1s ease-out 0.2s both; }
 .stat-card {
@@ -2283,7 +1836,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
 .stat-card:hover { transform:translateY(-4px); border-color:#6366f1; box-shadow:0 8px 25px rgba(99,102,241,0.15); }
 .stat-num { font-size:32px; font-weight:900; background:linear-gradient(135deg,#6366f1,#8b5cf6); -webkit-background-clip:text; -webkit-text-fill-color:transparent; animation:countUp 0.6s ease-out; }
 .stat-label { font-size:10px; color:#64748b; margin-top:2px; font-weight:600; }
-
 /* 비교 테이블 */
 .comp-table-wrap { animation:fadeInUp 1.1s ease-out 0.4s both; margin-bottom:18px; }
 .comp-table {
@@ -2304,13 +1856,11 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
 .comp-table tbody td:first-child { text-align:left; padding-left:14px; font-weight:600; color:#1e293b; }
 .comp-table tbody td:nth-child(2) { background:rgba(239,68,68,0.04); font-weight:700; }
 .comp-table tbody tr:last-child td { border-bottom:none; }
-
 /* 체크/엑스 아이콘 */
 .ck { color:#22c55e; font-weight:800; font-size:15px; animation:checkPop 0.4s ease-out; }
 .cx { color:#ef4444; font-weight:700; font-size:13px; }
 .cp { color:#f59e0b; font-weight:700; font-size:12px; }
 .cstar { color:#6366f1; font-weight:900; font-size:14px; }
-
 /* 차별화 카드 */
 .diff-grid { display:grid; grid-template-columns:1fr 1fr; gap:10px; margin-bottom:18px; }
 .diff-card {
@@ -2329,7 +1879,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
 .diff-title { font-size:13px; font-weight:800; color:#1e293b; margin-bottom:4px; }
 .diff-desc { font-size:10px; color:#64748b; line-height:1.5; }
 .diff-vs { display:inline-block; background:#fef2f2; color:#dc2626; font-size:9px; font-weight:700; padding:2px 6px; border-radius:4px; margin-top:4px; }
-
 /* 경쟁사 공략 바 */
 .attack-section { animation:fadeInUp 1.3s ease-out 0.8s both; margin-bottom:14px; }
 .attack-title { font-size:13px; font-weight:800; color:#1e293b; margin-bottom:10px; }
@@ -2339,7 +1888,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
 .attack-weak { font-size:9px; color:#ef4444; font-weight:600; }
 .attack-bar { height:8px; background:#f1f5f9; border-radius:4px; overflow:hidden; }
 .attack-fill { height:100%; border-radius:4px; animation:barGrow 1.5s ease-out; }
-
 /* 슬로건 */
 .slogan-box {
   background:linear-gradient(135deg,#faf5ff,#ede9fe,#e0e7ff); border-radius:16px;
@@ -2349,7 +1897,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
 .slogan-main { font-size:16px; font-weight:900; color:#3730a3; margin-bottom:6px; }
 .slogan-sub { font-size:11px; color:#6366f1; line-height:1.7; }
 </style>
-
 <div class="comp-wrap">
   <!-- 히어로 배너 -->
   <div class="hero-banner">
@@ -2360,7 +1907,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
     </div>
     <div class="hero-badge">🔬 v5.1 — 3대 킬러 기능 탑재</div>
   </div>
-
   <!-- 핵심 수치 -->
   <div class="stats-row">
     <div class="stat-card"><div class="stat-num">8축</div><div class="stat-label">탐지 차원<br>(업계 최다)</div></div>
@@ -2368,7 +1914,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
     <div class="stat-card"><div class="stat-num">무료</div><div class="stat-label">완전 무료<br>(횟수 무제한)</div></div>
     <div class="stat-card"><div class="stat-num">4종</div><div class="stat-label">모델 추정<br>(GPT/Claude/Gemini/PPX)</div></div>
   </div>
-
   <!-- 비교 테이블 -->
   <div class="comp-table-wrap">
     <table class="comp-table">
@@ -2513,7 +2058,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
       </tbody>
     </table>
   </div>
-
   <!-- 차별화 4대 카드 -->
   <div class="diff-grid" style="animation:fadeInUp 1.2s ease-out 0.6s both;">
     <div class="diff-card">
@@ -2541,7 +2085,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
       <div class="diff-vs">vs 전체 경쟁사: LLM 검증 미보유</div>
     </div>
   </div>
-
   <!-- 경쟁사 취약점 공략 -->
   <div class="attack-section">
     <div class="attack-title">⚔️ 경쟁사 취약점 vs 우리의 강점</div>
@@ -2566,7 +2109,6 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
       <div class="attack-bar"><div class="attack-fill" style="width:94%;background:linear-gradient(90deg,#a855f7,#ec4899);"></div></div>
     </div>
   </div>
-
   <!-- 슬로건 -->
   <div class="slogan-box">
     <div class="slogan-main">🇰🇷 한국어 AI 글을 가장 정확하게, 가장 투명하게, 완전 무료로 판별합니다</div>
@@ -2603,59 +2145,42 @@ with gr.Blocks(title="AI 글 판별기 v5.1") as demo:
         btn_ps.click(lambda:SAMPLE_AI,outputs=[inp_plag])
     with gr.Tab("📖 설명"):
         gr.Markdown("""
-### 아키텍처 v5.1 — 3대 킬러 기능 탑재
 - **탐지 5축:** 통계(6%)·문체(25%)·반복(10%)·구조(12%)·지문(30%)
 - **★ Perplexity 확률분석(17%):** 문자 엔트로피·Burstiness·TTR편차·종결엔트로피
 - **★ Humanizer 탐지:** 동의어과다치환·구조보존·접속사잔존·이중피동 등 6시그널
 - **★ 모델 추정:** GPT·Claude·Gemini·Perplexity 4모델 증거기반 추정
 - **품질 6항목:** 가독성·어휘·논리·정확성·표현·정보밀도
 - **LLM 교차검증:** GPT-OSS-120B·Qwen3-32B·Kimi-K2 (GROQ)
-
-### 표절 검사
 - **Brave Search**: 병렬 20개 동시 웹검색
 - **학술 DB**: KCI(한국학술지인용색인), RISS(학술연구정보), arXiv
 - **Gemini**: Google Search Grounding
 - **보고서**: CopyKiller 스타일 — 유사도%, 출처표, 문장별 하이라이트
-
-### 환경변수
 - `GROQ_API_KEY` — LLM 교차검증
 - `GEMINI_API_KEY` — 표절 검사 (Google Search Grounding)
 - `BRAVE_API_KEY` — 표절 검사 (Brave Search 병렬)
         """)
-    # ── 숨겨진 파일 텍스트 추출 API (탭1~4 파일 업로드용) ──
     with gr.Row(visible=False):
         _file_in = gr.File(label="hidden_file")
         _text_out = gr.Textbox(label="hidden_text")
         _file_in.change(extract_file_text_api, [_file_in], [_text_out], api_name="extract_file_text")
-
-# ═══ 정적 파일 준비 ═══
 import shutil, pathlib
 static_dir = pathlib.Path("static")
 static_dir.mkdir(exist_ok=True)
 if pathlib.Path("index.html").exists():
     shutil.copy("index.html", static_dir / "index.html")
-
-# ═══ FastAPI — index.html을 루트(/)로 서빙 ═══
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
-
 server = FastAPI()
-
 @server.get("/", response_class=HTMLResponse)
 async def serve_root():
     """루트 URL에서 프리미엄 index.html 서빙"""
     fp = pathlib.Path("static/index.html")
     if fp.exists():
         return HTMLResponse(fp.read_text(encoding="utf-8"))
-    # index.html 없으면 Gradio UI로 리다이렉트
     from fastapi.responses import RedirectResponse
     return RedirectResponse("/gradio/")
-
-# Gradio를 /gradio 경로에 마운트 — API는 /gradio/gradio_api/call/... 에서 작동
 app = gr.mount_gradio_app(server, demo, path="/gradio", allowed_paths=["static"])
-
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
-    
+    uvicorn.run(app, host="0.0.0.0", port=7860)