자산(엔진) 시스템 v1 + 오염 카드 압박 강화

자산 시스템 (docs/작업지시서/자산시스템_작업지시서.md 반영, 이전 세션 작업분 커밋): - 발라트로형 조커 레이어 엔진 빌딩 도입. assets.json 8종(트리거→효과→성장 스키마) + engine/assetEngine.js(이벤트 버스, 연쇄 깊이 상한 10)로 기존 수동 클릭형 자산 4종 전면 대체 - AssetInfoPopup 추가 — 자산 슬롯 클릭 시 트리거/효과/스택/충전 상태 표시, 발동 로그 피드 노출 오염 카드 압박 강화 (그레이박스 위기감 피드백 반영): - engine/pollution.js 신설 — 오염 주입 규칙(타입 매핑·등급 추첨·물량)을 단일 모듈로 분리해 사전 예고(SwipeCard) · 실제 주입(GameScreen) · 사후 알림이 같은 계산을 공유하도록 함 - 위험 파라미터를 올리는 결재는 정례회의를 기다리지 않고 그 자리에서 덱에 오염 카드를 주입 - UI 3종: 스와이프 시 오염 유입 사전 경고, 결재 후 유입 토스트, 상단 덱 오염 상시 게이지 - currentCardIndex를 매 결재마다 덱 길이로 정규화(주입/소각으로 덱 길이가 바뀌므로 필요) 기타: - docs/architecture_design.md를 실제 구현(plain JS/CSS, useState, engine/ 순수 함수 경계) 기준으로 전면 재작성 — 기존 문서는 채택되지 않은 초기 제안(Tailwind/Zustand/TS)이었음 - playtest.bat 추가 — 더블클릭으로 dev 서버 실행 (ASCII 전용, chcp로 인한 배치 파싱 오류 회피) - CLAUDE.md 상태 갱신 및 실기 플레이 결과 기록 실기 플레이로 정상 동작 확인. 자산 획득 경로(극비 카드 스와이프)는 플레이 중 한 번도 발생하지 않아 원인 미조사 상태로 남김 — CLAUDE.md에 후속 확인 항목으로 기록. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Part A (연대기 ↔ 내러티브 태그 개념 분리) — 문서 6개 반영
2026-07-23 22:59:30 +09:00 · 2026-07-13 21:22:42 +09:00
22 changed files with 1599 additions and 301 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -14,7 +14,10 @@ Phase 5(비주얼 폴리싱)는 그레이박스 테스트 피드백 반영 완
 ## 코드 컨벤션 (package.json으로 알 수 없는 것)
 - 전체 구조·아키텍처 원칙(상태 배치, `engine/` 경계, world 스냅샷 패턴) → @docs/architecture_design.md
 - 실제 앱은 `client/` 안에 있음. npm 명령은 `cd client` 후 실행.
 - 플레이테스트는 리포 루트의 `playtest.bat` 더블클릭 (dev 서버 + 브라우저 자동 오픈).
  파일명은 ASCII만 사용 — 한글/`chcp`를 넣으면 cmd.exe가 배치 파싱을 깨뜨린다(과거에 겪음).
 - 스타일: 컴포넌트별 개별 `.css` (글로벌 클래스, CSS Modules 아님)
 - 상태관리: `useState` / `useReducer`만 사용. 외부 상태관리 라이브러리 도입 금지.
 - 영구 저장: `localStorage` (도감 엔딩 저장 용도)
@@ -78,6 +81,59 @@ Phase 5 [ ] 비주얼 폴리싱 & UX          ← 그레이박스 테스트 완
 선별된 카드의 좌/우 선택지에서만 얻는다. 페이즈 전환 문턱은 "고유 태그 3종/6종 획득". 자세한
 내용은 `ROADMAP.md` Phase 4 참고.
 **2026-07-13 내러티브 태그 재설계 (작업지시서 반영):** `docs/내러티브태그_시스템_작업지시서.md` 기준으로
 ① 연대기(Chronicle, 결재 결정 이력)와 내러티브 태그(세계의 상흔, 결과)를 개념적으로 분리 —
 기획서/스토리 바이블/와이어프레임/비전/PRD/유저플로우/개발순서 문서 반영 완료. ② `narrative_tags.json`
 10종에 `snippet`(1~2문장 결과 보고서, 거리감 있는 관료체) · `snippet_type`("system" 7종 / "human" 3종)
 필드 추가 — 초안이므로 디자이너 검토 필요.
 **남은 작업:** 현재 코드(`ChroniclePopup.jsx`, `GameScreen.jsx`)는 아직 태그 히스토리와 연대기(카드·선택 이력)를
 하나의 팝업에서 함께 보여준다. 문서가 요구하는 "세계의 상흔 팝업 vs 연대기 팝업" 2종 분리 UI 구현은
 아직 미착수 — 별도 작업으로 진행 필요.
 **2026-07-13 자산(엔진) 시스템 v1 (작업지시서 반영):** `docs/작업지시서/자산시스템_작업지시서.md` 기준으로
 발라트로형 "조커 레이어" 엔진 빌딩을 도입 — 덱은 여전히 적(오염)이고, 자산 슬롯이 패시브로 오염을
 걸러내는 엔진이라는 설계 그대로 구현. 기존 4종 수동 클릭형 자산(성질변환/시한부격리/영구소각/결재권강제행사)을
 전면 대체: 신규 `client/src/data/assets.json`(8종, 트리거→효과→성장 스키마)과 `client/src/engine/assetEngine.js`
 (이벤트 버스 — every_n_approvals/on_pollution_draw/on_swipe_left/on_council_end/on_purge 연쇄, 깊이 상한 10)로 구현.
 극비 프로젝트 성공 시 미보유 자산 중 무작위 1종 획득(획득 경로 튜닝은 2차 배치로 범위 외). 자산 슬롯 클릭 시
 `AssetInfoPopup`으로 트리거→효과·스택·충전 상태 표시, 화면 우하단에 발동 로그 피드(최근 4건) 노출 — Part C UX
 블로커 해결. 기존 `mulliganShields`(방어막 카운트)를 "다음 오염 카드 페널티 무효화" 공용 풀로 재사용해
 결재 반려 도장(충전식 수동)과 책임 소재 불명 처리(조직저항 자동 무효화)가 같은 메커니즘을 공유하도록 구현.
 **단순화/가정 사항 (디자이너 확인 필요):** ① 위험 수용 계수 등 "+N%" 리스크는 기존 0~5단계 스케일(1단계=20%)로
 환산해 소수점으로 누적시킴. ② 임시 격리 컨테이너(좌 스와이프 격리)는 문서의 "발동 선택 가능"을 단순화해
 자동 발동으로 구현(확인 팝업 없음). ③ 자산 슬롯은 4개 고정 → 보유량만큼 늘어나는 가변 슬롯으로 변경.
 Part D 플레이테스트 체크리스트(역전 엔진 성립/연쇄 가시성/S급 킹핀/무효 빌드 풍자/오버파워 확인/연쇄 깊이 상한)는
 아직 미검증 — 디자이너 플레이 후 피드백 필요.
 **2026-07-23 오염 카드 압박 강화 (위기감 피드백 반영):** "오염 카드 수가 적어 위기감이 없고,
 스와이프가 오염을 늘린다는 걸 알려주지 않아 고민이 안 된다"는 그레이박스 피드백을 반영.
 ① 오염 주입 규칙을 `client/src/engine/pollution.js`로 분리 — 사전 예고 · 실제 주입 · 사후 알림이
 `previewPollution()` 단일 기준을 공유한다(예고와 결과가 어긋나면 정보 신뢰가 깨지므로 이 함수를
 우회해 오염 카드를 만들지 말 것). ② **위험 파라미터를 올리는 결재는 그 자리에서 덱에 오염 카드를 주입**
 (위험 +1 = 오염 1장, 1회 최대 3장, 현재 위치 2~4장 뒤에 삽입). 기존에는 정례회의에서만 파라미터당 1장이었다.
 ③ 정례회의 주입도 단계 비례로(`min(3, ceil(level/2))`). ④ 페널티 무효화(방어막/책임 소재 불명) 시에는
 오염도 유입되지 않는다 — 방어막의 값어치. ⑤ UI 3종: 스와이프 인텐트에 `☣ 오염 카드 +N` 사전 경고,
 결재 후 유입 토스트, 상단에 `☣ 덱 오염 N/전체` 상시 게이지(40% 이상 시 적색 점멸). ⑥ 덱 인덱스를
 매 결재마다 덱 길이로 정규화 — 이전에는 `currentCardIndex`가 덱 길이를 넘어 계속 증가해 삽입 위치 계산이
 무의미했다. `pickGrade`도 반올림 추가(자산 부작용이 파라미터를 소수점으로 올려 크래시 가능성이 있었음).
 **튜닝 수치는 `pollution.js` 상단 상수 블록에 모아뒀다.**
 **시뮬레이션(400~600회, 자산·의회 파라미터 정화 제외):** 신중 플레이 시 총 주입 오염 10.8장 → 25.1장,
 최종 덱 오염률 39% → 59%. 무작위 플레이의 붕괴율 ~100%는 변경 **이전에도** 동일했다(파라미터가 원인).
 **디자이너 확인 필요:** ⓐ 위험 1점 = 오염 1장 비율이 적정한지 ⓑ 항상 안전한 쪽만 고르면 붕괴율 0% —
 안전 선택지의 토큰 비용이 충분한 압박인지 별도 검토 필요.
 **2026-07-23 실기 플레이 결과:** 디자이너 직접 플레이 확인 — 위기감 강화 방향은 맞으나(목표에 조금 더
 가까워짐), 세부 밸런스는 아직 조정 여지 있음. 정밀 튜닝은 플레이 횟수를 더 쌓은 뒤 진행 예정.
 **⚠️ 미확인 이슈 — 자산 획득이 실기 플레이에서 한 번도 발생하지 않음 (2026-07-23):** 자산(엔진) 시스템
 플레이테스트 중 자산을 하나도 획득하지 못해 Part D 체크리스트를 아직 검증 못함. 단, 플레이 횟수 자체가
 적어 정상 확률 범위인지 실제 버그인지 구분 안 된 상태 — **아직 원인 조사 안 함, 다음 세션에서 확인할 것.**
 획득 경로는 `GameScreen.jsx`의 `handleSwipe` 내 `card.type === '극비'` 분기(카드 타입 '극비' 스와이프
 성공 시 미보유 자산 중 무작위 1종). 의심 지점: ① '극비' 카드는 페이즈2 풀(`phase2Pool`)에만 있고
 페이즈2는 내러티브 태그 3종 획득 후에야 덱에 섞이므로, 그 전까지는 애초에 등장 자체가 불가능 —
 플레이가 짧으면 페이즈2 진입 전에 끝났을 가능성. ② 페이즈2 진입 이후에도 '극비' 카드 등장 빈도/개수가
 낮을 수 있음(`cards.csv` 기준 극비 7종). 위쪽 확률 문제인지, 아니면 조건 분기 자체의 버그인지는 코드를
 다시 열어 확인 필요.
 **⚠️ 2026-07-09 병렬 브랜치 병합:** 이 폴더가 유일한 작업 사본이 아니라면, 작업 시작 전
 `git fetch` 후 `git log origin/main..HEAD`와 `git log HEAD..origin/main`으로 분기 여부를
 반드시 확인할 것. 과거에 다른 세션이 origin에 푸시한 커밋을 이 로컬이 받지 못한 채 Phase 2~4를
