@zeyue0329/xiaoma-cli 1.6.4 → 1.7.0

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

@@ -0,0 +1,105 @@
+---
+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 (John) — 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 covering: discovery, parity check, structure, deep review, section-by-section validation, cross-referencing, and completion reporting
+- 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 step 4
+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

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

@@ -0,0 +1,95 @@
+---
+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 (John) — Product Manager + Requirements Specialist
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. 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
+
+### 2. 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."
+
+### 3. 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`
+
+### 4. 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."
+
+### 5. 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

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

@@ -0,0 +1,107 @@
+---
+name: "step-07-create-architecture"
+description: "Architect role creates technical architecture design by delegating to create-architecture workflow"
+nextStepFile: "./step-08-finalize.md"
+---
+
+# Step 7 of 8: Create Architecture Design
+
+**Goal:** Design the technical architecture for the new features/requirements, integrating with the existing codebase architecture. Delegates to the existing create-architecture workflow.
+
+**Role:** Architect (Winston) — Technical Architect + Systems Design Expert
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Switch to Architect Role
+
+Adopt the Architect (Winston) persona:
+
+- You are Winston, the Technical Architect + Systems Design Expert
+- Your purpose is to design an architecture that integrates new requirements cleanly with the existing system
+- Focus on incremental, pragmatic design that respects existing patterns
+
+### 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 PRD)
+   - Requirement: Complete read, no skipping
+
+2. **SECONDARY SOURCES** — Read each file fully if it exists
+   - File: `{planning_artifacts}/epics.md` (epic and story breakdown) — Required
+   - File: `{planning_artifacts}/current-architecture-analysis.md` (from Step 3) — Required
+   - File: `{planning_artifacts}/requirements-analysis.md` (from Step 2) — Required
+
+### 3. Verify Workflow Prerequisites
+
+Before delegating, verify the required workflow exists:
+
+1. Check that `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-architecture/workflow.md` is readable
+2. If workflow is missing:
+   - HALT — "Required workflow not found: `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-architecture/workflow.md`. Verify XiaoMa installation is complete."
+
+### 4. Execute Architecture Design (Delegate)
+
+Invoke the `xiaoma-create-architecture` skill to design the technical architecture.
+
+**CRITICAL PIPELINE MODE INSTRUCTIONS:**
+
+- This is running in **automated pipeline mode** — do NOT pause for user input
+- The create-architecture workflow has 9 step files: init → (continue) → context → starter → decisions → patterns → structure → validation → complete
+- **IMPORTANT DISTINCTION:** Step 3 of this pipeline creates `current-architecture-analysis.md` (analysis of the *existing* codebase), NOT `architecture.md` (the *new* design document). Therefore `architecture.md` should NOT already exist when step-07 runs. If `architecture.md` IS found unexpectedly (e.g., from a prior partial run), treat it as a stale artifact and let the workflow overwrite/recreate it fresh
+- Step 1 (init) of create-architecture detects existing workflow state — if `architecture.md` already exists unexpectedly, it may branch to step-01b-continue.md — in that case, automatically select **O (Overwrite)** to start fresh
+- Step 1b (continue) presents a menu with R/C/O/X options — if reached due to a stale artifact, automatically select **O (Overwrite)** for a clean pipeline run
+- When ANY step presents a menu with **[C] Continue**, automatically select **C** to proceed to the next step
+- Step 1 asks user to confirm discovered documents — automatically confirm and select **C**
+- When the workflow asks for architectural decisions, make pragmatic choices based on the existing architecture analysis
+- Prefer incremental changes over greenfield redesigns
+- Ensure the architecture aligns with existing patterns and conventions
+- Consider the technology stack identified in Step 3
+- Output file MUST be: `{planning_artifacts}/architecture.md`
+
+### 5. Verify Architecture Output
+
+After create-architecture workflow completes:
+
+1. Verify `{planning_artifacts}/architecture.md` exists
+2. Verify the architecture addresses all epics from the PRD
+3. Verify it accounts for existing system patterns and conventions
+4. Verify it includes implementation guidance
+
+If architecture creation failed:
+
+- HALT — "Architecture design failed. Check PRD, epics, and existing architecture analysis."
+
+### 6. Pipeline Status Update
+
+- Set `{pipeline_status}` = "architecture-created"
+- Set `{steps_completed}` = 7
+- Output: "Architecture design complete at `{planning_artifacts}/architecture.md`. Proceeding to finalization."
+
+**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-08-finalize.md`
+
+---
+
+## SUCCESS METRICS
+
+- `{planning_artifacts}/architecture.md` created with complete technical design
+- Architecture addresses all epics and PRD features
+- Design is compatible with existing system architecture
+- Implementation guidance provided
+- Technology choices justified
+
+## FAILURE MODES
+
+- Architecture incompatible with existing system
+- Missing coverage for PRD features
+- Over-engineering or unnecessary greenfield redesign
+- Not writing output file

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

@@ -0,0 +1,124 @@
+---
+name: "step-08-finalize"
+description: "Generate completion report, validate all artifacts, and provide next-step guidance"
+nextStepFile: null
+---
+
+# Step 8 of 8: Finalize Pipeline
+
+**Goal:** Validate all output artifacts exist, generate a completion report, and provide guidance on next steps.
+
+**Role:** Pipeline Orchestrator
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Validate All Artifacts
+
+Check that ALL required output files exist:
+
+1. **Requirements Analysis** — `{planning_artifacts}/requirements-analysis.md`
+2. **Architecture Analysis** — `{planning_artifacts}/current-architecture-analysis.md`
+3. **PRD** — `{planning_artifacts}/prd.md`
+4. **Epics** — `{planning_artifacts}/epics.md`
+5. **Architecture Design** — `{planning_artifacts}/architecture.md`
+
+For each missing artifact, log a warning. If PRD or Epics are missing, this is a critical failure.
+
+### 2. Run Completion Checklist
+
+Load and evaluate: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/checklist.md`
+
+Mark each item as passed or failed based on artifact verification.
+
+### 3. Generate Completion Report
+
+Set `{steps_completed}` = 8 and `{pipeline_status}` = "complete" now, before printing, so the report reflects the final accurate values.
+
+**Output:**
+
+```
+═══════════════════════════════════════════════════
+  Auto Requirements Pipeline — COMPLETE
+═══════════════════════════════════════════════════
+
+Project: {project_name}
+Date: {date}
+Steps Completed: {steps_completed}/8
+
+📄 Output Artifacts:
+  ✅/❌ {planning_artifacts}/requirements-analysis.md
+  ✅/❌ {planning_artifacts}/current-architecture-analysis.md
+  ✅/❌ {planning_artifacts}/prd.md
+  ✅/❌ {planning_artifacts}/epics.md
+  ✅/❌ {planning_artifacts}/architecture.md
+
+Pipeline Status: {pipeline_status}
+
+═══════════════════════════════════════════════════
+```
+
+### 4. Generate Machine-Readable Status File
+
+Write machine-readable status to: `{planning_artifacts}/pipeline-status.json`
+
+```json
+{
+  "pipeline": "auto-requirements-pipeline",
+  "date": "{date}",
+  "project": "{project_name}",
+  "status": "complete",
+  "steps_completed": 8,
+  "artifacts": {
+    "requirements_analysis": "{planning_artifacts}/requirements-analysis.md",
+    "architecture_analysis": "{planning_artifacts}/current-architecture-analysis.md",
+    "prd": "{planning_artifacts}/prd.md",
+    "epics": "{planning_artifacts}/epics.md",
+    "architecture": "{planning_artifacts}/architecture.md"
+  },
+  "iterations": {
+    "analysis": "{analysis_iteration}",
+    "architecture": "{architecture_iteration}",
+    "validation": "{validation_iteration}"
+  }
+}
+```
+
+This enables downstream tools (including the Auto Story Pipeline) to check pipeline status programmatically.
+
+### 5. Provide Next Steps
+
+**Output:**
+
+```
+🔜 Recommended Next Steps:
+
+1. Review generated artifacts in {planning_artifacts}/
+2. Run Sprint Planning (SP) to organize stories into sprints
+3. Run Auto Story Pipeline to begin implementation
+
+Available commands:
+  - SP (Sprint Planning) — Organize epics/stories into sprints
+  - ASP (Auto Story Pipeline) — Automated story development lifecycle
+```
+
+### 6. Pipeline Complete
+
+**Pipeline execution is COMPLETE. HALT.**
+
+---
+
+## SUCCESS METRICS
+
+- All 5 output artifacts verified
+- Machine-readable `pipeline-status.json` generated
+- Completion report generated
+- Next steps provided
+- Pipeline status set to "complete"
+
+## FAILURE MODES
+
+- Missing critical artifacts (PRD, Epics)
+- Not providing completion report
+- Not suggesting next steps

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/workflow.md

