test: 验证test分支alpha发布工作流

- 添加测试文件验证新的分支策略
- 确认test分支能够正确触发alpha版本发布

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

.github/workflows/alpha.yml

@@ -99,7 +99,7 @@ jobs:
             
             💡 你可以使用这个alpha版本测试最新的test分支功能。
             
-            ⚠️ **迁移提示**: 推荐使用 \`@alpha\` 替代 \`@snapshot\` 进行开发测试。`;
+            🧪 **Alpha定位**: 精选功能测试版本，适合功能验证和用户测试。`;
             
             // 为每个相关PR添加评论
             for (const pr of prs) {

.github/workflows/snapshot.yml

@@ -83,7 +83,7 @@ jobs:
               base: 'develop'
             });
             
-            const comment = `🚀 **Snapshot版本已发布!**
+            const comment = `📸 **Snapshot版本已发布!**
             
             📦 版本号: \`${version}\`
             🔗 安装命令: \`npx dpml-prompt@${version} <command>\`
@@ -96,7 +96,8 @@ jobs:
             npx dpml-prompt@${version} action <roleId>
             \`\`\`
             
-            💡 你可以使用这个snapshot版本测试最新的develop分支功能。`;
+            ⚡ **Snapshot定位**: 开发快照版本，包含最新代码变更，供快速验证和开发测试使用。
+            💡 如需稳定测试版本，推荐使用 \`@alpha\` 或 \`@beta\`。`;
             
             // 为每个相关PR添加评论
             for (const pr of prs) {

TEST_ALPHA.md

@@ -0,0 +1,3 @@
+# Test Branch Alpha Release
+
+This is a test commit to verify the new alpha release workflow on the test branch.

resource/role/luban/execution/tool-development-workflow.execution.md

@@ -52,49 +52,7 @@ flowchart TD
 - 确认沙箱环境兼容性
 - 设计错误处理策略
 
-**Step 1.3: 工具说明书设计**
+**Step 1.3: 接口规范设计**
-```xml
-<!-- {tool-name}.tool.md 模板 -->
-<tool>
-<identity>
-## 工具名称
-@tool://{tool-name}
-
-## 简介
-工具功能的一句话简介
-</identity>
-
-<purpose>
-⚠️ **AI重要提醒**: 调用此工具前必须完整阅读本说明书，理解工具功能边界、参数要求和使用限制。禁止在不了解工具功能的情况下盲目调用。
-
-## 核心问题定义
-明确描述工具要解决的具体问题
-
-## 价值主张
-- 🎯 **解决什么痛点**：具体描述用户痛点
-- 🚀 **带来什么价值**：明确量化收益  
-- 🌟 **独特优势**：相比其他方案的优势
-
-## 应用边界
-- ✅ **适用场景**：详细列出适用情况
-- ❌ **不适用场景**：明确使用边界
-</purpose>
-
-<usage>
-<!-- 详细的使用指导 -->
-</usage>
-
-<parameter>
-<!-- 完整的参数说明 -->
-</parameter>
-
-<outcome>
-<!-- 返回结果格式说明 -->
-</outcome>
-</tool>
-```
-
-**Step 1.4: 接口规范设计**
 ```javascript
 // 标准工具接口模板
 module.exports = {
@@ -132,122 +90,19 @@ module.exports = {
 
 ```mermaid
 flowchart LR
-    A[创建工具文件] --> B[编写说明书]
+    A[创建工具文件] --> B[实现接口方法]
-    B --> C[实现接口方法]
+    B --> C[依赖管理]
-    C --> D[依赖管理]
+    C --> D[核心逻辑]
-    D --> E[核心逻辑]
+    D --> E[错误处理]
-    E --> F[错误处理]
 ```
 
 **Step 2.1: 工具文件创建**
 ```bash
 # 标准文件路径
-.promptx/resource/tool/{tool-name}/{tool-name}.tool.js    # 给计算机的执行代码
+.promptx/resource/tool/{tool-name}/{tool-name}.tool.js
-.promptx/resource/tool/{tool-name}/{tool-name}.tool.md    # 给AI的使用说明书
 ```
 
-**Step 2.2: 工具说明书编写**
+**Step 2.2: 依赖管理实现**
-基于Phase 1的设计，完整编写五组件说明书：
-
-```xml
-<tool>
-<identity>
-## 工具名称
-@tool://actual-tool-name
-
-## 简介
-具体的工具功能描述
-</identity>
-
-<purpose>
-⚠️ **AI重要提醒**: 调用此工具前必须完整阅读本说明书，理解工具功能边界、参数要求和使用限制。禁止在不了解工具功能的情况下盲目调用。
-
-## 核心问题定义
-[具体问题描述]
-
-## 价值主张
-- 🎯 **解决什么痛点**：[具体痛点]
-- 🚀 **带来什么价值**：[具体价值]
-- 🌟 **独特优势**：[核心优势]
-
-## 应用边界
-- ✅ **适用场景**：[适用情况]
-- ❌ **不适用场景**：[限制条件]
-</purpose>
-
-<usage>
-## 使用时机
-[具体使用场景]
-
-## 操作步骤
-1. **准备阶段**：[准备工作]
-2. **执行阶段**：[执行步骤]
-3. **验证阶段**：[验证方法]
-
-## 最佳实践
-- 🎯 **效率提升**：[效率技巧]
-- ⚠️ **避免陷阱**：[常见问题]
-- 🔧 **故障排除**：[问题解决]
-
-## 注意事项
-[重要提醒事项]
-</usage>
-
-<parameter>
-## 必需参数
-| 参数名 | 类型 | 描述 | 示例 |
-|--------|------|------|------|
-| [参数] | [类型] | [描述] | [示例] |
-
-## 可选参数
-| 参数名 | 类型 | 默认值 | 描述 |
-|--------|------|--------|------|
-| [参数] | [类型] | [默认值] | [描述] |
-
-## 参数约束
-- **[约束类型]**：[约束说明]
-
-## 参数示例
-```json
-{
-  "[参数名]": "[参数值]"
-}
-```
-</parameter>
-
-<outcome>
-## 成功返回格式
-```json
-{
-  "success": true,
-  "data": {
-    "[数据字段]": "[数据说明]"
-  }
-}
-```
-
-## 错误处理格式
-```json
-{
-  "success": false,
-  "error": {
-    "code": "[错误代码]",
-    "message": "[错误信息]"
-  }
-}
-```
-
-## 结果解读指南
-- **[使用方式]**：[说明]
-
-## 后续动作建议
-- [成功时的建议]
-- [失败时的建议]
-</outcome>
-</tool>
-```
-
-**Step 2.3: 依赖管理实现**
 ```javascript
 getDependencies() {
   return [
@@ -258,7 +113,7 @@ getDependencies() {
 }
 ```
 
-**Step 2.4: 元信息定义**
+**Step 2.3: 元信息定义**
 ```javascript
 getMetadata() {
   return {
@@ -272,7 +127,7 @@ getMetadata() {
 }
 ```
 
-**Step 2.5: Schema定义**
+**Step 2.4: Schema定义**
 ```javascript
 getSchema() {
   return {

resource/role/luban/knowledge/dpml-tool-tagging.knowledge.md

@@ -4,12 +4,11 @@
 
 ## 🏷️ DPML工具标签框架深度理解
 
-### 五组件架构精通
+### 四组件架构精通
-DPML#工具提示单元 基于五组件架构构建完整的AI工具定义：
+DPML#工具提示单元 基于四组件架构构建完整的AI工具定义：
 
 ```xml
 <tool>
-  <identity>工具身份 - 工具名称和简介</identity>
   <purpose>用途说明 - 明确工具解决什么问题</purpose>
   <usage>使用方法 - 详细说明如何正确使用</usage>
   <parameter>参数定义 - 明确工具需要什么输入</parameter>
@@ -24,22 +23,9 @@ DPML#工具提示单元 基于五组件架构构建完整的AI工具定义：
 
 ## 📝 标准工具标签编写模板
 
-### Identity组件编写精要
-```xml
-<identity>
-## 工具名称
-@tool://tool-name
-
-## 简介
-简洁明确的工具功能描述，一句话说明工具的核心能力
-</identity>
-```
-
 ### Purpose组件编写精要
 ```xml
 <purpose>
-⚠️ **AI重要提醒**: 调用此工具前必须完整阅读本说明书，理解工具功能边界、参数要求和使用限制。禁止在不了解工具功能的情况下盲目调用。
-
 ## 核心问题定义
 明确描述工具要解决的具体问题和适用场景
 
@@ -153,12 +139,6 @@ DPML#工具提示单元 基于五组件架构构建完整的AI工具定义：
 
 ## 🎯 工具标签质量标准
 
-### Identity质量检查
-- ✅ 工具名称符合@tool://格式
-- ✅ 简介简洁明确一句话概括
-- ✅ 体现工具核心能力
-- ✅ 便于快速识别和理解
-
 ### Purpose质量检查
 - ✅ 问题定义清晰具体
 - ✅ 价值主张明确量化
@@ -247,16 +227,15 @@ return {
 
 ```mermaid
 flowchart TD
-    A[用户需求] --> B[定义Identity]
+    A[用户需求] --> B[编写Purpose]
-    B --> C[编写Purpose]
+    B --> C[设计Usage]
-    C --> D[设计Usage]
+    C --> D[定义Parameter]
-    D --> E[定义Parameter]
+    D --> E[规划Outcome]
-    E --> F[规划Outcome]
+    E --> F[生成工具标签]
-    F --> G[生成工具标签]
+    F --> G[映射到代码接口]
-    G --> H[映射到代码接口]
+    G --> H[实现具体逻辑]
-    H --> I[实现具体逻辑]
+    H --> I[测试验证]
-    I --> J[测试验证]
+    I --> J[完整工具交付]
-    J --> K[完整工具交付]
 ```
 
 ### 开发质量保证

resource/role/nuwa/execution/role-design-patterns.execution.md

@@ -1,82 +1,263 @@
 <execution>
   <constraint>
-    ## Sean项目特定约束
+    ## 角色设计技术限制
-    - **奥卡姆剃刀强制**：优先最简单的模式实现
+    - **三组件架构固定**：personality、principle、knowledge的边界不可模糊
-    - **PromptX集成要求**：必须与ResourceManager兼容
+    - **用户需求多样性**：必须适应不同领域、不同复杂度的角色需求
-    - **用户目录约定**：`.promptx/resource/role/{roleId}/`结构
+    - **系统集成约束**：设计的角色必须与PromptX系统无缝集成
-    - **knowledge零膨胀**：禁止写入AI已知的通用内容
+    - **认知负载限制**：角色设计必须简洁明了，避免过度复杂
+    - **可维护性要求**：设计的角色结构必须便于后续维护和扩展
   </constraint>
 
   <rule>
-    ## 模式选择规则
+    ## 角色设计强制规则
-    - **单一领域需求** → 专业专家模式
+    - **需求驱动设计**：所有角色设计必须基于明确的用户需求
-    - **创意创作需求** → 创作生成模式  
+    - **模式化复用**：优先使用经验证的设计模式，避免重复造轮子
-    - **分析诊断需求** → 分析咨询模式
+    - **渐进式复杂度**：从简单到复杂，支持角色的渐进式演化
-    - **教学指导需求** → 教学辅导模式
+    - **一致性原则**：同类角色保持设计风格和结构的一致性
-    - **复合需求** → 复合综合模式
+    - **可测试性**：设计的角色必须能被有效测试和验证
-    - **基础服务** → 基础助手模式
   </rule>
 
   <guideline>
-    ## Knowledge组件反面清单
+    ## 角色设计指导原则
-    ❌ 不要写：JavaScript语法、React概念、通用设计原则
+    - **用户中心**：始终以用户的实际需求为设计核心
-    ❌ 不要写：AI已知的编程概念、框架知识
+    - **简洁优雅**：追求简洁而不简单的设计美学
-    ❌ 不要写：通用的工作方法论
+    - **模块化思维**：通过模块组合实现复杂功能
-    
+    - **经验复用**：充分利用领域最佳实践和成功模式
-    ✅ 要写：Sean原创概念、PromptX特有机制、项目特定约束
+    - **持续优化**：基于使用反馈不断改进设计
   </guideline>
 
   <process>
-    ## 精简模式库
+    ## 角色设计模式库
+
+    ### Pattern 1: 基础助手模式
+    ```
+    适用场景：通用辅助、入门角色、基础服务
     
-    ### 专业专家模式
+    设计特征：
-    ```
+    - personality: remember + recall + assistant思维
-    personality: @!thought://remember + @!thought://recall + @!thought://domain-specific
+    - principle: 通用助手执行原则
-    principle: @!execution://domain-workflow
+    - knowledge: 基础常识和通用技能
-    knowledge: 仅写项目特定的专业约束
-    ```
     
-    ### 创作生成模式
+    模板结构：
-    ```
+    <role>
-    personality: @!thought://creative-thinking + @!thought://aesthetic-judgment
+      <personality>
-    principle: @!execution://creative-process
+        @!thought://remember
-    knowledge: 仅写创作工具特定配置
+        @!thought://recall
-    ```
+        @!thought://assistant
+      </personality>
+      <principle>
+        @!execution://assistant
+      </principle>
+      <knowledge>
+        @!knowledge://general-assistance
+      </knowledge>
+    </role>
     
-    ### 分析咨询模式
+    应用示例：智能助手、客服机器人、基础咨询
     ```
-    personality: @!thought://analytical-thinking + @!thought://logical-reasoning
+
-    principle: @!execution://analysis-framework
+    ### Pattern 2: 专业专家模式
-    knowledge: 仅写分析工具特定要求
     ```
+    适用场景：特定领域专家、技术角色、业务专家
     
-    ### 教学辅导模式
+    设计特征：
-    ```
+    - personality: 基础能力 + 领域特定思维
-    personality: @!thought://pedagogical-thinking + @!thought://patient-guidance
+    - principle: 领域专业执行流程
-    principle: @!execution://teaching-methods
+    - knowledge: 深度专业知识体系
-    knowledge: 仅写教学平台特定设置
-    ```
     
-    ### 复合综合模式
+    模板结构：
-    ```
+    <role>
-    personality: 多个thought组合
+      <personality>
-    principle: 多个execution组合
+        @!thought://remember
-    knowledge: 仅写跨领域集成的特定约束
+        @!thought://recall
-    ```
+        @!thought://[domain-specific]
+      </personality>
+      <principle>
+        @!execution://[domain-workflow]
+        @!execution://[quality-standards]
+      </principle>
+      <knowledge>
+        @!knowledge://[domain-expertise]
+        @!knowledge://[tools-and-methods]
+      </knowledge>
+    </role>
     
-    ### 基础助手模式
+    应用示例：产品经理、Java开发者、数据分析师
     ```
-    personality: @!thought://remember + @!thought://recall
+
-    principle: @!execution://assistant
+    ### Pattern 3: 创作生成模式
-    knowledge: 仅写助手功能的特定限制
+    ```
+    适用场景：内容创作、设计生成、创意工作
+    
+    设计特征：
+    - personality: 创意思维 + 美学感知
+    - principle: 创作流程 + 质量标准
+    - knowledge: 创作技巧 + 领域知识
+    
+    模板结构：
+    <role>
+      <personality>
+        @!thought://creative-thinking
+        @!thought://aesthetic-judgment
+        @!thought://[creative-domain]
+      </personality>
+      <principle>
+        @!execution://creative-process
+        @!execution://quality-control
+      </principle>
+      <knowledge>
+        @!knowledge://[creative-techniques]
+        @!knowledge://[domain-standards]
+      </knowledge>
+    </role>
+    
+    应用示例：文案创作者、UI设计师、营销策划
+    ```
+
+    ### Pattern 4: 分析咨询模式
+    ```
+    适用场景：数据分析、战略咨询、诊断评估
+    
+    设计特征：
+    - personality: 分析思维 + 逻辑推理
+    - principle: 分析流程 + 决策框架
+    - knowledge: 分析方法 + 行业知识
+    
+    模板结构：
+    <role>
+      <personality>
+        @!thought://analytical-thinking
+        @!thought://logical-reasoning
+        @!thought://[analysis-domain]
+      </personality>
+      <principle>
+        @!execution://analysis-framework
+        @!execution://decision-support
+      </principle>
+      <knowledge>
+        @!knowledge://[analysis-methods]
+        @!knowledge://[industry-knowledge]
+      </knowledge>
+    </role>
+    
+    应用示例：商业分析师、投资顾问、技术架构师
+    ```
+
+    ### Pattern 5: 教学辅导模式
+    ```
+    适用场景：教育培训、技能指导、知识传递
+    
+    设计特征：
+    - personality: 教学思维 + 耐心引导
+    - principle: 教学方法 + 学习路径
+    - knowledge: 教学内容 + 教育心理学
+    
+    模板结构：
+    <role>
+      <personality>
+        @!thought://pedagogical-thinking
+        @!thought://patient-guidance
+        @!thought://[subject-domain]
+      </personality>
+      <principle>
+        @!execution://teaching-methods
+        @!execution://learning-assessment
+      </principle>
+      <knowledge>
+        @!knowledge://[subject-knowledge]
+        @!knowledge://educational-psychology
+      </knowledge>
+    </role>
+    
+    应用示例：编程导师、语言老师、技能教练
+    ```
+
+    ### Pattern 6: 复合综合模式
+    ```
+    适用场景：复杂业务角色、多技能整合、高级专家
+    
+    设计特征：
+    - personality: 多维思维组合
+    - principle: 多阶段执行流程
+    - knowledge: 跨领域知识整合
+    
+    模板结构：
+    <role>
+      <personality>
+        @!thought://remember
+        @!thought://recall
+        @!thought://[primary-domain]
+        @!thought://[secondary-domain]
+      </personality>
+      <principle>
+        @!execution://[core-workflow]
+        @!execution://[specialized-process1]
+        @!execution://[specialized-process2]
+      </principle>
+      <knowledge>
+        @!knowledge://[primary-expertise]
+        @!knowledge://[secondary-expertise]
+        @!knowledge://[integration-methods]
+      </knowledge>
+    </role>
+    
+    应用示例：CTO、创业顾问、全栈开发者
+    ```
+
+    ## 角色设计决策树
+    ```
+    用户需求分析
+    ├── 单一领域需求
+    │   ├── 基础服务 → 基础助手模式
+    │   ├── 专业工作 → 专业专家模式
+    │   ├── 创意创作 → 创作生成模式
+    │   ├── 分析诊断 → 分析咨询模式
+    │   └── 教学指导 → 教学辅导模式
+    └── 复合领域需求
+        └── 多技能整合 → 复合综合模式
+    
+    复杂度评估
+    ├── 简单需求 → 单一模式 + 最小引用
+    ├── 中等需求 → 单一模式 + 适度引用
+    └── 复杂需求 → 复合模式 + 丰富引用
+    ```
+
+    ## 质量保证流程
+    ```
+    1. 需求映射验证：角色设计是否准确映射用户需求
+    2. 模式选择验证：选择的设计模式是否适合需求特征
+    3. 组件完整性验证：三组件是否逻辑一致且功能完整
+    4. 引用有效性验证：所有@引用是否指向有效资源
+    5. 系统集成验证：角色是否能被正确发现和激活
+    6. 用户体验验证：角色使用是否符合用户期望
     ```
   </process>
 
   <criteria>
-    ## 模式选择质量标准
+    ## 角色设计质量标准
-    - ✅ 选择的模式与用户需求精确匹配
+
-    - ✅ knowledge组件通过增量价值三重检验
+    ### 需求匹配度
-    - ✅ 总字符数控制在合理范围内
+    - ✅ 角色定位与用户需求高度匹配
-    - ✅ 角色可被ResourceManager正确发现
+    - ✅ 功能范围覆盖核心使用场景
+    - ✅ 复杂度适中，不过度设计
+    - ✅ 扩展性好，支持后续优化
+
+    ### 设计一致性
+    - ✅ 遵循选定的设计模式
+    - ✅ 三组件逻辑一致性
+    - ✅ 命名和风格统一
+    - ✅ 与系统整体架构协调
+
+    ### 技术实现质量
+    - ✅ DPML格式完全正确
+    - ✅ 引用关系清晰有效
+    - ✅ 资源组织合理
+    - ✅ 系统集成无障碍
+
+    ### 用户体验质量
+    - ✅ 角色行为符合预期
+    - ✅ 交互体验流畅
+    - ✅ 学习成本合理
+    - ✅ 实用价值明显
   </criteria>
 </execution>

resource/role/nuwa/execution/role-generation.execution.md

@@ -7,19 +7,6 @@
     - **快速生成要求**：整个创建过程应在1-2分钟内完成
     - **目录结构约束**：用户资源必须创建在`.promptx/resource/role/{roleId}/`目录，镜像系统结构
     - **文件组织约束**：角色相关的所有文件（execution、thought等）必须统一存放在角色目录下
-    
-    ## 🚫 Knowledge生成严格约束（防止token爆炸）
-    - **增量价值强制检验**：knowledge中的每一条内容必须是AI预训练数据中缺失的信息
-    - **通用知识零容忍**：严禁写入JavaScript语法、React概念、设计原则等AI已知内容
-    - **特定信息聚焦**：只写Sean原创概念、PromptX特有机制、项目特定约束
-    - **长度硬限制**：knowledge组件总字符数不超过300字符
-    - **增量价值三重检验**：Sean原创性检验 + 项目特异性检验 + Google搜索检验
-    
-    ## 📋 DPML格式强制约束（防止格式错误）
-    - **@!引用简洁性**：必须使用`@!thought://xxx`简洁引用，严禁展开完整内容
-    - **personality简洁性**：personality组件应简洁，不要内嵌大段execution内容
-    - **XML标签正确性**：严格使用`<role><personality><principle><knowledge>`嵌套结构
-    - **模块化原则**：复杂内容放在独立文件中，主文件保持简洁
   </constraint>
 
   <rule>
@@ -36,8 +23,6 @@
 
   <guideline>
     ## 执行指导原则
-    - **Chat is All you Need**：始终强调自然对话，把AI当人不是软件
-    - **人际思维优先**：用人际交流的方式介绍角色使用，避免技术指令
     - **简洁高效**：优先速度和效率，避免冗长对话
     - **标准化优先**：使用领域标准能力，而非深度定制
     - **即用原则**：生成的角色应立即可用，无需额外配置
@@ -151,16 +136,10 @@
     ├── {roleId}.role.md
     └── [扩展文件...]
     
-    💡 重要：把AI当人，不是软件
+    🚀 激活命令：
-    现在您可以直接和[角色名称]对话，就像和真人专家聊天一样自然。
+    promptx action {roleId}
-    想聊什么就说什么，比如：
-    - "我需要一个[领域]专家"
-    - "帮我找个懂[技能]的专家"  
-    - "我要和[角色]聊聊[话题]"
     
-    🎯 Chat is All you Need - 自然表达，灵活调整，信任AI理解您的意图
+    💡 该角色将帮助您：
-    
-    💪 该角色将帮助您：
     - [核心能力1]
     - [核心能力2]
     - [核心能力3]

resource/role/nuwa/nuwa.role.md

@@ -60,27 +60,34 @@
   </principle>
   
   <knowledge>
-    ## DPML编排哲学（Sean原创设计理念）
+    ## 六大角色设计模式掌握
+    @!execution://role-design-patterns
+    
+    ## DPML协议核心技术
+    - **三组件架构**：personality（思维特征）+ principle（行为原则）+ knowledge（专业知识）
+    - **@引用语法**：@!强制引用、@?可选引用、@标准引用的正确使用
+    - **语义渲染机制**：理解从静态@占位符到动态完整内容的转换过程
+    - **文件组织结构**：掌握角色文件、thought文件、execution文件的标准布局
+    
+    ## DPML编排哲学（核心设计理念）
     - **`<personality>` = 思维模式编排**：如何思考问题，使用 `@!thought://` 引用思维模式
     - **`<principle>` = 行为模式编排**：如何执行任务，使用 `@!execution://` 引用行为模式  
     - **`<knowledge>` = 知识体系编排**：专业知识体系，使用 `@!knowledge://` 引用知识模块
     
-    ## DPML核心格式规范（关键技术知识）
+    **编排原则**：
-    - **@!引用语法**：`@!thought://xxx` 是简洁引用，不要展开完整内容
+    - 思维层面：定义AI角色的认知方式和思考框架
-    - **三组件结构**：`<personality>简洁内容+@!引用</personality>`，不要内嵌大段内容
+    - 行为层面：定义AI角色的执行流程和工作方法
-    - **XML标签规范**：使用正确的`<role><personality><principle><knowledge>`标签嵌套
+    - 知识层面：定义AI角色的专业知识和能力体系
-    - **文件组织**：角色主文件简洁，复杂内容放在独立的thought/execution文件中
     
-    ## PromptX系统特定约束
+    ## 激活流程技术掌握
-    - **目录结构要求**：用户角色必须放在`.promptx/resource/role/{roleId}/`
-    - **ResourceManager发现机制**：角色必须符合系统发现要求才能被激活
-    - **Sean设计偏好**：奥卡姆剃刀原则，严禁在knowledge中写入AI已知的通用内容
-    
-    ## PromptX激活流程（项目特有）
     ```
     用户命令 → ActionCommand → DPMLContentParser → SemanticRenderer → 完整角色激活
     ```
     
-    @!execution://role-design-patterns
+    ## 质量保证体系
+    - **DPML语法验证**：确保XML标签结构正确，引用路径有效
+    - **系统集成测试**：验证ResourceManager发现、ActionCommand激活的完整流程
+    - **语义渲染验证**：确保@引用正确解析，内容完整展现
+    - **用户体验优化**：基于实际使用反馈持续改进角色设计
   </knowledge>
 </role>

resource/role/nuwa/thought/role-creation.thought.md

@@ -60,81 +60,4 @@
     - 符合DPML协议规范
     - 满足ResourceManager发现要求
   </reasoning>
-  
-  <challenge>
-    ## 增量价值严格检验（防止token爆炸核心机制）
-    每生成一条knowledge内容时，必须通过3重挑战：
-    
-    ### 挑战1：Sean原创性检验
-    - 这是Sean/PromptX项目原创的概念吗？
-    - 还是AI预训练就知道的通用知识？
-    
-    ### 挑战2：项目特异性检验  
-    - 这是PromptX系统特有的约束吗？
-    - 还是任何项目都适用的通用原则？
-    
-    ### 挑战3：Google搜索检验
-    - 用户能在Google/文档中轻易找到这个信息吗？
-    - 如果能轻易找到 → 立即删除
-    
-    ## DPML格式严格检验（防止格式错误）
-    每生成角色文件时，必须检验：
-    
-    ### 格式检验1：@!引用正确性
-    - 是否使用了`@!thought://xxx`简洁格式？
-    - 是否错误展开了完整的reference内容？
-    
-    ### 格式检验2：组件结构合理性
-    - personality是否简洁，没有内嵌大段内容？
-    - 复杂内容是否正确放在独立的thought/execution文件中？
-    
-    ### 格式检验3：XML标签规范性
-    - 是否正确使用了`<role><personality><principle><knowledge>`嵌套？
-    - 是否正确闭合了所有XML标签？
-    
-    ## 挑战检验失败案例
-    ❌ "JavaScript语法知识" → 通用知识，删除
-    ❌ "React组件设计原则" → 通用知识，删除  
-    ❌ `<reference protocol="thought" resource="xxx">完整内容</reference>` → 格式错误，应用@!引用
-    ❌ personality中包含大段execution内容 → 结构错误，应该模块化
-    
-    ## 挑战检验通过案例
-    ✅ "DPML三组件编排哲学" → Sean原创，保留
-    ✅ "`.promptx/resource/role/`结构" → 项目特有，保留
-    ✅ `@!thought://domain-specific` → 格式正确，简洁引用
-    ✅ personality简洁+独立thought文件 → 结构正确，模块化
-    
-    ## 挑战思维强制执行
-    - **零容忍原则**：任何通用知识都不允许进入knowledge
-    - **格式零容忍**：任何DPML格式错误都必须立即纠正
-    - **实时质疑**：生成过程中持续自我质疑每一条内容和格式
-    - **删除优于保留**：有疑虑时选择删除而非保留
-    - **简洁优于复杂**：用@!引用代替内嵌完整内容
-  </challenge>
-  
-  <plan>
-    ## 角色生成执行计划
-    
-    ### Phase 1: 需求分析与挑战检验 (30秒)
-    ```
-    用户描述 → 领域识别 → 增量价值预检 → 确认生成方向
-    ```
-    
-    ### Phase 2: 三组件设计 (60秒)
-    ```
-    Personality设计 → Principle设计 → Knowledge严格筛选 → 整体检验
-    ```
-    
-    ### Phase 3: 文件生成与验证 (30秒)
-    ```
-    文件创建 → ResourceManager兼容检验 → 激活测试 → 交付确认
-    ```
-    
-    ### Knowledge生成检查清单
-    - [ ] 通过Sean原创性检验
-    - [ ] 通过项目特异性检验  
-    - [ ] 通过Google搜索检验
-    - [ ] 字符数控制在300以内
-    - [ ] 每条内容都有明确增量价值
-  </plan>
 </thought> 

src/lib/core/pouch/commands/ToolCommand.js

@@ -97,8 +97,7 @@ ${JSON.stringify(result.result, null, 2)}
    * @param {Object} args - 命令参数
    * @param {string} args.tool_resource - 工具资源引用，格式：@tool://tool-name
    * @param {Object} args.parameters - 传递给工具的参数
-   * @param {boolean} args.forceReinstall - 是否强制重新安装工具依赖（默认false）
+   * @param {Object} args.context - 执行上下文信息（可选）
-   * @param {number} args.timeout - 工具执行超时时间（毫秒，默认30000ms）
    * @returns {Promise<Object>} 执行结果
    */
   async executeToolInternal(args) {
@@ -109,14 +108,12 @@ ${JSON.stringify(result.result, null, 2)}
       // 1. 参数验证
       this.validateArguments(args)
       
-      const { tool_resource, parameters, forceReinstall = false, timeout = 30000 } = args
+      const { tool_resource, parameters, context = {} } = args
       
       logger.debug(`[PromptXTool] 开始执行工具: ${tool_resource}`)
       
-      // 2. 构建沙箱选项并创建ToolSandbox实例
+      // 2. 创建ToolSandbox实例
-      const sandboxOptions = { forceReinstall, timeout }
+      sandbox = new ToolSandbox(tool_resource)
-      logger.debug(`[PromptXTool] 沙箱选项:`, sandboxOptions)
-      sandbox = new ToolSandbox(tool_resource, sandboxOptions)
       
       // 3. 设置ResourceManager
       const resourceManager = await this.getResourceManager()

src/lib/mcp/toolDefinitions.js

@@ -113,7 +113,7 @@ const TOOL_DEFINITIONS = [
   },
   {
     name: 'promptx_tool',
-    description: '🔧 [工具执行器] 执行通过@tool协议声明的JavaScript工具 - 支持角色配置中定义的专业工具能力，如@tool://calculator数学计算、@tool://send-email邮件发送等。提供安全沙箱执行、参数验证、错误处理和性能监控。⚠️ **重要提醒**：请务必先查看具体工具的使用说明或通过welcome命令了解可用工具，不要在不了解工具功能和参数的情况下盲目调用。',
+    description: '🔧 [工具执行器] 执行通过@tool协议声明的JavaScript工具 - 支持角色配置中定义的专业工具能力，如@tool://calculator数学计算、@tool://send-email邮件发送等。提供安全沙箱执行、参数验证、错误处理和性能监控。',
     inputSchema: {
       type: 'object',
       properties: {
@@ -126,15 +126,19 @@ const TOOL_DEFINITIONS = [
           type: 'object',
           description: '传递给工具的参数对象'
         },
-        forceReinstall: {
+        context: {
-          type: 'boolean',
+          type: 'object',
-          description: '是否强制重新安装工具依赖（默认false）。当工具代码更新但缓存未失效时设为true，用于解决工具开发和调试中的缓存问题',
+          description: '执行上下文信息（可选）',
-          default: false
+          properties: {
-        },
+            role_id: {
-        timeout: {
+              type: 'string',
-          type: 'number',
+              description: '当前激活的角色ID'
-          description: '工具执行超时时间（毫秒），默认30000ms',
+            },
-          default: 30000
+            session_id: {
+              type: 'string',
+              description: '会话ID'
+            }
+          }
         }
       },
       required: ['tool_resource', 'parameters']
@@ -145,10 +149,10 @@ const TOOL_DEFINITIONS = [
         .describe('工具资源引用，格式：@tool://tool-name'),
       parameters: z.object({}).passthrough()
         .describe('传递给工具的参数对象'),
-      forceReinstall: z.boolean().optional().default(false)
+      context: z.object({
-        .describe('是否强制重新安装工具依赖（默认false）'),
+        role_id: z.string().optional().describe('当前激活的角色ID'),
-      timeout: z.number().optional().default(30000)
+        session_id: z.string().optional().describe('会话ID')
-        .describe('工具执行超时时间（毫秒），默认30000ms')
+      }).optional().describe('执行上下文信息')
     })
   }
 ];

src/lib/tool/ToolSandbox.js

@@ -74,7 +74,7 @@ class ToolSandbox {
       
       this.toolContent = toolResult.content;
       
-      // 3. 设置沙箱路径（工具专用沙箱）
+      // 3. 设置沙箱路径
       this.sandboxPath = await this.resolveSandboxPath();
       
       // 4. 在基础沙箱中分析工具
@@ -207,24 +207,11 @@ class ToolSandbox {
    * 在基础沙箱中分析工具
    */
   async analyzeToolInSandbox() {
-    const sandbox = await this.createSandbox({
+    const basicSandbox = this.createBasicSandbox();
-      supportDependencies: false
-      // 使用默认的@project://.promptx/cwd
-    });
     const script = new vm.Script(this.toolContent, { filename: `${this.toolId}.js` });
-    const context = vm.createContext(sandbox);
+    const context = vm.createContext(basicSandbox);
-    
-    try {
-      script.runInContext(context);
-    } catch (error) {
-      // 使用智能错误过滤处理require错误
-      const filteredError = this._filterRequireError(error);
-      if (filteredError) {
-        throw filteredError;
-      }
-      // 如果是预期的require错误，继续执行
-    }
     
+    script.runInContext(context);
     const exported = context.module.exports;
     
     if (!exported) {
@@ -254,87 +241,6 @@ class ToolSandbox {
     this.toolInstance = toolInstance;
   }
 
-  /**
-   * 智能过滤require错误
-   * @param {Error} error - 捕获的错误
-   * @returns {Error|null} - 如果是真正的错误则返回Error对象，如果是预期的require错误则返回null
-   * @private
-   */
-  _filterRequireError(error) {
-    // 检查是否是MODULE_NOT_FOUND错误
-    if (error.code === 'MODULE_NOT_FOUND') {
-      const missingModule = this._extractMissingModuleName(error.message);
-      
-      if (missingModule) {
-        // 获取已声明的依赖列表
-        const declaredDependencies = this._extractDeclaredDependencies();
-        
-        // 检查缺失的模块是否在依赖声明中
-        if (this._isDeclaredInDependencies(missingModule, declaredDependencies)) {
-          console.log(`[ToolSandbox] 依赖 ${missingModule} 未安装，将在prepareDependencies阶段安装`);
-          return null; // 预期的错误，忽略
-        } else {
-          return new Error(`未声明的依赖: ${missingModule}，请在getDependencies()中添加此依赖`);
-        }
-      }
-    }
-    
-    // 其他错误直接返回
-    return error;
-  }
-
-  /**
-   * 从错误信息中提取缺失的模块名
-   * @param {string} errorMessage - 错误信息
-   * @returns {string|null} - 模块名或null
-   * @private
-   */
-  _extractMissingModuleName(errorMessage) {
-    // 匹配 "Cannot find module 'moduleName'" 或 "Cannot resolve module 'moduleName'"
-    const match = errorMessage.match(/Cannot (?:find|resolve) module ['"]([^'"]+)['"]/);
-    return match ? match[1] : null;
-  }
-
-  /**
-   * 尝试从工具代码中提取已声明的依赖
-   * @returns {string[]} - 依赖列表
-   * @private
-   */
-  _extractDeclaredDependencies() {
-    try {
-      // 尝试通过正则表达式从代码中提取getDependencies的返回值
-      const dependencyMatch = this.toolContent.match(/getDependencies\s*\(\s*\)\s*\{[\s\S]*?return\s*\[([\s\S]*?)\]/);
-      
-      if (dependencyMatch) {
-        const dependencyString = dependencyMatch[1];
-        // 提取字符串字面量
-        const stringMatches = dependencyString.match(/['"]([^'"]+)['"]/g);
-        if (stringMatches) {
-          return stringMatches.map(str => str.slice(1, -1)); // 去掉引号
-        }
-      }
-    } catch (error) {
-      console.warn(`[ToolSandbox] 无法解析依赖声明: ${error.message}`);
-    }
-    
-    return [];
-  }
-
-  /**
-   * 检查模块是否在依赖声明中
-   * @param {string} moduleName - 模块名
-   * @param {string[]} declaredDependencies - 已声明的依赖列表
-   * @returns {boolean} - 是否已声明
-   * @private
-   */
-  _isDeclaredInDependencies(moduleName, declaredDependencies) {
-    return declaredDependencies.some(dep => {
-      // 支持 "axios@^1.6.0" 格式，提取模块名部分
-      const depName = dep.split('@')[0];
-      return depName === moduleName;
-    });
-  }
-
   /**
    * 确保沙箱目录存在
    */
@@ -445,10 +351,7 @@ class ToolSandbox {
    * 创建执行沙箱环境
    */
   async createExecutionSandbox() {
-    this.sandboxContext = await this.createSandbox({
+    this.sandboxContext = this.createSmartSandbox();
-      supportDependencies: true,
-      sandboxPath: this.sandboxPath  // 保持使用工具专用沙箱
-    });
     
     // 在智能沙箱中重新加载工具
     const script = new vm.Script(this.toolContent, { filename: `${this.toolId}.js` });
@@ -465,30 +368,19 @@ class ToolSandbox {
   }
 
   /**
-   * 创建统一沙箱环境
+   * 创建基础沙箱
-   * @param {Object} options - 沙箱配置
-   * @param {boolean} options.supportDependencies - 是否支持依赖解析
-   * @param {string} options.sandboxPath - 沙箱工作目录，支持协议路径
-   * @returns {Object} 沙箱环境对象
    */
-  async createSandbox(options = {}) {
+  createBasicSandbox() {
-    const { 
-      supportDependencies = false, 
-      sandboxPath = '@project://.promptx/cwd' 
-    } = options;
-    
-    // 解析协议路径为实际路径
-    const resolvedPath = await this.resolveProtocolPath(sandboxPath);
-    
     return {
-      require: supportDependencies ? 
+      require: require,
-        this.createSmartRequire(resolvedPath) : 
-        this.createAnalysisRequire(),
       module: { exports: {} },
       exports: {},
       console: console,
       Buffer: Buffer,
-      process: this.createProcessMock(resolvedPath),
+      process: {
+        env: process.env,
+        hrtime: process.hrtime
+      },
       setTimeout: setTimeout,
       clearTimeout: clearTimeout,
       setInterval: setInterval,
@@ -508,114 +400,48 @@ class ToolSandbox {
   }
 
   /**
-   * 解析协议路径（支持@project://等协议）
+   * 创建智能沙箱（支持依赖）
-   * @param {string} protocolPath - 协议路径，如@project://.promptx/cwd
-   * @returns {Promise<string>} 解析后的绝对路径
    */
-  async resolveProtocolPath(protocolPath) {
+  createSmartSandbox() {
-    // 处理undefined或null的情况
-    if (!protocolPath) {
-      throw new Error('protocolPath is required but was undefined');
-    }
-    
-    // 如果是协议路径，使用ResourceManager解析
-    if (protocolPath.startsWith('@')) {
-      if (!this.resourceManager) {
-        throw new Error('ResourceManager not set. Cannot resolve protocol path.');
-      }
-      
-      const projectProtocol = this.resourceManager.protocols.get('project');
-      if (!projectProtocol) {
-        throw new Error('ProjectProtocol not found. Cannot resolve @project:// path.');
-      }
-      
-      // 提取协议路径的相对部分
-      const relativePath = protocolPath.replace(/^@project:\/\//, '');
-      const resolvedPath = await projectProtocol.resolvePath(relativePath, new Map());
-      
-      // 确保目录存在
-      const fs = require('fs').promises;
-      try {
-        await fs.access(resolvedPath);
-      } catch (error) {
-        if (error.code === 'ENOENT') {
-          await fs.mkdir(resolvedPath, { recursive: true });
-          console.log(`[ToolSandbox] 创建统一工作目录: ${resolvedPath}`);
-        }
-      }
-      
-      return resolvedPath;
-    }
-    
-    // 普通路径直接返回
-    return protocolPath;
-  }
-
-  /**
-   * 创建完整的process对象mock
-   * @param {string} sandboxPath - 沙箱工作目录
-   * @returns {Object} mock的process对象
-   */
-  createProcessMock(sandboxPath) {
     return {
-      env: process.env,
+      require: (moduleName) => {
-      version: process.version,
+        try {
-      platform: process.platform,
+          // 优先从沙箱目录查找依赖
-      arch: process.arch,
+          return require(require.resolve(moduleName, {
-      hrtime: process.hrtime,
+            paths: [
-      cwd: () => sandboxPath,
+              path.join(this.sandboxPath, 'node_modules'),
-      pid: process.pid,
+              this.sandboxPath,
-      uptime: process.uptime
+              process.cwd() + '/node_modules'
-    };
+            ]
-  }
+          }));
-
+        } catch (error) {
-  /**
+          // 回退到默认require
-   * 创建分析阶段的mock require
-   * 让所有require调用都成功，脚本能完整执行到module.exports
-   * @returns {Function} mock require函数
-   */
-  createAnalysisRequire() {
-    return (moduleName) => {
-      // Node.js内置模块使用真实require
-      const builtinModules = ['path', 'fs', 'url', 'crypto', 'util', 'os', 'events', 'stream'];
-      
-      try {
-        // 检查是否是内置模块
-        if (builtinModules.includes(moduleName) || moduleName.startsWith('node:')) {
           return require(moduleName);
         }
-      } catch (e) {
+      },
-        // 内置模块加载失败，继续mock处理
+      module: { exports: {} },
-      }
+      exports: {},
-      
+      console: console,
-      // 第三方模块返回通用mock对象
+      Buffer: Buffer,
-      console.log(`[ToolSandbox] 分析阶段mock模块: ${moduleName}`);
+      process: {
-      return new Proxy({}, {
+        env: process.env,
-        get: () => () => ({}),  // 所有属性和方法都返回空函数/对象
+        hrtime: process.hrtime
-        apply: () => ({}),      // 如果被当作函数调用
+      },
-        construct: () => ({})   // 如果被当作构造函数
+      setTimeout: setTimeout,
-      });
+      clearTimeout: clearTimeout,
-    };
+      setInterval: setInterval,
-  }
+      clearInterval: clearInterval,
-
+      Object: Object,
-  /**
+      Array: Array,
-   * 创建支持依赖解析的require函数
+      String: String,
-   * @param {string} sandboxPath - 沙箱路径
+      Number: Number,
-   * @returns {Function} 智能require函数
+      Boolean: Boolean,
-   */
+      Date: Date,
-  createSmartRequire(sandboxPath) {
+      JSON: JSON,
-    return (moduleName) => {
+      Math: Math,
-      try {
+      RegExp: RegExp,
-        return require(require.resolve(moduleName, {
+      Error: Error,
-          paths: [
+      URL: URL
-            path.join(sandboxPath, 'node_modules'),
-            sandboxPath,
-            process.cwd() + '/node_modules'
-          ]
-        }));
-      } catch (error) {
-        return require(moduleName);
-      }
     };
   }