@zeyue0329/xiaoma-cli 6.0.0-alpha.17 → 6.0.0-alpha.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/package.json +1 -1
  2. package/src/modules/xmc/agents/auto-iteration-orchestrator.agent.yaml +8 -0
  3. package/src/modules/xmc/workflows/auto-iteration/full-auto-workflow.md +813 -394
  4. package/src/modules/xmc/workflows/auto-iteration/requirement-to-epic-workflow.md +428 -0
  5. package/src/modules/xmc/workflows/auto-iteration/story-implementation-workflow.md +675 -0
  6. package/src/modules/xmc/workflows/auto-iteration/full-auto-workflow-old.yaml +0 -0
package/src/modules/xmc/workflows/auto-iteration/full-auto-workflow.md CHANGED
@@ -75,19 +75,20 @@ knowledge_base:
75
75
  ### 智能体工作流集成汇总
76
76
 
77
77
  > **重要**: 本工作流严格遵循项目现有智能体的标准工作流，确保完全兼容。
78
-
79
- | 阶段 | 集成智能体 | 调用的工作流 | 用途 |
80
- |------|-----------|-------------|------|
81
- | Phase 1 | Mary (Analyst) | 内置分析能力 | 需求分析、业务规则匹配 |
82
- | Phase 2 | John (PM) | 内置 PRD 能力 | PRD 创建、史诗故事定义 |
83
- | Phase 3 | Winston (Architect) | 内置架构能力 | 架构设计、技术决策 |
84
- | Phase 4 | Bob (SM) | `*sprint-planning` | 生成 sprint-status.yaml |
85
- | Phase 4 | Bob (SM) | `*create-story` | 创建故事文件 (backlog→drafted→ready-for-dev) |
86
- | Phase 4 | Amelia (DEV) | `*develop-story` | TDD 开发 (ready-for-dev→in-progress→review) |
87
- | Phase 4 | Amelia (DEV) | `*code-review` | 代码审查 (review→done) |
88
- | Phase 5 | Murat (TEA) | `*trace` | 需求到测试追踪 |
89
- | Phase 5 | Murat (TEA) | `*test-review` | 测试质量评审 |
90
- | Phase 5 | Murat (TEA) | `*nfr-assess` | NFR 验证 |
78
+ > **关键变更**: Phase 4 现在包含完整的故事生命周期（包括测试验证），每个故事从创建到验证完成后才处理下一个故事。
79
+
80
+ | 阶段 | 集成智能体 | 调用的工作流 | 用途 | 故事状态 |
81
+ |------|-----------|-------------|------|----------|
82
+ | Phase 1 | Mary (Analyst) | 内置分析能力 | 需求分析、业务规则匹配 | - |
83
+ | Phase 2 | John (PM) | 内置 PRD 能力 | PRD 创建、史诗故事定义 | - |
84
+ | Phase 3 | Winston (Architect) | 内置架构能力 | 架构设计、技术决策 | - |
85
+ | Phase 4 Step 4.1 | Bob (SM) | `*sprint-planning` | 生成 sprint-status.yaml | - |
86
+ | Phase 4 STEP 1 | Bob (SM) | `*create-story` | 创建故事文件 | backlog→drafted |
87
+ | Phase 4 STEP 2 | Bob (SM) | `*validate-create-story` | 校验故事文件 | drafted→ready-for-dev |
88
+ | Phase 4 STEP 3 | Amelia (DEV) | `*develop-story` | TDD 开发 | ready-for-dev→in-progress |
89
+ | Phase 4 STEP 4 | Amelia (DEV) | `*code-review` | 代码审查 | in-progress→review |
90
+ | Phase 4 STEP 5 | Murat (TEA) | `*trace` + `*test-review` | 测试验证 | review→done |
91
+ | Phase 5 (可选) | Murat (TEA) | `*nfr-assess` | Sprint 最终报告 | - |
91
92
 
92
93
  ### 故事状态系统 (6状态流转)
93
94
 
@@ -102,13 +103,13 @@ backlog → drafted → ready-for-dev → in-progress → review → done
102
103
  └─ 仅存在于 Epic 文件中
103
104
  ```
104
105
 
105
- **状态转换触发点**:
106
- - `backlog → drafted`: SM `*create-story` 创建故事文件
107
- - `drafted → ready-for-dev`: SM `*create-story` 或 `*validate-create-story` 验证通过
108
- - `ready-for-dev → in-progress`: DEV `*develop-story` Step 4
109
- - `in-progress → review`: DEV `*develop-story` Step 9
110
- - `review → done`: DEV `*code-review` APPROVED
111
- - `review → in-progress`: DEV `*code-review` CHANGES_REQUESTED (返回修复)
106
+ **状态转换触发点 (完整故事生命周期)**:
107
+ - `backlog → drafted`: STEP 1 - SM `*create-story` 创建故事文件
108
+ - `drafted → ready-for-dev`: STEP 2 - SM `*validate-create-story` 验证通过
109
+ - `ready-for-dev → in-progress`: STEP 3 - DEV `*develop-story` 开始开发
110
+ - `in-progress → review`: STEP 4 - DEV `*code-review` 代码审查开始
111
+ - `review → done`: STEP 5 - TEA `*trace` + `*test-review` 测试验证通过
112
+ - `review → in-progress`: 代码审查或测试验证未通过 (返回修复)
112
113
 
113
114
  ```
114
115
  ┌─────────────────────────────────────────────────────────────────────────┐
@@ -139,20 +140,22 @@ backlog → drafted → ready-for-dev → in-progress → review → done
139
140
  │ ├─ 创建数据模型设计 │
140
141
  │ └─ 输出: 架构设计文档 + ADR │
141
142
  ├─────────────────────────────────────────────────────────────────────────┤
142
- │ Phase 4: 开发实现 [SM + DEV 能力] │
143
- │ ├─ Sprint 规划 │
144
- │ ├─ For Each Story: │
145
- │ │ ├─ 创建故事上下文 │
146
- │ │ ├─ TDD 驱动实现 │
147
- │ │ ├─ 代码审查 │
148
- │ │ └─ 更新状态 │
149
- │ └─ 输出: 实现的代码 + 测试 │
143
+ │ Phase 4: 开发实现与测试验证 [SM + DEV + TEA 能力] │
144
+ │ ├─ Sprint 规划 (SM) │
145
+ │ ├─ 🔄 For Each Story 完整生命周期循环: │
146
+ │ │ ├─ STEP 1: 创建用户故事 (SM) │
147
+ │ │ ├─ STEP 2: 校验用户故事 (SM) │
148
+ │ │ ├─ STEP 3: 开发用户故事 (DEV - TDD) │
149
+ │ │ ├─ STEP 4: 代码审查 (DEV) │
150
+ │ │ ├─ STEP 5: 测试验证 (TEA - 追溯+质量检查) │
151
+ │ │ └─ ✅ 故事完成 → 开始下一个故事 │
152
+ │ └─ 输出: 实现的代码 + 测试 + 每个故事的验证报告 │
150
153
  ├─────────────────────────────────────────────────────────────────────────┤
151
- │ Phase 5: 测试验证 [TEA 能力] │
152
- │ ├─ 执行单元测试 │
153
- │ ├─ 执行集成测试 │
154
- │ ├─ 质量门禁检查 │
155
- │ └─ 输出: 测试报告 + 质量报告 │
154
+ │ Phase 5: Sprint 收尾与最终报告 [TEA 能力] (可选) │
155
+ │ ├─ 生成 Sprint 完整追溯矩阵 │
156
+ │ ├─ 生成整体质量报告 │
157
+ │ ├─ NFR 综合验证 │
158
+ │ └─ 输出: 迭代完成报告 + 质量总结 │
156
159
  ├─────────────────────────────────────────────────────────────────────────┤
157
160
  │ 输出 │
158
161
  │ ├─ ✅ 完整的代码实现 │
@@ -738,12 +741,138 @@ tasks:
738
741
 
739
742
  ---
740
743
 
