@zeyue0329/xiaoma-cli 1.0.48 → 1.0.66

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-02-requirements-analysis.md

@@ -0,0 +1,146 @@
+---
+name: "step-02-requirements-analysis"
+description: "Analyst role performs deep requirements analysis on req.md, producing requirements-analysis.md"
+nextStepFile: "./step-03-architecture-analysis.md"
+---
+
+# Step 2 of 8: Requirements Analysis
+
+**Goal:** Perform deep analysis of the requirements document, identifying gaps, dependencies, priorities, and risks. Produce a structured requirements analysis report.
+
+**Role:** Analyst (xiaofen) — Strategic Business Analyst + Requirements Expert
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Switch to Analyst Role
+
+Adopt the Analyst (xiaofen) persona:
+
+- You are xiaofen, the Strategic Business Analyst + Requirements Expert
+- Your purpose is to dissect, clarify, and structure raw requirements into actionable analysis
+- Communication style: Speaks with the excitement of a treasure hunter — thrilled by every clue, energized when patterns emerge
+
+### 2. Load Requirements Document
+
+1. Read the FULL file: `{req_file_path}`
+2. Read ALL lines from beginning to end — do not skip any content
+3. Also load `project_context` if it exists for additional context
+
+### 3. Execute Requirements Analysis (8 Phases)
+
+#### Phase 1: Parse and Understand Requirements
+
+- Extract all stated requirements (functional and non-functional)
+- Identify the core problem being solved
+- Map stakeholders mentioned or implied
+
+#### Phase 2: Identify Ambiguities and Gaps
+
+- Flag vague or ambiguous requirements
+- Identify missing information (edge cases, error handling, performance targets)
+- Note assumptions that need validation
+
+#### Phase 3: Clarify and Refine Requirements
+
+- Rewrite ambiguous requirements with precision
+- Fill gaps with reasonable assumptions (clearly marked as assumptions)
+- Add missing acceptance criteria where obvious
+
+#### Phase 4: Categorize and Structure Requirements
+
+- Group requirements by feature area / domain
+- Classify as: Must-Have, Should-Have, Could-Have, Won't-Have (MoSCoW)
+- Separate functional vs non-functional requirements
+
+#### Phase 5: Analyze Users and Scenarios
+
+- Identify user personas / actors
+- Map key user journeys and scenarios
+- Identify edge cases and exception flows
+
+#### Phase 6: Identify Dependencies and Priorities
+
+- Map inter-requirement dependencies
+- Identify external dependencies (APIs, services, data)
+- Suggest implementation priority order
+
+#### Phase 7: Assess Risks and Constraints
+
+- Technical risks (feasibility, complexity)
+- Business risks (scope creep, unclear ROI)
+- Timeline / resource constraints mentioned or implied
+
+#### Phase 8: Generate Analysis Report
+
+- Compile all findings into a structured report
+- Include a requirements traceability matrix
+- Provide executive summary
+
+### 4. Self-Check Quality and Retry
+
+Before writing the output, initialize `{analysis_iteration}` = 1, then verify each criterion:
+
+- [ ] All requirements from req.md are addressed
+- [ ] Ambiguities are identified and clarified
+- [ ] MoSCoW prioritization is applied
+- [ ] Dependencies are mapped
+- [ ] Risks are assessed
+- [ ] Report is structured and actionable
+
+**IF any criteria are unchecked (analysis is incomplete):**
+1. Identify which phases (from section 3) produced insufficient or missing output
+2. Re-execute ONLY the deficient phases — do not restart the full analysis
+3. Increment `{analysis_iteration}`
+4. **IF `{analysis_iteration}` ≤ 2:** Repeat this quality check
+5. **IF `{analysis_iteration}` > 2:** Proceed to section 5 with current output; note any remaining gaps in the report's Executive Summary under "Known Limitations"
+
+**IF all criteria are checked:** Proceed to section 5 immediately.
+
+### 5. Write Output
+
+Write the complete analysis report to: `{planning_artifacts}/requirements-analysis.md`
+
+The report should include:
+
+1. Executive Summary
+2. Original Requirements Summary
+3. Detailed Analysis (by feature area)
+4. Ambiguities and Assumptions
+5. User Personas and Scenarios
+6. Requirements Classification (MoSCoW)
+7. Dependency Map
+8. Risk Assessment
+9. Recommendations
+
+### 6. Pipeline Status Update
+
+- Set `{pipeline_status}` = "requirements-analyzed"
+- Set `{steps_completed}` = 2
+- Output: "Requirements analysis complete. Report written to `{planning_artifacts}/requirements-analysis.md`. Proceeding to architecture analysis."
+
+**Automatically proceed to next step — do NOT wait for user input.**
+
+---
+
+## NEXT STEP
+
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-03-architecture-analysis.md`
+
+---
+
+## SUCCESS METRICS
+
+- All requirements from req.md analyzed and addressed
+- Ambiguities identified with clarifications
+- MoSCoW prioritization applied
+- `{planning_artifacts}/requirements-analysis.md` created
+- Report is actionable for PRD creation
+
+## FAILURE MODES
+
+- Skipping requirements or sections of req.md
+- Not identifying obvious ambiguities
+- Producing analysis that lacks structure
+- Not writing output file

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-03-architecture-analysis.md

@@ -0,0 +1,141 @@
+---
+name: "step-03-architecture-analysis"
+description: "Architect role analyzes existing codebase architecture, producing current-architecture-analysis.md"
+nextStepFile: "./step-04-create-prd.md"
+---
+
+# Step 3 of 8: Existing Architecture Analysis
+
+**Goal:** Analyze the existing codebase to understand the current architecture, technology stack, patterns, and conventions. This context is critical for creating a PRD and architecture design that fits the existing system.
+
+**Role:** Architect (xiaojia) — Technical Architect + Systems Design Expert
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Switch to Architect Role
+
+Adopt the Architect (xiaojia) persona:
+
+- You are xiaojia, the Technical Architect + Systems Design Expert
+- Your purpose is to understand the existing system deeply so that new features integrate cleanly
+- Focus on patterns, conventions, and architectural decisions already in place
+
+### 2. Scan Project Structure
+
+1. List the top-level directory structure of the project
+2. Identify the primary source directories and their organization
+3. Map the project layout (monorepo, multi-module, standard layout, etc.)
+
+### 3. Identify Technology Stack
+
+1. Read project configuration files (package.json, pom.xml, build.gradle, Cargo.toml, go.mod, etc.)
+2. Identify:
+   - Programming language(s) and version(s)
+   - Framework(s) and version(s)
+   - Build tool(s)
+   - Key dependencies and libraries
+   - Database technology (if detectable)
+   - API style (REST, GraphQL, gRPC, etc.)
+
+### 4. Analyze Architecture Patterns
+
+1. Scan source code structure to identify:
+   - Architectural pattern (layered, hexagonal, microservice, monolith, etc.)
+   - Package/module organization conventions
+   - Dependency injection patterns
+   - Configuration management approach
+2. Identify key abstractions and base classes
+3. Map the data flow (controllers → services → repositories, etc.)
+
+### 5. Analyze Database Design (if applicable)
+
+1. Look for schema definitions, migrations, or entity classes
+2. Identify:
+   - Database type (SQL, NoSQL, etc.)
+   - ORM or data access layer
+   - Key entities and relationships
+   - Migration strategy
+
+### 6. Analyze API Endpoints (if applicable)
+
+1. Scan for route/controller/endpoint definitions
+2. Catalog existing API structure
+3. Note authentication/authorization patterns
+4. Identify API versioning strategy (if any)
+
+### 7. Summarize Coding Conventions
+
+1. Check for linter/formatter configurations
+2. Identify naming conventions (camelCase, snake_case, etc.)
+3. Note testing patterns and frameworks
+4. Identify error handling patterns
+5. Note logging and monitoring patterns
+
+### 8. Self-Check Quality and Retry
+
+Before writing the output, initialize `{architecture_iteration}` = 1, then verify each criterion:
+
+- [ ] Technology stack fully identified
+- [ ] Architecture pattern documented
+- [ ] Key conventions captured
+- [ ] Database design analyzed (if applicable)
+- [ ] API structure mapped (if applicable)
+- [ ] Analysis is useful for downstream PRD and architecture design
+
+**IF any criteria are unchecked (analysis is incomplete):**
+1. Identify which sections (2–7) produced insufficient or missing output
+2. Re-execute ONLY the deficient sections — do not restart the full analysis
+3. Increment `{architecture_iteration}`
+4. **IF `{architecture_iteration}` ≤ 2:** Repeat this quality check
+5. **IF `{architecture_iteration}` > 2:** Proceed to section 9 with current output; note any remaining gaps in the report under "Key Observations and Constraints"
+
+**IF all criteria are checked:** Proceed to section 9 immediately.
+
+### 9. Write Output
+
+Write the complete architecture analysis to: `{planning_artifacts}/current-architecture-analysis.md`
+
+The report should include:
+
+1. Executive Summary
+2. Technology Stack
+3. Project Structure Overview
+4. Architecture Patterns
+5. Database Design (if applicable)
+6. API Structure (if applicable)
+7. Coding Conventions and Standards
+8. Key Observations and Constraints
+9. Recommendations for New Feature Integration
+
+### 10. Pipeline Status Update
+
+- Set `{pipeline_status}` = "architecture-analyzed"
+- Set `{steps_completed}` = 3
+- Output: "Architecture analysis complete. Report written to `{planning_artifacts}/current-architecture-analysis.md`. Proceeding to PRD creation."
+
+**Automatically proceed to next step — do NOT wait for user input.**
+
+---
+
+## NEXT STEP
+
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-04-create-prd.md`
+
+---
+
+## SUCCESS METRICS
+
+- Technology stack identified with versions
+- Architecture pattern documented
+- Coding conventions captured
+- `{planning_artifacts}/current-architecture-analysis.md` created
+- Analysis provides actionable context for PRD and architecture design
+
+## FAILURE MODES
+
+- Shallow analysis that misses key patterns
+- Not scanning actual source code
+- Producing generic analysis not specific to this codebase
+- Not writing output file

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-04-create-prd.md

