diff --git a/dashboard-api/index.html b/dashboard-api/index.html
index 960f021..054086a 100644
--- a/dashboard-api/index.html
+++ b/dashboard-api/index.html
@@ -7,7 +7,7 @@
 <style>
 @import url('https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@300;400;500;700;800;900&family=JetBrains+Mono:wght@400;600;700&display=swap');
 *{box-sizing:border-box;margin:0;padding:0}
-body{background:#0D1117;color:#E0E0E0;font-family:'Noto Sans KR',sans-serif;padding:0 24px 40px}
+body{background:#0D1117;color:#E0E0E0;font-family:'Noto Sans KR',sans-serif;padding:0}
 ::-webkit-scrollbar{width:6px}::-webkit-scrollbar-thumb{background:rgba(255,255,255,0.1);border-radius:3px}
 .wrap{max-width:1400px;margin:0 auto}
 .header{display:flex;justify-content:space-between;align-items:center;padding:20px 0;border-bottom:1px solid rgba(255,255,255,0.06);margin-bottom:24px}
@@ -15,9 +15,26 @@ body{background:#0D1117;color:#E0E0E0;font-family:'Noto Sans KR',sans-serif;padd
 .header .sub{font-size:12px;color:#546E7A;margin-top:4px}
 .header .time{font-size:13px;color:#607D8B;font-family:'JetBrains Mono',monospace}
 .btn{background:rgba(0,230,118,0.1);border:1px solid rgba(0,230,118,0.2);border-radius:8px;padding:8px 16px;color:#00E676;font-size:12px;cursor:pointer;font-weight:600}
-.tabs{display:flex;gap:4px;margin-bottom:24px}
-.tab{background:transparent;border:1px solid transparent;border-radius:8px;padding:8px 16px;color:#607D8B;font-size:13px;font-weight:500;cursor:pointer}
+.sidebar{position:fixed;left:0;top:0;bottom:0;width:212px;background:#0A0E14;border-right:1px solid rgba(255,255,255,0.06);padding:18px 12px;overflow-y:auto;z-index:200;transition:transform .25s ease}
+.brand{font-size:16px;font-weight:800;letter-spacing:-0.5px;padding:4px 10px 16px;display:flex;align-items:center;gap:7px;color:#E0E0E0}
+.brand span{color:#00E676}
+.tabs{display:flex;flex-direction:column;gap:2px;margin:0}
+.tab{display:flex;align-items:center;gap:8px;width:100%;text-align:left;background:transparent;border:1px solid transparent;border-radius:8px;padding:10px 12px;color:#90A4AE;font-size:13px;font-weight:500;cursor:pointer;font-family:inherit;transition:background .15s}
+.tab:hover{background:rgba(255,255,255,0.04);color:#CFD8DC}
 .tab.active{background:rgba(0,230,118,0.1);border-color:rgba(0,230,118,0.2);color:#00E676;font-weight:700}
+.main{margin-left:212px;padding:0 24px 40px;min-height:100vh}
+.hamburger{display:none;background:rgba(255,255,255,0.05);border:1px solid rgba(255,255,255,0.1);border-radius:8px;width:40px;height:40px;color:#CFD8DC;font-size:18px;cursor:pointer;flex-shrink:0;align-items:center;justify-content:center}
+.sidebar-overlay{display:none;position:fixed;inset:0;background:rgba(0,0,0,0.55);z-index:150}
+@media(max-width:860px){
+  .sidebar{transform:translateX(-100%);width:248px;box-shadow:6px 0 28px rgba(0,0,0,0.55)}
+  .sidebar.open{transform:translateX(0)}
+  .main{margin-left:0;padding:0 14px 40px}
+  .hamburger{display:flex}
+  .sidebar-overlay.show{display:block}
+  .header{flex-wrap:wrap}
+  .header h1{font-size:17px}
+  .header .sub{display:none}
+}
 .cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin-bottom:24px}
 .card{background:rgba(255,255,255,0.03);border:1px solid rgba(255,255,255,0.06);border-radius:16px;padding:24px 20px}
 .card .label{font-size:13px;color:#90A4AE;letter-spacing:1px;margin-bottom:8px}
@@ -25,6 +42,7 @@ body{background:#0D1117;color:#E0E0E0;font-family:'Noto Sans KR',sans-serif;padd
 .card .sub{font-size:12px;color:#607D8B;margin-top:8px}
 .grid2{display:grid;grid-template-columns:1fr 1fr;gap:16px}
 @media(max-width:900px){.grid2{grid-template-columns:1fr}}
+@media(max-width:680px){.usbrief-grid{grid-template-columns:1fr !important}}
 .panel{background:rgba(255,255,255,0.02);border:1px solid rgba(255,255,255,0.05);border-radius:16px;padding:20px;max-height:600px;overflow:auto}
 .panel h3{font-size:14px;font-weight:700;color:#90A4AE;margin-bottom:16px}
 .rank-item{display:flex;align-items:center;gap:12px;padding:10px 0;border-bottom:1px solid rgba(255,255,255,0.03)}
@@ -108,7 +126,7 @@ tr[data-stock]:hover{background:rgba(0,230,118,0.06) !important}
 body.auth-required .wrap, body.auth-required #chat-btn, body.auth-required #chat-panel { display:none !important; }
 body:not(.auth-required) #login-screen { display:none !important; }
 
-#login-screen{position:fixed;inset:0;background:#0E141A;display:flex;align-items:center;justify-content:center;padding:20px;z-index:100;overflow-y:auto}
+#login-screen{position:fixed;inset:0;background:#0E141A;display:flex;align-items:center;justify-content:center;padding:20px;z-index:300;overflow-y:auto}
 .login-card{background:#141B22;border:1px solid rgba(0,230,118,0.18);border-radius:20px;padding:40px;width:420px;max-width:100%;box-shadow:0 12px 60px rgba(0,0,0,0.6)}
 .login-logo{font-size:24px;font-weight:800;color:#E0E0E0;margin-bottom:6px;letter-spacing:0.5px}
 .login-logo span{color:#00E676}
@@ -174,8 +192,33 @@ body:not(.auth-required) #login-screen { display:none !important; }
   </div>
 </div>
 
+<aside class="sidebar" id="sidebar">
+  <div class="brand"><span>◆</span> Trading AI</div>
+  <div class="tabs">
+    <button class="tab active" onclick="showTab('overview',this)">📊 종합</button>
+    <button class="tab" onclick="showTab('performance',this)">🎯 추천성과</button>
+    <button class="tab" onclick="showTab('signals',this)">💰 매매시그널</button>
+    <button class="tab" onclick="showTab('surge',this)">🚀 거래량급증</button>
+    <button class="tab" onclick="showTab('hot',this)">🔥 지금뜨는</button>
+    <button class="tab" onclick="showTab('portfolio',this)">💼 포트폴리오</button>
+    <button class="tab" onclick="showTab('mystock',this)">📂 내 종목 분석</button>
+    <button class="tab" onclick="showTab('recommend',this)">🏆 추천종목</button>
+    <button class="tab" onclick="showTab('news',this)">📰 뉴스피드</button>
+    <button class="tab" onclick="showTab('supplydemand',this)">💹 수급</button>
+    <button class="tab" onclick="showTab('alerts',this)">🚨 알림</button>
+    <button class="tab" onclick="showTab('formulas',this)">🧮 10공식</button>
+    <button class="tab" onclick="showTab('backtest',this)">📈 백테스트</button>
+    <button class="tab" onclick="showTab('usmarket',this)">🌎 미증시</button>
+    <button class="tab" onclick="showTab('macro',this)">🌐 매크로·섹터</button>
+    <button class="tab" onclick="showTab('glossary',this)">📖 용어설명</button>
+  </div>
+</aside>
+<div class="sidebar-overlay" id="sbOverlay" onclick="toggleSidebar(false)"></div>
+
+<div class="main">
 <div class="wrap">
   <div class="header">
+    <button class="hamburger" onclick="toggleSidebar()">☰</button>
     <div><h1><span>◆</span> Trading AI Dashboard</h1><div class="sub">뉴스 + DART 공시 기반 종목 분석 시스템</div></div>
     <div style="display:flex;align-items:center;gap:16px">
       <div class="time" id="clock"></div>
@@ -190,26 +233,11 @@ body:not(.auth-required) #login-screen { display:none !important; }
   <button onclick="doSearch()" style="background:rgba(0,230,118,0.1);border:1px solid rgba(0,230,118,0.2);border-radius:8px;padding:10px 20px;color:#00E676;font-size:13px;cursor:pointer;font-weight:600;white-space:nowrap">🔍 검색</button>
 </div>
 <div id="searchResults" style="display:none;margin-bottom:24px"></div>
-  <div class="tabs">
-    <button class="tab active" onclick="showTab('overview',this)">📊 종합</button>
-    <button class="tab" onclick="showTab('performance',this)">🎯 추천성과</button>
-    <button class="tab" onclick="showTab('signals',this)">💰 매매시그널</button>
-    <button class="tab" onclick="showTab('surge',this)">🚀 거래량급증</button>
-    <button class="tab" onclick="showTab('portfolio',this)">💼 포트폴리오</button>
-    <button class="tab" onclick="showTab('mystock',this)">📂 내 종목 분석</button>
-    <button class="tab" onclick="showTab('recommend',this)">🏆 추천종목</button>
-    <button class="tab" onclick="showTab('news',this)">📰 뉴스피드</button>
-    <button class="tab" onclick="showTab('supplydemand',this)">💹 수급</button>
-    <button class="tab" onclick="showTab('alerts',this)">🚨 알림</button>
-    <button class="tab" onclick="showTab('formulas',this)">🧮 10공식</button>
-    <button class="tab" onclick="showTab('backtest',this)">📈 백테스트</button>
-    <button class="tab" onclick="showTab('usmarket',this)">🌎 미증시</button>
-    <button class="tab" onclick="showTab('macro',this)">🌐 매크로·섹터</button>
-  </div>
   <div id="overview"></div>
   <div id="performance" style="display:none"></div>
   <div id="signals" style="display:none"></div>
   <div id="surge" style="display:none"></div>
+  <div id="hot" style="display:none"></div>
   <div id="portfolio" style="display:none"></div>
   <div id="mystock" style="display:none"></div>
   <div id="recommend" style="display:none"></div>
@@ -220,8 +248,10 @@ body:not(.auth-required) #login-screen { display:none !important; }
   <div id="backtest" style="display:none"></div>
   <div id="usmarket" style="display:none"></div>
   <div id="macro" style="display:none"></div>
+  <div id="glossary" style="display:none"></div>
   <div class="footer">Trading AI System • 뉴스/공시 기반 자동 분석 • 투자 판단의 참고 자료로만 활용하세요</div>
 </div>
+</div>
 <script>
 const API = window.location.origin + '/api';
 const SCOL = {호재:'#00E676',악재:'#FF5252',중립:'#78909C'};
@@ -231,20 +261,117 @@ const RCOL = {강력매수:'#00E676',매수관심:'#69F0AE',관망:'#78909C',매
 function ftime(ts){if(!ts)return'-';const d=new Date(ts),m=Math.floor((Date.now()-d)/60000);if(m<60)return m+'분 전';if(m<1440)return Math.floor(m/60)+'시간 전';return d.toLocaleDateString('ko-KR',{month:'short',day:'numeric'})}
 function esc(s){const d=document.createElement('div');d.textContent=s;return d.innerHTML}
 
+function toggleSidebar(force){
+  const sb=document.getElementById('sidebar'), ov=document.getElementById('sbOverlay');
+  if(!sb)return;
+  const open = force===undefined ? !sb.classList.contains('open') : !!force;
+  sb.classList.toggle('open',open);
+  if(ov)ov.classList.toggle('show',open);
+}
+
 function showTab(id,el){
-  ['overview','performance','signals','surge','portfolio','mystock','recommend','news','supplydemand','alerts','formulas','backtest','usmarket','macro'].forEach(t=>{
+  ['overview','performance','signals','surge','hot','portfolio','mystock','recommend','news','supplydemand','alerts','formulas','backtest','usmarket','macro','glossary'].forEach(t=>{
     document.getElementById(t).style.display=t===id?'block':'none'});
   document.querySelectorAll('.tab').forEach(t=>t.classList.remove('active'));
   if(el)el.classList.add('active');
+  toggleSidebar(false);
   if(id==='mystock'){ if(isLoggedIn()) loadPortfolio().then(()=>renderMyStock()); else renderMyStock(); }
   if(id==='portfolio') renderPortfolio();
   if(id==='performance') renderPerformance();
   if(id==='supplydemand') renderSupplyDemand();
   if(id==='surge') renderVolumeSurge();
+  if(id==='hot') renderHot();
   if(id==='formulas') renderFormulas();
   if(id==='backtest') renderBacktest();
   if(id==='usmarket') renderUsMarket();
   if(id==='macro') renderMacro();
+  if(id==='glossary') renderGlossary();
+}
+
+// ── 용어 설명 ────────────────────────────────────────────────
+const GLOSSARY=[
+ {t:'📊 차트 보는 법',items:[
+   ['캔들(봉)','하루 주가 움직임을 막대 하나로 표시. 끝가가 시작가보다 <b>높으면 빨강(양봉=올랐다)</b>, <b>낮으면 파랑(음봉=내렸다)</b>. 위·아래로 삐져나온 가는 선은 그날의 최고가·최저가.'],
+   ['거래량','그날 사고판 주식 수. 많을수록 시장 관심이 크다는 뜻. 거래량 없이 슬금슬금 오르는 상승은 힘이 약하다.'],
+   ['시가/종가/고가/저가','시가=장 시작 가격, 종가=장 끝 가격, 고가=그날 최고가, 저가=그날 최저가.'],
+ ]},
+ {t:'📈 이동평균선 (MA = Moving Average)',items:[
+   ['MA5','최근 <b>5일</b> 종가의 평균선. 약 1주일치 단기 흐름.'],
+   ['MA20','최근 <b>20일</b> 평균선. 약 한 달 흐름이라 "생명선"이라 부른다. 주가가 이 위면 단기 분위기 양호.'],
+   ['MA60','최근 <b>60일</b> 평균선. 약 3개월, 중기 추세.'],
+   ['MA120','최근 <b>120일</b> 평균선. 약 6개월, 장기 추세라 "경기선"이라 부른다.'],
+   ['정배열 / 역배열','MA5>MA20>MA60 순으로 짧은 선이 위에 있으면 <b>정배열=상승 추세</b>. 거꾸로면 역배열=하락 추세.'],
+   ['골든크로스 / 데드크로스','짧은 선이 긴 선을 아래→위로 뚫으면 <b>골든크로스(매수 신호)</b>, 위→아래로 뚫으면 데드크로스(매도 신호).'],
+ ]},
+ {t:'🎯 기술적 지표 (매매 타이밍)',items:[
+   ['RSI','0~100 숫자. <b>70 이상이면 과열</b>(너무 많이 사서 비쌈), <b>30 이하면 과매도</b>(너무 많이 팔려 쌈). 되돌림 가능성을 본다.'],
+   ['MACD','단기·장기 이동평균의 차이로 추세 전환을 잡는 지표. 0선 위로 올라오면 상승 힘이 붙는 것.'],
+   ['볼린저밴드','주가가 보통 움직이는 범위를 상단·중간·하단 띠로 표시. 상단에 닿으면 단기 비쌈, 하단이면 쌈.'],
+   ['스토캐스틱','RSI처럼 과열/과매도를 보는 지표. 20 이하 과매도, 80 이상 과열.'],
+   ['OBV','거래량으로 돈이 들어오는지(매집)·나가는지(분산)를 추적. 주가보다 먼저 움직이기도 한다.'],
+   ['VWAP','거래량 가중 평균가. 기관 투자자가 "본전" 기준으로 삼는 가격.'],
+   ['일목균형표','구름대(저항·지지 구간)로 추세를 보는 일본식 종합 지표.'],
+ ]},
+ {t:'💰 재무 지표 (회사가 돈을 잘 버나)',items:[
+   ['ROE','자기자본이익률. 주주 돈 100원으로 1년에 얼마 벌었나. <b>높을수록 좋고 15% 이상이면 우수</b>. 워런 버핏이 가장 중시하는 숫자.'],
+   ['영업이익률','매출 100원 중 본업으로 남긴 이익 비율. 높을수록 사업 경쟁력이 강하다.'],
+   ['순이익률','매출에서 모든 비용·이자·세금을 다 빼고 최종으로 남은 비율.'],
+   ['부채비율','자기자본 대비 빚의 비율. <b>100% 이하면 안전</b>, 200%를 넘으면 위험 신호.'],
+   ['FCF비율','잉여현금흐름(Free Cash Flow). 회사가 벌어서 쓸 거 다 쓰고 <b>실제로 남긴 진짜 현금</b>. 회계상 이익보다 정직한 숫자라 플러스면 건강.'],
+   ['매출성장률','작년 대비 올해 매출이 얼마나 늘었나. 회사가 커가고 있는지를 본다.'],
+ ]},
+ {t:'🏷️ 가치 지표 (주가가 싼가 비싼가)',items:[
+   ['PER','주가 ÷ 주당순이익. 회사 이익 대비 주가가 몇 배인가. <b>낮을수록 싸다</b>. 보통 10배 이하면 저평가 경향.'],
+   ['PBR','주가 ÷ 주당순자산. <b>1배 미만이면 회사가 가진 자산보다 주가가 싸게</b> 거래되는 것.'],
+   ['EPS / BPS','EPS=주당순이익(1주가 1년에 번 돈). BPS=주당순자산(회사 청산 시 1주가 받을 몫).'],
+   ['시가총액','주가 × 총 주식 수 = 회사 전체의 시장 몸값.'],
+   ['배당수익률','주가 대비 1년간 받는 배당금 비율. 은행 이자처럼 보면 된다.'],
+ ]},
+ {t:'🧮 이 시스템의 점수',items:[
+   ['종합점수 (-100~100)','재무·뉴스·기술·공시·수급을 다 합친 최종 점수. <b>높을수록 매수 매력</b>이 크다.'],
+   ['펀더멘털 점수','회사의 본질 가치 점수 (ROE·이익률·부채·현금흐름 등 기반).'],
+   ['기술점수','차트·기술 지표 기반의 단기 매매 타이밍 점수.'],
+   ['뉴스점수','최근 7일 뉴스의 호재/악재를 종합한 점수.'],
+   ['10공식 보팅','매직포뮬러·F-Score 등 학계·실전 검증된 10개 투자 공식이 각자 매수/매도를 투표한 결과.'],
+   ['추천등급','강력매수 &gt; 매수관심 &gt; 관망 &gt; 매도관심 &gt; 강력매도 순. 점수와 공식 투표를 함께 본다.'],
+ ]},
+ {t:'🏛️ 시장 제도·거래 용어',items:[
+   ['공매도','내가 갖고 있지도 않은 주식을 <b>빌려서 먼저 판 뒤</b>, 값이 떨어지면 싸게 되사서 갚아 차익을 먹는 기법. 주가 <b>하락에 베팅</b>하는 것. 공매도 물량이 많으면 하락 압력 신호로 본다 (이 시스템의 공매도 점수에 반영).'],
+   ['사이드카','선물 가격이 ±5~6% 급등락하면 <b>프로그램 매매(컴퓨터 자동매매)를 5분간 정지</b>시키는 장치. 시장 쏠림을 잠깐 식히는 가벼운 브레이크. 5분 후 자동 해제.'],
+   ['서킷브레이커','사이드카보다 센 비상정지. 지수가 8%·15%·20% 급락하면 <b>주식 거래 전체를 20분간 멈춤</b>. 패닉 매도를 막는 장치.'],
+   ['VI (변동성완화장치)','개별 종목이 갑자기 급등락하면 2~3분간 단일가 매매로 바꿔 진정시키는 장치. 사이드카의 개별 종목 버전.'],
+   ['상한가 / 하한가','하루에 주가가 오를·내릴 수 있는 한계. 한국은 전일 종가 대비 <b>±30%</b>.'],
+   ['ISA','개인종합자산관리계좌. 주식·펀드·예금을 한 계좌에 담아 굴리는 <b>절세 계좌</b>. 수익 일정액까지 세금 면제·저율 과세. 의무 보유기간(보통 3년) 있음. "세금 혜택 받는 장기투자용 계좌".'],
+   ['배당','회사가 번 이익의 일부를 주주에게 나눠주는 돈. 1년에 한 번(결산배당)이 보통이고 분기마다 주는 회사도 있다.'],
+ ]},
+ {t:'💡 투자 스타일·철학',items:[
+   ['가치투자','회사의 본질가치보다 <b>싸게 거래되는 주식</b>을 사서 제값을 찾아갈 때까지 기다리는 방식. 대표: 벤저민 그레이엄·워런 버핏. 이 시스템의 기본 관점.'],
+   ['성장투자','지금 좀 비싸도 <b>매출·이익이 빠르게 크는 회사</b>면 산다. 미래 성장이 현재 가격을 정당화한다는 관점. 대표: 필립 피셔·피터 린치.'],
+   ['모멘텀투자','<b>오르는 주식이 더 오른다</b>는 경험칙에 기대 추세에 올라타는 방식(추세추종). 대표: AQR·제시 리버모어. 이 시스템의 12-1 모멘텀 공식이 여기 해당.'],
+   ['퀀트투자','감정을 배제하고 <b>데이터·통계로 패턴을 찾아 기계적으로</b> 매매. 대표: 짐 사이먼스(르네상스). 이 시스템의 10공식 엔진 자체가 퀀트 방식.'],
+   ['매크로투자','개별 종목보다 <b>금리·환율·경기 같은 큰 흐름</b>에 베팅. 대표: 조지 소로스·레이 달리오.'],
+   ['역발상투자','남들이 공포에 팔 때 사고 열광할 때 판다 — <b>대중과 반대로</b>. 대표: 존 템플턴.'],
+   ['인덱스투자','시장을 이기기 어려우니 <b>지수 전체를 싸게 사서 장기 보유</b>(패시브). 대표: 존 보글. 버핏도 일반인에겐 이걸 권한다.'],
+   ['기술적분석','재무가 아니라 <b>차트·거래량·지표로 매매 타이밍</b>을 잡는 방식. 가격이 모든 정보를 반영한다고 본다.'],
+   ['배당투자','<b>배당을 꾸준히·많이 주는 회사</b>로 안정적인 현금흐름을 추구. 주가 등락보다 배당 수입을 중시.'],
+   ['멀티팩터','가치·성장·모멘텀·퀄리티 등 <b>여러 방식을 데이터로 섞는</b> 현대 퀀트 접근. 한 스타일도 항상 이기진 못하기 때문 — <b>이 시스템이 실제로 쓰는 방식.</b>'],
+ ]},
+];
+function renderGlossary(){
+  const el=document.getElementById('glossary');
+  let h=`<div style="font-size:13px;color:#90A4AE;margin-bottom:16px;line-height:1.6">
+    📖 주식 표·차트에 나오는 용어를 <b style="color:#00E676">쉬운 말</b>로 풀이했습니다. 모르는 단어가 보이면 여기서 찾아보세요.</div>`;
+  GLOSSARY.forEach(g=>{
+    h+=`<div class="panel" style="max-height:none;margin-bottom:14px"><h3 style="margin-bottom:10px">${g.t}</h3>`;
+    g.items.forEach(it=>{
+      h+=`<div style="display:flex;gap:14px;padding:11px 2px;border-bottom:1px solid rgba(255,255,255,0.05)">
+        <div style="flex:0 0 96px;color:#00E676;font-weight:700;font-size:13px">${it[0]}</div>
+        <div style="flex:1;color:#B0BEC5;font-size:12.5px;line-height:1.65">${it[1]}</div>
+      </div>`;
+    });
+    h+=`</div>`;
+  });
+  el.innerHTML=h;
 }
 
 async function renderVolumeSurge(){
@@ -281,6 +408,41 @@ async function renderVolumeSurge(){
   }
 }
 
+async function renderHot(){
+  const el=document.getElementById('hot');
+  el.innerHTML=`<div style="text-align:center;color:#546E7A;padding:30px">불러오는 중...</div>`;
+  try{
+    const list=await api('/hot')||[];
+    if(!list.length){el.innerHTML='<div class="empty">지금 뜨는 종목 없음</div>';return;}
+    let h=`<div style="font-size:12px;color:#FFB74D;background:rgba(255,152,0,0.08);border:1px solid rgba(255,152,0,0.2);border-radius:8px;padding:10px 12px;margin-bottom:14px">
+      🔥 <b>지금 뜨는 종목</b> — 최근 뉴스 호재 + 거래량 급증 기준. <b style="color:#FF8A65">※ 관찰용입니다.</b> 백테스트상 핫종목은 5~10일 들면 시장에 지므로(되돌림) 매수신호가 아니라 "지금 뭐가 움직이나" 보는 창으로만 쓰세요.</div>`;
+    h+=`<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:10px">`;
+    list.forEach((r,i)=>{
+      const recoC=r.value_reco==='강력매수'?'#00E676':r.value_reco==='매수관심'?'#69F0AE':(r.value_reco||'').includes('매도')?'#FF5252':'#90A4AE';
+      const p5=r.price_5d_pct||0, p5C=p5>=0?'#00E676':'#FF5252';
+      h+=`<div data-stock="${r.stock_code}" data-stock-name="${esc(r.stock_name)}" style="cursor:pointer;background:rgba(255,255,255,0.03);border:1px solid rgba(255,152,0,0.12);border-radius:10px;padding:12px 14px;transition:background .15s" onmouseover="this.style.background='rgba(255,255,255,0.06)'" onmouseout="this.style.background='rgba(255,255,255,0.03)'">
+        <div style="display:flex;justify-content:space-between;align-items:flex-start;margin-bottom:6px">
+          <div>
+            <div style="font-size:13px;font-weight:700;color:#E0E0E0">${i+1}. ${esc(r.stock_name||r.stock_code)}</div>
+            <div style="font-size:10px;color:#546E7A;font-family:'JetBrains Mono',monospace">${r.stock_code}</div>
+          </div>
+          <div style="font-size:15px;color:#FFB74D;font-weight:700">🔥 ${(r.hot_score||0).toFixed(0)}</div>
+        </div>
+        <div style="display:flex;gap:10px;flex-wrap:wrap;font-size:11px;color:#90A4AE">
+          ${r.pos_news_3d?`<span>호재 ${r.pos_news_3d}건</span>`:''}
+          <span>5일 <b style="color:${p5C}">${p5>=0?'+':''}${p5.toFixed(1)}%</b></span>
+          ${r.vol_ratio>=1.5?`<span>거래량 ${(r.vol_ratio||0).toFixed(1)}배</span>`:''}
+        </div>
+        <div style="margin-top:6px;font-size:11px;color:#78909C">가치판단: <b style="color:${recoC}">${r.value_reco||'-'}</b>${r.value_score!=null?` (${r.value_score}점)`:''}</div>
+      </div>`;
+    });
+    h+=`</div>`;
+    el.innerHTML=h;
+  }catch(e){
+    el.innerHTML='<div class="empty">로드 실패: '+esc(e.message)+'</div>';
+  }
+}
+
 async function api(path){try{const r=await fetch(API+path);return await r.json()}catch(e){return null}}
 
 async function loadAll(){
@@ -1012,11 +1174,9 @@ async function renderPortfolio(){
   const el=document.getElementById('portfolio');
   const list=getPortfolio();
   if(!list.length){
-    el.innerHTML=`<div style="text-align:center;padding:80px 20px;color:#546E7A">
-      <div style="font-size:48px;margin-bottom:16px">💼</div>
-      <div style="font-size:16px;margin-bottom:8px;color:#78909C">보유 종목이 없습니다</div>
-      <div style="font-size:13px">📂 내 종목 분석 탭에서 종목을 추가하면 여기에 표시됩니다</div>
-    </div>`;
+    el.innerHTML='<div class="empty">AI 추천 포트폴리오 불러오는 중...</div>';
+    const reco=await api('/portfolio/recommended'+(recoAmount>0?'?amount='+recoAmount:'')).catch(()=>null);
+    el.innerHTML=`<div style="background:rgba(64,196,255,0.06);border:1px solid rgba(64,196,255,0.2);border-radius:12px;padding:16px 18px;margin-bottom:16px;color:#CFD8DC;font-size:13px;line-height:1.6">💼 아직 등록된 보유 종목이 없습니다. 아래 <b style="color:#69F0AE">AI 추천 포트폴리오</b>를 참고하거나, <b>📂 내 종목 분석</b> 탭에서 종목을 추가하세요.</div>`+recoPortfolioHTML(reco);
     return;
   }
   el.innerHTML='<div class="empty">현재가 · AI점수 불러오는 중...</div>';
@@ -1035,7 +1195,7 @@ async function renderPortfolio(){
     return{...p,cur,changePct:pd.change_pct||0,cost,val,
       pnl:val-cost,pnlPct:cost>0?(val-cost)/cost*100:0,
       techScore:pd.tech_score||0,signal:pd.signal||'관망',
-      aiScore:pd.ai_score,recommendation:pd.recommendation};
+      aiScore:pd.ai_score,recommendation:pd.recommendation,sector:pd.sector||'기타'};
   });
   const totalPnl=totalValue-totalCost;
   const totalPnlPct=totalCost>0?totalPnl/totalCost*100:0;
@@ -1109,9 +1269,134 @@ async function renderPortfolio(){
     </tr>`;
   });
   h+=`</tbody></table></div></div>`;
+  h+=portfolioSectorHTML(holdings);
+  h+=portfolioRebalanceHTML(holdings);
+  const reco=await api('/portfolio/recommended'+(recoAmount>0?'?amount='+recoAmount:'')).catch(()=>null);
+  h+=recoPortfolioHTML(reco);
   el.innerHTML=h;
 }
 
+let recoAmount=0;
+async function applyRecoAmount(){
+  const inp=document.getElementById('reco-amt');
+  const v=parseInt((inp&&inp.value)||'0',10);
+  recoAmount=isNaN(v)?0:v;
+  renderPortfolio();
+}
+
+function portfolioSectorHTML(holdings){
+  const sec={};
+  holdings.forEach(s=>{ if(s.weight>0) sec[s.sector]=(sec[s.sector]||0)+s.weight; });
+  const arr=Object.entries(sec).sort((a,b)=>b[1]-a[1]);
+  if(!arr.length) return '';
+  let h=`<div class="panel" style="max-height:none;margin-bottom:16px"><h3>📊 섹터(업종) 비중</h3>`;
+  arr.forEach(([name,w])=>{
+    const over=w>30, c=over?'#FF8A80':'#40C4FF';
+    h+=`<div style="margin-bottom:10px">
+      <div style="display:flex;justify-content:space-between;font-size:12px;margin-bottom:4px">
+        <span style="color:#CFD8DC">${esc(name)}${over?' ⚠️':''}</span>
+        <span style="color:${c};font-weight:700">${w.toFixed(1)}%</span></div>
+      <div style="height:8px;background:rgba(255,255,255,0.06);border-radius:4px;overflow:hidden">
+        <div style="height:100%;width:${Math.min(100,w).toFixed(0)}%;background:${c};border-radius:4px"></div></div></div>`;
+  });
+  if(arr[0][1]>30) h+=`<div style="font-size:11.5px;color:#FF8A80;margin-top:4px">⚠️ <b>${esc(arr[0][0])}</b> 업종이 ${arr[0][1].toFixed(0)}%로 한쪽에 쏠렸습니다. 한 업종 30% 이내로 분산하면 위험이 줄어듭니다.</div>`;
+  return h+`</div>`;
+}
+
+function portfolioRebalanceHTML(holdings){
+  const acts=[];
+  holdings.forEach(s=>{
+    if(s.recommendation==='강력매도'||s.recommendation==='매도관심')
+      acts.push([s,'sell',`AI가 <b>${esc(s.recommendation)}</b> 신호를 냈습니다 — 매도를 검토하세요`]);
+    else if(s.cur>0&&s.pnlPct<=-10)
+      acts.push([s,'cut',`손실 ${s.pnlPct.toFixed(1)}% — 손절 기준을 점검하세요`]);
+    else if(s.aiScore!=null&&s.aiScore<=-30)
+      acts.push([s,'sell',`AI점수 ${s.aiScore.toFixed(0)}점으로 부진 — 매도를 검토하세요`]);
+    else if(s.aiScore!=null&&s.aiScore>=70&&s.weight<7)
+      acts.push([s,'add',`AI점수 ${s.aiScore.toFixed(0)}점 우량인데 비중이 작습니다 — 추가 매수 고려`]);
+  });
+  let h=`<div class="panel" style="max-height:none;margin-bottom:16px"><h3>🔧 리밸런싱 진단</h3>`;
+  if(!acts.length){
+    h+=`<div style="color:#69F0AE;font-size:12.5px">✅ 보유 종목에 특별한 조치 신호가 없습니다. 그대로 유지해도 무난합니다.</div>`;
+  }else{
+    acts.forEach(([s,kind,msg])=>{
+      const c=kind==='add'?'#69F0AE':kind==='sell'?'#FF8A80':'#FFD740';
+      const ic=kind==='add'?'➕':kind==='sell'?'⚠️':'🔻';
+      h+=`<div data-stock="${s.code}" data-stock-name="${esc(s.name||'')}" style="display:flex;gap:10px;align-items:center;padding:9px 0;border-bottom:1px solid rgba(255,255,255,0.05);cursor:pointer">
+        <span style="font-size:15px">${ic}</span>
+        <div style="flex:1;min-width:0"><div style="color:#CFD8DC;font-size:12.5px;font-weight:600">${esc(s.name||s.code)}</div>
+        <div style="color:${c};font-size:11px;line-height:1.5">${msg}</div></div>
+        <span style="color:${s.pnlPct>=0?'#69F0AE':'#FF8A80'};font-size:11px;font-family:'JetBrains Mono',monospace">${s.cur>0?(s.pnlPct>=0?'+':'')+s.pnlPct.toFixed(1)+'%':'-'}</span></div>`;
+    });
+  }
+  return h+`</div>`;
+}
+
+function recoPortfolioHTML(reco){
+  if(!reco||!reco.holdings||!reco.holdings.length)
+    return `<div class="panel" style="max-height:none"><h3>🤖 AI 추천 포트폴리오</h3><div style="color:#546E7A;font-size:12px">${esc((reco&&reco.msg)||'추천 데이터를 불러오지 못했습니다.')}</div></div>`;
+  let h=`<div class="panel" style="max-height:none"><h3>🤖 AI 추천 포트폴리오 (${esc(reco.as_of||'')})</h3>
+    <div style="font-size:11.5px;color:#90A4AE;margin-bottom:12px;line-height:1.6">오늘 <b style="color:#69F0AE">강력매수·매수관심</b> 종목을 변동성·점수로 비중을 매기고, 한 업종 30% 이내로 분산한 구성입니다. 투자금액을 넣으면 종목별 매수 주수를 계산합니다.</div>
+    <div style="display:flex;gap:8px;margin-bottom:14px;align-items:center;flex-wrap:wrap">
+      <input id="reco-amt" type="number" placeholder="투자금액 입력 (원)" value="${recoAmount||''}"
+        style="background:rgba(255,255,255,0.05);border:1px solid rgba(255,255,255,0.1);border-radius:8px;padding:8px 12px;color:#E0E0E0;font-size:13px;width:180px;outline:none"
+        onkeypress="if(event.key==='Enter')applyRecoAmount()">
+      <button onclick="applyRecoAmount()" style="background:rgba(0,230,118,0.1);border:1px solid rgba(0,230,118,0.25);border-radius:8px;padding:8px 16px;color:#00E676;font-size:12px;font-weight:600;cursor:pointer">계산</button>
+    </div>`;
+  const sbArr=Object.entries(reco.sector_breakdown||{});
+  if(sbArr.length){
+    h+=`<div style="display:flex;flex-wrap:wrap;gap:6px;margin-bottom:12px">`;
+    sbArr.forEach(([n,w])=>{ h+=`<span style="background:rgba(64,196,255,0.1);border:1px solid rgba(64,196,255,0.25);border-radius:6px;padding:3px 9px;font-size:10.5px;color:#CFD8DC">${esc(n)} ${w.toFixed(0)}%</span>`; });
+    h+=`</div>`;
+  }
+  const hasAmt=reco.input_amount>0;
+  h+=`<div style="overflow-x:auto"><table style="width:100%;border-collapse:collapse;font-size:12px">
+    <thead><tr style="color:#78909C;border-bottom:1px solid rgba(255,255,255,0.08)">
+      <th style="text-align:left;padding:8px 6px;font-weight:600">종목</th>
+      <th style="text-align:center;padding:8px 6px;font-weight:600">AI점수</th>
+      <th style="text-align:right;padding:8px 6px;font-weight:600">비중</th>
+      ${hasAmt?'<th style="text-align:right;padding:8px 6px;font-weight:600">매수금액</th><th style="text-align:right;padding:8px 6px;font-weight:600">주수</th>':''}
+    </tr></thead><tbody>`;
+  reco.holdings.forEach((s,i)=>{
+    const aic=s.total_score>=70?'#00E676':s.total_score>=40?'#69F0AE':'#90A4AE';
+    h+=`<tr data-stock="${s.stock_code}" data-stock-name="${esc(s.stock_name)}" style="border-bottom:1px solid rgba(255,255,255,0.04);cursor:pointer;${i%2?'background:rgba(255,255,255,0.01)':''}">
+      <td style="padding:9px 6px"><div style="color:#CFD8DC;font-weight:600">${esc(s.stock_name)}</div>
+        <div style="font-size:10px;color:#546E7A">${esc(s.sector)} · ${esc(s.recommendation)}</div></td>
+      <td style="text-align:center;padding:9px 6px;color:${aic};font-weight:700;font-family:'JetBrains Mono',monospace">${s.total_score.toFixed(0)}</td>
+      <td style="text-align:right;padding:9px 6px"><span style="color:#40C4FF;font-weight:700">${s.weight_pct.toFixed(1)}%</span></td>
+      ${hasAmt?`<td style="text-align:right;padding:9px 6px;color:#CFD8DC;font-family:'JetBrains Mono',monospace">${fmt(s.invest_amount)}</td><td style="text-align:right;padding:9px 6px;color:#E0E0E0;font-weight:600">${s.shares.toLocaleString()}</td>`:''}
+    </tr>`;
+  });
+  h+=`</tbody></table></div>`;
+  if(hasAmt)
+    h+=`<div style="margin-top:10px;font-size:11.5px;color:#90A4AE">투자금 ${fmt(reco.input_amount)}원 중 <b style="color:#69F0AE">${fmt(reco.invested_amount)}원</b> 매수 · 현금 ${fmt(reco.cash_remaining)}원 남음</div>`;
+  return h+`</div>`;
+}
+
+function equityCurveSVG(curve){
+  if(!curve||curve.length<2) return '';
+  const W=640,H=180,pad=30;
+  const allv=curve.flatMap(p=>[p.strategy_pct,p.kospi_pct]).concat([0]);
+  let mn=Math.min(...allv), mx=Math.max(...allv);
+  if(mx===mn)mx=mn+1;
+  const X=i=>pad+(W-2*pad)*i/(curve.length-1);
+  const Y=v=>H-pad-(H-2*pad)*(v-mn)/(mx-mn);
+  const path=k=>curve.map((p,i)=>`${i?'L':'M'}${X(i).toFixed(1)},${Y(p[k]).toFixed(1)}`).join('');
+  const last=curve[curve.length-1];
+  const sC=last.strategy_pct>=0?'#00E676':'#FF5252';
+  return `<div class="panel" style="margin-top:14px"><h3>📈 자산곡선 — 추천을 따랐을 때 누적 수익률</h3>
+    <div style="font-size:11px;color:#90A4AE;margin-bottom:8px">매일 추천 종목을 등비중으로 샀다고 가정한 누적 수익률(거래비용 차감). <b style="color:${sC}">초록=전략</b> · <b style="color:#FFB74D">주황=KOSPI</b></div>
+    <svg viewBox="0 0 ${W} ${H}" style="width:100%;height:auto">
+      <line x1="${pad}" y1="${Y(0).toFixed(1)}" x2="${W-pad}" y2="${Y(0).toFixed(1)}" stroke="rgba(255,255,255,0.15)" stroke-dasharray="3"/>
+      <path d="${path('kospi_pct')}" fill="none" stroke="#FFB74D" stroke-width="1.6"/>
+      <path d="${path('strategy_pct')}" fill="none" stroke="${sC}" stroke-width="2.2"/>
+    </svg>
+    <div style="display:flex;justify-content:space-between;font-size:11px;color:#78909C;margin-top:4px">
+      <span>${esc(curve[0].date)}</span>
+      <span style="color:${sC};font-weight:700">전략 ${last.strategy_pct>=0?'+':''}${last.strategy_pct}% vs KOSPI ${last.kospi_pct>=0?'+':''}${last.kospi_pct}%</span>
+      <span>${esc(last.date)}</span></div></div>`;
+}
+
 function renderSignals(signals,cands){
   let h=`<div style="margin-bottom:20px">
     <div style="font-size:12px;color:#546E7A;margin-bottom:16px">
@@ -1871,6 +2156,7 @@ async function renderBacktest(){
         ${_btCard('MDD', oa.max_drawdown_pct, '%', true)}
         ${_btCard('알파', oa.avg_alpha_pct, '%', true)}
       </div>
+      ${equityCurveSVG(d.equity_curve)}
       <div class="panel" style="margin-top:14px"><h3>등급별 성과 (7일)</h3>${_btTable(d.by_recommendation_7d||{})}</div>`;
     if(oa30.n){
       h += `<h3 style="color:#90A4AE;font-size:13px;margin:18px 0 10px">30일 보유</h3>
@@ -1892,64 +2178,241 @@ async function renderBacktest(){
 // ─────────────────────────────────────────────────────────────
 // 🌎 미증시 동조
 // ─────────────────────────────────────────────────────────────
+// 미국 주요 티커 → 한글 회사명/설명 매핑 (페어·ETF 표시용)
+const US_TICKER_KR = {
+  // 반도체
+  NVDA:'엔비디아', AMD:'AMD', MU:'마이크론', INTC:'인텔', TSM:'TSMC(대만 반도체)',
+  AVGO:'브로드컴', QCOM:'퀄컴', TXN:'TI', AMAT:'어플라이드머티리얼', LRCX:'램리서치', KLAC:'KLA',
+  // 빅테크
+  AAPL:'애플', MSFT:'마이크로소프트', GOOGL:'구글', AMZN:'아마존', META:'메타(페북)',
+  TSLA:'테슬라', NFLX:'넷플릭스', ORCL:'오라클', ADBE:'어도비', CRM:'세일즈포스',
+  // 금융
+  JPM:'JP모건', BAC:'뱅크오브아메리카', GS:'골드만삭스', MS:'모건스탠리',
+  WFC:'웰스파고', C:'씨티그룹', BLK:'블랙록',
+  // 에너지/소재
+  XOM:'엑손모빌', CVX:'쉐브론', COP:'코노코필립스', NUE:'뉴코어(철강)', FCX:'프리포트(구리)',
+  // 헬스/바이오
+  JNJ:'존슨앤존슨', PFE:'화이자', MRK:'머크', ABBV:'애브비', LLY:'일라이릴리',
+  BMY:'BMS', GILD:'길리어드',
+  // 소비재/유통
+  WMT:'월마트', COST:'코스트코', HD:'홈디포', MCD:'맥도날드', NKE:'나이키',
+  SBUX:'스타벅스', DIS:'디즈니',
+  // 산업/방산
+  BA:'보잉', LMT:'록히드마틴', RTX:'레이시온', GD:'제너럴다이내믹스', CAT:'캐터필러', DE:'존디어',
+  // 자동차
+  F:'포드', GM:'GM', TM:'도요타',
+  // 2차전지/리튬
+  ALB:'알버말(리튬)', RIVN:'리비안',
+  // 화학
+  DOW:'다우', LYB:'라이언델바젤',
+  // 게임/엔터
+  NTES:'넷이즈(중국게임)',
+  // ETF
+  SOXX:'반도체 ETF', SMH:'반도체 ETF(VanEck)', XLK:'미국 기술주 ETF', QQQ:'나스닥100 ETF',
+  XBI:'바이오 ETF', IBB:'바이오 ETF(나스닥)', LIT:'리튬·전기차 ETF',
+  XLE:'에너지 ETF', XLF:'금융 ETF', XLV:'헬스케어 ETF', XLI:'산업재 ETF',
+  XLP:'필수소비재 ETF', XLY:'경기소비재 ETF', ITA:'항공·방산 ETF',
+};
+function usName(t){ return US_TICKER_KR[t] || ''; }
+
 async function renderUsMarket(){
   const el=document.getElementById('usmarket');
-  el.innerHTML=`<div style="font-size:12px;color:#546E7A;margin-bottom:14px">미국 섹터 ETF·KR↔US 페어 회귀로 한국 종목별 동조 시그널 산출 (매일 KST 08:00)</div><div style="text-align:center;color:#546E7A;padding:30px">불러오는 중...</div>`;
+  el.innerHTML=`<div style="text-align:center;color:#546E7A;padding:30px">불러오는 중...</div>`;
   try{
-    const [etfs, pairs, signals] = await Promise.all([
-      api('/usmarket/etfs'), api('/usmarket/pairs'), api('/usmarket/signals')
+    const [etfs, pairs, signals, brief] = await Promise.all([
+      api('/usmarket/etfs'), api('/usmarket/pairs'), api('/usmarket/signals'), api('/usmarket/briefing')
     ]);
-    let h = `<div class="grid2">`;
-    // 섹터 ETF
-    h += `<div class="panel"><h3>섹터 ETF (${Array.isArray(etfs)?etfs.length:0})</h3>`;
-    if(Array.isArray(etfs) && etfs.length){
-      h += `<table style="width:100%;font-size:11px;border-collapse:separate;border-spacing:1px">
-        <thead><tr style="color:#90A4AE"><th style="text-align:left;padding:6px">티커</th><th style="text-align:left">설명</th><th style="text-align:left">한국 섹터</th></tr></thead><tbody>`;
-      etfs.slice(0,30).forEach(e=>{
-        const kw = Array.isArray(e.sector_keywords)?e.sector_keywords.join(', '):'';
-        h += `<tr><td style="padding:5px 6px;color:#69F0AE;font-family:'JetBrains Mono',monospace;font-weight:700">${esc(e.etf_ticker)}</td><td style="color:#CFD8DC">${esc(e.description||'-')}</td><td style="color:#90A4AE;font-size:10px">${esc(kw)}</td></tr>`;
-      });
-      h += `</tbody></table>`;
-    } else h += `<div class="empty">데이터 없음</div>`;
-    h += `</div>`;
-    // 페어
-    h += `<div class="panel"><h3>KR ↔ US 페어 (${Array.isArray(pairs)?pairs.length:0})</h3>`;
-    if(Array.isArray(pairs) && pairs.length){
-      h += `<table style="width:100%;font-size:11px;border-collapse:separate;border-spacing:1px">
-        <thead><tr style="color:#90A4AE"><th style="text-align:left;padding:6px">US</th><th>KR</th><th title="60일 회귀 베타">β</th><th title="60일 상관">ρ</th><th>N</th></tr></thead><tbody>`;
-      pairs.slice(0,30).forEach(p=>{
-        const beta = p.beta_60d!=null?(+p.beta_60d).toFixed(2):'-';
-        const corr = p.correlation_60d!=null?(+p.correlation_60d).toFixed(2):'-';
-        h += `<tr><td style="padding:5px 6px;color:#69F0AE;font-family:'JetBrains Mono',monospace">${esc(p.us_ticker)}</td><td style="color:#CFD8DC;font-family:'JetBrains Mono',monospace">${esc(p.kr_code)}</td><td style="text-align:center;font-family:'JetBrains Mono',monospace;color:#FFD740">${beta}</td><td style="text-align:center;font-family:'JetBrains Mono',monospace;color:#90A4AE">${corr}</td><td style="text-align:center;color:#546E7A">${p.sample_size||'-'}</td></tr>`;
-      });
-      h += `</tbody></table>`;
-    } else h += `<div class="empty">데이터 없음</div>`;
-    h += `</div></div>`;
-    // 시그널
-    h += `<div class="panel" style="margin-top:14px"><h3>최신 동조 시그널 (${Array.isArray(signals)?signals.length:0})</h3>`;
+
+    // ── 0. 탭 안내 (이 탭은 뭐 하는 곳?) ──
+    let h = `
+    <div style="background:linear-gradient(135deg,rgba(64,196,255,0.07),rgba(105,240,174,0.05));border:1px solid rgba(64,196,255,0.25);border-radius:12px;padding:14px 18px;margin-bottom:16px">
+      <div style="display:flex;align-items:center;gap:8px;margin-bottom:8px">
+        <span style="font-size:18px">🌎</span>
+        <span style="font-weight:700;color:#40C4FF;font-size:14px">이 탭은 뭐예요?</span>
+      </div>
+      <div style="color:#CFD8DC;font-size:12.5px;line-height:1.7">
+        <b style="color:#69F0AE">미국 증시의 움직임</b>이 한국 종목에 어떤 영향을 줄지 미리 보여주는 곳입니다.
+        예) <span style="color:#FFD740">엔비디아가 어제 +5% 올랐다 → SK하이닉스도 오를 가능성 ↑</span>
+        <br>
+        매일 한국 시장 시작 전(KST 08:00)에 미국 마감을 보고 자동 계산됩니다.
+      </div>
+      <div style="background:rgba(255,255,255,0.04);border-radius:8px;padding:10px 12px;margin-top:10px;font-size:11.5px;color:#90A4AE;line-height:1.7">
+        <b style="color:#FFD740">📖 보는 법</b><br>
+        ① <b style="color:#CFD8DC">최신 동조 시그널</b>: 한국 종목별로 "오늘 미국 영향을 +/- 몇 점 받았는지". <b style="color:#69F0AE">+5 이상이면 강한 호재</b>, <b style="color:#FF8A80">-5 이하면 강한 악재</b>. 종합점수에 반영됨.<br>
+        ② <b style="color:#CFD8DC">섹터 ETF</b>: 미국 업종 ETF가 한국 어떤 업종에 영향 주는지. 예) 미국 반도체 ETF(SOXX) ↑ → 한국 반도체 ↑<br>
+        ③ <b style="color:#CFD8DC">KR↔US 페어</b>: 개별 종목 간 동조 (엔비디아↔SK하이닉스 등). β(민감도)가 클수록 강하게 따라감.
+      </div>
+    </div>`;
+
+    // ── 0.5. 오늘 새벽 미국증시 브리핑 (핫/저조 + 관련 KOSPI) ──
+    if(brief && !brief.err && ((brief.hot&&brief.hot.length)||(brief.cold&&brief.cold.length))){
+      const aiC=(v)=> v==null?'#546E7A': v>=30?'#69F0AE': v<=-30?'#FF8A80':'#90A4AE';
+      const krLine=(k)=>{
+        const sc=(k.ai_score!=null)?`<span style="color:${aiC(k.ai_score)};font-family:'JetBrains Mono',monospace;font-size:11px">${k.ai_score>=0?'+':''}${k.ai_score}</span>`:'<span style="color:#546E7A;font-size:11px">점수없음</span>';
+        const rec=(k.recommendation&&k.recommendation!=='-')?`<span style="color:${RCOL[k.recommendation]||'#78909C'};font-size:10px;font-weight:600">${esc(k.recommendation)}</span>`:'';
+        return `<div data-stock="${esc(k.kr_code)}" data-stock-name="${esc(k.kr_name)}" style="display:flex;gap:6px;align-items:center;padding:3px 0;cursor:pointer">
+          <span style="color:#CFD8DC;font-size:11.5px;flex:1;min-width:0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">${esc(k.kr_name)}</span>${sc}${rec}</div>`;
+      };
+      const stockCard=(s,isHot)=>{
+        const c=isHot?'#69F0AE':'#FF8A80';
+        const krs=(s.related_kr||[]).map(krLine).join('')||'<span style="color:#546E7A;font-size:11px">연결된 한국 종목 없음</span>';
+        return `<div style="background:rgba(255,255,255,0.03);border:1px solid ${c}33;border-radius:10px;padding:10px 12px;margin-bottom:8px">
+          <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:6px;gap:8px">
+            <span style="color:#E0E0E0;font-weight:700;font-size:12.5px">${esc(s.label)}</span>
+            <span style="color:${c};font-weight:700;font-family:'JetBrains Mono',monospace;font-size:14px;white-space:nowrap">${s.change_pct>=0?'+':''}${s.change_pct}%</span>
+          </div>
+          <div style="border-top:1px solid rgba(255,255,255,0.05);padding-top:5px">
+            <div style="font-size:10px;color:#607D8B;margin-bottom:2px">관련 KOSPI 종목 (AI점수 높은 순)</div>${krs}
+          </div></div>`;
+      };
+      h += `<div class="panel"><h3>🌙 오늘 새벽 미국증시 (${esc(brief.trade_date||'')} 기준)</h3>
+        <div style="font-size:11.5px;color:#90A4AE;margin-bottom:14px;line-height:1.6">간밤 미국에서 <b style="color:#69F0AE">오른 종목</b>·<b style="color:#FF8A80">내린 종목</b>과, 같이 움직이는 한국(KOSPI) 관련주입니다. 관련주의 <b style="color:#FFD740">AI점수가 높으면(+30↑)</b> 오늘 주목해볼 만합니다.</div>
+        <div class="usbrief-grid" style="display:grid;grid-template-columns:1fr 1fr;gap:14px">
+          <div><div style="color:#69F0AE;font-weight:700;font-size:12px;margin-bottom:8px">🔥 어젯밤 강했던 종목</div>
+            ${(brief.hot||[]).map(s=>stockCard(s,true)).join('')||'<div style="color:#546E7A;font-size:11px">데이터 없음</div>'}</div>
+          <div><div style="color:#FF8A80;font-weight:700;font-size:12px;margin-bottom:8px">❄️ 어젯밤 약했던 종목</div>
+            ${(brief.cold||[]).map(s=>stockCard(s,false)).join('')||'<div style="color:#546E7A;font-size:11px">데이터 없음</div>'}</div>
+        </div>`;
+      if(brief.sector_heat&&brief.sector_heat.length){
+        h += `<div style="margin-top:14px"><div style="font-size:11px;color:#607D8B;margin-bottom:6px">미국 업종 ETF 등락 — 한국 같은 업종에 영향</div>
+          <div style="display:flex;flex-wrap:wrap;gap:6px">`;
+        brief.sector_heat.forEach(e=>{
+          const c=e.change_pct>=0?'#69F0AE':'#FF8A80';
+          h += `<span style="background:${c}1a;border:1px solid ${c}40;border-radius:6px;padding:3px 9px;font-size:10.5px;color:#CFD8DC">${esc(e.label)} <b style="color:${c}">${e.change_pct>=0?'+':''}${e.change_pct}%</b></span>`;
+        });
+        h += `</div></div>`;
+      }
+      h += `</div>`;
+    }
+
+    // ── 1. 최신 동조 시그널 (가장 중요 — 맨 위로) ──
+    h += `<div class="panel"><h3>📡 오늘의 미국→한국 영향 (${Array.isArray(signals)?signals.length:0}개 종목)</h3>`;
+    h += `<div style="font-size:11px;color:#90A4AE;margin-bottom:12px">
+      🟢 양수(+) = 미국 영향으로 <b style="color:#69F0AE">올라갈 압력</b> · 🔴 음수(-) = <b style="color:#FF8A80">내려갈 압력</b><br>
+      "섹터"는 미국 업종 ETF, "페어"는 짝지어진 미국 개별주의 영향. 둘을 합친 게 총점.
+    </div>`;
     if(Array.isArray(signals) && signals.length){
-      h += `<div style="display:grid;grid-template-columns:repeat(auto-fill,minmax(260px,1fr));gap:8px">`;
-      // 절대값 큰 순으로 정렬
       const sorted = signals.slice().sort((a,b)=>Math.abs(+b.total_adj||0) - Math.abs(+a.total_adj||0));
-      sorted.slice(0,60).forEach(s=>{
+      // 강도 그룹별로 분류
+      const strong = sorted.filter(s=>Math.abs(+s.total_adj||0) >= 5);
+      const medium = sorted.filter(s=>{ const a=Math.abs(+s.total_adj||0); return a>=2 && a<5; });
+      const weak   = sorted.filter(s=>Math.abs(+s.total_adj||0) < 2);
+      const renderCard = (s)=>{
         const total = +s.total_adj || 0;
         const sec = +s.sector_adj || 0;
         const pair = +s.pair_adj || 0;
         const c = total>0?'#69F0AE':total<0?'#FF8A80':'#90A4AE';
-        h += `<div style="background:rgba(255,255,255,0.03);border:1px solid rgba(255,255,255,0.05);border-radius:10px;padding:10px 12px">
-          <div style="display:flex;justify-content:space-between;align-items:center">
-            <span style="color:#CFD8DC;font-family:'JetBrains Mono',monospace;font-weight:700">${esc(s.kr_code||'-')}</span>
-            <span style="color:${c};font-weight:700;font-family:'JetBrains Mono',monospace">${total>0?'+':''}${total.toFixed(2)}</span>
+        const arrow = total>=5?'🚀':total<=-5?'⚠️':total>0?'▲':total<0?'▼':'·';
+        const krName = esc(s.kr_name || s.kr_code || '-');
+        // contributing_pairs에서 어떤 미국 종목이 주된 원인인지 표시
+        let topReason = '';
+        try{
+          const cp = s.contributing_pairs;
+          const pairs = (cp && cp.pairs) ? cp.pairs : (Array.isArray(cp)?cp:[]);
+          if(pairs && pairs.length){
+            const top = pairs.slice().sort((a,b)=>Math.abs(+b.contribution||0)-Math.abs(+a.contribution||0))[0];
+            if(top){
+              const usK = usName(top.us) || '';
+              topReason = `${esc(top.us)}${usK?`(${esc(usK)})`:''} ${(+top.pct||0)>=0?'+':''}${(+top.pct||0).toFixed(1)}%`;
+            }
+          }
+        }catch(e){}
+        return `<div style="background:rgba(255,255,255,0.03);border:1px solid ${c}33;border-radius:10px;padding:12px 14px">
+          <div style="display:flex;justify-content:space-between;align-items:center;gap:8px">
+            <div style="flex:1;min-width:0">
+              <div style="color:#CFD8DC;font-weight:700;font-size:13px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">${krName}</div>
+              <div style="font-family:'JetBrains Mono',monospace;font-size:10px;color:#546E7A">${esc(s.kr_code||'')}</div>
+            </div>
+            <div style="text-align:right">
+              <div style="color:${c};font-weight:700;font-family:'JetBrains Mono',monospace;font-size:18px">${arrow} ${total>0?'+':''}${total.toFixed(1)}</div>
+            </div>
           </div>
-          <div style="font-size:10px;color:#90A4AE;margin-top:4px;display:flex;gap:10px">
-            <span>섹터 ${sec>=0?'+':''}${sec.toFixed(2)}</span>
-            <span>페어 ${pair>=0?'+':''}${pair.toFixed(2)}</span>
+          <div style="font-size:10.5px;color:#78909C;margin-top:6px;display:flex;gap:10px;flex-wrap:wrap">
+            <span title="섹터 ETF 영향">섹터 <span style="color:${sec>=0?'#69F0AE':'#FF8A80'}">${sec>=0?'+':''}${sec.toFixed(1)}</span></span>
+            <span title="개별 페어 영향">페어 <span style="color:${pair>=0?'#69F0AE':'#FF8A80'}">${pair>=0?'+':''}${pair.toFixed(1)}</span></span>
+          </div>
+          ${topReason?`<div style="font-size:10px;color:#90A4AE;margin-top:5px;border-top:1px solid rgba(255,255,255,0.05);padding-top:5px">📌 주원인: ${topReason}</div>`:''}
+        </div>`;
+      };
+      const renderGroup = (title, color, arr) => {
+        if(!arr.length) return '';
+        return `<div style="margin-bottom:14px">
+          <div style="font-size:12px;color:${color};font-weight:700;margin-bottom:8px">${title} <span style="color:#546E7A;font-weight:400">${arr.length}개</span></div>
+          <div style="display:grid;grid-template-columns:repeat(auto-fill,minmax(220px,1fr));gap:8px">
+            ${arr.slice(0,40).map(renderCard).join('')}
           </div>
         </div>`;
-      });
-      h += `</div>`;
-    } else h += `<div class="empty">시그널 없음 (아직 계산 전)</div>`;
+      };
+      h += renderGroup('🔥 강한 영향 (|점수| ≥ 5)', '#FFD740', strong);
+      h += renderGroup('➡️ 보통 영향 (2 ~ 5)', '#40C4FF', medium);
+      if(weak.length && (strong.length + medium.length) < 5){
+        h += renderGroup('약한 영향 (< 2)', '#78909C', weak.slice(0,20));
+      }
+    } else h += `<div class="empty">시그널 없음 — 매일 08:00에 자동 계산됨. 처음 배포 직후라면 아직 생성 전입니다.</div>`;
     h += `</div>`;
+
+    // ── 2. 섹터 ETF (어떤 업종이 어떻게 매칭되는지) ──
+    h += `<div class="grid2" style="margin-top:14px">`;
+    h += `<div class="panel"><h3>🏭 미국 섹터 ETF → 한국 업종 매칭 (${Array.isArray(etfs)?etfs.length:0})</h3>`;
+    h += `<div style="font-size:11px;color:#90A4AE;margin-bottom:10px">미국 ETF가 오르내리면 매칭된 한국 업종도 같이 영향받습니다.</div>`;
+    if(Array.isArray(etfs) && etfs.length){
+      h += `<table style="width:100%;font-size:11.5px;border-collapse:separate;border-spacing:0 3px">
+        <thead><tr style="color:#90A4AE;font-size:10.5px">
+          <th style="text-align:left;padding:4px 6px">미국 ETF</th>
+          <th style="text-align:left">설명</th>
+          <th style="text-align:left">한국 업종</th>
+        </tr></thead><tbody>`;
+      etfs.slice(0,30).forEach(e=>{
+        const kw = Array.isArray(e.sector_keywords)?e.sector_keywords.join(' · '):'';
+        const krDesc = usName(e.etf_ticker) || esc(e.description||'-');
+        h += `<tr style="background:rgba(255,255,255,0.02)">
+          <td style="padding:7px 8px;color:#69F0AE;font-family:'JetBrains Mono',monospace;font-weight:700">${esc(e.etf_ticker)}</td>
+          <td style="color:#CFD8DC">${esc(krDesc)}</td>
+          <td style="color:#FFD740;font-size:11px">${esc(kw)}</td>
+        </tr>`;
+      });
+      h += `</tbody></table>`;
+    } else h += `<div class="empty">데이터 없음</div>`;
+    h += `</div>`;
+
+    // ── 3. 개별 페어 ──
+    h += `<div class="panel"><h3>🔗 개별 종목 짝짓기 (${Array.isArray(pairs)?pairs.length:0})</h3>`;
+    h += `<div style="font-size:11px;color:#90A4AE;margin-bottom:10px">
+      <b>민감도(β)</b>: 미국 종목이 1% 오를 때 한국 종목이 몇% 따라가는지<br>
+      <b>상관계수(ρ)</b>: 같이 움직이는 정도. 0.7↑면 매우 강함, 0.5↑면 의미 있음, 0.3↓면 약함
+    </div>`;
+    if(Array.isArray(pairs) && pairs.length){
+      // 한국명 매칭되는 페어를 우선 정렬
+      const sorted = pairs.slice().sort((a,b)=>{
+        const corA = Math.abs(+a.correlation_60d||0);
+        const corB = Math.abs(+b.correlation_60d||0);
+        return corB - corA;
+      });
+      h += `<table style="width:100%;font-size:11.5px;border-collapse:separate;border-spacing:0 3px">
+        <thead><tr style="color:#90A4AE;font-size:10.5px">
+          <th style="text-align:left;padding:4px 6px">미국</th>
+          <th style="text-align:left">한국</th>
+          <th title="민감도: 미국 +1%일 때 한국 +β%" style="text-align:center">민감도(β)</th>
+          <th title="상관: 같이 움직이는 정도 (0~1)" style="text-align:center">상관(ρ)</th>
+        </tr></thead><tbody>`;
+      sorted.slice(0,40).forEach(p=>{
+        const beta = p.beta_60d!=null?(+p.beta_60d).toFixed(2):'-';
+        const corr = p.correlation_60d!=null?(+p.correlation_60d).toFixed(2):'-';
+        const corrN = +p.correlation_60d || 0;
+        const corrC = Math.abs(corrN)>=0.7?'#69F0AE':Math.abs(corrN)>=0.5?'#FFD740':Math.abs(corrN)>=0.3?'#90A4AE':'#546E7A';
+        const usK = usName(p.us_ticker) || '';
+        const krN = esc(p.kr_name || '');
+        h += `<tr style="background:rgba(255,255,255,0.02)">
+          <td style="padding:6px 8px;color:#69F0AE;font-family:'JetBrains Mono',monospace">${esc(p.us_ticker)}${usK?`<span style="color:#90A4AE;font-family:'Pretendard',sans-serif;font-size:10px;margin-left:4px">${esc(usK)}</span>`:''}</td>
+          <td style="color:#CFD8DC">${krN || `<span style="font-family:'JetBrains Mono',monospace">${esc(p.kr_code)}</span>`}</td>
+          <td style="text-align:center;font-family:'JetBrains Mono',monospace;color:#FFD740">${beta}</td>
+          <td style="text-align:center;font-family:'JetBrains Mono',monospace;color:${corrC};font-weight:700">${corr}</td>
+        </tr>`;
+      });
+      h += `</tbody></table>`;
+    } else h += `<div class="empty">페어 없음</div>`;
+    h += `</div></div>`;
+
     el.innerHTML = h;
   }catch(e){el.innerHTML=`<div class="empty">오류: ${esc(String(e))}</div>`}
 }
diff --git a/dashboard-api/main.py b/dashboard-api/main.py
index 5e1bbe2..6704709 100644
--- a/dashboard-api/main.py
+++ b/dashboard-api/main.py
@@ -317,7 +317,9 @@ async def recent(limit: int = Query(default=40), only_stock: bool = Query(defaul
     async with pg_pool.acquire() as c:
         rows = await c.fetch(f"""
             SELECT title, sentiment, intensity, primary_stock, reason,
-                   investment_action, source, analyzed_at, url, catalyst, stock_codes
+                   investment_action, source,
+                   COALESCE(published_at, analyzed_at) AS analyzed_at,
+                   url, catalyst, stock_codes
             FROM news_analysis {where}
             ORDER BY analyzed_at DESC LIMIT $1
         """, limit)
@@ -473,7 +475,7 @@ async def buy_candidates(limit: int = Query(default=20)):
                    ON t.stock_code = s.stock_code
                   AND s.score_date = (SELECT MAX(score_date) FROM stock_scores)
             LEFT JOIN LATERAL (
-                SELECT roe, operating_margin, debt_ratio, revenue_growth, net_margin,
+                SELECT stock_code, roe, operating_margin, debt_ratio, revenue_growth, net_margin,
                        operating_profit, revenue
                 FROM dart_financials
                 WHERE stock_code = t.stock_code
@@ -507,9 +509,11 @@ async def alerts():
     async with pg_pool.acquire() as c:
         rows = await c.fetch("""
             SELECT title, sentiment, intensity, primary_stock,
-                   reason, investment_action, source, analyzed_at
+                   reason, investment_action, source,
+                   COALESCE(published_at, analyzed_at) AS analyzed_at
             FROM news_analysis
-            WHERE intensity >= 3 AND analyzed_at >= NOW() - INTERVAL '24 hours'
+            WHERE intensity >= 3
+              AND COALESCE(published_at, analyzed_at) >= NOW() - INTERVAL '24 hours'
             ORDER BY intensity DESC, analyzed_at DESC LIMIT 20
         """)
     return [dict(r) for r in rows]
@@ -520,12 +524,12 @@ async def alerts():
 async def timeline(hours: int = Query(default=24)):
     async with pg_pool.acquire() as c:
         rows = await c.fetch("""
-            SELECT date_trunc('hour', analyzed_at) AS hour,
+            SELECT date_trunc('hour', COALESCE(published_at, analyzed_at)) AS hour,
                    SUM(CASE WHEN sentiment='호재' THEN 1 ELSE 0 END) AS pos,
                    SUM(CASE WHEN sentiment='악재' THEN 1 ELSE 0 END) AS neg,
                    COUNT(*) AS total
             FROM news_analysis
-            WHERE analyzed_at >= NOW() - INTERVAL '%s hours'
+            WHERE COALESCE(published_at, analyzed_at) >= NOW() - INTERVAL '%s hours'
             GROUP BY hour ORDER BY hour
         """ % hours)
     return [{"hour": str(r["hour"]), "positive": r["pos"],
@@ -537,7 +541,8 @@ async def timeline(hours: int = Query(default=24)):
 async def stock(code: str):
     async with pg_pool.acquire() as c:
         news   = await c.fetch("""
-            SELECT title, sentiment, intensity, reason, source, analyzed_at
+            SELECT title, sentiment, intensity, reason, source,
+                   COALESCE(published_at, analyzed_at) AS analyzed_at
             FROM news_analysis WHERE primary_stock=$1
             ORDER BY analyzed_at DESC LIMIT 20
         """, code)
@@ -766,11 +771,23 @@ async def portfolio_prices(codes: str = Query(default="")):
         except: pass
     async with pg_pool.acquire() as c:
         rows = await c.fetch("""
-            SELECT stock_code, total_score, recommendation, news_score, technical_score
+            SELECT stock_code, total_score, recommendation, news_score, technical_score, sector
             FROM stock_scores
             WHERE stock_code = ANY($1)
               AND score_date = (SELECT MAX(score_date) FROM stock_scores)
         """, code_list)
+        # Redis 가격캐시 미스 시 stock_prices 테이블에서 폴백 (캐시 비어도 손익 계산되게)
+        missing = [x for x in code_list if not price_map.get(x)]
+        if missing:
+            prows = await c.fetch("""
+                SELECT DISTINCT ON (stock_code) stock_code, price, change_pct
+                FROM stock_prices
+                WHERE stock_code = ANY($1) AND price > 0
+                ORDER BY stock_code, collected_at DESC
+            """, missing)
+            for pr in prows:
+                price_map[pr["stock_code"]] = {
+                    "price": pr["price"], "change_pct": float(pr["change_pct"] or 0)}
     score_map = {r["stock_code"]: dict(r) for r in rows}
     result = []
     for code in code_list:
@@ -786,6 +803,7 @@ async def portfolio_prices(codes: str = Query(default="")):
             "signal": ta.get("signal") or "관망",
             "ai_score": sc.get("total_score"),
             "recommendation": sc.get("recommendation"),
+            "sector": sc.get("sector") or "기타",
         })
     return result
 
@@ -1487,6 +1505,17 @@ async def volume_surge():
         except Exception as e:
             return JSONResponse(content={"data": [], "error": str(e)})
 
+
+@app.get("/api/hot")
+async def hot():
+    """지금 뜨는 종목 — 뉴스+거래량 모멘텀 (score-engine /hot 프록시)"""
+    async with httpx.AsyncClient() as c:
+        try:
+            r = await c.get(f"{SCORE_ENGINE_URL}/hot?limit=20", timeout=15)
+            return JSONResponse(content=r.json())
+        except Exception as e:
+            return JSONResponse(content=[], status_code=200)
+
 # ── 사용자 인증 + 포트폴리오 ────────────────────────────────
 
 class RegisterReq(BaseModel):
@@ -2042,12 +2071,39 @@ async def proxy_backtest(days: int = Query(default=180, ge=30, le=720)):
     return await _proxy_get(f"{SCORE_ENGINE_URL}/backtest?days={days}", timeout=30.0)
 
 
+@app.get("/api/portfolio/recommended")
+async def proxy_portfolio_recommended(amount: int = Query(default=0, ge=0)):
+    """AI 추천 포트폴리오 구성 (score-engine /portfolio/recommended)"""
+    return await _proxy_get(
+        f"{SCORE_ENGINE_URL}/portfolio/recommended?amount={amount}", timeout=20.0)
+
+
 @app.get("/api/sector-concentration")
 async def proxy_sector_concentration():
     """섹터 집중도 + 30% 초과 경고 (score-engine /sector/concentration)"""
     return await _proxy_get(f"{SCORE_ENGINE_URL}/sector/concentration")
 
 
+async def _enrich_kr_names(rows):
+    """rows의 kr_code/stock_code에 dart_corps.corp_name을 kr_name으로 첨부"""
+    if not isinstance(rows, list) or not rows:
+        return rows
+    codes = list({(r.get("kr_code") or r.get("stock_code") or "") for r in rows if isinstance(r, dict)})
+    codes = [c for c in codes if c]
+    if not codes:
+        return rows
+    async with pg_pool.acquire() as c:
+        name_rows = await c.fetch(
+            "SELECT stock_code, corp_name FROM dart_corps WHERE stock_code = ANY($1::text[])", codes)
+    name_map = {r["stock_code"]: r["corp_name"] for r in name_rows}
+    for r in rows:
+        if not isinstance(r, dict): continue
+        code = r.get("kr_code") or r.get("stock_code")
+        if code and name_map.get(code):
+            r["kr_name"] = name_map[code]
+    return rows
+
+
 @app.get("/api/usmarket/etfs")
 async def proxy_us_etfs():
     """미국 섹터 ETF 목록"""
@@ -2056,14 +2112,22 @@ async def proxy_us_etfs():
 
 @app.get("/api/usmarket/pairs")
 async def proxy_us_pairs():
-    """KR↔US 페어 + 60일 회귀 베타"""
-    return await _proxy_get(f"{US_MARKET_URL}/pairs")
+    """KR↔US 페어 + 60일 회귀 베타 + 한국 종목명"""
+    rows = await _proxy_get(f"{US_MARKET_URL}/pairs")
+    return await _enrich_kr_names(rows)
 
 
 @app.get("/api/usmarket/signals")
 async def proxy_us_signals():
-    """미증시 동조 시그널 (전체)"""
-    return await _proxy_get(f"{US_MARKET_URL}/signal/latest")
+    """미증시 동조 시그널 (전체) + 한국 종목명"""
+    rows = await _proxy_get(f"{US_MARKET_URL}/signal/latest")
+    return await _enrich_kr_names(rows)
+
+
+@app.get("/api/usmarket/briefing")
+async def proxy_us_briefing():
+    """미증시 새벽 핫/저조 종목 + 관련 KOSPI 추천 (us-market /overnight-briefing)"""
+    return await _proxy_get(f"{US_MARKET_URL}/overnight-briefing")
 
 
 @app.get("/api/macro/ecos")
diff --git a/news-collector/main.py b/news-collector/main.py
index 6a55e78..991638f 100644
--- a/news-collector/main.py
+++ b/news-collector/main.py
@@ -8,13 +8,15 @@
 import asyncio, hashlib, json, os, re, random, time
 import xml.etree.ElementTree as ET
 from datetime import datetime, timedelta
-from typing import Optional
+from typing import Optional, Literal
 import asyncpg, httpx, redis.asyncio as aioredis, structlog
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from bs4 import BeautifulSoup
 from fastapi import FastAPI, Query
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from sentiment_rules import keyword_rule, hallucination_match_ratio
 
 structlog.configure(processors=[
     structlog.processors.TimeStamper(fmt="iso"),
@@ -33,6 +35,94 @@ PG_PASS = os.getenv("POSTGRES_PASSWORD", "7895123")
 BAREUN_URL = os.getenv("BAREUN_API_URL", "http://bareunaapi:5757")
 OLLAMA_URL = os.getenv("OLLAMA_URL", "http://ollama:11434")
 QDRANT_URL = os.getenv("QDRANT_URL", "http://qdrant:6333")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
+GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.5-pro")
+GEMINI_DAILY_LIMIT = int(os.getenv("GEMINI_DAILY_LIMIT", "50"))  # 파싱실패 폴백 포함 일일 한도(비용통제)
+
+
+class _GeminiNewsClf(BaseModel):
+    sentiment: Literal["호재", "악재", "중립"]
+    intensity: int = Field(ge=1, le=5)
+    catalyst: Literal["실적", "수주", "배당", "리스크", "모멘텀", "기타"]
+    reason: str
+    confidence: float = Field(ge=0.0, le=1.0)
+
+
+async def _gemini_news_classify(title: str, content: str, exaone: dict,
+                                 rule: dict) -> tuple[dict, int]:
+    """Gemini 짧은 프롬프트로 뉴스 sentiment 재판정 (애매한 건만).
+    response_schema로 JSON 강제, max_output_tokens=1500.
+    returns: (parsed_dict_or_empty, cost_krw)
+    """
+    if not GEMINI_API_KEY:
+        return {}, 0
+    # === 글로벌 일일 1회 한도 (score-engine과 공유) ===
+    try:
+        async with pg_pool.acquire() as conn:
+            cnt = await conn.fetchval(
+                "SELECT COUNT(*) FROM gemini_call_log WHERE called_at::date = CURRENT_DATE")
+        if cnt and int(cnt) >= GEMINI_DAILY_LIMIT:
+            logger.warning("gemini.daily_limit", source="news_collector", today_count=int(cnt))
+            return {}, 0
+    except Exception as e:
+        logger.warning("gemini.limit_check_err", error=str(e))
+    try:
+        from google import genai
+        from google.genai import types
+        gclient = genai.Client(api_key=GEMINI_API_KEY)
+        system = (
+            "한국 주식 뉴스 한 건의 호재/악재/중립 여부를 판단합니다. "
+            "본문에 명시된 사실만 근거로 하고, 본문에 없는 정보는 절대 지어내지 마세요. "
+            "키워드 카운트와 EXAONE 1차 판단이 충돌하거나 신뢰도가 낮은 경우 호출됩니다."
+        )
+        prompt = (
+            f"[제목]\n{title}\n\n"
+            f"[본문(요약)]\n{(content or '')[:600]}\n\n"
+            f"[EXAONE 1차] {exaone.get('sentiment')}/"
+            f"강도{exaone.get('intensity',0)}/conf{float(exaone.get('confidence',0) or 0):.2f}\n"
+            f"[키워드 카운트] 호재 {rule['pos']} / 악재 {rule['neg']}"
+        )
+        config = types.GenerateContentConfig(
+            system_instruction=system,
+            temperature=0.1,
+            response_mime_type="application/json",
+            response_schema=_GeminiNewsClf,
+            max_output_tokens=1500,
+        )
+        resp = await asyncio.to_thread(
+            gclient.models.generate_content,
+            model=GEMINI_MODEL,
+            contents=prompt,
+            config=config,
+        )
+        text = getattr(resp, "text", "") or ""
+        parsed = {}
+        try:
+            parsed = json.loads(text)
+        except Exception:
+            pass
+        usage = getattr(resp, "usage_metadata", None)
+        cost_krw = 0
+        if usage:
+            in_tok    = getattr(usage, "prompt_token_count", 0) or 0
+            total_tok = getattr(usage, "total_token_count", 0) or 0
+            cand_tok  = getattr(usage, "candidates_token_count", 0) or 0
+            # 출력 전체(candidates + thinking) = total - prompt
+            out_tok = max(total_tok - in_tok, cand_tok)
+            cost_usd = (in_tok / 1_000_000 * 1.25) + (out_tok / 1_000_000 * 10.0)
+            cost_krw = int(cost_usd * 1400)
+        # 일일 한도 카운터 기록
+        try:
+            async with pg_pool.acquire() as conn:
+                await conn.execute(
+                    "INSERT INTO gemini_call_log (source, cost_krw) VALUES ($1, $2)",
+                    "news_collector", cost_krw)
+        except Exception:
+            pass
+        return parsed, cost_krw
+    except Exception as e:
+        logger.warning("news.gemini_err", error=str(e))
+        return {}, 0
 
 HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
 
@@ -42,12 +132,76 @@ scheduler = AsyncIOScheduler(timezone="Asia/Seoul")
 
 class S:
     collected = 0; processed = 0; duplicates = 0; errors = 0
-    noise = 0; off_topic = 0
+    noise = 0; off_topic = 0; stale = 0
     last_run = ""; running = False
 stats = S()
 
 def nhash(title, url=""): return hashlib.sha256(f"{title.strip()}{url.strip()}".encode()).hexdigest()[:16]
 
+
+def _loads_lenient(s: str):
+    """EXAONE 출력에서 JSON 객체를 관대하게 파싱. 실패 시 None.
+    마크다운 펜스 제거 + {..} 추출 + 트레일링 콤마 보정."""
+    if not s:
+        return None
+    s = s.replace("```json", "").replace("```", "").strip()
+    if not s.startswith("{"):
+        sx, ex = s.find("{"), s.rfind("}")
+        if sx != -1 and ex > sx:
+            s = s[sx:ex + 1]
+    try:
+        return json.loads(s)
+    except Exception:
+        pass
+    s2 = re.sub(r",\s*([}\]])", r"\1", s)   # 트레일링 콤마 제거
+    try:
+        return json.loads(s2)
+    except Exception:
+        return None
+
+# ── 출처 신뢰도 (정적 기본값 — score-engine 사후검증이 news_source_credibility 자동 갱신) ──
+# 0.0~1.0. 메이저 통신사·전문지일수록 높음. score-engine이 가격반응 기반으로 자동 보정.
+SOURCE_CREDIBILITY = {
+    "DART공시": 1.00,
+    "연합뉴스": 0.95, "한국경제": 0.92, "매일경제": 0.90, "조선비즈": 0.90,
+    "이데일리": 0.88, "머니투데이": 0.85, "파이낸셜뉴스": 0.85,
+    "서울경제": 0.85, "SBS Biz": 0.85, "더벨": 0.82,
+    "비즈니스포스트": 0.80, "전자신문": 0.80, "인포스탁": 0.78,
+    "헤럴드경제": 0.78, "디지털타임스": 0.75, "뉴스1": 0.78,
+    "뉴시스": 0.75, "이투데이": 0.72, "아시아경제": 0.72,
+    "네이버금융": 0.75, "뉴스핌": 0.70, "글로벌이코노믹": 0.65,
+    "스탁데일리": 0.60, "세계일보": 0.65,
+}
+async def get_source_credibility(source: str) -> float:
+    """static dict + DB 사후 학습 결과 융합. DB에 sample≥20이면 그 값으로 덮어씀."""
+    base = SOURCE_CREDIBILITY.get(source, 0.50)
+    if not pg_pool: return base
+    try:
+        row = await pg_pool.fetchrow(
+            "SELECT credibility, sample_size FROM news_source_credibility WHERE source=$1",
+            source)
+        if row and (row["sample_size"] or 0) >= 20:
+            return float(row["credibility"])
+    except Exception:
+        pass
+    return base
+
+# ── 제목 강도 (제목이 본문 대비 얼마나 강한 신호인지) ──
+_STRONG_TITLE_WORDS = (
+    "폭락","폭등","급락","급등","충격","역대급","쇼크","서프라이즈","어닝",
+    "사상최대","사상최저","신고가","신저가","상한가","하한가","적자전환","흑자전환",
+    "어닝쇼크","어닝서프라이즈","대규모","돌파","무너","급증","급감",
+)
+def measure_title_strength(title: str) -> float:
+    """0.3~1.5. 제목 강조어 ↑ 가중, 추측성("?"·"…")은 감점."""
+    if not title: return 0.5
+    s = 1.0
+    s += 0.10 * sum(1 for w in _STRONG_TITLE_WORDS if w in title)
+    if "!" in title: s += 0.05
+    if title.endswith("?") or "?" in title[-3:]: s -= 0.15
+    if "…" in title or "..." in title: s -= 0.05
+    return max(0.3, min(1.5, s))
+
 def normalize_title(title: str) -> str:
     """[속보][단독](종합) 등 제거 후 특수문자·공백 제거 → 유사 제목 중복 감지용"""
     t = re.sub(r'[\[\(【〔][^\]\)】〕]{0,10}[\]\)】〕]', '', title)
@@ -105,7 +259,6 @@ RSS_SOURCES = [
     ("전자신문",       "https://www.etnews.com/news/latest_news.xml"),
     ("디지털타임스",   "https://www.dt.co.kr/rss/rss_economy.html"),
     ("더벨",           "https://www.thebell.co.kr/free/content/xmlService.asp"),
-    ("스탁데일리",     "https://www.stockdaily.kr/rss/rss.xml"),
     ("세계일보",       "https://www.segye.com/RSS/economyRss.xml"),
     ("SBS Biz",        "https://news.sbs.co.kr/news/SectionRssFeed.do?sectionId=EC"),
 ]
@@ -273,12 +426,26 @@ async def _corp_name(code: str) -> str:
     return nm
 
 
-async def pipeline(item, client):
+async def pipeline(item, client, reprocess: bool = False):
     try:
         # 0. 비주식 카테고리 prefix 차단 (바른API 호출 전)
         if _is_noise_title(item.get("title", "")):
             return "noise"
 
+        # 0.5. published_at이 30일 이상 과거면 차단.
+        # 일부 RSS 사이트가 오래된 기사를 재노출해서 점수 왜곡 유발 → LLM 호출 전에 컷.
+        # 명시적 백필 엔드포인트(/collect/historical-raw)는 별도 경로라 영향 없음.
+        pub_str = item.get("published_at") or ""
+        if pub_str and not item.get("allow_stale"):
+            try:
+                pub_dt = datetime.fromisoformat(pub_str.replace("Z", "+00:00"))
+                # tz-aware 비교를 위해 둘 다 aware로 맞춤
+                now_dt = datetime.now(pub_dt.tzinfo) if pub_dt.tzinfo else datetime.now()
+                if (now_dt - pub_dt).days > 30:
+                    return "stale"
+            except Exception:
+                pass  # 파싱 실패는 정상 진행 (parse_rss_date가 fallback으로 NOW 채움)
+
         # 1. 바른API
         br = await client.post(f"{BAREUN_URL}/analyze", json={
             "title": item["title"], "content": item.get("content",""),
@@ -312,9 +479,36 @@ async def pipeline(item, client):
             sr = await client.post(f"{QDRANT_URL}/collections/news_vectors/points/search",
                 json={"vector":emb,"limit":6,"score_threshold":0.80,"with_payload":True}, timeout=15)
             hits = sr.json().get("result",[])
-            if any(h["score"]>=0.92 for h in hits): return "sim_dup"  # ≥0.99 근접중복도 차단
+            if not reprocess and any(h["score"]>=0.92 for h in hits): return "sim_dup"  # ≥0.99 근접중복도 차단
         except: hits = []
 
+        # 3.1. 사건 클러스터링: 유사도 0.85~0.92 안에 있는 hit이 있으면 그 클러스터로 합류.
+        # 첫 뉴스만 풀 가중, 후속은 score-engine에서 감쇠 (is_event_seed=True 인 것만 큰 신호로).
+        event_cluster_id = ""
+        is_event_seed = True
+        try:
+            for h in hits:
+                if 0.85 <= h.get("score", 0) < 0.92:
+                    pl = h.get("payload", {}) or {}
+                    cid = pl.get("event_cluster_id") or pl.get("hash") or ""
+                    if cid:
+                        event_cluster_id = cid
+                        is_event_seed = False
+                        try:
+                            await pg_pool.execute("""
+                                UPDATE news_event_cluster
+                                SET last_seen_at=NOW(), member_count=member_count+1
+                                WHERE cluster_id=$1
+                            """, cid)
+                        except Exception: pass
+                        break
+            if not event_cluster_id:
+                event_cluster_id = hashlib.sha256(
+                    normalize_title(data["title"]).encode()).hexdigest()[:32]
+        except Exception:
+            event_cluster_id = ""
+            is_event_seed = True
+
         # 3.5. RAG 컨텍스트: 유사 과거뉴스 + 종목 재무·추세·점수 (버핏 판단 근거 주입)
         ctx = []
         rel = [h for h in hits if 0.80 <= h.get("score", 0) < 0.92][:4]
@@ -373,94 +567,232 @@ async def pipeline(item, client):
                 logger.debug("rag.ctx_err", code=focus["code"], error=str(e))
         context_block = "\n".join(ctx)
 
-        # 4. Ollama EXAONE 분석 (버핏 관점 강화 프롬프트)
-        stocks_str = ", ".join([f'{s["name"]}({s["code"]})' for s in data["stocks"][:5]])
-        source = item.get("source", "")
-        content_preview = (data.get("filtered_text") or item.get("content") or "")[:400]
-        system_prompt = (
-            "당신은 워렌 버핏 스타일의 한국 주식 가치투자 애널리스트입니다.\n"
-            "뉴스 한 건을 읽고 기업 본질가치 관점에서 영향을 평가합니다.\n"
-            "판단 우선순위: 기업 본질가치(실적·FCF·경쟁우위) > 재무 리스크 > 단기 수급·테마\n\n"
-            "[sentiment] 호재 / 악재 / 중립 — 본질가치 또는 주가에 미치는 방향\n\n"
-            "[intensity] 1~5 정수\n"
-            " 5=상장폐지·대규모 횡령 등 기업 존폐\n"
-            " 4=연간실적 20% 이상 영향(대형 수주·어닝쇼크 등)\n"
-            " 3=분기실적에 유의미한 영향\n"
-            " 2=영업환경·업황 변화(직접 실적 수치 영향은 제한적)\n"
-            " 1=단순 정보성·정기공시·소폭 코멘트\n\n"
-            "[catalyst] 반드시 아래 6개 중 정확히 하나만 출력 (다른 단어·복합어·영문·한자 절대 금지):\n"
-            ' "실적"  = 영업이익·매출·순이익 증감, 흑자/적자 전환, 어닝 서프라이즈/쇼크, 실적 가이던스\n'
-            ' "수주"  = 신규 수주·공급계약·납품, M&A, 신사업·증설·신제품 등 성장 동인\n'
-            ' "배당"  = 배당 확대/축소, 자사주 매입·소각, 주주환원 정책\n'
-            ' "리스크" = 횡령·배임·소송·감사의견거절·부채급증·유상증자(희석)·경영진 돌발사임·규제/제재·상폐위험\n'
-            ' "모멘텀" = 본질가치 변화 없는 가격 동인(외국인/기관 수급, 목표주가 조정, 테마·정책 기대)\n'
-            ' "기타"  = 위 어디에도 명확히 속하지 않는 정보성 뉴스\n'
-            " 호재/악재면 catalyst를 '기타'로 두지 말고 실적·수주·배당·리스크·모멘텀 중 가장 가까운 것을 고르세요.\n\n"
-            "[참고] 블록은 보조 자료일 뿐 — 본 기사 내용으로 판단하고 과거 감성 흐름에 휩쓸리지 마세요.\n"
-            "동일 내용이 [참고]의 유사 과거뉴스에 반복되면 신규성이 낮으니 intensity를 보수적으로.\n\n"
-            "반드시 스키마에 맞는 유효한 JSON 객체 하나만 출력. 마크다운·설명문 금지."
-        )
-        user_prompt = (
-            f"[출처] {source}\n"
-            f"[제목] {data['title'][:200]}\n"
-            f"[내용] {content_preview}\n"
-            f"[관련종목] {stocks_str or '없음'}\n"
-            + (f"\n[참고]\n{context_block}\n" if context_block else "")
-            + "\ninvestment_action 규칙: 호재+intensity≥3→매수관심, 악재+intensity≥3→매도관심, 그 외→관망\n"
-            "primary_stock은 6자리 숫자코드(시장 전체 뉴스면 빈 문자열), "
-            "affected_stocks는 영향받는 다른 종목코드 배열, reason은 한 문장 핵심 근거.\n\n"
-            "JSON 스키마:\n"
-            '{"sentiment":"호재|악재|중립","intensity":1~5,"primary_stock":"005930",'
-            '"affected_stocks":["000660"],"reason":"핵심 근거 한 문장",'
-            '"investment_action":"매수관심|매도관심|관망",'
-            '"catalyst":"실적|수주|배당|리스크|모멘텀|기타"}\n'
-            "예시: "
-            '{"sentiment":"호재","intensity":4,"primary_stock":"005930",'
-            '"affected_stocks":["000660"],"reason":"HBM 대형 수주 확정으로 연간 반도체 실적 큰 폭 개선 기대",'
-            '"investment_action":"매수관심","catalyst":"수주"}'
-        )
-        # EXAONE 호출 + JSON 파싱 (실패 시 1회 재시도 → ~15% 유실 감소)
-        a = None
-        raw_prev = ""
-        for attempt in range(2):
-            msgs = [{"role":"system","content": system_prompt},
-                    {"role":"user","content": user_prompt}]
-            if attempt == 1:
-                msgs += [{"role":"assistant","content": raw_prev[:600]},
-                         {"role":"user","content":
-                          "위 응답이 유효한 JSON이 아닙니다. 설명·마크다운 없이 "
-                          "스키마에 맞는 JSON 객체 하나만 출력하세요."}]
+        # 3.9. 키워드 룰 1차 판정 — 명확한 호재/악재면 LLM 스킵 (비용 0)
+        rule_text = (data.get("title", "") or "") + " " + (data.get("filtered_text", "") or "")
+        rule = keyword_rule(rule_text)
+        if rule["sentiment"] is not None:
+            # 키워드 룰로 sentiment 확정 — LLM 스킵 (비용 0)
+            primary = (data["stocks"][0]["code"] if data["stocks"] else "")
+            affected = [s["code"] for s in data["stocks"][1:5]]
+            investment = ("매수관심" if rule["sentiment"] == "호재" and rule["intensity"] >= 3
+                          else "매도관심" if rule["sentiment"] == "악재" and rule["intensity"] >= 3
+                          else "관망")
+            hits = rule["pos_hits"] if rule["sentiment"] == "호재" else rule["neg_hits"]
+            stock_impacts = {primary: 1.0} if primary else {}
+            for c in affected:
+                stock_impacts[c] = 0.5
+            a = {
+                "sentiment": rule["sentiment"], "intensity": rule["intensity"],
+                "primary_stock": primary, "affected_stocks": affected,
+                "reason": f"키워드 룰 매칭: {'/'.join(hits)}"[:500],
+                "investment_action": investment,
+                "catalyst": rule["catalyst"],
+                "time_horizon": "단기", "impact_scope": "종목",
+                "confidence": 1.0, "stock_impacts": stock_impacts,
+                "sector_hint": "",
+            }
+            llm_conf = 1.0
+            logger.info("news.path", path="rule", sentiment=rule["sentiment"],
+                        pos=rule["pos"], neg=rule["neg"], hits=hits[:3])
+        else:
+            # 4. Ollama EXAONE 분석 (버핏 관점 + 라벨 세분화) — 키워드 룰 애매 케이스
+            stocks_str = ", ".join([f'{s["name"]}({s["code"]})' for s in data["stocks"][:5]])
+            source = item.get("source", "")
+            content_preview = (data.get("filtered_text") or item.get("content") or "")[:400]
+            system_prompt = (
+                "당신은 워렌 버핏 스타일의 한국 주식 가치투자 애널리스트입니다.\n"
+                "뉴스 한 건을 읽고 기업 본질가치 관점에서 영향을 평가합니다.\n"
+                "판단 우선순위: 기업 본질가치(실적·FCF·경쟁우위) > 재무 리스크 > 단기 수급·테마\n\n"
+                "[sentiment] 호재 / 악재 / 중립 — 본질가치 또는 주가에 미치는 방향\n\n"
+                "[intensity] 1~5 정수\n"
+                " 5=상장폐지·대규모 횡령 등 기업 존폐\n"
+                " 4=연간실적 20% 이상 영향(대형 수주·어닝쇼크 등)\n"
+                " 3=분기실적에 유의미한 영향\n"
+                " 2=영업환경·업황 변화(직접 실적 수치 영향은 제한적)\n"
+                " 1=단순 정보성·정기공시·소폭 코멘트\n\n"
+                "[catalyst] 반드시 아래 6개 중 정확히 하나만 출력 (다른 단어·복합어·영문·한자 절대 금지):\n"
+                ' "실적"  = 영업이익·매출·순이익 증감, 흑자/적자 전환, 어닝 서프라이즈/쇼크, 실적 가이던스\n'
+                ' "수주"  = 신규 수주·공급계약·납품, M&A, 신사업·증설·신제품 등 성장 동인\n'
+                ' "배당"  = 배당 확대/축소, 자사주 매입·소각, 주주환원 정책\n'
+                ' "리스크" = 횡령·배임·소송·감사의견거절·부채급증·유상증자(희석)·경영진 돌발사임·규제/제재·상폐위험\n'
+                ' "모멘텀" = 본질가치 변화 없는 가격 동인(외국인/기관 수급, 목표주가 조정, 테마·정책 기대)\n'
+                ' "기타"  = 위 어디에도 명확히 속하지 않는 정보성 뉴스\n'
+                " 호재/악재면 catalyst를 '기타'로 두지 말고 실적·수주·배당·리스크·모멘텀 중 가장 가까운 것을 고르세요.\n\n"
+                "[time_horizon] 영향이 발현되는 시간프레임\n"
+                ' "즉시" = 당일~3일 내 주가 반응 (수주공시·실적 발표·대형 사건)\n'
+                ' "단기" = 1~4주 (분기실적·수급 변화·일시적 모멘텀)\n'
+                ' "중기" = 1~6개월 (업황·정책 변화·신제품 출시 효과)\n'
+                ' "장기" = 6개월 이상 (구조적 변화·신사업 본격화·체질개선)\n\n'
+                "[impact_scope] 영향 받는 대상 범위\n"
+                ' "종목" = 특정 종목(들)에만 영향\n'
+                ' "섹터" = 동일 업종/테마 전체 영향 (예: 반도체 업황·2차전지 정책)\n'
+                ' "시장" = 코스피/코스닥 전체 또는 매크로 (금리·환율·지정학)\n\n'
+                "[stock_impacts] {종목코드: 영향가중치 0~1} 매핑. primary_stock=1.0, 보조 종목은 0.3~0.8.\n"
+                "  affected_stocks와 일치하는 모든 종목에 가중치를 매김. 단일 종목이면 {primary:1.0}.\n\n"
+                "[sector_hint] 관련 업종 한 단어 (예: 반도체, 2차전지, 바이오, 조선, 방산, 자동차, 금융,\n"
+                "  통신, 화학, 철강, 건설, 유통, AI, 로봇, 게임, 미디어, 에너지, 정유, 기타).\n\n"
+                "[confidence] 0.0~1.0 — 본인 판단의 신뢰도. 사실/숫자가 명확하면 0.8+, 추측·소문이면 0.3-0.5,\n"
+                "  맥락 부족·해석 모호하면 0.5 이하. 정직하게 평가하세요.\n\n"
+                "[참고] 블록은 보조 자료일 뿐 — 본 기사 내용으로 판단하고 과거 감성 흐름에 휩쓸리지 마세요.\n"
+                "동일 내용이 [참고]의 유사 과거뉴스에 반복되면 신규성이 낮으니 intensity를 보수적으로.\n\n"
+                "반드시 스키마에 맞는 유효한 JSON 객체 하나만 출력. 마크다운·설명문 금지."
+            )
+            user_prompt = (
+                f"[출처] {source}\n"
+                f"[제목] {data['title'][:200]}\n"
+                f"[내용] {content_preview}\n"
+                f"[관련종목] {stocks_str or '없음'}\n"
+                + (f"\n[참고]\n{context_block}\n" if context_block else "")
+                + "\ninvestment_action 규칙: 호재+intensity≥3→매수관심, 악재+intensity≥3→매도관심, 그 외→관망\n"
+                "primary_stock은 6자리 숫자코드(시장 전체 뉴스면 빈 문자열), "
+                "affected_stocks는 영향받는 다른 종목코드 배열.\n\n"
+                "JSON 스키마:\n"
+                '{"sentiment":"호재|악재|중립","intensity":1~5,"primary_stock":"005930",'
+                '"affected_stocks":["000660"],"stock_impacts":{"005930":1.0,"000660":0.5},'
+                '"reason":"핵심 근거 한 문장",'
+                '"investment_action":"매수관심|매도관심|관망",'
+                '"catalyst":"실적|수주|배당|리스크|모멘텀|기타",'
+                '"time_horizon":"즉시|단기|중기|장기","impact_scope":"종목|섹터|시장",'
+                '"sector_hint":"반도체|2차전지|바이오|조선|방산|자동차|금융|통신|화학|철강|건설|유통|AI|로봇|게임|미디어|에너지|정유|기타",'
+                '"confidence":0.85}\n'
+                "예시: "
+                '{"sentiment":"호재","intensity":4,"primary_stock":"005930",'
+                '"affected_stocks":["000660"],"stock_impacts":{"005930":1.0,"000660":0.6},'
+                '"reason":"HBM 대형 수주 확정으로 연간 반도체 실적 큰 폭 개선 기대",'
+                '"investment_action":"매수관심","catalyst":"수주",'
+                '"time_horizon":"중기","impact_scope":"섹터",'
+                '"sector_hint":"반도체","confidence":0.85}'
+            )
+            # EXAONE 호출 + JSON 파싱 (1차 정상, 2차 파싱실패/저신뢰 재시도)
+            a = None
+            raw_prev = ""
+            for attempt in range(2):
+                msgs = [{"role":"system","content": system_prompt},
+                        {"role":"user","content": user_prompt}]
+                if attempt == 1:
+                    hint = ("위 응답이 유효한 JSON이 아니거나 신뢰도가 낮습니다. "
+                            "설명·마크다운 없이 스키마에 맞는 JSON 객체 하나만 출력하고, "
+                            "확실하지 않으면 sentiment='중립', intensity=1로 보수적으로 표기하세요.")
+                    msgs += [{"role":"assistant","content": raw_prev[:600]},
+                             {"role":"user","content": hint}]
+                try:
+                    vr = await client.post(f"{OLLAMA_URL}/v1/chat/completions", json={
+                        "model":"exaone3.5:7.8b","messages": msgs,
+                        "max_tokens":800,"temperature":0.0 if attempt else 0.05},
+                        timeout=120)
+                    raw_prev = vr.json()["choices"][0]["message"]["content"]
+                    cand = _loads_lenient(raw_prev)
+                    if cand is None:
+                        continue
+                    conf = float(cand.get("confidence", 0.5) or 0.5)
+                    if attempt == 0 and conf < 0.40 and cand.get("sentiment") in ("호재","악재") \
+                            and int(cand.get("intensity", 0) or 0) >= 3:
+                        a = cand
+                        continue
+                    a = cand
+                    break
+                except Exception:
+                    continue
+            if a is None:
+                a = {"sentiment":"중립","intensity":0,"primary_stock":"","affected_stocks":[],
+                     "reason":"파싱실패","investment_action":"관망","confidence":0.0}
+            # enum 강제 / confidence clamp / stock_impacts 정합
+            if a.get("catalyst") not in ("실적","수주","배당","리스크","모멘텀","기타"):
+                a["catalyst"] = "기타"
+            if a.get("time_horizon") not in ("즉시","단기","중기","장기"):
+                a["time_horizon"] = "단기"
+            if a.get("impact_scope") not in ("종목","섹터","시장"):
+                a["impact_scope"] = "종목"
             try:
-                vr = await client.post(f"{OLLAMA_URL}/v1/chat/completions", json={
-                    "model":"exaone3.5:7.8b","messages": msgs,
-                    "max_tokens":400,"temperature":0.0 if attempt else 0.05},
-                    timeout=120)
-                raw_prev = vr.json()["choices"][0]["message"]["content"]
-                c = raw_prev.replace("```json","").replace("```","").strip()
-                if not c.startswith("{"):           # 앞뒤 설명 제거
-                    s, e = c.find("{"), c.rfind("}")
-                    if s != -1 and e > s: c = c[s:e+1]
-                a = json.loads(c)
-                break
+                llm_conf = max(0.0, min(1.0, float(a.get("confidence", 0.5) or 0.5)))
             except Exception:
-                continue
-        if a is None:
-            a = {"sentiment":"중립","intensity":0,"primary_stock":"","affected_stocks":[],"reason":"파싱실패","investment_action":"관망"}
+                llm_conf = 0.5
+            if a.get("reason") == "파싱실패":
+                llm_conf = 0.0
+            si = a.get("stock_impacts")
+            if not isinstance(si, dict): si = {}
+            ps = a.get("primary_stock") or ""
+            if ps and ps not in si: si[ps] = 1.0
+            for c in (a.get("affected_stocks") or []):
+                if c and c not in si: si[c] = 0.5
+            si = {k: max(0.0, min(1.0, float(v or 0)))
+                  for k, v in si.items() if k and isinstance(k, str) and len(k) <= 10}
+            a["stock_impacts"] = si
 
-        # catalyst 6개 enum 강제 (score-engine CATALYST_WEIGHTS 정합 — 일탈값은 '기타')
-        if a.get("catalyst") not in ("실적","수주","배당","리스크","모멘텀","기타"):
-            a["catalyst"] = "기타"
+            # === 환각 / 키워드 충돌 검증 → 필요 시 Gemini fallback ===
+            # 임계값을 보수적으로 (Gemini 과호출 방지 — Pro thinking 비용 큼)
+            halluc = hallucination_match_ratio(a.get("reason", ""), rule_text)
+            conflict = ((rule["pos"] >= 2 and a.get("sentiment") == "악재") or
+                        (rule["neg"] >= 2 and a.get("sentiment") == "호재"))
+            sent_strong = (a.get("sentiment") in ("호재", "악재")
+                           and int(a.get("intensity") or 0) >= 4)  # 4→매우 강한 시그널만
+            parse_failed = (a.get("reason") == "파싱실패")
+            need_gem = (parse_failed                      # EXAONE 파싱실패 → Gemini 재판정(중립 방치 대신)
+                        or (sent_strong and llm_conf < 0.4)  # 0.6→0.4 (정말 저신뢰만)
+                        or halluc < 0.25                  # 0.5→0.25 (명백한 환각만)
+                        or conflict)
+            if need_gem and GEMINI_API_KEY:
+                gem, gem_cost = await _gemini_news_classify(
+                    data.get("title", ""), content_preview,
+                    {"sentiment": a.get("sentiment"),
+                     "intensity": a.get("intensity"),
+                     "confidence": llm_conf}, rule)
+                if gem:
+                    a["sentiment"] = gem.get("sentiment", a["sentiment"])
+                    try:
+                        a["intensity"] = int(gem.get("intensity", a["intensity"]) or a["intensity"])
+                    except Exception:
+                        pass
+                    if gem.get("catalyst") in ("실적","수주","배당","리스크","모멘텀","기타"):
+                        a["catalyst"] = gem["catalyst"]
+                    a["reason"] = f"[Gemini검증] {gem.get('reason','')}"[:500]
+                    try:
+                        llm_conf = float(gem.get("confidence", llm_conf) or llm_conf)
+                    except Exception:
+                        pass
+                    a["investment_action"] = (
+                        "매수관심" if a["sentiment"] == "호재" and (a.get("intensity") or 0) >= 3
+                        else "매도관심" if a["sentiment"] == "악재" and (a.get("intensity") or 0) >= 3
+                        else "관망"
+                    )
+                    logger.info("news.path", path="gemini", final=a["sentiment"],
+                                halluc=round(halluc, 2), conflict=conflict,
+                                cost_krw=gem_cost)
+                else:
+                    logger.info("news.path", path="exaone_lowconf",
+                                halluc=round(halluc, 2), conflict=conflict,
+                                conf=round(llm_conf, 2))
+            else:
+                logger.info("news.path", path="exaone",
+                            sentiment=a.get("sentiment"),
+                            conf=round(llm_conf, 2), halluc=round(halluc, 2))
 
-        # 5. Qdrant 저장
+        # 파싱실패 복구분: EXAONE/Gemini는 종목을 안 주므로(스키마 없음), 바른 감지 종목으로
+        # primary_stock·stock_impacts 채움 — 안 그러면 score-engine 뉴스점수에 안 잡힘.
+        if parse_failed and not a.get("primary_stock") and not a.get("stock_impacts"):
+            _codes = [st["code"] for st in data.get("stocks", []) if st.get("code")]
+            if _codes:
+                _w = 1.0 if len(_codes) == 1 else 0.6
+                a["primary_stock"] = _codes[0]
+                a["stock_impacts"] = {c: _w for c in _codes[:5]}
+
+        # 출처 신뢰도 + 제목 강도 (분석 후 DB INSERT 직전에 계산)
+        src_cred = await get_source_credibility(item.get("source", ""))
+        title_str = measure_title_strength(data["title"])
+
+        # 5. Qdrant 저장 (event_cluster_id 포함 — 다음 뉴스의 클러스터 매칭에 사용)
         try:
             await client.put(f"{QDRANT_URL}/collections/news_vectors/points", json={
                 "points":[{"id":random.randint(1,999999999),"vector":emb,
                     "payload":{"title":data["title"],"hash":data["hash"],
                                "sentiment":a.get("sentiment",""),"intensity":a.get("intensity",0),
-                               "primary_stock":a.get("primary_stock","")}}]}, timeout=15)
+                               "primary_stock":a.get("primary_stock",""),
+                               "event_cluster_id": event_cluster_id,
+                               "catalyst": a.get("catalyst", "기타"),
+                               "time_horizon": a.get("time_horizon","단기")}}]}, timeout=15)
         except: pass
 
-        # 6. PostgreSQL 저장 (파라미터 바인딩 — 인젝션·이스케이프 유실 방지)
+        # 6. PostgreSQL 저장
         pub = data.get("published_at") or ""
         try:
             pub_dt = datetime.fromisoformat(pub.replace("Z", "+00:00")) if pub else datetime.now()
@@ -474,8 +806,11 @@ async def pipeline(item, client):
         await pg_pool.execute("""
             INSERT INTO news_analysis (title,url,source,published_at,hash,sentiment,intensity,
                 primary_stock,affected_stocks,reason,investment_action,keywords,stock_names,stock_codes,
-                catalyst,similar_count,analyzed_at)
-            VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10,$11,$12::jsonb,$13::jsonb,$14::jsonb,$15,0,NOW())
+                catalyst,similar_count,analyzed_at,
+                time_horizon,impact_scope,llm_confidence,source_credibility,title_strength,
+                stock_impacts,event_cluster_id,is_event_seed,sector_hint)
+            VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9::jsonb,$10,$11,$12::jsonb,$13::jsonb,$14::jsonb,$15,0,NOW(),
+                $16,$17,$18,$19,$20,$21::jsonb,$22,$23,$24)
             ON CONFLICT (hash) DO NOTHING
         """,
             s(data.get("title"))[:500], s(data.get("url"))[:500], s(data.get("source"))[:100],
@@ -485,7 +820,26 @@ async def pipeline(item, client):
             json.dumps(data.get("keywords", [])[:20], ensure_ascii=False),
             json.dumps([s_["name"] for s_ in data.get("stocks", [])], ensure_ascii=False),
             json.dumps([s_["code"] for s_ in data.get("stocks", [])], ensure_ascii=False),
-            s(a.get("catalyst", "기타"))[:20])
+            s(a.get("catalyst", "기타"))[:20],
+            s(a.get("time_horizon","단기"))[:10],
+            s(a.get("impact_scope","종목"))[:10],
+            llm_conf, src_cred, title_str,
+            json.dumps(a.get("stock_impacts", {}), ensure_ascii=False),
+            event_cluster_id[:32], is_event_seed,
+            s(a.get("sector_hint",""))[:40])
+
+        # 이벤트 클러스터 시드 등록 (첫 뉴스만)
+        if is_event_seed and event_cluster_id:
+            try:
+                await pg_pool.execute("""
+                    INSERT INTO news_event_cluster (cluster_id, member_count,
+                        seed_sentiment, seed_intensity, seed_catalyst)
+                    VALUES ($1, 1, $2, $3, $4)
+                    ON CONFLICT (cluster_id) DO NOTHING
+                """, event_cluster_id[:32], s(a.get("sentiment","중립"))[:10], iv,
+                    s(a.get("catalyst","기타"))[:20])
+            except Exception: pass
+
         return "ok"
     except Exception as e:
         logger.warning("pipeline.err", title=item.get("title","")[:50], error=str(e))
@@ -511,6 +865,8 @@ async def job_rss():
                     stats.processed += 1
                 elif r == "noise":
                     stats.noise += 1
+                elif r == "stale":
+                    stats.stale += 1
                 elif r == "off_topic":
                     stats.off_topic += 1
             stats.last_run = datetime.now().isoformat()
@@ -655,7 +1011,7 @@ async def job_historical_raw(count: int = 0, max_pages: int = 100):
         stats.running = False
 
 
-async def job_process_raw(batch_size: int = 200):
+async def job_process_raw(batch_size: int = 200, reprocess: bool = False):
     """news_raw의 미처리 행을 batch_size만큼 EXAONE 분석 → news_analysis로 이동.
     OLLAMA_NUM_PARALLEL=4와 매칭되는 4-동시 병렬 처리."""
     async with pg_pool.acquire() as conn:
@@ -680,11 +1036,11 @@ async def job_process_raw(batch_size: int = 200):
                     "stock_code": r["stock_code"],
                 }
                 try:
-                    if await is_dup(item["title"], item["url"]):
+                    if not reprocess and await is_dup(item["title"], item["url"]):
                         stats.duplicates += 1
                     else:
                         stats.collected += 1
-                        res = await pipeline(item, c)
+                        res = await pipeline(item, c, reprocess=reprocess)
                         if res == "ok": ok += 1; stats.processed += 1
                         elif res == "noise": stats.noise += 1
                         elif res == "off_topic": stats.off_topic += 1
@@ -741,6 +1097,7 @@ async def job_historical(count: int = 500, max_pages: int = 20):
                         if r == "ok":
                             ok += 1; stats.processed += 1
                         elif r == "noise": stats.noise += 1
+                        elif r == "stale": stats.stale += 1
                         elif r == "off_topic": stats.off_topic += 1
                     if (i + 1) % 50 == 0:
                         logger.info("historical.progress", done=i+1, of=len(codes),
@@ -774,6 +1131,8 @@ async def job_market():
                     stats.processed += 1
                 elif r == "noise":
                     stats.noise += 1
+                elif r == "stale":
+                    stats.stale += 1
                 elif r == "off_topic":
                     stats.off_topic += 1
             stats.last_run = datetime.now().isoformat()
@@ -817,8 +1176,8 @@ async def startup():
     pg_pool = await asyncpg.create_pool(host=PG_HOST,port=PG_PORT,database=PG_DB,user=PG_USER,password=PG_PASS,min_size=2,max_size=5)
     redis_cl = aioredis.Redis(host=REDIS_HOST,port=6379,password=REDIS_PASSWORD,db=4,decode_responses=True)
     await init_news_tables()
-    # 평일 RSS: 8-18시 5분마다
-    scheduler.add_job(job_rss,"cron",day_of_week="mon-fri",hour="8-18",minute="*/5",id="rss_weekday",replace_existing=True)
+    # 평일 RSS: 8-18시 2분마다 (자동매매 latency 단축)
+    scheduler.add_job(job_rss,"cron",day_of_week="mon-fri",hour="8-18",minute="*/2",id="rss_weekday",replace_existing=True)
     # 주말 RSS: 8-22시 15분마다 (누적 학습용)
     scheduler.add_job(job_rss,"cron",day_of_week="sat,sun",hour="8-22",minute="*/15",id="rss_weekend",replace_existing=True)
     # 평일 마켓 (네이버 금융): 9-17시 10분마다
@@ -831,6 +1190,11 @@ async def startup():
     scheduler.add_job(job_historical_raw,"cron",day_of_week="sun",hour="2",minute="0",
                       id="historical_raw_weekly",replace_existing=True,
                       kwargs={"count":0,"max_pages":50})
+    # 평일 18:30 전 종목 "최신 1페이지" 스위프 — RSS/마켓메인에 안 잡히는 중형주
+    # 신선뉴스가 주1회 백필까지 누락되던 사각지대 해소 (전 종목×1페이지 ≈ 25분)
+    scheduler.add_job(job_historical_raw,"cron",day_of_week="mon-fri",hour="18",minute="30",
+                      id="fresh_stock_sweep",replace_existing=True,
+                      kwargs={"count":0,"max_pages":1})
     scheduler.start()
     logger.info("news-collector.started", sources=len(RSS_SOURCES))
 
@@ -866,9 +1230,10 @@ async def m_historical_raw(count: int = 0, max_pages: int = 100):
     return {"status":"started","type":"historical_raw","count":count or "전체","max_pages":max_pages}
 
 @app.post("/process/raw")
-async def m_process_raw(batch_size: int = 200):
-    """news_raw 미처리분 batch 분석 → news_analysis로 이동"""
-    n = await job_process_raw(batch_size)
+async def m_process_raw(batch_size: int = 200, reprocess: bool = False):
+    """news_raw 미처리분 batch 분석 → news_analysis로 이동.
+    reprocess=true: is_dup·Qdrant sim_dup 우회 (파싱실패 복구 재분석용)."""
+    n = await job_process_raw(batch_size, reprocess=reprocess)
     return {"status":"done","processed":n}
 
 @app.get("/raw/stats")
diff --git a/score-engine/main.py b/score-engine/main.py
index 55ee935..8268ec3 100644
--- a/score-engine/main.py
+++ b/score-engine/main.py
@@ -8,9 +8,10 @@
 - 가치 필터: PER 0~40, 부채비율<80%, 영업이익>0, 시총>100억
 - 매일 장 마감 후 자동 집계 + 텔레그램 알림
 """
-import asyncio, json, os
+import asyncio, json, os, pickle
 from datetime import datetime, date, timedelta, timezone
-from typing import Optional
+from typing import Optional, Literal
+from pydantic import BaseModel, Field
 import asyncpg, httpx, redis.asyncio as aioredis, structlog
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from fastapi import FastAPI, Query
@@ -35,6 +36,8 @@ TG_TOKEN        = os.getenv("TELEGRAM_BOT_TOKEN", "")
 TG_CHAT_ID      = os.getenv("TELEGRAM_CHAT_ID", "")
 OLLAMA_URL      = os.getenv("OLLAMA_URL", "http://ollama:11434")
 EXAONE_MODEL    = os.getenv("EXAONE_MODEL", "exaone3.5:7.8b")
+GEMINI_API_KEY  = os.getenv("GEMINI_API_KEY", "")
+GEMINI_MODEL    = os.getenv("GEMINI_MODEL", "gemini-2.5-pro")
 
 pg_pool: Optional[asyncpg.Pool] = None
 redis_cl: Optional[aioredis.Redis] = None
@@ -42,18 +45,29 @@ scheduler = AsyncIOScheduler(timezone="Asia/Seoul")
 
 # ── 텔레그램 알림 ──────────────────────────────────────────
 
-async def send_telegram(msg: str):
+async def send_telegram(msg: str, reply_markup: dict | None = None):
     if not TG_TOKEN or not TG_CHAT_ID:
         return
     try:
+        payload = {"chat_id": TG_CHAT_ID, "text": msg, "parse_mode": "HTML"}
+        if reply_markup:
+            payload["reply_markup"] = reply_markup
         async with httpx.AsyncClient() as c:
             await c.post(
                 f"https://api.telegram.org/bot{TG_TOKEN}/sendMessage",
-                json={"chat_id": TG_CHAT_ID, "text": msg, "parse_mode": "HTML"},
-                timeout=10)
+                json=payload, timeout=10)
     except Exception as e:
         logger.warning("telegram.err", error=str(e))
 
+
+def order_inline_buttons(order_id: int, side: str = "buy") -> dict:
+    """주문 confirm/cancel inline 버튼 — 매수/매도 라벨 분리."""
+    confirm_label = "✅ 매수 실행" if side == "buy" else "✅ 매도 실행"
+    return {"inline_keyboard": [[
+        {"text": confirm_label, "callback_data": f"confirm:{order_id}"},
+        {"text": "❌ 취소",      "callback_data": f"cancel:{order_id}"},
+    ]]}
+
 # ── DB 초기화 ─────────────────────────────────────────────
 
 async def init_db():
@@ -172,6 +186,47 @@ async def init_db():
         """)
         await conn.execute(
             "CREATE INDEX IF NOT EXISTS idx_deep_date ON deep_analysis(analysis_date DESC)")
+        # 사용자 보유 포트폴리오 — 기존 테이블에 active 컬럼만 보강
+        await conn.execute("""
+            CREATE TABLE IF NOT EXISTS user_portfolio (
+                id          SERIAL PRIMARY KEY,
+                user_id     INTEGER NOT NULL DEFAULT 1,
+                stock_code  VARCHAR(10) NOT NULL,
+                stock_name  VARCHAR(100) NOT NULL DEFAULT '',
+                buy_price   INTEGER NOT NULL,
+                qty         INTEGER NOT NULL DEFAULT 1,
+                memo        TEXT DEFAULT '',
+                created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+                updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+            )
+        """)
+        await conn.execute(
+            "ALTER TABLE user_portfolio ADD COLUMN IF NOT EXISTS active BOOLEAN DEFAULT true")
+    # Phase 4: 자동매매 테이블 (trading_orders, trading_daily_pnl)
+    await ensure_trading_tables()
+    async with pg_pool.acquire() as conn:
+        # 하이브리드 검증 + 라벨링 컬럼 (EXAONE + Gemini 둘 다 저장 + 사후검증)
+        for col, typ in [
+            ("gemini_recommendation", "VARCHAR(20)"),
+            ("gemini_conviction",     "INTEGER DEFAULT 0"),
+            ("gemini_thesis",         "TEXT DEFAULT ''"),
+            ("gemini_target_price",   "BIGINT DEFAULT 0"),
+            ("gemini_stop_loss",      "BIGINT DEFAULT 0"),
+            ("gemini_report",         "JSONB DEFAULT '{}'::jsonb"),
+            ("agreement",             "BOOLEAN"),
+            ("llm_cost_krw",          "INTEGER DEFAULT 0"),
+            # 라벨링: Gemini 답을 학습용 정답(pseudo-ground-truth)으로 보관
+            ("training_label",        "VARCHAR(20)"),     # Gemini 답 복사 (학습 정답)
+            ("entry_price",           "INTEGER DEFAULT 0"),
+            # 사후 검증 (30일 후 실제 수익률 측정)
+            ("realized_price_30d",    "INTEGER"),
+            ("realized_return_30d",   "DOUBLE PRECISION"),
+            ("gemini_correct",        "BOOLEAN"),         # 30d 수익률 vs Gemini 판단
+            ("exaone_correct",        "BOOLEAN"),         # 30d 수익률 vs EXAONE 판단
+            ("verified_at",           "TIMESTAMP"),
+        ]:
+            await conn.execute(
+                f"ALTER TABLE deep_analysis ADD COLUMN IF NOT EXISTS {col} {typ}")
 
         await conn.execute("""
             CREATE TABLE IF NOT EXISTS recommendation_performance (
@@ -234,6 +289,130 @@ async def init_db():
                 created_at TIMESTAMP DEFAULT NOW()
             )
         """)
+        # 레짐/섹터 분리 학습용 segment 컬럼 + 복합 PK
+        try:
+            await conn.execute(
+                "ALTER TABLE weight_config ADD COLUMN IF NOT EXISTS segment VARCHAR(40) DEFAULT 'all'")
+            await conn.execute("ALTER TABLE weight_config DROP CONSTRAINT IF EXISTS weight_config_pkey")
+            await conn.execute(
+                "ALTER TABLE weight_config ADD CONSTRAINT weight_config_pkey PRIMARY KEY (config_date, segment)")
+        except Exception:
+            pass
+
+        # ─── 감성평가 보강: news_analysis 신규 컬럼 ────────────
+        for col in [
+            "time_horizon VARCHAR(10) DEFAULT '단기'",      # 즉시/단기/중기/장기
+            "impact_scope VARCHAR(10) DEFAULT '종목'",        # 종목/섹터/시장
+            "llm_confidence FLOAT DEFAULT 0.5",              # 0~1
+            "source_credibility FLOAT DEFAULT 0.5",          # 0~1
+            "title_strength FLOAT DEFAULT 1.0",              # 본문 대비 제목 강도
+            "stock_impacts JSONB DEFAULT '{}'::jsonb",       # {code:weight}
+            "event_cluster_id VARCHAR(32) DEFAULT ''",
+            "is_event_seed BOOLEAN DEFAULT FALSE",           # 사건 첫 뉴스 여부
+            "sector_hint VARCHAR(40) DEFAULT ''",
+        ]:
+            try:
+                await conn.execute(f"ALTER TABLE news_analysis ADD COLUMN IF NOT EXISTS {col}")
+            except Exception:
+                pass
+        try:
+            await conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_news_cluster ON news_analysis(event_cluster_id)")
+            await conn.execute(
+                "CREATE INDEX IF NOT EXISTS idx_news_time_horizon ON news_analysis(time_horizon)")
+        except Exception:
+            pass
+
+        # 출처별 신뢰도 (자동 갱신)
+        await conn.execute("""
+            CREATE TABLE IF NOT EXISTS news_source_credibility (
+                source VARCHAR(100) PRIMARY KEY,
+                credibility FLOAT DEFAULT 0.5,
+                sample_size INTEGER DEFAULT 0,
+                hit_ratio_3d FLOAT DEFAULT NULL,
+                avg_signed_return_3d FLOAT DEFAULT NULL,
+                last_updated TIMESTAMP DEFAULT NOW()
+            )
+        """)
+
+        # catalyst × time_horizon 별 사후 신뢰도
+        await conn.execute("""
+            CREATE TABLE IF NOT EXISTS sentiment_reliability (
+                catalyst VARCHAR(20) NOT NULL,
+                time_horizon VARCHAR(10) NOT NULL,
+                sample_size INTEGER DEFAULT 0,
+                avg_return_3d FLOAT DEFAULT NULL,
+                avg_return_7d FLOAT DEFAULT NULL,
+                hit_ratio_3d FLOAT DEFAULT NULL,
+                reliability_score FLOAT DEFAULT 1.0,
+                last_updated TIMESTAMP DEFAULT NOW(),
+                PRIMARY KEY (catalyst, time_horizon)
+            )
+        """)
+
+        # 사건 클러스터 메타 (중복/재유포 트래킹)
+        await conn.execute("""
+            CREATE TABLE IF NOT EXISTS news_event_cluster (
+                cluster_id VARCHAR(32) PRIMARY KEY,
+                first_seen_at TIMESTAMP DEFAULT NOW(),
+                last_seen_at TIMESTAMP DEFAULT NOW(),
+                member_count INTEGER DEFAULT 1,
+                seed_sentiment VARCHAR(10) DEFAULT '중립',
+                seed_intensity INTEGER DEFAULT 0,
+                seed_catalyst VARCHAR(20) DEFAULT '기타'
+            )
+        """)
+
+        # 학습 모델 평가지표 (walk-forward CV 결과)
+        await conn.execute("""
+            CREATE TABLE IF NOT EXISTS model_metrics (
+                id SERIAL PRIMARY KEY,
+                model_date DATE NOT NULL,
+                model_type VARCHAR(40) NOT NULL,
+                segment VARCHAR(40) DEFAULT 'all',
+                target VARCHAR(20) DEFAULT 'return_30d',
+                period_days INTEGER DEFAULT 0,
+                sample_size INTEGER DEFAULT 0,
+                n_folds INTEGER DEFAULT 0,
+                ic_spearman FLOAT DEFAULT NULL,
+                ic_pearson FLOAT DEFAULT NULL,
+                hit_ratio FLOAT DEFAULT NULL,
+                top_decile_spread FLOAT DEFAULT NULL,
+                sharpe_proxy FLOAT DEFAULT NULL,
+                r2_oos FLOAT DEFAULT NULL,
+                mae FLOAT DEFAULT NULL,
+                feature_importance JSONB DEFAULT '{}'::jsonb,
+                created_at TIMESTAMP DEFAULT NOW()
+            )
+        """)
+        await conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_mm_date ON model_metrics(model_date DESC)")
+        await conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_mm_segment ON model_metrics(segment, model_type)")
+
+        # 학습 모델 가중치 본체 (피처 확장 + 레짐/섹터 분리 지원)
+        await conn.execute("""
+            CREATE TABLE IF NOT EXISTS pricing_model_v2 (
+                id SERIAL PRIMARY KEY,
+                model_date DATE NOT NULL,
+                segment VARCHAR(40) DEFAULT 'all',
+                model_type VARCHAR(20) NOT NULL,
+                target VARCHAR(20) DEFAULT 'return_30d',
+                feature_names JSONB DEFAULT '[]'::jsonb,
+                feature_importance JSONB DEFAULT '{}'::jsonb,
+                coef JSONB DEFAULT '{}'::jsonb,
+                intercept FLOAT DEFAULT 0,
+                r2_oos FLOAT DEFAULT NULL,
+                ic_spearman FLOAT DEFAULT NULL,
+                hit_ratio FLOAT DEFAULT NULL,
+                sample_size INTEGER DEFAULT 0,
+                period_days INTEGER DEFAULT 0,
+                created_at TIMESTAMP DEFAULT NOW(),
+                UNIQUE(model_date, segment, model_type, target)
+            )
+        """)
+        await conn.execute(
+            "ALTER TABLE pricing_model_v2 ADD COLUMN IF NOT EXISTS model_blob BYTEA")
 
     logger.info("score.db.initialized")
 
@@ -304,78 +483,144 @@ async def health_check_services():
     if failed:
         logger.warning("healthcheck.failed", services=failed)
 
-async def _kospi_return_between(conn, start_date: date, end_date: date) -> Optional[float]:
-    """KOSPI 두 날짜 사이 수익률 (%) — stock_ohlcv에 'KOSPI' 코드 필요"""
-    rows = await conn.fetch("""
+async def _close_near(conn, code: str, target: date) -> Optional[float]:
+    """target일 또는 그 직전 거래일(최대 7일 소급)의 종가. 주말·휴장일 보정용."""
+    row = await conn.fetchrow("""
         SELECT close_price FROM stock_ohlcv
-        WHERE stock_code='KOSPI' AND dt IN ($1, $2)
-        ORDER BY dt
-    """, start_date, end_date)
-    if len(rows) < 2:
+        WHERE stock_code=$1 AND dt <= $2 AND dt >= $2 - 7
+        ORDER BY dt DESC LIMIT 1
+    """, code, target)
+    if not row or not row["close_price"] or float(row["close_price"]) <= 0:
         return None
-    s, e = float(rows[0]["close_price"]), float(rows[1]["close_price"])
-    if s <= 0:
+    return float(row["close_price"])
+
+
+async def _kospi_return_between(conn, start_date: date, end_date: date) -> Optional[float]:
+    """KOSPI 두 날짜 사이 수익률 (%) — 거래일 보정(_close_near)"""
+    s = await _close_near(conn, "KOSPI", start_date)
+    e = await _close_near(conn, "KOSPI", end_date)
+    if s is None or e is None or s <= 0:
         return None
     return (e - s) / s * 100
 
 
-async def update_performance_prices():
-    """추천 7일/30일 후 수익률 + KOSPI 대비 알파"""
+async def update_performance_prices(force: bool = False):
+    """추천 7일/30일 후 수익률 + KOSPI 대비 알파.
+    수익률 = (rec_date+N일 OHLCV 종가 − entry_price) / entry_price.
+    종가는 stock_ohlcv 거래일 보정(_close_near) — KOSPI 알파와 horizon 일치.
+    force=True면 측정 완료 행도 OHLCV 기준으로 재계산(라벨 정정용)."""
+    measured_7d = measured_30d = skipped = 0
     async with pg_pool.acquire() as conn:
-        rows_7d = await conn.fetch("""
-            SELECT id, stock_code, entry_price, rec_date FROM recommendation_performance
-            WHERE price_7d = 0 AND entry_price > 0
-              AND rec_date <= CURRENT_DATE - 7 AND rec_date >= CURRENT_DATE - 60
-        """)
+        cond_7d = ("entry_price > 0" if force else
+                   "price_7d = 0 AND entry_price > 0 "
+                   "AND rec_date <= CURRENT_DATE - 7 AND rec_date >= CURRENT_DATE - 60")
+        rows_7d = await conn.fetch(
+            f"SELECT id, stock_code, entry_price, rec_date "
+            f"FROM recommendation_performance WHERE {cond_7d}")
         for row in rows_7d:
-            price = await get_current_price(row["stock_code"])
-            if price > 0:
-                ret = (price - row["entry_price"]) / row["entry_price"] * 100
-                kospi_ret = await _kospi_return_between(
-                    conn, row["rec_date"], row["rec_date"] + timedelta(days=7))
-                alpha = (ret - kospi_ret) if kospi_ret is not None else None
-                await conn.execute("""
-                    UPDATE recommendation_performance
-                    SET price_7d=$1, return_7d=$2, kospi_return_7d=$3, alpha_7d=$4, updated_at=NOW()
-                    WHERE id=$5
-                """, price, ret, kospi_ret, alpha, row["id"])
-        rows_30d = await conn.fetch("""
-            SELECT id, stock_code, entry_price, rec_date FROM recommendation_performance
-            WHERE price_30d = 0 AND entry_price > 0
-              AND rec_date <= CURRENT_DATE - 30 AND rec_date >= CURRENT_DATE - 120
-        """)
+            target = row["rec_date"] + timedelta(days=7)
+            if target > date.today():
+                continue
+            price = await _close_near(conn, row["stock_code"], target)
+            if price is None:
+                skipped += 1
+                continue
+            ret = (price - row["entry_price"]) / row["entry_price"] * 100
+            kospi_ret = await _kospi_return_between(conn, row["rec_date"], target)
+            alpha = (ret - kospi_ret) if kospi_ret is not None else None
+            await conn.execute("""
+                UPDATE recommendation_performance
+                SET price_7d=$1, return_7d=$2, kospi_return_7d=$3, alpha_7d=$4, updated_at=NOW()
+                WHERE id=$5
+            """, int(price), ret, kospi_ret, alpha, row["id"])
+            measured_7d += 1
+        cond_30d = ("entry_price > 0" if force else
+                    "price_30d = 0 AND entry_price > 0 "
+                    "AND rec_date <= CURRENT_DATE - 30 AND rec_date >= CURRENT_DATE - 120")
+        rows_30d = await conn.fetch(
+            f"SELECT id, stock_code, entry_price, rec_date "
+            f"FROM recommendation_performance WHERE {cond_30d}")
         for row in rows_30d:
-            price = await get_current_price(row["stock_code"])
-            if price > 0:
-                ret = (price - row["entry_price"]) / row["entry_price"] * 100
-                kospi_ret = await _kospi_return_between(
-                    conn, row["rec_date"], row["rec_date"] + timedelta(days=30))
-                alpha = (ret - kospi_ret) if kospi_ret is not None else None
-                await conn.execute("""
-                    UPDATE recommendation_performance
-                    SET price_30d=$1, return_30d=$2, kospi_return_30d=$3, alpha_30d=$4, updated_at=NOW()
-                    WHERE id=$5
-                """, price, ret, kospi_ret, alpha, row["id"])
-    logger.info("performance.updated", rows_7d=len(rows_7d), rows_30d=len(rows_30d))
+            target = row["rec_date"] + timedelta(days=30)
+            if target > date.today():
+                continue
+            price = await _close_near(conn, row["stock_code"], target)
+            if price is None:
+                skipped += 1
+                continue
+            ret = (price - row["entry_price"]) / row["entry_price"] * 100
+            kospi_ret = await _kospi_return_between(conn, row["rec_date"], target)
+            alpha = (ret - kospi_ret) if kospi_ret is not None else None
+            await conn.execute("""
+                UPDATE recommendation_performance
+                SET price_30d=$1, return_30d=$2, kospi_return_30d=$3, alpha_30d=$4, updated_at=NOW()
+                WHERE id=$5
+            """, int(price), ret, kospi_ret, alpha, row["id"])
+            measured_30d += 1
+    logger.info("performance.updated", measured_7d=measured_7d,
+                measured_30d=measured_30d, skipped=skipped, force=force)
+    return {"measured_7d": measured_7d, "measured_30d": measured_30d, "skipped": skipped}
 
-def get_recommendation(score: float, buy_votes: int = 0, sell_votes: int = 0) -> str:
+def get_recommendation(score: float, buy_votes: int = 0, sell_votes: int = 0,
+                      ret_5d: float = 0.0, ret_20d: float = 0.0) -> str:
     """
-    임계값 + 다수공식 동의 강제
-    - 강력매수: 점수 ≥70 AND 6공식 중 ≥3 매수 동의
+    임계값 + 다수공식 동의 강제 + 단기 약세 가드
+    - 강력매수: 점수 ≥70 AND 매수 ≥2 (가중치>0 공식 한정)
     - 매수관심: 점수 ≥40 AND 매수≥1 AND 매도<2
-    - 강력매도: 점수 ≤-60
-    - 매도관심: 점수 ≤-30 OR 매도≥3
+    - 강력매도: 점수 ≤-60 OR 매도≥3
+    - 매도관심: 점수 ≤-30 OR 매도≥2
     - 그 외: 관망
+    ※ buy/sell_votes는 학습이 가중치 0으로 가지친 공식 제외하고 카운트됨.
+
+    단기 약세 가드: 펀더가 좋아도 최근 가격이 무너지면 등급 강등 (떨어지는 칼날 회피)
+    - 강력매수 → 매수관심: ret_5d ≤ -5% OR ret_20d ≤ -10%
+    - 매수관심 → 관망: ret_5d ≤ -8% OR ret_20d ≤ -15%
     """
-    if score >= 70 and buy_votes >= 3:
-        return "강력매수"
-    if score >= 40 and buy_votes >= 1 and sell_votes < 2:
-        return "매수관심"
-    if score <= -60 or sell_votes >= 4:
-        return "강력매도"
-    if score <= -30 or sell_votes >= 3:
-        return "매도관심"
-    return "관망"
+    if score >= 70 and buy_votes >= 2:
+        rec = "강력매수"
+    elif score >= 40 and buy_votes >= 1 and sell_votes < 2:
+        rec = "매수관심"
+    elif score <= -60 or sell_votes >= 3:
+        rec = "강력매도"
+    elif score <= -30 or sell_votes >= 2:
+        rec = "매도관심"
+    else:
+        rec = "관망"
+
+    if rec == "강력매수" and (ret_5d <= -5.0 or ret_20d <= -10.0):
+        rec = "매수관심"
+    if rec == "매수관심" and (ret_5d <= -8.0 or ret_20d <= -15.0):
+        rec = "관망"
+    return rec
+
+
+async def calc_short_returns(conn, stock_code: str, as_of: date | None = None) -> tuple[float, float]:
+    """
+    최근 5일·20일 수익률(%) — 단기 약세 가드용.
+    데이터 부족 시 (0.0, 0.0) 반환 (가드 미작동 = 안전 fallback).
+    """
+    if as_of is None:
+        rows = await conn.fetch("""
+            SELECT close_price FROM stock_ohlcv
+            WHERE stock_code=$1 ORDER BY dt DESC LIMIT 25
+        """, stock_code)
+    else:
+        rows = await conn.fetch("""
+            SELECT close_price FROM stock_ohlcv
+            WHERE stock_code=$1 AND dt <= $2 ORDER BY dt DESC LIMIT 25
+        """, stock_code, as_of)
+    closes = [float(r["close_price"]) for r in rows if r["close_price"] and r["close_price"] > 0]
+    if len(closes) < 6:
+        return 0.0, 0.0
+    latest = closes[0]
+    p_5d = closes[5]
+    ret_5d = (latest - p_5d) / p_5d * 100 if p_5d > 0 else 0.0
+    if len(closes) >= 21:
+        p_20d = closes[20]
+        ret_20d = (latest - p_20d) / p_20d * 100 if p_20d > 0 else 0.0
+    else:
+        ret_20d = 0.0
+    return ret_5d, ret_20d
 
 def calc_fundamental_score(fin: dict, per: float, pbr: float) -> tuple[float, list[str]]:
     """
@@ -984,13 +1229,28 @@ async def calc_beta(conn, stock_code: str, days: int = 60, as_of: date | None =
 
 
 # ── 앙상블 보팅 (공식별 신호 다수결) ───────────────────────
-def aggregate_signals(signals: dict) -> tuple[str, dict]:
+# 앙상블 보팅 10공식 — formula_weights 기본값·learn-weights 학습 대상의 단일 출처.
+# sig_map의 graph는 모델 신호라 학습 제외(formula_weights에 1.0 고정).
+ENSEMBLE_FORMULAS = ["magic", "fscore", "altman", "peg", "momentum",
+                     "beneish", "gpa", "gscore", "amihud", "beta"]
+
+# 경기민감(시클리컬) 섹터 — 실적 정점 = 주가 고점 함정 가드용 (dart_corps.sector 기준)
+CYCLICAL_SECTORS = {"전자/반도체", "화학", "1차금속", "기계",
+                    "전기장비", "자동차", "운수장비", "비금속광물"}
+
+
+def aggregate_signals(signals: dict, weights: dict | None = None) -> tuple[str, dict]:
     """
     signals: {공식이름: '매수'/'매도'/'관망'}
+    weights: {공식이름: float} — 주어지면 가중치 > 0인 공식만 카운트(학습이 죽인 공식 제외).
+             graph는 학습 제외이므로 weights에 없어도 항상 카운트.
     returns: (요약문, 카운트 dict)
     """
     counts = {"매수": 0, "매도": 0, "관망": 0}
-    for s in signals.values():
+    for fname, s in signals.items():
+        if weights is not None and fname in ENSEMBLE_FORMULAS:
+            if weights.get(fname, 0.0) <= 0:
+                continue
         counts[s] = counts.get(s, 0) + 1
     parts = []
     if counts["매수"] > 0: parts.append(f"매수 {counts['매수']}")
@@ -1143,14 +1403,48 @@ async def calc_news_score_weighted(
         cat = _map_catalyst(r["catalyst"])
         cw  = CATALYST_WEIGHTS.get(cat, 1.0)
         intensity = float(r["intensity"] or 1)
-        # 시간감쇠 (3일 반감기)
         try:
-            age_days = (now - r["analyzed_at"]).total_seconds() / 86400.0
+            age_days = (now - r["ref_at"]).total_seconds() / 86400.0
         except Exception:
             age_days = 3.0
         tw = _time_weight(max(0.0, age_days))
         sw = _similar_weight(r["sim"])
-        delta = intensity * 5.0 * cw * tw * sw
+        # 출처 신뢰도: 학습된 값 우선, 없으면 컬럼값 → 평균 0.5에서 ±0.5 범위 정규화 (0.5~1.5x)
+        src = r["source"] or ""
+        cred = _SRC_CRED_CACHE.get(src, float(r["source_credibility"] or 0.5))
+        cred_w = 0.5 + cred                               # 0.5~1.5
+        # LLM confidence: 0.3 이하면 절반 가중 (저신뢰 라벨 영향 축소)
+        llm_w = max(0.4, min(1.2, float(r["llm_confidence"] or 0.5) + 0.4))
+        # 제목 강도: 0.3~1.5 (news-collector에서 clamp됨)
+        ts_w = float(r["title_strength"] or 1.0)
+        # 사후 학습 reliability: catalyst×time_horizon 평균 hit_ratio 기반 (0.2~2.0)
+        th = r["time_horizon"] or "단기"
+        rel_w = _RELIABILITY_CACHE.get((cat, th), 1.0)
+        # 사건 시드 여부: 클러스터 첫 뉴스만 풀 가중, 후속은 0.30로 감쇠
+        seed_w = 1.0 if r["is_event_seed"] else 0.30
+        # 1뉴스 N종목 영향도: stock_impacts에 매핑된 가중치 (primary는 1.0)
+        try:
+            si = r["stock_impacts"]
+            if isinstance(si, str):
+                try: si = json.loads(si)
+                except: si = {}
+            si = si or {}
+        except Exception:
+            si = {}
+        # primary_stock 매칭으로 들어온 행은 stock_impacts에 없어도 풀 가중(1.0).
+        # stock_impacts에 키로 등장하면 LLM이 매긴 영향도를 사용.
+        if stock_code in si:
+            impact = float(si.get(stock_code) or 0)
+        else:
+            impact = 1.0
+        if impact <= 0:
+            continue
+        # impact_scope: 시장 광역 뉴스는 종목 영향 보수적 감쇠
+        scope = r["impact_scope"]
+        if scope == "시장": impact *= 0.30
+        elif scope == "섹터": impact *= 0.60
+
+        delta = intensity * 5.0 * cw * tw * sw * cred_w * llm_w * ts_w * rel_w * seed_w * impact
         if sent == "호재":
             score += delta; pos += 1
         else:
@@ -1170,10 +1464,13 @@ async def calc_sentiment_momentum(
     cutoff_recent = now - timedelta(days=3)
     cutoff_old    = now - timedelta(days=7)
     rows = await conn.fetch("""
-        SELECT sentiment, intensity, analyzed_at, COALESCE(similar_count, 1) AS sim,
+        SELECT sentiment, intensity,
+               COALESCE(published_at, analyzed_at) AS ref_at,
+               COALESCE(similar_count, 1) AS sim,
                COALESCE(catalyst, '기타') AS catalyst
         FROM news_analysis
-        WHERE primary_stock=$1 AND analyzed_at >= $2
+        WHERE primary_stock=$1
+          AND COALESCE(published_at, analyzed_at) >= $2
           AND sentiment IN ('호재','악재')
     """, stock_code, cutoff_old)
     recent = old = 0.0
@@ -1182,7 +1479,7 @@ async def calc_sentiment_momentum(
         sw = _similar_weight(r["sim"])
         val = float(r["intensity"] or 1) * cw * sw
         if r["sentiment"] == "악재": val = -val
-        if r["analyzed_at"] >= cutoff_recent:
+        if r["ref_at"] >= cutoff_recent:
             recent += val
         else:
             old += val
@@ -1216,6 +1513,142 @@ async def calc_news_surge_and_attention(
     return float(surge), float(attention)
 
 
+# ── 사후 검증 피드백 루프 ─────────────────────────────────
+async def calibrate_sentiment_reliability():
+    """
+    catalyst × time_horizon × sentiment별로 ±3/7일 가격반응 측정 → reliability_score 갱신.
+    감성과 부합한 비율(hit_ratio)이 높을수록 reliability ↑.
+    8일 전 ~ 120일 전 분석된 뉴스만 사용 (7일 수익률 확정 + 너무 옛것 제외).
+    """
+    from collections import defaultdict
+    async with pg_pool.acquire() as conn:
+        rows = await conn.fetch("""
+            WITH n AS (
+              SELECT na.primary_stock AS code, na.sentiment, na.intensity,
+                     COALESCE(na.catalyst, '기타') AS catalyst,
+                     COALESCE(na.time_horizon, '단기') AS th,
+                     na.analyzed_at::date AS d0,
+                     COALESCE(na.is_event_seed, TRUE) AS seed
+              FROM news_analysis na
+              WHERE na.primary_stock IS NOT NULL AND na.primary_stock != ''
+                AND na.sentiment IN ('호재','악재')
+                AND na.intensity >= 2
+                AND na.analyzed_at >= NOW() - INTERVAL '120 days'
+                AND na.analyzed_at <= NOW() - INTERVAL '8 days'
+            )
+            SELECT n.catalyst, n.th, n.sentiment, n.intensity, n.code, n.d0,
+                   (SELECT close_price FROM stock_ohlcv
+                      WHERE stock_code=n.code AND dt >= n.d0
+                      ORDER BY dt ASC LIMIT 1) AS p0,
+                   (SELECT close_price FROM stock_ohlcv
+                      WHERE stock_code=n.code AND dt >= n.d0 + INTERVAL '3 days'
+                      ORDER BY dt ASC LIMIT 1) AS p3,
+                   (SELECT close_price FROM stock_ohlcv
+                      WHERE stock_code=n.code AND dt >= n.d0 + INTERVAL '7 days'
+                      ORDER BY dt ASC LIMIT 1) AS p7
+            FROM n
+            WHERE n.seed = TRUE
+        """)
+        buckets = defaultdict(lambda: {"r3": [], "r7": [], "hit3": 0, "n": 0})
+        for r in rows:
+            p0 = float(r["p0"] or 0)
+            if p0 <= 0: continue
+            sign = 1 if r["sentiment"] == "호재" else -1
+            key = (r["catalyst"], r["th"])
+            b = buckets[key]
+            b["n"] += 1
+            if r["p3"]:
+                r3 = (float(r["p3"]) - p0) / p0 * 100
+                b["r3"].append(sign * r3)
+                if sign * r3 > 0: b["hit3"] += 1
+            if r["p7"]:
+                r7 = (float(r["p7"]) - p0) / p0 * 100
+                b["r7"].append(sign * r7)
+        saved = 0
+        for (cat, th), b in buckets.items():
+            n = b["n"]
+            if n < 5: continue
+            avg3 = sum(b["r3"])/len(b["r3"]) if b["r3"] else None
+            avg7 = sum(b["r7"])/len(b["r7"]) if b["r7"] else None
+            n3   = len(b["r3"])
+            hit3 = b["hit3"]/n3 if n3 else None
+            # reliability_score: hit_ratio 기반 0.2~2.0
+            # 0.5(랜덤) 근처면 1.0, 0.7 → 1.5, 0.9 → 2.0, 0.3 → 0.4
+            rel = 1.0
+            if hit3 is not None:
+                rel = max(0.2, min(2.0, 0.2 + (hit3 - 0.30) * 2.5))
+            if avg3 is not None:
+                if avg3 > 0.8:    rel = min(2.0, rel + 0.20)
+                elif avg3 < -0.5: rel = max(0.2, rel - 0.30)
+            await conn.execute("""
+                INSERT INTO sentiment_reliability
+                  (catalyst, time_horizon, sample_size, avg_return_3d, avg_return_7d,
+                   hit_ratio_3d, reliability_score, last_updated)
+                VALUES ($1,$2,$3,$4,$5,$6,$7,NOW())
+                ON CONFLICT (catalyst, time_horizon) DO UPDATE SET
+                  sample_size=$3, avg_return_3d=$4, avg_return_7d=$5,
+                  hit_ratio_3d=$6, reliability_score=$7, last_updated=NOW()
+            """, cat, th, n, avg3, avg7, hit3, rel)
+            saved += 1
+        logger.info("sentiment.calibration.done", buckets=len(buckets), saved=saved)
+        return {"buckets": len(buckets), "saved": saved}
+
+
+async def calibrate_source_credibility():
+    """
+    뉴스 출처별 감성 ↔ 3일 가격반응 부합도 측정 → news_source_credibility 갱신.
+    """
+    async with pg_pool.acquire() as conn:
+        rows = await conn.fetch("""
+            SELECT na.source, na.sentiment,
+                   na.primary_stock AS code,
+                   na.analyzed_at::date AS d0,
+                   (SELECT close_price FROM stock_ohlcv
+                      WHERE stock_code=na.primary_stock AND dt >= na.analyzed_at::date
+                      ORDER BY dt ASC LIMIT 1) AS p0,
+                   (SELECT close_price FROM stock_ohlcv
+                      WHERE stock_code=na.primary_stock AND dt >= na.analyzed_at::date + INTERVAL '3 days'
+                      ORDER BY dt ASC LIMIT 1) AS p3
+            FROM news_analysis na
+            WHERE na.primary_stock IS NOT NULL AND na.primary_stock != ''
+              AND na.sentiment IN ('호재','악재') AND na.intensity >= 2
+              AND COALESCE(na.is_event_seed, TRUE) = TRUE
+              AND na.analyzed_at >= NOW() - INTERVAL '90 days'
+              AND na.analyzed_at <= NOW() - INTERVAL '5 days'
+              AND na.source IS NOT NULL AND na.source != ''
+        """)
+        from collections import defaultdict
+        agg = defaultdict(lambda: {"hit": 0, "n": 0, "r": []})
+        for r in rows:
+            p0 = float(r["p0"] or 0); p3 = float(r["p3"] or 0)
+            if p0 <= 0 or p3 <= 0: continue
+            sign = 1 if r["sentiment"] == "호재" else -1
+            ret = (p3 - p0) / p0 * 100
+            a = agg[r["source"]]
+            a["n"] += 1
+            a["r"].append(sign * ret)
+            if sign * ret > 0: a["hit"] += 1
+        saved = 0
+        for src, a in agg.items():
+            n = a["n"]
+            if n < 10: continue
+            hit = a["hit"] / n
+            avg = sum(a["r"]) / n
+            # credibility 0.2~1.0 (기본 0.5, hit_ratio·avg_return으로 보정)
+            cred = max(0.2, min(1.0, 0.30 + hit * 0.6 + max(-0.1, min(0.1, avg / 20))))
+            await conn.execute("""
+                INSERT INTO news_source_credibility
+                  (source, credibility, sample_size, hit_ratio_3d, avg_signed_return_3d, last_updated)
+                VALUES ($1,$2,$3,$4,$5,NOW())
+                ON CONFLICT (source) DO UPDATE SET
+                  credibility=$2, sample_size=$3, hit_ratio_3d=$4,
+                  avg_signed_return_3d=$5, last_updated=NOW()
+            """, src[:100], cred, n, hit, avg)
+            saved += 1
+        logger.info("source.calibration.done", sources=len(agg), saved=saved)
+        return {"sources": len(agg), "saved": saved}
+
+
 async def calc_market_sentiment_baseline(conn, week_ago: date) -> float:
     """전체 시장 종목당 평균 가중 sentiment (sentiment_alpha 산출용 baseline)."""
     week_ago_dt = datetime.combine(week_ago, datetime.min.time(), tzinfo=timezone.utc)
@@ -1710,6 +2143,39 @@ async def calculate_daily_scores(as_of: date | None = None):
             logger.warning("aux_signals.load_err", error=str(e))
 
         # 미국증시 overnight 보정 사전 로드 (us-market 서비스가 채움)
+        # 주주환원율 사전 로드: (배당금 + 자사주매입) / 시가총액 × 100 (%)
+        # 코리아 디스카운트 방어 — 돈 벌어도 주주와 안 나누면 주가가 안 오름
+        shareholder_yield_map: dict = {}
+        try:
+            sy_rows = await conn.fetch("""
+                SELECT d.stock_code,
+                  COALESCE(dv.total_dividend, 0) AS dividend,
+                  COALESCE(fn.treasury, 0)       AS treasury,
+                  COALESCE(mc.market_cap, 0)     AS mcap
+                FROM dart_corps d
+                LEFT JOIN LATERAL (
+                  SELECT total_dividend FROM dart_dividends
+                  WHERE stock_code=d.stock_code ORDER BY bsns_year DESC LIMIT 1) dv ON true
+                LEFT JOIN LATERAL (
+                  SELECT treasury_acquired AS treasury FROM dart_financials
+                  WHERE stock_code=d.stock_code AND reprt_code='11011'
+                  ORDER BY bsns_year DESC LIMIT 1) fn ON true
+                LEFT JOIN LATERAL (
+                  SELECT market_cap FROM stock_prices
+                  WHERE stock_code=d.stock_code AND market_cap>0
+                  ORDER BY collected_at DESC LIMIT 1) mc ON true
+                WHERE d.is_active=true
+            """)
+            for r in sy_rows:
+                mcap = float(r["mcap"] or 0)
+                if mcap <= 0:
+                    continue
+                payout = float(r["dividend"] or 0) + float(r["treasury"] or 0)
+                shareholder_yield_map[r["stock_code"]] = payout / mcap * 100.0
+            logger.info("shareholder_yield.loaded", count=len(shareholder_yield_map))
+        except Exception as e:
+            logger.warning("shareholder_yield.load_err", error=str(e))
+
         # 시그널 날짜는 미국장 마감 기준이라 한국 today와 1일 차이날 수 있음
         # → 최근 2일 이내 가장 최신 시그널 사용
         us_overnight_map: dict = {}
@@ -2071,7 +2537,7 @@ async def calculate_daily_scores(as_of: date | None = None):
                 "beta":    beta_sig,
                 "graph":   graph_sig,
             }
-            ensemble_summary, vote_counts = aggregate_signals(sig_map)
+            ensemble_summary, vote_counts = aggregate_signals(sig_map, weights=formula_weights)
             if ensemble_summary:
                 fin_reasons.append(f"공식보팅 [{ensemble_summary}]")
 
@@ -2088,8 +2554,15 @@ async def calculate_daily_scores(as_of: date | None = None):
                 sentiment_raw_sum - market_sentiment_baseline))
 
             # 펀더멘털 통합: 기존 + 추세 + 이익품질 + 매직포뮬러 + F-Score (DCF는 종합점수에 별도 가중)
+            # 주주환원율 보너스 (배당+자사주매입 / 시총) — 퀄리티 보완
+            sy_pct = shareholder_yield_map.get(stock, 0.0)
+            sy_bonus = (8.0 if sy_pct >= 6 else 5.0 if sy_pct >= 4
+                        else 3.0 if sy_pct >= 2.5 else 1.0 if sy_pct >= 1 else 0.0)
+            if sy_bonus >= 5:
+                fin_reasons.append(f"주주환원율 {sy_pct:.1f}%")
             fundamental_combined = max(-100.0, min(100.0,
-                fundamental_score + trend_score + eq_score + magic_score + f_score_adj))
+                fundamental_score + trend_score + eq_score + magic_score
+                + f_score_adj + sy_bonus))
 
             # 종합 점수 (가중치 재배분)
             # 펀더24% + 뉴스18% + 기술15% + 공시10% + 외국인14% + 공매도6% + 가격3% + 안전마진10%
@@ -2137,10 +2610,25 @@ async def calculate_daily_scores(as_of: date | None = None):
             val_sig, val_reason = calc_valuation_percentile(per_list, per)
             aux_total = insider_sig + consensus_sig + macro_sig + flow_sig + val_sig
 
-            # H3: 시장 레짐 + 앙상블 + 미국증시 + 5개 보조
+            # 사이클 고점 가드: 경기민감주가 급등(고모멘텀) + 저PER이면
+            # peak-earnings(실적 정점=주가 고점) 함정 위험 → 점수 차감
+            cyc_penalty = 0.0
+            if sector in CYCLICAL_SECTORS and 0 < per < 10 and mom_val > 80:
+                cyc_penalty = -min(12.0, 4.0 + mom_val / 40.0)
+                fin_reasons.append(
+                    f"사이클 고점주의({sector}·모멘텀{mom_val:.0f}%·PER{per:.1f})")
+
+            # H3: 시장 레짐 + 앙상블 + 미국증시 + 5개 보조 + 사이클 가드
             total = max(-100, min(100,
-                total + regime_adj + ensemble_bonus + us_adj + aux_total))
-            rec   = get_recommendation(total, vote_counts["매수"], vote_counts["매도"])
+                total + regime_adj + ensemble_bonus + us_adj + aux_total + cyc_penalty))
+
+            # 단기 약세 가드: 펀더 좋아도 최근 5d/20d 가격 무너지면 등급 강등
+            ret_5d, ret_20d = await calc_short_returns(
+                conn, stock, as_of=today if backfill_mode else None)
+            rec   = get_recommendation(total, vote_counts["매수"], vote_counts["매도"],
+                                       ret_5d, ret_20d)
+            if rec in ("매수관심", "관망") and (ret_5d <= -5.0 or ret_20d <= -10.0):
+                fin_reasons.append(f"단기약세가드(5d{ret_5d:+.1f}%·20d{ret_20d:+.1f}%)")
 
             # 보조 시그널 근거 (점수에 영향 큰 것만)
             for sval, rtxt in [(insider_sig, insider_reason),
@@ -2316,9 +2804,9 @@ async def calculate_daily_scores(as_of: date | None = None):
                 await conn.execute("""
                     INSERT INTO recommendation_performance (
                         stock_code, stock_name, recommendation, total_score, entry_price, rec_date)
-                    VALUES ($1,$2,$3,$4,$5,CURRENT_DATE)
+                    VALUES ($1,$2,$3,$4,$5,$6)
                     ON CONFLICT (stock_code, rec_date) DO NOTHING
-                """, r["stock_code"], r["stock_name"], r["recommendation"], r["total_score"], entry_price)
+                """, r["stock_code"], r["stock_name"], r["recommendation"], r["total_score"], entry_price, today)
 
             if r["recommendation"] == "강력매수":
                 strong_buy.append((r["stock_name"], r["stock_code"], r["total_score"],
@@ -2329,6 +2817,42 @@ async def calculate_daily_scores(as_of: date | None = None):
 
     logger.info("scoring.done", scored=scored, recommended=len(rec_rows))
 
+    # 신규 강력매수 즉시 알림 (어제는 강력매수 아니었는데 오늘 새로 등장한 종목)
+    if not backfill_mode and strong_buy:
+        try:
+            async with pg_pool.acquire() as nc:
+                prev_codes = {r["stock_code"] for r in await nc.fetch("""
+                    SELECT stock_code FROM stock_scores
+                    WHERE score_date = $1 AND recommendation='강력매수'
+                """, today - timedelta(days=1))}
+                today_codes = {code for _name, code, *_ in strong_buy}
+                new_codes = sorted(today_codes - prev_codes)
+                if new_codes:
+                    lines = [f"🆕 <b>신규 강력매수 등장 ({today})</b>"]
+                    async with httpx.AsyncClient() as cli:
+                        for code in new_codes[:5]:
+                            try:
+                                res = await run_deep_analysis(nc, cli, code,
+                                                              save=True, model="hybrid")
+                                if res.get("error"):
+                                    continue
+                                agr = res.get("agreement")
+                                tag = "✅" if agr else ("⚠️" if agr is False else "")
+                                lines.append(
+                                    f"\n{tag} <b>{res['name']}</b>({code}) — "
+                                    f"{res['recommendation']} {res['conviction']}/5\n"
+                                    f"  {res['thesis'][:200]}\n"
+                                    f"  🎯 목표 {res.get('target_price', 0):,}원 / "
+                                    f"손절 {res.get('stop_loss', 0):,}원"
+                                )
+                            except Exception as e:
+                                logger.warning("new_buy.deep_err", code=code, error=str(e))
+                    if len(lines) > 1:
+                        await send_telegram("\n".join(lines))
+                    logger.info("new_buy.notified", count=len(new_codes), analyzed=min(5, len(new_codes)))
+        except Exception as e:
+            logger.warning("new_buy.err", error=str(e))
+
     # 텔레그램 알림
     if strong_buy or strong_sell:
         lines = [f"<b>📊 Trading AI 일간 리포트 ({today})</b>\n"]
@@ -2506,10 +3030,10 @@ async def startup():
     scheduler.add_job(calculate_daily_scores, "cron",
                       day_of_week="mon-fri", hour=16, minute=30,
                       id="daily_score", replace_existing=True)
-    for hr, mn in [(8, 0), (12, 0), (16, 0), (18, 0)]:
-        scheduler.add_job(send_briefing, "cron",
-                          day_of_week="mon-fri", hour=hr, minute=mn,
-                          id=f"briefing_{hr}_{mn}", replace_existing=True)
+    # 텔레그램 정기 알림 하루 2회로 축소 (사용자 요청 2026-06-02):
+    #   08:00 morning_brief_job(아침 브리핑) + 16:30 일간리포트(calculate_daily_scores).
+    # 중복이던 08:00 send_briefing + 12:30 send_briefing 스케줄 제거.
+    # (send_briefing 함수·/briefing/send 수동 엔드포인트는 유지 — 자동 발신만 중단)
     # 데이터 정리: 매일 새벽 4시
     scheduler.add_job(cleanup_old_data, "cron",
                       hour=4, minute=0,
@@ -2526,32 +3050,70 @@ async def startup():
     # 04:00 — 공식 가중치 학습 (90일 백테스트)
     # 05:00 — 예상가 모델 학습 (선형회귀 + RF + XGBoost)
     # 두 함수 모두 표본 부족 시 graceful (return early) — 데이터 누적되면 자동 활성화
-    scheduler.add_job(lambda: learn_weights(days=90), "cron",
+    scheduler.add_job(lambda: learn_weights(days=90, segment="all"), "cron",
                       day_of_week="sun", hour=4, minute=0,
                       id="learn_weights", replace_existing=True)
-    scheduler.add_job(lambda: learn_pricing(days=90), "cron",
+    scheduler.add_job(lambda: learn_pricing(days=90, segment="all",
+                      target="return_7d", n_folds=5), "cron",
                       day_of_week="sun", hour=5, minute=0,
                       id="learn_pricing", replace_existing=True)
-    # AI 심층분석: 평일 17:00 (16:30 스코어링 직후 당일 추천종목 대상)
-    scheduler.add_job(deep_analysis_batch_job, "cron",
-                      day_of_week="mon-fri", hour=17, minute=0,
-                      id="deep_batch", replace_existing=True)
+    # AI 심층분석 — 비용 폭주로 자동 호출 임시 비활성화 (2026-05-29)
+    # thinking 토큰 비용 누락 발견 → 실비용 추정의 5~10배. /deep 수동 호출만 사용
+    # 복원 방법: 아래 add_job 주석 해제. 또는 POST /deep-analysis/batch 수동.
+    # scheduler.add_job(deep_analysis_batch_job, "cron",
+    #                   day_of_week="mon-fri", hour=17, minute=0,
+    #                   id="deep_batch", replace_existing=True)
+    # 매일 아침 08:00 브리핑 — 톱 추천 + 보유/관심 종목 hybrid 분석 → 텔레그램
+    scheduler.add_job(morning_brief_job, "cron",
+                      day_of_week="mon-fri", hour=8, minute=0,
+                      id="morning_brief", replace_existing=True)
+    # 매일 03:30 사후 검증 — 30일 전 분석들 실제 수익률 매칭 → 라벨링
+    scheduler.add_job(verify_predictions_job, "cron",
+                      hour=3, minute=30,
+                      id="verify_predictions", replace_existing=True)
+    # 매주 일요일 09:00 — 주간 성과 리포트 (등급별 승률·알파·MDD)
+    scheduler.add_job(weekly_performance_report, "cron",
+                      day_of_week="sun", hour=9, minute=0,
+                      id="weekly_report", replace_existing=True)
+    # 매월 1일 09:30 — LLM 정확도 비교 리포트 (Gemini vs EXAONE)
+    scheduler.add_job(monthly_llm_comparison, "cron",
+                      day=1, hour=9, minute=30,
+                      id="monthly_llm_report", replace_existing=True)
+    # 자동매매: 평일 9:05~15:00 매 5분 신호 스캔 (매수+매도+한도 체크)
+    scheduler.add_job(auto_trade_scan_job, "cron",
+                      day_of_week="mon-fri", hour="9-14", minute="*/5",
+                      id="auto_trade_scan", replace_existing=True)
+    # 매일 16:00 보유종목 평가손익 갱신
+    scheduler.add_job(update_daily_pnl_job, "cron",
+                      day_of_week="mon-fri", hour=16, minute=0,
+                      id="daily_pnl", replace_existing=True)
+    # 매 30분 — 만료된 pending 주문 자동 expired 처리
+    scheduler.add_job(expire_stale_orders_job, "cron",
+                      minute="*/30",
+                      id="expire_stale_orders", replace_existing=True)
+
+    # 사후 검증 피드백 루프: 매일 03:00 — catalyst×horizon 신뢰도 / 출처 신뢰도 갱신
+    # (T-8d ~ T-120d 분석된 뉴스로 측정 → calc_news_score_weighted가 다음날부터 자동 적용)
+    scheduler.add_job(calibrate_sentiment_reliability, "cron",
+                      hour=3, minute=0,
+                      id="calibrate_reliability", replace_existing=True)
+    scheduler.add_job(calibrate_source_credibility, "cron",
+                      hour=3, minute=20,
+                      id="calibrate_source", replace_existing=True)
     scheduler.start()
 
-    # 평일 17:00 deep_batch가 컨테이너 재배포/다운으로 17:00에 떠있지 않으면
-    # APScheduler MemoryJobStore는 놓친 실행을 catch-up하지 않음 → startup 시 1회 보정.
-    async def _deep_batch_catchup():
-        now = datetime.now()                       # 컨테이너 TZ=Asia/Seoul
-        if now.weekday() >= 5 or now.hour < 17:     # 주말 or 17:00 이전이면 정시 발화에 맡김
-            return
-        async with pg_pool.acquire() as conn:
-            done = await conn.fetchval(
-                "SELECT 1 FROM deep_analysis WHERE analysis_date=CURRENT_DATE LIMIT 1")
-        if done:                                    # 오늘치 이미 있으면 스킵
-            return
-        logger.info("deep_batch.catchup_start")
-        await deep_analysis_batch_job()
-    asyncio.create_task(_deep_batch_catchup())
+    # catchup도 비용 폭주 이슈로 일시 비활성화 (2026-05-29)
+    # 복원: 아래 코드 주석 해제
+    # async def _deep_batch_catchup():
+    #     now = datetime.now()
+    #     if now.weekday() >= 5 or now.hour < 17: return
+    #     async with pg_pool.acquire() as conn:
+    #         done = await conn.fetchval(
+    #             "SELECT 1 FROM deep_analysis WHERE analysis_date=CURRENT_DATE LIMIT 1")
+    #     if done: return
+    #     logger.info("deep_batch.catchup_start")
+    #     await deep_analysis_batch_job()
+    # asyncio.create_task(_deep_batch_catchup())
 
     logger.info("score-engine.started")
 
@@ -2575,6 +3137,9 @@ async def cleanup_old_data():
         # trade_signals: 30일 이상 된 것 삭제
         deleted_signals = await conn.fetchval(
             "WITH d AS (DELETE FROM trade_signals WHERE created_at < NOW() - INTERVAL '30 days' RETURNING 1) SELECT COUNT(*) FROM d")
+        # pricing_model_v2: 120일 이상 된 모델 삭제 (model_blob 누적 방지, 최신만 사용)
+        await conn.execute(
+            "DELETE FROM pricing_model_v2 WHERE model_date < CURRENT_DATE - 120")
     logger.info("cleanup.done",
                 prices=deleted_prices, recs=deleted_recs,
                 news=deleted_news, signals=deleted_signals)
@@ -2714,6 +3279,180 @@ async def ranking(date: str = Query(default=""), limit: int = Query(default=30))
         """, datetime.strptime(d, "%Y-%m-%d").date(), limit)
     return [dict(r) for r in rows]
 
+@app.get("/hot")
+async def hot_stocks(limit: int = Query(default=20)):
+    """지금 뜨는 종목 — 뉴스 모멘텀(최근3일 호재강도) + 단기 가격 모멘텀(5일) + 거래량 급증.
+    가치투자 추천(/ranking)과 독립된 '최신 트렌드' 렌즈. 가치 점수는 참고용으로 병기."""
+    async with pg_pool.acquire() as conn:
+        rows = await conn.fetch("""
+            WITH active AS (
+                SELECT stock_code FROM dart_corps WHERE is_active=true
+            ),
+            px AS (
+                SELECT o.stock_code,
+                       (array_agg(o.close_price ORDER BY o.dt DESC))[1]  AS last_close,
+                       (array_agg(o.close_price ORDER BY o.dt DESC))[6]  AS close_5d,
+                       (array_agg(o.volume      ORDER BY o.dt DESC))[1]::float AS last_vol,
+                       AVG(o.volume)::float AS avg_vol
+                FROM stock_ohlcv o
+                WHERE o.stock_code IN (SELECT stock_code FROM active)
+                  AND o.dt >= CURRENT_DATE - 45
+                GROUP BY o.stock_code
+            ),
+            nw AS (
+                SELECT primary_stock AS stock_code,
+                       SUM(CASE WHEN sentiment='호재' THEN COALESCE(intensity,1)
+                                WHEN sentiment='악재' THEN -COALESCE(intensity,1)
+                                ELSE 0 END)::float AS news_pts,
+                       COUNT(*) FILTER (WHERE sentiment='호재') AS pos_cnt,
+                       COUNT(*) AS news_cnt
+                FROM news_analysis
+                WHERE primary_stock <> ''
+                  AND published_at >= now() - interval '3 days'
+                GROUP BY primary_stock
+            )
+            SELECT a.stock_code,
+                   COALESCE(t.stock_name, c.corp_name, a.stock_code) AS stock_name,
+                   px.last_close, px.close_5d, px.last_vol, px.avg_vol,
+                   t.vol_ratio,
+                   COALESCE(nw.news_pts, 0) AS news_pts,
+                   COALESCE(nw.pos_cnt, 0)  AS pos_cnt,
+                   COALESCE(nw.news_cnt, 0) AS news_cnt,
+                   s.total_score, s.recommendation
+            FROM active a
+            LEFT JOIN px ON px.stock_code = a.stock_code
+            LEFT JOIN nw ON nw.stock_code = a.stock_code
+            LEFT JOIN stock_technical t ON t.stock_code = a.stock_code
+            LEFT JOIN dart_corps c ON c.stock_code = a.stock_code
+            LEFT JOIN stock_scores s
+                   ON s.stock_code = a.stock_code
+                  AND s.score_date = (SELECT MAX(score_date) FROM stock_scores)
+        """)
+    out = []
+    for r in rows:
+        lc, c5 = r["last_close"], r["close_5d"]
+        price_mom = round((lc / c5 - 1) * 100, 1) if (lc and c5 and c5 > 0) else 0.0
+        vr = r["vol_ratio"]
+        if not vr or vr <= 0:
+            vr = (r["last_vol"] / r["avg_vol"]) if (r["last_vol"] and r["avg_vol"] and r["avg_vol"] > 0) else 1.0
+        news_pts = float(r["news_pts"] or 0)
+        c_news  = max(0.0, min(80.0, news_pts * 5.0))        # 최근3일 호재강도합 ×5 (0~80, 상위 변별력 확보)
+        c_vol   = max(0.0, min(20.0, (vr - 1.0) * 15.0))     # 평소 거래량 대비 배수 (0~20)
+        # 5일 가격 모멘텀은 백테스트상 되돌림(mean-reversion) 유발 → 점수서 제외, 표시만 유지.
+        # (news+vol 조합이 1일 알파 +0.58% vs 가격포함 +0.11%로 우월)
+        hot = round(c_news + c_vol, 1)
+        if hot <= 3:                                          # 뉴스·거래량 둘 다 미미한 종목 제외
+            continue
+        out.append({
+            "stock_code": r["stock_code"],
+            "stock_name": r["stock_name"],
+            "hot_score": hot,
+            "news_mom": round(c_news, 1),
+            "price_5d_pct": price_mom,
+            "vol_ratio": round(vr, 1),
+            "pos_news_3d": int(r["pos_cnt"] or 0),
+            "value_score": round(r["total_score"], 1) if r["total_score"] is not None else None,
+            "value_reco": r["recommendation"],
+        })
+    out.sort(key=lambda x: x["hot_score"], reverse=True)
+    return out[:limit]
+
+
+@app.get("/hot/backtest")
+async def hot_backtest(days: int = Query(default=40), top_k: int = Query(default=10),
+                       horizon: int = Query(default=5),
+                       w_news: float = Query(default=5.0), w_price: float = Query(default=1.5),
+                       w_vol: float = Query(default=15.0)):
+    """핫점수 예측력 검증: 과거 각 거래일의 핫 상위 top_k 종목이 horizon 거래일 후 실제 수익률.
+    시장(전종목 평균) 대비 알파·승률·IC(스피어만)로 /hot 가중치가 유효한지 측정.
+    w_news/w_price/w_vol로 가중치 조합을 실험."""
+    import numpy as np
+    from collections import defaultdict
+    async with pg_pool.acquire() as conn:
+        ohlcv = await conn.fetch("""
+            WITH base AS (
+                SELECT o.stock_code, o.dt,
+                       o.close_price::float AS c, o.volume::float AS v,
+                       (LAG(o.close_price, 5) OVER w)::float AS c5,
+                       (AVG(o.volume) OVER (PARTITION BY o.stock_code ORDER BY o.dt
+                                            ROWS BETWEEN 20 PRECEDING AND 1 PRECEDING))::float AS avgv20,
+                       (LEAD(o.close_price, $1) OVER w)::float AS cfwd
+                FROM stock_ohlcv o
+                WHERE o.stock_code <> 'KOSPI'
+                  AND o.dt >= CURRENT_DATE - ($2 + $1 + 45)
+                WINDOW w AS (PARTITION BY o.stock_code ORDER BY o.dt)
+            )
+            SELECT stock_code, dt, c, v, c5, avgv20, cfwd
+            FROM base
+            WHERE dt >= CURRENT_DATE - ($2 + $1)
+              AND c5 IS NOT NULL AND c5 > 0 AND cfwd IS NOT NULL AND avgv20 > 0
+            ORDER BY dt
+        """, horizon, days)
+        news = await conn.fetch("""
+            SELECT primary_stock AS code, published_at::date AS d,
+                   SUM(CASE WHEN sentiment='호재' THEN COALESCE(intensity,1)
+                            WHEN sentiment='악재' THEN -COALESCE(intensity,1) ELSE 0 END)::float AS pts
+            FROM news_analysis
+            WHERE primary_stock <> '' AND published_at >= CURRENT_DATE - ($1 + 45)
+            GROUP BY primary_stock, published_at::date
+        """, days)
+    npts = {(r["code"], r["d"]): r["pts"] for r in news}
+    def news3(code, d):
+        return sum(npts.get((code, d - timedelta(days=k)), 0.0) for k in range(3))
+
+    byday = defaultdict(list)
+    pooled_hot, pooled_fwd = [], []
+    for r in ohlcv:
+        c, c5, cfwd, avgv, v = r["c"], r["c5"], r["cfwd"], r["avgv20"], r["v"]
+        price_mom = (c / c5 - 1) * 100
+        vr = (v / avgv) if avgv > 0 else 1.0
+        np_pts = news3(r["stock_code"], r["dt"])
+        c_news  = max(0.0, min(80.0, np_pts * w_news))
+        c_price = max(-15.0, min(30.0, price_mom * w_price))
+        c_vol   = max(0.0, min(20.0, (vr - 1.0) * w_vol))
+        hot = c_news + c_price + c_vol
+        fwd = (cfwd / c - 1) * 100
+        byday[r["dt"]].append((hot, fwd))
+        pooled_hot.append(hot); pooled_fwd.append(fwd)
+
+    topk_alphas, topk_rets, mkt_rets, wins, n_days = [], [], [], 0, 0
+    for d, lst in byday.items():
+        if len(lst) < top_k * 3:
+            continue
+        n_days += 1
+        lst.sort(key=lambda x: x[0], reverse=True)
+        topk = [f for _, f in lst[:top_k]]
+        mkt = float(np.mean([f for _, f in lst]))
+        tk = float(np.mean(topk))
+        topk_rets.append(tk); mkt_rets.append(mkt)
+        topk_alphas.append(tk - mkt)
+        if tk > mkt: wins += 1
+
+    ic = None
+    if len(pooled_hot) > 30:
+        try:
+            from scipy import stats as _ss
+            ic = round(float(_ss.spearmanr(pooled_hot, pooled_fwd).correlation), 4)
+        except Exception:
+            ic = None
+
+    if n_days == 0:
+        return {"error": "표본 부족", "n_obs": len(pooled_hot)}
+    avg_alpha = round(float(np.mean(topk_alphas)), 2)
+    return {
+        "params": {"days": days, "top_k": top_k, "horizon_days": horizon},
+        "n_days": n_days, "n_obs": len(pooled_hot),
+        "hot_topk_avg_return_pct": round(float(np.mean(topk_rets)), 2),
+        "market_avg_return_pct": round(float(np.mean(mkt_rets)), 2),
+        "alpha_pct": avg_alpha,
+        "win_rate_vs_market_pct": round(100.0 * wins / n_days, 1),
+        "ic_spearman": ic,
+        "verdict": ("핫점수 예측력 유효 (시장 초과)" if avg_alpha > 0.3 and (ic or 0) > 0.03
+                    else "예측력 약함 — 가중치 재조정 필요" if avg_alpha <= 0
+                    else "중립 — 미세 우위"),
+    }
+
+
 @app.get("/recommendations")
 async def recommendations(days: int = Query(default=7)):
     async with pg_pool.acquire() as conn:
@@ -2785,10 +3524,29 @@ async def stock_detail(code: str):
     }
 
 
+# 한국주식 왕복 거래비용 추정(증권거래세+수수료+슬리피지). 백테스트 순수익률 보정용.
+ROUND_TRIP_COST_PCT = 0.30
+
+
+def _max_drawdown(seq: list) -> float:
+    """시간순 거래 수익률(%) 리스트 → 누적 자산곡선 최대낙폭(%). 음수 반환."""
+    equity = peak = 1.0
+    mdd = 0.0
+    for r in seq:
+        equity *= (1 + r / 100.0)
+        if equity > peak:
+            peak = equity
+        elif peak > 0:
+            mdd = max(mdd, (peak - equity) / peak * 100.0)
+    return -round(mdd, 2)
+
+
 @app.get("/backtest")
 async def backtest(days: int = Query(default=180, ge=30, le=365)):
     """
-    M1: 과거 추천 종목의 7d/30d 수익률, KOSPI 대비 알파, 적중률, 샤프, MDD 산출
+    M1: 과거 추천 종목의 7d/30d 수익률, KOSPI 대비 알파, 적중률, 샤프, MDD 산출.
+    수익률·알파는 왕복 거래비용(ROUND_TRIP_COST_PCT) 차감한 순(net) 기준.
+    MDD는 rec_date별 등비중 포트폴리오 자산곡선의 최대낙폭(동일자 추천은 병렬 보유).
     """
     since = date.today() - timedelta(days=days)
     async with pg_pool.acquire() as conn:
@@ -2797,74 +3555,127 @@ async def backtest(days: int = Query(default=180, ge=30, le=365)):
                    alpha_7d, alpha_30d, kospi_return_7d, kospi_return_30d, rec_date
             FROM recommendation_performance
             WHERE rec_date >= $1
+            ORDER BY rec_date
         """, since)
 
     if not rows:
         return {"period_days": days, "n": 0, "msg": "데이터 없음"}
 
-    def _summary(returns: list, alphas: list) -> dict:
-        if not returns:
+    cost = ROUND_TRIP_COST_PCT
+
+    def _date_curve(window_rows: list, col: str) -> list:
+        """rec_date별 등비중 평균 net 수익률 → 시간순 자산곡선 입력."""
+        by_date: dict = {}
+        for r in window_rows:
+            v = r[col]
+            if v is not None:
+                by_date.setdefault(r["rec_date"], []).append(float(v) - cost)
+        return [sum(v) / len(v) for _, v in sorted(by_date.items())]
+
+    def _summary(net_returns: list, net_alphas: list, mdd: float) -> dict:
+        if not net_returns:
             return {"n": 0}
-        n = len(returns)
-        avg_ret = sum(returns) / n
-        sd = (sum((r - avg_ret) ** 2 for r in returns) / n) ** 0.5 if n > 1 else 0
-        win = sum(1 for r in returns if r > 0) / n * 100
+        n = len(net_returns)
+        avg_ret = sum(net_returns) / n
+        sd = (sum((r - avg_ret) ** 2 for r in net_returns) / n) ** 0.5 if n > 1 else 0
+        win = sum(1 for r in net_returns if r > 0) / n * 100
         # 일간 변동성 가정 안 하고 단순 샤프 근사 (mean/sd, RFR=0)
         sharpe = avg_ret / sd if sd > 0 else 0
-        mdd = min(returns)
-        avg_alpha = sum(alphas) / len(alphas) if alphas else None
+        avg_alpha = sum(net_alphas) / len(net_alphas) if net_alphas else None
         return {
             "n": n,
             "avg_return_pct": round(avg_ret, 2),
             "win_rate_pct": round(win, 1),
             "stdev": round(sd, 2),
             "sharpe": round(sharpe, 2),
-            "max_drawdown_pct": round(mdd, 2),
+            "max_drawdown_pct": mdd,
             "avg_alpha_pct": round(avg_alpha, 2) if avg_alpha is not None else None,
         }
 
     overall = {}
     for window in ("7d", "30d"):
-        rs = [float(r[f"return_{window}"]) for r in rows if r[f"return_{window}"] is not None]
-        als = [float(r[f"alpha_{window}"]) for r in rows if r[f"alpha_{window}"] is not None]
-        overall[window] = _summary(rs, als)
+        rs  = [float(r[f"return_{window}"]) - cost for r in rows
+               if r[f"return_{window}"] is not None]
+        als = [float(r[f"alpha_{window}"]) - cost for r in rows
+               if r[f"alpha_{window}"] is not None]
+        mdd = _max_drawdown(_date_curve(rows, f"return_{window}"))
+        overall[window] = _summary(rs, als, mdd)
 
     by_rec = {}
     for rec in ("강력매수", "매수관심"):
-        rs7  = [float(r["return_7d"]) for r in rows
-                if r["recommendation"] == rec and r["return_7d"] is not None]
-        als7 = [float(r["alpha_7d"]) for r in rows
-                if r["recommendation"] == rec and r["alpha_7d"] is not None]
-        by_rec[rec] = _summary(rs7, als7)
+        sub  = [r for r in rows if r["recommendation"] == rec]
+        rs7  = [float(r["return_7d"]) - cost for r in sub if r["return_7d"] is not None]
+        als7 = [float(r["alpha_7d"]) - cost for r in sub if r["alpha_7d"] is not None]
+        mdd7 = _max_drawdown(_date_curve(sub, "return_7d"))
+        by_rec[rec] = _summary(rs7, als7, mdd7)
+
+    # 자산곡선(7d): rec_date별 등비중 포트폴리오 vs KOSPI 누적 수익률(%)
+    ec_by_date: dict = {}
+    for r in rows:
+        if r["return_7d"] is not None:
+            ec_by_date.setdefault(r["rec_date"], []).append((
+                float(r["return_7d"]) - cost,
+                float(r["kospi_return_7d"]) if r["kospi_return_7d"] is not None else None))
+    equity_curve = []
+    s_eq = k_eq = 1.0
+    for d in sorted(ec_by_date):
+        day = ec_by_date[d]
+        kk = [x[1] for x in day if x[1] is not None]
+        s_eq *= (1 + (sum(x[0] for x in day) / len(day)) / 100.0)
+        k_eq *= (1 + (sum(kk) / len(kk) if kk else 0.0) / 100.0)
+        equity_curve.append({"date": str(d),
+                             "strategy_pct": round((s_eq - 1) * 100, 2),
+                             "kospi_pct": round((k_eq - 1) * 100, 2)})
 
     return {
         "period_days": days,
         "total_recommendations": len(rows),
+        "round_trip_cost_pct": cost,
         "overall": overall,
         "by_recommendation_7d": by_rec,
+        "equity_curve": equity_curve,
     }
 
 
+@app.post("/performance/recompute")
+async def m_recompute_performance():
+    """기존 recommendation_performance 행을 OHLCV 종가로 재계산 (라벨 정정).
+    OHLCV 부재(보존기간 초과) 행은 skipped로 집계하고 기존 값 유지."""
+    return await update_performance_prices(force=True)
+
+
 @app.post("/learn-weights")
-async def learn_weights(days: int = Query(default=90, ge=14, le=365)):
+async def learn_weights(days: int = Query(default=90, ge=14, le=365),
+                        segment: str = Query(default="all")):
     """
     백테스트 기반 공식별 가중치 학습.
     각 공식이 '매수' 신호를 낸 종목들의 평균 7일 수익률 - '매도' 신호 종목 평균 = edge
-    edge가 큰 공식일수록 가중치 ↑ → ensemble 보팅에 반영
+    edge가 큰 공식일수록 가중치 ↑ → ensemble 보팅에 반영.
+
+    segment: "all" | "regime:강세|중립|약세" | "sector:반도체|2차전지|..."
+    표본 크기로 edge 신뢰도 조정 (n<10이면 edge=0 처리).
     """
     since = date.today() - timedelta(days=days)
-    formulas = ["magic", "fscore", "altman", "peg", "momentum", "beneish"]
+    formulas = ENSEMBLE_FORMULAS
     async with pg_pool.acquire() as conn:
-        rows = await conn.fetch("""
+        where = "p.rec_date >= $1 AND p.return_7d IS NOT NULL AND p.entry_price > 0"
+        params: list = [since]
+        if segment.startswith("regime:"):
+            params.append(segment.split(":", 1)[1])
+            where += f" AND EXISTS(SELECT 1 FROM market_regime mr WHERE mr.dt=s.score_date AND mr.regime=${len(params)})"
+        elif segment.startswith("sector:"):
+            params.append(segment.split(":", 1)[1])
+            where += f" AND s.sector = ${len(params)}"
+        rows = await conn.fetch(f"""
             SELECT s.signals, p.return_7d, p.return_30d
             FROM stock_scores s
             JOIN recommendation_performance p
               ON s.stock_code = p.stock_code AND s.score_date = p.rec_date
-            WHERE p.rec_date >= $1 AND p.return_7d IS NOT NULL
-        """, since)
+            WHERE {where}
+        """, *params)
 
         if not rows:
-            return {"period_days": days, "sample": 0,
+            return {"period_days": days, "segment": segment, "sample": 0,
                     "msg": "백테스트 표본 부족 — 추천·성과 데이터 누적 후 재학습",
                     "weights": {f: 1.0 for f in formulas}}
 
@@ -2881,15 +3692,21 @@ async def learn_weights(days: int = Query(default=90, ge=14, le=365)):
                     buy_rets.append(float(r["return_7d"]))
                 elif sig == "매도":
                     sell_rets.append(float(r["return_7d"]))
-            avg_buy  = sum(buy_rets)/len(buy_rets)   if buy_rets  else 0.0
-            avg_sell = sum(sell_rets)/len(sell_rets) if sell_rets else 0.0
+            n_b, n_s = len(buy_rets), len(sell_rets)
+            avg_buy  = sum(buy_rets)/n_b   if n_b  else 0.0
+            avg_sell = sum(sell_rets)/n_s if n_s else 0.0
+            raw_edge = avg_buy - avg_sell
+            # 표본 신뢰도 (shrinkage): n<10이면 edge=0, n>=30이면 풀가중. 사이는 선형
+            n_min = min(n_b, n_s) if (n_b and n_s) else max(n_b, n_s)
+            shrink = max(0.0, min(1.0, (n_min - 10) / 20.0))
+            edge = raw_edge * shrink
             out[f] = {
-                "buy_n": len(buy_rets), "buy_avg_return_7d": round(avg_buy, 2),
-                "sell_n": len(sell_rets), "sell_avg_return_7d": round(avg_sell, 2),
-                "edge": round(avg_buy - avg_sell, 2),
+                "buy_n": n_b, "buy_avg_return_7d": round(avg_buy, 2),
+                "sell_n": n_s, "sell_avg_return_7d": round(avg_sell, 2),
+                "raw_edge": round(raw_edge, 2), "shrink": round(shrink, 2),
+                "edge": round(edge, 2),
             }
 
-        # edge 양수만 가중치 부여, 합 6 (균등) 으로 정규화
         edges = {f: max(0.0, out[f]["edge"]) for f in formulas}
         total_edge = sum(edges.values())
         if total_edge > 0:
@@ -2898,15 +3715,44 @@ async def learn_weights(days: int = Query(default=90, ge=14, le=365)):
             weights = {f: 1.0 for f in formulas}
 
         await conn.execute("""
-            INSERT INTO weight_config (config_date, weights, period_days, sample_size)
-            VALUES (CURRENT_DATE, $1, $2, $3)
-            ON CONFLICT (config_date) DO UPDATE
-              SET weights=$1, period_days=$2, sample_size=$3
-        """, json.dumps(weights), days, len(rows))
+            INSERT INTO weight_config (config_date, segment, weights, period_days, sample_size)
+            VALUES (CURRENT_DATE, $1, $2, $3, $4)
+            ON CONFLICT (config_date, segment) DO UPDATE
+              SET weights=$2, period_days=$3, sample_size=$4
+        """, segment, json.dumps(weights), days, len(rows))
 
-    return {"period_days": days, "sample": len(rows),
+    return {"period_days": days, "segment": segment, "sample": len(rows),
             "by_formula": out, "weights": weights,
-            "applied": "다음 /score/calculate 부터 자동 적용"}
+            "applied": "다음 /score/calculate 부터 자동 적용 (segment 매칭 시)"}
+
+
+@app.post("/calibrate/sentiment")
+async def trigger_calibrate_sentiment():
+    """catalyst × time_horizon별 사후 reliability 수동 갱신"""
+    return await calibrate_sentiment_reliability()
+
+
+@app.post("/calibrate/source")
+async def trigger_calibrate_source():
+    """출처별 credibility 수동 갱신"""
+    return await calibrate_source_credibility()
+
+
+@app.get("/calibrate/status")
+async def calibrate_status():
+    """학습된 catalyst×horizon reliability + 상위/하위 source credibility 조회"""
+    async with pg_pool.acquire() as conn:
+        sr = await conn.fetch(
+            "SELECT catalyst, time_horizon, sample_size, avg_return_3d, "
+            "hit_ratio_3d, reliability_score, last_updated "
+            "FROM sentiment_reliability ORDER BY reliability_score DESC")
+        sc = await conn.fetch(
+            "SELECT source, credibility, sample_size, hit_ratio_3d, avg_signed_return_3d "
+            "FROM news_source_credibility ORDER BY credibility DESC")
+    return {
+        "sentiment_reliability": [dict(r) for r in sr],
+        "source_credibility": [dict(r) for r in sc],
+    }
 
 
 @app.get("/learn-weights")
@@ -3806,6 +4652,71 @@ async def _build_rag_context(conn, code: str) -> tuple[str, dict]:
     regime, _ = await calc_market_regime(conn)
     ctx.append(f"· 시장 레짐: {regime}")
 
+    # 단기 가격 추세 (5d/20d 수익률) — 떨어지는 칼날 진단
+    try:
+        ret_5d, ret_20d = await calc_short_returns(conn, code)
+        if ret_5d != 0.0 or ret_20d != 0.0:
+            warn = ""
+            if ret_5d <= -8.0 or ret_20d <= -15.0:
+                warn = " ⚠️ 강한 단기약세 (등급 강등 트리거)"
+            elif ret_5d <= -5.0 or ret_20d <= -10.0:
+                warn = " ⚠️ 단기약세 (한 단계 강등 트리거)"
+            ctx.append(f"· 단기 추세: 5일 {ret_5d:+.1f}% / 20일 {ret_20d:+.1f}%{warn}")
+    except Exception:
+        pass
+
+    # 공매도 잔고 변화 (5일 추세) — 시장 매도 압력 인디케이터
+    try:
+        shorts = await conn.fetch("""
+            SELECT dt, short_balance_qty, trade_weight FROM stock_short_sale
+            WHERE stock_code=$1 ORDER BY dt DESC LIMIT 5
+        """, code)
+        if len(shorts) >= 2:
+            latest_bal = shorts[0]["short_balance_qty"] or 0
+            oldest_bal = shorts[-1]["short_balance_qty"] or 0
+            latest_w = shorts[0]["trade_weight"] or 0
+            if oldest_bal > 0:
+                chg = (latest_bal - oldest_bal) / oldest_bal * 100
+                trend = "감소" if chg < -3 else ("증가" if chg > 3 else "유지")
+                ctx.append(f"· 공매도: 거래비중 {latest_w:.1f}% / 5일 잔고변화 {chg:+.1f}% ({trend})")
+    except Exception:
+        pass
+
+    # 외국인 순매수 추세 (5일 합)
+    try:
+        flows = await conn.fetch("""
+            SELECT foreign_net, institution_net FROM stock_ohlcv
+            WHERE stock_code=$1 AND dt >= CURRENT_DATE - INTERVAL '7 days'
+            ORDER BY dt DESC LIMIT 5
+        """, code)
+        if flows:
+            f_sum = sum(int(r["foreign_net"] or 0) for r in flows)
+            i_sum = sum(int(r["institution_net"] or 0) for r in flows)
+            ctx.append(f"· 수급(5일 합): 외국인 {f_sum/1e8:+.0f}억 / 기관 {i_sum/1e8:+.0f}억")
+    except Exception:
+        pass
+
+    # 최근 14일 DART 공시 — 정정·계약 등 시장 민감 키워드 강조
+    try:
+        discs = await conn.fetch("""
+            SELECT rcept_dt, report_nm FROM dart_disclosures
+            WHERE stock_code=$1
+              AND rcept_dt::date >= CURRENT_DATE - INTERVAL '14 days'
+            ORDER BY rcept_dt DESC LIMIT 5
+        """, code)
+        if discs:
+            ctx.append("· 최근 공시(14일):")
+            for d in discs:
+                tag = ""
+                nm = d["report_nm"] or ""
+                if "정정" in nm or "기재정정" in nm:
+                    tag = " ⚠️정정"
+                elif "단일판매" in nm or "공급계약" in nm:
+                    tag = " 💰계약"
+                ctx.append(f"  - {d['rcept_dt']} {nm.strip()}{tag}")
+    except Exception:
+        pass
+
     return "\n".join(ctx), meta
 
 
@@ -3817,6 +4728,12 @@ _DEEP_SYSTEM = (
     "밸류에이션(PER·PBR·DCF안전마진) > 뉴스 catalyst·모멘텀 > 단기 수급.\n"
     "주어진 데이터에 근거해서만 판단하고 데이터에 없는 사실을 지어내지 마세요.\n"
     "퀀트 시스템판정과 다른 결론을 내릴 경우 그 이유를 thesis에 명확히 쓰세요.\n"
+    "민감 신호 가드: "
+    "(1) 단기 추세 5일 ≤ -5% 또는 20일 ≤ -10%면 '떨어지는 칼날' 위험 — 펀더 강해도 '매수' 보류 권고. "
+    "(2) 최근 14일 ⚠️정정 공시가 있고 시장 신뢰 영향이 의심되면 risks에 반드시 기재. "
+    "(3) 공매도 잔고 증가 + 거래비중 10% 초과는 매도 압력 강함 → 매수 등급 하향. "
+    "(4) PER > 80은 'valuation_view: 고평가'로 명시. "
+    "(5) 외국인 5일 누적 매도 우세면 risks에 수급 악화 명시.\n"
     "반드시 아래 스키마의 유효한 JSON 객체 하나만 출력하세요. 마크다운·설명문 금지."
 )
 
@@ -3842,17 +4759,142 @@ async def _exaone_json(client, system: str, user: str, max_tokens: int = 900) ->
                          {"role": "user", "content": user}],
             "max_tokens": max_tokens, "temperature": 0.1}, timeout=180)
         c = r.json()["choices"][0]["message"]["content"]
-        c = c.replace("```json", "").replace("```", "").strip()
-        if not c.startswith("{"):           # 모델이 JSON 앞뒤에 설명을 붙인 경우
-            s, e = c.find("{"), c.rfind("}")
-            if s != -1 and e > s:
-                c = c[s:e + 1]
-        return json.loads(c)
+        # 1차: 정상 JSON 추출 — 첫 객체만 (모델이 JSON 뒤에 코멘트 붙이는 경우 방어)
+        parsed = _extract_json(c)
+        if parsed:
+            return parsed
+        # 2차: 첫 { ... } 균형 잡힌 부분만 추출 후 재시도
+        s = c.find("{")
+        if s == -1:
+            return {}
+        depth = 0
+        for i in range(s, len(c)):
+            if c[i] == "{": depth += 1
+            elif c[i] == "}":
+                depth -= 1
+                if depth == 0:
+                    sub = c[s:i+1].translate({k: " " for k in range(0x20) if k not in (0x09, 0x0a, 0x0d)})
+                    try:
+                        return json.loads(sub)
+                    except Exception:
+                        break
+        return {}
     except Exception as e:
         logger.warning("deep.exaone_err", error=str(e))
         return {}
 
 
+def _extract_json(text: str) -> dict:
+    """LLM 응답 텍스트에서 JSON 객체 추출 (Markdown·접두사 방어)."""
+    if not text:
+        return {}
+    try:
+        c = text.replace("```json", "").replace("```", "").strip()
+        if not c.startswith("{"):
+            s, e = c.find("{"), c.rfind("}")
+            if s != -1 and e > s:
+                c = c[s:e + 1]
+        c = c.translate({i: " " for i in range(0x20) if i not in (0x09, 0x0a, 0x0d)})
+        return json.loads(c)
+    except Exception:
+        return {}
+
+
+class _GeminiDeepResponse(BaseModel):
+    """Gemini response_schema (Structured Output) — 프롬프트에서 스키마 텍스트 제거 → 입력 토큰 절감."""
+    recommendation: Literal["강력매수", "매수", "중립", "매도", "강력매도"]
+    conviction: int = Field(ge=1, le=5)
+    thesis: str
+    key_points: list[str] = Field(default_factory=list)
+    risks: list[str] = Field(default_factory=list)
+    catalyst_watch: list[str] = Field(default_factory=list)
+    valuation_view: Literal["저평가", "적정", "고평가"]
+    time_horizon: Literal["단기", "중기", "장기"]
+    target_price: int
+    stop_loss: int
+
+
+async def _gemini_json(system: str, user: str) -> tuple[dict, int]:
+    """Gemini 2.5 Pro 호출 — 토큰 절감 옵션 적용:
+      A. system_instruction 분리 → implicit prefix cache hit (캐시 시 입력 75%↓)
+      B. response_schema (Pydantic) → 프롬프트 스키마 텍스트 제거 + JSON 출력 강제
+      C. max_output_tokens=2000 → thinking+응답 합산 상한 (폭주 방지)
+    returns: (parsed_json, estimated_cost_krw)
+    """
+    if not GEMINI_API_KEY:
+        return {}, 0
+    # === 글로벌 일일 1회 한도 ===
+    try:
+        async with pg_pool.acquire() as conn:
+            cnt = await conn.fetchval(
+                "SELECT COUNT(*) FROM gemini_call_log WHERE called_at::date = CURRENT_DATE")
+        if cnt and int(cnt) >= 1:
+            logger.warning("gemini.daily_limit", source="score_engine", today_count=int(cnt))
+            return {}, 0
+    except Exception as e:
+        logger.warning("gemini.limit_check_err", error=str(e))
+    try:
+        from google import genai
+        from google.genai import types
+        client = genai.Client(api_key=GEMINI_API_KEY)
+        config = types.GenerateContentConfig(
+            system_instruction=system,
+            temperature=0.2,
+            response_mime_type="application/json",
+            response_schema=_GeminiDeepResponse,
+            max_output_tokens=4000,  # Pro thinking + 응답 합산 — 비용 폭주로 8000→4000 축소
+        )
+        resp = await asyncio.to_thread(
+            client.models.generate_content,
+            model=GEMINI_MODEL,
+            contents=user,
+            config=config,
+        )
+        text = getattr(resp, "text", "") or ""
+        parsed = _extract_json(text)
+        # 비용 추정 (Gemini 2.5 Pro: $1.25/M input + $10/M output, 환율 1400원/$ 가정)
+        # ⚠️ thinking 토큰은 candidates_token_count에 안 들어감 → total - prompt 로 출력 전체 산출
+        usage = getattr(resp, "usage_metadata", None)
+        cost_krw = 0
+        in_tok = out_tok = cached_tok = 0
+        if usage:
+            in_tok     = getattr(usage, "prompt_token_count", 0) or 0
+            total_tok  = getattr(usage, "total_token_count", 0) or 0
+            cached_tok = getattr(usage, "cached_content_token_count", 0) or 0
+            # 출력 전체(candidates + thinking) = total - prompt
+            out_tok = max(total_tok - in_tok, getattr(usage, "candidates_token_count", 0) or 0)
+            paid_in = max(in_tok - cached_tok, 0)
+            cost_usd = (paid_in / 1_000_000 * 1.25) + (cached_tok / 1_000_000 * 0.31) + (out_tok / 1_000_000 * 10.0)
+            cost_krw = int(cost_usd * 1400)
+        # 일일 한도 카운터 기록 (호출 성사된 경우만)
+        try:
+            async with pg_pool.acquire() as conn:
+                await conn.execute(
+                    "INSERT INTO gemini_call_log (source, cost_krw) VALUES ($1, $2)",
+                    "score_engine", cost_krw)
+        except Exception:
+            pass
+        if not parsed:
+            finish = ""
+            try:
+                cands = getattr(resp, "candidates", None) or []
+                if cands:
+                    finish = str(getattr(cands[0], "finish_reason", "") or "")
+            except Exception:
+                pass
+            logger.warning("deep.gemini_empty",
+                           text_len=len(text), in_tok=in_tok, out_tok=out_tok,
+                           cached=cached_tok, finish=finish, text_head=text[:200])
+        else:
+            logger.info("deep.gemini_ok",
+                        in_tok=in_tok, out_tok=out_tok, cached=cached_tok,
+                        cost_krw=cost_krw)
+        return parsed, cost_krw
+    except Exception as e:
+        logger.warning("deep.gemini_err", error=str(e))
+        return {}, 0
+
+
 def _norm_int(v) -> int:
     try:
         return int(float(v))
@@ -3860,63 +4902,150 @@ def _norm_int(v) -> int:
         return 0
 
 
-async def run_deep_analysis(conn, client, code: str, save: bool = True) -> dict:
-    ctx, meta = await _build_rag_context(conn, code)
-    if "재무: DART 연간 재무데이터 없음" in ctx and meta["quant_score"] == 0.0:
-        return {"code": code, "error": "데이터 부족 (재무·퀀트 모두 없음)"}
-
-    user = (f"[분석 대상]\n{ctx}\n\n"
-            f"위 데이터를 종합해 버핏 가치투자 관점에서 매수/매도를 판단하세요.\n"
-            f"JSON 스키마:\n{_DEEP_SCHEMA}")
-    a = await _exaone_json(client, _DEEP_SYSTEM, user)
-
+def _normalize_llm(a: dict, tg: dict) -> dict:
+    """LLM 원시 응답 → 정규화된 분석 dict (rec/conv/tp/sl/thesis/key_points/...)."""
+    def _clean(lst):
+        return [str(x).lstrip("-*•· ").strip()
+                for x in (lst or []) if str(x).strip()][:6]
     rec = a.get("recommendation", "중립")
     if rec not in _DEEP_RECS:
         rec = "중립"
     conv = max(0, min(5, _norm_int(a.get("conviction", 0))))
     tp, sl = _norm_int(a.get("target_price", 0)), _norm_int(a.get("stop_loss", 0))
-    tg = meta.get("targets") or {}              # LLM이 0 내면 ta-engine 목표가로 폴백
     if tp <= 0:
         tp = _norm_int(tg.get("t2") or tg.get("t1") or 0)
     if sl <= 0:
         sl = _norm_int(tg.get("stop_loss") or 0)
-    thesis = str(a.get("thesis", "") or "")[:1000]
-    parsed_ok = bool(a)
-
-    def _clean(lst):
-        return [str(x).lstrip("-*•· ").strip()
-                for x in (lst or []) if str(x).strip()][:6]
-
-    report = {
+    return {
         "recommendation": rec, "conviction": conv,
-        "thesis": thesis,
+        "thesis": str(a.get("thesis", "") or "")[:1000],
         "key_points": _clean(a.get("key_points")),
         "risks": _clean(a.get("risks")),
         "catalyst_watch": _clean(a.get("catalyst_watch")),
         "valuation_view": a.get("valuation_view", "-"),
         "time_horizon": a.get("time_horizon", "-"),
         "target_price": tp, "stop_loss": sl,
-        "parsed_ok": parsed_ok,
+        "parsed_ok": bool(a),
     }
 
-    if save and parsed_ok:
+
+async def run_deep_analysis(conn, client, code: str, save: bool = True,
+                             model: str = "hybrid") -> dict:
+    """LLM 종목 심층분석.
+    model:
+      'exaone' — EXAONE만 (기본 무료)
+      'gemini' — Gemini만 (키 필요, Grounding OFF)
+      'hybrid' — 둘 다 호출하여 비교 (키 있을 때 자동, 없으면 exaone 폴백)
+    """
+    ctx, meta = await _build_rag_context(conn, code)
+    if "재무: DART 연간 재무데이터 없음" in ctx and meta["quant_score"] == 0.0:
+        return {"code": code, "error": "데이터 부족 (재무·퀀트 모두 없음)"}
+
+    base_user = (f"[분석 대상]\n{ctx}\n\n"
+                 f"위 데이터를 종합해 버핏 가치투자 관점에서 매수/매도를 판단하세요.")
+    gem_user = base_user  # Gemini는 response_schema가 강제 → 스키마 텍스트 불필요
+    user = f"{base_user}\nJSON 스키마:\n{_DEEP_SCHEMA}"  # EXAONE용 (스키마 텍스트 포함)
+    tg = meta.get("targets") or {}
+
+    has_gemini = bool(GEMINI_API_KEY)
+    use_exaone = model in ("exaone", "hybrid") or (model == "gemini" and not has_gemini)
+    use_gemini = (model in ("gemini", "hybrid")) and has_gemini
+
+    exaone_norm = None
+    gemini_norm = None
+    cost_krw = 0
+
+    # Hybrid 모드: Gemini 먼저 호출 → 그 답을 EXAONE 컨텍스트에 주입 (reflection)
+    # → EXAONE이 Gemini 분석을 참고해 자기 판단 재평가 → 학습 효과 흉내
+    if use_gemini:
+        try:
+            raw, c_krw = await _gemini_json(_DEEP_SYSTEM, gem_user)
+            gemini_norm = _normalize_llm(raw, tg)
+            cost_krw += c_krw
+        except Exception as e:
+            logger.warning("deep.llm_err", llm="gemini", error=str(e))
+
+    if use_exaone:
+        ex_user = user
+        if gemini_norm and gemini_norm["parsed_ok"]:
+            ex_user += (
+                f"\n\n[참고: 외부 분석가(Gemini)는 다음과 같이 판단했습니다]\n"
+                f"- 판단: {gemini_norm['recommendation']} (확신도 {gemini_norm['conviction']}/5)\n"
+                f"- 밸류: {gemini_norm['valuation_view']} / 기간: {gemini_norm['time_horizon']}\n"
+                f"- 논거: {gemini_norm['thesis'][:400]}\n"
+                f"- 목표가 {gemini_norm['target_price']:,}원 / 손절 {gemini_norm['stop_loss']:,}원\n"
+                f"위 외부 분석을 참고하되, 데이터로 입증된 결론만 채택하세요. "
+                f"동의하면 같은 방향, 다르면 명확한 근거를 thesis에 쓰세요."
+            )
+        try:
+            res = await _exaone_json(client, _DEEP_SYSTEM, ex_user)
+            exaone_norm = _normalize_llm(res, tg)
+        except Exception as e:
+            logger.warning("deep.llm_err", llm="exaone", error=str(e))
+
+    # 메인 결과는 hybrid이면 Gemini 우선(외부 검색 반영), 아니면 호출한 쪽
+    main = gemini_norm if (model in ("gemini", "hybrid") and gemini_norm and gemini_norm["parsed_ok"]) else exaone_norm
+    if not main:
+        return {"code": code, "error": "LLM 응답 없음"}
+
+    agreement = None
+    if exaone_norm and gemini_norm and exaone_norm["parsed_ok"] and gemini_norm["parsed_ok"]:
+        agreement = exaone_norm["recommendation"] == gemini_norm["recommendation"]
+
+    report = {**main}
+    if exaone_norm and exaone_norm is not main:
+        report["exaone"] = {k: exaone_norm[k] for k in
+            ("recommendation", "conviction", "thesis", "target_price", "stop_loss")}
+    if gemini_norm and gemini_norm is not main:
+        report["gemini"] = {k: gemini_norm[k] for k in
+            ("recommendation", "conviction", "thesis", "target_price", "stop_loss")}
+
+    if save and main["parsed_ok"]:
+        # EXAONE 결과는 메인 컬럼 / Gemini 결과는 gemini_* 컬럼 분리 저장
+        # training_label = Gemini 답 (학습용 pseudo-ground-truth, 30d 후 사후검증 대상)
+        exa = exaone_norm or main
+        gem = gemini_norm or {"recommendation": None, "conviction": 0, "thesis": "",
+                               "target_price": 0, "stop_loss": 0}
+        training_label = gem["recommendation"] if gemini_norm and gemini_norm["parsed_ok"] else main["recommendation"]
+        # entry_price: 현재가 (사후 30d 수익률 계산 기준)
+        cur_price = await conn.fetchval(
+            "SELECT price FROM stock_technical WHERE stock_code=$1", code) or 0
         await conn.execute("""
             INSERT INTO deep_analysis (
                 stock_code, stock_name, analysis_date, recommendation, conviction,
-                target_price, stop_loss, thesis, report, rag_context, quant_score)
-            VALUES ($1,$2,CURRENT_DATE,$3,$4,$5,$6,$7,$8,$9,$10)
+                target_price, stop_loss, thesis, report, rag_context, quant_score,
+                gemini_recommendation, gemini_conviction, gemini_thesis,
+                gemini_target_price, gemini_stop_loss, gemini_report,
+                agreement, llm_cost_krw, training_label, entry_price)
+            VALUES ($1,$2,CURRENT_DATE,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20)
             ON CONFLICT (stock_code, analysis_date) DO UPDATE SET
                 recommendation=EXCLUDED.recommendation, conviction=EXCLUDED.conviction,
                 target_price=EXCLUDED.target_price, stop_loss=EXCLUDED.stop_loss,
                 thesis=EXCLUDED.thesis, report=EXCLUDED.report,
                 rag_context=EXCLUDED.rag_context, quant_score=EXCLUDED.quant_score,
+                gemini_recommendation=EXCLUDED.gemini_recommendation,
+                gemini_conviction=EXCLUDED.gemini_conviction,
+                gemini_thesis=EXCLUDED.gemini_thesis,
+                gemini_target_price=EXCLUDED.gemini_target_price,
+                gemini_stop_loss=EXCLUDED.gemini_stop_loss,
+                gemini_report=EXCLUDED.gemini_report,
+                agreement=EXCLUDED.agreement, llm_cost_krw=EXCLUDED.llm_cost_krw,
+                training_label=EXCLUDED.training_label,
+                entry_price=EXCLUDED.entry_price,
                 created_at=NOW()
-        """, code, meta["name"], rec, conv, tp, sl, thesis,
-            json.dumps(report, ensure_ascii=False), ctx, meta["quant_score"])
+        """, code, meta["name"],
+            exa["recommendation"], exa["conviction"], exa["target_price"],
+            exa["stop_loss"], exa["thesis"][:1000],
+            json.dumps(report, ensure_ascii=False), ctx, meta["quant_score"],
+            gem["recommendation"], gem["conviction"], (gem["thesis"] or "")[:1000],
+            gem["target_price"], gem["stop_loss"],
+            json.dumps(gemini_norm or {}, ensure_ascii=False),
+            agreement, cost_krw, training_label, int(cur_price))
 
     return {
         "code": code, "name": meta["name"],
         "quant_score": meta["quant_score"], "quant_rec": meta["quant_rec"],
+        "agreement": agreement, "llm_cost_krw": cost_krw,
         **report,
     }
 
@@ -3926,14 +5055,31 @@ def _fmt_deep(r: dict) -> str:
         return f"⚠️ {r['code']}: {r['error']}"
     icon = {"강력매수": "🟢🟢", "매수": "🟢", "중립": "⚪",
             "매도": "🔴", "강력매도": "🔴🔴"}.get(r["recommendation"], "⚪")
+    # 하이브리드 검증 표시 (EXAONE vs Gemini 일치 여부)
+    agr = r.get("agreement")
+    agr_tag = ""
+    if agr is True:
+        agr_tag = " ✅두AI일치"
+    elif agr is False:
+        agr_tag = " ⚠️AI의견갈림"
+    cost = r.get("llm_cost_krw", 0)
+    cost_tag = f" · 비용 {cost}원" if cost else ""
+
     lines = [
-        f"{icon} <b>{r['name']}({r['code']})</b> — AI심층분석",
+        f"{icon} <b>{r['name']}({r['code']})</b> — AI심층분석{agr_tag}",
         f"판단: <b>{r['recommendation']}</b> (확신도 {r['conviction']}/5) "
-        f"· 퀀트 {r['quant_score']:.0f}점[{r['quant_rec']}]",
+        f"· 퀀트 {r['quant_score']:.0f}점[{r['quant_rec']}]{cost_tag}",
         f"밸류: {r.get('valuation_view','-')} · 기간: {r.get('time_horizon','-')}",
         "",
         f"<b>📝 투자논거</b>\n{r['thesis']}",
     ]
+    # 두 LLM 의견 갈림 시 다른 쪽 의견 동봉
+    if agr is False:
+        other = r.get("exaone") or r.get("gemini")
+        if other:
+            label = "EXAONE" if "exaone" in r else "Gemini"
+            lines.append(f"\n<b>🔄 {label} 의견 (참고)</b>")
+            lines.append(f"  {other.get('recommendation','-')} {other.get('conviction',0)}/5 — {other.get('thesis','')[:200]}")
     if r.get("key_points"):
         lines.append("\n<b>✅ 핵심근거</b>")
         lines += [f"  • {p}" for p in r["key_points"][:5]]
@@ -3954,13 +5100,16 @@ def _fmt_deep(r: dict) -> str:
 async def deep_analysis(code: str,
                         refresh: bool = Query(default=True),
                         notify: bool = Query(default=False),
-                        include_context: bool = Query(default=False)):
-    """RAG + EXAONE 종목 심층분석 (온디맨드). refresh=false면 당일 저장본 반환."""
+                        include_context: bool = Query(default=False),
+                        model: str = Query(default="hybrid",
+                                           regex="^(exaone|gemini|hybrid)$")):
+    """RAG + LLM 종목 심층분석. model=hybrid(기본): EXAONE+Gemini 동시 호출하여 비교."""
     async with pg_pool.acquire() as conn:
         if not refresh:
             cached = await conn.fetchrow("""
                 SELECT stock_name, recommendation, conviction, target_price,
-                       stop_loss, thesis, report, quant_score, rag_context
+                       stop_loss, thesis, report, quant_score, rag_context,
+                       agreement, llm_cost_krw
                 FROM deep_analysis
                 WHERE stock_code=$1 AND analysis_date=CURRENT_DATE
             """, code)
@@ -3968,14 +5117,17 @@ async def deep_analysis(code: str,
                 rep = _jload(cached["report"])
                 out = {"code": code, "name": cached["stock_name"],
                        "quant_score": float(cached["quant_score"] or 0),
-                       "quant_rec": "-", "cached": True, **rep}
+                       "quant_rec": "-", "cached": True,
+                       "agreement": cached["agreement"],
+                       "llm_cost_krw": cached["llm_cost_krw"] or 0,
+                       **rep}
                 if include_context:
                     out["rag_context"] = cached["rag_context"]
                 if notify:
                     await send_telegram(_fmt_deep(out))
                 return out
         async with httpx.AsyncClient() as client:
-            res = await run_deep_analysis(conn, client, code, save=True)
+            res = await run_deep_analysis(conn, client, code, save=True, model=model)
     if include_context and not res.get("error"):
         async with pg_pool.acquire() as conn:
             res["rag_context"], _ = await _build_rag_context(conn, code)
@@ -3984,6 +5136,30 @@ async def deep_analysis(code: str,
     return res
 
 
+@app.get("/hybrid-stats")
+async def hybrid_stats(days: int = Query(default=30, ge=1, le=365)):
+    """EXAONE vs Gemini 일치율·비용 통계."""
+    async with pg_pool.acquire() as conn:
+        row = await conn.fetchrow("""
+            SELECT
+              COUNT(*) AS total,
+              COUNT(*) FILTER (WHERE agreement IS NOT NULL) AS dual,
+              COUNT(*) FILTER (WHERE agreement = true)  AS agreed,
+              COUNT(*) FILTER (WHERE agreement = false) AS disagreed,
+              COALESCE(SUM(llm_cost_krw), 0) AS cost_krw
+            FROM deep_analysis
+            WHERE analysis_date >= CURRENT_DATE - $1::int
+        """, days)
+        return {
+            "period_days": days,
+            "total_analyses": row["total"],
+            "dual_llm_runs": row["dual"],
+            "agreed": row["agreed"], "disagreed": row["disagreed"],
+            "agreement_rate": round(row["agreed"] / row["dual"] * 100, 1) if row["dual"] else None,
+            "total_cost_krw": int(row["cost_krw"]),
+        }
+
+
 @app.post("/deep-analysis/batch")
 async def deep_analysis_batch(kinds: str = Query(default="강력매수,매수관심"),
                               limit: int = Query(default=10, ge=1, le=30),
@@ -4029,3 +5205,1257 @@ async def deep_analysis_batch_job():
         logger.info("deep_batch.done")
     except Exception as e:
         logger.error("deep_batch.err", error=str(e))
+
+
+async def morning_brief_job():
+    """평일 08:00 아침 자동 브리핑.
+    - 보유 종목(user_portfolio) 손익 + 전일 17:00 deep_analysis 판단 표시
+    - 그 외 톱 추천도 deep_analysis 저장본 재사용 (LLM 재호출 없음 → 비용 0원)
+    - 분석이 없거나 7일 이상 stale이면 안내 후 /deep 수동 호출 권유
+    """
+    try:
+        async with pg_pool.acquire() as conn:
+            portfolio = await conn.fetch("""
+                SELECT stock_code, qty, buy_price FROM user_portfolio
+                WHERE active=true ORDER BY created_at DESC
+            """)
+            top_codes = [r["stock_code"] for r in await conn.fetch("""
+                SELECT stock_code FROM stock_scores
+                WHERE score_date=(SELECT MAX(score_date) FROM stock_scores)
+                  AND recommendation IN ('강력매수','매수관심')
+                ORDER BY total_score DESC LIMIT 10
+            """)]
+        own_codes = [p["stock_code"] for p in portfolio]
+        own_meta = {p["stock_code"]: p for p in portfolio}
+        seen = set()
+        codes = [c for c in (own_codes + top_codes) if not (c in seen or seen.add(c))]
+        if not codes:
+            return
+
+        async with pg_pool.acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT DISTINCT ON (stock_code)
+                       stock_code, stock_name, recommendation, conviction,
+                       thesis, agreement, target_price, quant_score, analysis_date
+                FROM deep_analysis
+                WHERE stock_code = ANY($1)
+                ORDER BY stock_code, analysis_date DESC
+            """, codes)
+            prices = {r["stock_code"]: r["price"] or 0 for r in await conn.fetch(
+                "SELECT stock_code, price FROM stock_technical WHERE stock_code = ANY($1)",
+                codes)}
+            month_cost = await conn.fetchval("""
+                SELECT COALESCE(SUM(llm_cost_krw), 0) FROM deep_analysis
+                WHERE analysis_date >= date_trunc('month', CURRENT_DATE)
+            """)
+
+        analyzed = {r["stock_code"]: r for r in rows}
+        today = date.today()
+        lines = [f"🌅 <b>아침 브리핑 ({today.isoformat()})</b>"]
+
+        if own_codes:
+            lines.append("\n<b>👜 보유 종목 진단</b>")
+            for code in own_codes:
+                p = own_meta[code]
+                price = prices.get(code, 0)
+                buy = p["buy_price"]
+                pnl_pct = (price - buy) / buy * 100 if buy and price else 0
+                pnl_won = (price - buy) * p["qty"] if buy and price else 0
+                r = analyzed.get(code)
+                if r:
+                    age = (today - r["analysis_date"]).days
+                    stale = " (분석 " + (f"{age}일 전" if age else "어제") + ")" if age else ""
+                    agr = r["agreement"]
+                    tag = "✅" if agr else ("⚠️" if agr is False else "")
+                    lines.append(
+                        f"  {tag} <b>{r['stock_name']}</b>({code}) "
+                        f"{p['qty']}주 @{buy:,}원 → 현재 {price:,}원 "
+                        f"<b>{pnl_pct:+.1f}%</b> ({pnl_won:+,}원)\n"
+                        f"     판단: <b>{r['recommendation']}</b> {r['conviction']}/5{stale} — {(r['thesis'] or '')[:120]}…"
+                    )
+                else:
+                    lines.append(
+                        f"  • ({code}) {p['qty']}주 @{buy:,}원 → 현재 {price:,}원 "
+                        f"<b>{pnl_pct:+.1f}%</b> ({pnl_won:+,}원) — 분석 없음, /deep {code}"
+                    )
+
+        new_codes = [c for c in codes if c not in own_meta and c in analyzed]
+        if new_codes:
+            lines.append("\n<b>📈 오늘의 추천 (전날 분석)</b>")
+            for code in new_codes:
+                r = analyzed[code]
+                age = (today - r["analysis_date"]).days
+                stale = f" · {age}일 전" if age else ""
+                agr = r["agreement"]
+                tag = "✅" if agr else ("⚠️" if agr is False else "")
+                lines.append(
+                    f"  {tag} <b>{r['stock_name']}</b>({code}) — "
+                    f"{r['recommendation']} {r['conviction']}/5 · "
+                    f"퀀트 {(r['quant_score'] or 0):.0f} · "
+                    f"목표 {(r['target_price'] or 0):,}원{stale}"
+                )
+
+        lines.append(f"\n💰 이번 달 LLM 비용: {int(month_cost)}원 (오늘 0원 — 저장본 재사용)")
+        lines.append(f"\n자세한 분석은 /deep &lt;코드&gt; 명령")
+        await send_telegram("\n".join(lines))
+        logger.info("morning_brief.done", stocks=len(analyzed), cost_krw=0)
+    except Exception as e:
+        logger.error("morning_brief.err", error=str(e))
+
+
+@app.post("/portfolio/register")
+async def portfolio_register(code: str = Query(...),
+                              buy_price: int = Query(..., gt=0),
+                              qty: int = Query(default=1, gt=0),
+                              memo: str = Query(default="")):
+    async with pg_pool.acquire() as conn:
+        name = await conn.fetchval(
+            "SELECT corp_name FROM dart_corps WHERE stock_code=$1", code) or ""
+        row = await conn.fetchrow("""
+            INSERT INTO user_portfolio (stock_code, stock_name, buy_price, qty, memo)
+            VALUES ($1, $2, $3, $4, $5) RETURNING id
+        """, code, name, buy_price, qty, memo)
+    return {"id": row["id"], "code": code, "name": name, "buy_price": buy_price, "qty": qty}
+
+
+@app.get("/portfolio")
+async def portfolio_list(active_only: bool = Query(default=True)):
+    where = "WHERE p.active=true" if active_only else ""
+    async with pg_pool.acquire() as conn:
+        rows = await conn.fetch(f"""
+            SELECT p.*, d.corp_name,
+                   (SELECT price FROM stock_technical WHERE stock_code=p.stock_code) AS current_price
+            FROM user_portfolio p
+            LEFT JOIN dart_corps d ON d.stock_code=p.stock_code
+            {where} ORDER BY p.created_at DESC
+        """)
+    out = []
+    for r in rows:
+        d = dict(r)
+        cur = int(d.get("current_price") or 0)
+        if cur and d["buy_price"]:
+            d["pnl_pct"] = round((cur - d["buy_price"]) / d["buy_price"] * 100, 2)
+            d["pnl_won"] = (cur - d["buy_price"]) * d["qty"]
+        out.append(d)
+    return out
+
+
+@app.delete("/portfolio/{portfolio_id}")
+async def portfolio_delete(portfolio_id: int):
+    async with pg_pool.acquire() as conn:
+        await conn.execute("UPDATE user_portfolio SET active=false WHERE id=$1", portfolio_id)
+    return {"status": "deactivated", "id": portfolio_id}
+
+
+@app.post("/morning-brief/run")
+async def morning_brief_manual():
+    """수동 트리거 — 평일 8시 기다리지 않고 즉시 실행."""
+    asyncio.create_task(morning_brief_job())
+    return {"status": "started", "note": "텔레그램 확인. 보유종목 + 톱 10 분석 ~2~3분 소요"}
+
+
+async def verify_predictions_job():
+    """매일 03:00 — 30일 전 분석들 사후 검증 (실제 30d 수익률 매칭 → 누가 맞았나)."""
+    try:
+        async with pg_pool.acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT id, stock_code, analysis_date, entry_price,
+                       recommendation, gemini_recommendation
+                FROM deep_analysis
+                WHERE verified_at IS NULL
+                  AND analysis_date <= CURRENT_DATE - INTERVAL '30 days'
+                  AND entry_price > 0
+                LIMIT 500
+            """)
+            ok = 0
+            for r in rows:
+                price_30d = await conn.fetchval("""
+                    SELECT close_price FROM stock_ohlcv
+                    WHERE stock_code=$1 AND dt >= $2::date + INTERVAL '30 days'
+                    ORDER BY dt ASC LIMIT 1
+                """, r["stock_code"], r["analysis_date"])
+                if not price_30d:
+                    continue
+                ret = (price_30d - r["entry_price"]) / r["entry_price"] * 100
+                # 판단 정답 여부: 매수면 수익률>0, 매도면 <0, 중립이면 |수익률|<5
+                def _correct(rec):
+                    if not rec: return None
+                    if rec in ("강력매수","매수"): return ret > 0
+                    if rec in ("강력매도","매도"): return ret < 0
+                    if rec == "중립": return abs(ret) < 5
+                    return None
+                await conn.execute("""
+                    UPDATE deep_analysis SET realized_price_30d=$1,
+                      realized_return_30d=$2, exaone_correct=$3, gemini_correct=$4,
+                      verified_at=NOW()
+                    WHERE id=$5
+                """, price_30d, ret,
+                    _correct(r["recommendation"]), _correct(r["gemini_recommendation"]),
+                    r["id"])
+                ok += 1
+        logger.info("verify_predictions.done", verified=ok)
+    except Exception as e:
+        logger.error("verify_predictions.err", error=str(e))
+
+
+@app.get("/labels/stats")
+async def labels_stats(days: int = Query(default=90, ge=1, le=730)):
+    """LLM 라벨 사후검증 통계 (Gemini vs EXAONE 정확도)."""
+    async with pg_pool.acquire() as conn:
+        row = await conn.fetchrow("""
+            SELECT
+              COUNT(*) FILTER (WHERE verified_at IS NOT NULL) AS verified,
+              COUNT(*) FILTER (WHERE gemini_correct = true)  AS gem_ok,
+              COUNT(*) FILTER (WHERE gemini_correct = false) AS gem_no,
+              COUNT(*) FILTER (WHERE exaone_correct = true)  AS exa_ok,
+              COUNT(*) FILTER (WHERE exaone_correct = false) AS exa_no,
+              AVG(realized_return_30d) FILTER (WHERE gemini_recommendation IN ('강력매수','매수')) AS avg_buy_ret,
+              AVG(realized_return_30d) FILTER (WHERE gemini_recommendation IN ('강력매도','매도')) AS avg_sell_ret
+            FROM deep_analysis
+            WHERE analysis_date >= CURRENT_DATE - $1::int
+        """, days)
+    g_tot = (row["gem_ok"] or 0) + (row["gem_no"] or 0)
+    e_tot = (row["exa_ok"] or 0) + (row["exa_no"] or 0)
+    return {
+        "period_days": days,
+        "verified": row["verified"],
+        "gemini_accuracy": round(row["gem_ok"] / g_tot * 100, 1) if g_tot else None,
+        "exaone_accuracy": round(row["exa_ok"] / e_tot * 100, 1) if e_tot else None,
+        "gemini_buy_avg_30d_return": round(row["avg_buy_ret"], 2) if row["avg_buy_ret"] else None,
+        "gemini_sell_avg_30d_return": round(row["avg_sell_ret"], 2) if row["avg_sell_ret"] else None,
+    }
+
+
+# ── Phase 4: 자동매매 신호 + 텔레그램 confirm 인프라 ─────────
+
+async def ensure_trading_tables():
+    """trading_orders + trading_daily_pnl 테이블 보장 (init_db에서 호출)."""
+    async with pg_pool.acquire() as conn:
+        # 기존 30분 default 컬럼을 6시간으로 ALTER
+        await conn.execute(
+            "ALTER TABLE IF EXISTS trading_orders "
+            "ALTER COLUMN expires_at SET DEFAULT (NOW() + INTERVAL '6 hour')")
+        await conn.execute("""
+            CREATE TABLE IF NOT EXISTS trading_orders (
+                id              SERIAL PRIMARY KEY,
+                stock_code      VARCHAR(10) NOT NULL,
+                stock_name      VARCHAR(100) DEFAULT '',
+                side            VARCHAR(4) NOT NULL,        -- buy/sell
+                qty             INTEGER NOT NULL,
+                price           INTEGER NOT NULL,
+                status          VARCHAR(16) DEFAULT 'pending',  -- pending/confirmed/cancelled/filled/expired
+                reason          TEXT DEFAULT '',
+                signal_score    DOUBLE PRECISION DEFAULT 0,
+                target_price    INTEGER DEFAULT 0,
+                stop_loss       INTEGER DEFAULT 0,
+                proposed_at     TIMESTAMPTZ DEFAULT NOW(),
+                confirmed_at    TIMESTAMPTZ,
+                filled_at       TIMESTAMPTZ,
+                expires_at      TIMESTAMPTZ DEFAULT (NOW() + INTERVAL '6 hour'),
+                external_order_id  VARCHAR(40),    -- KIS/키움 주문번호 (다음 단계)
+                is_paper        BOOLEAN DEFAULT true
+            )
+        """)
+        await conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_orders_status ON trading_orders(status)")
+        await conn.execute("""
+            CREATE TABLE IF NOT EXISTS trading_daily_pnl (
+                dt              DATE PRIMARY KEY,
+                start_capital   BIGINT DEFAULT 0,
+                end_capital     BIGINT DEFAULT 0,
+                realized_pnl    BIGINT DEFAULT 0,
+                unrealized_pnl  BIGINT DEFAULT 0,
+                trades_count    INTEGER DEFAULT 0,
+                halted          BOOLEAN DEFAULT false,
+                updated_at      TIMESTAMPTZ DEFAULT NOW()
+            )
+        """)
+
+
+# 자동매매 안전 설정 — 보수적 기본값
+TRADE_SETTINGS = {
+    "enabled":            True,     # 자동매매 ON/OFF 토글
+    "max_position_pct":   10.0,     # 종목당 자본 ≤ 10%
+    "daily_loss_limit_pct": -3.0,   # 일일 손실 -3% 도달 시 매매 중단
+    "max_orders_per_day": 10,
+    "min_conviction":     4,        # Gemini 확신도 ≥4
+    "require_agreement":  True,     # 두 LLM 일치 필수
+    "min_diagnosis_score": 3,       # 5가지 진단 ≥3
+    "default_capital":    10_000_000,
+    # 매도 신호 임계값
+    "stop_loss_pct":      -8.0,
+    "take_profit_pct":    15.0,
+    "rsi_overbought":     75,       # RSI ≥75 매도 신호
+}
+
+
+async def evaluate_buy_signal(conn, code: str) -> dict:
+    """매수 신호 종합 평가 — 모든 가드 통과해야 매수 제안.
+    반환: {ok: bool, reasons: [...], score: float, target_price, stop_loss, ...}
+    """
+    reasons_pass = []
+    reasons_fail = []
+
+    # 1. 추천 등급 = 강력매수
+    sc = await conn.fetchrow("""
+        SELECT total_score, recommendation, buy_votes, sell_votes
+        FROM stock_scores
+        WHERE stock_code=$1 AND score_date=(SELECT MAX(score_date) FROM stock_scores)
+    """, code)
+    if not sc:
+        return {"ok": False, "reasons_fail": ["퀀트 점수 없음"]}
+    if sc["recommendation"] != "강력매수":
+        reasons_fail.append(f"등급={sc['recommendation']} (강력매수만 허용)")
+    else:
+        reasons_pass.append(f"강력매수 {sc['total_score']:.0f}점")
+
+    # 2. Hybrid LLM 분석 — 일치 + conviction
+    da = await conn.fetchrow("""
+        SELECT recommendation, gemini_recommendation, agreement,
+               gemini_conviction, gemini_target_price, gemini_stop_loss
+        FROM deep_analysis
+        WHERE stock_code=$1 AND analysis_date=CURRENT_DATE
+    """, code)
+    if not da:
+        reasons_fail.append("당일 LLM 분석 없음 (먼저 /deep 호출)")
+    else:
+        if TRADE_SETTINGS["require_agreement"] and not da["agreement"]:
+            reasons_fail.append("EXAONE/Gemini 의견 불일치")
+        else:
+            reasons_pass.append("두 LLM 일치")
+        if (da["gemini_conviction"] or 0) < TRADE_SETTINGS["min_conviction"]:
+            reasons_fail.append(f"Gemini 확신도 {da['gemini_conviction']}/5 (< {TRADE_SETTINGS['min_conviction']})")
+        else:
+            reasons_pass.append(f"Gemini 확신도 {da['gemini_conviction']}/5")
+        if da["gemini_recommendation"] not in ("강력매수", "매수"):
+            reasons_fail.append(f"Gemini 판단={da['gemini_recommendation']}")
+        else:
+            reasons_pass.append(f"Gemini {da['gemini_recommendation']}")
+
+    # 3. 단기 가격 추세 — 떨어지는 칼날 회피
+    try:
+        ret_5d, ret_20d = await calc_short_returns(conn, code)
+        if ret_5d <= -5 or ret_20d <= -10:
+            reasons_fail.append(f"단기 약세 (5d {ret_5d:+.1f}% / 20d {ret_20d:+.1f}%)")
+        else:
+            reasons_pass.append(f"단기 추세 (5d {ret_5d:+.1f}%)")
+    except Exception:
+        pass
+
+    # 4. 시장 레짐 — 약세장 회피
+    regime = await conn.fetchval(
+        "SELECT regime FROM market_regime ORDER BY dt DESC LIMIT 1")
+    if regime == "약세":
+        reasons_fail.append(f"시장 약세장 회피")
+    elif regime:
+        reasons_pass.append(f"시장 {regime}")
+
+    # 5. 일일 손실 한도 — 도달 시 매매 중단
+    pnl = await conn.fetchrow(
+        "SELECT halted FROM trading_daily_pnl WHERE dt=CURRENT_DATE")
+    if pnl and pnl["halted"]:
+        reasons_fail.append("일일 손실 한도 도달 — 매매 중단")
+
+    # 6. 일일 주문 한도
+    today_orders = await conn.fetchval("""
+        SELECT COUNT(*) FROM trading_orders
+        WHERE proposed_at::date = CURRENT_DATE AND status != 'cancelled'
+    """) or 0
+    if today_orders >= TRADE_SETTINGS["max_orders_per_day"]:
+        reasons_fail.append(f"일일 주문 한도 {today_orders}/{TRADE_SETTINGS['max_orders_per_day']}")
+
+    # 7. 이미 보유 중이면 재매수 제한
+    already = await conn.fetchval(
+        "SELECT id FROM user_portfolio WHERE stock_code=$1 AND active=true", code)
+    if already:
+        reasons_fail.append(f"이미 보유 중 (id={already})")
+
+    cur_price = await conn.fetchval(
+        "SELECT price FROM stock_technical WHERE stock_code=$1", code) or 0
+
+    target = (da["gemini_target_price"] if da else 0) or 0
+    sl = (da["gemini_stop_loss"] if da else 0) or 0
+
+    return {
+        "ok": len(reasons_fail) == 0,
+        "code": code,
+        "current_price": int(cur_price),
+        "target_price": int(target),
+        "stop_loss": int(sl),
+        "score": sc["total_score"] if sc else 0,
+        "reasons_pass": reasons_pass,
+        "reasons_fail": reasons_fail,
+    }
+
+
+async def propose_buy_order(conn, code: str, capital: int = None) -> dict:
+    """매수 신호 평가 통과 시 trading_orders에 pending 주문 등록 + 텔레그램 confirm 메시지."""
+    if capital is None:
+        capital = TRADE_SETTINGS["default_capital"]
+    sig = await evaluate_buy_signal(conn, code)
+    if not sig["ok"]:
+        return {"ok": False, "code": code, "reasons_fail": sig["reasons_fail"]}
+
+    price = sig["current_price"]
+    if price <= 0:
+        return {"ok": False, "reasons_fail": ["현재가 0"]}
+
+    # 종목당 max_position_pct 만큼 매수 (수량 1주 미만이면 매수 불가)
+    position = int(capital * TRADE_SETTINGS["max_position_pct"] / 100)
+    qty = position // price
+    if qty < 1:
+        return {"ok": False, "reasons_fail": [f"종목당 한도({position:,}원) < 1주 가격({price:,}원)"]}
+
+    name = await conn.fetchval(
+        "SELECT corp_name FROM dart_corps WHERE stock_code=$1", code) or code
+    reason = " · ".join(sig["reasons_pass"][:5])
+
+    row = await conn.fetchrow("""
+        INSERT INTO trading_orders (
+            stock_code, stock_name, side, qty, price, status, reason,
+            signal_score, target_price, stop_loss, is_paper)
+        VALUES ($1,$2,'buy',$3,$4,'pending',$5,$6,$7,$8,true)
+        RETURNING id, expires_at
+    """, code, name, qty, price, reason, sig["score"], sig["target_price"], sig["stop_loss"])
+
+    # 텔레그램 confirm 메시지 + 버튼
+    msg = (
+        f"🚨 <b>매수 신호 — 승인 대기 (#{row['id']})</b>\n\n"
+        f"<b>{name}</b> ({code})\n"
+        f"수량: {qty}주 × {price:,}원 = {qty * price:,}원\n"
+        f"목표가: {sig['target_price']:,}원 / 손절: {sig['stop_loss']:,}원\n\n"
+        f"<b>✅ 통과 신호</b>\n" + "\n".join(f"  • {r}" for r in sig["reasons_pass"]) +
+        f"\n\n<i>6시간 내 응답 없으면 자동 만료</i>"
+    )
+    await send_telegram(msg, reply_markup=order_inline_buttons(row["id"], side="buy"))
+
+    return {"ok": True, "order_id": row["id"], "code": code, "qty": qty,
+            "price": price, "expires_at": row["expires_at"].isoformat()}
+
+
+@app.post("/trade/propose/{code}")
+async def trade_propose(code: str,
+                        capital: int = Query(default=10_000_000, ge=1_000_000)):
+    """수동 매수 신호 평가 + confirm 요청 (자동 cron으로도 호출됨)."""
+    async with pg_pool.acquire() as conn:
+        return await propose_buy_order(conn, code, capital)
+
+
+@app.post("/trade/cancel/{order_id}")
+async def trade_cancel(order_id: int):
+    async with pg_pool.acquire() as conn:
+        await conn.execute("""
+            UPDATE trading_orders SET status='cancelled'
+            WHERE id=$1 AND status='pending'
+        """, order_id)
+    return {"status": "cancelled", "order_id": order_id}
+
+
+@app.get("/trade/orders")
+async def trade_orders_list(status: str = Query(default=""),
+                             days: int = Query(default=7)):
+    async with pg_pool.acquire() as conn:
+        if status:
+            rows = await conn.fetch("""
+                SELECT * FROM trading_orders
+                WHERE status=$1 AND proposed_at >= NOW() - $2::int * INTERVAL '1 day'
+                ORDER BY proposed_at DESC LIMIT 50
+            """, status, days)
+        else:
+            rows = await conn.fetch("""
+                SELECT * FROM trading_orders
+                WHERE proposed_at >= NOW() - $1::int * INTERVAL '1 day'
+                ORDER BY proposed_at DESC LIMIT 50
+            """, days)
+    return [dict(r) for r in rows]
+
+
+@app.post("/trade/scan")
+async def trade_scan(capital: int = Query(default=10_000_000),
+                     auto_propose: bool = Query(default=False)):
+    """모든 강력매수 종목 평가 → 통과 종목 표시 (또는 자동 proposal)."""
+    async with pg_pool.acquire() as conn:
+        codes = [r["stock_code"] for r in await conn.fetch("""
+            SELECT stock_code FROM stock_scores
+            WHERE score_date=(SELECT MAX(score_date) FROM stock_scores)
+              AND recommendation='강력매수'
+            ORDER BY total_score DESC LIMIT 10
+        """)]
+        results = []
+        for c in codes:
+            sig = await evaluate_buy_signal(conn, c)
+            results.append({"code": c, **sig})
+            if auto_propose and sig["ok"]:
+                await propose_buy_order(conn, c, capital)
+    return {"evaluated": len(results), "results": results}
+
+
+@app.get("/trade/settings")
+async def trade_settings_get():
+    return {"current": TRADE_SETTINGS}
+
+
+async def evaluate_sell_signal(conn, code: str) -> dict:
+    """보유 종목 매도 신호 평가 — 손절·익절·등급 하락 도달 시 매도."""
+    pos = await conn.fetchrow("""
+        SELECT id, stock_name, buy_price, qty FROM user_portfolio
+        WHERE stock_code=$1 AND active=true LIMIT 1
+    """, code)
+    if not pos:
+        return {"ok": False, "reasons_fail": ["보유 아님"]}
+    cur = await conn.fetchval(
+        "SELECT price FROM stock_technical WHERE stock_code=$1", code) or 0
+    if cur <= 0:
+        return {"ok": False, "reasons_fail": ["현재가 0"]}
+    buy = pos["buy_price"]
+    pnl_pct = (cur - buy) / buy * 100
+
+    reasons = []
+    sig_type = None
+    # 1. 손절선 도달
+    if pnl_pct <= TRADE_SETTINGS["stop_loss_pct"]:
+        reasons.append(f"손절선 도달 ({pnl_pct:+.1f}%)")
+        sig_type = "stop_loss"
+    # 2. 익절선 도달
+    elif pnl_pct >= TRADE_SETTINGS["take_profit_pct"]:
+        reasons.append(f"익절선 도달 ({pnl_pct:+.1f}%)")
+        sig_type = "take_profit"
+    # 3. 등급 강력매도/매도관심으로 하락
+    sc = await conn.fetchrow("""
+        SELECT recommendation, total_score FROM stock_scores
+        WHERE stock_code=$1 AND score_date=(SELECT MAX(score_date) FROM stock_scores)
+    """, code)
+    if sc and sc["recommendation"] in ("강력매도", "매도관심"):
+        reasons.append(f"등급 하락 ({sc['recommendation']} {sc['total_score']:.0f}점)")
+        sig_type = sig_type or "grade_drop"
+    # 4. Gemini 매도 판단
+    da = await conn.fetchrow("""
+        SELECT gemini_recommendation, gemini_conviction FROM deep_analysis
+        WHERE stock_code=$1 AND analysis_date=CURRENT_DATE
+    """, code)
+    if da and da["gemini_recommendation"] in ("강력매도", "매도") and (da["gemini_conviction"] or 0) >= 4:
+        reasons.append(f"Gemini 매도 {da['gemini_conviction']}/5")
+        sig_type = sig_type or "llm_sell"
+    # 5. RSI 과매수 (≥75) — 단기 과열 정점 회피
+    rsi = await conn.fetchval(
+        "SELECT rsi FROM stock_technical WHERE stock_code=$1", code)
+    if rsi is not None and rsi >= TRADE_SETTINGS["rsi_overbought"]:
+        reasons.append(f"RSI 과매수 ({rsi:.0f} ≥ {TRADE_SETTINGS['rsi_overbought']})")
+        sig_type = sig_type or "rsi_overbought"
+    # 6. 외국인 5일 누적 순매도 우세
+    f_flow = await conn.fetchval("""
+        SELECT COALESCE(SUM(foreign_net), 0) FROM stock_ohlcv
+        WHERE stock_code=$1 AND dt >= CURRENT_DATE - INTERVAL '7 days'
+    """, code)
+    if f_flow is not None and int(f_flow) < -1_000_000_000:    # -10억 이상 순매도
+        reasons.append(f"외국인 5일 매도 {f_flow/1e8:+.0f}억")
+        sig_type = sig_type or "foreign_sell"
+    return {
+        "ok": bool(sig_type), "type": sig_type,
+        "current_price": int(cur), "buy_price": buy, "qty": pos["qty"],
+        "pnl_pct": round(pnl_pct, 2),
+        "pnl_won": (cur - buy) * pos["qty"],
+        "reasons": reasons, "portfolio_id": pos["id"], "stock_name": pos["stock_name"],
+    }
+
+
+async def propose_sell_order(conn, code: str) -> dict:
+    sig = await evaluate_sell_signal(conn, code)
+    if not sig["ok"]:
+        return {"ok": False, "code": code, **sig}
+    reason = " · ".join(sig["reasons"])
+    row = await conn.fetchrow("""
+        INSERT INTO trading_orders (
+            stock_code, stock_name, side, qty, price, status, reason,
+            is_paper)
+        VALUES ($1,$2,'sell',$3,$4,'pending',$5,true)
+        RETURNING id
+    """, code, sig["stock_name"], sig["qty"], sig["current_price"], reason)
+    icon = {"stop_loss": "🛑", "take_profit": "💰", "grade_drop": "⬇️", "llm_sell": "🤖"}.get(sig["type"], "🔻")
+    msg = (
+        f"{icon} <b>매도 신호 — 승인 대기 (#{row['id']})</b>\n\n"
+        f"<b>{sig['stock_name']}</b> ({code})\n"
+        f"{sig['qty']}주 @ 매수 {sig['buy_price']:,}원 → 현재 {sig['current_price']:,}원\n"
+        f"손익: <b>{sig['pnl_pct']:+.2f}%</b> ({sig['pnl_won']:+,}원)\n\n"
+        f"📌 사유: " + " / ".join(sig["reasons"])
+    )
+    await send_telegram(msg, reply_markup=order_inline_buttons(row["id"], side="sell"))
+    return {"ok": True, "order_id": row["id"], "code": code,
+            "qty": sig["qty"], "price": sig["current_price"], "type": sig["type"]}
+
+
+@app.post("/trade/sell-scan")
+async def trade_sell_scan():
+    """보유 종목 매도 신호 일괄 평가 + 자동 propose."""
+    async with pg_pool.acquire() as conn:
+        codes = [r["stock_code"] for r in await conn.fetch(
+            "SELECT stock_code FROM user_portfolio WHERE active=true")]
+        results = []
+        for c in codes:
+            sig = await evaluate_sell_signal(conn, c)
+            if sig["ok"]:
+                results.append(await propose_sell_order(conn, c))
+    return {"checked": len(codes), "proposed": len(results), "results": results}
+
+
+@app.post("/trade/confirm/{order_id}")
+async def trade_confirm_v2(order_id: int):    # noqa: F811 (이전 정의 override)
+    """매수/매도 confirm 통합 처리."""
+    async with pg_pool.acquire() as conn:
+        order = await conn.fetchrow(
+            "SELECT * FROM trading_orders WHERE id=$1 AND status='pending'", order_id)
+        if not order:
+            return {"error": "주문 없음 또는 이미 처리됨"}
+        if order["expires_at"] and order["expires_at"] < datetime.now(timezone.utc):
+            await conn.execute(
+                "UPDATE trading_orders SET status='expired' WHERE id=$1", order_id)
+            return {"error": "주문 만료"}
+        if order["side"] == "buy":
+            await conn.execute("""
+                INSERT INTO user_portfolio (stock_code, stock_name, buy_price, qty, memo)
+                VALUES ($1, $2, $3, $4, $5)
+            """, order["stock_code"], order["stock_name"], order["price"],
+                order["qty"], f"자동매매 #{order_id} (모의)")
+            msg = (f"✅ <b>매수 체결 #{order_id}</b>\n"
+                   f"{order['stock_name']}({order['stock_code']}) "
+                   f"{order['qty']}주 × {order['price']:,}원")
+        else:  # sell
+            # 보유 종목 비활성화 + 실현손익 계산
+            held = await conn.fetchrow("""
+                SELECT id, buy_price, qty FROM user_portfolio
+                WHERE stock_code=$1 AND active=true LIMIT 1
+            """, order["stock_code"])
+            realized = 0
+            if held:
+                realized = (order["price"] - held["buy_price"]) * order["qty"]
+                await conn.execute(
+                    "UPDATE user_portfolio SET active=false WHERE id=$1", held["id"])
+            # 일일 손익 누적
+            await conn.execute("""
+                INSERT INTO trading_daily_pnl (dt, realized_pnl, trades_count)
+                VALUES (CURRENT_DATE, $1, 1)
+                ON CONFLICT (dt) DO UPDATE SET
+                  realized_pnl = trading_daily_pnl.realized_pnl + EXCLUDED.realized_pnl,
+                  trades_count = trading_daily_pnl.trades_count + 1,
+                  updated_at = NOW()
+            """, realized)
+            sign = "🟢" if realized > 0 else "🔴"
+            msg = (f"{sign} <b>매도 체결 #{order_id}</b>\n"
+                   f"{order['stock_name']}({order['stock_code']}) "
+                   f"{order['qty']}주 × {order['price']:,}원\n"
+                   f"실현손익: {realized:+,}원")
+        await conn.execute("""
+            UPDATE trading_orders
+            SET status='filled', confirmed_at=NOW(), filled_at=NOW()
+            WHERE id=$1
+        """, order_id)
+        await send_telegram(msg)
+    return {"status": "filled", "order_id": order_id}
+
+
+async def auto_trade_scan_job():
+    """5분마다: 매수 신호 + 매도 신호 자동 스캔. 한도 도달 시 자동 halt."""
+    if not TRADE_SETTINGS.get("enabled", True):
+        return
+    try:
+        async with pg_pool.acquire() as conn:
+            pnl = await conn.fetchrow(
+                "SELECT realized_pnl, halted FROM trading_daily_pnl WHERE dt=CURRENT_DATE")
+            capital = TRADE_SETTINGS["default_capital"]
+            if pnl and not pnl["halted"]:
+                loss_pct = (pnl["realized_pnl"] or 0) / capital * 100
+                if loss_pct <= TRADE_SETTINGS["daily_loss_limit_pct"]:
+                    await conn.execute("""
+                        UPDATE trading_daily_pnl SET halted=true WHERE dt=CURRENT_DATE
+                    """)
+                    await send_telegram(
+                        f"🛑 <b>일일 손실 한도 도달</b>\n"
+                        f"손실 {loss_pct:.2f}% ≤ -{abs(TRADE_SETTINGS['daily_loss_limit_pct'])}%\n"
+                        f"오늘 자동매매 중단됨"
+                    )
+                    return
+            # 매도 스캔 먼저 (보유 종목 리스크 관리 우선)
+            sell_codes = [r["stock_code"] for r in await conn.fetch(
+                "SELECT stock_code FROM user_portfolio WHERE active=true")]
+            for c in sell_codes:
+                sig = await evaluate_sell_signal(conn, c)
+                if sig["ok"]:
+                    # 같은 종목 pending 매도 주문 있는지 체크 (중복 방지)
+                    dup = await conn.fetchval("""
+                        SELECT id FROM trading_orders
+                        WHERE stock_code=$1 AND side='sell' AND status='pending'
+                    """, c)
+                    if not dup:
+                        await propose_sell_order(conn, c)
+            # 매수 스캔
+            buy_codes = [r["stock_code"] for r in await conn.fetch("""
+                SELECT stock_code FROM stock_scores
+                WHERE score_date=(SELECT MAX(score_date) FROM stock_scores)
+                  AND recommendation='강력매수'
+                ORDER BY total_score DESC LIMIT 5
+            """)]
+            for c in buy_codes:
+                dup = await conn.fetchval("""
+                    SELECT id FROM trading_orders
+                    WHERE stock_code=$1 AND side='buy'
+                      AND proposed_at::date = CURRENT_DATE
+                      AND status IN ('pending','confirmed','filled')
+                """, c)
+                if dup:
+                    continue
+                sig = await evaluate_buy_signal(conn, c)
+                if sig["ok"]:
+                    await propose_buy_order(conn, c)
+        logger.info("auto_trade_scan.done")
+    except Exception as e:
+        logger.error("auto_trade_scan.err", error=str(e))
+
+
+async def update_daily_pnl_job():
+    """매일 16:00 — unrealized PNL 갱신 (보유 종목 평가손익)."""
+    try:
+        async with pg_pool.acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT p.stock_code, p.buy_price, p.qty,
+                       (SELECT price FROM stock_technical WHERE stock_code=p.stock_code) AS cur
+                FROM user_portfolio p WHERE active=true
+            """)
+            unrealized = sum(int(((r["cur"] or 0) - r["buy_price"]) * r["qty"]) for r in rows)
+            await conn.execute("""
+                INSERT INTO trading_daily_pnl (dt, unrealized_pnl)
+                VALUES (CURRENT_DATE, $1)
+                ON CONFLICT (dt) DO UPDATE SET
+                  unrealized_pnl = EXCLUDED.unrealized_pnl, updated_at = NOW()
+            """, unrealized)
+        logger.info("daily_pnl.updated", unrealized=unrealized)
+    except Exception as e:
+        logger.error("daily_pnl.err", error=str(e))
+
+
+@app.post("/trade/auto-scan")
+async def trade_auto_scan_trigger():
+    asyncio.create_task(auto_trade_scan_job())
+    return {"status": "started"}
+
+
+async def expire_stale_orders_job():
+    """매 30분 — pending 상태 + expires_at 지난 주문 자동 expired 처리."""
+    try:
+        async with pg_pool.acquire() as conn:
+            rows = await conn.fetch("""
+                UPDATE trading_orders SET status='expired'
+                WHERE status='pending' AND expires_at < NOW()
+                RETURNING id, stock_name, side
+            """)
+            for r in rows:
+                logger.info("order.expired", id=r["id"], side=r["side"])
+    except Exception as e:
+        logger.warning("expire_orders.err", error=str(e))
+
+
+@app.post("/trade/autotrade")
+async def trade_autotrade_toggle(enabled: bool = Query(...)):
+    """자동매매 ON/OFF 토글."""
+    TRADE_SETTINGS["enabled"] = enabled
+    await send_telegram(
+        f"⚙️ <b>자동매매 {'ON ✅' if enabled else 'OFF 🛑'}</b>\n"
+        f"<i>{'5분마다 신호 자동 스캔 작동 중' if enabled else '신호 스캔 일시 중단'}</i>"
+    )
+    return {"enabled": enabled}
+
+
+@app.post("/trade/settings")
+async def trade_settings_update(
+    max_position_pct: float | None = Query(default=None),
+    daily_loss_limit_pct: float | None = Query(default=None),
+    max_orders_per_day: int | None = Query(default=None),
+    min_conviction: int | None = Query(default=None),
+    require_agreement: bool | None = Query(default=None),
+    stop_loss_pct: float | None = Query(default=None),
+    take_profit_pct: float | None = Query(default=None),
+    rsi_overbought: int | None = Query(default=None),
+    default_capital: int | None = Query(default=None),
+):
+    """안전 설정 수정 — 자동매매 임계값 튜닝용."""
+    updated = {}
+    for k, v in [
+        ("max_position_pct", max_position_pct),
+        ("daily_loss_limit_pct", daily_loss_limit_pct),
+        ("max_orders_per_day", max_orders_per_day),
+        ("min_conviction", min_conviction),
+        ("require_agreement", require_agreement),
+        ("stop_loss_pct", stop_loss_pct),
+        ("take_profit_pct", take_profit_pct),
+        ("rsi_overbought", rsi_overbought),
+        ("default_capital", default_capital),
+    ]:
+        if v is not None:
+            TRADE_SETTINGS[k] = v
+            updated[k] = v
+    return {"updated": updated, "current": TRADE_SETTINGS}
+
+
+@app.get("/system/status")
+async def system_status():
+    """전체 시스템 상태 한눈에."""
+    async with pg_pool.acquire() as conn:
+        today_analyses = await conn.fetchval("""
+            SELECT COUNT(*) FROM deep_analysis WHERE analysis_date=CURRENT_DATE
+        """)
+        today_cost = await conn.fetchval("""
+            SELECT COALESCE(SUM(llm_cost_krw), 0) FROM deep_analysis
+            WHERE analysis_date=CURRENT_DATE
+        """)
+        month_cost = await conn.fetchval("""
+            SELECT COALESCE(SUM(llm_cost_krw), 0) FROM deep_analysis
+            WHERE analysis_date >= date_trunc('month', CURRENT_DATE)
+        """)
+        latest_score_date = await conn.fetchval(
+            "SELECT MAX(score_date) FROM stock_scores")
+        scored_today = await conn.fetchval(
+            "SELECT COUNT(*) FROM stock_scores WHERE score_date=$1",
+            latest_score_date) if latest_score_date else 0
+        strong_buy = await conn.fetchval("""
+            SELECT COUNT(*) FROM stock_scores
+            WHERE score_date=$1 AND recommendation='강력매수'
+        """, latest_score_date) if latest_score_date else 0
+        portfolio_count = await conn.fetchval(
+            "SELECT COUNT(*) FROM user_portfolio WHERE active=true")
+        today_orders = await conn.fetchrow("""
+            SELECT
+              COUNT(*) FILTER (WHERE status='pending')   AS pending,
+              COUNT(*) FILTER (WHERE status='filled')    AS filled,
+              COUNT(*) FILTER (WHERE status='cancelled') AS cancelled,
+              COUNT(*) FILTER (WHERE status='expired')   AS expired
+            FROM trading_orders WHERE proposed_at::date = CURRENT_DATE
+        """)
+        pnl = await conn.fetchrow("""
+            SELECT realized_pnl, unrealized_pnl, halted FROM trading_daily_pnl
+            WHERE dt=CURRENT_DATE
+        """)
+    return {
+        "trading": {
+            "enabled": TRADE_SETTINGS.get("enabled", True),
+            "halted": bool(pnl and pnl["halted"]),
+            "realized_pnl_today": int((pnl["realized_pnl"] if pnl else 0) or 0),
+            "unrealized_pnl_today": int((pnl["unrealized_pnl"] if pnl else 0) or 0),
+            "orders_today": dict(today_orders) if today_orders else {},
+        },
+        "analysis": {
+            "today_analyses": today_analyses,
+            "today_llm_cost_krw": int(today_cost or 0),
+            "month_llm_cost_krw": int(month_cost or 0),
+        },
+        "scoring": {
+            "latest_score_date": str(latest_score_date) if latest_score_date else None,
+            "scored_today": scored_today,
+            "strong_buy_count": strong_buy,
+        },
+        "portfolio": {
+            "active_positions": portfolio_count,
+        },
+        "settings": TRADE_SETTINGS,
+    }
+
+
+@app.get("/trade/pnl")
+async def trade_pnl_view(days: int = Query(default=30)):
+    async with pg_pool.acquire() as conn:
+        rows = await conn.fetch("""
+            SELECT * FROM trading_daily_pnl
+            WHERE dt >= CURRENT_DATE - $1::int ORDER BY dt DESC
+        """, days)
+    return [dict(r) for r in rows]
+
+
+async def weekly_performance_report():
+    """매주 일요일 09:00 — 지난 7/30일 성과 리포트 텔레그램 발송.
+    자동매매 신뢰도 측정 핵심: 등급별 승률·알파·MDD 추적.
+    """
+    try:
+        async with pg_pool.acquire() as conn:
+            # 등급별 30일 성과 (지난 90일 누적)
+            grade_rows = await conn.fetch("""
+                SELECT recommendation,
+                       COUNT(*) AS n,
+                       ROUND(AVG(return_7d)::numeric, 2) AS r7,
+                       ROUND(AVG(return_30d)::numeric, 2) AS r30,
+                       ROUND(AVG(alpha_30d)::numeric, 2) AS alpha30,
+                       ROUND((COUNT(*) FILTER (WHERE return_30d > 0)::numeric /
+                              NULLIF(COUNT(*) FILTER (WHERE return_30d IS NOT NULL), 0) * 100), 1) AS win30
+                FROM recommendation_performance
+                WHERE rec_date >= CURRENT_DATE - INTERVAL '90 days'
+                GROUP BY recommendation
+                ORDER BY r30 DESC NULLS LAST
+            """)
+            # 이번 주 추천 종목 7일 성과
+            week = await conn.fetchrow("""
+                SELECT COUNT(*) AS n,
+                       ROUND(AVG(return_7d)::numeric, 2) AS r7,
+                       ROUND(AVG(alpha_7d)::numeric, 2) AS alpha7,
+                       ROUND((COUNT(*) FILTER (WHERE return_7d > 0)::numeric /
+                              NULLIF(COUNT(*) FILTER (WHERE return_7d IS NOT NULL), 0) * 100), 1) AS win7
+                FROM recommendation_performance
+                WHERE rec_date >= CURRENT_DATE - INTERVAL '7 days'
+                  AND recommendation IN ('강력매수','매수관심')
+            """)
+            # 보유 종목 평가 (있으면)
+            portfolio = await conn.fetch("""
+                SELECT p.stock_code, p.stock_name, p.buy_price, p.qty,
+                       (SELECT price FROM stock_technical WHERE stock_code=p.stock_code) AS cur
+                FROM user_portfolio p WHERE active=true
+            """)
+        lines = [f"📊 <b>주간 성과 리포트 ({date.today()})</b>\n"]
+        lines.append("<b>📈 시스템 등급별 성과 (90일)</b>")
+        for r in grade_rows:
+            sign = "🟢" if (r["alpha30"] or 0) > 0 else "🔴" if (r["alpha30"] or 0) < -3 else "🟡"
+            lines.append(
+                f"{sign} {r['recommendation']}({r['n']}건): "
+                f"30일 {r['r30']}% / 알파 {r['alpha30']}% / 승률 {r['win30']}%"
+            )
+        if week and week["n"]:
+            lines.append(f"\n<b>📅 이번 주 매수 추천 ({week['n']}건)</b>")
+            lines.append(f"  7일 평균 {week['r7']}% / 알파 {week['alpha7']}% / 승률 {week['win7']}%")
+        if portfolio:
+            lines.append(f"\n<b>👜 보유 종목</b>")
+            total_buy = 0
+            total_cur = 0
+            for p in portfolio:
+                cur = int(p["cur"] or 0)
+                buy = p["buy_price"]
+                if not cur or not buy:
+                    continue
+                pnl_pct = (cur - buy) / buy * 100
+                v_buy = buy * p["qty"]
+                v_cur = cur * p["qty"]
+                total_buy += v_buy
+                total_cur += v_cur
+                lines.append(f"  {p['stock_name']}({p['stock_code']}): {pnl_pct:+.1f}% ({v_cur - v_buy:+,}원)")
+            if total_buy:
+                tot_pnl = (total_cur - total_buy) / total_buy * 100
+                lines.append(f"  <b>합계 {tot_pnl:+.2f}% ({total_cur - total_buy:+,}원)</b>")
+
+        lines.append(f"\n<i>알파>0이면 시스템이 시장보다 잘함. 알파<-3이면 자동매매 부적합.</i>")
+        await send_telegram("\n".join(lines))
+        logger.info("weekly_report.done")
+    except Exception as e:
+        logger.error("weekly_report.err", error=str(e))
+
+
+async def monthly_llm_comparison():
+    """매월 1일 — Gemini vs EXAONE vs 퀀트 정확도 비교 리포트 텔레그램."""
+    try:
+        async with pg_pool.acquire() as conn:
+            row = await conn.fetchrow("""
+                SELECT
+                  COUNT(*) FILTER (WHERE verified_at IS NOT NULL) AS verified,
+                  COUNT(*) FILTER (WHERE gemini_correct=true)  AS g_ok,
+                  COUNT(*) FILTER (WHERE gemini_correct=false) AS g_no,
+                  COUNT(*) FILTER (WHERE exaone_correct=true)  AS e_ok,
+                  COUNT(*) FILTER (WHERE exaone_correct=false) AS e_no,
+                  AVG(realized_return_30d) FILTER (WHERE gemini_recommendation IN ('강력매수','매수')) AS g_buy_ret,
+                  AVG(realized_return_30d) FILTER (WHERE recommendation IN ('강력매수','매수')) AS e_buy_ret,
+                  COUNT(*) FILTER (WHERE agreement=true) AS agreed,
+                  COUNT(*) FILTER (WHERE agreement=false) AS disagreed,
+                  SUM(llm_cost_krw) AS cost
+                FROM deep_analysis
+                WHERE analysis_date >= CURRENT_DATE - INTERVAL '30 days'
+            """)
+        g_tot = (row["g_ok"] or 0) + (row["g_no"] or 0)
+        e_tot = (row["e_ok"] or 0) + (row["e_no"] or 0)
+        g_acc = round(row["g_ok"] / g_tot * 100, 1) if g_tot else None
+        e_acc = round(row["e_ok"] / e_tot * 100, 1) if e_tot else None
+        lines = [f"🤖 <b>LLM 정확도 월간 리포트 ({date.today()})</b>\n"]
+        lines.append(f"검증된 분석: {row['verified']}건 (지난 30일)")
+        lines.append(f"\n<b>정확도</b>")
+        lines.append(f"  🌟 Gemini: {g_acc}% ({row['g_ok']}/{g_tot})")
+        lines.append(f"  📘 EXAONE: {e_acc}% ({row['e_ok']}/{e_tot})")
+        lines.append(f"\n<b>매수 종목 30일 실제 수익률</b>")
+        if row["g_buy_ret"] is not None:
+            lines.append(f"  Gemini 매수: {row['g_buy_ret']:.2f}%")
+        if row["e_buy_ret"] is not None:
+            lines.append(f"  EXAONE 매수: {row['e_buy_ret']:.2f}%")
+        lines.append(f"\n<b>의견 일치율</b>")
+        lines.append(f"  일치: {row['agreed']}건 / 갈림: {row['disagreed']}건")
+        lines.append(f"\n💰 Gemini 비용: {int(row['cost'] or 0)}원")
+        # 정확도 기반 권고
+        if g_acc and g_acc >= 70:
+            lines.append(f"\n✅ Gemini 정확도 ≥70% — 자동매매 검토 가능 수준")
+        elif g_acc and g_acc >= 60:
+            lines.append(f"\n🟡 Gemini 정확도 60~70% — 모의매매로 검증 권장")
+        else:
+            lines.append(f"\n🔴 Gemini 정확도 < 60% — 자동매매 부적합, 데이터 누적 필요")
+        await send_telegram("\n".join(lines))
+        logger.info("monthly_llm_report.done")
+    except Exception as e:
+        logger.error("monthly_llm_report.err", error=str(e))
+
+
+@app.post("/performance/weekly-report")
+async def trigger_weekly_report():
+    asyncio.create_task(weekly_performance_report())
+    return {"status": "started"}
+
+
+@app.post("/performance/monthly-llm")
+async def trigger_monthly_llm():
+    asyncio.create_task(monthly_llm_comparison())
+    return {"status": "started"}
+
+
+@app.get("/performance/simulation")
+async def trading_simulation(days: int = Query(default=90, ge=14, le=365),
+                              kinds: str = Query(default="강력매수"),
+                              capital: int = Query(default=10_000_000, ge=1_000_000),
+                              stop_loss_pct: float = Query(default=-8.0),
+                              take_profit_pct: float = Query(default=15.0),
+                              trade_cost_pct: float = Query(default=0.3),
+                              max_position_pct: float = Query(default=10.0)):
+    """모의 자동매매 시뮬레이션 (거래비용·손절·익절 적용).
+    실전과 가까운 현실적 수익률 계산 → 자동매매 진짜 신뢰도.
+    """
+    kind_list = [k.strip() for k in kinds.split(",") if k.strip()]
+    async with pg_pool.acquire() as conn:
+        recs = await conn.fetch("""
+            SELECT p.stock_code, p.rec_date, p.entry_price, p.return_30d, p.recommendation,
+                   p.price_7d, p.price_30d
+            FROM recommendation_performance p
+            WHERE p.rec_date >= CURRENT_DATE - $1::int
+              AND p.recommendation = ANY($2::text[])
+              AND p.entry_price > 0 AND p.return_30d IS NOT NULL
+            ORDER BY p.rec_date
+        """, days, kind_list)
+
+    cash = float(capital)
+    wins = losses = stop_hits = profit_hits = full_holds = 0
+    pnl_total = 0.0
+    trade_log = []
+    # 단순화: 추천일 진입 → 30일 보유 동안 손절/익절 도달 시 청산
+    # price_7d, price_30d만 알지만 손절·익절 확률적 적용 (return_30d가 음수면 손절 가능성 ↑)
+    for r in recs:
+        ret_30d = r["return_30d"]
+        # 종목당 max_position_pct만큼 투자 (Kelly 단순화)
+        position = min(cash * max_position_pct / 100, cash)
+        if position <= 0: break
+        # 시뮬레이션: 진입 후 30일 동안
+        # 가장 보수적 가정: stop_loss < 30d 최저점이면 손절, take_profit < 30d 최고점이면 익절
+        # price_7d / price_30d만 있으므로 근사:
+        # - 종목이 결국 -8% 이하 마감했으면 손절(-8% 가정)
+        # - 30일 동안 +15% 이상 갔으면 익절(+15% 가정)
+        actual_ret = ret_30d
+        if ret_30d <= stop_loss_pct:
+            actual_ret = stop_loss_pct
+            stop_hits += 1
+        elif ret_30d >= take_profit_pct:
+            actual_ret = take_profit_pct
+            profit_hits += 1
+        else:
+            full_holds += 1
+        # 거래비용 (왕복 0.3%)
+        net_ret = actual_ret - trade_cost_pct
+        pnl = position * net_ret / 100
+        pnl_total += pnl
+        cash += pnl
+        if net_ret > 0: wins += 1
+        else: losses += 1
+        if len(trade_log) < 20:
+            trade_log.append({
+                "code": r["stock_code"], "date": str(r["rec_date"]),
+                "rec": r["recommendation"], "raw_ret_30d": ret_30d,
+                "actual_ret": round(actual_ret, 2), "pnl": round(pnl)
+            })
+    n = wins + losses
+    return {
+        "period_days": days, "kinds": kind_list,
+        "settings": {
+            "capital": capital, "stop_loss_pct": stop_loss_pct,
+            "take_profit_pct": take_profit_pct, "trade_cost_pct": trade_cost_pct,
+            "max_position_pct": max_position_pct,
+        },
+        "trades": n,
+        "wins": wins, "losses": losses,
+        "win_rate_pct": round(wins / n * 100, 1) if n else None,
+        "stop_loss_hits": stop_hits,
+        "take_profit_hits": profit_hits,
+        "full_holds": full_holds,
+        "final_capital": round(cash),
+        "total_pnl": round(pnl_total),
+        "total_return_pct": round(pnl_total / capital * 100, 2),
+        "annualized_return_pct": round(pnl_total / capital * (365 / days) * 100, 2) if days else None,
+        "sample_trades": trade_log[:10],
+    }
+
+
+@app.get("/labels/calibration")
+async def labels_calibration(days: int = Query(default=180, ge=30, le=730)):
+    """확신도(conviction) calibration — 1~5 별 실제 정확도.
+    잘 calibration된 모델: conv5 → 정확도 ~90%, conv3 → ~60%, conv1 → ~20%
+    크게 어긋나면 LLM 확신도가 과대평가/과소평가 신호.
+    """
+    async with pg_pool.acquire() as conn:
+        rows = await conn.fetch("""
+            SELECT gemini_conviction AS conv,
+                   COUNT(*) AS total,
+                   COUNT(*) FILTER (WHERE gemini_correct = true)  AS hit,
+                   COUNT(*) FILTER (WHERE gemini_correct = false) AS miss,
+                   AVG(realized_return_30d) AS avg_ret
+            FROM deep_analysis
+            WHERE verified_at IS NOT NULL
+              AND analysis_date >= CURRENT_DATE - $1::int
+            GROUP BY gemini_conviction
+            ORDER BY gemini_conviction
+        """, days)
+        exa_rows = await conn.fetch("""
+            SELECT conviction AS conv,
+                   COUNT(*) AS total,
+                   COUNT(*) FILTER (WHERE exaone_correct = true) AS hit
+            FROM deep_analysis
+            WHERE verified_at IS NOT NULL
+              AND analysis_date >= CURRENT_DATE - $1::int
+            GROUP BY conviction
+            ORDER BY conviction
+        """, days)
+    def _calib(r):
+        verified = (r["hit"] or 0) + (r["miss"] or 0) if "miss" in r else r["total"]
+        return {
+            "conviction": r["conv"],
+            "total": r["total"],
+            "hit": r["hit"],
+            "accuracy_pct": round(r["hit"] / verified * 100, 1) if verified else None,
+            "avg_return_30d": round(r["avg_ret"], 2) if "avg_ret" in r and r["avg_ret"] else None,
+        }
+    return {
+        "period_days": days,
+        "gemini_calibration": [_calib(r) for r in rows],
+        "exaone_calibration": [_calib(r) for r in exa_rows],
+        "interpretation": "확신도 ≥4의 정확도가 70% 미만이면 LLM이 과신 경향 → 임계값 보정 필요",
+    }
+
+
+@app.get("/labels/catalyst-accuracy")
+async def labels_catalyst_accuracy(days: int = Query(default=180, ge=30, le=730)):
+    """catalyst별 정확도 — 실적/수주/배당/리스크/모멘텀 중 어느 catalyst가 잘 맞는지.
+    잘 맞는 catalyst 가중치 ↑ / 못 맞는 catalyst 가중치 ↓로 향후 자동 조정 가능.
+    """
+    async with pg_pool.acquire() as conn:
+        rows = await conn.fetch("""
+            WITH na AS (
+              SELECT DISTINCT ON (n.primary_stock, n.analyzed_at::date)
+                     n.primary_stock, n.analyzed_at::date AS dt, n.catalyst, n.intensity
+              FROM news_analysis n
+              WHERE n.intensity >= 3 AND n.catalyst IS NOT NULL
+                AND n.analyzed_at::date >= CURRENT_DATE - $1::int
+              ORDER BY n.primary_stock, n.analyzed_at::date, n.intensity DESC
+            )
+            SELECT na.catalyst,
+                   COUNT(*) AS news_count,
+                   COUNT(da.id) AS analyzed,
+                   COUNT(*) FILTER (WHERE da.gemini_correct = true)  AS hit,
+                   COUNT(*) FILTER (WHERE da.gemini_correct = false) AS miss,
+                   AVG(da.realized_return_30d) AS avg_ret
+            FROM na
+            LEFT JOIN deep_analysis da
+                   ON da.stock_code = na.primary_stock
+                  AND da.analysis_date BETWEEN na.dt AND na.dt + INTERVAL '3 days'
+                  AND da.verified_at IS NOT NULL
+            GROUP BY na.catalyst
+            HAVING COUNT(da.id) >= 3
+            ORDER BY COUNT(*) FILTER (WHERE da.gemini_correct = true) DESC
+        """, days)
+    return {
+        "period_days": days,
+        "by_catalyst": [
+            {"catalyst": r["catalyst"],
+             "news_count": r["news_count"],
+             "analyzed": r["analyzed"],
+             "hit": r["hit"], "miss": r["miss"],
+             "accuracy_pct": round(r["hit"] / (r["hit"] + r["miss"]) * 100, 1) if (r["hit"] + r["miss"]) > 0 else None,
+             "avg_return_30d": round(r["avg_ret"], 2) if r["avg_ret"] else None}
+            for r in rows
+        ],
+        "interpretation": "정확도 높은 catalyst의 뉴스에 더 큰 가중치를 두는 게 합리적",
+    }
+
+
+@app.get("/labels/training-export")
+async def training_export(min_conviction: int = Query(default=3, ge=1, le=5),
+                          verified_only: bool = Query(default=False),
+                          require_agreement: bool = Query(default=False),
+                          max_abs_return: float = Query(default=30.0, gt=0,
+                              description="이상치 제거: |30d 수익률| 초과 케이스 배제 (시장 충격 noise)"),
+                          dedup_same_stock_days: int = Query(default=7, ge=0,
+                              description="같은 종목 N일 내 중복 분석 제거 (편향 방지)"),
+                          limit: int = Query(default=10000, ge=1, le=50000)):
+    """LoRA 파인튜닝용 JSONL 데이터셋 export — 노이즈 정제 파이프라인 포함.
+    포맷: {input: rag_context, target: {label, thesis}}
+    필터:
+      - verified_only=true: 30일 후 실제 수익률로 Gemini가 맞은 케이스만
+      - require_agreement=true: EXAONE+Gemini 일치 케이스만 (가장 신뢰)
+      - max_abs_return=30: 극단 수익률 케이스 제외 (시장 충격 외생 노이즈)
+      - dedup_same_stock_days=7: 같은 종목 일주일 내 중복 제거 (편향 방지)
+    """
+    where = ["gemini_recommendation IS NOT NULL", "gemini_conviction >= $1"]
+    if verified_only:
+        where.append("gemini_correct = true")
+    if require_agreement:
+        where.append("agreement = true")
+    if max_abs_return > 0:
+        where.append(f"(realized_return_30d IS NULL OR ABS(realized_return_30d) <= {max_abs_return})")
+    sql = f"""
+        SELECT stock_code, analysis_date, rag_context,
+               recommendation AS exaone_rec, gemini_recommendation,
+               gemini_thesis, gemini_conviction,
+               gemini_target_price, gemini_stop_loss,
+               realized_return_30d, gemini_correct, agreement
+        FROM deep_analysis
+        WHERE {' AND '.join(where)}
+        ORDER BY analysis_date DESC LIMIT $2
+    """
+    async with pg_pool.acquire() as conn:
+        rows = await conn.fetch(sql, min_conviction, limit)
+        total_raw = await conn.fetchval("""
+            SELECT COUNT(*) FROM deep_analysis WHERE gemini_recommendation IS NOT NULL
+        """)
+
+    # 같은 종목 N일 내 중복 제거 (시간순으로 후순위 제거)
+    seen: dict[str, date] = {}
+    samples = []
+    for r in rows:
+        last = seen.get(r["stock_code"])
+        if last and dedup_same_stock_days > 0 and (last - r["analysis_date"]).days < dedup_same_stock_days:
+            continue
+        seen[r["stock_code"]] = r["analysis_date"]
+        samples.append({
+            "input":  r["rag_context"],
+            "target": {
+                "recommendation": r["gemini_recommendation"],
+                "conviction": r["gemini_conviction"],
+                "thesis": r["gemini_thesis"],
+                "target_price": r["gemini_target_price"],
+                "stop_loss":    r["gemini_stop_loss"],
+            },
+            "meta": {
+                "stock_code": r["stock_code"],
+                "analysis_date": r["analysis_date"].isoformat(),
+                "realized_return_30d": r["realized_return_30d"],
+                "verified_correct": r["gemini_correct"],
+                "agreement": r["agreement"],
+            }
+        })
+    return {
+        "count": len(samples),
+        "filters": {
+            "min_conviction": min_conviction,
+            "verified_only": verified_only,
+            "require_agreement": require_agreement,
+            "max_abs_return": max_abs_return,
+            "dedup_same_stock_days": dedup_same_stock_days,
+        },
+        "noise_reduction": {
+            "raw_count": int(total_raw or 0),
+            "after_filters": len(rows),
+            "after_dedup": len(samples),
+            "removed_pct": round((1 - len(samples) / total_raw) * 100, 1) if total_raw else 0,
+        },
+        "samples": samples,
+    }
diff --git a/telegram-bot/main.py b/telegram-bot/main.py
index 9fe6623..7e4fda7 100644
--- a/telegram-bot/main.py
+++ b/telegram-bot/main.py
@@ -23,7 +23,7 @@ import httpx
 import structlog
 from telegram import Update, BotCommand
 from telegram.constants import ParseMode
-from telegram.ext import (Application, CommandHandler, MessageHandler,
+from telegram.ext import (Application, CommandHandler, MessageHandler, CallbackQueryHandler,
                            filters, ContextTypes)
 
 logging.basicConfig(level=logging.INFO,
@@ -254,16 +254,25 @@ async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
     if not is_allowed(update): return
     msg = (
         "👋 <b>Trading AI 봇</b>\n\n"
-        "명령어:\n"
-        "/buy — 오늘 매수 추천\n"
-        "/sell — 오늘 매도 신호\n"
-        "/stock 005930 — 특정 종목 상세\n"
-        "/deep 005930 — AI 심층분석(RAG+EXAONE)\n"
-        "/market — 시장 상황\n"
-        "/help — 도움말\n\n"
-        "자유 텍스트로 질문해도 됩니다. 예:\n"
+        "<b>📊 추천 조회</b>\n"
+        "• /buy 또는 '추천' — 오늘 매수 추천(가치투자)\n"
+        "• /hot 또는 '뜨는' — 지금 뜨는 종목(모멘텀)\n"
+        "• /sell 또는 '매도종목' — 오늘 매도 신호\n"
+        "• /stock 005930 — 종목 상세\n"
+        "• /deep 005930 — AI 심층분석\n"
+        "• /market 또는 '시장' — 시장 상황\n\n"
+        "<b>🤖 자동매매</b>\n"
+        "• /status 또는 '상태' — 시스템 상태\n"
+        "• /portfolio 또는 '보유' — 보유 종목 손익\n"
+        "• /orders 또는 '주문' — 매매 주문 목록\n"
+        "• /settings 또는 '설정' — 안전 설정\n"
+        "• /autotrade on|off 또는 '자동매매꺼' — 자동매매 토글\n\n"
+        "<b>💱 주문 처리</b> (텔레그램 알림 도착 시)\n"
+        "• 버튼: [✅ 매수/매도 실행] [❌ 취소]\n"
+        "• 텍스트: '매수 2', '매도 2', '취소 2', '승인 2'\n"
+        "• 명령: /confirm 2, /cancel 2\n\n"
+        "<b>💬 자유 질문</b>\n"
         "<i>\"에스엠 사도 돼?\"</i>\n"
-        "<i>\"오늘 추천 알려줘\"</i>\n"
         "<i>\"삼성전자 어때?\"</i>"
     )
     await update.message.reply_text(msg, parse_mode=ParseMode.HTML)
@@ -285,6 +294,40 @@ async def cmd_sells(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
     await update.message.reply_text(fmt_sells(rows), parse_mode=ParseMode.HTML)
 
 
+def fmt_hot(rows: list) -> str:
+    if not rows:
+        return "📭 지금 뜨는 종목 없음"
+    lines = ["🔥 <b>지금 뜨는 종목</b> <i>(뉴스·가격·거래량 모멘텀)</i>"]
+    for i, r in enumerate(rows, 1):
+        lines.append(f"🔥 <b>{i}. {r['stock_name']}({r['stock_code']})</b> {r['hot_score']:.0f}점")
+        parts = []
+        if r.get("pos_news_3d"):
+            parts.append(f"호재 {r['pos_news_3d']}건")
+        if r.get("price_5d_pct"):
+            parts.append(f"5일 {r['price_5d_pct']:+.1f}%")
+        if r.get("vol_ratio") and r["vol_ratio"] >= 1.5:
+            parts.append(f"거래량 {r['vol_ratio']:.1f}배")
+        if parts:
+            lines.append(f"   ▸ {' · '.join(parts)}")
+        vs, vr = r.get("value_score"), r.get("value_reco")
+        if vr:
+            lines.append(f"   ▸ 가치판단: {vr} ({vs}점)")
+    lines.append("\n<i>※ 모멘텀 기반이라 가치투자 추천(/buy)과 별개입니다. 변동성·추격매수 주의</i>")
+    return "\n".join(lines)
+
+
+async def cmd_hot(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_allowed(update): return
+    try:
+        async with httpx.AsyncClient(timeout=30) as c:
+            r = await c.get(f"{SCORE_API}/hot?limit=12")
+            rows = r.json()
+    except Exception as e:
+        await update.message.reply_text(f"오류: {e}")
+        return
+    await update.message.reply_text(fmt_hot(rows), parse_mode=ParseMode.HTML)
+
+
 async def cmd_stock(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
     if not is_allowed(update): return
     args = ctx.args
@@ -352,6 +395,208 @@ async def cmd_deep(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
     await update.message.reply_text(fmt_deep(r), parse_mode=ParseMode.HTML)
 
 
+SCORE_ENGINE_URL = os.getenv("SCORE_ENGINE_URL", "http://score-engine:8686")
+
+
+async def cmd_confirm(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """/confirm <order_id> — 자동매매 매수 신호 승인"""
+    if not is_allowed(update): return
+    if not ctx.args:
+        await update.message.reply_text("사용법: /confirm <주문번호>")
+        return
+    try:
+        oid = int(ctx.args[0])
+    except ValueError:
+        await update.message.reply_text("주문번호는 숫자")
+        return
+    import httpx
+    try:
+        async with httpx.AsyncClient(timeout=30) as c:
+            r = await c.post(f"{SCORE_ENGINE_URL}/trade/confirm/{oid}")
+            res = r.json()
+        if "error" in res:
+            await update.message.reply_text(f"❌ {res['error']}")
+        else:
+            await update.message.reply_text(f"✅ 주문 #{oid} 체결 완료")
+    except Exception as e:
+        await update.message.reply_text(f"오류: {e}")
+
+
+async def cmd_cancel(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """/cancel <order_id> — 매수 신호 거부"""
+    if not is_allowed(update): return
+    if not ctx.args:
+        await update.message.reply_text("사용법: /cancel <주문번호>")
+        return
+    try:
+        oid = int(ctx.args[0])
+    except ValueError:
+        await update.message.reply_text("주문번호는 숫자")
+        return
+    import httpx
+    try:
+        async with httpx.AsyncClient(timeout=30) as c:
+            r = await c.post(f"{SCORE_ENGINE_URL}/trade/cancel/{oid}")
+        await update.message.reply_text(f"🚫 주문 #{oid} 취소")
+    except Exception as e:
+        await update.message.reply_text(f"오류: {e}")
+
+
+async def on_callback(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """inline 버튼 콜백 처리: confirm:<id> / cancel:<id>"""
+    q = update.callback_query
+    if not q or not q.data:
+        return
+    await q.answer()
+    try:
+        action, oid_str = q.data.split(":", 1)
+        oid = int(oid_str)
+    except Exception:
+        await q.edit_message_text(f"{q.message.text}\n\n❌ 잘못된 콜백")
+        return
+    import httpx
+    try:
+        async with httpx.AsyncClient(timeout=30) as c:
+            r = await c.post(f"{SCORE_ENGINE_URL}/trade/{action}/{oid}")
+            res = r.json()
+        if "error" in res:
+            new_text = f"{q.message.text_html}\n\n❌ {res['error']}"
+        elif action == "confirm":
+            new_text = f"{q.message.text_html}\n\n✅ 승인됨 (#{oid} 체결)"
+        else:
+            new_text = f"{q.message.text_html}\n\n🚫 거부됨 (#{oid} 취소)"
+        # 버튼 제거 + 결과 표시
+        await q.edit_message_text(new_text, parse_mode=ParseMode.HTML)
+    except Exception as e:
+        await q.edit_message_text(f"{q.message.text}\n\n⚠️ 오류: {e}")
+
+
+async def cmd_portfolio(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """/portfolio — 보유 종목 + 손익"""
+    if not is_allowed(update): return
+    import httpx
+    try:
+        async with httpx.AsyncClient(timeout=30) as c:
+            r = await c.get(f"{SCORE_ENGINE_URL}/portfolio")
+            rows = r.json()
+        if not rows:
+            await update.message.reply_text("보유 종목 없음")
+            return
+        lines = ["👜 <b>보유 종목</b>\n"]
+        total_buy = 0
+        total_cur = 0
+        for p in rows:
+            cur = int(p.get("current_price") or 0)
+            buy = p["buy_price"]
+            qty = p["qty"]
+            pnl_pct = p.get("pnl_pct") or 0
+            pnl_won = p.get("pnl_won") or 0
+            total_buy += buy * qty
+            total_cur += cur * qty
+            sign = "🟢" if pnl_pct > 0 else "🔴" if pnl_pct < -3 else "🟡"
+            lines.append(
+                f"{sign} <b>{p.get('stock_name') or p['stock_code']}</b>({p['stock_code']})\n"
+                f"  {qty}주 @{buy:,}원 → {cur:,}원  <b>{pnl_pct:+.2f}%</b> ({pnl_won:+,}원)"
+            )
+        if total_buy:
+            tot_pct = (total_cur - total_buy) / total_buy * 100
+            lines.append(f"\n<b>합계 {tot_pct:+.2f}% ({total_cur - total_buy:+,}원)</b>")
+        await update.message.reply_text("\n".join(lines), parse_mode=ParseMode.HTML)
+    except Exception as e:
+        await update.message.reply_text(f"오류: {e}")
+
+
+async def cmd_autotrade(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """/autotrade on|off — 자동매매 토글"""
+    if not is_allowed(update): return
+    if not ctx.args or ctx.args[0].lower() not in ("on","off"):
+        await update.message.reply_text("사용법: /autotrade on  또는  /autotrade off")
+        return
+    enabled = ctx.args[0].lower() == "on"
+    import httpx
+    try:
+        async with httpx.AsyncClient(timeout=10) as c:
+            await c.post(f"{SCORE_ENGINE_URL}/trade/autotrade?enabled={'true' if enabled else 'false'}")
+        await update.message.reply_text(
+            f"⚙️ 자동매매 {'ON ✅' if enabled else 'OFF 🛑'}",
+            parse_mode=ParseMode.HTML)
+    except Exception as e:
+        await update.message.reply_text(f"오류: {e}")
+
+
+async def cmd_settings(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """/settings — 자동매매 안전설정 조회"""
+    if not is_allowed(update): return
+    import httpx
+    try:
+        async with httpx.AsyncClient(timeout=10) as c:
+            r = await c.get(f"{SCORE_ENGINE_URL}/trade/settings")
+            s = r.json().get("current", {})
+        lines = ["⚙️ <b>자동매매 설정</b>\n"]
+        for k, v in s.items():
+            lines.append(f"  • {k}: <code>{v}</code>")
+        await update.message.reply_text("\n".join(lines), parse_mode=ParseMode.HTML)
+    except Exception as e:
+        await update.message.reply_text(f"오류: {e}")
+
+
+async def cmd_status(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """/status — 시스템 상태 한눈에"""
+    if not is_allowed(update): return
+    import httpx
+    try:
+        async with httpx.AsyncClient(timeout=10) as c:
+            r = await c.get(f"{SCORE_ENGINE_URL}/system/status")
+            s = r.json()
+        t = s.get("trading", {})
+        a = s.get("analysis", {})
+        sc = s.get("scoring", {})
+        p = s.get("portfolio", {})
+        o = t.get("orders_today", {})
+        auto_icon = "✅" if t.get("enabled") else "🛑"
+        halt_icon = "🛑 HALTED" if t.get("halted") else ""
+        lines = [
+            f"📊 <b>시스템 상태</b>",
+            f"\n<b>자동매매</b> {auto_icon} {halt_icon}",
+            f"  오늘 주문: pending {o.get('pending',0)} / filled {o.get('filled',0)} / cancelled {o.get('cancelled',0)} / expired {o.get('expired',0)}",
+            f"  실현손익: {t.get('realized_pnl_today', 0):+,}원 / 평가손익: {t.get('unrealized_pnl_today', 0):+,}원",
+            f"\n<b>점수 ({sc.get('latest_score_date')})</b>",
+            f"  분석 종목: {sc.get('scored_today',0)}건 / 강력매수: {sc.get('strong_buy_count',0)}건",
+            f"\n<b>LLM 분석</b>",
+            f"  오늘: {a.get('today_analyses',0)}건 ({a.get('today_llm_cost_krw',0)}원)",
+            f"  이번 달: {a.get('month_llm_cost_krw',0)}원",
+            f"\n<b>보유</b>",
+            f"  활성 포지션: {p.get('active_positions',0)}건",
+        ]
+        await update.message.reply_text("\n".join(lines), parse_mode=ParseMode.HTML)
+    except Exception as e:
+        await update.message.reply_text(f"오류: {e}")
+
+
+async def cmd_orders(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """/orders — 최근 매매 주문 목록"""
+    if not is_allowed(update): return
+    import httpx
+    try:
+        async with httpx.AsyncClient(timeout=30) as c:
+            r = await c.get(f"{SCORE_ENGINE_URL}/trade/orders?days=7")
+            rows = r.json()
+        if not rows:
+            await update.message.reply_text("최근 주문 없음")
+            return
+        lines = ["📋 <b>최근 매매 주문 (7일)</b>\n"]
+        for r in rows[:15]:
+            icon = {"pending":"⏳","confirmed":"✅","filled":"✅",
+                    "cancelled":"🚫","expired":"⌛"}.get(r["status"], "·")
+            lines.append(
+                f"{icon} #{r['id']} {r['stock_name']}({r['stock_code']}) "
+                f"{r['side']} {r['qty']}주 @{r['price']:,}원 [{r['status']}]"
+            )
+        await update.message.reply_text("\n".join(lines), parse_mode=ParseMode.HTML)
+    except Exception as e:
+        await update.message.reply_text(f"오류: {e}")
+
+
 async def cmd_market(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
     if not is_allowed(update): return
     m = await db_market_regime()
@@ -378,17 +623,63 @@ async def on_text(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
         return
 
     # 한글 단축 키워드 → 명령 라우팅 (빠른 응답)
-    if text in ("추천", "매수", "오늘추천", "buy"):
+    if text in ("추천", "오늘추천", "buy"):
         rows = await db_top_buys(10)
         await update.message.reply_text(fmt_buys(rows), parse_mode=ParseMode.HTML)
         return
-    if text in ("매도", "팔것", "sell"):
+    if text in ("팔것", "매도종목", "sell"):
         rows = await db_top_sells(5)
         await update.message.reply_text(fmt_sells(rows), parse_mode=ParseMode.HTML)
         return
     if text in ("시장", "장", "market"):
         await cmd_market(update, ctx)
         return
+    if text in ("뜨는", "핫", "급등", "뜨는종목", "핫종목", "hot"):
+        await cmd_hot(update, ctx)
+        return
+
+    # 자동매매 한글 명령 라우팅
+    if text in ("상태", "status"):
+        await cmd_status(update, ctx); return
+    if text in ("보유", "포트폴리오", "내주식", "손익"):
+        await cmd_portfolio(update, ctx); return
+    if text in ("주문", "주문목록", "오더"):
+        await cmd_orders(update, ctx); return
+    if text in ("설정", "셋팅"):
+        await cmd_settings(update, ctx); return
+    if text in ("자동매매켜", "자동매매on", "자동매매시작"):
+        ctx.args = ["on"]
+        await cmd_autotrade(update, ctx); return
+    if text in ("자동매매꺼", "자동매매off", "자동매매중단", "자동매매정지"):
+        ctx.args = ["off"]
+        await cmd_autotrade(update, ctx); return
+
+    # 주문 confirm/cancel 자연어 — "매수 2", "매도 2", "승인 2", "취소 2"
+    import re as _re, httpx as _httpx
+    m = _re.match(r"^(매수|매도|승인|확인|실행)\s+(\d+)$", text)
+    if m:
+        oid = int(m.group(2))
+        try:
+            async with _httpx.AsyncClient(timeout=30) as c:
+                r = await c.post(f"{SCORE_ENGINE_URL}/trade/confirm/{oid}")
+                res = r.json()
+            if "error" in res:
+                await update.message.reply_text(f"❌ {res['error']}")
+            else:
+                await update.message.reply_text(f"✅ 주문 #{oid} 체결 완료")
+        except Exception as e:
+            await update.message.reply_text(f"오류: {e}")
+        return
+    m = _re.match(r"^(취소|거부|중단)\s+(\d+)$", text)
+    if m:
+        oid = int(m.group(2))
+        try:
+            async with _httpx.AsyncClient(timeout=30) as c:
+                await c.post(f"{SCORE_ENGINE_URL}/trade/cancel/{oid}")
+            await update.message.reply_text(f"🚫 주문 #{oid} 취소")
+        except Exception as e:
+            await update.message.reply_text(f"오류: {e}")
+        return
 
     await update.message.chat.send_action("typing")
 
@@ -488,8 +779,17 @@ def main():
     app.add_handler(CommandHandler(["buy", "buys"], cmd_buys))
     app.add_handler(CommandHandler(["sell", "sells"], cmd_sells))
     app.add_handler(CommandHandler(["stock"], cmd_stock))
+    app.add_handler(CommandHandler(["hot"], cmd_hot))
     app.add_handler(CommandHandler(["deep"], cmd_deep))
     app.add_handler(CommandHandler(["market"], cmd_market))
+    app.add_handler(CommandHandler(["confirm"], cmd_confirm))
+    app.add_handler(CommandHandler(["cancel"], cmd_cancel))
+    app.add_handler(CommandHandler(["orders"], cmd_orders))
+    app.add_handler(CommandHandler(["portfolio", "pnl"], cmd_portfolio))
+    app.add_handler(CommandHandler(["autotrade"], cmd_autotrade))
+    app.add_handler(CommandHandler(["settings"], cmd_settings))
+    app.add_handler(CommandHandler(["status"], cmd_status))
+    app.add_handler(CallbackQueryHandler(on_callback))
     app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, on_text))
     logger.info("telegram-bot.start", model=EXAONE_MODEL)
     app.run_polling(close_loop=False)