744
+ #### ⛔ 强制性执行约束 (MANDATORY CONSTRAINTS)
745
+
746
+ ```
747
+ ╔═══════════════════════════════════════════════════════════════════════════════╗
748
+ ║ 🚨 绝对禁止 - ABSOLUTELY FORBIDDEN 🚨 ║
749
+ ╠═══════════════════════════════════════════════════════════════════════════════╣
750
+ ║ ║
751
+ ║ 1. ❌ 禁止跳过故事文件创建 ║
752
+ ║ - 绝对禁止直接基于 Epic 进行开发 ║
753
+ ║ - 每个故事必须先创建独立的故事文件到 /sprint-artifacts/stories/ 目录 ║
754
+ ║ - 没有故事文件 = 不允许开发 ║
755
+ ║ ║
756
+ ║ 2. ❌ 禁止跳过故事验证 ║
757
+ ║ - 故事文件创建后必须执行 *validate-create-story 验证 ║
758
+ ║ - 验证未通过 = 不允许进入开发阶段 ║
759
+ ║ ║
760
+ ║ 3. ❌ 禁止跳过单元测试 ║
761
+ ║ - 开发完成后必须执行单元测试 ║
762
+ ║ - 测试未通过 = 不允许进入代码审查阶段 ║
763
+ ║ ║
764
+ ║ 4. ❌ 禁止跳过代码审查 ║
765
+ ║ - 所有代码必须通过 *code-review 审查 ║
766
+ ║ - 审查未通过 = 必须返回修复 ║
767
+ ║ ║
768
+ ║ 5. ❌ 禁止批量处理多个故事 ║
769
+ ║ - 必须一个故事一个故事地完成 ║
770
+ ║ - 当前故事未完成 = 不允许开始下一个故事 ║
771
+ ║ ║
772
+ ╚═══════════════════════════════════════════════════════════════════════════════╝
773
+ ```
774
+
775
+ #### ✅ 用户故事完整生命周期 5 步强制流程 (MANDATORY 5-STEP LIFECYCLE)
776
+
777
+ ```
778
+ ╔═══════════════════════════════════════════════════════════════════════════════╗
779
+ ║ 🔄 用户故事完整生命周期 (每个故事必须完成全部 5 步) ║
780
+ ╠═══════════════════════════════════════════════════════════════════════════════╣
781
+ ║ ║
782
+ ║ ⚠️ 关键原则: 每个故事必须完成从创建到测试验证的完整生命周期后, ║
783
+ ║ 才能开始下一个故事！禁止批量开发后统一测试！ ║
784
+ ║ ║
785
+ ║ 对于 sprint-status.yaml 中的每一个故事，必须严格按以下顺序执行: ║
786
+ ║ ║
787
+ ║ ┌─────────────────────────────────────────────────────────────────────────┐ ║
788
+ ║ │ STEP 1: 创建用户故事 (CREATE) [SM - Bob] │ ║
789
+ ║ │ ┌─────────────────────────────────────────────────────────────────────┐ │ ║
790
+ ║ │ │ 命令: /sm → *create-story │ │ ║
791
+ ║ │ │ 输出: /sprint-artifacts/stories/{story-key}.md │ │ ║
792
+ ║ │ │ 状态: backlog → drafted │ │ ║
793
+ ║ │ │ 🚨 门禁: 必须确认文件已创建在 stories/ 目录下 │ │ ║
794
+ ║ │ └─────────────────────────────────────────────────────────────────────┘ │ ║
795
+ ║ └─────────────────────────────────────────────────────────────────────────┘ ║
796
+ ║ ↓ ║
797
+ ║ ┌─────────────────────────────────────────────────────────────────────────┐ ║
798
+ ║ │ STEP 2: 校验用户故事 (VALIDATE) [SM - Bob] │ ║
799
+ ║ │ ┌─────────────────────────────────────────────────────────────────────┐ │ ║
800
+ ║ │ │ 命令: /sm → *validate-create-story │ │ ║
801
+ ║ │ │ 检查: 接受标准完整性、任务分解合理性、技术说明充分性 │ │ ║
802
+ ║ │ │ 状态: drafted → ready-for-dev │ │ ║
803
+ ║ │ │ 🚨 门禁: 验证必须通过，否则返回 STEP 1 修正 │ │ ║
804
+ ║ │ └─────────────────────────────────────────────────────────────────────┘ │ ║
805
+ ║ └─────────────────────────────────────────────────────────────────────────┘ ║
806
+ ║ ↓ ║
807
+ ║ ┌─────────────────────────────────────────────────────────────────────────┐ ║
808
+ ║ │ STEP 3: 开发用户故事 (DEVELOP) [DEV - Amelia] │ ║
809
+ ║ │ ┌─────────────────────────────────────────────────────────────────────┐ │ ║
810
+ ║ │ │ 命令: /dev → *develop-story │ │ ║
811
+ ║ │ │ 执行: TDD 驱动开发 (红-绿-重构) + 单元测试 100% 通过 │ │ ║
812
+ ║ │ │ 状态: ready-for-dev → in-progress │ │ ║
813
+ ║ │ │ 🚨 前置: 必须有 ready-for-dev 状态的故事文件 │ │ ║
814
+ ║ │ │ 🚨 门禁: 所有单元测试必须 100% 通过 │ │ ║
815
+ ║ │ └─────────────────────────────────────────────────────────────────────┘ │ ║
816
+ ║ └─────────────────────────────────────────────────────────────────────────┘ ║
817
+ ║ ↓ ║
818
+ ║ ┌─────────────────────────────────────────────────────────────────────────┐ ║
819
+ ║ │ STEP 4: 代码审查 (CODE REVIEW) [DEV - Amelia] │ ║
820
+ ║ │ ┌─────────────────────────────────────────────────────────────────────┐ │ ║
821
+ ║ │ │ 命令: /dev → *code-review │ │ ║
822
+ ║ │ │ 审查: 功能正确性 + 代码质量 + 安全性 + 测试覆盖 │ │ ║
823
+ ║ │ │ 状态: in-progress → review │ │ ║
824
+ ║ │ │ 🚨 门禁: APPROVED 继续，CHANGES_REQUESTED 返回 STEP 3 修复 │ │ ║
825
+ ║ │ └─────────────────────────────────────────────────────────────────────┘ │ ║
826
+ ║ └─────────────────────────────────────────────────────────────────────────┘ ║
827
+ ║ ↓ ║
828
+ ║ ┌─────────────────────────────────────────────────────────────────────────┐ ║
829
+ ║ │ STEP 5: 测试验证 (TEST VERIFICATION) [TEA - Murat] │ ║
830
+ ║ │ ┌─────────────────────────────────────────────────────────────────────┐ │ ║
831
+ ║ │ │ 命令: /tea → *trace + *test-review │ │ ║
832
+ ║ │ │ 验证: 需求追溯完整性 + 测试质量评审 + 集成测试 │ │ ║
833
+ ║ │ │ 状态: review → done (通过) 或 review → in-progress (返回修复) │ │ ║
834
+ ║ │ │ 🚨 门禁: 追溯完整 + 测试质量通过才能标记 done │ │ ║
835
+ ║ │ └─────────────────────────────────────────────────────────────────────┘ │ ║
836
+ ║ └─────────────────────────────────────────────────────────────────────────┘ ║
837
+ ║ ║
838
+ ║ ✅ 故事完成: 状态变为 done，🔄 返回 STEP 1 开始下一个故事 ║
839
+ ║ ║
840
+ ╚═══════════════════════════════════════════════════════════════════════════════╝
841
+ ```
842
+
843
+ #### 📋 故事文件存在性验证 (FILE EXISTENCE VALIDATION)
844
+
845
+ ```yaml
846
+ # 在开始开发任何故事之前，必须执行以下验证:
847
+
848
+ validation_before_development:
849
+ check_1_sprint_status_exists:
850
+ file: "{sprint_artifacts}/sprint-status.yaml"
851
+ error_if_missing: "❌ 必须先执行 /sm → *sprint-planning 生成 sprint-status.yaml"
852
+
853
+ check_2_story_file_exists:
854
+ file: "{sprint_artifacts}/stories/{story-key}.md"
855
+ error_if_missing: "❌ 必须先执行 /sm → *create-story 创建故事文件"
856
+
857
+ check_3_story_status_valid:
858
+ condition: "故事文件中 Status: 必须是 ready-for-dev"
859
+ error_if_invalid: "❌ 故事状态不是 ready-for-dev，必须先通过验证"
860
+
861
+ # 验证命令示例:
862
+ verification_commands:
863
+ - "ls {sprint_artifacts}/sprint-status.yaml # 确认存在"
864
+ - "ls {sprint_artifacts}/stories/ # 列出所有故事文件"
865
+ - "grep 'Status:' {sprint_artifacts}/stories/{story-key}.md # 检查状态"
866
+ ```
867
+
868
+ ---
869
+
741
870
  #### 🤖 智能体执行指令概览
742
871
 
743
872
  ```
744
873
  ┌─────────────────────────────────────────────────────────────────┐
745
- │ Phase 4: 开发实现 │
746
- │ 智能体: Bob (SM) + Amelia (DEV) │
874
+ │ Phase 4: 开发实现与测试验证 │
875
+ │ 智能体: Bob (SM) + Amelia (DEV) + Murat (TEA) │
747
876
  ├─────────────────────────────────────────────────────────────────┤
748
877
  │ │
749
878
  │ 阶段流程概览: │
@@ -753,36 +882,61 @@ tasks:
753
882
  │ │ ┌────────────────────────────────────────────────────────┐ │
754
883
  │ │ │ 执行: /sm → *sprint-planning │ │
755
884
  │ │ │ 输出: sprint-status.yaml │ │
885
+ │ │ │ 🚨 门禁: 必须生成 sprint-status.yaml 才能继续 │ │
756
886
  │ │ └────────────────────────────────────────────────────────┘ │
757
887
  │ └──────────────────────────────────────────────────────────────┘
758
888
  │ ↓ │
759
889
  │ ┌──────────────────────────────────────────────────────────────┐
760
- │ │ Step 4.2: For Each Story 循环 │
890
+ │ │ Step 4.2: 🔄 For Each Story 完整生命周期循环 │
891
+ │ │ ⚠️ 每个故事必须完成全部 5 步后才能开始下一个故事！ │
761
892
  │ │ │
762
- │ │ Step 4.2.1: 故事准备 (SM) │
893
+ │ │ STEP 1: 创建用户故事 (SM - Bob) 🔴 必须 │
763
894
  │ │ ┌────────────────────────────────────────────────────┐ │
764
895
  │ │ │ 执行: /sm → *create-story │ │
765
- │ │ │ 状态: backlog → drafted → ready-for-dev │ │
896
+ │ │ │ 输出: /sprint-artifacts/stories/{story-key}.md │ │
897
+ │ │ │ 状态: backlog → drafted │ │
898
+ │ │ │ 🚨 门禁: 确认文件已创建 │ │
899
+ │ │ └────────────────────────────────────────────────────┘ │
900
+ │ │ ↓ │
901
+ │ │ STEP 2: 校验用户故事 (SM - Bob) 🔴 必须 │
902
+ │ │ ┌────────────────────────────────────────────────────┐ │
903
+ │ │ │ 执行: /sm → *validate-create-story │ │
904
+ │ │ │ 检查: AC完整性、任务分解、技术说明 │ │
905
+ │ │ │ 状态: drafted → ready-for-dev │ │
906
+ │ │ │ 🚨 门禁: 验证通过才能继续 │ │
766
907
  │ │ └────────────────────────────────────────────────────┘ │
767
908
  │ │ ↓ │
768
- │ │ Step 4.2.2: 故事开发 (DEV) │
909
+ │ │ STEP 3: 开发用户故事 (DEV - Amelia) 🔴 必须 │
769
910
  │ │ ┌────────────────────────────────────────────────────┐ │
770
911
  │ │ │ 执行: /dev → *develop-story │ │
771
- │ │ │ 状态: ready-for-dev → in-progress → review │ │
912
+ │ │ │ 内容: TDD 开发 + 单元测试 100% 通过 │ │
913
+ │ │ │ 状态: ready-for-dev → in-progress │ │
914
+ │ │ │ 🚨 门禁: 单元测试 100% 通过 │ │
772
915
  │ │ └────────────────────────────────────────────────────┘ │
773
916
  │ │ ↓ │
774
- │ │ Step 4.2.3: 代码审查 (DEV) │
917
+ │ │ STEP 4: 代码审查 (DEV - Amelia) 🔴 必须 │
775
918
  │ │ ┌────────────────────────────────────────────────────┐ │
776
919
  │ │ │ 执行: /dev → *code-review │ │
920
+ │ │ │ 审查: 功能 + 代码质量 + 安全 + 测试覆盖 │ │
921
+ │ │ │ 状态: in-progress → review │ │
922
+ │ │ │ 🚨 门禁: APPROVED 继续，否则返回 STEP 3 │ │
923
+ │ │ └────────────────────────────────────────────────────┘ │
924
+ │ │ ↓ │
925
+ │ │ STEP 5: 测试验证 (TEA - Murat) 🔴 必须 │
926
+ │ │ ┌────────────────────────────────────────────────────┐ │
927
+ │ │ │ 执行: /tea → *trace + *test-review │ │
928
+ │ │ │ 验证: 需求追溯 + 测试质量 + 集成测试 │ │
777
929
  │ │ │ 状态: review → done (通过) 或 返回修复 │ │
930
+ │ │ │ 🚨 门禁: 追溯完整 + 质量通过才标记 done │ │
778
931
  │ │ └────────────────────────────────────────────────────┘ │
779
932
  │ │ │
933
+ │ │ ✅ 故事完成 → 🔄 返回 STEP 1 开始下一个故事 │
780
934
  │ └──────────────────────────────────────────────────────────────┘
781
935
  │ │
782
936
  └─────────────────────────────────────────────────────────────────┘
783
937
  ```
