siesa-agents 2.1.39 → 2.1.41

package/bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-08-complete.md

@@ -0,0 +1,352 @@
+# Step 8: Architecture Completion & Handoff
+
+## 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 completion between architectural peers
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- 💬 FOCUS on successful workflow completion and implementation handoff
+- 🎯 PROVIDE clear next steps for implementation phase
+- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- 🎯 Present completion summary and implementation guidance
+- 📖 Update frontmatter with final workflow state
+- 🚫 NO MORE STEPS - this is the final step
+
+## CONTEXT BOUNDARIES:
+
+- Complete architecture document is finished and validated
+- All architectural decisions, patterns, and structure are documented
+- Focus on successful completion and implementation preparation
+- Provide clear guidance for next steps in the development process
+
+## YOUR TASK:
+
+Complete the architecture workflow, provide a comprehensive completion summary, and guide the user to the next phase of their project development.
+
+## COMPLETION SEQUENCE:
+
+### 1. Present Architecture Completion Summary
+
+Based on user skill level, present the completion:
+
+**For Expert Users:**
+"Architecture workflow complete. {{decision_count}} architectural decisions documented across {{step_count}} steps.
+
+Your architecture is ready for AI agent implementation. All decisions are documented with specific versions and implementation patterns.
+
+Key deliverables:
+
+- Complete architecture decision document
+- Implementation patterns for agent consistency
+- Project structure with all files and directories
+- Validation confirming coherence and completeness
+
+Ready for implementation phase."
+
+**For Intermediate Users:**
+"Excellent! Your architecture for {{project_name}} is now complete and ready for implementation.
+
+**What we accomplished:**
+
+- Made {{decision_count}} key architectural decisions together
+- Established implementation patterns to ensure consistency
+- Created a complete project structure with {{component_count}} main areas
+- Validated that all your requirements are fully supported
+
+**Your architecture document includes:**
+
+- Technology choices with specific versions
+- Clear implementation patterns for AI agents to follow
+- Complete project directory structure
+- Mapping of your requirements to specific files and folders
+
+The architecture is comprehensive and ready to guide consistent implementation."
+
+**For Beginner Users:**
+"Congratulations! Your architecture for {{project_name}} is complete! 🎉
+
+**What this means:**
+Think of this as creating the complete blueprint for your house. We've made all the important decisions about how it will be built, what materials to use, and how everything fits together.
+
+**What we created together:**
+
+- {{decision_count}} architectural decisions (like choosing the foundation, framing, and systems)
+- Clear rules so that multiple builders (AI agents) all work the same way
+- A complete folder structure showing exactly where every file goes
+- Confirmation that everything you want to build is supported by these decisions
+
+**What happens next:**
+AI agents will read this architecture document before building anything. They'll follow all your decisions exactly, which means your app will be built with consistent patterns throughout.
+
+You're ready for the implementation phase!"
+
+### 2. Review Final Document State
+
+Confirm the architecture document is complete:
+
+**Document Structure Verification:**
+
+- Project Context Analysis ✅
+- Starter Template Evaluation ✅
+- Core Architectural Decisions ✅
+- Implementation Patterns & Consistency Rules ✅
+- Project Structure & Boundaries ✅
+- Architecture Validation Results ✅
+
+**Frontmatter Update:**
+
+```yaml
+stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
+workflowType: 'architecture'
+lastStep: 8
+status: 'complete'
+completedAt: '{{current_date}}'
+```
+
+### 3. Implementation Guidance
+
+Provide specific next steps for implementation:
+
+**Immediate Next Steps:**
+
+1. **Review the complete architecture document** at `{planning_artifacts}/architecture.md`
+2. **Begin with project initialization** using the starter template command documented
+3. **Create first implementation story** for project setup
+4. **Start implementing user stories** following the architectural decisions
+
+**Development Workflow:**
+"AI agents will:
+
+1. Read the architecture document before implementing each story
+2. Follow your technology choices and patterns exactly
+3. Use the project structure we defined
+4. Maintain consistency across all components"
+
+**Quality Assurance:**
+"Your architecture includes:
+
+- Specific technology versions to use
+- Implementation patterns that prevent conflicts
+- Clear project structure and boundaries
+- Validation that all requirements are supported"
+
+### 4. Generate Completion Content
+
+Prepare the final content to append to the document:
+
+#### Content Structure:
+
+```markdown
+## Architecture Completion Summary
+
+### Workflow Completion
+
+**Architecture Decision Workflow:** COMPLETED ✅
+**Total Steps Completed:** 8
+**Date Completed:** {{current_date}}
+**Document Location:** {planning_artifacts}/architecture.md
+
+### Final Architecture Deliverables
+
+**📋 Complete Architecture Document**
+
+- All architectural decisions documented with specific versions
+- Implementation patterns ensuring AI agent consistency
+- Complete project structure with all files and directories
+- Requirements to architecture mapping
+- Validation confirming coherence and completeness
+
+**🏗️ Implementation Ready Foundation**
+
+- {{decision_count}} architectural decisions made
+- {{pattern_count}} implementation patterns defined
+- {{component_count}} architectural components specified
+- {{requirement_count}} requirements fully supported
+
+**📚 AI Agent Implementation Guide**
+
+- Technology stack with verified versions
+- Consistency rules that prevent implementation conflicts
+- Project structure with clear boundaries
+- Integration patterns and communication standards
+
+### Implementation Handoff
+
+**For AI Agents:**
+This architecture document is your complete guide for implementing {{project_name}}. Follow all decisions, patterns, and structures exactly as documented.
+
+**First Implementation Priority:**
+{{starter_template_command_or_initialization_step}}
+
+**Development Sequence:**
+
+1. Initialize project using documented starter template
+2. Set up development environment per architecture
+3. Implement core architectural foundations
+4. Build features following established patterns
+5. Maintain consistency with documented rules
+
+### Quality Assurance Checklist
+
+**✅ Architecture Coherence**
+
+- [x] All decisions work together without conflicts
+- [x] Technology choices are compatible
+- [x] Patterns support the architectural decisions
+- [x] Structure aligns with all choices
+
+**✅ Requirements Coverage**
+
+- [x] All functional requirements are supported
+- [x] All non-functional requirements are addressed
+- [x] Cross-cutting concerns are handled
+- [x] Integration points are defined
+
+**✅ Implementation Readiness**
+
+- [x] Decisions are specific and actionable
+- [x] Patterns prevent agent conflicts
+- [x] Structure is complete and unambiguous
+- [x] Examples are provided for clarity
+
+### Project Success Factors
+
+**🎯 Clear Decision Framework**
+Every technology choice was made collaboratively with clear rationale, ensuring all stakeholders understand the architectural direction.
+
+**🔧 Consistency Guarantee**
+Implementation patterns and rules ensure that multiple AI agents will produce compatible, consistent code that works together seamlessly.
+
+**📋 Complete Coverage**
+All project requirements are architecturally supported, with clear mapping from business needs to technical implementation.
+
+**🏗️ Solid Foundation**
+The chosen starter template and architectural patterns provide a production-ready foundation following current best practices.
+
+---
+
+**Architecture Status:** READY FOR IMPLEMENTATION ✅
+
+**Next Phase:** Begin implementation using the architectural decisions and patterns documented herein.
+
+**Document Maintenance:** Update this architecture when major technical decisions are made during implementation.
+```
+
+### 5. Complete Workflow Finalization
+
+**Save Final Document:**
+
+- Ensure all content is properly appended to `{planning_artifacts}/architecture.md`
+- Update frontmatter with completion status
+- Verify document is complete and coherent
+
+**Workflow Status Update:**
+If not in standalone mode, update workflow status:
+
+- Load `{planning_artifacts}/bmm-workflow-status.yaml`
+- Update workflow_status["create-architecture"] = "{planning_artifacts}/architecture.md"
+- Save file with all structure and comments preserved
+
+### 6. Present Completion to User
+
+"🎉 **Architecture Workflow Complete!**
+
+Your architecture for {{project_name}} is comprehensive, validated, and ready for implementation.
+
+**✅ What's been delivered:**
+
+- Complete architecture document with all decisions and patterns
+- Project structure ready for AI agent implementation
+- Validation confirming everything works together coherently
+- Implementation guidance for the development phase
+
+**📍 Where to find it:**
+`{planning_artifacts}/architecture.md`
+
+**🚀 What's next:**
+
+1. Review your complete architecture document
+2. Begin implementation using the starter template command
+3. Create stories for AI agents to implement following your architectural decisions
+
+Your architecture will ensure consistent, high-quality implementation across all development work. Great job collaborating through these important architectural decisions!
+
+**💡 Optional Enhancement: Project Context File**
+
+Would you like to create a `project-context.md` file? This is a concise, optimized guide for AI agents that captures:
+
+- Critical language and framework rules they might miss
+- Specific patterns and conventions for your project
+- Testing and code quality requirements
+- Anti-patterns and edge cases to avoid
+
+{if_existing_project_context}
+I noticed you already have a project context file. Would you like to update it with your new architectural decisions?
+{else}
+This file helps ensure AI agents implement code consistently with your project's unique requirements and patterns.
+{/if_existing_project_context}
+
+**Create/Update project context?** [Y/N]
+
+**Ready to move to the next phase of your project development?**"
+
+### 7. Handle Project Context Creation Choice
+
+If user responds 'Y' or 'yes' to creating/updating project context:
+
+"Excellent choice! Let me launch the Generate Project Context workflow to create a comprehensive guide for AI agents.
+
+This will help ensure consistent implementation by capturing:
+
+- Language-specific patterns and rules
+- Framework conventions from your architecture
+- Testing and quality standards
+- Anti-patterns to avoid
+
+The workflow will collaborate with you to create an optimized `project-context.md` file that AI agents will read before implementing any code."
+
+**Execute the Generate Project Context workflow:**
+
+- Load and execute: `{project-root}/_bmad/bmm/workflows/generate-project-context/workflow.md`
+- The workflow will handle discovery, generation, and completion of the project context file
+- After completion, return here for final handoff
+
+If user responds 'N' or 'no':
+"Understood! Your architecture is complete and ready for implementation. You can always create a project context file later using the Generate Project Context workflow if needed."
+
+## SUCCESS METRICS:
+
+✅ Complete architecture document delivered with all sections
+✅ All architectural decisions documented and validated
+✅ Implementation patterns and consistency rules finalized
+✅ Project structure complete with all files and directories
+✅ User provided with clear next steps and implementation guidance
+✅ Workflow status properly updated
+✅ User collaboration maintained throughout completion process
+
+## FAILURE MODES:
+
+❌ Not providing clear implementation guidance
+❌ Missing final validation of document completeness
+❌ Not updating workflow status appropriately
+❌ Failing to celebrate the successful completion
+❌ Not providing specific next steps for the user
+❌ Rushing completion without proper summary
+
+❌ **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 COMPLETE:
+
+This is the final step of the Architecture workflow. The user now has a complete, validated architecture document ready for AI agent implementation.
+
+The architecture will serve as the single source of truth for all technical decisions, ensuring consistent implementation across the entire project development lifecycle.

