Update app.py

app.py

@@ -1,8 +1,8 @@
 """
-AI 글 판별기 v4.0 — AI 탐지 + 품질 + AI→인간 변환 + 표절 검사 + 문서 분석
+AI 글 판별기 v5.0 — 5축 AI 탐지 + 품질 측정 + LLM 교차검증 + 표절 검사
 ═══════════════════════════════════════════════════════════════════════════
 5축 AI 탐지 | 6항목 품질 | LLM 교차검증 (GPT-OSS-120B · Qwen3-32B · Kimi-K2)
-★ AI→인간: Adversarial Humanizer v2 (반복 자기대전 루프)
+★ LLM 교차검증: 3모델 (GPT-OSS/Qwen3/Kimi-K2) 투표 + 강건한 파싱
 ★ 표절: Brave Search 병렬(최대20) + KCI/RISS/ARXIV + Gemini + CopyKiller 보고서
 ★ 문서: PDF·DOCX·HWP·HWPX·TXT 업로드 → 섹션별 히트맵 + PDF 보고서
 """
@@ -319,140 +319,344 @@ def call_groq(model, prompt, max_tokens=800, temperature=0.1):
     except Exception as e: return None, str(e)[:150]
 
 # ═══════════════════════════════════════════════
-# ★ 통합 문장 점수 (탭1 + 탭2 공유)
+# ★ 통합 문장 점수 (탭1 + 탭2 공유) — v5.0 대폭 강화
 # ═══════════════════════════════════════════════
 AI_ENDINGS = ['합니다','입니다','됩니다','습니다','있습니다','했습니다','겠습니다']
-AI_CONNS = ['또한','따라서','그러므로','이에 따라','한편','더불어','아울러','뿐만 아니라','이를 통해','이에','결과적으로','궁극적으로','특히','나아가','이러한']
-AI_FILLER = ['것으로 보','것으로 나타','것으로 예상','할 수 있','볼 수 있','주목할 만','중요한 역할','중요한 의미','긍정적인 영향','부정적인 영향','필요합니다','필요하다','중요합니다','중요하다','역할을 하','영향을 미','기대된다','예상됩니다','부각되고','대두되고','다양한 분야','다양한 산업','눈부신 성과','획기적인 변화','혁신적인','점에서','측면에서','관점에서']
+# 비격식이지만 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',
+    'fundamentally transformed','has become increasingly','it should be noted',
+    'in the context of','paradigm shift','landscape of','methodologies',
+    'transformative impact','unprecedented','in various domains']
 HUMAN_MARKERS = {
-    'ㅋㅎㅠ': re.compile(r'([ㅋㅎㅠㅜㄷㄱ])\1{2,}'),
+    'ㅋㅎㅠ': re.compile(r'([ㅋㅎㅠㅜㄷㄱ])\1{1,}'),
     '이모티콘': re.compile(r'[;:]-?[)(DPp]|\^[_\-]?\^|ㅡㅡ|;;'),
-    '줄임': re.compile(r'ㄹㅇ|ㅇㅇ|ㄴㄴ|ㅇㅋ'),
+    '줄임': re.compile(r'ㄹㅇ|ㅇㅇ|ㄴㄴ|ㅇㅋ|ㄷㄷ|ㅂㅂ'),
     '느낌표': re.compile(r'[!?]{2,}'),
-    '비격식': re.compile(r'(거든|잖아|인데|인걸|같음|느낌|아님|대박|미쳤)'),
+    '비격식종결': re.compile(r'(거든|잖아|인데|인걸|같음|느낌|아님|대박|미쳤|헐|ㅋ$|ㅎ$|임$|음$|듯$)'),
+    '구어축약': re.compile(r'(걍|좀|막|완전|진짜|레알|존나|개|졸라|존맛|겁나)'),
+    '맞춤법오류': re.compile(r'됬|몇일|금새|할수있|것같[은다]|되가|되서|안됀|햇다'),
+    '말줄임표': re.compile(r'\.{3,}|…'),
 }
 FP = {
-    "GPT": {"m":['물론이죠','도움이 되셨기를','설명해 드리겠습니다','추가 질문','도움이 필요하시면'],"e":['습니다','드리겠습니다'],"lp":re.compile(r'^\d+\.\s|^[-•]\s',re.M)},
-    "Claude": {"m":['말씀하신','살펴보겠습니다','균형 잡힌','맥락에서','한 가지 주의할','뉘앙스'],"e":['네요','거예요'],"lp":re.compile(r'^\*\*.*\*\*|^#+\s',re.M)},
-    "Gemini": {"m":['다음과 같습니다','정리해 드리겠습니다','핵심 내용을','더 알고 싶으시면'],"e":['겠습니다','보세요'],"lp":re.compile(r'^\*\s|^-\s\*\*',re.M)},
-    "Perplexity": {"m":['검색 결과에 따르면','보도에 따르면','연구에 따르면','밝혔다','전했다'],"e":['밝혔다','나타났다'],"lp":re.compile(r'\[\d+\]',re.M)},
+    "GPT": {"m":['물론이죠','도움이 되셨기를','설명해 드리겠습니다','추가 질문','도움이 필요하시면',
+                 '요약하자면','간략히 정리하면','핵심은'],"e":['습니다','드리겠습니다'],"lp":re.compile(r'^\d+\.\s|^[-•]\s',re.M)},
+    "Claude": {"m":['말씀하신','살펴보겠습니다','균형 잡힌','맥락에서','한 가지 주의할','뉘앙스',
+                    '흥미로운 질문','복잡한 주제'],"e":['네요','거예요'],"lp":re.compile(r'^\*\*.*\*\*|^#+\s',re.M)},
+    "Gemini": {"m":['다음과 같습니다','정리해 드리겠습니다','핵심 내용을','더 알고 싶으시면',
+                   '알아보겠습니다'],"e":['겠습니다','보세요'],"lp":re.compile(r'^\*\s|^-\s\*\*',re.M)},
+    "Perplexity": {"m":['검색 결과에 따르면','보도에 따르면','연구에 따르면','밝혔다','전했다',
+                       '것으로 나타났다','것으로 조사됐다','것으로 집계됐다','발표했다'],"e":['밝혔다','나타났다','전했다'],"lp":re.compile(r'\[\d+\]',re.M)},
 }
 
 def score_sentence(sent):
