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

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@zeyue0329/xiaoma-cli",
-  "version": "6.0.0-alpha.16",
+  "version": "6.0.0-alpha.17",
   "description": "XiaoMa Cli: Universal AI Agent Framework",
   "keywords": [
     "agile",

package/src/modules/xmc/workflows/auto-iteration/full-auto-workflow.md

@@ -6,6 +6,24 @@
 
 ---
 
+## 智能体命令快速参考
+
+> **重要**: 本工作流通过唤醒专业智能体并执行其特定命令来完成各阶段任务。
+
+### 智能体命令汇总表
+
+| 智能体 | 唤醒命令 | 核心工作流命令 | 用途 |
+|--------|---------|---------------|------|
+| Mary (Analyst) | `/analyst` | `*product-brief`, `*research` | 需求分析、业务规则匹配 |
+| John (PM) | `/pm` | `*create-prd`, `*create-epics-and-stories` | PRD 创建、史诗故事定义 |
+| Winston (Architect) | `/architect` | `*create-architecture`, `*validate-architecture` | 架构设计、技术决策 |
+| Bob (SM) | `/sm` | `*sprint-planning`, `*create-story` | Sprint 规划、故事准备 |
+| Amelia (DEV) | `/dev` | `*develop-story`, `*code-review` | TDD 开发、代码审查 |
+| Murat (TEA) | `/tea` | `*trace`, `*test-review`, `*nfr-assess` | 测试追溯、质量验证 |
+| Phoenix (Orchestrator) | `/phoenix` | `*auto-iterate`, `*phase-*` | 全自动编排 |
+
+---
+
 ## 知识库集成
 
 ### 知识库配置
@@ -237,20 +255,83 @@ confidence: "high"
 
 **角色激活**: Analyst (需求分析师)
 
+---
+
+#### 🤖 智能体执行指令
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Phase 1: 需求分析                                               │
+│  智能体: Mary (Analyst)                                          │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Step 1.1: 唤醒 Analyst 智能体                                   │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: /analyst                                          ││
+│  │ 说明: 唤醒业务分析师 Mary，准备进行需求分析工作                ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 1.2: 执行产品简报/调研工作流                                │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *product-brief                                    ││
+│  │ 说明: 基于迭代需求文档，创建结构化的产品简报                   ││
+│  │ 输入: 迭代需求文档内容                                        ││
+│  │ 输出: product-brief.md                                      ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 1.3: (可选) 执行深度调研                                   │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *research                                         ││
+│  │ 说明: 针对复杂需求进行市场/竞品/技术调研                      ││
+│  │ 触发条件: 需求涉及新业务领域或技术栈                          ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 1.4: 生成需求分析报告                                      │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 基于 *product-brief 输出，整理为 requirement-analysis.md    ││
+│  │ 确保包含: 功能点清单、业务规则、隐含需求、约束和风险          ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**完整执行序列**:
+```bash
+# 1. 唤醒 Analyst 智能体
+/analyst
+
+# 2. 执行产品简报工作流
+*product-brief
+
+# 3. (可选) 执行深度调研
+*research
+```
+
+---
+
 **自动执行内容**:
 
 ```yaml
 phase: 1
 name: 需求分析
-role: Analyst
+role: Analyst (Mary)
+agent_activation:
+  command: "/analyst"
+  workflows:
+    - trigger: "*product-brief"
+      purpose: "创建产品简报，提取核心需求"
+    - trigger: "*research"
+      purpose: "深度调研（可选）"
+      condition: "需求涉及新业务领域时执行"
 inputs:
   - 迭代需求文档
   - 业务知识库
 outputs:
-  - requirement-analysis.md
+  - requirement-analysis.md (基于 product-brief 整理)
 
 tasks:
   - name: 解析需求文档
+    agent_command: "/analyst → *product-brief"
     action: |
       1. 读取需求文档全文
       2. 提取功能点列表
@@ -314,22 +395,94 @@ tasks:
 
 **角色激活**: PM (产品经理) + PO (产品负责人)
 
+---
+
+#### 🤖 智能体执行指令
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Phase 2: 需求规划                                               │
+│  智能体: John (PM)                                               │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Step 2.1: 唤醒 PM 智能体                                        │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: /pm                                               ││
+│  │ 说明: 唤醒产品经理 John，准备进行需求规划工作                  ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 2.2: 创建 PRD 文档                                         │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *create-prd                                       ││
+│  │ 说明: 基于需求分析报告，创建完整的产品需求文档                 ││
+│  │ 输入: requirement-analysis.md / product-brief.md            ││
+│  │ 输出: prd.md                                                ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 2.3: (推荐) 验证 PRD                                       │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *validate-prd                                     ││
+│  │ 说明: 使用全新上下文和不同 LLM 验证 PRD 质量                  ││
+│  │ 建议: 使用不同的 LLM 以获得更客观的评估                       ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 2.4: 创建史诗和故事定义                                    │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *create-epics-and-stories                         ││
+│  │ 说明: 从 PRD 创建史诗和用户故事（在架构完成后执行）           ││
+│  │ 输入: prd.md + architecture.md                              ││
+│  │ 输出: epics/epic-XXX.md                                     ││
+│  │ ⚠️ 注意: 故事定义写在 Epic 文件中，独立故事文件在 Phase 4    ││
+│  │         由 SM 的 *create-story 创建                          ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**完整执行序列**:
+```bash
+# 1. 唤醒 PM 智能体
+/pm
+
+# 2. 创建 PRD 文档
+*create-prd
+
+# 3. (推荐) 验证 PRD
+*validate-prd
+
+# 4. 创建史诗和故事定义 (需在架构设计后执行)
+*create-epics-and-stories
+```
+
+---
+
 **自动执行内容**:
 
 ```yaml
 phase: 2
 name: 需求规划
-role: PM + PO
+role: PM (John) + PO
+agent_activation:
+  command: "/pm"
+  workflows:
+    - trigger: "*create-prd"
+      purpose: "创建产品需求文档"
+    - trigger: "*validate-prd"
+      purpose: "验证 PRD 质量（推荐）"
+    - trigger: "*create-epics-and-stories"
+      purpose: "创建史诗和故事定义"
+      prerequisite: "需在架构设计完成后执行"
 inputs:
   - requirement-analysis.md
   - 业务知识库
 outputs:
   - prd.md
-  - epics/
-  - stories/
+  - epics/epic-XXX.md  # 包含故事定义的 Epic 文件
+  # 注意: 独立故事文件将在 Phase 4 由 *create-story 创建
 
 tasks:
   - name: 创建 PRD
+    agent_command: "/pm → *create-prd"
     action: |
       1. 基于需求分析报告创建 PRD
       2. 定义产品目标和成功指标
@@ -337,20 +490,22 @@ tasks:
       4. 定义非功能需求 (NFR)
     output: prd.md
 
-  - name: 创建史诗
+  - name: 创建史诗文件（包含故事定义）
+    agent_command: "/pm → *create-epics-and-stories"
     action: |
       1. 将功能需求按模块分组为史诗
       2. 定义每个史诗的业务价值
       3. 确定史诗间的依赖关系
-    output: epics/
-
-  - name: 分解用户故事
-    action: |
-      1. 将每个史诗分解为用户故事
-      2. 使用 INVEST 原则验证故事质量
-      3. 定义接受标准 (Given/When/Then)
-      4. 估算故事点
-    output: stories/
+      4. ⚠️ 重要: 故事定义写在 Epic 文件中，不单独创建故事文件
+      5. 故事文件将在 Phase 4 由 SM *create-story 工作流创建
+    output: epics/epic-XXX.md
+    note: |
+      ⚠️ Phase 2 不创建独立的故事文件！
+      故事的详细定义（用户故事、接受标准、任务分解）应写在 Epic 文件中。
+      Phase 4 的 *create-story 工作流会：
+      1. 从 Epic 文件提取故事定义
+      2. 创建符合 DEV 智能体格式的故事文件
+      3. 自动设置正确的 Status: drafted
 
   - name: PO 验收标准审核
     action: |
@@ -401,12 +556,98 @@ tasks:
 
 **角色激活**: Architect (架构师)
 
+---
+
+#### 🤖 智能体执行指令
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Phase 3: 架构设计                                               │
+│  智能体: Winston (Architect)                                     │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Step 3.1: 唤醒 Architect 智能体                                 │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: /architect                                        ││
+│  │ 说明: 唤醒架构师 Winston，准备进行架构设计工作                 ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 3.2: 创建架构文档                                          │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *create-architecture                              ││
+│  │ 说明: 基于 PRD 创建完整的架构设计文档                         ││
+│  │ 输入: prd.md + 现有代码库                                    ││
+│  │ 输出: architecture.md + adr/                                ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 3.3: (推荐) 验证架构                                       │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *validate-architecture                            ││
+│  │ 说明: 使用全新上下文和不同 LLM 验证架构设计                   ││
+│  │ 建议: 使用不同的 LLM 以获得更客观的评估                       ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 3.4: (可选) 实现准备验证                                   │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *implementation-readiness                         ││
+│  │ 说明: 验证 PRD、UX、架构、史诗和故事是否对齐                  ││
+│  │ 建议: 在进入 Phase 4 开发前执行此验证                        ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 3.5: (可选) 创建架构图                                     │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *create-excalidraw-diagram                        ││
+│  │ 说明: 创建系统架构图或技术图表                                ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 3.6: (可选) 创建数据流图                                   │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *create-excalidraw-dataflow                       ││
+│  │ 说明: 创建数据流图                                           ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**完整执行序列**:
+```bash
+# 1. 唤醒 Architect 智能体
+/architect
+
+# 2. 创建架构文档
+*create-architecture
+
+# 3. (推荐) 验证架构
+*validate-architecture
+
+# 4. (可选) 实现准备验证
+*implementation-readiness
+
+# 5. (可选) 创建架构图
+*create-excalidraw-diagram
+```
+
+---
+
 **自动执行内容**:
 
 ```yaml
 phase: 3
 name: 架构设计
-role: Architect
+role: Architect (Winston)
+agent_activation:
+  command: "/architect"
+  workflows:
+    - trigger: "*create-architecture"
+      purpose: "创建架构设计文档"
+    - trigger: "*validate-architecture"
+      purpose: "验证架构设计（推荐）"
+    - trigger: "*implementation-readiness"
+      purpose: "实现准备验证（可选）"
+    - trigger: "*create-excalidraw-diagram"
+      purpose: "创建架构图（可选）"
+    - trigger: "*create-excalidraw-dataflow"
+      purpose: "创建数据流图（可选）"
 inputs:
   - prd.md
   - epics/
@@ -418,6 +659,7 @@ outputs:
 
 tasks:
   - name: 分析现有架构
+    agent_command: "/architect → *create-architecture (Step 1)"
     action: |
       1. 扫描目标代码库结构
       2. 识别现有技术栈
@@ -425,6 +667,7 @@ tasks:
       4. 识别可复用组件
 
   - name: 设计技术方案
+    agent_command: "/architect → *create-architecture (Step 2)"
     action: |
       1. 基于 PRD 设计技术实现方案
       2. 匹配技术知识库中的最佳实践
@@ -432,12 +675,14 @@ tasks:
       4. 设计 API 接口
 
   - name: 数据模型设计
+    agent_command: "/architect → *create-architecture (Step 3)"
     action: |
       1. 设计新增/变更的数据表
       2. 创建 ER 图
       3. 设计数据迁移策略
 
   - name: 技术决策记录
+    agent_command: "/architect → *create-architecture (Step 4)"
     action: |
       1. 记录关键技术选型
       2. 记录选型理由和权衡
@@ -491,6 +736,92 @@ tasks:
 
 > **重要**: 本阶段严格遵循项目智能体的标准工作流，确保与 SM 和 DEV 智能体的完全兼容。
 
+---
+
+#### 🤖 智能体执行指令概览
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Phase 4: 开发实现                                               │
+│  智能体: Bob (SM) + Amelia (DEV)                                 │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  阶段流程概览:                                                    │
+│                                                                  │
+│  ┌──────────────────────────────────────────────────────────────┐
+│  │ Step 4.1: Sprint 规划 (SM)                                   │
+│  │ ┌────────────────────────────────────────────────────────┐   │
+│  │ │ 执行: /sm → *sprint-planning                           │   │
+│  │ │ 输出: sprint-status.yaml                               │   │
+│  │ └────────────────────────────────────────────────────────┘   │
+│  └──────────────────────────────────────────────────────────────┘
+│                              ↓                                   │
+│  ┌──────────────────────────────────────────────────────────────┐
+│  │ Step 4.2: For Each Story 循环                                │
+│  │                                                              │
+│  │   Step 4.2.1: 故事准备 (SM)                                  │
+│  │   ┌────────────────────────────────────────────────────┐     │
+│  │   │ 执行: /sm → *create-story                          │     │
+│  │   │ 状态: backlog → drafted → ready-for-dev            │     │
+│  │   └────────────────────────────────────────────────────┘     │
+│  │                         ↓                                    │
+│  │   Step 4.2.2: 故事开发 (DEV)                                 │
+│  │   ┌────────────────────────────────────────────────────┐     │
+│  │   │ 执行: /dev → *develop-story                        │     │
+│  │   │ 状态: ready-for-dev → in-progress → review         │     │
+│  │   └────────────────────────────────────────────────────┘     │
+│  │                         ↓                                    │
+│  │   Step 4.2.3: 代码审查 (DEV)                                 │
+│  │   ┌────────────────────────────────────────────────────┐     │
+│  │   │ 执行: /dev → *code-review                          │     │
+│  │   │ 状态: review → done (通过) 或 返回修复              │     │
+│  │   └────────────────────────────────────────────────────┘     │
+│  │                                                              │
+│  └──────────────────────────────────────────────────────────────┘
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**完整执行序列**:
+```bash
+# === Step 4.1: Sprint 规划 ===
+# 1. 唤醒 SM 智能体
+/sm
+
+# 2. 执行 Sprint 规划
+*sprint-planning
+
+# === Step 4.2: 故事开发循环 (对每个故事重复) ===
+
+# --- Step 4.2.1: 故事准备 (SM) ---
+# 3. 唤醒 SM 智能体 (如果不在当前上下文)
+/sm
+
+# 4. 创建故事文件
+*create-story
+
+# 5. (推荐) 验证故事
+*validate-create-story
+
+# --- Step 4.2.2: 故事开发 (DEV) ---
+# 6. 唤醒 DEV 智能体
+/dev
+
+# 7. 执行故事开发
+*develop-story
+
+# --- Step 4.2.3: 代码审查 (DEV) ---
+# 8. 唤醒 DEV 智能体 (建议使用全新上下文)
+/dev
+
+# 9. 执行代码审查
+*code-review
+
+# --- 重复 Step 4.2 直到所有故事完成 ---
+```
+
+---
+
 **故事状态定义** (与 SM 智能体一致):
 
 ```yaml
@@ -548,9 +879,52 @@ workflows_invoked:
 
 **调用工作流**: `{xiaoma_folder}/xmc/workflows/4-implementation/sprint-planning/workflow.yaml`
 
+---
+
+##### 🤖 智能体执行指令
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Step 4.1: Sprint 规划                                          │
+│  智能体: Bob (SM)                                                │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  执行步骤:                                                        │
+│                                                                  │
+│  1. 唤醒 SM 智能体                                               │
+│     ┌─────────────────────────────────────────────────────────┐ │
+│     │ 执行命令: /sm                                           │ │
+│     │ 说明: 唤醒 Scrum Master Bob，准备进行 Sprint 规划        │ │
+│     └─────────────────────────────────────────────────────────┘ │
+│                                                                  │
+│  2. 执行 Sprint 规划工作流                                       │
+│     ┌─────────────────────────────────────────────────────────┐ │
+│     │ 执行命令: *sprint-planning                              │ │
+│     │ 说明: 分析 Epic 文件，生成 sprint-status.yaml           │ │
+│     │ 输入: epics/*.md                                        │ │
+│     │ 输出: sprint-status.yaml                                │ │
+│     └─────────────────────────────────────────────────────────┘ │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**执行命令**:
+```bash
+# 唤醒 SM 智能体
+/sm
+
+# 执行 Sprint 规划
+*sprint-planning
+```
+
+---
+
 ```yaml
 task: sprint_planning
 role: SM (Bob)
+agent_activation:
+  command: "/sm"
+  workflow: "*sprint-planning"
 invoke_workflow: "*sprint-planning"
 actions:
   - name: 分析 Epic 文件
@@ -623,9 +997,67 @@ actions:
 
 **调用工作流**: `{xiaoma_folder}/xmc/workflows/4-implementation/create-story/workflow.yaml`
 
+---
+
+##### 🤖 智能体执行指令
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Step 4.2.1: 故事准备                                            │
+│  智能体: Bob (SM)                                                │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  执行步骤:                                                        │
+│                                                                  │
+│  1. 唤醒 SM 智能体                                               │
+│     ┌─────────────────────────────────────────────────────────┐ │
+│     │ 执行命令: /sm                                           │ │
+│     │ 说明: 唤醒 Scrum Master Bob，准备创建故事文件            │ │
+│     └─────────────────────────────────────────────────────────┘ │
+│                                                                  │
+│  2. 创建故事文件                                                  │
+│     ┌─────────────────────────────────────────────────────────┐ │
+│     │ 执行命令: *create-story                                 │ │
+│     │ 说明: 从 Epic 中提取故事定义，创建独立的故事文件          │ │
+│     │ 输入: sprint-status.yaml + epics/*.md                   │ │
+│     │ 输出: stories/{story-key}.md                            │ │
+│     │ 状态: backlog → drafted → ready-for-dev                 │ │
+│     └─────────────────────────────────────────────────────────┘ │
+│                                                                  │
+│  3. (推荐) 验证故事文件                                          │
+│     ┌─────────────────────────────────────────────────────────┐ │
+│     │ 执行命令: *validate-create-story                        │ │
+│     │ 说明: 使用全新上下文验证故事质量                          │ │
+│     │ 建议: 使用不同的 LLM 以获得更客观的评估                   │ │
+│     └─────────────────────────────────────────────────────────┘ │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**执行命令**:
+```bash
+# 唤醒 SM 智能体
+/sm
+
+# 创建故事文件
+*create-story
+
+# (推荐) 验证故事文件
+*validate-create-story
+```
+
+---
+
 ```yaml
 task: prepare_story
 role: SM (Bob)
+agent_activation:
+  command: "/sm"
+  workflows:
+    - trigger: "*create-story"
+      purpose: "创建故事文件"
+    - trigger: "*validate-create-story"
+      purpose: "验证故事（推荐）"
 invoke_workflow: "*create-story"
 
 for_each: story in sprint_status.development_status
@@ -664,9 +1096,13 @@ actions:
 
 **故事文件格式** (符合 DEV 智能体要求):
 
+> ⚠️ **关键**: 必须包含 `Status:` 行，且位于标题之后！
+
 ```markdown
 # Story: {story-key}
 
+Status: drafted
+
 ## Story
 As a [用户角色],
 I want [功能],
@@ -707,20 +1143,77 @@ So that [价值].
 
 ## Change Log
 [变更日志]
-
-## Status
-drafted  <!-- 将更新为: ready-for-dev → in-progress → review → done -->
 ```
 
+> **注意**: `Status:` 行位于文件顶部（标题之后），不是在底部！
+> 状态值将随开发进度更新: `drafted → ready-for-dev → in-progress → review → done`
+
 ---
 
 #### Step 4.2.2: 故事开发 (develop-story)
 
 **调用工作流**: `{xiaoma_folder}/xmc/workflows/4-implementation/dev-story/workflow.yaml`
 
+---
+
+##### 🤖 智能体执行指令
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Step 4.2.2: 故事开发                                            │
+│  智能体: Amelia (DEV)                                            │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  执行步骤:                                                        │
+│                                                                  │
+│  1. 唤醒 DEV 智能体                                              │
+│     ┌─────────────────────────────────────────────────────────┐ │
+│     │ 执行命令: /dev                                          │ │
+│     │ 说明: 唤醒开发者 Amelia，准备进行 TDD 开发               │ │
+│     └─────────────────────────────────────────────────────────┘ │
+│                                                                  │
+│  2. 执行故事开发工作流                                            │
+│     ┌─────────────────────────────────────────────────────────┐ │
+│     │ 执行命令: *develop-story                                │ │
+│     │ 说明: 执行 TDD 驱动的故事开发                            │ │
+│     │ 前置条件: 故事状态为 ready-for-dev                       │ │
+│     │ 执行流程:                                                │ │
+│     │   - Step 4: 标记为 in-progress                          │ │
+│     │   - Step 5: TDD 实现 (红-绿-重构)                        │ │
+│     │   - Step 6: 编写全面测试                                 │ │
+│     │   - Step 7: 运行验证和测试                               │ │
+│     │   - Step 8: 验证并标记任务完成                           │ │
+│     │   - Step 9: 标记为 review                                │ │
+│     │ 状态: ready-for-dev → in-progress → review              │ │
+│     └─────────────────────────────────────────────────────────┘ │
+│                                                                  │
+│  ⚠️ 关键规则:                                                    │
+│  - 故事文件是唯一的事实来源                                       │
+│  - 严格按照 Tasks/Subtasks 顺序执行                              │
+│  - 绝不实现故事文件中未定义的内容                                 │
+│  - 每个任务完成前必须有测试覆盖                                   │
+│  - 所有测试必须 100% 通过才能继续                                │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**执行命令**:
+```bash
+# 唤醒 DEV 智能体
+/dev
+
+# 执行故事开发
+*develop-story
+```
+
+---
+
 ```yaml
 task: develop_story
 role: DEV (Amelia)
+agent_activation:
+  command: "/dev"
+  workflow: "*develop-story"
 invoke_workflow: "*develop-story"
 
 precondition:
@@ -762,6 +1255,15 @@ critical_rules:
 status_transitions:
   on_start: "ready-for-dev → in-progress"
   on_complete: "in-progress → review"
+
+# ⚠️ 强制状态更新操作 - 必须执行！
+mandatory_updates:
+  on_start:
+    - action: "编辑故事文件: Status: ready-for-dev → Status: in-progress"
+    - action: "编辑 sprint-status.yaml: story_key: ready-for-dev → story_key: in-progress"
+  on_complete:
+    - action: "编辑故事文件: Status: in-progress → Status: review"
+    - action: "编辑 sprint-status.yaml: story_key: in-progress → story_key: review"
 ```
 
 ---
@@ -770,9 +1272,63 @@ status_transitions:
 
 **调用工作流**: `{xiaoma_folder}/xmc/workflows/4-implementation/code-review/workflow.yaml`
 
+---
+
+##### 🤖 智能体执行指令
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Step 4.2.3: 代码审查                                            │
+│  智能体: Amelia (DEV)                                            │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  执行步骤:                                                        │
+│                                                                  │
+│  1. 唤醒 DEV 智能体 (建议全新上下文)                              │
+│     ┌─────────────────────────────────────────────────────────┐ │
+│     │ 执行命令: /dev                                          │ │
+│     │ 说明: 唤醒开发者 Amelia，准备进行代码审查                │ │
+│     │ 建议: 使用全新上下文和不同 LLM 以获得更客观的评估        │ │
+│     └─────────────────────────────────────────────────────────┘ │
+│                                                                  │
+│  2. 执行代码审查工作流                                            │
+│     ┌─────────────────────────────────────────────────────────┐ │
+│     │ 执行命令: *code-review                                  │ │
+│     │ 说明: 执行彻底的代码审查                                 │ │
+│     │ 前置条件: 故事状态为 review                              │ │
+│     │ 审查维度:                                                │ │
+│     │   - 功能正确性: 是否满足所有接受标准                     │ │
+│     │   - 代码质量: 清晰可读、命名规范、遵循项目规范           │ │
+│     │   - 安全性: 注入风险、敏感数据处理、认证授权             │ │
+│     │   - 性能: 性能问题、数据库查询、内存泄漏                 │ │
+│     │   - 测试覆盖: 测试充分性、边界情况覆盖                   │ │
+│     │                                                          │ │
+│     │ 审查结果:                                                │ │
+│     │   - APPROVED: review → done                             │ │
+│     │   - CHANGES_REQUESTED: review → in-progress (返回修复)  │ │
+│     └─────────────────────────────────────────────────────────┘ │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**执行命令**:
+```bash
+# 唤醒 DEV 智能体 (建议全新上下文)
+/dev
+
+# 执行代码审查
+*code-review
+```
+
+---
+
 ```yaml
 task: code_review
 role: DEV (Amelia)
+agent_activation:
+  command: "/dev"
+  workflow: "*code-review"
+  recommendation: "使用全新上下文和不同 LLM 以获得更客观的评估"
 invoke_workflow: "*code-review"
 
 precondition:
@@ -809,11 +1365,19 @@ review_outcome:
     action: "更新状态为 done"
     update_sprint_status:
       story_key: "review → done"
+    # ⚠️ 强制执行以下操作！
+    mandatory_updates:
+      - "编辑故事文件: Status: review → Status: done"
+      - "编辑 sprint-status.yaml: story_key: review → story_key: done"
 
   CHANGES_REQUESTED:
     action: "生成修复任务，返回开发"
     insert_review_followups: true
     # DEV 智能体会在下次执行时处理审查反馈
+    # ⚠️ 强制执行以下操作！
+    mandatory_updates:
+      - "编辑故事文件: Status: review → Status: in-progress"
+      - "编辑 sprint-status.yaml: story_key: review → story_key: in-progress"
 
 best_practice: |
   建议使用不同的 LLM 执行代码审查以获得更客观的评估
@@ -895,12 +1459,113 @@ For Each Task in Story:
 
 > **重要**: 本阶段集成 TEA 智能体的专用测试工作流，提供全面的测试验证能力。
 
+---
+
+#### 🤖 智能体执行指令
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Phase 5: 测试验证                                               │
+│  智能体: Murat (TEA)                                             │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  Step 5.1: 唤醒 TEA 智能体                                       │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: /tea                                              ││
+│  │ 说明: 唤醒测试架构师 Murat，准备进行测试验证工作              ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 5.2: 需求追溯验证                                          │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *trace                                            ││
+│  │ 说明: 构建需求到测试的追溯矩阵                               ││
+│  │ 输出: traceability-matrix.md                                ││
+│  │ 验证: FR → Stories → Tests 映射完整性                       ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 5.3: 测试质量评审                                          │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *test-review                                      ││
+│  │ 说明: 评审测试质量和充分性                                   ││
+│  │ 检查: 测试充分性、测试质量、测试模式                         ││
+│  │ 输出: test-review-report.md                                 ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 5.4: NFR 验证                                              │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *nfr-assess                                       ││
+│  │ 说明: 验证非功能性需求 (性能、安全、可用性)                  ││
+│  │ 输出: nfr-assessment-report.md                              ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 5.5: (可选) 测试设计                                       │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *test-design                                      ││
+│  │ 说明: 创建全面的测试场景                                     ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 5.6: (可选) 测试自动化                                     │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *automate                                         ││
+│  │ 说明: 生成全面的测试自动化代码                               ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+│  Step 5.7: (可选) CI/CD 流水线                                   │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │ 执行命令: *ci                                               ││
+│  │ 说明: 搭建 CI/CD 质量流水线脚手架                           ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**完整执行序列**:
+```bash
+# 1. 唤醒 TEA 智能体
+/tea
+
+# 2. 需求追溯验证
+*trace
+
+# 3. 测试质量评审
+*test-review
+
+# 4. NFR 验证
+*nfr-assess
+
+# 5. (可选) 测试设计
+*test-design
+
+# 6. (可选) 测试自动化
+*automate
+
+# 7. (可选) CI/CD 流水线
+*ci
+```
+
+---
+
 **自动执行内容**:
 
 ```yaml
 phase: 5
 name: 测试验证
 role: TEA (Murat)
+agent_activation:
+  command: "/tea"
+  workflows:
+    - trigger: "*trace"
+      purpose: "需求到测试的追踪映射"
+    - trigger: "*test-review"
+      purpose: "测试质量评审"
+    - trigger: "*nfr-assess"
+      purpose: "非功能性需求验证"
+    - trigger: "*test-design"
+      purpose: "测试场景设计（可选）"
+    - trigger: "*automate"
+      purpose: "测试自动化（可选）"
+    - trigger: "*ci"
+      purpose: "CI/CD 流水线（可选）"
 inputs:
   - 实现的代码
   - 测试代码
@@ -917,12 +1582,15 @@ outputs:
 workflows_invoked:
   - agent: TEA (Murat)
     workflow: trace
+    command: "/tea → *trace"
     purpose: "需求到测试的追踪映射"
   - agent: TEA (Murat)
     workflow: test-review
+    command: "/tea → *test-review"
     purpose: "测试质量评审"
   - agent: TEA (Murat)
     workflow: nfr-assess
+    command: "/tea → *nfr-assess"
     purpose: "非功能性需求验证"
 ```
 
@@ -932,9 +1600,12 @@ workflows_invoked:
 
 **调用工作流**: `{xiaoma_folder}/xmc/workflows/testarch/trace/workflow.yaml`
 
+**执行命令**: `/tea → *trace`
+
 ```yaml
 task: requirement_traceability
 role: TEA (Murat)
+agent_command: "/tea → *trace"
 invoke_workflow: "*trace"
 
 actions:
@@ -989,9 +1660,12 @@ actions:
 
 **调用工作流**: `{xiaoma_folder}/xmc/workflows/testarch/test-review/workflow.yaml`
 
+**执行命令**: `/tea → *test-review`
+
 ```yaml
 task: test_quality_review
 role: TEA (Murat)
+agent_command: "/tea → *test-review"
 invoke_workflow: "*test-review"
 
 review_criteria:
@@ -1026,9 +1700,12 @@ output:
 
 **调用工作流**: `{xiaoma_folder}/xmc/workflows/testarch/nfr-assess/workflow.yaml`
 
+**执行命令**: `/tea → *nfr-assess`
+
 ```yaml
 task: nfr_validation
 role: TEA (Murat)
+agent_command: "/tea → *nfr-assess"
 invoke_workflow: "*nfr-assess"
 
 validations:
@@ -1309,6 +1986,100 @@ status_sync:
       note: "DEV 智能体会处理审查反馈"
 ```
 
+### 4. 强制状态更新操作 (MANDATORY)
+
+> ⚠️ **关键**: 以下操作是**必须执行**的，不是可选的描述！
+
+#### 4.1 Phase 4 开始前 - 创建 sprint-status.yaml
+
+**必须首先执行** `*sprint-planning` 或手动创建：
+
+```bash
+# 在 {sprint_artifacts} 目录创建 sprint-status.yaml
+# 示例路径: docs/sprint-artifacts/sprint-status.yaml
+```
+
+```yaml
+# sprint-status.yaml - 必须创建此文件
+generated: "{date}"
+project: "{project_name}"
+tracking_system: file-system
+story_location: "{sprint_artifacts}"
+
+development_status:
+  epic-1: backlog
+  1-1-story-name: backlog
+  1-2-story-name: backlog
+  # ... 列出所有故事
+```
+
+#### 4.2 状态更新文件编辑操作
+
+**每次状态变化时，必须执行以下两个更新**：
+
+##### 更新 1: sprint-status.yaml
+
+```yaml
+# 编辑 sprint-status.yaml 中的 development_status
+# 将故事状态从旧值改为新值
+
+# 示例: 1-1-user-auth 从 backlog 变为 drafted
+development_status:
+  1-1-user-auth: drafted  # 原来是 backlog
+```
+
+##### 更新 2: 故事文件
+
+故事文件必须使用以下格式（符合 SM/DEV 智能体要求）：
+
+```markdown
+# Story 1.1: User Authentication
+
+Status: drafted
+
+## Story
+As a user,
+I want to authenticate,
+so that I can access the system.
+
+## Acceptance Criteria
+...
+```
+
+**状态行位置**: 在标题之后，第一个 `## ` 节之前
+
+**允许的状态值**:
+- `drafted` - 故事文件已创建
+- `ready-for-dev` - 准备开发
+- `in-progress` - 开发中
+- `review` - 等待审查
+- `done` - 已完成
+
+#### 4.3 状态更新检查点
+
+在以下时间点**必须**更新状态：
+
+| 时间点 | 触发动作 | 更新内容 |
+|--------|---------|---------|
+| `*create-story` 完成 | 故事文件创建 | `backlog → drafted` (或 `ready-for-dev`) |
+| `*develop-story` Step 4 | 开始开发 | `ready-for-dev → in-progress` |
+| `*develop-story` Step 9 | 开发完成 | `in-progress → review` |
+| `*code-review` APPROVED | 审查通过 | `review → done` |
+
+#### 4.4 验证状态更新
+
+每个阶段完成后，验证状态一致性：
+
+```bash
+# 检查 sprint-status.yaml 中的状态
+grep "story-key" sprint-status.yaml
+
+# 检查故事文件中的状态
+head -5 stories/story-key.md | grep "Status:"
+```
+
+**状态必须同步**: `sprint-status.yaml` 和故事文件中的状态必须一致！
+
 ---
 
 ## 执行完成