oh-my-oop 0.2.0

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

@@ -0,0 +1,739 @@
+# PR #142 — [블랙잭 2단계] 디랙 미션
+
+- **Reviewee:** [@doabletuple](https://github.com/doabletuple)
+- **PR:** https://github.com/woowacourse/kotlin-blackjack/pull/142
+- **단계:** 2단계
+- **리뷰어:** [@KwonDae](https://github.com/KwonDae) (제이든) — 1단계 #126 동일 reviewer
+- **라인 코멘트:** 20 스레드 — *PR 본문 자가 의문 1개 (Game 책임 비대) + 1단계 reviewer 의도 자가 정정 (Thread 1) + reviewer 자가 사과 + 학생 자가 사과 + 다형성 학습 (학생 자가 코드 예시 + 4-5 라운드 양방향 토론) + Result Kotlin stdlib 충돌 → GameResult + tailrec 자가 적용 + 0 의미 상수 (MIN_BET_AMOUNT) + 패키지 분리 (participant/card/result) + 딜러 초기 핸드 = openInitialHand 분리 vs 상태 판단 (2 안 비교) + Bet (음수 X) vs Money (음수 OK) 분리*
+- **양 단계 완성 reviewee** (1단계 #126 batch 20 분석 완료 + 2단계 #142 = batch 21 추가).
+
+## 잘한 점 (설계 관점)
+
+### 1. PR 본문 자가 의문 + reviewer 자가 후퇴 + 학생 자가 사과 (Thread 1 학생 ↔ reviewer 양방향)
+
+PR 본문:
+
+> *"클래스가 비대해진만큼 다른 `Game`이 너무 많은 책임을 맡고 있는 것은 아닌지 의문이 들었지만, 그렇다고 `Game`이 맡고있는 책임 중 `Game`의 것이면 안 된다는 확신이 드는 부분도 없었습니다 😓"*
+
+→ **Game god-object 자가 의문**.
+
+reviewer (Thread 1) **1단계 의도 명료화 + 자가 사과**:
+
+> *"잘 구현해주셨습니다 👍 다만 제가 혼란을 드린 것 같아 죄송하네요.. 🥲 코멘트의 의도는 Controller에서 데이터를 꺼내 OutputView로 개별로 전달하는 것에 대한 이야기였습니다. 같이 객체 자체를 넘기고 outputView 에서 알아서 출력하도록 유도를 하고 싶었어요! iteration 을 수행해야 하는지? 에 대해 고민해보기를 바라는 코멘트였습니다 ㅎㅎ. 명확하지 못한 코멘트가 view 관련 함수가 domain으로 들어오게 하는 혼란을 야기한것 같네요. 보다 명확하게 전달드릴 수 있도록 하겠습니다 🙇‍♂️"*
+
+학생 자가 사과:
+
+> *"제가 완전히 잘못 이해하고 있었네요 😭 헷갈리는 부분은 바로 질문을 드렸어야 하는데, 뒤늦게 여쭤봐서 죄송합니다 🙇‍♂️"*
+
+→ **양방향 자가 사과 + reviewer 자가 명료화** = PR #130 (hyemdooly *"정말정말 미안해요!!"*) 결의 *reviewer 자가 한계 인정* 어휘 강화. **MCP 룰 `reviewer-self-clarification-explicit` 후보** — *reviewer 가 자가 의도 명료화 + 학생 오해 발생 자가 인정*.
+
+### 2. 다형성 학습 = 딜러도 자가 비교 (학생 자가 코드 예시 + 4-5 라운드 양방향)
+
+reviewer (Thread 10): *"공통점은 `내 카드의 점수가 상대방의 카드 점수보다 높다면 이긴다`. 차이점은 `bust 라는 로직에 대한 처리` 일겁니다. 이런 상황에서 다형성을 활용해볼 수 있습니다."*
+
+reviewer 후속 (Thread 10): *"위 코멘트의 핵심은 - `딜러든 참가자든 상대방의 카드와 비교할 수 있어야 한다` - `참가자는 현재 추상클래스로 구현되어 있다` 가 포인트 입니다."*
+
+학생 자가 코드 예시 + 자가 의문:
+
+> *"다음 코드와 같은 구조를 말씀하시는 것이라고 이해하면 될까요? (코드 예시) 현실 세계를 생각하면 플레이어와 딜러 모두 자신과 상대방을 비교해 승패를 판단할 수 있어야 하지만, 제가 기존에 `compareAgainst()` 함수를 `Player`에만 구현한 이유는 다음과 같습니다.*
+> *- 플레이어의 승패가 결정되면 딜러의 승패 또한 자동적으로 결정된다.*
+> *- 때문에 플레이어들의 결과를 재사용하면 '플레이어 vs 딜러'와 '딜러 vs 플레이어'를 따로 비교하는 반복을 피할 수 있다.*
+> *제가 기존 로직에 너무 매몰돼있는 것인지, 딜러가 `compareAgainst()` 함수를 가진다고 해도 중복 비교를 피하면서 해당 함수를 사용할 방법이 생각나지 않네요 😥"*
+
+reviewer 답변 (Thread 15):
+
+> *"디렉의 말씀하신 부분 중 `결과를 재상하여 비교 반복을 피할 수 있다` 도 맞습니다. 다만, 객체 지향적으로 생각해보면, 딜러와 플레이어 모두 독립적인 객체로서 자신의 상태를 판단하고 다른 객체와의 관계를 비교할 수 있는 책임을 가져야 합니다.*
+> *- 객체 간 책임 분리(딜러는 현재 스스로 승패를 판단할 수 없습니다)*
+> *- 딜러가 플레이어 외 다른 대상과 비교해야 하는 상황이 생긴다면 어떤 수정사항이 필요로 되는가?*
+> *현재 우리는 다형성을 학습하고 있어요. 물론 하나의 객체에 로직을 부여해 판단하는 방법이 틀린게 아닙니다. 다만 객체 지향 프로그래밍에서 다형성 을 통해 어떤 이점을 얻을 수 있을지 깊게 고민해보셔도 좋을거에요"*
+
+학생 자가 깨달음:
+
+> *"비교 반복을 없에는 일에 한눈이 팔려서 학습 목표를 놓치고 있었네요 😅 지금처럼 딜러의 결과가 플레이어의 결과에 의존하는 방식은 말씀하신대로 비교해야 하는 상황이 더 복잡해졌을 때 대응하기 어려울 것 같습니다. 딜러 vs 플레이어 비교가 가능하도록 변경했습니다!"*
+
+→ **5 라운드 양방향 토론 + 학생 자가 코드 예시 + 학생 자가 학습 목표 회수 + 변경 가능성 의식**:
+
+#### 2.1. *학생 자가 코드 예시 = 학습 시각화*
+
+학생이 *예시 코드 명시 + 자가 의문* = *PR #117·#129·#138 결의 *학생 자가 학습 가시화 정점* 강화*. **MCP 룰 `student-self-code-example-as-question` 후보**.
+
+#### 2.2. *추상화 활용 점검 + 학습 목표 회수*
+
+reviewer *"현재 우리는 다형성을 학습하고 있어요"* + 학생 *"학습 목표를 놓치고 있었네요"* = **MCP `oh-my-oop` 핵심 가치 (학습 의도 회수) 어휘**. PR #129 (KwonDae *"지금까지 추상화를 진행한 이유에 대해 고민해보시죠!"*) 결 강화.
+
+#### 2.3. *변경 가능성 = 다형성의 이점*
+
+reviewer *"딜러가 플레이어 외 다른 대상과 비교해야 하는 상황이 생긴다면"* = *변경 가능성 의식*. PR #126 (변경 가능성 = View 책임) 결과 같은 어휘 (*변경 가능성 = 다형성*).
+
+**MCP 룰 `polymorphism-as-change-tolerance` 후보** — *다형성 = 변경 가능성 대응*.
+
+### 3. `tailrec` 키워드 자가 학습 + 적용
+
+reviewer (Thread 16): *"이러한 반복되는 부분은 kotlin 의 tailrec 을 활용할 수 있는데요 어떤 기능을 하는지 한번 살펴보시고 적용가능한 부분들에 반영을 해볼까요?"*
+
+학생 자가 적용:
+
+```kotlin
+tailrec fun processHits(deck: Deck, input: (Player) -> Action, output: (Player) -> Unit) {
+    if (!canHit()) return
+    if (input(this) == Action.STAND) {
+        if (openHand().size == Hand.STARTING_HAND_SIZE) output(this)
+        return
+    }
+    accept(deck.draw())
+    output(this)
+    processHits(deck, input, output)
+}
+```
+
+reviewer (Thread 20): *"재귀함수에 tailrec을 붙이는것에 대해 어떤 역할을 하는지도 꼭 짚어보고 넘어가시면 좋습니다 👍"*
+
+학생 자가 답변:
+
+> *"함수의 마지막 줄이 재귀 호출로 끝날 경우 사용할 수 있고, 재귀를 `while` 문으로 변환해서 재귀 호출이 깊어져도 스택 오버플로우가 발생하지 않도록 방지해주는 기능으로 이해하고 있습니다. 바이트코드를 확인해보니 실제로 재귀 호출을 `while`로 바꿔주는 것이 신기하네요!"*
+
+→ **`tailrec` 자가 학습 + 바이트코드 확인** = *Kotlin 어휘 깊은 자가 학습 정점*. PR #138 (rosemin928 *tailrec 학습 권유*) 결의 *학생 자가 적용 (#138 학생은 적용 X / #142 학생은 적용 + 바이트코드 확인)* 진화.
+
+**MCP 룰 `tailrec-optimization-applicability` 강화** 누적 2+ PR (#138·#142).
+
+### 4. `Result` → `GameResult` Kotlin stdlib 충돌 회피
+
+reviewer (Thread 9):
+
+> *"Kotlin 의 Result와 혼동이 될 수 있으니 보다 명시적인 네이밍으로 수정해볼까요?"*
+
+학생 자가 적용: `Result` → `GameResult`.
+
+→ **Kotlin stdlib 충돌 회피** = PR #130 (medAndro *Number vs kotlin.Number*) 결 강화. **MCP 룰 `class-name-vs-stdlib-collision` 강화** 누적 2+ PR (#130·#142).
+
+### 5. `Bet` (음수 X invariant) vs `Money` (음수 OK) — value class 분리
+
+```kotlin
+class Bet(amount: Int) {
+    val amount = Money(amount)
+    init { require(this.amount >= Money(MIN_BET_AMOUNT)) { ... } }
+}
+
+@JvmInline
+value class Money(val value: Int) {
+    operator fun compareTo(other: Money): Int = this.value.compareTo(other.value)
+    operator fun times(factor: Double): Money = Money((value * factor).toInt())
+}
+```
+
+→ **`Bet` (invariant + Money 합성) vs `Money` (value class + operator)**:
+
+학생 자가 답변 (Thread 13):
+
+> *"`Bet`은 음수가 될 수 없도록 했기 때문에 마이너스가 될 수 있는 `profit`은 별도의 `Money` 클래스에 포장해보았습니다!"*
+
+→ **invariant 다른 두 도메인 객체 = 별도 클래스 분리** = *PR #138 결의 *value class 단일 vs 도메인 invariant 분리* 트레이드오프 진화*.
+
+#### 5.1. *2 가지 시점*
+
+| 안 | 장점 | 단점 |
+|---|---|---|
+| `Money` 단일 + nullable invariant | *단일 value class* | *Bet 의 음수 X invariant 처리 외부* |
+| `Bet` (Money 합성 + invariant) + `Money` (operator) | *각 도메인 invariant 명확* | *Bet ↔ Money 위임 ↑* |
+
+**MCP 룰 `domain-specific-value-class-vs-shared` 후보** — *도메인 별 invariant = 별도 value class*.
+
+### 6. `operator fun compareTo` + `operator fun times` — Kotlin 어휘 자가 활용
+
+```kotlin
+operator fun compareTo(other: Money): Int = this.value.compareTo(other.value)
+operator fun times(factor: Double): Money = Money((value * factor).toInt())
+```
+
+→ **`compareTo` + `times` operator overloading**:
+
+- `compareTo`: `bet.amount >= Money(MIN_BET_AMOUNT)` 가능.
+- `times`: `bet.amount * profitRate` = Money 반환.
+
+reviewer (Thread 19): *"연산자 오버로딩을 잘 활용해주셨네요 👍"*
+
+→ **Kotlin operator overloading 자가 활용** = PR #36 (`operator fun not()` GameResult 반전) 결 합류.
+
+### 7. 패키지 분리 (`participant/`, `card/`, `result/`)
+
+reviewer (Thread 6·7): *"model 패키지 내부에서 participant 와 관련된 도메인은 따로 패키징이 가능할까요?"* + *"card 와 관련된 도메인은 별도로 묶어도 좋을 것 같습니다."*
+
+학생 자가 적용:
+- `model/participant/` (Participant, Player, Dealer).
+- `model/card/` (Card, Hand, Deck, Rank, Suit).
+- `model/result/` (GameResult, Scoreboard).
+
+→ **도메인 별 패키지 분리** = PR #130 (medAndro PR 본문 자가 의문 *패키지 분리*) 결의 *시간 부족으로 미적용 → PR #142 학생 자가 적용 정공*.
+
+**MCP 룰 `package-by-domain` 후보** — *도메인 별 패키지 분리*.
+
+### 8. `enum GameResult` 5 멤버 + cashOut 메서드
+
+```kotlin
+enum class GameResult(private val profitRate: Double) {
+    WIN(1.0), LOSE(-1.0), PUSH(0.0),
+    BLACKJACK_WIN(0.5), BLACKJACK_LOSE(-0.5);
+
+    fun cashOut(player: Player): Money = (player.bet.amount * profitRate)
+}
+```
+
+→ **블랙잭 5 결과 + 순수익 모델 (0.5 vs 1.5)** = *PR #35 (hyemdooly *순수익 모델 0.5*) 결 일관*. PR #36·#87·#138 (총 받음 모델 1.5) 와 *반대 시점*.
+
+#### 8.1. *`BLACKJACK_LOSE(-0.5)` 멤버 = 도메인 정확성*
+
+학생 자가 적용 = *Thread 9 (1단계 학생 자가 답변)* 와 PR #130 (Thread 9 reviewer 블랙잭 룰 인용 *"딜러가 블랙잭이고 플레이어가 블랙잭이 아니지만 합이 21인 경우에도 딜러 승리"*) 결의 *학생 자가 도메인 학습 적용*.
+
+**MCP 룰 `blackjack-rule-fidelity-comparison` 강화** 누적 16+ PR ⭐⭐⭐.
+
+#### 8.2. *`cashOut(player: Player)` 메서드 = enum 책임 강화*
+
+`enum GameResult` 가 *결과 분류 + 수익 계산* 두 책임. **PR #138·#87·#35 결의 *enum 책임 강화* 어휘 합류**.
+
+### 9. `Scoreboard` 객체 분리 — Game god-object 회피
+
+```kotlin
+class Scoreboard(val dealer: Dealer, val players: List<Player>) {
+    fun playersProfits(): Map<Player, Money> = ...
+    fun dealerProfit(players: List<Player>): Money = ...
+}
+```
+
+→ **결과 통계 책임 분리** — *Game → Scoreboard 자가 이동*. reviewer (Thread 2·3·4) *상금 로직 Game ↔ Player 분산 → Result 응집* 권유 → 학생 자가 적용.
+
+**MCP 룰 `result-aggregation-locator` 강화** 누적 2+ PR (#126·#142).
+
+### 10. 추가 칭찬
+
+- Thread 18: *"중복 로직이 굉장히 많이 줄어들었네요 👍"*.
+- Thread 19: *"연산자 오버로딩을 잘 활용해주셨네요 👍"*.
+- 모든 20 스레드 학생 자가 답변 + commit SHA + 자가 코드 예시 2+ 회 (Thread 10, 11) = *학생 자가 학습 가시화 정점 유지*.
+
+## 못한 점 (설계 관점)
+
+### 1. `Player.lateinit var bet: Bet` + `placeBet()` 호출 강제 X — 호출 순서 invariant
+
+```kotlin
+class Player(...) : Participant(name, cards) {
+    lateinit var bet: Bet
+    ...
+    fun placeBet(input: (Player) -> Bet) {
+        bet = input(this)
+    }
+}
+```
+
+→ **`lateinit var bet` + `placeBet()` 호출 강제 X** = *PR #139 (parkjiminnnn *var betAmount + betting()*) 결과 같은 *호출 순서 invariant 부재* 패턴*.
+
+대안:
+- `Player(name, cards, bet: Bet)` 생성자 인자 (PR #139 1차 안 자가 거절 후 PR #142 재발).
+- `Player.startRound(bet: Bet): RoundPlayer` (Round 객체).
+
+**MCP 룰 `lateinit-var-call-order-invariant` 강화** 누적 10+ PR.
+
+### 2. `Dealer.openInitialHand()` vs `Player.openInitialHand()` — 시그니처 동일 / 의미 차이
+
+```kotlin
+// Participant
+abstract fun openInitialHand(): List<Card>
+
+// Player
+override fun openInitialHand(): List<Card> = openHand()  // 2장 전체
+
+// Dealer
+override fun openInitialHand(): List<Card> = openHand().take(INITIAL_OPEN_SIZE)  // 1장만
+```
+
+→ **`openInitialHand` 추상화 정공** — reviewer (Thread 14) *2 가지 대안 비교*:
+
+| 안 | 장점 | 단점 |
+|---|---|---|
+| 별도 추상화 (학생 자가 적용 `openInitialHand`) | *명시적 호출 의도 + 호출 시점 학생 자가 제어* | *비즈니스 로직 = 외부 호출자가 단계 알아야 함* |
+| 딜러 지역변수 (`initialHandShown: Boolean`) | *외부에서 신경 안 씀 + 자가 상태 관리* | *가변 상태 + 호출 횟수 invariant 부재* |
+
+학생 자가 답변 (Thread 14):
+
+> *"최초 오픈 시 별도의 `openInitialHand()` 함수를 사용하도록 변경해보았는데, 말씀하신 내용과 부합할까요? 지역변수로 관리하는 것에 비해 딜러의 행동을 보다 명시적으로 만들 수 있고, 추가적인 상태를 관리할 필요가 없어진다는 장점이 있을 것 같습니다."*
+
+→ **2 안 비교 + 학생 자가 선택**:
+
+- **명시적 호출 + 상태 X (정공)** = *Tell-Don't-Ask 정공 + 호출자가 단계 알아야 함*.
+- **지역변수 + 자가 상태 관리** = *상태 ↑ 위험 (PR #126 결 `initialHandShown` 안티패턴)*.
+
+학생의 선택 = *PR #126 결의 *상태 플래그 vs 도메인 상태 판단* 어휘 진화 + 정공 선택*. PR #126 1단계 reviewer 의 *지역변수 vs 도메인 상태* 의도가 *2단계에서 reviewer 자가 정정 (canHit() 시점 X)* 으로 진화.
+
+#### 2.1. *학생 자가 의문 (Thread 11)*
+
+> *"아하, 무슨 뜻인지 이해했습니다! 그런데 이렇게 된다면 딜러가 처음 뽑은 두 장이 16을 초과할 경우, `canHit()`가 `false`가 되어 처음부터 두 장을 보여줄 것 같은데 제가 놓치고 있는 것이 있을까요? 😵"*
+
+reviewer 자가 정정 (Thread 14):
+
+> *"맞습니다. 기존의 상태를 갖고 판단하게끔 설계하고 싶었지만 처음 뽑은 두장이 canHit() == false 가 될 상황이 생기겠네요."*
+
+→ **reviewer 가 1단계 권유 (canHit() 활용) 의 *경계 케이스 자가 발견* 후 자가 정정** = *PR #130 (hyemdooly *"정말정말 미안해요!!"*) 결과 같은 *reviewer 자가 한계 인정* 어휘 정점*.
+
+**MCP 룰 `state-flag-vs-domain-state-judgement` 강화** 누적 2+ PR (#126·#142). *학생/reviewer 양방향 토론 진화*.
+
+### 3. Game ↔ OutputView 객체 자체 넘김 — 1단계 misunderstanding 자가 정정
+
+Thread 1 §1 참조.
+
+학생 자가 적용 (PR #142 60a159d 커밋):
+
+```kotlin
+// Game.showStatus
+fun showStatus(output: (Participant) -> Unit) {
+    output(dealer)
+    players.forEach { player -> output(player) }
+}
+```
+
+→ **`output: (Participant) -> Unit` 객체 자체 넘김** — *PR #126 1단계 `outputView.printParticipantStatus(participant)` 호출 vs PR #142 *Participant 객체 자체 넘기고 outputView 자가 출력* 진화*.
+
+다만 *Game.showStatus 도 `forEach` 보유* = *외부에서 iteration 안 함*. **MCP 룰 `iteration-locator-domain-vs-view` 후보** — *iteration 위치 = Domain (current 정공) vs View vs Controller*.
+
+### 4. 상금 로직 Game ↔ Player 분산 → Result/Scoreboard 응집
+
+reviewer (Thread 2·3·4): *Game 비대 → Result 응집*.
+
+학생 자가 적용:
+- `enum GameResult.cashOut(player)` = 결과 별 수익 계산.
+- `Scoreboard.playersProfits / dealerProfit` = 통계.
+
+→ **god-object 회피 + 책임 응집** = PR #117·#129·#138·#126 결.
+
+다만 **Game 가 아직 다음 책임 보유**:
+- 참가자 invariant (이름 중복 X / 딜러 이름 X).
+- 베팅 단계 진행 (`processBets`).
+- 카드 분배 (`processPlayersHits`, `processDealerHits`).
+- 상태 출력 위임 (`showStatus`).
+
+→ *Game = 게임 진행 단계 책임 (controller-like) + Scoreboard = 결과 통계 책임*. **MCP 룰 `game-stages-vs-game-state` 후보**.
+
+### 5. `Player.compareAgainst(other)` super + 자식 확장 (PR #138 결과 같은 패턴)
+
+```kotlin
+// Participant
+open fun compareAgainst(other: Participant): GameResult { ... }
+
+// Player
+override fun compareAgainst(other: Participant): GameResult {
+    if (isBusted()) return GameResult.LOSE
+    if (other.isBusted()) return GameResult.WIN
+    return super.compareAgainst(other)
+}
+
+// Dealer
+override fun compareAgainst(other: Participant): GameResult {
+    if (other.isBusted()) return GameResult.WIN
+    if (!isBlackJack() && other.isBlackJack()) return GameResult.BLACKJACK_LOSE
+    return super.compareAgainst(other)
+}
+```
+
+→ **`super` 키워드 활용 = 공통 로직 + 자식 확장** = PR #138 (rosemin928 결과 같은 패턴). **MCP 룰 `super-keyword-for-shared-logic` 강화** 누적 2+ PR (#138·#142).
+
+#### 5.1. *Dealer 의 `BLACKJACK_LOSE` 분기*
+
+블랙잭 표준 룰: *플레이어 21점 (3장 이상) vs 딜러 블랙잭 (2장 21점) = 딜러 승리*. PR #130 (medAndro Thread 9) 의 *블랙잭 룰 학생 자가 학습* → PR #142 (doabletuple) *학생 자가 적용 정공*.
+
+다만 **`BLACKJACK_LOSE = -0.5`** = *0.5배 손실 (0.5 환불)* 의미 양가:
+- *블랙잭 패배 = 0.5배 추가 손실?*
+- *블랙잭 패배 = 베팅의 0.5배만 잃음?*
+
+학생 코드 `GameResult.BLACKJACK_LOSE(-0.5)` = *Player 베팅 × -0.5 = Player -0.5 베팅 손실* = *Dealer +0.5 베팅 수익*. **블랙잭 표준 룰과 양가** — 표준은 *Player Bust + Dealer Bust = Player Lose 베팅 전부* / *블랙잭 vs 일반 = 베팅 전부 손실*.
+
+**MCP 룰 `blackjack-payout-vs-profit-model` 강화** 누적 2+ PR (#35·#142).
+
+### 6. `lateinit var bet` Player 호출 강제 X — §1 참조
+
+### 7. 카드덱 효율 사용 — companion lazy + shuffled() 재호출
+
+reviewer (Thread 17):
+
+> *"현재 Suit, Rank를 조합하여 카드를 생성하고 있는데요. 플레잉카드는 정해진 모양과 숫자를 조합해 만들어지는데 카드덱에 있는 카드를 모두 사용하여 새로 추가를 해줘야 할 때, 다시. 카드 인스턴스를 모두 생성해주어야 할까요? 효율적으로 할 수 있는 방법이 있을까요?"*
+
+학생: *"`companion object`에서 만들어두면 카드를 추가할 때 새로운 인스턴스가 만들어지지 않는다고 생각했는데, 제가 잘못 이해하고 있었던 것 같네요 😅 해당 부분을 더 공부해보고 적용하도록 하겠습니다 🙏"*
+
+reviewer 후속:
+
+> *"밑에 `Pack` 과 `cards` 키워드를 제가 헷갈린거 같네요 🥲*
+> *처음엔 **suffled 된 카드 자체를 캐싱**하자는 의도를 갖고 코멘트를 남겼었지만, 현실 세계에 도입해보면 과할 수 있겠다는 생각이 한편으로는 드네요 ㅎㅎ..*
+> *말씀주신 것 처럼 기존에 companion object로 선언된 `pack` 으로 캐싱 처리를 잘 해주셨어요. 다만, 카드가 부족할 때 부족한 카드덱으로 다시 shuffled() 를 진행하는것에 대해 이야기를 하고 싶었는데 잘 수정해주셨네요 💯"*
+
+→ **reviewer 가 자가 혼동 + 학생이 *이미 적절히 구현* 인정** = *PR #130 결의 *reviewer 자가 한계 인정* 어휘 강화*.
+
+**MCP 룰 `reviewer-self-confusion-explicit` 후보** — *reviewer 가 자가 코드 읽기 혼동 명시*.
+
+### 8. 모델 → View 에러 메시지 위치 자가 의문
+
+reviewer (Thread 5): *"이또한 outputView로 다시 이사를 해야겠네요 😂"* (학생 도메인 안에 String 메시지)
+
+학생: *"앗, `Model`이 던지는 에러 메시지의 상수도 `OutputView`가 가지고 있는 것이 좋다고 이해하면 될까요?"*
+
+reviewer (Thread 12) 자가 정정: *"에러에 관련된 문구였군요 ㅎㅎ 😂 위 상수는 Model에 위치하는게 맞습니다! 👍"*
+
+→ **에러 메시지 = Model 위치 OK + reviewer 자가 정정** = *PR #126 (Verdict 문자열 = View 책임) 결과 *에러 메시지 = Model OK* 반대 시점 (변경 가능성 vs invariant 검증 어휘 차이)*.
+
+#### 8.1. *에러 메시지 vs UI 메시지 구분*
+
+- **에러 메시지 (Model)**: *invariant 검증 + 도메인 의미*.
+- **UI 메시지 (View)**: *출력 + 사용자 표현*.
+
+PR #126 (Verdict 출력 문자열 = View) vs PR #142 (Bet 에러 메시지 = Model) **반대 시점 = 차이 명시**.
+
+**MCP 룰 `model-error-vs-view-message-locator` 후보** — *에러 메시지 vs UI 메시지 위치 구분*.
+
+### 9. `Bet.MIN_BET_AMOUNT = 0` — 0 의미 부여
+
+```kotlin
+companion object {
+    private const val MIN_BET_AMOUNT = 0
+    private const val ERROR_MESSAGE_BET_NOT_POSITIVE = "베팅 금액은 ${MIN_BET_AMOUNT}보다 작을 수 없습니다."
+}
+```
+
+reviewer (Thread 8): *"0 이라는 금액도 상수를 통해 의미를 부여할 수 있을거에요"*
+
+학생 자가 적용.
+
+→ **매직 넘버 (0) → 상수 명명** = PR #117 (16 매직 넘버) 결 합류. **MCP 룰 `magic-number-zero-as-named-constant` 후보**.
+
+다만 **`MIN_BET_AMOUNT = 0` + `require(amount >= Money(0))`** = *베팅 0원 가능* 의미. *블랙잭 표준 = 최소 베팅 ≥ $5* (PR #138 결의 *1000원* vs PR #142 *0원* 양가).
+
+PR #138·#129 결의 *블랙잭 베팅 최소 1000원* 와 *반대 시점*. **블랙잭 도메인 룰 양가성 = 임의 도메인 상수**.
+
+**MCP 룰 `domain-rule-arbitrary-constant` 강화** 누적 3+ PR (#138·#35·#142).
+
+### 10. `Player(name, cards)` + 부생성자 2개 (vararg) — 테스트 fixture 의도
+
+```kotlin
+class Player(name: String, cards: List<Card>) : Participant(name, cards) {
+    lateinit var bet: Bet
+
+    constructor(name: String, vararg cards: Card) : this(name, cards.toList())
+    constructor(name: String, betAmount: Int, vararg cards: Card) : this(name, cards.toList()) {
+        this.bet = Bet(betAmount)
+    }
+    ...
+}
+```
+
+→ **부생성자 2개 (vararg)** = PR #126·#130 (test-fixture-secondary-constructor) 결 강화 누적 3+ PR.
+
+다만 **부생성자 2번째 가 `this.bet = Bet(betAmount)` lateinit 즉시 초기화** = *호출 순서 invariant 회피 가능 (테스트 한정)*. 
+
+### 11. `Player.placeBet(input: (Player) -> Bet)` — 람다 인자 = View 결합
+
+```kotlin
+fun placeBet(input: (Player) -> Bet) {
+    bet = input(this)
+}
+```
+
+→ **`(Player) -> Bet` 람다 인자 = View 호출 람다** = PR #36·#129·#138 (callback-lambda-view-cost) 결.
+
+대안: `Player.setBet(bet: Bet)` — *Player 가 *bet 객체 받음* + Controller 가 View 호출 + Player.setBet 호출*. **MCP 룰 `callback-lambda-vs-direct-setter` 후보**.
+
+### 12. `processBets` `processPlayersHits` `processDealerHits` `showStatus` — Game 의 행동 메서드 4개
+
+§4 참조. Game = 게임 진행 단계 책임 다수.
+
+### 13. `Dealer.processHits(deck, output: (Dealer, Int) -> Unit)` — output 인자 `(Dealer, Int)`
+
+```kotlin
+tailrec fun processHits(deck: Deck, output: (Dealer, Int) -> Unit) {
+    if (!canHit()) return
+    output(this, HIT_THRESHOLD)
+    accept(deck.draw())
+    processHits(deck, output)
+}
+```
+
+→ **`(Dealer, Int) -> Unit` 람다 인자 = Dealer 객체 + HIT_THRESHOLD 정수 둘 다 외부 전달** = *PR #36 결의 *Tuple 누수* 변형*.
+
+대안: `output(this)` 만 (View 가 Dealer 의 hit 한계 직접 호출). **MCP 룰 `lambda-multiple-args-tuple-leak` 후보**.
+
+### 14. `Scoreboard.dealerProfit(players: List<Player>)` — players 외부 인자 받음
+
+```kotlin
+fun dealerProfit(players: List<Player>): Money {
+    return Money(players.sumOf { player -> dealer.compareAgainst(player).cashOut(player).value })
+}
+```
+
+→ **`players` 외부 인자 받음** = *Scoreboard 가 이미 `players` 멤버 보유 (constructor)* → *중복 인자*. **MCP 룰 `redundant-parameter-vs-member` 후보**.
+
+대안:
+```kotlin
+fun dealerProfit(): Money {
+    return Money(players.sumOf { player -> dealer.compareAgainst(player).cashOut(player).value })
+}
+```
+
+### 15. `Game(deck, dealer, players)` 생성자 (3 변수) — 형식 규칙 vs 도메인 정합
+
+```kotlin
+class Game(
+    private val deck: Deck,
+    val dealer: Dealer,
+    val players: List<Player>,
+) { ... }
+```
+
+→ **3 변수** = *형식 규칙 위반*. 다만 *deck + dealer + players = 도메인 정합 (블랙잭 게임 3 구성요소)* = *형식 규칙 위반 무의미*.
+
+PR #138 (rosemin928 *형식 규칙 vs 도메인 의미 자가 의문*) 결의 *학생 자가 정공 선택* 일관.
+
+### 16. `Game.players: List<Player>` (Participants 일급 컬렉션 X)
+
+```kotlin
+class Game(... val players: List<Player>)
+```
+
+→ **`List<Player>` 노출 (1단계 #126 `Participants` 일급 컬렉션 → 2단계 #142 *Game.players: List<Player>* 노출 회귀)** = *Participants 객체 제거 + Game 가 players 직접 보유*.
+
+**MCP 룰 `first-class-collection-regression` 후보** — *1단계 일급 컬렉션 → 2단계 노출 회귀*.
+
+다만 **Game 이 Participants 책임 흡수** = *책임 통합 시점* — PR #138 (rosemin928 *BlackJackTable 자가 제거*) 결의 *형식 규칙 부산물 제거* 어휘 일관.
+
+### 17. `Money operator times(factor: Double)` `(value * factor).toInt()` 정밀도 손실
+
+```kotlin
+operator fun times(factor: Double): Money = Money((value * factor).toInt())
+```
+
+→ **`Double * Int → Double → toInt()`** = *소수점 손실*. *블랙잭 1.5배 = 100 × 1.5 = 150 (정공) / 100 × 0.5 = 50 (정공)* → *현재 안 OK*.
+
+다만 **`factor: Double` 인자 받음** = *임의 비율 가능* = *블랙잭 도메인 5 멤버 한정 X*. **MCP 룰 `times-factor-overflow-risk` 후보**.
+
+### 18. `Player.compareAgainst(other)` `super` 호출 — Dealer 의 BLACKJACK_LOSE 처리 X
+
+```kotlin
+// Player
+override fun compareAgainst(other: Participant): GameResult {
+    if (isBusted()) return GameResult.LOSE
+    if (other.isBusted()) return GameResult.WIN
+    return super.compareAgainst(other)
+}
+```
+
+→ **Player 시점 BLACKJACK_LOSE 처리 X** = *super 가 PUSH/BLACKJACK_WIN/WIN/LOSE/PUSH 만 반환 → Player 의 BLACKJACK_LOSE 케이스 미처리*.
+
+학생 코드의 *Dealer.compareAgainst* 만 `BLACKJACK_LOSE` 분기. *Scoreboard.playersProfits = player.compareAgainst(dealer) 호출* → *Player 시점 → BLACKJACK_LOSE 결과 안 나옴*.
+
+**대칭 깨짐** — *Player 결과 vs Dealer 결과 = 대칭 (부호 반전) 아님*. 
+
+#### 18.1. *Scoreboard 의 결과 호출*
+
+```kotlin
+fun playersProfits(): Map<Player, Money> = 
+    players.associateWith { player -> player.compareAgainst(dealer).cashOut(player) }
+
+fun dealerProfit(players: List<Player>): Money = 
+    Money(players.sumOf { player -> dealer.compareAgainst(player).cashOut(player).value })
+```
+
+→ **Player.compareAgainst(dealer) + Dealer.compareAgainst(player) 둘 다 호출** = *반복 비교*. *PR #142 (학생 자가 인지 + reviewer 권유 정공)*.
+
+다만 **결과 호출 양쪽 = 중복 평가 비용 + 도메인 일관성 유지 어려움**:
+- Player.compareAgainst(dealer) 시 isBlackJack 분기.
+- Dealer.compareAgainst(player) 시 BLACKJACK_LOSE 분기.
+
+→ **각 시점 별 BLACKJACK 분기 양가** = *PR #87·#36 결의 *symmetric-getResult vs compareWith* 어휘 합류 + 진화*.
+
+**MCP 룰 `symmetric-compare-bidirectional-call` 후보** — *양쪽 객체 모두 자가 비교 = 중복 평가*.
+
+### 19. `Hand.STARTING_HAND_SIZE` 상수 — companion object
+
+```kotlin
+// in Hand (가정)
+companion object { const val STARTING_HAND_SIZE = 2 }
+
+// in Player.processHits
+if (openHand().size == Hand.STARTING_HAND_SIZE) output(this)
+```
+
+→ **`Hand.STARTING_HAND_SIZE` 상수 외부 접근** = *도메인 룰 (초기 2장) Hand 에 위치 정공*. PR #130 (medAndro *초기 카드 장수 = 도메인 상수*) 결 강화.
+
+### 20. `Bet ↔ Money` 합성 + Bet 미인스턴스 시 lateinit 의존
+
+```kotlin
+class Bet(amount: Int) {
+    val amount = Money(amount)
+    ...
+}
+```
+
+→ **Bet 합성: Bet 객체 안에 Money 객체** = *2 단계 위임 (`bet.amount.value`)*. PR #87 (디미터 법칙) 결의 *깊이 위반 가능*.
+
+대안: `Bet(value: Int) extends Money` 또는 *Bet 이 Money 멤버 X + Money invariant 강화*. **MCP 룰 `composition-vs-extension-tradeoff` 후보**.
+
+## 리뷰어 의견 요지
+
+- **1단계 misunderstanding 자가 정정 + 양방향 사과** — *reviewer 자가 명료화 + 학생 자가 사과*.
+- **다형성 학습 = 딜러도 자가 비교** — *학생 자가 코드 예시 + 5 라운드 양방향*.
+- **`tailrec` Kotlin 어휘 자가 학습 + 바이트코드 확인**.
+- **`Result` Kotlin stdlib 충돌 → `GameResult`** — 누적 2 PR.
+- **`Bet` (음수 X) vs `Money` (음수 OK) 분리 + value class**.
+- **operator overloading 활용 (compareTo, times)** — 칭찬.
+- **패키지 분리 (participant/card/result)**.
+- **상금 로직 Game ↔ Player 분산 → Result 응집** + **Scoreboard 객체 생성**.
+- **`openInitialHand` 별도 추상화 vs 지역변수 (reviewer 자가 정정)**.
+- **에러 메시지 = Model 위치 OK (reviewer 자가 정정)**.
+- **`0` 매직 넘버 → MIN_BET_AMOUNT 상수**.
+- **카드덱 효율 = companion + shuffled() (reviewer 자가 혼동 + 학생 정공)**.
+- **수정 후 칭찬** — *중복 로직 줄어듦 + 연산자 오버로딩*.
+
+## 대표 인용
+
+> [KwonDae Thread 1]
+> *"잘 구현해주셨습니다 👍 다만 제가 혼란을 드린 것 같아 죄송하네요.. 🥲 코멘트의 의도는 Controller에서 데이터를 꺼내 OutputView로 개별로 전달하는 것에 대한 이야기였습니다. (...) 명확하지 못한 코멘트가 view 관련 함수가 domain으로 들어오게 하는 혼란을 야기한것 같네요. 보다 명확하게 전달드릴 수 있도록 하겠습니다 🙇‍♂️"*
+
+→ **reviewer 자가 의도 명료화 + 자가 사과** — **MCP 핵심 가치 정점**. PR #130 강화.
+
+> [doabletuple Thread 1]
+> *"제가 완전히 잘못 이해하고 있었네요 😭 헷갈리는 부분은 바로 질문을 드렸어야 하는데, 뒤늦게 여쭤봐서 죄송합니다 🙇‍♂️"*
+
+→ **양방향 자가 사과** — *학습 가시화*.
+
+> [KwonDae Thread 15]
+> *"현재 우리는 다형성을 학습하고 있어요. 물론 하나의 객체에 로직을 부여해 판단하는 방법이 틀린게 아닙니다. 다만 객체 지향 프로그래밍에서 다형성 을 통해 어떤 이점을 얻을 수 있을지 깊게 고민해보셔도 좋을거에요"*
+
+→ **학습 목표 회수 어휘** — *MCP `oh-my-oop` 핵심 가치 (학습 의도 회수)*.
+
+> [doabletuple Thread 15]
+> *"비교 반복을 없에는 일에 한눈이 팔려서 학습 목표를 놓치고 있었네요 😅"*
+
+→ **학생 자가 학습 목표 회수**.
+
+> [KwonDae Thread 14]
+> *"맞습니다. 기존의 상태를 갖고 판단하게끔 설계하고 싶었지만 처음 뽑은 두장이 canHit() == false 가 될 상황이 생기겠네요."*
+
+→ **reviewer 자가 경계 케이스 인정**.
+
+> [doabletuple Thread 20]
+> *"함수의 마지막 줄이 재귀 호출로 끝날 경우 사용할 수 있고, 재귀를 `while` 문으로 변환해서 재귀 호출이 깊어져도 스택 오버플로우가 발생하지 않도록 방지해주는 기능으로 이해하고 있습니다. 바이트코드를 확인해보니 실제로 재귀 호출을 `while`로 바꿔주는 것이 신기하네요!"*
+
+→ **tailrec 자가 학습 + 바이트코드 확인** — *학생 자가 학습 깊이 정점*.
+
+> [KwonDae Thread 17]
+> *"밑에 `Pack` 과 `cards` 키워드를 제가 헷갈린거 같네요 🥲 (...) 말씀주신 것 처럼 기존에 companion object로 선언된 `pack` 으로 캐싱 처리를 잘 해주셨어요."*
+
+→ **reviewer 자가 혼동 명시 + 학생 정공 인정**.
+
+## 얻은 교훈 (보편)
+
+1. **reviewer 자가 의도 명료화 + 자가 사과 (Thread 1)** — *PR #130 결의 *reviewer 자가 한계 인정* 강화*. **MCP 룰 `reviewer-self-clarification-explicit` 후보**.
+
+2. **양방향 자가 사과 + 학생 자가 *바로 질문* 후회** — *학습 가시화 정점*.
+
+3. **다형성 학습 = 변경 가능성 대응** — *학습 목표 회수 어휘*. **MCP 룰 `polymorphism-as-change-tolerance` 후보**.
+
+4. **학생 자가 코드 예시 + 자가 의문 (Thread 10)** — *학습 가시화 정점*. **MCP 룰 `student-self-code-example-as-question` 후보**.
+
+5. **`tailrec` 자가 학습 + 바이트코드 확인** — *Kotlin 어휘 깊은 자가 학습*. **MCP 룰 `tailrec-optimization-applicability` 강화** 누적 2+ PR.
+
+6. **Kotlin stdlib 충돌 (Result/Number)** — **MCP 룰 `class-name-vs-stdlib-collision` 강화** 누적 2+ PR.
+
+7. **`Bet` (invariant) vs `Money` (operator) 분리** — *도메인 별 invariant = 별도 value class*. **MCP 룰 `domain-specific-value-class-vs-shared` 후보**.
+
+8. **패키지 분리 (도메인 별)** — **MCP 룰 `package-by-domain` 후보**.
+
+9. **`openInitialHand` 별도 추상화 vs 지역변수 (reviewer 자가 정정)** — **MCP 룰 `state-flag-vs-domain-state-judgement` 강화** 누적 2+ PR.
+
+10. **에러 메시지 = Model 위치 OK (변경 가능성 vs invariant 검증 어휘 차이)** — *PR #126 (Verdict 출력 = View) 반대 시점*. **MCP 룰 `model-error-vs-view-message-locator` 후보**.
+
+11. **카드덱 효율 = companion + shuffled() (reviewer 자가 혼동)** — **MCP 룰 `reviewer-self-confusion-explicit` 후보**.
+
+12. **`super` 키워드 = 공통 로직 + 자식 확장** — **MCP 룰 `super-keyword-for-shared-logic` 강화** 누적 2+ PR (#138·#142).
+
+13. **`lateinit var bet` 호출 순서 invariant (PR #139 재발)** — **MCP 룰 `lateinit-var-call-order-invariant` 강화** 누적 10+ PR.
+
+14. **양쪽 객체 자가 비교 + 중복 평가** — *symmetric-compare-bidirectional-call*. **MCP 룰 후보**.
+
+15. **0 매직 넘버 → 상수 명명** — **MCP 룰 `magic-number-zero-as-named-constant` 후보**.
+
+16. **`callback 람다` vs `setter` 트레이드오프** — **MCP 룰 `callback-lambda-vs-direct-setter` 후보**.
+
+17. **iteration 위치 = Domain vs View vs Controller** — **MCP 룰 `iteration-locator-domain-vs-view` 후보**.
+
+18. **부생성자 + lateinit 즉시 초기화 (테스트 fixture)** — **MCP 룰 `test-fixture-secondary-constructor` 강화** 누적 3+ PR.
+
+19. **블랙잭 0.5 vs 1.5 모델 (PR #35·#142 0.5 모델 = 누적 2+ PR)** — **MCP 룰 `blackjack-payout-vs-profit-model` 강화**.
+
+20. **블랙잭 5 멤버 (WIN/LOSE/PUSH/BLACKJACK_WIN/BLACKJACK_LOSE)** — *PR #130 학생 자가 학습 → PR #142 자가 적용 (1단계 → 2단계 학습 시간성)*.
+
+21. **모든 20 스레드 학생 자가 답변 + commit SHA + 자가 코드 예시 2+ 회** — *2025 코호트 정점 유지*.
+
+## 얻은 교훈 (도메인)
+
+1. **블랙잭 5 결과 (WIN/LOSE/PUSH/BLACKJACK_WIN/BLACKJACK_LOSE)** — *PR #130 1단계 자가 학습 → PR #142 2단계 자가 적용*.
+
+2. **블랙잭 0.5 모델 (순수익)** = *PR #35 결*.
+
+3. **Dealer canHit = `<= 16` 정공** — PR #126·#138 결.
+
+4. **블랙잭 = 초기 2장 + 21점 = isBlackJack** = PR #130·#138·#126 결.
+
+5. **`tailrec` Kotlin 어휘 + 바이트코드** — 학생 자가 학습 정점.
+
+6. **Bet 0원 가능 (`MIN_BET_AMOUNT = 0`)** — *PR #138 (1000원) / PR #129 (1원) 와 양가 = 임의 도메인 상수*.
+
+7. **카드덱 caching (companion pack) + shuffled() 재호출** — *카드 부족 시 재 shuffled*.
+
+## MCP 룰 후보 신규 + 강화 (PR #142)
+
+| 룰 | 신규 / 강화 | 누적 PR |
+|---|---|---|
+| `reviewer-self-clarification-explicit` | 신규 | 1 (#142) |
+| `polymorphism-as-change-tolerance` | 신규 | 1 (#142) |
+| `student-self-code-example-as-question` | 신규 | 1 (#142) |
+| `tailrec-optimization-applicability` | 강화 | 2+ (#138·#142) |
+| `class-name-vs-stdlib-collision` | 강화 | 2+ (#130·#142) |
+| `domain-specific-value-class-vs-shared` | 신규 | 1 (#142) |
+| `package-by-domain` | 신규 | 1 (#142) |
+| `state-flag-vs-domain-state-judgement` | 강화 | 2+ (#126·#142) |
+| `model-error-vs-view-message-locator` | 신규 | 1 (#142) |
+| `reviewer-self-confusion-explicit` | 신규 | 1 (#142) |
+| `super-keyword-for-shared-logic` | 강화 | 2+ (#138·#142) |
+| `lateinit-var-call-order-invariant` | 강화 | 10+ |
+| `symmetric-compare-bidirectional-call` | 신규 | 1 (#142) |
+| `magic-number-zero-as-named-constant` | 신규 | 1 (#142) |
+| `callback-lambda-vs-direct-setter` | 신규 | 1 (#142) |
+| `iteration-locator-domain-vs-view` | 신규 | 1 (#142) |
+| `test-fixture-secondary-constructor` | 강화 | 3+ |
+| `blackjack-payout-vs-profit-model` | 강화 | 2+ (#35·#142) |
+| `blackjack-rule-fidelity-comparison` | 강화 | 16+ ⭐⭐⭐ |
+| `domain-rule-arbitrary-constant` | 강화 | 3+ |
+| `first-class-collection-regression` | 신규 | 1 (#142) |
+| `times-factor-overflow-risk` | 신규 | 1 (#142) |
+| `composition-vs-extension-tradeoff` | 신규 | 1 (#142) |
+| `lambda-multiple-args-tuple-leak` | 신규 | 1 (#142) |
+| `redundant-parameter-vs-member` | 신규 | 1 (#142) |
+| `game-stages-vs-game-state` | 신규 | 1 (#142) |
+| `result-aggregation-locator` | 강화 | 2+ (#126·#142) |
+
+## 메타 어휘 (14 reviewer + MCP 핵심 가치 합류 정점 유지)
+
+- ***reviewer 자가 의도 명료화 + 자가 사과*** — KwonDae PR #142 — *"제가 혼란을 드린 것 같아 죄송하네요.. 🥲"* — *PR #130 (hyemdooly *"정말정말 미안해요!!"*) 결 강화*.
+- ***학습 목표 회수 어휘*** — KwonDae PR #142 — *"현재 우리는 다형성을 학습하고 있어요. (...) 어떤 이점을 얻을 수 있을지 깊게 고민해보셔도 좋을거에요"*.
+- ***학생 자가 학습 목표 회수*** — doabletuple PR #142 — *"비교 반복을 없에는 일에 한눈이 팔려서 학습 목표를 놓치고 있었네요"*.
+- ***학생 자가 코드 예시 + 자가 의문*** — doabletuple PR #142 — *학습 가시화 정점*.
+- ***reviewer 자가 경계 케이스 인정*** — KwonDae PR #142 — *"맞습니다. 기존의 상태를 갖고 판단하게끔 설계하고 싶었지만 처음 뽑은 두장이 canHit() == false 가 될 상황이 생기겠네요."*.
+- ***`tailrec` 자가 학습 + 바이트코드 확인*** — doabletuple PR #142 — *Kotlin 어휘 깊은 자가 학습 정점*.
+- ***reviewer 자가 혼동 명시*** — KwonDae PR #142 — *"`Pack` 과 `cards` 키워드를 제가 헷갈린거 같네요 🥲"*.
+
+→ **14 reviewer + MCP 핵심 가치 어휘 합류 정점 유지**. **batch 21 신규 발견 = *학생 자가 코드 예시 + 자가 의문 + reviewer 자가 정정 4 자리*** (Thread 1·11·14·17) = **양방향 토론 깊이 정점**.
+
+## 비교 (PR #126 → #142 진화 — 사족 X, 안티패턴 명시만)
+
+- **1단계 #126 18 thread → 2단계 #142 20 thread** — *깊이 유지*.
+- **1단계 #126 Verdict 출력 문자열 = View 책임 → 2단계 #142 GameResult enum 책임 강화 + cashOut 메서드** — *학습 시간성 정공*.
+- **1단계 #126 `var initialHandShown` 가변 상태 → 2단계 #142 `openInitialHand` 별도 추상화 (학생 자가 정공 선택)** — *학습 시간성 정공*.
+- **1단계 #126 Participants 일급 컬렉션 → 2단계 #142 Game.players: List<Player> 노출 회귀** — *Participants → Game 책임 통합*.
+- **1단계 #126 Result enum → 2단계 #142 GameResult enum (Kotlin stdlib 충돌 자가 정정)** — *학습 시간성 정공*.
+- **1단계 #126 카드 N장 공개 추상화 (`showHand`) → 2단계 #142 별도 `openInitialHand` 추상화 추가** — *추상화 진화*.
+- **1단계 #126 학생 자가 4 안 분석 (`list`/`all`) → 2단계 #142 학생 자가 코드 예시 (Thread 10)** — *학생 자가 학습 가시화 진화*.
+
+→ *진화 비교 = 사족 아님* + *학생 자가 학습 정점 진화 + reviewer 자가 한계 인정 어휘 합류*.