@@ -0,0 +1,106 @@
+---
+name: auto-requirements-pipeline
+description: "Automated end-to-end requirements analysis pipeline: requirements analysis → architecture analysis → PRD creation → PRD validation → epic+story creation → architecture design → finalize. Use when the user says 'auto requirements', 'run requirements pipeline', or 'AR'"
+---
+
+# Auto Requirements Pipeline Workflow
+
+**Goal:** Execute the complete automated requirements analysis lifecycle — from requirements document (req.md) through analysis, PRD creation, validation, epic/story breakdown, architecture design, and delivery readiness — as a single continuous pipeline with zero user intervention.
+
+**Your Role:** Pipeline Orchestrator. You switch expert roles at each phase:
+
+- **Analyst (Mary)** — Requirements analysis and deep research
+- **Architect (Winston)** — Architecture analysis and design
+- **PM (John)** — PRD creation, validation, and epic/story breakdown
+
+- Communicate all responses in {communication_language} and generate all documents in {document_output_language}
+- Execute ALL steps in exact order; do NOT skip steps
+- Absolutely DO NOT stop because of "milestones", "significant progress", or "session boundaries". Continue in a single execution until the pipeline is COMPLETE or a HALT condition is triggered
+- Each step file loads fresh to combat "lost in the middle" context degradation
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for focused execution across a long-running pipeline:
+
+- Each step loads fresh to prevent context loss in long sessions
+- State persists via variables passed between steps
+- Sequential progression through pipeline phases with conditional branching
+- Role switching at each phase boundary
+
+### State Variables
+
+- `{req_file_path}` — Path to the requirements document (default: `{planning_artifacts}/req.md`)
+- `{pipeline_status}` — Current pipeline phase for tracking
+- `{steps_completed}` — Count of steps completed in this pipeline run
+- `{validation_iteration}` — PRD validation loop counter (used in step-05, max 3)
+- `{analysis_iteration}` — Requirements analysis quality-retry counter (used in step-02, max 2 retries)
+- `{architecture_iteration}` — Architecture analysis quality-retry counter (used in step-03, max 2 retries)
+
+### Output Artifacts
+
+All outputs are written to `{planning_artifacts}/`:
+
+- `requirements-analysis.md` — Deep requirements analysis report
+- `current-architecture-analysis.md` — Existing codebase architecture analysis
+- `prd.md` — Product Requirements Document
+- `epics.md` — Epic and story breakdown
+- `architecture.md` — Technical architecture design
+- `pipeline-status.json` — Machine-readable pipeline completion status
+
+### Architecture Document Types (Important Distinction)
+
+This pipeline produces TWO different architecture documents:
+
+1. **current-architecture-analysis.md** (Step 3 output)
+   - Analysis of the EXISTING codebase
+   - Generated by Architect (Winston) analyzing current system patterns
+   - Used as context for designing new features that integrate cleanly
+   - Describes what IS
+
+2. **architecture.md** (Step 7 output)
+   - Technical design for NEW features/requirements
+   - Generated by Architect (Winston) designing the solution
+   - References current architecture analysis as context
+   - Describes what SHOULD BE
+
+When step-07 runs, it may find a stale `architecture.md` from a prior pipeline run — in that case, the step explicitly overwrites it (see step-07 section 3).
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_xiaoma/xmc/config.yaml` and resolve:
+
+- `project_name`, `user_name`
+- `communication_language`, `document_output_language`
+- `user_skill_level`
+- `planning_artifacts`, `implementation_artifacts`
+- `date` as system-generated current datetime
+
+### Paths
+
+- `installed_path` = `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline`
+- `validation` = `{installed_path}/checklist.md`
+
+### Related Workflows
+
+These existing workflows contain the detailed logic that pipeline steps delegate to:
+
+- `create_prd_workflow` = `{project-root}/_xiaoma/core/tasks/xiaoma-create-prd/workflow.md` *(Note: uses `core/tasks/` path — `xiaoma-create-prd` originates in the core module, not the xmc module. All other related workflows use `_xiaoma/xmc/workflows/`.)*
+- `validate_prd_workflow` = `{project-root}/_xiaoma/xmc/workflows/2-plan-workflows/xiaoma-validate-prd/workflow.md`
+- `create_epics_workflow` = `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-epics-and-stories/workflow.md`
+- `create_architecture_workflow` = `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-architecture/workflow.md`
+
+### Context
+
+- `project_context` = `**/project-context.md` (load if exists)
+
+---
+
+## EXECUTION
+
+Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-01-init-and-validate.md` to begin the pipeline.

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/xiaoma-skill-manifest.yaml

@@ -0,0 +1,3 @@
+canonicalId: xiaoma-auto-requirements-pipeline
+type: workflow
+description: "Automated requirements analysis pipeline: analyze → PRD → validate → epics → architecture → ready. Use when the user says 'auto requirements', 'run requirements pipeline', or 'AR'"

package/src/xmc/workflows/1-analysis/research/xiaoma-domain-research/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: xiaoma-domain-research
+description: 'Conduct domain and industry research. Use when the user says "lets create a research report on [domain or industry]"'
+---
+
+Follow the instructions in [workflow.md](workflow.md).

package/src/xmc/workflows/1-analysis/research/xiaoma-domain-research/SKILL.md.bak

@@ -0,0 +1,6 @@
+---
+name: bmad-domain-research
+description: 'Conduct domain and industry research. Use when the user says "lets create a research report on [domain or industry]"'
+---
+
+Follow the instructions in [workflow.md](workflow.md).