siesa-agents 2.1.44 → 2.1.46

package/bmad/bmm/workflows/4-implementation/code-review/steps/step-01-load-story.md

@@ -0,0 +1,101 @@
+---
+name: 'step-01-load-story'
+description: 'Load story file and discover actual implementation changes via git'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/code-review'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-load-story.md'
+nextStepFile: '{workflow_path}/steps/step-02-build-plan.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/review-{story_key}.md'
+
+# Data References
+checklist: '{workflow_path}/checklist.md'
+---
+
+# Step 1: Load Story and Discover Changes
+
+## STEP GOAL:
+To load the target story file, identify the implementation scope, and discover the actual changes in the codebase using git.
+
+## MANDATORY EXECUTION RULES:
+- 🛑 NEVER generate content without user input
+- 📖 Read the complete step file before taking any action
+- 📋 YOU ARE AN ADVERSARIAL CODE REVIEWER - Skeptical and thorough
+
+## EXECUTION PROTOCOLS:
+- 🎯 Load story and parse requirements
+- 🔍 Detect git changes
+- 💾 meaningful frontmatter updates
+
+## Sequence of Instructions
+
+### 1. Identify Target Story
+
+If `{{story_path}}` is not already defined in variables:
+Ask the user: "Which story file should we review? (Provide path or key)"
+
+### 2. Load Story Content
+
+1. Load and read the COMPLETE story file from `{{story_path}}`
+2. Extract the `story_key` (e.g., from filename "1-2-user-auth.md" -> "1-2-user-auth")
+3. Parse the following sections:
+   - **Story Description**
+   - **Acceptance Criteria**
+   - **Tasks/Subtasks**
+   - **Dev Agent Record** (specifically the File List)
+   - **Change Log**
+
+### 3. Discover Git Changes
+
+1. Check if a git repository exists in the current directory (`git rev-parse --is-inside-work-tree`)
+2. If yes:
+   - Run `git status --porcelain` to find uncommitted changes
+   - Run `git diff --name-only` to see modified files
+   - Run `git diff --cached --name-only` to see staged files
+   - Compile a list of **Actual Changed Files**
+3. If no:
+   - Note that review will rely solely on Story's File List (Warning)
+
+### 4. Cross-Reference Claims vs Reality
+
+Compare the Story's **Dev Agent Record -> File List** with the **Actual Changed Files**:
+- Identify **Files in Git but NOT in Story** (Undocumented changes)
+- Identify **Files in Story but NOT in Git** (False claims)
+- Identify **Missing Documentation**
+
+### 5. Load Project Context
+
+Load `{project_context}` (usually `**/project-context.md`) to understand coding standards.
+
+### 6. Initialize Output Review Document
+
+Create `{outputFile}` with initial analysis:
+
+```markdown
+# Code Review: {{story_key}}
+
+- **Date**: {{date}}
+- **Reviewer**: {{user_name}} (AI Agent)
+- **Status**: In Progress
+
+## Initial Discovery
+- **Undocumented Changes**: [List]
+- **Missing Files**: [List]
+```
+
+### 7. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+- IF A: Execute {advancedElicitationTask}
+- IF P: Execute {partyModeWorkflow}
+- IF C: Save analysis to {outputFile}, update frontmatter `stepsCompleted: [1]`, `story_path: ...`, `story_key: ...`, then only then load, read entire file, then execute {nextStepFile}
+- IF Others: Handle queries then redisplay menu
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input
+- ONLY proceed to next step when user selects 'C'

package/bmad/bmm/workflows/4-implementation/code-review/steps/step-02-build-plan.md

