diff --git "a/\354\240\234\354\243\274\355\212\271\353\263\204\354\236\220\354\271\230\353\217\204_\355\206\265\355\225\251_TourAPI\353\263\221\355\225\251.xlsx" "b/data/\354\240\234\354\243\274\355\212\271\353\263\204\354\236\220\354\271\230\353\217\204_\355\206\265\355\225\251_TourAPI\353\263\221\355\225\251.xlsx"
similarity index 100%
rename from "\354\240\234\354\243\274\355\212\271\353\263\204\354\236\220\354\271\230\353\217\204_\355\206\265\355\225\251_TourAPI\353\263\221\355\225\251.xlsx"
rename to "data/\354\240\234\354\243\274\355\212\271\353\263\204\354\236\220\354\271\230\353\217\204_\355\206\265\355\225\251_TourAPI\353\263\221\355\225\251.xlsx"
diff --git a/requirements.txt b/requirements.txt
index 5825020..47d8dae 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -17,6 +17,7 @@ tqdm>=4.66
 openpyxl>=3.1
 scipy>=1.13
 neo4j>=5.26
+python-multipart>=0.0.32
 
 # --- 개발/테스트 (선택) ---
 pytest>=8.3
diff --git a/src/api/router.py b/src/api/router.py
index d457953..d9596e9 100644
--- a/src/api/router.py
+++ b/src/api/router.py
@@ -7,6 +7,7 @@
 import re
 from pathlib import Path
 
+import openpyxl
 from fastapi import APIRouter, File, HTTPException, UploadFile
 
 from src.api.schemas import (
@@ -290,35 +291,50 @@ def _parse_jeju_hours(raw: str) -> tuple[str, str] | None:
 
 
 def _build_jeju_place_index() -> dict[str, dict]:
-    """data/jeju_places.csv — 실측 좌표·영업시간을 가진 제주 전역 25,377건 통합 DB."""
+    """data/제주특별자치도_통합_TourAPI병합.xlsx — 실측 좌표를 가진 제주 전역 26,679건 통합 DB.
+    기존 jeju_places.csv(25,377건)에 TourAPI 실측 영업시간·contentid를 매칭 병합한 최신본
+    (2,153건 매칭, 1,302건 신규 추가). 영업시간은 TourAPI 실측값을 원문(영업시간)보다 우선한다."""
     index: dict[str, dict] = {}
-    path = _DATA_DIR / "jeju_places.csv"
+    path = _DATA_DIR / "제주특별자치도_통합_TourAPI병합.xlsx"
     if not path.exists():
         return index
-    with open(path, encoding="utf-8-sig") as f:
-        for row in csv.DictReader(f):
-            name = (row.get("상호명") or "").strip()
-            if not name:
-                continue
-            key = _normalize(name)
-            if key in index:
-                continue
-            try:
-                lat, lng = float(row["위도"]), float(row["경도"])
-            except (ValueError, TypeError, KeyError):
-                continue
-            entry = {
-                "name": name, "lat": lat, "lng": lng, "region": "제주",
-                "cat": _JEJU_CAT_MAP.get(row.get("대분류코드", ""), "12"),
-                "cat_name": row.get("대분류명", "관광지"),
-                "addr": (row.get("도로명주소") or "").strip(),
-                "has_coords": True,
-                "source": "jeju_csv",
-            }
-            hrs = _parse_jeju_hours(row.get("영업시간", ""))
-            if hrs:
-                entry["open_start"], entry["open_end"] = hrs
-            index[key] = entry
+    wb = openpyxl.load_workbook(path, read_only=True, data_only=True)
+    ws = wb.active
+    rows = ws.iter_rows(values_only=True)
+    header = [str(h or "").strip() for h in next(rows)]
+    for values in rows:
+        row = dict(zip(header, values, strict=True))
+        name = str(row.get("상호명") or "").strip()
+        if not name:
+            continue
+        key = _normalize(name)
+        if key in index:
+            continue
+        try:
+            lat, lng = float(row["위도"]), float(row["경도"])
+        except (ValueError, TypeError, KeyError):
+            continue
+        entry = {
+            "name": name, "lat": lat, "lng": lng, "region": "제주",
+            "cat": _JEJU_CAT_MAP.get(str(row.get("대분류코드") or ""), "12"),
+            "cat_name": row.get("대분류명") or "관광지",
+            "addr": str(row.get("도로명주소") or "").strip(),
+            "has_coords": True,
+            "source": "jeju_csv",
+        }
+        contentid = row.get("TourAPI_contentid")
+        if contentid not in (None, ""):
+            entry["contentid"] = str(int(contentid))
+        hrs = (
+            _parse_jeju_hours(str(row.get("TourAPI_영업시간") or ""))
+            or _parse_jeju_hours(str(row.get("영업시간") or ""))
+        )
+        if hrs:
+            entry["open_start"], entry["open_end"] = hrs
+        if str(row.get("반려동물동반") or "").strip().upper() == "Y":
+            entry["pet_friendly"] = True
+        index[key] = entry
+    wb.close()
     return index
 
 
@@ -660,6 +676,7 @@ def _resolve_poi(name: str, idx: int, address: str = "") -> tuple[POI, POIInfo]:
         open_start, open_end = hours.open_, hours.close_
         hours_estimated = True
     dwell = _guess_dwell(name)
+    pet_friendly = bool(place.get("pet_friendly")) if place else False
 
     # 지식그래프 근거 — 지역·도보권 대안. 그래프 미설정/미매칭 시 조용히 생략.
     graph_region, graph_nearby = "", []
@@ -675,6 +692,7 @@ def _resolve_poi(name: str, idx: int, address: str = "") -> tuple[POI, POIInfo]:
         open_start=open_start, open_end=open_end,
         duration_min=dwell, category=category,
         hours_estimated=hours_estimated,
+        pet_friendly=pet_friendly,
     )
     info = POIInfo(
         name=name, found=(confidence != "Low"), source=source,
@@ -685,6 +703,7 @@ def _resolve_poi(name: str, idx: int, address: str = "") -> tuple[POI, POIInfo]:
         hours_estimated=hours_estimated,
         graph_region=graph_region,
         graph_nearby=graph_nearby,
+        pet_friendly=pet_friendly,
     )
     return poi, info
 
@@ -888,8 +907,16 @@ async def validate_plan(req: ValidateRequest) -> ValidateResponse:
         plan=plan,
         per_day_pois=per_day_pois,
         matrix={},
+        pet_friendly_enabled=req.pet_friendly,
     )
 
+    if result.wellness_matched:
+        wellness_names = set(result.wellness_matched)
+        poi_info_list = [
+            info.model_copy(update={"wellness": True}) if info.name in wellness_names else info
+            for info in poi_info_list
+        ]
+
     data_reliability_score = _calc_reliability_score(poi_info_list)
 
     # ── 월별 혼잡도 경고 생성 ──────────────────────────────────────
diff --git a/src/api/schemas.py b/src/api/schemas.py
index be39c04..3e5f765 100644
--- a/src/api/schemas.py
+++ b/src/api/schemas.py
@@ -30,6 +30,8 @@ class POIInfo(BaseModel):
     graph_nearby: list[str] = []
     category: str = ""
     day_index: int = 0
+    wellness: bool = False
+    pet_friendly: bool = False
 
 
 class PlaceItem(BaseModel):
@@ -56,6 +58,7 @@ class ValidateRequest(BaseModel):
     travel_type: Optional[Literal["cultural", "nature", "shopping", "food", "adventure"]] = None
     date: str = "2026-05-10"
     start_time: str = "09:00"
+    pet_friendly: bool = False
 
 
 class ParseTextRequest(BaseModel):
