Rename to 러브로그(LoveLog) and clean up unused files

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app.py

@@ -1,8 +1,7 @@
-"""러브로그 — Gradio 플레이 (카카오톡 스타일 채팅 UI)"""
+"""러브로그 — Gradio 플레이 (스테이지 기반 + 다중 캐릭터)"""
 
 import json
 import os
-import random
 import re
 from datetime import datetime
 
@@ -11,28 +10,30 @@ from dotenv import load_dotenv
 from openai import OpenAI
 
 from scenarios import (
-    SCENARIOS, BOSS_EVENTS, TONE_DISTRIBUTION, TONES, DATING_TYPES, ALL_AXES,
+    STAGES, DATING_TYPES, WARMTH_THRESHOLDS, MAX_INTERRUPTIONS, INTERRUPT_STAGES,
+    pick_characters, get_warmth_variant, should_interrupt, get_confession_outcome,
+)
+from gpt_engine import (
+    generate_first_meetings, generate_event, generate_reaction,
+    generate_interruption, generate_ending, generate_analysis,
+    generate_personality_description,
 )
-from gpt_engine import generate_event, generate_reaction, generate_trait_summary
 from trait_engine import (
     empty_vector, apply_effects, classify_type, find_matches,
-    vector_to_profile, profile_to_vector,
+    vector_to_profile, generate_match_reason, AXIS_NAMES_KR,
 )
+from scene_art import get_scene_image
 
 load_dotenv()
 
-TONE_EMOJI = {"positive": "💗", "negative": "💔", "wildcard": "⚡"}
-
 
 # ── HTML 헬퍼 ──────────────────────────────────────────────
 
 def _md_bold(text):
-    """**볼드** → <strong> 변환"""
     return re.sub(r'\*\*(.+?)\*\*', r'<strong>\1</strong>', text)
 
 
 def _render_chat(state):
-    """채팅 히스토리 전체를 카카오톡 스타일 HTML로 렌더링"""
     parts = []
     for msg in state["chat_history"]:
         role = msg["role"]
@@ -45,22 +46,80 @@ def _render_chat(state):
             parts.append(f'<div class="bubble user-choice">{text}</div>')
         elif role == "question":
             parts.append(f'<div class="bubble question">{text}</div>')