784
938
 
785
- **完整执行序列**:
939
+ **完整执行序列 (5 步强制流程)**:
786
940
  ```bash
787
941
  # === Step 4.1: Sprint 规划 ===
788
942
  # 1. 唤醒 SM 智能体
@@ -791,33 +945,66 @@ tasks:
791
945
  # 2. 执行 Sprint 规划
792
946
  *sprint-planning
793
947
 
794
- # === Step 4.2: 故事开发循环 (对每个故事重复) ===
948
+ # 🚨 门禁检查: 确认 sprint-status.yaml 已生成
949
+ ls {sprint_artifacts}/sprint-status.yaml
795
950
 
796
- # --- Step 4.2.1: 故事准备 (SM) ---
797
- # 3. 唤醒 SM 智能体 (如果不在当前上下文)
798
- /sm
951
+ # === Step 4.2: 🔄 故事完整生命周期循环 (对每个故事重复 5 步流程) ===
952
+
953
+ # ╔═══════════════════════════════════════════════════════════════╗
954
+ # ║ 🔄 FOR EACH STORY - 完整生命周期循环开始 ║
955
+ # ╚═══════════════════════════════════════════════════════════════╝
799
956
 
800
- # 4. 创建故事文件
957
+ # ============================================================
958
+ # STEP 1: 创建用户故事 (SM - Bob) 🔴 必须执行
959
+ # ============================================================
960
+ /sm
801
961
  *create-story
802
962
 
803
- # 5. (推荐) 验证故事
963
+ # 🚨 门禁检查: 确认故事文件已创建
964
+ ls {sprint_artifacts}/stories/{story-key}.md
965
+
966
+ # ============================================================
967
+ # STEP 2: 校验用户故事 (SM - Bob) 🔴 必须执行
968
+ # ============================================================
969
+ /sm
804
970
  *validate-create-story
805
971
 
806
- # --- Step 4.2.2: 故事开发 (DEV) ---
807
- # 6. 唤醒 DEV 智能体
808
- /dev
972
+ # 🚨 门禁检查: 确认故事状态为 ready-for-dev
973
+ grep "Status: ready-for-dev" {sprint_artifacts}/stories/{story-key}.md
809
974
 
810
- # 7. 执行故事开发
975
+ # ============================================================
976
+ # STEP 3: 开发用户故事 (DEV - Amelia) 🔴 必须执行
977
+ # ============================================================
978
+ /dev
811
979
  *develop-story
812
980
 
813
- # --- Step 4.2.3: 代码审查 (DEV) ---
814
- # 8. 唤醒 DEV 智能体 (建议使用全新上下文)
815
- /dev
981
+ # 🚨 门禁检查: 单元测试必须 100% 通过 (TDD 开发中已执行)
982
+ # 如果测试失败，必须修复后重新运行，不允许跳过
816
983
 
817
- # 9. 执行代码审查
984
+ # ============================================================
985
+ # STEP 4: 代码审查 (DEV - Amelia) 🔴 必须执行
986
+ # ============================================================
987
+ /dev
818
988
  *code-review
819
989
 
820
- # --- 重复 Step 4.2 直到所有故事完成 ---
990
+ # 🚨 门禁检查:
991
+ # - APPROVED: 继续到 STEP 5
992
+ # - CHANGES_REQUESTED: 返回 STEP 3 修复后重新审查
993
+
994
+ # ============================================================
995
+ # STEP 5: 测试验证 (TEA - Murat) 🔴 必须执行
996
+ # ============================================================
997
+ /tea
998
+ *trace # 需求追溯验证
999
+ *test-review # 测试质量评审
1000
+
1001
+ # 🚨 门禁检查:
1002
+ # - 追溯完整 + 测试质量通过: 故事状态变为 done
1003
+ # - 验证失败: 返回 STEP 3 修复后重新验证
1004
+
1005
+ # ╔═══════════════════════════════════════════════════════════════╗
1006
+ # ║ ✅ 故事完成 → 🔄 返回 STEP 1 开始下一个故事 ║
1007
+ # ╚═══════════════════════════════════════════════════════════════╝
821
1008
  ```
822
1009
 
823
1010
  ---
@@ -845,7 +1032,7 @@ epic_status:
845
1032
 
846
1033
  ```yaml
847
1034
  phase: 4
848
- name: 开发实现
1035
+ name: 开发实现与测试验证
849
1036
  inputs:
850
1037
  - architecture.md
851
1038
  - epics/*.md # 包含故事定义的 Epic 文件
@@ -856,21 +1043,36 @@ outputs:
856
1043
  - 实现的代码
857
1044
  - 测试代码
858
1045
  - code-review-reports/
1046
+ - traceability-matrix.md # 需求追溯矩阵
1047
+ - test-review-reports/ # 测试质量报告
859
1048
 
860
- # 调用的智能体工作流
1049
+ # 调用的智能体工作流 (完整故事生命周期)
861
1050
  workflows_invoked:
862
- - agent: SM (Bob)
863
- workflow: sprint-planning
864
- purpose: "生成 sprint-status.yaml"
865
- - agent: SM (Bob)
1051
+ - step: "STEP 1"
1052
+ agent: SM (Bob)
866
1053
  workflow: create-story
867
- purpose: "为每个故事创建详细故事文件"
868
- - agent: DEV (Amelia)
869
- workflow: dev-story
1054
+ purpose: "创建用户故事文件"
1055
+ status_change: "backlog → drafted"
1056
+ - step: "STEP 2"
1057
+ agent: SM (Bob)
1058
+ workflow: validate-create-story
1059
+ purpose: "校验用户故事"
1060
+ status_change: "drafted → ready-for-dev"
1061
+ - step: "STEP 3"
1062
+ agent: DEV (Amelia)
1063
+ workflow: develop-story
870
1064
  purpose: "TDD 驱动的故事实现"
871
- - agent: DEV (Amelia)
1065
+ status_change: "ready-for-dev → in-progress"
1066
+ - step: "STEP 4"
1067
+ agent: DEV (Amelia)
872
1068
  workflow: code-review
873
1069
  purpose: "代码审查验证"
1070
+ status_change: "in-progress → review"
1071
+ - step: "STEP 5"
1072
+ agent: TEA (Murat)
1073
+ workflow: trace + test-review
1074
+ purpose: "测试验证 (需求追溯 + 测试质量)"
1075
+ status_change: "review → done"
874
1076
  ```
875
1077
 
876
1078
  ---
@@ -961,49 +1163,112 @@ actions:
961
1163
 
962
1164
  ---
963
1165
 
964
- #### Step 4.2: 故事开发循环
1166
+ #### Step 4.2: 故事开发循环 (5 步强制流程)
965
1167
 
966
- **对于每个故事，执行完整的状态转换和开发循环**:
1168
+ > ⚠️ **强制要求**: 对于每个故事，必须严格按照以下 5 步流程执行，禁止跳过任何步骤！
967
1169
 
968
1170
  ```
969
1171
  ┌─────────────────────────────────────────────────────────────────────────────┐
970
- │ 故事生命周期管理 │
1172
+ │ 故事生命周期管理 (5 步强制流程) │
971
1173
  ├─────────────────────────────────────────────────────────────────────────────┤
972
1174
  │ │
973
- │ Step 4.2.1: 故事准备 (SM - Bob) │
974
- │ ├─ 调用: *create-story │
1175
+ │ 🔴 STEP 1: 创建用户故事 (SM - Bob) [必须] │
1176
+ │ ├─ 命令: /sm → *create-story │
975
1177
  │ ├─ 输入: Epic 中的故事定义 │
976
- │ ├─ 输出: stories/{story-key}.md │
977
- │ └─ 状态: backlog → drafted → ready-for-dev │
1178
+ │ ├─ 输出: /sprint-artifacts/stories/{story-key}.md │
1179
+ │ ├─ 状态: backlog → drafted │
1180
+ │ └─ 🚨 门禁: 必须确认文件已创建，否则不能继续 │
978
1181
  │ │
979
- │ Step 4.2.2: 故事开发 (DEV - Amelia) │
980
- │ ├─ 调用: *develop-story │
981
- │ ├─ 输入: ready-for-dev 状态的故事 │
1182
+ │ 🔴 STEP 2: 校验用户故事 (SM - Bob) [必须] │
1183
+ │ ├─ 命令: /sm → *validate-create-story │
1184
+ │ ├─ 检查: 接受标准完整性、任务分解合理性、技术说明充分性 │
1185
+ │ ├─ 状态: drafted → ready-for-dev │
1186
+ │ └─ 🚨 门禁: 验证必须通过，失败则返回 STEP 1 修正 │
1187
+ │ │
1188
+ │ 🔴 STEP 3: 开发用户故事 (DEV - Amelia) [必须] │
1189
+ │ ├─ 命令: /dev → *develop-story │
1190
+ │ ├─ 前置: 必须有 ready-for-dev 状态的故事文件 │
982
1191
  │ ├─ 执行: TDD 驱动开发 (红-绿-重构) │
983
- │ └─ 状态: ready-for-dev → in-progress → review │
1192
+ │ ├─ 状态: ready-for-dev → in-progress │
1193
+ │ └─ 🚨 前置检查: 如果故事文件不存在或状态不对，必须先完成 STEP 1-2 │
1194
+ │ │
1195
+ │ 🔴 STEP 4: 自测用户故事 (DEV - Amelia) [必须] │
1196
+ │ ├─ 命令: 运行单元测试 (npm test / pytest / go test) │
1197
+ │ ├─ 检查: 所有测试必须 100% 通过 │
1198
+ │ ├─ 状态: in-progress → review │
1199
+ │ └─ 🚨 门禁: 测试未 100% 通过则不能进入 STEP 5，必须修复 │
984
1200
  │ │
985
- │ Step 4.2.3: 代码审查 (DEV - Amelia) │
986
- │ ├─ 调用: *code-review │
987
- │ ├─ 输入: review 状态的故事 │
988
- │ ├─ 审查: 功能正确性 + 代码质量 + 安全性 │
989
- │ └─ 状态: review → done (通过) 或 返回修复 │
1201
+ │ 🔴 STEP 5: 代码审查 + 集成测试 (DEV - Amelia) [必须] │
1202
+ │ ├─ 命令: /dev → *code-review │
1203
+ │ ├─ 审查: 功能正确性 + 代码质量 + 安全性 + 集成兼容性 │
1204
+ │ ├─ 结果: │
1205
+ │ │ ├─ APPROVED → 状态变为 done，故事完成 │
1206
+ │ │ └─ CHANGES_REQUESTED → 返回 STEP 3 修复 │
1207
+ │ └─ 🚨 门禁: 只有 APPROVED 才能标记 done │
1208
+ │ │
1209
+ │ ✅ 故事完成后，返回 STEP 1 处理下一个故事 │
990
1210
  │ │
991
1211
  └─────────────────────────────────────────────────────────────────────────────┘
992
1212
  ```
