37d Agent 管理与 Skill 体系

skills/
├── _shared/                          ← 共享模板和工具 Skill
│   ├── output-formatter.md           ← 输出格式化通用 Skill
│   └── error-handler.md              ← 错误处理通用 Skill
├── requirement/                      ← ① 需求/缺陷 Skill 组
│   ├── requirement-create.md         ← 创建需求
│   ├── requirement-status-change.md  ← 需求状态流转
│   ├── requirement-prd-generate.md   ← PRD 自动生成
│   ├── bug-create.md                 ← 创建缺陷
│   └── bug-status-change.md          ← 缺陷状态流转
├── code/                             ← ② 代码 Skill 组
│   ├── code-pr-review.md             ← PR 审查摘要
│   ├── code-search.md                ← 代码搜索
│   ├── code-ci-trigger.md            ← CI/CD 触发
│   └── code-branch-manage.md         ← 分支管理
├── ops/                              ← ③ 运维 Skill 组
│   ├── ops-log-query.md              ← 日志查询
│   ├── ops-service-status.md         ← 服务状态检查
│   ├── ops-alert-handle.md           ← 告警处理
│   └── ops-deploy-trigger.md         ← 部署触发
├── analytics/                        ← ④ 数据分析 Skill 组
│   ├── analytics-sql-query.md        ← SQL 数据查询
│   ├── analytics-ga-report.md        ← GA 数据报告
│   ├── analytics-weekly-report.md    ← 周报生成
│   └── analytics-trend.md            ← 趋势分析
├── team/                             ← ⑤ 团队管理 Skill 组
│   ├── team-weekly-summary.md        ← 工作总结生成
│   ├── team-okr-track.md             ← OKR 跟踪
│   ├── team-onboard.md               ← 入职流程
│   └── team-offboard.md              ← 离职流程
├── knowledge/                        ← ⑥ 知识库 Skill 组
│   ├── knowledge-rag-search.md       ← RAG 检索
│   ├── knowledge-doc-qa.md           ← 文档问答
│   └── knowledge-archive.md          ← 知识沉淀
└── growth/                           ← ⑦ 运营 Skill 组
    ├── growth-strategy.md            ← 增长策略建议
    ├── growth-competitor.md          ← 竞品分析
    ├── growth-content-generate.md    ← 内容生成
    └── growth-community.md           ← 社区运营

# {skill-name}
 
一句话描述这个 Skill 做什么。
 
## 触发条件
描述什么情况下触发这个 Skill。包括：
- 关键词匹配（用户消息中的触发词）
- 事件触发（飞书事件类型）
- 定时触发（cron 表达式）
 
## 执行步骤
编号列表，描述 Skill 的执行流程。每一步应该明确：
1. 做什么操作
2. 调用什么工具（MCP 工具名）
3. 如何处理结果
 
## 输出格式
定义 Skill 的输出结构和格式要求。包括：
- 消息格式（文本/卡片/表格）
- 必填字段
- 字段约束
 
## 示例输出
提供 1-2 个完整的输出示例，作为 Few-shot 参考。
 
## 权限要求
列出这个 Skill 需要的权限：
- 飞书权限
- MCP 工具权限
- 数据库权限
 
## 错误处理
描述常见错误场景和处理方式。

启动/热更新
    │
    ▼
扫描 skills/ 目录
    │
    ▼
解析每个 .md 文件
    │
    ├─→ 提取 Skill 名称（H1 标题）
    ├─→ 提取触发条件
    ├─→ 提取执行步骤
    └─→ 提取输出格式和示例
    │
    ▼
注册到 Skill 路由表
    │
    ▼
就绪，等待消息

用户消息
    │
    ▼
LLM 意图识别（Haiku 轻量模型）
    │
    ├─→ 匹配到单个 Skill → 直接执行
    ├─→ 匹配到多个 Skill → 按优先级选择
    ├─→ 未匹配到 Skill → 通用对话回复
    └─→ 识别为多步任务 → 编排多个 Skill
    │
    ▼
执行 Skill（Sonnet 主力模型）
    │
    ▼
输出结果 → 写入记忆 → 回复用户