-
+        elif role == "char_card":
+            parts.append(f'<div class="bubble narration char-card">{text}</div>')
+        elif role == "scene":
+            parts.append(f'<img class="scene-art" src="{msg["text"]}" alt="scene">')
     inner = "\n".join(parts)
     return f'''<div class="chat-container" id="chatbox">
-    <div class="chat-inner">
     {inner}
-    </div>
-</div>'''
+</div>
+'''
 
 
-# ── 게임 로직 ──────────────────────────────────────────────
+# ── 선택 히스토리 빌더 ────────────────────────────────────────
+
+def _format_effects(effects: dict) -> str:
+    """trait_effect에서 상위 3개를 한국어로."""
+    if not effects:
+        return ""
+    sorted_fx = sorted(effects.items(), key=lambda x: abs(x[1]), reverse=True)[:3]
+    parts = []
+    for axis, val in sorted_fx:
+        name = AXIS_NAMES_KR.get(axis, axis)
+        sign = "+" if val > 0 else ""
+        parts.append(f"{name} {sign}{val:.1f}")
+    return " · ".join(parts)
+
+
+def _build_choice_history_html(state: dict) -> str:
+    """이벤트 로그에서 선택 히스토리 HTML 생성."""
+    cards = []
+    for log in state.get("event_logs", []):
+        scenario = log.get("scenario", "?")
+        char_name = log.get("character", "")
+        stage = log.get("stage", "?")
+        warmth_after = log.get("warmth_after", 0)
+
+        t1 = log.get("turn1", {}).get("selected", {})
+        t2 = log.get("turn2", {}).get("selected", {})
+
+        t1_text = t1.get("text", "")
+        t2_text = t2.get("text", "")
+        t1_fx = _format_effects(t1.get("trait_effect", {}))
+        t2_fx = _format_effects(t2.get("trait_effect", {}))
+
+        warmth_int = max(0, int(warmth_after))
+        warmth_bar = "❤️" * warmth_int + "🤍" * max(0, 10 - warmth_int)
+
+        lines = [f'<div class="bubble narration choice-log">']
+        lines.append(f'<div class="log-stage">Stage {stage} · {scenario} — {char_name}</div>')
+        if t1_text:
+            lines.append(f'<div class="log-choice">1턴: {t1_text}</div>')
+            if t1_fx:
+                lines.append(f'<div class="log-effects">{t1_fx}</div>')
+        if t2_text:
+            lines.append(f'<div class="log-choice">2턴: {t2_text}</div>')
+            if t2_fx:
+                lines.append(f'<div class="log-effects">{t2_fx}</div>')
+        lines.append(f'<div class="log-warmth">호감도 {warmth_bar}</div>')
+        lines.append('</div>')
+        cards.append("\n".join(lines))
+
+    return "\n".join(cards)
+
+
+# ── 상태 관리 ──────────────────────────────────────────────
 
 def new_state():
     return {
         "phase": "idle",
-        "events": [],
-        "event_idx": 0,
+        "user_gender": "",
+        "partner_gender": "",
+        "characters": [],
+        "current_char_idx": -1,
+        "stage": 1,
+        "stage_event_count": 0,
         "trait_vector": empty_vector(),
         "choice_history": [],
         "event_logs": [],
@@ -68,131 +127,235 @@ def new_state():
         "current_reaction_data": {},
         "current_event_log": {},
         "chat_history": [],
+        "interruption_count": 0,
+        "alternating": False,
+        "alternate_char_indices": [],
     }
 
 
-def build_events(boss_chance=0.05):
-    events = []
-    for forced_tone in TONE_DISTRIBUTION:
-        tone = forced_tone or random.choice(["positive", "negative", "wildcard"])
-        pool = [s for s in SCENARIOS.values() if s["tone"] == tone]
-        used = {e["name"] for e in events}
-        pool = [s for s in pool if s["name"] not in used]
-        if not pool:
-            pool = [s for s in SCENARIOS.values() if s["name"] not in used]
-        events.append(random.choice(pool))
-    if random.random() < boss_chance:
-        boss = random.choice(list(BOSS_EVENTS.values()))
-        events.append({**boss, "_is_boss": True})
-    return events
-
-
 def get_client():
     api_key = os.getenv("OPENAI_API_KEY", "")
-    if not api_key:
-        return None
-    return OpenAI(api_key=api_key)
+    return OpenAI(api_key=api_key) if api_key else None
 
 
 def get_model():
     return os.getenv("OPENAI_MODEL", "gpt-4o-mini")
 
 
-# ── 핸들러: 시작 ──────────────────────────────────────────
+def _outputs(state, html, a="", b="", c="", restart_vis=False, start_vis=False):
+    return (
+        state, html,
+        gr.update(value=f"A. {a}", visible=bool(a)),
+        gr.update(value=f"B. {b}", visible=bool(b)),
+        gr.update(value=f"C. {c}", visible=bool(c)),
+        gr.update(visible=restart_vis),
+        gr.update(visible=start_vis),
+        gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),  # gender panel + hidden textboxes
+        gr.update(visible=False),  # gender confirm btn
+        gr.update(), gr.update(), gr.update(), gr.update(),  # gender buttons (hidden by panel)
+    )
+
+
+def _outputs_gender(state, html):
+    """성별 선택 화면 출력."""
+    return (
+        state, html,
+        gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+        gr.update(visible=False), gr.update(visible=False),
+        gr.update(visible=True),  # gender panel
+        gr.update(visible=False, value="여성"),  # gnd_my default
+        gr.update(visible=False, value="남성"),  # gnd_other default
+        gr.update(visible=True),  # gender confirm btn
+        gr.update(value="남성"), gr.update(value="✓ 여성"),  # my: 여성 selected
+        gr.update(value="✓ 남성"), gr.update(value="여성"),  # other: 남성 selected
+    )
+
+
+# ── 핸들러: 시작 → 성별 선택 ─────────────────────────────
 
 def on_start(state):
+    state = new_state()
+    state["phase"] = "gender_select"
+    state["chat_history"].append({"role": "header", "text": "💜 러브로그 시작"})
+    state["chat_history"].append({
+        "role": "narrator",
+        "text": "당신의 성별과 만나고 싶은 상대의 성별을 선택해주세요.",
+    })
+    html = _render_chat(state)
+    return _outputs_gender(state, html)
+
+
+def on_gender_select(user_gender, partner_gender, state):
+    if not user_gender or not partner_gender:
+        return _outputs_gender(state, _render_chat(state))
+
     client = get_client()
     if not client:
-        error_html = '<div class="chat-container"><div class="bubble narration">❌ OPENAI_API_KEY를 .env에 설정해주세요.</div></div>'
-        return (
-            state, error_html,
-            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
-            gr.update(visible=False), gr.update(visible=True),
+        state["chat_history"].append({"role": "narrator", "text": "❌ OPENAI_API_KEY를 .env에 설정해주세요."})
+        return _outputs(state, _render_chat(state), start_vis=True)
+
+    gender_map = {"남성": "M", "여성": "F", "남자": "M", "여자": "F"}
+    state["user_gender"] = gender_map.get(user_gender, "M")
+    state["partner_gender"] = gender_map.get(partner_gender, "F")
+
+    # 캐릭터 생성 (템플릿 기반, GPT 불필요)
+    state["characters"] = pick_characters(state["partner_gender"])
+
+    state["chat_history"].append({
+        "role": "user",
+        "text": f"내 성별: {user_gender} · 상대: {partner_gender}",
+    })
+
+    # 첫만남 장면 생성 (GPT 1 call)
+    state["chat_history"].append({"role": "header", "text": "Stage 1 · 첫만남"})
+    state["chat_history"].append({"role": "narrator", "text": "세 사람과의 첫만남..."})
+
+    model = get_model()
+    try:
+        meetings = generate_first_meetings(client, state["characters"], model=model)
+    except Exception as e:
+        state["chat_history"].append({"role": "narrator", "text": f"⚠️ 생성 오류: {e}"})
+        return _outputs(state, _render_chat(state), start_vis=True)
+
+    # 3명 카드 표시
+    for i, char in enumerate(state["characters"]):
+        meeting = meetings[i] if i < len(meetings) else {}
+        situation = meeting.get("situation", "")
+        dialogue = meeting.get("dialogue", "")
+        card_html = (
+            f"<div class='char-name'>{char['name']}</div>"
+            f"<div class='char-info'>{char['age']}세 · {char['job']}</div>"
+            f"<div class='char-meeting'>🏷️ {char['meeting_type']}</div>"
+            f"<div class='char-scene'>{situation}</div>"
+            f"<div class='char-dialogue'>&ldquo;{dialogue}&rdquo;</div>"
         )
+        state["chat_history"].append({"role": "char_card", "text": card_html})
+        # 미팅 데이터 저장
+        char["first_meeting"] = meeting
+
+    state["phase"] = "char_select"
+    html = _render_chat(state)
+
+    names = [c["name"] for c in state["characters"]]
+    return _outputs(state, html, names[0], names[1], names[2])
 
-    state = new_state()
-    state["phase"] = "loading_event"
-    state["events"] = build_events()
 
-    return _generate_event(state, client)
+# ── 핸들러: 캐릭터 선택 ──────────────────────────────────
 
+def on_choice(choice_idx, state):
+    client = get_client()
+    if not client:
+        return _outputs(state, _render_chat(state))
 
-def _generate_event(state, client):
-    idx = state["event_idx"]
-    events = state["events"]
+    phase = state["phase"]
 
-    if idx >= len(events):
-        return _show_results(state)
+    if phase == "char_select":
+        return _handle_char_select(choice_idx, state, client)
+    elif phase == "turn1":
+        return _handle_turn1(choice_idx, state, client)
+    elif phase == "turn2":
+        return _handle_turn2(choice_idx, state, client)
+    elif phase == "interruption":
+        return _handle_interruption(choice_idx, state, client)
+    elif phase == "ending_choice":
+        return _handle_ending_choice(choice_idx, state, client)
 
-    scenario = events[idx]
-    is_boss = scenario.get("_is_boss", False)
-    tone = TONE_EMOJI.get(scenario["tone"], "")
-    total = len(events)
+    return _outputs(state, _render_chat(state))
 
-    if is_boss:
-        header = f"⚔️ BOSS — {scenario['name']}"
-    else:
-        header = f"{idx + 1}/{total} {tone} {scenario['name']}"
+
+def _handle_char_select(choice_idx, state, client):
+    if choice_idx >= len(state["characters"]):
+        choice_idx = 0
+
+    state["current_char_idx"] = choice_idx
+    char = state["characters"][choice_idx]
+
+    state["chat_history"].append({
+        "role": "user",
+        "text": f"{char['name']}을(를) 선택했습니다",
+    })
+
+    # Stage 1 첫 이벤트 시작 (친해지기)
+    state["stage"] = 1
+    state["stage_event_count"] = 0
+    return _next_event(state, client)
+
+
+# ── 이벤트 생성 루프 ──────────────────────────────────────
+
+def _next_event(state, client):
+    stage_num = state["stage"]
+
+    # Stage 6 → 결말 선택
+    if stage_num >= 6:
+        return _show_ending_choices(state, client)
+
+    # 조기 결말: stage 4 이상에서 모든 캐릭터 warmth ≤ 0이면 바로 결말
+    if stage_num >= 4 and all(
+        c["warmth"] <= WARMTH_THRESHOLDS["early_ending"] for c in state["characters"]
+    ):
+        state["chat_history"].append({
+            "role": "narrator",
+            "text": "어느 순간, 모든 만남이 흐릿해져 갔다. 설렘도, 기대도 사라진 자리엔 익숙한 일상만 남았다.",
+        })
+        return _show_ending_choices(state, client)
+
+    stage = STAGES[stage_num]
+    char = state["characters"][state["current_char_idx"]]
+    warmth = char["warmth"]
+    variant = get_warmth_variant(stage_num, warmth)
+
+    # 난입 체크: 지정 스테이지 & 횟수 제한 내
+    if (stage_num in INTERRUPT_STAGES
+            and state["interruption_count"] < MAX_INTERRUPTIONS
+            and should_interrupt(warmth)):
+        return _trigger_interruption(state, client)
+
+    # 스테이지 헤더
+    total_stages = 6
+    header = f"Stage {stage_num}/{total_stages} · {stage['name']} — {char['name']}"
+    state["chat_history"].append({"role": "header", "text": header})
 
     model = get_model()
     try:
         event_data = generate_event(
-            client, scenario, state["trait_vector"], state["choice_history"],
-            event_logs=state["event_logs"], model=model,
+            client, stage, char, warmth,
+            state["trait_vector"], event_logs=state["event_logs"],
+            variant=variant, model=model,
         )
     except Exception as e:
-        state["event_idx"] += 1
-        return _generate_event(state, client)
+        state["chat_history"].append({"role": "narrator", "text": f"⚠️ 생성 오류: {e}"})
+        state["stage"] += 1
+        return _next_event(state, client)
 
     state["current_event_data"] = event_data
     state["current_event_log"] = {
-        "index": idx + 1,
-        "scenario": scenario["name"],
-        "desc": scenario["desc"],
-        "tone": scenario["tone"],
-        "is_boss": is_boss,
+        "stage": stage_num,
+        "scenario": stage["name"],
+        "desc": stage["desc"],
+        "character": char["name"],
+        "warmth": warmth,
+        "variant": variant,
     }
     state["phase"] = "turn1"
 
+    scene_tag = event_data.get("scene_tag", "")
+    if scene_tag:
+        state["chat_history"].append({"role": "scene", "text": get_scene_image(scene_tag)})
+
     situation = event_data.get("situation", "")
-    choices = event_data.get("choices", [])
     state["current_event_log"]["situation"] = situation
-
-    # 채팅 히스토리에 추가
-    state["chat_history"].append({"role": "header", "text": header})
     state["chat_history"].append({"role": "narrator", "text": situation})
 
-    game_html = _render_chat(state)
-
-    btn_a = choices[0].get("text", "A") if len(choices) > 0 else "A"
-    btn_b = choices[1].get("text", "B") if len(choices) > 1 else "B"
-    btn_c = choices[2].get("text", "C") if len(choices) > 2 else "C"
-
-    return (
-        state, game_html,
-        gr.update(value=f"A. {btn_a}", visible=True),
-        gr.update(value=f"B. {btn_b}", visible=True),
-        gr.update(value=f"C. {btn_c}", visible=True),
-        gr.update(visible=False), gr.update(visible=False),
-    )
-
-
-# ── 핸들러: 선택 ──────────────────────────────────────────
-
-def on_choice(choice_idx, state):
-    client = get_client()
-    if not client:
-        return state, "API 키 없음", *_hide_buttons()
+    choices = event_data.get("choices", [])
+    a = choices[0].get("text", "A") if len(choices) > 0 else "A"
+    b = choices[1].get("text", "B") if len(choices) > 1 else "B"
+    c = choices[2].get("text", "C") if len(choices) > 2 else "C"
 
-    phase = state["phase"]
+    return _outputs(state, _render_chat(state), a, b, c)
 
-    if phase == "turn1":
-        return _handle_turn1(choice_idx, state, client)
-    elif phase == "turn2":
-        return _handle_turn2(choice_idx, state, client)
-
-    return state, "알 수 없는 상태", *_hide_buttons()
 
+# ── 턴 1, 2 핸들러 ───────────────────────────────────────
 
 def _handle_turn1(choice_idx, state, client):
     choices = state["current_event_data"].get("choices", [])
@@ -200,58 +363,47 @@ def _handle_turn1(choice_idx, state, client):
         choice_idx = 0
     selected = choices[choice_idx]
 
-    scenario = state["events"][state["event_idx"]]
-    is_boss = scenario.get("_is_boss", False)
-    multiplier = 2.0 if is_boss else 1.0
+    # trait 적용
+    apply_effects(state["trait_vector"], selected.get("trait_effect", {}))
+
+    # warmth 적용
+    char = state["characters"][state["current_char_idx"]]
+    char["warmth"] += selected.get("warmth_delta", 0)
+    char["warmth"] = max(-10, min(10, char["warmth"]))
 
-    apply_effects(state["trait_vector"], selected.get("trait_effect", {}), multiplier=multiplier)
     state["choice_history"].append(selected.get("text", ""))
     state["current_event_log"]["turn1"] = {"options": choices, "selected": selected}
 
-    # 유저 선택 말풍선
-    state["chat_history"].append({
-        "role": "user",
-        "text": selected.get("text", ""),
-    })
+    state["chat_history"].append({"role": "user", "text": selected.get("text", "")})
 
+    # 2턴 생성
+    stage = STAGES[state["stage"]]
     situation = state["current_event_data"].get("situation", "")
     model = get_model()
     try:
         reaction_data = generate_reaction(
-            client, scenario, situation, selected,
+            client, stage, char, situation, selected,
             event_logs=state["event_logs"], model=model,
         )
     except Exception as e:
-        state["event_idx"] += 1
+        state["chat_history"].append({"role": "narrator", "text": f"⚠️ {e}"})
         state["event_logs"].append(state["current_event_log"])
-        return _generate_event(state, client)
+        state["stage"] += 1
+        return _next_event(state, client)
 
     state["current_reaction_data"] = reaction_data
     state["phase"] = "turn2"
 
     reaction_text = reaction_data.get("reaction", "")
-    choices_2 = reaction_data.get("choices", [])
-
     state["current_event_log"]["reaction"] = reaction_text
+    state["chat_history"].append({"role": "narrator", "text": f"💬 {reaction_text}"})
 
-    # 상황 전개 말풍선
-    state["chat_history"].append({
-        "role": "narrator",
-        "text": f"💬 {reaction_text}",
-    })
-    game_html = _render_chat(state)
-
-    btn_a = choices_2[0].get("text", "A") if len(choices_2) > 0 else "A"
-    btn_b = choices_2[1].get("text", "B") if len(choices_2) > 1 else "B"
-    btn_c = choices_2[2].get("text", "C") if len(choices_2) > 2 else "C"
+    choices_2 = reaction_data.get("choices", [])
+    a = choices_2[0].get("text", "A") if len(choices_2) > 0 else "A"
+    b = choices_2[1].get("text", "B") if len(choices_2) > 1 else "B"
+    c = choices_2[2].get("text", "C") if len(choices_2) > 2 else "C"
 
-    return (
-        state, game_html,
-        gr.update(value=f"A. {btn_a}", visible=True),
-        gr.update(value=f"B. {btn_b}", visible=True),
-        gr.update(value=f"C. {btn_c}", visible=True),
-        gr.update(visible=False), gr.update(visible=False),
-    )
+    return _outputs(state, _render_chat(state), a, b, c)
 
 
 def _handle_turn2(choice_idx, state, client):
@@ -260,68 +412,258 @@ def _handle_turn2(choice_idx, state, client):
         choice_idx = 0
     selected = choices[choice_idx]
 
-    scenario = state["events"][state["event_idx"]]
-    is_boss = scenario.get("_is_boss", False)
-    multiplier = 2.0 if is_boss else 1.0
+    apply_effects(state["trait_vector"], selected.get("trait_effect", {}))
+
+    char = state["characters"][state["current_char_idx"]]
+    char["warmth"] += selected.get("warmth_delta", 0)
+    char["warmth"] = max(-10, min(10, char["warmth"]))
 
-    apply_effects(state["trait_vector"], selected.get("trait_effect", {}), multiplier=multiplier)
     state["choice_history"].append(selected.get("text", ""))
     state["current_event_log"]["turn2"] = {"options": choices, "selected": selected}
     state["current_event_log"]["trait_snapshot"] = dict(state["trait_vector"])
+    state["current_event_log"]["warmth_after"] = char["warmth"]
     state["event_logs"].append(state["current_event_log"])
 
-    # 유저 선택 말풍선
+    state["chat_history"].append({"role": "user", "text": selected.get("text", "")})
+
+    char["event_count"] += 1
+    state["stage_event_count"] += 1
+
+    # 스테이지 1은 2개 이벤트 (친해지기), 나머지는 1개
+    events_for_stage = 2 if state["stage"] == 1 else 1
+    if state["stage_event_count"] >= events_for_stage:
+        state["stage"] += 1
+        state["stage_event_count"] = 0
+
+    # 교대 모드: 두 캐릭터 번갈아 진행, warmth 차이 크면 한쪽 집중
+    if state["alternating"]:
+        indices = state["alternate_char_indices"]
+        chars = state["characters"]
+        w0 = chars[indices[0]]["warmth"]
+        w1 = chars[indices[1]]["warmth"]
+
+        if abs(w0 - w1) >= 5:
+            focused = indices[0] if w0 >= w1 else indices[1]
+            other = indices[1] if focused == indices[0] else indices[0]
+            state["current_char_idx"] = focused
+            state["alternating"] = False
+            state["alternate_char_indices"] = []
+            state["chat_history"].append({
+                "role": "narrator",
+                "text": f"{chars[focused]['name']}과(와)의 관계가 깊어지면서, {chars[other]['name']}과(와)는 자연스럽게 멀어졌다.",
+            })
+        else:
+            cur = state["current_char_idx"]
+            state["current_char_idx"] = indices[1] if cur == indices[0] else indices[0]
+
+    return _next_event(state, client)
+
+
+# ── 난입 핸들러 ──────────────────────────────────────────
+
+def _trigger_interruption(state, client):
+    current_char = state["characters"][state["current_char_idx"]]
+    # 선택되지 않은 캐릭터 중 하나
+    others = [c for c in state["characters"] if c["id"] != current_char["id"] and c["active"]]
+    if not others:
+        return _next_event(state, client)  # 난입할 사람 없음
+
+    import random
+    intruder = random.choice(others)
+
+    state["chat_history"].append({"role": "header", "text": f"📱 {intruder['name']}에게서 연락이 왔어요"})
+
+    model = get_model()
+    try:
+        interrupt_data = generate_interruption(
+            client, current_char, intruder, current_char["warmth"],
+            event_logs=state["event_logs"], model=model,
+        )
+    except Exception as e:
+        state["chat_history"].append({"role": "narrator", "text": f"⚠️ {e}"})
+        state["interruption_count"] += 1
+        return _next_event(state, client)
+
+    state["current_event_data"] = interrupt_data
+    state["phase"] = "interruption"
+    state["interruption_count"] += 1
+    state["_intruder_id"] = intruder["id"]
+
+    scene_tag = interrupt_data.get("scene_tag", "")
+    if scene_tag:
+        state["chat_history"].append({"role": "scene", "text": get_scene_image(scene_tag)})
+
+    situation = interrupt_data.get("situation", "")
+    state["chat_history"].append({"role": "narrator", "text": situation})
+
+    choices = interrupt_data.get("choices", [])
+    a = choices[0].get("text", "A") if len(choices) > 0 else "A"
+    b = choices[1].get("text", "B") if len(choices) > 1 else "B"
+    c = choices[2].get("text", "C") if len(choices) > 2 else "C"
+
+    return _outputs(state, _render_chat(state), a, b, c)
+
+
+def _handle_interruption(choice_idx, state, client):
+    choices = state["current_event_data"].get("choices", [])
+    if choice_idx >= len(choices):
+        choice_idx = 0
+    selected = choices[choice_idx]
+
+    apply_effects(state["trait_vector"], selected.get("trait_effect", {}))
+
+    # warmth를 target_char에 적용
+    target_id = selected.get("target_char")
+    if target_id is not None:
+        for c in state["characters"]:
+            if c["id"] == target_id:
+                c["warmth"] += selected.get("warmth_delta", 0)
+                c["warmth"] = max(-10, min(10, c["warmth"]))
+                # 난입 캐릭터를 선택했으면 교대 모드 진입
+                if target_id == state.get("_intruder_id"):
+                    intruder_idx = next(
+                        i for i, ch in enumerate(state["characters"]) if ch["id"] == target_id
+                    )
+                    original_idx = state["current_char_idx"]
+                    state["alternating"] = True
+                    state["alternate_char_indices"] = [original_idx, intruder_idx]
+                    state["current_char_idx"] = intruder_idx
+                    original_name = state["characters"][original_idx]["name"]
+                    state["chat_history"].append({
+                        "role": "narrator",
+                        "text": f"{c['name']}과(와)의 이야기가 시작됩니다. 하지만 {original_name}과(와)의 인연도 계속되고 있어요.",
+                    })
+                break
+
+    state["choice_history"].append(selected.get("text", ""))
+    state["chat_history"].append({"role": "user", "text": selected.get("text", "")})
+
+    # 이벤트 로그 저장
+    state["event_logs"].append({
+        "stage": state["stage"],
+        "scenario": "난입",
+        "situation": state["current_event_data"].get("situation", ""),
+        "turn1": {"selected": selected},
+        "character": state["characters"][state["current_char_idx"]]["name"],
+    })
+
+    # 다음 스테이지로
+    return _next_event(state, client)
+
+
+# ── 결말 ───────────────────────────────────────────────────
+
+def _show_ending_choices(state, client):
+    """결말 선택지 표시: 고백 대상 선택 or 친구로 남기."""
+    state["chat_history"].append({"role": "header", "text": "Stage 6 · 결말"})
+
+    # warmth > 0인 캐릭터만 고백 가능, 높은 순 정렬, 최대 2명
+    confessable = [
+        (i, c) for i, c in enumerate(state["characters"]) if c["warmth"] > 0
+    ]
+    confessable.sort(key=lambda x: x[1]["warmth"], reverse=True)
+    confessable = confessable[:2]
+
+    if not confessable:
+        # 아무도 고백 불가 → 자동으로 멀어지는 결말
+        state["chat_history"].append({
+            "role": "narrator",
+            "text": "돌이켜보면, 누구에게도 진심으로 다가가지 못했던 것 같다.",
+        })
+        char = state["characters"][state["current_char_idx"]]
+        return _generate_ending_scene(state, client, char, "drifted")
+
+    # 고백 가능 캐릭터 요약
+    lines = []
+    for _, c in confessable:
+        warmth_bar = "❤️" * max(0, int(c["warmth"])) + "🤍" * max(0, 10 - int(c["warmth"]))
+        lines.append(f"{c['name']} — {warmth_bar}")
     state["chat_history"].append({
-        "role": "user",
-        "text": selected.get("text", ""),
+        "role": "narrator",
+        "text": "이야기가 끝을 향하고 있습니다.\n" + "\n".join(lines),
     })
 
-    state["event_idx"] += 1
-    return _generate_event(state, client)
+    state["phase"] = "ending_choice"
+    state["_confessable"] = [(i, c["name"]) for i, c in confessable]
 
+    choices = [f"{c['name']}에게 고백한다" for _, c in confessable]
+    choices.append("모두와 친구로 남는다")
 
-# ── 결과 ───────────────────────────────────────────────────
+    a = choices[0] if len(choices) > 0 else ""
+    b = choices[1] if len(choices) > 1 else ""
+    c = choices[2] if len(choices) > 2 else ""
+    return _outputs(state, _render_chat(state), a, b, c)
 
-def _show_results(state):
-    best_type, scores = classify_type(state["trait_vector"])
-    dt = DATING_TYPES.get(best_type, {})
 
-    state["chat_history"].append({"role": "header", "text": "💜 결과 발표"})
+def _handle_ending_choice(choice_idx, state, client):
+    """결말 선택 처리."""
+    confessable = state.get("_confessable", [])
+    friends_idx = len(confessable)  # 마지막 선택지 = 친구
 
-    match_html = ""
-    match_data = []
-    try:
-        matches = find_matches(state["trait_vector"], best_type, top_n=3)
-        for i, m in enumerate(matches, 1):
-            mdt = DATING_TYPES.get(m["type"], {})
-            p = m["profile"]
-            match_html += f'''<div class="bubble narration match-card">
-                <div class="match-rank">#{i} 💞</div>
-                <div class="match-name">{p['name']} ({p['age']}세, {p['gender']})</div>
-                <div class="match-type">{mdt.get('emoji', '')} {mdt.get('name', '')} · {p.get('archetype', '')}</div>
-                <div class="match-score">매칭 적합도 <strong>{m['match_score']}%</strong> · 행동 {m['behavior_sim']}% · 성격 {m['big5_sim']}%</div>
-            </div>'''
-            match_data.append({
-                "name": p["name"], "age": p["age"], "gender": p["gender"],
-                "archetype": p.get("archetype", ""), "type": m["type"],
-                "match_score": m["match_score"],
-                "behavior_sim": m["behavior_sim"], "big5_sim": m["big5_sim"],
-            })
-    except Exception:
-        match_html = '<div class="bubble narration">매칭 데이터를 불러올 수 없습니다.</div>'
+    if choice_idx >= friends_idx:
+        # 친구로 남는다
+        char = state["characters"][state["current_char_idx"]]
+        state["chat_history"].append({"role": "user", "text": "모두와 친구로 남는다"})
+        return _generate_ending_scene(state, client, char, "friends")
 
-    my_profile = vector_to_profile(state["trait_vector"], best_type)
+    # 고백 선택
+    char_idx, char_name = confessable[choice_idx]
+    char = state["characters"][char_idx]
+    state["current_char_idx"] = char_idx
+    state["chat_history"].append({"role": "user", "text": f"{char_name}에게 고백한다"})
+
+    outcome = get_confession_outcome(char["warmth"])
+    return _generate_ending_scene(state, client, char, outcome)
+
+
+def _generate_ending_scene(state, client, char, ending_type):
+    """GPT로 결말 장면 생성 + 결과 화면."""
+    warmth = char["warmth"]
+
+    ending_labels = {
+        "mutual": "💕 서로 고백 — 사귄다",
+        "accepted": "💕 고백 수락 — 사귄다",
+        "soft_reject": "🤝 거절 — 친구로 남는다",
+        "rejected": "💔 고백 거절당함",
+        "friends": "🤝 모두와 친구로 남는다",
+        "drifted": "🍂 자연스럽게 멀어진다",
+    }
 
-    # GPT 성향 요약 생성
-    client = get_client()
     model = get_model()
-    type_name = dt.get("title", dt.get("name", ""))
     try:
-        trait_summary = generate_trait_summary(client, my_profile, type_name, model=model)
+        ending = generate_ending(
+            client, char, warmth, ending_type,
+            event_logs=state["event_logs"], model=model,
+        )
     except Exception:
-        trait_summary = dt.get("desc", "")
+        ending = {"ending_scene": "이야기가 끝났습니다.", "ending_dialogue": "", "ending_type": ending_type}
+
+    state["chat_history"].append({
+        "role": "header",
+        "text": f"결말 — {ending_labels.get(ending_type, '결말')}",
+    })
+
+    scene_tag = ending.get("scene_tag", "")
+    if scene_tag:
+        state["chat_history"].append({"role": "scene", "text": get_scene_image(scene_tag)})
 
-    # 채팅 히스토리 + 결과 카드를 합쳐서 렌더링
+    state["chat_history"].append({"role": "narrator", "text": ending.get("ending_scene", "")})
+    if ending.get("ending_dialogue"):
+        state["chat_history"].append({
+            "role": "narrator",
+            "text": f"💬 {char['name']}: \"{ending['ending_dialogue']}\"",
+        })
+
+    state["ending_type"] = ending_type
+    return _show_results(state, client)
+
+
+def _show_results(state, client=None):
+    best_type, scores = classify_type(state["trait_vector"])
+    dt = DATING_TYPES.get(best_type, {})
+    ending_type = state.get("ending_type", "")
+
+    # ── 채팅 히스토리를 HTML로 렌더 ──
     chat_parts = []
     for msg in state["chat_history"]:
         role = msg["role"]
@@ -332,27 +674,115 @@ def _show_results(state):
             chat_parts.append(f'<div class="bubble narration">{text}</div>')
         elif role == "user":
             chat_parts.append(f'<div class="bubble user-choice">{text}</div>')
+        elif role == "char_card":
+            chat_parts.append(f'<div class="bubble narration char-card">{text}</div>')
+        elif role == "scene":
+            chat_parts.append(f'<img class="scene-art" src="{msg["text"]}" alt="scene">')
+
+    # ── Section 1: 결과 발표 + 호감도 ──
+    chat_parts.append('<div class="chat-divider"><span>💜 결과 발표</span></div>')
+    for char in state["characters"]:
+        warmth_bar = "❤️" * max(0, int(char["warmth"])) + "🤍" * max(0, 10 - int(char["warmth"]))
+        chat_parts.append(
+            f'<div class="bubble narration">{char["name"]} — 호감도 {char["warmth"]:.1f} {warmth_bar}</div>'
+        )
+
+    # ── Section 2: 선택 히스토리 ──
+    chat_parts.append('<div class="chat-divider"><span>📖 당신의 선택</span></div>')
+    chat_parts.append(_build_choice_history_html(state))
 
-    # 결과 카드
+    # ── Section 3: 유형 카드 ──
     chat_parts.append(f'''<div class="bubble narration result-header">
         <div class="result-emoji">{dt.get("emoji", "💜")}</div>
         <div class="result-title">{dt.get("title", "")}</div>
         <div class="result-desc">{dt.get("desc", "")}</div>
     </div>''')
+
+    # ── Section 4: AI 성향 분석 ──
+    analysis = None
+    if client:
+        try:
+            model = get_model()
+            analysis = generate_analysis(
+                client, state["trait_vector"], best_type, dt.get("name", ""),
+                state["event_logs"], ending_type, model=model,
+            )
+        except Exception:
+            analysis = None
+
+    if analysis:
+        summary = analysis.get("summary", "")
+        strengths = analysis.get("strengths", [])
+        watch_points = analysis.get("watch_points", [])
+        tip = analysis.get("dating_tip", "")
+
+        analysis_html = '<div class="bubble narration analysis-card">'
+        analysis_html += '<div class="section-title">🔮 AI 성향 분석</div>'
+        if summary:
+            analysis_html += f'<div class="analysis-summary">{summary}</div>'
+        if strengths:
+            analysis_html += '<div class="analysis-list">💪 '
+            analysis_html += " / ".join(strengths)
+            analysis_html += '</div>'
+        if watch_points:
+            analysis_html += '<div class="analysis-list">⚠️ '
+            analysis_html += " / ".join(watch_points)
+            analysis_html += '</div>'
+        if tip:
+            analysis_html += f'<div class="analysis-tip">💡 {tip}</div>'
+        analysis_html += '</div>'
+        chat_parts.append(analysis_html)
+
+    # ── Section 5: 성향 서술 (GPT) ──
+    my_profile = vector_to_profile(state["trait_vector"], best_type)
+    personality_desc = ""
+    if client:
+        try:
+            personality_desc = generate_personality_description(
+                client, my_profile, dt,
+                event_logs=state["event_logs"], model=get_model(),
+            )
+        except Exception:
+            personality_desc = dt.get("desc", "")
+    else:
+        personality_desc = dt.get("desc", "")
     chat_parts.append(f'''<div class="bubble narration">