@@ -0,0 +1,101 @@
+---
+name: "step-04-create-prd"
+description: "PM role creates PRD by delegating to create-prd workflow with pipeline context"
+nextStepFile: "./step-05-validate-prd.md"
+---
+
+# Step 4 of 8: Create PRD
+
+**Goal:** Create a comprehensive Product Requirements Document (PRD) by delegating to the existing create-prd workflow, enriched with requirements analysis and architecture analysis context.
+
+**Role:** PM (xiaochan) — Product Manager + Requirements Specialist
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Switch to PM Role
+
+Adopt the PM (xiaochan) persona:
+
+- You are xiaochan, the Product Manager + Requirements Specialist
+- Your purpose is to create a comprehensive PRD that bridges business requirements and technical implementation
+- Communication style: Precise, structured, stakeholder-aware
+
+### 2. Load Required Context
+
+Load these artifacts in order:
+
+1. **PRIMARY SOURCE** — Read the FULL file from beginning to end
+   - File: `{req_file_path}` (the original requirements)
+   - Requirement: Complete read, no skipping
+
+2. **SECONDARY SOURCES** — Read each file fully if it exists
+   - File: `{planning_artifacts}/requirements-analysis.md` (from Step 2) — Required
+   - File: `{planning_artifacts}/current-architecture-analysis.md` (from Step 3) — Required
+   - File: `project_context` — Optional (load if exists)
+
+### 3. Verify Workflow Prerequisites
+
+Before delegating, verify the required workflow exists:
+
+1. Check that `{project-root}/_xiaoma/core/tasks/xiaoma-create-prd/workflow.md` is readable
+2. If workflow is missing:
+   - HALT — "Required workflow not found: `{project-root}/_xiaoma/core/tasks/xiaoma-create-prd/workflow.md`. Verify XiaoMa installation is complete."
+
+### 4. Execute PRD Creation (Delegate)
+
+Invoke the `xiaoma-create-prd` skill to create the PRD.
+
+**CRITICAL PIPELINE MODE INSTRUCTIONS:**
+
+- This is running in **automated pipeline mode** — do NOT pause for user input at any step
+- The create-prd workflow has 15 step files in `steps-c/`: step-01-init, step-01b-continue, step-02-discovery, step-02b-vision, step-02c-executive-summary, step-03-success, step-04-journeys, step-05-domain, step-06-innovation, step-07-project-type, step-08-scoping, step-09-functional, step-10-nonfunctional, step-11-polish, step-12-complete
+- If step-01 detects an existing PRD artifact, it may branch to step-01b-continue — in automated pipeline mode, select **O (Overwrite)** to ensure a fresh PRD
+- When ANY step presents a menu (A/P/E/C options), automatically select **C (Continue)** to proceed
+- When the workflow asks for user decisions, make reasonable decisions automatically based on the requirements analysis and architecture analysis
+- When the workflow asks for clarification, use the requirements analysis to fill in gaps
+- Complete ALL steps of the create-prd workflow without stopping
+- Output file MUST be: `{planning_artifacts}/prd.md`
+
+### 5. Verify PRD Output
+
+After create-prd workflow completes:
+
+1. Verify `{planning_artifacts}/prd.md` exists
+2. Verify the PRD contains all essential sections (problem statement, goals, features, requirements)
+3. Verify requirements from req.md are traceable in the PRD
+
+If PRD creation failed:
+
+- HALT — "PRD creation failed. Check requirements analysis and architecture analysis for issues."
+
+### 6. Pipeline Status Update
+
+- Set `{pipeline_status}` = "prd-created"
+- Set `{steps_completed}` = 4
+- Output: "PRD created successfully at `{planning_artifacts}/prd.md`. Proceeding to PRD validation."
+
+**Automatically proceed to next step — do NOT wait for user input.**
+
+---
+
+## NEXT STEP
+
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-05-validate-prd.md`
+
+---
+
+## SUCCESS METRICS
+
+- PRD created at `{planning_artifacts}/prd.md`
+- All requirements from req.md are traceable in PRD
+- PRD includes: problem statement, goals, features, user stories, non-functional requirements
+- Architecture context is reflected in technical constraints
+
+## FAILURE MODES
+
+- PRD missing critical sections
+- Requirements not traceable from req.md to PRD
+- Stopping to ask user for input (pipeline mode requires autonomous decisions)
+- Not writing output file

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-05-validate-prd.md

@@ -0,0 +1,159 @@
+---
+name: "step-05-validate-prd"
+description: "PM role validates PRD by delegating to validate-prd workflow, auto-fixing issues up to 3 iterations"
+nextStepFile: "./step-06-create-epics.md"
+---
+
+# Step 5 of 8: Validate PRD
+
+**Goal:** Validate the PRD against quality standards using the existing validate-prd workflow. Automatically fix any issues found, up to 3 iterations.
+
+**Role:** PM (xiaochan) — Product Manager + Requirements Specialist
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Initialize Validation
+
+- Set `{validation_iteration}` = 0
+- Set `{max_validation_iterations}` = 3
+  *(Note: This step uses a higher limit than step-02/step-03's max 2 retries because PRD validation delegates to the full 14-step validate-prd workflow — a more complex operation that warrants additional attempts before halting.)*
+
+### 2. Load Required Context
+
+Load these artifacts in order:
+
+1. **PRIMARY SOURCE** — Read the FULL file from beginning to end
+   - File: `{planning_artifacts}/prd.md` (the PRD to validate)
+   - Requirement: Complete read, no skipping
+
+2. **SECONDARY SOURCES** — Read each file fully if it exists
+   - File: `{planning_artifacts}/requirements-analysis.md` (from Step 2) — For cross-reference validation
+   - File: `{req_file_path}` — For traceability verification
+
+### 3. Verify Workflow Prerequisites
+
+Before delegating, verify the required workflow exists:
+
+1. Check that `{project-root}/_xiaoma/xmc/workflows/2-plan-workflows/xiaoma-validate-prd/workflow.md` is readable
+2. If workflow is missing:
+   - HALT — "Required workflow not found: `{project-root}/_xiaoma/xmc/workflows/2-plan-workflows/xiaoma-validate-prd/workflow.md`. Verify XiaoMa installation is complete."
+
+### 4. Execute PRD Validation (Delegate)
+
+Invoke the `xiaoma-validate-prd` skill to validate the PRD.
+
+**CRITICAL PIPELINE MODE INSTRUCTIONS:**
+
+- This is running in **automated pipeline mode** — do NOT pause for user input
+- The validate-prd workflow has 14 step files in `steps-v/` (step-v-02b is a conditional branch for specific PRD format detection scenarios): step-v-01-discovery, step-v-02-format-detection, step-v-02b-parity-check, step-v-03-density-validation, step-v-04-brief-coverage, step-v-05-measurability, step-v-06-traceability, step-v-07-implementation-leakage, step-v-08-domain-compliance, step-v-09-project-type, step-v-10-smart, step-v-11-holistic-quality, step-v-12-completeness, step-v-13-report-complete
+- The workflow begins with discovery-based structure extraction (step-v-01) before validation
+- When ANY step presents a menu (Continue/Fix/Skip options), automatically select **Continue** unless critical issues are detected
+- When validation identifies issues, automatically fix them in the PRD
+- After fixing, re-run validation (up to `{max_validation_iterations}` times)
+- Make autonomous decisions on how to resolve validation failures
+
+### 5. Validation Loop
+
+For each iteration:
+
+1. Run validation against `{planning_artifacts}/prd.md`
+2. If ALL checks pass: Proceed to section 6 (Validation Passed)
+3. If issues found:
+   - Increment `{validation_iteration}`
+   - If `{validation_iteration}` > `{max_validation_iterations}`:
+     - HALT — "PRD validation failed after {max_validation_iterations} iterations. Manual review required. Issues: [list remaining issues]"
+   - Fix identified issues in `{planning_artifacts}/prd.md`
+   - Re-run validation
+
+### 6. Validation Passed
+
+1. Verify final PRD is complete and valid
+2. Output validation summary:
+   - Total iterations needed
+   - Issues found and resolved
+   - Final validation score (if applicable)
+
+### 7. Pipeline Status Update
+
+- Set `{pipeline_status}` = "prd-validated"
+- Set `{steps_completed}` = 5
+- Output: "PRD validated successfully (iteration {validation_iteration}). Proceeding to epic and story creation."
+
+**Automatically proceed to next step — do NOT wait for user input.**
+
+---
+
+## NEXT STEP
+
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-06-create-epics.md`
+
+---
+
+## SUCCESS METRICS
+
+- PRD passes all validation checks
+- All critical issues resolved within iteration limit
+- `{planning_artifacts}/prd.md` updated with fixes (if any)
+- Validation report generated
+
+## FAILURE MODES
+
+- Exceeding max validation iterations without resolution
+- Introducing new issues while fixing existing ones
+- Not properly delegating to validate-prd workflow
+- Stopping to ask user for input
+
+---
+
+## 阻断性问题检查清单 (Validation Blockers Checklist)
+
+以下条件**必须全部通过** — 任何一个失败都阻断进度到step-06:
+
+- [ ] **Functional Requirements Traceability**: 所有Story都可追溯到原始需求文档
+- [ ] **Technical Feasibility**: 提议的技术栈和架构在给定时间线内可实现
+- [ ] **Business Value Definition**: 每个Epic至少有一个明确的业务价值主张
+- [ ] **Acceptance Criteria Clarity**: 所有Acceptance criteria都是SMART格式 (Specific, Measurable, Achievable, Relevant, Time-bound)
+- [ ] **Cross-Team Dependencies**: 跨team和component的所有依赖已识别、优先级排序、可协调
+- [ ] **Performance & Scalability**: 性能目标和可扩展性要求明确量化
+- [ ] **Security Review**: 安全审查已完成，没有Critical或Unmitigated issues
+- [ ] **Compliance & Legal**: 任何合规性要求（数据保护、行业标准等）都已纳入Story
+
+## 验证通过标准 (Validation Pass Criteria)
+
+PRD验证通过的充要条件:
+
+1. ✅ 所有Blockers都已检查且通过
+2. ✅ 没有超过3个Medium优先级未解决的issues
+3. ✅ 所有Critical issues都有明确的Mitigation计划
+4. ✅ PM (xiaochan) 和至少一个stakeholder已同意
+5. ✅ 文档质量评分 >= 85%
+6. ✅ Story计数 >= 5个 (如果目标是正常sprint)
+
+## 如果验证失败后超过3次迭代 (Beyond 3 Iterations Escalation)
+
+**步骤:**
+
+1. 生成详细的"Unresolved Issues Report"，按优先级分类
+2. 对于仍未解决的**Critical issues**:
+   - 立即通知xiaojia (Architect) 进行架构审查
+   - 可能需要回到 **step-03-architecture-analysis** 重新评估技术可行性
+3. 对于**Major issues**:
+   - xiaochan尝试通过PRD微调来修复
+   - 如果无法修复，escalate至PM决策
+4. **决策选项**:
+   - A) 接受已识别的风险，添加mitigation计划到backlog
+   - B) 修改scope以移除有问题的Story
+   - C) 延迟到下一个iteration，回到step-04重新生成PRD
+   - D) 停止管道，等待manual intervention
+
+**Escalation Notification Template:**
+```
+PRD Validation Status: FAILED AFTER 3 ITERATIONS
+Blocking Story Count: [X]
+Critical Issues: [list]
+Proposed Resolution: [A/B/C/D]
+Escalation To: [PM/Architect/Stakeholder]
+Timeline Impact: [days]
+```

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-06-create-epics.md

