oh-my-oop 0.2.0

package/lessons/woowacourse-kotlin-blackjack/rosemin928/138-2/353/213/250/352/263/204-/353/270/224/353/236/231/354/236/255.md

@@ -0,0 +1,845 @@
+# PR #138 — [블랙잭 2단계] 비비 미션
+
+- **Reviewee:** [@rosemin928](https://github.com/rosemin928)
+- **PR:** https://github.com/woowacourse/kotlin-blackjack/pull/138
+- **단계:** 2단계
+- **리뷰어:** [@KwonDae](https://github.com/KwonDae) (제이든) — 1단계 #129 동일 reviewer
+- **라인 코멘트:** 20 스레드 — *PR 본문 자가 의문 2개 (8 덱 도메인 룰 자가 학습 + ParticipantCards 책임 이동) + getResult 다형성 + super 키워드 (4 스레드 학습) + value class + @JvmInline 자가 학습 + 재귀 함수 (tailrec) + BlackJackTable 형식 규칙 부산물 자가 인정 + 디미터 법칙 (외부글) + getOrNull 논리오류 처리 + 8 덱 도메인 룰 적용 + 캐싱 (companion lazy) + 인스턴스 변수 2개 묶음 (name+money vs name+cards) 자가 의문*
+- **양 단계 완성 reviewee** (1단계 #129 batch 19 분석 완료 + 2단계 #138 = batch 20 추가).
+
+## 잘한 점 (설계 관점)
+
+### 1. PR 본문 자가 의문 2개 (2025 코호트 자가 학습 정점)
+
+#### 1.1. *8 덱 도메인 룰 자가 학습*
+
+PR 본문:
+
+> *"1단계 merge하며 주신 리뷰 중 `deck을 전부 사용했을 때 어떻게 할 것인가?`를 고민하다가 **블랙잭의 최대 플레이 인원은 8명이다**, **블랙잭은 총 8개의 덱을 사용한다**라는 규칙이 있다는 것을 알게 되었습니다. 따라서 이 도메인 규칙에 따라 Deck 로직을 수정하였습니다! pop 로직을 바꾸지 않으려 해봤지만 결국 바꾸는 방향으로 가게 되었습니다...! 수정한 Deck에 대해 어떻게 생각하시는지 궁금합니다!"*
+
+→ **학생 자가 도메인 룰 학습 + 코드 자가 수정**:
+- 1단계 #129 reviewer (Thread 20) *"deck.pop 예외 처리 = 게임 종료 흐름"* 의문 → 학생 자가 도메인 학습.
+- **블랙잭 카지노 룰 = 8 덱** 자가 학습 + `MAX_DECK_COUNT = 8` 적용.
+
+**MCP `oh-my-oop` *학습 = 시간 두고 반복* 어휘 정점** — *reviewer 한 마디 의문 → 학생 자가 도메인 학습 → 코드 자가 수정 (1단계 → 2단계 사이 학습)*. PR #58 (otter66 *카지노 6덱 메타포 vs 요구사항*) 결의 *반대 시점 (실제 8덱)*. **MCP 룰 `multi-deck-domain-rule` 강화**.
+
+#### 1.2. *ParticipantCards 책임 이동 자가 의문*
+
+PR 본문:
+
+> *"이번에 각 객체들의 역할과 책임에 대해 고민해보다가 `isBust`, `isBlackJack`, `finalScore` 이 세 가지 함수를 ParticipantCards로 옮기게 되었습니다. 위의 3가지를 각 참여자가 가진 카드들의 상태로 볼 수도 있겠다는 생각을 하게 되어 수정했는데 제이든은 어떻게 생각하시는지 궁금합니다!"*
+
+reviewer 칭찬 (Thread 3):
+
+> *"좋습니다 👍 2단계로 오면서 참가자의 카드의 정보를 따로 분리하는 것에 대해 이야기 하려 했는데 이미 반영을 해주셨군요. 참가자가 들고 있는 카드들의 역할을 분리해볼 수 있습니다. 손에 있는 카드들 또한 객체로 취급할 수 있으니까요!"*
+
+→ **학생 자가 책임 이동 (Participant → ParticipantCards)** = *reviewer 가 권유 전에 학생이 자가 추론*. **학습 정점 = reviewer 예상 코멘트를 학생이 선제 적용**.
+
+PR #91·#107·#147·#22·#73·#76·#80·#82·#11·#13·#36·#87 결의 *학생 자가 한계 인정* 와 *반대 시점 (학생이 reviewer 보다 한 발 앞서)*.
+
+### 2. `value class Money(val value: Int)` + `@JvmInline` + 학생 자가 학습
+
+```kotlin
+@JvmInline
+value class Money(val value: Int) {
+    init {
+        require(value >= MINIMUM_BETTING_MONEY) { ERROR_UNDER_MINIMUM_BETTING_MONEY_MESSAGE }
+    }
+    ...
+}
+```
+
+→ **value class + @JvmInline 자가 적용 + 자가 학습 깊이**:
+
+reviewer (Thread 1·10): *"value class 활용이 가능해보이네요! 어떤 상황에서 사용할 수 있을까요?"* + *"`@JvmInline` 어노테이션은 어떤 역할을 하는걸까요?"*
+
+학생 자가 답변:
+
+> *"value class는 함수 호출 및 연산 시, 객체가 아닌 내부 값 자체로 처리되어 참조 비용을 줄이고 실행 속도를 향상시킨다는 장점이 있습니다. (...) `@JvmInline`은 코틀린에서 사용되는 애노테이션 중 하나로 인라인 클래스를 정의할 때 사용됩니다. 인라인 클래스는 **실제 객체를 만들지 않고**, 값을 직접 저장하는 방식으로 동작합니다."*
+
+→ **Kotlin 어휘 깊은 학생 자가 학습 + reviewer 가 *왜* 묻기 + 학생 자가 *답*하기**. PR #117 (parkjiminnnn *property val vs computed property*) 결의 *Kotlin 어휘 자가 학습* 강화. PR #36·#82·#76·#107·#106·#18 결의 *value class 적용* 일치.
+
+**MCP 룰 `value-class-application-and-rationale` 후보** — *value class 사용 시점 + @JvmInline 의도 명시*.
+
+### 3. `enum class GameResult` 멤버 별 수익 책임 분리 — 4 멤버 + 메서드 2개
+
+```kotlin
+enum class GameResult(
+    private val playerMultiplier: Double,
+    private val dealerMultiplier: Double,
+) {
+    WIN(1.0, 1.0),
+    LOSE(-1.0, -1.0),
+    DRAW(0.0, 0.0),
+    BLACKJACK(1.5, 1.0),
+    ;
+
+    fun calculatePlayerProfit(bettingMoney: Money): Double = bettingMoney.value * playerMultiplier
+    fun calculateDealerProfit(bettingMoney: Money): Double = bettingMoney.value * dealerMultiplier
+}
+```
+
+→ **enum 멤버에 playerMultiplier + dealerMultiplier 2 속성 묶음** + **calculatePlayerProfit + calculateDealerProfit 메서드** = *GameResult 가 수익률 계산 책임*. PR #87 (GameOutcome enum + scoreRecord + payoutMultiplier 묶음) 결.
+
+reviewer (Thread 9):
+
+> *"수익률을 계산하는 것은 BlackJackGame 내에서 수행하는 역할일까요? 로또 미션에서와 같이 GameResult 가 수익률을 계산해보는건 어떨까요?"*
+
+→ **로또 미션 결과 객체 결 일관** + **enum 의 책임 강화 (단순 분류 X)** — PR #133·#108·#46·#39·#88·#90·#131 (Lotto rank 자가 결과 계산) 결 합류.
+
+**`BLACKJACK(1.5, 1.0)` 별도 멤버** — *Win + isBlackjack 분기 vs 별도 멤버* 정공. 누적 10+ PR ⭐⭐⭐.
+
+#### 3.1. *Player vs Dealer 수익 부호 일관*
+
+```kotlin
+WIN(1.0, 1.0),   // 둘 다 양수? 의미 양가
+LOSE(-1.0, -1.0), 
+DRAW(0.0, 0.0),
+BLACKJACK(1.5, 1.0),
+```
+
+→ **WIN 둘 다 1.0 = Player.calculateProfit(WIN, money) = +money, Dealer.calculateProfit(WIN, money) = +money**. 
+
+다만 *호출 자리에서 부호 처리* (BlackJackGame.getDealerProfit):
+```kotlin
+fun getDealerProfit(): Double =
+    participants.players.sumOf { player ->
+        val result = participants.dealer.getResult(player)  // ← Dealer 의 결과
+        result.calculateDealerProfit(player.money)
+    }
+```
+
+→ *Dealer.getResult(player) = Dealer 시점 결과* → *Dealer Win 시 +money* → *Dealer 수익 = +money* (정확).
+
+다만 *Player Win = -money for Dealer* — *현재 GameResult.WIN(1.0, 1.0)* 에서 dealerMultiplier = +1.0 → *Player Win 시 Dealer 도 +money* = *룰 와전?*
+
+→ **WIN/LOSE 가 어느 시점 (Player/Dealer)에 적용되는지 명시 X = 양가성 위험**. *부호 일관 (-1.0, +1.0)* 또는 *operator fun not()* (PR #36 결) 활용 가능.
+
+**MCP 룰 `enum-bidirectional-multiplier-ambiguity` 후보** — *enum 에 양쪽 시점 multiplier 보관 = 부호 양가*.
+
+### 4. `Deck` interface + `ShuffledDeck` 구현 + 8 덱 도메인 룰
+
+```kotlin
+interface Deck {
+    fun pop(): TrumpCard
+    fun makeCards(): Deque<TrumpCard>
+}
+
+class ShuffledDeck : Deck {
+    private val deckPool: MutableList<Deque<TrumpCard>> = mutableListOf()
+    private var currentDeckIndex = 0
+
+    init {
+        repeat(MAX_DECK_COUNT) { deckPool.add(makeCards()) }
+    }
+
+    override fun pop(): TrumpCard {
+        val currentDeck = deckPool.getOrNull(currentDeckIndex)
+            ?: throw IllegalArgumentException(ERROR_EMPTY_DECK_MESSAGE)
+        return if (currentDeck.isNotEmpty()) {
+            currentDeck.pop()
+        } else {
+            currentDeckIndex++
+            pop()  // ← 재귀
+        }
+    }
+
+    companion object {
+        private const val MAX_DECK_COUNT = 8
+        private val SHUFFLED_DECK: List<TrumpCard> by lazy {
+            Shape.entries.flatMap { shape ->
+                CardTier.entries.map { tier -> TrumpCard(tier, shape) }
+            }.shuffled()
+        }
+    }
+}
+```
+
+→ **3 가지 정공**:
+
+#### 4.1. *interface 분리 (DIP)*
+
+1단계 #129 reviewer (Thread 9) 의 *Deck 테스트 가능성* 권유 → *interface Deck + ShuffledDeck 구현* 자가 적용 + *2단계 확장*. **MCP 룰 `interface-for-test-substitution` 강화** 누적 5+ PR.
+
+#### 4.2. *재귀 함수 (tailrec 미적용)*
+
+`pop()` 자가 호출 = *재귀*. reviewer (Thread 11·18) *"while 루프도 좋지만, 재귀함수로도 구현해볼 수 있을거에요. kotlin의 tailrec 에 대해 찾아보셔도 좋습니다!"* → 학생 자가 적용 (다만 `tailrec` 키워드 X).
+
+**MCP 룰 `tailrec-optimization-applicability` 후보** — *Kotlin tailrec = 스택 오버플로우 방지*.
+
+#### 4.3. *companion object lazy 캐싱*
+
+reviewer (Thread 4): *"트럼프 카드에는 중복되는 모양과 숫자, 문자가 존재하죠. 이 객체들을 효율적으로 사용할 수 있을까요?"* → 학생 자가 적용 (`SHUFFLED_DECK by lazy`).
+
+→ **lazy initialization + companion object** = *Singleton pool*. 다만 *블랙잭 = 카드 도메인 객체가 8 덱 모두 같은 풀에서 shuffle* = *각 덱이 SHUFFLED_DECK 인스턴스 재사용*. **PR #20·#28·#125·#65·#92·#108·#137·#106·#48·#9·#22·#13·#11·#39·#16·#46·#36·#117·#129 누적 18+ PR Singleton Deck 안티패턴 강화 (다만 정공: interface + lazy 활용)**.
+
+**MCP 룰 `lazy-init-companion-vs-instance-pool` 후보** — *companion lazy = 정적 한 번 초기화*.
+
+### 5. `getOrNull` 활용 — 논리오류 처리
+
+```kotlin
+val currentDeck = deckPool.getOrNull(currentDeckIndex)
+    ?: throw IllegalArgumentException(ERROR_EMPTY_DECK_MESSAGE)
+```
+
+→ reviewer (Thread 5): *"kotlin collection 에는 `getOrNull` 이라는 키워드가 존재합니다. 로또미션에서 [논리오류] 에 대해 학습했을 때 이러한 상황에서 어떻게 처리할 수 있을지 배웠던거 같아요. 어떻게 개선해볼 수 있을까요? 그렇다고 지금 상황이 논리오류 라는것은 아닙니다 :)"*
+
+학생 자가 답변:
+
+> *"1. 수정 전에는 currentDeckIndex가 MAX_DECK_COUNT를 초과하면 반복문이 종료되고 예외가 발생하지만 현재는 MAX_DECK_COUNT를 초과하는 즉시 예외가 발생한다. 2. getOrNull을 사용하여 null을 체크하고 그 경우에 예외를 던지기 때문에 더 안전해졌다."*
+
+→ **Kotlin `getOrNull` = 논리오류 즉시 감지** + **`get(index)` 예외 vs `getOrNull` nullable 비교**. 학생 자가 학습.
+
+**MCP 룰 `get-vs-getOrNull-exception-timing` 후보**.
+
+### 6. `getResult` 다형성 + `super` 키워드 — 4 스레드 학습
+
+```kotlin
+// Participant (공통 로직)
+open fun getResult(other: Participant): GameResult {
+    val myScore = cards.finalScore()
+    val otherScore = other.cards.finalScore()
+    return when {
+        !cards.isBlackJack() && other.cards.isBlackJack() -> GameResult.LOSE
+        cards.isBlackJack() && !other.cards.isBlackJack() -> GameResult.BLACKJACK
+        other.cards.isBust() -> GameResult.WIN
+        myScore > otherScore -> GameResult.WIN
+        myScore < otherScore -> GameResult.LOSE
+        else -> GameResult.DRAW
+    }
+}
+
+// Player (한 가지 경우만)
+override fun getResult(other: Participant): GameResult =
+    when {
+        cards.isBust() -> GameResult.LOSE
+        else -> super.getResult(other)  // ← super 키워드
+    }
+
+// Dealer (한 가지 경우만)
+override fun getResult(other: Participant): GameResult =
+    when {
+        cards.isBust() && !other.cards.isBust() -> GameResult.LOSE
+        else -> super.getResult(other)
+    }
+```
+
+→ **`super` 키워드 활용 = *공통 로직 + 자식 별 한 가지 경우 추가***:
+
+#### 6.1. *4 스레드 학습 흐름 (Thread 8 → 13 → 14 → 19)*
+
+1. **Thread 8 (reviewer)**: *"결과를 판단하는 로직이 게임 규칙상 굉장히 복잡하죠. 다형성을 활용해볼 수 있습니다. 다형성을 이용해서 어떻게 개선할 수 있을까요?"* — *질문*.
+2. **Thread 8 (학생)**: *"`getResult`의 로직을 확인해보니 한 가지의 경우를 제외하고는 플레이어와 딜러의 로직이 동일하다는 것을 알게 되었습니다. (...) 이렇게 변경한 것이 제이든의 의도와 맞게 변경한 것인지는 잘 모르겠어요 🥲 다형성을 이용해 더 개선할 수 있는 방법이 있을까요?"* — *학생 자가 의문*.
+3. **Thread 13 (reviewer)**: *"식으로 다형성을 활용해볼 수 있을거에요 (super 키워드 코드 예시)"* — *답변 코드 예시*.
+4. **Thread 14·19 (reviewer + 학생)**: *Dealer/Player 양쪽 `super.getResult` 호출 자가 적용 + reviewer 확장 권유 (각 자식이 자가 override 로 더 많은 케이스 다룸)*.
+
+→ **양방향 reviewer/학생 토론 + 학생 자가 한계 인정 + reviewer 코드 힌트 + 학생 자가 적용** = *학습 시간성 모범*. PR #87·#117·#129·#137·#151·#133·#146·#147 결 합류.
+
+#### 6.2. *open class + super 어휘*
+
+PR #129 (1단계) *abstract class 추상 메서드 없음 = open class 동치* 결의 *반대 시점* — *getResult 는 open + super 활용* = *공통 로직 보유 + 자식 확장 정공*.
+
+**MCP 룰 `super-keyword-for-shared-logic` 후보** — *부모 open + 자식 super 호출 = 공통 로직 + 자식 확장*.
+
+#### 6.3. *reviewer 추가 권유 (Thread 19)*
+
+> *"버스트의 케이스에 따라 딜러와 참가자가 다른 속성을 지니고 있죠. 이런 부분은 Dealer 와 Player 가 각각 override를 통해 설정을 해줄 수 있습니다. 그 이외에는 지금처럼 추상클래스에 구현을 하면 공통 로직 활용이 가능하죠. 이부분은 미션이 끝나고 한번 해보셔도 도움이 될 것 같아요.*
+>
+> *현재 Participant에 있는 '나' 와 'other' 의 많은 케이스들을 Dealer와 Player로 옮겨 조건문 복잡도를 줄일 수 있을거에요!"*
+
+→ **미션 종료 후 추가 학습 권유** — *학생 부담 최소화 + 학습 시간 인정* 어휘. PR #87·#129·#36 결.
+
+### 7. `BlackJackTable(deck, bettingMoney)` 객체 자가 생성 → 자가 제거
+
+학생 초안:
+```kotlin
+class BlackJackTable(
+    val deck: Deck,
+    private val bettingMoney: Map<Player, Money>,
+) {
+    fun getPlayerBettingMoney(player: Player): Money = ...
+}
+```
+
+→ **`BlackJackTable` 객체 자가 생성 후 *형식 규칙 (인스턴스 변수 2개)* 위해서만 묶음** = *형식 규칙 부산물 인공 객체*. PR #133·#88·#132·#136·#93·#87·#147 누적 결.
+
+reviewer (Thread 15·16):
+
+> *"bettingMoney는 Player에 있음으로써 응집도가 높아진다고 생각해요. 기존처럼 money를 Player가 갖고 있게 된다면 BlackJackTable 객체도 없어질 수 있을까요?"*
+
+> *"BlackJackTable 을 생성함으로써 어느 부분의 역할이 가벼워졌을까요? 처음 이 객체를 본 동료 개발자도 Table에 deck, bettingMoney만 있는걸 쉽게 알아차릴 수 있을까요? 🧐"*
+
+학생 자가 답변:
+
+> *"Table에 deck과 bettingMoney만 있는걸 쉽게 알아차리기는 어려울 것 같아요. 사실 인스턴스 변수를 2개를 유지하기 위해 BlackJackTable을 만들었었는데 Player에서 인스턴스 변수 2개를 유지할 수 있다는 장점을 제외하고는 스스로도 납득이 가는 장점이 크지는 않았던 것 같아요. (...) `돈을 가지고 있는 Player여야 하지 않나?` 라는 의문이 생겼었습니다! 그래서 Money는 Player로 다시 돌려주게 되었습니다!"*
+
+→ **학생 자가 형식 규칙 부산물 인정 + 자가 제거**. **MCP 룰 `instance-variable-limit-artificial-grouping` 강화** 누적 6+ PR ⭐⭐ (#133·#88·#132·#136·#93·#87·#138).
+
+다만 **현재 최종 코드** 는 `Player(name, cards, money)` = *3 변수* — *형식 규칙 위반*? 또는 *cards 가 ParticipantCards 객체로 추출되었으니 *유의미한 추출* OK*. **학생의 자가 판단**: *cards = 진짜 객체 / money = Player 의 도메인 속성 / name = Player 의 도메인 속성* → *형식 규칙 위반 무의미*.
+
+### 8. 디미터 법칙 — table.deck 접근
+
+reviewer (Thread 17):
+
+> *"table이라는 객체가 생기면서 객체 지향 프로그래밍에서 이야기하는 [디미터의 법칙](https://mangkyu.tistory.com/147)에 대해 한번 찾아보셔도 도움이 될 것 같아요 🙂"*
+
+학생 자가 깨달음:
+
+> *"table이 있을 때에는 table 내에서 deck을 가져와야 해서 응집도와 캡슐화를 해치게 되네요... 😢 앞으로 해당 사항 신경 쓰며 구현해보도록 하겠습니다!"*
+
+→ **디미터 법칙 + 외부글 (mangkyu.tistory) + 학생 자가 깨달음**:
+
+#### 8.1. *table.deck 깊이 = 디미터 위반*
+
+`blackJackGame.table.deck.pop()` → *3 단계 위임* = a.b.c.d 위반. 학생 자가 제거 (BlackJackTable 자가 제거).
+
+#### 8.2. *외부글 활용*
+
+`mangkyu.tistory.com/147` 디미터 법칙 — **외부 자료 + 자가 학습** 어휘. PR #87·#21·#117·#129 결의 *외부글 + 자가 학습* 어휘 합류.
+
+**MCP 룰 `law-of-demeter-violation-depth` 강화** 누적 7+ PR.
+
+### 9. `Player.choice` 재귀 함수 자가 적용
+
+```kotlin
+fun choice(
+    deck: Deck,
+    getPlayerChoice: (String) -> Boolean,
+    onPlayerStateUpdated: (Player) -> Unit,
+) {
+    if (!isDrawable()) return
+    if (getPlayerChoice(name)) {
+        receiveCard(deck.pop())
+        onPlayerStateUpdated(this)
+        choice(deck, getPlayerChoice, onPlayerStateUpdated)  // ← 재귀
+    }
+}
+```
+
+→ reviewer (Thread 12): *"이런 부분도 재귀로 구현이 가능할 것 같아요!"* → 학생 자가 적용.
+
+**재귀 = while 의 함수형 변환**. PR #117 (수학적 풀이) + PR #87 (mutableMap → fold) 결의 *명령형 vs 함수형* 어휘 합류.
+
+**MCP 룰 `recursive-vs-while-functional` 후보** — *재귀 = 함수형 정공*.
+
+### 10. 추가 칭찬
+
+- **2단계 카드 책임 분리 자가 적용 (PR 본문 + Thread 3)** — *reviewer 가 권유 전에 학생 선제 적용*.
+- **재귀 함수 활용 칭찬 (Thread 18)** — *"재귀로 잘 구현해주셨네요 👍"*.
+- **모든 20 스레드 학생 자가 답변 + 커밋 SHA + 자가 후속 의문 4+ 회** — *학생 자가 학습 가시화 정점* (PR #117·#129 결 강화).
+
+## 못한 점 (설계 관점)
+
+### 1. `Money(1000)` 최소 금액 검증 — require vs 재입력
+
+학생 초안: `require(value >= 1000)` → 미만 시 예외 던짐 + 프로그램 종료.
+
+reviewer (Thread 2):
+
+> *"require 로 검증을 잘 해주셨어요. 다만, 1000원 이상을 입력해야 하는 룰이 주어졌었나요? (정말 몰라서 하는 질문입니다 ㅎㅎ) 만약 그런 룰이 있다면 조건을 충족하지 못해 프로그램이 종료되어 버린다면 유저 입장에선 어떨까요?"*
+
+학생 자가 적용:
+
+> *"룰이 주어지지는 않았지만 실제 블랙잭 게임에서는 최소 베팅액이 주어진다는 것을 알게 되어 해당 검증을 하게 되었습니다! 최소 금액을 입력하지 않았을 때 프로그램을 종료하는 것보다 **에러 메세지를 주고 다시 입력**할 수 있도록 하는 것이 나을 것 같다고 생각하여 수정하였습니다! inputView에서 runCatching을 통해 검증에서 걸렸을 때 메시지를 출력하고 다시 입력하도록 했습니다!"*
+
+→ **require 예외 vs 재입력 (graceful retry)** — PR #129 (deck.pop 예외 vs graceful shutdown) 결의 *재입력* 변형:
+
+#### 1.1. *3 가지 트레이드오프*
+
+| 안 | 장점 | 단점 |
+|---|---|---|
+| `require` 예외 + 프로그램 종료 (학생 초안) | *invariant 강제 + 코드 간결* | *유저 경험 ↓ (재시도 X)* |
+| `require` + `runCatching` 재입력 (학생 자가 적용) | *유저 경험 ↑ + invariant 강제* | *Controller/View 가 runCatching 처리* |
+| `require` 없이 nullable 반환 | *호출자가 명시적 처리* | *invariant 강제 X (null 무시 가능)* |
+
+**MCP 룰 `require-exception-vs-graceful-retry` 후보** — *invariant 위반 시 종료 vs 재입력*. PR #129·#138 결.
+
+#### 1.2. *블랙잭 도메인 룰 자가 학습*
+
+학생 *"실제 블랙잭 게임에서는 최소 베팅액이 주어진다"* 자가 학습 = *PR 본문 8 덱 룰 학습* 어휘 합류.
+
+### 2. `getAllCards()` 위임 → `cards.take(count)` 직접 — Tell-Don't-Ask
+
+reviewer (Thread 6):
+
+> *"getAllCards() 함수를 거쳐야만 할까요? `cards.take(count)`"*
+
+학생 자가 적용 (`Participant.takeCards(count: Int): List<TrumpCard> = cards.allCards.take(count)`).
+
+→ **위임 메서드 줄임 + Tell-Don't-Ask 정공** — PR #87 (Participant.getName, getCards 위임 6개) 결의 *불필요 위임 메서드 줄임*.
+
+다만 *현재 takeCards 도 cards.allCards.take 호출* = *2 단계 위임 여전*. **`cards.takeFirstN(count)`** 가 더 정공 — *ParticipantCards.takeFirstN 메시지*.
+
+### 3. `choice` 로직 Player ↔ BlackJackGame 이동 — 학생 자가 토론
+
+reviewer (Thread 7):
+
+> *"이 로직들이 Paticipants -> BlackJackGame 으로 옮겨진 배경은 무엇일까요?"*
+
+학생:
+
+> *"`choice` 함수가 Player에 있을 때 `플레이어가 deck 자체를 아예 가지는 것이 아닌가?` 라는 의문이 들었고, 이는 블랙잭 게임에 어울리지 않는 상황이라 생각하여 옮기게 되었었습니다. 하지만 이번 리뷰를 반영하며 해당 로직이 Player와 Participants 내에 있어도 **Deck을 매개변수로 전달받아 필요할 때만 접근**하므로 Player가 Deck을 직접 소유하는 구조가 아니라는 것을 알게 되어 다시 수정하였습니다!"*
+
+→ **메서드 위치 토론 + 학생 자가 의문 + reviewer 의문 + 학생 자가 재정정**:
+
+#### 3.1. *책임 위치 토론*
+
+- **Player.choice(deck, ...)** = *Player 가 자가 결정 + deck 인자 받음 (소유 X)*.
+- **BlackJackGame.choice(player, deck, ...)** = *외부 조정 + 명시적 분리*.
+- **Participants.choice(deck, ...)** = *Participants 일급 컬렉션이 자가 처리* (현재 최종).
+
+학생의 자가 의문 = *"Player 가 deck 을 가지는 것 아닌가?"* → reviewer 의 *"deck 매개변수 전달 = 소유 X"* 깨달음. **객체 소유 vs 매개변수 전달 구분 자가 학습**.
+
+**MCP 룰 `object-ownership-vs-parameter-passing` 후보** — *멤버 보유 vs 메서드 인자 = 소유 의미 구분*.
+
+#### 3.2. *3 가지 트레이드오프*
+
+| 안 | 장점 | 단점 |
+|---|---|---|
+| Player.choice(deck, ...) (학생 자가 재적용) | *Tell-Don't-Ask + 응집도* | *Player 가 deck 어휘 알아야 함* |
+| Participants.choice(deck, ...) (중간 안) | *일급 컬렉션 + 위임 자연* | *Participants 가 각 Player 의 choice 호출* |
+| BlackJackGame.processPlayerTurn(...) | *외부 조정 + 명시적 분리* | *Player 가 데이터 컨테이너 (god-object 위험)* |
+
+reviewer 권유 = **Player.choice (Tell-Don't-Ask)**. 
+
+### 4. 인스턴스 변수 2개 묶음 — name + money vs name + cards (학생 자가 의문)
+
+reviewer (Thread 15·20):
+
+> *"기존처럼 money를 Player가 갖고 있게 된다면 BlackJackTable 객체도 없어질 수 있을까요? 다만, 비비가 인스턴스 변수에 대한 우려가 있으시다면 아래 처럼 해보는건 어떨까요?*
+> *(...) 이렇게 비슷한 성격의 그룹으로 묶으면 어떤 이점이 있을까요?"*
+
+> *"name과 money를 묶어보면 어떨까 싶었습니다. 이 둘은 유저의 종속적인 정보라고 판단 할 수 있다고 생각했어요. 비비의 생각은 어떠신가요?"*
+
+학생 자가 의문:
+
+> *"위처럼 묶으면 관련 데이터를 하나의 객체로 묶기 때문에 **의미를 명확하게** 할 수 있고, **가독성이 좋아진다**는 장점이 있습니다! (...) 하지만 이름과 베팅 금액, 카드 중에 2가지를 묶는다면 어떤 것들을 묶어야 할 지 잘 모르겠어요... 관련 데이터를 묶는다기엔 3가지 모두 플레이어가 가진 각각의 성격이 다른 데이터라는 생각이 들어요.*
+>
+> *`인스턴스 변수 유지라는 요구사항에 맞추기 위해 묶지 않아도 될 것을 계속 묶고 있나?` 라는 의문도 듭니다. 제이든은 어떻게 생각하시나요?? 🥲"*
+
+→ **학생 자가 *형식 규칙 vs 도메인 의미* 의문** — **형식 규칙 부산물 인공 객체 인지 모범**:
+
+#### 4.1. *학생 자가 의문 모범*
+
+학생 *"인스턴스 변수 유지라는 요구사항에 맞추기 위해 묶지 않아도 될 것을 계속 묶고 있나?"* = **형식 규칙 부산물 인공 객체 자가 인지** — *MCP `oh-my-oop` 핵심 가치 (형식 규칙이 만든 인공 객체) 자가 발견*.
+
+PR #87 (jaeyeongjo *ParticipantInfo* 자가 답변) 결의 *3 변수 제약 자가 학습* 와 **반대 시점** — *PR #87 = 학생 자가 적용 (regulation 따름) / PR #138 = 학생 자가 의문 (regulation 비판)*.
+
+**MCP 룰 `form-rule-artificial-grouping-self-critique` 후보** — *형식 규칙 부산물 자가 비판*.
+
+#### 4.2. *3 가지 대안 (가능)*
+
+| 안 | 묶음 | 의미 |
+|---|---|---|
+| `Player(name, cards, money)` (현재) | *3 변수* | *형식 규칙 위반, 다만 cards = 객체* |
+| `Player(playerInfo: PlayerInfo, cards)` | *(name+money) + cards = 2 변수* | *유저 종속 정보 묶음* |
+| `Player(name, hand: Hand)` + `Hand(cards, money)` | *name + (cards+money)* | *손에 든 것 = 카드 + 베팅* (도메인 메타포 약함) |
+
+reviewer 답변 보류 (DM 으로 토론) — **학생 자가 답변 가치 더 큼**.
+
+### 5. `tailrec` 키워드 미적용
+
+reviewer (Thread 11·18):
+
+> *"kotlin의 [tailrec](https://kotlinlang.org/docs/functions.html#tail-recursive-functions) 에 대해 찾아보셔도 좋습니다!"*
+
+> *"재귀로 잘 구현해주셨네요 👍 tailrec 에 대해서도 한번 살펴보시면 도움이 될 것 같아요!"*
+
+→ **`tailrec` 키워드 = 컴파일러 최적화 (스택 오버플로우 방지)** — *Kotlin 어휘 추가 학습 권유*. 학생 자가 적용 X (다만 *문서 학습 권유*).
+
+**MCP 룰 `tailrec-optimization-applicability` 후보** — *재귀 함수 + tailrec 의도 명시*.
+
+### 6. `Participant.getResult` open + super 키워드 — 다형성 + 공통 로직
+
+§6 참조. **`open` 키워드 + `super` 호출 = 부모 공통 로직 + 자식 확장**.
+
+다만 *Participant.getResult 가 *복잡한 when 분기 6개* 보유* = *부모가 여전히 god-method*. reviewer (Thread 19) *"현재 Participant에 있는 '나' 와 'other' 의 많은 케이스들을 Dealer와 Player로 옮겨 조건문 복잡도를 줄일 수 있을거에요!"* = *미션 종료 후 추가 학습 권유*.
+
+#### 6.1. *2 가지 정공*
+
+| 안 | 장점 | 단점 |
+|---|---|---|
+| Participant.getResult 공통 + 자식 override + super 호출 (현재) | *공통 로직 1 자리 + 자식 확장 간결* | *Participant 가 god-method (when 분기 ↑)* |
+| 자식 모두 자가 override (Participant.getResult abstract) | *자식 별 명확 + 부모 부담 ↓* | *공통 로직 중복* |
+| State 패턴 (sealed Result + Result.calculate(self, other)) | *Tell-Don't-Ask 정공* | *State/Result 객체 추가* |
+
+reviewer 권유 = *현재 안 OK + 미션 종료 후 추가 학습*.
+
+### 7. `Player.isDrawable() = cards.sumOfCards <= BUST_STANDARD` — 룰 와전 가능
+
+```kotlin
+override fun isDrawable(): Boolean = cards.sumOfCards <= BUST_STANDARD  // ≤ 21
+```
+
+→ **Player 가 21 시점에도 hit 가능 (`≤`)** — *블랙잭 룰: 21 = 블랙잭 = stop, 21 미만 = hit 가능*.
+
+다만 *Player.isDrawable = 21 시 true → 22 가능 → bust* = *룰 모호*. *실제 블랙잭 = 21 시 stop (자가)*.
+
+대안: `cards.sumOfCards < BUST_STANDARD` — *21 미만 hit*.
+
+학생의 *21 시 hit 가능 = 사용자 선택* → *사용자가 선택해서 22 = bust* = *룰 정합*. 다만 *명시적 stop 조건 X*.
+
+**MCP 룰 `blackjack-rule-fidelity-comparison` 강화** 누적 11+ PR ⭐⭐⭐. *< vs ≤ 점검*.
+
+### 8. `Dealer.DEALER_MAX_SCORE = 16` + `<=` 비교 — 16 시 hit?
+
+```kotlin
+override fun isDrawable(): Boolean {
+    if (cards.hasAce() && !cards.isBust(ACE_SOFT_SCORE)) {
+        return cards.sumOfCards + ACE_SOFT_SCORE <= DEALER_MAX_SCORE  // ≤ 16
+    }
+    return cards.sumOfCards <= DEALER_MAX_SCORE  // ≤ 16
+}
+```
+
+→ **Dealer 16 시 hit (`<=`)** — *PR #129 결의 `<` 비교 (16 시 stay) 반대 시점*. **블랙잭 표준 = 16 이하 hit (16 시 hit)** — *현재 코드 정공*.
+
+**PR #129 (`<` 16 시 stay = 룰 와전) vs PR #138 (`<=` 16 시 hit = 룰 정공) 반대 시점** = 학생 자가 정정. **MCP 룰 `blackjack-rule-fidelity-comparison` 강화 + 학생 자가 학습 시간성**.
+
+### 9. `ParticipantCards.isBlackJack` — 초기 2장 + 21 조건
+
+```kotlin
+fun isBlackJack(): Boolean = size == INITIAL_CARD_COUNT && finalScore() == BLACKJACK_SCORE
+```
+
+→ **블랙잭 = 초기 2장 + 21점 정확** — *PR #20·#64·#110·#28·#125·#147·#82·#36 결의 *Ace+10 두 장만 진짜 블랙잭* 룰 정공*. **MCP 룰 `blackjack-rule-fidelity` 강화** 누적 10+ PR ⭐⭐⭐.
+
+다만 *`size` private + 호출자는 isBlackJack 만 호출* — *isBlackJack 책임 ParticipantCards 에 자가 적용*.
+
+### 10. `getPlayerProfit(action: (String, Double) -> Unit)` — callback 람다 (PR #36 결)
+
+```kotlin
+fun getPlayerProfit(action: (String, Double) -> Unit) {
+    participants.players.forEach { player ->
+        val result = player.getResult(participants.dealer)
+        val profit = result.calculatePlayerProfit(player.money)
+        action(player.name, profit)
+    }
+}
+```
+
+→ **callback 람다 = View 결합** (PR #36·#129 결).
+
+대안: `getPlayerProfit(): List<Pair<String, Double>>` 반환 — *List 반환 후 Controller 가 View 처리*. **MCP 룰 `callback-action-for-result-aggregation` 강화** 누적 2+ PR (#129·#138).
+
+### 11. `getDealerProfit(): Double` 반환 = 의미 누수 (PR #129 결)
+
+```kotlin
+fun getDealerProfit(): Double = ...
+```
+
+→ **`Double` 반환 = *수익 의미 누수***. *Money value class 활용 가능* (`Money(value)`).
+
+대안: `getDealerProfit(): Money` — *도메인 어휘 + value class 활용*.
+
+**MCP 룰 `primitive-return-without-domain-meaning` 강화** 누적 3+ PR (#36·#129·#138).
+
+### 12. `Dealer.getResult` 의 `cards.isBust() && !other.cards.isBust() -> GameResult.LOSE` — 단일 경우만 처리
+
+```kotlin
+override fun getResult(other: Participant): GameResult =
+    when {
+        cards.isBust() && !other.cards.isBust() -> GameResult.LOSE
+        else -> super.getResult(other)
+    }
+```
+
+→ **Dealer 만 자가 처리 = *Dealer Bust + Player !Bust* 한 가지 경우** + *나머지는 super 위임*.
+
+다만 *Player.getResult* 도 동일 패턴:
+```kotlin
+override fun getResult(other: Participant): GameResult =
+    when {
+        cards.isBust() -> GameResult.LOSE  // ← Player Bust = 즉시 LOSE
+        else -> super.getResult(other)
+    }
+```
+
+→ **Player 는 자가 Bust = 즉시 LOSE** (모든 시점), **Dealer 는 자가 Bust + Player !Bust 만 LOSE**.
+
+#### 12.1. *블랙잭 룰 정공*
+
+- Player Bust: 무조건 Lose (자가).
+- Dealer Bust: 모든 살아있는 Player Win → Dealer Lose. 다만 *Player 도 Bust = Player Lose (Dealer 의 Bust 와 무관)*.
+
+→ *학생 코드 = 블랙잭 룰 정공*. 
+
+### 13. `BlackJackGame.processDealerTurn(): Int` 반환 = `Int` 의미 모호 (PR #129 결)
+
+§11 참조.
+
+### 14. `ParticipantCards.allCards: List<TrumpCard>` public getter — Tell-Don't-Ask 부분 누수
+
+```kotlin
+class ParticipantCards(private val _cards: MutableList<TrumpCard> = mutableListOf()) {
+    val allCards: List<TrumpCard> get() = _cards.toList()
+}
+```
+
+→ **`allCards: List<TrumpCard>` public 노출** + *Participant.takeCards = cards.allCards.take(count)* = *외부 가져옴*. **Tell-Don't-Ask 부분 누수**.
+
+대안: `ParticipantCards.takeFirstN(count: Int): List<TrumpCard>` — *메시지 던지기*.
+
+PR #36·#87·#117·#129 결의 *Tell-Don't-Ask 정공* 어휘.
+
+### 15. `Money(1000)` 최소 금액 `MINIMUM_BETTING_MONEY = 1000` — 도메인 룰 와전 가능
+
+```kotlin
+const val MINIMUM_BETTING_MONEY = 1000
+```
+
+→ **실제 블랙잭 = 최소 베팅액 카지노마다 다름** ($5, $10, $25). *1000원 = 임의 결정*. reviewer (Thread 2) 의문 어휘 일치: *"1000원 이상을 입력해야 하는 룰이 주어졌었나요?"*.
+
+학생 자가 답변 = *블랙잭 룰 자가 학습 (실제 카지노 최소 베팅액)*.
+
+**MCP 룰 `domain-rule-arbitrary-constant` 후보** — *도메인 룰 vs 임의 상수 구분*.
+
+### 16. `Player.choice` 재귀 = `tailrec` 미적용
+
+```kotlin
+fun choice(deck: Deck, getPlayerChoice: ..., onPlayerStateUpdated: ...) {
+    if (!isDrawable()) return
+    if (getPlayerChoice(name)) {
+        receiveCard(deck.pop())
+        onPlayerStateUpdated(this)
+        choice(deck, getPlayerChoice, onPlayerStateUpdated)  // ← tailrec 미적용
+    }
+}
+```
+
+→ **재귀 호출이 if 안에 있음 + 마지막 표현식** → `tailrec` 키워드 추가 가능. 다만 *조건부 재귀 (`if (drawable) recurse`)* = *tailrec 조건 만족 (마지막 표현식이 자가 호출)*.
+
+§5 참조.
+
+### 17. `ShuffledDeck.pop()` 재귀 + currentDeckIndex 변경 — 부작용 + 재귀
+
+```kotlin
+override fun pop(): TrumpCard {
+    val currentDeck = deckPool.getOrNull(currentDeckIndex) ?: throw ...
+    return if (currentDeck.isNotEmpty()) {
+        currentDeck.pop()  // ← currentDeck 변경 (부작용)
+    } else {
+        currentDeckIndex++  // ← currentDeckIndex 변경 (부작용)
+        pop()  // ← 재귀
+    }
+}
+```
+
+→ **재귀 + 부작용 (currentDeckIndex 변경)** = *함수형 정공 X*. 다만 *Singleton Deck 객체 = mutable state 보유* → *부작용 불가피*.
+
+대안: **immutable Deck + (Deck, TrumpCard) 반환** — *부작용 X*. 다만 *블랙잭 도메인 = mutable 자연 (카드 사용 후 사라짐)* → *현재 안 OK*.
+
+**MCP 룰 `recursive-with-side-effect-vs-immutable` 후보**.
+
+### 18. `Player.money` public val — 외부 노출
+
+```kotlin
+class Player(val name: String, cards: ParticipantCards, val money: Money) : Participant(cards)
+```
+
+→ **`money: Money` public val** = *외부에서 player.money 접근 가능* + *BlackJackGame.getDealerProfit = result.calculateDealerProfit(player.money)* 외부 호출. **Tell-Don't-Ask 부분 누수**.
+
+대안: `Player.calculateProfit(other: Participant): Money` — *Player 가 자가 계산*.
+
+PR #87·#129 결의 *Tell-Don't-Ask 정공*.
+
+### 19. `Participants` 의 `getChoice` 위임만 — 단순 위임 (PR #129 결)
+
+```kotlin
+// Participants (PR #129 결 같은 단순 위임)
+fun getChoice(deck: Deck, getPlayerChoice: ..., onPlayerStateUpdated: ...) {
+    players.forEach { player -> player.choice(deck, getPlayerChoice, onPlayerStateUpdated) }
+}
+```
+
+→ **단순 위임 메서드 = 추가 책임 X = 메서드 인공** — PR #129 결 강화. **MCP 룰 `simple-delegation-method-unnecessary` 강화** 누적 3+ PR (#129·#87·#138).
+
+### 20. `GameResult.WIN(1.0, 1.0)` 부호 양가성
+
+§3.1 참조. **MCP 룰 `enum-bidirectional-multiplier-ambiguity` 후보**.
+
+## 리뷰어 의견 요지
+
+- **PR 본문 자가 의문 2개에 reviewer 답변** — *8 덱 도메인 룰 자가 학습 + ParticipantCards 책임 이동 자가 적용 (reviewer 선제 칭찬)*.
+- **value class + @JvmInline = Kotlin 어휘 자가 학습** — *어떤 상황 / 어떤 이점 / 어떤 역할 3 질문*.
+- **require 예외 vs runCatching 재입력 (유저 경험)** — *블랙잭 도메인 룰 학습*.
+- **getResult 다형성 + super 키워드 = 공통 로직 + 자식 확장** — *4 스레드 학습 흐름*.
+- **수익률 계산 = GameResult 책임 (BlackJackGame X)** — *로또 미션 결과 객체 결*.
+- **재귀 함수 + tailrec 학습 권유** — *명령형 vs 함수형*.
+- **getAllCards 위임 → cards.take 직접 (Tell-Don't-Ask)**.
+- **choice 로직 위치 토론 + 학생 자가 정정** — *객체 소유 vs 매개변수 전달*.
+- **BlackJackTable 형식 규칙 부산물 자가 인정** + **인스턴스 변수 2개 묶음 자가 의문** — *형식 규칙 vs 도메인 의미*.
+- **디미터 법칙 + 외부글 (mangkyu.tistory) + 학생 자가 깨달음** (table.deck 깊이).
+- **getOrNull = 논리오류 처리 (로또 미션 결)**.
+- **캐싱 (companion lazy) + 트럼프 카드 효율 사용**.
+- **Dealer/Player 한 가지 경우만 자가 override + super 호출** (Thread 13·14·19).
+- **버스트 케이스 추가 학습 미션 종료 후 권유** — *학생 부담 최소화*.
+
+## 대표 인용
+
+> [rosemin928 PR 본문]
+> *"1단계 merge하며 주신 리뷰 중 `deck을 전부 사용했을 때 어떻게 할 것인가?`를 고민하다가 **블랙잭의 최대 플레이 인원은 8명이다**, **블랙잭은 총 8개의 덱을 사용한다**라는 규칙이 있다는 것을 알게 되었습니다."*
+
+→ **학생 자가 도메인 룰 학습 + 1단계 → 2단계 사이 학습**. *MCP `oh-my-oop` *학습 = 시간 두고 반복* 정점*.
+
+> [rosemin928 PR 본문]
+> *"이번에 각 객체들의 역할과 책임에 대해 고민해보다가 `isBust`, `isBlackJack`, `finalScore` 이 세 가지 함수를 ParticipantCards로 옮기게 되었습니다."*
+
+→ **학생 자가 책임 이동 = reviewer 권유 전 선제 적용** — 학습 가시화 정점.
+
+> [KwonDae Thread 3]
+> *"좋습니다 👍 2단계로 오면서 참가자의 카드의 정보를 따로 분리하는 것에 대해 이야기 하려 했는데 이미 반영을 해주셨군요"*
+
+→ **reviewer 가 학생 선제 적용 인정 + 학생 자가 학습 정점**.
+
+> [KwonDae Thread 8]
+> *"결과를 판단하는 로직이 게임 규칙상 굉장히 복잡하죠. 또한, 딜러와 플레이어 양쪽으로 중복되는 로직과 차이점이 동시에 존재합니다. 이런 상황에서 다형성을 활용해볼 수 있습니다."*
+
+→ **다형성 활용 어휘 + 외부글 (위키)**.
+
+> [KwonDae Thread 13]
+> *"식으로 다형성을 활용해볼 수 있을거에요 (super 키워드 코드 예시). 여기서 다형성과 super 키워드에 대해 생각해보시면 좋습니다"*
+
+→ **super 키워드 코드 힌트** — *학생 자가 적용 가능*.
+
+> [rosemin928 Thread 15]
+> *"인스턴스 변수 유지라는 요구사항에 맞추기 위해 묶지 않아도 될 것을 계속 묶고 있나? 라는 의문도 듭니다. 제이든은 어떻게 생각하시나요?? 🥲"*
+
+→ **학생 자가 형식 규칙 vs 도메인 의미 의문** — *MCP `oh-my-oop` 핵심 가치 자가 발견*.
+
+> [KwonDae Thread 16]
+> *"BlackJackTable 을 생성함으로써 어느 부분의 역할이 가벼워졌을까요? 처음 이 객체를 본 동료 개발자도 Table에 deck, bettingMoney만 있는걸 쉽게 알아차릴 수 있을까요? 🧐"*
+
+→ **동료 개발자 시점 어휘** (maintainer perspective locator) + *학생 자가 부산물 인정 트리거*.
+
+> [rosemin928 Thread 16]
+> *"Table에 deck과 bettingMoney만 있는걸 쉽게 알아차리기는 어려울 것 같아요. 사실 인스턴스 변수를 2개를 유지하기 위해 BlackJackTable을 만들었었는데 Player에서 인스턴스 변수 2개를 유지할 수 있다는 장점을 제외하고는 스스로도 납득이 가는 장점이 크지는 않았던 것 같아요."*
+
+→ **학생 자가 부산물 인정 + 자가 제거** 어휘 — *형식 규칙 비판 모범*.
+
+> [KwonDae Thread 17]
+> *"table이라는 객체가 생기면서 객체 지향 프로그래밍에서 이야기하는 디미터의 법칙에 대해 한번 찾아보셔도 도움이 될 것 같아요 🙂"*
+
+→ **디미터 법칙 + 외부글** 어휘. PR #87·#129·#36 결.
+
+> [rosemin928 Thread 17]
+> *"table이 있을 때에는 table 내에서 deck을 가져와야 해서 응집도와 캡슐화를 해치게 되네요... 😢 앞으로 해당 사항 신경 쓰며 구현해보도록 하겠습니다!"*
+
+→ **학생 자가 디미터 깨달음 + 미래 학습 의지**.
+
+> [KwonDae Thread 19]
+> *"이부분은 미션이 끝나고 한번 해보셔도 도움이 될 것 같아요. 현재 Participant에 있는 '나' 와 'other' 의 많은 케이스들을 Dealer와 Player로 옮겨 조건문 복잡도를 줄일 수 있을거에요!"*
+
+→ **미션 종료 후 추가 학습 권유** — *학생 부담 최소화*.
+
+> [KwonDae Thread 20]
+> *"이 질문이 이해를 잘 하지 못했는데, `인스턴스 변수 유지` 요구사항이 어떤 사항을 말씀하시는걸까요? DM으로 말씀주시면 좋을 것 같습니다 🙂"*
+
+→ **DM 으로 추가 토론 + reviewer 가 사용자에게 자가 의문 명시** — *양방향 토론 깊이*. PR #129 (커뮤니케이션 메타) 결.
+
+## 얻은 교훈 (보편)
+
+1. **PR 본문 자가 의문 2개 + 1단계 → 2단계 사이 자가 도메인 학습** — *MCP `oh-my-oop` *학습 = 시간 두고 반복* 어휘 정점*. **MCP 룰 `multi-stage-domain-self-learning` 후보**.
+
+2. **학생 자가 책임 이동 = reviewer 권유 전 선제 적용** — *학습 가시화 정점*. *reviewer 가 학생 선제 적용 인정* 어휘. 누적 3+ PR (#138·#147·#39).
+
+3. **value class + @JvmInline = Kotlin 어휘 자가 학습 (어떤 상황 / 어떤 이점 / 어떤 역할 3 질문)** — *reviewer 가 *왜* 묻기 + 학생 자가 *답* 하기*. **MCP 룰 `value-class-application-and-rationale` 후보**.
+
+4. **require 예외 vs runCatching 재입력 (유저 경험)** — **MCP 룰 `require-exception-vs-graceful-retry` 후보**.
+
+5. **getResult 다형성 + super 키워드 = 공통 로직 + 자식 확장** — *4 스레드 학습 흐름 (의문 → 자가 의문 → 코드 힌트 → 자가 적용)*. **MCP 룰 `super-keyword-for-shared-logic` 후보**.
+
+6. **수익률 계산 = GameResult 책임 (로또 미션 결)** — *enum 멤버 + 메서드 = 책임 강화*. PR #133·#108·#46·#39·#88·#90·#131 결.
+
+7. **재귀 함수 + tailrec = 명령형 → 함수형** — **MCP 룰 `recursive-vs-while-functional` 후보** + **MCP 룰 `tailrec-optimization-applicability` 후보**.
+
+8. **getAllCards 위임 → cards.take 직접 (Tell-Don't-Ask)** — *위임 메서드 줄임*. PR #87·#129·#36 결.
+
+9. **객체 소유 vs 매개변수 전달 구분 (choice 위치 토론)** — *멤버 보유 vs 메서드 인자 = 소유 의미 구분*. **MCP 룰 `object-ownership-vs-parameter-passing` 후보**.
+
+10. **형식 규칙 부산물 인공 객체 자가 비판 (BlackJackTable 자가 제거)** — *학생 자가 *인스턴스 변수 유지 요구사항이 묶지 않아도 될 것을 계속 묶고 있나?* 의문*. **MCP 룰 `form-rule-artificial-grouping-self-critique` 후보** + **MCP 룰 `instance-variable-limit-artificial-grouping` 강화** 누적 7+ PR.
+
+11. **디미터 법칙 + table.deck 깊이 + 외부글** — **MCP 룰 `law-of-demeter-violation-depth` 강화** 누적 7+ PR.
+
+12. **getOrNull = 논리오류 처리 (로또 미션 결)** — *Kotlin 어휘 + 즉시 감지*. **MCP 룰 `get-vs-getOrNull-exception-timing` 후보**.
+
+13. **캐싱 (companion lazy)** — *Singleton 효율 사용*. **MCP 룰 `lazy-init-companion-vs-instance-pool` 후보**.
+
+14. **enum 양쪽 시점 multiplier 묶음 = 부호 양가** — *Player vs Dealer 시점 명시 X*. **MCP 룰 `enum-bidirectional-multiplier-ambiguity` 후보**.
+
+15. **미션 종료 후 추가 학습 권유** — *학생 부담 최소화*. PR #87·#129·#36·#117 결.
+
+16. **DM 으로 추가 토론** — *양방향 토론 깊이 + reviewer 자가 의문 명시*. PR #129 (커뮤니케이션 메타) 결.
+
+17. **학생 자가 도메인 룰 학습 (8 덱 / 최소 베팅액 1000원)** — *블랙잭 실제 카지노 룰 자가 학습*. **MCP `oh-my-oop` *학습 = 시간 두고 반복* 정점**.
+
+18. **재귀 + 부작용 (currentDeckIndex 변경)** — *immutable vs mutable 트레이드오프*. PR #87·#137·#148 결.
+
+19. **단순 위임 메서드 = 추가 책임 X (PR #129·#87 결 강화)** — 누적 3+ PR.
+
+20. **`<` vs `<=` 점검 (블랙잭 룰 정확성)** — *Dealer 16 시 hit 정공 (현재) vs PR #129 16 시 stay 와전 (자가 정정)*. **MCP 룰 `blackjack-rule-fidelity-comparison` 강화** 누적 11+ PR ⭐⭐⭐.
+
+## 얻은 교훈 (도메인)
+
+1. **블랙잭 8 덱 도메인 룰** — *최대 플레이 인원 8명 + 총 8개 덱*. 학생 자가 학습. **MCP 룰 `multi-deck-domain-rule` 강화** PR #58 (6덱 메타포) 결 + PR #138 (8덱 정공).
+
+2. **블랙잭 최소 베팅액 = 카지노 도메인 룰 (1000원 임의)** — *블랙잭 카지노마다 다름 ($5-$25)*. 학생 자가 학습.
+
+3. **`Dealer.isDrawable() = sum <= 16` (Soft Ace 적용)** — *블랙잭 표준 룰 정공*. PR #129 의 `<` 16 시 stay 자가 정정.
+
+4. **`Player.isDrawable() = sum <= 21`** — *Player 21 시 hit 가능 (자가 결정)*. 블랙잭 룰 정합.
+
+5. **`isBlackJack = size == 2 && finalScore == 21`** — *초기 2장 + 21점*. PR #20·#64·#110·#36·#26·#147·#88·#93·#136·#152·#133·#129 누적 결.
+
+6. **`BLACKJACK(1.5, 1.0)` enum 멤버** — *블랙잭 1.5배 별도 멤버* 정공. 누적 11+ PR ⭐⭐⭐.
+
+7. **`Ace Soft 1↔11 단일 +10 룰`** — PR #36·#129 결의 *Multi-Ace 한 가지 처리* 일치.
+
+## MCP 룰 후보 신규 + 강화 (PR #138)
+
+| 룰 | 신규 / 강화 | 누적 PR |
+|---|---|---|
+| `multi-stage-domain-self-learning` | 신규 | 1 (#138) — *1단계 → 2단계 사이 자가 도메인 학습* |
+| `value-class-application-and-rationale` | 신규 | 1 (#138) |
+| `require-exception-vs-graceful-retry` | 신규 | 2+ (#129·#138) |
+| `super-keyword-for-shared-logic` | 신규 | 1 (#138) |
+| `recursive-vs-while-functional` | 신규 | 1 (#138) |
+| `tailrec-optimization-applicability` | 신규 | 1 (#138) |
+| `object-ownership-vs-parameter-passing` | 신규 | 1 (#138) |
+| `form-rule-artificial-grouping-self-critique` | 신규 | 1 (#138) |
+| `instance-variable-limit-artificial-grouping` | 강화 | 7+ (#133·#88·#132·#136·#93·#87·#138) |
+| `law-of-demeter-violation-depth` | 강화 | 7+ |
+| `get-vs-getOrNull-exception-timing` | 신규 | 1 (#138) |
+| `lazy-init-companion-vs-instance-pool` | 신규 | 1 (#138) |
+| `enum-bidirectional-multiplier-ambiguity` | 신규 | 1 (#138) |
+| `recursive-with-side-effect-vs-immutable` | 신규 | 1 (#138) |
+| `multi-deck-domain-rule` | 강화 | 2+ (#58·#138) |
+| `domain-rule-arbitrary-constant` | 신규 | 1 (#138) |
+| `blackjack-rule-fidelity-comparison` | 강화 | 11+ ⭐⭐⭐ |
+| `interface-for-test-substitution` | 강화 | 5+ |
+| `simple-delegation-method-unnecessary` | 강화 | 3+ (#129·#87·#138) |
+| `callback-action-for-result-aggregation` | 강화 | 2+ (#129·#138) |
+| `primitive-return-without-domain-meaning` | 강화 | 3+ (#36·#129·#138) |
+
+## 메타 어휘 (13 reviewer + MCP 핵심 가치 합류 정점 유지)
+
+- ***학생 자가 책임 이동 + reviewer 권유 전 선제 적용*** — rosemin928 PR #138 — *reviewer 가 *2단계로 오면서 참가자의 카드의 정보를 따로 분리하는 것에 대해 이야기 하려 했는데 이미 반영을 해주셨군요* 인정* — **학습 가시화 정점**.
+- ***1단계 → 2단계 사이 자가 도메인 학습*** — rosemin928 PR #138 — *8 덱 룰 + 최소 베팅액 자가 학습*. **MCP `oh-my-oop` *학습 = 시간 두고 반복* 정점**.
+- ***학생 자가 형식 규칙 vs 도메인 의미 의문*** — rosemin928 PR #138 — *"인스턴스 변수 유지라는 요구사항에 맞추기 위해 묶지 않아도 될 것을 계속 묶고 있나?"* — **형식 규칙 부산물 자가 비판** = *MCP `oh-my-oop` 핵심 가치 자가 발견*.
+- ***학생 자가 디미터 깨달음 + 미래 학습 의지*** — rosemin928 PR #138 — *"앞으로 해당 사항 신경 쓰며 구현해보도록 하겠습니다!"*.
+- ***reviewer 가 *왜* 묻기 + 학생 자가 *답*하기 (Kotlin 어휘 자가 학습)*** — KwonDae/rosemin928 PR #138 — *value class / @JvmInline / getOrNull / tailrec 모두 *왜* 질문 형식*. **MCP `oop_propose_alternatives` 핵심 가치 (학생 자가 학습 권유)**.
+- ***DM 으로 추가 토론*** — KwonDae PR #138 — *"DM으로 말씀주시면 좋을 것 같습니다 🙂"* — *공개 토론 + 사적 토론 분리 어휘*. **PR #129 (커뮤니케이션 메타) 결 강화**.
+- ***모든 20 스레드 학생 자가 답변 + 커밋 SHA + 자가 후속 의문 4+ 회*** — rosemin928 PR #138 — *학생 자가 학습 가시화 정점* (PR #117·#129 결 강화).
+
+→ **13 reviewer + MCP 핵심 가치 어휘 합류 정점 유지**. **batch 20 신규 발견 = *학생 자가 *선제 적용* + reviewer 인정* 패턴** (학습 가시화 정점). 
+
+## 비교 (PR #129 → #138 진화 — 사족 X, 안티패턴 명시만)
+
+- **1단계 #129 학생 자가 의문 5+ 회 → 2단계 #138 PR 본문 자가 의문 2개 + 라인 자가 의문 4+ 회** — *학생 자가 학습 정점 유지*.
+- **1단계 deck.pop 예외 처리 의문 → 2단계 8 덱 도메인 룰 자가 학습** — *1단계 → 2단계 사이 학습*.
+- **1단계 추상화 활용 점검 (isDrawable) → 2단계 super 키워드 활용 (getResult)** — *추상화 학습 시간성*.
+- **1단계 ParticipantCards 자가 생성 → 2단계 책임 이동 자가 적용 (isBust/isBlackJack/finalScore)** — *학습 가시화 정점*.
+- **1단계 `<` 비교 16 시 stay 가능 → 2단계 `<=` 비교 16 시 hit 정공** — *블랙잭 룰 자가 정정*.
+- **1단계 시간 압박 인정 → 2단계 자가 도메인 학습 + 자가 선제 적용** — *학생 학습 깊이 진화*.
+
+→ *진화 비교 = 사족 아님 (안티패턴 코드 위치 명시)* + *학생 자가 학습 정점 진화 일관*.