Merge pull request #121 from Deepractice/feature/unified-project-cwd

🎯 实现统一项目工作目录：@project://.promptx/cwd

.github/workflows/alpha.yml

@@ -99,7 +99,7 @@ jobs:
             
             💡 你可以使用这个alpha版本测试最新的test分支功能。
             
-            🧪 **Alpha定位**: 精选功能测试版本，适合功能验证和用户测试。`;
+            ⚠️ **迁移提示**: 推荐使用 \`@alpha\` 替代 \`@snapshot\` 进行开发测试。`;
             
             // 为每个相关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,8 +96,7 @@ jobs:
             npx dpml-prompt@${version} action <roleId>
             \`\`\`
             
-            ⚡ **Snapshot定位**: 开发快照版本，包含最新代码变更，供快速验证和开发测试使用。
-            💡 如需稳定测试版本，推荐使用 \`@alpha\` 或 \`@beta\`。`;
+            💡 你可以使用这个snapshot版本测试最新的develop分支功能。`;
             
             // 为每个相关PR添加评论
             for (const pr of prs) {

TEST_ALPHA.md

@@ -1,3 +0,0 @@
-# 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,7 +52,49 @@ 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 = {
@@ -90,19 +132,122 @@ module.exports = {
 
 ```mermaid
 flowchart LR
