@zeyue0329/xiaoma-cli 1.6.4 → 1.7.0

package/src/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-06-test-story.md

@@ -0,0 +1,144 @@
+---
+name: "step-06-test-story"
+description: "Perform functional testing with real data using QA role"
+nextStepFile: "./step-08-complete-story.md"
+nextStepFile_fail: "./step-07-fix-and-retest.md"
+---
+
+# Step 6 of 9: QA Functional Testing
+
+**Goal:** Perform comprehensive functional testing using real data to verify all acceptance criteria are met.
+
+**Role:** QA (Quinn) — Quality Assurance Engineer
+
+---
+
+## CORE TESTING PRINCIPLE
+
+**ALL tests MUST use real data. Mock data is strictly forbidden.**
+
+- Query APIs MUST return data from the actual database
+- Create operations MUST insert real records and verify in database
+- Update operations MUST modify real records and verify changes
+- Delete operations MUST remove/soft-delete real records and verify
+- End-to-end flows MUST validate the complete data pipeline
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Switch to QA Role
+
+Adopt the QA persona:
+- You are Quinn, the QA Engineer focused on functional correctness
+- Your mission: verify every acceptance criterion with real data
+- Zero tolerance for mock data or fake test passes
+- Test from the user's perspective — does it actually work?
+
+### 2. Load Story and Implementation Context
+
+1. Read the COMPLETE story file at `{current_story_path}`
+2. Extract all Acceptance Criteria
+3. Load the File List to identify all implementation files
+4. Load project context for testing standards
+
+### 3. Generate Automated Tests (Delegate)
+
+Invoke the `xiaoma-qa-generate-e2e-tests` skill to generate automated test files:
+
+**CRITICAL PIPELINE MODE INSTRUCTIONS:**
+- This is running in **automated pipeline mode** — do NOT pause for user input
+- Auto-detect the project's test framework (playwright, jest, vitest, cypress, etc.)
+- Auto-discover features from the story's implementation files
+- Generate API tests for any new/modified endpoints
+- Generate E2E tests for any new/modified UI features
+- Run the generated tests to verify they pass; fix any failures immediately
+
+If the project has no test framework or tests are not applicable for this story type, skip this step and proceed directly to functional verification.
+
+### 4. Execute Functional Test Sequence
+
+Perform tests in priority order:
+
+**4.1 Acceptance Criteria Verification**
+- For EACH acceptance criterion:
+  1. Design a test scenario that exercises the AC
+  2. Execute the test using real application flow
+  3. Verify expected outcomes against actual results
+  4. Record: PASS / FAIL with evidence
+
+**4.2 Database Operation Testing (Real Data)**
+- Query tests: Call API → verify response matches actual database state
+- Create tests: Call API → query database to verify record insertion
+- Update tests: Call API → query database to verify record modification
+- Delete tests: Call API → query database to verify record removal/soft-delete
+
+**4.3 API Contract Testing**
+- Verify request/response formats match specifications
+- Test error responses for invalid inputs
+- Validate authentication/authorization requirements
+- Check pagination, filtering, sorting if applicable
+
+**4.4 Business Logic End-to-End Testing**
+- Execute complete business workflows
+- Verify data flows correctly through all layers
+- Test boundary conditions and edge cases
+- Validate error handling and user-facing messages
+
+**4.5 Data Integrity Verification**
+- Verify referential integrity after operations
+- Check data consistency across related entities
+- Validate business rule enforcement at data level
+
+### 5. Compile Test Results
+
+Create a test results summary:
+- Total ACs tested: {ac_count}
+- ACs passed: {ac_pass_count}
+- ACs failed: {ac_fail_count}
+- Issues found: List with severity (HIGH/MEDIUM/LOW)
+- Overall gate decision: PASS / FAIL
+
+### 6. Evaluate Test Outcome
+
+**IF all ACs pass AND no HIGH severity issues:**
+- Output: "QA testing PASSED. All {ac_count} acceptance criteria verified with real data. Proceeding to completion."
+- **NEXT:** Proceed to step-08 (complete story)
+
+**IF any AC fails OR HIGH severity issues found:**
+- Output: "QA testing FAILED. {ac_fail_count} acceptance criteria not met. Issues: {issue_list}"
+- Record test failures in story file under QA Results section
+- **NEXT:** Proceed to step-07 (fix and retest)
+
+### 7. Pipeline Status Update
+
+- Set `{pipeline_status}` = "qa-testing-complete" (if passed) or "qa-testing-failed" (if failed)
+- Set `{steps_completed}` = `{steps_completed}` + 1
+
+---
+
+## NEXT STEP
+
+**If tests pass:**
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-08-complete-story.md`
+
+**If tests fail:**
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-07-fix-and-retest.md`
+
+---
+
+## SUCCESS METRICS
+
+- All acceptance criteria tested with real data
+- All database operations verified against actual database state
+- API contracts validated with real requests/responses
+- End-to-end business flows tested
+- No mock data used in any test
+- PASS gate decision achieved
+
+## FAILURE MODES
+
+- Using mock data instead of real database queries
+- Skipping acceptance criteria during testing
+- Not verifying database state after write operations
+- Marking tests as PASS without evidence

