Upload 2 files

app_coach.py

@@ -29,7 +29,7 @@ import gradio as gr
 #   - 변화율(rate-of-change)을 감지하며 (절대값보다 EVA 추세·증감을 봄)
 #   - 차근차근 표현하게 (단계적으로, 부담 덜며 구체화)
 # → 완성 기준도 'EVA 상승'이 아닌 '표현 구체화/신호 안정'으로 새로 정의해야. 데이터 0건이므로 만든 뒤 검증 필수.
-VERSION = "coach-0.9.2-hint"  # 0.9.1 + 완성 후보 개선: (1) 코치에게 한 질문(조언요청 "나는 어떻게 해야해?") 후보에서 제외(is_coach_question) (2) 완성 시점 LLM 힌트 1개 생성(make_hint — 사용자 발화 중 마음 잘 담긴 걸 전달용으로 보수적 재구성, 내용추가·조언 금지) (3) 힌트를 후보 위에 "예시"로 표시+선택가능(choose_hint, 원문 후보 병행=A안). 힌트 실패시 기존 후보만(graceful). DEBUG off·다중선택·CON/FUL 데이터기록 유지.
+VERSION = "coach-0.9.3-compass-norm"  # 0.9.2 + 나침반 스케일 정규화: EVA·EAR을 각 축 분포(95분위 0.73/0.63, 241발화 근거)로 나눠 ±1 기준 표시. 화면 lim 2.2→1.15로 점이 가장자리까지 크게 움직여 다이나믹. 측정값/로그는 원본 유지(표시만 정규화). 2축(EVA·EAR) 유지=변화율 궤적 보존(VAL/REI 단발 불안정이라 레이더 대신 2축 선택).
 DEBUG = False  # True면 측정값/상태를 나침반 캡션 아래 표시(임계값 조정용). 평소 False(사용자 화면에 수치 노출 안 함).
 ENCODER = "BM-K/KoSimCSE-roberta-multitask"
 USE_SENTENCE_TRANSFORMERS = ENCODER.startswith("BAAI")
@@ -536,12 +536,18 @@ import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 
+# 각 축 표시 스케일(95분위 |값|, 241발화 근거). 값을 이걸로 나눠 ±1 기준 정규화.
+# → EVA·EAR이 화면 가장자리까지 크게 움직여 다이나믹하게 보인다. 배포 데이터로 재보정 가능.
+COMPASS_SCALE = {"EVA": 0.73, "EAR": 0.63}
+
 def render_compass(coords, best_idx=None):
     """EVA(x: 부정↔긍정) × EAR(y: 차분↔격앙) 평면에 발화 궤적을 그린다.
-    coords: [(eva, ear, strength), ...] 발화 순서. best_idx: best 표현 순번(별표).
+    각 축을 자기 분포로 정규화(EVA/0.73, EAR/0.63)해 화면을 꽉 채운다.
+    coords: [(eva, ear, strength), ...] 원본 측정값. best_idx: best 표현 순번(별표).
     한글 폰트가 없는 환경(HF Space) 대비, 차트 내 텍스트는 영어/기호만 사용."""
     fig, ax = plt.subplots(figsize=(4.2, 4.2), dpi=100)
-    lim = 2.2
+    lim = 1.15   # 정규화 후 기준(±1)보다 살짝 여유. 95분위가 ±1 근처에 오도록.
+    sx, sy = COMPASS_SCALE["EVA"], COMPASS_SCALE["EAR"]
     # 사분면 배경/안내(영어로 — 폰트 안전)
     ax.axhline(0, color="#bbb", lw=0.8, zorder=1)
     ax.axvline(0, color="#bbb", lw=0.8, zorder=1)
@@ -555,8 +561,9 @@ def render_compass(coords, best_idx=None):
     ax.text(lim*0.42, -lim*0.93, "CALM", fontsize=8, color="#27ae60", alpha=0.7, weight="bold")
 
     if coords:
-        xs = [max(-lim, min(lim, c[0])) for c in coords]
-        ys = [max(-lim, min(lim, c[1])) for c in coords]
+        # 정규화: 각 축을 자기 스케일로 나눠 ±1 기준. clip은 lim으로.
+        xs = [max(-lim, min(lim, c[0] / sx)) for c in coords]
+        ys = [max(-lim, min(lim, c[1] / sy)) for c in coords]
         n = len(coords)
         # ── B-2: 추세선(EMA 평활) — 측정 원본은 점으로 정직하게, 흐름은 부드러운 선으로 ──
         # 긍정 흐름 중 "미안/짜증" 한 발화로 튀어도, 추세선은 이전 긍정을 반영해 완만하게 보상.

app_coach_v0_9_2_hint.py