993
1213
 
1214
+ #### 📊 状态流转图 (5 步流程对应)
1215
+
1216
+ ```
1217
+ STEP 1 STEP 2
1218
+ ┌──────────────┐ ┌──────────────┐
1219
+ backlog ────│ *create-story │───▶│ *validate │───▶ ready-for-dev
1220
+ │ (SM) │ │ (SM) │
1221
+ └──────────────┘ └──────────────┘
1222
+ │
1223
+ │ STEP 3
1224
+ ▼
1225
+ ┌──────────────┐
1226
+ │ *develop-story│
1227
+ │ (DEV) │
1228
+ └──────────────┘
1229
+ │
1230
+ ▼
1231
+ in-progress
1232
+ │
1233
+ │ STEP 4 (自测)
1234
+ ▼
1235
+ ┌──────────────┐
1236
+ │ 运行单元测试 │
1237
+ │ 100% 通过 │
1238
+ └──────────────┘
1239
+ │
1240
+ ▼
1241
+ review
1242
+ │
1243
+ │ STEP 5
1244
+ ▼
1245
+ ┌──────────────┐
1246
+ ┌────────│ *code-review │────────┐
1247
+ │ │ (DEV) │ │
1248
+ │ └──────────────┘ │
1249
+ │ │
1250
+ APPROVED CHANGES_REQUESTED
1251
+ │ │
1252
+ ▼ │
1253
+ done ◄─────────────────────────────┘
1254
+ (返回 STEP 3)
1255
+ ```
1256
+
994
1257
  ---
995
1258
 
996
- #### Step 4.2.1: 故事准备 (create-story)
1259
+ #### Step 4.2.1: 🔴 STEP 1 - 创建用户故事 (create-story) [必须]
997
1260
 
998
1261
  **调用工作流**: `{xiaoma_folder}/xmc/workflows/4-implementation/create-story/workflow.yaml`
999
1262
 
1263
+ > ⚠️ **强制要求**: 此步骤为必须执行步骤，禁止跳过！必须生成故事文件后才能进入 STEP 2！
1264
+
1000
1265
  ---
1001
1266
 
1002
1267
  ##### 🤖 智能体执行指令
1003
1268
 
1004
1269
  ```
1005
1270
  ┌─────────────────────────────────────────────────────────────────┐
1006
- │ Step 4.2.1: 故事准备 │
1271
+ │ 🔴 STEP 1: 创建用户故事 [必须] │
1007
1272
  │ 智能体: Bob (SM) │
1008
1273
  ├─────────────────────────────────────────────────────────────────┤
1009
1274
  │ │
@@ -1015,20 +1280,22 @@ actions:
1015
1280
  │ │ 说明: 唤醒 Scrum Master Bob，准备创建故事文件 │ │
1016
1281
  │ └─────────────────────────────────────────────────────────┘ │
1017
1282
  │ │
1018
- │ 2. 创建故事文件 │
1283
+ │ 2. 🔴 创建故事文件 [必须] │
1019
1284
  │ ┌─────────────────────────────────────────────────────────┐ │
1020
1285
  │ │ 执行命令: *create-story │ │
1021
1286
  │ │ 说明: 从 Epic 中提取故事定义，创建独立的故事文件 │ │
1022
1287
  │ │ 输入: sprint-status.yaml + epics/*.md │ │
1023
- │ │ 输出: stories/{story-key}.md │ │
1024
- │ │ 状态: backlog → drafted → ready-for-dev │ │
1288
+ │ │ 输出: /sprint-artifacts/stories/{story-key}.md │ │
1289
+ │ │ 状态: backlog → drafted │ │
1025
1290
  │ └─────────────────────────────────────────────────────────┘ │
1026
1291
  │ │
1027
- │ 3. (推荐) 验证故事文件 │
1292
+ │ 🚨 门禁检查 (GATE 1): │
1028
1293
  │ ┌─────────────────────────────────────────────────────────┐ │
1029
- │ │ 执行命令: *validate-create-story │ │
1030
- │ │ 说明: 使用全新上下文验证故事质量 │ │
1031
- │ │ 建议: 使用不同的 LLM 以获得更客观的评估 │ │
1294
+ │ │ # 必须验证故事文件已创建 │ │
1295
+ │ │ ls -la {sprint_artifacts}/stories/{story-key}.md │ │
1296
+ │ │ │ │
1297
+ │ │ ❌ 如果文件不存在：禁止继续！必须先创建故事文件！ │ │
1298
+ │ │ ✅ 如果文件存在：可以进入 STEP 2 │ │
1032
1299
  │ └─────────────────────────────────────────────────────────┘ │
1033
1300
  │ │
1034
1301
  └─────────────────────────────────────────────────────────────────┘
@@ -1039,11 +1306,83 @@ actions:
1039
1306
  # 唤醒 SM 智能体
1040
1307
  /sm
1041
1308
 
1042
- # 创建故事文件
1309
+ # 🔴 [必须] 创建故事文件
1043
1310
  *create-story
1044
1311
 
1045
- # (推荐) 验证故事文件
1312
+ # 🚨 门禁检查：验证故事文件已创建
1313
+ ls -la {sprint_artifacts}/stories/{story-key}.md
1314
+ # 如果文件不存在，禁止继续！
1315
+ ```
1316
+
1317
+ ---
1318
+
1319
+ #### Step 4.2.2: 🔴 STEP 2 - 校验用户故事 (validate-story) [必须]
1320
+
1321
+ **调用工作流**: `{xiaoma_folder}/xmc/workflows/4-implementation/create-story/workflow.yaml` (validate-create-story)
1322
+
1323
+ > ⚠️ **强制要求**: 此步骤为必须执行步骤，禁止跳过！验证通过后才能进入 STEP 3！
1324
+
1325
+ ---
1326
+
1327
+ ##### 🤖 智能体执行指令
1328
+
1329
+ ```
1330
+ ┌─────────────────────────────────────────────────────────────────┐
1331
+ │ 🔴 STEP 2: 校验用户故事 [必须] │
1332
+ │ 智能体: Bob (SM) │
1333
+ ├─────────────────────────────────────────────────────────────────┤
1334
+ │ │
1335
+ │ 前置条件检查: │
1336
+ │ ┌─────────────────────────────────────────────────────────┐ │
1337
+ │ │ # 验证故事文件存在且状态为 drafted │ │
1338
+ │ │ grep "Status: drafted" {sprint_artifacts}/stories/*.md │ │
1339
+ │ │ │ │
1340
+ │ │ ❌ 如果没有 drafted 状态的故事：返回 STEP 1 │ │
1341
+ │ │ ✅ 如果存在：继续执行验证 │ │
1342
+ │ └─────────────────────────────────────────────────────────┘ │
1343
+ │ │
1344
+ │ 执行步骤: │
1345
+ │ │
1346
+ │ 1. 唤醒 SM 智能体 │
1347
+ │ ┌─────────────────────────────────────────────────────────┐ │
1348
+ │ │ 执行命令: /sm │ │
1349
+ │ │ 说明: 唤醒 Scrum Master Bob，准备验证故事 │ │
1350
+ │ └─────────────────────────────────────────────────────────┘ │
1351
+ │ │
1352
+ │ 2. 🔴 验证故事文件 [必须] │
1353
+ │ ┌─────────────────────────────────────────────────────────┐ │
1354
+ │ │ 执行命令: *validate-create-story │ │
1355
+ │ │ 说明: 验证故事质量，检查接受标准完整性 │ │
1356
+ │ │ 验证内容: │ │
1357
+ │ │ - 接受标准完整性 (Given-When-Then) │ │
1358
+ │ │ - 任务分解合理性 │ │
1359
+ │ │ - 技术说明充分性 │ │
1360
+ │ │ 状态: drafted → ready-for-dev │ │
1361
+ │ └─────────────────────────────────────────────────────────┘ │
1362
+ │ │
1363
+ │ 🚨 门禁检查 (GATE 2): │
1364
+ │ ┌─────────────────────────────────────────────────────────┐ │
1365
+ │ │ # 验证故事状态已更新为 ready-for-dev │ │
1366
+ │ │ grep "Status: ready-for-dev" {story-file} │ │
1367
+ │ │ │ │
1368
+ │ │ ❌ 验证未通过：返回 STEP 1 修正故事 │ │
1369
+ │ │ ✅ 验证通过：可以进入 STEP 3 │ │
1370
+ │ └─────────────────────────────────────────────────────────┘ │
1371
+ │ │
1372
+ └─────────────────────────────────────────────────────────────────┘
1373
+ ```
1374
+
1375
+ **执行命令**:
1376
+ ```bash
1377
+ # 唤醒 SM 智能体
1378
+ /sm
1379
+
1380
+ # 🔴 [必须] 验证故事文件
1046
1381
  *validate-create-story
1382
+
1383
+ # 🚨 门禁检查：验证故事状态已更新
1384
+ grep "Status: ready-for-dev" {sprint_artifacts}/stories/{story-key}.md
1385
+ # 如果状态不是 ready-for-dev，禁止继续！
1047
1386
  ```
1048
1387
 
1049
1388
  ---
@@ -1150,20 +1489,35 @@ So that [价值].
1150
1489
 
1151
1490
  ---
1152
1491
 
1153
- #### Step 4.2.2: 故事开发 (develop-story)
1492
+ #### Step 4.2.3: 🔴 STEP 3 - 开发用户故事 (develop-story) [必须]
1154
1493
 
1155
1494
  **调用工作流**: `{xiaoma_folder}/xmc/workflows/4-implementation/dev-story/workflow.yaml`
1156
1495
 
1496
+ > ⚠️ **强制要求**: 此步骤为必须执行步骤！必须基于 `/sprint-artifacts/stories/{story-key}.md` 故事文件进行开发！
1497
+
1498
+ > 🚨 **前置条件**: 必须存在状态为 `ready-for-dev` 的故事文件，否则必须返回 STEP 1-2 先创建并验证故事！
1499
+
1157
1500
  ---
1158
1501
 
