diff --git a/.changeset/witty-ideas-flow.md b/.changeset/witty-ideas-flow.md
new file mode 100644
index 00000000..3bba43a5
--- /dev/null
+++ b/.changeset/witty-ideas-flow.md
@@ -0,0 +1,15 @@
+---
+"@promptx/desktop": patch
+---
+feat: 角色/工具详情面板添加导出按钮，支持 v1 和 v2 角色导出
+
+- 角色和工具详情面板右上角新增导出按钮（非 system 资源可见）
+- 后端 resources:download 支持 version 参数，v2 角色正确定位 ~/.rolex/roles/ 目录
+- v2 角色导出的 ZIP 以 roleId 为顶层目录，确保导入时还原正确 ID
+- 添加 i18n 键：export / exportSuccess / exportFailed（中英文）
+
+fix: macOS 上 AgentX 对话时子进程不再显示 Dock 图标
+
+- macOS 启动时检测 Electron Helper 二进制（LSUIElement=true），用于 spawn 子进程
+- buildOptions 和 AgentXService 的 MCP server 在 macOS 上优先使用 Helper 二进制
+- 所有 spawn 调用添加 windowsHide: true
diff --git a/CENSUS_PARSER_FIX.md b/CENSUS_PARSER_FIX.md
new file mode 100644
index 00000000..a9effaca
--- /dev/null
+++ b/CENSUS_PARSER_FIX.md
@@ -0,0 +1,214 @@
+# Census.list 文本解析器修复
+
+## 问题描述
+
+用户报告在角色页面看不到组织，尽管通过 `directory` 操作可以看到两个组织：
+1. rolex (RoleX) - 系统组织
+2. 火花堆栈人工智能有限公司 - 用户创建的组织
+
+## 根本原因
+
+RoleX 1.1.0 的 `census.list` 返回的是**文本格式**的输出，而不是 JSON 结构化数据。原代码期望的是 JSON 格式，导致解析失败。
+
+### census.list 输出格式示例
+
+```
+rolex (RoleX)
+  nuwa (女娲, nvwa) — individual-manager, organization-manager, position-manager
+
+火花堆栈人工智能有限公司
+  Node全栈工程师 — Node全栈工程师岗位
+  测试工程师 — 测试工程师岗位
+  AI系统架构师 — AI系统架构师岗位
+  UI设计师 — UI设计师岗位
+  产品经理 — 产品经理岗位
+```
+
+## 解决方案
+
+### 1. 添加文本解析器
+
+在 `RolexBridge.js` 中添加 `_parseCensusOutput()` 方法，将文本格式转换为结构化 JSON：
+
+```javascript
+_parseCensusOutput(text) {
+  const result = {
+    roles: [],
+    organizations: []
+  }
+
+  // 解析逻辑：
+  // 1. 识别组织行（无缩进）
+  // 2. 识别角色行（有缩进，描述包含 manager 等关键词）
+  // 3. 识别职位行（有缩进，描述是职位说明）
+
+  return result
+}
+```
+
+### 2. 区分角色和职位
+
+**关键判断逻辑：**
+- **角色**：描述包含多个逗号分隔的职位，或包含 "manager"、"individual"、"organization"、"position" 等关键词
+- **职位**：描述是职位说明文本（如"Node全栈工程师岗位"）
+
+### 3. 输出结构
+
+```json
+{
+  "roles": [
+    {
+      "name": "nuwa",
+      "org": "rolex (RoleX)",
+      "position": "individual-manager"
+    }
+  ],
+  "organizations": [
+    {
+      "name": "rolex (RoleX)",
+      "members": [
+        {
+          "name": "nuwa",
+          "position": "individual-manager"
+        }
+      ],
+      "positions": []
+    },
+    {
+      "name": "火花堆栈人工智能有限公司",
+      "members": [],
+      "positions": [
+        {
+          "name": "Node全栈工程师",
+          "description": "Node全栈工程师岗位"
+        },
+        ...
+      ]
+    }
+  ]
+}
+```
+
+## 文件改动
+
+### 1. `packages/core/src/rolex/RolexBridge.js`
+- 修改 `directory()` 方法，调用 `_parseCensusOutput()` 解析文本
+- 添加 `_parseCensusOutput()` 私有方法
+
+### 2. `apps/desktop/src/main/windows/ResourceListWindow.ts`
+- 移除 `rolex:directory` handler 中的 `JSON.parse()`
+- 移除 `resources:getV2RoleData` handler 中的 `JSON.parse()`
+
+### 3. `apps/desktop/src/view/pages/roles-window/index.tsx`
+- 移除前端的 `JSON.parse()`
+
+## 测试结果
+
+### 解析前（错误）
+```
+角色列表包含职位定义：
+- nuwa
+- Node全栈工程师  ❌ 这是职位，不是角色
+- 测试工程师      ❌ 这是职位，不是角色
+...
+```
+
+### 解析后（正确）
+```
+角色列表：
+- nuwa (rolex (RoleX) - individual-manager) ✅
+
+组织列表：
+- rolex (RoleX)
+  成员: nuwa [individual-manager] ✅
+
+- 火花堆栈人工智能有限公司
+  职位: Node全栈工程师, 测试工程师, ... ✅
+  成员: (空，因为还没有任命角色到职位)
+```
+
+## 为什么看不到"火花堆栈人工智能有限公司"组织？
+
+**原因：该组织没有成员！**
+
+虽然组织定义了 5 个职位，但还没有任命任何角色到这些职位。树状列表只显示**有成员的组织**。
+
+## 如何让组织显示在列表中？
+
+需要任命角色到职位：
+
+```javascript
+// 1. 创建一个新角色（或使用现有角色）
+// 假设已有角色 "alice"
+
+// 2. 任命角色到职位
+{
+  "operation": "require",
+  "role": "nuwa",
+  "orgName": "火花堆栈人工智能有限公司",
+  "position": "Node全栈工程师",
+  "individual": "alice"
+}
+```
+
+任命后，`census.list` 输出会变成：
+
+```
+火花堆栈人工智能有限公司
+  alice — Node全栈工程师
+  Node全栈工程师 — Node全栈工程师岗位
+  ...
+```
+
+此时解析器会识别：
+- `alice` 是角色（因为描述是职位名称，不是职位说明）
+- `Node全栈工程师` 是职位定义
+
+## 下一步
+
+1. **重启 PromptX Desktop**
+2. **打开角色窗口**
+3. **切换到 V2 Rolex 标签**
+4. **应该能看到 "rolex (RoleX)" 组织，展开后看到 nuwa**
+5. **任命角色到"火花堆栈人工智能有限公司"的职位**
+6. **刷新后应该能看到该组织**
+
+## 调试命令
+
+### 查看解析后的目录数据
+```javascript
+window.electronAPI?.invoke("rolex:directory", {}).then(result => {
+  console.log('Directory:', result.data)
+  console.log('Organizations:', result.data.organizations)
+  console.log('Roles:', result.data.roles)
+})
+```
+
+### 查看原始 census.list 输出
+通过 MCP action 工具：
+```json
+{
+  "role": "nuwa",
+  "operation": "directory"
+}
+```
+
+## 注意事项
+
+1. **职位 vs 角色**：census.list 中同时包含职位定义和角色任命，需要正确区分
+2. **空组织**：没有成员的组织不会显示在树状列表中（这是设计行为）
+3. **组织名称**：包含括号的组织名称（如 "rolex (RoleX)"）会被完整保留
+4. **多职位角色**：如果角色担任多个职位，只显示第一个职位
+
+## 已知限制
+
+1. **解析启发式**：使用关键词判断是否为角色，可能在某些边缘情况下误判
+2. **职位描述格式**：假设职位描述不包含逗号和 manager 等关键词
+3. **文本格式依赖**：依赖 census.list 的固定文本格式，如果 RoleX 更新格式可能需要调整解析器
+
+## 改进建议
+
+如果 RoleX 未来提供结构化 API（返回 JSON），应该：
+1. 优先使用结构化 API
+2. 保留文本解析器作为后备方案
+3. 添加版本检测逻辑
diff --git a/ORGANIZATION_API_GUIDE.md b/ORGANIZATION_API_GUIDE.md
new file mode 100644
index 00000000..d1b34f71
--- /dev/null
+++ b/ORGANIZATION_API_GUIDE.md
@@ -0,0 +1,314 @@
+# 角色组织架构 API 使用指南
+
+## 概述
+
+PromptX 集成了 RoleX 1.1.0，支持完整的组织架构管理功能。本文档介绍如何获取和管理角色的组织架构信息。
+
+## 1. 获取组织目录（Directory）
+
+### 方法：`directory()`
+
+获取整个社会目录，包含所有角色和组织的信息。
+
+```javascript
+const { RolexActionDispatcher } = require('@promptx/core').rolex
+const dispatcher = new RolexActionDispatcher()
+
+// 获取完整的组织目录
+const directoryResult = await dispatcher.dispatch('directory', {})
+
+// directory 返回的是 JSON 字符串，需要解析
+const directory = JSON.parse(directoryResult)
+
+console.log(directory)
+// 输出结构：
+// {
+//   roles: [
+//     { name: "角色ID", org: "组织名称", position: "职位名称" },
+//     ...
+//   ],
+//   organizations: [
+//     { name: "组织名称", charter: "组织章程", members: [...] },
+//     ...
+//   ]
+// }
+```
+
+### 从目录中查找特定角色的组织信息
+
+```javascript
+const directory = JSON.parse(directoryResult)
+
+// 查找角色的组织信息
+const roleId = "nuwa"
+const roleEntry = directory.roles?.find(r => r.name === roleId)
+
+if (roleEntry && roleEntry.org) {
+  const orgName = roleEntry.org
+  const position = roleEntry.position
+
+  // 查找组织详情
+  const org = directory.organizations?.find(o => o.name === orgName)
+
+  console.log(`角色 ${roleId} 属于组织 ${orgName}`)
+  console.log(`职位：${position}`)
+  console.log(`组织章程：${org?.charter}`)
+  console.log(`组织成员：`, org?.members)
+} else {
+  console.log(`角色 ${roleId} 未加入任何组织`)
+}
+```
+
+## 2. 组织管理操作
+
+### 2.1 创建组织（Synthesize）
+
+```javascript
+// 创建新组织
+await dispatcher.dispatch('synthesize', {
+  role: 'founder-role-id',  // 创建者角色ID
+  name: 'MyOrganization',    // 组织名称
+  charter: '组织章程内容'     // 组织章程
+})
+```
+
+### 2.2 定义组织章程（Charter）
+
+```javascript
+// 为组织定义或更新章程
+await dispatcher.dispatch('charter', {
+  role: 'admin-role-id',
+  orgName: 'MyOrganization',
+  content: '更新后的组织章程内容'
+})
+```
+
+### 2.3 解散组织（Dissolve）
+
+```javascript
+// 解散组织
+await dispatcher.dispatch('dissolve', {
+  role: 'admin-role-id',
+  orgName: 'MyOrganization'
+})
+```
+
+## 3. 职位管理操作
+
+### 3.1 设立职位（Charge）
+
+```javascript
+// 在组织中设立新职位
+await dispatcher.dispatch('charge', {
+  role: 'admin-role-id',
+  orgName: 'MyOrganization',
+  position: 'Engineer',      // 职位名称
+  procedure: '职位职责描述'   // 职位流程/职责
+})
+```
+
+### 3.2 任命角色到职位（Require）
+
+```javascript
+// 任命角色到特定职位
+await dispatcher.dispatch('require', {
+  role: 'admin-role-id',
+  orgName: 'MyOrganization',
+  position: 'Engineer',
+  individual: 'target-role-id'  // 被任命的角色ID
+})
+```
+
+### 3.3 撤销职位（Abolish）
+
+```javascript
+// 撤销组织中的职位
+await dispatcher.dispatch('abolish', {
+  role: 'admin-role-id',
+  orgName: 'MyOrganization',
+  position: 'Engineer'
+})
+```
+
+## 4. 在前端获取组织信息
+
+### 4.1 通过 IPC 调用
+
+```typescript
+// 在 Electron 渲染进程中
+const result = await window.electronAPI?.invoke('resources:getV2RoleData', {
+  roleId: 'nuwa'
+})
+
+if (result?.success) {
+  const { identity, focus, directory } = result
+
+  // directory 已经是解析后的对象
+  const roleEntry = directory?.roles?.find(r => r.name === 'nuwa')
+  const orgName = roleEntry?.org
+  const position = roleEntry?.position
+  const org = orgName ? directory?.organizations?.find(o => o.name === orgName) : null
+
+  console.log('组织信息：', {
+    orgName,
+    position,
+    charter: org?.charter,
+    members: org?.members
+  })
+}
+```
+
+### 4.2 使用 React Hook
+
+```typescript
+// 在 React 组件中使用
+function MyComponent({ roleId }: { roleId: string }) {
+  const [orgInfo, setOrgInfo] = useState(null)
+
+  useEffect(() => {
+    const loadOrgInfo = async () => {
+      const result = await window.electronAPI?.invoke('resources:getV2RoleData', {
+        roleId
+      })
+
+      if (result?.success && result.directory) {
+        const roleEntry = result.directory.roles?.find(r => r.name === roleId)
+        if (roleEntry?.org) {
+          const org = result.directory.organizations?.find(
+            o => o.name === roleEntry.org
+          )
+          setOrgInfo({
+            orgName: roleEntry.org,
+            position: roleEntry.position,
+            org
+          })
+        }
+      }
+    }
+
+    loadOrgInfo()
+  }, [roleId])
+
+  return (
+    <div>
+      {orgInfo ? (
+        <>
+          <p>组织：{orgInfo.orgName}</p>
+          <p>职位：{orgInfo.position}</p>
+          <p>章程：{orgInfo.org?.charter}</p>
+        </>
+      ) : (
+        <p>未加入任何组织</p>
+      )}
+    </div>
+  )
+}
+```
+
+## 5. 完整示例：组织管理流程
+
+```javascript
+const { RolexActionDispatcher } = require('@promptx/core').rolex
+const dispatcher = new RolexActionDispatcher()
+
+async function organizationExample() {
+  // 1. 创建组织
+  await dispatcher.dispatch('synthesize', {
+    role: 'founder',
+    name: 'TechCorp',
+    charter: '致力于技术创新的组织'
+  })
+
+  // 2. 设立职位
+  await dispatcher.dispatch('charge', {
+    role: 'founder',
+    orgName: 'TechCorp',
+    position: 'CTO',
+    procedure: '负责技术战略和团队管理'
+  })
+
+  await dispatcher.dispatch('charge', {
+    role: 'founder',
+    orgName: 'TechCorp',
+    position: 'Engineer',
+    procedure: '负责产品开发和维护'
+  })
+
+  // 3. 任命角色到职位
+  await dispatcher.dispatch('require', {
+    role: 'founder',
+    orgName: 'TechCorp',
+    position: 'CTO',
+    individual: 'alice'
+  })
+
+  await dispatcher.dispatch('require', {
+    role: 'founder',
+    orgName: 'TechCorp',
+    position: 'Engineer',
+    individual: 'bob'
+  })
+
+  // 4. 查看组织结构
+  const directoryResult = await dispatcher.dispatch('directory', {})
+  const directory = JSON.parse(directoryResult)
+
+  const org = directory.organizations?.find(o => o.name === 'TechCorp')
+  console.log('TechCorp 组织结构：', org)
+
+  // 5. 查看特定角色的组织信息
+  const aliceEntry = directory.roles?.find(r => r.name === 'alice')
+  console.log('Alice 的组织信息：', {
+    org: aliceEntry?.org,
+    position: aliceEntry?.position
+  })
+}
+```
+
+## 6. 数据结构说明
+
+### Directory 结构
+
+```typescript
+interface Directory {
+  roles: Array<{
+    name: string        // 角色ID
+    org?: string        // 所属组织名称（可选）
+    position?: string   // 在组织中的职位（可选）
+  }>
+  organizations: Array<{
+    name: string        // 组织名称
+    charter?: string    // 组织章程
+    members?: Array<{   // 成员列表
+      name: string      // 成员角色ID
+      position: string  // 职位
+    }>
+  }>
+}
+```
+
+## 7. 注意事项
+
+1. **V2 角色专属**：组织架构功能仅适用于 RoleX V2 角色，V1 角色不支持
+2. **权限管理**：某些操作（如解散组织、撤销职位）可能需要特定权限
+3. **数据持久化**：组织信息存储在 RoleX SQLite 数据库中（`~/.rolex/rolex.db`）
+4. **字符串格式**：`directory()` 返回的是 JSON 字符串，需要使用 `JSON.parse()` 解析
+
+## 8. 相关文件
+
+- **后端 API**：`packages/core/src/rolex/RolexBridge.js`
+- **前端组件**：`apps/desktop/src/view/pages/roles-window/components/RoleDetailPanel.tsx`
+- **IPC Handler**：`apps/desktop/src/main/windows/ResourceListWindow.ts` (line 984-1011)
+- **MCP 工具**：`packages/mcp-server/src/tools/action.ts`
+
+## 9. 相关操作列表
+
+| 操作 | 方法 | 说明 |
+|------|------|------|
+| 获取目录 | `directory()` | 获取所有角色和组织信息 |
+| 创建组织 | `synthesize(name, charter)` | 创建新组织 |
+| 定义章程 | `charter(orgName, content)` | 定义或更新组织章程 |
+| 解散组织 | `dissolve(orgName)` | 解散组织 |
+| 设立职位 | `charge(orgName, position, procedure)` | 在组织中设立职位 |
+| 任命角色 | `require(orgName, position, individual)` | 任命角色到职位 |
+| 撤销职位 | `abolish(orgName, position)` | 撤销组织中的职位 |
diff --git a/ROLEX_UPGRADE_GUIDE.md b/ROLEX_UPGRADE_GUIDE.md
new file mode 100644
index 00000000..bb38a4e4
--- /dev/null
+++ b/ROLEX_UPGRADE_GUIDE.md
@@ -0,0 +1,257 @@
+# PromptX RoleX v2 升级到 1.1.0 指南
+
+## 当前状态
+
+- **RoleX 版本**: 1.1.0
+- **问题**: v2 角色列表显示 0 个角色
+- **原因**: RoleX 1.1.0 使用 SQLite 数据库存储，需要重新初始化
+
+## 升级步骤
+
+### 1. 备份现有数据（可选）
+
+如果你有重要的 v2 角色数据，先备份：
+
+```bash
+# 备份旧的 RoleX 数据
+cp -r ~/.rolex ~/.rolex.backup.$(date +%Y%m%d)
+```
+
+### 2. 清理旧数据
+
+RoleX 1.1.0 使用全新的数据库存储，旧的文件系统数据不兼容。建议清理：
+
+```bash
+# 删除旧的 RoleX 数据（会删除所有 v2 角色）
+rm -rf ~/.rolex
+
+# 或者只删除数据库文件，保留 roles 目录作为参考
+rm -f ~/.rolex/rolex.db
+```
+
+**注意**: 这会删除所有现有的 v2 角色数据。如果需要保留，请先备份。
+
+### 3. 重新初始化 RoleX
+
+RoleX 1.1.0 会在首次运行时自动调用 `genesis()` 创建初始世界。
+
+当前代码已经包含了 genesis 调用（RolexBridge.js line 98）：
+
+```javascript
+await this.rolex.genesis()
+```
+
+### 4. 验证升级
+
+重新启动 PromptX Desktop 应用，然后：
+
+1. 打开角色窗口
+2. 切换到 "RoleX" 标签
+3. 应该能看到初始角色（如 nuwa）
+
+### 5. 检查日志
+
+查看日志确认初始化成功：
+
+```bash
+tail -f ~/.promptx/logs/promptx-$(date +%Y-%m-%d).log | grep -i rolex
+```
+
+应该看到类似的日志：
+
+```
+[RolexBridge] Initializing RoleX...
+[RolexBridge] Creating platform...
+[RolexBridge] Creating Rolex instance...
+[RolexBridge] Running genesis...
+[RolexBridge] RoleX initialized successfully
+[RolexBridge] Census result: [...]
+[RolexBridge] Found X V2 roles from database
+```
+
+## 已知问题和解决方案
+
+### 问题 1: Census 返回空数组
+
+**症状**: 日志显示 `[RolexBridge] Census result:` 后面是空的
+
+**原因**:
+1. genesis() 可能没有正确执行
+2. 或者 census.list 返回格式不符合预期
+
+**解决方案**:
+
+检查 census.list 的返回格式。根据 RoleX 源码分析，census.list 应该返回 `CensusEntry[]` 数组：
+
+```typescript
+interface CensusEntry {
+  id?: string;
+  name: string;
+  tag?: string;
+}
+```
+
+当前代码（RolexBridge.js line 349-366）已经处理了这个格式。
+
+### 问题 2: 数据库权限问题
+
+**症状**: 初始化失败，提示数据库错误
+
+**解决方案**:
+
+```bash
+# 确保目录权限正确
+chmod 755 ~/.rolex
+chmod 644 ~/.rolex/rolex.db
+```
+
+### 问题 3: Node.js 版本不兼容
+
+**症状**: SQLite 相关错误
+
+**要求**: Node.js 22+ 或 Bun
+
+**解决方案**: 升级 Node.js 或使用 Bun
+
+## 代码修改总结
+
+已完成的修改（在 `packages/core/src/rolex/RolexBridge.js`）：
+
+1. ✅ **localPlatform 配置** (line 91)
+   ```javascript
+   this.platform = localPlatform({ dataDir: this.rolexRoot })
+   ```
+
+2. ✅ **Rolex.create()** (line 94)
+   ```javascript
+   this.rolex = await Rolex.create(this.platform)
+   ```
+
+3. ✅ **genesis() 调用** (line 98)
+   ```javascript
+   await this.rolex.genesis()
+   ```
+
+4. ✅ **listV2Roles() 数据库查询** (line 339-410)
+   - 使用 `rolex.direct('!census.list')` 查询
+   - 降级方案使用 `platform.repository.runtime`
+
+## 测试步骤
+
+### 1. 重新构建
+
+```bash
+cd /e/Users/DF/Desktop/11111/PromptX
+pnpm build:core
+pnpm build:desktop
+```
+
+### 2. 启动应用
+
+启动 PromptX Desktop 应用
+
+### 3. 检查角色列表
+
+1. 打开角色窗口
+2. 切换到 "RoleX" 标签
+3. 应该看到至少 1 个角色（nuwa）
+
+### 4. 测试 census.list
+
+在应用中激活 nuwa 角色，然后执行：
+
+```javascript
+// 通过 MCP 或直接调用
+await rolex.direct('!census.list')
+```
+
+应该返回类似：
+
+```json
+[
+  {
+    "id": "nuwa",
+    "name": "Nuwa",
+    "tag": null
+  }
+]
+```
+
+## 如果仍然没有角色
+
+### 调试步骤
+
+1. **检查 genesis 是否执行**
+
+查看日志中是否有 "Running genesis" 和 "RoleX initialized successfully"
+
+2. **手动查询数据库**
+
+```bash
+# 如果有 sqlite3 命令
+sqlite3 ~/.rolex/rolex.db "SELECT * FROM nodes WHERE name='individual';"
+```
+
+3. **检查 bootstrap 配置**
+
+确认 localPlatform 配置中包含 bootstrap：
+
+```javascript
+this.platform = localPlatform({
+  dataDir: this.rolexRoot,
+  bootstrap: ['npm:@rolexjs/genesis']  // 添加这一行
+})
+```
+
+4. **强制重新初始化**
+
+```bash
+# 删除数据库
+rm -f ~/.rolex/rolex.db
+
+# 重启应用，会重新运行 genesis
+```
+
+## 迁移现有角色（可选）
+
+如果你有旧的 v2 角色需要迁移到 1.1.0：
+
+### 方案 1: 手动重建
+
+1. 导出旧角色的 Feature 内容
+2. 使用 `!individual.born` 重新创建
+3. 使用 `!individual.train` 添加技能
+
+### 方案 2: 使用 ResourceX
+
+1. 将旧角色打包为 ResourceX 资源
+2. 使用 `!prototype.summon` 导入
+
+## 提交更改
+
+完成升级后，提交代码：
+
+```bash
+cd /e/Users/DF/Desktop/11111/PromptX
+git add packages/core/src/rolex/RolexBridge.js
+git commit -m "feat(core): complete RoleX 1.1.0 migration
+
+- Use Rolex.create() instead of new Rolex()
+- Add genesis() call for world initialization
+- Update listV2Roles() to query from database via census.list
+- Fix localPlatform configuration with dataDir object"
+```
+
+## 参考文档
+
+- RoleX 1.1.0 源码分析: `RoleX-Analysis-Phase*.md`
+- RoleX GitHub: https://github.com/Deepractice/RoleX
+- Genesis 包: `@rolexjs/genesis`
+
+## 需要帮助？
+
+如果升级过程中遇到问题：
+
+1. 检查日志文件: `~/.promptx/logs/promptx-*.log`
+2. 查看 RoleX 数据目录: `~/.rolex/`
+3. 确认 Node.js 版本: `node --version` (需要 22+)
diff --git a/ROLEX_UPGRADE_QUICK.md b/ROLEX_UPGRADE_QUICK.md
new file mode 100644
index 00000000..39721e0d
--- /dev/null
+++ b/ROLEX_UPGRADE_QUICK.md
@@ -0,0 +1,113 @@
+# RoleX v2 升级到 1.1.0 - 快速指南
+
+## 🎯 核心问题
+
+RoleX 1.1.0 使用 SQLite 数据库存储，不再使用文件系统。需要重新初始化。
+
+## ⚡ 快速升级步骤
+
+### 1. 清理旧数据
+
+```bash
+# 删除旧的 RoleX 数据库（会清空所有 v2 角色）
+rm -f ~/.rolex/rolex.db
+
+# 或者完全重置（推荐）
+rm -rf ~/.rolex
+```
+
+**⚠️ 警告**: 这会删除所有现有的 v2 角色。如需保留，请先备份：
+```bash
+cp -r ~/.rolex ~/.rolex.backup
+```
+
+### 2. 重启应用
+
+重新启动 PromptX Desktop 应用。
+
+应用会自动：
+1. 创建新的 SQLite 数据库
+2. 运行 `genesis()` 初始化世界
+3. 创建 Nuwa 种子角色
+
+### 3. 验证
+
+打开角色窗口 → 切换到 "RoleX" 标签 → 应该看到 **nuwa** 角色
+
+## 🔧 已完成的代码修改
+
+所有必要的代码修改已完成：
+
+1. ✅ **添加 bootstrap 配置** - 注册 Genesis 原型
+2. ✅ **使用 Rolex.create()** - 替代 new Rolex()
+3. ✅ **调用 genesis()** - 初始化世界
+4. ✅ **数据库查询** - 使用 census.list 查询角色
+
+## 📋 检查清单
+
+- [ ] 删除旧数据库: `rm -f ~/.rolex/rolex.db`
+- [ ] 重启 PromptX Desktop
+- [ ] 打开角色窗口
+- [ ] 切换到 "RoleX" 标签
+- [ ] 确认看到 nuwa 角色
+
+## 🐛 故障排除
+
+### 问题: 仍然显示 0 个角色
+
+**解决方案 1**: 完全重置
+```bash
+rm -rf ~/.rolex
+# 重启应用
+```
+
+**解决方案 2**: 检查日志
+```bash
+tail -f ~/.promptx/logs/promptx-$(date +%Y-%m-%d).log | grep -i rolex
+```
+
+应该看到：
+```
+[RolexBridge] Running genesis...
+[RolexBridge] RoleX initialized successfully
+[RolexBridge] Found X V2 roles from database
+```
+
+### 问题: Genesis 失败
+
+**可能原因**: Node.js 版本过低
+
+**解决方案**: 确保 Node.js 22+ 或使用 Bun
+```bash
+node --version  # 应该 >= 22
+```
+
+## 📝 提交更改
+
+```bash
+git add packages/core/src/rolex/RolexBridge.js
+git commit -m "feat(core): complete RoleX 1.1.0 migration with bootstrap config"
+```
+
+## 🎓 关键变化
+
+| 项目 | 0.11.0 | 1.1.0 |
+|------|--------|-------|
+| 存储 | 文件系统 (`~/.rolex/roles/`) | SQLite 数据库 (`~/.rolex/rolex.db`) |
+| 初始化 | `bootstrap()` | `genesis()` |
+| 实例化 | `new Rolex(platform)` | `await Rolex.create(platform)` |
+| Platform | `localPlatform(path)` | `localPlatform({ dataDir, bootstrap })` |
+| 角色查询 | 文件系统扫描 | 数据库查询 (`census.list`) |
+
+## ✨ 新功能
+
+- **Genesis 系统**: 自动创建初始世界和 Nuwa 角色
+- **Census 查询**: 统一的实体查询接口
+- **数据库存储**: 更高效的数据管理
+- **原型系统**: 支持角色模板和复用
+
+## 📚 参考
+
+- 详细升级指南: `ROLEX_UPGRADE_GUIDE.md`
+- RoleX 源码分析: `RoleX-Analysis-Phase*.md`
+- RoleX GitHub: https://github.com/Deepractice/RoleX
diff --git a/V2_ROLE_TREE_CHANGES.md b/V2_ROLE_TREE_CHANGES.md
new file mode 100644
index 00000000..cdd90f45
--- /dev/null
+++ b/V2_ROLE_TREE_CHANGES.md
@@ -0,0 +1,213 @@
+# V2 角色树状列表和数据修复
+
+## 改动概述
+
+本次更新主要解决两个问题：
+1. V2 角色列表改为树状结构，按组织分组显示
+2. 修复 V2 角色详细页的数据显示问题（适配 RoleX 1.1.0 数据库架构）
+
+## 文件改动
+
+### 1. 新增文件
+
+#### `apps/desktop/src/view/pages/roles-window/components/RoleTreeListPanel.tsx`
+- 新的树状角色列表组件
+- 支持按组织分组显示 V2 角色
+- 显示组织章程、职位信息
+- 可展开/折叠组织节点
+- 独立角色单独分组显示
+- V1 角色保持平面列表显示
+
+**主要特性：**
+- 组织节点显示：组织名称、章程、成员数量
+- 角色节点显示：角色名称、职位标签、来源标签、描述
+- 树状缩进和连接线视觉效果
+- 支持搜索和筛选
+
+### 2. 修改文件
+
+#### `apps/desktop/src/view/pages/roles-window/index.tsx`
+**改动：**
+- 导入 `RoleTreeListPanel` 替代 `RoleListPanel`
+- 添加 `organizations` 状态管理
+- 修改 `loadRoles` 函数，增加组织目录数据加载：
+  ```typescript
+  // 加载组织目录信息
+  const directoryResult = await window.electronAPI?.invoke("rolex:directory", {})
+  // 更新角色的组织信息（org, position）
+  // 设置组织列表
+  ```
+- 将组织数据传递给 `RoleTreeListPanel`
+
+#### `apps/desktop/src/view/pages/roles-window/components/RoleDetailPanel.tsx`
+**改动：**
+- 修复 `V2GoalsTab` 组件，适配 RoleX 1.1.0 的 `focus()` 输出格式
+- RoleX 1.1.0 的 `focus()` 返回文本格式而非结构化数据
+- 改为直接显示原始文本输出（使用 `<pre>` 标签）
+
+**修改前：**
+```typescript
+const current = data?.focus?.current  // 期望结构化数据
+const otherGoals: any[] = data?.focus?.otherGoals || []
+```
+
+**修改后：**
+```typescript
+const focusText = data?.focus  // 直接使用文本输出
+// 使用 <pre> 标签显示格式化文本
+```
+
+#### `apps/desktop/src/main/windows/ResourceListWindow.ts`
+**改动：**
+- 添加 `rolex:directory` IPC handler
+- 调用 `RolexActionDispatcher.dispatch('directory', {})` 获取组织目录
+- 返回解析后的 JSON 数据
+
+```typescript
+ipcMain.handle('rolex:directory', async (_evt) => {
+  const dispatcher = new RolexActionDispatcher()
+  const directoryResult = await dispatcher.dispatch('directory', {})
+  const directory = typeof directoryResult === 'string'
+    ? JSON.parse(directoryResult)
+    : directoryResult
+  return { success: true, data: directory }
+})
+```
+
+#### `apps/desktop/src/i18n/locales/en.json`
+**改动：**
+- 添加 `roles.filters.independent`: "Independent Roles"
+
+#### `apps/desktop/src/i18n/locales/zh-CN.json`
+**改动：**
+- 添加 `roles.filters.independent`: "独立角色"
+
+## 数据结构
+
+### RoleItem 扩展
+```typescript
+type RoleItem = {
+  id: string
+  name: string
+  description?: string
+  type: "role"
+  source?: string
+  version?: "v1" | "v2"
+  org?: string        // 新增：所属组织
+  position?: string   // 新增：在组织中的职位
+}
+```
+
+### OrganizationNode
+```typescript
+type OrganizationNode = {
+  name: string
+  charter?: string
+  roles: RoleItem[]
+}
+```
+
+### Directory 结构（来自 RoleX）
+```typescript
+interface Directory {
+  roles: Array<{
+    name: string        // 角色ID
+    org?: string        // 所属组织
+    position?: string   // 职位
+  }>
+  organizations: Array<{
+    name: string        // 组织名称
+    charter?: string    // 组织章程
+    members?: Array<{
+      name: string      // 成员角色ID
+      position: string  // 职位
+    }>
+  }>
+}
+```
+
+## UI 效果
+
+### V2 角色列表（树状结构）
+```
+┌─ 组织A (3)
+│  ├─ 角色1 [CTO]
+│  ├─ 角色2 [Engineer]
+│  └─ 角色3 [Designer]
+├─ 组织B (2)
+│  ├─ 角色4 [Manager]
+│  └─ 角色5 [Developer]
+└─ 独立角色 (2)
+   ├─ 角色6
+   └─ 角色7
+```
+
+### V1 角色列表（平面列表）
+```
+- 角色A
+- 角色B
+- 角色C
+```
+
+## API 调用流程
+
+### 加载角色列表
+1. `window.electronAPI?.getGroupedResources()` - 获取基础角色数据
+2. `window.electronAPI?.invoke("rolex:directory", {})` - 获取组织目录
+3. 合并数据：将组织信息（org, position）添加到角色对象
+4. 构建组织节点列表
+
+### 加载角色详情
+1. `window.electronAPI?.invoke("resources:getV2RoleData", { roleId })` - 获取角色详细数据
+2. 返回：`{ identity, focus, directory }`
+3. `focus` 是文本格式的当前目标输出
+4. `directory` 包含组织结构信息
+
+## 兼容性
+
+- ✅ V1 角色：保持原有平面列表显示
+- ✅ V2 角色（无组织）：显示在"独立角色"分组
+- ✅ V2 角色（有组织）：显示在对应组织节点下
+- ✅ 搜索和筛选：在所有模式下正常工作
+- ✅ V2 功能禁用时：自动切换到 V1 模式
+
+## 测试建议
+
+1. **树状列表测试**
+   - 创建多个组织和角色
+   - 验证组织节点展开/折叠
+   - 验证角色的组织和职位标签显示
+   - 测试搜索功能
+
+2. **数据显示测试**
+   - 查看有目标的 V2 角色的 Goals 标签
+   - 查看有组织的 V2 角色的 Organization 标签
+   - 验证 Identity 文本正确显示
+
+3. **边界情况测试**
+   - 无组织的 V2 角色
+   - 无目标的 V2 角色
+   - 空组织
+   - V1/V2 混合场景
+
+## 后续优化建议
+
+1. **Focus 数据解析**
+   - 可以考虑在后端解析 focus 文本输出为结构化数据
+   - 提取目标名称、计划、任务列表等信息
+   - 提供更友好的 UI 展示
+
+2. **组织管理功能**
+   - 添加创建组织的 UI
+   - 添加设立职位的 UI
+   - 添加任命角色的 UI
+
+3. **性能优化**
+   - 大量角色时的虚拟滚动
+   - 组织节点的懒加载
+   - 缓存组织目录数据
+
+4. **视觉优化**
+   - 组织节点的图标和颜色主题
+   - 更丰富的职位标签样式
+   - 组织层级的视觉连接线
diff --git a/V2_ROLE_TREE_TEST_GUIDE.md b/V2_ROLE_TREE_TEST_GUIDE.md
new file mode 100644
index 00000000..cfe7911c
--- /dev/null
+++ b/V2_ROLE_TREE_TEST_GUIDE.md
@@ -0,0 +1,226 @@
+# V2 角色树状列表测试指南
+
+## 测试前准备
+
+1. 确保已启用 V2 功能（设置 → 服务器配置 → 启用 V2 功能）
+2. 确保有一些 V2 角色存在
+3. 重启 PromptX Desktop
+
+## 测试步骤
+
+### 1. 基础显示测试
+
+**测试树状列表显示：**
+1. 打开角色窗口
+2. 切换到 "V2 Rolex" 标签
+3. 验证：
+   - [ ] 如果有组织，应该看到组织节点（带 Building2 图标）
+   - [ ] 组织节点显示组织名称和成员数量
+   - [ ] 组织节点可以展开/折叠（点击查看）
+   - [ ] 展开后显示该组织下的所有角色
+   - [ ] 角色显示职位标签（紫色）
+   - [ ] 无组织的角色显示在"独立角色"分组下
+
+**测试 V1 角色显示：**
+1. 切换到 "V1 DPML" 标签
+2. 验证：
+   - [ ] V1 角色保持平面列表显示（无树状结构）
+   - [ ] 所有 V1 角色正常显示
+
+### 2. 创建测试组织和角色
+
+使用 MCP action 工具或 AgentX 对话创建测试数据：
+
+```javascript
+// 1. 创建组织
+{
+  "operation": "synthesize",
+  "role": "nuwa",
+  "name": "TechCorp",
+  "charter": "致力于技术创新的组织"
+}
+
+// 2. 设立职位
+{
+  "operation": "charge",
+  "role": "nuwa",
+  "orgName": "TechCorp",
+  "position": "CTO",
+  "procedure": "负责技术战略"
+}
+
+{
+  "operation": "charge",
+  "role": "nuwa",
+  "orgName": "TechCorp",
+  "position": "Engineer",
+  "procedure": "负责产品开发"
+}
+
+// 3. 创建新角色（如果需要）
+// 使用 nuwa 角色创建新的 V2 角色
+
+// 4. 任命角色到职位
+{
+  "operation": "require",
+  "role": "nuwa",
+  "orgName": "TechCorp",
+  "position": "CTO",
+  "individual": "alice"  // 替换为实际角色ID
+}
+```
+
+### 3. 刷新并验证
+
+1. 关闭并重新打开角色窗口（或重启应用）
+2. 验证：
+   - [ ] 看到 "TechCorp" 组织节点
+   - [ ] 组织节点显示成员数量
+   - [ ] 展开后看到被任命的角色
+   - [ ] 角色显示对应的职位标签（如 "CTO"）
+
+### 4. 角色详情测试
+
+**测试组织信息显示：**
+1. 选择一个有组织的 V2 角色
+2. 点击 "Organization" 标签
+3. 验证：
+   - [ ] 显示组织名称
+   - [ ] 显示角色的职位
+   - [ ] 显示组织成员列表
+
+**测试目标信息显示：**
+1. 选择一个有目标的 V2 角色
+2. 点击 "Goals" 标签
+3. 验证：
+   - [ ] 显示当前目标的文本输出
+   - [ ] 文本格式正确（使用等宽字体）
+   - [ ] 如果没有目标，显示"暂无活跃目标"
+
+**测试身份信息显示：**
+1. 点击 "Overview" 标签
+2. 验证：
+   - [ ] 显示角色描述
+   - [ ] 显示角色身份文本（identity）
+
+**测试结构信息显示：**
+1. 点击 "Structure" 标签
+2. 验证：
+   - [ ] 显示四个层级：Persona、Knowledge、Voice、Experience
+   - [ ] 可以展开查看各层级的文件
+   - [ ] 可以点击文件查看内容
+
+### 5. 搜索和筛选测试
+
+**测试搜索功能：**
+1. 在搜索框输入角色名称
+2. 验证：
+   - [ ] 只显示匹配的角色
+   - [ ] 组织节点根据是否有匹配角色显示/隐藏
+   - [ ] 清空搜索后恢复所有角色
+
+**测试来源筛选：**
+1. 点击不同的来源筛选按钮（All/System/Plaza/User）
+2. 验证：
+   - [ ] 只显示对应来源的角色
+   - [ ] 组织节点根据筛选结果更新
+
+### 6. 边界情况测试
+
+**测试无组织角色：**
+1. 创建一个新的 V2 角色但不加入任何组织
+2. 验证：
+   - [ ] 角色显示在"独立角色"分组下
+   - [ ] 点击角色查看详情正常
+
+**测试空组织：**
+1. 创建一个组织但不任命任何角色
+2. 验证：
+   - [ ] 组织节点显示成员数量为 0
+   - [ ] 展开后显示为空
+
+**测试混合场景：**
+1. 同时有 V1 和 V2 角色
+2. 验证：
+   - [ ] 切换 V1/V2 标签正常工作
+   - [ ] 数据不会混淆
+
+### 7. 性能测试
+
+**测试大量角色：**
+1. 如果有大量角色（>50个）
+2. 验证：
+   - [ ] 列表滚动流畅
+   - [ ] 展开/折叠响应及时
+   - [ ] 搜索响应快速
+
+## 常见问题排查
+
+### 问题1：看不到组织节点
+**可能原因：**
+- 没有创建组织
+- 角色没有被任命到组织
+- 需要刷新数据
+
+**解决方法：**
+1. 使用 action 工具创建组织和任命角色
+2. 关闭并重新打开角色窗口
+3. 检查后端日志是否有错误
+
+### 问题2：角色详情显示不正确
+**可能原因：**
+- RoleX 数据库数据格式问题
+- 后端 API 返回数据格式不匹配
+
+**解决方法：**
+1. 检查浏览器控制台是否有错误
+2. 查看后端日志
+3. 验证 `resources:getV2RoleData` 返回的数据结构
+
+### 问题3：树状列表不显示
+**可能原因：**
+- 组件导入错误
+- 构建失败
+
+**解决方法：**
+1. 重新构建：`pnpm --filter @promptx/desktop build`
+2. 检查构建日志是否有错误
+3. 重启应用
+
+## 调试技巧
+
+### 查看组织目录数据
+在浏览器控制台执行：
+```javascript
+window.electronAPI?.invoke("rolex:directory", {}).then(console.log)
+```
+
+### 查看角色详细数据
+```javascript
+window.electronAPI?.invoke("resources:getV2RoleData", { roleId: "nuwa" }).then(console.log)
+```
+
+### 查看所有角色数据
+```javascript
+window.electronAPI?.getGroupedResources().then(console.log)
+```
+
+## 预期结果
+
+✅ **成功标准：**
+1. V2 角色按组织分组显示
+2. 组织节点可以展开/折叠
+3. 角色显示职位标签
+4. 角色详情页正确显示组织、目标、身份信息
+5. 搜索和筛选功能正常
+6. V1 角色保持原有显示方式
+7. 性能流畅，无明显卡顿
+
+## 反馈
+
+如果发现问题，请记录：
+1. 问题描述
+2. 复现步骤
+3. 预期行为 vs 实际行为
+4. 浏览器控制台错误信息
+5. 后端日志（如果有）
diff --git a/V2_STRUCTURE_TAB_DATABASE_MIGRATION.md b/V2_STRUCTURE_TAB_DATABASE_MIGRATION.md
new file mode 100644
index 00000000..76b3b4ff
--- /dev/null
+++ b/V2_STRUCTURE_TAB_DATABASE_MIGRATION.md
@@ -0,0 +1,124 @@
+# V2 Structure Tab Database Migration
+
+## 问题
+V2 角色详情页的"结构"标签页仍在从文件系统读取 identity 数据（`~/.rolex/roles/<id>/identity/*.feature`），但 RoleX 1.1.0 已将所有数据迁移到 SQLite 数据库。
+
+## 解决方案
+
+### 1. 后端改动
+
+**文件**: `apps/desktop/src/main/windows/ResourceListWindow.ts`
+
+添加新的 IPC handler `rolex:getIdentityNodes`：
+
+```typescript
+ipcMain.handle('rolex:getIdentityNodes', async (_evt, payload: { roleId: string }) => {
+  try {
+    const { RolexBridge } = require('@promptx/core')
+    const bridge = RolexBridge.getInstance()
+    const identityData = await bridge.identity(payload.roleId)
+    return { success: true, data: identityData }
+  } catch (error: any) {
+    return { success: false, message: error?.message }
+  }
+})
+```
+
+这个 handler 调用 `RolexBridge.identity(roleId)`，它内部会：
+1. 激活角色：`await this.rolex.activate(roleId)`
+2. 获取身份投影：`return role.project()`
+3. 返回包含 identity 节点的结构化数据
+
+### 2. 前端改动
+
+**文件**: `apps/desktop/src/view/pages/roles-window/components/RoleDetailPanel.tsx`
+
+完全重写 `V2StructureTab` 组件：
+
+#### 主要变化：
+
+1. **数据加载**：
+   - 旧：调用 `resources:listV2RoleFiles` 获取文件列表
+   - 新：调用 `rolex:getIdentityNodes` 获取数据库节点
+
+2. **数据结构**：
+   - 旧：`files: string[]` (文件名数组)
+   - 新：`nodes: any[]` (节点对象数组，包含 id, name, information)
+
+3. **分类逻辑**：
+   - 旧：根据文件名模式 (`.knowledge.`, `.voice.`, `.experience.`)
+   - 新：根据节点的 name 或 id 包含的关键词
+
+4. **内容查看**：
+   - 旧：点击文件后调用 `resources:readV2RoleFile` 读取文件内容
+   - 新：直接显示节点的 `information` 字段（Gherkin Feature 内容）
+
+5. **编辑功能**：
+   - 旧：支持编辑和保存（调用 `resources:saveV2RoleFile`）
+   - 新：只读模式（数据库节点不支持 UI 直接编辑）
+
+## 数据流
+
+```
+用户点击"结构"标签
+  ↓
+V2StructureTab 调用 rolex:getIdentityNodes
+  ↓
+IPC handler 调用 RolexBridge.identity(roleId)
+  ↓
+RolexBridge 调用 role.project()
+  ↓
+RoleX 从 SQLite 数据库查询 identity 节点
+  ↓
+返回节点数组 [{ id, name, information, ... }]
+  ↓
+前端按类别显示节点
+  ↓
+用户点击节点查看 Gherkin 内容
+```
+
+## RoleX 1.1.0 数据库架构
+
+根据 RoleX 分析文档：
+
+- **nodes 表**：存储所有节点
+  - `id`: 节点唯一标识
+  - `name`: 节点名称
+  - `information`: Gherkin Feature 格式的内容
+  - `prototype`: 原型引用
+
+- **identity 节点**：角色的身份结构
+  - persona: 人格特征
+  - knowledge: 知识库
+  - voice: 语音风格
+  - experience: 经验记录
+
+## 测试建议
+
+1. 打开一个 V2 角色的详情页
+2. 切换到"结构"标签
+3. 验证显示了 4 个层级（persona, knowledge, voice, experience）
+4. 点击展开每个层级，查看节点列表
+5. 点击节点，查看 Gherkin Feature 内容
+6. 确认内容是从数据库加载的（不是文件系统）
+
+## 注意事项
+
+1. **只读模式**：当前实现将所有节点设为只读。如果需要编辑功能，需要：
+   - 添加新的 IPC handler 调用 RoleX API 更新节点
+   - 在前端恢复编辑和保存逻辑
+
+2. **节点分类**：当前使用简单的关键词匹配。如果 RoleX 提供了更明确的节点类型标识，应该使用那个。
+
+3. **错误处理**：如果角色没有 identity 数据，会显示空列表。可以考虑添加更友好的提示。
+
+## 相关文件
+
+- `packages/core/src/rolex/RolexBridge.js` - identity() 方法
+- `apps/desktop/src/main/windows/ResourceListWindow.ts` - IPC handlers
+- `apps/desktop/src/view/pages/roles-window/components/RoleDetailPanel.tsx` - V2StructureTab
+
+## 提交
+
+Commit: d869209
+Message: "fix(core): migrate V2 role Structure tab from filesystem to database"
diff --git a/apps/desktop/src/i18n/locales/en.json b/apps/desktop/src/i18n/locales/en.json
index cadab941..1df513f0 100644
--- a/apps/desktop/src/i18n/locales/en.json
+++ b/apps/desktop/src/i18n/locales/en.json
@@ -53,7 +53,9 @@
         "activate": "Set as active",
         "activated": "Configuration activated",
         "deleted": "Configuration deleted",
