Upload 140 files

.gitattributes

@@ -39,3 +39,12 @@ web/assets/인물/카르밀라[[:space:]]가면.png filter=lfs diff=lfs merge=lf
 web/assets/인물/카르밀라.png filter=lfs diff=lfs merge=lfs -text
 web/assets/플래이[[:space:]]이미지/1.png filter=lfs diff=lfs merge=lfs -text
 web/assets/플래이[[:space:]]이미지/4.png filter=lfs diff=lfs merge=lfs -text
+web/assets/배경/식당.png filter=lfs diff=lfs merge=lfs -text
+web/assets/배경/안개[[:space:]]숲.png filter=lfs diff=lfs merge=lfs -text
+web/assets/배경/폐허성당.png filter=lfs diff=lfs merge=lfs -text
+web/assets/오노마x소락_방향/개요2.png filter=lfs diff=lfs merge=lfs -text
+web/assets/오노마x소락_방향/개요3.png filter=lfs diff=lfs merge=lfs -text
+web/assets/인물/가정교사.png filter=lfs diff=lfs merge=lfs -text
+web/assets/인물/보모.png filter=lfs diff=lfs merge=lfs -text
+web/assets/인물/아버지.png filter=lfs diff=lfs merge=lfs -text
+web/assets/플래이[[:space:]]이미지/2.png filter=lfs diff=lfs merge=lfs -text

content/beatcards/E01.yaml

@@ -104,7 +104,7 @@ cards:
 
       *— (오후의 해자 산책. 유저가 무엇을 묻든 아버지는 자상하게 응한다. 어머니·외로움으로 화제가 닿으면, 그는 답을 다 잇지 못한다.)*'
   - type: character_dialogue
-    speaker: 유저
+    speaker: 로라
     text: 어머니는… 어떤 분이셨어요?
     anchor: true
   - type: prose

engine/router.py

@@ -39,6 +39,33 @@ IMAGE_MAP = {
     "E06-10": "/assets/배경/침실.png",          # 도달점 — 두 점 발견
 }
 
+# 인트로 시퀀스 — 표지 "밤을 연다" 뒤, 새 시작에만 (이어 읽기는 건너뜀)
+INTRO_IMAGES = [
+    "/assets/오노마x소락_방향/개요2.png",  # 작품 소개
+    "/assets/오노마x소락_방향/개요3.png",  # 등장인물 소개
+    "/assets/플래이 이미지/2.png",         # 1장 시작
+]
+
+# 화자 초상 (비주얼 노벨 발화 — 참고 연출: 플래이 이미지/7.png). character_dialogue의
+# speaker 기준. 매핑 없는 화자(하인·백작부인·약장수 등)는 이름표만 표시된다
+SPEAKER_PORTRAIT = {
+    "카르밀라": "/assets/인물/카르밀라.png",
+    "아버지": "/assets/인물/아버지.png",
+    "마드모아젤": "/assets/인물/가정교사.png",
+    "마담": "/assets/인물/보모.png",
+}
+
+# 장소별 배경 (비주얼 노벨) — 카드 태그 `#장소/X` 기준. 매핑 없는 장소(정원·화랑·서재 등)는
+# 직전 배경 유지. 에셋이 생기면 여기 한 줄 추가 + scripts/sync_assets.py 갱신
+BACKGROUND_MAP = {
+    "침실": "/assets/배경/침실.png",
+    "만찬홀": "/assets/배경/식당.png",
+    "숲길": "/assets/배경/안개 숲.png",
+    "해자": "/assets/배경/성.png",
+    "폐허": "/assets/배경/폐허성당.png",
+    "예배당": "/assets/배경/폐허성당.png",
+}
+
 app = FastAPI(title="carmilla-demo")
 
 _repo = ContentRepository(ROOT / "content")
@@ -49,6 +76,24 @@ _CUT_IDS = {cid for cid in IMAGE_MAP if _repo.has_card(cid)}
 _SOLO_IDS = _CUT_IDS | {c.id for c in _repo.all_cards() if c.can_chat}
 _pager = Pager(_repo, solo_ids=_SOLO_IDS, cut_ids=_CUT_IDS)
 
+
+def _partition_backgrounds() -> list[Optional[str]]:
+    """파티션별 유효 배경 — 카드의 첫 `#장소/` 태그가 매핑되면 갱신, 아니면 직전 배경 유지.
+    파티션 순서(전역)의 순수 함수라 경로·복원과 무관하게 결정적."""
+    bgs: list[Optional[str]] = []
+    current: Optional[str] = None
+    for part in _pager.partitions:
+        for cid in part:
+            place = next((t.split("/", 1)[1] for t in _repo.get_card(cid).tags
+                          if t.startswith("#장소/")), None)
+            if place and place in BACKGROUND_MAP:
+                current = BACKGROUND_MAP[place]
+        bgs.append(current)
+    return bgs
+
+
+_PART_BG = _partition_backgrounds()
+
 _pocket = PocketService(
     _repo, plugins=[TurnLoggingPlugin(PlaylogRepository(ROOT / "logs" / "playlog.jsonl"))])
 _playdb = PlaySessionRepository(ROOT / "data" / "sessions.db")
@@ -104,7 +149,7 @@ def _step_json(ps: PlaySession) -> dict:
     page = ps.last_step
     if page.ending is not None:
         return {"card": None, "narration": [], "choices": [], "can_chat": False,
-                "image": None,
+                "image": None, "background": None,  # 엔딩은 배경을 걷어낸다
                 "progress": {"index": _pager.display_total, "total": _pager.display_total},
                 "ending": {"id": page.ending.id, "label": page.ending.label,
                            "description": page.ending.description}}
@@ -113,11 +158,14 @@ def _step_json(ps: PlaySession) -> dict:
         # id는 페이지 끝 카드(선택·채팅·진행 기준), 제목·에피소드·컷은 첫 카드 기준
         "card": {"id": last.id, "title": first.title, "episode": first.episode_id,
                  "episode_title": ps.episode_titles.get(first.episode_id, first.episode_id)},
-        "narration": [{"type": b.type, "text": b.text, "speaker": b.speaker}
+        "narration": [{"type": b.type, "text": b.text, "speaker": b.speaker,
+                       "portrait": (SPEAKER_PORTRAIT.get(b.speaker)
+                                    if b.type == "character_dialogue" else None)}
                       for b in page.narration],
         "choices": [{"label": c.label} for c in page.choices],
         "can_chat": page.can_chat,
         "image": IMAGE_MAP.get(first.id),
+        "background": _PART_BG[_pager.part_of[last.id]],
         "progress": {"index": _pager.display_index(last.id), "total": _pager.display_total},
         "ending": None,
     }