1159
1502
  ##### 🤖 智能体执行指令
1160
1503
 
1161
1504
  ```
1162
1505
  ┌─────────────────────────────────────────────────────────────────┐
1163
- │ Step 4.2.2: 故事开发 │
1506
+ │ 🔴 STEP 3: 开发用户故事 [必须] │
1164
1507
  │ 智能体: Amelia (DEV) │
1165
1508
  ├─────────────────────────────────────────────────────────────────┤
1166
1509
  │ │
1510
+ │ 前置条件检查 (强制!): │
1511
+ │ ┌─────────────────────────────────────────────────────────┐ │
1512
+ │ │ # 🚨 必须验证故事文件存在且状态为 ready-for-dev │ │
1513
+ │ │ ls {sprint_artifacts}/stories/{story-key}.md │ │
1514
+ │ │ grep "Status: ready-for-dev" {story-file} │ │
1515
+ │ │ │ │
1516
+ │ │ ❌ 如果故事文件不存在：禁止开发！返回 STEP 1 │ │
1517
+ │ │ ❌ 如果状态不是 ready-for-dev：返回 STEP 1-2 │ │
1518
+ │ │ ✅ 如果存在且状态正确：继续开发 │ │
1519
+ │ └─────────────────────────────────────────────────────────┘ │
1520
+ │ │
1167
1521
  │ 执行步骤: │
1168
1522
  │ │
1169
1523
  │ 1. 唤醒 DEV 智能体 │
@@ -1172,37 +1526,55 @@ So that [价值].
1172
1526
  │ │ 说明: 唤醒开发者 Amelia，准备进行 TDD 开发 │ │
1173
1527
  │ └─────────────────────────────────────────────────────────┘ │
1174
1528
  │ │
1175
- │ 2. 执行故事开发工作流 │
1529
+ │ 2. 🔴 执行故事开发工作流 [必须] │
1176
1530
  │ ┌─────────────────────────────────────────────────────────┐ │
1177
1531
  │ │ 执行命令: *develop-story │ │
1178
- │ │ 说明: 执行 TDD 驱动的故事开发 │ │
1179
- │ │ 前置条件: 故事状态为 ready-for-dev │ │
1532
+ │ │ 说明: 基于故事文件执行 TDD 驱动开发 │ │
1533
+ │ │ 输入: /sprint-artifacts/stories/{story-key}.md │ │
1180
1534
  │ │ 执行流程: │ │
1181
1535
  │ │ - Step 4: 标记为 in-progress │ │
1182
1536
  │ │ - Step 5: TDD 实现 (红-绿-重构) │ │
1183
1537
  │ │ - Step 6: 编写全面测试 │ │
1184
1538
  │ │ - Step 7: 运行验证和测试 │ │
1185
1539
  │ │ - Step 8: 验证并标记任务完成 │ │
1186
- │ │ - Step 9: 标记为 review │ │
1187
- │ │ 状态: ready-for-dev → in-progress → review │ │
1540
+ │ │ 状态: ready-for-dev → in-progress │ │
1188
1541
  │ └─────────────────────────────────────────────────────────┘ │
1189
1542
  │ │
1190
- │ ⚠️ 关键规则: │
1191
- │ - 故事文件是唯一的事实来源 │
1192
- │ - 严格按照 Tasks/Subtasks 顺序执行 │
1193
- │ - 绝不实现故事文件中未定义的内容 │
1194
- │ - 每个任务完成前必须有测试覆盖 │
1195
- │ - 所有测试必须 100% 通过才能继续 │
1543
+ │ 🚨 关键规则 (绝对不能违反): │
1544
+ │ ┌─────────────────────────────────────────────────────────────┐ │
1545
+ │ │ ❌ 禁止基于 Epic 直接开发！必须基于 Story 文件！ │ │
1546
+ │ │ ❌ 禁止跳过故事文件验证！ │ │
1547
+ │ │ ✅ 故事文件是唯一的事实来源 │ │
1548
+ │ │ ✅ 严格按照 Tasks/Subtasks 顺序执行 │ │
1549
+ │ │ ✅ 绝不实现故事文件中未定义的内容 │ │
1550
+ │ │ ✅ 每个任务完成前必须有测试覆盖 │ │
1551
+ │ └─────────────────────────────────────────────────────────────┘ │
1552
+ │ │
1553
+ │ 🚨 门禁检查 (GATE 3): │
1554
+ │ ┌─────────────────────────────────────────────────────────┐ │
1555
+ │ │ # 开发完成后，必须验证: │ │
1556
+ │ │ 1. 故事状态已变为 in-progress │ │
1557
+ │ │ 2. 所有 Tasks 已有代码实现 │ │
1558
+ │ │ 3. 测试文件已创建 │ │
1559
+ │ │ │ │
1560
+ │ │ ❌ 开发未完成：不能进入 STEP 4 │ │
1561
+ │ │ ✅ 开发完成：可以进入 STEP 4 (自测) │ │
1562
+ │ └─────────────────────────────────────────────────────────┘ │
1196
1563
  │ │
1197
1564
  └─────────────────────────────────────────────────────────────────┘
1198
1565
  ```
1199
1566
 
1200
1567
  **执行命令**:
1201
1568
  ```bash
1569
+ # 🚨 前置检查：验证故事文件存在
1570
+ ls {sprint_artifacts}/stories/{story-key}.md
1571
+ grep "Status: ready-for-dev" {sprint_artifacts}/stories/{story-key}.md
1572
+ # 如果检查失败，禁止继续！必须返回 STEP 1-2
1573
+
1202
1574
  # 唤醒 DEV 智能体
1203
1575
  /dev
1204
1576
 
1205
- # 执行故事开发
1577
+ # 🔴 [必须] 执行故事开发 (基于故事文件！)
1206
1578
  *develop-story
1207
1579
  ```
1208
1580
 
@@ -1268,20 +1640,32 @@ mandatory_updates:
1268
1640
 
1269
1641
  ---
1270
1642
 
1271
- #### Step 4.2.3: 代码审查 (code-review)
1643
+ #### Step 4.2.4: 🔴 STEP 4 - 代码审查 (code-review) [必须]
1272
1644
 
1273
1645
  **调用工作流**: `{xiaoma_folder}/xmc/workflows/4-implementation/code-review/workflow.yaml`
1274
1646
 
1647
+ > ⚠️ **强制要求**: 此步骤为必须执行步骤！代码审查通过 (APPROVED) 后才能进入测试验证阶段！
1648
+
1275
1649
  ---
1276
1650
 
1277
1651
  ##### 🤖 智能体执行指令
1278
1652
 
1279
1653
  ```
1280
1654
  ┌─────────────────────────────────────────────────────────────────┐
1281
- │ Step 4.2.3: 代码审查 │
1655
+ │ 🔴 STEP 4: 代码审查 [必须] │
1282
1656
  │ 智能体: Amelia (DEV) │
1283
1657
  ├─────────────────────────────────────────────────────────────────┤
1284
1658
  │ │
1659
+ │ 前置条件检查: │
1660
+ │ ┌─────────────────────────────────────────────────────────┐ │
1661
+ │ │ # 验证故事状态为 in-progress 且单元测试已通过 │ │
1662
+ │ │ grep "Status: in-progress" {story-file} │ │
1663
+ │ │ # 验证所有单元测试已通过 (STEP 3 中执行) │ │
1664
+ │ │ │ │
1665
+ │ │ ❌ 如果状态不是 in-progress：返回 STEP 3 │ │
1666
+ │ │ ✅ 如果状态正确且测试通过：继续执行代码审查 │ │
1667
+ │ └─────────────────────────────────────────────────────────┘ │
1668
+ │ │
1285
1669
  │ 执行步骤: │
1286
1670
  │ │
1287
1671
  │ 1. 唤醒 DEV 智能体 (建议全新上下文) │
@@ -1291,21 +1675,36 @@ mandatory_updates:
1291
1675
  │ │ 建议: 使用全新上下文和不同 LLM 以获得更客观的评估 │ │
1292
1676
  │ └─────────────────────────────────────────────────────────┘ │
1293
1677
  │ │
1294
- │ 2. 执行代码审查工作流 │
1678
+ │ 2. 🔴 执行代码审查工作流 [必须] │
1295
1679
  │ ┌─────────────────────────────────────────────────────────┐ │
1296
1680
  │ │ 执行命令: *code-review │ │
1297
- │ │ 说明: 执行彻底的代码审查 │ │
1298
- │ │ 前置条件: 故事状态为 review │ │
1299
1681
  │ │ 审查维度: │ │
1300
1682
  │ │ - 功能正确性: 是否满足所有接受标准 │ │
1301
1683
  │ │ - 代码质量: 清晰可读、命名规范、遵循项目规范 │ │
1302
1684
  │ │ - 安全性: 注入风险、敏感数据处理、认证授权 │ │
1303
- │ │ - 性能: 性能问题、数据库查询、内存泄漏 │ │
1304
1685
  │ │ - 测试覆盖: 测试充分性、边界情况覆盖 │ │
1305
- │ │ │ │
1306
- │ │ 审查结果: │ │
1307
- │ │ - APPROVED: review → done │ │
1308
- │ │ - CHANGES_REQUESTED: review → in-progress (返回修复) │ │
1686
+ │ │ 状态: in-progress → review │ │
1687
+ │ └─────────────────────────────────────────────────────────┘ │
1688
+ │ │
1689
+ │ 🚨 审查结果处理: │
1690
+ │ ┌─────────────────────────────────────────────────────────┐ │
1691
+ │ │ APPROVED (通过): │ │
1692
+ │ │ - 状态更新为 review │ │
1693
+ │ │ - 继续到 STEP 5 (测试验证) │ │
1694
+ │ │ │ │
1695
+ │ │ CHANGES_REQUESTED (需修改): │ │
1696
+ │ │ - 返回 STEP 3 修复问题 │ │
1697
+ │ │ - 修复后重新执行 STEP 3-4 │ │
1698
+ │ └─────────────────────────────────────────────────────────┘ │
1699
+ │ │
1700
+ │ 🚨 门禁检查 (GATE 4): │
1701
+ │ ┌─────────────────────────────────────────────────────────┐ │
1702
+ │ │ # 代码审查结果验证 │ │
1703
+ │ │ 1. 审查结果必须为 APPROVED │ │
1704
+ │ │ 2. 故事状态已更新为 review │ │
1705
+ │ │ │ │
1706
+ │ │ ❌ 审查未通过：返回 STEP 3 修复！ │ │
1707
+ │ │ ✅ 审查通过：可以进入 STEP 5 (测试验证) │ │
1309
1708
  │ └─────────────────────────────────────────────────────────┘ │
1310
1709
  │ │
1311
1710
  └─────────────────────────────────────────────────────────────────┘
@@ -1316,8 +1715,12 @@ mandatory_updates:
1316
1715
  # 唤醒 DEV 智能体 (建议全新上下文)
1317
1716
  /dev
1318
1717
 
1319
- # 执行代码审查
1718
+ # 🔴 [必须] 执行代码审查
1320
1719
  *code-review
1720
+
1721
+ # 🚨 门禁检查：
1722
+ # - APPROVED: 继续到 STEP 5 (测试验证)
1723
+ # - CHANGES_REQUESTED: 返回 STEP 3 修复
1321
1724
  ```