-    """단일 문장 AI 점수 (0~100). 탭1·탭2 공유."""
+    """단일 문장 AI 점수 (0~100). 탭1·탭2 공유. v5.0 대폭 강화."""
     sc = 0; reasons = []
-    # 격식 종결어미
+    sl = sent.lower().strip()
+    sr = sent.rstrip('.!?。')
+
+    # ── 격식 종결어미 ──
     for e in AI_ENDINGS:
-        if sent.rstrip('.').endswith(e): sc += 25; reasons.append(f"격식어미(-{e})"); break
-    # 문두 접속사
+        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 sent.strip().startswith(c): sc += 20; reasons.append(f"AI접속사({c})"); break
-    # 상투적 표현
-    filler_found = 0
-    for f in AI_FILLER:
-        if f in sent: filler_found += 1
-    if filler_found >= 2: sc += 25; reasons.append(f"상투표현×{filler_found}")
-    elif filler_found == 1: sc += 15; reasons.append("상투표현×1")
-    # 모델 지문
+        if stripped.startswith(c):
+            sc += 18; reasons.append(f"AI접속사({c})"); break
+    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 += 10; reasons.append(f"{mn}지문({m})"); break
-    # 인간 마커 (감점)
+            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():
-        if p.search(sent): sc -= 30; reasons.append(f"인간마커({n})")
+        matches = p.findall(sent)
+        if matches:
+            if n in ('ㅋㅎㅠ','이모티콘','줄임'): sc -= 25; reasons.append(f"인간({n})")
+            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
-    burst = 90 if cv<0.25 else 70 if cv<0.35 else 50 if cv<0.50 else 30 if cv<0.65 else 15
+    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:
+        avg_d = sum(diffs)/len(diffs)
+        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)
-    ne = 0
-    if t > 0:
-        ent = -sum((c/t)*math.log2(c/t) for c in wf.values() if c>0)
-        mx = math.log2(len(wf)) if len(wf)>1 else 1
-        ne = ent/mx if mx>0 else 0
-    es = 75 if ne>0.92 else 55 if ne>0.85 else 30
     ttr = len(wf)/t if t>0 else 0
-    vs = 70 if ttr<0.45 else 50 if ttr<0.55 else 25
-    se = []
-    for s in sentences:
-        sw = split_words(s)
-        if len(sw)<3: continue
-        sf = Counter(sw); st = len(sw)
-        se.append(-sum((c/st)*math.log2(c/st) for c in sf.values() if c>0))
-    ps = 50
-    if len(se)>=2:
-        sa = sum(se)/len(se); scv = math.sqrt(sum((e-sa)**2 for e in se)/len(se))/(sa if sa else 1)
-        ps = 80 if scv<0.15 else 55 if scv<0.25 else 25
-    return {"score":int(burst*0.35+es*0.2+vs*0.2+ps*0.25),"cv":round(cv,3),"ttr":round(ttr,3)}
+    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:
+        wpc_avg = sum(wpc)/len(wpc)
+        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):
-    fc = sum(1 for s in sentences if any(s.rstrip('.').endswith(e) for e in AI_ENDINGS))
-    fr = fc/len(sentences) if sentences else 0
-    es = 80 if fr>0.8 else 60 if fr>0.6 else 40 if fr>0.4 else 20
-    cc = sum(1 for c in AI_CONNS if c in text); cd = cc/len(sentences) if sentences else 0
-    cs = 85 if cd>0.5 else 65 if cd>0.3 else 40 if cd>0.15 else 15
-    flc = sum(1 for f in AI_FILLER if f in text)
-    fs = 90 if flc>=5 else 70 if flc>=3 else 45 if flc>=1 else 10
-    hs = sum(len(p.findall(text)) for p in HUMAN_MARKERS.values())
-    hp = min(30, hs*10)
-    ps = 50
+    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())
-        nr = sum(pc.get(t,0) for t in ['NNG','NNP','NNB','NR','NP'])/tm if tm else 0
-        ps = 70 if nr>0.45 else 55 if nr>0.40 else 30
-    return {"score":max(5,int(es*0.25+cs*0.25+fs*0.25+ps*0.25)-hp),"formal":f"{fr:.0%}","conn":f"{cd:.2f}","filler":flc,"human":hs}
+        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)>=3:
+    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
-    ns = 75 if tr>0.15 else 55 if tr>0.08 else 25
-    fws = 50
-    if len(sentences)>=3:
-        fw = [split_words(s)[0] for s in sentences if split_words(s)]
-        if fw: r = Counter(fw).most_common(1)[0][1]/len(fw); fws = 70 if r>0.4 else 50 if r>0.25 else 20
-    # 접속사 문두 반복 (순수 AI 접속사만 — 자연어 접속사 제외)
+    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
-    css = 85 if crr>0.4 else 60 if crr>0.25 else 35 if crr>0.1 else 15
-    return {"score":int(ns*0.3+fws*0.3+css*0.4)}
+    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('.!?。')
+        for e in AI_ENDINGS + ['있다','했다','된다','한다','이다','는다']:
+            if sr.endswith(e): endings.append(e); break
+    ending_div = 50
+    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
+    elif concrete_total >= 3: abstract_score = 10
+    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()]
-    psc = 40
-    if len(paras)>1:
-        pl = [len(split_sentences(p)) for p in paras]; ap = sum(pl)/len(pl)
-        sp = math.sqrt(sum((l-ap)**2 for l in pl)/len(pl)) if len(pl)>1 else 0
-        cv = sp/ap if ap>0 else 0
-        psc = 75 if cv<0.2 and len(paras)>=3 else 50 if cv<0.4 else 25
-    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))
-    lsc = 85 if lt>=5 else 60 if lt>=2 else 15
-    return {"score":int(psc*0.4+lsc*0.6)}
+    para_score = 35
+    if len(paras) >= 2:
+        pl = [len(split_sentences(p)) for p in paras]
+        avg_p = sum(pl)/len(pl)
+        if avg_p > 0:
+            pcv = math.sqrt(sum((l-avg_p)**2 for l in pl)/len(pl))/avg_p
+            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()
     for mn, fp in FP.items():
         sc = sum(min(15,text.count(m)*5) for m in fp["m"] if text.count(m)>0)
         lm = fp["lp"].findall(text)