@@ -0,0 +1,89 @@
+---
+name: 'step-02-build-plan'
+description: 'Build a rigorous review attack plan based on requirements'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/code-review'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-02-build-plan.md'
+nextStepFile: '{workflow_path}/steps/step-03-review.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/review-{story_key}.md'
+---
+
+# Step 2: Build Review Attack Plan
+
+## STEP GOAL:
+To create a structured "attack plan" for the review, identifying exactly what needs to be verified based on the story's Acceptance Criteria and Tasks.
+
+## MANDATORY EXECUTION RULES:
+- 📋 YOU ARE AN ADVERSARIAL REVIEWER
+- 🎯 Don't trust; verify.
+- 📖 Read entire file before executing
+
+## Sequence of Instructions
+
+### 1. Extract Requirements
+
+From the loaded story file:
+1. Extract **ALL Acceptance Criteria (ACs)**
+2. Extract **ALL Tasks and Subtasks** that are marked as completed `[x]`
+3. Extract the **claimed implementation files**
+
+### 2. Identify Context Documents
+
+Based on the `input_file_patterns` strategy:
+1. Detect referenced Epic files (Selective Load)
+2. Detect Architecture documents (Full Load)
+3. Detect UX Design documents (if applicable)
+
+*Note: Do not read them yet, just identify which ones are relevant for the review.*
+
+### 3. Construct Review Matrix
+
+Create a plan to verify each item:
+
+1. **AC Validation Plan**:
+   - For each AC, define what defines "success".
+   - Identify which files likely contain the logic.
+
+2. **Task Audit Plan**:
+   - For each completed Task, define verifying evidence.
+   - Flag any tasks that seem subjective.
+
+3. **Code Quality Criteria**:
+   - Security (Injection, Auth, Input Validation)
+   - Performance (Loops, Queries, Caching)
+   - Maintainability (Naming, Structure, Comments)
+   - Tests (Real assertions vs placeholders, Coverage)
+
+### 4. Document Plan
+
+Append to `{outputFile}`:
+
+```markdown
+## Review Plan
+
+### Items to Verify
+- [ ] AC1: ...
+- [ ] AC2: ...
+- [ ] Task: ...
+
+### Focus Areas
+- Security checks on: [List files]
+- Performance checks on: [List files]
+```
+
+### 5. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+- IF C: Save plan to {outputFile}, update frontmatter `stepsCompleted: [1, 2]`, then load/execute {nextStepFile}
+- IF A/P: Execute respective flows
+- IF Others: Handle queries then loop
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input
+- ONLY proceed to next step when user selects 'C'

package/bmad/bmm/workflows/4-implementation/code-review/steps/step-03-review.md

@@ -0,0 +1,91 @@
+---
+name: 'step-03-review'
+description: 'Execute the adversarial code review and find specific issues'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/code-review'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-03-review.md'
+nextStepFile: '{workflow_path}/steps/step-04-fix.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/review-{story_key}.md'
+---
+
+# Step 3: Execute Adversarial Review
+
+## STEP GOAL:
+To execute the review plan, rigorously verifying every claim against the actual code, and finding at least 3-10 specific, actionable issues.
+
+## MANDATORY EXECUTION RULES:
+- 📋 VALIDATE EVERY CLAIM - Check git reality vs story claims
+- 🛑 NOT LOOKING HARD ENOUGH? Find more problems!
+- 🔍 Find minimum 3 specific issues
+
+## Sequence of Instructions
+
+### 1. Git vs Story Logic Check
+
+1. Analyze discrepancies found in Step 1.
+2. **Files in Git but not in Story**: Mark as MEDIUM finding (Incomplete documentation).
+3. **Files in Story but not in Git**: Mark as HIGH finding (False claims).
+4. **Uncommitted changes**: Mark as MEDIUM finding (Transparency).
+
+### 2. Comprehensive File Analysis
+
+Create a **Comprehensive File List** (Story List + Git Items).
+For EACH file in the list:
+1. **Read the file content**.
+2. **Code Quality Scan**:
+   - **Security**: SQLi, XSS, insecure deps, missing auth.
+   - **Performance**: N+1 queries, loops, memory usage.
+   - **Error Handling**: Empty catches, generic errors.
+   - **Maintainability**: Magic numbers, bad naming, monolithic functions.
+   - **Test Quality**: "Expect true to be true" patterns (Red Flag).
+
+### 3. AC & Task Verification
+
+1. **AC Validation**:
+   - Read specific lines implementing the AC.
+   - If missing/partial -> HIGH SEVERITY.
+2. **Task Completion Audit**:
+   - For items marked `[x]`, verify the code exists.
+   - If marked done but code missing -> CRITICAL FINDING.
+
+### 4. Re-Scan Loop
+
+**CRITICAL CHECK**: Do you have < 3 issues total?
+- If yes: **LOOK HARDER**.
+- Re-examine for edge cases, null handling, documentation gaps.
+- You MUST find at least 3 issues.
+
+### 5. Document Findings
+
+Append findings to `{outputFile}`:
+
+```markdown
+## Review Findings
+
+### Critical Issues (Must Fix)
+- [CRITICAL] Task X marked done but feature Y missing in `file.ts`.
+- [HIGH] AC Z not implemented.
+
+### Medium Issues (Should Fix)
+- [MED] Security risk in `auth.ts` line 42.
+
+### Low Issues (Nice to Fix)
+- [LOW] Variable naming in `utils.ts`.
+```
+
+### 6. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+- IF C: Save findings to {outputFile}, update frontmatter `stepsCompleted: [1, 2, 3]`, then load/execute {nextStepFile}
+- IF A/P: Execute respective flows
+- IF Others: Loop
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input
+- ONLY proceed to next step when user selects 'C'

