@huajiwuyan/hello 3.0.0

package/templates/codex/skills/references/stages/tweak.md

@@ -0,0 +1,239 @@
+# 微调模式模块
+
+本模块定义微调模式（≤2文件且≤30行改动）的执行规则。
+
+---
+
+## 模块入口
+
+### 触发条件
+
+```yaml
+前置条件: 需求评估阶段复杂度判定为微调模式
+加载时机: 用户确认进入微调模式后加载
+特点: 直接修改代码，不创建方案包
+```
+
+### 状态设置
+
+```yaml
+设置时机: 本模块被加载时
+设置内容:
+  - CURRENT_STAGE = TWEAK
+  - 保持 WORKFLOW_MODE 不变（继承自需求评估阶段）
+  - 保持 STAGE_ENTRY_MODE = NATURAL
+```
+
+---
+
+## 执行模式适配
+
+<mode_adaptation>
+
+### 模式行为
+
+```yaml
+读取状态变量: WORKFLOW_MODE
+
+"交互模式"（INTERACTIVE，默认）:
+  - 执行下方"执行流程"步骤1-7
+  - 完成后输出结果，等待用户确认
+
+"全授权模式"（AUTO_FULL，~auto命令）:
+  - 静默执行下方"执行流程"步骤1-7（不输出中间状态）
+  - 完成后在总结中列出微调结果
+  - 不单独输出微调完成状态
+
+"规划模式"（AUTO_PLAN，~plan命令）:
+  - "微调模式"不适用于~plan命令（~plan需要生成方案包）
+  - 如判定为微调，自动升级为"轻量迭代模式"，进入项目分析和方案设计
+```
+
+### 阶段流转
+
+```yaml
+微调完成后:
+  执行: 按 G6 状态重置协议执行
+  输出: 按G3场景内容规则（完成场景）输出
+```
+
+</mode_adaptation>
+
+---
+
+## 执行流程
+
+> 📌 触发条件见 G5 微调模式
+
+### 步骤1: 知识库开关检查
+
+按 G1 "KB开关检查规则" 和 "KB_SKIPPED 变量生命周期" 执行。
+
+```yaml
+微调模式特殊规则:
+  - 无论 KB_CREATE_MODE 值如何，微调模式始终设置 KB_SKIPPED = true
+  - CHANGELOG 更新: 按 G1 "目录/文件自动创建规则 - CHANGELOG.md" 处理
+  - 原因: 微调模式是轻量级操作，不触发完整知识库创建
+```
+
+### 步骤2: 定位文件
+
+```yaml
+工具使用:
+  - 文件查找: 根据需求定位目标文件
+  - 内容搜索: 定位具体修改位置
+
+定位失败处理:
+  "交互模式": 询问用户确认
+  "全授权模式": 输出错误，终止流程
+```
+
+### 步骤3: 直接修改
+
+```yaml
+执行规则:
+  - 按需求直接修改代码
+  - 单次修改≤30行
+  - 不创建方案包
+
+修改前检查:
+  - 确认修改范围符合微调条件
+  - 如超出范围: 触发升级判定（见下方"升级判定"章节）
+```
+
+### 步骤4: 知识库同步
+
+```yaml
+执行规则: 按 G1 "目录/文件自动创建规则" 执行
+
+CHANGELOG 更新（微调模式特殊规则）:
+  触发条件: 改动≤2文件且≤30行，无方案包
+  记录位置: helloagents/CHANGELOG.md 的"微调"分类下
+  记录格式: - **[模块名]**: 微调描述 + 类型标注 + 文件路径:行号范围
+
+例外规则（优先于 G1 KB_CREATE_MODE=3 的 ALWAYS 模式）:
+  - 微调模式不触发完整知识库创建（即使 KB_CREATE_MODE=3）
+  - 仅更新 CHANGELOG（如 helloagents/ 目录已存在）
+  - 模块文档不存在时不创建
+  - KB_CREATE_MODE=0 且 helloagents/ 目录不存在时跳过 CHANGELOG 更新
+
+设计理由: 微调模式是轻量级操作，不应产生创建完整知识库的副作用
+```
+
+### 步骤5: 遗留方案包扫描
+
+按 G6 "遗留方案包扫描" 执行。
+
+### 步骤6: 微调后验收
+
+> 按 G8 阶段验收标准（tweak）执行
+
+```yaml
+验收项:
+  - 变更已应用 (警告性): 确认代码已修改
+  - 基础功能正常 (警告性): 快速验证通过（如有测试）
+
+验收方式:
+  变更验证:
+    - 确认目标文件已保存
+    - 确认变更内容与预期一致
+    - 检查是否有语法错误（如 IDE 或编译器报错）
+
+  快速测试验证（如项目有测试）:
+    触发条件: 项目存在测试框架或测试文件
+    验证范围:
+      - 优先: 与修改文件相关的单元测试
+      - 次选: 项目的快速冒烟测试（如有）
+    验证方式:
+      - 执行测试命令，观察测试结果
+      - 仅关注与本次修改相关的测试失败
+    跳过条件:
+      - 项目无测试框架
+      - 无法识别相关测试文件
+      - 测试执行超时（>30秒）
+
+验收失败处理:
+  警告性失败:
+    - 记录到微调报告
+    - 提示用户检查变更
+    - 不阻塞流程完成
+
+自动模式行为: 静默执行，问题记录到验收报告
+```
+
+### 步骤7: 输出与流转
+
+```yaml
+输出: 按"执行模式适配 - 阶段流转"规则执行
+```
+
+---
+
+## 升级判定
+
+```yaml
+触发条件（执行过程中发现以下情况）:
+  - 实际修改超过2个文件
+  - 实际修改超过30行
+  - 发现需要跨模块修改
+  - 检测到 EHRB 风险（按 G2 EHRB 检测规则）
+
+"交互模式"处理:
+  按G3场景内容规则（确认场景）输出升级询问
+
+  用户选择处理:
+    升级:
+      - 保存当前修改内容（不提交）
+      - 保持 WORKFLOW_MODE = INTERACTIVE
+      - 设置 CURRENT_STAGE = ANALYZE
+      - 进入轻量迭代流程（项目分析 → 方案设计）
+      - 方案包中包含已分析的修改内容
+    强制继续:
+      - 继续微调模式
+      - 在CHANGELOG中标注"超范围微调"
+    取消:
+      - 回滚已做的修改（如有）
+      - 按 G6 状态重置协议执行
+
+"全授权模式"处理:
+  - 保持 WORKFLOW_MODE = AUTO_FULL（升级后继续静默执行）
+  - 设置 CURRENT_STAGE = ANALYZE
+  - 自动进入轻量迭代流程
+  - 在最终总结中标注升级原因
+
+"规划模式"处理:
+  - 注意: ~plan命令在 G4 需求评估阶段会将微调升级为轻量迭代，不会进入tweak.md
+  - 如果意外进入: 保持 WORKFLOW_MODE = AUTO_PLAN，升级为轻量迭代
+```
+
+---
+
+## 用户选择处理
+
+> 本章节定义微调模式需要用户确认的场景，供 G3 输出格式统一提取。
+
+### 场景: 升级判定确认
+
+```yaml
+内容要素:
+  - 升级原因: 触发升级的具体原因（超出文件数/行数/跨模块/EHRB）
+  - 当前修改: 已完成的修改内容摘要
+  - 升级说明: 升级后将进入轻量迭代流程
+
+选项:
+  升级: 保存当前修改，进入轻量迭代流程
+  强制继续: 继续微调模式，在CHANGELOG中标注"超范围微调"
+  取消: 回滚已做的修改，按 G6 状态重置协议执行
+```
+
+### 场景: 微调后验收完成
+
+```yaml
+内容要素:
+  - 验收状态: 通过/部分通过
+  - 变更摘要: 修改的文件和行数
+  - 验证结果: 基础功能验证结果（如适用）
+  - 问题汇总: 警告信息（如有）
+
+输出格式: 按G3场景内容规则（完成场景）输出
+```