package/src/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-07-fix-and-retest.md

@@ -0,0 +1,121 @@
+---
+name: "step-07-fix-and-retest"
+description: "Fix bugs found in review/testing, then re-run tests. Self-referencing loop with max 5 iterations."
+nextStepFile: "./step-08-complete-story.md"
+nextStepFile_loop: "./step-07-fix-and-retest.md"
+---
+
+# Step 7 of 9: Fix and Retest
+
+**Goal:** Analyze failures from code review or QA testing, apply targeted fixes, and re-run tests. This step loops until all issues are resolved or the iteration limit is reached.
+
+**Role:** Dev (Amelia) — Bug Fixer
+
+---
+
+## CONFIGURATION
+
+Load from `{project-root}/_xiaoma/xmc/config.yaml`:
+- `max_fix_iterations` (default: 5) — Maximum number of fix-and-retest cycles allowed per story
+- If not specified in config, use default value of 5
+
+Set `{max_fix_iterations}` from config (or default 5).
+
+## LOOP CONTROL
+
+1. Increment `{fix_iteration}` by 1
+2. **IF `{fix_iteration}` > `{max_fix_iterations}`:**
+   - HALT — "Fix iteration limit reached ({max_fix_iterations} attempts) for story {current_story_key}. Remaining issues: {unresolved_issues}. Manual intervention required."
+   - Output a summary of all fix attempts and remaining issues
+   - **DO NOT CONTINUE** — This is a hard stop
+
+3. Set `{steps_completed}` = `{steps_completed}` + 1
+4. Output: "Fix Iteration {fix_iteration}/{max_fix_iterations} for story {current_story_key}"
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Switch to Dev Role
+
+Adopt the Dev persona:
+- You are Amelia, focused on precise bug fixing
+- Analyze root causes, not just symptoms
+- Fix issues without introducing regressions
+
+### 2. Analyze Failure Context
+
+1. Read the COMPLETE story file at `{current_story_path}`
+2. Identify the source of failures:
+   - Code review findings (from step-05): Check Dev Agent Record for review issues
+   - QA test failures (from step-06): Check QA Results section for test failures
+3. Compile a prioritized fix list:
+   - **Priority 1:** HIGH severity issues / failed acceptance criteria
+   - **Priority 2:** MEDIUM severity issues / partial AC failures
+   - **Priority 3:** LOW severity issues (fix if time permits)
+
+### 3. Build Fix Plan
+
+For each issue in priority order:
+1. Identify the root cause (not just the symptom)
+2. Determine the minimal fix that resolves the issue
+3. Identify which tests need to be added/updated
+4. Check for potential ripple effects on other components
+
+### 4. Apply Fixes
+
+For each fix in the plan:
+1. Implement the code fix
+2. Add or update tests to cover the fixed behavior
+3. Run the specific test to verify the fix works
+4. Run the full test suite to verify no regressions
+5. Update the story file:
+   - Add fix details to Dev Agent Record → Debug Log
+   - Update File List with modified files
+   - Add Change Log entry: "Fix iteration {fix_iteration}: {fix_summary}"
+
+### 5. Re-Run Full Validation
+
+After all fixes are applied:
+
+1. Run all unit tests
+2. Run all integration tests
+3. Run full regression suite
+4. Re-verify each previously failed acceptance criterion
+
+### 6. Evaluate Fix Results
+
+**IF all tests pass AND all previously failed ACs now pass:**
+- Output: "All issues resolved in fix iteration {fix_iteration}. Tests passing. Proceeding to completion."
+- **NEXT:** Proceed to step-08 (complete story)
+
+**IF some issues remain:**
+- Output: "Fix iteration {fix_iteration} resolved {fixed_count} issues. {remaining_count} issues remain: {remaining_list}"
+- **NEXT:** Loop back to this step (step-07) for another iteration
+
+---
+
+## NEXT STEP
+
+**If all issues resolved:**
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-08-complete-story.md`
+
+**If issues remain and `{fix_iteration}` <= `{max_fix_iterations}`:**
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-07-fix-and-retest.md`
+
+---
+
+## SUCCESS METRICS
+
+- All HIGH and MEDIUM issues resolved
+- All previously failed acceptance criteria now pass
+- Full test suite passes with no regressions
+- Fix details documented in story file
+- Resolution achieved within `{max_fix_iterations}` iterations
+
+## FAILURE MODES
+
+- Fixing symptoms instead of root causes (leads to recurring failures)
+- Introducing new regressions while fixing existing issues
+- Exceeding `{max_fix_iterations}` fix iterations without resolution
+- Not running regression tests after each fix