1322
1725
 
1323
1726
  ---
@@ -1325,43 +1728,184 @@ mandatory_updates:
1325
1728
  ```yaml
1326
1729
  task: code_review
1327
1730
  role: DEV (Amelia)
1328
- agent_activation:
1329
- command: "/dev"
1330
- workflow: "*code-review"
1331
- recommendation: "使用全新上下文和不同 LLM 以获得更客观的评估"
1332
- invoke_workflow: "*code-review"
1731
+ mandatory: true
1333
1732
 
1334
1733
  precondition:
1335
- - sprint_status[story_key] == "review"
1734
+ - sprint_status[story_key] == "in-progress"
1735
+ - all_unit_tests_passed == true
1336
1736
 
1337
1737
  review_dimensions:
1338
- functionality:
1339
- - 是否满足所有接受标准
1340
- - 边界情况是否处理
1341
- - 异常处理是否完善
1738
+ - functionality: "是否满足所有接受标准"
1739
+ - code_quality: "清晰可读、命名规范、遵循项目规范"
1740
+ - security: "注入风险、敏感数据处理、认证授权"
1741
+ - test_coverage: "测试充分性、边界情况覆盖"
1742
+
1743
+ gate_check:
1744
+ pass_condition: "APPROVED"
1745
+ on_pass:
1746
+ - action: "更新故事状态: in-progress → review"
1747
+ - action: "编辑故事文件: Status: in-progress → Status: review"
1748
+ - next_step: "STEP 5 - 测试验证 (TEA)"
1749
+ on_fail:
1750
+ - action: "返回 STEP 3 修复"
1751
+ - next_step: "修复后重新执行 STEP 3-4"
1752
+ ```
1342
1753
 
1343
- code_quality:
1344
- - 代码是否清晰可读
1345
- - 命名是否规范
1346
- - 是否遵循项目规范
1754
+ ---
1347
1755
 
1348
- security:
1349
- - 是否存在注入风险
1350
- - 敏感数据处理
1351
- - 认证授权正确性
1756
+ #### Step 4.2.5: 🔴 STEP 5 - 测试验证 (test-verification) [必须]
1352
1757
 
1353
- performance:
1354
- - 是否有性能问题
1355
- - 数据库查询优化
1356
- - 内存泄漏风险
1758
+ **调用工作流**:
1759
+ - `{xiaoma_folder}/xmc/workflows/testarch/trace/workflow.yaml` (需求追溯)
1760
+ - `{xiaoma_folder}/xmc/workflows/testarch/test-review/workflow.yaml` (测试质量评审)
1761
+
1762
+ > ⚠️ **强制要求**: 此步骤为必须执行步骤！测试验证通过后才能标记故事为 done！这是故事生命周期的最后一步！
1763
+
1764
+ ---
1765
+
1766
+ ##### 🤖 智能体执行指令
1767
+
1768
+ ```
1769
+ ┌─────────────────────────────────────────────────────────────────┐
1770
+ │ 🔴 STEP 5: 测试验证 [必须] - 故事生命周期最后一步 │
1771
+ │ 智能体: Murat (TEA) │
1772
+ ├─────────────────────────────────────────────────────────────────┤
1773
+ │ │
1774
+ │ 前置条件检查: │
1775
+ │ ┌─────────────────────────────────────────────────────────┐ │
1776
+ │ │ # 验证故事状态为 review 且代码审查已通过 │ │
1777
+ │ │ grep "Status: review" {story-file} │ │
1778
+ │ │ │ │
1779
+ │ │ ❌ 如果状态不是 review：返回 STEP 4 完成代码审查 │ │
1780
+ │ │ ✅ 如果状态正确：继续执行测试验证 │ │
1781
+ │ └─────────────────────────────────────────────────────────┘ │
1782
+ │ │
1783
+ │ 执行步骤: │
1784
+ │ │
1785
+ │ 1. 唤醒 TEA 智能体 │
1786
+ │ ┌─────────────────────────────────────────────────────────┐ │
1787
+ │ │ 执行命令: /tea │ │
1788
+ │ │ 说明: 唤醒测试架构师 Murat，准备进行测试验证 │ │
1789
+ │ │ 建议: 使用全新上下文以获得更客观的测试评估 │ │
1790
+ │ └─────────────────────────────────────────────────────────┘ │
1791
+ │ │
1792
+ │ 2. 🔴 执行需求追溯验证 [必须] │
1793
+ │ ┌─────────────────────────────────────────────────────────┐ │
1794
+ │ │ 执行命令: *trace │ │
1795
+ │ │ 说明: 验证代码实现与需求的追溯关系 │ │
1796
+ │ │ 验证内容: │ │
1797
+ │ │ - 需求覆盖: 每个接受标准都有对应的代码实现 │ │
1798
+ │ │ - 测试覆盖: 每个接受标准都有对应的测试用例 │ │
1799
+ │ │ - 追溯完整: 需求 ↔ 代码 ↔ 测试 三向追溯 │ │
1800
+ │ │ - 无遗漏: 没有未实现的需求项 │ │
1801
+ │ └─────────────────────────────────────────────────────────┘ │
1802
+ │ │
1803
+ │ 3. 🔴 执行测试质量评审 [必须] │
1804
+ │ ┌─────────────────────────────────────────────────────────┐ │
1805
+ │ │ 执行命令: *test-review │ │
1806
+ │ │ 说明: 评审测试用例的质量和完整性 │ │
1807
+ │ │ 评审维度: │ │
1808
+ │ │ - 测试充分性: 测试用例是否覆盖所有场景 │ │
1809
+ │ │ - 边界测试: 边界条件和异常情况是否测试 │ │
1810
+ │ │ - 测试质量: 断言是否明确、测试是否独立 │ │
1811
+ │ │ - 集成测试: 模块间交互是否验证 │ │
1812
+ │ │ - 回归测试: 是否可防止功能退化 │ │
1813
+ │ └─────────────────────────────────────────────────────────┘ │
1814
+ │ │
1815
+ │ 🚨 验证结果处理: │
1816
+ │ ┌─────────────────────────────────────────────────────────┐ │
1817
+ │ │ PASS (通过): │ │
1818
+ │ │ - 状态: review → done │ │
1819
+ │ │ - 故事完成！处理下一个故事 │ │
1820
+ │ │ │ │
1821
+ │ │ FAIL (失败): │ │
1822
+ │ │ - 状态: review → in-progress │ │
1823
+ │ │ - 返回 STEP 3 修复问题 │ │
1824
+ │ │ - 修复后重新执行 STEP 3-5 │ │
1825
+ │ └─────────────────────────────────────────────────────────┘ │
1826
+ │ │
1827
+ │ 🚨 门禁检查 (GATE 5 - 最终门禁): │
1828
+ │ ┌─────────────────────────────────────────────────────────┐ │
1829
+ │ │ # 故事完成验证 │ │
1830
+ │ │ 1. 需求追溯完整 (*trace 通过) │ │
1831
+ │ │ 2. 测试质量达标 (*test-review 通过) │ │
1832
+ │ │ 3. 所有测试 100% 通过 │ │
1833
+ │ │ 4. 故事状态已更新为 done │ │
1834
+ │ │ │ │
1835
+ │ │ ❌ 验证未通过：返回 STEP 3 修复 │ │
1836
+ │ │ ✅ 验证通过：故事完成，处理下一个故事 │ │
1837
+ │ └─────────────────────────────────────────────────────────┘ │
1838
+ │ │
1839
+ └─────────────────────────────────────────────────────────────────┘
1840
+ ```
1841
+
1842
+ **执行命令**:
1843
+ ```bash
1844
+ # 🚨 前置检查：验证故事状态为 review
1845
+ grep "Status: review" {sprint_artifacts}/stories/{story-key}.md
1846
+ # 如果状态不是 review，禁止继续！必须返回 STEP 4
1847
+
1848
+ # 唤醒 TEA 智能体 (建议全新上下文)
1849
+ /tea
1850
+
1851
+ # 🔴 [必须] 执行需求追溯验证
1852
+ *trace
1853
+
1854
+ # 🔴 [必须] 执行测试质量评审
1855
+ *test-review
1856
+
1857
+ # 根据验证结果处理:
1858
+ # PASS → 故事完成，处理下一个故事
1859
+ # FAIL → 返回 STEP 3 修复
1860
+ ```
1357
1861
 
1358
- test_coverage:
1359
- - 测试是否充分
1360
- - 边界情况覆盖
1361
- - 测试可维护性
1862
+ ---
1362
1863
 
1363
- review_outcome:
1364
- APPROVED:
1864
+ ```yaml
1865
+ task: test_verification
1866
+ role: TEA (Murat)
1867
+ agent_activation:
1868
+ command: "/tea"
1869
+ workflows:
1870
+ - "*trace"
1871
+ - "*test-review"
1872
+ recommendation: "使用全新上下文以获得更客观的测试评估"
1873
+
1874
+ precondition:
1875
+ - sprint_status[story_key] == "review"
1876
+ - code_review_result == "APPROVED"
1877
+
1878
+ verification_steps:
1879
+ trace:
1880
+ workflow: "*trace"
1881
+ purpose: "需求追溯验证"
1882
+ checks:
1883
+ - 每个接受标准都有对应的代码实现
1884
+ - 每个接受标准都有对应的测试用例
1885
+ - 需求 ↔ 代码 ↔ 测试 三向追溯完整
1886
+ - 没有未实现的需求项
1887
+
1888
+ test_review:
1889
+ workflow: "*test-review"
1890
+ purpose: "测试质量评审"
1891
+ dimensions:
1892
+ test_adequacy:
1893
+ - 测试用例是否覆盖所有场景
1894
+ - 正常流程和异常流程是否都有测试
1895
+ boundary_testing:
1896
+ - 边界条件是否测试
1897
+ - 异常输入是否测试
1898
+ test_quality:
1899
+ - 断言是否明确
1900
+ - 测试是否独立可重复
1901
+ integration_testing:
1902
+ - 模块间交互是否验证
1903
+ - API 契约是否测试
1904
+ regression_prevention:
1905
+ - 是否可防止功能退化
1906
+
1907
+ verification_outcome:
1908
+ PASS:
1365
1909
  action: "更新状态为 done"
1366
1910
  update_sprint_status:
1367
1911
  story_key: "review → done"
@@ -1370,25 +1914,26 @@ review_outcome:
1370
1914
  - "编辑故事文件: Status: review → Status: done"
1371
1915
  - "编辑 sprint-status.yaml: story_key: review → story_key: done"
1372
1916
 
1373
- CHANGES_REQUESTED:
1917
+ FAIL:
1374
1918
  action: "生成修复任务，返回开发"
1375
- insert_review_followups: true
1376
- # DEV 智能体会在下次执行时处理审查反馈
1919
+ return_to_step: "STEP 3"
1377
1920
  # ⚠️ 强制执行以下操作！
1378
1921
  mandatory_updates:
1379
1922
  - "编辑故事文件: Status: review → Status: in-progress"
1380
1923
  - "编辑 sprint-status.yaml: story_key: review → story_key: in-progress"
1924
+ note: "修复后需要重新执行 STEP 3 → STEP 4 → STEP 5"
1381
1925
 
1382
1926
  best_practice: |
1383
- 建议使用不同的 LLM 执行代码审查以获得更客观的评估
1927
+ 建议使用全新上下文执行测试验证以获得更客观的评估
1384
1928
  ```