@@ -214,7 +262,8 @@ async def pocket_close(sid: str):
 # ── 메타 (표지 등 프레젠테이션 상수) ────────────────────────
 @app.get("/api/meta")
 async def meta():
-    return {"cover_image": COVER_IMAGE, "title": "카르밀라", "subtitle": "잠들지 않는 밤 · 도입 아크"}
+    return {"cover_image": COVER_IMAGE, "title": "카르밀라", "subtitle": "잠들지 않는 밤 · 도입 아크",
+            "intro_images": INTRO_IMAGES}
 
 
 # ── 정적 프론트 ─────────────────────────────────────────────

scripts/beatcard_convert.py

@@ -0,0 +1,397 @@
+"""비트카드 MD → content/ YAML 변환기 (개발팀 소유).
+
+사용법:
+  .venv/bin/python scripts/beatcard_convert.py <비트카드_폴더> -o content/beatcards
+
+- 입력: 카르밀라/0701_카르밀라/비트카드/ (권위, 대표님 소유 — 내용 변형 금지)
+- 출력: content/beatcards/E##.yaml + R-*.yaml
+- 구조 변환만 한다. 매칭이 불확실한 선택지 결과는 리포트로 표시하고 axis=None으로 남긴다.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+import yaml
+
+# engine.schemas로 즉시 검증하기 위해 저장소 루트를 경로에 추가
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from engine.schemas.beatcard import EpisodeFile, RCard  # noqa: E402
+
+AXIS_MAP = {"신뢰+": "trust", "의심+": "doubt", "중립": "neutral",
+            "흘림": "neutral", "수동": "neutral"}
+GATE_MARKS = {"표면": "all", "심층": "trust_high"}
+
+RE_CARD_HEADER = re.compile(r"^##\s+(?:★\s*)?([A-Z]\d{2}-\d{2}[A-Z]?)\s*[··]\s*(?:★\s*)?([^(\n]+?)(?:\s*\(([^)]*)\))?\s*$", re.M)
+RE_TAG = re.compile(r"`(#[^`]+)`")
+RE_NEXT = re.compile(r"·\s*→\s*([\w가-힣/\-]+)")
+RE_CHOICE_HEADER = re.compile(r"^\*\*▷\s*(.+?)\*\*", re.M)
+RE_CHOICE_LABEL = re.compile(r"\[([^\]]+)\]")
+RE_CHOICE_MOD = re.compile(r"〔([^〕]+)〕")
+RE_CENTER = re.compile(r"❝\s*(.+?)\s*❞", re.S)
+RE_CHAR_DIALOGUE = re.compile(r"^>\s*([가-힣A-Za-z·\s]{1,20}?):\s*[「\"](.+?)[」\"]\s*$")
+RE_OLD_RESULT = re.compile(r"^-\s*\*([^:*]+):\*\s*(.+)$")
+RE_NEW_RESULT = re.compile(r"^〈([^·〉]+)\s*·\s*([^〉]*)〉\s*(.*)$")
+RE_RESULT_NEXT = re.compile(r"→\s*\*{0,2}([A-Z]\d{2}-\d{2}[A-Z]?)\*{0,2}")
+RE_BRANCH_MAP = re.compile(r"([가-힣]+)\s*→\s*\*\*([A-Z]\d{2}-\d{2}[A-Z]?)\*\*")
+RE_RCARD_REF = re.compile(r"R-[가-힣\w]+")
+RE_SECTION_STOP = re.compile(r"^(?:▸\s*노트:|🎬|🖼)")
+RE_STAGE = re.compile(r"^###\s*(\d)단계\s*[—–-]\s*(.+)$", re.M)
+
+
+def _bigrams(s: str) -> set[str]:
+    s = re.sub(r"[^\w가-힣]", "", s)
+    return {s[i:i + 2] for i in range(len(s) - 1)} | set(s)
+
+
+def _match_score(label: str, hint: str, text: str) -> float:
+    """선택지 라벨 ↔ 결과 블록 유사도 (라벨힌트 가중 + 본문 앞부분)."""
+    lb = _bigrams(label)
+    return 3 * len(lb & _bigrams(hint)) + len(lb & _bigrams(text[:60]))
+
+
+class EpisodeParser:
+    def parse(self, text: str, source: str) -> tuple[dict, list[str]]:
+        warnings: list[str] = []
+        m = re.search(r"^#\s+(E\d{2})\s+비트\s*카드\s*[—–-]\s*(.+?)\s*(?:\(v.*)?$", text, re.M)
+        ep_id, ep_title = (m.group(1), m.group(2).strip()) if m else ("UNKNOWN", "")
+
+        cards = []
+        headers = list(RE_CARD_HEADER.finditer(text))
+        for i, h in enumerate(headers):
+            body = text[h.end(): headers[i + 1].start() if i + 1 < len(headers) else len(text)]
+            card, ws = self._parse_card(h.group(1), h.group(2).strip(), (h.group(3) or "").strip(), body)
+            cards.append(card)
+            warnings += [f"{card['id']}: {w}" for w in ws]
+
+        self._resolve_branches(cards, warnings)
+        self._demote_reach_skips(cards, warnings)
+        return {"episode": {"id": ep_id, "title": ep_title, "source": source}, "cards": cards}, warnings
+
+    # ── 카드 한 장 ──────────────────────────────────────────
+    def _parse_card(self, cid: str, title: str, subtitle: str, body: str) -> tuple[dict, list[str]]:
+        ws: list[str] = []
+        lines = body.split("\n")
+
+        # 태그 라인 (첫 '>' 라인)
+        tag_line = next((l for l in lines if l.strip().startswith(">") and "`#" in l), "")
+        tags = RE_TAG.findall(tag_line)
+
+        nxt, next_options = None, []
+        nm = RE_NEXT.search(tag_line)
+        if nm:
+            raw = nm.group(1)
+            if "/" in raw:  # E06-10B/C → [E06-10B, E06-10C]
+                head, *rest = raw.split("/")
+                prefix = head[: head.rfind(head.lstrip("A-Z0-9-")) ] if False else head
+                base = re.match(r"([A-Z]\d{2}-\d{2})", head)
+                next_options = [head] + [(base.group(1) + r) if base and len(r) <= 2 else r for r in rest]
+            else:
+                nxt = raw
+
+        # 축/쇠약 태그
+        axis = None
+        axis_tags = [t for t in tags if t.startswith("#축/")]
+        if axis_tags:
+            v = axis_tags[0][len("#축/"):]
+            axis = AXIS_MAP.get(v)  # "신뢰+·의심+" 같은 복합값 → None (선택지가 결정)
+        frailty = any(t.startswith("#메커니즘/쇠약도") for t in tags)
+        canon = any(t.startswith("#캐논/") for t in tags)
+        status = next((t.split("/", 1)[1] for t in tags if t.startswith("#상태/")), "초안")
+
+        # 본문 절단 (노트/연출/이미지 분리)
+        note = self._grab(body, r"▸\s*노트:\s*(.+?)(?=\n🎬|\n🖼|\n---|\Z)")
+        direction = self._grab(body, r"🎬\s*\*\*연출 포인트:\*\*\s*(.+?)(?=\n🖼|\n---|\Z)")
+        image = self._grab(body, r"🖼\s*\*\*장면 이미지:\*\*\s*(.+?)(?=\n---|\Z)")
+
+        # 선택지 라벨
+        choices: list[dict] = []
+        ch = RE_CHOICE_HEADER.search(body)
+        if ch:
+            seg = ch.group(1)
+            mods = RE_CHOICE_MOD.findall(seg)
+            for lab in RE_CHOICE_LABEL.findall(seg):
+                choices.append({"label": lab.strip(), "modifiers": mods, "axis": None,
+                                "result": "", "next": None})
+
+        # 내레이션 + 결과 블록
+        narration, results = self._parse_blocks(lines, tag_line, ws)
+
+        # 결과 블록 ↔ 선택지 매칭
+        if choices and results:
+            self._match_results(choices, results, ws)
+        elif results and not choices:
+            ws.append(f"결과 블록 {len(results)}개가 선택지 없이 존재")
+
+        # 분기 매핑 라인 (숨김 → **E06-10C**)은 전체 카드 파싱 후 후처리 (타깃 카드 본문 필요)
+        branch_hints = RE_BRANCH_MAP.findall(body)
+
+        r_refs = sorted(set(RE_RCARD_REF.findall(body)))
+
+        card = {
+            "id": cid, "title": title, "subtitle": subtitle, "tags": tags,
+            "status": status, "canon": canon, "next": nxt, "next_options": next_options,
+            "axis": axis, "frailty": frailty, "narration": narration, "choices": choices,
+            "r_card_refs": r_refs, "note": note, "direction": direction, "image": image,
+        }
+        if branch_hints:
+            card["_branch_hints"] = branch_hints  # 후처리용 임시 키 (저장 전 제거)
+        return card, ws
+
+    def _demote_reach_skips(self, cards: list[dict], warnings: list[str]):
+        """canon 도달점 우회 방지 — 선택지 next가 하류 분기카드의 옵션이면
+        preset_branch로 강등하고 정상 경로(card.next)를 따르게 한다."""
+        by_id = {c["id"]: c for c in cards}
+        for card in cards:
+            for ch in card["choices"]:
+                target = ch.get("next")
+                if not target:
+                    continue
+                cur, hops = card, 0
+                while cur and cur.get("next") in by_id and hops < 6:
+                    cur = by_id[cur["next"]]
+                    hops += 1
+                    if target in cur.get("next_options", []) and cur["id"] != target:
+                        ch["next"] = None
+                        ch["preset_branch"] = target
+                        warnings.append(
+                            f"{card['id']}: '{ch['label'][:14]}…' next={target}는 "
+                            f"도달점 {cur['id']} 우회 → preset_branch로 강등")
+                        break
+
+    def _resolve_branches(self, cards: list[dict], warnings: list[str]):
+        """분기 매핑 후처리 — 타깃 카드의 첫 지문과 선택지 라벨을 대조해 1:1 배정."""
+        by_id = {c["id"]: c for c in cards}
+        for card in cards:
+            hints = card.pop("_branch_hints", None)
+            if not hints:
+                continue
+            used = set()
+            for hint, target in hints:
+                tgt = by_id.get(target)
+                tgt_text = tgt["narration"][0]["text"] if tgt and tgt["narration"] else ""
+                cands = [c for i, c in enumerate(card["choices"]) if i not in used]
+                if not cands:
+                    warnings.append(f"{card['id']}: 분기 '{hint}→{target}' 배정할 선택지 없음")
+                    continue
+                best = max(cands, key=lambda c: _match_score(c["label"], hint, "")
+                           + _match_score(c["label"], "", tgt_text))
+                score = (_match_score(best["label"], hint, "")
+                         + _match_score(best["label"], "", tgt_text))
+                if score <= 0:
+                    warnings.append(f"{card['id']}: 분기 '{hint}→{target}' 매칭 실패 — 수동 확인 필요")
+                    continue
+                best["next"] = target
+                used.add(card["choices"].index(best))
+
+    # ── 본문 블록 파싱 ──────────────────────────────────────
+    def _parse_blocks(self, lines: list[str], tag_line: str, ws: list[str]):
+        narration, results = [], []
+        buf: list[str] = []
+        gate = "all"
+        in_results = False  # ▷ 헤더 이후는 결과 영역
+        cur_result = None
+
+        def flush_prose():
+            t = "\n".join(buf).strip()
+            buf.clear()
+            if t:
+                narration.append({"type": "prose", "text": t, "gate": gate})
+
+        def close_result():
+            nonlocal cur_result
+            if cur_result:
+                cur_result["text"] = cur_result["text"].strip()
+                results.append(cur_result)
+                cur_result = None
+
+        for raw in lines:
+            line = raw.rstrip()
+            s = line.strip()
+            if not s or s == tag_line.strip() or s.startswith("---"):
+                continue
+            if RE_SECTION_STOP.match(s):
+                break
+
+            if RE_CHOICE_HEADER.match(s):
+                flush_prose()
+                close_result()
+                in_results = True
+                continue
+
+            nr = RE_NEW_RESULT.match(s)
+            if nr:
+                mark, hint, rest = nr.group(1).strip(), nr.group(2).strip(), nr.group(3)
+                if mark in GATE_MARKS:  # 〈표면〉〈심층〉 = 지문 게이트
+                    flush_prose()
+                    gate = GATE_MARKS[mark]
+                    if rest.strip():
+                        buf.append(rest)
+                    continue
+                flush_prose()
+                close_result()
+                nm = RE_RESULT_NEXT.search(rest)
+                cur_result = {"axis": AXIS_MAP.get(mark), "hint": hint,
+                              "text": RE_RESULT_NEXT.sub("", rest).strip(),
+                              "next": nm.group(1) if nm else None}
+                continue
+
+            orr = RE_OLD_RESULT.match(s)
+            if orr and in_results:
+                flush_prose()
+                close_result()
+                cur_result = {"axis": None, "hint": orr.group(1).strip(),
+                              "text": orr.group(2).strip(), "next": None}
+                continue
+
+            if cur_result is not None:  # 결과 블록 연속 줄
+                cur_result["text"] += "\n" + s
+                continue
+
+            cm = RE_CENTER.search(s)
+            if cm and s.startswith(">"):
+                flush_prose()
+                narration.append({"type": "dialogue_center", "text": cm.group(1).strip(), "gate": gate})
+                gate = "all" if gate == "trust_high" else gate  # 심층 게이트는 대표대사까지
+                continue
+
+            dm = RE_CHAR_DIALOGUE.match(s)
+            if dm:
+                flush_prose()
+                narration.append({"type": "character_dialogue", "speaker": dm.group(1).strip(),
+                                  "text": dm.group(2).strip(), "anchor": True, "gate": gate})
+                continue
+
+            if re.match(r"^\*\(.+\)\*$", s):
+                flush_prose()
+                narration.append({"type": "stage_direction",
+                                  "text": s.strip("*()").strip(), "gate": gate})
+                continue
+
+            if s.startswith(">"):
+                s = s.lstrip("> ").strip()
+            buf.append(s)
+
+        flush_prose()
+        close_result()
+        # 스키마 기본값과 같은 키 제거 없이 그대로 두되, speaker/anchor 없는 블록은 기본값 생략
+        narration = [
+            {k: v for k, v in b.items() if not (k == "speaker" and not v)
+             and not (k == "anchor" and not v) and not (k == "gate" and v == "all")}
+            for b in narration
+        ]
+        return narration, results
+
+    def _match_results(self, choices: list[dict], results: list[dict], ws: list[str]):
+        """결과 블록을 선택지에 유사도 순으로 배정 (탐욕, 1:1)."""
+        pairs = sorted(
+            ((r_i, c_i, _match_score(c["label"], r["hint"], r["text"]))
+             for r_i, r in enumerate(results) for c_i, c in enumerate(choices)),
+            key=lambda t: -t[2],
+        )
+        used_r, used_c = set(), set()
+        for r_i, c_i, score in pairs:
+            if r_i in used_r or c_i in used_c:
+                continue
+            r, c = results[r_i], choices[c_i]
+            if score <= 0:
+                ws.append(f"결과 '〈{r['hint']}〉' ↔ 선택지 매칭 실패 (score 0)")
+                used_r.add(r_i)
+                continue
+            c["axis"], c["result"] = r["axis"], r["text"]
+            if r["next"]:
+                c["next"] = r["next"]
+            if score < 3:
+                ws.append(f"매칭 약함(score {score}): '{c['label']}' ← 〈{r['hint']}〉")
+            used_r.add(r_i)
+            used_c.add(c_i)
+
+    @staticmethod
+    def _grab(body: str, pattern: str) -> str:
+        m = re.search(pattern, body, re.S)
+        return re.sub(r"\s+", " ", m.group(1)).strip() if m else ""
+
+
+class RCardParser:
+    def parse(self, text: str) -> dict:
+        m = re.search(r"^#\s+(R-[가-힣\w]+)", text, re.M)
+        rid = m.group(1) if m else "R-UNKNOWN"
+        tm = re.search(r"^##\s+" + re.escape(rid) + r"\s*[··]\s*(.+)$", text, re.M)
+        title = tm.group(1).strip() if tm else ""
+        tag_line = next((l for l in text.split("\n") if l.strip().startswith(">") and "`#" in l), "")
+        tags = RE_TAG.findall(tag_line)
+
+        rules = []
+        rm = re.search(r"###\s*🔒[^\n]*\n(.*?)(?=\n###)", text, re.S)
+        if rm:
+            rules = [re.sub(r"\*\*", "", l.strip("- ").strip())
+                     for l in rm.group(1).split("\n") if l.strip().startswith("-")]
+
+        stages = []
+        stage_iter = list(RE_STAGE.finditer(text))
+        for i, sm in enumerate(stage_iter):
+            seg = text[sm.end(): stage_iter[i + 1].start() if i + 1 < len(stage_iter) else len(text)]
+            anchor_m = RE_CENTER.search(seg)
+            variants = re.findall(r"-\s*(?:변형|물리 증거[^:]*):\s*(.+)", seg)
+            prose = "\n".join(
+                l.strip() for l in seg.split("\n")
+                if l.strip() and not l.strip().startswith(("-", ">", "▸", "#"))
+            ).strip()
+            stages.append({"stage": int(sm.group(1)), "title": sm.group(2).strip(),
+                           "anchor": anchor_m.group(1).strip() if anchor_m else "",
+                           "prose": prose, "variants": variants})
+
+        return {"id": rid, "title": title, "tags": tags, "rules": rules,
+                "stages": stages, "raw": "" if stages else text}
+
+
+def save(data: dict, path: Path):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.dump(data, allow_unicode=True, sort_keys=False, width=100),
+                    encoding="utf-8")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("input", help="비트카드 폴더 (E01~ 하위 폴더 + R-*.md)")
+    ap.add_argument("-o", "--output", default="content/beatcards")
+    ap.add_argument("--episodes", default="E01,E02,E03,E04,E05,E06")
+    args = ap.parse_args()
+
+    src, out = Path(args.input), Path(args.output)
+    episodes = args.episodes.split(",")
+    total_cards, all_warnings = 0, []
+
+    ep_parser = EpisodeParser()
+    for ep in episodes:
+        md = src / ep / f"{ep}_비트카드.md"
+        if not md.exists():
+            print(f"⚠ 원본 없음: {md}")
+            continue
+        data, ws = ep_parser.parse(md.read_text(encoding="utf-8"), str(md))
+        EpisodeFile.model_validate(data)  # 저장 전 스키마 검증
+        save(data, out / f"{ep}.yaml")
+        total_cards += len(data["cards"])
+        all_warnings += ws
+        print(f"✓ {ep}: 카드 {len(data['cards'])}개 → {out / (ep + '.yaml')}")
+
+    r_parser = RCardParser()
+    for rmd in sorted(src.glob("R-*.md")):
+        data = r_parser.parse(rmd.read_text(encoding="utf-8"))
+        RCard.model_validate(data)
+        save(data, out / f"{data['id']}.yaml")
+        print(f"✓ {data['id']}: 단계 {len(data['stages'])}개")
+
+    print(f"\n총 {total_cards}카드 변환 완료")
+    if all_warnings:
+        print(f"\n점검 항목 {len(all_warnings)}건:")
+        for w in all_warnings:
+            print(f"  ⚠ {w}")
+
+
+if __name__ == "__main__":
+    main()

scripts/play.py

@@ -0,0 +1,139 @@
+"""카르밀라 챕터1 플레이 CLI — 리딩 루프 + 개입 포켓 (M4 통합).
+
+사용법:
+  .venv/bin/python scripts/play.py                    # 대화형 (포켓은 LLM 키 있으면 채팅)
+  .venv/bin/python scripts/play.py --policy trust --quiet    # 자동 플레이, 엔딩 확인
+  .venv/bin/python scripts/play.py --chat             # 포켓 자유채팅 강제 (OPENAI_API_KEY 필요)
+  .venv/bin/python scripts/play.py --no-chat          # 포켓 채팅 끄기 (선택지만)
+
+포켓 채팅: 선택지 카드에서 번호 대신 자유 텍스트를 입력하면 카르밀라와 대화가 열리고,
+director 수렴(또는 턴 상한) 후 선택지로 복귀한다.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from engine.repositories.content import ContentRepository  # noqa: E402
+from engine.services.story import StepResult, StoryEngine  # noqa: E402
+
+DIM = "\033[2m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+
+
+def render(step: StepResult, quiet: bool):
+    if quiet or step.card is None:
+        return
+    c = step.card
+    print(f"\n{BOLD}── {c.id} · {c.title} ──{RESET}")
+    for b in step.narration:
+        if b.type == "dialogue_center":
+            print(f"\n{BOLD}    ❝ {b.text} ❞{RESET}\n")
+        elif b.type == "character_dialogue":
+            print(f'  {b.speaker}: "{b.text}"')
+        elif b.type == "stage_direction":
+            print(f"{DIM}  ({b.text}){RESET}")
+        else:
+            print("\n" + b.text)
+
+
+async def pocket_chat(pocket_service, engine: StoryEngine, card_id: str, first_line: str):
+    """개입 포켓 자유채팅 — 수렴/턴 상한까지 돌고 숨은 상태를 커밋한다."""
+    sid = await pocket_service.open(card_id, engine.state)
+    line = first_line
+    while True:
+        turn = await pocket_service.run_turn(sid, line)
+        print(f"\n  {BOLD}카르밀라{RESET}: {turn.reply}")
+        if turn.converged:
+            print(f"{DIM}  (장면이 조용히 다음으로 기운다 — {turn.reason}){RESET}")
+            break
+        line = input("나(로라) > ").strip()
+        if not line:
+            break
+    log = await pocket_service.close(sid, engine.state)
+    return log
+
+
+def pick_or_chat(step: StepResult, policy: str, chat_enabled: bool):
+    """선택지 입력 또는 자유 텍스트(포켓 채팅 진입). 반환: ('choice', idx) | ('chat', text)."""
+    choices = step.choices
+    if policy != "ask":
+        for i, ch in enumerate(choices):
+            if ch.axis == policy:
+                return "choice", i
+        for i, ch in enumerate(choices):
+            if ch.axis in (None, "neutral"):
+                return "choice", i
+        return "choice", 0
+    for i, ch in enumerate(choices):
+        print(f"  [{i + 1}] {ch.label}")
+    if chat_enabled:
+        print(f"{DIM}  (번호 대신 하고 싶은 말을 쓰면 카르밀라와 대화합니다){RESET}")
+    while True:
+        raw = input("선택 > ").strip()
+        if raw.isdigit() and 1 <= int(raw) <= len(choices):
+            return "choice", int(raw) - 1
+        if raw and chat_enabled:
+            return "chat", raw
+        if raw and not chat_enabled:
+            print(f"{DIM}  (포켓 채팅 꺼짐 — 번호를 입력하세요){RESET}")
+
+
+async def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--policy", default="ask", choices=["ask", "trust", "doubt", "neutral"])
+    ap.add_argument("--quiet", action="store_true")
+    ap.add_argument("--content", default="content")
+    ap.add_argument("--chat", action="store_true", help="포켓 자유채팅 강제 활성화")
+    ap.add_argument("--no-chat", action="store_true", help="포켓 자유채팅 비활성화")
+    args = ap.parse_args()
+
+    chat_enabled = not args.no_chat and (args.chat or bool(os.environ.get("OPENAI_API_KEY")))
+    repo = ContentRepository(args.content)
+    engine = StoryEngine(repo)
+
+    pocket_service = None
+    if chat_enabled:
+        from engine.plugins.logging import TurnLoggingPlugin
+        from engine.services.pocket import PocketService
+        pocket_service = PocketService(repo, plugins=[TurnLoggingPlugin()])
+
+    step = engine.start()
+    while step.ending is None:
+        render(step, args.quiet)
+        if step.choices:
+            while True:
+                kind, val = pick_or_chat(step, args.policy, chat_enabled)
+                if kind == "choice":
+                    choice, step = engine.choose(val)
+                    if not args.quiet:
+                        print(f"\n{DIM}▷ {choice.label}{RESET}")
+                        if choice.result:
+                            print(choice.result)
+                    break
+                card = repo.get_card(engine.current_id)
+                if not card.can_chat:
+                    print(f"{DIM}  (이 장면에선 그녀가 자리에 없다 — 번호를 입력하세요){RESET}")
+                    continue
+                await pocket_chat(pocket_service, engine, engine.current_id, val)
+                # 채팅 후 같은 카드의 선택지로 복귀 (도달점·분기는 코드가 보장)
+        else:
+            if not args.quiet and args.policy == "ask":
+                input(f"{DIM}(다음 ⏎){RESET}")
+            step = engine.advance()
+
+    s = engine.state
+    print(f"\n{BOLD}═══ 챕터 종료: {step.ending.label} ═══{RESET}")
+    print(f"{DIM}[디버그 — 유저 비노출] trust={s.trust_score} doubt={s.doubt_score} "
+          f"frailty={s.frailty} level={s.trust_level} 카드 {len(engine.visited)}장 방문{RESET}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scripts/sync_assets.py

@@ -0,0 +1,57 @@
+"""연출 이미지 슬림 동기화 — 원본 폴더(권위)에서 데모가 쓰는 이미지만 web/assets/로 복사.
+
+원천(권위): 카르밀라/0701_카르밀라/이미지/ (대표님 산출물). web/assets/는 배포용 파생물.
+router의 COVER_IMAGE·IMAGE_MAP·BACKGROUND_MAP·INTRO_IMAGES가 참조하는
+상대경로를 그대로 유지한 채 복사한다 (권위는 router.py — 변경 시 함께 갱신).
+
+실행: python scripts/sync_assets.py
+"""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC = ROOT / "카르밀라" / "0701_카르밀라" / "이미지"
+DST = ROOT / "web" / "assets"
+
+RELATIVE_PATHS = [
+    # 표지·연출 컷 (IMAGE_MAP)
+    "플래이 이미지/1.png",       # 표지
+    "플래이 이미지/4.png",       # E01-07
+    "인물/카르밀라.png",         # E03-03 + 화자 초상
+    "인물/카르밀라 가면.png",    # E06-09
+    # 화자 초상 (SPEAKER_PORTRAIT)
+    "인물/아버지.png",
+    "인물/가정교사.png",         # 마드모아젤
+    "인물/보모.png",             # 마담
+
+    # 인트로 시퀀스 (INTRO_IMAGES)
+    "오노마x소락_방향/개요2.png",  # 작품 소개
+    "오노마x소락_방향/개요3.png",  # 등장인물 소개
+    "플래이 이미지/2.png",         # 1장 시작
+    # 장소별 배경 (BACKGROUND_MAP)
+    "배경/성.png",
+    "배경/침실.png",
+    "배경/식당.png",
+    "배경/안개 숲.png",
+    "배경/폐허성당.png",
+]
+
+
+def main() -> None:
+    if not SRC.exists():
+        raise SystemExit(f"원본 이미지 폴더 없음: {SRC}")
+    for rel in RELATIVE_PATHS:
+        src, dst = SRC / rel, DST / rel
+        if not src.exists():
+            raise SystemExit(f"원본 이미지 누락: {src}")
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(src, dst)
+        print(f"복사: {rel}")
+    print(f"완료 — {len(RELATIVE_PATHS)}장 → {DST}")
+
+
+if __name__ == "__main__":
+    main()

web/index.html

@@ -20,6 +20,16 @@
     overflow-x: hidden;
   }
 
