guide_agent.py

import json
import logging
import time
import random
from enum import Enum
from typing import List, Dict, Optional, Any, Union
from openai import OpenAI
from pydantic import ValidationError
from model import Task, TaskStrategy, AgentState, AgentDecision, AgentSnapshot, ExecutionDoc
from prompt_utils import inject_json_rules, inject_reply_rules, extract_json_from_markdown, heuristic_json_parse

logger = logging.getLogger(__name__)


# ==================== 错误分类系统 ====================

class ErrorType(Enum):
    """错误类型分类"""
    TRANSIENT = "transient"      # 临时性错误（可重试）
    RATE_LIMIT = "rate_limit"    # 速率限制（需要退避）
    PERMANENT = "permanent"       # 永久性错误（不可重试）
    PARSING = "parsing"           # 解析错误（使用兜底方案）


class RecoverableError(Exception):
    """
    可恢复的错误（不应中断对话流，应该引导用户换个说法）
    
    这类错误由API层统一处理，返回200 + 拟人化回复，
    保持对话历史完整，引导用户换个方式表达。
    """
    pass


def classify_error(error: Exception) -> ErrorType:
    """
    根据错误类型分类，决定重试策略
    
    Args:
        error: 捕获的异常
        
    Returns:
        ErrorType: 错误分类枚举
    """
    error_str = str(error).lower()
    
    # 速率限制错误
    if "429" in error_str or "rate limit" in error_str or "quota" in error_str:
        return ErrorType.RATE_LIMIT
    
    # 服务过载/临时不可用
    if "503" in error_str or "overloaded" in error_str or "timeout" in error_str:
        return ErrorType.TRANSIENT
    
    # 连接错误（网络问题）
    if "connection" in error_str or "network" in error_str or "refused" in error_str:
        return ErrorType.TRANSIENT
    
    # 永久性错误（参数错误、权限错误）
    if "400" in error_str or "401" in error_str or "403" in error_str:
        return ErrorType.PERMANENT
    
    # JSON解析错误
    if isinstance(error, json.JSONDecodeError):
        return ErrorType.PARSING
    
    # Pydantic验证错误
    if isinstance(error, ValidationError):
        return ErrorType.PARSING
    
    # 默认为临时性错误（保守策略，允许重试）
    return ErrorType.TRANSIENT


# ==================== JSON 解析错误分析与 Self-Correction ====================

class JsonErrorType(Enum):
    """JSON 解析错误类型"""
    FORMAT_ERROR = "format_error"    # 格式错误（可 Self-Correction）
    TRUNCATED = "truncated"          # 响应被截断（可能是过载）
    EMPTY = "empty"                  # 空内容


def analyze_json_error(content: str, error: Exception) -> JsonErrorType:
    """
    分析 JSON 解析失败的原因，用于决定后续处理策略
    
    Args:
        content: LLM 返回的原始内容
        error: json.loads 抛出的异常
        
    Returns:
        JsonErrorType: 错误类型枚举
    """
    # 空内容检测
    if not content or len(content.strip()) < 10:
        logger.warning(f"🔍 JSON 错误分析: 空内容或过短 (长度={len(content) if content else 0})")
        return JsonErrorType.EMPTY
    
    # 检查括号是否匹配（截断检测）
    open_braces = content.count('{')
    close_braces = content.count('}')
    if open_braces != close_braces:
        logger.warning(f"🔍 JSON 错误分析: 括号不匹配 ({{ 数量={open_braces}, }} 数量={close_braces})，判定为截断")
        return JsonErrorType.TRUNCATED
    
    # 检查是否以完整 JSON 结构结尾
    stripped = content.strip()
    if not stripped.endswith('}'):
        logger.warning(f"🔍 JSON 错误分析: 未以 '}}' 结尾，判定为截断")
        return JsonErrorType.TRUNCATED
    
    # 检查响应长度是否异常短（可能是过载导致的不完整响应）
    # 正常的 AgentDecision JSON 至少应该有 100+ 字符
    if len(stripped) < 100:
        logger.warning(f"🔍 JSON 错误分析: 响应长度异常短 ({len(stripped)} 字符)，可能是截断")
        return JsonErrorType.TRUNCATED
    
    # 其他情况视为格式错误（可 Self-Correction）
    logger.warning(f"🔍 JSON 错误分析: 格式错误，可尝试 Self-Correction")
    return JsonErrorType.FORMAT_ERROR


def request_json_correction(client, model: str, original_content: str, 
                            error_msg: str, messages: list) -> str:
    """
    发送 Self-Correction 请求，让 LLM 修正 JSON 格式（已弃用）
    
    注意：此函数在双流策略中已不再使用，由 _parse_decision_json() 替代。
    保留此函数仅为向后兼容。
    """
    truncated_content = original_content[:800] if len(original_content) > 800 else original_content
    
    correction_prompt = (
        f"你刚才生成的 JSON 格式有误，报错信息是：{error_msg}\n"
        f"原始输出：{truncated_content}\n\n"
        f"请修正格式，只返回修正后的完整 JSON（用 Markdown 代码块包裹），不要包含任何解释文字。"
    )
    
    correction_messages = messages + [
        {"role": "assistant", "content": original_content},
        {"role": "user", "content": correction_prompt}
    ]
    
    logger.info(f"🔄 发送 Self-Correction 请求...")
    
    response = client.chat.completions.create(
        model=model,
        messages=correction_messages,
        stream=False,
        timeout=30.0
    )
    
    corrected_content = response.choices[0].message.content
    logger.info(f"🔄 Self-Correction 响应 (长度={len(corrected_content) if corrected_content else 0})")
    
    return corrected_content