用户消息 → 飞书 → OpenClaw Gateway
                        │
                        ▼
                ┌───────────────┐
                │  Router Agent │  ← 轻量模型（Haiku），只做意图分类
                │  (路由 Agent)  │
                └───────┬───────┘
                        │
          ┌─────────────┼─────────────┬──────────────┐
          ▼             ▼             ▼              ▼
    ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐
    │ PM Agent  │ │ Dev Agent │ │ Data Agent│ │ Ops Agent │
    │ 产品需求   │ │ 代码运维   │ │ 数据分析   │ │ 团队管理   │
    │           │ │           │ │           │ │           │
    │ Skills:   │ │ Skills:   │ │ Skills:   │ │ Skills:   │
    │ requirement│ │ code/*   │ │ analytics│ │ team/*   │
    │ knowledge │ │ ops/*    │ │ growth/* │ │ knowledge│
    └───────────┘ └───────────┘ └───────────┘ └───────────┘

{
  "name": "hackquest-agent",
  "mode": "multi-agent",
  "router": {
    "model": "claude-haiku-4-20250514",
    "prompt": "你是 HackQuest 团队的消息路由器。根据用户消息内容，判断应该由哪个 Agent 处理。只输出 Agent 名称，不要解释。",
    "routes": [
      {
        "agent": "pm-agent",
        "description": "产品需求、缺陷管理、PRD、需求评审、知识库问答",
        "keywords": ["需求", "缺陷", "bug", "PRD", "评审", "知识库", "文档"]
      },
      {
        "agent": "dev-agent",
        "description": "代码审查、PR、CI/CD、分支管理、部署、日志查询、告警",
        "keywords": ["PR", "代码", "部署", "CI", "日志", "告警", "分支", "上线"]
      },
      {
        "agent": "data-agent",
        "description": "数据查询、报表生成、增长策略、竞品分析、运营内容",
        "keywords": ["数据", "查询", "报表", "增长", "竞品", "流量", "转化率"]
      },
      {
        "agent": "team-agent",
        "description": "工作总结、OKR、考勤、入职离职、项目进度、交付",
        "keywords": ["周报", "OKR", "考勤", "入职", "离职", "进度", "里程碑"]
      }
    ],
    "fallback": "pm-agent"
  },
  "agents": {
    "pm-agent": {
      "model": "claude-sonnet-4-20250514",
      "skills": ["requirement/*", "knowledge/*", "_shared/*"],
      "mcp": ["lark-mcp"],
      "memory": { "namespace": "pm" },
      "description": "产品需求和知识库 Agent"
    },
    "dev-agent": {
      "model": "claude-sonnet-4-20250514",
      "skills": ["code/*", "ops/*", "_shared/*"],
      "mcp": ["lark-mcp", "github", "postgres"],
      "memory": { "namespace": "dev" },
      "description": "开发和运维 Agent"
    },
    "data-agent": {
      "model": "claude-sonnet-4-20250514",
      "skills": ["analytics/*", "growth/*", "_shared/*"],
      "mcp": ["lark-mcp", "postgres"],
      "memory": { "namespace": "data" },
      "description": "数据分析和运营 Agent"
    },
    "team-agent": {
      "model": "claude-sonnet-4-20250514",
      "skills": ["team/*", "knowledge/*", "_shared/*"],
      "mcp": ["lark-mcp", "github"],
      "memory": { "namespace": "team" },
      "description": "团队管理和人事 Agent"
    }
  },
  "daemon": {
    "enabled": true,
    "port": 3100
  },
  "memory": {
    "enabled": true,
    "persistPath": ".openclaw/memory",
    "shared": true
  }
}

# requirement-prd-generate
 
...
 
## 执行步骤
1. 从记忆中读取需求详情
2. 调用 knowledge-rag-search 检索相关文档
3. 生成 PRD 文档
4. **委派 dev-agent**：在 GitHub 创建对应的 Issue
   - 委派指令：创建 GitHub Issue，标题为"[需求] {requirement_title}"，关联 PRD 链接
   - 等待结果：是（同步委派）
5. 更新需求多维表格的 PRD 链接和 Issue 链接
 
## 委派声明
- 目标 Agent: dev-agent
- 触发条件: PRD 生成完成后
- 传递数据: requirement_title, prd_link
- 等待模式: sync（同步等待结果）

{
  "delegations": {
    "pm-agent": {
      "can_delegate_to": ["dev-agent", "data-agent"],
      "max_depth": 2
    },
    "dev-agent": {
      "can_delegate_to": ["pm-agent"],
      "max_depth": 1
    },
    "data-agent": {
      "can_delegate_to": ["pm-agent"],
      "max_depth": 1
    },
    "team-agent": {
      "can_delegate_to": ["dev-agent", "data-agent"],
      "max_depth": 2
    }
  }
}

PM Agent 执行 requirement-prd-generate
    │
    ├─→ 步骤 1-3：正常执行（PM Agent 自己的 Skill）
    │
    ├─→ 步骤 4：需要创建 GitHub Issue
    │       │
    │       ▼
    │   检查委派权限：pm-agent → dev-agent ✅
    │       │
    │       ▼
    │   构造委派消息：
    │   {
    │     "from": "pm-agent",
    │     "to": "dev-agent",
    │     "task": "创建 GitHub Issue: [需求] 新增 Solana 课程模块",
    │     "context": { "requirement_title": "...", "prd_link": "..." },
    │     "mode": "sync"
    │   }
    │       │
    │       ▼
    │   Dev Agent 接收委派，执行 code-issue-create Skill
    │       │
    │       ▼
    │   返回结果：{ "issue_url": "https://github.com/..." }
    │
    ├─→ 步骤 5：PM Agent 继续执行，使用委派结果
    │
    ▼
  完成

.openclaw/memory/
├── shared/                    ← 共享记忆（所有 Agent 可读写）
│   ├── requirement_rec001.md  ← 需求信息（PM Agent 写，Dev Agent 读）
│   ├── pr_156.md              ← PR 信息（Dev Agent 写，PM Agent 读）
│   └── sprint_2026-W28.md     ← 迭代信息（Team Agent 写，所有 Agent 读）
├── pm/                        ← PM Agent 私有记忆
│   └── prd_templates.md
├── dev/                       ← Dev Agent 私有记忆
│   └── ci_config_cache.md
├── data/                      ← Data Agent 私有记忆
│   └── query_cache.md
└── team/                      ← Team Agent 私有记忆
    └── attendance_rules.md

## 记忆操作
- 写入共享记忆：requirement_{record_id}（其他 Agent 需要读取需求信息）
- 写入私有记忆：prd_draft_cache（只有 PM Agent 需要的草稿缓存）

# requirement-lifecycle
 
需求全生命周期编排：从创建到上线的完整 Skill 链。
 
## 编排类型
事件驱动状态机
 
## 状态转换定义
 
### 触发：用户提出需求
- 执行：requirement-create（PM Agent）
- 写入共享记忆：requirement_{id}
- 下一状态：待评审
 
### 触发：评审人点击"通过"（飞书卡片回调）
- 执行：requirement-status-change（PM Agent）
- 自动触发：requirement-prd-generate（PM Agent）
- 委派：dev-agent 创建 GitHub Issue
- 下一状态：PRD编写中
 
### 触发：PM 确认 PRD（飞书消息）
- 执行：requirement-status-change（PM Agent）
- 下一状态：设计中
 
### 触发：设计评审通过（飞书卡片回调）
- 执行：requirement-status-change（PM Agent）
- 下一状态：开发中
 
### 触发：GitHub PR 创建（GitHub Webhook）
- 执行：code-pr-review（Dev Agent）
- 读取共享记忆：requirement_{id}（关联需求）
- 写入共享记忆：pr_{number}
- 下一状态：待审查
 
### 触发：PR 合并（GitHub Webhook）
- 执行：requirement-status-change（PM Agent）
- 委派：dev-agent 触发 CI/CD
- 下一状态：测试中
 
### 触发：测试通过（飞书消息）
- 执行：requirement-test-verify（PM Agent）
- 委派：dev-agent → ops-deploy-trigger（需人工确认）
- 下一状态：待部署
 
### 触发：部署完成（运维确认）
- 执行：requirement-status-change（PM Agent）
- 通知：项目群发送上线通知
- 下一状态：已上线（终态）
 
## 超时规则
- 待评审超过 24h → 提醒评审人
- 待评审超过 48h → 升级到 CTO
- 待部署状态无超时 → 必须人工确认
 
## 异常处理
- 任何 Skill 执行失败 → 保持当前状态，通知相关人
- 委派失败 → 回退到委派前状态，记录错误日志

启动
  │
  ▼
扫描 skills/_orchestration/*.md
  │
  ▼
解析状态转换定义
  │
  ▼
为每个"触发"注册事件监听：
  ├─→ 飞书消息事件 → 匹配关键词
  ├─→ 飞书卡片回调 → 匹配 action value
  ├─→ 多维表格变更 → 匹配字段变更
  ├─→ GitHub Webhook → 匹配 PR/CI 事件
  └─→ 定时事件 → cron 触发
  │
  ▼
事件到达时，按编排定义执行 Skill 链

张三 @机器人: 创建一个 P1 需求：新增 Solana 课程模块
    │
    ▼
Router Agent（Haiku）: 识别为"需求"类 → 路由到 PM Agent
    │
    ▼
PM Agent: 执行 requirement-create
    ├─→ 创建多维表格记录
    ├─→ 写入共享记忆 shared/requirement_rec001.md
    └─→ 发送评审卡片到评审群
    │
    ▼
李四点击"通过" → 飞书卡片回调
    │
    ▼
PM Agent: 执行 requirement-status-change → requirement-prd-generate
    ├─→ 读取共享记忆 requirement_rec001
    ├─→ 检索知识库（RAG）
    ├─→ 生成 PRD 文档
    ├─→ 委派 Dev Agent: 创建 GitHub Issue
    │       │
    │       ▼
    │   Dev Agent: 执行 code-issue-create
    │       ├─→ 通过 GitHub MCP 创建 Issue
    │       └─→ 返回 issue_url 给 PM Agent
    │
    └─→ 更新多维表格（PRD 链接 + Issue 链接）
    │
    ▼
... 设计评审通过 → PM Agent 更新状态 ...
    │
    ▼
张三提交 PR #156 → GitHub Webhook
    │
    ▼
Router Agent: GitHub 事件 → 路由到 Dev Agent
    │
    ▼
Dev Agent: 执行 code-pr-review
    ├─→ 读取共享记忆 requirement_rec001（关联需求上下文）
    ├─→ 通过 GitHub MCP 获取 PR diff
    ├─→ 生成审查摘要
    ├─→ 写入共享记忆 shared/pr_156.md
    └─→ 发送审查摘要到开发群
    │
    ▼
PR 合并 → PM Agent 更新状态为"测试中"
    │
    ▼
王五: @机器人 测试通过
    │
    ▼
Router Agent: 路由到 PM Agent
    │
    ▼
PM Agent: 执行 requirement-test-verify
    ├─→ 委派 Dev Agent: 触发部署
    │       │
    │       ▼
    │   Dev Agent: 执行 ops-deploy-trigger
    │       ├─→ 发送部署确认卡片到运维群
    │       └─→ 等待运维确认（高风险操作）
    │
    └─→ 运维确认后 → PM Agent 更新状态为"已上线"

# cross-department-incident
 
线上故障全链路编排：从告警到复盘的跨部门 Agent 协作。
 
## 编排类型
跨部门事件驱动链
 
## 参与 Agent
- Dev Agent：告警处理、代码修复、部署
- PM Agent：缺陷管理、状态流转
- Data Agent：影响面分析
- Team Agent：复盘报告归档
 
## 链路定义
 
### 阶段 1：告警触发（Dev Agent）
- 触发：监控系统告警 / 用户报告"线上问题"
- 执行：ops-alert-handle（Dev Agent）
- 操作：
  1. 查询日志定位问题
  2. 评估影响范围
  3. 写入共享记忆：incident_{id} = {severity, service, error, affected_users}
- 委派：PM Agent → 创建缺陷记录
- 委派：Data Agent → 分析用户影响面
- 下一阶段：缺陷创建
 
### 阶段 2：缺陷创建 + 影响分析（PM Agent + Data Agent 并行）
- PM Agent 执行：bug-create
  - 读取共享记忆：incident_{id}
  - 创建缺陷记录，严重程度根据影响面自动判定
  - 写入共享记忆：bug_{id} = {title, severity, assignee}
- Data Agent 执行：analytics-sql-query（并行）
  - 查询受影响用户数、影响时间段、业务损失
  - 写入共享记忆：incident_{id}_impact = {affected_users, duration, revenue_impact}
- 下一阶段：修复开发
 
### 阶段 3：修复与部署（Dev Agent）
- 触发：开发者提交修复 PR
- 执行：code-pr-review（Dev Agent）
  - 读取共享记忆：incident_{id}, bug_{id}
  - 标记为 hotfix，跳过常规 CR 流程
- PR 合并后自动触发：ops-deploy-trigger
  - 高优先级部署，仍需运维确认
- 部署完成后：
  - 委派 PM Agent：更新缺陷状态为"已修复"
  - 委派 Data Agent：验证修复效果
- 下一阶段：效果验证
 
### 阶段 4：效果验证（Data Agent）
- 触发：部署完成后 30 分钟
- 执行：analytics-sql-query（Data Agent）
  - 对比修复前后的错误率、用户影响
  - 写入共享记忆：incident_{id}_resolution = {error_rate_before, error_rate_after, resolved}
- 如果问题未解决 → 通知 Dev Agent 继续排查
- 如果问题已解决 → 委派 Team Agent 生成复盘报告
- 下一阶段：复盘归档
 
### 阶段 5：复盘归档（Team Agent）
- 触发：Data Agent 确认问题已解决
- 执行：team-incident-postmortem（Team Agent）
  - 读取共享记忆：incident_{id}, bug_{id}, incident_{id}_impact, incident_{id}_resolution
  - 汇总全链路信息，生成复盘报告
  - 写入飞书知识库（供 RAG 检索）
  - 更新记忆：incident_{id}_postmortem
- 通知：项目群发送复盘报告链接
 
## 超时规则
- 阶段 1 → 阶段 2：S0/S1 故障 5 分钟内必须创建缺陷，超时升级到 CTO
- 阶段 3 部署确认：hotfix 最多等待 30 分钟
- 阶段 4 效果验证：部署后 30 分钟自动触发
- 阶段 5 复盘报告：修复后 24 小时内完成
 
## 异常处理
- 任何 Agent 委派失败 → 回退到上一阶段，通知管理员
- Data Agent 查询超时 → 跳过影响分析，标记为"待补充"
- 复盘报告生成失败 → 不影响主流程，记录待办

═══════════════════════════════════════════════════════════
阶段 1：告警触发                              Dev Agent
═══════════════════════════════════════════════════════════

Sentry 告警: course-progress API 500 错误率飙升到 15%
    │
    ▼
Router Agent → Dev Agent
    │
    ▼
Dev Agent: 执行 ops-alert-handle
    ├─→ 查询日志：发现 Redis 连接池耗尽
    ├─→ 评估影响：课程进度保存功能不可用
    ├─→ 写入共享记忆 shared/incident_inc001.md:
    │   {severity: S1, service: course-api, error: "Redis pool exhausted",
    │    affected_feature: "课程进度保存", start_time: "10:15"}
    ├─→ 委派 PM Agent: 创建缺陷
    └─→ 委派 Data Agent: 分析影响面（并行）
    │
    ▼
═══════════════════════════════════════════════════════════
阶段 2：缺陷创建 + 影响分析        PM Agent + Data Agent
═══════════════════════════════════════════════════════════

PM Agent: 执行 bug-create                    （并行执行）
    ├─→ 读取 shared/incident_inc001
    ├─→ 创建缺陷：
    │   标题：课程进度接口 500 - Redis 连接池耗尽
    │   严重程度：S1（自动判定：影响核心功能）
    │   指派：张三（后端负责人）
    └─→ 写入共享记忆 shared/bug_rec042.md

Data Agent: 执行 analytics-sql-query          （并行执行）
    ├─→ SQL: 统计 10:15 以来受影响的用户数
    ├─→ SQL: 统计进度保存失败的请求数
    ├─→ 结果：影响 1,200 用户，3,500 次请求失败
    └─→ 写入共享记忆 shared/incident_inc001_impact.md:
        {affected_users: 1200, failed_requests: 3500,
         duration: "45min", estimated_data_loss: "部分用户进度未保存"}
    │
    ▼
Agent 在项目群发送汇总：
  🚨 S1 故障进行中
  - 问题：课程进度接口 500（Redis 连接池耗尽）
  - 影响：1,200 用户，3,500 次请求失败
  - 已指派：张三
  - 缺陷链接：[查看](https://xxx.feishu.cn/base/xxx)
    │
    ▼
═══════════════════════════════════════════════════════════
阶段 3：修复与部署                            Dev Agent
═══════════════════════════════════════════════════════════

张三提交 hotfix PR #178: fix: increase Redis pool size
    │
    ▼
Dev Agent: 执行 code-pr-review
    ├─→ 读取 shared/incident_inc001, shared/bug_rec042
    ├─→ 识别为 hotfix（关联 S1 缺陷）
    ├─→ 生成审查摘要（标注为紧急修复）
    └─→ 发送到开发群，建议快速合并
    │
    ▼
PR 合并 → Dev Agent: 执行 ops-deploy-trigger
    ├─→ 发送部署确认卡片到运维群（标注 hotfix）
    └─→ 运维确认 → 部署完成
    │
    ├─→ 委派 PM Agent: 更新缺陷状态为"已修复"
    └─→ 委派 Data Agent: 30 分钟后验证效果
    │
    ▼
═══════════════════════════════════════════════════════════
阶段 4：效果验证                             Data Agent
═══════════════════════════════════════════════════════════

（部署后 30 分钟自动触发）

Data Agent: 执行 analytics-sql-query
    ├─→ 查询修复后 30 分钟的错误率：0.1%（正常水平）
    ├─→ 对比修复前：15% → 0.1% ✅
    ├─→ 写入共享记忆 shared/incident_inc001_resolution.md:
    │   {error_rate_before: "15%", error_rate_after: "0.1%",
    │    resolved: true, fix_duration: "2h15min"}
    └─→ 委派 Team Agent: 生成复盘报告
    │
    ▼
Agent 在项目群发送：
  ✅ S1 故障已修复
  - 错误率：15% → 0.1%
  - 修复耗时：2 小时 15 分钟
  - 复盘报告将在 24 小时内生成
    │
    ▼
═══════════════════════════════════════════════════════════
阶段 5：复盘归档                             Team Agent
═══════════════════════════════════════════════════════════

Team Agent: 执行 team-incident-postmortem
    ├─→ 读取所有共享记忆：
    │   incident_inc001, bug_rec042,
    │   incident_inc001_impact, incident_inc001_resolution
    ├─→ 生成复盘报告：
    │   📋 故障复盘：课程进度接口 500
    │   ┌──────────────────────────────────────┐
    │   │ 时间线                                │
    │   │ 10:15 告警触发                        │
    │   │ 10:20 缺陷创建，影响面分析完成         │
    │   │ 11:00 hotfix PR 提交                  │
    │   │ 11:30 部署完成                        │
    │   │ 12:00 效果验证通过                    │
    │   │ 12:30 复盘报告生成                    │
    │   ├──────────────────────────────────────┤
    │   │ 根因：Redis 连接池配置过小（默认 10）   │
    │   │ 影响：1,200 用户，3,500 次请求失败     │
    │   │ 修复：连接池扩大到 50，增加连接超时配置  │
    │   │ 改进项：                              │
    │   │ 1. 增加 Redis 连接池监控告警           │
    │   │ 2. 压测覆盖高并发场景                  │
    │   │ 3. 课程进度增加本地缓存兜底             │
    │   └──────────────────────────────────────┘
    ├─→ 写入飞书知识库（供 RAG 检索）
    └─→ 在项目群发送复盘报告链接

# 共享记忆数据契约
 
## incident_{id}.md
写入方：Dev Agent（ops-alert-handle）
读取方：PM Agent, Data Agent, Team Agent
字段：
- severity: S0 | S1 | S2 | S3
- service: 受影响的服务名
- error: 错误描述
- affected_feature: 受影响的功能
- start_time: 故障开始时间
- reporter: 报告人
 
## incident_{id}_impact.md
写入方：Data Agent（analytics-sql-query）
读取方：PM Agent, Team Agent
字段：
- affected_users: 受影响用户数
- failed_requests: 失败请求数
- duration: 影响时长
- estimated_data_loss: 数据损失评估
 
## incident_{id}_resolution.md
写入方：Data Agent（analytics-sql-query）
读取方：Team Agent
字段：
- error_rate_before: 修复前错误率
- error_rate_after: 修复后错误率
- resolved: true | false
- fix_duration: 修复耗时

{
  "delegations": {
    "pm-agent": {
      "can_delegate_to": ["dev-agent", "data-agent", "team-agent"],
      "max_depth": 2
    },
    "dev-agent": {
      "can_delegate_to": ["pm-agent", "data-agent", "team-agent"],
      "max_depth": 2
    },
    "data-agent": {
      "can_delegate_to": ["pm-agent", "team-agent"],
      "max_depth": 1
    },
    "team-agent": {
      "can_delegate_to": ["dev-agent", "data-agent", "pm-agent"],
      "max_depth": 2
    }
  }
}

# 查看某个 incident 的全链路日志
cat .openclaw/logs/audit.log | \
  jq 'select(.input | test("inc001")) or select(.memoryWrites[]? | test("incident_inc001"))'
 
# 查看委派链路
cat .openclaw/logs/audit.log | \
  jq 'select(.event == "delegation") | {from, to, task, status, duration}'
 
# 查看共享记忆的读写记录
cat .openclaw/logs/audit.log | \
  jq 'select(.memoryWrites[]? | test("shared/")) | {skill, memoryWrites, timestamp}'
 
# 检查是否有循环委派
cat .openclaw/logs/audit.log | \
  jq 'select(.event == "delegation" and .depth > 1) | {from, to, depth, traceId}'

Data Agent: 发现课程完成率下降 10%
    │
    ├─→ 写入共享记忆：growth_alert_{id}
    ├─→ 委派 PM Agent: 创建改进需求
    │       │
    │       ▼
    │   PM Agent: 创建需求 + 生成 PRD
    │       ├─→ 委派 Dev Agent: 创建 Issue
    │       └─→ 写入共享记忆：requirement_{id}
    │
    └─→ 需求上线后，Data Agent 自动验证效果
        ├─→ 对比改进前后的完成率
        └─→ 写入共享记忆：growth_alert_{id}_result

Team Agent: 检测到人员表新增记录
    │
    ├─→ 执行入职 Checklist
    ├─→ 委派 Dev Agent: 开通 GitHub 权限
    │       └─→ 返回：权限已开通
    ├─→ 委派 PM Agent: 分配首个任务
    │       └─→ 从需求表中选择适合新人的 P3 任务
    └─→ 一周后自动触发：生成新员工首周总结
        ├─→ 委派 Data Agent: 查询新员工的代码提交和 PR 数据
        └─→ 汇总首周表现报告，发送给直属管理者

Team Agent: 季度末触发 OKR 复盘
    │
    ├─→ 读取 OKR 表，汇总各 KR 进度
    ├─→ 委派 Data Agent: 用数据验证 KR 达成情况
    │       ├─→ 查询用户增长数据（验证增长类 KR）
    │       ├─→ 查询课程完成率（验证产品类 KR）
    │       └─→ 返回数据验证结果
    ├─→ 生成 OKR 复盘报告
    ├─→ 委派 PM Agent: 基于复盘结果生成下季度需求建议
    │       └─→ 从未完成的 KR 中提取需求方向
    └─→ 发送复盘报告 + 需求建议到管理层群

hackquest-agent/                  ← Git 仓库根目录
├── .openclaw/config.json
├── skills/                       ← Skill 文件（核心资产）
├── mcp/servers.json
├── .github/
│   └── workflows/
│       └── skill-review.yml      ← Skill 变更自动检查
├── .gitignore                    ← 忽略 memory/ 和 logs/
└── README.md

.openclaw/memory/
.openclaw/logs/
.env
node_modules/

main                    ← 生产环境 Skill（daemon 从此分支加载）
  └── develop           ← 开发集成分支
       ├── feature/skill-requirement-create    ← 新 Skill 开发
       ├── fix/skill-bug-create-format         ← Skill 修复
       └── improve/skill-analytics-sql-query   ← Skill 优化

1. 创建分支
   git checkout -b feature/skill-xxx develop

2. 编写/修改 Skill
   编辑 skills/xxx/xxx.md

3. 本地测试
   openclaw skill test skills/xxx/xxx.md

4. 提交 PR
   git push origin feature/skill-xxx
   → 创建 PR 到 develop

5. Code Review
   → 至少 1 人审阅
   → 检查 Skill 模板完整性
   → 检查权限声明

6. 合并到 develop → 测试环境验证

7. 合并到 main → 生产环境自动热更新

name: Skill Review
 
on:
  pull_request:
    paths:
      - 'skills/**/*.md'
 
jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Check Skill Template
        run: |
          for file in $(git diff --name-only origin/main -- 'skills/**/*.md'); do
            echo "Checking $file..."
 
            # 检查必须包含的章节
            for section in "# " "## 触发条件" "## 执行步骤" "## 输出格式" "## 权限要求"; do
              if ! grep -q "$section" "$file"; then
                echo "❌ Missing section: $section in $file"
                exit 1
              fi
            done
 
            echo "✅ $file passed template check"
          done
 
      - name: Check Naming Convention
        run: |
          for file in $(git diff --name-only origin/main -- 'skills/**/*.md'); do
            filename=$(basename "$file" .md)
            # 检查命名格式：组名-动作-对象
            if ! echo "$filename" | grep -qE '^[a-z]+-[a-z]+-[a-z]+'; then
              # 允许共享 Skill 不遵循此规则
              dir=$(dirname "$file")
              if [[ "$dir" != *"_shared"* ]]; then
                echo "⚠️ Warning: $filename doesn't follow naming convention {group}-{action}-{object}"
              fi
            fi
          done

{
  "permissions": {
    "roles": {
      "admin": { "skills": ["*"], "approve": true },
      "developer": { "skills": ["requirement/*", "code/*", "knowledge/*"], "approve": false },
      "product": { "skills": ["requirement/*", "analytics/*", "knowledge/*", "growth/*"], "approve": false },
      "ops": { "skills": ["ops/*", "analytics/*"], "approve": true },
      "growth": { "skills": ["analytics/*", "growth/*", "knowledge/*"], "approve": false },
      "hr": { "skills": ["team/*"], "approve": false },
      "readonly": { "skills": ["knowledge/*"], "approve": false }
    },
    "userRoles": {
      "ou_cto_id": "admin",
      "ou_dev_zhangsan": "developer",
      "ou_pm_lisi": "product",
      "ou_ops_wangwu": "ops"
    }
  }
}