package/templates/codex/skills/rlm/__init__.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+HelloAGENTS-RLM: Recursive Language Model Engine
+
+基于以下前沿技术:
+- MIT RLM (Recursive Language Models) - Python REPL + 递归自调用
+- Context Folding (OpenReview) - 子轨迹分支 + 折叠 + 摘要保留
+- Google ADK - 三层上下文架构
+- GPT-5.2-Codex - 原生Context Compaction
+
+核心特点:
+- 零MCP预加载开销: 利用Codex原生spawn_agent
+- 三层上下文分离: Working Context / Session Events / Memory
+- 5层递归深度: 分治处理任意规模任务
+- 24并行子Agent: 最大化利用Codex能力
+- 主动Context Folding: 不被动等待溢出
+"""
+
+from .engine import RLMEngine, RLMMode, AgentResult, FoldedTrajectory
+from .context_manager import ContextManager, ContextLayer
+from .agent_orchestrator import AgentOrchestrator, OrchestrationMode
+from .folding import ContextFolder, FoldingStrategy
+from .repl import RLMREPL
+
+__version__ = "1.0.0"
+__all__ = [
+    "RLMEngine",
+    "RLMMode",
+    "AgentResult",
+    "FoldedTrajectory",
+    "ContextManager",
+    "ContextLayer",
+    "AgentOrchestrator",
+    "OrchestrationMode",
+    "ContextFolder",
+    "FoldingStrategy",
+    "RLMREPL",
+]

package/templates/codex/skills/rlm/agent_orchestrator.py

@@ -0,0 +1,422 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+HelloAGENTS-RLM Agent Orchestrator
+子Agent编排器实现
+
+支持四种编排模式:
+1. Sequential Chain (顺序链)
+2. Parallel Fan-out (并行扇出)
+3. Divide & Conquer (分治递归)
+4. Expert Consultation (专家会诊)
+"""
+
+import asyncio
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from .engine import RLMEngine, AgentResult
+
+
+class OrchestrationMode(Enum):
+    """编排模式"""
+    SEQUENTIAL = "sequential"       # 顺序链: A → B → C
+    PARALLEL = "parallel"           # 并行扇出: → [A, B, C] →
+    DIVIDE_CONQUER = "divide"       # 分治递归
+    EXPERT_CONSULT = "expert"       # 专家会诊
+
+
+@dataclass
+class TaskNode:
+    """任务节点"""
+    task_id: str
+    role: str
+    task: str
+    context_hint: List[str] = field(default_factory=list)
+    depends_on: List[str] = field(default_factory=list)
+    timeout: int = 120
+    result: Optional[AgentResult] = None
+    status: str = "pending"  # pending | running | completed | failed
+
+
+@dataclass
+class OrchestrationPlan:
+    """编排计划"""
+    mode: OrchestrationMode
+    nodes: List[TaskNode]
+    merge_strategy: str = "synthesize"
+    max_parallel: int = 24
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+class AgentOrchestrator:
+    """
+    子Agent编排器
+
+    负责:
+    - 任务分解
+    - 依赖管理
+    - 并行/顺序执行
+    - 结果合并
+    """
+
+    def __init__(self, engine: RLMEngine):
+        self.engine = engine
+        self.task_counter = 0
+        self.execution_log: List[Dict[str, Any]] = []
+
+    # ==================== 编排模式实现 ====================
+
+    async def execute_sequential(
+        self,
+        tasks: List[Dict[str, Any]],
+        pass_output: bool = True,
+    ) -> List[AgentResult]:
+        """
+        顺序链执行
+
+        Args:
+            tasks: 任务列表 [{role, task, context_hint}]
+            pass_output: 是否将前一任务输出传递给下一任务
+
+        Returns:
+            按顺序执行的结果列表
+        """
+        results = []
+        previous_output = ""
+
+        for i, task_config in enumerate(tasks):
+            task_desc = task_config.get("task", "")
+
+            # 如果需要传递输出，替换模板
+            if pass_output and previous_output and "{{previous_output}}" in task_desc:
+                task_desc = task_desc.replace("{{previous_output}}", previous_output)
+            elif pass_output and previous_output:
+                task_desc = f"{task_desc}\n\n前置任务输出:\n{previous_output}"
+
+            result = await self.engine.spawn_agent(
+                role=task_config.get("role", "explorer"),
+                task=task_desc,
+                context_hint=task_config.get("context_hint"),
+                timeout=task_config.get("timeout", 120),
+            )
+
+            results.append(result)
+
+            # 记录日志
+            self._log_execution("sequential", i, task_config, result)
+
+            # 如果失败，根据策略决定是否继续
+            if result.status == "failed":
+                break
+
+            # 准备传递给下一任务的输出
+            previous_output = result.to_summary()
+
+        return results
+
+    async def execute_parallel(
+        self,
+        tasks: List[Dict[str, Any]],
+        merge_strategy: str = "synthesize",
+    ) -> tuple[List[AgentResult], str]:
+        """
+        并行扇出执行
+
+        Args:
+            tasks: 任务列表
+            merge_strategy: 合并策略 (concat | synthesize | vote)
+
+        Returns:
+            (结果列表, 合并后的输出)
+        """
+        # 使用engine的batch方法并行执行
+        results = await self.engine.batch(tasks)
+
+        # 记录日志
+        for i, (task_config, result) in enumerate(zip(tasks, results)):
+            self._log_execution("parallel", i, task_config, result)
+
+        # 合并结果
+        merged = self.engine.merge(results, strategy=merge_strategy)
+
+        return results, merged
+
+    async def execute_divide_conquer(
+        self,
+        task: str,
+        subtasks: List[Dict[str, Any]],
+        synthesizer_prompt: str = "综合以下子任务结果",
+        max_depth: int = 3,
+        current_depth: int = 0,
+    ) -> AgentResult:
+        """
+        分治递归执行
+
+        Args:
+            task: 主任务描述
+            subtasks: 子任务列表 (可嵌套)
+            synthesizer_prompt: 综合提示
+            max_depth: 最大递归深度
+            current_depth: 当前深度
+
+        Returns:
+            综合后的结果
+        """
+        if current_depth >= max_depth:
+            # 达到最大深度，直接执行
+            return await self.engine.spawn_agent(
+                role="implementer",
+                task=task,
+            )
+
+        # 并行执行子任务
+        sub_results = []
+        for subtask in subtasks:
+            if "subtasks" in subtask:
+                # 递归处理嵌套子任务
+                result = await self.execute_divide_conquer(
+                    task=subtask.get("task", ""),
+                    subtasks=subtask.get("subtasks", []),
+                    synthesizer_prompt=synthesizer_prompt,
+                    max_depth=max_depth,
+                    current_depth=current_depth + 1,
+                )
+            else:
+                # 叶子任务，直接执行
+                result = await self.engine.spawn_agent(
+                    role=subtask.get("role", "implementer"),
+                    task=subtask.get("task", ""),
+                    context_hint=subtask.get("context_hint"),
+                )
+            sub_results.append(result)
+
+        # 综合子任务结果
+        merged = self.engine.merge(sub_results, strategy="synthesize")
+
+        # 使用synthesizer生成最终结果
+        final_result = await self.engine.spawn_agent(
+            role="synthesizer",
+            task=f"{synthesizer_prompt}\n\n子任务结果:\n{merged}",
+        )
+
+        return final_result
+
+    async def execute_expert_consultation(
+        self,
+        question: str,
+        perspectives: List[str],
+        final_decision_prompt: str = "基于以上专家意见，做出最终决策",
+    ) -> tuple[List[AgentResult], AgentResult]:
+        """
+        专家会诊执行
+
+        Args:
+            question: 需要决策的问题
+            perspectives: 不同视角列表 (如: ["性能", "安全", "可维护性"])
+            final_decision_prompt: 最终决策提示
+
+        Returns:
+            (各专家意见列表, 最终决策)
+        """
+        # 构建多视角任务
+        expert_tasks = [
+            {
+                "role": "analyzer",
+                "task": f"从{perspective}角度分析: {question}",
+            }
+            for perspective in perspectives
+        ]
+
+        # 并行获取各专家意见
+        expert_results, merged_opinions = await self.execute_parallel(
+            tasks=expert_tasks,
+            merge_strategy="synthesize",
+        )
+
+        # 综合决策
+        final_decision = await self.engine.spawn_agent(
+            role="synthesizer",
+            task=f"{final_decision_prompt}\n\n各角度分析:\n{merged_opinions}\n\n原始问题: {question}",
+        )
+
+        return expert_results, final_decision
+
+    # ==================== 高级编排 ====================
+
+    async def execute_plan(self, plan: OrchestrationPlan) -> Dict[str, Any]:
+        """
+        执行编排计划
+
+        Args:
+            plan: 编排计划
+
+        Returns:
+            执行结果
+        """
+        start_time = datetime.now()
+
+        if plan.mode == OrchestrationMode.SEQUENTIAL:
+            tasks = [
+                {
+                    "role": node.role,
+                    "task": node.task,
+                    "context_hint": node.context_hint,
+                    "timeout": node.timeout,
+                }
+                for node in plan.nodes
+            ]
+            results = await self.execute_sequential(tasks)
+            merged = self.engine.merge(results, strategy=plan.merge_strategy)
+
+        elif plan.mode == OrchestrationMode.PARALLEL:
+            tasks = [
+                {
+                    "role": node.role,
+                    "task": node.task,
+                    "context_hint": node.context_hint,
+                    "timeout": node.timeout,
+                }
+                for node in plan.nodes
+            ]
+            results, merged = await self.execute_parallel(
+                tasks=tasks,
+                merge_strategy=plan.merge_strategy,
+            )
+
+        elif plan.mode == OrchestrationMode.DIVIDE_CONQUER:
+            # 转换为分治结构
+            main_task = plan.metadata.get("main_task", "执行任务")
+            subtasks = [
+                {"role": node.role, "task": node.task, "context_hint": node.context_hint}
+                for node in plan.nodes
+            ]
+            result = await self.execute_divide_conquer(
+                task=main_task,
+                subtasks=subtasks,
+            )
+            results = [result]
+            merged = result.to_summary()
+
+        elif plan.mode == OrchestrationMode.EXPERT_CONSULT:
+            question = plan.metadata.get("question", "")
+            perspectives = [node.task for node in plan.nodes]
+            results, final = await self.execute_expert_consultation(
+                question=question,
+                perspectives=perspectives,
+            )
+            results.append(final)
+            merged = final.to_summary()
+
+        else:
+            raise ValueError(f"未知编排模式: {plan.mode}")
+
+        execution_time = (datetime.now() - start_time).total_seconds()
+
+        return {
+            "mode": plan.mode.value,
+            "results": [r.to_dict() for r in results],
+            "merged": merged,
+            "execution_time": execution_time,
+            "node_count": len(plan.nodes),
+        }
+
+    # ==================== 便捷方法 ====================
+
+    def create_sequential_plan(
+        self,
+        tasks: List[Dict[str, Any]],
+    ) -> OrchestrationPlan:
+        """创建顺序编排计划"""
+        nodes = []
+        for i, task in enumerate(tasks):
+            node = TaskNode(
+                task_id=f"seq_{i}",
+                role=task.get("role", "explorer"),
+                task=task.get("task", ""),
+                context_hint=task.get("context_hint", []),
+                depends_on=[f"seq_{i-1}"] if i > 0 else [],
+            )
+            nodes.append(node)
+
+        return OrchestrationPlan(
+            mode=OrchestrationMode.SEQUENTIAL,
+            nodes=nodes,
+        )
+
+    def create_parallel_plan(
+        self,
+        tasks: List[Dict[str, Any]],
+        merge_strategy: str = "synthesize",
+    ) -> OrchestrationPlan:
+        """创建并行编排计划"""
+        nodes = [
+            TaskNode(
+                task_id=f"par_{i}",
+                role=task.get("role", "explorer"),
+                task=task.get("task", ""),
+                context_hint=task.get("context_hint", []),
+            )
+            for i, task in enumerate(tasks)
+        ]
+
+        return OrchestrationPlan(
+            mode=OrchestrationMode.PARALLEL,
+            nodes=nodes,
+            merge_strategy=merge_strategy,
+        )
+
+    def create_expert_plan(
+        self,
+        question: str,
+        perspectives: List[str],
+    ) -> OrchestrationPlan:
+        """创建专家会诊计划"""
+        nodes = [
+            TaskNode(
+                task_id=f"expert_{i}",
+                role="analyzer",
+                task=perspective,
+            )
+            for i, perspective in enumerate(perspectives)
+        ]
+
+        return OrchestrationPlan(
+            mode=OrchestrationMode.EXPERT_CONSULT,
+            nodes=nodes,
+            metadata={"question": question},
+        )
+
+    # ==================== 内部方法 ====================
+
+    def _generate_task_id(self) -> str:
+        """生成任务ID"""
+        self.task_counter += 1
+        return f"task_{self.task_counter}_{datetime.now().strftime('%H%M%S')}"
+
+    def _log_execution(
+        self,
+        mode: str,
+        index: int,
+        task_config: Dict[str, Any],
+        result: AgentResult,
+    ):
+        """记录执行日志"""
+        self.execution_log.append({
+            "mode": mode,
+            "index": index,
+            "role": task_config.get("role"),
+            "task": task_config.get("task", "")[:100],
+            "status": result.status,
+            "timestamp": datetime.now().isoformat(),
+        })
+
+    def get_execution_log(self) -> List[Dict[str, Any]]:
+        """获取执行日志"""
+        return self.execution_log
+
+    def clear_execution_log(self):
+        """清空执行日志"""
+        self.execution_log.clear()