+  /* ── 장소 배경 (비주얼 노벨) — 서버가 페이지마다 지정, 크로스페이드 ── */
+  .bg-layer { position: fixed; inset: 0; z-index: -2; pointer-events: none;
+              background-size: cover; background-position: center;
+              opacity: 0; transition: opacity 1.6s ease;
+              filter: brightness(.5) saturate(.85); }
+  .bg-layer.show { opacity: .55; }
+  #bg-dim { position: fixed; inset: 0; z-index: -1; pointer-events: none;
+            background: linear-gradient(rgba(11,14,20,.3) 0%, rgba(11,14,20,.55) 45%,
+                                        rgba(11,14,20,.82) 100%); }
+
   /* ── 진행 바 + 장 라벨 ── */
   #progress-wrap { position: fixed; top: 0; left: 0; right: 0; z-index: 40; }
   #progress-bar { height: 2px; width: 0%; background: linear-gradient(90deg, var(--gold-dim), var(--gold));
@@ -41,9 +51,29 @@
                  margin: 2.4em 0; line-height: 2.1; word-break: keep-all; }
   .center-line::before { content: "❝ "; color: var(--gold-dim); }
   .center-line::after  { content: " ❞"; color: var(--gold-dim); }
-  .char-line { margin: 1.2em 0; padding-left: 1em; border-left: 2px solid var(--gold-dim);
-               color: #cfc4ad; word-break: keep-all; }
-  .char-line .spk { color: var(--gold-dim); font-size: .85rem; margin-right: .6em; }
+  /* ── 캐릭터 발화 (비주얼 노벨 — 참고: 플래이 이미지/7.png) ──
+     초상 일러스트 → 장식 이름표 → 대사. 초상 없는 화자는 이름표+대사만 */
+  .vn-block { margin: 2.6em auto; text-align: center; }
+  .vn-portrait { display: block; margin: 0 auto 16px;
+                 max-width: min(80vw, 430px); max-height: 46vh; object-fit: contain;
+                 border: 1px solid rgba(201,168,106,.28);
+                 box-shadow: 0 0 70px rgba(0,0,0,.85); }
+  .vn-name { display: inline-block; position: relative; margin-bottom: 14px;
+             padding: 5px 30px; font-size: .9rem; color: var(--gold);
+             letter-spacing: .3em; text-indent: .3em;
+             border: 1px solid rgba(201,168,106,.5); background: rgba(11,14,20,.72); }
+  .vn-name::before, .vn-name::after {
+    content: ""; position: absolute; top: 50%; width: 46px; height: 1px;
+    background: linear-gradient(90deg, transparent, var(--gold-dim)); }
+  .vn-name::before { right: 100%; margin-right: 10px; }
+  .vn-name::after { left: 100%; margin-left: 10px; transform: scaleX(-1); }
+  .vn-line { font-size: 1.06rem; color: #e5dfd2; line-height: 2.05;
+             word-break: keep-all; margin: .35em 0; }
+  .vn-block.player { text-align: right; }
+  .vn-block.player .vn-name { padding: 4px 18px; font-size: .8rem;
+                              color: var(--text-dim); border-color: rgba(143,140,133,.4); }
+  .vn-block.player .vn-name::before, .vn-block.player .vn-name::after { display: none; }
+  .vn-block.player .vn-line { color: var(--text-dim); font-size: 1rem; }
   .stage-dir { color: var(--text-dim); font-style: italic; font-size: .92rem;
                text-align: center; margin: 1.4em 0; }
   .result-block { margin: 1.6em 0; padding: 1em 1.2em; background: rgba(201,168,106,.05);
@@ -52,9 +82,17 @@
   .fade { animation: fadein 1.1s ease both; }
   @keyframes fadein { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; } }
 
-  /* ── 선택지: 본문 흐름 안, 중앙 중하부 1열 ── */
-  #choice-area { margin: 9vh auto 0; max-width: 430px; display: flex;
-                 flex-direction: column; gap: 12px; }
+  /* ── 선택지: 대화하듯 — › 마커 + 가는 구분선 리스트 (참고: 플래이 이미지/7.png) ── */
+  #choice-area { margin: 8vh auto 0; max-width: 520px; display: flex;
+                 flex-direction: column; gap: 0; }
+  #choice-area button { background: transparent; border: none; border-radius: 0;
+                        border-top: 1px solid rgba(201,168,106,.22);
+                        text-align: left; padding: 17px 12px; font-size: 1rem; }
+  #choice-area button:last-child { border-bottom: 1px solid rgba(201,168,106,.22); }
+  #choice-area button::before { content: "›"; color: var(--gold-dim);
+                                margin-right: .8em; font-size: 1.05rem; }
+  #choice-area button:hover { color: var(--gold); background: rgba(201,168,106,.06); }
+  #choice-area button.chat-open { border-style: solid; }
   button {
     font-family: inherit; font-size: .98rem; cursor: pointer; word-break: keep-all;
     background: rgba(26,34,51,.85); color: var(--text);
@@ -115,15 +153,37 @@
                 padding: 11px 14px; font-family: inherit; font-size: .96rem; }
   #chat-input:focus { outline: none; border-color: var(--gold); }
 