修改 skills/xxx.md
        │
        ▼
OpenClaw 文件监听器检测到变更
        │
        ▼
重新解析变更的 Skill 文件
        │
        ▼
更新 Skill 路由表
        │
        ▼
新的消息使用更新后的 Skill
（正在执行的 Skill 不受影响）

# 重新加载所有 Skill
openclaw skill reload
 
# 重新加载指定 Skill
openclaw skill reload skills/requirement/requirement-create.md
 
# 查看 Skill 加载状态
openclaw skill list --verbose

# 1. 修改 Skill 文件
vim skills/requirement/requirement-create.md
 
# 2. 检查 Skill 是否已重新加载
openclaw skill status requirement-create
 
# 3. 本地测试
openclaw chat
> 创建一个测试需求
 
# 4. 确认输出符合预期后，提交到 Git
git add skills/requirement/requirement-create.md
git commit -m "improve: requirement-create output format"

# 方案 1：Git 回滚
git checkout HEAD~1 -- skills/requirement/requirement-create.md
# OpenClaw 自动检测文件变更并重新加载
 
# 方案 2：临时禁用 Skill
openclaw skill disable requirement-create
# 排查问题后重新启用
openclaw skill enable requirement-create

{
  "timestamp": "2026-07-15T10:30:00Z",
  "level": "info",
  "skill": "requirement-create",
  "skillGroup": "requirement",
  "userId": "ou_dev_zhangsan",
  "userName": "张三",
  "trigger": "message",
  "input": "创建一个 P1 需求：新增 Solana 课程模块",
  "mcpCalls": [
    { "server": "lark-mcp", "tool": "create_bitable_record", "duration": 1200, "status": "success" }
  ],
  "tokenUsage": { "input": 850, "output": 320 },
  "duration": 3500,
  "status": "success",
  "output": "✅ 需求已创建：新增 Solana 课程模块 (P1)"
}