@@ -0,0 +1,104 @@
+---
+name: "step-06-create-epics"
+description: "PM role creates epics and stories by delegating to create-epics-and-stories workflow"
+nextStepFile: "./step-07-create-architecture.md"
+---
+
+# Step 6 of 8: Create Epics and Stories
+
+**Goal:** Break down the validated PRD into epics and user stories using the existing create-epics-and-stories workflow.
+
+**Role:** PM (xiaochan) — Product Manager + Requirements Specialist
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Switch to PM Role
+
+Adopt the PM (xiaochan) persona:
+
+- You are xiaochan, the Product Manager + Requirements Specialist
+- Your purpose is to break down the validated PRD into well-structured epics and user stories
+- Communication style: Precise, structured, stakeholder-aware
+- Focus on complete feature coverage and actionable story granularity
+
+### 2. Load Required Context
+
+Load these artifacts in order:
+
+1. **PRIMARY SOURCE** — Read the FULL file from beginning to end
+   - File: `{planning_artifacts}/prd.md` (validated in Step 5)
+   - Requirement: Complete read, no skipping
+
+2. **SECONDARY SOURCES** — Read each file fully if it exists
+   - File: `{planning_artifacts}/requirements-analysis.md` (from Step 2) — Required
+   - File: `{planning_artifacts}/current-architecture-analysis.md` (from Step 3) — Required
+
+### 3. Verify Workflow Prerequisites
+
+Before delegating, verify the required workflow exists:
+
+1. Check that `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-epics-and-stories/workflow.md` is readable
+2. If workflow is missing:
+   - HALT — "Required workflow not found: `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-epics-and-stories/workflow.md`. Verify XiaoMa installation is complete."
+
+### 4. Execute Epic and Story Creation (Delegate)
+
+Invoke the `xiaoma-create-epics-and-stories` skill to create the epic breakdown.
+
+**CRITICAL PIPELINE MODE INSTRUCTIONS:**
+
+- This is running in **automated pipeline mode** — do NOT pause for user input
+- The create-epics-and-stories workflow has 4 step files: validate-prerequisites → design-epics → create-stories → final-validation
+- When ANY step presents a menu with **[C] Continue**, automatically select **C** to proceed to the next step
+- Step 1 (validate-prerequisites) will ask the user to confirm discovered documents and extracted requirements — automatically confirm and continue
+- Step 1 asks "Do these extracted requirements accurately represent what needs to be built?" — auto-confirm YES and select **C**
+- When the workflow asks for user decisions on epic boundaries or story granularity, make reasonable decisions based on the PRD and architecture analysis
+- Ensure every PRD feature is covered by at least one epic
+- Each epic should have well-defined user stories with acceptance criteria
+- Output file MUST be: `{planning_artifacts}/epics.md`
+
+### 5. Verify Epic Output
+
+After create-epics-and-stories workflow completes:
+
+1. Verify `{planning_artifacts}/epics.md` exists
+2. Verify all PRD features are covered by epics
+3. Verify each epic has at least one user story
+4. Verify stories have acceptance criteria
+
+If epic creation failed:
+
+- HALT — "Epic and story creation failed. Check PRD for completeness."
+
+### 6. Pipeline Status Update
+
+- Set `{pipeline_status}` = "epics-created"
+- Set `{steps_completed}` = 6
+- Output: "Epics and stories created at `{planning_artifacts}/epics.md`. Proceeding to architecture design."
+
+**Automatically proceed to next step — do NOT wait for user input.**
+
+---
+
+## NEXT STEP
+
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-07-create-architecture.md`
+
+---
+
+## SUCCESS METRICS
+
+- `{planning_artifacts}/epics.md` created with complete epic breakdown
+- All PRD features covered by at least one epic
+- Each epic has user stories with acceptance criteria
+- Story dependencies identified
+- Implementation priority suggested
+
+## FAILURE MODES
+
+- PRD features not fully covered by epics
+- Stories missing acceptance criteria
+- Epic boundaries too broad or too narrow
+- Not writing output file