diff --git a/src/api/static/index.html b/src/api/static/index.html
index 93f617c..a22acb3 100644
--- a/src/api/static/index.html
+++ b/src/api/static/index.html
@@ -550,10 +550,18 @@
 .rep-item{background:var(--mint-l);border-radius:var(--r-sm);padding:.68rem .88rem;
   margin-bottom:.48rem;border:1.5px solid rgba(0,191,165,.22)}
 .rep-type{font-size:.65rem;font-weight:800;color:var(--mint);
-  letter-spacing:.5px;text-transform:uppercase;margin-bottom:.28rem}
+  letter-spacing:.5px;text-transform:uppercase;margin-bottom:.28rem;
+  display:flex;align-items:center;justify-content:space-between;gap:.4rem}
 .rep-body{font-size:.81rem;color:var(--n700);line-height:1.55}
 .rep-arr-place{font-weight:700;color:var(--navy)}
 .rep-arr-arrow{color:var(--n400);font-size:.72rem}
+.rep-gain{font-size:.68rem;font-weight:800;color:var(--mint);background:#fff;
+  border:1.5px solid var(--mint);border-radius:999px;padding:.08rem .48rem;white-space:nowrap}
+.rep-resolved{font-size:.68rem;font-weight:700;color:var(--mint);margin-top:.32rem;
+  display:flex;align-items:center;gap:.3rem}
+.rep-maplink{font-size:.72rem;font-weight:700;color:var(--navy);background:none;
+  border:none;padding:0;margin-top:.34rem;cursor:pointer;text-decoration:underline;
+  display:inline-block}
 
 /* Route compare */
 .route-compare{display:grid;grid-template-columns:1fr 1fr;gap:.55rem}
@@ -1404,6 +1412,12 @@ <h2>내 여행 일정,<br/>실제로 가능한지 검증해드립니다</h2>
             <button class="step-btn" id="size-plus" onclick="changeSize(1)" aria-label="인원 늘리기">+</button>
           </div>
         </div>
+        <div style="display:flex;align-items:center;justify-content:space-between;margin-top:.85rem">
+          <span style="font-size:.8rem;font-weight:600;color:var(--n600)">반려동물과 함께 가세요?</span>
+          <label style="display:flex;align-items:center;gap:.4rem;cursor:pointer;font-size:.78rem;color:var(--n600)">
+            <input type="checkbox" id="pet-friendly-chk" onchange="cfg.petFriendly=this.checked"/> 반려동물 동반
+          </label>
+        </div>
       </div>
       <div class="scard">
         <div class="scard-label">여행 스타일 <span style="font-size:.67rem;font-weight:500;color:var(--n400)">(선택)</span></div>
@@ -1681,7 +1695,7 @@ <h3>데이터 라이선스</h3>
 
 <script>
 /* ─── State ─────────────────────────────────────────────────────────── */
-var cfg = { region:"제주", date:"2026-06-01", startTime:"09:00", partyType:"친구", partySize:2, travelType:"" };
+var cfg = { region:"제주", date:"2026-06-01", startTime:"09:00", partyType:"친구", partySize:2, travelType:"", petFriendly:false };
 var days = [["성산일출봉","섭지코지","우도"],["한라산","사려니숲길"]];
 var selDay = 0;
 var allPlaces = [], filteredCache = [];
@@ -1757,6 +1771,8 @@ <h3>데이터 라이선스</h3>
     tip:"힐링·치유에 좋은 관광지가 포함돼 있어요"},
   accessibility:{title:"무장애 여행 가능!",
     tip:"거동이 불편하셔도 편하게 다닐 수 있는 코스예요"},
+  pet_friendly:{title:"반려동물 동반 가능!",
+    tip:"반려동물과 함께 갈 수 있는 장소가 포함돼 있어요"},
 };
 var SLABELS = {
   efficiency:  {label:"이동 효율",   tip:"얼마나 효율적으로 움직이는지예요. 이동시간 낭비가 적을수록 높아요"},
@@ -1957,6 +1973,7 @@ <h3>데이터 라이선스</h3>
   if (ddt) ddt.textContent = formatCalDisplay(cfg.date);
   document.getElementById("time-inp").value = cfg.startTime;
   document.getElementById("time-inp").addEventListener("change", function(){cfg.startTime=this.value;});
+  document.getElementById("pet-friendly-chk").checked = !!cfg.petFriendly;
   updateSizeDisplay();
 }
 
@@ -2828,7 +2845,8 @@ <h3>데이터 라이선스</h3>
   var payload = {
     days: fd.map(function(places){return {places:places.map(function(p){return {name:pname(p), address:pnote(p)};})};}),
     party_size:cfg.partySize, party_type:cfg.partyType,
-    date:cfg.date, start_time:cfg.startTime, travel_type:cfg.travelType||null
+    date:cfg.date, start_time:cfg.startTime, travel_type:cfg.travelType||null,
+    pet_friendly:!!cfg.petFriendly
   };
   var btn = document.getElementById("val-btn");
   btn.disabled=true; btn.textContent="살펴보는 중...";
@@ -3099,33 +3117,62 @@ <h3>데이터 라이선스</h3>
     html+='</div></div>';
   }
 
