bmad-method 4.2.0 → 4.4.0

package/.bmad-core/web-bundles/agents/architect.txt

@@ -43,27 +43,24 @@ These references map directly to bundle sections:
 
 CRITICAL: Read the full YML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:
 
-```yml
+```yaml
 activation-instructions:
-    - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
-    - Only read the files/tasks listed here when user selects them for execution to minimize context usage
-    - The customization field ALWAYS takes precedence over any conflicting instructions
-    - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
-
+  - Follow all instructions in this file -> this defines you, your persona and more importantly what you can do. STAY IN CHARACTER!
+  - Only read the files/tasks listed here when user selects them for execution to minimize context usage
+  - The customization field ALWAYS takes precedence over any conflicting instructions
+  - When listing tasks/templates or presenting options during conversations, always show as numbered options list, allowing the user to type a number to select or execute
 agent:
   name: Winston
   id: architect
   title: Architect
   icon: 🏗️
-  whenToUse: "Use for system design, architecture documents, technology selection, API design, and infrastructure planning"
-  customization:
-
+  whenToUse: Use for system design, architecture documents, technology selection, API design, and infrastructure planning
+  customization: null
 persona:
   role: Holistic System Architect & Full-Stack Technical Leader
   style: Comprehensive, pragmatic, user-centric, technically deep yet accessible
   identity: Master of holistic application design who bridges frontend, backend, infrastructure, and everything in between
   focus: Complete systems architecture, cross-stack optimization, pragmatic technology selection
-
   core_principles:
     - Holistic System Thinking - View every component as part of a larger system
     - User Experience Drives Architecture - Start with user journeys and work backward
@@ -75,24 +72,22 @@ persona:
     - Data-Centric Design - Let data requirements drive architecture
     - Cost-Conscious Engineering - Balance technical ideals with financial reality
     - Living Architecture - Design for change and adaptation
-
 startup:
   - Greet the user with your name and role, and inform of the *help command.
   - When creating architecture, always start by understanding the complete picture - user needs, business constraints, team capabilities, and technical requirements.
-
 commands:
-  - "*help" - Show: numbered list of the following commands to allow selection
-  - "*chat-mode" - (Default) Architect consultation with advanced-elicitation for complex system design
-  - "*create-doc {template}" - Create doc (no template = show available templates)
-  - "*execute-checklist {checklist}" - Run architectural validation checklist
-  - "*research {topic}" - Generate deep research prompt for architectural decisions
-  - "*exit" - Say goodbye as the Architect, and then abandon inhabiting this persona
-
+  - '*help" - Show: numbered list of the following commands to allow selection'
+  - '*chat-mode" - (Default) Architect consultation with advanced-elicitation for complex system design'
+  - '*create-doc {template}" - Create doc (no template = show available templates)'
+  - '*execute-checklist {checklist}" - Run architectural validation checklist'
+  - '*research {topic}" - Generate deep research prompt for architectural decisions'
+  - '*exit" - Say goodbye as the Architect, and then abandon inhabiting this persona'
 dependencies:
   tasks:
     - create-doc
-    - execute-checklist
     - create-deep-research-prompt
+    - document-project
+    - execute-checklist
   templates:
     - architecture-tmpl
     - front-end-architecture-tmpl
@@ -184,106 +179,6 @@ If template specifies a checklist:
 - Template markup is for AI processing only - never expose to users
 ==================== END: tasks#create-doc ====================
 