# skill-monitor
 
生成 Skill 运行监控报告。
 
## 触发条件
- 定时触发：每天 9:00
- 手动触发：用户消息包含"Skill 监控"、"Skill 报告"
 
## 执行步骤
1. 从 OpenClaw 日志中统计过去 24 小时的 Skill 执行数据
2. 计算每个 Skill 的执行次数、成功率、平均耗时
3. 识别异常 Skill（成功率 < 90% 或平均耗时 > 30s）
4. 生成监控报告并发送到运维群
 
## 输出格式
📊 Skill 运行日报（2026-07-15）
 
| Skill | 执行次数 | 成功率 | 平均耗时 | Token 消耗 |
|-------|---------|--------|---------|-----------|
 
⚠️ 异常 Skill：
- xxx：成功率 85%，主要错误：MCP 超时

## 输出 Schema
输出必须包含以下字段：
- title: string, 必填, 不超过 50 字
- priority: enum(P0, P1, P2, P3), 必填
- status: 固定为"待评审"
- module: enum(课程, Hackathon, 社区, 基础设施, 运营), 必填
 
如果用户未提供优先级，默认为 P2。
如果用户未提供模块，根据需求内容自动推断。

## 示例
 
### 示例 1
**输入**: 创建一个需求：新增 Solana 课程模块，优先级 P1
**输出**:
✅ 需求已创建
- 标题：新增 Solana 课程模块
- 优先级：P1
- 状态：待评审
- 模块：课程
- 多维表格链接：[查看](https://xxx.feishu.cn/base/xxx)
 
### 示例 2
**输入**: 提一个 bug，Safari 上课程进度条显示不对
**输出**:
✅ 缺陷已创建
- 标题：课程进度条在 Safari 上显示异常
- 严重程度：S2（默认）
- 状态：待确认
- 环境：生产
- 多维表格链接：[查看](https://xxx.feishu.cn/base/xxx)
 
请补充以下信息以便开发排查：
1. Safari 版本号？
2. 具体哪个课程页面？
3. 是否有截图？