멀티턴 대화 구현 완료

npc_social_network/README.txt

@@ -39,13 +39,16 @@ portfolio/
     ├── README.txt
     │
     ├── data/
-    │   └── saves/
-    │       └── simulation_state.pkl  # NPC 월드의 상태가 저장되는 파일
+    │   ├── saves/
+    │   │   └── simulation_state.pkl  # NPC 월드의 상태가 저장되는 파일
+    │   └── vectorstores/
+    │       └── 영문 캐릭터명           # 각각의 캐릭터에 대한 정보가 저장되는 파일
     │
     ├── routes/
     │   └── npc_route.py              # ✅ '월드 관찰자' 대시보드의 모든 웹 API 정의
     │
     ├── manager/
+    │   ├── conversation_manager.py     # 대화의 시작, 진행, 종료를 총괄하는 역할
     │   └── simulation_manager.py       # 시뮬레이션 상태를 저장/로드하는 기능
     │
     ├── scenarios/
@@ -60,12 +63,12 @@ portfolio/
     │   ├── npc_relationship.py       # 관계 점수 관리
     │   ├── npc_memory_embedder.py    # 기억 임베딩 + FAISS 검색
     │   ├── emotion_config.py         # 감정 구조 정의
-    │   └── personality_config.py     # 성격 및 나이 프로필
+    │   ├── personality_config.py     # 성격 및 나이 프로필
+    │   └── npc_planner.py            # 목표와 관련된 구조
     │
     ├── models/                       # LLM 및 임베딩 모델 관련
-    │   │   ├── gemini_setup.py       # Gemini API 설정
-    │   ├── llm_helper.py             # 감정 추론, 응답 생성
-    │   └── llm_prompt_builder.py     # 프롬프트 생성
+    │   ├── gemini_setup.py           # Gemini API 설정
+    │   └── llm_helper.py             # 감정 추론, 응답 생성
     │
     ├── templates/
     │   └── dashboard.html            # '월드 관찰자' 대시보드 HTML/CSS/JS

npc_social_network/manager/conversation_manager.py

@@ -1,7 +1,8 @@
 # portfolio/npc_social_network/manager/conversation_manager.py
 # 대화의 시작, 진행, 종료를 총괄하는 역할
-from .. import simulation_core
-from ..models.llm_helper import summarize_memories, summarize_text
+from ..models.llm_helper import summarize_memories, summarize_text, query_llm_for_emotion
+from ..npc.npc_manager import get_korean_postposition
+from ..npc.emotion_config import EMOTION_RELATION_IMPACT
 import threading
 from typing import List, Optional, TYPE_CHECKING
 if TYPE_CHECKING:
@@ -35,6 +36,7 @@ class ConversationManager:
     
     def _add_and_log_utterance(self,speaker: "NPC", utterance: str):
         """대사를 대화 기록과 UI 로그에 모두 추가"""
+        from .. import simulation_core
         if not self.is_conversation_active():
             return        
         log_message = f"[{speaker.korean_name}]: {utterance}"
@@ -42,7 +44,8 @@ class ConversationManager:
         simulation_core.add_log(log_message)
 
     def _summarize_and_remember_in_background(self, conv: "Conversation"):
-        """백그라운드 스레드 대화를 요약하고 기억시키는 함수"""
+        """백그라운드 스레드 대화를 요약하고 기억하며, 관계와 성격에 반영하는 함수"""
+        from .. import simulation_core
         try:
             if not conv.conversation_history:
                 print("기억할 대화 내용이 없어 종료.")
@@ -50,12 +53,30 @@ class ConversationManager:
             initiator, target = conv.participants[0], conv.participants[1]
             full_conversation = "\n".join(conv.conversation_history)
 
+            # 1. 대화 내용 요약
             summary = summarize_text(full_conversation)
+
+            # 2. 대화의 전반적인 감정 톤 분석
+            overall_emotion = query_llm_for_emotion(summary)
+
             with simulation_core.simulation_lock:
+                target_postposition = get_korean_postposition(target.korean_name, "과", "와")
+                # 3. 요약된 내용을 바탕으로 기억 생성
                 memory_content = f"'{conv.topic}'에 대해 대화하며 '{summary}'라는 결론을 내렸다."
-                initiator.remember(content=f"{target.korean_name}와(과) {memory_content}", importance=7, memory_type="Conversation")
-                target.remember(content=f"{initiator.korean_name}와(과) {memory_content}", importance=7, memory_type="Conversation")
-                print(f"[{initiator.korean_name}, {target.korean_name}] 대화 내용이 기억에 저장되었습니다.")
+                initiator.remember(content=f"{target.korean_name}{target_postposition} {memory_content}", importance=7, memory_type="Conversation")
+                target.remember(content=f"{initiator.korean_name}{target_postposition} {memory_content}", importance=7, memory_type="Conversation")
+        
+                # 4. 대화의 감정을 바탕으로 관계 상태 업데이트
+                if overall_emotion and overall_emotion in EMOTION_RELATION_IMPACT:
+                    initiator.relationships.update_relationship(target.name, overall_emotion, strength=3.0)
+                    target.relationships.update_relationship(initiator.name, overall_emotion, strength=3.0)
+
+                # 5. 관계 변화를 바탕으로 양쪽 모두의 성격 업데이트
+                initiator.update_personality()
+                target.update_personality()
+
+                simulation_core.add_log(f"[{initiator.korean_name}, {target.korean_name}] 대화 경험이 기억과 관계, 성격에 반영되었습니다.")
+
         except Exception as e:
             print(f"[에러] 백그라운드 기억 저장 중 문제 발생: {e}")
             import traceback
@@ -64,19 +85,21 @@ class ConversationManager:
     def start_conversation(self, initiator: "NPC", target: "NPC",
                            topic: Optional[str] = None):
         """새로운 대화를 시작, 바로 다음 턴을 호출"""
+        from .. import simulation_core
         if self.is_conversation_active():
             return # 이미 다른 대화가 진행중이면 시작 x
         
         conv_topic = topic or "가벼운 인사"
         self.active_conversation = Conversation(initiator, target, conv_topic)
-        print(f"--[대화 시작]--")
-        print(f"주제: {conv_topic} / 참여자: {initiator.korean_name}, {target.korean_name}")
+        simulation_core.add_log(f"--[대화 시작]--")
+        simulation_core.add_log(f"주제: {conv_topic} / 참여자: {initiator.korean_name}, {target.korean_name}")
         
         # 1. 첫 마디 생성
         self.next_turn()
 
     def end_conversation(self, reason: str = "자연스럽게"):
         """현재 대화를 종료하고, 대화 내용을 요약하여 기억으로 저장"""
+        from .. import simulation_core
         if not self.is_conversation_active():
             return
         
@@ -85,7 +108,7 @@ class ConversationManager:
 
         # 1. 대화 상태를 즉시 '종료'로 변경하여 메인 루프를 해방
         self.active_conversation = None
