how推导agent run update

agent/tools/builtin/__init__.py

@@ -15,6 +15,7 @@ from agent.tools.builtin.file.grep import grep_content
 from agent.tools.builtin.bash import bash_command
 from agent.tools.builtin.skill import skill, list_skills
 from agent.tools.builtin.subagent import agent, evaluate
+from agent.trace.goal_tool import goal
 from agent.tools.builtin.experience import get_experience
 from agent.tools.builtin.search import search_posts, get_search_suggestions
 from agent.tools.builtin.sandbox import (sandbox_create_environment, sandbox_run_shell,
@@ -39,6 +40,7 @@ __all__ = [
     "list_skills",
     "agent",
     "evaluate",
+    "goal",
     "search_posts",
     "get_search_suggestions",
     "sandbox_create_environment",

examples_how/overall_derivation/input/家有大志/解构内容/6921937a000000001b0278d1.json

@@ -0,0 +1,421 @@
+{
+    "帖子ID": "6921937a000000001b0278d1",
+    "处理说明": "优化版批量分类流程：一次性对所有点进行分类，移除了评估和调整步骤",
+    "灵感点": [
+        {
+            "点": "蟑螂饭店",
+            "点描述": "一个为蟑螂设计的微型饭店。它由一个普通的蟑螂屋改造而成，增加了红色的中式屋顶、写有“开业大酬宾”的横幅，并配有“营业中”、“无限畅吃”、“拍照送饵剂”等多个微型促销招牌。",
+            "分词结果": [
+                {
+                    "词": "蟑螂饭店",
+                    "详细描述": "指将蟑螂屋通过创意改造后形成的微缩饭店场景，是本帖的核心创意主体。",
+                    "来源": "原文保留",
+                    "应用原则": "前置判断-完整内容体",
+                    "处理理由": "作为内容的核心核心概念和完整表达，整体具有极高的检索价值，不可拆分。"
+                }
+            ],
+            "分词评估": {
+                "评估结果": "通过",
+                "评估意见": {
+                    "完整性": "评估失败，默认通过",
+                    "合理性": "评估失败，默认通过",
+                    "准确性": "评估失败，默认通过"
+                },
+                "建议调整": []
+            },
+            "实质": {
+                "具体元素": [
+                    {
+                        "名称": "蟑螂饭店",
+                        "说明": "由蟑螂屋改造而成的、具有饭店外观特征的微缩模型装置",
+                        "来源": "图片中展示的带有屋顶、横幅和招牌的红色微型建筑",
+                        "分类理由": "内容核心呈现的具体实体对象，是故事发生的载体和视觉主体"
+                    }
+                ],
+                "具象概念": [],
+                "抽象概念": []
+            },
+            "形式": {
+                "具体元素形式": [],
+                "具象概念形式": [],
+                "整体形式": []
+            }
+        }
+    ],
+    "目的点": [
+        {
+            "点": "分享创意改造蟑螂屋",
+            "点描述": "意图：通过记录和展示妻子为蟑螂屋进行创意改造的幽默行为，与用户分享生活中的一件趣事，以达到娱乐和引发共鸣的效果。\n实质：将蟑螂屋装饰成“蟑螂饭店”的创意改造过程和成品",
+            "分词结果": [
+                {
+                    "词": "分享",
+                    "详细描述": "指将特定的生活趣事或创意内容向他人展示和传播的行为。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "有明确含义的动词，非连接词，直接保留。"
+                },
+                {
+                    "词": "创意改造",
+                    "详细描述": "指对原有物品进行具有新颖想法的二次加工或装饰的行为。",
+                    "来源": "智能重组",
+                    "应用原则": "智能重组",
+                    "处理理由": "'创意'为修饰词，'改造'为属性词，组合后语义完整且符合搜索习惯。"
+                },
+                {
+                    "词": "蟑螂屋",
+                    "详细描述": "一种用于捕捉蟑螂的日常用品，是本选题点的改造对象。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "行业固定概念，具有独立检索价值，保持完整。"
+                }
+            ],
+            "分词评估": {
+                "评估结果": "通过",
+                "评估意见": {
+                    "完整性": "评估失败，默认通过",
+                    "合理性": "评估失败，默认通过",
+                    "准确性": "评估失败，默认通过"
+                },
+                "建议调整": []
+            },
+            "实质": {
+                "具体元素": [
+                    {
+                        "名称": "蟑螂屋",
+                        "说明": "用于捕捉蟑螂的普通家居用品，是改造前的原始对象",
+                        "来源": "正文提到“之前家里放的蟑螂屋”",
+                        "分类理由": "内容中明确提到的具体实物对象"
+                    }
+                ],
+                "具象概念": [],
+                "抽象概念": []
+            },
+            "形式": {
+                "具体元素形式": [
+                    {
+                        "名称": "创意改造",
+                        "说明": "通过非传统方式改变物品原有用途的创意手法",
+                        "作用": "增加内容的趣味性和奇观感，展示生活智慧，吸引用户注意力",
+                        "分类理由": "这是对日常物品进行处理的表现手法，而非物品本身"
+                    }
+                ],
+                "具象概念形式": [],
+                "整体形式": []
+            },
+            "意图": [
+                {
+                    "名称": "分享",
+                    "说明": "创作者将生活中的趣事发布到社交平台的行为",
+                    "分类理由": "表示创作者的创作目的和行为动词"
+                }
+            ]
+        }
+    ],
+    "关键点": [
+        {
+            "点": "日常物品DIY改造",
+            "点描述": "帖子的核心创意在于将摩托车后视镜、勺子等日常生活中常见的物品，通过简单的DIY方式改造成具有夸张功能的“摸鱼神器”。这种低成本、高创意的改造手法是构成内容趣味性的基础，也是“办公室防老板摸鱼神器”（inspiration_1）这一灵感点的具体实现方式。",
+            "分词结果": [
+                {
+                    "词": "日常物品",
+                    "详细描述": "指生活中常见的、普通的各种生活用品。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "完整的名词短语，作为改造的基础对象，直接保留。"
+                },
+                {
+                    "词": "DIY改造",
+                    "详细描述": "指通过手工方式对物品进行个性化加工或功能重塑。",
+                    "来源": "智能重组",
+                    "应用原则": "智能重组",
+                    "处理理由": "'DIY'作为修饰/方式词与'改造'结合，形成完整的行为概念。"
+                }
+            ],
+            "分词评估": {
+                "评估结果": "通过",
+                "评估意见": {
+                    "完整性": "评估失败，默认通过",
+                    "合理性": "评估失败，默认通过",
+                    "准确性": "评估失败，默认通过"
+                },
+                "建议调整": []
+            },
+            "实质": {
+                "具体元素": [
+                    {
+                        "名称": "日常物品",
+                        "说明": "生活中常见的普通用品，如蟑螂屋、纸片等",
+                        "来源": "正文提到的“蟑螂屋”及图片中的纸质装饰材料",
+                        "分类理由": "内容所涉及的具体实物对象"
+                    }
+                ],
+                "具象概念": [],
+                "抽象概念": []
+            },
+            "形式": {
+                "具体元素形式": [],
+                "具象概念形式": [],
+                "整体形式": [
+                    {
+                        "名称": "DIY改造",
+                        "说明": "亲手制作、改装物品的创作方式",
+                        "作用": "体现生活情趣，通过低成本的动手实践创造出意想不到的视觉效果",
+                        "分类理由": "属于创作者呈现内容所采用的特定方式和手段"
+                    }
+                ]
+            }
+        },
+        {
+            "点": "饭店式促销标语",
+            "点描述": "内容中大量使用了模仿真实饭店的促销标语，如“开业大酬宾”、“无限畅吃”、“拍照送饵剂”等。这些拟人化的营销文案是幽默感和创意的主要来源，通过反差和荒诞感，极大地增强了“蟑螂饭店”这一概念的趣味性，是实现“分享趣事”这一意图的核心内容元素。",
+            "分词结果": [
+                {
+                    "词": "饭店式",
+                    "详细描述": "指模仿饭店经营风格或特征的表现形式。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "后缀'式'必须与前词合并，保留完整的修饰语义。"
+                },
+                {
+                    "词": "促销标语",
+                    "详细描述": "用于吸引顾客、宣传优惠活动的文字短语。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "完整的名词短语，具有明确的行业含义，直接保留。"
+                }
+            ],
+            "分词评估": {
+                "评估结果": "通过",
+                "评估意见": {
+                    "完整性": "评估失败，默认通过",
+                    "合理性": "评估失败，默认通过",
+                    "准确性": "评估失败，默认通过"
+                },
+                "建议调整": []
+            },
+            "实质": {
+                "具体元素": [],
+                "具象概念": [],
+                "抽象概念": []
+            },
+            "形式": {
+                "具体元素形式": [],
+                "具象概念形式": [],
+                "整体形式": [
+                    {
+                        "名称": "饭店式",
+                        "说明": "模仿餐饮行业经营风格的视觉和语言特征",
+                        "作用": "营造出一种荒诞的拟人化氛围，增强内容的幽默感",
+                        "分类理由": "属于对内容呈现风格的修饰，是表现手法"
+                    },
+                    {
+                        "名称": "促销标语",
+                        "说明": "模仿商业促销的文字内容，如“开业大酬宾”等",
+                        "作用": "通过文字载体强化“饭店”这一设定，制造反差萌和趣味性",
+                        "分类理由": "作为一种表达载体，其目的是为了实现幽默的呈现效果"
+                    }
+                ]
+            }
+        },
+        {
+            "点": "微缩场景模型",
+            "点描述": "核心创意是将一个普通的蟑螂屋通过添加屋顶、横幅、招牌等元素，精心打造成一个完整的、细节丰富的微缩饭店场景。这种模型化的改造是整个作品的视觉主体和创意的基础，它将一个日常用品转变为一个充满想象力的艺术装置，直接支撑了“展示生活创意”的目的。",
+            "分词结果": [
+                {
+                    "词": "微缩场景模型",
+                    "详细描述": "指按比例缩小的、模拟真实环境的立体模型装置。",
+                    "来源": "原文保留",
+                    "应用原则": "前置判断-固定概念",
+                    "处理理由": "属于艺术/模型领域的固定术语，整体语义完整，不可细化拆分。"
+                }
+            ],
+            "分词评估": {
+                "评估结果": "通过",
+                "评估意见": {
+                    "完整性": "评估失败，默认通过",
+                    "合理性": "评估失败，默认通过",
+                    "准确性": "评估失败，默认通过"
+                },
+                "建议调整": []
+            },
+            "实质": {
+                "具体元素": [],
+                "具象概念": [],
+                "抽象概念": []
+            },
+            "形式": {
+                "具体元素形式": [],
+                "具象概念形式": [],
+                "整体形式": [
+                    {
+                        "名称": "微缩场景模型",
+                        "说明": "将现实场景按比例缩小制作而成的模型表现形式",
+                        "作用": "以精致、小巧的视觉效果呈现创意，增加内容的观赏价值",
+                        "分类理由": "是内容呈现的艺术载体和表现形式"
+                    }
+                ]
+            }
+        },
+        {
+            "点": "丈夫第一人称叙事",
+            "点描述": "内容采用丈夫作为第一人称叙事者，通过他的视角、口吻和心理活动来讲述关于妻子或夫妻间的趣事。这种叙事方式常带有吐槽、宠溺、关怀或欣赏等多种情感色彩，旨在增强故事的真实感、生活气息和亲和力。",
+            "分词结果": [
+                {
+                    "词": "丈夫",
+                    "详细描述": "指叙事的主体身份，定义了故事的讲述者角色。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "核心人物名词，具有独立检索价值。"
+                },
+                {
+                    "词": "第一人称视角",
+                    "详细描述": "一种文学创作或内容讲述手法，以'我'的视角展开叙述。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "完整的文学/叙事学专有名词，不可进一步拆散。",
+                    "归一化原词": "第一人称叙事"
+                }
+            ],
+            "分词评估": {
+                "评估结果": "通过",
+                "评估意见": {
+                    "完整性": "评估失败，默认通过",
+                    "合理性": "评估失败，默认通过",
+                    "准确性": "评估失败，默认通过"
+                },
+                "建议调整": []
+            },
+            "实质": {
+                "具体元素": [
+                    {
+                        "名称": "丈夫",
+                        "说明": "故事的讲述者，妻子的配偶",
+                        "来源": "正文中的“我”以及标题“我老婆”",
+                        "分类理由": "内容中存在的具体人物角色"
+                    }
+                ],
+                "具象概念": [],
+                "抽象概念": []
+            },
+            "形式": {
+                "具体元素形式": [],
+                "具象概念形式": [],
+                "整体形式": [
+                    {
+                        "名称": "第一人称视角",
+                        "说明": "以当事人的身份进行叙述的文学/影视表现手法",
+                        "作用": "增强故事的真实感和代入感，便于表达主观的情感吐槽",
+                        "分类理由": "属于创作者组织和讲述故事的叙事手法"
+                    }
+                ]
+            },
+            "归一化原点名称": "丈夫欣赏式口吻"
+        },
+        {
+            "点": "模拟动物视角",
+            "点描述": "帖子中专门用一张图片（图4）标注了“蟑螂视角”，通过低角度拍摄来模拟目标“顾客”的观察角度。这种独特的拍摄手法增强了故事的代入感和戏剧性，从视觉上强化了“为蟑螂开饭店”的荒诞幽默感，是一种服务于整体趣味性的表现形式。",
+            "分词结果": [
+                {
+                    "词": "模拟",
+                    "详细描述": "指模仿某种真实情景或视角的行为。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "明确的动词，表示创作手法，直接保留。"
+                },
+                {
+                    "词": "动物视角",
+                    "详细描述": "指模仿动物观察世界的角度进行拍摄或描述的创意手法。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "完整的创意概念，具有独立检索价值，不应拆分为'动物'和'视角'。"
+                }
+            ],
+            "分词评估": {
+                "评估结果": "通过",
+                "评估意见": {
+                    "完整性": "评估失败，默认通过",
+                    "合理性": "评估失败，默认通过",
+                    "准确性": "评估失败，默认通过"
+                },
+                "建议调整": []
+            },
+            "实质": {
+                "具体元素": [],
+                "具象概念": [],
+                "抽象概念": []
+            },
+            "形式": {
+                "具体元素形式": [
+                    {
+                        "名称": "动物视角",
+                        "说明": "模拟动物（如蟑螂）观察世界的低矮视点",
+                        "作用": "产生独特的视觉冲击力，让观众身临其境地感受“蟑螂饭店”的规模",
+                        "分类理由": "属于特定的拍摄角度和视觉呈现手法"
+                    }
+                ],
+                "具象概念形式": [],
+                "整体形式": [
+                    {
+                        "名称": "模拟",
+                        "说明": "模仿某种特定状态或视角的动作手法",
+                        "作用": "通过模仿行为增强内容的戏剧性和趣味性",
+                        "分类理由": "描述的是如何呈现内容的动作手段"
+                    }
+                ]
+            }
+        },
+        {
+            "点": "视觉聚焦夸张道具",
+            "点描述": "前两张图片采用特写镜头，集中展示了密码锁的长度和密集的数字转盘，通过视觉手段放大了道具的夸张特质。这种拍摄手法为后续的反转情节进行了有效铺垫，并直接支撑了“超长密码锁”这一核心灵感，使其荒诞感深入人心。",
+            "分词结果": [
+                {
+                    "词": "视觉聚焦",
+                    "详细描述": "指通过摄影或剪辑手段使观众注意力集中在特定位置的处理方式。",
+                    "来源": "原文保留",
+                    "应用原则": "粒度控制",
+                    "处理理由": "完整的专业术语概念，不宜进一步拆分。"
+                },
+                {
+                    "词": "夸张道具",
+                    "详细描述": "指外形、尺寸或功能超出常规、具有戏剧效果的物品。",
+                    "来源": "智能重组",
+                    "应用原则": "智能重组",
+                    "处理理由": "'夸张'为修饰词，'道具'为核心词，重组后语义完整且符合搜索习惯。"
+                }
+            ],
+            "分词评估": {
+                "评估结果": "通过",
+                "评估意见": {
+                    "完整性": "评估失败，默认通过",
+                    "合理性": "评估失败，默认通过",
+                    "准确性": "评估失败，默认通过"
+                },
+                "建议调整": []
+            },
+            "实质": {
+                "具体元素": [],
+                "具象概念": [],
+                "抽象概念": []
+            },
+            "形式": {
+                "具体元素形式": [
+                    {
+                        "名称": "视觉聚焦",
+                        "说明": "通过特写镜头或构图使观众注意力集中在特定对象上",
+                        "作用": "突出展示捕鼠夹在车座上的细节，增强视觉冲击力",
+                        "分类理由": "为呈现具体元素而选择的视觉手段"
+                    }
+                ],
+                "具象概念形式": [
+                    {
+                        "名称": "夸张道具",
+                        "说明": "使用与环境极不协调或属性极端的物品作为道具",
+                        "作用": "通过捕鼠夹与自行车座的荒诞组合，营造出强烈的戏剧效果和幽默感",
+                        "分类理由": "表达具象概念时采用的手法，增强了内容的表现力"
+                    }
+                ],
+                "整体形式": []
+            }
+        }
+    ]
+}

examples_how/overall_derivation/overall_derivation_agent_run.py

@@ -1,126 +1,480 @@
-import asyncio
-import logging
+"""
+选题点整体推导 Agent（增强版）
+
+参考 examples/how/run.py，提供：
+1. 命令行交互：输入 'p' 暂停、'q' 退出
+2. 暂停后可插入干预消息、触发经验总结、查看 GoalTree、手动压缩上下文
+3. 支持 --trace <ID> 恢复已有 Trace 继续执行
+4. 使用 SimplePrompt 加载 production.prompt，支持评估子 agent（agent_type=evaluate_derivation）
+"""
+
+import argparse
+import os
 import sys
+import select
+import asyncio
 from pathlib import Path
-from agent import AgentRunner, RunConfig
-from agent.llm import create_openrouter_llm_call
+
+# 与 examples/how/run.py 一致：禁止 httpx/urllib 自动检测系统 HTTP 代理
+# os.environ.setdefault("no_proxy", "*")
+
+# 添加项目根目录到 Python 路径
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from agent.llm.prompts import SimplePrompt
+from agent.core.runner import AgentRunner, RunConfig
+from agent.core.presets import AgentPreset, register_preset
 from agent.trace import (
     FileSystemTraceStore,
     Trace,
     Message,
 )
+from agent.llm import create_openrouter_llm_call
+from agent.trace.compaction import build_reflect_prompt
 
-# 配置日志，只显示错误信息（避免干扰最终输出）
-logging.basicConfig(
-    level=logging.WARNING,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    stream=sys.stderr
-)
 
-DEFAULT_MODEL="google/gemini-3-flash-preview"
+# ===== 非阻塞 stdin 检测 =====
+if sys.platform == 'win32':
+    import msvcrt
 
-store = FileSystemTraceStore(base_path=".trace")
-runner = AgentRunner(
-    trace_store=store,
-    llm_call=create_openrouter_llm_call(model=DEFAULT_MODEL),
-)
 
-def print_step(step_num, description, details=""):
-    """打印步骤信息"""
-    print(f"\n[步骤 {step_num}] {description}", file=sys.stderr)
-    if details:
-        print(f"  {details}", file=sys.stderr)
+def check_stdin() -> str | None:
+    """
+    跨平台非阻塞检查 stdin 输入。
+    Windows: msvcrt.kbhit()；macOS/Linux: select.select()
+    """
+    if sys.platform == 'win32':
+        if msvcrt.kbhit():
+            ch = msvcrt.getwch().lower()
+            if ch == 'p':
+                return 'pause'
+            if ch == 'q':
+                return 'quit'
+        return None
+    else:
+        ready, _, _ = select.select([sys.stdin], [], [], 0)
+        if ready:
+            line = sys.stdin.readline().strip().lower()
+            if line in ('p', 'pause'):
+                return 'pause'
+            if line in ('q', 'quit'):
+                return 'quit'
+        return None
+
+
+# ===== 交互菜单 =====
+
+def _read_multiline() -> str:
+    """读取多行输入，以连续两次回车（空行）结束。"""
+    print("\n请输入干预消息（连续输入两次回车结束）：")
+    lines: list[str] = []
+    blank_count = 0
+    while True:
+        line = input()
+        if line == "":
+            blank_count += 1
+            if blank_count >= 2:
+                break
+            lines.append("")
+        else:
+            blank_count = 0
+            lines.append(line)
+    while lines and lines[-1] == "":
+        lines.pop()
+    return "\n".join(lines)
+
+
+async def show_interactive_menu(
+    runner: AgentRunner,
+    trace_id: str,
+    current_sequence: int,
+    store: FileSystemTraceStore,
+):
+    """显示交互式菜单，让用户选择操作。"""
+    print("\n" + "=" * 60)
+    print("  执行已暂停")
+    print("=" * 60)
+    print("请选择操作：")
+    print("  1. 插入干预消息并继续")
+    print("  2. 触发经验总结（reflect）")
+    print("  3. 查看当前 GoalTree")
+    print("  4. 手动压缩上下文（compact）")
+    print("  5. 继续执行")
+    print("  6. 停止执行")
+    print("=" * 60)
+
+    while True:
+        choice = input("请输入选项 (1-6): ").strip()
+
+        if choice == "1":
+            text = _read_multiline()
+            if not text:
+                print("未输入任何内容，取消操作")
+                continue
+            print("\n将插入干预消息并继续执行...")
+            live_trace = await store.get_trace(trace_id)
+            actual_sequence = live_trace.last_sequence if live_trace and live_trace.last_sequence else current_sequence
+            return {
+                "action": "continue",
+                "messages": [{"role": "user", "content": text}],
+                "after_sequence": actual_sequence,
+            }
+
+        elif choice == "2":
+            print("\n触发经验总结...")
+            focus = input("请输入反思重点（可选，直接回车跳过）: ").strip()
+            trace = await store.get_trace(trace_id)
+            saved_head = trace.head_sequence
+            prompt = build_reflect_prompt()
+            if focus:
+                prompt += f"\n\n请特别关注：{focus}"
+            print("正在生成反思...")
+            reflect_cfg = RunConfig(trace_id=trace_id, max_iterations=1, tools=[])
+            reflection_text = ""
+            try:
+                result = await runner.run_result(
+                    messages=[{"role": "user", "content": prompt}],
+                    config=reflect_cfg,
+                )
+                reflection_text = result.get("summary", "")
+            finally:
+                await store.update_trace(trace_id, head_sequence=saved_head)
+            if reflection_text:
+                from datetime import datetime
+                experiences_path = runner.experiences_path or "./.cache/experiences_overall_derivation.md"
+                os.makedirs(os.path.dirname(experiences_path), exist_ok=True)
+                header = f"\n\n---\n\n## {trace_id} ({datetime.now().strftime('%Y-%m-%d %H:%M')})\n\n"
+                with open(experiences_path, "a", encoding="utf-8") as f:
+                    f.write(header + reflection_text + "\n")
+                print(f"\n反思已保存到: {experiences_path}")
+                print("\n--- 反思内容 ---")
+                print(reflection_text)
+                print("--- 结束 ---\n")
+            else:
+                print("未生成反思内容")
+            continue
+
+        elif choice == "3":
+            goal_tree = await store.get_goal_tree(trace_id)
+            if goal_tree and goal_tree.goals:
+                print("\n当前 GoalTree:")
+                print(goal_tree.to_prompt())
+            else:
+                print("\n当前没有 Goal")
+            continue
+
+        elif choice == "4":
+            print("\n正在执行上下文压缩（compact）...")
+            try:
+                goal_tree = await store.get_goal_tree(trace_id)
+                trace = await store.get_trace(trace_id)
+                if not trace:
+                    print("未找到 Trace，无法压缩")
+                    continue
+                main_path = await store.get_main_path_messages(trace_id, trace.head_sequence)
+                history = [msg.to_llm_dict() for msg in main_path]
+                head_seq = main_path[-1].sequence if main_path else 0
+                next_seq = head_seq + 1
+                compact_config = RunConfig(trace_id=trace_id)
+                new_history, new_head, new_seq = await runner._compress_history(
+                    trace_id=trace_id,
+                    history=history,
+                    goal_tree=goal_tree,
+                    config=compact_config,
+                    sequence=next_seq,
+                    head_seq=head_seq,
+                )
+                print(f"\n✅ 压缩完成: {len(history)} 条消息 → {len(new_history)} 条")
+            except Exception as e:
+                print(f"\n❌ 压缩失败: {e}")
+            continue
+
+        elif choice == "5":
+            print("\n继续执行...")
+            return {"action": "continue"}
+
+        elif choice == "6":
+            print("\n停止执行...")
+            return {"action": "stop"}
+
+        else:
+            print("无效选项，请重新输入")
+
 
 async def main():
+    parser = argparse.ArgumentParser(description="选题点整体推导 Agent（支持交互与恢复）")
+    parser.add_argument(
+        "--trace", type=str, default=None,
+        help="已有的 Trace ID，用于恢复继续执行（不指定则新建）",
+    )
+    args = parser.parse_args()
+
+    base_dir = Path(__file__).parent
+    project_root = base_dir.parent.parent
+    prompt_path = base_dir / "production.prompt"
+    output_dir = base_dir / "output"
+    output_dir.mkdir(exist_ok=True)
+
+    # 加载项目级 presets（evaluate_derivation 等）
+    presets_path = base_dir / "presets.json"
+    if presets_path.exists():
+        import json
+        with open(presets_path, "r", encoding="utf-8") as f:
+            project_presets = json.load(f)
+        for name, cfg in project_presets.items():
+            register_preset(name, AgentPreset(**cfg))
+        print(f"   - 已加载项目 presets: {list(project_presets.keys())}")
+
+    skills_dir = str(base_dir / "skills")
+
+    print("=" * 60)
+    print("选题点整体推导 Agent（交互增强）")
+    print("=" * 60)
+    print()
+    print("💡 交互提示：")
+    print("   - 执行过程中输入 'p' 或 'pause' 暂停并进入交互模式")
+    print("   - 执行过程中输入 'q' 或 'quit' 停止执行")
+    print("=" * 60)
+    print()
+
+    print("1. 加载 prompt 配置...")
+    prompt = SimplePrompt(prompt_path)
+
+    print("2. 构建任务消息...")
+    messages = prompt.build_messages()
+
+    print("3. 创建 Agent Runner...")
+    print(f"   - Skills 目录: {skills_dir}")
+    model_key = prompt.config.get("model", "gemini-3-flash-preview")
+    model_id = f"google/{model_key}" if not model_key.startswith("google/") else model_key
+    print(f"   - 模型: {model_id}")
+
+    store = FileSystemTraceStore(base_path=".trace")
+    runner = AgentRunner(
+        trace_store=store,
+        llm_call=create_openrouter_llm_call(model=model_id),
+        skills_dir=skills_dir,
+        experiences_path="./.cache/experiences_overall_derivation.md",
+        debug=True,
+    )
+
+    resume_trace_id = args.trace
+    if resume_trace_id:
+        existing_trace = await store.get_trace(resume_trace_id)
+        if not existing_trace:
+            print(f"\n错误: Trace 不存在: {resume_trace_id}")
+            sys.exit(1)
+        print(f"4. 恢复已有 Trace: {resume_trace_id[:8]}...")
+        print(f"   - 状态: {existing_trace.status}")
+        print(f"   - 消息数: {existing_trace.total_messages}")
+        print(f"   - 任务: {existing_trace.task}")
+    else:
+        print("4. 启动新 Agent 模式...")
+
+    print()
+
+    final_response = ""
+    current_trace_id = resume_trace_id
+    current_sequence = 0
+    should_exit = False
+
     try:
-        print_step(1, "开始执行任务")
-        
-        # 读取prompt文件
-        print_step(2, "读取prompt文件")
-        prompt_file = Path(__file__).parent / "prompt_overall_derivation.md"
-        print(f"  文件路径: {prompt_file}", file=sys.stderr)
-        
-        if not prompt_file.exists():
-            print(f"错误: prompt文件不存在: {prompt_file}", file=sys.stderr)
-            return
-        
-        with open(prompt_file, 'r', encoding='utf-8') as f:
-            prompt_content = f.read()
-        
-        content_length = len(prompt_content)
-        content_lines = len(prompt_content.splitlines())
-        print(f"  文件大小: {content_length} 字符, {content_lines} 行", file=sys.stderr)
-        
-        print_step(3, "准备发送给模型")
-        print(f"  模型: {DEFAULT_MODEL}", file=sys.stderr)
-        print(f"  Prompt内容预览: {prompt_content[:100]}...", file=sys.stderr)
-        
-        print_step(4, "等待模型响应")
-        print("  正在接收模型输出...", file=sys.stderr)
-        
-        last_result = None
-        message_count = 0
-        tool_call_count = 0
-        
-        async for item in runner.run(
-            messages=[{"role": "user", "content": prompt_content}],
-            config=RunConfig(model=DEFAULT_MODEL),
-        ):
-            # 显示处理进度
-            if hasattr(item, '__class__'):
-                class_name = item.__class__.__name__
-                
-                if class_name == 'Message':
-                    message_count += 1
-                    role = getattr(item, 'role', 'unknown')
-                    print(f"  [收到消息 #{message_count}] 角色: {role}", file=sys.stderr)
-                    
-                    if role == 'assistant':
-                        content = item.content
-                        text = ""
-                        
-                        if isinstance(content, dict):
-                            text = content.get('text', '')
-                            tool_calls = content.get('tool_calls', [])
-                            if tool_calls:
-                                tool_call_count += len(tool_calls)
-                                print(f"    [工具调用] 数量: {len(tool_calls)}", file=sys.stderr)
-                        elif isinstance(content, str):
-                            text = content
-                        
-                        if text:
-                            text_preview = text[:200] + "..." if len(text) > 200 else text
-                            print(f"    [文本内容] 长度: {len(text)} 字符", file=sys.stderr)
-                            print(f"    [内容预览] {text_preview}", file=sys.stderr)
-                            last_result = text
-                
-                elif class_name == 'ToolCall':
-                    tool_call_count += 1
-                    tool_name = getattr(item, 'name', 'unknown')
-                    print(f"  [工具调用 #{tool_call_count}] {tool_name}", file=sys.stderr)
-                
-                elif class_name == 'ToolResult':
-                    tool_name = getattr(item, 'tool_name', 'unknown')
-                    print(f"  [工具结果] {tool_name}", file=sys.stderr)
-        
-        print_step(5, "处理完成")
-        print(f"  总计收到消息: {message_count} 条", file=sys.stderr)
-        print(f"  总计工具调用: {tool_call_count} 次", file=sys.stderr)
-        
-        print_step(6, "输出最终结果")
-        if last_result:
-            print("\n" + "="*80, file=sys.stderr)
-            print("最终结果:", file=sys.stderr)
-            print("="*80, file=sys.stderr)
-            print(last_result)
+        if resume_trace_id:
+            initial_messages = None
+            config = RunConfig(
+                model=model_id,
+                temperature=float(prompt.config.get("temperature", 0.3)),
+                max_iterations=1000,
+                trace_id=resume_trace_id,
+            )
         else:
-            print("未获取到最终结果", file=sys.stderr)
-                
-    except Exception as e:
-        print(f"\n[错误] {e}", file=sys.stderr)
-        import traceback
-        traceback.print_exc()
-        raise
-
-if __name__ == '__main__':
-    asyncio.run(main())
+            initial_messages = messages
+            config = RunConfig(
+                model=model_id,
+                temperature=float(prompt.config.get("temperature", 0.3)),
+                max_iterations=1000,
+                name="选题点整体推导任务",
+            )
+
+        while not should_exit:
+            if current_trace_id:
+                config.trace_id = current_trace_id
+
+            final_response = ""
+
+            if current_trace_id and initial_messages is None:
+                check_trace = await store.get_trace(current_trace_id)
+                if check_trace and check_trace.status in ("completed", "failed"):
+                    if check_trace.status == "completed":
+                        print(f"\n[Trace] ✅ 已完成")
+                        print(f"  - Total messages: {check_trace.total_messages}")
+                        print(f"  - Total cost: ${check_trace.total_cost:.4f}")
+                    else:
+                        print(f"\n[Trace] ❌ 已失败: {check_trace.error_message}")
+                    current_sequence = check_trace.head_sequence
+                    menu_result = await show_interactive_menu(
+                        runner, current_trace_id, current_sequence, store
+                    )
+                    if menu_result["action"] == "stop":
+                        break
+                    elif menu_result["action"] == "continue":
+                        new_messages = menu_result.get("messages", [])
+                        if new_messages:
+                            initial_messages = new_messages
+                            config.after_sequence = menu_result.get("after_sequence")
+                        else:
+                            initial_messages = []
+                            config.after_sequence = None
+                        continue
+                    break
+                initial_messages = []
+
+            print(f"{'▶️ 开始执行...' if not current_trace_id else '▶️ 继续执行...'}")
+
+            paused = False
+            try:
+                async for item in runner.run(messages=initial_messages, config=config):
+                    cmd = check_stdin()
+                    if cmd == 'pause':
+                        print("\n⏸️ 正在暂停执行...")
+                        if current_trace_id:
+                            await runner.stop(current_trace_id)
+                        await asyncio.sleep(0.5)
+                        menu_result = await show_interactive_menu(
+                            runner, current_trace_id, current_sequence, store
+                        )
+                        if menu_result["action"] == "stop":
+                            should_exit = True
+                            paused = True
+                            break
+                        elif menu_result["action"] == "continue":
+                            new_messages = menu_result.get("messages", [])
+                            if new_messages:
+                                initial_messages = new_messages
+                                after_seq = menu_result.get("after_sequence")
+                                if after_seq is not None:
+                                    config.after_sequence = after_seq
+                                paused = True
+                                break
+                            else:
+                                initial_messages = []
+                                config.after_sequence = None
+                                paused = True
+                                break
+
+                    elif cmd == 'quit':
+                        print("\n🛑 用户请求停止...")
+                        if current_trace_id:
+                            await runner.stop(current_trace_id)
+                        should_exit = True
+                        break
+
+                    if isinstance(item, Trace):
+                        current_trace_id = item.trace_id
+                        if item.status == "running":
+                            print(f"[Trace] 开始: {item.trace_id[:8]}...")
+                        elif item.status == "completed":
+                            print(f"\n[Trace] ✅ 完成")
+                            print(f"  - Total messages: {item.total_messages}")
+                            print(f"  - Total tokens: {item.total_tokens}")
+                            print(f"  - Total cost: ${item.total_cost:.4f}")
+                        elif item.status == "failed":
+                            print(f"\n[Trace] ❌ 失败: {item.error_message}")
+                        elif item.status == "stopped":
+                            print(f"\n[Trace] ⏸️ 已停止")
+
+                    elif isinstance(item, Message):
+                        current_sequence = item.sequence
+                        if item.role == "assistant":
+                            content = item.content
+                            if isinstance(content, dict):
+                                text = content.get("text", "")
+                                tool_calls = content.get("tool_calls")
+                                if text and not tool_calls:
+                                    final_response = text
+                                    print(f"\n[Response] Agent 回复：")
+                                    print(text)
+                                elif text:
+                                    preview = text[:150] + "..." if len(text) > 150 else text
+                                    print(f"[Assistant] {preview}")
+                                if tool_calls:
+                                    for tc in tool_calls:
+                                        tool_name = tc.get("function", {}).get("name", "unknown")
+                                        print(f"[Tool Call] 🛠️  {tool_name}")
+                        elif item.role == "tool":
+                            content = item.content
+                            if isinstance(content, dict):
+                                tool_name = content.get("tool_name", "unknown")
+                                print(f"[Tool Result] ✅ {tool_name}")
+                            if item.description:
+                                desc = item.description[:80] if len(item.description) > 80 else item.description
+                                print(f"  {desc}...")
+
+            except Exception as e:
+                print(f"\n执行出错: {e}")
+                import traceback
+                traceback.print_exc()
+
+            if paused:
+                if should_exit:
+                    break
+                continue
+
+            if should_exit:
+                break
+
+            if current_trace_id:
+                menu_result = await show_interactive_menu(
+                    runner, current_trace_id, current_sequence, store
+                )
+                if menu_result["action"] == "stop":
+                    break
+                elif menu_result["action"] == "continue":
+                    new_messages = menu_result.get("messages", [])
+                    if new_messages:
+                        initial_messages = new_messages
+                        config.after_sequence = menu_result.get("after_sequence")
+                    else:
+                        initial_messages = []
+                        config.after_sequence = None
+                    continue
+            break
+
+    except KeyboardInterrupt:
+        print("\n\n用户中断 (Ctrl+C)")
+        if current_trace_id:
+            await runner.stop(current_trace_id)
+
+    if final_response:
+        print()
+        print("=" * 60)
+        print("Agent 响应:")
+        print("=" * 60)
+        print(final_response)
+        print("=" * 60)
+        print()
+        output_file = output_dir / "result.txt"
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(final_response)
+        print(f"✓ 结果已保存到: {output_file}")
+        print()
+
+    if current_trace_id:
+        print("=" * 60)
+        print("可视化 Step Tree:")
+        print("=" * 60)
+        print("1. 启动 API Server:")
+        print("   python3 api_server.py")
+        print()
+        print("2. 浏览器访问:")
+        print("   http://localhost:8000/api/traces")
+        print()
+        print(f"3. Trace ID: {current_trace_id}")
+        print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples_how/overall_derivation/presets.json

@@ -0,0 +1,8 @@
+{
+  "evaluate_derivation": {
+    "max_iterations": 30,
+    "temperature": 0.2,
+    "skills": ["planning", "derivation_eval"],
+    "description": "选题点推导评估子 Agent，用于判断推导选题点与帖子解构选题点是否语义匹配，并判断是否需下一轮推导"
+  }
+}

examples_how/overall_derivation/prompt_overall_derivation.md → examples_how/overall_derivation/production.prompt

@@ -1,3 +1,9 @@
+---
+model: gemini-3-flash-preview
+temperature: 0.3
+---
+
+$system$
 # 选题点推导任务
 
 ## 角色
@@ -376,16 +382,15 @@
 
 ## 推导过程
 ### 推导流程
-1. **初始化**：已推导的选题点集合置为空集。
-2. **推导**：以人设分类树、人设 pattern 表、**已推导成功的选题点集合**为输入（不包含帖子单帖解构内容），使用某一下述定义的推导方法，产出**本轮推导出的可能选题点**（含推导过程数据，如边、detail 等）。
-3. **评估验证**：调用评估子 agent 进行验证。
-   - **调用方式**：启动评估子 agent，子 agent 读取 `./prompt_eval.md` 作为 prompt 执行。(prompt_eval.md文件已经存在，无需创建)
-   - **传入子 agent 的输入**：1，历史已推导成功的选题点，2，本轮推导出的可能选题点（包含推导过程数据）；3，子agent的核心prompt文件路径：`./prompt_eval.md`
-   - **子 agent 职责**：1，判断本轮推导的选题点与帖子解构内容的选题点是否语义相似或接近，返回匹配结果。2，判断帖子解构内容的选题点是否还有未推导成功的选题点，如果有，告知主agent还需要进行下一轮推导。
-   - **主 agent 后续动作**：根据子 agent 返回的「本轮匹配成功的选题点」，将其加入已推导成功的选题点集合；未匹配的不加入。
-4. **多轮推导**：评估子agent如果返回还需要进行下一轮推导，则增加新推导的选题点作为新输入进行下一轮推导。
-5. **推导失败后改进重试及探索游走**：在评估验证阶段，若本轮推导出的可能选题点经子 agent 评估后均与帖子选题点不匹配，则更换推导方法或改变调用输入，再次执行第 2 步（推导）。在第 2～3 步中循环执行；若以同样输入重试次数达到 3 次，则不再以此节点进行推导。
-6. **生成结果**：将推导关系构建为节点和边的结构，用于可视化展示，并将整个推导结果按上述输出文件格式写入两个 JSON 文件。
+1. **推导**：以人设分类树、人设 pattern 表、**已推导成功的选题点集合**为输入（不包含帖子单帖解构内容，首轮已推导成功的选题点集合为空），使用某一下述定义的推导方法，产出**本轮推导出的可能选题点**（含推导过程数据，如边、detail 等）。
+2. **评估验证**：调用评估子 agent（evaluate_derivation agent）进行验证。注意：
+   - 使用内置的 `agent` 工具，传入 `agent_type="evaluate_derivation"`，在 `task` 参数中给出：1）历史已推导成功的选题点（JSON）；2）本轮推导出的可能选题点（含推导过程数据）；3）**帖子ID**（不传解构内容路径）。
+   - 评估子 agent 会自动加载本目录下的 skill：`examples_how/overall_derivation/skills/derivation_eval.md` 作为 system prompt；它不直接接收帖子单帖解构内容路径，而是根据传入的**帖子ID**在内部读取 `input/家有大志/解构内容/{帖子ID}.json` 获取单帖解构内容。
+   - 子 agent 职责：判断本轮推导的选题点与帖子解构选题点是否语义相似或接近，返回匹配结果；判断是否还有未推导成功的选题点，若有则告知主 agent 需进行下一轮推导。
+   - 主 agent 后续动作：根据子 agent 返回的「本轮匹配成功的选题点」加入已推导成功的选题点集合；未匹配的不加入；根据「是否需要进行下一轮推导」决定是否继续推导。如需续跑同一子 agent，可通过 `continue_from` 复用该子 agent 的 trace。
+3. **多轮推导**：评估子agent如果返回还需要进行下一轮推导，则增加新推导的选题点作为新输入进行下一轮推导。
+4. **推导失败后改进重试及探索游走**：在评估验证阶段，若本轮推导出的可能选题点经子 agent 评估后均与帖子选题点不匹配，则更换推导方法或改变调用输入，再次执行第 1 步（推导）。在第 1～2 步中循环执行；若以同样输入重试次数达到 3 次，则不再以此节点进行推导。
+5. **生成结果**：将推导关系构建为节点和边的结构，用于可视化展示，并将整个推导结果按上述输出文件格式写入两个 JSON 文件。
 
 ### 推导方法的定义
 每一个推导方法都可以从以下两个角度来定义，两个角度正交，每个角度的单一枚举值组合在一起，定义了一个方法。
@@ -427,3 +432,6 @@
 2. `node_list`中的节点都有必需的字段
 3. `edge_list`中的边都有正确的输入输出节点引用
 4. 推导结果中的成功/失败选题点数量之和等于总选题点数
+
+$user$
+请开始执行 帖子ID=6921937a000000001b0278d1 的选题点整体推导任务。所有路径均相对于项目根目录。

examples_how/overall_derivation/prompt_eval.md → examples_how/overall_derivation/skills/derivation_eval.md

@@ -1,3 +1,8 @@
+---
+name: derivation_eval
+description: 选题点推导评估任务 - 判断推导产出的选题点与帖子解构选题点是否语义一致
+---
+
 # 选题点推导评估任务
 
 ## 角色
@@ -17,8 +22,8 @@
 仅基于「本轮推导出的选题点」的语义与帖子解构选题点做匹配判断，过程数据用于可解释性。
 
 ### 3. 帖子单帖解构内容
-- **路径**: `input/家有大志/解构内容/68fb6a5c000000000302e5de.json`
-- **作用**: 包含帖子的选题点数据（灵感点、目的点、关键点），每个点包含分词结果、实质、形式、意图等分类信息
+- **来源**：本评估子 agent **不直接接收**帖子单帖解构内容路径。主 agent 传入的是**帖子ID**；你需根据帖子ID 自行读取文件：`input/家有大志/解构内容/{帖子ID}.json` 获取单帖解构内容。
+- **作用**: 该 JSON 包含帖子的选题点数据（灵感点、目的点、关键点），每个点包含分词结果、实质、形式、意图等分类信息
 
 **重要：帖子中「选题点」的定义**  
 帖子解构里，**用于匹配的选题点**是**选题点对象中「分词结果」数组里每个词对象的「词」字段**，不是选题点对象顶层的「点」字段。