1385
1929
 
1386
1930
  ---
1387
1931
 
1388
- #### Step 4.2.4: 更新 Sprint 状态
1932
+ #### Step 4.2.6: 更新 Sprint 状态 (每个故事完成后)
1389
1933
 
1390
1934
  ```yaml
1391
1935
  task: update_sprint_status
1936
+ description: "每个故事完成 5 步流程后自动更新 Sprint 状态"
1392
1937
  after_each_story:
1393
1938
  - name: 更新故事状态
1394
1939
  file: "{sprint_artifacts}/sprint-status.yaml"
@@ -1453,11 +1998,12 @@ For Each Task in Story:
1453
1998
 
1454
1999
  ---
1455
2000
 
1456
- ### Step 5: 测试验证阶段 (Phase 5)
2001
+ ### Step 5: Sprint 收尾与最终报告 (Phase 5) [可选]
1457
2002
 
1458
- **角色激活**: TEA (测试架构师 - Murat)
2003
+ **角色激活**: TEA (测试架构师 - Murat) / SM (Scrum Master - Bob)
1459
2004
 
1460
- > **重要**: 本阶段集成 TEA 智能体的专用测试工作流，提供全面的测试验证能力。
2005
+ > **说明**: 本阶段为可选阶段，在所有用户故事完成后执行。用于生成 Sprint 级别的综合报告和收尾工作。
2006
+ > **注意**: 每个故事的测试验证已在 Phase 4 的 STEP 5 中由 TEA 完成，此阶段主要是 Sprint 级别的汇总。
1461
2007
 
1462
2008
  ---
1463
2009
 
@@ -1465,82 +2011,74 @@ For Each Task in Story:
1465
2011
 
1466
2012
  ```
1467
2013
  ┌─────────────────────────────────────────────────────────────────┐
1468
- │ Phase 5: 测试验证 │
1469
- │ 智能体: Murat (TEA) │
2014
+ │ Phase 5: Sprint 收尾与最终报告 [可选] │
2015
+ │ 智能体: TEA (Murat) / SM (Bob) │
1470
2016
  ├─────────────────────────────────────────────────────────────────┤
1471
2017
  │ │