-        <div class="profile-content">{trait_summary}</div>
+        <div class="section-title">💜 당신의 연애 성향</div>
+        <div class="profile-content">{personality_desc}</div>
     </div>''')
 
+    # ── Section 6: 매칭 결과 + 이유 ──
+    chat_parts.append('<div class="chat-divider"><span>💞 나와 맞는 사람들</span></div>')
+    match_data = []
+    try:
+        matches = find_matches(state["trait_vector"], best_type, top_n=3)
+        for i, m in enumerate(matches, 1):
+            mdt = DATING_TYPES.get(m["type"], {})
+            p = m["profile"]
+            reason = generate_match_reason(state["trait_vector"], best_type, m)
+            chat_parts.append(f'''<div class="bubble narration match-card">
+                <div class="match-rank">#{i} 💞</div>
+                <div class="match-name">{p['name']} ({p['age']}세, {p['gender']})</div>
+                <div class="match-type">{mdt.get('emoji', '')} {mdt.get('name', '')} · {p.get('archetype', '')}</div>
+                <div class="match-score">매칭 적합도 <strong>{m['match_score']}%</strong></div>
+                <div class="match-reason">{reason}</div>
+            </div>''')
+            match_data.append({
+                "name": p["name"], "age": p["age"], "gender": p["gender"],
+                "type": m["type"], "match_score": m["match_score"],
+                "reason": reason,
+            })
+    except Exception:
+        chat_parts.append('<div class="bubble narration">매칭 데이터를 불러올 수 없습니다.</div>')
+
+    # ── HTML 조립 ──
     inner = "\n".join(chat_parts)
     game_html = f'''<div class="chat-container results" id="chatbox">
-    <div class="chat-inner">
     {inner}
-    {match_html}
-    </div>
-</div>'''
+</div>
+'''
 
     _save_log(state, best_type, scores, match_data, my_profile)
-
     state["phase"] = "results"
 
     return (
@@ -360,6 +790,9 @@ def _show_results(state):
         gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
         gr.update(value="🔄 다시 플레이", visible=True),
         gr.update(visible=False),
+        gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+        gr.update(visible=False),  # gender confirm btn
+        gr.update(), gr.update(), gr.update(), gr.update(),  # gender buttons
     )
 
 
