@zeyue0329/xiaoma-cli 1.8.3 → 1.9.0

package/package.json

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

package/src/xmc/agents/sm.agent.yaml

@@ -39,3 +39,7 @@ agent:
     - trigger: ASP or fuzzy match on auto-story
       exec: "skill:auto-story-pipeline"
       description: "[ASP] Auto Story Pipeline: End-to-end automated story development — from story creation through dev, code review, and testing"
+
+    - trigger: AFP or fuzzy match on auto-full
+      exec: "skill:auto-full-pipeline"
+      description: "[AFP] Auto Full Pipeline: End-to-end automated requirements-to-delivery — from requirements analysis through PRD, epics, architecture, sprint planning, and story development"

package/src/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-01-init-and-validate.md

@@ -18,12 +18,19 @@ nextStepFile: "./step-02-create-story.md"
 
 Check that the following required artifacts exist:
 
-1. **Sprint Status File** — `{sprint_status}` must exist
-   - If missing: HALT — "No sprint-status.yaml found. Run `sprint-planning` (SP) first to initialize sprint tracking."
-
-2. **Epics File** — `{planning_artifacts}/*epic*.md` must exist
+1. **Epics File** — `{planning_artifacts}/*epic*.md` must exist
    - If missing: HALT — "No epics file found. Run the planning workflow first to create epics."
 
