diff --git a/.gitignore b/.gitignore
index 2658ecc6f..22e2612dd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,6 +29,7 @@ run_dev.bat
 elua.confirmed
 # C extensions
 *.so
+/results
 
 # Distribution / packaging
 .Python
diff --git a/src/plugins/chat/bot.py b/src/plugins/chat/bot.py
index 959a497a1..29cafdd61 100644
--- a/src/plugins/chat/bot.py
+++ b/src/plugins/chat/bot.py
@@ -454,6 +454,16 @@ class ChatBot:
     async def handle_forward_message(self, event: MessageEvent, bot: Bot) -> None:
         """专用于处理合并转发的消息处理器"""
 
+        # 用户屏蔽,不区分私聊/群聊
+        if event.user_id in global_config.ban_user_id:
+            return
+        
+        if isinstance(event, GroupMessageEvent):
+            if event.group_id:
+                if event.group_id not in global_config.talk_allowed_groups:
+                    return
+
+
         # 获取合并转发消息的详细信息
         forward_info = await bot.get_forward_msg(message_id=event.message_id)
         messages = forward_info["messages"]
@@ -464,22 +474,11 @@ class ChatBot:
             # 提取发送者昵称
             nickname = node["sender"].get("nickname", "未知用户")
             
-            # 处理消息内容
-            message_content = []
-            for seg in node["message"]: 
-                if seg["type"] == "text":
-                    message_content.append(seg["data"]["text"])
-                elif seg["type"] == "image":
-                    message_content.append("[图片]")
-                elif seg["type"] =="face":
-                    message_content.append("[表情]")
-                elif seg["type"] == "at":
-                    message_content.append(f"@{seg['data'].get('qq', '未知用户')}")
-                else:
-                    message_content.append(f"[{seg['type']}]")
+            # 递归处理消息内容
+            message_content = await self.process_message_segments(node["message"],layer=0)
             
             # 拼接为【昵称】+ 内容
-            processed_messages.append(f"【{nickname}】{''.join(message_content)}")
+            processed_messages.append(f"【{nickname}】{message_content}")
 
         # 组合所有消息
         combined_message = "\n".join(processed_messages)
@@ -498,7 +497,7 @@ class ChatBot:
         if isinstance(event, GroupMessageEvent):
             group_info = GroupInfo(
                 group_id=event.group_id,
-                group_name= None,
+                group_name=None,
                 platform="qq"
             )
 
@@ -515,5 +514,42 @@ class ChatBot:
         # 进入标准消息处理流程
         await self.message_process(message_cq)
 
+    async def process_message_segments(self, segments: list,layer:int) -> str:
+        """递归处理消息段"""
+        parts = []
+        for seg in segments:
+            part = await self.process_segment(seg,layer+1)
+            parts.append(part)
+        return "".join(parts)
+
+    async def process_segment(self, seg: dict , layer:int) -> str:
+        """处理单个消息段"""
+        seg_type = seg["type"]
+        if layer > 3 :
+            #防止有那种100层转发消息炸飞麦麦
+            return "【转发消息】"
+        if seg_type == "text":
+            return seg["data"]["text"]
+        elif seg_type == "image":
+            return "[图片]"
+        elif seg_type == "face":
+            return "[表情]"
+        elif seg_type == "at":
+            return f"@{seg['data'].get('qq', '未知用户')}"
+        elif seg_type == "forward":
+            # 递归处理嵌套的合并转发消息
+            nested_nodes = seg["data"].get("content", [])
+            nested_messages = []
+            nested_messages.append("合并转发消息内容：")
+            for node in nested_nodes:
+                nickname = node["sender"].get("nickname", "未知用户")
+                content = await self.process_message_segments(node["message"],layer=layer)
+                # nested_messages.append('-' * layer)
+                nested_messages.append(f"{'--' * layer}【{nickname}】{content}")
+            # nested_messages.append(f"{'--' * layer}合并转发第【{layer}】层结束")
+            return "\n".join(nested_messages)
+        else:
+            return f"[{seg_type}]"
+        
 # 创建全局ChatBot实例
 chat_bot = ChatBot()
diff --git a/src/plugins/memory_system/draw_memory.py b/src/plugins/memory_system/draw_memory.py
index 42bc28290..584985bbd 100644
--- a/src/plugins/memory_system/draw_memory.py
+++ b/src/plugins/memory_system/draw_memory.py
@@ -7,14 +7,17 @@ import jieba
 import matplotlib.pyplot as plt
 import networkx as nx
 from dotenv import load_dotenv
-from src.common.logger import get_module_logger
+from loguru import logger
+# from src.common.logger import get_module_logger
 
-logger = get_module_logger("draw_memory")
+# logger = get_module_logger("draw_memory")
 
 # 添加项目根目录到 Python 路径
 root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
 sys.path.append(root_path)
 
+print(root_path)
+
 from src.common.database import db  # noqa: E402
 
 # 加载.env.dev文件
diff --git a/src/plugins/memory_system/memory.py b/src/plugins/memory_system/memory.py
index 4e4fed32f..07a7fb2ee 100644
--- a/src/plugins/memory_system/memory.py
+++ b/src/plugins/memory_system/memory.py
@@ -594,7 +594,7 @@ class Hippocampus:
 
         logger.info("[遗忘] 开始检查数据库... 当前Logger信息:")
         # logger.info(f"- Logger名称: {logger.name}")
-        logger.info(f"- Logger等级: {logger.level}")
+        # logger.info(f"- Logger等级: {logger.level}")
         # logger.info(f"- Logger处理器: {[handler.__class__.__name__ for handler in logger.handlers]}")
 
         # logger2 = setup_logger(LogModule.MEMORY)