package/src/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-08-complete-story.md

@@ -0,0 +1,115 @@
+---
+name: "step-08-complete-story"
+description: "Mark story as done, update sprint-status, and generate completion summary"
+nextStepFile: "./step-09-cycle-check.md"
+---
+
+# Step 8 of 9: Complete Story
+
+**Goal:** Mark the story as done, sync all tracking artifacts, and generate a completion summary.
+
+**Role:** Pipeline Orchestrator
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Final Validation
+
+Before marking complete, verify all gates:
+1. Read the COMPLETE story file at `{current_story_path}`
+2. Verify ALL tasks and subtasks are marked [x]
+3. Verify ALL acceptance criteria have been tested and passed
+4. Verify no unresolved HIGH or MEDIUM issues remain
+5. Verify the full test suite passes
+
+If any gate fails: **DO NOT mark as done** — return to the appropriate step:
+- Incomplete tasks → step-04 (develop)
+- Failed tests → step-07 (fix and retest)
+- Unresolved review issues → step-07 (fix and retest)
+
+### 2. Update Story Status
+
+1. Update the story Status field to "done"
+2. Add completion timestamp to Dev Agent Record
+3. Add final Change Log entry: "Story completed via auto-pipeline on {date}"
+4. Save the story file
+
+### 3. Update Sprint Status
+
+1. Load the FULL file: `{sprint_status}`
+2. Find `development_status` key matching `{current_story_key}`
+3. Update `development_status[{current_story_key}]` = "done"
+4. Update `last_updated` field to current date
+5. Save file, preserving ALL comments and structure
+
+### 4. Check Epic Completion
+
+1. Extract `{epic_num}` from `{current_story_key}` using pattern matching:
+   - Pattern: story key must match `{epic_num}-{story_num}-{name}` where epic_num and story_num are positive integers
+   - Extract: Read first numeric component before first dash
+   - Example: "1-2-user-auth" → epic_num = "1"
+   - Example: "12-3-payment-flow" → epic_num = "12"
+   - Skip keys that don't match pattern (e.g., "epic-1-retrospective" is an epic marker, not a story)
+   - If key doesn't match expected pattern: Output WARNING — "Could not extract epic number from {current_story_key}. Skipping epic completion check." and skip to section 5
+   - If extraction fails for any reason: Continue without epic update (non-blocking)
+2. In sprint-status.yaml, find all stories for epic `{epic_num}` (pattern: `{epic_num}-*`, excluding epic markers like `epic-{epic_num}` and retrospectives like `epic-{epic_num}-retrospective`)
+3. Check if ALL stories in this epic have status "done"
+4. If all stories are done:
+   - Update `development_status[epic-{epic_num}]` = "done"
+   - Output: "Epic {epic_num} fully completed! All stories are done."
+5. If some stories remain:
+   - Output: "Epic {epic_num}: {done_in_epic}/{total_in_epic} stories completed."
+
+### 5. Generate Completion Summary
+
+Increment `{stories_completed}` by 1
+
+Output:
+```
+Story {current_story_key} — COMPLETED
+
+Summary:
+- Story: {story_title}
+- File: {current_story_path}
+- Status: done
+- Fix Iterations Used: {fix_iteration}
+- Stories Completed This Pipeline Run: {stories_completed}
+
+Pipeline Phases Completed:
+  [x] Story Creation (SM)
+  [x] Story Validation (PM)
+  [x] Development (Dev)
+  [x] Code Review (Reviewer)
+  [x] QA Testing (QA)
+  [x] Status Updated (done)
+```
+
+### 6. Pipeline Status Update
+
+- Set `{pipeline_status}` = "story-completed"
+- Reset `{fix_iteration}` = 0 (for next story if batch mode)
+- Set `{steps_completed}` = `{steps_completed}` + 1
+
+---
+
+## NEXT STEP
+
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-09-cycle-check.md`
+
+---
+
+## SUCCESS METRICS
+
+- Story status set to "done" in story file
+- Sprint-status.yaml updated with "done" for story key
+- Epic completion checked and updated if applicable
+- Completion summary generated
+- `{stories_completed}` counter incremented
+
+## FAILURE MODES
+
+- Marking story done without verifying all gates
+- Not updating sprint-status.yaml
+- Not checking epic-level completion
+- Not resetting fix_iteration for next story

package/src/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-09-cycle-check.md

@@ -0,0 +1,135 @@
+---
+name: "step-09-cycle-check"
+description: "Check if there are more stories to process. Loop back for batch mode or finalize the pipeline."
+nextStepFile_loop: "./step-02-create-story.md"
+nextStepFile: null
+---
+
+# Step 9 of 9: Cycle Check
+
+**Goal:** Determine if the pipeline should process another story (batch mode) or finalize (single mode / all stories done).
+
+**Role:** Pipeline Orchestrator
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Check Pipeline Mode
+
+**IF `{pipeline_mode}` == "single":**
+- This was a single-story run — proceed directly to finalization (section 4)
+
+**IF `{pipeline_mode}` == "batch":**
+- Continue to section 2 to check for more stories
+
+### 2. Find Next Processable Story
+
+1. Load the FULL file: `{sprint_status}`
+2. Read ALL lines from beginning to end — do not skip any content
+3. Parse the `development_status` section completely
+4. First, find the FIRST story (reading top to bottom) where:
+   - Key matches pattern: number-number-name (e.g., "1-2-user-auth")
+   - NOT an epic key (epic-X) or retrospective (epic-X-retrospective)
+   - Status value equals "backlog"
+5. If no "backlog" story is found, search again for the FIRST story where:
+   - Key matches the same pattern (not epic, not retrospective)
+   - Status value equals "ready-for-dev"
+   - *(Mirrors step-01's initial story selection: "backlog, or ready-for-dev if no backlog")*
+
+### 3. Evaluate Next Story
+
+**IF a backlog or ready-for-dev story is found:**
+- Set `{current_story_key}` = found story key
+- Set `{current_story_path}` = "" (will be set during creation/validation)
+- Set `{fix_iteration}` = 0
+
+**3.5. Batch Mode Progress Checkpoint**
+
+Before looping back to step-02 for the next story, output a progress summary:
+
+```
+═══════════════════════════════════════════════════
+  Batch Progress Checkpoint
+═══════════════════════════════════════════════════
+- Stories Completed So Far: {stories_completed}
+- Starting Next Story: {current_story_key} (status: {found_status})
+- Sprint Status: Backlog {backlog_count} | Ready {ready_count} | In Progress {in_progress_count} | Review {review_count} | Done {done_count}
+- Pipeline Continuing...
+═══════════════════════════════════════════════════
+```
+
+- **NEXT:** Loop back to step-02 (create story) — step-02's section 1 skip logic will detect "ready-for-dev" stories, skip creation, and route them to step-03 (validate) before development begins
+
+**IF no backlog or ready-for-dev story is found:**
+- All processable stories have been completed — proceed to finalization (section 4)
+
+### 4. Pipeline Finalization
+
+**4.1 Refresh Sprint Status Counters**
+
+Before generating the final report, reload current sprint status to get up-to-date counts (these values were set at pipeline start and may be stale after processing multiple stories in batch mode):
+
+1. Load the FULL file: `{sprint_status}`
+2. Read ALL lines from beginning to end — do not skip any content
+3. Recount all stories by current status:
+   - Update `{backlog_count}` — Stories with status "backlog"
+   - Update `{ready_count}` — Stories with status "ready-for-dev"
+   - Update `{in_progress_count}` — Stories with status "in-progress"
+   - Update `{review_count}` — Stories with status "review"
+   - Update `{done_count}` — Stories with status "done"
+
+**4.2 Generate Final Report**
+
+Output:
+```
+Auto Story Pipeline — COMPLETE
+
+Pipeline Summary:
+- Mode: {pipeline_mode}
+- Stories Completed: {stories_completed}
+- Steps Executed: {steps_completed}
+- Pipeline Status: finalized
+
+Stories Processed:
+{for each completed story: key, title, fix iterations used}
+
+Sprint Status (current):
+- Backlog: {backlog_count} remaining
+- Ready for Dev: {ready_count}
+- In Progress: {in_progress_count}
+- In Review: {review_count}
+- Done: {done_count}
+
+The automated story development pipeline has finished.
+```
+
+**IF `{backlog_count}` == 0 AND `{ready_count}` == 0 AND `{in_progress_count}` == 0 AND `{review_count}` == 0:**
+- Output: "All stories in the sprint are complete! Consider running epic-retrospective (ER) to review the work."
+
+**HALT** — Pipeline complete.
+
+---
+
+## NEXT STEP
+
+**If more stories to process (batch mode):**
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-02-create-story.md`
+
+**If pipeline complete:**
+**HALT** — Output final report and end.
+
+---
+
+## SUCCESS METRICS
+
+- Correct determination of whether to continue or finalize
+- Next story correctly identified for batch mode
+- State variables properly reset for next cycle
+- Comprehensive final report generated
+
+## FAILURE MODES
+
+- Continuing batch mode when no backlog or ready-for-dev stories remain
+- Not resetting state variables for next story cycle
+- Skipping final report generation