1472
- │ Step 5.1: 唤醒 TEA 智能体 │
1473
- │ ┌─────────────────────────────────────────────────────────────┐│
1474
- │ │ 执行命令: /tea ││
1475
- │ │ 说明: 唤醒测试架构师 Murat，准备进行测试验证工作 ││
1476
- │ └─────────────────────────────────────────────────────────────┘│
1477
- │ │
1478
- │ Step 5.2: 需求追溯验证 │
1479
- │ ┌─────────────────────────────────────────────────────────────┐│
1480
- │ │ 执行命令: *trace ││
1481
- │ │ 说明: 构建需求到测试的追溯矩阵 ││
1482
- │ │ 输出: traceability-matrix.md ││
1483
- │ │ 验证: FR → Stories → Tests 映射完整性 ││
1484
- │ └─────────────────────────────────────────────────────────────┘│
2018
+ │ 前置条件检查: │
2019
+ │ ┌─────────────────────────────────────────────────────────┐ │
2020
+ │ │ # 验证所有故事状态为 done │ │
2021
+ │ │ # 如果存在未完成的故事，则不执行本阶段 │ │
2022
+ │ │ grep "Status: done" {sprint_artifacts}/stories/*.md │ │
2023
+ │ └─────────────────────────────────────────────────────────┘ │
1485
2024
  │ │
1486
- │ Step 5.3: 测试质量评审 │
2025
+ │ Step 5.1: 唤醒 TEA 智能体 (可选 - 生成质量报告) │
1487
2026
  │ ┌─────────────────────────────────────────────────────────────┐│
1488
- │ │ 执行命令: *test-review ││
1489
- │ │ 说明: 评审测试质量和充分性 ││
1490
- │ │ 检查: 测试充分性、测试质量、测试模式 ││
1491
- │ │ 输出: test-review-report.md ││
2027
+ │ │ 执行命令: /tea ││
2028
+ │ │ 说明: 唤醒测试架构师 Murat，生成 Sprint 级别质量报告 ││
1492
2029
  │ └─────────────────────────────────────────────────────────────┘│
1493
2030
  │ │
1494
- │ Step 5.4: NFR 验证 │
2031
+ │ Step 5.2: NFR 验证 (可选 - 非功能需求综合评估) │
1495
2032
  │ ┌─────────────────────────────────────────────────────────────┐│
1496
2033
  │ │ 执行命令: *nfr-assess ││
1497
- │ │ 说明: 验证非功能性需求 (性能、安全、可用性) ││
2034
+ │ │ 说明: 验证整个 Sprint 的非功能性需求 (性能、安全、可用性) ││
1498
2035
  │ │ 输出: nfr-assessment-report.md ││
1499
2036
  │ └─────────────────────────────────────────────────────────────┘│
1500
2037
  │ │
1501
- │ Step 5.5: (可选) 测试设计 │
1502
- │ ┌─────────────────────────────────────────────────────────────┐│
1503
- │ │ 执行命令: *test-design ││
1504
- │ │ 说明: 创建全面的测试场景 ││
1505
- │ └─────────────────────────────────────────────────────────────┘│
1506
- │ │
1507
- │ Step 5.6: (可选) 测试自动化 │
2038
+ │ Step 5.3: (可选) 测试自动化增强 │
1508
2039
  │ ┌─────────────────────────────────────────────────────────────┐│
1509
2040
  │ │ 执行命令: *automate ││
1510
- │ │ 说明: 生成全面的测试自动化代码 ││
2041
+ │ │ 说明: 生成额外的测试自动化代码 ││
1511
2042
  │ └─────────────────────────────────────────────────────────────┘│
1512
2043
  │ │
1513
- │ Step 5.7: (可选) CI/CD 流水线 │
2044
+ │ Step 5.4: (可选) CI/CD 流水线 │
1514
2045
  │ ┌─────────────────────────────────────────────────────────────┐│
1515
2046
  │ │ 执行命令: *ci ││
1516
2047
  │ │ 说明: 搭建 CI/CD 质量流水线脚手架 ││
1517
2048
  │ └─────────────────────────────────────────────────────────────┘│
1518
2049
  │ │
2050
+ │ Step 5.5: 生成 Sprint 最终报告 │
2051
+ │ ┌─────────────────────────────────────────────────────────────┐│
2052
+ │ │ 输出: sprint-summary-report.md ││
2053
+ │ │ 内容: ││
2054
+ │ │ - Sprint 执行摘要 ││
2055
+ │ │ - 故事完成统计 ││
2056
+ │ │ - 质量指标汇总 ││
2057
+ │ │ - 问题和经验教训 ││
2058
+ │ └─────────────────────────────────────────────────────────────┘│
2059
+ │ │
1519
2060
  └─────────────────────────────────────────────────────────────────┘
1520
2061
  ```
1521
2062
 
1522
- **完整执行序列**:
2063
+ **执行序列** (可选):
1523
2064
  ```bash
1524
- # 1. 唤醒 TEA 智能体
1525
- /tea
1526
-
1527
- # 2. 需求追溯验证
1528
- *trace
2065
+ # 前置检查：验证所有故事已完成
2066
+ # 如果有未完成的故事，跳过本阶段
1529
2067
 
1530
- # 3. 测试质量评审
1531
- *test-review
2068
+ # 1. (可选) 唤醒 TEA 智能体进行 Sprint 级别质量报告
2069
+ /tea
1532
2070
 
1533
- # 4. NFR 验证
2071
+ # 2. (可选) NFR 综合验证
1534
2072
  *nfr-assess
1535
2073
 
1536
- # 5. (可选) 测试设计
1537
- *test-design
1538
-
1539
- # 6. (可选) 测试自动化
2074
+ # 3. (可选) 测试自动化增强
1540
2075
  *automate
1541
2076
 
1542
- # 7. (可选) CI/CD 流水线
2077
+ # 4. (可选) CI/CD 流水线
1543
2078
  *ci
2079
+
2080
+ # 5. 生成 Sprint 最终报告
2081
+ # 自动生成 sprint-summary-report.md
1544
2082
  ```
1545
2083
 
1546
2084
  ---
@@ -1549,154 +2087,72 @@ For Each Task in Story:
1549
2087
 
1550
2088
  ```yaml
1551
2089
  phase: 5
1552
- name: 测试验证
1553
- role: TEA (Murat)
2090
+ name: Sprint 收尾与最终报告
2091
+ optional: true
2092
+ role: TEA (Murat) / SM (Bob)
2093
+ precondition:
2094
+ - all_stories_status == "done"
2095
+
1554
2096
  agent_activation:
1555
2097
  command: "/tea"
1556
- workflows:
1557
- - trigger: "*trace"
1558
- purpose: "需求到测试的追踪映射"
1559
- - trigger: "*test-review"
1560
- purpose: "测试质量评审"
2098
+ optional_workflows:
1561
2099
  - trigger: "*nfr-assess"
1562
- purpose: "非功能性需求验证"
1563
- - trigger: "*test-design"
1564
- purpose: "测试场景设计（可选）"
2100
+ purpose: "Sprint 级别非功能性需求验证"
1565
2101
  - trigger: "*automate"
1566
- purpose: "测试自动化（可选）"
2102
+ purpose: "测试自动化增强（可选）"
1567
2103
  - trigger: "*ci"
1568
2104
  purpose: "CI/CD 流水线（可选）"
2105
+
1569
2106
  inputs:
1570
- - 实现的代码
1571
- - 测试代码
1572
- - prd.md
1573
- - stories/
1574
- - architecture.md
2107
+ - 所有已完成的故事文件
2108
+ - 各故事的测试报告
2109
+ - sprint-status.yaml
1575
2110
  outputs:
1576
- - test-report.md
1577
- - quality-report.md
1578
- - traceability-matrix.md
1579
- - coverage-report/
1580
-
1581
- # 调用的 TEA 智能体工作流
1582
- workflows_invoked:
1583
- - agent: TEA (Murat)
1584
- workflow: trace
1585
- command: "/tea → *trace"
1586
- purpose: "需求到测试的追踪映射"
1587
- - agent: TEA (Murat)
1588
- workflow: test-review
1589
- command: "/tea → *test-review"
1590
- purpose: "测试质量评审"
1591
- - agent: TEA (Murat)
1592
- workflow: nfr-assess
1593
- command: "/tea → *nfr-assess"
1594
- purpose: "非功能性需求验证"
1595
- ```
1596
-
1597
- ---
1598
-
1599
- #### Step 5.1: 需求追溯验证
1600
-
1601
- **调用工作流**: `{xiaoma_folder}/xmc/workflows/testarch/trace/workflow.yaml`
1602
-
1603
- **执行命令**: `/tea → *trace`
1604
-
1605
- ```yaml
1606
- task: requirement_traceability
1607
- role: TEA (Murat)
1608
- agent_command: "/tea → *trace"
1609
- invoke_workflow: "*trace"
1610
-
1611
- actions:
1612
- - name: 构建追溯矩阵
1613
- map:
1614
- - FR → Stories → Tests
1615
- - AC → Test Cases
1616
- - NFR → Validation Tests
2111
+ - sprint-summary-report.md
2112
+ - nfr-assessment-report.md (可选)
1617
2113
 
1618
- - name: 验证覆盖完整性
1619
- check:
1620
- - 每个 FR 都有对应测试
1621
- - 每个 AC 都有对应测试用例
1622
- - 无遗漏的需求
2114
+ note: |
2115
+ 由于每个故事已在 Phase 4 的 STEP 5 中完成 TEA 测试验证：
2116
+ - *trace (需求追溯)
2117
+ - *test-review (测试质量评审)
1623
2118
 
1624
- - name: 生成追溯报告
1625
- output: "traceability-matrix.md"
2119
+ 本阶段主要做 Sprint 级别的汇总和可选的增强工作。
1626
2120
  ```
1627
2121
 
1628
2122
  ---
1629
2123
 
1630
- #### Step 5.2: 执行测试套件
2124
+ #### Step 5.1: Sprint 级别质量汇总
1631
2125
 
1632
2126
  ```yaml
1633
- task: execute_test_suites
1634
- actions:
1635
- - name: 运行单元测试
1636
- command: "npm run test:unit"
1637
- collect:
1638
- - 通过/失败数量
1639
- - 覆盖率报告
1640
- - 失败详情
1641
-
1642
- - name: 运行集成测试
1643
- command: "npm run test:integration"
1644
- collect:
1645
- - 通过/失败数量
1646
- - API 测试结果
1647
- - 数据库测试结果
1648
-
1649
- - name: 运行端到端测试
1650
- command: "npm run test:e2e"
1651
- if: e2e_tests_exist
1652
- collect:
1653
- - 通过/失败数量
1654
- - 用户流程测试结果
1655
- ```
1656
-
1657
- ---
1658
-
1659
- #### Step 5.3: 测试质量评审
2127
+ task: sprint_quality_summary
2128
+ optional: true
2129
+ role: TEA (Murat)
2130
+ description: "汇总所有故事的测试验证结果，生成 Sprint 级别报告"
1660
2131
 
1661
- **调用工作流**: `{xiaoma_folder}/xmc/workflows/testarch/test-review/workflow.yaml`
2132
+ aggregation:
2133
+ - name: 故事完成统计
2134
+ metrics:
2135
+ total_stories: count(stories)
2136
+ completed_stories: count(stories where status == "done")
2137
+ completion_rate: completed_stories / total_stories * 100%
1662
2138
 
1663
- **执行命令**: `/tea → *test-review`
2139
+ - name: 测试覆盖汇总
2140
+ metrics:
2141
+ total_tests: sum(story.test_count)
2142
+ passed_tests: sum(story.passed_tests)
2143
+ pass_rate: passed_tests / total_tests * 100%
2144
+ coverage: average(story.coverage)
1664
2145
 
1665
- ```yaml
1666
- task: test_quality_review
1667
- role: TEA (Murat)
1668
- agent_command: "/tea → *test-review"
1669
- invoke_workflow: "*test-review"
1670
-
1671
- review_criteria:
1672
- - name: 测试充分性
1673
- check:
1674
- - 关键路径是否覆盖
1675
- - 边界条件是否测试
1676
- - 异常场景是否覆盖
1677
-
1678
- - name: 测试质量
1679
- check:
1680
- - 测试是否独立
1681
- - 断言是否明确
1682
- - 测试是否可维护
1683
-
1684
- - name: 测试模式
1685
- check:
1686
- - AAA 模式 (Arrange-Act-Assert)
1687
- - 单一职责
1688
- - 无硬编码依赖
1689
-
1690
- output:
1691
- test_review_report:
1692
- score: "[A-F]"
1693
- issues: []
1694
- recommendations: []
2146
+ - name: 质量指标汇总
2147
+ metrics:
2148
+ code_review_issues: sum(story.review_issues)
2149
+ bugs_found: count(bugs)
2150
+ bugs_fixed: count(bugs where status == "fixed")
1695
2151
  ```
1696
2152
 
1697
2153
  ---
1698
2154
 
1699
- #### Step 5.4: NFR 验证
2155
+ #### Step 5.2: NFR 综合验证 (可选)
1700
2156
 
1701
2157
  **调用工作流**: `{xiaoma_folder}/xmc/workflows/testarch/nfr-assess/workflow.yaml`
1702
2158
 
@@ -1705,9 +2161,12 @@ output:
1705
2161
  ```yaml
1706
2162
  task: nfr_validation
1707
2163
  role: TEA (Murat)
2164
+ optional: true
1708
2165
  agent_command: "/tea → *nfr-assess"
1709
2166
  invoke_workflow: "*nfr-assess"
1710
2167
 
2168
+ description: "Sprint 级别的非功能性需求综合评估"
2169
+
1711
2170
  validations:
1712
2171
  performance:
1713
2172
  - nfr_id: "NFR-PERF-001"
@@ -1723,10 +2182,6 @@ validations:
1723
2182
  requirement: "所有 API 需要认证"
1724
2183
  test_method: "安全扫描"
1725
2184
 
1726
- - nfr_id: "NFR-SEC-002"
1727
- requirement: "敏感数据加密传输"
1728
- test_method: "HTTPS 验证"
1729
-
1730
2185
  usability:
1731
2186
  - nfr_id: "NFR-USA-001"
1732
2187
  requirement: "支持响应式布局"
@@ -1735,79 +2190,43 @@ validations:
1735
2190
 
1736
2191
  ---
1737
2192
 
1738
- #### Step 5.5: 质量门禁检查
1739
-
1740
- ```yaml
1741
- task: quality_gate_check
1742
- actions:
1743
- - name: 代码覆盖率检查
1744
- threshold:
1745
- statements: ">= 80%"
1746
- branches: ">= 75%"
1747
- functions: ">= 85%"
1748
- lines: ">= 80%"
1749
-
1750
- - name: 代码质量检查
1751
- run: "npm run lint"
1752
- threshold:
1753
- errors: 0
1754
- warnings: "<= 10"
1755
-
1756
- - name: 安全扫描
1757
- run: "npm audit"
1758
- threshold:
1759
- critical: 0
1760
- high: 0
1761
-
1762
- - name: 类型检查
1763
- run: "npm run type-check"
1764
- threshold:
1765
- errors: 0
1766
-
1767
- - name: 构建验证
1768
- run: "npm run build"
1769
- threshold:
1770
- success: true
1771
- ```
1772
-
1773
- ---
1774
-
1775
- #### Step 5.6: 生成测试报告
2193
+ #### Step 5.3: 生成 Sprint 最终报告
1776
2194
 
1777
2195
  ```yaml
1778
- task: generate_reports
2196
+ task: generate_sprint_report
1779
2197
  outputs:
1780
- - name: test-report.md
2198
+ - name: sprint-summary-report.md
1781
2199
  content:
1782
- - 执行摘要
1783
- - 测试执行详情
1784
- - 代码覆盖率
1785
- - 需求追溯
1786
- - 问题和建议
1787
-
1788
- - name: quality-report.md
1789
- content:
1790
- - 质量门禁结果
1791
- - 代码质量分析
1792
- - 安全扫描结果
1793
- - NFR 验证结果
1794
-
1795
- - name: traceability-matrix.md
1796
- content:
1797
- - FR → Story → Test 映射
1798
- - AC → Test Case 映射
1799
- - 覆盖率统计
2200
+ - Sprint 执行摘要
2201
+ - Sprint 目标
2202
+ - 计划 vs 实际完成
2203
+ - 关键成果
2204
+ - 故事完成详情
2205
+ - 已完成故事列表
2206
+ - 各故事状态
2207
+ - 工作量统计
2208
+ - 质量指标
2209
+ - 测试通过率
2210
+ - 代码覆盖率
2211
+ - 代码审查结果
2212
+ - 问题和风险
2213
+ - 遇到的阻塞问题
2214
+ - 解决方案
2215
+ - 遗留问题
2216
+ - 经验教训
2217
+ - 做得好的方面
2218
+ - 需要改进的方面
2219
+ - 下个 Sprint 建议
1800
2220
  ```
1801
2221
 
1802
2222
  ---
1803
2223
 
1804
- **质量门禁**:
1805
- - [ ] 测试覆盖率 >= 80%
1806
- - [ ] 所有测试通过 (100%)
1807
- - [ ] 无严重安全漏洞 (0 critical/high)
1808
- - [ ] 代码质量评分 >= B
1809
- - [ ] NFR 验证通过
1810
- - [ ] 需求追溯完整 (100%)
2224
+ **Sprint 完成检查清单**:
2225
+ - [ ] 所有故事状态为 done
2226
+ - [ ] 所有测试验证通过 (Phase 4 STEP 5)
2227
+ - [ ] sprint-status.yaml 已更新
2228
+ - [ ] Sprint 最终报告已生成 (可选)
2229
+ - [ ] NFR 验证通过 (可选)
1811
2230
 
1812
2231
  ---
1813
2232