diff --git a/src/plugins/personality/big5_test.py b/src/plugins/personality/big5_test.py
new file mode 100644
index 000000000..80114ec36
--- /dev/null
+++ b/src/plugins/personality/big5_test.py
@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# from .questionnaire import PERSONALITY_QUESTIONS, FACTOR_DESCRIPTIONS
+
+import os
+import sys
+from pathlib import Path
+import random
+
+current_dir = Path(__file__).resolve().parent
+project_root = current_dir.parent.parent.parent
+env_path = project_root / ".env.prod"
+
+root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
+sys.path.append(root_path)
+
+from src.plugins.personality.scene import get_scene_by_factor,get_all_scenes,PERSONALITY_SCENES
+from src.plugins.personality.questionnaire import PERSONALITY_QUESTIONS,FACTOR_DESCRIPTIONS
+from src.plugins.personality.offline_llm import LLMModel 
+
+
+
+class BigFiveTest:
+    def __init__(self):
+        self.questions = PERSONALITY_QUESTIONS
+        self.factors = FACTOR_DESCRIPTIONS
+        
+    def run_test(self):
+        """运行测试并收集答案"""
+        print("\n欢迎参加中国大五人格测试！")
+        print("\n本测试采用六级评分，请根据每个描述与您的符合程度进行打分：")
+        print("1 = 完全不符合")
+        print("2 = 比较不符合")
+        print("3 = 有点不符合")
+        print("4 = 有点符合")
+        print("5 = 比较符合")
+        print("6 = 完全符合")
+        print("\n请认真阅读每个描述，选择最符合您实际情况的选项。\n")
+        
+        # 创建题目序号到题目的映射
+        questions_map = {q['id']: q for q in self.questions}
+        
+        # 获取所有题目ID并随机打乱顺序
+        question_ids = list(questions_map.keys())
+        random.shuffle(question_ids)
+        
+        answers = {}
+        total_questions = len(question_ids)
+        
+        for i, question_id in enumerate(question_ids, 1):
+            question = questions_map[question_id]
+            while True:
+                try:
+                    print(f"\n[{i}/{total_questions}] {question['content']}")
+                    score = int(input("您的评分（1-6）: "))
+                    if 1 <= score <= 6:
+                        answers[question_id] = score
+                        break
+                    else:
+                        print("请输入1-6之间的数字！")
+                except ValueError:
+                    print("请输入有效的数字！")
+        
+        return self.calculate_scores(answers)
+    
+    def calculate_scores(self, answers):
+        """计算各维度得分"""
+        results = {}
+        factor_questions = {
+            "外向性": [],
+            "神经质": [],
+            "严谨性": [],
+            "开放性": [],
+            "宜人性": []
+        }
+        
+        # 将题目按因子分类
+        for q in self.questions:
+            factor_questions[q['factor']].append(q)
+        
+        # 计算每个维度的得分
+        for factor, questions in factor_questions.items():
+            total_score = 0
+            for q in questions:
+                score = answers[q['id']]
+                # 处理反向计分题目
+                if q['reverse_scoring']:
+                    score = 7 - score  # 6分量表反向计分为7减原始分
+                total_score += score
+            
+            # 计算平均分
+            avg_score = round(total_score / len(questions), 2)
+            results[factor] = {
+                "得分": avg_score,
+                "题目数": len(questions),
+                "总分": total_score
+            }
+        
+        return results
+
+    def get_factor_description(self, factor):
+        """获取因子的详细描述"""
+        return self.factors[factor]
+
+def main():
+    test = BigFiveTest()
+    results = test.run_test()
+    
+    print("\n测试结果：")
+    print("=" * 50)
+    for factor, data in results.items():
+        print(f"\n{factor}:")
+        print(f"平均分: {data['得分']} (总分: {data['总分']}, 题目数: {data['题目数']})")
+        print("-" * 30)
+        description = test.get_factor_description(factor)
+        print("维度说明:", description['description'][:100] + "...")
+        print("\n特征词:", ", ".join(description['trait_words']))
+    print("=" * 50)
+    
+if __name__ == "__main__":
+    main()
diff --git a/src/plugins/personality/combined_test.py b/src/plugins/personality/combined_test.py
new file mode 100644
index 000000000..a842847fb
--- /dev/null
+++ b/src/plugins/personality/combined_test.py
@@ -0,0 +1,361 @@
+from typing import Dict, List
+import json
+import os
+from pathlib import Path
+import sys
+from datetime import datetime
+import random
+from scipy import stats  # 添加scipy导入用于t检验
+
+current_dir = Path(__file__).resolve().parent
+project_root = current_dir.parent.parent.parent
+env_path = project_root / ".env.prod"
+
+root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
+sys.path.append(root_path)
+
+from src.plugins.personality.big5_test import BigFiveTest
+from src.plugins.personality.renqingziji import PersonalityEvaluator_direct
+from src.plugins.personality.questionnaire import FACTOR_DESCRIPTIONS, PERSONALITY_QUESTIONS
+
+class CombinedPersonalityTest:
+    def __init__(self):
+        self.big5_test = BigFiveTest()
+        self.scenario_test = PersonalityEvaluator_direct()
+        self.dimensions = ["开放性", "严谨性", "外向性", "宜人性", "神经质"]
+        
+    def run_combined_test(self):
+        """运行组合测试"""
+        print("\n=== 人格特征综合评估系统 ===")
+        print("\n本测试将通过两种方式评估人格特征：")
+        print("1. 传统问卷测评（约40题）")
+        print("2. 情景反应测评（15个场景）")
+        print("\n两种测评完成后，将对比分析结果的异同。")
+        input("\n准备好开始第一部分（问卷测评）了吗？按回车继续...")
+        
+        # 运行问卷测试
+        print("\n=== 第一部分：问卷测评 ===")
+        print("本部分采用六级评分，请根据每个描述与您的符合程度进行打分：")
+        print("1 = 完全不符合")
+        print("2 = 比较不符合") 
+        print("3 = 有点不符合")
+        print("4 = 有点符合")
+        print("5 = 比较符合")
+        print("6 = 完全符合")
+        print("\n重要提示：您可以选择以下两种方式之一来回答问题：")
+        print("1. 根据您自身的真实情况来回答")
+        print("2. 根据您想要扮演的角色特征来回答")
+        print("\n无论选择哪种方式，请保持一致并认真回答每个问题。")
+        input("\n按回车开始答题...")
+        
+        questionnaire_results = self.run_questionnaire()
+        
+        # 转换问卷结果格式以便比较
+        questionnaire_scores = {
+            factor: data["得分"] 
+            for factor, data in questionnaire_results.items()
+        }
+        
+        # 运行情景测试
+        print("\n=== 第二部分：情景反应测评 ===")
+        print("接下来，您将面对一系列具体场景，请描述您在每个场景中可能的反应。")
+        print("每个场景都会评估不同的人格维度，共15个场景。")
+        print("您可以选择提供自己的真实反应，也可以选择扮演一个您创作的角色来回答。")
+        input("\n准备好开始了吗？按回车继续...")
+        
+        scenario_results = self.run_scenario_test()
+        
+        # 比较和展示结果
+        self.compare_and_display_results(questionnaire_scores, scenario_results)
+        
+        # 保存结果
+        self.save_results(questionnaire_scores, scenario_results)
+
+    def run_questionnaire(self):
+        """运行问卷测试部分"""
+        # 创建题目序号到题目的映射
+        questions_map = {q['id']: q for q in PERSONALITY_QUESTIONS}
+        
+        # 获取所有题目ID并随机打乱顺序
+        question_ids = list(questions_map.keys())
+        random.shuffle(question_ids)
+        
+        answers = {}
+        total_questions = len(question_ids)
+        
+        for i, question_id in enumerate(question_ids, 1):
+            question = questions_map[question_id]
+            while True:
+                try:
+                    print(f"\n问题 [{i}/{total_questions}]")
+                    print(f"{question['content']}")
+                    score = int(input("您的评分（1-6）: "))
+                    if 1 <= score <= 6:
+                        answers[question_id] = score
+                        break
+                    else:
+                        print("请输入1-6之间的数字！")
+                except ValueError:
+                    print("请输入有效的数字！")
+                    
+            # 每10题显示一次进度
+            if i % 10 == 0:
+                print(f"\n已完成 {i}/{total_questions} 题 ({int(i/total_questions*100)}%)")
+        
+        return self.calculate_questionnaire_scores(answers)
+        
+    def calculate_questionnaire_scores(self, answers):
+        """计算问卷测试的维度得分"""
+        results = {}
+        factor_questions = {
+            "外向性": [],
+            "神经质": [],
+            "严谨性": [],
+            "开放性": [],
+            "宜人性": []
+        }
+        
+        # 将题目按因子分类
+        for q in PERSONALITY_QUESTIONS:
+            factor_questions[q['factor']].append(q)
+        
+        # 计算每个维度的得分
+        for factor, questions in factor_questions.items():
+            total_score = 0
+            for q in questions:
+                score = answers[q['id']]
+                # 处理反向计分题目
+                if q['reverse_scoring']:
+                    score = 7 - score  # 6分量表反向计分为7减原始分
+                total_score += score
+            
+            # 计算平均分
+            avg_score = round(total_score / len(questions), 2)
+            results[factor] = {
+                "得分": avg_score,
+                "题目数": len(questions),
+                "总分": total_score
+            }
+        
+        return results
+        
+    def run_scenario_test(self):
+        """运行情景测试部分"""
+        final_scores = {"开放性": 0, "严谨性": 0, "外向性": 0, "宜人性": 0, "神经质": 0}
+        dimension_counts = {trait: 0 for trait in final_scores.keys()}
+
+        # 随机打乱场景顺序
+        scenarios = self.scenario_test.scenarios.copy()
+        random.shuffle(scenarios)
+
+        for i, scenario_data in enumerate(scenarios, 1):
+            print(f"\n场景 [{i}/{len(scenarios)}] - {scenario_data['场景编号']}")
+            print("-" * 50)
+            print(scenario_data["场景"])
+            print("\n请描述您在这种情况下会如何反应：")
+            response = input().strip()
+
+            if not response:
+                print("反应描述不能为空！")
+                continue
+
+            print("\n正在评估您的描述...")
+            scores = self.scenario_test.evaluate_response(
+                scenario_data["场景"], 
+                response, 
+                scenario_data["评估维度"]
+            )
+
+            # 更新分数
+            for dimension, score in scores.items():
+                final_scores[dimension] += score
+                dimension_counts[dimension] += 1
+
+            # print("\n当前场景评估结果：")
+            # print("-" * 30)
+            # for dimension, score in scores.items():
+            #     print(f"{dimension}: {score}/6")
+
+            # 每5个场景显示一次总进度
+            if i % 5 == 0:
+                print(f"\n已完成 {i}/{len(scenarios)} 个场景 ({int(i/len(scenarios)*100)}%)")
+
+            if i < len(scenarios):
+                input("\n按回车继续下一个场景...")
+
+        # 计算平均分
+        for dimension in final_scores:
+            if dimension_counts[dimension] > 0:
+                final_scores[dimension] = round(
+                    final_scores[dimension] / dimension_counts[dimension], 
+                    2
+                )
+                
+        return final_scores
+
+    def compare_and_display_results(self, questionnaire_scores: Dict, scenario_scores: Dict):
+        """比较和展示两种测试的结果"""
+        print("\n=== 测评结果对比分析 ===")
+        print("\n" + "=" * 60)
+        print(f"{'维度':<8} {'问卷得分':>10} {'情景得分':>10} {'差异':>10} {'差异程度':>10}")
+        print("-" * 60)
+        
+        # 收集每个维度的得分用于统计分析
+        questionnaire_values = []
+        scenario_values = []
+        diffs = []
+        
+        for dimension in self.dimensions:
+            q_score = questionnaire_scores[dimension]
+            s_score = scenario_scores[dimension]
+            diff = round(abs(q_score - s_score), 2)
+            
+            questionnaire_values.append(q_score)
+            scenario_values.append(s_score)
+            diffs.append(diff)
+            
+            # 计算差异程度
+            diff_level = "低" if diff < 0.5 else "中" if diff < 1.0 else "高"
+            print(f"{dimension:<8} {q_score:>10.2f} {s_score:>10.2f} {diff:>10.2f} {diff_level:>10}")
+        
+        print("=" * 60)
+        
+        # 计算整体统计指标
+        mean_diff = sum(diffs) / len(diffs)
+        std_diff = (sum((x - mean_diff) ** 2 for x in diffs) / (len(diffs) - 1)) ** 0.5
+        
+        # 计算效应量 (Cohen's d)
+        pooled_std = ((sum((x - sum(questionnaire_values)/len(questionnaire_values))**2 for x in questionnaire_values) +
+                      sum((x - sum(scenario_values)/len(scenario_values))**2 for x in scenario_values)) /
+                     (2 * len(self.dimensions) - 2)) ** 0.5
+        
+        if pooled_std != 0:
+            cohens_d = abs(mean_diff / pooled_std)
+            
+            # 解释效应量
+            if cohens_d < 0.2:
+                effect_size = "微小"
+            elif cohens_d < 0.5:
+                effect_size = "小"
+            elif cohens_d < 0.8:
+                effect_size = "中等"
+            else:
+                effect_size = "大"
+        
+        # 对所有维度进行整体t检验
+        t_stat, p_value = stats.ttest_rel(questionnaire_values, scenario_values)
+        print(f"\n整体统计分析:")
+        print(f"平均差异: {mean_diff:.3f}")
+        print(f"差异标准差: {std_diff:.3f}")
+        print(f"效应量(Cohen's d): {cohens_d:.3f}")
+        print(f"效应量大小: {effect_size}")
+        print(f"t统计量: {t_stat:.3f}")
+        print(f"p值: {p_value:.3f}")
+        
+        if p_value < 0.05:
+            print("结论: 两种测评方法的结果存在显著差异 (p < 0.05)")
+        else:
+            print("结论: 两种测评方法的结果无显著差异 (p >= 0.05)")
+            
+        print("\n维度说明：")
+        for dimension in self.dimensions:
+            print(f"\n{dimension}:")
+            desc = FACTOR_DESCRIPTIONS[dimension]
+            print(f"定义：{desc['description']}")
+            print(f"特征词：{', '.join(desc['trait_words'])}")
+            
+        # 分析显著差异
+        significant_diffs = []
+        for dimension in self.dimensions:
+            diff = abs(questionnaire_scores[dimension] - scenario_scores[dimension])
+            if diff >= 1.0:  # 差异大于等于1分视为显著
+                significant_diffs.append({
+                    "dimension": dimension,
+                    "diff": diff,
+                    "questionnaire": questionnaire_scores[dimension],
+                    "scenario": scenario_scores[dimension]
+                })
+        
+        if significant_diffs:
+            print("\n\n显著差异分析：")
+            print("-" * 40)
+            for diff in significant_diffs:
+                print(f"\n{diff['dimension']}维度的测评结果存在显著差异：")
+                print(f"问卷得分：{diff['questionnaire']:.2f}")
+                print(f"情景得分：{diff['scenario']:.2f}")
+                print(f"差异值：{diff['diff']:.2f}")
+                
+                # 分析可能的原因
+                if diff['questionnaire'] > diff['scenario']:
+                    print("可能原因：在问卷中的自我评价较高，但在具体情景中的表现较为保守。")
+                else:
+                    print("可能原因：在具体情景中表现出更多该维度特征，而在问卷自评时较为保守。")
+
+    def save_results(self, questionnaire_scores: Dict, scenario_scores: Dict):
+        """保存测试结果"""
+        results = {
+            "测试时间": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "问卷测评结果": questionnaire_scores,
+            "情景测评结果": scenario_scores,
+            "维度说明": FACTOR_DESCRIPTIONS
+        }
+        
+        # 确保目录存在
+        os.makedirs("results", exist_ok=True)
+        
+        # 生成带时间戳的文件名
+        filename = f"results/personality_combined_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        
+        # 保存到文件
+        with open(filename, "w", encoding="utf-8") as f:
+            json.dump(results, f, ensure_ascii=False, indent=2)
+            
+        print(f"\n完整的测评结果已保存到：{filename}")
+
+def load_existing_results():
+    """检查并加载已有的测试结果"""
+    results_dir = "results"
+    if not os.path.exists(results_dir):
+        return None
+        
+    # 获取所有personality_combined开头的文件
+    result_files = [f for f in os.listdir(results_dir) 
+                   if f.startswith("personality_combined_") and f.endswith(".json")]
+    
+    if not result_files:
+        return None
+        
+    # 按文件修改时间排序，获取最新的结果文件
+    latest_file = max(result_files, 
+                     key=lambda f: os.path.getmtime(os.path.join(results_dir, f)))
+    
+    print(f"\n发现已有的测试结果：{latest_file}")
+    try:
+        with open(os.path.join(results_dir, latest_file), "r", encoding="utf-8") as f:
+            results = json.load(f)
+        return results
+    except Exception as e:
+        print(f"读取结果文件时出错：{str(e)}")
+        return None
+
+def main():
+    test = CombinedPersonalityTest()
+    
+    # 检查是否存在已有结果
+    existing_results = load_existing_results()
+    
+    if existing_results:
+        print("\n=== 使用已有测试结果进行分析 ===")
+        print(f"测试时间：{existing_results['测试时间']}")
+        
+        questionnaire_scores = existing_results["问卷测评结果"]
+        scenario_scores = existing_results["情景测评结果"]
+        
+        # 直接进行结果对比分析
+        test.compare_and_display_results(questionnaire_scores, scenario_scores)
+    else:
+        print("\n未找到已有的测试结果，开始新的测试...")
+        test.run_combined_test()
+
+if __name__ == "__main__":
+    main() 
\ No newline at end of file
diff --git a/src/plugins/personality/offline_llm.py b/src/plugins/personality/offline_llm.py
index e4dc23f93..db51ca00f 100644
--- a/src/plugins/personality/offline_llm.py
+++ b/src/plugins/personality/offline_llm.py
@@ -11,7 +11,7 @@ logger = get_module_logger("offline_llm")
 
 
 class LLMModel:
-    def __init__(self, model_name="deepseek-ai/DeepSeek-V3", **kwargs):
+    def __init__(self, model_name="Pro/deepseek-ai/DeepSeek-V3", **kwargs):
         self.model_name = model_name
         self.params = kwargs
         self.api_key = os.getenv("SILICONFLOW_KEY")
diff --git a/src/plugins/personality/questionnaire.py b/src/plugins/personality/questionnaire.py
new file mode 100644
index 000000000..4afff1185
--- /dev/null
+++ b/src/plugins/personality/questionnaire.py
@@ -0,0 +1,110 @@
+# 人格测试问卷题目 王孟成, 戴晓阳, & 姚树桥. (2011). 中国大五人格问卷的初步编制Ⅲ:简式版的制定及信效度检验. 中国临床心理学杂志, 19(04), Article 04.
+# 王孟成, 戴晓阳, & 姚树桥. (2010). 中国大五人格问卷的初步编制Ⅰ:理论框架与信度分析. 中国临床心理学杂志, 18(05), Article 05.
+
+PERSONALITY_QUESTIONS = [
+    # 神经质维度 (F1)
+    {"id": 1, "content": "我常担心有什么不好的事情要发生", "factor": "神经质", "reverse_scoring": False},
+    {"id": 2, "content": "我常感到害怕", "factor": "神经质", "reverse_scoring": False},
+    {"id": 3, "content": "有时我觉得自己一无是处", "factor": "神经质", "reverse_scoring": False},
+    {"id": 4, "content": "我很少感到忧郁或沮丧", "factor": "神经质", "reverse_scoring": True},
+    {"id": 5, "content": "别人一句漫不经心的话，我常会联系在自己身上", "factor": "神经质", "reverse_scoring": False},
+    {"id": 6, "content": "在面对压力时，我有种快要崩溃的感觉", "factor": "神经质", "reverse_scoring": False},
+    {"id": 7, "content": "我常担忧一些无关紧要的事情", "factor": "神经质", "reverse_scoring": False},
+    {"id": 8, "content": "我常常感到内心不踏实", "factor": "神经质", "reverse_scoring": False},
+    
+    # 严谨性维度 (F2)
+    {"id": 9, "content": "在工作上，我常只求能应付过去便可", "factor": "严谨性", "reverse_scoring": True},
+    {"id": 10, "content": "一旦确定了目标，我会坚持努力地实现它", "factor": "严谨性", "reverse_scoring": False},
+    {"id": 11, "content": "我常常是仔细考虑之后才做出决定", "factor": "严谨性", "reverse_scoring": False},
+    {"id": 12, "content": "别人认为我是个慎重的人", "factor": "严谨性", "reverse_scoring": False},
+    {"id": 13, "content": "做事讲究逻辑和条理是我的一个特点", "factor": "严谨性", "reverse_scoring": False},
+    {"id": 14, "content": "我喜欢一开头就把事情计划好", "factor": "严谨性", "reverse_scoring": False},
+    {"id": 15, "content": "我工作或学习很勤奋", "factor": "严谨性", "reverse_scoring": False},
+    {"id": 16, "content": "我是个倾尽全力做事的人", "factor": "严谨性", "reverse_scoring": False},
+    
+    # 宜人性维度 (F3)
+    {"id": 17, "content": "尽管人类社会存在着一些阴暗的东西（如战争、罪恶、欺诈），我仍然相信人性总的来说是善良的", "factor": "宜人性", "reverse_scoring": False},
+    {"id": 18, "content": "我觉得大部分人基本上是心怀善意的", "factor": "宜人性", "reverse_scoring": False},
+    {"id": 19, "content": "虽然社会上有骗子，但我觉得大部分人还是可信的", "factor": "宜人性", "reverse_scoring": False},
+    {"id": 20, "content": "我不太关心别人是否受到不公正的待遇", "factor": "宜人性", "reverse_scoring": True},
+    {"id": 21, "content": "我时常觉得别人的痛苦与我无关", "factor": "宜人性", "reverse_scoring": True},
+    {"id": 22, "content": "我常为那些遭遇不幸的人感到难过", "factor": "宜人性", "reverse_scoring": False},
+    {"id": 23, "content": "我是那种只照顾好自己，不替别人担忧的人", "factor": "宜人性", "reverse_scoring": True},
+    {"id": 24, "content": "当别人向我诉说不幸时，我常感到难过", "factor": "宜人性", "reverse_scoring": False},
+    
+    # 开放性维度 (F4)
+    {"id": 25, "content": "我的想象力相当丰富", "factor": "开放性", "reverse_scoring": False},
+    {"id": 26, "content": "我头脑中经常充满生动的画面", "factor": "开放性", "reverse_scoring": False},
+    {"id": 27, "content": "我对许多事情有着很强的好奇心", "factor": "开放性", "reverse_scoring": False},
+    {"id": 28, "content": "我喜欢冒险", "factor": "开放性", "reverse_scoring": False},
+    {"id": 29, "content": "我是个勇于冒险，突破常规的人", "factor": "开放性", "reverse_scoring": False},
+    {"id": 30, "content": "我身上具有别人没有的冒险精神", "factor": "开放性", "reverse_scoring": False},
+    {"id": 31, "content": "我渴望学习一些新东西，即使它们与我的日常生活无关", "factor": "开放性", "reverse_scoring": False},
+    {"id": 32, "content": "我很愿意也很容易接受那些新事物、新观点、新想法", "factor": "开放性", "reverse_scoring": False},
+    
+    # 外向性维度 (F5)
+    {"id": 33, "content": "我喜欢参加社交与娱乐聚会", "factor": "外向性", "reverse_scoring": False},
+    {"id": 34, "content": "我对人多的聚会感到乏味", "factor": "外向性", "reverse_scoring": True},
+    {"id": 35, "content": "我尽量避免参加人多的聚会和嘈杂的环境", "factor": "外向性", "reverse_scoring": True},
+    {"id": 36, "content": "在热闹的聚会上，我常常表现主动并尽情玩耍", "factor": "外向性", "reverse_scoring": False},
+    {"id": 37, "content": "有我在的场合一般不会冷场", "factor": "外向性", "reverse_scoring": False},
+    {"id": 38, "content": "我希望成为领导者而不是被领导者", "factor": "外向性", "reverse_scoring": False},
+    {"id": 39, "content": "在一个团体中，我希望处于领导地位", "factor": "外向性", "reverse_scoring": False},
+    {"id": 40, "content": "别人多认为我是一个热情和友好的人", "factor": "外向性", "reverse_scoring": False}
+]
+
+# 因子维度说明
+FACTOR_DESCRIPTIONS = {
+    "外向性": {
+        "description": "反映个体神经系统的强弱和动力特征。外向性主要表现为个体在人际交往和社交活动中的倾向性，包括对社交活动的兴趣、对人群的态度、社交互动中的主动程度以及在群体中的影响力。高分者倾向于积极参与社交活动，乐于与人交往，善于表达自我，并往往在群体中发挥领导作用；低分者则倾向于独处，不喜欢热闹的社交场合，表现出内向、安静的特征。",
+        "trait_words": ["热情", "活力", "社交", "主动"],
+        "subfactors": {
+            "合群性": "个体愿意与他人聚在一起，即接近人群的倾向；高分表现乐群、好交际，低分表现封闭、独处",
+            "热情": "个体对待别人时所表现出的态度；高分表现热情好客，低分表现冷淡",
+            "支配性": "个体喜欢指使、操纵他人，倾向于领导别人的特点；高分表现好强、发号施令，低分表现顺从、低调",
+            "活跃": "个体精力充沛，活跃、主动性等特点；高分表现活跃，低分表现安静"
+        }
+    },
+    "神经质": {
+        "description": "反映个体情绪的状态和体验内心苦恼的倾向性。这个维度主要关注个体在面对压力、挫折和日常生活挑战时的情绪稳定性和适应能力。它包含了对焦虑、抑郁、愤怒等负面情绪的敏感程度，以及个体对这些情绪的调节和控制能力。高分者容易体验负面情绪，对压力较为敏感，情绪波动较大；低分者则表现出较强的情绪稳定性，能够较好地应对压力和挫折。",
+        "trait_words": ["稳定", "沉着", "从容", "坚韧"],
+        "subfactors": {
+            "焦虑": "个体体验焦虑感的个体差异；高分表现坐立不安，低分表现平静",
+            "抑郁": "个体体验抑郁情感的个体差异；高分表现郁郁寡欢，低分表现平静",
+            "敏感多疑": "个体常常关注自己的内心活动，行为和过于意识人对自己的看法、评价；高分表现敏感多疑，低分表现淡定、自信",
+            "脆弱性": "个体在危机或困难面前无力、脆弱的特点；高分表现无能、易受伤、逃避，低分表现坚强",
+            "愤怒-敌意": "个体准备体验愤怒，及相关情绪的状态；高分表现暴躁易怒，低分表现平静"
+        }
+    },
+    "严谨性": {
+        "description": "反映个体在目标导向行为上的组织、坚持和动机特征。这个维度体现了个体在工作、学习等目标性活动中的自我约束和行为管理能力。它涉及到个体的责任感、自律性、计划性、条理性以及完成任务的态度。高分者往往表现出强烈的责任心、良好的组织能力、谨慎的决策风格和持续的努力精神；低分者则可能表现出随意性强、缺乏规划、做事马虎或易放弃的特点。",
+        "trait_words": ["负责", "自律", "条理", "勤奋"],
+        "subfactors": {
+            "责任心": "个体对待任务和他人认真负责，以及对自己承诺的信守；高分表现有责任心、负责任，低分表现推卸责任、逃避处罚",
+            "自我控制": "个体约束自己的能力，及自始至终的坚持性；高分表现自制、有毅力，低分表现冲动、无毅力",
+            "审慎性": "个体在采取具体行动前的心理状态；高分表现谨慎、小心，低分表现鲁莽、草率",
+            "条理性": "个体处理事务和工作的秩序，条理和逻辑性；高分表现整洁、有秩序，低分表现混乱、遗漏",
+            "勤奋": "个体工作和学习的努力程度及为达到目标而表现出的进取精神；高分表现勤奋、刻苦，低分表现懒散"
+        }
+    },
+    "开放性": {
+        "description": "反映个体对新异事物、新观念和新经验的接受程度，以及在思维和行为方面的创新倾向。这个维度体现了个体在认知和体验方面的广度、深度和灵活性。它包括对艺术的欣赏能力、对知识的求知欲、想象力的丰富程度，以及对冒险和创新的态度。高分者往往具有丰富的想象力、广泛的兴趣、开放的思维方式和创新的倾向；低分者则倾向于保守、传统，喜欢熟悉和常规的事物。",
+        "trait_words": ["创新", "好奇", "艺术", "冒险"],
+        "subfactors": {
+            "幻想": "个体富于幻想和想象的水平；高分表现想象力丰富，低分表现想象力匮乏",
+            "审美": "个体对于艺术和美的敏感与热爱程度；高分表现富有艺术气息，低分表现一般对艺术不敏感",
+            "好奇心": "个体对未知事物的态度；高分表现兴趣广泛、好奇心浓，低分表现兴趣少、无好奇心",
+            "冒险精神": "个体愿意尝试有风险活动的个体差异；高分表现好冒险，低分表现保守",
+            "价值观念": "个体对新事物、新观念、怪异想法的态度；高分表现开放、坦然接受新事物，低分则相反"
+        }
+    },
+    "宜人性": {
+        "description": "反映个体在人际关系中的亲和倾向，体现了对他人的关心、同情和合作意愿。这个维度主要关注个体与他人互动时的态度和行为特征，包括对他人的信任程度、同理心水平、助人意愿以及在人际冲突中的处理方式。高分者通常表现出友善、富有同情心、乐于助人的特质，善于与他人建立和谐关系；低分者则可能表现出较少的人际关注，在社交互动中更注重自身利益，较少考虑他人感受。",
+        "trait_words": ["友善", "同理", "信任", "合作"],
+        "subfactors": {
+            "信任": "个体对他人和/或他人言论的相信程度；高分表现信任他人，低分表现怀疑",
+            "体贴": "个体对别人的兴趣和需要的关注程度；高分表现体贴、温存，低分表现冷漠、不在乎",
+            "同情": "个体对处于不利地位的人或物的态度；高分表现富有同情心，低分表现冷漠"
+        }
+    }
+} 
\ No newline at end of file
diff --git a/src/plugins/personality/renqingziji.py b/src/plugins/personality/renqingziji.py
index 53d31cbf6..b3a3e267e 100644
--- a/src/plugins/personality/renqingziji.py
+++ b/src/plugins/personality/renqingziji.py
@@ -1,3 +1,11 @@
+'''
+The definition of artificial personality in this paper follows the dispositional para-digm and adapts a definition of personality developed for humans [17]: 
+Personality for a human is the "whole and organisation of relatively stable tendencies and patterns of experience and 
+behaviour within one person (distinguishing it from other persons)". This definition is modified for artificial personality: 
+Artificial personality describes the relatively stable tendencies and patterns of behav-iour of an AI-based machine that 
+can be designed by developers and designers via different modalities, such as language, creating the impression 
+of individuality of a humanized social agent when users interact with the machine.'''
+
 from typing import Dict, List
 import json
 import os