+2. **Sprint Status File** — `{sprint_status}` must exist
+   - If missing:
+     a. Output INFO — "sprint-status.yaml not found. Auto-generating via Sprint Planning..."
+     b. Verify epics file exists (checked in step 1 above) — if epics are present, proceed with auto-generation
+     c. Read and follow the sprint-planning workflow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/xiaoma-sprint-planning/workflow.md`
+     d. Execute the sprint-planning workflow fully — it will parse epics, detect story statuses, and generate `{sprint_status}`
+     e. After sprint-planning completes, verify `{sprint_status}` now exists
+     f. If `{sprint_status}` still does not exist after auto-generation attempt: HALT — "Failed to auto-generate sprint-status.yaml. Check that epics are correctly formatted and try running Sprint Planning (SP) manually: /xiaoma-sprint-planning"
+     g. Output INFO — "sprint-status.yaml auto-generated successfully. Continuing pipeline..."
+
 3. **Planning Artifacts** — At least one of `{planning_artifacts}/*prd*.md` or `{planning_artifacts}/*architecture*.md` should exist
    - If missing: Output warning but continue — "Planning documents not found. Story creation may have limited context."
 
@@ -163,6 +170,7 @@ Based on the starting step determined in section 5 above, proceed to the correct
 
 ## FAILURE MODES
 
-- Proceeding without sprint-status.yaml
+- Proceeding without sprint-status.yaml AND without auto-generating it
+- Auto-generation of sprint-status.yaml fails silently without HALT
 - Not initializing state variables
 - Starting batch mode with no backlog stories

package/src/xmc/workflows/5-full-pipeline/auto-full-pipeline/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: xiaoma-auto-full-pipeline
+description: "Fully automated requirements-to-delivery pipeline: requirements analysis → PRD → validation → epics → architecture → sprint planning → story development → code review → testing → done. Use when the user says 'run full pipeline', 'auto full', 'end to end', or 'AFP'"
+---
+
+Follow the instructions in [workflow.md](workflow.md).

package/src/xmc/workflows/5-full-pipeline/auto-full-pipeline/checklist.md

@@ -0,0 +1,37 @@
+# Auto Full Pipeline Completion Checklist
+
+Use this checklist to validate the full requirements-to-delivery pipeline completed successfully.
+
+## Phase 1 — Requirements Analysis Validation
+
+- [ ] **Requirements Analysis** — `requirements-analysis.md` exists and contains structured analysis
+- [ ] **Architecture Analysis** — `current-architecture-analysis.md` exists with technology stack and patterns
+- [ ] **PRD Created** — `prd.md` exists with problem statement, goals, features, and requirements
+- [ ] **PRD Validated** — PRD passed validation (all critical blockers resolved)
+- [ ] **Epics Created** — `epics.md` exists with epic/story breakdown and acceptance criteria
+- [ ] **Architecture Designed** — `architecture.md` exists with technical design for new features
+- [ ] **Requirements Pipeline Status** — `pipeline-status.json` shows status "complete"
+
+## Phase 2 — Sprint Planning Validation
+
+- [ ] **Sprint Status Generated** — `sprint-status.yaml` exists with valid YAML
+- [ ] **All Epics Represented** — Every epic from `epics.md` appears in sprint status
+- [ ] **All Stories Represented** — Every story from `epics.md` appears in sprint status
+- [ ] **Retrospective Entries** — Each epic has a corresponding retrospective entry
+
+## Phase 3 — Story Development Validation
+
+- [ ] **All Stories Processed** — Every backlog story has been processed through the pipeline
+- [ ] **Stories Completed** — All story statuses set to "done" in sprint-status.yaml
+- [ ] **Epics Completed** — All epics with every story "done" marked as "done"
+- [ ] **No Orphaned States** — No stories stuck in intermediate states (in-progress, review)
+- [ ] **Fix Iterations Within Limits** — No story exceeded `{max_fix_iterations}` fix iterations
+- [ ] **Tests Passing** — All unit, integration, and E2E tests pass
+
+## Pipeline-Level Validation
+
+- [ ] **All 5 Master Steps Executed** — Steps 1-5 completed successfully
+- [ ] **No Unhandled HALT Conditions** — All halts properly reported with context
+- [ ] **Unified Completion Report Generated** — Final summary output with all phase statuses
+- [ ] **Machine-Readable Status** — `{implementation_artifacts}/full-pipeline-status.json` generated with accurate data
+- [ ] **Artifact Consistency** — Sprint status entries match story files on disk

package/src/xmc/workflows/5-full-pipeline/auto-full-pipeline/steps/step-01-init-and-validate.md

@@ -0,0 +1,152 @@
+---
+name: "step-01-init-and-validate"
+description: "Validate unified environment prerequisites, initialize master pipeline state variables, and prepare for end-to-end execution"
+nextStepFile: "./step-02-run-requirements-pipeline.md"
+---
+
+# Step 1 of 5: Initialize and Validate Environment
+
+**Goal:** Verify all prerequisites for the full requirements-to-delivery pipeline are met, initialize master pipeline state variables, and confirm that both sub-pipelines are accessible.
+
+**Role:** Master Pipeline Orchestrator
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Load Configuration
+
+Read 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`
+- `max_fix_iterations` (default: 5 if not set)
+- `date` as system-generated current datetime
+
+**HALT if config not found:** "XiaoMa config not found at `{project-root}/_xiaoma/xmc/config.yaml`. Run `npx @zeyue0329/xiaoma-cli install` first."
+
+### 2. Validate Prerequisites
+
+Check that the following required artifacts and workflows exist:
+
+1. **Requirements Document** — `{planning_artifacts}/req.md` must exist
+   - If missing: HALT — "No requirements document found at `{planning_artifacts}/req.md`. Create a requirements document before running the full pipeline."
+
+2. **Auto Requirements Pipeline** — `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/workflow.md` must be readable
+   - If missing: HALT — "Auto Requirements Pipeline workflow not found. Verify XiaoMa installation is complete."
+
+3. **Sprint Planning Workflow** — `{project-root}/_xiaoma/xmc/workflows/4-implementation/xiaoma-sprint-planning/workflow.md` must be readable
+   - If missing: HALT — "Sprint Planning workflow not found. Verify XiaoMa installation is complete."
+
+4. **Auto Story Pipeline** — `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/workflow.md` must be readable
+   - If missing: HALT — "Auto Story Pipeline workflow not found. Verify XiaoMa installation is complete."
+
+5. **Source Directory** — `src/` directory should exist (warning only if missing)
+   - If missing: Output WARNING — "No `src/` directory found. Architecture analysis may be limited."
+
+### 3. Check Existing Artifacts
+
+Scan for pre-existing output artifacts from prior runs:
+
+- `{planning_artifacts}/requirements-analysis.md`
+- `{planning_artifacts}/current-architecture-analysis.md`
+- `{planning_artifacts}/prd.md`
+- `{planning_artifacts}/epics.md`
+- `{planning_artifacts}/architecture.md`
+- `{planning_artifacts}/pipeline-status.json`
+- `{implementation_artifacts}/sprint-status.yaml`
+
+If any exist, log INFO — "Pre-existing artifact found: {filename}. Will be overwritten during pipeline execution."
+
+### 4. Detect Resume Mode
+
+Check if a prior pipeline run left completed phases that can be skipped:
+
+**Resume Conditions:**
+
+1. **Phase 1 resumable** — ALL of these exist: `{planning_artifacts}/prd.md`, `{planning_artifacts}/epics.md`, `{planning_artifacts}/architecture.md`, AND `{planning_artifacts}/pipeline-status.json` contains `"status": "complete"`
+2. **Phase 2 resumable** — Phase 1 resumable AND `{implementation_artifacts}/sprint-status.yaml` exists with valid YAML containing at least one story entry
+
+**Resume Logic:**
+
+- If Phase 1 AND Phase 2 are resumable:
+  - Set `{phase_1_status}` = "success (resumed)", `{phase_2_status}` = "success (resumed)"
+  - Set `{resume_from_step}` = 4 (skip to Step-04 Story Development)
+  - Output: "🔄 Resume mode detected — Phase 1 and Phase 2 artifacts found from prior run. Skipping to Phase 3 (Story Development)."
+- If Phase 1 only is resumable:
+  - Set `{phase_1_status}` = "success (resumed)"
+  - Set `{resume_from_step}` = 3 (skip to Step-03 Sprint Planning Bridge)
+  - Output: "🔄 Resume mode detected — Phase 1 artifacts found from prior run. Skipping to Phase 2 (Sprint Planning Bridge)."
+- Otherwise:
+  - Set `{resume_from_step}` = 2 (normal — start from Step-02)
+  - Output: "Starting fresh pipeline run."
+
+### 5. Initialize Master Pipeline State Variables
+
+- `{full_pipeline_status}` = "initializing" → "initialized"
+- `{full_steps_completed}` = 1
+- `{phase_1_status}` = value from resume detection, or "pending" for fresh run
+- `{phase_2_status}` = value from resume detection, or "pending" for fresh run
+- `{phase_3_status}` = "pending"
+- Ensure `{planning_artifacts}/` directory exists
+- Ensure `{implementation_artifacts}/` directory exists
+
+### 6. Load Context
+
+- Load `project_context` = `**/project-context.md` (if exists)
+
+### 7. Output Environment Summary
+
+**Output:**
+
+```
+═══════════════════════════════════════════════════
+  Auto Full Pipeline — INITIALIZED
+═══════════════════════════════════════════════════
+
+Project: {project_name}
+User: {user_name}
+Date: {date}
+Language: {communication_language} / {document_output_language}
+
+📋 Requirements: {req_file_path}
+📂 Planning Artifacts: {planning_artifacts}/
+📂 Implementation Artifacts: {implementation_artifacts}/
+
+Mode: {resume_from_step == 2 ? "Fresh Run" : "Resume Mode (skipping to Step " + resume_from_step + ")"}
+
+Pipeline Phases:
+  {resume_from_step <= 2 ? "⬜" : "⏭️"} Phase 1 — Requirements Analysis Pipeline (8 sub-steps)
+  {resume_from_step <= 3 ? "⬜" : "⏭️"} Phase 2 — Sprint Planning Bridge (5 inline steps)
+  ⬜ Phase 3 — Story Development Pipeline (9 sub-steps, batch mode)
+
+Finalization: Step 5 — Unified completion report
+
+Master Step: 1/5
+═══════════════════════════════════════════════════
+```
+
+**Auto-Proceed:** YES — Do NOT wait for user input. Proceed to the step indicated by `{resume_from_step}`:
+- If `{resume_from_step}` == 2: Proceed to step-02 (normal flow)
+- If `{resume_from_step}` == 3: Skip step-02, proceed directly to step-03
+- If `{resume_from_step}` == 4: Skip step-02 and step-03, proceed directly to step-04
+
+---
+
+## SUCCESS METRICS
+
+- Config loaded and all variables resolved
+- Requirements document exists and is readable
+- All three sub-pipeline workflows accessible
+- Master state variables initialized
+- Resume mode correctly detected (if applicable)
+- Environment summary output
+
+## FAILURE MODES
+
+- Missing req.md (cannot proceed without requirements)
+- Missing XiaoMa config (installation incomplete)
+- Missing sub-pipeline workflows (installation incomplete)
+- Directory creation failures

package/src/xmc/workflows/5-full-pipeline/auto-full-pipeline/steps/step-02-run-requirements-pipeline.md

@@ -0,0 +1,120 @@
+---
+name: "step-02-run-requirements-pipeline"
+description: "Execute the complete auto-requirements-pipeline to produce PRD, epics, and architecture design"
+nextStepFile: "./step-03-bridge-sprint-planning.md"
+---
+
+# Step 2 of 5: Execute Requirements Analysis Pipeline
+
+**Goal:** Delegate to the auto-requirements-pipeline to execute the complete requirements analysis lifecycle — from req.md through analysis, PRD creation, validation, epic/story breakdown, and architecture design.
+
+**Role:** Master Pipeline Orchestrator → delegates to auto-requirements-pipeline roles (Analyst Mary → Architect Winston → PM John → Architect Winston)
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Announce Phase Entry
+
+**Output:**
+
+```
+═══════════════════════════════════════════════════
+  Phase 1 of 3 — Requirements Analysis Pipeline
+═══════════════════════════════════════════════════
+
+Starting automated requirements analysis...
+This phase will produce:
+  • Requirements Analysis
+  • Current Architecture Analysis
+  • PRD (Product Requirements Document)
+  • Validated PRD
+  • Epics and User Stories
+  • Architecture Design
+
+Delegating to auto-requirements-pipeline...
+───────────────────────────────────────────────────
+```
+
+### 2. Execute Auto Requirements Pipeline
+
+Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/workflow.md`
+
+**Critical Full Pipeline Mode Instructions:**
+
+- **FULLY AUTOMATED:** Do NOT pause for user input at any point
+- Execute ALL 8 sub-steps of the requirements pipeline sequentially (step-01 through step-08)
+- When any sub-step presents a menu or asks for user confirmation: auto-select the appropriate proceed/continue option
+- When any sub-step delegates to another workflow (create-prd, validate-prd, create-epics, create-architecture): follow the pipeline mode instructions within those delegation steps
+- **IMPORTANT:** The requirements pipeline's step-01 will also validate prerequisites — since we already validated in our step-01, these checks should pass. If they fail unexpectedly, propagate the HALT
+- Continue through ALL 8 sub-steps until the requirements pipeline reaches its own step-08 (finalize) and completes
+- **Do NOT stop after the requirements pipeline's finalize step outputs "Next Steps" guidance** — those next steps are handled by THIS full pipeline automatically
+
+### 3. Verify Requirements Pipeline Output
+
+After the requirements pipeline completes, verify ALL expected output artifacts exist:
+
+1. **Requirements Analysis** — `{planning_artifacts}/requirements-analysis.md` — REQUIRED
+2. **Architecture Analysis** — `{planning_artifacts}/current-architecture-analysis.md` — REQUIRED
+3. **PRD** — `{planning_artifacts}/prd.md` — CRITICAL (must exist)
+4. **Epics** — `{planning_artifacts}/epics.md` — CRITICAL (must exist)
+5. **Architecture Design** — `{planning_artifacts}/architecture.md` — REQUIRED
+6. **Pipeline Status** — `{planning_artifacts}/pipeline-status.json` — OPTIONAL (informational)
+
+**Verification Logic:**
+
+- If `prd.md` AND `epics.md` both exist: `{phase_1_status}` = "success"
+- If either `prd.md` OR `epics.md` is missing: `{phase_1_status}` = "failed" → HALT — "Requirements pipeline failed to produce critical artifacts. Missing: {list missing}. Cannot proceed to development phase."
+- If `requirements-analysis.md`, `current-architecture-analysis.md`, or `architecture.md` is missing: Output WARNING but continue — "Non-critical artifact missing: {filename}. Development may have reduced context."
+
+### 4. Check Pipeline Status JSON (Optional)
+
+If `{planning_artifacts}/pipeline-status.json` exists:
+
+- Read and verify `status` == "complete"
+- If status != "complete": Output WARNING — "Requirements pipeline reported status '{status}' instead of 'complete'. Proceeding with available artifacts."
+
+### 5. Update Master Pipeline State
+
+- `{full_pipeline_status}` = "requirements-phase-complete"
+- `{full_steps_completed}` = 2
+
+**Output:**
+
+```
+───────────────────────────────────────────────────
+  ✅ Phase 1 Complete — Requirements Analysis
+───────────────────────────────────────────────────
+
+Artifacts produced:
+  ✅/❌ requirements-analysis.md
+  ✅/❌ current-architecture-analysis.md
+  ✅/❌ prd.md
+  ✅/❌ epics.md
+  ✅/❌ architecture.md
+
+Phase 1 Status: {phase_1_status}
+Master Step: 2/5
+
+Proceeding to Phase 2 — Sprint Planning Bridge...
+───────────────────────────────────────────────────
+```
+
+**Auto-Proceed:** YES — Do NOT wait for user input. Immediately proceed to step-03.
+
+---
+
+## SUCCESS METRICS
+
+- All 8 sub-steps of requirements pipeline executed
+- PRD and Epics produced (critical)
+- Requirements analysis, architecture analysis, and architecture design produced (important)
+- Pipeline status JSON generated
+- Phase 1 status set to "success"
+
+## FAILURE MODES
+
+- Requirements pipeline HALT propagated (any of its 8 sub-steps)
+- PRD not generated (critical — cannot create stories without PRD)
+- Epics not generated (critical — cannot create sprint status without epics)
+- Validation loop exceeded max iterations in sub-pipeline