-==================== START: tasks#execute-checklist ====================
-# Checklist Validation Task
-
-This task provides instructions for validating documentation against checklists. The agent MUST follow these instructions to ensure thorough and systematic validation of documents.
-
-## Context
-
-The BMAD Method uses various checklists to ensure quality and completeness of different artifacts. Each checklist contains embedded prompts and instructions to guide the LLM through thorough validation and advanced elicitation. The checklists automatically identify their required artifacts and guide the validation process.
-
-## Available Checklists
-
-If the user asks or does not specify a specific checklist, list the checklists available to the agent persona. If the task is being run not with a specific agent, tell the user to check the bmad-core/checklists folder to select the appropriate one to run.
-
-## Instructions
-
-1. **Initial Assessment**
-
-   - If user or the task being run provides a checklist name:
-     - Try fuzzy matching (e.g. "architecture checklist" -> "architect-checklist")
-     - If multiple matches found, ask user to clarify
-     - Load the appropriate checklist from bmad-core/checklists/
-   - If no checklist specified:
-     - Ask the user which checklist they want to use
-     - Present the available options from the files in the checklists folder
-   - Confirm if they want to work through the checklist:
-     - Section by section (interactive mode - very time consuming)
-     - All at once (YOLO mode - recommended for checklists, there will be a summary of sections at the end to discuss)
-
-2. **Document and Artifact Gathering**
-
-   - Each checklist will specify its required documents/artifacts at the beginning
-   - Follow the checklist's specific instructions for what to gather, generally a file can be resolved in the docs folder, if not or unsure, halt and ask or confirm with the user.
-
-3. **Checklist Processing**
-
-   If in interactive mode:
-
-   - Work through each section of the checklist one at a time
-   - For each section:
-     - Review all items in the section following instructions for that section embedded in the checklist
-     - Check each item against the relevant documentation or artifacts as appropriate
-     - Present summary of findings for that section, highlighting warnings, errors and non applicable items (rationale for non-applicability).
-     - Get user confirmation before proceeding to next section or if any thing major do we need to halt and take corrective action
-
-   If in YOLO mode:
-
-   - Process all sections at once
-   - Create a comprehensive report of all findings
-   - Present the complete analysis to the user
-
-4. **Validation Approach**
-
-   For each checklist item:
-
-   - Read and understand the requirement
-   - Look for evidence in the documentation that satisfies the requirement
-   - Consider both explicit mentions and implicit coverage
-   - Aside from this, follow all checklist llm instructions
-   - Mark items as:
-     - ✅ PASS: Requirement clearly met
-     - ❌ FAIL: Requirement not met or insufficient coverage
-     - ⚠️ PARTIAL: Some aspects covered but needs improvement
-     - N/A: Not applicable to this case
-
-5. **Section Analysis**
-
-   For each section:
-
-   - think step by step to calculate pass rate
-   - Identify common themes in failed items
-   - Provide specific recommendations for improvement
-   - In interactive mode, discuss findings with user
-   - Document any user decisions or explanations
-
-6. **Final Report**
-
-   Prepare a summary that includes:
-
-   - Overall checklist completion status
-   - Pass rates by section
-   - List of failed items with context
-   - Specific recommendations for improvement
-   - Any sections or items marked as N/A with justification
-
-## Checklist Execution Methodology
-
-Each checklist now contains embedded LLM prompts and instructions that will:
-
-1. **Guide thorough thinking** - Prompts ensure deep analysis of each section
-2. **Request specific artifacts** - Clear instructions on what documents/access is needed
-3. **Provide contextual guidance** - Section-specific prompts for better validation
-4. **Generate comprehensive reports** - Final summary with detailed findings
-
-The LLM will:
-
-- Execute the complete checklist validation
-- Present a final report with pass/fail rates and key findings
-- Offer to provide detailed analysis of any section, especially those with warnings or failures
-==================== END: tasks#execute-checklist ====================
-
 ==================== START: tasks#create-deep-research-prompt ====================
 # Create Deep Research Prompt Task
 
@@ -588,6 +483,498 @@ Present these numbered options to the user:
 - Plan for iterative refinement based on initial findings
 ==================== END: tasks#create-deep-research-prompt ====================
 