@@ -5,16 +13,19 @@ from pathlib import Path
 from dotenv import load_dotenv
 import sys
 
+'''
+第一种方案：基于情景评估的人格测定
+'''
 current_dir = Path(__file__).resolve().parent
-# 获取项目根目录（上三层目录）
 project_root = current_dir.parent.parent.parent
-# env.dev文件路径
 env_path = project_root / ".env.prod"
 
 root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
 sys.path.append(root_path)
 
-from src.plugins.personality.offline_llm import LLMModel  # noqa E402
+from src.plugins.personality.scene import get_scene_by_factor,get_all_scenes,PERSONALITY_SCENES
+from src.plugins.personality.questionnaire import PERSONALITY_QUESTIONS,FACTOR_DESCRIPTIONS
+from src.plugins.personality.offline_llm import LLMModel 
 
 # 加载环境变量
 if env_path.exists():
@@ -25,48 +36,77 @@ else:
     print("将使用默认配置")
 
 
-class PersonalityEvaluator:
+class PersonalityEvaluator_direct:
     def __init__(self):
-        self.personality_traits = {"开放性": 0, "尽责性": 0, "外向性": 0, "宜人性": 0, "神经质": 0}
-        self.scenarios = [
-            {
-                "场景": "在团队项目中，你发现一个同事的工作质量明显低于预期，这可能会影响整个项目的进度。",
-                "评估维度": ["尽责性", "宜人性"],
-            },
-            {"场景": "你被邀请参加一个完全陌生的社交活动，现场都是不认识的人。", "评估维度": ["外向性", "神经质"]},
-            {
-                "场景": "你的朋友向你推荐了一个新的艺术展览，但风格与你平时接触的完全不同。",
-                "评估维度": ["开放性", "外向性"],
-            },
-            {"场景": "在工作中，你遇到了一个技术难题，需要学习全新的技术栈。", "评估维度": ["开放性", "尽责性"]},
-            {"场景": "你的朋友因为个人原因情绪低落，向你寻求帮助。", "评估维度": ["宜人性", "神经质"]},
-        ]
+        self.personality_traits = {"开放性": 0, "严谨性": 0, "外向性": 0, "宜人性": 0, "神经质": 0}
+        self.scenarios = []
+        
+        # 为每个人格特质获取对应的场景
+        for trait in PERSONALITY_SCENES:
+            scenes = get_scene_by_factor(trait)
+            if not scenes:
+                continue
+                
+            # 从每个维度选择3个场景
+            import random
+            scene_keys = list(scenes.keys())
+            selected_scenes = random.sample(scene_keys, min(3, len(scene_keys)))
+            
+            for scene_key in selected_scenes:
+                scene = scenes[scene_key]
+                
+                # 为每个场景添加评估维度
+                # 主维度是当前特质，次维度随机选择一个其他特质
+                other_traits = [t for t in PERSONALITY_SCENES if t != trait]
+                secondary_trait = random.choice(other_traits)
+                
+                self.scenarios.append({
+                    "场景": scene["scenario"],
+                    "评估维度": [trait, secondary_trait],
+                    "场景编号": scene_key
+                })
+            
         self.llm = LLMModel()
 
     def evaluate_response(self, scenario: str, response: str, dimensions: List[str]) -> Dict[str, float]:
         """
         使用 DeepSeek AI 评估用户对特定场景的反应
         """