package/src/xmc/workflows/5-full-pipeline/auto-full-pipeline/steps/step-03-bridge-sprint-planning.md

@@ -0,0 +1,119 @@
+---
+name: "step-03-bridge-sprint-planning"
+description: "Bridge phase: auto-run sprint planning to generate sprint-status.yaml from epics, connecting requirements analysis output to story development input"
+nextStepFile: "./step-04-run-story-pipeline.md"
+---
+
+# Step 3 of 5: Bridge — Sprint Planning
+
+**Goal:** Generate `sprint-status.yaml` from the epics produced in Phase 1. This bridges the requirements analysis output to the story development pipeline input. Without this step, the story pipeline cannot determine which stories to process.
+
+**Role:** SM (Bob) — Scrum Master generating sprint tracking
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Announce Phase Entry
+
+**Output:**
+
+```
+═══════════════════════════════════════════════════
+  Phase 2 of 3 — Sprint Planning Bridge
+═══════════════════════════════════════════════════
+
+Generating sprint-status.yaml from epics...
+This bridges requirements → development.
+───────────────────────────────────────────────────
+```
+
+### 2. Verify Epics Input
+
+Confirm `{planning_artifacts}/epics.md` exists and is readable (should always pass since Phase 1 verified this, but re-check for fresh context loading):
+
+- If missing: HALT — "epics.md not found. Phase 1 may have failed. Cannot generate sprint status."
+
+Also check for sharded epics format (safety net only — the auto-requirements-pipeline in Phase 1 produces a single `epics.md` file, not a sharded format):
+
+- If `{planning_artifacts}/epics.md` not found, check for `{planning_artifacts}/epics/index.md`
+- If sharded version found, proceed — the sprint planning workflow handles both formats
+- If neither format found: HALT — "No epics found in any format. Phase 1 may have failed."
+
+### 3. Execute Sprint Planning Workflow
+
+Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/xiaoma-sprint-planning/workflow.md`
+
+**Critical Full Pipeline Mode Instructions:**
+
+- **FULLY AUTOMATED:** Do NOT pause for user input
+- The sprint planning workflow is a **single-file workflow** (`workflow.md`) containing 5 inline `<step>` blocks (not separate step files):
+  1. Parse epic files and extract all work items
+  2. Build sprint status structure (epic-N, story keys, retrospective entries)
+  3. Apply intelligent status detection (check for existing story files)
+  4. Generate `{implementation_artifacts}/sprint-status.yaml`
+  5. Validate and report totals
+- Execute ALL 5 inline steps sequentially within the single workflow file
+- Since this is a fresh pipeline run, all stories should default to "backlog" status (no story files exist yet)
+- When the workflow outputs "Next Steps" guidance at the end, **ignore it** — the next steps are handled by THIS full pipeline automatically
+- **Complete ALL steps without stopping**
+
+### 4. Verify Sprint Status Output
+
+After sprint planning completes, verify:
+
+1. **Sprint Status File** — `{implementation_artifacts}/sprint-status.yaml` must exist
+   - If missing: HALT — "Sprint planning failed to generate sprint-status.yaml. Check epics format and retry."
+
+2. **Content Validation** — Read the generated file and verify:
+   - Contains `development_status:` section
+   - Contains at least one story entry (not just epic entries)
+   - Valid YAML syntax
+
+3. **Count Stories** — Parse and count:
+   - Total epics
+   - Total stories
+   - Stories in "backlog" status (should be all stories for a fresh run)
+
+### 5. Update Master Pipeline State
+
+- `{phase_2_status}` = "success"
+- `{full_pipeline_status}` = "bridge-complete"
+- `{full_steps_completed}` = 3
+
+**Output:**
+
+```
+───────────────────────────────────────────────────
+  ✅ Phase 2 Complete — Sprint Planning Bridge
+───────────────────────────────────────────────────
+
+Sprint Status: {implementation_artifacts}/sprint-status.yaml
+  Total Epics: {epic_count}
+  Total Stories: {story_count}
+  Stories in Backlog: {backlog_count}
+
+Phase 2 Status: {phase_2_status}
+Master Step: 3/5
+
+Proceeding to Phase 3 — Story Development Pipeline (batch mode)...
+───────────────────────────────────────────────────
+```
+
+**Auto-Proceed:** YES — Do NOT wait for user input. Immediately proceed to step-04.
+
+---
+
+## SUCCESS METRICS
+
+- sprint-status.yaml generated with valid YAML
+- All epics and stories from epics.md represented
+- Story counts tallied for pipeline tracking
+- Phase 2 status set to "success"
+
+## FAILURE MODES
+
+- Epics file missing or unreadable
+- Sprint planning workflow fails
+- Generated sprint-status.yaml is malformed or empty
+- No story entries found in sprint status

package/src/xmc/workflows/5-full-pipeline/auto-full-pipeline/steps/step-04-run-story-pipeline.md

@@ -0,0 +1,125 @@
+---
+name: "step-04-run-story-pipeline"
+description: "Execute the complete auto-story-pipeline in batch mode to develop, review, test, and deliver all stories"
+nextStepFile: "./step-05-finalize.md"
+---
+
+# Step 4 of 5: Execute Story Development Pipeline
+
+**Goal:** Delegate to the auto-story-pipeline in **batch mode** to execute the complete story development lifecycle for ALL stories — from story creation through validation, development, code review, testing, bug fixing, and final delivery.
+
+**Role:** Master Pipeline Orchestrator → delegates to auto-story-pipeline roles (SM Bob → PM John → Dev Amelia → Reviewer → QA Quinn)
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Announce Phase Entry
+
+**Output:**
+
+```
+═══════════════════════════════════════════════════
+  Phase 3 of 3 — Story Development Pipeline
+═══════════════════════════════════════════════════
+
+Starting automated story development in BATCH mode...
+Processing all {backlog_count} backlog stories sequentially.
+
+For each story, the pipeline will:
+  1. Create story file from epics
+  2. Validate story (PM quality gate)
+  3. Develop implementation (TDD)
+  4. Adversarial code review
+  5. QA functional testing
+  6. Fix-and-retest loop (if needed)
+  7. Mark story as done
+
+Delegating to auto-story-pipeline...
+───────────────────────────────────────────────────
+```
+
+### 2. Execute Auto Story Pipeline
+
+Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/workflow.md`
+
+**Critical Full Pipeline Mode Instructions:**
+
+- **FULLY AUTOMATED:** Do NOT pause for user input at any point
+- **BATCH MODE:** When step-01 of the story pipeline asks for pipeline mode, select "batch" — process ALL backlog stories sequentially
+- Execute ALL 9 sub-steps of the story pipeline (step-01 through step-09)
+- The story pipeline will loop through its step-02 → step-09 cycle for each story:
+  - step-02: Create user story from epics and planning artifacts
+  - step-03: PM validation (quality gate, max 3 attempts)
+  - step-04: Development implementation (TDD)
+  - step-05: Adversarial code review (auto-fix HIGH/MEDIUM issues)
+  - step-06: QA functional testing (real data, no mocks)
+  - step-07: Fix-and-retest loop (max `{max_fix_iterations}` iterations)
+  - step-08: Complete story (mark done, update sprint status)
+  - step-09: Cycle check (find next story, loop back to step-02 or finalize)
+- **IMPORTANT:** The story pipeline's step-01 will validate prerequisites including sprint-status.yaml — since we just generated it in step-03 of this pipeline, this check should pass
+- **IMPORTANT:** The story pipeline's step-01 may attempt to auto-generate sprint-status.yaml if it can't find it — this is fine as a safety net, but should not be needed
+- Continue through ALL stories until the story pipeline reaches finalization in step-09 and completes
+- **Do NOT stop after individual story completions** — the batch mode cycle check (step-09) handles continuation automatically
+- **If a story HALTS** (e.g., fix iteration exceeded): The story pipeline's escalation logic handles this. The escalation report will be generated. The full pipeline should note this as a partial completion
+
+### 3. Verify Story Pipeline Output
+
+After the story pipeline completes (either all stories done or a HALT condition):
+
+1. **Re-read sprint-status.yaml** — Fresh read from disk to get final state
+2. **Count final statuses:**
+   - Stories with status "done"
+   - Stories with status "backlog" (not yet processed — may indicate early termination)
+   - Stories with status "in-progress" or "review" (stuck — may indicate HALT)
+3. **Determine Phase 3 result:**
+   - If ALL stories are "done": `{phase_3_status}` = "success"
+   - If SOME stories are "done" but others remain: `{phase_3_status}` = "partial" — Output WARNING with count of remaining stories
+   - If NO stories completed: `{phase_3_status}` = "failed" — Output ERROR
+
+### 4. Update Master Pipeline State
+
+- `{full_pipeline_status}` = "development-phase-complete"
+- `{full_steps_completed}` = 4
+
+**Output:**
+
+```
+───────────────────────────────────────────────────
+  ✅/⚠️/❌ Phase 3 Complete — Story Development
+───────────────────────────────────────────────────
+
+Stories Completed: {done_count}/{total_story_count}
+Stories Remaining: {remaining_count}
+
+Sprint Status Breakdown:
+  ✅ Done: {done_count}
+  ⬜ Backlog: {backlog_count}
+  🔄 In Progress: {in_progress_count}
+  👀 Review: {review_count}
+
+Phase 3 Status: {phase_3_status}
+Master Step: 4/5
+
+Proceeding to Finalization...
+───────────────────────────────────────────────────
+```
+
+**Auto-Proceed:** YES — Do NOT wait for user input. Immediately proceed to step-05.
+
+---
+
+## SUCCESS METRICS
+
+- Story pipeline executed in batch mode
+- All stories processed through create → validate → develop → review → test → complete
+- All story statuses updated to "done" in sprint-status.yaml
+- Epic statuses updated where all stories complete
+
+## FAILURE MODES
+
+- Story pipeline HALT propagated (escalation from fix loop)
+- Individual story validation fails after 3 attempts
+- Story creation fails (malformed epics)
+- Story pipeline unable to find backlog stories
+- Partial completion (some stories done, others stuck)