@@ -460,8 +664,29 @@ 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
-    return {"score":85 if mx>=50 else 65 if mx>=30 else 40 if mx>=15 else 15,"model_scores":ms}
+    # 복수 모델에서 점수가 나오면 더 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}}
 
 # ═══════════════════════════════════════════════
 # 품질
@@ -610,14 +835,34 @@ AI확률: 75%
 # ═══════════════════════════════════════════════
 # 종합 판정 (일관된 기준)
 # ═══════════════════════════════════════════════
-def compute_verdict(scores, llm_score=-1):
-    w={"통계":.25,"문체":.30,"반복성":.15,"구조":.15,"지문":.15}
+def compute_verdict(scores, llm_score=-1, sent_avg=-1):
+    w={"통계":.08,"문체":.30,"반복성":.12,"구조":.15,"지문":.35}
     ws=sum(scores[k]*w[k] for k in w)
+
+    # ★ 교차 신호 부스트 — 문체/지문 중심
+    style = scores["문체"]; fp = scores["지문"]; rep = scores["반복성"]; struct = scores["구조"]
+    if style >= 35 and fp >= 35: ws += 8  # 문체+지문 동시 → 강한 AI 신호
+    elif style >= 30 and fp >= 25: ws += 4
+    if style >= 30 and rep >= 25 and fp >= 20: ws += 4  # 3축 약신호
+    if fp >= 45: ws += 3  # 강한 지문 단독 부스트
+    if struct >= 50 and style >= 30: ws += 3  # 추상적+격식 문체
+
+    # ★ 문장 수준 부스트 (끌어내리지 않음)
+    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+=12
-    elif hi>=3: ws+=8
-    elif hi>=2: ws+=4
-    if sum(1 for v in scores.values() if v<25)>=3: ws-=8
+    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:
+        ws -= 5  # 격식이지만 AI 지문 없고 구체적 = 인간
+
+    lo=sum(1 for v in scores.values() if v<20)
+    if lo>=3: ws-=8
+    elif lo>=2: ws-=3
     if llm_score>=0: ws=ws*0.70+llm_score*0.30
     fs=max(0,min(100,int(ws)))
     if fs>=75: return fs,"AI 작성 확신","ai_high"
@@ -631,275 +876,14 @@ def quick_score(text):
     sc={"통계":analyze_statistics(text,sents,words)["score"],"문체":analyze_korean_style(text,sents,morphs)["score"],
         "반복성":analyze_repetition(text,sents,words)["score"],"구조":analyze_structure(text,sents)["score"],
         "지문":analyze_model_fingerprint(text,sents)["score"]}
-    fs,v,lv=compute_verdict(sc); return fs,v,lv,sc
+    # 문장 수준 평균 계산
+    sent_scores = [score_sentence(s)[0] for s in sents]
+    sent_avg = sum(sent_scores)/len(sent_scores) if sent_scores else -1
+    fs,v,lv=compute_verdict(sc, sent_avg=sent_avg); return fs,v,lv,sc
 
 # ═══════════════════════════════════════════════