-    A[创建工具文件] --> B[实现接口方法]
-    B --> C[依赖管理]
-    C --> D[核心逻辑]
-    D --> E[错误处理]
+    A[创建工具文件] --> B[编写说明书]
+    B --> C[实现接口方法]
+    C --> D[依赖管理]
+    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 [
@@ -113,7 +258,7 @@ getDependencies() {
 }
 ```
 
-**Step 2.3: 元信息定义**
+**Step 2.4: 元信息定义**
 ```javascript
 getMetadata() {
   return {
@@ -127,7 +272,7 @@ getMetadata() {
 }
 ```
 
-**Step 2.4: Schema定义**
+**Step 2.5: Schema定义**
 ```javascript
 getSchema() {
   return {

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

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

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

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

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

@@ -7,6 +7,19 @@
     - **快速生成要求**：整个创建过程应在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>
@@ -23,6 +36,8 @@
 
   <guideline>
     ## 执行指导原则
+    - **Chat is All you Need**：始终强调自然对话，把AI当人不是软件
+    - **人际思维优先**：用人际交流的方式介绍角色使用，避免技术指令
     - **简洁高效**：优先速度和效率，避免冗长对话
     - **标准化优先**：使用领域标准能力，而非深度定制
     - **即用原则**：生成的角色应立即可用，无需额外配置
@@ -136,10 +151,16 @@
     ├── {roleId}.role.md
     └── [扩展文件...]
     
-    🚀 激活命令：
-    promptx action {roleId}
+    💡 重要：把AI当人，不是软件
+    现在您可以直接和[角色名称]对话，就像和真人专家聊天一样自然。
+    想聊什么就说什么，比如：
+    - "我需要一个[领域]专家"
+    - "帮我找个懂[技能]的专家"  
+    - "我要和[角色]聊聊[话题]"
     
-    💡 该角色将帮助您：
+    🎯 Chat is All you Need - 自然表达，灵活调整，信任AI理解您的意图
+    
+    💪 该角色将帮助您：
     - [核心能力1]
     - [核心能力2]
     - [核心能力3]

resource/role/nuwa/nuwa.role.md

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

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

@@ -60,4 +60,81 @@
     - 符合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,7 +97,8 @@ ${JSON.stringify(result.result, null, 2)}
    * @param {Object} args - 命令参数
    * @param {string} args.tool_resource - 工具资源引用，格式：@tool://tool-name
    * @param {Object} args.parameters - 传递给工具的参数
-   * @param {Object} args.context - 执行上下文信息（可选）
+   * @param {boolean} args.forceReinstall - 是否强制重新安装工具依赖（默认false）
+   * @param {number} args.timeout - 工具执行超时时间（毫秒，默认30000ms）
    * @returns {Promise<Object>} 执行结果
    */
   async executeToolInternal(args) {
@@ -108,12 +109,14 @@ ${JSON.stringify(result.result, null, 2)}
       // 1. 参数验证
       this.validateArguments(args)
       
-      const { tool_resource, parameters, context = {} } = args
+      const { tool_resource, parameters, forceReinstall = false, timeout = 30000 } = args
       
       logger.debug(`[PromptXTool] 开始执行工具: ${tool_resource}`)
       
-      // 2. 创建ToolSandbox实例
-      sandbox = new ToolSandbox(tool_resource)
+      // 2. 构建沙箱选项并创建ToolSandbox实例
+      const sandboxOptions = { forceReinstall, timeout }
+      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邮件发送等。提供安全沙箱执行、参数验证、错误处理和性能监控。',
+    description: '🔧 [工具执行器] 执行通过@tool协议声明的JavaScript工具 - 支持角色配置中定义的专业工具能力，如@tool://calculator数学计算、@tool://send-email邮件发送等。提供安全沙箱执行、参数验证、错误处理和性能监控。⚠️ **重要提醒**：请务必先查看具体工具的使用说明或通过welcome命令了解可用工具，不要在不了解工具功能和参数的情况下盲目调用。',
     inputSchema: {
       type: 'object',
       properties: {
@@ -126,19 +126,15 @@ const TOOL_DEFINITIONS = [
           type: 'object',
           description: '传递给工具的参数对象'
         },
-        context: {
-          type: 'object',
-          description: '执行上下文信息（可选）',
-          properties: {
-            role_id: {
-              type: 'string',
-              description: '当前激活的角色ID'
-            },
-            session_id: {
-              type: 'string',
-              description: '会话ID'
-            }
-          }
+        forceReinstall: {
+          type: 'boolean',
+          description: '是否强制重新安装工具依赖（默认false）。当工具代码更新但缓存未失效时设为true，用于解决工具开发和调试中的缓存问题',
+          default: false
+        },
+        timeout: {
+          type: 'number',
+          description: '工具执行超时时间（毫秒），默认30000ms',
+          default: 30000
         }
       },
       required: ['tool_resource', 'parameters']
@@ -149,10 +145,10 @@ const TOOL_DEFINITIONS = [
         .describe('工具资源引用，格式：@tool://tool-name'),
       parameters: z.object({}).passthrough()
         .describe('传递给工具的参数对象'),
-      context: z.object({
-        role_id: z.string().optional().describe('当前激活的角色ID'),
-        session_id: z.string().optional().describe('会话ID')
-      }).optional().describe('执行上下文信息')
+      forceReinstall: z.boolean().optional().default(false)
+        .describe('是否强制重新安装工具依赖（默认false）'),
+      timeout: z.number().optional().default(30000)
+        .describe('工具执行超时时间（毫秒），默认30000ms')
     })
   }
 ];

src/lib/tool/ToolSandbox.js

@@ -74,7 +74,7 @@ class ToolSandbox {
       
       this.toolContent = toolResult.content;
       
-      // 3. 设置沙箱路径
+      // 3. 设置沙箱路径（工具专用沙箱）
       this.sandboxPath = await this.resolveSandboxPath();
       
       // 4. 在基础沙箱中分析工具
@@ -207,11 +207,24 @@ class ToolSandbox {
    * 在基础沙箱中分析工具
    */
   async analyzeToolInSandbox() {
-    const basicSandbox = this.createBasicSandbox();
+    const sandbox = await this.createSandbox({
+      supportDependencies: false
+      // 使用默认的@project://.promptx/cwd
+    });
     const script = new vm.Script(this.toolContent, { filename: `${this.toolId}.js` });
-    const context = vm.createContext(basicSandbox);
+    const context = vm.createContext(sandbox);
+    
+    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) {
@@ -241,6 +254,87 @@ 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;
+    });
+  }
+
   /**
    * 确保沙箱目录存在
    */
@@ -351,7 +445,10 @@ class ToolSandbox {
    * 创建执行沙箱环境
    */
   async createExecutionSandbox() {
-    this.sandboxContext = this.createSmartSandbox();
+    this.sandboxContext = await this.createSandbox({
+      supportDependencies: true,
+      sandboxPath: this.sandboxPath  // 保持使用工具专用沙箱
+    });
     
     // 在智能沙箱中重新加载工具
     const script = new vm.Script(this.toolContent, { filename: `${this.toolId}.js` });
@@ -368,19 +465,30 @@ class ToolSandbox {
   }
 
   /**
-   * 创建基础沙箱
+   * 创建统一沙箱环境
+   * @param {Object} options - 沙箱配置
+   * @param {boolean} options.supportDependencies - 是否支持依赖解析
+   * @param {string} options.sandboxPath - 沙箱工作目录，支持协议路径
+   * @returns {Object} 沙箱环境对象
    */
-  createBasicSandbox() {
+  async createSandbox(options = {}) {
+    const { 
+      supportDependencies = false, 
+      sandboxPath = '@project://.promptx/cwd' 
+    } = options;
+    
+    // 解析协议路径为实际路径
+    const resolvedPath = await this.resolveProtocolPath(sandboxPath);
+    
     return {
-      require: require,
+      require: supportDependencies ? 
+        this.createSmartRequire(resolvedPath) : 
+        this.createAnalysisRequire(),
       module: { exports: {} },
       exports: {},
       console: console,
       Buffer: Buffer,
-      process: {
-        env: process.env,
-        hrtime: process.hrtime
-      },
+      process: this.createProcessMock(resolvedPath),
       setTimeout: setTimeout,
       clearTimeout: clearTimeout,
       setInterval: setInterval,
@@ -400,48 +508,114 @@ class ToolSandbox {
   }
 
   /**
-   * 创建智能沙箱（支持依赖）
+   * 解析协议路径（支持@project://等协议）
+   * @param {string} protocolPath - 协议路径，如@project://.promptx/cwd
+   * @returns {Promise<string>} 解析后的绝对路径
    */
-  createSmartSandbox() {
+  async resolveProtocolPath(protocolPath) {
+    // 处理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 {
-      require: (moduleName) => {
-        try {
-          // 优先从沙箱目录查找依赖
-          return require(require.resolve(moduleName, {
-            paths: [
-              path.join(this.sandboxPath, 'node_modules'),
-              this.sandboxPath,
-              process.cwd() + '/node_modules'
-            ]
-          }));
-        } catch (error) {
-          // 回退到默认require
+      env: process.env,
+      version: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      hrtime: process.hrtime,
+      cwd: () => sandboxPath,
+      pid: process.pid,
+      uptime: process.uptime
+    };
+  }
+
+  /**
+   * 创建分析阶段的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);
         }
-      },
-      module: { exports: {} },
-      exports: {},
-      console: console,
-      Buffer: Buffer,
-      process: {
-        env: process.env,
-        hrtime: process.hrtime
-      },
-      setTimeout: setTimeout,
-      clearTimeout: clearTimeout,
-      setInterval: setInterval,
-      clearInterval: clearInterval,
-      Object: Object,
-      Array: Array,
-      String: String,
-      Number: Number,
-      Boolean: Boolean,
-      Date: Date,
-      JSON: JSON,
-      Math: Math,
-      RegExp: RegExp,
-      Error: Error,
-      URL: URL
+      } catch (e) {
+        // 内置模块加载失败，继续mock处理
+      }
+      
+      // 第三方模块返回通用mock对象
+      console.log(`[ToolSandbox] 分析阶段mock模块: ${moduleName}`);
+      return new Proxy({}, {
+        get: () => () => ({}),  // 所有属性和方法都返回空函数/对象
+        apply: () => ({}),      // 如果被当作函数调用
+        construct: () => ({})   // 如果被当作构造函数
+      });
+    };
+  }
+
+  /**
+   * 创建支持依赖解析的require函数
+   * @param {string} sandboxPath - 沙箱路径
+   * @returns {Function} 智能require函数
+   */
+  createSmartRequire(sandboxPath) {
+    return (moduleName) => {
+      try {
+        return require(require.resolve(moduleName, {
+          paths: [
+            path.join(sandboxPath, 'node_modules'),
+            sandboxPath,
+            process.cwd() + '/node_modules'
+          ]
+        }));
+      } catch (error) {
+        return require(moduleName);
+      }
     };
   }