Merge pull request 'test' (#427) from test into main

Reviewed-on: #427

docs/20260529_메인_홈_추천_API/plan-task.md

@@ -597,6 +597,29 @@
 
 ---
 
+### Phase 9: 운영 MySQL native query Boolean 매핑 회귀 수정
+
+- [x] **Task 9.1: 첫 오디오 콘텐츠 native query 계산 Boolean 매핑 보정**
+  - Modify: `src/test/kotlin/kr/co/vividnext/sodalive/v2/recommendation/adapter/out/persistence/DefaultHomeRecommendationQueryRepositoryTest.kt`
+  - Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/adapter/out/persistence/DefaultHomeRecommendationQueryRepository.kt`
+  - Modify: `docs/20260529_메인_홈_추천_API/prd.md`
+  - Modify: `docs/20260529_메인_홈_추천_API/plan-task.md`
+  - RED: 운영에서 관측된 `is_original_series` native query 결과 `Integer(0/1)` row를 mock query로 재현하고 기존 `row[9] as Boolean` 캐스팅 실패를 확인한다.
+  - GREEN: `Boolean`과 `Number` 결과를 모두 Boolean으로 변환하는 최소 매핑을 적용한다.
+  - REFACTOR: 첫 오디오 콘텐츠 매핑 범위 밖 공개 API 스키마와 추천 정책은 변경하지 않는다.
+  - 검증 기준:
+    - Run: `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest.shouldMapNumericNativeBooleanFromFirstAudioContentRows`
+    - Run: `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest`
+    - Run: `./gradlew ktlintCheck`
+  - 기대 결과: 운영 MySQL/JDBC에서 `EXISTS` 계산 컬럼이 `Integer`로 반환되어도 `isOriginalSeries`가 정상 매핑된다.
+  - 검증 기록(2026-06-27):
+    - 무엇을: 운영에서 관측된 `is_original_series` native query 계산 컬럼의 `Integer(0/1)` 반환을 첫 오디오 콘텐츠 row 매핑에서 처리하는지 확인했다.
+    - 왜: 기존 `row[9] as Boolean` 캐스팅이 운영 MySQL/JDBC 결과에서 `ClassCastException`을 발생시켰기 때문이다.
+    - 어떻게: RED에서 `DefaultHomeRecommendationQueryRepositoryTest.shouldMapNumericNativeBooleanFromFirstAudioContentRows`를 추가하고 `row[9] = 1` mock row로 기존 구현의 `ClassCastException` 실패를 확인했다. GREEN에서 native Boolean 변환 helper를 적용한 뒤 동일 단일 테스트와 repository 테스트 클래스 전체를 재실행했다.
+    - 결과: 단일 테스트는 RED에서 `ClassCastException`으로 실패했고, GREEN 후 `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest.shouldMapNumericNativeBooleanFromFirstAudioContentRows`, `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest`, `./gradlew ktlintCheck`, `./gradlew tasks --all`이 모두 `BUILD SUCCESSFUL`로 통과했다. `ktlintCheck`와 `tasks --all`은 sandbox의 `~/.gradle` lock 파일 접근 제한으로 1차 실패했고 권한 상승 재실행으로 통과했다.
+
+---
+
 ## PRD Coverage Check
 
 - Feature A: Phase 3, Phase 6, Phase 7에서 통합 조회, limit, 인증/비회원, 팔로우 제외, 콘텐츠 조회 이력, 본인인증 여부, 차단 필터, 스냅샷 빈 배열 처리를 검증한다.
@@ -604,19 +627,20 @@
 - Feature C: Task 3.1과 Task 7.7에서 기존 콘텐츠 홈 배너 재활용, orders 정렬, 동일 orders 랜덤 정렬, 활성 배너/콘텐츠 조건, `EVENT`/`CREATOR`/`SERIES` 대상 비활성 제외, `CREATOR`/`SERIES` 대상 양방향 차단 제외, `LINK` 배너의 자체 활성 상태 기준 노출, 앱 이동 필드 유지를 검증한다.
 - Feature D: Task 1.3, Task 3.1에서 활동 타입 영문 enum, 최신 활동 1개, 크리에이터 프로필 이미지/닉네임, UTC 시간, 이동 대상 id nullable을 검증한다.
 - Feature E: Task 1.1, Task 1.2, Task 3.2, Task 6.3에서 데뷔일/점수/동점 랜덤 정렬/프로필 이미지와 닉네임 노출/전체보기를 검증한다.
-- Feature F: Task 1.1, Task 3.2, Task 6.3에서 첫 오디오 콘텐츠 판정, 최신성 점수 구간, 예약 공개 제외를 검증한다.
+- Feature F: Task 1.1, Task 3.2, Task 6.3, Task 9.1에서 첫 오디오 콘텐츠 판정, 최신성 점수 구간, 예약 공개 제외, native query Boolean 계산 컬럼 매핑을 검증한다.
 - Feature G: Task 1.1, Task 2.2, Task 2.6, Task 2.7, Task 2.8, Task 2.9, Task 3.3, Task 6.3, Task 8.1, Task 8.2에서 AI 캐릭터 점수, 캐릭터 생성일 기준 신규 부스트, 스냅샷, AI 채팅 집계 범위, DB-side exact scoring, 응답 필드, 오리지널 작품명 조건, 전체보기, AI 캐릭터에 대응하는 `creatorId` 노출을 검증한다.
 - Feature H: Task 4.1, Task 4.2, Task 4.3, Task 4.4에서 장르 조회 이력, 조회 이력 없을 때 랜덤 장르, 부족분 랜덤 보충, 한 응답 내 크리에이터 중복 제거, 조회 시점별 재노출 허용, 팔로우 제외, 조회자 본인 크리에이터 제외, 성인 장르 조건, 크리에이터 프로필 이미지/닉네임/id 노출을 검증한다.
 - Feature I: Task 5.1, Task 5.2에서 장르의 크리에이터와 최근 응원이 많은 크리에이터가 공통 동시 팔로우 use case를 재사용하고, 이미 팔로우 중인 id와 본인 id는 서버 내부에서 제외하며, 비활성 팔로우 이력은 재활성화하고, 존재하지 않는 id/크리에이터가 아닌 id는 전체 실패로 처리하는지 검증한다.
 - Feature J: Task 1.1, Task 2.2, Task 2.3.1, Task 2.4, Task 2.5, Task 2.8, Task 2.9, Task 3.3, Task 5.1, Task 5.2에서 최근 응원 점수/스냅샷 조회, 스냅샷 일 배치 클러스터 단일 실행, 8명 limit, 크리에이터 프로필 이미지/닉네임 노출, `CHANNEL_DONATION` 기준 후원 금액/후원 수, 팬 Talk 수, 최근 7일 집계, 데뷔일 기준 신규 부스트, DB-side exact scoring, 해당 섹션의 동시 팔로우를 검증한다.
 - Feature K: Task 1.1, Task 2.2, Task 2.5, Task 2.8, Task 2.9, Task 3.3, Task 7.1에서 인기 커뮤니티 점수/조건/홈 통합 응답 노출 필드(크리에이터 프로필 이미지, 닉네임, UTC 시간, 좋아요 수, 댓글 수, 내용)/댓글 불가 게시글 댓글 수 0점 계산, 데뷔일 기준 신규 부스트, 최근 7일 집계, DB-side exact scoring을 검증한다.
 - Metrics: Task 7.2에서 메인 홈 API 성공률/응답 시간, 섹션별 빈 응답 비율, 전체보기 API 조회 수, 추천 섹션별 클릭률, 동시 팔로우 요청/성공 수, 콘텐츠 조회 이력 기록 성공률, 일 배치 집계 성공/실패 수와 스냅샷 생성 소요 시간의 로그 또는 metric 기록 지점을 검증한다.
-- Technical Constraints/Non-Goals: Phase 1~7에서 `v2.api.home`/`v2.recommendation` 패키지 경계, `port.out` 의존 방향, 신규 v2 endpoint 분리, 기존 공개 스키마 유지, 서버 다국어 번역/ML 개인화/A-B 테스트/관리자 화면/수동 편집 제외 조건을 검증한다. 응답 enum 영문 code 안정성은 Task 1.3과 Task 3.1에서, `RecommendationSnapshotPort`의 persistence entity 노출 정리는 Task 2.4에서, 점수 기반 스냅샷의 `RecommendationScoreSpec` 공유 산식과 candidate pre-limit 금지는 Task 2.9에서, JPA/QueryDSL 우선 및 native SQL 제한 사용 전략은 Task 2.9와 Task 3.1에서, 신규 엔티티 테이블 생성 SQL 문서화는 Task 7.4에서 검증한다.
+- Technical Constraints/Non-Goals: Phase 1~7과 Phase 9에서 `v2.api.home`/`v2.recommendation` 패키지 경계, `port.out` 의존 방향, 신규 v2 endpoint 분리, 기존 공개 스키마 유지, 서버 다국어 번역/ML 개인화/A-B 테스트/관리자 화면/수동 편집 제외 조건을 검증한다. 응답 enum 영문 code 안정성은 Task 1.3과 Task 3.1에서, `RecommendationSnapshotPort`의 persistence entity 노출 정리는 Task 2.4에서, 점수 기반 스냅샷의 `RecommendationScoreSpec` 공유 산식과 candidate pre-limit 금지는 Task 2.9에서, JPA/QueryDSL 우선 및 native SQL 제한 사용 전략은 Task 2.9와 Task 3.1에서, native query Boolean 계산 컬럼 매핑은 Task 9.1에서, 신규 엔티티 테이블 생성 SQL 문서화는 Task 7.4에서 검증한다.
 
 ---
 
 ## Verification Log
 
+- 2026-06-27: Phase 9 코드 리뷰 및 검증을 진행했다. 변경 범위가 첫 오디오 콘텐츠 native query row 매핑의 Boolean 변환 보정과 운영 회귀 테스트/문서 보강에 한정되어 있는지 확인했고, `isPointAvailable`, `isAdult`, `isOriginalSeries`가 `Boolean` 또는 `Number(0/1)` 모두에서 명시적으로 Boolean으로 변환되는지 점검했다. 리뷰 결과 수정이 필요한 결함은 발견하지 못했다. 검증으로 `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest.shouldMapNumericNativeBooleanFromFirstAudioContentRows`, `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest`, `./gradlew ktlintCheck`, `./gradlew tasks --all`, `git diff --check`, `git diff --check --cached`, `./gradlew test`를 실행했고 모두 `BUILD SUCCESSFUL` 또는 통과를 확인했다. `ktlintCheck`와 `tasks --all`은 sandbox의 `~/.gradle` lock 파일 접근 제한으로 최초 실패해 권한 상승으로 재실행했다.
 - 2026-06-23: Phase 8 코드 리뷰 및 검증을 진행했다. 변경 범위가 `creatorId` additive schema 추가에 한정되어 있는지 확인했고, `HomeAiCharacterRecommendationRecord.creatorId` → `HomeAiCharacterItem.creatorId` 매핑, `ChatCharacter.creatorMember` inner join과 활성/CREATOR/AI_CHARACTER 필터, 홈 통합/AI 캐릭터 전체보기 JSON 응답 검증 테스트를 점검했다. 리뷰 결과 수정이 필요한 결함은 발견하지 못했다. 검증으로 `./gradlew test --rerun-tasks --tests kr.co.vividnext.sodalive.v2.recommendation.application.HomeRecommendationQueryServiceTest --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest --tests kr.co.vividnext.sodalive.v2.api.home.dto.recommendation.HomeRecommendationResponseTest --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest`, `./gradlew ktlintCheck`, `./gradlew tasks --all`, `git diff --check`, `./gradlew test`를 실행했고 모두 `BUILD SUCCESSFUL` 또는 통과를 확인했다. `ktlintCheck`와 `tasks --all`은 sandbox의 `~/.gradle` lock 파일 접근 제한으로 최초 실패해 권한 상승으로 재실행했다.
 - 2026-06-23: Phase 8 구현을 진행했다. RED에서 `HomeAiCharacterRecommendationRecord`와 `HomeAiCharacterItem`의 `creatorId` 미구현으로 `compileTestKotlin`이 실패하는 것을 확인했고, GREEN에서 `HomeAiCharacterRecommendationRecord.creatorId`, AI 캐릭터 상세 조회의 `ChatCharacter.creatorMember` inner join 및 활성/CREATOR/AI_CHARACTER 조건, `HomeAiCharacterItem.creatorId`, facade 매핑을 추가했다. 회귀 검증으로 `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.application.HomeRecommendationQueryServiceTest --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest --tests kr.co.vividnext.sodalive.v2.api.home.dto.recommendation.HomeRecommendationResponseTest --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest`, `./gradlew ktlintCheck`, `./gradlew tasks --all`, `git diff --check`, `./gradlew test`를 실행해 모두 성공을 확인했다. `ktlintCheck`는 최초 실행에서 import 정렬 오류로 실패했고 import 순서 보정 후 `BUILD SUCCESSFUL`로 통과했다. 리뷰어 지적에 따라 `creatorMember` 누락 row 제외 테스트를 추가했고, 해당 단일 테스트와 Phase 8 대상 테스트 묶음, `ktlintCheck`를 재실행해 모두 성공한 뒤 리뷰어 재검토에서 승인받았다.
 - 2026-06-23: 사용자 피드백에 따라 AI 캐릭터 추천 item에 `creatorId`를 추가하는 요구사항을 기존 홈 추천 API PRD와 plan-task에 후속 Phase 8로 보강했다. `creatorId`는 `ChatCharacter.creatorMember.id`로 확정하고, 기존 `characterId`는 AI 채팅 이동 대상 id로 유지하는 additive schema 변경으로 문서화했다. 검증으로 `rg -n "creatorId|Phase 8|Task 8\\.|ChatCharacter.creatorMember|Feature G" docs/20260529_메인_홈_추천_API/prd.md docs/20260529_메인_홈_추천_API/plan-task.md`, `git diff --check`, `./gradlew tasks --all`을 실행했다. `./gradlew tasks --all`은 최초 샌드박스 실행에서 Gradle wrapper의 `~/.gradle` lock 파일 접근 권한 문제로 실패했으나, 권한 상승 재실행 결과 `BUILD SUCCESSFUL`로 통과했다.

docs/20260529_메인_홈_추천_API/prd.md

@@ -268,6 +268,7 @@
 - 기존 엔티티 후보는 `Member`, `LiveRoom`, `AudioContent`, `AudioContentBanner`, `CreatorFollowing`, `CreatorCommunity`, `CreatorCommunityLike`, `CreatorCommunityComment`, `CreatorCheers`, `ChannelDonationMessage`, `AudioContentComment`, `AudioContentLike`, `ChatCharacter` 등이다.
 - 조회 구현은 복잡도에 맞춰 선택한다. 단순 id 조회, 단건 조회, 명확한 조건 조회는 Spring Data JPA 기본 메서드 또는 `@Query`를 사용할 수 있고, 동적 조건/집계/서브쿼리/복합 정렬이 필요한 경우 QueryDSL을 우선 사용한다.
 - native SQL은 CTE, window function, `union all`, DB-side exact scoring, DB별 랜덤 tie-breaker처럼 QueryDSL/JPA 표현이 부자연스럽거나 정확도/성능을 해칠 수 있는 경우에만 사용한다. native SQL을 사용할 때는 RED 단계에서 제외 조건, null aggregate, boundary window, 정렬/limit 순서, Kotlin 정책 산식과의 parity를 촘촘히 검증한다.
+- native SQL 결과 매핑에서 `exists`, `case`, 집계식처럼 DB/JDBC 드라이버가 `0/1` 숫자로 반환할 수 있는 Boolean 계산 컬럼은 `Boolean` 직접 캐스팅에 의존하지 않고 명시적으로 Boolean 값으로 변환한다.
 - 홈 추천 조회에는 공통 차단 필터를 적용해 내가 차단했거나 나를 차단한 크리에이터의 데이터를 제외한다.
 - 커뮤니티 게시글 조회에는 비공개 제외, 유료 글 제외, 핀 고정 글 제외, 성인 노출 조건(`MemberContentPreference.isAdultContentVisible`)을 공통 적용한다.
 - 일 1회 갱신 섹션은 조회 시점마다 무거운 집계를 하지 않도록 집계 테이블 또는 스냅샷 엔티티를 신규로 둔다.

docs/20260627_관리자_회원목록_LazyInitializationException_수정/plan-task.md

@@ -0,0 +1,94 @@
+# 관리자 회원 목록 LazyInitializationException 수정 Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:executing-plans` 또는 동등한 TDD 절차로 task 단위 구현을 진행한다. 각 단계는 체크박스(`- [ ]`)로 진행 상태를 갱신한다.
+
+**Goal:** `spring.jpa.open-in-view=false` 환경에서 관리자 회원 리스트와 크리에이터 리스트 조회가 `Member.signOutReasons` lazy collection 접근 때문에 실패하지 않게 한다.
+
+**Architecture:** 기존 `AdminMemberService`의 응답 매핑 구조는 유지한다. 서비스 클래스에 read-only 트랜잭션을 기본 적용해 목록 조회와 응답 매핑 전체를 열린 영속성 컨텍스트 안에서 처리한다. 쓰기 메서드는 기존 메서드 레벨 `@Transactional`로 read-only 기본값을 override한다.
+
+**Tech Stack:** Kotlin, Spring Boot 2.7.14, Java 17, Spring Data JPA, QueryDSL, JUnit 5, Gradle Wrapper
+
+---
+
+## 0. 구현 전 확정 사항
+
+- API 응답 스키마는 변경하지 않는다.
+- `Member.signOutReasons`를 eager로 바꾸지 않는다.
+- OSIV 설정을 켜지 않는다.
+- 리포지토리 fetch join이나 projection 전면 개편은 이번 범위에서 제외한다.
+- lazy 접근 문제가 확인된 대상 메서드:
+  - `AdminMemberService.getMemberList(...)`
+  - `AdminMemberService.searchMember(...)`
+  - `AdminMemberService.getCreatorList(...)`
+  - `AdminMemberService.searchCreator(...)`
+
+---
+
+## 1. 파일 구조 계획
+
+- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/admin/member/AdminMemberService.kt`
+  - 클래스 레벨에 `@Transactional(readOnly = true)`를 추가하고, 기존 쓰기 메서드의 `@Transactional`은 유지한다.
+- Create: `src/test/kotlin/kr/co/vividnext/sodalive/admin/member/AdminMemberServiceTest.kt`
+  - OSIV off 환경에서 탈퇴 이력이 있는 회원/크리에이터 목록 조회가 예외 없이 응답되는지 검증한다.
+- Verify: `src/test/resources/application.yml`
+  - `spring.jpa.open-in-view: false` 테스트 설정을 그대로 사용한다.
+
+---
+
+### Phase 1: LazyInitializationException 재현 테스트
+
+- [x] **Task 1.1: 관리자 회원/크리에이터 목록 실패 테스트 작성**
+  - Test: `src/test/kotlin/kr/co/vividnext/sodalive/admin/member/AdminMemberServiceTest.kt`
+  - RED: `@SpringBootTest(properties = ["cloud.aws.cloud-front.host=https://cdn.test"])` 통합 테스트를 추가한다.
+  - RED: 테스트 클래스에는 `@Transactional`을 붙이지 않아 서비스 호출이 테스트 트랜잭션에 의해 가려지지 않게 한다.
+  - RED: `MemberRole.USER` 회원과 `MemberRole.CREATOR` 회원을 저장하고, 각각 `SignOut`을 저장한다.
+  - RED: `service.getMemberList(PageRequest.of(0, 20))`, `service.getCreatorList(PageRequest.of(0, 20))`를 호출해 `signOutDate`가 비어 있지 않고 예외가 발생하지 않기를 기대한다.
+  - 실패 확인: `./gradlew test --tests kr.co.vividnext.sodalive.admin.member.AdminMemberServiceTest`
+  - 기대 결과: production code 수정 전에는 `LazyInitializationException`으로 테스트가 실패한다.
+  - 구현 기록(2026-06-27): `AdminMemberServiceTest`를 추가해 `@Transactional` 없는 테스트 클래스에서 서비스 목록 조회를 호출하도록 했다.
+    - 1차 RED: `./gradlew test --tests kr.co.vividnext.sodalive.admin.member.AdminMemberServiceTest` 실행 시 Redis 연결 실패로 Spring context 생성이 실패해 의도한 실패가 아니었다.
+    - 보정: 기존 통합 테스트 패턴에 맞춰 `EmbeddedRedisInitializer`를 추가했다.
+    - 2차 RED: 같은 명령 재실행 결과 `getMemberList`, `getCreatorList` 모두 `LazyInitializationException`으로 실패해 OSIV off lazy collection 접근 문제를 재현했다.
+
+---
+
+### Phase 2: 서비스 read-only 트랜잭션 보강
+
+- [x] **Task 2.1: 서비스 클래스에 read-only 트랜잭션 기본값 추가**
+  - Modify: `src/main/kotlin/kr/co/vividnext/sodalive/admin/member/AdminMemberService.kt`
+  - GREEN: `AdminMemberService` 클래스에 `@Transactional(readOnly = true)`를 추가한다.
+  - GREEN: `updateMember`, `resetPassword`의 기존 메서드 레벨 `@Transactional`은 유지해 쓰기 트랜잭션으로 동작하게 한다.
+  - GREEN: 응답 매핑 로직과 리포지토리 쿼리는 변경하지 않는다.
+  - 통과 확인: `./gradlew test --tests kr.co.vividnext.sodalive.admin.member.AdminMemberServiceTest`
+  - 기대 결과: `BUILD SUCCESSFUL`
+  - REFACTOR: 불필요한 import/format 변경이 생기지 않았는지 확인한다.
+  - 구현 기록(2026-06-27): 최초 구현에서는 `getMemberList`, `searchMember`, `getCreatorList`, `searchCreator`에 `@Transactional(readOnly = true)`를 추가했다.
+    - GREEN: `./gradlew test --tests kr.co.vividnext.sodalive.admin.member.AdminMemberServiceTest` 실행 결과 `BUILD SUCCESSFUL`을 확인했다.
+    - 검증 이유: OSIV off 환경에서 서비스 메서드의 read-only 트랜잭션 안에서 `signOutReasons`와 `auth` lazy 접근이 완료되는지 확인했다.
+  - 후속 수정(2026-06-27): 리뷰 피드백에 따라 개별 조회 메서드 annotation을 제거하고 `AdminMemberService` 클래스 레벨 `@Transactional(readOnly = true)`로 정리했다. 쓰기 메서드 `updateMember`, `resetPassword`는 기존 메서드 레벨 `@Transactional`을 유지했다.
+
+---
+
+### Phase 3: 회귀 검증과 문서 기록
+
+- [x] **Task 3.1: 관련 검증 실행 및 문서 기록**
+  - Verify: `./gradlew test --tests kr.co.vividnext.sodalive.admin.member.AdminMemberServiceTest`
+  - Verify: `./gradlew :app:ktlintCheck`는 단일 루트 프로젝트에 `:app` 모듈이 없으면 실행하지 않고 `./gradlew ktlintCheck`로 대체한다.
+  - Verify: `./gradlew ktlintCheck`
+  - Verify: `./gradlew tasks --all`
+  - 문서 기록: 각 task 아래에 실행 명령, 결과, 검증 이유를 한국어로 누적한다.
+  - 구현 기록(2026-06-27): 관련 단일 테스트, ktlint, Gradle task 목록 검증을 실행했다.
+    - 단일 테스트: `./gradlew test --tests kr.co.vividnext.sodalive.admin.member.AdminMemberServiceTest` 실행 결과 `BUILD SUCCESSFUL`을 확인했다.
+    - ktlint 1차: `./gradlew ktlintCheck`를 `./gradlew tasks --all`과 동시에 실행했을 때 `~/.gradle` wrapper lock 파일 접근 sandbox 오류로 실패했다.
+    - ktlint 재실행: `./gradlew --no-daemon ktlintCheck` 실행 결과 `BUILD SUCCESSFUL`을 확인했다.
+    - 명령 유효성: `./gradlew --no-daemon tasks --all` 실행 결과 `BUILD SUCCESSFUL`을 확인했다.
+
+---
+
+## 검증 기록
+
+- 2026-06-27: `./gradlew test --tests kr.co.vividnext.sodalive.admin.member.AdminMemberServiceTest`로 OSIV off lazy collection 재현 테스트가 수정 후 통과함을 확인했다.
+- 2026-06-27: `./gradlew --no-daemon ktlintCheck`로 Kotlin formatting 검증이 통과함을 확인했다.
+- 2026-06-27: `./gradlew --no-daemon tasks --all`로 문서에 안내된 Gradle 명령 목록이 유효함을 확인했다.
+- 2026-06-27: 최종 확인으로 `./gradlew --no-daemon test --tests kr.co.vividnext.sodalive.admin.member.AdminMemberServiceTest`와 `./gradlew --no-daemon ktlintCheck`를 재실행했고 둘 다 `BUILD SUCCESSFUL`을 확인했다.
+- 2026-06-27: 클래스 레벨 `@Transactional(readOnly = true)` 후속 변경 후 `./gradlew --no-daemon test --tests kr.co.vividnext.sodalive.admin.member.AdminMemberServiceTest`와 `./gradlew --no-daemon ktlintCheck`를 재실행했고 둘 다 `BUILD SUCCESSFUL`을 확인했다.

docs/20260627_관리자_회원목록_LazyInitializationException_수정/prd.md

@@ -0,0 +1,77 @@
+# PRD: 관리자 회원 목록 LazyInitializationException 수정
+
+## 1. Overview
+`spring.jpa.open-in-view=false` 환경에서 관리자 회원 리스트와 크리에이터 리스트 조회 시 `Member.signOutReasons` lazy collection 접근으로 발생하는 `LazyInitializationException`을 방지한다.
+
+---
+
+## 2. Problem
+- 관리자 회원 목록 응답 생성 중 `Member.signOutReasons`를 읽어 탈퇴일을 계산한다.
+- 현재 `AdminMemberService`의 목록 조회 메서드는 트랜잭션 경계가 없어 QueryDSL 조회 후 영속성 컨텍스트가 닫힌 상태에서 lazy collection을 접근할 수 있다.
+- `spring.jpa.open-in-view=false` 환경에서는 이 접근이 `org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: kr.co.vividnext.sodalive.member.Member.signOutReasons`로 이어진다.
+- 같은 응답 매핑 흐름을 사용하는 관리자 회원 리스트, 회원 검색, 크리에이터 리스트, 크리에이터 검색 모두 같은 위험이 있다.
+
+---
+
+## 3. Goals
+- `osiv=false` 환경에서도 관리자 회원 리스트와 크리에이터 리스트가 예외 없이 응답된다.
+- 기존 API 응답 스키마와 정렬/필터 조건을 변경하지 않는다.
+- 탈퇴 이력이 있는 회원의 `signOutDate` 계산 동작을 유지한다.
+- 서비스 계층에 명확한 read-only 트랜잭션 기본 경계를 둔다.
+- 실패 재현 테스트를 먼저 작성하고, 최소 수정으로 통과시킨다.
+
+---
+
+## 4. Non-Goals
+- 관리자 회원 목록 API의 응답 필드를 변경하지 않는다.
+- `Member.signOutReasons` fetch 전략을 전역 eager로 바꾸지 않는다.
+- 목록 조회를 projection 전용 쿼리로 전면 개편하지 않는다.
+- pagination/count 쿼리 구조를 리팩터링하지 않는다.
+- OSIV 설정을 다시 켜지 않는다.
+
+---
+
+## 5. Target Users
+- 관리자: 관리자 화면에서 회원 목록과 크리에이터 목록을 조회하는 사용자
+- 운영자: 탈퇴 또는 차단 이력이 있는 회원을 포함한 목록을 안정적으로 확인해야 하는 사용자
+
+---
+
+## 6. User Stories
+- 관리자는 탈퇴 이력이 있는 일반 회원이 포함된 회원 리스트를 조회해도 서버 오류를 만나지 않아야 한다.
+- 관리자는 탈퇴 이력이 있는 크리에이터가 포함된 크리에이터 리스트를 조회해도 서버 오류를 만나지 않아야 한다.
+- 관리자는 검색 결과에서도 동일하게 탈퇴일과 활성 상태를 확인할 수 있어야 한다.
+
+---
+
+## 7. Core Features
+
+### Feature A. 관리자 회원 목록 조회 트랜잭션 보강
+
+#### Requirements
+- `AdminMemberService`는 클래스 레벨 `@Transactional(readOnly = true)`로 조회 기본 트랜잭션을 제공한다.
+- `AdminMemberService.getMemberList(...)`는 read-only 트랜잭션 안에서 조회와 응답 매핑을 완료한다.
+- `AdminMemberService.searchMember(...)`는 read-only 트랜잭션 안에서 조회와 응답 매핑을 완료한다.
+- `AdminMemberService.getCreatorList(...)`는 read-only 트랜잭션 안에서 조회와 응답 매핑을 완료한다.
+- `AdminMemberService.searchCreator(...)`는 read-only 트랜잭션 안에서 조회와 응답 매핑을 완료한다.
+- `AdminMemberService.updateMember(...)`, `AdminMemberService.resetPassword(...)`는 메서드 레벨 `@Transactional`로 쓰기 트랜잭션을 유지한다.
+- 기존 `processMemberListToGetAdminMemberListResponseItemList(...)`의 응답 필드 계산 방식은 유지한다.
+
+#### Edge Cases
+- `signOutReasons`가 비어 있으면 기존처럼 `signOutDate`는 빈 문자열이다.
+- `signOutReasons`가 있으면 기존처럼 마지막 탈퇴 이력의 `createdAt`을 KST `yyyy-MM-dd HH:mm` 형식으로 내려준다.
+- `auth` lazy one-to-one 접근도 같은 read-only 트랜잭션 안에서 처리되어야 한다.
+
+---
+
+## 8. Technical Constraints
+- Kotlin + Spring Boot 2.7.14 + Spring Data JPA 기준으로 구현한다.
+- 테스트 환경의 `spring.jpa.open-in-view=false` 설정을 유지한다.
+- 서비스 클래스에는 `@Transactional(readOnly = true)`를 사용하고, 쓰기 메서드는 기존 메서드 레벨 `@Transactional`을 유지한다.
+- 변경 범위는 `AdminMemberService`와 해당 테스트로 제한한다.
+
+---
+
+## 9. Metrics
+- `AdminMemberServiceTest`에서 OSIV off 조건의 회원/크리에이터 목록 조회 테스트가 통과한다.
+- 관련 단일 테스트와 `ktlintCheck`가 통과한다.

docs/20260627_콘텐츠_전체보기_API/plan-task.md

@@ -0,0 +1,804 @@
+# 콘텐츠 전체보기 API Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use `superpowers:subagent-driven-development` 또는 `superpowers:executing-plans`로 task 단위 구현을 진행한다. 각 단계는 체크박스(`- [ ]`)로 진행 상태를 갱신한다.
+
+**Goal:** `GET /api/v2/contents`로 인증 회원이 `NEW_AND_HOT_AUDIO`, `FIRST_AUDIO_CONTENT` 콘텐츠 전체보기 목록을 동일한 페이징 계약으로 조회할 수 있게 한다.
+
+**Architecture:** 공개 API controller/facade/response DTO는 `kr.co.vividnext.sodalive.v2.api.content.overview` 조립 계층에 둔다. New & Hot 조회는 기존 `v2.content.recommendation` 도메인 조회 계층을 확장해 재사용하고, 첫 번째 오디오 콘텐츠 조회는 기존 `v2.recommendation.application.HomeRecommendationQueryService.findFirstAudioContents(...)`를 재사용한다. 기존 홈 하위 전체보기 endpoint는 배포 전 기능이므로 제거하고, 새 콘텐츠 전체보기 API로 책임을 이동한다.
+
+**Tech Stack:** Kotlin, Spring Boot 2.7.14, Java 17, Spring MVC, Spring Security, Spring Data JPA, QueryDSL/native SQL, Redisson, JUnit 5, MockMvc, Gradle Wrapper
+
+---
+
+## 0. 구현 전 확정 사항
+
+- API endpoint: `GET /api/v2/contents`
+- 인증 정책: 비회원 조회 불가. 인증 회원만 호출할 수 있다.
+- 응답 wrapper: `ApiResponse.ok(...)`
+- 요청 query parameter:
+  - `type`: `NEW_AND_HOT_AUDIO`, `FIRST_AUDIO_CONTENT`; 기본값 `NEW_AND_HOT_AUDIO`
+  - `page`: 0부터 시작. 기본값 `0`
+  - `size`: 기본값 `20`, 최소값보다 작으면 `20`, 최대 `50`
+- invalid `type`은 400 오류 대신 `NEW_AND_HOT_AUDIO`로 fallback한다.
+- `hasNext`는 `size + 1`개 조회 후 응답 item은 최대 `size`개만 내려주는 방식으로 계산한다.
+- `NEW_AND_HOT_AUDIO`는 `AudioRecommendationQueryService`에 페이징 조회 메서드를 추가해 조회한다.
+- New & Hot 첫 화면 노출 수는 `12`로 유지한다.
+- New & Hot 스냅샷 저장 수는 `SAFE`, `ALL` 각각 `100`으로 확장한다.
+- `FIRST_AUDIO_CONTENT`는 `HomeRecommendationQueryService.findFirstAudioContents(...)`를 새 콘텐츠 전체보기 Facade에서 직접 호출한다.
+- `GET /api/v2/home/recommendations/first-audio-contents`는 제거한다.
+- 신규 DB 테이블과 DDL은 작성하지 않는다. New & Hot 전체보기용 스냅샷은 기존 `recommendation_snapshot` 테이블을 재사용하고, 저장 개수만 visibility별 100개로 확장한다.
+
+---
+
+## 1. 파일 구조 계획
+
+### 신규 API 조립 계층
+- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewController.kt`
+- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewFacade.kt`
+- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewQueryPolicy.kt`
+- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/dto/ContentOverviewPageResponse.kt`
+- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewControllerTest.kt`
+- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewFacadeTest.kt`
+- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewQueryPolicyTest.kt`
+- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/dto/ContentOverviewPageResponseTest.kt`
+
+### 기존 도메인 조회 계층 확장
+- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationQueryService.kt`
+- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationSnapshotRefreshService.kt`
+- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/port/out/HomeRecommendationQueryPort.kt`
+- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/adapter/out/persistence/DefaultHomeRecommendationQueryRepository.kt`
+- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationQueryServiceTest.kt`
+- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationSnapshotRefreshServiceTest.kt`
+- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/recommendation/application/HomeRecommendationQueryServiceTest.kt`
+
+### 미배포 홈 하위 endpoint 제거
+- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/home/adapter/in/web/HomeRecommendationController.kt`
+- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/home/application/HomeRecommendationFacade.kt`
+- Modify: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/home/HomeRecommendationControllerTest.kt`
+
+### 통합 검증
+- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewEndToEndTest.kt`
+- Verify: `src/main/kotlin/kr/co/vividnext/sodalive/configs/SecurityConfig.kt`
+- Verify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/port/out/RecommendationSnapshotPort.kt`
+- Verify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/port/out/AudioRecommendationQueryPort.kt`
+- Verify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/application/HomeRecommendationQueryService.kt`
+
+---
+
+## 2. 공개 응답 및 정책 초안
+
+`src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/dto/ContentOverviewPageResponse.kt`
+
+```kotlin
+package kr.co.vividnext.sodalive.v2.api.content.overview.dto
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import kr.co.vividnext.sodalive.v2.content.recommendation.domain.AudioCard
+import kr.co.vividnext.sodalive.v2.recommendation.port.out.HomeFirstAudioContentRecord
+
+data class ContentOverviewPageResponse(
+    val type: ContentOverviewType,
+    val items: List<ContentOverviewItemResponse>,
+    val page: Int,
+    val size: Int,
+    @JsonProperty("hasNext")
+    val hasNext: Boolean
+)
+
+enum class ContentOverviewType {
+    NEW_AND_HOT_AUDIO,
+    FIRST_AUDIO_CONTENT;
+
+    companion object {
+        fun from(value: String?): ContentOverviewType {
+            return values().firstOrNull { it.name == value } ?: NEW_AND_HOT_AUDIO
+        }
+    }
+}
+
+data class ContentOverviewItemResponse(
+    val contentId: Long,
+    val title: String,
+    val coverImage: String?,
+    val price: Int,
+    @JsonProperty("isPointAvailable")
+    val isPointAvailable: Boolean,
+    val creatorNickname: String,
+    @JsonProperty("isAdult")
+    val isAdult: Boolean,
+    @JsonProperty("isFirstContent")
+    val isFirstContent: Boolean,
+    @JsonProperty("isOriginalSeries")
+    val isOriginalSeries: Boolean
+) {
+    companion object {
+        fun fromNewAndHot(audio: AudioCard): ContentOverviewItemResponse {
+            return ContentOverviewItemResponse(
+                contentId = audio.audioContentId,
+                title = audio.title,
+                coverImage = audio.imageUrl,
+                price = audio.price,
+                isPointAvailable = audio.isPointAvailable,
+                creatorNickname = audio.creatorNickname,
+                isAdult = audio.isAdult,
+                isFirstContent = audio.isFirstContent,
+                isOriginalSeries = audio.isOriginalSeries
+            )
+        }
+
+        fun fromFirstAudioContent(
+            audio: HomeFirstAudioContentRecord,
+            coverImage: String?
+        ): ContentOverviewItemResponse {
+            return ContentOverviewItemResponse(
+                contentId = audio.contentId,
+                title = audio.title,
+                coverImage = coverImage,
+                price = audio.price,
+                isPointAvailable = audio.isPointAvailable,
+                creatorNickname = audio.creatorNickname,
+                isAdult = audio.isAdult,
+                isFirstContent = true,
+                isOriginalSeries = audio.isOriginalSeries
+            )
+        }
+    }
+}
+```
+
+`src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewQueryPolicy.kt`
+
+```kotlin
+package kr.co.vividnext.sodalive.v2.api.content.overview.application
+
+import kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewType
+
+data class ContentOverviewPage(
+    val page: Int,
+    val size: Int
+) {
+    val offset: Long = page.toLong() * size
+}
+
+class ContentOverviewQueryPolicy {
+    fun resolveType(type: String?): ContentOverviewType {
+        return ContentOverviewType.from(type)
+    }
+
+    fun createPage(page: Int?, size: Int?): ContentOverviewPage {
+        val resolvedPage = (page ?: DEFAULT_PAGE).coerceAtLeast(DEFAULT_PAGE)
+        val requestedSize = size ?: DEFAULT_SIZE
+        val resolvedSize = if (requestedSize < 1) DEFAULT_SIZE else minOf(requestedSize, MAX_SIZE)
+        return ContentOverviewPage(page = resolvedPage, size = resolvedSize)
+    }
+
+    fun <T> pageItems(items: List<T>, page: ContentOverviewPage): List<T> {
+        return items.take(page.size)
+    }
+
+    fun <T> hasNext(items: List<T>, page: ContentOverviewPage): Boolean {
+        return items.size > page.size
+    }
+
+    companion object {
+        const val DEFAULT_PAGE = 0
+        const val DEFAULT_SIZE = 20
+        const val MAX_SIZE = 50
+    }
+}
+```
+
+---
+
+## 3. 테스트 helper 기준
+
+아래 helper는 각 테스트 파일에서 필요한 범위만 복사해 사용한다. Kotlin 1.6.21을 사용하므로 enum 변환 구현에는 `entries`가 아니라 `values()`를 사용한다.
+
+```kotlin
+private fun member(id: Long): Member {
+    return Member(
+        email = "viewer$id@test.com",
+        password = "password",
+        nickname = "viewer$id",
+        role = MemberRole.USER
+    ).apply {
+        this.id = id
+    }
+}
+
+private fun audioCard(id: Long): AudioCard {
+    return AudioCard(
+        audioContentId = id,
+        title = "audio$id",
+        duration = "00:01",
+        imageUrl = "https://cdn.test/audio$id.png",
+        price = id.toInt(),
+        isAdult = false,
+        isPointAvailable = true,
+        isFirstContent = true,
+        isOriginalSeries = false,
+        creatorNickname = "creator$id"
+    )
+}
+
+private fun firstAudio(id: Long): HomeFirstAudioContentRecord {
+    return HomeFirstAudioContentRecord(
+        contentId = id,
+        creatorId = id + 100,
+        creatorNickname = "creator$id",
+        creatorProfileImage = null,
+        title = "first audio$id",
+        price = id.toInt(),
+        coverImage = "cover/audio$id.png",
+        isPointAvailable = true,
+        isAdult = false,
+        isOriginalSeries = false
+    )
+}
+
+private fun snapshot(
+    sectionType: RecommendedSectionType,
+    targetId: Long,
+    score: Double = 100.0 - targetId,
+    snapshotAt: LocalDateTime = LocalDateTime.of(2026, 6, 26, 23, 59, 59)
+): RecommendationSnapshotRecord {
+    return RecommendationSnapshotRecord(
+        sectionType = sectionType,
+        targetId = targetId,
+        score = score,
+        snapshotAt = snapshotAt,
+        randomTieBreaker = targetId.toDouble() / 1000
+    )
+}
+
+private fun anyLocalDateTime(): LocalDateTime {
+    return Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.of(2026, 6, 27, 0, 0)
+}
+
+private fun emptyResponse(type: ContentOverviewType): ContentOverviewPageResponse {
+    return ContentOverviewPageResponse(
+        type = type,
+        items = emptyList(),
+        page = 0,
+        size = 20,
+        hasNext = false
+    )
+}
+```
+
+---
+
+### Phase 1: 콘텐츠 전체보기 응답/요청 정책 작성
+
+- [x] **Task 1.1: ContentOverview DTO 직렬화 테스트 작성**
+  - Files:
+    - Create: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/dto/ContentOverviewPageResponseTest.kt`
+    - Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/dto/ContentOverviewPageResponse.kt`
+  - RED: `ContentOverviewPageResponse`와 `ContentOverviewItemResponse`의 `JsonProperty` 필드명을 검증하는 실패 테스트를 작성한다.
+  - 테스트 코드 기준:
+    ```kotlin
+    class ContentOverviewPageResponseTest {
+        private val objectMapper = jacksonObjectMapper()
+
+        @Test
+        fun shouldSerializeContentOverviewPageResponse() {
+            val response = ContentOverviewPageResponse(
+                type = ContentOverviewType.NEW_AND_HOT_AUDIO,
+                items = listOf(
+                    ContentOverviewItemResponse(
+                        contentId = 1L,
+                        title = "audio",
+                        coverImage = "https://cdn.test/audio.png",
+                        price = 10,
+                        isPointAvailable = true,
+                        creatorNickname = "creator",
+                        isAdult = false,
+                        isFirstContent = true,
+                        isOriginalSeries = false
+                    )
+                ),
+                page = 0,
+                size = 20,
+                hasNext = true
+            )
+
+            val json = objectMapper.readTree(objectMapper.writeValueAsString(response))
+
+            assertEquals("NEW_AND_HOT_AUDIO", json["type"].asText())
+            assertEquals(true, json["hasNext"].asBoolean())
+            assertEquals(1L, json["items"][0]["contentId"].asLong())
+            assertEquals("https://cdn.test/audio.png", json["items"][0]["coverImage"].asText())
+            assertEquals(true, json["items"][0]["isPointAvailable"].asBoolean())
+            assertEquals(false, json["items"][0]["isAdult"].asBoolean())
+            assertEquals(true, json["items"][0]["isFirstContent"].asBoolean())
+            assertEquals(false, json["items"][0]["isOriginalSeries"].asBoolean())
+            assertEquals(false, json["items"][0].has("audioContentId"))
+            assertEquals(false, json["items"][0].has("imageUrl"))
+            assertEquals(false, json["items"][0].has("duration"))
+            assertEquals(false, json["items"][0].has("creatorId"))
+            assertEquals(false, json["items"][0].has("creatorProfileImage"))
+            assertEquals(false, json["items"][0].has("pointAvailable"))
+            assertEquals(false, json["items"][0].has("adult"))
+            assertEquals(false, json["items"][0].has("firstContent"))
+            assertEquals(false, json["items"][0].has("originalSeries"))
+        }
+    }
+    ```
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewPageResponseTest`
+  - 기대 결과: DTO 파일이 없어서 `compileTestKotlin` 실패.
+  - GREEN: 위 DTO 초안을 추가하고 테스트를 통과시킨다.
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewPageResponseTest`
+  - REFACTOR: import 정리 후 같은 테스트를 재실행한다.
+  - 검증 기록:
+    - RED: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewPageResponseTest` 실행 시 `ContentOverviewPageResponse`, `ContentOverviewType`, `ContentOverviewItemResponse` 미구현으로 `compileTestKotlin` 실패.
+    - GREEN: DTO 구현 후 같은 명령 재실행, `BUILD SUCCESSFUL`.
+    - REVIEW 보완: `fromFirstAudioContent(...)`가 성인/오리지널 플래그를 전달하는 테스트를 추가했다. 보완 RED는 `isAdult`, `isOriginalSeries` 파라미터 미존재로 `compileTestKotlin` 실패했고, 시그니처 보강 후 같은 DTO 테스트가 `BUILD SUCCESSFUL`.
+
+- [x] **Task 1.2: ContentOverviewQueryPolicy 테스트와 구현 작성**
+  - Files:
+    - Create: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewQueryPolicyTest.kt`
+    - Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewQueryPolicy.kt`
+  - RED: type/page/size 보정 정책 실패 테스트를 작성한다.
+  - 테스트 코드 기준:
+    ```kotlin
+    class ContentOverviewQueryPolicyTest {
+        private val policy = ContentOverviewQueryPolicy()
+
+        @Test
+        fun shouldResolveTypeWithDefaultFallback() {
+            assertEquals(ContentOverviewType.NEW_AND_HOT_AUDIO, policy.resolveType(null))
+            assertEquals(ContentOverviewType.NEW_AND_HOT_AUDIO, policy.resolveType("UNKNOWN"))
+            assertEquals(ContentOverviewType.FIRST_AUDIO_CONTENT, policy.resolveType("FIRST_AUDIO_CONTENT"))
+        }
+
+        @Test
+        fun shouldNormalizePageAndSize() {
+            assertEquals(ContentOverviewPage(page = 0, size = 20), policy.createPage(null, null))
+            assertEquals(ContentOverviewPage(page = 0, size = 20), policy.createPage(-1, 0))
+            assertEquals(ContentOverviewPage(page = 2, size = 50), policy.createPage(2, 100))
+        }
+
+        @Test
+        fun shouldCalculatePageItemsAndHasNext() {
+            val page = ContentOverviewPage(page = 0, size = 2)
+            val items = listOf(1, 2, 3)
+
+            assertEquals(listOf(1, 2), policy.pageItems(items, page))
+            assertEquals(true, policy.hasNext(items, page))
+        }
+    }
+    ```
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewQueryPolicyTest`
+  - 기대 결과: policy 파일이 없어서 `compileTestKotlin` 실패.
+  - GREEN: 위 policy 초안을 추가하고 테스트를 통과시킨다.
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewQueryPolicyTest`
+  - REFACTOR: `ContentOverviewType.from(...)`와 page 보정 로직이 DTO/Facade에 중복되지 않게 유지하고 같은 테스트를 재실행한다.
+  - 검증 기록:
+    - RED: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewQueryPolicyTest` 실행 시 `ContentOverviewQueryPolicy`, `ContentOverviewPage` 미구현으로 `compileTestKotlin` 실패.
+    - GREEN: policy 구현 후 같은 명령 재실행, `BUILD SUCCESSFUL`.
+    - REVIEW 보완: `size = 19`가 기본 size `20`으로 보정되는 테스트를 추가하고, `MIN_SIZE = 20` 정책을 반영했다. 보완 후 같은 policy 테스트가 `BUILD SUCCESSFUL`.
+    - REVIEW 보완: 큰 `page` 입력에서 `offset`이 Int overflow 되지 않도록 `offset: Long = page.toLong() * size`로 변경했다. 보완 RED는 `Int.MAX_VALUE, size = 50` offset assertion 실패였고, 수정 후 같은 policy 테스트가 `BUILD SUCCESSFUL`.
+    - REVIEW 보완: 후속 Phase에서 `ContentOverviewPage.offset`을 그대로 넘길 수 있도록 `RecommendationSnapshotPort`, `HomeRecommendationQueryPort`, 관련 service/adapter/repository offset 계약과 문서 예시를 `Long`으로 정렬했다.
+    - Phase 1 묶음: `./gradlew test --tests 'kr.co.vividnext.sodalive.v2.api.content.overview.*'` 실행, `BUILD SUCCESSFUL`.
+    - Lint: `./gradlew ktlintCheck` 실행, `BUILD SUCCESSFUL`.
+    - 참고: `./gradlew test` 전체 실행은 다수 테스트의 XML 결과 파일 write 실패로 중단되어 Phase 1 로직 실패로 보지 않는다.
+
+---
+
+### Phase 2: New & Hot 스냅샷 저장 수와 페이징 조회 분리
+
+- [x] **Task 2.1: New & Hot 스냅샷 저장 limit 100 테스트 작성**
+  - Files:
+    - Modify: `src/test/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationSnapshotRefreshServiceTest.kt`
+    - Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationSnapshotRefreshService.kt`
+  - RED: `refreshDailySnapshots(now)`가 New & Hot 후보 조회 시 `limit = 100`을 전달하는 실패 테스트를 추가한다.
+  - 테스트 코드 기준:
+    ```kotlin
+    @Test
+    @DisplayName("New & Hot 스냅샷은 visibility별 100개 후보를 저장한다")
+    fun shouldRequestOneHundredNewAndHotSnapshotsPerVisibility() {
+        val snapshotPort = FakeRecommendationSnapshotPort()
+        val queryPort = Mockito.mock(AudioRecommendationQueryPort::class.java)
+        val service = AudioRecommendationSnapshotRefreshService(snapshotPort, queryPort)
+        val now = LocalDateTime.of(2026, 6, 27, 0, 0, 0)
+        val snapshotAt = LocalDateTime.of(2026, 6, 26, 23, 59, 59)
+        val windowStart = LocalDateTime.of(2026, 6, 24, 0, 0, 0)
+
+        service.refreshDailySnapshots(now)
+
+        Mockito.verify(queryPort).findNewAndHotSnapshots(windowStart, snapshotAt, AudioRecommendationVisibility.SAFE, 100)
+        Mockito.verify(queryPort).findNewAndHotSnapshots(windowStart, snapshotAt, AudioRecommendationVisibility.ALL, 100)
+    }
+    ```
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationSnapshotRefreshServiceTest`
+  - 기대 결과: 현재 구현이 `NEW_AND_HOT_LIMIT = 12`를 사용하므로 verify가 실패.
+  - GREEN: `AudioRecommendationSnapshotRefreshService`에서 `NEW_AND_HOT_SNAPSHOT_LIMIT = 100`을 추가하고 New & Hot 저장 조회에 사용한다.
+  - 구현 기준:
+    ```kotlin
+    companion object {
+        const val NEW_AND_HOT_SNAPSHOT_LIMIT = 100
+        const val MOST_COMMENTED_LIMIT = 5
+        const val RECOMMENDED_AUDIO_LIMIT = 10
+        private val KST_ZONE: ZoneId = ZoneId.of("Asia/Seoul")
+    }
+    ```
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationSnapshotRefreshServiceTest`
+  - REFACTOR: 기존 `NEW_AND_HOT_LIMIT` 이름이 남아 있으면 저장 limit 의미가 드러나는 `NEW_AND_HOT_SNAPSHOT_LIMIT`으로 정리하고 같은 테스트를 재실행한다.
+  - 검증 기록:
+    - RED: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationSnapshotRefreshServiceTest` 실행 시 `shouldRequestOneHundredNewAndHotSnapshotsPerVisibility`가 기존 `limit = 12` 호출과 기대 `100` 차이로 `ArgumentsAreDifferent` 실패.
+    - GREEN: `NEW_AND_HOT_SNAPSHOT_LIMIT = 100`으로 저장 조회 limit을 분리한 뒤 같은 명령 재실행, `BUILD SUCCESSFUL`.
+
+- [x] **Task 2.2: AudioRecommendationQueryService의 첫 화면 12개 조회 회귀 테스트 작성**
+  - Files:
+    - Modify: `src/test/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationQueryServiceTest.kt`
+    - Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationQueryService.kt`
+  - RED: `getRecommendations(member)`는 New & Hot 첫 화면 조회 시 여전히 12개만 요청하는 회귀 테스트를 추가한다.
+  - 테스트 코드 기준:
+    ```kotlin
+    @Test
+    @DisplayName("추천 탭 첫 화면은 New & Hot 스냅샷을 12개만 조회한다")
+    fun shouldKeepNewAndHotHomeLimitAtTwelve() {
+        val member = member(id = 10L)
+        Mockito.doReturn(true).`when`(memberContentPreferenceService).canViewAdultContent(member)
+        Mockito.doReturn(emptyList<RecommendationSnapshotRecord>()).`when`(snapshotPort)
+            .findLatestSnapshots(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, limit = 12)
+
+        queryService.getRecommendations(member)
+
+        Mockito.verify(snapshotPort).findLatestSnapshots(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, limit = 12)
+    }
+    ```
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryServiceTest`
+  - 기대 결과: 상수명을 아직 분리하지 않았거나 test helper가 없으면 컴파일 또는 verify 실패.
+  - GREEN: `AudioRecommendationQueryService`에 `NEW_AND_HOT_HOME_LIMIT = 12`를 추가하고 첫 화면 조회와 lazy refresh 재조회에 사용한다.
+  - 구현 기준:
+    ```kotlin
+    companion object {
+        const val NEW_AND_HOT_HOME_LIMIT = 12
+        // 기존 NEW_AND_HOT_AUDIO_LIMIT 사용처는 첫 화면 의미이면 NEW_AND_HOT_HOME_LIMIT로 교체한다.
+    }
+    ```
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryServiceTest`
+  - REFACTOR: 첫 화면 limit과 스냅샷 저장 limit 이름이 섞이지 않게 import/상수명을 정리하고 같은 테스트를 재실행한다.
+  - 검증 기록:
+    - RED: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryServiceTest` 실행 시 `NEW_AND_HOT_HOME_LIMIT` 미구현으로 `compileTestKotlin` 실패.
+    - GREEN: `NEW_AND_HOT_HOME_LIMIT = 12`를 추가하고 홈 첫 화면 조회와 lazy refresh 재조회에서 사용하도록 정리한 뒤 같은 명령 재실행, `BUILD SUCCESSFUL`.
+
+- [x] **Task 2.3: New & Hot 전체보기 페이징 조회 테스트 작성**
+  - Files:
+    - Modify: `src/test/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationQueryServiceTest.kt`
+    - Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationQueryService.kt`
+  - RED: `findNewAndHotAudios(member, offset, limit)`가 visibility, offset, limit을 반영하고 상세 조회 순서를 유지하는 실패 테스트를 작성한다.
+  - 테스트 코드 기준:
+    ```kotlin
+    @Test
+    @DisplayName("New & Hot 전체보기는 스냅샷 offset과 limit으로 오디오 카드를 조회한다")
+    fun shouldFindNewAndHotAudiosWithOffsetAndLimit() {
+        val member = member(id = 10L)
+        val nowSnapshots = listOf(
+            snapshot(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, targetId = 3L),
+            snapshot(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, targetId = 4L),
+            snapshot(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, targetId = 5L)
+        )
+        Mockito.doReturn(true).`when`(memberContentPreferenceService).canViewAdultContent(member)
+        Mockito.doReturn(nowSnapshots).`when`(snapshotPort)
+            .findLatestSnapshots(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, offset = 20L, limit = 21)
+        Mockito.doReturn(listOf(audioCard(3L), audioCard(4L), audioCard(5L))).`when`(queryPort)
+            .findAudioCardsByIds(listOf(3L, 4L, 5L), member.id, true, anyLocalDateTime())
+
+        val result = queryService.findNewAndHotAudios(member, offset = 20L, limit = 21)
+
+        assertEquals(listOf(3L, 4L, 5L), result.map { it.audioContentId })
+        Mockito.verify(snapshotPort).findLatestSnapshots(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, offset = 20L, limit = 21)
+    }
+    ```
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryServiceTest`
+  - 기대 결과: `findNewAndHotAudios` 메서드가 없어 `compileTestKotlin` 실패.
+  - GREEN: `AudioRecommendationQueryService.findNewAndHotAudios(member, offset, limit)`를 추가한다.
+  - 구현 기준:
+    ```kotlin
+    fun findNewAndHotAudios(member: Member, offset: Long, limit: Int): List<AudioCard> {
+        val now = LocalDateTime.now()
+        val canViewAdultContent = canViewAdultContent(member)
+        val visibility = if (canViewAdultContent) AudioRecommendationVisibility.ALL else AudioRecommendationVisibility.SAFE
+        val sectionType = newAndHotSectionType(visibility)
+        val snapshots = findNewAndHotSnapshotsWithLazyRefresh(sectionType, offset, limit)
+
+        return queryPort.findAudioCardsByIds(
+            snapshots.map { it.targetId },
+            member.id,
+            canViewAdultContent,
+            now
+        )
+    }
+    ```
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryServiceTest`
+  - REFACTOR: 기존 `refreshMissingNewAndHotSnapshots(...)`는 첫 화면과 전체보기에서 공통 사용 가능한 private 함수로 정리하고 같은 테스트를 재실행한다.
+  - 검증 기록:
+    - RED: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryServiceTest` 실행 시 `findNewAndHotAudios` 미구현으로 `compileTestKotlin` 실패.
+    - GREEN: `findNewAndHotAudios(member, offset, limit)`를 추가하고 기존 lazy refresh 재조회가 동일 `offset`, `limit`을 사용하도록 보강한 뒤 같은 명령 재실행, `BUILD SUCCESSFUL`.
+
+---
+
+### Phase 3: 콘텐츠 전체보기 API 조립 계층 작성
+
+- [x] **Task 3.1: ContentOverviewFacade 테스트 작성**
+  - Files:
+    - Create: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewFacadeTest.kt`
+    - Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewFacade.kt`
+    - Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/port/out/HomeRecommendationQueryPort.kt`
+    - Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/adapter/out/persistence/DefaultHomeRecommendationQueryRepository.kt`
+  - RED: `NEW_AND_HOT_AUDIO`와 `FIRST_AUDIO_CONTENT`를 각각 조회해 `ContentOverviewPageResponse`로 변환하는 실패 테스트를 작성한다.
+  - 테스트 코드 기준:
+    ```kotlin
+    class ContentOverviewFacadeTest {
+        private val audioRecommendationQueryService = Mockito.mock(AudioRecommendationQueryService::class.java)
+        private val homeRecommendationQueryService = Mockito.mock(HomeRecommendationQueryService::class.java)
+        private val memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java)
+        private val facade = ContentOverviewFacade(
+            audioRecommendationQueryService = audioRecommendationQueryService,
+            homeRecommendationQueryService = homeRecommendationQueryService,
+            memberContentPreferenceService = memberContentPreferenceService,
+            cloudFrontHost = "https://cdn.test",
+            queryPolicy = ContentOverviewQueryPolicy()
+        )
+
+        @Test
+        fun shouldReturnNewAndHotPage() {
+            val member = member(id = 10L)
+            Mockito.doReturn(listOf(audioCard(1L), audioCard(2L), audioCard(3L))).`when`(audioRecommendationQueryService)
+                .findNewAndHotAudios(member, offset = 0L, limit = 3)
+
+            val response = facade.getContents("NEW_AND_HOT_AUDIO", page = 0, size = 2, member = member)
+
+            assertEquals(ContentOverviewType.NEW_AND_HOT_AUDIO, response.type)
+            assertEquals(listOf(1L, 2L), response.items.map { it.contentId })
+            assertEquals(listOf("https://cdn.test/audio1.png", "https://cdn.test/audio2.png"), response.items.map { it.coverImage })
+            assertEquals(true, response.hasNext)
+        }
+
+        @Test
+        fun shouldReturnFirstAudioContentPage() {
+            val member = member(id = 10L)
+            Mockito.doReturn(true).`when`(memberContentPreferenceService).canViewAdultContent(member)
+            Mockito.doReturn(listOf(firstAudio(1L), firstAudio(2L))).`when`(homeRecommendationQueryService)
+                .findFirstAudioContents(anyLocalDateTime(), offset = 20L, limit = 21, memberId = member.id, includeAdultContents = true)
+
+            val response = facade.getContents("FIRST_AUDIO_CONTENT", page = 1, size = 20, member = member)
+
+            assertEquals(ContentOverviewType.FIRST_AUDIO_CONTENT, response.type)
+            assertEquals(listOf(1L, 2L), response.items.map { it.contentId })
+            assertEquals("https://cdn.test/cover/audio1.png", response.items[0].coverImage)
+            assertEquals(true, response.items[0].isFirstContent)
+        }
+    }
+    ```
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewFacadeTest`
+  - 기대 결과: Facade 파일이 없어 `compileTestKotlin` 실패.
+  - GREEN: `ContentOverviewFacade`를 추가하고 `size + 1` 조회, item `take(size)`, `hasNext` 계산을 구현한다.
+  - GREEN: `HomeFirstAudioContentRecord`에 `isAdult: Boolean`, `isOriginalSeries: Boolean` 필드를 추가하고, `DefaultHomeRecommendationQueryRepository.findFirstAudioContents(...)`가 해당 값을 조회해 채우도록 보강한다.
+  - 구현 기준:
+    ```kotlin
+    fun getContents(type: String?, page: Int?, size: Int?, member: Member): ContentOverviewPageResponse {
+        val resolvedType = queryPolicy.resolveType(type)
+        val resolvedPage = queryPolicy.createPage(page, size)
+
+        return when (resolvedType) {
+            ContentOverviewType.NEW_AND_HOT_AUDIO -> getNewAndHotContents(member, resolvedPage)
+            ContentOverviewType.FIRST_AUDIO_CONTENT -> getFirstAudioContents(member, resolvedPage)
+        }
+    }
+    ```
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewFacadeTest`
+  - REFACTOR: `coverImage` CDN URL 변환은 `String?.toCdnUrl(cloudFrontHost)`를 사용하고, 타입별 전용 필드 없이 `ContentOverviewItemResponse`의 동일 필드만 채우는지 확인한 뒤 같은 테스트를 재실행한다.
+  - 검증 기록:
+    - RED: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewFacadeTest` 실행 시 `ContentOverviewFacade` 미구현 및 `HomeFirstAudioContentRecord`의 `isAdult`, `isOriginalSeries` 필드 미구현으로 `compileTestKotlin` 실패.
+    - GREEN: `ContentOverviewFacade` 추가, `HomeFirstAudioContentRecord` 플래그 확장, `DefaultHomeRecommendationQueryRepository.findFirstAudioContents(...)` 플래그 조회 보강 후 같은 명령 재실행, `BUILD SUCCESSFUL`.
+    - REFACTOR: Kotlin Mockito matcher 보정과 Phase 1의 `MIN_SIZE = 20` 정책에 맞춰 테스트 기대값을 정렬했고, `String?.toCdnUrl(cloudFrontHost)`로 coverImage CDN 변환을 유지했다.
+    - REVIEW 보완: `findFirstAudioContents(...)` native SQL의 오리지널 시리즈 subquery가 실제 `SeriesContent`/`Series` 테이블(`series_content`, `series`)과 FK(`series_id`)를 참조하는지 검증하는 repository 테스트를 추가했다. 보완 RED는 존재하지 않는 `content_series_content` 테이블 참조로 `SQLGrammarException` 실패였고, 테이블/FK명을 실제 스키마에 맞춘 뒤 `DefaultHomeRecommendationQueryRepositoryTest`가 `BUILD SUCCESSFUL`.
+
+- [x] **Task 3.2: ContentOverviewController 인증/파라미터 테스트 작성**
+  - Files:
+    - Create: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewControllerTest.kt`
+    - Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewController.kt`
+  - RED: 비회원 요청은 401, 인증 회원 요청은 facade에 type/page/size/member를 전달하는 실패 테스트를 작성한다.
+  - 테스트 코드 기준:
+    ```kotlin
+    @WebMvcTest(ContentOverviewController::class)
+    @Import(SecurityConfig::class)
+    class ContentOverviewControllerTest @Autowired constructor(
+        private val mockMvc: MockMvc
+    ) {
+        @MockBean
+        private lateinit var facade: ContentOverviewFacade
+
+        @Test
+        fun shouldRejectAnonymousRequest() {
+            mockMvc.perform(get("/api/v2/contents"))
+                .andExpect(status().isUnauthorized)
+        }
+
+        @Test
+        fun shouldPassAuthenticatedMemberAndQueryParameters() {
+            val member = member(id = 10L)
+            Mockito.doReturn(emptyResponse(ContentOverviewType.FIRST_AUDIO_CONTENT)).`when`(facade)
+                .getContents("FIRST_AUDIO_CONTENT", 1, 30, member)
+
+            mockMvc.perform(
+                get("/api/v2/contents")
+                    .param("type", "FIRST_AUDIO_CONTENT")
+                    .param("page", "1")
+                    .param("size", "30")
+                    .with(user(MemberAdapter(member)))
+            )
+                .andExpect(status().isOk)
+                .andExpect(jsonPath("$.success").value(true))
+                .andExpect(jsonPath("$.data.type").value("FIRST_AUDIO_CONTENT"))
+
+            Mockito.verify(facade).getContents("FIRST_AUDIO_CONTENT", 1, 30, member)
+        }
+    }
+    ```
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.adapter.in.web.ContentOverviewControllerTest`
+  - 기대 결과: Controller 파일이 없어 `compileTestKotlin` 실패.
+  - GREEN: `ContentOverviewController`를 추가한다.
+  - 구현 기준:
+    ```kotlin
+    @RestController
+    @RequestMapping("/api/v2/contents")
+    class ContentOverviewController(
+        private val facade: ContentOverviewFacade
+    ) {
+        @GetMapping
+        fun getContents(
+            @RequestParam(required = false) type: String?,
+            @RequestParam(required = false) page: Int?,
+            @RequestParam(required = false) size: Int?,
+            @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+        ) = run {
+            ApiResponse.ok(facade.getContents(type, page, size, requireMember(member)))
+        }
+
+        private fun requireMember(member: Member?): Member {
+            return member ?: throw SodaException(messageKey = "common.error.bad_credentials")
+        }
+    }
+    ```
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.adapter.in.web.ContentOverviewControllerTest`
+  - REFACTOR: `SecurityConfig`에 `/api/v2/contents` permitAll을 추가하지 않았는지 확인하고 같은 테스트를 재실행한다.
+  - 검증 기록:
+    - RED: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.adapter.in.web.ContentOverviewControllerTest` 실행 시 `ContentOverviewController` 미구현으로 `compileTestKotlin` 실패.
+    - GREEN: `ContentOverviewController` 추가 후 인증 회원 query parameter 전달 테스트 통과. 비회원 401 검증은 slice test에서 실제 `JwtAuthenticationEntryPoint`, `JwtAccessDeniedHandler`를 import하고 `.with(anonymous())`를 명시하도록 보정한 뒤 같은 명령 재실행, `BUILD SUCCESSFUL`.
+    - REFACTOR: `SecurityConfig`에 `/api/v2/contents` `permitAll`을 추가하지 않았음을 확인했다. `/api/v2/contents`는 기존 `anyRequest().authenticated()` 정책으로 인증 필수다.
+    - Phase 3 묶음: `./gradlew test --tests 'kr.co.vividnext.sodalive.v2.api.content.overview.*'` 실행, `BUILD SUCCESSFUL`.
+    - 회귀: `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.application.HomeRecommendationQueryServiceTest` 실행, `BUILD SUCCESSFUL`.
+    - 회귀: `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest` 실행, `BUILD SUCCESSFUL`.
+    - Lint: `./gradlew ktlintCheck` 실행, `BUILD SUCCESSFUL`.
+    - 코드 리뷰: `ContentOverviewFacade`, `ContentOverviewController`, `HomeFirstAudioContentRecord` 확장, `DefaultHomeRecommendationQueryRepository.findFirstAudioContents(...)` 변경을 Phase 3 요구사항과 대조했고 차단 이슈는 발견하지 않았다.
+    - 리뷰 검증: `git diff --check` 실행, 공백 오류 없음.
+    - 리뷰 검증: `./gradlew test --tests 'kr.co.vividnext.sodalive.v2.api.content.overview.*'` 재실행, `BUILD SUCCESSFUL`.
+    - 리뷰 회귀: `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.application.HomeRecommendationQueryServiceTest` 재실행, `BUILD SUCCESSFUL`.
+    - 리뷰 회귀: `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.DefaultHomeRecommendationQueryRepositoryTest` 재실행, `BUILD SUCCESSFUL`.
+    - 리뷰 wiring: `./gradlew test --tests kr.co.vividnext.sodalive.support.SpringBootIntegrationSampleTest` 실행, `BUILD SUCCESSFUL`.
+    - 리뷰 Lint: `./gradlew ktlintCheck` 재실행, `BUILD SUCCESSFUL`. 최초 sandbox 실행은 Gradle wrapper lock 파일 접근 권한 문제로 중단되어 sandbox 밖에서 재실행했다.
+
+---
+
+### Phase 4: 미배포 홈 하위 전체보기 endpoint 제거
+
+- [x] **Task 4.1: 홈 하위 first-audio-contents 제거 테스트 갱신**
+  - Files:
+    - Modify: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/home/HomeRecommendationControllerTest.kt`
+    - Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/home/adapter/in/web/HomeRecommendationController.kt`
+    - Modify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/home/application/HomeRecommendationFacade.kt`
+  - RED: `/api/v2/home/recommendations/first-audio-contents`가 더 이상 성공 endpoint가 아님을 확인하는 테스트로 갱신한다.
+  - 테스트 코드 기준:
+    ```kotlin
+    @Test
+    @DisplayName("미배포 first-audio-contents 홈 하위 endpoint는 제거된다")
+    fun shouldNotExposeDeprecatedFirstAudioContentsEndpoint() {
+        val member = saveMember("home-viewer", MemberRole.USER)
+        entityManager.flush()
+        entityManager.clear()
+
+        mockMvc.perform(
+            get("/api/v2/home/recommendations/first-audio-contents")
+                .with(user(MemberAdapter(member)))
+        )
+            .andExpect(status().isNotFound)
+    }
+    ```
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest`
+  - 기대 결과: 기존 endpoint가 남아 있으면 200 OK로 응답해 테스트 실패.
+  - GREEN: `HomeRecommendationController.getFirstAudioContents(...)`를 제거하고, `HomeRecommendationFacade.getFirstAudioContents(...)`와 관련 로그 section 처리만 제거한다.
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest`
+  - REFACTOR: `HomeRecommendationQueryService.findFirstAudioContents(...)`는 새 API에서 재사용하므로 제거하지 않았는지 확인하고 같은 테스트를 재실행한다.
+  - 검증 기록:
+    - RED: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest` 실행 시 `shouldNotExposeDeprecatedFirstAudioContentsEndpoint`가 기존 endpoint 200 응답으로 실패.
+    - GREEN: `HomeRecommendationController.getFirstAudioContents(...)`와 `HomeRecommendationFacade.getFirstAudioContents(...)` 제거 후 같은 명령 재실행, `BUILD SUCCESSFUL`.
+    - REFACTOR: `rg -n "findFirstAudioContents|firstAudioContents|HOME_FIRST_AUDIO_CONTENT_LIMIT" ...`로 홈 메인 `firstAudioContents`, `HOME_FIRST_AUDIO_CONTENT_LIMIT`, `HomeRecommendationQueryService.findFirstAudioContents(...)`, 새 `ContentOverviewFacade` 재사용 경로가 유지됨을 확인했다.
+
+- [x] **Task 4.2: 홈 전체보기 인증 경로 목록 회귀 테스트 정리**
+  - Files:
+    - Modify: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/home/HomeRecommendationControllerTest.kt`
+  - RED: 기존 테스트의 경로 목록에서 `/first-audio-contents`를 제거하고 `/lives`, `/debut-creators`, `/ai-characters`만 홈 하위 전체보기 endpoint로 검증하도록 갱신한다.
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest`
+  - 기대 결과: controller 제거와 테스트 기대값이 어긋나면 실패.
+  - GREEN: 홈 추천 controller 테스트에서 first-audio-contents 성공 응답, facade 실패 로그 검증, 경로 반복 목록을 모두 새 정책에 맞춰 정리한다.
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest`
+  - REFACTOR: 홈 추천 첫 화면의 `firstAudioContents` 필드와 `HOME_FIRST_AUDIO_CONTENT_LIMIT`는 유지되어야 하므로 삭제하지 않았는지 확인한다.
+  - 검증 기록:
+    - 테스트 정리: `HomeRecommendationControllerTest`의 성공 응답 반복 경로와 비회원 거부 반복 경로에서 `/first-audio-contents`를 제거하고, facade page failure 로그 검증에서 `FIRST_AUDIO_CONTENT` section 검증을 제거했다.
+    - 회귀: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewFacadeTest` 실행, `BUILD SUCCESSFUL`.
+    - 회귀: `./gradlew test --tests kr.co.vividnext.sodalive.v2.recommendation.application.HomeRecommendationQueryServiceTest` 실행, `BUILD SUCCESSFUL`.
+    - Lint: `./gradlew ktlintCheck` 실행, `BUILD SUCCESSFUL`.
+    - 코드 리뷰: `HomeRecommendationController`, `HomeRecommendationFacade`, `HomeRecommendationControllerTest` 변경을 Phase 4 요구사항과 대조했고 차단 이슈는 발견하지 않았다.
+    - 리뷰 확인: `rg -n "first-audio-contents|getFirstAudioContents|FIRST_AUDIO_CONTENT|findFirstAudioContents|HOME_FIRST_AUDIO_CONTENT_LIMIT|firstAudioContents" ...` 실행으로 제거 endpoint는 문서와 404 테스트에만 남고, 홈 메인 `firstAudioContents`와 새 콘텐츠 전체보기의 `findFirstAudioContents(...)` 재사용 경로가 유지됨을 확인했다.
+    - 리뷰 검증: `git diff --check` 실행, 공백 오류 없음.
+    - 리뷰 검증: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest` 재실행, `BUILD SUCCESSFUL`.
+    - 리뷰 회귀: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewFacadeTest --tests kr.co.vividnext.sodalive.v2.recommendation.application.HomeRecommendationQueryServiceTest` 실행, `BUILD SUCCESSFUL`.
+    - 리뷰 Lint: `./gradlew ktlintCheck` 재실행, `BUILD SUCCESSFUL`. 최초 sandbox 실행은 Gradle wrapper lock 파일 접근 권한 문제로 중단되어 sandbox 밖에서 재실행했다.
+
+---
+
+### Phase 5: End-to-End 검증
+
+- [x] **Task 5.1: 콘텐츠 전체보기 E2E 테스트 작성**
+  - Files:
+    - Create: `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewEndToEndTest.kt`
+  - RED: 인증 회원 기준 `NEW_AND_HOT_AUDIO`, `FIRST_AUDIO_CONTENT`가 `ApiResponse.ok`와 `items/page/size/hasNext`를 반환하는 E2E 실패 테스트를 작성한다.
+  - 테스트 범위:
+    - 비회원 `GET /api/v2/contents`는 401
+    - 인증 회원 `GET /api/v2/contents?type=NEW_AND_HOT_AUDIO`는 200, `data.type = NEW_AND_HOT_AUDIO`
+    - 인증 회원 `GET /api/v2/contents?type=FIRST_AUDIO_CONTENT`는 200, `data.type = FIRST_AUDIO_CONTENT`
+    - invalid type은 `NEW_AND_HOT_AUDIO`로 fallback
+  - 실패 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.adapter.in.web.ContentOverviewEndToEndTest`
+  - 기대 결과: API 구현 전에는 endpoint 미존재 또는 bean 미구성으로 실패.
+  - GREEN: Phase 1~4 구현을 통합해 E2E 테스트를 통과시킨다.
+  - 통과 확인 명령: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.adapter.in.web.ContentOverviewEndToEndTest`
+  - REFACTOR: 테스트 데이터가 다른 추천 테스트와 충돌하지 않도록 각 테스트에서 저장한 데이터만 사용하고, 같은 테스트를 재실행한다.
+  - 검증 기록:
+    - E2E 테스트 작성: `ContentOverviewEndToEndTest`를 추가해 비회원 401, 인증 회원 `NEW_AND_HOT_AUDIO` 200, 인증 회원 `FIRST_AUDIO_CONTENT` 200, invalid type의 `NEW_AND_HOT_AUDIO` fallback을 검증했다.
+    - GREEN: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.content.overview.adapter.in.web.ContentOverviewEndToEndTest` 실행, `BUILD SUCCESSFUL`.
+
+- [x] **Task 5.2: 전체 관련 테스트와 ktlint 검증**
+  - Files:
+    - Verify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/**`
+    - Verify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationQueryService.kt`
+    - Verify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationSnapshotRefreshService.kt`
+    - Verify: `src/main/kotlin/kr/co/vividnext/sodalive/v2/api/home/**`
+  - RED: 신규/수정 테스트를 한 번에 실행해 남은 컴파일 오류나 회귀를 확인한다.
+  - 실행 명령:
+    - `./gradlew test --tests 'kr.co.vividnext.sodalive.v2.api.content.overview.*'`
+    - `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryServiceTest --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationSnapshotRefreshServiceTest`
+    - `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest`
+  - 기대 결과: 모든 명령 `BUILD SUCCESSFUL`.
+  - GREEN: 실패가 있으면 해당 task 문서 체크박스를 되돌리고 RED/GREEN 단계로 돌아가 수정한다.
+  - REFACTOR: `./gradlew ktlintCheck`를 실행하고 `BUILD SUCCESSFUL`을 확인한다.
+  - 검증 기록:
+    - 관련 테스트 묶음: `./gradlew test --tests 'kr.co.vividnext.sodalive.v2.api.content.overview.*'` 실행, `BUILD SUCCESSFUL`.
+    - 회귀: `./gradlew test --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryServiceTest --tests kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationSnapshotRefreshServiceTest` 실행, `BUILD SUCCESSFUL`.
+    - 회귀: `./gradlew test --tests kr.co.vividnext.sodalive.v2.api.home.HomeRecommendationControllerTest` 실행, `BUILD SUCCESSFUL`.
+    - Lint: `./gradlew ktlintCheck` 실행, `BUILD SUCCESSFUL`.
+
+---
+
+## 검증 기록
+
+- 구현 전 문서 생성 단계에서는 코드 변경이 없으므로 단위 테스트를 실행하지 않는다.
+- 문서 변경 후 명령 유효성은 `./gradlew tasks --all`로 확인한다.
+- 구현 중 각 task 완료 즉시 해당 task 아래에 실행 명령, 결과, 실패 원인과 수정 내용을 한국어로 누적 기록한다.
+- Phase 3 코드 리뷰 및 검증 기록 추가 후 `git diff --check` 실행, 공백 오류 없음.
+- Phase 3 코드 리뷰 및 검증 기록 추가 후 `./gradlew tasks --all` 실행, `BUILD SUCCESSFUL`. 최초 sandbox 실행은 Gradle wrapper lock 파일 접근 권한 문제로 중단되어 sandbox 밖에서 재실행했다.
+
+---
+
+## Self-Review Checklist
+
+- PRD의 endpoint `GET /api/v2/contents`는 Phase 3과 Phase 5에서 구현/검증한다.
+- 비회원 조회 불가는 Phase 3 controller 테스트와 Phase 5 E2E 테스트에서 검증한다.
+- `NEW_AND_HOT_AUDIO` 스냅샷 저장 수 100개는 Phase 2에서 검증한다.
+- New & Hot 첫 화면 12개 유지 회귀는 Phase 2에서 검증한다.
+- `FIRST_AUDIO_CONTENT` 조회 재사용은 Phase 3 Facade 테스트와 Phase 5 E2E 테스트에서 검증한다.
+- 미배포 홈 하위 endpoint 제거는 Phase 4에서 검증한다.
+- 신규 DB 테이블이 없다는 제약은 파일 구조 계획과 Phase 5 검증 범위에 반영했다.

docs/20260627_콘텐츠_전체보기_API/prd.md

@@ -0,0 +1,242 @@
+# PRD: 콘텐츠 전체보기 API
+
+## 1. Overview
+콘텐츠 섹션에서 노출되는 오디오 목록의 전체보기 화면을 위해 `NEW_AND_HOT_AUDIO`, `FIRST_AUDIO_CONTENT` 두 타입을 페이징으로 조회하는 v2 API를 제공한다.
+
+---
+
+## 2. Problem
+- 기존 `GET /api/v2/audio/recommendations`는 추천 탭 첫 화면의 섹션별 기본 개수만 내려주며, New & Hot 섹션 전체보기/페이징 API가 없다.
+- 기존 `GET /api/v2/home/recommendations/first-audio-contents`는 아직 배포되지 않은 홈 추천 하위 개별 endpoint이며, 콘텐츠 전체보기 API가 추가되면 별도 유지할 이유가 없다.
+- `GET /api/v2/audio/recommendations/contents`는 추천 API 하위 리소스처럼 보이므로, 콘텐츠 전체보기 API라는 의미와 맞지 않는다.
+- `GET /api/v2/audio/contents`는 이미 메인 콘텐츠 전체 탭 API가 사용 중이므로, 새 섹션 전체보기 API 경로로 재사용하지 않는다.
+- 클라이언트는 전체보기 화면에서 동일한 페이징 응답 형태로 섹션 타입만 바꿔 조회할 수 있어야 한다.
+- V2 패키지에는 `AudioRecommendationQueryService`, `HomeRecommendationQueryService`, `AudioCardResponse`, `HomeFirstAudioContentItem`, `HomeRecommendationPageResponse` 등 재사용 가능한 조회/응답 패턴이 있으므로, 새 API는 기존 패턴을 우선 재사용해야 한다.
+
+---
+
+## 3. Goals
+- 콘텐츠 전체보기 API를 `kr.co.vividnext.sodalive.v2` 하위 코드로 제공한다.
+- 기존 패턴과 동일하게 API 조립 계층과 도메인 조회 계층을 분리한다.
+- 조회 타입은 `NEW_AND_HOT_AUDIO`, `FIRST_AUDIO_CONTENT`를 지원한다.
+- `NEW_AND_HOT_AUDIO`는 `AudioRecommendationQueryService`의 New & Hot 스냅샷 조회 흐름을 재사용한다.
+- `FIRST_AUDIO_CONTENT`는 `HomeRecommendationQueryService.findFirstAudioContents` 조회 흐름을 재사용한다.
+- 하나의 endpoint에서 `type` query parameter로 두 타입을 분리한다.
+- 비회원 조회를 허용하지 않는다.
+- 인증 회원의 차단/성인 콘텐츠 노출 가능 여부 등 기존 사용자 조건을 반영한다.
+- 아직 배포되지 않은 `GET /api/v2/home/recommendations/first-audio-contents`는 제거한다.
+- PRD에 API endpoint와 Response data class 초안을 포함한다.
+
+---
+
+## 4. Non-Goals
+- 기존 `GET /api/v2/audio/recommendations` 공개 응답 스키마를 변경하지 않는다.
+- 기존 `GET /api/v2/home/recommendations` 공개 응답 스키마를 변경하지 않는다.
+- 기존 `GET /api/v2/home/recommendations/first-audio-contents` endpoint는 배포 전 기능이므로 하위 호환 대상으로 보지 않는다.
+- New & Hot 점수 산식, 스냅샷 생성 주기, lazy refresh 정책을 변경하지 않는다.
+- 첫 번째 오디오 콘텐츠 판정 기준과 정렬 정책을 변경하지 않는다.
+- `RECENT_DEBUT_CREATOR`, `AI_CHARACTER` 등 다른 홈 추천 전체보기 타입은 이번 범위에 포함하지 않는다.
+- 새로운 DB 테이블, 배치 작업, 관리자 기능은 이번 범위에 포함하지 않는다.
+
+---
+
+## 5. Target Users
+- 회원: 콘텐츠 섹션의 전체보기에서 더 많은 오디오 콘텐츠를 탐색하는 사용자
+- 앱 클라이언트: 동일한 전체보기 화면에서 타입, page, size, hasNext를 기반으로 목록을 구성하려는 클라이언트
+
+---
+
+## 6. User Stories
+- 사용자는 New & Hot 섹션에서 첫 화면에 보이는 개수보다 더 많은 오디오를 보고 싶다.
+- 사용자는 처음부터 함께 성장 섹션의 첫 번째 오디오 콘텐츠를 전체보기로 더 탐색하고 싶다.
+- 앱 클라이언트는 전체보기 화면에서 `type`만 바꿔 동일한 페이징 응답을 처리하고 싶다.
+- 앱 클라이언트는 인증 회원 기준으로 서버가 기존 성인 콘텐츠/차단 정책을 반영한 결과를 받길 원한다.
+
+---
+
+## 7. Core Features
+
+### Feature A. 콘텐츠 전체보기 통합 조회 API
+
+#### Requirements
+- 신규 API endpoint는 `GET /api/v2/contents`로 정의한다.
+- 응답 wrapper는 기존 패턴과 동일하게 `ApiResponse.ok(...)`를 사용한다.
+- 비회원 조회를 허용하지 않는다.
+- Security 설정은 `GET /api/v2/contents`를 인증 필요 endpoint로 둔다.
+- 회원 조회 시 `@AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?` 패턴과 `requireMember(...)` 가드절을 사용한다.
+- 요청 query parameter는 `type`, `page`, `size`를 사용한다.
+- `type` 값은 아래 enum으로 정의한다.
+  - `NEW_AND_HOT_AUDIO`: 콘텐츠 추천 탭 New & Hot 오디오 전체보기
+  - `FIRST_AUDIO_CONTENT`: 메인 홈 처음부터 함께 성장 오디오 전체보기
+- `type`을 보내지 않으면 `NEW_AND_HOT_AUDIO`를 기본값으로 사용한다.
+- 지원하지 않는 `type` 값이 들어오면 400 오류 대신 `NEW_AND_HOT_AUDIO`로 fallback한다.
+- `page`는 0부터 시작하는 page index로 처리한다.
+- `page`를 보내지 않으면 기본값 `0`을 사용한다.
+- `size`를 보내지 않으면 기본값 `20`을 사용한다.
+- `page`가 0보다 작으면 `0`으로 fallback한다.
+- `size`가 1보다 작으면 기본값 `20`으로 fallback한다.
+- `size`가 50보다 크면 `50`으로 fallback한다.
+- 다음 page 존재 여부는 `size + 1`개 조회 또는 동등한 방식으로 판단하되, 응답 목록에는 최대 `size`개만 내려준다.
+
+#### Edge Cases
+- 조회 결과가 없으면 `items`는 빈 배열, `hasNext`는 `false`로 내려준다.
+- 요청한 page 범위에 콘텐츠가 없으면 `items`는 빈 배열, `hasNext`는 `false`로 내려준다.
+- 특정 타입 조회 중 필터링으로 스냅샷 대상 상세 데이터가 제거될 수 있으며, 이 경우 가능한 항목만 내려준다.
+
+### Feature B. NEW_AND_HOT_AUDIO 전체보기
+
+#### Requirements
+- `type=NEW_AND_HOT_AUDIO`는 `AudioRecommendationQueryService`의 New & Hot 조회 정책을 재사용한다.
+- 인증 회원의 성인 콘텐츠 노출 가능 여부에 따라 `AudioRecommendationVisibility.SAFE` 또는 `AudioRecommendationVisibility.ALL`을 결정한다.
+- `SAFE`는 `RecommendedSectionType.NEW_AND_HOT_AUDIO_SAFE`, `ALL`은 `RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL` 스냅샷을 조회한다.
+- New & Hot 첫 화면 노출 수는 기존과 동일하게 12개로 유지한다.
+- New & Hot 스냅샷 저장 수는 전체보기 페이징을 위해 visibility별 100개로 확장한다.
+- 스냅샷 저장 수 100개는 `SAFE`와 `ALL` 각각에 적용한다.
+- `RecommendationSnapshotPort.findLatestSnapshots(sectionType, offset, limit)`로 page offset과 `size + 1` limit을 적용한다.
+- 스냅샷이 없으면 기존 `AudioRecommendationQueryService`의 New & Hot lazy refresh 정책을 재사용한다.
+- 스냅샷 target id 목록을 `AudioRecommendationQueryPort.findAudioCardsByIds(...)`로 상세 조회한다.
+- 응답 item은 기존 `AudioCardResponse` 필드 의미를 유지한다.
+
+#### Edge Cases
+- lazy refresh 후에도 스냅샷이 없으면 빈 배열로 내려준다.
+- 스냅샷에는 있지만 비활성/예약 공개/차단/성인 콘텐츠 정책으로 상세 조회에서 제외된 항목은 응답하지 않는다.
+
+### Feature C. FIRST_AUDIO_CONTENT 전체보기
+
+#### Requirements
+- `type=FIRST_AUDIO_CONTENT`는 `HomeRecommendationQueryService.findFirstAudioContents(...)`를 재사용한다.
+- `offset = page * size`, `limit = size + 1`로 조회한다.
+- `member.id`와 `MemberContentPreferenceService.canViewAdultContent(member)` 결과를 전달한다.
+- 응답 item은 `NEW_AND_HOT_AUDIO`와 동일한 `ContentOverviewItemResponse` 필드를 모두 채운다.
+- 기존 `HomeFirstAudioContentRecord`에 공통 응답 구성을 위해 필요한 `isAdult`, `isOriginalSeries` 값을 보강한다.
+- `FIRST_AUDIO_CONTENT` 응답의 `isFirstContent`는 첫 번째 콘텐츠 섹션 특성상 `true`로 내려준다.
+
+#### Edge Cases
+- 첫 번째 오디오 콘텐츠 판정은 기존 홈 추천 PRD와 현재 `HomeRecommendationQueryService.findFirstAudioContents` 구현을 따른다.
+- 예약 공개 콘텐츠는 기존 조회 서비스 정책에 따라 공개 전에는 노출하지 않는다.
+
+### Feature D. 공통 콘텐츠 정책
+
+#### Requirements
+- 모든 타입은 공개 가능한 콘텐츠만 조회한다.
+- 회원이 차단했거나 회원을 차단한 크리에이터의 콘텐츠는 노출하지 않는다.
+- 인증 회원은 기존 콘텐츠 조회 설정에 따라 19금 콘텐츠 노출 가능 여부를 반영한다.
+- 이미지 경로와 기본 프로필 이미지는 기존 각 조회 서비스/Facade 변환 정책을 따른다.
+
+### Feature E. 미배포 홈 하위 전체보기 API 제거
+
+#### Requirements
+- `HomeRecommendationController`의 `GET /api/v2/home/recommendations/first-audio-contents` endpoint를 제거한다.
+- 해당 endpoint만을 위한 `HomeRecommendationFacade.getFirstAudioContents(...)` 조립 메서드는 새 콘텐츠 전체보기 Facade로 책임을 옮긴 뒤 제거한다.
+- 관련 Controller/Facade 테스트는 새 `GET /api/v2/contents?type=FIRST_AUDIO_CONTENT` 테스트로 대체한다.
+- `SecurityConfig`에 홈 하위 전체보기 endpoint를 위한 별도 설정이 있다면 제거하거나 더 이상 영향이 없게 정리한다.
+
+#### Edge Cases
+- `HomeRecommendationQueryService.findFirstAudioContents(...)`는 새 API에서 재사용하므로 제거하지 않는다.
+
+---
+
+## 8. API Endpoint
+
+```http
+GET /api/v2/contents?type=NEW_AND_HOT_AUDIO&page=0&size=20
+Authorization: Bearer {accessToken}
+```
+
+- 비회원 조회를 허용하지 않는다.
+- `SecurityConfig`에서 `GET /api/v2/contents`는 인증 필요 endpoint로 둔다.
+- `type` 미지정 또는 invalid 값은 `NEW_AND_HOT_AUDIO`로 fallback한다.
+- `FIRST_AUDIO_CONTENT` 조회 예시는 아래와 같다.
+
+```http
+GET /api/v2/contents?type=FIRST_AUDIO_CONTENT&page=0&size=20
+Authorization: Bearer {accessToken}
+```
+
+---
+
+## 9. Response Data Class
+
+```kotlin
+data class ContentOverviewPageResponse(
+    val type: ContentOverviewType,
+    val items: List<ContentOverviewItemResponse>,
+    val page: Int,
+    val size: Int,
+    @JsonProperty("hasNext")
+    val hasNext: Boolean
+)
+
+enum class ContentOverviewType {
+    NEW_AND_HOT_AUDIO,
+    FIRST_AUDIO_CONTENT
+}
+
+data class ContentOverviewItemResponse(
+    val contentId: Long,
+    val title: String,
+    val coverImage: String?,
+    val price: Int,
+    @JsonProperty("isPointAvailable")
+    val isPointAvailable: Boolean,
+    val creatorNickname: String,
+    @JsonProperty("isAdult")
+    val isAdult: Boolean,
+    @JsonProperty("isFirstContent")
+    val isFirstContent: Boolean,
+    @JsonProperty("isOriginalSeries")
+    val isOriginalSeries: Boolean
+)
+```
+
+- `NEW_AND_HOT_AUDIO`, `FIRST_AUDIO_CONTENT` 모두 동일한 item 필드를 채우며 타입별 nullable 전용 필드를 두지 않는다.
+- 기존 `audioContentId`, `imageUrl` 공개 필드명은 각각 `contentId`, `coverImage`로 사용한다.
+- `duration`, `creatorId`, `creatorProfileImage`는 콘텐츠 전체보기 응답에 포함하지 않는다.
+
+---
+
+## 10. Technical Constraints
+
+### 패키지 구조
+- 공개 API 조립 계층은 콘텐츠 전체보기 API 의미가 드러나도록 `kr.co.vividnext.sodalive.v2.api.content.overview` 하위에 둔다.
+  - Controller: `...adapter.in.web.ContentOverviewController`
+  - Facade: `...application.ContentOverviewFacade`
+  - Response DTO: `...dto.ContentOverviewPageResponse`
+- 도메인 조회 계층은 기존 서비스 재사용을 우선한다.
+  - New & Hot: `kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryService`
+  - 첫 번째 오디오 콘텐츠: `kr.co.vividnext.sodalive.v2.recommendation.application.HomeRecommendationQueryService`
+- 신규 도메인 모델/정책이 필요하면 `kr.co.vividnext.sodalive.v2.content.recommendation.domain`에 최소 범위로 추가한다.
+- 의존 방향은 `v2.api.content.overview -> v2.content.recommendation`, `v2.api.content.overview -> v2.recommendation`만 허용한다.
+
+### V2 공통화/재사용 대상
+- `AudioRecommendationQueryService.resolveVisibility(...)`
+- `AudioRecommendationQueryService.newAndHotSectionType(...)`
+- `RecommendationSnapshotPort.findLatestSnapshots(...)`
+- `AudioRecommendationQueryPort.findAudioCardsByIds(...)`
+- `HomeRecommendationQueryService.findFirstAudioContents(...)`
+- `AudioCardResponse`의 응답 필드 의미와 `JsonProperty` 네이밍 패턴
+- `HomeFirstAudioContentItem`의 응답 필드 의미와 이미지 URL 변환 패턴
+- `HomeRecommendationFacade`의 page/size 보정, `size + 1` 기반 `hasNext` 계산 패턴
+
+### 스냅샷 저장 정책
+- New & Hot은 첫 화면 조회 limit과 스냅샷 저장 limit을 분리한다.
+- 첫 화면 조회 limit은 `NEW_AND_HOT_HOME_LIMIT = 12`로 유지한다.
+- 스냅샷 저장 limit은 `NEW_AND_HOT_SNAPSHOT_LIMIT = 100`으로 정의한다.
+- `AudioRecommendationSnapshotRefreshService`는 `findNewAndHotSnapshots(..., limit = NEW_AND_HOT_SNAPSHOT_LIMIT)`로 `SAFE`, `ALL` 각각 최대 100개를 저장한다.
+- `AudioRecommendationQueryService.getRecommendations(...)`는 첫 화면 응답 조립 시 최신 스냅샷에서 12개만 조회한다.
+- 콘텐츠 전체보기 API는 저장된 100개 스냅샷 범위 안에서 `offset`, `size + 1`로 페이징한다.
+
+### 구현 판단
+- 별도 endpoint 2개보다 typed endpoint 1개를 기본안으로 한다.
+- 이유는 두 요구가 모두 “오디오 콘텐츠 목록 전체보기”이고, page/size/hasNext 응답 계약이 동일하며, `MainContentAllController`도 `type` 기반 단일 endpoint 패턴을 이미 사용하기 때문이다.
+- endpoint는 `GET /api/v2/contents`를 사용한다.
+- 이유는 `GET /api/v2/audio/recommendations/contents`가 추천 하위 리소스처럼 읽혀 콘텐츠 전체보기 API 의미와 맞지 않고, `GET /api/v2/audio/contents`는 이미 메인 콘텐츠 전체 탭 API가 사용 중이기 때문이다.
+- 기존 `GET /api/v2/home/recommendations/first-audio-contents`는 배포 전 endpoint이므로 제거하고, 새 API의 `type=FIRST_AUDIO_CONTENT`로 대체한다.
+
+---
+
+## 11. Decisions
+
+- `GET /api/v2/contents`는 인증 회원만 호출할 수 있다.
+- 기존 홈 하위 전체보기 endpoint는 배포 전 기능이므로 제거한다.
+- New & Hot 스냅샷은 전체보기 지원을 위해 visibility별 100개 저장한다.

src/main/kotlin/kr/co/vividnext/sodalive/admin/member/AdminMemberService.kt

@@ -16,6 +16,7 @@ import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 
 @Service
+@Transactional(readOnly = true)
 class AdminMemberService(
     private val repository: AdminMemberRepository,
     private val passwordEncoder: PasswordEncoder,

src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewController.kt

@@ -0,0 +1,31 @@
+package kr.co.vividnext.sodalive.v2.api.content.overview.adapter.`in`.web
+
+import kr.co.vividnext.sodalive.common.ApiResponse
+import kr.co.vividnext.sodalive.common.SodaException
+import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewFacade
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping("/api/v2/contents")
+class ContentOverviewController(
+    private val facade: ContentOverviewFacade
+) {
+    @GetMapping
+    fun getContents(
+        @RequestParam(required = false) type: String?,
+        @RequestParam(required = false) page: Int?,
+        @RequestParam(required = false) size: Int?,
+        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
+    ) = run {
+        ApiResponse.ok(facade.getContents(type, page, size, requireMember(member)))
+    }
+
+    private fun requireMember(member: Member?): Member {
+        return member ?: throw SodaException(messageKey = "common.error.bad_credentials")
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewFacade.kt

@@ -0,0 +1,72 @@
+package kr.co.vividnext.sodalive.v2.api.content.overview.application
+
+import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
+import kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewItemResponse
+import kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewPageResponse
+import kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewType
+import kr.co.vividnext.sodalive.v2.common.domain.toCdnUrl
+import kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryService
+import kr.co.vividnext.sodalive.v2.recommendation.application.HomeRecommendationQueryService
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.stereotype.Component
+import java.time.LocalDateTime
+
+@Component
+class ContentOverviewFacade(
+    private val audioRecommendationQueryService: AudioRecommendationQueryService,
+    private val homeRecommendationQueryService: HomeRecommendationQueryService,
+    private val memberContentPreferenceService: MemberContentPreferenceService,
+    @Value("\${cloud.aws.cloud-front.host}")
+    private val cloudFrontHost: String,
+    private val queryPolicy: ContentOverviewQueryPolicy = ContentOverviewQueryPolicy()
+) {
+    fun getContents(type: String?, page: Int?, size: Int?, member: Member): ContentOverviewPageResponse {
+        val resolvedType = queryPolicy.resolveType(type)
+        val resolvedPage = queryPolicy.createPage(page, size)
+
+        return when (resolvedType) {
+            ContentOverviewType.NEW_AND_HOT_AUDIO -> getNewAndHotContents(member, resolvedPage)
+            ContentOverviewType.FIRST_AUDIO_CONTENT -> getFirstAudioContents(member, resolvedPage)
+        }
+    }
+
+    private fun getNewAndHotContents(member: Member, page: ContentOverviewPage): ContentOverviewPageResponse {
+        val fetched = audioRecommendationQueryService.findNewAndHotAudios(
+            member = member,
+            offset = page.offset,
+            limit = page.size + 1
+        )
+        return ContentOverviewPageResponse(
+            type = ContentOverviewType.NEW_AND_HOT_AUDIO,
+            items = queryPolicy.pageItems(fetched, page).map { ContentOverviewItemResponse.fromNewAndHot(it) },
+            page = page.page,
+            size = page.size,
+            hasNext = queryPolicy.hasNext(fetched, page)
+        )
+    }
+
+    private fun getFirstAudioContents(member: Member, page: ContentOverviewPage): ContentOverviewPageResponse {
+        val fetched = homeRecommendationQueryService.findFirstAudioContents(
+            now = LocalDateTime.now(),
+            offset = page.offset,
+            limit = page.size + 1,
+            memberId = member.id,
+            includeAdultContents = memberContentPreferenceService.canViewAdultContent(member)
+        )
+        return ContentOverviewPageResponse(
+            type = ContentOverviewType.FIRST_AUDIO_CONTENT,
+            items = queryPolicy.pageItems(fetched, page).map {
+                ContentOverviewItemResponse.fromFirstAudioContent(
+                    audio = it,
+                    coverImage = it.coverImage.toCdnUrl(cloudFrontHost),
+                    isAdult = it.isAdult,
+                    isOriginalSeries = it.isOriginalSeries
+                )
+            },
+            page = page.page,
+            size = page.size,
+            hasNext = queryPolicy.hasNext(fetched, page)
+        )
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewQueryPolicy.kt

@@ -0,0 +1,38 @@
+package kr.co.vividnext.sodalive.v2.api.content.overview.application
+
+import kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewType
+
+data class ContentOverviewPage(
+    val page: Int,
+    val size: Int
+) {
+    val offset: Long = page.toLong() * size
+}
+
+class ContentOverviewQueryPolicy {
+    fun resolveType(type: String?): ContentOverviewType {
+        return ContentOverviewType.from(type)
+    }
+
+    fun createPage(page: Int?, size: Int?): ContentOverviewPage {
+        val resolvedPage = (page ?: DEFAULT_PAGE).coerceAtLeast(DEFAULT_PAGE)
+        val requestedSize = size ?: DEFAULT_SIZE
+        val resolvedSize = if (requestedSize < MIN_SIZE) DEFAULT_SIZE else minOf(requestedSize, MAX_SIZE)
+        return ContentOverviewPage(page = resolvedPage, size = resolvedSize)
+    }
+
+    fun <T> pageItems(items: List<T>, page: ContentOverviewPage): List<T> {
+        return items.take(page.size)
+    }
+
+    fun <T> hasNext(items: List<T>, page: ContentOverviewPage): Boolean {
+        return items.size > page.size
+    }
+
+    companion object {
+        const val DEFAULT_PAGE = 0
+        const val DEFAULT_SIZE = 20
+        const val MIN_SIZE = 20
+        const val MAX_SIZE = 50
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/dto/ContentOverviewPageResponse.kt

@@ -0,0 +1,76 @@
+package kr.co.vividnext.sodalive.v2.api.content.overview.dto
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import kr.co.vividnext.sodalive.v2.content.recommendation.domain.AudioCard
+import kr.co.vividnext.sodalive.v2.recommendation.port.out.HomeFirstAudioContentRecord
+
+data class ContentOverviewPageResponse(
+    val type: ContentOverviewType,
+    val items: List<ContentOverviewItemResponse>,
+    val page: Int,
+    val size: Int,
+    @JsonProperty("hasNext")
+    val hasNext: Boolean
+)
+
+enum class ContentOverviewType {
+    NEW_AND_HOT_AUDIO,
+    FIRST_AUDIO_CONTENT;
+
+    companion object {
+        fun from(value: String?): ContentOverviewType {
+            return values().firstOrNull { it.name == value } ?: NEW_AND_HOT_AUDIO
+        }
+    }
+}
+
+data class ContentOverviewItemResponse(
+    val contentId: Long,
+    val title: String,
+    val coverImage: String?,
+    val price: Int,
+    @JsonProperty("isPointAvailable")
+    val isPointAvailable: Boolean,
+    val creatorNickname: String,
+    @JsonProperty("isAdult")
+    val isAdult: Boolean,
+    @JsonProperty("isFirstContent")
+    val isFirstContent: Boolean,
+    @JsonProperty("isOriginalSeries")
+    val isOriginalSeries: Boolean
+) {
+    companion object {
+        fun fromNewAndHot(audio: AudioCard): ContentOverviewItemResponse {
+            return ContentOverviewItemResponse(
+                contentId = audio.audioContentId,
+                title = audio.title,
+                coverImage = audio.imageUrl,
+                price = audio.price,
+                isPointAvailable = audio.isPointAvailable,
+                creatorNickname = audio.creatorNickname,
+                isAdult = audio.isAdult,
+                isFirstContent = audio.isFirstContent,
+                isOriginalSeries = audio.isOriginalSeries
+            )
+        }
+
+        fun fromFirstAudioContent(
+            audio: HomeFirstAudioContentRecord,
+            coverImage: String?,
+            isAdult: Boolean,
+            isOriginalSeries: Boolean
+        ): ContentOverviewItemResponse {
+            return ContentOverviewItemResponse(
+                contentId = audio.contentId,
+                title = audio.title,
+                coverImage = coverImage,
+                price = audio.price,
+                isPointAvailable = audio.isPointAvailable,
+                creatorNickname = audio.creatorNickname,
+                isAdult = isAdult,
+                isFirstContent = true,
+                isOriginalSeries = isOriginalSeries
+            )
+        }
+    }
+}

src/main/kotlin/kr/co/vividnext/sodalive/v2/api/home/adapter/in/web/HomeRecommendationController.kt

@@ -57,21 +57,6 @@ class HomeRecommendationController(
         )
     }
 
-    @GetMapping("/first-audio-contents")
-    fun getFirstAudioContents(
-        @RequestParam(defaultValue = "0") page: Int,
-        @RequestParam(defaultValue = "$DEFAULT_PAGE_SIZE") size: Int,
-        @AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?
-    ) = run {
-        ApiResponse.ok(
-            homeRecommendationFacade.getFirstAudioContents(
-                requireMember(member),
-                normalizePage(page),
-                normalizeSize(size)
-            )
-        )
-    }
-
     @GetMapping("/ai-characters")
     fun getAiCharacters(
         @RequestParam(defaultValue = "0") page: Int,

src/main/kotlin/kr/co/vividnext/sodalive/v2/api/home/application/HomeRecommendationFacade.kt

@@ -143,24 +143,6 @@ class HomeRecommendationFacade(
         }.getOrThrow()
     }
 
-    fun getFirstAudioContents(member: Member, page: Int, size: Int): HomeRecommendationPageResponse<HomeFirstAudioContentItem> {
-        val startedAt = System.currentTimeMillis()
-        return runCatching {
-            val fetched = queryService.findFirstAudioContents(
-                now = LocalDateTime.now(),
-                offset = page.toOffset(size),
-                limit = size + 1,
-                memberId = member.id,
-                includeAdultContents = resolveAdultVisibility(member)
-            )
-            fetched.toPage(page, size) { it.toItem() }
-        }.onSuccess {
-            logPageSuccess("FIRST_AUDIO_CONTENT", member, page, size, it.items.size, System.currentTimeMillis() - startedAt)
-        }.onFailure { ex ->
-            logPageFailure("FIRST_AUDIO_CONTENT", member, page, size, startedAt, ex)
-        }.getOrThrow()
-    }
-
     fun getAiCharacters(member: Member, page: Int, size: Int): HomeRecommendationPageResponse<HomeAiCharacterItem> {
         val startedAt = System.currentTimeMillis()
         return runCatching {
@@ -217,7 +199,7 @@ class HomeRecommendationFacade(
         return memberContentPreferenceService.canViewAdultContent(member)
     }
 
-    private fun Int.toOffset(size: Int): Int = this * size
+    private fun Int.toOffset(size: Int): Long = this.toLong() * size
 
     private fun <S, T> List<S>.toPage(
         page: Int,

src/main/kotlin/kr/co/vividnext/sodalive/v2/api/home/live/application/HomeOnAirLiveFacade.kt

@@ -21,7 +21,7 @@ class HomeOnAirLiveFacade(
     fun getOnAirLives(member: Member, page: Int): HomeOnAirLivePageResponse {
         val normalizedPage = page.coerceIn(0, MAX_PAGE)
         val fetched = queryService.findLiveRecommendations(
-            offset = normalizedPage * PAGE_SIZE,
+            offset = normalizedPage.toLong() * PAGE_SIZE,
             limit = PAGE_SIZE + 1,
             memberId = member.id,
             includeAdultLives = memberContentPreferenceService.canViewAdultContent(member)

src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationQueryService.kt

@@ -2,6 +2,7 @@ package kr.co.vividnext.sodalive.v2.content.recommendation.application
 
 import kr.co.vividnext.sodalive.member.Member
 import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
+import kr.co.vividnext.sodalive.v2.content.recommendation.domain.AudioCard
 import kr.co.vividnext.sodalive.v2.content.recommendation.domain.AudioRecommendationVisibility
 import kr.co.vividnext.sodalive.v2.content.recommendation.domain.AudioRecommendations
 import kr.co.vividnext.sodalive.v2.content.recommendation.port.out.AudioRecommendationQueryPort
@@ -29,7 +30,7 @@ class AudioRecommendationQueryService(
         val visibility = if (canViewAdultContent) AudioRecommendationVisibility.ALL else AudioRecommendationVisibility.SAFE
         val memberId = member?.id
         val newAndHotSectionType = newAndHotSectionType(visibility)
-        val newAndHotSnapshots = snapshotPort.findLatestSnapshots(newAndHotSectionType, limit = NEW_AND_HOT_AUDIO_LIMIT)
+        val newAndHotSnapshots = snapshotPort.findLatestSnapshots(newAndHotSectionType, limit = NEW_AND_HOT_HOME_LIMIT)
         val mostCommentedSnapshots = snapshotPort.findLatestSnapshots(
             mostCommentedSectionType(visibility),
             limit = MOST_COMMENTED_AUDIO_LIMIT
@@ -38,7 +39,12 @@ class AudioRecommendationQueryService(
             recommendedAudioSectionType(visibility),
             limit = RECOMMENDED_AUDIO_LIMIT
         )
-        val refreshedNewAndHotSnapshots = refreshMissingNewAndHotSnapshots(newAndHotSectionType, newAndHotSnapshots)
+        val refreshedNewAndHotSnapshots = refreshMissingNewAndHotSnapshots(
+            newAndHotSectionType,
+            newAndHotSnapshots,
+            offset = 0,
+            limit = NEW_AND_HOT_HOME_LIMIT
+        )
 
         return AudioRecommendations(
             banners = queryPort.findBanners(BANNER_LIMIT, memberId, canViewAdultContent),
@@ -66,6 +72,22 @@ class AudioRecommendationQueryService(
         )
     }
 
+    fun findNewAndHotAudios(member: Member, offset: Long, limit: Int): List<AudioCard> {
+        val now = LocalDateTime.now()
+        val canViewAdultContent = canViewAdultContent(member)
+        val visibility = if (canViewAdultContent) AudioRecommendationVisibility.ALL else AudioRecommendationVisibility.SAFE
+        val sectionType = newAndHotSectionType(visibility)
+        val snapshots = snapshotPort.findLatestSnapshots(sectionType, offset, limit)
+        val refreshedSnapshots = refreshMissingNewAndHotSnapshots(sectionType, snapshots, offset, limit)
+
+        return queryPort.findAudioCardsByIds(
+            refreshedSnapshots.map { it.targetId },
+            member.id,
+            canViewAdultContent,
+            now
+        )
+    }
+
     fun resolveVisibility(member: Member?): AudioRecommendationVisibility {
         return if (canViewAdultContent(member)) AudioRecommendationVisibility.ALL else AudioRecommendationVisibility.SAFE
     }
@@ -93,7 +115,9 @@ class AudioRecommendationQueryService(
 
     private fun refreshMissingNewAndHotSnapshots(
         sectionType: RecommendedSectionType,
-        snapshots: List<RecommendationSnapshotRecord>
+        snapshots: List<RecommendationSnapshotRecord>,
+        offset: Long,
+        limit: Int
     ): List<RecommendationSnapshotRecord> {
         if (snapshots.isNotEmpty()) return snapshots
         val today = LocalDate.now(KST_ZONE)
@@ -107,7 +131,7 @@ class AudioRecommendationQueryService(
             marker.delete()
             throw ex
         }
-        return snapshotPort.findLatestSnapshots(sectionType, limit = NEW_AND_HOT_AUDIO_LIMIT)
+        return snapshotPort.findLatestSnapshots(sectionType, offset, limit)
     }
 
     private fun newAndHotLazyRefreshMarkerKey(date: LocalDate): String {
@@ -125,7 +149,7 @@ class AudioRecommendationQueryService(
         const val LATEST_AUDIO_LIMIT = 12
         const val FREE_AUDIO_LIMIT = 10
         const val POINT_AUDIO_LIMIT = 10
-        const val NEW_AND_HOT_AUDIO_LIMIT = 12
+        const val NEW_AND_HOT_HOME_LIMIT = 12
         const val MOST_COMMENTED_AUDIO_LIMIT = 5
         const val RECOMMENDED_AUDIO_LIMIT = 10
         private const val LAZY_REFRESH_MARKER_KEY_PREFIX = "audio-recommendation:new-and-hot:lazy-refresh-attempted"

src/main/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationSnapshotRefreshService.kt

@@ -68,7 +68,7 @@ class AudioRecommendationSnapshotRefreshService(
         visibility: AudioRecommendationVisibility
     ) {
         val sectionType = visibility.newAndHotSectionType()
-        val snapshots = queryPort.findNewAndHotSnapshots(windowStart, snapshotAt, visibility, NEW_AND_HOT_LIMIT)
+        val snapshots = queryPort.findNewAndHotSnapshots(windowStart, snapshotAt, visibility, NEW_AND_HOT_SNAPSHOT_LIMIT)
         snapshotPort.replaceSnapshots(sectionType, snapshotAt, snapshots)
     }
 
@@ -128,7 +128,7 @@ class AudioRecommendationSnapshotRefreshService(
     }
 
     companion object {
-        const val NEW_AND_HOT_LIMIT = 12
+        const val NEW_AND_HOT_SNAPSHOT_LIMIT = 100
         const val MOST_COMMENTED_LIMIT = 5
         const val RECOMMENDED_AUDIO_LIMIT = 10
         private val KST_ZONE: ZoneId = ZoneId.of("Asia/Seoul")

src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/adapter/out/persistence/DefaultHomeRecommendationQueryRepository.kt

@@ -51,7 +51,7 @@ class DefaultHomeRecommendationQueryRepository(
     private val entityManager: EntityManager
 ) : HomeRecommendationQueryRepository {
     override fun findLiveRecommendations(
-        offset: Int,
+        offset: Long,
         limit: Int,
         memberId: Long?,
         includeAdultLives: Boolean
@@ -79,7 +79,7 @@ class DefaultHomeRecommendationQueryRepository(
                 member.isActive.isTrue
             )
             .orderBy(liveRoom.beginDateTime.desc(), liveRoom.id.desc())
-            .offset(offset.toLong())
+            .offset(offset)
             .limit(limit.toLong())
             .fetch()
     }
@@ -211,7 +211,7 @@ class DefaultHomeRecommendationQueryRepository(
 
     override fun findRecentDebutCreators(
         now: LocalDateTime,
-        offset: Int,
+        offset: Long,
         limit: Int,
         memberId: Long?,
         includeAdultContents: Boolean
@@ -355,7 +355,7 @@ class DefaultHomeRecommendationQueryRepository(
 
     override fun findFirstAudioContents(
         now: LocalDateTime,
-        offset: Int,
+        offset: Long,
         limit: Int,
         memberId: Long?,
         includeAdultContents: Boolean
@@ -390,6 +390,14 @@ class DefaultHomeRecommendationQueryRepository(
                        ac.release_date as release_date,
                        ac.is_active as is_active,
                        ac.is_point_available as is_point_available,
+                       ac.is_adult as is_adult,
+                       exists (
+                           select 1
+                           from series_content csc
+                           join series cs on cs.id = csc.series_id
+                           where csc.content_id = ac.id
+                             and cs.is_original = true
+                       ) as is_original_series,
                        row_number() over (
                            partition by ac.member_id
                            order by ac.created_at asc, ac.release_date asc, ac.id asc
@@ -416,7 +424,9 @@ class DefaultHomeRecommendationQueryRepository(
                    ec.title as title,
                    ec.price as price,
                    ec.cover_image as cover_image,
-                   ec.is_point_available as is_point_available
+                   ec.is_point_available as is_point_available,
+                   ec.is_adult as is_adult,
+                   ec.is_original_series as is_original_series
             from eligible_contents ec
             join member m on m.id = ec.creator_id
             join creator_debut cd on cd.creator_id = ec.creator_id
@@ -465,7 +475,9 @@ class DefaultHomeRecommendationQueryRepository(
                 title = row[4] as String,
                 price = (row[5] as Number).toInt(),
                 coverImage = row[6] as String?,
-                isPointAvailable = row[7] as Boolean
+                isPointAvailable = row[7].toNativeBoolean(),
+                isAdult = row[8].toNativeBoolean(),
+                isOriginalSeries = row[9].toNativeBoolean()
             )
         }
     }
@@ -1173,6 +1185,14 @@ class DefaultHomeRecommendationQueryRepository(
         return if (condition == null) this else and(condition)
     }
 
+    private fun Any?.toNativeBoolean(): Boolean {
+        return when (this) {
+            is Boolean -> this
+            is Number -> this.toInt() != 0
+            else -> this as Boolean
+        }
+    }
+
     private fun includeAdultCommunityCondition(includeAdultCommunities: Boolean): BooleanExpression? {
         return if (includeAdultCommunities) null else creatorCommunity.isAdult.isFalse
     }

src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/adapter/out/persistence/RecommendationSnapshotPersistenceAdapter.kt

@@ -12,7 +12,7 @@ class RecommendationSnapshotPersistenceAdapter(
 ) : RecommendationSnapshotPort {
     override fun findLatestSnapshots(
         sectionType: RecommendedSectionType,
-        offset: Int,
+        offset: Long,
         limit: Int
     ): List<RecommendationSnapshotRecord> {
         return repository.findLatestSnapshots(sectionType.name, offset, limit).map { it.toRecord() }

src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/adapter/out/persistence/RecommendationSnapshotRepository.kt

@@ -24,7 +24,7 @@ interface RecommendationSnapshotRepository : JpaRepository<RecommendationSnapsho
     )
     fun findLatestSnapshots(
         @Param("sectionType") sectionType: String,
-        @Param("offset") offset: Int,
+        @Param("offset") offset: Long,
         @Param("limit") limit: Int
     ): List<RecommendationSnapshot>
 

src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/application/HomeRecommendationQueryService.kt

@@ -24,7 +24,7 @@ class HomeRecommendationQueryService(
     private val snapshotPort: RecommendationSnapshotPort
 ) {
     fun findLiveRecommendations(
-        offset: Int = 0,
+        offset: Long = 0,
         limit: Int = DEFAULT_LIVE_LIMIT,
         memberId: Long? = null,
         includeAdultLives: Boolean = false
@@ -49,7 +49,7 @@ class HomeRecommendationQueryService(
 
     fun findRecentDebutCreators(
         now: LocalDateTime,
-        offset: Int = 0,
+        offset: Long = 0,
         limit: Int = DEFAULT_RECENT_DEBUT_CREATOR_LIMIT,
         memberId: Long? = null,
         includeAdultContents: Boolean = false
@@ -59,7 +59,7 @@ class HomeRecommendationQueryService(
 
     fun findFirstAudioContents(
         now: LocalDateTime,
-        offset: Int = 0,
+        offset: Long = 0,
         limit: Int = DEFAULT_FIRST_AUDIO_CONTENT_LIMIT,
         memberId: Long? = null,
         includeAdultContents: Boolean = false
@@ -68,7 +68,7 @@ class HomeRecommendationQueryService(
     }
 
     fun findAiCharacterRecommendations(
-        offset: Int = 0,
+        offset: Long = 0,
         limit: Int = DEFAULT_AI_CHARACTER_LIMIT
     ): List<HomeAiCharacterRecommendationRecord> {
         val snapshots = snapshotPort.findLatestSnapshots(RecommendedSectionType.AI_CHARACTER, offset, limit)

src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/port/out/HomeRecommendationQueryPort.kt

@@ -5,7 +5,7 @@ import java.time.LocalDateTime
 
 interface HomeRecommendationQueryPort {
     fun findLiveRecommendations(
-        offset: Int = 0,
+        offset: Long = 0,
         limit: Int,
         memberId: Long? = null,
         includeAdultLives: Boolean = false
@@ -24,7 +24,7 @@ interface HomeRecommendationQueryPort {
 
     fun findRecentDebutCreators(
         now: LocalDateTime,
-        offset: Int = 0,
+        offset: Long = 0,
         limit: Int,
         memberId: Long? = null,
         includeAdultContents: Boolean = false
@@ -32,7 +32,7 @@ interface HomeRecommendationQueryPort {
 
     fun findFirstAudioContents(
         now: LocalDateTime,
-        offset: Int = 0,
+        offset: Long = 0,
         limit: Int,
         memberId: Long? = null,
         includeAdultContents: Boolean = false
@@ -119,7 +119,9 @@ data class HomeFirstAudioContentRecord(
     val title: String,
     val price: Int,
     val coverImage: String?,
-    val isPointAvailable: Boolean
+    val isPointAvailable: Boolean,
+    val isAdult: Boolean,
+    val isOriginalSeries: Boolean
 )
 
 data class HomeAiCharacterRecommendationRecord(

src/main/kotlin/kr/co/vividnext/sodalive/v2/recommendation/port/out/RecommendationSnapshotPort.kt

@@ -6,7 +6,7 @@ import java.time.LocalDateTime
 interface RecommendationSnapshotPort {
     fun findLatestSnapshots(
         sectionType: RecommendedSectionType,
-        offset: Int = 0,
+        offset: Long = 0,
         limit: Int = Int.MAX_VALUE
     ): List<RecommendationSnapshotRecord>
 

src/test/kotlin/kr/co/vividnext/sodalive/admin/member/AdminMemberServiceTest.kt

@@ -0,0 +1,81 @@
+package kr.co.vividnext.sodalive.admin.member
+
+import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.member.MemberRole
+import kr.co.vividnext.sodalive.member.SignOut
+import kr.co.vividnext.sodalive.member.SignOutRepository
+import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.data.domain.PageRequest
+import org.springframework.test.context.ContextConfiguration
+
+@SpringBootTest(properties = ["cloud.aws.cloud-front.host=https://cdn.test"])
+@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
+class AdminMemberServiceTest @Autowired constructor(
+    private val service: AdminMemberService,
+    private val adminMemberRepository: AdminMemberRepository,
+    private val signOutRepository: SignOutRepository
+) {
+    @AfterEach
+    fun tearDown() {
+        signOutRepository.deleteAll()
+        adminMemberRepository.deleteAll()
+    }
+
+    @Test
+    @DisplayName("OSIV off 환경에서 탈퇴 이력이 있는 회원 리스트를 조회해도 lazy 초기화 예외가 발생하지 않는다")
+    fun shouldGetMemberListWithSignOutReasonsWhenOpenInViewIsDisabled() {
+        val member = saveMemberWithSignOutReason(
+            email = "admin-member-list-user@test.com",
+            nickname = "회원 목록 사용자",
+            role = MemberRole.USER
+        )
+
+        val response = service.getMemberList(PageRequest.of(0, 20))
+
+        val item = response.items.single { it.id == member.id }
+        assertEquals(1, response.totalCount)
+        assertTrue(item.signOutDate.isNotBlank())
+    }
+
+    @Test
+    @DisplayName("OSIV off 환경에서 탈퇴 이력이 있는 크리에이터 리스트를 조회해도 lazy 초기화 예외가 발생하지 않는다")
+    fun shouldGetCreatorListWithSignOutReasonsWhenOpenInViewIsDisabled() {
+        val creator = saveMemberWithSignOutReason(
+            email = "admin-member-list-creator@test.com",
+            nickname = "크리에이터 목록 사용자",
+            role = MemberRole.CREATOR
+        )
+
+        val response = service.getCreatorList(PageRequest.of(0, 20))
+
+        val item = response.items.single { it.id == creator.id }
+        assertEquals(1, response.totalCount)
+        assertTrue(item.signOutDate.isNotBlank())
+    }
+
+    private fun saveMemberWithSignOutReason(
+        email: String,
+        nickname: String,
+        role: MemberRole
+    ): Member {
+        val member = adminMemberRepository.save(
+            Member(
+                email = email,
+                password = "password",
+                nickname = nickname,
+                role = role
+            )
+        )
+        val signOut = SignOut(reason = "운영 정책 위반")
+        signOut.member = member
+        signOutRepository.save(signOut)
+        return member
+    }
+}

src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewControllerTest.kt

@@ -0,0 +1,105 @@
+package kr.co.vividnext.sodalive.v2.api.content.overview.adapter.`in`.web
+
+import kr.co.vividnext.sodalive.common.CountryContext
+import kr.co.vividnext.sodalive.configs.SecurityConfig
+import kr.co.vividnext.sodalive.i18n.LangContext
+import kr.co.vividnext.sodalive.i18n.SodaMessageSource
+import kr.co.vividnext.sodalive.jwt.JwtAccessDeniedHandler
+import kr.co.vividnext.sodalive.jwt.JwtAuthenticationEntryPoint
+import kr.co.vividnext.sodalive.jwt.TokenProvider
+import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.member.MemberAdapter
+import kr.co.vividnext.sodalive.member.MemberRole
+import kr.co.vividnext.sodalive.v2.api.content.overview.application.ContentOverviewFacade
+import kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewPageResponse
+import kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewType
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.mockito.Mockito
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
+import org.springframework.boot.test.mock.mockito.MockBean
+import org.springframework.context.annotation.Import
+import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.anonymous
+import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.user
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+
+@WebMvcTest(ContentOverviewController::class)
+@Import(SecurityConfig::class, JwtAuthenticationEntryPoint::class, JwtAccessDeniedHandler::class)
+class ContentOverviewControllerTest @Autowired constructor(
+    private val mockMvc: MockMvc
+) {
+    @MockBean
+    private lateinit var facade: ContentOverviewFacade
+
+    @MockBean
+    private lateinit var countryContext: CountryContext
+
+    @MockBean
+    private lateinit var langContext: LangContext
+
+    @MockBean
+    private lateinit var sodaMessageSource: SodaMessageSource
+
+    @MockBean
+    private lateinit var tokenProvider: TokenProvider
+
+    @Test
+    @DisplayName("콘텐츠 전체보기는 비회원 요청을 거부한다")
+    fun shouldRejectAnonymousRequest() {
+        mockMvc.perform(
+            get("/api/v2/contents")
+                .with(anonymous())
+        )
+            .andExpect(status().isUnauthorized)
+    }
+
+    @Test
+    @DisplayName("콘텐츠 전체보기는 인증 회원과 query parameter를 facade에 전달한다")
+    fun shouldPassAuthenticatedMemberAndQueryParameters() {
+        val member = member(id = 10L)
+        Mockito.doReturn(emptyResponse(ContentOverviewType.FIRST_AUDIO_CONTENT)).`when`(facade)
+            .getContents(eqValue("FIRST_AUDIO_CONTENT"), eqValue(1), eqValue(30), eqValue(member))
+
+        mockMvc.perform(
+            get("/api/v2/contents")
+                .param("type", "FIRST_AUDIO_CONTENT")
+                .param("page", "1")
+                .param("size", "30")
+                .with(user(MemberAdapter(member)))
+        )
+            .andExpect(status().isOk)
+            .andExpect(jsonPath("$.success").value(true))
+            .andExpect(jsonPath("$.data.type").value("FIRST_AUDIO_CONTENT"))
+
+        Mockito.verify(facade).getContents(eqValue("FIRST_AUDIO_CONTENT"), eqValue(1), eqValue(30), eqValue(member))
+    }
+
+    private fun <T> eqValue(value: T): T {
+        return Mockito.eq(value) ?: value
+    }
+
+    private fun member(id: Long): Member {
+        return Member(
+            email = "viewer$id@test.com",
+            password = "password",
+            nickname = "viewer$id",
+            role = MemberRole.USER
+        ).apply {
+            this.id = id
+        }
+    }
+
+    private fun emptyResponse(type: ContentOverviewType): ContentOverviewPageResponse {
+        return ContentOverviewPageResponse(
+            type = type,
+            items = emptyList(),
+            page = 0,
+            size = 20,
+            hasNext = false
+        )
+    }
+}

src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewEndToEndTest.kt

@@ -0,0 +1,204 @@
+package kr.co.vividnext.sodalive.v2.api.content.overview.adapter.`in`.web
+
+import kr.co.vividnext.sodalive.content.AudioContent
+import kr.co.vividnext.sodalive.content.theme.AudioContentTheme
+import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.member.MemberAdapter
+import kr.co.vividnext.sodalive.member.MemberRole
+import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
+import kr.co.vividnext.sodalive.v2.recommendation.adapter.out.persistence.RecommendationSnapshot
+import kr.co.vividnext.sodalive.v2.recommendation.domain.RecommendedSectionType
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.user
+import org.springframework.test.annotation.DirtiesContext
+import org.springframework.test.context.ContextConfiguration
+import org.springframework.test.web.servlet.MockMvc
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+import org.springframework.transaction.support.TransactionTemplate
+import java.time.LocalDateTime
+import javax.persistence.EntityManager
+
+@SpringBootTest(
+    properties = [
+        "cloud.aws.cloud-front.host=https://cdn.test",
+        "spring.cache.type=none",
+        "spring.datasource.url=jdbc:h2:mem:content-overview-e2e;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE"
+    ]
+)
+@AutoConfigureMockMvc
+@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
+@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
+class ContentOverviewEndToEndTest @Autowired constructor(
+    private val mockMvc: MockMvc,
+    private val entityManager: EntityManager,
+    private val transactionTemplate: TransactionTemplate
+) {
+    @Test
+    @DisplayName("콘텐츠 전체보기 API는 비회원 요청을 거부한다")
+    fun shouldRejectAnonymousContentOverviewRequest() {
+        mockMvc.perform(get("/api/v2/contents"))
+            .andExpect(status().isUnauthorized)
+    }
+
+    @Test
+    @DisplayName("콘텐츠 전체보기 API는 인증 회원에게 New & Hot 오디오 페이지를 반환한다")
+    fun shouldReturnNewAndHotAudioOverviewForMember() {
+        val fixture = createNewAndHotFixture("content-overview-new-hot")
+
+        mockMvc.perform(
+            get("/api/v2/contents")
+                .param("type", "NEW_AND_HOT_AUDIO")
+                .param("page", "0")
+                .param("size", "20")
+                .with(user(MemberAdapter(fixture.viewer)))
+        )
+            .andExpect(status().isOk)
+            .andExpect(jsonPath("$.success").value(true))
+            .andExpect(jsonPath("$.data.type").value("NEW_AND_HOT_AUDIO"))
+            .andExpect(jsonPath("$.data.items[0].contentId").value(fixture.audioContentId))
+            .andExpect(jsonPath("$.data.items[0].title").value("content-overview-new-hot-audio"))
+            .andExpect(jsonPath("$.data.items[0].coverImage").value("https://cdn.test/content-overview-new-hot.png"))
+            .andExpect(jsonPath("$.data.page").value(0))
+            .andExpect(jsonPath("$.data.size").value(20))
+            .andExpect(jsonPath("$.data.hasNext").value(false))
+    }
+
+    @Test
+    @DisplayName("콘텐츠 전체보기 API는 인증 회원에게 첫 번째 오디오 콘텐츠 페이지를 반환한다")
+    fun shouldReturnFirstAudioContentOverviewForMember() {
+        val fixture = createFirstAudioFixture("content-overview-first")
+
+        mockMvc.perform(
+            get("/api/v2/contents")
+                .param("type", "FIRST_AUDIO_CONTENT")
+                .param("page", "0")
+                .param("size", "20")
+                .with(user(MemberAdapter(fixture.viewer)))
+        )
+            .andExpect(status().isOk)
+            .andExpect(jsonPath("$.success").value(true))
+            .andExpect(jsonPath("$.data.type").value("FIRST_AUDIO_CONTENT"))
+            .andExpect(jsonPath("$.data.items[0].contentId").value(fixture.audioContentId))
+            .andExpect(jsonPath("$.data.items[0].title").value("content-overview-first-audio"))
+            .andExpect(jsonPath("$.data.items[0].coverImage").value("https://cdn.test/content-overview-first.png"))
+            .andExpect(jsonPath("$.data.items[0].isFirstContent").value(true))
+            .andExpect(jsonPath("$.data.page").value(0))
+            .andExpect(jsonPath("$.data.size").value(20))
+            .andExpect(jsonPath("$.data.hasNext").value(false))
+    }
+
+    @Test
+    @DisplayName("콘텐츠 전체보기 API는 유효하지 않은 type을 New & Hot으로 대체한다")
+    fun shouldFallbackInvalidTypeToNewAndHotAudio() {
+        val fixture = createNewAndHotFixture("content-overview-invalid-type")
+
+        mockMvc.perform(
+            get("/api/v2/contents")
+                .param("type", "UNKNOWN")
+                .param("page", "0")
+                .param("size", "20")
+                .with(user(MemberAdapter(fixture.viewer)))
+        )
+            .andExpect(status().isOk)
+            .andExpect(jsonPath("$.success").value(true))
+            .andExpect(jsonPath("$.data.type").value("NEW_AND_HOT_AUDIO"))
+            .andExpect(jsonPath("$.data.items[0].contentId").value(fixture.audioContentId))
+            .andExpect(jsonPath("$.data.page").value(0))
+            .andExpect(jsonPath("$.data.size").value(20))
+            .andExpect(jsonPath("$.data.hasNext").value(false))
+    }
+
+    private fun createNewAndHotFixture(prefix: String): Fixture {
+        return transactionTemplate.execute {
+            val now = LocalDateTime.now().minusHours(1)
+            val viewer = saveMember("$prefix-viewer", MemberRole.USER)
+            val creator = saveMember("$prefix-creator", MemberRole.CREATOR)
+            val theme = saveTheme(prefix)
+            val audio = saveAudio(creator, theme, "$prefix-audio", "$prefix.png", now)
+            saveSnapshot(RecommendedSectionType.NEW_AND_HOT_AUDIO_SAFE, audio.id!!, now)
+            entityManager.flush()
+            entityManager.clear()
+
+            Fixture(viewer = viewer, audioContentId = audio.id!!)
+        }!!
+    }
+
+    private fun createFirstAudioFixture(prefix: String): Fixture {
+        return transactionTemplate.execute {
+            val now = LocalDateTime.now().minusHours(1)
+            val viewer = saveMember("$prefix-viewer", MemberRole.USER)
+            val creator = saveMember("$prefix-creator", MemberRole.CREATOR)
+            val theme = saveTheme(prefix)
+            val audio = saveAudio(creator, theme, "$prefix-audio", "$prefix.png", now)
+            entityManager.flush()
+            entityManager.clear()
+
+            Fixture(viewer = viewer, audioContentId = audio.id!!)
+        }!!
+    }
+
+    private fun saveMember(nickname: String, role: MemberRole): Member {
+        val member = Member(
+            email = "$nickname@test.com",
+            password = "password",
+            nickname = nickname,
+            role = role
+        )
+        entityManager.persist(member)
+        return member
+    }
+
+    private fun saveTheme(prefix: String): AudioContentTheme {
+        val theme = AudioContentTheme(theme = "$prefix-theme", image = "$prefix-theme.png", isActive = true)
+        entityManager.persist(theme)
+        return theme
+    }
+
+    private fun saveAudio(
+        creator: Member,
+        theme: AudioContentTheme,
+        title: String,
+        coverImage: String,
+        releaseDate: LocalDateTime
+    ): AudioContent {
+        val audio = AudioContent(
+            title = title,
+            detail = "detail",
+            languageCode = "ko",
+            releaseDate = releaseDate,
+            isAdult = false,
+            price = 100,
+            isPointAvailable = true
+        )
+        audio.member = creator
+        audio.theme = theme
+        audio.isActive = true
+        audio.coverImage = coverImage
+        audio.duration = "00:10"
+        entityManager.persist(audio)
+        return audio
+    }
+
+    private fun saveSnapshot(sectionType: RecommendedSectionType, targetId: Long, snapshotAt: LocalDateTime) {
+        entityManager.persist(
+            RecommendationSnapshot(
+                sectionType = sectionType,
+                targetId = targetId,
+                score = 1.0,
+                snapshotAt = snapshotAt,
+                randomTieBreaker = 0.0
+            )
+        )
+    }
+
+    private data class Fixture(
+        val viewer: Member,
+        val audioContentId: Long
+    )
+}

src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewFacadeTest.kt

@@ -0,0 +1,117 @@
+package kr.co.vividnext.sodalive.v2.api.content.overview.application
+
+import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.member.MemberRole
+import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
+import kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewType
+import kr.co.vividnext.sodalive.v2.content.recommendation.application.AudioRecommendationQueryService
+import kr.co.vividnext.sodalive.v2.content.recommendation.domain.AudioCard
+import kr.co.vividnext.sodalive.v2.recommendation.application.HomeRecommendationQueryService
+import kr.co.vividnext.sodalive.v2.recommendation.port.out.HomeFirstAudioContentRecord
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.mockito.Mockito
+import java.time.LocalDateTime
+
+class ContentOverviewFacadeTest {
+    private val audioRecommendationQueryService = Mockito.mock(AudioRecommendationQueryService::class.java)
+    private val homeRecommendationQueryService = Mockito.mock(HomeRecommendationQueryService::class.java)
+    private val memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java)
+    private val facade = ContentOverviewFacade(
+        audioRecommendationQueryService = audioRecommendationQueryService,
+        homeRecommendationQueryService = homeRecommendationQueryService,
+        memberContentPreferenceService = memberContentPreferenceService,
+        cloudFrontHost = "https://cdn.test",
+        queryPolicy = ContentOverviewQueryPolicy()
+    )
+
+    @Test
+    @DisplayName("New & Hot 전체보기는 size + 1 조회 결과를 공통 페이지 응답으로 변환한다")
+    fun shouldReturnNewAndHotPage() {
+        val member = member(id = 10L)
+        Mockito.doReturn((1L..21L).map { audioCard(it) }).`when`(audioRecommendationQueryService)
+            .findNewAndHotAudios(member, offset = 0L, limit = 21)
+
+        val response = facade.getContents("NEW_AND_HOT_AUDIO", page = 0, size = 20, member = member)
+
+        assertEquals(ContentOverviewType.NEW_AND_HOT_AUDIO, response.type)
+        assertEquals((1L..20L).toList(), response.items.map { it.contentId })
+        assertEquals("https://cdn.test/audio1.png", response.items[0].coverImage)
+        assertEquals(0, response.page)
+        assertEquals(20, response.size)
+        assertEquals(true, response.hasNext)
+    }
+
+    @Test
+    @DisplayName("첫 번째 오디오 콘텐츠 전체보기는 adult visibility와 offset을 반영해 조회한다")
+    fun shouldReturnFirstAudioContentPage() {
+        val member = member(id = 10L)
+        Mockito.doReturn(true).`when`(memberContentPreferenceService).canViewAdultContent(member)
+        Mockito.doReturn(listOf(firstAudio(1L), firstAudio(2L))).`when`(homeRecommendationQueryService)
+            .findFirstAudioContents(
+                anyLocalDateTime(),
+                eqValue(20L),
+                eqValue(21),
+                eqValue(member.id),
+                eqValue(true)
+            )
+
+        val response = facade.getContents("FIRST_AUDIO_CONTENT", page = 1, size = 20, member = member)
+
+        assertEquals(ContentOverviewType.FIRST_AUDIO_CONTENT, response.type)
+        assertEquals(listOf(1L, 2L), response.items.map { it.contentId })
+        assertEquals("https://cdn.test/cover/audio1.png", response.items[0].coverImage)
+        assertEquals(true, response.items[0].isFirstContent)
+        assertEquals(false, response.hasNext)
+    }
+
+    private fun member(id: Long): Member {
+        return Member(
+            email = "viewer$id@test.com",
+            password = "password",
+            nickname = "viewer$id",
+            role = MemberRole.USER
+        ).apply {
+            this.id = id
+        }
+    }
+
+    private fun audioCard(id: Long): AudioCard {
+        return AudioCard(
+            audioContentId = id,
+            title = "audio$id",
+            duration = "00:01",
+            imageUrl = "https://cdn.test/audio$id.png",
+            price = id.toInt(),
+            isAdult = false,
+            isPointAvailable = true,
+            isFirstContent = true,
+            isOriginalSeries = false,
+            creatorNickname = "creator$id"
+        )
+    }
+
+    private fun anyLocalDateTime(): LocalDateTime {
+        return Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.of(2026, 6, 27, 0, 0)
+    }
+
+    private fun <T> eqValue(value: T): T {
+        return Mockito.eq(value) ?: value
+    }
+
+    private fun firstAudio(id: Long): HomeFirstAudioContentRecord {
+        return HomeFirstAudioContentRecord(
+            contentId = id,
+            creatorId = id + 100,
+            creatorNickname = "creator$id",
+            creatorProfileImage = null,
+            title = "first audio$id",
+            price = id.toInt(),
+            coverImage = "cover/audio$id.png",
+            isPointAvailable = true,
+            isAdult = false,
+            isOriginalSeries = false
+        )
+    }
+}

src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/application/ContentOverviewQueryPolicyTest.kt

@@ -0,0 +1,45 @@
+package kr.co.vividnext.sodalive.v2.api.content.overview.application
+
+import kr.co.vividnext.sodalive.v2.api.content.overview.dto.ContentOverviewType
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+class ContentOverviewQueryPolicyTest {
+    private val policy = ContentOverviewQueryPolicy()
+
+    @Test
+    @DisplayName("콘텐츠 전체보기 type은 null 또는 invalid 값을 기본 타입으로 보정한다")
+    fun shouldResolveTypeWithDefaultFallback() {
+        assertEquals(ContentOverviewType.NEW_AND_HOT_AUDIO, policy.resolveType(null))
+        assertEquals(ContentOverviewType.NEW_AND_HOT_AUDIO, policy.resolveType("UNKNOWN"))
+        assertEquals(ContentOverviewType.FIRST_AUDIO_CONTENT, policy.resolveType("FIRST_AUDIO_CONTENT"))
+    }
+
+    @Test
+    @DisplayName("콘텐츠 전체보기 page와 size를 기본값과 최대값으로 보정한다")
+    fun shouldNormalizePageAndSize() {
+        assertEquals(ContentOverviewPage(page = 0, size = 20), policy.createPage(null, null))
+        assertEquals(ContentOverviewPage(page = 0, size = 20), policy.createPage(-1, 0))
+        assertEquals(ContentOverviewPage(page = 0, size = 20), policy.createPage(0, 19))
+        assertEquals(ContentOverviewPage(page = 2, size = 50), policy.createPage(2, 100))
+    }
+
+    @Test
+    @DisplayName("콘텐츠 전체보기 offset은 큰 page 입력에서도 Int overflow 없이 계산한다")
+    fun shouldCalculateOffsetWithoutIntOverflow() {
+        val page = policy.createPage(Int.MAX_VALUE, 50)
+
+        assertEquals(Int.MAX_VALUE.toLong() * 50, page.offset)
+    }
+
+    @Test
+    @DisplayName("콘텐츠 전체보기 응답 목록과 hasNext는 size + 1 조회 결과로 계산한다")
+    fun shouldCalculatePageItemsAndHasNext() {
+        val page = ContentOverviewPage(page = 0, size = 2)
+        val items = listOf(1, 2, 3)
+
+        assertEquals(listOf(1, 2), policy.pageItems(items, page))
+        assertEquals(true, policy.hasNext(items, page))
+    }
+}

src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/dto/ContentOverviewPageResponseTest.kt

@@ -0,0 +1,80 @@
+package kr.co.vividnext.sodalive.v2.api.content.overview.dto
+
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import kr.co.vividnext.sodalive.v2.recommendation.port.out.HomeFirstAudioContentRecord
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+class ContentOverviewPageResponseTest {
+    private val objectMapper = jacksonObjectMapper()
+
+    @Test
+    @DisplayName("콘텐츠 전체보기 응답은 공개 JSON 필드명만 직렬화한다")
+    fun shouldSerializeContentOverviewPageResponse() {
+        val response = ContentOverviewPageResponse(
+            type = ContentOverviewType.NEW_AND_HOT_AUDIO,
+            items = listOf(
+                ContentOverviewItemResponse(
+                    contentId = 1L,
+                    title = "audio",
+                    coverImage = "https://cdn.test/audio.png",
+                    price = 10,
+                    isPointAvailable = true,
+                    creatorNickname = "creator",
+                    isAdult = false,
+                    isFirstContent = true,
+                    isOriginalSeries = false
+                )
+            ),
+            page = 0,
+            size = 20,
+            hasNext = true
+        )
+
+        val json = objectMapper.readTree(objectMapper.writeValueAsString(response))
+
+        assertEquals("NEW_AND_HOT_AUDIO", json["type"].asText())
+        assertEquals(true, json["hasNext"].asBoolean())
+        assertEquals(1L, json["items"][0]["contentId"].asLong())
+        assertEquals("https://cdn.test/audio.png", json["items"][0]["coverImage"].asText())
+        assertEquals(true, json["items"][0]["isPointAvailable"].asBoolean())
+        assertEquals(false, json["items"][0]["isAdult"].asBoolean())
+        assertEquals(true, json["items"][0]["isFirstContent"].asBoolean())
+        assertEquals(false, json["items"][0]["isOriginalSeries"].asBoolean())
+        assertEquals(false, json["items"][0].has("audioContentId"))
+        assertEquals(false, json["items"][0].has("imageUrl"))
+        assertEquals(false, json["items"][0].has("duration"))
+        assertEquals(false, json["items"][0].has("creatorId"))
+        assertEquals(false, json["items"][0].has("creatorProfileImage"))
+        assertEquals(false, json["items"][0].has("pointAvailable"))
+        assertEquals(false, json["items"][0].has("adult"))
+        assertEquals(false, json["items"][0].has("firstContent"))
+        assertEquals(false, json["items"][0].has("originalSeries"))
+    }
+
+    @Test
+    @DisplayName("첫 번째 오디오 콘텐츠 변환은 성인/오리지널 플래그를 전달한다")
+    fun shouldMapFirstAudioContentFlags() {
+        val response = ContentOverviewItemResponse.fromFirstAudioContent(
+            audio = HomeFirstAudioContentRecord(
+                contentId = 1L,
+                creatorId = 10L,
+                creatorNickname = "creator",
+                creatorProfileImage = null,
+                title = "first audio",
+                price = 100,
+                coverImage = "cover/audio.png",
+                isPointAvailable = true,
+                isAdult = true,
+                isOriginalSeries = true
+            ),
+            coverImage = "https://cdn.test/cover/audio.png",
+            isAdult = true,
+            isOriginalSeries = true
+        )
+
+        assertEquals(true, response.isAdult)
+        assertEquals(true, response.isOriginalSeries)
+    }
+}

src/test/kotlin/kr/co/vividnext/sodalive/v2/api/home/HomeRecommendationControllerTest.kt

@@ -318,30 +318,19 @@ class HomeRecommendationControllerTest @Autowired constructor(
         Mockito.`when`(
             failingQueryService.findRecentDebutCreators(
                 now = Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.MIN,
-                offset = Mockito.eq(0),
+                offset = Mockito.eq(0L),
                 limit = Mockito.eq(21),
                 memberId = Mockito.eq(member.id),
                 includeAdultContents = Mockito.eq(false)
             )
         ).thenThrow(IllegalStateException("debut page failed"))
-        Mockito.`when`(
+        Mockito.`when`(failingQueryService.findAiCharacterRecommendations(offset = 0L, limit = 21))
-            failingQueryService.findFirstAudioContents(
-                now = Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.MIN,
-                offset = Mockito.eq(0),
-                limit = Mockito.eq(21),
-                memberId = Mockito.eq(member.id),
-                includeAdultContents = Mockito.eq(false)
-            )
-        ).thenThrow(IllegalStateException("first audio page failed"))
-        Mockito.`when`(failingQueryService.findAiCharacterRecommendations(offset = 0, limit = 21))
             .thenThrow(IllegalStateException("ai page failed"))
 
         assertThrows(IllegalStateException::class.java) { facade.getRecentDebutCreators(member, page = 0, size = 20) }
-        assertThrows(IllegalStateException::class.java) { facade.getFirstAudioContents(member, page = 0, size = 20) }
         assertThrows(IllegalStateException::class.java) { facade.getAiCharacters(member, page = 0, size = 20) }
 
         assertTrue(output.out.contains("section=DEBUT_CREATOR"))
-        assertTrue(output.out.contains("section=FIRST_AUDIO_CONTENT"))
         assertTrue(output.out.contains("section=AI_CHARACTER"))
     }
 
@@ -362,31 +351,43 @@ class HomeRecommendationControllerTest @Autowired constructor(
     }
 
     @Test
-    @DisplayName("첫 오디오/AI 캐릭터 전체보기도 같은 페이징 응답 형식을 사용한다")
+    @DisplayName("AI 캐릭터 전체보기도 같은 페이징 응답 형식을 사용한다")
     fun shouldReturnPagedSectionsWithSameFormat() {
         val member = saveMember("paged-section-viewer", MemberRole.USER)
         entityManager.flush()
         entityManager.clear()
 
-        for (path in listOf("/first-audio-contents", "/ai-characters")) {
+        mockMvc.perform(
-            mockMvc.perform(
+            get("/api/v2/home/recommendations/ai-characters")
-                get("/api/v2/home/recommendations$path")
+                .with(user(MemberAdapter(member)))
-                    .with(user(MemberAdapter(member)))
+                .param("page", "1")
-                    .param("page", "1")
+                .param("size", "10")
-                    .param("size", "10")
+        )
-            )
+            .andExpect(status().isOk)
-                .andExpect(status().isOk)
+            .andExpect(jsonPath("$.data.items").isArray)
-                .andExpect(jsonPath("$.data.items").isArray)
+            .andExpect(jsonPath("$.data.page").value(1))
-                .andExpect(jsonPath("$.data.page").value(1))
+            .andExpect(jsonPath("$.data.size").value(10))
-                .andExpect(jsonPath("$.data.size").value(10))
+            .andExpect(jsonPath("$.data.hasNext").isBoolean)
-                .andExpect(jsonPath("$.data.hasNext").isBoolean)
+    }
-        }
+
+    @Test
+    @DisplayName("미배포 first-audio-contents 홈 하위 endpoint는 제거된다")
+    fun shouldNotExposeDeprecatedFirstAudioContentsEndpoint() {
+        val member = saveMember("home-viewer", MemberRole.USER)
+        entityManager.flush()
+        entityManager.clear()
+
+        mockMvc.perform(
+            get("/api/v2/home/recommendations/first-audio-contents")
+                .with(user(MemberAdapter(member)))
+        )
+            .andExpect(status().isNotFound)
     }
 
     @Test
     @DisplayName("세부 전체보기 API는 비회원 요청을 거부한다")
     fun shouldRejectAnonymousSectionPages() {
-        for (path in listOf("/lives", "/debut-creators", "/first-audio-contents", "/ai-characters")) {
+        for (path in listOf("/lives", "/debut-creators", "/ai-characters")) {
             mockMvc.perform(get("/api/v2/home/recommendations$path"))
                 .andExpect(status().isUnauthorized)
         }

src/test/kotlin/kr/co/vividnext/sodalive/v2/api/home/live/application/HomeOnAirLiveFacadeTest.kt

@@ -22,7 +22,7 @@ class HomeOnAirLiveFacadeTest {
         val member = createMember(100L)
         Mockito.doReturn(true).`when`(preferenceService).canViewAdultContent(member)
         Mockito.doReturn((1L..21L).map { record(it) }).`when`(queryService).findLiveRecommendations(
-            eqValue(0),
+            eqValue(0L),
             eqValue(21),
             eqValue(member.id),
             eqValue(true)
@@ -34,7 +34,7 @@ class HomeOnAirLiveFacadeTest {
         assertEquals(20, response.size)
         assertEquals(true, response.hasNext)
         assertEquals(20, response.items.size)
-        Mockito.verify(queryService).findLiveRecommendations(eqValue(0), eqValue(21), eqValue(member.id), eqValue(true))
+        Mockito.verify(queryService).findLiveRecommendations(eqValue(0L), eqValue(21), eqValue(member.id), eqValue(true))
     }
 
     @Test
@@ -43,7 +43,7 @@ class HomeOnAirLiveFacadeTest {
         val member = createMember(100L)
         Mockito.doReturn(false).`when`(preferenceService).canViewAdultContent(member)
         Mockito.doReturn(listOf(record(1L, creatorProfileImage = null))).`when`(queryService).findLiveRecommendations(
-            eqValue(0),
+            eqValue(0L),
             eqValue(21),
             eqValue(member.id),
             eqValue(false)
@@ -60,7 +60,7 @@ class HomeOnAirLiveFacadeTest {
         val member = createMember(100L)
         Mockito.doReturn(false).`when`(preferenceService).canViewAdultContent(member)
         Mockito.doReturn(listOf(record(1L, beginDateTime = LocalDateTime.of(2026, 6, 26, 12, 30)))).`when`(queryService)
-            .findLiveRecommendations(eqValue(0), eqValue(21), eqValue(member.id), eqValue(false))
+            .findLiveRecommendations(eqValue(0L), eqValue(21), eqValue(member.id), eqValue(false))
 
         val response = facade.getOnAirLives(member, page = 0)
 

src/test/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationQueryServiceTest.kt

@@ -1,6 +1,9 @@
 package kr.co.vividnext.sodalive.v2.content.recommendation.application
 
+import kr.co.vividnext.sodalive.member.Member
+import kr.co.vividnext.sodalive.member.MemberRole
 import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
+import kr.co.vividnext.sodalive.v2.content.recommendation.domain.AudioCard
 import kr.co.vividnext.sodalive.v2.content.recommendation.domain.AudioRecommendationVisibility
 import kr.co.vividnext.sodalive.v2.content.recommendation.port.out.AudioRecommendationQueryPort
 import kr.co.vividnext.sodalive.v2.recommendation.domain.RecommendedSectionType
@@ -51,7 +54,7 @@ class AudioRecommendationQueryServiceTest {
             .findLatestSnapshots(
                 RecommendedSectionType.NEW_AND_HOT_AUDIO_SAFE,
                 0,
-                AudioRecommendationQueryService.NEW_AND_HOT_AUDIO_LIMIT
+                AudioRecommendationQueryService.NEW_AND_HOT_HOME_LIMIT
             )
         Mockito.doReturn(emptyList<RecommendationSnapshotRecord>())
             .`when`(snapshotPort)
@@ -100,7 +103,7 @@ class AudioRecommendationQueryServiceTest {
             .findLatestSnapshots(
                 RecommendedSectionType.NEW_AND_HOT_AUDIO_SAFE,
                 0,
-                AudioRecommendationQueryService.NEW_AND_HOT_AUDIO_LIMIT
+                AudioRecommendationQueryService.NEW_AND_HOT_HOME_LIMIT
             )
         Mockito.doReturn(emptyList<RecommendationSnapshotRecord>())
             .`when`(snapshotPort)
@@ -127,19 +130,14 @@ class AudioRecommendationQueryServiceTest {
     @Test
     @DisplayName("인증 회원 성인 정책은 조회용 저장 preference를 사용한다")
     fun shouldUseStoredPreferenceForMemberAdultVisibility() {
-        val member = kr.co.vividnext.sodalive.member.Member(
+        val member = member(id = 10L)
-            email = "adult@test.com",
-            password = "password",
-            nickname = "adult",
-            role = kr.co.vividnext.sodalive.member.MemberRole.USER
-        )
         Mockito.doReturn(true).`when`(preferenceService).canViewAdultContent(member)
         Mockito.doReturn(listOf(snapshot(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, 10L)))
             .`when`(snapshotPort)
             .findLatestSnapshots(
                 RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL,
                 0,
-                AudioRecommendationQueryService.NEW_AND_HOT_AUDIO_LIMIT
+                AudioRecommendationQueryService.NEW_AND_HOT_HOME_LIMIT
             )
 
         service.getRecommendations(member)
@@ -149,10 +147,52 @@ class AudioRecommendationQueryServiceTest {
         Mockito.verify(snapshotPort).findLatestSnapshots(
             RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL,
             0,
-            AudioRecommendationQueryService.NEW_AND_HOT_AUDIO_LIMIT
+            AudioRecommendationQueryService.NEW_AND_HOT_HOME_LIMIT
         )
     }
 
+    @Test
+    @DisplayName("추천 탭 첫 화면은 New & Hot 스냅샷을 12개만 조회한다")
+    fun shouldKeepNewAndHotHomeLimitAtTwelve() {
+        val member = member(id = 10L)
+        Mockito.doReturn(true).`when`(preferenceService).canViewAdultContent(member)
+        Mockito.doReturn(listOf(snapshot(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, 10L))).`when`(snapshotPort)
+            .findLatestSnapshots(
+                RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL,
+                0,
+                AudioRecommendationQueryService.NEW_AND_HOT_HOME_LIMIT
+            )
+
+        service.getRecommendations(member)
+
+        Mockito.verify(snapshotPort).findLatestSnapshots(
+            RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL,
+            0,
+            AudioRecommendationQueryService.NEW_AND_HOT_HOME_LIMIT
+        )
+    }
+
+    @Test
+    @DisplayName("New & Hot 전체보기는 스냅샷 offset과 limit으로 오디오 카드를 조회한다")
+    fun shouldFindNewAndHotAudiosWithOffsetAndLimit() {
+        val member = member(id = 10L)
+        val snapshots = listOf(
+            snapshot(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, 3L),
+            snapshot(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, 4L),
+            snapshot(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, 5L)
+        )
+        Mockito.doReturn(true).`when`(preferenceService).canViewAdultContent(member)
+        Mockito.doReturn(snapshots).`when`(snapshotPort)
+            .findLatestSnapshots(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, 20L, 21)
+        Mockito.doReturn(listOf(audioCard(3L), audioCard(4L), audioCard(5L))).`when`(queryPort)
+            .findAudioCardsByIds(eqValue(listOf(3L, 4L, 5L)), eqValue(member.id), eqValue(true), anyLocalDateTime())
+
+        val result = service.findNewAndHotAudios(member, offset = 20L, limit = 21)
+
+        assertEquals(listOf(3L, 4L, 5L), result.map { it.audioContentId })
+        Mockito.verify(snapshotPort).findLatestSnapshots(RecommendedSectionType.NEW_AND_HOT_AUDIO_ALL, 20L, 21)
+    }
+
     @Test
     @DisplayName("visibility와 섹션 조합은 신규 RecommendedSectionType으로 매핑된다")
     fun shouldMapVisibilityToAudioSectionTypes() {
@@ -186,6 +226,32 @@ class AudioRecommendationQueryServiceTest {
         return Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.now()
     }
 
+    private fun member(id: Long): Member {
+        return Member(
+            email = "viewer$id@test.com",
+            password = "password",
+            nickname = "viewer$id",
+            role = MemberRole.USER
+        ).apply {
+            this.id = id
+        }
+    }
+
+    private fun audioCard(id: Long): AudioCard {
+        return AudioCard(
+            audioContentId = id,
+            title = "audio$id",
+            duration = "00:01",
+            imageUrl = "https://cdn.test/audio$id.png",
+            price = id.toInt(),
+            isAdult = false,
+            isPointAvailable = true,
+            isFirstContent = true,
+            isOriginalSeries = false,
+            creatorNickname = "creator$id"
+        )
+    }
+
     private fun snapshot(sectionType: RecommendedSectionType, targetId: Long): RecommendationSnapshotRecord {
         return RecommendationSnapshotRecord(
             sectionType = sectionType,

src/test/kotlin/kr/co/vividnext/sodalive/v2/content/recommendation/application/AudioRecommendationSnapshotRefreshServiceTest.kt

@@ -30,7 +30,7 @@ class AudioRecommendationSnapshotRefreshServiceTest {
             newAndHotWindowStart,
             snapshotAt,
             AudioRecommendationVisibility.SAFE,
-            AudioRecommendationSnapshotRefreshService.NEW_AND_HOT_LIMIT
+            AudioRecommendationSnapshotRefreshService.NEW_AND_HOT_SNAPSHOT_LIMIT
         )
         Mockito.verify(queryPort).findMostCommentedSnapshots(
             mostCommentedWindowStart,
@@ -66,7 +66,7 @@ class AudioRecommendationSnapshotRefreshServiceTest {
             newAndHotWindowStart,
             snapshotAt,
             AudioRecommendationVisibility.SAFE,
-            AudioRecommendationSnapshotRefreshService.NEW_AND_HOT_LIMIT
+            AudioRecommendationSnapshotRefreshService.NEW_AND_HOT_SNAPSHOT_LIMIT
         )
         Mockito.verify(queryPort).findMostCommentedSnapshots(
             mostCommentedWindowStart,
@@ -81,4 +81,27 @@ class AudioRecommendationSnapshotRefreshServiceTest {
             AudioRecommendationSnapshotRefreshService.RECOMMENDED_AUDIO_LIMIT
         )
     }
+
+    @Test
+    @DisplayName("New & Hot 스냅샷은 visibility별 100개 후보를 저장한다")
+    fun shouldRequestOneHundredNewAndHotSnapshotsPerVisibility() {
+        val now = LocalDateTime.of(2026, 6, 27, 0, 0, 0)
+        val snapshotAt = LocalDateTime.of(2026, 6, 26, 23, 59, 59)
+        val windowStart = LocalDateTime.of(2026, 6, 24, 0, 0, 0)
+
+        service.refreshDailySnapshots(now)
+
+        Mockito.verify(queryPort).findNewAndHotSnapshots(
+            windowStart,
+            snapshotAt,
+            AudioRecommendationVisibility.SAFE,
+            100
+        )
+        Mockito.verify(queryPort).findNewAndHotSnapshots(
+            windowStart,
+            snapshotAt,
+            AudioRecommendationVisibility.ALL,
+            100
+        )
+    }
 }

src/test/kotlin/kr/co/vividnext/sodalive/v2/recommendation/adapter/out/persistence/DefaultHomeRecommendationQueryRepositoryTest.kt

@@ -44,11 +44,15 @@ import kr.co.vividnext.sodalive.v2.recommendation.port.out.HomePopularCommunityR
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
+import org.mockito.ArgumentMatchers.any
+import org.mockito.ArgumentMatchers.anyString
+import org.mockito.Mockito
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
 import org.springframework.context.annotation.Import
 import java.time.LocalDateTime
 import javax.persistence.EntityManager
+import javax.persistence.Query
 
 @DataJpaTest(
     properties = [
@@ -99,8 +103,8 @@ class DefaultHomeRecommendationQueryRepositoryTest @Autowired constructor(
         val oldest = saveLiveRoom(creator, baseAt, channelName = "paged-live-oldest", isAdult = false)
         flushAndClear()
 
-        val page0 = repository.findLiveRecommendations(offset = 0, limit = 3, includeAdultLives = false)
+        val page0 = repository.findLiveRecommendations(offset = 0L, limit = 3, includeAdultLives = false)
-        val page1 = repository.findLiveRecommendations(offset = 2, limit = 3, includeAdultLives = false)
+        val page1 = repository.findLiveRecommendations(offset = 2L, limit = 3, includeAdultLives = false)
 
         assertEquals(listOf(newest.id, middle.id, oldest.id), page0.map { it.liveRoomId })
         assertEquals(listOf(oldest.id), page1.map { it.liveRoomId })
@@ -1032,8 +1036,8 @@ class DefaultHomeRecommendationQueryRepositoryTest @Autowired constructor(
         updateCreatedAt("AudioContentLike", like.id!!, now.minusHours(1))
         flushAndClear()
 
-        val page0 = repository.findRecentDebutCreators(now, offset = 0, limit = 2, includeAdultContents = false)
+        val page0 = repository.findRecentDebutCreators(now, offset = 0L, limit = 2, includeAdultContents = false)
-        val page1 = repository.findRecentDebutCreators(now, offset = 1, limit = 2, includeAdultContents = false)
+        val page1 = repository.findRecentDebutCreators(now, offset = 1L, limit = 2, includeAdultContents = false)
 
         assertEquals(listOf(normalNewest.id, normalOldest.id), page0.map { it.creatorId })
         assertEquals(listOf(normalOldest.id), page1.map { it.creatorId })
@@ -1071,9 +1075,9 @@ class DefaultHomeRecommendationQueryRepositoryTest @Autowired constructor(
         saveAudioContent(creator3, now.minusDays(5), isActive = true)
         flushAndClear()
 
-        val page0 = repository.findRecentDebutCreators(now, offset = 0, limit = 1, includeAdultContents = false)
+        val page0 = repository.findRecentDebutCreators(now, offset = 0L, limit = 1, includeAdultContents = false)
-        val page1 = repository.findRecentDebutCreators(now, offset = 1, limit = 1, includeAdultContents = false)
+        val page1 = repository.findRecentDebutCreators(now, offset = 1L, limit = 1, includeAdultContents = false)
-        val page2 = repository.findRecentDebutCreators(now, offset = 2, limit = 1, includeAdultContents = false)
+        val page2 = repository.findRecentDebutCreators(now, offset = 2L, limit = 1, includeAdultContents = false)
 
         val pagedCreatorIds = (page0 + page1 + page2).map { it.creatorId }
         assertEquals(setOf(creator1.id, creator2.id, creator3.id), pagedCreatorIds.toSet())
@@ -1157,13 +1161,71 @@ class DefaultHomeRecommendationQueryRepositoryTest @Autowired constructor(
         val oldest = saveAudioContent(oldestCreator, now.minusDays(21), isActive = true, isAdult = false)
         flushAndClear()
 
-        val page0 = repository.findFirstAudioContents(now, offset = 0, limit = 2, includeAdultContents = false)
+        val page0 = repository.findFirstAudioContents(now, offset = 0L, limit = 2, includeAdultContents = false)
-        val page1 = repository.findFirstAudioContents(now, offset = 1, limit = 2, includeAdultContents = false)
+        val page1 = repository.findFirstAudioContents(now, offset = 1L, limit = 2, includeAdultContents = false)
 
         assertEquals(listOf(newest.id, oldest.id), page0.map { it.contentId })
         assertEquals(listOf(oldest.id), page1.map { it.contentId })
     }
 
+    @Test
+    @DisplayName("첫 오디오 콘텐츠는 성인 여부와 오리지널 시리즈 여부를 함께 조회한다")
+    fun shouldMapFirstAudioContentAdultAndOriginalSeriesFlags() {
+        val now = LocalDateTime.of(2026, 5, 31, 10, 0)
+        val creator = saveMember("first-audio-flags", MemberRole.CREATOR)
+        val content = saveAudioContent(creator, now.minusDays(1), isActive = true, isAdult = false)
+        val series = saveSeries("first-audio-original-series", creator, isActive = true).apply {
+            isOriginal = true
+        }
+        saveSeriesContent(series, content)
+        updateCreatedAt("AudioContent", content.id!!, now.minusDays(1))
+        flushAndClear()
+
+        val contents = repository.findFirstAudioContents(now, limit = 10)
+
+        assertEquals(false, contents.single().isAdult)
+        assertEquals(true, contents.single().isOriginalSeries)
+    }
+
+    @Test
+    @DisplayName("첫 오디오 콘텐츠 native query의 숫자 Boolean 값을 매핑한다")
+    fun shouldMapNumericNativeBooleanFromFirstAudioContentRows() {
+        val mockEntityManager = Mockito.mock(EntityManager::class.java)
+        val mockQuery = Mockito.mock(Query::class.java)
+        val repository = DefaultHomeRecommendationQueryRepository(
+            JPAQueryFactory(mockEntityManager),
+            mockEntityManager
+        )
+        Mockito.`when`(mockEntityManager.createNativeQuery(anyString())).thenReturn(mockQuery)
+        Mockito.`when`(mockQuery.setParameter(anyString(), any())).thenReturn(mockQuery)
+        Mockito.`when`(mockQuery.resultList).thenReturn(
+            listOf(
+                arrayOf(
+                    1L,
+                    2L,
+                    "creator",
+                    null,
+                    "title",
+                    0,
+                    null,
+                    true,
+                    false,
+                    1
+                )
+            )
+        )
+
+        val contents = repository.findFirstAudioContents(
+            now = LocalDateTime.of(2026, 6, 27, 10, 0),
+            offset = 0L,
+            limit = 1,
+            memberId = null,
+            includeAdultContents = false
+        )
+
+        assertEquals(true, contents.single().isOriginalSeries)
+    }
+
     @Test
     @DisplayName("첫 오디오 콘텐츠는 회원과 크리에이터의 양방향 차단 관계를 제외한다")
     fun shouldExcludeBidirectionalBlockedCreatorsFromFirstAudioContents() {
@@ -1196,9 +1258,9 @@ class DefaultHomeRecommendationQueryRepositoryTest @Autowired constructor(
         val content3 = saveAudioContent(creator3, now.minusDays(5), isActive = true)
         flushAndClear()
 
-        val page0 = repository.findFirstAudioContents(now, offset = 0, limit = 1, includeAdultContents = false)
+        val page0 = repository.findFirstAudioContents(now, offset = 0L, limit = 1, includeAdultContents = false)
-        val page1 = repository.findFirstAudioContents(now, offset = 1, limit = 1, includeAdultContents = false)
+        val page1 = repository.findFirstAudioContents(now, offset = 1L, limit = 1, includeAdultContents = false)
-        val page2 = repository.findFirstAudioContents(now, offset = 2, limit = 1, includeAdultContents = false)
+        val page2 = repository.findFirstAudioContents(now, offset = 2L, limit = 1, includeAdultContents = false)
 
         val pagedContentIds = (page0 + page1 + page2).map { it.contentId }
         assertEquals(setOf(content1.id, content2.id, content3.id), pagedContentIds.toSet())

src/test/kotlin/kr/co/vividnext/sodalive/v2/recommendation/application/HomeRecommendationQueryServiceTest.kt

@@ -615,7 +615,7 @@ class HomeRecommendationQueryServiceTest {
 
     private class FakeHomeRecommendationQueryPort : HomeRecommendationQueryPort {
         var liveLimit: Int? = null
-        var liveOffset: Int? = null
+        var liveOffset: Long? = null
         var liveMemberId: Long? = null
         var liveIncludeAdultLives: Boolean? = null
         var bannerLimit: Int? = null
@@ -625,12 +625,12 @@ class HomeRecommendationQueryServiceTest {
         var activeCreatorIncludeAdultActivities: Boolean? = null
         var recentDebutNow: LocalDateTime? = null
         var recentDebutLimit: Int? = null
-        var recentDebutOffset: Int? = null
+        var recentDebutOffset: Long? = null
         var recentDebutMemberId: Long? = null
         var recentDebutIncludeAdultContents: Boolean? = null
         var firstAudioNow: LocalDateTime? = null
         var firstAudioLimit: Int? = null
-        var firstAudioOffset: Int? = null
+        var firstAudioOffset: Long? = null
         var firstAudioMemberId: Long? = null
         var firstAudioIncludeAdultContents: Boolean? = null
         var aiCharacterDetailIds: List<Long> = emptyList()
@@ -688,7 +688,9 @@ class HomeRecommendationQueryServiceTest {
                 title = "first-audio",
                 price = 10,
                 coverImage = "first-audio.png",
-                isPointAvailable = true
+                isPointAvailable = true,
+                isAdult = false,
+                isOriginalSeries = false
             )
         )
         var aiCharacterDetails: List<HomeAiCharacterRecommendationRecord> = emptyList()
@@ -699,7 +701,7 @@ class HomeRecommendationQueryServiceTest {
         var genreCreatorRecommendations: List<HomeGenreCreatorRecommendationGroup> = emptyList()
 
         override fun findLiveRecommendations(
-            offset: Int,
+            offset: Long,
             limit: Int,
             memberId: Long?,
             includeAdultLives: Boolean
@@ -730,7 +732,7 @@ class HomeRecommendationQueryServiceTest {
 
         override fun findRecentDebutCreators(
             now: LocalDateTime,
-            offset: Int,
+            offset: Long,
             limit: Int,
             memberId: Long?,
             includeAdultContents: Boolean
@@ -745,7 +747,7 @@ class HomeRecommendationQueryServiceTest {
 
         override fun findFirstAudioContents(
             now: LocalDateTime,
-            offset: Int,
+            offset: Long,
             limit: Int,
             memberId: Long?,
             includeAdultContents: Boolean
@@ -821,7 +823,7 @@ private class FakeHomeRecommendationSnapshotPort : RecommendationSnapshotPort {
 
     override fun findLatestSnapshots(
         sectionType: RecommendedSectionType,
-        offset: Int,
+        offset: Long,
         limit: Int
     ): List<RecommendationSnapshotRecord> {
         val latestSnapshotAt = snapshots
@@ -832,8 +834,8 @@ private class FakeHomeRecommendationSnapshotPort : RecommendationSnapshotPort {
             .filter { it.sectionType == sectionType && it.snapshotAt == latestSnapshotAt }
             .sortedWith(compareByDescending<RecommendationSnapshotRecord> { it.score }.thenBy { it.randomTieBreaker })
 
-        if (offset == 0 && limit == Int.MAX_VALUE) return all
+        if (offset == 0L && limit == Int.MAX_VALUE) return all
-        return all.drop(offset).take(limit)
+        return all.drop(offset.toInt()).take(limit)
     }
 
     override fun replaceSnapshots(

src/test/kotlin/kr/co/vividnext/sodalive/v2/recommendation/application/RecommendationSnapshotRefreshServiceTest.kt

@@ -256,7 +256,7 @@ private class FakeRecommendationSnapshotPort : RecommendationSnapshotPort {
 
     override fun findLatestSnapshots(
         sectionType: RecommendedSectionType,
-        offset: Int,
+        offset: Long,
         limit: Int
     ): List<RecommendationSnapshotRecord> {
         val latestSnapshotAt = snapshots
@@ -267,8 +267,8 @@ private class FakeRecommendationSnapshotPort : RecommendationSnapshotPort {
             .filter { it.sectionType == sectionType && it.snapshotAt == latestSnapshotAt }
             .sortedWith(compareByDescending<RecommendationSnapshotRecord> { it.score }.thenBy { it.randomTieBreaker })
 
-        if (offset == 0 && limit == Int.MAX_VALUE) return all
+        if (offset == 0L && limit == Int.MAX_VALUE) return all
-        return all.drop(offset).take(limit)
+        return all.drop(offset.toInt()).take(limit)
     }
 
     override fun replaceSnapshots(