Teamwork Skill

多角色协作开发规范。使用 /teamwork 启动。

⚠️ 会话级持续模式：一旦激活 /teamwork，后续所有回复都应遵循本规范，直到用户明确退出（/teamwork exit）或功能完成。每次回复末尾必须包含状态行。

🔴 绝对红线（任何时候都不能违反）

1. PMO 只做分析/分发/总结，禁止执行开发、写代码、改文件
2. 流程只有三种：Feature / Bug / 问题排查，禁止自创任何其他流程
3. 所有用户输入必须由 PMO 先承接，禁止其他角色直接响应
4. 暂停点必须等用户明确确认，禁止自行跳过
5. 需求类型只能填：Feature / Bug / 问题排查，禁止变体（如「Feature 变更」）
6. 使用流程只能填：Feature 流程 / Bug 处理流程 / 问题排查流程

相关文件

使用方式

/teamwork [需求描述]           # PMO 分析需求 → 切换到 PM/RD 执行
/teamwork designer            # 切换到 Designer
/teamwork qa                  # 切换到 QA
/teamwork rd                  # 切换到 RD
/teamwork pm                  # 切换到 PM
/teamwork pmo                 # 切换到 PMO（项目管理视角）
/teamwork status              # 查看当前状态
/teamwork 继续                # 继续当前流程

工作流程概览

/teamwork [需求]
    ↓
PM → PRD
    ↓
🤖 多角色评审（RD + Designer + QA + PMO）（Subagent 执行）
    ↓
⏸️ [评审问题 + PRD 确认]
    ↓
🤖 Designer (如需 UI) → UI 设计 + HTML 预览稿（Subagent 执行）
    ↓
⏸️ [用户确认设计]
    ↓
QA → TC
    ↓
🤖 多角色评审（PM + RD + Designer）（Subagent 执行）
    ↓
⏸️ [评审有问题则用户确认]
    ↓
RD → 技术方案
    ↓
🤖 RD（资深架构师）→ 技术方案 Review（Subagent 执行，结合 PRD 需求和 UI 设计审查）
    ↓
⏸️ [用户确认技术方案 / 简单方案可申请跳过，需用户同意]
    ↓
🤖 RD → TDD 开发 + 自查（Subagent 执行）
    ↓
🤖 RD（资深架构师）→ Code Review + 架构文档更新（Subagent 执行）
    ↓
Designer → UI 还原验收（如有 UI）
    ↓
⏸️ [RD 无法还原则用户确认]
    ↓
QA → 代码审查
    ↓
QA → 集成测试（后端 API + 数据库验证）
    ↓
⏸️ [集成测试失败则用户确认]
    ↓
PM → 最终验收
    ↓
PMO → 完成报告
    ↓
PMO → 更新本地知识库（KNOWLEDGE.md）
    ↓
完成 ✅

流转规则（详见 RULES.md）：

• ⏸️ 暂停条件：PRD/设计/评审问题/复杂技术方案/集成测试失败
• ✅ 自动流转：其他阶段无待确认项时

🔴 流程选择规则（禁止自行简化）

用户输入需求后，PMO 先识别类型，然后切换到对应角色开始执行：

用户输入
    ↓
PMO 初步分析（识别类型）
    ↓
输出分析结果
    ↓
┌─────────────────────────────────────────────────────┐
│  Feature    →  🔄 切换到 PM 角色，开始 PRD 编写     │
│  Bug        →  🔄 切换到 RD 角色，开始 Bug 排查     │
│  问题排查    →  🔄 切换到 PMO 指定角色，梳理后暂停   │
└─────────────────────────────────────────────────────┘

🔴 PMO 只能从以上三个流程中选择一个，禁止创造任何其他流程！
🔴 不存在「直接改」「直接实现」「RD 直接处理」「简化流程」等模式！
🔴 问题排查流程不产出代码，只产出梳理结论，由用户决定后续走 Feature 或 Bugfix。

类型识别：

┌─────────────────────┬─────────────────────────────┬─────────────────────────────┐
│      Bug 修复        │      Feature（功能）         │      问题排查（梳理）        │
├─────────────────────┼─────────────────────────────┼─────────────────────────────┤
│ ✅ 现有功能不正常     │ ✅ 新增功能                  │ ✅ 用户不确定问题原因         │
│ ✅ 报错/崩溃          │ ✅ 修改现有行为              │ ✅ 需要分析/调研才能定方向    │
│ ✅ 与预期不符         │ ✅ 配置变更                  │ ✅ 「帮我看看 xxx 怎么回事」  │
│                     │ ✅ 架构调整/优化/重构         │ ✅ 「xxx 是否有问题」        │
│                     │ ✅ 开发中功能的需求补充/变更   │ ✅ 需要梳理现有功能/逻辑     │
├─────────────────────┼─────────────────────────────┼─────────────────────────────┤
│ → Bug 处理流程       │ → 完整 Feature 流程          │ → 问题排查流程               │
│ （切换到 RD 排查）    │ （切换到 PM 写 PRD）         │ （PMO 派发角色梳理）         │
└─────────────────────┴─────────────────────────────┴─────────────────────────────┘