-# ★ AI→인간 변환 (대폭 강화)
-# ═══════════════════════════════════════════════
-CONN_MAP = {'또한':['그리고','이 밖에도','게다가'],'따라서':['그래서','이런 이유로','그러니까'],
-    '이에 따라':['그래서','그러니까'],'한편':['반면에','반대로'],
-    '더불어':['함께','같이'],'결과적으로':['결국','끝내는'],
-    '궁극적으로':['결국에는','마지막에는'],'나아가':['더 나아가면','여기서 더'],
-    '이러한':['이런','이와 같은'],'특히':['그중에서도','무엇보다','특별히'],
-    '뿐만 아니라':['거기에다','그것뿐 아니라'],'이를 통해':['덕분에','이 덕에'],
-    '이에':['그래서','이걸로'],'아울러':['그리고','함께'],'그러므로':['그래서','그러니']}
-FILL_MAP = {
-    '중요한 역할을 하고':'큰 몫을 차지하고','중요한 역할을 하':'큰 몫을 차지하',
-    '중요한 의미를 가지':'큰 의미를 지니',
-    '긍정적인 영향을 미치고':'좋은 쪽으로 작용하고','긍정적인 영향':'좋은 쪽 작용',
-    '부정적인 영향을':'나쁜 쪽으로','영향을 미치':'작용을 하',
-    '눈부신 성과를 거두':'대단한 결과를 내','눈부신 성과':'대단한 결과',
-    '괄목할 만한':'눈에 띄는','획기적인 변화':'큰 전환점','혁신적인':'새로운',
-    '다양한 분야':'여러 분야','다양한 산업 분야':'여러 산업','다양한 산업':'여러 산업',
-    '다양한 창작':'여러 창작','다양한 측면':'여러 면',
-    '부각되고 있습니다':'두드러지고 있다','부각되고':'두드러지고',
-    '대두되고':'떠오르고','활용할 수 있게':'쓸 수 있게',
-    '활발히 진행되고 있습니다':'활발하게 이뤄지고 있다',
-    '것으로 예상됩니다':'것 같다','것으로 보입니다':'것 같다',
-    '것으로 판단됩니다':'것으로 보인다','것으로 분석됩니다':'것으로 보인다',
-    '것으로 보이':'것 같','것으로 나타':'것으로 드러나',
-    '할 수 있습니다':'할 수 있다','볼 수 있습니다':'볼 수 있다',
-    '주목할 만한':'눈여겨볼','주목할 만':'눈여겨볼 만',
-    '필요합니다':'필요하다','중요합니다':'중요하다',
-    '역할을 하고':'몫을 하고','역할을 하':'몫을 하',
-    '점에서':'면에서','측면에서':'부분에서','관점에서':'시각에서',
-}
-INLINE_CONN = {'이를 통해 ':'이걸로 ','이에 대한 ':'이 문제에 대한 ','따라서 ':'그래서 ',
-    '결과적으로 ':'결국 ','이러한 ':'이런 ','이에 ':'이걸로 ','나아가 ':'더 나아가면 '}
-END_RULES = [
-    ('활발히 진행되고 있습니다','활발하게 이뤄지고 있다'),
-    ('거두고 있습니다','거두고 있다'),('변화하고 있습니다','바뀌고 있다'),
-    ('있게 되었습니다','있게 됐다'),('하고 있습니다','하고 있다'),
-    ('되고 있습니다','되고 있다'),('할 수 있습니다','할 수 있다'),
-    ('미치고 있으며','주고 있고'),('가능해졌으며','가능해졌고'),
-    ('필요합니다','필요하다'),('중요합니다','중요하다'),
-    ('있습니다','있다'),('됩니다','된다'),('했습니다','했다'),
-    ('겠습니다','것이다'),('입니다','이다'),
-    ('가지며','가지고'),('이루는 것이','이루는 게'),
-]
-# 문장 재구성용 패턴
-RESTRUCTURE = [
-    (r'(\S+)은 (\S+)에서 (.+)', lambda m: f"{m.group(2)}에서 {m.group(1)}은 {m.group(3)}" if random.random()<0.3 else m.group()),
-    (r'(.+)하고 있다\.', lambda m: f"{m.group(1)}하는 중이다." if random.random()<0.3 else m.group()),
-]
-
-def rule_humanize(text):
-    r=text; ch=[]
-    # 1. 문두 접속사 (100% 교체 — 50%는 대체, 50%는 삭제)
-    for ac,alts in CONN_MAP.items():
-        pat=re.compile(r'(?:^|\n)(\s*)('+re.escape(ac)+r')(\s)',re.M)
-        for m in reversed(list(pat.finditer(r))):
-            if random.random()<0.6:
-                alt=random.choice(alts); r=r[:m.start(2)]+alt+r[m.end(2):]; ch.append(f"접속사 '{ac}'→'{alt}'")
-            else: r=r[:m.start(2)]+r[m.end(2):]; ch.append(f"접속사제거 '{ac}'")
-    # 2. 문장 내 접속사
-    for ai,hu in INLINE_CONN.items():
-        if ai in r: r=r.replace(ai,hu,1); ch.append(f"내부접속 '{ai.strip()}'")
-    # 3. 상투 (FILL_MAP — AI_FILLER 완전 무력화)
-    for ai in sorted(FILL_MAP.keys(), key=len, reverse=True):
-        hu = FILL_MAP[ai]
-        if ai in r: r=r.replace(ai,hu,1); ch.append(f"상투 '{ai}'")
-    # 4. 종결어미 전면 변환
-    for ai,hu in END_RULES:
-        cnt=r.count(ai)
-        if cnt>0: r=r.replace(ai,hu); ch.append(f"종결 '{ai}'→'{hu}' ×{cnt}")
-    # 5. 마크다운 제거
-    r=re.sub(r'^\d+\.\s+','',r,flags=re.M)
-    r=re.sub(r'^[-•*]\s+','',r,flags=re.M)
-    r=re.sub(r'\*\*([^*]+)\*\*',r'\1',r)
-    r=re.sub(r'^#+\s+','',r,flags=re.M)
-    # 6. 문장 재구성
-    sents = split_sentences(r)
-    rebuilt = []
-    for i, s in enumerate(sents):
-        ns = s
-        for pat, repl in RESTRUCTURE:
-            ns = re.sub(pat, repl, ns)
-        rebuilt.append(ns)
-    # 7. 문장 길이 변동 주입 (통계축 개선) — BUG3 FIX
-    if len(rebuilt) >= 4:
-        sl = [len(s) for s in rebuilt]
-        avg = sum(sl)/len(sl)
-        cv = math.sqrt(sum((l-avg)**2 for l in sl)/len(sl))/(avg if avg>0 else 1)
-        if cv < 0.35:  # CV가 낮으면 = 문장 길이가 너무 균일 = AI적
-            # 랜덤 위치에 짧은 문장 삽입
-            short_comments = [
-                "좀 놀랍다.","이게 핵심이다.","꽤 의미 있다.","변화가 크다.",
-                "쉽지 않은 문제다.","생각해볼 부분이다.","무시 못 할 흐름이다."
-            ]
-            # 2~3개 삽입 (중복 방지)
-            used = set()
-            for _ in range(min(3, len(rebuilt)//3)):
-                pos = random.randint(1, len(rebuilt)-1)
-                cmt = random.choice([c for c in short_comments if c not in used])
-                used.add(cmt)
-                rebuilt.insert(pos, cmt)
-            ch.append(f"짧은 문장 {len(used)}개 삽입 (CV 개선)")
-            # 가끔 긴 문장도 만들기 (짧은 2개 합치기)
-            if len(rebuilt) >= 6 and random.random() < 0.5:
-                idx = random.randint(0, len(rebuilt)-2)
-                if 15 < len(rebuilt[idx]) < 35 and 15 < len(rebuilt[idx+1]) < 35:
-                    merged = rebuilt[idx].rstrip('.') + ', ' + rebuilt[idx+1][0].lower() + rebuilt[idx+1][1:] if rebuilt[idx+1] else rebuilt[idx]
-                    rebuilt[idx] = merged
-                    rebuilt.pop(idx+1)
-                    ch.append("긴 문장 합병 (CV 개선)")
-    # 8. 문단 나누기 — 구조축 개선
-    if len(rebuilt) >= 6 and '\n\n' not in ' '.join(rebuilt):
-        mid = len(rebuilt)//2
-        rebuilt.insert(mid, '\n')
-        ch.append("문단 분리 삽입")
-    r = ' '.join(rebuilt)
-    r = r.replace(' \n ', '\n\n')
-    return r.strip(), ch
-
-def llm_humanize(text):
-    if not GROQ_KEY: return text, ["LLM: API키 없음"]
-    prompt = f"""당신은 AI 텍스트 탐지기를 우회하는 리라이터입니다. 아래 텍스트를 자연스러운 사람이 쓴 글로 완전히 재작성하세요.
-
-[필수 규칙]
-1. "-습니다/-합니다/-입니다" 종결어미 절대 사용 금지. 전부 "-다/-이다/-했다/-인 셈이다" 등 비격식체로
-2. "또한/따라서/나아가/이러한/이에/결과적으로" 절대 사용 금지
-3. "중요한 역할/긍정적인 영향/다양한 분야/획기적인" 전부 일상어로
-4. 문장 길이를 심하게 불규칙하게: 5~10자 짧은 문장과 50~80자 긴 문장을 반드시 섞어라
-5. 반드시 3~4개 개인적 감상/의견 삽입 ("솔직히", "사실", "근데 생각해보면", "내 생각엔")
-6. 원래 의미·정보는 100% 보존
-7. 마크다운/리스트 없이 완전한 산문으로
-8. 문장 순서를 일부 바꿔도 됨
-9. 피동 표현 줄이고 능동태 위주
-10. "~것으로 보인다/예상된다" 같은 회피 표현 → "~일 거다/~할 것 같다"
-
-[원문]
-{text[:2500]}
-
-[변환 결과만 출력 - 설명 없이]"""
-    resp, err = call_groq("qwen/qwen3-32b", prompt, max_tokens=2000, temperature=0.85)
-    if resp:
-        cleaned = re.sub(r'<think>.*?</think>', '', resp, flags=re.S).strip()
-        if len(cleaned) > 50: return cleaned, [f"LLM 리라이팅 ({len(cleaned)}자)"]
-    return text, [f"LLM 실패: {err}"]
-
-def run_humanizer(text, progress=gr.Progress()):
-    if not text or len(text.strip())<50: return "","","",""
-    text=text.strip()
-    progress(0.05,"원본 분석...")
-    b_score,b_verdict,_,b_axes=quick_score(text)
-    bq=analyze_quality(text,split_sentences(text),split_words(text),get_morphemes(text))
-    if b_score<25: return text,"이미 인간적인 텍스트 (AI점수 25미만).","",""
-
-    # ═══ Adversarial Humanizer v2.1: 반복 자기대전 (열화 방지) ═══
-    MAX_ROUNDS = 3
-    TARGET_SCORE = 25
-    best_text = text
-    best_score = b_score
-    best_method = "원본"
-    all_ch = []
-    round_log = []
-    original_text = text  # LLM은 항상 원본 기반으로 호출 (열화 방지)
-
-    for rnd in range(1, MAX_ROUNDS + 1):
-        if best_score <= TARGET_SCORE:
-            round_log.append(f"🏆 Round {rnd} 스킵 — 이미 목표 달성 (점수 {best_score})")
-            break
-
-        pct = 0.05 + (rnd / MAX_ROUNDS) * 0.65
-        progress(pct, f"⚔️ Round {rnd}/{MAX_ROUNDS} — 현재 점수 {best_score}...")
-
-        candidates = []
-
-        # 규칙 변환: 현재 best에 적용 (Round 1은 원본, Round 2+는 best)
-        rule_text, rule_ch = rule_humanize(best_text)
-        r_score, _, _, _ = quick_score(rule_text)
-        candidates.append((rule_text, r_score, f"R{rnd}-규칙", rule_ch))
-
-        if GROQ_KEY:
-            # LLM: 항상 원본 텍스트 기반 (Round 2+에서 열화된 텍스트 재LLM 방지)
-            llm_text, llm_ch = llm_humanize(original_text)
-            l_score, _, _, _ = quick_score(llm_text)
-            candidates.append((llm_text, l_score, f"R{rnd}-LLM", llm_ch))
-
-            # LLM → 규칙 하이브리드
-            llm_rule, lr_ch = rule_humanize(llm_text)
-            lr_score, _, _, _ = quick_score(llm_rule)
-            candidates.append((llm_rule, lr_score, f"R{rnd}-LLM+규칙", llm_ch + lr_ch))
-
-        # 최적 선택
-        winner = min(candidates, key=lambda x: x[1])
-        w_text, w_score, w_method, w_changes = winner
-        score_strs = ', '.join(f"{c[2]}:{c[1]}" for c in candidates)
-        round_log.append(f"Round {rnd}: {score_strs} → {w_method} 채택 (Δ{best_score - w_score})")
-
-        # 악화 방지: 이전보다 2점 이상 개선된 경우만 채택
-        if w_score < best_score - 1:
-            best_text, best_score, best_method = w_text, w_score, w_method
-            all_ch.extend(w_changes)
-        else:
-            round_log.append(f"  ↳ 유의미한 개선 없음 (Δ{best_score - w_score}), 이전 결과 유지")
-            break
-
-    final_text = best_text
-    method = best_method
-
-    progress(0.75, "최종 검증...")
-    a_score, a_verdict, a_level, a_axes = quick_score(final_text)
-    aq = analyze_quality(final_text, split_sentences(final_text), split_words(final_text), get_morphemes(final_text))
-
-    progress(0.85, "LLM 교차검증...")
-    llm_v = llm_cross_check(final_text)
-    if llm_v["score"] >= 0:
-        a_score_f, a_verdict_f, _ = compute_verdict(a_axes, llm_v["score"])
-    else:
-        a_score_f, a_verdict_f = a_score, a_verdict
-
-    delta = b_score - a_score_f
-    passed = a_score_f < 30
-    change_log = f"⚔️ Adversarial v2 ({len(round_log)}라운드)\n"
-    change_log += '\n'.join(f"  {r}" for r in round_log)
-    change_log += f"\n\n총 {len(all_ch)}건 변환:\n" + '\n'.join(f"  • {c}" for c in all_ch[:20])
-    if len(all_ch) > 20: change_log += f"\n  ... +{len(all_ch)-20}건"
-
-    # 비교 HTML
-    def cbar(lbl,bv,av):
-        bc="#FF4444" if bv>=50 else "#DDAA00" if bv>=35 else "#22AA44"
-        ac="#FF4444" if av>=50 else "#DDAA00" if av>=35 else "#22AA44"
-        d=bv-av; ds=f"<span style='color:#22AA44;font-weight:700;'>↓{d}</span>" if d>0 else f"<span style='color:#FF4444;'>↑{abs(d)}</span>" if d<0 else "="
-        return f"<div style='margin:3px 0;display:grid;grid-template-columns:70px 1fr 20px 1fr 36px;align-items:center;gap:3px;font-size:11px;'><span style='font-weight:600;'>{lbl}</span><div style='background:#E8E8E8;border-radius:3px;height:6px;'><div style='background:{bc};height:100%;width:{bv}%;border-radius:3px;'></div></div><span style='text-align:center;color:#CCC;'>→</span><div style='background:#E8E8E8;border-radius:3px;height:6px;'><div style='background:{ac};height:100%;width:{av}%;border-radius:3px;'></div></div><span style='text-align:right;'>{ds}</span></div>"
-
-    bfg="#FF4444" if b_score>=60 else "#FF8800" if b_score>=45 else "#DDAA00" if b_score>=30 else "#22AA44"
-    bbg="#FFE0E0" if b_score>=60 else "#FFF0DD" if b_score>=45 else "#FFFBE0" if b_score>=30 else "#E0FFE8"
-    afg="#FF4444" if a_score_f>=60 else "#FF8800" if a_score_f>=45 else "#DDAA00" if a_score_f>=30 else "#22AA44"
-    abg="#FFE0E0" if a_score_f>=60 else "#FFF0DD" if a_score_f>=45 else "#FFFBE0" if a_score_f>=30 else "#E0FFE8"
-    dc="#22AA44" if delta>0 else "#FF4444"
-    badge='<span style="background:#22AA44;color:white;padding:4px 14px;border-radius:20px;font-weight:700;">✅ 검증 통과</span>' if passed else '<span style="background:#FF8800;color:white;padding:4px 14px;border-radius:20px;font-weight:700;">⚠️ 추가 수정 권장 (AI점수 {})'.format(a_score_f)+'</span>'
-
-    html=f"""<div style="font-family:'Pretendard',sans-serif;max-width:700px;margin:0 auto;">
-        <div style="text-align:center;margin-bottom:12px;">{badge}</div>
-        <div style="display:grid;grid-template-columns:1fr 50px 1fr;gap:6px;margin-bottom:12px;">
-            <div style="background:{bbg};border:2px solid {bfg};border-radius:12px;padding:14px;text-align:center;">
-                <div style="font-size:10px;color:#888;">BEFORE</div>
-                <div style="font-size:32px;font-weight:900;color:{bfg};">{b_score}</div>
-                <div style="font-size:10px;color:{bfg};">{b_verdict}</div>
-            </div>
-            <div style="display:flex;align-items:center;justify-content:center;">
-                <div style="font-size:22px;color:{dc};font-weight:900;">{"↓" if delta>0 else "↑"}{abs(delta)}</div>
-            </div>
-            <div style="background:{abg};border:2px solid {afg};border-radius:12px;padding:14px;text-align:center;">
-                <div style="font-size:10px;color:#888;">AFTER ({method})</div>
-                <div style="font-size:32px;font-weight:900;color:{afg};">{a_score_f}</div>
-                <div style="font-size:10px;color:{afg};">{a_verdict_f}</div>
-            </div>
-        </div>
-        <div style="background:#FAFAFA;border-radius:8px;padding:10px;margin-bottom:8px;">
-            <div style="font-size:11px;font-weight:700;margin-bottom:4px;">📊 축별 비교</div>
-            {cbar("통계",b_axes["통계"],a_axes["통계"])}{cbar("문체",b_axes["문체"],a_axes["문체"])}{cbar("반복",b_axes["반복성"],a_axes["반복성"])}{cbar("구조",b_axes["구조"],a_axes["구조"])}{cbar("지문",b_axes["지문"],a_axes["지문"])}
-        </div>
-        <div style="background:#F0F4FF;border-radius:6px;padding:6px 10px;font-size:11px;">
-            <b>품질:</b> {bq['grade']}({bq['score']}) → {aq['grade']}({aq['score']})
-        </div></div>"""
-    return final_text, change_log, html, ""
-
 # ═══════════════════════════════════════════════
 # ★ 표절 검사 (Brave Search 병렬 + KCI/RISS/ARXIV + Gemini)
-# ═══════════════════════════════════════════════
 def brave_search(query, count=5):
     """Brave Search API — 단일 쿼리"""
     if not BRAVE_KEY: return []
@@ -1457,15 +1441,16 @@ def run_detection(text, progress=gr.Progress()):
     progress(0.62); qr=analyze_quality(text,sents,words,morphs)
     progress(0.75); lr=llm_cross_check(text)
     sc={"통계":s1["score"],"문체":s2["score"],"반복성":s3["score"],"구조":s4["score"],"지문":s5["score"]}
-    fs,verdict,level=compute_verdict(sc,lr["score"])
+    # 문장별 점수 (탭2와 동일 기준)
+    sent_scores = [score_sentence(s)[0] for s in sents]
+    sent_avg = sum(sent_scores)/len(sent_scores) if sent_scores else -1
+    fs,verdict,level=compute_verdict(sc,lr["score"],sent_avg=sent_avg)
     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","?"))
     ms=s5.get("model_scores",{}); tm=max(ms,key=ms.get) if ms else "N/A"; tms=ms.get(tm,0)
     mt=f"{tm} ({tms}점)" if tms>=15 else "특정 불가"
 
-    # 문장별 점수 (탭2와 동일 기준)
-    sent_scores = [score_sentence(s)[0] for s in sents]
     ai_sents = sum(1 for s in sent_scores if s >= 40)
     human_sents = sum(1 for s in sent_scores if s < 20)
 
@@ -1563,28 +1548,43 @@ def run_highlight(text):
     sents=split_sentences(text)
     hl=[]
     for s in sents:
-        sc, reasons = score_sentence(s)  # ← 동일 함수 사용
-        bg=f"rgba(255,68,68,{sc/150})" if sc>=50 else f"rgba(255,170,0,{sc/150})" if sc>=25 else f"rgba(34,170,68,{max(0.05,(100-sc)/300)})"
-        tt = ' | '.join(reasons) if reasons else '인간적 표현'
-        level = "AI" if sc >= 50 else "의심" if sc >= 25 else "인간"
-        hl.append(f'<span style="background:{bg};padding:2px 4px;border-radius:3px;display:inline;line-height:2;" title="[{level}] {tt} ({sc}점)">{s}</span>')
+        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}")
+            elif '접속사' in r: detail_parts.append(f"🔗 {r}")
+            elif '상투' in r: detail_parts.append(f"📋 {r}")
+            elif '지문' in r: detail_parts.append(f"🔍 {r}")
+            elif '인간' in r or '구어' in r or '맞춤법' in r: detail_parts.append(f"✅ {r}")
+            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_cnt = sum(1 for s in total_scores if s >= 50)
+    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:12px;align-items:center;font-size:11px;margin-bottom:6px;'>
-                <span style='background:rgba(255,68,68,0.4);padding:2px 8px;border-radius:3px;'>🔴 AI ({ai_cnt}문장)</span>
-                <span style='background:rgba(255,170,0,0.3);padding:2px 8px;border-radius:3px;'>🟠 의심</span>
-                <span style='background:rgba(34,170,68,0.15);padding:2px 8px;border-radius:3px;'>🟢 인간 ({human_cnt}문장)</span>
-                <span style='color:#888;'>평균 {avg_sc:.0f}점 | 마우스 오버→근거</span>
+            <div style='display:flex;gap:8px;align-items:center;font-size:11px;margin-bottom:6px;flex-wrap:wrap;'>
+                <span style='background:rgba(220,38,38,0.35);padding:2px 8px;border-radius:3px;'>🔴 AI확신 {ai_high}</span>
+                <span style='background:rgba(249,115,22,0.30);padding:2px 8px;border-radius:3px;'>🟠 AI의심 {ai_mid}</span>
+                <span style='background:rgba(234,179,8,0.25);padding:2px 8px;border-radius:3px;'>🟡 주의</span>
+                <span style='background:rgba(132,204,22,0.15);padding:2px 8px;border-radius:3px;'>🟢 인간 {human_cnt}</span>
+                <span style='color:#888;'>평균 {avg_sc:.0f}점 | 마우스 오버→상세 근거</span>
             </div>
-            <div style='font-size:10px;color:#888;'>💡 점수 기준: 격식어미(25점) + AI접속사(20점) + 상투표현(15~25점) + 모델지문(10점) − 인간마커(30점)</div>
+            <div style='font-size:10px;color:#888;'>💡 격식어미(22) + AI접속사(18) + 상투표현(10~25) + 양보패턴(10) + 모델지문(8) + 복합보너스(8) − 인간마커(~25)</div>
         </div>
-        <div style='line-height:2.2;font-size:14px;'>{'  '.join(hl)}</div>
+        <div style='line-height:2.4;font-size:14px;'>{'  '.join(hl)}</div>
     </div>"""
 
 # ═══════════════════════════════════════════════
@@ -1637,7 +1637,9 @@ def run_document_analysis(file, progress=gr.Progress()):
     progress(0.30, "LLM 교차검증...")
     llm_result = llm_cross_check(full_text[:3000])
     if llm_result["score"] >= 0:
-        total_score, total_verdict, total_level = compute_verdict(total_axes, llm_result["score"])
+        _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)
 
     # 섹션별 분석
     progress(0.45, f"{len(sections)}개 섹션 분석...")
@@ -1884,7 +1886,7 @@ def extract_file_text_api(file):
 
 
 with gr.Blocks(title="AI 글 판별기 v4.0") as demo:
-    gr.Markdown("# 🔎 AI 글 판별기 v4.0\n**5축 AI 탐지 · 품질 측정 · LLM 교차검증 · Adversarial Humanizer v2 · 표절 검사 · 파일 업로드**")
+    gr.Markdown("# 🔎 AI 글 판별기 v5.0\n**5축 AI 탐지 · 품질 측정 · LLM 교차검증 · 표절 검사 · 파일 업로드**")
     with gr.Tab("🔍 분석"):
         gr.Markdown("텍스트가 AI에 의해 작성되었는지 5개 축으로 분석합니다. 0~100점 (높을수록 AI 가능성 높음)")
         inp=gr.Textbox(label="분석할 텍스트",placeholder="최소 50자 이상...",lines=10)
@@ -1898,15 +1900,6 @@ with gr.Blocks(title="AI 글 판별기 v4.0") as demo:
         gr.Markdown("문장별로 AI 확률을 색상 표시합니다. **탭1과 동일한 기준**으로 판정합니다. 마우스 오버 시 근거 확인.")
         ih=gr.Textbox(label="텍스트",lines=8); bh=gr.Button("🎨 하이라이트 분석",variant="primary"); hr=gr.HTML()
         bh.click(run_highlight,[ih],[hr],api_name="run_highlight")
-    with gr.Tab("🔄 AI→인간 변환"):
-        gr.Markdown("**Adversarial Humanizer v2** — 탐지기와 변환기의 자기대전 루프. 최대 3라운드 반복하며 AI 점수를 최저로 끌어내립니다.")
-        ihm=gr.Textbox(label="원본 (AI 텍스트)",lines=8)
-        with gr.Row():
-            bhm=gr.Button("🔄 자동 변환 + 검증",variant="primary",size="lg"); bhs=gr.Button("📝 AI 예시",size="sm")
-        ohm=gr.Textbox(label="✅ 변환 결과",lines=8)
-        och=gr.Textbox(label="📋 변환 내역",lines=5,elem_classes=["mono"])
-        ocp=gr.HTML(); oex=gr.Textbox(visible=False)
-        bhm.click(run_humanizer,[ihm],[ohm,och,ocp,oex],api_name="run_humanizer"); bhs.click(lambda:SAMPLE_AI,outputs=[ihm])
     with gr.Tab("🔍 표절 검사"):
         gr.Markdown("**Brave Search 병렬(최대20) + KCI · RISS · arXiv + Gemini Google Search** 기반 표절 검사. CopyKiller 스타일 보고서.")
         inp_plag=gr.Textbox(label="검사할 텍스트",placeholder="표절 검사할 텍스트 (최소 50자)...",lines=10)
@@ -1918,7 +1911,7 @@ with gr.Blocks(title="AI 글 판별기 v4.0") as demo:
         btn_ps.click(lambda:SAMPLE_AI,outputs=[inp_plag])
     with gr.Tab("📖 설명"):
         gr.Markdown("""
-### 아키텍처 v4.0
+### 아키텍처 v5.0
 - **탐지 5축:** 통계(25%)·문체(30%)·반복(15%)·구조(15%)·지문(15%)
 - **품질 6항목:** 가독성·어휘·논리·정확성·표현·정보밀도
 - **LLM 교차검증:** GPT-OSS-120B·Qwen3-32B·Kimi-K2 (GROQ)
@@ -1927,26 +1920,14 @@ with gr.Blocks(title="AI 글 판별기 v4.0") as demo:
 - `score_sentence()` 통합 함수로 동일 기준 판정
 - 격식어미(25점) + AI접속사(20점) + 상투표현(15~25점) + 모델지문(10점) − 인간마커(30점)
 
-### AI→인간 변환 (Adversarial v2)
-1. **자기대전 루프**: 변환→탐지→재변환 최대 3라운드
-2. **라운드별**: 규칙 / LLM / LLM+규칙 3후보 경쟁
-3. **자동 종료**: 목표 점수(25점) 이하 달성 시 종료
-4. **피드백**: 이전 라운드 최적 결과를 다음 라운드 입력으로
-
 ### 표절 검사
 - **Brave Search**: 병렬 20개 동시 웹검색
 - **학술 DB**: KCI(한국학술지인용색인), RISS(학술연구정보), arXiv
 - **Gemini**: Google Search Grounding
 - **보고서**: CopyKiller 스타일 — 유사도%, 출처표, 문장별 하이라이트
 
-### 📄 문서 분석 (NEW)
-- **지원 형식**: PDF · DOCX · HWP · HWPX · TXT · MD
-- **섹션별 히트맵**: 페이지/문단별 AI 확률 색상 시각화
-- **문장별 하이라이트**: 각 문장 AI 확률 score_sentence() 기반
-- **PDF 보고서**: 종합결과 + 5축 분석 + 섹션별 상세 다운로드
-
 ### 환경변수
-- `GROQ_API_KEY` — LLM 교차검증 + AI→인간 리라이팅
+- `GROQ_API_KEY` — LLM 교차검증
 - `GEMINI_API_KEY` — 표절 검사 (Google Search Grounding)
 - `BRAVE_API_KEY` — 표절 검사 (Brave Search 병렬)
         """)