@@ -369,6 +802,12 @@ def _save_log(state, best_type, scores, match_data, profile):
     ts = datetime.now().strftime("%Y%m%d_%H%M%S")
     run_log = {
         "timestamp": ts,
+        "user_gender": state["user_gender"],
+        "partner_gender": state["partner_gender"],
+        "characters": [
+            {"name": c["name"], "warmth": c["warmth"], "event_count": c["event_count"]}
+            for c in state["characters"]
+        ],
         "profile": profile,
         "events": state["event_logs"],
         "final_vector": state["trait_vector"],
@@ -380,301 +819,320 @@ def _save_log(state, best_type, scores, match_data, profile):
         json.dump(run_log, f, ensure_ascii=False, indent=2)
 
 
-def _hide_buttons():
-    return (
-        gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
-        gr.update(visible=False), gr.update(visible=False),
-    )
-
-
 # ── CSS ────────────────────────────────────────────────────
 
 CUSTOM_CSS = """
-footer {display: none !important}
+/* =========================
+   LoveLog Theme (Purple tone 유지)
+   - 유지보수용 토큰(변수) 기반
+   - !important 최소화
+   ========================= */
+
+footer { display: none !important; }
+
+/* ---- Theme tokens ---- */
+:root {
+  /* Brand purple palette */
+  --bg-0: #f3eaff;      /* top background */
+  --bg-1: #ede5f7;      /* panel background */
+  --ink-0: #1a1a1a;
+  --ink-1: #2d1b4e;     /* narration text */
+  --ink-2: #6b5b8a;     /* secondary text */
+  --brand-0: #5b21b6;   /* main purple */
+  --brand-1: #7c3aed;   /* accent purple */
+  --brand-2: #a78bfa;   /* soft border purple */
+  --brand-3: #d4bfff;   /* soft stroke */
+  --card-0: rgba(255, 255, 255, 0.92);
+  --glass-0: rgba(246, 239, 255, 0.86);
+
+  /* Radii & spacing */
+  --r-lg: 22px;
+  --r-md: 16px;
+  --r-sm: 12px;
+  --pad: 16px;
+  --gap: 10px;
+
+  /* Shadows */
+  --sh-1: 0 1px 4px rgba(139, 92, 246, 0.12);
+  --sh-2: 0 4px 14px rgba(124, 58, 237, 0.14);
+  --sh-inset: inset 0 1px 0 rgba(255, 255, 255, 0.35);
+
+  /* Focus ring */
+  --focus: 0 0 0 3px rgba(124, 58, 237, 0.16);
+}
 
-/* ── 전체 배경 ── */
+/* ---- App container ---- */
 .gradio-container {
-    background: linear-gradient(180deg, #f3eaff 0%, #ede5f7 100%) !important;
-    max-width: 640px !important;
-    margin: 0 auto !important;
+  background: linear-gradient(180deg, var(--bg-0) 0%, var(--bg-1) 100%) !important;
+  max-width: 640px !important;
+  margin: 0 auto !important;
 }
 
-/* ── 채팅 컨테이너 (스크롤 가능, 하단 고정) ── */
-.chat-container {
-    display: flex;
-    flex-direction: column-reverse;
-    padding: 0;
-    background: #ede5f7;
-    border-radius: 20px;
-    height: 520px;
-    overflow-y: auto;
-    scroll-behavior: smooth;
-}
+/* ---- Title area ---- */
+.title-area { text-align: center; padding: 10px 0 4px; }
+.title-area h1 { color: var(--brand-0) !important; font-size: 22px !important; }
+.title-area p  { color: var(--ink-2); font-size: 13.5px; }
 
-.chat-inner {
-    display: flex;
-    flex-direction: column;
-    gap: 10px;
-    padding: 20px 16px;
+/* ---- Welcome ---- */
+.welcome-container {
+  display: grid;
+  place-items: center;
+  gap: 14px;
+  padding: 56px 20px;
+  background: var(--bg-1);
+  border-radius: var(--r-lg);
+  height: 520px;
+  text-align: center;
+  box-shadow: var(--sh-1);
 }
+.welcome-emoji { font-size: 56px; }
+.welcome-title { font-size: 20px; font-weight: 800; color: var(--brand-0); }
+.welcome-desc  { font-size: 14px; color: var(--ink-2); line-height: 1.7; max-width: 320px; }
 
-.chat-container::-webkit-scrollbar {
-    width: 6px;
+/* ---- Chat container ---- */
+.chat-container {
+  display: flex;
+  flex-direction: column;
+  gap: var(--gap);
+  padding: 20px var(--pad);
+  background: var(--bg-1);
+  border-radius: var(--r-lg);
+  height: 520px;
+  overflow-y: auto;
+  scroll-behavior: smooth;
+  box-shadow: var(--sh-1);
 }
+.chat-container.results { height: 600px; }
+
+.chat-container::-webkit-scrollbar { width: 6px; }
 .chat-container::-webkit-scrollbar-thumb {
-    background: #c9b5ec;
-    border-radius: 3px;
-}
-.chat-container::-webkit-scrollbar-track {
-    background: transparent;
+  background: rgba(167, 139, 250, 0.65);
+  border-radius: 10px;
 }
 
-/* ── 구분선 (이벤트 헤더) ── */
+/* ---- Divider ---- */
 .chat-divider {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    margin: 12px 0 4px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 14px 0 4px;
 }
-
 .chat-divider span {
-    background: #d4c4f0;
-    color: #5b21b6;
-    font-size: 12px;
-    font-weight: 700;
-    padding: 4px 16px;
-    border-radius: 12px;
+  background: rgba(167, 139, 250, 0.35);
+  color: var(--brand-0);
+  font-size: 12px;
+  font-weight: 800;
+  padding: 6px 16px;
+  border-radius: 999px;
+  border: 1px solid rgba(124, 58, 237, 0.16);
 }
 
-/* ── 말풍선 공통 ── */
-.bubble {
-    max-width: 85%;
-    padding: 14px 18px;
-    border-radius: 18px;
-    font-size: 14.5px;
-    line-height: 1.7;
-    word-break: keep-all;
-    animation: fadeUp 0.25s ease;
+/* ---- Scene image ---- */
+.scene-art {
+  display: block;
+  width: 100%;
+  border-radius: var(--r-sm);
+  margin: 4px 0;
+  align-self: stretch;
+  box-shadow: 0 2px 10px rgba(26, 10, 46, 0.28);
 }
 
+/* ---- Bubbles (base) ---- */
+.bubble {
+  max-width: 86%;
+  padding: 14px 16px;
+  border-radius: 18px;
+  font-size: 14.5px;
+  line-height: 1.7;
+  word-break: keep-all;
+  animation: fadeUp 0.22s ease;
+}
 @keyframes fadeUp {
-    from { opacity: 0; transform: translateY(6px); }
-    to   { opacity: 1; transform: translateY(0); }
+  from { opacity: 0; transform: translateY(6px); }
+  to   { opacity: 1; transform: translateY(0); }
 }
 
-/* ── 지문 말풍선 (왼쪽, 보라) ── */
+/* Narration */
 .bubble.narration {
-    background: linear-gradient(135deg, #d0c0ec 0%, #c4b0e4 100%);
-    color: #2d1b4e;
-    align-self: flex-start;
-    border-bottom-left-radius: 4px;
-    box-shadow: 0 1px 4px rgba(139, 92, 246, 0.12);
+  background: linear-gradient(135deg, rgba(208, 192, 236, 0.95) 0%, rgba(196, 176, 228, 0.95) 100%);
+  color: var(--ink-1);
+  align-self: flex-start;
+  border-bottom-left-radius: 6px;
+  box-shadow: var(--sh-1);
+  border: 1px solid rgba(124, 58, 237, 0.10);
 }
 
-/* ── 유저 선택 말풍선 (오른쪽, 흰색) ── */
+/* User choice */
 .bubble.user-choice {
-    background: #ffffff;
-    color: #1a1a1a;
-    align-self: flex-end;
-    border-bottom-right-radius: 4px;
-    box-shadow: 0 1px 6px rgba(0, 0, 0, 0.08);
-    font-weight: 500;
+  background: rgba(255, 255, 255, 0.96);
+  color: var(--ink-0);
+  align-self: flex-end;
+  border-bottom-right-radius: 6px;
+  box-shadow: 0 1px 8px rgba(0,0,0,0.08);
+  border: 1px solid rgba(124, 58, 237, 0.10);
+  font-weight: 600;
 }
 
-/* ── 질문 말풍선 (지문과 동일) ── */
+/* Question (옵션: 기존 role="question" 쓰면 살아남) */
 .bubble.question {
-    background: linear-gradient(135deg, #d0c0ec 0%, #c4b0e4 100%);
-    color: #2d1b4e;
-    align-self: flex-start;
-    border-bottom-left-radius: 4px;
-    font-weight: 600;
-    font-size: 13.5px;
+  background: rgba(255, 255, 255, 0.65);
+  color: var(--brand-0);
+  border: 1px dashed rgba(124, 58, 237, 0.28);
+  align-self: flex-start;
 }
 
-/* ── 카카오톡 스타일 선택 버튼 (세로 배치) ── */
-.choice-column {
-    gap: 8px !important;
-    padding: 6px 0 !important;
+/* ---- Character card ---- */
+.bubble.char-card {
+  max-width: 92%;
+  border-left: 4px solid var(--brand-2);
+  padding: 16px 16px;
 }
-
+.char-name { font-size: 16px; font-weight: 900; color: var(--brand-0); }
+.char-info { font-size: 13px; color: var(--ink-2); margin-top: 2px; }
+.char-meeting { font-size: 12px; color: var(--brand-1); margin-top: 6px; font-weight: 700; }
+.char-scene { font-size: 13.5px; margin: 10px 0 6px; line-height: 1.65; }
+.char-dialogue { font-size: 13.5px; font-style: italic; color: rgba(74, 54, 112, 0.95); }
+
+/* ---- Choice buttons ---- */
+.choice-column { gap: 10px !important; padding: 8px 0 !important; }
 .choice-column button {
-    background: white !important;
-    border: 2px solid #d4bfff !important;
-    border-radius: 24px !important;
-    color: #5b21b6 !important;
-    font-size: 14px !important;
-    font-weight: 500 !important;
-    padding: 13px 20px !important;
-    text-align: left !important;
-    transition: all 0.2s cubic-bezier(.4,0,.2,1) !important;
-    box-shadow: 0 1px 4px rgba(139, 92, 246, 0.08) !important;
-    min-height: 48px !important;
-    cursor: pointer !important;
+  width: 100%;
+  background: rgba(255, 255, 255, 0.94) !important;
+  border: 2px solid rgba(212, 191, 255, 0.95) !important;
+  border-radius: 999px !important;
+  color: var(--brand-0) !important;
+  font-size: 14px !important;
+  font-weight: 700 !important;
+  padding: 13px 18px !important;
+  text-align: left !important;
+  transition: transform 0.16s ease, box-shadow 0.16s ease, background 0.16s ease, border-color 0.16s ease !important;
+  box-shadow: 0 1px 6px rgba(139, 92, 246, 0.10) !important;
+  min-height: 48px !important;
+  cursor: pointer !important;
 }
-
 .choice-column button:hover {
-    background: linear-gradient(135deg, #f5f0ff 0%, #ede5ff 100%) !important;
-    border-color: #a78bfa !important;
-    transform: translateY(-2px) !important;
-    box-shadow: 0 4px 16px rgba(139, 92, 246, 0.18) !important;
+  background: linear-gradient(135deg, rgba(245, 240, 255, 0.98) 0%, rgba(237, 229, 255, 0.98) 100%) !important;
+  border-color: rgba(167, 139, 250, 0.95) !important;
+  transform: translateY(-2px) !important;
+  box-shadow: var(--sh-2) !important;
 }
-
-.choice-column button:active {
-    transform: translateY(0) !important;
-    background: #ede5ff !important;
+.choice-column button:focus-visible {
+  outline: none !important;
+  box-shadow: var(--sh-2), var(--focus) !important;
 }
 
-/* ── 시작/재시작 버튼 ── */
+/* ---- Start/Restart (CTA) ---- */
 .start-btn button {
-    background: linear-gradient(135deg, #8b5cf6 0%, #7c3aed 100%) !important;
-    border: none !important;
-    border-radius: 16px !important;
-    color: white !important;
-    font-size: 16px !important;
-    font-weight: 700 !important;
-    padding: 16px 32px !important;
-    box-shadow: 0 4px 20px rgba(124, 58, 237, 0.3) !important;
-    transition: all 0.2s ease !important;
+  background: rgba(255, 255, 255, 0.94) !important;
+  border: 2px solid rgba(212, 191, 255, 0.95) !important;
+  border-radius: 999px !important;
+  color: var(--brand-0) !important;
+  font-size: 15px !important;
+  font-weight: 900 !important;
+  padding: 14px 22px !important;
+  box-shadow: 0 1px 8px rgba(139, 92, 246, 0.12) !important;
+  transition: transform 0.16s ease, box-shadow 0.16s ease, background 0.16s ease, border-color 0.16s ease !important;
 }
-
 .start-btn button:hover {
-    transform: translateY(-2px) !important;
-    box-shadow: 0 6px 24px rgba(124, 58, 237, 0.4) !important;
+  background: linear-gradient(135deg, rgba(245, 240, 255, 0.98) 0%, rgba(237, 229, 255, 0.98) 100%) !important;
+  border-color: rgba(167, 139, 250, 0.95) !important;
+  transform: translateY(-2px) !important;
+  box-shadow: var(--sh-2) !important;
 }
-
-/* ── 결과 화면 ── */
-.results {
-    height: 600px;
+.start-btn button:active { transform: translateY(0) scale(0.99) !important; }
+.start-btn button:focus-visible {
+  outline: none !important;
+  box-shadow: var(--sh-2), var(--focus) !important;
 }
 
-.result-header {
-    text-align: center;
-    padding: 24px !important;
+/* ---- Gender selection panel ---- */
+.gender-panel {
+  gap: 10px !important;
+  padding: 20px !important;
+  border-radius: var(--r-lg) !important;
+  background: linear-gradient(145deg, rgba(243, 236, 255, 0.92), rgba(233, 224, 250, 0.90)) !important;
+  border: 1px solid rgba(124, 58, 237, 0.14) !important;
+  box-shadow: 0 4px 14px rgba(91, 33, 182, 0.08) !important;
 }
-
-.result-emoji {
-    font-size: 48px;
-    margin-bottom: 8px;
+.gender-label { margin: 4px 0 0 !important; }
+.gender-label p { font-size: 13px !important; font-weight: 700 !important; color: var(--brand-0) !important; margin: 0 !important; }
+.gender-btn-row { gap: 8px !important; }
+.gender-btn button {
+  background: unset !important;
+  border: 2px solid var(--brand-3) !important;
+  border-radius: 999px !important;
+  color: var(--brand-0) !important;
+  font-size: 14px !important;
+  font-weight: 700 !important;
+  padding: 10px 0 !important;
+  cursor: pointer !important;
+  transition: all 0.16s ease !important;
+  min-height: unset !important;
 }
-
-.result-title {
-    font-size: 20px;
-    font-weight: 800;
-    color: #5b21b6;
-    margin-bottom: 6px;
+.gender-btn button:hover {
+  border-color: var(--brand-1) !important;
+  background: rgba(124, 58, 237, 0.06) !important;
 }
 
-.result-desc {
-    font-size: 13.5px;
-    color: #6b5b8a;
-    line-height: 1.5;
-}
+/* ---- Results ---- */
+.result-header { text-align: center; padding: 22px 18px !important; }
+.result-emoji { font-size: 48px; margin-bottom: 8px; }
+.result-title { font-size: 20px; font-weight: 900; color: var(--brand-0); margin-bottom: 6px; }
+.result-desc  { font-size: 13.5px; color: var(--ink-2); line-height: 1.55; }
 
-.section-title {
-    font-size: 14px;
-    font-weight: 700;
-    color: #7c3aed;
-    margin-bottom: 8px;
-}
+.section-title { font-size: 14px; font-weight: 900; color: var(--brand-1); margin-bottom: 8px; }
 
-.profile-content {
-    font-size: 13px;
-    line-height: 1.6;
-}
+.profile-content { font-size: 13px; line-height: 1.65; }
 
 .profile-json {
-    background: #f8f5ff;
-    border-radius: 10px;
-    padding: 12px;
-    font-size: 11.5px;
-    overflow-x: auto;
-    color: #3b1f6e;
-    border: 1px solid #e2d5f5;
-}
-
-.match-card {
-    border-left: 4px solid #a78bfa !important;
-}
-
-.match-rank {
-    font-size: 16px;
-    font-weight: 700;
-}
-
-.match-name {
-    font-size: 15px;
-    font-weight: 600;
-    color: #5b21b6;
-    margin: 4px 0;
-}
-
-.match-type {
-    font-size: 12.5px;
-    color: #7c6b9e;
-    margin-bottom: 4px;
-}
-
-.match-score {
-    font-size: 12.5px;
-    color: #4a3670;
-}
-
-/* ── 타이틀 ── */
-.title-area {
-    text-align: center;
-    padding: 6px 0 2px;
-}
-
-.title-area h1 {
-    color: #5b21b6 !important;
-    font-size: 22px !important;
-}
-
-.title-area p {
-    color: #7c6b9e;
-    font-size: 13.5px;
-}
-
-/* ── 웰컴 화면 ── */
-.welcome-container {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    gap: 16px;
-    padding: 60px 20px;
-    background: #ede5f7;
-    border-radius: 20px;
-    height: 520px;
-    text-align: center;
+  background: rgba(248, 245, 255, 0.98);
+  border-radius: var(--r-sm);
+  padding: 12px;
+  font-size: 11.5px;
+  overflow-x: auto;
+  color: rgba(59, 31, 110, 0.98);
+  border: 1px solid rgba(226, 213, 245, 0.95);
 }
 
-.welcome-emoji {
-    font-size: 56px;
-}
-
-.welcome-title {
-    font-size: 20px;
-    font-weight: 700;
-    color: #5b21b6;
-}
+/* Match card */
+.match-card { border-left: 4px solid var(--brand-2) !important; }
+.match-rank { font-size: 16px; font-weight: 900; }
+.match-name { font-size: 15px; font-weight: 800; color: var(--brand-0); margin: 6px 0 2px; }
+.match-type { font-size: 12.5px; color: rgba(124, 107, 158, 0.98); margin-bottom: 4px; }
+.match-score { font-size: 12.5px; color: rgba(74, 54, 112, 0.98); }
+.match-reason { font-size: 12px; color: var(--ink-2); margin-top: 6px; font-style: italic; line-height: 1.5; }
+
+/* Choice history log */
+.choice-log { border-left: 3px solid var(--brand-2) !important; padding: 12px 14px !important; }
+.log-stage { font-size: 12px; font-weight: 800; color: var(--brand-1); margin-bottom: 6px; }
+.log-choice { font-size: 13px; margin: 3px 0; }
+.log-effects { font-size: 11.5px; color: var(--ink-2); margin-bottom: 4px; }
+.log-warmth { font-size: 11.5px; color: var(--ink-2); margin-top: 6px; }
+
+/* Analysis card */
+.analysis-card { background: linear-gradient(135deg, rgba(220, 210, 245, 0.95), rgba(200, 185, 230, 0.95)) !important; }
+.analysis-summary { font-size: 14px; line-height: 1.7; margin-bottom: 10px; }
+.analysis-list { font-size: 13px; line-height: 1.6; margin: 4px 0; }
+.analysis-tip { font-size: 13px; font-style: italic; color: var(--brand-0); margin-top: 10px; padding: 8px 12px; background: rgba(255,255,255,0.5); border-radius: var(--r-sm); }
 
-.welcome-desc {
-    font-size: 14px;
-    color: #6b5b8a;
-    line-height: 1.7;
-    max-width: 300px;
-}
 """
 
+theme = gr.themes.Soft(primary_hue="purple").set(
+    input_background_fill="rgba(255,255,255,0.30)",
+    input_background_fill_hover="rgba(255,255,255,0.38)",
+    input_background_fill_focus="rgba(255,255,255,0.45)",
+    input_border_color="rgba(124,58,237,0.30)",
+    input_border_color_focus="rgba(124,58,237,0.60)",
+)
+
 WELCOME_HTML = """<div class="welcome-container">
     <div class="welcome-emoji">💜</div>
-    <div class="welcome-title">Love Run을 시작하세요</div>
+    <div class="welcome-title">러브로그에 오신 것을 환영합니다</div>
     <div class="welcome-desc">
         가상의 연애 상황을 체험하며<br>
         당신의 성향을 발견하세요.<br><br>
-        플레이가 끝나면,<br>
-        당신과 맞는 인연을 찾아드립니다.
+        세 사람 중 한 명을 선택하고,<br>
+        관계의 결말까지 경험해보세요.
     </div>
 </div>"""
 
@@ -683,7 +1141,7 @@ WELCOME_HTML = """<div class="welcome-container">
 
 with gr.Blocks(
     title="💜 러브로그",
-    theme=gr.themes.Soft(primary_hue="purple"),
+    theme=theme,
     css=CUSTOM_CSS,
 ) as app:
 
@@ -693,16 +1151,33 @@ with gr.Blocks(
     )
 
     state = gr.State(new_state())
-
     game_display = gr.HTML(WELCOME_HTML)
 
+    # 성별 선택 패널 (버튼형)
+    with gr.Column(visible=False, elem_classes=["gender-panel"]) as gender_row:
+        gr.Markdown("당신의 성별", elem_classes=["gender-label"])
+        with gr.Row(elem_classes=["gender-btn-row"]):
+            my_male_btn = gr.Button("남성", elem_classes=["gender-btn"], variant="secondary")
+            my_female_btn = gr.Button("여성", elem_classes=["gender-btn"], variant="secondary")
+        gr.Markdown("상대의 성별", elem_classes=["gender-label"])
+        with gr.Row(elem_classes=["gender-btn-row"]):
+            other_male_btn = gr.Button("남성", elem_classes=["gender-btn"], variant="secondary")
+            other_female_btn = gr.Button("여성", elem_classes=["gender-btn"], variant="secondary")
+    gnd_my = gr.Textbox(visible=False)
+    gnd_other = gr.Textbox(visible=False)
+
+    gender_confirm_btn = gr.Button(
+        "💜 이어서하기", visible=False, variant="huggingface", size="lg",
+        elem_classes=["start-btn"],
+    )
+
     with gr.Column(elem_classes=["choice-column"]):
         btn_a = gr.Button("A", visible=False, variant="secondary", scale=1)
         btn_b = gr.Button("B", visible=False, variant="secondary", scale=1)
         btn_c = gr.Button("C", visible=False, variant="secondary", scale=1)
 
     start_btn = gr.Button(
-        "💜 Love Run 시작", variant="huggingface", size="lg",
+        "💜 시작하기", variant="huggingface", size="lg",
         elem_classes=["start-btn"],
     )
     restart_btn = gr.Button(
@@ -710,13 +1185,58 @@ with gr.Blocks(
         elem_classes=["start-btn"],
     )
 
-    outputs = [state, game_display, btn_a, btn_b, btn_c, restart_btn, start_btn]
+    outputs = [state, game_display, btn_a, btn_b, btn_c, restart_btn, start_btn, gender_row, gnd_my, gnd_other, gender_confirm_btn, my_male_btn, my_female_btn, other_male_btn, other_female_btn]
+
+    # 자동 스크롤 JS — .then()으로 Python 핸들러 완료 후 실행
+    SCROLL_JS = """
+    () => {
+        function sb() {
+            const el = document.getElementById('chatbox');
+            if (el) el.scrollTop = el.scrollHeight;
+        }
+        setTimeout(sb, 80);
+        setTimeout(sb, 300);
+        setTimeout(sb, 800);
+    }
+    """
+
+    # 시작 → 성별 선택 화면
+    start_btn.click(fn=on_start, inputs=[state], outputs=outputs).then(fn=None, js=SCROLL_JS)
+    restart_btn.click(fn=on_start, inputs=[state], outputs=outputs).then(fn=None, js=SCROLL_JS)
+
+    # 성별 버튼 클릭
+    my_male_btn.click(
+        fn=lambda: ("남성", gr.update(value="✓ 남성"), gr.update(value="여성")),
+        outputs=[gnd_my, my_male_btn, my_female_btn],
+    )
+    my_female_btn.click(
+        fn=lambda: ("여성", gr.update(value="남성"), gr.update(value="✓ 여성")),
+        outputs=[gnd_my, my_male_btn, my_female_btn],
+    )
+    other_male_btn.click(
+        fn=lambda: ("남성", gr.update(value="✓ 남성"), gr.update(value="여��")),
+        outputs=[gnd_other, other_male_btn, other_female_btn],
+    )
+    other_female_btn.click(
+        fn=lambda: ("여성", gr.update(value="남성"), gr.update(value="✓ 여성")),
+        outputs=[gnd_other, other_male_btn, other_female_btn],
+    )
+
+    # 성별 선택 완료 → 이어서하기 버튼 클릭 시 게임 시작
+    gender_confirm_btn.click(
+        fn=on_gender_select,
+        inputs=[gnd_my, gnd_other, state],
+        outputs=outputs,
+    ).then(fn=None, js=SCROLL_JS)
+
+    # 선택 버튼
+    btn_a.click(fn=lambda s: on_choice(0, s), inputs=[state], outputs=outputs).then(fn=None, js=SCROLL_JS)
+    btn_b.click(fn=lambda s: on_choice(1, s), inputs=[state], outputs=outputs).then(fn=None, js=SCROLL_JS)
+    btn_c.click(fn=lambda s: on_choice(2, s), inputs=[state], outputs=outputs).then(fn=None, js=SCROLL_JS)
 
-    start_btn.click(fn=on_start, inputs=[state], outputs=outputs)
-    restart_btn.click(fn=on_start, inputs=[state], outputs=outputs)
+def launch(share: bool = False):
+    app.launch(share=share, debug=True)
 
-    btn_a.click(fn=lambda s: on_choice(0, s), inputs=[state], outputs=outputs)
-    btn_b.click(fn=lambda s: on_choice(1, s), inputs=[state], outputs=outputs)
-    btn_c.click(fn=lambda s: on_choice(2, s), inputs=[state], outputs=outputs)
 
-app.launch(share=True)
+if __name__ == "__main__":
+    launch(share=False)

gpt_engine.py

@@ -1,224 +1,514 @@
-"""GPT API 엔진 — 시나리오 이벤트 생성"""
+"""GPT API 엔진 — 스테이지 기반 이벤트 생성"""
 
 import json
+import time
 from openai import OpenAI
+from scene_art import SCENE_TAGS_STR
+
+MAX_RETRIES = 2
+RETRY_DELAY = 1.0  # seconds
+
+
+def _chat_with_retry(client: OpenAI, *, model: str, messages: list,
+                     temperature: float = 0.9, retries: int = MAX_RETRIES) -> dict:
+    """GPT chat completion with retry on failure."""
+    last_err = None
+    for attempt in range(1 + retries):
+        try:
+            resp = client.chat.completions.create(
+                model=model, messages=messages,
+                response_format={"type": "json_object"},
+                temperature=temperature,
+            )
+            return json.loads(resp.choices[0].message.content)
+        except Exception as e:
+            last_err = e
+            if attempt < retries:
+                time.sleep(RETRY_DELAY)
+    raise last_err
 
 SYSTEM_PROMPT = """\
-너는 '러브로그'라는 로그라이크 연애 시뮬레이션의 시나리오 작가야.
-유저는 가상의 연애 상황을 체험하며 자신의 성향을 드러내게 된다.
-
-■ 서사 규칙:
-- 상황 묘사는 게임 시나리오처럼 장면을 보여준다.
-- 상대방은 이름 없이 "그 사람", "상대" 등으로 지칭한다.
-- 대화체는 자연스러운 한국어.
-- 모든 응답은 지정된 JSON 형식으로만 출력한다.
+너는 20-30대 커플의 연애 과정을 관찰하는 다큐멘터리 감독이다.
+카메라는 그냥 거기 있고, 두 사람은 카메라를 의식하지 않는다.
+유저는 이 상황 속 한 사람이 되어 자신의 성향을 자연스럽게 드러낸다.
+
+■ 관찰 규칙:
+- 감정을 설명하지 마라. 행동만 보여줘라.
+  ❌ "설레는 마음을 감추며" / "묘한 긴장감이 흐른다"
+  ✅ "괜히 메뉴판을 두 번 넘긴다" / "핸드폰을 만지작거리다가 올려다본다"
+- 구체적인 디테일을 써라.
+  ❌ "카페에서 대화를 나눈다"
+  ✅ "을지로 골목 2층, 창가 자리. 아이스 아메리카노 얼음이 거의 녹았다."
+- 어색한 순간, 침묵, 타이밍을 놓치는 순간을 자연스럽게 넣어라.
+- 드라마틱한 이벤트(사고, 우연의 일치, 갑작스러운 고백)는 최소화.
+
+■ 캐릭터:
+- 상대방의 이름, 직업, 성격, 말투 정보가 주어진다.
+- 상대 대사는 반드시 그 캐릭터의 speech_style에 맞게 작성하라.
+- 상대를 이름으로 지칭한다.
+- 상대의 행동/대사도 situation과 reaction에 포함시켜라.
+
+■ 대사 규칙:
+- 실제 20-30대가 대면이나 카톡에서 쓰는 말투 그대로.
+  ❌ "의외로 너 이런 분위기도 잘 어울린다"
+  ✅ "아 근데 여기 생각보다 괜찮다 진짜"
+- 말이 끊기거나, 얼버무리거나, 웃음으로 때우는 것도 자연스러움.
+- 큰따옴표 없이 문장만 작성.
+
+■ 선택지:
+- text는 유저가 직접 말하는 대사 + 짧은 행동 묘사 가능.
+  ✅ "아 진짜? 하며 웃는다"
+  ✅ "핸드폰을 꺼내 연락처를 건넨다"
+  ✅ "... 괜찮아, 별거 아니야"
+- 3개. 정답 없음.
+- "이 상황에서 실제로 사람들이 하는 서로 다른 반응"이어야 한다.
+- 적극/회피/관망 같은 고정 프레임 금지.
+
+■ 달달함과 갈등:
+- 달달함 = 사소한 순간. 같이 편의점에서 뭐 먹을지 고르기, 걷다가 손이 스치기.
+- 갈등 = 현실적 마찰. 답장 늦기, 약속 까먹기, 사소한 말투 차이.
+
+■ 난입 규칙:
+- 난입 이벤트가 요청되면: 현재 상대와 관계가 애매해진 상황에서, 다른 캐릭터가 자연스럽게 등장한다.
+- 난입 방식: 카톡이 온다, 우연히 마주친다, 같이 밥 먹자고 연락 온다 등.
+- 유저가 마음이 흔들릴 수 있는 상황을 만들어라.
 
 ■ 연결된 서사:
-- 이전 이벤트의 상황과 유저의 선택이 주어지면, 새로운 상황은 반드시 그 맥락 위에서 자연스럽게 이어져야 한다.
-- 마치 드라마의 다음 회차처럼, 이전 선택의 결과가 새로운 상황의 배경이 되어야 한다.
-- 같은 "그 사람"이 등장하되, 관계가 이전 선택에 따라 변화한다.
-
-■ 선택지 설계 (매우 중요):
-- 선택지는 반드시 3개. 정답은 없다.
-- 3개의 선택지는 반드시 방향이 완전히 달라야 한다:
-  A = 적극적/다가가는 방향 (예: 직접 말을 건다, 솔직하게 표현한다)
-  B = 회피적/거리를 두는 방향 (예: 모른 척한다, 자리를 피한다, 냉담하게 반응한다)
-  C = 관망/전략적 방향 (예: 상황을 지켜본다, 다른 방법을 찾는다)
-- 절대로 3개가 모두 긍정적이면 안 된다. 반드시 부정적/회피적 선택지를 포함해야 한다.
-- 유저가 어떤 선택을 해도 이야기가 이어지되, 선택에 따라 관계의 온도가 확연히 달라져야 한다.
-
-■ 대사 규칙 (매우 중요):
-- 선택지의 text는 반���시 유저가 직접 말하는 **대사**만 작성한다. 행동 묘사 절대 금지.
-  ✅ "괜찮아, 오늘 재밌었어." / "저기… 혹시 같이 걸을래요?"
-  ❌ 상대에게 다가가 어깨를 두드린다 / 살짝 고개를 들어 미소를 짓는다
-- 대사는 자연스러운 구어체로. 큰따옴표 없이 문장만 작성.
+- 이전 이벤트의 상황과 유저의 선택이 주어지면, 새로운 상황은 그 맥락 위에서 자연스럽게 이어져야 한다.
 
 ■ 볼드 규칙:
-- situation, reaction 묘사에서 핵심 감정·행동·분위기 단어는 **볼드**로 강조한다.
-  예: "그 사람이 **살짝 미소** 지으며 고개를 **끄덕**인다."
+- 눈에 보이는 행동이나 구체적 사물만 **볼드**로 강조.
+
+■ 1턴 vs 2턴:
+- 1턴 = 이 상황에서 뭘 할 것인가
+- 2턴 = 상대 반응을 본 뒤, 어떻게 이어갈 것인가
+- 2턴의 상황 전개는 1턴 선택에 따라 완전히 달라져야 한다.
 
-■ 1턴 vs 2턴 구분:
-- 1턴 선택지 = "행동의 방향" (무엇을 할 것인가? 다가갈 것인가, 피할 것인가, 지켜볼 것인가)
-- 2턴 선택지 = "표현의 방식" (어떤 톤으로 말할 것인가? 진지하게, 장난스럽게, 차갑게)
-- 2턴의 상황 전개(reaction)는 1턴 선택에 따라 완전히 달라져야 한다.
+■ 모든 응답은 지정된 JSON 형식으로만 출력한다.
 """
 
 
+def _char_context(character: dict) -> str:
+    """캐릭터 정보를 프롬프트용 문자열로."""
+    return (
+        f"이름: {character['name']} ({character['age']}세, {character['job']})\n"
+        f"성격: {character['personality']}\n"
+        f"말투: {character['speech_style']}"
+    )
+
+
 def _build_story_context(event_logs: list[dict]) -> str:
-    """이전 이벤트 요약 — 꼬리에 꼬리를 무는 서사를 위한 컨텍스트"""
+    """이전 이벤트 요약."""
     if not event_logs:
         return "없음 (첫 번째 이벤트)"
-
     lines = []
-    for log in event_logs[-3:]:  # 최근 3개까지
-        scenario_name = log.get("scenario", "?")
+    for log in event_logs[-3:]:
+        name = log.get("scenario", "?")
         situation = log.get("situation", "")
         reaction = log.get("reaction", "")
-        turn1 = log.get("turn1", {}).get("selected", {}).get("text", "")
-        turn2 = log.get("turn2", {}).get("selected", {}).get("text", "")
+        t1 = log.get("turn1", {}).get("selected", {}).get("text", "")
+        t2 = log.get("turn2", {}).get("selected", {}).get("text", "")
         lines.append(
-            f"[{scenario_name}] 상황: {situation[:80]}... "
-            f"→ 유저 선택1: \"{turn1}\" → 전개: {reaction[:60]}... "
-            f"→ 유저 선택2: \"{turn2}\""
+            f"[{name}] {situation[:80]}... → 유저: \"{t1}\" → {reaction[:60]}... → 유저: \"{t2}\""
         )
     return "\n".join(lines)
 
 
+# ── 첫만남 장면 배치 생성 (1 GPT call) ──────────────────────
+
+def generate_first_meetings(
+    client: OpenAI,
+    characters: list[dict],
+    model: str = "gpt-4o-mini",
+) -> list[dict]:
+    """3명 캐릭터의 첫만남 장면을 한번에 생성."""
+    char_descriptions = []
+    for i, c in enumerate(characters):
+        char_descriptions.append(
+            f"캐릭터 {i+1}:\n"
+            f"  {_char_context(c)}\n"
+            f"  첫만남 유형: {c['meeting_type']} — {c['meeting_desc']}"
+        )
+    chars_str = "\n\n".join(char_descriptions)
+
+    user_prompt = f"""\
+아래 3명의 캐릭터와의 첫만남 장면을 각각 만들어줘.
+각 장면은 그 캐릭터의 성격/말투에 맞는 짧은 상황 묘사(2~3문장)와 상대의 첫 대사를 포함해야 한다.
+
+{chars_str}
+
+아래 JSON 형식으로:
+{{
+  "meetings": [
+    {{
+      "character_id": 0,
+      "situation": "다큐 카메라가 포착한 첫만남 장면. 2~3문장. 핵심 행동은 **볼드**.",
+      "dialogue": "상대방의 첫 대사 (캐릭터 말투에 맞게)"
+    }},
+    {{
+      "character_id": 1,
+      "situation": "...",
+      "dialogue": "..."
+    }},
+    {{
+      "character_id": 2,
+      "situation": "...",
+      "dialogue": "..."
+    }}
+  ]
+}}
+"""
+    data = _chat_with_retry(
+        client, model=model,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_prompt},
+        ],
+    )
+    return data.get("meetings", [])
+
+
+# ── 스테이지 이벤트 생성 ─────────────────────────────────────
+
 def generate_event(
     client: OpenAI,
-    scenario: dict,
+    stage: dict,
+    character: dict,
+    warmth: float,
     current_traits: dict,
-    prev_choices: list[str],
     event_logs: list[dict] = None,
+    variant: str = "normal",
     model: str = "gpt-4o-mini",
 ) -> dict:
-    """이벤트 1턴(감정태그 + 상황 + 선택지) 생성"""
-
-    axes_str = ", ".join(scenario["axes"])
+    """이벤트 1턴(상황 + 선택지) 생성."""
+    axes_str = ", ".join(stage["axes"])
     story_context = _build_story_context(event_logs or [])
+    char_str = _char_context(character)
 
-    user_prompt = f"""\
-상황 카테고리: {scenario['name']} — {scenario['desc']}
-측정 축: {axes_str}
-유저 현재 성향: {json.dumps(current_traits, ensure_ascii=False)}
+    warmth_desc = "차가움" if warmth < 2 else ("미지근" if warmth < 5 else "따뜻함")
+    variant_hint = ""
+    if variant == "cold":
+        variant_hint = "관계가 멀어지고 있다. 연락이 뜸해지고, 대화가 어색해지는 방향으로."
+    elif variant == "warm":
+        variant_hint = "관계가 깊어지고 있다. 서로에 대한 확신이 생기는 방향으로."
 
-═══ 이전 이벤트 흐름 (이 맥락 위에서 이어지는 상황을 만들어야 함) ═══
+    traits_str = json.dumps(current_traits, ensure_ascii=False)
+    user_prompt = f"""\
+═══ 상대 캐릭터 ═══
+{char_str}
+═══ 관계 상태 ═══
+스테이지: {stage['name']} — {stage['desc']}
+관계 온도: {warmth:.1f} ({warmth_desc})
+유저 현재 성향: {traits_str}
+{variant_hint}
+═══ 이전 흐름 ═══
 {story_context}
-═══════════════════════════════════════════════════════════
+═══ 측정 축 ═══
+{axes_str}
 
-위 이전 이벤트의 결과를 자연스럽게 이어받아, 새로운 상황을 만들어줘.
-이전에 유저가 한 선택의 결과가 이번 상황의 배경이 되어야 한다.
-마치 드라마의 다음 회차처럼, 관계와 감정이 이전에서 이어진다.
+위 맥락에 이어지는 현실적인 상황을 만들어줘.
+상대({character['name']})의 대사와 행동을 캐릭터 성격/말투에 맞게 포함시켜.
 
-아래 JSON 형식으로 이벤트를 생성해줘:
+아래 JSON 형식으로:
 {{
-  "emotion_tag": {{
-    "question": "이 상황에서 당신의 첫 감정은?",
-    "options": [
-      {{"id": "A", "emoji": "...", "label": "긍정적 감정", "trait_effect": {{"축1": 변화량, "축2": 변화량, "축3": 변화량}} }},
-      {{"id": "B", "emoji": "...", "label": "부정적 감정", "trait_effect": {{"축1": 변화량, "축2": 변화량, "축3": 변화량}} }},
-      {{"id": "C", "emoji": "...", "label": "중립적 감정", "trait_effect": {{"축1": 변화량, "축2": 변화량, "축3": 변화량}} }}
-    ]
-  }},
-  "situation": "게임 시나리오처럼 장면을 보여주는 상황 묘사 (3~5문장). 상대방은 '그 사람' 등으로 지칭. 핵심 단어는 **볼드**.",
+  "scene_tag": "장소 태그",
+  "situation": "다큐 카메라가 포착한 장면. 상대 이름/대사 포함. 3~5문장. 핵심 행동은 **볼드**.",
   "choices": [
-    {{"id": "A", "direction": "approach", "text": "적극적으로 다가가는 유저 대사 (직접 말하는 문장만)", "trait_effect": {{...4~6개 축...}} }},
-    {{"id": "B", "direction": "avoid", "text": "회피하거나 거리를 두는 유저 대사 (직접 말하는 문장만)", "trait_effect": {{...4~6개 축...}} }},
-    {{"id": "C", "direction": "observe", "text": "관망하거나 전략적인 유저 대사 (직접 말하는 문장만)", "trait_effect": {{...4~6개 축...}} }}
+    {{"id": "A", "text": "현실적 대사 또는 행동", "warmth_delta": 0.0, "trait_effect": {{...4~6개 축...}} }},
+    {{"id": "B", "text": "다른 방향의 반응", "warmth_delta": 0.0, "trait_effect": {{...4~6개 축...}} }},
+    {{"id": "C", "text": "또 다른 방향의 반응", "warmth_delta": 0.0, "trait_effect": {{...4~6개 축...}} }}
   ]
 }}
 
-★ 1턴 선택지 = 행동의 방향 (text는 반드시 유저가 직접 말하는 대사):
-- A(approach): 적극적, 직진, 솔직한 대사 → pace/extraversion/affection 등 양수
-- B(avoid): 회피, 냉담, 거부하는 대사 → pace/affection 등 음수, jealousy/neuroticism 양수 가능
-- C(observe): 관망, 탐색, 전략적인 대사 → planning/conscientiousness/leadership 양수
-- 3개 선택지의 trait_effect 방향이 확연히 달라야 한다 (양수 vs 음수)
-
-★ trait_effect 규칙:
-- 감정 태그: 2~3개 축, 선택지: 4~6개 축 (행동 축 + Big Five 혼합)
-- 변화량은 -1.0 ~ 1.0. 회피/부정 선택은 음수 값을 적극 활용
-- 15축: cooperation, leadership, emotional_depth, pace, humor, risk, contact_frequency, affection, jealousy, planning, openness, conscientiousness, extraversion, agreeableness, neuroticism
+★ scene_tag: 장면이 벌어지는 장소. 다음 중 하나: {SCENE_TAGS_STR}
+★ warmth_delta: 이 선택이 관계 온도에 미치는 영향. -2.0 ~ 2.0 범위.
+  가까워지는 선택은 양수, 멀어지는 선택은 음수.
+★ trait_effect: 4~6개 축, -1.0 ~ 1.0
+  15축: cooperation, leadership, emotional_depth, pace, humor, risk, contact_frequency, affection, jealousy, planning, openness, conscientiousness, extraversion, agreeableness, neuroticism
 """
-
-    resp = client.chat.completions.create(
-        model=model,
+    return _chat_with_retry(
+        client, model=model,
         messages=[
             {"role": "system", "content": SYSTEM_PROMPT},
             {"role": "user", "content": user_prompt},
         ],
-        response_format={"type": "json_object"},
-        temperature=0.9,
     )
 
-    return json.loads(resp.choices[0].message.content)
-
 
-def generate_trait_summary(
+def generate_reaction(
     client: OpenAI,
-    profile: dict,
-    type_name: str,
-    model: str = "gpt-4o-mini",
-) -> str:
-    """15축 성향 벡터를 자연어로 간단히 설명"""
+    stage: dict,
+    character: dict,
+    situation: str,
+    user_choice: dict,
+    event_logs: list[dict] = None,
+    model: str = "gpt-5-chat-latest",
+) -> dict:
+    """상황 전개 + 2턴 선택지 생성."""
+    axes_str = ", ".join(stage["axes"])
+    story_context = _build_story_context(event_logs or [])
+    char_str = _char_context(character)
 
-    prompt = f"""\
-유저의 연애 성향 분석 결과야. 아래 데이터를 바탕으로 2~3문장으로 자연스럽게 요약해줘.
-- 숫자나 축 이름을 직접 노출하지 마.
-- 유저가 어떤 연애 스타일인지, 어떤 점이 매력적인지 따뜻하게 설명해.
-- 반말 금지, 존댓말 사용.
+    user_prompt = f"""\
+═══ 상대 캐릭터 ═══
+{char_str}
+═══ 지금까지의 흐름 ═══
+{story_context}
+═══════════════════════
 
-유형: {type_name}
-행동 성향: {profile.get('traits', {{}})}
-성격: {profile.get('big_five', {{}})}
-"""
+현재 상황: {situation}
+유저가 한 것: {user_choice['text']}
+측정 축: {axes_str}
 
-    resp = client.chat.completions.create(
-        model=model,
-        messages=[{"role": "user", "content": prompt}],
-        temperature=0.7,
-        max_tokens=200,
+유저가 "{user_choice['text']}"라고 했다/했다.
+{character['name']}의 반응을 캐릭터 성격/말투에 맞게 보여줘.
+
+아래 JSON 형식으로:
+{{
+  "reaction": "{character['name']}의 반응. 감정 설명 없이 행동/표정/대사만. 2~3문장. 핵심 행동은 **볼드**.",
+  "choices": [
+    {{"id": "A", "text": "현실적 후속 반응", "warmth_delta": 0.0, "trait_effect": {{...4~6개 축...}} }},
+    {{"id": "B", "text": "다른 방향", "warmth_delta": 0.0, "trait_effect": {{...4~6개 축...}} }},
+    {{"id": "C", "text": "또 다른 방향", "warmth_delta": 0.0, "trait_effect": {{...4~6개 축...}} }}
+  ]
+}}
+
+★ warmth_delta: -2.0 ~ 2.0. 가까워지면 양수, 멀어지면 음수.
+★ trait_effect: 4~6개 축, -1.0 ~ 1.0
+15축: cooperation, leadership, emotional_depth, pace, humor, risk, contact_frequency, affection, jealousy, planning, openness, conscientiousness, extraversion, agreeableness, neuroticism
+"""
+    return _chat_with_retry(
+        client, model=model,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_prompt},
+        ],
     )