--- a/client/src/components/AssetInfoPopup.css
+++ b/client/src/components/AssetInfoPopup.css
@@ -0,0 +1,92 @@
 .asset-popup-overlay {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background: rgba(0, 0, 0, 0.85);
  z-index: 300;
  display: flex;
  align-items: center;
  justify-content: center;
 }
 .asset-popup {
  background: var(--color-surface);
  width: 85%;
  max-width: 420px;
  border-radius: 16px;
  padding: 20px;
  border: 1px solid rgba(255, 255, 255, 0.15);
  box-shadow: 0 10px 50px rgba(0, 0, 0, 0.9);
 }
 .asset-popup-header {
  display: flex;
  align-items: center;
  gap: 10px;
  margin-bottom: 12px;
 }
 .asset-popup-grade {
  font-family: var(--font-typewriter);
  font-weight: bold;
  font-size: 13px;
  padding: 2px 8px;
  border-radius: 4px;
  border: 1px solid currentColor;
 }
 .grade-C { color: #9ca3af; }
 .grade-B { color: #4ade80; }
 .grade-A { color: #60a5fa; }
 .grade-S { color: #fbbf24; }
 .asset-popup-archetype {
  font-size: 13px;
  color: #a1a1aa;
 }
 .asset-popup-header .close-btn {
  margin-left: auto;
 }
 .asset-popup-name {
  margin: 0 0 8px 0;
  font-family: var(--font-doc-title);
  font-size: 20px;
 }
 .asset-popup-desc {
  font-size: 14px;
  color: #d4d4d8;
  line-height: 1.5;
  margin: 0 0 12px 0;
 }
 .asset-popup-stat {
  font-size: 13px;
  color: var(--color-token-info);
  margin-bottom: 10px;
 }
 .asset-popup-activate {
  width: 100%;
  background: var(--color-resistance-critical);
  color: #05201c;
  border: none;
  border-radius: 8px;
  padding: 10px;
  font-family: var(--font-ui);
  font-weight: 700;
  font-size: 15px;
  cursor: pointer;
  margin-bottom: 10px;
 }
 .asset-popup-flavor {
  font-size: 12px;
  color: #888;
  font-style: italic;
  margin: 0;
 }
--- a/client/src/components/AssetInfoPopup.jsx
+++ b/client/src/components/AssetInfoPopup.jsx
@@ -0,0 +1,43 @@
 import React from 'react';
 import { ARCHETYPE_META } from '../engine/assetEngine';
 import './AssetInfoPopup.css';
 export default function AssetInfoPopup({ instance, def, onActivate, onClose }) {
  if (!instance || !def) return null;
  const meta = ARCHETYPE_META[def.archetype];
  const isManualCharge = def.trigger.type === 'manual_charge';
  const ready = isManualCharge && instance.charge >= 1;
  return (
    <div className="asset-popup-overlay" onClick={onClose}>
      <div className="asset-popup" onClick={e => e.stopPropagation()}>
        <div className="asset-popup-header">
          <span className={`asset-popup-grade grade-${def.grade}`}>{def.grade}</span>
          <span className="asset-popup-archetype">{meta.icon} {meta.label}</span>
          <button className="close-btn" onClick={onClose}>&times;</button>
        </div>
        <h3 className="asset-popup-name">{def.name}</h3>
        <p className="asset-popup-desc">{def.description}</p>
        {def.growth && (
          <div className="asset-popup-stat">
            현재 숙련 스택: <strong>{instance.stack || 0}</strong> (매 {def.growth.per}회마다 추가 발동)
          </div>
        )}
        {isManualCharge && (
          <div className="asset-popup-stat">
            {ready ? '충전 완료 — 발동 가능' : `충전 대기 중 (${def.trigger.params.chargeEvery}건마다 충전)`}
          </div>
        )}
        {ready && (
          <button className="asset-popup-activate" onClick={onActivate}>발동</button>
        )}
        <p className="asset-popup-flavor">{def.flavor}</p>
      </div>
    </div>
  );
 }
--- a/client/src/components/GameScreen.css
+++ b/client/src/components/GameScreen.css
@@ -57,6 +57,30 @@
  font-size: 12px;
  color: #999;
  white-space: nowrap;
  display: flex;
  flex-direction: column;
  gap: 3px;
  align-items: center;
 }
 /* 덱 오염도 — 결재를 이어갈수록 덱이 얼마나 썩었는지 상시 노출 */
 .deck-pollution {
  font-size: 11px;
  color: #84cc16;
  opacity: 0.75;
  letter-spacing: 0.5px;
 }
 .deck-pollution.critical {
  color: #f87171;
  opacity: 1;
  font-weight: 700;
  animation: pulse-pollution 1.6s infinite alternate;
 }
@keyframes pulse-pollution {
  0% { text-shadow: none; }
  100% { text-shadow: 0 0 8px currentColor; }
 }
 .parameters {
@@ -191,6 +215,46 @@
  cursor: default;
 }
 .asset-slot.grade-S { border-color: #fbbf24; }
 .asset-slot.grade-A { border-color: #60a5fa; }
 .asset-slot.grade-B { border-color: #4ade80; }
 .asset-slot.grade-C { border-color: #9ca3af; }
 .asset-slot.ready {
  box-shadow: 0 0 10px rgba(251, 191, 36, 0.7);
  animation: shake 1.2s infinite;
 }
 .asset-slot-empty-hint {
  font-family: var(--font-typewriter);
  font-size: 12px;
  color: #555;
 }
 /* 자산 발동 로그 피드 — 발라트로 조커 점멸에 해당하는 최소 구현(텍스트 로그) */
 .asset-log-feed {
  position: absolute;
  right: 12px;
  bottom: 190px;
  display: flex;
  flex-direction: column;
  gap: 4px;
  max-width: 60%;
  z-index: 50;
  pointer-events: none;
 }
 .asset-log-line {
  font-family: var(--font-typewriter);
  font-size: 11px;
  color: #d4d4d8;
  background: rgba(0, 0, 0, 0.55);
  border-left: 2px solid var(--color-risk-critical);
  padding: 4px 8px;
  border-radius: 4px;
  text-align: right;
 }
 /* Game Over */
 .game-over {
  display: flex;
@@ -234,11 +298,61 @@
  background: var(--color-text);
  color: var(--color-bg);
 }
-.tag-notification {
+/* 태그 획득 / 오염 유입 토스트는 같은 열에 쌓아 서로 겹치지 않게 한다 */
 .notification-stack {
  position: absolute;
  top: 100px;
  left: 50%;
  transform: translateX(-50%);
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 8px;
  z-index: 100;
  pointer-events: none;
  width: max-content;
  max-width: 90%;
 }
 .pollution-notification {
  background: rgba(0, 0, 0, 0.92);
  border: 1px solid #dc2626;
  border-radius: 12px;
  padding: 10px 20px;
  display: flex;
  align-items: center;
  gap: 14px;
  box-shadow: 0 4px 20px rgba(139, 0, 0, 0.5);
  animation: notiFadeOut 2.6s forwards;
 }
 .pollution-noti-icon {
  font-size: 26px;
  color: #f87171;
 }
 .pollution-noti-info h4 {
  margin: 0;
  color: #f87171;
  font-size: 13px;
  font-family: var(--font-ui);
 }
 .pollution-noti-info p {
  margin: 4px 0 0 0;
  color: #e4e4e7;
  font-size: 13px;
  font-family: var(--font-typewriter);
 }
@keyframes notiFadeOut {
  0% { opacity: 0; transform: translateY(-16px); }
  10% { opacity: 1; transform: translateY(0); }
  85% { opacity: 1; transform: translateY(0); }
  100% { opacity: 0; transform: translateY(-16px); }
 }
 .tag-notification {
  background: rgba(0, 0, 0, 0.9);
  border: 1px solid #fbbf24;
  border-radius: 12px;
@@ -247,8 +361,7 @@
  align-items: center;
  gap: 16px;
  box-shadow: 0 4px 20px rgba(251, 191, 36, 0.4);
-  z-index: 100;
+  animation: notiFadeOut 3s forwards;
  animation: slideDownFadeOut 3s forwards;
 }
 .tag-noti-icon {
@@ -268,9 +381,3 @@
  font-size: 18px;
 }
@keyframes slideDownFadeOut {
  0% { opacity: 0; transform: translate(-50%, -20px); }
  10% { opacity: 1; transform: translate(-50%, 0); }
  80% { opacity: 1; transform: translate(-50%, 0); }
  100% { opacity: 0; transform: translate(-50%, -20px); }
 }
--- a/client/src/components/GameScreen.jsx
+++ b/client/src/components/GameScreen.jsx
@@ -1,4 +1,4 @@
-import React, { useState, useEffect } from 'react';
+import React, { useState, useEffect, useRef } from 'react';
 import Papa from 'papaparse';
 import cardsCsvRaw from '../data/cards.csv?raw';
 import narrativeTagsData from '../data/narrative_tags.json';
@@ -7,50 +7,28 @@ import SwipeCard from './SwipeCard';
 import CouncilScreen from './CouncilScreen';
 import EndingScreen from './EndingScreen';
 import ChroniclePopup from './ChroniclePopup';
 import AssetInfoPopup from './AssetInfoPopup';
 import * as AssetEngine from '../engine/assetEngine';
 import {
  CONTAM_TYPES,
  CONTAM_TYPE_ICON,
  previewPollution,
  buildPollutionCards,
  buildCouncilPollutionCards,
  insertIntoDeck,
  describePollution,
 } from '../engine/pollution';
 import { CHAIRMAN_AXES, isNarrativeChainComplete, resolveEnding, getEndingById } from '../data/endings';
 import './GameScreen.css';
-// 오염 카드 타입 <-> 파라미터 매핑 (파산/오염 등급 시스템)
+// 오염 카드 주입 규칙(타입 매핑 · 등급 추첨 · 물량)은 engine/pollution.js에 모여 있다.
-const CONTAM_TYPE_BY_PARAM = {
+// 스와이프 예고(SwipeCard)와 실제 주입이 같은 계산을 쓰게 하기 위해 여기서 다시 정의하지 말 것.
  entropy: '신화',
  resistance: '조직저항',
  panic: '사회공황',
  risk: '이사회압박',
 };
 const CONTAM_TYPES = new Set(Object.values(CONTAM_TYPE_BY_PARAM));
 // 파라미터 단계(1~5)가 높을수록 높은 등급(S/A) 확률이 커지는 가중치 테이블
 const GRADE_WEIGHTS = {
  1: { C: 70, B: 22, A: 6, S: 2 },
  2: { C: 50, B: 28, A: 15, S: 7 },
  3: { C: 32, B: 30, A: 23, S: 15 },
  4: { C: 18, B: 24, A: 32, S: 26 },
  5: { C: 8, B: 17, A: 33, S: 42 },
 };
 const pickGrade = (level) => {
  const weights = GRADE_WEIGHTS[Math.min(5, Math.max(1, level))];
  const total = Object.values(weights).reduce((a, b) => a + b, 0);
  let r = Math.random() * total;
  for (const [grade, w] of Object.entries(weights)) {
    if (r < w) return grade;
    r -= w;
  }
  return 'C';
 };
 // 내러티브 태그는 narrative_tags.json 풀(10종)에서 "처음 획득하는 태그"만 진행도에 반영된다.
 // 문턱은 풀 크기 대비 낮게 잡는다 (기존 4/8은 실제 플레이에서 길게 느껴진다는 피드백 반영).
 const PHASE2_TAG_THRESHOLD = 3;
 const PHASE3_TAG_THRESHOLD = 6;
 const ASSET_META = {
  transform: { icon: '🧪', label: '성질 변환' },
  quarantine: { icon: '⏳', label: '시한부 격리' },
  purge: { icon: '🔥', label: '물리적 영구 소각' },
  mulligan: { icon: '🛡️', label: '결재권 강제 행사' },
 };
 // 글로벌 지부장 12개 파벌 풀 (게임 시작 시 5명 무작위 선발, 실리에 따라 우호도 개별 계산)
 const GLOBAL_FACTIONS = [
  { id: 'military', name: '군산복합 연합', computeAffinity: (c) => c.tags.force * 15 + c.tokens.personnel * 0.4 - 40 },
@@ -106,23 +84,15 @@ const buildCardFromRow = (row) => ({
  },
 });
 const transformCard = (card) => {
  const flip = (stats) => ({ ...stats, res: -stats.res, ent: -stats.ent, pan: -stats.pan, rsk: -stats.rsk });
  return {
    ...card,
    transformed: true,
    text: card.transformed ? card.text : `${card.text} (순화됨)`,
    left: { ...card.left, stats: flip(card.left.stats) },
    right: { ...card.right, stats: flip(card.right.stats) },
  };
 };
 export function GameScreen() {
  const [params, setParams] = useState({ resistance: 0, entropy: 0, panic: 0, risk: 0 });
  const [tokens, setTokens] = useState({ budget: 50, personnel: 50, info: 50 });
  const [tags, setTags] = useState({ wealth: 0, force: 0, surveillance: 0 });
  const [acquiredTags, setAcquiredTags] = useState([]);
  const [newTagNotification, setNewTagNotification] = useState(null);
  // 결재 직후 "오염 카드 N건이 덱에 유입됨"을 알리는 토스트. 연속 스와이프 시 타이머를 갱신한다.
  const [pollutionNotification, setPollutionNotification] = useState(null);
  const pollutionTimerRef = useRef(null);
  const [phase, setPhase] = useState(1);
  const [gameOver, setGameOver] = useState(false);
  const [cards, setCards] = useState([]);
@@ -135,7 +105,11 @@ export function GameScreen() {
  const [showCouncil, setShowCouncil] = useState(false);
  const [chronicle, setChronicle] = useState([]);
  const [showChronicle, setShowChronicle] = useState(false);
-  const [assets, setAssets] = useState([]);
+
  // 자산(엔진) 시스템 — 작업지시서 기준 트리거/효과 엔진
  const [ownedAssets, setOwnedAssets] = useState([]);
  const [assetLog, setAssetLog] = useState([]);
  const [assetPopup, setAssetPopup] = useState(null);
  // 라운드 구조: 라운드가 증가할수록 정례회의까지 남은 결재 건수가 줄어든다 (시간 압박 시각화)
  const [roundCount, setRoundCount] = useState(1);
@@ -226,51 +200,93 @@ export function GameScreen() {
    }
  }, [turns]);
-  const applySide = (side, nullifyDanger) => {
+  // 자산 엔진 world 스냅샷 생성/반영 — 현재 state를 복사해 엔진에 넘기고, 반환된 결과를 다시 state로 반영한다.
-    const s = side.stats;
+  // 호출 지점 하나당 반드시 buildAssetWorld/commitAssetWorld를 한 번씩만 쓴다: 같은 이벤트 처리 안에서
-    setParams(p => ({
+  // 여러 번 짝지어 부르면 나중 커밋이 아직 리렌더되지 않은(오래된) 클로저 state로 앞의 변경을 덮어써 버린다.
-      resistance: Math.max(0, p.resistance + (nullifyDanger ? 0 : s.res)),
+  const buildAssetWorld = () => ({
-      entropy: Math.max(0, p.entropy + (nullifyDanger ? 0 : s.ent)),
+    cards: [...cards],
-      panic: Math.max(0, p.panic + (nullifyDanger ? 0 : s.pan)),
+    tokens: { ...tokens },
-      risk: Math.max(0, p.risk + (nullifyDanger ? 0 : s.rsk)),
+    tags: { ...tags },
-    }));
+    params: { ...params },
-    setTokens(t => ({
+    owned: ownedAssets.map(o => ({ ...o })),
-      budget: t.budget + s.bud,
+    quarantine: quarantineZone.map(q => ({ ...q })),
-      personnel: t.personnel + s.per,
+    logs: [],
-      info: t.info + s.inf,
+    purgeGain: 0,
-    }));
+  });
-    setTags(tg => ({
+
-      wealth: tg.wealth + s.wea,
+  const commitAssetWorld = (world) => {
-      force: tg.force + s.for,
+    setCards(world.cards);
-      surveillance: tg.surveillance + s.sur,
+    setTokens(world.tokens);
-    }));
+    setTags(world.tags);
    setParams(world.params);
    setOwnedAssets(world.owned);
    setQuarantineZone(world.quarantine);
    if (world.purgeGain) setPurgeCount(c => c + world.purgeGain);
    if (world.logs.length) setAssetLog(prev => [...prev, ...world.logs].slice(-8));
  };
  // 오염 유입 토스트 — 빠르게 연속 스와이프해도 마지막 알림 기준으로 표시 시간이 다시 채워진다.
  const notifyPollution = (count, entries) => {
    if (pollutionTimerRef.current) clearTimeout(pollutionTimerRef.current);
    setPollutionNotification({ id: Date.now(), count, summary: describePollution(entries) });
    pollutionTimerRef.current = setTimeout(() => setPollutionNotification(null), 2600);
  };
  useEffect(() => () => clearTimeout(pollutionTimerRef.current), []);
  const handleSwipe = (direction) => {
    if (cards.length === 0) return;
-    const card = cards[currentCardIndex % cards.length];
+    const cardIdx = currentCardIndex % cards.length;
-
+    const card = cards[cardIdx];
    let outcomeText = '';
    const side = direction === 'left' ? card.left : direction === 'right' ? card.right : null;
    const world = buildAssetWorld();
    let outcomeText = '';
    let isNewTag = false;
    let gainedTag = null;
-    if (side) {
+    // 자산 엔진: 좌 스와이프 격리 도박(임시 격리 컨테이너) — 성공하면 이 카드는 정상 결과 대신 격리된다.
-      const shouldNullify = card.contaminated && mulliganShields > 0;
+    let quarantinedByAsset = false;
-      applySide(side, shouldNullify);
+    if (direction === 'left' && card.contaminated) {
      AssetEngine.onSwipeLeft(world, cardIdx, turns);
      quarantinedByAsset = world.quarantinedCard;
    }
    // 자산 엔진: 오염 카드 드로우 트리거(신화 환전/조직저항 자동 무효화 등)
    let negateFree = false;
    if (!quarantinedByAsset && card.contaminated) {
      AssetEngine.onPollutionDraw(world, card.type);
      negateFree = world.negateFree;
    }
    if (quarantinedByAsset) {
      setChronicle(prev => [...prev, {
        turn: turns + 1, cardType: card.type, keyword: card.keyword, text: card.text,
        decision: '임시 격리 컨테이너로 격리 (정례회의 전까지 미회수 시 실패)', tag: null,
      }]);
    } else if (side) {
      const shouldNullify = card.contaminated && (negateFree || mulliganShields > 0);
      const s = side.stats;
      world.params.resistance = Math.max(0, world.params.resistance + (shouldNullify ? 0 : s.res));
      world.params.entropy = Math.max(0, world.params.entropy + (shouldNullify ? 0 : s.ent));
      world.params.panic = Math.max(0, world.params.panic + (shouldNullify ? 0 : s.pan));
      world.params.risk = Math.max(0, world.params.risk + (shouldNullify ? 0 : s.rsk));
      world.tokens.budget += s.bud;
      world.tokens.personnel += s.per;
      world.tokens.info += s.inf;
      world.tags.wealth += s.wea;
      world.tags.force += s.for;
      world.tags.surveillance += s.sur;
      outcomeText = side.text;
      // 파산 문책: 결재 결과 토큰이 마이너스가 되면 파산 카운터 증가
-      const nextBudget = tokens.budget + side.stats.bud;
+      if (world.tokens.budget < 0 || world.tokens.personnel < 0 || world.tokens.info < 0) {
      const nextPersonnel = tokens.personnel + side.stats.per;
      const nextInfo = tokens.info + side.stats.inf;
      if (nextBudget < 0 || nextPersonnel < 0 || nextInfo < 0) {
        setBankruptcyCount(c => c + 1);
      }
      // 극단적 파라미터 조기 엔딩 판별용: 이번 결재에서 가장 크게 증가한 위험 파라미터 추적
      if (!shouldNullify) {
-        const dangerDeltas = { resistance: side.stats.res, entropy: side.stats.ent, panic: side.stats.pan };
+        const dangerDeltas = { resistance: s.res, entropy: s.ent, panic: s.pan };
        let maxParam = null, maxVal = 0;
        Object.entries(dangerDeltas).forEach(([p, v]) => {
          if (v > maxVal) { maxVal = v; maxParam = p; }
@@ -297,32 +313,59 @@ export function GameScreen() {
      }
      if (shouldNullify) {
-        setMulliganShields(s => s - 1);
+        if (negateFree) {
          outcomeText += ' (책임 소재 불명 처리로 자동 무효화)';
        } else {
          setMulliganShields(s2 => s2 - 1);
          outcomeText += ' (방어막으로 페널티 무효화)';
        }
      }
      // 위험 파라미터를 올린 결재는 그 자리에서 덱에 오염 카드를 주입한다 (정례회의까지 기다리지 않는다).
      // 페널티가 무효화된 경우 파라미터도 오르지 않았으므로 오염도 유입되지 않는다 — 방어막의 값어치.
      if (!shouldNullify) {
        const { total, entries } = previewPollution(s);
        if (total > 0) {
          const injected = buildPollutionCards(entries, world.params, contaminationTemplates);
          if (injected.length > 0) {
            world.cards = insertIntoDeck(world.cards, cardIdx, injected);
            outcomeText += ` → 오염 카드 ${injected.length}건 유입`;
            notifyPollution(injected.length, entries);
          }
        }
      }
    } else if (direction === 'up') {
      outcomeText = '보류 / 버리기';
    }
-    if (outcomeText) {
+    if (!quarantinedByAsset && outcomeText) {
      setChronicle(prev => [...prev, {
        turn: turns + 1, cardType: card.type, keyword: card.keyword, text: card.text,
        decision: outcomeText, tag: isNewTag ? gainedTag : null,
      }]);
    }
-    // 극비 프로젝트 성공 시 자산 획득 (4종 중 랜덤)
+    // 극비 프로젝트 성공 시 자산 획득 (아직 보유하지 않은 자산 중 무작위 1종)
-    if (card.type === '극비' && direction !== 'up') {
+    if (!quarantinedByAsset && card.type === '극비' && direction !== 'up') {
-      if (assets.length < 4) {
+      const ownedIds = new Set(world.owned.map(a => a.defId));
-        const types = Object.keys(ASSET_META);
+      const pool = AssetEngine.ASSET_CATALOG.filter(a => !ownedIds.has(a.id));
-        const type = types[Math.floor(Math.random() * types.length)];
+      if (pool.length > 0) {
-        setAssets(prev => [...prev, { id: Date.now(), type, ...ASSET_META[type] }]);
+        const def = pool[Math.floor(Math.random() * pool.length)];
        world.owned.push(AssetEngine.createAssetInstance(def.id, turns + 1));
        setAssetsAcquiredCount(c => c + 1);
        world.logs.push(`『${def.name}』(${def.grade}급) 획득`);
      }
    }
-    setCurrentCardIndex(idx => idx + 1);
+    // 자산 엔진: 결재 N건마다 발동(문서 파쇄실) + 충전식 자산 충전 확인
-    setTurns(t => t + 1);
+    const nextTurns = turns + 1;
    AssetEngine.onApprovalTick(world, nextTurns);
    commitAssetWorld(world);
    // 덱은 인덱스를 순환하는 풀이다. 주입/소각으로 길이가 바뀌므로 다음 인덱스는 항상 최종 덱 길이로
    // 정규화해 범위 안에 둔다 — 그래야 "현재 위치 기준 2~4장 뒤 삽입"이 의도대로 동작한다.
    setCurrentCardIndex(world.cards.length > 0 ? (cardIdx + 1) % world.cards.length : 0);
    setTurns(nextTurns);
    const newRemaining = approvalsRemaining - 1;
    setApprovalsRemaining(newRemaining);
@@ -331,33 +374,28 @@ export function GameScreen() {
    }
  };
-  // 그림자 의회 종료 후 파라미터 단계에 비례한 등급 가중치로 오염 카드 주입
+  // 그림자 의회 종료 후 파라미터 단계에 비례한 등급/물량으로 오염 카드 주입
  const injectContaminationCards = () => {
-    const newCards = [];
+    const newCards = buildCouncilPollutionCards(params, contaminationTemplates);
-    Object.entries(CONTAM_TYPE_BY_PARAM).forEach(([paramKey, cardType]) => {
+    if (newCards.length === 0) return;
      const level = params[paramKey];
      if (level < 1) return;
      const grade = pickGrade(level);
      const pool = contaminationTemplates.filter(t => t.type === cardType && t.grade === grade);
      if (pool.length === 0) return;
      const template = pool[Math.floor(Math.random() * pool.length)];
      newCards.push({ ...template, id: `${template.id}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}` });
    });
-    if (newCards.length > 0) {
+    setCards(prev => insertIntoDeck(prev, currentCardIndex, newCards));
      setCards(prev => {
        const insertAt = Math.min(prev.length, currentCardIndex + 1);
        const next = [...prev];
        next.splice(insertAt, 0, ...newCards);
        return next;
      });
    setChronicle(prev => [...prev, { turn: turns, cardType: '오염', keyword: null, text: `정례회의 종료 후 신규 오염 카드 ${newCards.length}건이 덱에 스며들었습니다.`, decision: '', tag: null }]);
-    }
+    const byType = newCards.reduce((acc, c) => ({ ...acc, [c.type]: (acc[c.type] || 0) + 1 }), {});
    notifyPollution(
      newCards.length,
      Object.entries(byType).map(([type, count]) => ({ icon: CONTAM_TYPE_ICON[type], type, count })),
    );
  };
  const handleCouncilResolve = (result) => {
    setShowCouncil(false);
    // 자산 엔진: 의회 종료 시 상시 자산 리스크 정산 + 격리 실패 판정(심연 보관 조례 개입 포함)
    const councilWorld = buildAssetWorld();
    AssetEngine.onCouncilEnd(councilWorld);
    commitAssetWorld(councilWorld);
    if (result.bankrupted) {
      setFinalEnding(getEndingById('bankruptcy'));
      setGameOver(true);
@@ -395,42 +433,16 @@ export function GameScreen() {
    }
  };
-  // 자산 효과 4종 발동
+  // 자산 슬롯 클릭 — 항상 정보 팝업을 연다 (Part C UX 블로커 해결). defId만 저장해 최신 스택/충전 값을 반영한다.
-  const activateAsset = (asset) => {
+  const handleAssetSlotClick = (inst) => setAssetPopup(inst.defId);
    if (asset.type === 'mulligan') {
      setMulliganShields(s => s + 1);
      setAssets(prev => prev.filter(a => a.id !== asset.id));
      setChronicle(prev => [...prev, { turn: turns, cardType: '자산', keyword: null, text: '결재권 강제 행사 방어막을 전개했습니다. 다음 오염 카드의 페널티가 무효화됩니다.', decision: '', tag: null }]);
      return;
    }
-    const contaminatedIdx = [];
+  // 충전식 자산(manual_charge) 수동 발동 — 팝업 내부의 '발동' 버튼에서 호출
-    cards.forEach((c, i) => { if (c.contaminated) contaminatedIdx.push(i); });
+  const handleAssetActivate = (defId) => {
-
+    const world = buildAssetWorld();
-    if (contaminatedIdx.length === 0) {
+    AssetEngine.activateManualAsset(world, defId, turns);
-      setChronicle(prev => [...prev, { turn: turns, cardType: '자산', keyword: null, text: `${asset.label}을(를) 발동했지만 대상이 될 오염 카드가 없습니다.`, decision: '', tag: null }]);
+    commitAssetWorld(world);
-      setAssets(prev => prev.filter(a => a.id !== asset.id));
+    if (world.negateChargeGranted) setMulliganShields(s => s + 1);
-      return;
+    setAssetPopup(null);
    }
    if (asset.type === 'purge') {
      const target = contaminatedIdx[Math.floor(Math.random() * contaminatedIdx.length)];
      setCards(prev => prev.filter((_, i) => i !== target));
      setPurgeCount(c => c + 1);
      setChronicle(prev => [...prev, { turn: turns, cardType: '자산', keyword: null, text: '오염 카드를 물리적으로 영구 소각했습니다.', decision: '', tag: null }]);
    } else if (asset.type === 'quarantine') {
      const targetSet = new Set(contaminatedIdx.slice(0, 2));
      const quarantined = cards.filter((c, i) => targetSet.has(i));
      setCards(prev => prev.filter((_, i) => !targetSet.has(i)));
      setQuarantineZone(prev => [...prev, ...quarantined.map(c => ({ ...c, returnTurn: turns + 5 }))]);
      setChronicle(prev => [...prev, { turn: turns, cardType: '자산', keyword: null, text: `오염 카드 ${quarantined.length}건을 시한부 격리했습니다. (5턴 후 덱으로 복귀)`, decision: '', tag: null }]);
    } else if (asset.type === 'transform') {
      const target = contaminatedIdx[Math.floor(Math.random() * contaminatedIdx.length)];
      setCards(prev => prev.map((c, i) => (i === target ? transformCard(c) : c)));
      setChronicle(prev => [...prev, { turn: turns, cardType: '자산', keyword: null, text: '오염 카드의 성질을 영구적으로 순화했습니다. (독을 약으로)', decision: '', tag: null }]);
    }
    setAssets(prev => prev.filter(a => a.id !== asset.id));
  };
  const renderDots = (value, max = 5) => {
@@ -454,7 +466,7 @@ export function GameScreen() {
    // 글로벌 지부장 12개 파벌 중 이번 회차 선발된 5명의 우호도를 각자 다른 조건으로 개별 계산
    const affinityCtx = {
      tags, tokens, params,
-      assetsCount: assets.length,
+      assetsCount: ownedAssets.length,
      mythicCount: cards.filter(c => c.type === '신화').length,
      tagCount: acquiredTags.length, assetsAcquiredCount, purgeCount, bribeCount,
    };
@@ -485,6 +497,10 @@ export function GameScreen() {
  const phaseClass = phase === 1 ? 'phase-1' : phase === 2 ? 'phase-2' : 'phase-3';
  const nextTagThreshold = phase === 1 ? PHASE2_TAG_THRESHOLD : phase === 2 ? PHASE3_TAG_THRESHOLD : null;
  // 덱 오염도 — 결재를 이어갈수록 덱이 얼마나 썩었는지 상시 노출해 압박을 준다.
  const pollutedCount = cards.filter(c => c.contaminated).length;
  const pollutionRatio = cards.length > 0 ? pollutedCount / cards.length : 0;
  return (
    <div className={`game-screen ${phaseClass}`}>
      {/* Top Bar */}
@@ -493,7 +509,10 @@ export function GameScreen() {
          <BookOpen size={16} /> <span>{acquiredTags.length}{nextTagThreshold !== null ? `/${nextTagThreshold}` : ''}</span>
        </div>
        <div className="round-info">
-          제 {roundCount}차 정례회의 상정까지: 잔여 {approvalsRemaining}건
+          <div>제 {roundCount}차 정례회의 상정까지: 잔여 {approvalsRemaining}건</div>
          <div className={`deck-pollution ${pollutionRatio >= 0.4 ? 'critical' : ''}`}>
            ☣ 덱 오염 {pollutedCount}/{cards.length}
          </div>
        </div>
        <div className="parameters">
          <div className={`param ${params.resistance >= 4 ? 'critical' : ''}`} style={{'--param-color': 'var(--color-resistance-critical)'}}>
@@ -538,23 +557,44 @@ export function GameScreen() {
          <div className="tag"><EyeOff size={14} /> <span>{tags.surveillance}</span></div>
        </div>
        <div className="asset-slots">
-          {[0, 1, 2, 3].map(i => {
+          {ownedAssets.length === 0 && <div className="asset-slot-empty-hint">보유 자산 없음</div>}
-            const asset = assets[i];
+          {ownedAssets.map((inst) => {
            const def = AssetEngine.getAssetDef(inst.defId);
            const meta = AssetEngine.ARCHETYPE_META[def.archetype];
            const ready = def.trigger.type === 'manual_charge' && inst.charge >= 1;
            return (
              <button
-                key={i}
+                key={inst.defId}
-                className={`asset-slot ${asset ? 'filled' : ''}`}
+                className={`asset-slot filled grade-${def.grade} ${ready ? 'ready' : ''}`}
-                onClick={() => asset && activateAsset(asset)}
+                onClick={() => handleAssetSlotClick(inst)}
-                disabled={!asset}
+                title={def.name}
                title={asset ? asset.label : '빈 슬롯'}
              >
-                {asset ? <span className="asset-icon">{asset.icon}</span> : ''}
+                <span className="asset-icon">{meta.icon}</span>
              </button>
            );
          })}
        </div>
      </div>
      {assetLog.length > 0 && (
        <div className="asset-log-feed">
          {assetLog.slice(-4).map((line, i) => (
            <div key={i} className="asset-log-line">{line}</div>
          ))}
        </div>
      )}
      {assetPopup && (
        <AssetInfoPopup
          instance={ownedAssets.find(a => a.defId === assetPopup)}
          def={AssetEngine.getAssetDef(assetPopup)}
          onActivate={() => handleAssetActivate(assetPopup)}
          onClose={() => setAssetPopup(null)}
        />
      )}
      {(newTagNotification || pollutionNotification) && (
        <div className="notification-stack">
          {newTagNotification && (
            <div className="tag-notification">
              <div className="tag-noti-icon">{newTagNotification.icon}</div>
@@ -564,6 +604,17 @@ export function GameScreen() {
              </div>
            </div>
          )}
          {pollutionNotification && (
            <div className="pollution-notification" key={pollutionNotification.id}>
              <div className="pollution-noti-icon">☣</div>
              <div className="pollution-noti-info">
                <h4>오염 카드 {pollutionNotification.count}건이 덱에 유입되었습니다</h4>
                <p>{pollutionNotification.summary}</p>
              </div>
            </div>
          )}
        </div>
      )}
      {showChronicle && (
        <ChroniclePopup
--- a/client/src/components/SwipeCard.css
+++ b/client/src/components/SwipeCard.css
@@ -222,6 +222,43 @@
  font-size: 20px;
 }
 /* 오염 카드 사전 경고 — 이 선택이 덱을 얼마나 더럽히는지 스와이프 전에 보여준다 */
 .pollution-warning {
  display: inline-flex;
  flex-direction: column;
  align-items: center;
  gap: 2px;
  background: rgba(20, 0, 0, 0.92);
  border: 2px solid #dc2626;
  color: #f87171;
  padding: 6px 14px;
  border-radius: 8px;
  margin-bottom: 8px;
  font-family: var(--font-ui);
  box-shadow: 0 0 15px rgba(139, 0, 0, 0.6);
  animation: pulsePollutionWarning 1.5s infinite;
  text-transform: none;
  letter-spacing: 0;
 }
 .pollution-warning-head {
  font-size: 16px;
  font-weight: 900;
 }
 .pollution-warning-types {
  font-family: var(--font-typewriter);
  font-size: 11px;
  color: #e4e4e7;
  white-space: nowrap;
 }
@keyframes pulsePollutionWarning {
  0% { transform: scale(1); box-shadow: 0 0 12px rgba(139, 0, 0, 0.5); }
  50% { transform: scale(1.04); box-shadow: 0 0 22px rgba(139, 0, 0, 0.9); }
  100% { transform: scale(1); box-shadow: 0 0 12px rgba(139, 0, 0, 0.5); }
 }
@keyframes pulseTag {
  0% { transform: scale(1); box-shadow: 0 0 15px rgba(251, 191, 36, 0.5); }
  50% { transform: scale(1.05); box-shadow: 0 0 25px rgba(251, 191, 36, 0.8); }
--- a/client/src/components/SwipeCard.jsx
+++ b/client/src/components/SwipeCard.jsx
@@ -1,8 +1,22 @@
 import React, { useState, useEffect } from 'react';
 import { motion, useMotionValue, useTransform, useAnimation } from 'framer-motion';
 import { HandCoins, Droplet, Eye, Shield, Building2, EyeOff } from 'lucide-react';
 import { previewPollution, describePollution } from '../engine/pollution';
 import './SwipeCard.css';
 // 이 선택이 덱에 오염 카드를 몇 장 밀어 넣는지 스와이프 전에 예고한다.
 // 계산은 반드시 engine/pollution.js의 previewPollution을 쓴다 — 실제 주입과 같은 기준이어야 한다.
 const renderPollutionWarning = (stats) => {
  const { total, entries } = previewPollution(stats);
  if (total === 0) return null;
  return (
    <div className="pollution-warning">
      <span className="pollution-warning-head">☣ 오염 카드 +{total}</span>
      <span className="pollution-warning-types">{describePollution(entries)}</span>
    </div>
  );
 };
 const renderStats = (stats) => {
  if (!stats) return null;
  const items = [];
@@ -117,6 +131,7 @@ export default function SwipeCard({ card, onSwipe, phase }) {
              <span className="intent-tag-name">{card.left.tag.name}</span>
            </div>
          )}
          {renderPollutionWarning(card.left?.stats)}
          {renderStats(card.left?.stats)}
        </motion.div>
        <motion.div className="swipe-intent right-intent" style={{ opacity: rightOpacity }}>
@@ -127,6 +142,7 @@ export default function SwipeCard({ card, onSwipe, phase }) {
              <span className="intent-tag-name">{card.right.tag.name}</span>
            </div>
          )}
          {renderPollutionWarning(card.right?.stats)}
          {renderStats(card.right?.stats)}
        </motion.div>
        {card.type === '극비' && (
--- a/client/src/data/assets.json
+++ b/client/src/data/assets.json
@@ -1,30 +1,106 @@
 [
  {
-    "id": "asset_01",
+    "id": "asset_purge_001",
-    "name": "전임 국장의 만년필",
+    "name": "문서 파쇄실",
-    "icon": "🖋️",
+    "grade": "C",
-    "description": "피로 쓰여진 듯한 잉크가 나옵니다. 예산 관리에 소소한 도움을 줍니다.",
+    "archetype": "purge",
-    "flavor": "\"예산 전용 동의서에 서명하기 아주 좋은 펜이군.\""
+    "trigger": { "type": "every_n_approvals", "params": { "n": 5 } },
    "effect": { "type": "purge_lowest", "params": { "count": 1 } },
    "growth": null,
    "risk": null,
    "faction_link": "scavengers",
    "description": "결재 5건마다 덱에서 최하 등급 오염 카드 1장을 영구 소각한다.",
    "flavor": "파쇄 용량: 일일 1건. 증설 요청은 3회 반려됨."
  },
  {
-    "id": "asset_02",
+    "id": "asset_purge_002",
-    "name": "비밀 스위스 은행 계좌",
+    "name": "소각 처리 대장",
-    "icon": "🏦",
+    "grade": "A",
-    "description": "마이너스 예산을 한 번 막아줄 수 있습니다.",
+    "archetype": "purge",
-    "flavor": "\"우리 기구가 파산해도 내 노후는 안전해야지.\""
+    "trigger": { "type": "on_purge", "params": {} },
    "effect": null,
    "growth": { "stackOn": "on_purge", "per": 3, "bonus": { "effect": "purge_lowest", "count": 1 } },
    "risk": null,
    "faction_link": "scavengers",
    "description": "소각이 발생할 때마다 숙련도가 쌓인다. 숙련 3회마다 최하 등급 오염 카드 1장을 추가로 소각한다.",
    "flavor": "소각로 온도는 서류로 증명되지 않는다."
  },
  {
-    "id": "asset_03",
+    "id": "asset_convert_001",
-    "name": "기억 소거 장치",
+    "name": "폐기물 재활용 규정",
-    "icon": "🔦",
+    "grade": "C",
-    "description": "불리한 결재 건을 한 번 취소할 수 있습니다.",
+    "archetype": "convert",
-    "flavor": "\"자, 여기 불빛을 보세요. 당신은 방금 아무것도 보지 못했습니다.\""
+    "trigger": { "type": "on_pollution_draw", "params": { "category": "신화", "minGrade": null } },
    "effect": { "type": "convert_to_token", "params": { "tokenType": "budget", "amount": 2 } },
    "growth": null,
    "risk": null,
    "faction_link": "nexus_traders",
    "description": "신화 오염 카드가 드로우되면 예산 토큰 2를 회수한다. (페널티는 정상 적용 후)",
    "flavor": "괴수 사체도 감가상각 대상이다."
  },
  {
-    "id": "asset_04",
+    "id": "asset_convert_002",
-    "name": "방탄 커피 머신",
+    "name": "부산물 매각 계약",
-    "icon": "☕",
+    "grade": "B",
-    "description": "요원들의 불만을 약간 억제합니다.",
+    "archetype": "convert",
-    "flavor": "\"아무리 세상이 멸망해도 모닝 커피는 포기 못하지.\""
+    "trigger": { "type": "on_convert", "params": {} },
    "effect": { "type": "convert_multiplier", "params": { "multiplier": 2 } },
    "growth": null,
    "risk": { "param": "risk_tolerance", "amount": 5, "when": "council_end" },
    "faction_link": "nexus_traders",
    "description": "모든 환전 효과의 산출량을 2배로 늘린다. 의회가 열릴 때마다 위험 수용 계수가 소폭 상승한다.",
    "flavor": "이 계약서에 서명한 사람은 아무도 기억하지 못한다."
  },
  {
    "id": "asset_quarantine_001",
    "name": "임시 격리 컨테이너",
    "grade": "C",
    "archetype": "quarantine",
    "trigger": { "type": "on_swipe_left", "params": {} },
    "effect": { "type": "quarantine", "params": { "failCondition": "다음 의회까지 대중 공황 1단계 상승" } },
    "growth": null,
    "risk": null,
    "faction_link": "occult_collectors",
    "description": "좌로 스와이프한 오염 카드를 격리한다. 다음 의회 전까지 처리하지 못하면 대중 공황이 상승한다.",
    "flavor": "컨테이너 라벨: '절대 열지 말 것 (2차 통보)'."
  },
  {
    "id": "asset_quarantine_002",
    "name": "심연 보관 조례",
    "grade": "S",
    "archetype": "quarantine",
    "trigger": { "type": "on_quarantine_fail", "params": {} },
    "effect": { "type": "quarantine_fail_to_purge", "params": { "bonusTag": "surveillance" } },
    "growth": null,
    "risk": null,
    "faction_link": "occult_collectors",
    "description": "격리가 실패로 판정되면 그 즉시 대상을 영구 소각하고, 감시 태그 1을 획득한다. 격리 실패가 더 이상 페널티가 아니다.",
    "flavor": "실패란 서류상의 표현일 뿐이다."
  },
  {
    "id": "asset_skip_001",
    "name": "결재 반려 도장",
    "grade": "C",
    "archetype": "skip",
    "trigger": { "type": "manual_charge", "params": { "chargeEvery": 10 } },
    "effect": { "type": "negate_penalty", "params": { "category": null } },
    "growth": null,
    "risk": null,
    "faction_link": "field_agents_union",
    "description": "결재 10건마다 충전된다. 충전 완료 시 수동으로 발동해 다음 오염 카드의 페널티를 1회 무효화한다.",
    "flavor": "도장이 닳는 속도가 곧 국장의 임기다."
  },
  {
    "id": "asset_skip_002",
    "name": "책임 소재 불명 처리",
    "grade": "B",
    "archetype": "skip",
    "trigger": { "type": "on_pollution_draw", "params": { "category": "조직저항", "minGrade": null } },
    "effect": { "type": "negate_penalty", "params": { "category": "조직저항" } },
    "growth": null,
    "risk": { "param": "resistance", "amount": 3, "when": "on_trigger" },
    "faction_link": "field_agents_union",
    "description": "조직 저항 계열 오염 카드의 페널티를 자동으로 무효화한다. 다만 책임 소재가 사라질 때마다 내부 저항이 소폭 상승한다.",
    "flavor": "'담당자 부재'라는 담당자가 새로 생겼다."
  }
 ]
--- a/client/src/data/narrative_tags.json
+++ b/client/src/data/narrative_tags.json
@@ -3,60 +3,80 @@
    "id": "tag_ruthless",
    "name": "피도 눈물도 없는 진압",
    "icon": "🩸",
-    "description": "반발을 무력으로 짓밟았습니다. 공포는 훌륭한 통제 수단입니다."
+    "description": "반발을 무력으로 짓밟았습니다. 공포는 훌륭한 통제 수단입니다.",
    "snippet": "진압 대응 인력 214명 투입. 민간인 부상 신고는 '작전 지연 방지' 사유로 접수 목록에서 삭제 처리됨.",
    "snippet_type": "system"
  },
  {
    "id": "tag_coverup",
    "name": "진실의 장막",
    "icon": "🤫",
-    "description": "대중이 알지 못하도록 변칙 사건을 완벽하게 은폐했습니다."
+    "description": "대중이 알지 못하도록 변칙 사건을 완벽하게 은폐했습니다.",
    "snippet": "변칙 목격 신고 63건, 언론 자문위 검토 후 '기상 이상 현상'으로 통합 발표 승인됨.",
    "snippet_type": "system"
  },
  {
    "id": "tag_alien_contact",
    "name": "금지된 지식",
    "icon": "👁️",
-    "description": "이계의 존재와 거래하거나 그들의 유물을 받아들였습니다. 장막 너머의 눈이 당신을 주시합니다."
+    "description": "이계의 존재와 거래하거나 그들의 유물을 받아들였습니다. 장막 너머의 눈이 당신을 주시합니다.",
    "snippet": "압수된 이계 유물 1점, 등급 미분류 상태로 특수연구소 이관됨.",
    "snippet_type": "system"
  },
  {
    "id": "tag_corruption",
    "name": "검은 뒷돈",
    "icon": "💼",
-    "description": "공적인 자산을 사적으로 유용하거나 부당한 거래를 승인했습니다."
+    "description": "공적인 자산을 사적으로 유용하거나 부당한 거래를 승인했습니다.",
    "snippet": "결산 불일치 340만 원, 담당 경리 개인 계좌 이체로 충당된 정황 확인. 사유 불문 처리됨.",
    "snippet_type": "human"
  },
  {
    "id": "tag_madness",
    "name": "이성의 붕괴",
    "icon": "🌀",
-    "description": "요원들을 비인도적인 실험과 광기에 노출시켰습니다. 인간성은 점점 희미해집니다."
+    "description": "요원들을 비인도적인 실험과 광기에 노출시켰습니다. 인간성은 점점 희미해집니다.",
    "snippet": "실험 참여 요원, 심리 평가 미제출 24개월째로 현장 배치 유지 확인. 재평가 요청 반려됨.",
    "snippet_type": "human"
  },
  {
    "id": "tag_cult",
    "name": "사이비의 그림자",
    "icon": "🌑",
-    "description": "고대 신을 숭배하는 종교와 엮이기 시작했습니다. 그들의 교리가 스며듭니다."
+    "description": "고대 신을 숭배하는 종교와 엮이기 시작했습니다. 그들의 교리가 스며듭니다.",
    "snippet": "신흥 종교단체 신도 수 3,400명 규모로 집계. 포교 활동 규제 안건은 종교자유 조항 검토 사유로 반려됨.",
    "snippet_type": "system"
  },
  {
    "id": "tag_coup",
    "name": "쿠데타의 그림자",
    "icon": "🗡️",
-    "description": "권력자들이 등을 돌리기 시작했습니다. 칼끝이 서서히 당신을 향하고 있습니다."
+    "description": "권력자들이 등을 돌리기 시작했습니다. 칼끝이 서서히 당신을 향하고 있습니다.",
    "snippet": "국장 신임 재투표 요구 서명 9명분 접수. 인사위원회 소집 안건은 '정족수 미달'로 미반영됨.",
    "snippet_type": "system"
  },
  {
    "id": "tag_panic_mob",
    "name": "군중의 광기",
    "icon": "😱",
-    "description": "이성을 잃은 대중이 거리를 뒤덮었습니다. 더 이상 통제할 수 없습니다."
+    "description": "이성을 잃은 대중이 거리를 뒤덮었습니다. 더 이상 통제할 수 없습니다.",
    "snippet": "자경단 관련 신고 118건, 담당 부서 인력 부족을 사유로 전건 내부 종결됨.",
    "snippet_type": "system"
  },
  {
    "id": "tag_political_pressure",
    "name": "정치적 압박",
    "icon": "⚖️",
-    "description": "이사회가 당신의 자리를 노리고 있습니다. 숫자 하나하나가 무기가 됩니다."
+    "description": "이사회가 당신의 자리를 노리고 있습니다. 숫자 하나하나가 무기가 됩니다.",
    "snippet": "이사회 특별 감사 요청 안건 5건 상정. 국장 관련 항목은 '자료 미비'로 반려됨.",
    "snippet_type": "system"
  },
  {
    "id": "tag_sacrifice",
    "name": "희생의 대가",
    "icon": "⚰️",
-    "description": "누군가의 목숨과 맞바꾼 결정이었습니다. 그 무게는 사라지지 않습니다."
+    "description": "누군가의 목숨과 맞바꾼 결정이었습니다. 그 무게는 사라지지 않습니다.",
    "snippet": "현장 요원 1명, 격리 프로토콜을 위반해 통로를 개방한 뒤 실종 처리됨.",
    "snippet_type": "human"
  }
 ]
--- a/client/src/engine/assetEngine.js
+++ b/client/src/engine/assetEngine.js
@@ -0,0 +1,226 @@
 // 자산(엔진) 시스템 — 트리거 → 효과 → (선택) 성장 이벤트 엔진 (그레이박스 v1)
 // docs/작업지시서/자산시스템_작업지시서.md 기준.
 //
 // GameScreen은 매 훅 지점(결재, 오염 드로우, 좌 스와이프, 의회 종료)마다 현재 상태로
 // world 스냅샷을 만들어 이 모듈의 함수에 넘기고, 반환된 world를 다시 React state로 반영한다.
 // world = { cards, tokens, tags, params, owned, quarantine, logs, purgeGain }
 import assetDefs from '../data/assets.json';
 const byId = Object.fromEntries(assetDefs.map((a) => [a.id, a]));
 export const ASSET_CATALOG = assetDefs;
 export const getAssetDef = (id) => byId[id];
 export const ARCHETYPE_META = {
  purge: { icon: '🔥', label: '소각' },
  convert: { icon: '💱', label: '환전' },
  quarantine: { icon: '⏳', label: '격리' },
  skip: { icon: '🛡️', label: '회피' },
 };
 const MAX_CHAIN_DEPTH = 10;
 const GRADE_RANK = { C: 0, B: 1, A: 2, S: 3 };
 const TOKEN_LABEL = { budget: '예산', personnel: '인력', info: '정보' };
 const TAG_LABEL = { wealth: '재력', force: '무력', surveillance: '감시' };
 export const createAssetInstance = (defId, turns) => ({
  defId,
  stack: 0,
  charge: 0,
  lastChargeTurn: turns,
  acquiredTurn: turns,
 });
 const log = (world, text) => world.logs.push(text);
 const hasAsset = (world, defId) => world.owned.some((o) => o.defId === defId);
 const lowestGradeContaminatedIndex = (cards) => {
  let best = -1;
  let bestRank = Infinity;
  cards.forEach((c, i) => {
    if (!c.contaminated) return;
    const r = GRADE_RANK[c.grade] ?? 0;
    if (r < bestRank) { bestRank = r; best = i; }
  });
  return best;
 };
 // 퍼센트 리스크(예: 5%, 3%)는 기존 0~5단계 파라미터 스케일(1단계 = 20%)로 환산한다.
 // '1단계' 같이 정수 단위로 명시된 페널티(격리 실패 등)는 그대로 정수로 더한다.
 const applyRisk = (world, risk, sourceName) => {
  if (!risk) return;
  const key = risk.param === 'risk_tolerance' ? 'risk' : risk.param;
  const amount = risk.amount / 20;
  world.params[key] = (world.params[key] || 0) + amount;
  log(world, `『${sourceName}』 부작용 — ${key} +${risk.amount}%`);
 };
 const convertAmount = (world, amount) => {
  const doubled = world.owned.some((o) => getAssetDef(o.defId)?.effect?.type === 'convert_multiplier');
  return doubled ? amount * 2 : amount;
 };
 const doPurge = (world, count, sourceName, depth) => {
  for (let i = 0; i < count; i++) {
    const idx = lowestGradeContaminatedIndex(world.cards);
    if (idx === -1) return;
    const [removed] = world.cards.splice(idx, 1);
    world.purgeGain = (world.purgeGain || 0) + 1;
    log(world, `『${sourceName}』 발동 — [${removed.grade}급 ${removed.type}] 소각됨`);
    fireEvent(world, 'on_purge', {}, depth + 1);
  }
 };
 // 결재 카드 스와이프마다 호출: every_n_approvals 자산 발동 + manual_charge 충전 확인
 export function onApprovalTick(world, turns) {
  world.owned.forEach((inst) => {
    const def = getAssetDef(inst.defId);
    if (!def) return;
    if (def.trigger.type === 'every_n_approvals') {
      const n = def.trigger.params.n;
      if (turns > 0 && turns % n === 0) {
        doPurge(world, def.effect.params.count, def.name, 0);
      }
    }
    if (def.trigger.type === 'manual_charge' && inst.charge < 1) {
      const base = inst.lastChargeTurn ?? inst.acquiredTurn ?? 0;
      if (turns - base >= def.trigger.params.chargeEvery) {
        inst.charge = 1;
        log(world, `『${def.name}』 충전 완료 — 슬롯을 눌러 발동할 수 있습니다.`);
      }
    }
  });
  return world;
 }
 // 오염 카드가 드로우(결재 대상으로 등장)될 때 호출. world.negateFree === true면 이번 카드 페널티를 자동 무효화.
 export function onPollutionDraw(world, category) {
  world.negateFree = false;
  world.owned.forEach((inst) => {
    const def = getAssetDef(inst.defId);
    if (!def || def.trigger.type !== 'on_pollution_draw') return;
    if (def.trigger.params.category && def.trigger.params.category !== category) return;
    if (def.effect.type === 'convert_to_token') {
      const amt = convertAmount(world, def.effect.params.amount);
      const tokenType = def.effect.params.tokenType;
      world.tokens[tokenType] = (world.tokens[tokenType] || 0) + amt;
      log(world, `『${def.name}』 발동 — ${TOKEN_LABEL[tokenType]} +${amt}`);
    } else if (def.effect.type === 'negate_penalty') {
      world.negateFree = true;
      log(world, `『${def.name}』 발동 — 이번 오염 카드 페널티 자동 무효화`);
      applyRisk(world, def.risk, def.name);
    }
  });
  return world;
 }
 // 좌 스와이프 시 호출(cardIndex는 world.cards 내 위치). 반환된 world.quarantinedCard === true면
 // 이번 카드는 정상 결과 대신 격리 처리되어 world.cards에서 이미 제거된 상태다.
 export function onSwipeLeft(world, cardIndex, turns) {
  world.quarantinedCard = false;
  const card = world.cards[cardIndex];
  if (!card || !card.contaminated) return world;
  const inst = world.owned.find((o) => o.defId === 'asset_quarantine_001');
  if (!inst) return world;
  const def = getAssetDef('asset_quarantine_001');
  world.cards.splice(cardIndex, 1);
  world.quarantine.push({ ...card, returnTurn: turns + 5, viaAsset: def.id, failChecked: false });
  log(world, `『${def.name}』 발동 — [${card.grade}급 ${card.type}] 격리됨 (다음 의회 전까지 미회수 시 실패)`);
  world.quarantinedCard = true;
  return world;
 }
 // 의회 종료 시 호출: 상시 자산 리스크 정산 + 격리 실패 판정(+심연 보관 조례 개입)
 export function onCouncilEnd(world) {
  world.owned.forEach((inst) => {
    const def = getAssetDef(inst.defId);
    if (def?.risk?.when === 'council_end') applyRisk(world, def.risk, def.name);
  });
  const pending = world.quarantine.filter((c) => c.viaAsset === 'asset_quarantine_001' && !c.failChecked);
  pending.forEach((card) => {
    card.failChecked = true;
    if (hasAsset(world, 'asset_quarantine_002')) {
      world.quarantine = world.quarantine.filter((c) => c !== card);
      const def6 = getAssetDef('asset_quarantine_002');
      world.tags.surveillance = (world.tags.surveillance || 0) + 1;
      world.purgeGain = (world.purgeGain || 0) + 1;
      log(world, `『${def6.name}』 발동 — 격리 실패한 [${card.grade}급 ${card.type}]를 영구 소각하고 감시 태그 획득`);
      fireEvent(world, 'on_purge', {}, 1);
    } else {
      world.params.panic = (world.params.panic || 0) + 1;
      log(world, `격리 실패 — [${card.grade}급 ${card.type}] 처리 지연으로 대중 공황 1단계 상승`);
    }
  });
  return world;
 }
 // 충전된 manual_charge 자산을 수동 발동. 성공 시 world.negateChargeGranted === true.
 export function activateManualAsset(world, defId, turns) {
  world.negateChargeGranted = false;
  const inst = world.owned.find((o) => o.defId === defId);
  const def = getAssetDef(defId);
  if (!inst || !def || inst.charge < 1) return world;
  inst.charge = 0;
  inst.lastChargeTurn = turns;
  world.negateChargeGranted = true;
  log(world, `『${def.name}』 발동 — 다음 오염 카드 페널티 무효화 충전을 사용했습니다.`);
  return world;
 }
 // on_purge / on_convert 등 연쇄 이벤트 디스패치. depth는 무한 루프 방지용 상한(10)까지.
 function fireEvent(world, eventType, payload, depth) {
  if (depth > MAX_CHAIN_DEPTH) {
    log(world, '⚠️ 연쇄 발동이 상한(10회)에 도달해 중단되었습니다.');
    return world;
  }
  world.owned.forEach((inst) => {
    const def = getAssetDef(inst.defId);
    if (!def || def.trigger.type !== eventType) return;
    if (def.growth && def.growth.stackOn === eventType) {
      inst.stack = (inst.stack || 0) + 1;
      if (inst.stack % def.growth.per === 0) {
        log(world, `『${def.name}』 숙련 ${inst.stack}회 누적 — 추가 발동`);
        if (def.growth.bonus.effect === 'purge_lowest') {
          doPurge(world, def.growth.bonus.count, def.name, depth);
        }
      }
      return;
    }
    if (!def.effect) return;
    switch (def.effect.type) {
      case 'gain_token': {
        const tokenType = def.effect.params.tokenType;
        const amt = def.effect.params.amount;
        world.tokens[tokenType] = (world.tokens[tokenType] || 0) + amt;
        log(world, `『${def.name}』 발동 — ${TOKEN_LABEL[tokenType]} +${amt}`);
        break;
      }
      case 'gain_tag': {
        const tagType = def.effect.params.tagType;
        const amt = def.effect.params.amount;
        world.tags[tagType] = (world.tags[tagType] || 0) + amt;
        log(world, `『${def.name}』 발동 — ${TAG_LABEL[tagType]} 태그 +${amt}`);
        break;
      }
      default:
        // convert_multiplier 등 상시 패시브 효과는 소유 여부만으로 별도 계산부(convertAmount)에서 반영한다.
        break;
    }
  });
  return world;
 }
 export { fireEvent };
--- a/client/src/engine/pollution.js
+++ b/client/src/engine/pollution.js
@@ -0,0 +1,154 @@
 // 오염 카드 주입 엔진 — 결재 선택(스와이프)과 정례회의 종료 시 덱에 오염 카드를 밀어 넣는다.
 //
 // 설계 의도(그레이박스 튜닝):
 //   좌우 스와이프 외에 능동적 행동이 거의 없는 게임이라, "내 결정이 덱을 더럽힌다"는 압박이
 //   위기감의 핵심이다. 그래서 위험 파라미터를 올리는 선택은 정례회의를 기다리지 않고
 //   그 자리에서 덱에 오염 카드를 주입한다.
 //
 //   SwipeCard의 사전 예고 · GameScreen의 사후 알림 · 실제 주입은 모두 previewPollution()을
 //   단일 기준으로 쓴다. 예고한 숫자와 실제 주입량이 어긋나면 플레이어가 정보를 신뢰하지 않게 되므로,
 //   이 함수를 우회해서 오염 카드를 만들지 말 것.
 // 오염 카드 타입 <-> 파라미터 매핑 (파산/오염 등급 시스템)
 export const CONTAM_TYPE_BY_PARAM = {
  entropy: '신화',
  resistance: '조직저항',
  panic: '사회공황',
  risk: '이사회압박',
 };
 export const CONTAM_TYPES = new Set(Object.values(CONTAM_TYPE_BY_PARAM));
 export const CONTAM_TYPE_ICON = {
  신화: '🌀',
  조직저항: '✊',
  사회공황: '😱',
  이사회압박: '⚠️',
 };
 // cards.csv의 위험 스탯 키 -> 파라미터 키 (상단 파라미터 표시 순서와 동일하게 유지)
 const DANGER_STAT_TO_PARAM = {
  res: 'resistance',
  ent: 'entropy',
  pan: 'panic',
  rsk: 'risk',
 };
 /* ── 밸런스 튜닝 상수 (오염 물량 조정은 여기만 고치면 된다) ───────────────── */
 // 위험 파라미터 +1 당 주입되는 오염 카드 장수.
 // cards.csv의 위험 수치는 대부분 +1, 일부 +2, 드물게 +3이다(한 선택지 최대 합계 +5).
 export const POLLUTION_PER_DANGER_POINT = 1;
 // 한 번의 결재로 주입되는 최대 장수 — 극단적인 카드 한 장이 덱을 통째로 망가뜨리지 않게 하는 상한.
 export const MAX_POLLUTION_PER_SWIPE = 3;
 // 정례회의 종료 시 파라미터 단계별 주입량 (기존: 단계와 무관하게 무조건 1장).
 export const councilPollutionCount = (level) => Math.min(3, Math.ceil(level / 2));
 // 주입된 카드가 실제로 등장하기까지 남겨두는 결재 건수 — 즉시 등장하면 예측 가능해지고,
 // 너무 멀면 인과가 안 느껴진다.
 const INJECT_OFFSET_MIN = 2;
 const INJECT_OFFSET_MAX = 4;
 // 파라미터 단계(1~5)가 높을수록 높은 등급(S/A) 확률이 커지는 가중치 테이블
 const GRADE_WEIGHTS = {
  1: { C: 70, B: 22, A: 6, S: 2 },
  2: { C: 50, B: 28, A: 15, S: 7 },
  3: { C: 32, B: 30, A: 23, S: 15 },
  4: { C: 18, B: 24, A: 32, S: 26 },
  5: { C: 8, B: 17, A: 33, S: 42 },
 };
 // 자산 부작용(applyRisk)이 파라미터를 소수점으로 올리므로 반드시 정수 단계로 반올림해서 조회한다.
 export const pickGrade = (level) => {
  const step = Math.min(5, Math.max(1, Math.round(level || 0)));
  const weights = GRADE_WEIGHTS[step];
  const total = Object.values(weights).reduce((a, b) => a + b, 0);
  let r = Math.random() * total;
  for (const [grade, w] of Object.entries(weights)) {
    if (r < w) return grade;
    r -= w;
  }
  return 'C';
 };
 /**
 * 이 선택지가 덱에 몇 장의 오염 카드를 주입하는지 미리 계산한다.
 * 스와이프 전 예고(SwipeCard)와 실제 주입(GameScreen)이 같은 값을 쓰도록 하는 단일 기준.
 * @returns {{ total: number, entries: Array<{param, type, icon, count}> }}
 */
 export function previewPollution(stats) {
  if (!stats) return { total: 0, entries: [] };
  const entries = [];
  Object.entries(DANGER_STAT_TO_PARAM).forEach(([statKey, param]) => {
    const value = stats[statKey] || 0;
    if (value <= 0) return;
    const type = CONTAM_TYPE_BY_PARAM[param];
    entries.push({ param, type, icon: CONTAM_TYPE_ICON[type], count: value * POLLUTION_PER_DANGER_POINT });
  });
  // 상한 초과분은 뒤쪽 항목부터 깎는다 (앞 = 저항/엔트로피 쪽을 우선 남긴다)
  let total = entries.reduce((sum, e) => sum + e.count, 0);
  for (let i = entries.length - 1; i >= 0 && total > MAX_POLLUTION_PER_SWIPE; i--) {
    const cut = Math.min(entries[i].count, total - MAX_POLLUTION_PER_SWIPE);
    entries[i].count -= cut;
    total -= cut;
  }
  return { total, entries: entries.filter((e) => e.count > 0) };
 }
 const makePollutionCard = (type, level, templates) => {
  const grade = pickGrade(level);
  // 등급별 초안이 아직 비어 있는 타입이 있을 수 있으므로 같은 타입 전체로 폴백한다.
  const pool = templates.filter((t) => t.type === type && t.grade === grade);
  const fallback = pool.length > 0 ? pool : templates.filter((t) => t.type === type);
  if (fallback.length === 0) return null;
  const template = fallback[Math.floor(Math.random() * fallback.length)];
  return { ...template, id: `${template.id}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}` };
 };
 /**
 * previewPollution()의 entries를 실제 카드 인스턴스로 만든다.
 * 등급은 "그 파라미터의 현재 단계"로 뽑으므로, 위험이 높을수록 더 흉악한 오염이 들어온다.
 */
 export function buildPollutionCards(entries, params, templates) {
  const out = [];
  entries.forEach(({ param, type, count }) => {
    for (let i = 0; i < count; i++) {
      const card = makePollutionCard(type, params[param], templates);
      if (card) out.push(card);
    }
  });
  return out;
 }
 /** 정례회의 종료 시 주입분 — 파라미터 단계에 비례한 장수로 뽑는다. */
 export function buildCouncilPollutionCards(params, templates) {
  const entries = [];
  Object.entries(CONTAM_TYPE_BY_PARAM).forEach(([param, type]) => {
    const level = params[param] || 0;
    if (level < 1) return;
    entries.push({ param, type, icon: CONTAM_TYPE_ICON[type], count: councilPollutionCount(level) });
  });
  return buildPollutionCards(entries, params, templates);
 }
 /**
 * 현재 결재 위치 기준 2~4장 뒤에 오염 카드를 끼워 넣는다.
 * 덱은 인덱스를 순환(modulo)하며 도는 풀이므로, currentIdx는 항상 덱 범위 안의 값이어야 한다.
 */
 export function insertIntoDeck(deck, currentIdx, newCards) {
  const next = [...deck];
  newCards.forEach((card) => {
    const span = INJECT_OFFSET_MAX - INJECT_OFFSET_MIN + 1;
    const offset = INJECT_OFFSET_MIN + Math.floor(Math.random() * span);
    next.splice(Math.min(next.length, currentIdx + offset), 0, card);
  });
  return next;
 }
 /** 요약 문자열: "🌀 신화 x2 · 😱 사회공황" */
 export const describePollution = (entries) =>
  entries.map((e) => `${e.icon} ${e.type}${e.count > 1 ? ` x${e.count}` : ''}`).join(' · ');
--- a/기획서.md
+++ b/기획서.md
@@ -84,8 +84,6 @@
 				- 우: 위험 단계 (엔트로피, 내부 저항, 위험 수용 계수) 상승
 		- 공통 획득
 			- 내러티브 태그: 스토리 전달 + 엔딩 조건 중 하나
 				- 연대기 시스템 (Chronicle)
 				    - 누적된 내러티브 태그를 터치하면, 플레이어가 지금까지 세상을 어떻게 망치고 구해왔는지 연대기 형태의 히스토리/텍스트로 확인 가능. (플레이어의 목적의식과 내러티브 몰입도 강화)
 			- 성향 태그: 파벌과의 우호도 변화
 		- 덱 오염 (토큰을 마이너스)
 			- 그림자 의회가 끝날때 마다 엔트로피 단계(1~5단계)에 따라 '신화 카드' 추가
@@ -174,6 +172,9 @@
 			- 태그 0~3개: 페이즈1 (사태 파악 및 은폐의 시작)
 			- 태그 4~7개: 페이즈2 (프로젝트 가동 및 이사회의 개입 본격화)
 			- 태그 8개 이상: 페이즈3 (통제 불능의 사태 및 종말의 카운트다운)
 	- 연대기 (Chronicle)
 		- 국장이 결재한 카드와 그에 대한 선택(좌/우/위)을 시간순으로 기록하는 결정 장부. 내러티브 태그가 '세계의 결과'라면, 연대기는 '국장의 원인 이력'이다.
 		- 내러티브 태그(세계의 상흔)와는 별도의 데이터·별도의 진입점(로그 버튼)으로 관리한다.
 ## 라운드 플로우차트 (Round Flowchart)
--- a/docs/Project
+++ b/docs/Project
@@ -19,7 +19,7 @@ UN 상임이사국과 글로벌 메가코프들이 비밀리에 설립한 초법
 **모래성 무너뜨리기 (The Sandcastle)**
 국장은 재력, 무력, 감시라는 영구 자원 태그를 모아 거대한 통제 엔진을 구축합니다. 하지만 세계의 엔트로피가 차오를수록, 이사회의 표적 규약과 쏟아지는 뉴스 속보가 당신이 공들여 쌓은 방어벽을 잔인하게 허물어뜨립니다.
 **연대기의 편찬 (The Chronicle)**
-국장은 끝없이 반복되는 루프 속에서 단편적인 무작위 내러티브 태그들을 마주합니다. 국장은 이 혼란스러운 단서들을 수집(Collect)하고, 얽혀있는 파벌 간의 인과를 조직화(Organize)하며, 멸망의 진정한 원인을 추출(Distill)하여 최종 결재라는 형태로 세계에 표현(Express)해 나갑니다. 이 지독한 과정은 플레이어의 목적의식을 강화하는 한 편의 텍스트 연대기(Chronicle)로 기록됩니다.
+국장의 모든 결재는 되돌릴 수 없는 기록으로 남습니다. 세계의 상흔(내러티브 태그)이 '무엇이 벌어졌는가'를 말한다면, 연대기는 '누가 그렇게 결정했는가'를 말합니다. 플레이어는 회차가 끝난 뒤 이 장부를 되짚으며, 멸망이 사고가 아니라 자신의 서명들이 쌓인 결과였음을 마주합니다.
 ## 3. 메인 시나리오: 종말의 3단계 페이징 (Story Paging)
 시나리오는 획득한 [내러티브 태그]의 누적 개수에 따라 기구의 토큰 경제가 파탄 나는 3가지 페이즈로 진행됩니다.
 ### 페이즈 1: 사태 파악 및 은폐의 시작 (태그 0~3개)
--- a/docs/ProjectSS
+++ b/docs/ProjectSS
@@ -65,7 +65,9 @@
 - **페이즈 3 (태그 8개 이상)**: 종말 카운트다운. 극한의 오염 카드와 뉴스 속보가 쏟아지는 자원 고갈의 생존 구간.
 ## 5. 최종 목표: 멀티 엔딩 매트릭스 도감
-다양한 엔딩을 수집하여 [연대기 시스템]을 통해 플레이어의 히스토리를 시각화합니다.
+다양한 엔딩을 수집하여 도감에 기록합니다. 회차의 여정은 두 축으로 분리되어 기록됩니다.
 - **연대기(Chronicle)**: 국장이 결재한 카드와 좌/우/위 선택을 시간순으로 기록한 결정 이력.
 - **내러티브 태그**: 그 결재의 결과로 세계에 남은 상흔이자 엔딩 조건. 연대기와는 별개로 관리·저장됩니다.
 - **수집해야 할 엔딩 카테고리**:
    - 기본 4대 붕괴 엔딩 (사임, 멸망, 문명 붕괴, 탄핵)
--- a/docs/ProjectSS
+++ b/docs/ProjectSS
@@ -46,7 +46,7 @@
 - **작업 항목**:
    - **엔딩 분기 시스템**: 파라미터 5단계 도달 시, 현재 보유한 토큰/자원 태그를 검사하여 기본 붕괴 엔딩 또는 변주된 엔딩으로 분기시키는 판별기 구현.
    - **특수 엔딩 트리거**: 극단적 파라미터, 내러티브 연쇄, 의회 정치 조건 달성 시 발동하는 조기 엔딩 이벤트 구현.
-    - **도감 및 연대기(Chronicle)**: 해금된 엔딩을 저장하는 도감 UI 구현 및 이번 회차에서 획득한 내러티브 태그를 히스토리 텍스트로 나열해 주는 연대기 기능 구현.
+    - **도감 및 연대기(Chronicle)**: 해금된 엔딩을 저장하는 도감 UI 구현. 연대기 기능(결재 카드·선택 이력 로그)과 내러티브 태그 뷰('세계의 상흔', 태그 키워드+스니펫 히스토리)를 별도의 UI/팝업으로 분리 구현.
 ## Phase 5: 비주얼 폴리싱 및 다이제틱 UX
 핵심 로직이 모두 검증된 후, 기획 단계에서 논의된 추상적이고 몰입감 있는 피드백을 적용합니다.
--- a/docs/ProjectSS
+++ b/docs/ProjectSS
@@ -34,7 +34,7 @@
 - **영구 자원 태그 (1코스트 할인 효과)**: 재력/자본 태그(건물), 무력/조직 태그(방패), 감시/언론 태그(눈동자).
 ### C. 엔딩 도감 및 연대기 (Chronicle)
- **연대기 시스템**: 누적된 내러티브 태그를 통해 플레이어가 세상을 어떻게 망치고 구해왔는지 히스토리를 확인하여 몰입도를 강화합니다.
+- **연대기 시스템**: 국장이 결재한 카드와 좌/우/위 선택을 시간순으로 기록한 결정 장부입니다. 세계가 어떻게 되었는가(세계의 상흔)는 내러티브 태그가 별도로 담당하며, 연대기는 '누가 그렇게 결정했는가'라는 원인 축을 기록해 몰입도를 강화합니다.
 - **멀티 엔딩 매트릭스**: 기본 붕괴 엔딩 외에도 특정 자원/토큰과 결합된 변주 엔딩, 극단적 파라미터 조기 엔딩, 내러티브 연쇄 엔딩, 의회 정치 엔딩 등 수십 가지의 결과를 수집해야 합니다.
--- a/유저플로우.md
+++ b/유저플로우.md
@@ -82,5 +82,5 @@
    - 조건에 부합하는 가장 높은 우선순위의 텍스트와 연출 출력.
 4. **도감 동기화**
    - 출력된 엔딩을 계정 도감 데이터에 '해금(Unlocked)' 처리.
-    - 이번 회차의 연대기 히스토리 보관.
+    - 이번 회차의 [연대기](결재 결정 이력)와 [내러티브 태그](세계 상흔) 목록을 각각 분리 저장.
--- a/와이어프레임.md
+++ b/와이어프레임.md
@@ -47,16 +47,26 @@
 - `[🩸 내부 감사] (인력 소모 / 기권 유도)`
 ## 3. 오버레이 및 팝업 (Overlays & Popups)
-### 3.1. 연대기 시스템 (Chronicle Popup)
+### 3.1. 세계의 상흔 팝업 (World's Scars Popup)
-메인 화면 좌상단의 내러티브 태그 터치 시 노출.
+메인 화면 좌상단의 `[📖 4/8]` 카운터 터치 시 노출.
- **타이틀**: 국장의 연대기
+- **타이틀**: 세계의 상흔
- **본문**: 획득한 [내러티브 태그]의 스토리가 시간순으로 나열된 텍스트 목록 (세상을 망치고 구한 히스토리).
+- **본문**: 획득한 [내러티브 태그]의 키워드와 스니펫이 시간순으로 나열된 텍스트 목록 (세상이 어떻게 망가졌는가).
-### 3.2. 엔딩 결산 화면 (Ending Result Screen)
+### 3.2. 연대기 팝업 (Chronicle Popup, 신규)
 메인 화면의 별도 로그 버튼 터치 시 노출. '세계의 상흔' 팝업과는 별개의 진입점·별개의 데이터.
 - **타이틀**: 국장의 연대기
 - **본문**: 국장이 결재한 카드와 좌/우/위 선택 이력이 시간순으로 나열된 결정 장부.
    ```
    [일상] 오염된 장부 승인
      └ 좌(예산+): 유가족 위로금은 예비비 충당
    ```
 ### 3.3. 엔딩 결산 화면 (Ending Result Screen)
 붕괴 조건 도달 시 출력되는 화면.
 - **타이틀**: `[수집한 엔딩 이름]` (예: 사임, 세계 멸망, 문명 붕괴, 정치적 탄핵 등).
 - **결과 텍스트**: 해당 엔딩에 대한 상세 서사.
 - **원인 요약**: 현재 붕괴 게이지, 특정 자원 태그, 토큰 보유 상황 등 엔딩 발동 조건 표기.
 - **이번 회차 연대기**: 회차 중 결재한 카드와 선택 이력을 요약한 '결정 요약' 블록.
 - **액션**: `[도감에 기록하기 & 다음 회차 시작]` 버튼.
--- a/docs/architecture_design.md
+++ b/docs/architecture_design.md
@@ -1,105 +1,200 @@
-# Project SS - 파일 및 컴포넌트 구조 설계
+# Project SS — 아키텍처 (구현 실태)
-본 문서는 **"서사형 덱빌딩 게임 시스템 기획서"** 및 **"스토리 바이블"**을 바탕으로, 기존 단일 HTML 파일을 모던 웹 프레임워크(React + Vite + Tailwind CSS + Zustand) 기반으로 마이그레이션 및 고도화하기 위한 디렉토리 및 컴포넌트 구조를 정의합니다.
+> **이 문서는 "제안"이 아니라 "현재 코드가 실제로 어떻게 생겼는가"의 기록이다.**
 > 2026-07-23 기준으로 실제 구현을 확인해 전면 재작성했다.
 > 초기 제안서(React + Vite + **Tailwind + Zustand + TypeScript**)는 상당 부분 채택되지 않았고,
 > 그 내역은 문서 하단 "채택하지 않은 초기 제안"에 남겨 뒀다.
 >
 > 게임 **규칙·수치**의 원본은 이 문서가 아니라 `docs/` 하위 기획서들이다. 여기엔 코드 구조만 적는다.
-## 📂 1. 전체 디렉토리 구조 (Directory Structure)
+---
 ## 1. 기술 스택 (실제)
 `client/package.json` 의존성이 전부다. 목록에 없는 것은 쓰지 않는다.
 | 영역 | 채택 | 비고 |
 |---|---|---|
 | 프레임워크 | **React 19** | 함수 컴포넌트만, 클래스 컴포넌트 없음 |
 | 빌드 | **Vite 8** | `client/`가 프로젝트 루트. npm 명령은 `cd client` 후 실행 |
 | 언어 | **plain JavaScript (`.jsx`)** | TypeScript 미도입 |
 | 스타일 | **컴포넌트별 개별 `.css`** | 글로벌 클래스명. CSS Modules 아님, Tailwind 아님 |
 | 상태관리 | **`useState` / `useEffect`** | 외부 상태관리 라이브러리 없음 |
 | 애니메이션 | **Framer Motion** | 카드 드래그/스와이프 |
 | 아이콘 | **lucide-react** | |
 | CSV 파싱 | **papaparse** | 런타임 파싱 (빌드 타임 변환 아님) |
 | 영구 저장 | **localStorage** | 엔딩 도감 전용 |
 디자인 토큰(컬러/폰트)은 `src/index.css`의 CSS 변수로 정의한다 (`--color-entropy-critical`,
 `--font-typewriter` 등). 컴포넌트 CSS는 이 변수를 참조한다.
 ---
 ## 2. 디렉토리 구조 (실제)
 ```text
-/src
+ProjectSS/
- ├── assets/             # 이미지, 폰트, 아이콘 등 정적 파일
+├── playtest.bat               # 더블클릭 → npm install(최초 1회) + dev 서버 + 브라우저 자동 오픈
- ├── components/         # UI 및 도메인 컴포넌트
+│                                # ASCII 전용 — 한글/chcp를 넣으면 cmd.exe가 배치 파싱을 깨뜨린다
- │    ├── common/        # 공통 UI 요소 (버튼, 모달, 툴팁 등)
+├── CLAUDE.md                 # 작업 규칙 · Phase 상태 (실질적인 단일 진실 공급원)
- │    ├── dashboard/     # 상단 상태창 및 파라미터 표시
+├── ROADMAP.md
- │    ├── gameplay/      # 핵심 게임 루프 (카드 스와이프, 자산 관리)
+├── docs/                     # 기획서 · 스토리 바이블 · 작업지시서 (게임 규칙의 원본)
- │    └── council/       # 주간 의회 시스템 (투표, 법안, 파벌)
+└── client/                   # ★ 실제 앱. npm 명령은 여기서 실행
- ├── constants/          # 게임 내 상수 (파벌 정보, 테마 컬러, 엔딩 조건 등)
+    ├── update_csv.js         # ⛔ 보호 파일 — cards.csv 전처리
- ├── data/               # 초기 데이터 및 시나리오 (CSV/JSON 형식)
+    ├── update_csv_tags.js    # ⛔ 보호 파일 — 내러티브 태그 매핑
- ├── hooks/              # 커스텀 훅 (ex. useSwipe, useVoting)
+    └── src/
- ├── store/              # 전역 상태 관리 (Zustand)
+        ├── main.jsx                 (10줄)  진입점
- ├── types/              # TypeScript 타입 정의 (Card, Faction, State 등)
+        ├── App.jsx                  (13줄)  GameScreen 하나만 렌더 — 라우터 없음
- ├── utils/              # 헬퍼 함수 (엔트로피 계산, 전투/결과 연산 등)
+        ├── index.css                        디자인 토큰(CSS 변수) + 리셋
- ├── App.tsx             # 루트 컴포넌트 (페이지 라우팅 및 전역 상태 주입)
+        ├── assets/                          hero.png 등 정적 파일
- └── main.tsx            # 진입점
+        ├── components/                      ★ flat 구조. 하위 폴더 없음
        │   ├── GameScreen.jsx      (628줄) ★ 상태 허브 + 화면 전환
        │   ├── SwipeCard.jsx       (156줄)  카드 드래그 · 선택지 사전 예고
        │   ├── CouncilScreen.jsx   (220줄)  정례회의(투표 · 개입 액션)
        │   ├── EndingScreen.jsx     (46줄)  엔딩 출력 + 도감 저장
        │   ├── EndingCodex.jsx      (33줄)  엔딩 도감 (localStorage 읽기)
        │   ├── ChroniclePopup.jsx   (63줄)  연대기 + 태그 히스토리
        │   ├── AssetInfoPopup.jsx   (43줄)  자산 상세 · 수동 발동
        │   └── *.css                        컴포넌트당 1개씩 짝을 이룸
        ├── engine/                          ★ React를 모르는 순수 로직
        │   ├── assetEngine.js      (226줄)  자산 트리거→효과→연쇄
        │   └── pollution.js        (154줄)  오염 카드 주입 규칙 · 밸런스 상수
        └── data/
            ├── cards.csv                    카드 원본 (런타임 papaparse 파싱)
            ├── assets.json                  자산 8종 정의
            ├── narrative_tags.json          재사용 태그 풀 10종
            ├── endings.js          (123줄)  엔딩 카탈로그 + 판별 함수
            └── pollution_cards.json         ⚠️ 어디서도 import하지 않음 (레거시)
 ```
 ---
-## 🧩 2. 상세 컴포넌트 구조 (Components Breakdown)
+## 3. 핵심 아키텍처 원칙
-### 2.1 공통 UI (`/components/common`)
+### 3.1 상태는 `GameScreen.jsx` 한 곳에 모은다
 프리미엄한 관료주의 다크/레트로 UI를 구성하는 기본 요소들입니다.
 - `Button.tsx`: 액션 버튼 (결재, 서명 등 텍스처 효과 포함)
 - `Modal.tsx`: 미스터리 보드, 법안 확인 등을 위한 공통 팝업
 - `ProgressBar.tsx`: 게이지 바 (엔트로피, 내부 저항 등)
 - `AlertToast.tsx`: 패시브 효과 연쇄나 비상 사태를 알리는 시스템 메시지 (우측 하단/상단 노출)
-### 2.2 대시보드 (`/components/dashboard`)
+전역 스토어가 없다. 게임 상태 전부가 `GameScreen`의 `useState`로 존재하고, 하위 컴포넌트는
-플레이어의 현재 상태(국장실 요약)를 보여줍니다.
+props로 값과 콜백을 받는 프레젠테이션 계층이다.
 - `StatusHeader.tsx`: 현재 주차(Week), 일차(Day), 주간 아젠다 노출
 - `ParameterBoard.tsx`: 3대 핵심 파라미터 게이지 (내부 저항, 엔트로피, 위험 수용 계수)
 - `ResourcePanel.tsx`: 3대 토큰(예산, 인력, 정보) 및 자원 태그(재력, 무력, 감시) 현황
 - `FactionDonut.tsx`: 8대 파벌의 의회 지분율 및 우호도를 시각화하는 도넛 차트
-### 2.3 게임플레이 (`/components/gameplay`)
+```
-일일 업무(결재 단계)를 처리하는 핵심 루프 컴포넌트입니다.
+GameScreen (상태 소유)
- `DeskView.tsx`: 국장실 책상 배경 및 전체 레이아웃 래퍼
+ ├── SwipeCard        ← card, onSwipe, phase
- `CardSwiper.tsx`: 틴더 스타일의 스와이프 인터페이스 (Tinder-like Swipe)
+ ├── CouncilScreen    ← params/tokens/tags + setter, onResolve   ※ setter를 직접 넘기는 유일한 예외
-  - 좌/우 스와이프에 따른 예측 결과(예상 토큰/파라미터 증감)를 오버레이로 표시
+ ├── EndingScreen     ← ending, narrativeTags
- `DilemmaCard.tsx`: 개별 딜레마/위기 서류. (제목, 내용, 플레이버 텍스트, 결재/반려 스탬프 이펙트)
+ ├── ChroniclePopup   ← chronicle, acquiredTags
- `AssetManager.tsx`: 보유 중인 자산(파이프라인, 성질 변환 등 덱 압축 장치) 관리 모달
+ └── AssetInfoPopup   ← instance, def, onActivate
 ### 2.4 의회 시스템 (`/components/council`)
 매주 5일차 종료 후 진행되는 정치 시스템 컴포넌트입니다.
 - `CouncilPhase.tsx`: 주간 의회 화면 메인 컨테이너
 - `BillDisplay.tsx`: 상정된 법안(이득 규약 vs 표적 규약) 비교 UI
 - `VotingBoard.tsx`: 13명의 임원(상임 이사 8명 + 글로벌 지부장 5명)의 예상 투표 현황 및 게이지 바
 - `InterventionPanel.tsx`: 국장의 개입 액션 (매수, 장부 조작, 내부 감사) 버튼 및 리스크 안내 패널
 ### 2.5 뷰 / 씬 (Views/Scenes)
 - `LoadingScreen.tsx`: 초기 데이터 파싱 및 게임 세팅 화면
 - `GameScreen.tsx`: 인게임 전체 메인 화면 (대시보드 + 게임플레이 결합)
 - `EndingScreen.tsx`: 멀티 엔딩 매트릭스에 따른 최종 결과 출력 (위대한 침묵, 신인류의 탄생 등)
 ---
 ## 💾 3. 전역 상태 구조 (Global State - Zustand 제안)
 관리가 복잡한 게임 데이터를 효율적으로 다루기 위해 상태를 나눕니다.
 ```typescript
 interface GameState {
  // 시간/페이즈 관리
  week: number;
  day: number;
  phase: 'DAY_WORK' | 'COUNCIL' | 'ENDING';
  // 핵심 파라미터
  entropy: number;       // 0~100%
  internalResistance: number; // 0~100%
  riskTolerance: number;      // 0~100%
  // 자원
  tokens: { budget: number; personnel: number; info: number; };
  tags: { finance: number; force: number; surveillance: number; };
  // 덱 및 내러티브
  narrativeTags: string[];
  ideologyTags: string[];
  deck: Card[];        // 섞인 오염카드 및 이벤트 풀
  assets: Asset[];     // 덱 압축 파이프라인
  // 파벌 및 의회 (13명의 임원 정보 포함)
  factions: FactionState[];
  currentBills: Bill[];
 }
 ```
 **트레이드오프:** 파일이 628줄까지 커졌고 관심사가 섞여 있다. 다만 게임 규칙이 아직 확정되지
 않아 잦은 수정이 예상되는 그레이박스 단계에서는 "한 파일만 보면 전체 흐름을 안다"는 이점이
 분할 비용보다 컸다. Phase 5 이후 재검토 대상이다.
 ### 3.2 규칙 계산은 `engine/`의 순수 함수로 뺀다
 `engine/`은 React·훅·JSX를 전혀 import하지 않는다. 평범한 객체를 받아 평범한 객체를 돌려준다.
 이 경계 덕분에 **게임을 띄우지 않고 밸런스를 검증할 수 있다.** 실제로 오염 카드 물량 조정 시
 `node` 스크립트로 `pollution.js`를 직접 import해 600회 시뮬레이션을 돌려 변경 전후를 비교했다.
 새 규칙 모듈을 만들 때도 이 성질을 깨지 말 것.
 ### 3.3 `world` 스냅샷 패턴 (자산 엔진)
 `assetEngine`은 상태를 직접 만지지 않는다. `GameScreen`이 현재 state를 복사한 `world` 객체를
 만들어 넘기고, 엔진이 변형한 결과를 다시 state로 커밋한다.
 ```js
 const world = buildAssetWorld();      // state 복사 → { cards, tokens, tags, params, owned, quarantine, logs }
 AssetEngine.onPollutionDraw(world, card.type);
 AssetEngine.onApprovalTick(world, nextTurns);
 commitAssetWorld(world);              // 결과를 setState로 일괄 반영
 ```
 > **⚠️ 반드시 지킬 것:** 한 이벤트 처리 안에서 `buildAssetWorld`/`commitAssetWorld` 쌍을
 > **정확히 한 번만** 쓴다. 두 번 짝지어 부르면 두 번째 `build`가 아직 리렌더되지 않은
 > 낡은 클로저 state를 복사하므로, 나중 커밋이 앞의 변경을 덮어써 버린다.
 엔진 훅 지점은 4곳이다: `onApprovalTick`(결재마다) · `onPollutionDraw`(오염 카드 등장) ·
 `onSwipeLeft`(좌 스와이프 격리) · `onCouncilEnd`(정례회의 종료). 연쇄 발동은 `fireEvent`가
 깊이 상한 10으로 처리한다.
 ### 3.4 예고 · 실행 · 알림은 같은 함수를 공유한다
 플레이어에게 미리 보여준 숫자와 실제 결과가 어긋나면 정보 자체를 신뢰하지 않게 된다.
 그래서 오염 주입량은 `pollution.js`의 `previewPollution()` 하나가 단일 기준이다.
 ```
 SwipeCard  "☣ 오염 카드 +2" 사전 경고  ─┐
 GameScreen 실제 덱 주입                 ─┼─ 모두 previewPollution() 사용
 GameScreen "2건 유입" 사후 토스트        ─┘
 ```
 이 함수를 우회해 오염 카드를 만들지 말 것. 밸런스 수치는 `pollution.js` 상단 상수 블록에 모여 있다.
 ---
-## 🚀 4. 추천 기술 스택
+## 4. 데이터 흐름
- **Framework**: `React` (컴포넌트 분리를 통한 복잡한 UI 관리)
+
- **Build Tool**: `Vite` (빠른 HMR 및 빌드 속도)
+```
- **Styling**: `Tailwind CSS` (유틸리티 클래스로 빠른 UI 구현) + CSS Animations (스와이프 액션, 팝업 등)
+cards.csv ──(?raw import)──> papaparse ──> buildCardFromRow() ──> 덱 배열
- **State Management**: `Zustand` (가볍고 직관적인 전역 상태 관리)
+                                                                    │
- **Interactions**: `Framer Motion` 또는 `react-spring` (부드러운 카드 스와이프 액션 및 몰입감 있는 애니메이션)
+narrative_tags.json ──> left_tag/right_tag id로 조인 ────────────────┘
- **Type Checking**: `TypeScript` (복잡한 자원 계산과 이벤트 분기에 대한 안정성 보장)
+```
 - **카드 데이터는 런타임에 파싱한다.** `import cardsCsvRaw from '../data/cards.csv?raw'` 후
  브라우저에서 papaparse로 처리한다. 빌드 타임 변환 단계가 없으므로 CSV를 고치면 새로고침만으로 반영된다.
 - 덱은 **인덱스를 순환(modulo)하는 풀**이다. 소진되어 없어지지 않고 계속 돈다.
  `currentCardIndex`는 매 결재마다 최종 덱 길이로 정규화해 범위 안에 유지한다 — 주입/소각으로
  길이가 변하기 때문이다.
 - 카드 풀은 페이즈별로 분리한다: 페이즈1(일상/위기)로 시작하고, 내러티브 태그 3종 획득 시
  페이즈2(작전/극비) 풀이 덱에 삽입된다.
 - 오염 카드(신화/조직저항/사회공황/이사회압박)는 `contaminationTemplates`로 따로 보관하다가
  주입 시점에 복제해 고유 id를 붙인다.
 ---
 ## 5. 화면 전환
 라우터가 없다. `GameScreen`이 상태를 보고 조기 return으로 화면을 고른다.
 ```js
 if (gameOver)    return <EndingScreen ... />;
 if (showCouncil) return <CouncilScreen ... />;
 if (cards.length === 0) return <div>데이터를 불러오는 중...</div>;
 return ( /* 결재 화면 */ );
 ```
 팝업(연대기·자산 정보·도감)은 화면을 갈아끼우지 않고 조건부 오버레이로 렌더한다.
 ---
 ## 6. 영구 저장
 localStorage에 저장하는 것은 **엔딩 도감뿐이다.** 세이브/로드 기능은 없고, 게임오버 시
 `window.location.reload()`로 재시작한다.
 - 키: `ss_endings_v2` (`EndingCodex.jsx`에서 `ENDINGS_STORAGE_KEY`로 export)
 - 값: 해금된 엔딩 **id** 배열. 구버전 `ss_endings`는 제목 문자열 기반이라 폐기했고 호환되지 않는다.
 ---
 ## 7. 채택하지 않은 초기 제안
 초기 제안서에 있었으나 **의도적으로 도입하지 않은** 것들이다. 되살리려면 CLAUDE.md 규칙부터 바꿔야 한다.
 | 제안 | 현재 | 사유 |
 |---|---|---|
 | Tailwind CSS | 컴포넌트별 `.css` | 관료제 다크 UI는 유틸리티 클래스보다 커스텀 CSS가 손에 맞았다 |
 | Zustand | `useState` | 상태가 한 컴포넌트에 모여 있어 전역 스토어의 값어치가 없다. **도입 금지** |
 | TypeScript | plain JS | 그레이박스 단계의 잦은 스키마 변경 대비 타입 유지비가 컸다 |
 | `store/ hooks/ types/ utils/ constants/` | 없음 | 규칙 로직은 `engine/`으로 통합 |
 | `components/{common,dashboard,gameplay,council}/` | flat | 컴포넌트 7개뿐이라 계층이 불필요 |
 | 8대 파벌 도넛 차트 | 텍스트 목록 | 파벌은 12종 풀에서 5명 선발 방식으로 변경됨 |
 ---
 ## 8. 알려진 부채
 - **`GameScreen.jsx` 628줄** — 상태 허브 + 화면 전환 + 스와이프 처리 + 파벌 계산이 한 파일에 있다.
 - **`data/pollution_cards.json` 미사용** — 어디서도 import하지 않는 레거시. 오염 카드는 `cards.csv`에서 온다.
 - **테스트 코드 없음** — 검증은 `engine/` 모듈을 직접 부르는 일회성 node 스크립트로 해 왔다.
 - **`window.location.reload()` 재시작** — 상태 초기화 로직이 따로 없다.
--- a/docs/작업지시서/내러티브태그_시스템_작업지시서.md
+++ b/docs/작업지시서/내러티브태그_시스템_작업지시서.md
@@ -0,0 +1,138 @@
 # 내러티브 태그 시스템 작업 지시서
 > **범위:** (A) 연대기 ↔ 내러티브 태그 개념 분리 + (B) 내러티브 태그 스니펫 시스템 도입.
 >
 > **작업 환경:** Claude Code 세션에서 각 파일을 열어 해당 섹션을 대조 후 반영. 아래 문구는 리포 실제 텍스트와 100% 일치하지 않을 수 있으므로 의미 기준으로 수정할 것.
 >
 > **주의:** `narrative_tags.json` 콘텐츠(스니펫 등)는 자유롭게 초안·반영 가능. 단 `update_csv_tags.js` 등 **보호된 스크립트** 수정이 필요해지면 임의 실행 금지 — 근거 설명 → diff 확인 → 승인 절차를 따를 것.
 ---
 # PART A. 연대기 ↔ 내러티브 태그 분리
 ## A-0. 개념 정의 (기준선)
 | 구분 | 내러티브 태그 (Narrative Tag) | 연대기 (Chronicle) |
 |---|---|---|
 | 본질 | **결과** — 세계가 어떻게 되었는가 | **원인** — 내가 무엇을 어떻게 결재했는가 |
 | 성격 | 명사 · 세계의 상흔 | 동사 · 국장의 결정 로그 |
 | 구성 | 키워드 + 스니펫 + 엔딩 조건 + 페이즈 축 | 등장한 결재 카드 + 플레이어 선택(좌/우/위) 이력 (시간순) |
 | 진입점 | 좌상단 `[📖 4/8]` 카운터 → '세계의 상흔' 팝업 | 별도 로그 버튼 + 엔딩 화면 '이번 회차 결정 요약' |
 **한 줄 기억표:** 태그는 스토리의 '무엇', 연대기는 '어떻게'.
 **스니펫은 태그 쪽에 귀속된다** (태그의 살). 연대기와는 무관.
 ## A-1. 시스템 기획서 — `Project SS 서사형 덱빌딩 게임 시스템 기획서.md`
 1. 내러티브 태그 항목에서 연대기 서술을 **제거**. 태그 항목엔 스토리 전달(스니펫) + 엔딩 조건 + 페이즈 축만 남김.
 2. 시스템 목록에 **독립 항목** 신설:
   > **연대기 (Chronicle):** 국장이 결재한 카드와 그에 대한 선택(좌/우/위)을 시간순으로 기록한 결정 장부. 내러티브 태그가 '세계의 결과'라면, 연대기는 '국장의 원인 이력'이다.
 ## A-2. 스토리 바이블 — `Project SS 스토리 바이블 v3.0.md`
 2장 "연대기의 편찬(The Chronicle)" 테마를 '결정 장부' 관점으로 재서술:
 > 국장의 모든 결재는 되돌릴 수 없는 기록으로 남는다. 세계의 상흔(내러티브 태그)이 '무엇이 벌어졌는가'를 말한다면, 연대기는 '누가 그렇게 결정했는가'를 말한다. 플레이어는 회차가 끝난 뒤 이 장부를 되짚으며, 멸망이 사고가 아니라 자신의 서명들이 쌓인 결과였음을 마주한다.
 ## A-3. 텍스트 와이어프레임 — `ProjectSS 텍스트 와이어프레임.md`
 1. **3.1 팝업 2종 분리:**
   - '세계의 상흔' 팝업: `[📖 4/8]` 터치. 본문 = 태그 키워드 + 스니펫 시간순.
   - '연대기' 팝업(신규): 별도 로그 버튼. 본문 = 결재 카드 + 선택 이력 시간순.
     ```
     [일상] 오염된 장부 승인
       └ 좌(예산+): 유가족 위로금은 예비비 충당
     ```
 2. **3.2 엔딩 화면:** '이번 회차 연대기(결정 요약)' 블록 추가.
 ## A-4~A-7. 나머지 문서 (한두 줄 수정)
 - **비전 문서 4-C:** 연대기 = 결재 카드·선택의 시간순 결정 장부. 세계 상태는 태그가 담당(분리).
 - **PRD 5장:** 연대기(결재 결정 이력) / 내러티브 태그(엔딩·세계 상태) 각주 분리.
 - **유저플로우 4.4:** 연대기와 태그 목록을 **분리 저장**으로 명시.
 - **개발순서 Phase 4:** 연대기 기능과 태그 뷰('세계의 상흔')를 별도 UI로 분리 구현 명시.
 ---
 # PART B. 내러티브 태그 스니펫 시스템
 > 태그 키워드만으로는 서사 체감이 약함. 각 태그에 1~2문장 결과 보고서 스니펫을 붙여 살을 부여한다. 그레이박스 원칙 안에서 순수 텍스트로 검증 가능.
 ## B-1. 스타일 가이드 (확정)
 **톤 3원칙**
 1. **거리 유지** — 감정 형용사·판단·괴수 외형 묘사 금지. 오직 기록·숫자·행정 용어.
 2. **숫자 하나** — 스니펫마다 구체 숫자 정확히 1개(예: 14명, 47건, 15%). 냉혹한 비용편익의 앵커.
 3. **인정 유예** — 스니펫은 위로·의미 부여를 하지 않는다. 인정(감동)은 엔딩/연대기 회고의 몫으로 미룬다.
 **포맷 골격**
 `사실 진술 → 행정적 뒤틀림 → [처리 상태]로 종결`
 - **마침 도장(각인층):** 모든 스니펫은 결재 상태어로 끝난다(처리됨 / 승인됨 / 종결됨 / 이관됨 / 반려됨 / 미반영됨 등). 이 게임만의 문장 지문.
 **유형 2종 — 비율 약 7:3**
 - **시스템형(70%):** 시스템의 부조리가 주인공.
 - **사람형(30%):** 익명의 개인이 데이터 이상치로만 존재('숨겨진 헌신'). 엔딩/변주 콜백용.
 > **설계 근거(참고 문서에서 이식):** 감동 공식(거리+숨겨진 헌신+인정+의미의 역류) — 거리는 문체로 확보, 헌신은 사람형 스니펫에 매설, 인정은 엔딩에서 역류. 로그라이크 루프가 이 역류를 회차마다 반복시킨다.
 ## B-2. 스키마 변경 (승인 필요 항목)
 각 태그 객체에 두 필드 추가:
 ```json
 {
  "id": "quarantine_breach",
  "keyword": "격리 붕괴",
  "snippet": "격리동 전력 계통에 원인 불명의 수동 복구 기록 1건. 해당 시간대 출입 승인자 없음. 요원 K-771, 실종자 명단으로 이관됨.",
  "snippet_type": "human",
  "phase": 2
 }
 ```
 - `snippet` (string): 태그 스니펫 본문.
 - `snippet_type` ("system" | "human"): 콜백 로직용. 엔딩/연대기 회고에서 해당 회차의 human 태그를 골라 "그때 K-771이…" 식 콜백 훅으로 사용.
 > `narrative_tags.json` 직접 수정은 가능. 단 이 파일이 `update_csv_tags.js`로 **생성/가공**되는 구조라면 스크립트에 신규 컬럼 반영이 필요하므로, 그 경우 diff 확인 → 승인 후 진행.
 ## B-3. 샘플 배치 8종 (검토용 기준선)
 **시스템형 (5)**
 | 태그 | 스니펫 |
 |---|---|
 | `[실종]` | 7구역 정수장 근무자 14명 미귀가. 근태 시스템상 전원 '정상 퇴근'으로 **처리됨**. |
 | `[가스 폭발]` | 언론 브리핑상 '노후 배관 폭발'로 발표. 유가족 위로금 항목은 예비비로 충당, 회계 **승인됨**. |
 | `[매수]` | 3분기 감사 중 국장 명의 차명 계좌 3건 인지. 담당 조사관 해외 연수 발령으로 조사 **중단됨**. |
 | `[차원 균열]` | 12구역 상공 '접힘 현상', 위성 미검출. 목격 진술 47건 전원 상이. 관측 장비 오류로 **종결됨**. |
 | `[마녀사냥]` | '이웃이 변이체' 신고 폭증. 실제 변이 확인 0건, 자경단 폭행 사망 3건. 통계 비공개 **결정됨**. |
 **사람형 (3) — 숨겨진 헌신**
 | 태그 | 스니펫 |
 |---|---|
 | `[격리 붕괴]` | 격리동 전력 계통에 원인 불명의 수동 복구 기록 1건. 해당 시간대 출입 승인자 없음. 요원 K-771, 실종자 명단으로 **이관됨**. |
 | `[결손 보전]` | 은폐 자금 결손분 340만, 익명 입금으로 충당. 입금자 추적 '불필요' 판정. 계정 **종결됨**. |
 | `[초과 근무]` | 작전부 잔업 신청 반려 건수 218건. 반려된 요원 전원 무급으로 현장 잔류 확인. 근태 기록 **미반영됨**. |
 ## B-4. 확정 대기 (스타일 가이드 완성 전 결정 필요)
 - [ ] **사람형 헌신 농도:** ⑥~⑧을 더 은근하게 vs 더 드러나게.
 - [ ] **마침 도장 어휘:** 자유 어휘 허용 vs 고정 리스트로 관리(처리됨/승인됨/종결됨/이관됨/반려됨/미반영됨…).
 이 둘이 정해지면 스타일 가이드 확정 → 나머지 태그를 다음 배치들로 진행.
 ---
 # 통합 체크리스트
 **Part A (개념 분리)**
 - [ ] 시스템 기획서: 연대기 독립 항목 승격, 태그 항목 정리
 - [ ] 스토리 바이블: "연대기의 편찬" 결정 장부 관점 재서술
 - [ ] 와이어프레임: 팝업 2종 분리 + 엔딩 결정 요약 블록
 - [ ] 비전/PRD/유저플로우/개발순서: 정의 분리 및 분리 저장/분리 구현 반영
 **Part B (스니펫)**
 - [ ] 스타일 가이드 확정(B-4 두 항목 결정)
 - [ ] `narrative_tags.json` 스키마에 `snippet`, `snippet_type` 추가
 - [ ] (해당 시) `update_csv_tags.js` 신규 컬럼 반영 — diff 승인 후
 - [ ] 샘플 8종 반영 → 검토 → 나머지 태그 배치 확장
 - [ ] 스토리 바이블 톤 앤 매너에 스니펫 3원칙·포맷 규칙 문서화(선택)
--- a/docs/작업지시서/자산시스템_작업지시서.md
+++ b/docs/작업지시서/자산시스템_작업지시서.md
@@ -0,0 +1,128 @@
 # 자산(엔진) 시스템 작업지시서 — 그레이박스 v1
 > **목적**: 발라트로형 엔진 빌딩 검증. 자산 8종을 데이터로 구현하고, 자산 정보 UI 블로커를 해결하여 실제 플레이 테스트가 가능한 상태를 만든다.
 > **원칙**: Greybox First. 수치는 전부 가안이며 튜닝 대상. 비주얼 연출 금지(텍스트/기본 도형만).
 > **주의**: `update_csv_tags.js`, `update_csv.js` 등 파이프라인 스크립트는 수정 금지. 본 작업은 신규 데이터 파일 + 신규 로직 모듈로만 구성한다.
 ---
 ## Part A. 자산 데이터 스키마
 신규 파일 `src/data/assets.json` 생성. 자산 1장의 문법은 **트리거 → 효과 → (선택) 성장**.
 ```json
 {
  "id": "asset_purge_001",
  "name": "문서 파쇄실",
  "grade": "C",                  // C | B | A | S
  "archetype": "purge",          // purge | convert | quarantine | skip
  "trigger": {
    "type": "every_n_approvals", // 트리거 enum (아래 표)
    "params": { "n": 5 }
  },
  "effect": {
    "type": "purge_lowest",      // 효과 enum (아래 표)
    "params": { "count": 1 }
  },
  "growth": null,                // A급 이상만 사용. { "stackOn": "...", "per": 3, "bonus": {...} }
  "risk": null,                  // 부작용. { "param": "risk_tolerance", "amount": 5, "when": "council_end" }
  "faction_link": "scavengers",  // 우호도 연동 파벌 (nullable)
  "description": "결재 5건마다 덱에서 최하 등급 오염 카드 1장을 영구 소각한다.",
  "flavor": "파쇄 용량: 일일 1건. 증설 요청은 3회 반려됨."
 }
 ```
 ### 트리거 enum (v1 범위)
 | type | 의미 | params |
 |---|---|---|
 | `on_pollution_draw` | 오염 카드 드로우 시 | `category`(신화/저항/공황/압박, nullable), `minGrade`(nullable) |
 | `on_swipe_left` | 좌 스와이프 시 | — |
 | `on_token_spend` | 토큰 소모 시 | `tokenType`(nullable) |
 | `every_n_approvals` | 결재 N건마다 | `n` |
 | `on_council_end` | 의회 종료 시 | — |
 | `on_purge` | 오염 카드 소각 시 (연쇄용) | — |
 | `on_convert` | 오염 카드 변환 시 (연쇄용) | — |
 | `on_quarantine_fail` | 격리 실패 복귀 시 (연쇄용) | — |
 | `manual_charge` | 충전식 수동/자동 방패 | `chargeEvery` |
 ### 효과 enum (v1 범위)
 | type | 의미 | params |
 |---|---|---|
 | `purge_lowest` | 최하 등급 오염 소각 | `count` |
 | `convert_to_token` | 오염 → 토큰 환전 | `tokenType`, `amount` |
 | `quarantine` | 오염 격리 (조건 실패 시 강화 복귀) | `failCondition` |
 | `negate_penalty` | 페널티 1회 무효 | `category`(nullable) |
 | `gain_token` | 토큰 생성 | `tokenType`, `amount` |
 | `gain_tag` | 자원 태그 생성 | `tagType`, `amount` |
 | `convert_multiplier` | 변환 산출 배수 (상시) | `multiplier` |
 | `quarantine_fail_to_purge` | 격리 실패 → 영구 소각으로 치환 (규칙 왜곡) | `bonusTag`(nullable) |
 > 구현 노트: 트리거는 게임 이벤트 버스에 리스너로 등록. `on_purge`/`on_convert`/`on_quarantine_fail`은 다른 자산의 효과가 발생시키는 이벤트를 구독하므로, **효과 실행부가 반드시 이벤트를 발행**해야 연쇄가 성립한다. 무한 루프 방지를 위해 결재 1건당 연쇄 깊이 상한 10회.
 ---
 ## Part B. 자산 8종 데이터 (확정 배치 1차)
 ### ① 소각 특화 (faction: scavengers)
 1. **문서 파쇄실** — C급
   - 트리거: `every_n_approvals(5)` / 효과: `purge_lowest(1)`
 2. **소각 처리 대장** — A급
   - 트리거: `on_purge` / 성장: 스택 +1, 스택 3마다 `purge_lowest(1)` 추가 발동
 ### ② 변환 경제 (faction: nexus_traders)
 3. **폐기물 재활용 규정** — C급
   - 트리거: `on_pollution_draw(category: 신화)` / 효과: `gain_token(예산, 2)` (페널티는 정상 적용 후)
 4. **부산물 매각 계약** — B급
   - 효과: `convert_multiplier(2)` 상시 / 리스크: 의회 종료 시마다 위험 수용 계수 +5%
 ### ③ 격리 도박 (faction: occult_collectors)
 5. **임시 격리 컨테이너** — C급
   - 트리거: `on_swipe_left`(발동 선택 가능) / 효과: `quarantine(failCondition: 다음 의회까지 대중 공황 1단계 상승)`
 6. **심연 보관 조례** — S급
   - 트리거: `on_quarantine_fail` / 효과: `quarantine_fail_to_purge(bonusTag: 감시 +1)`
 ### ④ 무효 회피 (faction: field_agents_union — 우호도 **하락** 연동)
 7. **결재 반려 도장** — C급
   - 트리거: `manual_charge(chargeEvery: 10)` / 효과: `negate_penalty(전체)`
 8. **책임 소재 불명 처리** — B급
   - 트리거: 조직 저항 계열 `negate_penalty` 발동 시 / 효과: 인력 토큰 소모 없이 통과 / 리스크: 내부 저항 +3%
 > 수치(5건, 토큰 2, 스택 3, 5%, 3% 등)는 전부 가안. 플레이 테스트 후 일괄 튜닝.
 ---
 ## Part C. UX 블로커 해결 (최우선 선행 작업)
 **현재 문제**: 자산 클릭 시 아무 정보도 표시되지 않음 → 덱압축 시스템 평가 자체가 불가능.
 1. 하단 자산 슬롯의 `Icon_Asset` 탭/클릭 시 정보 팝업 표시:
   - 이름, 등급, 아키타입 아이콘
   - **트리거 조건 → 효과** 를 한 문장으로 (description 필드 그대로)
   - 성장형이면 현재 스택 수치 표시
 2. **자산 발동 시 가시 피드백 (텍스트 로그로 충분)**: 화면 한쪽에 "『문서 파쇄실』 발동 — [하급 신화] 소각됨" 식의 1줄 로그. 발라트로의 조커 점멸에 해당하는 최소 구현. 연쇄 발동 시 순서대로 줄줄이 출력되어야 "엔진이 돌아간다"는 감각이 생긴다.
 3. 그레이박스 기준이므로 애니메이션 불필요. 텍스트 로그 + 팝업만.
 ---
 ## Part D. 플레이 테스트 체크리스트
 구현 완료 후 아래를 검증한다.
 - [ ] **역전 엔진 성립**: 3번(재활용 규정) + 1번(파쇄실) 조합 시, 오염이 늘수록 자원이 돌고 덱이 정화되는 체감이 있는가?
 - [ ] **연쇄 가시성**: 2번(소각 처리 대장) 보유 시 소각→스택→추가 소각 연쇄가 로그로 읽히는가?
 - [ ] **S급 킹핀**: 6번(심연 보관 조례) 획득 전후로 격리 자산의 가치 평가가 뒤집히는가? (획득 전: 격리 기피 / 획득 후: 격리 남발)
 - [ ] **무효 빌드의 풍자 체감**: 7+8번 조합으로 "덱은 더럽지만 아무 일도 안 일어나는" 상태가 만들어지는가?
 - [ ] **오버파워 확인**: 페이즈 3에서 엔진이 오염 주입 속도를 이기는 순간이 오는가? (이겨야 정상 — 발라트로 모델)
 - [ ] 연쇄 깊이 상한(10회)에 걸리는 케이스가 있는가?
 ## 범위 외 (다음 배치)
 - 의회 압박 강화(안건 예고제, 표차 가시화) — 별도 작업지시서로 분리 예정
 - 하이브리드 아키타입 자산 및 A/S급 보강 (2차 배치)
 - 자산 획득 경로(극비 프로젝트 보상 테이블) 튜닝
--- a/playtest.bat
+++ b/playtest.bat
@@ -0,0 +1,46 @@
@echo off
 REM ProjectSS playtest launcher.
 REM ASCII only on purpose: Korean text inside a .bat is mangled by cmd.exe codepage
 REM handling, and calling "chcp" mid-script corrupts the batch parser itself.
 title ProjectSS - playtest
 cd /d "%~dp0client"
 where npm >nul 2>nul
 if errorlevel 1 goto no_node
 if not exist node_modules goto install
 goto run
 :install
 echo.
 echo   First run - installing dependencies. This takes 1-2 minutes.
 echo.
 call npm install
 if errorlevel 1 goto install_failed
 :run
 echo.
 echo   Starting dev server. Your browser will open automatically.
 echo   Close this window or press Ctrl+C to stop.
 echo.
 call npm run dev -- --open
 echo.
 echo   Server stopped.
 pause
 exit /b 0
 :no_node
 echo.
 echo   [ERROR] Node.js is not installed.
 echo   Install the LTS build from https://nodejs.org and run this again.
 echo.
 pause
 exit /b 1
 :install_failed
 echo.
 echo   [ERROR] npm install failed. See the messages above.
 echo.
 pause
 exit /b 1