计划生成器Skill plan-generator

---

名称: plan-generator 描述: 从需求创建结构化计划。生成全面的计划，包括步骤、依赖、风险和成功标准。与专家代理协调以获取规划输入，并验证计划的完整性。使用 template-renderer 进行格式化输出。 版本: 1.1 模型: opus invoked_by: both user_invocable: true 工具: [Read, Write, Edit, Bash, Glob, Grep, Skill] 最佳实践:

• 与分析员、产品经理、架构师协调规划输入
• 将需求分解为可执行的步骤（每个部分不超过7步）
• 识别依赖和序列
• 评估风险并提供缓解策略
• 验证计划的完整性和可行性
• 使用 template-renderer 进行计划格式化输出 错误处理: 优雅的 streaming: 支持的 相关技能: [template-renderer, writing-plans] 已验证: false 上次验证时间: 2026-02-19T05:29:09.098Z

---

计划生成器技能

<identity> 计划生成器技能 - 通过协调专家代理和生成全面的计划工件，从需求创建结构化、验证的计划。 </identity>

<capabilities>

• 创建新功能计划
• 规划重构工作
• 规划系统迁移
• 规划架构变更
• 分解复杂需求
• 验证现有计划 </capabilities>

<instructions> <execution_process>

步骤1：分析需求

解析用户需求：

• 提取显式需求
• 识别隐式需求
• 确定规划范围
• 评估复杂性

步骤2：协调专家

从相关代理请求规划输入：

• 分析员: 业务需求和市场背景
• 产品经理: 产品需求和用户故事
• 架构师: 技术架构和设计
• 数据库架构师: 数据需求
• UX专家: 界面需求

步骤3：生成计划结构

创建计划，遵循以下可执行结构：

# 计划: [标题]

## 执行摘要

[2-3句概述]

## 目标

- [目标1]
- [目标2]

## 阶段

### 阶段 N: [阶段标题]

**依赖**: [阶段编号或'无']
**可并行**: [是/否 - 任务可以并发运行吗？]

#### 任务

- [ ] **N.1** [任务描述] (~X 分钟)
  - **命令**: `实际shell命令`
  - **验证**: `验证成功的命令`
  - **回滚**: `如果需要，撤销的命令`

- [ ] **N.2** [任务描述] (~X 分钟) [⚡ 可并行]
  - **命令**: `...`
  - **验证**: `...`

#### 阶段 N 错误处理

如果任何任务失败：

1. 运行已完成任务的回滚命令（逆序）
2. 记录错误: `echo "阶段 N 失败: [错误]" >> .claude/context/memory/issues.md`
3. 不要继续到阶段 N+1

#### 阶段 N 验证门