-        prompt = f"""请根据以下场景和用户描述，评估用户在大五人格模型中的相关维度得分（0-10分）。
-场景：{scenario}
-用户描述：{response}
+        # 构建维度描述
+        dimension_descriptions = []
+        for dim in dimensions:
+            desc = FACTOR_DESCRIPTIONS.get(dim, "")
+            if desc:
+                dimension_descriptions.append(f"- {dim}：{desc}")
+        
+        dimensions_text = "\n".join(dimension_descriptions)
+        
+        prompt = f"""请根据以下场景和用户描述，评估用户在大五人格模型中的相关维度得分（1-6分）。
 
-需要评估的维度：{", ".join(dimensions)}
+场景描述：
+{scenario}
+
+用户回应：
+{response}
+
+需要评估的维度说明：
+{dimensions_text}
 
 请按照以下格式输出评估结果（仅输出JSON格式）：
 {{
-    "维度1": 分数,
-    "维度2": 分数
+    "{dimensions[0]}": 分数,
+    "{dimensions[1]}": 分数
 }}
 
-评估标准：
-- 开放性：对新事物的接受程度和创造性思维
-- 尽责性：计划性、组织性和责任感
-- 外向性：社交倾向和能量水平
-- 宜人性：同理心、合作性和友善程度
-- 神经质：情绪稳定性和压力应对能力
+评分标准：
+1 = 非常不符合该维度特征
+2 = 比较不符合该维度特征
+3 = 有点不符合该维度特征
+4 = 有点符合该维度特征
+5 = 比较符合该维度特征
+6 = 非常符合该维度特征
 