package/bmad/bmm/workflows/4-implementation/code-review/steps/step-04-fix.md

@@ -0,0 +1,92 @@
+---
+name: 'step-04-fix'
+description: 'Present findings and facilitate fixes or task creation'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/code-review'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-04-fix.md'
+nextStepFile: '{workflow_path}/steps/step-05-sync-sprint.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/review-{story_key}.md'
+---
+
+# Step 4: Present and Fix Findings
+
+## STEP GOAL:
+To present the review findings to the user and either fix them automatically or convert them into action items for the story.
+
+## MANDATORY EXECUTION RULES:
+- 🛑 NEVER apply fixes without user choice
+- 💾 Update Story file if Action Items created
+
+## Sequence of Instructions
+
+### 1. Summarize Status
+
+Analyze the findings from the output file.
+Count: High, Medium, Low issues.
+
+Display to User:
+"**Review Complete!**
+Issues Found: {{High}} High, {{Medium}} Medium, {{Low}} Low."
+
+### 2. Present FIX MENU OPTIONS
+
+Display:
+"**What should I do with these issues?**
+[1] **Fix automatically** (I will update code and tests for High/Med issues)
+[2] **Create Action Items** (Add checklist to Story for later)
+[3] **Show Details** (Deep dive into specific issues)"
+
+**Wait for User Selection.**
+
+### 3. Handle Selection
+
+1. **If [1] Fix Automatically**:
+   - For all HIGH/MEDIUM issues:
+     - Generate fix code.
+     - Apply to files.
+     - Add/Update tests.
+   - Update Story Dev Record / File List.
+   - Record `fixed_count`.
+   - Proceed to Final Menu.
+
+2. **If [2] Create Action Items**:
+   - Create section "Review Follow-ups (AI)" in the Story file.
+   - Add checkbox items: `- [ ] [AI-Review][Severity] Description`
+   - Record `action_count`.
+   - Proceed to Final Menu.
+
+3. **If [3] Show Details**:
+   - Display full details of issues.
+   - Redisplay FIX MENU.
+
+### 4. Determine New Status
+
+Based on the outcome:
+- If **All Critical/High/Med Fixed** AND **ACs Done**: New Status = `done`
+- Else: New Status = `in-progress`
+
+Append to `{outputFile}`:
+```markdown
+## Fix Outcome
+- **Action Taken**: [Fixed/Tasks Created]
+- **Fixed Count**: X
+- **Task Count**: Y
+- **Recommended Status**: {{NewStatus}}
+```
+
+### 5. Present CONTINUATION MENU
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+- IF C: Save outcome to {outputFile}, update frontmatter `stepsCompleted: [1, 2, 3, 4]`, then load/execute {nextStepFile}
+- IF A/P: Execute respective flows
+- IF Others: Loop
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input
+- ONLY proceed to next step when user selects 'C'