package/src/xmc/workflows/5-full-pipeline/auto-full-pipeline/steps/step-05-finalize.md

@@ -0,0 +1,194 @@
+---
+name: "step-05-finalize"
+description: "Generate unified completion report across both phases, validate all artifacts, and provide final summary"
+nextStepFile: null
+---
+
+# Step 5 of 5: Finalize Full Pipeline
+
+**Goal:** Validate all output artifacts from both phases, generate a unified completion report, and provide a comprehensive summary of the entire requirements-to-delivery pipeline execution.
+
+**Role:** Master Pipeline Orchestrator
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Validate All Artifacts
+
+Check that ALL expected output files exist from both phases:
+
+**Phase 1 — Requirements Artifacts:**
+
+1. `{planning_artifacts}/requirements-analysis.md`
+2. `{planning_artifacts}/current-architecture-analysis.md`
+3. `{planning_artifacts}/prd.md`
+4. `{planning_artifacts}/epics.md`
+5. `{planning_artifacts}/architecture.md`
+6. `{planning_artifacts}/pipeline-status.json`
+
+**Phase 2 — Sprint Planning Artifact:**
+
+7. `{implementation_artifacts}/sprint-status.yaml`
+
+**Phase 3 — Development Artifacts:**
+
+8. Story files at `{implementation_artifacts}/*.md` (one per story)
+
+For each missing artifact, log a warning. If PRD, Epics, or sprint-status.yaml are missing, this is a critical failure.
+
+### 2. Run Completion Checklist
+
+Load and evaluate: `{project-root}/_xiaoma/xmc/workflows/5-full-pipeline/auto-full-pipeline/checklist.md`
+
+Mark each item as passed or failed based on artifact verification and phase status tracking.
+
+### 3. Gather Final Statistics
+
+**From sprint-status.yaml (fresh read from disk):**
+
+- Total epics
+- Total stories
+- Stories by status (done, backlog, in-progress, review)
+- Epics completed (all stories done)
+
+**From pipeline tracking:**
+
+- Phase 1 iterations: `{analysis_iteration}`, `{architecture_iteration}`, `{validation_iteration}`
+- Phase 3 stories completed: `{stories_completed}`
+- Phase 3 total fix iterations across all stories
+
+### 4. Generate Unified Completion Report
+
+Set `{full_steps_completed}` = 5 and `{full_pipeline_status}` = "complete" now, before printing, so the report reflects the final accurate values.
+
+**Output:**
+
+```
+═══════════════════════════════════════════════════════════════
+  Auto Full Pipeline — COMPLETE
+═══════════════════════════════════════════════════════════════
+
+Project: {project_name}
+Date: {date}
+Master Steps Completed: {full_steps_completed}/5
+
+Phase 1 — Requirements Analysis          [{phase_1_status}]
+  ├─ Requirements Analysis                ✅/❌
+  ├─ Architecture Analysis                ✅/❌
+  ├─ PRD                                  ✅/❌
+  ├─ PRD Validation                       ✅/❌
+  ├─ Epics & Stories                      ✅/❌
+  └─ Architecture Design                  ✅/❌
+
+Phase 2 — Sprint Planning Bridge          [{phase_2_status}]
+  └─ sprint-status.yaml                   ✅/❌
+
+Phase 3 — Story Development               [{phase_3_status}]
+  ├─ Stories Completed: {done_count}/{total_story_count}
+  ├─ Epics Completed: {completed_epic_count}/{total_epic_count}
+  └─ Total Fix Iterations: {total_fix_iterations}
+
+Pipeline Status: {full_pipeline_status}
+═══════════════════════════════════════════════════════════════
+```
+
+### 5. Generate Machine-Readable Status File
+
+Write to: `{implementation_artifacts}/full-pipeline-status.json`
+
+```json
+{
+  "pipeline": "auto-full-pipeline",
+  "date": "{date}",
+  "project": "{project_name}",
+  "status": "{full_pipeline_status}",
+  "master_steps_completed": 5,
+  "phases": {
+    "requirements": {
+      "status": "{phase_1_status}",
+      "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}"
+      }
+    },
+    "sprint_planning": {
+      "status": "{phase_2_status}",
+      "artifact": "{implementation_artifacts}/sprint-status.yaml"
+    },
+    "development": {
+      "status": "{phase_3_status}",
+      "stories_completed": "{done_count}",
+      "stories_total": "{total_story_count}",
+      "epics_completed": "{completed_epic_count}",
+      "epics_total": "{total_epic_count}",
+      "total_fix_iterations": "{total_fix_iterations}"
+    }
+  }
+}
+```
+
+### 6. Provide Next Steps
+
+**If all stories completed ({phase_3_status} == "success"):**
+
+```
+🎉 All stories developed and delivered!
+
+🔜 Recommended Next Steps:
+  1. Review all implemented code and tests
+  2. Run epic-retrospective (ER) for completed epics
+  3. Consider deployment and release planning
+```
+
+**If partial completion ({phase_3_status} == "partial"):**
+
+```
+⚠️ Pipeline completed with {remaining_count} stories remaining.
+
+🔜 Recommended Next Steps:
+  1. Review escalation reports for blocked stories
+  2. Run /xiaoma-auto-story-pipeline to resume remaining stories
+  3. Use /xiaoma-correct-course (CC) if scope changes are needed
+```
+
+**If development failed ({phase_3_status} == "failed"):**
+
+```
+❌ Story development phase failed.
+
+🔜 Recommended Next Steps:
+  1. Check story pipeline logs for error details
+  2. Verify epics and architecture are well-formed
+  3. Run /xiaoma-auto-story-pipeline manually to diagnose
+```
+
+### 7. Pipeline Complete
+
+**Pipeline execution is COMPLETE. HALT.**
+
+---
+
+## SUCCESS METRICS
+
+- All 3 phases completed successfully
+- All planning artifacts verified
+- All stories developed and marked "done"
+- Machine-readable full-pipeline-status.json generated
+- Unified completion report generated
+- Next steps provided
+
+## FAILURE MODES
+
+- Missing critical artifacts from any phase
+- Partial story completion not properly reported
+- Not providing next steps for partial/failed completions
+- Not generating machine-readable status file