-    return resp.choices[0].message.content.strip()
 
 
-def generate_reaction(
+# ── 난입 이벤트 생성 ─────────────────────────────────────────
+
+def generate_interruption(
     client: OpenAI,
-    scenario: dict,
-    situation: str,
-    user_choice: dict,
+    current_char: dict,
+    interrupting_char: dict,
+    warmth: float,
     event_logs: list[dict] = None,
     model: str = "gpt-4o-mini",
 ) -> dict:
-    """상황 전개 + 2턴 선택지 생성"""
-
-    axes_str = ", ".join(scenario["axes"])
+    """다른 캐릭터가 난입하는 이벤트 생성."""
     story_context = _build_story_context(event_logs or [])
 
     user_prompt = f"""\
-═══ 지금까지의 이야기 흐름 ═══
+═══ 현재 상황 ═══
+현재 만나고 있는 사람: {current_char['name']} ({current_char['job']})
+관계 온도: {warmth:.1f} (미지근하거나 차가움)
+═══ 난입하는 사람 ═══
+{_char_context(interrupting_char)}
+첫만남 유형: {interrupting_char.get('meeting_type', '?')}
+═══ 이전 흐름 ═══
 {story_context}
-═══════════════════════════════
+═══════════════
 
-현재 상황: {situation}
-유저의 1턴 선택: {user_choice['text']}
-측정 축: {axes_str}
-
-유저가 1턴에서 "{user_choice['text']}" 를 선택했다.
-이 선택의 결과로 상황이 어떻게 전개되는지 묘사하고, 2턴 선택지를 생성해줘.
+{current_char['name']}과(와)의 관계가 애매해진 상황에서,
+{interrupting_char['name']}이(가) 자연스럽게 등장하는 장면을 만들어줘.
+(카톡이 온다, 우연히 마주친다, 같이 밥 먹자고 연락 등)
 
-중요: 2턴은 "표현의 방식"을 고르는 단계다.
-- 1턴에서 행동의 방향을 정했으니, 2턴에서는 그 행동을 "어떤 톤���로" 할지를 결정한다.
-- reaction(상황 전개)은 1턴 선택에 따라 완전히 달라져야 한다.
-  (적극적 선택 → 가까워진 상황 / 회피 선택 → 멀어진 상황 / 관망 → 탐색 중인 상황)
+유저가 마음이 흔들릴 수 있는 상황이어야 한다.
 
 아래 JSON 형식으로:
 {{
-  "reaction": "1턴 선택의 직접적 결과로 벌어진 상황 (2~3문장). 선택에 따라 관계 온도가 확연히 달라야 함. 핵심 단어는 **볼드**.",
+  "scene_tag": "장소 태그",
+  "situation": "난입 장면. {interrupting_char['name']}의 대사 포함. 3~4문장. **볼드** 사용.",
   "choices": [
-    {{"id": "A", "tone": "sincere", "text": "진지하고 솔직한 톤의 유저 대사 (직접 말하는 문장만)", "trait_effect": {{...4~6개 축...}} }},
-    {{"id": "B", "tone": "playful", "text": "장난스럽거나 가볍게 넘기는 톤의 유저 대사 (직접 말하는 문장만)", "trait_effect": {{...4~6개 축...}} }},
-    {{"id": "C", "tone": "cold", "text": "차갑거나 무심한 톤의 유저 대사 (직접 말하는 문장만)", "trait_effect": {{...4~6개 축...}} }}
+    {{"id": "A", "text": "{interrupting_char['name']}에게 반응하는 선택", "target_char": {interrupting_char['id']}, "warmth_delta": 1.0, "trait_effect": {{...}} }},
+    {{"id": "B", "text": "{current_char['name']}에게 집중하는 선택", "target_char": {current_char['id']}, "warmth_delta": 0.5, "trait_effect": {{...}} }},
+    {{"id": "C", "text": "어느 쪽도 아닌 반응", "target_char": null, "warmth_delta": 0.0, "trait_effect": {{...}} }}
   ]
 }}
 
-★ 2턴 선택지 = 표현의 방식 (text는 반드시 유저가 직접 말하는 대사):
-- A(sincere): 진지, 솔직, 따뜻한 대사 → emotional_depth/affection/agreeableness 양수
-- B(playful): 유머, 장난, 가볍게 넘기는 대사 → humor 양수, emotional_depth 음수 가능
-- C(cold): 냉담, 무관심, 벽을 세우는 대사 → affection/cooperation 음수, leadership/jealousy 양수 가능
-- 3개의 톤이 확연히 달라야 한다
-
+★ scene_tag: 장면이 벌어지는 장소. 다음 중 하나: {SCENE_TAGS_STR}
+★ target_char: 이 선택이 호감도를 올리는 대상의 id. null이면 아무도 아님.
+★ warmth_delta: 해당 target_char의 호감도 변화. -2.0 ~ 2.0.
 ★ trait_effect: 4~6개 축, -1.0 ~ 1.0
-15축: cooperation, leadership, emotional_depth, pace, humor, risk, contact_frequency, affection, jealousy, planning, openness, conscientiousness, extraversion, agreeableness, neuroticism
 """
+    return _chat_with_retry(
+        client, model=model,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_prompt},
+        ],
+    )
 