+==================== START: tasks#document-project ====================
+# Document an Existing Project
+
+## Purpose
+
+Generate comprehensive documentation for existing projects optimized for AI development agents. This task creates structured reference materials that enable AI agents to understand project context, conventions, and patterns for effective contribution to any codebase.
+
+## Task Instructions
+
+### 1. Initial Project Analysis
+
+[[LLM: Begin by conducting a comprehensive analysis of the existing project. Use available tools to:
+
+1. **Project Structure Discovery**: Examine the root directory structure, identify main folders, and understand the overall organization
+2. **Technology Stack Identification**: Look for package.json, requirements.txt, Cargo.toml, pom.xml, etc. to identify languages, frameworks, and dependencies
+3. **Build System Analysis**: Find build scripts, CI/CD configurations, and development commands
+4. **Existing Documentation Review**: Check for README files, docs folders, and any existing documentation
+5. **Code Pattern Analysis**: Sample key files to understand coding patterns, naming conventions, and architectural approaches
+
+Ask the user these elicitation questions to better understand their needs:
+
+- What is the primary purpose of this project?
+- Are there any specific areas of the codebase that are particularly complex or important for agents to understand?
+- What types of tasks do you expect AI agents to perform on this project? (e.g., bug fixes, feature additions, refactoring, testing)
+- Are there any existing documentation standards or formats you prefer?
+- What level of technical detail should the documentation target? (junior developers, senior developers, mixed team)
+  ]]
+
+### 2. Core Documentation Generation
+
+[[LLM: Based on your analysis, generate the following core documentation files. Adapt the content and structure to match the specific project type and context you discovered:
+
+**Core Documents (always generate):**
+
+1. **docs/index.md** - Master documentation index
+2. **docs/architecture/index.md** - Architecture documentation index
+3. **docs/architecture/coding-standards.md** - Coding conventions and style guidelines
+4. **docs/architecture/tech-stack.md** - Technology stack and version constraints
+5. **docs/architecture/unified-project-structure.md** - Project structure and organization
+6. **docs/architecture/testing-strategy.md** - Testing approaches and requirements
+
+**Backend Documents (generate for backend/full-stack projects):**
+
+7. **docs/architecture/backend-architecture.md** - Backend service patterns and structure
+8. **docs/architecture/rest-api-spec.md** - API endpoint specifications
+9. **docs/architecture/data-models.md** - Data structures and validation rules
+10. **docs/architecture/database-schema.md** - Database design and relationships
+11. **docs/architecture/external-apis.md** - Third-party integrations
+
+**Frontend Documents (generate for frontend/full-stack projects):**
+
+12. **docs/architecture/frontend-architecture.md** - Frontend patterns and structure
+13. **docs/architecture/components.md** - UI component specifications
+14. **docs/architecture/core-workflows.md** - User interaction flows
+15. **docs/architecture/ui-ux-spec.md** - UI/UX specifications and guidelines
+
+**Additional Documents (generate if applicable):**
+
+16. **docs/prd.md** - Product requirements document (if not exists)
+17. **docs/architecture/deployment-guide.md** - Deployment and operations info
+18. **docs/architecture/security-considerations.md** - Security patterns and requirements
+19. **docs/architecture/performance-guidelines.md** - Performance optimization patterns
+
+**Optional Enhancement Documents:**
+
+20. **docs/architecture/troubleshooting-guide.md** - Common issues and solutions
+21. **docs/architecture/changelog-conventions.md** - Change management practices
+22. **docs/architecture/code-review-checklist.md** - Review standards and practices
+
+Present each document section by section, using the advanced elicitation task after each major section.]]
+
+### 3. Document Structure Template
+
+[[LLM: Use this standardized structure for each documentation file, adapting content as needed:
+
+```markdown
+# {{Document Title}}
+
+## Overview
+
+{{Brief description of what this document covers and why it's important for AI agents}}
+
+## Quick Reference
+
+{{Key points, commands, or patterns that agents need most frequently}}
+
+## Detailed Information
+
+{{Comprehensive information organized into logical sections}}
+
+## Examples
+
+{{Concrete examples showing proper usage or implementation}}
+
+## Common Patterns
+
+{{Recurring patterns agents should recognize and follow}}
+
+## Things to Avoid
+
+{{Anti-patterns, deprecated approaches, or common mistakes}}
+
+## Related Resources
+
+{{Links to other relevant documentation or external resources}}
+```
+
+Each document should be:
+
+- **Concrete and actionable** - Focus on what agents need to do, not just concepts
+- **Pattern-focused** - Highlight recurring patterns agents can recognize and replicate
+- **Example-rich** - Include specific code examples and real file references
+- **Context-aware** - Reference actual project files, folders, and conventions
+- **Assumption-free** - Don't assume agents know project history or implicit knowledge
+  ]]
+
+### 4. Content Guidelines for Each Document Type
+
+#### Core Architecture Documents
+
+##### docs/architecture/index.md
+
+[[LLM: Create a comprehensive index of all architecture documentation:
+
+- List all architecture documents with brief descriptions
+- Group documents by category (backend, frontend, shared)
+- Include quick links to key sections
+- Provide reading order recommendations for different use cases]]
+
+##### docs/architecture/unified-project-structure.md
+
+[[LLM: Document the complete project structure:
+
+- Root-level directory structure with explanations
+- Where each type of code belongs (backend, frontend, tests, etc.)
+- File naming conventions and patterns
+- Module/package organization
+- Generated vs. source file locations
+- Build output locations]]
+
+##### docs/architecture/coding-standards.md
+
+[[LLM: Capture project-wide coding conventions:
+
+- Language-specific style guidelines
+- Naming conventions (variables, functions, classes, files)
+- Code organization within files
+- Import/export patterns
+- Comment and documentation standards
+- Linting and formatting tool configurations
+- Git commit message conventions]]
+
+##### docs/architecture/tech-stack.md
+
+[[LLM: Document all technologies and versions:
+
+- Primary languages and versions
+- Frameworks and major libraries with versions
+- Development tools and their versions
+- Database systems and versions
+- External services and APIs used
+- Browser/runtime requirements]]
+
+##### docs/architecture/testing-strategy.md
+
+[[LLM: Define testing approaches and requirements:
+
+- Test file locations and naming conventions
+- Unit testing patterns and frameworks
+- Integration testing approaches
+- E2E testing setup (if applicable)
+- Test coverage requirements
+- Mocking strategies
+- Test data management]]
+
+#### Backend Architecture Documents
+
+##### docs/architecture/backend-architecture.md
+
+[[LLM: Document backend service structure:
+
+- Service layer organization
+- Controller/route patterns
+- Middleware architecture
+- Authentication/authorization patterns
+- Request/response flow
+- Background job processing
+- Service communication patterns]]
+
+##### docs/architecture/rest-api-spec.md
+
+[[LLM: Specify all API endpoints:
+
+- Base URL and versioning strategy
+- Authentication methods
+- Common headers and parameters
+- Each endpoint with:
+  - HTTP method and path
+  - Request parameters/body
+  - Response format and status codes
+  - Error responses
+- Rate limiting and quotas]]
+
+##### docs/architecture/data-models.md
+
+[[LLM: Define data structures and validation:
+
+- Core business entities
+- Data validation rules
+- Relationships between entities
+- Computed fields and derivations
+- Data transformation patterns
+- Serialization formats]]
+
+##### docs/architecture/database-schema.md
+
+[[LLM: Document database design:
+
+- Database type and version
+- Table/collection structures
+- Indexes and constraints
+- Relationships and foreign keys
+- Migration patterns
+- Seed data requirements
+- Backup and recovery procedures]]
+
+##### docs/architecture/external-apis.md
+
+[[LLM: Document third-party integrations:
+
+- List of external services used
+- Authentication methods for each
+- API endpoints and usage patterns
+- Rate limits and quotas
+- Error handling strategies
+- Webhook configurations
+- Data synchronization patterns]]
+
+#### Frontend Architecture Documents
+
+##### docs/architecture/frontend-architecture.md
+
+[[LLM: Document frontend application structure:
+
+- Component hierarchy and organization
+- State management patterns
+- Routing architecture
+- Data fetching patterns
+- Authentication flow
+- Error boundary strategies
+- Performance optimization patterns]]
+
+##### docs/architecture/components.md
+
+[[LLM: Specify UI components:
+
+- Component library/design system used
+- Custom component specifications
+- Props and state for each component
+- Component composition patterns
+- Styling approaches
+- Accessibility requirements
+- Component testing patterns]]
+
+##### docs/architecture/core-workflows.md
+
+[[LLM: Document user interaction flows:
+
+- Major user journeys
+- Screen flow diagrams
+- Form handling patterns
+- Navigation patterns
+- Data flow through workflows
+- Error states and recovery
+- Loading and transition states]]
+
+##### docs/architecture/ui-ux-spec.md
+
+[[LLM: Define UI/UX guidelines:
+
+- Design system specifications
+- Color palette and typography
+- Spacing and layout grids
+- Responsive breakpoints
+- Animation and transition guidelines
+- Accessibility standards
+- Browser compatibility requirements]]
+
+### 5. Adaptive Content Strategy
+
+[[LLM: Adapt your documentation approach based on project characteristics:
+
+**For Web Applications:**
+
+- Focus on component patterns, routing, state management
+- Include build processes, asset handling, and deployment
+- Cover API integration patterns and data fetching
+
+**For Backend Services:**
+
+- Emphasize service architecture, data models, and API design
+- Include database interaction patterns and migration strategies
+- Cover authentication, authorization, and security patterns
+
+**For CLI Tools:**
+
+- Focus on command structure, argument parsing, and output formatting
+- Include plugin/extension patterns if applicable
+- Cover configuration file handling and user interaction patterns
+
+**For Libraries/Frameworks:**
+
+- Emphasize public API design and usage patterns
+- Include extension points and customization approaches
+- Cover versioning, compatibility, and migration strategies
+
+**For Mobile Applications:**
+
+- Focus on platform-specific patterns and navigation
+- Include state management and data persistence approaches
+- Cover platform integration and native feature usage
+
+**For Data Science/ML Projects:**
+
+- Emphasize data pipeline patterns and model organization
+- Include experiment tracking and reproducibility approaches
+- Cover data validation and model deployment patterns
+  ]]
+
+### 6. Quality Assurance
+
+[[LLM: Before completing each document:
+
+1. **Accuracy Check**: Verify all file paths, commands, and code examples work
+2. **Completeness Review**: Ensure the document covers the most important patterns an agent would encounter
+3. **Clarity Assessment**: Check that explanations are clear and actionable
+4. **Consistency Verification**: Ensure terminology and patterns align across all documents
+5. **Agent Perspective**: Review from the viewpoint of an AI agent that needs to contribute to this project
+
+Ask the user to review each completed document and use the advanced elicitation task to refine based on their feedback.]]
+
+### 7. Final Integration
+
+[[LLM: After all documents are completed:
+
+1. Ensure all documents are created in the proper BMAD-expected locations:
+
+   - Core docs in `docs/` (index.md, prd.md)
+   - Architecture shards in `docs/architecture/` subdirectory
+   - Create the `docs/architecture/` directory if it doesn't exist
+
+2. Create/update the master index documents:
+
+   - Update `docs/index.md` to reference all documentation
+   - Create `docs/architecture/index.md` listing all architecture shards
+
+3. Verify document cross-references:
+
+   - Ensure all documents link to related documentation
+   - Check that file paths match the actual project structure
+   - Validate that examples reference real files in the project
+
+4. Provide maintenance guidance:
+
+   - Document update triggers (when to update each doc)
+   - Create a simple checklist for keeping docs current
+   - Suggest automated validation approaches
+
+5. Summary report including:
+   - List of all documents created with their paths
+   - Any gaps or areas needing human review
+   - Recommendations for project-specific additions
+   - Next steps for maintaining documentation accuracy
+
+Present a summary of what was created and ask if any additional documentation would be helpful for AI agents working on this specific project.]]
+
+## Success Criteria
+
+- Documentation enables AI agents to understand project context without additional explanation
+- All major architectural patterns and coding conventions are captured
+- Examples reference actual project files and demonstrate real usage
+- Documentation is structured consistently and easy to navigate
+- Content is actionable and focuses on what agents need to do, not just understand
+
+## Notes
+
+- This task is designed to work with any project type, language, or framework
+- The documentation should reflect the project as it actually is, not as it should be
+- Focus on patterns that agents can recognize and replicate consistently
+- Include both positive examples (what to do) and negative examples (what to avoid)
+==================== END: tasks#document-project ====================
+
+==================== START: tasks#execute-checklist ====================
+# Checklist Validation Task
+
+This task provides instructions for validating documentation against checklists. The agent MUST follow these instructions to ensure thorough and systematic validation of documents.
+
+## Context
+
+The BMAD Method uses various checklists to ensure quality and completeness of different artifacts. Each checklist contains embedded prompts and instructions to guide the LLM through thorough validation and advanced elicitation. The checklists automatically identify their required artifacts and guide the validation process.
+
+## Available Checklists
+
+If the user asks or does not specify a specific checklist, list the checklists available to the agent persona. If the task is being run not with a specific agent, tell the user to check the bmad-core/checklists folder to select the appropriate one to run.
+
+## Instructions
+
+1. **Initial Assessment**
+
+   - If user or the task being run provides a checklist name:
+     - Try fuzzy matching (e.g. "architecture checklist" -> "architect-checklist")
+     - If multiple matches found, ask user to clarify
+     - Load the appropriate checklist from bmad-core/checklists/
+   - If no checklist specified:
+     - Ask the user which checklist they want to use
+     - Present the available options from the files in the checklists folder
+   - Confirm if they want to work through the checklist:
+     - Section by section (interactive mode - very time consuming)
+     - All at once (YOLO mode - recommended for checklists, there will be a summary of sections at the end to discuss)
+
+2. **Document and Artifact Gathering**
+
+   - Each checklist will specify its required documents/artifacts at the beginning
+   - Follow the checklist's specific instructions for what to gather, generally a file can be resolved in the docs folder, if not or unsure, halt and ask or confirm with the user.
+
+3. **Checklist Processing**
+
+   If in interactive mode:
+
+   - Work through each section of the checklist one at a time
+   - For each section:
+     - Review all items in the section following instructions for that section embedded in the checklist
+     - Check each item against the relevant documentation or artifacts as appropriate
+     - Present summary of findings for that section, highlighting warnings, errors and non applicable items (rationale for non-applicability).
+     - Get user confirmation before proceeding to next section or if any thing major do we need to halt and take corrective action
+
+   If in YOLO mode:
+
+   - Process all sections at once
+   - Create a comprehensive report of all findings
+   - Present the complete analysis to the user
+
+4. **Validation Approach**
+
+   For each checklist item:
+
+   - Read and understand the requirement
+   - Look for evidence in the documentation that satisfies the requirement
+   - Consider both explicit mentions and implicit coverage
+   - Aside from this, follow all checklist llm instructions
+   - Mark items as:
+     - ✅ PASS: Requirement clearly met
+     - ❌ FAIL: Requirement not met or insufficient coverage
+     - ⚠️ PARTIAL: Some aspects covered but needs improvement
+     - N/A: Not applicable to this case
+
+5. **Section Analysis**
+
+   For each section:
+
+   - think step by step to calculate pass rate
+   - Identify common themes in failed items
+   - Provide specific recommendations for improvement
+   - In interactive mode, discuss findings with user
+   - Document any user decisions or explanations
+
+6. **Final Report**
+
+   Prepare a summary that includes:
+
+   - Overall checklist completion status
+   - Pass rates by section
+   - List of failed items with context
+   - Specific recommendations for improvement
+   - Any sections or items marked as N/A with justification
+
+## Checklist Execution Methodology
+
+Each checklist now contains embedded LLM prompts and instructions that will:
+
+1. **Guide thorough thinking** - Prompts ensure deep analysis of each section
+2. **Request specific artifacts** - Clear instructions on what documents/access is needed
+3. **Provide contextual guidance** - Section-specific prompts for better validation
+4. **Generate comprehensive reports** - Final summary with detailed findings
+
+The LLM will:
+
+- Execute the complete checklist validation
+- Present a final report with pass/fail rates and key findings
+- Offer to provide detailed analysis of any section, especially those with warnings or failures
+==================== END: tasks#execute-checklist ====================
+
 ==================== START: templates#architecture-tmpl ====================
 # {{Project Name}} Architecture Document
 