-        "saved": "Configuration saved"
+        "saved": "Configuration saved",
+        "anthropicOnly": "Anthropic format only",
+        "openaiNotSupported": "OpenAI protocol endpoints are not supported"
       },
       "skills": {
         "title": "Skills Configuration",
@@ -419,7 +421,8 @@
       "all": "All",
       "system": "System",
       "plaza": "Plaza",
-      "user": "User"
+      "user": "User",
+      "independent": "Independent Roles"
     },
     "activate": "Activate",
     "empty": "No roles found",
@@ -690,6 +693,7 @@
       },
       "rename": {
         "placeholder": "Enter conversation name",
+        "cancel": "Cancel",
         "saving": "Saving...",
         "save": "Save"
       },
@@ -768,5 +772,40 @@
         "toolPrompt": "What tools are available?"
       }
     }
+  },
+  "notifications": {
+    "button": "Notifications",
+    "title": "Notifications",
+    "unreadCount": "{{count}} unread notification",
+    "unreadCount_other": "{{count}} unread notifications",
+    "allRead": "All notifications read",
+    "markAllRead": "Mark all as read",
+    "markRead": "Mark as read",
+    "empty": "No notifications",
+    "time": {
+      "justNow": "Just now",
+      "minutesAgo": "{{count}} minute ago",
+      "minutesAgo_other": "{{count}} minutes ago",
+      "hoursAgo": "{{count}} hour ago",
+      "hoursAgo_other": "{{count}} hours ago",
+      "daysAgo": "{{count}} day ago",
+      "daysAgo_other": "{{count}} days ago"
+    },
+    "welcome": {
+      "title": "Welcome to PromptX!",
+      "content": "Thank you for using PromptX. Explore roles, tools, and AgentX to enhance your AI experience."
+    },
+    "update": {
+      "title": "New Features Available",
+      "content": "Check out the latest updates: RoleX lifecycle management, improved UI, and more!"
+    },
+    "updateV220": {
+      "title": "v2.2.0 Update Released",
+      "content": "New notification center, AgentX config with preset & OpenAI protocol detection, RoleX core upgraded from v0.11.0 to v1.3.0, fixed conversation rename bug, fixed Windows Git link issue. V2 role import/export/delete features temporarily disabled."
+    },
+    "rolexUpgrade": {
+      "title": "RoleX (V2) Architecture Upgrade",
+      "content": "Existing V2 roles need to be upgraded. Please activate Nuwa and ask her to upgrade and migrate your roles to continue using them."
+    }
   }
 }