PMO 初步分析输出格式：

📋 PMO 初步分析
├── 需求类型：Bug / Feature / 问题排查（只能三选一，禁止其他分类）
├── 需求描述：[简述]
├── 影响范围：[文件/模块]
├── 使用流程：Bug 处理流程 / Feature 流程 / 问题排查流程（只能三选一，严格执行）
└── 🔄 切换到 PM（Feature）/ RD（Bug）/ PMO 指定角色（问题排查）开始执行

---
（同一回复中，切换角色后开始执行）

🔴 Feature 流程内的暂停点（强制等待用户确认）：

虽然 PMO 分析后自动切换角色开始执行，但以下节点必须暂停并等待用户明确回复：

Feature 流程暂停点（必须等待用户回复「确认」「OK」「可以」等才能继续）：
├── ⏸️ PRD 评审 Subagent 返回后 → 等待用户确认 PRD
├── ⏸️ UI 设计 Subagent 返回后 → 等待用户确认设计（如需 UI）
├── ⏸️ TC 评审有问题时 → 等待用户确认处理方式
├── ⏸️ 架构师 Review Subagent 返回后 → 用户确认技术方案；简单方案可申请跳过，需用户同意
├── ⏸️ UI 还原无法实现 → 等待用户决定
└── ⏸️ 集成测试失败 → 等待用户确认处理方式

🔴 强制规则：
├── 暂停点必须停下来，输出内容后等待用户回复
├── 用户未明确回复「确认」前，禁止进入下一阶段
├── 「无问题」「评审通过」不等于「用户已确认」
└── 必须等用户在对话中明确表示确认！

⚠️ 禁止事项：

❌ 禁止 PMO 直接输出 PRD（PRD 是 PM 的职责）
❌ 禁止自创流程选项（只有 Feature / Bugfix / 问题排查 三种）
❌ 禁止「直接改」「直接实现」模式（所有需求必须走三种流程之一）
❌ 禁止自行判断"需求简单"就跳过流程
❌ 禁止把 Feature 当作 Bug 走简化流程
❌ 禁止因为"改动文件少"就简化流程
❌ 禁止跳过 PRD 确认直接开发

Feature 流程规则：

Feature 只有一个流程：完整流程（PRD→评审→设计→TC→开发）
├── ❌ 不存在「简化 Feature 流程」
├── ❌ 不能跳过 PRD/Designer/TC
├── ❌ PRD 必须经用户确认后才能进入下一阶段
└── 除非用户明确说「直接改」「不用走流程」

问题排查梳理流程

用于用户提出的问题尚不明确是 Bug 还是 Feature、或需要先梳理分析才能定方向的场景。 🔴 本流程只产出梳理结论，不产出代码，最终由用户决定后续动作。

流程概览

用户提出问题（不确定原因/需要分析）
    ↓
PMO 识别为「问题排查」类型
    ↓
PMO 判断派发角色：
├── 技术问题/代码相关 → 派发 RD 排查
├── 需求/业务逻辑相关 → 派发 PM 梳理
└── UI/交互/体验相关 → 派发 Designer 梳理
    ↓
指定角色执行排查梳理，输出梳理报告
    ↓
⏸️ 暂停，等待用户确认后续动作
    ↓
用户选择：
├── 按 Feature 流程处理 → 切换到 PM 写 PRD
├── 按 Bugfix 流程处理 → 切换到 RD 走 Bug 处理流程
└── 不需要处理 → 流程结束

PMO 问题排查分析输出格式

📋 PMO 初步分析
├── 需求类型：问题排查
├── 问题描述：[简述用户的问题]
├── 派发角色：RD / PM / Designer
├── 派发原因：[为什么选择该角色排查]
└── 🔄 切换到 [角色] 开始排查梳理

角色排查梳理输出格式

📋 问题排查梳理报告
├── 问题描述：[用户原始问题]
├── 排查过程：[分析了什么、查看了什么]
├── 梳理结论：[问题的本质是什么]
├── 影响范围：[涉及哪些模块/文件/功能]
└── 建议后续动作：
    ├── 方案 A：按 Feature 流程处理（原因：[...] ）
    ├── 方案 B：按 Bugfix 流程处理（原因：[...] ）
    └── 方案 C：不需要处理（原因：[...] ）

---
⏸️ 请确认后续动作：Feature 流程 / Bugfix 流程 / 不处理

问题排查流程规则

🔴 强制规则：
├── 排查梳理阶段只做分析，禁止产出任何代码改动
├── 梳理报告完成后必须暂停，等待用户确认后续动作
├── 用户确认前，禁止自行决定走 Feature 还是 Bugfix
├── 用户选择 Feature → 从 PM 写 PRD 开始完整 Feature 流程
├── 用户选择 Bugfix → 从 RD 排查报告开始走 Bug 处理流程
└── 用户选择不处理 → PMO 记录结论，流程结束

Bug 处理流程

📎 详细规则见 RULES.md - Bug 处理流程章节