+  // Map — 점수·이유와 함께 핵심 정보이므로 개선 제안 바로 위, 상단부에 배치
+  var mapPois = (d.poi_info||[]).filter(function(p){return p.lat&&p.lng&&p.lat!==37.5665;});
+  if (mapPois.length) {
+    var mapDayCount = mapPois.reduce(function(m,p){return Math.max(m, (p.day_index||0)+1);}, 1);
+    var mapDayColors = _dayColors();
+    var dayLegend = "";
+    for (var mdi = 0; mdi < mapDayCount; mdi++) {
+      dayLegend += '<span class="leg-item"><span class="leg-dot" style="background:'+mapDayColors[mdi%mapDayColors.length]+'"></span>'+(mdi+1)+'일차</span>';
+    }
+    html += '<div class="map-card">' +
+      '<div class="map-head"><h3>여행 동선 지도</h3>' +
+      (d.hard_fails&&d.hard_fails.length?'<span class="rep-gain" style="border-color:var(--st-fail-fg);color:var(--st-fail-fg)">✕ 문제 지점 '+d.hard_fails.length+'곳</span>':'') +
+      '</div>' +
+      '<div id="travel-map"></div>' +
+      '<div class="map-legend">' + dayLegend +
+        (d.optimal_route ? '<span class="leg-item"><span style="border-bottom:2px dashed #00BFA5;width:18px;display:inline-block"></span>추천 순서</span>' : '') +
+        (d.hard_fails&&d.hard_fails.length ? '<span class="leg-item">✕ 문제 지점</span>' : '') +
+      '</div>' +
+    '</div>';
+  }
+
   // Repair
   var rep=d.repair_suggestions;
   if(rep&&!isRepEmpty(rep)){
     html+='<div id="res-repair" class="rcard"><div class="rcard-head"><div class="rcard-head-icon rcard-icon-blue"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" width="14" height="14"><path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7"/><path d="M18.5 2.5a2.121 2.121 0 013 3L12 15l-4 1 1-4 9.5-9.5z"/></svg></div><h3>이렇게 바꿔보면 어떨까요?</h3></div><div class="rcard-body">';
     (rep.reorders||[]).forEach(function(ro){
+      var firstPoi=(ro.suggested_order||[])[0];
       html+='<div class="rep-item">'+
-        '<div class="rep-type">순서 변경 제안 · Day '+(ro.day_index+1)+'</div>'+
+        '<div class="rep-type"><span>순서 변경 제안 · Day '+(ro.day_index+1)+'</span>'+repGainPill(ro)+'</div>'+
         '<div class="rep-body">이 순서로 가면 이동이 훨씬 편해요:<br/>'+
         (ro.suggested_order||[]).map(function(n,i,a){
           return '<span class="rep-arr-place">'+esc(n)+'</span>'+(i<a.length-1?' <span class="rep-arr-arrow">→</span> ':'');
         }).join("")+'</div>'+
         (ro.reason?'<div class="rep-reason">'+esc(ro.reason)+'</div>':'')+
+        repResolvedRow(ro)+
+        (firstPoi?'<button class="rep-maplink" onclick="focusMapPoi(\''+esc(firstPoi).replace(/'/g,"\\'")+'\')">지도에서 보기 →</button>':'')+
       '</div>';
     });
     (rep.time_tunes||[]).forEach(function(tt){
       var adjs=Object.entries(tt.adjustments||{}).map(function(kv){return esc(kv[0])+(kv[1]>0?" +"+kv[1]:" "+kv[1])+"분";}).join(", ");
+      var firstPoi=Object.keys(tt.adjustments||{})[0];
       html+='<div class="rep-item">'+
-        '<div class="rep-type">체류시간 조정 제안 · Day '+(tt.day_index+1)+'</div>'+
+        '<div class="rep-type"><span>체류시간 조정 제안 · Day '+(tt.day_index+1)+'</span>'+repGainPill(tt)+'</div>'+
         '<div class="rep-body">'+(adjs?adjs+" 조정하면 ":"")+(tt.saved_minutes?Math.round(tt.saved_minutes)+"분 여유가 생겨요":"여유가 생겨요")+'</div>'+
         (tt.reason?'<div class="rep-reason">'+esc(tt.reason)+'</div>':'')+
+        repResolvedRow(tt)+
+        (firstPoi?'<button class="rep-maplink" onclick="focusMapPoi(\''+esc(firstPoi).replace(/'/g,"\\'")+'\')">지도에서 보기 →</button>':'')+
       '</div>';
     });
     (rep.deletions||[]).forEach(function(dl){
       html+='<div class="rep-item">'+
-        '<div class="rep-type">방문지 조정 제안 · Day '+(dl.day_index+1)+'</div>'+
+        '<div class="rep-type"><span>방문지 조정 제안 · Day '+(dl.day_index+1)+'</span>'+repGainPill(dl)+'</div>'+
         '<div class="rep-body"><strong>'+esc(dl.candidate_name)+'</strong>을(를) 빼면 이동이 '+Math.round(dl.travel_saved_km||0)+'km 줄어들어요</div>'+
         (dl.reason?'<div class="rep-reason">'+esc(dl.reason)+'</div>':'')+
+        repResolvedRow(dl)+
+        '<button class="rep-maplink" onclick="focusMapPoi(\''+esc(dl.candidate_name).replace(/'/g,"\\'")+'\')">지도에서 보기 →</button>'+
       '</div>';
     });
     html+='</div></div>';
@@ -3177,24 +3224,6 @@ <h3>데이터 라이선스</h3>
     html+='</div></div>';
   }
 
-  // Map
-  var mapPois = (d.poi_info||[]).filter(function(p){return p.lat&&p.lng&&p.lat!==37.5665;});
-  if (mapPois.length) {
-    var mapDayCount = mapPois.reduce(function(m,p){return Math.max(m, (p.day_index||0)+1);}, 1);
-    var mapDayColors = _dayColors();
-    var dayLegend = "";
-    for (var mdi = 0; mdi < mapDayCount; mdi++) {
-      dayLegend += '<span class="leg-item"><span class="leg-dot" style="background:'+mapDayColors[mdi%mapDayColors.length]+'"></span>'+(mdi+1)+'일차</span>';
-    }
-    html += '<div class="map-card">' +
-      '<div class="map-head"><h3>여행 동선 지도</h3></div>' +
-      '<div id="travel-map"></div>' +
-      '<div class="map-legend">' + dayLegend +
-        (d.optimal_route ? '<span class="leg-item"><span style="border-bottom:2px dashed #00BFA5;width:18px;display:inline-block"></span>추천 순서</span>' : '') +
-      '</div>' +
-    '</div>';
-  }
-
   // POI table
   if(d.poi_info&&d.poi_info.length){
     html+='<div class="rcard"><div class="rcard-head"><div class="rcard-head-icon rcard-icon-gray"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" width="14" height="14"><path d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"/></svg></div><h3>장소별 상세 정보</h3></div>'+
@@ -3206,7 +3235,9 @@ <h3>데이터 라이선스</h3>
       var cl=p.confidence==="High"?"확실":p.confidence==="Medium"?"보통":"불확실";
       var graphLine=p.graph_region?'<div style="font-size:.66rem;color:var(--n400);margin-top:.15rem">'+esc(p.graph_region)+(p.graph_nearby&&p.graph_nearby.length?' · 도보권 대안 '+p.graph_nearby.length+'곳':'')+'</div>':'';
       var hoursTag=p.hours_estimated?' <span class="conf cm" style="margin-left:.25rem">추정</span>':'';
-      html+='<tr><td><strong>'+esc(p.name)+'</strong>'+graphLine+'</td>'+
+      var placeBadges=(p.wellness?' <span class="conf" style="background:var(--wellness-l);color:var(--wellness);margin-left:.25rem">웰니스 장소</span>':'')+
+        (p.pet_friendly?' <span class="conf" style="background:#eef2ff;color:#4338ca;margin-left:.25rem">반려동물 동반</span>':'');
+      html+='<tr><td><strong>'+esc(p.name)+'</strong>'+placeBadges+graphLine+'</td>'+
         '<td style="font-size:.73rem;color:var(--n500)">'+esc(p.open_start)+'~'+esc(p.open_end)+hoursTag+'</td>'+
         '<td>'+p.duration_min+'분</td>'+
         '<td><span class="conf '+cc+'">'+cl+'</span></td></tr>';
@@ -3249,7 +3280,7 @@ <h3>데이터 라이선스</h3>
   }, 60);
   if(d.scores) requestAnimationFrame(function(){drawRadar(d.scores);});
   var mapPoisFinal = (d.poi_info||[]).filter(function(p){return p.lat&&p.lng&&p.lat!==37.5665;});
-  if (mapPoisFinal.length) initMap(mapPoisFinal, d.optimal_route, d.congestion_warnings);
+  if (mapPoisFinal.length) initMap(mapPoisFinal, d.optimal_route, d.congestion_warnings, d.hard_fails);
 }
 
 function animateScore(target) {
@@ -3268,6 +3299,15 @@ <h3>데이터 라이선스</h3>
 
 function toggleEx(i){document.getElementById("ex"+i).classList.toggle("open");}
 function isRepEmpty(r){return(!r.reorders||!r.reorders.length)&&(!r.time_tunes||!r.time_tunes.length)&&(!r.deletions||!r.deletions.length);}
+function repGainPill(sug){
+  var g=sug.estimated_score_gain;
+  if(!g) return "";
+  return '<span class="rep-gain">'+(g>0?"+":"")+g+'점 예상</span>';
+}
+function repResolvedRow(sug){
+  if(!sug.resolves_hard_fail) return "";
+  return '<div class="rep-resolved">✓ 이 문제를 해결해요</div>';
+}
 
 /* ─── Radar ─────────────────────────────────────────────────────────── */
 function drawRadar(sc){
@@ -3694,6 +3734,18 @@ <h3>데이터 라이선스</h3>
 var _leafletMap = null;
 var _leafletReady = false;
 var _leafletLoading = false;
+var _leafletMarkersByName = {};
+
+function focusMapPoi(name) {
+  var mapCard = document.querySelector(".map-card");
+  if (mapCard) mapCard.scrollIntoView({ behavior: "smooth", block: "center" });
+  var marker = _leafletMarkersByName[name];
+  if (!marker || !_leafletMap) return;
+  setTimeout(function () {
+    _leafletMap.flyTo(marker.getLatLng(), 15, { duration: 0.6 });
+    marker.openPopup();
+  }, 350);
+}
 
 function loadLeaflet(cb) {
   if (typeof L !== "undefined") { cb(); return; }
@@ -3711,13 +3763,14 @@ <h3>데이터 라이선스</h3>
   document.head.appendChild(js);
 }
 
-function initMap(pois, optimalRoute, congestionWarnings) {
+function initMap(pois, optimalRoute, congestionWarnings, hardFails) {
   loadLeaflet(function(){
   var mapEl = document.getElementById("travel-map");
   if (!mapEl) return;
 
   // 이전 지도 인스턴스 제거
   if (_leafletMap) { _leafletMap.remove(); _leafletMap = null; }
+  _leafletMarkersByName = {};
 
   var center = [pois[0].lat, pois[0].lng];
   _leafletMap = L.map("travel-map", { zoomControl: true }).setView(center, 12);
@@ -3750,10 +3803,11 @@ <h3>데이터 라이선스</h3>
       iconSize: [28, 28],
       iconAnchor: [14, 14],
     });
-    L.marker([p.lat, p.lng], {icon: icon})
+    var marker = L.marker([p.lat, p.lng], {icon: icon})
       .addTo(_leafletMap)
       .bindPopup("<strong>"+esc(p.name)+"</strong><br/>"+(dayIdx+1)+"일차"+(catInfo ? " · "+esc(catInfo.label) : "")+
                  "<br/>"+esc(p.open_start)+"~"+esc(p.open_end)+" | "+esc(String(p.duration_min))+"분", {maxWidth:200});
+    _leafletMarkersByName[p.name] = marker;
   });
 
   // 현재 순서 경로선 — 일차별로 끊어서 색상 구분
@@ -3812,8 +3866,31 @@ <h3>데이터 라이선스</h3>
     });
   }
 
-  // 범례 (일차별 색상은 지도 하단 map-legend에서 표시 — 여기선 최적 동선/과밀만)
-  if ((optimalRoute && optimalRoute.length) || congCount) {
+  // 문제 지점 표시 (hard_fails 의 poi_name 을 좌표에 매칭 — 과밀과 구분되는 진한 빨강 ✕)
+  var failCount = 0;
+  if (hardFails && hardFails.length) {
+    var byNameF = {};
+    pois.forEach(function(p){ byNameF[p.name] = p; });
+    hardFails.forEach(function(hf){
+      var poi = hf.poi_name ? byNameF[hf.poi_name] : null;
+      if (!poi) return;
+      var ficon = L.divIcon({
+        className: "",
+        html: '<div style="width:34px;height:34px;border-radius:50%;border:3px solid #DC2626;'+
+              'background:#DC262622;display:flex;align-items:center;justify-content:center;'+
+              'font-size:15px;font-weight:900;color:#DC2626;box-shadow:0 0 0 4px #DC26261a">✕</div>',
+        iconSize: [34, 34],
+        iconAnchor: [17, 17],
+      });
+      L.marker([poi.lat, poi.lng], {icon: ficon, zIndexOffset: 1100})
+        .addTo(_leafletMap)
+        .bindPopup("<strong>"+esc(poi.name)+"</strong><br/>"+esc(hf.message||"문제가 있는 장소예요"), {maxWidth:220});
+      failCount++;
+    });
+  }
+
+  // 범례 (일차별 색상은 지도 하단 map-legend에서 표시 — 여기선 최적 동선/과밀/문제지점만)
+  if ((optimalRoute && optimalRoute.length) || congCount || failCount) {
     var legend = L.control({position: "bottomright"});
     legend.onAdd = function(){
       var div = L.DomUtil.create("div");
@@ -3827,6 +3904,9 @@ <h3>데이터 라이선스</h3>
       if (congCount) {
         rows += '<div><span style="vertical-align:middle">⚠</span> 과밀 지점 ('+congCount+')</div>';
       }
+      if (failCount) {
+        rows += '<div><span style="vertical-align:middle;color:#DC2626;font-weight:900">✕</span> 문제 지점 ('+failCount+')</div>';
+      }
       div.innerHTML = rows;
       return div;
     };
diff --git a/src/data/models.py b/src/data/models.py
index c272868..7e7eac6 100644
--- a/src/data/models.py
+++ b/src/data/models.py
@@ -114,6 +114,7 @@ class POI(BaseModel):
     # 영업시간이 실측/검증값이 아니라 카테고리 추정값이면 True.
     # 기본 False(기존 동작 유지) — 라우터에서 해석한 POI 만 True 로 설정한다.
     hours_estimated: bool = False
+    pet_friendly: bool = False
 
     @field_validator("poi_id")
     @classmethod
@@ -233,6 +234,7 @@ class ValidationResult(BaseModel):
     alternatives: dict[str, list[AlternativePOI]] = {}
     penalty_breakdown: dict[str, int] = Field(default_factory=dict)
     bonus_breakdown: dict[str, int] = Field(default_factory=dict)
+    wellness_matched: list[str] = Field(default_factory=list)
     repair: dict = Field(default_factory=dict)
     vrptw_optimal_route: list[DayRouteComparison] | None = None
     vrptw_efficiency_gap: float | None = None
diff --git a/src/explain/pipeline.py b/src/explain/pipeline.py
index c81d9f2..8cd19a8 100644
--- a/src/explain/pipeline.py
+++ b/src/explain/pipeline.py
@@ -20,28 +20,30 @@
 """
 from __future__ import annotations
 
+import dataclasses
 from pathlib import Path
 
 from src.data.models import (
-    ItineraryPlan,
     POI,
+    HardFail,
+    ItineraryPlan,
     Scores,
     ValidationResult,
     VRPTWDay,
     VRPTWPlace,
     VRPTWRequest,
 )
-from src.validation.vrptw_engine import VRPTWEngine
 from src.data.theme_taxonomy import UserPreferences
 from src.explain.explain_engine import ExplainEngine
-from src.explain.repair import RepairEngine
-from src.scoring.bonus_engine import BonusEngine
+from src.explain.repair import RepairEngine, RepairResult
+from src.scoring.bonus_engine import BonusEngine, BonusResult
 from src.scoring.cluster_dispersion import evaluate_cluster_dispersion
 from src.scoring.reward_engine import generate_rewards
 from src.scoring.theme_alignment import POIWithCategory, ThemeAlignmentJudge
 from src.scoring.travel_ratio import evaluate_travel_ratio
 from src.validation.hard_fail import HardFailDetector
 from src.validation.scoring import ScoreCalculator
+from src.validation.vrptw_engine import VRPTWEngine
 from src.validation.warning import WarningDetector
 
 _DEFAULT_WELLNESS_PATH = Path("data/wellness_places.json")
@@ -77,6 +79,24 @@ def _to_poi_with_category(pois: list[POI], order_offset: int = 0) -> list[POIWit
     ]
 
 
+@dataclasses.dataclass
+class _ScoreBundle:
+    """1·3·3b·4·5·6·7·8단계(점수 계산)만의 결과. Warning·Repair·Explain 미포함."""
+    adjusted: int
+    base_score: int
+    scores: Scores
+    hard_fails: list[HardFail]
+    capping_fails: list[HardFail]
+    vrptw_optimal_route: list | None
+    vrptw_efficiency_gap: float | None
+    cluster_penalty: int
+    travel_ratio_penalty: int
+    theme_penalty: int
+    vrptw_penalty: int
+    overall_travel_ratio: float
+    bonus_result: BonusResult
+
+
 class ValidatorPipeline:
     """전체 검증 파이프라인. External I/O = Claude API (ExplainEngine·ThemeAlignmentJudge)."""
 
@@ -103,6 +123,7 @@ def run(
         matrix: dict,
         sigungu_codes_per_day: list[list[str]] | None = None,
         user_prefs: UserPreferences | None = None,
+        pet_friendly_enabled: bool = False,
     ) -> ValidationResult:
         """파이프라인 실행 → ValidationResult 반환.
 
@@ -112,26 +133,13 @@ def run(
             matrix: 이동 시간 행렬 (인덱스 기반, 없으면 빈 dict)
             sigungu_codes_per_day: 일자별 시군구 코드 (ClusterDispersion M1/M3용)
             user_prefs: LLM 테마 판정용 UserPreferences (None이면 스킵)
+            pet_friendly_enabled: 사용자가 "반려동물 동반" 카테고리를 켰는지 여부
         """
         all_pois: list[POI] = [poi for day in per_day_pois for poi in day]
-
-        # ── 1. HardFail 탐지 (per-day) ─────────────────────────────────
-        hard_fails = []
-        prev_last_accom: POI | None = None
-        for day_idx, day_pois in enumerate(per_day_pois):
-            if not day_pois:
-                continue
-            fails = self._hard_fail.detect(
-                plan=plan,
-                pois=day_pois,
-                matrix=matrix,
-                origin_poi=prev_last_accom,
-                day_index=day_idx,
-            )
-            hard_fails.extend(fails)
-            # 마지막 숙소 POI 추출 (다음 날 origin으로)
-            accom_pois = [p for p in day_pois if p.category == "32"]
-            prev_last_accom = accom_pois[-1] if accom_pois else None
+        bundle = self._score(
+            plan, per_day_pois, matrix,
+            sigungu_codes_per_day, user_prefs, pet_friendly_enabled,
+        )
 
         # ── 2. Warning 탐지 (per-day) ────────────────────────────────────
         # PURPOSE_MISMATCH는 여행 전체 테마 판단 → all_pois로 1회만 호출
@@ -151,6 +159,111 @@ def run(
             self._warning.check_cumulative_fatigue(plan, per_day_pois, matrix)
         )
 
+        rewards = generate_rewards(
+            scores=bundle.scores,
+            n_hard_fails=len(bundle.hard_fails),
+            n_warnings=len(warnings),
+            overall_travel_ratio=bundle.overall_travel_ratio,
+            cluster_penalty=bundle.cluster_penalty,
+        )
+
+        penalty_breakdown: dict[str, int] = {}
+        if bundle.cluster_penalty:
+            penalty_breakdown["cluster_dispersion"] = bundle.cluster_penalty
+        if bundle.travel_ratio_penalty:
+            penalty_breakdown["travel_ratio"] = bundle.travel_ratio_penalty
+        if bundle.theme_penalty:
+            penalty_breakdown["theme_alignment"] = bundle.theme_penalty
+        if bundle.vrptw_penalty:
+            penalty_breakdown["vrptw_efficiency"] = bundle.vrptw_penalty
+
+        bonus_breakdown: dict[str, int] = {}
+        if bundle.bonus_result.wellness_bonus:
+            bonus_breakdown["wellness"] = bundle.bonus_result.wellness_bonus
+        if bundle.bonus_result.accessibility_bonus:
+            bonus_breakdown["accessibility"] = bundle.bonus_result.accessibility_bonus
+        if bundle.bonus_result.pet_friendly_bonus:
+            bonus_breakdown["pet_friendly"] = bundle.bonus_result.pet_friendly_bonus
+
+        # ── 10. Repair Engine (Hard Fail 발생 시만 실행) ─────────────────
+        repair_data: dict = {}
+        if bundle.hard_fails:
+            repair_result = self._repair.repair(
+                plan=plan,
+                per_day_pois=per_day_pois,
+                matrix=matrix,
+                hard_fails=bundle.hard_fails,
+            )
+            if not repair_result.is_empty:
+                repair_result = self._estimate_repair_gains(
+                    plan, per_day_pois, matrix, pet_friendly_enabled, repair_result,
+                )
+                repair_data = repair_result.to_dict()
+
+        # ── 11. ExplainEngine → 4단계 자연어 설명 생성 ─────────────────
+        explanations = self._explain.generate(
+            hard_fails=bundle.hard_fails,
+            warnings=warnings,
+            penalty_breakdown=penalty_breakdown,
+            bonus_breakdown=bonus_breakdown,
+            scores=bundle.scores,
+            plan=plan,
+            final_score=bundle.adjusted,
+        )
+
+        # ── 12. Hard Fail POI 대안 (지식그래프 도보권 대안, 미설정/미매칭 시 빈 dict) ──
+        alternatives = self._explain.build_alternatives(bundle.hard_fails) if bundle.hard_fails else {}
+
+        return ValidationResult(
+            plan_id=plan.plan_id,
+            final_score=bundle.adjusted,
+            base_score=bundle.base_score,
+            hard_fails=bundle.hard_fails,
+            warnings=warnings,
+            scores=bundle.scores,
+            explanations=explanations,
+            rewards=rewards,
+            alternatives=alternatives,
+            penalty_breakdown=penalty_breakdown,
+            bonus_breakdown=bonus_breakdown,
+            wellness_matched=bundle.bonus_result.wellness_matched,
+            repair=repair_data,
+            vrptw_optimal_route=bundle.vrptw_optimal_route,
+            vrptw_efficiency_gap=bundle.vrptw_efficiency_gap,
+        )
+
+    def _score(
+        self,
+        plan: ItineraryPlan,
+        per_day_pois: list[list[POI]],
+        matrix: dict,
+        sigungu_codes_per_day: list[list[str]] | None,
+        user_prefs: UserPreferences | None,
+        pet_friendly_enabled: bool,
+    ) -> _ScoreBundle:
+        """1·3·3b·4·5·6·7·8단계만 실행해 점수를 계산한다 (Warning·Repair·Explain 제외).
+
+        RepairEngine 제안의 예상 점수 변화를 시뮬레이션하는 `_estimate_repair_gains`에서도 재사용된다.
+        """
+        all_pois: list[POI] = [poi for day in per_day_pois for poi in day]
+
+        # ── 1. HardFail 탐지 (per-day) ─────────────────────────────────
+        hard_fails: list[HardFail] = []
+        prev_last_accom: POI | None = None
+        for day_idx, day_pois in enumerate(per_day_pois):
+            if not day_pois:
+                continue
+            fails = self._hard_fail.detect(
+                plan=plan,
+                pois=day_pois,
+                matrix=matrix,
+                origin_poi=prev_last_accom,
+                day_index=day_idx,
+            )
+            hard_fails.extend(fails)
+            accom_pois = [p for p in day_pois if p.category == "32"]
+            prev_last_accom = accom_pois[-1] if accom_pois else None
+
         # ── 3. ScoreCalculator → base_score ────────────────────────────
         if all_pois:
             scores, base_score = self._scorer.compute(
@@ -164,7 +277,6 @@ def run(
             base_score = 0
 
         # ── 3b. VRPTWEngine 실행 — 최적 경로 + Efficiency Gap ────────────
-        # vrptw_days를 한 번만 생성해 step 4·5에서 재사용
         vrptw_days = [_to_vrptw_day(day) for day in per_day_pois if day]
         vrptw_optimal_route = None
         vrptw_efficiency_gap = None
@@ -185,9 +297,7 @@ def run(
         # ── 4. ClusterDispersion 패널티 ─────────────────────────────────
         cluster_penalty = 0
         if vrptw_days:
-            cd_report = evaluate_cluster_dispersion(
-                vrptw_days, sigungu_codes_per_day
-            )
+            cd_report = evaluate_cluster_dispersion(vrptw_days, sigungu_codes_per_day)
             cluster_penalty = cd_report.total_penalty
 
         # ── 5. TravelRatio 패널티 ───────────────────────────────────────
@@ -206,82 +316,96 @@ def run(
             theme_penalty = ta_report.penalty
 
         # ── 7. BonusEngine 가산점 ───────────────────────────────────────
-        bonus_result = self._bonus.compute(pois=all_pois, party_type=plan.party_type)
-        total_bonus = bonus_result.total_bonus
+        bonus_result = self._bonus.compute(
+            pois=all_pois, party_type=plan.party_type,
+            pet_friendly_enabled=pet_friendly_enabled,
+        )
 
         # ── 8. 최종 점수 조립 ───────────────────────────────────────────
         penalty_total = cluster_penalty + travel_ratio_penalty + theme_penalty + vrptw_penalty
-        adjusted = base_score - penalty_total + total_bonus
+        adjusted = base_score - penalty_total + bonus_result.total_bonus
         adjusted = max(0, min(100, adjusted))
         # 추정 영업시간 충돌(estimated=True)은 '확인 필요' 수준 → 점수 캡에서 제외.
         capping_fails = [hf for hf in hard_fails if not getattr(hf, "estimated", False)]
         if capping_fails:
             adjusted = min(adjusted, 59)
 
-        # ── 9. Rewards ──────────────────────────────────────────────────
-        rewards = generate_rewards(
+        return _ScoreBundle(
+            adjusted=adjusted,
+            base_score=base_score,
             scores=scores,
-            n_hard_fails=len(hard_fails),
-            n_warnings=len(warnings),
-            overall_travel_ratio=overall_travel_ratio,
+            hard_fails=hard_fails,
+            capping_fails=capping_fails,
+            vrptw_optimal_route=vrptw_optimal_route,
+            vrptw_efficiency_gap=vrptw_efficiency_gap,
             cluster_penalty=cluster_penalty,
+            travel_ratio_penalty=travel_ratio_penalty,
+            theme_penalty=theme_penalty,
+            vrptw_penalty=vrptw_penalty,
+            overall_travel_ratio=overall_travel_ratio,
+            bonus_result=bonus_result,
         )
 
-        penalty_breakdown: dict[str, int] = {}
-        if cluster_penalty:
-            penalty_breakdown["cluster_dispersion"] = cluster_penalty
-        if travel_ratio_penalty:
-            penalty_breakdown["travel_ratio"] = travel_ratio_penalty
-        if theme_penalty:
-            penalty_breakdown["theme_alignment"] = theme_penalty
-        if vrptw_penalty:
-            penalty_breakdown["vrptw_efficiency"] = vrptw_penalty
-
-        bonus_breakdown: dict[str, int] = {}
-        if bonus_result.wellness_bonus:
-            bonus_breakdown["wellness"] = bonus_result.wellness_bonus
-        if bonus_result.accessibility_bonus:
-            bonus_breakdown["accessibility"] = bonus_result.accessibility_bonus
-
-        # ── 10. Repair Engine (Hard Fail 발생 시만 실행) ─────────────────
-        repair_data: dict = {}
-        if hard_fails:
-            repair_result = self._repair.repair(
-                plan=plan,
-                per_day_pois=per_day_pois,
-                matrix=matrix,
-                hard_fails=hard_fails,
-            )
-            if not repair_result.is_empty:
-                repair_data = repair_result.to_dict()
-
-        # ── 11. ExplainEngine → 4단계 자연어 설명 생성 ─────────────────
-        explanations = self._explain.generate(
-            hard_fails=hard_fails,
-            warnings=warnings,
-            penalty_breakdown=penalty_breakdown,
-            bonus_breakdown=bonus_breakdown,
-            scores=scores,
-            plan=plan,
-            final_score=adjusted,
+    def _estimate_repair_gains(
+        self,
+        plan: ItineraryPlan,
+        per_day_pois: list[list[POI]],
+        matrix: dict,
+        pet_friendly_enabled: bool,
+        repair_result: RepairResult,
+    ) -> RepairResult:
+        """교정 제안별 예상 점수 변화(`estimated_score_gain`)와 문제 해소 여부(`resolves_hard_fail`)를 채운다.
+
+        ponytail: baseline·시뮬레이션 양쪽 모두 sigungu_codes_per_day=None, user_prefs=None로
+        고정해 M1/M3 시군구 백트래킹과 LLM 테마 판정(ThemeAlignment)을 생략한다 — 두 항목 모두
+        비교 대상인 base_score/penalty 구조와 무관하게 baseline·시뮬레이션에 동일하게 적용되므로
+        델타 계산의 공정성은 유지되면서 추가 I/O·LLM 호출 없이 저지연으로 끝난다.
+        정밀도가 필요해지면 실제 sigungu_codes_per_day·user_prefs를 그대로 전달하도록 확장한다.
+        """
+        baseline = self._score(
+            plan, per_day_pois, matrix,
+            sigungu_codes_per_day=None, user_prefs=None,
+            pet_friendly_enabled=pet_friendly_enabled,
         )
 
-        # ── 12. Hard Fail POI 대안 (지식그래프 도보권 대안, 미설정/미매칭 시 빈 dict) ──
-        alternatives = self._explain.build_alternatives(hard_fails) if hard_fails else {}
-
-        return ValidationResult(
-            plan_id=plan.plan_id,
-            final_score=adjusted,
-            base_score=base_score,
-            hard_fails=hard_fails,
-            warnings=warnings,
-            scores=scores,
-            explanations=explanations,
-            rewards=rewards,
-            alternatives=alternatives,
-            penalty_breakdown=penalty_breakdown,
-            bonus_breakdown=bonus_breakdown,
-            repair=repair_data,
-            vrptw_optimal_route=vrptw_optimal_route,
-            vrptw_efficiency_gap=vrptw_efficiency_gap,
-        )
+        def simulate(day_idx: int, modified_day: list[POI]) -> tuple[int, bool]:
+            sim_days = list(per_day_pois)
+            sim_days[day_idx] = modified_day
+            bundle = self._score(
+                plan, sim_days, matrix,
+                sigungu_codes_per_day=None, user_prefs=None,
+                pet_friendly_enabled=pet_friendly_enabled,
+            )
+            resolved = not any(hf.day_index == day_idx for hf in bundle.capping_fails)
+            return bundle.adjusted - baseline.adjusted, resolved
+
+        reorders = []
+        for ro in repair_result.reorders:
+            by_name = {p.name: p for p in per_day_pois[ro.day_index]}
+            modified = [by_name[n] for n in ro.suggested_order if n in by_name]
+            gain, resolved = simulate(ro.day_index, modified)
+            reorders.append(dataclasses.replace(
+                ro, estimated_score_gain=gain, resolves_hard_fail=resolved,
+            ))
+
+        time_tunes = []
+        for tt in repair_result.time_tunes:
+            modified = [
+                p.model_copy(update={"duration_min": tt.adjustments[p.name]})
+                if p.name in tt.adjustments else p
+                for p in per_day_pois[tt.day_index]
+            ]
+            gain, resolved = simulate(tt.day_index, modified)
+            time_tunes.append(dataclasses.replace(
+                tt, estimated_score_gain=gain, resolves_hard_fail=resolved,
+            ))
+
+        deletions = []
+        for dl in repair_result.deletions:
+            modified = [p for p in per_day_pois[dl.day_index] if p.name != dl.candidate_name]
+            gain, resolved = simulate(dl.day_index, modified)
+            deletions.append(dataclasses.replace(
+                dl, estimated_score_gain=gain, resolves_hard_fail=resolved,
+            ))
+
+        return RepairResult(reorders=reorders, time_tunes=time_tunes, deletions=deletions)
diff --git a/src/explain/repair.py b/src/explain/repair.py
index dc4109f..2d162cd 100644
--- a/src/explain/repair.py
+++ b/src/explain/repair.py
@@ -45,6 +45,8 @@ class ReorderSuggestion:
     day_index: int
     suggested_order: list[str]
     reason: str
+    estimated_score_gain: int = 0
+    resolves_hard_fail: bool = False
 
 
 @dataclass
@@ -53,6 +55,8 @@ class TimeTuneSuggestion:
     adjustments: dict[str, int]  # poi_name → 조정 후 duration_min
     saved_minutes: int
     reason: str
+    estimated_score_gain: int = 0
+    resolves_hard_fail: bool = False
 
 
 @dataclass
@@ -62,6 +66,8 @@ class DeletionSuggestion:
     travel_saved_km: float
     reason: str
     nearby_restaurants: list[dict] = field(default_factory=list)
+    estimated_score_gain: int = 0
+    resolves_hard_fail: bool = False
 
 
 @dataclass
diff --git a/src/scoring/bonus_engine.py b/src/scoring/bonus_engine.py
index 9d9c69f..a1f0a83 100644
--- a/src/scoring/bonus_engine.py
+++ b/src/scoring/bonus_engine.py
@@ -10,6 +10,7 @@
 
 WELLNESS_BONUS_PER_PLACE: int = 3
 ACCESSIBILITY_BONUS_PER_PLACE: int = 5
+PET_FRIENDLY_BONUS_PER_PLACE: int = 2
 BONUS_CAP: int = 20
 
 ACCESSIBLE_PARTY_TYPES: frozenset[str] = frozenset({"아기동반", "어르신동반", "가족"})
@@ -22,9 +23,11 @@
 class BonusResult:
     wellness_bonus: int
     accessibility_bonus: int
+    pet_friendly_bonus: int
     total_bonus: int
     wellness_matched: list[str]        # 매칭된 POI 이름 목록
     accessibility_matched: list[str]   # 매칭된 POI 이름 목록
+    pet_friendly_matched: list[str]    # 매칭된 POI 이름 목록
 
 
 @dataclass(frozen=True)
@@ -80,14 +83,18 @@ def compute(
         self,
         pois: list[POI],
         party_type: str,
+        pet_friendly_enabled: bool = False,
     ) -> BonusResult:
         """POI 목록에서 가산점 계산.
 
         - 웰니스 장소: 모든 party_type에 적용.
         - 무장애 장소: ACCESSIBLE_PARTY_TYPES에만 적용.
+        - 반려동물 동반: 사용자가 카테고리를 켠 경우(pet_friendly_enabled)만 적용.
+          미매칭이어도 감점은 없다 — 가산점 전용.
         """
         wellness_matched: list[str] = []
         accessibility_matched: list[str] = []
+        pet_friendly_matched: list[str] = []
 
         for poi in pois:
             if _nearest_km(poi, self._wellness) <= MATCH_RADIUS_KM:
@@ -97,6 +104,8 @@ def compute(
                 and _nearest_km(poi, self._barrier_free) <= MATCH_RADIUS_KM
             ):
                 accessibility_matched.append(poi.name)
+            if pet_friendly_enabled and poi.pet_friendly:
+                pet_friendly_matched.append(poi.name)
 
         wellness_bonus = min(
             len(wellness_matched) * WELLNESS_BONUS_PER_PLACE, BONUS_CAP
@@ -104,14 +113,21 @@ def compute(
         accessibility_bonus = min(
             len(accessibility_matched) * ACCESSIBILITY_BONUS_PER_PLACE, BONUS_CAP
         )
-        total_bonus = min(wellness_bonus + accessibility_bonus, BONUS_CAP)
+        pet_friendly_bonus = min(
+            len(pet_friendly_matched) * PET_FRIENDLY_BONUS_PER_PLACE, BONUS_CAP
+        )
+        total_bonus = min(
+            wellness_bonus + accessibility_bonus + pet_friendly_bonus, BONUS_CAP
+        )
 
         return BonusResult(
             wellness_bonus=wellness_bonus,
             accessibility_bonus=accessibility_bonus,
+            pet_friendly_bonus=pet_friendly_bonus,
             total_bonus=total_bonus,
             wellness_matched=wellness_matched,
             accessibility_matched=accessibility_matched,
+            pet_friendly_matched=pet_friendly_matched,
         )
 
 
diff --git a/tests/test_bonus_engine.py b/tests/test_bonus_engine.py
index 2dc4e79..0cd0af4 100644
--- a/tests/test_bonus_engine.py
+++ b/tests/test_bonus_engine.py
@@ -12,18 +12,22 @@
     ACCESSIBLE_PARTY_TYPES,
     ACCESSIBILITY_BONUS_PER_PLACE,
     BONUS_CAP,
+    PET_FRIENDLY_BONUS_PER_PLACE,
     WELLNESS_BONUS_PER_PLACE,
     BonusEngine,
     _PlaceCoord,
 )
 
 
-def make_poi(poi_id: str = "1", lat: float = 37.5, lng: float = 127.0) -> POI:
+def make_poi(
+    poi_id: str = "1", lat: float = 37.5, lng: float = 127.0, pet_friendly: bool = False,
+) -> POI:
     return POI(
         poi_id=poi_id, name=f"POI_{poi_id}",
         lat=lat, lng=lng,
         open_start="09:00", open_end="18:00",
         duration_min=60,
+        pet_friendly=pet_friendly,
     )
 
 
@@ -111,6 +115,43 @@ def test_accessibility_bonus_capped(self):
         assert result.accessibility_bonus <= BONUS_CAP
 
 
+# ---------------------------------------------------------------------------
+# BonusEngine.compute() — pet-friendly bonus (가산점만, 감점 없음)
+# ---------------------------------------------------------------------------
+
+class TestPetFriendlyBonus:
+    def test_disabled_gives_zero_even_if_matched(self):
+        engine = make_engine()
+        pois = [make_poi("1", 37.5, 127.0, pet_friendly=True)]
+        result = engine.compute(pois, party_type="친구", pet_friendly_enabled=False)
+        assert result.pet_friendly_bonus == 0
+
+    def test_enabled_and_flagged_gives_bonus(self):
+        engine = make_engine()
+        pois = [make_poi("1", 37.5, 127.0, pet_friendly=True)]
+        result = engine.compute(pois, party_type="친구", pet_friendly_enabled=True)
+        assert result.pet_friendly_bonus == PET_FRIENDLY_BONUS_PER_PLACE
+
+    def test_enabled_but_not_flagged_no_bonus_no_penalty(self):
+        engine = make_engine()
+        pois = [make_poi("1", 37.5, 127.0, pet_friendly=False)]
+        result = engine.compute(pois, party_type="친구", pet_friendly_enabled=True)
+        assert result.pet_friendly_bonus == 0
+        assert result.total_bonus == 0
+
+    def test_pet_friendly_bonus_capped(self):
+        pois = [make_poi(str(i), pet_friendly=True) for i in range(20)]
+        engine = make_engine()
+        result = engine.compute(pois, party_type="친구", pet_friendly_enabled=True)
+        assert result.pet_friendly_bonus <= BONUS_CAP
+
+    def test_pet_friendly_matched_names_populated(self):
+        engine = make_engine()
+        pois = [make_poi("1", pet_friendly=True), make_poi("2", pet_friendly=False)]
+        result = engine.compute(pois, party_type="친구", pet_friendly_enabled=True)
+        assert result.pet_friendly_matched == ["POI_1"]
+
+
 # ---------------------------------------------------------------------------
 # BonusEngine.compute() — total_bonus cap
 # ---------------------------------------------------------------------------
diff --git a/tests/test_pipeline_orchestrator.py b/tests/test_pipeline_orchestrator.py
index 8f9f9b9..641812a 100644
--- a/tests/test_pipeline_orchestrator.py
+++ b/tests/test_pipeline_orchestrator.py
@@ -254,6 +254,33 @@ def test_accessibility_bonus_for_accessible_party(self):
         assert "accessibility" in result.bonus_breakdown
         assert result.bonus_breakdown["accessibility"] > 0
 
+    def test_pet_friendly_bonus_when_enabled(self, pipeline):
+        poi = make_poi("1", 37.5, 127.0).model_copy(update={"pet_friendly": True})
+        plan = make_plan([poi.name])
+        result = pipeline.run(
+            plan=plan, per_day_pois=[[poi]], matrix={}, pet_friendly_enabled=True
+        )
+        assert "pet_friendly" in result.bonus_breakdown
+        assert result.bonus_breakdown["pet_friendly"] > 0
+
+    def test_pet_friendly_bonus_absent_when_disabled(self, pipeline):
+        poi = make_poi("1", 37.5, 127.0).model_copy(update={"pet_friendly": True})
+        plan = make_plan([poi.name])
+        result = pipeline.run(
+            plan=plan, per_day_pois=[[poi]], matrix={}, pet_friendly_enabled=False
+        )
+        assert "pet_friendly" not in result.bonus_breakdown
+
+    def test_wellness_matched_exposed_on_result(self):
+        wellness = [_PlaceCoord(lat=37.5, lng=127.0)]
+        engine = BonusEngine(wellness_coords=wellness, barrier_free_coords=[])
+        pipeline = ValidatorPipeline(bonus_engine=engine)
+
+        pois = [make_poi("1", 37.5, 127.0)]
+        plan = make_plan([p.name for p in pois])
+        result = pipeline.run(plan=plan, per_day_pois=[pois], matrix={})
+        assert pois[0].name in result.wellness_matched
+
 
 # ---------------------------------------------------------------------------
 # ValidatorPipeline.run() — multi-day
@@ -349,3 +376,35 @@ def test_vrptw_penalty_does_not_double_count_with_single_poi(self, pipeline):
         result = pipeline.run(plan=plan, per_day_pois=[pois], matrix={})
         # 단일 POI는 efficiency gap 미정의 → vrptw 패널티 없어야 함
         assert result.penalty_breakdown.get("vrptw_efficiency", 0) == 0
+
+
+# ---------------------------------------------------------------------------
+# ValidatorPipeline.run() — Repair 제안 예상 점수 변화 (지도 UX 개선)
+# ---------------------------------------------------------------------------
+
+class TestPipelineRepairGainEstimation:
+    def test_deletion_suggestion_carries_gain_and_resolves_flag(self, pipeline):
+        """지리적 이상치이자 Hard Fail 유발 POI를 삭제하면 점수가 오르고 문제가 해소돼야 한다."""
+        a = make_poi("A", 37.50, 127.00)
+        b = make_poi("B", 37.51, 127.01)
+        night_only = POI(
+            poi_id="X", name="NightOnly", lat=38.50, lng=127.00,
+            open_start="22:00", open_end="23:00", duration_min=60, category="14",
+        )
+        pois = [a, b, night_only]
+        plan = make_plan([p.name for p in pois])
+        result = pipeline.run(plan=plan, per_day_pois=[pois], matrix={})
+
+        assert result.hard_fails
+        deletions = result.repair.get("deletions", [])
+        assert deletions
+        target = next((d for d in deletions if d["candidate_name"] == night_only.name), None)
+        assert target is not None
+        assert target["resolves_hard_fail"] is True
+        assert target["estimated_score_gain"] > 0
+
+    def test_no_repair_no_gain_fields_needed(self, pipeline, sample_pois, sample_plan):
+        """Hard Fail이 없으면 repair 자체가 비어 있어야 한다 (기존 동작 유지)."""
+        result = pipeline.run(plan=sample_plan, per_day_pois=[sample_pois], matrix={})
+        if not result.hard_fails:
+            assert result.repair == {}
diff --git a/tests/test_resolve_poi.py b/tests/test_resolve_poi.py
index 4b94775..321b003 100644
--- a/tests/test_resolve_poi.py
+++ b/tests/test_resolve_poi.py
@@ -3,11 +3,93 @@
 
 from unittest.mock import patch
 
+import openpyxl
+import pytest
 from fastapi.testclient import TestClient
 
 from src.api import router
 from src.api.main import app
 
+_XLSX_HEADER = [
+    "상호명", "도로명주소", "위도", "경도", "대분류코드", "대분류명", "영업시간",
+    "TourAPI_contentid", "TourAPI_영업시간", "반려동물동반",
+]
+
+
+def _write_jeju_xlsx(path, rows):
+    wb = openpyxl.Workbook()
+    ws = wb.active
+    ws.append(_XLSX_HEADER)
+    for row in rows:
+        ws.append([row.get(col, "") for col in _XLSX_HEADER])
+    wb.save(path)
+
+
+@pytest.fixture
+def jeju_xlsx_index(tmp_path, monkeypatch):
+    """data/제주특별자치도_통합_TourAPI병합.xlsx 를 임시 파일로 대체해 _build_jeju_place_index()를 격리 실행."""
+    _write_jeju_xlsx(
+        tmp_path / "제주특별자치도_통합_TourAPI병합.xlsx",
+        [
+            {  # TourAPI 매칭 성공 — 실측 영업시간·contentid 우선 사용, 반려동물 동반 가능
+                "상호명": "제주아트센터", "도로명주소": "제주시 어딘가", "위도": "33.4", "경도": "126.5",
+                "대분류코드": "VE", "대분류명": "문화관광",
+                "영업시간": "10:00~19:00", "TourAPI_contentid": 1755806,
+                "TourAPI_영업시간": "09:30~18:30 (휴게 12:00~13:00)", "반려동물동반": "Y",
+            },
+            {  # TourAPI 미매칭 — 기존 영업시간 원문 텍스트로 폴백, 반려동물 동반 정보 없음
+                "상호명": "클리프홀", "도로명주소": "서귀포시 어딘가", "위도": "33.38", "경도": "126.23",
+                "대분류코드": "VE", "대분류명": "문화관광",
+                "영업시간": "10:00~24:00", "TourAPI_contentid": "", "TourAPI_영업시간": "", "반려동물동반": "",
+            },
+        ],
+    )
+    monkeypatch.setattr(router, "_DATA_DIR", tmp_path)
+    return router._build_jeju_place_index()
+
+
+def test_jeju_index_prefers_tourapi_hours_over_legacy_text(jeju_xlsx_index):
+    entry = jeju_xlsx_index[router._normalize("제주아트센터")]
+    assert (entry["open_start"], entry["open_end"]) == ("09:30", "18:30")
+
+
+def test_jeju_index_sets_contentid_when_tourapi_matched(jeju_xlsx_index):
+    entry = jeju_xlsx_index[router._normalize("제주아트센터")]
+    assert entry["contentid"] == "1755806"
+
+
+def test_jeju_index_falls_back_to_legacy_hours_when_unmatched(jeju_xlsx_index):
+    entry = jeju_xlsx_index[router._normalize("클리프홀")]
+    assert (entry["open_start"], entry["open_end"]) == ("10:00", "24:00")
+    assert "contentid" not in entry
+
+
+def test_jeju_index_sets_pet_friendly_flag_when_y(jeju_xlsx_index):
+    entry = jeju_xlsx_index[router._normalize("제주아트센터")]
+    assert entry["pet_friendly"] is True
+
+
+def test_jeju_index_defaults_pet_friendly_false_when_blank(jeju_xlsx_index):
+    entry = jeju_xlsx_index[router._normalize("클리프홀")]
+    assert entry.get("pet_friendly", False) is False
+
+
+def test_resolve_poi_propagates_pet_friendly_flag(monkeypatch):
+    """_resolve_poi()가 place dict의 pet_friendly 속성을 POI·POIInfo로 전달한다."""
+    monkeypatch.setitem(
+        router._JEJU_CSV_INDEX,
+        router._normalize("반려동반테스트장소"),
+        {
+            "name": "반려동반테스트장소", "lat": 33.4, "lng": 126.5,
+            "region": "제주", "cat": "12", "cat_name": "관광지",
+            "addr": "", "has_coords": True, "source": "jeju_csv",
+            "pet_friendly": True,
+        },
+    )
+    poi, info = router._resolve_poi("반려동반테스트장소", 0)
+    assert poi.pet_friendly is True
+    assert info.pet_friendly is True
+
 
 def test_geocode_fallback_used_when_keyword_search_fails():
     """카카오 키워드 검색이 실패해도 주소가 있으면 지오코딩으로 좌표를 보강한다."""