package/bmad/bmm/workflows/4-implementation/code-review/steps/step-05-sync-sprint.md

@@ -0,0 +1,70 @@
+---
+name: 'step-05-sync-sprint'
+description: 'Update story status content and synchronize sprint tracking file'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/code-review'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-05-sync-sprint.md'
+nextStepFile: '{workflow_path}/steps/step-06-jira-sync.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/review-{story_key}.md'
+
+# Data References
+sprint_status_file: '{implementation_artifacts}/sprint-status.yaml'
+---
+
+# Step 5: Update Status and Sync Sprint
+
+## STEP GOAL:
+To officially update the story file's status field and synchronize the project's sprint-status.yaml file to reflect the review outcome.
+
+## MANDATORY EXECUTION RULES:
+- 💾 Persist all status changes
+- 🔄 Ensure consistency between Story and Sprint Status
+
+## Sequence of Instructions
+
+### 1. Update Story File
+
+Using the `New Status` determined in Step 4 (`done` or `in-progress`):
+1. **Load** the Story File.
+2. **Find** the `Status:` field in the metadata/header.
+3. **Update** it to the new status.
+4. **Save** the Story File.
+
+### 2. Update Sprint Status YAML
+
+Check if `{sprint_status_file}` exists.
+- **If NO**:
+  - Log "No sprint-status.yaml found. Skipping sync."
+
+- **If YES**:
+  1. **Load** `{sprint_status_file}`.
+  2. **Find** the key `development_status` matching `{{story_key}}`.
+  3. **Update** the value to the new status (`done` or `in-progress`).
+  4. **Save** the file, preserving comments and structure.
+  5. **Log**: "✅ Sprint status synced: {{story_key}} -> {{status}}".
+
+### 3. Log Result
+
+Append to `{outputFile}`:
+```markdown
+## Status Sync
+- **Story File Status**: Updated to {{status}}
+- **Sprint Status YAML**: [Synced/Skipped]
+```
+
+### 4. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Jira Sync"
+
+#### Menu Handling Logic:
+- IF C: Save result to {outputFile}, update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]`, then load/execute {nextStepFile}
+- IF A/P: Execute respective flows
+- IF Others: Loop
+
+#### EXECUTION RULES:
+- ALWAYS halt and wait for user input
+- ONLY proceed to next step when user selects 'C'

package/bmad/bmm/workflows/4-implementation/code-review/steps/step-06-jira-sync.md

@@ -0,0 +1,123 @@
+---
+name: 'step-06-jira-sync'
+description: 'Synchronize completion status with Jira and update documentation'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/code-review'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06-jira-sync.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/review-{story_key}.md'
+
+# User Defined References
+storyFile: '{{story_path}}'
+---
+
+# Step 6: Sync with Jira
+
+## STEP GOAL:
+To synchronize the "Done" status with Jira by transitioning the Story and its Subtasks, and updating the story document to reflect this synchronization.
+
+## MANDATORY EXECUTION RULES:
+- 🛑 ONLY execute if status is 'done'
+- 🧱 Use Pattern B (Cascading Updates) for Jira: Always discover transitions before executing
+- 📄 Update tables in Markdown without breaking format or losing data
+
+## Sequence of Instructions
+
+### 1. Conditional Execution Checker
+
+<check if="{{new_status}} == 'done'">
+
+  ### 2. Validation of Requirements
+
+  1. **Validate Auth**: Check if you can access Jira resources.
+     <action>Call `mcp__atlassian__getAccessibleAtlassianResources` or `mcp__atlassian__atlassianUserInfo`.</action>
+
+     <check if="Auth failed or no resources returned">
+        <action>STOP IMMEDIATELY.</action>
+        <output>❌ **MCP Authentication Failed.** I cannot connect to Jira. Please ensure you are authenticated with the Atlassian MCP server.</output>
+        <output>Run the following command to authenticate (copy and paste into your terminal/chat):</output>
+        <display>
+        ```bash
+        /mcp auth mcp-atlassian
+        ```
+        </display>
+        <output>
+        ℹ  Note: Authentication requires completing an OAuth flow in your web browser.
+           Follow the on-screen instructions provided by the CLI after running the command.
+        </output>
+        <output>After validating in the browser, please choose an option:</output>
+        <menu>
+           <item cmd="R" action="restart_step2">Retry Authentication (Re-run check)</item>
+           <item cmd="E" action="exit">Exit Workflow</item>
+        </menu>
+        <logic>
+            <if selection="R">Restart this Step 2 from the beginning.</if>
+            <if selection="E">Terminate the workflow with a message: "Workflow aborted due to authentication failure."</if>
+        </logic>
+     </check>
+
+  2. **Load Configuration**:
+     <action>Ensure `{cloud_id}` is available from `project_config.yaml`. If not, load it.</action>
+
+  3. **Validate Story Integrity**:
+     <action>Read `{story_path}`.</action>
+     <check if="content does NOT contain '## Jira Information' OR content does NOT contain '## Synced Tasks'">
+        <output>
+        ⚠️ **CRITICAL ERROR: Missing Jira Sections**
+        La historia no está vinculada a Jira. Por favor ejecuta el workflow 'sync-epics-stories' primero.
+        </output>
+        <action>STOP execution of this step.</action>
+     </check>
+
+  ### 3. Jira Transition Execution (Pattern B)
+
+  1. **Extract Key**: Identify the Jira Key (e.g., PIJB-62) from the story content. Let's call it `{{jira_key}}`.
+
+  2. **Transition Parent Story**:
+     - **Discovery**: Call `mcp__atlassian__getTransitionsForJiraIssue(issueIdOrKey="{{jira_key}}", cloudId="{{cloud_id}}")`.
+     - **Select**: Find the transition ID where `to.statusCategory.key` == "done" (or name "Listo"/"Finalizada"/"Done").
+     - **Execute**: Call `mcp__atlassian__transitionJiraIssue(issueIdOrKey="{{jira_key}}", transition={id: "FOUND_ID"}, cloudId="{{cloud_id}}")`.
+     - <output>✅ Historia {{jira_key}} movida a Done en Jira.</output>
+
+  3. **Transition Subtasks (Cascade)**:
+     - **Fetch Hierarchy**: Call `mcp__atlassian__getJiraIssue(issueIdOrKey="{{jira_key}}", cloudId="{{cloud_id}}")`.
+     - **Iterate**: For each subtask in `fields.subtasks`:
+       - **Discovery**: Call `getTransitionsForJiraIssue` for the subtask key (transitions vary by ID).
+       - **Select**: Find the "Done" transition ID.
+       - **Execute**: Call `transitionJiraIssue` for the subtask.
+     - <output>✅ Subtareas movidas a Done.</output>
+
+  ### 4. Update Markdown Tables
+
+  Modify `{{story_path}}` to reflect the new state:
+
+  <action>
+  1. Read `{{story_path}}`.
+  2. Locate `## Jira Information`: Add `| Jira State |` to header, `|---|` to divider, `| **Done** |` to data row.
+  3. Locate `## Synced Tasks`: Add `| Jira State |` to header, `|---|` to divider (if needed), and `| **Done** |` to each task row.
+  4. Save the file.
+  </action>
+
+  ### 5. Final Log
+
+  <action>Append to `{outputFile}`:</action>
+  <template-output>
+  ## Jira Sync
+  - **Story Transition**: Success
+  - **Subtasks Transitioned**: All moved to Done
+  - **Document Tables**: Updated with 'Done' state
+  </template-output>
+
+</check>
+
+<check if="{{new_status}} != 'done'">
+  <output>Status is '{{new_status}}'. Skipping Jira sync because code review outcome is not 'done'.</output>
+</check>
+
+### 6. Finish Workflow
+<action>Update frontmatter of `{outputFile}`: `stepsCompleted: [1, 2, 3, 4, 5, 6]`</action>
+<output>🎉 Code Review Workflow Completed.</output>
+<action>EXIT</action>

