diff --git a/src/chat/planner_actions/action_manager.py b/src/chat/planner_actions/action_manager.py
index 4c2cada69..87aca9f88 100644
--- a/src/chat/planner_actions/action_manager.py
+++ b/src/chat/planner_actions/action_manager.py
@@ -220,7 +220,7 @@ class ChatterActionManager:
 
                 return {"action_type": "no_reply", "success": True, "reply_text": "", "command": ""}
 
-            elif action_name != "reply" and action_name != "no_action":
+            elif action_name != "reply" and action_name != "respond" and action_name != "no_action":
                 # 执行普通动作
                 success, reply_text, command = await self._handle_action(
                     chat_stream,
@@ -248,13 +248,38 @@ class ChatterActionManager:
                     "command": command,
                 }
             else:
-                # 生成回复
+                # 生成回复 (reply 或 respond)
+                # reply: 针对单条消息的回复，使用 s4u 模板
+                # respond: 对未读消息的统一回应，使用 normal 模板
                 try:
+                    # 根据动作类型确定提示词模式
+                    prompt_mode = "s4u" if action_name == "reply" else "normal"
+                    
+                    # 将prompt_mode传递给generate_reply
+                    action_data_with_mode = (action_data or {}).copy()
+                    action_data_with_mode["prompt_mode"] = prompt_mode
+                    
+                    # 只传递当前正在执行的动作，而不是所有可用动作
+                    # 这样可以让LLM明确知道"已决定执行X动作"，而不是"有这些动作可用"
+                    current_action_info = self._using_actions.get(action_name)
+                    current_actions: dict[str, Any] = {action_name: current_action_info} if current_action_info else {}
+                    
+                    # 附加目标消息信息（如果存在）
+                    if target_message:
+                        # 提取目标消息的关键信息
+                        target_msg_info = {
+                            "message_id": getattr(target_message, "message_id", ""),
+                            "sender": getattr(target_message.user_info, "user_nickname", "") if hasattr(target_message, "user_info") else "",
+                            "content": getattr(target_message, "processed_plain_text", ""),
+                            "time": getattr(target_message, "time", 0),
+                        }
+                        current_actions["_target_message"] = target_msg_info
+                    
                     success, response_set, _ = await generator_api.generate_reply(
                         chat_stream=chat_stream,
                         reply_message=target_message,
-                        action_data=action_data or {},
-                        available_actions=self.get_using_actions(),
+                        action_data=action_data_with_mode,
+                        available_actions=current_actions,  # type: ignore
                         enable_tool=global_config.tool.enable_tool,
                         request_type="chat.replyer",
                         from_plugin=False,
@@ -267,15 +292,19 @@ class ChatterActionManager:
                             msg_text = "未知消息"
 
                         logger.info(f"对 {msg_text} 的回复生成失败")
-                        return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None}
+                        return {"action_type": action_name, "success": False, "reply_text": "", "loop_info": None}
                 except asyncio.CancelledError:
                     logger.debug(f"{log_prefix} 并行执行：回复生成任务已被取消")
-                    return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None}
+                    return {"action_type": action_name, "success": False, "reply_text": "", "loop_info": None}
 
                 # 从action_data中提取should_quote_reply参数
                 should_quote_reply = None
                 if action_data and isinstance(action_data, dict):
                     should_quote_reply = action_data.get("should_quote_reply", None)
+                
+                # respond动作默认不引用回复，保持对话流畅
+                if action_name == "respond" and should_quote_reply is None:
+                    should_quote_reply = False
 
                 # 发送并存储回复
                 loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(
@@ -290,15 +319,15 @@ class ChatterActionManager:
                 )
 
                 # 记录回复动作到目标消息（改为同步等待）
-                await self._record_action_to_message(chat_stream, "reply", target_message, action_data)
+                await self._record_action_to_message(chat_stream, action_name, target_message, action_data)
 
                 if clear_unread_messages:
-                    await self._clear_all_unread_messages(chat_stream.stream_id, "reply")
+                    await self._clear_all_unread_messages(chat_stream.stream_id, action_name)
 
                 # 回复成功，重置打断计数（改为同步等待）
                 await self._reset_interruption_count_after_action(chat_stream.stream_id)
 
-                return {"action_type": "reply", "success": True, "reply_text": reply_text, "loop_info": loop_info}
+                return {"action_type": action_name, "success": True, "reply_text": reply_text, "loop_info": loop_info}
 
         except Exception as e:
             logger.error(f"{log_prefix} 执行动作时出错: {e}")
diff --git a/src/chat/replyer/default_generator.py b/src/chat/replyer/default_generator.py
index 1f6aabac4..e389a0528 100644
--- a/src/chat/replyer/default_generator.py
+++ b/src/chat/replyer/default_generator.py
@@ -69,14 +69,7 @@ def init_prompt():
 {keywords_reaction_prompt}
 {moderation_prompt}
 不要复读你前面发过的内容，意思相近也不行。