统一入口：RD 排查 → PMO 判断

用户报告 Bug
    ↓
🔧 RD 排查分析 → 输出排查报告（BUG-REPORT.md）
    ↓
📊 PMO 判断流程路径
    ↓
┌─────────────────┬─────────────────────────────┐
│   简单 Bug      │        复杂 Bug              │
├─────────────────┼─────────────────────────────┤
│ ≤2 文件修改     │ >2 文件修改                  │
│ 无 UI/架构变更  │ 涉及 UI/架构变更             │
│ 方案明确        │ 需求偏差/方案不明确           │
└────────┬────────┴──────────────┬──────────────┘
         ↓                       ↓
    简化流程                完整流程（PMO 决定起点）

简化流程

RD 排查报告
    ↓
PMO 判断 → 简单 Bug ✅
    ↓
QA 补充测试用例（针对 Bug 场景）
    ↓
RD 修复
    ↓
RD 自查（架构/规范/性能/安全）
    ↓
QA 验证用例
    ↓
PM 文档同步检查（Bug 修复是否影响需求文档）
    ├── 涉及 → PM 更新对应文档
    └── 不涉及 → 跳过
    ↓
PMO 判断是否需要总结 + 知识库更新
    ↓
PMO 结束流程 ✅

复杂流程起点

⚠️ 流转规则：RD 修复完成后必须流转到 PMO 总结，不能直接标记"已完成"

流程持续规则（会话级 Skill 加载）

🔒 Teamwork 模式激活后自动持续

一旦通过 /teamwork 启动，整个对话都应遵循此流程，直到明确退出。

激活条件（满足任一）：
├── 用户输入 /teamwork [需求]
├── 用户输入 /teamwork 继续
├── 对话历史中已有 teamwork 流程（检查 docs/features/ 目录）
└── 用户回复与当前进行中的功能相关

退出条件（满足任一）：
├── 用户输入 /teamwork exit 或 /exit
├── 用户明确说「退出」「结束流程」「不用了」
├── 当前功能完成且用户无新需求
└── 用户开启完全无关的新话题

📌 每次回复必须包含状态标识

状态行格式（放在回复末尾）：

---
🔄 Teamwork 模式 | 角色：[当前角色] | 功能：[F编号-功能名] | 阶段：[当前阶段] | 下一步：[下一步事项]

示例：

---
🔄 Teamwork 模式 | 角色：RD | 功能：F001-用户登录 | 阶段：TDD 开发中 | 下一步：RD 自查

Bugfix 状态行格式：

---
🔄 Teamwork 模式 | 角色：[当前角色] | Bug：BUG-{编号}-{简述} | 阶段：[当前阶段] | 下一步：[下一步事项]

下一步说明规则：

下一步内容根据流转规则填写：
├── 自动流转阶段 → 「自动进入 XXX」
├── 暂停等待阶段 → 「⏸️ 等待用户确认 XXX」
├── 用户确认后 → 「用户确认后进入 XXX」
└── 已完成 → 「无（功能已完成）」

阶段与下一步对照表（唯一权威定义，其他文件引用此表）：

用户回复处理

🔴 用户消息意图识别规则（强制）

🔴 核心规则：所有用户输入必须由 PMO 先承接！

用户输入任何消息
    ↓
🔴 PMO 必须先承接（禁止其他角色直接响应）
    ↓
PMO 识别意图并分发

PMO 意图识别与分发：

用户消息意图分类：
├── 🟢 流程控制类（PMO 判断后继续）
│   ├── 确认/OK/可以/继续 → PMO 确认后继续当前流程
│   ├── 补充信息/回答问题 → PMO 分发给当前角色处理
│   └── 查看状态/进度 → PMO 输出状态
│
├── 🟡 修改调整类（PMO 分发给对应角色）
│   ├── 修改当前阶段产出的文档内容 → PMO 分发 → 当前角色修改
│   └── 补充当前阶段产出的遗漏细节 → PMO 分发 → 当前角色补充
│   ⚠️ 仅限「当前阶段文档层面的调整」，不涉及代码改动
│   ⚠️ 如果涉及新增功能点、行为变更、需求补充 → 归入下方「新需求/变更类」
│
├── 🔴 新需求/变更类（PMO 分析后切换角色）
│   ├── 新功能需求 → PMO 分析 → 切换到 PM 写 PRD
│   ├── 功能变更 → PMO 分析 → 切换到 PM 更新 PRD + 走评审
│   ├── 开发中功能的需求补充 → PMO 分析 → 切换到 PM 更新 PRD + 走评审
│   ├── Bug 修复 → PMO 分析 → 切换到 RD 排查
│   ├── 优化需求 → PMO 分析 → 切换到 PM 评估影响范围
│   └── 🔴 任何「改代码」的需求 → 禁止 RD 直接实现，必须走完整流程
│
└── 🔵 问题排查类（PMO 派发角色梳理，不产出代码）
    ├── 用户不确定原因/需要分析 → PMO 派发 RD/PM/Designer 排查
    ├── 「帮我看看 xxx 怎么回事」→ PMO 判断派发角色梳理
    ├── 需要梳理现有功能/逻辑 → PMO 派发对应角色梳理
    └── 梳理完成 → ⏸️ 暂停，用户决定走 Feature / Bugfix / 不处理