@@ -0,0 +1,1353 @@
+# -*- coding: utf-8 -*-
+"""
+표현 코칭 — 최소 흐름 프로토타입 (v0.1)
+시나리오: 서운함 전하기 (B·여성 고정)
+흐름: 적기 → 측정 분기(막막/또렷) → 비계(선택지) → 3단계(자기 문장 다듬기) → 완성
+
+측정: KoSimCSE(검증된 엔진) — 신호 강도(max|coord|) 게이트로 막막/또렷 분기
+응답: Gemini (좌표 요약을 시스템 프롬프트에 + 최근 몇 턴만 — 비용 절제)
+
+목적: '적기→측정분기→3단계'가 작동하는지, '거울+산파'로 느껴지는지 검증.
+뺀 것(의도적): 맥락 3선택, 데이터 저장, 나침반, 4시나리오 — 검증 후 추가.
+
+실행: Colab/로컬에서 GEMINI_API_KEY 환경변수 또는 Colab Secrets 설정 후 python app_coach.py
+     (HF Space면 Space Secret에 GEMINI_API_KEY)
+"""
+import os
+import re
+import json
+import time
+from contextlib import nullcontext
+import numpy as np
+from numpy.linalg import norm
+import gradio as gr
+
+# ── [향후: 긍정 트랙 설계 메모] ──────────────────────────────────
+# 현재는 '부정 감정 표현' 트랙만 (서운/속상/화남 → 다듬어 전하기). 완성=EVA 상승(격한 감정 정리).
+# 긍정 트랙(호감/고마움/기쁨)은 별도 설계 필요. 핵심 원칙(사용자 지침):
+#   - 세기가 너무 세지지 않게 (긍정 감정이 과하게 분출되지 않도록 조절)
+#   - 변화율(rate-of-change)을 감지하며 (절대값보다 EVA 추세·증감을 봄)
+#   - 차근차근 표현하게 (단계적으로, 부담 덜며 구체화)
+# → 완성 기준도 'EVA 상승'이 아닌 '표현 구체화/신호 안정'으로 새로 정의해야. 데이터 0건이므로 만든 뒤 검증 필수.
+VERSION = "coach-0.9.2-hint"  # 0.9.1 + 완성 후보 개선: (1) 코치에게 한 질문(조언요청 "나는 어떻게 해야해?") 후보에서 제외(is_coach_question) (2) 완성 시점 LLM 힌트 1개 생성(make_hint — 사용자 발화 중 마음 잘 담긴 걸 전달용으로 보수적 재구성, 내용추가·조언 금지) (3) 힌트를 후보 위에 "예시"로 표시+선택가능(choose_hint, 원문 후보 병행=A안). 힌트 실패시 기존 후보만(graceful). DEBUG off·다중선택·CON/FUL 데이터기록 유지.
+DEBUG = False  # True면 측정값/상태를 나침반 캡션 아래 표시(임계값 조정용). 평소 False(사용자 화면에 수치 노출 안 함).
+ENCODER = "BM-K/KoSimCSE-roberta-multitask"
+USE_SENTENCE_TRANSFORMERS = ENCODER.startswith("BAAI")
+
+# HF Dataset 저장 설정 — Space Secret에 HF_TOKEN(쓰기), HF_DATASET_REPO("아이디/coach-data") 설정 시 영구 저장
+HF_DATASET_REPO = os.environ.get("HF_DATASET_REPO", "")
+DATA_DIR = os.environ.get("COACH_DATA_DIR", "/tmp/coach_data")
+
+# 신호 강도 게이트 — 검증값(의미분명 1.25 vs 단편 0.37). 이 값으로 막막/또렷 분기.
+GATE = 0.35
+# 또렷 판정: max|coord|가 이 이상이면 '이미 표현됨' → 비계 건너뛰고 3단계
+CLEAR_THRESHOLD = 0.7
+
+GEMINI_PRICES = {"gemini-2.5-flash": (0.30, 2.50), "gemini-2.5-flash-lite": (0.10, 0.40)}
+
+# ============================== 축 정의 (검증된 CONSTRUCTS) ==============================
+CONSTRUCTS = {
+    "VAL": {"label": ("자율 지향", "순응 지향"), "pos": [
+        "나는 내 삶을 어떻게 살지 스스로 결정하는 것을 좋아한다.",
+        "새롭고 독창적인 생각을 떠올리는 것이 나에게 중요하다.",
+        "나는 무엇이든 내 방식대로 해결하는 편이다.",
+        "내 목표를 스스로 자유롭게 선택하는 것이 중요하다.",
+        "남에게 묻기보다 내 판단을 믿고 따르는 편이다.",
+        "나는 호기심을 따라 새로운 것을 탐험하는 것을 가치 있게 여긴다.",
+        "누가 알려주기보다 세상을 스스로 이해하고 싶다.",
+        "나는 독립적으로 일을 해내는 것에 자부심을 느낀다.",
+        "남을 따라 하기보다 내 방식을 새로 만드는 편이 좋다.",
+        "내 인생의 방향을 스스로 정하는 것이 무척 중요하다.",
+        "나는 창의적으로, 내 식대로 시도하는 것을 좋아한다.",
+        "나에게 무엇이 옳은지 스스로 판단할 수 있다고 믿는다.",
+    ], "neg": [
+        "나는 사람은 규칙을 잘 지켜야 한다고 생각한다.",
+        "시키는 일을 잘 따르는 것이 나에게 중요하다.",
+        "나는 예의 바르게 행동하고 잘못된 일을 하지 않으려 애쓴다.",
+        "물려받은 전통과 관습을 지키는 것이 나에게 중요하다.",
+        "나는 권위와 윗사람을 존중해야 한다고 믿는다.",
+        "전통을 존중하는 것을 중요하게 여긴다.",
+        "나는 튀기보다 집단에 어울리는 편을 택한다.",
+        "정해진 방식을 함부로 의심하지 않는 편이 낫다고 생각한다.",
+        "나에게 기대되는 바를 지키는 것이 옳게 느껴진다.",
+        "나는 순종적이고 믿음직한 사람이 되는 것을 가치 있게 여긴다.",
+        "사회 규범에는 이유가 있으니 지켜야 한다고 믿는다.",
+        "나에게는 새로움보다 안정과 질서를 지키는 것이 더 중요하다.",
+        # 선택-동사 순응 보강 — 진단 결과 '능동 선택형 순응'(남들 따라 고르기)이
+        # 자율로 오측정되던 문제 완화. 독립 데이터 검증 AUC 0.90→0.95.
+        "남들이 많이 사는 물건을 골라서 산다.",
+        "유행하는 쪽을 보고 그대로 선택한다.",
+        "다수가 정한 방향에 내 결정을 맞춘다.",
+        "주변에서 고르는 것을 보고 똑같이 고른다.",
+        "나도 남들 하는 대로 무난한 쪽을 택한다.",
+        "사람들이 좋다고 하는 것을 골라 산다.",
+        "내 취향보다 대세를 따라 고르는 편이다.",
+        "남들 눈을 의식해서 선택을 정한다.",
+    ]},
+    "REI": {"label": ("분석적", "직관적"), "pos": [
+        "나는 깊이 생각해야 하는 문제를 즐긴다.",
+        "행동하기 전에 상황을 논리적으로 분석하는 것을 좋아한다.",
+        "나는 단계를 밟아 차근차근 따져보는 편이다.",
+        "복잡한 문제를 깊이 고민하는 것이 만족스럽다.",
+        "나는 결론을 내릴 때 논리와 근거에 의존한다.",
+        "문제를 부분으로 나누어 분석하는 것을 좋아한다.",
+        "어려운 지적 과제를 풀어내는 것을 즐긴다.",
+        "결정할 때 감정보다 이성을 더 믿는다.",
+        "나는 결정 전에 장단점을 신중히 따져본다.",
+        "추상적이고 분석적인 사고가 즐겁다.",
+        "분명한 근거로 뒷받침된 결론을 선호한다.",
+        "무언가의 논리를 풀어내면 만족스럽다.",
+        "느낌이 좋았지만 가격을 비교하고 구매했다.",
+        "느낌보다 데이터를 우선해 전공을 정했다.",
+        "감으로 판단하지 않고 사실을 확인했다.",
+        "직감이 들어도 먼저 수치를 확인한다.",
+        "막연한 느낌을 숫자로 바꿔 확인했다.",
+        "직감이 나빴지만 안전 데이터를 검증했다.",
+        "감보다 근거를 보고 이직을 결정했다.",
+        "느낌에 기대지 않고 논문을 분석했다.",
+        "느낌이 와도 계약 조건을 따져본다.",
+        "직감을 가설로 세워 실험을 설계했다.",
+    ], "neg": [
+        "나는 보통 직감에 따라 행동한다.",
+        "나는 종종 무엇이 옳은지 그냥 느낌으로 안다.",
+        "분석보다 첫인상에 더 의존하는 편이다.",
+        "나는 많은 결정을 느낌에 따라 내린다.",
+        "설명할 수 없어도 내 직관을 믿는다.",
+        "내 예감은 대체로 들어맞는다.",
+        "나는 그 순간 옳게 느껴지는 대로 하는 편이다.",
+        "나는 상황을 본능으로 읽는다.",
+        "나는 결정을 느낌으로 더듬어 가는 편이 좋다.",
+        "나는 감정과 인상에 따라 선택하곤 한다.",
+        "따져보지 않아도 옳다는 걸 아는 경우가 많다.",
+        "나는 신중한 분석보다 직관에 더 의존한다.",
+    ]},
+    "EVA": {"label": ("긍정", "부정"), "pos": [
+        "지금 나는 즐겁고 기분이 좋다.", "따뜻한 만족감이 느껴진다.",
+        "오늘 나는 희망차고 밝다.", "나는 흐뭇하고 만족스럽다.",
+        "나는 고맙고 뿌듯하다.", "좋고 기분 좋은 느낌이 함께한다.",
+        "나는 행복하고 마음이 가볍다.", "나는 흡족하고 긍정적이다.",
+        "지금 내 안에 기쁨이 있다.", "나는 즐겁고 편안하다.",
+        "나는 감사하고 마음이 따뜻하다.", "밝은 안녕감이 느껴진다.",
+    ], "neg": [
+        "지금 나는 시무룩하고 우울하다.", "무거운 슬픔이 느껴진다.",
+        "오늘 나는 낙담하고 서럽다.", "나는 언짢고 불만스럽다.",
+        "나는 비참하고 의기소침하다.", "나쁘고 불쾌한 느낌이 함께한다.",
+        "나는 침울하고 풀이 죽었다.", "나는 속상하고 부정적이다.",
+        "지금 내 안에 슬픔이 있다.", "나는 슬프고 마음이 불편하다.",
+        "나는 씁쓸하고 마음이 차갑다.", "어두운 괴로움이 느껴진다.",
+    ]},
+    "EAR": {"label": ("고각성", "저각성"), "pos": [
+        "나는 활력이 넘치고 또렷이 깨어 있다.", "나는 들뜨고 잔뜩 흥분돼 있다.",
+        "내 몸이 활성화되고 긴장돼 있다.", "나는 격렬하고 잔뜩 달아올라 있다.",
+        "나는 안절부절못하며 에너지가 넘친다.", "심장이 빠르게 뛰는 것 같다.",
+        "나는 긴장되고 크게 각성돼 있다.", "나는 안달이 나고 자극받아 있다.",
+        "나는 한껏 충���돼 들떠 있다.", "나는 곤두서고 신경이 팽팽하다.",
+        "몸에 각성이 솟구치는 느낌이다.", "나는 또렷하고 활기차게 깨어 있다.",
+    ], "neg": [
+        "나는 차분하고 고요하다.", "나는 졸리고 느긋하다.",
+        "나는 조용하고 가라앉아 있다.", "나는 나른하고 멍하다.",
+        "내 에너지가 낮고 느리게 느껴진다.", "나는 누그러지고 서두르지 않는다.",
+        "나는 평온하고 쉬고 있다.", "나는 축 늘어지고 무겁다.",
+        "나는 잔잔하고 조용하다.", "나는 졸음이 오고 잦아든다.",
+        "깊은 고요함이 느껴진다.", "나는 느긋하고 반쯤 잠든 듯하다.",
+    ]},
+    # ── 외로움/공허 측정용 신규 축 (노트북 검증: 외로움 vs 중립 CON d=-3.70, 공허 vs 중립 FUL d=-4.76, 길이통제 통과) ──
+    # ※ 측정·기록만. signal_strength/완성판정에는 미반영(검증 전엔 동작 불변). 실사용 재검증 후 활용 예정.
+    "CON": {"label": ("연결됨", "고립됨"), "pos": [
+        "나는 사람들과 깊이 이어져 있다고 느낀다.",
+        "내 곁에는 마음을 나눌 사람들이 있다.",
+        "나는 누군가와 함께 있고 연결되어 있다.",
+        "내가 속한 사람들 사이에서 소속감을 느낀다.",
+        "나를 아끼고 곁에 있어 주는 사람들이 있다.",
+        "나는 다른 사람들과 가깝게 맺어져 있다.",
+    ], "neg": [
+        "나는 혼자 동떨어져 있다고 느낀다.",
+        "내 곁에는 마음을 나눌 사람이 아무도 없다.",
+        "나는 외롭고 누구와도 이어져 있지 않다.",
+        "어디에도 속하지 못하고 겉도는 느낌이다.",
+        "아무도 내 곁에 없는 것 같다.",
+        "나는 사람들에게서 멀리 떨어져 단절되어 있다.",
+    ]},
+    "FUL": {"label": ("충만함", "공허함"), "pos": [
+        "내 삶은 의미로 가득 차 있다.",
+        "나는 마음이 충만하고 채워져 있다.",
+        "하루하루가 의미 있고 보람차다.",
+        "내 안이 따뜻하게 채워진 느낌이다.",
+        "나는 살아가는 이유와 의미를 느낀다.",
+        "내 마음은 풍요롭고 가득하다.",
+    ], "neg": [
+        "내 마음은 텅 비어 있다.",
+        "나는 공허하고 아무것도 느껴지지 않는다.",
+        "하루하루가 의미 없이 비어 있다.",
+        "내 안이 허전하게 비어 있는 느낌이다.",
+        "나는 살아가는 의미를 찾지 못하겠다.",
+        "내 마음은 메마르고 텅 비었다.",
+    ]},
+}
+
+# ============================== 측정 엔진 (검증된 코드 그대로) ==============================
+class MeasurementEngine:
+    def __init__(self, encoder_name=ENCODER):
+        self.encoder_name = encoder_name
+        self._load_encoder()
+        self.axes, self.refs = {}, {}
+        for c, d in CONSTRUCTS.items():
+            ep, en = self._embed(d["pos"]), self._embed(d["neg"])
+            v = ep.mean(0) - en.mean(0); v = v / (norm(v) + 1e-8)
+            self.axes[c] = v
+            ref = np.vstack([ep, en]) @ v
+            self.refs[c] = (ref.mean(), ref.std() + 1e-8)
+
+    def _load_encoder(self):
+        if USE_SENTENCE_TRANSFORMERS:
+            from sentence_transformers import SentenceTransformer
+            self._st = SentenceTransformer(self.encoder_name)
+        else:
+            from transformers import AutoModel, AutoTokenizer
+            import torch
+            self._torch = torch
+            self._tok = AutoTokenizer.from_pretrained(self.encoder_name)
+            self._mdl = AutoModel.from_pretrained(self.encoder_name).eval()
+
+    def _embed(self, sents):
+        if isinstance(sents, str): sents = [sents]
+        if USE_SENTENCE_TRANSFORMERS:
+            return np.asarray(self._st.encode(sents, normalize_embeddings=True), dtype=np.float64)
+        out = []
+        for i in range(0, len(sents), 16):
+            b = sents[i:i + 16]
+            inp = self._tok(b, padding=True, truncation=True, max_length=64, return_tensors="pt")
+            with self._torch.no_grad():
+                e = self._mdl(**inp).last_hidden_state[:, 0]
+            e = e / (e.norm(dim=1, keepdim=True) + 1e-8)
+            out.append(e.cpu().double().numpy())
+        return np.vstack(out)
+
+    def measure(self, text):
+        emb = self._embed(text)[0]
+        return {c: float((emb @ v - self.refs[c][0]) / self.refs[c][1]) for c, v in self.axes.items()}
+
+def signal_strength(m):
+    """신호 강도 = 전체 축 최대 |coord|. 막막/또렷 분기의 기준."""
+    return max(abs(m[c]) for c in ("VAL", "REI", "EVA", "EAR"))
+
+
+# ── VAL/REI 방향 3단계 분류 (실험적, A+B용) ──────────────────────────────
+# 검증 결과: VAL/REI는 '방향'(자율/순응, 분석/직관)은 안정적으로 갈리나
+# '강도'(매우/약간)는 KoSimCSE가 못 잡음 → 4/8단계 불가, 2~3단계만 유효.
+# 따라서 방향 기반 3단계(양극 + 중립)로만 분류. 강도 표현 금지.
+# 주의: 방향 분류는 동의어 변동에 안정적(범주정확도 VAL 100%/REI 92%)이나,
+#       그 분류가 '실제 성향'과 맞는지는 외부검증 안 됨 → 참고용/실험적.
+#       EVA(KNU 0.75 검증)와 달리 강하게 의존하지 말 것.
+VALREI_NEUTRAL_BAND = 0.3   # |값| < 0.3 이면 '뚜렷하지 않음'(중립). 검증에서 쓴 값.
+
+def classify3(value, pos_label, neg_label):
+    """연속 측정값을 방향 3단계로. 강도는 표현하지 않음(방향만)."""
+    if value > VALREI_NEUTRAL_BAND:
+        return pos_label
+    elif value < -VALREI_NEUTRAL_BAND:
+        return neg_label
+    else:
+        return None  # 뚜렷하지 않음 → 성향 언급 안 함
+
+def tendency_of(m):
+    """측정 m에서 VAL/REI 방향 성향을 추출. (val_dir, rei_dir) 각각 라벨 또는 None."""
+    val_dir = classify3(m["VAL"], "자율", "순응")
+    rei_dir = classify3(m["REI"], "분석", "직관")
+    return val_dir, rei_dir
+
+
+# ── 반어 의심 플래그 ──────────────────────────────────────────────────────
+# 측정이 약한 '순수 반어'("내가 행복하겠어?" = 불행이나 EVA 양수로 측정됨)를
+# 대화 흐름의 급반전으로 탐지. 자동 처리 안 함 — 플래그만 기록(데이터 수집용).
+# 절대 원칙: EVA 측정값 불변. 완성 판정 등 기존 로직에 안 씀. 진짜 긍정 전환 보호.
+IRONY_PATTERNS = [
+    r"겠어\s*\?", r"겠니\s*\?", r"겠나\s*\?", r"겠어요\s*\?",   # 수사의문
+    r"리가\s*없", r"리\s*없", r"ㄹ\s*리가", r"을\s*리가",       # ~리가 없
+    r"뭐\s*(좋|행복|즐겁|기쁘)",                                # 뭐 좋아
+    r"(좋|행복|즐거울|기쁠)\s*게\s*(뭐|있)",                    # 좋을 게 뭐
+]
+
+def has_irony_cue(text):
+    """조건2: 반어 형태 단서가 있는가."""
+    for p in IRONY_PATTERNS:
+        if re.search(p, text):
+            return True
+    return False
+
+def is_eva_reversal(cur_eva, eva_hist, n=3, neg_thresh=-0.2, jump_thresh=0.5):
+    """조건1: 직전 부정 흐름에서 현재가 크게 상승해 양수(급반전).
+    이력이 적은 대화 초반에도 탐지되도록, 있는 만큼(최소 1턴)으로 직전 평균을 본다.
+    (기록만 — 측정값/완성판정 안 건드림. 반어는 초반에 자주 나오므로 초반 탐지가 중요.)"""
+    if len(eva_hist) < 1:
+        return False, None
+    win = min(len(eva_hist), n)          # 있는 만큼(최대 n)
+    recent = eva_hist[-win:]
+    recent_mean = sum(recent) / len(recent)
+    jump = cur_eva - recent_mean
+    cond = (recent_mean < neg_thresh) and (jump > jump_thresh) and (cur_eva > 0)
+    return cond, {"recent_mean": round(recent_mean, 2), "jump": round(jump, 2), "win": win}
+
+def irony_suspect(cur_text, cur_eva, eva_hist):
+    """반어 의심 종합 판정. 자동 처리 안 함 — 플래그만 반환.
+    level: 강(반어 의심) / 급반전(진짜 전환 가능, 안 건드림) / 형태만 / 없음"""
+    c1, c1d = is_eva_reversal(cur_eva, eva_hist)
+    c2 = has_irony_cue(cur_text)
+    if c1 and c2:
+        level = "강"
+    elif c1:
+        level = "급반전"
+    elif c2:
+        level = "형태만"
+    else:
+        level = "없음"
+    return {"level": level, "cond1_reversal": c1, "cond2_cue": c2, "detail": c1d}
+
+
+print("측정 엔진 로딩 중...")
+ENGINE = MeasurementEngine()
+print("측정 엔진 준비 완료:", {k: round(v, 2) for k, v in ENGINE.measure("오늘 정말 행복해").items()})
+
+# ============================== 데이터 저장 (측정값·변수만, 발화 원문 제외) ==============================
+def _now():
+    return time.strftime("%Y-%m-%dT%H:%M:%S")
+
+class CoachDataStore:
+    """대화별 측정값·변수·원문을 저장. HF Dataset 영구화(설정 시).
+    원문 수집은 화면 하단 고지로 알림(별도 동의 체크 없음 — 가상 시나리오 + 고지 기반).
+    주의: 일반 공개 시에는 명시적 동의 절차로 강화 필요."""
+    def __init__(self, data_dir=DATA_DIR, repo=HF_DATASET_REPO, version=VERSION, encoder=ENCODER):
+        self.dir = data_dir
+        os.makedirs(data_dir, exist_ok=True)
+        self.path = os.path.join(data_dir, "coach_turns.jsonl")
+        self.version, self.encoder = version, encoder
+        self.saved = 0
+        self.scheduler = None
+        if repo and os.environ.get("HF_TOKEN"):
+            try:
+                from huggingface_hub import CommitScheduler, hf_hub_download
+                from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
+                # ★ 재시작 복구: CommitScheduler 시작 전에 HF에서 기존 파일을 먼저 받아 로컬에 복원.
+                # (이 단계가 없으면 빈 로컬 폴더가 HF로 동기화돼 기존 데이터를 덮어씀 — 데이터 손실 원인.)
+                safe_to_sync = True
+                if not os.path.exists(self.path) or os.path.getsize(self.path) == 0:
+                    try:
+                        cached = hf_hub_download(repo_id=repo, repo_type="dataset",
+                                                 filename="data/coach_turns.jsonl",
+                                                 token=os.environ.get("HF_TOKEN"))
+                        import shutil
+                        shutil.copyfile(cached, self.path)
+                        n = sum(1 for _ in open(self.path, encoding="utf-8"))
+                        print(f"HF Dataset 복구: 기존 {n}건 불러옴 → {self.path}")
+                    except (EntryNotFoundError, RepositoryNotFoundError):
+                        # HF에 파일/레포가 아직 없음 = 최초 실행. 빈 채로 시작해도 안전(덮어쓸 데이터 없음).
+                        print("HF Dataset 복구: 기존 파일 없음(최초 실행) — 빈 채로 시작")
+                    except Exception as de:
+                        # 그 외 실패(네트워크 등): HF에 데이터가 있을 수 있음 → 빈 폴더로 덮어쓰기 방지 위해 동기화 끔.
+                        safe_to_sync = False
+                        print(f"⚠️ HF Dataset 복구 실패(네트워크 등): {de}\n"
+                              f"   → 기존 데이터 덮어쓰기 방지를 위해 이번 세션 자동 동기화를 끕니다. "
+                              f"로컬에는 계속 저장되며, Space 재시작으로 복구를 재시도하세요.")
+                if safe_to_sync:
+                    self.scheduler = CommitScheduler(repo_id=repo, repo_type="dataset",
+                                                     folder_path=data_dir, path_in_repo="data",
+                                                     every=5, private=True)
+                    print("HF Dataset 동기화 ON:", repo)
+                else:
+                    print("HF Dataset 동기화 OFF(안전모드) — 로컬 저장만 유지")
+            except Exception as e:
+                print("HF Dataset 동기화 OFF:", e)
+        else:
+            print("HF Dataset 미설정 — 로컬 저장만(재시작 시 초기화). HF_TOKEN·HF_DATASET_REPO 설정 시 영구화.")
+
+    def write(self, rec):
+        lock = self.scheduler.lock if self.scheduler else nullcontext()
+        with lock:
+            with open(self.path, "a", encoding="utf-8") as f:
+                f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                f.flush()
+                try:
+                    os.fsync(f.fileno())  # 디스크에 즉시 반영(동기화 타이밍 문제 방지)
+                except Exception:
+                    pass
+        self.saved += 1
+        print(f"[SAVE-DEBUG] write 완료: type={rec.get('type')}, "
+              f"누적 {self.saved}건, 파일={self.path}")
+
+    def log_turn(self, session, m, strength, state, utter_len, kind="user", text=None):
+        """발화 한 건의 측정값·변수 기록. text 제공 시 원문도 함께 저장(고지 후 수집)."""
+        rec = {
+            "type": "coach_turn", "ts": int(time.time()), "datetime": _now(),
+            "session": session, "app_version": self.version, "encoder": self.encoder, "kind": kind,
+            "EVA": round(float(m["EVA"]), 4), "EAR": round(float(m["EAR"]), 4),
+            "VAL": round(float(m["VAL"]), 4), "REI": round(float(m["REI"]), 4),
+            "CON": round(float(m.get("CON", 0.0)), 4), "FUL": round(float(m.get("FUL", 0.0)), 4),  # 신규 축(기록만 — 외로움/공허 실사용 검증용)
+            "strength": round(float(strength), 4),
+            "phase": state["phase"], "turn": state["turns"],
+            "refine_turns": state["refine_turns"], "stall_count": state["stall_count"],
+            "max_strength": round(float(state["max_strength"]), 4),
+            "n_candidates": len(state["candidates"]),
+            "irony_flag": state.get("irony_flag", "없음"),  # 반어 의심 레벨(기록만)
+            "emotions": state.get("emotions"),  # 사용자가 고른 감정 주제들(EMOTIONS 키 리스트) — 감정별 분석용
+            "utter_len": int(utter_len),
+            "text": text,  # 발화 원문(고지 후 수집). None이면 미저장.
+        }
+        self.write(rec)
+
+    def log_selection(self, session, candidates, chosen_idx, emotions=None):
+        """길2 완성 선택 기록 — 최종 후보 리스트와 사용자 선택. 원문 포함(고지 후 수집).
+        '사용자가 어떤 측정 특성/표현을 선택하는가'를 분석하기 위한 데이터."""
+        print(f"[SAVE-DEBUG] log_selection 호출됨: session={session}, "
+              f"후보수={len(candidates)}, chosen_idx={chosen_idx}")
+        cand_rows = []
+        for i, c in enumerate(candidates):
+            cand_rows.append({
+                "idx": i,
+                "EVA": c["EVA"], "EAR": c["EAR"], "VAL": c["VAL"], "REI": c["REI"],
+                "strength": c["strength"], "turn": c.get("turn"),
+                "len": len(c["text"]),
+                "text": c["text"],              # 후보 표현 원문(고지 후 수집)
+                "chosen": (i == chosen_idx),
+            })
+        chosen = candidates[chosen_idx] if 0 <= chosen_idx < len(candidates) else None
+        rec = {
+            "type": "coach_selection", "ts": int(time.time()), "datetime": _now(),
+            "session": session, "app_version": self.version, "encoder": self.encoder,
+            "n_candidates": len(candidates),
+            "chosen_idx": chosen_idx,
+            # 선택된 표현의 측정값(값만)
+            "chosen_EVA": chosen["EVA"] if chosen else None,
+            "chosen_EAR": chosen["EAR"] if chosen else None,
+            "chosen_VAL": chosen["VAL"] if chosen else None,
+            "chosen_REI": chosen["REI"] if chosen else None,
+            "chosen_strength": chosen["strength"] if chosen else None,
+            "chosen_turn": chosen.get("turn") if chosen else None,
+            "chosen_len": len(chosen["text"]) if chosen else None,
+            "chosen_text": chosen["text"] if chosen else None,  # 선택된 표현 원문(고지 후 수집)
+            # 후보 리스트 전체(값만 — 선택 안 된 것과 비교용)
+            "candidates": cand_rows,
+            # 선택된 게 신호강도 최고였나?(측정과 사람 선택의 일치 여부 — 핵심 분석 지표)
+            "chose_max_strength": (chosen_idx == max(range(len(candidates)),
+                                    key=lambda i: candidates[i]["strength"])) if candidates else None,
+            "emotions": emotions,  # 사용자가 고른 감정 주제들(EMOTIONS 키 리스트) — 감정별 선택 분석용
+        }
+        self.write(rec)
+
+STORE = CoachDataStore()
+import uuid as _uuid
+
+# ============================== 측정 → 자연어 요약 (좌표를 LLM에 압축 전달) ==============================
+def describe_measure(m):
+    """측정 좌표를 LLM이 읽을 짧은 자연어로. EVA는 강도 신뢰, 나머지는 방향 위주."""
+    eva, ear = m["EVA"], m["EAR"]
+    strength = signal_strength(m)
+    # EVA(감정가) — 강도까지 신뢰
+    if eva > 0.6: emo = "분명히 긍정적"
+    elif eva > 0.15: emo = "약간 긍정적"
+    elif eva < -0.6: emo = "분명히 부정적(가라앉음)"
+    elif eva < -0.15: emo = "약간 부정적"
+    else: emo = "중립적이거나 섞임"
+    # 신호 강도 — 막막/또렷
+    if strength < GATE: clarity = "감정이 흐릿하거나 억압된 듯(신호 약함)"
+    elif strength < CLEAR_THRESHOLD: clarity = "감정이 어느 정도 드러남"
+    else: clarity = "감정이 또렷하게 표현됨"
+    desc = f"감정가: {emo} / 표현 또렷함: {clarity} (신호강도 {strength:.2f})"
+    # VAL/REI 방향 성향 (실험적, 참고용) — 뚜렷할 때만, 강도 없이 방향만
+    val_dir, rei_dir = tendency_of(m)
+    hints = []
+    if val_dir == "자율":
+        hints.append("스스로 정하려는 결(자율) 쪽")
+    elif val_dir == "순응":
+        hints.append("주위에 맞추려는 결(순응) 쪽")
+    if rei_dir == "분석":
+        hints.append("따져 생각하는 결(분석) 쪽")
+    elif rei_dir == "직관":
+        hints.append("느낌으로 받아들이는 결(직관) 쪽")
+    if hints:
+        desc += f" / 말하는 결(참고만, 약하게): {', '.join(hints)}"
+    return desc
+
+# ============================== 코칭 프롬프트 (단계별) ==============================
+SITUATION = ("사용자는 '서운함·속상함·화남 같은 부정적인 마음을 누군가에게 전하고 싶은' 상황입니다. "
+             "상대는 연인일 수도, 가족·친구·동료일 수도 있습니다. 어떤 일이 있었고 그 일로 마음이 상했는데, "
+             "'이런 마음을 표현해도 되나, 어떻게 말해야 하나' 망설입니다. 고마움이나 미안함 같은 다른 감정이 "
+             "함께 섞여 있을 수도 있습니다. 구체적인 상황은 사용자가 직접 이야기합니다 — 미리 단정하지 마세요. "
+             "사용자의 성별·나이·관계는 정해져 있지 않습니다.")
+
+# ── 감정 주제 8가지 (터치 선택) ──────────────────────────────────────────
+# 실사용 피드백 반영: 감정 직접형(외로움/공허/화남/서운 — 여성 피드백 좋음) +
+#   관계·인정형(인정/관계회복/미안/복잡 — 인정·관계 프레임). 성별 라벨 없이 사용자가 끌리는 걸 선택.
+# 각 감정: label(버튼), note(코치용 상황 설명), tone(코치 접근 톤 힌트).
+# 약한 감정(외로움/공허/관계회복)은 '세기 약하니 차근차근, 변화율로'(사용자 지침) 톤 반영.
+EMOTIONS = {
+    "lonely": {
+        "label": "🌙 외로움 · 혼자인 것 같아 / 쓸쓸해 / 허전해",
+        "note": "사���자는 외로움을 느끼고 있습니다. 누군가에게 그 마음을 전하고 싶거나, 혼자라는 느낌을 털어놓고 싶어 합니다.",
+        "tone": "외로움은 격하게 터지기보다 가만히 가라앉는 감정입니다. 다그치지 말고, 그 쓸쓸함을 천천히 말로 옮기도록 차분히 곁을 지켜주세요.",
+    },
+    "empty": {
+        "label": "🫥 공허함 · 마음이 텅 빈 / 의욕이 없어 / 다 부질없어",
+        "note": "사용자는 공허함·허전함을 느끼고 있습니다. 무엇이 비어 있는지, 그 마음을 어떻게 표현할지 함께 찾고 싶어 합니다.",
+        "tone": "공허함은 또렷한 사건보다 막연한 느낌일 수 있습니다. 억지로 이유를 캐묻지 말고, 어렴풋한 마음을 조금씩 말로 만들어가게 도와주세요.",
+    },
+    "angry": {
+        "label": "🔥 화남 · 욱했어 / 따지고 싶어 / 못 참겠어",
+        "note": "사용자는 화가 난 상태입니다. 그 화를 누군가에게 어떻게 전할지, 어떻게 표현해야 할지 막막해합니다.",
+        "tone": "화는 강하게 올라오는 감정입니다. 화를 누르라고 하지 말고, 그 화 밑에 있는 진짜 바람(무엇을 원했는지)이 드러나도록 비춰주세요.",
+    },
+    "hurt": {
+        "label": "💧 서운함 · 서운해 / 몰라줘 / 기대했는데",
+        "note": "사용자는 누군가에게 서운하고 속상한 마음입니다. 그 마음을 그 사람에게 전하고 싶어 합니다.",
+        "tone": "서운함은 기대가 어긋난 자리에서 옵니다. '이런 마음을 가져도 되나' 망설임을 풀어주고, 자기 감정을 그대로 인정하게 도와주세요.",
+    },
+    "recognized": {
+        "label": "🏅 인정받고 싶음 · 알아줬으면 / 노력했는데 / 속상해",
+        "note": "사용자는 자신의 노력·마음을 누군가가 알아주길 바랍니다. 인정받고 싶은 마음을 어떻게 전할지 고민합니다.",
+        "tone": "인정 욕구는 약점이 아니라 자연스러운 바람입니다. '알아달라'고 말하는 게 부끄럽지 않도록, 그 바람을 떳떳이 표현하게 도와주세요. 감정을 캐묻기보다 '무엇을 알아줬으면 하는지'에 초점을 맞추세요.",
+    },
+    "reconnect": {
+        "label": "🤝 관계 회복 · 멀어졌어 / 다가가고 싶어 / 예전처럼",
+        "note": "사용자는 멀어졌거나 소원해진 사람과 다시 가까워지고 싶어 합니다. 그 마음을 어떻게 전할지 찾고 있습니다.",
+        "tone": "관계를 잇고 싶은 마음은 조심스럽습니다. 서두르지 말고, '다시 다가가고 싶다'는 마음을 부담 없이 한 걸음씩 말로 옮기게 도와주세요. 상대를 분석하기보다 자기 바람에 집중하게 하세요.",
+    },
+    "sorry": {
+        "label": "🙏 미안함 · 내가 잘못했어 / 사과하고 싶어 / 후회돼",
+        "note": "사용자는 누군가에게 미안한 마음이 있습니다. 그 사과를 어떻게 진심으로 전할지 고민합니다.",
+        "tone": "사과는 변명이 섞이면 흐려집니다. 자기 행동을 인정하는 마음이 또렷한 말이 되도록, 핑계보다 진심에 머물게 도와주세요.",
+    },
+}
+
+# 여러 감정을 함께 고른 경우(복합) 코치 톤 — 단일 감정 'mixed' 대신 다중선택으로 대체됨
+COMBINED_TONE = ("섞인 감정은 하나로 누르지 말고, 여러 마음이 함께 있어도 괜찮다고 알려주세요. "
+                 "그중 지금 가장 전하고 싶은 마음이 무엇인지 천천히 가려내게 도와주세요.")
+EMOTION_ORDER = ["lonely", "empty", "angry", "hurt", "recognized", "reconnect", "sorry"]
+
+COACH_RULES = ("당신은 '표현 코칭'을 돕는 따뜻한 대화 상대입니다. 핵심 원칙(반드시 지킬 것):\n"
+    "1) 절대 '이렇게 말해'라고 정답 문장을 주지 마세요. 당신은 거울과 산파일 뿐, 사용자가 스스로 자기 말을 찾게 돕습니다.\n"
+    "2) 사용자가 직접 쓴 표현을 존중하고, 더 정확한지 '본인이' 판단하게 하세요.\n"
+    "3) 감정을 지적·진단하지 말고, 부드럽게 비춰주고 물어보세요.\n"
+    "4) 한국어로 2~3문장, 따뜻하고 담백하게. 과한 느낌표·이모지 자제.\n"
+    "5) 표현이 서툰 것을 탓하지 말고, 표현하려는 시도 자체를 인정하세요.\n"
+    "6) 사용자에게 '상대방이 어떻게 반응할지/생각할지 예상해보라'고 묻지 마세요. 이 앱은 '자기 표현'을 돕는 곳이지 상대를 분석하는 곳이 아닙니다. "
+    "상대 입장은 필요할 때 '당신(코치)이 긍정적으로 비춰주는' 것이지, 사용자에게 예측을 시키지 않습니다.")
+
+# ============================== 나침반(감정 평면 + 궤적) ==============================
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+def render_compass(coords, best_idx=None):
+    """EVA(x: 부정↔긍정) × EAR(y: 차분↔격앙) 평면에 발화 궤적을 그린다.
+    coords: [(eva, ear, strength), ...] 발화 순서. best_idx: best 표현 순번(별표).
+    한글 폰트가 없는 환경(HF Space) 대비, 차트 내 텍스트는 영어/기호만 사용."""
+    fig, ax = plt.subplots(figsize=(4.2, 4.2), dpi=100)
+    lim = 2.2
+    # 사분면 배경/안내(영어로 — 폰트 안전)
+    ax.axhline(0, color="#bbb", lw=0.8, zorder=1)
+    ax.axvline(0, color="#bbb", lw=0.8, zorder=1)
+    ax.fill_between([-lim, 0], 0, lim, color="#ffe5e5", alpha=0.5, zorder=0)   # 좌상: 부정+격앙(분노)
+    ax.fill_between([0, lim], 0, lim, color="#fff4e0", alpha=0.5, zorder=0)    # 우상: 긍정+격앙(흥분)
+    ax.fill_between([-lim, 0], -lim, 0, color="#e8eef7", alpha=0.5, zorder=0)  # 좌하: 부정+차분(가라앉음)
+    ax.fill_between([0, lim], -lim, 0, color="#e6f5ea", alpha=0.5, zorder=0)   # 우하: 긍정+차분(평온)
+    ax.text(-lim*0.96, lim*0.88, "ANGRY", fontsize=8, color="#c0392b", alpha=0.7, weight="bold")
+    ax.text(lim*0.45, lim*0.88, "EXCITED", fontsize=8, color="#e67e22", alpha=0.7, weight="bold")
+    ax.text(-lim*0.96, -lim*0.93, "DOWN", fontsize=8, color="#5a7", alpha=0.7, weight="bold")
+    ax.text(lim*0.42, -lim*0.93, "CALM", fontsize=8, color="#27ae60", alpha=0.7, weight="bold")
+
+    if coords:
+        xs = [max(-lim, min(lim, c[0])) for c in coords]
+        ys = [max(-lim, min(lim, c[1])) for c in coords]
+        n = len(coords)
+        # ── B-2: 추세선(EMA 평활) — 측정 원본은 점으로 정직하게, 흐름은 부드러운 선으로 ──
+        # 긍정 흐름 중 "미안/짜증" 한 발화로 튀어도, 추세선은 이전 긍정을 반영해 완만하게 보상.
+        if n >= 2:
+            alpha_ema = 0.45  # 평활 강도(작을수록 더 부드러움 = 과거 더 반영)
+            ex, ey = xs[0], ys[0]
+            tx, ty = [ex], [ey]
+            for i in range(1, n):
+                ex = alpha_ema * xs[i] + (1 - alpha_ema) * ex
+                ey = alpha_ema * ys[i] + (1 - alpha_ema) * ey
+                tx.append(ex); ty.append(ey)
+            ax.plot(tx, ty, "-", color="#3498db", lw=2.4, alpha=0.55, zorder=2,
+                    solid_capstyle="round", label="흐름(추세)")
+            # 원본 점은 옅은 점선으로 가볍게 연결(순서 참고용)
+            ax.plot(xs, ys, ":", color="#aaa", lw=0.9, alpha=0.5, zorder=2)
+        # 원본 점들(측정 그대로 — 정확한 위치)
+        for i, (x, y) in enumerate(zip(xs, ys)):
+            is_last = (i == n - 1)
+            is_best = (best_idx is not None and i == best_idx)
+            if is_best:
+                ax.scatter([x], [y], s=260, marker="*", color="#f1c40f",
+                           edgecolors="#b8860b", linewidths=1.2, zorder=5)
+            alpha = 0.35 + 0.65 * (i + 1) / n
+            color = "#2c3e50" if is_last else "#5d6d7e"
+            sz = 130 if is_last else 70
+            ax.scatter([x], [y], s=sz, color=color, alpha=alpha, zorder=4,
+                       edgecolors="white", linewidths=1.0)
+            ax.annotate(str(i + 1), (x, y), fontsize=7, color="white",
+                        ha="center", va="center", zorder=6, weight="bold")
+        # 추세선 끝(현재 마음의 '흐름상' 위치) 표시
+        if n >= 2:
+            ax.scatter([tx[-1]], [ty[-1]], s=90, marker="D", color="#3498db",
+                       alpha=0.7, zorder=5, edgecolors="white", linewidths=1.0)
+
+    ax.set_xlim(-lim, lim); ax.set_ylim(-lim, lim)
+    ax.set_xlabel("← negative      valence      positive →", fontsize=8)
+    ax.set_ylabel("← calm      arousal      excited →", fontsize=8)
+    ax.set_xticks([]); ax.set_yticks([])
+    ax.set_title("Emotion Compass", fontsize=10, weight="bold")
+    # 범례(영어 — 폰트 안전): 점=각 발화, 파란선=흐름(추세), 별=가장 또렷한 표현
+    from matplotlib.lines import Line2D
+    legend_items = [
+        Line2D([0], [0], marker="o", color="w", markerfacecolor="#2c3e50", markersize=7, label="each msg"),
+        Line2D([0], [0], color="#3498db", lw=2.4, alpha=0.7, label="trend (smoothed)"),
+    ]
+    if best_idx is not None:
+        legend_items.append(Line2D([0], [0], marker="*", color="w", markerfacecolor="#f1c40f",
+                                   markeredgecolor="#b8860b", markersize=12, label="clearest"))
+    ax.legend(handles=legend_items, loc="upper right", fontsize=6.5, framealpha=0.85)
+    for spine in ax.spines.values():
+        spine.set_edgecolor("#ddd")
+    fig.tight_layout()
+    return fig
+
+def compass_caption(coords, best_idx=None):
+    """나침반 아래에 붙일 한글 설명(차트 밖이라 폰트 안전)."""
+    if not coords:
+        return "아직 좌표가 없어요. 마음을 적으면 나침반에 표시됩니다."
+    eva, ear, _ = coords[-1]
+    # 현재 위치 설명
+    val_txt = "긍정적" if eva > 0.3 else ("부정적" if eva < -0.3 else "중립")
+    ar_txt = "격앙됨" if ear > 0.3 else ("차분함" if ear < -0.3 else "보통")
+    cur = f"지금: 감정가 {val_txt}, 각성 {ar_txt}"
+    # 이동 설명(처음 대비)
+    move = ""
+    if len(coords) >= 2:
+        d_eva = eva - coords[0][0]; d_ear = ear - coords[0][1]
+        parts = []
+        if d_eva > 0.4: parts.append("덜 부정적으로")
+        elif d_eva < -0.4: parts.append("더 부정적으로")
+        if d_ear < -0.4: parts.append("더 차분하게")
+        elif d_ear > 0.4: parts.append("더 격해지게")
+        if parts:
+            move = " · 처음보다 " + ", ".join(parts) + " 이동했어요"
+    star = ""
+    if best_idx is not None:
+        star = f" · ⭐는 가장 또렷한 표현({best_idx+1}번)"
+    return cur + move + star
+
+def debug_line(m, strength, state):
+    """임계값 조정용 실측 표시(DEBUG=True일 때만). 측정값과 상태를 한 줄로."""
+    if not DEBUG:
+        return ""
+    n_cand = len(state.get("candidates", []))
+    irony = state.get("irony_flag", "없음")
+    irony_txt = f" | 반어신호={irony}" if irony in ("강", "급반전") else ""
+    return (f"<sub>🔧 EVA={m['EVA']:.2f} EAR={m['EAR']:.2f} VAL={m['VAL']:.2f} REI={m['REI']:.2f} "
+            f"신호={strength:.2f} | phase={state['phase']} refine턴={state['refine_turns']} "
+            f"max신호={state['max_strength']:.2f} stall={state['stall_count']} 후보={n_cand}개{irony_txt}</sub>")
+
+def build_coach_prompt(phase, measure_desc, situation_note="", best=None, hard5=False, tendency=None, emotions=None):
+    # 사용자가 고른 감정 주제(들)가 있으면 그 맥락·톤을 상황에 반영(감정별 코칭 분기)
+    valid = [e for e in (emotions or []) if e in EMOTIONS]
+    if len(valid) == 1:
+        em = EMOTIONS[valid[0]]
+        situation_block = f"{em['note']}\n[이 감정을 대할 때] {em['tone']}"
+    elif len(valid) >= 2:
+        # 복합: 고른 감정들의 note를 모으고, 복합 전용 톤을 붙임
+        names = " · ".join(EMOTIONS[e]["label"].split("·")[0].strip() for e in valid)
+        notes = " 그리고 ".join(EMOTIONS[e]["note"] for e in valid)
+        situation_block = (f"사용자는 여러 감정({names})이 섞여 있다고 느낍니다. {notes}\n"
+                           f"[이 감정을 대할 때] {COMBINED_TONE}")
+    else:
+        situation_block = SITUATION
+    base = f"{COACH_RULES}\n\n[상황]\n{situation_block}\n"
+    if best:
+        base += f"\n[사용자가 지금까지 도달한 가장 또렷한 표현]\n\"{best}\"\n"
+    if measure_desc:
+        base += f"\n[방금 사용자 발화의 측정 결과 — 은근히 참고하되 숫자나 진단은 직접 언급 금지]\n{measure_desc}\n"
+    # 성향 기반 코칭 방향 (실험적, 보조) — 방향만, 강도 없음. 강압 아닌 미세 조정.
+    if tendency:
+        val_dir, rei_dir = tendency
+        guide = []
+        if val_dir == "순응":
+            guide.append("이 사람은 주위에 맞추려는 결이 보입니다. 자기 마음을 눌러 표현을 망설일 수 있으니, '당신이 느끼는 것 자체가 소중하다'는 쪽으로 자기 표현을 살며시 북돋아 주세요.")
+        elif val_dir == "자율":
+            guide.append("이 사람은 스스로 정하려는 결이 보입니다. 이미 자기 마음을 꺼내고 있으니, 방향을 바꾸려 들지 말고 그 표현을 존중하며 비춰만 주세요.")
+        if rei_dir == "분석":
+            guide.append("이 사람은 따져 생각하는 결이 보입니다. 감정을 논리로 정리해 버리지 않도록, 느끼는 것 자체에 잠시 머물게 도와주세요.")
+        elif rei_dir == "직관":
+            guide.append("이 사람은 느낌으로 받아들이는 결이 보입니다. 막연한 느낌을 한 걸음 더 구체적인 말로 옮겨보도록 부드럽게 도와주세요.")
+        if guide:
+            base += ("\n[말하는 결에 맞춘 보조 지침 — 약하게 반영, 측정 진단은 절대 입 밖에 내지 말 것]\n"
+                     + " ".join(guide) + "\n")
+    if phase == "scaffold":
+        base += ("\n[지금 단계: 비계]\n사용자의 감정이 아직 흐릿합니다(억압·막막). "
+                 "감정을 '대신 규정'하지 말고, 방향을 좁히도록 도와주세요. 단 선택지(①②③)는 시스템이 따로 제시하므로, "
+                 "당신은 사용자가 자기 마음을 살짝 더 들여다보도록 공감하며 한 걸음만 이끄세요.")
+    elif phase == "graduate":
+        base += ("\n[지금 단계: 졸업 전환]\n사용자의 감정이 또렷해졌습니다. "
+                 "'고마움과 서운함은 함께 있어도 괜찮다'는 점을 비춰 자기검열을 풀어주고, "
+                 "이제 그 마음을 '직접 한 문장으로 써보도록' 부드럽게 권하세요.")
+    elif phase == "refine":
+        base += ("\n[지금 단계: 자기 문장 다듬기]\n사용자가 자기 표현을 썼습니다. "
+                 "그 문장에 어떤 마음이 담겼는지 측정 결과로 '비춰주고'(고쳐주지 말 것), "
+                 "처음보다 또렷해졌다면 그 변화를 짚어주세요.\n"
+                 "[중요 — 반복 금지] 매번 똑같은 질문('그 사람이 어떻게 반응할까요/이해하길 바라나요')을 되풀이하지 마세요. "
+                 "특히 '상대가 어떻게 반응할지 예상해보라'는 식의 질문은 하지 마세요 — 그건 상대를 분석하게 만들어 자기검열을 부추깁니다. "
+                 "대신 사용자 '자신의 표현'에 집중하게 하세요. 표현이 이미 또렷하면 더 캐묻지 말고, "
+                 "사용자가 한두 번 더 다듬으면 그것으로 충분합니다. 간결하게 1~2문장으로.")
+    elif phase == "confirm":
+        if hard5:
+            base += ("\n[지금 단계: 완성 확인 — 충분히 다듬음]\n사용자가 여러 번 표현을 다듬었습니다. 위 '가장 또렷한 표현'을 그대로 인용해 따뜻하게 인정한 뒤, "
+                     "'마음을 충분히 잘 정리하셨어요. 이대로 마무리할까요, 아니면 조금 더 다듬어볼까요?'라고 부드럽게 물으세요. "
+                     "절대 하지 말 것: 상대 반응 예상 질문, 같은 질문 반복. 2문장 이내.")
+        else:
+            base += ("\n[지금 단계: 완성 확인 — 딱 한 번만]\n사용자의 표현이 충분히 또렷해졌습니다. 위 '가장 또렷한 표현'을 그대로 인용해 따뜻하게 인정한 뒤, "
+                     "'이 표현이면 마음이 잘 담긴 것 같아요. 이대로 정리할까요?'라고 딱 한 번만 부드럽게 확인하세요. "
+                     "절대 하지 말 것: 상대 반응 예상 질문, '더 담아볼까요/덧붙일까요' 같은 추가 다듬기 유도, 같은 질문 반복. 2문장 이내.")
+    elif phase == "complete":
+        base += ("\n[지금 단계: 완성·마무리 — 질문 없이 끝맺기]\n사용자가 표현을 확정했습니다. 위 '가장 또렷한 표현'을 인용하며 다음을 담아 따뜻하게 맺으세요(2~3문장):\n"
+                 "1) 그 표현을 긍정적으로 재해석 — 서운함/요구가 아니라 '너와 더 가까이 있고 싶은 소중한 마음'임을 비춰주세요.\n"
+                 "2) 그 말이 상대에게 '비난'이 아니라 '사랑의 표현'으로 가닿을 수 있음을 당신(코치)이 직접 안심시켜 자기검열을 풀어주세요.\n"
+                 "3) 준비됐을 때 솔직하게 전해보도록 격려하고 끝맺으세요.\n"
+                 "★절대 금지: 어떤 질문도 하지 마세요(특히 '상대가 어떻게 반응할까요' 류). 이건 마지막 응답이니 질문 없이 따뜻하게 마침표를 찍으세요.")
+    return base
+
+# ============================== Gemini 호출 ==============================
+def _msg_text(c):
+    if isinstance(c, str): return c
+    if isinstance(c, list):
+        return " ".join(_msg_text(x) for x in c)
+    if isinstance(c, dict):
+        return c.get("text", "") or c.get("content", "") or ""
+    return str(c) if c is not None else ""
+
+def make_hint(candidates, emotions=None):
+    """완성 시점 힌트 1개 생성 — 사용자 발화 후보 중 '마음을 가장 잘 담은 것'을 골라
+    상대에게 전할 수 있게 보수적으로 다듬는다(재구성만, 내용 추가·조언·해석 금지).
+    측정이 표현 질을 못 보므로(KoSimCSE 한계) 이 판단·다듬기는 LLM이 맡음.
+    실패 시 None 반환(힌트 없이 진행)."""
+    texts = [c["text"] for c in (candidates or []) if c.get("text")]
+    if not texts:
+        return None
+    joined = "\n".join(f"- {t}" for t in texts)
+    sysp = (
+        "너는 사용자가 마음 속 이야기를 상대에게 전할 수 있게 돕는 도우미다.\n"
+        "아래는 사용자가 대화 중 한 말들이다. 이 중에서 사용자의 진짜 마음이 가장 잘 담긴 말을 하나 고르고, "
+        "그 말을 상대에게 그대로 전할 수 있는 자연스러운 한 문장으로 다듬어라.\n\n"
+        "[반드시 지킬 것]\n"
+        "1. 사용자가 하지 않은 말(새로운 내용·이유·상황)을 절대 추가하지 마라.\n"
+        "2. 조언·해결책·평가·훈수를 넣지 마라. 사용자의 마음을 대신 전하는 것일 뿐이다.\n"
+        "3. 사용자가 '나는 어떻게 해야 하나' 같이 스스로에게 던진 질문이나 도우미에게 한 질문은 고르지 마라. "
+        "상대에게 전할 '마음'을 골라라.\n"
+        "4. 1인칭으로(내가 상대에게 말하듯), 한 문장으로, 담담하게.\n"
+        "5. 설명 없이 다듬은 문장만 출력해라. 따옴표도 붙이지 마라."
+    )
+    user_msg = f"사용자가 한 말들:\n{joined}\n\n이 중 마음이 가장 잘 담긴 것을 골라 상대에게 전할 한 문장으로 다듬어줘."
+    try:
+        out = gemini(sysp, [], user_msg)
+    except Exception:
+        return None
+    if not out or out.startswith("["):  # 키 미설정 등
+        return None
+    hint = out.strip().strip('"').strip("'").split("\n")[0].strip()
+    # 안전장치: 너무 길거나(다듬기 실패) 비면 버림
+    if not hint or len(hint) > 120:
+        return None
+    # 후보 원문과 완전히 같으면 힌트로서 의미 없음 → 그래도 표시(다듬을 게 없던 것일 수)
+    return hint
+
+def gemini(sys_prompt, history, user_msg):
+    key = os.environ.get("GEMINI_API_KEY", "").strip()
+    if not key:
+        try:
+            from google.colab import userdata
+            key = (userdata.get("GEMINI_API_KEY") or "").strip()
+        except Exception:
+            pass
+    if not key:
+        return "[GEMINI_API_KEY 미설정 — 환경변수/Colab Secrets/Space Secret에 추가하세요]"
+    import requests
+    models = ["gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-flash-latest"]
+    # 최근 3턴(6메시지)만 — 비용 절제(입력 누적 방지). 좌표는 시스템 프롬프트에 이미 압축.
+    hist = (history or [])[-6:]
+    while hist and hist[0].get("role") == "assistant":
+        hist = hist[1:]
+    contents = []
+    for m in hist:
+        role = "model" if m.get("role") == "assistant" else "user"
+        c = _msg_text(m.get("content")).strip()
+        if c: contents.append({"role": role, "parts": [{"text": c}]})
+    contents.append({"role": "user", "parts": [{"text": user_msg}]})
+    payload = {"system_instruction": {"parts": [{"text": sys_prompt}]},
+               "contents": contents,
+               "generationConfig": {"thinkingConfig": {"thinkingBudget": 0},
+                                    "maxOutputTokens": 400, "temperature": 0.85}}
+    for mdl in models:
+        url = f"https://generativelanguage.googleapis.com/v1beta/models/{mdl}:generateContent?key={key}"
+        try:
+            data = requests.post(url, json=payload, timeout=30).json()
+        except Exception as e:
+            continue
+        if "error" in data:
+            continue
+        cands = data.get("candidates")
+        if not cands: continue
+        parts = cands[0].get("content", {}).get("parts", [])
+        text = "".join(p.get("text", "") for p in parts).strip()
+        if text: return text
+    return "[응답 생성 실패 — 잠시 후 다시 시도해주세요]"
+
+# ============================== 대화 상태 + 흐름 로직 ==============================
+def new_state():
+    return {"phase": "start",        # start → scaffold → refine → confirm → complete
+            "first_strength": None,   # 처음 적은 글의 신호강도(성장 비교용)
+            "first_text": None,
+            "candidates": [],          # 길2: refine 표현 후보 [{text, EVA, EAR, VAL, REI, strength, turn}]. UI는 text, 저장은 값.
+            "chosen_text": None,       # 사용자가 최종 선택한 표현(텍스트 — UI용)
+            "chosen_meta": None,       # 선택된 후보의 측정값(저장용 — 값만)
+            "refine_turns": 0,         # refine 단계에 머문 턴 수
+            "stall_count": 0,          # 새 표현 없이 맴돈 횟수(무한루프 방지)
+            "coords": [],              # 나침반 궤적: [(eva, ear, strength), ...] 발화별 좌표
+            "eva_hist": [],            # refine 단계 EVA 이력(조건3: 이전 3턴 평균 비교용)
+            "eva_all": [],             # 모든 발화 EVA 이력(반어 급반전 판정용 — start/confirm 포함, 직전 흐름 정확히)
+            "irony_flag": "없음",      # 반어 의심 플래그(기록만 — 측정값 안 건드림)
+            "max_strength": 0.0,       # 세션 최고 신호강도(완성 조건 판정용 — best '선정'과 무관)
+            "done_shown": False,       # 완성 마무리 1회 표시 여부
+            "show_confirm": False,     # 완성 선택 UI 표시 여부(@gr.render가 읽음)
+            "hint": None,              # 완성 시점 LLM이 다듬은 힌트(전달용 예시 1개)
+            "hard5_flag": False,       # 완성 멘트 hard5 여부(@gr.render 헤더용)
+            "emotions": [],            # 사용자가 고른 감정 주제들(EMOTIONS 키 리스트) — 다중선택, 코치 프롬프트 분기용
+            "emo_pick": [],            # 시작 화면에서 아직 '시작하기' 전 임시 선택(토글) 상태
+            "topic_chosen": False,     # 감정 주제 선택 완료 여부(시작 화면 버튼 표시 제어)
+            "session": None,           # 세션 id(저장용, 첫 발화 때 생성)
+            "turns": 0}
+
+# ── 완성 판정 파라미터 ──
+CLEAR_FOR_DONE = 0.6      # 완성 후보가 되려면 '세션 최고 표현'이 이 이상 또렷해야
+CONVERGE_DELTA = 0.10     # (참고용)
+REPEAT_SIM = 0.80         # (참고용)
+MIN_REFINE_TURNS = 1      # refine 최소 턴
+STALL_LIMIT = 3           # 새 표현 없이 이만큼 맴돌면 강제 완성 제안
+
+# ── 완성 4조건 ── (모호한 임계값 추측 대신 명확한 규칙)
+COND_MIN_REFINE = 3        # 조건1: refine 최소 턴
+EXTREME_NEG_EVA = -0.55    # 조건2: EVA가 이보다 위면 '극단 부정 해소'됨(이 아래는 아직 격한 분노)
+HARD_DONE_REFINE = 5       # 조건4: refine 5턴째엔 무조건 완료 선택지
+
+def completion_conditions(eva, state):
+    """완성 제안 4조건 판정.
+      조건1: refine 3턴 이상
+      조건2: 극단 부정 해소 (현재 EVA > EXTREME_NEG_EVA)
+      조건3: 현재 EVA ≥ 직전 3턴 평균 (감정이 나아지는 추세)
+      조건4: refine 5턴째면 무조건 완료 선택지(1·2·3 무시)
+    반환: (제안할까, 강제5턴인가, 사유)"""
+    rt = state["refine_turns"]
+    # 조건4 — 5턴째 강제
+    if rt >= HARD_DONE_REFINE:
+        return True, True, "5턴_강제선택"
+    # 조건1
+    if rt < COND_MIN_REFINE:
+        return False, False, ""
+    # 표현 후보가 하나라도 있어야(다듬은 결과)
+    if not state["candidates"]:
+        return False, False, ""
+    # 조건2 — 극단 부정 해소
+    if eva <= EXTREME_NEG_EVA:
+        return False, False, "조건2미충족(아직 격한 부정)"
+    # 조건3 — 직전 3턴 평균 이상
+    hist = state["eva_hist"]
+    if len(hist) >= 3:
+        prev3 = hist[-3:]
+        if eva < sum(prev3) / 3:
+            return False, False, "조건3미충족(감정 추세 하락)"
+    # 1·2·3 모두 충족
+    return True, False, "조건123충족"
+
+# ── 길2: 표현 후보 수집 ── (측정으로 best를 '선정'하지 않음 — 명백히 표현이 아닌 것만 제외하고 모두 수집)
+# 측정은 어순/구조를 못 보므로(shuffle 검증) best 자동 선정 불가. 대신 사용자가 완성 시 직접 선택.
+# 순수 메타 발화(코칭 소감)만 제외 — '좋았/고마워'가 표현 내용에 들어간 경우는 후보로 살림.
+PURE_META = ["고마워", "고맙습니다", "감사", "도움이 됐", "도움이 되었", "도움 됐", "알겠어", "알겠습니다",
+             "이제 알", "정리됐어", "정리되었", "기분이 나아", "덕분"]
+def is_pure_meta(t):
+    """발화 전체가 코칭에 대한 소감인지(표현이 아니라). 짧고 메타 표현으로만 구성."""
+    s = t.strip()
+    if len(s) <= 12 and any(s.startswith(w) or s == w or w in s for w in PURE_META):
+        return True
+    return False
+
+def is_coach_question(t):
+    """코치에게 던진 질문(조언 요청)인지 — '전할 표현'이 아니라 '어떻게 해야 하냐'는 물음.
+    예: '나는 어떻게 해야해?', '와이프한테 어떻게 해야 마음을 열 수 있어?', '이럴 땐 어떡해?'
+    이런 건 상대에게 전할 말이 아니므로 완성 후보에서 제외."""
+    s = t.strip()
+    # 물음표로 끝나고 + 조언/방법을 구하는 표현이 있으면 코치 질문으로 간주
+    asks_how = any(k in s for k in ["어떻게 해", "어떡해", "어떻게 하", "어떻해", "어찌해", "어째",
+                                     "방법이 뭐", "방법 좀", "어떻게 풀", "어떻게 대처",
+                                     "뭐라고 해야", "뭐라 해야", "어떤 말을 해야", "조언", "어떻게 말해"])
+    asks_self = any(k in s for k in ["나는 어떻게", "내가 어떻게", "난 어떻게", "어떻게 해야 할", "어떻게 해야 돼", "어떻게 해야해"])
+    if (s.endswith("?") or s.endswith("？")) and (asks_how or asks_self):
+        return True
+    if asks_self:  # '나는 어떻게 해야해' 류는 물음표 없어도
+        return True
+    if any(k in s for k in ["조언", "어떻게 해야", "어떡하면", "어떻게 하면 좋"]):  # 명시적 조언 요청은 물음표 없어도
+        return True
+    return False
+
+def is_expression_candidate(user_msg, said_done, is_choice):
+    """'전할 표현 후보'로 모을지 — 짧은 답/순수메타/선택지/확정어/코치질문만 제외, 나머지는 모두 후보.
+    (측정값으로 거르지 않음: 신호강도가 표현 완성도를 반영하지 못함이 확인됨.
+     '좋았/고마워'가 표현 내용에 든 경우는 살림 — 순수 메타 발화만 제외)"""
+    t = user_msg.strip()
+    if said_done or is_choice:
+        return False
+    if len(t) < 6:          # 너무 짧은 단어 조각/맞장구 제외
+        return False
+    if is_pure_meta(t):     # 순수 코칭 소감만 제외
+        return False
+    if is_coach_question(t):  # 코치에게 한 질문(조언 요청)은 '전할 표현'이 아니므로 제외
+        return False
+    # 단순 맞장구·되묻기(표현 아님) 제외
+    fillers = ["응 맞아", "그러게", "그치", "맞아 그래서", "뭐라는", "그건 왜", "그게 다야", "응 그래"]
+    if any(t == f or t.startswith(f + " ") for f in fillers):
+        return False
+    return True
+
+def add_candidate(state, user_msg, m, strength):
+    """후보 추가(중복 제외). 텍스트 + 측정값을 함께 저장. 최신이 뒤로."""
+    t = user_msg.strip()
+    for c in state["candidates"]:
+        if c["text"] == t:
+            return
+    state["candidates"].append({
+        "text": t,
+        "EVA": round(float(m["EVA"]), 4), "EAR": round(float(m["EAR"]), 4),
+        "VAL": round(float(m["VAL"]), 4), "REI": round(float(m["REI"]), 4),
+        "strength": round(float(strength), 4),
+        "turn": state["turns"],
+    })
+    # 너무 많아지면 최근 6개만(완성 시 선택 부담 줄임)
+    if len(state["candidates"]) > 6:
+        state["candidates"] = state["candidates"][-6:]
+
+# 사용자의 명시적 '확정/충분' 의사 (더 다듬을 게 없다는 명확한 신호만 — 맞장구성 '맞아/응'은 제외)
+DONE_WORDS = ["없는", "없어", "없을", "없다", "충분", "이대로", "이거면", "됐어", "됐고", "이게 다",
+              "그게 다", "다인거 같", "다인 것 같", "끝", "이 정도면", "이거로", "이걸로", "그만"]
+# 더 다듬겠다는 의사
+MORE_WORDS = ["더", "바꾸", "다시", "고치", "조금", "다른", "추가", "보태"]
+# 메타 대화(코칭 자체에 대한 응답: 고마움·소감) — '전할 표현'이 아니므로 best 추적에서 제외
+META_WORDS = ["고마", "감사", "도움", "알게", "알겠", "좋았", "좋네", "괜찮았", "덕분", "이제 알", "정리됐", "정리되"]
+
+def _cos(a, b):
+    if a is None or b is None: return 0.0
+    return float(a @ b / ((norm(a) * norm(b)) + 1e-8))
+
+SCAFFOLD_CHOICES = ["① 고마운데 뭔가 아쉬운", "② 서운한데 말하기 미안한", "③ 나도 내 마음을 잘 모르겠는"]
+
+# 상대 반응 예측을 유도하는 문장 — 생성 응답에서 이런 문장이 나오면 제거(프롬프트가 안 먹혀서 코드로 강제)
+import re as _re
+def strip_prediction(text):
+    """상대 반응 예측 유도 문장을 제거. 프롬프트로 막아도 LLM이 어겨서 코드로 강제 차단.
+    문장 단위로 쪼개, '상대(연인 등) + 반응/받아들임/생각' 류를 묻는 의문문이면 그 문장을 뺀다."""
+    # 문장 분리(물음표·마침표·줄바꿈 기준, 구분자 유지)
+    parts = _re.split(r'(?<=[.!?？\n])', text)
+    OTHER = ("연인", "상대", "그 사람", "남자친구", "여자친구", "그분", "그가", "그녀",
+             "가족", "친구", "동료", "엄마", "아빠", "부모", "남편", "아내", "선배", "후배", "그들")
+    REACT = ("반응", "받아들", "어떻게 들", "어떻게 생각", "어떻게 느", "어떤 마음", "어떤 생각")
+    kept = []
+    for s in parts:
+        is_q = ("?" in s) or ("？" in s)
+        about_other = any(o in s for o in OTHER)
+        about_react = any(r in s for r in REACT)
+        # 상대의 반응을 묻는 의문문이면 제거
+        if is_q and about_other and about_react:
+            continue
+        # '상상해/예상해/떠올려'+반응 류도 제거(상대 명시 없어도)
+        if is_q and any(g in s for g in ("상상해", "예상해", "떠올려")) and any(r in s for r in ("반응", "받아들")):
+            continue
+        kept.append(s)
+    out = "".join(kept)
+    out = _re.sub(r"\n{3,}", "\n\n", out).strip()
+    if out:
+        return out
+    # 전부 제거됨(= 응답이 상대반응 질문뿐이었음) → 자기표현으로 돌리는 중립 멘트로 대체
+    return "지금 표현에 당신의 마음이 잘 담긴 것 같아요. 혹시 더 보태고 싶은 말이 있으면 편하게 적어주세요."
+
+COMPLETE_CLARITY_THRESHOLD = 0.7   # best_strength 이 미만이면 A(또렷함 낮음), 이상이면 B(또렷함 높음). 실사용으로 조정.
+
+def make_completion_message(chosen_text, grew=False):
+    """완성 마무리를 코드가 직접 생성(LLM 안 씀 → 상대 반응 질문 구조적 차단).
+    길2: 사용자가 직접 고른 표현(chosen_text)을 인용해 따뜻하게 마무리."""
+    bt = (chosen_text or "").strip()
+    quote = f'"{bt}"\n\n' if bt else ""
+    grew_line = ""
+    if grew:
+        grew_line = "\n\n처음의 막연한 마음에서 여기까지, 표현이 한 걸음 또렷해졌어요."
+    body = ("이 표현에 당신의 마음이 잘 담겼어요. "
+            "막막했던 마음을 이렇게 한 문장으로 정리해낸 것 자체가 의미 있는 일이에요.\n\n"
+            "준비됐을 때, 편하게 전해보세요. 잘 해내실 거예요. 🙂")
+    return f"{quote}{body}{grew_line}"
+
+# ── 길2: 후보 선택 버튼 ──
+MAX_CAND = 6  # 후보 버튼 최대 개수
+
+def make_candidate_updates(state):  # [미사용] 0.8.2부터 @gr.render로 대체
+    """후보 버튼들 + '더 다듬기' 버튼의 gr.update 리스트 생성.
+    반환: [버튼1..버튼MAX_CAND, btn_more] (총 MAX_CAND+1개)"""
+    cands = state.get("candidates", [])[-MAX_CAND:]
+    updates = []
+    for i in range(MAX_CAND):
+        if i < len(cands):
+            txt = cands[i]["text"]
+            label = txt if len(txt) <= 40 else txt[:38] + "…"
+            updates.append(gr.update(value=label, visible=True))
+        else:
+            updates.append(gr.update(visible=False))
+    # 마지막: '더 다듬어볼래요' 버튼(완성 선택 시 항상 표시)
+    updates.append(gr.update(visible=True))
+    return updates
+
+OPENING = ("안녕하세요. 여기서는 '마음에 있는데, 어떻게 말해야 할지 막막한 이야기'를 같이 정리해볼 수 있어요.\n\n"
+           "지금 내 상황과 가장 가까운 걸 아래에서 하나 골라주세요. 고르고 나면, 무슨 일이 있었는지 편하게 적어보시면 돼요.\n"
+           "(딱 맞는 게 없어도 괜찮아요 — 가장 가까운 걸 고르거나 맨 아래 '여러 감정이 섞여서…'를 골라주세요.)")
+
+def respond(user_msg, chat, state, is_choice=False):
+    if not user_msg or not user_msg.strip():
+        return (chat, state, "", gr.update(visible=False), gr.update(), gr.update())
+    state["turns"] += 1
+    if state["session"] is None:
+        state["session"] = _uuid.uuid4().hex[:12]
+    m = ENGINE.measure(user_msg)
+    strength = signal_strength(m)
+    # 반어 의심 신호 — 측정 직후, eva_hist에 이번 값 넣기 전(직전 흐름 기준). 기록만, 측정값 불변.
+    irony_sig = irony_suspect(user_msg, m["EVA"], state["eva_all"])
+    state["irony_flag"] = irony_sig["level"]
+    mdesc = describe_measure(m)
+    tnd = tendency_of(m)  # VAL/REI 방향 성향 (실험적, 보조 코칭용)
+    show_choices = False
+    show_confirm = False  # 완성 제안 시 "더 해볼래요/충분해요" 버튼 표시 여부
+    said_done_now = any(w in user_msg for w in DONE_WORDS)
+    is_meta = any(w in user_msg for w in META_WORDS)
+    # 비계 선택지 문구는 사용자 표현이 아니므로 best에서 제외(버튼 클릭 또는 문구 일치)
+    is_choice = is_choice or (user_msg.strip() in SCAFFOLD_CHOICES)
+    phase_before = state["phase"]  # 이번 발화가 도착했을 때의 단계(전환 판단용)
+    # 나침반 좌표 누적(EVA=x, EAR=y)
+    state["coords"].append((m["EVA"], m["EAR"], strength))
+    state["eva_all"].append(m["EVA"])  # 모든 발화 EVA 누적(반어 판정용 — 다음 발화가 이번 흐름을 봄)
+
+    # 흐름 분기
+    if state["phase"] == "start":
+        # 처음 적기 → 신호강도로 막막/또렷 분기
+        state["first_strength"] = strength
+        state["first_text"] = user_msg
+        state["max_strength"] = max(state["max_strength"], strength)
+        if strength >= CLEAR_THRESHOLD:
+            # 또렷 → 바로 다듬기로
+            state["phase"] = "refine"
+            sysp = build_coach_prompt("graduate", mdesc, tendency=tnd, emotions=state.get("emotions"))
+            # 첫 발화가 또렷하면 후보로 수집(표현일 수 있음)
+            if is_expression_candidate(user_msg, said_done_now, is_choice):
+                add_candidate(state, user_msg, m, strength)
+        else:
+            # 막막 → 비계
+            state["phase"] = "scaffold"
+            sysp = build_coach_prompt("scaffold", mdesc, tendency=tnd, emotions=state.get("emotions"))
+            show_choices = True
+    elif state["phase"] == "scaffold":
+        # 비계 중 — 신호 또렷해지면 졸업, 아니면 계속 비계
+        state["max_strength"] = max(state["max_strength"], strength)
+        if strength >= CLEAR_THRESHOLD or any(k in user_msg for k in [
+                "서운", "속상", "화나", "화가", "짜증", "섭섭", "아쉬", "답답", "억울", "미안", "속상해", "슬프"]):
+            state["phase"] = "refine"
+            sysp = build_coach_prompt("graduate", mdesc, tendency=tnd, emotions=state.get("emotions"))
+            # 졸업을 일으킨 발화를 후보로 수집
+            if is_expression_candidate(user_msg, said_done_now, is_choice):
+                add_candidate(state, user_msg, m, strength)
+        else:
+            sysp = build_coach_prompt("scaffold", mdesc, tendency=tnd, emotions=state.get("emotions"))
+            show_choices = True
+    elif state["phase"] == "refine":
+        state["refine_turns"] += 1
+        state["eva_hist"].append(m["EVA"])  # 조건3용 EVA 이력
+        state["max_strength"] = max(state["max_strength"], strength)
+        # 길2: 표현 후보 수집(측정으로 거르지 않음 — 명백히 표현 아닌 것만 제외)
+        if is_expression_candidate(user_msg, said_done_now, is_choice):
+            add_candidate(state, user_msg, m, strength)
+            state["stall_count"] = 0
+        else:
+            state["stall_count"] += 1
+        # 완성 4조건 판정 (명확한 규칙)
+        suggest, hard5, why = completion_conditions(m["EVA"], state)
+        # 사용자가 직접 "충분/없어" 확정하면 바로 완성 선택으로(조건과 별개)
+        said_more = any(w in user_msg for w in MORE_WORDS)
+        explicit_done = said_done_now and not said_more and bool(state["candidates"])
+        if explicit_done or suggest:
+            # 완성 시점 — 사용자가 표현을 직접 선택(길2)
+            state["phase"] = "confirm"
+            sysp = "PICK_EXPRESSION"   # 후보 선택 UI 표시(코드 처리)
+            show_confirm = True
+            state["_hard5"] = hard5 and not explicit_done
+        else:
+            grew = ""
+            if state["first_strength"] is not None and state["max_strength"] > state["first_strength"] + 0.2:
+                grew = f"(처음보다 또렷해짐 — 성장 비춰주기)"
+            sysp = build_coach_prompt("refine", mdesc + " " + grew, tendency=tnd, emotions=state.get("emotions"))
+    elif state["phase"] == "confirm":
+        # 완성 제안 단계 — 보통은 버튼으로 처리되지만, 텍스트로 답한 경우 대비
+        affirm = any(w in user_msg for w in DONE_WORDS) or any(k in user_msg for k in ["응", "네", "그래", "좋아", "맞아", "알았", "그치", "그러"])
+        more = any(w in user_msg for w in MORE_WORDS) or ("아니" in user_msg and "아니야" not in user_msg[:4])
+        # 새 표현을 입력했으면 후보에 추가(긍정/더 아닌 실제 표현)
+        if is_expression_candidate(user_msg, said_done_now, is_choice) and not affirm:
+            add_candidate(state, user_msg, m, strength)
+        if more and not affirm:
+            state["phase"] = "refine"
+            state["stall_count"] = 0
+            sysp = build_coach_prompt("refine", mdesc, tendency=tnd, emotions=state.get("emotions"))
+        else:
+            # 다시 후보 선택 UI 표시
+            sysp = "PICK_EXPRESSION"
+            show_confirm = True
+    elif state["phase"] == "complete":
+        # 이미 마무리함 → 반복하지 않고 짧게 응답(종료 상태 유지)
+        sysp = "DONE_ALREADY"
+    else:
+        sysp = build_coach_prompt("refine", mdesc, tendency=tnd, emotions=state.get("emotions"))
+
+    # 응답 생성:
+    #  - sysp == "PICK_EXPRESSION": 완성 시점 → 사용자가 표현 직접 선택(길2). 후보 안내 멘트.
+    #  - sysp == "DONE_ALREADY": 이미 마무리함 → 반복 없이 짧은 종료 멘트
+    #  - 그 외: LLM 생성 후 '상대 반응 예측' 문장 후처리 제거
+    if sysp == "PICK_EXPRESSION":
+        hard5 = state.get("_hard5", False)
+        if hard5:
+            reply = ("여러 표현을 다듬어보셨어요. 충분히 마음이 정리된 것 같아요.\n"
+                     "아래에서 가장 마음에 드는 표현을 골라주세요. 더 다듬고 싶으면 '더 해볼래요'를 눌러주세요.")
+        else:
+            reply = ("지금까지 마음을 잘 표현해주셨어요.\n"
+                     "아래에서 그 사람에게 전하고 싶은 표현을 골라주세요. 더 다듬고 싶으면 '더 해볼래요'를 눌러주세요.")
+    elif sysp == "DONE_ALREADY":
+        reply = "이미 마음을 잘 정리하셨어요. 준비됐을 때 전해보세요. 새로 이야기하고 싶으면 페이지를 새로고침해 주세요. 🙂"
+    else:
+        reply = gemini(sysp, chat, user_msg)
+        reply = strip_prediction(reply)
+    chat = chat + [{"role": "user", "content": user_msg},
+                   {"role": "assistant", "content": reply}]
+    # 측정값·변수 저장(원문 제외, 길이만) — 갱신된 phase/refine_turns 반영
+    try:
+        STORE.log_turn(state["session"], m, strength, state, utter_len=len(user_msg.strip()), kind="user", text=user_msg.strip())
+    except Exception as e:
+        if DEBUG:
+            print("저장 실패:", e)
+    # 나침반 갱신(길2: best 별표 없음 — 측정이 best를 모름)
+    fig = render_compass(state["coords"], None)
+    cap = compass_caption(state["coords"], None)
+    dbg = debug_line(m, strength, state)
+    if dbg:
+        cap = cap + "\n\n" + dbg
+    # 완성 선택 UI는 @gr.render가 state["show_confirm"]/candidates를 보고 그림
+    state["show_confirm"] = show_confirm
+    # 완성 시점이면 힌트 1개 생성(사용자 발화를 전달용으로 보수적으로 다듬은 예시).
+    # 후보가 발화 원문 그대로라 그 자체로는 '전할 표현'이 되기 어려움 → LLM이 다듬어 예시 제공.
+    if show_confirm:
+        cands_for_hint = state.get("candidates", [])[-MAX_CAND:]
+        state["hint"] = make_hint(cands_for_hint, state.get("emotions"))
+    else:
+        state["hint"] = None
+    state["hard5_flag"] = state.get("_hard5", False)
+    return (chat, state, "", gr.update(visible=show_choices), fig, cap)
+
+def pick_choice(choice, chat, state):
+    # 비계 선택지 — 측정은 하되(분기용) best 추적에서는 제외(is_choice=True)
+    return respond(choice, chat, state, is_choice=True)
+
+def choose_more(chat, state):
+    """완성 시점에 '더 해볼래요' → refine 복귀(고도화 기회)."""
+    state["phase"] = "refine"
+    state["stall_count"] = 0
+    state["show_confirm"] = False  # 완성 선택 UI 닫기
+    reply = ("좋아요. 그럼 조금 더 다듬어볼까요? 지금 표현에서 더 보태거나 바꾸고 싶은 부분, "
+             "또는 아직 못 한 말이 있다면 편하게 적어주세요.")
+    chat = chat + [{"role": "assistant", "content": reply}]
+    fig = render_compass(state["coords"], None)
+    cap = compass_caption(state["coords"], None)
+    return (chat, state, "", gr.update(visible=False), fig, cap)
+
+def choose_candidate(idx, chat, state):
+    """후보 선택 → 그 표현으로 마무리(길2의 핵심). 선택 데이터 저장."""
+    cands = state.get("candidates", [])[-MAX_CAND:]
+    if idx < 0 or idx >= len(cands):
+        return (chat, state, "", gr.update(visible=False), gr.update(), gr.update())
+    chosen = cands[idx]
+    state["chosen_text"] = chosen["text"]
+    state["chosen_meta"] = chosen
+    state["phase"] = "complete"
+    state["done_shown"] = True
+    state["show_confirm"] = False  # 완성 선택 UI 닫기
+    # 선택 결과 저장(측정값 + 원문)
+    try:
+        STORE.log_selection(state["session"], cands, idx, emotions=state.get("emotions"))
+    except Exception as e:
+        if DEBUG:
+            print("선택 저장 실패:", e)
+    grew = (state["first_strength"] is not None and state["max_strength"] > state["first_strength"] + 0.25)
+    reply = make_completion_message(chosen["text"], grew=grew)
+    chat = chat + [{"role": "assistant", "content": reply}]
+    fig = render_compass(state["coords"], None)
+    cap = compass_caption(state["coords"], None)
+    return (chat, state, "", gr.update(visible=False), fig, cap)
+
+def choose_hint(hint_text, chat, state):
+    """LLM이 다듬은 힌트를 사용자가 선택 → 그 표현으로 마무리.
+    힌트 선택 여부도 기록(데이터 분석: 사람이 원문 vs 다듬은 힌트 중 무엇을 고르나)."""
+    state["chosen_text"] = hint_text
+    state["chosen_meta"] = {"text": hint_text, "is_hint": True}
+    state["phase"] = "complete"
+    state["done_shown"] = True
+    state["show_confirm"] = False
+    # 힌트 선택 기록 — log_selection에 힌트를 후보로 추가해 'chosen=힌트'로 저장
+    try:
+        cands = state.get("candidates", [])[-MAX_CAND:]
+        hint_cand = {"text": hint_text, "EVA": 0.0, "EAR": 0.0, "VAL": 0.0, "REI": 0.0,
+                     "strength": 0.0, "turn": state.get("turns"), "is_hint": True}
+        cands_with_hint = cands + [hint_cand]
+        STORE.log_selection(state["session"], cands_with_hint, len(cands_with_hint) - 1,
+                            emotions=state.get("emotions"))
+    except Exception as e:
+        if DEBUG:
+            print("힌트 선택 저장 실패:", e)
+    reply = make_completion_message(hint_text, grew=False)
+    chat = chat + [{"role": "assistant", "content": reply}]
+    fig = render_compass(state["coords"], None)
+    cap = compass_caption(state["coords"], None)
+    return (chat, state, "", gr.update(visible=False), fig, cap)
+
+def toggle_emotion(emotion_key, state):
+    """시작 화면에서 감정 주제 토글(선택/해제). 임시 선택 emo_pick만 갱신 → @gr.render 재실행으로 강조 반영.
+    아직 '시작하기' 전이므로 채팅은 시작하지 않음.
+    ※ Gradio가 state 변경을 확실히 감지하도록 새 dict를 반환(같은 객체 반환 시 재렌더 누락 위험)."""
+    if emotion_key not in EMOTIONS:
+        return state
+    pick = list(state.get("emo_pick", []))
+    if emotion_key in pick:
+        pick.remove(emotion_key)          # 다시 누르면 해제
+    else:
+        if len(pick) < 3:                 # 너무 많이 고르면 초점 흐려짐 → 최대 3개
+            pick.append(emotion_key)
+    new_state = dict(state)               # 새 객체로 복사 → 변경 감지 보장
+    new_state["emo_pick"] = pick
+    return new_state
+
+def start_with_emotions(chat, state):
+    """'시작하기' — 선택한 감정들을 확정하고 코칭 시작. 0개여도 시작 가능(바로 상황 적기)."""
+    state["emotions"] = list(state.get("emo_pick", []))
+    state["topic_chosen"] = True
+    n = len(state["emotions"])
+    if n == 0:
+        reply = ("편하게 시작해볼게요. 어떤 일이 있었는지, 그때 마음이 어땠는지 적어보세요. "
+                 "짧아도 괜찮아요. (적는 것만으로도 마음이 조금 정리될 거예요.)")
+    else:
+        reply = ("그런 마음이셨군요. 여기서 함께 천천히 들여다볼게요.\n\n"
+                 "어떤 일이 있었는지, 그때 마음이 어땠는지 편하게 적어보세요. 짧아도 괜찮아요. "
+                 "(적는 것만으로도 마음이 조금 정리될 거예요.)")
+    chat = chat + [{"role": "assistant", "content": reply}]
+    return (chat, state, "", gr.update(visible=False), gr.update(), gr.update())
+
+# ============================== UI ==============================
+def build_app():
+    with gr.Blocks(title="표현 코칭 (최소 흐름)") as demo:
+        gr.Markdown("## 표현 코칭 — 마음을 정리하고 표현 다듬기\n*하고 싶은 말을 함께 찾아가는 곳*")
+        state = gr.State(new_state())
+        outs_holder = {}  # 핸들러 출력 리스트를 런타임에 담아 @gr.render가 참조
+        with gr.Row():
+            with gr.Column(scale=3):
+                _cb_kwargs = dict(value=[{"role": "assistant", "content": OPENING}],
+                                  height=440, show_label=False)
+                try:
+                    if int(gr.__version__.split(".")[0]) < 6:
+                        _cb_kwargs["type"] = "messages"
+                except Exception:
+                    pass
+                chatbot = gr.Chatbot(**_cb_kwargs)
+                # 시작: 감정 주제 다중선택 (@gr.render — topic_chosen 전까지 표시)
+                # 토글 버튼(선택 시 강조) + '시작하기'. inputs=state로 로드 시 렌더 + 선택(state 변경) 시 재렌더.
+                @gr.render(inputs=state)
+                def render_topics(s):
+                    if s and s.get("topic_chosen"):
+                        return  # 이미 시작했으면 숨김
+                    _outs = outs_holder.get("outs")
+                    pick = (s.get("emo_pick", []) if s else [])
+                    gr.Markdown("**지금 내 마음에 가까운 걸 모두 골라주세요** (여러 개 선택 가능, 최대 3개)")
+                    for key in EMOTION_ORDER:
+                        em = EMOTIONS[key]
+                        selected = key in pick
+                        # 선택되면 primary(강조)+체크, 아니면 secondary
+                        label = ("✓ " + em["label"]) if selected else em["label"]
+                        b = gr.Button(label, size="sm",
+                                      variant=("primary" if selected else "secondary"))
+                        # 토글: state만 갱신 → 재렌더로 강조 반영 (채팅 시작 안 함)
+                        b.click(lambda st, _k=key: toggle_emotion(_k, st), [state], [state])
+                    # 선택 요약 + 시작 버튼
+                    if pick:
+                        names = ", ".join(EMOTIONS[k]["label"].split("·")[0].strip() for k in pick)
+                        gr.Markdown(f"선택: **{names}**")
+                    start = gr.Button("시작하기 →", variant="primary")
+                    start.click(start_with_emotions, [chatbot, state], _outs)
+                    gr.Markdown("<sub>딱 맞는 게 없으면 — 아무것도 고르지 않고 바로 '시작하기'를 눌러도 돼요.</sub>")
+                # 비계 선택지(막막할 때)
+                with gr.Row(visible=False) as choice_row:
+                    c1 = gr.Button(SCAFFOLD_CHOICES[0], size="sm")
+                    c2 = gr.Button(SCAFFOLD_CHOICES[1], size="sm")
+                    c3 = gr.Button(SCAFFOLD_CHOICES[2], size="sm")
+                # 길2: 완성 시점 — 표현 후보 선택 (@gr.render 동적 생성, 이 위치에 그려짐)
+                # 초기 visible=False 컴포넌트 업데이트 실패 문제를 회피: state를 보고 매번 새로 그림.
+                @gr.render(inputs=state, triggers=[chatbot.change])
+                def render_confirm(s):
+                    if not s or not s.get("show_confirm"):
+                        return
+                    cands = s.get("candidates", [])[-MAX_CAND:]
+                    if not cands:
+                        return
+                    if s.get("hard5_flag"):
+                        gr.Markdown("**여러 표현을 다듬어보셨어요. 가장 마음에 드는 표현을 골라주세요** ↓")
+                    else:
+                        gr.Markdown("**전하고 싶은 표현을 골라주세요** ↓")
+                    _outs = outs_holder.get("outs")
+                    # 힌트(LLM이 사용자 발화를 전달용으로 다듬은 예시) — 후보 위에, 구분해서 표시
+                    hint = s.get("hint")
+                    if hint:
+                        gr.Markdown(f"<sub>💡 이렇게 말해볼 수도 있어요 (예시일 뿐이에요)</sub>")
+                        hb = gr.Button(f"💡 {hint}", size="sm", variant="primary")
+                        hb.click(lambda ch, st, _h=hint: choose_hint(_h, ch, st),
+                                 [chatbot, state], _outs)
+                        gr.Markdown("<sub>— 또는 내가 한 말 중에서 고르기 —</sub>")
+                    for i, c in enumerate(cands):
+                        txt = c["text"]
+                        label = txt if len(txt) <= 40 else txt[:38] + "…"
+                        b = gr.Button(label, size="sm")
+                        b.click(lambda ch, st, _i=i: choose_candidate(_i, ch, st),
+                                [chatbot, state], _outs)
+                    mb = gr.Button("✏️ 더 다듬어볼래요", size="sm", variant="secondary")
+                    mb.click(choose_more, [chatbot, state], _outs)
+                with gr.Row():
+                    msg = gr.Textbox(show_label=False, placeholder="마음을 편하게 적어보세요…", scale=8)
+                    send = gr.Button("보내기", variant="primary", scale=1, min_width=70)
+            with gr.Column(scale=2):
+                gr.Markdown("**🧭 감정 나침반** — 내 마음이 어디서 어���로 움직이는지")
+                compass = gr.Plot(show_label=False)
+                compass_cap = gr.Markdown("아직 좌표가 없어요. 마음을 적으면 나침반에 표시됩니다.")
+        gr.Markdown("<sub>측정: KoSimCSE(감정·타이밍) · 표현 선택: 사용자 · 응답: Gemini · 대화 내용과 측정값은 서비스 개선을 위해 저장됩니다.</sub>")
+
+        # 출력: chatbot, state, msg, choice_row, compass, compass_cap (6개)
+        outs = [chatbot, state, msg, choice_row, compass, compass_cap]
+        outs_holder["outs"] = outs  # @gr.render 내부 핸들러가 런타임에 참조
+
+        msg.submit(respond, [msg, chatbot, state], outs)
+        send.click(respond, [msg, chatbot, state], outs)
+        c1.click(pick_choice, [c1, chatbot, state], outs)
+        c2.click(pick_choice, [c2, chatbot, state], outs)
+        c3.click(pick_choice, [c3, chatbot, state], outs)
+    return demo
+
+if __name__ == "__main__":
+    build_app().launch()