diff --git a/apps/desktop/src/i18n/locales/en.json.bak b/apps/desktop/src/i18n/locales/en.json.bak
new file mode 100644
index 00000000..8af143f1
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/en.json.bak
@@ -0,0 +1,776 @@
+{
+  "settings": {
+    "title": "Settings",
+    "subtitle": "Customize your PromptX experience",
+    "tabs": {
+      "system": "System",
+      "agentx": "AgentX",
+      "remote": "Remote Access"
+    },
+    "language": {
+      "title": "Language",
+      "description": "Choose your preferred language",
+      "english": "English",
+      "chinese": "简体中文"
+    },
+    "agentx": {
+      "title": "AgentX Configuration",
+      "description": "Configure AgentX AI assistant API connection",
+      "apiKey": {
+        "label": "API Key",
+        "placeholder": "sk-ant-...",
+        "description": "Your AgentX API Key"
+      },
+      "baseUrl": {
+        "label": "API Base URL",
+        "placeholder": "https://api.anthropic.com",
+        "description": "API server address, defaults to Anthropic official endpoint"
+      },
+      "model": {
+        "label": "Model",
+        "placeholder": "claude-opus-4-5-20251101",
+        "description": "Model name to use"
+      },
+      "testConnection": "Test Connection",
+      "testing": "Testing...",
+      "testSuccess": "Connection successful!",
+      "testFailed": "Connection failed",
+      "save": "Save Configuration",
+      "saving": "Saving...",
+      "saveSuccess": "AgentX configuration saved successfully",
+      "saveFailed": "Failed to save AgentX configuration",
+      "windowsGitWarning": {
+        "text": "AgentX requires Git to be installed on Windows.",
+        "link": "Download Git for Windows"
+      },
+      "profiles": {
+        "empty": "No configurations yet. Add one to get started.",
+        "add": "Add Configuration",
+        "addTitle": "Add Configuration",
+        "editTitle": "Edit Configuration",
+        "name": "Name",
+        "active": "Active",
+        "activate": "Set as active",
+        "activated": "Configuration activated",
+        "deleted": "Configuration deleted",
+        "saved": "Configuration saved",
+        "anthropicOnly": "Anthropic format only",
+        "openaiNotSupported": "OpenAI protocol endpoints are not supported"
+      },
+      "skills": {
+        "title": "Skills Configuration",
+        "description": "Manage enabled Skills that will be used for all AgentX conversations",
+        "empty": "No available Skills",
+        "emptyHint": "Click 'Add Skill' to import your first skill",
+        "refresh": "Refresh",
+        "save": "Save",
+        "saving": "Saving...",
+        "addSkill": "Add Skill",
+        "importing": "Importing...",
+        "loadError": "Failed to load Skills",
+        "saveSuccess": "Skills configuration saved",
+        "saveError": "Failed to save Skills configuration",
+        "importSuccess": "Skill \"{{name}}\" imported successfully",
+        "importError": "Failed to import Skill",
+        "invalidStructure": "Invalid skill package: SKILL.md not found in the zip",
+        "deleteConfirm": "Are you sure you want to delete skill \"{{name}}\"?",
+        "deleteSuccess": "Skill \"{{name}}\" deleted successfully",
+        "deleteError": "Failed to delete Skill",
+        "delete": "Delete"
+      }
+    },
+    "autoStart": {
+      "title": "Auto Start",
+      "description": "Launch PromptX automatically when computer starts",
+      "enable": "Enable auto start"
+    },
+    "webAccess": {
+      "title": "Remote Access",
+      "description": "Enable LAN access to PromptX via browser, supports multiple sessions",
+      "port": {
+        "label": "HTTP Port",
+        "description": "Web service port, default 5201"
+      },
+      "toggle": "Enable Remote Access",
+      "enabled": "Remote access enabled",
+      "disabled": "Remote access disabled",
+      "enableFailed": "Failed to enable",
+      "disableFailed": "Failed to disable",
+      "copyUrl": "URL copied",
+      "qrHint": "Scan to access on phone or other devices"
+    },
+    "server": {
+      "title": "Server Configuration",
+      "description": "Configure server host, port and debug settings",
+      "host": {
+        "label": "Server Host",
+        "placeholder": "127.0.0.1",
+        "description": "Host address for the server to listen on, e.g. 127.0.0.1"
+      },
+      "port": {
+        "label": "Server Port",
+        "placeholder": "5203",
+        "description": "Port for the server to listen on, range 1-65535"
+      },
+      "debug": {
+        "label": "Debug Mode",
+        "description": "Output more log information for troubleshooting"
+      },
+      "enableV2": {
+        "label": "Enable V2 Features (RoleX)",
+        "description": "Enable RoleX role lifecycle management: role creation, goal management, and organization features"
+      },
+      "save": "Save Configuration",
+      "saving": "Saving...",
+      "reset": "Reset to Default"
+    },
+    "mcp": {
+      "title": "MCP Configuration",
+      "description": "Configure Model Context Protocol servers",
+      "add": "Add Server",
+      "edit": "Edit Server",
+      "empty": "No MCP servers configured",
+      "emptyHint": "Click 'Add Server' to add your first MCP server",
+      "dialogDescription": "Configure the MCP server with JSON format",
+      "fields": {
+        "name": "Server Name",
+        "namePlaceholder": "e.g., my-mcp-server",
+        "config": "Configuration (JSON)",
+        "configHint": "Stdio: {command, args, env} | HTTP/SSE: {type, url}",
+        "enabled": "Enable this server"
+      },
+      "save": "Save",
+      "saving": "Saving...",
+      "cancel": "Cancel",
+      "saveSuccess": "MCP configuration saved successfully",
+      "saveFailed": "Failed to save MCP configuration",
+      "loadError": "Failed to load MCP servers",
+      "validation": {
+        "nameRequired": "Server name is required",
+        "commandOrUrlRequired": "Either 'command' (stdio) or 'url' (http/sse) is required",
+        "typeRequired": "The 'type' field is required when using 'url' (http or sse)",
+        "invalidJson": "Invalid JSON format",
+        "invalidConfig": "Invalid configuration",
+        "duplicate": "A server with this name already exists"
+      },
+      "builtin": "Built-in",
+      "cannotDeleteBuiltin": "Cannot delete built-in server",
+      "cannotDisableBuiltin": "Cannot disable built-in server"
+    },
+    "skills": {
+      "title": "Skills Configuration",
+      "description": "Manage and configure AI skills"
+    }
+  },
+
+  "logs": {
+    "title": "Application Logs",
+    "subtitle": "View and manage application logs",
+    "management": "Logs Management",
+    "description": "View, filter, and manage application logs",
+    "search": {
+      "placeholder": "Search logs..."
+    },
+    "filters": {
+      "all": "All",
+      "normal": "Normal",
+      "error": "Error",
+      "clearDate": "Clear"
+    },
+    "list": {
+      "title": "Log Files",
+      "count": "Log Files ({{count}})",
+      "empty": "No logs found"
+    },
+    "viewer": {
+      "selectPrompt": "Select a log file to view its content",
+      "loading": "Loading...",
+      "empty": "Log is empty"
+    },
+    "actions": {
+      "clearAll": "Clear All",
+      "delete": "Delete"
+    },
+    "messages": {
+      "loadFailed": "Failed to load logs",
+      "readFailed": "Failed to read log",
+      "deleteFailed": "Failed to delete log",
+      "deleteSuccess": "Log deleted successfully",
+      "deleteConfirm": "Delete log file: {{name}}?",
+      "clearAllConfirm": "Are you sure you want to delete ALL log files?",
+      "clearSuccess": "Cleared {{count}} log files",
+      "clearFailed": "Failed to clear logs"
+    }
+  },
+  "resources": {
+    "comingSoon": {
+      "title": "Coming Soon",
+      "description": "Agent Shop is under construction, stay tuned",
+      "badge": "Coming Soon"
+    },
+    "banner": {
+      "title": "Share Your Creations",
+      "subtitle": "Discover and share roles & tools with the community",
+      "publishRole": "Publish Role",
+      "publishTool": "Publish Tool"
+    },
+    "search": {
+      "placeholder": "Search resources / roles / tools"
+    },
+    "import": {
+      "title": "Import Resource",
+      "description": "Import a role or tool from a file ",
+      "button": "Import Resource",
+      "methods": {
+        "file": "File Import",
+        "url": "URL Import (Coming Soon)"
+      },
+      "fields": {
+        "resourceType": "Resource Type",
+        "zipFile": "ZIP File",
+        "browse": "Browse",
+        "upload": "Upload",
+        "customId": "Custom ID (Optional)",
+        "customIdPlaceholder": "Leave empty to use original ID",
+        "customIdHint": "The ID will be used as the folder name",
+        "customName": "Custom Name (Optional)",
+        "customNamePlaceholder": "Display name for the resource",
+        "customDescription": "Custom Description (Optional)",
+        "customDescriptionPlaceholder": "Brief description of the resource"
+      },
+      "actions": {
+        "cancel": "Cancel",
+        "import": "Import",
+        "importing": "Importing..."
+      },
+      "messages": {
+        "selectFile": "Please select a file",
+        "importSuccess": "Resource imported successfully",
+        "importFailed": "Failed to import resource",
+        "invalidStructure": "Invalid resource structure",
+        "fileNotFound": "File not found",
+        "resourceExists": "Resource exists",
+        "resourceExistsMessage": "Resource \"{{id}}\" already exists. Overwrite?",
+        "cancelled": "Operation cancelled"
+      },
+      "urlComingSoon": "URL import feature is coming soon..."
+    },
+    "cards": {
+      "roles": {
+        "title": "Roles",
+        "description": "Number of activatable roles"
+      },
+      "tools": {
+        "title": "Tools", 
+        "description": "Number of executable tools"
+      },
+      "sources": {
+        "title": "Sources",
+        "description": "Resource count by source"
+      }
+    },
+    "filters": {
+      "type": "Type:",
+      "source": "Source:",
+      "all": "All",
+      "roles": "Roles",
+      "tools": "Tools",
+      "system": "System",
+      "user": "User"
+    },
+    "actions": {
+      "edit": "Edit",
+      "download": "Download",
+      "delete": "Delete",
+      "use": "Use",
+      "export": "Export",
+      "exportSuccess": "Exported successfully",
+      "exportFailed": "Export failed"
+    },
+    "messages": {
+      "loadFailed": "Failed to load resources",
+      "searchFailed": "Search failed",
+      "downloadSuccess": "Saved to: {{path}}",
+      "downloadFailed": "Download failed",
+      "deleteConfirm": "Confirm delete {{type}} \"{{name}}\"? This action cannot be undone.",
+      "deleteSuccess": "Deleted successfully",
+      "deleteFailed": "Delete failed",
+      "deleteOnlyUser": "Only user resources can be deleted (system/project cannot be deleted)",
+      "noMore": "No more items :-I",
+      "editOnlyUser": "Only user resources can be edited "
+    },
+    "types": {
+      "role": "Role",
+      "tool": "Tool"
+    },
+    "editor": {
+      "title": "Edit {{type}}: {{name}}",
+      "fields": {
+        "name": "Name",
+        "description": "Description",
+        "namePlaceholder": "Enter resource name",
+        "descriptionPlaceholder": "Enter resource description"
+      },
+      "fileList": "File List",
+      "editFile": "Edit: {{file}}",
+      "selectFile": "Please select a file",
+      "fileContent": "File content...",
+      "selectFilePrompt": "Please select a file to edit from the left",
+      "buttons": {
+        "saveResourceInfo": "Save Resource Info",
+        "saveFile": "Save File",
+        "close": "Close",
+        "saving": "Saving...",
+        "copyPrompt": "Copy Prompt",
+        "copySuccess": "Prompt copied to clipboard"
+      },
+      "messages": {
+        "loadFilesFailed": "Failed to load file list",
+        "readFileFailed": "Failed to read file",
+        "editorOpenFailed": "Failed to open editor",
+        "saveFailed": "Save failed",
+        "saveSuccess": "Saved successfully",
+        "resourceInfoSaveSuccess": "Resource info saved successfully",
+        "saveResourceInfoFailed": "Failed to save resource info",
+        "onlyUserEditable": "Only user resources can be edited (system/project are read-only)",
+        "loading": "Loading...",
+        "loadingFileContent": "Loading file content..."
+      },
+      "tabs": {
+        "editor": "Editor",
+        "preview": "Preview"
+      },
+      "preview": {
+        "loading": "Loading preview...",
+        "empty": "No preview content",
+        "failed": "Failed to load preview"
+      },
+      "readOnly": "⚠️ This resource is in read-only mode ({{source}})"
+    }
+  },
+  "tray": {
+    "tooltip": "PromptX Desktop",
+    "status": {
+      "running": "Running",
+      "stopped": "Stopped",
+      "starting": "Starting...",
+      "stopping": "Stopping...",
+      "error": "Error",
+      "unknown": "Unknown"
+    },
+    "menu": {
+      "status": "Status: {{status}}",
+      "startServer": "Start Server",
+      "stopServer": "Stop Server",
+      "toggleServer": "Toggle Server",
+      "copyAddress": "Copy Server Address",
+      "openMainWindow": "Open Main Window",
+      "manageResources": "Manage Resources",
+      "showLogs": "Show Logs",
+      "settings": "Settings...",
+      "checkUpdates": "Check for Updates...",
+      "checkingUpdates": "Checking for Updates...",
+      "downloadUpdate": "Download Update ({{version}})",
+      "downloading": "Downloading... {{percent}}%",
+      "installUpdate": "Install Update ({{version}})",
+      "retryUpdate": "Retry Update Check",
+      "about": "About PromptX",
+      "quit": "Quit PromptX"
+    },
+    "windows": {
+      "logs": "PromptX Logs",
+      "settings": "PromptX Settings"
+    }
+  },
+  "messages": {
+    "autoStartEnabled": "Auto start enabled successfully",
+    "autoStartDisabled": "Auto start disabled successfully",
+    "autoStartError": "Failed to toggle auto start",
+    "configSaved": "Configuration saved successfully",
+    "configSaveError": "Failed to save configuration",
+    "configReset": "Configuration reset to default",
+    "configResetError": "Failed to reset configuration",
+    "loadError": "Failed to load settings, please try again",
+    "languageChanged": "Language changed successfully",
+    "restartRequired": "Restart Required",
+    "restartDescription": "Server configuration has been saved. The application needs to restart for changes to take effect.",
+    "restartNow": "Restart Now",
+    "restartLater": "Later",
+    "restartError": "Failed to restart application"
+  },
+  "sidebar": {
+    "agentx": "AgentX Chat",
+    "resources": "Agent Shop",
+    "roles":"Roles",
+    "tools":"Tools",
+    "logs": "Logs",
+    "settings": "Settings",
+    "update": "Check for Updates"
+  },
+  "roles": {
+    "search": {
+      "placeholder": "Search roles..."
+    },
+    "stats": {
+      "total": "Total Roles",
+      "system": "System Roles",
+      "user": "User Roles"
+    },
+    "filters": {
+      "source": "Source:",
+      "all": "All",
+      "system": "System",
+      "plaza": "Plaza",
+      "user": "User",
+      "independent": "Independent Roles"
+    },
+    "activate": "Activate",
+    "empty": "No roles found",
+    "noDescription": "No description available",
+    "detail": {
+      "description": "Description",
+      "createRole":"Create Role",
+      "close": "Close",
+      "editRole": "Edit Role",
+      "editRoleName": "Name",
+      "uploadAvatar": "Upload Avatar",
+      "structure": "Structure",
+      "memory": "Memory",
+      "architecture": "DPML Layer Architecture (Three-Layer Architecture, On-Demand Loading)",
+      "memoryEmpty": "No memory data available",
+      "selectRole": "Select a role to view details",
+      "overview": "Overview",
+      "structure": "Structure",
+      "prompt": "Role Prompt",
+      "rolePrompt": "Role Prompt",
+      "promptLoading": "Loading prompt...",
+      "promptError": "Failed to load prompt",
+      "promptLoadError": "Failed to load prompt",
+      "roleFile": "Role Definition",
+      "personalityLayer": "Personality Layer",
+      "personalityDesc": "Defines thinking patterns and cognitive traits",
+      "principleLayer": "Principle Layer",
+      "principleDesc": "Defines workflows and execution standards",
+      "knowledgeLayer": "Knowledge Layer",
+      "knowledgeDesc": "Defines domain expertise and professional knowledge",
+      "noFiles": "No files",
+      "loadingFiles": "Loading files...",
+      "loadFilesFailed": "Failed to load file list",
+      "systemRoleReadOnly": "Built-in system roles cannot be viewed",
+      "fileContent": "File Content",
+      "loadingContent": "Loading content...",
+      "loadContentFailed": "Failed to load content",
+      "readOnly": "Read-only",
+      "save": "Save",
+      "saving": "Saving...",
+      "saveSuccess": "Saved successfully",
+      "saveFailed": "Failed to save",
+      "close": "Close",
+      "goals": "Goals",
+      "organization": "Organization",
+      "identity": "Identity",
+      "currentGoal": "Current Goal",
+      "noGoals": "No active goals",
+      "goalPlan": "Execution Plan",
+      "goalTasks": "Tasks",
+      "noTasks": "No tasks",
+      "noOrganization": "Not in any organization",
+      "orgPosition": "Position",
+      "orgMembers": "Members",
+      "taskPending": "Pending",
+      "taskInProgress": "In Progress",
+      "taskCompleted": "Completed",
+      "loadingData": "Loading...",
+      "v2PersonaLayer": "Persona",
+      "v2PersonaDesc": "Core personality and behavioral traits",
+      "v2KnowledgeLayer": "Knowledge",
+      "v2KnowledgeDesc": "Domain knowledge and professional expertise",
+      "v2VoiceLayer": "Voice",
+      "v2VoiceDesc": "Language style and communication patterns",
+      "v2ExperienceLayer": "Experience",
+      "v2ExperienceDesc": "Accumulated experience from practice"
+    },
+    "memory": {
+      "overview": "Overview",
+      "engrams": "Engrams",
+      "network": "Network",
+      "cues": "Cues",
+      "engramCount": "Engrams",
+      "cueCount": "Cues",
+      "connections": "Connections",
+      "lastActive": "Last Active",
+      "topCues": "Top Cues",
+      "noMemoryData": "No memory data available",
+      "loading": "Loading...",
+      "type": "Type",
+      "strength": "Strength",
+      "schema": "Schema",
+      "search": "Search...",
+      "page": "Page",
+      "clickToExplore": "Click to explore",
+      "recallFrequency": "Recall Frequency",
+      "weight": "Weight",
+      "edit": "Edit",
+      "delete": "Delete",
+      "save": "Save",
+      "cancel": "Cancel",
+      "confirmDelete": "Are you sure?",
+      "deleteCue": "Delete Cue",
+      "typeAtomic": "Atomic",
+      "typeLink": "Link",
+      "typePattern": "Pattern",
+      "allTypes": "All"
+    },
+    "messages": {
+      "loadFailed": "Failed to load roles",
+      "activateSuccess": "Role \"{{name}}\" activated successfully",
+      "activateFailed": "Failed to activate role",
+      "activatePrompt": "Activate role {{name}}",
+      "deleteConfirm": "Delete role \"{{name}}\"? This cannot be undone.",
+      "deleteSuccess": "Role \"{{name}}\" deleted successfully",
+      "deleteFailed": "Failed to delete role",
+      "deleteOnlyUser": "Only user-created roles can be deleted"
+    }
+  },
+  "tools": {
+    "search": {
+      "placeholder": "Search tools..."
+    },
+    "stats": {
+      "total": "Total Tools",
+      "system": "System Tools",
+      "user": "User Tools"
+    },
+    "filters": {
+      "source": "Source:",
+      "all": "All",
+      "system": "System",
+      "plaza": "Plaza",
+      "user": "User"
+    },
+    "execute": "Execute",
+    "empty": "No tools found",
+    "noDescription": "No description available",
+    "detail": {
+      "description": "Description",
+      "parameters": "Parameters",
+      "parametersPlaceholder": "{\"key\": \"value\"}",
+      "parametersHint": "Optional. Enter JSON parameters for tool execution.",
+      "result": "Execution Result",
+      "close": "Close",
+      "overview": "Overview",
+      "test": "Test",
+      "configure": "Configure",
+      "logs": "Logs",
+      "install": "Install Tool",
+      "output": "Output",
+      "outputEmpty": "Run a test to see output here...",
+      "runTest": "Run Test",
+      "envVars": "Environment Variables",
+      "noEnvVars": "No environment variables configured",
+      "noLogs": "No execution logs available",
+      "selectTool": "Select a tool to view details",
+      "deleteTool": "Delete Tool",
+      "tags": "Tags",
+      "manual": "Documentation",
+      "info": "Tool Info",
+      "source": "Source",
+      "execSuccess": "Execution succeeded",
+      "execFailed": "Execution failed",
+      "paramsHint": "Enter JSON parameters for tool execution. Leave {} for no parameters.",
+      "executing": "Executing...",
+      "execNoOutput": "Execution completed with no output",
+      "toolFiles": "Tool Files",
+      "noFiles": "No tool files found",
+      "readOnly": "Read-only",
+      "loadingFile": "Loading file...",
+      "paramSchema": "Parameter Schema",
+      "execHistory": "Execution History",
+      "clearLogs": "Clear Logs",
+      "formMode": "Form",
+      "edit": "Edit",
+      "save": "Save",
+      "cancel": "Cancel",
+      "editInfo": "Edit Info",
+      "editName": "Tool Name",
+      "editDescription": "Tool Description",
+      "namePlaceholder": "Enter tool name",
+      "descriptionPlaceholder": "Enter tool description",
+      "createTool": "Create Tool"
+    },
+    "messages": {
+      "loadFailed": "Failed to load tools",
+      "executeSuccess": "Tool \"{{name}}\" executed successfully",
+      "executeFailed": "Failed to execute tool",
+      "invalidParams": "Invalid JSON parameters",
+      "deleteOnlyUser": "Only user-created tools can be deleted",
+      "deleteConfirm": "Are you sure you want to delete tool \"{{name}}\"? This cannot be undone.",
+      "deleteSuccess": "Tool \"{{name}}\" deleted successfully",
+      "deleteFailed": "Failed to delete tool",
+      "saveSuccess": "File saved successfully",
+      "saveFailed": "Failed to save file",
+      "updateSuccess": "Tool info updated successfully",
+      "updateFailed": "Failed to update tool info",
+      "updateOnlyUser": "Only user-created tools can be edited"
+    }
+  },
+  "update": {
+    "title": "Software Update",
+    "description": "Check for and install software updates",
+    "currentVersion": "Current Version",
+    "checkNow": "Check Now",
+    "checking": "Checking...",
+    "upToDate": "You're up to date!",
+    "upToDateMessage": "You're running the latest version",
+    "newVersion": "New Version Available",
+    "download": "Download",
+    "downloading": "Downloading...",
+    "downloadComplete": "Download complete",
+    "readyToInstall": "Update ready to install",
+    "installNow": "Install Now",
+    "releaseNotes": "What's New",
+    "checkFailed": "Failed to check for updates",
+    "downloadFailed": "Failed to download update",
+    "installFailed": "Failed to install update",
+    "errorMessage": "An error occurred while checking for updates"
+  },
+  "datePicker": {
+    "placeholder": "Select date",
+    "selectDate": "Select Date",
+    "clear": "Clear"
+  },
+  "agentxUI": {
+    "chat": {
+      "placeholder": "Type a message...",
+      "toolbar": {
+        "emoji": "Emoji",
+        "file": "File",
+        "save": "Save conversation"
+      },
+      "status": {
+        "thinking": "Thinking",
+        "responding": "Responding",
+        "planning": "Planning",
+        "executing": "Executing",
+        "error": "Error",
+        "idle": "Idle",
+        "queued": "Queued",
+        "processing": "Processing"
+      },
+      "messageCount": "{{count}} message",
+      "messageCount_other": "{{count}} messages",
+      "actions": {
+        "stop": "Stop",
+        "send": "Send (Enter)",
+        "remove": "Remove",
+        "download": "Download",
+        "removeImage": "Remove image",
+        "escToStop": "esc to stop",
+        "copy": "Copy",
+        "regenerate": "Regenerate",
+        "like": "Like",
+        "dislike": "Dislike"
+      },
+      "empty": {
+        "title": "No conversation selected",
+        "description": "Select a conversation or start a new one"
+      },
+      "dropToSend": "Drop to send",
+      "errors": {
+        "maxAttachments": "Maximum {{max}} attachments allowed",
+        "fileTooLarge": "{{name}} exceeds the {{max}} size limit",
+        "fileTypeNotAccepted": "{{name}} is not a supported file type"
+      }
+    },
+    "conversations": {
+      "title": "Conversations",
+      "new": "New conversation",
+      "search": "Search conversations...",
+      "empty": {
+        "title": "No conversations yet",
+        "description": "Start a new conversation to begin",
+        "action": "New conversation"
+      },
+      "rename": {
+        "placeholder": "Enter conversation name",
+        "cancel": "Cancel",
+        "saving": "Saving...",
+        "save": "Save"
+      },
+      "delete": {
+        "confirm": "Are you sure you want to delete \"{{name}}\"?",
+        "cancel": "Cancel",
+        "confirm_button": "Delete",
+        "deleting": "Deleting..."
+      },
+      "actions": {
+        "rename": "Rename",
+        "delete": "Delete"
+      },
+      "status": {
+        "online": "Online",
+        "offline": "Offline"
+      },
+      "untitled": "Untitled"
+    },
+    "messages": {
+      "empty": {
+        "title": "No messages",
+        "description": "Start the conversation by sending a message"
+      }
+    },
+    "tool": {
+      "status": {
+        "planning": "Planning...",
+        "executing": "Executing...",
+        "completed": "Completed",
+        "error": "Error"
+      }
+    },
+    "sidebar": {
+      "expand": "Expand sidebar",
+      "collapse": "Collapse sidebar"
+    },
+    "list": {
+      "empty": {
+        "description": "Get started by creating a new item"
+      }
+    },
+    "time": {
+      "justNow": "Just now",
+      "unknown": "Unknown",
+      "minAgo": "1 min ago",
+      "minsAgo": "{{count}} mins ago",
+      "hourAgo": "1 hour ago",
+      "hoursAgo": "{{count}} hours ago",
+      "dayAgo": "1 day ago",
+      "daysAgo": "{{count}} days ago"
+    },
+    "mobile": {
+      "search": "Search..."
+    },
+    "page": {
+      "notConfigured": {
+        "title": "AgentX Not Configured",
+        "description": "Please configure your AgentX API Key in Settings to use AgentX.",
+        "hint": "Settings → AgentX Configuration → Enter API Key → Save"
+      },
+      "connectionError": "Connection Error",
+      "connecting": "Connecting to AgentX..."
+    },
+    "welcome": {
+      "tagline": "PromptX, Making AI Accessible",
+      "inputPlaceholder": "Ask me anything...",
+      "presets": {
+        "luban": "Activate Luban to build tools",
+        "lubanPrompt": "Activate Luban, I want to build a tool",
+        "nuwa": "Activate Nuwa to create roles",
+        "nuwaPrompt": "Activate Nuwa, I want to create a role",
+        "role": "Explore available roles",
+        "rolePrompt": "What roles are available?",
+        "tool": "Explore available tools",
+        "toolPrompt": "What tools are available?"
+      }
+    }
+  }
+}
diff --git a/apps/desktop/src/i18n/locales/zh-CN.json b/apps/desktop/src/i18n/locales/zh-CN.json
index fee51d7a..7bc628af 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.json
+++ b/apps/desktop/src/i18n/locales/zh-CN.json
@@ -53,7 +53,9 @@
         "activate": "设为当前",
         "activated": "已切换配置",
         "deleted": "配置已删除",
-        "saved": "配置已保存"
+        "saved": "配置已保存",
+        "anthropicOnly": "仅支持 Anthropic 格式",
+        "openaiNotSupported": "暂不支持 OpenAI 协议的端点"
       },
       "skills": {
         "title": "Skills 配置",
@@ -418,7 +420,8 @@
       "all": "全部",
       "system": "系统",
       "plaza": "广场",
-      "user": "用户"
+      "user": "用户",
+      "independent": "独立角色"
     },
     "activate": "激活",
     "empty": "暂无角色",
@@ -687,6 +690,7 @@
       },
       "rename": {
         "placeholder": "输入对话名称",
+        "cancel": "取消",
         "saving": "保存中...",
         "save": "保存"
       },
@@ -765,5 +769,40 @@
         "toolPrompt": "有哪些可用的工具？"
       }
     }
+  },
+  "notifications": {
+    "button": "通知",
+    "title": "通知中心",
+    "unreadCount": "{{count}} 条未读通知",
+    "unreadCount_other": "{{count}} 条未读通知",
+    "allRead": "所有通知已读",
+    "markAllRead": "全部标为已读",
+    "markRead": "标为已读",
+    "empty": "暂无通知",
+    "time": {
+      "justNow": "刚刚",
+      "minutesAgo": "{{count}} 分钟前",
+      "minutesAgo_other": "{{count}} 分钟前",
+      "hoursAgo": "{{count}} 小时前",
+      "hoursAgo_other": "{{count}} 小时前",
+      "daysAgo": "{{count}} 天前",
+      "daysAgo_other": "{{count}} 天前"
+    },
+    "welcome": {
+      "title": "欢迎使用 PromptX！",
+      "content": "感谢使用 PromptX。探索角色、工具和 AgentX，提升您的 AI 体验。"
+    },
+    "update": {
+      "title": "新功能上线",
+      "content": "查看最新更新：RoleX 生命周期管理、界面优化等更多功能！"
+    },
+    "updateV220": {
+      "title": "v2.2.0 版本更新",
+      "content": "新增通知中心、AgentX 配置增加预设与 OpenAI 协议识别功能、V2 RoleX 内核从 v0.11.0 更新到 v1.3.0、修复对话重命名后无效的 bug、修复 Windows 平台点击 Git 链接无响应的 bug。V2 的角色导入导出与删除功能暂时下架。"
+    },
+    "rolexUpgrade": {
+      "title": "RoleX（V2）架构升级",
+      "content": "原有 V2 角色需要升级。请激活女娲，让女娲进行升级与迁移才能继续使用。"
+    }
   }
 }
diff --git a/apps/desktop/src/main/index.ts b/apps/desktop/src/main/index.ts
index 4b97f6a4..0bbd365c 100644
--- a/apps/desktop/src/main/index.ts
+++ b/apps/desktop/src/main/index.ts
@@ -69,6 +69,7 @@ class PromptXDesktopApp {
     this.setupLanguageIPC()
     this.setupLogsIPC()
     this.setupDialogIPC()
+    this.setupShellIPC()
     this.setupAgentXIPC()
     this.setupWebAccessIPC()
 
@@ -566,6 +567,34 @@ class PromptXDesktopApp {
     })
   }
 