-        print(f"---[대화 종료: {reason}]---\n")
+        simulation_core.add_log(f"---[대화 종료: {reason}]---\n")
 
         # 2. 시간이 걸리는 '기억 저장' 작업은 별도의 스레드를 생성하여 백그라운드에서 처리.
         background_thread = threading.Thread(

npc_social_network/models/llm_helper.py

@@ -6,10 +6,11 @@ from npc_social_network.npc.npc_memory import Memory
 from typing import List
 import json
 import re
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
 if TYPE_CHECKING:
     from ..npc.npc_base import NPC
+    from ..manager.conversation_manager import Conversation
 
 # Gemini 모델 초기화
 gemini_model = load_gemini()
@@ -117,7 +118,7 @@ def classify_and_extract_plan_details(plan_step: str) -> dict:
 # Instruction
 Analyze the following action plan. Classify its type and extract the target NPC and topic if applicable.
 Your response MUST be in JSON format.
-Action Types can be "TALK" (for conversing with others) or "SOLO_ACTION" (for acting alone).
+Action Types can be "TALK" (for conversing with others), "HELP" (for helping someone), or "SOLO_ACTION" (for acting alone).
 
 # Action Plan
 "{plan_step}"
@@ -202,6 +203,23 @@ def generate_dialogue_action(speaker: "NPC", target: "NPC", conversation: "Conve
     history_str = "\n".join(conversation.conversation_history)
     memory_str = "\n".join([f"- {m.content}" for m in memories]) if memories else "관련된 특별한 기억 없음"
 
+    # 평판 정보 생성
+    reputation_info = ""
+    reputation_score = speaker.reputation.get(target.name, 0)
+    if reputation_score > 5:
+        reputation_info = f"- '{target.korean_name}'에 대한 나의 평판: 신뢰할 만한 사람 같다. (점수: {reputation_score})"
+    elif reputation_score < -5:
+        reputation_info = f"- '{target.korean_name}'에 대한 나의 평판: 좋지 않은 소문을 들었다. (점수: {reputation_score})"
+
+    # 상징 기억 조회
+    symbolic_memories = [mem for mem in speaker.memory_store.get_all_memories() if mem.memory_type == "Symbolic"]
+    symbolic_section = ""
+    if symbolic_memories:
+        symbolic_section_title = "# Core Symbolic Values (Symbolic Memory)"
+        symbolic_contents = "\n".join([f"- {mem.content}" for mem in symbolic_memories])
+        # 프롬프트에 예쁘게 들어갈 수 있도록 앞뒤로 줄바꿈 추가
+        symbolic_section = f"\n{symbolic_section_title}\n{symbolic_contents}"
+
     if is_final_turn:
         task_instruction = """
 - 상대방이 대화를 마무리하려고 합니다. 상대방의 마지막 말에 어울리는 자연스러운 작별 인사를 생성하세요. (예: "네, 조심히 가세요.", "다음에 또 봬요.", "알겠습니다. 좋은 하루 보내세요.")
@@ -225,6 +243,11 @@ def generate_dialogue_action(speaker: "NPC", target: "NPC", conversation: "Conve
 - 당신의 성격: {speaker.personality.get_personality_summary()}
 - "{target.korean_name}"와의 관계: {speaker.relationships.get_relationship_summary(target.name)}
 
+# Reputation Information
+{reputation_info}
+
+{symbolic_section}
+
 # Relevant Memories
 {memory_str}
 
@@ -270,4 +293,39 @@ def generate_dialogue_action(speaker: "NPC", target: "NPC", conversation: "Conve
         result["dialogue"] = dialogue
         return result
     
-    return {"dialogue": "...", "action": "END"} # 최종 실패 시 안전하게 대화 종료
+    return {"dialogue": "...", "action": "END"} # 최종 실패 시 안전하게 대화 종료
+
+def evaluate_social_action_outcome(initiator: "NPC", target: "NPC", action_type: str) -> dict:
+    """두 NPC의 성격과 관계를 바탕으로 사회적 행동의 결과를 추론합니다."""
+    prompt = f"""
+# Context
+- 행동자: "{initiator.korean_name}" (성격: {initiator.personality.get_personality_summary()})
+- 대상자: "{target.korean_name}" (성격: {target.personality.get_personality_summary()})
+- 둘의 관계: {initiator.relationships.get_relationship_summary(target.name)}
+- 행동: 행동자는 대상자를 도와주려고 합니다. (Action: {action_type})
+
+# Your Task
+위 상황을 바탕으로, 이 행동의 결과를 현실적으로 추론해주세요.
+결과는 반드시 아래 JSON 형식이어야 합니다.
+
+# Outcome (JSON format only)
+{{
+    "success": "true or false"
+    "outcome_summary": "행동의 결과를 한 문장으로 요약 (예: '밥은 찰리의 서투른 도움에 고마워하면서도 조금 답답해했다.')",
+    "initiator_emotion": "행동을 한 후 행동자가 느낄 감정 (아래 'Emotion_List에서 찾아서 한 단어로 표현)"
+    "target_emotion": "행동을 받은 후 대상자가 느낄 감정 (아래 'Emotion_List에서 찾아서 한 단어로 표현)"
+}}
+
+# Emotion_List
+{EMOTION_LIST}
+"""
+    result = _query_llm_for_json_robustly(prompt)   # 3중 방어 시스템 재활용
+    
+    if isinstance(result, dict) and "success" in result:
+        return result
+    return {# 최종 실패 시 안전한 기본값 반환
+            "success": False,
+            "outcome_summary": "행동의 결과를 평가하는 데 실패했습니다.",
+            "initiator_emotion": "confusion",
+            "target_emotion": "neutral"
+        }

npc_social_network/models/llm_prompt_builder.py

@@ -1,98 +0,0 @@
-# portfolio/npc_social_network/models/llm_prompt_builder.py
-
-from typing import List, Optional, TYPE_CHECKING
-from ..npc.npc_memory import Memory
-
-# 타입 검사 시에만 NPC 클래스를 임포트하여 순환 참조 방지
-if TYPE_CHECKING:
-    from ..npc.npc_base import NPC
-    from ..npc.npc_memory import Memory
-
-def build_npc_prompt(npc:"NPC", user_input: str, matched_memories: List[Memory],
-                     time_context:str, target_npc: Optional["NPC"]=None) -> str:
-    """
-    NPC 대사를 생성하기 위한 강화된 프롬프트 구성 함수
-    - SocialProfile의 관꼐 요약을 프롬프트에 포함하도록 수정
-    """
-    # 대화 상대방의 이름을 동적으로 설정
-    interlocutor_name = target_npc.name if target_npc else "player"
-    interlocutor_korean_name = target_npc.korean_name if target_npc else "플레이어"
-
-    # 감정 상태 요약
-    emotion_summary = npc.summarize_emotional_state()
-    # 성격 요약
-    personality_summary = npc.personality.get_personality_summary()
-    # 관계 요약
-    relationship_description = npc.get_relationship_description(interlocutor_name)
-
-    # 평판 정보
-    reputation_info = ""
-    if target_npc:
-        reputation_score = npc.reputation.get(target_npc.name, 0)
-        if reputation_score > 5:
-            reputation_info = f"- '{target_npc.korean_name}'에 대한 평판: 신뢰할 만한 사람 같다. (평판 점수: {reputation_score})"
-        elif reputation_score < -5:
-            reputation_info = f"- '{target_npc.korean_name}'에 대한 평판: 그다지 좋은 소문을 듣지 못했다. (평판 점수: {reputation_score})"
-
-    # 기억 유무에 따른 동적 지침 생성
-    if matched_memories:
-        memory_section_title = "# 연관된 기억"
-        memory_contents = []
-        for mem in matched_memories:
-            tags = f"(감정: {mem.emotion}, 시간: {', '.join(mem.context_tags)})"
-            short_content = mem.content[:70] + "..." if len(mem.content) > 70 else mem.content
-            memory_contents.append(f"- {short_content} {tags}")
-        memory_section = "\n".join(memory_contents)
-
-        # 기억이 있을 때의 지침
-        instruction = f"""
-         나는 '{interlocutor_name}'의 말과 관련된 아래의 기억들을 가지고 있습니다.
-         이 기억들을 바탕으로 자연스럽게 대화하세요."""
-    else:
-        memory_section_title = "# 연관된 기억 없음"
-        memory_section = "관련된 특별한 기억이 없습니다."
-
-        # 기억이 없을 때의 지침
-        instruction = f"""
-         나는 '{interlocutor_name}'의 말과 관련된 명확한 기억이 없습니다.
-         이 사실을 솔직하게 인정하거나, 잘 기억나지 않는다는 뉘앙스로 되물어보세요.
-         **절대로 없는 기억을 지어내면 안 됩니다.**"""
-        
-    # 상정 기억이 있다면 프롬프트에 추가
-    symbolic_memories = [mem for mem in npc.memory_store.long_term if mem.memory_type == "Symbolic"]
-    symbolic_section = ""
-    if symbolic_memories:
-        symbolic_section_title = "# 당신의 핵심 가치관 (상징 기억)"
-        symbolic_contents = "\n".join([f"- {mem.content}" for mem in symbolic_memories])
-        symbolic_section = f"{symbolic_section_title}\n{symbolic_contents}\n"
-
-    # 프롬프트 구성
-    prompt = f"""
-        # 지시사항
-        → 아래 상황에 어울리는 자연스럽고 인간적인 사람 반응을 생성하세요.
-        → 말투, 반응은 감정 상태에 맞추어 주세요.
-        → 대답은 NPC의 1인칭 시점으로 작성하세요.
-        {instruction}
-
-        # 나의 프로필
-        - 이름: {npc.korean_name}
-        - 직업: {npc.job}
-        - 현재 대화 상대: {interlocutor_korean_name}
-        - 현재 시간대: {time_context}
-
-        # 나의 내면 상태
-        - 현재 감정: {emotion_summary}
-        - 성격: {personality_summary}
-        - {interlocutor_korean_name}와(과)의 관계: {relationship_description}
-        - {reputation_info}
-
-        {symbolic_section}
-
-        {memory_section_title}
-        {memory_section}
-
-        # 대화 로그
-        {interlocutor_korean_name}: "{user_input}"
-        {npc.korean_name}:
-"""
-    return prompt

npc_social_network/npc/npc_base.py

@@ -7,19 +7,23 @@ from datetime import datetime
 from .npc_memory import Memory, MemoryStore
 from .npc_emotion import EmotionManager
 from .npc_behavior import BehaviorManager
-from .emotion_config import EMOTION_LIST, EMOTION_CATEGORY_MAP, EMOTION_DECAY_RATE, PERSONALITY_TEMPLATE, EMOTION_RELATION_IMPACT
-from .emotion_config import POSITIVE_RELATION_EMOTIONS, NEGATIVE_RELATION_EMOTIONS, COGNITIVE_RELATION_EMOTIONS
+from .emotion_config import (EMOTION_LIST, EMOTION_CATEGORY_MAP, EMOTION_DECAY_RATE
+                            , PERSONALITY_TEMPLATE, EMOTION_RELATION_IMPACT
+                            , POSITIVE_RELATION_EMOTIONS, NEGATIVE_RELATION_EMOTIONS
+                            , COGNITIVE_RELATION_EMOTIONS)
 from .personality_config import AGE_PROFILE, PERSONALITY_PROFILE
 from .npc_relationship import RelationshipManager
-from ..models.llm_helper import query_llm_with_prompt, query_llm_for_emotion, summarize_memories
-from ..models.llm_helper import analyze_gossip, classify_and_extract_plan_details, generate_dialogue_action
-from ..models.llm_prompt_builder import build_npc_prompt
+from ..models.llm_helper import (query_llm_with_prompt, query_llm_for_emotion, summarize_memories
+                                , analyze_gossip, classify_and_extract_plan_details
+                                , generate_dialogue_action, evaluate_social_action_outcome)
 from .npc_memory_embedder import search_similar_memories, add_memory_to_index
+from .npc_manager import get_korean_postposition
 from .npc_planner import PlannerManager
 from .. import simulation_core
-from typing import TYPE_CHECKING, Tuple
+from typing import TYPE_CHECKING, Tuple, List
 if TYPE_CHECKING:
     from .npc_manager import NPCManager
+    from ..manager.conversation_manager import Conversation
 
 
 # Personality 데이터를 관리하고 요약 기능을 제공하는 클래스 정의
@@ -165,8 +169,6 @@ class NPC:
         action = result.get("action", "END").strip().upper()
 
         # 행동하기 (잠금과 함께)
-        # 이 부분은 대화가 끝난 후, 전체 대화 내용을 바탕으로 기억/관계를 한 번에 업데이트 하도록 향후 수정.
-        # 지금은 매 턴 감정만 업데이트
         with simulation_core.simulation_lock:
             emotion = query_llm_for_emotion(dialogue)
             if emotion and emotion in EMOTION_LIST:
@@ -174,92 +176,6 @@ class NPC:
 
         return dialogue, action
 
-    # def generate_dialogue(self, user_input: str, time_context: str
-    #                       , target_npc: Optional["NPC"]=None, use_llm: bool=True
-    #                       , create_memory: bool = True) -> str:
-    #     """
-    #     플레이어 또는 NPC와 상호작용 시 사용되는 통합 대사 생성 함수
-    #     - user_input: 입력 문장 (플레이어나 NPC로부터)
-    #     - target_npc: NPC 간 대화일 경우 상대 NPC
-    #     """
-    #     if use_llm and user_input:
-    #         # 1. 생각하기
-    #         # 1-1. 유사 기억 검색
-    #         _, _, matched_memories = search_similar_memories(self, user_input)
-
-    #         # 1-2. LLM 프롬프트 생성 및 호출
-    #         prompt = build_npc_prompt(self, user_input, matched_memories, time_context, target_npc)
-    #         npc_reply = query_llm_with_prompt(prompt)
-
-    #         if not npc_reply or "[LLM Error]" in npc_reply:
-    #             return "[LLM Error]..." # 에러 시 기본 응답
-
-    #         # 1-3. 자신의 응답에서 감정 추론 및 상태 업데이트
-    #         emotion_from_reply  = query_llm_for_emotion(npc_reply)
-    #         # 1-4. 상대방의 말에서 감정 추론 (NPC간 대화일 경우)
-    #         emotion_from_input = query_llm_for_emotion(user_input) if target_npc else None
-
-    #         # 2. 행동하기
-    #         if create_memory:
-    #             with simulation_core.simulation_lock:
-    #                 # 2-1. 기억 요약 및 장기 기억화
-    #                 if len(matched_memories) >= 3:
-    #                     self.summarize_and_store_memories(matched_memories)
-
-    #                 # 2-2. 추론한 감정들을 상태에 업데이트
-    #                 if emotion_from_reply  and emotion_from_reply  in EMOTION_LIST:
-    #                     self.update_emotion(emotion_from_reply , strength=2.0)
-
-    #                 # 2-3. 상호작용 기억 저장
-    #                 interlocutor_name = target_npc.name if target_npc else "player"
-    #                 interlocutor_korean_name = target_npc.korean_name if target_npc else "플레이어"
-    #                 memory_content = f"[{interlocutor_korean_name}의 말] '{user_input}' → [나의 응답] '{npc_reply}'"
-    #                 memory = self.remember(content=memory_content, importance=7, emotion=emotion_from_reply , context_tags=[time_context])
-
-    #                 # 2-4. 관계 상태 업데이트
-    #                 if emotion_from_reply  and emotion_from_reply  in EMOTION_RELATION_IMPACT:
-    #                     self.relationships.update_relationship(interlocutor_name, emotion_from_reply , strength=2.0, memory=memory)
-    #                 if target_npc and emotion_from_input and emotion_from_input in EMOTION_RELATION_IMPACT:
-    #                     target_npc.relationships.update_relationship(self.name, emotion_from_input, strength=2.0, memory=memory)
-
-    #                 # 2-5. 성격 변화 반영
-    #                 self.update_personality()
-
-    #         return npc_reply
-
-    #     else:
-    #         # LLM 미사용 시: 감정 기반 행동 생성
-    #         behavior_output, behavior_trace = self.behavior.perform_sequence(
-    #             self.name, self.job, emotion_buffer=self._emotion_buffer, return_trace=True
-    #         )
-
-    #         # 행동 기반 감정 추론 및 반영
-    #         for action, score in behavior_trace:
-    #             emotion_name = self.behavior.action_to_emotion.get(action)
-    #             if emotion_name:
-    #                 self.update_emotion(emotion_name, strength=score)
-
-    #         # dominant_score 기반 중요도 추정
-    #         dominant_emotions = self.behavior.get_layer_dominant_emotions(self._emotion_buffer)
-    #         dominant_sequence = self.behavior.decide_layered_sequence(dominant_emotions)
-    #         dominant_score = max([score for _, score in dominant_sequence]) if dominant_sequence else 5
-    #         importance = min(int(dominant_score), 10)
-
-    #         # Memory 저장
-    #         memory_entry = Memory(
-    #             content=f"행동 수행: {behavior_trace}",
-    #             importance=importance,
-    #             emotion=self.emotion.get_dominant_emotion(),
-    #             behavior_trace=behavior_trace,
-    #             context_tags=[time_context]
-    #         )
-    #         self.memory_store.add_memory(memory_entry)
-
-    #         # 성격 업데이트
-    #         self.update_personality()
-
-    #         return str(behavior_output)
-
     def remember(self, content: str, importance: int = 5, emotion: str = None,
                  strength: float = 1.0, memory_type:str = "Event",
                  context_tags: Optional[List[str]]=None) -> Memory:
@@ -475,25 +391,38 @@ class NPC:
             # LLM으로 계획을 분석하여 행동을 결정
             plan_details = classify_and_extract_plan_details(step)
             action_type = plan_details.get("action_type")
-
-            if action_type == "TALK":
-                target_korean_name = plan_details.get("target")
-                topic = plan_details.get("topic")
+            target_korean_name = plan_details.get("target")
+
+            if action_type == "TALK" and target_korean_name:
+                target_npc = self.manager.get_npc_by_korean_name(target_korean_name)
+                if target_npc and target_npc != self:
+                    # 주제가 있는 대화 시작
+                    simulation_core.conversation_manager.start_conversation(self, target_npc, topic=plan_details.get("topic"))
+
+            elif action_type == "HELP" and target_korean_name:
+                target_npc = self.manager.get_npc_by_korean_name(target_korean_name)
+                target_postposition = get_korean_postposition(target_korean_name, "이", "가")
+                target_postposition_Eul = get_korean_postposition(target_korean_name, "을", "를")
+
+                if target_npc and target_npc != self:
+                    # '돕기' 행동의 결과를 시뮬레이션
+                    outcome = evaluate_social_action_outcome(self, target_npc, "HELP")
+                    summary = outcome.get('outcome_summary')
+
+                    # 결과를 바탕으로 양쪽 모두의 상태를 업데이트
+                    with simulation_core.simulation_lock:
+                        # 행동자(나)의 기억과 관계 업데이트
+                        self.remember(content=f"{target_korean_name}{target_postposition_Eul} 도왔다. ({summary})", importance=8, emotion=outcome.get('initiator_emotion'))
+                        self.relationships.update_relationship(target_npc.name, outcome.get('initiator_emotion'), strength=3.0)
+
+                        # 대상자(상대방)의 기억과 관계 업데이트
+                        target_npc.remember(content=f"{self.korean_name}{target_postposition} 나를 도와주었다. ({summary})")
+                        target_npc.relationships.update_relationship(self.name, outcome.get('target_emotion'), strength=3.0)
                 
-                if target_korean_name:
-                    target_npc = self.manager.get_npc_by_korean_name(target_korean_name)
-                    if target_npc and target_npc != self:
-                        # 주제가 있는 대화 시작
-                        simulation_core.conversation_manager.start_conversation(self, target_npc, topic=topic)
-                    else:
-                        print(f"[{self.korean_name}] '{target_korean_name}'를 찾을 수 없어 대화 계획을 실행하지 못했습니다.")
-                else:
-                    # LLM이 대상을 특정하지 못한 경우
-                    print(f"[{self.korean_name}] 대화 대상을 특정하지 못해 계획을 실행하지 못했습니다.")
-            else:
+            else:   # SOLOT_ACTION 또는 기타
                 # 대화가 아닌 다른 행동은 그대로 기억에만 기록
                 self.remember(
-                    content=f"'{self.planner.current_goal.description}' 목표를 위해 행동 했다: {step}",
+                    content=f"'{self.planner.current_goal.description}' 목표를 위해 혼자 행동 했다: {step}",
                     importance = 6,
                     emotion="engagement",
                     memory_type="Behavior"

npc_social_network/npc/npc_manager.py

@@ -142,7 +142,7 @@ class NPCManager:
 
             initiator_postposition = get_korean_postposition(initiator.korean_name, "이", "가")
             target_postposition = get_korean_postposition(target.korean_name, "에게", "에게")
-            witness_postposition = get_korean_postposition(initiator.korean_name, "이", "가")
+            witness_postposition = get_korean_postposition(witness.korean_name, "이", "가")
 
             gossip_content = f"'{initiator.korean_name}'{initiator_postposition} '{target.korean_name}'{target_postposition} '{initial_utterance[:100]}...'라고 말하는 것을 봤다."
             

npc_social_network/npc/npc_relationship.py

@@ -82,15 +82,17 @@ class RelationshipManager:
         profile = self._get_or_create_profile(target_name)
         return profile.summary
     
-    def summarize_relationship(self, target_name: str):
+    def summarize_relationship(self, target_name: str, npc_manager: "NPCManager"):
         """ LLM을 사용하여 특정 대상과의 관계를 주기적으로 요약하고 업데이트"""
         from ..models.llm_helper import query_llm_with_prompt
+        from .. import simulation_core
+        
         profile = self._get_or_create_profile(target_name)
 
         if not profile.key_memories:
             return # 요약할 기억이 없으면 실행 안함
         
-        target_npc = self.manager.get_npc_by_korean_name(target_name)
+        target_npc = npc_manager.get_npc_by_name(target_name)
         target_korean_name = target_npc.korean_name if target_npc else target_name
 
         memory_details = "\n".join([f"- {mem.content} (감정: {mem.emotion})" for mem in profile.key_memories])
@@ -101,13 +103,13 @@ class RelationshipManager:
         # '{target_korean_name}'와(과)의 핵심 기억들
         {memory_details}
 
-        → '{target_korean_name}'에 대한 나의 생각:
+        → '{target_korean_name}'에 대한 {self.owner_npc.korean_name}의 생각:
         """
         
         summary = query_llm_with_prompt(prompt).replace("'", "").strip()
 
         if summary and "[LLM Error]" not in summary:
             profile.summary = summary
-            print(f"[{self.owner_npc.korean_name}의 관계 요약 업데이트] → {target_korean_name}: {profile.summary}")
+            simulation_core.add_log(f"[{self.owner_npc.korean_name}의 관계 요약 업데이트] {profile.summary}")
 
     

npc_social_network/simulation_core.py

@@ -52,6 +52,26 @@ def tick_simulation():
         if random.random() < 0.1:
             npc.update_autonomous_behavior("자율 행동 시간")
 
+        # 고차원적 자아 기능
+        # 1. 관계 재정의 (2% 확률)
+        if random.random() < 0.02:
+            with simulation_lock:
+                # 성찰할 만한 관계가 있는지 확인
+                if npc.relationships.relationships:
+                    # 가장 많은 상호작용을 한 관계를 하나 선택
+                    target_name_to_reflect = max(
+                        npc.relationships.relationships.keys(),
+                        key=lambda name: len(npc.relationships.relationships[name].key_memories)
+                    )
+                    # 해당 관계에 대해 요약 및 재정의
+                    npc.relationships.summarize_relationship(target_name_to_reflect, npc_manager)
+        
+        # 2. 가치관 형성 (0.5% 확률, 기억이 30개 이상일 때만)
+        if random.random() < 0.005 and len(npc.memory_store.get_all_memories()) > 30:
+            with simulation_lock:
+                npc.create_symbolic_memory()
+
+
 def simulation_loop():
     """백그라운드에서 주기적으로 시뮬레이션을 실행하는 루프"""
     add_log("백그라운드 시뮬레이션 루프 시작됨.")