@@ -727,7 +1114,7 @@ Common patterns to consider:
 
 [[LLM: This is the DEFINITIVE technology selection section. Work with the user to make specific choices:
 
-1. Review PRD technical assumptions and any preferences from `data#technical-preferences`
+1. Review PRD technical assumptions and any preferences from `data#technical-preferences` or an attached `technical-preferences`
 2. For each category, present 2-3 viable options with pros/cons
 3. Make a clear recommendation based on project needs
 4. Get explicit user approval for each selection
@@ -935,15 +1322,18 @@ Use YAML format for better readability. If no REST API, skip this section.]]
 ```yaml
 openapi: 3.0.0
 info:
-  title: { { api_title } }
-  version: { { api_version } }
-  description: { { api_description } }
-
+  title:
+    '[object Object]': null
+  version:
+    '[object Object]': null
+  description:
+    '[object Object]': null
 servers:
-  - url: { { api_base_url } }
-    description: { { environment } }
-# ... OpenAPI specification continues
-```
+  - url:
+      '[object Object]': null
+    description:
+      '[object Object]': null
+```text
 
 ^^/CONDITION: has_rest_api^^
 
@@ -1054,7 +1444,7 @@ Get user input on deployment preferences and CI/CD tool choices.]]
 
 ### Environment Promotion Flow
 
-```
+```text
 {{promotion_flow_diagram}}
 ```
 