package/src/xmc/workflows/5-full-pipeline/auto-full-pipeline/workflow.md

@@ -0,0 +1,110 @@
+---
+name: auto-full-pipeline
+description: "Fully automated requirements-to-delivery pipeline: requirements analysis → PRD → epics → architecture → sprint planning → story creation → development → code review → testing → delivery. Use when the user says 'run full pipeline', 'auto full', 'end to end', or 'AFP'"
+---
+
+# Auto Full Pipeline Workflow
+
+**Goal:** Execute the complete automated software development lifecycle — from initial requirements document through requirements analysis, PRD creation, epic/story breakdown, architecture design, sprint planning, and iterative story development with code review and testing — as a single continuous pipeline.
+
+**Your Role:** Master Pipeline Orchestrator. You coordinate two sub-pipelines and a bridge step, switching expert roles as each phase demands:
+
+- **Phase 1 — Requirements Analysis** (delegates to auto-requirements-pipeline)
+  - Analyst (Mary) → Architect (Winston) → PM (John) → Architect (Winston)
+- **Phase 2 — Bridge** (sprint planning)
+  - SM (Bob) — Generate sprint tracking from epics
+- **Phase 3 — Story Development** (delegates to auto-story-pipeline)
+  - SM (Bob) → PM (John) → Dev (Amelia) → Reviewer → QA (Quinn)
+
+- 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
+
+## Context Management Strategy
+
+This pipeline may execute 8 + 5 + 9×N steps (where N = number of stories). To maintain coherence across long sessions:
+
+1. **Phase Boundary Summaries** — At the end of each Phase (Steps 02, 03, 04), output a concise state snapshot including all master pipeline variables, artifact paths produced, and story counts. This ensures critical state survives context compression.
+2. **Story Batch Checkpoints** — During Phase 3 (Step-04), the story pipeline's step-09 (cycle check) should output a running tally after every completed story: `"[Checkpoint] Stories done: X/Y, current story: {key}, phase_3 elapsed stories: X"`. This provides recovery anchors if context is compressed mid-batch.
+3. **Fresh File Reads Over Memory** — When resuming after context compression, always re-read `sprint-status.yaml` from disk rather than relying on in-memory state. The file on disk is the source of truth for story statuses.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** with delegation to existing sub-pipelines:
+
+- Step-01: Initialize and validate — unified prerequisite check
+- Step-02: Execute auto-requirements-pipeline — produces PRD, epics, architecture
+- Step-03: Bridge — auto-run sprint-planning to generate sprint-status.yaml
+- Step-04: Execute auto-story-pipeline — develop all stories in batch mode
+- Step-05: Finalize — unified completion report across both phases
+
+### State Variables
+
+**Pipeline-Level:**
+
+- `{full_pipeline_status}` — Current master phase: "initializing" → "requirements-phase" → "bridge-phase" → "development-phase" → "complete"
+- `{full_steps_completed}` — Count of master pipeline steps executed (1–5)
+- `{phase_1_status}` — Result of requirements pipeline: "success" | "success (resumed)" | "failed"
+- `{phase_2_status}` — Result of sprint planning bridge: "success" | "success (resumed)" | "failed"
+- `{phase_3_status}` — Result of story pipeline: "success" | "partial" | "failed"
+- `{resume_from_step}` — Step to resume from: 2 (fresh), 3 (skip Phase 1), or 4 (skip Phase 1+2)
+
+**Inherited from auto-requirements-pipeline (Phase 1):**
+
+- `{req_file_path}` — Path to requirements document
+- `{pipeline_status}` — Requirements pipeline phase tracking
+- `{steps_completed}` — Requirements pipeline step counter
+- `{validation_iteration}`, `{analysis_iteration}`, `{architecture_iteration}` — Retry counters
+
+**Inherited from auto-story-pipeline (Phase 3):**
+
+- `{pipeline_mode}` — Always "batch" in full pipeline
+- `{current_story_key}`, `{current_story_path}` — Current story tracking
+- `{fix_iteration}`, `{max_fix_iterations}` — Bug fix loop control
+- `{stories_completed}` — Story completion counter
+- `{backlog_count}`, `{ready_count}`, `{in_progress_count}`, `{review_count}`, `{done_count}` — Status counts
+
+### Pipeline Flow
+
+```
+Step-01 (Init) → Step-02 (Requirements Pipeline) → Step-03 (Sprint Planning Bridge) → Step-04 (Story Pipeline) → Step-05 (Finalize)
+                  ├─ 8 sub-steps internally           │                                  ├─ 9 sub-steps internally
+                  └─ Produces: PRD, epics,             │                                  └─ Produces: implemented stories,
+                     architecture, pipeline-status      │                                     passing tests, done statuses
+                                                        └─ Produces: sprint-status.yaml
+```
+
+---
+
+## 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/5-full-pipeline/auto-full-pipeline`
+- `requirements_pipeline` = `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/workflow.md`
+- `sprint_planning_workflow` = `{project-root}/_xiaoma/xmc/workflows/4-implementation/xiaoma-sprint-planning/workflow.md`
+- `story_pipeline` = `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/workflow.md`
+- `validation` = `{installed_path}/checklist.md`
+
+### Context
+
+- `project_context` = `**/project-context.md` (load if exists)
+
+---
+
+## EXECUTION
+
+Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/5-full-pipeline/auto-full-pipeline/steps/step-01-init-and-validate.md` to begin the pipeline.

package/src/xmc/workflows/5-full-pipeline/auto-full-pipeline/xiaoma-skill-manifest.yaml

@@ -0,0 +1,3 @@
+canonicalId: xiaoma-auto-full-pipeline
+type: workflow
+description: "Fully automated requirements-to-delivery pipeline: analyze → PRD → epics → architecture → sprint plan → develop → review → test → done. Use when the user says 'run full pipeline', 'auto full', 'end to end', or 'AFP'"