Upload app.py

app.py

@@ -0,0 +1,1201 @@
+# -*- coding: utf-8 -*-
+"""
+자기인식 지원 앱 — 지인 데이터 수집판 (P-25-0322)  v0.3-collect
+================================================================================
+데이터 플라이휠 + 영구 저장 + 안전 고지.
+  · 측정: KoSimCSE 임베딩으로 가치·인지·감정 4벡터 독립 측정
+  · 라벨: 측정값을 '보여주기 전' 독립 자기보고 → 깨끗한 검증쌍
+  · 저장: 데이터를 두 스트림으로 분리·구조화하여 HF Dataset에 영구 저장
+        - sessions.jsonl : 세션·온보딩 기준선 (1행/세션)
+        - labels.jsonl   : 라벨 검증쌍 (1행/라벨 턴)
+  · 안전: 위기 안내 + 동의 고지(동의 시에만 발화 저장)
+
+운영(영구 저장 켜기):
+  Space Secret 에 HF_TOKEN(쓰기 권한) 과 HF_DATASET_REPO("아이디/데이터셋명") 설정.
+  미설정 시 로컬 파일로만 저장(Colab은 세션 보존, Spaces는 재시작 시 초기화).
+
+⚠️ 실험 도구이며 상담·치료가 아님. 발화는 민감정보 — 동의·익명화 전제. 정신건강 위기는 전문기관으로.
+================================================================================
+"""
+import numpy as np
+from numpy.linalg import norm
+import os, json, time, uuid, datetime
+from contextlib import nullcontext
+
+VERSION = "0.4.15-consent-save"  # 데이터 저장 문제 수정: 동의 체크박스 기본 ON(value=True, 깜빡 방지)+안내문 '원치 않으면 해제'로 변경. do_chat이 미동의 시 채팅 아래 저장 경고 표시. 입력창 아래 '💾 내 데이터 저장 상태 확인' 버튼 추가(저장 ON/OFF·참가자코드·턴수 안내).  # (4)Gemini thinking 끔(thinkingBudget=0)+출력상한500 → 토큰·비용·지연 감소. (2)EVA/EAR 자기보고 발화앵커 구체화. (3)단일발화: 짧은발화 길이가중 억제(6자미만 제외)+EVA/EAR 평활(나침반 안흔들림), reveal은 원시값 유지.  # 온보딩 Q1~Q4 강도별 4지선다(2→4, 기준선 정밀화). EAR 고각성 라벨에 분노 추가(매우 들뜸·긴장·분노).  # 측정 나침반(심플 3축 막대 EVA·EAR·VAL, REI제외; EVA강도신뢰·EAR/VAL방향위주; profile_md→gr.HTML). 성찰질문형 넛지(주제당1회·재청시재제공·조언금지·안전우선).  # 자기보고 4지선다(중간 제거, EVA/EAR/VAL/REI+PILOT). VAL 질문 직관화. build_prompt: 약간 긍정적 존댓말+닉네임 호칭+관심 말투, 3턴부터 사용자 유형별 대화 전략.  # 체크박스 첫 선택 지연 수정: CheckboxGroup을 빈 choices 대신 공통항목으로 초기화(프라이밍) → 첫 선택부터 즉시 렌더. on_domain은 도메인 선택 시 도메인 항목 추가.  # 관심사 체크박스: on_domain이 gr.update 대신 새 CheckboxGroup 인스턴스 반환(6.0에서 빈 choices 갱신 확실). + 진단 로그(이벤트 발동·반환 개수).  # 6.0 대응(트레이스백 기반): content가 리스트로 와 .strip() 크래시(=원래 2턴 오류) → content 정규화 헬퍼. Chatbot type 버전조건부(6.0은 생략). README는 버전 핀 제거(4.44.1은 Py3.13 audioop 비호환 → 작동하던 6.x 사용).
+
+# ============================== 설정 ==============================
+ENCODER = "BM-K/KoSimCSE-roberta-multitask"   # 또는 "BAAI/bge-m3"
+USE_SENTENCE_TRANSFORMERS = ENCODER.startswith("BAAI")
+LLM_MODE = "gemini"      # "template" | "gemini" | "local"
+W_BASE = 6.0
+GATE = 0.5              # (구) 하드 신뢰 게이트 — 누적에선 소프트 가중(|coord|)으로 대체됨
+LEN_REF = 150          # 길이 정규화 기준(자): 초과 발화는 가중치를 완만히 감소(긴 글의 분석 편향 완화)
+MIN_MEASURE_LEN = 6    # 이 미만(자)은 측정 신뢰 불가 → 누적·평활에서 제외(가중 0). 데이터: 짧은 발화 어휘노이즈
+RELIABLE_LEN = 18      # 이 이상이면 측정 신뢰(full 가중). MIN~RELIABLE은 약하게 합성(짧을수록 약하게)
+FREE_WEIGHT = 0.5
+DATA_DIR = "data"                                   # 수집 데이터 폴더(분리 저장)
+HF_DATASET_REPO = os.environ.get("HF_DATASET_REPO", "")   # 예: "myid/selfaware-data"
+
+# Gemini 토큰 단가(USD per 1M tokens): (입력, 출력). 출력엔 thinking 토큰 포함해 합산.
+GEMINI_PRICES = {
+    "gemini-2.5-flash": (0.30, 2.50),
+    "gemini-2.5-flash-lite": (0.10, 0.40),
+    "gemini-flash-latest": (0.30, 2.50),
+}
+def _gemini_cost(model, tin, tout):
+    pin, pout = GEMINI_PRICES.get(model, (0.30, 2.50))
+    return tin / 1e6 * pin + tout / 1e6 * pout
+
+# ============================== 축 정의 문항(한국어 1인칭) ==============================
+CONSTRUCTS = {
+    "VAL": {"label": ("자율 지향", "순응 지향"), "pos": [
+        "나는 내 삶을 어떻게 살지 스스로 결정하는 것을 좋아한다.",
+        "새롭고 독창적인 생각을 떠올리는 것이 나에게 중요하다.",
+        "나는 무엇이든 내 방식대로 해결하는 편이다.",
+        "내 목표를 스스로 자유롭게 선택하는 것이 중요하다.",
+        "남에게 묻기보다 내 판단을 믿고 따르는 편이다.",
+        "나는 호기심을 따라 새로운 것을 탐험하는 것을 가치 있게 여긴다.",
+        "누가 알려주기보다 세상을 스스로 이해하고 싶다.",
+        "나는 독립적으로 일을 해내는 것에 자부심을 느낀다.",
+        "남을 따라 하기보다 내 방식을 새로 만드는 편이 좋다.",
+        "내 인생의 방향을 스스로 정하는 것이 무척 중요하다.",
+        "나는 창의적으로, 내 식대로 시도하는 것을 좋아한다.",
+        "나에게 무엇이 옳은지 스스로 판단할 수 있다고 믿는다.",
+    ], "neg": [
+        "나는 사람은 규칙을 잘 지켜야 한다고 생각한다.",
+        "시키는 일을 잘 따르는 것이 나에게 중요하다.",
+        "나는 예의 바르게 행동하고 잘못된 일을 하지 않으려 애쓴다.",
+        "물려받은 전통과 관습을 지키는 것이 나에게 중요하다.",
+        "나는 권위와 윗사람을 존중해야 한다고 믿는다.",
+        "전통을 존중하는 것을 중요하게 여긴다.",
+        "나는 튀기보다 집단에 어울리는 편을 택한다.",
+        "정해진 방식을 함부로 의심하지 않는 편이 낫다고 생각한다.",
+        "나에게 기대되는 바를 지키는 것이 옳게 느껴진다.",
+        "나는 순종적이고 믿음직한 사람이 되는 것을 가치 있게 여긴다.",
+        "사회 규범에는 이유가 있으니 지켜야 한다고 믿는다.",
+        "나에게는 새로움보다 안정과 질서를 지키는 것이 더 중요하다.",
+        # 선택-동사 순응 보강 — 진단 결과 '능동 선택형 순응'(남들 따라 고르기)이
+        # 자율로 오측정되던 문제 완화. 독립 데이터 검증 AUC 0.90→0.95.
+        "남들이 많이 사는 물건을 골라서 산다.",
+        "유행하는 쪽을 보고 그대로 선택한다.",
+        "다수가 정한 방향에 내 결정을 맞춘다.",
+        "주변에서 고르는 것을 보고 똑같이 고른다.",
+        "나도 남들 하는 대로 무난한 쪽을 택한다.",
+        "사람들이 좋다고 하는 것을 골라 산다.",
+        "내 취향보다 대세를 따라 고르는 편이다.",
+        "남들 눈을 의식해서 선택을 정한다.",
+    ]},
+    "REI": {"label": ("분석적", "직관적"), "pos": [
+        "나는 깊이 생각해야 하는 문제를 즐긴다.",
+        "행동하기 전에 상황을 논리적으로 분석하는 것을 좋아한다.",
+        "나는 단계를 밟아 차근차근 따져보는 편이다.",
+        "복잡한 문제를 깊이 고민하는 것이 만족스럽다.",
+        "나는 결론을 내릴 때 논리와 근거에 의존한다.",
+        "문제를 부분으로 나누어 분석하는 것을 좋아한다.",
+        "어려운 지적 과제를 풀어내는 것을 즐긴다.",
+        "결정할 때 감정보다 이성을 더 믿는다.",
+        "나는 결정 전에 장단점을 신중히 따져본다.",
+        "추상적이고 분석적인 사고가 즐겁다.",
+        "분명한 근거로 뒷받침된 결론을 선호한다.",
+        "무언가의 논리를 풀어내면 만족스럽다.",
+        "느낌이 좋았지만 가격을 비교하고 구매했다.",
+        "느낌보다 데이터를 우선해 전공을 정했다.",
+        "감으로 판단하지 않고 사실을 확인했다.",
+        "직감이 들어도 먼저 수치를 확인한다.",
+        "막연한 느낌을 숫자로 바꿔 확인했다.",
+        "직감이 나빴지만 안전 데이터를 검증했다.",
+        "감보다 근거를 보고 이직을 결정했다.",
+        "느낌에 기대지 않고 논문을 분석했다.",
+        "느낌이 와도 계약 조건을 따져본다.",
+        "직감을 가설로 세워 실험을 설계했다.",
+    ], "neg": [
+        "나는 보통 직감에 따라 행동한다.",
+        "나는 종종 무엇이 옳은지 그냥 느낌으로 안다.",
+        "분석보다 첫인상에 더 의존하는 편이다.",
+        "나는 많은 결정을 느낌에 따라 내린다.",
+        "설명할 수 없어도 내 직관을 믿는다.",
+        "내 예감은 대체로 들어맞는다.",
+        "나는 그 순간 옳게 느껴지는 대로 하는 편이다.",
+        "나는 상황을 본능으로 읽는다.",
+        "나는 결정을 느낌으로 더듬어 가는 편이 좋다.",
+        "나는 감정과 인상에 따라 선택하곤 한다.",
+        "따져보지 않아도 옳다는 걸 아는 경우가 많다.",
+        "나는 신중한 분석보다 직관에 더 의존한다.",
+    ]},
+    "EVA": {"label": ("긍정", "부정"), "pos": [
+        "지금 나는 즐겁고 기분이 좋다.", "따뜻한 만족감이 느껴진다.",
+        "오늘 나는 희망차고 밝다.", "나는 흐뭇하고 만족스럽다.",
+        "나는 고맙고 뿌듯하다.", "좋고 기분 좋은 느낌이 함께한다.",
+        "나는 행복하고 마음이 가볍다.", "나는 흡족하고 긍정적이다.",
+        "지금 내 안에 기쁨이 있다.", "나는 즐겁고 편안하다.",
+        "나는 감사하고 마음이 따뜻하다.", "밝은 안녕감이 느껴진다.",
+    ], "neg": [
+        "지금 나는 시무룩하고 우울하다.", "무거운 슬픔이 느껴진다.",
+        "오늘 나는 낙담하고 서럽다.", "나는 언짢고 불만스럽다.",
+        "나는 비참하고 의기소침하다.", "나쁘고 불쾌한 느낌이 함께한다.",
+        "나는 침울하고 풀이 죽었다.", "나는 속상하고 부정적이다.",
+        "지금 내 안에 슬픔이 있다.", "나는 슬프고 마음이 불편하다.",
+        "나는 씁쓸하고 마음이 차갑다.", "어두운 괴로움이 느껴진다.",
+    ]},
+    "EAR": {"label": ("고각성", "저각성"), "pos": [
+        "나는 활력이 넘치고 또렷이 깨어 있다.", "나는 들뜨고 잔뜩 흥분돼 있다.",
+        "내 몸이 활성화되고 긴장돼 있다.", "나는 격렬하고 잔뜩 달아올라 있다.",
+        "나는 안절부절못하며 에너지가 넘친다.", "심장이 빠르게 뛰는 것 같다.",
+        "나는 긴장되고 크게 각성돼 있다.", "나는 안달이 나고 자극받아 있다.",
+        "나는 한껏 충전돼 들떠 있다.", "나는 곤두서고 신경이 팽팽하다.",
+        "몸에 각성이 솟구치는 느낌이다.", "나는 또렷하고 활기차게 깨어 있다.",
+    ], "neg": [
+        "나는 차분하고 고요하다.", "나는 졸리고 느긋하다.",
+        "나는 조용하고 가라앉아 있다.", "나는 나른하고 멍하다.",
+        "내 에너지가 낮고 느리게 느껴진다.", "나는 누그러지고 서두르지 않는다.",
+        "나는 평온하고 쉬고 있다.", "나는 축 늘어지고 무겁다.",
+        "나는 잔잔하고 조용하다.", "나는 졸음이 오고 잦아든다.",
+        "깊은 고요함이 느껴진다.", "나는 느긋하고 반쯤 잠든 듯하다.",
+    ]},
+}
+
+# ============================== 온보딩(선택지 = 구성-순수 문장) ==============================
+ONBOARD = [
+    {"construct": "VAL", "q": "Q1. 중요한 결정을 앞두고 가까운 사람이 당신과 '다른' 의견을 강하게 말합니다. 당신은?", "choices": [
+        ("끝까지 내 판단대로 한다", "나는 주변이 강하게 반대해도 끝까지 내 판단대로 결정한다."),
+        ("대체로 내 생각을 따른다", "나는 주변 의견을 듣더라도 대체로 내 생각을 따라 결정하는 편이다."),
+        ("주변 의견을 꽤 반영한다", "나는 결정할 때 주변의 의견을 꽤 반영해 조정하는 편이다."),
+        ("주변 뜻에 맞춰 따른다", "나는 중요한 결정에서 주변의 뜻에 맞춰 따르는 편이다."),
+    ]},
+    {"construct": "VAL", "q": "Q2. 익숙한 안정을 포기해야 새로운 기회를 잡을 수 있습니다. 당신은?", "choices": [
+        ("과감히 새로 도전한다", "나는 안정을 포기하더라도 과감히 내 방식대로 새롭게 도전한다."),
+        ("어느 정도 시도해본다", "나는 안정을 조금 양보하더라도 새로운 기회를 어느 정도 시도하는 편이다."),
+        ("대체로 안정을 지킨다", "나는 새로운 기회보다 대체로 안정과 익숙함을 지키는 편이다."),
+        ("안정과 조화를 지킨다", "나는 새로운 기회보다 안정과 사람들과의 조화를 확실히 지킨다."),
+    ]},
+    {"construct": "REI", "q": "Q3. 처음 보는 복잡한 문제를 풀어야 합니다. 당신의 첫 반응은?", "choices": [
+        ("철저히 분석부터 한다", "나는 복잡한 문제를 만나면 자료를 모아 철저히 논리적으로 분석한다."),
+        ("우선 근거를 따져본다", "나는 복잡한 문제를 만나면 우선 근거를 따져보며 차근차근 접근하는 편이다."),
+        ("대체로 직감을 따른다", "나는 복잡한 문제를 만나면 대체로 전체 느낌과 직감을 따르는 편이다."),
+        ("바로 직감으로 간다", "나는 복잡한 문제를 만나면 바로 전체 느낌을 잡아 직감으로 판단한다."),
+    ]},
+    {"construct": "REI", "q": "Q4. 큰 선택에서 '근거'와 '직감'이 서로 다른 방향을 가리킵니다. 당신은?", "choices": [
+        ("확실히 근거를 따른다", "나는 근거와 데이터가 가리키는 방향을 확실히 따라 결정한다."),
+        ("대체로 근거를 따른다", "나는 근거와 직감이 부딪치면 대체로 근거 쪽을 따르는 편이다."),
+        ("대체로 직감을 따른다", "나는 근거와 직감이 부딪치면 대체로 직감 쪽을 따르는 편이다."),
+        ("확실히 직감을 따른다", "나는 직감과 느낌이 가리키는 방향을 확실히 따라 결정한다."),
+    ]},
+]
+
+# ============================== 라벨 수집 설계 ==============================
+LABEL_SCHEMES = {
+    "EVA": {"q": "잠깐 — 방금 그 말을 할 때, 기분은 어느 쪽에 더 가까웠나요?",
+            "opts": [("매우 슬픔", -2), ("약간 슬픔", -1), ("약간 즐거움", 1), ("매우 즐거움", 2)],
+            "poles": ("즐거운", "슬픈"), "reveal_lead": "기분을 ‘{}’ 쪽으로"},
+    "EAR": {"q": "잠깐 — 방금 그 말을 할 때, 마음의 에너지는 어느 쪽이었나요?",
+            "opts": [("매우 차분·처짐", -2), ("약간 가라앉음", -1), ("약간 들뜸", 1), ("매우 들뜸·긴장·분노", 2)],
+            "poles": ("들뜬·긴장된", "차분한"), "reveal_lead": "에너지를 ‘{}’ 쪽으로"},
+    # VAL 직관화: '어땠나요'(추상) → '방금 한 그 일이 누구의 뜻에 가까웠나'(구체).
+    "VAL": {"q": "잠깐 — 방금 말씀하신 그 일은 누구의 뜻에 더 가까웠나요? (내 뜻대로 ↔ 남·상황에 맞춰)",
+            "opts": [("전적으로 남·상황에 맞춤", -2), ("주로 맞춤", -1), ("주로 내 뜻대로", 1), ("전적으로 내 뜻대로", 2)],
+            "poles": ("주도적인", "맞춰주는"), "reveal_lead": "태도를 ‘{}’ 쪽으로"},
+    # REI: '말투'(문체) 기준. 측정이 분석↔직관 어휘/문체를 보므로 자기보고도 문체를 묻도록 정렬.
+    "REI": {"q": "잠깐 — 방금 ‘말투’는 어느 쪽에 더 가깝나요?",
+            "opts": [("매우 직감적 말투", -2), ("약간 직감적", -1), ("약간 분석적", 1), ("매우 분석적 말투", 2)],
+            "poles": ("분석적인", "직감적인"), "reveal_lead": "말투를 ‘{}’ 쪽으로"},
+}
+_AXIS_CYCLE = ["EVA", "VAL", "EAR", "REI"]
+def pick_axis(n): return _AXIS_CYCLE[(n - 1) % len(_AXIS_CYCLE)]
+def _now(): return datetime.datetime.now().isoformat(timespec="seconds")
+
+
+# ============================== 관심사(2단계 계층형) — 측정 아님: 자기보고 + 대화 맥락 ==============================
+# 1단계 가치영역(우선순위) → 2단계 행복/방해(공통4 + 1순위 분류별3). VAL/REI 측정 축은 건드리지 않음.
+VALUE_DOMAINS = [
+    ("🏡 가정·관계", "family"), ("🏆 성공·성취", "achievement"), ("🕊️ 자유·자기실현", "freedom"),
+    ("🌿 안정·평온", "stability"), ("📚 배움·성장", "growth"), ("💪 건강", "health"), ("🎉 재미·즐거움", "fun"),
+]
+COMMON_HAPPY = [("🤝 가까운 사람과 함께할 때", "relation"), ("💗 몸과 마음이 건강할 때", "health"),
+                ("😄 즐겁고 재미있는 경험을 할 때", "fun"), ("🌿 안정되고 여유로울 때", "stability")]
+DOMAIN_HAPPY = {
+    "family": [("👨‍👩‍👧 가족과 따뜻한 시간을 보낼 때", "family"), ("💞 소중한 사람에게 힘이 되어줄 때", "relation"), ("🫂 사람들과 깊이 연결됐다고 느낄 때", "relation")],
+    "achievement": [("🎯 스스로 정한 목표를 이뤄낼 때", "achievement"), ("📈 실력이 늘고 성장하는 게 느껴질 때", "growth"), ("🏅 노력을 인정받을 때", "recognition")],
+    "freedom": [("🧭 스스로 결정하고 선택할 때", "autonomy"), ("✨ 새로운 걸 시도하고 도전할 때", "openness"), ("🪶 무엇에도 얽매이지 않을 때", "autonomy")],
+    "stability": [("🛏️ 마음이 편안하고 걱정 없을 때", "stability"), ("🍵 느긋하게 쉴 여유가 있을 때", "stability"), ("🏠 일상이 안정적으로 돌아갈 때", "stability")],
+    "growth": [("💡 새로운 걸 배우고 깨달을 때", "growth"), ("🔍 호기심이 채워질 때", "growth"), ("🌱 어제보다 나아진 나를 느낄 때", "growth")],
+    "health": [("🏃 몸이 가볍고 활력 있을 때", "health"), ("🧘 마음이 건강하고 단단할 때", "health"), ("😴 잘 쉬고 회복됐을 때", "health")],
+    "fun": [("🎮 좋아하는 걸 즐길 때", "fun"), ("🎨 무언가에 몰입하고 빠져들 때", "flow"), ("🤣 마음껏 웃을 때", "fun")],
+}
+COMMON_BARRIER = [("💸 경제적 압박·돈 걱정", "money"), ("⏰ 시간이 부족하고 쫓길 때", "time"),
+                  ("😔 몸이 지치고 아플 때", "health"), ("🪞 나도 모르게 남과 비교하게 될 때", "comparison")]
+DOMAIN_BARRIER = {
+    "family": [("💔 가까운 사람과 갈등·서운함이 있을 때", "relation"), ("🫥 외롭거나 단절된 느낌일 때", "relation"), ("🤐 마음을 나눌 사람이 없을 때", "relation")],
+    "achievement": [("📉 노력만큼 성과가 안 날 때", "achievement"), ("🪫 실력이 정체된 느낌일 때", "growth"), ("🥀 인정받지 못한다고 느낄 때", "recognition")],
+    "freedom": [("⛓️ 내 뜻대로 못 하고 얽매일 때", "autonomy"), ("🚧 선택의 여지가 ��을 때", "autonomy"), ("📋 정해진 틀에 갇힌 느낌일 때", "autonomy")],
+    "stability": [("🌪️ 일상이 흔들리고 불안정할 때", "stability"), ("😰 마음이 쉴 틈 없이 불안할 때", "anxiety"), ("🌫️ 미래가 불확실하게 느껴질 때", "uncertainty")],
+    "growth": [("🧱 배우고 싶은데 여건이 안 될 때", "growth"), ("😶‍🌫️ 제자리걸음 같다고 느낄 때", "growth"), ("❓ 뭘 해야 할지 막막할 때", "uncertainty")],
+    "health": [("🤒 몸이 자주 아프거나 무거울 때", "health"), ("😣 잠을 못 자고 회복이 안 될 때", "health"), ("🥵 체력이 달릴 때", "health")],
+    "fun": [("🫠 즐길 여유나 흥미가 없을 때", "fun"), ("😑 모든 게 지루하게 느껴질 때", "fun"), ("🪫 좋아하던 것도 시큰둥할 때", "fun")],
+}
+_DOMAIN_TAG = {lbl: tag for lbl, tag in VALUE_DOMAINS}
+_HAPPY_TAG = {lbl: tag for lbl, tag in COMMON_HAPPY}
+_BARRIER_TAG = {lbl: tag for lbl, tag in COMMON_BARRIER}
+for _v in DOMAIN_HAPPY.values(): _HAPPY_TAG.update({l: t for l, t in _v})
+for _v in DOMAIN_BARRIER.values(): _BARRIER_TAG.update({l: t for l, t in _v})
+_COMMON_HAPPY_SET = {l for l, _ in COMMON_HAPPY}
+_COMMON_BARRIER_SET = {l for l, _ in COMMON_BARRIER}
+def happy_choices(tag): return [l for l, _ in COMMON_HAPPY + DOMAIN_HAPPY.get(tag, [])]
+def barrier_choices(tag): return [l for l, _ in COMMON_BARRIER + DOMAIN_BARRIER.get(tag, [])]
+def _txt(s): return s.split(" ", 1)[1] if " " in s else s   # 이모지 제거(프롬프트용)
+
+
+# ============================== 데이터 저장소(분리 스트림 + HF Dataset) ==============================
+class DataStore:
+    """수집 데이터를 sessions/labels 두 스트림으로 분리·구조화. 동의 시에만 발화 저장. 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.labels_path = os.path.join(data_dir, "labels.jsonl")
+        self.sessions_path = os.path.join(data_dir, "sessions.jsonl")
+        self.interests_path = os.path.join(data_dir, "interests.jsonl")
+        self.responses_path = os.path.join(data_dir, "responses.jsonl")
+        self.reveals_path = os.path.join(data_dir, "reveals.jsonl")
+        self.pilot_path = os.path.join(data_dir, "pilot_labels.jsonl")  # 연구 파일럿: 4축 자기라벨 + 측정 + LLM 점수 (원문 미저장)
+        self.pilot_saved = 0
+        self.version, self.encoder = version, encoder
+        self.stats = []        # 실시간 통계용(발화 없음, PII 아님)
+        self.resp_stats = []   # 응답 모델/폴백 집계(PII 아님)
+        self.tok_in = 0; self.tok_out = 0; self.cost_total = 0.0   # 실측 토큰·비용 누적
+        self.saved = 0
+        self.scheduler = None
+        if repo and os.environ.get("HF_TOKEN"):
+            try:
+                from huggingface_hub import CommitScheduler
+                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)
+            except Exception as e:
+                print("HF Dataset 동기화 OFF:", e)
+        if os.path.exists(self.labels_path):
+            try:
+                for ln in open(self.labels_path, encoding="utf-8"):
+                    r = json.loads(ln); ax = r["labeled_axis"]
+                    self.stats.append({"axis": ax, "coord": float(r["coord_" + ax]),
+                                       "label_value": int(r["label_value"])})
+                    self.saved += 1
+            except Exception:
+                pass
+        if os.path.exists(self.responses_path):
+            try:
+                for ln in open(self.responses_path, encoding="utf-8"):
+                    r = json.loads(ln)
+                    self.resp_stats.append({"model": r.get("response_model"),
+                                            "depth": int(r.get("fallback_depth", 0))})
+                    self.tok_in += int(r.get("prompt_tokens", 0) or 0)
+                    self.tok_out += int(r.get("output_tokens", 0) or 0)
+                    self.cost_total += float(r.get("cost_usd", 0) or 0)
+            except Exception:
+                pass
+
+    def _write(self, path, rec):
+        lock = self.scheduler.lock if self.scheduler else nullcontext()
+        with lock:
+            with open(path, "a", encoding="utf-8") as f:
+                f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+
+    def save_session(self, session, participant, consent, baseline, onboard_rows):
+        if not consent:
+            return
+        self._write(self.sessions_path, {
+            "type": "session", "ts": int(time.time()), "datetime": _now(),
+            "session": session, "participant": participant or None,
+            "encoder": self.encoder, "app_version": self.version, "consent": True,
+            "baseline_VAL": round(float(baseline[0]), 4), "baseline_REI": round(float(baseline[1]), 4),
+            "onboard": onboard_rows})
+
+    def save_interests(self, session, participant, domains, happy, barriers, consent):
+        if not consent:
+            return
+        self._write(self.interests_path, {
+            "type": "interests", "ts": int(time.time()), "datetime": _now(),
+            "session": session, "participant": participant or None,
+            "domains": domains, "happy": happy, "barriers": barriers,
+            "app_version": self.version})
+
+    def add_label(self, session, participant, turn, utt, coords, coords_cum, axis, label, value, consent):
+        self.stats.append({"axis": axis, "coord": float(coords[axis]),
+                           "coord_cum": float(coords_cum[axis]), "label_value": int(value)})
+        if not consent:
+            return
+        self._write(self.labels_path, {
+            "type": "label", "ts": int(time.time()), "datetime": _now(),
+            "session": session, "participant": participant or None, "turn": int(turn),
+            "char_len": len(utt),
+            "coord_VAL": round(float(coords["VAL"]), 4), "coord_REI": round(float(coords["REI"]), 4),
+            "coord_EVA": round(float(coords["EVA"]), 4), "coord_EAR": round(float(coords["EAR"]), 4),
+            "coord_VAL_cum": round(float(coords_cum["VAL"]), 4), "coord_REI_cum": round(float(coords_cum["REI"]), 4),
+            "coord_EVA_cum": round(float(coords_cum["EVA"]), 4), "coord_EAR_cum": round(float(coords_cum["EAR"]), 4),
+            "labeled_axis": axis, "label_text": label, "label_value": int(value),
+            "agree": (None if value == 0 else bool((coords[axis] >= 0) == (value > 0))),
+            "agree_cum": (None if value == 0 else bool((coords_cum[axis] >= 0) == (value > 0))),
+            "encoder": self.encoder, "app_version": self.version})
+        self.saved += 1
+
+    def add_reveal(self, session, participant, turn, axis, measured_sign, measured_label, self_value, fit_value, consent):
+        # (ii) 측정 공개 후 "이게 맞나요?" 재질문. 편향없는 자기보고(labels.jsonl)와 분리된 2차 검증 신호.
+        # fit_value: +1 맞음 / 0 모름 / -1 틀림 (사용자가 측정을 본 뒤의 직접 판단)
+        if not consent:
+            return
+        self._write(self.reveals_path, {
+            "type": "reveal", "ts": int(time.time()), "datetime": _now(),
+            "session": session, "participant": participant or None, "turn": int(turn),
+            "labeled_axis": axis, "measured_sign": int(measured_sign), "measured_label": measured_label,
+            "self_report_value": int(self_value), "fit_value": int(fit_value),
+            "encoder": self.encoder, "app_version": self.version})
+
+    def add_pilot_label(self, session, participant, turn, char_len, ko, ko_cum, llm, self_labels, consent, act_self=None):
+        # 연구 파일럿 — 4축 자기라벨(-2..+2) + KoSimCSE 측정 + LLM(Gemini) 채점(-100..+100).
+        # act_self: ACT(신체 활성도) 5번째 축 자기보고(-2..+2) 또는 None. 검증 중 — 측정/LLM은 4축 유지.
+        # 프로토콜 5.6: 수집 시점에 점수 계산, 발화 원문은 저장하지 않음(길이만).
+        self.pilot_saved += 1
+        if not consent:
+            return
+        rec = {
+            "type": "pilot_label", "ts": int(time.time()), "datetime": _now(),
+            "session": session, "participant": participant or None, "turn": int(turn),
+            "char_len": int(char_len),
+            "ko_VAL": round(float(ko["VAL"]), 4), "ko_REI": round(float(ko["REI"]), 4),
+            "ko_EVA": round(float(ko["EVA"]), 4), "ko_EAR": round(float(ko["EAR"]), 4),
+            "ko_VAL_cum": (round(float(ko_cum["VAL"]), 4) if ko_cum.get("VAL") is not None else None),
+            "ko_REI_cum": (round(float(ko_cum["REI"]), 4) if ko_cum.get("REI") is not None else None),
+            "ko_EVA_cum": round(float(ko_cum["EVA"]), 4), "ko_EAR_cum": round(float(ko_cum["EAR"]), 4),
+            "self_VAL": int(self_labels["VAL"]), "self_REI": int(self_labels["REI"]),
+            "self_EVA": int(self_labels["EVA"]), "self_EAR": int(self_labels["EAR"]),
+            "self_ACT": (int(act_self) if act_self is not None else None),
+            "llm_VAL": (round(float(llm["VAL"]), 1) if llm else None),
+            "llm_REI": (round(float(llm["REI"]), 1) if llm else None),
+            "llm_EVA": (round(float(llm["EVA"]), 1) if llm else None),
+            "llm_EAR": (round(float(llm["EAR"]), 1) if llm else None),
+            "llm_model": ("gemini" if llm else None),
+            "encoder": self.encoder, "app_version": self.version}
+        self._write(self.pilot_path, rec)
+
+    def add_response(self, session, participant, turn, model, depth, char_len, consent, usage=None):
+        # 응답 LLM ���델/폴백/실측 토큰·비용 기록 — 발화 원문 없음(PII 아님)
+        self.resp_stats.append({"model": model, "depth": int(depth)})
+        tin = int((usage or {}).get("in", 0) or 0)
+        tout = int((usage or {}).get("out", 0) or 0)
+        cost = _gemini_cost(model, tin, tout) if model else 0.0
+        self.tok_in += tin; self.tok_out += tout; self.cost_total += cost
+        if not consent:
+            return
+        self._write(self.responses_path, {
+            "type": "response", "ts": int(time.time()), "datetime": _now(),
+            "session": session, "participant": participant or None, "turn": int(turn),
+            "char_len": int(char_len), "response_model": model, "fallback_depth": int(depth),
+            "prompt_tokens": tin, "output_tokens": tout, "cost_usd": round(cost, 6),
+            "ok": bool(model is not None), "app_version": self.version})
+
+    def _resp_section(self):
+        if not self.resp_stats:
+            return ""
+        from collections import Counter
+        mc = Counter((r["model"] or "실패") for r in self.resp_stats)
+        fb = sum(1 for r in self.resp_stats if r["depth"] >= 1 and r["model"] is not None)
+        fail = sum(1 for r in self.resp_stats if r["model"] is None)
+        out = [f"\n**응답 모델 사용** (총 {len(self.resp_stats)}턴):"]
+        for mdl, ct in mc.most_common():
+            out.append(f"- {mdl}: {ct}회")
+        out.append(f"- 폴백 발생 {fb}회 · 응답 실패 {fail}회")
+        if self.tok_in or self.tok_out:
+            out.append(f"- 실측 토큰 누적: 입력 {self.tok_in:,} · 출력 {self.tok_out:,}")
+            out.append(f"- 실측 API 비용 누적: ${self.cost_total:.4f} (≈{self.cost_total*1380:,.0f}원)")
+        return "\n".join(out)
+
+    def summary_md(self):
+        head = ("🟢 HF Dataset 영구 저장 ON" if self.scheduler
+                else "🟡 로컬 저장만 — Spaces는 재시작 시 초기화 (HF_TOKEN·HF_DATASET_REPO 설정 시 영구화)")
+        if not self.stats:
+            return (f"### 측정 검증 데이터\n{head}\n\n아직 라벨이 없습니다. 대화 후 뜨는 자기보고를 눌러 보세요."
+                    + self._resp_section())
+        from collections import defaultdict
+        by = defaultdict(list)
+        for r in self.stats: by[r["axis"]].append(r)
+        lines = [f"### 측정 검증 데이터  (라벨 {len(self.stats)}개)", "실사용 발화 측정-자기보고 일치율:"]
+        allnn = []
+        for ax in ["EVA", "EAR", "VAL", "REI"]:
+            nn = [r for r in by.get(ax, []) if r["label_value"] != 0]
+            if not nn: continue
+            agr = np.mean([(r["coord"] >= 0) == (r["label_value"] > 0) for r in nn])
+            allnn += [(r["coord"] >= 0) == (r["label_value"] > 0) for r in nn]
+            lines.append(f"- {ax}: **{agr*100:.0f}%** (n={len(nn)})")
+        if allnn:
+            lines.append(f"\n**전체 일치율 {np.mean(allnn)*100:.0f}%**  (우연 기대 50%)")
+        rs = self._resp_section()
+        if rs:
+            lines.append(rs)
+        lines.append(f"\n_저장 레코드 {self.saved}개 · {head}_")
+        return "\n".join(lines)
+
+
+# ============================== 측정 엔진 ==============================
+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 new_profile():
+    return {
+        "baseline": {"VAL": None, "REI": None},
+        "cum": {"VAL": None, "REI": None},
+        "wsum": {"VAL": 0.0, "REI": 0.0},      # 세션 누적 가중치 합 (소프트 게이트용)
+        "wcsum": {"VAL": 0.0, "REI": 0.0},     # 세션 누적 (가중치×좌표) 합
+        "n": 0, "emotion_traj": [], "last": None,
+        "smooth": {"EVA": None, "EAR": None},   # EVA/EAR 약한 합성(평활)값 — 나침반 표시용(단일 발화 노이즈 완화)
+        "last_utt": None, "label_axis": None, "participant": None, "interests": None,
+        "pending_reveal": None,
+        "end_suggested": False, "ended": False,
+        "phase": "build", "clarify_queue": [], "clarify_asked": False, "explore_offered": False,
+    }
+
+def set_baseline(profile, val_coord, rei_coord):
+    profile["baseline"]["VAL"] = val_coord
+    profile["baseline"]["REI"] = rei_coord
+    profile["cum"]["VAL"] = val_coord
+    profile["cum"]["REI"] = rei_coord
+    return profile
+
+def _len_weight(n):
+    # 측정 신뢰도 ∝ 발화 길이. 너무 짧으면 제외, 짧으면 약하게(약한 합성), 충분하면 full, 너무 길면 완만 감소.
+    if n < MIN_MEASURE_LEN:
+        return 0.0                                          # 제외(어휘 노이즈로 측정 불가)
+    if n < RELIABLE_LEN:
+        return 0.3 + 0.7 * (n - MIN_MEASURE_LEN) / (RELIABLE_LEN - MIN_MEASURE_LEN)   # 0.3→1.0 선형
+    if n <= LEN_REF:
+        return 1.0
+    return (LEN_REF / max(n, 1)) ** 0.5                     # 긴 글의 분석 편향 완화(기존)
+
+def update_cumulative(profile, m, utt_len=0):
+    lw = _len_weight(utt_len)
+    for c in ("VAL", "REI"):
+        cn = m[c]
+        w = abs(cn) * lw                       # 소프트 게이트(신뢰=|coord|) × 길이 가중(짧으면 0~약하게)
+        profile["wsum"][c] += w
+        profile["wcsum"][c] += w * cn
+        base = profile["baseline"][c] if profile["baseline"][c] is not None else 0.0
+        # 기준선 앵커(가중치 W_BASE) + 세션 전체 신뢰가중 누적
+        profile["cum"][c] = (W_BASE * base + profile["wcsum"][c]) / (W_BASE + profile["wsum"][c])
+    # EVA/EAR 약한 합성(평활): 단일 발화 노이즈 완화. 짧은 발화(lw 작음)는 거의 반영 안 함, 너무 짧으면(lw=0) 이전값 유지.
+    for c in ("EVA", "EAR"):
+        prev = profile["smooth"][c]
+        if prev is None:
+            profile["smooth"][c] = float(m[c])
+        else:
+            alpha = 0.6 * lw
+            profile["smooth"][c] = float((1 - alpha) * prev + alpha * m[c])
+    profile["emotion_traj"].append(profile["smooth"]["EVA"])   # 궤적은 평활값으로(노이즈 완화)
+    profile["n"] += 1
+    profile["last"] = m            # 원시값 — 재질문(reveal)은 '방금 그 발화'를 비교하므로 원시 유지
+    return profile
+
+def emotion_trend(profile):
+    t = profile["emotion_traj"]
+    if len(t) < 2: return 0.0
+    k = min(4, len(t))
+    return float(np.mean(t[-k:]) - np.mean(t[:k]))
+
+
+# ============================== 응답 LLM(언어 출력만) ==============================
+def build_prompt(profile):
+    cum, last = profile["cum"], profile["last"] or {"EVA": 0, "EAR": 0}
+    val = "자율 지향(스스로 탐색하도록 도움)" if (cum["VAL"] or 0) >= 0 else "순응 지향(안정감과 명확한 방향 제시)"
+    rei = "분석적(논리·근거 중심)" if (cum["REI"] or 0) >= 0 else "직관적(비유·느낌 중심)"
+    eva = "즐거운 편" if last["EVA"] >= 0 else "가라앉은 편"
+    ear = "높음" if last["EAR"] >= 0 else "낮음"
+    nick = (profile.get("participant") or "").strip()
+    honorific = f"{nick}님" if nick else "사용자님"
+    base = (
+        f"당신은 '{honorific}'와 편하게 이야기 나누는 따뜻하고 다정한 대화 상대입니다. "
+        "항상 존댓말을 쓰고, 약간 밝고 긍정적인 말투를 쓰되 과하게 들뜨지는 마세요(느낌표·감탄사·이모지 남발 금지). "
+        f"사용자에게 진심으로 관심을 보이고, 가끔 자연스럽게 '{honorific}'이라고 불러 주세요(매 문장 호명은 어색하니 가끔만). "
+        "가장 중요한 규칙: 사용자가 방금 꺼낸 주제·감정에 먼저 반응하고 그 안에 머무르세요. "
+        "다른 고민을 캐묻거나 화제를 돌리지 말고, 사용자가 말한 것에 진짜로 응답하세요. "
+        "사용자가 무겁거나 진지한 이야기를 하면 즉시 톤을 낮추고 그 이야기에 충분히 머무르세요. "
+        "당신은 AI입니다 — 쉬고 있다거나 감정이 있다는 식으로 자신을 꾸며내지 말고, 사용자에게 집중하세요. "
+        "아래 측정 결과를 은근히 반영하되(진단·분석�� 직접 언급 금지):\n"
+        f"- 가치관: {val}\n- 인지 방식: {rei}\n- 지금 기분: {eva} · 에너지: {ear}\n"
+        "사용자의 가치관·인지 방식에 맞춰 말투를 조절하고, 현재 기분에 톤을 맞추세요. "
+        "한국어로 2~3문장, 일상 대화체로 짧게. "
+        "매 턴 질문하지 말고 공감으로 자연스럽게 마무리하세요(아래 '지금 할 일'이 있으면 그건 따르세요)."
+    )
+    phase = profile.get("phase", "build")
+    q = profile.get("clarify_queue") or []
+    if phase == "build" and profile.get("n", 0) >= 3:
+        base += (
+            "\n[대화 전략] 대화가 어느 정도 쌓였습니다. 사용자가 지금 무엇을 원하는지 살펴 그에 맞게 이끌어 주세요: "
+            "· 감정을 알아주길 원하는 듯하면 → 먼저 그 감정에 정서적으로 공감하기. "
+            "· 인정·이해를 원하는 듯하면 → 그 마음과 노력을 충분히 인정하고 이해해 주기. "
+            "· 지식·생각을 나누고 싶어 하면 → 흥미를 보이며 그 주제로 함께 이야기 나누기. "
+            "· 뿌듯함·자랑을 드러내면 → 진심으로 함께 기뻐하고 축하해 주기. "
+            "· 고민을 털어놓고 싶어 하면 → 판단 없이 들어주고 곁에 있어 주기. "
+            "사용자가 스스로 더 이야기하고 싶도록 여지를 열어두되(주도권은 사용자에게), 억지로 깊이 캐묻거나 원치 않는 방향으로 몰지 마세요. "
+            "어떤 유형인지 확실하지 않으면 일단 공감하며 가볍게 따라가세요."
+        )
+        base += (
+            "\n[넛지] 사용자가 불편하거나 힘든 상황을 이야기하면, 그 주제에서 '한 번만', 스스로 작은 변화를 떠올리도록 돕는 부드러운 질문을 건네세요. "
+            "예: \"혹시 지금 마음을 가볍게 해줄 수 있는 게 어떤 게 있을까요?\" "
+            "조언이나 해결책을 직접 제시하지 말고(사용자가 스스로 답을 찾도록), 같은 주제에서 반복하지 마세요. "
+            "사용자가 새 주제로 넘어가거나 다시 청하면 그때 다시 건네도 됩니다. "
+            "사용자가 정말 힘들어 보이면 넛지 대신 그냥 충분히 들어주세요(안녕이 최우선)."
+        )
+    if phase == "clarify" and q:
+        target = q[0]
+        if target == "VAL":
+            base += ("\n[지금 할 일] 사용자의 '가치관'(스스로 정함 ↔ 주변에 맞춤)이 온보딩에서 불명확했습니다. "
+                     "구체적인 실제 생활 상황을 하나 들어, 어느 쪽에 가까운지 자연스럽게 확인하는 질문을 '하나만' 하세요. 캐묻지 마세요.")
+        else:
+            base += ("\n[지금 할 일] 사용자의 '인지 방식'(분석 ↔ 직감)이 온보딩에서 불명확했습니다. "
+                     "구체적인 실제 생활 상황을 하나 들어, 어느 쪽에 가까운지 자연스럽게 확인하는 질문을 '하나만' 하세요. 캐묻지 마세요.")
+    elif phase == "explore":
+        bar = ""
+        it0 = profile.get("interests")
+        if it0 and it0.get("barriers"):
+            bar = f"사용자가 힘든 점으로 '{_txt(it0['barriers'][0]['item'])}'을(를) 꼽았습니다. "
+        base += ("\n[지금 할 일] 라포가 쌓였습니다. " + bar +
+                 "사용자가 지금 이야기하는 흐름을 끊지 말고, 그 안에서 한 번만 부드럽게 더 깊이 들어가는 질문을 던져 자기이해를 도와보세요. "
+                 "사용자가 원치 않거나 부담스러워하면 즉시 물러나 공감으로 돌아가세요. "
+                 "절대 부정적 감정을 억지로 끌어내거나 캐묻지 마세요. 사용자의 안녕이 최우선입니다.")
+    it = profile.get("interests")
+    if it:
+        ctx = []
+        dom = ", ".join(_txt(d["item"]) for d in it.get("domains", []))
+        hap = ", ".join(_txt(h["item"]) for h in it.get("happy", [])[:3])
+        bar = ", ".join(_txt(b["item"]) for b in it.get("barriers", [])[:3])
+        if dom: ctx.append(f"중요시하는 것: {dom}")
+        if hap: ctx.append(f"행복요인: {hap}")
+        if bar: ctx.append(f"방해요인: {bar}")
+        if ctx:
+            base += "\n참고 맥락(직접 나열하지 말고 자연스럽게만 반영): " + " · ".join(ctx)
+    return base
+
+def generate_response(profile, history, user_msg):
+    sys_prompt = build_prompt(profile)
+    if LLM_MODE == "gemini":
+        return _gemini(sys_prompt, history, user_msg)
+    if LLM_MODE == "local":
+        return (_local(sys_prompt, history, user_msg), "local", 0, None)
+    return (_template(profile, user_msg), "template", 0, None)
+
+def detect_ambiguity(onboard_rows, baseline_val, baseline_rei):
+    """온보딩에서 명료화가 필요한 구성(VAL/REI)을 반환. 부호충돌 또는 약신호(|기준선|<0.3)."""
+    queue = []
+    for ax, base in [("VAL", baseline_val), ("REI", baseline_rei)]:
+        cs = [r["coord"] for r in onboard_rows if r["axis"] == ax and r.get("coord") is not None]
+        conflict = (len(cs) == 2 and (cs[0] >= 0) != (cs[1] >= 0))
+        weak = (base is not None and abs(base) < 0.3)
+        if conflict or weak:
+            queue.append(ax)
+    return queue
+
+def generate_opening(profile):
+    """앱이 먼저 대화를 여는 첫 메시지(LLM 생성). 관심사 있으면 그걸로, 없으면 직업 질문."""
+    it = profile.get("interests")
+    if it and it.get("domains"):
+        dom = _txt(it["domains"][0]["item"])
+        op = (f"사용자가 요즘 중요하게 여기는 것으로 '{dom}'을(를) 꼽았습니다. "
+              "이걸 자연스럽게 언급하며 따뜻하게 대화를 여세요. 한두 문장으로 관심을 보이고, "
+              "그 주제로 부담 없는 질문을 하나만 하세요.")
+    else:
+        op = ("사용자가 관심사를 밝히지 않았습니다. 따뜻하게 인사하고, 요즘 어떤 일을 하며 지내는지"
+              "(직업이나 하루 일과) 가볍게 물어 대화를 여세요. 한두 문장과 질문 하나로.")
+    sys = "당신은 사용자와 편하게 수다 떠는 친근한 대화 상대입니다. 친구처럼 가볍고 자연스럽게, 한국어로 2~3문장. " + op
+    return _gemini(sys, [], "(따뜻하게 먼저 대화를 시작해 주세요.)")
+
+def _template(profile, user_msg):
+    last = profile["last"] or {"EVA": 0, "EAR": 0}
+    cum = profile["cum"]
+    feel = "마음이 무거우신 듯해요" if last["EVA"] < 0 else "기분이 괜찮아 보이세요"
+    nudge = "이 일을 스스로는 어떻게 바라보고 싶으세요?" if (cum["VAL"] or 0) >= 0 \
+            else "지금 가장 마음이 놓이는 방향은 어떤 쪽일까요?"
+    return f"{feel}. {nudge}"
+
+def _msg_text(content):
+    # Gradio 버전별 메시지 content 정규화: 4.x는 문자열, 6.0은 리스트([{'type':'text','text':...}])일 수 있음.
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, dict):
+        return str(content.get("text", "") or "")
+    if isinstance(content, (list, tuple)):
+        parts = []
+        for it in content:
+            if isinstance(it, str):
+                parts.append(it)
+            elif isinstance(it, dict):
+                parts.append(str(it.get("text", "") or ""))
+        return " ".join(p for p in parts if p)
+    return str(content)
+
+
+def _gemini(sys_prompt, history, user_msg):
+    import os, requests
+    key = os.environ.get("GEMINI_API_KEY", "").strip()
+    if not key:
+        return ("[GEMINI_API_KEY 가 설정되지 않았습니다. Colab Secrets 또는 Space Secret에 추가하세요.]", None, 0, None)
+    models = ["gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-flash-latest"]
+    # 최근 대화 이력 포함 — 맥락 유지. 비용 절제 위해 마지막 6개(=약 3턴)만. (이력 없으면 AI가 직전 흐름을 못 봄)
+    hist = (history or [])[-6:]
+    while hist and hist[0].get("role") == "assistant":
+        hist = hist[1:]   # Gemini contents는 user 턴으로 시작해야 함 — 선두 assistant 제거
+    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},  # thinking 끔 → 출력 토큰·비용·지연 대폭 감소(2.5-flash는 기본 on)
+                   "maxOutputTokens": 500,                    # 2~3문장이면 충분 — 폭주 방지 안전망
+                   "temperature": 0.9,
+               }}
+    last_err = ""
+    for i, mdl in enumerate(models):
+        url = (f"https://generativelanguage.googleapis.com/v1beta/models/"
+               f"{mdl}:generateContent?key={key}")
+        try:
+            data = requests.post(url, json=payload, timeout=30).json()
+        except Exception as e:
+            last_err = f"요청 실패: {e}"; continue
+        if "error" in data:
+            msg = data["error"].get("message", str(data["error"]))
+            last_err = f"{mdl}: {msg}"
+            if any(w in msg.lower() for w in ["not found", "not supported", "permission", "model", "quota", "rate", "exhaust"]):
+                continue
+            return (f"[Gemini 오류] {last_err}", None, i, None)
+        cands = data.get("candidates")
+        if not cands:
+            last_err = f"{mdl}: candidates 없음 ({data.get('promptFeedback', {})})"; continue
+        parts = cands[0].get("content", {}).get("parts", [])
+        text = "".join(p.get("text", "") for p in parts).strip()
+        if text:
+            um = data.get("usageMetadata", {}) or {}
+            usage = {"in": int(um.get("promptTokenCount", 0) or 0),
+                     "out": int(um.get("candidatesTokenCount", 0) or 0) + int(um.get("thoughtsTokenCount", 0) or 0)}
+            return (text, mdl, i, usage)
+        last_err = f"{mdl}: 빈 응답 (finishReason: {cands[0].get('finishReason')})"
+    return (f"[Gemini 응답 실패] 마지막 원인 — {last_err}", None, len(models), None)
+
+def _gemini_score_4axis(text):
+    # 연구 파일럿 — 발화를 4축으로 LLM 채점(-100..+100). 실패 시 None.
+    sys = ("다음 한국어 문장을 네 독립 축으로 채점하라. 각 축 -100~+100 정수. "
+           "오직 JSON만 출력하고 설명은 절대 쓰지 마라: {\"VAL\":n,\"REI\":n,\"EVA\":n,\"EAR\":n}\n"
+           "VAL 자율(+)↔순응(-): 내 기준으로 정하면 +, 주변·규칙에 맞추면 -.\n"
+           "REI 분석(+)↔직관(-): 근거·논리로 정하면 +, 직감·느낌으로 정하면 -.\n"
+           "EVA 긍정(+)↔부정(-): 감정이 긍정적이면 +, 부정적이면 -.\n"
+           "EAR 고각성(+)↔저각성(-): 에너지·흥분·긴장이 높으면 +, 차분·처짐이면 - (감정 좋고나쁨과 무관).\n"
+           "해당 축이 무관하면 0.")
+    try:
+        txt, mdl, depth, usage = _gemini(sys, [], (text or "").strip())
+    except Exception:
+        return None
+    if mdl is None or not txt:
+        return None
+    import json as _json, re as _re
+    s = txt.strip().replace("```json", "").replace("```", "").strip()
+    m = _re.search(r"\{.*\}", s, _re.DOTALL)
+    if not m:
+        return None
+    try:
+        d = _json.loads(m.group(0))
+        return {ax: float(d.get(ax, 0)) for ax in ("VAL", "REI", "EVA", "EAR")}
+    except Exception:
+        return None
+
+# 연구 파일럿 자기라벨 도구 (프로토콜 부록 A) — 4축 5단계
+PILOT_AXES = {
+    "EVA": ("기분(감정가)", ["-2 매우 부정적", "-1 약간 부정적", "+1 약간 긍정적", "+2 매우 긍정적"]),
+    "EAR": ("에너지·각성", ["-2 매우 차분·처짐", "-1 약간 가라앉음", "+1 약간 들뜸·또렷", "+2 매우 흥분·곤두섬"]),
+    "REI": ("사고방식", ["-2 순전히 직감·느낌", "-1 주로 느낌", "+1 주로 근거·논리", "+2 순전히 근거·논리"]),
+    "VAL": ("자율성", ["-2 전적으로 주변·규칙", "-1 주로 주변", "+1 주로 내 기준", "+2 전적으로 내 기준"]),
+}
+# ACT(신체 활성도) — 검증 중인 5번째 축 후보. 자기보고만 수집(측정·LLM은 4축 유지).
+# 각성(에너지 높낮이)과 별개로, '몸이 격렬하게 반응/소진된 정도'. 차분(저활성) vs 탈진(고활성) 구분 검증용.
+PILOT_ACT = ("신체 활성도(실험)", ["-2 완전히 이완·고요", "-1 약간 느슨", "+1 약간 격렬·긴장", "+2 매우 격렬·소진"])
+def _parse_pilot_val(opt):
+    return int(opt.split()[0])   # "-2 매우..." → -2, "+1 약간..." → 1 (중간 없는 4지선다 대응)
+_PILOT_MAP = {ax: {opt: _parse_pilot_val(opt) for opt in opts} for ax, (_lbl, opts) in PILOT_AXES.items()}
+_PILOT_MAP["ACT"] = {opt: _parse_pilot_val(opt) for opt in PILOT_ACT[1]}
+PILOT_PASSWORD = "qwer"
+
+
+def _local(sys_prompt, history, user_msg):
+    global _LOCAL_PIPE
+    try:
+        _LOCAL_PIPE
+    except NameError:
+        from transformers import pipeline
+        _LOCAL_PIPE = pipeline("text-generation", model="kakaocorp/kanana-nano-2.1b-instruct",
+                               device_map="auto", max_new_tokens=180)
+    msgs = [{"role": "system", "content": sys_prompt}, {"role": "user", "content": user_msg}]
+    try:
+        out = _LOCAL_PIPE(msgs)[0]["generated_text"]
+        return out[-1]["content"] if isinstance(out, list) else str(out)
+    except Exception as e:
+        return f"[로컬 모델 오류: {e}]"
+
+
+# ============================== Gradio UI ==============================
+def _wmean(pairs):
+    sw = sum(w for _, w in pairs)
+    return (sum(v * w for v, w in pairs) / sw) if sw else 0.0
+
+def build_app():
+    import gradio as gr
+    print("측정 엔진 로딩 중 (KoSimCSE)...")
+    engine = MeasurementEngine()
+    store = DataStore()
+    print("준비 완료.")
+    label2stmt = [{lab: stmt for lab, stmt in item["choices"]} for item in ONBOARD]
+
+    def label_update(axis, visible):
+        if not visible:
+            return gr.update(choices=[], value=None, visible=False)
+        sc = LABEL_SCHEMES[axis]
+        return gr.update(choices=[o[0] for o in sc["opts"]], label=sc["q"], value=None, visible=True)
+
+    def do_onboard(*args):
+        picks = args[:-4]; consent = args[-4]; participant = args[-3]; session = args[-2]; old_profile = args[-1]
+        coords = {"VAL": [], "REI": []}; onboard_rows = []
+        for i, item in enumerate(ONBOARD):
+            c = item["construct"]
+            radio, free = picks[2 * i], picks[2 * i + 1]
+            coord = None
+            if radio:
+                coord = engine.measure(label2stmt[i][radio])[c]
+                coords[c].append((coord, 1.0))
+            if free and free.strip():
+                fc = engine.measure(free.strip())[c]
+                coords[c].append((fc, FREE_WEIGHT))
+                coord = fc if coord is None else coord
+            onboard_rows.append({"axis": c, "choice": radio or None,
+                                 "coord": (round(float(coord), 4) if coord is not None else None)})
+        if not coords["VAL"] or not coords["REI"]:
+            return old_profile, "가치(Q1·Q2)와 인지(Q3·Q4) 각각에서 최소 한 가지는 선택하거나 입력해 주세요.", gr.update(), gr.update(), gr.update(), store.summary_md()
+        profile = set_baseline(new_profile(), _wmean(coords["VAL"]), _wmean(coords["REI"]))
+        profile["participant"] = (participant.strip() if participant and participant.strip() else None)
+        profile["interests"] = old_profile.get("interests")   # 관심사 보존(흐름 A: 관심사 → 온보딩)
+        store.save_session(session, profile["participant"], bool(consent),
+                           (profile["baseline"]["VAL"], profile["baseline"]["REI"]), onboard_rows)
+        # 애매한 온보딩 항목 감지 → 명료화 큐
+        profile["clarify_queue"] = detect_ambiguity(onboard_rows, profile["baseline"]["VAL"], profile["baseline"]["REI"])
+        profile["phase"] = "open"
+        # 앱이 먼저 대화를 연다 — 템플릿(LLM 호출 없음, 무료 한도 절약)
+        it = profile.get("interests")
+        if it and it.get("domains"):
+            op_text = (f"안녕! 🙂 아까 '{_txt(it['domains'][0]['item'])}' 얘기 했었죠. "
+                       "거기서부터 가볍게 시작해도 좋고, 아래 버튼에서 골라도 돼요. 요즘 어때요?")
+        else:
+            op_text = ("안녕! 🙂 편하게 수다 떨어요. 무슨 얘기부터 할지 고민되면 "
+                       "아래 버튼에서 하나 골라봐요 — 아니면 그냥 떠오르는 대로 적어도 좋아요.")
+        opening_chat = [{"role": "assistant", "content": op_text}]
+        return (profile, render_profile(profile), gr.update(value=opening_chat, visible=True),
+                gr.update(visible=True), gr.update(visible=True), store.summary_md())
+
+    END_SUGGEST_TURN = 12
+    EXPLORE_TURN = 8
+
+    def do_chat(msg, chat, profile, session, consent):
+        if not msg or not msg.strip():
+            return chat, profile, render_profile(profile), "", label_update(None, False), "", store.summary_md(), gr.update(visible=False)
+        # 동의 안내: 미동의 상태면 측정·자기보고가 저장되지 않음을 채팅 아래에 명확히 안내
+        consent_note = ("" if bool(consent) else
+                        "⚠️ 현재 **익명 저장 동의가 해제**되어 있어요. 대화는 그대로 되지만 "
+                        "측정 결과가 **저장되지 않습니다**. 연구에 도움을 주시려면 위 '연구 참여 안내·동의'의 "
+                        "체크박스를 켜 주세요. (대화 원문은 어떤 경우에도 저장되지 않습니다.)")
+        if profile.get("ended"):
+            return (chat, profile, render_profile(profile), "", label_update(None, False),
+                    "대화를 이미 마쳤어요. 더 하려면 페이지를 새로고침해 주세요.", store.summary_md(), gr.update(visible=False))
+        if profile["baseline"]["VAL"] is None:
+            chat = chat + [{"role": "assistant", "content": "먼저 위 질문 몇 개만 완료해 주세요 🙂"}]
+            return chat, profile, render_profile(profile), "", label_update(None, False), consent_note, store.summary_md(), gr.update(visible=False)
+        m = engine.measure(msg)
+        profile = update_cumulative(profile, m, len(msg))
+        profile["last_utt"] = msg
+        profile["pending_reveal"] = None  # 새 메시지 → 직전 재질문 상태 정리
+        profile["label_axis"] = pick_axis(profile["n"])
+        # --- 대화 단계 전환 (응답 생성 전) ---
+        phase = profile.get("phase", "build")
+        if phase == "open":
+            # 오프닝에 대한 첫 답변을 받음 → 명료화 필요하면 clarify, 아니면 build
+            if profile.get("clarify_queue"):
+                profile["phase"] = "clarify"; profile["clarify_asked"] = False
+            else:
+                profile["phase"] = "build"
+        elif phase == "clarify":
+            if profile.get("clarify_asked") and profile.get("clarify_queue"):
+                profile["clarify_queue"].pop(0)          # 직전에 물어본 구성에 답함 → 제거
+            if profile.get("clarify_queue"):
+                profile["clarify_asked"] = True          # 이번 턴에 queue[0]��� 확인
+            else:
+                profile["phase"] = "build"; profile["clarify_asked"] = False
+        elif phase == "build":
+            if profile["n"] >= EXPLORE_TURN and not profile.get("explore_offered"):
+                profile["phase"] = "explore"; profile["explore_offered"] = True
+        elif phase == "explore":
+            profile["phase"] = "build"   # explore는 '한 번'만 — 다음 턴부터 일반 대화로 복귀(캐묻기 방지)
+        reply, rmodel, rdepth, rusage = generate_response(profile, chat, msg)
+        store.add_response(session, profile.get("participant"), profile["n"],
+                           rmodel, rdepth, len(msg), bool(consent), rusage)
+        if profile["n"] >= END_SUGGEST_TURN and not profile["end_suggested"]:
+            profile["end_suggested"] = True
+            reply = reply + "\n\n(오늘 충분히 이야기 나눴어요 🙂 더 하셔도 좋고, 마치려면 아래 '✋ 이제 그만할래'를 눌러주세요.)"
+        chat = chat + [{"role": "user", "content": msg}, {"role": "assistant", "content": reply}]
+        return chat, profile, render_profile(profile), "", label_update(profile["label_axis"], True), consent_note, store.summary_md(), gr.update(visible=False)
+
+    def do_end(chat, profile):
+        profile["ended"] = True
+        profile["pending_reveal"] = None
+        chat = chat + [{"role": "assistant",
+                        "content": "오늘 대화는 여기까지 할게요. 솔직하게 이야기 나눠줘서 고마워요 🙂 "
+                                   "측정 개선에 큰 도움이 됩니다. 더 하고 싶으면 페이지를 새로고침해 주세요."}]
+        return (chat, gr.update(visible=False), gr.update(visible=False), gr.update(visible=False),
+                gr.update(value=None, visible=False), "대화를 마쳤어요. 고마워요 🙂", store.summary_md(),
+                gr.update(value=None, visible=False))
+
+    def check_save_status(profile, consent, session):
+        n = profile.get("n", 0) if profile else 0
+        if not bool(consent):
+            return ("⚠️ **저장 꺼짐** — 현재 익명 저장 동의가 해제되어 있어, 지금까지의 측정이 "
+                    "저장되지 **않습니다**. 위쪽 '연구 참여 안내·동의'의 체크박스를 켜시면, "
+                    "이후 대화부터 측정 좌표·자기보고가 익명으로 저장됩니다. "
+                    "(대화 원문은 어떤 경우에도 저장되지 않아요.)")
+        pcode = (profile.get("participant") or "").strip() if profile else ""
+        pcode_txt = f"참가자 코드 **{pcode}**로 " if pcode else "익명으로 "
+        return (f"✅ **저장 켜짐** — {pcode_txt}측정 좌표와 자기보고가 익명으로 저장되고 있어요. "
+                f"지금까지 대화 {n}턴. 솔직하게 이야기해 주셔서 측정 개선에 큰 도움이 됩니다. "
+                f"(대화 원문은 저장되지 않고, 길이 등 숫자만 남습니다.)")
+
+    def do_label(choice, profile, consent, session):
+        if not choice or profile.get("last") is None or profile.get("label_axis") is None:
+            return "", store.summary_md(), gr.update(), gr.update(visible=False), profile
+        axis = profile["label_axis"]
+        value = dict(LABEL_SCHEMES[axis]["opts"])[choice]
+        coord = profile["last"][axis]
+        # 누적 좌표: VAL/REI는 세션 전체 누적, EVA/EAR(상태축)는 턴별값 그대로
+        cum = profile["cum"]
+        coords_cum = {"VAL": cum["VAL"], "REI": cum["REI"],
+                      "EVA": profile["last"]["EVA"], "EAR": profile["last"]["EAR"]}
+        # 1) 편향없는 자기보고를 '먼저' 저장 (1차 검증 신호 — 측정 공개 전, 불변)
+        store.add_label(session, profile.get("participant"), profile["n"],
+                        profile.get("last_utt", ""), profile["last"], coords_cum, axis, choice, value, bool(consent))
+        # 2) (ii) 측정 공개 + "맞나요?" 재질문 — 매 턴이 아니라 3턴마다만(피로 감소). 그 외 턴은 공개 없이 가볍게.
+        if profile["n"] % 3 != 0:
+            return ("기록했어요. 고마워요 🙂", store.summary_md(),
+                    gr.update(value=None, visible=False), gr.update(visible=False), profile)
+        sch = LABEL_SCHEMES[axis]
+        measured_sign = 1 if coord >= 0 else -1
+        measured_label = sch["poles"][0] if coord >= 0 else sch["poles"][1]
+        profile["pending_reveal"] = {"axis": axis, "turn": int(profile["n"]),
+                                     "measured_sign": measured_sign, "measured_label": measured_label,
+                                     "self_value": int(value)}
+        note = ("기록했어요, 고마워요 🙂 하나만 더 — 제가 방금 " + sch["reveal_lead"].format(measured_label)
+                + " 느꼈는데, 실제로도 그랬어요? 맞아도 틀려도 다 도움이 되니 편하게 알려줘요.")
+        fit_choices = ["응, 맞아요", "잘 모르겠어요", "아니, 달라요"]
+        return (note, store.summary_md(), gr.update(value=None, visible=False),
+                gr.update(choices=fit_choices, value=None, visible=True, label="제 느낌이 맞았나요?"), profile)
+
+    def do_fit(choice, profile, consent, session):
+        pr = profile.get("pending_reveal")
+        if not choice or not pr:
+            return "", gr.update(visible=False), profile
+        fit_value = {"응, 맞아요": 1, "잘 모르겠어요": 0, "아니, 달라요": -1}.get(choice, 0)
+        store.add_reveal(session, profile.get("participant"), pr["turn"], pr["axis"],
+                         pr["measured_sign"], pr["measured_label"], pr["self_value"], fit_value, bool(consent))
+        profile["pending_reveal"] = None
+        if fit_value == 1:
+            note = "오, 맞았네요! 알려줘서 고마워요 🙂"
+        elif fit_value == -1:
+            note = "알려줘서 정말 고마워요 — ‘틀렸다’는 이 한 번이 측정을 더 정확하게 만들어요 🙏"
+        else:
+            note = "괜찮아요, 그것도 좋은 답이에요. 고마워요 🙂"
+        return note, gr.update(value=None, visible=False), profile
+
+    def on_domain(d1):
+        # 빈 상태가 아니라 공통 항목으로 시작 → 첫 선택부터 즉시 렌더(6.0 한 박자 지연 방지).
+        print(f"[on_domain] 호출됨 · d1={d1!r} · tag={_DOMAIN_TAG.get(d1)!r}", flush=True)
+        tag = _DOMAIN_TAG.get(d1)
+        h = happy_choices(tag) if tag else [l for l, _ in COMMON_HAPPY]
+        b = barrier_choices(tag) if tag else [l for l, _ in COMMON_BARRIER]
+        print(f"[on_domain] happy {len(h)}개 · barrier {len(b)}개 반환", flush=True)
+        return (gr.CheckboxGroup(choices=h, value=[], label="요즘 나를 행복하게 하는 것 (최대 3개 · 1순위 선택 시 더 추가됨)"),
+                gr.CheckboxGroup(choices=b, value=[], label="행복을 방해하는 것 (최대 3개)"))
+
+    def save_interests(d1, d2, happy_sel, barrier_sel, consent, session, profile):
+        if not d1:
+            return "1순위(가장 중요한 것)를 먼저 선택해 주세요.", profile
+        if len(happy_sel) > 3 or len(barrier_sel) > 3:
+            return "행복·방해 요인은 각각 최대 3개까지만 골라주세요.", profile
+        doms = [d1] + ([d2] if (d2 and d2 != "— 없음 —" and d2 != d1) else [])
+        domains = [{"item": d, "tag": _DOMAIN_TAG.get(d, ""), "rank": i + 1} for i, d in enumerate(doms)]
+        happy = [{"item": h, "tag": _HAPPY_TAG.get(h, ""), "common": h in _COMMON_HAPPY_SET} for h in happy_sel]
+        barriers = [{"item": b, "tag": _BARRIER_TAG.get(b, ""), "common": b in _COMMON_BARRIER_SET} for b in barrier_sel]
+        profile["interests"] = {"domains": domains, "happy": happy, "barriers": barriers}
+        store.save_interests(session, profile.get("participant"), domains, happy, barriers, bool(consent))
+        return "관심사를 반영했어요. 이제 편하게 대화를 시작해 보세요.", profile
+
+    def pilot_unlock(pw):
+        if (pw or "").strip() == PILOT_PASSWORD:
+            return (True, "✓ 연구 파일럿 입장됨. 대화에서 메시지를 보낸 뒤, 아래에서 그 발화의 네 축을 평가해 저장하세요.",
+                    gr.update(visible=True))
+        return (False, "✗ 비밀번호가 올바르지 않습니다.", gr.update(visible=False))
+
+    def pilot_save_fn(v_eva, v_ear, v_rei, v_val, v_act, profile, session, consent, unlocked):
+        blank = (gr.update(), gr.update(), gr.update(), gr.update(), gr.update())
+        if not unlocked:
+            return ("먼저 비밀번호로 입장해 주세요.", *blank)
+        if not consent:
+            return ("저장하려면 상단의 동의에 체크해 주세요 (발화 원문은 저장되지 않습니다).", *blank)
+        if profile.get("last_utt") is None or profile.get("last") is None:
+            return ("먼저 대화에서 메시지를 한 번 보내 주세요 — 직전에 보낸 발화를 평가합니다.", *blank)
+        vals = {"EVA": v_eva, "EAR": v_ear, "REI": v_rei, "VAL": v_val}
+        if any(vals[a] is None for a in vals):
+            return ("네 축(기분·에너지·사고방식·자율성)을 모두 평가해 주세요. (활성도는 선택)", *blank)
+        try:
+            self_labels = {a: _PILOT_MAP[a][vals[a]] for a in vals}
+            act_self = _PILOT_MAP["ACT"][v_act] if v_act is not None else None  # ACT는 선택(실험 항목)
+        except KeyError:
+            return ("선택지를 다시 골라 주세요.", *blank)
+        llm = _gemini_score_4axis(profile["last_utt"])   # 발화 텍스트는 메모리에서만 사용, 저장 안 함
+        ko = profile["last"]
+        cum = profile.get("cum", {})
+        ko_cum = {"VAL": cum.get("VAL"), "REI": cum.get("REI"),
+                  "EVA": profile["last"]["EVA"], "EAR": profile["last"]["EAR"]}
+        store.add_pilot_label(session, profile.get("participant"), profile.get("n", 0),
+                              len(profile["last_utt"]), ko, ko_cum, llm, self_labels, bool(consent), act_self)
+        note = "측정·자기라벨·LLM 채점 저장" if llm else "측정·자기라벨 저장 (LLM 채점 실패)"
+        if act_self is not None:
+            note += " (+활성도)"
+        total = getattr(store, "pilot_saved", 0)
+        return (f"✓ 저장됐어요 — {note}. (누적 {total}건) 다음 발화를 보낸 뒤 또 평가할 수 있어요.",
+                gr.update(value=None), gr.update(value=None), gr.update(value=None), gr.update(value=None), gr.update(value=None))
+
+    SELFREPORT_CSS = """
+    #selfreport_box {background:#FFF7E6; border:1px solid #E6C674; border-radius:12px;
+      padding:10px 12px; margin:8px 0 6px 0; box-shadow:0 2px 10px rgba(180,140,40,0.12);}
+    #selfreport_box span, #selfreport_box label {font-weight:600 !important;}
+    #fit_box {background:#E7F4F4; border:1px solid #7FBFC4; border-radius:12px;
+      padding:10px 12px; margin:2px 0 6px 0; box-shadow:0 2px 10px rgba(14,124,134,0.12);}
+    #fit_box span, #fit_box label {font-weight:600 !important;}
+    #selfreport_box, #fit_box {position:sticky; bottom:8px; z-index:30;}
+    """
+    with gr.Blocks(title="자기인식 지원 (0322 데이터 수집판)", css=SELFREPORT_CSS) as app:
+        gr.Markdown("## 자기인식 지원 대화 — 데이터 수집판")
+        session_state = gr.State("")
+        prof_state = gr.State(new_profile())
+
+        with gr.Accordion("연구 참여 안내 · 동의 (먼저 읽어주세요)", open=True):
+            gr.Markdown(
+                "이 앱은 **측정 도구 개선을 위한 실험**입니다. 대화하면 가치·인지·감정이 자동 측정되고, 가끔 자기보고를 여쭤봅니다. "
+                "동의하시면 **측정 좌표(숫자)와 자기보고 라벨만 익명으로 저장**되고, **대화 원문은 저장하지 않습니다**(길이만 숫자로 남음). "
+                "응답 생성을 위해 입력은 Google Gemini API로 전송됩니다(저장 안 함). "
+                "**아래 체크는 기본으로 켜져 있습니다 — 익명 저장에 참여하시려면 그대로 두시고, 원치 않으면 해제하세요.** 언제든 중단할 수 있습니다.")
+            consent = gr.Checkbox(value=True, label="✅ 익명 저장(측정 좌표·자기보고 라벨만, 발화 원문 제외)에 동의합니다. — 연구에 큰 도움이 됩니다")
+            participant = gr.Textbox(label="참가자 코드 (선택 · 별명 권장 — 예: 라일락-01. 다시 올 땐 같은 코드를 쓰면 변화를 볼 수 있어요)", lines=1)
+
+        with gr.Accordion("1단계 · 관심사 (먼저 알려주세요 · 건너뛰어도 됩니다)", open=True):
+            gr.Markdown("대화를 당신 맥락에 맞추기 위한 선택입니다. 건너뛰어도 됩니다.")
+            with gr.Row():
+                d1 = gr.Dropdown(choices=[l for l, _ in VALUE_DOMAINS], label="1순위 — 요즘 가장 중요한 것")
+                d2 = gr.Dropdown(choices=["— 없음 —"] + [l for l, _ in VALUE_DOMAINS], value="— 없음 —",
+                                 label="2순위 (선택)")
+            happy_cg = gr.CheckboxGroup(choices=[l for l, _ in COMMON_HAPPY], label="요즘 나를 행복하게 하는 것 (최대 3개 · 1순위 선택 시 더 추가됨)")
+            barrier_cg = gr.CheckboxGroup(choices=[l for l, _ in COMMON_BARRIER], label="행복을 방해하는 것 (최대 3개)")
+            interests_btn = gr.Button("관심사 반영")
+            interests_status = gr.Markdown("")
+
+        with gr.Accordion("2단계 · 짧은 질문 (가치·인지)", open=True):
+            gr.Markdown("가까운 보기를 고르거나 아래 칸에 직접 한 문장 적어 주세요. 완료하면 대화가 시작됩니다.")
+            onboard_inputs = []
+            for item in ONBOARD:
+                gr.Markdown(f"**{item['q']}**")
+                r = gr.Radio(choices=[c[0] for c in item["choices"]], label="선택지")
+                t = gr.Textbox(label="또는 직접 적어주세요 (한 문장 이상, 선택)", lines=2,
+                               placeholder="예: 나는 보통 ~한 편이에요. 왜냐하면 ~")
+                onboard_inputs += [r, t]
+            onboard_btn = gr.Button("대화 시작하기", variant="primary")
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                _cb_kwargs = dict(label="대화", height=360, visible=False)
+                try:
+                    if int(gr.__version__.split(".")[0]) < 6:
+                        _cb_kwargs["type"] = "messages"  # 4.x/5.x: 메시지 딕셔너리 쓰려면 필요. 6.0: 인자 자체가 없음(기본 messages)
+                except Exception:
+                    pass
+                chatbot = gr.Chatbot(**_cb_kwargs)
+                # 주제 선택 칩 — 시작 시 표시(주제 고민 줄이기), 첫 메시지 후 숨김
+                with gr.Row(visible=False) as topic_row:
+                    tb1 = gr.Button("오늘 있었던 일", size="sm")
+                    tb2 = gr.Button("요즘 신경 쓰이는 거", size="sm")
+                    tb3 = gr.Button("그냥 사는 얘기", size="sm")
+                    tb4 = gr.Button("관계 얘기", size="sm")
+                # 자기보고(라벨) — 입력창 '바로 위'에 강조 박스로 표시 (스크롤 없이 즉시 눈에 띄도록)
+                label_radio = gr.Radio(choices=[], label="자기보고", visible=False, elem_id="selfreport_box")
+                fit_radio = gr.Radio(choices=[], label="시스템 측정이 맞나요?", visible=False, elem_id="fit_box")
+                label_status = gr.Markdown("")
+                with gr.Row():
+                    msg = gr.Textbox(show_label=False, placeholder="메시지 입력", scale=8)
+                    send_btn = gr.Button("입력", variant="primary", scale=1, min_width=64)
+                with gr.Row():
+                    save_check_btn = gr.Button("💾 내 데이터 저장 상태 확인", size="sm", scale=1)
+                save_check_status = gr.Markdown("")
+                with gr.Row(visible=False) as helper_row:
+                    qb_other = gr.Button("🔄 다른 얘기", size="sm")
+                    end_btn = gr.Button("✋ 이제 그만할래", size="sm", variant="secondary")
+            with gr.Column(scale=2):
+                profile_md = gr.HTML("<div style='color:#999;padding:6px;font-family:system-ui;'>대화를 시작하면 여기에 측정 나침반이 보여요.</div>")
+                stats_md = gr.Markdown(store.summary_md())
+
+        with gr.Accordion("도움이 필요하면 — 상담 연락처", open=False):
+            gr.Markdown("이 앱은 자기이해를 돕는 실험 도구이며 상담·치료가 아닙니다. "
+                        "힘들거나 위기라고 느껴지면 연락하세요 — **자살예방 109**(24시간) · **정신건강 1577-0199** · 긴급 **119·112**.")
+
+        with gr.Accordion("🔬 연구 파일럿 (비밀번호 필요)", open=False):
+            gr.Markdown(
+                "연구 참가자 전용입니다. 입장하면 **방금 보낸 발화**에 대해 네 축(기분·에너지·사고방식·자율성)을 "
+                "직접 5단계로 평가해 저장합니다. 측정값(KoSimCSE)·자기 라벨·LLM(Gemini) 채점이 함께 기록되며, "
+                "**발화 원문은 저장되지 않습니다**(길이만). 저장은 상단 동의 체크가 있어야 합니다.")
+            pilot_state = gr.State(False)
+            with gr.Row():
+                pilot_pw = gr.Textbox(label="비밀번호", type="password", scale=3)
+                pilot_enter = gr.Button("입장", scale=1, min_width=80)
+            pilot_status = gr.Markdown("")
+            with gr.Group(visible=False) as pilot_panel:
+                gr.Markdown("**직전에 보낸 발화**를 떠올리며, 그때의 상태를 골라 주세요.")
+                sr_eva = gr.Radio(choices=PILOT_AXES["EVA"][1], label="기분 — 그 말을 할 때 내 기분은? (감정의 좋고/나쁨)")
+                sr_ear = gr.Radio(choices=PILOT_AXES["EAR"][1], label="에너지 — 그때 내 에너지·긴장 수준은? (기분 좋고나쁨과 무관, 에너지만)")
+                sr_rei = gr.Radio(choices=PILOT_AXES["REI"][1], label="사고방식 — 그 결정/생각은 무엇으로? (직감 ↔ 근거)")
+                sr_val = gr.Radio(choices=PILOT_AXES["VAL"][1], label="자율성 — 그건 누구의 기준으로? (주변 ↔ 나)")
+                sr_act = gr.Radio(choices=PILOT_ACT[1], label="🧪 신체 활성도 (선택·실험) — 그때 몸이 얼마나 격렬했나/소진됐나? (에너지 높낮이와 별개: 차분한 평온 ↔ 격렬·탈진)")
+                pilot_save = gr.Button("이번 발화 자기라벨 저장", variant="primary")
+                pilot_save_status = gr.Markdown("")
+
+        chat_outputs = [chatbot, prof_state, profile_md, msg, label_radio, label_status, stats_md, fit_radio]
+        def _hide_topics(): return gr.update(visible=False)
+        onboard_btn.click(do_onboard, onboard_inputs + [consent, participant, session_state, prof_state],
+                          [prof_state, profile_md, chatbot, topic_row, helper_row, stats_md])
+        msg.submit(do_chat, [msg, chatbot, prof_state, session_state, consent], chat_outputs).then(_hide_topics, None, topic_row)
+        send_btn.click(do_chat, [msg, chatbot, prof_state, session_state, consent], chat_outputs).then(_hide_topics, None, topic_row)
+        save_check_btn.click(check_save_status, [prof_state, consent, session_state], save_check_status)
+
+        def quick_send(text):
+            def _fn(chat, profile, session, consent):
+                return do_chat(text, chat, profile, session, consent)
+            return _fn
+        # 주제 칩 → 그 주제로 가볍게 대화 시작 (클릭 후 칩 숨김)
+        ti = [chatbot, prof_state, session_state, consent]
+        tb1.click(quick_send("오늘 있었던 일 얘기해볼까"), ti, chat_outputs).then(_hide_topics, None, topic_row)
+        tb2.click(quick_send("요즘 좀 신경 쓰이는 일이 있어"), ti, chat_outputs).then(_hide_topics, None, topic_row)
+        tb3.click(quick_send("그냥 사는 얘기나 해볼까"), ti, chat_outputs).then(_hide_topics, None, topic_row)
+        tb4.click(quick_send("사람들이랑 지내는 얘기 좀 해볼까"), ti, chat_outputs).then(_hide_topics, None, topic_row)
+        qb_other.click(quick_send("다른 얘기 하자"), ti, chat_outputs).then(_hide_topics, None, topic_row)
+        end_btn.click(do_end, [chatbot, prof_state],
+                      [chatbot, msg, topic_row, helper_row, label_radio, label_status, stats_md, fit_radio])
+
+        label_radio.input(do_label, [label_radio, prof_state, consent, session_state],
+                          [label_status, stats_md, label_radio, fit_radio, prof_state])
+        fit_radio.input(do_fit, [fit_radio, prof_state, consent, session_state],
+                        [label_status, fit_radio, prof_state])
+        d1.change(on_domain, [d1], [happy_cg, barrier_cg])
+        interests_btn.click(save_interests, [d1, d2, happy_cg, barrier_cg, consent, session_state, prof_state],
+                            [interests_status, prof_state])
+
+        pilot_enter.click(pilot_unlock, [pilot_pw], [pilot_state, pilot_status, pilot_panel])
+        pilot_save.click(pilot_save_fn,
+                         [sr_eva, sr_ear, sr_rei, sr_val, sr_act, prof_state, session_state, consent, pilot_state],
+                         [pilot_save_status, sr_eva, sr_ear, sr_rei, sr_val, sr_act])
+
+        # 각 사용자 접속(페이지 로드)마다 고유 세션 ID 생성 — 사용자 간 세션 분리
+        app.load(lambda: str(uuid.uuid4())[:8], outputs=[session_state])
+    return app
+
+
+def render_profile(profile):
+    last = profile.get("last")
+    cum = profile.get("cum", {})
+    sm = profile.get("smooth", {})
+    if not last:
+        return "<div style='color:#999;padding:6px;font-family:system-ui;'>대화를 시작하면 여기에 측정 나침반이 보여요.</div>"
+
+    def axis_bar(x, name, neg_pole, pos_pole, trusted):
+        x = 0.0 if x is None else x
+        c = max(-2.5, min(2.5, x))
+        width = abs(c) / 2.5 * 50.0            # 트랙의 절반(50%)이 한쪽 최대
+        color = "#3b82f6" if trusted else "#94a3b8"
+        opacity = "1" if trusted else "0.5"
+        fill = (f"left:50%;width:{width:.0f}%;" if c >= 0 else f"right:50%;width:{width:.0f}%;")
+        tag = "" if trusted else " <span style='font-size:10px;color:#aaa;'>(방향 위주)</span>"
+        return (
+            "<div style='margin:7px 0;'>"
+            "<div style='display:flex;justify-content:space-between;font-size:12px;color:#777;'>"
+            f"<span>{neg_pole}</span><span style='font-weight:600;color:#333;'>{name}{tag}</span><span>{pos_pole}</span></div>"
+            "<div style='position:relative;height:10px;background:#eee;border-radius:5px;margin-top:3px;'>"
+            "<div style='position:absolute;left:50%;top:0;bottom:0;width:1px;background:#bbb;'></div>"
+            f"<div style='position:absolute;top:0;bottom:0;{fill}background:{color};border-radius:5px;opacity:{opacity};'></div>"
+            "</div></div>"
+        )
+
+    bars = (axis_bar(sm.get("EVA"), "기분", "슬픔", "즐거움", True)
+            + axis_bar(sm.get("EAR"), "에너지", "차분", "들뜸", False)
+            + axis_bar(cum.get("VAL"), "자율성", "맞춤", "내 뜻", False))
+    tr = emotion_trend(profile)
+    trend = " · ↗ 긍정 흐름" if tr > 0.1 else (" · ↘ 가라앉는 흐름" if tr < -0.1 else " · → 안정")
+    return (
+        "<div style='font-family:system-ui;max-width:430px;'>"
+        "<div style='font-weight:600;margin-bottom:6px;color:#444;'>🧭 측정 나침반 (실시간)</div>"
+        f"{bars}"
+        f"<div style='font-size:11px;color:#aaa;margin-top:6px;'>측정값일 뿐 진단이 아니에요{trend}</div>"
+        "</div>"
+    )
+
+
+if __name__ == "__main__":
+    build_app().launch()