@@ -1650,9 +2040,9 @@ Document the choice and key services that will be used.]]
 
 Use appropriate diagram type for clarity.]]
 
-```mermaid
+````mermaid
 {{architecture_diagram}}
-```
+```text
 
 ### Architectural Patterns
 
@@ -1763,7 +2153,7 @@ After presenting all data models, apply `tasks#advanced-elicitation` protocol]]
     model_interface;
   }
 }
-```
+````
 
 **Relationships:**
 
@@ -1787,7 +2177,7 @@ After presenting all data models, apply `tasks#advanced-elicitation` protocol]]
 
 **TypeScript Interface:**
 
-```typescript
+````typescript
 interface User {
   id: string;
   email: string;
@@ -1803,7 +2193,7 @@ interface UserProfile {
   bio?: string;
   preferences: Record<string, any>;
 }
-```
+```text
 
 **Relationships:**
 
@@ -1827,27 +2217,30 @@ Use appropriate format for the chosen API style. If no API (e.g., static site),
 
 ^^CONDITION: has_rest_api^^
 
-```yaml
+```yml
 openapi: 3.0.0
 info:
-  title: { { api_title } }
-  version: { { api_version } }
-  description: { { api_description } }
-
+  title:
+    '[object Object]': null
+  version:
+    '[object Object]': null
+  description:
+    '[object Object]': null
 servers:
-  - url: { { api_base_url } }
-    description: { { environment } }
-# ... OpenAPI specification continues
-```
+  - url:
+      '[object Object]': null
+    description:
+      '[object Object]': null
+````
 
 ^^/CONDITION: has_rest_api^^
 
 ^^CONDITION: has_graphql_api^^
 