-请确保分数在0-10之间，并给出合理的评估理由。"""
+请根据用户的回应，结合场景和维度说明进行评分。确保分数在1-6之间，并给出合理的评估。"""
 
         try:
             ai_response, _ = self.llm.generate_response(prompt)
@@ -76,29 +116,30 @@ class PersonalityEvaluator:
             if start_idx != -1 and end_idx != 0:
                 json_str = ai_response[start_idx:end_idx]
                 scores = json.loads(json_str)
-                # 确保所有分数在0-10之间
-                return {k: max(0, min(10, float(v))) for k, v in scores.items()}
+                # 确保所有分数在1-6之间
+                return {k: max(1, min(6, float(v))) for k, v in scores.items()}
             else:
                 print("AI响应格式不正确，使用默认评分")
-                return {dim: 5.0 for dim in dimensions}
+                return {dim: 3.5 for dim in dimensions}
         except Exception as e:
             print(f"评估过程出错：{str(e)}")
-            return {dim: 5.0 for dim in dimensions}
+            return {dim: 3.5 for dim in dimensions}
 
 
 def main():
     print("欢迎使用人格形象创建程序！")
-    print("接下来，您将面对一系列场景。请根据您想要创建的角色形象，描述在该场景下可能的反应。")
+    print("接下来，您将面对一系列场景（共15个）。请根据您想要创建的角色形象，描述在该场景下可能的反应。")
     print("每个场景都会评估不同的人格维度，最终得出完整的人格特征评估。")
+    print("评分标准：1=非常不符合，2=比较不符合，3=有点不符合，4=有点符合，5=比较符合，6=非常符合")
     print("\n准备好了吗？按回车键开始...")
     input()
 
-    evaluator = PersonalityEvaluator()
-    final_scores = {"开放性": 0, "尽责性": 0, "外向性": 0, "宜人性": 0, "神经质": 0}
+    evaluator = PersonalityEvaluator_direct()
+    final_scores = {"开放性": 0, "严谨性": 0, "外向性": 0, "宜人性": 0, "神经质": 0}
     dimension_counts = {trait: 0 for trait in final_scores.keys()}
 
     for i, scenario_data in enumerate(evaluator.scenarios, 1):
-        print(f"\n场景 {i}/{len(evaluator.scenarios)}:")
+        print(f"\n场景 {i}/{len(evaluator.scenarios)} - {scenario_data['场景编号']}:")
         print("-" * 50)
         print(scenario_data["场景"])
         print("\n请描述您的角色在这种情况下会如何反应：")
@@ -119,7 +160,7 @@ def main():
         print("\n当前评估结果：")
         print("-" * 30)
         for dimension, score in scores.items():
-            print(f"{dimension}: {score}/10")
+            print(f"{dimension}: {score}/6")
 
         if i < len(evaluator.scenarios):
             print("\n按回车键继续下一个场景...")
@@ -133,10 +174,15 @@ def main():
     print("\n最终人格特征评估结果：")
     print("-" * 30)
     for trait, score in final_scores.items():
-        print(f"{trait}: {score}/10")
+        print(f"{trait}: {score}/6")
+        print(f"测试场景数：{dimension_counts[trait]}")
 
     # 保存结果
-    result = {"final_scores": final_scores, "scenarios": evaluator.scenarios}
+    result = {
+        "final_scores": final_scores, 
+        "dimension_counts": dimension_counts,
+        "scenarios": evaluator.scenarios
+    }
 
     # 确保目录存在
     os.makedirs("results", exist_ok=True)