-  /* ── 표지·엔딩 ── */
+  /* ── 표지·엔딩 ──
+     원본(1086×1448)을 화면에 cover로 늘리면 해상도가 깨진다 —
+     블러 백드롭 + 원본 크기 이하로만 선명하게 중앙 배치 (인트로도 동일 기법) */
   #cover { position: fixed; inset: 0; z-index: 70; display: flex; flex-direction: column;
            align-items: center; justify-content: flex-end; padding-bottom: 9vh;
-           background-size: cover; background-position: center 20%; }
-  #cover::after { content: ""; position: absolute; inset: 0;
-                  background: linear-gradient(transparent 40%, rgba(11,14,20,.92)); }
-  #cover > * { position: relative; z-index: 1; }
-  #cover button { padding: 14px 52px; background: rgba(11,14,20,.75); font-size: 1.02rem;
+           background: var(--ink); overflow: hidden; }
+  #cover-blur { position: absolute; inset: -48px; background-size: cover;
+                background-position: center 20%; filter: blur(30px) brightness(.45); }
+  #cover-art { position: absolute; left: 50%; top: 46%; transform: translate(-50%, -50%);
+               max-width: min(92vw, 1086px); max-height: min(84vh, 1448px);
+               box-shadow: 0 0 90px rgba(0,0,0,.85);
+               border: 1px solid rgba(201,168,106,.2); }
+  #cover::after { content: ""; position: absolute; inset: 0; z-index: 1;
+                  background: linear-gradient(transparent 55%, rgba(11,14,20,.9)); }
+  #cover button { position: relative; z-index: 2; padding: 14px 52px;
+                  background: rgba(11,14,20,.75); font-size: 1.02rem;
                   letter-spacing: .3em; text-indent: .3em; }