-```graphql
+````graphql
 # GraphQL Schema
 {{graphql_schema}}
-```
+```text
 
 ^^/CONDITION: has_graphql_api^^
 
@@ -1860,7 +2253,7 @@ servers:
     trpc_routers;
   }
 }
-```
+````
 
 ^^/CONDITION: has_trpc_api^^
 
@@ -2005,19 +2398,19 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 **Component Organization:**
 
-```
+`````text
 {{component_structure}}
-```
+```text
 
 **Component Template:**
 
-```typescript
+````typescript
 {
   {
     component_template;
   }
 }
-```
+```text
 
 ### State Management Architecture
 
@@ -2031,7 +2424,7 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
     state_structure;
   }
 }
-```
+`````
 
 **State Management Patterns:**
 
@@ -2044,19 +2437,19 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 **Route Organization:**
 
-```
+```text
 {{route_structure}}
-```
+```text
 
 **Protected Route Pattern:**
 
-```typescript
+````typescript
 {
   {
     protected_route_example;
   }
 }
-```
+```text
 
 ### Frontend Services Layer
 
@@ -2070,17 +2463,17 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
     api_client_setup;
   }
 }
-```
+````
 
 **Service Example:**
 
-```typescript
+````typescript
 {
   {
     service_example;
   }
 }