package/bmad/bmm/workflows/3-solutioning/create-architecture/workflow.md

@@ -0,0 +1,51 @@
+---
+name: create-architecture
+description: Collaborative architectural decision facilitation for AI-agent consistency. Replaces template-driven architecture with intelligent, adaptive conversation that produces a decision-focused architecture document optimized for preventing agent conflicts.
+web_bundle: true
+---
+
+# Architecture Workflow
+
+**Goal:** Create comprehensive architecture decisions through collaborative step-by-step discovery that ensures AI agents implement consistently.
+
+**Your Role:** You are an architectural facilitator collaborating with a peer. This is a partnership, not a client-vendor relationship. You bring structured thinking and architectural knowledge, while the user brings domain expertise and product vision. Work together as equals to make decisions that prevent implementation conflicts.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **micro-file architecture** for disciplined execution:
+
+- Each step is a self-contained file with embedded rules
+- Sequential progression with user control at each step
+- Document state tracked in frontmatter
+- Append-only document building through conversation
+- You NEVER proceed to a step file if the current step file indicates the user must approve and indicate continuation.
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+
+- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Paths
+
+- `installed_path` = `{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture`
+- `template_path` = `{installed_path}/architecture-decision-template.md`
+- `data_files_path` = `{installed_path}/data/`
+- `company_standards_path` = `{data_files_path}/company-standards`
+
+---
+
+## EXECUTION
+
+Load and execute `steps/step-01-init.md` to begin the workflow.
+
+**Note:** Input document discovery and all initialization protocols are handled in step-01-init.md.

