Merge pull request '하네스: 카드 kind↔효과 규칙(RULES §9)+검증도구 + codex 규칙 보강 (협업자 반영)' (#103 ) from docs/harness-card-kinds into main

docs(rules): 카드 kind↔효과 규칙(§9)+검증도구 + codex 규칙 보강 (협업자 하네스 반영)
이번 세션에서 발견·수정한 하네스 학습을 저장소(공유 매개)에 반영해 협업자(codex 등)도 적용받게 한다. 메모리는 로컬이라 공유 안 됨. - RULES.md §9 신설 (카드 kind ↔ 효과 일치): ResolveCardDrop 라우팅 (Attack=몬스터드롭/Skill·Power=스윕/Status=unplayable)·Power 분기가 damage/aoe 무시 → 데미지=Attack, block/유틸=Skill, 지속효과=Power. 안 맞으면 사용불가/死카드(아이언 바디·분노 사고). - tools/verify/cardkinds.mjs 신설: kind↔효과 위반(Attack-무데미지/ Power-무효과/미지원 kind) 정적 검출(이상 0=exit 0). 현재 main 147장 0, Defend=Attack·Rage=Power 위반은 2건 검출 확인. - docs/codex-working-rules.md 6~9 추가: ⑥ main 머지 충돌 시 머지 전체 revert 금지(소스 충돌만 해소·산출물 재생성 — #98/#99가 #96 날린 사고) ⑦ 카드 kind 일치+cardkinds 검증 ⑧ 변경 후 검증 스위트 ⑨ RULES.md 권위. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UUvHKjrt8jqLzDeCsRRGmj
2026-06-30 17:12:40 +09:00 · 2026-06-30 17:11:11 +09:00 · 2026-06-30 08:35:52 +09:00 · 2026-06-30 08:34:54 +09:00 · 2026-06-30 08:34:54 +09:00 · 2026-06-30 02:33:07 +09:00
38 changed files with 3547 additions and 989 deletions
--- a/README.md
+++ b/README.md
@@ -121,6 +121,7 @@ slaymaple/
 | **로비 마을** | 전용 물리 맵 `lobby.map`(마을 배경). **NPC 4종 월드 엔티티** — 모험가(런 시작)·사서(카드 도감)·상인(영혼 상점)·안내원(게시판). 근접 시 머리 위 마크 + `↑`키 **또는 직접 클릭**으로 상호작용. **이동·공격 모션은 로비 맵에서만** 풀림(전투맵은 잠금), 카메라는 로비에서 **플레이어 추종**(전투맵은 고정) |
 | **캐릭터·전직** | 시작 시 **전사(HP80)/도적(HP70)/마법사(HP70)** 3종 선택(**초상화·직업 설명·선택 테두리 강조** 캐릭터 선택 UI), 클래스별 시작 덱. 보스 클리어 시 [유물] vs [**2차 전직**] — 각 클래스 3종(전사→파이터/페이지/스피어맨, 법사→위자드불독/위자드썬콜/클레릭, 도적→Shiv/Poison/Trickster). 전용 카드는 해당 클래스 풀만 획득 |
 | **카드 전투** | 에너지 3·드로우·**드래그 사용**(공격=적에 드롭, 스킬=위로 스윕). 카드 **121장** — kind **Attack/Skill/Power/Status**. 메커니즘: 다단히트·방어 무시·자가 디버프·드로·회복·**전체 공격(AoE)**·**독(DoT)**·**retain**(턴 종료 손패 유지)·**sly discard**(버림 트리거) |
+| **도적 카드 공용 효과** | 카드 효과를 **카드명 하드코딩 대신 `data/cards.json` 공용 필드**로 표현(재사용). **불가침**·**x-cost**(에너지 비례 피해/약화)·드로우 수 비례 데미지·**다음 스킬 반복**·**처치 보상/반복**·카드 설명 **키워드 하이라이트**·드로우 연동(`drawSkillBlock`·`drawPoison`)·독 버스트·랜덤 타깃 등. **Lua + JS 미러 양쪽 구현**. 필드 사전 [`docs/card-effect-fields.md`](docs/card-effect-fields.md) |
 | **버프/디버프** | StS 표준 — **힘**(+N 영구)·**약화**(주는 피해 −25%)·**취약**(받는 피해 +50%)·**독**(매 행동 틱). 양방향(적 디버프 인텐트 포함), 인텐트는 최종 예상치 표시 |
 | **전투 연출** | 공격 이펙트·**몬스터 데미지 팝업(자릿수 스킨)**·드래그 타깃 마커·적 개별 차례·**공격/피격/독뎀 모션**(아바타 상태 전이·몬스터 hit 클립·런지/넉백) |
 | **절차 생성 맵** | 막 시작마다 **경로 생성**(런마다 다름, **가로 진행**). 층 규칙: 1~2층 전투만 → 3층~ 상점/휴식 → 4층~ 엘리트/**유물 방** → 보스 수렴. 점선 경로·상태 4단·층 카운터. 노드 타입별 **몬스터 랜덤 구성**(일반 1~3 / 엘리트 / 보스) + intent 랜덤 행동 |
@@ -130,7 +131,7 @@ slaymaple/
 | **승천(Ascension)** | A1~A10 누적 모디파이어(적 강화·시작 HP 감소·보상 감소). UserDataStorage 유저별 영구 저장, 런 클리어 시 다음 단계 해금 |
 | **멀티 act** | **5막** 진행(보스 클리어→다음 막 텔레포트, 맵·인카운터 변경, 적 스케일 `1+(막-1)*0.45`), 5막 클리어 시 런 종료 |
 | **경제** | 화폐 표기 **메소**(코인 아이콘), 카드/유물/물약 메소 가격. 내부 식별자는 Gold 유지 |
-| **밸런스 시뮬** | `tools/balance/sim-balance.mjs` — 전투 규칙 JS 미러(몬테카를로) + `tools/map/rogue-map.mjs`(맵 생성 미러) + node 단위테스트 |
+| **밸런스 시뮬** | `tools/balance/sim-balance.mjs` — 전투 규칙 JS 미러(몬테카를로) + `tools/map/rogue-map.mjs`(맵 생성 미러) + node 단위테스트(현 84종) |

 > ⚠️ 수치(적 스탯·경제·승천 배율)는 1차 조정 상태입니다. 정밀 밸런싱은 `sim-balance.mjs`로 검증하며 진행합니다.
 > ℹ️ 도적(Silent) 카드 86장은 STS Silent 완역 포트 + **공식 스킬 아이콘 적용 완료**. 남은 작업은 카드명 메이플 재서사(어쌔신/시프)·멀티플레이어 전제 카드 싱글 정리 — [`docs/deck-concept.md`](docs/deck-concept.md) 참조.
--- a/RULES.md
+++ b/RULES.md
@@ -23,7 +23,7 @@ Claude Code는 `CLAUDE.md`가 이 파일을 임포트하므로 자동 적용된

 - `.claude/settings.json`의 permissions.deny가 위 파일의 Read/Edit/Write 도구 사용을 차단한다 (이 저장소를 열면 자동 적용). deny는 **glob** — `ui/*.ui`·`map/*.map`·`RootDesk/MyDesk/*.codeblock`·`Global/common.gamelogic`·`Global/SectorConfig.config`. 따라서 **메이커 저작 codeblock/UI**(`Monster`·`MonsterAttack`·`PlayerAttack`·`PlayerHit`·`UIPopup`·`UIToast`.codeblock, **그리고 모든 `ui/*.ui`** — UI는 6개 UIGroup으로 메이커 저작)**도** Read/Edit 금지 — 이들은 생성기가 없으니 **메이커에서** 편집한다(텍스트 도구로 X). codeblock은 한 줄짜리 JSON이라 Read 시 토큰 폭발.
 - **게임 로직 수정** = `tools/deck/gen-slaydeck.mjs`(오케스트레이터) + `tools/deck/cb/*.mjs`(codeblock Lua) 또는 `data/*.json`(데이터) 수정 → 재생성(`SlayDeckController.codeblock`+`common.gamelogic`만, **`.ui` 미접근**) → 통째로 커밋. **UI 수정 = 메이커에서**(생성기는 UI를 안 만든다).
-  - **codeblock 메서드(Lua)는 기능별 모듈** `tools/deck/cb/*.mjs`(boot·state·combat·hand·deckview·items·map·shop 등 17종). **공유분**: 상수·데이터·lua 테이블 = `tools/deck/lib/{ui-helpers,data,codeblock}.mjs`(cb가 import — `MAX_MONSTERS`=4 등). prop 103개는 오케스트레이터 `writeCodeblocks`에 유지. 특정 메서드 수정은 `cb/<name>.mjs`만(의존: orchestrator→cb→lib 단방향). **cb 모듈은 원본 메서드 순서 보존이 바이트동일 조건**. **UI emit(옛 `hud/*.mjs` 15종·`gen-cardhand.mjs`)은 `tools/deck/legacy/`로 이관 — 휴면(생성기 미사용)**: UI가 메이커 저작이라 생성기가 안 만든다. (롤백용 `legacy/upsert-ui.mjs`는 직접 실행 시에만 옛 `DefaultGroup.ui`를 재생성.)
+  - **codeblock 메서드(Lua)는 관심사별 모듈** `tools/deck/cb/*.mjs`(boot·screens·npc·navigation·layout·combat·hand·deckview·items·map·shop 등 20종 — 화면전환=`screens`·NPC=`npc`·포지션=`navigation`(월드 텔레포트)/`layout`(UI 슬롯 배치). 새 메서드는 관심사에 맞는 모듈에 작성하고, 한 모듈이 비대해지면 분할한다. 횡단 관심사를 한 모듈에 몰아넣지 않는다). **공유분**: 상수·데이터·lua 테이블 = `tools/deck/lib/{ui-helpers,data,codeblock}.mjs`(cb가 import — `MAX_MONSTERS`=4 등). prop 103개는 오케스트레이터 `writeCodeblocks`에 유지. 특정 메서드 수정은 `cb/<name>.mjs`만(의존: orchestrator→cb→lib 단방향). **cb 모듈은 원본 메서드 순서 보존이 바이트동일 조건**. **UI emit(옛 `hud/*.mjs` 15종·`gen-cardhand.mjs`)은 `tools/deck/legacy/`로 이관 — 휴면(생성기 미사용)**: UI가 메이커 저작이라 생성기가 안 만든다. (롤백용 `legacy/upsert-ui.mjs`는 직접 실행 시에만 옛 `DefaultGroup.ui`를 재생성.)
  - 리팩터 시 **출력 바이트-동일 검증**: `node tools/deck/gen-slaydeck.mjs` 후 `node tools/verify/diffcheck.mjs [ref]`(워킹트리 vs ref(기본 HEAD) 줄바꿈 정규화 비교 — 산출물 경로를 명령줄에 노출 안 해 deny 회피). 산출물 ` M`은 보통 autocrlf churn이니 `git checkout --`로 복원.
  - **UI 전면 메이커 저작 (2026-06-17~)**: 단일 `DefaultGroup`을 7개 UIGroup으로 분리 — `DefaultGroup`(MainMenu+월드조작), `SelectUIGroup`(charselect/job), `LobbyUIGroup`(lobby/board/soulshop), `RunUIGroup`(combat/map/shop/rest/treasure/reward/cardhand/deck), `DeckUIGroup`(덱 도감), `PopupGroup`·`ToastGroup`. 컨트롤러(`cb/*.mjs`)는 엔티티 **경로**(`/ui/<UIGroup>/<Hud>/...`)로 텍스트·이미지·표시숨김·상태기반 위치/크기/색을 **런타임 주입**(레이아웃=메이커, 내용=컨트롤러 — 메이커가 이 경로 유지 필수). 몬스터 슬롯 = `RunUIGroup/CombatHud/MonsterStatus{1..4}`(자식 Name·Hp·Intent·HpBarFill·Buffs·BlockBadge·TargetMarker; TargetFrame 없음). **부트 흐름**: `OnBeginPlay`→MainMenu→(`MainMenu/NewGameButton`)→로비→run NPC(`OnLobbyNpcInteract` id=="run")→charselect→런. **재연결 검증**: `node tools/verify/cbgap.mjs`(cb 참조 경로↔.ui GAP 0이어야) + 재생성 후 `git status -- ui/` 변경 0(생성기 .ui 미접근 증명). 섹션→UIGroup 일괄 remap 마이그레이션은 `tools/deck/reconnect-ui-paths.mjs`(멱등). UIGroup별 .ui 분포 확인은 `tools/verify/uimap.mjs`.
  - **머지 충돌(gen-slaydeck.mjs)**: 다른 브랜치가 단일체를 수정해 충돌나면, 그쪽 버전(`git checkout --theirs tools/deck/gen-slaydeck.mjs`)을 취해 **콘텐츠 마커 기반으로 재모듈화**(라인인덱스 X — 줄 추가에 안전·export 이름 자동 파생·`const x=[]` 직전 전문 상수 walk-back 포함) 후 `node tools/verify/diffcheck.mjs origin/main`으로 ui·codeblock 바이트-동일 확인(손실 0 증명). codeblock 메서드·patchCommon은 오케스트레이터 잔류라 그쪽 변경은 자동 보존됨.
@@ -65,6 +65,8 @@ grep -c "CalcPlayerAttack" RootDesk/MyDesk/SlayDeckController.codeblock
  - 제목/본문은 UTF-8 spec JSON 파일로 작성 후 `create <spec.json>` / `merge <번호>`.
  - PR 제목과 본문은 한국어로 작성한다.
 - 산출물 재생성 커밋은 소스 변경 커밋과 분리하거나, 메시지에 "산출물 재생성"을 명시.
+- **PR 머지 후 브랜치 삭제**: 머지된 `feature/*`·`docs/*` 브랜치는 로컬·원격 모두 삭제한다. 삭제 전 `git merge-base --is-ancestor origin/<브랜치> origin/main`로 완전 머지 확인(종료코드 0=완전 머지 → 삭제 가능). main에 없는 커밋이 남은 브랜치와 `codex/*` 등 작업 중 브랜치는 보존한다.
+- **⚠️ main 머지 충돌 시 "머지 전체 revert" 금지 (타인 작업 유실 방지)**: 작업 브랜치에 `git merge main`(또는 origin/main) 했다가 충돌·문제가 나도 **그 머지 커밋을 통째로 `git revert` 하지 말 것.** main에 먼저 들어간 타인의 작업이 collateral로 전부 사라진다. 대신 **소스 충돌만 해소**하고 산출물(codeblock 등)은 **재생성**한다. 충돌이 산출물뿐이면 `git checkout --theirs`/재생성으로 끝. (2026-06-30 사고: codex `#98/#99`가 main 머지 후 그 머지를 revert해 `#96`의 버그수정 11개를 전부 날림 → 다시 재통합해야 했다. 복구는 `git diff <pre-merge> <내브랜치> -- <소스> | git apply --3way` 로 소스만 재적용 후 재생성하면 codex 변경과 충돌 없이 양립.)

 ## 5. 메이커(MSW) 연동 주의

@@ -86,3 +88,18 @@ grep -c "CalcPlayerAttack" RootDesk/MyDesk/SlayDeckController.codeblock
 - UI 텍스트에서는 정수값인 숫자에 `.0`을 붙이지 않는다. `1.0/1.0`이 아니라 `1/1`처럼 표시한다.
 - 생성기 내 Lua UI 코드에서 number 또는 숫자 문자열을 텍스트에 붙일 때는 `FormatNumber` 같은 포맷 헬퍼를 우선 사용한다.
 - 소수부가 플레이어에게 의미 있을 때만 소수점 표기를 유지한다.
+
+## 8. codeblock 변수명
+
+- cb(`tools/deck/cb/*.mjs`)의 Lua 지역변수는 **의미가 드러나는 이름**으로 작성한다(`e`→`entity`, `n`→`count`, `m`→`monster`, `lp`→`localPlayer`, `s`→`soulPoints`, `tr`→`transform`). `a`/`b`/`c` 같은 무의미 단일문자 변수는 금지.
+- 단, 순수 반복 인덱스 `i`/`j`/`r`/`c`는 관용상 허용한다.
+- 새 cb 메서드를 작성하거나 기존 메서드를 손댈 때 이 규칙을 적용한다(대규모 일괄 개명은 별도 작업으로).
+
+## 9. 카드 데이터 규칙 (kind ↔ 효과 일치)
+
+새 카드를 추가/수정할 때 `data/cards.json`의 `kind`는 카드의 효과·사용 메커니즘과 **반드시 일치**해야 한다. 안 맞으면 카드가 **사용 불가**거나 **재생 시 아무 효과 없는 死카드**가 된다(런타임 에러도 안 나고 sim 테스트도 못 잡음 — 정적 검증 필수).
+
+- **`ResolveCardDrop` 사용 라우팅이 kind별로 다름**: `Attack`=몬스터 위에 드롭(`FindMonsterAtTouch>0` 필요)·`Skill`/`Power`=위로 스윕(`ui.y>-180`)·`Status`=unplayable. → **block·디버프·드로우 등 유틸만 있고 데미지가 없는 카드를 `Attack`으로 두면 위로 스윕으로 사용할 수 없다**(2026-06-30 아이언 바디 사고: block만 있는 방어카드가 Attack이라 전사 시작덱 4장이 먹통 → Skill로 수정).
+- **`PlayCard`의 `Power` 분기는 PlayerPowers 등록만 하고 `damage`/`aoe`를 무시**한다. → 데미지 카드=`Attack`, 방어/유틸=`Skill`, 지속효과=`Power`(단 `powerEffect` 또는 지속/온플레이 power 필드 — `turnStart*`·`dex`·`thorns`·`intangible`·`attackPoison`·`drawDamage`·`shivX`·`cardPlayed*` 등 — 이 있어야 함). Power인데 power 효과 필드가 없으면 死카드(2026-06-30 분노 사고: `damage:4/aoe`만 있어 Power 분기서 무시됨 → kind Power→Attack으로 기능화).
+- 새 효과 필드는 `docs/card-effect-fields.md` 사전에 등록하고 Lua(`tools/deck/cb/*.mjs`) + JS 미러(`tools/balance/sim-balance.mjs`) **양쪽에 핸들러 구현**(§6). 한쪽만 있으면 게임↔시뮬 드리프트.
+- **검증: `node tools/verify/cardkinds.mjs`** — kind↔효과 위반(Attack-무데미지 / Power-무효과 / 미지원 kind)을 정적 검출(이상 0 = exit 0). 카드 추가/수정 후 반드시 실행. (관련 가드: 미선언 `self.X` = `cbprops.mjs`, UI 경로 = `cbgap.mjs`, 이중구현 = `sim-balance.test.mjs`.)
--- a/RootDesk/MyDesk/SlayDeckController.codeblock
+++ b/RootDesk/MyDesk/SlayDeckController.codeblock
--- a/cards_to_excel.bat
+++ b/cards_to_excel.bat
@@ -0,0 +1,7 @@
+@echo off
+setlocal
+chcp 65001 >nul
+powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0tools\cards\cards_excel.ps1" export
+echo.
+echo Press any key to close this window.
+pause >nul
--- a/data/cardframes.json
+++ b/data/cardframes.json
@@ -10,7 +10,7 @@
      "unique": "f5def2e8022b4e59a17d3c16414034fe",
      "legend": "cff71f2e472041ce80c6fbd296f42e2d"
    },
-    "bandit": {
+    "rogue": {
      "normal": "9487b06867bc46269ed1d855420f457f",
      "unique": "b3081fb2fb1445fa90b12b01481a78ef",
      "legend": "c357d2daf31a489d95b8fa47e50dd879"
@@ -25,11 +25,13 @@
    "firepoison": "magician",
    "icelightning": "magician",
    "cleric": "magician",
-    "bandit": "bandit",
-    "curse": "bandit",
-    "shiv": "bandit",
-    "poisoner": "bandit",
-    "trickster": "bandit"
+    "curse": "rogue",
+    "shiv": "rogue",
+    "rogue": "rogue",
+    "assassin": "rogue",
+    "hermit": "rogue",
+    "thief": "rogue",
+    "thiefmaster": "rogue"
  },
  "rewardWeights": {
    "normal": 70,
--- a/data/cards.json
+++ b/data/cards.json
--- a/data/cards.xlsx
+++ b/data/cards.xlsx
--- a/data/characters.json
+++ b/data/characters.json
@@ -1,7 +1,7 @@
 {
  "portraits": {
-    "warrior":  "28c88fdc5ab44f34a8b3fc1e19d4ce78",
+    "warrior": "28c88fdc5ab44f34a8b3fc1e19d4ce78",
    "magician": "3b9ea1f066a744bb859df47fef817277",
-    "bandit":   "efa920e58d31426486ef974106e7dc8b"
+    "rogue": "efa920e58d31426486ef974106e7dc8b"
  }
 }
--- a/docs/bandit-card-audit.md
+++ b/docs/bandit-card-audit.md
@@ -1,102 +1,22 @@
-# Bandit Card Audit
+# Rogue Card Audit

-`bandit` 카드의 구현 상태를 카드별로 정리한 문서입니다.
+Current status of rogue cards and shared effect hooks.

-상태 기준:
+## Implemented

- `구현됨`: 공용 필드와 공용 로직으로 처리됨
- `부분구현`: 카드 설명의 일부만 맞음
- `미구현`: 아직 전용 메커니즘이 없음
+`Neutralize`, `SilentStrike`, `Survivor`, `SilentDefend`, `Slice`, `DaggerSpray`, `DaggerThrow`, `PoisonedStab`, `SuckerPunch`, `LeadingStrike`, `FollowThrough`, `FlickFlack`, `Prepared`, `Deflect`, `BladeDance`, `Backflip`, `DodgeAndRoll`, `CloakAndDagger`, `DeadlyPoison`, `Snakebite`, `Untouchable`, `Backstab`, `PreciseCut`, `Finisher`, `MementoMori`, `Flechettes`, `Dash`, `Predator`, `CalculatedGamble`, `HiddenDaggers`, `Acrobatics`, `Blur`, `LegSweep`, `Reflex`, `Haze`, `Tactician`, `WellLaidPlans`, `InfiniteBlades`, `Footwork`, `GrandFinale`, `Adrenaline`, `ShadowStep`, `Assassinate`, `Nightmare`, `ToolsOfTheTrade`, `Afterimage`, `Burst`, `StormOfSteel`, `Abrasive`, `Suppress`, `Expertise`, `Shadowmeld`, `Pounce`, `BouncingFlask`, `Accuracy`, `PhantomBlades`, `Speedster`, `CorrosiveWave`, `Tracking`, `FanOfKnives`, `Strangle`, `Mirage`, `Accelerant`, `MasterPlanner`, `Outbreak`, `EscapePlan`, `HandTrick`, `NoxiousFumes`, `Pinpoint`, `TheHunt`, `Murder`, `Malaise`, `BladeOfInk`, `KnifeTrap`, `BulletTime`, `Envenom`, `SerpentForm`, `WraithForm`, `Skewer`, `Ricochet`, `Anticipate`, `PiercingWail`, `Expose`, `UpMySleeve`, `EchoingSlash`, `BubbleBubble`

-## 구현됨
+Shared hooks already in use:

-`Neutralize`, `SilentStrike`, `Survivor`, `SilentDefend`, `Slice`, `DaggerSpray`, `DaggerThrow`, `PoisonedStab`, `SuckerPunch`, `LeadingStrike`, `FollowThrough`, `FlickFlack`, `Prepared`, `Deflect`, `BladeDance`, `Backflip`, `DodgeAndRoll`, `CloakAndDagger`, `DeadlyPoison`, `Snakebite`, `Untouchable`, `Backstab`, `PreciseCut`, `Finisher`, `MementoMori`, `Flechettes`, `Dash`, `Predator`, `CalculatedGamble`, `HiddenDaggers`, `Acrobatics`, `Blur`, `LegSweep`, `Reflex`, `Haze`, `Tactician`, `WellLaidPlans`, `InfiniteBlades`, `Footwork`, `GrandFinale`, `Adrenaline`, `ShadowStep`, `Assassinate`, `Nightmare`, `ToolsOfTheTrade`, `Afterimage`, `StormOfSteel`, `Abrasive`, `Suppress`, `Expertise`, `Shadowmeld`, `Pounce`, `Pinpoint`
+- `poison`, `innate`, `playableWhenDrawPileEmpty`
+- `retain`, `sly`, `discard`, `discardAll`, `addShiv`, `addShivPerDiscard`, `turnStartShiv`, `retainOne`
+- `turnStartDraw`, `turnStartDiscard`
+- `nextTurnBlock`, `nextTurnDraw`, `nextTurnKeepBlock`, `nextTurnAttackMultiplier`, `nextTurnCopies`, `nextTurnSelectHandCard`
+- `damagePerOtherHandCard`, `damagePerAttackPlayedThisTurn`, `damagePerDiscardedThisTurn`, `damagePerSkillInHand`, `otherHandAtLeast`, `bonusHitsWhenOtherHandAtLeast`
+- `gainEnergy`, `drawUntilHandSize`, `drawPerDiscarded`, `cardPlayedBlock`, `blockGainMultiplier`, `blockPerDamageDealtThisTurn`, `nextSkillCostZero`, `skillCostReductionThisTurn`
+- `firstCardDamageBonus`
+- `drawDamage`, `drawPoison`, `shivDamageBonus`, `firstShivDamageBonus`, `shivRetain`, `shivAoe`, `attackDamageVsWeakMultiplier`, `poisonHits`, `poisonRandomTargets`, `skillSlyOnPlay`, `extraPoisonTicks`, `poisonApplicationBurstEvery`, `poisonApplicationBurstDamage`

-공용 메모:
-
- `poison`, `innate`, `playableWhenDrawPileEmpty` 구현됨
- `retain`, `sly`, `discard`, `discardAll`, `addShiv`, `addShivPerDiscard`, `turnStartShiv`, `retainOne` 구현됨
- `turnStartDraw`, `turnStartDiscard` 구현됨
- `nextTurnBlock`, `nextTurnDraw`, `nextTurnKeepBlock`, `nextTurnAttackMultiplier`, `nextTurnCopies`, `nextTurnSelectHandCard` 구현됨
- `damagePerOtherHandCard`, `damagePerAttackPlayedThisTurn`, `damagePerDiscardedThisTurn`, `damagePerSkillInHand`, `otherHandAtLeast`, `bonusHitsWhenOtherHandAtLeast` 구현됨
- `gainEnergy`, `drawUntilHandSize`, `drawPerDiscarded`, `cardPlayedBlock`, `blockGainMultiplier`, `nextSkillCostZero`, `skillCostReductionThisTurn` 구현됨
-
-## 부분구현
-
-`Ricochet`: 무작위 적 4회 타격이 아니라 일반 분산 공격으로만 처리됨
-
-`Anticipate`: 이번 턴 동안 민첩 2가 아니라 전투 전체 민첩 증가
-
-`PiercingWail`: 이번 턴 적 공격 감소가 아니라 공용 약화/취약 계열만 적용
-
-`Expose`: 방어도/인공물 제거는 없고 취약만 적용됨
-
-`BubbleBubble`: 적이 독을 보유한 경우라는 조건이 아직 없음
-
-`BouncingFlask`: 무작위 적 3번 분산 대신 단일 독 9 처리
-
-## 미구현
-
-`Skewer`: X코스트 연타 공격
-
-`Outbreak`: 독 3번 부여 시 전체 피해 트리거
-
-`Strangle`: 이번 턴 카드 사용마다 추가 피해
-
-`EscapePlan`: 드로우한 카드가 스킬이면 방어도 3
-
-`HandTrick`: 손패의 스킬 카드 하나에 교활 부여
-
-`Mirage`: 모든 적의 독 총합만큼 방어 획득
-
-`UpMySleeve`: 표창 생성 + 비용 감소
-
-`NoxiousFumes`: 턴 시작 전체 적 독 부여 파워
-
-`Accuracy`: 표창 피해 증가 파워
-
-`PhantomBlades`: 표창 보존 + 첫 표창 강화
-
-`Speedster`: 드로우할 때마다 전체 피해
-
-`EchoingSlash`: 처치 시 반복
-
-`TheHunt`: 처치 조건 보상
-
-`Murder`: 이번 전투 동안 뽑은 카드 수 비례 피해
-
-`Malaise`: X코스트 약화/피해 감소
-
-`Pinpoint`: 이번 턴 스킬 비용 감소
-
-`CorrosiveWave`: 드로우할 때마다 독
-
-`BladeOfInk`: 전용 표창 생성
-
-`Burst`: 다음 스킬 1회 추가 사용
-
-`KnifeTrap`: 소멸된 표창 전부 사용
-
-`BulletTime`: 드로우 금지 + 손패 무료 사용
-
-`Accelerant`: 추가 독 발동
-
-`Envenom`: 공격 적중 시 독 부여
-
-`MasterPlanner`: 스킬 사용 시 교활 부여
-
-`Tracking`: 약화된 적이 공격 피해를 2배로 받음
-
-`FanOfKnives`: 표창이 모든 적 대상
-
-`SerpentForm`: 카드 사용할 때마다 무작위 적에게 피해
-
-`WraithForm`: 불가침 2 + 턴 종료 시 민첩 감소
-
-## 다음 축
-
- 조건부 피해
- 카드 사용 트리거
- 비용/X코스트
- 드로우 연동 파워
+## Open questions

+None at the moment.
--- a/docs/card-effect-fields.md
+++ b/docs/card-effect-fields.md
@@ -1,87 +1,126 @@
 # Card Effect Fields

-`data/cards.json`의 카드 효과를 공용 데이터 필드로 표현하는 기준 문서입니다.
+This file tracks the shared data fields used by `data/cards.json`.
+The goal is to keep card behavior reusable instead of hardcoding one-off card names.

-## 피해 수치
+## Damage

- `damage`: 기본 피해
- `damagePerOtherHandCard`: 손패의 다른 카드 수만큼 피해 증감
- `damagePerAttackPlayedThisTurn`: 이번 턴에 사용한 공격 카드 수만큼 피해 증감
- `damagePerDiscardedThisTurn`: 이번 턴에 버린 카드 수만큼 피해 증감
- `damagePerSkillInHand`: 손패의 스킬 카드 수만큼 피해 증감
- `otherHandAtLeast`: 손패의 다른 카드가 이 수 이상일 때 조건 충족
- `bonusHitsWhenOtherHandAtLeast`: 조건 충족 시 추가 적중 수
+- `damage`: base attack damage
+- `damagePerOtherHandCard`: bonus damage per other card in hand
+- `damagePerAttackPlayedThisTurn`: bonus damage per attack played this turn
+- `damagePerDiscardedThisTurn`: bonus damage per card discarded this turn
+- `damagePerSkillInHand`: bonus damage per skill card in hand
+- `damagePerCardDrawnThisCombat`: bonus damage per card drawn this combat
+- `damagePerTurn`: damage applied at turn start
+- `cardPlayedDamage`: damage when the card is played
+- `cardPlayedRandomDamage`: random damage when the card is played
+- `rewardOnKill`: gain bonus reward screens when the card kills
+- `randomTargetEachHit`: choose a random alive enemy for each hit
+- `repeatOnKill`: repeat the attack when it kills at least one enemy
+- `firstCardDamageBonus`: bonus damage for the first card played this turn
+- `drawDamage`: damage dealt when a card is drawn
+- `blockPerDamageDealtThisTurn`: gain block equal to damage dealt this turn
+- `shivDamageBonus`: bonus damage for all Shivs
+- `firstShivDamageBonus`: bonus damage for the first Shiv each turn
+- `attackDamageVsWeakMultiplier`: multiplier when the attack hits Weak targets
+- `useAllEnergy`: treat the card as spending all available energy
+- `xDamagePerEnergy`: scale attack damage by energy spent
+- `xWeakPerEnergy`: scale Weak applied by energy spent

-## 방어/상태
+## Block and utility

- `block`: 방어도 획득
- `cardPlayedBlock`: 카드를 사용할 때마다 방어도 획득
- `blockGainMultiplier`: 이번 턴 동안 얻는 방어도 배수
- `hits`: 다단히트 횟수
- `aoe`: 모든 적 대상
- `pierce`: 방어도 무시
- `draw`: 즉시 드로우
- `drawUntilHandSize`: 손패가 지정 장수에 도달할 때까지 드로우
- `heal`: 즉시 회복
- `gainEnergy`: 즉시 에너지 획득
- `strength`: 힘 획득
- `dex`: 민첩 획득
- `thorns`: 가시 획득
- `selfVuln`: 자신에게 취약 부여
+- `block`: gain block
+- `cardPlayedBlock`: gain block whenever a card is played
+- `blockGainMultiplier`: multiplier for block gained this turn
+- `hits`: multi-hit count
+- `aoe`: hit all enemies
+- `pierce`: ignore block
+- `draw`: draw cards immediately
+- `drawUntilHandSize`: draw until hand reaches a target size
+- `drawSkillBlock`: gain block for each Skill drawn
+- `drawPoison`: apply poison when a card is drawn
+- `handCostZeroThisTurn`: make hand cards cost 0 this turn
+- `drawDisabledThisTurn`: disable draw for the rest of the turn
+- `heal`: heal immediately
+- `gainEnergy`: gain energy immediately
+- `strength`: gain Strength
+- `dex`: gain Dexterity
+- `thorns`: gain Thorns
+- `selfVuln`: apply Vulnerable to self
+- `extraPoisonTicks`: add extra poison ticks at enemy turn start

-## 상태이상
+## Status

- `weak`: 약화 부여
- `vuln`: 취약 부여
- `poison`: 중독 부여
+- `weak`: apply Weak
+- `vuln`: apply Vulnerable
+- `poison`: apply Poison
+- `poisonHits`: apply poison multiple times
+- `poisonRandomTargets`: spread poison applications across random alive enemies
+- `poisonIfTargetPoisoned`: apply poison only if the target is already poisoned
+- `poisonApplicationBurstEvery`: trigger a burst every N poison applications
+- `poisonApplicationBurstDamage`: burst damage when the poison application threshold is reached
+- `skillSlyOnPlay`: make a played Skill card count as sly when it is later discarded
+- `turnHandSlyCount`: mark up to N other Skill cards in hand as sly for this turn
+- `attackPoison`: apply poison when attack damage is dealt
+- `intangible`: reduce incoming damage to 1 for the duration
+- `endTurnDexLoss`: lose Dexterity at end of turn
+- `combatCostReductionOnPlay`: reduce this card's cost each time it is played this combat
+- `enemyStrengthLossThisTurn`: reduce enemy Strength for the rest of the turn
+- `affectsAllEnemies`: apply the card's debuffs to every alive enemy
+- `removeEnemyBlock`: clear enemy block when the card resolves
+- `removeEnemyArtifact`: consume enemy Artifact when the card resolves

-`poison`은 적 턴 시작 시 피해를 주고 1 감소합니다.
+`poison` deals damage at enemy turn start and then decreases by 1.

-## 드로우/버리기
+## Shivs and discard

- `discard`: 손패에서 지정 장수 버리기
- `discardAll`: 손패 전부 버리기
- `drawPerDiscarded`: 버린 카드 1장당 추가 드로우
- `addShiv`: 표창 생성
- `addShivPerDiscard`: 버린 장수만큼 표창 생성
- `sly`: 버려질 때 교활 발동
- `retain`: 턴 종료 시 해당 카드 보존
+- `discard`: discard a chosen number of cards from hand
+- `discardAll`: discard the whole hand
+- `drawPerDiscarded`: draw one extra card per discarded card
+- `addShiv`: create Shiv cards
+- `addShivPerDiscard`: create one Shiv per discarded card
+- `shivRetain`: Shiv cards are retained at end of turn
+- `shivAoe`: Shiv cards hit all enemies for the turn
+- `sly`: trigger on discard
+- `retain`: keep the card at end of turn

-## 파워/턴 효과
+## Powers and turn effects

 - `powerEffect: "strengthPerTurn"`
 - `powerEffect: "energyPerTurn"`
 - `powerEffect: "blockPerTurn"`
+- `powerEffect: "poisonPerTurn"`
+- `powerEffect: "damagePerTurn"`
 - `powerEffect: "retainOne"`
- `turnStartShiv`: 턴 시작 시 표창 생성
- `turnStartDraw`: 턴 시작 시 추가 드로우
- `turnStartDiscard`: 턴 시작 시 카드 버리기
+- `turnStartShiv`: create Shivs at turn start
+- `turnStartDraw`: draw cards at turn start
+- `turnStartDiscard`: discard cards at turn start

-## 다음 턴 예약
+## Next turn planning

- `nextTurnBlock`: 다음 턴 시작 시 방어도 획득
- `nextTurnDraw`: 다음 턴 시작 시 추가 드로우
- `nextTurnKeepBlock`: 다음 턴 시작 시 기존 방어도 유지
- `nextTurnAttackMultiplier`: 다음 턴 공격 피해 배수
- `nextTurnCopies`: 다음 턴에 손패에서 가져올 복사본 수
- `nextTurnSelectHandCard`: 현재 손패에서 카드 1장 선택
- `nextTurnSelectPrompt`: 선택 UI 문구
- `nextSkillCostZero`: 다음 스킬 카드 비용을 0으로 만듦
- `skillCostReductionThisTurn`: 이번 턴 스킬 카드 비용을 일정량 감소
+- `nextTurnBlock`: gain block next turn
+- `nextTurnDraw`: draw extra cards next turn
+- `nextTurnKeepBlock`: keep block next turn
+- `nextTurnAttackMultiplier`: attack multiplier next turn
+- `nextTurnCopies`: copy a chosen card next turn
+- `nextTurnSelectHandCard`: choose a card from the current hand for next turn copies
+- `nextTurnSelectPrompt`: prompt text for selection UI
+- `nextSkillRepeatCount`: repeat the next Skill's effect
+- `nextSkillCostZero`: make the next Skill cost 0
+- `skillCostReductionThisTurn`: reduce Skill costs this turn

-## 기타
+## Misc

- `innate`: 전투 시작 시 첫 손패에 우선 진입
- `playableWhenDrawPileEmpty`: 뽑을 카드 더미가 비었을 때만 사용 가능
- `exhaust`: 사용 후 소멸
- `unplayable`: 사용 불가
- `curse`: 저주 카드
- `token`: 토큰 카드
- `endTurnDamage`: 턴 종료 시 손패에 있으면 피해
+- `innate`: place the card in the opening hand
+- `playableWhenDrawPileEmpty`: only playable when the draw pile is empty
+- `exhaust`: exhaust after use
+- `unplayable`: cannot be played
+- `curse`: curse card
+- `token`: token card
+- `endTurnDamage`: damage if the card remains in hand at end of turn

-## 사용 원칙
-
- 카드 전용 분기보다 공용 필드를 먼저 쓴다.
- 같은 효과는 같은 필드로 재사용한다.
- 새 카드가 같은 패턴이면 먼저 공용 필드를 추가한다.
+## Rules

+- Prefer shared fields over card-specific branches.
+- Reuse the same field name for the same behavior.
+- Add a new shared field before adding more special-case card logic.
--- a/docs/codex-working-rules.md
+++ b/docs/codex-working-rules.md
@@ -0,0 +1,11 @@
+# Codex Working Rules
+
+1. 사용자가 특정 클래스만 수정하라고 했으면 그 클래스 외의 데이터, 설명문, 밸런스 문구는 건드리지 않는다.
+2. 기존 한글 텍스트는 요청이 없으면 임의로 바꾸지 않는다.
+3. 전직 구조를 바꿀 때는 실제 직업명만 사용한다. 임의의 내부 분류명이나 새 직업명을 사용자-facing 구조에 추가하지 않는다.
+4. 대량 치환 전에 수정 대상 파일과 범위를 먼저 확인하고, 원본 문자열이 깨진 상태면 치환 작업을 진행하지 않는다.
+5. 생성기 파일을 크게 수정할 때는 `node --check`와 생성기 실행으로 문법을 먼저 검증한 뒤 산출물을 갱신한다.
+6. 작업 브랜치에 `main`을 머지했다가 충돌·문제가 나도 **그 머지 커밋을 통째로 `git revert`하지 않는다** — main에 먼저 들어간 타인 작업이 collateral로 사라진다(2026-06-30 `#98/#99`가 `#96`의 버그수정 11개를 이렇게 전부 날림). 소스 충돌만 해소하고 산출물(codeblock 등)은 재생성한다. (RULES §4)
+7. 카드 `kind`는 효과와 일치시킨다 — 데미지 카드=`Attack`, block·유틸만 있으면=`Skill`, 지속효과=`Power`(`powerEffect` 또는 power 필드 필수). 안 맞으면 사용 불가/死카드가 된다(2026-06-30 아이언 바디=Attack인데 block만, 분노=Power인데 damage만 → 둘 다 먹통). 카드 추가/수정 후 `node tools/verify/cardkinds.mjs`로 검증(이상 0 = exit 0). (RULES §9)
+8. 카드/cb 변경 후 검증 스위트를 돌린다: `node tools/verify/cardkinds.mjs`(kind↔효과)·`cbprops.mjs`(미선언 `self.X` 필드)·`cbgap.mjs`(UI 경로) + `node --test tools/balance/sim-balance.test.mjs`(이중구현 미러). 새 효과 필드는 Lua(`cb/*.mjs`)와 JS 미러(`tools/balance/sim-balance.mjs`) **양쪽**에 구현(한쪽만 = 게임↔시뮬 드리프트). (RULES §6)
+9. 하네스 규칙의 권위는 `RULES.md`다 — 작업 전 RULES.md(§1 산출물 읽기/수정 금지·§4 git/PR·§6 이중구현 동기화·§9 카드 kind)를 읽고 따른다.
--- a/docs/intangible.md
+++ b/docs/intangible.md
@@ -0,0 +1,5 @@
+# 불가침
+
+`intangible`는 카드를 사용할 때 플레이어에게 불가침 수치를 부여하는 공용 필드입니다. 불가침이 남아 있는 동안 받는 피해는 1로 줄어들고, 턴이 끝날 때 1씩 감소합니다.
+
+`endTurnDexLoss`는 그 카드가 활성화된 동안 매 턴 종료 시 민첩을 잃게 만드는 공용 필드입니다. `WraithForm` 같은 카드가 이 조합을 사용합니다.
--- a/docs/next-skill-repeat.md
+++ b/docs/next-skill-repeat.md
@@ -0,0 +1,12 @@
+# Next Skill Repeat
+
+`nextSkillRepeatCount`는 다음에 사용하는 스킬 카드의 효과를 추가 횟수만큼 다시 적용하는 공용 필드입니다.
+
+현재 구현은 카드가 발동할 때 이 수치를 전역 상태에 누적해 두고, 다음 스킬 카드가 실제로 사용되면 그 효과를 같은 카드에 대해 다시 한 번 이상 적용합니다. 카드 종류는 고정하지 않았기 때문에, 같은 필드를 다른 카드에도 그대로 붙일 수 있습니다.
+
+예시:
+
+- `Burst`
+  - `nextSkillRepeatCount = 1`
+  - 다음 스킬을 한 번 더 적용
+
--- a/docs/reward-on-kill.md
+++ b/docs/reward-on-kill.md
@@ -0,0 +1,5 @@
+# 처치 보상
+
+`rewardOnKill`은 해당 카드가 적을 처치했을 때 전투 보상 화면을 한 번 더 이어서 보여주는 공용 필드입니다. 현재 보상 UI는 3장 선택을 유지하고, 보상 화면만 추가로 한 번 더 열립니다.
+
+`TheHunt`는 이 규칙을 사용합니다. 같은 패턴이 필요한 다른 카드에도 그대로 붙일 수 있습니다.
--- a/excel_to_cards.bat
+++ b/excel_to_cards.bat
@@ -0,0 +1,7 @@
+@echo off
+setlocal
+chcp 65001 >nul
+powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0tools\cards\cards_excel.ps1" import
+echo.
+echo Press any key to close this window.
+pause >nul
--- a/tools/balance/sim-balance.mjs
+++ b/tools/balance/sim-balance.mjs
@@ -1,4 +1,4 @@
-// AI 전투 밸런스 시뮬레이터 — 오프라인 몬테카를로.
+// AI 전투 밸런스 시뮬레이터 — 오프라인 몬테카를로.
 // ⚠️ 전투 규칙은 tools/deck/gen-slaydeck.mjs 의 Lua(SlayDeckController)와 동기화 유지할 것.
 //    (데이터는 data/*.json 공유, 규칙 로직은 JS로 중복 재현)
 import { readFileSync } from 'node:fs';
@@ -54,6 +54,11 @@ export function calcAttack(base, str, weak, vulnOnTarget) {
  return dmg;
 }

+export function calcEnemyAttack(base, str, weak, vulnOnTarget, strengthLoss = 0) {
+  // Lua EnemyActStep 동기화: 힘 손실은 (value+str) 전체에서 차감(음수 힘 허용), 최종 calcAttack이 0 클램프.
+  return calcAttack(base, str - strengthLoss, weak, vulnOnTarget);
+}
+
 // 방어 우선 차감 후 hp 적용 → { hp, block }
 export function applyDamage(hp, block, amount) {
  let dmg = amount;
@@ -100,12 +105,16 @@ export function chooseAction(hand, cards, energy, ctx = {}) {
      if (ctx.nextSkillCostZero === true) effectiveCost = 0;
      else effectiveCost = Math.max(0, effectiveCost - (ctx.skillCostReductionThisTurn || 0));
    }
+    if (ctx.combatCardCostReduction && ctx.combatCardCostReduction[x.id] != null) {
+      effectiveCost = Math.max(0, effectiveCost - ctx.combatCardCostReduction[x.id]);
+    }
    return card.useAllEnergy === true ? true : effectiveCost <= energy;
  });
  const powers = entries.filter((x) => cards[x.id].kind === 'Power');
  const attacks = entries.filter((x) => cards[x.id].kind === 'Attack');
  const skills = entries.filter((x) => cards[x.id].kind === 'Skill');
-  const effectiveCost = (card) => {
+  const effectiveCost = (x) => {
+    const card = cards[x.id];
    let cost = card.cost || 0;
    if (ctx.handCostZeroThisTurn === true) cost = 0;
    else if (card.useAllEnergy === true) cost = 1;
@@ -113,10 +122,13 @@ export function chooseAction(hand, cards, energy, ctx = {}) {
      if (ctx.nextSkillCostZero === true) cost = 0;
      else cost = Math.max(0, cost - (ctx.skillCostReductionThisTurn || 0));
    }
+    if (ctx.combatCardCostReduction && ctx.combatCardCostReduction[x.id] != null) {
+      cost = Math.max(0, cost - ctx.combatCardCostReduction[x.id]);
+    }
    return cost;
  };
-  const dmgEff = (x) => (cards[x.id].damage || 0) / Math.max(effectiveCost(cards[x.id]), 1);
-  const blkEff = (x) => (cards[x.id].block || 0) / Math.max(effectiveCost(cards[x.id]), 1);
+  const dmgEff = (x) => (cards[x.id].damage || 0) / Math.max(effectiveCost(x), 1);
+  const blkEff = (x) => (cards[x.id].block || 0) / Math.max(effectiveCost(x), 1);
  const bestBy = (list, fn) => list.slice().sort((a, b) => fn(b) - fn(a))[0];
  if (powers.length) return powers[0].i;
  if (attacks.length) return bestBy(attacks, dmgEff).i;
@@ -148,25 +160,103 @@ export function simulateCombat(data, rng, stats) {
  const exhaust = [];
  let hand = [];
  let pHp = PLAYER_HP, pBlock = 0;
-  let pStr = 0, pDex = 0, pThorns = 0, pWeak = 0, pVuln = 0;
+  let pStr = 0, pDex = 0, pThorns = 0, pWeak = 0, pVuln = 0, pIntangible = 0;
  let blockGainMultiplier = 1;
  let handCostZeroThisTurn = false;
  let drawDisabledThisTurn = false;
  let nextSkillCostZero = false;
+  let nextSkillRepeatCount = 0;
  let skillCostReductionThisTurn = 0;
+  const combatCardCostReduction = {};
  let nextTurnBlock = 0, nextTurnDraw = 0, nextTurnKeepBlock = false;
  let nextTurnAttackMultiplier = 1, turnAttackMultiplier = 1;
  let nextTurnAddCards = [];
  let turnAttackCardsPlayed = 0, turnDiscardedCards = 0;
+  let turnCardsPlayedThisTurn = 0;
+  let damageDealtThisTurn = 0;
+  let shivFirstDamageBonusUsed = false;
+  let drawDamageThisTurn = 0;
+  let drawPoisonThisTurn = 0;
+  let shivAoeThisCombat = false;
+  const skillSlyOnPlayCards = new Set();
+  const turnSkillSlyCards = new Set();
+  let poisonApplicationsThisCombat = 0;
+  let enemyStrengthLossThisTurn = 0;
  let cardsDrawnThisCombat = 0;
+  let bonusRewardScreens = 0;
+  let activeKillReward = 0;
  let energy = 0;
  const powers = [];
  const mob = monsters.map((m) => ({
-    name: m.name, hp: m.maxHp, maxHp: m.maxHp, block: 0, str: 0, weak: 0, vuln: 0, poison: 0,
+    name: m.name, hp: m.maxHp, maxHp: m.maxHp, block: 0, str: m.str || 0, weak: 0, vuln: 0, poison: 0, artifact: m.artifact || 0,
    intents: m.intents, intentIdx: 0, alive: true,
  }));
  let turns = 0;

+  const aliveMonsters = () => mob.filter((m) => m.alive);
+  const countAliveMonsters = () => aliveMonsters().length;
+  const randomAliveMonster = () => {
+    const alive = aliveMonsters();
+    if (!alive.length) return null;
+    return alive[Math.floor(rng() * alive.length)];
+  };
+  const removeEnemyBlock = (target) => {
+    if (target) target.block = 0;
+  };
+  const removeEnemyArtifact = (target) => {
+    if (target) target.artifact = 0;
+  };
+  const applyMonsterWeak = (target, amount) => {
+    if (!target || !amount || amount <= 0) return;
+    if (target.artifact > 0) { target.artifact--; return; }
+    target.weak += amount;
+  };
+  const applyMonsterVuln = (target, amount) => {
+    if (!target || !amount || amount <= 0) return;
+    if (target.artifact > 0) { target.artifact--; return; }
+    target.vuln += amount;
+  };
+  const applyPoisonToMonster = (target, amount) => {
+    if (!target || !target.alive || !amount || amount <= 0) return;
+    if (target.artifact > 0) { target.artifact--; return; }
+    target.poison += amount;
+    poisonApplicationsThisCombat += 1;
+    const burstEvery = powerFieldTotal('poisonApplicationBurstEvery');
+    const burstDamage = powerFieldTotal('poisonApplicationBurstDamage');
+    if (burstEvery > 0 && burstDamage > 0 && poisonApplicationsThisCombat % burstEvery === 0) {
+      for (const m of mob) {
+        if (!m.alive) continue;
+        const r = applyDamage(m.hp, m.block, burstDamage);
+        m.hp = r.hp; m.block = r.block;
+        if (burstDamage > 0) damageDealtThisTurn += burstDamage;
+        if (m.hp <= 0) m.alive = false;
+      }
+    }
+  };
+  const dealDamageToMonster = (target, amount, pierce = false) => {
+    if (!target || !target.alive) return false;
+    let dmg = amount;
+    const effectiveStr = Math.max(0, target.str - enemyStrengthLossThisTurn);
+    dmg = calcAttack(dmg, effectiveStr, target.weak, 0);
+    if (target.vuln > 0) dmg = Math.floor(dmg * 1.5);
+    if (target.block > 0 && !pierce) {
+      const absorbed = Math.min(target.block, dmg);
+      target.block -= absorbed;
+      dmg -= absorbed;
+    }
+    target.hp -= dmg;
+    if (dmg > 0) {
+      const attackPoison = powerFieldTotal('attackPoison');
+      if (attackPoison > 0) applyPoisonToMonster(target, attackPoison);
+    }
+    if (target.hp <= 0) {
+      target.hp = 0;
+      target.alive = false;
+      return true;
+    }
+    return false;
+  };
+
  function draw(n) {
    const drawn = [];
    if (drawDisabledThisTurn === true) return drawn;
@@ -176,6 +266,26 @@ export function simulateCombat(data, rng, stats) {
      const card = drawPile.pop();
      drawn.push(card);
      cardsDrawnThisCombat++;
+      const drawDamage = powerFieldTotal('drawDamage') + drawDamageThisTurn;
+      const drawPoison = powerFieldTotal('drawPoison') + drawPoisonThisTurn;
+      if ((drawDamage > 0 || drawPoison > 0) && mob.some((m) => m.alive)) {
+        for (const m of mob) {
+          if (!m.alive) continue;
+          let dmg = drawDamage;
+          if (m.vuln > 0) dmg = Math.floor(dmg * 1.5);
+          if (m.block > 0) {
+            const absorbed = Math.min(m.block, dmg);
+            m.block -= absorbed;
+            dmg -= absorbed;
+          }
+          if (drawPoison > 0) applyPoisonToMonster(m, drawPoison);
+          if (dmg > 0) {
+            m.hp -= dmg;
+            damageDealtThisTurn += dmg;
+          }
+          if (m.hp <= 0) { m.hp = 0; m.alive = false; }
+        }
+      }
      // 손패 10장 상한 — 초과 드로는 자동 버림 (Lua DrawCards 동기화)
      if (hand.length >= 10) {
        discard.push(card);
@@ -233,6 +343,11 @@ export function simulateCombat(data, rng, stats) {
    if (c.damagePerDiscardedThisTurn) base += turnDiscardedCards * c.damagePerDiscardedThisTurn;
    if (c.damagePerSkillInHand) base += countOtherHandSkills(id) * c.damagePerSkillInHand;
    if (c.damagePerCardDrawnThisCombat) base += cardsDrawnThisCombat * c.damagePerCardDrawnThisCombat;
+    if (c.kind === 'Attack' && turnCardsPlayedThisTurn === 0 && c.firstCardDamageBonus) base += c.firstCardDamageBonus;
+    if (c.class === 'shiv') {
+      if (powerFieldTotal('shivDamageBonus') > 0) base += powerFieldTotal('shivDamageBonus');
+      if (!shivFirstDamageBonusUsed && powerFieldTotal('firstShivDamageBonus') > 0) base += powerFieldTotal('firstShivDamageBonus');
+    }
    if (base < 0) base = 0;
    return base;
  }
@@ -279,9 +394,26 @@ export function simulateCombat(data, rng, stats) {
    let blockGained = 0;
    if (c.blockGainMultiplier && c.blockGainMultiplier > 0) blockGainMultiplier *= c.blockGainMultiplier;
    if (c.nextSkillCostZero === true) nextSkillCostZero = true;
+    if (c.nextSkillRepeatCount && c.nextSkillRepeatCount > 0) nextSkillRepeatCount += c.nextSkillRepeatCount;
    if (c.skillCostReductionThisTurn && c.skillCostReductionThisTurn > 0) skillCostReductionThisTurn += c.skillCostReductionThisTurn;
    if (c.handCostZeroThisTurn === true) handCostZeroThisTurn = true;
    if (c.drawDisabledThisTurn === true) drawDisabledThisTurn = true;
+    if (c.drawDamage && c.kind !== 'Power') drawDamageThisTurn += c.drawDamage;
+    if (c.drawPoison && c.kind !== 'Power') drawPoisonThisTurn += c.drawPoison;
+    if (c.shivAoe === true && c.kind !== 'Power') shivAoeThisCombat = true;
+    if (c.skillSlyOnPlay === true && c.kind === 'Skill') skillSlyOnPlayCards.add(id);
+    if (c.turnHandSlyCount && c.turnHandSlyCount > 0) {
+      let picked = 0;
+      for (const hid of hand) {
+        if (hid === id) continue;
+        const hc = cards[hid];
+        if (hc?.kind === 'Skill' && !turnSkillSlyCards.has(hid) && !skillSlyOnPlayCards.has(hid) && hc.sly !== true) {
+          turnSkillSlyCards.add(hid);
+          picked++;
+          if (picked >= c.turnHandSlyCount) break;
+        }
+      }
+    }
    const xEnergy = costSpent || 0;
    if (c.kind === 'Attack') {
      if (alive.length && (c.damage || c.xDamagePerEnergy)) {
@@ -289,35 +421,73 @@ export function simulateCombat(data, rng, stats) {
        const bonusHits = (c.otherHandAtLeast && c.bonusHitsWhenOtherHandAtLeast && Math.max(0, hand.length - 1) >= c.otherHandAtLeast)
          ? c.bonusHitsWhenOtherHandAtLeast : 0;
        const hitN = (c.hits || 1) + bonusHits;
-        const preview = calcAttack(baseDamage || 0, pStr, pWeak, 0) * turnAttackMultiplier;
-        const target = chooseTarget(alive, preview);
-        if (c.weak) target.weak += c.weak;
-        if (c.vuln) target.vuln += c.vuln;
-        let totalNv = 0;
-        for (let h = 0; h < hitN; h++) totalNv += calcAttack(baseDamage || 0, pStr, pWeak, 0) * turnAttackMultiplier;
-        dmg = totalNv;
-        if (c.aoe === true) {
-          for (const m2 of aliveList()) {
-            const d2 = m2.vuln > 0 ? Math.floor(totalNv * 1.5) : totalNv;
-            const r2 = applyDamage(m2.hp, m2.block, d2);
-            m2.hp = r2.hp; m2.block = r2.block;
-            const attackPoison = powerFieldTotal('attackPoison');
-            if (d2 > 0 && attackPoison > 0) m2.poison += attackPoison;
-            if (m2.hp <= 0) m2.alive = false;
+        let useAoe = c.aoe === true;
+        if (c.class === 'shiv' && shivAoeThisCombat === true) useAoe = true;
+        if (c.class === 'shiv' && !shivFirstDamageBonusUsed && powerFieldTotal('firstShivDamageBonus') > 0) {
+          shivFirstDamageBonusUsed = true;
+        }
+        const perHit = calcAttack(baseDamage || 0, pStr, pWeak, 0) * turnAttackMultiplier;
+        const dealToTarget = (target, amount) => {
+          if (!target || !target.alive) return { killed: false, dealt: 0 };
+          let dealt = amount;
+          if (target.vuln > 0) dealt = Math.floor(dealt * 1.5);
+          if (target.weak > 0 && c.attackDamageVsWeakMultiplier && c.attackDamageVsWeakMultiplier > 1) {
+            dealt = Math.floor(dealt * c.attackDamageVsWeakMultiplier);
          }
-        } else {
-          dmg = target.vuln > 0 ? Math.floor(totalNv * 1.5) : totalNv;
          if (c.pierce === true) {
-            target.hp -= dmg;
+            target.hp -= dealt;
            if (target.hp < 0) target.hp = 0;
          } else {
-            const r = applyDamage(target.hp, target.block, dmg);
+            const r = applyDamage(target.hp, target.block, dealt);
            target.hp = r.hp; target.block = r.block;
          }
          const attackPoison = powerFieldTotal('attackPoison');
-          if (dmg > 0 && attackPoison > 0) target.poison += attackPoison;
-          if (target.hp <= 0) target.alive = false;
-        }
+          if (dealt > 0 && attackPoison > 0) applyPoisonToMonster(target, attackPoison);
+          let killed = false;
+          if (target.hp <= 0) {
+            target.alive = false;
+            killed = true;
+            if (c.rewardOnKill) bonusRewardScreens += c.rewardOnKill;
+          }
+          return { killed, dealt };
+        };
+        const resolveAttackRound = () => {
+          let roundKilled = false;
+          let roundDamage = 0;
+          if (useAoe === true) {
+            for (const m2 of aliveList()) {
+              const r2 = dealToTarget(m2, perHit);
+              roundDamage += r2.dealt;
+              if (r2.killed) roundKilled = true;
+            }
+          } else if (c.randomTargetEachHit === true) {
+            for (let h = 0; h < hitN; h++) {
+              const target = randomAliveMonster();
+              if (!target) break;
+              const r = dealToTarget(target, perHit);
+              roundDamage += r.dealt;
+              if (r.killed) roundKilled = true;
+            }
+          } else {
+            const preview = perHit;
+            const target = chooseTarget(aliveList(), preview);
+            if (target) {
+              if (c.weak) applyMonsterWeak(target, c.weak);
+              if (c.vuln) applyMonsterVuln(target, c.vuln);
+              const totalNv = perHit * hitN;
+              const r = dealToTarget(target, totalNv);
+              roundDamage += r.dealt;
+              if (r.killed) roundKilled = true;
+            }
+          }
+          dmg += roundDamage;
+          damageDealtThisTurn += roundDamage;
+          return roundKilled;
+        };
+        let roundKilled = false;
+        do {
+          roundKilled = resolveAttackRound();
+        } while (c.repeatOnKill === true && roundKilled === true && countAliveMonsters() > 0);
      }
      if (c.block) blockGained = addBlock(c.block);
    } else if (c.kind === 'Power') {
@@ -325,11 +495,30 @@ export function simulateCombat(data, rng, stats) {
    } else {
      if (c.block) blockGained = addBlock(c.block);
      const weakAmount = (c.weak || 0) + (c.xWeakPerEnergy || 0) * xEnergy;
-      if ((weakAmount || c.vuln || c.poison) && alive.length) {
-        const target = chooseTarget(alive, 0);
-        if (weakAmount) target.weak += weakAmount;
-        if (c.vuln) target.vuln += c.vuln;
-        if (c.poison) target.poison += c.poison;
+      const vulnAmount = c.vuln || 0;
+      if ((weakAmount || vulnAmount || c.poison || c.removeEnemyBlock || c.removeEnemyArtifact || c.enemyStrengthLossThisTurn) && alive.length) {
+        const targets = c.affectsAllEnemies === true ? aliveList() : [chooseTarget(alive, 0)];
+        if (c.enemyStrengthLossThisTurn && c.enemyStrengthLossThisTurn > 0) {
+          enemyStrengthLossThisTurn += c.enemyStrengthLossThisTurn;
+        }
+        for (const target of targets) {
+          if (!target || !target.alive) continue;
+          if (c.removeEnemyBlock === true) removeEnemyBlock(target);
+          if (c.removeEnemyArtifact === true) removeEnemyArtifact(target);
+          if (weakAmount) applyMonsterWeak(target, weakAmount);
+          if (vulnAmount) applyMonsterVuln(target, vulnAmount);
+        if (c.poison) {
+          if (c.poisonIfTargetPoisoned !== true || target.poison > 0) {
+            const poisonHits = c.poisonHits || 1;
+            for (let i = 0; i < poisonHits; i++) {
+              const target2 = c.poisonRandomTargets === true
+                ? alive[Math.floor(rng() * alive.length)]
+                : target;
+              if (target2) applyPoisonToMonster(target2, c.poison);
+            }
+          }
+        }
+        }
      }
    }
    if (c.strength) pStr += c.strength;
@@ -338,7 +527,10 @@ export function simulateCombat(data, rng, stats) {
    if (c.selfVuln) pVuln += c.selfVuln;
    if (c.heal) pHp = Math.min(pHp + c.heal, PLAYER_HP);
    if (c.gainEnergy) energy += c.gainEnergy;
+    activeKillReward = c.rewardOnKill || 0;
+    if (c.intangible) pIntangible += c.intangible;
    queueNextTurnEffects(c);
+    turnCardsPlayedThisTurn++;
    let drawnCards = [];
    if (c.draw) drawnCards = drawnCards.concat(draw(c.draw));
    if (c.drawUntilHandSize) {
@@ -356,6 +548,7 @@ export function simulateCombat(data, rng, stats) {
      if (target && target.alive) {
        target.hp -= c.cardPlayedDamage;
        dmg += c.cardPlayedDamage;
+        damageDealtThisTurn += c.cardPlayedDamage;
        if (target.hp <= 0) target.alive = false;
      }
    }
@@ -366,15 +559,20 @@ export function simulateCombat(data, rng, stats) {
        if (target) {
          target.hp -= c.cardPlayedRandomDamage;
          dmg += c.cardPlayedRandomDamage;
+          damageDealtThisTurn += c.cardPlayedRandomDamage;
          if (target.hp <= 0) target.alive = false;
        }
      }
    }
+    if (c.blockPerDamageDealtThisTurn && c.blockPerDamageDealtThisTurn > 0 && c.kind !== 'Power') {
+      blockGained += addBlock(Math.max(0, damageDealtThisTurn * c.blockPerDamageDealtThisTurn));
+    }
    if (recordStats && stats) stats[id] = bump(stats[id], costSpent, dmg, blockGained);
  }
  function triggerSly(id) {
    const c = cards[id];
-    if (!c?.sly) return;
+    if (!c) return;
+    if (!c.sly && !skillSlyOnPlayCards.has(id) && !turnSkillSlyCards.has(id)) return;
    resolveCardEffects(id, c, 0, false);
  }
  function discardHandCard(idx, trigger = true) {
@@ -401,6 +599,12 @@ export function simulateCombat(data, rng, stats) {
    turns++;
    turnAttackCardsPlayed = 0;
    turnDiscardedCards = 0;
+    shivFirstDamageBonusUsed = false;
+    drawDamageThisTurn = 0;
+    drawPoisonThisTurn = 0;
+    shivAoeThisCombat = false;
+    turnSkillSlyCards.clear();
+    enemyStrengthLossThisTurn = 0;
    blockGainMultiplier = 1;
    handCostZeroThisTurn = false;
    drawDisabledThisTurn = false;
@@ -420,7 +624,7 @@ export function simulateCombat(data, rng, stats) {
      else if (pc.powerEffect === 'energyPerTurn') energyBonus += pc.value;
      else if (pc.powerEffect === 'blockPerTurn') pBlock += pc.value;
      else if (pc.powerEffect === 'poisonPerTurn') {
-        for (const m of mob) if (m.alive) m.poison += pc.value;
+        for (const m of mob) if (m.alive) applyPoisonToMonster(m, pc.value);
      } else if (pc.powerEffect === 'damagePerTurn') {
        for (const m of mob) {
          if (!m.alive) continue;
@@ -446,24 +650,38 @@ export function simulateCombat(data, rng, stats) {
    while (true) {
      const alive = aliveList();
      if (alive.length === 0) break;
-      const idx = chooseAction(hand, cards, energy, { drawPileCount: drawPile.length, nextSkillCostZero, skillCostReductionThisTurn, handCostZeroThisTurn });
+      const idx = chooseAction(hand, cards, energy, { drawPileCount: drawPile.length, nextSkillCostZero, skillCostReductionThisTurn, handCostZeroThisTurn, combatCardCostReduction });
      if (idx < 0) break;
      const id = hand[idx], c = cards[id];
+      let dmg = 0;
      const skillFree = c.kind === 'Skill' && nextSkillCostZero === true;
+      const skillRepeat = c.kind === 'Skill' ? nextSkillRepeatCount : 0;
      const baseCost = c.cost || 0;
+      const combatReduction = combatCardCostReduction[id] || 0;
      const cost = handCostZeroThisTurn === true ? 0 : (c.useAllEnergy === true ? energy : (skillFree ? 0 : (c.kind === 'Skill' ? Math.max(0, baseCost - skillCostReductionThisTurn) : baseCost)));
-      energy -= cost;
-      resolveCardEffects(id, c, cost);
-      if (c.kind === 'Attack') turnAttackCardsPlayed++;
-      if (skillFree === true && c.nextSkillCostZero !== true) nextSkillCostZero = false;
+      const finalCost = c.useAllEnergy === true ? cost : Math.max(0, cost - combatReduction);
+      energy -= finalCost;
+      resolveCardEffects(id, c, finalCost);
      const playedBlock = powerFieldTotal('cardPlayedBlock');
      if (playedBlock > 0) addBlock(playedBlock);
+      if (skillRepeat > 0) {
+        nextSkillRepeatCount = Math.max(0, nextSkillRepeatCount - skillRepeat);
+        for (let r = 0; r < skillRepeat; r++) {
+          resolveCardEffects(id, c, finalCost);
+          if (playedBlock > 0) addBlock(playedBlock);
+        }
+      }
+      if (c.kind === 'Attack') turnAttackCardsPlayed++;
+      if (skillFree === true && c.nextSkillCostZero !== true) nextSkillCostZero = false;
      hand.splice(idx, 1);
      queueSelectedReserve(c);
      if (c.exhaust === true || String(c.desc || '').includes('소멸.')) exhaust.push(id);
      else if (c.kind !== 'Power') discard.push(id);
+      if (c.combatCostReductionOnPlay && c.combatCostReductionOnPlay > 0) {
+        combatCardCostReduction[id] = (combatCardCostReduction[id] || 0) + c.combatCostReductionOnPlay;
+      }
      applyDiscardEffects(c);
-      if (aliveList().length === 0) return { win: true, turns, playerHpRemaining: pHp };
+      if (aliveList().length === 0) return { win: true, turns, playerHpRemaining: pHp, bonusRewardScreens };
    }
    // 화상(endTurnDamage) — 손패에 있으면 턴 종료 시 피해 (Lua EndPlayerTurn 동기화)
    let burn = 0;
@@ -472,10 +690,18 @@ export function simulateCombat(data, rng, stats) {
    const kept = [];
    for (const hid of hand) {
      const hc = cards[hid];
-      if (hc?.retain === true) kept.push(hid);
+      if (hc?.retain === true || (hc?.class === 'shiv' && powerFieldTotal('shivRetain') > 0)) kept.push(hid);
      else discard.push(hid);
    }
    hand = kept;
+    for (const pid of powers) {
+      const pc = cards[pid];
+      if (pc?.endTurnDexLoss) {
+        pDex -= pc.endTurnDexLoss;
+        if (pDex < 0) pDex = 0;
+      }
+    }
+    if (pIntangible > 0) pIntangible--;
    if (pHp <= 0) return { win: false, turns, playerHpRemaining: 0 };
    // 플레이어 디버프 감소 — Lua EndPlayerTurn 동기화 (적 행동 전)
    if (pWeak > 0) pWeak--;
@@ -483,19 +709,24 @@ export function simulateCombat(data, rng, stats) {
    for (const m of mob) {
      if (!m.alive) continue;
      // 독 틱 — 행동 시작 시 (Lua EnemyActStep 동기화). 사망 시 행동 생략
-      if (m.poison > 0) {
+      const poisonTicks = 1 + Math.max(0, powerFieldTotal('extraPoisonTicks'));
+      for (let tick = 0; tick < poisonTicks; tick++) {
+        if (m.poison <= 0) break;
        m.hp -= m.poison;
        m.poison--;
-        if (m.hp <= 0) { m.hp = 0; m.alive = false; continue; }
+        if (m.hp <= 0) { m.hp = 0; m.alive = false; break; }
      }
+      if (!m.alive) continue;
      m.block = 0; // 매 턴 초기화 (이전 턴 블록 미이월)
      // 정의된 intent 중 랜덤 선택 (Lua EnemyActStep 동기화 — 순차→랜덤)
      const it = m.intents.length ? m.intents[Math.floor(rng() * m.intents.length)] : null;
      if (it) {
        if (it.kind === 'Attack') {
-          const atk = calcAttack(it.value, m.str, m.weak, pVuln);
+          const atk = calcEnemyAttack(it.value, m.str, m.weak, pVuln, enemyStrengthLossThisTurn);
          const beforeHp = pHp;
-          const r = applyDamage(pHp, pBlock, atk); pHp = r.hp; pBlock = r.block;
+          let incoming = atk;
+          if (pIntangible > 0 && incoming > 1) incoming = 1;
+          const r = applyDamage(pHp, pBlock, incoming); pHp = r.hp; pBlock = r.block;
          if (beforeHp > pHp && pThorns > 0) {
            m.hp -= pThorns;
            if (m.hp <= 0) m.alive = false;
@@ -516,9 +747,9 @@ export function simulateCombat(data, rng, stats) {
      if (pHp <= 0) return { win: false, turns, playerHpRemaining: 0 };
    }
    // 독 사망 등 적 페이즈 중 전멸 처리 (Lua FinishEnemyTurn→CheckCombatEnd 동기화)
-    if (!mob.some((m) => m.alive)) return { win: true, turns, playerHpRemaining: pHp };
+    if (!mob.some((m) => m.alive)) return { win: true, turns, playerHpRemaining: pHp, bonusRewardScreens };
  }
-  return { win: false, turns, playerHpRemaining: pHp, draw: true };
+  return { win: false, turns, playerHpRemaining: pHp, draw: true, bonusRewardScreens };
 }

 function mean(a) { return a.length ? a.reduce((s, x) => s + x, 0) / a.length : 0; }
--- a/tools/balance/sim-balance.test.mjs
+++ b/tools/balance/sim-balance.test.mjs
@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
-  mulberry32, applyDamage, chooseAction, chooseTarget, simulateCombat, runBatch, calcAttack, rarityForRoll,
+  mulberry32, applyDamage, chooseAction, chooseTarget, simulateCombat, runBatch, calcAttack, calcEnemyAttack, rarityForRoll,
 } from './sim-balance.mjs';

 test('rarityForRoll: 70/25/5 경계 (Lua OfferReward 미러)', () => {
@@ -262,6 +262,19 @@ test('simulateCombat: 카드 취약 부여가 같은 카드 피해에 선적용
  assert.equal(r.turns, 1);
 });

+test('simulateCombat: firstCardDamageBonus가 턴 첫 카드에 적용 (kind===Attack, Lua 동기화)', () => {
+  // ChargedBlow처럼 class=warrior·kind=Attack인 카드의 첫-카드 보너스.
+  // 게이트가 class==="Attack"이면 영구 false라 미발동(버그) → 5뎀/2턴.
+  // kind==="Attack"이면 5+2=7 → 1턴 처치.
+  const data = {
+    cards: { CB: { name: '차지블로우', cost: 3, kind: 'Attack', class: 'warrior', damage: 5, firstCardDamageBonus: 2 } },
+    starterDeck: ['CB', 'CB', 'CB', 'CB', 'CB'],
+    monsters: [{ name: '적', maxHp: 7, intents: [{ kind: 'Defend', value: 0 }] }],
+  };
+  const r = simulateCombat(data, mulberry32(1));
+  assert.equal(r.turns, 1);
+});
+
 test('simulateCombat: Power(매턴 힘) 누적', () => {
  const data = {
    cards: {
@@ -713,6 +726,28 @@ test("simulateCombat: nextSkillCostZero makes the next skill free", () => {
  assert.equal(r.playerHpRemaining, 80);
 });

+test("simulateCombat: nextSkillRepeatCount repeats the next skill effect", () => {
+  const shared = {
+    cards: {
+      Burst: { name: "Burst", cost: 1, kind: "Skill", draw: 1, block: 5, nextSkillRepeatCount: 1 },
+      Guard: { name: "Guard", cost: 2, kind: "Skill", block: 8 },
+    },
+    starterDeck: ["Burst", "Guard"],
+    monsters: [{ name: "Dummy", maxHp: 9999, intents: [{ kind: "Attack", value: 15 }] }],
+  };
+  const withBurst = simulateCombat(shared, () => 0.999999);
+  const withoutBurst = simulateCombat({
+    ...shared,
+    cards: {
+      Burst: { name: "Burst", cost: 1, kind: "Skill", draw: 1, block: 5 },
+      Guard: shared.cards.Guard,
+    },
+  }, () => 0.999999);
+  assert.equal(withBurst.draw, true);
+  assert.equal(withBurst.playerHpRemaining, 80);
+  assert.ok(withBurst.playerHpRemaining > withoutBurst.playerHpRemaining);
+});
+
 test("chooseAction: skillCostReductionThisTurn allows discounted skills", () => {
  const cards = {
    Guard: { name: "Guard", cost: 2, kind: "Skill", block: 8 },
@@ -736,6 +771,14 @@ test("chooseAction: useAllEnergy cards remain playable at zero energy", () => {
  assert.equal(chooseAction(["Skewer"], cards, 0, {}), 0);
 });

+test("chooseAction: combatCardCostReduction discounts the same card across combat", () => {
+  const cards = {
+    Sleeve: { name: "UpMySleeve", cost: 2, kind: "Skill" },
+  };
+  assert.equal(chooseAction(["Sleeve"], cards, 1, { combatCardCostReduction: { Sleeve: 1 } }), 0);
+  assert.equal(chooseAction(["Sleeve"], cards, 1, {}), -1);
+});
+
 test("simulateCombat: drawSkillBlock grants block for each drawn skill", () => {
  const data = {
    cards: {
@@ -799,10 +842,219 @@ test("simulateCombat: attackPoison power applies poison on attack damage", () =>
  assert.equal(r.turns, 1);
 });

-test("simulateCombat: cardPlayedDamage hits the target whenever a card is played", () => {
+test("simulateCombat: skillSlyOnPlay makes later discards of the same skill trigger sly effects", () => {
+  const shared = {
+    cards: {
+      MasterPlanner: { name: "MasterPlanner", cost: 1, kind: "Skill", poison: 1, discardAll: true },
+    },
+    starterDeck: ["MasterPlanner", "MasterPlanner"],
+    monsters: [{ name: "Dummy", maxHp: 2, intents: [{ kind: "Attack", value: 0 }] }],
+  };
+  const withSly = simulateCombat({
+    ...shared,
+    cards: {
+      MasterPlanner: { name: "MasterPlanner", cost: 1, kind: "Skill", poison: 1, discardAll: true, skillSlyOnPlay: true },
+    },
+  }, () => 0.999999);
+  const withoutSly = simulateCombat(shared, () => 0.999999);
+  assert.equal(withSly.win, true);
+  assert.equal(withSly.turns, 1);
+  assert.ok(withoutSly.turns > withSly.turns);
+});
+
+test("simulateCombat: randomTargetEachHit can spread hits across alive enemies", () => {
+  const shared = {
+    cards: {
+      Ricochet: { name: "Ricochet", cost: 2, kind: "Attack", damage: 3, hits: 4, randomTargetEachHit: true },
+    },
+    starterDeck: ["Ricochet"],
+    monsters: [
+      { name: "DummyA", maxHp: 6, intents: [{ kind: "Attack", value: 0 }] },
+      { name: "DummyB", maxHp: 6, intents: [{ kind: "Attack", value: 0 }] },
+    ],
+  };
+  const makeRng = () => {
+    const seq = [0, 0.999999, 0, 0.999999];
+    let i = 0;
+    return () => seq[i++ % seq.length];
+  };
+  const withRicochet = simulateCombat(shared, makeRng());
+  const withoutRicochet = simulateCombat({
+    ...shared,
+    cards: {
+      Ricochet: { name: "Ricochet", cost: 2, kind: "Attack", damage: 3, hits: 4 },
+    },
+  }, makeRng());
+  assert.equal(withRicochet.win, true);
+  assert.equal(withRicochet.turns, 1);
+  assert.equal(withoutRicochet.turns, 2);
+});
+
+test("calcEnemyAttack: enemyStrengthLossThisTurn reduces enemy attack damage", () => {
+  assert.equal(calcEnemyAttack(10, 6, 0, 0, 6), 10);
+  assert.equal(calcEnemyAttack(10, 6, 0, 0, 0), 16);
+});
+
+test("calcEnemyAttack: 힘 손실이 base 아래로 공격을 낮춘다 (음수 힘, Lua 동기화)", () => {
+  // 적 str=0, loss=6 → 힘 -6 → 10-6=4. JS가 str을 0에서 클램프하면 10(버그). Lua는 전체에서 차감.
+  assert.equal(calcEnemyAttack(10, 0, 0, 0, 6), 4);
+  assert.equal(calcEnemyAttack(10, 3, 0, 0, 6), 7);
+  assert.equal(calcEnemyAttack(5, 0, 0, 0, 6), 0); // 5-6=-1 → 0 클램프
+});
+
+test('simulateCombat: firstShivDamageBonus는 턴당 첫 Shiv에만 적용 (Lua 동기화)', () => {
+  // PhantomBlades(firstShivDamageBonus 9) 활성. 턴당 3 Shiv 사용(에너지3·cost1).
+  // 정답(첫 Shiv만 +9): 턴1 = 10+1+1=12 → 13HP에 1 남김 → 2턴.
+  // 버그(모든 Shiv +9): 턴1 = 10*3=30 → 1턴.
  const data = {
    cards: {
-      Strangle: { name: "Strangle", cost: 1, kind: "Attack", damage: 8, cardPlayedDamage: 2 },
+      PhantomBlades: { name: '환영검', cost: 0, kind: 'Power', firstShivDamageBonus: 9 },
+      Shiv: { name: '시브', cost: 1, kind: 'Attack', class: 'shiv', damage: 1 },
+    },
+    starterDeck: ['PhantomBlades', 'Shiv', 'Shiv', 'Shiv', 'Shiv'],
+    monsters: [{ name: '적', maxHp: 13, intents: [{ kind: 'Attack', value: 0 }] }],
+  };
+  const r = simulateCombat(data, mulberry32(1));
+  assert.equal(r.turns, 2);
+});
+
+test('simulateCombat: blockPerDamageDealtThisTurn이 실제 방어를 부여 (Lua 동기화)', () => {
+  // 매턴 Hit(5뎀) → Guard(준 피해만큼 방어 5) → 적 공격 5 상쇄.
+  // 수정(실제 방어): 무한 생존 → 무승부. 버그(방어 미부여): 매턴 5피해 → 사망.
+  const data = {
+    cards: {
+      Hit: { name: '타격', cost: 2, kind: 'Attack', damage: 5 },
+      Guard: { name: '대비', cost: 1, kind: 'Skill', blockPerDamageDealtThisTurn: 1 },
+    },
+    starterDeck: ['Hit', 'Guard'],
+    monsters: [{ name: '적', maxHp: 9999, intents: [{ kind: 'Attack', value: 5 }] }],
+  };
+  const r = simulateCombat(data, mulberry32(1));
+  assert.equal(r.draw, true);
+});
+
+test("simulateCombat: repeatOnKill repeats an attack until no kill occurs", () => {
+  const shared = {
+    cards: {
+      EchoingSlash: { name: "EchoingSlash", cost: 1, kind: "Attack", aoe: true, damage: 10, repeatOnKill: true },
+    },
+    starterDeck: ["EchoingSlash"],
+    monsters: [
+      { name: "DummyA", maxHp: 10, intents: [{ kind: "Attack", value: 0 }] },
+      { name: "DummyB", maxHp: 20, intents: [{ kind: "Attack", value: 0 }] },
+    ],
+  };
+  const withRepeat = simulateCombat(shared, () => 0.999999);
+  const withoutRepeat = simulateCombat({
+    ...shared,
+    cards: {
+      EchoingSlash: { name: "EchoingSlash", cost: 1, kind: "Attack", aoe: true, damage: 10 },
+    },
+  }, () => 0.999999);
+  assert.equal(withRepeat.win, true);
+  assert.equal(withRepeat.turns, 1);
+  assert.equal(withoutRepeat.turns, 2);
+});
+
+test("simulateCombat: poisonIfTargetPoisoned only applies poison to already poisoned enemies", () => {
+  const shared = {
+    cards: {
+      Bubble: { name: "BubbleBubble", cost: 1, kind: "Skill", poison: 9, poisonIfTargetPoisoned: true },
+    },
+    starterDeck: ["Bubble"],
+    monsters: [{ name: "Dummy", maxHp: 2, intents: [{ kind: "Attack", value: 0 }] }],
+  };
+  const withBubble = simulateCombat(shared, () => 0.999999);
+  const withoutBubble = simulateCombat({
+    ...shared,
+    cards: {
+      Bubble: { name: "BubbleBubble", cost: 1, kind: "Skill", poison: 9 },
+    },
+  }, () => 0.999999);
+  assert.equal(withBubble.draw, true);
+  assert.equal(withBubble.turns, 100);
+  assert.equal(withoutBubble.win, true);
+  assert.equal(withoutBubble.turns, 1);
+});
+
+test("simulateCombat: turnHandSlyCount marks a skill in hand as sly for the turn", () => {
+  const shared = {
+    cards: {
+      HandTrick: { name: "HandTrick", cost: 0, kind: "Skill", block: 7, turnHandSlyCount: 1 },
+      Shield: { name: "Shield", cost: 0, kind: "Skill", unplayable: true, block: 7 },
+      Gamble: { name: "Gamble", cost: 0, kind: "Skill", discardAll: true },
+    },
+    starterDeck: ["Gamble", "Shield", "HandTrick"],
+    monsters: [{ name: "Dummy", maxHp: 9999, intents: [{ kind: "Attack", value: 10 }] }],
+  };
+  const withHandTrick = simulateCombat(shared, () => 0.999999);
+  const withoutHandTrick = simulateCombat({
+    ...shared,
+    cards: {
+      HandTrick: { name: "HandTrick", cost: 0, kind: "Skill", block: 7 },
+      Shield: shared.cards.Shield,
+      Gamble: shared.cards.Gamble,
+    },
+  }, () => 0.999999);
+  assert.equal(withHandTrick.playerHpRemaining, 80);
+  assert.equal(withoutHandTrick.playerHpRemaining, 0);
+});
+
+test("simulateCombat: extraPoisonTicks adds an extra poison tick at enemy turn start", () => {
+  const shared = {
+    cards: {
+      Accelerant: { name: "Accelerant", cost: 1, kind: "Power", extraPoisonTicks: 1 },
+      Poison: { name: "Poison", cost: 1, kind: "Skill", poison: 2 },
+    },
+    starterDeck: ["Accelerant", "Poison"],
+    monsters: [{ name: "Dummy", maxHp: 3, intents: [{ kind: "Attack", value: 0 }] }],
+  };
+  const withTick = simulateCombat(shared, () => 0.999999);
+  const withoutTick = simulateCombat({
+    ...shared,
+    cards: {
+      Accelerant: { name: "Accelerant", cost: 1, kind: "Power" },
+      Poison: shared.cards.Poison,
+    },
+  }, () => 0.999999);
+  assert.equal(withTick.win, true);
+  assert.equal(withTick.turns, 1);
+  assert.equal(withoutTick.turns, 2);
+});
+
+test("simulateCombat: poisonApplicationBurstEvery bursts after every third poison application", () => {
+  const shared = {
+    cards: {
+      Outbreak: { name: "Outbreak", cost: 1, kind: "Power", poisonApplicationBurstEvery: 3, poisonApplicationBurstDamage: 11 },
+      Poison1: { name: "Poison1", cost: 0, kind: "Skill", poison: 1 },
+      Poison2: { name: "Poison2", cost: 0, kind: "Skill", poison: 1 },
+      Poison3: { name: "Poison3", cost: 0, kind: "Skill", poison: 1 },
+    },
+    starterDeck: ["Outbreak", "Poison1", "Poison2", "Poison3"],
+    monsters: [
+      { name: "DummyA", maxHp: 11, intents: [{ kind: "Attack", value: 0 }] },
+      { name: "DummyB", maxHp: 11, intents: [{ kind: "Attack", value: 0 }] },
+    ],
+  };
+  const withBurst = simulateCombat(shared, () => 0.999999);
+  const withoutBurst = simulateCombat({
+    ...shared,
+    cards: {
+      Outbreak: { name: "Outbreak", cost: 1, kind: "Power" },
+      Poison1: shared.cards.Poison1,
+      Poison2: shared.cards.Poison2,
+      Poison3: shared.cards.Poison3,
+    },
+  }, () => 0.999999);
+  assert.equal(withBurst.win, true);
+  assert.equal(withBurst.turns, 1);
+  assert.ok(withoutBurst.turns > withBurst.turns);
+});
+
+test("simulateCombat: firstCardDamageBonus applies on the first card played this turn", () => {
+  const data = {
+    cards: {
+      Strangle: { name: "Strangle", cost: 1, kind: "Attack", damage: 8, firstCardDamageBonus: 2 },
    },
    starterDeck: ["Strangle"],
    monsters: [{ name: "Dummy", maxHp: 10, intents: [{ kind: "Attack", value: 0 }] }],
@@ -811,6 +1063,19 @@ test("simulateCombat: cardPlayedDamage hits the target whenever a card is played
  assert.equal(r.win, true);
 });

+test("simulateCombat: blockPerDamageDealtThisTurn grants block from damage dealt this turn", () => {
+  const data = {
+    cards: {
+      Mirage: { name: "Mirage", cost: 1, kind: "Skill", blockPerDamageDealtThisTurn: 1, block: 0 },
+      Strike: { name: "Strike", cost: 1, kind: "Attack", damage: 4 },
+    },
+    starterDeck: ["Strike", "Mirage"],
+    monsters: [{ name: "Dummy", maxHp: 4, intents: [{ kind: "Attack", value: 0 }] }],
+  };
+  const r = simulateCombat(data, () => 0.999999);
+  assert.equal(r.win, true);
+});
+
 test("simulateCombat: cardPlayedRandomDamage hits a random enemy on card play", () => {
  const data = {
    cards: {
@@ -823,6 +1088,32 @@ test("simulateCombat: cardPlayedRandomDamage hits a random enemy on card play",
  assert.equal(r.win, true);
 });

+test("simulateCombat: rewardOnKill grants an extra reward screen when an attack kills", () => {
+  const data = {
+    cards: {
+      TheHunt: { name: "TheHunt", cost: 1, kind: "Attack", damage: 10, rewardOnKill: 1 },
+    },
+    starterDeck: ["TheHunt"],
+    monsters: [{ name: "Dummy", maxHp: 10, intents: [{ kind: "Attack", value: 0 }] }],
+  };
+  const r = simulateCombat(data, () => 0.999999);
+  assert.equal(r.win, true);
+  assert.equal(r.bonusRewardScreens, 1);
+});
+
+test("simulateCombat: intangible cards reduce incoming damage and persist across turns", () => {
+  const data = {
+    cards: {
+      Wraith: { name: "WraithForm", cost: 3, kind: "Power", intangible: 2, endTurnDexLoss: 1, innate: true },
+      Strike: { name: "Strike", cost: 1, kind: "Attack", damage: 1 },
+    },
+    starterDeck: ["Wraith", "Strike"],
+    monsters: [{ name: "Dummy", maxHp: 1, intents: [{ kind: "Attack", value: 10 }] }],
+  };
+  const r = simulateCombat(data, () => 0.999999);
+  assert.equal(r.win, true);
+});
+
 test("simulateCombat: useAllEnergy skewer consumes all energy for damage", () => {
  const data = {
    cards: {
@@ -866,3 +1157,38 @@ test("simulateCombat: damagePerCardDrawnThisCombat scales murder", () => {
  assert.equal(r.win, true);
  assert.ok(stats.Murder.damage > 1);
 });
+
+test("simulateCombat: shiv damage bonuses stack and first Shiv bonus applies once per turn", () => {
+  const data = {
+    cards: {
+      Accuracy: { name: "Accuracy", cost: 1, kind: "Power", shivDamageBonus: 2 },
+      PhantomBlades: { name: "PhantomBlades", cost: 1, kind: "Power", firstShivDamageBonus: 3 },
+      Shiv: { name: "Shiv", cost: 0, kind: "Attack", class: "shiv", damage: 1 },
+    },
+    starterDeck: ["Accuracy", "PhantomBlades", "Shiv"],
+    monsters: [{ name: "Dummy", maxHp: 6, intents: [{ kind: "Attack", value: 0 }] }],
+  };
+  const r = simulateCombat(data, () => 0.999999);
+  assert.equal(r.win, true);
+  assert.equal(r.turns, 1);
+});
+
+test("simulateCombat: shivAoe makes Shivs hit all enemies", () => {
+  const data = {
+    cards: {
+      FanOfKnives: { name: "FanOfKnives", cost: 2, kind: "Skill", addShiv: 2, shivAoe: true },
+      Accuracy: { name: "Accuracy", cost: 1, kind: "Power", shivDamageBonus: 2 },
+      Shiv: { name: "Shiv", cost: 0, kind: "Attack", class: "shiv", damage: 1 },
+      Pass: { name: "Pass", cost: 99, kind: "Skill" },
+    },
+    starterDeck: ["Accuracy", "FanOfKnives", "Pass"],
+    monsters: [
+      { name: "A", maxHp: 3, intents: [{ kind: "Attack", value: 0 }] },
+      { name: "B", maxHp: 3, intents: [{ kind: "Attack", value: 0 }] },
+      { name: "C", maxHp: 3, intents: [{ kind: "Attack", value: 0 }] },
+    ],
+  };
+  const r = simulateCombat(data, () => 0.999999);
+  assert.equal(r.win, true);
+  assert.equal(r.turns, 1);
+});
--- a/tools/cards/cards_excel.ps1
+++ b/tools/cards/cards_excel.ps1
@@ -0,0 +1,629 @@
+param(
+  [Parameter(Mandatory = $true, Position = 0)]
+  [ValidateSet('export', 'import')]
+  [string]$Action,
+  [string]$JsonPath,
+  [string]$XlsxPath,
+  [string]$OutJsonPath
+)
+
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+Add-Type -AssemblyName System.IO.Compression
+
+$repoRoot = (Resolve-Path (Join-Path $PSScriptRoot '..\..')).Path
+if ([string]::IsNullOrWhiteSpace($JsonPath)) { $JsonPath = Join-Path $repoRoot 'data\cards.json' }
+if ([string]::IsNullOrWhiteSpace($XlsxPath)) { $XlsxPath = Join-Path $repoRoot 'data\cards.xlsx' }
+if ([string]::IsNullOrWhiteSpace($OutJsonPath)) { $OutJsonPath = $JsonPath }
+
+$utf8NoBom = [System.Text.UTF8Encoding]::new($false)
+
+function Escape-Xml([string]$Text) {
+  if ($null -eq $Text) { return '' }
+  return [System.Security.SecurityElement]::Escape($Text)
+}
+
+function Get-ColumnName([int]$Index) {
+  $n = $Index
+  $name = ''
+  while ($n -gt 0) {
+    $n--
+    $name = [char][int](65 + ($n % 26)) + $name
+    $n = [math]::Floor($n / 26)
+  }
+  return $name
+}
+
+function Get-ColumnIndex([string]$Name) {
+  $n = 0
+  foreach ($ch in $Name.ToCharArray()) {
+    if ($ch -match '[A-Z]') {
+      $n = $n * 26 + ([int][char]$ch - 64)
+    }
+  }
+  return $n
+}
+
+function Get-CellRef([int]$Col, [int]$Row) {
+  return (Get-ColumnName $Col) + $Row
+}
+
+function Has-MapKey($Map, $Key) {
+  if ($null -eq $Map) { return $false }
+  if ($null -eq $Key) { return $false }
+  if ($Key -is [string] -and [string]::IsNullOrWhiteSpace($Key)) { return $false }
+  foreach ($existingKey in $Map.Keys) {
+    if ($existingKey -eq $Key) { return $true }
+  }
+  return $false
+}
+
+function Get-ScalarType($Value) {
+  if ($null -eq $Value) { return 'null' }
+  if ($Value -is [bool]) { return 'boolean' }
+  if ($Value -is [byte] -or $Value -is [sbyte] -or
+      $Value -is [int16] -or $Value -is [uint16] -or
+      $Value -is [int32] -or $Value -is [uint32] -or
+      $Value -is [int64] -or $Value -is [uint64] -or
+      $Value -is [single] -or $Value -is [double] -or $Value -is [decimal]) { return 'number' }
+  if ($Value -is [string]) { return 'string' }
+  return 'string'
+}
+
+function Get-CardSchema($Cards) {
+  $schema = [ordered]@{}
+  foreach ($cardEntry in $Cards.PSObject.Properties) {
+    $card = $cardEntry.Value
+    foreach ($prop in $card.PSObject.Properties) {
+      $kind = Get-ScalarType $prop.Value
+      if (-not (Has-MapKey $schema $prop.Name)) {
+        $schema[$prop.Name] = $kind
+      } elseif ($schema[$prop.Name] -ne $kind -and $kind -ne 'null') {
+        $schema[$prop.Name] = 'string'
+      }
+    }
+  }
+  return $schema
+}
+
+function Get-ColumnWidth([string]$Header, [string]$Type) {
+  switch ($Header) {
+    'id' { return 18 }
+    'name' { return 24 }
+    'desc' { return 48 }
+    'image' { return 36 }
+    'fx' { return 36 }
+    'kind' { return 12 }
+    'class' { return 12 }
+    'rarity' { return 12 }
+    default {
+      if ($Type -eq 'boolean') { return 10 }
+      if ($Type -eq 'number') { return 12 }
+      return 16
+    }
+  }
+}
+
+function To-InvariantNumber($Value) {
+  return [string]::Format([System.Globalization.CultureInfo]::InvariantCulture, '{0}', $Value)
+}
+
+function New-HeaderCellXml([string]$Ref, [string]$Text) {
+  $escaped = Escape-Xml $Text
+  return "<c r=""$Ref"" s=""1"" t=""inlineStr""><is><t xml:space=""preserve"">$escaped</t></is></c>"
+}
+
+function New-TextCellXml([string]$Ref, [string]$Text) {
+  $escaped = Escape-Xml $Text
+  return "<c r=""$Ref"" t=""inlineStr""><is><t xml:space=""preserve"">$escaped</t></is></c>"
+}
+
+function New-NumberCellXml([string]$Ref, $Value) {
+  if ($null -eq $Value) { return $null }
+  if ($Value -is [string] -and $Value -eq '') { return $null }
+  return "<c r=""$Ref""><v>$(To-InvariantNumber $Value)</v></c>"
+}
+
+function New-BoolCellXml([string]$Ref, $Value) {
+  if ($null -eq $Value) { return $null }
+  if ($Value -is [string] -and $Value -eq '') { return $null }
+  $bool = $false
+  if ($Value -is [bool]) {
+    $bool = $Value
+  } else {
+    $text = [string]$Value
+    if ($text -match '^(?i:true|1|yes|y)$') { $bool = $true }
+    elseif ($text -match '^(?i:false|0|no|n)$') { $bool = $false }
+    else { return $null }
+  }
+  $n = if ($bool) { 1 } else { 0 }
+  return "<c r=""$Ref"" t=""b""><v>$n</v></c>"
+}
+
+function New-CellXml([string]$Ref, $Value, [string]$Type) {
+  switch ($Type) {
+    'number' { return New-NumberCellXml $Ref $Value }
+    'boolean' { return New-BoolCellXml $Ref $Value }
+    default {
+      if ($null -eq $Value) {
+        return New-TextCellXml $Ref ''
+      }
+      return New-TextCellXml $Ref ([string]$Value)
+    }
+  }
+}
+
+function Get-WorksheetXml([string]$SheetName, [string[]]$Headers, [object[]]$Rows, [hashtable]$TypeMap) {
+  $maxCol = $Headers.Count
+  $lastCol = Get-ColumnName $maxCol
+  $rowCount = $Rows.Count + 1
+  $colsXml = New-Object System.Collections.Generic.List[string]
+  for ($i = 0; $i -lt $Headers.Count; $i++) {
+    $header = $Headers[$i]
+    $type = if (Has-MapKey $TypeMap $header) { [string]$TypeMap[$header] } else { 'string' }
+    $width = Get-ColumnWidth $header $type
+    $colsXml.Add("<col min=""$($i + 1)"" max=""$($i + 1)"" width=""$width"" customWidth=""1"" />")
+  }
+
+  $rowsXml = New-Object System.Collections.Generic.List[string]
+  $headerCells = New-Object System.Collections.Generic.List[string]
+  for ($i = 0; $i -lt $Headers.Count; $i++) {
+    $headerCells.Add((New-HeaderCellXml (Get-CellRef ($i + 1) 1) $Headers[$i]))
+  }
+  $rowsXml.Add("<row r=""1"" spans=""1:$maxCol"" ht=""20"" customHeight=""1"">$($headerCells -join '')</row>")
+
+  for ($r = 0; $r -lt $Rows.Count; $r++) {
+    $row = $Rows[$r]
+    $cells = New-Object System.Collections.Generic.List[string]
+    for ($c = 0; $c -lt $Headers.Count; $c++) {
+      $header = $Headers[$c]
+      $type = if (Has-MapKey $TypeMap $header) { [string]$TypeMap[$header] } else { 'string' }
+      $value = $null
+      if (Has-MapKey $row $header) { $value = $row[$header] }
+      $cellXml = New-CellXml (Get-CellRef ($c + 1) ($r + 2)) $value $type
+      if ($null -ne $cellXml) { $cells.Add($cellXml) }
+    }
+    $rowsXml.Add("<row r=""$($r + 2)"" spans=""1:$maxCol"">$($cells -join '')</row>")
+  }
+
+  $sheetView = '<sheetViews><sheetView workbookViewId="0"><pane ySplit="1" topLeftCell="A2" activePane="bottomLeft" state="frozen"/><selection pane="bottomLeft" activeCell="A2" sqref="A2"/></sheetView></sheetViews>'
+  $cols = '<cols>' + ($colsXml -join '') + '</cols>'
+  $sheetData = '<sheetData>' + ($rowsXml -join '') + '</sheetData>'
+  $autoFilter = "<autoFilter ref=""A1:$lastCol$rowCount""/>"
+  return @"
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+ xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  $sheetView
+  <sheetFormatPr defaultRowHeight="18"/>
+  $cols
+  $sheetData
+  $autoFilter
+  <pageMargins left="0.25" right="0.25" top="0.5" bottom="0.5" header="0.3" footer="0.3"/>
+</worksheet>
+"@
+}
+
+function Get-StylesXml {
+  return @"
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <fonts count="2">
+    <font>
+      <sz val="11"/>
+      <color rgb="FF000000"/>
+      <name val="Calibri"/>
+      <family val="2"/>
+      <scheme val="minor"/>
+    </font>
+    <font>
+      <b/>
+      <sz val="11"/>
+      <color rgb="FFFFFFFF"/>
+      <name val="Calibri"/>
+      <family val="2"/>
+      <scheme val="minor"/>
+    </font>
+  </fonts>
+  <fills count="2">
+    <fill><patternFill patternType="none"/></fill>
+    <fill><patternFill patternType="solid"><fgColor rgb="FF2D3748"/><bgColor indexed="64"/></patternFill></fill>
+  </fills>
+  <borders count="1">
+    <border>
+      <left/><right/><top/><bottom/><diagonal/>
+    </border>
+  </borders>
+  <cellStyleXfs count="1">
+    <xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>
+  </cellStyleXfs>
+  <cellXfs count="2">
+    <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>
+    <xf numFmtId="0" fontId="1" fillId="1" borderId="0" xfId="0" applyFont="1" applyFill="1"/>
+  </cellXfs>
+  <cellStyles count="1">
+    <cellStyle name="Normal" xfId="0" builtinId="0"/>
+  </cellStyles>
+</styleSheet>
+"@
+}
+
+function Get-WorkbookXml([string[]]$SheetNames) {
+  $sheetsXml = New-Object System.Collections.Generic.List[string]
+  for ($i = 0; $i -lt $SheetNames.Count; $i++) {
+    $sheetsXml.Add("<sheet name=""$(Escape-Xml $SheetNames[$i])"" sheetId=""$($i + 1)"" r:id=""rId$($i + 1)""/>")
+  }
+  return @"
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+ xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <sheets>
+    $($sheetsXml -join '')
+  </sheets>
+</workbook>
+"@
+}
+
+function Get-WorkbookRelsXml([int]$SheetCount) {
+  $rels = New-Object System.Collections.Generic.List[string]
+  for ($i = 1; $i -le $SheetCount; $i++) {
+    $rels.Add("<Relationship Id=""rId$i"" Type=""http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"" Target=""worksheets/sheet$i.xml""/>")
+  }
+  $rels.Add("<Relationship Id=""rId$($SheetCount + 1)"" Type=""http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"" Target=""styles.xml""/>")
+  return @"
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  $($rels -join '')
+</Relationships>
+"@
+}
+
+function Get-RootRelsXml {
+  return @"
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+</Relationships>
+"@
+}
+
+function Get-ContentTypesXml([int]$SheetCount) {
+  $overrides = New-Object System.Collections.Generic.List[string]
+  for ($i = 1; $i -le $SheetCount; $i++) {
+    $overrides.Add("<Override PartName=""/xl/worksheets/sheet$i.xml"" ContentType=""application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml""/>")
+  }
+  $overrides.Add('<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>')
+  $overrides.Add('<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>')
+  return @"
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  $($overrides -join '')
+</Types>
+"@
+}
+
+function Write-Xlsx([string]$Path, [hashtable]$Parts) {
+  $dir = Split-Path -Parent $Path
+  if (-not [string]::IsNullOrWhiteSpace($dir) -and -not (Test-Path $dir)) {
+    New-Item -ItemType Directory -Path $dir -Force | Out-Null
+  }
+  if (Test-Path $Path) {
+    Remove-Item -LiteralPath $Path -Force
+  }
+  $file = [System.IO.File]::Open($Path, [System.IO.FileMode]::Create, [System.IO.FileAccess]::ReadWrite)
+  try {
+    $zip = New-Object System.IO.Compression.ZipArchive($file, [System.IO.Compression.ZipArchiveMode]::Create, $false)
+    try {
+      foreach ($entryName in $Parts.Keys) {
+        $entry = $zip.CreateEntry($entryName)
+        $stream = $entry.Open()
+        $writer = New-Object System.IO.StreamWriter($stream, $utf8NoBom)
+        try {
+          $writer.Write([string]$Parts[$entryName])
+        } finally {
+          $writer.Dispose()
+          $stream.Dispose()
+        }
+      }
+    } finally {
+      $zip.Dispose()
+    }
+  } finally {
+    $file.Dispose()
+  }
+}
+
+function Read-XlsxXml([string]$Path, [string]$EntryName) {
+  $zip = [System.IO.Compression.ZipFile]::OpenRead($Path)
+  try {
+    $entry = $zip.GetEntry($EntryName)
+    if ($null -eq $entry) { throw "Missing XLSX entry: $EntryName" }
+    $stream = $entry.Open()
+    try {
+      $reader = New-Object System.IO.StreamReader($stream, $utf8NoBom)
+      try { return $reader.ReadToEnd() } finally { $reader.Dispose() }
+    } finally {
+      $stream.Dispose()
+    }
+  } finally {
+    $zip.Dispose()
+  }
+}
+
+function Read-SharedStrings([string]$Path) {
+  try {
+    $xmlText = Read-XlsxXml $Path 'xl/sharedStrings.xml'
+  } catch {
+    return @()
+  }
+  [xml]$xml = $xmlText
+  $ns = New-Object System.Xml.XmlNamespaceManager($xml.NameTable)
+  $ns.AddNamespace('x', 'http://schemas.openxmlformats.org/spreadsheetml/2006/main')
+  $items = $xml.SelectNodes('/x:sst/x:si', $ns)
+  $values = New-Object System.Collections.Generic.List[string]
+  foreach ($item in $items) {
+    $values.Add([string]$item.InnerText)
+  }
+  return $values.ToArray()
+}
+
+function Read-WorksheetRows([string]$XmlText, [string[]]$SharedStrings) {
+  [xml]$xml = $XmlText
+  $ns = New-Object System.Xml.XmlNamespaceManager($xml.NameTable)
+  $ns.AddNamespace('x', 'http://schemas.openxmlformats.org/spreadsheetml/2006/main')
+  $rows = $xml.SelectNodes('/x:worksheet/x:sheetData/x:row', $ns)
+  $parsed = @()
+  foreach ($row in $rows) {
+    $cells = @{}
+    foreach ($cell in @($row.ChildNodes)) {
+      if ($cell.Name -ne 'c') { continue }
+      $ref = [string]$cell.Attributes['r'].Value
+      $col = Get-ColumnIndex (($ref -replace '\d+$', ''))
+      $type = [string]$cell.Attributes['t'].Value
+      $text = [string]$cell.InnerText
+      if ($type -eq 's' -and $text -match '^\d+$') {
+        $index = [int]$text
+        if ($index -ge 0 -and $index -lt $SharedStrings.Count) {
+          $text = [string]$SharedStrings[$index]
+        }
+      }
+      $cells[$col] = $text
+    }
+    $parsed += ,$cells
+  }
+  return $parsed
+}
+
+function Convert-CellValue([string]$Text, [string]$Type) {
+  if ($null -eq $Text -or $Text -eq '') { return $null }
+  switch ($Type) {
+    'number' {
+      $num = 0
+      if ([double]::TryParse($Text, [System.Globalization.NumberStyles]::Any, [System.Globalization.CultureInfo]::InvariantCulture, [ref]$num)) {
+        if ([math]::Abs($num - [math]::Round($num)) -lt 0.0000001) { return [int64][math]::Round($num) }
+        return $num
+      }
+      return $null
+    }
+    'boolean' {
+      if ($Text -match '^(?i:true|1|yes|y)$') { return $true }
+      if ($Text -match '^(?i:false|0|no|n)$') { return $false }
+      return $null
+    }
+    default {
+      return $Text
+    }
+  }
+}
+
+function Export-Cards {
+  $source = Get-Content -LiteralPath $JsonPath -Raw -Encoding utf8 | ConvertFrom-Json
+  $schema = Get-CardSchema $source.cards
+  $cardCore = @('id', 'name', 'cost', 'kind', 'rarity', 'class', 'desc', 'image', 'fx')
+  $cardExtras = @($schema.Keys | Where-Object { $_ -notin $cardCore } | Sort-Object)
+  $cardHeaders = @($cardCore + $cardExtras)
+
+  $maxDeckSize = 0
+  foreach ($deckEntry in $source.starterDecks.PSObject.Properties) {
+    $deckSize = @($deckEntry.Value).Count
+    if ($deckSize -gt $maxDeckSize) {
+      $maxDeckSize = $deckSize
+    }
+  }
+  if ($maxDeckSize -lt 1) { $maxDeckSize = 1 }
+
+  $starterDeckHeaders = New-Object System.Collections.Generic.List[string]
+  $starterDeckHeaders.Add('class')
+  for ($i = 1; $i -le $maxDeckSize; $i++) {
+    $starterDeckHeaders.Add("slot$i")
+  }
+
+  $cardRows = New-Object System.Collections.Generic.List[object]
+  foreach ($cardEntry in $source.cards.PSObject.Properties) {
+    $cardId = $cardEntry.Name
+    $card = $cardEntry.Value
+    $row = [ordered]@{ id = $cardId }
+    foreach ($header in $cardHeaders) {
+      if ($header -eq 'id') { continue }
+      if ($card.PSObject.Properties.Name -contains $header) {
+        $row[$header] = $card.$header
+      } else {
+        $row[$header] = $null
+      }
+    }
+    $cardRows.Add($row)
+  }
+
+  $deckRows = New-Object System.Collections.Generic.List[object]
+  foreach ($deckEntry in $source.starterDecks.PSObject.Properties) {
+    $cls = $deckEntry.Name
+    $deck = @($deckEntry.Value)
+    $row = [ordered]@{ class = $cls }
+    for ($i = 1; $i -le $maxDeckSize; $i++) {
+      $key = "slot$i"
+      $row[$key] = if ($i -le $deck.Count) { $deck[$i - 1] } else { $null }
+    }
+    $deckRows.Add($row)
+  }
+
+  $cardSheet = Get-WorksheetXml 'Cards' $cardHeaders $cardRows $schema
+  $deckTypeMap = [ordered]@{ class = 'string' }
+  for ($i = 1; $i -le $maxDeckSize; $i++) { $deckTypeMap["slot$i"] = 'string' }
+  $deckSheet = Get-WorksheetXml 'StarterDecks' $starterDeckHeaders $deckRows $deckTypeMap
+
+  $parts = [ordered]@{
+    '[Content_Types].xml' = (Get-ContentTypesXml 2)
+    '_rels/.rels' = (Get-RootRelsXml)
+    'xl/workbook.xml' = (Get-WorkbookXml @('Cards', 'StarterDecks'))
+    'xl/_rels/workbook.xml.rels' = (Get-WorkbookRelsXml 2)
+    'xl/styles.xml' = (Get-StylesXml)
+    'xl/worksheets/sheet1.xml' = $cardSheet
+    'xl/worksheets/sheet2.xml' = $deckSheet
+  }
+
+  Write-Host "Source JSON: $JsonPath"
+  Write-Host "Target XLSX: $XlsxPath"
+  Write-Xlsx $XlsxPath $parts
+  Write-Host "Excel export complete: $XlsxPath"
+}
+
+function Import-Cards {
+  $source = Get-Content -LiteralPath $JsonPath -Raw -Encoding utf8 | ConvertFrom-Json
+  $schema = Get-CardSchema $source.cards
+  $origCardOrders = @{}
+  foreach ($cardEntry in $source.cards.PSObject.Properties) {
+    $origCardOrders[$cardEntry.Name] = @($cardEntry.Value.PSObject.Properties.Name)
+  }
+  $origDeckOrder = @($source.starterDecks.PSObject.Properties.Name)
+
+  $sharedStrings = Read-SharedStrings $XlsxPath
+  $cardsXml = Read-XlsxXml $XlsxPath 'xl/worksheets/sheet1.xml'
+  $deckXml = Read-XlsxXml $XlsxPath 'xl/worksheets/sheet2.xml'
+  $cardRowsRaw = Read-WorksheetRows $cardsXml $sharedStrings
+  $deckRowsRaw = Read-WorksheetRows $deckXml $sharedStrings
+
+  if ($cardRowsRaw.Count -lt 2) { throw 'Cards sheet has no data rows.' }
+  if ($deckRowsRaw.Count -lt 2) { throw 'StarterDecks sheet has no data rows.' }
+
+  $cardHeaderMap = $cardRowsRaw[0]
+  $cardHeaders = @($cardHeaderMap.Keys | Sort-Object)
+  $orderedCardHeaders = New-Object System.Collections.Generic.List[string]
+  foreach ($col in $cardHeaders) {
+    $header = $cardHeaderMap[$col]
+    if ([string]::IsNullOrWhiteSpace($header)) { continue }
+    $orderedCardHeaders.Add($header)
+  }
+
+  $newCards = [ordered]@{}
+  for ($r = 1; $r -lt $cardRowsRaw.Count; $r++) {
+    $row = $cardRowsRaw[$r]
+    $cardId = $null
+    $rowValues = @{}
+    for ($c = 0; $c -lt $orderedCardHeaders.Count; $c++) {
+      $header = $orderedCardHeaders[$c]
+      $text = $null
+      if (Has-MapKey $row ($c + 1)) { $text = $row[$c + 1] }
+      if ($header -eq 'id') {
+        $cardId = [string]$text
+        continue
+      }
+      $rowValues[$header] = $text
+    }
+    if (-not [string]::IsNullOrWhiteSpace($cardId)) {
+      $cardObj = [ordered]@{}
+      $fieldOrder = New-Object System.Collections.Generic.List[string]
+      if ($origCardOrders.ContainsKey($cardId)) {
+        foreach ($name in @($origCardOrders[$cardId])) {
+          if ($name -ne 'id' -and -not $fieldOrder.Contains($name)) {
+            $fieldOrder.Add($name)
+          }
+        }
+      }
+      foreach ($name in $orderedCardHeaders) {
+        if ($name -ne 'id' -and -not $fieldOrder.Contains($name)) {
+          $fieldOrder.Add($name)
+        }
+      }
+      foreach ($header in $fieldOrder) {
+        $text = $null
+        if (Has-MapKey $rowValues $header) { $text = $rowValues[$header] }
+        $type = if (Has-MapKey $schema $header) { [string]$schema[$header] } else { 'string' }
+        $value = Convert-CellValue $text $type
+        if ($null -eq $value) { continue }
+        $cardObj[$header] = $value
+      }
+      $newCards[$cardId] = $cardObj
+    }
+  }
+
+  $deckHeaderMap = $deckRowsRaw[0]
+  $deckHeaderCols = @($deckHeaderMap.Keys | Sort-Object)
+  $orderedDeckHeaders = New-Object System.Collections.Generic.List[string]
+  foreach ($col in $deckHeaderCols) {
+    $header = $deckHeaderMap[$col]
+    if ([string]::IsNullOrWhiteSpace($header)) { continue }
+    $orderedDeckHeaders.Add($header)
+  }
+
+  $newDecks = [ordered]@{}
+  for ($r = 1; $r -lt $deckRowsRaw.Count; $r++) {
+    $row = $deckRowsRaw[$r]
+    $cls = $null
+    $deckValues = @{}
+    for ($c = 0; $c -lt $orderedDeckHeaders.Count; $c++) {
+      $header = $orderedDeckHeaders[$c]
+      $text = $null
+      if (Has-MapKey $row ($c + 1)) { $text = $row[$c + 1] }
+      if ($header -eq 'class') {
+        $cls = [string]$text
+        continue
+      }
+      $deckValues[$header] = $text
+    }
+    if (-not [string]::IsNullOrWhiteSpace($cls)) {
+      $deck = New-Object System.Collections.Generic.List[string]
+      foreach ($header in $orderedDeckHeaders) {
+        if ($header -eq 'class') { continue }
+        $text = $null
+        if (Has-MapKey $deckValues $header) { $text = $deckValues[$header] }
+        if (-not [string]::IsNullOrWhiteSpace([string]$text)) {
+          $deck.Add([string]$text)
+        }
+      }
+      $newDecks[$cls] = $deck.ToArray()
+    }
+  }
+
+  if ($origDeckOrder.Count -gt 0) {
+    $orderedDecks = [ordered]@{}
+    foreach ($cls in $origDeckOrder) {
+      if (Has-MapKey $newDecks $cls) {
+        $orderedDecks[$cls] = $newDecks[$cls]
+      }
+    }
+    foreach ($entry in $newDecks.GetEnumerator()) {
+      if (-not (Has-MapKey $orderedDecks $entry.Key)) {
+        $orderedDecks[$entry.Key] = $entry.Value
+      }
+    }
+    $newDecks = $orderedDecks
+  }
+
+  $out = [ordered]@{
+    cards = $newCards
+    starterDecks = $newDecks
+  }
+
+  $json = $out | ConvertTo-Json -Depth 64
+  Write-Host "Source XLSX: $XlsxPath"
+  Write-Host "Target JSON: $OutJsonPath"
+  [System.IO.File]::WriteAllText($OutJsonPath, $json, $utf8NoBom)
+  Write-Host "JSON import complete: $OutJsonPath"
+}
+
+switch ($Action) {
+  'export' { Export-Cards }
+  'import' { Import-Cards }
+}
--- a/tools/deck/cb/charselect.mjs
+++ b/tools/deck/cb/charselect.mjs
@@ -11,14 +11,14 @@ self:RenderCharacterSelect()`, [
      { Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'className' },
    ]),
    method('RenderCharacterSelect', `local base = "/ui/SelectUIGroup/CharacterSelectHud"
-local arts = { { p = "/WarriorButton/Art", c = "warrior" }, { p = "/MageButton/Art", c = "magician" }, { p = "/BanditButton/Art", c = "bandit" } }
+local arts = { { p = "/WarriorButton/Art", c = "warrior" }, { p = "/MageButton/Art", c = "magician" }, { p = "/BanditButton/Art", c = "rogue" } }
 for i = 1, #arts do
 	local e = _EntityService:GetEntityByPath(base .. arts[i].p)
 	if e ~= nil and e.SpriteGUIRendererComponent ~= nil and self.ClassPortraits ~= nil and self.ClassPortraits[arts[i].c] ~= nil then
 		e.SpriteGUIRendererComponent.ImageRUID = self.ClassPortraits[arts[i].c]
 	end
 end
-local btns = { { p = "/WarriorButton", c = "warrior" }, { p = "/MageButton", c = "magician" }, { p = "/BanditButton", c = "bandit" } }
+local btns = { { p = "/WarriorButton", c = "warrior" }, { p = "/MageButton", c = "magician" }, { p = "/BanditButton", c = "rogue" } }
 for i = 1, #btns do
 	local e = _EntityService:GetEntityByPath(base .. btns[i].p)
 	if e ~= nil then
@@ -44,9 +44,9 @@ if self.SelectedClass == "warrior" then
 	eng = "Warrior"
 	btnName = "/WarriorButton"
 	desc = "직업군 · 모험가" .. nl .. "방어를 쌓고 버티다 강하게 역공하는 단단한 탱커."
-elseif self.SelectedClass == "bandit" then
+elseif self.SelectedClass == "rogue" then
 	name = "도적"
-	eng = "Thief"
+	eng = "Rogue"
 	btnName = "/BanditButton"
 	desc = "직업군 · 모험가" .. nl .. "표창 난사와 독으로 빠르게 몰아치는 민첩한 직업."
 elseif self.SelectedClass == "magician" then
@@ -65,7 +65,7 @@ end
 self:SetText(base .. "/SelectedClass", name)
 self:SetText(base .. "/SelectedClass/SelectedClassEng", eng)
 self:SetText(base .. "/SelectedClassStatus", desc)`),
-    method('StartNewGame', `if self.SelectedClass ~= "warrior" and self.SelectedClass ~= "bandit" and self.SelectedClass ~= "magician" then
+    method('StartNewGame', `if self.SelectedClass ~= "warrior" and self.SelectedClass ~= "rogue" and self.SelectedClass ~= "magician" then
 	self:SetText("/ui/SelectUIGroup/CharacterSelectHud/SelectedClassStatus", "직업을 먼저 선택하세요")
 	return
 end
--- a/tools/deck/cb/combat.mjs
+++ b/tools/deck/cb/combat.mjs
@@ -46,24 +46,55 @@ if self:CanPlayCardNow(c) ~= true then
 end
 local cost = c.cost or 0
 local skillFree = false
+local skillRepeat = 0
 if self.HandCostZeroThisTurn == true then
 	cost = 0
 elseif c.useAllEnergy == true then
 	cost = self.Energy
 end
-if c.kind == "Skill" and self.NextSkillCostZero == true then
+if c.kind == "Skill" and c.useAllEnergy ~= true and self.NextSkillCostZero == true then
 	cost = 0
 	skillFree = true
 end
-if c.kind == "Skill" and self.SkillCostReductionThisTurn ~= nil and self.SkillCostReductionThisTurn > 0 then
+if c.kind == "Skill" and c.useAllEnergy ~= true and self.SkillCostReductionThisTurn ~= nil and self.SkillCostReductionThisTurn > 0 then
 	cost = math.max(0, cost - self.SkillCostReductionThisTurn)
 end
+if c.useAllEnergy ~= true and self.CombatCardCostReduction ~= nil and self.CombatCardCostReduction[cardId] ~= nil then
+	cost = math.max(0, cost - self.CombatCardCostReduction[cardId])
+end
+if c.kind == "Skill" and self.NextSkillRepeatCount ~= nil and self.NextSkillRepeatCount > 0 then
+	skillRepeat = self.NextSkillRepeatCount
+end
 if self.Energy < cost then
 	self:Toast("에너지가 부족합니다")
 	return
 end
 self.Energy = self.Energy - cost
+self.ActiveKillReward = c.rewardOnKill or 0
 self:ResolveCardEffects(cardId, slot, c, false, cost)
+local function applyCardPlayHooks()
+	if self:HasPowerField("cardPlayedBlock") == true then
+		self:AddCardBlock(self:AddPowerFieldTotal("cardPlayedBlock"))
+	end
+	if c.cardPlayedDamage ~= nil and c.cardPlayedDamage > 0 then
+		self:DealDirectDamageToTarget(c.cardPlayedDamage)
+	end
+	if c.cardPlayedRandomDamage ~= nil and c.cardPlayedRandomDamage > 0 then
+		self:DealDirectDamageToRandomMonster(c.cardPlayedRandomDamage)
+	end
+end
+applyCardPlayHooks()
+if skillRepeat > 0 then
+	local remaining = (self.NextSkillRepeatCount or 0) - skillRepeat
+	if remaining < 0 then
+		remaining = 0
+	end
+	self.NextSkillRepeatCount = remaining
+	for i = 1, skillRepeat do
+		self:ResolveCardEffects(cardId, slot, c, false, cost)
+		applyCardPlayHooks()
+	end
+end
 if c.kind == "Attack" then
 	self.TurnAttackCardsPlayed = (self.TurnAttackCardsPlayed or 0) + 1
 end
@@ -72,14 +103,14 @@ if skillFree == true then
 		self.NextSkillCostZero = false
 	end
 end
-if self:HasPowerField("cardPlayedBlock") == true then
-	self:AddCardBlock(self:AddPowerFieldTotal("cardPlayedBlock"))
+if self.ActiveKillReward ~= nil and self.ActiveKillReward <= 0 then
+	self.ActiveKillReward = 0
 end
-if c.cardPlayedDamage ~= nil and c.cardPlayedDamage > 0 then
-	self:DealDirectDamageToTarget(c.cardPlayedDamage)
-end
-if c.cardPlayedRandomDamage ~= nil and c.cardPlayedRandomDamage > 0 then
-	self:DealDirectDamageToRandomMonster(c.cardPlayedRandomDamage)
+if c.combatCostReductionOnPlay ~= nil and c.combatCostReductionOnPlay > 0 then
+	if self.CombatCardCostReduction == nil then
+		self.CombatCardCostReduction = {}
+	end
+	self.CombatCardCostReduction[cardId] = (self.CombatCardCostReduction[cardId] or 0) + c.combatCostReductionOnPlay
 end
 table.remove(self.Hand, slot)
 if c.exhaust == true then
@@ -235,7 +266,7 @@ end`, [
      { Type: 'any', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'touchPoint' },
    ]),
    method('Toast', `log(message)`, [{ Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'message' }]),
-    method('DealDamageToTarget', `local m = self.Monsters[self.TargetIndex]
+method('DealDamageToTarget', `local m = self.Monsters[self.TargetIndex]
 if m == nil or m.alive ~= true then
 	m = nil
 	for i = 1, #self.Monsters do
@@ -243,12 +274,15 @@ if m == nil or m.alive ~= true then
 	end
 end
 if m == nil then
-	return
+	return false
 end
 local dmg = amount
 if m.vuln > 0 then
 	dmg = math.floor(dmg * 1.5)
 end
+if m.weak > 0 and self.ActiveAttackDamageVsWeakMultiplier ~= nil and self.ActiveAttackDamageVsWeakMultiplier > 1 then
+	dmg = math.floor(dmg * self.ActiveAttackDamageVsWeakMultiplier)
+end
 if m.block > 0 and pierce ~= true then
 	local absorbed = math.min(m.block, dmg)
 	m.block = m.block - absorbed
@@ -258,17 +292,20 @@ m.hp = m.hp - dmg
 if dmg > 0 then
 	local poison = self:AddPowerFieldTotal("attackPoison")
 	if poison ~= nil and poison > 0 then
-		m.poison = (m.poison or 0) + poison
+		self:ApplyPoisonToMonster(m, poison)
 	end
 end
 self:MonsterHitMotion(m.slot)
+local killed = false
 if m.hp <= 0 then
 	m.hp = 0
 	self:KillMonster(m.slot)
-end`, [
+	killed = true
+end
+return killed`, [
      { Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'amount' },
      { Type: 'boolean', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'pierce' },
-    ]),
+    ], 0, 'boolean'),
    method('DealDirectDamageToTarget', `local m = self.Monsters[self.TargetIndex]
 if m == nil or m.alive ~= true then
 	m = nil
@@ -277,17 +314,20 @@ if m == nil or m.alive ~= true then
 	end
 end
 if m == nil then
-	return
+	return false
 end
 m.hp = m.hp - amount
 self:ShowDmgPop(m.slot, amount)
 self:MonsterHitMotion(m.slot)
+local killed = false
 if m.hp <= 0 then
 	m.hp = 0
 	self:KillMonster(m.slot)
-end`, [
+	killed = true
+end
+return killed`, [
      { Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'amount' },
-    ]),
+    ], 0, 'boolean'),
    method('DealDirectDamageToRandomMonster', `local alive = {}
 for i = 1, #self.Monsters do
 	local m = self.Monsters[i]
@@ -296,24 +336,91 @@ for i = 1, #self.Monsters do
 	end
 end
 if #alive <= 0 then
-	return
+	return false
 end
 local m = alive[math.random(1, #alive)]
 if m == nil then
-	return
+	return false
 end
 m.hp = m.hp - amount
 self:ShowDmgPop(m.slot, amount)
 self:MonsterHitMotion(m.slot)
+local killed = false
 if m.hp <= 0 then
 	m.hp = 0
 	self:KillMonster(m.slot)
+	killed = true
+end
+return killed`, [
+      { Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'amount' },
+    ], 0, 'boolean'),
+method('ApplyPoisonToMonster', `if target == nil or target.alive ~= true or amount == nil or amount <= 0 then
+	return
+end
+if target.artifact ~= nil and target.artifact > 0 then
+	target.artifact = target.artifact - 1
+	return
+end
+target.poison = (target.poison or 0) + amount
+self.PoisonApplicationsThisCombat = (self.PoisonApplicationsThisCombat or 0) + 1
+local burstEvery = self:AddPowerFieldTotal("poisonApplicationBurstEvery")
+local burstDamage = self:AddPowerFieldTotal("poisonApplicationBurstDamage")
+if burstEvery ~= nil and burstEvery > 0 and burstDamage ~= nil and burstDamage > 0 then
+	if (self.PoisonApplicationsThisCombat % burstEvery) == 0 then
+		self:DealDamageToAllMonsters(burstDamage)
+	end
 end`, [
+      { Type: 'any', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'target' },
      { Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'amount' },
    ]),
+    method('DealDamageToAllMonsters', `if self.Monsters == nil then
+	return false
+end
+local killCount = 0
+for i = 1, #self.Monsters do
+	local m = self.Monsters[i]
+	if m ~= nil and m.alive == true then
+		local dmg = amount
+		if isAttack == true and m.vuln > 0 then
+			dmg = math.floor(dmg * 1.5)
+		end
+		if m.block > 0 then
+			local absorbed = math.min(m.block, dmg)
+			m.block = m.block - absorbed
+			dmg = dmg - absorbed
+		end
+		m.hp = m.hp - dmg
+		if dmg > 0 then
+			self.DamageDealtThisTurn = (self.DamageDealtThisTurn or 0) + dmg
+			if isAttack == true then
+				local poison = self:AddPowerFieldTotal("attackPoison")
+				if poison ~= nil and poison > 0 then
+					self:ApplyPoisonToMonster(m, poison)
+				end
+			end
+		end
+		self:ShowDmgPop(i, dmg)
+		self:MonsterHitMotion(i)
+		if m.hp <= 0 then
+			m.hp = 0
+			self:KillMonster(m.slot)
+			killCount = killCount + 1
+		end
+	end
+end
+if killCount > 0 and self.ActiveKillReward ~= nil and self.ActiveKillReward > 0 then
+	self.BonusRewardScreens = (self.BonusRewardScreens or 0) + (killCount * self.ActiveKillReward)
+end
+self:RenderCombat()
+self:CheckCombatEnd()
+return killCount > 0`, [
+      { Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'amount' },
+      { Type: 'boolean', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'isAttack' },
+    ], 0, 'boolean'),
    method('PlayAttackFx', `local m = self.Monsters[targetIndex]
 if m == nil or m.alive ~= true or m.entity == nil or not isvalid(m.entity) then
 	self:DealDamageToTarget(damage, pierce)
+	self.ActiveAttackDamageVsWeakMultiplier = 1
 	self:RenderCombat()
 	self:CheckCombatEnd()
 	return
@@ -339,7 +446,15 @@ _TimerService:SetTimerOnce(function()
 	if mt ~= nil and mt.alive == true and mt.vuln > 0 then
 		shown = math.floor(damage * 1.5)
 	end
-	self:DealDamageToTarget(damage, pierce)
+	if mt ~= nil and mt.alive == true and mt.weak > 0 and self.ActiveAttackDamageVsWeakMultiplier ~= nil and self.ActiveAttackDamageVsWeakMultiplier > 1 then
+		shown = math.floor(shown * self.ActiveAttackDamageVsWeakMultiplier)
+	end
+	local killed = self:DealDamageToTarget(damage, pierce)
+	if killed == true and self.ActiveKillReward ~= nil and self.ActiveKillReward > 0 then
+		self.BonusRewardScreens = (self.BonusRewardScreens or 0) + self.ActiveKillReward
+	end
+	self.ActiveKillReward = 0
+	self.ActiveAttackDamageVsWeakMultiplier = 1
 	self:ShowDmgPop(targetIndex, shown)
 	self:RenderCombat()
 	self:CheckCombatEnd()
@@ -363,6 +478,7 @@ end
 _TimerService:SetTimerOnce(function()
 	if fx ~= nil then fx.Enable = false end
 	self.FxBusy = false
+	local killCount = 0
 	for i = 1, #self.Monsters do
 		local m = self.Monsters[i]
 		if m ~= nil and m.alive == true then
@@ -370,6 +486,9 @@ _TimerService:SetTimerOnce(function()
 			if m.vuln > 0 then
 				dmg = math.floor(dmg * 1.5)
 			end
+			if m.weak > 0 and self.ActiveAttackDamageVsWeakMultiplier ~= nil and self.ActiveAttackDamageVsWeakMultiplier > 1 then
+				dmg = math.floor(dmg * self.ActiveAttackDamageVsWeakMultiplier)
+			end
 			if m.block > 0 then
 				local absorbed = math.min(m.block, dmg)
 				m.block = m.block - absorbed
@@ -379,7 +498,7 @@ _TimerService:SetTimerOnce(function()
 			if dmg > 0 then
 				local poison = self:AddPowerFieldTotal("attackPoison")
 				if poison ~= nil and poison > 0 then
-					m.poison = (m.poison or 0) + poison
+					self:ApplyPoisonToMonster(m, poison)
 				end
 			end
 			self:ShowDmgPop(i, dmg)
@@ -387,9 +506,15 @@ _TimerService:SetTimerOnce(function()
 			if m.hp <= 0 then
 				m.hp = 0
 				self:KillMonster(m.slot)
+				killCount = killCount + 1
 			end
 		end
 	end
+	if killCount > 0 and self.ActiveKillReward ~= nil and self.ActiveKillReward > 0 then
+		self.BonusRewardScreens = (self.BonusRewardScreens or 0) + (killCount * self.ActiveKillReward)
+	end
+	self.ActiveKillReward = 0
+	self.ActiveAttackDamageVsWeakMultiplier = 1
 	self:RenderCombat()
 	self:CheckCombatEnd()
 end, 0.35)`, [
@@ -415,6 +540,9 @@ if self.PlayerBlock > 0 then
 	self.PlayerBlock = self.PlayerBlock - absorbed
 	dmg = dmg - absorbed
 end
+if dmg > 0 and self.PlayerIntangible ~= nil and self.PlayerIntangible > 0 and dmg > 1 then
+	dmg = 1
+end
 if dmg > 0 then
 	self.PlayerHp = self.PlayerHp - dmg
 	local reflect = self.PlayerThorns or 0
@@ -462,18 +590,25 @@ local m = self.Monsters[idx]
 local base = "/ui/RunUIGroup/CombatHud/MonsterStatus" .. tostring(idx)
 self:SetEntityEnabled(base .. "/ActFrame", true)
 _TimerService:SetTimerOnce(function()
-	if m.poison ~= nil and m.poison > 0 then
-		m.hp = m.hp - m.poison
-		self:ShowDmgPop(idx, m.poison)
-		self:MonsterHitMotion(idx)
-		m.poison = m.poison - 1
-		if m.hp <= 0 then
-			m.hp = 0
-			self:KillMonster(m.slot)
-			self:RenderCombat()
-			self:SetEntityEnabled(base .. "/ActFrame", false)
-			_TimerService:SetTimerOnce(function() self:EnemyActStep(idx + 1) end, 0.15)
-			return
+	local poisonTicks = 1
+	local bonusTicks = self:AddPowerFieldTotal("extraPoisonTicks")
+	if bonusTicks ~= nil and bonusTicks > 0 then
+		poisonTicks = poisonTicks + bonusTicks
+	end
+	for pt = 1, poisonTicks do
+		if m.poison ~= nil and m.poison > 0 then
+			m.hp = m.hp - m.poison
+			self:ShowDmgPop(idx, m.poison)
+			self:MonsterHitMotion(idx)
+			m.poison = m.poison - 1
+			if m.hp <= 0 then
+				m.hp = 0
+				self:KillMonster(m.slot)
+				self:RenderCombat()
+				self:SetEntityEnabled(base .. "/ActFrame", false)
+				_TimerService:SetTimerOnce(function() self:EnemyActStep(idx + 1) end, 0.15)
+				return
+			end
 		end
 	end
 	m.block = 0
@@ -482,6 +617,10 @@ _TimerService:SetTimerOnce(function()
 		if intent.kind == "Attack" then
 			self:MonsterLunge(idx)
 			local atk = intent.value + m.str
+			if self.EnemyStrengthLossThisTurn ~= nil and self.EnemyStrengthLossThisTurn > 0 then
+				atk = atk - self.EnemyStrengthLossThisTurn
+				if atk < 0 then atk = 0 end
+			end
 			if m.weak > 0 then
 				atk = math.floor(atk * 0.75)
 			end
@@ -550,7 +689,10 @@ self.NextTurnAddCards = {}
 self:UpdateDiscardPrompt()
 self:RenderHand(false)
 self:RenderPiles()`),
-    method('CheckCombatEnd', `local anyAlive = false
+    method('CheckCombatEnd', `if self.CombatOver == true then
+	return
+end
+local anyAlive = false
 for i = 1, #self.Monsters do
 	if self.Monsters[i].alive == true then anyAlive = true; break end
 end
@@ -575,7 +717,7 @@ if anyAlive == false then
 		end
 	end
 	if node ~= nil and node.type == "boss" then
-		if self.PlayerJob == "" and self.Floor < self.RunLength then
+		if self:CanAdvanceJob() == true and self.Floor < self.RunLength then
 			self:ShowJobChoice()
 		else
 			if self.PlayerJob ~= "" then self:AwardSouls(1) end
--- a/tools/deck/cb/deckturn.mjs
+++ b/tools/deck/cb/deckturn.mjs
@@ -10,7 +10,11 @@ for i = #list, 2, -1 do
 \tlocal j = math.random(1, i)
 \tlist[i], list[j] = list[j], list[i]
 end`, [{ Type: 'any', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'list' }]),
-    method('BindButtons', `local endTurn = _EntityService:GetEntityByPath("/ui/RunUIGroup/DeckHud/EndTurnButton")
+    method('BindButtons', `if self.ButtonsBound == true then
+	return
+end
+self.ButtonsBound = true
+local endTurn = _EntityService:GetEntityByPath("/ui/RunUIGroup/DeckHud/EndTurnButton")
 if endTurn ~= nil and (endTurn.ButtonComponent ~= nil or endTurn:AddComponent("ButtonComponent") ~= nil) then
 	if self.EndTurnHandler ~= nil then
 		endTurn:DisconnectEvent(ButtonClickEvent, self.EndTurnHandler)
@@ -228,6 +232,8 @@ self.RetainSelectActive = false
 self.ReserveSelectActive = false
 self.TurnAttackCardsPlayed = 0
 self.TurnDiscardedCards = 0
+self.TurnCardsPlayedThisTurn = 0
+self.DamageDealtThisTurn = 0
 self.NextTurnSelectCopies = 0
 self.NextTurnSelectPrompt = ""
 self.SkillCostReductionThisTurn = 0
@@ -247,6 +253,14 @@ end
 self.TurnAttackMultiplier = self.NextTurnAttackMultiplier or 1
 self.NextTurnAttackMultiplier = 1
 self.CardsDrawnThisCombat = self.CardsDrawnThisCombat or 0
+self.ShivFirstDamageBonusUsed = false
+self.ActiveAttackDamageVsWeakMultiplier = 1
+self.DrawDamageThisTurn = 0
+self.DrawPoisonThisTurn = 0
+self.ShivAoeThisCombat = false
+self.SkillSlyOnPlayCards = self.SkillSlyOnPlayCards or {}
+self.TurnSkillSlyCards = {}
+self.EnemyStrengthLossThisTurn = 0
 self.HandCostZeroThisTurn = false
 self.DrawDisabledThisTurn = false
 local powerTurnDraw = 0
@@ -266,7 +280,7 @@ if self.PlayerPowers ~= nil then
 					for j = 1, #self.Monsters do
 						local tm = self.Monsters[j]
 						if tm ~= nil and tm.alive == true then
-							tm.poison = (tm.poison or 0) + pc.value
+							self:ApplyPoisonToMonster(tm, pc.value)
 						end
 					end
 				end
@@ -419,17 +433,31 @@ local kept = {}
 for i = 1, #self.Hand do
 \tlocal cardId = self.Hand[i]
 \tlocal c = self.Cards[cardId]
-\tif c ~= nil and (c.retain == true or i == retainSlot) then
+\tif c ~= nil and (c.retain == true or (c.class == "shiv" and self:HasPowerField("shivRetain") == true) or i == retainSlot) then
 \t\ttable.insert(kept, cardId)
 \telse
 \t\ttable.insert(self.DiscardPile, cardId)
 \tend
 end
 self.Hand = kept
+if self.PlayerPowers ~= nil then
+	for i = 1, #self.PlayerPowers do
+		local pc = self.Cards[self.PlayerPowers[i]]
+		if pc ~= nil and pc.endTurnDexLoss ~= nil and pc.endTurnDexLoss > 0 then
+			self.PlayerDex = self.PlayerDex - pc.endTurnDexLoss
+			if self.PlayerDex < 0 then self.PlayerDex = 0 end
+		end
+	end
+end
+if self.PlayerIntangible ~= nil and self.PlayerIntangible > 0 then
+	self.PlayerIntangible = self.PlayerIntangible - 1
+	if self.PlayerIntangible < 0 then self.PlayerIntangible = 0 end
+end
 if self.PlayerWeak > 0 then self.PlayerWeak = self.PlayerWeak - 1 end
 if self.PlayerVuln > 0 then self.PlayerVuln = self.PlayerVuln - 1 end
 self:RenderHand(false)
 self:RenderPiles()
+self.TurnSkillSlyCards = {}
 self:EnemyTurn()`, [{ Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'retainSlot' }]),
 method('DrawCards', `local drawnSlots = {}
 local drawnCards = {}
@@ -447,6 +475,7 @@ for i = 1, amount do
 \tlocal cardId = table.remove(self.DrawPile)
 \ttable.insert(drawnCards, cardId)
 \tself.CardsDrawnThisCombat = (self.CardsDrawnThisCombat or 0) + 1
+\tself:ApplyDrawTrigger()
 \tif #self.Hand >= 10 then
 \t\ttable.insert(self.DiscardPile, cardId)
 \t\tself:TriggerSly(cardId)
--- a/tools/deck/cb/deckview.mjs
+++ b/tools/deck/cb/deckview.mjs
@@ -77,7 +77,7 @@ if thiefTab ~= nil and (thiefTab.ButtonComponent ~= nil or thiefTab:AddComponent
 		thiefTab:DisconnectEvent(ButtonClickEvent, self.ThiefDeckTabHandler)
 		self.ThiefDeckTabHandler = nil
 	end
-	self.ThiefDeckTabHandler = thiefTab:ConnectEvent(ButtonClickEvent, function() self:SetClassDeckTab("bandit") end)
+	self.ThiefDeckTabHandler = thiefTab:ConnectEvent(ButtonClickEvent, function() self:SetClassDeckTab("rogue") end)
 end
 local mageTab = _EntityService:GetEntityByPath("/ui/DeckUIGroup/DeckAllHud/MageTab")
 if mageTab ~= nil and (mageTab.ButtonComponent ~= nil or mageTab:AddComponent("ButtonComponent") ~= nil) then
@@ -101,8 +101,8 @@ end`, [{ Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], N
 	return
 end
 local className = self.SelectedClass
-if className ~= "warrior" and className ~= "magician" and className ~= "bandit" then
-	className = "bandit"
+if className ~= "warrior" and className ~= "magician" and className ~= "rogue" then
+	className = "rogue"
 end
 self.CodexMode = false
 self.ClassDeckMode = true
@@ -119,32 +119,30 @@ self:Toast("테스트 카드 추가 모드")`),
 end
 self.ClassDeckCards = {}
 self.ClassDeckTitle = "직업 덱"
-if className ~= "warrior" and className ~= "magician" and className ~= "bandit" then
-	className = "bandit"
+if className ~= "warrior" and className ~= "magician" and className ~= "rogue" then
+	className = "rogue"
 end
 self.ClassDeckClass = className
 local allowed = {}
+local group = nil
+if self.ClassGroups ~= nil then
+	group = self.ClassGroups[className]
+end
+if group == nil then
+	group = { className }
+end
+for i = 1, #group do
+	allowed[group[i]] = true
+end
 if className == "warrior" then
-	allowed["warrior"] = true
-	allowed["fighter"] = true
-	allowed["page"] = true
-	allowed["spearman"] = true
 	self.ClassDeckTitle = "전사 전체 덱"
 elseif className == "magician" then
-	allowed["magician"] = true
-	allowed["firepoison"] = true
-	allowed["icelightning"] = true
-	allowed["cleric"] = true
 	self.ClassDeckTitle = "마법사 전체 덱"
 else
-	allowed["bandit"] = true
-	allowed["shiv"] = true
-	allowed["poisoner"] = true
-	allowed["trickster"] = true
 	self.ClassDeckTitle = "도적 전체 덱"
 end
 for id, c in pairs(self.Cards) do
-	if c ~= nil and c.curse ~= true and allowed[c.class] == true then
+	if c ~= nil and c.curse ~= true and c.token ~= true and allowed[c.class] == true then
 		table.insert(self.ClassDeckCards, id)
 	end
 end
@@ -162,7 +160,7 @@ self:RenderAllDeck()
 self:RenderClassDeckTabs()`, [{ Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'className' }]),
    method('RenderClassDeckTabs', `local tabs = {
 	{ path = "/ui/DeckUIGroup/DeckAllHud/WarriorTab", cls = "warrior" },
-	{ path = "/ui/DeckUIGroup/DeckAllHud/ThiefTab", cls = "bandit" },
+	{ path = "/ui/DeckUIGroup/DeckAllHud/ThiefTab", cls = "rogue" },
 	{ path = "/ui/DeckUIGroup/DeckAllHud/MageTab", cls = "magician" },
 }
 for i = 1, #tabs do
--- a/tools/deck/cb/hand.mjs
+++ b/tools/deck/cb/hand.mjs
@@ -3,6 +3,42 @@ import { CARDS, ENEMIES, CLASSES, JOBS, SOUL_UNLOCKS, CARDFRAMES, RARITIES, MAP_
 import { UI_FILE, COMMON_FILE, UI_ROOT, GENERATED_UI_SECTIONS, UI_APPEND_ORDER, DISABLED_STOCK_CONTROLS, TRANSPARENT, DARK, GOLD, ATTACK, DEFEND, SKILL, DAMAGE_DIGIT_RUIDS, DAMAGE_POP_MAX_DIGITS, DAMAGE_POP_DIGIT_W, DAMAGE_POP_DIGIT_H, DAMAGE_POP_DIGIT_SPACING, MAX_MONSTERS, HEAD_OFFSET_Y, HP_BAR_W, WHITE, CARD_NAME_TEXT, CARD_DESC_TEXT, cardFaceLayout, CARD_W, CARD_H, CARD_SPACING, CARD_XS, ALIGN_CENTER, ALIGN_BOTTOM_CENTER, guid, transform, sprite, button, text, scrollLayoutGroup, popupLayerFor, uiOrderFor, displayOrderFor, applySortingOverride, entity, uiPath, sectionRoot, isGeneratedUiEntity, appendUiSection } from '../lib/ui-helpers.mjs';

 export const handMethods = [
+    method('ApplyDrawTrigger', `if self.Monsters == nil then
+	return
+end
+local drawDamage = self:AddPowerFieldTotal("drawDamage") + (self.DrawDamageThisTurn or 0)
+local drawPoison = self:AddPowerFieldTotal("drawPoison") + (self.DrawPoisonThisTurn or 0)
+if (drawDamage ~= nil and drawDamage > 0) or (drawPoison ~= nil and drawPoison > 0) then
+	for mi = 1, #self.Monsters do
+		local m2 = self.Monsters[mi]
+		if m2 ~= nil and m2.alive == true then
+			local dmg = drawDamage or 0
+			if m2.vuln > 0 then
+				dmg = math.floor(dmg * 1.5)
+			end
+			if m2.block > 0 then
+				local absorbed = math.min(m2.block, dmg)
+				m2.block = m2.block - absorbed
+				dmg = dmg - absorbed
+			end
+			if drawPoison ~= nil and drawPoison > 0 then
+				self:ApplyPoisonToMonster(m2, drawPoison)
+			end
+			if dmg > 0 then
+				m2.hp = m2.hp - dmg
+				self.DamageDealtThisTurn = (self.DamageDealtThisTurn or 0) + dmg
+			end
+			self:ShowDmgPop(mi, dmg)
+			self:MonsterHitMotion(mi)
+			if m2.hp <= 0 then
+				m2.hp = 0
+				self:KillMonster(m2.slot)
+			end
+		end
+	end
+	self:RenderCombat()
+	self:CheckCombatEnd()
+end`),
    method('GetHandSlotX', `local n = 0
 if self.Hand ~= nil then
 	n = #self.Hand
@@ -311,6 +347,17 @@ end
 if c.damagePerCardDrawnThisCombat ~= nil then
 	base2 = base2 + (self.CardsDrawnThisCombat or 0) * c.damagePerCardDrawnThisCombat
 end
+if c.kind == "Attack" and (self.TurnCardsPlayedThisTurn or 0) == 0 and c.firstCardDamageBonus ~= nil then
+	base2 = base2 + c.firstCardDamageBonus
+end
+if c.class == "shiv" then
+	if self:HasPowerField("shivDamageBonus") == true then
+		base2 = base2 + self:AddPowerFieldTotal("shivDamageBonus")
+	end
+	if self.ShivFirstDamageBonusUsed ~= true and self:HasPowerField("firstShivDamageBonus") == true then
+		base2 = base2 + self:AddPowerFieldTotal("firstShivDamageBonus")
+	end
+end
 if base2 < 0 then
 	base2 = 0
 end
@@ -382,6 +429,9 @@ end
 if c.nextSkillCostZero == true then
 	self.NextSkillCostZero = true
 end
+if c.nextSkillRepeatCount ~= nil and c.nextSkillRepeatCount > 0 then
+	self.NextSkillRepeatCount = (self.NextSkillRepeatCount or 0) + c.nextSkillRepeatCount
+end
 if c.skillCostReductionThisTurn ~= nil and c.skillCostReductionThisTurn > 0 then
 	self.SkillCostReductionThisTurn = (self.SkillCostReductionThisTurn or 0) + c.skillCostReductionThisTurn
 end
@@ -391,6 +441,42 @@ end
 if c.drawDisabledThisTurn == true then
 	self.DrawDisabledThisTurn = true
 end
+if c.drawDamage ~= nil and c.drawDamage > 0 and c.kind ~= "Power" then
+	self.DrawDamageThisTurn = (self.DrawDamageThisTurn or 0) + c.drawDamage
+end
+if c.drawPoison ~= nil and c.drawPoison > 0 and c.kind ~= "Power" then
+	self.DrawPoisonThisTurn = (self.DrawPoisonThisTurn or 0) + c.drawPoison
+end
+if c.shivAoe == true and c.kind ~= "Power" then
+	self.ShivAoeThisCombat = true
+end
+if c.skillSlyOnPlay == true and c.kind == "Skill" then
+	if self.SkillSlyOnPlayCards == nil then
+		self.SkillSlyOnPlayCards = {}
+	end
+	self.SkillSlyOnPlayCards[cardId] = true
+end
+if c.turnHandSlyCount ~= nil and c.turnHandSlyCount > 0 then
+	if self.TurnSkillSlyCards == nil then
+		self.TurnSkillSlyCards = {}
+	end
+	local picked = 0
+	if self.Hand ~= nil then
+		for i = 1, #self.Hand do
+			local hid = self.Hand[i]
+			if hid ~= nil and hid ~= cardId then
+				local hc = self.Cards[hid]
+				if hc ~= nil and hc.kind == "Skill" and self.TurnSkillSlyCards[hid] ~= true and self.SkillSlyOnPlayCards[hid] ~= true and hc.sly ~= true then
+					self.TurnSkillSlyCards[hid] = true
+					picked = picked + 1
+					if picked >= c.turnHandSlyCount then
+						break
+					end
+				end
+			end
+		end
+	end
+end
 local xEnergy = energySpent or 0
 local weakAmount = c.weak or 0
 local vulnAmount = c.vuln or 0
@@ -402,6 +488,7 @@ if c.kind == "Attack" then
 	if c.damage ~= nil or c.xDamagePerEnergy ~= nil then
 		self:PlayerAttackMotion()
 		local baseDmg = self:AttackBaseForCard(slot, c)
+		self.ActiveAttackDamageVsWeakMultiplier = c.attackDamageVsWeakMultiplier or 1
 		if c.xDamagePerEnergy ~= nil and c.xDamagePerEnergy > 0 then
 			baseDmg = xEnergy * c.xDamagePerEnergy
 		end
@@ -420,11 +507,67 @@ if c.kind == "Attack" then
 		for h = 1, hitN do
 			total = total + self:CalcPlayerAttack(baseDmg)
 		end
-		if c.aoe == true then
-			self:PlayAoeFx(c.fx or c.image, total)
-		else
-			self:PlayAttackFx(self.TargetIndex, c.fx or c.image, total, c.pierce == true)
+		local useAoe = c.aoe == true
+		if c.class == "shiv" and (self.ShivAoeThisCombat == true or self:HasPowerField("shivAoe") == true) then
+			useAoe = true
 		end
+		if c.class == "shiv" and self.ShivFirstDamageBonusUsed ~= true and self:HasPowerField("firstShivDamageBonus") == true then
+			self.ShivFirstDamageBonusUsed = true
+		end
+		local function countAliveMonsters()
+			local n = 0
+			if self.Monsters ~= nil then
+				for mi = 1, #self.Monsters do
+					local om = self.Monsters[mi]
+					if om ~= nil and om.alive == true then n = n + 1 end
+				end
+			end
+			return n
+		end
+		local function randomAliveMonsterIndex()
+			local alive = {}
+			if self.Monsters ~= nil then
+				for mi = 1, #self.Monsters do
+					local om = self.Monsters[mi]
+					if om ~= nil and om.alive == true then
+						table.insert(alive, mi)
+					end
+				end
+			end
+			if #alive <= 0 then
+				return 0
+			end
+			return alive[math.random(1, #alive)]
+		end
+		local function resolveAttackRound()
+			local roundKilled = false
+			if useAoe == true then
+				local killed = self:DealDamageToAllMonsters(total, true)
+				if killed == true then roundKilled = true end
+			elseif c.randomTargetEachHit == true then
+				for h = 1, hitN do
+					local targetIdx = randomAliveMonsterIndex()
+					if targetIdx ~= nil and targetIdx > 0 then
+						local prev = self.TargetIndex
+						self.TargetIndex = targetIdx
+						local killed = self:DealDamageToTarget(total / hitN, c.pierce == true)
+						self.TargetIndex = prev
+						if killed == true then roundKilled = true end
+					end
+				end
+			else
+				local killed = self:DealDamageToTarget(total, c.pierce == true)
+				if killed == true then roundKilled = true end
+			end
+			return roundKilled
+		end
+		local totalDamage = 0
+		local roundKilled = false
+		repeat
+			roundKilled = resolveAttackRound()
+			totalDamage = totalDamage + total
+		until c.repeatOnKill ~= true or roundKilled ~= true or countAliveMonsters() <= 0
+		self.DamageDealtThisTurn = (self.DamageDealtThisTurn or 0) + totalDamage
 	end
 	if c.block ~= nil then
 		self:AddCardBlock(c.block)
@@ -459,21 +602,89 @@ end
 if c.gainEnergy ~= nil and c.gainEnergy ~= 0 then
 	self.Energy = self.Energy + c.gainEnergy
 end
+if c.intangible ~= nil and c.intangible > 0 then
+	self.PlayerIntangible = (self.PlayerIntangible or 0) + c.intangible
+end
+self.TurnCardsPlayedThisTurn = (self.TurnCardsPlayedThisTurn or 0) + 1
+if c.blockPerDamageDealtThisTurn ~= nil and c.blockPerDamageDealtThisTurn > 0 then
+	self:AddCardBlock((self.DamageDealtThisTurn or 0) * c.blockPerDamageDealtThisTurn)
+end
 self:QueueNextTurnEffects(c)
-if c.weak ~= nil or c.vuln ~= nil or c.poison ~= nil or c.xWeakPerEnergy ~= nil then
+if c.combatCostReductionOnPlay ~= nil and c.combatCostReductionOnPlay > 0 then
+	if self.CombatCardCostReduction == nil then
+		self.CombatCardCostReduction = {}
+	end
+	self.CombatCardCostReduction[cardId] = (self.CombatCardCostReduction[cardId] or 0) + c.combatCostReductionOnPlay
+end
+if c.weak ~= nil or c.vuln ~= nil or c.poison ~= nil or c.xWeakPerEnergy ~= nil or c.affectsAllEnemies == true or c.removeEnemyBlock == true or c.removeEnemyArtifact == true or (c.enemyStrengthLossThisTurn ~= nil and c.enemyStrengthLossThisTurn > 0) then
 	local tm = self.Monsters[self.TargetIndex]
 	if tm == nil or tm.alive ~= true then
 		for i = 1, #self.Monsters do
 			if self.Monsters[i].alive == true then tm = self.Monsters[i]; self.TargetIndex = i; break end
 		end
 	end
-	if tm ~= nil and tm.alive == true then
-		if weakAmount ~= nil and weakAmount > 0 then tm.weak = tm.weak + weakAmount end
-		if poisonAmount ~= nil and poisonAmount > 0 then tm.poison = (tm.poison or 0) + poisonAmount end
-		if vulnAmount ~= nil and vulnAmount > 0 then
-			tm.vuln = tm.vuln + vulnAmount
-			if self:HasRelic("championBelt") then
-				tm.weak = tm.weak + 1
+	local targets = {}
+	if c.affectsAllEnemies == true and self.Monsters ~= nil then
+		for mi = 1, #self.Monsters do
+			local om = self.Monsters[mi]
+			if om ~= nil and om.alive == true then
+				table.insert(targets, om)
+			end
+		end
+	elseif tm ~= nil and tm.alive == true then
+		table.insert(targets, tm)
+	end
+	if c.enemyStrengthLossThisTurn ~= nil and c.enemyStrengthLossThisTurn > 0 then
+		self.EnemyStrengthLossThisTurn = (self.EnemyStrengthLossThisTurn or 0) + c.enemyStrengthLossThisTurn
+	end
+	for ti = 1, #targets do
+		local target = targets[ti]
+		if target ~= nil and target.alive == true then
+			if c.removeEnemyBlock == true then
+				target.block = 0
+			end
+			if c.removeEnemyArtifact == true then
+				target.artifact = 0
+			end
+			if weakAmount ~= nil and weakAmount > 0 then
+				if target.artifact ~= nil and target.artifact > 0 then
+					target.artifact = target.artifact - 1
+				else
+					target.weak = target.weak + weakAmount
+				end
+			end
+			if poisonAmount ~= nil and poisonAmount > 0 then
+				if c.poisonIfTargetPoisoned ~= true or (target.poison ~= nil and target.poison > 0) then
+					local poisonHits = c.poisonHits or 1
+					for pi = 1, poisonHits do
+						local target2 = target
+						if c.poisonRandomTargets == true and self.Monsters ~= nil then
+							local alive = {}
+							for mi = 1, #self.Monsters do
+								local om = self.Monsters[mi]
+								if om ~= nil and om.alive == true then
+									table.insert(alive, om)
+								end
+							end
+							if #alive > 0 then
+								target2 = alive[math.random(#alive)]
+							end
+						end
+						if target2 ~= nil and target2.alive == true then
+							self:ApplyPoisonToMonster(target2, poisonAmount)
+						end
+					end
+				end
+			end
+			if vulnAmount ~= nil and vulnAmount > 0 then
+				if target.artifact ~= nil and target.artifact > 0 then
+					target.artifact = target.artifact - 1
+				else
+					target.vuln = target.vuln + vulnAmount
+					if self:HasRelic("championBelt") then
+						target.weak = target.weak + 1
+					end
+				end
 			end
 		end
 	end
@@ -516,9 +727,16 @@ end`, [
      { Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'energySpent' },
    ]),
    method('TriggerSly', `local c = self.Cards[cardId]
-if c == nil or c.sly ~= true then
+if c == nil then
 	return
 end
+if c.sly ~= true then
+	local onPlay = self.SkillSlyOnPlayCards ~= nil and self.SkillSlyOnPlayCards[cardId] == true
+	local tempSly = self.TurnSkillSlyCards ~= nil and self.TurnSkillSlyCards[cardId] == true
+	if onPlay ~= true and tempSly ~= true then
+		return
+	end
+end
 self:Toast("교활 발동: " .. c.name)
 self:ResolveCardEffects(cardId, 0, c, true, 0)`, [{ Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'cardId' }]),
    method('DiscardHandCard', `if self.Hand == nil then
--- a/tools/deck/cb/jobs.mjs
+++ b/tools/deck/cb/jobs.mjs
@@ -1,9 +1,50 @@
-import { method, RUN_LENGTH, GOLD_PER_WIN, CARD_PRICE, REST_HEAL, RELIC_PRICE, ACT_COUNT, ACT_MAPS, LOBBY_MAP, LOBBY_SPAWN } from '../lib/codeblock.mjs';
-import { CARDS, ENEMIES, CLASSES, JOBS, SOUL_UNLOCKS, CARDFRAMES, RARITIES, MAP_ROWS, MAP_COLS, CHEST_CLOSED_RUID, CHEST_OPEN_RUID, NODEICONS, CHARS, CAM, RELICS, POTIONS, luaSoulShopTable, frameRuid, luaFramesTable, luaNodeIconsTable, luaRelicsTable, luaPotionsTable, luaIntentsArray, luaEnemiesTable, luaStr, luaJobsTable, luaCardsTable, luaDeckTable } from '../lib/data.mjs';
-import { UI_FILE, COMMON_FILE, UI_ROOT, GENERATED_UI_SECTIONS, UI_APPEND_ORDER, DISABLED_STOCK_CONTROLS, TRANSPARENT, DARK, GOLD, ATTACK, DEFEND, SKILL, DAMAGE_DIGIT_RUIDS, DAMAGE_POP_MAX_DIGITS, DAMAGE_POP_DIGIT_W, DAMAGE_POP_DIGIT_H, DAMAGE_POP_DIGIT_SPACING, MAX_MONSTERS, HEAD_OFFSET_Y, HP_BAR_W, WHITE, CARD_NAME_TEXT, CARD_DESC_TEXT, cardFaceLayout, CARD_W, CARD_H, CARD_SPACING, CARD_XS, ALIGN_CENTER, ALIGN_BOTTOM_CENTER, guid, transform, sprite, button, text, scrollLayoutGroup, popupLayerFor, uiOrderFor, displayOrderFor, applySortingOverride, entity, uiPath, sectionRoot, isGeneratedUiEntity, appendUiSection } from '../lib/ui-helpers.mjs';
+import { method } from '../lib/codeblock.mjs';

 export const jobMethods = [
-    method('ShowJobChoice', `self:SetEntityEnabled("/ui/RunUIGroup/CardHand", false)
+    method('BaseClassLabel', `if classId == "warrior" then
+	return "전사"
+elseif classId == "rogue" then
+	return "Rogue"
+elseif classId == "magician" then
+	return "마법사"
+end
+return "플레이어"`, [{ Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'classId' }], 0, 'string'),
+    method('CurrentClassId', `if self.PlayerJob ~= nil and self.PlayerJob ~= "" then
+	return self.PlayerJob
+end
+return self.SelectedClass or ""`, [], 0, 'string'),
+    method('GetPlayableClasses', `local current = self:CurrentClassId()
+if current == nil or current == "" then
+	return {}
+end
+if self.ClassLineages ~= nil and self.ClassLineages[current] ~= nil then
+	return self.ClassLineages[current]
+end
+return { current }`, [], 0, 'any'),
+    method('CanUseClassCard', `if cardClass == nil or cardClass == "" then
+	return false
+end
+if cardClass == "curse" then
+	return true
+end
+local playable = self:GetPlayableClasses()
+for i = 1, #playable do
+	if playable[i] == cardClass then
+		return true
+	end
+end
+return false`, [{ Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'cardClass' }], 0, 'boolean'),
+    method('CanAdvanceJob', `local current = self:CurrentClassId()
+if current == nil or current == "" or self.Jobs == nil then
+	return false
+end
+local opts = self.Jobs[current]
+return opts ~= nil and #opts > 0`, [], 0, 'boolean'),
+    method('ShowJobChoice', `if self:CanAdvanceJob() ~= true then
+	self:ContinueAfterBoss()
+	return
+end
+self:SetEntityEnabled("/ui/RunUIGroup/CardHand", false)
 self:SetEntityEnabled("/ui/RunUIGroup/DeckHud", false)
 self:SetEntityEnabled("/ui/SelectUIGroup/JobChoiceHud", true)`),
    method('PickJobReward', `self:SetEntityEnabled("/ui/SelectUIGroup/JobChoiceHud", false)
@@ -20,9 +61,13 @@ if kind == "relic" then
 else
 	self:ShowJobSelect()
 end`, [{ Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'kind' }]),
-    method('ShowJobSelect', `local opts = self.Jobs[self.SelectedClass]
+    method('ShowJobSelect', `local current = self:CurrentClassId()
+local opts = nil
+if self.Jobs ~= nil then
+	opts = self.Jobs[current]
+end
 if opts == nil then
-	opts = self.Jobs["warrior"]
+	opts = {}
 end
 self.JobOpts = opts
 for i = 1, 3 do
@@ -41,36 +86,30 @@ for i = 1, 3 do
 	end
 end
 self:SetEntityEnabled("/ui/SelectUIGroup/JobSelectHud", true)`),
-    method('JobLabel', `if self.PlayerJob ~= "" and self.Jobs ~= nil then
-	for cls, list in pairs(self.Jobs) do
-		for i = 1, #list do
-			if list[i].id == self.PlayerJob then
-				return list[i].name
-			end
-		end
-	end
+    method('JobLabel', `if self.PlayerJob ~= "" and self.JobMeta ~= nil and self.JobMeta[self.PlayerJob] ~= nil then
+	return self.JobMeta[self.PlayerJob].name
 end
-if self.SelectedClass == "warrior" then
-	return "전사"
-elseif self.SelectedClass == "bandit" then
-	return "도적"
-elseif self.SelectedClass == "magician" then
-	return "마법사"
-end
-return "플레이어"`, [], 0, 'string'),
-    method('SetJob', `self.PlayerJob = jobId
+return self:BaseClassLabel(self.SelectedClass)`, [], 0, 'string'),
+    method('SetJob', `local current = self:CurrentClassId()
 local starter = ""
-local opts = self.Jobs[self.SelectedClass] or {}
+local tier = 2
+local opts = {}
+if self.Jobs ~= nil and self.Jobs[current] ~= nil then
+	opts = self.Jobs[current]
+end
 for i = 1, #opts do
 	if opts[i].id == jobId then
-		starter = opts[i].starter
+		starter = opts[i].starter or ""
+		tier = opts[i].tier or 2
+		break
 	end
 end
+self.PlayerJob = jobId
 if starter ~= "" then
 	table.insert(self.RunDeck, starter)
 	local sc = self.Cards[starter]
 	if sc ~= nil then
-		self:Toast("2차 전직: " .. self:JobLabel() .. "! 신규 카드 — " .. sc.name)
+		self:Toast(tostring(tier) .. "차 전직: " .. self:JobLabel() .. "! 신규 카드 - " .. sc.name)
 	end
 end
 self:SetText("/ui/RunUIGroup/CombatHud/PlayerPanel/Name", self:JobLabel())
--- a/tools/deck/cb/layout.mjs
+++ b/tools/deck/cb/layout.mjs
@@ -0,0 +1,21 @@
+import { method, RUN_LENGTH, GOLD_PER_WIN, CARD_PRICE, REST_HEAL, RELIC_PRICE, ACT_COUNT, ACT_MAPS, LOBBY_MAP, LOBBY_SPAWN } from '../lib/codeblock.mjs';
+import { CARDS, ENEMIES, CLASSES, JOBS, SOUL_UNLOCKS, CARDFRAMES, RARITIES, MAP_ROWS, MAP_COLS, CHEST_CLOSED_RUID, CHEST_OPEN_RUID, NODEICONS, CHARS, CAM, RELICS, POTIONS, luaSoulShopTable, frameRuid, luaFramesTable, luaNodeIconsTable, luaRelicsTable, luaPotionsTable, luaIntentsArray, luaEnemiesTable, luaStr, luaJobsTable, luaCardsTable, luaDeckTable } from '../lib/data.mjs';
+import { UI_FILE, COMMON_FILE, UI_ROOT, GENERATED_UI_SECTIONS, UI_APPEND_ORDER, DISABLED_STOCK_CONTROLS, TRANSPARENT, DARK, GOLD, ATTACK, DEFEND, SKILL, DAMAGE_DIGIT_RUIDS, DAMAGE_POP_MAX_DIGITS, DAMAGE_POP_DIGIT_W, DAMAGE_POP_DIGIT_H, DAMAGE_POP_DIGIT_SPACING, MAX_MONSTERS, HEAD_OFFSET_Y, HP_BAR_W, WHITE, CARD_NAME_TEXT, CARD_DESC_TEXT, cardFaceLayout, CARD_W, CARD_H, CARD_SPACING, CARD_XS, ALIGN_CENTER, ALIGN_BOTTOM_CENTER, guid, transform, sprite, button, text, scrollLayoutGroup, popupLayerFor, uiOrderFor, displayOrderFor, applySortingOverride, entity, uiPath, sectionRoot, isGeneratedUiEntity, appendUiSection } from '../lib/ui-helpers.mjs';
+
+export const layoutMethods = [
+    method('PositionMonsterSlot', `local monster = self.Monsters[slot]
+if monster == nil or monster.entity == nil or not isvalid(monster.entity) then
+	return
+end
+local transform = monster.entity.TransformComponent
+if transform == nil then
+	return
+end
+local worldPos = transform.WorldPosition
+local screen = _UILogic:WorldToScreenPosition(Vector2(worldPos.x, worldPos.y + ${HEAD_OFFSET_Y}))
+local uipos = _UILogic:ScreenToUIPosition(screen)
+local slotEntity = _EntityService:GetEntityByPath("/ui/RunUIGroup/CombatHud/MonsterStatus" .. tostring(slot))
+if slotEntity ~= nil and slotEntity.UITransformComponent ~= nil then
+	slotEntity.UITransformComponent.anchoredPosition = uipos
+end`, [{ Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'slot' }]),
+];
--- a/tools/deck/cb/navigation.mjs
+++ b/tools/deck/cb/navigation.mjs
@@ -0,0 +1,34 @@
+import { method, RUN_LENGTH, GOLD_PER_WIN, CARD_PRICE, REST_HEAL, RELIC_PRICE, ACT_COUNT, ACT_MAPS, LOBBY_MAP, LOBBY_SPAWN } from '../lib/codeblock.mjs';
+import { CARDS, ENEMIES, CLASSES, JOBS, SOUL_UNLOCKS, CARDFRAMES, RARITIES, MAP_ROWS, MAP_COLS, CHEST_CLOSED_RUID, CHEST_OPEN_RUID, NODEICONS, CHARS, CAM, RELICS, POTIONS, luaSoulShopTable, frameRuid, luaFramesTable, luaNodeIconsTable, luaRelicsTable, luaPotionsTable, luaIntentsArray, luaEnemiesTable, luaStr, luaJobsTable, luaCardsTable, luaDeckTable } from '../lib/data.mjs';
+import { UI_FILE, COMMON_FILE, UI_ROOT, GENERATED_UI_SECTIONS, UI_APPEND_ORDER, DISABLED_STOCK_CONTROLS, TRANSPARENT, DARK, GOLD, ATTACK, DEFEND, SKILL, DAMAGE_DIGIT_RUIDS, DAMAGE_POP_MAX_DIGITS, DAMAGE_POP_DIGIT_W, DAMAGE_POP_DIGIT_H, DAMAGE_POP_DIGIT_SPACING, MAX_MONSTERS, HEAD_OFFSET_Y, HP_BAR_W, WHITE, CARD_NAME_TEXT, CARD_DESC_TEXT, cardFaceLayout, CARD_W, CARD_H, CARD_SPACING, CARD_XS, ALIGN_CENTER, ALIGN_BOTTOM_CENTER, guid, transform, sprite, button, text, scrollLayoutGroup, popupLayerFor, uiOrderFor, displayOrderFor, applySortingOverride, entity, uiPath, sectionRoot, isGeneratedUiEntity, appendUiSection } from '../lib/ui-helpers.mjs';
+
+export const navigationMethods = [
+    method('GoLobbyMap', `self.LobbyTpTries = 0
+local eventId = 0
+local function tryTeleport()
+	self.LobbyTpTries = self.LobbyTpTries + 1
+	local localPlayer = _UserService.LocalPlayer
+	if localPlayer ~= nil then
+		if localPlayer.CurrentMapName ~= "${LOBBY_MAP}" then
+			_TeleportService:TeleportToMapPosition(localPlayer, ${LOBBY_SPAWN}, "${LOBBY_MAP}")
+		end
+		_TimerService:ClearTimer(eventId)
+	elseif self.LobbyTpTries > 50 then
+		_TimerService:ClearTimer(eventId)
+	end
+end
+eventId = _TimerService:SetTimerRepeat(tryTeleport, 0.1)`),
+    method('TeleportToActMap', `local maps = { ${ACT_MAPS.map((mapName) => `"${mapName}"`).join(', ')} }
+local target = maps[self.Floor]
+if target == nil then
+	return
+end
+local localPlayer = _UserService.LocalPlayer
+if localPlayer == nil then
+	return
+end
+if localPlayer.CurrentMapName == target then
+	return
+end
+_TeleportService:TeleportToMapPosition(localPlayer, Vector3(-6, 0.03, 0), target)`),
+];
--- a/tools/deck/cb/npc.mjs
+++ b/tools/deck/cb/npc.mjs
@@ -0,0 +1,18 @@
+import { method, RUN_LENGTH, GOLD_PER_WIN, CARD_PRICE, REST_HEAL, RELIC_PRICE, ACT_COUNT, ACT_MAPS, LOBBY_MAP, LOBBY_SPAWN } from '../lib/codeblock.mjs';
+import { CARDS, ENEMIES, CLASSES, JOBS, SOUL_UNLOCKS, CARDFRAMES, RARITIES, MAP_ROWS, MAP_COLS, CHEST_CLOSED_RUID, CHEST_OPEN_RUID, NODEICONS, CHARS, CAM, RELICS, POTIONS, luaSoulShopTable, frameRuid, luaFramesTable, luaNodeIconsTable, luaRelicsTable, luaPotionsTable, luaIntentsArray, luaEnemiesTable, luaStr, luaJobsTable, luaCardsTable, luaDeckTable } from '../lib/data.mjs';
+import { UI_FILE, COMMON_FILE, UI_ROOT, GENERATED_UI_SECTIONS, UI_APPEND_ORDER, DISABLED_STOCK_CONTROLS, TRANSPARENT, DARK, GOLD, ATTACK, DEFEND, SKILL, DAMAGE_DIGIT_RUIDS, DAMAGE_POP_MAX_DIGITS, DAMAGE_POP_DIGIT_W, DAMAGE_POP_DIGIT_H, DAMAGE_POP_DIGIT_SPACING, MAX_MONSTERS, HEAD_OFFSET_Y, HP_BAR_W, WHITE, CARD_NAME_TEXT, CARD_DESC_TEXT, cardFaceLayout, CARD_W, CARD_H, CARD_SPACING, CARD_XS, ALIGN_CENTER, ALIGN_BOTTOM_CENTER, guid, transform, sprite, button, text, scrollLayoutGroup, popupLayerFor, uiOrderFor, displayOrderFor, applySortingOverride, entity, uiPath, sectionRoot, isGeneratedUiEntity, appendUiSection } from '../lib/ui-helpers.mjs';
+
+export const npcMethods = [
+    method('OnLobbyNpcInteract', `if self.RunActive == true then
+	return
+end
+if id == "run" then
+	self:ShowCharacterSelect()
+elseif id == "codex" then
+	self:ShowCodex()
+elseif id == "shop" then
+	self:ShowSoulShop()
+elseif id == "board" then
+	self:ShowBoard()
+end`, [{ Type: 'string', DefaultValue: '""', SyncDirection: 0, Attributes: [], Name: 'id' }]),
+];
--- a/tools/deck/cb/render.mjs
+++ b/tools/deck/cb/render.mjs
@@ -68,6 +68,10 @@ self:SetHpBar("/ui/RunUIGroup/CombatHud/PlayerPanel/HpBarFill", self.PlayerHp, s
 self:SetEntityEnabled("/ui/RunUIGroup/CombatHud/PlayerPanel/BlockBadge", self.PlayerBlock > 0)
 self:SetText("/ui/RunUIGroup/CombatHud/PlayerPanel/BlockBadge/Value", string.format("%d", self.PlayerBlock))
 local pb = self:BuffsLabel(self.PlayerStr, self.PlayerWeak, self.PlayerVuln, 0)
+if self.PlayerIntangible ~= nil and self.PlayerIntangible > 0 then
+	if pb ~= "" then pb = pb .. " " end
+	pb = pb .. "불가침" .. tostring(self.PlayerIntangible)
+end
 if self.PlayerDex ~= nil and self.PlayerDex > 0 then
 	if pb ~= "" then pb = pb .. " " end
 	pb = pb .. "민첩+" .. tostring(self.PlayerDex)
@@ -279,21 +283,6 @@ e.UITransformComponent.RectSize = Vector2(w, 14)`, [
      { Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'maxHp' },
      { Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'width' },
    ]),
-    method('PositionMonsterSlot', `local m = self.Monsters[slot]
-if m == nil or m.entity == nil or not isvalid(m.entity) then
-	return
-end
-local tr = m.entity.TransformComponent
-if tr == nil then
-	return
-end
-local wp = tr.WorldPosition
-local screen = _UILogic:WorldToScreenPosition(Vector2(wp.x, wp.y + ${HEAD_OFFSET_Y}))
-local uipos = _UILogic:ScreenToUIPosition(screen)
-local e = _EntityService:GetEntityByPath("/ui/RunUIGroup/CombatHud/MonsterStatus" .. tostring(slot))
-if e ~= nil and e.UITransformComponent ~= nil then
-	e.UITransformComponent.anchoredPosition = uipos
-end`, [{ Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'slot' }]),
    method('SetTarget', `if self.Monsters[slot] ~= nil and self.Monsters[slot].alive == true then
 	self.TargetIndex = slot
 	self:RenderCombat()
--- a/tools/deck/cb/reward.mjs
+++ b/tools/deck/cb/reward.mjs
@@ -5,7 +5,7 @@ import { UI_FILE, COMMON_FILE, UI_ROOT, GENERATED_UI_SECTIONS, UI_APPEND_ORDER,
 export const rewardMethods = [
    method('CardPool', `local pool = {}
 for id, c in pairs(self.Cards) do
-	if c.token ~= true and (c.class == self.SelectedClass or (self.PlayerJob ~= "" and c.class == self.PlayerJob)) then
+	if c.token ~= true and self:CanUseClassCard(c.class) == true then
 		table.insert(pool, id)
 	end
 end
@@ -38,7 +38,7 @@ end`),
      { Type: 'number', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'slot' },
      { Type: 'string', DefaultValue: null, SyncDirection: 0, Attributes: [], Name: 'cardId' },
    ]),
-    method('PickReward', `if self.CombatOver ~= true or self.RunActive ~= true then
+method('PickReward', `if self.CombatOver ~= true or self.RunActive ~= true then
 	return
 end
 if slot ~= 0 and self.RewardChoices ~= nil then
@@ -47,6 +47,11 @@ if slot ~= 0 and self.RewardChoices ~= nil then
 		table.insert(self.RunDeck, id)
 	end
 end
+if self.BonusRewardScreens ~= nil and self.BonusRewardScreens > 0 and slot ~= 0 then
+	self.BonusRewardScreens = self.BonusRewardScreens - 1
+	self:OfferReward()
+	return
+end
 local hud = _EntityService:GetEntityByPath("/ui/RunUIGroup/RewardHud")
 if hud ~= nil then
 	hud.Enable = false
--- a/tools/deck/cb/run.mjs
+++ b/tools/deck/cb/run.mjs
@@ -1,14 +1,14 @@
 import { method, RUN_LENGTH, GOLD_PER_WIN, CARD_PRICE, REST_HEAL, RELIC_PRICE, ACT_COUNT, ACT_MAPS, LOBBY_MAP, LOBBY_SPAWN } from '../lib/codeblock.mjs';
-import { CARDS, ENEMIES, CLASSES, JOBS, SOUL_UNLOCKS, CARDFRAMES, RARITIES, MAP_ROWS, MAP_COLS, CHEST_CLOSED_RUID, CHEST_OPEN_RUID, NODEICONS, CHARS, CAM, RELICS, POTIONS, luaSoulShopTable, frameRuid, luaFramesTable, luaNodeIconsTable, luaCharsTable, luaRelicsTable, luaPotionsTable, luaIntentsArray, luaEnemiesTable, luaStr, luaJobsTable, luaCardsTable, luaDeckTable } from '../lib/data.mjs';
+import { CARDS, ENEMIES, CLASSES, JOBS, JOB_META, CLASS_GROUPS, CLASS_LINEAGES, SOUL_UNLOCKS, CARDFRAMES, RARITIES, MAP_ROWS, MAP_COLS, CHEST_CLOSED_RUID, CHEST_OPEN_RUID, NODEICONS, CHARS, CAM, RELICS, POTIONS, luaSoulShopTable, frameRuid, luaFramesTable, luaNodeIconsTable, luaCharsTable, luaRelicsTable, luaPotionsTable, luaIntentsArray, luaEnemiesTable, luaStr, luaJobsTable, luaClassGroupsTable, luaClassLineagesTable, luaJobMetaTable, luaCardsTable, luaDeckTable } from '../lib/data.mjs';
 import { UI_FILE, COMMON_FILE, UI_ROOT, GENERATED_UI_SECTIONS, UI_APPEND_ORDER, DISABLED_STOCK_CONTROLS, TRANSPARENT, DARK, GOLD, ATTACK, DEFEND, SKILL, DAMAGE_DIGIT_RUIDS, DAMAGE_POP_MAX_DIGITS, DAMAGE_POP_DIGIT_W, DAMAGE_POP_DIGIT_H, DAMAGE_POP_DIGIT_SPACING, MAX_MONSTERS, HEAD_OFFSET_Y, HP_BAR_W, WHITE, CARD_NAME_TEXT, CARD_DESC_TEXT, cardFaceLayout, CARD_W, CARD_H, CARD_SPACING, CARD_XS, ALIGN_CENTER, ALIGN_BOTTOM_CENTER, guid, transform, sprite, button, text, scrollLayoutGroup, popupLayerFor, uiOrderFor, displayOrderFor, applySortingOverride, entity, uiPath, sectionRoot, isGeneratedUiEntity, appendUiSection } from '../lib/ui-helpers.mjs';

 export const runMethods = [
    method('StartRun', `if self.SelectedClass == "magician" then
 	self.PlayerMaxHp = ${CLASSES.magician.maxHp}
 self.RunDeck = { ${CARDS.starterDecks.magician.map(luaStr).join(', ')} }
-elseif self.SelectedClass == "bandit" then
-	self.PlayerMaxHp = ${CLASSES.bandit.maxHp}
-	self.RunDeck = { ${CARDS.starterDecks.bandit.map(luaStr).join(', ')} }
+elseif self.SelectedClass == "rogue" then
+	self.PlayerMaxHp = ${CLASSES.rogue.maxHp}
+	self.RunDeck = { ${CARDS.starterDecks.rogue.map(luaStr).join(', ')} }
 else
 	self.PlayerMaxHp = ${CLASSES.warrior.maxHp}
 	self.RunDeck = { ${CARDS.starterDecks.warrior.map(luaStr).join(', ')} }
@@ -30,6 +30,9 @@ self.CurrentNodeId = ""
 self.CurrentEnemyId = ""
 self.PlayerJob = ""
 ${luaJobsTable(JOBS)}
+${luaJobMetaTable(JOB_META)}
+${luaClassGroupsTable(CLASS_GROUPS)}
+${luaClassLineagesTable(CLASS_LINEAGES)}
 ${luaFramesTable()}
 ${luaNodeIconsTable()}
 ${luaCharsTable()}
@@ -72,16 +75,32 @@ self.CardsDrawnThisCombat = 0
 self.HandCostZeroThisTurn = false
 self.DrawDisabledThisTurn = false
 self.NextSkillCostZero = false
+self.NextSkillRepeatCount = 0
 self.SkillCostReductionThisTurn = 0
+self.CombatCardCostReduction = {}
+self.SkillSlyOnPlayCards = {}
+self.TurnSkillSlyCards = {}
+self.ShivFirstDamageBonusUsed = false
+self.ActiveAttackDamageVsWeakMultiplier = 1
+self.DrawDamageThisTurn = 0
+self.DrawPoisonThisTurn = 0
+self.ShivAoeThisCombat = false
+self.PoisonApplicationsThisCombat = 0
+self.EnemyStrengthLossThisTurn = 0
 self.PlayerStr = 0
 self.PlayerDex = 0
 self.PlayerThorns = 0
 self.PlayerWeak = 0
 self.PlayerVuln = 0
+self.PlayerIntangible = 0
+self.BonusRewardScreens = 0
+self.ActiveKillReward = 0
 self.PlayerPowers = {}
 self.FightAttackCount = 0
 self.TurnAttackCardsPlayed = 0
 self.TurnDiscardedCards = 0
+self.TurnCardsPlayedThisTurn = 0
+self.DamageDealtThisTurn = 0
 self.DmgPopSeq = 0
 self.FirstHpLossDone = false
 self.ClayBlockNext = 0
@@ -224,7 +243,7 @@ for i = 1, n do
 	local startIdx = 1
 	if #intents > 0 then startIdx = math.random(1, #intents) end
 	self.Monsters[i] = { entity = item.entity, enemyId = item.enemyId, name = e.name,
-		hp = maxHp, maxHp = maxHp, block = 0, str = 0, weak = 0, vuln = 0, poison = 0,
+		hp = maxHp, maxHp = maxHp, block = 0, str = e.str or 0, weak = 0, vuln = 0, poison = 0, artifact = e.artifact or 0,
 		hitClip = hitClip, standClip = standClip, motionBusy = false,
 		intents = intents, intentIdx = startIdx, alive = true, slot = i }
 	self:ReviveMonsterEntity(item.entity)
--- a/tools/deck/cb/runend.mjs
+++ b/tools/deck/cb/runend.mjs
@@ -3,19 +3,6 @@ import { CARDS, ENEMIES, CLASSES, JOBS, SOUL_UNLOCKS, CARDFRAMES, RARITIES, MAP_
 import { UI_FILE, COMMON_FILE, UI_ROOT, GENERATED_UI_SECTIONS, UI_APPEND_ORDER, DISABLED_STOCK_CONTROLS, TRANSPARENT, DARK, GOLD, ATTACK, DEFEND, SKILL, DAMAGE_DIGIT_RUIDS, DAMAGE_POP_MAX_DIGITS, DAMAGE_POP_DIGIT_W, DAMAGE_POP_DIGIT_H, DAMAGE_POP_DIGIT_SPACING, MAX_MONSTERS, HEAD_OFFSET_Y, HP_BAR_W, WHITE, CARD_NAME_TEXT, CARD_DESC_TEXT, cardFaceLayout, CARD_W, CARD_H, CARD_SPACING, CARD_XS, ALIGN_CENTER, ALIGN_BOTTOM_CENTER, guid, transform, sprite, button, text, scrollLayoutGroup, popupLayerFor, uiOrderFor, displayOrderFor, applySortingOverride, entity, uiPath, sectionRoot, isGeneratedUiEntity, appendUiSection } from '../lib/ui-helpers.mjs';

 export const runEndMethods = [
-    method('TeleportToActMap', `local maps = { ${ACT_MAPS.map((m) => `"${m}"`).join(', ')} }
-local target = maps[self.Floor]
-if target == nil then
-	return
-end
-local lp = _UserService.LocalPlayer
-if lp == nil then
-	return
-end
-if lp.CurrentMapName == target then
-	return
-end
-_TeleportService:TeleportToMapPosition(lp, Vector3(-6, 0.03, 0), target)`),
    method('ShowResult', `self:SetText("/ui/RunUIGroup/CombatHud/Result", text)
 local entity = _EntityService:GetEntityByPath("/ui/RunUIGroup/CombatHud/Result")
 if entity ~= nil then
--- a/tools/deck/cb/screens.mjs
+++ b/tools/deck/cb/screens.mjs
@@ -2,7 +2,7 @@ import { method, RUN_LENGTH, GOLD_PER_WIN, CARD_PRICE, REST_HEAL, RELIC_PRICE, A
 import { CARDS, ENEMIES, CLASSES, JOBS, SOUL_UNLOCKS, CARDFRAMES, RARITIES, MAP_ROWS, MAP_COLS, CHEST_CLOSED_RUID, CHEST_OPEN_RUID, NODEICONS, CHARS, CAM, RELICS, POTIONS, luaSoulShopTable, frameRuid, luaFramesTable, luaNodeIconsTable, luaRelicsTable, luaPotionsTable, luaIntentsArray, luaEnemiesTable, luaStr, luaJobsTable, luaCardsTable, luaDeckTable } from '../lib/data.mjs';
 import { UI_FILE, COMMON_FILE, UI_ROOT, GENERATED_UI_SECTIONS, UI_APPEND_ORDER, DISABLED_STOCK_CONTROLS, TRANSPARENT, DARK, GOLD, ATTACK, DEFEND, SKILL, DAMAGE_DIGIT_RUIDS, DAMAGE_POP_MAX_DIGITS, DAMAGE_POP_DIGIT_W, DAMAGE_POP_DIGIT_H, DAMAGE_POP_DIGIT_SPACING, MAX_MONSTERS, HEAD_OFFSET_Y, HP_BAR_W, WHITE, CARD_NAME_TEXT, CARD_DESC_TEXT, cardFaceLayout, CARD_W, CARD_H, CARD_SPACING, CARD_XS, ALIGN_CENTER, ALIGN_BOTTOM_CENTER, guid, transform, sprite, button, text, scrollLayoutGroup, popupLayerFor, uiOrderFor, displayOrderFor, applySortingOverride, entity, uiPath, sectionRoot, isGeneratedUiEntity, appendUiSection } from '../lib/ui-helpers.mjs';

-export const stateMethods = [
+export const screensMethods = [
    method('HideGameHud', `self:SetEntityEnabled("/ui/DefaultGroup/Button_Attack", false)
 self:SetEntityEnabled("/ui/DefaultGroup/Button_Jump", false)
 self:SetEntityEnabled("/ui/DefaultGroup/UIJoystick", false)
@@ -21,14 +21,14 @@ self:SetEntityEnabled("/ui/DeckUIGroup/DeckAllHud", false)
 self:SetEntityEnabled("/ui/LobbyUIGroup/LobbyHud", false)
 self:SetEntityEnabled("/ui/LobbyUIGroup/BoardHud", false)
 self:SetEntityEnabled("/ui/LobbyUIGroup/SoulShopHud", false)`),
-    method('ActivateUIGroups', `local function grp(n)
-	local g = _EntityService:GetEntityByPath("/ui/" .. n)
-	if g ~= nil then g:SetEnable(true) end
+    method('ActivateUIGroups', `local function enableGroup(name)
+	local group = _EntityService:GetEntityByPath("/ui/" .. name)
+	if group ~= nil then group:SetEnable(true) end
 end
-grp("SelectUIGroup")
-grp("LobbyUIGroup")
-grp("RunUIGroup")
-grp("DeckUIGroup")`, [], 2),
+enableGroup("SelectUIGroup")
+enableGroup("LobbyUIGroup")
+enableGroup("RunUIGroup")
+enableGroup("DeckUIGroup")`, [], 2),
    method('ShowState', `self:HideGameHud()
 self:SetEntityEnabled("/ui/DefaultGroup/MainMenu", state == "menu")
 self:SetEntityEnabled("/ui/SelectUIGroup/CharacterSelectHud", state == "charselect")
@@ -75,7 +75,7 @@ if thief ~= nil and (thief.ButtonComponent ~= nil or thief:AddComponent("ButtonC
 		thief:DisconnectEvent(ButtonClickEvent, self.ThiefSelectHandler)
 		self.ThiefSelectHandler = nil
 	end
-	self.ThiefSelectHandler = thief:ConnectEvent(ButtonClickEvent, function() self:SelectClass("bandit") end)
+	self.ThiefSelectHandler = thief:ConnectEvent(ButtonClickEvent, function() self:SelectClass("rogue") end)
 end
 local mage = _EntityService:GetEntityByPath("/ui/SelectUIGroup/CharacterSelectHud/MageButton")
 if mage ~= nil and (mage.ButtonComponent ~= nil or mage:AddComponent("ButtonComponent") ~= nil) then
@@ -135,44 +135,17 @@ self:SetEntityEnabled("/ui/LobbyUIGroup/SoulShopHud", false)
 self:BindLobbyButtons()
 self:BindMenuButtons()
 self:GoLobbyMap()`),
-    method('GoLobbyMap', `self.LobbyTpTries = 0
-local eventId = 0
-local function go()
-	self.LobbyTpTries = self.LobbyTpTries + 1
-	local lp = _UserService.LocalPlayer
-	if lp ~= nil then
-		if lp.CurrentMapName ~= "${LOBBY_MAP}" then
-			_TeleportService:TeleportToMapPosition(lp, ${LOBBY_SPAWN}, "${LOBBY_MAP}")
-		end
-		_TimerService:ClearTimer(eventId)
-	elseif self.LobbyTpTries > 50 then
-		_TimerService:ClearTimer(eventId)
-	end
-end
-eventId = _TimerService:SetTimerRepeat(go, 0.1)`),
-    method('OnLobbyNpcInteract', `if self.RunActive == true then
-	return
-end
-if id == "run" then
-	self:ShowCharacterSelect()
-elseif id == "codex" then
-	self:ShowCodex()
-elseif id == "shop" then
-	self:ShowSoulShop()
-elseif id == "board" then
-	self:ShowBoard()
-end`, [{ Type: 'string', DefaultValue: '""', SyncDirection: 0, Attributes: [], Name: 'id' }]),
-    method('RenderSoulLabel', `local s = self.SoulPoints or 0
-self:SetText("/ui/LobbyUIGroup/LobbyHud/SoulLabel", "영혼 " .. string.format("%d", s))
-self:SetText("/ui/LobbyUIGroup/SoulShopHud/Souls", "영혼 " .. string.format("%d", s))`),
+    method('RenderSoulLabel', `local soulPoints = self.SoulPoints or 0
+self:SetText("/ui/LobbyUIGroup/LobbyHud/SoulLabel", "영혼 " .. string.format("%d", soulPoints))
+self:SetText("/ui/LobbyUIGroup/SoulShopHud/Souls", "영혼 " .. string.format("%d", soulPoints))`),
    method('BindLobbyButtons', `if self.LobbyBound == true then
 	return
 end
 self.LobbyBound = true
-local function bindClick(path, fn)
-	local e = _EntityService:GetEntityByPath(path)
-	if e ~= nil and (e.ButtonComponent ~= nil or e:AddComponent("ButtonComponent") ~= nil) then
-		e:ConnectEvent(ButtonClickEvent, fn)
+local function bindClick(path, handler)
+	local entity = _EntityService:GetEntityByPath(path)
+	if entity ~= nil and (entity.ButtonComponent ~= nil or entity:AddComponent("ButtonComponent") ~= nil) then
+		entity:ConnectEvent(ButtonClickEvent, handler)
 	end
 end
 bindClick("/ui/LobbyUIGroup/LobbyHud/AscMinus", function() self:AdjustAscension(-1) end)
--- a/tools/deck/cb/tooltip.mjs
+++ b/tools/deck/cb/tooltip.mjs
@@ -105,6 +105,9 @@ return out`, [{ Type: 'any', DefaultValue: null, SyncDirection: 0, Attributes: [
    method('HoverCard', `if self.DragSlot ~= nil and self.DragSlot > 0 then
 	return
 end
+if self.Hand == nil then
+	return
+end
 local cardId = self.Hand[slot]
 if cardId == nil then
 	return
--- a/tools/deck/gen-slaydeck.mjs
+++ b/tools/deck/gen-slaydeck.mjs
@@ -3,7 +3,10 @@
 import { POTIONS } from './lib/data.mjs';
 import { prop, codeblock, RUN_LENGTH } from './lib/codeblock.mjs';
 import { bootMethods } from './cb/boot.mjs';
-import { stateMethods } from './cb/state.mjs';
+import { screensMethods } from './cb/screens.mjs';
+import { npcMethods } from './cb/npc.mjs';
+import { navigationMethods } from './cb/navigation.mjs';
+import { layoutMethods } from './cb/layout.mjs';
 import { soulMethods } from './cb/soul.mjs';
 import { charSelectMethods } from './cb/charselect.mjs';
 import { runMethods } from './cb/run.mjs';
@@ -45,6 +48,9 @@ function writeCodeblocks() {
    prop('any', 'AscPlusHandler'),
    prop('any', 'JobOpts'),
    prop('any', 'Jobs'),
+    prop('any', 'JobMeta'),
+    prop('any', 'ClassGroups'),
+    prop('any', 'ClassLineages'),
    prop('number', 'AscensionLevel', '0'),
    prop('number', 'AscensionUnlocked', '0'),
    prop('any', 'StartGameHandler'),
@@ -58,6 +64,7 @@ function writeCodeblocks() {
    prop('any', 'AllDeckCloseHandler'),
    prop('number', 'SoulPoints', '0'),
    prop('boolean', 'LobbyBound', 'false'),
+    prop('boolean', 'ButtonsBound', 'false'),
    prop('number', 'LobbyTpTries', '0'),
    prop('boolean', 'CodexMode', 'false'),
    prop('any', 'CodexCards'),
@@ -113,14 +120,33 @@ function writeCodeblocks() {
    prop('number', 'PlayerStr', '0'),
    prop('number', 'PlayerWeak', '0'),
    prop('number', 'PlayerVuln', '0'),
+    prop('number', 'PlayerIntangible', '0'),
    prop('any', 'PlayerPowers'),
    prop('any', 'Potions'),
    prop('any', 'RunPotions'),
    prop('number', 'PotionSlots', String(POTIONS.baseSlots)),
    prop('string', 'ShopPotion', '""'),
    prop('boolean', 'ShopPotionBought', 'false'),
+    prop('number', 'CardsDrawnThisCombat', '0'),
+    prop('boolean', 'HandCostZeroThisTurn', 'false'),
+    prop('boolean', 'DrawDisabledThisTurn', 'false'),
+    prop('number', 'SkillCostReductionThisTurn', '0'),
+    prop('any', 'SkillSlyOnPlayCards'),
+    prop('any', 'TurnSkillSlyCards'),
+    prop('boolean', 'ShivFirstDamageBonusUsed', 'false'),
+    prop('any', 'CombatCardCostReduction'),
+    prop('number', 'ActiveAttackDamageVsWeakMultiplier', '1'),
+    prop('number', 'DrawDamageThisTurn', '0'),
+    prop('number', 'DrawPoisonThisTurn', '0'),
+    prop('boolean', 'ShivAoeThisCombat', 'false'),
+    prop('number', 'PoisonApplicationsThisCombat', '0'),
+    prop('number', 'EnemyStrengthLossThisTurn', '0'),
+    prop('number', 'ActiveKillReward', '0'),
+    prop('number', 'BonusRewardScreens', '0'),
    prop('number', 'FightAttackCount', '0'),
    prop('number', 'TurnAttackCardsPlayed', '0'),
+    prop('number', 'TurnCardsPlayedThisTurn', '0'),
+    prop('number', 'DamageDealtThisTurn', '0'),
    prop('number', 'TurnDiscardedCards', '0'),
    prop('boolean', 'FirstHpLossDone', 'false'),
    prop('number', 'ClayBlockNext', '0'),
@@ -133,6 +159,8 @@ function writeCodeblocks() {
    prop('number', 'DiscardSelectTotal', '0'),
    prop('number', 'DiscardPostShiv', '0'),
    prop('number', 'DiscardShivPerPick', '0'),
+    prop('number', 'DiscardPostDraw', '0'),
+    prop('number', 'DiscardDrawPerPick', '0'),
    prop('boolean', 'RetainSelectActive', 'false'),
    prop('boolean', 'ReserveSelectActive', 'false'),
    prop('number', 'NextTurnBlock', '0'),
@@ -143,11 +171,13 @@ function writeCodeblocks() {
    prop('string', 'NextTurnSelectPrompt', '""'),
    prop('number', 'NextTurnSelectCopies', '0'),
    prop('boolean', 'NextSkillCostZero', 'false'),
-    prop('number', 'SkillCostReductionThisTurn', '0'),
+    prop('number', 'NextSkillRepeatCount', '0'),
    prop('any', 'NextTurnAddCards'),
  ], [
    ...bootMethods,
-    ...stateMethods,
+    ...screensMethods,
+    ...npcMethods,
+    ...navigationMethods,
    ...soulMethods,
    ...charSelectMethods,
    ...runMethods,
@@ -158,6 +188,7 @@ function writeCodeblocks() {
    ...jobMethods,
    ...runEndMethods,
    ...renderMethods,
+    ...layoutMethods,
    ...rewardMethods,
    ...itemMethods,
    ...tooltipMethods,
--- a/tools/deck/lib/data.mjs
+++ b/tools/deck/lib/data.mjs
@@ -6,7 +6,7 @@ const ENEMIES = JSON.parse(readFileSync('data/enemies.json', 'utf8'));
 // 검증 (fail-fast): 잘못된 데이터면 생성 중단
 const CLASSES = {
  warrior: { label: '전사', maxHp: 80 },
-  bandit: { label: '도적', maxHp: 70 },
+  rogue: { label: '도적', maxHp: 70 },
  magician: { label: '마법사', maxHp: 70 },
 };
 for (const cls of Object.keys(CLASSES)) {
@@ -15,22 +15,28 @@ for (const cls of Object.keys(CLASSES)) {
    if (!CARDS.cards[id]) throw new Error(`[gen-slaydeck] starterDecks.${cls}에 없는 카드 id 참조: ${id}`);
  }
 }
-// 전직 옵션 (클래스별 2차 — JobSelectHud 동적 구성·SetJob 대표 카드)
+
+// 전직 옵션
 const JOBS = {
  warrior: [
-    { id: 'fighter', name: '파이터', desc: '공격 특화\n콤보 어택 · 버서크\n라이징 어택', starter: 'ComboAttack' },
-    { id: 'page', name: '페이지', desc: '속성 차지 특화\n썬더/블리자드 차지\n파워 가드', starter: 'ThunderCharge' },
-    { id: 'spearman', name: '스피어맨', desc: '방어·관통 특화\n피어스 · 아이언 월\n하이퍼 바디', starter: 'Pierce' },
+    { id: 'fighter', name: '파이터', desc: '공격 특화\n콤보 어택 · 버서크\n라이징 어택', starter: 'ComboAttack', tier: 2, parent: 'warrior' },
+    { id: 'page', name: '페이지', desc: '속성 차지 특화\n썬더/블리자드 차지\n파워 가드', starter: 'ThunderCharge', tier: 2, parent: 'warrior' },
+    { id: 'spearman', name: '스피어맨', desc: '방어·관통 특화\n피어스 · 아이언 월\n하이퍼 바디', starter: 'Pierce', tier: 2, parent: 'warrior' },
  ],
  magician: [
-    { id: 'firepoison', name: '위자드(불·독)', desc: '화염·독 특화\n파이어 애로우\n포이즌 브레스 · 앰플', starter: 'FireArrow' },
-    { id: 'icelightning', name: '위자드(썬·콜)', desc: '광역·빙결 특화\n썬더 볼트(전체)\n콜드 빔 · 칠링 스텝', starter: 'ThunderBolt' },
-    { id: 'cleric', name: '클레릭', desc: '회복·축복 특화\n힐 · 블레스\n홀리 애로우', starter: 'Heal' },
+    { id: 'firepoison', name: '위자드(불·독)', desc: '화염·독 특화\n파이어 애로우\n포이즌 브레스 · 앰플', starter: 'FireArrow', tier: 2, parent: 'magician' },
+    { id: 'icelightning', name: '위자드(썬·콜)', desc: '광역·빙결 특화\n썬더 볼트(전체)\n콜드 빔 · 칠링 스텝', starter: 'ThunderBolt', tier: 2, parent: 'magician' },
+    { id: 'cleric', name: '클레릭', desc: '회복·축복 특화\n힐 · 블레스\n홀리 애로우', starter: 'Heal', tier: 2, parent: 'magician' },
  ],
-  bandit: [
-    { id: 'shiv', name: 'Shiv', desc: 'Many small attacks\nBlade Dance\nAccuracy · After Image', starter: 'BladeDance' },
-    { id: 'poisoner', name: 'Poison', desc: 'Poison scaling\nDeadly Poison\nCatalyst · Noxious Fumes', starter: 'DeadlyPoison' },
-    { id: 'trickster', name: 'Trickster', desc: 'Draw and tempo\nAcrobatics\nAdrenaline · Tools', starter: 'Acrobatics' },
+  rogue: [
+    { id: 'assassin', name: 'Assassin', desc: '표창 중심 전직\n단일 화력과 독 압박\n빠른 마무리', starter: 'DeadlyPoison', tier: 2, parent: 'rogue' },
+    { id: 'thief', name: 'Thief', desc: '단검 중심 전직\n드로우와 운영 강화\n빠른 연계', starter: 'Acrobatics', tier: 2, parent: 'rogue' },
+  ],
+  assassin: [
+    { id: 'hermit', name: 'Hermit', desc: 'Assassin의 3차 전직\n표창과 독 운영 심화\n누적 압박 강화', starter: 'NoxiousFumes', tier: 3, parent: 'assassin' },
+  ],
+  thief: [
+    { id: 'thiefmaster', name: 'Thief Master', desc: 'Thief의 3차 전직\n단검 운영 심화\n드로우와 템포 강화', starter: 'ToolsOfTheTrade', tier: 3, parent: 'thief' },
  ],
 };
 for (const [cls, jobs] of Object.entries(JOBS)) {
@@ -38,6 +44,42 @@ for (const [cls, jobs] of Object.entries(JOBS)) {
    if (!CARDS.cards[j.starter]) throw new Error(`[gen-slaydeck] JOBS.${cls}.${j.id} 대표 카드 없음: ${j.starter}`);
  }
 }
+
+const CLASS_GROUPS = {
+  warrior: ['warrior', 'fighter', 'page', 'spearman'],
+  magician: ['magician', 'firepoison', 'icelightning', 'cleric'],
+  rogue: ['rogue', 'assassin', 'hermit', 'thief', 'thiefmaster'],
+};
+
+const CLASS_LINEAGES = {
+  warrior: ['warrior'],
+  fighter: ['warrior', 'fighter'],
+  page: ['warrior', 'page'],
+  spearman: ['warrior', 'spearman'],
+  magician: ['magician'],
+  firepoison: ['magician', 'firepoison'],
+  icelightning: ['magician', 'icelightning'],
+  cleric: ['magician', 'cleric'],
+  rogue: ['rogue'],
+  assassin: ['rogue', 'assassin'],
+  hermit: ['rogue', 'assassin', 'hermit'],
+  thief: ['rogue', 'thief'],
+  thiefmaster: ['rogue', 'thief', 'thiefmaster'],
+};
+
+const JOB_META = {};
+for (const [sourceClass, jobs] of Object.entries(JOBS)) {
+  for (const job of jobs) {
+    JOB_META[job.id] = {
+      name: job.name,
+      starter: job.starter,
+      tier: job.tier ?? 2,
+      parent: job.parent ?? sourceClass,
+      sourceClass,
+    };
+  }
+}
+
 // 영혼(soul) 메타 해금 — 2차 전직 후 보스 클리어로 영혼 적립, 로비 영혼상점에서 구매 → 다음 런 이점
 const SOUL_UNLOCKS = [
  { key: 'meso', name: '두둑한 지갑', desc: '런 시작 시 메소 +60', cost: 3 },
@@ -85,27 +127,23 @@ function luaCharsTable() {
 }

 // 맵은 런타임 절차 생성(GenerateMap Lua ↔ tools/map/rogue-map.mjs 미러). 정적 data/map.json 제거됨.
-const MAP_ROWS = 6; // 걷는 행 1..6, 보스 row 7 (depth 최대 7)
+const MAP_ROWS = 6;
 const MAP_COLS = 4;

-// 보물 상자 스프라이트 (공식 maplestory 리소스, 메이커 선별)
 const CHEST_CLOSED_RUID = '43df67920c0d43298e0d93c02c6afa71';
 const CHEST_OPEN_RUID = '09c5cee56fd640bf8ae3a18ce50f4759';

-// 노드 맵 아이콘/배경 (공식 maplestory RUID, data/nodeicons.json 단일 소스 — 교체 시 이 파일만 수정 후 재생성)
 const NODEICONS = JSON.parse(readFileSync('data/nodeicons.json', 'utf8'));
 for (const t of ['combat', 'elite', 'boss', 'shop', 'rest', 'treasure']) {
  if (!/^[0-9a-f]{32}$/.test((NODEICONS.icons || {})[t] || '')) throw new Error(`[gen-slaydeck] nodeicons.json icons.${t} RUID 누락/형식오류`);
 }
 if (!/^[0-9a-f]{32}$/.test(NODEICONS.background || '')) throw new Error('[gen-slaydeck] nodeicons.json background RUID 누락/형식오류');

-// 캐릭터 선택 초상화 (메이커 임포트 RUID, data/characters.json 단일 소스 — 교체 시 이 파일만 수정 후 재생성)
 const CHARS = JSON.parse(readFileSync('data/characters.json', 'utf8'));
-for (const c of ['warrior', 'magician', 'bandit']) {
+for (const c of ['warrior', 'magician', 'rogue']) {
  if (!/^[0-9a-f]{32}$/.test((CHARS.portraits || {})[c] || '')) throw new Error(`[gen-slaydeck] characters.json portraits.${c} RUID 누락/형식오류`);
 }

-// 전투 카메라 고정값(StS2: 플레이어 좌·몬스터 우). KickCombatCamera가 StartCombat에서 재confine에 사용.
 const CAM = JSON.parse(readFileSync('data/camera.json', 'utf8'));

 const RELICS = JSON.parse(readFileSync('data/relics.json', 'utf8'));
@@ -143,17 +181,33 @@ function luaEnemiesTable(enemies) {
    `\t${id} = { name = ${luaStr(e.name)}, maxHp = ${e.maxHp}, intents = ${luaIntentsArray(e.intents)} },`);
  return `self.Enemies = {\n${lines.join('\n')}\n}`;
 }
-// Lua 직렬화 헬퍼
+
 function luaStr(s) {
  return '"' + String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"';
 }
 function luaJobsTable(jobs) {
  const cls = Object.entries(jobs).map(([clsId, list]) => {
-    const items = list.map((j) => `\t\t{ id = ${luaStr(j.id)}, name = ${luaStr(j.name)}, desc = ${luaStr(j.desc)}, starter = ${luaStr(j.starter)} },`).join('\n');
+    const items = list.map((j) =>
+      `\t\t{ id = ${luaStr(j.id)}, name = ${luaStr(j.name)}, desc = ${luaStr(j.desc)}, starter = ${luaStr(j.starter)}, tier = ${j.tier ?? 2}, parent = ${luaStr(j.parent ?? clsId)} },`).join('\n');
    return `\t${clsId} = {\n${items}\n\t},`;
  }).join('\n');
  return `self.Jobs = {\n${cls}\n}`;
 }
+function luaClassGroupsTable(groups) {
+  const rows = Object.entries(groups).map(([clsId, list]) =>
+    `\t${clsId} = { ${list.map(luaStr).join(', ')} },`).join('\n');
+  return `self.ClassGroups = {\n${rows}\n}`;
+}
+function luaClassLineagesTable(lineages) {
+  const rows = Object.entries(lineages).map(([clsId, list]) =>
+    `\t${clsId} = { ${list.map(luaStr).join(', ')} },`).join('\n');
+  return `self.ClassLineages = {\n${rows}\n}`;
+}
+function luaJobMetaTable(meta) {
+  const rows = Object.entries(meta).map(([jobId, entry]) =>
+    `\t${jobId} = { name = ${luaStr(entry.name)}, starter = ${luaStr(entry.starter)}, tier = ${entry.tier}, parent = ${luaStr(entry.parent)}, sourceClass = ${luaStr(entry.sourceClass)} },`);
+  return `self.JobMeta = {\n${rows.join('\n')}\n}`;
+}
 function luaCardsTable(cards) {
  const lines = Object.entries(cards).map(([id, c]) => {
    const fields = [`name = ${luaStr(c.name)}`, `cost = ${c.cost}`, `desc = ${luaStr(c.desc)}`, `kind = ${luaStr(c.kind)}`];
@@ -166,12 +220,17 @@ function luaCardsTable(cards) {
    if (c.damagePerTurn != null) fields.push(`damagePerTurn = ${c.damagePerTurn}`);
    if (c.cardPlayedDamage != null) fields.push(`cardPlayedDamage = ${c.cardPlayedDamage}`);
    if (c.cardPlayedRandomDamage != null) fields.push(`cardPlayedRandomDamage = ${c.cardPlayedRandomDamage}`);
+    if (c.firstCardDamageBonus != null) fields.push(`firstCardDamageBonus = ${c.firstCardDamageBonus}`);
+    if (c.rewardOnKill != null) fields.push(`rewardOnKill = ${c.rewardOnKill}`);
+    if (c.intangible != null) fields.push(`intangible = ${c.intangible}`);
+    if (c.endTurnDexLoss != null) fields.push(`endTurnDexLoss = ${c.endTurnDexLoss}`);
    if (c.poisonPerTurn != null) fields.push(`poisonPerTurn = ${c.poisonPerTurn}`);
    if (c.attackPoison != null) fields.push(`attackPoison = ${c.attackPoison}`);
    if (c.otherHandAtLeast != null) fields.push(`otherHandAtLeast = ${c.otherHandAtLeast}`);
    if (c.bonusHitsWhenOtherHandAtLeast != null) fields.push(`bonusHitsWhenOtherHandAtLeast = ${c.bonusHitsWhenOtherHandAtLeast}`);
    if (c.block != null) fields.push(`block = ${c.block}`);
    if (c.blockGainMultiplier != null) fields.push(`blockGainMultiplier = ${c.blockGainMultiplier}`);
+    if (c.blockPerDamageDealtThisTurn != null) fields.push(`blockPerDamageDealtThisTurn = ${c.blockPerDamageDealtThisTurn}`);
    if (c.strength != null) fields.push(`strength = ${c.strength}`);
    if (c.dex != null) fields.push(`dex = ${c.dex}`);
    if (c.thorns != null) fields.push(`thorns = ${c.thorns}`);
@@ -189,6 +248,8 @@ function luaCardsTable(cards) {
    if (c.draw != null) fields.push(`draw = ${c.draw}`);
    if (c.drawUntilHandSize != null) fields.push(`drawUntilHandSize = ${c.drawUntilHandSize}`);
    if (c.drawSkillBlock != null) fields.push(`drawSkillBlock = ${c.drawSkillBlock}`);
+    if (c.drawDamage != null) fields.push(`drawDamage = ${c.drawDamage}`);
+    if (c.drawPoison != null) fields.push(`drawPoison = ${c.drawPoison}`);
    if (c.heal != null) fields.push(`heal = ${c.heal}`);
    if (c.gainEnergy != null) fields.push(`gainEnergy = ${c.gainEnergy}`);
    if (c.poison != null) fields.push(`poison = ${c.poison}`);
@@ -203,6 +264,14 @@ function luaCardsTable(cards) {
    if (c.drawDisabledThisTurn === true) fields.push('drawDisabledThisTurn = true');
    if (c.addShivPerDiscard === true) fields.push('addShivPerDiscard = true');
    if (c.useAllEnergy === true) fields.push('useAllEnergy = true');
+    if (c.shivDamageBonus != null) fields.push(`shivDamageBonus = ${c.shivDamageBonus}`);
+    if (c.firstShivDamageBonus != null) fields.push(`firstShivDamageBonus = ${c.firstShivDamageBonus}`);
+    if (c.shivRetain === true) fields.push('shivRetain = true');
+    if (c.shivAoe === true) fields.push('shivAoe = true');
+    if (c.attackDamageVsWeakMultiplier != null) fields.push(`attackDamageVsWeakMultiplier = ${c.attackDamageVsWeakMultiplier}`);
+    if (c.poisonHits != null) fields.push(`poisonHits = ${c.poisonHits}`);
+    if (c.poisonRandomTargets === true) fields.push('poisonRandomTargets = true');
+    if (c.poisonIfTargetPoisoned === true) fields.push('poisonIfTargetPoisoned = true');
    if (c.xDamagePerEnergy != null) fields.push(`xDamagePerEnergy = ${c.xDamagePerEnergy}`);
    if (c.xWeakPerEnergy != null) fields.push(`xWeakPerEnergy = ${c.xWeakPerEnergy}`);
    if (c.nextTurnBlock != null) fields.push(`nextTurnBlock = ${c.nextTurnBlock}`);
@@ -212,8 +281,21 @@ function luaCardsTable(cards) {
    if (c.nextTurnCopies != null) fields.push(`nextTurnCopies = ${c.nextTurnCopies}`);
    if (c.nextTurnSelectHandCard === true) fields.push('nextTurnSelectHandCard = true');
    if (c.nextTurnSelectPrompt != null) fields.push(`nextTurnSelectPrompt = ${luaStr(c.nextTurnSelectPrompt)}`);
+    if (c.nextSkillRepeatCount != null) fields.push(`nextSkillRepeatCount = ${c.nextSkillRepeatCount}`);
    if (c.nextSkillCostZero === true) fields.push('nextSkillCostZero = true');
    if (c.skillCostReductionThisTurn != null) fields.push(`skillCostReductionThisTurn = ${c.skillCostReductionThisTurn}`);
+    if (c.skillSlyOnPlay === true) fields.push('skillSlyOnPlay = true');
+    if (c.turnHandSlyCount != null) fields.push(`turnHandSlyCount = ${c.turnHandSlyCount}`);
+    if (c.combatCostReductionOnPlay != null) fields.push(`combatCostReductionOnPlay = ${c.combatCostReductionOnPlay}`);
+    if (c.randomTargetEachHit === true) fields.push('randomTargetEachHit = true');
+    if (c.repeatOnKill === true) fields.push('repeatOnKill = true');
+    if (c.affectsAllEnemies === true) fields.push('affectsAllEnemies = true');
+    if (c.removeEnemyBlock === true) fields.push('removeEnemyBlock = true');
+    if (c.removeEnemyArtifact === true) fields.push('removeEnemyArtifact = true');
+    if (c.enemyStrengthLossThisTurn != null) fields.push(`enemyStrengthLossThisTurn = ${c.enemyStrengthLossThisTurn}`);
+    if (c.extraPoisonTicks != null) fields.push(`extraPoisonTicks = ${c.extraPoisonTicks}`);
+    if (c.poisonApplicationBurstEvery != null) fields.push(`poisonApplicationBurstEvery = ${c.poisonApplicationBurstEvery}`);
+    if (c.poisonApplicationBurstDamage != null) fields.push(`poisonApplicationBurstDamage = ${c.poisonApplicationBurstDamage}`);
    if (c.innate === true) fields.push('innate = true');
    if (c.playableWhenDrawPileEmpty === true) fields.push('playableWhenDrawPileEmpty = true');
    if (c.sly === true) fields.push('sly = true');
@@ -234,4 +316,11 @@ function luaDeckTable(deck) {
  return `self.DrawPile = { ${deck.map(luaStr).join(', ')} }`;
 }

-export { CARDS, ENEMIES, CLASSES, JOBS, SOUL_UNLOCKS, luaSoulShopTable, CARDFRAMES, RARITIES, frameRuid, luaFramesTable, luaNodeIconsTable, luaCharsTable, MAP_ROWS, MAP_COLS, CHEST_CLOSED_RUID, CHEST_OPEN_RUID, NODEICONS, CHARS, CAM, RELICS, luaRelicsTable, POTIONS, luaPotionsTable, luaIntentsArray, luaEnemiesTable, luaStr, luaJobsTable, luaCardsTable, luaDeckTable };
+export {
+  CARDS, ENEMIES, CLASSES, JOBS, JOB_META, CLASS_GROUPS, CLASS_LINEAGES, SOUL_UNLOCKS,
+  luaSoulShopTable, CARDFRAMES, RARITIES, frameRuid, luaFramesTable, luaNodeIconsTable,
+  luaCharsTable, MAP_ROWS, MAP_COLS, CHEST_CLOSED_RUID, CHEST_OPEN_RUID, NODEICONS, CHARS,
+  CAM, RELICS, luaRelicsTable, POTIONS, luaPotionsTable, luaIntentsArray, luaEnemiesTable,
+  luaStr, luaJobsTable, luaClassGroupsTable, luaClassLineagesTable, luaJobMetaTable,
+  luaCardsTable, luaDeckTable,
+};
--- a/tools/verify/cardkinds.mjs
+++ b/tools/verify/cardkinds.mjs
@@ -0,0 +1,42 @@
+// 카드 kind ↔ 효과 정합성 정적 검사 (협업자/codex가 카드 추가 후 실행).
+// 배경(2026-06-30): kind가 효과와 안 맞으면 카드가 사용불가/死카드가 된다.
+//  - ResolveCardDrop 라우팅: Attack=몬스터 위 드롭(FindMonsterAtTouch>0 필요) / Skill·Power=위로 스윕 / Status=unplayable.
+//    → block·유틸만 있고 데미지 없는 카드를 Attack으로 두면 위로 스윕으로 못 쓴다(아이언 바디 사고).
+//  - PlayCard의 Power 분기는 PlayerPowers 등록만 하고 damage/aoe를 무시한다.
+//    → Power인데 powerEffect도 power필드도 없으면 재생 시 아무 효과 없는 死카드(분노 사고).
+// 사용: node tools/verify/cardkinds.mjs   (이상 0 → exit 0, 있으면 목록 + exit 1)
+import { readFileSync } from 'node:fs';
+
+const cards = JSON.parse(readFileSync('data/cards.json', 'utf8')).cards;
+
+// Power 카드를 실제로 기능하게 하는 필드(powerEffect 지속효과 + 온플레이/지속 power 필드).
+// damage/aoe/block 같은 Attack/Skill 전용 필드는 Power 분기서 무시되므로 제외.
+const POWER_FIELDS = [
+  'powerEffect', 'strength', 'dex', 'thorns', 'intangible',
+  'turnStartShiv', 'turnStartDraw', 'turnStartDiscard',
+  'shivDamageBonus', 'firstShivDamageBonus', 'shivRetain', 'shivAoe',
+  'attackPoison', 'drawDamage', 'drawPoison', 'attackDamageVsWeakMultiplier',
+  'cardPlayedBlock', 'cardPlayedDamage', 'cardPlayedRandomDamage',
+  'extraPoisonTicks', 'poisonApplicationBurstEvery', 'poisonApplicationBurstDamage',
+  'skillSlyOnPlay', 'endTurnDexLoss',
+];
+const VALID_KINDS = ['Attack', 'Skill', 'Power', 'Status'];
+
+const issues = [];
+for (const [id, c] of Object.entries(cards)) {
+  if (!VALID_KINDS.includes(c.kind)) {
+    issues.push(`${id}(${c.name}): 미지원 kind="${c.kind}"`);
+    continue;
+  }
+  if (c.kind === 'Attack' && c.damage == null && c.xDamagePerEnergy == null) {
+    issues.push(`${id}(${c.name}): kind=Attack인데 damage 없음 → 몬스터 드롭 라우팅 불가(방어/유틸이면 kind=Skill)`);
+  }
+  if (c.kind === 'Power' && !POWER_FIELDS.some((f) => c[f] != null)) {
+    issues.push(`${id}(${c.name}): kind=Power인데 power효과 없음(死카드) → damage/aoe는 Power 분기서 무시, kind 재검토`);
+  }
+}
+
+console.log(`카드 ${Object.keys(cards).length}장 kind↔효과 정합성: 이상 ${issues.length}`);
+for (const i of issues) console.log('  ⚠️ ' + i);
+console.log(issues.length ? 'RESULT: 정합성 위반 (위 카드 kind 수정 필요)' : 'RESULT: 모든 카드 kind↔효과 일치 ✓');
+process.exit(issues.length ? 1 : 0);
--- a/tools/verify/cbprops.mjs
+++ b/tools/verify/cbprops.mjs
@@ -0,0 +1,34 @@
+// cb/*.mjs의 `self.<Field> = ` 대입 ↔ gen-slaydeck.mjs 선언 prop 대조.
+// 미선언 prop에 대입하면 MSW 런타임 "cannot set X, no such field" → 그 후보를 정적 검출.
+// 사용: node tools/verify/cbprops.mjs
+import { readFileSync, readdirSync } from 'node:fs';
+
+const orch = readFileSync('tools/deck/gen-slaydeck.mjs', 'utf8');
+const declared = new Set();
+for (const m of orch.matchAll(/prop\(\s*'[^']*'\s*,\s*'([^']+)'/g)) declared.add(m[1]);
+
+// MSW 빌트인/설정으로 대입 가능한 self 필드(프롭 아님) — 오탐 제외 화이트리스트.
+const BUILTIN = new Set(['Entity']);
+
+const dir = 'tools/deck/cb';
+const files = readdirSync(dir).filter((f) => f.endsWith('.mjs'));
+const assigns = new Map(); // name -> Set(files)
+for (const f of files) {
+  const src = readFileSync(`${dir}/${f}`, 'utf8');
+  // self.Name = (단, == / ~= / .Y= / [..]= 는 제외)
+  for (const m of src.matchAll(/self\.([A-Za-z_]\w*)\s*=(?!=)/g)) {
+    const name = m[1];
+    if (!assigns.has(name)) assigns.set(name, new Set());
+    assigns.get(name).add(f);
+  }
+}
+
+const missing = [...assigns.keys()]
+  .filter((n) => !declared.has(n) && !BUILTIN.has(n))
+  .sort();
+
+console.log(`선언 prop: ${declared.size} | 대입된 self.X distinct: ${assigns.size}`);
+console.log(`미선언 대입 (no such field 후보): ${missing.length}`);
+for (const n of missing) console.log(`  - ${n}  [${[...assigns.get(n)].join(', ')}]`);
+console.log(missing.length ? 'RESULT: MISSING PROPS ABOVE' : 'RESULT: 모든 self 대입이 선언됨 ✓');
+process.exit(missing.length ? 1 : 0);
--- a/tools/verify/cbset.mjs
+++ b/tools/verify/cbset.mjs
@@ -0,0 +1,40 @@
+// 순서 무관 codeblock 메서드 집합 비교. 본문 미출력 — 이름·차이 카운트만.
+// 메서드 이동 리팩터의 무손실 검증용: 워킹트리 codeblock vs ref(기본 HEAD).
+// 사용: node tools/verify/cbset.mjs [ref]
+import { readFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+
+const PATH = 'RootDesk/MyDesk/SlayDeckController.codeblock';
+const ref = process.argv[2] || 'HEAD';
+
+function methodsOf(jsonText) {
+  const obj = JSON.parse(jsonText);
+  const arr = obj.ContentProto.Json.Methods;
+  const map = new Map();
+  for (const m of arr) {
+    map.set(m.Name, { code: m.Code, exec: m.ExecSpace, params: JSON.stringify(m.Parameters || []) });
+  }
+  return map;
+}
+
+const work = methodsOf(readFileSync(PATH, 'utf8'));
+const base = methodsOf(execSync(`git show ${ref}:${PATH}`, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }));
+
+const onlyWork = [...work.keys()].filter((k) => !base.has(k));
+const onlyBase = [...base.keys()].filter((k) => !work.has(k));
+const changed = [];
+for (const k of work.keys()) {
+  if (!base.has(k)) continue;
+  const a = work.get(k);
+  const b = base.get(k);
+  if (a.code !== b.code || a.exec !== b.exec || a.params !== b.params) changed.push(k);
+}
+
+console.log(`ref=${ref}  work=${work.size}  base=${base.size}`);
+console.log(`only-in-work (${onlyWork.length}): ${onlyWork.join(', ') || '-'}`);
+console.log(`only-in-base (${onlyBase.length}): ${onlyBase.join(', ') || '-'}`);
+console.log(`body/exec/params changed (${changed.length}): ${changed.join(', ') || '-'}`);
+
+const ok = onlyWork.length === 0 && onlyBase.length === 0 && changed.length === 0;
+console.log(ok ? 'RESULT: IDENTICAL SET (무손실)' : 'RESULT: DIFFERENCES ABOVE');
+process.exit(ok ? 0 : 1);