package/bmad/bmm/workflows/4-implementation/code-review/workflow.md

@@ -0,0 +1,57 @@
+---
+name: code-review
+description: "Adversarial Senior Developer Code Review. Validates stories, checks git changes, enforces strict quality, and syncs status with Jira."
+web_bundle: true
+---
+
+# Code Review
+
+**Goal:** Perform an adversarial code review to validate implementation against story requirements, finding at least 3-10 specific issues, and synchronize status with project tracking.
+
+**Your Role:** In addition to your name, communication_style, and persona, you are an **Adversarial Senior Developer**. You verify claims against reality. You doubt everything until proven. You bring deep code quality expertise, while the user brings the implementation to be reviewed. Work together to perfect the code.
+
+## WORKFLOW ARCHITECTURE
+
+### Core Principles
+
+- **Micro-file Design**: Each step of the overall goal is a self contained instruction file that you will adhere too 1 file as directed at a time
+- **Just-In-Time Loading**: Only 1 current step file will be loaded, read, and executed to completion - never load future step files until told to do so
+- **Sequential Enforcement**: Sequence within the step files must be completed in order, no skipping or optimization allowed
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array when a workflow produces a document
+- **Append-Only Building**: Build documents by appending content as directed to the output file
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: If the step has a menu with Continue as an option, only proceed to next step when user selects 'C' (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, load, read entire file, then execute the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- 🛑 **NEVER** load multiple step files simultaneously
+- 📖 **ALWAYS** read entire step file before execution
+- 🚫 **NEVER** skip steps or optimize the sequence
+- 💾 **ALWAYS** update frontmatter of output files when writing the final output for a specific step
+- 🎯 **ALWAYS** follow the exact instructions in the step file
+- ⏸️ **ALWAYS** halt at menus and wait for user input
+- 📋 **NEVER** create mental todo lists from future steps
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Module Configuration Loading
+
+Load and read full config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+
+- `project_name`, `output_folder`, `user_name`, `communication_language`, `document_output_language`
+- `user_skill_level`, `planning_artifacts`, `implementation_artifacts`
+
+### 2. First Step EXECUTION
+
+Load, read the full file and then execute `{workflow_root}/steps/step-01-load-story.md` to begin the workflow.
+
+*(Note: `workflow_root` is `{project-root}/_bmad/bmm/workflows/4-implementation/code-review`)*

package/bmad/bmm/workflows/sync-epics-stories/completion-summary-sync-epics-stories.md

@@ -0,0 +1,43 @@
+---
+workflowName: sync-epics-stories
+creationDate: 2026-01-13
+module: bmm
+status: COMPLETE
+stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+---
+
+# Workflow Creation Summary
+
+## Workflow Information
+
+- **Name:** sync-epics-stories
+- **Module:** bmm (Created via bmb-creations)
+- **Created:** 2026-01-13
+- **Location:** _bmad-output/bmb-creations/workflows/sync-epics-stories
+
+## Generated Files
+
+- `workflow.md`
+- `steps/step-01-init.md`
+- `steps/step-01b-continue.md`
+- `steps/step-02-setup.md`
+- `steps/step-03-scope.md`
+- `steps/step-04-epics.md`
+- `steps/step-05-stories.md`
+
+## Quick Start Guide
+
+**To run this workflow:**
+
+1.  Ensure you have `mcp-atlassian` configured and authenticated.
+2.  Ensure you have your artifacts ready at:
+    - `_bmad-output/planning-artifacts/epics.md`
+    - `_bmad-output/planning-artifacts/stories.md`
+3.  Command an agent to run the workflow:
+    > "Execute the workflow at `_bmad-output/bmb-creations/workflows/sync-epics-stories/workflow.md`"
+
+## Next Steps
+
+1.  **Run a Test:** Execute the workflow with a small set of epics/stories (or backups) first.
+2.  **Verify Jira:** Check that issues are created correctly and linked.
+3.  **Check Docs:** Verify that your local markdown files are updated with the Sync Status blocks.