package/src/xmc/workflows/4-implementation/auto-story-pipeline/workflow.md

@@ -0,0 +1,91 @@
+---
+name: auto-story-pipeline
+description: "Automated end-to-end story development pipeline: create → validate → develop → review → test → fix → done. Use when the user says 'run auto pipeline', 'automate story development', or 'auto story pipeline'"
+---
+
+# Auto Story Pipeline Workflow
+
+**Goal:** Execute the complete automated story development lifecycle — from story creation through validation, development, code review, testing, bug fixing, and final delivery — as a single continuous pipeline.
+
+**Your Role:** Pipeline Orchestrator. You switch expert roles at each phase:
+- **SM (Bob)** — Story creation and sprint coordination
+- **PM (John)** — Story validation and quality gate
+- **Dev (Amelia)** — Code implementation and bug fixing
+- **Reviewer** — Adversarial code review
+- **QA (Quinn)** — Functional testing with real data
+
+- 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
+
+- `{pipeline_mode}` — "single" (one story) or "batch" (all backlog stories)
+- `{current_story_key}` — Key of story being processed (e.g., "1-2-user-auth")
+- `{current_story_path}` — Full path to current story file (derived in step-01 after resolving `{current_story_key}`; re-set in step-02 skip branch for batch cycles)
+- `{fix_iteration}` — Bug fix loop counter (max 5)
+- `{stories_completed}` — Count of stories completed in this pipeline run
+- `{pipeline_status}` — Current pipeline phase for tracking
+- `{validation_attempt}` — Story validation attempt counter (used in step-03, max 3)
+- `{steps_completed}` — Count of pipeline step files executed in this run (initialized to 0 in step-01)
+- `{backlog_count}` — Count of stories with status "backlog" (initialized in step-01)
+- `{ready_count}` — Count of stories with status "ready-for-dev" (initialized in step-01)
+- `{in_progress_count}` — Count of stories with status "in-progress" (initialized in step-01)
+- `{review_count}` — Count of stories with status "review" (initialized in step-01)
+- `{done_count}` — Count of stories with status "done" (initialized in step-01)
+
+### Status Machine
+
+Stories progress through these states:
+- `backlog` → `ready-for-dev` → `in-progress` → `review` → `done`
+
+---
+
+## 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/4-implementation/auto-story-pipeline`
+- `sprint_status` = `{implementation_artifacts}/sprint-status.yaml`
+- `validation` = `{installed_path}/checklist.md`
+
+### Related Workflows
+
+These existing workflows contain the detailed logic that pipeline steps delegate to:
+
+- `create_story_workflow` = `{project-root}/_xiaoma/xmc/workflows/4-implementation/xiaoma-create-story/workflow.md`
+- `dev_story_workflow` = `{project-root}/_xiaoma/xmc/workflows/4-implementation/xiaoma-dev-story/workflow.md`
+- `code_review_workflow` = `{project-root}/_xiaoma/xmc/workflows/4-implementation/xiaoma-code-review/workflow.md`
+- `qa_test_workflow` = `{project-root}/_xiaoma/xmc/workflows/xiaoma-qa-generate-e2e-tests/workflow.md`
+
+### Context
+
+- `project_context` = `**/project-context.md` (load if exists)
+
+---
+
+## EXECUTION
+
+Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/4-implementation/auto-story-pipeline/steps/step-01-init-and-validate.md` to begin the pipeline.

package/src/xmc/workflows/4-implementation/auto-story-pipeline/xiaoma-skill-manifest.yaml

@@ -0,0 +1,3 @@
+canonicalId: xiaoma-auto-story-pipeline
+type: workflow
+description: "Automated end-to-end story development pipeline. Use when the user says 'run auto pipeline', 'automate story development', or 'auto story pipeline'"

package/src/xmc/workflows/4-implementation/xiaoma-code-review/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: xiaoma-code-review
+description: 'Perform adversarial code review finding specific issues. Use when the user says "run code review" or "review this code"'
+---
+
+Follow the instructions in [workflow.md](workflow.md).

package/src/xmc/workflows/4-implementation/xiaoma-code-review/SKILL.md.bak

@@ -0,0 +1,6 @@
+---
+name: bmad-code-review
+description: 'Perform adversarial code review finding specific issues. Use when the user says "run code review" or "review this code"'
+---
+
+Follow the instructions in [workflow.md](workflow.md).