diff --git a/src/plugins/personality/scene.py b/src/plugins/personality/scene.py
new file mode 100644
index 000000000..936b07a3e
--- /dev/null
+++ b/src/plugins/personality/scene.py
@@ -0,0 +1,258 @@
+from typing import Dict, List
+
+PERSONALITY_SCENES = {
+    "外向性": {
+        "场景1": {
+            "scenario": """你刚刚搬到一个新的城市工作。今天是你入职的第一天，在公司的电梯里，一位同事微笑着和你打招呼：
+            
+同事：「嗨！你是新来的同事吧？我是市场部的小林。」
+
+同事看起来很友善，还主动介绍说：「待会午饭时间，我们部门有几个人准备一起去楼下新开的餐厅，你要一起来吗？可以认识一下其他同事。」""",
+            "explanation": "这个场景通过职场社交情境，观察个体对于新环境、新社交圈的态度和反应倾向。"
+        },
+        "场景2": {
+            "scenario": """在大学班级群里，班长发起了一个组织班级联谊活动的投票：
+
+班长：「大家好！下周末我们准备举办一次班级联谊活动，地点在学校附近的KTV。想请大家报名参加，也欢迎大家邀请其他班级的同学！」
+
+已经有几个同学在群里积极响应，有人@你问你要不要一起参加。""",
+            "explanation": "通过班级活动场景，观察个体对群体社交活动的参与意愿。"
+        },
+        "场景3": {
+            "scenario": """你在社交平台上发布了一条动态，收到了很多陌生网友的评论和私信：
+
+网友A：「你说的这个观点很有意思！想和你多交流一下。」
+
+网友B：「我也对这个话题很感兴趣，要不要建个群一起讨论？」""",
+            "explanation": "通过网络社交场景，观察个体对线上社交的态度。"
+        },
+        "场景4": {
+            "scenario": """你暗恋的对象今天主动来找你：
+
+对方：「那个...我最近在准备一个演讲比赛，听说你口才很好。能不能请你帮我看看演讲稿，顺便给我一些建议？如果你有时间的话，可以一起吃个饭聊聊。」""",
+            "explanation": "通过恋爱情境，观察个体在面对心仪对象时的社交表现。"
+        },
+        "场景5": {
+            "scenario": """在一次线下读书会上，主持人突然点名让你分享读后感：
+
+主持人：「听说你对这本书很有见解，能不能和大家分享一下你的想法？」
+
+现场有二十多个陌生的读书爱好者，都期待地看着你。""",
+            "explanation": "通过即兴发言场景，观察个体的社交表现欲和公众表达能力。"
+        }
+    },
+    
+    "神经质": {
+        "场景1": {
+            "scenario": """你正在准备一个重要的项目演示，这关系到你的晋升机会。就在演示前30分钟，你收到了主管发来的消息：
+
+主管：「临时有个变动，CEO也会来听你的演示。他对这个项目特别感兴趣。」
+
+正当你准备回复时，主管又发来一条：「对了，能不能把演示时间压缩到15分钟？CEO下午还有其他安排。你之前准备的是30分钟的版本对吧？」""",
+            "explanation": "这个场景通过突发的压力情境，观察个体在面对计划外变化时的情绪反应和调节能力。"
+        },
+        "场景2": {
+            "scenario": """期末考试前一天晚上，你收到了好朋友发来的消息：
+
+好朋友：「不好意思这么晚打扰你...我看你平时成绩很好，能不能帮我解答几个问题？我真的很担心明天的考试。」
+
+你看了看时间，已经是晚上11点，而你原本计划的复习还没完成。""",
+            "explanation": "通过考试压力场景，观察个体在时间紧张时的情绪管理。"
+        },
+        "场景3": {
+            "scenario": """你在社交媒体上发表的一个观点引发了争议，有不少人开始批评你：
+
+网友A：「这种观点也好意思说出来，真是无知。」
+
+网友B：「建议楼主先去补补课再来发言。」
+
+评论区里的负面评论越来越多，还有人开始人身攻击。""",
+            "explanation": "通过网络争议场景，观察个体面对批评时的心理承受能力。"
+        },
+        "场景4": {
+            "scenario": """你和恋人约好今天一起看电影，但在约定时间前半小时，对方发来消息：
+
+恋人：「对不起，我临时有点事，可能要迟到一会儿。」
+
+二十分钟后，对方又发来消息：「可能要再等等，抱歉！」
+
+电影快要开始了，但对方还是没有出现。""",
+            "explanation": "通过恋爱情境，观察个体对不确定性的忍耐程度。"
+        },
+        "场景5": {
+            "scenario": """在一次重要的小组展示中，你的组员在演示途中突然卡壳了：
+
+组员小声对你说：「我忘词了，接下来的部分是什么来着...」
+
+台下的老师和同学都在等待，气氛有些尴尬。""",
+            "explanation": "通过公开场合的突发状况，观察个体的应急反应和压力处理能力。"
+        }
+    },
+    
+    "严谨性": {
+        "场景1": {
+            "scenario": """你是团队的项目负责人，刚刚接手了一个为期两个月的重要项目。在第一次团队会议上：
+
+小王：「老大，我觉得两个月时间很充裕，我们先做着看吧，遇到问题再解决。」
+
+小张：「要不要先列个时间表？不过感觉太详细的计划也没必要，点到为止就行。」
+
+小李：「客户那边说如果能提前完成有奖励，我觉得我们可以先做快一点的部分。」""",
+            "explanation": "这个场景通过项目管理情境，体现个体在工作方法、计划性和责任心方面的特征。"
+        },
+        "场景2": {
+            "scenario": """期末小组作业，组长让大家分工完成一份研究报告。在截止日期前三天：
+
+组员A：「我的部分大概写完了，感觉还行。」
+
+组员B：「我这边可能还要一天才能完成，最近太忙了。」
+
+组员C发来一份没有任何引用出处、可能存在抄袭的内容：「我写完了，你们看看怎么样？」""",
+            "explanation": "通过学习场景，观察个体对学术规范和质量要求的重视程度。"
+        },
+        "场景3": {
+            "scenario": """你在一个兴趣小组的群聊中，大家正在讨论举办一次线下活动：
+
+成员A：「到时候见面就知道具体怎么玩了！」
+
+成员B：「对啊，随意一点挺好的。」
+
+成员C：「人来了自然就热闹了。」""",
+            "explanation": "通过活动组织场景，观察个体对活动计划的态度。"
+        },
+        "场景4": {
+            "scenario": """你和恋人计划一起去旅游，对方说：
+
+恋人：「我们就随心而行吧！订个目的地，其他的到了再说，这样更有意思。」
+
+距离出发还有一周时间，但机票、住宿和具体行程都还没有确定。""",
+            "explanation": "通过旅行规划场景，观察个体的计划性和对不确定性的接受程度。"
+        },
+        "场景5": {
+            "scenario": """在一个重要的团队项目中，你发现一个同事的工作存在明显错误：
+
+同事：「差不多就行了，反正领导也看不出来。」
+
+这个错误可能不会立即造成问题，但长期来看可能会影响项目质量。""",
+            "explanation": "通过工作质量场景，观察个体对细节和标准的坚持程度。"
+        }
+    },
+    
+    "开放性": {
+        "场景1": {
+            "scenario": """周末下午，你的好友小美兴致勃勃地给你打电话：
+
+小美：「我刚发现一个特别有意思的沉浸式艺术展！不是传统那种挂画的展览，而是把整个空间都变成了艺术品。观众要穿特制的服装，还要带上VR眼镜，好像还有AI实时互动！」
+
+小美继续说：「虽然票价不便宜，但听说体验很独特。网上评价两极分化，有人说是前所未有的艺术革新，也有人说是哗众取宠。要不要周末一起去体验一下？」""",
+            "explanation": "这个场景通过新型艺术体验，反映个体对创新事物的接受程度和尝试意愿。"
+        },
+        "场景2": {
+            "scenario": """在一节创意写作课上，老师提出了一个特别的作业：
+
+老师：「下周的作业是用AI写作工具协助创作一篇小说。你们可以自由探索如何与AI合作，打破传统写作方式。」
+
+班上随即展开了激烈讨论，有人认为这是对创作的亵渎，也有人对这种新形式感到兴奋。""",
+            "explanation": "通过新技术应用场景，观察个体对创新学习方式的态度。"
+        },
+        "场景3": {
+            "scenario": """在社交媒体上，你看到一个朋友分享了一种新的生活方式：
+
+「最近我在尝试'数字游牧'生活，就是一边远程工作一边环游世界。没有固定住所，住青旅或短租，认识来自世界各地的朋友。虽然有时会很不稳定，但这种自由的生活方式真的很棒！」
+
+评论区里争论不断，有人向往这种生活，也有人觉得太冒险。""",
+            "explanation": "通过另类生活方式，观察个体对非传统选择的态度。"
+        },
+        "场景4": {
+            "scenario": """你的恋人突然提出了一个想法：
+
+恋人：「我们要不要尝试一下开放式关系？就是在保持彼此关系的同时，也允许和其他人发展感情。现在国外很多年轻人都这样。」
+
+这个提议让你感到意外，你之前从未考虑过这种可能性。""",
+            "explanation": "通过感情观念场景，观察个体对非传统关系模式的接受度。"
+        },
+        "场景5": {
+            "scenario": """在一次朋友聚会上，大家正在讨论未来职业规划：
+
+朋友A：「我准备辞职去做自媒体，专门介绍一些小众的文化和艺术。」
+
+朋友B：「我想去学习生物科技，准备转行做人造肉研发。」
+
+朋友C：「我在考虑加入一个区块链创业项目，虽然风险很大。」""",
+            "explanation": "通过职业选择场景，观察个体对新兴领域的探索意愿。"
+        }
+    },
+    
+    "宜人性": {
+        "场景1": {
+            "scenario": """在回家的公交车上，你遇到这样一幕：
+
+一位老奶奶颤颤巍巍地上了车，车上座位已经坐满了。她站在你旁边，看起来很疲惫。这时你听到前排两个年轻人的对话：
+
+年轻人A：「那个老太太好像站不稳，看起来挺累的。」
+
+年轻人B：「现在的老年人真是...我看她包里还有菜，肯定是去菜市场买完菜回来的，这么多人都不知道叫子女开车接送。」
+
+就在这时，老奶奶一个趔趄，差点摔倒。她扶住了扶手，但包里的东西洒了一些出来。""",
+            "explanation": "这个场景通过公共场合的助人情境，体现个体的同理心和对他人需求的关注程度。"
+        },
+        "场景2": {
+            "scenario": """在班级群里，有同学发起为生病住院的同学捐款：
+
+同学A：「大家好，小林最近得了重病住院，医药费很贵，家里负担很重。我们要不要一起帮帮他？」
+
+同学B：「我觉得这是他家里的事，我们不方便参与吧。」
+
+同学C：「但是都是同学一场，帮帮忙也是应该的。」""",
+            "explanation": "通过同学互助场景，观察个体的助人意愿和同理心。"
+        },
+        "场景3": {
+            "scenario": """在一个网络讨论组里，有人发布了求助信息：
+
+求助者：「最近心情很低落，感觉生活很压抑，不知道该怎么办...」
+
+评论区里已经有一些回复：
+「生活本来就是这样，想开点！」
+「你这样子太消极了，要积极面对。」
+「谁还没点烦心事啊，过段时间就好了。」""",
+            "explanation": "通过网络互助场景，观察个体的共情能力和安慰方式。"
+        },
+        "场景4": {
+            "scenario": """你的恋人向你倾诉工作压力：
+
+恋人：「最近工作真的好累，感觉快坚持不下去了...」
+
+但今天你也遇到了很多烦心事，心情也不太好。""",
+            "explanation": "通过感情关系场景，观察个体在自身状态不佳时的关怀能力。"
+        },
+        "场景5": {
+            "scenario": """在一次团队项目中，新来的同事小王因为经验不足，造成了一个严重的错误。在部门会议上：
+
+主管：「这个错误造成了很大的损失，是谁负责的这部分？」
+
+小王看起来很紧张，欲言又止。你知道是他造成的错误，同时你也是这个项目的共同负责人。""",
+            "explanation": "通过职场情境，观察个体在面对他人过错时的态度和处理方式。"
+        }
+    }
+}
+
+def get_scene_by_factor(factor: str) -> Dict:
+    """
+    根据人格因子获取对应的情景测试
+    
+    Args:
+        factor (str): 人格因子名称
+        
+    Returns:
+        Dict: 包含情景描述的字典
+    """
+    return PERSONALITY_SCENES.get(factor, None)
+
+def get_all_scenes() -> Dict:
+    """
+    获取所有情景测试
+    
+    Returns:
+        Dict: 所有情景测试的字典
+    """
+    return PERSONALITY_SCENES
diff --git a/src/plugins/personality/看我.txt b/src/plugins/personality/看我.txt
new file mode 100644
index 000000000..d5d6f8903
--- /dev/null
+++ b/src/plugins/personality/看我.txt
@@ -0,0 +1 @@
+那是以后会用到的妙妙小工具.jpg
\ No newline at end of file
diff --git a/src/plugins/willing/mode_classical.py b/src/plugins/willing/mode_classical.py
index 6ba778808..75237a525 100644
--- a/src/plugins/willing/mode_classical.py
+++ b/src/plugins/willing/mode_classical.py
@@ -54,7 +54,7 @@ class WillingManager:
 
         self.chat_reply_willing[chat_id] = min(current_willing, 3.0)
 