+
+  /* ── 인트로 시퀀스 (작품 소개 → 인물 소개 → 1장 시작) ── */
+  #intro { position: fixed; inset: 0; z-index: 68; background: var(--ink);
+           display: none; align-items: center; justify-content: center;
+           cursor: pointer; overflow: hidden; }
+  #intro.open { display: flex; }
+  #intro-blur { position: absolute; inset: -48px; background-size: cover;
+                background-position: center; filter: blur(30px) brightness(.4); }
+  #intro-art { position: relative; max-width: min(94vw, 1086px); max-height: min(92vh, 1491px);
+               object-fit: contain; box-shadow: 0 0 90px rgba(0,0,0,.85);
+               border: 1px solid rgba(201,168,106,.2); animation: fadein 1s ease both; }
+  #intro-hint { position: fixed; bottom: 20px; left: 50%; transform: translateX(-50%);
+                color: var(--text-dim); font-size: .72rem; letter-spacing: .25em;
+                animation: fadein 1.6s ease both 1s; }
   .ending { text-align: center; }
   .ending h2 { color: var(--gold); letter-spacing: .25em; margin: 20vh 0 1.4em; font-weight: 500; }
   .ending p { color: var(--text-dim); }
@@ -131,14 +191,26 @@
 </style>
 </head>
 <body>