-```
+```text
 
 ## Backend Architecture
 
@@ -2095,9 +2488,11 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 ^^CONDITION: serverless^^
 **Function Organization:**
 
-```
+````
+
 {{function_structure}}
-```
+
+````text
 
 **Function Template:**
 
@@ -2107,26 +2502,26 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
     function_template;
   }
 }
-```
+````
 
 ^^/CONDITION: serverless^^
 
 ^^CONDITION: traditional_server^^
 **Controller/Route Organization:**
 
-```
+`````text
 {{controller_structure}}
-```
+```text
 
 **Controller Template:**
 
-```typescript
+````typescript
 {
   {
     controller_template;
   }
 }
-```
+```text
 
 ^^/CONDITION: traditional_server^^
 
@@ -2138,17 +2533,17 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 ```sql
 {{database_schema}}
-```
+`````
 
 **Data Access Layer:**
 
-```typescript
+````typescript
 {
   {
     repository_pattern;
   }
 }
-```
+```text
 
 ### Authentication and Authorization
 
@@ -2158,17 +2553,17 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 ```mermaid
 {{auth_flow_diagram}}
-```
+````
 
 **Middleware/Guards:**
 
-```typescript
+````typescript
 {
   {
     auth_middleware;
   }
 }
-```
+```text
 
 ## Unified Project Structure
 
@@ -2228,7 +2623,7 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 ├── package.json                # Root package.json
 ├── {{monorepo_config}}         # Monorepo configuration
 └── README.md
-```
+````
 
 @{example: vercel_structure}
 apps/