-    resp = client.chat.completions.create(
-        model=model,
+
+# ── 결말 생성 ─────────────────────────────────────────────────
+
+def generate_ending(
+    client: OpenAI,
+    character: dict,
+    warmth: float,
+    ending_type: str,
+    event_logs: list[dict] = None,
+    model: str = "gpt-4o-mini",
+) -> dict:
+    """warmth 기반 결말 생성."""
+    story_context = _build_story_context(event_logs or [])
+    char_str = _char_context(character)
+
+    ending_hints = {
+        "mutual": "상대도 유저에게 마음이 있었다. 서로 고백하게 되는 장면. 두근거리는 확인의 순간.",
+        "accepted": "유저가 고백했고, 상대가 받아주는 장면. 조심스럽지만 기쁜 순간.",
+        "soft_reject": "유저가 고백했지만, 상대가 조심스럽게 거절하는 장면. 하지만 좋은 친구로 남기로 하는 담담한 순간.",
+        "rejected": "유저가 고백했지만, 상대가 거절하는 장면. 아쉽지만 각자의 길을 가는 순간.",
+        "friends": "유저가 모두와 친구로 남기로 했다. 연인은 아니지만 편한 관계로 남는 장면.",
+        "drifted": "서로 연락이 뜸해지고, 자연스럽게 멀어지는 장면. 아쉽지만 그게 현실인 순간.",
+    }
+
+    user_prompt = f"""\
+═══ 상대 캐릭터 ═══
+{char_str}
+═══ 관계 온도 ═══
+{warmth:.1f}
+═══ 결말 방향 ═══
+{ending_type}: {ending_hints.get(ending_type, '')}
+═══ 이전 흐름 ═══
+{story_context}
+═══════════════
+
+이 관계의 결말을 다큐 카메라가 포착한 마지막 장면으로 보여줘.
+{character['name']}의 마지막 대사를 포함시켜.
+
+아래 JSON 형식으로:
+{{
+  "scene_tag": "장소 태그",
+  "ending_scene": "결말 장면. 4~6문장. 핵심 행동/사물 **볼드**.",
+  "ending_dialogue": "{character['name']}의 마지막 대사",
+  "ending_type": "{ending_type}"
+}}
+
+★ scene_tag: 결말이 벌어지는 장소. 다음 중 하나: {SCENE_TAGS_STR}
+"""
+    return _chat_with_retry(
+        client, model=model,
         messages=[
             {"role": "system", "content": SYSTEM_PROMPT},
             {"role": "user", "content": user_prompt},
         ],
-        response_format={"type": "json_object"},
-        temperature=0.9,
     )
 
-    return json.loads(resp.choices[0].message.content)
+
+# ── 성향 분석 생성 ───────────────────────────────────────────────
+
+ANALYSIS_SYSTEM = """\
+너는 연애 성향 분석 전문가이다.
+유저가 가상 연애 시뮬레이션에서 한 선택들을 바탕으로 연애 스타일을 분석한다.
+따뜻하고 공감하는 톤으로, 구체적인 선택을 근거로 들어 분석한다.
+반말(~해요체) 사용. 짧고 임팩트 있게.
+"""
+
+
+def generate_analysis(
+    client: OpenAI,
+    trait_vector: dict,
+    type_id: str,
+    type_name: str,
+    event_logs: list[dict],
+    ending_type: str,
+    model: str = "gpt-4o-mini",
+) -> dict:
+    """플레이 결과 기반 성향 분석 생성."""
+    choice_lines = []
+    for log in event_logs[-4:]:
+        scenario = log.get("scenario", "?")
+        t1 = log.get("turn1", {}).get("selected", {}).get("text", "")
+        t2 = log.get("turn2", {}).get("selected", {}).get("text", "")
+        if t1:
+            choice_lines.append(f"[{scenario}] 1턴: {t1}")
+        if t2:
+            choice_lines.append(f"[{scenario}] 2턴: {t2}")
+    choices_str = "\n".join(choice_lines) if choice_lines else "없음"
+
+    ending_labels = {
+        "mutual": "서로 고백 → 사귐",
+        "accepted": "고백 수락 → 사귐",
+        "soft_reject": "거절당했지만 친구로",
+        "rejected": "고백 거절당함",
+        "friends": "모두와 친구로 남음",
+        "drifted": "자연스럽게 멀어짐",
+    }
+
+    traits_str = json.dumps(trait_vector, ensure_ascii=False)
+    user_prompt = f"""\
+유저의 연애 시뮬레이션 결과를 분석해줘.
+
+■ 연애 유형: {type_name} ({type_id})
+■ 결말: {ending_labels.get(ending_type, ending_type)}
+■ 15축 성향 벡터: {traits_str}
+■ 핵심 선택들:
+{choices_str}
+
+아래 JSON으로:
+{{
+  "summary": "2-3문장. 이 사람의 연애 스타일 핵심 요약. 구체적 선택을 언급해서.",
+  "strengths": ["강점 1 (한 줄)", "강점 2 (한 줄)"],
+  "watch_points": ["주의할 점 1 (한 줄)"],
+  "dating_tip": "이 유형에게 맞는 연애 팁 한 줄"
+}}
+"""
+    return _chat_with_retry(
+        client, model=model,
+        messages=[
+            {"role": "system", "content": ANALYSIS_SYSTEM},
+            {"role": "user", "content": user_prompt},
+        ],
+        temperature=0.8,
+    )
+
+
+# ── 성향 서술 생성 ─────────────────────────────────────────────────
+
+def generate_personality_description(
+    client: OpenAI,
+    profile: dict,
+    type_info: dict,
+    event_logs: list[dict] = None,
+    model: str = "gpt-4o-mini",
+) -> str:
+    """유저의 성향 벡터를 바탕으로 자연어 서술을 생성."""
+    story_context = _build_story_context(event_logs or [])
+    traits_str = json.dumps(profile.get("traits", {}), ensure_ascii=False, indent=2)
+    big5_str = json.dumps(profile.get("big_five", {}), ensure_ascii=False, indent=2)
+
+    user_prompt = f"""\
+아래는 유저가 연애 시뮬레이션에서 보여준 성향 데이터야.
+이걸 바탕으로, 이 사람이 연애할 때 어떤 사람인지 2인칭(당신)으로 따뜻하게 서술해줘.
+
+═══ 유형 ═══
+{type_info.get('emoji', '')} {type_info.get('title', '')}
+{type_info.get('desc', '')}
+
+═══ 행동 성향 (10축) ═══
+{traits_str}
+
+═══ 성격 (Big Five) ═══
+{big5_str}
+
+═══ 플레이 중 선택 흐름 ═══
+{story_context}
+
+■ 작성 규칙:
+- 3~5문장. 너무 길지 않게.
+- 수치를 직접 언급하지 마. 자연스러운 문장으로 표현해.
+- "당신은 ~한 사람이에요" 같은 따뜻한 톤.
+- 플레이 중 보여준 선택 패턴을 자연스럽게 녹여서.
+- JSON 아닌 순수 텍스트로만 응답해.
+"""
+    resp = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": "너는 연애 성향 분석 전문가야. 따뜻하고 공감 어린 톤으로 서술한다."},
+            {"role": "user", "content": user_prompt},
+        ],
+        temperature=0.85,
+    )
+    return resp.choices[0].message.content.strip()