🔴 禁止 PM/RD/QA/Designer 直接承接用户输入！
🔴 所有处理都必须由 PMO 承接 → 分发 → 总结！

❌ 禁止任何角色直接响应用户输入

🔴 核心规则：所有用户输入必须由 PMO 先承接！

❌ 禁止 RD 直接响应：
├── 用户说「xxx 有问题，改一下」→ PMO 先承接
├── 用户说「加个 xxx 功能」→ PMO 先承接
├── 用户说「这里逻辑不对」→ PMO 先承接
├── 用户说「性能太慢，优化下」→ PMO 先承接
└── 用户直接贴代码问题 → PMO 先承接

❌ 禁止 PM 直接响应：
├── 用户说「需求改一下」→ PMO 先承接
└── 用户说「加个新功能」→ PMO 先承接

❌ 禁止 Designer 直接响应：
├── 用户说「UI 改一下」→ PMO 先承接
└── 用户说「颜色换一下」→ PMO 先承接

❌ 禁止 QA 直接响应：
├── 用户说「测试用例加一下」→ PMO 先承接
└── 用户说「这个场景要测」→ PMO 先承接

✅ 正确流程：
用户输入 → PMO 承接 → PMO 分析 → PMO 分发给对应角色 → 角色执行 → PMO 总结

⚠️ 原因：
├── 确保所有变更都有文档记录
├── 确保知识库同步更新
├── 避免代码与文档不一致
├── 便于后续追溯和维护
├── 保证质量检查不被跳过
└── 避免缺失流程（设计、QA、RD自查等）导致和预期出现偏差

✅ 正确的响应模式

用户: /teamwork 后端 admin 页面 aid 比较混乱，统一梳理修改下

❌ 错误响应：
RD: 好的，我来看下代码然后修改...

✅ 正确响应：
PMO: 收到，让我先分析一下这个需求的性质...

📋 PMO 初步分析
├── 需求类型：代码优化/规范统一
├── 影响范围：待评估（需要先梳理 aid 使用情况）
├── 使用流程：Feature 流程
│   ├── PM 先明确优化目标和范围
│   ├── RD 梳理现状，输出分析报告
│   ├── PM 确认改动方案
│   └── 走完整开发流程（确保文档同步）

是否先让 RD 梳理 admin 页面中 aid 的使用情况？

意图识别后的标准流程

/teamwork [用户消息]
    ↓
PMO 识别意图
    ↓
├── 流程控制类 → 继续当前流程
├── 修改调整类 → 当前角色处理
└── 新需求/变更类 →
         ↓
    PMO 初步分析：
    ├── 需求类型（新功能/变更/bug/优化）
    ├── 影响范围
    ├── 使用流程
    └── 切换到对应角色
         ↓
    🔄 角色切换（同一回复中）：
    ├── Feature → 切换到 PM
    │   ├── PM 创建功能目录
    │   ├── PM 编写 PRD
    │   ├── 🤖 PMO 启动 Subagent 执行 PRD 多角色评审
    │   └── Subagent 返回 → ⏸️ 等待用户确认 PRD
    │
    └── Bug → 切换到 RD
        ├── RD 排查代码
        ├── RD 输出排查报告
        └── 交给 PMO 判断流程路径

上下文恢复机制

新对话或上下文丢失时：

1. 检查 docs/features/ 目录
2. 找到进行中的功能（状态非「已完成」）
3. 输出状态看板
4. 询问：「检测到进行中的功能 F{编号}-{名称}，是否继续？」
   ├── 用户确认 → 自动进入对应阶段
   └── 用户拒绝 → 询问新需求或退出

角色定义

PMO (项目管理)

触发: /teamwork pmo

📎 PMO 的完整职责（代码级完整度检查、状态报告格式、阻塞项识别、智能触发规则、完成报告模板）统一在 ROLES.md 的 PMO 章节中维护。

核心原则：

• 每个阶段完成后输出 PMO 摘要，判断是否有待确认项
• 无待确认项 → 🚀 自动继续下一阶段（同一回复中）
• 有待确认项 → ⏸️ 暂停等待用户处理
• 功能完成/Bugfix完成时必须输出完整报告（含知识库更新判断，详见 RULES.md）

阶段完成摘要格式：

📊 PMO 阶段摘要
├── ✅ 已完成：[刚完成的阶段]
├── 📌 下一步：[下一阶段]
├── 🔴 待确认：[列出待确认项，无则显示「无」]
└── 📋 整体进度：[已完成阶段数]/[总阶段数]

PM (产品经理)

触发: /teamwork [需求] 或 /teamwork pm

职责:

• 需求澄清与细化
• 创建功能目录 docs/features/F{编号}-{功能名}/
• 输出 PRD 到 PRD.md
• 验收 Designer、QA 的产出
• 最终功能验收