+  private setupShellIPC(): void {
+    // 打开外部链接 - 在新的 Electron 窗口中打开
+    ipcMain.handle('shell:openExternal', async (_event, url: string) => {
+      try {
+        const { BrowserWindow } = await import('electron')
+
+        // 创建新的浏览器窗口
+        const browserWindow = new BrowserWindow({
+          width: 1200,
+          height: 800,
+          webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+          },
+          title: 'Browser',
+        })
+
+        // 加载 URL
+        await browserWindow.loadURL(url)
+
+        logger.info('Opened URL in Electron browser window:', url)
+      } catch (error) {
+        logger.error('Failed to open URL in browser window:', String(error))
+        throw error
+      }
+    })
+  }
+
   private setupAgentXIPC(): void {
     // 获取 AgentX 服务器 URL
     ipcMain.handle('agentx:getServerUrl', () => {
diff --git a/apps/desktop/src/main/windows/ResourceListWindow.ts b/apps/desktop/src/main/windows/ResourceListWindow.ts
index 71006644..dccc9dec 100644
--- a/apps/desktop/src/main/windows/ResourceListWindow.ts
+++ b/apps/desktop/src/main/windows/ResourceListWindow.ts
@@ -1000,8 +1000,7 @@ export class ResourceListWindow {
         // 获取组织目录
         let directory = null
         try {
-          const dirResult = await dispatcher.dispatch('directory', { role: payload.roleId })
-          directory = typeof dirResult === 'string' ? JSON.parse(dirResult) : dirResult
+          directory = await dispatcher.dispatch('directory', { role: payload.roleId })
         } catch { /* no organizations */ }
 
         return { success: true, identity, focus, directory }
@@ -1010,6 +1009,24 @@ export class ResourceListWindow {
       }
     })
 
+    // 获取 RoleX 组织目录
+    ipcMain.handle('rolex:directory', async (_evt) => {
+      try {
+        const core = await import('@promptx/core')
+        const coreExports = (core as any).default || core
+        const { RolexActionDispatcher } = (coreExports as any).rolex
+        const dispatcher = new RolexActionDispatcher()
+
+        // directory() 现在返回结构化的 JSON 数据
+        const directory = await dispatcher.dispatch('directory', {})
+
+        return { success: true, data: directory }
+      } catch (error: any) {
+        console.error('Failed to get directory:', error)
+        return { success: false, message: error?.message }
+      }
+    })
+
     // V2 角色文件列表（~/.rolex/roles/<id>/identity/）
     ipcMain.handle('resources:listV2RoleFiles', async (_evt, payload: { roleId: string }) => {
       try {
@@ -1056,6 +1073,49 @@ export class ResourceListWindow {
       }
     })
 
+    // V2 角色身份结构（从数据库读取）
+    ipcMain.handle('rolex:getIdentityNodes', async (_evt, payload: { roleId: string }) => {
+      try {
+        const core = require('@promptx/core')
+        const bridge = core.rolex.getRolexBridge()
+        const identityText = await bridge.identity(payload.roleId)
+        console.log('[rolex:getIdentityNodes] roleId:', payload.roleId)
+        console.log('[rolex:getIdentityNodes] identityText type:', typeof identityText)
+
+        // Parse the text into structured nodes
+        const nodes: any[] = []
+        if (typeof identityText === 'string') {
+          // Split by ## markers to find top-level nodes
+          const sections = identityText.split(/\n## \[/)
+          for (let i = 1; i < sections.length; i++) {
+            const section = sections[i]
+            // Extract node type and id from [type] (id)
+            const match = section.match(/^([^\]]+)\]\s*\(([^)]+)\)/)
+            if (match) {
+              const nodeType = match[1].trim()
+              const nodeId = match[2].trim()
+              // Extract the content (everything after the first line until next ## or end)
+              const contentMatch = section.match(/\n([\s\S]*?)(?=\n## \[|$)/)
+              const content = contentMatch ? contentMatch[1].trim() : ''
+
+              nodes.push({
+                id: nodeId,
+                name: nodeId,
+                type: nodeType,
+                information: content
+              })
+            }
+          }
+        }
+
+        console.log('[rolex:getIdentityNodes] Parsed nodes:', nodes.length)
+        return { success: true, data: nodes }
+      } catch (error: any) {
+        console.error('[rolex:getIdentityNodes] Error:', error)
+        return { success: false, message: error?.message }
+      }
+    })
+
     // 获取角色头像（profile.png/jpg/jpeg/webp）→ base64 data URL
     ipcMain.handle('resources:getRoleAvatar', async (_evt, payload: { id: string; source?: string }) => {
       try {
diff --git a/apps/desktop/src/preload/index.ts b/apps/desktop/src/preload/index.ts
index c05a3a42..8a6d004d 100644
--- a/apps/desktop/src/preload/index.ts
+++ b/apps/desktop/src/preload/index.ts
@@ -174,7 +174,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
   },
   // Shell API
   shell: {
-    openExternal: (url: string) => shell.openExternal(url),
+    openExternal: (url: string) => ipcRenderer.invoke('shell:openExternal', url),
   },
   // System info
   platform: process.platform,
diff --git a/apps/desktop/src/view/components/agentx-ui/components/container/AgentList.tsx b/apps/desktop/src/view/components/agentx-ui/components/container/AgentList.tsx
index d8671a80..cd4e931c 100644
--- a/apps/desktop/src/view/components/agentx-ui/components/container/AgentList.tsx
+++ b/apps/desktop/src/view/components/agentx-ui/components/container/AgentList.tsx
@@ -194,7 +194,7 @@ export function AgentList({
   const items: ListPaneItem[] = React.useMemo(() => {
     return images.map((img) => ({
       id: img.imageId,
-      title: firstMessages[img.imageId] || img.name || t("agentxUI.conversations.untitled"),
+      title: img.name || firstMessages[img.imageId] || t("agentxUI.conversations.untitled"),
       trailing: (
         <span
           className={cn("w-2 h-2 rounded-full", img.online ? "bg-green-500" : "bg-gray-400")}
@@ -377,7 +377,7 @@ export function AgentList({
               onClick={() => handleDialogClose(false)}
               disabled={isRenaming}
             >
-              Cancel
+              {t("agentxUI.conversations.rename.cancel")}
             </Button>
             <Button onClick={handleRename} disabled={isRenaming || !editingName.trim()}>
               {isRenaming ? t("agentxUI.conversations.rename.saving") : t("agentxUI.conversations.rename.save")}
diff --git a/apps/desktop/src/view/components/agentx-ui/components/container/WelcomePage.tsx b/apps/desktop/src/view/components/agentx-ui/components/container/WelcomePage.tsx
index 06b06a16..1d11b196 100644
--- a/apps/desktop/src/view/components/agentx-ui/components/container/WelcomePage.tsx
+++ b/apps/desktop/src/view/components/agentx-ui/components/container/WelcomePage.tsx
@@ -12,7 +12,7 @@ import * as React from "react";
 import { Send, Hammer, Sparkles, Bot, Wrench } from "lucide-react";
 import { useTranslation } from "react-i18next";
 import { cn } from "@/components/agentx-ui/utils";
-import logo from "../../../../../../assets/icons/PromptX-transparent.png";
+import logo from "../../../../../../assets/icons/icon.png";
 
 export interface PresetQuestion {
   id: string;
diff --git a/apps/desktop/src/view/components/notifications/NotificationList.tsx b/apps/desktop/src/view/components/notifications/NotificationList.tsx
new file mode 100644
index 00000000..fc290056
--- /dev/null
+++ b/apps/desktop/src/view/components/notifications/NotificationList.tsx
@@ -0,0 +1,189 @@
+import { useState, useEffect } from "react"
+import { useTranslation } from "react-i18next"
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogDescription,
+} from "@/components/ui/dialog"
+import { Button } from "@/components/ui/button"
+import { ScrollArea } from "@/components/ui/scroll-area"
+import { Badge } from "@/components/ui/badge"
+import { Info, CheckCircle, AlertTriangle, XCircle, X, Check } from "lucide-react"
+import { Notification } from "./types"
+import { notificationService } from "./notificationService"
+import { cn } from "@/components/agentx-ui/utils/utils"
+
+interface NotificationListProps {
+  isOpen: boolean
+  onClose: () => void
+}
+
+const getNotificationIcon = (type: Notification["type"]) => {
+  switch (type) {
+    case "info":
+      return <Info className="h-5 w-5 text-blue-500" />
+    case "success":
+      return <CheckCircle className="h-5 w-5 text-green-500" />
+    case "warning":
+      return <AlertTriangle className="h-5 w-5 text-yellow-500" />
+    case "error":
+      return <XCircle className="h-5 w-5 text-red-500" />
+  }
+}
+
+const getNotificationBadgeVariant = (type: Notification["type"]) => {
+  switch (type) {
+    case "info":
+      return "default"
+    case "success":
+      return "default"
+    case "warning":
+      return "destructive"
+    case "error":
+      return "destructive"
+  }
+}
+
+export function NotificationList({ isOpen, onClose }: NotificationListProps) {
+  const { t } = useTranslation()
+  const [notifications, setNotifications] = useState<Notification[]>([])
+
+  useEffect(() => {
+    if (isOpen) {
+      loadNotifications()
+    }
+  }, [isOpen])
+
+  const loadNotifications = () => {
+    const data = notificationService.getNotifications()
+    setNotifications(data)
+  }
+
+  const handleMarkAsRead = (id: string) => {
+    notificationService.markAsRead(id)
+    loadNotifications()
+  }
+
+  const handleMarkAllAsRead = () => {
+    notificationService.markAllAsRead()
+    loadNotifications()
+  }
+
+  const handleDelete = (id: string) => {
+    notificationService.deleteNotification(id)
+    loadNotifications()
+  }
+
+  const formatTime = (timestamp: number) => {
+    const date = new Date(timestamp)
+    const now = new Date()
+    const diff = now.getTime() - date.getTime()
+    const minutes = Math.floor(diff / 60000)
+    const hours = Math.floor(diff / 3600000)
+    const days = Math.floor(diff / 86400000)
+
+    if (minutes < 1) return t("notifications.time.justNow")
+    if (minutes < 60) return t("notifications.time.minutesAgo", { count: minutes })
+    if (hours < 24) return t("notifications.time.hoursAgo", { count: hours })
+    if (days < 7) return t("notifications.time.daysAgo", { count: days })
+    return date.toLocaleDateString()
+  }
+
+  const unreadCount = notifications.filter(n => !n.read).length
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onClose}>
+      <DialogContent className="max-w-2xl max-h-[80vh]">
+        <DialogHeader>
+          <div className="flex items-center justify-between">
+            <div>
+              <DialogTitle>{t("notifications.title")}</DialogTitle>
+              <DialogDescription>
+                {unreadCount > 0
+                  ? t("notifications.unreadCount", { count: unreadCount })
+                  : t("notifications.allRead")}
+              </DialogDescription>
+            </div>
+            {unreadCount > 0 && (
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={handleMarkAllAsRead}
+                className="text-xs"
+              >
+                <Check className="h-3.5 w-3.5 mr-1" />
+                {t("notifications.markAllRead")}
+              </Button>
+            )}
+          </div>
+        </DialogHeader>
+
+        <ScrollArea className="h-[500px] pr-4">
+          {notifications.length === 0 ? (
+            <div className="flex flex-col items-center justify-center py-12 text-muted-foreground">
+              <Info className="h-12 w-12 mb-4 opacity-50" />
+              <p>{t("notifications.empty")}</p>
+            </div>
+          ) : (
+            <div className="space-y-3">
+              {notifications.map((notification) => (
+                <div
+                  key={notification.id}
+                  className={cn(
+                    "p-4 rounded-lg border transition-colors",
+                    notification.read
+                      ? "bg-background"
+                      : "bg-muted/50 border-primary/20"
+                  )}
+                >
+                  <div className="flex items-start gap-3">
+                    <div className="mt-0.5">
+                      {getNotificationIcon(notification.type)}
+                    </div>
+                    <div className="flex-1 space-y-2">
+                      <div className="flex items-start justify-between gap-2">
+                        <div className="flex-1">
+                          <h4 className="font-medium text-sm">
+                            {t(notification.title)}
+                          </h4>
+                          <p className="text-sm text-muted-foreground mt-1">
+                            {t(notification.content)}
+                          </p>
+                        </div>
+                        <Button
+                          variant="ghost"
+                          size="icon"
+                          className="h-6 w-6 shrink-0"
+                          onClick={() => handleDelete(notification.id)}
+                        >
+                          <X className="h-3.5 w-3.5" />
+                        </Button>
+                      </div>
+                      <div className="flex items-center justify-between">
+                        <span className="text-xs text-muted-foreground">
+                          {formatTime(notification.timestamp)}
+                        </span>
+                        {!notification.read && (
+                          <Button
+                            variant="ghost"
+                            size="sm"
+                            className="h-6 text-xs"
+                            onClick={() => handleMarkAsRead(notification.id)}
+                          >
+                            {t("notifications.markRead")}
+                          </Button>
+                        )}
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </ScrollArea>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/apps/desktop/src/view/components/notifications/examples.ts b/apps/desktop/src/view/components/notifications/examples.ts
new file mode 100644
index 00000000..c1131e6a
--- /dev/null
+++ b/apps/desktop/src/view/components/notifications/examples.ts
@@ -0,0 +1,70 @@
+// 通知系统使用示例
+// Example usage of the notification system
+
+import { notificationService } from "@/components/notifications"
+
+// 示例 1: 添加一条信息通知
+// Example 1: Add an info notification
+export function addInfoNotification() {
+  notificationService.addNotification({
+    title: "notifications.info.title",
+    content: "notifications.info.content",
+    type: "info",
+    read: false,
+  })
+}
+
+// 示例 2: 添加一条成功通知
+// Example 2: Add a success notification
+export function addSuccessNotification() {
+  notificationService.addNotification({
+    title: "notifications.success.title",
+    content: "notifications.success.content",
+    type: "success",
+    read: false,
+  })
+}
+
+// 示例 3: 添加一条警告通知
+// Example 3: Add a warning notification
+export function addWarningNotification() {
+  notificationService.addNotification({
+    title: "notifications.warning.title",
+    content: "notifications.warning.content",
+    type: "warning",
+    read: false,
+  })
+}
+
+// 示例 4: 添加一条错误通知
+// Example 4: Add an error notification
+export function addErrorNotification() {
+  notificationService.addNotification({
+    title: "notifications.error.title",
+    content: "notifications.error.content",
+    type: "error",
+    read: false,
+  })
+}
+
+// 示例 5: 获取未读通知数量
+// Example 5: Get unread notification count
+export function getUnreadCount() {
+  const count = notificationService.getUnreadCount()
+  console.log(`Unread notifications: ${count}`)
+  return count
+}
+
+// 示例 6: 标记所有通知为已读
+// Example 6: Mark all notifications as read
+export function markAllAsRead() {
+  notificationService.markAllAsRead()
+  console.log("All notifications marked as read")
+}
+
+// 示例 7: 重置"已显示"状态（用于测试）
+// Example 7: Reset shown status (for testing)
+export function resetShownStatus() {
+  notificationService.resetShownStatus()
+  console.log("Notification shown status reset - will auto-show on next app launch")
+}
diff --git a/apps/desktop/src/view/components/notifications/index.ts b/apps/desktop/src/view/components/notifications/index.ts
new file mode 100644
index 00000000..245951e5
--- /dev/null
+++ b/apps/desktop/src/view/components/notifications/index.ts
@@ -0,0 +1,3 @@
+export { NotificationList } from "./NotificationList"
+export { notificationService } from "./notificationService"
+export type { Notification, NotificationStore } from "./types"
diff --git a/apps/desktop/src/view/components/notifications/notificationService.ts b/apps/desktop/src/view/components/notifications/notificationService.ts
new file mode 100644
index 00000000..ed35a334
--- /dev/null
+++ b/apps/desktop/src/view/components/notifications/notificationService.ts
@@ -0,0 +1,97 @@
+import { Notification, NotificationStore } from "./types"
+
+const STORAGE_KEY = "promptx_notifications"
+const SHOWN_KEY = "promptx_notifications_shown"
+
+// 默认通知数据
+const defaultNotifications: Notification[] = [
+  {
+    id: "update-v2.2.0",
+    title: "notifications.updateV220.title",
+    content: "notifications.updateV220.content",
+    type: "success",
+    timestamp: Date.now(),
+    read: false,
+  },
+  {
+    id: "rolex-upgrade",
+    title: "notifications.rolexUpgrade.title",
+    content: "notifications.rolexUpgrade.content",
+    type: "warning",
+    timestamp: Date.now(),
+    read: false,
+  },
+]
+
+export const notificationService = {
+  // 获取所有通知
+  getNotifications(): Notification[] {
+    const stored = localStorage.getItem(STORAGE_KEY)
+    if (stored) {
+      return JSON.parse(stored)
+    }
+    // 首次使用，初始化默认通知
+    this.saveNotifications(defaultNotifications)
+    return defaultNotifications
+  },
+
+  // 保存通知
+  saveNotifications(notifications: Notification[]): void {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(notifications))
+  },
+
+  // 标记通知为已读
+  markAsRead(id: string): void {
+    const notifications = this.getNotifications()
+    const updated = notifications.map(n =>
+      n.id === id ? { ...n, read: true } : n
+    )
+    this.saveNotifications(updated)
+  },
+
+  // 标记所有通知为已读
+  markAllAsRead(): void {
+    const notifications = this.getNotifications()
+    const updated = notifications.map(n => ({ ...n, read: true }))
+    this.saveNotifications(updated)
+  },
+
+  // 获取未读数量
+  getUnreadCount(): number {
+    const notifications = this.getNotifications()
+    return notifications.filter(n => !n.read).length
+  },
+
+  // 添加新通知
+  addNotification(notification: Omit<Notification, "id" | "timestamp">): void {
+    const notifications = this.getNotifications()
+    const newNotification: Notification = {
+      ...notification,
+      id: `notification-${Date.now()}`,
+      timestamp: Date.now(),
+    }
+    this.saveNotifications([newNotification, ...notifications])
+  },
+
+  // 删除通知
+  deleteNotification(id: string): void {
+    const notifications = this.getNotifications()
+    const updated = notifications.filter(n => n.id !== id)
+    this.saveNotifications(updated)
+  },
+
+  // 检查是否已显示过通知弹窗
+  hasShownNotifications(): boolean {
+    return localStorage.getItem(SHOWN_KEY) === "true"
+  },
+
+  // 标记已显示通知弹窗
+  markAsShown(): void {
+    localStorage.setItem(SHOWN_KEY, "true")
+  },
+
+  // 重置显示状态（用于测试）
+  resetShownStatus(): void {
+    localStorage.removeItem(SHOWN_KEY)
+  },
+}
diff --git a/apps/desktop/src/view/components/notifications/types.ts b/apps/desktop/src/view/components/notifications/types.ts
new file mode 100644
index 00000000..6d2eda09
--- /dev/null
+++ b/apps/desktop/src/view/components/notifications/types.ts
@@ -0,0 +1,14 @@
+export interface Notification {
+  id: string
+  title: string
+  content: string
+  type: "info" | "success" | "warning" | "error"
+  timestamp: number
+  read: boolean
+  link?: string
+}
+
+export interface NotificationStore {
+  notifications: Notification[]
+  unreadCount: number
+}
diff --git a/apps/desktop/src/view/components/ui/badge.tsx b/apps/desktop/src/view/components/ui/badge.tsx
new file mode 100644
index 00000000..f000e3ef
--- /dev/null
+++ b/apps/desktop/src/view/components/ui/badge.tsx
@@ -0,0 +1,36 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const badgeVariants = cva(
+  "inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+  {
+    variants: {
+      variant: {
+        default:
+          "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+        secondary:
+          "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+        destructive:
+          "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+        outline: "text-foreground",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+export interface BadgeProps
+  extends React.HTMLAttributes<HTMLDivElement>,
+    VariantProps<typeof badgeVariants> {}
+
+function Badge({ className, variant, ...props }: BadgeProps) {
+  return (
+    <div className={cn(badgeVariants({ variant }), className)} {...props} />
+  )
+}
+
+export { Badge, badgeVariants }
diff --git a/apps/desktop/src/view/pages/main-window/index.tsx b/apps/desktop/src/view/pages/main-window/index.tsx
index 005f5c99..34a6f86e 100644
--- a/apps/desktop/src/view/pages/main-window/index.tsx
+++ b/apps/desktop/src/view/pages/main-window/index.tsx
@@ -12,10 +12,12 @@ import {
   SidebarProvider,
   SidebarTrigger,
   SidebarHeader,
+  SidebarFooter,
   useSidebar,
 } from "@/components/ui/sidebar"
-import { Store, FileText, Settings, Pickaxe, MessageSquare, UsersRound, Plus, Upload } from "lucide-react"
+import { Store, FileText, Settings, Pickaxe, MessageSquare, UsersRound, Plus, Upload, Bell } from "lucide-react"
 import { Button } from "@/components/ui/button"
+import { Badge } from "@/components/ui/badge"
 import ResourcesPage from "../resources-window"
 import LogsPage from "../logs-window"
 import SettingsPage from "../settings-window"
@@ -23,6 +25,8 @@ import ToolsPage from "../tools-window"
 import RolesPage from "../roles-window"
 import AgentXPage from "../agentx-window"
 import { ResourceImporter } from "../resources-window/components/ResourceImporter"
+import { NotificationList } from "@/components/notifications/NotificationList"
+import { notificationService } from "@/components/notifications/notificationService"
 import { goToSendMessage } from "../../../utils/goToSendMessage"
 import logo from "../../../../assets/icons/icon-64x64.png"
 type PageType = "resources" | "logs" | "settings" | "update" |"agentx"|"roles"|"tools"
@@ -32,6 +36,8 @@ function MainContent() {
   const [currentPage, setCurrentPage] = useState<PageType>("agentx")
   const [pageKey, setPageKey] = useState(0)
   const { open } = useSidebar()
+  const [notificationOpen, setNotificationOpen] = useState(false)
+  const [unreadCount, setUnreadCount] = useState(0)
 
   const navigateTo = (page: PageType) => {
     setCurrentPage(page)
@@ -48,6 +54,31 @@ function MainContent() {
     }).catch(() => {})
   }, [])
 
+  // 自动打开通知弹窗
+  useEffect(() => {
+    const hasShown = notificationService.hasShownNotifications()
+    if (!hasShown) {
+      // 延迟500ms打开，让应用先完全加载
+      const timer = setTimeout(() => {
+        setNotificationOpen(true)
+        notificationService.markAsShown()
+      }, 500)
+      return () => clearTimeout(timer)
+    }
+  }, [])
+
+  // 更新未读数量
+  useEffect(() => {
+    const updateUnreadCount = () => {
+      setUnreadCount(notificationService.getUnreadCount())
+    }
+    updateUnreadCount()
+
+    // 监听通知变化
+    const interval = setInterval(updateUnreadCount, 1000)
+    return () => clearInterval(interval)
+  }, [notificationOpen])
+
   useEffect(() => {
     const handler = (e: Event) => {
       const page = (e as CustomEvent).detail?.page
@@ -173,6 +204,24 @@ function MainContent() {
             </SidebarGroupContent>
           </SidebarGroup>
         </SidebarContent>
+        <SidebarFooter className="border-t p-2">
+          <Button
+            variant="ghost"
+            className="w-full justify-start relative"
+            onClick={() => setNotificationOpen(true)}
+          >
+            <Bell className="h-4 w-4 mr-2" />
+            <span>{t("notifications.button")}</span>
+            {unreadCount > 0 && (
+              <Badge
+                variant="destructive"
+                className="ml-auto h-5 min-w-5 px-1 text-xs"
+              >
+                {unreadCount > 99 ? "99+" : unreadCount}
+              </Badge>
+            )}
+          </Button>
+        </SidebarFooter>
       </Sidebar>
 
       <main className={`flex-1 overflow-hidden ${open ? 'ml-[12vw] ' : ''}`}>
@@ -197,6 +246,13 @@ function MainContent() {
         enableV2={enableV2}
         onImportSuccess={() => navigateTo(currentPage)}
       />
+      <NotificationList
+        isOpen={notificationOpen}
+        onClose={() => {
+          setNotificationOpen(false)
+          setUnreadCount(notificationService.getUnreadCount())
+        }}
+      />
     </div>
   )
 }
diff --git a/apps/desktop/src/view/pages/roles-window/components/RoleDetailPanel.tsx b/apps/desktop/src/view/pages/roles-window/components/RoleDetailPanel.tsx
index 5d714c89..2c307719 100644
--- a/apps/desktop/src/view/pages/roles-window/components/RoleDetailPanel.tsx
+++ b/apps/desktop/src/view/pages/roles-window/components/RoleDetailPanel.tsx
@@ -495,10 +495,10 @@ function V2GoalsTab({ data, loading }: { data: any; loading: boolean }) {
     )
   }
 
-  const current = data?.focus?.current
-  const otherGoals: any[] = data?.focus?.otherGoals || []
+  // RoleX 1.1.0 focus() 返回的是文本输出，需要解析
+  const focusText = data?.focus
 
-  if (!current && otherGoals.length === 0) {
+  if (!focusText || typeof focusText !== 'string') {
     return (
       <div className="flex flex-col items-center justify-center py-20 gap-3">
         <Target className="h-10 w-10 text-muted-foreground/40" />
@@ -507,62 +507,20 @@ function V2GoalsTab({ data, loading }: { data: any; loading: boolean }) {
     )
   }
 
-  const taskStatusColor = (s: string) =>
-    s === "completed" ? "bg-green-500" : s === "in_progress" ? "bg-blue-500" : "bg-muted-foreground/30"
-  const taskStatusLabel = (s: string) =>
-    s === "completed" ? t("roles.detail.taskCompleted")
-      : s === "in_progress" ? t("roles.detail.taskInProgress")
-      : t("roles.detail.taskPending")
-
+  // 显示原始的 focus 输出
   return (
     <div className="space-y-4 h-full overflow-y-auto">
-      {current && (
-        <div className="rounded-lg border bg-card p-4">
-          <div className="flex items-center gap-2 mb-2">
-            <div className="h-2 w-2 rounded-full bg-primary shrink-0" />
-            <span className="text-xs font-medium text-muted-foreground">{t("roles.detail.currentGoal")}</span>
-          </div>
-          <p className="text-sm font-semibold mb-1">{current.name}</p>
-          {current.description && (
-            <p className="text-xs text-muted-foreground mb-3 leading-relaxed">{current.description}</p>
-          )}
-          {current.plan && (
-            <div className="mt-3 pt-3 border-t">
-              <p className="text-xs font-medium text-muted-foreground mb-1">{t("roles.detail.goalPlan")}</p>
-              <p className="text-sm">{current.plan.name}</p>
-            </div>
-          )}
-          {current.tasks && current.tasks.length > 0 && (
-            <div className="mt-3 pt-3 border-t">
-              <p className="text-xs font-medium text-muted-foreground mb-2">{t("roles.detail.goalTasks")}</p>
-              <div className="space-y-1.5">
-                {current.tasks.map((task: any, i: number) => (
-                  <div key={i} className="flex items-center gap-2">
-                    <div className={`h-2 w-2 rounded-full shrink-0 ${taskStatusColor(task.status)}`} />
-                    <span className="text-sm flex-1 truncate">{task.name}</span>
-                    <span className="text-xs text-muted-foreground shrink-0">{taskStatusLabel(task.status)}</span>
-                  </div>
-                ))}
-              </div>
-            </div>
-          )}
+      <div className="rounded-lg border bg-card p-4">
+        <div className="flex items-center gap-2 mb-3">
+          <Target className="h-4 w-4 text-primary" />
+          <h3 className="text-sm font-semibold">{t("roles.detail.currentGoal")}</h3>
         </div>
-      )}
-      {otherGoals.length > 0 && (
-        <div className="rounded-lg border bg-muted/30 p-4">
-          <p className="text-xs font-medium text-muted-foreground mb-2">
-            {t("roles.detail.goals")} ({otherGoals.length})
-          </p>
-          <div className="space-y-1">
-            {otherGoals.map((goal: any, i: number) => (
-              <div key={i} className="flex items-center gap-2">
-                <div className="h-1.5 w-1.5 rounded-full bg-muted-foreground/50 shrink-0" />
-                <span className="text-sm text-muted-foreground">{goal.name}</span>
-              </div>
-            ))}
-          </div>
+        <div className="rounded-lg bg-muted/50 p-3">
+          <pre className="text-sm whitespace-pre-wrap font-mono leading-relaxed text-muted-foreground">
+            {focusText}
+          </pre>
         </div>
-      )}
+      </div>
     </div>
   )
 }
@@ -637,17 +595,13 @@ function V2OrganizationTab({ role, data, loading }: { role: RoleItem; data: any;
 // V2 Structure Tab: identity .feature files with viewer/editor
 function V2StructureTab({ role }: { role: RoleItem }) {
   const { t } = useTranslation()
-  const [files, setFiles] = useState<string[]>([])
+  const [nodes, setNodes] = useState<any[]>([])
   const [loading, setLoading] = useState(true)
   const [error, setError] = useState("")
 
   const [viewerOpen, setViewerOpen] = useState(false)
-  const [viewerFile, setViewerFile] = useState("")
+  const [viewerNode, setViewerNode] = useState<any>(null)
   const [viewerContent, setViewerContent] = useState("")
-  const [viewerLoading, setViewerLoading] = useState(false)
-  const [editedContent, setEditedContent] = useState("")
-  const [saving, setSaving] = useState(false)
-  const [isEditing, setIsEditing] = useState(false)
 
   const [expanded, setExpanded] = useState<Record<string, boolean>>({
     persona: true, knowledge: true, voice: true, experience: true,
@@ -660,53 +614,66 @@ function V2StructureTab({ role }: { role: RoleItem }) {
       setLoading(true)
       setError("")
       try {
-        const res = await window.electronAPI?.invoke("resources:listV2RoleFiles", { roleId: role.id })
-        if (res?.success) setFiles(res.files || [])
-        else setError(res?.message || t("roles.detail.loadFilesFailed"))
-      } catch { setError(t("roles.detail.loadFilesFailed")) }
-      finally { setLoading(false) }
+        const res = await window.electronAPI?.invoke("rolex:getIdentityNodes", { roleId: role.id })
+        console.log('[V2StructureTab] Response:', res)
+        console.log('[V2StructureTab] res.data type:', typeof res?.data)
+        console.log('[V2StructureTab] res.data:', res?.data)
+        if (res?.success && res.data) {
+          // res.data is the identity projection from role.project()
+          // It should contain nodes with their information (Gherkin content)
+          const identityNodes = Array.isArray(res.data) ? res.data : (res.data.nodes || [])
+          console.log('[V2StructureTab] identityNodes:', identityNodes)
+          console.log('[V2StructureTab] identityNodes length:', identityNodes.length)
+          setNodes(identityNodes)
+        } else {
+          setError(res?.message || t("roles.detail.loadFilesFailed"))
+        }
+      } catch (err: any) {
+        console.error('[V2StructureTab] Error:', err)
+        setError(err?.message || t("roles.detail.loadFilesFailed"))
+      } finally {
+        setLoading(false)
+      }
     }
     load()
   }, [role, t])
 
   const categorize = useCallback(() => {
-    const persona: string[] = [], knowledge: string[] = [], voice: string[] = [], experience: string[] = []
-    for (const f of files) {
-      if (f.includes(".knowledge.")) knowledge.push(f)
-      else if (f.includes(".voice.")) voice.push(f)
-      else if (f.includes(".experience.")) experience.push(f)
-      else persona.push(f)
+    const persona: any[] = [], knowledge: any[] = [], voice: any[] = [], experience: any[] = []
+    for (const node of nodes) {
+      const nodeType = node.type || ""
+      const id = node.id || ""
+      const name = node.name || id
+
+      // Categorize by node type
+      if (nodeType === "identity" || nodeType === "individual") {
+        persona.push(node)
+      } else if (nodeType === "procedure" || nodeType === "principle" || name.includes("knowledge") || id.includes("knowledge")) {
+        knowledge.push(node)
+      } else if (name.includes("voice") || id.includes("voice")) {
+        voice.push(node)
+      } else if (name.includes("experience") || id.includes("experience") || nodeType === "experience") {
+        experience.push(node)
+      } else if (nodeType === "position" || nodeType === "organization" || nodeType === "duty" || nodeType === "requirement" || nodeType === "charter") {
+        // These are structural/organizational nodes, put in persona
+        persona.push(node)
+      } else {
+        // Default to persona
+        persona.push(node)
+      }
     }
     return { persona, knowledge, voice, experience }
-  }, [files])
+  }, [nodes])
 
   const { persona, knowledge, voice, experience } = categorize()
 
-  const openFile = async (fileName: string) => {
-    setViewerFile(fileName)
+  const openNode = (node: any) => {
+    setViewerNode(node)
+    setViewerContent(node.information || "")
     setViewerOpen(true)
-    setViewerLoading(true)
-    setIsEditing(false)
-    try {
-      const res = await window.electronAPI?.invoke("resources:readV2RoleFile", { roleId: role.id, fileName })
-      if (res?.success) { setViewerContent(res.content || ""); setEditedContent(res.content || "") }
-      else setViewerContent(t("roles.detail.loadContentFailed"))
-    } catch { setViewerContent(t("roles.detail.loadContentFailed")) }
-    finally { setViewerLoading(false) }
-  }
-
-  const handleSave = async () => {
-    setSaving(true)
-    try {
-      const res = await window.electronAPI?.invoke("resources:saveV2RoleFile", {
-        roleId: role.id, fileName: viewerFile, content: editedContent,
-      })
-      if (res?.success) { setViewerContent(editedContent); setIsEditing(false) }
-    } catch { /* ignore */ }
-    finally { setSaving(false) }
   }
 
-  const renderLayer = (key: string, label: string, desc: string, layerFiles: string[], color: string) => (
+  const renderLayer = (key: string, label: string, desc: string, layerNodes: any[], color: string) => (
     <div key={key} className="rounded-lg border bg-card overflow-hidden">
       <button
         className="w-full flex items-center gap-3 px-4 py-3 text-left hover:bg-muted/50 transition-colors"
@@ -717,19 +684,22 @@ function V2StructureTab({ role }: { role: RoleItem }) {
         <div className="flex-1 min-w-0">
           <div className="flex items-center gap-2">
             <span className="text-sm font-medium">{label}</span>
-            <span className="text-xs text-muted-foreground">({layerFiles.length})</span>
+            <span className="text-xs text-muted-foreground">({layerNodes.length})</span>
           </div>
           <p className="text-xs text-muted-foreground truncate">{desc}</p>
         </div>
       </button>
       {expanded[key] && (
         <div className="px-3 pb-2 pl-10 space-y-0.5">
-          {layerFiles.length === 0
+          {layerNodes.length === 0
             ? <span className="text-xs text-muted-foreground">{t("roles.detail.noFiles")}</span>
-            : layerFiles.map(f => (
-              <button key={f} className="flex items-center gap-2 w-full rounded-md px-3 py-1.5 text-left text-sm hover:bg-muted/80 transition-colors group" onClick={() => openFile(f)}>
+            : layerNodes.map(node => (
+              <button key={node.id} className="flex items-center gap-2 w-full rounded-md px-3 py-1.5 text-left text-sm hover:bg-muted/80 transition-colors group" onClick={() => openNode(node)}>
                 <FileText className="h-3.5 w-3.5 text-muted-foreground shrink-0" />
-                <span className="truncate text-muted-foreground group-hover:text-foreground">{f}</span>
+                <div className="flex items-center gap-2 flex-1 min-w-0">
+                  <span className="truncate text-muted-foreground group-hover:text-foreground">{node.name || node.id}</span>
+                  {node.type && <span className="text-xs text-muted-foreground/60 shrink-0">[{node.type}]</span>}
+                </div>
               </button>
             ))
           }
@@ -766,40 +736,20 @@ function V2StructureTab({ role }: { role: RoleItem }) {
         <DialogContent className="max-w-4xl w-[85vw] h-[75vh] flex flex-col">
           <DialogHeader className="shrink-0">
             <DialogTitle className="flex items-center gap-2 text-base">
-              <FileText className="h-4 w-4" />{viewerFile}
+              <FileText className="h-4 w-4" />{viewerNode?.name || viewerNode?.id}
             </DialogTitle>
             <DialogDescription className="flex items-center gap-2">
-              <span className="font-mono text-xs">{role.id}/identity/{viewerFile}</span>
-              {isReadOnly && <span className="rounded bg-muted px-1.5 py-0.5 text-xs text-muted-foreground">{t("roles.detail.readOnly")}</span>}
+              <span className="font-mono text-xs">{role.id} / {viewerNode?.id}</span>
+              <span className="rounded bg-muted px-1.5 py-0.5 text-xs text-muted-foreground">{t("roles.detail.readOnly")}</span>
             </DialogDescription>
           </DialogHeader>
           <div className="flex-1 min-h-0 rounded-lg border bg-muted/30 overflow-hidden">
-            {viewerLoading ? (
-              <div className="flex items-center justify-center h-full">
-                <Loader2 className="h-5 w-5 animate-spin text-muted-foreground" />
-              </div>
-            ) : isEditing && !isReadOnly ? (
-              <textarea className="w-full h-full resize-none bg-transparent p-4 text-sm font-mono leading-relaxed focus:outline-none" value={editedContent} onChange={e => setEditedContent(e.target.value)} />
-            ) : (
-              <pre className="w-full h-full overflow-auto p-4 text-sm font-mono leading-relaxed whitespace-pre-wrap text-muted-foreground">{viewerContent}</pre>
-            )}
+            <pre className="w-full h-full overflow-auto p-4 text-sm font-mono leading-relaxed whitespace-pre-wrap text-muted-foreground">{viewerContent}</pre>
           </div>
           <DialogFooter className="shrink-0">
-            {!isReadOnly && (
-              isEditing ? (
-                <>
-                  <Button variant="outline" size="sm" onClick={() => { setEditedContent(viewerContent); setIsEditing(false) }}>{t("roles.memory.cancel")}</Button>
-                  <Button size="sm" onClick={handleSave} disabled={saving}>
-                    <Save className="h-3.5 w-3.5 mr-1.5" />
-                    {saving ? t("roles.detail.saving") : t("roles.detail.save")}
-                  </Button>
-                </>
-              ) : (
-                <Button variant="outline" size="sm" onClick={() => setIsEditing(true)}>
-                  <Pencil className="h-3.5 w-3.5 mr-1.5" />{t("roles.detail.editRole")}
-                </Button>
-              )
-            )}
+            <Button variant="outline" size="sm" onClick={() => setViewerOpen(false)}>
+              {t("roles.memory.cancel")}
+            </Button>
           </DialogFooter>
         </DialogContent>
       </Dialog>
@@ -983,7 +933,7 @@ export default function RoleDetailPanel({ selectedRole, onActivate, onDelete, on
             </div>
           </div>
           <div className="flex items-center gap-2">
-            {(selectedRole.source ?? "user") !== "system" && (
+            {(selectedRole.source ?? "user") !== "system" && !isV2 && (
               <Button variant="outline" size="sm" onClick={async () => {
                 try {
                   const result = await window.electronAPI?.invoke("resources:download", { id: selectedRole.id, type: "role", source: selectedRole.source ?? "user", version: selectedRole.version ?? "v1" })
@@ -1000,7 +950,7 @@ export default function RoleDetailPanel({ selectedRole, onActivate, onDelete, on
                 {t("resources.actions.export")}
               </Button>
             )}
-            {(selectedRole.source ?? "user") !== "system" && (
+            {(selectedRole.source ?? "user") !== "system" && !isV2 && (
               <Button variant="outline" size="sm" className="text-destructive hover:text-destructive hover:bg-destructive/10 border-destructive/30" onClick={() => onDelete(selectedRole)}>
                 <Trash2 className="h-3.5 w-3.5 mr-1.5" />
                 {t("resources.actions.delete")}
diff --git a/apps/desktop/src/view/pages/roles-window/components/RoleTreeListPanel.tsx b/apps/desktop/src/view/pages/roles-window/components/RoleTreeListPanel.tsx
new file mode 100644
index 00000000..2169bd28
--- /dev/null
+++ b/apps/desktop/src/view/pages/roles-window/components/RoleTreeListPanel.tsx
@@ -0,0 +1,282 @@
+import { useTranslation } from "react-i18next"
+import { Input } from "@/components/ui/input"
+import { ScrollArea } from "@/components/ui/scroll-area"
+import { Search, Loader2, ChevronRight, ChevronDown, Building2, Users } from "lucide-react"
+import RoleAvatar from "./RoleAvatar"
+import { useState } from "react"
+
+type RoleItem = {
+  id: string
+  name: string
+  description?: string
+  type: "role"
+  source?: string
+  version?: "v1" | "v2"
+  org?: string
+  position?: string
+}
+
+type OrganizationNode = {
+  name: string
+  charter?: string
+  roles: RoleItem[]
+}
+
+type VersionFilter = "v1" | "v2"
+type SourceFilter = "all" | "system" | "plaza" | "user"
+
+type Props = {
+  loading: boolean
+  filteredRoles: RoleItem[]
+  organizations: OrganizationNode[]
+  versionFilter: VersionFilter
+  setVersionFilter: (v: VersionFilter) => void
+  versionStats: { v1: number; v2: number }
+  sourceFilter: SourceFilter
+  setSourceFilter: (f: SourceFilter) => void
+  sourceStats: { system: number; plaza: number; user: number }
+  query: string
+  setQuery: (q: string) => void
+  selectedRole: RoleItem | null
+  setSelectedRole: (r: RoleItem) => void
+  enableV2?: boolean
+}
+
+export default function RoleTreeListPanel({
+  loading, filteredRoles, organizations, versionFilter, setVersionFilter, versionStats,
+  sourceFilter, setSourceFilter, sourceStats, query, setQuery,
+  selectedRole, setSelectedRole, enableV2 = true,
+}: Props) {
+  const { t } = useTranslation()
+  const [expandedOrgs, setExpandedOrgs] = useState<Set<string>>(new Set())
+
+  const toggleOrg = (orgName: string) => {
+    setExpandedOrgs(prev => {
+      const next = new Set(prev)
+      if (next.has(orgName)) {
+        next.delete(orgName)
+      } else {
+        next.add(orgName)
+      }
+      return next
+    })
+  }
+
+  // 分离有组织的角色和无组织的角色
+  const rolesWithOrg = filteredRoles.filter(r => r.org)
+  const rolesWithoutOrg = filteredRoles.filter(r => !r.org)
+
+  // 按组织分组
+  const orgMap = new Map<string, RoleItem[]>()
+  rolesWithOrg.forEach(role => {
+    if (role.org) {
+      if (!orgMap.has(role.org)) {
+        orgMap.set(role.org, [])
+      }
+      orgMap.get(role.org)!.push(role)
+    }
+  })
+
+  // 获取组织信息
+  const getOrgInfo = (orgName: string) => {
+    return organizations.find(o => o.name === orgName)
+  }
+
+  const renderRole = (role: RoleItem) => (
+    <button
+      key={`${role.source}-${role.id}`}
+      className={`w-full flex items-center gap-3 rounded-lg px-3 py-2.5 text-left transition-colors ${
+        selectedRole?.id === role.id && selectedRole?.source === role.source
+          ? "bg-accent border border-border"
+          : "hover:bg-muted"
+      }`}
+      onClick={() => setSelectedRole(role)}
+    >
+      <RoleAvatar
+        id={role.id}
+        name={role.name}
+        source={role.source}
+        className="h-9 w-9 rounded-lg text-sm"
+      />
+      <div className="w-0 flex-1">
+        <div className="flex items-center gap-2">
+          <span className="text-sm font-medium truncate">{role.name}</span>
+          {role.position && (
+            <span className="shrink-0 rounded px-1.5 py-0.5 text-[10px] font-medium bg-purple-100 text-purple-700">
+              {role.position}
+            </span>
+          )}
+          <span className={`shrink-0 rounded px-1.5 py-0.5 text-[10px] font-medium ${
+            role.source === "system"
+              ? "bg-blue-100 text-blue-700"
+              : role.source === "project"
+              ? "bg-amber-100 text-amber-700"
+              : "bg-green-100 text-green-700"
+          }`}>
+            {t(`roles.filters.${role.source === "project" ? "plaza" : (role.source ?? "user")}`)}
+          </span>
+        </div>
+        <p className="text-xs text-muted-foreground truncate mt-0.5">
+          {role.description || t("roles.noDescription")}
+        </p>
+      </div>
+    </button>
+  )
+
+  return (
+    <div className="w-[320px] border-r flex flex-col bg-muted/30 overflow-hidden">
+      <div className="p-3 space-y-2">
+        {enableV2 ? (
+          <>
+            {/* V2 enabled: V1/V2 toggle → source filter → search */}
+            <div className="flex gap-1">
+              {(["v1", "v2"] as const).map((v) => (
+                <button
+                  key={v}
+                  className={`flex-1 rounded-md px-2 py-1.5 text-xs font-medium transition-colors ${
+                    versionFilter === v
+                      ? "bg-foreground text-background"
+                      : "bg-muted text-muted-foreground hover:bg-muted/80"
+                  }`}
+                  onClick={() => { setVersionFilter(v); setSourceFilter("all") }}
+                >
+                  {v === "v1" ? "V1 DPML" : "V2 Rolex"}
+                  <span className="ml-1 opacity-70">({versionStats[v]})</span>
+                </button>
+              ))}
+            </div>
+            <div className="flex gap-1">
+              {(["all", "system", "plaza", "user"] as const).map((f) => (
+                <button
+                  key={f}
+                  className={`flex-1 rounded-md px-1 py-0.5 text-[10px] transition-colors ${
+                    sourceFilter === f
+                      ? "bg-foreground/80 text-background"
+                      : "bg-muted/60 text-muted-foreground hover:bg-muted/80"
+                  }`}
+                  onClick={() => setSourceFilter(f)}
+                >
+                  {t(`roles.filters.${f}`)}
+                  {f !== "all" && <span className="ml-0.5 opacity-70">({sourceStats[f]})</span>}
+                </button>
+              ))}
+            </div>
+            <div className="relative">
+              <Search className="absolute left-2.5 top-2.5 h-4 w-4 text-muted-foreground" />
+              <Input
+                placeholder={t("roles.search.placeholder")}
+                value={query}
+                onChange={(e) => setQuery(e.target.value)}
+                className="pl-8 h-9 text-sm"
+              />
+            </div>
+          </>
+        ) : (
+          <>
+            {/* V2 disabled: search → source filter */}
+            <div className="relative">
+              <Search className="absolute left-2.5 top-2.5 h-4 w-4 text-muted-foreground" />
+              <Input
+                placeholder={t("roles.search.placeholder")}
+                value={query}
+                onChange={(e) => setQuery(e.target.value)}
+                className="pl-8 h-9 text-sm"
+              />
+            </div>
+            <div className="flex gap-1">
+              {(["all", "system", "plaza", "user"] as const).map((f) => (
+                <button
+                  key={f}
+                  className={`flex-1 rounded-md px-1.5 py-1 text-[11px] transition-colors ${
+                    sourceFilter === f
+                      ? "bg-foreground text-background"
+                      : "bg-muted text-muted-foreground hover:bg-muted/80"
+                  }`}
+                  onClick={() => setSourceFilter(f)}
+                >
+                  {t(`roles.filters.${f}`)}
+                  {f !== "all" && <span className="ml-0.5 opacity-70">({sourceStats[f]})</span>}
+                </button>
+              ))}
+            </div>
+          </>
+        )}
+      </div>
+      <ScrollArea className="flex-1">
+        <div className="px-2 pb-2 space-y-1">
+          {loading && filteredRoles.length === 0 ? (
+            <div className="flex items-center justify-center py-10">
+              <Loader2 className="h-5 w-5 animate-spin text-muted-foreground" />
+            </div>
+          ) : filteredRoles.length === 0 ? (
+            <div className="text-center py-10 text-sm text-muted-foreground">
+              {t("roles.empty")}
+            </div>
+          ) : versionFilter === "v2" ? (
+            <>
+              {/* V2 角色：显示组织树状结构 */}
+              {Array.from(orgMap.entries()).map(([orgName, orgRoles]) => {
+                const orgInfo = getOrgInfo(orgName)
+                const isExpanded = expandedOrgs.has(orgName)
+                return (
+                  <div key={orgName} className="mb-2">
+                    <button
+                      className="w-full flex items-center gap-2 rounded-lg px-3 py-2 text-left transition-colors hover:bg-muted/80 bg-muted/50"
+                      onClick={() => toggleOrg(orgName)}
+                    >
+                      {isExpanded ? (
+                        <ChevronDown className="h-4 w-4 text-muted-foreground shrink-0" />
+                      ) : (
+                        <ChevronRight className="h-4 w-4 text-muted-foreground shrink-0" />
+                      )}
+                      <Building2 className="h-4 w-4 text-primary shrink-0" />
+                      <div className="flex-1 min-w-0">
+                        <div className="flex items-center gap-2">
+                          <span className="text-sm font-semibold truncate">{orgName}</span>
+                          <span className="shrink-0 rounded-full bg-primary/10 px-2 py-0.5 text-[10px] font-medium text-primary">
+                            {orgRoles.length}
+                          </span>
+                        </div>
+                        {orgInfo?.charter && (
+                          <p className="text-xs text-muted-foreground truncate mt-0.5">
+                            {orgInfo.charter}
+                          </p>
+                        )}
+                      </div>
+                    </button>
+                    {isExpanded && (
+                      <div className="ml-6 mt-1 space-y-1 border-l-2 border-muted pl-2">
+                        {orgRoles.map(role => renderRole(role))}
+                      </div>
+                    )}
+                  </div>
+                )
+              })}
+
+              {/* 无组织的 V2 角色 */}
+              {rolesWithoutOrg.length > 0 && (
+                <div className="mb-2">
+                  <div className="flex items-center gap-2 px-3 py-2 text-sm text-muted-foreground">
+                    <Users className="h-4 w-4" />
+                    <span className="font-medium">{t("roles.filters.independent")}</span>
+                    <span className="rounded-full bg-muted px-2 py-0.5 text-[10px]">
+                      {rolesWithoutOrg.length}
+                    </span>
+                  </div>
+                  <div className="space-y-1">
+                    {rolesWithoutOrg.map(role => renderRole(role))}
+                  </div>
+                </div>
+              )}
+            </>
+          ) : (
+            /* V1 角色：平面列表 */
+            filteredRoles.map(role => renderRole(role))
+          )}
+        </div>
+      </ScrollArea>
+    </div>
+  )
+}
+
+export type { RoleItem, VersionFilter, SourceFilter, OrganizationNode }
diff --git a/apps/desktop/src/view/pages/roles-window/index.tsx b/apps/desktop/src/view/pages/roles-window/index.tsx
index a3bd2e4f..27972e20 100644
--- a/apps/desktop/src/view/pages/roles-window/index.tsx
+++ b/apps/desktop/src/view/pages/roles-window/index.tsx
@@ -2,12 +2,13 @@ import { useEffect, useMemo, useState } from "react"
 import { useTranslation } from "react-i18next"
 import { toast, Toaster } from "sonner"
 import { goToSendMessage } from "../../../utils/goToSendMessage"
-import RoleListPanel from "./components/RoleListPanel"
+import RoleTreeListPanel from "./components/RoleTreeListPanel"
 import RoleDetailPanel from "./components/RoleDetailPanel"
-import type { RoleItem, VersionFilter, SourceFilter } from "./components/RoleListPanel"
+import type { RoleItem, VersionFilter, SourceFilter, OrganizationNode } from "./components/RoleTreeListPanel"
 export default function RolesPage() {
   const { t } = useTranslation()
   const [roles, setRoles] = useState<RoleItem[]>([])
+  const [organizations, setOrganizations] = useState<OrganizationNode[]>([])
   const [query, setQuery] = useState("")
   const [versionFilter, setVersionFilter] = useState<VersionFilter>("v2")
   const [sourceFilter, setSourceFilter] = useState<SourceFilter>("all")
@@ -62,6 +63,8 @@ export default function RolesPage() {
       if (result?.success) {
         const { grouped } = result.data || {}
         const flat: RoleItem[] = []
+
+        // 加载基础角色数据
         Object.keys(grouped || {}).forEach((source) => {
           const group = grouped[source] || {}
           ;(group.roles || []).forEach((role: any) =>
@@ -75,6 +78,41 @@ export default function RolesPage() {
             })
           )
         })
+
+        // 如果启用了 V2，加载组织目录信息
+        if (useV2) {
+          try {
+            const directoryResult = await window.electronAPI?.invoke("rolex:directory", {})
+            if (directoryResult?.success) {
+              const directory = directoryResult.data
+
+              // 更新角色的组织信息
+              if (directory?.roles) {
+                flat.forEach(role => {
+                  if (role.version === "v2") {
+                    const roleEntry = directory.roles.find((r: any) => r.name === role.id)
+                    if (roleEntry) {
+                      role.org = roleEntry.org
+                      role.position = roleEntry.position
+                    }
+                  }
+                })
+              }
+
+              // 设置组织列表
+              if (directory?.organizations) {
+                setOrganizations(directory.organizations.map((org: any) => ({
+                  name: org.name,
+                  charter: org.charter,
+                  roles: flat.filter(r => r.org === org.name)
+                })))
+              }
+            }
+          } catch (e) {
+            console.error('Failed to load directory:', e)
+          }
+        }
+
         setRoles(flat)
         if (flat.length > 0 && !selectedRole) {
           if (useV2) {
@@ -136,9 +174,10 @@ export default function RolesPage() {
   return (
     <div className="flex h-full">
       <Toaster />
-      <RoleListPanel
+      <RoleTreeListPanel
         loading={loading}
         filteredRoles={filteredRoles}
+        organizations={organizations}
         versionFilter={versionFilter}
         setVersionFilter={setVersionFilter}
         versionStats={versionStats}
diff --git a/apps/desktop/src/view/pages/settings-window/components/AgentXProfilesConfig.tsx b/apps/desktop/src/view/pages/settings-window/components/AgentXProfilesConfig.tsx
index d0a20b49..78604ff8 100644
--- a/apps/desktop/src/view/pages/settings-window/components/AgentXProfilesConfig.tsx
+++ b/apps/desktop/src/view/pages/settings-window/components/AgentXProfilesConfig.tsx
@@ -3,13 +3,7 @@ import { useTranslation } from "react-i18next"
 import { Button } from "@/components/ui/button"
 import { Input } from "@/components/ui/input"
 import { Label } from "@/components/ui/label"
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-  DialogFooter,
-} from "@/components/ui/dialog"
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog"
 import { CheckCircle2, XCircle, Loader2, Plus, Pencil, Trash2, Check } from "lucide-react"
 import { toast } from "sonner"
 
@@ -25,11 +19,70 @@ const EMPTY_FORM = {
   name: "",
   apiKey: "",
   baseUrl: "https://api.anthropic.com",
-  model: "claude-sonnet-4-20250514",
+  model: "claude-sonnet-4-20250514"
 }
 
+const PRESETS = [
+  {
+    id: "anthropic",
+    name: "Anthropic Official",
+    nameZh: "Anthropic 官方",
+    baseUrl: "https://api.anthropic.com",
+    model: "claude-opus-4-6"
+  },
+  {
+    id: "DouBaoSeed",
+    name: "DouBao Seed",
+    nameZh: "豆包 Seed",
+    baseUrl: "https://ark.cn-beijing.volces.com/api/coding",
+    model: "ark-code-latest"
+  },
+  {
+    id: "Kimi Code",
+    name: "Kimi Code",
+    nameZh: "Kimi Code",
+    baseUrl: "https://api.kimi.com/coding",
+    model: "kimi"
+  },
+  {
+    id: "packyapi",
+    name: "PackyAPI",
+    nameZh: "PackyAPI",
+    baseUrl: "https://www.packyapi.com",
+    model: "claude-opus-4-6"
+  },
+  {
+    id: "deepractice",
+    name: "Deepractice",
+    nameZh: "深度实践",
+    baseUrl: "https://relay.deepractice.ai/api",
+    model: "claude-opus-4-6"
+  },
+  {
+    id: "siliconflow",
+    name: "SiliconFlow",
+    nameZh: "硅基流动",
+    baseUrl: "https://api.siliconflow.cn",
+    model: "zai-org/GLM-4.6"
+  },
+  {
+    id: "openrouter",
+    name: "OpenRouter",
+    nameZh: "OpenRouter",
+    baseUrl: "https://openrouter.ai/api ",
+    model: "claude-opus-4-6"
+  },
+  {
+    id: "custom",
+    name: "Custom",
+    nameZh: "自定义",
+    baseUrl: "",
+    model: "claude-sonnet-4-20250514"
+  }
+]
+
 export function AgentXProfilesConfig() {
-  const { t } = useTranslation()
+  const { t, i18n } = useTranslation()
   const [profiles, setProfiles] = useState<AgentXProfile[]>([])
   const [activeProfileId, setActiveProfileId] = useState<string | undefined>()
   const [dialogOpen, setDialogOpen] = useState(false)
@@ -38,8 +91,11 @@ export function AgentXProfilesConfig() {
   const [isTesting, setIsTesting] = useState(false)
   const [isSaving, setIsSaving] = useState(false)
   const [connectionStatus, setConnectionStatus] = useState<"idle" | "success" | "error">("idle")
+  const [urlError, setUrlError] = useState<string>("")
 
-  useEffect(() => { loadProfiles() }, [])
+  useEffect(() => {
+    loadProfiles()
+  }, [])
 
   const loadProfiles = async () => {
     const config = await window.electronAPI?.agentx.getConfig()
@@ -53,13 +109,36 @@ export function AgentXProfilesConfig() {
     setEditingId(null)
     setForm(EMPTY_FORM)
     setConnectionStatus("idle")
+    setUrlError("")
     setDialogOpen(true)
   }
 
+  const validateBaseUrl = (url: string) => {
+    if (url.includes("completions") || url.includes("/v1/chat")) {
+      setUrlError(t("settings.agentx.profiles.openaiNotSupported"))
+      return false
+    }
+    setUrlError("")
+    return true
+  }
+
+  const applyPreset = (preset: (typeof PRESETS)[0]) => {
+    const presetName = i18n.language === "zh-CN" ? preset.nameZh : preset.name
+    setForm(f => ({
+      ...f,
+      name: presetName,
+      baseUrl: preset.baseUrl,
+      model: preset.model
+    }))
+    setConnectionStatus("idle")
+  }
+
   const openEdit = (p: AgentXProfile) => {
     setEditingId(p.id)
     setForm({ name: p.name, apiKey: p.apiKey, baseUrl: p.baseUrl, model: p.model })
     setConnectionStatus("idle")
+    setUrlError("")
+    validateBaseUrl(p.baseUrl)
     setDialogOpen(true)
   }
 
@@ -87,7 +166,7 @@ export function AgentXProfilesConfig() {
       const result = await window.electronAPI?.agentx.testConnection({
         apiKey: form.apiKey,
         baseUrl: form.baseUrl,
-        model: form.model,
+        model: form.model
       })
       setConnectionStatus(result?.success ? "success" : "error")
       if (!result?.success) toast.error(result?.error ?? t("settings.agentx.testFailed"))
@@ -108,7 +187,7 @@ export function AgentXProfilesConfig() {
       let newActiveId = (config as any).activeProfileId as string | undefined
 
       if (editingId) {
-        newProfiles = existing.map(p => p.id === editingId ? { ...p, ...form } : p)
+        newProfiles = existing.map(p => (p.id === editingId ? { ...p, ...form } : p))
       } else {
         const newProfile: AgentXProfile = { id: crypto.randomUUID(), ...form }
         newProfiles = [...existing, newProfile]
@@ -135,13 +214,11 @@ export function AgentXProfilesConfig() {
             <div className="min-w-0 flex-1">
               <div className="flex items-center gap-2">
                 <span className="text-sm font-medium">{profile.name}</span>
-                {profile.id === activeProfileId && (
-                  <span className="rounded-full bg-green-100 px-1.5 py-0.5 text-xs text-green-700 dark:bg-green-900/30 dark:text-green-400">
-                    {t("settings.agentx.profiles.active")}
-                  </span>
-                )}
+                {profile.id === activeProfileId && <span className="rounded-full bg-green-100 px-1.5 py-0.5 text-xs text-green-700 dark:bg-green-900/30 dark:text-green-400">{t("settings.agentx.profiles.active")}</span>}
               </div>
-              <p className="truncate text-xs text-muted-foreground">{profile.baseUrl} · {profile.model}</p>
+              <p className="truncate text-xs text-muted-foreground">
+                {profile.baseUrl} · {profile.model}
+              </p>
             </div>
             <div className="flex shrink-0 items-center gap-1">
               {profile.id !== activeProfileId && (
@@ -168,18 +245,47 @@ export function AgentXProfilesConfig() {
       <Dialog open={dialogOpen} onOpenChange={setDialogOpen}>
         <DialogContent className="sm:max-w-md">
           <DialogHeader>
-            <DialogTitle>
-              {editingId ? t("settings.agentx.profiles.editTitle") : t("settings.agentx.profiles.addTitle")}
-            </DialogTitle>
+            <DialogTitle>{editingId ? t("settings.agentx.profiles.editTitle") : t("settings.agentx.profiles.addTitle")}</DialogTitle>
           </DialogHeader>
+
+          {/* Preset buttons - only show when adding new profile */}
+          {!editingId && (
+            <div className="flex flex-wrap gap-2 pb-2">
+              {PRESETS.map(preset => {
+                const displayName = i18n.language === "zh-CN" ? preset.nameZh : preset.name
+                return (
+                  <Button key={preset.id} variant="outline" size="sm" className="flex-1 min-w-[120px]" onClick={() => applyPreset(preset)}>
+                    {displayName}
+                  </Button>
+                )
+              })}
+            </div>
+          )}
+
           <div className="space-y-4 py-2">
             <div className="space-y-1.5">
               <Label>{t("settings.agentx.profiles.name")}</Label>
+              <Input value={form.name} placeholder="My Config" onChange={e => setForm(f => ({ ...f, name: e.target.value }))} />
+            </div>
+            <div className="space-y-1.5">
+              <div className="flex items-center gap-2">
+                <Label>{t("settings.agentx.baseUrl.label")}</Label>
+                <span className="text-xs text-muted-foreground">({t("settings.agentx.profiles.anthropicOnly")})</span>
+              </div>
               <Input
-                value={form.name}
-                placeholder="My Config"
-                onChange={e => setForm(f => ({ ...f, name: e.target.value }))}
+                value={form.baseUrl}
+                placeholder={t("settings.agentx.baseUrl.placeholder")}
+                className={urlError ? "border-red-500" : ""}
+                onChange={e => {
+                  const newUrl = e.target.value
+                  setForm(f => ({ ...f, baseUrl: newUrl }))
+                  validateBaseUrl(newUrl)
+                  setConnectionStatus("idle")
+                }}
               />
+              {urlError && (
+                <p className="text-xs text-red-500">{urlError}</p>
+              )}
             </div>
             <div className="space-y-1.5">
               <Label>{t("settings.agentx.apiKey.label")}</Label>
@@ -187,15 +293,10 @@ export function AgentXProfilesConfig() {
                 type="password"
                 value={form.apiKey}
                 placeholder={t("settings.agentx.apiKey.placeholder")}
-                onChange={e => { setForm(f => ({ ...f, apiKey: e.target.value })); setConnectionStatus("idle") }}
-              />
-            </div>
-            <div className="space-y-1.5">
-              <Label>{t("settings.agentx.baseUrl.label")}</Label>
-              <Input
-                value={form.baseUrl}
-                placeholder={t("settings.agentx.baseUrl.placeholder")}
-                onChange={e => { setForm(f => ({ ...f, baseUrl: e.target.value })); setConnectionStatus("idle") }}
+                onChange={e => {
+                  setForm(f => ({ ...f, apiKey: e.target.value }))
+                  setConnectionStatus("idle")
+                }}
               />
             </div>
             <div className="space-y-1.5">
@@ -203,7 +304,10 @@ export function AgentXProfilesConfig() {
               <Input
                 value={form.model}
                 placeholder={t("settings.agentx.model.placeholder")}
-                onChange={e => { setForm(f => ({ ...f, model: e.target.value })); setConnectionStatus("idle") }}
+                onChange={e => {
+                  setForm(f => ({ ...f, model: e.target.value }))
+                  setConnectionStatus("idle")
+                }}
               />
             </div>
           </div>
@@ -215,7 +319,7 @@ export function AgentXProfilesConfig() {
             {connectionStatus === "success" && <CheckCircle2 className="h-5 w-5 text-green-500" />}
             {connectionStatus === "error" && <XCircle className="h-5 w-5 text-red-500" />}
             <div className="flex-1" />
-            <Button disabled={isSaving || !form.name || !form.apiKey} onClick={handleSave}>
+            <Button disabled={isSaving || !form.name || !form.apiKey || !!urlError} onClick={handleSave}>
               {isSaving ? t("settings.agentx.saving") : t("settings.agentx.save")}
             </Button>
           </DialogFooter>
diff --git a/apps/desktop/src/view/pages/settings-window/index.tsx b/apps/desktop/src/view/pages/settings-window/index.tsx
index 6731ea38..85fd278f 100644
--- a/apps/desktop/src/view/pages/settings-window/index.tsx
+++ b/apps/desktop/src/view/pages/settings-window/index.tsx
@@ -323,7 +323,20 @@ function SettingsWindow() {
                       target="_blank"
                       rel="noreferrer"
                       className="font-medium underline underline-offset-2 hover:text-yellow-900 dark:hover:text-yellow-200"
-                      onClick={e => { e.preventDefault(); window.electronAPI?.shell?.openExternal("https://git-scm.com/download/win") }}
+                      onClick={async (e) => {
+                        e.preventDefault();
+                        const url = "https://git-scm.com/download/win";
+                        try {
+                          if (window.electronAPI?.shell?.openExternal) {
+                            await window.electronAPI.shell.openExternal(url);
+                          } else {
+                            window.open(url, "_blank");
+                          }
+                        } catch (error) {
+                          console.error("Failed to open external URL:", error);
+                          toast.error("无法打开链接，请手动访问: " + url);
+                        }
+                      }}
                     >
                       {t("settings.agentx.windowsGitWarning.link")}
                     </a>
diff --git a/package.json b/package.json
index dad2d085..148ac042 100644
--- a/package.json
+++ b/package.json
@@ -24,6 +24,7 @@
     "@types/node": "^22.19.11",
     "@vitest/coverage-v8": "^4.0.18",
     "@vitest/ui": "^4.0.18",
+    "electron": "38.0.0",
     "eslint": "^8.57.1",
     "prettier": "^2.8.8",
     "rimraf": "^5.0.10",
@@ -31,8 +32,7 @@
     "tsx": "^4.20.5",
     "turbo": "^2.5.6",
     "typescript": "^5.9.2",
-    "vitest": "^4.0.18",
-    "electron": "38.0.0"
+    "vitest": "^4.0.18"
   },
   "engines": {
     "node": ">=18.17.0",
@@ -84,5 +84,8 @@
       "lodash": "^4.17.21",
       "tough-cookie": "^5.0.0"
     }
+  },
+  "dependencies": {
+    "@rolexjs/genesis": "1.3.0"
   }
 }
diff --git a/packages/core/package.json b/packages/core/package.json
index 36543c8e..f9428319 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -36,9 +36,11 @@
     "@npmcli/arborist": "^9.2.0",
     "@promptx/logger": "workspace:*",
     "@promptx/resource": "workspace:*",
-    "@rolexjs/core": "^0.11.0",
-    "@rolexjs/local-platform": "^0.11.0",
-    "@rolexjs/parser": "^0.11.0",
+    "@rolexjs/core": "^1.1.0",
+    "@rolexjs/local-platform": "^1.1.0",
+    "@rolexjs/parser": "^1.1.0",
+    "@rolexjs/prototype": "^1.1.0",
+    "@rolexjs/system": "^1.1.0",
     "ajv": "^8.17.1",
     "better-sqlite3": "^12.4.1",
     "env-paths": "2.2.1",
@@ -50,7 +52,8 @@
     "importx": "^0.5.2",
     "is-electron": "^2.2.2",
     "peggy": "^5.0.5",
-    "rolexjs": "^0.11.0"
+    "resourcexjs": "^2.14.0",
+    "rolexjs": "^1.1.0"
   },
   "files": [
     "dist/**/*",
diff --git a/packages/core/src/pouch/areas/discover/RoleListArea.js b/packages/core/src/pouch/areas/discover/RoleListArea.js
index 0e14176c..2b3ff3aa 100644
--- a/packages/core/src/pouch/areas/discover/RoleListArea.js
+++ b/packages/core/src/pouch/areas/discover/RoleListArea.js
@@ -5,39 +5,65 @@ const logger = require('@promptx/logger')
  * RoleListArea - 角色列表展示区域
  */
 class RoleListArea extends BaseArea {
-  constructor(roleCategories) {
+  constructor(roleCategories, directoryData = null) {
     super('ROLE_LIST_AREA')
     this.roleCategories = roleCategories
+    this.directoryData = directoryData || { roles: [], organizations: [] }
   }
 
   async render() {
     let content = ''
-    
+
     // 渲染各个来源的角色
     for (const [source, roles] of Object.entries(this.roleCategories)) {
       if (roles.length === 0) continue
-      
+
       const sourceIcon = this.getSourceIcon(source)
       const sourceTitle = this.getSourceTitle(source)
-      
+
       content += `\n${sourceIcon} **${sourceTitle}** (${roles.length}个)\n`
-      
+
       // 按ID排序
       roles.sort((a, b) => a.id.localeCompare(b.id))
-      
+
       roles.forEach(role => {
         if (role.version === 'v2') {
           const command = `action({ operation: "activate", role: "${role.id}" })`
-          content += `- \`${role.id}\` [V2]: ${role.name || '未命名角色'} → ${command}\n`
+          const orgInfo = this.getOrganizationInfo(role.id)
+          if (orgInfo) {
+            content += `- \`${role.id}\` [V2]: ${role.name || '未命名角色'} (${orgInfo.org} - ${orgInfo.position}) → ${command}\n`
+          } else {
+            content += `- \`${role.id}\` [V2]: ${role.name || '未命名角色'} → ${command}\n`
+          }
         } else {
           const command = `action("${role.id}")`
           content += `- \`${role.id}\`: ${role.name || role.title || '未命名角色'} → ${command}\n`
         }
       })
     }
-    
+
     return content || '暂无可用角色'
   }
+
+  /**
+   * 获取角色的组织和岗位信息
+   * @param {string} roleId - 角色ID
+   * @returns {Object|null} { org: string, position: string } 或 null
+   */
+  getOrganizationInfo(roleId) {
+    if (!this.directoryData || !this.directoryData.roles) {
+      return null
+    }
+
+    const roleData = this.directoryData.roles.find(r => r.name === roleId)
+    if (roleData && roleData.org && roleData.position) {
+      return {
+        org: roleData.org,
+        position: roleData.position
+      }
+    }
+    return null
+  }
   
   getSourceIcon(source) {
     const icons = {
diff --git a/packages/core/src/pouch/commands/DiscoverCommand.js b/packages/core/src/pouch/commands/DiscoverCommand.js
index d0451869..86a782b1 100644
--- a/packages/core/src/pouch/commands/DiscoverCommand.js
+++ b/packages/core/src/pouch/commands/DiscoverCommand.js
@@ -33,28 +33,31 @@ class DiscoverCommand extends BasePouchCommand {
   async assembleAreas(args) {
     // 首先刷新所有资源
     await this.refreshAllResources()
-    
+
     // 加载角色和工具
     const roleRegistry = await this.loadRoleRegistry()
     const toolRegistry = await this.loadToolRegistry()
-    
+
+    // 获取 V2 角色的组织信息
+    const directoryData = await this.loadDirectoryData()
+
     // 按来源分组
     const roleCategories = this.categorizeBySource(roleRegistry)
     const toolCategories = this.categorizeBySource(toolRegistry)
-    
+
     // 统计信息
     const stats = this.calculateStats(roleCategories, toolCategories)
-    
+
     // 注册Areas
     const headerArea = new DiscoverHeaderArea(stats)
     this.registerArea(headerArea)
-    
-    const roleArea = new RoleListArea(roleCategories)
+
+    const roleArea = new RoleListArea(roleCategories, directoryData)
     this.registerArea(roleArea)
-    
+
     const toolArea = new ToolListArea(toolCategories)
     this.registerArea(toolArea)
-    
+
     const stateArea = new StateArea('discover_completed')
     this.registerArea(stateArea)
   }
@@ -245,7 +248,51 @@ class DiscoverCommand extends BasePouchCommand {
 
     return registry
   }
-  
+
+  /**
+   * 加载 V2 角色的组织架构信息
+   * @returns {Promise<Object>} 组织架构数据
+   */
+  async loadDirectoryData() {
+    try {
+      const bridge = getRolexBridge()
+      const directoryData = await bridge.directory()
+      logger.info('[DiscoverCommand] Directory data type:', typeof directoryData)
+      logger.info('[DiscoverCommand] Directory data:', JSON.stringify(directoryData, null, 2))
+
+      // bridge.directory() 已经返回解析好的对象，不需要再解析
+      if (directoryData && typeof directoryData === 'object') {
+        logger.info(`[DiscoverCommand] Loaded directory data: ${directoryData.roles?.length || 0} roles, ${directoryData.organizations?.length || 0} orgs`)
+        return directoryData
+      }
+      return { roles: [], organizations: [] }
+    } catch (error) {
+      logger.warn('[DiscoverCommand] Failed to load directory data:', error.message)
+      logger.warn('[DiscoverCommand] Error stack:', error.stack)
+      return { roles: [], organizations: [] }
+    }
+  }
+
+  /**
+   * 解析 directory 命令的输出
+   * @param {string} text - directory 命令的文本输出
+   * @returns {Object} 解析后的数据 { roles: [], organizations: [] }
+   * @deprecated bridge.directory() 已经返回解析好的对象
+   */
+  parseDirectoryOutput(text) {
+    try {
+      // directory 输出是 JSON 格式
+      const data = JSON.parse(text)
+      return {
+        roles: data.roles || [],
+        organizations: data.organizations || []
+      }
+    } catch (error) {
+      logger.warn('[DiscoverCommand] Failed to parse directory output:', error.message)
+      return { roles: [], organizations: [] }
+    }
+  }
+
   /**
    * 加载工具注册表
    * @returns {Promise<Object>} 工具注册信息（按来源分类）
diff --git a/packages/core/src/pouch/commands/RecallCommand.js b/packages/core/src/pouch/commands/RecallCommand.js
index 83f4c14c..ad929c64 100644
--- a/packages/core/src/pouch/commands/RecallCommand.js
+++ b/packages/core/src/pouch/commands/RecallCommand.js
@@ -41,6 +41,32 @@ class RecallCommand extends BasePouchCommand {
       return
     }
 
+    // 检查是否为 V2 角色
+    try {
+      const { getRolexBridge } = require('../../rolex')
+      const bridge = getRolexBridge()
+      const isV2 = await bridge.isV2Role(role)
+      if (isV2) {
+        const roleLayer = new RoleLayer()
+        roleLayer.addRoleArea(new StateArea(
+          'error: V2 角色不支持 recall 命令',
+          [
+            'V2 角色使用 RoleX 记忆系统，请使用以下命令：',
+            '- focus: 查看当前目标和进展',
+            '- identity: 查看角色身份定义',
+            '- action: 执行角色相关操作',
+            '',
+            '传统的 remember/recall 命令仅适用于 V1 角色'
+          ]
+        ))
+        this.registerLayer(roleLayer)
+        return
+      }
+    } catch (error) {
+      logger.warn('[RecallCommand] Failed to check V2 role:', error)
+      // 如果检查失败，继续执行（向后兼容）
+    }
+
     logger.info('🧠 [RecallCommand] 开始记忆检索流程 (基于认知体系)')
     logger.info(` [RecallCommand] 角色: ${role}, 查询内容: ${query ? `"${query}"` : '全部记忆'}, 模式: ${mode || 'balanced'}`)
 
diff --git a/packages/core/src/pouch/commands/RememberCommand.js b/packages/core/src/pouch/commands/RememberCommand.js
index 61f180d9..a873b7e2 100644
--- a/packages/core/src/pouch/commands/RememberCommand.js
+++ b/packages/core/src/pouch/commands/RememberCommand.js
@@ -38,6 +38,32 @@ class RememberCommand extends BasePouchCommand {
       return
     }
 
+    // 检查是否为 V2 角色
+    try {
+      const { getRolexBridge } = require('../../rolex')
+      const bridge = getRolexBridge()
+      const isV2 = await bridge.isV2Role(role)
+      if (isV2) {
+        const roleLayer = new RoleLayer()
+        roleLayer.addRoleArea(new StateArea(
+          'error: V2 角色不支持 remember 命令',
+          [
+            'V2 角色使用 RoleX 记忆系统，请使用以下命令：',
+            '- reflect: 反思经历并形成经验',
+            '- realize: 从经验中掌握原则',
+            '- master: 掌握程序/技能',
+            '',
+            '传统的 remember/recall 命令仅适用于 V1 角色'
+          ]
+        ))
+        this.registerLayer(roleLayer)
+        return
+      }
+    } catch (error) {
+      logger.warn('[RememberCommand] Failed to check V2 role:', error)
+      // 如果检查失败，继续执行（向后兼容）
+    }
+
     try {
       logger.info('🧠 [RememberCommand] 开始批量记忆保存流程')
       logger.info(` [RememberCommand] 批量保存 ${engrams.length} 个Engram`)
diff --git a/packages/core/src/resource/protocols/RoleProtocol.js b/packages/core/src/resource/protocols/RoleProtocol.js
index c7d2b097..3cd9c6c4 100644
--- a/packages/core/src/resource/protocols/RoleProtocol.js
+++ b/packages/core/src/resource/protocols/RoleProtocol.js
@@ -46,24 +46,33 @@ class RoleProtocol extends ResourceProtocol {
 
   /**
    * 解析角色协议
-   * @param {string} rolePath - 角色路径，如 'java-developer'
+   * @param {string} rolePath - 角色路径，如 'java-developer' 或 'v2:nuwa'
    * @param {Object} queryParams - 查询参数（暂未使用）
    * @returns {Promise<string>} 角色文件内容
    */
   async resolve(rolePath, queryParams = {}) {
     try {
+      // 检查是否为 v2 角色（带 v2: 前缀）
+      if (rolePath.startsWith('v2:')) {
+        const roleId = rolePath.substring(3) // 去掉 'v2:' 前缀
+        const { getRolexBridge } = require('../rolex/RolexBridge')
+        const bridge = getRolexBridge()
+        const content = await bridge.identity(roleId)
+        return content
+      }
+
       // 构建可能的资源ID格式
       const fullResourceId = `role:${rolePath}`
       const shortResourceId = rolePath
-      
+
       // 从RegistryData查找资源
       let resourceData = this.registryManager.registryData.findResourceById(rolePath, 'role')
-      
+
       if (!resourceData) {
         // 如果没找到，尝试其他格式
         resourceData = this.registryManager.registryData.findResourceById(fullResourceId)
       }
-      
+
       if (!resourceData) {
         const availableRoles = this.registryManager.registryData.getResourcesByProtocol('role')
           .map(r => r.id).join(', ')
@@ -72,7 +81,7 @@ class RoleProtocol extends ResourceProtocol {
 
       // 通过ResourceManager加载实际内容
       const result = await this.registryManager.loadResourceByProtocol(resourceData.reference)
-      
+
       return result
     } catch (error) {
       throw new Error(`RoleProtocol.resolve failed: ${error.message}`)
diff --git a/packages/core/src/rolex/RolexActionDispatcher.js b/packages/core/src/rolex/RolexActionDispatcher.js
index 1de74b37..3e472f28 100644
--- a/packages/core/src/rolex/RolexActionDispatcher.js
+++ b/packages/core/src/rolex/RolexActionDispatcher.js
@@ -42,8 +42,11 @@ class RolexActionDispatcher {
         return this._abandon(args)
       case 'focus':
         return this._focus(args)
+      case 'synthesize':
+        return this._synthesize(args)
       case 'growup':
-        return this._growup(args)
+        // 向后兼容：growup 已重命名为 synthesize
+        return this._synthesize(args)
       case 'found':
         return this._found(args)
       case 'establish':
@@ -58,6 +61,38 @@ class RolexActionDispatcher {
         return this._dismiss(args)
       case 'directory':
         return this._directory(args)
+      // 新增：学习循环操作
+      case 'reflect':
+        return this._reflect(args)
+      case 'realize':
+        return this._realize(args)
+      case 'master':
+        return this._master(args)
+      case 'forget':
+        return this._forget(args)
+      case 'skill':
+        return this._skill(args)
+      // 新增：个体生命周期
+      case 'retire':
+        return this._retire(args)
+      case 'die':
+        return this._die(args)
+      case 'rehire':
+        return this._rehire(args)
+      case 'train':
+        return this._train(args)
+      // 新增：组织管理
+      case 'charter':
+        return this._charter(args)
+      case 'dissolve':
+        return this._dissolve(args)
+      // 新增：职位管理
+      case 'charge':
+        return this._charge(args)
+      case 'require':
+        return this._require(args)
+      case 'abolish':
+        return this._abolish(args)
       default:
         throw new Error(`Unknown RoleX operation: ${operation}`)
     }
@@ -111,9 +146,14 @@ class RolexActionDispatcher {
     return this.bridge.focus(args.name)
   }
 
+  async _synthesize (args) {
+    if (!args.name) throw new Error('name is required for synthesize operation')
+    return this.bridge.synthesize(args.name, args.source, args.type, args.role)
+  }
+
+  // 向后兼容：保留 _growup 方法
   async _growup (args) {
-    if (!args.name) throw new Error('name is required for growup operation')
-    return this.bridge.growup(args.name, args.source, args.type, args.role)
+    return this._synthesize(args)
   }
 
   async _found (args) {
@@ -157,6 +197,88 @@ class RolexActionDispatcher {
     return this.bridge.directory()
   }
 
+  // ---- 学习循环操作 ----
+
+  async _reflect (args) {
+    if (!args.encounters) throw new Error('encounters is required for reflect')
+    return this.bridge.reflect(args.encounters, args.experience, args.id)
+  }
+
+  async _realize (args) {
+    if (!args.experiences) throw new Error('experiences is required for realize')
+    return this.bridge.realize(args.experiences, args.principle, args.id)
+  }
+
+  async _master (args) {
+    if (!args.procedure) throw new Error('procedure is required for master')
+    return this.bridge.master(args.procedure, args.id, args.experiences)
+  }
+
+  async _forget (args) {
+    if (!args.nodeId) throw new Error('nodeId is required for forget')
+    return this.bridge.forget(args.nodeId)
+  }
+
+  async _skill (args) {
+    if (!args.locator) throw new Error('locator is required for skill')
+    return this.bridge.skill(args.locator)
+  }
+
+  // ---- 个体生命周期 ----
+
+  async _retire (args) {
+    if (!args.individual) throw new Error('individual is required for retire')
+    return this.bridge.retire(args.individual)
+  }
+
+  async _die (args) {
+    if (!args.individual) throw new Error('individual is required for die')
+    return this.bridge.die(args.individual)
+  }
+
+  async _rehire (args) {
+    if (!args.individual) throw new Error('individual is required for rehire')
+    return this.bridge.rehire(args.individual)
+  }
+
+  async _train (args) {
+    if (!args.individual) throw new Error('individual is required for train')
+    if (!args.skillId) throw new Error('skillId is required for train')
+    return this.bridge.train(args.individual, args.skillId, args.content)
+  }
+
+  // ---- 组织管理 ----
+
+  async _charter (args) {
+    if (!args.org) throw new Error('org is required for charter')
+    if (!args.content) throw new Error('content is required for charter')
+    return this.bridge.charter(args.org, args.content)
+  }
+
+  async _dissolve (args) {
+    if (!args.org) throw new Error('org is required for dissolve')
+    return this.bridge.dissolve(args.org)
+  }
+
+  // ---- 职位管理 ----
+
+  async _charge (args) {
+    if (!args.position) throw new Error('position is required for charge')
+    if (!args.content) throw new Error('content is required for charge')
+    return this.bridge.charge(args.position, args.content)
+  }
+
+  async _require (args) {
+    if (!args.position) throw new Error('position is required for require')
+    if (!args.skill) throw new Error('skill is required for require')
+    return this.bridge.require(args.position, args.skill)
+  }
+
+  async _abolish (args) {
+    if (!args.position) throw new Error('position is required for abolish')
+    return this.bridge.abolish(args.position)
+  }
+
   /**
    * 检查指定角色是否为 V2 角色
    */
diff --git a/packages/core/src/rolex/RolexBridge.js b/packages/core/src/rolex/RolexBridge.js
index 88a10e9f..ccaeb253 100644
--- a/packages/core/src/rolex/RolexBridge.js
+++ b/packages/core/src/rolex/RolexBridge.js
@@ -51,8 +51,6 @@ class RolexBridge {
     this.initializing = null
     this.currentRoleName = null
     this.rolexRoot = path.join(os.homedir(), '.rolex')
-    this._renderFeature = null
-    this._renderFeatures = null
   }
 
   /**
@@ -72,46 +70,52 @@ class RolexBridge {
       logger.info('[RolexBridge] Initializing RoleX...')
       await fs.ensureDir(this.rolexRoot)
 
-      const { LocalPlatform } = await import('@rolexjs/local-platform')
-      const { Rolex, bootstrap, renderFeature, renderFeatures } = await import('rolexjs')
-
-      this._renderFeature = renderFeature
-      this._renderFeatures = renderFeatures
+      logger.info('[RolexBridge] Importing @rolexjs/local-platform...')
+      const { localPlatform } = await import('@rolexjs/local-platform')
+      logger.info('[RolexBridge] Importing rolexjs...')
+      const { Rolex } = await import('rolexjs')
 
       // 版本检测：rolexjs 更新时强制重建 SEED 角色（在创建 platform 之前）
+      logger.info('[RolexBridge] Syncing SEED roles...')
       await this._syncSeedRoles()
 
       // 创建 platform（在 SEED 同步之后，确保读到最新的文件状态）
-      this.platform = new LocalPlatform(this.rolexRoot)
-      this.rolex = new Rolex(this.platform)
-
-      // Bootstrap: 确保种子角色存在
-      bootstrap(this.platform)
+      // RoleX 1.1.0: localPlatform 是工厂函数，不是构造函数
+      logger.info('[RolexBridge] Creating platform...')
+      this.platform = localPlatform({
+        dataDir: this.rolexRoot,
+        bootstrap: ['npm:@rolexjs/genesis']  // 注册 Genesis 原型
+      })
+      logger.info('[RolexBridge] Creating Rolex instance...')
+      // RoleX 1.1.0: 使用 Rolex.create() 而不是 new Rolex()
+      this.rolex = await Rolex.create(this.platform)
+
+      // RoleX 1.1.0: 调用 genesis() 初始化世界（首次运行时创建基础结构）
+      logger.info('[RolexBridge] Running genesis...')
+      await this.rolex.genesis()
 
       this.initialized = true
       logger.info('[RolexBridge] RoleX initialized successfully')
     } catch (error) {
-      logger.warn('[RolexBridge] RoleX initialization failed:', error.message)
+      logger.error('[RolexBridge] RoleX initialization failed:', error)
       throw error
     }
   }
 
   /**
-   * 同步 SEED 角色 - 当 rolexjs 版本变化时删除旧的 SEED 角色
-   * bootstrap 会在之后重建它们
+   * 同步 SEED 角色版本标记
+   * RoleX 1.1.0: 不再自动管理 SEED 角色，只记录版本
    */
   async _syncSeedRoles () {
-    const SEED_ROLES = RolexBridge.SEED_ROLES
     const versionFile = path.join(this.rolexRoot, '.seed-version')
 
-    // 读取 rolexjs 当前版本（通过文件路径，避免 ESM exports 限制）
+    // 读取 rolexjs 当前版本
     let currentVersion = 'unknown'
     try {
       const rolexjsDir = path.dirname(require.resolve('rolexjs'))
       const pkg = await fs.readJson(path.join(rolexjsDir, '..', 'package.json'))
       currentVersion = pkg.version
     } catch {
-      // fallback: 无法读取版本，每次都重建
       currentVersion = Date.now().toString()
     }
 
@@ -120,36 +124,12 @@ class RolexBridge {
     try {
       savedVersion = (await fs.readFile(versionFile, 'utf-8')).trim()
     } catch {
-      // 无版本文件 = 首次运行或旧安装
+      // 无版本文件 = 首次运行
     }
 
     if (savedVersion !== currentVersion) {
-      logger.info(`[RolexBridge] SEED version changed (${savedVersion || 'none'} → ${currentVersion}), resyncing built-in roles...`)
-      for (const name of SEED_ROLES) {
-        const roleDir = path.join(this.rolexRoot, 'roles', name)
-        if (await fs.pathExists(roleDir)) {
-          await fs.remove(roleDir)
-          logger.info(`[RolexBridge] Removed outdated SEED role: ${name}`)
-        }
-      }
-
-      // 同时从 rolex.json 注册表中移除 SEED 角色，否则 bootstrap 会跳过重建
-      const registryFile = path.join(this.rolexRoot, 'rolex.json')
-      try {
-        if (await fs.pathExists(registryFile)) {
-          const registry = await fs.readJson(registryFile)
-          if (Array.isArray(registry.roles)) {
-            registry.roles = registry.roles.filter(r => !SEED_ROLES.includes(r))
-            await fs.writeJson(registryFile, registry, { spaces: 2 })
-            logger.info('[RolexBridge] Removed SEED roles from rolex.json registry')
-          }
-        }
-      } catch (e) {
-        logger.warn('[RolexBridge] Failed to clean rolex.json registry:', e.message)
-      }
-
+      logger.info(`[RolexBridge] RoleX version: ${savedVersion || 'none'} → ${currentVersion}`)
       await fs.writeFile(versionFile, currentVersion)
-      logger.info('[RolexBridge] SEED roles cleared, bootstrap will recreate them')
     }
   }
 
@@ -157,192 +137,468 @@ class RolexBridge {
    * 检查指定角色是否为 V2 角色
    * 通过检查 ~/.promptx/rolex/roles/<roleId>/identity/persona.identity.feature 是否存在
    */
+  /**
+   * 检查角色是否为 V2 角色
+   * RoleX 1.1.0: 查询数据库而不是文件系统
+   */
   async isV2Role (roleId) {
     if (process.env.PROMPTX_ENABLE_V2 === '0') return false
-    await this.ensureInitialized()
-    const featurePath = path.join(
-      this.rolexRoot, 'roles', roleId, 'identity', 'persona.identity.feature'
-    )
-    return fs.pathExists(featurePath)
+    try {
+      await this.ensureInitialized()
+      // 使用 census.list 查询数据库中是否存在该角色
+      const censusResult = await this.rolex.direct('!census.list', { type: 'individual' })
+      if (typeof censusResult === 'string' && censusResult) {
+        const lines = censusResult.split('\n').filter(l => l.trim())
+        for (const line of lines) {
+          const match = line.match(/^([^\s(#]+)/)
+          if (match && match[1] === roleId) {
+            return true
+          }
+        }
+      }
+      return false
+    } catch (error) {
+      logger.warn('[RolexBridge] isV2Role check failed:', error)
+      return false
+    }
   }
 
   /**
-   * 激活 V2 角色 - 返回渲染后的 Gherkin 文本
+   * 激活 V2 角色 - 返回渲染后的状态文本
+   * RoleX 1.1.0: 使用 rolex.activate(roleId) 返回 Role 实例
    */
   async activate (roleId) {
     await this.ensureInitialized()
-    const features = this.rolex.role(roleId).identity()
+    const role = await this.rolex.activate(roleId)
     this.currentRoleName = roleId
-    return this._renderFeatures(features)
+    return role.project()
   }
 
   /**
    * 创建新角色 (born)
+   * RoleX 1.1.0: 使用 rolex.direct('!individual.born', ...)
    */
   async born (name, source) {
     await this.ensureInitialized()
-    const feature = this.rolex.born(name, source)
-    return this._renderFeature(feature)
+    await this.rolex.direct('!individual.born', { id: name, content: source })
+    return `Individual "${name}" born.`
   }
 
   /**
    * 查看角色身份信息
+   * RoleX 1.1.0: 使用 rolex.activate() + role.project()
    */
   async identity (roleId) {
     await this.ensureInitialized()
-    const features = this.rolex.role(roleId || this.currentRoleName).identity()
-    return this._renderFeatures(features)
+    const targetId = roleId || this.currentRoleName
+    if (!targetId) throw new Error('No role specified')
+    const role = await this.rolex.activate(targetId)
+    return role.project()
   }
 
   /**
    * 创建目标 (want)
+   * RoleX 1.1.0: role.want(goal, id)
    */
   async want (name, source, options = {}) {
     await this.ensureInitialized()
-    const role = this._requireActiveRole()
-    return this.rolex.role(role).want(name, source, options.testable)
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.want(source, name)
   }
 
   /**
    * 制定计划 (plan)
+   * RoleX 1.1.0: role.plan(plan)
    */
   async plan (source) {
     await this.ensureInitialized()
-    const role = this._requireActiveRole()
-    return this.rolex.role(role).plan(source)
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.plan(source)
   }
 
   /**
    * 创建任务 (todo)
+   * RoleX 1.1.0: role.todo(task, id)
    */
   async todo (name, source, options = {}) {
     await this.ensureInitialized()
-    const role = this._requireActiveRole()
-    return this.rolex.role(role).todo(name, source, options.testable)
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.todo(source, name)
   }
 
   /**
    * 完成任务 (finish)
+   * RoleX 1.1.0: role.finish(task)
    */
   async finish (name) {
     await this.ensureInitialized()
-    const role = this._requireActiveRole()
-    this.rolex.role(role).finish(name)
-    return `Task "${name}" finished.`
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.finish(name)
   }
 
   /**
-   * 达成目标 (achieve)
+   * 达成目标/完成计划 (achieve → complete)
+   * RoleX 1.1.0: role.complete()
    */
   async achieve (experience) {
     await this.ensureInitialized()
-    const role = this._requireActiveRole()
-    this.rolex.role(role).achieve(experience)
-    return 'Goal achieved.'
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.complete(undefined, experience)
   }
 
   /**
-   * 放弃目标 (abandon)
+   * 放弃目标/计划 (abandon)
+   * RoleX 1.1.0: role.abandon()
    */
   async abandon (experience) {
     await this.ensureInitialized()
-    const role = this._requireActiveRole()
-    this.rolex.role(role).abandon(experience)
-    return 'Goal abandoned.'
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.abandon(undefined, experience)
   }
 
   /**
    * 聚焦查看 (focus)
+   * RoleX 1.1.0: role.focus(goal)
    */
   async focus (name) {
     await this.ensureInitialized()
-    const role = this._requireActiveRole()
-    return this.rolex.role(role).focus(name)
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.focus(name)
   }
 
   /**
-   * 成长 (growup) - 映射到 rolex.teach()
+   * 综合 (synthesize) - 向角色注入知识
+   * RoleX 1.1.0: 使用 rolex.direct('!individual.teach', ...)
    * @param {string} name - 知识名称
    * @param {string} source - Gherkin 源码
    * @param {string} type - 类型 (knowledge/experience/voice)
    * @param {string} [targetRole] - 目标角色，如果不指定则使用当前激活角色
    */
-  async growup (name, source, type, targetRole) {
+  async synthesize (name, source, type, targetRole) {
     await this.ensureInitialized()
     const role = targetRole || this._requireActiveRole()
-    const feature = this.rolex.teach(role, type, name, source)
-    return this._renderFeature(feature)
+    await this.rolex.direct('!individual.teach', { individual: role, id: name, content: source })
+    return `Knowledge "${name}" synthesized for "${role}".`
+  }
+
+  /**
+   * @deprecated 使用 synthesize() 替代。growup 已重命名为 synthesize 以符合康德认识论语义
+   */
+  async growup (name, source, type, targetRole) {
+    return this.synthesize(name, source, type, targetRole)
   }
 
   /**
    * 创建组织 (found)
+   * RoleX 1.1.0: rolex.direct('!org.found', ...)
    */
   async found (name, source, parent) {
     await this.ensureInitialized()
-    this.rolex.found(name, source, parent)
+    await this.rolex.direct('!org.found', { id: name, content: source })
     return `Organization "${name}" founded.`
   }
 
   /**
    * 创建职位 (establish)
+   * RoleX 1.1.0: rolex.direct('!position.establish', ...)
    */
   async establish (positionName, source, orgName) {
     await this.ensureInitialized()
-    this.rolex.establish(positionName, source, orgName)
+    await this.rolex.direct('!position.establish', { id: positionName, content: source })
     return `Position "${positionName}" established in "${orgName}".`
   }
 
   /**
    * 雇佣角色到组织 (hire)
+   * RoleX 1.1.0: rolex.direct('!org.hire', ...)
    */
   async hire (roleName, orgName) {
     await this.ensureInitialized()
-    const { Organization } = await import('rolexjs')
-    const org = new Organization(this.platform, orgName)
-    org.hire(roleName)
+    await this.rolex.direct('!org.hire', { org: orgName, individual: roleName })
     return `Role "${roleName}" hired into "${orgName}".`
   }
 
   /**
    * 解雇角色 (fire)
+   * RoleX 1.1.0: rolex.direct('!org.fire', ...)
    */
   async fire (roleName, orgName) {
     await this.ensureInitialized()
-    const { Organization } = await import('rolexjs')
-    const org = new Organization(this.platform, orgName)
-    org.fire(roleName)
+    await this.rolex.direct('!org.fire', { org: orgName, individual: roleName })
     return `Role "${roleName}" fired from "${orgName}".`
   }
 
   /**
    * 任命角色到职位 (appoint)
+   * RoleX 1.1.0: rolex.direct('!position.appoint', ...)
    */
   async appoint (roleName, positionName, orgName) {
     await this.ensureInitialized()
-    const { Organization } = await import('rolexjs')
-    const org = new Organization(this.platform, orgName)
-    org.appoint(roleName, positionName)
+    await this.rolex.direct('!position.appoint', { position: positionName, individual: roleName })
     return `Role "${roleName}" appointed to "${positionName}".`
   }
 
   /**
    * 免职 (dismiss)
+   * RoleX 1.1.0: rolex.direct('!position.dismiss', ...)
    */
   async dismiss (roleName, orgName) {
     await this.ensureInitialized()
-    const { Organization } = await import('rolexjs')
-    const org = new Organization(this.platform, orgName)
-    org.dismiss(roleName)
+    await this.rolex.direct('!position.dismiss', { position: orgName, individual: roleName })
     return `Role "${roleName}" dismissed.`
   }
 
   /**
    * 社会目录 (directory)
+   * RoleX 1.1.0: 使用 census.list 返回所有实体列表（字符串格式）
+   * 返回结构化的 JSON 数据
    */
   async directory () {
     await this.ensureInitialized()
-    const dir = this.rolex.directory()
-    return JSON.stringify(dir, null, 2)
+    const textOutput = await this.rolex.direct('!census.list')
+
+    // 解析文本输出为结构化数据
+    return this._parseCensusOutput(textOutput)
+  }
+
+  /**
+   * 解析 census.list 的文本输出
+   * @private
+   */
+  _parseCensusOutput (text) {
+    const result = {
+      roles: [],
+      organizations: []
+    }
+
+    if (!text || typeof text !== 'string') {
+      return result
+    }
+
+    const lines = text.split('\n').filter(l => l.trim() && !l.includes('---') && !l.includes('📅') && !l.includes('📊') && !l.includes('Powered by'))
+
+    let currentOrg = null
+
+    for (const line of lines) {
+      const trimmed = line.trim()
+
+      // 跳过空行
+      if (!trimmed) continue
+
+      // 检测组织行（没有缩进，可能包含括号）
+      if (!line.startsWith(' ')) {
+        // 这是一个组织名称
+        currentOrg = trimmed
+        if (!result.organizations.find(o => o.name === currentOrg)) {
+          result.organizations.push({
+            name: currentOrg,
+            members: [],
+            positions: []
+          })
+        }
+      }
+      // 检测缩进行（角色或职位）
+      else if (line.startsWith('  ') && currentOrg) {
+        const match = trimmed.match(/^([^\s—]+)(?:\s*\([^)]+\))?\s*—\s*(.+)$/)
+        if (match) {
+          const name = match[1].trim()
+          const description = match[2].trim()
+
+          // 判断是角色还是职位
+          // 如果描述包含多个逗号分隔的职位，或者包含 "manager" 等关键词，则是角色
+          // 否则是职位定义
+          const isRole = description.includes(',') ||
+                        description.includes('manager') ||
+                        description.includes('individual') ||
+                        description.includes('organization') ||
+                        description.includes('position')
+
+          if (isRole) {
+            // 这是一个角色
+            const positions = description.split(',').map(p => p.trim())
+
+            // 添加到 roles 列表
+            result.roles.push({
+              name: name,
+              org: currentOrg,
+              position: positions[0]
+            })
+
+            // 添加到组织的成员列表
+            const org = result.organizations.find(o => o.name === currentOrg)
+            if (org) {
+              org.members.push({
+                name: name,
+                position: positions[0]
+              })
+            }
+          } else {
+            // 这是一个职位定义
+            const org = result.organizations.find(o => o.name === currentOrg)
+            if (org) {
+              org.positions.push({
+                name: name,
+                description: description
+              })
+            }
+          }
+        }
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * 反思经历 (reflect)
+   * RoleX 1.1.0: role.reflect(encounters, experience)
+   */
+  async reflect (encounters, experience, id) {
+    await this.ensureInitialized()
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.reflect(encounters, experience, id)
+  }
+
+  /**
+   * 掌握原则 (realize)
+   * RoleX 1.1.0: role.realize(experiences, principle)
+   */
+  async realize (experiences, principle, id) {
+    await this.ensureInitialized()
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.realize(experiences, principle, id)
+  }
+
+  /**
+   * 掌握程序/技能 (master)
+   * RoleX 1.1.0: role.master(procedure, id, experiences)
+   */
+  async master (procedure, id, experiences) {
+    await this.ensureInitialized()
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.master(procedure, id, experiences)
+  }
+
+  /**
+   * 遗忘知识 (forget)
+   * RoleX 1.1.0: role.forget(nodeId)
+   */
+  async forget (nodeId) {
+    await this.ensureInitialized()
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.forget(nodeId)
+  }
+
+  /**
+   * 加载技能 (skill)
+   * RoleX 1.1.0: role.skill(locator)
+   */
+  async skill (locator) {
+    await this.ensureInitialized()
+    const roleId = this._requireActiveRole()
+    const role = await this.rolex.activate(roleId)
+    return role.skill(locator)
+  }
+
+  /**
+   * 退休个体 (retire)
+   * RoleX 1.1.0: rolex.direct('!individual.retire', ...)
+   */
+  async retire (individualId) {
+    await this.ensureInitialized()
+    await this.rolex.direct('!individual.retire', { individual: individualId })
+    return `Individual "${individualId}" retired.`
+  }
+
+  /**
+   * 删除个体 (die)
+   * RoleX 1.1.0: rolex.direct('!individual.die', ...)
+   */
+  async die (individualId) {
+    await this.ensureInitialized()
+    await this.rolex.direct('!individual.die', { individual: individualId })
+    return `Individual "${individualId}" deleted.`
+  }
+
+  /**
+   * 恢复个体 (rehire)
+   * RoleX 1.1.0: rolex.direct('!individual.rehire', ...)
+   */
+  async rehire (individualId) {
+    await this.ensureInitialized()
+    await this.rolex.direct('!individual.rehire', { individual: individualId })
+    return `Individual "${individualId}" rehired.`
+  }
+
+  /**
+   * 注入技能 (train)
+   * RoleX 1.1.0: rolex.direct('!individual.train', ...)
+   */
+  async train (individualId, skillId, content) {
+    await this.ensureInitialized()
+    await this.rolex.direct('!individual.train', { individual: individualId, id: skillId, content })
+    return `Skill "${skillId}" trained for "${individualId}".`
+  }
+
+  /**
+   * 定义组织章程 (charter)
+   * RoleX 1.1.0: rolex.direct('!org.charter', ...)
+   */
+  async charter (orgName, content) {
+    await this.ensureInitialized()
+    await this.rolex.direct('!org.charter', { org: orgName, content })
+    return `Charter defined for organization "${orgName}".`
+  }
+
+  /**
+   * 解散组织 (dissolve)
+   * RoleX 1.1.0: rolex.direct('!org.dissolve', ...)
+   */
+  async dissolve (orgName) {
+    await this.ensureInitialized()
+    await this.rolex.direct('!org.dissolve', { org: orgName })
+    return `Organization "${orgName}" dissolved.`
+  }
+
+  /**
+   * 赋予职位职责 (charge)
+   * RoleX 1.1.0: rolex.direct('!position.charge', ...)
+   */
+  async charge (positionName, content) {
+    await this.ensureInitialized()
+    await this.rolex.direct('!position.charge', { position: positionName, content })
+    return `Responsibilities charged to position "${positionName}".`
+  }
+
+  /**
+   * 声明职位技能要求 (require)
+   * RoleX 1.1.0: rolex.direct('!position.require', ...)
+   */
+  async require (positionName, skillId) {
+    await this.ensureInitialized()
+    await this.rolex.direct('!position.require', { position: positionName, skill: skillId })
+    return `Skill "${skillId}" required for position "${positionName}".`
+  }
+
+  /**
+   * 废除职位 (abolish)
+   * RoleX 1.1.0: rolex.direct('!position.abolish', ...)
+   */
+  async abolish (positionName) {
+    await this.ensureInitialized()
+    await this.rolex.direct('!position.abolish', { position: positionName })
+    return `Position "${positionName}" abolished.`
   }
 
   /**
@@ -352,39 +608,47 @@ class RolexBridge {
     if (process.env.PROMPTX_ENABLE_V2 === '0') return []
     try {
       await this.ensureInitialized()
-      const rolesDir = path.join(this.rolexRoot, 'roles')
-      if (!await fs.pathExists(rolesDir)) return []
-      const entries = await fs.readdir(rolesDir, { withFileTypes: true })
+
+      // RoleX 1.1.0: census.list 返回渲染后的字符串，不是数组
+      // 使用 type='individual' 参数获取纯文本个体列表
       const roles = []
 
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue
-        const featurePath = path.join(
-          rolesDir, entry.name, 'identity', 'persona.identity.feature'
-        )
-        if (await fs.pathExists(featurePath)) {
-          const isSeed = RolexBridge.SEED_ROLES.includes(entry.name)
-          let description = ''
-          let featureName = ''
-          try {
-            const content = await fs.readFile(featurePath, 'utf-8')
-            featureName = extractFeatureName(content)
-            description = extractFeatureDescription(content)
-          } catch { /* ignore */ }
-          roles.push({
-            id: entry.name,
-            name: featureName || entry.name,
-            description,
-            source: isSeed ? 'system' : 'rolex',
-            version: 'v2',
-            protocol: 'role'
-          })
+      try {
+        const censusResult = await this.rolex.direct('!census.list', { type: 'individual' })
+        logger.info('[RolexBridge] Census individual result:', censusResult)
+
+        if (typeof censusResult === 'string' && censusResult && !censusResult.startsWith('No ')) {
+          // 格式: "id (alias1, alias2) #tag" 或仅 "id"，每行一个
+          const lines = censusResult.split('\n').filter(l => l.trim())
+          for (const line of lines) {
+            // 提取 ID：第一个空格、'(' 或 '#' 之前的内容
+            const match = line.match(/^([^\s(#]+)/)
+            if (match) {
+              const id = match[1].trim()
+              if (id) {
+                const isSeed = RolexBridge.SEED_ROLES.includes(id)
+                roles.push({
+                  id,
+                  name: id,
+                  description: '',
+                  source: isSeed ? 'system' : 'rolex',
+                  version: 'v2',
+                  protocol: 'role'
+                })
+              }
+            }
+          }
+        } else {
+          logger.info('[RolexBridge] Census returned empty or no individuals:', censusResult)
         }
+      } catch (censusError) {
+        logger.warn('[RolexBridge] Census query failed:', censusError)
       }
 
+      logger.info(`[RolexBridge] Found ${roles.length} V2 roles from database`)
       return roles
     } catch (error) {
-      logger.warn('[RolexBridge] Failed to list V2 roles:', error.message)
+      logger.error('[RolexBridge] Failed to list V2 roles:', error)
       return []
     }
   }
diff --git a/packages/core/tsup.config.js b/packages/core/tsup.config.js
index 739330ba..0e7a65f1 100644
--- a/packages/core/tsup.config.js
+++ b/packages/core/tsup.config.js
@@ -36,6 +36,9 @@ export default defineConfig({
     '@rolexjs/core',
     '@rolexjs/local-platform',
     '@rolexjs/parser',
+    '@rolexjs/prototype',
+    '@rolexjs/system',
+    'resourcexjs',
     // ... 其他外部依赖
   ],
   noExternal: [], // 不强制打包任何模块
diff --git a/packages/mcp-server/src/tools/action.ts b/packages/mcp-server/src/tools/action.ts
index 5fd0494e..40fb8d31 100644
--- a/packages/mcp-server/src/tools/action.ts
+++ b/packages/mcp-server/src/tools/action.ts
@@ -4,7 +4,7 @@ import { MCPOutputAdapter } from '~/utils/MCPOutputAdapter.js';
 const outputAdapter = new MCPOutputAdapter();
 
 const V2_DESCRIPTION_SECTION = `
-**V2 Roles (RoleX)**: Full lifecycle management (born → want → plan → todo → growup).
+**V2 Roles (RoleX)**: Full lifecycle management (born → want → plan → todo → synthesize).
 
 On activate, version is auto-detected: V2 takes priority, falls back to V1 if not found.
 Use \`version\` parameter to force a specific version: \`"v1"\` for DPML, \`"v2"\` for RoleX.`;
@@ -32,13 +32,22 @@ const V2_EXAMPLES = `
 
 **V2 finish task / achieve goal:**
 \`\`\`json
-{ "operation": "finish", "role": "_" }
+{ "operation": "finish", "role": "_", "name": "task-id" }
 { "operation": "achieve", "role": "_", "experience": "learned..." }
 \`\`\`
 
-**V2 growup (teach knowledge to a role):**
+**V2 learning cycle (reflect → realize → master):**
 \`\`\`json
-{ "operation": "growup", "role": "target-role", "name": "domain-knowledge", "source": "Feature: ...", "type": "knowledge" }
+{ "operation": "reflect", "role": "_", "encounters": ["enc1", "enc2"], "experience": "Feature: ..." }
+{ "operation": "realize", "role": "_", "experiences": ["exp1"], "principle": "Feature: ..." }
+{ "operation": "master", "role": "_", "procedure": "Feature: ...", "id": "skill-id" }
+{ "operation": "forget", "role": "_", "nodeId": "knowledge-id" }
+{ "operation": "skill", "role": "_", "locator": "npm:@scope/package" }
+\`\`\`
+
+**V2 synthesize (teach knowledge to a role):**
+\`\`\`json
+{ "operation": "synthesize", "role": "target-role", "name": "domain-knowledge", "source": "Feature: ...", "type": "knowledge" }
 \`\`\`
 
 **Organization: view directory:**
@@ -56,6 +65,23 @@ const V2_EXAMPLES = `
 \`\`\`json
 { "operation": "establish", "role": "_", "name": "lead", "source": "Feature: ...", "org": "my-team" }
 { "operation": "appoint", "role": "_", "name": "my-dev", "position": "lead", "org": "my-team" }
+{ "operation": "charge", "role": "_", "position": "lead", "content": "Feature: ..." }
+{ "operation": "require", "role": "_", "position": "lead", "skill": "leadership" }
+{ "operation": "abolish", "role": "_", "position": "lead" }
+\`\`\`
+
+**Individual lifecycle:**
+\`\`\`json
+{ "operation": "retire", "role": "_", "individual": "my-dev" }
+{ "operation": "rehire", "role": "_", "individual": "my-dev" }
+{ "operation": "die", "role": "_", "individual": "my-dev" }
+{ "operation": "train", "role": "_", "individual": "my-dev", "skillId": "coding", "content": "Feature: ..." }
+\`\`\`
+
+**Organization management:**
+\`\`\`json
+{ "operation": "charter", "role": "_", "org": "my-team", "content": "Feature: ..." }
+{ "operation": "dissolve", "role": "_", "org": "my-team" }
 \`\`\`
 `;
 
@@ -114,7 +140,18 @@ Use \`roleResources\` to load additional sections **before** you need them:
 - Act as the activated role, maintain its professional traits
 - Use \`discover\` first when a role is not found`;
 
-  const v2Operations = ['born', 'identity', 'want', 'plan', 'todo', 'finish', 'achieve', 'abandon', 'focus', 'growup', 'found', 'establish', 'hire', 'fire', 'appoint', 'dismiss', 'directory'];
+  const v2Operations = [
+    'born', 'identity', 'want', 'plan', 'todo', 'finish', 'achieve', 'abandon', 'focus', 'synthesize',
+    'found', 'establish', 'hire', 'fire', 'appoint', 'dismiss', 'directory',
+    // 学习循环
+    'reflect', 'realize', 'master', 'forget', 'skill',
+    // 个体生命周期
+    'retire', 'die', 'rehire', 'train',
+    // 组织管理
+    'charter', 'dissolve',
+    // 职位管理
+    'charge', 'require', 'abolish'
+  ];
   const operationEnum = enableV2
     ? ['activate', ...v2Operations]
     : ['activate'];
@@ -129,7 +166,7 @@ Use \`roleResources\` to load additional sections **before** you need them:
           type: 'string',
           enum: operationEnum,
           description: enableV2
-            ? 'Operation type. Default: activate. V2 lifecycle operations: born, identity, want, plan, todo, finish, achieve, abandon, focus, growup. Organization operations: found, establish, hire, fire, appoint, dismiss, directory'
+            ? 'Operation type. Default: activate. V2 lifecycle: born, identity, want, plan, todo, finish, achieve, abandon, focus, synthesize. Learning: reflect, realize, master, forget, skill. Organization: found, charter, dissolve, hire, fire. Position: establish, charge, require, appoint, dismiss, abolish. Individual: retire, die, rehire, train. Query: directory'
             : 'Operation type. Default: activate.'
         },
         role: {
@@ -144,15 +181,15 @@ Use \`roleResources\` to load additional sections **before** you need them:
         ...(enableV2 ? {
           name: {
             type: 'string',
-            description: 'Name parameter for born(role name), want(goal name), todo(task name), focus(focus item), growup(knowledge name), finish(task name)'
+            description: 'Name parameter for born(role name), want(goal name), todo(task name), focus(focus item), synthesize(knowledge name), finish(task name)'
           },
           source: {
             type: 'string',
-            description: 'Gherkin source text for born/want/todo/growup/plan/establish operations'
+            description: 'Gherkin source text for born/want/todo/synthesize/plan/establish operations'
           },
           type: {
             type: 'string',
-            description: 'Growup type: knowledge, experience, or voice. For growup operation, role parameter specifies the target role to teach.'
+            description: 'Synthesize type: knowledge, experience, or voice. For synthesize operation, role parameter specifies the target role to teach.'
           },
           experience: {
             type: 'string',
@@ -172,7 +209,53 @@ Use \`roleResources\` to load additional sections **before** you need them:
           },
           position: {
             type: 'string',
-            description: 'Position name for appoint'
+            description: 'Position name for appoint/charge/require/abolish'
+          },
+          encounters: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Array of encounter IDs for reflect operation'
+          },
+          experiences: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Array of experience IDs for realize operation'
+          },
+          principle: {
+            type: 'string',
+            description: 'Gherkin source for principle in realize operation'
+          },
+          procedure: {
+            type: 'string',
+            description: 'Gherkin source for procedure in master operation'
+          },
+          nodeId: {
+            type: 'string',
+            description: 'Node ID for forget operation'
+          },
+          locator: {
+            type: 'string',
+            description: 'Resource locator for skill operation (e.g., npm:@scope/package)'
+          },
+          individual: {
+            type: 'string',
+            description: 'Individual ID for retire/die/rehire/train operations'
+          },
+          skillId: {
+            type: 'string',
+            description: 'Skill ID for train/require operations'
+          },
+          content: {
+            type: 'string',
+            description: 'Content for train/charter/charge operations'
+          },
+          id: {
+            type: 'string',
+            description: 'Optional ID for reflect/realize/master operations'
+          },
+          skill: {
+            type: 'string',
+            description: 'Skill name for require operation'
           },
           version: {
             type: 'string',
diff --git a/packages/mcp-server/src/tools/recall.ts b/packages/mcp-server/src/tools/recall.ts
index c0a1982f..1e526a5c 100644
--- a/packages/mcp-server/src/tools/recall.ts
+++ b/packages/mcp-server/src/tools/recall.ts
@@ -83,6 +83,22 @@ Step 3: Answer using recalled context
   handler: async (args: { role: string; query?: string | null; mode?: string }) => {
     const core = await import('@promptx/core');
     const coreExports = core.default || core;
+
+    // 检查是否为 v2 角色
+    try {
+      const { RolexActionDispatcher } = (coreExports as any).rolex;
+      const dispatcher = new RolexActionDispatcher();
+      if (await dispatcher.isV2Role(args.role)) {
+        return outputAdapter.convertToMCPFormat({
+          type: 'error',
+          content: `❌ V2 角色 "${args.role}" 不支持 recall 功能\n\nV2 角色（RoleX）使用数据库存储，记忆管理功能正在开发中。\n当前 recall 工具仅支持 V1 角色（DPML 格式）。\n\n如需使用记忆功能，请使用 V1 角色。`
+        });
+      }
+    } catch (e) {
+      // 如果检查失败，继续执行（可能是 v1 角色）
+      console.warn('[recall] V2 role check failed, continuing:', e);
+    }
+
     const cli = (coreExports as any).cli || (coreExports as any).pouch?.cli;
 
     if (!cli || !cli.execute) {
diff --git a/packages/mcp-server/src/tools/remember.ts b/packages/mcp-server/src/tools/remember.ts
index bdb81149..4da697d5 100644
--- a/packages/mcp-server/src/tools/remember.ts
+++ b/packages/mcp-server/src/tools/remember.ts
@@ -121,12 +121,28 @@ Strip content to minimum essential words. For each word ask: does removing it ch
   handler: async (args: { role: string; engrams: string[] }) => {
     const core = await import('@promptx/core');
     const coreExports = core.default || core;
+
+    // 检查是否为 v2 角色
+    try {
+      const { RolexActionDispatcher } = (coreExports as any).rolex;
+      const dispatcher = new RolexActionDispatcher();
+      if (await dispatcher.isV2Role(args.role)) {
+        return outputAdapter.convertToMCPFormat({
+          type: 'error',
+          content: `❌ V2 角色 "${args.role}" 不支持 remember 功能\n\nV2 角色（RoleX）使用数据库存储，记忆管理功能正在开发中。\n当前 remember 工具仅支持 V1 角色（DPML 格式）。\n\n如需使用记忆功能，请使用 V1 角色。`
+        });
+      }
+    } catch (e) {
+      // 如果检查失败，继续执行（可能是 v1 角色）
+      console.warn('[remember] V2 role check failed, continuing:', e);
+    }
+
     const cli = (coreExports as any).cli || (coreExports as any).pouch?.cli;
-    
+
     if (!cli || !cli.execute) {
       throw new Error('CLI not available in @promptx/core');
     }
-    
+
     const result = await cli.execute('remember', [args]);
     return outputAdapter.convertToMCPFormat(result);
   }
diff --git a/packages/resource/resources/role/dayu/execution/migration-workflow.execution.md b/packages/resource/resources/role/dayu/execution/migration-workflow.execution.md
index e806ad97..3cc643de 100644
--- a/packages/resource/resources/role/dayu/execution/migration-workflow.execution.md
+++ b/packages/resource/resources/role/dayu/execution/migration-workflow.execution.md
@@ -16,11 +16,11 @@
 
     ### Step 3: 创建V2角色
     - born：用整合后的 persona 描述创建角色
-    - **activate**：born 后必须立即 activate 该角色（growup 依赖活跃角色）
-    - growup type=voice：迁移有独立价值的 thought
-    - growup type=knowledge：迁移专有知识
-    - growup type=experience：迁移关键执行经验
-    - ⚠️ 严格顺序：born → activate → growup，不可跳过 activate
+    - **activate**：born 后必须立即 activate 该角色（synthesize 依赖活跃角色）
+    - synthesize type=voice：迁移有独立价值的 thought
+    - synthesize type=knowledge：迁移专有知识
+    - synthesize type=experience：迁移关键执行经验
+    - ⚠️ 严格顺序：born → activate → synthesize，不可跳过 activate
 
     ### Step 4: 组织安排（可选）
     - 如果角色属于某个团队 → hire 到组织
@@ -29,11 +29,11 @@
     ### Step 5: 验证
     - identity 查看角色完整身份，确认所有 feature 已写入
     - 与 V1 原始内容对比，确认核心特质保留
-    - 如有缺失，补充 growup
+    - 如有缺失，补充 synthesize
   </process>
 
   <rule>
-    - born 之后必须 activate，然后才能 growup——这是最常见的错误
+    - born 之后必须 activate，然后才能 synthesize——这是最常见的错误
     - IF V1角色有大量thought THEN 整合为精炼的persona，不要逐个迁移
     - IF knowledge是通用知识 THEN 不迁移（AI已具备）
     - IF execution是标准流程 THEN 映射为duty；IF是领域知识 THEN 映射为knowledge
diff --git a/packages/resource/resources/role/dayu/knowledge/rolex-api.knowledge.md b/packages/resource/resources/role/dayu/knowledge/rolex-api.knowledge.md
index ebc7ccc6..83a55e2b 100644
--- a/packages/resource/resources/role/dayu/knowledge/rolex-api.knowledge.md
+++ b/packages/resource/resources/role/dayu/knowledge/rolex-api.knowledge.md
@@ -6,10 +6,10 @@
   |---|---|---|---|---|
   | born | name, source | - | 无 | 创建角色 |
   | activate | role | version | 无 | 激活角色（设为当前活跃角色） |
-  | growup | name, source, type | - | **必须先 activate** | 教授知识/经验/声音 |
+  | synthesize | name, source, type | - | **必须先 activate** | 教授知识/经验/声音 |
   | identity | - | role | 无 | 查看角色身份 |
 
-  > ⚠️ 关键：born 只创建角色，不会自动激活。growup 前必须 activate，否则报错 "No active V2 role"。
+  > ⚠️ 关键：born 只创建角色，不会自动激活。synthesize 前必须 activate，否则报错 "No active V2 role"。
 
   ### 组织操作
   | 操作 | 必需参数 | 可选参数 | 说明 |
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 250835c0..4d3e1249 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -15,6 +15,10 @@ overrides:
 importers:
 
   .:
+    dependencies:
+      '@rolexjs/genesis':
+        specifier: 1.3.0
+        version: 1.3.0
     devDependencies:
       '@changesets/changelog-github':
         specifier: ^0.5.1
@@ -283,14 +287,20 @@ importers:
         specifier: workspace:*
         version: link:../resource
       '@rolexjs/core':
-        specifier: ^0.11.0
-        version: 0.11.0
+        specifier: ^1.1.0
+        version: 1.1.0
       '@rolexjs/local-platform':
-        specifier: ^0.11.0
-        version: 0.11.0
+        specifier: ^1.1.0
+        version: 1.1.0(@types/better-sqlite3@7.6.13)(better-sqlite3@12.4.1)
       '@rolexjs/parser':
-        specifier: ^0.11.0
-        version: 0.11.0
+        specifier: ^1.1.0
+        version: 1.1.0
+      '@rolexjs/prototype':
+        specifier: ^1.1.0
+        version: 1.1.0
+      '@rolexjs/system':
+        specifier: ^1.1.0
+        version: 1.1.0
       ajv:
         specifier: ^8.17.1
         version: 8.17.1
@@ -324,9 +334,12 @@ importers:
       peggy:
         specifier: ^5.0.5
         version: 5.0.6
+      resourcexjs:
+        specifier: ^2.14.0
+        version: 2.18.0
       rolexjs:
-        specifier: ^0.11.0
-        version: 0.11.0
+        specifier: ^1.1.0
+        version: 1.1.0
     devDependencies:
       '@alicloud/openapi-client':
         specifier: ^0.4.15
@@ -345,7 +358,7 @@ importers:
     dependencies:
       '@modelcontextprotocol/sdk':
         specifier: ^1.26.0
-        version: 1.27.1(zod@3.25.76)
+        version: 1.27.1(zod@4.3.6)
       mammoth:
         specifier: ^1.8.0
         version: 1.11.0
@@ -410,7 +423,7 @@ importers:
     dependencies:
       '@modelcontextprotocol/server-filesystem':
         specifier: ^2026.1.14
-        version: 2026.1.14(zod@3.25.76)
+        version: 2026.1.14(zod@4.3.6)
       '@promptx/logger':
         specifier: workspace:*
         version: link:../logger
@@ -440,7 +453,7 @@ importers:
         version: 1.9.0
       '@anthropic-ai/claude-agent-sdk':
         specifier: ^0.1.76
-        version: 0.1.77(zod@3.25.76)
+        version: 0.1.77(zod@4.3.6)
       rxjs:
         specifier: ^7.8.2
         version: 7.8.2
@@ -512,6 +525,11 @@ packages:
     peerDependencies:
       zod: ^3.25.0 || ^4.0.0
 
+  '@anthropic-ai/sandbox-runtime@0.0.32':
+    resolution: {integrity: sha512-+mQDTTxBc72W2xpsRHamruom5Xdo8vswTRlKlEtlhMbYemQgqLdQpULHi33dalTkvbbHmwgugLfQ82IZUzqT4w==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
   '@babel/code-frame@7.27.1':
     resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==}
     engines: {node: '>=6.9.0'}
@@ -808,6 +826,14 @@ packages:
   '@date-fns/tz@1.4.1':
     resolution: {integrity: sha512-P5LUNhtbj6YfI3iJjw5EL9eUAG6OitD0W3fWQcpQjDRc/QIsL0tRNuO1PcDvPccWL1fSTXXdE1ds+l95DV/OFA==}
 
+  '@deepracticex/drizzle@0.2.3':
+    resolution: {integrity: sha512-zFyR4VhRjr4kfzhq6YWukUcj/XtJNJmNtnEEvTzeqPVSK1ZGd3Ywtr4GVf9rtVCtRa67j85tBykzN3LUwuy4SQ==}
+    peerDependencies:
+      drizzle-orm: '>=0.38.0'
+
+  '@deepracticex/sqlite@0.2.0':
+    resolution: {integrity: sha512-cBrJbqoN9Oxt2wXQomoxdQT76RL0Hn8yfGAKgyGzxi7vPHZC9UnxoJgfQpidqGGky+067FXRPBB7f0xzNkJ3bg==, tarball: https://registry.npmjs.org/@deepracticex/sqlite/-/sqlite-0.2.0.tgz}
+
   '@develar/schema-utils@2.6.5':
     resolution: {integrity: sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig==}
     engines: {node: '>= 8.9.0'}
@@ -2128,6 +2154,9 @@ packages:
   '@polka/url@1.0.0-next.29':
     resolution: {integrity: sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==}
 
+  '@pondwader/socks5-server@1.0.10':
+    resolution: {integrity: sha512-bQY06wzzR8D2+vVCUoBsr5QS2U6UgPUQRmErNwtsuI6vLcyRKkafjkr3KxbtGFf9aBBIV2mcvlsKD1UYaIV+sg==}
+
   '@radix-ui/number@1.1.1':
     resolution: {integrity: sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g==}
 
@@ -2545,15 +2574,41 @@ packages:
   '@radix-ui/rect@1.1.1':
     resolution: {integrity: sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==}
 
-  '@rolexjs/core@0.11.0':
-    resolution: {integrity: sha512-P/kBRgsP7tMKJzXVKG0L8ZrVSNpWwSy56Aa+cuxNYoPqe+57C1qzi8rQDOkQFqvTtwObtt9Epr0rvn/qKaWoKw==}
+  '@resourcexjs/arp@2.18.0':
+    resolution: {integrity: sha512-rcpdtBM46bwcjLeSoGp8vip6yfeuv6+4Fl99ltKe99LKSXxTxuDgMuhxfBT//ZJaCagIiVaioyqRwLozX5blAg==}
     engines: {node: '>=22.0.0'}
 
-  '@rolexjs/local-platform@0.11.0':
-    resolution: {integrity: sha512-t2KhkyWkfJVjSesCrwUzi4moN4m33rpjty4CbrReXeZilrfxnE1TSuHtdH4wkNPwYmZHzGlqSvIrg89KpN+D4A==}
+  '@resourcexjs/core@0.5.0':
+    resolution: {integrity: sha512-M3oUkRybg+CU46fx/9r6gnAcOvCRTEOdD7dmxnQ8/S5R0Qy3KgorrOC42SlYRP9lGMVix0xF0U3MdfJBRjpo7Q==}
+    engines: {node: '>=22.0.0'}
 
-  '@rolexjs/parser@0.11.0':
-    resolution: {integrity: sha512-w+S+Hx1HlFlkICXw5uqOC9vQsIjs0OvenoIRvRB8PO70m2Bwhw2WflrW8KB1KHbW0wFkxaNOluUAc/c1IOd0nw==}
+  '@resourcexjs/core@2.18.0':
+    resolution: {integrity: sha512-y/Pnp5+s+lmg3kXbo8h8menJvq511z6PIN8/uH/CQjw35BoEHJQpKPSlHcXQY3Npd6MyOPkKBJ4yGsRMxdOlcA==}
+    engines: {node: '>=22.0.0'}
+
+  '@resourcexjs/node-provider@2.18.0':
+    resolution: {integrity: sha512-8QZNl/YBNQHV7pecvvm6sj54ufgcAQ7U/moO3B6sZIoh3t+54voQtLULDWTLRehlxVITt6eIU6cm4vedVqNPSg==}
+
+  '@rolexjs/core@1.1.0':
+    resolution: {integrity: sha512-2JItPVWS24cNtAuXm1hG5m+yzFBv8jshlkkv4lWP9bryXLySfFcLSMqFprafShoFDqPV+2w8gkQowxoNcJop8w==}
+    engines: {node: '>=22.0.0'}
+
+  '@rolexjs/genesis@1.3.0':
+    resolution: {integrity: sha512-V5Dz6U5+8Z0H6DakBXbpV6OhQZGp2IWsSnwFcb3r7m7RNKJ7YJx0ppQJ9RmVhYtqRA/iHFcykpyEpwD+44Ttuw==}
+
+  '@rolexjs/local-platform@1.1.0':
+    resolution: {integrity: sha512-0JwgVNoL53sUVllg9S7N+hsrFkz4haTSeF02bOZ0FBFjvs3YTmUPZ8PJGolKfa4Jo/O3isRBQ124GSBkp7tdIA==}
+
+  '@rolexjs/parser@1.1.0':
+    resolution: {integrity: sha512-M3Ku6eie4ijZZFikPV4hvXu5wMlsu2eVIPjvMeBdP5LuWxUnibiavngyRbg0GaPK5KOSop6ZekxOs6Hb+28/9g==}
+    engines: {node: '>=22.0.0'}
+
+  '@rolexjs/prototype@1.1.0':
+    resolution: {integrity: sha512-wzv4qVS3MCfbe9R+VzSxDCy6xMyxs9BqET2jxBXi+vCfpX4q+FBYqzYgAIxvoSnDT+Wd9npItRKHatSKeG0+Nw==}
+    engines: {node: '>=22.0.0'}
+
+  '@rolexjs/system@1.1.0':
+    resolution: {integrity: sha512-LVhggnGMep7J8osyp3opUY7NwrABb8VOqXXXThzSIpdJ6nqqfynTByGUyaUsxLttMvo0BKapJKH/i93hI4rt8A==}
     engines: {node: '>=22.0.0'}
 
   '@rolldown/pluginutils@1.0.0-beta.43':
@@ -2680,6 +2735,18 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@sandboxxjs/cloudflare-isolator@0.5.1':
+    resolution: {integrity: sha512-0qc3+H77vzVI7wUmJPu9QFXpUsu9uDHXAmZNcPKNFzGvZqBatMN5FI3JaDXbB16sAZUZ6RxyfDjoVw1cdiY86w==}
+    hasBin: true
+
+  '@sandboxxjs/core@0.5.1':
+    resolution: {integrity: sha512-C4gj8OkOivomMUJllFYODvprqFxu3k3rAaZCjKVHR9uSXpKMJItDjH5Dv/2SgZQY3iRUgkFVdeCQde31Go/EQg==}
+    engines: {node: '>=22.0.0'}
+
+  '@sandboxxjs/state@0.5.1':
+    resolution: {integrity: sha512-kY95hh3BQyHZwN/cBV1wg1XN2LskD77yPXPYNaH2IY7M/aWNhf45Kp3c6FjKhN+UVUFteLRlnYihwWd4PO8dZg==}
+    engines: {node: '>=22.0.0'}
+
   '@sec-ant/readable-stream@0.4.1':
     resolution: {integrity: sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==}
 
@@ -2909,6 +2976,12 @@ packages:
   '@types/keyv@3.1.4':
     resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==}
 
+  '@types/lodash-es@4.17.12':
+    resolution: {integrity: sha512-0NgftHUcV4v34VhXm8QBSftKVXtbkBG3ViCjs6+eJ5a6y6Mi/jiFGPc1sC7QK+9BFhWrURE3EOggmWaSxL9OzQ==}
+
+  '@types/lodash@4.17.24':
+    resolution: {integrity: sha512-gIW7lQLZbue7lRSWEFql49QJJWThrTFFeIMJdp3eH4tKoxm1OvEPg02rm4wCCSHS0cL3/Fizimb35b7k8atwsQ==}
+
   '@types/mdast@4.0.4':
     resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==}
 
@@ -4052,6 +4125,98 @@ packages:
     resolution: {integrity: sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g==}
     engines: {node: '>=10'}
 
+  drizzle-orm@0.45.1:
+    resolution: {integrity: sha512-Te0FOdKIistGNPMq2jscdqngBRfBpC8uMFVwqjf6gtTVJHIQ/dosgV/CLBU2N4ZJBsXL5savCba9b0YJskKdcA==}
+    peerDependencies:
+      '@aws-sdk/client-rds-data': '>=3'
+      '@cloudflare/workers-types': '>=4'
+      '@electric-sql/pglite': '>=0.2.0'
+      '@libsql/client': '>=0.10.0'
+      '@libsql/client-wasm': '>=0.10.0'
+      '@neondatabase/serverless': '>=0.10.0'
+      '@op-engineering/op-sqlite': '>=2'
+      '@opentelemetry/api': ^1.4.1
+      '@planetscale/database': '>=1.13'
+      '@prisma/client': '*'
+      '@tidbcloud/serverless': '*'
+      '@types/better-sqlite3': '*'
+      '@types/pg': '*'
+      '@types/sql.js': '*'
+      '@upstash/redis': '>=1.34.7'
+      '@vercel/postgres': '>=0.8.0'
+      '@xata.io/client': '*'
+      better-sqlite3: '>=7'
+      bun-types: '*'
+      expo-sqlite: '>=14.0.0'
+      gel: '>=2'
+      knex: '*'
+      kysely: '*'
+      mysql2: '>=2'
+      pg: '>=8'
+      postgres: '>=3'
+      prisma: '*'
+      sql.js: '>=1'
+      sqlite3: '>=5'
+    peerDependenciesMeta:
+      '@aws-sdk/client-rds-data':
+        optional: true
+      '@cloudflare/workers-types':
+        optional: true
+      '@electric-sql/pglite':
+        optional: true
+      '@libsql/client':
+        optional: true
+      '@libsql/client-wasm':
+        optional: true
+      '@neondatabase/serverless':
+        optional: true
+      '@op-engineering/op-sqlite':
+        optional: true
+      '@opentelemetry/api':
+        optional: true
+      '@planetscale/database':
+        optional: true
+      '@prisma/client':
+        optional: true
+      '@tidbcloud/serverless':
+        optional: true
+      '@types/better-sqlite3':
+        optional: true
+      '@types/pg':
+        optional: true
+      '@types/sql.js':
+        optional: true
+      '@upstash/redis':
+        optional: true
+      '@vercel/postgres':
+        optional: true
+      '@xata.io/client':
+        optional: true
+      better-sqlite3:
+        optional: true
+      bun-types:
+        optional: true
+      expo-sqlite:
+        optional: true
+      gel:
+        optional: true
+      knex:
+        optional: true
+      kysely:
+        optional: true
+      mysql2:
+        optional: true
+      pg:
+        optional: true
+      postgres:
+        optional: true
+      prisma:
+        optional: true
+      sql.js:
+        optional: true
+      sqlite3:
+        optional: true
+
   duck@0.1.12:
     resolution: {integrity: sha512-wkctla1O6VfP89gQ+J/yDesM0S7B7XLXjKGzXxMDVFg7uEn706niAtyYovKbyq1oT9YwDcly721/iUWoc8MVRg==}
 
@@ -4333,6 +4498,10 @@ packages:
     resolution: {integrity: sha512-jpWzZ1ZhwUmeWRhS7Qv3mhpOhLfwI+uAX4e5fOcXqwMR7EcJ0pj2kV1CVzHVMX/LphnKWD3LObjZCoJ71lKpHw==}
     engines: {node: ^18.19.0 || >=20.5.0}
 
+  execa@9.6.1:
+    resolution: {integrity: sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==}
+    engines: {node: ^18.19.0 || >=20.5.0}
+
   exif-parser@0.1.12:
     resolution: {integrity: sha512-c2bQfLNbMzLPmzQuOr8fy0csy84WmwnER81W88DzTp9CYNPJ6yzOj2EZAh9pywYpqHnshVLHQJ8WzldAyfY+Iw==}
 
@@ -5401,6 +5570,9 @@ packages:
     resolution: {integrity: sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
 
+  lodash-es@4.17.23:
+    resolution: {integrity: sha512-kVI48u3PZr38HdYz98UmfPnXl2DXrpdctLrFLCd3kOx1xUkOmpFPx7gCWWM5MPkL/fD8zb+Ph0QzjGFs4+hHWg==}
+
   lodash.camelcase@4.3.0:
     resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==}
 
@@ -5833,6 +6005,10 @@ packages:
   mlly@1.8.0:
     resolution: {integrity: sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==}
 
+  modern-tar@0.7.5:
+    resolution: {integrity: sha512-YTefgdpKKFgoTDbEUqXqgUJct2OG6/4hs4XWLsxcHkDLj/x/V8WmKIRppPnXP5feQ7d1vuYWSp3qKkxfwaFaxA==}
+    engines: {node: '>=18.0.0'}
+
   motion-dom@12.34.1:
     resolution: {integrity: sha512-SC7ZC5dRcGwku2g7EsPvI4q/EzHumUbqsDNumBmZTLFg+goBO5LTJvDu9MAxx+0mtX4IA78B2be/A3aRjY0jnw==}
 
@@ -5865,6 +6041,11 @@ packages:
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
+  nanoid@5.1.6:
+    resolution: {integrity: sha512-c7+7RQ+dMB5dPwwCp4ee1/iV/q2P6aK1mTZcfr1BTuVlyW9hJYiMPybJCcnBlQtuSmTIWNeazm/zqNoZSSElBg==}
+    engines: {node: ^18 || >=20}
+    hasBin: true
+
   napi-build-utils@2.0.0:
     resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}
 
@@ -6752,6 +6933,14 @@ packages:
     engines: {node: '>= 0.4'}
     hasBin: true
 
+  resourcexjs@0.5.0:
+    resolution: {integrity: sha512-OwsGF0nkuwjhDGh6rjYQQYnZT2GlRLNSChJJ/bHoGaqurwBfa0JXl3L9unzGMVn1mhhxVhIyUlqTEhFozt2/2w==}
+    engines: {node: '>=22.0.0'}
+
+  resourcexjs@2.18.0:
+    resolution: {integrity: sha512-UYEyLoDVvxImopuOyIcZFa2obilOsHkS52Ey2fYKvuMHvl2JEa+zTZyJG2psyZ1HtixeDOD1SIXA2oZXMp09TA==}
+    engines: {node: '>=22.0.0'}
+
   responselike@2.0.1:
     resolution: {integrity: sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==}
 
@@ -6789,8 +6978,8 @@ packages:
     resolution: {integrity: sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==}
     engines: {node: '>=8.0'}
 
-  rolexjs@0.11.0:
-    resolution: {integrity: sha512-VTNshNYOX+fIleCZz6CB1akm+a4EaxYxLMhflvtJSNuOoVTq+WCXo5MKlWIsO8oHsrp39PMo4I7kjGxaMSuv5Q==}
+  rolexjs@1.1.0:
+    resolution: {integrity: sha512-L8UovTJDF8PoVCYpzsbaBCR+Nq2ww9M/oxWBrSP8lhx9tt0cP/clJEuUfDp6so+SbPVFaIVwB8U83x2NF/lXKw==}
     engines: {node: '>=22.0.0'}
 
   rollup@4.52.4:
@@ -6821,6 +7010,10 @@ packages:
   safer-buffer@2.1.2:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
 
+  sandboxxjs@0.5.1:
+    resolution: {integrity: sha512-cbfwBvwyO1GTLkZMY2G1AzeHU7NfUBZww37ENgibkMgfVX6Lqt4qidRsfhTRxDcVjMiXIe5VwmuvLhes99cHOg==}
+    engines: {node: '>=22.0.0'}
+
   sanitize-filename@1.6.3:
     resolution: {integrity: sha512-y/52Mcy7aw3gRm7IrcGDFx/bCk4AhRh2eI9luHOQM86nZsqwiRkkq2GekHXBBD+SmPidc8i2PqtYZl+pWJ8Oeg==}
 
@@ -6904,6 +7097,10 @@ packages:
     resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
     engines: {node: '>=8'}
 
+  shell-quote@1.8.3:
+    resolution: {integrity: sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==}
+    engines: {node: '>= 0.4'}
+
   side-channel-list@1.0.0:
     resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}
     engines: {node: '>= 0.4'}
@@ -8039,6 +8236,9 @@ packages:
   zod@3.25.76:
     resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==}
 
+  zod@4.3.6:
+    resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==}
+
   zustand@5.0.11:
     resolution: {integrity: sha512-fdZY+dk7zn/vbWNCYmzZULHRrss0jx5pPFiOuMZ/5HJN6Yv3u+1Wswy/4MpZEkEGhtNH+pwxZB8OKgUBPzYAGg==}
     engines: {node: '>=12.20.0'}
@@ -8213,9 +8413,9 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@anthropic-ai/claude-agent-sdk@0.1.77(zod@3.25.76)':
+  '@anthropic-ai/claude-agent-sdk@0.1.77(zod@4.3.6)':
     dependencies:
-      zod: 3.25.76
+      zod: 4.3.6
     optionalDependencies:
       '@img/sharp-darwin-arm64': 0.33.5
       '@img/sharp-darwin-x64': 0.33.5
@@ -8226,6 +8426,15 @@ snapshots:
       '@img/sharp-linuxmusl-x64': 0.33.5
       '@img/sharp-win32-x64': 0.33.5
 
+  '@anthropic-ai/sandbox-runtime@0.0.32':
+    dependencies:
+      '@pondwader/socks5-server': 1.0.10
+      '@types/lodash-es': 4.17.12
+      commander: 12.1.0
+      lodash-es: 4.17.23
+      shell-quote: 1.8.3
+      zod: 3.25.76
+
   '@babel/code-frame@7.27.1':
     dependencies:
       '@babel/helper-validator-identifier': 7.27.1
@@ -8716,6 +8925,13 @@ snapshots:
 
   '@date-fns/tz@1.4.1': {}
 
+  '@deepracticex/drizzle@0.2.3(drizzle-orm@0.45.1(@types/better-sqlite3@7.6.13)(better-sqlite3@12.4.1))':
+    dependencies:
+      '@deepracticex/sqlite': 0.2.0
+      drizzle-orm: 0.45.1(@types/better-sqlite3@7.6.13)(better-sqlite3@12.4.1)
+
+  '@deepracticex/sqlite@0.2.0': {}
+
   '@develar/schema-utils@2.6.5':
     dependencies:
       ajv: 6.14.0
@@ -9634,7 +9850,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@modelcontextprotocol/sdk@1.27.1(zod@3.25.76)':
+  '@modelcontextprotocol/sdk@1.27.1(zod@4.3.6)':
     dependencies:
       '@hono/node-server': 1.19.9(hono@4.12.3)
       ajv: 8.18.0
@@ -9651,18 +9867,18 @@ snapshots:
       json-schema-typed: 8.0.2
       pkce-challenge: 5.0.1
       raw-body: 3.0.2
-      zod: 3.25.76
-      zod-to-json-schema: 3.25.1(zod@3.25.76)
+      zod: 4.3.6
+      zod-to-json-schema: 3.25.1(zod@4.3.6)
     transitivePeerDependencies:
       - supports-color
 
-  '@modelcontextprotocol/server-filesystem@2026.1.14(zod@3.25.76)':
+  '@modelcontextprotocol/server-filesystem@2026.1.14(zod@4.3.6)':
     dependencies:
-      '@modelcontextprotocol/sdk': 1.27.1(zod@3.25.76)
+      '@modelcontextprotocol/sdk': 1.27.1(zod@4.3.6)
       diff: 5.2.0
       glob: 10.5.0
       minimatch: 10.2.4
-      zod-to-json-schema: 3.24.6(zod@3.25.76)
+      zod-to-json-schema: 3.24.6(zod@4.3.6)
     transitivePeerDependencies:
       - '@cfworker/json-schema'
       - supports-color
@@ -9901,6 +10117,8 @@ snapshots:
 
   '@polka/url@1.0.0-next.29': {}
 
+  '@pondwader/socks5-server@1.0.10': {}
+
   '@radix-ui/number@1.1.1': {}
 
   '@radix-ui/primitive@1.1.3': {}
@@ -10307,18 +10525,79 @@ snapshots:
 
   '@radix-ui/rect@1.1.1': {}
 
-  '@rolexjs/core@0.11.0': {}
+  '@resourcexjs/arp@2.18.0': {}
+
+  '@resourcexjs/core@0.5.0': {}
 
-  '@rolexjs/local-platform@0.11.0':
+  '@resourcexjs/core@2.18.0':
     dependencies:
-      '@rolexjs/core': 0.11.0
-      '@rolexjs/parser': 0.11.0
+      modern-tar: 0.7.5
+      zod: 4.3.6
 
-  '@rolexjs/parser@0.11.0':
+  '@resourcexjs/node-provider@2.18.0':
+    dependencies:
+      '@resourcexjs/core': 2.18.0
+
+  '@rolexjs/core@1.1.0':
+    dependencies:
+      '@resourcexjs/core': 2.18.0
+      '@rolexjs/system': 1.1.0
+
+  '@rolexjs/genesis@1.3.0': {}
+
+  '@rolexjs/local-platform@1.1.0(@types/better-sqlite3@7.6.13)(better-sqlite3@12.4.1)':
+    dependencies:
+      '@deepracticex/drizzle': 0.2.3(drizzle-orm@0.45.1(@types/better-sqlite3@7.6.13)(better-sqlite3@12.4.1))
+      '@deepracticex/sqlite': 0.2.0
+      '@resourcexjs/node-provider': 2.18.0
+      '@rolexjs/core': 1.1.0
+      '@rolexjs/system': 1.1.0
+      drizzle-orm: 0.45.1(@types/better-sqlite3@7.6.13)(better-sqlite3@12.4.1)
+    transitivePeerDependencies:
+      - '@aws-sdk/client-rds-data'
+      - '@cloudflare/workers-types'
+      - '@electric-sql/pglite'
+      - '@libsql/client'
+      - '@libsql/client-wasm'
+      - '@neondatabase/serverless'
+      - '@op-engineering/op-sqlite'
+      - '@opentelemetry/api'
+      - '@planetscale/database'
+      - '@prisma/client'
+      - '@tidbcloud/serverless'
+      - '@types/better-sqlite3'
+      - '@types/pg'
+      - '@types/sql.js'
+      - '@upstash/redis'
+      - '@vercel/postgres'
+      - '@xata.io/client'
+      - better-sqlite3
+      - bun-types
+      - expo-sqlite
+      - gel
+      - knex
+      - kysely
+      - mysql2
+      - pg
+      - postgres
+      - prisma
+      - sql.js
+      - sqlite3
+
+  '@rolexjs/parser@1.1.0':
     dependencies:
       '@cucumber/gherkin': 38.0.0
       '@cucumber/messages': 32.0.1
 
+  '@rolexjs/prototype@1.1.0':
+    dependencies:
+      '@rolexjs/core': 1.1.0
+      '@rolexjs/parser': 1.1.0
+      '@rolexjs/system': 1.1.0
+      resourcexjs: 2.18.0
+
+  '@rolexjs/system@1.1.0': {}
+
   '@rolldown/pluginutils@1.0.0-beta.43': {}
 
   '@rollup/rollup-android-arm-eabi@4.52.4':
@@ -10387,6 +10666,20 @@ snapshots:
   '@rollup/rollup-win32-x64-msvc@4.52.4':
     optional: true
 
+  '@sandboxxjs/cloudflare-isolator@0.5.1': {}
+
+  '@sandboxxjs/core@0.5.1':
+    dependencies:
+      '@anthropic-ai/sandbox-runtime': 0.0.32
+      '@sandboxxjs/cloudflare-isolator': 0.5.1
+      '@sandboxxjs/state': 0.5.1
+      execa: 9.6.1
+      nanoid: 5.1.6
+
+  '@sandboxxjs/state@0.5.1':
+    dependencies:
+      resourcexjs: 0.5.0
+
   '@sec-ant/readable-stream@0.4.1': {}
 
   '@sigstore/bundle@4.0.0':
@@ -10613,6 +10906,12 @@ snapshots:
     dependencies:
       '@types/node': 22.19.12
 
+  '@types/lodash-es@4.17.12':
+    dependencies:
+      '@types/lodash': 4.17.24
+
+  '@types/lodash@4.17.24': {}
+
   '@types/mdast@4.0.4':
     dependencies:
       '@types/unist': 3.0.3
@@ -11868,6 +12167,11 @@ snapshots:
 
   dotenv@8.6.0: {}
 
+  drizzle-orm@0.45.1(@types/better-sqlite3@7.6.13)(better-sqlite3@12.4.1):
+    optionalDependencies:
+      '@types/better-sqlite3': 7.6.13
+      better-sqlite3: 12.4.1
+
   duck@0.1.12:
     dependencies:
       underscore: 1.13.7
@@ -12311,6 +12615,21 @@ snapshots:
       strip-final-newline: 4.0.0
       yoctocolors: 2.1.2
 
+  execa@9.6.1:
+    dependencies:
+      '@sindresorhus/merge-streams': 4.0.0
+      cross-spawn: 7.0.6
+      figures: 6.1.0
+      get-stream: 9.0.1
+      human-signals: 8.0.1
+      is-plain-obj: 4.1.0
+      is-stream: 4.0.1
+      npm-run-path: 6.0.0
+      pretty-ms: 9.3.0
+      signal-exit: 4.1.0
+      strip-final-newline: 4.0.0
+      yoctocolors: 2.1.2
+
   exif-parser@0.1.12: {}
 
   expand-template@2.0.3: {}
@@ -13466,6 +13785,8 @@ snapshots:
     dependencies:
       p-locate: 6.0.0
 
+  lodash-es@4.17.23: {}
+
   lodash.camelcase@4.3.0: {}
 
   lodash.clamp@4.0.3: {}
@@ -14108,6 +14429,8 @@ snapshots:
       pkg-types: 1.3.1
       ufo: 1.6.3
 
+  modern-tar@0.7.5: {}
+
   motion-dom@12.34.1:
     dependencies:
       motion-utils: 12.29.2
@@ -14132,6 +14455,8 @@ snapshots:
 
   nanoid@3.3.11: {}
 
+  nanoid@5.1.6: {}
+
   napi-build-utils@2.0.0: {}
 
   natural-compare@1.4.0: {}
@@ -15116,6 +15441,16 @@ snapshots:
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
+  resourcexjs@0.5.0:
+    dependencies:
+      '@resourcexjs/core': 0.5.0
+
+  resourcexjs@2.18.0:
+    dependencies:
+      '@resourcexjs/arp': 2.18.0
+      '@resourcexjs/core': 2.18.0
+      sandboxxjs: 0.5.1
+
   responselike@2.0.1:
     dependencies:
       lowercase-keys: 2.0.0
@@ -15153,9 +15488,13 @@ snapshots:
       sprintf-js: 1.1.3
     optional: true
 
-  rolexjs@0.11.0:
+  rolexjs@1.1.0:
     dependencies:
-      '@rolexjs/core': 0.11.0
+      '@rolexjs/core': 1.1.0
+      '@rolexjs/parser': 1.1.0
+      '@rolexjs/prototype': 1.1.0
+      '@rolexjs/system': 1.1.0
+      resourcexjs: 2.18.0
 
   rollup@4.52.4:
     dependencies:
@@ -15211,6 +15550,10 @@ snapshots:
 
   safer-buffer@2.1.2: {}
 
+  sandboxxjs@0.5.1:
+    dependencies:
+      '@sandboxxjs/core': 0.5.1
+
   sanitize-filename@1.6.3:
     dependencies:
       truncate-utf8-bytes: 1.0.2
@@ -15326,6 +15669,8 @@ snapshots:
 
   shebang-regex@3.0.0: {}
 
+  shell-quote@1.8.3: {}
+
   side-channel-list@1.0.0:
     dependencies:
       es-errors: 1.3.0
@@ -16419,16 +16764,22 @@ snapshots:
 
   yoctocolors@2.1.2: {}
 
-  zod-to-json-schema@3.24.6(zod@3.25.76):
+  zod-to-json-schema@3.24.6(zod@4.3.6):
     dependencies:
-      zod: 3.25.76
+      zod: 4.3.6
 
   zod-to-json-schema@3.25.1(zod@3.25.76):
     dependencies:
       zod: 3.25.76
 
+  zod-to-json-schema@3.25.1(zod@4.3.6):
+    dependencies:
+      zod: 4.3.6
+
   zod@3.25.76: {}
 
+  zod@4.3.6: {}
+
   zustand@5.0.11(@types/react@19.2.2)(react@18.3.1):
     optionalDependencies:
       '@types/react': 19.2.2
diff --git a/test-census-parser.js b/test-census-parser.js
new file mode 100644
index 00000000..8de21389
--- /dev/null
+++ b/test-census-parser.js
@@ -0,0 +1,126 @@
+// 测试 census.list 文本解析器
+const testInput = `rolex (RoleX)
+  nuwa (女娲, nvwa) — individual-manager, organization-manager, position-manager
+
+火花堆栈人工智能有限公司
+  Node全栈工程师 — Node全栈工程师岗位
+  测试工程师 — 测试工程师岗位
+  AI系统架构师 — AI系统架构师岗位
+  UI设计师 — UI设计师岗位
+  产品经理 — 产品经理岗位
+
+---
+📅 2026-03-05 12:01:08
+📊 Token usage: ~69 tokens
+Powered by PromptX v2.1.0 | deepractice.ai`
+
+function parseCensusOutput(text) {
+  const result = {
+    roles: [],
+    organizations: []
+  }
+
+  if (!text || typeof text !== 'string') {
+    return result
+  }
+
+  const lines = text.split('\n').filter(l => l.trim() && !l.includes('---') && !l.includes('📅') && !l.includes('📊') && !l.includes('Powered by'))
+
+  let currentOrg = null
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    // 跳过空行
+    if (!trimmed) continue
+
+    // 检测组织行（没有缩进，可能包含括号）
+    if (!line.startsWith(' ')) {
+      // 这是一个组织名称
+      currentOrg = trimmed
+      if (!result.organizations.find(o => o.name === currentOrg)) {
+        result.organizations.push({
+          name: currentOrg,
+          members: [],
+          positions: []
+        })
+      }
+    }
+    // 检测缩进行（角色或职位）
+    else if (line.startsWith('  ') && currentOrg) {
+      const match = trimmed.match(/^([^\s—]+)(?:\s*\([^)]+\))?\s*—\s*(.+)$/)
+      if (match) {
+        const name = match[1].trim()
+        const description = match[2].trim()
+
+        // 判断是角色还是职位
+        // 如果描述包含多个逗号分隔的职位，或者包含 "manager" 等关键词，则是角色
+        // 否则是职位定义
+        const isRole = description.includes(',') ||
+                      description.includes('manager') ||
+                      description.includes('individual') ||
+                      description.includes('organization') ||
+                      description.includes('position')
+
+        if (isRole) {
+          // 这是一个角色
+          const positions = description.split(',').map(p => p.trim())
+
+          // 添加到 roles 列表
+          result.roles.push({
+            name: name,
+            org: currentOrg,
+            position: positions[0]
+          })
+
+          // 添加到组织的成员列表
+          const org = result.organizations.find(o => o.name === currentOrg)
+          if (org) {
+            org.members.push({
+              name: name,
+              position: positions[0]
+            })
+          }
+        } else {
+          // 这是一个职位定义
+          const org = result.organizations.find(o => o.name === currentOrg)
+          if (org) {
+            org.positions.push({
+              name: name,
+              description: description
+            })
+          }
+        }
+      }
+    }
+  }
+
+  return result
+}
+
+// 测试
+const result = parseCensusOutput(testInput)
+console.log('解析结果：')
+console.log(JSON.stringify(result, null, 2))
+
+console.log('\n组织列表：')
+result.organizations.forEach(org => {
+  console.log(`- ${org.name}`)
+  if (org.members && org.members.length > 0) {
+    console.log(`  成员 (${org.members.length}):`)
+    org.members.forEach(m => {
+      console.log(`    - ${m.name} [${m.position}]`)
+    })
+  }
+  if (org.positions && org.positions.length > 0) {
+    console.log(`  职位 (${org.positions.length}):`)
+    org.positions.forEach(p => {
+      console.log(`    - ${p.name}: ${p.description}`)
+    })
+  }
+})
+
+console.log('\n角色列表：')
+result.roles.forEach(role => {
+  console.log(`- ${role.name}${role.org ? ` (${role.org} - ${role.position})` : ''}`)
+})