bmad-method 6.0.0-alpha.2 → 6.0.0-alpha.20

package/src/modules/bmm/workflows/1-analysis/research/technical-steps/step-02-technical-overview.md

@@ -0,0 +1,238 @@
+# Technical Research Step 2: Technology Stack Analysis
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without web search verification
+
+- 📖 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
+- ✅ Search the web to verify and supplement your knowledge with current facts
+- 📋 YOU ARE A TECHNOLOGY STACK ANALYST, not content generator
+- 💬 FOCUS on languages, frameworks, tools, and platforms
+- 🔍 WEB SEARCH REQUIRED - verify current facts against live sources
+- 📝 WRITE CONTENT IMMEDIATELY TO DOCUMENT
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show web search analysis before presenting findings
+- ⚠️ Present [C] continue option after technology stack content generation
+- 📝 WRITE TECHNOLOGY STACK ANALYSIS TO DOCUMENT IMMEDIATELY
+- 💾 ONLY proceed when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1, 2]` before loading next step
+- 🚫 FORBIDDEN to load next step until C is selected
+
+## CONTEXT BOUNDARIES:
+
+- Current document and frontmatter from step-01 are available
+- **Research topic = "{{research_topic}}"** - established from initial discussion
+- **Research goals = "{{research_goals}}"** - established from initial discussion
+- Focus on languages, frameworks, tools, and platforms
+- Web search capabilities with source verification are enabled
+
+## YOUR TASK:
+
+Conduct technology stack analysis focusing on languages, frameworks, tools, and platforms. Search the web to verify and supplement current facts.
+
+## TECHNOLOGY STACK ANALYSIS SEQUENCE:
+
+### 1. Begin Technology Stack Analysis
+
+**UTILIZE SUBPROCESSES AND SUBAGENTS**: Use research subagents, subprocesses or parallel processing if available to thoroughly analyze different technology stack areas simultaneously and thoroughly.
+
+Start with technology stack research approach:
+"Now I'll conduct **technology stack analysis** for **{{research_topic}}** to understand the technology landscape.
+
+**Technology Stack Focus:**
+
+- Programming languages and their evolution
+- Development frameworks and libraries
+- Database and storage technologies
+- Development tools and platforms
+- Cloud infrastructure and deployment platforms
+
+**Let me search for current technology stack insights.**"
+
+### 2. Parallel Technology Stack Research Execution
+
+**Execute multiple web searches simultaneously:**
+
+Search the web: "{{research_topic}} programming languages frameworks"
+Search the web: "{{research_topic}} development tools platforms"
+Search the web: "{{research_topic}} database storage technologies"
+Search the web: "{{research_topic}} cloud infrastructure platforms"
+
+**Analysis approach:**
+
+- Look for recent technology trend reports and developer surveys
+- Search for technology documentation and best practices
+- Research open-source projects and their technology choices
+- Analyze technology adoption patterns and migration trends
+- Study platform and tool evolution in the domain
+
+### 3. Analyze and Aggregate Results
+
+**Collect and analyze findings from all parallel searches:**
+
+"After executing comprehensive parallel web searches, let me analyze and aggregate technology stack findings:
+
+**Research Coverage:**
+
+- Programming languages and frameworks analysis
+- Development tools and platforms evaluation
+- Database and storage technologies assessment
+- Cloud infrastructure and deployment platform analysis
+
+**Cross-Technology Analysis:**
+[Identify patterns connecting language choices, frameworks, and platform decisions]
+
+**Quality Assessment:**
+[Overall confidence levels and research gaps identified]"
+
+### 4. Generate Technology Stack Content
+
+**WRITE IMMEDIATELY TO DOCUMENT**
+
+Prepare technology stack analysis with web search citations:
+
+#### Content Structure:
+
+When saving to document, append these Level 2 and Level 3 sections:
+
+```markdown
+## Technology Stack Analysis
+
+### Programming Languages
+
+[Programming languages analysis with source citations]
+_Popular Languages: [Most widely used languages for {{research_topic}}]_
+_Emerging Languages: [Growing languages gaining adoption]_
+_Language Evolution: [How language preferences are changing]_
+_Performance Characteristics: [Language performance and suitability]_
+_Source: [URL]_
+
+### Development Frameworks and Libraries
+
+[Frameworks analysis with source citations]
+_Major Frameworks: [Dominant frameworks and their use cases]_
+_Micro-frameworks: [Lightweight options and specialized libraries]_
+_Evolution Trends: [How frameworks are evolving and changing]_
+_Ecosystem Maturity: [Library availability and community support]_
+_Source: [URL]_
+
+### Database and Storage Technologies
+
+[Database analysis with source citations]
+_Relational Databases: [Traditional SQL databases and their evolution]_
+_NoSQL Databases: [Document, key-value, graph, and other NoSQL options]_
+_In-Memory Databases: [Redis, Memcached, and performance-focused solutions]_
+_Data Warehousing: [Analytics and big data storage solutions]_
+_Source: [URL]_
+
+### Development Tools and Platforms
+
+[Tools and platforms analysis with source citations]
+_IDE and Editors: [Development environments and their evolution]_
+_Version Control: [Git and related development tools]_
+_Build Systems: [Compilation, packaging, and automation tools]_
+_Testing Frameworks: [Unit testing, integration testing, and QA tools]_
+_Source: [URL]_
+
+### Cloud Infrastructure and Deployment
+
+[Cloud platforms analysis with source citations]
+_Major Cloud Providers: [AWS, Azure, GCP and their services]_
+_Container Technologies: [Docker, Kubernetes, and orchestration]_
+_Serverless Platforms: [FaaS and event-driven computing]_
+_CDN and Edge Computing: [Content delivery and distributed computing]_
+_Source: [URL]_
+
+### Technology Adoption Trends
+
+[Adoption trends analysis with source citations]
+_Migration Patterns: [How technology choices are evolving]_
+_Emerging Technologies: [New technologies gaining traction]_
+_Legacy Technology: [Older technologies being phased out]_
+_Community Trends: [Developer preferences and open-source adoption]_
+_Source: [URL]_
+```
+
+### 5. Present Analysis and Continue Option
+
+**Show analysis and present continue option:**
+
+"I've completed **technology stack analysis** of the technology landscape for {{research_topic}}.
+
+**Key Technology Stack Findings:**
+
+- Programming languages and frameworks thoroughly analyzed
+- Database and storage technologies evaluated
+- Development tools and platforms documented
+- Cloud infrastructure and deployment options mapped
+- Technology adoption trends identified
+
+**Ready to proceed to integration patterns analysis?**
+[C] Continue - Save this to document and proceed to integration patterns
+
+### 6. Handle Continue Selection
+
+#### If 'C' (Continue):
+
+- **CONTENT ALREADY WRITTEN TO DOCUMENT**
+- Update frontmatter: `stepsCompleted: [1, 2]`
+- Load: `./step-03-integration-patterns.md`
+
+## APPEND TO DOCUMENT:
+
+Content is already written to document when generated in step 4. No additional append needed.
+
+## SUCCESS METRICS:
+
+✅ Programming languages and frameworks thoroughly analyzed
+✅ Database and storage technologies evaluated
+✅ Development tools and platforms documented
+✅ Cloud infrastructure and deployment options mapped
+✅ Technology adoption trends identified
+✅ Content written immediately to document
+✅ [C] continue option presented and handled correctly
+✅ Proper routing to next step (integration patterns)
+✅ Research goals alignment maintained
+
+## FAILURE MODES:
+
+❌ Relying solely on training data without web verification for current facts
+
+❌ Missing critical programming languages or frameworks
+❌ Incomplete database and storage technology analysis
+❌ Not identifying development tools and platforms
+❌ Not writing content immediately to document
+❌ Not presenting [C] continue option after content generation
+❌ Not routing to integration patterns step
+
+❌ **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
+
+## TECHNOLOGY STACK RESEARCH PROTOCOLS:
+
+- Research technology trend reports and developer surveys
+- Use technology documentation and best practices guides
+- Analyze open-source projects and their technology choices
+- Study technology adoption patterns and migration trends
+- Focus on current technology data
+- Present conflicting information when sources disagree
+- Apply confidence levels appropriately
+
+## TECHNOLOGY STACK ANALYSIS STANDARDS:
+
+- Always cite URLs for web search results
+- Use authoritative technology research sources
+- Note data currency and potential limitations
+- Present multiple perspectives when sources conflict
+- Apply confidence levels to uncertain data
+- Focus on actionable technology insights
+
+## NEXT STEP:
+
+After user selects 'C', load `./step-03-integration-patterns.md` to analyze APIs, communication protocols, and system interoperability for {{research_topic}}.
+
+Remember: Always write research content to document immediately and emphasize current technology data with rigorous source verification!

package/src/modules/bmm/workflows/1-analysis/research/technical-steps/step-03-integration-patterns.md

@@ -0,0 +1,247 @@
+# Technical Research Step 3: Integration Patterns
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without web search verification
+
+- 📖 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
+- ✅ Search the web to verify and supplement your knowledge with current facts
+- 📋 YOU ARE AN INTEGRATION ANALYST, not content generator
+- 💬 FOCUS on APIs, protocols, and system interoperability
+- 🔍 WEB SEARCH REQUIRED - verify current facts against live sources
+- 📝 WRITE CONTENT IMMEDIATELY TO DOCUMENT
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show web search analysis before presenting findings
+- ⚠️ Present [C] continue option after integration patterns content generation
+- 📝 WRITE INTEGRATION PATTERNS ANALYSIS TO DOCUMENT IMMEDIATELY
+- 💾 ONLY proceed when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
+- 🚫 FORBIDDEN to load next step until C is selected
+
+## CONTEXT BOUNDARIES:
+
+- Current document and frontmatter from previous steps are available
+- **Research topic = "{{research_topic}}"** - established from initial discussion
+- **Research goals = "{{research_goals}}"** - established from initial discussion
+- Focus on APIs, protocols, and system interoperability
+- Web search capabilities with source verification are enabled
+
+## YOUR TASK:
+
+Conduct integration patterns analysis focusing on APIs, communication protocols, and system interoperability. Search the web to verify and supplement current facts.
+
+## INTEGRATION PATTERNS ANALYSIS SEQUENCE:
+
+### 1. Begin Integration Patterns Analysis
+
+**UTILIZE SUBPROCESSES AND SUBAGENTS**: Use research subagents, subprocesses or parallel processing if available to thoroughly analyze different integration areas simultaneously and thoroughly.
+
+Start with integration patterns research approach:
+"Now I'll conduct **integration patterns analysis** for **{{research_topic}}** to understand system integration approaches.
+
+**Integration Patterns Focus:**
+
+- API design patterns and protocols
+- Communication protocols and data formats
+- System interoperability approaches
+- Microservices integration patterns
+- Event-driven architectures and messaging
+
+**Let me search for current integration patterns insights.**"
+
+### 2. Parallel Integration Patterns Research Execution
+
+**Execute multiple web searches simultaneously:**
+
+Search the web: "{{research_topic}} API design patterns protocols"
+Search the web: "{{research_topic}} communication protocols data formats"
+Search the web: "{{research_topic}} system interoperability integration"
+Search the web: "{{research_topic}} microservices integration patterns"
+
+**Analysis approach:**
+
+- Look for recent API design guides and best practices
+- Search for communication protocol documentation and standards
+- Research integration platform and middleware solutions
+- Analyze microservices architecture patterns and approaches
+- Study event-driven systems and messaging patterns
+
+### 3. Analyze and Aggregate Results
+
+**Collect and analyze findings from all parallel searches:**
+
+"After executing comprehensive parallel web searches, let me analyze and aggregate integration patterns findings:
+
+**Research Coverage:**
+
+- API design patterns and protocols analysis
+- Communication protocols and data formats evaluation
+- System interoperability approaches assessment
+- Microservices integration patterns documentation
+
+**Cross-Integration Analysis:**
+[Identify patterns connecting API choices, communication protocols, and system design]
+
+**Quality Assessment:**
+[Overall confidence levels and research gaps identified]"
+
+### 4. Generate Integration Patterns Content
+
+**WRITE IMMEDIATELY TO DOCUMENT**
+
+Prepare integration patterns analysis with web search citations:
+
+#### Content Structure:
+
+When saving to document, append these Level 2 and Level 3 sections:
+
+```markdown
+## Integration Patterns Analysis
+
+### API Design Patterns
+
+[API design patterns analysis with source citations]
+_RESTful APIs: [REST principles and best practices for {{research_topic}}]_
+_GraphQL APIs: [GraphQL adoption and implementation patterns]_
+_RPC and gRPC: [High-performance API communication patterns]_
+_Webhook Patterns: [Event-driven API integration approaches]_
+_Source: [URL]_
+
+### Communication Protocols
+
+[Communication protocols analysis with source citations]
+_HTTP/HTTPS Protocols: [Web-based communication patterns and evolution]_
+_WebSocket Protocols: [Real-time communication and persistent connections]_
+_Message Queue Protocols: [AMQP, MQTT, and messaging patterns]_
+_grpc and Protocol Buffers: [High-performance binary communication protocols]_
+_Source: [URL]_
+
+### Data Formats and Standards
+
+[Data formats analysis with source citations]
+_JSON and XML: [Structured data exchange formats and their evolution]_
+_Protobuf and MessagePack: [Efficient binary serialization formats]_
+_CSV and Flat Files: [Legacy data integration and bulk transfer patterns]_
+_Custom Data Formats: [Domain-specific data exchange standards]_
+_Source: [URL]_
+
+### System Interoperability Approaches
+
+[Interoperability analysis with source citations]
+_Point-to-Point Integration: [Direct system-to-system communication patterns]_
+_API Gateway Patterns: [Centralized API management and routing]_
+_Service Mesh: [Service-to-service communication and observability]_
+_Enterprise Service Bus: [Traditional enterprise integration patterns]_
+_Source: [URL]_
+
+### Microservices Integration Patterns
+
+[Microservices integration analysis with source citations]
+_API Gateway Pattern: [External API management and routing]_
+_Service Discovery: [Dynamic service registration and discovery]_
+_Circuit Breaker Pattern: [Fault tolerance and resilience patterns]_
+_Saga Pattern: [Distributed transaction management]_
+_Source: [URL]_
+
+### Event-Driven Integration
+
+[Event-driven analysis with source citations]
+_Publish-Subscribe Patterns: [Event broadcasting and subscription models]_
+_Event Sourcing: [Event-based state management and persistence]_
+_Message Broker Patterns: [RabbitMQ, Kafka, and message routing]_
+_CQRS Patterns: [Command Query Responsibility Segregation]_
+_Source: [URL]_
+
+### Integration Security Patterns
+
+[Security patterns analysis with source citations]
+_OAuth 2.0 and JWT: [API authentication and authorization patterns]_
+_API Key Management: [Secure API access and key rotation]_
+_Mutual TLS: [Certificate-based service authentication]_
+_Data Encryption: [Secure data transmission and storage]_
+_Source: [URL]_
+```
+
+### 5. Present Analysis and Continue Option
+
+**Show analysis and present continue option:**
+
+"I've completed **integration patterns analysis** of system integration approaches for {{research_topic}}.
+
+**Key Integration Patterns Findings:**
+
+- API design patterns and protocols thoroughly analyzed
+- Communication protocols and data formats evaluated
+- System interoperability approaches documented
+- Microservices integration patterns mapped
+- Event-driven integration strategies identified
+
+**Ready to proceed to architectural patterns analysis?**
+[C] Continue - Save this to document and proceed to architectural patterns
+
+### 6. Handle Continue Selection
+
+#### If 'C' (Continue):
+
+- **CONTENT ALREADY WRITTEN TO DOCUMENT**
+- Update frontmatter: `stepsCompleted: [1, 2, 3]`
+- Load: `./step-04-architectural-patterns.md`
+
+## APPEND TO DOCUMENT:
+
+Content is already written to document when generated in step 4. No additional append needed.
+
+## SUCCESS METRICS:
+
+✅ API design patterns and protocols thoroughly analyzed
+✅ Communication protocols and data formats evaluated
+✅ System interoperability approaches documented
+✅ Microservices integration patterns mapped
+✅ Event-driven integration strategies identified
+✅ Content written immediately to document
+✅ [C] continue option presented and handled correctly
+✅ Proper routing to next step (architectural patterns)
+✅ Research goals alignment maintained
+
+## FAILURE MODES:
+
+❌ Relying solely on training data without web verification for current facts
+
+❌ Missing critical API design patterns or protocols
+❌ Incomplete communication protocols analysis
+❌ Not identifying system interoperability approaches
+❌ Not writing content immediately to document
+❌ Not presenting [C] continue option after content generation
+❌ Not routing to architectural patterns step
+
+❌ **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
+
+## INTEGRATION PATTERNS RESEARCH PROTOCOLS:
+
+- Research API design guides and best practices documentation
+- Use communication protocol specifications and standards
+- Analyze integration platform and middleware solutions
+- Study microservices architecture patterns and case studies
+- Focus on current integration data
+- Present conflicting information when sources disagree
+- Apply confidence levels appropriately
+
+## INTEGRATION PATTERNS ANALYSIS STANDARDS:
+
+- Always cite URLs for web search results
+- Use authoritative integration research sources
+- Note data currency and potential limitations
+- Present multiple perspectives when sources conflict
+- Apply confidence levels to uncertain data
+- Focus on actionable integration insights
+
+## NEXT STEP:
+
+After user selects 'C', load `./step-04-architectural-patterns.md` to analyze architectural patterns, design decisions, and system structures for {{research_topic}}.
+
+Remember: Always write research content to document immediately and emphasize current integration data with rigorous source verification!

package/src/modules/bmm/workflows/1-analysis/research/technical-steps/step-04-architectural-patterns.md

@@ -0,0 +1,201 @@
+# Technical Research Step 4: Architectural Patterns
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without web search verification
+
+- 📖 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
+- ✅ Search the web to verify and supplement your knowledge with current facts
+- 📋 YOU ARE A SYSTEMS ARCHITECT, not content generator
+- 💬 FOCUS on architectural patterns and design decisions
+- 🔍 WEB SEARCH REQUIRED - verify current facts against live sources
+- 📝 WRITE CONTENT IMMEDIATELY TO DOCUMENT
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show web search analysis before presenting findings
+- ⚠️ Present [C] continue option after architectural patterns content generation
+- 📝 WRITE ARCHITECTURAL PATTERNS ANALYSIS TO DOCUMENT IMMEDIATELY
+- 💾 ONLY proceed when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
+- 🚫 FORBIDDEN to load next step until C is selected
+
+## CONTEXT BOUNDARIES:
+
+- Current document and frontmatter from previous steps are available
+- **Research topic = "{{research_topic}}"** - established from initial discussion
+- **Research goals = "{{research_goals}}"** - established from initial discussion
+- Focus on architectural patterns and design decisions
+- Web search capabilities with source verification are enabled
+
+## YOUR TASK:
+
+Conduct comprehensive architectural patterns analysis with emphasis on design decisions and implementation approaches for {{research_topic}}.
+
+## ARCHITECTURAL PATTERNS SEQUENCE:
+
+### 1. Begin Architectural Patterns Analysis
+
+Start with architectural research approach:
+"Now I'll focus on **architectural patterns and design decisions** for effective architecture approaches for [technology/domain].
+
+**Architectural Patterns Focus:**
+
+- System architecture patterns and their trade-offs
+- Design principles and best practices
+- Scalability and maintainability considerations
+- Integration and communication patterns
+- Security and performance architectural considerations
+
+**Let me search for current architectural patterns and approaches.**"
+
+### 2. Web Search for System Architecture Patterns
+
+Search for current architecture patterns:
+Search the web: "system architecture patterns best practices"
+
+**Architecture focus:**
+
+- Microservices, monolithic, and serverless patterns
+- Event-driven and reactive architectures
+- Domain-driven design patterns
+- Cloud-native and edge architecture patterns
+
+### 3. Web Search for Design Principles
+
+Search for current design principles:
+Search the web: "software design principles patterns"
+
+**Design focus:**
+
+- SOLID principles and their application
+- Clean architecture and hexagonal architecture
+- API design and GraphQL vs REST patterns
+- Database design and data architecture patterns
+
+### 4. Web Search for Scalability Patterns
+
+Search for current scalability approaches:
+Search the web: "scalability architecture patterns"
+
+**Scalability focus:**
+
+- Horizontal vs vertical scaling patterns
+- Load balancing and caching strategies
+- Distributed systems and consensus patterns
+- Performance optimization techniques
+
+### 5. Generate Architectural Patterns Content
+
+Prepare architectural analysis with web search citations:
+
+#### Content Structure:
+
+When saving to document, append these Level 2 and Level 3 sections:
+
+```markdown
+## Architectural Patterns and Design
+
+### System Architecture Patterns
+
+[System architecture patterns analysis with source citations]
+_Source: [URL]_
+
+### Design Principles and Best Practices
+
+[Design principles analysis with source citations]
+_Source: [URL]_
+
+### Scalability and Performance Patterns
+
+[Scalability patterns analysis with source citations]
+_Source: [URL]_
+
+### Integration and Communication Patterns
+
+[Integration patterns analysis with source citations]
+_Source: [URL]_
+
+### Security Architecture Patterns
+
+[Security patterns analysis with source citations]
+_Source: [URL]_
+
+### Data Architecture Patterns
+
+[Data architecture analysis with source citations]
+_Source: [URL]_
+
+### Deployment and Operations Architecture
+
+[Deployment architecture analysis with source citations]
+_Source: [URL]_
+```
+
+### 6. Present Analysis and Continue Option
+
+Show the generated architectural patterns and present continue option:
+"I've completed the **architectural patterns analysis** for effective architecture approaches.
+
+**Key Architectural Findings:**
+
+- System architecture patterns and trade-offs clearly mapped
+- Design principles and best practices thoroughly documented
+- Scalability and performance patterns identified
+- Integration and communication patterns analyzed
+- Security and data architecture considerations captured
+
+**Ready to proceed to implementation research?**
+[C] Continue - Save this to the document and move to implementation research
+
+### 7. Handle Continue Selection
+
+#### If 'C' (Continue):
+
+- Append the final content to the research document
+- Update frontmatter: `stepsCompleted: [1, 2, 3]`
+- Load: `./step-05-implementation-research.md`
+
+## APPEND TO DOCUMENT:
+
+When user selects 'C', append the content directly to the research document using the structure from step 5.
+
+## SUCCESS METRICS:
+
+✅ System architecture patterns identified with current citations
+✅ Design principles clearly documented and analyzed
+✅ Scalability and performance patterns thoroughly mapped
+✅ Integration and communication patterns captured
+✅ Security and data architecture considerations analyzed
+✅ [C] continue option presented and handled correctly
+✅ Content properly appended to document when C selected
+✅ Proper routing to implementation research step
+
+## FAILURE MODES:
+
+❌ Relying solely on training data without web verification for current facts
+
+❌ Missing critical system architecture patterns
+❌ Not analyzing design trade-offs and considerations
+❌ Incomplete scalability or performance patterns analysis
+❌ Not presenting [C] continue option after content generation
+❌ Appending content without user selecting 'C'
+
+❌ **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
+
+## ARCHITECTURAL RESEARCH PROTOCOLS:
+
+- Search for architecture documentation and pattern catalogs
+- Use architectural conference proceedings and case studies
+- Research successful system architectures and their evolution
+- Note architectural decision records (ADRs) and rationales
+- Research architecture assessment and evaluation frameworks
+
+## NEXT STEP:
+
+After user selects 'C' and content is saved to document, load `./step-05-implementation-research.md` to focus on implementation approaches and technology adoption.
+
+Remember: Always emphasize current architectural data and rigorous source verification!