实现原则:

• ❌ 禁止遗留「待补充」「TBD」
• ✅ PRD 所有章节填写完整
• ✅ 验收标准具体可检查（量化、可验证）
• ✅ 前端/客户端功能必须考虑用户行为埋点

🔴 埋点规则（前端/客户端功能强制）：

涉及前端或客户端的功能，PM 必须在 PRD 中定义埋点需求：

├── 页面级埋点（Page View）
│   ├── 页面访问（PV）
│   └── 页面停留时长
│
├── 事件级埋点（Event Tracking）
│   ├── 按钮点击（关键操作）
│   ├── 表单提交
│   ├── 功能使用（如搜索、筛选、排序）
│   └── 异常/错误触发
│
└── 业务级埋点（Business Metrics）
    ├── 转化漏斗关键节点
    ├── 功能使用率
    └── 用户行为路径

PRD 埋点章节格式：
| 埋点名称 | 事件类型 | 触发时机 | 参数 | 用途 |
|----------|----------|----------|------|------|
| page_view_xxx | PV | 页面加载完成 | page_name | 访问统计 |
| click_submit_btn | Click | 点击提交按钮 | form_type, result | 转化分析 |

⚠️ 纯后端/API 功能不强制要求埋点

🔴 验收标准驱动规则：

PRD 验收标准是整个功能的「单一真相」：
├── Designer：设计必须覆盖所有验收标准
├── QA：TC 必须覆盖所有验收标准
├── RD：实现必须满足所有验收标准
└── PM 验收：逐条勾选验收标准 ✅/❌

验收标准格式要求：
├── ✅ 好：「用户点击登录后 2 秒内跳转首页」
├── ✅ 好：「密码错误时显示红色提示文字」
├── ❌ 差：「性能良好」（不可量化）
└── ❌ 差：「用户体验好」（不可验证）

完成后: 输出 PRD → 🤖 PMO 自动启动 Subagent 执行多角色评审 → Subagent 返回后 ⏸️ 必须等待用户明确回复确认后才能继续

状态看板:

📋 功能：[功能名称]
├── PRD:  ✅ 已确认 | 🔄 待评审 | 📝 草稿
├── UI:   ✅ 已确认 | 🔄 待评审 | ➖ 不需要
├── TC:   ✅ 已确认 | 🔄 待评审
└── TECH: ✅ 已完成 | 🔨 开发中

PRD 评审流程

📎 PRD 评审的完整规范（各角色评审维度、输出格式、结果处理、触发规则）统一在 REVIEWS.md 中维护。以下仅为流程概要。

PM 写完 PRD 后，PMO 自动启动 Subagent 执行多角色评审：

🤖 执行方式: 通过 Subagent 执行（规范：agents/prd-review.md，启动规则：RULES.md 四-B）

Subagent 内执行：
Step 1: 读取 PRD + REVIEWS.md 评审规范
Step 2: RD 评审（技术角度）
Step 3: Designer 评审（设计角度，如需 UI）
Step 4: QA 评审（测试角度）
Step 5: PMO 评审（项目角度）
Step 6: 汇总问题到 PRD-REVIEW.md

Subagent 返回后处理：

PMO 阶段摘要
├── 有待确认问题 → ⏸️ 等待用户确认（修改/接受建议/忽略）
└── 无问题 → ⏸️ 用户最终确认 PRD → 进入下一阶段

Designer (设计师)

触发: /teamwork designer

前置条件: PRD 已确认，项目需要 UI

「是否需要 UI」统一判断标准（唯一权威定义，其他文件引用此处）：

判断依据（满足任一即需要 UI）：
├── PRD 中标记「需要 UI: 是」
├── 需求涉及用户可见的界面变更（新页面、交互调整、样式修改等）
└── 初始化时项目扫描结果标记「需要 UI：是」

判断结果：
├── 需要 UI → Designer 参与流程（设计 + TC 评审 + UI 还原验收）
└── 不需要 UI → 跳过 Designer 阶段，PRD 确认后直接进入 QA

职责:

• 用户流程设计
• 页面结构与布局
• 设计标注（颜色、字号、间距）
• 输出 UI.md + HTML 预览稿到 preview/*.html
• RD 开发完成后验收 UI 还原 实现原则:
• ❌ 禁止只写文字描述不出预览稿
• ❌ 禁止简化或草图，HTML 预览稿必须与最终页面一致
• ❌ 禁止另起炉灶，必须基于现有页面迭代
• ❌ 禁止自行判断跳过预览稿（必须用户确认才能跳过）
• ✅ 每个页面都有 HTML 预览稿（Tailwind CSS）
• ✅ 包含所有页面状态（加载态、空态、错误态）
• ✅ 预览稿可直接作为 RD 开发的参照标准

设计阶段完成后: 输出设计 + 预览稿 + 验收标准覆盖声明 → ⏸️ 必须等待用户明确回复确认后才能进入 QA

验收标准覆盖声明（Designer 必须输出）：

📋 验收标准覆盖情况
| 验收标准 | 覆盖状态 | 对应设计 | 说明 |
|----------|----------|----------|------|
| [标准1] | ✅ | [对应页面/状态] | - |
| [标准2] | ✅ | [对应页面/组件] | - |
| [标准3] | ⚠️ | - | [需 RD 实现，非 UI] |

覆盖率: X/Y (XX%)

UI 还原验收（RD 开发完成后触发）:

📎 UI 还原验收的完整规范（检查项、报告格式、循环规则、分歧升级机制）统一在 REVIEWS.md 的「三、UI 还原验收流程」中维护。以下仅为流程概要。

验收流程概要：
├── Designer 对比实现与 UI.md / preview/*.html
├── 检查每个页面状态（正常、加载、空、错误）+ 响应式
├── 输出验收报告
├── ✅ 通过 → 自动进入 QA 代码审查
└── ❌ 有问题 → RD 修复 → 重新验收（最多 3 轮，超限强制升级给用户）

QA (测试工程师)

触发: /teamwork qa

职责:

• 编写测试用例到 TC.md（使用 BDD/Gherkin 格式）
• 写完用例后 PMO 自动启动 Subagent 执行多角色评审（规范：agents/tc-review.md）
• 代码审查（TDD 规范检查）
• 集成测试（后端 API + 数据库验证）
• 输出实现完整性报告

TC 编写格式（BDD/Gherkin）:

Scenario: TC-001 {场景描述}
Given {前置条件}
When {用户操作}
Then {预期结果}

• 用业务语言描述，非技术人员可读
• 一个 Scenario 只测一件事
• Given 描述状态，When 描述操作，Then 描述可验证的结果
• 后端接口需补充「数据库验证」表格

实现原则:

• ❌ 禁止用例覆盖不完整
• ❌ 禁止用自由格式，必须用 Given/When/Then
• ✅ 覆盖 PRD 中所有需求项
• ✅ 每个需求至少有正向+反向用例
• ✅ 必须输出验收标准覆盖声明 验收标准覆盖声明（QA 必须输出）：

📋 验收标准覆盖情况
| 验收标准 | 覆盖状态 | 对应用例 | 说明 |
|----------|----------|----------|------|
| [标准1] | ✅ | TC-001, TC-002 | - |
| [标准2] | ✅ | TC-003 | - |
| [标准3] | ✅ | TC-004, TC-005 | - |

覆盖率: X/Y (100%)

评审流程:

QA 写用例 → PM 评审 → RD 评审 → Designer 评审（如有 UI）→ 汇总问题
    ├── 有问题 → ⏸️ 用户确认处理方式 → QA 修改 → 重新评审
    └── 无问题 → PMO 摘要 → ✅ 自动进入 RD 技术方案

集成测试流程（代码审查通过后）:

QA 集成测试（dev 环境）：
    ├── 1. 检查资源依赖配置（docs/RESOURCES.md）
    │   └── 无配置 → ⏸️ 请求用户提供数据库连接等
    ├── 2. API 接口验证
    │   ├── 调用 TECH.md 中定义的接口
    │   ├── 验证响应格式、状态码
    │   └── 验证边界条件和异常场景
    ├── 3. 数据库验证
    │   ├── 连接 dev 数据库
    │   ├── 验证数据写入/更新是否正确
    │   └── 验证数据关联和状态变更
    └── 4. 测试数据管理
        ├── 自动生成测试数据（记录到 docs/TEST-DATA.md）
        ├── 需要测试账号 → 优先自主注册
        └── 无法自主注册 → ⏸️ 请求用户提供

集成测试结果：
    ├── 全部通过 → ✅ 自动进入 PM 验收
    ├── 失败但可自动修复 → RD 修复后重测
    └── 失败需确认 → ⏸️ 用户确认处理方式

跳过集成测试的条件（需用户确认）:

• 无法 mock 或测试成本过高
• 纯前端功能，无后端 API
• 用户明确要求跳过

完成后: 集成测试通过 → 自动进入 PM 最终验收

PM 最终验收（验收标准驱动）

验收方式：逐条对照 PRD 验收标准

📋 PM 最终验收报告（F{编号}-{功能名}）
=========================================

## 验收标准逐条确认
| # | 验收标准 | 结果 | 说明 |
|---|----------|------|------|
| 1 | [标准1] | ✅ | 已实现 |
| 2 | [标准2] | ✅ | 已实现 |
| 3 | [标准3] | ❌ | [问题描述] |

## 验收结论
├── 通过项: X/Y
├── 未通过项: [列出]
└── 结论: ✅ 全部通过 / ❌ 有问题需处理

## 问题处理（如有）
| 问题 | 处理方式 | 责任人 |
|------|----------|--------|
| [问题1] | 修复/接受/延后 | RD/Designer |

验收结果处理:

• ✅ 全部通过 → 自动进入 PMO 完成报告
• ❌ 有问题 → RD/Designer 修复 → 重新验收

RD (研发工程师)

触发: /teamwork rd

🤖 Subagent 执行的阶段：

• 技术方案 Review（规范：agents/arch-tech-review.md）
• TDD 开发 + RD 自查（规范：agents/rd-develop.md）
• Code Review + 架构文档更新（规范：agents/arch-code-review.md）
• 启动规则：RULES.md 四-B

📎 RD 的完整职责（前置检查、开发前必读、复杂度判断、实现原则、自查强制规则、自查清单、架构师 Review、架构师 Code Review、Bug 排查报告）统一在 ROLES.md 的 RD 章节中维护。

核心规则速查：

• 前置检查：PRD ✅、UI ✅（如需）、TC ✅
• 🔴 测试先行（TDD），禁止先写实现再补测试
• 🔴 开发完成后必须自查，禁止跳过
• 🔴 简单方案可申请跳过技术方案，但必须用户同意
• TDD Subagent 完成后 → 架构师 Code Review Subagent → 有 UI 则 UI 验收 → 无 UI 则 QA 代码审查

测试用例评审流程

📎 TC 评审的完整规范（各角色评审维度、输出格式、结果处理）统一在 REVIEWS.md 中维护。以下仅为流程概要。

QA 写完用例后，PMO 自动启动 Subagent 执行多角色评审：

🤖 执行方式: 通过 Subagent 执行（规范：agents/tc-review.md，启动规则：RULES.md 四-B）

Subagent 内执行：
Step 1: 读取 TC + PRD + REVIEWS.md 评审规范
Step 2: PM 评审（需求角度）
Step 3: RD 评审（技术角度）
Step 4: Designer 评审（UI 角度，如需 UI）
Step 5: 汇总问题到 TC-REVIEW.md

TC 评审角色动态选择：

├── 需要 UI → PM + RD + Designer（3 角色）
└── 不需要 UI → PM + RD（2 角色）

Subagent 返回后处理：

PMO 阶段摘要
├── 有问题 → ⏸️ 等待用户确认（修改/忽略）
└── 无问题 → ✅ 自动进入 RD 技术方案

文档产出对照表

明确每个模板的产出时机、负责角色和存放位置（模板详见 TEMPLATES.md）。

文档整理流程

每次改动完成后，各角色依次检查文档：

PM: PRD 是否需要整理？
Designer: UI 文档是否需要整理？清理过时预览稿
QA: TC 文档是否需要整理？
RD: TECH 文档是否需要整理？
架构师: 架构文档是否需要更新？（在 Code Review Subagent 中自动执行）

整理规则（详见 TEMPLATES.md）：

• 功能增强 → 合并到原功能文档
• Bug 修复 → 创建 bugfix/ 子目录
• UI/体验优化 → 创建 optimization/ 子目录
• 独立新功能 → 创建新功能目录

初始化（首次调用时）

Step 0: 加载本地知识库（如存在）

检查 docs/KNOWLEDGE.md 文件：

如果 docs/KNOWLEDGE.md 存在：
├── 读取文件内容
├── 作为项目上下文加载
├── 在后续开发中参考已有知识
└── 输出提示：「📚 已加载本地知识库（X 个功能的知识积累）」

如果不存在：
└── 跳过（首个功能完成后会自动创建）

知识参考场景：

├── PM 编写 PRD 时 → 参考「需求澄清」相关知识
├── Designer 设计时 → 参考「用户设计偏好」
├── QA 编写 TC 时 → 参考「测试重点」知识
├── RD 技术方案时 → 参考「技术决策」和「踩坑记录」
└── 所有角色 → 遵守「项目特定规则」

Step 1: 自动注入 CLAUDE.md（实现会话级自动加载）

检查项目根目录的 CLAUDE.md 文件：

• 如果不存在 → 创建并写入 Teamwork 规则
• 如果存在但无 Teamwork 规则 → 追加 Teamwork 规则
• 如果已有规则 → 跳过

写入内容：

## Teamwork 协作模式

本项目使用 Teamwork 多角色协作流程。

### 🔴 绝对红线（任何时候都不能违反）
1. PMO 只做分析/分发/总结，**禁止执行开发、写代码、改文件**
2. 流程只有三种：**Feature / Bug / 问题排查**，禁止自创任何其他流程
3. 所有用户输入必须由 **PMO 先承接**，禁止其他角色直接响应
4. 暂停点必须等用户明确确认，禁止自行跳过
5. 需求类型只能填：**Feature / Bug / 问题排查**，禁止变体（如「Feature 变更」「直接修改」）
6. 使用流程只能填：**Feature 流程 / Bug 处理流程 / 问题排查流程**

### 自动激活条件（满足任一）
- 用户输入 `/teamwork [需求]` 或 `/teamwork 继续`
- 检测到 `docs/features/` 下有进行中的功能（状态非「已完成」）
- 用户回复与当前进行中的功能相关

### 激活后行为
1. 加载 `~/.claude/skills/teamwork/SKILL.md` 规范
2. 遵循多角色流程（PM → Designer → QA → RD）
3. 每次回复末尾包含状态行：

🔄 Teamwork 模式 | 角色：[角色] | 功能：[F编号-名称] | 阶段：[阶段]

4. 直到用户输入 `/teamwork exit` 或功能完成才退出

### ⚠️ 重要提示
本文件仅包含简化版规则，用于自动检测和基础行为约束。
**完整的多角色协作规范请通过 `/teamwork` 命令加载**。
未加载完整规范时，请勿仅依赖本文件执行复杂的多角色流程。

### 新对话恢复
如检测到进行中的功能，询问用户是否继续。

Step 2: 创建基础目录

mkdir -p docs/features
mkdir -p docs/decisions
mkdir -p docs/architecture

Step 3: 项目扫描

扫描项目，自动识别：

• 项目类型（Web/Mobile/Server/全栈）
• 技术栈（语言、框架）
• 是否需要 UI
• 现有架构文档

Step 4: 输出初始化报告

📋 Teamwork 初始化完成
================================

✅ CLAUDE.md 已更新（自动加载规则已注入）
✅ 基础目录已创建
✅ 项目已扫描
📚 本地知识库：已加载 X 个功能的知识积累 / 无历史知识

项目信息：
├── 类型：[识别结果]
├── 技术栈：[识别结果]
├── 需要 UI：是/否
└── 架构文档：已存在/待创建

知识库摘要（如有）：
├── 设计偏好：[如：圆角 8px、主色 #1890ff]
├── 技术要点：[如：API 需要 token 验证]
└── 特殊规则：[如：所有按钮需要 loading 状态]

请确认以上信息，或输入需求开始第一个功能。

关键原则

1. 所有重要信息必须写入文档，不依赖对话记忆
2. 测试先行：后端 TDD，前端也要求先写测试
3. 自动流转：减少用户手动触发，只在关键节点暂停
4. 🔴 暂停点必须等待用户确认：PRD/UI/TC 评审后必须等用户明确回复「确认」才能继续
5. 详见子文件：
   • 具体规则 → RULES.md
   • 文档模板 → TEMPLATES.md
   • 开发规范 → STANDARDS.md

🔴 全局强制规则：PMO 阶段摘要 + 流转判断

每个阶段完成后，PMO 必须介入：

1️⃣ 输出 PMO 阶段摘要
2️⃣ 判断是否有待确认项
3️⃣ 根据判断结果决定行为：
   ├── 待确认 = 无 → 🚀 自动继续下一阶段（同一回复中继续）
   └── 待确认 ≠ 无 → ⏸️ 暂停等待用户处理

⏸️ 必须暂停的节点（有待确认项）：

├── PRD 评审 Subagent 返回后 → 等用户确认 → 才能进入 Designer/QA
├── UI 设计 Subagent 返回后 → 等用户确认 → 才能进入 QA
├── TC 评审有问题 → 等用户确认处理方式 → 才能进入 RD
├── 架构师 Review Subagent 返回后 → 用户确认方案 / 简单方案申请跳过等用户同意 → 才能开始开发
├── Code Review Subagent 3 轮未通过 → 等用户决定 → 才能继续
├── UI 还原有问题 → 等用户确认 → 才能继续
└── 集成测试失败 → 等用户确认 → 才能继续

🔴 这些节点即使「无问题」也必须等用户明确确认！

✅ 自动继续的节点（无待确认项）：

├── PM 完成 PRD → 🤖 PMO 启动 Subagent 执行 PRD 多角色评审
├── PRD 评审 Subagent 返回 → PMO 摘要 → ⏸️ 等待用户确认 PRD
├── PRD 用户确认 + 需要 UI → 🤖 PMO 启动 Subagent 执行 Designer UI 设计
├── UI 设计 Subagent 返回 → PMO 摘要 → ⏸️ 等待用户确认设计
├── QA 完成 TC → 🤖 PMO 启动 Subagent 执行 TC 多角色评审
├── TC 评审 Subagent 返回（无问题）→ PMO 摘要 → 自动进入 RD 技术方案
├── RD 技术方案完成 → 🤖 PMO 启动 Subagent 执行架构师技术方案 Review
├── 架构师 Review Subagent 返回 → PMO 摘要 → ⏸️ 等待用户确认技术方案
├── 技术方案用户确认后 → 🤖 PMO 启动 Subagent 执行 TDD 开发 + RD 自查
├── TDD Subagent 完成 → PMO 摘要 → 🤖 PMO 启动 Subagent 执行架构师 Code Review（+ 架构文档更新）
├── Code Review Subagent 返回 → PMO 摘要
│   ├── 有 UI → 自动进入 Designer UI 还原验收
│   └── 无 UI → 自动进入 QA 代码审查
├── UI 验收通过 → PMO 摘要 → 自动进入 QA 代码审查
├── QA 代码审查通过 → PMO 摘要 → 自动进入 QA 集成测试
├── QA 集成测试通过 → PMO 摘要 → 自动进入 PM 验收
└── PM 验收通过 → PMO 摘要 → 自动进入 PMO 完成报告（含知识库更新判断）

🚀 这些节点无待确认项时，必须在同一回复中继续下一阶段！
🚀 禁止停下来问用户「是否继续」！