-不要浮夸，不要夸张修辞，平淡且不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )，只输出一条回复就好。
-
-**【！！！绝对禁止！！！】在回复中输出任何格式化标记**：
-- **核心原则**: 你的回复**只能**包含纯粹的口语化文本。任何看起来像程序指令、系统提示或格式标签的内容都**绝对不允许**出现在你的回复里。
-- **禁止模仿系统消息**: 绝对禁止输出任何类似 `[回复<xxx>：xxx]`、`[表情包：xxx]`、`[图片：xxx]` 的格式。这些都是系统用于展示消息的方式，不是你应该说的话。
-- **禁止模仿动作指令**: 绝对禁止输出 `[戳了戳]` 或 `[poke]`。这类互动由名为 `poke_user` 的特殊动作处理，不是文本消息。
-- **正确提及用户**: 如果想提到某人，直接说“你”或他/她的名字，绝对禁止使用 `[回复<某人>]` 或 `@某人` 的格式。
-- **正确表达情绪**: 如果想表达笑的情绪，直接说“哈哈”、“嘻嘻”等，绝对禁止使用 `[表情包：笑哭]` 这样的文字。
+不要浮夸，不要夸张修辞，平淡且不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at，[xx：xxx]系统格式化文字或 @等 )，只输出一条回复就好。
 
 *你叫{bot_name}，也有人叫你{bot_nickname}*
 
@@ -138,19 +131,13 @@ def init_prompt():
 ## 规则
 {safety_guidelines_block}
 
+注意：在规划回复时，务必确定对方是不是真的在叫自己。聊天时往往有数百甚至数千个用户，请务必认清自己的身份和角色，避免误以为对方在和自己对话而贸然插入回复，导致尴尬局面。
 你的回复应该是一条简短、完整且口语化的回复。
 
  --------------------------------
 {time_block}
 
-请注意不要输出多余内容(包括前后缀，冒号和引号，at或 @等 )。只输出回复内容。
-
-**【！！！绝对禁止！！！】在回复中输出任何格式化标记**：
-- **核心原则**: 你的回复**只能**包含纯粹的口语化文本。任何看起来像程序指令、系统提示或格式标签的内容都**绝对不允许**出现在你的回复里。
-- **禁止模仿系统消息**: 绝对禁止输出任何类似 `[回复<xxx>：xxx]`、`[表情包：xxx]`、`[图片：xxx]` 的格式。这些都是系统用于展示消息的方式，不是你应该说的话。
-- **禁止模仿动作指令**: 绝对禁止输出 `[戳了戳]` 或 `[poke]`。这类互动由名为 `poke_user` 的特殊动作处理，不是文本消息。
-- **正确提及用户**: 如果想提到某人，直接说“你”或他/她的名字，绝对禁止使用 `[回复<某人>]` 或 `@某人` 的格式。
-- **正确表达情绪**: 如果想表达笑的情绪，直接说“哈哈”、“嘻嘻”等，绝对禁止使用 `[表情包：笑哭]` 这样的文字。
+请注意不要输出多余内容(包括前后缀，冒号和引号，at，[xx：xxx]系统格式化文字或 @等 )。只输出回复内容。
 
 {moderation_prompt}
 
@@ -177,60 +164,66 @@ If you need to use the search tool, please directly call the function "lpmm_sear
         name="lpmm_get_knowledge_prompt",
     )
 
