ma-agents 3.4.7 → 3.4.8

package/.opencode/skills/bmad-create-story/workflow.md

@@ -0,0 +1,380 @@
+# Create Story Workflow
+
+**Goal:** Create a comprehensive story file that gives the dev agent everything needed for flawless implementation.
+
+**Your Role:** Story context engine that prevents LLM developer mistakes, omissions, or disasters.
+- Communicate all responses in {communication_language} and generate all documents in {document_output_language}
+- Your purpose is NOT to copy from epics - it's to create a comprehensive, optimized story file that gives the DEV agent EVERYTHING needed for flawless implementation
+- COMMON LLM MISTAKES TO PREVENT: reinventing wheels, wrong libraries, wrong file locations, breaking regressions, ignoring UX, vague implementations, lying about completion, not learning from past work
+- EXHAUSTIVE ANALYSIS REQUIRED: You must thoroughly analyze ALL artifacts to extract critical context - do NOT be lazy or skim! This is the most important function in the entire development process!
+- UTILIZE SUBPROCESSES AND SUBAGENTS: Use research subagents, subprocesses or parallel processing if available to thoroughly analyze different artifacts simultaneously and thoroughly
+- SAVE QUESTIONS: If you think of questions or clarifications during analysis, save them for the end after the complete story is written
+- ZERO USER INTERVENTION: Process should be fully automated except for initial epic/story selection or missing documents
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_bmad/bmm/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
+
+- `sprint_status` = `{implementation_artifacts}/sprint-status.yaml`
+- `epics_file` = `{planning_artifacts}/epics.md`
+- `prd_file` = `{planning_artifacts}/prd.md`
+- `architecture_file` = `{planning_artifacts}/architecture.md`
+- `ux_file` = `{planning_artifacts}/*ux*.md`
+- `story_title` = "" (will be elicited if not derivable)
+- `project_context` = `**/project-context.md` (load if exists)
+- `default_output_file` = `{implementation_artifacts}/{{story_key}}.md`
+
+### Input Files
+
+| Input | Description | Path Pattern(s) | Load Strategy |
+|-------|-------------|------------------|---------------|
+| prd | PRD (fallback - epics file should have most content) | whole: `{planning_artifacts}/*prd*.md`, sharded: `{planning_artifacts}/*prd*/*.md` | SELECTIVE_LOAD |
+| architecture | Architecture (fallback - epics file should have relevant sections) | whole: `{planning_artifacts}/*architecture*.md`, sharded: `{planning_artifacts}/*architecture*/*.md` | SELECTIVE_LOAD |
+| ux | UX design (fallback - epics file should have relevant sections) | whole: `{planning_artifacts}/*ux*.md`, sharded: `{planning_artifacts}/*ux*/*.md` | SELECTIVE_LOAD |
+| epics | Enhanced epics+stories file with BDD and source hints | whole: `{planning_artifacts}/*epic*.md`, sharded: `{planning_artifacts}/*epic*/*.md` | SELECTIVE_LOAD |
+
+---
+
+## EXECUTION
+
+<workflow>
+
+<step n="1" goal="Determine target story">
+  <check if="{{story_path}} is provided by user or user provided the epic and story number such as 2-4 or 1.6 or epic 1 story 5">
+    <action>Parse user-provided story path: extract epic_num, story_num, story_title from format like "1-2-user-auth"</action>
+    <action>Set {{epic_num}}, {{story_num}}, {{story_key}} from user input</action>
+    <action>GOTO step 2a</action>
+  </check>
+
+  <action>Check if {{sprint_status}} file exists for auto discover</action>
+  <check if="sprint status file does NOT exist">
+    <output>🚫 No sprint status file found and no story specified</output>
+    <output>
+      **Required Options:**
+      1. Run `sprint-planning` to initialize sprint tracking (recommended)
+      2. Provide specific epic-story number to create (e.g., "1-2-user-auth")
+      3. Provide path to story documents if sprint status doesn't exist yet
+    </output>
+    <ask>Choose option [1], provide epic-story number, path to story docs, or [q] to quit:</ask>
+
+    <check if="user chooses 'q'">
+      <action>HALT - No work needed</action>
+    </check>
+
+    <check if="user chooses '1'">
+      <output>Run sprint-planning workflow first to create sprint-status.yaml</output>
+      <action>HALT - User needs to run sprint-planning</action>
+    </check>
+
+    <check if="user provides epic-story number">
+      <action>Parse user input: extract epic_num, story_num, story_title</action>
+      <action>Set {{epic_num}}, {{story_num}}, {{story_key}} from user input</action>
+      <action>GOTO step 2a</action>
+    </check>
+
+    <check if="user provides story docs path">
+      <action>Use user-provided path for story documents</action>
+      <action>GOTO step 2a</action>
+    </check>
+  </check>
+
+  <!-- Auto-discover from sprint status only if no user input -->
+  <check if="no user input provided">
+    <critical>MUST read COMPLETE {sprint_status} file from start to end to preserve order</critical>
+    <action>Load the FULL file: {{sprint_status}}</action>
+    <action>Read ALL lines from beginning to end - do not skip any content</action>
+    <action>Parse the development_status section completely</action>
+
+    <action>Find the FIRST story (by reading in order from 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"
+    </action>
+
+    <check if="no backlog story found">
+      <output>📋 No backlog stories found in sprint-status.yaml
+
+        All stories are either already created, in progress, or done.
+
+        **Options:**
+        1. Run sprint-planning to refresh story tracking
+        2. Load PM agent and run correct-course to add more stories
+        3. Check if current sprint is complete and run retrospective
+      </output>
+      <action>HALT</action>
+    </check>
+
+    <action>Extract from found story key (e.g., "1-2-user-authentication"):
+      - epic_num: first number before dash (e.g., "1")
+      - story_num: second number after first dash (e.g., "2")
+      - story_title: remainder after second dash (e.g., "user-authentication")
+    </action>
+    <action>Set {{story_id}} = "{{epic_num}}.{{story_num}}"</action>
+    <action>Store story_key for later use (e.g., "1-2-user-authentication")</action>
+
+    <!-- Mark epic as in-progress if this is first story -->
+    <action>Check if this is the first story in epic {{epic_num}} by looking for {{epic_num}}-1-* pattern</action>
+    <check if="this is first story in epic {{epic_num}}">
+      <action>Load {{sprint_status}} and check epic-{{epic_num}} status</action>
+      <action>If epic status is "backlog" → update to "in-progress"</action>
+      <action>If epic status is "contexted" (legacy status) → update to "in-progress" (backward compatibility)</action>
+      <action>If epic status is "in-progress" → no change needed</action>
+      <check if="epic status is 'done'">
+        <output>🚫 ERROR: Cannot create story in completed epic</output>
+        <output>Epic {{epic_num}} is marked as 'done'. All stories are complete.</output>
+        <output>If you need to add more work, either:</output>
+        <output>1. Manually change epic status back to 'in-progress' in sprint-status.yaml</output>
+        <output>2. Create a new epic for additional work</output>
+        <action>HALT - Cannot proceed</action>
+      </check>
+      <check if="epic status is not one of: backlog, contexted, in-progress, done">
+        <output>🚫 ERROR: Invalid epic status '{{epic_status}}'</output>
+        <output>Epic {{epic_num}} has invalid status. Expected: backlog, in-progress, or done</output>
+        <output>Please fix sprint-status.yaml manually or run sprint-planning to regenerate</output>
+        <action>HALT - Cannot proceed</action>
+      </check>
+      <output>📊 Epic {{epic_num}} status updated to in-progress</output>
+    </check>
+
+    <action>GOTO step 2a</action>
+  </check>
+  <action>Load the FULL file: {{sprint_status}}</action>
+  <action>Read ALL lines from beginning to end - do not skip any content</action>
+  <action>Parse the development_status section completely</action>
+
+  <action>Find the FIRST story (by reading in order from 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"
+  </action>
+
+  <check if="no backlog story found">
+    <output>No backlog stories found in sprint-status.yaml
+
+      All stories are either already created, in progress, or done.
+
+      **Options:**
+      1. Run sprint-planning to refresh story tracking
+      2. Load PM agent and run correct-course to add more stories
+      3. Check if current sprint is complete and run retrospective
+    </output>
+    <action>HALT</action>
+  </check>
+
+  <action>Extract from found story key (e.g., "1-2-user-authentication"):
+    - epic_num: first number before dash (e.g., "1")
+    - story_num: second number after first dash (e.g., "2")
+    - story_title: remainder after second dash (e.g., "user-authentication")
+  </action>
+  <action>Set {{story_id}} = "{{epic_num}}.{{story_num}}"</action>
+  <action>Store story_key for later use (e.g., "1-2-user-authentication")</action>
+
+  <!-- Mark epic as in-progress if this is first story -->
+  <action>Check if this is the first story in epic {{epic_num}} by looking for {{epic_num}}-1-* pattern</action>
+  <check if="this is first story in epic {{epic_num}}">
+    <action>Load {{sprint_status}} and check epic-{{epic_num}} status</action>
+    <action>If epic status is "backlog" → update to "in-progress"</action>
+    <action>If epic status is "contexted" (legacy status) → update to "in-progress" (backward compatibility)</action>
+    <action>If epic status is "in-progress" → no change needed</action>
+    <check if="epic status is 'done'">
+      <output>ERROR: Cannot create story in completed epic</output>
+      <output>Epic {{epic_num}} is marked as 'done'. All stories are complete.</output>
+      <output>If you need to add more work, either:</output>
+      <output>1. Manually change epic status back to 'in-progress' in sprint-status.yaml</output>
+      <output>2. Create a new epic for additional work</output>
+      <action>HALT - Cannot proceed</action>
+    </check>
+    <check if="epic status is not one of: backlog, contexted, in-progress, done">
+      <output>ERROR: Invalid epic status '{{epic_status}}'</output>
+      <output>Epic {{epic_num}} has invalid status. Expected: backlog, in-progress, or done</output>
+      <output>Please fix sprint-status.yaml manually or run sprint-planning to regenerate</output>
+      <action>HALT - Cannot proceed</action>
+    </check>
+    <output>Epic {{epic_num}} status updated to in-progress</output>
+  </check>
+
+  <action>GOTO step 2a</action>
+</step>
+
+<step n="2" goal="Load and analyze core artifacts">
+  <critical>🔬 EXHAUSTIVE ARTIFACT ANALYSIS - This is where you prevent future developer mistakes!</critical>
+
+  <!-- Load all available content through discovery protocol -->
+  <action>Read fully and follow `./discover-inputs.md` to load all input files</action>
+  <note>Available content: {epics_content}, {prd_content}, {architecture_content}, {ux_content},
+  {project_context}</note>
+
+  <!-- Analyze epics file for story foundation -->
+  <action>From {epics_content}, extract Epic {{epic_num}} complete context:</action> **EPIC ANALYSIS:** - Epic
+  objectives and business value - ALL stories in this epic for cross-story context - Our specific story's requirements, user story
+  statement, acceptance criteria - Technical requirements and constraints - Dependencies on other stories/epics - Source hints pointing to
+  original documents <!-- Extract specific story requirements -->
+  <action>Extract our story ({{epic_num}}-{{story_num}}) details:</action> **STORY FOUNDATION:** - User story statement
+  (As a, I want, so that) - Detailed acceptance criteria (already BDD formatted) - Technical requirements specific to this story -
+  Business context and value - Success criteria <!-- Previous story analysis for context continuity -->
+  <check if="story_num > 1">
+    <action>Find {{previous_story_num}}: scan {implementation_artifacts} for the story file in epic {{epic_num}} with the highest story number less than {{story_num}}</action>
+    <action>Load previous story file: {implementation_artifacts}/{{epic_num}}-{{previous_story_num}}-*.md</action> **PREVIOUS STORY INTELLIGENCE:** -
+  Dev notes and learnings from previous story - Review feedback and corrections needed - Files that were created/modified and their
+  patterns - Testing approaches that worked/didn't work - Problems encountered and solutions found - Code patterns established <action>Extract
+  all learnings that could impact current story implementation</action>
+  </check>
+
+  <!-- Git intelligence for previous work patterns -->
+  <check
+    if="previous story exists AND git repository detected">
+    <action>Get last 5 commit titles to understand recent work patterns</action>
+    <action>Analyze 1-5 most recent commits for relevance to current story:
+      - Files created/modified
+      - Code patterns and conventions used
+      - Library dependencies added/changed
+      - Architecture decisions implemented
+      - Testing approaches used
+    </action>
+    <action>Extract actionable insights for current story implementation</action>
+  </check>
+</step>
+
+<step n="3" goal="Architecture analysis for developer guardrails">
+  <critical>🏗️ ARCHITECTURE INTELLIGENCE - Extract everything the developer MUST follow!</critical> **ARCHITECTURE DOCUMENT ANALYSIS:** <action>Systematically
+  analyze architecture content for story-relevant requirements:</action>
+
+  <!-- Load architecture - single file or sharded -->
+  <check if="architecture file is single file">
+    <action>Load complete {architecture_content}</action>
+  </check>
+  <check if="architecture is sharded to folder">
+    <action>Load architecture index and scan all architecture files</action>
+  </check> **CRITICAL ARCHITECTURE EXTRACTION:** <action>For
+  each architecture section, determine if relevant to this story:</action> - **Technical Stack:** Languages, frameworks, libraries with
+  versions - **Code Structure:** Folder organization, naming conventions, file patterns - **API Patterns:** Service structure, endpoint
+  patterns, data contracts - **Database Schemas:** Tables, relationships, constraints relevant to story - **Security Requirements:**
+  Authentication patterns, authorization rules - **Performance Requirements:** Caching strategies, optimization patterns - **Testing
+  Standards:** Testing frameworks, coverage expectations, test patterns - **Deployment Patterns:** Environment configurations, build
+  processes - **Integration Patterns:** External service integrations, data flows <action>Extract any story-specific requirements that the
+  developer MUST follow</action>
+  <action>Identify any architectural decisions that override previous patterns</action>
+</step>
+
+<step n="4" goal="Web research for latest technical specifics">
+  <critical>🌐 ENSURE LATEST TECH KNOWLEDGE - Prevent outdated implementations!</critical> **WEB INTELLIGENCE:** <action>Identify specific
+  technical areas that require latest version knowledge:</action>
+
+  <!-- Check for libraries/frameworks mentioned in architecture -->
+  <action>From architecture analysis, identify specific libraries, APIs, or
+  frameworks</action>
+  <action>For each critical technology, research latest stable version and key changes:
+    - Latest API documentation and breaking changes
+    - Security vulnerabilities or updates
+    - Performance improvements or deprecations
+    - Best practices for current version
+  </action>
+  **EXTERNAL CONTEXT INCLUSION:** <action>Include in story any critical latest information the developer needs:
+    - Specific library versions and why chosen
+    - API endpoints with parameters and authentication
+    - Recent security patches or considerations
+    - Performance optimization techniques
+    - Migration considerations if upgrading
+  </action>
+</step>
+
+<step n="5" goal="Create comprehensive story file">
+  <critical>📝 CREATE ULTIMATE STORY FILE - The developer's master implementation guide!</critical>
+
+  <action>Initialize from template.md:
+  {default_output_file}</action>
+  <template-output file="{default_output_file}">story_header</template-output>
+
+  <!-- Story foundation from epics analysis -->
+  <template-output
+    file="{default_output_file}">story_requirements</template-output>
+
+  <!-- Developer context section - MOST IMPORTANT PART -->
+  <template-output file="{default_output_file}">
+  developer_context_section</template-output> **DEV AGENT GUARDRAILS:** <template-output file="{default_output_file}">
+  technical_requirements</template-output>
+  <template-output file="{default_output_file}">architecture_compliance</template-output>
+  <template-output
+    file="{default_output_file}">library_framework_requirements</template-output>
+  <template-output file="{default_output_file}">
+  file_structure_requirements</template-output>
+  <template-output file="{default_output_file}">testing_requirements</template-output>
+
+  <!-- Previous story intelligence -->
+  <check
+    if="previous story learnings available">
+    <template-output file="{default_output_file}">previous_story_intelligence</template-output>
+  </check>
+
+  <!-- Git intelligence -->
+  <check
+    if="git analysis completed">
+    <template-output file="{default_output_file}">git_intelligence_summary</template-output>
+  </check>
+
+  <!-- Latest technical specifics -->
+  <check if="web research completed">
+    <template-output file="{default_output_file}">latest_tech_information</template-output>
+  </check>
+
+  <!-- Project context reference -->
+  <template-output
+    file="{default_output_file}">project_context_reference</template-output>
+
+  <!-- Final status update -->
+  <template-output file="{default_output_file}">
+  story_completion_status</template-output>
+
+  <!-- CRITICAL: Set status to ready-for-dev -->
+  <action>Set story Status to: "ready-for-dev"</action>
+  <action>Add completion note: "Ultimate
+  context engine analysis completed - comprehensive developer guide created"</action>
+</step>
+
+<step n="6" goal="Update sprint status and finalize">
+  <action>Validate the newly created story file {default_output_file} against `./checklist.md` and apply any required fixes before finalizing</action>
+  <action>Save story document unconditionally</action>
+
+  <!-- Update sprint status -->
+  <check if="sprint status file exists">
+    <action>Update {{sprint_status}}</action>
+    <action>Load the FULL file and read all development_status entries</action>
+    <action>Find development_status key matching {{story_key}}</action>
+    <action>Verify current status is "backlog" (expected previous state)</action>
+    <action>Update development_status[{{story_key}}] = "ready-for-dev"</action>
+    <action>Update last_updated field to current date</action>
+    <action>Save file, preserving ALL comments and structure including STATUS DEFINITIONS</action>
+  </check>
+
+  <action>Report completion</action>
+  <output>**🎯 ULTIMATE BMad Method STORY CONTEXT CREATED, {user_name}!**
+
+    **Story Details:**
+    - Story ID: {{story_id}}
+    - Story Key: {{story_key}}
+    - File: {{story_file}}
+    - Status: ready-for-dev
+
+    **Next Steps:**
+    1. Review the comprehensive story in {{story_file}}
+    2. Run dev agents `dev-story` for optimized implementation
+    3. Run `code-review` when complete (auto-marks done)
+    4. Optional: If Test Architect module installed, run `/bmad:tea:automate` after `dev-story` to generate guardrail tests
+
+    **The developer now has everything needed for flawless implementation!**
+  </output>
+</step>
+
+</workflow>

package/.opencode/skills/bmad-create-ux-design/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: bmad-create-ux-design
+description: 'Plan UX patterns and design specifications. Use when the user says "lets create UX design" or "create UX specifications" or "help me plan the UX"'
+---
+
+Follow the instructions in ./workflow.md.

package/.opencode/skills/bmad-create-ux-design/steps/step-01-init.md

@@ -0,0 +1,135 @@
+# Step 1: UX Design Workflow Initialization
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without user input
+
+- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
+- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
+- ✅ ALWAYS treat this as collaborative discovery between UX facilitator and stakeholder
+- 📋 YOU ARE A UX FACILITATOR, not a content generator
+- 💬 FOCUS on initialization and setup only - don't look ahead to future steps
+- 🚪 DETECT existing workflow state and handle continuation properly
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- 💾 Initialize document and update frontmatter
+- 📖 Set up frontmatter `stepsCompleted: [1]` before loading next step
+- 🚫 FORBIDDEN to load next step until setup is complete
+
+## CONTEXT BOUNDARIES:
+
+- Variables from workflow.md are available in memory
+- Previous context = what's in output document + frontmatter
+- Don't assume knowledge from other steps
+- Input document discovery happens in this step
+
+## YOUR TASK:
+
+Initialize the UX design workflow by detecting continuation state and setting up the design specification document.
+
+## INITIALIZATION SEQUENCE:
+
+### 1. Check for Existing Workflow
+
+First, check if the output document already exists:
+
+- Look for file at `{planning_artifacts}/*ux-design-specification*.md`
+- If exists, read the complete file including frontmatter
+- If not exists, this is a fresh workflow
+
+### 2. Handle Continuation (If Document Exists)
+
+If the document exists and has frontmatter with `stepsCompleted`:
+
+- **STOP here** and load `./step-01b-continue.md` immediately
+- Do not proceed with any initialization tasks
+- Let step-01b handle the continuation logic
+
+### 3. Fresh Workflow Setup (If No Document)
+
+If no document exists or no `stepsCompleted` in frontmatter:
+
+#### A. Input Document Discovery
+
+Discover and load context documents using smart discovery. Documents can be in the following locations:
+- {planning_artifacts}/**
+- {output_folder}/**
+- {product_knowledge}/**
+- {project-root}/docs/**
+
+Also - when searching - documents can be a single markdown file, or a folder with an index and multiple files. For Example, if searching for `*foo*.md` and not found, also search for a folder called *foo*/index.md (which indicates sharded content)
+
+Try to discover the following:
+- Product Brief (`*brief*.md`)
+- Research Documents (`*prd*.md`)
+- Project Documentation (generally multiple documents might be found for this in the `{product_knowledge}` or `docs` folder.)
+- Project Context (`**/project-context.md`)
+
+<critical>Confirm what you have found with the user, along with asking if the user wants to provide anything else. Only after this confirmation will you proceed to follow the loading rules</critical>
+
+**Loading Rules:**
+
+- Load ALL discovered files completely that the user confirmed or provided (no offset/limit)
+- If there is a project context, whatever is relevant should try to be biased in the remainder of this whole workflow process
+- For sharded folders, load ALL files to get complete picture, using the index first to potentially know the potential of each document
+- index.md is a guide to what's relevant whenever available
+- Track all successfully loaded files in frontmatter `inputDocuments` array
+
+#### B. Create Initial Document
+
+Copy the template from `../ux-design-template.md` to `{planning_artifacts}/ux-design-specification.md`
+Initialize frontmatter in the template.
+
+#### C. Complete Initialization and Report
+
+Complete setup and report to user:
+
+**Document Setup:**
+
+- Created: `{planning_artifacts}/ux-design-specification.md` from template
+- Initialized frontmatter with workflow state
+
+**Input Documents Discovered:**
+Report what was found:
+"Welcome {{user_name}}! I've set up your UX design workspace for {{project_name}}.
+
+**Documents Found:**
+
+- PRD: {number of PRD files loaded or "None found"}
+- Product brief: {number of brief files loaded or "None found"}
+- Other context: {number of other files loaded or "None found"}
+
+**Files loaded:** {list of specific file names or "No additional documents found"}
+
+Do you have any other documents you'd like me to include, or shall we continue to the next step?
+
+[C] Continue to UX discovery"
+
+## NEXT STEP:
+
+After user selects [C] to continue, ensure the file `{planning_artifacts}/ux-design-specification.md` has been created and saved, and then load `./step-02-discovery.md` to begin the UX discovery phase.
+
+Remember: Do NOT proceed to step-02 until output file has been updated and user explicitly selects [C] to continue!
+
+## SUCCESS METRICS:
+
+✅ Existing workflow detected and handed off to step-01b correctly
+✅ Fresh workflow initialized with template and frontmatter
+✅ Input documents discovered and loaded using sharded-first logic
+✅ All discovered files tracked in frontmatter `inputDocuments`
+✅ User confirmed document setup and can proceed
+
+## FAILURE MODES:
+
+❌ Proceeding with fresh initialization when existing workflow exists
+❌ Not updating frontmatter with discovered input documents
+❌ Creating document without proper template
+❌ Not checking sharded folders first before whole files
+❌ Not reporting what documents were found to user
+
+❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
+❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
+❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols

package/.opencode/skills/bmad-create-ux-design/steps/step-01b-continue.md

@@ -0,0 +1,127 @@
+# Step 1B: UX Design Workflow Continuation
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without user input
+
+- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
+- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
+- ✅ ALWAYS treat this as collaborative discovery between UX facilitator and stakeholder
+- 📋 YOU ARE A UX FACILITATOR, not a content generator
+- 💬 FOCUS on understanding where we left off and continuing appropriately
+- 🚪 RESUME workflow from exact point where it was interrupted
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis of current state before taking action
+- 💾 Keep existing frontmatter `stepsCompleted` values
+- 📖 Only load documents that were already tracked in `inputDocuments`
+- 🚫 FORBIDDEN to modify content completed in previous steps
+
+## CONTEXT BOUNDARIES:
+
+- Current document and frontmatter are already loaded
+- Previous context = complete document + existing frontmatter
+- Input documents listed in frontmatter were already processed
+- Last completed step = `lastStep` value from frontmatter
+
+## YOUR TASK:
+
+Resume the UX design workflow from where it was left off, ensuring smooth continuation.
+
+## CONTINUATION SEQUENCE:
+
+### 1. Analyze Current State
+
+Review the frontmatter to understand:
+
+- `stepsCompleted`: Which steps are already done
+- `lastStep`: The most recently completed step number
+- `inputDocuments`: What context was already loaded
+- All other frontmatter variables
+
+### 2. Load All Input Documents
+
+Reload the context documents listed in `inputDocuments`:
+
+- For each document in `inputDocuments`, load the complete file
+- This ensures you have full context for continuation
+- Don't discover new documents - only reload what was previously processed
+
+### 3. Summarize Current Progress
+
+Welcome the user back and provide context:
+"Welcome back {{user_name}}! I'm resuming our UX design collaboration for {{project_name}}.
+
+**Current Progress:**
+
+- Steps completed: {stepsCompleted}
+- Last worked on: Step {lastStep}
+- Context documents available: {len(inputDocuments)} files
+- Current UX design specification is ready with all completed sections
+
+**Document Status:**
+
+- Current UX design document is ready with all completed sections
+- Ready to continue from where we left off
+
+Does this look right, or do you want to make any adjustments before we proceed?"
+
+### 4. Determine Next Step
+
+Based on `lastStep` value, determine which step to load next:
+
+- If `lastStep = 1` → Load `./step-02-discovery.md`
+- If `lastStep = 2` → Load `./step-03-core-experience.md`
+- If `lastStep = 3` → Load `./step-04-emotional-response.md`
+- Continue this pattern for all steps
+- If `lastStep` indicates final step → Workflow already complete
+
+### 5. Present Continuation Options
+
+After presenting current progress, ask:
+"Ready to continue with Step {nextStepNumber}: {nextStepTitle}?
+
+[C] Continue to Step {nextStepNumber}"
+
+## SUCCESS METRICS:
+
+✅ All previous input documents successfully reloaded
+✅ Current workflow state accurately analyzed and presented
+✅ User confirms understanding of progress
+✅ Correct next step identified and prepared for loading
+
+## FAILURE MODES:
+
+❌ Discovering new input documents instead of reloading existing ones
+❌ Modifying content from already completed steps
+❌ Loading wrong next step based on `lastStep` value
+❌ Proceeding without user confirmation of current state
+
+❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
+❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
+❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
+
+## WORKFLOW ALREADY COMPLETE?
+
+If `lastStep` indicates the final step is completed:
+"Great news! It looks like we've already completed the UX design workflow for {{project_name}}.
+
+The final UX design specification is ready at {planning_artifacts}/ux-design-specification.md with all sections completed through step {finalStepNumber}.
+
+The complete UX design includes visual foundations, user flows, and design specifications ready for implementation.
+
+Would you like me to:
+
+- Review the completed UX design specification with you
+- Suggest next workflow steps (like wireframe generation or architecture)
+- Start a new UX design revision
+
+What would be most helpful?"
+
+## NEXT STEP:
+
+After user confirms they're ready to continue, load the appropriate next step file based on the `lastStep` value from frontmatter.
+
+Remember: Do NOT load the next step until user explicitly selects [C] to continue!