package/bmad/bmm/workflows/3-solutioning/create-epics-and-stories/steps/step-01-validate-prerequisites.md

@@ -0,0 +1,259 @@
+---
+name: 'step-01-validate-prerequisites'
+description: 'Validate required documents exist and extract all requirements for epic and story creation'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/create-epics-and-stories'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-validate-prerequisites.md'
+nextStepFile: '{workflow_path}/steps/step-02-design-epics.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{planning_artifacts}/epics.md'
+epicsTemplate: '{workflow_path}/templates/epics-template.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+
+# Template References
+epicsTemplate: '{workflow_path}/templates/epics-template.md'
+---
+
+# Step 1: Validate Prerequisites and Extract Requirements
+
+## STEP GOAL:
+
+To validate that all required input documents exist and extract all requirements (FRs, NFRs, and additional requirements from UX/Architecture) needed for epic and story creation.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Role Reinforcement:
+
+- ✅ You are a product strategist and technical specifications writer
+- ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring requirements extraction expertise
+- ✅ User brings their product vision and context
+
+### Step-Specific Rules:
+
+- 🎯 Focus ONLY on extracting and organizing requirements
+- 🚫 FORBIDDEN to start creating epics or stories in this step
+- 💬 Extract requirements from ALL available documents
+- 🚪 POPULATE the template sections exactly as needed
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Extract requirements systematically from all documents
+- 💾 Populate {outputFile} with extracted requirements
+- 📖 Update frontmatter with extraction progress
+- 🚫 FORBIDDEN to load next step until user selects 'C' and requirements are extracted
+
+## REQUIREMENTS EXTRACTION PROCESS:
+
+### 1. Welcome and Overview
+
+Welcome {user_name} to comprehensive epic and story creation!
+
+**CRITICAL PREREQUISITE VALIDATION:**
+
+Verify required documents exist and are complete:
+
+1. **PRD.md** - Contains requirements (FRs and NFRs) and product scope
+2. **Architecture.md** - Contains technical decisions, API contracts, data models
+3. **UX Design.md** (if UI exists) - Contains interaction patterns, mockups, user flows
+
+### 2. Document Discovery and Validation
+
+Search for required documents using these patterns (sharded means a large document was split into multiple small files with an index.md into a folder) - if the whole document is found, use that instead of the sharded version:
+
+**PRD Document Search Priority:**
+
+1. `{planning_artifacts}/*prd*.md` (whole document)
+2. `{planning_artifacts}/*prd*/index.md` (sharded version)
+
+**Architecture Document Search Priority:**
+
+1. `{planning_artifacts}/*architecture*.md` (whole document)
+2. `{planning_artifacts}/*architecture*/index.md` (sharded version)
+
+**UX Design Document Search (Optional):**
+
+1. `{planning_artifacts}/*ux*.md` (whole document)
+2. `{planning_artifacts}/*ux*/index.md` (sharded version)
+
+Before proceeding, Ask the user if there are any other documents to include for analysis, and if anything found should be excluded. Wait for user confirmation. Once confirmed, create the {outputFile} from the {epicsTemplate} and in the front matter list the files in the array of `inputDocuments: []`.
+
+### 3. Extract Functional Requirements (FRs)
+
+From the PRD document (full or sharded), read then entire document and extract ALL functional requirements:
+
+**Extraction Method:**
+
+- Look for numbered items like "FR1:", "Functional Requirement 1:", or similar
+- Identify requirement statements that describe what the system must DO
+- Include user actions, system behaviors, and business rules
+
+**Format the FR list as:**
+
+```
+FR1: [Clear, testable requirement description]
+FR2: [Clear, testable requirement description]
+...
+```
+
+### 4. Extract Non-Functional Requirements (NFRs)
+
+From the PRD document, extract ALL non-functional requirements:
+
+**Extraction Method:**
+
+- Look for performance, security, usability, reliability requirements
+- Identify constraints and quality attributes
+- Include technical standards and compliance requirements
+
+**Format the NFR list as:**
+
+```
+NFR1: [Performance/Security/Usability requirement]
+NFR2: [Performance/Security/Usability requirement]
+...
+```
+
+### 5. Extract Additional Requirements from Architecture
+
+Review the Architecture document for technical requirements that impact epic and story creation:
+
+**Look for:**
+
+- **Starter Template**: Does Architecture specify a starter/greenfield template? If YES, document this for Epic 1 Story 1
+- Infrastructure and deployment requirements
+- Integration requirements with external systems
+- Data migration or setup requirements
+- Monitoring and logging requirements
+- API versioning or compatibility requirements
+- Security implementation requirements
+
+**IMPORTANT**: If a starter template is mentioned in Architecture, note it prominently. This will impact Epic 1 Story 1.
+
+**Format Additional Requirements as:**
+
+```
+- [Technical requirement from Architecture that affects implementation]
+- [Infrastructure setup requirement]
+- [Integration requirement]
+...
+```
+
+### 6. Extract Additional Requirements from UX (if exists)
+
+Review the UX document for requirements that affect epic and story creation:
+
+**Look for:**
+
+- Responsive design requirements
+- Accessibility requirements
+- Browser/device compatibility
+- User interaction patterns that need implementation
+- Animation or transition requirements
+- Error handling UX requirements
+
+**Add these to Additional Requirements list.**
+
+### 7. Load and Initialize Template
+
+Load {epicsTemplate} and initialize {outputFile}:
+
+1. Copy the entire template to {outputFile}
+2. Replace {{project_name}} with the actual project name
+3. Replace placeholder sections with extracted requirements:
+   - {{fr_list}} → extracted FRs
+   - {{nfr_list}} → extracted NFRs
+   - {{additional_requirements}} → extracted additional requirements
+4. Leave {{requirements_coverage_map}} and {{epics_list}} as placeholders for now
+
+### 8. Present Extracted Requirements
+
+Display to user:
+
+**Functional Requirements Extracted:**
+
+- Show count of FRs found
+- Display the first few FRs as examples
+- Ask if any FRs are missing or incorrectly captured
+
+**Non-Functional Requirements Extracted:**
+
+- Show count of NFRs found
+- Display key NFRs
+- Ask if any constraints were missed
+
+**Additional Requirements:**
+
+- Summarize technical requirements from Architecture
+- Summarize UX requirements (if applicable)
+- Verify completeness
+
+### 9. Get User Confirmation
+
+Ask: "Do these extracted requirements accurately represent what needs to be built? Any additions or corrections?"
+
+Update the requirements based on user feedback until confirmation is received.
+
+## CONTENT TO SAVE TO DOCUMENT:
+
+After extraction and confirmation, update {outputFile} with:
+
+- Complete FR list in {{fr_list}} section
+- Complete NFR list in {{nfr_list}} section
+- All additional requirements in {{additional_requirements}} section
+
+### 10. Present MENU OPTIONS
+
+Display: `**Confirm the Requirements are complete and correct to [C] continue:**`
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- User can chat or ask questions - always respond and then end with display again of the menu option
+
+#### Menu Handling Logic:
+
+- IF C: Save all to {outputFile}, update frontmatter, only then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#10-present-menu-options)
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN C is selected and all requirements are saved to document and frontmatter is updated, will you then load, read entire file, then execute {nextStepFile} to execute and begin epic design step.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- All required documents found and validated
+- All FRs extracted and formatted correctly
+- All NFRs extracted and formatted correctly
+- Additional requirements from Architecture/UX identified
+- Template initialized with requirements
+- User confirms requirements are complete and accurate
+
+### ❌ SYSTEM FAILURE:
+
+- Missing required documents
+- Incomplete requirements extraction
+- Template not properly initialized
+- Not saving requirements to output file
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.