feat(map): NaverMapView 채널별 마커 색상

- GoogleMapView와 동일 팔레트 (8 색)
- 식당 첫 채널 기준 색상, activeChannel 있으면 우선
- getChannelColorMap 재사용 패턴 동일

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

CHANGELOG.md

@@ -4,8 +4,279 @@
 
 ---
 
+## 2026-06-16
+
+### 🎨 NaverMapView 채널별 마커 색상 (v0.1.60)
+- GoogleMapView와 동일 팔레트 (amber/blue/green/pink/purple/red/teal/yellow)
+- 식당의 첫 채널 기준 색상, activeChannel 있으면 그 채널 우선
+
+### ⚡ NaverMapView SDK 네이티브 마커 + InfoWindow (v0.1.59)
+- 마커를 React `absolute div` overlay → `naver.maps.Marker` 네이티브로 교체
+  - 줌/팬 시 SDK가 GPU 최적화, 매 frame React 리렌더링 없음 → 랙 해소
+- 식당명 InfoWindow 추가 (마커 클릭 시 표시)
+- bounds_changed → idle 이벤트로 sync (줌/팬 중 발화 빈도 ↓)
+- 클러스터도 네이티브 마커 (HTML 콘텐츠로 숫자 표시)
+
+### 🗺️ NaverMapView 안정화 + 재활성 (v0.1.57)
+- divRef 항상 마운트 (이전: ready 가드로 첫 렌더 ref 누락 가능)
+- 명시적 width/height + 회색 배경(시각적 로딩 표시)
+- ResizeObserver + requestAnimationFrame으로 컨테이너 0×0 → 정상 크기 시 refresh
+- try/catch + initError state로 init 실패 가시화
+- Naver 키 재활성
+
+### ⏪ NaverMap 임시 비활성, 한국도 GoogleMap fallback (v0.1.55)
+- NaverMapView 골격이 실 운영에서 지도/마커 렌더 실패 (정확한 원인 추후 진단)
+- NEXT_PUBLIC_NAVER_MAP_CLIENT_ID 빈 값으로 dispatcher가 GoogleMap fallback (회귀 0)
+- NaverMapView 코드는 유지 — 안정화 후 환경변수 채우면 재활성
+
+### 🐛 /api/stats/visits 500 — StatsMapper resultType int → long (v0.1.54)
+- StatsMapper interface는 `long` 반환인데 XML resultType이 `int` → Integer를 long에 cast 실패
+- ClassCastException: Integer → Long. resultType만 long으로 교정
+
+### 🐛 NaverMap 인증 파라미터 ncpClientId → ncpKeyId (v0.1.53)
+- NCLOUD 신 정책: `ncpKeyId` 사용 (옛 `ncpClientId`는 NAVER Developers용)
+- 인증 200/Failed의 진짜 원인 — 도메인 등록은 정확했으나 파라미터 이름 차이로 키 인식 실패
+- 새 NCLOUD Maps Client ID(`fg01bipxbo`)로 prod 재빌드
+- 참고: https://github.com/navermaps/maps.js.ncp/blob/master/index.html
+
+### 🗺️ #363 메인 지도 SDK 국내(네이버)/해외(구글) 분기 (v0.1.52)
+- MapView를 dispatcher로 전환: 좌표가 KR bbox + NAVER_MAP_CLIENT_ID 설정 시 NaverMapView, 그 외 GoogleMapView
+- NaverMapView 신규 (네이버 v3 직접 wrapper, Supercluster 재사용, 마커/클러스터/flyTo)
+- GoogleMapView 신규 (기존 MapView 내용 rename)
+- MapView.types.ts 공용 (MapBounds/FlyTo/MapViewProps + isKoreaCoord)
+- Dockerfile + deploy.sh: NEXT_PUBLIC_NAVER_MAP_CLIENT_ID build-arg 추가
+- 키 미설정 시 GoogleMap fallback (회귀 0)
+- 설계서: docs/design/363-map-sdk-branch/README.md
+- Refs: #363
+
+### 🗺️ 식당 상세 지도 링크 국내/해외 분기 (v0.1.51)
+- 좌표 기반 한국 판정 (WGS84 KR bbox 33~38.7°N, 124~132°E)
+- 국내: 네이버 지도 primary + Google Maps 보조 (네이버 URL은 신 도메인 /p/search/)
+- 해외: Google Maps 단독
+- 좌표 없으면 region 첫 토큰 fallback (구 데이터 호환)
+- frontend-only 배포
+
 ## 2026-06-15
 
+### 🐛 캐치테이블 URL 패턴 수정 (v0.1.50)
+- 실제 catchtable URL은 `app.catchtable.co.kr/ct/shop/...` 형식 (옛 `/shop/`, `/dining/`은 매칭 실패)
+- 첫 회차(v0.1.49) 캐치테이블 벌크 결과 1044건 전부 미발견(매핑 0%)의 원인
+- 패턴을 `catchtable.co.kr/ct/shop/`, `catchtable.co.kr/ct/dining/`로 교정 후 NONE 해제 + 재실행
+
+### 🐛 WebSearchService HTTP timeout 추가 (v0.1.49)
+- 벌크 백필 중 특정 검색에서 무한 hang → backend executor virtual thread 점유로 후속 작업 중단 (90건 처리 후 멈춤)
+- connectTimeout=5s + request timeout=15s (Naver/DDG 둘 다)
+- 해당 식당은 HttpTimeoutException → notfound로 안전 처리
+
+### ⏱️ bulk-tabling/catchtable SSE timeout 10분 → 3시간 (v0.1.48)
+- 대량 백필(724건 ≈ 100분) 시 10분 SSE timeout으로 중간 끊김 → 3시간으로 확장
+- 백엔드 작업은 virtual thread로 별도 진행됐지만 emit() 예외로 마지막 cache.flush + complete 누락이슈 해소
+
+### 🐛 #357 후속 — tabling-url validation에 www. 호스트 허용 (v0.1.47)
+- Naver/DDG 결과가 `https://www.tabling.co.kr/...` 형태인데 #290 validation은 `tabling.co.kr/`만 허용 → 단건 매핑 PUT 거부
+- bulk-tabling SSE는 validation 없이 service.update 직접 호출이라 통과 → 단일/벌크 불일치
+- `www.tabling.co.kr` prefix도 허용 (catchtable은 이미 app/www 둘 다 허용)
+- 시연 등록: bbq 부천은하마을점 → BBQ 치킨 부천은하마을점
+
+### 🔍 #359 1단계 — google_place_id 중복 조회 API (v0.1.46)
+- GET /api/admin/restaurants/duplicates/place-id (어드민 전용)
+- 응답: 그룹별 식당 + video/review/memo 카운트 (병합 의사결정 자료)
+- 정리/병합 + UNIQUE 제약은 별도 PR (데이터 위험 분리)
+- 설계서: docs/design/359a-duplicate-place-id-view/README.md
+- Refs: #359 (조회 단계 완료, 후속 분리 유지)
+
+### 📋 #358 RestaurantUpdateDTO + @Valid 표준화 (v0.1.45)
+- dto/RestaurantUpdateDTO record 신규 (15 필드, 모두 nullable)
+- Bean Validation: @Size/@Pattern(URL or NONE)/@DecimalMin·Max/@Min·Max
+- RestaurantController.update 시그니처 Map → @Valid DTO 교체
+- toFieldMap()으로 null 제외 후 기존 Service.update 호출 (회귀 0)
+- #332 ALLOWED_UPDATE_FIELDS Set 제거 (DTO 필드 자체가 화이트리스트)
+- 설계서: docs/design/358-restaurant-update-dto/README.md
+- Refs: #358 (close)
+
+### 🔎 #357 DDG → Naver Search 정식 API + DDG 폴백 (v0.1.44)
+- WebSearchService 신규 (Naver webkr.json 우선, 키 미설정/실패 시 DDG 폴백)
+- RestaurantController.searchTabling/searchCatchtable 내부 호출 교체, DDG 인라인 80줄 제거
+- application.yml: app.naver.client-id/secret (NAVER_CLIENT_ID/SECRET 환경변수)
+- k8s/secrets.yaml.template에 NAVER_CLIENT_ID/SECRET 항목 추가
+- 미사용 import 정리 (HttpClient/URI/URLEncoder/Pattern 등 RestaurantController에서)
+- 설계서: docs/design/357-web-search-api/README.md
+- Refs: #357 (close)
+
+### 🎯 #356 영상-식당 관련도 LLM 평가 (v0.1.43)
+- DB: video_restaurants 컬럼 추가 (relevance/relevance_reason/relevance_evaluated_at) + idx_vr_relevance
+- VideoRelevanceService 신규 (#322 RestaurantVerifyService 패턴 모방, @Async verifyAsync/verify/verifyAll)
+- PipelineService.processExtract — linkVideoRestaurant 후 verifyAsync(linkId) 자동 트리거
+- GET /api/restaurants/{id}/videos: 기본 strong/unknown만 응답 (안전 기본값), ?include_weak=true 시 모두
+- AdminVideoRelevanceController 신규 (pending/all/{id}/evaluate/{id} PATCH)
+- 응답 매핑: relevance, relevance_reason 필드 동봉
+- 기존 1244 링크는 'unknown' 시작 → 어드민 백필로 점진 평가
+- 설계서: docs/design/356-video-relevance-llm/README.md
+- Refs: #356 (close)
+
+### 🧹 #351 admin SSE 6곳 consumeSseStream 통일 (v0.1.42)
+- VideosPanel 4곳(bulkTranscript/Extract, rebuildVectors, remapCuisine, remapFoods)
+- RestaurantsPanel 2곳(bulkTabling, bulkCatchtable)
+- response.body?.getReader 직접 호출 0건 (lib/admin-utils.ts의 consumeSseStream 활용)
+- 149줄 삭제 → 74줄 압축, npm test 13/13 통과
+- Refs: #351 (close)
+
+### 🧪 #343 Jest+RTL 인프라 + ARIA Tabs + remotePatterns (v0.1.40)
+- Jest 30 + jest-environment-jsdom + RTL + jest-dom matchers 도입
+- next/jest 자동 SWC 통합, jest.config.ts + jest.setup.ts (setupFilesAfterEnv)
+- npm scripts: test, test:watch
+- 샘플 테스트 3개 13/13 통과: i18n/config(5), Stars(5), admin-utils(4)
+- MyReviewsList: role=tablist/tab/aria-selected/aria-controls/tabIndex + tabpanel
+- next.config.ts remotePatterns: Google avatar + YouTube thumbnail/avatar
+- 후속: 전체 컴포넌트 테스트 확장, 백엔드 JUnit, E2E(Playwright), CI 통합
+- 설계서: docs/design/343-frontend-test-infra/README.md
+- Refs: #343 (close)
+
+### 🔤 #348 isNameSimilar 한국어 자모 + Sørensen-Dice (v0.1.38)
+- HangulSimilarity 유틸 신규 (Unicode NFD 분해 + bigram Sørensen-Dice)
+- RestaurantController.isNameSimilar 교체, 임계값 0.45
+- 짧은 한국어 이름 매칭 정확도 향상 (예: "스타벅스 강남" vs "스타벅스 강남점")
+- 후속 분리: #357(DDG→정식 API), #358(DTO+@Valid), #359(UNIQUE+데이터 정리)
+- 설계서: docs/design/348-name-similarity/README.md
+- Refs: #348 (close)
+
+### 🌐 #352 i18n 뼈대 ko/en/ja/es (v0.1.37)
+- next-intl 5.x 도입
+- src/i18n/{config,LocaleProvider} + src/messages/{ko,en,ja,es}.json (30 키)
+- LanguageSwitcher 컴포넌트 (헤더, ARIA listbox, 44px, 국기+네이티브명)
+- localStorage tasteby_locale + 브라우저 언어 감지 + ko fallback
+- 설계서: docs/design/352-i18n-skeleton/README.md
+- 미적용: URL 라우팅 i18n, SEO meta, 사용자 콘텐츠 번역, 어드민(한국어 유지)
+- Refs: #352 (close)
+
+### 🧹 #329 admin/page.tsx 분리 (v0.1.35→v0.1.36 운영 반영)
+- page.tsx 2817 → 107 LOC (탭 라우팅 + 헤더만)
+- _panels/{Channels,Videos,Restaurants,Users,Daemon}Panel.tsx 5개 분리
+- localStorage.getItem 10곳 → getAdminToken() (admin-utils.ts)
+- SSE 통일은 후속 #351 분리
+- 설계서: docs/design/329-admin-split/README.md
+- Refs: #329 (close)
+
+### ⚡ #331 VectorService batchUpdate (v0.1.34)
+- saveRestaurantVectors: N+1 단건 INSERT → 단일 jdbc.batchUpdate(SqlParameterSource[])
+- UUID 인라인 변환 제거 → IdGenerator.newId() 공통화
+- 현재 N=1이지만 chunk 분할 도입 시 효과 본격화
+- 설계서: docs/design/331-vector-batch-insert/README.md
+- Refs: #331 (close)
+
+### ⚡ #326 parseJson 단일 패스 (v0.1.33)
+- OciGenAiService.parseJson 잘린 배열 복구를 brace depth counter 단일 패스로 교체
+- 이전 O(N²) + Jackson 예외 양산 → O(N) + 명시적 에러 경로
+- 문자열/escape 처리 정확
+- 설계서: docs/design/326-parsejson-optimization/README.md
+- Refs: #326 (close)
+
+### 🛡️ #332 Restaurant PUT 화이트리스트 명시 (v0.1.32)
+- ALLOWED_UPDATE_FIELDS set으로 PUT /api/restaurants/{id} body 필터
+- 허용 외 키 silent drop + DEBUG 로그
+- sanitized.isEmpty()면 200 + no-op
+- 후속 분리: #348 (DDG → 정식 API, isNameSimilar 한국어, DTO 표준화)
+- Refs: #332 (close)
+
+### 🛡️ #337 통계 봇 필터 + 레이트리밋 (v0.1.31)
+- BotDetector: UA 정규식 (bot|crawler|spider|slurp|scrap|fetch|monitor|preview|lighthouse)
+- RateLimitService: Redis SET NX EX(60s) 패턴, fail-open (의존성 최소화)
+- StatsController.recordVisit: X-Forwarded-For 우선 IP + 봇/IP 가드
+- 응답: {ok, counted:bool} — 차단도 200 (사용자 페이지 지장 X)
+- application.yml: app.rate-limit.visit-window-seconds (기본 60)
+- 운영 검증: Googlebot/Mozilla/즉시 재호출 인수조건 모두 충족
+- 설계서: docs/design/337-stats-bot-ratelimit/README.md
+- Refs: #337 (close)
+
+### 🔒 #335 데몬 분산 락 ShedLock+Redis (v0.1.30)
+- shedlock-spring 5.16.0 + shedlock-provider-redis-spring
+- @EnableSchedulerLock(defaultLockAtMostFor=PT15M)
+- DaemonScheduler.run: @SchedulerLock(name="daemon-runner", lockAtMostFor=PT15M, lockAtLeastFor=PT30S)
+- ShedLockConfig: RedisLockProvider Bean (in-cluster Redis 재사용)
+- 멀티 파드(RollingUpdate) + dev/prod ATP 공유 환경에서 데몬 중복 실행 차단
+- 설계서: docs/design/335-daemon-distributed-lock/README.md
+- Refs: #335 (close)
+
+### 💾 #336 캐시 SCAN/UNLINK + 자동 복구 + 에러 메트릭 (v0.1.29)
+- CacheService.flush: redis.keys() 블로킹 → SCAN cursor + UNLINK 논블로킹 (500 batch)
+- @Scheduled(30s) checkHealth: Redis ping → disabled 자동 토글 (재기동 시 자동 복구)
+- AtomicLong errorCount + volatile lastError + 로그 throttle (n==1 또는 n%100==0)
+- GET /api/admin/cache/stats: disabled/errorCount/lastError 노출 (admin only)
+- 설계서: docs/design/336-cache-scan-recovery/README.md
+- Refs: #336 (close)
+
+### 🔧 P5-2 작은 후속 (v0.1.26)
+- #338: /api/version 신규 (HealthController + permitAll), application.yml app.build.{version,commit} env 주입 준비
+- #320: findRegionFromCoords 거리 보정 (유클리드 → cos(lat) 가중치)
+- #340: MapView 클러스터/마커/범례에 role/aria-label
+- #333: ChannelController cache.flush() → cache.del("channels") (다른 모듈 캐시 보존)
+- Refs: #338 #320 #340 #333 (close)
+
+### 🧹 P5-1 작은 후속 묶음 (v0.1.24)
+- #325: ThreadLocalRandom 통일, rebuildVectors not_implemented 이벤트, getTranscript JavaDoc 명세
+- #319: buildSearchQuery 헬퍼 + fn-doc(BottomSheet snap 정책)
+- #344: --z-bottom-sheet/--z-filter-sheet/--z-modal CSS 변수 + LoginMenu zIndex 99999 → var(--z-modal)
+- Refs: #319 #325 #344 (close)
+
+### ⭐ P4-4 별점 공통화 + 로그인 모달 접근성 (v0.1.23)
+- #281: 공통 Stars 컴포넌트 (0.5단위 절반 채우기), StarSelector role=radiogroup + 44px + 반쪽 별 ⯨, try/catch + alert
+- #283: LoginMenu에 useEscapeKey/useFocusTrap/useBodyScrollLock 훅 적용, role=dialog/aria-modal/aria-labelledby, onError 인라인 alert
+- MyReviewsList: Math.round → Stars (0.5단위 정확 렌더)
+- 후속 분리: #343(next/image, ARIA Tabs, 테스트), #344(z-index 토큰, i18n)
+- Refs: #281 #283 (close)
+
+### 🔐 P4-3 인증 메시지 + 지도 접근성 (v0.1.22)
+- #266: Google verifier 실패 메시지 고정 + log.warn (정보 누출 차단)
+- #278: boundsTimerRef cleanup, '내 위치' 44px + aria-label, dead code 제거
+- #277: 결함 모두 후속(#338) — deep health/version/테스트는 별도
+- 후속 분리: #338(deep health), #339(브랜드 토큰화/마커 ARIA), #340(다중 audience)
+- Refs: #266 #277 #278 (close)
+
+### ⚙️ P4-2 데몬/캐시/통계 결함 (v0.1.21)
+- #275: updateConfig 가드(1+ 정수), Scheduler try-finally updateLastX, GET config admin-only
+- #276: ping try-with-resources + ConnectionFactory null 가드, makeKey null 가드
+- #274: SiteVisitStats int → long, recordVisit DataIntegrityViolationException 1회 재시도
+- 후속 분리: #335 (분산락), #336 (SCAN/자동복구), #337 (봇/레이트리밋)
+- Refs: #275 #276 #274 (close)
+
+### 🧱 P4-1 백엔드 CRUD 결함 (v0.1.20)
+- #294: MemoService/ReviewService 동시성 DuplicateKeyException 가드, rating 0~5 검증, getAvgRating NVL
+- #295: 유니크 충돌 typed exception, channel_id "UC..." 형식 명시 분기, findByChannelId 컬럼 보완, body null 가드
+- #290: @PreDestroy executor shutdown, 캐시 silent → log.warn + cache.del, tabling/catchtable URL 스킴 화이트리스트
+- 후속 분리: #332(#290), #333(#295), #334(#294) — DTO/DDG/세분화/테스트
+- Refs: #290 #294 #295 (close)
+
+### 🔍 #293 검색/벡터 결함 7건 (v0.1.19)
+- SearchController: q 빈값 400 가드 (`%%` 응답 폭발 차단)
+- SearchService: LIKE 와일드카드 escape (%, _, \), hybrid 모드에서 sem 결과에도 채널 부착
+- SearchService: ObjectMapper/TypeReference static 재사용, 알 수 없는 mode warn 로그
+- SearchService: maxDistance를 @Value("${app.search.max-distance:0.57}") 외부화 (env SEARCH_MAX_DISTANCE)
+- SearchMapper.xml: LIKE 절에 ESCAPE '\' 추가
+- VectorService: embeddings null/empty 가드 (NPE 차단)
+- 후속 분리: #331 (batch insert + 테스트)
+- Refs: #293 (close)
+
+### 🛠 #304+#323 어드민 LLM 검증 UI + 공통 유틸 (v0.1.18)
+- 신규 frontend/src/lib/admin-utils.ts:
+  - getAdminToken / authHeaders / consumeSseStream
+- api.ts: Restaurant 타입에 hidden/hidden_reason/verified_at + verify/setRestaurantHidden API 4개
+- RestaurantsPanel:
+  - 헤더: "미검증 N건 + LLM 검증" 버튼
+  - 테이블: 검증 컬럼 (숨김/OK/미검증 배지 + 클릭으로 토글)
+- colSpan 7로 수정
+- 후속 분리: #329 (admin 전체 파일 분리 + localStorage/SSE 11+곳 통일)
+- Refs: #304 #323 #322 (close)
+
+### 🔧 #291+#292 백엔드 결함 일괄 수정 (v0.1.17)
+- ExtractorService: transcript null/blank 가드 (NPE 방지)
+- PipelineService.processExtract: 진입 시 status='processing' 명시 전이 (SSE/사용자 가시성)
+- PipelineService: geocode 실패 시 좌표/place_id/주소 컬럼을 data에 put하지 않아 upsert COALESCE 보존 의도 명확화
+- GeocodingService.parseRegionFromAddress: 빈 토큰을 region 문자열에서 제거 ('한국||구' 깨짐 방지)
+- VideoService.saveVideosBatch: @Transactional 추가 → batch insert 원자성
+- .gitignore: backend-java/cookies.txt 및 **/cookies.txt
+- 후속 분리: #325 (#291 잔여 MINOR), #326 (parseJson 최적화 + #292 MINOR)
+- Refs: #291 #292 (close)
+
 ### 🧹 #322 LLM 검증으로 잘못된/프랜차이즈 식당 자동 숨김 (v0.1.16)
 - DB 마이그레이션: restaurants에 hidden(NUMBER(1)), hidden_reason(VARCHAR2(120)), verified_at(TIMESTAMP) + idx_restaurants_hidden
 - 도메인/Mapper/Service 확장: includeHidden 옵션, updateVerification, findUnverified 등

backend-java/build.gradle

@@ -28,6 +28,12 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-data-redis'
     implementation 'org.springframework.boot:spring-boot-starter-validation'
 
+    // #335 — 분산 락 (RollingUpdate 시 멀티 파드 공존 중 데몬 중복 실행 차단)
+    implementation 'net.javacrumbs.shedlock:shedlock-spring:5.16.0'
+    implementation 'net.javacrumbs.shedlock:shedlock-provider-redis-spring:5.16.0'
+
+    // #337 — IP 레이트리밋은 Redis SET NX EX 패턴으로 자체 구현 (기존 spring-data-redis 활용)
+
     // Oracle JDBC + Security (Wallet support for Oracle ADB)
     implementation 'com.oracle.database.jdbc:ojdbc11:23.7.0.25.01'
     implementation 'com.oracle.database.security:oraclepki:23.7.0.25.01'

backend-java/src/main/java/com/tasteby/TastebyApplication.java

@@ -1,5 +1,6 @@
 package com.tasteby;
 
+import net.javacrumbs.shedlock.spring.annotation.EnableSchedulerLock;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.scheduling.annotation.EnableAsync;
@@ -8,6 +9,8 @@ import org.springframework.scheduling.annotation.EnableScheduling;
 @SpringBootApplication
 @EnableAsync
 @EnableScheduling
+// #335 — defaultLockAtMostFor: 어떤 작업이 lockAtMostFor 명시 안 해도 보호 (안전 마진)
+@EnableSchedulerLock(defaultLockAtMostFor = "PT15M")
 public class TastebyApplication {
     public static void main(String[] args) {
         SpringApplication.run(TastebyApplication.class, args);

backend-java/src/main/java/com/tasteby/config/SecurityConfig.java

@@ -30,13 +30,14 @@ public class SecurityConfig {
             .authorizeHttpRequests(auth -> auth
                 // Public endpoints
                 .requestMatchers("/api/health").permitAll()
+                .requestMatchers("/api/version").permitAll()   // #338 — 빌드 정보 공개
                 .requestMatchers("/api/auth/**").permitAll()
                 .requestMatchers(HttpMethod.GET, "/api/restaurants/**").permitAll()
                 .requestMatchers(HttpMethod.GET, "/api/channels").permitAll()
                 .requestMatchers(HttpMethod.GET, "/api/search").permitAll()
                 .requestMatchers(HttpMethod.GET, "/api/restaurants/*/reviews").permitAll()
                 .requestMatchers("/api/stats/**").permitAll()
-                .requestMatchers(HttpMethod.GET, "/api/daemon/config").permitAll()
+                // #275 — /api/daemon/config는 admin-only로 변경 (이전 permitAll 제거)
                 // Everything else requires authentication (controller-level admin checks)
                 .anyRequest().authenticated()
             )

backend-java/src/main/java/com/tasteby/config/ShedLockConfig.java

@@ -0,0 +1,22 @@
+package com.tasteby.config;
+
+import net.javacrumbs.shedlock.core.LockProvider;
+import net.javacrumbs.shedlock.provider.redis.spring.RedisLockProvider;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+
+/**
+ * #335 — ShedLock LockProvider (Redis 기반).
+ *
+ * 데몬 스케줄러가 다중 파드 환경에서 한 번에 하나만 실행되도록 보장.
+ * key prefix는 ShedLock 기본 ("lock:")을 사용 → Redis 키는 `lock:daemon-runner`.
+ */
+@Configuration
+public class ShedLockConfig {
+
+    @Bean
+    public LockProvider lockProvider(RedisConnectionFactory connectionFactory) {
+        return new RedisLockProvider(connectionFactory);
+    }
+}

backend-java/src/main/java/com/tasteby/controller/AdminCacheController.java

@@ -22,4 +22,14 @@ public class AdminCacheController {
         cacheService.flush();
         return Map.of("ok", true);
     }
+
+    /**
+     * #336 — 캐시 상태 가시화: disabled / errorCount / lastError.
+     * 외부 모니터링 도구 도입 전 운영자가 어드민에서 확인 가능.
+     */
+    @GetMapping("/cache/stats")
+    public CacheService.CacheStats cacheStats() {
+        AuthUtil.requireAdmin();
+        return cacheService.getStats();
+    }
 }

backend-java/src/main/java/com/tasteby/controller/AdminRestaurantController.java

@@ -62,6 +62,15 @@ public class AdminRestaurantController {
         return Map.of("success", true, "id", id);
     }
 
+    // #359 1단계 — google_place_id 중복 조회 (정리/UNIQUE는 후속).
+    @GetMapping("/duplicates/place-id")
+    public Map<String, Object> duplicatePlaceIds() {
+        var admin = AuthUtil.requireAdmin();
+        var groups = restaurantService.findDuplicatePlaceIdGroups();
+        log.info("[ADMIN] {} duplicate place_id groups: {}", admin.getSubject(), groups.size());
+        return Map.of("groups", groups, "group_count", groups.size());
+    }
+
     /**
      * 어드민용 hidden 토글.
      */

backend-java/src/main/java/com/tasteby/controller/AdminVideoRelevanceController.java

@@ -0,0 +1,70 @@
+package com.tasteby.controller;
+
+import com.tasteby.security.AuthUtil;
+import com.tasteby.service.RestaurantService;
+import com.tasteby.service.VideoRelevanceService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * #356 영상-식당 관련도 LLM 평가 어드민 API.
+ * - 미평가 카운트 / 일괄 백필 / 단건 재평가 / 수동 토글
+ */
+@RestController
+@RequestMapping("/api/admin/video-relevance")
+public class AdminVideoRelevanceController {
+
+    private static final Logger log = LoggerFactory.getLogger(AdminVideoRelevanceController.class);
+    private static final Set<String> VALID = Set.of("strong", "weak", "incidental", "unknown");
+
+    private final RestaurantService restaurantService;
+    private final VideoRelevanceService relevanceService;
+
+    public AdminVideoRelevanceController(RestaurantService restaurantService, VideoRelevanceService relevanceService) {
+        this.restaurantService = restaurantService;
+        this.relevanceService = relevanceService;
+    }
+
+    @GetMapping("/pending")
+    public Map<String, Object> pendingCount() {
+        var admin = AuthUtil.requireAdmin();
+        int n = restaurantService.countUnevaluatedLinks();
+        log.info("[ADMIN] {} video-relevance pending: {}", admin.getSubject(), n);
+        return Map.of("pending", n);
+    }
+
+    @PostMapping("/all")
+    public Map<String, Object> verifyAll(@RequestParam(defaultValue = "10") int batchSize) {
+        var admin = AuthUtil.requireAdmin();
+        int pending = restaurantService.countUnevaluatedLinks();
+        log.info("[ADMIN] {} triggered video-relevance verifyAllAsync (batchSize={}, pending={})", admin.getSubject(), batchSize, pending);
+        // 비동기 트리거 — HTTP request는 즉시 응답. 진행은 /pending 폴링으로 확인.
+        relevanceService.verifyAllAsync(batchSize);
+        return Map.of("started", true, "pending", pending);
+    }
+
+    @PostMapping("/{linkId}/evaluate")
+    public Map<String, Object> evaluateOne(@PathVariable String linkId) {
+        var admin = AuthUtil.requireAdmin();
+        log.info("[ADMIN] {} video-relevance evaluate({})", admin.getSubject(), linkId);
+        relevanceService.verify(linkId);
+        return Map.of("success", true, "linkId", linkId);
+    }
+
+    @PatchMapping("/{linkId}")
+    public Map<String, Object> setRelevance(@PathVariable String linkId, @RequestBody Map<String, Object> body) {
+        var admin = AuthUtil.requireAdmin();
+        Object relObj = body.get("relevance");
+        if (!(relObj instanceof String relevance) || !VALID.contains(relevance)) {
+            return Map.of("success", false, "error", "relevance must be one of strong|weak|incidental|unknown");
+        }
+        String reason = body.get("reason") instanceof String s ? s : "manual";
+        restaurantService.updateLinkRelevance(linkId, relevance, reason);
+        log.info("[ADMIN] {} manual relevance={} for link {}", admin.getSubject(), relevance, linkId);
+        return Map.of("success", true, "linkId", linkId, "relevance", relevance);
+    }
+}

backend-java/src/main/java/com/tasteby/controller/ChannelController.java

@@ -7,6 +7,7 @@ import com.tasteby.security.AuthUtil;
 import com.tasteby.service.CacheService;
 import com.tasteby.service.ChannelService;
 import com.tasteby.service.YouTubeService;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.server.ResponseStatusException;
@@ -52,16 +53,22 @@ public class ChannelController {
         String channelId = body.get("channel_id");
         String channelName = body.get("channel_name");
         String titleFilter = body.get("title_filter");
+        // #295 — body 필수값 가드 (NOT NULL 컬럼에 빈 값 들어가 500 나는 것 방지)
+        if (channelId == null || channelId.isBlank()) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "channel_id는 필수입니다");
+        }
+        if (channelName == null || channelName.isBlank()) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "channel_name은 필수입니다");
+        }
         try {
             String id = channelService.create(channelId, channelName, titleFilter);
-            cache.flush();
+            // #333 — 전체 flush 대신 channels 키만 evict (다른 모듈 캐시 보존)
+            cache.del(cache.makeKey("channels"));
             return Map.of("id", id, "channel_id", channelId);
-        } catch (Exception e) {
+        } catch (DataIntegrityViolationException e) {
-            if (e.getMessage() != null && e.getMessage().toUpperCase().contains("UQ_CHANNELS_CID")) {
+            // #295 — 유니크 충돌을 메시지 문자열 매칭 대신 typed 예외로 감지 (제약명 변경에도 견고).
             throw new ResponseStatusException(HttpStatus.CONFLICT, "Channel already exists");
         }
-            throw e;
-        }
     }
 
     @PostMapping("/{channelId}/scan")

backend-java/src/main/java/com/tasteby/controller/DaemonController.java

@@ -19,6 +19,8 @@ public class DaemonController {
 
     @GetMapping("/config")
     public DaemonConfig getConfig() {
+        // #275 — 데몬 운영 설정은 admin 전용 (이전: 공개 노출 — 정보 누출 위험)
+        AuthUtil.requireAdmin();
         DaemonConfig config = daemonConfigService.getConfig();
         return config != null ? config : DaemonConfig.builder().build();
     }

backend-java/src/main/java/com/tasteby/controller/HealthController.java

@@ -1,5 +1,6 @@
 package com.tasteby.controller;
 
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
 
@@ -8,8 +9,20 @@ import java.util.Map;
 @RestController
 public class HealthController {
 
+    // #338 — 배포 시 set되는 빌드 정보. 미설정 시 "dev"로 표시.
+    @Value("${app.build.version:dev}")
+    private String version;
+
+    @Value("${app.build.commit:unknown}")
+    private String commit;
+
     @GetMapping("/api/health")
     public Map<String, String> health() {
         return Map.of("status", "ok");
     }
+
+    @GetMapping("/api/version")
+    public Map<String, String> version() {
+        return Map.of("version", version, "commit", commit);
+    }
 }

backend-java/src/main/java/com/tasteby/controller/RestaurantController.java

@@ -4,9 +4,13 @@ import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.tasteby.domain.Restaurant;
 import com.tasteby.security.AuthUtil;
+import com.tasteby.dto.RestaurantUpdateDTO;
 import com.tasteby.service.CacheService;
 import com.tasteby.service.GeocodingService;
 import com.tasteby.service.RestaurantService;
+import com.tasteby.service.WebSearchService;
+import jakarta.validation.Valid;
+import jakarta.annotation.PreDestroy;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpStatus;
@@ -14,19 +18,10 @@ import org.springframework.web.bind.annotation.*;
 import org.springframework.web.server.ResponseStatusException;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 
-import java.net.URI;
-import java.net.URLDecoder;
-import java.net.URLEncoder;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
-import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadLocalRandom;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 @RestController
 @RequestMapping("/api/restaurants")
@@ -38,13 +33,21 @@ public class RestaurantController {
     private final GeocodingService geocodingService;
     private final CacheService cache;
     private final ObjectMapper objectMapper;
+    private final WebSearchService webSearch;
     private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
 
-    public RestaurantController(RestaurantService restaurantService, GeocodingService geocodingService, CacheService cache, ObjectMapper objectMapper) {
+    public RestaurantController(RestaurantService restaurantService, GeocodingService geocodingService, CacheService cache, ObjectMapper objectMapper, WebSearchService webSearch) {
         this.restaurantService = restaurantService;
         this.geocodingService = geocodingService;
         this.cache = cache;
         this.objectMapper = objectMapper;
+        this.webSearch = webSearch;
+    }
+
+    // #290 — Bean 종료 시 virtual thread executor를 정리하여 리소스 누수 방지.
+    @PreDestroy
+    public void shutdownExecutor() {
+        executor.shutdown();
     }
 
     @GetMapping
@@ -61,7 +64,7 @@ public class RestaurantController {
         if (cached != null) {
             try {
                 return objectMapper.readValue(cached, new TypeReference<List<Restaurant>>() {});
-            } catch (Exception ignored) {}
+            } catch (Exception e) { log.warn("Cache deserialize failed, evicting: {}", e.getMessage()); cache.del(key); }
         }
         var result = restaurantService.findAll(limit, offset, cuisine, region, channel);
         cache.set(key, result);
@@ -75,7 +78,7 @@ public class RestaurantController {
         if (cached != null) {
             try {
                 return objectMapper.readValue(cached, Restaurant.class);
-            } catch (Exception ignored) {}
+            } catch (Exception e) { log.warn("Cache deserialize failed, evicting: {}", e.getMessage()); cache.del(key); }
         }
         var r = restaurantService.findById(id);
         if (r == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Restaurant not found");
@@ -84,14 +87,17 @@ public class RestaurantController {
     }
 
     @PutMapping("/{id}")
-    public Map<String, Object> update(@PathVariable String id, @RequestBody Map<String, Object> body) {
+    public Map<String, Object> update(@PathVariable String id, @Valid @RequestBody RestaurantUpdateDTO dto) {
         AuthUtil.requireAdmin();
         var r = restaurantService.findById(id);
         if (r == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Restaurant not found");
 
+        // #358 — DTO → Map (null 제외). 화이트리스트는 DTO 필드 자체로 표현.
+        Map<String, Object> sanitized = dto.toFieldMap();
+
         // Re-geocode if name or address changed
-        String newName = (String) body.get("name");
+        String newName = (String) sanitized.get("name");
-        String newAddress = (String) body.get("address");
+        String newAddress = (String) sanitized.get("address");
         boolean nameChanged = newName != null && !newName.equals(r.getName());
         boolean addressChanged = newAddress != null && !newAddress.equals(r.getAddress());
         if (nameChanged || addressChanged) {
@@ -99,26 +105,30 @@ public class RestaurantController {
             String geoAddr = newAddress != null ? newAddress : r.getAddress();
             var geo = geocodingService.geocodeRestaurant(geoName, geoAddr);
             if (geo != null) {
-                body.put("latitude", geo.get("latitude"));
+                sanitized.put("latitude", geo.get("latitude"));
-                body.put("longitude", geo.get("longitude"));
+                sanitized.put("longitude", geo.get("longitude"));
-                body.put("google_place_id", geo.get("google_place_id"));
+                sanitized.put("google_place_id", geo.get("google_place_id"));
                 if (geo.containsKey("formatted_address")) {
-                    body.put("address", geo.get("formatted_address"));
+                    sanitized.put("address", geo.get("formatted_address"));
                 }
-                if (geo.containsKey("rating")) body.put("rating", geo.get("rating"));
+                if (geo.containsKey("rating")) sanitized.put("rating", geo.get("rating"));
-                if (geo.containsKey("rating_count")) body.put("rating_count", geo.get("rating_count"));
+                if (geo.containsKey("rating_count")) sanitized.put("rating_count", geo.get("rating_count"));
-                if (geo.containsKey("phone")) body.put("phone", geo.get("phone"));
+                if (geo.containsKey("phone")) sanitized.put("phone", geo.get("phone"));
-                if (geo.containsKey("business_status")) body.put("business_status", geo.get("business_status"));
+                if (geo.containsKey("business_status")) sanitized.put("business_status", geo.get("business_status"));
 
-                // formatted_address에서 region 파싱 (예: "대한민국 서울특별시 강남구 ..." → "한국|서울|강남구")
                 String addr = (String) geo.get("formatted_address");
                 if (addr != null) {
-                    body.put("region", GeocodingService.parseRegionFromAddress(addr));
+                    sanitized.put("region", GeocodingService.parseRegionFromAddress(addr));
                 }
             }
         }
 
-        restaurantService.update(id, body);
+        if (sanitized.isEmpty()) {
+            // 허용 키가 하나도 없으면 no-op
+            return Map.of("ok", true, "restaurant", r);
+        }
+
+        restaurantService.update(id, sanitized);
         cache.flush();
         var updated = restaurantService.findById(id);
         return Map.of("ok", true, "restaurant", updated);
@@ -165,7 +175,7 @@ public class RestaurantController {
     @PostMapping("/bulk-tabling")
     public SseEmitter bulkTabling() {
         AuthUtil.requireAdmin();
-        SseEmitter emitter = new SseEmitter(600_000L);
+        SseEmitter emitter = new SseEmitter(10_800_000L); // 3h — 대량 백필 대응
 
         executor.execute(() -> {
             try {
@@ -241,6 +251,13 @@ public class RestaurantController {
         var r = restaurantService.findById(id);
         if (r == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND);
         String url = body.get("tabling_url");
+        // #290 — javascript:/외부 악성 URL 차단. 빈 문자열은 매핑 해제로 허용.
+        // Naver/DDG 결과가 www.tabling.co.kr 형태로도 옴.
+        if (url != null && !url.isBlank()
+                && !url.startsWith("https://tabling.co.kr/")
+                && !url.startsWith("https://www.tabling.co.kr/")) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "테이블링 URL은 https://(www.)tabling.co.kr/ 만 허용");
+        }
         restaurantService.update(id, Map.of("tabling_url", url != null ? url : ""));
         cache.flush();
         return Map.of("ok", true);
@@ -292,7 +309,7 @@ public class RestaurantController {
     @PostMapping("/bulk-catchtable")
     public SseEmitter bulkCatchtable() {
         AuthUtil.requireAdmin();
-        SseEmitter emitter = new SseEmitter(600_000L);
+        SseEmitter emitter = new SseEmitter(10_800_000L); // 3h — 대량 백필 대응
 
         executor.execute(() -> {
             try {
@@ -367,116 +384,49 @@ public class RestaurantController {
         var r = restaurantService.findById(id);
         if (r == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND);
         String url = body.get("catchtable_url");
+        // #290 — javascript:/외부 악성 URL 차단. 빈 문자열은 매핑 해제로 허용.
+        if (url != null && !url.isBlank()
+                && !url.startsWith("https://app.catchtable.co.kr/")
+                && !url.startsWith("https://www.catchtable.co.kr/")) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "캐치테이블 URL은 https://(app|www).catchtable.co.kr/ 만 허용");
+        }
         restaurantService.update(id, Map.of("catchtable_url", url != null ? url : ""));
         cache.flush();
         return Map.of("ok", true);
     }
 
     @GetMapping("/{id}/videos")
-    public List<Map<String, Object>> videos(@PathVariable String id) {
+    public List<Map<String, Object>> videos(
-        String key = cache.makeKey("restaurant_videos", id);
+            @PathVariable String id,
+            @RequestParam(name = "include_weak", defaultValue = "false") boolean includeWeak) {
+        String key = cache.makeKey("restaurant_videos", id, includeWeak ? "all" : "strong");
         String cached = cache.getRaw(key);
         if (cached != null) {
             try {
                 return objectMapper.readValue(cached, new TypeReference<List<Map<String, Object>>>() {});
-            } catch (Exception ignored) {}
+            } catch (Exception e) { log.warn("Cache deserialize failed, evicting: {}", e.getMessage()); cache.del(key); }
         }
         var r = restaurantService.findById(id);
         if (r == null) throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Restaurant not found");
-        var result = restaurantService.findVideoLinks(id);
+        var result = restaurantService.findVideoLinks(id, includeWeak);
         cache.set(key, result);
         return result;
     }
 
-    // ─── DuckDuckGo HTML search helpers ─────────────────────────────────
+    // ─── 예약 사이트 URL 검색 (#357 WebSearchService: Naver primary + DDG fallback) ───
 
-    private static final HttpClient httpClient = HttpClient.newBuilder()
+    private List<Map<String, Object>> searchTabling(String restaurantName) {
-            .followRedirects(HttpClient.Redirect.NORMAL)
+        return webSearch.search(
-            .build();
-
-    private static final Pattern DDG_RESULT_PATTERN = Pattern.compile(
-            "<a[^>]+class=\"result__a\"[^>]+href=\"([^\"]+)\"[^>]*>(.*?)</a>",
-            Pattern.DOTALL
-    );
-
-    /**
-     * DuckDuckGo HTML 검색을 통해 특정 사이트의 URL을 찾는다.
-     * html.duckduckgo.com은 서버사이드 렌더링이라 봇 판정 없이 HTTP 요청만으로 결과를 파싱할 수 있다.
-     */
-    private List<Map<String, Object>> searchDuckDuckGo(String query, String... urlPatterns) throws Exception {
-        String encoded = URLEncoder.encode(query, StandardCharsets.UTF_8);
-        String searchUrl = "https://html.duckduckgo.com/html/?q=" + encoded;
-        log.info("[DDG] Searching: {}", query);
-
-        HttpRequest request = HttpRequest.newBuilder()
-                .uri(URI.create(searchUrl))
-                .header("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36")
-                .header("Accept", "text/html,application/xhtml+xml")
-                .header("Accept-Language", "ko-KR,ko;q=0.9")
-                .GET()
-                .build();
-
-        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
-        String html = response.body();
-
-        List<Map<String, Object>> results = new ArrayList<>();
-        Set<String> seen = new HashSet<>();
-        Matcher matcher = DDG_RESULT_PATTERN.matcher(html);
-
-        while (matcher.find() && results.size() < 5) {
-            String href = matcher.group(1);
-            String title = matcher.group(2).replaceAll("<[^>]+>", "").trim();
-
-            // DDG 링크에서 실제 URL 추출 (uddg 파라미터)
-            String actualUrl = extractDdgUrl(href);
-            if (actualUrl == null) continue;
-
-            boolean matches = false;
-            for (String pattern : urlPatterns) {
-                if (actualUrl.contains(pattern)) {
-                    matches = true;
-                    break;
-                }
-            }
-            if (matches && !seen.contains(actualUrl)) {
-                seen.add(actualUrl);
-                results.add(Map.of("title", title, "url", actualUrl));
-            }
-        }
-
-        log.info("[DDG] Found {} results for '{}'", results.size(), query);
-        return results;
-    }
-
-    /** DDG 리다이렉트 URL에서 실제 URL 추출 */
-    private String extractDdgUrl(String ddgHref) {
-        try {
-            // //duckduckgo.com/l/?uddg=ENCODED_URL&rut=...
-            if (ddgHref.contains("uddg=")) {
-                String uddgParam = ddgHref.substring(ddgHref.indexOf("uddg=") + 5);
-                int ampIdx = uddgParam.indexOf('&');
-                if (ampIdx > 0) uddgParam = uddgParam.substring(0, ampIdx);
-                return URLDecoder.decode(uddgParam, StandardCharsets.UTF_8);
-            }
-            // 직접 URL인 경우
-            if (ddgHref.startsWith("http")) return ddgHref;
-        } catch (Exception e) {
-            log.debug("[DDG] Failed to extract URL from: {}", ddgHref);
-        }
-        return null;
-    }
-
-    private List<Map<String, Object>> searchTabling(String restaurantName) throws Exception {
-        return searchDuckDuckGo(
                 "site:tabling.co.kr " + restaurantName,
                 "tabling.co.kr/restaurant/", "tabling.co.kr/place/"
         );
     }
 
-    private List<Map<String, Object>> searchCatchtable(String restaurantName) throws Exception {
+    private List<Map<String, Object>> searchCatchtable(String restaurantName) {
-        return searchDuckDuckGo(
+        // 실제 캐치테이블 URL은 /ct/shop/ 형식. 옛 /dining/ /shop/ 패턴은 매칭 실패.
+        return webSearch.search(
                 "site:app.catchtable.co.kr " + restaurantName,
-                "catchtable.co.kr/dining/", "catchtable.co.kr/shop/"
+                "catchtable.co.kr/ct/shop/", "catchtable.co.kr/ct/dining/"
         );
     }
 
@@ -484,25 +434,12 @@ public class RestaurantController {
      * 식당 이름과 검색 결과 제목의 유사도 검사.
      * 한쪽 이름이 다른쪽에 포함되거나, 공통 글자 비율이 40% 이상이면 유사하다고 판단.
      */
+    /**
+     * #348 — 한국어 자모 분해 + Sørensen-Dice bigram 유사도(임계값 0.45).
+     * 짧은 한국어 이름에서 이전 Jaccard-like(set 비율) 방식보다 정확.
+     */
     private boolean isNameSimilar(String restaurantName, String resultTitle) {
-        String a = normalize(restaurantName);
+        return com.tasteby.util.HangulSimilarity.similarity(restaurantName, resultTitle) >= 0.45;
-        String b = normalize(resultTitle);
-        if (a.isEmpty() || b.isEmpty()) return false;
-
-        // 포함 관계 체크
-        if (a.contains(b) || b.contains(a)) return true;
-
-        // 공통 문자 비율 (Jaccard-like)
-        var setA = a.chars().boxed().collect(java.util.stream.Collectors.toSet());
-        var setB = b.chars().boxed().collect(java.util.stream.Collectors.toSet());
-        long common = setA.stream().filter(setB::contains).count();
-        double ratio = (double) common / Math.max(setA.size(), setB.size());
-        return ratio >= 0.4;
-    }
-
-    private String normalize(String s) {
-        if (s == null) return "";
-        return s.replaceAll("[\\s·\\-_()（）\\[\\]【】]", "").toLowerCase();
     }
 
     private void emit(SseEmitter emitter, Map<String, Object> data) {

backend-java/src/main/java/com/tasteby/controller/ReviewController.java

@@ -39,7 +39,7 @@ public class ReviewController {
             @PathVariable String restaurantId,
             @RequestBody Map<String, Object> body) {
         String userId = AuthUtil.getUserId();
-        double rating = ((Number) body.get("rating")).doubleValue();
+        double rating = requireRating(body.get("rating"));
         String text = (String) body.get("review_text");
         LocalDate visitedAt = body.get("visited_at") != null
                 ? LocalDate.parse((String) body.get("visited_at")) : null;
@@ -51,8 +51,7 @@ public class ReviewController {
             @PathVariable String reviewId,
             @RequestBody Map<String, Object> body) {
         String userId = AuthUtil.getUserId();
-        Double rating = body.get("rating") != null
+        Double rating = body.get("rating") != null ? requireRating(body.get("rating")) : null;
-                ? ((Number) body.get("rating")).doubleValue() : null;
         String text = (String) body.get("review_text");
         LocalDate visitedAt = body.get("visited_at") != null
                 ? LocalDate.parse((String) body.get("visited_at")) : null;
@@ -94,4 +93,18 @@ public class ReviewController {
     public List<Restaurant> myFavorites() {
         return reviewService.getUserFavorites(AuthUtil.getUserId());
     }
+
+    /**
+     * #294 — rating 검증: null/비숫자/범위 외 입력은 400.
+     */
+    private static double requireRating(Object raw) {
+        if (!(raw instanceof Number n)) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "rating은 숫자여야 합니다");
+        }
+        double v = n.doubleValue();
+        if (v < 0.0 || v > 5.0 || Double.isNaN(v)) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "rating은 0.0 ~ 5.0 범위여야 합니다");
+        }
+        return v;
+    }
 }

backend-java/src/main/java/com/tasteby/controller/SearchController.java

@@ -2,7 +2,9 @@ package com.tasteby.controller;
 
 import com.tasteby.domain.Restaurant;
 import com.tasteby.service.SearchService;
+import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.server.ResponseStatusException;
 
 import java.util.List;
 
@@ -21,7 +23,12 @@ public class SearchController {
             @RequestParam String q,
             @RequestParam(defaultValue = "keyword") String mode,
             @RequestParam(defaultValue = "20") int limit) {
+        // #293 — q 빈값 가드: '%%' LIKE로 응답 폭발 차단
+        if (q == null || q.isBlank()) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "검색어가 필요합니다");
+        }
         if (limit > 100) limit = 100;
-        return searchService.search(q, mode, limit);
+        if (limit < 1) limit = 1;
+        return searchService.search(q.trim(), mode, limit);
     }
 }

backend-java/src/main/java/com/tasteby/controller/StatsController.java

@@ -1,7 +1,12 @@
 package com.tasteby.controller;
 
 import com.tasteby.domain.SiteVisitStats;
+import com.tasteby.service.RateLimitService;
 import com.tasteby.service.StatsService;
+import com.tasteby.util.BotDetector;
+import jakarta.servlet.http.HttpServletRequest;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.Map;
@@ -10,20 +15,51 @@ import java.util.Map;
 @RequestMapping("/api/stats")
 public class StatsController {
 
-    private final StatsService statsService;
+    private static final Logger log = LoggerFactory.getLogger(StatsController.class);
 
-    public StatsController(StatsService statsService) {
+    private final StatsService statsService;
+    private final RateLimitService rateLimitService;
+
+    public StatsController(StatsService statsService, RateLimitService rateLimitService) {
         this.statsService = statsService;
+        this.rateLimitService = rateLimitService;
     }
 
     @PostMapping("/visit")
-    public Map<String, Object> recordVisit() {
+    public Map<String, Object> recordVisit(HttpServletRequest req) {
+        // #337 — 봇 UA + IP 레이트리밋. 모두 통과해야 카운트 진행.
+        String ua = req.getHeader("User-Agent");
+        if (BotDetector.isBot(ua)) {
+            log.debug("visit skipped (bot): {}", ua);
+            return Map.of("ok", true, "counted", false);
+        }
+
+        String clientIp = resolveClientIp(req);
+        if (!rateLimitService.tryConsume(clientIp)) {
+            log.debug("visit skipped (rate-limit): {}", clientIp);
+            return Map.of("ok", true, "counted", false);
+        }
+
         statsService.recordVisit();
-        return Map.of("ok", true);
+        return Map.of("ok", true, "counted", true);
     }
 
     @GetMapping("/visits")
     public SiteVisitStats getVisits() {
         return statsService.getVisits();
     }
+
+    /**
+     * #337 — X-Forwarded-For 우선 (Nginx Ingress 뒤). chain이면 첫 번째(원본).
+     * 없으면 RemoteAddr 폴백.
+     */
+    private static String resolveClientIp(HttpServletRequest req) {
+        String fwd = req.getHeader("X-Forwarded-For");
+        if (fwd != null && !fwd.isBlank()) {
+            int comma = fwd.indexOf(',');
+            return (comma > 0 ? fwd.substring(0, comma) : fwd).trim();
+        }
+        String addr = req.getRemoteAddr();
+        return addr != null ? addr : "unknown";
+    }
 }

backend-java/src/main/java/com/tasteby/controller/VideoSseController.java

@@ -11,6 +11,7 @@ import org.springframework.web.bind.annotation.*;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 
 import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadLocalRandom;
@@ -182,7 +183,8 @@ public class VideoSseController {
                 for (int i = 0; i < total; i++) {
                     var v = rows.get(i);
                     if (i > 0) {
-                        long delay = (long) (3000 + Math.random() * 5000);
+                        // #325 — ThreadLocalRandom으로 통일 (bulkTranscript와 일관성)
+                        long delay = 3000L + ThreadLocalRandom.current().nextLong(5000);
                         emit(emitter, Map.of("type", "wait", "index", i, "delay", delay / 1000.0));
                         Thread.sleep(delay);
                     }
@@ -347,13 +349,15 @@ public class VideoSseController {
     @PostMapping("/rebuild-vectors")
     public SseEmitter rebuildVectors() {
         AuthUtil.requireAdmin();
-        SseEmitter emitter = new SseEmitter(600_000L);
+        SseEmitter emitter = new SseEmitter(60_000L);
 
         executor.execute(() -> {
             try {
-                emit(emitter, Map.of("type", "start"));
+                // #325 — 운영자에게 미구현 상태 명시 (이전: 즉시 complete(total=0) → 무반응 인상)
-                // TODO: Implement full vector rebuild using VectorService
+                emit(emitter, Map.of(
-                emit(emitter, Map.of("type", "complete", "total", 0));
+                        "type", "not_implemented",
+                        "message", "벡터 재생성은 아직 구현되지 않았습니다. 후속 이슈(#325/#331)에서 처리 예정입니다."
+                ));
                 emitter.complete();
             } catch (Exception e) {
                 emitter.completeWithError(e);

backend-java/src/main/java/com/tasteby/domain/SiteVisitStats.java

@@ -10,6 +10,7 @@ import lombok.NoArgsConstructor;
 @NoArgsConstructor
 @AllArgsConstructor
 public class SiteVisitStats {
-    private int today;
+    // #274 — long으로 변경 (21억 이상 누적 시 int 오버플로 방지)
-    private int total;
+    private long today;
+    private long total;
 }

backend-java/src/main/java/com/tasteby/dto/RestaurantUpdateDTO.java

@@ -0,0 +1,94 @@
+package com.tasteby.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.DecimalMax;
+import jakarta.validation.constraints.DecimalMin;
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+
+import java.math.BigDecimal;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * #358 식당 부분 업데이트 DTO.
+ * - null = 변경 없음 (toFieldMap에서 제외).
+ * - 화이트리스트는 record 필드로 표현 — Jackson SNAKE_CASE 매핑 유지.
+ * - URL: http(s) / "NONE" / 빈 문자열만 허용 ("NONE"은 DDG/Naver 매칭 실패 마킹).
+ */
+public record RestaurantUpdateDTO(
+        @Size(min = 1, max = 200)
+        String name,
+
+        @Size(max = 500)
+        String address,
+
+        @Size(max = 100)
+        String region,
+
+        @JsonProperty("cuisine_type")
+        @Size(max = 50)
+        String cuisineType,
+
+        @JsonProperty("price_range")
+        @Min(1) @Max(5)
+        Integer priceRange,
+
+        @Size(max = 50)
+        String phone,
+
+        @Pattern(regexp = "^(https?://.*|NONE|)$")
+        String website,
+
+        @JsonProperty("tabling_url")
+        @Pattern(regexp = "^(https?://.*|NONE|)$")
+        String tablingUrl,
+
+        @JsonProperty("catchtable_url")
+        @Pattern(regexp = "^(https?://.*|NONE|)$")
+        String catchtableUrl,
+
+        @DecimalMin("-90.0") @DecimalMax("90.0")
+        BigDecimal latitude,
+
+        @DecimalMin("-180.0") @DecimalMax("180.0")
+        BigDecimal longitude,
+
+        @JsonProperty("google_place_id")
+        @Size(max = 200)
+        String googlePlaceId,
+
+        @JsonProperty("business_status")
+        @Size(max = 50)
+        String businessStatus,
+
+        @DecimalMin("0.0") @DecimalMax("5.0")
+        BigDecimal rating,
+
+        @JsonProperty("rating_count")
+        @Min(0)
+        Integer ratingCount
+) {
+    /** null이 아닌 필드만 DB 컬럼명 키로 변환. */
+    public Map<String, Object> toFieldMap() {
+        Map<String, Object> m = new LinkedHashMap<>();
+        if (name != null) m.put("name", name);
+        if (address != null) m.put("address", address);
+        if (region != null) m.put("region", region);
+        if (cuisineType != null) m.put("cuisine_type", cuisineType);
+        if (priceRange != null) m.put("price_range", priceRange);
+        if (phone != null) m.put("phone", phone);
+        if (website != null) m.put("website", website);
+        if (tablingUrl != null) m.put("tabling_url", tablingUrl);
+        if (catchtableUrl != null) m.put("catchtable_url", catchtableUrl);
+        if (latitude != null) m.put("latitude", latitude);
+        if (longitude != null) m.put("longitude", longitude);
+        if (googlePlaceId != null) m.put("google_place_id", googlePlaceId);
+        if (businessStatus != null) m.put("business_status", businessStatus);
+        if (rating != null) m.put("rating", rating);
+        if (ratingCount != null) m.put("rating_count", ratingCount);
+        return m;
+    }
+}

backend-java/src/main/java/com/tasteby/mapper/RestaurantMapper.java

@@ -28,9 +28,24 @@ public interface RestaurantMapper {
 
     int countUnverified();
 
+    // #356 영상-식당 관련도
+    void updateLinkRelevance(@Param("linkId") String linkId,
+                             @Param("relevance") String relevance,
+                             @Param("reason") String reason);
+
+    Map<String, Object> findLinkContext(@Param("linkId") String linkId);
+
+    List<Map<String, Object>> findUnevaluatedLinks(@Param("limit") int limit);
+
+    int countUnevaluatedLinks();
+
+    // #359 1단계 — google_place_id 중복 조회
+    List<Map<String, Object>> findDuplicatePlaceIdRows();
+
     Restaurant findById(@Param("id") String id);
 
-    List<Map<String, Object>> findVideoLinks(@Param("restaurantId") String restaurantId);
+    List<Map<String, Object>> findVideoLinks(@Param("restaurantId") String restaurantId,
+                                              @Param("includeWeak") boolean includeWeak);
 
     void insertRestaurant(Restaurant r);
 

backend-java/src/main/java/com/tasteby/mapper/StatsMapper.java

@@ -7,7 +7,7 @@ public interface StatsMapper {
 
     void recordVisit();
 
-    int getTodayVisits();
+    long getTodayVisits();
 
-    int getTotalVisits();
+    long getTotalVisits();
 }

backend-java/src/main/java/com/tasteby/service/AuthService.java

@@ -6,6 +6,8 @@ import com.google.api.client.http.javanet.NetHttpTransport;
 import com.google.api.client.json.gson.GsonFactory;
 import com.tasteby.domain.UserInfo;
 import com.tasteby.security.JwtTokenProvider;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
@@ -17,6 +19,8 @@ import java.util.Map;
 @Service
 public class AuthService {
 
+    private static final Logger log = LoggerFactory.getLogger(AuthService.class);
+
     private final UserService userService;
     private final JwtTokenProvider jwtProvider;
     private final GoogleIdTokenVerifier verifier;
@@ -58,7 +62,10 @@ public class AuthService {
         } catch (ResponseStatusException e) {
             throw e;
         } catch (Exception e) {
-            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "Invalid Google token: " + e.getMessage());
+            // #266 — 외부에는 고정 메시지만, 상세는 로그로 (Google verifier 내부 네트워크/공개키
+            // 조회 실패 메시지가 클라이언트에 노출되지 않도록)
+            log.warn("Google token verification failed: {}", e.getMessage());
+            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "Invalid Google token");
         }
     }
 

backend-java/src/main/java/com/tasteby/service/CacheService.java

@@ -5,38 +5,52 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.Cursor;
+import org.springframework.data.redis.core.ScanOptions;
 import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 
+import java.nio.charset.StandardCharsets;
 import java.time.Duration;
-import java.util.Set;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
 
 @Service
 public class CacheService {
 
     private static final Logger log = LoggerFactory.getLogger(CacheService.class);
     private static final String PREFIX = "tasteby:";
+    private static final String SCAN_PATTERN = PREFIX + "*";
+    private static final int SCAN_BATCH = 500;
 
     private final StringRedisTemplate redis;
     private final ObjectMapper mapper;
     private final Duration ttl;
-    private boolean disabled = false;
+
+    // #336 — disabled/errorCount/lastError는 헬스체크와 다른 호출 스레드 사이에서 안전하게 공유.
+    private volatile boolean disabled = false;
+    private final AtomicLong errorCount = new AtomicLong(0);
+    private volatile String lastError = null;
 
     public CacheService(StringRedisTemplate redis, ObjectMapper mapper,
                         @Value("${app.cache.ttl-seconds:600}") int ttlSeconds) {
         this.redis = redis;
         this.mapper = mapper;
         this.ttl = Duration.ofSeconds(ttlSeconds);
-        try {
+        this.disabled = !pingOk();
-            redis.getConnectionFactory().getConnection().ping();
+        if (!disabled) log.info("Redis connected");
-            log.info("Redis connected");
-        } catch (Exception e) {
-            log.warn("Redis unavailable ({}), caching disabled", e.getMessage());
-            disabled = true;
-        }
     }
 
     public String makeKey(String... parts) {
+        if (parts == null || parts.length == 0) {
+            throw new IllegalArgumentException("makeKey requires at least one part");
+        }
+        for (String p : parts) {
+            if (p == null) throw new IllegalArgumentException("makeKey parts must not be null");
+        }
         return PREFIX + String.join(":", parts);
     }
 
@@ -48,7 +62,7 @@ public class CacheService {
                 return mapper.readValue(val, type);
             }
         } catch (Exception e) {
-            log.debug("Cache get error: {}", e.getMessage());
+            recordError("get", e);
         }
         return null;
     }
@@ -58,7 +72,7 @@ public class CacheService {
         try {
             return redis.opsForValue().get(key);
         } catch (Exception e) {
-            log.debug("Cache get error: {}", e.getMessage());
+            recordError("getRaw", e);
             return null;
         }
     }
@@ -69,20 +83,114 @@ public class CacheService {
             String json = mapper.writeValueAsString(value);
             redis.opsForValue().set(key, json, ttl);
         } catch (JsonProcessingException e) {
-            log.debug("Cache set error: {}", e.getMessage());
+            recordError("set:serialize", e);
+        } catch (Exception e) {
+            recordError("set", e);
         }
     }
 
+    /**
+     * #336 — KEYS 블로킹 명령 대체.
+     * SCAN으로 cursor 순회 후 UNLINK(논블로킹 삭제)로 일괄 삭제.
+     */
     public void flush() {
         if (disabled) return;
-        try {
+        Integer count = redis.execute((org.springframework.data.redis.core.RedisCallback<Integer>) conn -> {
-            Set<String> keys = redis.keys(PREFIX + "*");
+            List<byte[]> batch = new ArrayList<>(SCAN_BATCH);
-            if (keys != null && !keys.isEmpty()) {
+            int deleted = 0;
-                redis.delete(keys);
+            try (Cursor<byte[]> cursor = conn.keyCommands().scan(
+                    ScanOptions.scanOptions().match(SCAN_PATTERN).count(SCAN_BATCH).build())) {
+                while (cursor.hasNext()) {
+                    batch.add(cursor.next());
+                    if (batch.size() >= SCAN_BATCH) {
+                        deleted += unlinkBatch(conn, batch);
+                        batch.clear();
+                    }
+                }
+                if (!batch.isEmpty()) {
+                    deleted += unlinkBatch(conn, batch);
                 }
-            log.info("Cache flushed");
             } catch (Exception e) {
-            log.debug("Cache flush error: {}", e.getMessage());
+                recordError("flush:scan", e);
+            }
+            return deleted;
+        });
+        log.info("Cache flushed ({} keys via SCAN+UNLINK)", count == null ? 0 : count);
+    }
+
+    private int unlinkBatch(org.springframework.data.redis.connection.RedisConnection conn, List<byte[]> keys) {
+        try {
+            Long n = conn.keyCommands().unlink(keys.toArray(new byte[0][]));
+            return n == null ? 0 : n.intValue();
+        } catch (Exception e) {
+            // UNLINK 미지원 환경 대비 DEL 폴백
+            recordError("flush:unlink", e);
+            try {
+                Long n = conn.keyCommands().del(keys.toArray(new byte[0][]));
+                return n == null ? 0 : n.intValue();
+            } catch (Exception delErr) {
+                recordError("flush:del", delErr);
+                return 0;
             }
         }
     }
+
+    public void del(String key) {
+        if (disabled) return;
+        try {
+            redis.delete(key);
+        } catch (Exception e) {
+            recordError("del", e);
+        }
+    }
+
+    /**
+     * #336 — Redis 다운 → disabled=true, 재기동되면 자동으로 disabled=false.
+     * 30초마다 ping 한 번(<1ms)이라 부하 미미.
+     */
+    @Scheduled(fixedDelay = 30_000L)
+    public void checkHealth() {
+        boolean ok = pingOk();
+        if (ok && disabled) {
+            disabled = false;
+            log.info("Redis recovered, caching re-enabled");
+        } else if (!ok && !disabled) {
+            disabled = true;
+            log.warn("Redis lost, caching disabled");
+        }
+    }
+
+    private boolean pingOk() {
+        RedisConnectionFactory factory = redis.getConnectionFactory();
+        if (factory == null) return false;
+        try (var conn = factory.getConnection()) {
+            conn.ping();
+            return true;
+        } catch (Exception e) {
+            lastError = "ping: " + e.getMessage();
+            return false;
+        }
+    }
+
+    private void recordError(String op, Exception e) {
+        long n = errorCount.incrementAndGet();
+        String msg = e.getMessage();
+        lastError = op + ": " + (msg == null ? e.getClass().getSimpleName() : msg);
+        // 한 번씩만 WARN, 나머지는 DEBUG로 (운영 로그 폭주 방지 — 단순한 throttle)
+        if (n == 1 || n % 100 == 0) {
+            log.warn("Cache {} error #{}: {}", op, n, lastError);
+        } else {
+            log.debug("Cache {} error #{}: {}", op, n, lastError);
+        }
+    }
+
+    public boolean isDisabled() {
+        return disabled;
+    }
+
+    public CacheStats getStats() {
+        return new CacheStats(disabled, errorCount.get(), lastError);
+    }
+
+    public record CacheStats(boolean disabled, long errorCount, String lastError) {}
+}

backend-java/src/main/java/com/tasteby/service/ChannelService.java

@@ -27,11 +27,16 @@ public class ChannelService {
     }
 
     public boolean deactivate(String channelId) {
-        // Try deactivate by channel_id first, then by DB id
+        if (channelId == null || channelId.isBlank()) return false;
-        int rows = mapper.deactivateByChannelId(channelId);
+        // #295 — 입력 형식으로 명시적 분기:
-        if (rows == 0) {
+        //   "UC..."(24 chars) 형식 → YouTube channel_id로 비활성화
-            rows = mapper.deactivateById(channelId);
+        //   그 외(32-char hex UUID 등) → DB id로 비활성화
-        }
+        // 이전: channel_id 시도 → 0이면 id 시도. 우연히 UC가 hex와 같을 확률은 0이지만
+        // 가독성/의도 명확성 + 잘못된 폴백 차단을 위해 명시화.
+        boolean looksLikeYouTubeId = channelId.startsWith("UC") && channelId.length() == 24;
+        int rows = looksLikeYouTubeId
+                ? mapper.deactivateByChannelId(channelId)
+                : mapper.deactivateById(channelId);
         return rows > 0;
     }
 

backend-java/src/main/java/com/tasteby/service/DaemonConfigService.java

@@ -2,7 +2,9 @@ package com.tasteby.service;
 
 import com.tasteby.domain.DaemonConfig;
 import com.tasteby.mapper.DaemonConfigMapper;
+import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
+import org.springframework.web.server.ResponseStatusException;
 
 import java.util.Map;
 
@@ -27,20 +29,33 @@ public class DaemonConfigService {
             current.setScanEnabled(Boolean.TRUE.equals(body.get("scan_enabled")));
         }
         if (body.containsKey("scan_interval_min")) {
-            current.setScanIntervalMin(((Number) body.get("scan_interval_min")).intValue());
+            // #275 — 0/음수 입력으로 30초 사이클 폭주 방지. ClassCastException 대신 400.
+            current.setScanIntervalMin(requirePositiveInt(body.get("scan_interval_min"), "scan_interval_min"));
         }
         if (body.containsKey("process_enabled")) {
             current.setProcessEnabled(Boolean.TRUE.equals(body.get("process_enabled")));
         }
         if (body.containsKey("process_interval_min")) {
-            current.setProcessIntervalMin(((Number) body.get("process_interval_min")).intValue());
+            current.setProcessIntervalMin(requirePositiveInt(body.get("process_interval_min"), "process_interval_min"));
         }
         if (body.containsKey("process_limit")) {
-            current.setProcessLimit(((Number) body.get("process_limit")).intValue());
+            current.setProcessLimit(requirePositiveInt(body.get("process_limit"), "process_limit"));
         }
         mapper.updateConfig(current);
     }
 
+    /** #275 — 양의 정수 가드. 비숫자/0/음수는 400. */
+    private static int requirePositiveInt(Object raw, String field) {
+        if (!(raw instanceof Number n)) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, field + "은(는) 정수여야 합니다");
+        }
+        int v = n.intValue();
+        if (v < 1) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, field + "은(는) 1 이상이어야 합니다 (폭주 방지)");
+        }
+        return v;
+    }
+
     public void updateLastScan() {
         mapper.updateLastScan();
     }

backend-java/src/main/java/com/tasteby/service/DaemonScheduler.java

@@ -1,6 +1,7 @@
 package com.tasteby.service;
 
 import com.tasteby.domain.DaemonConfig;
+import net.javacrumbs.shedlock.spring.annotation.SchedulerLock;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
@@ -37,6 +38,10 @@ public class DaemonScheduler {
     }
 
     @Scheduled(fixedDelay = 30_000) // Check every 30 seconds
+    // #335 — 분산 락: 멀티 파드 환경에서 한 인스턴스만 실행. Redis 키 `lock:daemon-runner`.
+    // lockAtMostFor: 작업이 비정상 종료돼도 15분 후 강제 해제 (다음 cron이 잡을 수 있게)
+    // lockAtLeastFor: 빨리 끝나도 30초 동안 유지 (즉시 다른 cron이 같은 작업 잡는 것 방지)
+    @SchedulerLock(name = "daemon-runner", lockAtMostFor = "PT15M", lockAtLeastFor = "PT30S")
     public void run() {
         // 인스턴스 차원 차단(dev/prod 동일 DB 공유 환경에서 dev 쪽 동시 폴링 방지).
         // dev .env: DAEMON_ENABLED=false → 이 인스턴스는 스케줄러 동작 안 함.
@@ -50,8 +55,13 @@ public class DaemonScheduler {
                 Instant lastScan = config.getLastScanAt() != null ? config.getLastScanAt().toInstant() : null;
                 if (lastScan == null || Instant.now().isAfter(lastScan.plus(config.getScanIntervalMin(), ChronoUnit.MINUTES))) {
                     log.info("Running scheduled channel scan...");
-                    int newVideos = youTubeService.scanAllChannels();
+                    int newVideos = 0;
+                    try {
+                        newVideos = youTubeService.scanAllChannels();
+                    } finally {
+                        // #275 — 외부 호출 예외 시에도 last_scan_at을 갱신해 다음 cron까지의 backoff를 보장
                         daemonConfigService.updateLastScan();
+                    }
                     if (newVideos > 0) {
                         cacheService.flush();
                         log.info("Scan completed: {} new videos", newVideos);
@@ -63,8 +73,12 @@ public class DaemonScheduler {
                 Instant lastProcess = config.getLastProcessAt() != null ? config.getLastProcessAt().toInstant() : null;
                 if (lastProcess == null || Instant.now().isAfter(lastProcess.plus(config.getProcessIntervalMin(), ChronoUnit.MINUTES))) {
                     log.info("Running scheduled video processing (limit={})...", config.getProcessLimit());
-                    int restaurants = pipelineService.processPending(config.getProcessLimit());
+                    int restaurants = 0;
+                    try {
+                        restaurants = pipelineService.processPending(config.getProcessLimit());
+                    } finally {
                         daemonConfigService.updateLastProcess();
+                    }
                     if (restaurants > 0) {
                         cacheService.flush();
                         log.info("Processing completed: {} restaurants extracted", restaurants);

backend-java/src/main/java/com/tasteby/service/MemoService.java

@@ -3,6 +3,7 @@ package com.tasteby.service;
 import com.tasteby.domain.Memo;
 import com.tasteby.mapper.MemoMapper;
 import com.tasteby.util.IdGenerator;
+import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -25,11 +26,18 @@ public class MemoService {
     @Transactional
     public Memo upsert(String userId, String restaurantId, Double rating, String memoText, LocalDate visitedAt) {
         String visitedStr = visitedAt != null ? visitedAt.toString() : null;
+        // #294 — 동시성 가드: 사전 SELECT → 분기 INSERT/UPDATE 패턴은 두 트랜잭션이 동시에 미존재
+        // 판정 후 둘 다 INSERT → UNIQUE 충돌(500). INSERT 우선 시도 후 DuplicateKeyException 시 UPDATE.
         Memo existing = mapper.findByUserAndRestaurant(userId, restaurantId);
         if (existing != null) {
             mapper.updateMemo(userId, restaurantId, rating, memoText, visitedStr);
         } else {
+            try {
                 mapper.insertMemo(IdGenerator.newId(), userId, restaurantId, rating, memoText, visitedStr);
+            } catch (DuplicateKeyException e) {
+                // 동시 INSERT 충돌 → UPDATE로 폴백
+                mapper.updateMemo(userId, restaurantId, rating, memoText, visitedStr);
+            }
         }
         return mapper.findByUserAndRestaurant(userId, restaurantId);
     }

backend-java/src/main/java/com/tasteby/service/OciGenAiService.java

@@ -150,26 +150,25 @@ public class OciGenAiService {
             return mapper.readValue(raw, Object.class);
         } catch (Exception ignored) {}
 
-        // Try to recover truncated array
+        // #326 — Recover truncated array. Brace depth counter로 단일 패스 O(N).
+        // 이전: 각 idx에서 end를 1씩 늘려가며 매번 readValue → O(N²) + 예외 스택트레이스 양산.
         if (raw.trim().startsWith("[")) {
             List<Object> items = new ArrayList<>();
             int idx = raw.indexOf('[') + 1;
             while (idx < raw.length()) {
                 while (idx < raw.length() && " \t\n\r,".indexOf(raw.charAt(idx)) >= 0) idx++;
                 if (idx >= raw.length() || raw.charAt(idx) == ']') break;
+                if (raw.charAt(idx) != '{') break;  // 객체 시작이 아니면 복구 중단
 
-                // Try to parse next object
+                int end = findObjectEnd(raw, idx);
-                boolean found = false;
+                if (end < 0) break;  // 잘린 객체 — 거기서 멈춤
-                for (int end = idx + 1; end <= raw.length(); end++) {
                 try {
-                        Object obj = mapper.readValue(raw.substring(idx, end), Object.class);
+                    Object obj = mapper.readValue(raw.substring(idx, end + 1), Object.class);
                     items.add(obj);
-                        idx = end;
+                } catch (Exception ignored2) {
-                        found = true;
+                    break;  // 불가해 객체 — 멈춤
-                        break;
-                    } catch (Exception ignored2) {}
                 }
-                if (!found) break;
+                idx = end + 1;
             }
             if (!items.isEmpty()) {
                 log.info("Recovered {} items from truncated JSON", items.size());
@@ -179,4 +178,27 @@ public class OciGenAiService {
 
         throw new RuntimeException("JSON parse failed: " + raw.substring(0, Math.min(80, raw.length())));
     }
+
+    /**
+     * #326 — JSON 객체 시작 위치(`{`)에서 매칭되는 닫는 `}` 인덱스를 반환.
+     * 문자열 안의 `{` `}`와 escape는 무시. 매칭 못 찾으면 -1.
+     */
+    private static int findObjectEnd(String raw, int start) {
+        int depth = 0;
+        boolean inString = false;
+        boolean escaped = false;
+        for (int i = start; i < raw.length(); i++) {
+            char c = raw.charAt(i);
+            if (escaped) { escaped = false; continue; }
+            if (c == '\\') { escaped = true; continue; }
+            if (c == '"') { inString = !inString; continue; }
+            if (inString) continue;
+            if (c == '{') depth++;
+            else if (c == '}') {
+                depth--;
+                if (depth == 0) return i;
+            }
+        }
+        return -1;
+    }
 }

backend-java/src/main/java/com/tasteby/service/PipelineService.java

@@ -29,6 +29,7 @@ public class PipelineService {
     private final VectorService vectorService;
     private final CacheService cacheService;
     private final RestaurantVerifyService verifyService;
+    private final VideoRelevanceService relevanceService;
 
     public PipelineService(YouTubeService youTubeService,
                             ExtractorService extractorService,
@@ -37,7 +38,8 @@ public class PipelineService {
                             VideoService videoService,
                             VectorService vectorService,
                             CacheService cacheService,
-                            RestaurantVerifyService verifyService) {
+                            RestaurantVerifyService verifyService,
+                            VideoRelevanceService relevanceService) {
         this.youTubeService = youTubeService;
         this.extractorService = extractorService;
         this.geocodingService = geocodingService;
@@ -46,6 +48,7 @@ public class PipelineService {
         this.vectorService = vectorService;
         this.cacheService = cacheService;
         this.verifyService = verifyService;
+        this.relevanceService = relevanceService;
     }
 
     /**
@@ -145,13 +148,16 @@ public class PipelineService {
                 evaluationJson = JsonUtil.toJson(s);
             }
 
-            restaurantService.linkVideoRestaurant(
+            String linkId = restaurantService.linkVideoRestaurant(
                     videoDbId, restId,
                     foods instanceof List<?> ? (List<String>) foods : null,
                     evaluationJson,
                     guests instanceof List<?> ? (List<String>) guests : null
             );
 
+            // #356 — 신규 등록 직후 비동기 관련도 평가
+            relevanceService.verifyAsync(linkId);
+
             // Vector embeddings
             var chunks = VectorService.buildChunks(name, restData, title);
             if (!chunks.isEmpty()) {

backend-java/src/main/java/com/tasteby/service/RateLimitService.java

@@ -0,0 +1,51 @@
+package com.tasteby.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.stereotype.Service;
+
+import java.time.Duration;
+
+/**
+ * #337 — IP 기반 레이트리밋 (방문 카운트 어뷰즈 차단).
+ *
+ * 단순 Redis SETIFABSENT(SET NX EX) 패턴:
+ * - 첫 호출 시 키 등록 + TTL → 허용
+ * - TTL 동안 다음 호출은 키 존재로 차단
+ *
+ * Redis 다운 시 fail-open (true 반환) — 사용자 페이지 로드 우선.
+ * 멀티 파드 + Redis 단일 인스턴스 환경에서 자연스럽게 동작.
+ */
+@Service
+public class RateLimitService {
+
+    private static final Logger log = LoggerFactory.getLogger(RateLimitService.class);
+    private static final String PREFIX = "ratelimit:visit:";
+
+    private final StringRedisTemplate redis;
+
+    @Value("${app.rate-limit.visit-window-seconds:60}")
+    private long visitWindowSeconds;
+
+    public RateLimitService(StringRedisTemplate redis) {
+        this.redis = redis;
+    }
+
+    /**
+     * 단일 IP의 visit 호출 허용 여부.
+     * @return true = 허용 (첫 호출 또는 윈도우 만료), false = 차단 (윈도우 안 재호출)
+     */
+    public boolean tryConsume(String ipKey) {
+        try {
+            String key = PREFIX + ipKey;
+            Boolean ok = redis.opsForValue().setIfAbsent(key, "1", Duration.ofSeconds(visitWindowSeconds));
+            return Boolean.TRUE.equals(ok);
+        } catch (Exception e) {
+            // fail-open: Redis 문제로 통계가 약간 부풀어도 사용자 영향 X
+            log.debug("RateLimit error (fail-open): {}", e.getMessage());
+            return true;
+        }
+    }
+}

backend-java/src/main/java/com/tasteby/service/RestaurantService.java

@@ -77,7 +77,11 @@ public class RestaurantService {
     }
 
     public List<Map<String, Object>> findVideoLinks(String restaurantId) {
-        var rows = mapper.findVideoLinks(restaurantId);
+        return findVideoLinks(restaurantId, false);
+    }
+
+    public List<Map<String, Object>> findVideoLinks(String restaurantId, boolean includeWeak) {
+        var rows = mapper.findVideoLinks(restaurantId, includeWeak);
         return rows.stream().map(row -> {
             var m = JsonUtil.lowerKeys(row);
             m.put("foods_mentioned", JsonUtil.parseStringList(m.get("foods_mentioned")));
@@ -87,6 +91,43 @@ public class RestaurantService {
         }).toList();
     }
 
+    // #356 영상-식당 관련도
+    public void updateLinkRelevance(String linkId, String relevance, String reason) {
+        mapper.updateLinkRelevance(linkId, relevance, reason);
+    }
+
+    public Map<String, Object> findLinkContext(String linkId) {
+        var row = mapper.findLinkContext(linkId);
+        return row != null ? JsonUtil.lowerKeys(row) : null;
+    }
+
+    public List<Map<String, Object>> findUnevaluatedLinks(int limit) {
+        return mapper.findUnevaluatedLinks(limit).stream()
+                .map(JsonUtil::lowerKeys)
+                .toList();
+    }
+
+    public int countUnevaluatedLinks() {
+        return mapper.countUnevaluatedLinks();
+    }
+
+    // #359 1단계 — google_place_id 중복 그룹 (참조 카운트 동봉)
+    public List<Map<String, Object>> findDuplicatePlaceIdGroups() {
+        var rows = mapper.findDuplicatePlaceIdRows().stream()
+                .map(JsonUtil::lowerKeys)
+                .toList();
+        Map<String, List<Map<String, Object>>> grouped = new LinkedHashMap<>();
+        for (var r : rows) {
+            String key = (String) r.get("google_place_id");
+            grouped.computeIfAbsent(key, k -> new ArrayList<>()).add(r);
+        }
+        List<Map<String, Object>> out = new ArrayList<>(grouped.size());
+        for (var e : grouped.entrySet()) {
+            out.add(Map.of("google_place_id", e.getKey(), "items", e.getValue()));
+        }
+        return out;
+    }
+
     public void update(String id, Map<String, Object> fields) {
         mapper.updateFields(id, fields);
     }
@@ -138,12 +179,13 @@ public class RestaurantService {
         }
     }
 
-    public void linkVideoRestaurant(String videoId, String restaurantId, List<String> foods, String evaluation, List<String> guests) {
+    public String linkVideoRestaurant(String videoId, String restaurantId, List<String> foods, String evaluation, List<String> guests) {
         String id = IdGenerator.newId();
         String foodsJson = foods != null ? JsonUtil.toJson(foods) : null;
         String guestsJson = guests != null ? JsonUtil.toJson(guests) : null;
         String evalJson = JsonUtil.normalizeEvaluation(evaluation);
         mapper.linkVideoRestaurant(id, videoId, restaurantId, foodsJson, evalJson, guestsJson);
+        return id;
     }
 
     public void updateCuisineType(String id, String cuisineType) {

backend-java/src/main/java/com/tasteby/service/ReviewService.java

@@ -5,6 +5,7 @@ import com.tasteby.domain.Review;
 import com.tasteby.mapper.ReviewMapper;
 import com.tasteby.util.IdGenerator;
 import com.tasteby.util.JsonUtil;
+import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -37,11 +38,13 @@ public class ReviewService {
         return mapper.findById(id);
     }
 
+    @Transactional   // #334 — 단일 SQL이지만 어노테이션 일관성
     public boolean update(String reviewId, String userId, Double rating, String reviewText, LocalDate visitedAt) {
         String visitedStr = visitedAt != null ? visitedAt.toString() : null;
         return mapper.updateReview(reviewId, userId, rating, reviewText, visitedStr) > 0;
     }
 
+    @Transactional   // #334 — 단일 SQL이지만 어노테이션 일관성
     public boolean delete(String reviewId, String userId) {
         return mapper.deleteReview(reviewId, userId) > 0;
     }
@@ -60,10 +63,15 @@ public class ReviewService {
         if (existingId != null) {
             mapper.deleteFavorite(userId, restaurantId);
             return false;
-        } else {
-            mapper.insertFavorite(IdGenerator.newId(), userId, restaurantId);
-            return true;
         }
+        // #294 — 동시성 가드: 동시 INSERT 시 UNIQUE 충돌 → 한 쪽 500.
+        // INSERT 시도 후 DuplicateKeyException은 "이미 추가됨"으로 간주 (토글 의도는 ON).
+        try {
+            mapper.insertFavorite(IdGenerator.newId(), userId, restaurantId);
+        } catch (DuplicateKeyException ignored) {
+            // 다른 트랜잭션이 먼저 INSERT 함 — 결과는 어쨌든 즐겨찾기 ON.
+        }
+        return true;
     }
 
     public List<Restaurant> getUserFavorites(String userId) {

backend-java/src/main/java/com/tasteby/service/SearchService.java

@@ -1,9 +1,12 @@
 package com.tasteby.service;
 
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.tasteby.domain.Restaurant;
 import com.tasteby.mapper.SearchMapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
 import java.util.*;
@@ -12,12 +15,17 @@ import java.util.*;
 public class SearchService {
 
     private static final Logger log = LoggerFactory.getLogger(SearchService.class);
+    private static final ObjectMapper JSON = new ObjectMapper();
+    private static final TypeReference<List<Restaurant>> LIST_TYPE = new TypeReference<>() {};
 
     private final SearchMapper searchMapper;
     private final RestaurantService restaurantService;
     private final VectorService vectorService;
     private final CacheService cache;
 
+    @Value("${app.search.max-distance:0.57}")
+    private double maxDistance;
+
     public SearchService(SearchMapper searchMapper,
                           RestaurantService restaurantService,
                           VectorService vectorService,
@@ -33,8 +41,8 @@ public class SearchService {
         String cached = cache.getRaw(key);
         if (cached != null) {
             try {
-                var mapper = new com.fasterxml.jackson.databind.ObjectMapper();
+                // #293 — ObjectMapper 재사용 (필드 static)
-                return mapper.readValue(cached, new com.fasterxml.jackson.core.type.TypeReference<List<Restaurant>>() {});
+                return JSON.readValue(cached, LIST_TYPE);
             } catch (Exception ignored) {}
         }
 
@@ -44,13 +52,20 @@ public class SearchService {
             case "hybrid" -> {
                 var kw = keywordSearch(q, limit);
                 var sem = semanticSearch(q, limit);
+                // #293 — semantic 결과에도 channels 부착 (이전: keyword에만 부착되어 hybrid에서 sem 결과는 채널 누락)
+                if (!sem.isEmpty()) attachChannels(sem);
                 Set<String> seen = new HashSet<>();
                 var merged = new ArrayList<Restaurant>();
                 for (var r : kw) { if (seen.add(r.getId())) merged.add(r); }
                 for (var r : sem) { if (seen.add(r.getId())) merged.add(r); }
                 result = merged.size() > limit ? merged.subList(0, limit) : merged;
             }
-            default -> result = keywordSearch(q, limit);
+            case "keyword" -> result = keywordSearch(q, limit);
+            default -> {
+                // #293 — 알 수 없는 mode는 silent fallback 대신 경고 로그
+                log.warn("Unknown search mode '{}', falling back to keyword", mode);
+                result = keywordSearch(q, limit);
+            }
         }
 
         cache.set(key, result);
@@ -58,7 +73,10 @@ public class SearchService {
     }
 
     private List<Restaurant> keywordSearch(String q, int limit) {
-        String pattern = "%" + q + "%";
+        // #293 — LIKE 와일드카드 escape: 사용자 입력의 %, _, \ 를 리터럴로 처리.
+        // SQL에서는 ESCAPE '\\' 절을 사용 (SearchMapper.xml).
+        String escaped = q.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_");
+        String pattern = "%" + escaped + "%";
         List<Restaurant> results = searchMapper.keywordSearch(pattern, limit);
         if (!results.isEmpty()) {
             attachChannels(results);
@@ -68,7 +86,7 @@ public class SearchService {
 
     private List<Restaurant> semanticSearch(String q, int limit) {
         try {
-            var similar = vectorService.searchSimilar(q, Math.max(30, limit * 3), 0.57);
+            var similar = vectorService.searchSimilar(q, Math.max(30, limit * 3), maxDistance);
             if (similar.isEmpty()) return List.of();
 
             Set<String> seen = new LinkedHashSet<>();

backend-java/src/main/java/com/tasteby/service/StatsService.java

@@ -2,11 +2,16 @@ package com.tasteby.service;
 
 import com.tasteby.domain.SiteVisitStats;
 import com.tasteby.mapper.StatsMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.stereotype.Service;
 
 @Service
 public class StatsService {
 
+    private static final Logger log = LoggerFactory.getLogger(StatsService.class);
+
     private final StatsMapper mapper;
 
     public StatsService(StatsMapper mapper) {
@@ -14,7 +19,19 @@ public class StatsService {
     }
 
     public void recordVisit() {
+        // #274 — 자정 경계 동시성: 두 트랜잭션이 동시에 'NOT MATCHED' 판정 → 둘 다 INSERT
+        // → PK/UNIQUE 충돌 시 한 쪽 500. 1회 재시도(다음엔 MATCHED → UPDATE 분기).
+        try {
             mapper.recordVisit();
+        } catch (DataIntegrityViolationException e) {
+            log.debug("recordVisit conflict (midnight race), retry once: {}", e.getMessage());
+            try {
+                mapper.recordVisit();
+            } catch (DataIntegrityViolationException retryFail) {
+                // 두 번째 시도도 실패: 카운트 1건 손실은 수용 (운영 영향 미미)
+                log.warn("recordVisit double-conflict, dropping one count: {}", retryFail.getMessage());
+            }
+        }
     }
 
     public SiteVisitStats getVisits() {

backend-java/src/main/java/com/tasteby/service/VectorService.java

@@ -1,10 +1,12 @@
 package com.tasteby.service;
 
+import com.tasteby.util.IdGenerator;
 import com.tasteby.util.JsonUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.jdbc.core.namedparam.SqlParameterSource;
 import org.springframework.stereotype.Service;
 
 import java.util.*;
@@ -27,12 +29,15 @@ public class VectorService {
      */
     public List<Map<String, Object>> searchSimilar(String query, int topK, double maxDistance) {
         List<List<Double>> embeddings = genAi.embedTexts(List.of(query));
-        if (embeddings.isEmpty()) return List.of();
+        // #293 — embeddings 빈/null 가드 (NPE/IndexOutOfBoundsException 방지)
+        if (embeddings == null || embeddings.isEmpty()) return List.of();
+        List<Double> first = embeddings.getFirst();
+        if (first == null || first.isEmpty()) return List.of();
 
         // Convert to float array for Oracle VECTOR type
-        float[] queryVec = new float[embeddings.getFirst().size()];
+        float[] queryVec = new float[first.size()];
         for (int i = 0; i < queryVec.length; i++) {
-            queryVec[i] = embeddings.getFirst().get(i).floatValue();
+            queryVec[i] = first.get(i).floatValue();
         }
 
         String sql = """
@@ -61,6 +66,9 @@ public class VectorService {
 
     /**
      * Save vector embeddings for a restaurant.
+     *
+     * #331 — N개 청크를 단일 batchUpdate 호출로 처리 (이전: N+1 INSERT round-trip).
+     * UUID 생성은 IdGenerator.newId() 공통 유틸 사용 (인라인 변환 코드 제거).
      */
     public void saveRestaurantVectors(String restaurantId, List<String> chunks) {
         if (chunks.isEmpty()) return;
@@ -72,19 +80,20 @@ public class VectorService {
             VALUES (:id, :rid, :chunk, :emb)
         """;
 
+        SqlParameterSource[] batch = new SqlParameterSource[chunks.size()];
         for (int i = 0; i < chunks.size(); i++) {
-            String id = UUID.randomUUID().toString().replace("-", "").substring(0, 32).toUpperCase();
+            List<Double> emb = embeddings.get(i);
-            float[] vec = new float[embeddings.get(i).size()];
+            float[] vec = new float[emb.size()];
             for (int j = 0; j < vec.length; j++) {
-                vec[j] = embeddings.get(i).get(j).floatValue();
+                vec[j] = emb.get(j).floatValue();
             }
-            var params = new MapSqlParameterSource();
+            batch[i] = new MapSqlParameterSource()
-            params.addValue("id", id);
+                    .addValue("id", IdGenerator.newId())
-            params.addValue("rid", restaurantId);
+                    .addValue("rid", restaurantId)
-            params.addValue("chunk", chunks.get(i));
+                    .addValue("chunk", chunks.get(i))
-            params.addValue("emb", vec);
+                    .addValue("emb", vec);
-            jdbc.update(sql, params);
         }
+        jdbc.batchUpdate(sql, batch);
     }
 
     /**

backend-java/src/main/java/com/tasteby/service/VideoRelevanceService.java

@@ -0,0 +1,154 @@
+package com.tasteby.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * #356 영상-식당 관련도 LLM 평가.
+ * 설계서: docs/design/356-video-relevance-llm/README.md
+ *
+ * 신규 등록 시 자동 평가 + 어드민 백필. 결과는 video_restaurants.relevance에 저장.
+ * - strong: 본격 다룸 (방문 리뷰, 메뉴 평가)
+ * - weak: 잠깐 언급, 비교 대상
+ * - incidental: 일반 토픽 중 단순 언급, 입점 전
+ * - unknown: 미평가 or LLM 실패 (안전 기본값으로 표시 유지)
+ */
+@Service
+public class VideoRelevanceService {
+
+    private static final Logger log = LoggerFactory.getLogger(VideoRelevanceService.class);
+    private static final Set<String> VALID = Set.of("strong", "weak", "incidental", "unknown");
+    private static final long BACKFILL_SLEEP_MS = 200;
+
+    private final RestaurantService restaurantService;
+    private final OciGenAiService genAi;
+    private final ObjectMapper jsonMapper = new ObjectMapper();
+
+    public VideoRelevanceService(RestaurantService restaurantService, OciGenAiService genAi) {
+        this.restaurantService = restaurantService;
+        this.genAi = genAi;
+    }
+
+    @Async
+    public void verifyAsync(String linkId) {
+        try {
+            verify(linkId);
+        } catch (Exception e) {
+            log.warn("verifyAsync failed for link {}: {}", linkId, e.getMessage());
+        }
+    }
+
+    public void verify(String linkId) {
+        Map<String, Object> ctx = restaurantService.findLinkContext(linkId);
+        if (ctx == null) return;
+        VerifyResult result;
+        try {
+            String prompt = buildPrompt(ctx);
+            String response = genAi.chat(prompt, 120);
+            result = parseRelevance(response);
+        } catch (Exception e) {
+            log.warn("verify({}) LLM failed: {} — keeping unknown", linkId, e.getMessage());
+            return;
+        }
+        restaurantService.updateLinkRelevance(linkId, result.relevance(), truncate(result.reason(), 120));
+    }
+
+    @Async
+    public void verifyAllAsync(int batchSize) {
+        try {
+            int n = verifyAll(batchSize);
+            log.info("[VideoRelevance] backfill done: {} processed", n);
+        } catch (Exception e) {
+            log.warn("verifyAllAsync failed: {}", e.getMessage());
+        }
+    }
+
+    public int verifyAll(int batchSize) {
+        int total = 0;
+        List<Map<String, Object>> batch;
+        while (!(batch = restaurantService.findUnevaluatedLinks(batchSize)).isEmpty()) {
+            for (Map<String, Object> row : batch) {
+                String linkId = (String) row.get("link_id");
+                if (linkId == null) continue;
+                try {
+                    verify(linkId);
+                } catch (Exception e) {
+                    log.warn("verifyAll({}) failed: {}", linkId, e.getMessage());
+                }
+                total++;
+                try { Thread.sleep(BACKFILL_SLEEP_MS); } catch (InterruptedException ie) {
+                    Thread.currentThread().interrupt();
+                    return total;
+                }
+            }
+            if (batch.size() < batchSize) break;
+        }
+        return total;
+    }
+
+    // ---- pure helpers ----
+
+    String buildPrompt(Map<String, Object> ctx) {
+        String foods = safeStr(ctx.get("foods_mentioned"));
+        String evaluation = safeStr(ctx.get("evaluation"));
+        return "다음 YouTube 영상이 이 식당을 어떻게 다루는지 판정하라.\n\n" +
+               "식당명: " + safeStr(ctx.get("restaurant_name")) + "\n" +
+               "주소: " + safeStr(ctx.get("address")) + "\n" +
+               "음식 분류: " + safeStr(ctx.get("cuisine_type")) + "\n" +
+               "언급된 음식: " + (foods.isEmpty() ? "(없음)" : foods) + "\n\n" +
+               "영상 제목: " + safeStr(ctx.get("video_title")) + "\n" +
+               "영상 채널: " + safeStr(ctx.get("channel_name")) + "\n" +
+               "영상에 등장한 평가: " + (evaluation.isEmpty() ? "(없음)" : evaluation) + "\n\n" +
+               "응답 형식(JSON만, 다른 텍스트 없이):\n" +
+               "{\"relevance\": \"strong\"|\"weak\"|\"incidental\", \"reason\": \"20자 이내 한국어\"}\n\n" +
+               "가이드:\n" +
+               "- strong: 영상이 이 식당을 본격 다룸 (방문 리뷰, 메뉴 평가).\n" +
+               "- weak: 잠깐 언급, 다른 식당과 비교 대상으로 등장.\n" +
+               "- incidental: 일반 토픽 중 단순 언급, 식당 입점 전 영상.\n" +
+               "- 판단 모호 시 strong (보수적 — 사용자에게 표시 유지).";
+    }
+
+    private static final Pattern JSON_BLOCK = Pattern.compile("\\{[^{}]*\\}", Pattern.DOTALL);
+
+    VerifyResult parseRelevance(String raw) {
+        if (raw == null) return VerifyResult.unknown();
+        String trimmed = raw.trim();
+        String json = (trimmed.startsWith("{") && trimmed.endsWith("}")) ? trimmed : null;
+        if (json == null) {
+            Matcher m = JSON_BLOCK.matcher(raw);
+            if (m.find()) json = m.group();
+        }
+        if (json == null) return VerifyResult.unknown();
+        try {
+            JsonNode node = jsonMapper.readTree(json);
+            String rel = node.path("relevance").asText("unknown").toLowerCase();
+            if (!VALID.contains(rel)) rel = "unknown";
+            String reason = node.path("reason").asText("");
+            return new VerifyResult(rel, reason);
+        } catch (Exception e) {
+            return VerifyResult.unknown();
+        }
+    }
+
+    private static String safeStr(Object o) {
+        return o == null ? "" : o.toString();
+    }
+
+    private static String truncate(String s, int max) {
+        return s == null ? null : (s.length() <= max ? s : s.substring(0, max));
+    }
+
+    public record VerifyResult(String relevance, String reason) {
+        public static VerifyResult unknown() { return new VerifyResult("unknown", "parse_failed"); }
+    }
+}

backend-java/src/main/java/com/tasteby/service/WebSearchService.java

@@ -0,0 +1,159 @@
+package com.tasteby.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.net.URI;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * #357 웹 검색 추상화.
+ * - Naver Search webkr.json 우선 (한국 식당 정확도 높음, 무료 일 25k).
+ * - 키 미설정 또는 5xx/timeout 시 DDG HTML 파싱으로 폴백.
+ * - 결과는 urlPatterns로 필터링 (기존 searchDuckDuckGo와 동일 인터페이스).
+ */
+@Service
+public class WebSearchService {
+
+    private static final Logger log = LoggerFactory.getLogger(WebSearchService.class);
+    private static final int MAX_RESULTS = 5;
+
+    private static final Duration REQ_TIMEOUT = Duration.ofSeconds(15);
+    private static final HttpClient HTTP = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.NORMAL)
+            .connectTimeout(Duration.ofSeconds(5))
+            .build();
+
+    private static final Pattern DDG_RESULT = Pattern.compile(
+            "<a[^>]+class=\"result__a\"[^>]+href=\"([^\"]+)\"[^>]*>(.*?)</a>",
+            Pattern.DOTALL);
+
+    private final ObjectMapper json = new ObjectMapper();
+    private final String naverClientId;
+    private final String naverClientSecret;
+
+    public WebSearchService(
+            @Value("${app.naver.client-id:}") String naverClientId,
+            @Value("${app.naver.client-secret:}") String naverClientSecret) {
+        this.naverClientId = naverClientId == null ? "" : naverClientId.trim();
+        this.naverClientSecret = naverClientSecret == null ? "" : naverClientSecret.trim();
+        log.info("WebSearchService init — Naver={}", naverClientId.isEmpty() ? "off" : "on");
+    }
+
+    public List<Map<String, Object>> search(String query, String... urlPatterns) {
+        if (!naverClientId.isEmpty() && !naverClientSecret.isEmpty()) {
+            try {
+                List<Map<String, Object>> n = searchNaver(query, urlPatterns);
+                if (!n.isEmpty()) return n;
+            } catch (Exception e) {
+                log.warn("[NaverSearch] failed, falling back to DDG: {}", e.getMessage());
+            }
+        }
+        try {
+            return searchDdg(query, urlPatterns);
+        } catch (Exception e) {
+            log.warn("[DDG] failed: {}", e.getMessage());
+            return List.of();
+        }
+    }
+
+    // ─── Naver ───
+
+    List<Map<String, Object>> searchNaver(String query, String... urlPatterns) throws Exception {
+        String encoded = URLEncoder.encode(query, StandardCharsets.UTF_8);
+        String url = "https://openapi.naver.com/v1/search/webkr.json?query=" + encoded + "&display=30";
+        HttpRequest req = HttpRequest.newBuilder()
+                .uri(URI.create(url))
+                .timeout(REQ_TIMEOUT)
+                .header("X-Naver-Client-Id", naverClientId)
+                .header("X-Naver-Client-Secret", naverClientSecret)
+                .GET()
+                .build();
+        HttpResponse<String> resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString());
+        if (resp.statusCode() >= 400) {
+            throw new RuntimeException("Naver " + resp.statusCode());
+        }
+        JsonNode root = json.readTree(resp.body());
+        JsonNode items = root.path("items");
+        List<Map<String, Object>> out = new ArrayList<>();
+        Set<String> seen = new HashSet<>();
+        for (JsonNode it : items) {
+            if (out.size() >= MAX_RESULTS) break;
+            String link = it.path("link").asText("");
+            String title = stripTags(it.path("title").asText(""));
+            if (link.isEmpty() || !matchesPattern(link, urlPatterns)) continue;
+            if (seen.add(link)) out.add(Map.of("title", title, "url", link));
+        }
+        log.info("[NaverSearch] '{}' → {}", query, out.size());
+        return out;
+    }
+
+    // ─── DDG ───
+
+    List<Map<String, Object>> searchDdg(String query, String... urlPatterns) throws Exception {
+        String encoded = URLEncoder.encode(query, StandardCharsets.UTF_8);
+        String url = "https://html.duckduckgo.com/html/?q=" + encoded;
+        HttpRequest req = HttpRequest.newBuilder()
+                .uri(URI.create(url))
+                .timeout(REQ_TIMEOUT)
+                .header("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36")
+                .header("Accept", "text/html,application/xhtml+xml")
+                .header("Accept-Language", "ko-KR,ko;q=0.9")
+                .GET()
+                .build();
+        HttpResponse<String> resp = HTTP.send(req, HttpResponse.BodyHandlers.ofString());
+        String html = resp.body();
+        Matcher m = DDG_RESULT.matcher(html);
+        List<Map<String, Object>> out = new ArrayList<>();
+        Set<String> seen = new HashSet<>();
+        while (m.find() && out.size() < MAX_RESULTS) {
+            String href = m.group(1);
+            String title = m.group(2).replaceAll("<[^>]+>", "").trim();
+            String actual = extractDdgUrl(href);
+            if (actual == null || !matchesPattern(actual, urlPatterns)) continue;
+            if (seen.add(actual)) out.add(Map.of("title", title, "url", actual));
+        }
+        log.info("[DDG] '{}' → {}", query, out.size());
+        return out;
+    }
+
+    private String extractDdgUrl(String ddgHref) {
+        try {
+            if (ddgHref.contains("uddg=")) {
+                String p = ddgHref.substring(ddgHref.indexOf("uddg=") + 5);
+                int amp = p.indexOf('&');
+                if (amp > 0) p = p.substring(0, amp);
+                return URLDecoder.decode(p, StandardCharsets.UTF_8);
+            }
+            if (ddgHref.startsWith("http")) return ddgHref;
+        } catch (Exception e) {
+            log.debug("[DDG] url extract failed: {}", ddgHref);
+        }
+        return null;
+    }
+
+    static String stripTags(String s) {
+        return s == null ? "" : s.replaceAll("<[^>]+>", "").trim();
+    }
+
+    static boolean matchesPattern(String url, String[] patterns) {
+        if (patterns == null || patterns.length == 0) return true;
+        for (String p : patterns) {
+            if (url.contains(p)) return true;
+        }
+        return false;
+    }
+}

backend-java/src/main/java/com/tasteby/service/YouTubeService.java

@@ -278,8 +278,19 @@ public class YouTubeService {
 
     /**
      * Fetch transcript for a YouTube video.
-     * Tries API first (fast), then falls back to Playwright browser extraction.
+     *
-     * @param mode "auto" = manual first then generated, "manual" = manual only, "generated" = generated only
+     * 흐름: (1) Playwright headed 브라우저 추출 → (2) 실패 시 youtube-transcript-api 폴백.
+     *
+     * <p>#325 — mode 인자 명세:
+     * <ul>
+     *   <li>"auto" (기본): manual → generated 순서로 시도</li>
+     *   <li>"manual": manual(사람이 쓴 자막)만</li>
+     *   <li>"generated": 자동 생성 자막만</li>
+     * </ul>
+     * 주의: mode 인자는 <b>youtube-transcript-api 폴백 경로에서만 사용</b>됩니다.
+     * 브라우저 추출은 YouTube가 노출하는 자막 트랙 전체를 그대로 수신하므로 mode 무관.
+     *
+     * @param mode 위 설명 참조. null이면 "auto"로 간주.
      */
     public TranscriptResult getTranscript(String videoId, String mode) {
         if (mode == null) mode = "auto";

backend-java/src/main/java/com/tasteby/util/BotDetector.java

@@ -0,0 +1,25 @@
+package com.tasteby.util;
+
+import java.util.regex.Pattern;
+
+/**
+ * #337 — User-Agent 기반 봇 패턴 매칭.
+ *
+ * Googlebot / bingbot / facebookexternalhit / 일반 crawler/spider 등을 일괄 차단.
+ * 빈 UA는 봇으로 간주하지 않음(모바일 앱 등 정상 케이스 보호).
+ */
+public final class BotDetector {
+
+    private BotDetector() {}
+
+    // 일반적인 봇/크롤러 패턴. 케이스 무시.
+    private static final Pattern BOT_PATTERN = Pattern.compile(
+            "bot|crawler|spider|slurp|scrap|fetch|monitor|preview|lighthouse",
+            Pattern.CASE_INSENSITIVE
+    );
+
+    public static boolean isBot(String userAgent) {
+        if (userAgent == null || userAgent.isBlank()) return false;
+        return BOT_PATTERN.matcher(userAgent).find();
+    }
+}

backend-java/src/main/java/com/tasteby/util/HangulSimilarity.java

@@ -0,0 +1,67 @@
+package com.tasteby.util;
+
+import java.text.Normalizer;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * #348 — 한국어 자모 분해(Unicode NFD) + Sørensen-Dice bigram 유사도.
+ *
+ * 음절 단위 Jaccard보다 짧은 한국어 이름에 정확. 예:
+ *   similarity("스타벅스 강남", "스타벅스 강남점")  ≈ 0.85+
+ *   similarity("스타벅스 강남", "스타벅스 종로")    ≈ 0.55~0.85
+ *   similarity("스타벅스", "맥도날드")              < 0.20
+ *
+ * 공백/구두점은 제거하고 소문자화한 뒤 NFD 분해.
+ */
+public final class HangulSimilarity {
+
+    private HangulSimilarity() {}
+
+    /** 공백/구두점 제거 + 소문자화 + NFD 분해(한글 음절 → 자모). */
+    public static String decompose(String s) {
+        if (s == null || s.isEmpty()) return "";
+        String stripped = s.replaceAll("[\\s·\\-_()（）\\[\\]【】]", "").toLowerCase();
+        return Normalizer.normalize(stripped, Normalizer.Form.NFD);
+    }
+
+    /**
+     * Sørensen-Dice 계수 (bigram multiset 기반). 0.0~1.0.
+     * 동일 문자열 → 1.0. 빈 입력 → 0.0.
+     */
+    public static double similarity(String a, String b) {
+        String da = decompose(a);
+        String db = decompose(b);
+        if (da.isEmpty() || db.isEmpty()) return 0.0;
+        if (da.equals(db)) return 1.0;
+
+        // 포함 관계는 강한 신호로 1.0 처리 (기존 동작과 일관)
+        if (da.contains(db) || db.contains(da)) return 1.0;
+
+        if (da.length() < 2 || db.length() < 2) {
+            return 0.0;
+        }
+
+        Map<String, Integer> bigramsA = bigrams(da);
+        Map<String, Integer> bigramsB = bigrams(db);
+        int common = 0;
+        for (var e : bigramsA.entrySet()) {
+            Integer countB = bigramsB.get(e.getKey());
+            if (countB != null) {
+                common += Math.min(e.getValue(), countB);
+            }
+        }
+        int sizeA = da.length() - 1;
+        int sizeB = db.length() - 1;
+        return (2.0 * common) / (sizeA + sizeB);
+    }
+
+    private static Map<String, Integer> bigrams(String s) {
+        Map<String, Integer> map = new HashMap<>();
+        for (int i = 0; i < s.length() - 1; i++) {
+            String gram = s.substring(i, i + 2);
+            map.merge(gram, 1, Integer::sum);
+        }
+        return map;
+    }
+}

backend-java/src/main/resources/application.yml

@@ -56,9 +56,28 @@ app:
     youtube-api-key: ${YOUTUBE_DATA_API_KEY}
     client-id: ${GOOGLE_CLIENT_ID:635551099330-2l003d3ernjmkqavd4f6s78r8r405iml.apps.googleusercontent.com}
 
+  # #357 — Naver Search API (Tabling/Catchtable URL 매칭). 미설정 시 DDG 폴백.
+  naver:
+    client-id: ${NAVER_CLIENT_ID:}
+    client-secret: ${NAVER_CLIENT_SECRET:}
+
   cache:
     ttl-seconds: 600
 
+  search:
+    # #293 — 벡터 검색 cosine distance 임계값 (0.0=완전일치, 1.0=직교).
+    # 0.57은 cohere embed-v4 한국어 시맨틱 적합도 기준 경험값.
+    max-distance: ${SEARCH_MAX_DISTANCE:0.57}
+
+  rate-limit:
+    # #337 — 같은 IP에서 visit 카운트 허용 간격(초). 기본 60.
+    visit-window-seconds: ${VISIT_WINDOW_SECONDS:60}
+
+  build:
+    # #338 — 배포 시 deploy.sh가 env로 주입. dev에서는 dev/unknown.
+    version: ${APP_VERSION:dev}
+    commit: ${APP_COMMIT:unknown}
+
   daemon:
     # 인스턴스 차원 스케줄러 활성화. dev/prod가 같은 DB를 공유하므로
     # dev .env에 DAEMON_ENABLED=false를 설정해 dev 폴링을 끄고 prod만 동작시킨다.

backend-java/src/main/resources/db/migration/V20260615b__video_relevance.sql

@@ -0,0 +1,7 @@
+-- #356 영상-식당 관련도 LLM 평가
+ALTER TABLE video_restaurants ADD (
+  relevance VARCHAR2(16) DEFAULT 'unknown' NOT NULL,
+  relevance_reason VARCHAR2(120),
+  relevance_evaluated_at TIMESTAMP
+);
+CREATE INDEX idx_vr_relevance ON video_restaurants(relevance);

backend-java/src/main/resources/mybatis/mapper/ChannelMapper.xml

@@ -44,7 +44,8 @@
     </update>
 
     <select id="findByChannelId" resultMap="channelResultMap">
-        SELECT id, channel_id, channel_name, title_filter
+        <!-- #295 — findAllActive와 동일하게 description/tags/sort_order까지 SELECT -->
+        SELECT id, channel_id, channel_name, title_filter, description, tags, sort_order
         FROM channels
         WHERE channel_id = #{channelId} AND is_active = 1
     </select>

backend-java/src/main/resources/mybatis/mapper/RestaurantMapper.xml

@@ -69,14 +69,20 @@
     </select>
 
     <select id="findVideoLinks" resultType="map">
-        SELECT v.video_id, v.title, v.url,
+        <!-- #356 — relevance 컬럼 SELECT + includeWeak 가드 -->
+        SELECT vr.id AS link_id,
+               v.video_id, v.title, v.url,
                TO_CHAR(v.published_at, 'YYYY-MM-DD"T"HH24:MI:SS') AS published_at,
                vr.foods_mentioned, vr.evaluation, vr.guests,
+               vr.relevance, vr.relevance_reason,
                c.channel_name, c.channel_id
         FROM video_restaurants vr
         JOIN videos v ON v.id = vr.video_id
         JOIN channels c ON c.id = v.channel_id
         WHERE vr.restaurant_id = #{restaurantId}
+        <if test="includeWeak == null or !includeWeak">
+            AND vr.relevance IN ('strong', 'unknown')
+        </if>
         ORDER BY v.published_at DESC
     </select>
 
@@ -315,4 +321,53 @@
         SELECT COUNT(*) FROM restaurants WHERE verified_at IS NULL
     </select>
 
+    <!-- ===== #356 영상-식당 관련도 ===== -->
+
+    <update id="updateLinkRelevance">
+        UPDATE video_restaurants
+        SET relevance = #{relevance},
+            relevance_reason = #{reason,jdbcType=VARCHAR},
+            relevance_evaluated_at = CURRENT_TIMESTAMP
+        WHERE id = #{linkId}
+    </update>
+
+    <select id="findLinkContext" resultType="map">
+        <!-- LLM 평가에 필요한 정보 -->
+        SELECT vr.id AS link_id, vr.foods_mentioned, vr.evaluation,
+               r.id AS restaurant_id, r.name AS restaurant_name, r.address, r.cuisine_type,
+               v.title AS video_title, c.channel_name
+        FROM video_restaurants vr
+        JOIN restaurants r ON r.id = vr.restaurant_id
+        JOIN videos v ON v.id = vr.video_id
+        JOIN channels c ON c.id = v.channel_id
+        WHERE vr.id = #{linkId}
+    </select>
+
+    <select id="findUnevaluatedLinks" resultType="map">
+        SELECT id AS link_id FROM video_restaurants
+        WHERE relevance_evaluated_at IS NULL
+        FETCH FIRST #{limit} ROWS ONLY
+    </select>
+
+    <select id="countUnevaluatedLinks" resultType="int">
+        SELECT COUNT(*) FROM video_restaurants WHERE relevance_evaluated_at IS NULL
+    </select>
+
+    <!-- #359 1단계 — google_place_id 중복 조회 (그룹 식당 + 참조 카운트) -->
+    <select id="findDuplicatePlaceIdRows" resultType="map">
+        SELECT r.id, r.google_place_id, r.name, r.address,
+               TO_CHAR(r.created_at, 'YYYY-MM-DD"T"HH24:MI:SS') AS created_at,
+               r.hidden,
+               (SELECT COUNT(*) FROM video_restaurants vr WHERE vr.restaurant_id = r.id) AS video_count,
+               (SELECT COUNT(*) FROM user_reviews rv WHERE rv.restaurant_id = r.id) AS review_count,
+               (SELECT COUNT(*) FROM user_memos mm WHERE mm.restaurant_id = r.id) AS memo_count
+        FROM restaurants r
+        WHERE r.google_place_id IN (
+            SELECT google_place_id FROM restaurants
+            WHERE google_place_id IS NOT NULL
+            GROUP BY google_place_id HAVING COUNT(*) > 1
+        )
+        ORDER BY r.google_place_id, r.created_at
+    </select>
+
 </mapper>

backend-java/src/main/resources/mybatis/mapper/ReviewMapper.xml

@@ -79,7 +79,8 @@
     </select>
 
     <select id="getAvgRating" resultType="map">
-        SELECT ROUND(AVG(rating), 1) AS avg_rating, COUNT(*) AS review_count
+        <!-- #294 — review 0건이면 AVG는 NULL → 클라이언트 NaN 처리 부담. NVL로 0.0 보장. -->
+        SELECT NVL(ROUND(AVG(rating), 1), 0) AS avg_rating, COUNT(*) AS review_count
         FROM user_reviews
         WHERE restaurant_id = #{restaurantId}
     </select>

backend-java/src/main/resources/mybatis/mapper/SearchMapper.xml

@@ -30,12 +30,13 @@
         JOIN video_restaurants vr ON vr.restaurant_id = r.id
         JOIN videos v ON v.id = vr.video_id
         WHERE r.latitude IS NOT NULL
-          AND (UPPER(r.name) LIKE UPPER(#{query})
+          <!-- #293 — ESCAPE 절로 사용자 입력의 %, _ 와일드카드 의도 우회 차단 -->
-               OR UPPER(r.address) LIKE UPPER(#{query})
+          AND (UPPER(r.name) LIKE UPPER(#{query}) ESCAPE '\'
-               OR UPPER(r.region) LIKE UPPER(#{query})
+               OR UPPER(r.address) LIKE UPPER(#{query}) ESCAPE '\'
-               OR UPPER(r.cuisine_type) LIKE UPPER(#{query})
+               OR UPPER(r.region) LIKE UPPER(#{query}) ESCAPE '\'
-               OR UPPER(vr.foods_mentioned) LIKE UPPER(#{query})
+               OR UPPER(r.cuisine_type) LIKE UPPER(#{query}) ESCAPE '\'
-               OR UPPER(v.title) LIKE UPPER(#{query}))
+               OR UPPER(vr.foods_mentioned) LIKE UPPER(#{query}) ESCAPE '\'
+               OR UPPER(v.title) LIKE UPPER(#{query}) ESCAPE '\')
         FETCH FIRST #{limit} ROWS ONLY
     </select>
 

backend-java/src/main/resources/mybatis/mapper/StatsMapper.xml

@@ -10,13 +10,13 @@
         WHEN NOT MATCHED THEN INSERT (visit_date, visit_count) VALUES (src.d, 1)
     </update>
 
-    <select id="getTodayVisits" resultType="int">
+    <select id="getTodayVisits" resultType="long">
         SELECT NVL(visit_count, 0)
         FROM site_visits
         WHERE visit_date = TRUNC(SYSDATE)
     </select>
 
-    <select id="getTotalVisits" resultType="int">
+    <select id="getTotalVisits" resultType="long">
         SELECT NVL(SUM(visit_count), 0)
         FROM site_visits
     </select>

deploy.sh

@@ -62,15 +62,18 @@ if [[ "$TARGET" == "all" || "$TARGET" == "frontend" ]]; then
   # Read build args from env or .env file
   MAPS_KEY="${NEXT_PUBLIC_GOOGLE_MAPS_API_KEY:-}"
   CLIENT_ID="${NEXT_PUBLIC_GOOGLE_CLIENT_ID:-}"
+  NAVER_MAP_ID="${NEXT_PUBLIC_NAVER_MAP_CLIENT_ID:-}"
 
   if [[ -f frontend/.env.local ]]; then
     MAPS_KEY="${MAPS_KEY:-$(grep NEXT_PUBLIC_GOOGLE_MAPS_API_KEY frontend/.env.local 2>/dev/null | cut -d= -f2)}"
     CLIENT_ID="${CLIENT_ID:-$(grep NEXT_PUBLIC_GOOGLE_CLIENT_ID frontend/.env.local 2>/dev/null | cut -d= -f2)}"
+    NAVER_MAP_ID="${NAVER_MAP_ID:-$(grep NEXT_PUBLIC_NAVER_MAP_CLIENT_ID frontend/.env.local 2>/dev/null | cut -d= -f2)}"
   fi
 
   docker build --platform "$PLATFORM" \
     --build-arg NEXT_PUBLIC_GOOGLE_MAPS_API_KEY="$MAPS_KEY" \
     --build-arg NEXT_PUBLIC_GOOGLE_CLIENT_ID="$CLIENT_ID" \
+    --build-arg NEXT_PUBLIC_NAVER_MAP_CLIENT_ID="$NAVER_MAP_ID" \
     -t "$REGISTRY/frontend:$TAG" \
     -t "$REGISTRY/frontend:latest" \
     frontend/

docs/design/279-frontend-restaurant-detail/fn-bottomsheet-snap.md

@@ -0,0 +1,54 @@
+<!-- 함수 설계서. 작성: [AI] Architect. -->
+
+# 함수 설계서: BottomSheet snap 정책 (#319)
+
+> **상태**: Approved <!-- Draft | Approved | Superseded -->
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #319 / 부모 #301 · 관련 컴포넌트: `frontend/src/components/BottomSheet.tsx`
+
+## 1. 책임
+
+모바일 BottomSheet의 **3-snap 점착(snap) 점**과 **닫힘 임계 속도**를 정의하고, 사용자의 드래그 제스처가 어느 snap에 안착할지 결정하는 알고리즘을 명세한다.
+
+## 2. 상수 (매직 넘버)
+
+| 상수 | 값 | 의미 |
+|------|----|------|
+| `SNAP_POINTS.PEEK` | `0.4` | 초기/맨 아래 snap. 화면 높이의 40%만 시트가 보임 — 지도와 시트를 함께 보는 균형. |
+| `SNAP_POINTS.HALF` | `0.55` | 중간 snap. 시트 콘텐츠 핵심(이름·평점·리뷰 첫 줄)이 잘 보이는 위치. |
+| `SNAP_POINTS.FULL` | `0.92` | 거의 풀 화면. 8% 여백은 상단 스와이프 핸들·상태바를 위해 남김. |
+| `VELOCITY_THRESHOLD` | `0.5` (vh/s) | 빠른 아래 스와이프 감지 기준. 초당 화면 높이의 50% 이상이면 "닫기 의도"로 간주. |
+| `CLOSE_BELOW_RATIO` | `0.6 × PEEK` ≈ 0.24 | snap 후보 중 PEEK의 60% 아래로 끌어내리면 강제 닫힘. |
+
+## 3. 결정 알고리즘 (`snapTo(height, velocity)`)
+
+```
+입력: height(현재 높이 ratio 0~1), velocity(아래 방향 vh/s, 양수=아래)
+
+1. velocity > VELOCITY_THRESHOLD && height < HALF  →  onClose()
+2. height < CLOSE_BELOW_RATIO                       →  onClose()
+3. 그 외: [PEEK, HALF, FULL] 중 height와 최단 거리인 점에 setHeight()
+```
+
+## 4. 왜 이 값들인가 (근거)
+
+- **0.4/0.55/0.92**: 모바일 UX 가이드(Material/iOS BottomSheet)의 30%/50%/95% 패턴을 한국 식당 카드 콘텐츠 길이(이름 18px + 평점 16px + 영상 썸네일 200px 기준)에 맞춰 조정.
+- **0.5 vh/s**: 일반 손가락 플릭 속도가 0.7~1.2 vh/s, 의도적인 닫기 스와이프 임계점.
+- **0.24 close-below**: PEEK(0.4)의 60% — 우발적 드래그(<0.05) 차단 + 의도적 닫기(<0.24) 수용.
+
+## 5. 변경 시 주의
+
+- 사용자의 근육 기억(스와이프 거리 감각) 교란 위험이 있어 SNAP_POINTS 변경은 ADR로 분리할 것.
+- VELOCITY_THRESHOLD를 낮추면 의도치 않은 닫힘 ↑, 높이면 닫기 어려움 ↑.
+
+## 6. 테스트 권고
+
+- `snapTo(0.45, 0.1)` → HALF로 안착
+- `snapTo(0.2, 0.7)` → onClose 호출
+- `snapTo(0.85, 0)` → FULL로 안착
+- `snapTo(0.1, 0)` → onClose 호출 (CLOSE_BELOW_RATIO)
+- 단위 테스트는 `utils/bottomSheetSnap.ts`로 함수 추출 후 #343에서 진행.
+
+## 7. 미해결 질문
+
+- 가로 모드 / 큰 폰트 접근성 모드에서 PEEK가 너무 작아 보이는 케이스 — 향후 동적 조정 검토.

docs/design/326-parsejson-optimization/README.md

@@ -0,0 +1,81 @@
+# 설계서: OciGenAiService.parseJson 단일 패스 최적화 (#326)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #326 · 부모: #292 (추출 파이프라인 Reviewer 후속, 09-Done)
+> · 구현 파일: `backend-java/src/main/java/com/tasteby/service/OciGenAiService.java`
+
+## 1. 목적 (Why)
+
+LLM 응답이 잘린(truncated) 배열일 때 `parseJson`의 복구 로직이 O(N²): 각 객체 시작점에서 `end`를 1씩 늘려가며 매번 `mapper.readValue(substring)`을 try. 8192 토큰 응답(약 30KB)에서 매우 비효율 + 매 try마다 Jackson 예외 객체 생성(스택트레이스 양산). brace depth counter로 단일 패스 O(N)으로 교체.
+
+## 2. 범위
+
+- **포함**: `parseJson`의 truncated-array 복구 로직을 brace depth counter로 변경.
+- **제외**: `parseJson`의 마크다운/콤마 정규식 전처리는 그대로. Jackson streaming API 도입은 추가 최적화이지만 본 범위 밖.
+
+## 3. 인수조건
+
+- [ ] 정상 JSON 배열 → 동일 결과 반환.
+- [ ] 잘린 배열(끝 `}` 누락) → 가능한 만큼 객체 추출 + 로그.
+- [ ] 문자열 안의 `{` `}` `"` (escape 포함) 잘못 카운트 안 됨.
+- [ ] 8192 token 응답 처리 시간 < 10ms (이전: 수백 ms 가능).
+- [ ] 회귀 없음 (기존 추출 파이프라인 시나리오 통과).
+
+## 4. 컨텍스트 & 제약
+
+- LLM 응답은 마크다운 + JSON 혼합 가능.
+- 응답 크기 최대 약 30KB (8192 token × 4 char/token).
+- mapper는 Jackson ObjectMapper.
+
+## 5. 아키텍처 개요
+
+```
+parseJson(raw)
+   ├ strip markdown/trailing commas (기존)
+   ├ try readValue(raw) → 성공 시 반환
+   └ truncated array 복구:
+        idx = '['의 다음
+        while idx < len:
+           skip whitespace, ','
+           if raw[idx] != '{': break  // 객체 아님
+           depth=0, inString=false, escaped=false
+           단일 패스로 객체 끝 (depth==0 && } 만남) 찾음
+           items.add(readValue(substring))
+           idx = 객체 끝 다음
+        return items
+```
+
+## 6. 함수 명세
+
+| 함수 | 책임 | 비고 |
+|------|------|------|
+| `parseJson(raw)` (수정) | brace depth + 단일 readValue | private 헬퍼 `findObjectEnd(raw, start)` 추출 |
+
+## 7. 흐름
+
+1. 기존 정규식 전처리.
+2. 전체 파싱 시도.
+3. 실패 + 배열 시작이면 위 알고리즘으로 객체 단위 복구.
+
+## 8. 엣지케이스
+
+- **빈 배열 `[]`**: 일반 readValue가 처리.
+- **문자열 안 `{` `}`**: inString 토글로 무시.
+- **escape `\"` `\\`**: escaped 토글로 무시.
+- **객체가 아닌 원시값 배열 `[1, 2, 3]`**: 첫 char가 `{`가 아니므로 break. 전체 파싱이 성공할 경우 도달 안 함.
+- **매우 짧은 응답**: 전체 파싱이 성공 → 복구 경로 미진입.
+
+## 9. 테스트
+
+- 정상 배열, 잘린 끝, 마크다운 wrap, escape 포함 5케이스 unit test (후속).
+
+## 10. 리스크 & 대안
+
+- **선택**: brace depth counter (단일 패스).
+- **대안 A**: Jackson `JsonParser` streaming API — 더 빠르지만 코드 복잡.
+- **대안 B**: 응답을 모두 받지 않고 streaming 파싱 — 본 범위 밖.
+
+## 11. 미해결 질문
+
+- LLM 응답에 객체 외 다른 타입 섞일 수 있는가? 현재 추출 결과는 `[{...}, {...}]` 형태로 가정.

docs/design/329-admin-split/README.md

@@ -0,0 +1,107 @@
+# 설계서: admin/page.tsx 분리 + 토큰/SSE 유틸 통일 (#329)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #329 · 부모: #304 (현행화 frontend-admin, 09-Done)
+> · 구현 파일: `frontend/src/app/admin/page.tsx`, `frontend/src/app/admin/_panels/*.tsx` (신규), `frontend/src/lib/admin-utils.ts`
+> · 테스트: 수동 (각 탭 진입 + 기존 시나리오 회귀)
+
+## 1. 목적 (Why)
+
+`admin/page.tsx`가 2817 LOC 단일 파일. 5개 패널이 같은 파일 안에 함께 있어 (a) 빌드 변경 시 무관한 패널까지 재빌드/재배포, (b) 코드 리뷰 시 충돌 가능성↑, (c) 로직 격리 어려움. 또한 `localStorage` 직접 호출 + SSE 파싱 코드 중복이 남아있어 #304 후속에서 한 번 더 정리.
+
+## 2. 범위 (Scope)
+
+- **포함**
+  - 5개 패널을 `app/admin/_panels/<Panel>.tsx`로 추출 (Next.js underscore prefix로 라우팅 제외).
+  - `page.tsx`는 탭 라우팅 + 헤더 + 패널 import만.
+  - 남은 `localStorage.getItem("tasteby_token")` 호출 → `getAdminToken()`/`authHeaders()` 교체.
+  - SSE 파싱 중복(약 5~6곳) → `consumeSseStream()` 활용.
+  - 공유 타입(`AdminUser`/`UserFavorite`/`UserReview`/`UserMemo`/`VideoSortKey`)을 _panels 파일 내부 또는 `api.ts`에 옮김(짧은 타입만).
+- **제외**
+  - 패널 내부 로직 변경 (state/effect 그대로).
+  - catch{/*ignore*/} 일괄 로깅 (별도 후속).
+  - ad-hoc 타입 캐스팅 정리 (별도 후속).
+  - 디자인 시스템 색상 통일.
+
+## 3. 인수조건
+
+- [ ] 5개 파일 신규: `_panels/{Channels,Videos,Restaurants,Users,Daemon}Panel.tsx`.
+- [ ] `page.tsx` < 200 LOC (이전 2817).
+- [ ] localStorage 직접 호출이 admin 페이지 내에 0건.
+- [ ] SSE reader 직접 호출(`response.body?.getReader()`)이 0건.
+- [ ] 모든 탭 진입 + 기존 시나리오 회귀 없음(빌드 통과 + 수동 smoke).
+- [ ] dev 빌드 + 운영 배포 성공.
+
+## 4. 컨텍스트 & 제약
+
+- Next.js 16 (App Router). `_` prefix 디렉토리는 route 제외.
+- `"use client"` 지시문 각 패널 파일 상단에 필요.
+- React Server Components 미사용 (모두 클라이언트 컴포넌트).
+- `useAuth()` 훅이 `auth-context`에 있음. 부모 `AdminPage`가 isAdmin 판정 후 prop으로 패널에 전달.
+- 패널 간 상태 공유 없음 (각각 독립).
+
+## 5. 아키텍처 개요
+
+```
+app/admin/
+  page.tsx                     ← 탭 라우팅 + 헤더 + CacheFlushButton + 패널 import
+  _panels/
+    ChannelsPanel.tsx          ← 214 LOC
+    VideosPanel.tsx            ← 1272 LOC (가장 큼)
+    RestaurantsPanel.tsx       ← 667 LOC
+    UsersPanel.tsx             ← 332 LOC
+    DaemonPanel.tsx            ← 223 LOC
+
+lib/admin-utils.ts (이미 존재)
+  ├─ getAdminToken()
+  ├─ authHeaders()
+  └─ consumeSseStream()
+```
+
+## 6. 함수 명세
+
+| 단위 | 책임 | 비고 |
+|------|------|------|
+| `page.tsx` (재작성) | 탭 라우팅 + 패널 import | < 200 LOC |
+| `_panels/*.tsx` (신규 5개) | 각 패널 로직 그대로 옮김 | "use client" |
+| `localStorage` 호출 (~10곳) | `getAdminToken()`/`authHeaders()`로 통일 | 의미 동일 |
+| SSE `getReader` (~5곳) | `consumeSseStream(resp, onEvent)`로 통일 | 의미 동일 |
+
+## 7. 흐름
+
+1. `_panels/` 디렉토리 생성.
+2. 각 패널 함수 + 그에 종속된 타입/상수를 `<Panel>Panel.tsx`로 잘라 옮김.
+3. 각 파일에 `"use client"` + import 추가.
+4. `localStorage.getItem("tasteby_token")` → `getAdminToken()` 일괄.
+5. SSE `getReader/decoder/buf.split/match` 패턴 → `consumeSseStream(resp, onEvent)` 일괄.
+6. `page.tsx` 재작성 — 탭 라우팅 + 패널 import.
+7. `npm run build`.
+8. `pm2 restart` 또는 `deploy.sh --frontend-only`.
+
+## 8. 엣지케이스
+
+- **순환 import**: 패널 간 의존 없음 → 안전.
+- **Type 중복**: `AdminUser` 등 패널 내부 타입은 그대로 옮김. 공유 타입은 `api.ts`에 있음.
+- **default export vs named**: 각 패널은 named export. `page.tsx`에서 `import { ChannelsPanel } from "./_panels/ChannelsPanel"`.
+- **빌드 크기**: 동일(코드 splitting은 별도 작업).
+
+## 9. 테스트
+
+- 빌드: `npm run build` 통과.
+- 수동:
+  - `/admin` 접근 → 5탭 모두 진입 가능.
+  - 채널 추가, 영상 강제 추출(SSE), 식당 검색/수정, 유저 권한 토글, 데몬 설정 변경 — 모두 정상.
+- 자동: 별도 후속(테스트 인프라 #343).
+
+## 10. 리스크 & 대안
+
+- **선택**: 5개 파일 추출 + 내부 로직 그대로.
+- **대안 A**: 추출 + 내부 리팩터링 동시 — 회귀 위험↑, 별도 후속이 안전.
+- **대안 B**: Atomic Design (atoms/molecules/organisms) — 큰 재구조화. 미루기.
+- **트레이드오프**: 외형은 동일, 유지보수성/충돌 가능성만 개선. 점진적 접근.
+
+## 11. 미해결 질문
+
+- 공통 panel layout(헤더/리스트/페이징) 추상화 — 후속.
+- VideosPanel 1272 LOC 내부 분할(상태 머신 + SSE 흐름 분리) — 별도 후속.

docs/design/331-vector-batch-insert/README.md

@@ -0,0 +1,81 @@
+# 설계서: VectorService batch insert + IdGenerator 공통화 (#331)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #331 · 부모: #293 (검색/벡터 Reviewer 후속, 09-Done)
+> · 구현 파일: `backend-java/src/main/java/com/tasteby/service/VectorService.java`
+> · 테스트: 본 이슈 범위 밖 (단위 테스트 인프라 도입은 #343 후속 묶음에 해당)
+
+## 1. 목적 (Why)
+
+`VectorService.saveRestaurantVectors`가 chunk N개를 N번의 단건 `jdbc.update`로 처리한다. 현재 `buildChunks`가 1개 청크만 반환해 N=1이지만, 향후 chunk 분할 도입 시 N+1 INSERT 비효율. 또한 UUID 생성 코드가 인라인 변환(`UUID.randomUUID().toString().replace("-", "").substring(0, 32).toUpperCase()`)으로 다른 곳의 `IdGenerator.newId()`와 중복.
+
+## 2. 범위
+
+- **포함**
+  - `jdbc.batchUpdate(sql, SqlParameterSource[])`로 단일 호출 전환.
+  - UUID 생성을 `IdGenerator.newId()` 공통 유틸로 교체.
+- **제외**
+  - 단위/통합 테스트 도입 (테스트 인프라 미도입 — 별도 후속 #343 묶음).
+  - `buildChunks`의 chunk 분할 로직 자체 변경 (현재 단일 청크 정책 유지).
+  - `restaurant_vectors` 스키마 변경.
+
+## 3. 인수조건
+
+- [ ] `saveRestaurantVectors`가 한 번의 `jdbc.batchUpdate` 호출로 N개 청크 삽입.
+- [ ] UUID 인라인 변환 제거 → `IdGenerator.newId()` 호출.
+- [ ] 회귀 없음 — 신규 식당 등록 시 `restaurant_vectors`에 정상 row 추가.
+- [ ] N=0 가드(`chunks.isEmpty()`)는 유지.
+
+## 4. 컨텍스트 & 제약
+
+- Spring `NamedParameterJdbcTemplate.batchUpdate(String, SqlParameterSource[])` 사용.
+- Oracle VECTOR 타입 파라미터는 `float[]`로 그대로 바인딩 가능 (`MapSqlParameterSource.addValue`).
+- 한 batch 안 `int[]` 반환 → batch 결과 카운트는 사용하지 않음(throw if 어쩌고 미적용).
+- `IdGenerator.newId()` 시그니처: `public static String newId()` → 32-char uppercase hex (현재 인라인과 동일).
+
+## 5. 아키텍처 개요
+
+```
+saveRestaurantVectors(restaurantId, chunks)
+   ├ if chunks.isEmpty() → return
+   ├ embeddings = genAi.embedTexts(chunks)
+   ├ params[] = build N개 MapSqlParameterSource
+   │      .addValue("id", IdGenerator.newId())
+   │      .addValue("rid", restaurantId)
+   │      .addValue("chunk", chunks.get(i))
+   │      .addValue("emb", float[] embeddings[i])
+   └ jdbc.batchUpdate(sql, params)
+```
+
+## 6. 함수 명세
+
+| 함수 | 책임 | 비고 |
+|------|------|------|
+| `VectorService.saveRestaurantVectors(id, chunks)` (수정) | batchUpdate 1회 | IdGenerator 사용 |
+
+## 7. 흐름
+
+1. embed 호출 (기존).
+2. `SqlParameterSource[]` 생성.
+3. `jdbc.batchUpdate(sql, params)` 단일 호출.
+
+## 8. 엣지케이스
+
+- **chunks 빈 배열**: 조기 return (기존 유지).
+- **embed 결과와 chunks 크기 불일치**: 현재 OCI GenAI는 입력 N → 출력 N 보장. 안전 가드 추가는 본 범위 밖 (필요 시 후속).
+
+## 9. 테스트 (수동만)
+
+- dev에서 신규 식당 등록(데몬 또는 수동 trigger) → `SELECT count(*) FROM restaurant_vectors WHERE restaurant_id = '...'` 정상 row 확인.
+
+## 10. 리스크 & 대안
+
+- **선택**: `NamedParameterJdbcTemplate.batchUpdate`. 단일 트랜잭션 + 단일 round-trip.
+- **대안 A**: `JdbcTemplate.batchUpdate(BatchPreparedStatementSetter)` — 더 저수준이지만 named param 손실.
+- **대안 B**: MERGE로 upsert — 동일 restaurant_id 재처리 시 중복 제거 가능. 다만 본 이슈 범위 밖.
+
+## 11. 미해결 질문
+
+- chunk 분할 정책(현재 1개 단일 청크) — 후속 (검색 정확도 vs 토큰 비용 트레이드오프 결정).
+- batchUpdate 결과 row 수 검증 — 운영 모니터링 도구 도입 후 결정.

docs/design/332-restaurant-update-whitelist/README.md

@@ -0,0 +1,94 @@
+# 설계서: Restaurant 임의 필드 업데이트 화이트리스트 (#332)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #332 · 부모: #290 (식당 CRUD Reviewer 후속, 09-Done)
+> · 구현 파일: `backend-java/src/main/java/com/tasteby/controller/RestaurantController.java`, `backend-java/src/main/java/com/tasteby/service/RestaurantService.java`
+> · 테스트: 수동 (curl로 화이트리스트 외 필드 시도)
+
+## 1. 목적 (Why)
+
+`PUT /api/restaurants/{id}` body가 `Map<String, Object>`로 임의 키를 받는다. SQL 측 `updateFields`는 컬럼별 `<if test="containsKey('...')">` 가드로 화이트리스트가 이미 적용되어 있어 임의 컬럼 갱신은 차단된다. 다만 Controller 레벨에서 화이트리스트가 명시되지 않아 — (a) 의도 모호, (b) 향후 SQL 측 가드가 무력화되거나 다른 매퍼로 확장되면 위험. 명시적 화이트리스트로 의도 강화.
+
+## 2. 범위 (Scope)
+
+- **포함**
+  - `RestaurantController.update(id, body)`에서 허용된 키만 통과시키는 `ALLOWED_UPDATE_FIELDS` set.
+  - 허용되지 않은 키는 무시(silently drop) + 디버그 로그. 400 응답은 hard policy라 사용자 경험 영향 큼.
+- **제외 (out of scope)**
+  - DTO 클래스 도입 (RestaurantUpdateDTO + Bean Validation) — 더 강한 표준화지만 코드 영향 큼. 후속.
+  - DDG HTML 검색 → 정식 API 전환 (별도 후속, 비용/계약 결정 필요).
+  - isNameSimilar 한국어 자모 알고리즘 (별도 후속).
+  - UNIQUE(google_place_id) 제약 강화 (DB 마이그레이션 + 데이터 정리 필요, 별도).
+
+## 3. 인수조건
+
+- [ ] `ALLOWED_UPDATE_FIELDS` 상수 정의 (SQL `updateFields` 가드와 일치).
+- [ ] PUT 호출 시 body에서 허용 외 키는 자동 제거 + 디버그 로그.
+- [ ] 허용 키만 있는 정상 호출 → 200 정상 동작 회귀 없음.
+- [ ] 허용 외 키만 있는 호출 → 200 + 변경 없음 (또는 200 + 빈 업데이트).
+
+## 4. 컨텍스트 & 제약
+
+- Spring MVC. 변경 최소화. DTO 도입 없이도 가드 가능.
+- 운영 영향 없음 (어드민이 화면에서 호출하는 키는 모두 허용 set 안에).
+- 가정: 화이트리스트 set은 SQL `updateFields` 의 `<if>` 키들과 1:1.
+
+## 5. 아키텍처 개요
+
+```
+PUT /api/restaurants/{id}  body
+        │
+        ▼
+RestaurantController.update
+   ├ requireAdmin
+   ├ allowed = ALLOWED_UPDATE_FIELDS
+   ├ filtered = body where key ∈ allowed
+   ├ if (filtered.isEmpty()) → 200 + no-op
+   └ restaurantService.update(id, filtered) → mapper.updateFields
+```
+
+## 6. 데이터 모델
+
+`Set<String> ALLOWED_UPDATE_FIELDS = Set.of(name, address, region, cuisine_type, price_range, phone, website, tabling_url, catchtable_url, latitude, longitude, google_place_id, business_status, rating, rating_count)` — SQL `updateFields`의 키들과 일치.
+
+## 7. 함수 명세
+
+| 함수 | 책임 | 비고 |
+|------|------|------|
+| `RestaurantController.update(id, body)` (수정) | 화이트리스트 필터 후 위임 | filtered.isEmpty()면 no-op |
+
+## 8. 흐름
+
+1. body Map 수신.
+2. `body.entrySet().stream().filter(e -> ALLOWED_UPDATE_FIELDS.contains(e.getKey())).collect(toMap)`.
+3. 비어있으면 200 응답하고 끝.
+4. 아니면 `restaurantService.update(id, filtered)` 호출.
+
+## 9. 엣지케이스
+
+- **빈 body**: 200 + no-op.
+- **허용 외 키만**: 200 + no-op + 디버그 로그.
+- **null 값을 포함한 허용 키**: SQL `updateFields`가 그대로 NULL 저장 — 의도된 동작 (좌표/주소 해제 등).
+
+## 10. 테스트
+
+- 수동:
+  ```
+  curl -X PUT -H "Authorization: Bearer <admin>" -H "Content-Type: application/json" \
+       -d '{"name":"테스트", "is_admin":true}' /api/restaurants/<id>
+  → name만 갱신, is_admin은 무시
+  ```
+- 자동: 별도 후속(통합 테스트 인프라 도입 시).
+
+## 11. 리스크 & 대안
+
+- **선택**: Controller 화이트리스트 set + silent drop.
+- **대안 A**: DTO + Bean Validation — 표준화 깔끔하지만 변경 범위 큼.
+- **대안 B**: 허용 외 키 발견 시 400 — 사용자 경험 부담, 클라이언트가 잘못된 키 보내면 즉시 실패. 본 변경은 보수적으로 silent drop.
+
+## 12. 미해결 질문
+
+- DDG → 정식 검색 API 전환 — 별도 후속 (비용/계약 결정).
+- isNameSimilar 한국어 알고리즘 — 별도 후속.
+- DTO 도입 표준화 — 별도 후속.

docs/design/335-daemon-distributed-lock/README.md

@@ -0,0 +1,104 @@
+# 설계서: 데몬 스케줄러 분산 락 (#335)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #335 · 부모: #275 (현행화 backend-daemon, 09-Done)
+> · 구현 파일: `backend-java/build.gradle`, `backend-java/src/main/java/com/tasteby/TastebyApplication.java`, `backend-java/src/main/java/com/tasteby/config/ShedLockConfig.java` (신규), `backend-java/src/main/java/com/tasteby/service/DaemonScheduler.java`
+> · 테스트: 수동 (롤링 업데이트 시 두 파드 공존 시뮬레이션)
+
+## 1. 목적 (Why)
+
+OKE 운영에서 backend Pod 1개로 동작하지만 RollingUpdate(maxSurge>0) 시 신·구 Pod이 잠시 공존. 또한 dev(PM2)와 운영이 같은 Oracle ATP를 공유 — 이미 `DAEMON_ENABLED` 플래그로 dev 폴링은 차단했지만, 운영 자체에서 두 Pod이 같은 30초 주기로 `scanAllChannels`를 호출하면 YouTube/OCI GenAI 중복 호출 + 동일 영상 두 번 처리 + 봇 감지 위험. ShedLock으로 한 인스턴스만 실행하도록 보장.
+
+## 2. 범위 (Scope)
+
+- **포함**
+  - `DaemonScheduler.run()`을 분산 락으로 보호 (lockAtMostFor + lockAtLeastFor).
+  - Lock provider: Redis (이미 운영 중인 in-cluster Redis 재사용).
+  - 의존성: `net.javacrumbs.shedlock:shedlock-spring`, `shedlock-provider-redis-spring`.
+- **제외 (out of scope)**
+  - 다른 @Scheduled 메서드(CacheService.checkHealth, 향후 추가될 cron). 필요 시 같은 패턴으로 확장.
+  - 락 획득 실패 시 알람 — Spring Actuator/Micrometer 도입 후 후속.
+  - DB 기반 lock provider (JDBC) — Redis가 충분.
+
+## 3. 인수조건
+
+- [ ] build.gradle에 shedlock-spring + shedlock-provider-redis-spring 추가.
+- [ ] `@EnableSchedulerLock` 활성화.
+- [ ] `DaemonScheduler.run`에 `@SchedulerLock(name="daemon-runner", ...)` 적용.
+- [ ] 락 키는 `lock:daemon-runner` 형태로 Redis에 저장 (prefix 기본).
+- [ ] 운영 배포 후 로그에 lock acquire/release 메시지 또는 정상 동작 확인.
+- [ ] 회귀 없음 — 자동 cron 정상 동작.
+
+## 4. 컨텍스트 & 제약
+
+- Redis는 in-cluster 단일 인스턴스. ShedLock의 Redis provider는 단일 인스턴스에서 SET NX EX로 동작.
+- Pod 1개 운영이라 평소엔 락 경합 없음 → ShedLock 부하 미미 (Redis 1회 SET NX EX, <1ms).
+- `lockAtMostFor`: 락이 강제로 해제되기까지 시간. `scanAllChannels`는 channel 6 × 영상 fetch 시간 ≈ 최대 10분 예상. `PT15M`로 안전 마진.
+- `lockAtLeastFor`: 작업이 빨리 끝나도 락 유지하는 최소 시간 (다음 cron이 즉시 잡지 못하게). 30초 cycle이라 PT30S로 충분.
+
+## 5. 아키텍처 개요
+
+```
+[Pod A]                    [Pod B]
+   │                          │
+   │ @Scheduled(fixedDelay=30s)
+   ▼                          ▼
+DaemonScheduler.run         DaemonScheduler.run
+   │                          │
+   │ @SchedulerLock           │ @SchedulerLock
+   ▼                          ▼
+LockProvider (Redis)
+   ├─ SET lock:daemon-runner EX 900 NX  ✓ → Pod A 진행
+   └─ SET lock:daemon-runner EX 900 NX  ✗ → Pod B 즉시 종료(no-op)
+   │
+   ▼
+scanAllChannels / processPending 실행 (A만)
+   │
+   ▼ 종료 시 락 키 lockUntil 시각으로 갱신 (lockAtLeastFor 보장)
+```
+
+## 6. 데이터 모델
+
+Redis 키 1개:
+- key: `lock:daemon-runner`
+- value: lockedBy(host:pid) + lockedAt
+- expiry: lockAtMostFor
+
+## 7. 함수 명세
+
+| 함수 | 책임 | 시그니처 | 비고 |
+|------|------|----------|------|
+| `DaemonScheduler.run()` (수정) | @SchedulerLock 추가 | 기존 | name="daemon-runner" |
+| `ShedLockConfig.lockProvider(...)` (신규) | Bean 등록 | `LockProvider lockProvider(RedisConnectionFactory)` | Redis provider |
+
+## 8. 흐름
+
+1. 30초마다 fixedDelay로 run() 호출.
+2. ShedLock AOP가 SET NX EX 시도.
+3. 성공: 본문 실행. 실패: 즉시 반환(no-op).
+4. 본문 종료 시 lockUntil 갱신.
+
+## 9. 엣지케이스
+
+- **lockAtMostFor 초과 작업**: 락 자동 해제 후 다른 Pod이 잡을 수 있음. scanAllChannels가 15분 넘기지 않게 channel별 timeout 적용 권고(설계서 #275 §11 참고).
+- **Pod 죽음**: lockAtMostFor 만료 후 자동 해제.
+- **Redis 다운**: SET 실패 → Spring AOP가 RuntimeException → 다음 30초에 재시도. 캐시 disabled와 별개.
+- **clock skew**: ShedLock은 Redis 서버 시간 기준이라 클러스터 노드 간 시간 차이 무관.
+
+## 10. 테스트 계획
+
+- 수동: Pod 2개 동시 실행 (kubectl scale deploy backend --replicas=2) 후 로그에서 한 쪽만 `Running scheduled channel scan...` 찍히는지 확인.
+- 자동: 후속 (ShedLock 자체는 lib 차원에서 테스트됨).
+
+## 11. 리스크 & 대안
+
+- **선택**: ShedLock + Redis.
+- **대안 A**: Redis SET NX EX 수동 구현 — 가능하나 ShedLock이 lockAtMostFor/lockAtLeastFor 자동 처리해서 더 안전.
+- **대안 B**: DB(Oracle) 기반 ShedLock — 추가 테이블 필요 + DB 부하. Redis가 더 단순.
+- **대안 C**: 단일 leader pod (k8s Lease object) — Spring Cloud Kubernetes 도입 부담 크다.
+
+## 12. 미해결 질문
+
+- ShedLock 의존성이 standard library가 아닌 4th-party에 가까움 — 검증된 라이브러리(8년+ 사용, 4k+ stars)지만 향후 Spring 마이크로 버전 호환성은 별도 모니터링.
+- CacheService.checkHealth는 락 안 걸어도 됨(idempotent). 추가 cron 도입 시 same name 충돌 주의.

docs/design/336-cache-scan-recovery/README.md

@@ -0,0 +1,162 @@
+# 설계서: 캐시 SCAN/UNLINK + disabled 자동 복구 + 에러 메트릭 (#336)
+
+> **상태**: Approved <!-- Draft | Approved | Superseded -->
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #336 · 부모: #276 (현행화 backend-cache, 09-Done)
+> · 구현 파일: `backend-java/src/main/java/com/tasteby/service/CacheService.java`, `backend-java/src/main/java/com/tasteby/controller/AdminCacheController.java`
+> · 테스트: 후속 (Testcontainers Redis 인프라는 별도)
+
+## 1. 목적 (Why)
+
+`CacheService.flush()`가 `redis.keys("tasteby:*")` 블로킹 명령을 사용해 키가 많아지면 Redis 인스턴스 전체가 정지(Redis는 single-threaded). 또한 생성자에서 한 번 ping 실패하면 `disabled=true`로 영구 no-op 상태 — Redis가 재기동되어도 자동 복구 안 됨. 그리고 set/get/flush 실패가 DEBUG 로그로만 묻혀 운영 monitoring 사각지대.
+
+## 2. 범위 (Scope)
+
+- **포함**
+  - `flush()`/추후 `flushByPrefix()`를 `SCAN` + `UNLINK`(논블로킹 삭제)로 교체.
+  - 30초 주기 헬스체크로 `disabled` 플래그 자동 토글 (Redis 재기동 시 자동 복구).
+  - 캐시 에러 카운터(in-memory `AtomicLong`)와 마지막 에러 메시지를 노출하는 admin 엔드포인트.
+- **제외 (out of scope)**
+  - Micrometer/Prometheus 메트릭 stack 도입(별도 이슈, Spring Boot Actuator + 별도 인프라).
+  - Testcontainers Redis 기반 단위 테스트(별도 후속, 인프라 도입 비용 큼).
+  - 캐시 key 네임스페이스 다중화.
+
+## 3. 인수조건 (Acceptance Criteria)
+
+- [ ] `flush()`가 `KEYS` 대신 SCAN 커서 기반으로 동작한다 (블로킹 없음).
+- [ ] 삭제는 `UNLINK`(Redis 4.0+ 논블로킹) 사용. 미지원 환경에서는 `DEL`로 폴백.
+- [ ] Redis가 다운된 상태에서 startup → `disabled=true`. 이후 Redis 재기동되면 60초 이내 `disabled=false`로 자동 복구되어 set/get 정상 동작한다.
+- [ ] set/get/flush/del의 예외는 `cacheErrorCount` 카운터가 증가하고 `lastError`에 메시지를 기록한다.
+- [ ] `GET /api/admin/cache/stats` 가 `{ disabled, errorCount, lastError }` 응답.
+- [ ] 기존 캐시 동작(hit/miss/TTL) 회귀 없음.
+- [ ] 운영 배포 후 외부 `/api/restaurants` 응답이 캐시 hit 경로에서 변함없이 동작.
+
+## 4. 컨텍스트 & 제약
+
+- Spring Data Redis 3.x + Lettuce 클라이언트.
+- 운영 Redis: OKE in-cluster (단일 인스턴스, persistence X). UNLINK 지원.
+- 키 prefix: `tasteby:`. 현재 키 개수는 수십~수백 (식당/검색/채널 캐시), 향후 수만으로 증가 가능성.
+- 30초 헬스체크 추가 부하 미미(ping 한 번 = 0.5ms 이하).
+- 가정: `StringRedisTemplate.execute(RedisCallback)`에서 native `ScanOptions` + `RedisServerCommands.scan()` 사용 가능.
+
+## 5. 아키텍처 개요
+
+```
+[ Spring Context ]
+        │
+        ▼
+   CacheService
+   ├─ disabled : volatile boolean  (자동 토글)
+   ├─ errorCount : AtomicLong
+   ├─ lastError : volatile String
+   │
+   ├─ get/set/del/flush
+   │      └─ try {} catch { errorCount.incrementAndGet(); lastError = ...; }
+   │
+   ├─ flush()  ⟶  redis.execute(connection -> {
+   │                  ScanOptions opt = match("tasteby:*").count(500);
+   │                  while (cursor.hasNext()) keys.add(cursor.next());
+   │                  if (!keys.isEmpty()) connection.keyCommands().unlink(keys);
+   │              })
+   │
+   └─ @Scheduled(fixedDelay=30_000)
+      checkHealth()
+        ├ try { ping } → disabled = false (회복)
+        └ catch → disabled = true (또는 유지)
+
+AdminCacheController
+   └─ GET /api/admin/cache/stats → { disabled, errorCount, lastError }
+```
+
+I/O ↔ 순수 로직 경계: SCAN 루프는 Redis 통신이지만 결과 처리는 단순 `for` 루프. 헬스체크는 단일 ping. 에러 기록은 atomic.
+
+## 6. 데이터 모델
+
+| 필드 | 타입 | 의미 |
+|------|------|------|
+| `disabled` | `volatile boolean` | 캐시 일시 비활성 (Redis 다운 시 true) |
+| `errorCount` | `AtomicLong` | 누적 에러 횟수 (set/get/flush/del 통합) |
+| `lastError` | `volatile String` | 최근 에러 메시지 (운영 디버깅용) |
+
+응답 DTO:
+```json
+{ "disabled": false, "errorCount": 0, "lastError": null }
+```
+
+## 7. 함수 명세
+
+| 함수 | 책임(1줄) | 시그니처 | 입력 | 출력 | 에러 | 복잡? |
+|------|-----------|----------|------|------|------|-------|
+| `CacheService.flush()` (수정) | SCAN+UNLINK 기반 prefix 삭제 | `void flush()` | - | side-effect | recordError() | **복잡** |
+| `CacheService.checkHealth()` (신규) | 30초마다 ping → disabled 토글 | `void checkHealth()` (@Scheduled) | - | side-effect | disabled=true 유지 | 단순 |
+| `CacheService.recordError(op, e)` (신규) | 카운터 증가 + lastError 기록 | `void recordError(String, Exception)` | op, e | side-effect | - | 단순 |
+| `CacheService.getStats()` (신규) | 외부 노출용 stats | `CacheStats getStats()` | - | DTO | - | 단순 |
+| `AdminCacheController.stats()` (신규) | GET endpoint | `Map stats()` | - | DTO | requireAdmin | 단순 |
+
+## 8. 흐름 / 알고리즘
+
+### flush (SCAN + UNLINK)
+```
+batch = 500 (한 번에 받는 키 수)
+keys = []
+redis.execute(conn ->
+   try (Cursor<byte[]> cursor = conn.keyCommands().scan(ScanOptions.scanOptions().match("tasteby:*").count(batch).build())) {
+     while (cursor.hasNext()) keys.add(new String(cursor.next()));
+   }
+   if (!keys.isEmpty()) conn.keyCommands().unlink(keys.toArray(byte[][]));
+   return null;
+)
+```
+
+### 헬스체크
+```
+@Scheduled(fixedDelay = 30_000)
+void checkHealth() {
+   if (DAEMON_ENABLED env가 false면 dev에서 노이즈 피해 skip 가능 — 단, 캐시 헬스체크는 데몬 플래그와 무관하니 항상 실행)
+   try (conn = factory.getConnection()) {
+     conn.ping();
+     if (disabled) { log.info("Redis recovered"); disabled = false; }
+   } catch (Exception e) {
+     if (!disabled) { log.warn("Redis lost: {}", e); disabled = true; }
+   }
+}
+```
+
+### 에러 기록
+```
+catch (Exception e) {
+   errorCount.incrementAndGet();
+   lastError = op + ": " + e.getMessage();
+   log.warn("Cache {} error (count={}): {}", op, errorCount.get(), e.getMessage());
+}
+```
+
+## 9. 엣지케이스 & 에러 처리
+
+- **SCAN 중 다른 스레드가 키 추가/삭제**: SCAN의 best-effort 보장상 일부 키 누락 가능. flush의 자연 무효화(TTL)와 함께 작동하면 영향 미미.
+- **UNLINK 미지원 Redis(2.x)**: Spring Data Redis가 fallback하지 않으므로 `DEL`로 명시 폴백. 운영 Redis는 6.x라 미지원 가능성 거의 없음.
+- **헬스체크와 set/get 동시 호출**: volatile + atomic 사용. race 가능하지만 영향 작음 (잠시 후 보정).
+- **로그 폭주**: 같은 에러가 매번 발생하면 WARN 로그가 폭주 — 운영에서 모니터링 후 throttle 검토 (후속).
+- **fixedDelay=30s 가 너무 잦은가**: ping은 0.5ms 미만이라 무해.
+
+## 10. 테스트 계획
+
+- 수동:
+  - dev에서 Redis 임시 중단(`pm2 stop redis` 등) → 60초 후 `/api/admin/cache/stats` 의 disabled=true 확인.
+  - Redis 재기동 → 60초 이내 disabled=false 자동 복구 확인.
+  - `/api/restaurants` 호출로 캐시 set/get 작동 확인.
+- 자동: Testcontainers Redis 기반 단위 테스트는 별도 후속.
+
+## 11. 리스크 & 대안 검토
+
+- **선택**: SCAN + UNLINK + @Scheduled 헬스체크.
+- **대안 A**: TTL만 의존(flush 폐기) — 단순하지만 즉시 무효화 불가, 어드민 강제 무효화 시나리오 손상.
+- **대안 B**: Redis 6.0+의 `FLUSHDB ASYNC` — 더 단순하지만 prefix 격리 안 됨(다른 앱이 같은 Redis 공유 시 위험). tasteby Redis는 전용이라 가능하지만 일반화 위해 SCAN/UNLINK 채택.
+- **대안 C**: Lettuce native `RedisAsyncCommands.scan` 직접 사용 — 더 빠르지만 추상화 레벨 낮춤.
+- **트레이드오프**: SCAN은 N개 키마다 cursor 왕복 발생 → flush 1회 latency 증가(키 1만 개 기준 ~50ms). 비동기 UNLINK로 삭제는 빠름.
+
+## 12. 미해결 질문
+
+- Micrometer 메트릭(JVM/캐시) 도입 시 errorCount를 prom으로 export — 별도 후속.
+- Redis sentinel/cluster 도입 시 헬스체크 의미 재정의 — 현재 단일 인스턴스라 무관.
+- `lastError` 노출이 운영자에게 충분한가, 또는 sliding window가 필요한가 — 운영 24h 관찰 후 결정.

docs/design/337-stats-bot-ratelimit/README.md

@@ -0,0 +1,114 @@
+# 설계서: 통계 방문 카운트 봇 필터 + 레이트리밋 (#337)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #337 · 부모: #274 (현행화 backend-stats, 09-Done)
+> · 구현 파일: `backend-java/build.gradle`, `backend-java/src/main/java/com/tasteby/controller/StatsController.java`, `backend-java/src/main/java/com/tasteby/util/BotDetector.java` (신규), `backend-java/src/main/java/com/tasteby/service/RateLimitService.java` (신규)
+> · 테스트: 수동 (curl로 봇 UA + 같은 IP 다중 호출)
+
+## 1. 목적 (Why)
+
+`POST /api/stats/visit`이 인증 없이 누구나 호출 가능 + 봇/크롤러 필터 없음 → (a) 일반 봇이 사이트 인덱싱하면서 카운터 인플레이션, (b) 악의적 새로고침 어뷰즈로 통계 왜곡. 또한 페이지 로드마다 DB write QPS 증가 — 클라이언트 어뷰즈에 취약.
+
+## 2. 범위 (Scope)
+
+- **포함**
+  - User-Agent 기반 봇 패턴 필터 (Googlebot, bingbot, crawler 등 일반 패턴).
+  - IP 기반 레이트리밋: 같은 IP에서 1분에 1회만 카운트 (Bucket4j + Redis).
+  - X-Forwarded-For 헤더 우선 (Nginx Ingress 뒤이므로).
+  - 봇/리밋 초과: 200 응답하되 카운터 미증가 (사용자 경험 영향 X).
+- **제외 (out of scope)**
+  - WAF 수준 봇 차단 (Cloudflare 등).
+  - UU(고유 방문자) — 별도 후속 (쿠키/세션).
+  - Redis INCR 기반 비동기 통계 (DB write 분리) — 별도 후속.
+
+## 3. 인수조건
+
+- [ ] build.gradle에 bucket4j-redis 추가.
+- [ ] User-Agent에 'bot'/'crawler'/'spider' 포함 시 카운트 skip + 디버그 로그.
+- [ ] 같은 IP에서 60초 안에 두 번째 visit 호출 시 카운트 skip.
+- [ ] 응답은 항상 `{ "ok": true, "counted": bool }` 형태.
+- [ ] 봇/리밋 초과 호출도 200 응답 (사용자 페이지 로드 지장 X).
+- [ ] 운영 배포 후 회귀 없음 — 통계 카운터가 정상 증가.
+
+## 4. 컨텍스트 & 제약
+
+- Bucket4j 8.x + Redis backend (Lettuce 호환).
+- 메모리만 사용하는 경우(단일 파드) ConcurrentLinkedHashMap도 가능하나 ShedLock 사례처럼 멀티 파드 미래 대비 Redis.
+- 운영 트래픽 작아 Bucket4j 부하 미미.
+- 1분 1회 정책은 동일 IP에서 사용자가 페이지 새로고침해도 영향 작음. 너무 빡빡하면 다중 사용자 NAT(회사/카페) 영향 → 1분/IP는 균형.
+
+## 5. 아키텍처 개요
+
+```
+사용자 페이지 로드
+   │
+   ▼  POST /api/stats/visit  (X-Forwarded-For: client-ip)
+StatsController.recordVisit(req)
+   │
+   ├─ BotDetector.isBot(userAgent) → skip
+   │
+   ├─ RateLimitService.tryConsume(clientIp) → false면 skip
+   │
+   ▼
+StatsService.recordVisit() → DB MERGE
+```
+
+## 6. 데이터 모델
+
+Redis 키:
+- `bucket4j:visit:<ip>` — Bucket4j가 자동 관리 (token bucket state)
+
+응답:
+```json
+{ "ok": true, "counted": true }   // 정상 카운트
+{ "ok": true, "counted": false }  // 봇/리밋 초과
+```
+
+## 7. 함수 명세
+
+| 함수 | 책임 | 시그니처 | 비고 |
+|------|------|----------|------|
+| `BotDetector.isBot(ua)` | UA 문자열 봇 패턴 매칭 | `static boolean isBot(String)` | 순수 함수 |
+| `RateLimitService.tryConsume(key)` | Bucket4j 1 토큰 소비 | `boolean tryConsume(String)` | Bucket 1/min |
+| `StatsController.recordVisit(req)` (수정) | 봇 + IP 필터 후 카운트 | `@PostMapping("/visit")` | request 헤더 활용 |
+
+## 8. 흐름
+
+1. POST `/api/stats/visit` 진입.
+2. `X-Forwarded-For` 우선 → 없으면 `request.getRemoteAddr()`.
+3. User-Agent 검사 (`isBot` true면 counted=false).
+4. IP 레이트 검사 (`tryConsume` false면 counted=false).
+5. 통과 시 `recordVisit()` 호출.
+6. 응답 `{ok:true, counted: ...}`.
+
+## 9. 엣지케이스
+
+- **여러 IP가 헤더에 chain**: X-Forwarded-For 첫 번째(원본 클라이언트) 사용.
+- **헤더 위조**: Nginx Ingress 뒤라 외부 위조는 어렵지만, 신뢰는 가정.
+- **Redis 다운**: Bucket4j Redis 에러 → fail open(즉, counted=true 진행). 통계는 약간 부풀지만 사용자 경험 우선.
+- **빈 UA**: 봇 판정 안 함 (정상 모바일 앱일 수도).
+
+## 10. 테스트
+
+- 수동:
+  ```
+  curl -X POST -H "User-Agent: Googlebot/2.1" https://www.tasteby.net/api/stats/visit
+  → counted=false
+  curl -X POST -H "User-Agent: Mozilla/5.0" https://www.tasteby.net/api/stats/visit
+  → counted=true
+  (즉시 재호출) → counted=false (rate limit)
+  ```
+
+## 11. 리스크 & 대안
+
+- **선택**: Bucket4j + Redis backend + UA 정규식.
+- **대안 A**: 메모리 LRU만 사용 — 단일 파드는 OK, 멀티 파드는 어뷰즈 가능.
+- **대안 B**: Nginx Ingress에서 rate limit — 인프라 분리 깔끔. 다만 봇 UA 필터는 ingress nginx 모듈 추가 부담, 어플리케이션 가시성↓.
+- **대안 C**: 비동기 큐(@Async 또는 Redis INCR) — DB write 부담 해소. 본 이슈는 어뷰즈 차단이 우선이라 후속으로 분리.
+
+## 12. 미해결 질문
+
+- UU(쿠키 기반 고유 방문자) — 별도 후속 (#274 후속 #337의 잔여 항목으로 분리).
+- Bucket4j 1분 정책의 적정성 — 운영 1주일 관찰 후 조정.
+- 봇 UA 화이트리스트(친화적 검색 엔진은 카운트 포함?) — 현재 일괄 skip.

docs/design/343-frontend-test-infra/README.md

@@ -0,0 +1,117 @@
+# 설계서: RTL/Jest 인프라 + next/image + ARIA Tabs (#343)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #343 · 부모: #281 (현행화 frontend-review-memo, 09-Done)
+> · 구현 파일: `frontend/package.json`, `frontend/jest.config.ts` (신규), `frontend/jest.setup.ts` (신규), `frontend/next.config.ts`, `frontend/__tests__/*` (신규), `frontend/src/components/MyReviewsList.tsx`, `frontend/src/components/ReviewSection.tsx`
+> · 테스트: 본 이슈가 테스트 인프라 자체를 도입
+
+## 1. 목적 (Why)
+
+본 프로젝트는 지금까지 자동화된 단위 테스트가 0건. 누적된 "후속 테스트" 항목이 12+개(StatsService/CacheService/SearchService/Stars/HangulSimilarity 등)이며, 그동안 분리된 후속 이슈를 처리할 인프라가 없어 모두 보류 상태. 본 이슈에서 Jest + RTL 인프라 도입 + next/image 적용 + ARIA Tabs 보강.
+
+## 2. 범위 (Scope)
+
+- **포함**
+  - Jest 30 + `next/jest` 자동 설정 + `@testing-library/react` + `@testing-library/jest-dom`.
+  - `jest.config.ts`, `jest.setup.ts`, `package.json scripts: test, test:watch`.
+  - 샘플 테스트 3개 — 가장 안전한 순수 함수/단순 컴포넌트로 인프라 검증:
+    - `Stars` 컴포넌트 렌더 + 별점 표시
+    - 기존 `HangulSimilarity` (#348) — 자모/유사도
+    - `BotDetector` (#337) — 봇 UA 패턴
+  - `next.config.ts` `images.remotePatterns`에 Google avatar 도메인(`lh3.googleusercontent.com`) + YouTube thumbnail(`i.ytimg.com`).
+  - `ReviewSection`/`MyReviewsList`의 `<img>` 일부를 `next/image` 또는 명시적 eslint-disable로 정리.
+  - `MyReviewsList` 탭에 WAI-ARIA Tabs 패턴(role=tablist/tab/aria-selected/aria-controls).
+- **제외 (후속)**
+  - 백엔드 JUnit 테스트 인프라 (별도 큰 작업).
+  - E2E (Playwright) 도입.
+  - CI 통합 (GitHub Actions 또는 OCI DevOps).
+  - 모든 컴포넌트 테스트 — 점진적으로 추가.
+  - 모든 `<img>` → `next/image` 전수 교체 — 점진적.
+
+## 3. 인수조건
+
+- [ ] `npm test`가 단일 명령으로 동작 (0건 → 샘플 3개 통과).
+- [ ] `npm run build`가 회귀 없이 통과.
+- [ ] `next.config.ts`에 `remotePatterns` 설정.
+- [ ] `ReviewSection`의 user_avatar_url `<img>`에 `next/image` 또는 eslint-disable 주석.
+- [ ] `MyReviewsList` 탭이 `role="tablist"`/`role="tab"`/`aria-selected`/`aria-controls`/`tabIndex` 설정.
+
+## 4. 컨텍스트 & 제약
+
+- Next.js 16.1.6 + Turbopack.
+- `next/jest`는 SWC/Babel 자동 통합. Turbopack 빌드와는 분리(테스트만 Jest 별도).
+- Pretendard/Geist 폰트는 `next/font/local` 사용 → 테스트에선 mock 불필요.
+- 패널 분리(#329)로 admin 영역은 단위 테스트 도입 더 쉬워짐.
+
+## 5. 아키텍처 개요
+
+```
+frontend/
+├── package.json
+│   └── scripts: test, test:watch
+├── jest.config.ts            (next/jest createNextJestConfig 사용)
+├── jest.setup.ts             (@testing-library/jest-dom 확장 matchers)
+├── __tests__/
+│   ├── Stars.test.tsx
+│   ├── HangulSimilarity.test.ts   (자체 구현은 backend Java, TS 포팅은 미적용 → 다른 순수 함수로 대체)
+│   └── BotDetector.test.ts        (마찬가지 — backend → TS 동등 포팅 불가)
+└── (대안) 프론트 측 순수 함수:
+    ├── lib/cuisine-icons.ts 의 getPhosphorCuisineIcon
+    ├── components/Stars 의 0.5 단위 렌더
+    └── i18n/config.ts 의 isLocale/detectBrowserLocale
+```
+
+→ 백엔드 Java 코드는 TS 테스트로 검증 불가. 프론트 측 순수 함수 3개로 대체:
+- `Stars` 렌더 (RTL component test)
+- `i18n/config.ts` `isLocale` (pure)
+- `i18n/config.ts` `detectBrowserLocale` (navigator mock)
+
+## 6. 데이터 모델
+
+`__tests__/*.test.{tsx,ts}` — Jest 표준 컨벤션.
+
+## 7. 함수 명세
+
+| 단위 | 책임 | 비고 |
+|------|------|------|
+| `jest.config.ts` | `createJestConfig(customConfig)` + moduleNameMapper `@/*` | next/jest |
+| `jest.setup.ts` | `import "@testing-library/jest-dom"` | 확장 matchers |
+| `Stars.test.tsx` | 별점 0/2.5/5 렌더, aria-label 확인 | RTL |
+| `i18n/config.test.ts` | isLocale/detectBrowserLocale | navigator mock |
+| `MyReviewsList` Tabs 패치 | tablist/tab/aria-selected | role + aria |
+| `ReviewSection` img → eslint-disable | 최소 변경 | next/image는 후속 |
+
+## 8. 흐름
+
+1. `npm i -D jest jest-environment-jsdom @testing-library/react @testing-library/jest-dom @testing-library/user-event @types/jest`.
+2. `jest.config.ts` + `jest.setup.ts` 작성.
+3. `package.json`에 `"test": "jest"` + `"test:watch": "jest --watch"` 추가.
+4. `__tests__/`에 3개 샘플 테스트.
+5. `next.config.ts`에 `remotePatterns` 추가.
+6. `MyReviewsList` Tabs ARIA 보강.
+7. `ReviewSection`의 `<img>` 라인에 `// eslint-disable-next-line @next/next/no-img-element` (next/image 전환은 후속).
+8. `npm test` 통과 → `npm run build` 통과.
+
+## 9. 엣지케이스
+
+- **Turbopack vs Jest**: 무관 (테스트는 별도 SWC 컴파일).
+- **CSS modules / globals.css import**: jest.config.ts의 moduleNameMapper로 `\\.(css|scss)$` → `identity-obj-proxy` 대신 next/jest가 자동 처리.
+- **Next.js Server Components**: 본 프로젝트는 모두 `"use client"` 컴포넌트라 RTL이 통상 동작.
+
+## 10. 테스트
+
+자기 자신 — `npm test`가 통과해야 본 이슈 완료.
+
+## 11. 리스크 & 대안
+
+- **선택**: `next/jest` + RTL. Next.js 공식 권장.
+- **대안 A**: Vitest — 더 빠르지만 Next.js 공식 가이드 부재, 본 프로젝트 규모에서 차이 작음.
+- **대안 B**: Playwright Component Testing — 더 무겁고 E2E 통합 안 됨.
+- **트레이드오프**: Jest 30 + RTL은 React 19에 호환. 의존성 부담은 dev-only.
+
+## 12. 미해결 질문
+
+- CI(테스트 자동 실행) — 본 이슈 범위 밖. OCI DevOps Build Pipeline은 ARM64 미지원 → GitHub Actions 또는 Gitea Actions 후속.
+- 백엔드 JUnit 테스트 인프라 — 별도 큰 이슈.
+- E2E (Playwright) — 별도.

docs/design/348-name-similarity/README.md

@@ -0,0 +1,80 @@
+# 설계서: isNameSimilar 한국어 자모 분해 + Sørensen-Dice (#348)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #348 · 부모: #332 (이미 close)
+> · 구현 파일: `backend-java/src/main/java/com/tasteby/util/HangulSimilarity.java` (신규), `backend-java/src/main/java/com/tasteby/controller/RestaurantController.java`
+
+## 1. 목적
+
+기존 `isNameSimilar`가 Jaccard-like(문자 set 교집합 비율 ≥ 0.4)로 짧은 한국어 이름에서 오탐 가능. 자모 분해 + Sørensen-Dice bigram으로 정확도 향상.
+
+## 2. 범위
+
+- **포함**
+  - `HangulSimilarity.similarity(a, b)` 유틸 신규
+  - `RestaurantController.isNameSimilar` 호출부를 새 유틸로 교체
+- **제외 (별도 후속으로 분리)**
+  - DDG → 정식 검색 API 전환 (외부 API 결정 + 비용/계약 필요)
+  - DTO RestaurantUpdateDTO + @Valid 표준화 (#332 화이트리스트 set으로 SQL 측 가드 확보)
+  - UNIQUE(google_place_id) 제약 강화 — DB 중복 정리 선행 필요(현재 10+건 중복 확인)
+
+## 3. 인수조건
+
+- [ ] `HangulSimilarity.similarity(a, b)` 0.0~1.0 반환 (1.0=동일)
+- [ ] 한국어 음절을 Unicode NFD로 자모 분해(초성·중성·종성)
+- [ ] 분해 후 bigram 기반 Sørensen-Dice 계수 계산
+- [ ] 빈 문자열 안전 처리 (둘 다 비면 0.0, 한쪽만 비면 0.0)
+- [ ] `RestaurantController.isNameSimilar` 임계값 0.45로 호출 (Jaccard 0.4와 유사 보수성)
+- [ ] 회귀 없음 — 기존 정상 매칭 시나리오 통과
+
+## 4. 컨텍스트 & 제약
+
+- Java 21 `Normalizer.normalize(Form.NFD)` 활용.
+- 한글 음절(가-힣) NFD → 초성(ㄱ-ㅎ 호환자모 또는 조합자모) + 중성 + 종성.
+- 영문/숫자는 그대로 통과.
+- Sørensen-Dice: `2 * |A ∩ B| / (|A| + |B|)` — bigram 다중집합(multiset) 기준.
+
+## 5. 함수 명세
+
+| 함수 | 책임 | 시그니처 |
+|------|------|---------|
+| `decomposeHangul(s)` | NFD 자모 분해 + 공백/구두점 제거 + 소문자화 | `static String decompose(String)` |
+| `bigrams(s)` | 2글자 bigram 리스트 | `static List<String> bigrams(String)` |
+| `similarity(a, b)` | Sørensen-Dice 0.0~1.0 | `static double similarity(String, String)` |
+
+## 6. 흐름
+
+1. 두 이름을 `decompose`로 자모 분해 + 정규화.
+2. 각 분해 결과를 `bigrams`로 분해.
+3. multiset 교집합 크기 카운트.
+4. `2 * common / (sizeA + sizeB)`.
+
+## 7. 엣지케이스
+
+- **둘 다 빈 문자열**: 0.0 반환.
+- **bigram 1개 이하**: 두 문자열 같으면 1.0, 아니면 0.0.
+- **포함 관계**: 기존 코드의 `a.contains(b) || b.contains(a)` 단축 평가 유지 (1.0 반환).
+- **혼합(한영)**: NFD가 한글만 분해 → 영문은 그대로. bigram 계산은 동일하게 동작.
+
+## 8. 테스트 (수동)
+
+```
+similarity("스타벅스 강남", "스타벅스 강남점")  → ≥ 0.85
+similarity("스타벅스 강남", "스타벅스 종로")    → ≥ 0.55, < 0.85
+similarity("스타벅스", "맥도날드")             → < 0.20
+similarity("PIZZAHUT", "피자헛")              → 한글 + 영문 혼재 가드 통과
+```
+
+## 9. 리스크 & 대안
+
+- **선택**: NFD 분해 + bigram Sørensen-Dice. Java 표준 라이브러리만 사용.
+- **대안 A**: Apache Commons Text `JaroWinklerSimilarity` — 라이브러리 추가 부담.
+- **대안 B**: Hangul.js류 라이브러리 — Java 포팅 없음.
+- **대안 C**: Levenshtein 거리 — 자모 분해와 결합 시 좋으나 구현 복잡.
+
+## 10. 미해결 질문 / 분리된 후속
+
+- DDG → 정식 검색 API: Naver Search API 또는 Google Custom Search (외부 API 결정 + 비용 검토 필요) — 별도 신규 이슈
+- DTO RestaurantUpdateDTO + @Valid: #332 set 화이트리스트로 1차 가드. 본격 DTO는 큰 변경 — 별도 신규 이슈
+- UNIQUE(google_place_id) 제약: 현재 10+건 중복. 데이터 정리(병합/삭제) 선행 → 별도 신규 이슈

docs/design/352-i18n-skeleton/README.md

@@ -0,0 +1,141 @@
+# 설계서: i18n 뼈대 — ko/en/ja/es (#352)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #352
+> · 구현 파일: `frontend/package.json`, `frontend/next.config.ts`, `frontend/src/i18n/*` (신규), `frontend/src/messages/{ko,en,ja,es}.json` (신규), `frontend/src/components/LanguageSwitcher.tsx` (신규)
+> · 테스트: 수동 (언어 전환 + ko fallback)
+
+## 1. 목적
+
+장기적으로 영어/일본어/스페인어 시장으로 확장 가능하도록 i18n 뼈대 구축. 본 이슈는 *뼈대*만 — 약 30개 키 초기 번역.
+
+## 2. 범위
+
+- **포함**
+  - `next-intl` 라이브러리 도입 (Next.js 16 App Router 권장).
+  - 4개 로케일: `ko, en, ja, es`. 기본 `ko`, fallback `ko`.
+  - 메시지 디렉토리 `src/messages/{ko,en,ja,es}.json`.
+  - Provider (`<NextIntlClientProvider>`) 루트 layout 적용.
+  - `LanguageSwitcher` 컴포넌트 (헤더 우측).
+  - 로케일 저장: localStorage `tasteby_locale`.
+  - 초기 번역 키 ~30개: 헤더(로그인/검색/메뉴) + 주요 액션(저장/취소/삭제/확인) + 페이지 제목.
+- **제외**
+  - URL 라우팅 i18n (`/ko/...`).
+  - SEO meta tags i18n.
+  - 식당명/리뷰 등 사용자 콘텐츠 번역.
+  - 어드민 페이지(운영자만 사용, 한국어 유지).
+  - 식당 카드/상세 시트 전체 키 추출 (점진).
+
+## 3. 인수조건
+
+- [ ] `npm i next-intl` + 4개 메시지 파일 생성.
+- [ ] `tasteby_locale`이 localStorage에 있으면 사용, 없으면 브라우저 언어 감지(`navigator.language`) → 매칭 안되면 `ko`.
+- [ ] 헤더 우측 LanguageSwitcher 드롭다운(국기 + 코드).
+- [ ] 초기 번역 키 약 30개 — 4개 언어 모두 채움.
+- [ ] 미번역 키는 `ko` fallback (에러 없이).
+- [ ] 빌드/배포 회귀 없음.
+
+## 4. 컨텍스트 & 제약
+
+- Next.js 16 + App Router + `"use client"` 컴포넌트 다수.
+- 기존 `auth-context`처럼 i18n도 React Context 패턴.
+- `next-intl`은 server/client 모두 지원, 본 프로젝트는 client-side switching이라 `NextIntlClientProvider` 중심.
+- URL 라우팅 변경 없이 단순 메시지만 교체(낮은 비용).
+- 폰트: Pretendard Variable이 한국어/영어 잘 표시, 일본어는 시스템 폰트 fallback OK, 스페인어는 라틴 문자라 OK.
+
+## 5. 아키텍처 개요
+
+```
+frontend/
+├── src/
+│   ├── i18n/
+│   │   ├── config.ts            ← 로케일 목록/기본값 상수
+│   │   ├── LocaleProvider.tsx   ← NextIntlClientProvider wrap + localStorage 저장
+│   │   └── useTranslations.ts   ← (next-intl 재export)
+│   ├── messages/
+│   │   ├── ko.json              ← 기본
+│   │   ├── en.json
+│   │   ├── ja.json
+│   │   └── es.json
+│   ├── components/
+│   │   └── LanguageSwitcher.tsx ← 헤더용
+│   └── app/
+│       └── layout.tsx           ← LocaleProvider로 감싸기
+```
+
+## 6. 데이터 모델
+
+### 메시지 키 (초기 ~30)
+```json
+{
+  "header": {
+    "search": "검색", "login": "로그인", "logout": "로그아웃",
+    "menu": "메뉴", "myReviews": "내 리뷰", "favorites": "즐겨찾기"
+  },
+  "actions": {
+    "save": "저장", "cancel": "취소", "delete": "삭제",
+    "edit": "수정", "confirm": "확인", "close": "닫기",
+    "loading": "로딩 중...", "submit": "제출"
+  },
+  "filter": {
+    "title": "필터", "cuisine": "음식 종류", "price": "가격대",
+    "region": "지역", "channel": "채널", "reset": "초기화"
+  },
+  "restaurant": {
+    "rating": "평점", "address": "주소", "phone": "전화",
+    "website": "웹사이트", "closed": "폐업", "tempClosed": "임시휴업"
+  },
+  "review": {
+    "title": "리뷰", "write": "리뷰 작성", "noReviews": "아직 리뷰가 없습니다"
+  }
+}
+```
+
+총 5개 카테고리 × 평균 6개 = 30개 키.
+
+## 7. 함수 명세
+
+| 함수/컴포넌트 | 책임 | 비고 |
+|---|---|---|
+| `i18n/config.ts` | LOCALES, DEFAULT_LOCALE 상수 | 단순 |
+| `LocaleProvider.tsx` | NextIntlClientProvider wrap + 메시지 동적 로딩 + localStorage 동기화 | client |
+| `LanguageSwitcher.tsx` | 헤더 드롭다운 (국기 + 코드) | client, 44px 터치 |
+| `messages/<lang>.json` | 키 → 텍스트 | flat or nested |
+
+## 8. 흐름
+
+1. 사용자 첫 방문 → `tasteby_locale` 없음 → `navigator.language.split('-')[0]`이 LOCALES에 있으면 사용, 아니면 `ko`.
+2. LocaleProvider가 해당 로케일 메시지 파일 import → NextIntlClientProvider에 전달.
+3. 컴포넌트는 `useTranslations('header')` 등으로 호출.
+4. LanguageSwitcher에서 변경 → localStorage 저장 → 페이지 새로고침 또는 state 업데이트.
+
+## 9. 엣지케이스
+
+- **메시지 파일 누락 키**: next-intl 기본 동작은 키 자체 표시 + 콘솔 경고. fallback 처리는 messages 명시.
+- **localStorage 비활성/SSR**: typeof window 체크.
+- **로케일 코드 대소문자**: 항상 소문자 정규화.
+- **placeholder 변수**: next-intl ICU 메시지 형식 지원 (`{name}` 등). 초기 키에는 미적용.
+
+## 10. 테스트
+
+- 수동:
+  - 한국어 첫 방문 → "검색" 표시.
+  - LanguageSwitcher에서 English → "Search" 표시.
+  - 새로고침 후 영어 유지.
+  - 메시지 누락 키 → 콘솔 경고 + 키 표시.
+
+## 11. 리스크 & 대안
+
+- **선택**: `next-intl` (Next.js 16 App Router 권장, ICU 메시지, 활발 유지보수).
+- **대안 A**: `react-i18next` — 더 일반적이지만 App Router 통합 next-intl이 더 매끄러움.
+- **대안 B**: 자체 구현 + Context — 의존성 ↓ but 기능/표준화 ↓.
+- **트레이드오프**: 30개 키는 단순하지만 ICU 메시지(복수형, 성별 등) 필요 시 next-intl 가치 큼.
+
+## 12. 미해결 질문
+
+- 식당명/리뷰 콘텐츠 번역 — 사용자 작성이라 자동 번역(LLM)? 별도 정책 결정.
+- URL 라우팅 i18n (`/en/`) — 후속.
+- SEO meta tags i18n — 후속.
+- 어드민 페이지는 운영자 한국어 유지 — 확정.
+- 통화/날짜 포맷(Intl API) — 후속.

docs/design/356-video-relevance-llm/README.md

@@ -0,0 +1,172 @@
+# 설계서: 영상-식당 관련도 LLM 평가로 약한 매칭 자동 숨김 (#356)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #356 · 유사 패턴: #322(식당 LLM 검증, 09-Done) · 부모 영역: #270(영상→식당 추출 파이프라인 현행화, 09-Done)
+> · 구현 파일: `backend-java/src/main/java/com/tasteby/service/VideoRelevanceService.java`(신규), `backend-java/src/main/resources/mybatis/mapper/RestaurantMapper.xml`, `backend-java/src/main/java/com/tasteby/service/RestaurantService.java`, `backend-java/src/main/java/com/tasteby/controller/AdminVideoRelevanceController.java`(신규), DB 마이그레이션 SQL
+> · 테스트: 본 범위 밖 (테스트 인프라 #343 도입됨, 후속에서 점진 확장)
+
+## 1. 목적 (Why)
+
+식당 상세에 연결된 영상 중 식당과 **본격적으로 관련 없는 약한 언급**(비교 대상, 일반 토픽 중 잠깐 언급, 식당 입점 전 영상 등)이 노이즈로 표시. 실제 케이스 — 파이브가이즈 강남의 영상 7개 중 3건이 약한 매칭(쉐이크쉑 비교 / 미국 비만율 일반 토픽 / 한국 입점 전 미국 여행). LLM 평가로 약한 매칭 자동 숨김.
+
+## 2. 범위 (Scope)
+
+- **포함**
+  - `video_restaurants` 테이블에 `relevance`, `relevance_reason`, `relevance_evaluated_at` 컬럼 추가.
+  - `VideoRelevanceService` 신규 — LLM 판정 + DB 반영 (`#322` 패턴 모방).
+  - `PipelineService.processExtract` 완료 후 `verifyAsync(linkId)` 호출 — 신규 등록 자동 평가.
+  - `GET /api/restaurants/{id}/videos`: 기본 `relevance = 'strong'`만 응답. `?include_weak=true` 시 모두 포함.
+  - 어드민 API: 단건 재평가 / 일괄 백필 / 수동 토글.
+- **제외 (별도 후속)**
+  - 어드민 UI(검증 칼럼 / 토글) — `#322`의 RestaurantsPanel UI와 같은 패턴으로 별도 후속.
+  - 프론트 사용자 옵션 UI("약한 매칭도 보기" 토글) — 별도 후속.
+  - LLM 비용 모니터링/메트릭 — 별도.
+
+## 3. 인수조건
+
+- [ ] `video_restaurants` 테이블에 `relevance VARCHAR2(16) DEFAULT 'unknown'`, `relevance_reason VARCHAR2(120)`, `relevance_evaluated_at TIMESTAMP` 컬럼 + `idx_vr_relevance` 인덱스.
+- [ ] 가능한 값: `strong | weak | incidental | unknown` (unknown = 미평가).
+- [ ] 신규 등록 시 60초 안에 `relevance_evaluated_at` 설정.
+- [ ] `GET /api/restaurants/{id}/videos` 기본 응답: `relevance IN ('strong','unknown')` (안전한 기본값 = 평가 실패 시 표시).
+- [ ] `?include_weak=true`: 모두 포함 + `relevance`, `relevance_reason` 필드 동봉.
+- [ ] 어드민 API:
+  - `GET /api/admin/video-relevance/pending` → 미평가(unknown) 카운트
+  - `POST /api/admin/video-relevance/all?batchSize=10` → 백필
+  - `POST /api/admin/video-relevance/{linkId}/evaluate` → 단건 재평가
+  - `PATCH /api/admin/video-relevance/{linkId}` → 수동 강제 토글 `{relevance, reason}`
+- [ ] LLM 호출 실패 시 `unknown` 유지 + 로그 (`#322`와 같은 안전 기본값).
+- [ ] 빌드/배포 회귀 없음.
+
+## 4. 컨텍스트 & 제약
+
+- 기존 `OciGenAiService.chat(prompt, maxTokens)` 재사용.
+- LLM 비용: 영상-식당 페어당 1회 단발. 현재 1,244건 → 백필 시 약 1,244 호출.
+- `video_restaurants`는 한 영상에 여러 식당, 한 식당에 여러 영상이 m:n 관계.
+- 같은 페어는 `relevance_evaluated_at`이 NULL 아니면 재평가 안 함 (캐시).
+
+## 5. 아키텍처 개요
+
+```
+PipelineService.processExtract (기존)
+   │
+   ▼
+RestaurantService.linkVideoRestaurant (video_restaurants INSERT)
+   │
+   ▼
+VideoRelevanceService.verifyAsync(linkId)  ← #356 신규
+   │ (비동기)
+   ▼
+OciGenAiService.chat(prompt, 120)
+   │
+   ▼
+parseRelevance → { relevance: strong|weak|incidental, reason: string }
+   │
+   ▼
+RestaurantMapper.updateRelevance(linkId, relevance, reason)
+   │
+   ▼ (조회 시)
+RestaurantMapper.findVideoLinks(restaurantId, includeWeak)
+   ├ includeWeak=false (기본): WHERE relevance IN ('strong','unknown')
+   └ includeWeak=true:  모두 + relevance/reason 필드 노출
+```
+
+## 6. 데이터 모델
+
+### DB 마이그레이션
+```sql
+ALTER TABLE video_restaurants ADD (
+  relevance VARCHAR2(16) DEFAULT 'unknown' NOT NULL,
+  relevance_reason VARCHAR2(120),
+  relevance_evaluated_at TIMESTAMP
+);
+CREATE INDEX idx_vr_relevance ON video_restaurants(relevance);
+```
+
+### 도메인 (`VideoRestaurantLink` 확장은 본 범위 밖 — findVideoLinks는 `resultType="map"`)
+응답 Map에 키 추가:
+- `relevance`: `"strong" | "weak" | "incidental" | "unknown"`
+- `relevance_reason`: `string | null`
+
+### LLM 응답 스키마
+```json
+{
+  "relevance": "strong" | "weak" | "incidental",
+  "reason": "20자 이내"
+}
+```
+
+## 7. 함수 명세
+
+| 함수 | 책임 | 비고 |
+|---|---|---|
+| `VideoRelevanceService.verifyAsync(linkId)` | 비동기 트리거 | `#322`의 `RestaurantVerifyService.verifyAsync` 유사 |
+| `VideoRelevanceService.verify(linkId)` | 단건 검증 + DB 반영 | LLM 실패 시 unknown 유지 |
+| `VideoRelevanceService.verifyAll(batchSize)` | 백필 (식당당 200ms sleep) | |
+| `VideoRelevanceService.buildPrompt(...)` | 프롬프트 생성 | 식당명·주소·음식·영상 제목·평가 |
+| `VideoRelevanceService.parseRelevance(raw)` | LLM 응답 → DTO | 파싱 실패 시 unknown 안전 기본값 |
+| `RestaurantMapper.updateRelevance(linkId, rel, reason)` | DB 갱신 | |
+| `RestaurantMapper.findVideoLinks(restaurantId, includeWeak)` | 기존 SQL에 WHERE 조건 추가 | |
+| `AdminVideoRelevanceController` 신규 | 4개 admin endpoint | requireAdmin |
+
+## 8. 흐름
+
+### 신규 등록 자동 평가
+1. `PipelineService.processExtract` → `linkVideoRestaurant` → linkId 획득.
+2. `VideoRelevanceService.verifyAsync(linkId)` 호출(@Async).
+3. 별도 스레드: 영상/식당/평가 데이터 조회 → buildPrompt → LLM → parse → DB.
+
+### 백필
+1. 어드민 `POST /api/admin/video-relevance/all` 호출.
+2. `WHERE relevance_evaluated_at IS NULL` 인 link 10개씩 조회 → 순차 검증.
+3. 식당당 200ms sleep (LLM rate 보호).
+
+### 프롬프트 예시
+```
+다음 YouTube 영상이 이 식당을 어떻게 다루는지 판정하라.
+
+식당명: {restaurantName}
+주소: {address}
+음식: {foodsMentioned}
+
+영상 제목: {videoTitle}
+영상 채널: {channelName}
+영상에 등장한 평가 내용: {evaluation}
+
+응답 형식(JSON만, 다른 텍스트 없이):
+{"relevance": "strong"|"weak"|"incidental", "reason": "20자 이내 한국어"}
+
+가이드:
+- strong: 영상 본편이 이 식당을 본격 다룸. 방문 리뷰, 메뉴 평가 등.
+- weak: 영상에서 잠깐 언급, 비교 대상으로만 등장, 다른 식당의 일부로.
+- incidental: 식당 입점 전 영상에서 단순 언급, 일반 토픽(미국 비만, 환율 등)에서 잠깐.
+- 판단 모호 시 strong (보수적 — 사용자에게 표시 유지).
+```
+
+## 9. 엣지케이스
+
+- **LLM 응답 비-JSON**: parseRelevance → unknown 기본값.
+- **LLM 호출 실패**: unknown 유지 → 다음 백필 재시도.
+- **영상 데이터 누락(transcript 없음, evaluation 비어있음)**: 프롬프트에 "(미상)" 표기. LLM이 판정 어려우면 strong 보수적.
+- **동시성**: 같은 linkId verifyAsync 두 번 호출 → idempotent.
+- **삭제된 영상**: linkId 조회 결과 없으면 no-op.
+
+## 10. 테스트 (수동)
+
+- 파이브가이즈 강남 케이스 백필 → 7건 중 3건이 weak/incidental로 마킹되는지 확인.
+- 공개 API `/api/restaurants/{id}/videos` → 약한 매칭 제외 확인.
+- `?include_weak=true` → 모두 포함 확인.
+
+## 11. 리스크 & 대안
+
+- **선택**: `#322` 동일 패턴 + DB 마이그레이션.
+- **대안 A**: 사용자가 직접 "약한 매칭도 보기" 토글 → 사용자 결정 부담.
+- **대안 B**: 추출 단계에서 한 번에 판정 → 비용 ↓이지만 ExtractorService 비대.
+- **트레이드오프**: 단발 LLM 평가는 비용 합리적. false positive는 어드민 수동 토글 + `unknown` 안전 기본값으로 보완.
+
+## 12. 미해결 질문
+
+- 임계값(weak/incidental 둘 다 숨김 vs incidental만 숨김) — 현재는 둘 다 숨김.
+- 영상 자막 전체를 LLM에 보낼지 vs 평가 텍스트만 → 비용/정확도 트레이드오프. 현재는 evaluation만(짧음).
+- 사용자에게 "약한 매칭도 보기" UI → 별도 후속.
+- 어드민 UI — 별도 후속 (#322 패턴 모방).

docs/design/357-web-search-api/README.md

@@ -0,0 +1,114 @@
+# 설계서: DDG HTML 파싱 → 정식 검색 API 전환 (#357)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #357 · 부모: #348(이름 유사도, 09-Done) · 관련: searchTabling/searchCatchtable
+> · 구현 파일: `backend-java/src/main/java/com/tasteby/service/WebSearchService.java`(신규), `backend-java/src/main/java/com/tasteby/controller/RestaurantController.java`, `backend-java/src/main/resources/application.yml`, `k8s/secrets.yaml.template`
+> · 테스트: 본 범위 밖 (수동 — Tabling/Catchtable 매핑 SSE에서 확인)
+
+## 1. 목적 (Why)
+
+`searchDuckDuckGo`는 html.duckduckgo.com을 정규식으로 긁어 Tabling/Catchtable URL을 추출. 봇 차단/HTML 구조 변경 시 대량 `NONE` 마킹 위험. 정식 검색 API로 교체해 안정성/정확도 확보.
+
+## 2. 범위 (Scope)
+
+- **포함**
+  - `WebSearchService` 신규 — Naver Search webkr.json 우선, 미설정/실패 시 DDG 폴백.
+  - `RestaurantController.searchTabling/searchCatchtable` 내부 호출을 새 서비스로 교체.
+  - `application.yml` + `k8s/secrets.yaml.template`에 `NAVER_CLIENT_ID/SECRET` 항목 추가.
+- **제외 (별도 후속)**
+  - Kakao Local API 검색 (식당 검색 전용이라 사이트 URL 매칭 부적합).
+  - Google Custom Search Engine (비용 + 무료 100/day 제약).
+  - 결과 캐시/메트릭 — 후속.
+
+## 3. 인수조건
+
+- [ ] `NAVER_CLIENT_ID/SECRET` 환경변수 등록 시 Naver Search webkr.json 호출.
+- [ ] 미설정 또는 5xx/timeout 시 DDG로 자동 폴백 — 회귀 없음.
+- [ ] 응답 형식: 기존 `List<Map<String, Object>>` 유지 — `{title, url}` 키.
+- [ ] URL 패턴 필터 동일 동작 (예: `tabling.co.kr/restaurant/`, `tabling.co.kr/place/`).
+- [ ] 빌드/배포 회귀 없음.
+
+## 4. 컨텍스트 & 제약
+
+- Naver Search 무료 한도: 일 25,000건. Tabling/Catchtable 매핑 백필이 1,200 식당 × 2회 ≈ 2,400건 1회성 → 한도 내.
+- Naver는 `site:` 연산자 미지원 — 결과 URL 패턴 필터링으로 대체.
+- `WebClient` 또는 `HttpClient` — 기존 `HttpClient`(static) 재사용.
+- 키 미설정 환경(dev local 일부)에서도 DDG 폴백으로 동작 보장.
+
+## 5. 아키텍처 개요
+
+```
+RestaurantController.searchTabling(name)
+   │
+   ▼
+WebSearchService.search(query, urlPatterns)
+   │
+   ├─ NAVER_CLIENT_ID 설정 시
+   │     └─ Naver webkr.json → URL 패턴 필터 → 결과
+   │             (실패/0건 시 ▼)
+   └─ DDG html.duckduckgo.com → 정규식 파싱 → URL 패턴 필터
+```
+
+## 6. 데이터 모델
+
+### 응답 (기존 유지)
+```json
+[ { "title": "스타벅스 강남대로점", "url": "https://app.catchtable.co.kr/dining/12345" } ]
+```
+
+### Naver 응답 → 변환
+```json
+{ "items": [ { "title": "<b>스타벅스</b> 강남점", "link": "https://..." } ] }
+```
+- `title`은 `<b>` 태그 제거 후 사용.
+- `link`가 urlPatterns 중 하나에 매칭되면 결과에 포함.
+
+## 7. 함수 명세
+
+| 함수 | 책임 | 비고 |
+|---|---|---|
+| `WebSearchService.search(query, urlPatterns)` | 외부 진입점 | Naver 우선 → DDG 폴백 |
+| `WebSearchService.searchNaver(...)` | Naver Search webkr.json 호출 + 필터 | 키 미설정 시 즉시 빈 결과 |
+| `WebSearchService.searchDdg(...)` | 기존 DDG 로직 이관 | RestaurantController에서 옮김 |
+| `WebSearchService.stripTags(s)` | `<b>...</b>` 제거 | |
+| `WebSearchService.matchesPattern(url, patterns)` | URL 패턴 매칭 | `urlPatterns.length == 0` 면 모두 통과 |
+
+## 8. 흐름
+
+### 정상
+1. `searchTabling(name)` → `webSearchService.search("스타벅스", ["tabling.co.kr/restaurant/", "tabling.co.kr/place/"])`.
+2. Naver 호출 → 200, items 30 → URL 패턴 매칭 0~N건 추출.
+3. 0건이면 DDG 폴백, 그래도 0건이면 빈 리스트.
+
+### 폴백
+- Naver 5xx / IOException / 키 미설정 → DDG.
+
+### 키 등록 (운영자 작업)
+1. https://developers.naver.com/apps/#/list 검색 앱 등록.
+2. `NAVER_CLIENT_ID`, `NAVER_CLIENT_SECRET` 발급.
+3. dev: `.env`에 추가, prod: `k8s/secrets.yaml`에 추가 + `kubectl apply`.
+
+## 9. 엣지케이스
+
+- **키 미설정**: searchNaver 즉시 빈 리스트 → DDG 폴백 (회귀 없음).
+- **Naver rate limit (429)**: DDG 폴백.
+- **DDG도 막힘**: 빈 리스트 반환 → 호출자(매핑 SSE)에서 `NONE` 처리 — 기존 동작 동일.
+- **URL 패턴 빈 배열**: 패턴 매칭 스킵, 모든 결과 반환 (API 일반화 대비).
+
+## 10. 테스트 (수동)
+
+- Dev: `NAVER_CLIENT_ID/SECRET` 등록 → 어드민 `bulkTabling` SSE 실행 → 매칭율 비교 (이전 DDG 대비 ≥).
+- 키 일부 제거 → DDG 폴백 동작 확인.
+
+## 11. 리스크 & 대안
+
+- **선택**: Naver primary + DDG fallback. 한국 식당 정확도 + 무료 한도 + 폴백 안정성.
+- **대안 A**: Kakao Local Search — 식당 정보 직접 검색은 가능하지만 Tabling/Catchtable URL 매핑 부적합.
+- **대안 B**: Google CSE — 비용/한도 제약.
+- **트레이드오프**: Naver 응답 정확도가 압도적이지만 키 발급 운영자 작업 필요. 폴백으로 회귀 0 보장.
+
+## 12. 미해결 질문
+
+- Naver의 인덱스 신선도 vs Tabling/Catchtable 최신 입점 식당 미반영 가능성 — 백필 주기 후속.
+- 결과 캐시(같은 식당 재호출) — 후속.

docs/design/358-restaurant-update-dto/README.md

@@ -0,0 +1,75 @@
+# 설계서: RestaurantUpdateDTO + @Valid 표준화 (#358)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #358 · 부모: #348(09-Done) · 관련: #332(화이트리스트 1차)
+> · 구현 파일: `backend-java/src/main/java/com/tasteby/dto/RestaurantUpdateDTO.java`(신규), `backend-java/src/main/java/com/tasteby/controller/RestaurantController.java`
+> · 테스트: 본 범위 밖 (수동 — 어드민 식당 편집 동작 확인)
+
+## 1. 목적 (Why)
+
+`#332`에서 Set 화이트리스트로 1차 가드 적용했지만, 타입 안전성·validation·API 명세는 여전히 `Map<String, Object>`로 흐릿함. 본격 DTO 표준화로 잘못된 입력 자동 거부 + 명세 명확화.
+
+## 2. 범위 (Scope)
+
+- **포함**
+  - `RestaurantUpdateDTO` record — 화이트리스트 14필드 모두 Optional(null 시 미변경).
+  - `@Valid` + Bean Validation 어노테이션 적용 (`@Size`, `@Pattern`, `@DecimalMin/Max`, `@Min`).
+  - Controller `PUT /api/restaurants/{id}` 시그니처: `Map → RestaurantUpdateDTO`.
+  - DTO → Map 변환(`toFieldMap()`) — Service 계층은 그대로 (재작업 0).
+  - 잘못된 입력 시 400 자동 응답 (Spring 기본 `MethodArgumentNotValidException`).
+- **제외 (별도 후속)**
+  - `tabling-url` / `catchtable-url` PUT 엔드포인트 — 단일 필드라 현행 유지.
+  - PATCH 시멘틱 (부분 업데이트) — 현재 PUT이 부분 업데이트 의미로 사용 중.
+
+## 3. 인수조건
+
+- [ ] 모든 화이트리스트 필드 record에 등재 + null 가능.
+- [ ] `name`: `@Size(min=1, max=200)`.
+- [ ] `website`/`tabling_url`/`catchtable_url`: `@Pattern(http(s)://... | "NONE" | "")`.
+- [ ] `latitude`: `@DecimalMin("-90.0") @DecimalMax("90.0")`.
+- [ ] `longitude`: `@DecimalMin("-180.0") @DecimalMax("180.0")`.
+- [ ] `rating`: `@DecimalMin("0.0") @DecimalMax("5.0")`.
+- [ ] `rating_count`: `@Min(0)`.
+- [ ] `price_range`: `@Min(1) @Max(5)`.
+- [ ] 잘못된 입력 → HTTP 400 자동 응답.
+- [ ] 기존 동작 회귀 없음 (geocode/cache flush 흐름 동일).
+
+## 4. 컨텍스트 & 제약
+
+- `spring-boot-starter-validation` 이미 의존성 등록됨.
+- record + Bean Validation: 컴파일 시 어노테이션 인식 OK.
+- Jackson SNAKE_CASE 매핑 유지: `cuisine_type`, `tabling_url` 등.
+- `null`은 "변경 없음" 시그널 — `toFieldMap()`에서 제외.
+
+## 5. 함수 명세
+
+| 함수 | 책임 | 비고 |
+|---|---|---|
+| `RestaurantUpdateDTO` (record) | 입력 표면 | 14 필드, 모두 nullable |
+| `RestaurantUpdateDTO.toFieldMap()` | null 제외 Map 변환 | Service `update` 시그니처 유지 |
+| `RestaurantController.update(...)` | DTO 받음 + geocode 분기 | `@Valid @RequestBody RestaurantUpdateDTO` |
+
+## 6. 흐름
+
+1. 클라이언트 → `PUT /api/restaurants/{id}` JSON.
+2. Spring 역직렬화 + Bean Validation. 실패 시 400 자동.
+3. `dto.toFieldMap()` → null 제외.
+4. 기존 geocode 분기 + `restaurantService.update(id, fieldMap)`.
+
+## 7. 엣지케이스
+
+- **모든 필드 null**: `toFieldMap()` 빈 Map → no-op (현행 유지).
+- **`tabling_url = "NONE"` / 빈 문자열**: Pattern에 포함 → 통과.
+- **숫자 범위 위반**: 400.
+- **알 수 없는 필드 (예: `xxx`)**: Jackson 기본은 무시 (mapper 설정 유지) → 안전.
+
+## 8. 리스크 & 대안
+
+- **선택**: record + Bean Validation. 코드 최소.
+- **대안 A**: class + setter. 보일러플레이트 다수.
+- **대안 B**: 개별 PATCH endpoint per 필드. 표면 폭증.
+
+## 9. 미해결 질문
+
+- bulkUpdate (batch) 도입 시 별도 DTO — 후속.

docs/design/359a-duplicate-place-id-view/README.md

@@ -0,0 +1,47 @@
+# 설계서: google_place_id 중복 조회 API (#359 1단계)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-15
+> **추적성** — Redmine: #359 · 1단계(조회 전용, 위험 0). 2단계(자동 병합) / 3단계(UNIQUE)는 별도 PR.
+> · 구현 파일: `backend-java/src/main/resources/mybatis/mapper/RestaurantMapper.xml`, `backend-java/src/main/java/com/tasteby/mapper/RestaurantMapper.java`, `backend-java/src/main/java/com/tasteby/service/RestaurantService.java`, `backend-java/src/main/java/com/tasteby/controller/AdminRestaurantController.java`
+> · 테스트: 본 범위 밖 (수동 — admin token으로 호출).
+
+## 1. 목적 (Why)
+
+같은 `google_place_id`에 다중 식당이 매핑된 경우 운영자가 어떤 것을 유지/병합할지 결정 필요. 본 단계는 **조회만** — 그룹과 후보 식당을 메타데이터(연결된 영상/리뷰/메모 수)와 함께 보여줘 의사결정 자료 제공.
+
+## 2. 범위
+
+- 포함: `GET /api/admin/restaurants/duplicates/place-id` — 운영자만, 그룹별 식당 + 카운트 동봉.
+- 제외 (별도 PR): 병합/삭제, UNIQUE constraint.
+
+## 3. 인수조건
+
+- [ ] requireAdmin 보호.
+- [ ] 응답 구조: `[{ google_place_id, items: [{ id, name, address, created_at, video_count, review_count, memo_count, hidden }] }]`.
+- [ ] 그룹은 `COUNT(*) > 1` 만 반환.
+
+## 4. SQL
+
+```sql
+SELECT r.id, r.google_place_id, r.name, r.address,
+       TO_CHAR(r.created_at, 'YYYY-MM-DD"T"HH24:MI:SS') AS created_at,
+       r.hidden,
+       (SELECT COUNT(*) FROM video_restaurants vr WHERE vr.restaurant_id = r.id) AS video_count,
+       (SELECT COUNT(*) FROM reviews rv WHERE rv.restaurant_id = r.id) AS review_count,
+       (SELECT COUNT(*) FROM memos mm WHERE mm.restaurant_id = r.id) AS memo_count
+FROM restaurants r
+WHERE r.google_place_id IN (
+    SELECT google_place_id FROM restaurants
+    WHERE google_place_id IS NOT NULL
+    GROUP BY google_place_id HAVING COUNT(*) > 1
+)
+ORDER BY r.google_place_id, r.created_at
+```
+
+Service 계층에서 google_place_id로 그룹핑하여 응답 구조 변환.
+
+## 5. 엣지케이스
+
+- 중복 0건 → 빈 배열.
+- 누군가가 google_place_id를 동시에 변경 중 → 다음 호출에서 반영 (캐시 X).

docs/design/363-map-sdk-branch/README.md

@@ -0,0 +1,112 @@
+# 설계서: 메인 지도 탭 SDK 국내/해외 분기 (#363)
+
+> **상태**: Approved
+> **작성**: [AI] Architect · **최종수정**: 2026-06-16
+> **추적성** — Redmine: #363 · 부모: v0.1.51 1단계(외부 링크 분기) · 관련: MapView.tsx, mobile nearby
+> · 구현 파일: `frontend/src/components/MapView.tsx`(dispatcher), `frontend/src/components/GoogleMapView.tsx`(rename from 기존 MapView 내용), `frontend/src/components/NaverMapView.tsx`(신규), `frontend/src/lib/map-utils.ts`(공용 헬퍼)
+> · 테스트: 본 범위 밖 (수동 — dev 브라우저 검증)
+
+## 1. 목적 (Why)
+
+현재 MapView는 `@vis.gl/react-google-maps` 단일 사용. 한국 식당은 네이버 지도가 지번/도로명/상호/길찾기에서 압도적으로 정확. 메인 지도 탭 자체를 국내/해외 분기.
+
+## 2. 범위
+
+- 포함: MapView를 dispatcher로 전환, 좌표 기반 자동 분기(KR bbox), 네이버 키 미설정 시 GoogleMap fallback.
+- 제외 (별도 후속): 사용자 강제 토글 UI, mixed 화면(한국+해외 동시) 최적화, 모바일 nearby도 동일 분기는 1차 적용 후 검토.
+
+## 3. 인수조건
+
+- [ ] `NEXT_PUBLIC_NAVER_MAP_CLIENT_ID` 환경변수 설정 + 화면 중심이 KR bbox 안이면 NaverMap 렌더.
+- [ ] 키 미설정 또는 화면이 KR 밖이면 GoogleMap 렌더 (현행 동일).
+- [ ] Supercluster + 클러스터/단일 마커 표시, 클릭 → onSelectRestaurant 콜백 동일.
+- [ ] flyTo, onBoundsChanged, 내 위치, 채널 색상 동일하게 동작.
+- [ ] 빌드/타입 회귀 없음.
+
+## 4. 컨텍스트 & 제약
+
+- 네이버 지도 v3: `https://oapi.map.naver.com/openapi/v3/maps.js?ncpClientId=<ID>` 스크립트 로드.
+- 네이버 좌표계: 기본 WGS84 (`naver.maps.LatLng(lat, lng)`).
+- 직접 wrapper 채택 (react-naver-maps 의존성 제거 — 메인터넌스 리스크).
+- Supercluster는 SDK 독립이라 재사용.
+- KR bbox: 위도 33~38.7, 경도 124~132. 화면 중심좌표가 안에 있으면 한국.
+
+## 5. 아키텍처 개요
+
+```
+MapView (dispatcher)
+   │
+   ├─ 화면 중심 좌표가 KR bbox AND 네이버 키 있음 → NaverMapView
+   │     ├─ <script src=naver maps v3> 동적 로드
+   │     ├─ useEffect: new naver.maps.Map(div, ...)
+   │     ├─ Supercluster로 cluster 계산 → markers div overlay
+   │     └─ flyTo: map.setCenter + setZoom
+   │
+   └─ 그 외 → GoogleMapView (기존 MapView 내용 그대로 이전)
+```
+
+## 6. 함수 명세
+
+| 함수 | 책임 | 비고 |
+|---|---|---|
+| `MapView` (dispatcher) | 좌표 기반 분기 | flyTo 또는 첫 마운트 좌표로 판정 |
+| `GoogleMapView` | 기존 MapView 내용 | rename만, 로직 변경 X |
+| `NaverMapView` | 신규 — 네이버 지도 + Supercluster + markers | wrapper 직접 |
+| `useNaverMaps(clientId)` | 스크립트 로드 + ready boolean | 한 번만 로드 |
+| `isKoreaBounds(lat, lng)` | KR bbox 판정 | map-utils 공용 |
+
+## 7. 흐름
+
+1. MapView 마운트 → flyTo or 첫 식당 평균 좌표로 초기 중심 계산.
+2. KR bbox + 키 있음 → NaverMapView 마운트.
+3. NaverMapView: `useNaverMaps` 훅으로 v3 스크립트 로드, ready되면 `new naver.maps.Map(divRef, options)` 생성.
+4. Supercluster로 cluster 계산 → 마커는 absolute positioned div overlay (네이버 OverlayView 또는 자체 좌표 변환).
+5. 사용자 줌/팬 → bounds_changed 이벤트 → 클러스터 재계산 + onBoundsChanged 콜백.
+
+## 8. 엣지케이스
+
+- **네이버 스크립트 로드 실패**: ready=false 유지, dispatcher가 다음 렌더 사이클에서 GoogleMap fallback.
+- **flyTo가 해외 좌표인데 현재 NaverMap 중**: dispatcher 재판정 → GoogleMap로 교체 (remount).
+- **mixed 화면(한국+해외 식당)**: 화면 중심 기준 SDK 선택 → 다른 나라 식당은 화면 밖에 있어 무관.
+- **키 미설정**: 항상 GoogleMap (회귀 0).
+
+## 9. 리스크 & 대안
+
+- **선택**: 직접 wrapper. 의존성 최소, 유지보수 자유.
+- **대안 A**: `react-naver-maps` npm — 빠른 시작이지만 메인터넌스 상태 불확실.
+- **대안 B**: 단일 SDK(Maplibre + 네이버 타일) — 타일 권리 이슈.
+- **트레이드오프**: 직접 wrapper는 초기 코드 양 ↑이지만 한 번 만들면 안정.
+
+## 10. 미해결 질문
+
+- 한 화면 mixed(국가 경계 근처) 동시 마커 — 후속.
+- 사용자 토글 UI — 후속.
+- 모바일 nearby 동일 분기 — 1차 적용 후 결정.
+
+## 11. 실제 구현 기록 (2026-06-16)
+
+### 배포 흐름
+| 버전 | 내용 |
+|---|---|
+| v0.1.51 | **1단계** — 식당 상세 외부 링크 좌표 기반 분기 (`RestaurantDetail.tsx`) |
+| v0.1.52 | **2단계** — MapView dispatcher + NaverMapView/GoogleMapView 분리 + Dockerfile/deploy.sh build-arg |
+| v0.1.53 | **fix**: 인증 파라미터 `ncpClientId` → `ncpKeyId` (NCLOUD 신 정책, 옛 NAVER Developers와 다름) |
+| v0.1.55–56 | 임시 fallback (운영 일시 GoogleMap, 디버그) |
+| v0.1.57 | **안정화 + 재활성** — divRef 첫 렌더 누락 fix, ResizeObserver/rAF, try/catch |
+
+### 운영 진단에서 확인된 사항
+- NCLOUD Maps Application의 Web 서비스 URL은 **스킴 포함**(`https://...`).
+- 옛 NAVER Developers와 NCLOUD는 다른 시스템 — Search Application과 Maps Application은 도메인 중복 충돌 없음.
+- NCLOUD 콘솔의 신규 경로: `Services > Application Services > Maps > Application`.
+
+### NaverMapView 안정화 핵심 결정사항
+- **`divRef` 항상 마운트** (early return 제거) — `ready=false` 동안에도 div를 두고 로딩 메시지는 overlay로 표시.
+- **명시적 `width:100%; height:100%`** + 회색 배경 — 컨테이너 영역이 시각적으로 확인 가능.
+- **ResizeObserver + requestAnimationFrame**으로 컨테이너 0×0 → 정상 크기 변경 시 `m.refresh(true)`.
+- **try/catch + `initError` state** — init 실패 시 화면 가시화.
+
+### 후속 (별도 PR)
+- 사용자 토글 (네이버/구글 강제 선택) UI.
+- mixed 화면(국경 근처) 동시 마커.
+- 모바일 nearby 탭 동일 분기 검토.
+- 채널 색상/InfoWindow 등 GoogleMapView 수준의 디테일을 NaverMapView에 도입.

frontend/Dockerfile

@@ -6,6 +6,7 @@ RUN npm ci
 COPY . .
 ARG NEXT_PUBLIC_GOOGLE_MAPS_API_KEY
 ARG NEXT_PUBLIC_GOOGLE_CLIENT_ID
+ARG NEXT_PUBLIC_NAVER_MAP_CLIENT_ID
 RUN npm run build
 
 # ── Runtime stage ──

frontend/__tests__/Stars.test.tsx

@@ -0,0 +1,36 @@
+/**
+ * #343 — Stars 컴포넌트 렌더 테스트.
+ */
+import { render, screen } from "@testing-library/react";
+import Stars from "@/components/Stars";
+
+describe("Stars", () => {
+  it("renders 5 star slots", () => {
+    const { container } = render(<Stars rating={3} />);
+    // 빈 별 5개 (text-gray-300 클래스 갖는 span)
+    const emptyStars = container.querySelectorAll("span.text-gray-300");
+    expect(emptyStars.length).toBe(5);
+  });
+
+  it("shows aria-label with rating", () => {
+    render(<Stars rating={4.5} />);
+    expect(screen.getByLabelText("4.5점")).toBeInTheDocument();
+  });
+
+  it("clamps rating to 0~5", () => {
+    render(<Stars rating={-1} />);
+    expect(screen.getByLabelText("0점")).toBeInTheDocument();
+    render(<Stars rating={10} />);
+    expect(screen.getByLabelText("5점")).toBeInTheDocument();
+  });
+
+  it("shows number when showNumber + rating > 0", () => {
+    const { container } = render(<Stars rating={3.5} showNumber />);
+    expect(container.textContent).toContain("3.5");
+  });
+
+  it("does not show number when rating is 0 even with showNumber", () => {
+    const { container } = render(<Stars rating={0} showNumber />);
+    expect(container.textContent).not.toContain("0");
+  });
+});

frontend/__tests__/admin-utils.test.ts

@@ -0,0 +1,28 @@
+/**
+ * #343 — admin-utils 순수 함수 단위 테스트.
+ */
+import { getAdminToken, authHeaders } from "@/lib/admin-utils";
+
+describe("admin-utils", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("getAdminToken returns null when not set", () => {
+    expect(getAdminToken()).toBeNull();
+  });
+
+  it("getAdminToken returns stored token", () => {
+    localStorage.setItem("tasteby_token", "abc123");
+    expect(getAdminToken()).toBe("abc123");
+  });
+
+  it("authHeaders is empty when no token", () => {
+    expect(authHeaders()).toEqual({});
+  });
+
+  it("authHeaders includes Bearer when token set", () => {
+    localStorage.setItem("tasteby_token", "xyz");
+    expect(authHeaders()).toEqual({ Authorization: "Bearer xyz" });
+  });
+});

frontend/__tests__/i18n-config.test.ts

@@ -0,0 +1,42 @@
+/**
+ * #343 — i18n/config 순수 함수 단위 테스트.
+ */
+import { isLocale, detectBrowserLocale, DEFAULT_LOCALE } from "@/i18n/config";
+
+describe("i18n/config.isLocale", () => {
+  it("returns true for supported locales", () => {
+    expect(isLocale("ko")).toBe(true);
+    expect(isLocale("en")).toBe(true);
+    expect(isLocale("ja")).toBe(true);
+    expect(isLocale("es")).toBe(true);
+  });
+
+  it("returns false for unsupported / null / undefined", () => {
+    expect(isLocale("fr")).toBe(false);
+    expect(isLocale("zh")).toBe(false);
+    expect(isLocale(null)).toBe(false);
+    expect(isLocale(undefined)).toBe(false);
+    expect(isLocale("")).toBe(false);
+  });
+});
+
+describe("i18n/config.detectBrowserLocale", () => {
+  // jsdom의 navigator.language는 기본 'en-US'
+  it("returns supported locale from navigator.language", () => {
+    Object.defineProperty(navigator, "language", { value: "en-US", configurable: true });
+    expect(detectBrowserLocale()).toBe("en");
+    Object.defineProperty(navigator, "language", { value: "ko-KR", configurable: true });
+    expect(detectBrowserLocale()).toBe("ko");
+    Object.defineProperty(navigator, "language", { value: "ja", configurable: true });
+    expect(detectBrowserLocale()).toBe("ja");
+    Object.defineProperty(navigator, "language", { value: "es-MX", configurable: true });
+    expect(detectBrowserLocale()).toBe("es");
+  });
+
+  it("falls back to DEFAULT_LOCALE for unsupported", () => {
+    Object.defineProperty(navigator, "language", { value: "fr-FR", configurable: true });
+    expect(detectBrowserLocale()).toBe(DEFAULT_LOCALE);
+    Object.defineProperty(navigator, "language", { value: "zh-CN", configurable: true });
+    expect(detectBrowserLocale()).toBe(DEFAULT_LOCALE);
+  });
+});

frontend/jest.config.ts

@@ -0,0 +1,21 @@
+// #343 — Jest 설정. next/jest로 SWC 자동 통합.
+
+import type { Config } from "jest";
+import nextJest from "next/jest.js";
+
+const createJestConfig = nextJest({
+  // 테스트 환경의 Next.js 앱 루트
+  dir: "./",
+});
+
+const customConfig: Config = {
+  // jest-dom matchers는 setupFilesAfterEnv로 등록 (Jest framework 로드 후)
+  setupFilesAfterEnv: ["<rootDir>/jest.setup.ts"],
+  testEnvironment: "jsdom",
+  moduleNameMapper: {
+    "^@/(.*)$": "<rootDir>/src/$1",
+  },
+  testPathIgnorePatterns: ["<rootDir>/.next/", "<rootDir>/node_modules/"],
+};
+
+export default createJestConfig(customConfig);

frontend/jest.setup.ts

@@ -0,0 +1,2 @@
+// #343 — Jest setup. @testing-library/jest-dom matchers 확장.
+import "@testing-library/jest-dom";

frontend/next.config.ts

@@ -2,6 +2,14 @@ import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
   output: "standalone",
+  // #343 — 외부 이미지 도메인 허용 (next/image)
+  images: {
+    remotePatterns: [
+      { protocol: "https", hostname: "lh3.googleusercontent.com" }, // Google avatar
+      { protocol: "https", hostname: "i.ytimg.com" },               // YouTube thumbnail
+      { protocol: "https", hostname: "yt3.ggpht.com" },             // YouTube channel avatar
+    ],
+  },
 };
 
 export default nextConfig;

frontend/package.json

@@ -6,25 +6,35 @@
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
-    "lint": "eslint"
+    "lint": "eslint",
+    "test": "jest",
+    "test:watch": "jest --watch"
   },
   "dependencies": {
+    "@phosphor-icons/react": "^2.1.10",
     "@react-oauth/google": "^0.13.4",
     "@tabler/icons-react": "^3.40.0",
     "@types/supercluster": "^7.1.3",
     "@vis.gl/react-google-maps": "^1.7.1",
     "next": "16.1.6",
+    "next-intl": "^4.13.0",
     "react": "19.2.3",
     "react-dom": "19.2.3",
     "supercluster": "^8.0.1"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/jest": "^30.0.0",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "eslint": "^9",
     "eslint-config-next": "16.1.6",
+    "jest": "^30.4.2",
+    "jest-environment-jsdom": "^30.4.1",
     "tailwindcss": "^4",
     "typescript": "^5"
   }

frontend/src/app/admin/_panels/ChannelsPanel.tsx

@@ -0,0 +1,222 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { api } from "@/lib/api";
+import type { Channel } from "@/lib/api";
+
+// #329 — admin/page.tsx에서 추출 (내부 로직 그대로)
+export function ChannelsPanel({ isAdmin }: { isAdmin: boolean }) {
+  const [channels, setChannels] = useState<Channel[]>([]);
+  const [newId, setNewId] = useState("");
+  const [newName, setNewName] = useState("");
+  const [newFilter, setNewFilter] = useState("");
+  const [loading, setLoading] = useState(false);
+  const [scanResult, setScanResult] = useState<Record<string, string>>({});
+
+  const load = useCallback(() => {
+    api.getChannels().then(setChannels).catch(console.error);
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  const handleAdd = async () => {
+    if (!newId.trim() || !newName.trim()) return;
+    setLoading(true);
+    try {
+      await api.addChannel(newId.trim(), newName.trim(), newFilter.trim() || undefined);
+      setNewId("");
+      setNewName("");
+      setNewFilter("");
+      load();
+    } catch (e: unknown) {
+      alert(e instanceof Error ? e.message : "채널 추가 실패");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const [editingChannel, setEditingChannel] = useState<string | null>(null);
+  const [editDesc, setEditDesc] = useState("");
+  const [editTags, setEditTags] = useState("");
+  const [editOrder, setEditOrder] = useState<number>(99);
+
+  const handleSaveChannel = async (id: string) => {
+    try {
+      await api.updateChannel(id, { description: editDesc, tags: editTags, sort_order: editOrder });
+      setEditingChannel(null);
+      load();
+    } catch {
+      alert("채널 수정 실패");
+    }
+  };
+
+  const handleDelete = async (channelId: string, channelName: string) => {
+    if (!confirm(`"${channelName}" 채널을 삭제하시겠습니까?`)) return;
+    try {
+      await api.deleteChannel(channelId);
+      load();
+    } catch {
+      alert("채널 삭제 실패");
+    }
+  };
+
+  const handleScan = async (channelId: string, full: boolean = false) => {
+    setScanResult((prev) => ({ ...prev, [channelId]: full ? "전체 스캔 중..." : "스캔 중..." }));
+    try {
+      const res = await api.scanChannel(channelId, full);
+      setScanResult((prev) => ({
+        ...prev,
+        [channelId]: `${res.total_fetched}개 조회, ${res.new_videos}개 신규${(res as Record<string, unknown>).filtered ? `, ${(res as Record<string, unknown>).filtered}개 필터링` : ""}`,
+      }));
+    } catch {
+      setScanResult((prev) => ({ ...prev, [channelId]: "스캔 실패" }));
+    }
+  };
+
+  return (
+    <div>
+      {isAdmin && <div className="bg-surface rounded-lg shadow p-4 mb-6">
+        <h2 className="font-semibold mb-3">채널 추가</h2>
+        <div className="flex gap-2">
+          <input
+            placeholder="YouTube Channel ID"
+            value={newId}
+            onChange={(e) => setNewId(e.target.value)}
+            className="border rounded px-3 py-2 flex-1 text-sm bg-surface text-gray-900"
+          />
+          <input
+            placeholder="채널 이름"
+            value={newName}
+            onChange={(e) => setNewName(e.target.value)}
+            className="border rounded px-3 py-2 flex-1 text-sm bg-surface text-gray-900"
+          />
+          <input
+            placeholder="제목 필터 (선택)"
+            value={newFilter}
+            onChange={(e) => setNewFilter(e.target.value)}
+            className="border rounded px-3 py-2 w-40 text-sm bg-surface text-gray-900"
+          />
+          <button
+            onClick={handleAdd}
+            disabled={loading}
+            className="bg-brand-600 text-white px-4 py-2 rounded text-sm hover:bg-brand-700 disabled:opacity-50"
+          >
+            추가
+          </button>
+        </div>
+      </div>}
+
+      <div className="bg-surface rounded-lg shadow">
+        <table className="w-full text-sm">
+          <thead className="bg-brand-50 border-b border-brand-100 text-brand-800 text-sm font-semibold">
+            <tr>
+              <th className="text-left px-4 py-3">채널 이름</th>
+              <th className="text-left px-4 py-3">Channel ID</th>
+              <th className="text-left px-4 py-3">제목 필터</th>
+              <th className="text-left px-4 py-3">설명</th>
+              <th className="text-left px-4 py-3">태그</th>
+              <th className="text-center px-4 py-3">순서</th>
+              <th className="text-right px-4 py-3">영상 수</th>
+              {isAdmin && <th className="text-left px-4 py-3">액션</th>}
+              <th className="text-left px-4 py-3">스캔 결과</th>
+            </tr>
+          </thead>
+          <tbody>
+            {channels.map((ch) => (
+              <tr key={ch.id} className="border-b hover:bg-brand-50/50">
+                <td className="px-4 py-3 font-medium">{ch.channel_name}</td>
+                <td className="px-4 py-3 text-gray-500 font-mono text-xs">
+                  {ch.channel_id}
+                </td>
+                <td className="px-4 py-3 text-sm">
+                  {ch.title_filter ? (
+                    <span className="px-2 py-0.5 bg-brand-50 text-brand-700 rounded text-xs">
+                      {ch.title_filter}
+                    </span>
+                  ) : (
+                    <span className="text-gray-400 text-xs">전체</span>
+                  )}
+                </td>
+                <td className="px-4 py-3 text-xs">
+                  {editingChannel === ch.id ? (
+                    <input value={editDesc} onChange={(e) => setEditDesc(e.target.value)}
+                      className="border rounded px-2 py-1 text-xs w-32 bg-surface text-gray-900" placeholder="설명" />
+                  ) : (
+                    <span className="text-gray-600 cursor-pointer" onClick={() => {
+                      if (!isAdmin) return;
+                      setEditingChannel(ch.id); setEditDesc(ch.description || ""); setEditTags(ch.tags || ""); setEditOrder(ch.sort_order ?? 99);
+                    }}>{ch.description || <span className="text-gray-400">-</span>}</span>
+                  )}
+                </td>
+                <td className="px-4 py-3 text-xs">
+                  {editingChannel === ch.id ? (
+                    <div className="flex gap-1">
+                      <input value={editTags} onChange={(e) => setEditTags(e.target.value)}
+                        className="border rounded px-2 py-1 text-xs w-40 bg-surface text-gray-900" placeholder="태그 (쉼표 구분)" />
+                      <button onClick={() => handleSaveChannel(ch.id)} className="text-brand-600 text-xs hover:underline">저장</button>
+                      <button onClick={() => setEditingChannel(null)} className="text-gray-400 text-xs hover:underline">취소</button>
+                    </div>
+                  ) : (
+                    <span className="text-gray-500 cursor-pointer" onClick={() => {
+                      if (!isAdmin) return;
+                      setEditingChannel(ch.id); setEditDesc(ch.description || ""); setEditTags(ch.tags || ""); setEditOrder(ch.sort_order ?? 99);
+                    }}>{ch.tags ? ch.tags.split(",").map(t => t.trim()).join(", ") : <span className="text-gray-400">-</span>}</span>
+                  )}
+                </td>
+                <td className="px-4 py-3 text-center text-xs">
+                  {editingChannel === ch.id ? (
+                    <input type="number" value={editOrder} onChange={(e) => setEditOrder(Number(e.target.value))}
+                      className="border rounded px-2 py-1 text-xs w-14 text-center bg-surface text-gray-900" min={1} />
+                  ) : (
+                    <span className="text-gray-500">{ch.sort_order ?? 99}</span>
+                  )}
+                </td>
+                <td className="px-4 py-3 text-right font-medium">
+                  {ch.video_count > 0 ? (
+                    <span className="px-2 py-0.5 bg-green-50 text-green-700 rounded text-xs">{ch.video_count}개</span>
+                  ) : (
+                    <span className="text-gray-400 text-xs">0</span>
+                  )}
+                </td>
+                {isAdmin && <td className="px-4 py-3 flex gap-3">
+                  <button
+                    onClick={() => handleScan(ch.channel_id)}
+                    className="text-brand-600 hover:underline text-sm"
+                  >
+                    스캔
+                  </button>
+                  <button
+                    onClick={() => handleScan(ch.channel_id, true)}
+                    className="text-purple-600 hover:underline text-sm"
+                  >
+                    전체 스캔
+                  </button>
+                  <button
+                    onClick={() => handleDelete(ch.id, ch.channel_name)}
+                    className="text-red-500 hover:underline text-sm"
+                  >
+                    삭제
+                  </button>
+                </td>}
+                <td className="px-4 py-3 text-gray-600">
+                  {scanResult[ch.channel_id] || "-"}
+                </td>
+              </tr>
+            ))}
+            {channels.length === 0 && (
+              <tr>
+                <td colSpan={7} className="px-4 py-8 text-center text-gray-400">
+                  등록된 채널이 없습니다
+                </td>
+              </tr>
+            )}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  );
+}
+
+/* ─── 영상 관리 ─── */
+type VideoSortKey = "status" | "channel_name" | "title" | "published_at";
+

frontend/src/app/admin/_panels/DaemonPanel.tsx

@@ -0,0 +1,231 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { api } from "@/lib/api";
+import type { DaemonConfig } from "@/lib/api";
+
+// #329 — admin/page.tsx에서 추출
+export function DaemonPanel({ isAdmin }: { isAdmin: boolean }) {
+  const [config, setConfig] = useState<DaemonConfig | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [running, setRunning] = useState<string | null>(null);
+  const [result, setResult] = useState<string | null>(null);
+
+  // Editable fields
+  const [scanEnabled, setScanEnabled] = useState(false);
+  const [scanInterval, setScanInterval] = useState(60);
+  const [processEnabled, setProcessEnabled] = useState(false);
+  const [processInterval, setProcessInterval] = useState(60);
+  const [processLimit, setProcessLimit] = useState(10);
+
+  const load = useCallback(() => {
+    setLoading(true);
+    api.getDaemonConfig().then((cfg) => {
+      setConfig(cfg);
+      setScanEnabled(cfg.scan_enabled);
+      setScanInterval(cfg.scan_interval_min);
+      setProcessEnabled(cfg.process_enabled);
+      setProcessInterval(cfg.process_interval_min);
+      setProcessLimit(cfg.process_limit);
+    }).catch(console.error).finally(() => setLoading(false));
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  const handleSave = async () => {
+    setSaving(true);
+    setResult(null);
+    try {
+      await api.updateDaemonConfig({
+        scan_enabled: scanEnabled,
+        scan_interval_min: scanInterval,
+        process_enabled: processEnabled,
+        process_interval_min: processInterval,
+        process_limit: processLimit,
+      });
+      setResult("설정 저장 완료");
+      load();
+    } catch (e: unknown) {
+      setResult(e instanceof Error ? e.message : "저장 실패");
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const handleRunScan = async () => {
+    setRunning("scan");
+    setResult(null);
+    try {
+      const res = await api.runDaemonScan();
+      setResult(`채널 스캔 완료: 신규 ${res.new_videos}개 영상`);
+      load();
+    } catch (e: unknown) {
+      setResult(e instanceof Error ? e.message : "스캔 실패");
+    } finally {
+      setRunning(null);
+    }
+  };
+
+  const handleRunProcess = async () => {
+    setRunning("process");
+    setResult(null);
+    try {
+      const res = await api.runDaemonProcess(processLimit);
+      setResult(`영상 처리 완료: ${res.restaurants_extracted}개 식당 추출`);
+      load();
+    } catch (e: unknown) {
+      setResult(e instanceof Error ? e.message : "처리 실패");
+    } finally {
+      setRunning(null);
+    }
+  };
+
+  if (loading) return <p className="text-gray-500">로딩 중...</p>;
+
+  return (
+    <div className="space-y-6">
+      {/* Schedule Config */}
+      <div className="bg-surface rounded-lg shadow p-6">
+        <h2 className="text-lg font-semibold mb-4">스케줄 설정</h2>
+        <p className="text-xs text-gray-500 mb-4">
+          데몬이 실행 중일 때, 아래 설정에 따라 자동으로 채널 스캔 및 영상 처리를 수행합니다.
+        </p>
+
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-6">
+          {/* Scan config */}
+          <div className="border rounded-lg p-4 space-y-3">
+            <div className="flex items-center justify-between">
+              <h3 className="font-medium">채널 스캔</h3>
+              <label className="flex items-center gap-2 cursor-pointer">
+                <input
+                  type="checkbox"
+                  checked={scanEnabled}
+                  onChange={(e) => setScanEnabled(e.target.checked)}
+                  disabled={!isAdmin}
+                  className="w-4 h-4"
+                />
+                <span className={`text-sm ${scanEnabled ? "text-green-600 font-medium" : "text-gray-500"}`}>
+                  {scanEnabled ? "활성" : "비활성"}
+                </span>
+              </label>
+            </div>
+            <div>
+              <label className="block text-xs text-gray-500 mb-1">주기 (분)</label>
+              <input
+                type="number"
+                value={scanInterval}
+                onChange={(e) => setScanInterval(Number(e.target.value))}
+                disabled={!isAdmin}
+                min={1}
+                className="border rounded px-3 py-1.5 text-sm w-32"
+              />
+            </div>
+            {config?.last_scan_at && (
+              <p className="text-xs text-gray-400">마지막 스캔: {config.last_scan_at}</p>
+            )}
+          </div>
+
+          {/* Process config */}
+          <div className="border rounded-lg p-4 space-y-3">
+            <div className="flex items-center justify-between">
+              <h3 className="font-medium">영상 처리</h3>
+              <label className="flex items-center gap-2 cursor-pointer">
+                <input
+                  type="checkbox"
+                  checked={processEnabled}
+                  onChange={(e) => setProcessEnabled(e.target.checked)}
+                  disabled={!isAdmin}
+                  className="w-4 h-4"
+                />
+                <span className={`text-sm ${processEnabled ? "text-green-600 font-medium" : "text-gray-500"}`}>
+                  {processEnabled ? "활성" : "비활성"}
+                </span>
+              </label>
+            </div>
+            <div className="flex gap-4">
+              <div>
+                <label className="block text-xs text-gray-500 mb-1">주기 (분)</label>
+                <input
+                  type="number"
+                  value={processInterval}
+                  onChange={(e) => setProcessInterval(Number(e.target.value))}
+                  disabled={!isAdmin}
+                  min={1}
+                  className="border rounded px-3 py-1.5 text-sm w-32"
+                />
+              </div>
+              <div>
+                <label className="block text-xs text-gray-500 mb-1">처리 건수</label>
+                <input
+                  type="number"
+                  value={processLimit}
+                  onChange={(e) => setProcessLimit(Number(e.target.value))}
+                  disabled={!isAdmin}
+                  min={1}
+                  max={50}
+                  className="border rounded px-3 py-1.5 text-sm w-32"
+                />
+              </div>
+            </div>
+            {config?.last_process_at && (
+              <p className="text-xs text-gray-400">마지막 처리: {config.last_process_at}</p>
+            )}
+          </div>
+        </div>
+
+        {isAdmin && (
+          <div className="mt-4">
+            <button
+              onClick={handleSave}
+              disabled={saving}
+              className="px-4 py-2 bg-brand-600 text-white text-sm rounded hover:bg-brand-700 disabled:opacity-50"
+            >
+              {saving ? "저장 중..." : "설정 저장"}
+            </button>
+          </div>
+        )}
+      </div>
+
+      {/* Manual Triggers */}
+      <div className="bg-surface rounded-lg shadow p-6">
+        <h2 className="text-lg font-semibold mb-4">수동 실행</h2>
+        <p className="text-xs text-gray-500 mb-4">
+          스케줄과 관계없이 즉시 실행합니다. 처리 시간이 걸릴 수 있습니다.
+        </p>
+
+        <div className="flex gap-3">
+          {isAdmin && (
+            <>
+              <button
+                onClick={handleRunScan}
+                disabled={running !== null}
+                className="px-4 py-2 bg-green-600 text-white text-sm rounded hover:bg-green-700 disabled:opacity-50"
+              >
+                {running === "scan" ? "스캔 중..." : "채널 스캔 실행"}
+              </button>
+              <button
+                onClick={handleRunProcess}
+                disabled={running !== null}
+                className="px-4 py-2 bg-purple-600 text-white text-sm rounded hover:bg-purple-700 disabled:opacity-50"
+              >
+                {running === "process" ? "처리 중..." : "영상 처리 실행"}
+              </button>
+            </>
+          )}
+        </div>
+
+        {result && (
+          <p className={`mt-3 text-sm ${result.includes("실패") || result.includes("API") ? "text-red-600" : "text-green-600"}`}>
+            {result}
+          </p>
+        )}
+      </div>
+
+      {/* Config updated_at */}
+      {config?.updated_at && (
+        <p className="text-xs text-gray-400 text-right">설정 수정일: {config.updated_at}</p>
+      )}
+    </div>
+  );
+}

frontend/src/app/admin/_panels/RestaurantsPanel.tsx

@@ -0,0 +1,654 @@
+"use client";
+import { getAdminToken, consumeSseStream } from "@/lib/admin-utils";
+
+import { useCallback, useEffect, useState } from "react";
+import { api } from "@/lib/api";
+import type { Restaurant, VideoLink } from "@/lib/api";
+
+// #329 — admin/page.tsx에서 추출
+export function RestaurantsPanel({ isAdmin }: { isAdmin: boolean }) {
+  const [restaurants, setRestaurants] = useState<Restaurant[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [page, setPage] = useState(0);
+  const [nameSearch, setNameSearch] = useState("");
+  const [selected, setSelected] = useState<Restaurant | null>(null);
+  const [editForm, setEditForm] = useState<Record<string, string>>({});
+  const [saving, setSaving] = useState(false);
+  const [videos, setVideos] = useState<VideoLink[]>([]);
+  const [tablingSearching, setTablingSearching] = useState(false);
+  const [bulkTabling, setBulkTabling] = useState(false);
+  const [bulkTablingProgress, setBulkTablingProgress] = useState({ current: 0, total: 0, name: "", linked: 0, notFound: 0 });
+  const [catchtableSearching, setCatchtableSearching] = useState(false);
+  const [bulkCatchtable, setBulkCatchtable] = useState(false);
+  const [bulkCatchtableProgress, setBulkCatchtableProgress] = useState({ current: 0, total: 0, name: "", linked: 0, notFound: 0 });
+  type RestSortKey = "name" | "region" | "cuisine_type" | "price_range" | "rating" | "business_status";
+  const [sortKey, setSortKey] = useState<RestSortKey>("name");
+  const [sortAsc, setSortAsc] = useState(true);
+  const perPage = 20;
+
+  const handleSort = (key: RestSortKey) => {
+    if (sortKey === key) setSortAsc(!sortAsc);
+    else { setSortKey(key); setSortAsc(true); }
+  };
+  const sortIcon = (key: RestSortKey) => sortKey !== key ? " ↕" : sortAsc ? " ↑" : " ↓";
+
+  const load = useCallback(() => {
+    setLoading(true);
+    api
+      .getRestaurants({ limit: 500 })
+      .then(setRestaurants)
+      .catch(console.error)
+      .finally(() => setLoading(false));
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  // #322/#323 LLM 검증 UI
+  const [verifyPending, setVerifyPending] = useState<number | null>(null);
+  const [verifying, setVerifying] = useState(false);
+  const [verifyResult, setVerifyResult] = useState<string | null>(null);
+
+  const loadVerifyPending = useCallback(() => {
+    api.getVerifyPending().then((r) => setVerifyPending(r.pending)).catch(() => setVerifyPending(null));
+  }, []);
+  useEffect(() => { loadVerifyPending(); }, [loadVerifyPending]);
+
+  const handleVerifyAll = async () => {
+    if (!isAdmin) return;
+    if (!confirm(`미검증 식당 ${verifyPending ?? "?"}건을 LLM으로 일괄 검증합니다.\n잘못 등록된 데이터/프랜차이즈를 자동으로 숨김 처리합니다.\n진행할까요?`)) return;
+    setVerifying(true);
+    setVerifyResult(null);
+    try {
+      const r = await api.verifyAll(10);
+      setVerifyResult(`${r.processed}건 검증 완료`);
+      loadVerifyPending();
+      load();
+    } catch (e) {
+      setVerifyResult(`실패: ${e instanceof Error ? e.message : String(e)}`);
+    } finally {
+      setVerifying(false);
+    }
+  };
+
+  const handleToggleHidden = async (r: Restaurant) => {
+    if (!isAdmin) return;
+    const becomingHidden = !r.hidden;
+    const reason = becomingHidden ? (prompt("숨김 사유(선택)", "manual") ?? "manual") : "";
+    try {
+      await api.setRestaurantHidden(r.id, becomingHidden, reason || "manual");
+      load();
+    } catch (e) {
+      alert(`실패: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  };
+
+  const filtered = restaurants.filter((r) => {
+    if (nameSearch && !r.name.toLowerCase().includes(nameSearch.toLowerCase())) return false;
+    return true;
+  });
+
+  const sorted = [...filtered].sort((a, b) => {
+    let av: string | number = a[sortKey] ?? "";
+    let bv: string | number = b[sortKey] ?? "";
+    if (sortKey === "rating") {
+      av = a.rating ?? 0;
+      bv = b.rating ?? 0;
+    }
+    const cmp = av < bv ? -1 : av > bv ? 1 : 0;
+    return sortAsc ? cmp : -cmp;
+  });
+
+  const totalPages = Math.max(1, Math.ceil(sorted.length / perPage));
+  const paged = sorted.slice(page * perPage, (page + 1) * perPage);
+
+  const handleSelect = (r: Restaurant) => {
+    if (selected?.id === r.id) {
+      setSelected(null);
+      setVideos([]);
+      return;
+    }
+    setSelected(r);
+    api.getRestaurantVideos(r.id).then(setVideos).catch(() => setVideos([]));
+    setEditForm({
+      name: r.name || "",
+      address: r.address || "",
+      region: r.region || "",
+      cuisine_type: r.cuisine_type || "",
+      price_range: r.price_range || "",
+      phone: r.phone || "",
+      website: r.website || "",
+      latitude: r.latitude != null ? String(r.latitude) : "",
+      longitude: r.longitude != null ? String(r.longitude) : "",
+    });
+  };
+
+  const handleSave = async () => {
+    if (!selected) return;
+    setSaving(true);
+    try {
+      const data: Record<string, unknown> = { ...editForm };
+      if (editForm.latitude) data.latitude = parseFloat(editForm.latitude);
+      else data.latitude = null;
+      if (editForm.longitude) data.longitude = parseFloat(editForm.longitude);
+      else data.longitude = null;
+      await api.updateRestaurant(selected.id, data as Partial<Restaurant>);
+      load();
+      setSelected(null);
+    } catch (e) {
+      alert("저장 실패: " + (e instanceof Error ? e.message : String(e)));
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const handleDelete = async () => {
+    if (!selected) return;
+    if (!confirm(`"${selected.name}" 식당을 삭제하시겠습니까?\n연결된 영상 매핑, 리뷰, 벡터도 함께 삭제됩니다.`)) return;
+    try {
+      await api.deleteRestaurant(selected.id);
+      setSelected(null);
+      load();
+    } catch {
+      alert("삭제 실패");
+    }
+  };
+
+  return (
+    <div>
+      <div className="flex items-center gap-3 mb-4">
+        <div className="flex">
+          <input
+            type="text"
+            placeholder="식당 이름 검색..."
+            value={nameSearch}
+            onChange={(e) => { setNameSearch(e.target.value); setPage(0); }}
+            onKeyDown={(e) => e.key === "Escape" && setNameSearch("")}
+            className="border border-r-0 rounded-l px-3 py-2 text-sm w-48 bg-surface text-gray-900"
+          />
+          {nameSearch ? (
+            <button
+              onClick={() => { setNameSearch(""); setPage(0); }}
+              className="border rounded-r px-2 py-2 text-sm text-gray-400 hover:text-gray-600 hover:bg-gray-100"
+            >
+              ✕
+            </button>
+          ) : (
+            <button
+              onClick={() => load()}
+              className="border rounded-r px-2 py-2 text-sm text-gray-400 hover:text-gray-600 hover:bg-gray-100"
+              title="새로고침"
+            >
+              ↻
+            </button>
+          )}
+        </div>
+        {isAdmin && (<>
+          {/* #322/#323 — LLM 검증 */}
+          <div className="flex items-center gap-2 text-xs text-gray-600 dark:text-gray-400">
+            <span>미검증 {verifyPending ?? "?"}건</span>
+            <button
+              onClick={handleVerifyAll}
+              disabled={verifying || verifyPending === 0}
+              className="px-3 py-1 text-xs rounded bg-amber-500 hover:bg-amber-600 text-white disabled:opacity-50 disabled:cursor-not-allowed"
+            >
+              {verifying ? "검증 중..." : "LLM 검증"}
+            </button>
+            {verifyResult && <span className="text-amber-600">{verifyResult}</span>}
+          </div>
+          <button
+            onClick={async () => {
+              const pending = await fetch(`/api/restaurants/tabling-pending`, {
+                headers: { Authorization: `Bearer ${getAdminToken()}` },
+              }).then(r => r.json());
+              if (pending.count === 0) { alert("테이블링 미연결 식당이 없습니다"); return; }
+              if (!confirm(`테이블링 미연결 식당 ${pending.count}개를 벌크 검색합니다.\n식당당 5~15초 소요됩니다. 진행할까요?`)) return;
+              setBulkTabling(true);
+              setBulkTablingProgress({ current: 0, total: pending.count, name: "", linked: 0, notFound: 0 });
+              try {
+                const res = await fetch("/api/restaurants/bulk-tabling", {
+                  method: "POST",
+                  headers: { Authorization: `Bearer ${getAdminToken()}` },
+                });
+                // #351 — consumeSseStream으로 통일
+                await consumeSseStream(res, (raw) => {
+                  const evt = raw as { type: string; [k: string]: unknown };
+                  if (evt.type === "processing" || evt.type === "done" || evt.type === "notfound" || evt.type === "error") {
+                    setBulkTablingProgress(p => ({
+                      ...p, current: evt.current as number, total: (evt.total as number) || p.total, name: evt.name as string,
+                      linked: evt.type === "done" ? p.linked + 1 : p.linked,
+                      notFound: (evt.type === "notfound" || evt.type === "error") ? p.notFound + 1 : p.notFound,
+                    }));
+                  } else if (evt.type === "complete") {
+                    alert(`완료! 연결: ${evt.linked}개, 미발견: ${evt.notFound}개`);
+                  }
+                });
+              } catch (e) { alert("벌크 테이블링 실패: " + (e instanceof Error ? e.message : String(e))); }
+              finally { setBulkTabling(false); load(); }
+            }}
+            disabled={bulkTabling}
+            className="px-3 py-1.5 text-xs bg-brand-500 text-white rounded hover:bg-brand-600 disabled:opacity-50"
+          >
+            {bulkTabling ? `테이블링 검색 중 (${bulkTablingProgress.current}/${bulkTablingProgress.total})` : "벌크 테이블링 연결"}
+          </button>
+          <button
+            onClick={async () => {
+              if (!confirm("테이블링 매핑을 전부 초기화하시겠습니까?")) return;
+              try {
+                await fetch("/api/restaurants/reset-tabling", {
+                  method: "DELETE",
+                  headers: { Authorization: `Bearer ${getAdminToken()}` },
+                });
+                alert("테이블링 매핑 초기화 완료");
+                load();
+              } catch (e) { alert("실패: " + e); }
+            }}
+            className="px-3 py-1.5 text-xs bg-red-50 text-red-600 border border-red-200 rounded hover:bg-red-100"
+          >
+            테이블링 초기화
+          </button>
+          <button
+            onClick={async () => {
+              if (!confirm("캐치테이블 매핑을 전부 초기화하시겠습니까?")) return;
+              try {
+                await fetch("/api/restaurants/reset-catchtable", {
+                  method: "DELETE",
+                  headers: { Authorization: `Bearer ${getAdminToken()}` },
+                });
+                alert("캐치테이블 매핑 초기화 완료");
+                load();
+              } catch (e) { alert("실패: " + e); }
+            }}
+            className="px-3 py-1.5 text-xs bg-red-50 text-red-600 border border-red-200 rounded hover:bg-red-100"
+          >
+            캐치테이블 초기화
+          </button>
+          <button
+            onClick={async () => {
+              const pending = await fetch(`/api/restaurants/catchtable-pending`, {
+                headers: { Authorization: `Bearer ${getAdminToken()}` },
+              }).then(r => r.json());
+              if (pending.count === 0) { alert("캐치테이블 미연결 식당이 없습니다"); return; }
+              if (!confirm(`캐치테이블 미연결 식당 ${pending.count}개를 벌크 검색합니다.\n식당당 5~15초 소요됩니다. 진행할까요?`)) return;
+              setBulkCatchtable(true);
+              setBulkCatchtableProgress({ current: 0, total: pending.count, name: "", linked: 0, notFound: 0 });
+              try {
+                const res = await fetch("/api/restaurants/bulk-catchtable", {
+                  method: "POST",
+                  headers: { Authorization: `Bearer ${getAdminToken()}` },
+                });
+                // #351 — consumeSseStream으로 통일
+                await consumeSseStream(res, (raw) => {
+                  const evt = raw as { type: string; [k: string]: unknown };
+                  if (evt.type === "processing" || evt.type === "done" || evt.type === "notfound" || evt.type === "error") {
+                    setBulkCatchtableProgress(p => ({
+                      ...p, current: evt.current as number, total: (evt.total as number) || p.total, name: evt.name as string,
+                      linked: evt.type === "done" ? p.linked + 1 : p.linked,
+                      notFound: (evt.type === "notfound" || evt.type === "error") ? p.notFound + 1 : p.notFound,
+                    }));
+                  } else if (evt.type === "complete") {
+                    alert(`완료! 연결: ${evt.linked}개, 미발견: ${evt.notFound}개`);
+                  }
+                });
+              } catch (e) { alert("벌크 캐치테이블 실패: " + (e instanceof Error ? e.message : String(e))); }
+              finally { setBulkCatchtable(false); load(); }
+            }}
+            disabled={bulkCatchtable}
+            className="px-3 py-1.5 text-xs bg-violet-500 text-white rounded hover:bg-violet-600 disabled:opacity-50"
+          >
+            {bulkCatchtable ? `캐치테이블 검색 중 (${bulkCatchtableProgress.current}/${bulkCatchtableProgress.total})` : "벌크 캐치테이블 연결"}
+          </button>
+        </>)}
+        <span className="text-sm text-gray-400 ml-auto">
+          {nameSearch ? `${sorted.length} / ` : ""}총 {restaurants.length}개 식당
+        </span>
+      </div>
+      {bulkTabling && bulkTablingProgress.name && (
+        <div className="bg-brand-50 rounded p-3 mb-4 text-sm">
+          <div className="flex justify-between mb-1">
+            <span>{bulkTablingProgress.current}/{bulkTablingProgress.total} - {bulkTablingProgress.name}</span>
+            <span className="text-xs text-gray-500">연결: {bulkTablingProgress.linked} / 미발견: {bulkTablingProgress.notFound}</span>
+          </div>
+          <div className="w-full bg-brand-200 rounded-full h-1.5">
+            <div className="bg-brand-500 h-1.5 rounded-full transition-all" style={{ width: `${(bulkTablingProgress.current / bulkTablingProgress.total) * 100}%` }} />
+          </div>
+        </div>
+      )}
+      {bulkCatchtable && bulkCatchtableProgress.name && (
+        <div className="bg-violet-50 rounded p-3 mb-4 text-sm">
+          <div className="flex justify-between mb-1">
+            <span>{bulkCatchtableProgress.current}/{bulkCatchtableProgress.total} - {bulkCatchtableProgress.name}</span>
+            <span className="text-xs text-gray-500">연결: {bulkCatchtableProgress.linked} / 미발견: {bulkCatchtableProgress.notFound}</span>
+          </div>
+          <div className="w-full bg-violet-200 rounded-full h-1.5">
+            <div className="bg-violet-500 h-1.5 rounded-full transition-all" style={{ width: `${(bulkCatchtableProgress.current / bulkCatchtableProgress.total) * 100}%` }} />
+          </div>
+        </div>
+      )}
+
+      <div className="bg-surface rounded-lg shadow overflow-auto">
+        <table className="w-full text-sm">
+          <thead className="bg-brand-50 border-b border-brand-100 text-brand-800 text-sm font-semibold">
+            <tr>
+              <th className="text-left px-4 py-3 cursor-pointer select-none hover:bg-gray-100" onClick={() => handleSort("name")}>이름{sortIcon("name")}</th>
+              <th className="text-left px-4 py-3 cursor-pointer select-none hover:bg-gray-100" onClick={() => handleSort("region")}>지역{sortIcon("region")}</th>
+              <th className="text-left px-4 py-3 cursor-pointer select-none hover:bg-gray-100" onClick={() => handleSort("cuisine_type")}>음식 종류{sortIcon("cuisine_type")}</th>
+              <th className="text-left px-4 py-3 cursor-pointer select-none hover:bg-gray-100" onClick={() => handleSort("price_range")}>가격대{sortIcon("price_range")}</th>
+              <th className="text-center px-4 py-3 cursor-pointer select-none hover:bg-gray-100" onClick={() => handleSort("rating")}>평점{sortIcon("rating")}</th>
+              <th className="text-center px-4 py-3 cursor-pointer select-none hover:bg-gray-100" onClick={() => handleSort("business_status")}>상태{sortIcon("business_status")}</th>
+              <th className="text-center px-4 py-3">검증</th>
+            </tr>
+          </thead>
+          <tbody>
+            {paged.map((r) => (
+              <tr
+                key={r.id}
+                onClick={() => handleSelect(r)}
+                className={`border-b cursor-pointer hover:bg-brand-50/50 ${selected?.id === r.id ? "bg-brand-50" : ""}`}
+              >
+                <td className="px-4 py-3 font-medium">{r.name}</td>
+                <td className="px-4 py-3 text-gray-600 text-xs">{r.region || "-"}</td>
+                <td className="px-4 py-3 text-gray-600 text-xs">{r.cuisine_type || "-"}</td>
+                <td className="px-4 py-3 text-gray-600 text-xs">{r.price_range || "-"}</td>
+                <td className="px-4 py-3 text-center text-xs">
+                  {r.rating ? (
+                    <span><span className="text-yellow-500">★</span> {r.rating}</span>
+                  ) : "-"}
+                </td>
+                <td className="px-4 py-3 text-center">
+                  {r.business_status === "CLOSED_PERMANENTLY" ? (
+                    <span className="px-1.5 py-0.5 bg-red-100 text-red-700 rounded text-[10px] font-semibold">폐업</span>
+                  ) : r.business_status === "CLOSED_TEMPORARILY" ? (
+                    <span className="px-1.5 py-0.5 bg-yellow-100 text-yellow-700 rounded text-[10px] font-semibold">임시휴업</span>
+                  ) : (
+                    <span className="text-xs text-gray-400">-</span>
+                  )}
+                </td>
+                <td className="px-4 py-3 text-center" onClick={(e) => e.stopPropagation()}>
+                  {r.hidden ? (
+                    <button
+                      onClick={() => handleToggleHidden(r)}
+                      disabled={!isAdmin}
+                      title={r.hidden_reason || "manual"}
+                      className="px-1.5 py-0.5 bg-red-100 text-red-700 rounded text-[10px] font-semibold hover:bg-red-200 disabled:opacity-50"
+                    >
+                      숨김 {r.hidden_reason ? `(${r.hidden_reason.slice(0, 12)})` : ""}
+                    </button>
+                  ) : r.verified_at ? (
+                    <button
+                      onClick={() => handleToggleHidden(r)}
+                      disabled={!isAdmin}
+                      title="검증 통과 — 클릭하면 숨김"
+                      className="px-1.5 py-0.5 bg-green-100 text-green-700 rounded text-[10px] font-semibold hover:bg-green-200 disabled:opacity-50"
+                    >
+                      OK
+                    </button>
+                  ) : (
+                    <span className="text-xs text-gray-400">미검증</span>
+                  )}
+                </td>
+              </tr>
+            ))}
+            {!loading && filtered.length === 0 && (
+              <tr>
+                <td colSpan={7} className="px-4 py-8 text-center text-gray-400">
+                  식당 데이터가 없습니다
+                </td>
+              </tr>
+            )}
+          </tbody>
+        </table>
+      </div>
+
+      {totalPages > 1 && (
+        <div className="flex items-center justify-center gap-2 mt-4">
+          <button onClick={() => setPage(0)} disabled={page === 0} className="px-3 py-1 rounded border text-sm disabled:opacity-30 hover:bg-gray-100">«</button>
+          <button onClick={() => setPage(page - 1)} disabled={page === 0} className="px-3 py-1 rounded border text-sm disabled:opacity-30 hover:bg-gray-100">‹</button>
+          <span className="text-sm text-gray-600 px-2">{page + 1} / {totalPages}</span>
+          <button onClick={() => setPage(page + 1)} disabled={page >= totalPages - 1} className="px-3 py-1 rounded border text-sm disabled:opacity-30 hover:bg-gray-100">›</button>
+          <button onClick={() => setPage(totalPages - 1)} disabled={page >= totalPages - 1} className="px-3 py-1 rounded border text-sm disabled:opacity-30 hover:bg-gray-100">»</button>
+        </div>
+      )}
+
+      {/* 식당 상세/수정 패널 */}
+      {selected && (
+        <div className="mt-6 bg-surface rounded-lg shadow p-4">
+          <div className="flex items-center justify-between mb-4">
+            <h3 className="font-semibold text-base">{selected.name}</h3>
+            <button onClick={() => setSelected(null)} className="text-gray-400 hover:text-gray-600 text-xl leading-none">x</button>
+          </div>
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-3">
+            {[
+              { key: "name", label: "이름" },
+              { key: "address", label: "주소" },
+              { key: "region", label: "지역" },
+              { key: "cuisine_type", label: "음식 종류" },
+              { key: "price_range", label: "가격대" },
+              { key: "phone", label: "전화" },
+              { key: "website", label: "웹사이트" },
+              { key: "latitude", label: "위도" },
+              { key: "longitude", label: "경도" },
+            ].map(({ key, label }) => (
+              <div key={key}>
+                <label className="text-xs text-gray-500">{label}</label>
+                <input
+                  value={editForm[key] || ""}
+                  onChange={(e) => setEditForm((f) => ({ ...f, [key]: e.target.value }))}
+                  className="w-full border rounded px-2 py-1.5 text-sm bg-surface text-gray-900"
+                  disabled={!isAdmin}
+                />
+              </div>
+            ))}
+          </div>
+          {selected.business_status && (
+            <p className="mt-3 text-xs text-gray-500">
+              Google 상태: <span className="font-medium">{selected.business_status}</span>
+              {selected.rating && <> / ★ {selected.rating} ({selected.rating_count?.toLocaleString()})</>}
+            </p>
+          )}
+          {selected.google_place_id && (
+            <p className="mt-1">
+              <a
+                href={`https://www.google.com/maps/place/?q=place_id:${selected.google_place_id}`}
+                target="_blank"
+                rel="noopener noreferrer"
+                className="text-brand-600 hover:underline text-xs"
+              >
+                Google Maps에서 보기
+              </a>
+            </p>
+          )}
+          {/* 테이블링 연결 */}
+          {isAdmin && (
+            <div className="mt-4 border-t pt-3">
+              <div className="flex items-center gap-2 mb-2">
+                <h4 className="text-xs font-semibold text-gray-500">테이블링</h4>
+                {selected.tabling_url === "NONE" ? (
+                  <span className="text-xs text-gray-400">검색완료-없음</span>
+                ) : selected.tabling_url ? (
+                  <a href={selected.tabling_url} target="_blank" rel="noopener noreferrer"
+                    className="text-brand-600 hover:underline text-xs">{selected.tabling_url}</a>
+                ) : (
+                  <span className="text-xs text-gray-400">미연결</span>
+                )}
+                <button
+                  onClick={async () => {
+                    setTablingSearching(true);
+                    try {
+                      const results = await api.searchTabling(selected.id);
+                      if (results.length === 0) {
+                        alert("테이블링에서 검색 결과가 없습니다");
+                      } else {
+                        const best = results[0];
+                        if (confirm(`"${best.title}"\n${best.url}\n\n이 테이블링 페이지를 연결할까요?`)) {
+                          await api.setTablingUrl(selected.id, best.url);
+                          setSelected({ ...selected, tabling_url: best.url });
+                          load();
+                        }
+                      }
+                    } catch (e) { alert("검색 실패: " + (e instanceof Error ? e.message : String(e))); }
+                    finally { setTablingSearching(false); }
+                  }}
+                  disabled={tablingSearching}
+                  className="px-2 py-0.5 text-[11px] bg-brand-500 text-white rounded hover:bg-brand-600 disabled:opacity-50"
+                >
+                  {tablingSearching ? "검색 중..." : "테이블링 검색"}
+                </button>
+                {selected.tabling_url && (
+                  <button
+                    onClick={async () => {
+                      await api.setTablingUrl(selected.id, "");
+                      setSelected({ ...selected, tabling_url: null });
+                      load();
+                    }}
+                    className="px-2 py-0.5 text-[11px] text-red-500 border border-red-200 rounded hover:bg-red-50"
+                  >
+                    연결 해제
+                  </button>
+                )}
+              </div>
+            </div>
+          )}
+          {/* 캐치테이블 연결 */}
+          {isAdmin && (
+            <div className="mt-4 border-t pt-3">
+              <div className="flex items-center gap-2 mb-2">
+                <h4 className="text-xs font-semibold text-gray-500">캐치테이블</h4>
+                {selected.catchtable_url === "NONE" ? (
+                  <span className="text-xs text-gray-400">검색완료-없음</span>
+                ) : selected.catchtable_url ? (
+                  <a href={selected.catchtable_url} target="_blank" rel="noopener noreferrer"
+                    className="text-brand-600 hover:underline text-xs">{selected.catchtable_url}</a>
+                ) : (
+                  <span className="text-xs text-gray-400">미연결</span>
+                )}
+                <button
+                  onClick={async () => {
+                    setCatchtableSearching(true);
+                    try {
+                      const results = await api.searchCatchtable(selected.id);
+                      if (results.length === 0) {
+                        alert("캐치테이블에서 검색 결과가 없습니다");
+                      } else {
+                        const best = results[0];
+                        if (confirm(`"${best.title}"\n${best.url}\n\n이 캐치테이블 페이지를 연결할까요?`)) {
+                          await api.setCatchtableUrl(selected.id, best.url);
+                          setSelected({ ...selected, catchtable_url: best.url });
+                          load();
+                        }
+                      }
+                    } catch (e) { alert("검색 실패: " + (e instanceof Error ? e.message : String(e))); }
+                    finally { setCatchtableSearching(false); }
+                  }}
+                  disabled={catchtableSearching}
+                  className="px-2 py-0.5 text-[11px] bg-violet-500 text-white rounded hover:bg-violet-600 disabled:opacity-50"
+                >
+                  {catchtableSearching ? "검색 중..." : "캐치테이블 검색"}
+                </button>
+                {selected.catchtable_url && (
+                  <button
+                    onClick={async () => {
+                      await api.setCatchtableUrl(selected.id, "");
+                      setSelected({ ...selected, catchtable_url: null });
+                      load();
+                    }}
+                    className="px-2 py-0.5 text-[11px] text-red-500 border border-red-200 rounded hover:bg-red-50"
+                  >
+                    연결 해제
+                  </button>
+                )}
+              </div>
+            </div>
+          )}
+
+          {videos.length > 0 && (
+            <div className="mt-4 border-t pt-3">
+              <h4 className="text-xs font-semibold text-gray-500 mb-2">연결된 영상 ({videos.length})</h4>
+              <div className="space-y-1.5 max-h-32 overflow-y-auto">
+                {videos.map((v) => (
+                  <div key={v.video_id} className="flex items-center gap-2 text-xs">
+                    <span className="px-1.5 py-0.5 bg-red-50 text-red-600 rounded text-[10px] font-medium shrink-0">
+                      {v.channel_name}
+                    </span>
+                    <a href={v.url} target="_blank" rel="noopener noreferrer" className="text-brand-600 hover:underline truncate">
+                      {v.title}
+                    </a>
+                    <span className="text-gray-400 shrink-0">{v.published_at?.slice(0, 10)}</span>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          <div className="flex gap-2 mt-4">
+            {isAdmin && <button
+              onClick={handleSave}
+              disabled={saving}
+              className="px-4 py-2 text-sm bg-brand-600 text-white rounded hover:bg-brand-700 disabled:opacity-50"
+            >
+              {saving ? "저장 중..." : "저장"}
+            </button>}
+            <button
+              onClick={() => setSelected(null)}
+              className="px-4 py-2 text-sm border rounded text-gray-600 hover:bg-gray-100"
+            >
+              {isAdmin ? "취소" : "닫기"}
+            </button>
+            {isAdmin && <button
+              onClick={handleDelete}
+              className="px-4 py-2 text-sm text-red-500 border border-red-200 rounded hover:bg-red-50 ml-auto"
+            >
+              식당 삭제
+            </button>}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+
+
+/* ─── 유저 관리 ─── */
+interface AdminUser {
+  id: string;
+  email: string | null;
+  nickname: string | null;
+  avatar_url: string | null;
+  is_admin: boolean;
+  provider: string | null;
+  created_at: string | null;
+  favorite_count: number;
+  review_count: number;
+  memo_count: number;
+}
+
+interface UserFavorite {
+  id: string;
+  name: string;
+  address: string | null;
+  region: string | null;
+  cuisine_type: string | null;
+  rating: number | null;
+  business_status: string | null;
+  created_at: string | null;
+}
+
+interface UserReview {
+  id: string;
+  restaurant_id: string;
+  rating: number;
+  review_text: string | null;
+  visited_at: string | null;
+  created_at: string | null;
+  restaurant_name: string | null;
+}
+
+interface UserMemo {
+  id: string;
+  restaurant_id: string;
+  rating: number | null;
+  memo_text: string | null;
+  visited_at: string | null;
+  created_at: string;
+  restaurant_name: string | null;
+}
+

frontend/src/app/admin/_panels/UsersPanel.tsx

@@ -0,0 +1,383 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { api } from "@/lib/api";
+
+// #329 — admin/page.tsx에서 추출
+interface AdminUser {
+  id: string;
+  email: string | null;
+  nickname: string | null;
+  avatar_url: string | null;
+  is_admin: boolean;
+  provider: string | null;
+  created_at: string | null;
+  favorite_count: number;
+  review_count: number;
+  memo_count: number;
+}
+
+interface UserFavorite {
+  id: string;
+  name: string;
+  address: string | null;
+  region: string | null;
+  cuisine_type: string | null;
+  rating: number | null;
+  business_status: string | null;
+  created_at: string | null;
+}
+
+interface UserReview {
+  id: string;
+  restaurant_id: string;
+  rating: number;
+  review_text: string | null;
+  visited_at: string | null;
+  created_at: string | null;
+  restaurant_name: string | null;
+}
+
+interface UserMemo {
+  id: string;
+  restaurant_id: string;
+  rating: number | null;
+  memo_text: string | null;
+  visited_at: string | null;
+  created_at: string;
+  restaurant_name: string | null;
+}
+
+export function UsersPanel() {
+  const [users, setUsers] = useState<AdminUser[]>([]);
+  const [total, setTotal] = useState(0);
+  const [page, setPage] = useState(0);
+  const [selectedUser, setSelectedUser] = useState<AdminUser | null>(null);
+  const [favorites, setFavorites] = useState<UserFavorite[]>([]);
+  const [reviews, setReviews] = useState<UserReview[]>([]);
+  const [memos, setMemos] = useState<UserMemo[]>([]);
+  const [detailLoading, setDetailLoading] = useState(false);
+  const perPage = 20;
+
+  const loadUsers = useCallback(async (p: number) => {
+    try {
+      const res = await api.getAdminUsers({ limit: perPage, offset: p * perPage });
+      setUsers(res.users);
+      setTotal(res.total);
+    } catch (e) {
+      console.error("Failed to load users:", e);
+    }
+  }, []);
+
+  useEffect(() => {
+    loadUsers(page);
+  }, [page, loadUsers]);
+
+  const handleSelectUser = async (u: AdminUser) => {
+    if (selectedUser?.id === u.id) {
+      setSelectedUser(null);
+      setFavorites([]);
+      setReviews([]);
+      setMemos([]);
+      return;
+    }
+    setSelectedUser(u);
+    setDetailLoading(true);
+    try {
+      const [favs, revs, mems] = await Promise.all([
+        api.getAdminUserFavorites(u.id),
+        api.getAdminUserReviews(u.id),
+        api.getAdminUserMemos(u.id),
+      ]);
+      setFavorites(favs);
+      setReviews(revs);
+      setMemos(mems);
+    } catch (e) {
+      console.error(e);
+    } finally {
+      setDetailLoading(false);
+    }
+  };
+
+  const totalPages = Math.ceil(total / perPage);
+
+  return (
+    <div className="space-y-4">
+      <h2 className="text-lg font-bold">유저 관리 ({total}명)</h2>
+
+      {/* Users Table */}
+      <div className="bg-surface rounded-lg shadow overflow-hidden">
+        <table className="w-full text-sm">
+          <thead className="bg-brand-50 border-b border-brand-100 text-brand-800 text-sm font-semibold">
+            <tr>
+              <th className="text-left px-4 py-2">사용자</th>
+              <th className="text-left px-4 py-2">이메일</th>
+              <th className="text-center px-4 py-2">관리자</th>
+              <th className="text-center px-4 py-2">찜</th>
+              <th className="text-center px-4 py-2">리뷰</th>
+              <th className="text-center px-4 py-2">메모</th>
+              <th className="text-left px-4 py-2">가입일</th>
+            </tr>
+          </thead>
+          <tbody>
+            {users.map((u) => (
+              <tr
+                key={u.id}
+                onClick={() => handleSelectUser(u)}
+                className={`border-t cursor-pointer transition-colors ${
+                  selectedUser?.id === u.id
+                    ? "bg-brand-50"
+                    : "hover:bg-brand-50/50"
+                }`}
+              >
+                <td className="px-4 py-2">
+                  <div className="flex items-center gap-2">
+                    {u.avatar_url ? (
+                      <img
+                        src={u.avatar_url}
+                        alt=""
+                        className="w-7 h-7 rounded-full"
+                      />
+                    ) : (
+                      <div className="w-7 h-7 rounded-full bg-gray-200 flex items-center justify-center text-xs font-semibold text-gray-500">
+                        {(u.nickname || u.email || "?").charAt(0).toUpperCase()}
+                      </div>
+                    )}
+                    <span className="font-medium">
+                      {u.nickname || "-"}
+                    </span>
+                  </div>
+                </td>
+                <td className="px-4 py-2 text-gray-500">{u.email || "-"}</td>
+                <td className="px-4 py-2 text-center">
+                  <button
+                    onClick={async (e) => {
+                      e.stopPropagation();
+                      try {
+                        await api.updateAdminUserAdmin(u.id, !u.is_admin);
+                        setUsers((prev) => prev.map((x) => x.id === u.id ? { ...x, is_admin: !u.is_admin } : x));
+                      } catch (err) {
+                        console.error("Failed to update admin:", err);
+                        alert("관리자 권한 변경에 실패했습니다.");
+                      }
+                    }}
+                    className={`inline-block px-2 py-0.5 rounded-full text-xs font-medium transition-colors ${
+                      u.is_admin
+                        ? "bg-green-100 text-green-700 hover:bg-green-200"
+                        : "bg-gray-100 text-gray-400 hover:bg-gray-200"
+                    }`}
+                  >
+                    {u.is_admin ? "ON" : "OFF"}
+                  </button>
+                </td>
+                <td className="px-4 py-2 text-center">
+                  {u.favorite_count > 0 ? (
+                    <span className="inline-block px-2 py-0.5 bg-red-50 text-red-600 rounded-full text-xs font-medium">
+                      {u.favorite_count}
+                    </span>
+                  ) : (
+                    <span className="text-gray-300">0</span>
+                  )}
+                </td>
+                <td className="px-4 py-2 text-center">
+                  {u.review_count > 0 ? (
+                    <span className="inline-block px-2 py-0.5 bg-brand-50 text-brand-600 rounded-full text-xs font-medium">
+                      {u.review_count}
+                    </span>
+                  ) : (
+                    <span className="text-gray-300">0</span>
+                  )}
+                </td>
+                <td className="px-4 py-2 text-center">
+                  {u.memo_count > 0 ? (
+                    <span className="inline-block px-2 py-0.5 bg-purple-50 text-purple-600 rounded-full text-xs font-medium">
+                      {u.memo_count}
+                    </span>
+                  ) : (
+                    <span className="text-gray-300">0</span>
+                  )}
+                </td>
+                <td className="px-4 py-2 text-gray-400 text-xs">
+                  {u.created_at?.slice(0, 10) || "-"}
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      {/* Pagination */}
+      {totalPages > 1 && (
+        <div className="flex items-center justify-center gap-2">
+          <button
+            onClick={() => setPage((p) => Math.max(0, p - 1))}
+            disabled={page === 0}
+            className="px-3 py-1 text-sm border rounded disabled:opacity-30"
+          >
+            이전
+          </button>
+          <span className="text-sm text-gray-600">
+            {page + 1} / {totalPages}
+          </span>
+          <button
+            onClick={() => setPage((p) => Math.min(totalPages - 1, p + 1))}
+            disabled={page >= totalPages - 1}
+            className="px-3 py-1 text-sm border rounded disabled:opacity-30"
+          >
+            다음
+          </button>
+        </div>
+      )}
+
+      {/* Selected User Detail */}
+      {selectedUser && (
+        <div className="bg-surface rounded-lg shadow p-5 space-y-4">
+          <div className="flex items-center gap-3 pb-3 border-b">
+            {selectedUser.avatar_url ? (
+              <img
+                src={selectedUser.avatar_url}
+                alt=""
+                className="w-12 h-12 rounded-full"
+              />
+            ) : (
+              <div className="w-12 h-12 rounded-full bg-gray-200 flex items-center justify-center text-lg font-semibold text-gray-500">
+                {(selectedUser.nickname || selectedUser.email || "?").charAt(0).toUpperCase()}
+              </div>
+            )}
+            <div>
+              <div className="font-bold">{selectedUser.nickname || "-"}</div>
+              <div className="text-sm text-gray-500">{selectedUser.email || "-"}</div>
+              <div className="text-xs text-gray-400">
+                {selectedUser.provider} · 가입: {selectedUser.created_at?.slice(0, 10)}
+              </div>
+            </div>
+          </div>
+
+          {detailLoading ? (
+            <p className="text-sm text-gray-500">로딩 중...</p>
+          ) : (
+            <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+              {/* Favorites */}
+              <div>
+                <h3 className="font-semibold text-sm mb-2 text-red-600">
+                  찜한 식당 ({favorites.length})
+                </h3>
+                {favorites.length === 0 ? (
+                  <p className="text-xs text-gray-400">찜한 식당이 없습니다.</p>
+                ) : (
+                  <div className="space-y-1 max-h-64 overflow-y-auto">
+                    {favorites.map((f) => (
+                      <div
+                        key={f.id}
+                        className="flex items-center justify-between border rounded px-3 py-2 text-xs"
+                      >
+                        <div>
+                          <span className="font-medium">{f.name}</span>
+                          {f.region && (
+                            <span className="ml-1.5 text-gray-400">{f.region}</span>
+                          )}
+                          {f.cuisine_type && (
+                            <span className="ml-1.5 text-gray-400">· {f.cuisine_type}</span>
+                          )}
+                          {f.business_status === "CLOSED_PERMANENTLY" && (
+                            <span className="ml-1.5 px-1 bg-red-100 text-red-600 rounded text-[10px]">
+                              폐업
+                            </span>
+                          )}
+                        </div>
+                        {f.rating && (
+                          <span className="text-yellow-500 shrink-0">
+                            ★ {f.rating}
+                          </span>
+                        )}
+                      </div>
+                    ))}
+                  </div>
+                )}
+              </div>
+
+              {/* Reviews */}
+              <div>
+                <h3 className="font-semibold text-sm mb-2 text-brand-600">
+                  작성한 리뷰 ({reviews.length})
+                </h3>
+                {reviews.length === 0 ? (
+                  <p className="text-xs text-gray-400">작성한 리뷰가 없습니다.</p>
+                ) : (
+                  <div className="space-y-1 max-h-64 overflow-y-auto">
+                    {reviews.map((r) => (
+                      <div
+                        key={r.id}
+                        className="border rounded px-3 py-2 text-xs space-y-0.5"
+                      >
+                        <div className="flex items-center justify-between">
+                          <span className="font-medium">
+                            {r.restaurant_name || "알 수 없음"}
+                          </span>
+                          <span className="text-yellow-500 shrink-0">
+                            {"★".repeat(Math.round(r.rating))} {r.rating}
+                          </span>
+                        </div>
+                        {r.review_text && (
+                          <p className="text-gray-600 line-clamp-2">
+                            {r.review_text}
+                          </p>
+                        )}
+                        <div className="text-gray-400 text-[10px]">
+                          {r.visited_at && `방문: ${r.visited_at} · `}
+                          {r.created_at?.slice(0, 10)}
+                        </div>
+                      </div>
+                    ))}
+                  </div>
+                )}
+              </div>
+
+              {/* Memos */}
+              <div>
+                <h3 className="font-semibold text-sm mb-2 text-purple-600">
+                  작성한 메모 ({memos.length})
+                </h3>
+                {memos.length === 0 ? (
+                  <p className="text-xs text-gray-400">작성한 메모가 없습니다.</p>
+                ) : (
+                  <div className="space-y-1 max-h-64 overflow-y-auto">
+                    {memos.map((m) => (
+                      <div
+                        key={m.id}
+                        className="border border-purple-200 rounded px-3 py-2 text-xs space-y-0.5 bg-purple-50/30"
+                      >
+                        <div className="flex items-center justify-between">
+                          <span className="font-medium">
+                            {m.restaurant_name || "알 수 없음"}
+                          </span>
+                          {m.rating && (
+                            <span className="text-yellow-500 shrink-0">
+                              {"★".repeat(Math.round(m.rating))} {m.rating}
+                            </span>
+                          )}
+                        </div>
+                        {m.memo_text && (
+                          <p className="text-gray-600 line-clamp-2">
+                            {m.memo_text}
+                          </p>
+                        )}
+                        <div className="text-gray-400 text-[10px]">
+                          {m.visited_at && `방문: ${m.visited_at} · `}
+                          {m.created_at?.slice(0, 10)}
+                          <span className="ml-1 text-purple-400">비공개</span>
+                        </div>
+                      </div>
+                    ))}
+                  </div>
+                )}
+              </div>
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+/* ─── 데몬 설정 ─── */

frontend/src/app/globals.css

@@ -18,6 +18,10 @@
   --brand-800: #9A4500;
   --brand-900: #6B3000;
   --brand-950: #3D1A00;
+  /* #344 z-index 토큰 (모달/오버레이가 매직 넘버 없이 일관) */
+  --z-bottom-sheet: 50;
+  --z-filter-sheet: 60;
+  --z-modal: 70;
   color-scheme: only light !important;
 }
 

frontend/src/app/page.tsx

@@ -3,6 +3,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { GoogleLogin } from "@react-oauth/google";
 import LoginMenu from "@/components/LoginMenu";
+import LanguageSwitcher from "@/components/LanguageSwitcher";
 import { api } from "@/lib/api";
 import type { Restaurant, Channel, Review, Memo } from "@/lib/api";
 import { useAuth } from "@/lib/auth-context";
@@ -168,10 +169,15 @@ function findRegionFromCoords(
   }
   let best: { country: string; city: string } | null = null;
   let bestDist = Infinity;
+  // #320 — 유클리드 거리는 적도/극지에서 경도·위도의 실거리 차이가 커서 왜곡됨.
+  // cos(lat) 가중치(equirectangular approximation)로 위도 의존 보정.
+  const cosLat = Math.cos((lat * Math.PI) / 180);
   for (const g of groups.values()) {
     const cLat = g.lats.reduce((a, b) => a + b, 0) / g.lats.length;
     const cLng = g.lngs.reduce((a, b) => a + b, 0) / g.lngs.length;
-    const dist = (cLat - lat) ** 2 + (cLng - lng) ** 2;
+    const dLat = cLat - lat;
+    const dLng = (cLng - lng) * cosLat;
+    const dist = dLat * dLat + dLng * dLng;
     if (dist < bestDist) {
       bestDist = dist;
       best = { country: g.country, city: g.city };
@@ -714,6 +720,8 @@ export default function Home() {
                 </>
               )}
               <div className="flex-1" />
+              {/* #352 — Language switcher */}
+              <LanguageSwitcher />
               {/* Desktop user area */}
               {authLoading ? null : user ? (
                 <div className="flex items-center gap-2 shrink-0">

frontend/src/app/providers.tsx

@@ -2,6 +2,7 @@
 
 import { GoogleOAuthProvider } from "@react-oauth/google";
 import { AuthProvider } from "@/lib/auth-context";
+import { LocaleProvider } from "@/i18n/LocaleProvider";
 import type { ReactNode } from "react";
 
 const GOOGLE_CLIENT_ID = process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID || "";
@@ -9,7 +10,9 @@ const GOOGLE_CLIENT_ID = process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID || "";
 export function Providers({ children }: { children: ReactNode }) {
   return (
     <GoogleOAuthProvider clientId={GOOGLE_CLIENT_ID}>
+      <LocaleProvider>
         <AuthProvider>{children}</AuthProvider>
+      </LocaleProvider>
     </GoogleOAuthProvider>
   );
 }

frontend/src/components/GoogleMapView.tsx

@@ -0,0 +1,395 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  APIProvider,
+  Map,
+  AdvancedMarker,
+  InfoWindow,
+  useMap,
+} from "@vis.gl/react-google-maps";
+import Supercluster from "supercluster";
+import type { Restaurant } from "@/lib/api";
+import { getCuisineIcon } from "@/lib/cuisine-icons";
+import Icon from "@/components/Icon";
+
+const SEOUL_CENTER = { lat: 37.5665, lng: 126.978 };
+const API_KEY = process.env.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY || "";
+
+// Channel color palette
+const CHANNEL_COLORS = [
+  { bg: "#fff7ed", text: "#78350f", border: "#f59e0b", arrow: "#f59e0b" }, // amber (default)
+  { bg: "#eff6ff", text: "#1e3a5f", border: "#3b82f6", arrow: "#3b82f6" }, // blue
+  { bg: "#f0fdf4", text: "#14532d", border: "#22c55e", arrow: "#22c55e" }, // green
+  { bg: "#fdf2f8", text: "#831843", border: "#ec4899", arrow: "#ec4899" }, // pink
+  { bg: "#faf5ff", text: "#581c87", border: "#a855f7", arrow: "#a855f7" }, // purple
+  { bg: "#fff1f2", text: "#7f1d1d", border: "#ef4444", arrow: "#ef4444" }, // red
+  { bg: "#f0fdfa", text: "#134e4a", border: "#14b8a6", arrow: "#14b8a6" }, // teal
+  { bg: "#fefce8", text: "#713f12", border: "#eab308", arrow: "#eab308" }, // yellow
+];
+
+function getChannelColorMap(restaurants: Restaurant[]) {
+  const channels = new Set<string>();
+  restaurants.forEach((r) => r.channels?.forEach((ch) => channels.add(ch)));
+  const map: Record<string, typeof CHANNEL_COLORS[0]> = {};
+  let i = 0;
+  for (const ch of channels) {
+    map[ch] = CHANNEL_COLORS[i % CHANNEL_COLORS.length];
+    i++;
+  }
+  return map;
+}
+
+import type { MapBounds, FlyTo, MapViewProps } from "@/components/MapView.types";
+
+type RestaurantProps = { restaurant: Restaurant };
+type RestaurantFeature = Supercluster.PointFeature<RestaurantProps>;
+
+function useSupercluster(restaurants: Restaurant[]) {
+  // #278 — indexRef 제거 (set만 되고 read 없는 dead code)
+  const points: RestaurantFeature[] = useMemo(
+    () =>
+      restaurants.map((r) => ({
+        type: "Feature" as const,
+        geometry: { type: "Point" as const, coordinates: [r.longitude, r.latitude] },
+        properties: { restaurant: r },
+      })),
+    [restaurants]
+  );
+
+  const index = useMemo(() => {
+    const sc = new Supercluster<{ restaurant: Restaurant }>({
+      radius: 60,
+      maxZoom: 16,
+      minPoints: 2,
+    });
+    sc.load(points);
+    return sc;
+  }, [points]);
+
+  const getClusters = useCallback(
+    (bounds: MapBounds, zoom: number) => {
+      return index.getClusters(
+        [bounds.west, bounds.south, bounds.east, bounds.north],
+        Math.floor(zoom)
+      );
+    },
+    [index]
+  );
+
+  const getExpansionZoom = useCallback(
+    (clusterId: number): number => {
+      try {
+        return index.getClusterExpansionZoom(clusterId);
+      } catch {
+        return 17;
+      }
+    },
+    [index]
+  );
+
+  return { getClusters, getExpansionZoom, index };
+}
+
+function getClusterSize(count: number): number {
+  if (count < 10) return 36;
+  if (count < 50) return 42;
+  if (count < 100) return 48;
+  return 54;
+}
+
+function MapContent({ restaurants, selected, onSelectRestaurant, flyTo, activeChannel }: Omit<MapViewProps, "onMyLocation" | "onBoundsChanged">) {
+  const map = useMap();
+  const [infoTarget, setInfoTarget] = useState<Restaurant | null>(null);
+  const [zoom, setZoom] = useState(13);
+  const [bounds, setBounds] = useState<MapBounds | null>(null);
+  const channelColors = useMemo(() => getChannelColorMap(restaurants), [restaurants]);
+  const { getClusters, getExpansionZoom } = useSupercluster(restaurants);
+
+  // #278 — restaurantMap 제거 (빌드만 되고 렌더에서 사용 안 됨, dead code)
+
+  const clusters = useMemo(() => {
+    if (!bounds) return [];
+    return getClusters(bounds, zoom);
+  }, [bounds, zoom, getClusters]);
+
+  const handleMarkerClick = useCallback(
+    (r: Restaurant) => {
+      setInfoTarget(r);
+      onSelectRestaurant?.(r);
+    },
+    [onSelectRestaurant]
+  );
+
+  const handleClusterClick = useCallback(
+    (clusterId: number, lng: number, lat: number) => {
+      if (!map) return;
+      const expansionZoom = Math.min(getExpansionZoom(clusterId), 18);
+      map.panTo({ lat, lng });
+      map.setZoom(expansionZoom);
+    },
+    [map, getExpansionZoom]
+  );
+
+  // Track camera changes for clustering
+  useEffect(() => {
+    if (!map) return;
+    const listener = map.addListener("idle", () => {
+      const b = map.getBounds();
+      const z = map.getZoom();
+      if (b && z != null) {
+        const ne = b.getNorthEast();
+        const sw = b.getSouthWest();
+        setBounds({ north: ne.lat(), south: sw.lat(), east: ne.lng(), west: sw.lng() });
+        setZoom(z);
+      }
+    });
+    // Trigger initial bounds
+    const b = map.getBounds();
+    const z = map.getZoom();
+    if (b && z != null) {
+      const ne = b.getNorthEast();
+      const sw = b.getSouthWest();
+      setBounds({ north: ne.lat(), south: sw.lat(), east: ne.lng(), west: sw.lng() });
+      setZoom(z);
+    }
+    return () => google.maps.event.removeListener(listener);
+  }, [map]);
+
+  // Fly to a specific location (region filter)
+  useEffect(() => {
+    if (!map || !flyTo) return;
+    map.panTo({ lat: flyTo.lat, lng: flyTo.lng });
+    if (flyTo.zoom) map.setZoom(flyTo.zoom);
+  }, [map, flyTo]);
+
+  // Pan and zoom to selected restaurant
+  useEffect(() => {
+    if (!map || !selected) return;
+    map.panTo({ lat: selected.latitude, lng: selected.longitude });
+    map.setZoom(16);
+    setInfoTarget(selected);
+  }, [map, selected]);
+
+  return (
+    <>
+      {clusters.map((feature) => {
+        const [lng, lat] = feature.geometry.coordinates;
+        const isCluster = feature.properties && "cluster" in feature.properties && feature.properties.cluster;
+
+        if (isCluster) {
+          const { cluster_id, point_count } = feature.properties as Supercluster.ClusterProperties;
+          const size = getClusterSize(point_count);
+          return (
+            <AdvancedMarker
+              key={`cluster-${cluster_id}`}
+              position={{ lat, lng }}
+              onClick={() => handleClusterClick(cluster_id, lng, lat)}
+              zIndex={100}
+            >
+              <div
+                role="button"
+                aria-label={`${point_count}개 식당이 모인 클러스터, 클릭하면 확대됩니다`}
+                style={{
+                  width: size,
+                  height: size,
+                  borderRadius: "50%",
+                  background: "linear-gradient(135deg, #E8720C 0%, #f59e0b 100%)",
+                  border: "3px solid #fff",
+                  boxShadow: "0 2px 8px rgba(0,0,0,0.25)",
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  color: "#fff",
+                  fontSize: size > 42 ? 15 : 13,
+                  fontWeight: 700,
+                  cursor: "pointer",
+                  transition: "transform 0.2s ease",
+                }}
+              >
+                {point_count}
+              </div>
+            </AdvancedMarker>
+          );
+        }
+
+        // Individual marker
+        const r = (feature.properties as { restaurant: Restaurant }).restaurant;
+        const isSelected = selected?.id === r.id;
+        const isClosed = r.business_status === "CLOSED_PERMANENTLY";
+        const chKey = activeChannel && r.channels?.includes(activeChannel) ? activeChannel : r.channels?.[0];
+        const chColor = chKey ? channelColors[chKey] : CHANNEL_COLORS[0];
+        const c = chColor || CHANNEL_COLORS[0];
+        return (
+          <AdvancedMarker
+            key={r.id}
+            position={{ lat: r.latitude, lng: r.longitude }}
+            onClick={() => handleMarkerClick(r)}
+            zIndex={isSelected ? 1000 : 1}
+          >
+            <div
+              role="button"
+              aria-label={`${r.name}${isClosed ? ' (폐업)' : ''}, 클릭하면 상세 정보가 표시됩니다`}
+              style={{ display: "flex", flexDirection: "column", alignItems: "center", transition: "transform 0.2s ease", transform: isSelected ? "scale(1.15)" : "scale(1)", opacity: isClosed ? 0.5 : 1 }}>
+              <div
+                style={{
+                  padding: "4px 8px",
+                  backgroundColor: isSelected ? "#2563eb" : isClosed ? "#f3f4f6" : c.bg,
+                  color: isSelected ? "#fff" : isClosed ? "#9ca3af" : c.text,
+                  fontSize: 12,
+                  fontWeight: 600,
+                  borderRadius: 6,
+                  border: isSelected ? "2px solid #1d4ed8" : `1.5px solid ${c.border}`,
+                  boxShadow: isSelected
+                    ? "0 2px 8px rgba(37,99,235,0.4)"
+                    : `0 1px 4px ${c.border}40`,
+                  whiteSpace: "nowrap",
+                  maxWidth: 120,
+                  overflow: "hidden",
+                  textOverflow: "ellipsis",
+                  textDecoration: isClosed ? "line-through" : "none",
+                }}
+              >
+                <span className="material-symbols-rounded" style={{ fontSize: 14, width: 14, height: 14, overflow: "hidden", display: "inline-flex", alignItems: "center", justifyContent: "center", marginRight: 3, verticalAlign: "middle", color: "#E8720C" }}>{getCuisineIcon(r.cuisine_type)}</span>
+                {r.name}
+              </div>
+              <div
+                style={{
+                  width: 0,
+                  height: 0,
+                  borderLeft: "6px solid transparent",
+                  borderRight: "6px solid transparent",
+                  borderTop: isSelected ? "6px solid #1d4ed8" : `6px solid ${c.arrow}`,
+                  marginTop: -1,
+                }}
+              />
+            </div>
+          </AdvancedMarker>
+        );
+      })}
+
+      {infoTarget && (
+        <InfoWindow
+          position={{ lat: infoTarget.latitude, lng: infoTarget.longitude }}
+          onCloseClick={() => setInfoTarget(null)}
+        >
+          <div style={{ backgroundColor: "#ffffff", color: "#171717", colorScheme: "light" }} className="max-w-xs p-1">
+            <div className="flex items-center gap-2">
+              <h3 className="font-bold text-base" style={{ color: "#171717" }}><span className="material-symbols-rounded" style={{ fontSize: 18, width: 18, height: 18, overflow: "hidden", display: "inline-flex", alignItems: "center", justifyContent: "center", verticalAlign: "middle", color: "#E8720C", marginRight: 4 }}>{getCuisineIcon(infoTarget.cuisine_type)}</span>{infoTarget.name}</h3>
+              {infoTarget.business_status === "CLOSED_PERMANENTLY" && (
+                <span className="px-1.5 py-0.5 bg-red-100 text-red-700 rounded text-[10px] font-semibold">폐업</span>
+              )}
+              {infoTarget.business_status === "CLOSED_TEMPORARILY" && (
+                <span className="px-1.5 py-0.5 bg-yellow-100 text-yellow-700 rounded text-[10px] font-semibold">임시휴업</span>
+              )}
+            </div>
+            {infoTarget.rating && (
+              <p className="text-xs mt-0.5">
+                <span className="text-yellow-500">★</span> {infoTarget.rating}
+                {infoTarget.rating_count && (
+                  <span className="text-gray-400 ml-1">({infoTarget.rating_count.toLocaleString()})</span>
+                )}
+              </p>
+            )}
+            {infoTarget.cuisine_type && (
+              <p className="text-xs text-gray-500">{infoTarget.cuisine_type}</p>
+            )}
+            {infoTarget.address && (
+              <p className="text-[11px] text-gray-400 mt-1">{infoTarget.address}</p>
+            )}
+            {infoTarget.price_range && (
+              <p className="text-[11px] text-gray-400">{infoTarget.price_range}</p>
+            )}
+            {infoTarget.phone && (
+              <p className="text-[11px] text-gray-400">{infoTarget.phone}</p>
+            )}
+            <button
+              onClick={() => onSelectRestaurant?.(infoTarget)}
+              className="mt-2 text-sm text-blue-600 hover:underline"
+            >
+              상세 보기
+            </button>
+          </div>
+        </InfoWindow>
+      )}
+    </>
+  );
+}
+
+export default function GoogleMapView({ restaurants, selected, onSelectRestaurant, onBoundsChanged, flyTo, onMyLocation, activeChannel }: MapViewProps) {
+  const channelColors = useMemo(() => getChannelColorMap(restaurants), [restaurants]);
+  const channelNames = useMemo(() => {
+    const names = Object.keys(channelColors);
+    if (activeChannel) return names.filter((n) => n === activeChannel);
+    return names;
+  }, [channelColors, activeChannel]);
+  const boundsTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const handleCameraChanged = useCallback((ev: { detail: { bounds: { north: number; south: number; east: number; west: number } } }) => {
+    if (!onBoundsChanged) return;
+    if (boundsTimerRef.current) clearTimeout(boundsTimerRef.current);
+    boundsTimerRef.current = setTimeout(() => {
+      const { north, south, east, west } = ev.detail.bounds;
+      onBoundsChanged({ north, south, east, west });
+    }, 150);
+  }, [onBoundsChanged]);
+
+  // #278 — 언마운트 시 디바운스 타이머 정리 (메모리 누수 + unmounted setState 경고 방지)
+  useEffect(() => {
+    return () => {
+      if (boundsTimerRef.current) clearTimeout(boundsTimerRef.current);
+    };
+  }, []);
+
+  return (
+    <APIProvider apiKey={API_KEY}>
+      <Map
+        defaultCenter={SEOUL_CENTER}
+        defaultZoom={13}
+        mapId="tasteby-map"
+        className="h-full w-full"
+        colorScheme="LIGHT"
+        mapTypeControl={false}
+        fullscreenControl={false}
+        onCameraChanged={handleCameraChanged}
+      >
+        <MapContent
+          restaurants={restaurants}
+          selected={selected}
+          onSelectRestaurant={onSelectRestaurant}
+          flyTo={flyTo}
+          activeChannel={activeChannel}
+        />
+      </Map>
+      {onMyLocation && (
+        <button
+          onClick={onMyLocation}
+          aria-label="내 위치로 이동"
+          // #278 — 44×44px 터치 영역 확보 (이전 36px)
+          className="absolute top-2 right-2 w-11 h-11 bg-surface rounded-lg shadow-md flex items-center justify-center text-gray-600 dark:text-gray-300 hover:text-brand-500 dark:hover:text-brand-400 transition-colors z-10 touch-manipulation"
+          title="내 위치"
+        >
+          <Icon name="my_location" size={22} />
+        </button>
+      )}
+      {channelNames.length > 0 && (
+        <div
+          role="region"
+          aria-label="채널 범례"
+          className="absolute bottom-2 left-2 bg-surface/90 backdrop-blur-sm rounded-lg shadow px-2.5 py-1.5 flex flex-wrap gap-x-3 gap-y-1 text-[11px] z-10"
+        >
+          {channelNames.map((ch) => (
+            <div key={ch} className="flex items-center gap-1">
+              <span
+                aria-hidden="true"
+                className="inline-block w-2.5 h-2.5 rounded-full border"
+                style={{ backgroundColor: channelColors[ch].border, borderColor: channelColors[ch].border }}
+              />
+              <span className="text-gray-700 dark:text-gray-300">{ch}</span>
+            </div>
+          ))}
+        </div>
+      )}
+    </APIProvider>
+  );
+}

frontend/src/components/LanguageSwitcher.tsx

@@ -0,0 +1,57 @@
+"use client";
+
+import { useState } from "react";
+import { useLocale } from "@/i18n/LocaleProvider";
+import { LOCALES, LOCALE_LABELS } from "@/i18n/config";
+
+// #352 — 헤더용 언어 전환 드롭다운. 44px 터치 영역 + ARIA listbox 패턴.
+export default function LanguageSwitcher() {
+  const { locale, setLocale } = useLocale();
+  const [open, setOpen] = useState(false);
+
+  return (
+    <div className="relative">
+      <button
+        onClick={() => setOpen((v) => !v)}
+        aria-haspopup="listbox"
+        aria-expanded={open}
+        aria-label="언어 선택 / Select language"
+        className="min-h-[44px] min-w-[44px] px-2 py-1.5 flex items-center gap-1 text-sm rounded-lg hover:bg-brand-50 touch-manipulation"
+      >
+        <span aria-hidden="true">{LOCALE_LABELS[locale].flag}</span>
+        <span className="text-xs text-gray-500 uppercase">{locale}</span>
+      </button>
+      {open && (
+        <>
+          <button
+            aria-hidden="true"
+            tabIndex={-1}
+            className="fixed inset-0 z-40 cursor-default"
+            onClick={() => setOpen(false)}
+          />
+          <ul
+            role="listbox"
+            aria-label="언어 목록"
+            className="absolute right-0 mt-1 bg-surface rounded-lg shadow-lg border border-gray-200 dark:border-gray-700 py-1 z-50 min-w-[160px]"
+          >
+            {LOCALES.map((l) => (
+              <li key={l}>
+                <button
+                  role="option"
+                  aria-selected={l === locale}
+                  onClick={() => { setLocale(l); setOpen(false); }}
+                  className={`w-full text-left px-3 py-2 text-sm flex items-center gap-2 hover:bg-brand-50 ${
+                    l === locale ? "font-semibold text-brand-700" : "text-gray-700"
+                  }`}
+                >
+                  <span aria-hidden="true">{LOCALE_LABELS[l].flag}</span>
+                  <span>{LOCALE_LABELS[l].native}</span>
+                </button>
+              </li>
+            ))}
+          </ul>
+        </>
+      )}
+    </div>
+  );
+}

frontend/src/components/LoginMenu.tsx

@@ -1,8 +1,9 @@
 "use client";
 
-import { useState } from "react";
+import { useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { GoogleLogin } from "@react-oauth/google";
+import { useEscapeKey, useFocusTrap, useBodyScrollLock } from "@/lib/hooks/useModalA11y";
 
 interface LoginMenuProps {
   onGoogleSuccess: (credential: string) => void;
@@ -10,6 +11,22 @@ interface LoginMenuProps {
 
 export default function LoginMenu({ onGoogleSuccess }: LoginMenuProps) {
   const [open, setOpen] = useState(false);
+  const [errorMsg, setErrorMsg] = useState<string | null>(null);
+  const dialogRef = useRef<HTMLDivElement>(null);
+  const titleId = "login-dialog-title";
+
+  // #283 — 모달 접근성: ESC / focus trap / body scroll lock
+  useEscapeKey(open, () => setOpen(false));
+  useFocusTrap(open, dialogRef);
+  useBodyScrollLock(open);
+
+  const handleSuccess = (res: { credential?: string }) => {
+    setErrorMsg(null);
+    if (res.credential) {
+      onGoogleSuccess(res.credential);
+      setOpen(false);
+    }
+  };
 
   return (
     <>
@@ -22,30 +39,40 @@ export default function LoginMenu({ onGoogleSuccess }: LoginMenuProps) {
 
       {open && createPortal(
         <div
+          // #344 — z-index 매직 넘버 99999 → CSS 변수 토큰 (--z-modal=70).
+          // 다른 오버레이(BottomSheet=50, FilterSheet=60) 위 일관된 stacking.
           className="fixed inset-0 flex items-center justify-center bg-black/40 backdrop-blur-sm"
-          style={{ zIndex: 99999 }}
+          style={{ zIndex: "var(--z-modal)" } as React.CSSProperties}
           onClick={(e) => { if (e.target === e.currentTarget) setOpen(false); }}
         >
-          <div className="bg-surface rounded-2xl shadow-2xl p-6 mx-4 w-full max-w-xs space-y-4">
+          <div
+            ref={dialogRef}
+            role="dialog"
+            aria-modal="true"
+            aria-labelledby={titleId}
+            tabIndex={-1}
+            className="bg-surface rounded-2xl shadow-2xl p-6 mx-4 w-full max-w-sm space-y-4"
+          >
             <div className="flex items-center justify-between">
-              <h3 className="text-base font-semibold dark:text-gray-100">로그인</h3>
+              <h3 id={titleId} className="text-base font-semibold dark:text-gray-100">로그인</h3>
               <button
                 onClick={() => setOpen(false)}
-                className="text-gray-400 hover:text-gray-600 dark:hover:text-gray-200 text-lg leading-none"
+                aria-label="로그인 창 닫기"
+                className="text-gray-400 hover:text-gray-600 dark:hover:text-gray-200 text-lg leading-none p-2 -m-2"
               >
                 ✕
               </button>
             </div>
             <p className="text-xs text-gray-400 dark:text-gray-500">소셜 계정으로 간편 로그인</p>
+            {errorMsg && (
+              <p role="alert" className="text-xs text-red-600 dark:text-red-400 bg-red-50 dark:bg-red-950/40 rounded p-2">
+                {errorMsg}
+              </p>
+            )}
             <div className="flex flex-col items-center gap-3">
               <GoogleLogin
-                onSuccess={(res) => {
+                onSuccess={handleSuccess}
-                  if (res.credential) {
+                onError={() => setErrorMsg("Google 로그인에 실패했습니다. 팝업 차단 또는 네트워크 상태를 확인해주세요.")}
-                    onGoogleSuccess(res.credential);
-                    setOpen(false);
-                  }
-                }}
-                onError={() => console.error("Google login failed")}
                 size="large"
                 width="260"
                 text="signin_with"

frontend/src/components/MapView.tsx

@@ -1,404 +1,37 @@
 "use client";
 
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import GoogleMapView from "@/components/GoogleMapView";
-import {
+import NaverMapView from "@/components/NaverMapView";
-  APIProvider,
+import { isKoreaCoord, type MapBounds, type FlyTo, type MapViewProps } from "@/components/MapView.types";
-  Map,
-  AdvancedMarker,
-  InfoWindow,
-  useMap,
-} from "@vis.gl/react-google-maps";
-import Supercluster from "supercluster";
-import type { Restaurant } from "@/lib/api";
-import { getCuisineIcon } from "@/lib/cuisine-icons";
-import Icon from "@/components/Icon";
 
-const SEOUL_CENTER = { lat: 37.5665, lng: 126.978 };
+export type { MapBounds, FlyTo };
-const API_KEY = process.env.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY || "";
 
-// Channel color palette
+const NAVER_KEY = process.env.NEXT_PUBLIC_NAVER_MAP_CLIENT_ID || "";
-const CHANNEL_COLORS = [
-  { bg: "#fff7ed", text: "#78350f", border: "#f59e0b", arrow: "#f59e0b" }, // amber (default)
-  { bg: "#eff6ff", text: "#1e3a5f", border: "#3b82f6", arrow: "#3b82f6" }, // blue
-  { bg: "#f0fdf4", text: "#14532d", border: "#22c55e", arrow: "#22c55e" }, // green
-  { bg: "#fdf2f8", text: "#831843", border: "#ec4899", arrow: "#ec4899" }, // pink
-  { bg: "#faf5ff", text: "#581c87", border: "#a855f7", arrow: "#a855f7" }, // purple
-  { bg: "#fff1f2", text: "#7f1d1d", border: "#ef4444", arrow: "#ef4444" }, // red
-  { bg: "#f0fdfa", text: "#134e4a", border: "#14b8a6", arrow: "#14b8a6" }, // teal
-  { bg: "#fefce8", text: "#713f12", border: "#eab308", arrow: "#eab308" }, // yellow
-];
 
-function getChannelColorMap(restaurants: Restaurant[]) {
+/**
-  const channels = new Set<string>();
+ * #363 — 메인 지도 dispatcher.
-  restaurants.forEach((r) => r.channels?.forEach((ch) => channels.add(ch)));
+ * - 키 미설정: GoogleMap (회귀 0)
-  const map: Record<string, typeof CHANNEL_COLORS[0]> = {};
+ * - flyTo 또는 selected 좌표가 KR bbox: NaverMap
-  let i = 0;
+ * - 그 외 (해외 + 좌표 추정): GoogleMap
-  for (const ch of channels) {
+ * - 초기 마운트 시 화면 중심을 추정할 수 없으면 식당 평균 좌표로.
-    map[ch] = CHANNEL_COLORS[i % CHANNEL_COLORS.length];
+ */
-    i++;
+export default function MapView(props: MapViewProps) {
+  if (!NAVER_KEY) return <GoogleMapView {...props} />;
+
+  const targetLat = props.flyTo?.lat ?? props.selected?.latitude ?? avgLat(props.restaurants);
+  const targetLng = props.flyTo?.lng ?? props.selected?.longitude ?? avgLng(props.restaurants);
+
+  if (targetLat != null && targetLng != null && isKoreaCoord(targetLat, targetLng)) {
+    return <NaverMapView {...props} />;
   }
-  return map;
+  return <GoogleMapView {...props} />;
 }
 
-export interface MapBounds {
+function avgLat(rs: MapViewProps["restaurants"]): number | null {
-  north: number;
+  if (!rs.length) return null;
-  south: number;
+  return rs.reduce((s, r) => s + r.latitude, 0) / rs.length;
-  east: number;
-  west: number;
 }
-
+function avgLng(rs: MapViewProps["restaurants"]): number | null {
-export interface FlyTo {
+  if (!rs.length) return null;
-  lat: number;
+  return rs.reduce((s, r) => s + r.longitude, 0) / rs.length;
-  lng: number;
-  zoom?: number;
-}
-
-interface MapViewProps {
-  restaurants: Restaurant[];
-  selected?: Restaurant | null;
-  onSelectRestaurant?: (r: Restaurant) => void;
-  onBoundsChanged?: (bounds: MapBounds) => void;
-  flyTo?: FlyTo | null;
-  onMyLocation?: () => void;
-  activeChannel?: string;
-}
-
-type RestaurantProps = { restaurant: Restaurant };
-type RestaurantFeature = Supercluster.PointFeature<RestaurantProps>;
-
-function useSupercluster(restaurants: Restaurant[]) {
-  const indexRef = useRef<Supercluster<{ restaurant: Restaurant }> | null>(null);
-
-  const points: RestaurantFeature[] = useMemo(
-    () =>
-      restaurants.map((r) => ({
-        type: "Feature" as const,
-        geometry: { type: "Point" as const, coordinates: [r.longitude, r.latitude] },
-        properties: { restaurant: r },
-      })),
-    [restaurants]
-  );
-
-  const index = useMemo(() => {
-    const sc = new Supercluster<{ restaurant: Restaurant }>({
-      radius: 60,
-      maxZoom: 16,
-      minPoints: 2,
-    });
-    sc.load(points);
-    indexRef.current = sc;
-    return sc;
-  }, [points]);
-
-  const getClusters = useCallback(
-    (bounds: MapBounds, zoom: number) => {
-      return index.getClusters(
-        [bounds.west, bounds.south, bounds.east, bounds.north],
-        Math.floor(zoom)
-      );
-    },
-    [index]
-  );
-
-  const getExpansionZoom = useCallback(
-    (clusterId: number): number => {
-      try {
-        return index.getClusterExpansionZoom(clusterId);
-      } catch {
-        return 17;
-      }
-    },
-    [index]
-  );
-
-  return { getClusters, getExpansionZoom, index };
-}
-
-function getClusterSize(count: number): number {
-  if (count < 10) return 36;
-  if (count < 50) return 42;
-  if (count < 100) return 48;
-  return 54;
-}
-
-function MapContent({ restaurants, selected, onSelectRestaurant, flyTo, activeChannel }: Omit<MapViewProps, "onMyLocation" | "onBoundsChanged">) {
-  const map = useMap();
-  const [infoTarget, setInfoTarget] = useState<Restaurant | null>(null);
-  const [zoom, setZoom] = useState(13);
-  const [bounds, setBounds] = useState<MapBounds | null>(null);
-  const channelColors = useMemo(() => getChannelColorMap(restaurants), [restaurants]);
-  const { getClusters, getExpansionZoom } = useSupercluster(restaurants);
-
-  // Build a lookup for restaurants by id
-  const restaurantMap = useMemo(() => {
-    const m: Record<string, Restaurant> = {};
-    restaurants.forEach((r) => { m[r.id] = r; });
-    return m;
-  }, [restaurants]);
-
-  const clusters = useMemo(() => {
-    if (!bounds) return [];
-    return getClusters(bounds, zoom);
-  }, [bounds, zoom, getClusters]);
-
-  const handleMarkerClick = useCallback(
-    (r: Restaurant) => {
-      setInfoTarget(r);
-      onSelectRestaurant?.(r);
-    },
-    [onSelectRestaurant]
-  );
-
-  const handleClusterClick = useCallback(
-    (clusterId: number, lng: number, lat: number) => {
-      if (!map) return;
-      const expansionZoom = Math.min(getExpansionZoom(clusterId), 18);
-      map.panTo({ lat, lng });
-      map.setZoom(expansionZoom);
-    },
-    [map, getExpansionZoom]
-  );
-
-  // Track camera changes for clustering
-  useEffect(() => {
-    if (!map) return;
-    const listener = map.addListener("idle", () => {
-      const b = map.getBounds();
-      const z = map.getZoom();
-      if (b && z != null) {
-        const ne = b.getNorthEast();
-        const sw = b.getSouthWest();
-        setBounds({ north: ne.lat(), south: sw.lat(), east: ne.lng(), west: sw.lng() });
-        setZoom(z);
-      }
-    });
-    // Trigger initial bounds
-    const b = map.getBounds();
-    const z = map.getZoom();
-    if (b && z != null) {
-      const ne = b.getNorthEast();
-      const sw = b.getSouthWest();
-      setBounds({ north: ne.lat(), south: sw.lat(), east: ne.lng(), west: sw.lng() });
-      setZoom(z);
-    }
-    return () => google.maps.event.removeListener(listener);
-  }, [map]);
-
-  // Fly to a specific location (region filter)
-  useEffect(() => {
-    if (!map || !flyTo) return;
-    map.panTo({ lat: flyTo.lat, lng: flyTo.lng });
-    if (flyTo.zoom) map.setZoom(flyTo.zoom);
-  }, [map, flyTo]);
-
-  // Pan and zoom to selected restaurant
-  useEffect(() => {
-    if (!map || !selected) return;
-    map.panTo({ lat: selected.latitude, lng: selected.longitude });
-    map.setZoom(16);
-    setInfoTarget(selected);
-  }, [map, selected]);
-
-  return (
-    <>
-      {clusters.map((feature) => {
-        const [lng, lat] = feature.geometry.coordinates;
-        const isCluster = feature.properties && "cluster" in feature.properties && feature.properties.cluster;
-
-        if (isCluster) {
-          const { cluster_id, point_count } = feature.properties as Supercluster.ClusterProperties;
-          const size = getClusterSize(point_count);
-          return (
-            <AdvancedMarker
-              key={`cluster-${cluster_id}`}
-              position={{ lat, lng }}
-              onClick={() => handleClusterClick(cluster_id, lng, lat)}
-              zIndex={100}
-            >
-              <div
-                style={{
-                  width: size,
-                  height: size,
-                  borderRadius: "50%",
-                  background: "linear-gradient(135deg, #E8720C 0%, #f59e0b 100%)",
-                  border: "3px solid #fff",
-                  boxShadow: "0 2px 8px rgba(0,0,0,0.25)",
-                  display: "flex",
-                  alignItems: "center",
-                  justifyContent: "center",
-                  color: "#fff",
-                  fontSize: size > 42 ? 15 : 13,
-                  fontWeight: 700,
-                  cursor: "pointer",
-                  transition: "transform 0.2s ease",
-                }}
-              >
-                {point_count}
-              </div>
-            </AdvancedMarker>
-          );
-        }
-
-        // Individual marker
-        const r = (feature.properties as { restaurant: Restaurant }).restaurant;
-        const isSelected = selected?.id === r.id;
-        const isClosed = r.business_status === "CLOSED_PERMANENTLY";
-        const chKey = activeChannel && r.channels?.includes(activeChannel) ? activeChannel : r.channels?.[0];
-        const chColor = chKey ? channelColors[chKey] : CHANNEL_COLORS[0];
-        const c = chColor || CHANNEL_COLORS[0];
-        return (
-          <AdvancedMarker
-            key={r.id}
-            position={{ lat: r.latitude, lng: r.longitude }}
-            onClick={() => handleMarkerClick(r)}
-            zIndex={isSelected ? 1000 : 1}
-          >
-            <div style={{ display: "flex", flexDirection: "column", alignItems: "center", transition: "transform 0.2s ease", transform: isSelected ? "scale(1.15)" : "scale(1)", opacity: isClosed ? 0.5 : 1 }}>
-              <div
-                style={{
-                  padding: "4px 8px",
-                  backgroundColor: isSelected ? "#2563eb" : isClosed ? "#f3f4f6" : c.bg,
-                  color: isSelected ? "#fff" : isClosed ? "#9ca3af" : c.text,
-                  fontSize: 12,
-                  fontWeight: 600,
-                  borderRadius: 6,
-                  border: isSelected ? "2px solid #1d4ed8" : `1.5px solid ${c.border}`,
-                  boxShadow: isSelected
-                    ? "0 2px 8px rgba(37,99,235,0.4)"
-                    : `0 1px 4px ${c.border}40`,
-                  whiteSpace: "nowrap",
-                  maxWidth: 120,
-                  overflow: "hidden",
-                  textOverflow: "ellipsis",
-                  textDecoration: isClosed ? "line-through" : "none",
-                }}
-              >
-                <span className="material-symbols-rounded" style={{ fontSize: 14, marginRight: 3, verticalAlign: "middle", color: "#E8720C" }}>{getCuisineIcon(r.cuisine_type)}</span>
-                {r.name}
-              </div>
-              <div
-                style={{
-                  width: 0,
-                  height: 0,
-                  borderLeft: "6px solid transparent",
-                  borderRight: "6px solid transparent",
-                  borderTop: isSelected ? "6px solid #1d4ed8" : `6px solid ${c.arrow}`,
-                  marginTop: -1,
-                }}
-              />
-            </div>
-          </AdvancedMarker>
-        );
-      })}
-
-      {infoTarget && (
-        <InfoWindow
-          position={{ lat: infoTarget.latitude, lng: infoTarget.longitude }}
-          onCloseClick={() => setInfoTarget(null)}
-        >
-          <div style={{ backgroundColor: "#ffffff", color: "#171717", colorScheme: "light" }} className="max-w-xs p-1">
-            <div className="flex items-center gap-2">
-              <h3 className="font-bold text-base" style={{ color: "#171717" }}><span className="material-symbols-rounded" style={{ fontSize: 18, verticalAlign: "middle", color: "#E8720C", marginRight: 4 }}>{getCuisineIcon(infoTarget.cuisine_type)}</span>{infoTarget.name}</h3>
-              {infoTarget.business_status === "CLOSED_PERMANENTLY" && (
-                <span className="px-1.5 py-0.5 bg-red-100 text-red-700 rounded text-[10px] font-semibold">폐업</span>
-              )}
-              {infoTarget.business_status === "CLOSED_TEMPORARILY" && (
-                <span className="px-1.5 py-0.5 bg-yellow-100 text-yellow-700 rounded text-[10px] font-semibold">임시휴업</span>
-              )}
-            </div>
-            {infoTarget.rating && (
-              <p className="text-xs mt-0.5">
-                <span className="text-yellow-500">★</span> {infoTarget.rating}
-                {infoTarget.rating_count && (
-                  <span className="text-gray-400 ml-1">({infoTarget.rating_count.toLocaleString()})</span>
-                )}
-              </p>
-            )}
-            {infoTarget.cuisine_type && (
-              <p className="text-xs text-gray-500">{infoTarget.cuisine_type}</p>
-            )}
-            {infoTarget.address && (
-              <p className="text-[11px] text-gray-400 mt-1">{infoTarget.address}</p>
-            )}
-            {infoTarget.price_range && (
-              <p className="text-[11px] text-gray-400">{infoTarget.price_range}</p>
-            )}
-            {infoTarget.phone && (
-              <p className="text-[11px] text-gray-400">{infoTarget.phone}</p>
-            )}
-            <button
-              onClick={() => onSelectRestaurant?.(infoTarget)}
-              className="mt-2 text-sm text-blue-600 hover:underline"
-            >
-              상세 보기
-            </button>
-          </div>
-        </InfoWindow>
-      )}
-    </>
-  );
-}
-
-export default function MapView({ restaurants, selected, onSelectRestaurant, onBoundsChanged, flyTo, onMyLocation, activeChannel }: MapViewProps) {
-  const channelColors = useMemo(() => getChannelColorMap(restaurants), [restaurants]);
-  const channelNames = useMemo(() => {
-    const names = Object.keys(channelColors);
-    if (activeChannel) return names.filter((n) => n === activeChannel);
-    return names;
-  }, [channelColors, activeChannel]);
-  const boundsTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  const handleCameraChanged = useCallback((ev: { detail: { bounds: { north: number; south: number; east: number; west: number } } }) => {
-    if (!onBoundsChanged) return;
-    if (boundsTimerRef.current) clearTimeout(boundsTimerRef.current);
-    boundsTimerRef.current = setTimeout(() => {
-      const { north, south, east, west } = ev.detail.bounds;
-      onBoundsChanged({ north, south, east, west });
-    }, 150);
-  }, [onBoundsChanged]);
-
-  return (
-    <APIProvider apiKey={API_KEY}>
-      <Map
-        defaultCenter={SEOUL_CENTER}
-        defaultZoom={13}
-        mapId="tasteby-map"
-        className="h-full w-full"
-        colorScheme="LIGHT"
-        mapTypeControl={false}
-        fullscreenControl={false}
-        onCameraChanged={handleCameraChanged}
-      >
-        <MapContent
-          restaurants={restaurants}
-          selected={selected}
-          onSelectRestaurant={onSelectRestaurant}
-          flyTo={flyTo}
-          activeChannel={activeChannel}
-        />
-      </Map>
-      {onMyLocation && (
-        <button
-          onClick={onMyLocation}
-          className="absolute top-2 right-2 w-9 h-9 bg-surface rounded-lg shadow-md flex items-center justify-center text-gray-600 dark:text-gray-300 hover:text-brand-500 dark:hover:text-brand-400 transition-colors z-10"
-          title="내 위치"
-        >
-          <Icon name="my_location" size={20} />
-        </button>
-      )}
-      {channelNames.length > 0 && (
-        <div className="absolute bottom-2 left-2 bg-surface/90 backdrop-blur-sm rounded-lg shadow px-2.5 py-1.5 flex flex-wrap gap-x-3 gap-y-1 text-[11px] z-10">
-          {channelNames.map((ch) => (
-            <div key={ch} className="flex items-center gap-1">
-              <span
-                className="inline-block w-2.5 h-2.5 rounded-full border"
-                style={{ backgroundColor: channelColors[ch].border, borderColor: channelColors[ch].border }}
-              />
-              <span className="text-gray-700 dark:text-gray-300">{ch}</span>
-            </div>
-          ))}
-        </div>
-      )}
-    </APIProvider>
-  );
 }

frontend/src/components/MapView.types.ts

@@ -0,0 +1,29 @@
+import type { Restaurant } from "@/lib/api";
+
+export interface MapBounds {
+  north: number;
+  south: number;
+  east: number;
+  west: number;
+}
+
+export interface FlyTo {
+  lat: number;
+  lng: number;
+  zoom?: number;
+}
+
+export interface MapViewProps {
+  restaurants: Restaurant[];
+  selected?: Restaurant | null;
+  onSelectRestaurant?: (r: Restaurant) => void;
+  onBoundsChanged?: (bounds: MapBounds) => void;
+  flyTo?: FlyTo | null;
+  onMyLocation?: () => void;
+  activeChannel?: string;
+}
+
+// 좌표가 한국 영토 bbox 안인지 (WGS84).
+export function isKoreaCoord(lat: number, lng: number): boolean {
+  return lat >= 33 && lat <= 38.7 && lng >= 124 && lng <= 132;
+}

frontend/src/components/MemoSection.tsx

@@ -5,11 +5,13 @@ import { api } from "@/lib/api";
 import type { Memo } from "@/lib/api";
 import { useAuth } from "@/lib/auth-context";
 import Icon from "@/components/Icon";
+import Stars from "@/components/Stars";
 
 interface MemoSectionProps {
   restaurantId: string;
 }
 
+// #281 — ReviewSection의 StarSelector와 동일 UX (0.5 단위 + 44px 터치 + ARIA radiogroup)
 function StarSelector({
   value,
   onChange,
@@ -18,38 +20,32 @@ function StarSelector({
   onChange: (v: number) => void;
 }) {
   return (
-    <div className="flex items-center gap-1">
+    <div role="radiogroup" aria-label="별점 선택" className="flex items-center gap-0.5">
       <span className="text-xs text-gray-500 mr-1">별점:</span>
-      {[0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5].map((v) => (
+      {[1, 2, 3, 4, 5].map((v) => {
+        const nextVal = value === v ? v - 0.5 : v;
+        return (
           <button
             key={v}
             type="button"
-          onClick={() => onChange(v)}
+            role="radio"
-          className={`w-6 h-6 text-xs rounded border ${
+            aria-checked={value >= v - 0.5 && value <= v}
-            value === v
+            aria-label={`${nextVal}점`}
-              ? "bg-yellow-500 text-white border-yellow-600"
+            onClick={() => onChange(nextVal)}
-              : "bg-white text-gray-600 border-gray-300 hover:border-yellow-400"
+            className="min-w-[44px] min-h-[44px] flex items-center justify-center touch-manipulation"
-          }`}
+            title={`${nextVal}점`}
           >
-          {v}
+            <span className={`text-xl ${v <= value ? "text-yellow-500" : v - 0.5 === value ? "text-yellow-400" : "text-gray-300"}`}>
+              {v <= value ? "★" : v - 0.5 === value ? "⯨" : "☆"}
+            </span>
           </button>
-      ))}
+        );
+      })}
+      {value > 0 && <span className="text-xs text-yellow-600 font-medium ml-1">{value}</span>}
     </div>
   );
 }
 
-function StarDisplay({ rating }: { rating: number }) {
-  const stars = [];
-  for (let i = 1; i <= 5; i++) {
-    stars.push(
-      <span key={i} className={rating >= i - 0.5 ? "text-yellow-500" : "text-gray-300"}>
-        ★
-      </span>
-    );
-  }
-  return <span className="text-sm">{stars}</span>;
-}
-
 export default function MemoSection({ restaurantId }: MemoSectionProps) {
   const { user } = useAuth();
   const [memo, setMemo] = useState<Memo | null>(null);
@@ -104,6 +100,9 @@ export default function MemoSection({ restaurantId }: MemoSectionProps) {
       setMemo(saved);
       setShowForm(false);
       setEditing(false);
+    } catch (err) {
+      // #281 — 사용자 피드백
+      alert(`메모 저장 실패: ${err instanceof Error ? err.message : String(err)}`);
     } finally {
       setSubmitting(false);
     }
@@ -111,8 +110,12 @@ export default function MemoSection({ restaurantId }: MemoSectionProps) {
 
   const handleDelete = async () => {
     if (!confirm("메모를 삭제하시겠습니까?")) return;
+    try {
       await api.deleteMemo(restaurantId);
       setMemo(null);
+    } catch (err) {
+      alert(`메모 삭제 실패: ${err instanceof Error ? err.message : String(err)}`);
+    }
   };
 
   return (
@@ -167,7 +170,7 @@ export default function MemoSection({ restaurantId }: MemoSectionProps) {
       ) : memo ? (
         <div className="border border-brand-200 rounded-lg p-3 bg-brand-50/30">
           <div className="flex items-center gap-2 mb-1">
-            {memo.rating && <StarDisplay rating={memo.rating} />}
+            {memo.rating && <Stars rating={memo.rating} />}
             {memo.visited_at && (
               <span className="text-xs text-gray-400">방문일: {memo.visited_at}</span>
             )}

frontend/src/components/MyReviewsList.tsx

@@ -3,6 +3,7 @@
 import { useState } from "react";
 import type { Review, Memo } from "@/lib/api";
 import Icon from "@/components/Icon";
+import Stars from "@/components/Stars";
 
 interface MyReview extends Review {
   restaurant_id: string;
@@ -40,8 +41,14 @@ export default function MyReviewsList({
         </button>
       </div>
 
-      <div className="flex gap-1 border-b">
+      {/* #343 — WAI-ARIA Tabs 패턴 */}
+      <div role="tablist" aria-label="내 활동" className="flex gap-1 border-b">
         <button
+          role="tab"
+          id="tab-reviews"
+          aria-selected={tab === "reviews"}
+          aria-controls="panel-reviews"
+          tabIndex={tab === "reviews" ? 0 : -1}
           onClick={() => setTab("reviews")}
           className={`px-3 py-1.5 text-sm font-medium border-b-2 transition-colors ${
             tab === "reviews"
@@ -53,6 +60,11 @@ export default function MyReviewsList({
           리뷰 ({reviews.length})
         </button>
         <button
+          role="tab"
+          id="tab-memos"
+          aria-selected={tab === "memos"}
+          aria-controls="panel-memos"
+          tabIndex={tab === "memos" ? 0 : -1}
           onClick={() => setTab("memos")}
           className={`px-3 py-1.5 text-sm font-medium border-b-2 transition-colors ${
             tab === "memos"
@@ -66,7 +78,8 @@ export default function MyReviewsList({
       </div>
 
       {tab === "reviews" ? (
-        reviews.length === 0 ? (
+        <div role="tabpanel" id="panel-reviews" aria-labelledby="tab-reviews">
+        {reviews.length === 0 ? (
           <p className="text-sm text-gray-500 py-8 text-center">
             아직 작성한 리뷰가 없습니다.
           </p>
@@ -82,9 +95,9 @@ export default function MyReviewsList({
                   <span className="font-semibold text-sm truncate">
                     {r.restaurant_name || "알 수 없는 식당"}
                   </span>
-                  <span className="text-yellow-500 text-sm shrink-0 ml-2">
+                  <span className="text-sm shrink-0 ml-2 flex items-center gap-1">
-                    {"★".repeat(Math.round(r.rating))}
+                    <Stars rating={r.rating} />
-                    <span className="text-gray-500 ml-1">{r.rating}</span>
+                    <span className="text-gray-500">{r.rating}</span>
                   </span>
                 </div>
                 {r.review_text && (
@@ -99,9 +112,11 @@ export default function MyReviewsList({
               </button>
             ))}
           </div>
-        )
+        )}
+        </div>
       ) : (
-        memos.length === 0 ? (
+        <div role="tabpanel" id="panel-memos" aria-labelledby="tab-memos">
+        {memos.length === 0 ? (
           <p className="text-sm text-gray-500 py-8 text-center">
             아직 작성한 메모가 없습니다.
           </p>
@@ -118,9 +133,9 @@ export default function MyReviewsList({
                     {m.restaurant_name || "알 수 없는 식당"}
                   </span>
                   {m.rating && (
-                    <span className="text-yellow-500 text-sm shrink-0 ml-2">
+                    <span className="text-sm shrink-0 ml-2 flex items-center gap-1">
-                      {"★".repeat(Math.round(m.rating))}
+                      <Stars rating={m.rating} />
-                      <span className="text-gray-500 ml-1">{m.rating}</span>
+                      <span className="text-gray-500">{m.rating}</span>
                     </span>
                   )}
                 </div>
@@ -136,7 +151,8 @@ export default function MyReviewsList({
               </button>
             ))}
           </div>
-        )
+        )}
+        </div>
       )}
     </div>
   );

frontend/src/components/NaverMapView.tsx

@@ -0,0 +1,326 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import Supercluster from "supercluster";
+import type { Restaurant } from "@/lib/api";
+import Icon from "@/components/Icon";
+import type { MapBounds, MapViewProps } from "@/components/MapView.types";
+
+declare global {
+  interface Window {
+    naver?: { maps: NaverMaps };
+  }
+}
+type LatLng = { lat: () => number; lng: () => number };
+type NaverMaps = {
+  LatLng: new (lat: number, lng: number) => LatLng;
+  Map: new (el: HTMLElement, opts: Record<string, unknown>) => NaverMapInstance;
+  Marker: new (opts: Record<string, unknown>) => NaverMarker;
+  InfoWindow: new (opts: Record<string, unknown>) => NaverInfoWindow;
+  Event: { addListener: (target: unknown, type: string, fn: (...args: unknown[]) => void) => unknown; removeListener: (handler: unknown) => void };
+  Size: new (w: number, h: number) => unknown;
+  Point: new (x: number, y: number) => unknown;
+};
+type NaverMapInstance = {
+  setCenter: (latlng: unknown) => void;
+  setZoom: (zoom: number, useEffect?: boolean) => void;
+  getZoom: () => number;
+  getBounds: () => { getNE: () => LatLng; getSW: () => LatLng };
+  panTo: (latlng: unknown, opts?: Record<string, unknown>) => void;
+  refresh: (noEffect?: boolean) => void;
+};
+type NaverMarker = {
+  setMap: (map: NaverMapInstance | null) => void;
+  setIcon: (icon: Record<string, unknown>) => void;
+  setPosition: (latlng: unknown) => void;
+  getPosition: () => LatLng;
+};
+type NaverInfoWindow = {
+  open: (map: NaverMapInstance, marker: NaverMarker) => void;
+  close: () => void;
+  setContent: (content: string) => void;
+  getMap: () => NaverMapInstance | null;
+};
+
+const NAVER_CLIENT_ID = process.env.NEXT_PUBLIC_NAVER_MAP_CLIENT_ID || "";
+
+// Channel color palette — GoogleMapView와 동일
+const CHANNEL_COLORS = [
+  { border: "#f59e0b" }, // amber (default)
+  { border: "#3b82f6" }, // blue
+  { border: "#22c55e" }, // green
+  { border: "#ec4899" }, // pink
+  { border: "#a855f7" }, // purple
+  { border: "#ef4444" }, // red
+  { border: "#14b8a6" }, // teal
+  { border: "#eab308" }, // yellow
+];
+
+function getChannelColorMap(restaurants: Restaurant[]) {
+  const channels = new Set<string>();
+  restaurants.forEach((r) => r.channels?.forEach((ch) => channels.add(ch)));
+  const map: Record<string, typeof CHANNEL_COLORS[0]> = {};
+  let i = 0;
+  for (const ch of channels) {
+    map[ch] = CHANNEL_COLORS[i % CHANNEL_COLORS.length];
+    i++;
+  }
+  return map;
+}
+
+function useNaverMaps(): { ready: boolean; error: string | null } {
+  const [ready, setReady] = useState(typeof window !== "undefined" && !!window.naver?.maps);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!NAVER_CLIENT_ID) { setError("NEXT_PUBLIC_NAVER_MAP_CLIENT_ID 미설정"); return; }
+    if (window.naver?.maps) { setReady(true); return; }
+    const existing = document.querySelector<HTMLScriptElement>(`script[data-naver-maps]`);
+    if (existing) {
+      existing.addEventListener("load", () => setReady(true), { once: true });
+      return;
+    }
+    const s = document.createElement("script");
+    s.src = `https://oapi.map.naver.com/openapi/v3/maps.js?ncpKeyId=${NAVER_CLIENT_ID}`;
+    s.async = true;
+    s.dataset.naverMaps = "1";
+    s.onload = () => setReady(true);
+    s.onerror = () => setError("naver maps v3 스크립트 로드 실패");
+    document.head.appendChild(s);
+  }, []);
+
+  return { ready, error };
+}
+
+type RestaurantProps = { restaurant: Restaurant };
+type RestaurantFeature = Supercluster.PointFeature<RestaurantProps>;
+
+function useSupercluster(restaurants: Restaurant[]) {
+  const points: RestaurantFeature[] = useMemo(
+    () => restaurants.map((r) => ({
+      type: "Feature" as const,
+      geometry: { type: "Point" as const, coordinates: [r.longitude, r.latitude] },
+      properties: { restaurant: r },
+    })),
+    [restaurants]
+  );
+  const index = useMemo(() => {
+    const sc = new Supercluster<{ restaurant: Restaurant }>({ radius: 60, maxZoom: 16, minPoints: 2 });
+    sc.load(points);
+    return sc;
+  }, [points]);
+  const getClusters = useCallback((bounds: MapBounds, zoom: number) =>
+    index.getClusters([bounds.west, bounds.south, bounds.east, bounds.north], Math.floor(zoom))
+  , [index]);
+  const getExpansionZoom = useCallback((clusterId: number) => {
+    try { return index.getClusterExpansionZoom(clusterId); } catch { return 17; }
+  }, [index]);
+  return { getClusters, getExpansionZoom };
+}
+
+function getClusterSize(count: number): number {
+  if (count < 10) return 36;
+  if (count < 50) return 42;
+  if (count < 100) return 48;
+  return 54;
+}
+
+// 단일 마커 — 채널 색상별
+function markerIconHtml(color: string): string {
+  return `<div style="width:28px;height:28px;border-radius:9999px;background:${color};border:2px solid #fff;box-shadow:0 2px 6px rgba(0,0,0,.25);"></div>`;
+}
+// SVG data URL — 클러스터(숫자)
+function clusterIconHtml(count: number, size: number): string {
+  return `<div style="width:${size}px;height:${size}px;border-radius:9999px;background:rgba(245,158,11,.92);color:#fff;display:flex;align-items:center;justify-content:center;font-weight:700;font-size:${size > 44 ? 14 : 12}px;border:2px solid #fff;box-shadow:0 2px 8px rgba(0,0,0,.3);">${count}</div>`;
+}
+
+export default function NaverMapView({
+  restaurants,
+  selected,
+  onSelectRestaurant,
+  onBoundsChanged,
+  flyTo,
+  onMyLocation,
+  activeChannel,
+}: MapViewProps) {
+  const channelColors = useMemo(() => getChannelColorMap(restaurants), [restaurants]);
+  const { ready, error } = useNaverMaps();
+  const divRef = useRef<HTMLDivElement | null>(null);
+  const mapRef = useRef<NaverMapInstance | null>(null);
+  const markersRef = useRef<NaverMarker[]>([]);
+  const infoWindowRef = useRef<NaverInfoWindow | null>(null);
+  const [bounds, setBounds] = useState<MapBounds | null>(null);
+  const [zoom, setZoom] = useState(13);
+  const [initError, setInitError] = useState<string | null>(null);
+  const { getClusters, getExpansionZoom } = useSupercluster(restaurants);
+
+  // 지도 1회 생성
+  useEffect(() => {
+    if (!ready || !divRef.current || mapRef.current) return;
+    try {
+      const n = window.naver!.maps;
+      const initLat = flyTo?.lat ?? selected?.latitude ?? 37.5665;
+      const initLng = flyTo?.lng ?? selected?.longitude ?? 126.978;
+      const initZoom = flyTo?.zoom ?? 13;
+      const m = new n.Map(divRef.current, {
+        center: new n.LatLng(initLat, initLng),
+        zoom: initZoom,
+        logoControl: false,
+        mapDataControl: false,
+        scaleControl: false,
+        zoomControl: false,
+      });
+      mapRef.current = m;
+      infoWindowRef.current = new n.InfoWindow({
+        borderWidth: 0,
+        anchorSize: new n.Size(10, 10),
+        pixelOffset: new n.Point(0, -8),
+        backgroundColor: "transparent",
+        disableAnchor: false,
+      });
+
+      const ro = new ResizeObserver(() => {
+        try { m.refresh(true); } catch { /* noop */ }
+      });
+      ro.observe(divRef.current);
+
+      // bounds_changed가 줌/팬 끝나는 시점에 한 번만 emit (SDK가 throttle)
+      const sync = () => {
+        try {
+          const b = m.getBounds();
+          const ne = b.getNE(), sw = b.getSW();
+          const nb: MapBounds = { north: ne.lat(), south: sw.lat(), east: ne.lng(), west: sw.lng() };
+          setBounds(nb);
+          setZoom(m.getZoom());
+          onBoundsChanged?.(nb);
+        } catch (e) {
+          console.warn("[NaverMap] sync failed", e);
+        }
+      };
+      requestAnimationFrame(() => {
+        try { m.refresh(true); } catch { /* noop */ }
+        sync();
+      });
+      // idle = 줌/팬 끝났을 때 한 번 (bounds_changed보다 적게 발화 → 성능)
+      n.Event.addListener(m, "idle", sync);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.error("[NaverMap] init failed", e);
+      setInitError(msg);
+    }
+  }, [ready, flyTo, selected, onBoundsChanged]);
+
+  // flyTo 변경 반영
+  useEffect(() => {
+    const m = mapRef.current;
+    if (!m || !flyTo || !window.naver?.maps) return;
+    m.panTo(new window.naver.maps.LatLng(flyTo.lat, flyTo.lng));
+    if (flyTo.zoom) m.setZoom(flyTo.zoom, true);
+  }, [flyTo]);
+
+  // 클러스터 계산 (bounds/zoom 변경 시)
+  const clusters = useMemo(() => {
+    if (!bounds) return [];
+    return getClusters(bounds, zoom);
+  }, [bounds, zoom, getClusters]);
+
+  // 마커를 SDK 네이티브로 그림 — clusters 바뀌면 기존 마커 모두 제거 후 새로 생성
+  useEffect(() => {
+    const m = mapRef.current;
+    const naver = window.naver?.maps;
+    if (!m || !naver) return;
+
+    // 기존 마커 제거
+    for (const mk of markersRef.current) mk.setMap(null);
+    markersRef.current = [];
+
+    for (const feature of clusters) {
+      const [lng, lat] = feature.geometry.coordinates;
+      const isCluster = feature.properties && "cluster" in feature.properties && feature.properties.cluster;
+      if (isCluster) {
+        const { cluster_id, point_count } = feature.properties as Supercluster.ClusterProperties;
+        const size = getClusterSize(point_count);
+        const marker = new naver.Marker({
+          position: new naver.LatLng(lat, lng),
+          map: m,
+          icon: {
+            content: clusterIconHtml(point_count, size),
+            anchor: new naver.Point(size / 2, size / 2),
+          },
+        });
+        naver.Event.addListener(marker, "click", () => {
+          const z = Math.min(getExpansionZoom(cluster_id), 18);
+          m.panTo(new naver.LatLng(lat, lng));
+          m.setZoom(z, true);
+        });
+        markersRef.current.push(marker);
+      } else {
+        const r = (feature.properties as RestaurantProps).restaurant;
+        const chKey = activeChannel && r.channels?.includes(activeChannel) ? activeChannel : r.channels?.[0];
+        const chColor = chKey ? channelColors[chKey] : CHANNEL_COLORS[0];
+        const marker = new naver.Marker({
+          position: new naver.LatLng(lat, lng),
+          map: m,
+          title: r.name,
+          icon: {
+            content: markerIconHtml(chColor?.border ?? "#f59e0b"),
+            anchor: new naver.Point(14, 14),
+          },
+        });
+        naver.Event.addListener(marker, "click", () => {
+          const iw = infoWindowRef.current;
+          if (iw && m) {
+            iw.setContent(
+              `<div style="background:#fff;border-radius:8px;padding:8px 12px;box-shadow:0 4px 12px rgba(0,0,0,.18);font-size:13px;font-weight:600;color:#111;white-space:nowrap;">${escapeHtml(r.name)}</div>`
+            );
+            iw.open(m, marker);
+          }
+          onSelectRestaurant?.(r);
+        });
+        markersRef.current.push(marker);
+      }
+    }
+  }, [clusters, getExpansionZoom, onSelectRestaurant, channelColors, activeChannel]);
+
+  // 컴포넌트 unmount 시 마커 정리
+  useEffect(() => {
+    return () => {
+      for (const mk of markersRef.current) mk.setMap(null);
+      markersRef.current = [];
+      infoWindowRef.current?.close();
+    };
+  }, []);
+
+  return (
+    <div className="relative w-full h-full">
+      <div
+        ref={divRef}
+        className="absolute inset-0"
+        style={{ width: "100%", height: "100%", backgroundColor: "#e5e7eb" }}
+      />
+      {(error || initError) && (
+        <div className="absolute inset-0 flex items-center justify-center text-xs text-red-600 bg-white/80 pointer-events-none">
+          {error ?? initError}
+        </div>
+      )}
+      {!ready && !error && (
+        <div className="absolute inset-0 flex items-center justify-center text-xs text-gray-500 bg-white/80 pointer-events-none">
+          네이버 지도 로딩 중…
+        </div>
+      )}
+      {onMyLocation && (
+        <button
+          onClick={onMyLocation}
+          aria-label="내 위치"
+          className="absolute right-3 bottom-3 size-11 rounded-full bg-white shadow-lg flex items-center justify-center z-10"
+        >
+          <Icon name="my-location" size={22} />
+        </button>
+      )}
+    </div>
+  );
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/[&<>"']/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[ch] as string));
+}

frontend/src/components/RestaurantDetail.tsx

@@ -13,6 +13,26 @@ interface RestaurantDetailProps {
   onClose: () => void;
 }
 
+// #319 — 외부 지도 검색용 쿼리 빌더. region이 더미('나라|' 형태)면 무시.
+function buildSearchQuery(r: Restaurant): string {
+  if (r.address) return `${r.name} ${r.address}`;
+  if (r.region) {
+    const cleanRegion = r.region.replace(/\|/g, " ").trim();
+    // 빈 토큰만 남는 경우 (예: '한국' 또는 '한국|') → name만 사용
+    if (cleanRegion && cleanRegion !== "한국") return `${r.name} ${cleanRegion}`;
+  }
+  return r.name;
+}
+
+// 좌표 기반 한국 판정 (WGS84). KR bbox 대략 33~38.7°N, 124~132°E.
+// 좌표 없으면 region 첫 토큰으로 fallback (구 데이터 호환).
+function isKoreaRestaurant(r: Restaurant): boolean {
+  if (r.latitude != null && r.longitude != null) {
+    return r.latitude >= 33 && r.latitude <= 38.7 && r.longitude >= 124 && r.longitude <= 132;
+  }
+  return !r.region || r.region.split("|")[0] === "한국";
+}
+
 export default function RestaurantDetail({
   restaurant,
   onClose,
@@ -127,23 +147,34 @@ export default function RestaurantDetail({
         )}
         {restaurant.google_place_id && (
           <p className="flex gap-3">
+            {isKoreaRestaurant(restaurant) ? (
+              <>
                 <a
-              href={`https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(restaurant.name + (restaurant.address ? " " + restaurant.address : restaurant.region ? " " + restaurant.region.replace(/\|/g, " ") : ""))}`}
+                  href={`https://map.naver.com/p/search/${encodeURIComponent(buildSearchQuery(restaurant))}`}
-              target="_blank"
-              rel="noopener noreferrer"
-              className="text-brand-600 dark:text-brand-400 hover:underline text-xs"
-            >
-              Google Maps에서 보기
-            </a>
-            {(!restaurant.region || restaurant.region.split("|")[0] === "한국") && (
-              <a
-                href={`https://map.naver.com/v5/search/${encodeURIComponent(restaurant.name)}`}
                   target="_blank"
                   rel="noopener noreferrer"
                   className="text-green-600 dark:text-green-400 hover:underline text-xs"
                 >
                   네이버 지도에서 보기
                 </a>
+                <a
+                  href={`https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(buildSearchQuery(restaurant))}`}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="text-gray-500 dark:text-gray-400 hover:underline text-xs"
+                >
+                  Google Maps
+                </a>
+              </>
+            ) : (
+              <a
+                href={`https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(buildSearchQuery(restaurant))}`}
+                target="_blank"
+                rel="noopener noreferrer"
+                className="text-brand-600 dark:text-brand-400 hover:underline text-xs"
+              >
+                Google Maps에서 보기
+              </a>
             )}
           </p>
         )}

frontend/src/components/ReviewSection.tsx

@@ -4,37 +4,12 @@ import { useCallback, useEffect, useState } from "react";
 import { api } from "@/lib/api";
 import type { Review } from "@/lib/api";
 import { useAuth } from "@/lib/auth-context";
+import Stars from "@/components/Stars";
 
 interface ReviewSectionProps {
   restaurantId: string;
 }
 
-function StarDisplay({ rating }: { rating: number }) {
-  const stars = [];
-  for (let i = 1; i <= 5; i++) {
-    if (rating >= i) {
-      stars.push(
-        <span key={i} className="text-yellow-500">
-          ★
-        </span>
-      );
-    } else if (rating >= i - 0.5) {
-      stars.push(
-        <span key={i} className="text-yellow-500">
-          ★
-        </span>
-      );
-    } else {
-      stars.push(
-        <span key={i} className="text-gray-300">
-          ★
-        </span>
-      );
-    }
-  }
-  return <span className="text-sm">{stars}</span>;
-}
-
 function StarSelector({
   value,
   onChange,
@@ -43,22 +18,30 @@ function StarSelector({
   onChange: (v: number) => void;
 }) {
   return (
-    <div className="flex items-center gap-1">
+    <div role="radiogroup" aria-label="별점 선택" className="flex items-center gap-0.5">
       <span className="text-xs text-gray-500 mr-1">별점:</span>
-      {[0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5].map((v) => (
+      {[1, 2, 3, 4, 5].map((v) => {
+        const isCurrent = value === v || value === v - 0.5;
+        const nextVal = value === v ? v - 0.5 : v;
+        return (
           <button
             key={v}
             type="button"
-          onClick={() => onChange(v)}
+            role="radio"
-          className={`w-6 h-6 text-xs rounded border ${
+            aria-checked={value >= v - 0.5 && value <= v}
-            value === v
+            aria-label={`${nextVal}점`}
-              ? "bg-yellow-500 text-white border-yellow-600"
+            onClick={() => onChange(nextVal)}
-              : "bg-white text-gray-600 border-gray-300 hover:border-yellow-400"
+            // #281 — 최소 터치 영역 44×44
-          }`}
+            className="min-w-[44px] min-h-[44px] flex items-center justify-center touch-manipulation"
+            title={`${nextVal}점`}
           >
-          {v}
+            <span className={`text-xl ${v <= value ? "text-yellow-500" : v - 0.5 === value ? "text-yellow-400" : "text-gray-300"}`}>
+              {v <= value ? "★" : v - 0.5 === value ? "⯨" : "☆"}
+            </span>
           </button>
-      ))}
+        );
+      })}
+      {value > 0 && <span className="text-xs text-yellow-600 font-medium ml-1">{value}</span>}
     </div>
   );
 }
@@ -170,29 +153,42 @@ export default function ReviewSection({ restaurantId }: ReviewSectionProps) {
     ? reviews.find((r) => r.user_id === user.id)
     : null;
 
+  // #281 — API 실패 시 unhandled rejection 방지 + 사용자 피드백
   const handleCreate = async (data: {
     rating: number;
     review_text?: string;
     visited_at?: string;
   }) => {
+    try {
       await api.createReview(restaurantId, data);
       setShowForm(false);
       loadReviews();
+    } catch (e) {
+      alert(`리뷰 작성 실패: ${e instanceof Error ? e.message : String(e)}`);
+    }
   };
 
   const handleUpdate = async (
     reviewId: string,
     data: { rating: number; review_text?: string; visited_at?: string }
   ) => {
+    try {
       await api.updateReview(reviewId, data);
       setEditingId(null);
       loadReviews();
+    } catch (e) {
+      alert(`리뷰 수정 실패: ${e instanceof Error ? e.message : String(e)}`);
+    }
   };
 
   const handleDelete = async (reviewId: string) => {
     if (!confirm("리뷰를 삭제하시겠습니까?")) return;
+    try {
       await api.deleteReview(reviewId);
       loadReviews();
+    } catch (e) {
+      alert(`리뷰 삭제 실패: ${e instanceof Error ? e.message : String(e)}`);
+    }
   };
 
   return (
@@ -216,7 +212,7 @@ export default function ReviewSection({ restaurantId }: ReviewSectionProps) {
         <>
           {reviewCount > 0 && avgRating !== null && (
             <div className="flex items-center gap-2 mb-3 text-sm">
-              <StarDisplay rating={Math.round(avgRating * 2) / 2} />
+              <Stars rating={Math.round(avgRating * 2) / 2} />
               <span className="font-medium">{avgRating.toFixed(1)}</span>
               <span className="text-gray-500">({reviewCount}개)</span>
             </div>
@@ -261,6 +257,9 @@ export default function ReviewSection({ restaurantId }: ReviewSectionProps) {
                     <>
                       <div className="flex items-center gap-2 mb-1">
                         {review.user_avatar_url && (
+                          // eslint-disable-next-line @next/next/no-img-element
+                          // #343 — Google avatar URL은 remotePatterns에 추가됨.
+                          // next/image 전환은 SSR/lazy 효과 미미한 5x5 아바타라 후속에서 일괄 적용.
                           <img
                             src={review.user_avatar_url}
                             alt=""
@@ -270,7 +269,7 @@ export default function ReviewSection({ restaurantId }: ReviewSectionProps) {
                         <span className="text-sm font-medium">
                           {review.user_nickname || "익명"}
                         </span>
-                        <StarDisplay rating={review.rating} />
+                        <Stars rating={review.rating} />
                         <span className="text-xs text-gray-400">
                           {new Date(review.created_at).toLocaleDateString(
                             "ko-KR"

frontend/src/components/Stars.tsx

@@ -0,0 +1,37 @@
+// #281 공통 별점 컴포넌트 — ReviewSection/MemoSection/MyReviewsList 재사용.
+// 0.5 단위 시각 구분: 빈 별 위에 황색 절반 별을 절대배치 + clip으로 표시.
+
+interface StarsProps {
+  rating: number; // 0~5, 0.5 단위
+  size?: "sm" | "md";
+  showNumber?: boolean;
+  className?: string;
+}
+
+export default function Stars({ rating, size = "sm", showNumber = false, className = "" }: StarsProps) {
+  const r = Math.max(0, Math.min(5, rating));
+  const textSize = size === "md" ? "text-base" : "text-sm";
+  return (
+    <span className={`inline-flex items-center gap-0.5 ${textSize} ${className}`} aria-label={`${r}점`}>
+      {[1, 2, 3, 4, 5].map((i) => {
+        const full = r >= i;
+        const half = !full && r >= i - 0.5;
+        return (
+          <span key={i} className="relative inline-block leading-none">
+            <span className="text-gray-300">★</span>
+            {(full || half) && (
+              <span
+                aria-hidden="true"
+                className="absolute inset-0 text-yellow-500 overflow-hidden"
+                style={{ width: full ? "100%" : "50%" }}
+              >
+                ★
+              </span>
+            )}
+          </span>
+        );
+      })}
+      {showNumber && r > 0 && <span className="text-xs text-yellow-600 font-medium ml-1">{r}</span>}
+    </span>
+  );
+}

frontend/src/i18n/LocaleProvider.tsx

@@ -0,0 +1,56 @@
+"use client";
+
+import { NextIntlClientProvider } from "next-intl";
+import { useEffect, useState } from "react";
+import { DEFAULT_LOCALE, LOCALE_STORAGE_KEY, Locale, detectBrowserLocale, isLocale } from "./config";
+
+// #352 — 메시지 파일을 정적 import (Tree-shaking 가능, 클라이언트 번들에 4언어 모두 포함되지만
+// 30개 키 수준이라 부담 미미. 키가 늘어나면 동적 import로 분할 검토)
+import ko from "@/messages/ko.json";
+import en from "@/messages/en.json";
+import ja from "@/messages/ja.json";
+import es from "@/messages/es.json";
+
+const MESSAGES: Record<Locale, typeof ko> = { ko, en, ja, es };
+
+interface LocaleContextValue {
+  locale: Locale;
+  setLocale: (l: Locale) => void;
+}
+
+import { createContext, useContext } from "react";
+const LocaleContext = createContext<LocaleContextValue | null>(null);
+
+export function useLocale() {
+  const ctx = useContext(LocaleContext);
+  if (!ctx) throw new Error("useLocale must be used within LocaleProvider");
+  return ctx;
+}
+
+export function LocaleProvider({ children }: { children: React.ReactNode }) {
+  // SSR 단계는 기본 로케일로 시작 (hydration mismatch 방지)
+  const [locale, setLocaleState] = useState<Locale>(DEFAULT_LOCALE);
+
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const saved = localStorage.getItem(LOCALE_STORAGE_KEY);
+    const initial: Locale = isLocale(saved) ? saved : detectBrowserLocale();
+    if (initial !== locale) setLocaleState(initial);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const setLocale = (l: Locale) => {
+    setLocaleState(l);
+    if (typeof window !== "undefined") {
+      localStorage.setItem(LOCALE_STORAGE_KEY, l);
+    }
+  };
+
+  return (
+    <LocaleContext.Provider value={{ locale, setLocale }}>
+      <NextIntlClientProvider locale={locale} messages={MESSAGES[locale]}>
+        {children}
+      </NextIntlClientProvider>
+    </LocaleContext.Provider>
+  );
+}

frontend/src/i18n/config.ts

@@ -0,0 +1,28 @@
+// #352 i18n 뼈대 — 로케일 목록/기본값
+
+export const LOCALES = ["ko", "en", "ja", "es"] as const;
+export type Locale = (typeof LOCALES)[number];
+
+export const DEFAULT_LOCALE: Locale = "ko";
+export const LOCALE_STORAGE_KEY = "tasteby_locale";
+
+export const LOCALE_LABELS: Record<Locale, { flag: string; label: string; native: string }> = {
+  ko: { flag: "🇰🇷", label: "Korean", native: "한국어" },
+  en: { flag: "🇺🇸", label: "English", native: "English" },
+  ja: { flag: "🇯🇵", label: "Japanese", native: "日本語" },
+  es: { flag: "🇪🇸", label: "Spanish", native: "Español" },
+};
+
+export function isLocale(value: string | null | undefined): value is Locale {
+  return value != null && (LOCALES as readonly string[]).includes(value);
+}
+
+/**
+ * 브라우저 언어 감지 → 지원 로케일이면 그것, 아니면 기본값.
+ * SSR-safe (typeof window 체크 호출자).
+ */
+export function detectBrowserLocale(): Locale {
+  if (typeof navigator === "undefined") return DEFAULT_LOCALE;
+  const code = navigator.language.split("-")[0].toLowerCase();
+  return isLocale(code) ? code : DEFAULT_LOCALE;
+}

frontend/src/lib/admin-utils.ts

@@ -0,0 +1,52 @@
+// #304 어드민 페이지 공통 유틸.
+// 결함: localStorage 직접 접근 10+곳 / SSE 파싱 코드 6곳 중복.
+
+const TOKEN_KEY = "tasteby_token";
+
+export function getAdminToken(): string | null {
+  if (typeof window === "undefined") return null;
+  return localStorage.getItem(TOKEN_KEY);
+}
+
+export function authHeaders(): Record<string, string> {
+  const token = getAdminToken();
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+
+/**
+ * SSE(Server-Sent Events) 스트림을 라인 단위로 파싱하여 onEvent 콜백을 호출.
+ * 호환 패턴: `data: { ...json... }` 한 줄 = 한 이벤트.
+ * 비어있는 줄은 무시. JSON 파싱 실패 시 콜백 skip.
+ */
+export async function consumeSseStream(
+  response: Response,
+  onEvent: (event: unknown) => void,
+  onError?: (err: unknown) => void,
+): Promise<void> {
+  const reader = response.body?.getReader();
+  if (!reader) return;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:")) continue;
+        const payload = trimmed.slice(5).trim();
+        if (!payload) continue;
+        try {
+          onEvent(JSON.parse(payload));
+        } catch {
+          // 무시: 일부 SSE 줄이 JSON이 아닐 수도 있음
+        }
+      }
+    }
+  } catch (err) {
+    onError?.(err);
+  }
+}

frontend/src/lib/api.ts

@@ -51,6 +51,10 @@ export interface Restaurant {
   website: string | null;
   channels?: string[];
   foods_mentioned?: string[];
+  // #322 LLM 검증
+  hidden?: boolean;
+  hidden_reason?: string | null;
+  verified_at?: string | null;
 }
 
 export interface VideoLink {
@@ -310,6 +314,7 @@ export const api = {
         email: string | null;
         nickname: string | null;
         avatar_url: string | null;
+        is_admin: boolean;
         provider: string | null;
         created_at: string | null;
         favorite_count: number;
@@ -320,6 +325,14 @@ export const api = {
     }>(`/api/admin/users${qs ? `?${qs}` : ""}`);
   },
 
+  updateAdminUserAdmin(userId: string, admin: boolean) {
+    return fetchApi<{ success: boolean }>(`/api/admin/users/${userId}/admin`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ admin }),
+    });
+  },
+
   getAdminUserFavorites(userId: string) {
     return fetchApi<
       {
@@ -567,4 +580,30 @@ export const api = {
       { method: "POST" }
     );
   },
+
+  // #322 — LLM 검증 어드민 API
+  getVerifyPending() {
+    return fetchApi<{ pending: number }>("/api/admin/restaurants/verify/pending");
+  },
+  verifyAll(batchSize: number = 10) {
+    return fetchApi<{ processed: number }>(
+      `/api/admin/restaurants/verify/all?batchSize=${batchSize}`,
+      { method: "POST" }
+    );
+  },
+  verifyOne(id: string) {
+    return fetchApi<{ success: boolean; id: string }>(
+      `/api/admin/restaurants/${id}/verify`,
+      { method: "POST" }
+    );
+  },
+  setRestaurantHidden(id: string, hidden: boolean, reason: string = "manual") {
+    return fetchApi<{ success: boolean; id: string; hidden: boolean }>(
+      `/api/admin/restaurants/${id}/hidden`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({ hidden, reason }),
+      }
+    );
+  },
 };

frontend/src/messages/en.json

@@ -0,0 +1,41 @@
+{
+  "header": {
+    "search": "Search",
+    "login": "Sign In",
+    "logout": "Sign Out",
+    "menu": "Menu",
+    "myReviews": "My Reviews",
+    "favorites": "Favorites"
+  },
+  "actions": {
+    "save": "Save",
+    "cancel": "Cancel",
+    "delete": "Delete",
+    "edit": "Edit",
+    "confirm": "OK",
+    "close": "Close",
+    "loading": "Loading...",
+    "submit": "Submit"
+  },
+  "filter": {
+    "title": "Filter",
+    "cuisine": "Cuisine",
+    "price": "Price Range",
+    "region": "Region",
+    "channel": "Channel",
+    "reset": "Reset"
+  },
+  "restaurant": {
+    "rating": "Rating",
+    "address": "Address",
+    "phone": "Phone",
+    "website": "Website",
+    "closed": "Permanently Closed",
+    "tempClosed": "Temporarily Closed"
+  },
+  "review": {
+    "title": "Reviews",
+    "write": "Write a Review",
+    "noReviews": "No reviews yet"
+  }
+}

frontend/src/messages/es.json

@@ -0,0 +1,41 @@
+{
+  "header": {
+    "search": "Buscar",
+    "login": "Iniciar sesión",
+    "logout": "Cerrar sesión",
+    "menu": "Menú",
+    "myReviews": "Mis reseñas",
+    "favorites": "Favoritos"
+  },
+  "actions": {
+    "save": "Guardar",
+    "cancel": "Cancelar",
+    "delete": "Eliminar",
+    "edit": "Editar",
+    "confirm": "Aceptar",
+    "close": "Cerrar",
+    "loading": "Cargando...",
+    "submit": "Enviar"
+  },
+  "filter": {
+    "title": "Filtro",
+    "cuisine": "Tipo de cocina",
+    "price": "Rango de precios",
+    "region": "Región",
+    "channel": "Canal",
+    "reset": "Restablecer"
+  },
+  "restaurant": {
+    "rating": "Calificación",
+    "address": "Dirección",
+    "phone": "Teléfono",
+    "website": "Sitio web",
+    "closed": "Cerrado permanentemente",
+    "tempClosed": "Cerrado temporalmente"
+  },
+  "review": {
+    "title": "Reseñas",
+    "write": "Escribir una reseña",
+    "noReviews": "Aún no hay reseñas"
+  }
+}

frontend/src/messages/ja.json

@@ -0,0 +1,41 @@
+{
+  "header": {
+    "search": "検索",
+    "login": "ログイン",
+    "logout": "ログアウト",
+    "menu": "メニュー",
+    "myReviews": "マイレビュー",
+    "favorites": "お気に入り"
+  },
+  "actions": {
+    "save": "保存",
+    "cancel": "キャンセル",
+    "delete": "削除",
+    "edit": "編集",
+    "confirm": "確認",
+    "close": "閉じる",
+    "loading": "読み込み中...",
+    "submit": "送信"
+  },
+  "filter": {
+    "title": "フィルター",
+    "cuisine": "料理ジャンル",
+    "price": "価格帯",
+    "region": "地域",
+    "channel": "チャンネル",
+    "reset": "リセット"
+  },
+  "restaurant": {
+    "rating": "評価",
+    "address": "住所",
+    "phone": "電話",
+    "website": "ウェブサイト",
+    "closed": "閉店",
+    "tempClosed": "一時休業"
+  },
+  "review": {
+    "title": "レビュー",
+    "write": "レビューを書く",
+    "noReviews": "まだレビューがありません"
+  }
+}

frontend/src/messages/ko.json

@@ -0,0 +1,41 @@
+{
+  "header": {
+    "search": "검색",
+    "login": "로그인",
+    "logout": "로그아웃",
+    "menu": "메뉴",
+    "myReviews": "내 리뷰",
+    "favorites": "즐겨찾기"
+  },
+  "actions": {
+    "save": "저장",
+    "cancel": "취소",
+    "delete": "삭제",
+    "edit": "수정",
+    "confirm": "확인",
+    "close": "닫기",
+    "loading": "로딩 중...",
+    "submit": "제출"
+  },
+  "filter": {
+    "title": "필터",
+    "cuisine": "음식 종류",
+    "price": "가격대",
+    "region": "지역",
+    "channel": "채널",
+    "reset": "초기화"
+  },
+  "restaurant": {
+    "rating": "평점",
+    "address": "주소",
+    "phone": "전화",
+    "website": "웹사이트",
+    "closed": "폐업",
+    "tempClosed": "임시휴업"
+  },
+  "review": {
+    "title": "리뷰",
+    "write": "리뷰 작성",
+    "noReviews": "아직 리뷰가 없습니다"
+  }
+}