```bash
# 在继续之前，所有必须通过
[验证命令]

风险

风险	影响	缓解措施	回滚
[风险]	[高/中/低]	[策略]	[命令]

时间线摘要

阶段	任务	预计时间	可并行？
1	5	30 分钟	部分
2	3	20 分钟	否

### 可执行任务格式（强制）

每个任务必须包括：
1. **复选框** - `- [ ]` 用于进度跟踪
2. **ID** - `N.M` 格式供参考
3. **时间估计** - `(~X 分钟)`
4. **命令** - 实际可执行命令
5. **验证** - 确认成功的命令
6. **回滚** - 撤销命令（如果适用）
7. **并行标记** - `[⚡ 可并行]` 如果可以并发运行

### 指南
- 定义清晰目标
- 分解为阶段（总共<=7阶段）
- 每个阶段有<=7任务
- 每个任务有可执行命令
- 包括阶段间的验证门

### 步骤4：评估风险

识别风险和缓解措施：

- 技术风险
- 资源风险
- 时间线风险
- 依赖风险
- 缓解策略

### 步骤5：验证计划

验证计划完整性：

- 所有需求已解决
- 依赖已映射
- 成功标准已定义
- 风险已识别
- 计划可行

### 步骤6：生成工件

使用 template-renderer 技能创建计划工件：

**使用 Template-Renderer**:
创建计划数据结构后，调用 template-renderer 生成格式化输出：

```javascript
// 映射计划数据到模板令牌
const planTokens = {
  PLAN_TITLE: plan.title,
  DATE: new Date().toISOString().split('T')[0],
  FRAMEWORK_VERSION: 'Agent-Studio v2.2.1',
  STATUS: plan.status || '阶段 0 - 研究',
  EXECUTIVE_SUMMARY: plan.executiveSummary,
  TOTAL_TASKS: `${plan.totalTasks} 原子任务`,
  FEATURES_COUNT: plan.features.length,
  ESTIMATED_TIME: plan.estimatedTime,
  STRATEGY: plan.strategy,
  KEY_DELIVERABLES_LIST: plan.keyDeliverables.map(d => `- ${d}`).join('
'),
  // 阶段特定令牌
  PHASE_0_PURPOSE: plan.phases[0].purpose,
  PHASE_0_DURATION: plan.phases[0].duration,
  PHASE_1_NAME: plan.phases[1].name,
  PHASE_1_PURPOSE: plan.phases[1].purpose,
  PHASE_1_DURATION: plan.phases[1].duration,
  DEPENDENCIES: plan.phases[1].dependencies,
  PARALLEL_OK: plan.phases[1].parallelOk ? '是' : '否',
  VERIFICATION_COMMANDS: plan.phases[1].verificationCommands,
  // 根据需要添加更多阶段令牌
};

// 调用 template-renderer 技能
Skill({
  skill: 'template-renderer',
  args: {
    templateName: 'plan-template',
    outputPath: `.claude/context/plans/${planId}.md`,
    tokens: planTokens
  }
});
```

**输出位置**:
- 计划markdown（来自模板）: `.claude/context/plans/<plan-id>.md`
- 计划JSON（结构化数据）: `.claude/context/plans/<plan-id>.json`
- 计划摘要（供快速参考）
</execution_process>

<plan_types>
**功能开发计划**:

- 目标: 功能目标
- 步骤: 分析 -> 设计 -> 实现 -> 测试
- 代理: 分析员 -> 产品经理 -> 架构师 -> 开发者 -> QA

**重构计划**:

- 目标: 代码质量目标
- 步骤: 分析 -> 规划 -> 实现 -> 验证
- 代理: 代码审查员 -> 重构专家 -> 开发者 -> QA

**迁移计划**:

- 目标: 迁移目标
- 步骤: 分析 -> 规划 -> 执行 -> 验证
- 代理: 架构师 -> 遗留现代化专家 -> 开发者 -> QA

**架构计划**:

- 目标: 架构目标
- 步骤: 分析 -> 设计 -> 验证 -> 文档化
- 代理: 架构师 -> 数据库架构师 -> 安全架构师 -> 技术作家
</plan_types>

<integration>
**与规划代理的集成**:
规划代理使用此技能：
- 从需求生成计划
- 协调专家输入
- 验证计划完整性
- 跟踪计划执行
</integration>

<best_practices>

1. **早期协调**: 在最终确定计划前获取专家输入
2. **保持步骤聚焦**: 每个计划部分<=7步
3. **映射依赖**: 清晰识别先决条件
4. **评估风险**: 主动识别和缓解风险
5. **彻底验证**: 确保计划完整且可行
</best_practices>
</instructions>

<examples>
<formatting_example>
**示例计划输出**

**命令**: "生成用户认证功能计划"

**生成的计划**:

```markdown
# 计划: 用户认证功能

## 执行摘要
添加基于JWT的认证，包括登录/注销端点。包括密码哈希、会话管理和安全测试。

## 目标
- 实现基于JWT的认证
- 支持登录、注销和会话管理
- 提供安全的密码处理

## 阶段

### 阶段 1: 设置与设计
**依赖**: 无
**可并行**: 部分

#### 任务
- [ ] **1.1** 创建功能分支 (~2 分钟)
  - **命令**: `git checkout -b feature/auth`
  - **验证**: `git branch --show-current | grep feature/auth`

- [ ] **1.2** 创建认证模块目录 (~1 分钟) [⚡ 可并行]
  - **命令**: `mkdir -p src/auth`
  - **验证**: `ls -d src/auth`

- [ ] **1.3** 设计认证架构 (~15 分钟)
  - **命令**: `Task({ task_id: 'task-1', agent: "architect", prompt: "设计JWT认证..." })`
  - **验证**: `ls .claude/context/artifacts/auth-design.md`

#### 阶段 1 验证门
```bash
git branch --show-current | grep feature/auth && ls src/auth && ls .claude/context/artifacts/auth-design.md
```

### 阶段 2: 实现

**依赖**: 阶段 1
**可并行**: 否（顺序TDD）

#### 任务

- [ ] **2.1** 编写认证端点测试 (~10 分钟)
  - **命令**: `Task({ task_id: 'task-2', agent: "developer", prompt: "TDD: 为/login端点编写失败测试" })`
  - **验证**: `npm test -- --grep "login" 2>&1 | grep -E "failing|FAIL"`
  - **回滚**: `git checkout -- src/auth/__tests__/`

- [ ] **2.2** 实现登录端点 (~15 分钟)
  - **命令**: `Task({ task_id: 'task-3', agent: "developer", prompt: "实现登录以通过测试" })`
  - **验证**: `npm test -- --grep "login" 2>&1 | grep -E "passing|PASS"`

- [ ] **2.3** 实现注销端点 (~10 分钟)
  - **命令**: `Task({ task_id: 'task-4', agent: "developer", prompt: "TDD: 注销端点" })`
  - **验证**: `npm test -- --grep "logout" 2>&1 | grep -E "passing|PASS"`

#### 阶段 2 错误处理

如果任何任务失败：

1. 运行: `git stash && git checkout -- src/auth/`
2. 文档: `echo "阶段 2 失败: $(date)" >> .claude/context/memory/issues.md`
3. 不要继续到阶段 3

#### 阶段 2 验证门

```bash
npm test -- --grep "auth" && echo "所有认证测试通过"
```

### 阶段 3: 安全审查

**依赖**: 阶段 2
**可并行**: 是

#### 任务

- [ ] **3.1** 安全审计 (~20 分钟) [⚡ 可并行]
  - **命令**: `Task({ task_id: 'task-5', agent: "security-architect", prompt: "审计认证实现" })`
  - **验证**: `ls .claude/context/reports/security-audit.md`

- [ ] **3.2** 运行安全测试 (~5 分钟) [⚡ 可并行]
  - **命令**: `npm run test:security`
  - **验证**: `echo $?` (退出代码 0)

## 风险

| 风险                | 影响 | 缓解措施            | 回滚                  |
| ------------------- | ------ | --------------------- | ------------------------- |
| JWT 秘密暴露 | 高   | 使用环境变量          | 立即旋转秘密 |
| SQL 注入       | 高   | 参数化查询 | `git revert HEAD`         |

## 时间线摘要

| 阶段     | 任务 | 预计时间   | 可并行？ |
| --------- | ----- | ----------- | --------- |
| 1         | 3     | 18 分钟      | 部分   |
| 2         | 3     | 35 分钟      | 否        |
| 3         | 2     | 25 分钟      | 是       |
| **总计** | **8** | **~78 分钟** |           |

**计划生成后**, 调用 template-renderer:

```javascript
// 映射计划数据到令牌
const tokens = {
  PLAN_TITLE: '用户认证功能',
  DATE: '2026-01-28',
  FRAMEWORK_VERSION: 'Agent-Studio v2.2.1',
  STATUS: '阶段 0 - 研究',
  EXECUTIVE_SUMMARY: '添加基于JWT的认证，包括登录/注销端点...',
  TOTAL_TASKS: '8 原子任务',
  FEATURES_COUNT: '1',
  ESTIMATED_TIME: '~78 分钟',
  STRATEGY: '基础优先 → 核心功能 → 安全审查',
  KEY_DELIVERABLES_LIST: '- 认证模块
- 登录/注销端点
- 安全审计',
  PHASE_1_NAME: '设置与设计',
  PHASE_1_PURPOSE: '创建功能分支和设计架构',
  PHASE_1_DURATION: '18 分钟',
  DEPENDENCIES: '无',
  PARALLEL_OK: '部分',
  VERIFICATION_COMMANDS: 'git branch --show-current | grep feature/auth && ls src/auth',
};

// 使用模板渲染计划
Skill({
  skill: 'template-renderer',
  args: {
    templateName: 'plan-template',
    outputPath: '.claude/context/plans/user-auth-plan.md',
    tokens: tokens
  }
});
```

</formatting_example>
</examples>

## 规则

### 规划的硬性规则

```
每个任务必须有一个可执行命令
```

没有命令的任务不是任务 - 它是一个愿望。

### 强制元素

- **每个任务**必须有: 复选框、ID、时间估计、命令、验证
- **每个阶段**必须有: 验证门、错误处理
- **每个风险**必须有: 回滚命令

### 反模式（不要做）

| 反模式                | 问题                    | 修复                               |
| --------------------------- | -------------------------- | --------------------------------- |
| "安装 X" 没有命令 | 不可执行             | 添加: `cp -r source dest`          |
| "验证 Y 工作"            | 模糊                      | 添加: `npm test \| grep PASS`      |
| "更新 Z"                  | 什么文件？什么更改？    | 添加精确的 `Edit` 或 `sed` 命令 |
| 没有时间估计           | 无法跟踪进度       | 为每个任务添加 `(~X 分钟)`      |
| 没有回滚                 | 无法从失败恢复 | 添加回滚命令              |

### 质量检查清单

在最终确定任何计划前，验证：

- [ ] 我可以复制粘贴每个命令并运行它吗？
- [ ] 每个验证命令都有清晰的通过/失败输出吗？
- [ ] 对于每个破坏性操作，都有回滚吗？
- [ ] 时间估计是否现实和详细？
- [ ] 并行任务标记了 ⚡ 吗？

## 模板集成

此技能使用 `template-renderer` 技能生成格式化计划：

**集成流程**:

1. plan-generator 创建结构化计划数据（JSON）
2. 映射计划数据到模板令牌（见步骤6）
3. 使用 plan-template 调用 template-renderer
4. 输出渲染计划到 `.claude/context/plans/`

**所需令牌**（对于 plan-template）:

- 核心: `PLAN_TITLE`, `DATE`, `FRAMEWORK_VERSION`, `STATUS`
- 摘要: `EXECUTIVE_SUMMARY`, `TOTAL_TASKS`, `ESTIMATED_TIME`, `STRATEGY`
- 阶段: `PHASE_N_NAME`, `PHASE_N_PURPOSE`, `DEPENDENCIES`, `PARALLEL_OK`
- 验证: `VERIFICATION_COMMANDS`

见 `.claude/templates/plan-template.md` 获取完整令牌列表。

## 相关技能

- [`template-renderer`](../template-renderer/SKILL.md) - 使用令牌替换渲染 plan-template
- [`writing-plans`](../writing-plans/SKILL.md) - 带有完整实现代码的小型任务计划

## 内存协议（强制）

**开始前**:

```bash
cat .claude/context/memory/learnings.md
```

**完成后**:

- 新模式 -> `.claude/context/memory/learnings.md`
- 发现问题 -> `.claude/context/memory/issues.md`
- 决策 -> `.claude/context/memory/decisions.md`

> 假设中断: 您的上下文可能重置。如果不在内存中，它就没有发生。