+<div class="bg-layer" id="bgA"></div>
+<div class="bg-layer" id="bgB"></div>
+<div id="bg-dim"></div>
+
 <div id="progress-wrap"><div id="progress-bar"></div></div>
 <div id="progress-label"></div>
 <div id="browse-ribbon">지나온 페이지 — 오른쪽을 눌러 지금으로</div>
 
 <div id="cover">
+  <div id="cover-blur"></div>
+  <img id="cover-art" alt="카르밀라 표지">
   <button onclick="start()" id="start-btn">밤을 연다</button>
 </div>
 
+<div id="intro">
+  <div id="intro-blur"></div>
+  <img id="intro-art" alt="">
+  <div id="intro-hint">— 눌러서 계속 —</div>
+</div>
+
 <div id="stage"><div id="page"></div></div>
 
 <div id="nav-left"  class="nav-zone" title="이전"></div>
@@ -177,10 +249,13 @@ const api = async (path, body) => {
 
 /* ── 시작 ── */
 let RESUME = null;                  // {sid, step} — 저장된 세션 복원분
+let INTRO = [];                     // 인트로 시퀀스 이미지 (새 시작에만, 서버 /meta)
 (async () => {
   try {
     const m = await api('/meta');
-    $('cover').style.backgroundImage = `url("${encodeURI(m.cover_image)}")`;
+    $('cover-blur').style.backgroundImage = `url("${encodeURI(m.cover_image)}")`;
+    $('cover-art').src = encodeURI(m.cover_image);
+    INTRO = m.intro_images || [];
   } catch (e) {}
   const saved = localStorage.getItem('carmilla_sid');
   if (saved) {
@@ -197,6 +272,7 @@ let RESUME = null;                  // {sid, step} — 저장된 세션 복원
 async function start() {
   $('start-btn').disabled = true;
   let step;
+  const fresh = !RESUME;
   if (RESUME) {
     SID = RESUME.sid; step = RESUME.step;
   } else {
@@ -206,26 +282,86 @@ async function start() {
     step = data.step;
   }
   $('cover').remove();
+  if (fresh && INTRO.length) return showIntro(0, step);  // 새 시작에만 인트로
+  beginReading(step);
+}
+
+function beginReading(step) {
   document.body.classList.add('show-hints');
   setTimeout(() => document.body.classList.remove('show-hints'), 5000);
   showStep(step, true);
 }
 
+function showIntro(i, step) {       // 작품 소개 → 인물 소개 → 1장 시작 → 본문
+  const el = $('intro');
+  $('intro-blur').style.backgroundImage = `url("${encodeURI(INTRO[i])}")`;
+  $('intro-art').src = encodeURI(INTRO[i]);
+  el.classList.add('open');
+  el.onclick = () => {
+    if (i + 1 < INTRO.length) showIntro(i + 1, step);
+    else { el.classList.remove('open'); el.onclick = null; beginReading(step); }
+  };
+}
+
+/* ── 장소 배경 (크로스페이드) ── */
+let bgFlip = false, bgCurrent = null;
+function setBackground(url) {
+  if ((url || null) === bgCurrent) return;
+  bgCurrent = url || null;
+  const nxt = $(bgFlip ? 'bgA' : 'bgB'), prv = $(bgFlip ? 'bgB' : 'bgA');
+  bgFlip = !bgFlip;
+  if (url) { nxt.style.backgroundImage = `url("${encodeURI(url)}")`; nxt.classList.add('show'); }
+  else nxt.classList.remove('show');
+  prv.classList.remove('show');
+}
+
 /* ── 렌더 ── */
+const PLAYER_SPEAKERS = new Set(['유저', '로라', '나']);   // 1인칭 — 초상 없이 오른쪽 정렬
+
 function block(b) {
   if (b.type === 'dialogue_center') return `<div class="center-line fade">${esc(b.text)}</div>`;
-  if (b.type === 'character_dialogue')
-    return `<div class="char-line fade"><span class="spk">${esc(b.speaker)}</span>“${esc(b.text)}”</div>`;
   if (b.type === 'stage_direction') return `<div class="stage-dir fade">( ${esc(b.text)} )</div>`;
   return `<div class="prose fade">${esc(b.text)}</div>`;
 }
 
+function vnBlock(spk, portrait, lines) {
+  const player = PLAYER_SPEAKERS.has(spk);
+  let h = `<div class="vn-block fade${player ? ' player' : ''}">`;
+  if (portrait && !player)
+    h += `<img class="vn-portrait" src="${encodeURI(portrait)}" alt="${esc(spk)}">`;
+  h += `<div class="vn-name">${esc(player ? '나' : spk)}</div>`;
+  for (const t of lines) h += `<div class="vn-line">“${esc(t)}”</div>`;
+  return h + `</div>`;
+}
+
+function narrationHtml(blocks) {
+  // 연속된 같은 화자의 발화는 한 VN 블록으로. 초상은 페이지당 화자별 1회만
+  let out = '';
+  const portraitShown = new Set();
+  for (let i = 0; i < blocks.length;) {
+    const b = blocks[i];
+    if (b.type !== 'character_dialogue') { out += block(b); i++; continue; }
+    const spk = b.speaker, lines = [];
+    let portrait = null;
+    while (i < blocks.length && blocks[i].type === 'character_dialogue'
+           && blocks[i].speaker === spk) {
+      lines.push(blocks[i].text);
+      portrait = portrait || blocks[i].portrait;
+      i++;
+    }
+    if (portrait && portraitShown.has(spk)) portrait = null;
+    if (portrait) portraitShown.add(spk);
+    out += vnBlock(spk, portrait, lines);
+  }
+  return out;
+}
+
 function pageHtml(step, fresh) {
   const c = step.card;
   let html = '';
   if (fresh || c.episode !== lastEpisode) html += `<div class="ep-header fade">${esc(c.episode_title || c.episode)}</div>`;
   html += `<div class="card-title fade">${esc(c.title)}</div>`;
-  html += step.narration.map(block).join('');
+  html += narrationHtml(step.narration);
   html += `<div id="choice-area">${choicesHtml(step)}</div>`;
   return html;
 }
@@ -259,20 +395,21 @@ function pushCutPage(step) {        // 이미지 페이지 번호 = 본문 번
   const html = `<div class="page-cut"><img src="${encodeURI(step.image)}" alt="">` +
                `<div class="cut-caption">${esc(step.card.title)}</div></div>`;
   pushEntry(html, {index: step.progress.index - 1, total: step.progress.total},
-            step.card.episode_title);
+            step.card.episode_title, step.background);
 }
 
 function pushPage(step, fresh) {
   lastEpisode = step.card.episode;
-  pushEntry(pageHtml(step, fresh), step.progress, step.card.episode_title);
+  pushEntry(pageHtml(step, fresh), step.progress, step.card.episode_title, step.background);
 }
 
-function pushEntry(html, progress, ep) {
+function pushEntry(html, progress, ep, bg) {
   $('page').innerHTML = html;
-  history.push({html, progress, ep});
+  history.push({html, progress, ep, bg});
   cursor = history.length - 1;
   document.body.classList.remove('browsing');
   setProgress(progress, ep);
+  setBackground(bg);
   window.scrollTo({top: 0});
 }
 
@@ -281,6 +418,7 @@ function renderEntry(i) {
   $('page').innerHTML = h.html;
   document.body.classList.toggle('browsing', i < history.length - 1);
   setProgress(h.progress, h.ep);
+  setBackground(h.bg);
   window.scrollTo({top: 0});
 }
 
@@ -289,12 +427,19 @@ $('nav-right').onclick = () => go(+1);
 $('nav-left').onclick = () => go(-1);
 document.addEventListener('keydown', (e) => {
   if (chatOpen) return;
+  const intro = $('intro');
+  if (intro && intro.classList.contains('open')) {   // 인트로 중 — →/스페이스로 넘김
+    if ((e.key === 'ArrowRight' || e.key === ' ' || e.key === 'Enter') && intro.onclick)
+      intro.onclick();
+    return;
+  }
   if (e.key === 'ArrowRight' || e.key === ' ') go(+1);
   if (e.key === 'ArrowLeft') go(-1);
 });
 
 async function go(dir) {
-  if (busy || chatOpen || !SID || STEP?.ending && cursor >= history.length - 1 && dir > 0) return;
+  if (busy || chatOpen || !SID || !STEP
+      || STEP.ending && cursor >= history.length - 1 && dir > 0) return;
   if (dir < 0) {                                   // 과거 페이지 훑어보기 (읽기 전용)
     if (cursor <= 0) return;
     cursor--;
@@ -396,10 +541,11 @@ $('chat-input').addEventListener('keydown', (e) => { if (e.key === 'Enter') send
 function renderEnding(end) {
   setProgress(STEP.progress, '');
   $('progress-label').textContent = '';
+  setBackground(null);               // 엔딩 — 배경을 걷고 정적으로
   $('page').innerHTML = `<div class="ending fade">
     <h2>${esc(end.label)}</h2><p>${esc(end.description)}</p>
     <button onclick="restart()">다시, 처음의 밤으로</button></div>`;
-  history.push({html: $('page').innerHTML, progress: STEP.progress, ep: ''});
+  history.push({html: $('page').innerHTML, progress: STEP.progress, ep: '', bg: null});
   cursor = history.length - 1;
 }