-    # normal 版 prompt 模板（0.9之前的简化模式）
+    # normal 版 prompt 模板（参考 s4u 格式，用于统一回应未读消息）
     logger.debug("[Prompt模式调试] 正在注册normal_style_prompt模板")
     Prompt(
         """
-{chat_scene}
+# 人设：{identity}
 
-**重要：消息针对性判断**
-在回应之前，首先分析消息的针对性：
-1. **直接针对你**：@你、回复你、明确询问你 → 必须回应
-2. **间接相关**：涉及你感兴趣的话题但未直接问你 → 谨慎参与
-3. **他人对话**：与你无关的私人交流 → 通常不参与
-4. **重复内容**：他人已充分回答的问题 → 避免重复
+## 当前状态
+- 你现在的心情是：{mood_state}
+{schedule_block}
 
-{expression_habits_block}
-{tool_info_block}
-{knowledge_prompt}
-{memory_block}
-{relation_info_block}
-{extra_info_block}
+## 历史记录
+### 📜 已读历史消息
+{read_history_prompt}
 
 {cross_context_block}
-{identity}
-如果有人说你是人机，你可以用一种阴阳怪气的口吻来回应
-{schedule_block}
+
+### 📬 未读历史消息
+{unread_history_prompt}
+
+{notice_block}
+
+## 表达方式
+- *你需要参考你的回复风格：*
+{reply_style}
+{keywords_reaction_prompt}
+
+{expression_habits_block}
+
+{tool_info_block}
+
+{knowledge_prompt}
+
+## 其他信息
+{memory_block}
+{relation_info_block}
+
+{extra_info_block}
+{auth_role_prompt_block}
 
 {action_descriptions}
 
-下面是群里最近的聊天内容：
---------------------------------
+## 任务
+
+*{chat_scene}*
+
+### 核心任务
+- 你需要对以上未读历史消息进行统一回应。这些消息可能来自不同的参与者，你需要理解整体对话动态，生成一段自然、连贯的回复。
+- 你的回复应该能够推动对话继续，可以回应其中一个或多个话题，也可以提出新的观点。
+
+## 规则
+{safety_guidelines_block}
+注意：在规划回复时，务必确定对方是不是真的在叫自己。聊天时往往有数百甚至数千个用户，请务必认清自己的身份和角色，避免误以为对方在和自己对话而贸然插入回复，导致尴尬局面。
+你的回复应该是一条简短、完整且口语化的回复。
+
+ --------------------------------
 {time_block}
-{chat_info}
---------------------------------
 
-{reply_target_block}
-
-你现在的心情是：{mood_state}
-{config_expression_style}
-注意不要复读你前面发过的内容，意思相近也不行。
-{keywords_reaction_prompt}
-请注意不要输出多余内容(包括前后缀，冒号和引号，at或 @等 )。只输出回复内容。
-
-**【！！！绝对禁止！！！】在回复中输出任何格式化标记**：
-- **核心原则**: 你的回复**只能**包含纯粹的口语化文本。任何看起来像程序指令、系统提示或格式标签的内容都**绝对不允许**出现在你的回复里。
-- **禁止模仿系统消息**: 绝对禁止输出任何类似 `[回复<xxx>：xxx]`、`[表情包：xxx]`、`[图片：xxx]` 的格式。这些都是系统用于展示消息的方式，不是你应该说的话。
-- **禁止模仿动作指令**: 绝对禁止输出 `[戳了戳]` 或 `[poke]`。这类互动由名为 `poke_user` 的特殊动作处理，不是文本消息。
-- **正确提及用户**: 如果想提到某人，直接说“你”或他/她的名字，绝对禁止使用 `[回复<某人>]` 或 `@某人` 的格式。
-- **正确表达情绪**: 如果想表达笑的情绪，直接说“哈哈”、“嘻嘻”等，绝对禁止使用 `[表情包：笑哭]` 这样的文字。
+请注意不要输出多余内容(包括前后缀，冒号和引号，at，[xx：xxx]系统格式化文字或 @等 )。只输出回复内容。
 
 {moderation_prompt}
-你的核心任务是针对 {reply_target_block} 中提到的内容，{relation_info_block}生成一段紧密相关且能推动对话的回复。你的回复应该：
-1.  明确回应目标消息，而不是宽泛地评论。
-2.  可以分享你的看法、提出相关问题，或者开个合适的玩笑。
-3.  目的是让对话更有趣、更深入。
-最终请输出一条简短、完整且口语化的回复。
 
 *你叫{bot_name}，也有人叫你{bot_nickname}*
 
@@ -364,6 +357,15 @@ class DefaultReplyer:
             available_actions = {}
         llm_response = None
         try:
+            # 从available_actions中提取prompt_mode（由action_manager传递）
+            # 如果没有指定，默认使用s4u模式
+            prompt_mode_value: str = "s4u"
+            if available_actions and "_prompt_mode" in available_actions:
+                mode = available_actions.get("_prompt_mode", "s4u")
+                # 确保类型安全
+                if isinstance(mode, str):
+                    prompt_mode_value = mode
+            
             # 构建 Prompt
             with Timer("构建Prompt", {}):  # 内部计时器，可选保留
                 prompt = await self.build_prompt_reply_context(
@@ -372,6 +374,7 @@ class DefaultReplyer:
                     available_actions=available_actions,
                     enable_tool=enable_tool,
                     reply_message=reply_message,
+                    prompt_mode=prompt_mode_value,  # 传递prompt_mode
                 )
 
             if not prompt:
@@ -1127,6 +1130,7 @@ class DefaultReplyer:
         available_actions: dict[str, ActionInfo] | None = None,
         enable_tool: bool = True,
         reply_message: DatabaseMessages | None = None,
+        prompt_mode: str = "s4u",  # 新增参数：s4u 或 normal
     ) -> str:
         """
         构建回复器上下文
@@ -1138,6 +1142,7 @@ class DefaultReplyer:
             enable_timeout: 是否启用超时处理
             enable_tool: 是否启用工具调用
             reply_message: 回复的原始消息
+            prompt_mode: 提示词模式，"s4u"（针对单条消息回复）或"normal"（统一回应未读消息）
 
         Returns:
             str: 构建好的上下文
@@ -1218,14 +1223,41 @@ class DefaultReplyer:
 
         target = await replace_user_references_async(target, chat_stream.platform, replace_bot_name=True)
 
-        # 构建action描述 (如果启用planner)
+        # 构建action描述（告诉回复器已选取的动作）
         action_descriptions = ""
         if available_actions:
-            action_descriptions = "以下是系统中可用的动作列表。**【重要】**这些动作将由一个独立的决策模型决定是否执行，**并非你的职责**。你只需要了解这些能力的存在，以便更好地理解对话情景，**严禁**在你的回复中模仿、调用或提及这些动作本身。\n"
-            for action_name, action_info in available_actions.items():
-                action_description = action_info.description
-                action_descriptions += f"- {action_name}: {action_description}\n"
-            action_descriptions += "\n"
+            # 过滤掉特殊键（以_开头）
+            action_items = {k: v for k, v in available_actions.items() if not k.startswith("_")}
+            
+            # 提取目标消息信息（如果存在）
+            target_msg_info = available_actions.get("_target_message")  # type: ignore
+            
+            if action_items:
+                if len(action_items) == 1:
+                    # 单个动作
+                    action_name, action_info = list(action_items.items())[0]
+                    action_desc = action_info.description
+                    
+                    # 构建基础决策信息
+                    action_descriptions = f"## 决策信息\n\n你已经决定要执行 **{action_name}** 动作（{action_desc}）。\n\n"
+                    
+                    # 如果有目标消息信息，添加目标消息详情
+                    if target_msg_info and isinstance(target_msg_info, dict):
+                        import time as time_module
+                        sender = target_msg_info.get("sender", "未知用户")
+                        content = target_msg_info.get("content", "")
+                        msg_time = target_msg_info.get("time", 0)
+                        time_str = time_module.strftime("%H:%M:%S", time_module.localtime(msg_time)) if msg_time else "未知时间"
+                        
+                        action_descriptions += f"**目标消息**: {time_str} {sender} 说: {content}\n\n"
+                else:
+                    # 多个动作
+                    action_descriptions = "## 决策信息\n\n你已经决定同时执行以下动作：\n\n"
+                    for action_name, action_info in action_items.items():
+                        action_desc = action_info.description
+                        action_descriptions += f"- **{action_name}**: {action_desc}\n"
+                    action_descriptions += "\n"
+
 
         # 从内存获取历史消息，避免重复查询数据库
         from src.plugin_system.apis.chat_api import get_chat_manager
@@ -1426,7 +1458,7 @@ class DefaultReplyer:
                         duration_minutes = (now - start_time).total_seconds() / 60
                         remaining_minutes = (end_time - now).total_seconds() / 60
                         schedule_block = (
-                                f"你当前正在进行“{activity}”，"
+                                f"- 你当前正在进行“{activity}”，"
                                 f"计划时间从{start_time.strftime('%H:%M')}到{end_time.strftime('%H:%M')}。"
                                 f"这项活动已经开始了{duration_minutes:.0f}分钟，"
                                 f"预计还有{remaining_minutes:.0f}分钟结束。"
@@ -1434,9 +1466,9 @@ class DefaultReplyer:
                             )
 
                     except (ValueError, AttributeError):
-                        schedule_block = f"你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)"
+                        schedule_block = f"- 你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)"
                 else:
-                    schedule_block = f"你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)"
+                    schedule_block = f"- 你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)"
 
         moderation_prompt_block = (
             "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。"
@@ -1457,7 +1489,7 @@ class DefaultReplyer:
             if is_group_chat:
                 if sender:
                     reply_target_block = (
-                        f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。"
+                        f"现在{sender}的消息:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。"
                     )
                 elif target:
                     reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。"
@@ -1465,7 +1497,7 @@ class DefaultReplyer:
                     reply_target_block = "现在，你想要在群里发言或者回复消息。"
             else:  # private chat
                 if sender:
-                    reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。"
+                    reply_target_block = f"现在{sender}的消息:{target}。引起了你的注意，针对这条消息回复。"
                 elif target:
                     reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。"
                 else:
@@ -1493,7 +1525,7 @@ class DefaultReplyer:
             available_actions=available_actions,
             enable_tool=enable_tool,
             chat_target_info=self.chat_target_info,
-            prompt_mode="s4u",
+            prompt_mode=prompt_mode,  # 使用传入的prompt_mode参数
             message_list_before_now_long=message_list_before_now_long,
             message_list_before_short=message_list_before_short,
             chat_talking_prompt_short=chat_talking_prompt_short,
@@ -1521,8 +1553,10 @@ class DefaultReplyer:
             bot_nickname=",".join(global_config.bot.alias_names) if global_config.bot.alias_names else "",
         )
 
-        # 使用新的统一Prompt系统 - 使用正确的模板名称
-        template_name = "s4u_style_prompt"
+        # 使用新的统一Prompt系统 - 根据prompt_mode选择模板
+        # s4u: 针对单条消息的深度回复
+        # normal: 对未读消息的统一回应
+        template_name = "s4u_style_prompt" if prompt_mode == "s4u" else "normal_style_prompt"
 
         # 获取模板内容
         template_prompt = await global_prompt_manager.get_prompt_async(template_name)
diff --git a/src/chat/utils/prompt.py b/src/chat/utils/prompt.py
index 5cb437819..e954d6b63 100644
--- a/src/chat/utils/prompt.py
+++ b/src/chat/utils/prompt.py
@@ -513,8 +513,8 @@ class Prompt:
                     context_data[key] = value
 
         # --- 步骤 4: 构建特定模式的上下文和补充基础信息 ---
-        # 为 s4u 模式构建特殊的聊天历史上下文
-        if self.parameters.prompt_mode == "s4u":
+        # 为 s4u 和 normal 模式构建聊天历史上下文
+        if self.parameters.prompt_mode in ["s4u", "normal"]:
             await self._build_s4u_chat_context(context_data)
 
         # 补充所有模式都需要的基础信息
@@ -762,8 +762,10 @@ class Prompt:
         # 根据prompt_mode选择不同的参数准备策略
         if self.parameters.prompt_mode == "s4u":
             params = self._prepare_s4u_params(context_data)
+        elif self.parameters.prompt_mode == "normal":
+            params = self._prepare_normal_params(context_data)
         else:
-            # 当前normal模式和default模式使用相同的参数准备逻辑
+            # 默认模式或其他未指定模式
             params = self._prepare_default_params(context_data)
 
         # 如果prompt有名称，则通过全局管理器格式化（这样可以应用注入逻辑），否则直接格式化
@@ -783,6 +785,7 @@ class Prompt:
             "notice_block": self.parameters.notice_block or context_data.get("notice_block", ""),
             "identity": self.parameters.identity_block or context_data.get("identity", ""),
             "action_descriptions": self.parameters.action_descriptions or context_data.get("action_descriptions", ""),
+            "schedule_block": self.parameters.schedule_block or context_data.get("schedule_block", ""),
             "sender_name": self.parameters.sender or "未知用户",
             "mood_state": self.parameters.mood_prompt or context_data.get("mood_state", ""),
             "read_history_prompt": context_data.get("read_history_prompt", ""),
@@ -812,21 +815,28 @@ class Prompt:
             "relation_info_block": context_data.get("relation_info_block", ""),
             "extra_info_block": self.parameters.extra_info_block or context_data.get("extra_info_block", ""),
             "cross_context_block": context_data.get("cross_context_block", ""),
+            "notice_block": self.parameters.notice_block or context_data.get("notice_block", ""),
             "identity": self.parameters.identity_block or context_data.get("identity", ""),
             "action_descriptions": self.parameters.action_descriptions or context_data.get("action_descriptions", ""),
             "schedule_block": self.parameters.schedule_block or context_data.get("schedule_block", ""),
             "time_block": context_data.get("time_block", ""),
             "chat_info": context_data.get("chat_info", ""),
             "reply_target_block": context_data.get("reply_target_block", ""),
-            "config_expression_style": global_config.personality.reply_style,
+            "reply_style": global_config.personality.reply_style,
             "mood_state": self.parameters.mood_prompt or context_data.get("mood_state", ""),
+            "read_history_prompt": context_data.get("read_history_prompt", ""),
+            "unread_history_prompt": context_data.get("unread_history_prompt", ""),
             "keywords_reaction_prompt": self.parameters.keywords_reaction_prompt
             or context_data.get("keywords_reaction_prompt", ""),
             "moderation_prompt": self.parameters.moderation_prompt_block or context_data.get("moderation_prompt", ""),
             "safety_guidelines_block": self.parameters.safety_guidelines_block
             or context_data.get("safety_guidelines_block", ""),
+            "auth_role_prompt_block": self.parameters.auth_role_prompt_block
+            or context_data.get("auth_role_prompt_block", ""),
             "chat_scene": self.parameters.chat_scene
             or "你正在一个QQ群里聊天，你需要理解整个群的聊天动态和话题走向，并做出自然的回应。",
+            "bot_name": self.parameters.bot_name,
+            "bot_nickname": self.parameters.bot_nickname,
         }
 
     def _prepare_default_params(self, context_data: dict[str, Any]) -> dict[str, Any]:
@@ -838,6 +848,7 @@ class Prompt:
             "time_block": context_data.get("time_block", ""),
             "chat_info": context_data.get("chat_info", ""),
             "identity": self.parameters.identity_block or context_data.get("identity", ""),
+            "schedule_block": self.parameters.schedule_block or context_data.get("schedule_block", ""),
             "chat_target_2": "",
             "reply_target_block": context_data.get("reply_target_block", ""),
             "raw_reply": self.parameters.target,
diff --git a/src/plugin_system/apis/generator_api.py b/src/plugin_system/apis/generator_api.py
index ef3e974bb..616db0b88 100644
--- a/src/plugin_system/apis/generator_api.py
+++ b/src/plugin_system/apis/generator_api.py
@@ -128,6 +128,18 @@ async def generate_reply(
         if not extra_info and action_data:
             extra_info = action_data.get("extra_info", "")
 
+        # 从action_data中提取prompt_mode
+        prompt_mode = "s4u"  # 默认使用s4u模式
+        if action_data and "prompt_mode" in action_data:
+            prompt_mode = action_data.get("prompt_mode", "s4u")
+        
+        # 将prompt_mode添加到available_actions中（作为特殊键）
+        # 注意：这里我们需要暂时使用类型忽略，因为available_actions的类型定义不支持非ActionInfo值
+        if available_actions is None:
+            available_actions = {}
+        available_actions = available_actions.copy()  # 避免修改原字典
+        available_actions["_prompt_mode"] = prompt_mode  # type: ignore  # 特殊键，用于传递prompt_mode
+
         # 如果action_data中有thinking，添加到extra_info中
         if action_data and (thinking := action_data.get("thinking")):
             if extra_info:
diff --git a/src/plugins/built_in/affinity_flow_chatter/planner/plan_filter.py b/src/plugins/built_in/affinity_flow_chatter/planner/plan_filter.py
index 0ed435ae9..94a7485ee 100644
--- a/src/plugins/built_in/affinity_flow_chatter/planner/plan_filter.py
+++ b/src/plugins/built_in/affinity_flow_chatter/planner/plan_filter.py
@@ -75,16 +75,29 @@ class ChatterPlanFilter:
 
                 if "reply" in plan.available_actions and reply_not_available:
                     # 如果reply动作不可用，但llm返回的仍然有reply，则改为no_reply
-                    if (
-                        isinstance(parsed_json, dict)
-                        and parsed_json.get("actions", {}).get("action_type", "") == "reply"
-                    ):
-                        parsed_json["actions"]["action_type"] = "no_reply"
+                    if isinstance(parsed_json, dict):
+                        actions_obj = parsed_json.get("actions", {})
+                        # actions 可能是字典或列表
+                        if isinstance(actions_obj, dict) and actions_obj.get("action_type", "") == "reply":
+                            parsed_json["actions"]["action_type"] = "no_reply"
+                        elif isinstance(actions_obj, list):
+                            for action_item in actions_obj:
+                                if isinstance(action_item, dict) and action_item.get("action_type", "") == "reply":
+                                    action_item["action_type"] = "no_reply"
+                                    if "reason" in action_item:
+                                        action_item["reason"] += " (但由于兴趣度不足，reply动作不可用，已改为no_reply)"
                     elif isinstance(parsed_json, list):
                         for item in parsed_json:
-                            if isinstance(item, dict) and item.get("actions", {}).get("action_type", "") == "reply":
-                                item["actions"]["action_type"] = "no_reply"
-                                item["actions"]["reason"] += " (但由于兴趣度不足，reply动作不可用，已改为no_reply)"
+                            if isinstance(item, dict):
+                                actions_obj = item.get("actions", {})
+                                if isinstance(actions_obj, dict) and actions_obj.get("action_type", "") == "reply":
+                                    item["actions"]["action_type"] = "no_reply"
+                                elif isinstance(actions_obj, list):
+                                    for action_item in actions_obj:
+                                        if isinstance(action_item, dict) and action_item.get("action_type", "") == "reply":
+                                            action_item["action_type"] = "no_reply"
+                                            if "reason" in action_item:
+                                                action_item["reason"] += " (但由于兴趣度不足，reply动作不可用，已改为no_reply)"
 
                 if isinstance(parsed_json, dict):
                     parsed_json = [parsed_json]
diff --git a/src/plugins/built_in/affinity_flow_chatter/planner/planner.py b/src/plugins/built_in/affinity_flow_chatter/planner/planner.py
index 587378f2a..8d5b3baad 100644
--- a/src/plugins/built_in/affinity_flow_chatter/planner/planner.py
+++ b/src/plugins/built_in/affinity_flow_chatter/planner/planner.py
@@ -333,16 +333,17 @@ class ChatterActionPlanner:
                     context.processing_message_id = target_message_id
                     logger.debug(f"Normal模式 - 开始处理目标消息: {target_message_id}")
 
-                # 4. 构建回复动作（Normal模式的简化流程）
+                # 4. 构建回复动作（Normal模式使用respond动作）
                 from src.common.data_models.info_data_model import ActionPlannerInfo, Plan
                 from src.plugin_system.base.component_types import ChatType
 
                 # 构建目标消息字典 - 使用 flatten() 方法获取扁平化的字典
                 target_message_dict = target_message.flatten()
 
-                reply_action = ActionPlannerInfo(
-                    action_type="reply",
-                    reasoning="Normal模式 - 兴趣度达到阈值，直接回复（简化流程）",
+                # Normal模式使用respond动作，表示统一回应未读消息
+                respond_action = ActionPlannerInfo(
+                    action_type="respond",
+                    reasoning="Normal模式 - 兴趣度达到阈值，使用respond动作统一回应未读消息",
                     action_data={"target_message_id": target_message.message_id},
                     action_message=target_message,
                     should_quote_reply=False,  # Normal模式默认不引用回复，保持对话流畅
@@ -354,14 +355,14 @@ class ChatterActionPlanner:
                     chat_id=self.chat_id,
                     chat_type=ChatType.PRIVATE if not context else context.chat_type,
                     mode=ChatMode.NORMAL,
-                    decided_actions=[reply_action],
+                    decided_actions=[respond_action],
                 )
 
-                # 5. 执行reply动作
+                # 5. 执行respond动作
                 execution_result = await self.executor.execute(minimal_plan)
                 self._update_stats_from_execution_result(execution_result)
 
-                logger.info("Normal模式 - 执行reply动作完成")
+                logger.info("Normal模式 - 执行respond动作完成")
 
                 # 6. 更新兴趣计算器状态（回复成功，重置不回复计数）
                 await self._update_interest_calculator_state(replied=True)
@@ -374,7 +375,7 @@ class ChatterActionPlanner:
                 # 8. 检查是否需要退出Normal模式
                 await self._check_exit_normal_mode(context)
 
-                return [asdict(reply_action)], target_message_dict
+                return [asdict(respond_action)], target_message_dict
             else:
                 # 未达到reply阈值
                 logger.debug("Normal模式 - 未达到reply阈值，不执行回复")
diff --git a/src/plugins/built_in/affinity_flow_chatter/planner/planner_prompts.py b/src/plugins/built_in/affinity_flow_chatter/planner/planner_prompts.py
index 212c15f9d..7dbdd07d6 100644
--- a/src/plugins/built_in/affinity_flow_chatter/planner/planner_prompts.py
+++ b/src/plugins/built_in/affinity_flow_chatter/planner/planner_prompts.py
@@ -43,29 +43,30 @@ def init_prompts():
 
 # 目标
 你的任务是根据当前对话，给出一个或多个动作，构成一次完整的响应组合。
-- 主要动作：通常是 reply（如需回复）。
+- 主要动作：通常是 reply或respond（如需回复）。
 - 辅助动作（可选）：如 emoji、poke_user 等，用于增强表达。
 
 # 决策流程
 1. 已读仅供参考，不能对已读执行任何动作。
 2. 目标消息必须来自未读历史，并使用其前缀 <m...> 作为 target_message_id。
-3. **【重要】兴趣度优先原则**：每条未读消息后都标注了 [兴趣度: X.XXX]，数值越高表示该消息越值得你关注和回复。在选择回复目标时，**应优先选择兴趣度高的消息**（通常 ≥0.5 表示较高兴趣），除非有特殊情况（如被直接@或提问）。
+3. 兴趣度优先原则：每条未读消息后都标注了 [兴趣度: X.XXX]，数值越高表示该消息越值得你关注和回复。在选择回复目标时，**应优先选择兴趣度高的消息**（通常 ≥0.5 表示较高兴趣），除非有特殊情况（如被直接@或提问）。
 4. 优先级：
    - 直接针对你：@你、回复你、点名提问、引用你的消息。
    - **兴趣度高的消息**：兴趣度 ≥0.5 的消息应优先考虑回复。
    - 与你强相关的话题或你熟悉的问题。
    - 其他与上下文弱相关的内容最后考虑。
 {mentioned_bonus}
-4. 多目标：若多人同时需要回应，请在 actions 中并行生成多个 reply，每个都指向各自的 target_message_id。
-5. **【核心规则】处理无上下文的纯表情包**: 对不含任何实质文本、且无紧密上下文互动的纯**表情包**消息（如消息内容仅为“[表情包：xxxxx]”），应默认选择 `no_action`。
-6. **【！！！绝对禁止！！！】处理失败消息**: 绝不能回复任何指示媒体内容（图片、表情包等）处理失败的消息。如果消息中出现如“[表情包(描述生成失败)]”或“[图片(描述生成失败)]”等文字，必须将其视为系统错误提示，并立即选择`no_action`。
-6. 风格：保持人设一致；避免重复你说过的话；避免冗余和口头禅。
+5. 多目标：若多人同时需要回应，请在 actions 中并行生成多个 reply，每个都指向各自的 target_message_id。
+6. 处理无上下文的纯表情包: 对不含任何实质文本、且无紧密上下文互动的纯**表情包**消息（如消息内容仅为“[表情包：xxxxx]”），应默认选择 `no_action`。
+7. 处理失败消息: 绝不能回复任何指示媒体内容（图片、表情包等）处理失败的消息。如果消息中出现如“[表情包(描述生成失败)]”或“[图片(描述生成失败)]”等文字，必须将其视为系统错误提示，并立即选择`no_action`。
+8. 正确决定回复时机: 在决定reply或respond前，务必评估当前对话氛围和上下文连贯性。避免在不合适的时机（如对方情绪低落、话题不相关等,对方并没有和你对话,贸然插入会很令人讨厌等）进行回复，以免打断对话流或引起误解。如判断当前不适合回复，请选择`no_action`。
+9. 认清自己的身份和角色: 在规划回复时，务必确定对方是不是真的在叫自己。聊天时往往有数百甚至数千个用户，请务必认清自己的身份和角色，避免误以为对方在和自己对话而贸然插入回复，导致尴尬局面。
 
 # 思绪流规范（thinking）
 - 真实、自然、非结论化，像给自己看的随笔。
 - 描述你看到/想到/感觉到的过程，不要出现"因此/我决定"等总结词。
 - 直接使用对方昵称，而不是 <m1>/<m2> 这样的标签。
-- **禁止出现"兴趣度、分数"等技术术语或内部实现细节**。兴趣度仅用于你内部的决策权重，不要在thinking中提及，而应该用自然语言描述你对消息的感受（如"这个话题挺有意思的"、"我对这个很感兴趣"等）。
+- 禁止出现"兴趣度、分数"等技术术语或内部实现细节。兴趣度仅用于你内部的决策权重，不要在thinking中提及，而应该用自然语言描述你对消息的感受（如"这个话题挺有意思的"、"我对这个很感兴趣"等）。
 
 ## 可用动作列表
 {action_options_text}
@@ -77,12 +78,10 @@ def init_prompts():
     "thinking": "在这里写下你的思绪流...",
     "actions": [
         {{
-            "action_type": "reply",
+            "action_type": "respond",
             "reasoning": "选择该动作的理由",
             "action_data": {{
-                "target_message_id": "m123",
                 "content": "你的回复内容",
-                "should_quote_reply": false
             }}
         }}
     ]
@@ -116,21 +115,6 @@ def init_prompts():
 }}
 ```
 
-# 引用回复控制（should_quote_reply）
-在群聊中回复消息时，你可以通过 `should_quote_reply` 参数控制是否引用原消息：
-- **true**: 明确引用原消息（适用于需要明确指向特定消息时，如回答问题、回应多人之一、回复较早的消息）
-- **false**: 不引用原消息（适用于自然对话流、接续最新话题、轻松闲聊等场景）
-- **不填写**: 系统将自动决定（默认不引用，让对话更流畅）
-
-**【重要】默认策略：大多数情况下应该使用 `false` 以保持对话自然流畅**
-
-**使用建议**：
-- 当对话自然流畅、你的回复是接续最新话题时，**建议明确设为 `false`** 以避免打断对话节奏
-- 当需要明确回复某个特定用户或特定问题时，设为 `true` 以帮助定位
-- 当群聊中多人同时发言，你要回复其中一个较早的消息（非最新消息）时，设为 `true`
-- 当有人直接@你或明确向你提问时，可以考虑设为 `true` 表明你在回复他
-- 私聊场景**必须**设为 `false` 或不填（因为只有两个人，引用是多余的）
-
 # 强制规则
 - 需要目标消息的动作（reply/poke_user/set_emoji_like 等），必须提供准确的 target_message_id（来自未读历史里的 <m...> 标签）。
 - 当动作需要额外参数时，必须在 action_data 中补全。
diff --git a/src/plugins/built_in/core_actions/plugin.py b/src/plugins/built_in/core_actions/plugin.py
index def36beff..3b1c7a014 100644
--- a/src/plugins/built_in/core_actions/plugin.py
+++ b/src/plugins/built_in/core_actions/plugin.py
@@ -16,6 +16,7 @@ from src.plugin_system.base.config_types import ConfigField
 
 # 导入API模块 - 标准Python包方式
 from src.plugins.built_in.core_actions.emoji import EmojiAction
+from src.plugins.built_in.core_actions.reply import ReplyAction, RespondAction
 
 logger = get_logger("core_actions")
 
@@ -52,7 +53,8 @@ class CoreActionsPlugin(BasePlugin):
             "config_version": ConfigField(type=str, default="0.6.0", description="配置文件版本"),
         },
         "components": {
-            "enable_reply": ConfigField(type=bool, default=True, description="是否启用基本回复动作"),
+            "enable_reply": ConfigField(type=bool, default=True, description="是否启用 reply 动作（s4u模板）"),
+            "enable_respond": ConfigField(type=bool, default=True, description="是否启用 respond 动作（normal模板）"),
             "enable_emoji": ConfigField(type=bool, default=True, description="是否启用发送表情/图片动作"),
         },
     }
@@ -62,6 +64,16 @@ class CoreActionsPlugin(BasePlugin):
 
         # --- 根据配置注册组件 ---
         components: ClassVar = []
+        
+        # 注册 reply 动作
+        if self.get_config("components.enable_reply", True):
+            components.append((ReplyAction.get_action_info(), ReplyAction))
+        
+        # 注册 respond 动作
+        if self.get_config("components.enable_respond", True):
+            components.append((RespondAction.get_action_info(), RespondAction))
+        
+        # 注册 emoji 动作
         if self.get_config("components.enable_emoji", True):
             components.append((EmojiAction.get_action_info(), EmojiAction))
 
diff --git a/src/plugins/built_in/core_actions/reply.py b/src/plugins/built_in/core_actions/reply.py
new file mode 100644
index 000000000..993ddb85a
--- /dev/null
+++ b/src/plugins/built_in/core_actions/reply.py
@@ -0,0 +1,108 @@
+"""
+回复动作模块
+
+定义了两种回复动作：
+- reply: 针对单条消息的深度回复（使用 s4u 模板）
+- respond: 对未读消息的统一回应（使用 normal 模板）
+"""
+
+from typing import ClassVar
+
+from src.common.logger import get_logger
+from src.plugin_system import ActionActivationType, BaseAction, ChatMode
+
+logger = get_logger("reply_actions")
+
+
+class ReplyAction(BaseAction):
+    """Reply动作 - 针对单条消息的深度回复
+    
+    特点：
+    - 使用 s4u (Speak for You) 模板
+    - 专注于理解和回应单条消息的具体内容
+    - 适合 Focus 模式下的精准回复
+    """
+    
+    # 动作基本信息
+    action_name = "reply"
+    action_description = "针对特定消息进行精准回复。深度理解并回应单条消息的具体内容。需要指定目标消息ID。"
+    
+    # 激活设置
+    activation_type = ActionActivationType.ALWAYS  # 回复动作总是可用
+    mode_enable = ChatMode.ALL  # 在所有模式下都可用
+    parallel_action = False  # 回复动作不能与其他动作并行
+    
+    # 动作参数定义
+    action_parameters: ClassVar = {
+        "target_message_id": "要回复的目标消息ID（必需，来自未读消息的 <m...> 标签）",
+        "content": "回复的具体内容（可选，由LLM生成）",
+        "should_quote_reply": "是否引用原消息（可选，true/false，默认false。群聊中回复较早消息或需要明确指向时使用true）",
+    }
+    
+    # 动作使用场景
+    action_require: ClassVar = [
+        "需要针对特定消息进行精准回复时使用",
+        "适合单条消息的深度理解和回应",
+        "必须提供准确的 target_message_id（来自未读历史的 <m...> 标签）",
+        "私聊场景必须使用此动作（不支持 respond）",
+        "群聊中需要明确回应某个特定用户或问题时使用",
+        "关注单条消息的具体内容和上下文细节",
+    ]
+    
+    # 关联类型
+    associated_types: ClassVar[list[str]] = ["text"]
+    
+    async def execute(self) -> tuple[bool, str]:
+        """执行reply动作
+        
+        注意：实际的回复生成由 action_manager 统一处理
+        这里只是标记使用 reply 动作（s4u 模板）
+        """
+        logger.info(f"{self.log_prefix} 使用 reply 动作（s4u 模板）")
+        return True, ""
+
+
+class RespondAction(BaseAction):
+    """Respond动作 - 对未读消息的统一回应
+    
+    特点：
+    - 关注整体对话动态和未读消息的统一回应
+    - 适合对于群聊消息下的宏观回应
+    - 避免与单一用户深度对话而忽略其他用户的消息
+    """
+    
+    # 动作基本信息
+    action_name = "respond"
+    action_description = "统一回应所有未读消息。理解整体对话动态和话题走向，生成连贯的回复。无需指定目标消息。"
+    
+    # 激活设置
+    activation_type = ActionActivationType.ALWAYS  # 回应动作总是可用
+    mode_enable = ChatMode.ALL  # 在所有模式下都可用
+    parallel_action = False  # 回应动作不能与其他动作并行
+    
+    # 动作参数定义
+    action_parameters: ClassVar = {
+        "content": "回复的具体内容（可选，由LLM生成）",
+    }
+    
+    # 动作使用场景
+    action_require: ClassVar = [
+        "需要统一回应多条未读消息时使用（Normal 模式专用）",
+        "适合理解整体对话动态而非单条消息",
+        "不需要指定 target_message_id，会自动处理所有未读消息",
+        "关注对话流程、话题走向和整体氛围",
+        "适合群聊中的自然对话流，无需精确指向特定消息",
+        "可以同时回应多个话题或参与者",
+    ]
+    
+    # 关联类型
+    associated_types: ClassVar[list[str]] = ["text"]
+    
+    async def execute(self) -> tuple[bool, str]:
+        """执行respond动作
+        
+        注意：实际的回复生成由 action_manager 统一处理
+        这里只是标记使用 respond 动作（normal 模板）
+        """
+        logger.info(f"{self.log_prefix} 使用 respond 动作（normal 模板）")
+        return True, ""