feat(home): 첫 오디오 콘텐츠 가격을 응답한다

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

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

@@ -826,201 +826,51 @@ class DefaultHomeRecommendationQueryRepository(
         genreLimit: Int,
         creatorLimit: Int
     ): List<HomeGenreCreatorRecommendationGroup> {
-        val groups = mutableListOf<HomeGenreCreatorRecommendationGroup>()
-        val selectedGenreIds = mutableSetOf<Long>()
-
-        val viewedTargets = findViewedGenreRecommendationTargets(
+        val genres = findGenreRecommendationTargets(
             memberId = memberId,
             includeAdultGenres = includeAdultGenres,
-            targetLimit = genreLimit
+            targetLimit = (genreLimit * creatorLimit).coerceAtLeast(genreLimit)
         )
 
-        viewedTargets.forEach { target ->
-            groups.add(toGenreCreatorRecommendationGroup(target, memberId, includeAdultGenres, creatorLimit))
-            selectedGenreIds.add(target.id)
-        }
-
-        fillFallbackGenreCreatorGroups(
-            groups = groups,
-            selectedGenreIds = selectedGenreIds,
+        return genres.asSequence().mapNotNull { genre ->
+            val creators = findCreatorsByGenre(
+                genreId = genre.id,
                 memberId = memberId,
                 includeAdultGenres = includeAdultGenres,
-            genreLimit = genreLimit,
                 creatorLimit = creatorLimit
             )
-
-        return groups
+            creators.takeIf { it.isNotEmpty() }?.let {
+                HomeGenreCreatorRecommendationGroup(
+                    genreId = genre.id,
+                    genreName = genre.name,
+                    creators = it
+                )
+            }
+        }.toList()
     }
 
-    private fun findViewedGenreRecommendationTargets(
+    private fun findGenreRecommendationTargets(
         memberId: Long?,
         includeAdultGenres: Boolean,
         targetLimit: Int
     ): List<GenreRecommendationTarget> {
-        if (memberId == null || targetLimit <= 0) return emptyList()
-
-        val sql = """
-            select ct.id,
-                   ct.theme as genre
-            from content_theme ct
-            join (
-                select distinct c.theme_id
-                from creator_content_view_history ccvh
-                join content c on c.id = ccvh.content_id
-                where ccvh.member_id = :memberId
-            ) viewed on viewed.theme_id = ct.id
-            where ct.is_active = true
-              and ${eligibleGenreExistsSql()}
-            order by rand() asc
-            limit :targetLimit
-        """.trimIndent()
-
-        val query = entityManager.createNativeQuery(sql)
-            .setParameter("memberId", memberId)
-            .setParameter("includeAdultGenres", includeAdultGenres)
-            .setParameter("targetLimit", targetLimit)
-
-        @Suppress("UNCHECKED_CAST")
-        val rows = query.resultList as List<Array<Any?>>
-
-        return rows.map { row ->
-            GenreRecommendationTarget(
-                id = (row[0] as Number).toLong(),
-                name = row[1] as String,
-                isViewed = true
-            )
-        }
-    }
-
-    private fun fillFallbackGenreCreatorGroups(
-        groups: MutableList<HomeGenreCreatorRecommendationGroup>,
-        selectedGenreIds: MutableSet<Long>,
-        memberId: Long?,
-        includeAdultGenres: Boolean,
-        genreLimit: Int,
-        creatorLimit: Int
-    ) {
-        val fullTargets = findFallbackGenreRecommendationTargets(
-            memberId = memberId,
-            includeAdultGenres = includeAdultGenres,
-            excludedGenreIds = selectedGenreIds,
-            targetLimit = (genreLimit * creatorLimit).coerceAtLeast(genreLimit),
-            minCreatorCount = creatorLimit
-        )
-
-        fullTargets.forEach { target ->
-            groups.add(toGenreCreatorRecommendationGroup(target, memberId, includeAdultGenres, creatorLimit))
-            selectedGenreIds.add(target.id)
-        }
-        val partialTargets = findFallbackGenreRecommendationTargets(
-            memberId = memberId,
-            includeAdultGenres = includeAdultGenres,
-            excludedGenreIds = selectedGenreIds,
-            targetLimit = (genreLimit * creatorLimit).coerceAtLeast(genreLimit),
-            minCreatorCount = 1
-        )
-
-        partialTargets.forEach { target ->
-            groups.add(toGenreCreatorRecommendationGroup(target, memberId, includeAdultGenres, creatorLimit))
-            selectedGenreIds.add(target.id)
-        }
-    }
-
-    private fun findFallbackGenreRecommendationTargets(
-        memberId: Long?,
-        includeAdultGenres: Boolean,
-        excludedGenreIds: Set<Long>,
-        targetLimit: Int,
-        minCreatorCount: Int
-    ): List<GenreRecommendationTarget> {
-        if (targetLimit <= 0) return emptyList()
-
-        val excludedClause = if (excludedGenreIds.isEmpty()) "" else "and ct.id not in (:excludedGenreIds)"
         val sql = """
             select selected.id,
                    selected.genre
             from (
                 select ct.id,
                        ct.theme as genre,
-                       count(distinct m.id) as creator_count,
+                       case when viewed.theme_id is null then 1 else 0 end as source_rank,
                        rand() as random_tie_breaker
                 from content_theme ct
-                join content c on c.theme_id = ct.id
-                join member m on m.id = c.member_id
+                left join (
+                    select distinct c.theme_id
+                    from creator_content_view_history ccvh
+                    join content c on c.id = ccvh.content_id
+                    where (:memberId is not null and ccvh.member_id = :memberId)
+                ) viewed on viewed.theme_id = ct.id
                 where ct.is_active = true
-                  $excludedClause
-                  and c.is_active = true
-                  and (:includeAdultGenres = true or c.is_adult = false)
-                  and m.is_active = true
-                  and m.role = 'CREATOR'
-                  and not exists (
-                      select 1
-                      from creator_following cf
-                      where :memberId is not null
-                        and cf.member_id = :memberId
-                        and cf.creator_id = m.id
-                        and cf.is_active = true
-                  )
-                  and not exists (
-                      select 1
-                      from block_member bm
-                      where :memberId is not null
-                        and bm.is_active = true
-                        and (
-                            (bm.member_id = :memberId and bm.blocked_member_id = m.id)
-                            or (bm.member_id = m.id and bm.blocked_member_id = :memberId)
-                        )
-                  )
-                group by ct.id, ct.theme
-                having count(distinct m.id) >= :minCreatorCount
-            ) selected
-            order by selected.random_tie_breaker asc
-            limit :targetLimit
-        """.trimIndent()
-
-        val query = entityManager.createNativeQuery(sql)
-            .setParameter("memberId", memberId)
-            .setParameter("includeAdultGenres", includeAdultGenres)
-            .setParameter("targetLimit", targetLimit)
-            .setParameter("minCreatorCount", minCreatorCount)
-
-        if (excludedGenreIds.isNotEmpty()) {
-            query.setParameter("excludedGenreIds", excludedGenreIds)
-        }
-
-        @Suppress("UNCHECKED_CAST")
-        val rows = query.resultList as List<Array<Any?>>
-
-        return rows.map { row ->
-            GenreRecommendationTarget(
-                id = (row[0] as Number).toLong(),
-                name = row[1] as String
-            )
-        }
-    }
-
-    private fun toGenreCreatorRecommendationGroup(
-        target: GenreRecommendationTarget,
-        memberId: Long?,
-        includeAdultGenres: Boolean,
-        creatorLimit: Int
-    ): HomeGenreCreatorRecommendationGroup {
-        return HomeGenreCreatorRecommendationGroup(
-            genreId = target.id,
-            genreName = target.name,
-            isViewedTheme = target.isViewed,
-            creators = findCreatorsByGenre(
-                genreId = target.id,
-                memberId = memberId,
-                includeAdultGenres = includeAdultGenres,
-                creatorLimit = creatorLimit
-            )
-        )
-    }
-
-    private fun eligibleGenreExistsSql(): String {
-        return """
-            exists (
+                  and exists (
                       select 1
                       from content c
                       join member m on m.id = c.member_id
@@ -1048,7 +898,25 @@ class DefaultHomeRecommendationQueryRepository(
                               )
                         )
                    )
+            ) selected
+            order by selected.source_rank asc, selected.random_tie_breaker asc
+            limit :targetLimit
         """.trimIndent()
+
+        val query = entityManager.createNativeQuery(sql)
+            .setParameter("memberId", memberId)
+            .setParameter("includeAdultGenres", includeAdultGenres)
+            .setParameter("targetLimit", targetLimit)
+
+        @Suppress("UNCHECKED_CAST")
+        val rows = query.resultList as List<Array<Any?>>
+
+        return rows.map { row ->
+            GenreRecommendationTarget(
+                id = (row[0] as Number).toLong(),
+                name = row[1] as String
+            )
+        }
     }
 
     private fun findCreatorsByGenre(
@@ -1262,7 +1130,6 @@ class DefaultHomeRecommendationQueryRepository(
 
     private data class GenreRecommendationTarget(
         val id: Long,
-        val name: String,
-        val isViewed: Boolean = false
+        val name: String
     )
 }

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

@@ -116,38 +116,14 @@ class HomeRecommendationQueryService(
         creatorLimit: Int = DEFAULT_GENRE_CREATOR_CREATOR_LIMIT
     ): List<HomeGenreCreatorRecommendationGroup> {
         val selectedCreatorIds = mutableSetOf<Long>()
-        val partialFallbackGroups = mutableListOf<HomeGenreCreatorRecommendationGroup>()
-        val selectedGroups = mutableListOf<HomeGenreCreatorRecommendationGroup>()
+        val candidateLimit = genreLimit * creatorLimit
 
-        queryPort.findGenreCreatorRecommendations(memberId, includeAdultGenres, genreLimit, creatorLimit)
-            .forEach { group ->
-                if (selectedGroups.size >= genreLimit) return@forEach
-
-                val creators = group.creators.filter { it.creatorId !in selectedCreatorIds }.take(creatorLimit)
-                if (creators.isEmpty()) return@forEach
-
-                val deduplicatedGroup = group.copy(creators = creators)
-                if (group.isViewedTheme || creators.size == creatorLimit) {
-                    selectedGroups.add(deduplicatedGroup)
-                    selectedCreatorIds.addAll(creators.map { it.creatorId })
-                } else {
-                    partialFallbackGroups.add(group)
+        return queryPort.findGenreCreatorRecommendations(memberId, includeAdultGenres, genreLimit, candidateLimit)
+            .map { group ->
+                group.copy(creators = group.creators.filter { selectedCreatorIds.add(it.creatorId) }.take(creatorLimit))
             }
-            }
-
-        if (selectedGroups.size < genreLimit) {
-            partialFallbackGroups.forEach { group ->
-                if (selectedGroups.size >= genreLimit) return@forEach
-
-                val creators = group.creators.filter { it.creatorId !in selectedCreatorIds }.take(creatorLimit)
-                if (creators.isEmpty()) return@forEach
-
-                selectedGroups.add(group.copy(creators = creators))
-                selectedCreatorIds.addAll(creators.map { it.creatorId })
-            }
-        }
-
-        return selectedGroups.take(genreLimit)
+            .filter { it.creators.isNotEmpty() }
+            .take(genreLimit)
     }
 
     fun resolveAudioContentActivityType(theme: String): RecommendedActivityType {

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

@@ -165,8 +165,7 @@ data class HomePopularCommunityRecommendationRecord(
 data class HomeGenreCreatorRecommendationGroup(
     val genreId: Long,
     val genreName: String,
-    val creators: List<HomeGenreCreatorRecommendationRecord>,
-    val isViewedTheme: Boolean = false
+    val creators: List<HomeGenreCreatorRecommendationRecord>
 )
 
 data class HomeGenreCreatorRecommendationRecord(

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

@@ -1504,95 +1504,8 @@ class DefaultHomeRecommendationQueryRepositoryTest @Autowired constructor(
     }
 
     @Test
-    @DisplayName("조회 이력이 없으면 크리에이터 8명을 채울 수 있는 콘텐츠 테마 후보를 먼저 반환한다")
-    fun shouldRecommendFullRandomThemeCandidatesFirstWhenViewHistoryDoesNotExist() {
-        repeat(5) { themeIndex ->
-            val theme = saveTheme("no-history-underfilled-theme-$themeIndex")
-            saveAudioContent(
-                saveMember("no-history-underfilled-creator-$themeIndex", MemberRole.CREATOR),
-                LocalDateTime.of(2026, 5, 30, 10, 0).plusMinutes(themeIndex.toLong()),
-                isActive = true,
-                theme = theme
-            )
-        }
-        repeat(5) { themeIndex ->
-            val theme = saveTheme("no-history-full-theme-$themeIndex")
-            repeat(8) { creatorIndex ->
-                saveAudioContent(
-                    saveMember("no-history-full-$themeIndex-creator-$creatorIndex", MemberRole.CREATOR),
-                    LocalDateTime.of(2026, 5, 30, 11, 0).plusMinutes((themeIndex * 10 + creatorIndex).toLong()),
-                    isActive = true,
-                    theme = theme
-                )
-            }
-        }
-        flushAndClear()
-
-        val recommendations = repository.findGenreCreatorRecommendations(
-            memberId = null,
-            includeAdultGenres = false,
-            genreLimit = 5,
-            creatorLimit = 8
-        )
-
-        assertEquals(true, recommendations.size >= 5)
-        assertEquals(true, recommendations.take(5).all { it.genreName.startsWith("no-history-full-theme-") })
-        assertEquals(true, recommendations.take(5).all { it.creators.size == 8 })
-    }
-
-    @Test
-    @DisplayName("조회 이력 콘텐츠 테마는 8명이 되지 않아도 후보에 포함하고 부족한 장르는 8명 보유 테마 후보로 채운다")
-    fun shouldKeepViewedThemeCandidateEvenWhenUnderfilledAndReturnFullRandomThemeCandidates() {
-        val viewer = saveMember("viewed-partial-viewer", MemberRole.USER)
-        val viewedTheme = saveTheme("viewed-partial-theme")
-        val viewedContent = saveAudioContent(
-            saveMember("viewed-partial-creator", MemberRole.CREATOR),
-            LocalDateTime.of(2026, 5, 30, 10, 0),
-            isActive = true,
-            theme = viewedTheme
-        )
-        repeat(5) { themeIndex ->
-            val theme = saveTheme("viewed-fill-full-theme-$themeIndex")
-            repeat(8) { creatorIndex ->
-                saveAudioContent(
-                    saveMember("viewed-fill-full-$themeIndex-creator-$creatorIndex", MemberRole.CREATOR),
-                    LocalDateTime.of(2026, 5, 30, 11, 0).plusMinutes((themeIndex * 10 + creatorIndex).toLong()),
-                    isActive = true,
-                    theme = theme
-                )
-            }
-        }
-        entityManager.persist(
-            CreatorContentViewHistory(
-                memberId = viewer.id!!,
-                contentId = viewedContent.id!!,
-                genreId = 999L,
-                viewedAt = LocalDateTime.of(2026, 5, 31, 10, 0)
-            )
-        )
-        flushAndClear()
-
-        val recommendations = repository.findGenreCreatorRecommendations(
-            memberId = viewer.id!!,
-            includeAdultGenres = false,
-            genreLimit = 5,
-            creatorLimit = 8
-        )
-
-        assertEquals(true, recommendations.size >= 5)
-        assertEquals(true, recommendations.any { it.genreId == viewedTheme.id && it.creators.size == 1 })
-        assertEquals(
-            true,
-            recommendations
-                .filter { it.genreId != viewedTheme.id }
-                .take(4)
-                .all { it.genreName.startsWith("viewed-fill-full-theme-") && it.creators.size == 8 }
-        )
-    }
-
-    @Test
-    @DisplayName("장르 기반 크리에이터 추천 repository는 service 보충용 후보 그룹을 genreLimit보다 많이 반환한다")
-    fun shouldReturnMoreCandidateGroupsThanFinalGenreLimitForServiceBackfill() {
+    @DisplayName("장르 기반 크리에이터 추천은 서비스 중복 제거용 후보 그룹을 genreLimit보다 많이 반환한다")
+    fun shouldReturnMoreCandidateGroupsThanFinalGenreLimitForServiceDeduplicationBackfill() {
         val sharedCreator = saveMember("candidate-shared", MemberRole.CREATOR)
         val backfillCreator = saveMember("candidate-backfill", MemberRole.CREATOR)
         val firstTheme = saveTheme("candidate-first-theme")

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

@@ -374,7 +374,7 @@ class HomeRecommendationQueryServiceTest {
         assertEquals(100L, port.genreCreatorMemberId)
         assertEquals(true, port.genreCreatorIncludeAdultGenres)
         assertEquals(5, port.genreCreatorGenreLimit)
-        assertEquals(8, port.genreCreatorCreatorLimit)
+        assertEquals(40, port.genreCreatorCreatorLimit)
         assertEquals(listOf(10L, 11L), recommendations[0].creators.map { it.creatorId })
         assertEquals(listOf(12L, 13L), recommendations[1].creators.map { it.creatorId })
     }
@@ -429,150 +429,6 @@ class HomeRecommendationQueryServiceTest {
         assertEquals(false, recommendations.any { it.creators.isEmpty() })
     }
 
-    @Test
-    @DisplayName("장르 기반 크리에이터 추천은 중복 제거 후 랜덤 보충 장르가 8명이 되지 않으면 뒤 후보로 대체한다")
-    fun shouldBackfillRandomThemesWhenCreatorDeduplicationMakesThemeUnderfilled() {
-        val sharedCreators = (1L..8L).map { creatorId ->
-            HomeGenreCreatorRecommendationRecord(
-                creatorId = creatorId,
-                creatorNickname = "shared-$creatorId",
-                creatorProfileImage = null
-            )
-        }
-        val uniqueCreators = (101L..108L).map { creatorId ->
-            HomeGenreCreatorRecommendationRecord(
-                creatorId = creatorId,
-                creatorNickname = "unique-$creatorId",
-                creatorProfileImage = null
-            )
-        }
-        port.genreCreatorRecommendations = listOf(
-            HomeGenreCreatorRecommendationGroup(
-                genreId = 1L,
-                genreName = "first-random-theme",
-                creators = sharedCreators
-            ),
-            HomeGenreCreatorRecommendationGroup(
-                genreId = 2L,
-                genreName = "underfilled-after-dedup-theme",
-                creators = sharedCreators
-            ),
-            HomeGenreCreatorRecommendationGroup(
-                genreId = 3L,
-                genreName = "backfill-random-theme",
-                creators = uniqueCreators
-            )
-        )
-
-        val recommendations = service.findGenreCreatorRecommendations(
-            memberId = null,
-            includeAdultGenres = false,
-            genreLimit = 2,
-            creatorLimit = 8
-        )
-
-        assertEquals(listOf(1L, 3L), recommendations.map { it.genreId })
-        assertEquals(true, recommendations.all { it.creators.size == 8 })
-    }
-
-    @Test
-    @DisplayName("장르 기반 크리에이터 추천은 보류된 부분 후보의 크리에이터를 뒤 충분 후보에서 중복 제거하지 않는다")
-    fun shouldNotConsumeCreatorsFromDeferredPartialFallbackCandidates() {
-        val firstCreators = (1L..8L).map { creatorId ->
-            HomeGenreCreatorRecommendationRecord(
-                creatorId = creatorId,
-                creatorNickname = "first-$creatorId",
-                creatorProfileImage = null
-            )
-        }
-        val partialUniqueCreator = HomeGenreCreatorRecommendationRecord(
-            creatorId = 101L,
-            creatorNickname = "partial-unique",
-            creatorProfileImage = null
-        )
-        val fullBackfillCreators = (101L..108L).map { creatorId ->
-            HomeGenreCreatorRecommendationRecord(
-                creatorId = creatorId,
-                creatorNickname = "full-$creatorId",
-                creatorProfileImage = null
-            )
-        }
-        port.genreCreatorRecommendations = listOf(
-            HomeGenreCreatorRecommendationGroup(
-                genreId = 1L,
-                genreName = "first-random-theme",
-                creators = firstCreators
-            ),
-            HomeGenreCreatorRecommendationGroup(
-                genreId = 2L,
-                genreName = "deferred-partial-theme",
-                creators = firstCreators.take(7) + partialUniqueCreator
-            ),
-            HomeGenreCreatorRecommendationGroup(
-                genreId = 3L,
-                genreName = "full-backfill-theme",
-                creators = fullBackfillCreators
-            )
-        )
-
-        val recommendations = service.findGenreCreatorRecommendations(
-            memberId = null,
-            includeAdultGenres = false,
-            genreLimit = 2,
-            creatorLimit = 8
-        )
-
-        assertEquals(listOf(1L, 3L), recommendations.map { it.genreId })
-        assertEquals((101L..108L).toList(), recommendations[1].creators.map { it.creatorId })
-    }
-
-    @Test
-    @DisplayName("장르 기반 크리에이터 추천은 조회 이력 장르는 중복 제거 후 8명 미만이어도 유지한다")
-    fun shouldKeepViewedThemeWhenCreatorDeduplicationMakesThemeUnderfilled() {
-        val sharedCreators = (1L..8L).map { creatorId ->
-            HomeGenreCreatorRecommendationRecord(
-                creatorId = creatorId,
-                creatorNickname = "shared-$creatorId",
-                creatorProfileImage = null
-            )
-        }
-        val uniqueCreators = (101L..108L).map { creatorId ->
-            HomeGenreCreatorRecommendationRecord(
-                creatorId = creatorId,
-                creatorNickname = "unique-$creatorId",
-                creatorProfileImage = null
-            )
-        }
-        port.genreCreatorRecommendations = listOf(
-            HomeGenreCreatorRecommendationGroup(
-                genreId = 1L,
-                genreName = "first-random-theme",
-                creators = sharedCreators
-            ),
-            HomeGenreCreatorRecommendationGroup(
-                genreId = 2L,
-                genreName = "viewed-theme",
-                creators = sharedCreators + uniqueCreators.first(),
-                isViewedTheme = true
-            ),
-            HomeGenreCreatorRecommendationGroup(
-                genreId = 3L,
-                genreName = "backfill-random-theme",
-                creators = uniqueCreators
-            )
-        )
-
-        val recommendations = service.findGenreCreatorRecommendations(
-            memberId = 100L,
-            includeAdultGenres = false,
-            genreLimit = 2,
-            creatorLimit = 8
-        )
-
-        assertEquals(listOf(1L, 2L), recommendations.map { it.genreId })
-        assertEquals(1, recommendations[1].creators.size)
-    }
-
     private class FakeHomeRecommendationQueryPort : HomeRecommendationQueryPort {
         var liveLimit: Int? = null
         var liveOffset: Int? = null