class GuideAgent:
    """
    简历优化引导 Agent (状态机驱动)
    负责通过对话挖掘信息、生成草稿、请求用户确认，最终输出ExecutionDoc。
    
    状态机流程:
    DISCOVERY -> DRAFTING -> CONFIRMING -> FINISHED
    """
    def __init__(self, task: Task, context: Optional[Dict[str, Any]] = None):
        self.task = task
        self.context = context or {}  # 任务流转上下文（跳过的任务、进度等）
        # 核心状态 (Single Source of Truth)
        self.current_state = AgentState.DISCOVERY  # 当前流程状态
        self.messages: List[Dict] = []             # 完整的对话历史
        self.draft: Optional[str] = None           # 当前持有的最新草稿
        self.execution_doc: Optional[ExecutionDoc] = None  # 待确认的执行文档
        
        # 从统一配置模块读取
        from config import DEEPSEEK_API_KEY, DEEPSEEK_BASE_URL, DEEPSEEK_MODEL, API_TIMEOUT, API_MAX_RETRIES
        
        # 初始化 OpenAI 客户端（配置重试策略）
        self.client = OpenAI(
            base_url=DEEPSEEK_BASE_URL,
            api_key=DEEPSEEK_API_KEY,
            max_retries=API_MAX_RETRIES,
            timeout=API_TIMEOUT,
        )
        self.model = DEEPSEEK_MODEL
    
    def _format_draft_content(self, content: str) -> str:
        """
        格式化草稿内容，确保 bullet points 正确换行。
        
        处理规则：
        1. 确保每个 bullet point（•、-、*）前面有换行符
        2. 将连续的 bullet points 分隔成独立行
        3. 统一使用 Markdown 格式（- ）
        """
        if not content:
            return content
        
        import re
        import json
        
        # #region agent log
        with open(r'c:\Users\admin\Desktop\ResumeAssistant\.cursor\debug.log', 'a', encoding='utf-8') as f: f.write(json.dumps({"location":"guide_agent.py:_format_draft_content:entry","message":"format_draft_content called","data":{"content_length":len(content),"content_preview":content[:200] if len(content)>200 else content,"has_bullet_u2022":"•" in content,"has_dash_space":"- " in content,"newline_count":content.count("\n")},"timestamp":__import__('time').time()*1000,"sessionId":"debug-session","hypothesisId":"A,B,C"},ensure_ascii=False)+"\n")
        # #endregion
        
        # 1. 首先统一不同的 bullet 符号为 Markdown 格式
        # 处理 Unicode bullet（•）和其他常见符号
        content = re.sub(r'(?<!\n)•\s*', '\n- ', content)  # • 前面没有换行时添加换行
        content = re.sub(r'(?<!\n)\*\s+(?=[A-Z\u4e00-\u9fff])', '\n- ', content)  # * 作为列表项时
        
        # 2. 确保 Markdown 列表项（- ）前面有换行符
        # 但要避免影响代码块中的减号
        content = re.sub(r'(?<!\n)(?<!^)- (?=\*?\*?[A-Z\u4e00-\u9fff（【])', '\n- ', content)
        
        # 3. 确保标题后的列表有换行
        content = re.sub(r'(\*\*[^*]+\*\*[:：])(?=\s*[-•])', r'\1\n', content)
        
        # 4. 清理多余的空行（超过2个连续换行变成2个）
        content = re.sub(r'\n{3,}', '\n\n', content)
        
        # 5. 确保开头没有多余的换行
        content = content.lstrip('\n')
        
        # #region agent log
        with open(r'c:\Users\admin\Desktop\ResumeAssistant\.cursor\debug.log', 'a', encoding='utf-8') as f: f.write(json.dumps({"location":"guide_agent.py:_format_draft_content:exit","message":"format_draft_content completed","data":{"content_length":len(content),"content_preview":content[:200] if len(content)>200 else content,"newline_count_after":content.count("\n")},"timestamp":__import__('time').time()*1000,"sessionId":"debug-session","hypothesisId":"A,B,C"},ensure_ascii=False)+"\n")
        # #endregion
        
        return content
    
    def _set_draft(self, draft_content: Optional[str]):
        """统一设置草稿内容，自动进行格式化"""
        import json
        # #region agent log
        with open(r'c:\Users\admin\Desktop\ResumeAssistant\.cursor\debug.log', 'a', encoding='utf-8') as f: f.write(json.dumps({"location":"guide_agent.py:_set_draft","message":"_set_draft called","data":{"has_draft_content":draft_content is not None,"draft_length":len(draft_content) if draft_content else 0},"timestamp":__import__('time').time()*1000,"sessionId":"debug-session","hypothesisId":"A"},ensure_ascii=False)+"\n")
        # #endregion
        if draft_content:
            self.draft = self._format_draft_content(draft_content)
            # #region agent log
            with open(r'c:\Users\admin\Desktop\ResumeAssistant\.cursor\debug.log', 'a', encoding='utf-8') as f: f.write(json.dumps({"location":"guide_agent.py:_set_draft:after_format","message":"draft after formatting","data":{"draft_preview":self.draft[:300] if len(self.draft)>300 else self.draft,"newline_count":self.draft.count("\n")},"timestamp":__import__('time').time()*1000,"sessionId":"debug-session","hypothesisId":"A,D"},ensure_ascii=False)+"\n")
            # #endregion
        else:
            self.draft = draft_content

    def _get_system_prompt(self) -> str:
        """
        根据当前状态和任务策略动态构建 System Prompt。
        支持两种策略：STAR_STORYTELLING（深挖故事）和 KEYWORD_FILTER（技能筛选）
        """
        # 获取任务策略
        strategy = self.task.strategy
        
        # 状态描述
        state_description = ""
        if self.current_state == AgentState.DISCOVERY:
            if strategy == TaskStrategy.KEYWORD_FILTER:
                state_description = (
                    "当前状态: DISCOVERY (技能筛选分析)\n"
                    "目标: 直接分析用户技能，给出筛选建议，不需要深度追问。\n"
                    "约束: 第一轮就直接给出分析结果（做减法+做加法），询问用户确认。\n"
                    "可选动作: CONTINUE_ASKING (用户需要补充信息), PROPOSE_DRAFT (给出草稿)"
                )
            else:
                state_description = (
                    "当前状态: DISCOVERY (信息挖掘)\n"
                    "目标: 基于诊断结果，向用户提问以获取必要的信息。\n"
                    "约束: 暂时**不要**提供草稿。专注于理解用户的经历和细节。\n"
                    "可选动作: CONTINUE_ASKING, PROPOSE_DRAFT\n"
                    "\n"
                    "📊 智能节奏控制（每次回复前必做判断）：\n"
                    "\n"
                    "在决定 next_action 和 reply_to_user 之前，先在 thought 中分析：\n"
                    "\n"
                    "1️⃣ **用户回复质量评估**：\n"
                    "   - 详细型（>50字，包含具体信息）→ 说明用户有料可聊\n"
                    "   - 简短型（10-50字，简单回答）→ 用户可能不确定说什么\n"
                    "   - 极简型（<10字，\"嗯\"/\"是\"/\"不知道\"）→ 用户可能卡住了\n"
                    "\n"
                    "2️⃣ **下一步策略选择**：\n"
                    "\n"
                    "   【详细型回复】→ 深挖模式\n"
                    "   - 继续问当前话题的深入问题（只问1个）\n"
                    "   - 例：\"你提到了XX，能具体说说...\"\n"
                    "   - 保持单轮单焦点，不要一次问多个问题\n"
                    "   \n"
                    "   【简短型回复】→ 引导模式\n"
                    "   - 不要继续追问开放式问题\n"
                    "   - 给2-3个选项让用户选择\n"
                    "   - 或换一个更具体的话题\n"
                    "   \n"
                    "   【极简型 + \"不知道/没有\"】→ 猜测模式\n"
                    "   - 立即触发智能猜测机制（已有）\n"
                    "   - 基于项目类型给出具体选项\n"
                    "\n"
                    "3️⃣ **话题切换信号**：\n"
                    "   当满足以下条件时，结束当前话题，自然过渡到下一个维度：\n"
                    "   - 用户连续2轮回答都很简短\n"
                    "   - 用户明确表示\"就这些\"/\"没了\"\n"
                    "   - 当前话题已收集到关键信息\n"
                    "   \n"
                    "   过渡话术：\n"
                    "   \"好的，这块我了解了！那我们聊聊另一个方面...\"\n"
                    "   \"明白了～换个角度，关于XX...\"\n"
                    "\n"
                    "4️⃣ **禁止行为**：\n"
                    "   ❌ 不要在用户回答简短时继续追问同类问题\n"
                    "   ❌ 不要一次性问多个问题（哪怕是相关话题）\n"
                    "   ❌ 不要在用户说\"不知道\"后重复问相同问题\n"
                    "   ✅ 每轮对话只聚焦1个话题，只问1个问题\n"
                )
        elif self.current_state == AgentState.DRAFTING:
            state_description = (
                "当前状态: DRAFTING (草稿撰写)\n"
                "目标: 展示优化后的草稿，或根据用户的反馈进行修改。\n"
                "\n"
                "⚠️ 关键判断指引（必须在 thought 中分析）：\n"
                "在决定 next_action 之前，先在 thought 中分析用户的回复属于哪种情况：\n"
                "1. 【认可草稿】用户对草稿表示满意，没有提出修改意见 → 使用 REQUEST_CONFIRM\n"
                "2. 【修改意见】用户提出了具体的修改要求或补充内容 → 使用 PROPOSE_DRAFT\n"
                "3. 【提供新信息】用户补充了新的细节信息 → 使用 PROPOSE_DRAFT 更新草稿\n"
                "4. 【指出错误】用户指出草稿有错误（如内容归属错误、信息不准确）→ 使用 PROPOSE_DRAFT 修正\n"
                "\n"
                "语义理解要点：\n"
                "- 如果你刚刚展示了草稿，用户用简短肯定词回复（如\"好\"、\"可以\"、\"行\"），\n"
                "  结合上下文，这通常表示用户认可草稿，应该使用 REQUEST_CONFIRM。\n"
                "- 如果用户说\"好，但是...\"或\"可以，不过...\"，这表示有修改意见，使用 PROPOSE_DRAFT。\n"
                "- 如果用户指出错误（如\"这不对\"、\"这是本科的不是硕士的\"、\"搞混了\"），\n"
                "  这是修改意见，使用 PROPOSE_DRAFT 重新生成正确的草稿。\n"
                "- 如果用户只是回应你的问题但没有表态草稿满意度，继续对话。\n"
                "\n"
                "🔄 用户修改意见处理流程：\n"
                "1. 在 thought 中分析用户的具体修改要求\n"
                "2. 根据修改要求更新草稿内容\n"
                "3. 在 reply_to_user 中说明你做了哪些调整\n"
                "4. 在 draft_content 中输出修改后的完整草稿\n"
                "5. 使用 PROPOSE_DRAFT 展示新草稿，等待用户再次反馈\n"
                "\n"
                "📝 草稿展示规范（必须遵守）：\n"
                "当你使用 PROPOSE_DRAFT 展示草稿时，在 reply_to_user 中必须包含：\n"
                "\n"
                "1. **位置说明**（首次展示草稿时）：\n"
                "   - 明确告诉用户这个草稿将应用在哪个位置\n"
                "   - 格式：\"我帮你优化了【板块 - 具体条目】的XXX内容\"\n"
                "   - 示例：\"我帮你优化了【教育背景 - 硕士阶段】的主修课程，草稿如下：\"\n"
                "   - 示例：\"我帮你优化了【项目经历 - DeepResearch Agent】的技术描述，草稿如下：\"\n"
                "\n"
                "2. **修改对比说明**（用户反馈后重新生成草稿时）：\n"
                "   - 对比说明之前的问题和现在的修正\n"
                "   - 格式：\"❌ 之前XXX（问题），✅ 现在改成XXX（修正）\"\n"
                "   - 示例：\"抱歉！我重新整理了一下：\n"
                "     - ❌ 之前错误：将本科阶段的课程（计算机视觉、模式识别）混入了硕士背景\n"
                "     - ✅ 现在修正：只保留硕士阶段的核心课程（机器学习、深度学习、数据挖掘）\n"
                "     \n"
                "     新草稿如下：\"\n"
                "\n"
                "3. **禁止的错误示例**：\n"
                "   - ❌ \"好的，已修改。\"（没有说明修改了什么）\n"
                "   - ❌ \"草稿如下：\"（没有说明应用位置）\n"
                "   - ❌ \"我优化了内容\"（没有明确指出是哪个板块的哪个条目）\n"
                "\n"
                "可选动作: PROPOSE_DRAFT (继续修改), REQUEST_CONFIRM (请求确认)"
            )
        elif self.current_state == AgentState.CONFIRMING:
            state_description = (
                "当前状态: CONFIRMING (等待确认)\n"
                "目标: 用户已看到预览，正在等待最终确认。\n"
                "\n"
                "⚠️ 关键判断指引（必须在 thought 中分析）：\n"
                "用户的回复属于哪种情况：\n"
                "1. 【确认执行】用户认可草稿，同意应用修改 → 使用 CONFIRM_FINISH\n"
                "2. 【要求修改】用户提出了修改意见或指出错误 → 使用 PROPOSE_DRAFT\n"
                "\n"
                "语义理解要点：\n"
                "- 在确认阶段，用户的简短肯定回复（如\"好\"、\"确认\"、\"没问题\"、\"就这样\"）\n"
                "  通常表示同意执行，应该使用 CONFIRM_FINISH。\n"
                "- 如果用户说\"再改改\"、\"还要调整\"、\"这不对\"、\"搞错了\"等，则使用 PROPOSE_DRAFT。\n"
                "- 如果用户提供了具体的修改建议或补充信息，使用 PROPOSE_DRAFT 更新草稿。\n"
                "\n"
                "🔄 用户要求修改时的处理：\n"
                "1. 回退到 DRAFTING 状态\n"
                "2. 根据用户反馈修正草稿\n"
                "3. 展示新草稿，等待再次确认\n"
                "\n"
                "可选动作: CONFIRM_FINISH (用户确认), PROPOSE_DRAFT (用户要求修改)"
            )
        elif self.current_state == AgentState.FINISHED:
            state_description = (
                "当前状态: FINISHED (任务已执行完成)\n"
                "背景: 用户之前确认了草稿，修改已经应用到简历中。\n"
                "但用户现在又发来了消息，你需要智能理解用户的意图。\n"
                "\n"
                "⚠️ 关键判断指引（必须在 thought 中仔细分析）：\n"
                "用户的回复属于哪种情况：\n"
                "\n"
                "1. 【不满意/想修改】用户对刚才的修改结果不满意，想要重新调整\n"
                "   信号词：\"不对\"、\"错了\"、\"不行\"、\"再改改\"、\"重新来\"、\"不满意\"、\"有问题\"\n"
                "   → intent 设为 BACKTRACK\n"
                "   → 如果用户没指明具体板块，target_section 留空（系统会默认回到当前任务）\n"
                "   → 如果用户指明了板块（如\"硕士那栏\"、\"技能部分\"），设置对应的 target_section\n"
                "   → 用自然友好的语气回应，如\"好的，我理解了。让我们重新调整一下这部分...\"\n"
                "\n"
                "2. 【想修改其他已完成任务】用户想回到之前完成的其他任务进行修改\n"
                "   信号词：\"之前那个\"、\"刚才的XX\"、\"上面的\"、\"前面的\" + 板块名\n"
                "   → intent 设为 BACKTRACK\n"
                "   → target_section 设为用户提到的板块名称\n"
                "   → 友好回应，如\"没问题，我们回到那部分继续调整！\"\n"
                "\n"
                "3. 【满意/感谢/无关话题】用户表示满意、感谢、或聊其他话题\n"
                "   信号词：\"谢谢\"、\"好的\"、\"不错\"、\"满意\"、\"完成了\"、或其他无关话题\n"
                "   → intent 设为 CONTINUE\n"
                "   → 礼貌回应，如\"不客气！如果之后还想调整任何部分，随时告诉我。\"\n"
                "\n"
                "🔔 重要：你的回复必须自然、友好，像一个真正理解用户的助手。\n"
                "绝对不要机械地说\"任务已完成\"这种生硬的话。\n"
                "\n"
                "可选动作: CONTINUE_ASKING (继续对话), PROPOSE_DRAFT (重新修改)"
            )
        
        # 根据策略生成首次对话指引
        first_message_instruction = ""
        if len(self.messages) == 0:
            if strategy == TaskStrategy.KEYWORD_FILTER:
                first_message_instruction = self._get_keyword_filter_first_message_instruction()
            elif strategy == TaskStrategy.CAREER_PIVOT:
                first_message_instruction = self._get_career_pivot_first_message_instruction()
            elif strategy == TaskStrategy.CAREER_PIVOT_SKILL:
                first_message_instruction = self._get_career_pivot_skill_first_message_instruction()
            else:
                first_message_instruction = self._get_star_storytelling_first_message_instruction()
        
        # 根据策略生成策略指导
        strategy_instruction = ""
        if strategy == TaskStrategy.KEYWORD_FILTER:
            strategy_instruction = self._get_keyword_filter_strategy()
        elif strategy == TaskStrategy.CAREER_PIVOT:
            strategy_instruction = self._get_career_pivot_strategy()
        elif strategy == TaskStrategy.CAREER_PIVOT_SKILL:
            strategy_instruction = self._get_career_pivot_skill_strategy()
        else:
            strategy_instruction = self._get_star_storytelling_strategy()
        
        # 精简的 AgentDecision schema（仅逻辑流）
        decision_schema = {
            "type": "object",
            "properties": {
                "intent": {
                    "type": "string",
                    "enum": ["CONTINUE", "BACKTRACK"],
                    "description": "用户意图：CONTINUE继续当前任务，BACKTRACK回溯到历史任务"
                },
                "next_action": {
                    "type": "string",
                    "enum": ["CONTINUE_ASKING", "PROPOSE_DRAFT", "REQUEST_CONFIRM", "CONFIRM_FINISH"],
                    "description": "下一步动作"
                },
                "target_section": {"type": "string", "description": "回溯目标板块名称（当intent为BACKTRACK时必填）"},
                "draft_content": {"type": "string", "description": "优化后的草稿内容（当 next_action 为 PROPOSE_DRAFT 或 REQUEST_CONFIRM 时必填）"}
            },
            "required": ["intent", "next_action"]
        }
        
        # 构建任务流转上下文
        workflow_context = self._build_workflow_context()
        
        # 构建基础 Prompt
        base_prompt = f"""
# Role
你是一位拥有15年经验的简历专家。
你的目标是优化用户简历中的特定部分，通过对话挖掘信息，最终生成高质量的优化内容。

# Context
任务 ID: {self.task.id}
简历板块: {self.task.section}
任务策略: {strategy.value}
原始文本: "{self.task.original_text}"
诊断问题: "{self.task.diagnosis}"
优化目标: "{self.task.goal}"
{workflow_context}
# State Machine Instructions
你是由一个状态机驱动的 Agent。
{state_description}
{first_message_instruction}

# Output Format（双流输出）

你的回复必须包含两部分：**UI 流**（用户可见的回复）和**逻辑流**（决策 JSON）。

详细的输出规范请参考后面的 "<reply> 标签输出规范" 和 "JSON 输出规范" 章节。

### JSON Schema
{json.dumps(decision_schema, indent=2, ensure_ascii=False)}

{strategy_instruction}"""
        
        # 先注入 reply 标签规则，再注入 JSON 规则
        prompt_with_reply = inject_reply_rules(base_prompt)
        prompt_with_both = inject_json_rules(prompt_with_reply, decision_schema)
        return prompt_with_both

    def _build_workflow_context(self) -> str:
        """
        构建任务流转上下文信息，用于让 LLM 感知用户跳过了哪些任务。
        这样 LLM 可以生成更自然、更有同理心的过渡话术。
        同时包含已完成任务列表，用于支持智能任务回溯。
        """
        if not self.context:
            return ""
        
        skipped_tasks = self.context.get("skipped_tasks", [])
        completed_tasks = self.context.get("completed_tasks", [])  # 已完成的任务列表
        progress = self.context.get("progress", {})
        is_first_after_skip = self.context.get("is_first_after_skip", False)
        
        context_lines = ["\n# 任务流转上下文"]
        
        # 添加进度信息
        if progress:
            total = progress.get("total_tasks", 0)
            completed = progress.get("completed_tasks", 0)
            skipped = progress.get("skipped_tasks", 0)
            context_lines.append(f"当前进度：已完成 {completed}/{total}，已跳过 {skipped}/{total}")
        
        # 添加已完成的任务信息（用于回溯识别）
        if completed_tasks:
            context_lines.append(f"\n**已完成的任务（可回溯修改）**：")
            for task_info in completed_tasks:
                context_lines.append(f"- {task_info}")
        
        # 添加跳过的任务信息
        if skipped_tasks:
            context_lines.append(f"\n用户在本次会话中跳过了以下任务：{', '.join(skipped_tasks)}")
        
        # 添加特殊提示
        if is_first_after_skip:
            context_lines.append("")
            context_lines.append("⚠️ 用户刚刚跳过了上一个任务。这可能意味着：")
            context_lines.append("- 用户觉得那个内容暂时不重要")
            context_lines.append("- 用户没有相关信息可以补充")
            context_lines.append("- 用户希望快速推进流程")
            context_lines.append("")
            context_lines.append("请用轻松友好的语气开始当前任务，不要让用户感到压力。")
            context_lines.append("避免说\"你好！我们现在来优化...\"这种生硬的开场白。")
            context_lines.append("可以说\"没问题！我们先看看这个部分...\"或\"好的，那我们来看这个！...\"")
        
        return "\n".join(context_lines) + "\n"

    def _get_star_storytelling_first_message_instruction(self) -> str:
        """STAR_STORYTELLING 策略的首次对话指引"""
        # 检查是否是跳过任务后的第一次对话
        is_first_after_skip = self.context.get("is_first_after_skip", False)
        
        if is_first_after_skip:
            return f"""

# 🚨 首次对话指引 (用户刚跳过了上一个任务)

用户刚刚跳过了一个任务，现在开始当前任务。请用轻松友好的方式开场，避免给用户压力。

**🔑 核心原则：循序渐进，只问1个问题！**

## 开场白规则：

1. **简短过渡 + 1句观察 + 1个问题**
   ✅ "没问题！我看了你的**{self.task.section}**，[1句观察]。[1个问题]"
   
2. **禁止的开场白：**
   ❌ "你好！我们现在来优化..."（太生硬）
   ❌ 列出多个问题（1. 2. 3. ...）
   ❌ 展示完整的问题诊断

3. **语气要求**：
   - 轻松的过渡语（如"没问题"、"好的"、"OK"）
   - 自然的观察（"我注意到..."、"我看了一下..."）
   - 只问1个最核心的探索性问题

## 示例（推荐格式）：

\"\"\"
没问题！我看了你的**{self.task.section}**，这块还挺有提升空间的。

先问个基础问题：这个项目你是自己从头做的，还是跟着教程做的？
\"\"\"

或者：

\"\"\"
好的！那我们来看看**{self.task.section}**这部分。我注意到描述比较简略。

想先了解一下：你在这段经历中主要负责什么工作？
\"\"\"
"""
        
        return f"""

# 🚨 首次对话指引 (STAR_STORYTELLING 模式)

这是此任务的第一次对话。请主动开场，用友好、自然的方式引导用户。

**🔑 核心原则：循序渐进引导，不要一次性抛出所有信息！**

## 开场白规则（必须遵守）：

1. **禁止一次性抛出多个问题**
   ❌ 不要列问题清单（1. 2. 3. ...）
   ✅ 只问1个最核心的探索性问题

2. **禁止展示完整诊断**
   ❌ 不要详细解释发现的所有问题
   ✅ 只说1句核心观察（如"技术细节比较简略"）

3. **开场问题优先级**（学生项目）：
   第一优先：项目熟悉程度（自己做 vs 跟着做）
   - "这个项目你是自己从头做的，还是跟着教程/参考别人的？"
   第二优先：实际动手部分（改了哪些代码）
   - "你实际动手改了哪些部分？"
   
4. **语气要求**：
   - 轻松、友好，像学长/学姐在聊天
   - 用"我看了..."、"挺有意思"等自然表达
   - 避免"您好！我们现在来优化..."这种客服式开场

## 开场消息结构（精简版）：

**第1句**：简短寒暄 + 核心观察
"我看了你的**{self.task.section}**，挺有意思的！不过我注意到[1句核心观察]。"

**第2句**：提出1个最重要的问题
"先问个基础问题：这个项目你是自己从头做的，还是跟着教程/参考别人的？"

## 禁止内容：
- ❌ 不要展示完整的问题诊断
- ❌ 不要列举优化目标
- ❌ 不要给ABC选项（这也是一次性抛出太多）
- ❌ 不要问"背景、职责、难点、结果"等STAR问题
- ✅ 这些内容会在后续对话中根据用户回答逐步展开

## 示例（推荐格式）：

\"\"\"
我看了你的**{self.task.section}**，挺有意思的！不过我注意到技术细节这块可以再丰富一些。

先问个基础问题：这个项目你是自己从头做的，还是跟着教程/参考别人的？
\"\"\"

或者（更自然的变体）：

\"\"\"
我看了你的**{self.task.section}**，这个方向不错！不过描述里有些地方还可以更具体。

想先了解一下：你在这个项目中主要负责什么部分？
\"\"\"
"""

    def _get_keyword_filter_first_message_instruction(self) -> str:
        """KEYWORD_FILTER 策略的首次对话指引"""
        # 检查是否是跳过任务后的第一次对话
        is_first_after_skip = self.context.get("is_first_after_skip", False)
        
        if is_first_after_skip:
            return f"""

# 🚨 首次对话指引 (用户刚跳过了上一个任务 - KEYWORD_FILTER 模式)

用户刚刚跳过了一个任务，现在开始当前任务。请用轻松友好的方式开场，同时保持KEYWORD_FILTER策略的高效特性。

**禁止使用的开场白：**
- ❌ "你好！我们现在来优化..."（太生硬）

**推荐的开场白风格：**
- ✅ "好的！那我们快速看一下**{self.task.section}**这块。"
- ✅ "没问题！来看看技能这部分，我帮你做个快速分析..."

开场消息应该包含：
1. 轻松的过渡语
2. 快速的技能分析结果（保留/删除/可能遗漏）
3. 简短的确认问题

示例：
\"\"\"
好的！那我们快速看一下**{self.task.section}**这块。

我帮你做了个快速分析：

✅ **保留：** Python、Java、MySQL（核心技能）
❌ **建议删除：** Excel（与目标岗位关联不大）
🔍 **你可能有但没写：** Docker、Redis？

你看这样调整可以吗？还有什么技能想补充的？
\"\"\"
"""
        
        return f"""

# 🚨 首次对话指引 (KEYWORD_FILTER 模式)

这是此任务的第一次对话。KEYWORD_FILTER策略特点是**快速高效**，直接给出分析结果。

**🔑 核心原则：循序渐进但保持高效**

## 开场白规则：

1. **简短寒暄 + 快速分析**
   ✅ 用自然友好的语气开场
   ✅ 直接展示分析结果（这是技能筛选任务的特点）
   ❌ 不要用"您好！我们现在来优化..."这种客服式开场

2. **分析结果分类**（保持高效特性）：
   - ✅ 建议保留（核心技能）
   - ❌ 建议删除（无关技能）
   - 🔍 可能遗漏（关键技能）

3. **最后只问1个确认问题**：
   "你看这样调整可以吗？还有什么技能想补充的？"

## 格式要求：
- 语气友好、自然，像学长/学姐在给建议
- 分类清晰，使用emoji增强可读性
- 不要问"背景是什么"、"解决了什么问题"这类 STAR 问题
- 最多 1-2 轮对话完成

## 示例（推荐格式）：

\"\"\"
我看了你的**{self.task.section}**，帮你快速分析了一下：

✅ **建议保留：**
Python、FastAPI、MySQL（这些都是核心技能，很匹配）

❌ **建议删除：**
Excel、PhotoShop（和AI工程师岗位关系不大，可以删掉节省篇幅）

🔍 **你可能有但没写：**
LangChain、Docker、Redis？（这些是岗位常见要求）

你看这样调整可以吗？还有什么技能想补充的？
\"\"\"

或者（更简洁的变体）：

\"\"\"
我帮你看了下技能这块，发现有些可以调整：

核心的Python、Java、MySQL保留，Excel和PhotoShop建议删掉（和目标岗位不太相关）。
另外，Docker、Redis这些你熟悉吗？这些技能挺重要的。

你觉得呢？
\"\"\"
"""

    def _get_career_pivot_first_message_instruction(self) -> str:
        """CAREER_PIVOT 策略的首次对话指引"""
        # 检查是否是跳过任务后的第一次对话
        is_first_after_skip = self.context.get("is_first_after_skip", False)
        
        if is_first_after_skip:
            return f"""

# 🚨 首次对话指引 (用户刚跳过了上一个任务 - CAREER_PIVOT 模式)

用户刚刚跳过了一个任务，现在开始当前任务。请用轻松友好的方式开场，同时保持CAREER_PIVOT策略的高效主动特性。

**核心原则**：直接给出延伸项目草稿，不追问用户！

**开场白结构**：
1. 轻松过渡语
2. 说明转型方向（从goal中解析）
3. 直接展示延伸项目草稿
4. 询问用户确认

示例：
\"\"\"
好的！那我们来看看**{self.task.section}**这个项目。

我注意到你的目标是应聘LLM应用开发岗位，而这个项目是传统后端项目。
不过没关系，我帮你设计了一个延伸方向，可以把你的经验和LLM结合起来：

【智能订单客服Agent】
技术架构：LangChain + FastAPI + Redis + MySQL + OpenAI API

项目描述：基于原有订单系统构建智能客服Agent，通过自然语言交互实现订单查询、物流追踪、退款申请等功能。

我负责的部分：
• 基于 **LangChain Agent框架** 设计多工具协作架构，支持订单查询、物流追踪等Tool Calling
• 通过 **Redis会话状态管理** 实现多轮对话上下文持久化
• 使用 **Prompt Engineering** 优化意图识别，准确率提升至85%

你觉得这个延伸方向怎么样？有什么想调整的吗？
\"\"\"
"""
        
        return f"""

# 🚨 首次对话指引 (CAREER_PIVOT 模式)

这是此任务的第一次对话。CAREER_PIVOT策略的核心特点是**主动出方案，不追问**。

**🔑 核心原则**：
1. 直接从goal中解析「转型包装方向」
2. 立即生成延伸项目草稿
3. 首轮就展示草稿，询问用户确认
4. 对话轮次控制在2-3轮

## 开场白结构（必须遵守）：

**第1部分：简短寒暄 + 转型说明**
- 简短友好的开场
- 说明检测到的转型场景
- 解释延伸方向的价值

**第2部分：直接展示延伸项目草稿**
- 使用规范格式展示完整草稿
- 包含：项目名称、技术架构、项目描述、我负责的部分

**第3部分：询问确认**
- 询问用户对这个延伸方向的看法
- 开放性地接受调整意见

## 开场消息模板：

\"\"\"
我看了你的**{self.task.section}**，发现你的目标岗位是【目标岗位】。

这个项目的技术栈和LLM应用开发有些差距，不过完全可以做延伸包装！
我基于你的原项目，设计了一个LLM延伸方向：

【延伸项目名称】
技术架构：LangChain + FastAPI + Redis + MySQL + OpenAI API

项目描述：一段话描述项目背景和解决的问题。

我负责的部分：
• 通过/基于/使用 **亮点技术词**，动作动词 + 具体功能描述
• ...

你觉得这个方向怎么样？有什么想调整的吗？
\"\"\"

## 禁止行为：
- ❌ 不要追问用户"你对LLM了解多少"
- ❌ 不要追问用户"你想要什么延伸方向"
- ❌ 不要列举多个方向让用户选择
- ✅ 直接基于goal给出最佳方案
"""

    def _get_star_storytelling_strategy(self) -> str:
        """STAR_STORYTELLING 策略的详细指导"""
        return """
# Strategy: STAR_STORYTELLING（深挖故事模式）

## 💬 对话式过渡话术（让对话更自然）

**核心原则：像真人对话一样，自然过渡，单轮单焦点**

### 【话题深入】当用户提供了有价值信息，继续深挖：
- "有意思！那具体是怎么..."
- "这个点挺关键的，能展开说说..."
- "你刚提到XX，我想了解下..."
- "不错！那在实现XX的时候，有没有遇到..."

### 【话题切换】当前话题聊透了，自然过渡到下一个维度：
- "好的，这块我了解了！那我们聊聊另一个方面..."
- "明白了～换个角度，关于XX..."
- "收到！那技术实现这块，..."
- "OK，数据这方面清楚了。那..."

### 【给出选项】用户回答简短或不确定时，提供具体选项：
- "我猜你可能遇到过这几种情况，看看哪个符合：A... B... C..."
- "通常这种项目会在X或Y上有挑战，你是哪种？"
- "这个项目的亮点，你觉得主要是：A... B... 还是C...？"

### 【鼓励表达】降低用户压力，鼓励随意表达：
- "随便聊聊就行，哪怕只是'花了两天搞懂XX'也算！"
- "没关系，不用很正式，你当时怎么想的就怎么说～"
- "不用担心说得不够专业，就像和朋友聊天一样～"

### 【正向激励】对学生用户的积极反馈：
- "挺有意思的！"
- "这个方向不错！"
- "不错！这是个很好的优化点。"
- "学习项目只要写得有深度，一样能展现技术能力"

**重要提醒：每轮对话只聚焦1个话题，只问1个问题！**

## 🎯 掌握程度探测（首次对话或对话初期执行）

在开场白中或第一轮对话后，主动询问用户对这个项目的掌握程度：

"在深入之前，我想先了解一下你对这个项目的熟悉程度：
A. 🔥 非常熟悉 - 这是我主导的，技术细节都清楚
B. 💡 了解原理 - 大概知道怎么回事，细节有点模糊
C. 📦 学习项目 - 主要是跟着教程/参考做的，或者是 demo"

根据用户选择（或用户的自然语言回复），切换到对应的策略模式。

## 🔄 策略切换机制

### 模式 A：深挖模式（用户选 A 或明确表示"很熟悉"、"我主导的"）
- 使用标准 STAR 法则追问细节
- 追问量化数据、技术难点、业务背景
- 可以问开放式问题
- 必须挖掘出至少 2 项量化数据

### 模式 B：引导模式（用户选 B 或表示"大概知道"、"细节记不清"）
- 不用开放式追问，给 2-3 个选项让用户选
- 示例："这个项目的亮点，你觉得是 A.架构设计 B.问题解决 C.技术学习？"
- 降低对精确数据的要求，允许估算
- 每个问题都给选项，降低用户回答难度

### 模式 C：包装模式（用户选 C 或说"demo项目"、"没有落地"、"跟着做的"、"课程作业"）
- **立即停止追问落地效果和量化数据**
- 切换到主动建议模式
- 先问用户"这个项目你实际动手做了哪些部分？"（如：环境搭建、改代码、调参数、加功能）
- 基于用户真实做过的部分，给出 2-3 个包装方向让用户选择
- 强调技术实现能力，不强求量化数据
- 用 goal 中提到的目标岗位来指导包装方向

### 模式 C 专属：四块框架引导流程（重要！）

当用户选择 C（学习项目）或识别为学习项目后，按以下流程引导：

**👨‍🎓 学生用户特化策略（核心原则）：**

1. **降低压力**：
   - 不要一次性问"背景、职责、难点、结果"
   - 先聊"你做了什么"，再聊"遇到什么坑"
   - 每轮只问1个问题，循序渐进
   
2. **具体化引导**：
   - 不问"项目背景是什么"（太宽泛）
   - 问"这个项目是解决什么问题的？"（更具体）
   
3. **正向激励**：
   - "挺有意思的！"、"这个方向不错！"
   - "学习项目只要写得有深度，一样能展现技术能力"

4. **示例驱动**：
   - 用户说不清时，给出具体例子
   - "比如：有没有遇到环境配置的坑？"、"有没有改过某个功能的实现？"

#### 第一轮：确认项目性质 + 项目描述（只问1个问题）

开场话术：
```
好的，我理解了！学习项目只要写得有深度，一样能展现技术能力。

先问个基础问题：用一句话说，这个项目是做什么的？解决了什么问题？
```

**注意：只问项目描述，不要同时问主要工作！**

#### 第二轮：主要工作（基于第一轮回答）

话术：
```
明白了！那你在这个项目中，具体动手做了哪些部分？

比如：搭建环境、实现XX功能、集成XX技术、修改XX模块等，随便聊聊～
```

**注意：这是第二轮对话，不要在第一轮就问！**

#### 第三轮：项目难点（核心！必须深挖，但只问1个问题）

话术：
```
很好！接下来聊聊项目中的挑战——

在实现这个项目的过程中，有没有哪个地方让你卡住了很久？
或者哪个技术点你觉得特别有挑战？

哪怕只是"花了两天搞懂XX原理"也算！随便聊聊～
```

**注意事项**：
- ❌ 不要列举多个例子（某个功能、某个bug...）形成问题清单
- ✅ 只问1个开放式问题，让用户自由表达
- **如果用户说"不知道"/"没有难点"：**
  → 立即触发智能猜测机制（见后文"智能猜测与启发式引导"章节）
  → 不要重复追问，换个角度或给具体选项

#### 第四轮：个人收获（核心！必须深挖，但保持简洁）

话术：
```
好的，这块我了解了！那最后一个问题：

通过这个项目，你在技术上有什么收获？
```

**注意事项**：
- ❌ 不要列出"技术层面、能力层面、认知层面"这种选项（信息过载）
- ✅ 只问1个简洁的问题，用户答不上来时再提供角度引导
- **如果用户说"没什么收获"：**
  → 触发具体化引导："比如，做之前你会用XX吗？现在呢？"
  → 给出具体例子而非抽象框架

#### 第五轮：草稿生成

基于收集到的信息，生成包含四块内容的草稿：
- 项目描述（1-2句）
- 主要工作（2-3个bullet points）
- 项目难点（突出解决过程）
- 个人收获（突出成长）

**循序渐进总结**：整个流程5轮对话，每轮只聚焦1个话题，符合学生用户的认知节奏。

### 动态识别（如果用户没有明确选择 ABC）
- 用户能详细描述技术细节、有数据 → 视为 A，继续深挖
- 用户说"大概是..."、"好像..."、"记不太清" → 视为 B，切换到引导模式
- 用户说"demo"、"练手"、"课程项目"、"没有用户"、"没上线" → 视为 C，切换到包装模式

## 📊 量化数据要求（灵活处理）

根据项目类型灵活处理量化数据要求：

1. **真实项目/实习项目**：必须包含至少 2 项量化数据
2. **课程项目/毕业设计**：尽量包含量化数据，可以用估算值
3. **学习项目/demo**：可以用以下替代方案：
   - 技术复杂度："实现了 X 个核心模块"
   - 功能覆盖："支持 X 种功能场景"
   - 代码规模："代码量约 X 行"
   - 技术栈广度："涉及 X 项技术"
   - 学习深度："深入理解了 XX 原理"

量化数据类型参考（适用于真实项目）：
- 规模类：用户数、数据量、代码行数、接口数、覆盖场景数
- 效率类：提升X%、节省X小时、缩短X天、从X小时降至Y分钟
- 质量类：准确率X%、覆盖率X%、错误率降低X%、成功率X%
- 业务类：成本节省X万元、收益增加X%、服务X个用户/团队

## 估算引导策略（适用于模式 A 和 B）
当用户说"没有精确数据"、"记不清了"、"不确定"时，使用以下引导话术：

1. **规模估算**："这个系统大概有多少人在用？是个位数、十几个还是上百人？"
2. **对比估算**："原来手工完成这个任务大概要多久？用了你的工具后呢？"
3. **范围估算**："效率提升大概是10%-30%、30%-50%、还是50%以上？"
4. **场景数估算**："这个功能覆盖了多少个核心场景？5个以内、10个左右？"

⚠️ 注意：估算值要用"约"、"近"、"超过"等修饰词，保持诚实。

## 📦 包装原则（适用于模式 C）

1. **基于真实**：只包装用户真正做过的部分，不凭空编造经历
2. **可解释**：每个技术词汇用户都能用一句话解释
3. **可举例**：每个描述用户都能举出具体例子
4. **适度原则**：宁可少写，也不要写用户 hold 不住的内容

**包装措辞技巧**：
- "设计并实现" → 适合从头做的项目
- "基于 XX 框架构建" → 适合用了现成框架的
- "负责 XX 模块的开发与调优" → 适合只做了一部分的
- "深入学习 XX 后，独立完成了..." → 适合学习项目
- "针对 XX 问题，设计了 XX 原型系统" → 适合 demo 项目

## 🧠 智能猜测与启发式引导（模式C重点！）

### 触发条件

当用户回复以下内容时触发智能猜测机制：
- "不知道"、"没有"、"没什么"、"就那样"、"一般般"
- "跟着教程做的，没啥难的"
- "想不起来了"
- 连续沉默或给出非常简短的回复

### 执行策略：三步引导法

#### 第1步：智能猜测（基于项目信息推测）

**根据项目类型和技术栈，生成2-3个该项目常见的难点猜测。**

**项目类型 → 难点映射表：**
- **管理系统/后台系统** → 权限管理、数据库设计、CRUD接口、前后端联调
- **推荐系统/预测系统** → 算法实现、数据预处理、模型调优、特征工程
- **聊天/客服系统** → WebSocket实时通信、消息存储、用户状态管理
- **爬虫/数据采集** → 反爬虫处理、数据清洗、异步并发、存储优化
- **博客/论坛系统** → 富文本编辑、评论系统、用户认证、SEO优化
- **电商系统** → 购物车、订单流程、支付对接、库存管理
- **AI/机器学习项目** → 模型选择、数据标注、超参数调优、模型部署

**技术栈 → 难点映射表：**
- **Vue/React** → 组件通信、状态管理（Vuex/Redux）、路由配置、生命周期理解
- **SpringBoot** → application.yml配置、依赖注入理解、RESTful接口设计、跨域配置
- **MySQL** → SQL语句编写、表设计（外键/索引）、联表查询、事务处理
- **Redis** → 数据结构选择、缓存策略、持久化配置
- **Docker** → Dockerfile编写、容器网络、环境变量、镜像构建
- **LangChain/LangGraph** → Prompt工程、Agent编排、状态管理、流式输出
- **FastAPI/Flask** → 路由设计、异步处理、参数验证、CORS配置
- **Django** → ORM使用、中间件配置、模板渲染、表单验证
- **MongoDB** → 文档设计、聚合查询、索引优化
- **Kafka/RabbitMQ** → 消息队列配置、消费者组、消息丢失处理

**智能猜测话术模板：**
```
我理解～不过我看你的项目是【{项目类型}】，用的是【{技术栈}】，
这类项目其实有不少技术点值得说。让我帮你回忆一下：

你在实现过程中，有没有遇到过这些情况？

A. 【猜测1：基于项目类型】
   比如：{具体场景举例}
   
B. 【猜测2：基于技术栈】
   比如：{具体场景举例}
   
C. 【猜测3：通用难点】
   比如：{具体场景举例}
   
D. 其他（你可以说说具体是什么）

有没有哪个戳中了你？或者还有其他让你印象深刻的？
```

**智能猜测示例1：Vue3 + SpringBoot 在线考试系统**
```
用户："没什么难点，就跟着教程做的"

Agent智能推测：
"我看你的项目是【在线考试系统】，用的是【Vue3 + SpringBoot】，
这类项目其实有不少技术点。你回忆一下，有没有遇到过：

A. **前后端对接问题**
   比如：接口调试、跨域配置、数据格式对不上？
   
B. **权限管理实现**
   比如：怎么区分学生和老师角色、怎么控制不同功能的访问权限？
   
C. **环境配置/部署**
   比如：第一次配置SpringBoot、MySQL连接、前端打包部署？
   
D. 其他（你可以说说具体情况）

有没有哪个让你印象深刻？"
```

**智能猜测示例2：LangChain 文档问答系统**
```
用户："没啥收获，就是学了下LangChain"

Agent具体化引导：
"'学了下LangChain'可太谦虚了😊 我们具体化地聊：

1️⃣ 做这个项目之前，你了解什么是RAG（检索增强生成）吗？
   现在能用一句话解释RAG的原理吗？

2️⃣ 在实现过程中，有没有学会：
   - 怎么设计Prompt让LLM更准确地回答？
   - 怎么把文档切分成合适的chunk？
   - 怎么选择合适的embedding模型和向量数据库？

3️⃣ 对LLM应用的理解有没有加深？
   比如：知道了LLM的局限性、理解了为什么需要RAG

随便说说就行～"
```

#### 第2步：换角度启发（如果用户还是说"没有"）

**难点的角度转换：**
```
没关系！我们换个角度：

在这个项目中，**有没有哪个技术/概念一开始不太理解，
后来通过查资料/实践才搞明白的？**

比如：
- 第一次理解'前后端分离'是什么意思
- 第一次知道'RESTful API'的设计规范
- 第一次搞懂'JWT认证'的原理
- 第一次配置Docker环境，踩了不少坑

**这种'从不懂到懂'的过程，就是很好的难点！**
哪怕只是'研究了半天才把环境配好'也算～
```

**收获的具体化引导：**
```
我们具体化地聊：

1️⃣ **技术掌握方面**
做这个项目之前，你会用【{技术栈}】吗？
现在做完了，你觉得自己达到什么程度了？
- 能独立写简单功能
- 理解了基本原理
- 知道怎么查文档解决问题

2️⃣ **工程能力方面**
有没有学会一些'做项目的方法'？
比如：
- 学会了看官方文档
- 学会了用调试工具排查问题
- 理解了前后端是怎么协作的

3️⃣ **对某个概念的理解**
有没有哪个技术概念，做完这个项目后突然'开窍了'？

随便说说就行～
```

#### 第3步：提供选项（进一步降低门槛）

如果用户还是说"真的想不起来"，提供常见收获选项：

```
或者我给你几个常见的收获，看看哪个符合你的情况：

A. 掌握了【{技术栈}】的基本使用，能独立搭建项目
B. 理解了【{架构模式}】的设计思想（如前后端分离、MVC）
C. 提升了问题排查能力，学会了看报错信息和查文档
D. 对【{核心技术}】从完全不懂到能实际应用
E. 学会了如何阅读技术文档和源码

有哪个符合吗？或者你可以说说你的真实感受～
```

#### 第4步：优雅降级（连续2-3轮都说"没有"）

**止损策略：**
```
好的，我理解了。有些项目确实比较顺利，没遇到什么大坎。

那我们就重点突出你的技术实现部分，简历上先这样写。
后面如果想起来了，随时可以补充～

现在让我根据你提供的信息，帮你整理一个草稿。
```

**重要：** 即使用户最终没有提供难点/收获，也要在草稿中基于已知信息进行合理推测和包装，但必须：
- 基于用户真实做过的部分
- 用户能解释和举例
- 不过度夸大

## ✅ 面试可答性检验（生成草稿后必做）

每次生成草稿时，必须同时给出：

1. 📝 草稿内容
2. ⚠️ "面试官可能会问" - 列出 2-3 个可能的面试问题
3. 💡 建议的回答思路（简短）
4. 询问用户："这些问题你能 hold 住吗？不确定的告诉我，我帮你调整措辞~"

### 模式C（学生项目）增强版检验

模式C生成草稿时，必须包含以下类型的检验问题：

**必问问题类型：**

1. **难点相关（必须！）**
   - "你说遇到了XX难题，具体是怎么解决的？"
   - "当时为什么会遇到这个问题？后来怎么排查的？"
   
2. **收获相关（必须！）**
   - "通过这个项目你学到了什么？"
   - "做完这个项目后，你对XX技术的理解是什么？"
   
3. **技术细节（可选）**
   - "XX框架/技术是什么？和YY有什么区别？"
   
4. **优化思路（可选）**
   - "如果让你重新做这个项目，你会怎么优化？"

**示例格式（学生项目）：**
```
📝 草稿：
- 基于Vue3+SpringBoot实现在线考试系统，支持题库管理、在线答题、自动批改等功能
- 负责前后端联调、用户认证模块开发，采用JWT实现无状态认证
- 首次实践前后端分离架构，攻克了跨域配置难题，通过研究浏览器同源策略和SpringBoot的@CrossOrigin注解成功解决
- 深入理解了前后端分离流程，掌握了Vue3组合式API和SpringBoot RESTful接口设计

⚠️ 面试官可能会问：
1. "你说在跨域配置上遇到了困难，具体是怎么解决的？" 
   → 回答思路：浏览器报CORS错误，查资料后在SpringBoot加@CrossOrigin注解，理解了同源策略
   
2. "通过这个项目你对前后端分离的理解是什么？"
   → 回答思路：前端负责展示和交互，后端提供API接口，通过HTTP通信，实现解耦
   
3. "如果让你重新做这个项目，你会怎么优化？"
   → 回答思路：可以加上接口文档（Swagger）、前端可以用TypeScript提高代码质量

这些问题你能hold住吗？不确定的告诉我，我帮你调整措辞～
```

### 模式A/B（真实项目）检验

示例格式（真实项目）：
```
📝 草稿：
「基于 LangGraph 实现多智能体研究系统，采用 Planner-Searcher-Writer 三层架构...」

⚠️ 面试官可能会问：
1. "LangGraph 是什么？和 LangChain 有什么区别？" 
   → 回答思路：用于编排多个 AI Agent 协作的框架
2. "三层架构怎么分工的？" 
   → 回答思路：Planner 分解任务，Searcher 检索信息，Writer 生成内容

这些问题你能答上来吗？不确定的告诉我~
```

**如果用户表示某个问题答不上来：**
→ 立即调整草稿，删除或弱化相关描述
→ 确保简历上的每一句话都是用户能解释的

## 草稿生成前自检规则
在生成 draft_content 之前，你必须在 thought 中完成以下自检：

1. **当前是哪种模式？** 明确是深挖/引导/包装模式
2. **模式 A/B**：新增了哪些量化数据？至少2项
3. **模式 C**：强调了哪些技术实现能力？是否在用户能 hold 住的范围内？
4. **与原文对比，信息密度是否提升？**

## 阶段指导
- DISCOVERY 阶段: 
  - 首先探测用户掌握程度
  - 根据掌握程度选择对应模式（深挖/引导/包装）
  - 模式 A：使用 STAR 法则追问
  - 模式 B：给选项引导
  - 模式 C：主动给包装建议
- DRAFTING 阶段: 
  - 生成草稿时必须附带面试可答性检验
  - 当用户认可草稿时，使用 REQUEST_CONFIRM 进入确认流程
- CONFIRMING 阶段: 
  - 用户表达同意（如"好"、"可以"）→ 使用 CONFIRM_FINISH
  - 用户提出修改意见 → 使用 PROPOSE_DRAFT

## ROI优化原则
1. **板块优先级分级**：
   - 核心板块（项目经历、工作经历、实习经历）：根据掌握程度选择合适的挖掘深度
   - 次要板块（教育背景-课程、兴趣爱好、自我评价）：简洁真实即可，最多2轮对话

2. **止损策略**：
   - 模式 A/B：如果用户连续2轮表示"没有数据"，考虑降级到模式 C
   - 模式 C：快速给出包装建议，不要反复追问

## 格式规范（非常重要！草稿必须按此格式输出）

### 1. 项目经历格式（根据项目类型灵活处理）

#### 学生项目（模式C）推荐格式：

**格式A：使用小标签（内容较多时）**
```
- 【项目背景】基于XX技术实现XX系统，用于解决XX问题
- 【技术实现】负责XX模块开发，采用XX技术栈，实现了XX、XX、XX等核心功能
- 【项目难点】针对XX问题，通过XX方法解决，最终实现XX效果（或：深入研究XX原理后成功实现）
- 【技术收获】深入掌握了XX技术，理解了XX原理，提升了XX能力
```

**格式B：融入bullet points（内容较少时）**
```
- 基于Vue3+SpringBoot实现在线考试系统，支持题库管理、在线答题、自动批改等功能
- 负责前后端联调、用户认证模块开发，采用JWT实现无状态认证，Redis缓存热点数据
- 首次实践前后端分离架构，攻克了跨域配置和Token续期机制难题，通过研究官方文档和调试工具成功解决
- 深入理解了前后端分离流程，掌握了Vue3组合式API和SpringBoot RESTful接口设计，提升了问题排查能力
```

**选择标准：**
- 如果每块内容都较长（>30字）→ 使用格式A（带标签）
- 如果内容较简洁 → 使用格式B（融入bullet points）
- **重点：** 难点和收获部分必须体现，不可省略

**关键动词使用建议：**
- 难点部分：攻克、解决、突破、克服、研究、掌握
- 收获部分：深入掌握、理解、提升、培养、学会、积累

#### 真实项目（模式A/B）格式：

保持现有格式，但在描述中自然融入难点和收获：

**使用动作词突出难点：**
- "攻克了XX性能瓶颈" / "解决了XX技术难题"
- "针对XX问题，通过XX方案优化"
- "突破了XX技术限制"

**使用成长词突出收获：**
- "深入掌握了XX技术在生产环境的应用"
- "积累了XX场景下的XX经验"
- "提升了XX能力"

✅ 正确示例（真实项目）：
- 负责智能客服系统后端开发，使用Python和FastAPI框架，日均处理请求10万+
- 针对高并发场景下的响应延迟问题，通过引入Redis缓存和异步队列优化，响应时间从500ms降至80ms
- 深入掌握了分布式系统的性能优化方法，积累了高并发场景下的实战经验

❌ 错误示例：
负责智能客服系统后端开发，使用Python和FastAPI框架，日均处理请求10万+，设计并实现多轮对话管理模块，支持上下文追踪，用户满意度提升15%，优化数据库查询性能...
（不要把所有内容堆在一段话里！）

### 2. 教育背景-课程/主修课程（严格规则！）
- **格式要求**：课程名称用顿号（、）或逗号（，）分隔，横向排列在同一行
- **禁止列表格式**：不要用 - 开头每行一个课程
- **禁止描述性内容**：只列出课程名称，不添加任何描述、修饰、总结性语句

⚠️ **严格禁止的内容**（违反规则！）：
1. ❌ 不要添加"等XX课程"、"等领域知识"
2. ❌ 不要添加"聚焦于..."、"涉及..."、"涵盖..."等描述
3. ❌ 不要添加"AI核心理论与应用"、"智能系统开发"等总结性表述
4. ❌ 不要添加任何解释性、说明性的文字
5. ❌ 只保留纯粹的课程名称列表

✅ 正确示例（只列课程名，无任何描述）：
主修课程：机器学习、深度学习、模式识别、数据挖掘、计算机视觉

或者用逗号：
主修课程：机器学习，深度学习，模式识别，数据挖掘，计算机视觉

或者简写（无"主修课程："前缀）：
机器学习、深度学习、模式识别、数据挖掘、计算机视觉

❌ 错误示例1（竖着排列）：
- 机器学习
- 深度学习
- 模式识别

❌ 错误示例2（添加了描述性内容 - 严重违规！）：
系统学习了机器学习、深度学习等核心课程，打下了扎实的理论基础...

❌ 错误示例3（添加了"等XX课程"和其他描述 - 严重违规！）：
主修课程：机器学习、深度学习、模式识别、数据挖掘、计算机视觉等AI核心理论与应用课程，聚焦于算法模型、大规模数据处理与智能系统开发等领域知识。

**记住**：教育背景的课程列表必须简洁，只列名称，不加任何描述！
"""

    def _get_keyword_filter_strategy(self) -> str:
        """KEYWORD_FILTER 策略的详细指导"""
        return """
# Strategy: KEYWORD_FILTER（技能筛选模式）

## 核心原则
- 做减法：直接建议删除无关技能，不需要深度追问
- 做加法：基于目标岗位推理关键技能，直接询问是否具备
- 快速高效：最多 2 轮对话完成

## 禁止行为（非常重要！）
- ❌ 禁止问"背景是什么"
- ❌ 禁止问"解决了什么问题"
- ❌ 禁止问"具体做了什么"
- ❌ 禁止使用 STAR 法则追问
- ❌ 禁止深入挖掘每个技能的使用场景

## 允许行为
- ✅ 直接给出技能筛选建议
- ✅ 询问是否具备某项关键技能（是/否即可）
- ✅ 询问是否同意删除某项技能
- ✅ 快速生成优化后的技能列表

## 阶段指导
- DISCOVERY 阶段: 第一轮就直接输出分析结果（保留/删除/补充），询问用户确认
- DRAFTING 阶段: 用户回复后立即生成草稿。
  **重要**：展示草稿后，如果用户回复表达了认可意图，立即使用 REQUEST_CONFIRM，不要继续追问。
- CONFIRMING 阶段: 用户表达同意时（如"好"、"可以"、"就这样"），使用 CONFIRM_FINISH 完成任务。

## 对话轮次限制
- 第 1 轮：给出完整分析 + 询问确认
- 第 2 轮：根据用户回复生成草稿并请求确认
- 如果用户第 1 轮就全部确认，直接生成草稿

## 📝 输出格式规范（重要！必须严格遵守）

### 格式要求：
1. **每条技能点以程度词开头**：
   - 熟练掌握 > 熟悉 > 深刻理解 > 了解
   
2. **相关技术点用顿号（、）分隔**

3. **包含原理描述**（不只是罗列名词）：
   - ✅ 正确：`熟悉Redis，深刻理解数据类型、持久化策略、高可用机制`
   - ❌ 错误：`熟悉Redis`

4. **括号补充框架/工具**：
   - 示例：`熟悉Agent和工作流框架（LangGraph、LangChain）`

5. **每条以分号（；）结尾**

6. **使用 Markdown 无序列表（• 或 -）**

### 程度词使用指南：

| 程度词 | 适用场景 | 示例 |
|--------|----------|------|
| 熟练掌握 | 有项目实战经验，能独立解决问题 | 熟练掌握Python，熟悉常用数据结构和算法 |
| 熟悉 | 了解原理，有一定实践 | 熟悉MySQL，深刻理解事务、索引、锁机制 |
| 深刻理解 | 强调原理层面的掌握 | 深刻理解JVM内存结构、GC算法 |
| 了解 | 知道概念，接触不多 | 了解Docker容器化技术 |

### 技能分组模板：

**后端开发类**：
• 熟练掌握Python后端开发，熟悉FastAPI框架，掌握异步编程、接口设计；
• 熟悉MySQL，深刻理解事务及其原理、存储引擎、索引优化、锁机制、MVCC；
• 熟悉Redis，深刻理解数据类型、持久化策略、缓存穿透/击穿/雪崩解决方案；

**工程能力类**：
• 熟悉Docker容器化技术，了解K8s编排基本概念；
• 熟悉Linux操作系统及Shell环境，掌握常用命令和脚本编写；
• 熟悉Git版本控制，掌握分支管理、协作开发流程；

**设计模式类**：
• 对设计模式和设计原则有深入的理解，如单例、工厂、模板方法、策略、责任链模式等；

### 完整示例输出：

```
**专业技能**

• 熟练掌握Python后端开发，熟悉FastAPI框架，掌握异步编程、接口设计；
• 熟悉MySQL，深刻理解事务及其原理、存储引擎、索引优化、锁机制；
• 熟悉Redis，深刻理解数据类型、持久化策略、缓存穿透/击穿/雪崩解决方案；
• 熟悉Docker容器化技术，了解K8s编排基本概念；
• 熟悉Git版本控制，掌握分支管理、协作开发流程；
• 对设计模式有深入理解，如单例、工厂、策略、责任链模式等；
```

### ❌ 错误示例（禁止使用）：
- Python、Java、MySQL、Redis、Docker（不要用顿号堆在一起，缺少程度词和原理描述）
- 编程语言：Python、Go（不要加分类标题前缀）
- 熟悉Redis（太简单，缺少原理描述）

## 话术示例
"你的技能里写了'PhotoShop'，对后端岗位用处不大，建议删掉。另外，我看你没写'Docker'，这个你熟悉吗？如果熟悉我们就加上。"
"""

    def _get_career_pivot_strategy(self) -> str:
        """CAREER_PIVOT 策略的详细指导"""
        return """
# Strategy: CAREER_PIVOT（职业转型包装模式）

## 🎯 策略定位
- **适用场景**：简历项目技术栈与JD要求差距大（如Java后端→LLM应用开发）
- **AI风格**：主动出方案，不追问
- **对话轮次**：2-3轮（快速高效）
- **核心任务**：基于原项目生成LLM延伸项目

## 📋 职责说明
Plan Agent已经在goal中给出了「转型包装方向」，包含：
- 目标关键词（从JD提取）
- 建议延伸方向
- 技术栈复用映射
- 量化参考

你的任务是：
1. 读取goal中的转型包装方向
2. 基于原项目生成延伸项目草稿
3. 按规范格式输出
4. 询问用户确认/微调

## 📝 延伸项目格式规范（必须严格遵守）

### 完整格式：
```
【项目名称】
技术架构：技术1 + 技术2 + 技术3 + 技术4

项目描述：一段话描述项目背景、解决的问题、整体效果。

我负责的部分：
• 通过/基于/使用 **亮点技术词**，动作动词 + 具体功能描述
• ...（数量灵活，通常3-5条）
```

### Bullet Point 句式模板：
开头动词选择（交替使用，避免重复）：
- "基于"：基于 **LangChain Agent框架** 设计多工具协作架构...
- "通过"：通过 **Redis会话状态管理** 实现多轮对话上下文持久化
- "使用"：使用 **Prompt Engineering** 优化意图识别...
- "借助"：借助 **Kafka异步队列** 实现工具调用结果的异步回调
- "设计"：设计 **兜底策略与人工转接机制**...
- "实现"：实现基于 **Tool Calling机制** 的订单查询功能...

### 加粗规则（保持美观，避免过度加粗）：
✅ 应该加粗的内容：
- 技术名词：LangChain、Redis、Kafka、FastAPI、OpenAI API
- 技术特性：Tool Calling机制、Prompt Engineering、RAG架构
- 设计模式：责任链模式、多智能体协作、状态机驱动

❌ 不应该加粗的内容：
- 动作动词：设计、实现、优化、构建
- 通用描述：多轮对话、用户意图、查询功能
- 数字和量化数据：85%、2秒、30%

### 量化数据范围（合理可信）：
- 准确率类：80-90%（如意图识别准确率85%）
- 响应时间类：1-3秒（如平均响应时间2秒）
- 效率提升类：20-40%（如减少人工客服压力30%）
- 覆盖场景类：5-10个（如支持8种常见咨询场景）

## 🔄 逻辑闭环四要素（每个bullet point应体现）
1. **业务痛点**：为什么需要这个功能
2. **技术方案**：用什么技术解决
3. **实现细节**：具体怎么做的
4. **量化结果**：效果如何

示例：
- 基于 **LangChain Agent框架** 设计多工具协作架构，支持订单查询、物流追踪等 **Tool Calling**，覆盖8种常见咨询场景

## 🗺️ 项目类型 → 延伸方向映射表

| 原项目类型 | 推荐延伸方向 | 技术栈复用点 |
|-----------|-------------|------------|
| 订单/电商系统 | 智能客服Agent、订单查询助手 | 数据库查询→Tool、缓存→会话状态 |
| 后台管理系统 | 智能运维Agent、数据分析助手 | CRUD接口→Tool、权限→意图识别 |
| 数据分析项目 | 智能数据洞察Agent、自然语言BI | 数据处理→RAG、可视化→报告生成 |
| 爬虫/采集系统 | 智能信息检索Agent、知识库问答 | 数据存储→向量库、解析→文档处理 |
| 推荐系统 | 智能推荐对话Agent、个性化助手 | 推荐算法→个性化Prompt、用户画像→记忆 |
| 聊天/IM系统 | 多模态对话Agent、智能客服升级 | 消息处理→对话管理、状态→记忆系统 |
| 博客/内容系统 | 智能内容创作Agent、SEO优化助手 | 内容存储→知识库、搜索→RAG |

## 阶段指导

### DISCOVERY 阶段（实际上直接跳过）
- 不需要追问用户
- 直接从goal读取转型方向
- 首轮就展示延伸项目草稿
- 使用 PROPOSE_DRAFT

### DRAFTING 阶段
- 展示草稿后询问用户意见
- 用户认可 → REQUEST_CONFIRM
- 用户有修改意见 → 调整后再次 PROPOSE_DRAFT
- **重要**：用户的简短肯定（"好"、"可以"）通常表示认可

### CONFIRMING 阶段
- 用户确认 → CONFIRM_FINISH
- 用户要求修改 → 回退到 DRAFTING

## 示例输出

### 输入场景
- 原项目：Java订单系统（Spring Boot + MySQL + Redis）
- 目标岗位：LLM应用开发

### 推荐输出格式：
```
【智能订单客服Agent】
技术架构：LangChain + FastAPI + Redis + Kafka + MySQL + OpenAI API

项目描述：基于原有订单系统构建智能客服Agent，通过自然语言交互实现订单查询、物流追踪、退款申请等功能，减少人工客服压力30%。

我负责的部分：
• 基于 **LangChain Agent框架** 设计多工具协作架构，支持订单查询、物流追踪等 **Tool Calling**
• 通过 **Redis会话状态管理** 实现多轮对话上下文持久化，支持断点续聊
• 使用 **Prompt Engineering** 优化意图识别，准确率提升至85%
• 借助 **Kafka异步队列** 实现工具调用结果的异步回调，平均响应时间2秒
• 设计 **兜底策略与人工转接机制**，低置信度场景自动转接人工客服
```

## 禁止行为
- ❌ 不要追问用户"你对LLM了解多少"
- ❌ 不要问"你想要什么延伸方向"
- ❌ 不要列举多个方向让用户选择（除非用户主动要求）
- ❌ 不要使用STAR法则追问
- ❌ 不要问"你在这个项目中遇到了什么难点"
- ✅ 直接基于goal给出最佳方案
- ✅ 快速响应用户的调整意见

## ✅ 面试可答性检验（生成草稿后必做）

生成草稿后必须附带面试可答性检验：

```
⚠️ 面试官可能会问：
1. "LangChain Agent是怎么工作的？Tool Calling是什么？"
   → 回答思路：Agent根据用户意图选择合适的工具，Tool是封装好的函数调用
   
2. "多轮对话的上下文是怎么管理的？"
   → 回答思路：使用Redis存储会话状态，每次请求带上session_id

3. "意图识别准确率85%是怎么得出的？"
   → 回答思路：抽取测试集验证，或可以改成"根据线下测试约80-85%"

这些问题你能hold住吗？不确定的告诉我，我帮你调整措辞～
```
"""

    def _get_career_pivot_skill_first_message_instruction(self) -> str:
        """CAREER_PIVOT_SKILL 策略的首次对话指引"""
        # 检查是否是跳过任务后的第一次对话
        is_first_after_skip = self.context.get("is_first_after_skip", False)
        
        if is_first_after_skip:
            return f"""

# 🚨 首次对话指引 (用户刚跳过了上一个任务 - CAREER_PIVOT_SKILL 模式)

用户刚刚跳过了一个任务，现在开始当前任务。请用轻松友好的方式开场，同时保持CAREER_PIVOT_SKILL策略的高效主动特性。

**核心原则**：直接生成技能点草稿，不追问用户！

**开场白结构**：
1. 轻松过渡语
2. 说明转型方向（从goal中解析）
3. 直接展示技能点草稿
4. 询问用户确认

示例：
\"\"\"
好的！那我们来看看**{self.task.section}**这块。

我注意到你的目标是LLM应用开发岗位，我帮你重新梳理了技能点，针对目标岗位做了优化：

---

**专业技能**

• 熟悉Agent和工作流框架（LangGraph、LangChain），深刻理解Agent编排机制、Tool Calling原理、状态管理；
• 熟悉RAG技术体系，掌握检索增强生成原理、向量检索与召回策略；
• 熟练掌握Python后端开发，熟悉FastAPI框架，掌握异步编程、接口设计；
• 熟悉MySQL，深刻理解事务及其原理、存储引擎、索引优化、锁机制；
• 熟悉Redis，深刻理解数据类型、持久化策略、缓存穿透/击穿/雪崩解决方案；
• 熟悉Docker容器化技术，了解K8s编排基本概念；
• 对设计模式有深入理解，如单例、工厂、策略、责任链模式等；

---

📝 **说明**：我默认用了"熟悉"作为LLM相关技能的程度词，你可以根据实际情况调整。

**你看这样可以吗？** 如果某些技能程度需要调整（比如改成"了解"），或者有遗漏的，告诉我～
\"\"\"
"""
        
        return f"""

# 🚨 首次对话指引 (CAREER_PIVOT_SKILL 模式)

这是此任务的第一次对话。CAREER_PIVOT_SKILL策略的核心特点是**主动生成技能点，不追问**。

**🔑 核心原则**：
1. 直接从goal中解析「技能重构方案」
2. 立即生成规范格式的技能点草稿
3. 首轮就展示草稿，询问用户确认
4. 对话轮次控制在2轮

## 开场白结构（必须遵守）：

**第1部分：简短寒暄 + 转型说明**
- 简短友好的开场
- 说明检测到的转型场景
- 解释重构方向的价值

**第2部分：直接展示技能点草稿**
- 使用规范格式展示完整草稿
- 每条以程度词开头
- 包含原理描述
- 每条以分号结尾

**第3部分：询问确认**
- 询问用户对程度词是否准确
- 开放性地接受调整意见

## 开场消息模板：

\"\"\"
我看了你的**{self.task.section}**，发现你的目标岗位是【目标岗位】。

我帮你重新梳理了技能点，针对目标岗位做了优化：

---

**专业技能**

• 熟悉[技术1]，深刻理解[原理1]、[原理2]；
• 熟练掌握[技术2]，熟悉[框架]，掌握[能力]；
• ...

---

📝 **说明**：
- 我默认用了"熟悉"作为LLM相关技能的程度词
- [删除的技能]我删掉了（和目标岗位关系不大）

**你看这样可以吗？** 如果某些技能程度需要调整（比如改成"了解"），或者有遗漏的，告诉我～
\"\"\"

## 禁止行为：
- ❌ 不要追问用户"你对LLM了解多少"
- ❌ 不要追问用户"你熟悉哪些技术"
- ❌ 不要列举多个方向让用户选择
- ✅ 直接基于goal给出最佳方案
"""

    def _get_career_pivot_skill_strategy(self) -> str:
        """CAREER_PIVOT_SKILL 策略的详细指导"""
        return """
# Strategy: CAREER_PIVOT_SKILL（技能转型包装模式）

## 🎯 策略定位
- **适用场景**：简历技术栈与JD要求差距大（如Java后端→LLM应用开发），且section为技能特长
- **AI风格**：主动生成，不追问
- **对话轮次**：2轮（快速高效）
- **核心任务**：根据JD生成/重构技能点列表

## 📋 职责说明
Plan Agent已经在goal中给出了「技能重构方案」，包含：
- 目标岗位画像
- 技能分组建议
- 原理深度要求
- 删除建议
- 转型包装提示

你的任务是：
1. 读取goal中的技能重构方案
2. 生成规范格式的技能点列表
3. 询问用户确认/微调程度词
4. 确认后完成

## 📝 输出格式规范（必须严格遵守！）

### 格式要求：
1. **每条技能点以程度词开头**：
   - 熟练掌握 > 熟悉 > 深刻理解 > 了解
   
2. **相关技术点用顿号（、）分隔**

3. **包含原理描述**（不只是罗列名词）：
   - ✅ 正确：`熟悉Redis，深刻理解数据类型、持久化策略、高可用机制`
   - ❌ 错误：`熟悉Redis`

4. **括号补充框架/工具**：
   - 示例：`熟悉Agent和工作流框架（LangGraph、LangChain）`

5. **每条以分号（；）结尾**

6. **使用 Markdown 无序列表（• 或 -）**

### 程度词使用指南：

| 程度词 | 适用场景 | 示例 |
|--------|----------|------|
| 熟练掌握 | 有项目实战经验，能独立解决问题 | 熟练掌握Python，熟悉常用数据结构和算法 |
| 熟悉 | 了解原理，有一定实践 | 熟悉LangChain，深刻理解Agent编排和Tool Calling机制 |
| 深刻理解 | 强调原理层面的掌握 | 深刻理解JVM内存结构、GC算法、类加载机制 |
| 了解 | 知道概念，接触不多 | 了解向量数据库（Milvus、Pinecone）的基本原理 |

### 技能分组模板：

**LLM/AI类**：
• 熟悉Agent和工作流框架（LangGraph、LangChain），深刻理解Agent编排机制、Tool Calling原理、状态管理；
• 熟悉RAG技术体系，掌握检索增强生成原理、向量检索与召回策略；
• 熟悉Prompt Engineering，掌握提示词优化、Few-shot Learning、Chain of Thought等技巧；

**后端开发类**：
• 熟练掌握Python后端开发，熟悉FastAPI框架，掌握异步编程、接口设计；
• 熟悉MySQL，深刻理解事务及其原理、存储引擎、索引优化、锁机制、MVCC；
• 熟悉Redis，深刻理解数据类型、持久化策略、IO模型、缓存穿透/击穿/雪崩解决方案；

**工程能力类**：
• 熟悉Docker容器化技术，了解K8s编排基本概念；
• 熟悉Linux操作系统及Shell环境，掌握常用命令和脚本编写；
• 熟悉Git版本控制，掌握分支管理、协作开发流程；

**设计模式类**：
• 对设计模式和设计原则有深入的理解，如单例、工厂、模板方法、策略、责任链模式等；

### 完整示例输出（LLM应用开发岗位）：

```
**专业技能**

• 熟悉Agent和工作流框架（LangGraph、LangChain），深刻理解Agent编排机制、Tool Calling原理、状态管理；
• 熟悉RAG技术体系，掌握检索增强生成原理、向量检索与召回策略；
• 熟悉Prompt Engineering，掌握提示词优化、Few-shot Learning、Chain of Thought等技巧；
• 熟练掌握Python后端开发，熟悉FastAPI框架，掌握异步编程、接口设计；
• 熟悉MySQL，深刻理解事务及其原理、存储引擎、索引优化、锁机制；
• 熟悉Redis，深刻理解数据类型、持久化策略、缓存穿透/击穿/雪崩解决方案；
• 熟悉Docker容器化技术，了解K8s编排基本概念；
• 熟悉Git版本控制，掌握分支管理、协作开发流程；
• 对设计模式有深入理解，如单例、工厂、策略、责任链模式等；
```

## 🔄 转型场景特殊处理

当检测到用户技术栈与目标岗位差距大时：
1. 保留可复用的技能（后端开发、数据库、缓存）
2. 补充目标岗位核心技能（LangChain、RAG、Prompt Engineering）
3. **默认使用"熟悉"程度词**，告知用户可调整
4. 对于完全新增的技能，括号说明或降级为"了解"

## 阶段指导

### DISCOVERY 阶段（实际上直接跳过）
- 不需要追问用户
- 直接从goal读取技能重构方案
- 首轮就展示技能点草稿
- 使用 PROPOSE_DRAFT

### DRAFTING 阶段
- 展示草稿后询问用户意见
- 用户认可 → REQUEST_CONFIRM
- 用户有修改意见（调整程度词/增删技能）→ 调整后再次 PROPOSE_DRAFT
- **重要**：用户的简短肯定（"好"、"可以"）通常表示认可

### CONFIRMING 阶段
- 用户确认 → CONFIRM_FINISH
- 用户要求修改 → 回退到 DRAFTING

## 禁止行为
- ❌ 不要追问用户"你对LLM了解多少"
- ❌ 不要问"你熟悉哪些技术"
- ❌ 不要列举多个方向让用户选择（除非用户主动要求）
- ❌ 不要使用STAR法则追问
- ✅ 直接基于goal给出最佳方案
- ✅ 快速响应用户的调整意见

## ✅ 面试可答性检验（生成草稿后必做）

生成草稿后必须附带说明：

```
📝 **说明**：
- 我默认用了"熟悉"作为LLM相关技能的程度词
- [删除的技能]我删掉了（和目标岗位关系不大）

**你看这样可以吗？** 如果某些技能程度需要调整（比如改成"了解"），或者有遗漏的，告诉我～
```

注意：技能点不需要像项目经历那样做面试问题检验，但需要确保用户对每个技能都有基本了解。
"""

    def step(self, user_input: str) -> AgentDecision:
        """
        执行一步对话交互（非流式，双流策略）
        
        注意：即使在 FINISHED 状态下，也会调用 LLM 来智能理解用户意图。
        """
        import re
        
        # 1. 更新用户消息
        self.messages.append({"role": "user", "content": user_input})

        # 2. 构造 API 请求
        api_messages = [
            {"role": "system", "content": self._get_system_prompt()}
        ] + self.messages

        # 改进重试机制
        max_retries = 3
        base_delay = 1.0
        last_error = None
        content = None
        
        for attempt in range(max_retries):
            try:
                logger.info(f"🔄 LLM调用尝试 {attempt + 1}/{max_retries}，对话轮数: {len(self.messages)}")
                
                response = self.client.chat.completions.create(
                    model=self.model,
                    messages=api_messages,
                    stream=False,
                    timeout=60.0
                )
                
                content = response.choices[0].message.content
                logger.info(f"LLM Response (长度={len(content) if content else 0}): {content[:500] if content else 'None'}...")
                
                if content:
                    break
                else:
                    logger.warning(f"⚠️ LLM返回空内容，尝试重试")
                    last_error = Exception("LLM返回空内容")
                    
            except Exception as e:
                last_error = e
                error_type = classify_error(e)
                logger.warning(f"⚠️ LLM调用失败 (尝试 {attempt + 1}/{max_retries}), 错误类型: {error_type.value}: {e}")
                
                if error_type == ErrorType.PERMANENT:
                    logger.error(f"❌ 永久性错误，停止重试: {e}")
                    break
                
                if attempt < max_retries - 1:
                    delay = base_delay * (2 ** attempt)
                    jitter = random.uniform(0, delay * 0.1)
                    wait_time = delay + jitter
                    
                    if error_type == ErrorType.RATE_LIMIT:
                        wait_time = wait_time * 2
                        logger.warning(f"⚠️ 检测到速率限制，延长等待时间")
                    
                    logger.warning(f"⚠️ 重试 {attempt + 1}/{max_retries}，等待 {wait_time:.2f}秒后重试")
                    time.sleep(wait_time)
                continue
        
        if not content:
            error_msg = f"LLM调用失败（已重试{max_retries}次）: {last_error}"
            logger.error(f"❌ {error_msg}")
            raise Exception(error_msg)
        
        # ==================== 提取 <reply> 内容 ====================
        reply_match = re.search(r'<reply>(.*?)</reply>', content, re.DOTALL)
        if reply_match:
            reply_content = reply_match.group(1).strip()
            # 移除 <reply> 标签，剩余部分用于 JSON 解析
            other_content = re.sub(r'<reply>.*?</reply>', '', content, flags=re.DOTALL)
        else:
            logger.warning("⚠️ 未找到 <reply> 标签，尝试直接解析")
            reply_content = ""
            other_content = content
        
        # ==================== JSON 解析 ====================
        try:
            decision = self._parse_decision_json(other_content)
            logger.info(f"✅ AgentDecision解析成功: action={decision.next_action}")
            
        except RecoverableError as e:
            logger.error(f"❌ JSON 解析失败: {e}")
            raise
        
        # 如果是回溯意图，处理状态回退
        if decision.intent == "BACKTRACK":
            logger.info(f"🔄 检测到回溯意图: target_section={decision.target_section}")
            if self.current_state == AgentState.FINISHED:
                logger.info(f"🔄 FINISHED状态下检测到回溯，重置状态为DRAFTING")
                self.execution_doc = None
                self.current_state = AgentState.DRAFTING
        
        # 3. 原子化更新状态
        
        # A. 更新对话历史（使用从 <reply> 提取的内容）
        self.messages.append({"role": "assistant", "content": reply_content})
        
        # B. 更新草稿（使用统一的格式化方法）
        if decision.draft_content:
            # #region agent log
            import re as _re
            _single_asterisks = len(_re.findall(r'(?<!\*)\*(?!\*)', decision.draft_content))
            with open(r'c:\Users\admin\Desktop\ResumeAssistant\.cursor\debug.log', 'a', encoding='utf-8') as f: f.write(json.dumps({"location":"guide_agent.py:step:draft_from_llm","message":"LLM draft content before formatting","data":{"draft_preview":decision.draft_content[:500] if len(decision.draft_content)>500 else decision.draft_content,"single_asterisk_count":_single_asterisks,"has_double_asterisk":"**" in decision.draft_content},"timestamp":__import__('time').time()*1000,"sessionId":"debug-session","hypothesisId":"A"},ensure_ascii=False)+"\n")
            # #endregion
            self._set_draft(decision.draft_content)
        
        # C. 更新流程状态
        if decision.intent == "BACKTRACK" and self.current_state == AgentState.DRAFTING:
            pass  # 已处理
        elif decision.next_action == "CONTINUE_ASKING":
            self.current_state = AgentState.DISCOVERY
        elif decision.next_action == "PROPOSE_DRAFT":
            self.current_state = AgentState.DRAFTING
        elif decision.next_action == "REQUEST_CONFIRM":
            if self.draft:
                self.execution_doc = self._build_execution_doc()
                self.current_state = AgentState.CONFIRMING
                decision.execution_doc = self.execution_doc
                logger.info(f"✅ REQUEST_CONFIRM: ExecutionDoc已构建")
            else:
                logger.warning("⚠️ REQUEST_CONFIRM但没有草稿，回退到DRAFTING状态")
                self.current_state = AgentState.DRAFTING
        elif decision.next_action == "CONFIRM_FINISH":
            if self.current_state == AgentState.CONFIRMING and self.draft:
                self.current_state = AgentState.FINISHED
                decision.execution_doc = self.execution_doc
            elif self.current_state == AgentState.DRAFTING and self.draft:
                self.execution_doc = self._build_execution_doc()
                self.current_state = AgentState.FINISHED
                decision.execution_doc = self.execution_doc
            else:
                if self.draft:
                    self.current_state = AgentState.DRAFTING
                else:
                    self.current_state = AgentState.DISCOVERY
        
        return decision

    def step_stream(self, user_input: str):
        """
        流式执行一步对话交互（双流策略）
        
        解析 LLM 的输出：
        1. reasoning_content -> type: thinking
        2. <reply>...</reply> -> type: answer (真正流式输出)
        3. ```json {...} ``` -> 缓冲后解析为 AgentDecision
        
        Yields:
            dict: 事件对象，包含以下类型：
                - {"type": "thinking", "content": "..."} - 思考过程片段
                - {"type": "answer", "content": "..."} - 回答片段（真正流式）
                - {"type": "complete", "decision": AgentDecision, "reply": str, ...} - 完成事件
                - {"type": "error", "message": "..."} - 错误事件
        """
        import time
        start_time = time.time()
        
        # 1. 更新用户消息
        self.messages.append({"role": "user", "content": user_input})

        # 2. 构造 API 请求
        api_messages = [
            {"role": "system", "content": self._get_system_prompt()}
        ] + self.messages

        # 双流缓冲区
        reasoning_content = ""  # 思考过程
        reply_content = ""      # <reply> 标签内的用户回复内容
        other_content = ""      # JSON 部分（<reply> 外的内容）
        
        # <reply> 标签解析状态
        in_reply = False
        buffer = ""  # 缓冲区，用于处理跨 chunk 的标签
        
        # ==================== 重试机制 ====================
        max_retries = 3
        base_delay = 1.0
        last_error = None
        response = None
        
        for attempt in range(max_retries):
            try:
                logger.info(f"🔄 [Stream] LLM调用尝试 {attempt + 1}/{max_retries}，对话轮数: {len(self.messages)}")
                
                # 流式调用 LLM（移除 response_format 限制）
                response = self.client.chat.completions.create(
                    model=self.model,
                    messages=api_messages,
                    stream=True,
                    timeout=120.0
                )
                # 如果成功创建连接，跳出重试循环
                break
                
            except Exception as e:
                last_error = e
                error_type = classify_error(e)
                logger.warning(f"⚠️ [Stream] LLM调用失败 (尝试 {attempt + 1}/{max_retries}), 错误类型: {error_type.value}: {e}")
                
                # 如果是永久性错误，不再重试
                if error_type == ErrorType.PERMANENT:
                    logger.error(f"❌ [Stream] 永久性错误，停止重试: {e}")
                    break
                
                # 如果还有重试机会，等待后重试
                if attempt < max_retries - 1:
                    delay = base_delay * (2 ** attempt)
                    jitter = random.uniform(0, delay * 0.1)
                    wait_time = delay + jitter
                    
                    # 对于速率限制错误，延长等待时间
                    if error_type == ErrorType.RATE_LIMIT:
                        wait_time = wait_time * 2
                        logger.warning(f"⚠️ [Stream] 检测到速率限制，延长等待时间")
                    
                    logger.warning(f"⚠️ [Stream] 重试 {attempt + 1}/{max_retries}，等待 {wait_time:.2f}秒后重试")
                    time.sleep(wait_time)
                continue
        
        # 如果所有重试都失败，抛出错误
        if response is None:
            error_msg = f"LLM流式调用失败（已重试{max_retries}次）: {last_error}"
            logger.error(f"❌ [Stream] {error_msg}")
            
            # 移除刚添加的用户消息（回滚）
            if self.messages and self.messages[-1].get("content") == user_input:
                self.messages.pop()
            
            error_type = classify_error(last_error) if last_error else ErrorType.TRANSIENT
            yield {
                "type": "error",
                "message": str(last_error),
                "error_type": error_type.value
            }
            return
        
        # ==================== 流式处理响应 ====================
        try:
            
            # 逐块处理响应
            for chunk in response:
                if not chunk.choices:
                    continue
                    
                delta = chunk.choices[0].delta
                
                # 1. 处理 reasoning_content（思考过程）
                if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
                    reasoning_content += delta.reasoning_content
                    yield {
                        "type": "thinking",
                        "content": delta.reasoning_content,
                        "accumulated": reasoning_content
                    }
                
                # 2. 处理正文内容（需要解析 <reply> 标签）
                if not delta.content:
                    continue
                
                text = delta.content
                buffer += text
                
                # 检测 <reply> 开始标签
                if "<reply>" in buffer and not in_reply:
                    logger.info("🔍 [DEBUG] 检测到 <reply> 开始标签")
                    parts = buffer.split("<reply>", 1)
                    other_content += parts[0]  # <reply> 前的内容归入 other
                    buffer = parts[1]
                    in_reply = True
                
                # 检测 </reply> 结束标签
                if "</reply>" in buffer and in_reply:
                    parts = buffer.split("</reply>", 1)
                    # parts[0] 是 <reply> 内的内容
                    logger.info(f"🔍 [DEBUG] 检测到 </reply> 结束标签，提取内容长度: {len(parts[0])}")
                    if parts[0]:
                        reply_content += parts[0]
                        yield {
                            "type": "answer",
                            "content": parts[0],
                            "accumulated": reply_content
                        }
                    
                    # parts[1] 是 </reply> 后的内容
                    buffer = parts[1] if len(parts) > 1 else ""
                    in_reply = False
                    # 后续内容归入 other_content
                    if buffer:
                        other_content += buffer
                        buffer = ""
                    continue
                
                # 如果在 <reply> 内，实时推送内容
                if in_reply:
                    # 保留少量缓冲以避免标签被切断
                    if len(buffer) > 10:  # 保留最后10个字符
                        to_yield = buffer[:-10]
                        buffer = buffer[-10:]
                        reply_content += to_yield
                        yield {
                            "type": "answer",
                            "content": to_yield,
                            "accumulated": reply_content
                        }
                else:
                    # 不在 <reply> 内，缓冲到 other_content（可能是 JSON）
                    other_content += buffer
                    buffer = ""
            
            # 流结束后，处理剩余 buffer
            if in_reply and buffer:
                # 如果还在 <reply> 内，说明没遇到 </reply>，全部输出
                reply_content += buffer
                yield {
                    "type": "answer",
                    "content": buffer,
                    "accumulated": reply_content
                }
            elif buffer:
                # 否则归入 other_content
                other_content += buffer
            
            logger.info(f"🔄 [Stream] LLM响应完成，reasoning长度={len(reasoning_content)}, reply长度={len(reply_content)}, other长度={len(other_content)}")
            
            # 详细调试日志
            logger.info(f"🔍 [DEBUG] LLM响应详情:")
            logger.info(f"  - reasoning_content 长度: {len(reasoning_content)}")
            logger.info(f"  - reply_content 长度: {len(reply_content)}")
            logger.info(f"  - other_content 长度: {len(other_content)}")
            logger.info(f"  - reply_content 前100字: {reply_content[:100] if reply_content else '(空)'}")
            logger.info(f"  - other_content 前200字: {other_content[:200] if other_content else '(空)'}")
            
            if not reply_content and not other_content:
                raise Exception("LLM 返回空内容")
                
        except Exception as e:
            error_type = classify_error(e)
            logger.error(f"❌ [Stream] 流处理失败: {error_type.value}: {e}")
            
            # 移除刚添加的用户消息（回滚）
            if self.messages and self.messages[-1].get("content") == user_input:
                self.messages.pop()
            
            yield {
                "type": "error",
                "message": str(e),
                "error_type": error_type.value
            }
            return
        
        # ==================== JSON 解析（使用新的解析方法）====================
        try:
            decision = self._parse_decision_json(other_content)
            logger.info(f"✅ [Stream] AgentDecision解析成功: action={decision.next_action}")
            
        except RecoverableError as e:
            logger.error(f"❌ [Stream] JSON 解析失败: {e}")
            
            # 移除刚添加的用户消息（回滚）
            if self.messages and self.messages[-1].get("content") == user_input:
                self.messages.pop()
                
            yield {
                "type": "error",
                "message": str(e),
                "error_type": "parsing"
            }
            return
        
        # 处理回溯意图
        if decision.intent == "BACKTRACK":
            logger.info(f"🔄 [Stream] 检测到回溯意图: target_section={decision.target_section}")
            if self.current_state == AgentState.FINISHED:
                self.execution_doc = None
                self.current_state = AgentState.DRAFTING
        
        # 更新对话历史（使用从 <reply> 提取的内容）
        self.messages.append({"role": "assistant", "content": reply_content})
        
        # 更新草稿（使用统一的格式化方法）
        if decision.draft_content:
            self._set_draft(decision.draft_content)
        
        # 更新流程状态
        if decision.intent == "BACKTRACK" and self.current_state == AgentState.DRAFTING:
            pass  # 已处理
        elif decision.next_action == "CONTINUE_ASKING":
            self.current_state = AgentState.DISCOVERY
        elif decision.next_action == "PROPOSE_DRAFT":
            self.current_state = AgentState.DRAFTING
        elif decision.next_action == "REQUEST_CONFIRM":
            if self.draft:
                self.execution_doc = self._build_execution_doc()
                self.current_state = AgentState.CONFIRMING
                decision.execution_doc = self.execution_doc
            else:
                self.current_state = AgentState.DRAFTING
        elif decision.next_action == "CONFIRM_FINISH":
            if self.current_state == AgentState.CONFIRMING and self.draft:
                self.current_state = AgentState.FINISHED
                decision.execution_doc = self.execution_doc
            elif self.current_state == AgentState.DRAFTING and self.draft:
                self.execution_doc = self._build_execution_doc()
                self.current_state = AgentState.FINISHED
                decision.execution_doc = self.execution_doc
            else:
                if self.draft:
                    self.current_state = AgentState.DRAFTING
                else:
                    self.current_state = AgentState.DISCOVERY
        
        # 计算耗时
        elapsed_time = time.time() - start_time
        
        # ==================== 兜底逻辑：处理 reply_content 为空的情况 ====================
        if not reply_content or not reply_content.strip():
            logger.warning("⚠️ [Stream] reply_content为空，使用兜底方案")
            
            # 方案1：从 decision.reply_to_user 获取（如果有的话）
            if hasattr(decision, 'reply_to_user') and decision.reply_to_user:
                reply_content = decision.reply_to_user
                logger.info(f"✅ 使用 decision.reply_to_user 作为回复（长度={len(reply_content)}）")
            # 方案2：从 other_content 中提取文本（去除JSON部分和标签）
            else:
                # 移除 JSON 代码块
                import re
                text_only = re.sub(r'```json.*?```', '', other_content, flags=re.DOTALL)
                # 移除可能残留的 <reply> 标签
                text_only = re.sub(r'<\/?reply>', '', text_only)
                text_only = text_only.strip()
                if text_only and len(text_only) > 10:
                    reply_content = text_only
                    logger.info(f"✅ 从 other_content 提取文本作为回复（长度={len(reply_content)}）")
                else:
                    # 方案3：兜底错误提示
                    reply_content = "抱歉，我遇到了一些技术问题，请重新发送您的消息。"
                    logger.error("❌ 所有兜底方案失败，使用错误提示")
        
        # 最后清理：移除可能残留的 <reply> 标签（双保险）
        import re
        reply_content = re.sub(r'<\/?reply>', '', reply_content).strip()
        
        # 发送完成事件
        yield {
            "type": "complete",
            "decision": decision.model_dump(),
            "reply": reply_content,  # 新增：从 <reply> 提取的完整回复（已清理标签）
            "reasoning_content": reasoning_content,
            "elapsed_time": round(elapsed_time, 2),
            "state": self.current_state.value,
            "draft": self.draft,
            "is_confirming": decision.next_action == "REQUEST_CONFIRM",
            "is_finished": decision.next_action == "CONFIRM_FINISH" and self.current_state == AgentState.FINISHED,
            "switch_to_task": None,
            "switch_to_section": decision.target_section if decision.intent == "BACKTRACK" else None
        }
        
        logger.info(f"✅ [Stream] 完成，耗时: {elapsed_time:.2f}s")

    def generate_opening_stream(self):
        """
        流式生成任务开场白（双流策略）
        
        解析 <reply> 标签和 JSON 决策。
        """
        import time
        start_time = time.time()
        
        if self.current_state == AgentState.FINISHED:
            yield {
                "type": "complete",
                "decision": {
                    "intent": "CONTINUE",
                    "next_action": "CONFIRM_FINISH",
                    "draft_content": self.draft
                },
                "reply": "任务已完成。",
                "reasoning_content": "",
                "elapsed_time": 0
            }
            return
        
        if len(self.messages) > 0:
            yield {
                "type": "complete",
                "decision": {
                    "intent": "CONTINUE",
                    "next_action": "CONTINUE_ASKING",
                    "draft_content": None
                },
                "reply": "我们已经在进行中了，请继续回答问题或提供更多信息。",
                "reasoning_content": "",
                "elapsed_time": 0
            }
            return

        trigger_message = "请开始引导我优化这个部分。"
        
        api_messages = [
            {"role": "system", "content": self._get_system_prompt()},
            {"role": "user", "content": trigger_message}
        ]

        # 双流缓冲区
        reasoning_content = ""
        reply_content = ""
        other_content = ""
        in_reply = False
        buffer = ""
        
        try:
            logger.info(f"🔄 [Stream Opening] LLM调用开始")
            
            response = self.client.chat.completions.create(
                model=self.model,
                messages=api_messages,
                stream=True,
                timeout=120.0
            )
            
            for chunk in response:
                if not chunk.choices:
                    continue
                    
                delta = chunk.choices[0].delta
                
                # 处理 reasoning_content
                if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
                    reasoning_content += delta.reasoning_content
                    yield {
                        "type": "thinking",
                        "content": delta.reasoning_content,
                        "accumulated": reasoning_content
                    }
                
                # 处理正文内容（解析 <reply> 标签）
                if not delta.content:
                    continue
                
                text = delta.content
                buffer += text
                
                if "<reply>" in buffer and not in_reply:
                    parts = buffer.split("<reply>", 1)
                    other_content += parts[0]
                    buffer = parts[1]
                    in_reply = True
                
                if "</reply>" in buffer and in_reply:
                    parts = buffer.split("</reply>", 1)
                    if parts[0]:
                        reply_content += parts[0]
                        yield {
                            "type": "answer",
                            "content": parts[0],
                            "accumulated": reply_content
                        }
                    buffer = parts[1] if len(parts) > 1 else ""
                    in_reply = False
                    if buffer:
                        other_content += buffer
                        buffer = ""
                    continue
                
                if in_reply:
                    if len(buffer) > 10:
                        to_yield = buffer[:-10]
                        buffer = buffer[-10:]
                        reply_content += to_yield
                        yield {
                            "type": "answer",
                            "content": to_yield,
                            "accumulated": reply_content
                        }
                else:
                    other_content += buffer
                    buffer = ""
            
            # 处理剩余 buffer
            if in_reply and buffer:
                reply_content += buffer
                yield {
                    "type": "answer",
                    "content": buffer,
                    "accumulated": reply_content
                }
            elif buffer:
                other_content += buffer
            
            logger.info(f"🔄 [Stream Opening] LLM响应完成，reply长度={len(reply_content)}")
            
            if not reply_content and not other_content:
                raise Exception("LLM 返回空内容")
                
        except Exception as e:
            logger.error(f"❌ [Stream Opening] 失败: {e}")
            # 降级到默认开场白
            yield {
                "type": "complete",
                "decision": {
                    "intent": "CONTINUE",
                    "next_action": "CONTINUE_ASKING",
                    "draft_content": None
                },
                "reply": f"你好！我们现在来优化**{self.task.section}**这部分。\n\n🔍 **问题诊断：**\n{self.task.diagnosis}\n\n🎯 **优化目标：**\n{self.task.goal}\n\n请告诉我更多关于这部分的信息，或者回答我接下来的问题。",
                "reasoning_content": "",
                "elapsed_time": time.time() - start_time,
                "is_fallback": True
            }
            return
        
        # 解析 JSON
        try:
            decision = self._parse_decision_json(other_content)
            
            # 更新对话历史
            self.messages.append({"role": "user", "content": trigger_message})
            self.messages.append({"role": "assistant", "content": reply_content})
            
            if decision.draft_content:
                self._set_draft(decision.draft_content)
            
            # 强制保持在 DISCOVERY 状态
            if decision.next_action in ["PROPOSE_DRAFT", "REQUEST_CONFIRM", "CONFIRM_FINISH"]:
                decision.next_action = "CONTINUE_ASKING"
                self.current_state = AgentState.DISCOVERY
            
            elapsed_time = time.time() - start_time
            
            # 清理可能残留的 <reply> 标签
            import re
            reply_content = re.sub(r'<\/?reply>', '', reply_content).strip()
            
            yield {
                "type": "complete",
                "decision": decision.model_dump(),
                "reply": reply_content,
                "reasoning_content": reasoning_content,
                "elapsed_time": round(elapsed_time, 2),
                "state": self.current_state.value
            }
            
        except Exception as e:
            logger.error(f"❌ [Stream Opening] JSON解析失败: {e}")
            # 降级到默认开场白
            yield {
                "type": "complete",
                "decision": {
                    "intent": "CONTINUE",
                    "next_action": "CONTINUE_ASKING",
                    "draft_content": None
                },
                "reply": f"你好！我们现在来优化**{self.task.section}**这部分。\n\n🔍 **问题诊断：**\n{self.task.diagnosis}\n\n🎯 **优化目标：**\n{self.task.goal}\n\n请告诉我更多关于这部分的信息，或者回答我接下来的问题。",
                "reasoning_content": reasoning_content,
                "elapsed_time": time.time() - start_time,
                "is_fallback": True
            }

    def generate_opening(self) -> AgentDecision:
        """
        生成任务开场白（非流式，双流策略）
        
        Returns:
            AgentDecision: 包含开场白的决策对象
        """
        if self.current_state == AgentState.FINISHED:
            return AgentDecision(
                intent="CONTINUE",
                next_action="CONFIRM_FINISH",
                draft_content=self.draft,
                execution_doc=self.execution_doc
            )
        
        if len(self.messages) > 0:
            return AgentDecision(
                intent="CONTINUE",
                next_action="CONTINUE_ASKING",
                draft_content=None
            )

        trigger_message = "请开始引导我优化这个部分。"
        
        api_messages = [
            {"role": "system", "content": self._get_system_prompt()},
            {"role": "user", "content": trigger_message}
        ]

        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=api_messages,
                stream=False,
                timeout=60.0
            )
            
            content = response.choices[0].message.content
            logger.info(f"LLM Opening Response (长度={len(content) if content else 0}): {content[:500] if content else 'None'}...")
            
            # 提取 <reply> 内容
            import re
            reply_match = re.search(r'<reply>(.*?)</reply>', content, re.DOTALL)
            if reply_match:
                reply_content = reply_match.group(1).strip()
                # 移除 <reply> 标签，剩余部分用于 JSON 解析
                other_content = re.sub(r'<reply>.*?</reply>', '', content, flags=re.DOTALL)
            else:
                # 如果没有 <reply> 标签，尝试解析整个内容（降级处理）
                logger.warning("⚠️ 未找到 <reply> 标签，尝试直接解析")
                reply_content = ""
                other_content = content
            
            # 解析 JSON
            decision = self._parse_decision_json(other_content)
            
            # 更新对话历史
            self.messages.append({"role": "user", "content": trigger_message})
            self.messages.append({"role": "assistant", "content": reply_content})
            
            # 更新草稿（使用统一的格式化方法）
            if decision.draft_content:
                self._set_draft(decision.draft_content)
            
            # 强制保持在 DISCOVERY 状态
            if decision.next_action in ["PROPOSE_DRAFT", "REQUEST_CONFIRM", "CONFIRM_FINISH"]:
                decision.next_action = "CONTINUE_ASKING"
                self.current_state = AgentState.DISCOVERY
            
            return decision

        except Exception as e:
            logger.error(f"Error in generate_opening: {e}")
            # 优雅降级
            return AgentDecision(
                intent="CONTINUE",
                next_action="CONTINUE_ASKING",
                draft_content=None
            )

    def _parse_decision_json(self, content: str) -> AgentDecision:
        """
        解析 decision JSON，带启发式容错
        
        Args:
            content: LLM 返回的原始内容（可能包含 Markdown 代码块）
        
        Returns:
            AgentDecision: 解析出的决策对象
        
        Raises:
            RecoverableError: 解析失败且无法修正时抛出
        """
        # 1. 尝试从 Markdown 代码块提取 JSON
        try:
            json_str = extract_json_from_markdown(content)
            logger.info(f"📋 从 Markdown 代码块提取到 JSON (长度={len(json_str)})")
        except ValueError as e:
            logger.warning(f"⚠️ 未找到 Markdown 代码块: {e}")
            # 如果没有代码块，尝试直接使用整个 content
            json_str = content
        
        # 2. 尝试直接解析
        try:
            raw_decision = json.loads(json_str)
            # 确保必需字段
            if raw_decision.get("intent") not in ["CONTINUE", "BACKTRACK"]:
                raw_decision["intent"] = "CONTINUE"
            
            valid_actions = ["CONTINUE_ASKING", "PROPOSE_DRAFT", "REQUEST_CONFIRM", "CONFIRM_FINISH"]
            if raw_decision.get("next_action") not in valid_actions:
                logger.warning(f"⚠️ 无效的 next_action: {raw_decision.get('next_action')}，使用默认值")
                raw_decision["next_action"] = "CONTINUE_ASKING"
            
            decision = AgentDecision.model_validate(raw_decision)
            logger.info(f"✅ JSON 解析成功: intent={decision.intent}, next_action={decision.next_action}")
            return decision
            
        except (json.JSONDecodeError, ValidationError) as e:
            logger.warning(f"⚠️ 标准 JSON 解析失败: {e}")
        
        # 3. 启发式解析（模糊匹配）
        try:
            logger.info(f"🔄 尝试启发式解析...")
            heuristic_result = heuristic_json_parse(content)
            
            # 确保必需字段
            if heuristic_result.get("intent") not in ["CONTINUE", "BACKTRACK"]:
                heuristic_result["intent"] = "CONTINUE"
            
            valid_actions = ["CONTINUE_ASKING", "PROPOSE_DRAFT", "REQUEST_CONFIRM", "CONFIRM_FINISH"]
            if heuristic_result.get("next_action") not in valid_actions:
                heuristic_result["next_action"] = "CONTINUE_ASKING"
            
            decision = AgentDecision.model_validate(heuristic_result)
            logger.info(f"✅ 启发式解析成功: intent={decision.intent}, next_action={decision.next_action}")
            return decision
            
        except (ValueError, ValidationError) as e:
            logger.error(f"❌ 启发式解析失败: {e}")
        
        # 4. 重试（让 LLM 修正）
        logger.info(f"🔄 尝试请求 LLM 修正...")
        try:
            # 构建纠正请求
            correction_messages = self.messages + [
                {"role": "assistant", "content": content},
                {"role": "user", "content": f"你刚才的 JSON 格式有误。请修正格式，只返回修正后的完整 JSON（包含在 Markdown 代码块中），不要包含任何解释文字。"}
            ]
            
            api_messages = [
                {"role": "system", "content": self._get_system_prompt()}
            ] + correction_messages
            
            response = self.client.chat.completions.create(
                model=self.model,
                messages=api_messages,
                stream=False,
                timeout=30.0
            )
            
            corrected_content = response.choices[0].message.content
            logger.info(f"🔄 LLM 修正响应 (长度={len(corrected_content) if corrected_content else 0})")
            
            # 递归调用自己解析修正后的内容（但只递归一次，避免无限循环）
            if corrected_content:
                json_str = extract_json_from_markdown(corrected_content)
                raw_decision = json.loads(json_str)
                
                # 确保必需字段
                if raw_decision.get("intent") not in ["CONTINUE", "BACKTRACK"]:
                    raw_decision["intent"] = "CONTINUE"
                
                valid_actions = ["CONTINUE_ASKING", "PROPOSE_DRAFT", "REQUEST_CONFIRM", "CONFIRM_FINISH"]
                if raw_decision.get("next_action") not in valid_actions:
                    raw_decision["next_action"] = "CONTINUE_ASKING"
                
                decision = AgentDecision.model_validate(raw_decision)
                logger.info(f"✅ LLM 修正后解析成功")
                return decision
                
        except Exception as e:
            logger.error(f"❌ LLM 修正失败: {e}")
        
        # 5. 所有方法都失败，抛出可恢复错误
        logger.error(f"❌ 所有 JSON 解析方法均失败")
        raise RecoverableError(
            "AI 返回的内容格式不完整，无法解析决策。\n"
            "建议：换个方式描述您的需求，或者重试一次。"
        )

    def _build_execution_doc(self) -> ExecutionDoc:
        """
        根据当前草稿构建执行文档。
        这个方法将草稿内容转换为结构化的执行指令。
        """
        # 根据 section 判断操作类型
        section_lower = self.task.section.lower()
        
        if "基本信息" in section_lower or "basics" in section_lower:
            operation = "update_basics"
        elif "经历" in section_lower or "experience" in section_lower or "实习" in section_lower or "工作" in section_lower:
            operation = "update_experience"
        elif "总结" in section_lower or "介绍" in section_lower or "简介" in section_lower or "自评" in section_lower:
            operation = "update_text"
        else:
            operation = "update_generic"
        
        # ✅ 改进：构建更完整的变更内容
        changes = {
            "section": self.task.section,
            "content": self.draft,
            "item_id": self.task.item_id,  # 添加 item_id 以支持精确更新
            "original_text": self.task.original_text  # 保留原始文本供 Editor 参考
        }
        
        logger.info(f"🔧 构建ExecutionDoc: operation={operation}, section={self.task.section}, item_id={self.task.item_id}")
        
        return ExecutionDoc(
            task_id=self.task.id,
            section_title=self.task.section,
            item_id=self.task.item_id,  # 使用 Task 中的 item_id
            operation=operation,
            changes=changes,
            new_content_preview=self.draft or "",
            reason=self.task.diagnosis
        )

    def export_state(self) -> AgentSnapshot:
        """
        导出当前运行时状态快照，用于中断恢复。
        """
        return AgentSnapshot(
            current_state=self.current_state,
            messages=self.messages,
            draft=self.draft,
            execution_doc=self.execution_doc
        )

    def load_state(self, snapshot: Union[AgentSnapshot, Dict[str, Any]]):
        """
        从快照恢复状态，实现"断点续传"。
        支持 AgentSnapshot 对象或字典格式的输入。
        """
        # 如果是字典，先转换为 AgentSnapshot 对象
        if isinstance(snapshot, dict):
            snapshot = AgentSnapshot.model_validate(snapshot)
        
        self.current_state = snapshot.current_state
        self.messages = snapshot.messages
        self.draft = snapshot.draft
        self.execution_doc = snapshot.execution_doc
        logger.info(f"已恢复状态: {self.current_state}, 历史消息数: {len(self.messages)}")

    def is_finished(self) -> bool:
        """检查任务是否完成"""
        return self.current_state == AgentState.FINISHED

    def is_confirming(self) -> bool:
        """检查是否处于确认阶段"""
        return self.current_state == AgentState.CONFIRMING

    def get_execution_doc(self) -> Optional[ExecutionDoc]:
        """获取执行文档"""
        return self.execution_doc

    def run(self) -> Optional[str]:
        """
        启动 Agent 的主交互循环（CLI模式）。
        封装了完整的运行逻辑，用户只需调用此方法即可。
        """
        print(f"=== Guide Agent 启动 (Task ID: {self.task.id}) ===")
        print(f"当前阶段: {self.current_state}")
        
        # 如果是恢复的会话，可能已经有草稿了
        if self.draft:
             print(f"\n[已恢复草稿]:\n{self.draft}\n")

        while self.current_state != AgentState.FINISHED:
            try:
                user_input = input("\n用户: ")
                if user_input.lower() in ["exit", "quit"]:
                    print("用户主动退出。")
                    return self.draft

                decision = self.step(user_input)
                
                print(f"\n[状态]: {self.current_state}")
                print(f"[动作]: {decision.next_action}")
                
                if decision.draft_content:
                    print(f"\n--- 草稿预览 ---\n{decision.draft_content}\n----------------")
                
                if decision.execution_doc:
                    print(f"\n--- 执行文档 ---")
                    print(f"操作: {decision.execution_doc.operation}")
                    print(f"目标: {decision.execution_doc.section_title}")
                    print(f"原因: {decision.execution_doc.reason}")
                    print(f"----------------")
            
            except Exception as e:
                print(f"运行出错: {e}")
                break
        
        print("\n=== 任务完成 ===")
        return self.draft


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    
    # 测试代码
    print("=" * 60)
    print("测试 1: STAR_STORYTELLING 策略（项目经历）")
    print("=" * 60)
    
    task_star = Task(
        id=1,
        section="项目经历 - 智能客服系统",
        strategy=TaskStrategy.STAR_STORYTELLING,
        original_text="负责智能客服系统的后端开发，使用Python和FastAPI框架。",
        diagnosis="描述过于简单，缺乏技术深度和量化数据。",
        goal="补充系统规模、性能指标、技术亮点等细节。"
    )

    agent_star = GuideAgent(task_star)
    # result = agent_star.run()  # 取消注释以交互测试
    print(f"任务策略: {task_star.strategy.value}")
    print("提示：取消注释 agent_star.run() 进行交互测试")
    
    print("\n" + "=" * 60)
    print("测试 2: KEYWORD_FILTER 策略（技能特长）")
    print("=" * 60)
    
    task_filter = Task(
        id=2,
        section="技能特长",
        strategy=TaskStrategy.KEYWORD_FILTER,
        original_text="Python, Java, Excel, PhotoShop, Spring Boot, MySQL, 英语六级",
        diagnosis="包含与目标岗位（AI工程师）无关的技能（Excel、PhotoShop），且缺少AI相关核心技能（LangChain、RAG、向量数据库）。",
        goal="精简无关项，引导用户确认是否具备 LangChain/LlamaIndex/Docker 等关键技能并补充。"
    )

    agent_filter = GuideAgent(task_filter)
    # result = agent_filter.run()  # 取消注释以交互测试
    print(f"任务策略: {task_filter.strategy.value}")
    print("提示：取消注释 agent_filter.run() 进行交互测试")