requirements.txt

@@ -1,4 +1,3 @@
 openai>=1.0.0
 python-dotenv>=1.0.0
-gradio==4.36.1
-huggingface_hub==0.23.4
+gradio>=4.0.0

scenarios.py

@@ -1,4 +1,6 @@
-"""러브로그 시나리오 프레임 데이터"""
+"""하트로그 시나리오 프레임 데이터 — 스테이지 기반 + 다중 캐릭터"""
+
+import random
 
 # ── 15축 정의 ──────────────────────────────────────────────
 
@@ -13,59 +15,108 @@ BIG5_AXES = [
 
 ALL_AXES = BEHAVIOR_AXES + BIG5_AXES
 
-# ── 시나리오 톤 ────────────────────────────────────────────
+# ── 관계 스테이지 ─────────────────────────────────────────
 
-TONES = {
-    "positive": {"emoji": "💗", "label": "긍정", "desc": "설렘, 발전, 교감"},
-    "negative": {"emoji": "💔", "label": "부정", "desc": "갈등, 위기, 실망"},
-    "wildcard": {"emoji": "⚡", "label": "돌발", "desc": "예측 불가, 변수, 반전"},
+STAGES = {
+    1: {"name": "첫만남", "desc": "설렘, 첫인상, 어색함", "axes": ["pace", "extraversion", "openness"]},
+    2: {"name": "데이트", "desc": "알아가기, 관심 표현, 거리 좁히기", "axes": ["humor", "cooperation", "affection"]},
+    3: {"name": "썸", "desc": "감정 확인, 밀당", "axes": ["emotional_depth", "affection", "contact_frequency"]},
+    4: {"name": "관계 정의", "desc": "고백/확인 또는 정리", "axes": ["risk", "pace", "planning"]},
+    5: {"name": "갈등", "desc": "현실적 충돌, 의견 차이", "axes": ["cooperation", "agreeableness", "neuroticism"]},
+    6: {"name": "결말", "desc": "사귐, 친구, 고백 거절, 또는 거절", "axes": ["planning", "conscientiousness", "emotional_depth"]},
 }
 
-# ── 상황 카테고리 (Depth 2) ─────────────────────────────────
-
-SCENARIOS = {
-    # 💗 긍정
-    "P1": {"name": "첫 인상", "desc": "처음 만난 순간의 반응", "tone": "positive", "axes": ["pace", "extraversion"]},
-    "P2": {"name": "관심 표현", "desc": "호감을 어떻게 드러내는가", "tone": "positive", "axes": ["affection", "contact_frequency"]},
-    "P3": {"name": "깊은 대화", "desc": "감정을 나누는 순간", "tone": "positive", "axes": ["emotional_depth", "openness"]},
-    "P4": {"name": "함께하는 시간", "desc": "데이트 중 선택", "tone": "positive", "axes": ["humor", "cooperation"]},
-    "P5": {"name": "미래 이야기", "desc": "관계의 다음 단계 언급", "tone": "positive", "axes": ["planning", "conscientiousness"]},
-    "P6": {"name": "서프라이즈", "desc": "상대를 위한 행동", "tone": "positive", "axes": ["affection", "agreeableness"]},
-    # 💔 부정
-    "N1": {"name": "연락 두절", "desc": "갑자기 답이 없다", "tone": "negative", "axes": ["jealousy", "neuroticism"]},
-    "N2": {"name": "의견 충돌", "desc": "서로 다른 생각", "tone": "negative", "axes": ["cooperation", "agreeableness"]},
-    "N3": {"name": "질투 상황", "desc": "다른 이성의 등장", "tone": "negative", "axes": ["jealousy", "neuroticism"]},
-    "N4": {"name": "실망 순간", "desc": "기대와 다른 모습 발견", "tone": "negative", "axes": ["emotional_depth", "conscientiousness"]},
-    "N5": {"name": "거리감", "desc": "상대가 한 발 물러섬", "tone": "negative", "axes": ["pace", "contact_frequency"]},
-    "N6": {"name": "과거 등장", "desc": "전 애인 관련 상황", "tone": "negative", "axes": ["risk", "neuroticism"]},
-    # ⚡ 돌발
-    "W1": {"name": "우연한 재회", "desc": "예상 못한 곳에서 마주침", "tone": "wildcard", "axes": ["extraversion", "pace"]},
-    "W2": {"name": "제3자 개입", "desc": "친구/가족의 의견", "tone": "wildcard", "axes": ["leadership", "agreeableness"]},
-    "W3": {"name": "돌발 고백", "desc": "예상보다 빠른 감정 표현", "tone": "wildcard", "axes": ["risk", "pace"]},
-    "W4": {"name": "환경 변화", "desc": "이사/이직 등 외부 변수", "tone": "wildcard", "axes": ["planning", "openness"]},
-    "W5": {"name": "오해 발생", "desc": "의도와 다르게 전달된 상황", "tone": "wildcard", "axes": ["cooperation", "emotional_depth"]},
-    "W6": {"name": "시험대", "desc": "관계를 증명해야 하는 순간", "tone": "wildcard", "axes": ["risk", "leadership"]},
+# ── warmth 분기 임계값 ────────────────────────────────────
+
+WARMTH_THRESHOLDS = {
+    "stage3_cold": 3,             # 이 미만이면 멀어지는 방향
+    "confession_mutual": 7,       # 이상이면 상대도 고백 → 사귄다
+    "confession_accepted": 4,     # 이상이면 고백 수락 → 사귄다
+    "confession_soft_reject": 2,  # 이상이면 거절 → 친구로 남는다
+    # > 0: 거절당함
+    # <= 0: 고백 불가 (선택지에 안 뜸)
+    "interruption": 2,            # 이 미만이면 난입 확정
+    "early_ending": 0,            # 모든 캐릭터가 이 이하이면 조기 결말
 }
 
-# ── 보스 이벤트 ────────────────────────────────────────────
+MAX_INTERRUPTIONS = 2  # 난입 최대 횟수
+INTERRUPT_STAGES = {3, 4}  # 난입 발생 가능 스테이지
+
+# ── 첫만남 유형 ───────────────────────────────────────────
+
+MEETING_TYPES = [
+    {"type": "소개팅", "desc": "친구가 소개해준 사람. 카페에서 처음 만남."},
+    {"type": "친구에서 발전", "desc": "같은 동호회/회사 사람. 이미 아는 사이에서 미묘해짐."},
+    {"type": "우연한 만남", "desc": "동네 편의점/카페에서 자주 마주치다 말 걸게 됨."},
+]
 
-BOSS_EVENTS = {
-    "B1": {"name": "이별 위기", "desc": "헤어질 것인가, 잡을 것인가", "tone": "negative", "axes": ["emotional_depth", "cooperation", "neuroticism"]},
-    "B2": {"name": "고백 순간", "desc": "관계를 정의하는 선택", "tone": "positive", "axes": ["risk", "affection", "extraversion"]},
-    "B3": {"name": "진실 폭로", "desc": "숨겨진 사실이 드러남", "tone": "wildcard", "axes": ["openness", "agreeableness", "neuroticism"]},
-    "B4": {"name": "선택의 기로", "desc": "상대 vs 나의 우선순위", "tone": "wildcard", "axes": ["leadership", "planning", "cooperation"]},
+# ── 캐릭터 템플릿 풀 ──────────────────────────────────────
+
+CHAR_POOL = {
+    "M": [
+        {"name": "김서진", "age": 27, "job": "IT회사 백엔드 개발자", "personality": "조용하지만 할 말은 하는 편. 리액션이 늦지만 한번 웃으면 오래 웃음.", "speech_style": "...어 그건 좀, 아 근데 / 단답 많지만 가끔 길게"},
+        {"name": "이준호", "age": 29, "job": "광고대행사 기획자", "personality": "사교적이고 분위기 메이커. 약간 오버하는 경향.", "speech_style": "아 진짜? 대박 / 텐션 높고 리액션 큼"},
+        {"name": "박도현", "age": 26, "job": "스타트업 디자이너", "personality": "감성적이고 세심. 상대 기분에 민감.", "speech_style": "음... 괜찮아? / 조심스럽고 배려하는 톤"},
+        {"name": "최현우", "age": 28, "job": "대기업 영업팀", "personality": "자신감 있고 직설적. 결정이 빠름.", "speech_style": "내가 할게 / 짧고 확실한 톤"},
+        {"name": "정민재", "age": 25, "job": "대학원생 (경영학)", "personality": "분석적이고 신중. 계획을 좋아함.", "speech_style": "그거 한번 생각해보자 / 논리적이지만 딱딱하진 않음"},
+    ],
+    "F": [
+        {"name": "이수빈", "age": 26, "job": "출판사 편집자", "personality": "차분하고 관찰력 좋음. 말보다 표정으로 드러남.", "speech_style": "아 그래? / 짧게 대답하지만 눈 맞춤 많음"},
+        {"name": "한소희", "age": 28, "job": "마케팅 대리", "personality": "활발하고 주도적. 약속 잡는 걸 좋아함.", "speech_style": "야 우리 이거 하자! / 에너지 넘치는 톤"},
+        {"name": "김하은", "age": 25, "job": "카페 바리스타 겸 일러스트레이터", "personality": "몽글몽글하고 감성적. 사소한 것에 감동.", "speech_style": "헐 이거 진짜 예쁘다... / 감탄사 많음"},
+        {"name": "정유진", "age": 27, "job": "금융권 애널리스트", "personality": "똑부러지고 현실적. 비효율 싫어함.", "speech_style": "그건 좀 아닌 거 같은데 / 명확하고 직접적"},
+        {"name": "박지우", "age": 24, "job": "대학원생 (심리학)", "personality": "공감 능력 높고 호기심 많음. 질문을 많이 함.", "speech_style": "그때 어떤 기분이었어? / 탐구하는 톤"},
+    ],
 }
 
-# ── 톤 배분 템플릿 (6이벤트 + 보스 1) ──────────────────────
 
-TONE_DISTRIBUTION = [
-    "positive",   # 1: 관계 진입
-    "positive",   # 2: 관계 진입
-    "negative",   # 3: 갈등
-    "wildcard",   # 4: 변수
-    None,         # 5: 랜덤
-    None,         # 6: 랜덤
-]
+def pick_characters(partner_gender: str, count: int = 3, seed: int | None = None) -> list[dict]:
+    """상대 성별 풀에서 count명 랜덤 선택 + 첫만남 유형 배정."""
+    rng = random.Random(seed)
+    pool = CHAR_POOL.get(partner_gender, CHAR_POOL["F"])
+    chars = rng.sample(pool, min(count, len(pool)))
+    meetings = list(MEETING_TYPES)
+    rng.shuffle(meetings)
+    result = []
+    for i, char in enumerate(chars):
+        result.append({
+            **char,
+            "id": i,
+            "meeting_type": meetings[i]["type"],
+            "meeting_desc": meetings[i]["desc"],
+            "warmth": 0,
+            "active": True,
+            "event_count": 0,
+        })
+    return result
+
+
+def get_warmth_variant(stage: int, warmth: float) -> str:
+    """warmth 기반으로 스테이지 variant 결정."""
+    t = WARMTH_THRESHOLDS
+    if stage == 3:
+        return "warm" if warmth >= t["stage3_cold"] else "cold"
+    return "normal"
+
+
+def get_confession_outcome(warmth: float) -> str:
+    """고백 시 warmth 기반 결과 결정."""
+    t = WARMTH_THRESHOLDS
+    if warmth >= t["confession_mutual"]:
+        return "mutual"
+    if warmth >= t["confession_accepted"]:
+        return "accepted"
+    if warmth >= t["confession_soft_reject"]:
+        return "soft_reject"
+    return "rejected"
+
+
+def should_interrupt(warmth: float) -> bool:
+    """난입 이벤트 발생 조건. 임계값 미만이면 확정, 이상이면 50%."""
+    if warmth < WARMTH_THRESHOLDS["interruption"]:
+        return True
+    return random.random() < 0.5
+
 
 # ── 감정 태그 ──────────────────────────────────────────────
 
@@ -116,4 +167,3 @@ DATING_TYPES = {
         "weights": {"risk": 1.5, "openness": 2.0, "jealousy": -2.0},
     },
 }
-

scene_art.py

@@ -0,0 +1,35 @@
+"""장면별 이미지 — PNG를 base64로 로드."""
+
+import base64
+from pathlib import Path
+
+SCENE_TAGS = [
+    "cafe", "restaurant", "park", "street", "store",
+    "home", "bar", "phone", "cinema", "night",
+]
+
+_IMG_DIR = Path(__file__).parent / "scene_images"
+
+
+def _load_images() -> tuple[dict[str, str], str]:
+    images = {}
+    for tag in SCENE_TAGS:
+        path = _IMG_DIR / f"{tag}.png"
+        if path.exists():
+            b64 = base64.b64encode(path.read_bytes()).decode()
+            images[tag] = f"data:image/png;base64,{b64}"
+    default_path = _IMG_DIR / "default.png"
+    default = ""
+    if default_path.exists():
+        b64 = base64.b64encode(default_path.read_bytes()).decode()
+        default = f"data:image/png;base64,{b64}"
+    return images, default
+
+
+_SCENE_IMAGES, _DEFAULT_IMAGE = _load_images()
+SCENE_TAGS_STR = ", ".join(SCENE_TAGS)
+
+
+def get_scene_image(tag: str) -> str:
+    """태그에 해당하는 이미지의 base64 data URI 반환."""
+    return _SCENE_IMAGES.get(tag, _DEFAULT_IMAGE)

trait_engine.py

@@ -153,8 +153,6 @@ def find_matches(user_vector: dict, user_type: str, top_n: int = 3) -> list[dict
     profiles = load_seed_profiles()
     results = []
 
-    user_type_obj, _ = classify_type(user_vector)
-
     for profile in profiles:
         candidate_vector = profile_to_vector(profile)
 
@@ -203,6 +201,59 @@ def find_matches(user_vector: dict, user_type: str, top_n: int = 3) -> list[dict
     return results[:top_n]
 
 
+AXIS_NAMES_KR = {
+    "cooperation": "협력성", "leadership": "주도성", "emotional_depth": "감정 깊이",
+    "pace": "관계 속도", "humor": "유머", "risk": "모험성",
+    "contact_frequency": "연락 빈도", "affection": "애정 표현",
+    "jealousy": "질투/독점", "planning": "계획성",
+    "openness": "개방성", "conscientiousness": "성실성",
+    "extraversion": "외향성", "agreeableness": "친화성", "neuroticism": "정서 불안정성",
+}
+
+COMPLEMENTARY_TYPES = {
+    "flame": "stable", "stable": "flame",
+    "emotional": "strategic", "strategic": "emotional",
+    "free": "stable",
+}
+
+
+def generate_match_reason(user_vector: dict, user_type: str, match: dict) -> str:
+    """매칭 이유를 deterministic하게 생성."""
+    cand_vector = profile_to_vector(match["profile"])
+
+    similarities = []
+    complements = []
+    for axis in ALL_AXES:
+        u = user_vector.get(axis, 0)
+        c = cand_vector.get(axis, 0)
+        diff = abs(u - c)
+        magnitude = abs(u) + abs(c)
+        if magnitude > 1.0:
+            if diff < 1.0:
+                similarities.append((axis, magnitude))
+            elif diff > 1.5 and u * c < 0:
+                complements.append((axis, abs(u), abs(c)))
+
+    similarities.sort(key=lambda x: -x[1])
+    parts = []
+
+    if similarities:
+        names = [AXIS_NAMES_KR.get(s[0], s[0]) for s in similarities[:2]]
+        parts.append(f"{', '.join(names)}이(가) 비슷해요")
+
+    if complements:
+        name = AXIS_NAMES_KR.get(complements[0][0], complements[0][0])
+        parts.append(f"{name}에서 서로 보완돼요")
+
+    cand_type = match.get("type", "")
+    if cand_type == COMPLEMENTARY_TYPES.get(user_type, ""):
+        parts.append("상호 보완적인 유형이에요")
+    elif cand_type == user_type:
+        parts.append("같은 유형이라 공감대가 높아요")
+
+    return " · ".join(parts) if parts else "전반적인 성향이 잘 맞아요"
+
+
 def format_match_card(match: dict, rank: int) -> str:
     """매칭 결과 카드 출력"""
     p = match["profile"]