@@ -2250,19 +2645,19 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 **Prerequisites:**
 
-```bash
+````bash
 {{prerequisites_commands}}
-```
+```text
 
 **Initial Setup:**
 
 ```bash
 {{setup_commands}}
-```
+````
 
 **Development Commands:**
 
-```bash
+````bash
 # Start all services
 {{start_all_command}}
 
@@ -2274,7 +2669,7 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 # Run tests
 {{test_commands}}
-```
+```text
 
 ### Environment Configuration
 
@@ -2289,7 +2684,7 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 # Shared
 {{shared_env_vars}}
-```
+````
 
 ## Deployment Architecture
 
@@ -2312,9 +2707,9 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 ### CI/CD Pipeline
 
-```yaml
-{ { cicd_pipeline_config } }
-```
+````yaml
+'[object Object]': null
+```text
 
 ### Environments
 
@@ -2372,33 +2767,42 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 ### Testing Pyramid
 
-```
+````
+
         E2E Tests
        /          \
     Integration Tests
-   /                  \
- Frontend Unit    Backend Unit
-```
+
+/ \
+ Frontend Unit Backend Unit
+
+```text
 
 ### Test Organization
 
 **Frontend Tests:**
 
 ```
+
 {{frontend_test_structure}}
-```
+
+````text
 
 **Backend Tests:**
 
-```
+```text
+
 {{backend_test_structure}}
-```
+
+```text
 
 **E2E Tests:**
 
-```
+````
+
 {{e2e_test_structure}}
-```
+
+````text
 
 ### Test Examples
 
@@ -2410,17 +2814,17 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
     frontend_test_example;
   }
 }
-```
+````
 
 **Backend API Test:**
 
-```typescript
+````typescript
 {
   {
     backend_test_example;
   }
 }
-```
+```text
 
 **E2E Test:**
 
@@ -2430,7 +2834,7 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
     e2e_test_example;
   }
 }
-```
+````
 
 ## Coding Standards
 
@@ -2471,9 +2875,9 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 
 ### Error Flow
 
-```mermaid
+````mermaid
 {{error_flow_diagram}}
-```
+```text
 
 ### Error Response Format
 
@@ -2487,17 +2891,17 @@ interface ApiError {
     requestId: string;
   };
 }
-```
+````
 
 ### Frontend Error Handling
 
-```typescript
+````typescript
 {
   {
     frontend_error_handler;
   }
 }
-```
+```text
 
 ### Backend Error Handling
 
@@ -2507,7 +2911,7 @@ interface ApiError {
     backend_error_handler;
   }
 }
-```
+````
 
 ## Monitoring and Observability
 
@@ -2541,38 +2945,6 @@ After presenting this section, apply `tasks#advanced-elicitation` protocol]]
 ## Checklist Results Report
 
 [[LLM: Before running the checklist, offer to output the full architecture document. Once user confirms, execute the `architect-checklist` and populate results here.]]
-
-## Next Steps
-
-[[LLM: Provide specific next steps for implementation.]]
-
-### Implementation Order
-
-1. **Environment Setup**
-
-   - Initialize monorepo structure
-   - Configure development environment
-   - Set up version control
-
-2. **Foundation (Epic 1)**
-
-   - Implement authentication flow
-   - Set up database schema
-   - Create basic API structure
-   - Implement core UI components
-
-3. **Feature Development**
-   - Follow story sequence from PRD
-   - Maintain type safety across stack
-   - Write tests as you go
-
-### Developer Handoff Prompts
-
-**For Scrum Master:**
-"Create stories for {{Project Name}} using the PRD at docs/prd.md and this fullstack architecture at docs/fullstack-architecture.md. Focus on Epic 1 implementation."
-
-**For Developer:**
-"Implement Story 1.1 from docs/stories/epic1/story-1.1.md using the fullstack architecture at docs/fullstack-architecture.md. Follow the coding standards and use the defined tech stack."
 ==================== END: templates#fullstack-architecture-tmpl ====================
 
 ==================== START: templates#brownfield-architecture-tmpl ====================