-        reply_probability = min(max((current_willing - 0.5), 0.03) * config.response_willing_amplifier * 2, 1)
+        reply_probability = min(max((current_willing - 0.5), 0.01) * config.response_willing_amplifier * 2, 1)
 
         # 检查群组权限（如果是群聊）
         if chat_stream.group_info and config:
diff --git a/template/bot_config_template.toml b/template/bot_config_template.toml
index 07db0890f..ec2b5fbd4 100644
--- a/template/bot_config_template.toml
+++ b/template/bot_config_template.toml
@@ -16,7 +16,7 @@ version = "0.0.10"
 [bot]
 qq = 123
 nickname = "麦麦"
-alias_names = ["小麦", "阿麦"]
+alias_names = ["麦叠", "牢麦"]
 
 [personality]
 prompt_personality = [
@@ -37,7 +37,7 @@ thinking_timeout = 120 # 麦麦思考时间
 
 response_willing_amplifier = 1 # 麦麦回复意愿放大系数，一般为1
 response_interested_rate_amplifier = 1 # 麦麦回复兴趣度放大系数,听到记忆里的内容时放大系数
-down_frequency_rate = 3.5 # 降低回复频率的群组回复意愿降低系数
+down_frequency_rate = 3 # 降低回复频率的群组回复意愿降低系数 除法
 ban_words = [
     # "403","张三"
     ]
@@ -126,27 +126,14 @@ ban_user_id = []  #禁止回复消息的QQ号
 enable = true
 
 
-#V3
-#name = "deepseek-chat"
-#base_url = "DEEP_SEEK_BASE_URL"
-#key = "DEEP_SEEK_KEY"
-
-#R1
-#name = "deepseek-reasoner"
-#base_url = "DEEP_SEEK_BASE_URL"
-#key = "DEEP_SEEK_KEY"
-
 #下面的模型若使用硅基流动则不需要更改，使用ds官方则改成.env.prod自定义的宏，使用自定义模型则选择定位相似的模型自己填写
-
 #推理模型：
-
 [model.llm_reasoning] #回复模型1 主要回复模型
 name = "Pro/deepseek-ai/DeepSeek-R1"
 provider = "SILICONFLOW"
 pri_in = 0 #模型的输入价格（非必填，可以记录消耗）
 pri_out = 0 #模型的输出价格（非必填，可以记录消耗）
 
-
 [model.llm_reasoning_minor] #回复模型3 次要回复模型
 name = "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
 provider = "SILICONFLOW"
diff --git a/麦麦开始学习.bat b/麦麦开始学习.bat
index f7391150f..f96d7cfdc 100644
--- a/麦麦开始学习.bat
+++ b/麦麦开始学习.bat
@@ -1,17 +1,27 @@
 @echo off
+chcp 65001 > nul
 setlocal enabledelayedexpansion
-chcp 65001
 cd /d %~dp0
 
-echo =====================================
-echo 选择Python环境:
-echo 1 - venv (推荐)
-echo 2 - conda
-echo =====================================
-choice /c 12 /n /m "输入数字(1或2): "
+title 麦麦学习系统
+
+cls
+echo ======================================
+echo    警告提示
+echo ======================================
+echo  1.这是一个demo系统,不完善不稳定,仅用于体验/不要塞入过长过大的文本,这会导致信息提取迟缓
+echo ======================================
+
+echo.
+echo ======================================
+echo    请选择Python环境:
+echo    1 - venv (推荐)
+echo    2 - conda
+echo ======================================
+choice /c 12 /n /m "请输入数字选择(1或2): "
 
 if errorlevel 2 (
-    echo =====================================
+    echo ======================================
     set "CONDA_ENV="
     set /p CONDA_ENV="请输入要激活的 conda 环境名称: "
     
@@ -35,11 +45,12 @@ if errorlevel 2 (
     if exist "venv\Scripts\python.exe" (
         venv\Scripts\python src/plugins/zhishi/knowledge_library.py
     ) else (
-        echo =====================================
+        echo ======================================
         echo 错误: venv环境不存在，请先创建虚拟环境
         pause
         exit /b 1
     )
 )
+
 endlocal
 pause