chore: add BMAD agent workflows and configuration system

- Add comprehensive agent workflow definitions for 8 specialized roles (analyst, architect, developer, product manager, scrum master, technical writer, UX designer, QA engineer)
- Add 35+ workflow definitions covering analysis, planning, solutioning, and implementation phases
- Add BMAD configuration system with agent, task, tool, workflow, and file manifests
- Add BMM (Business Model Methodology) documentation including quick-start guides, architecture references, and workflow analysis
- Add test architecture knowledge base with 20+ testing patterns and best practices
- Add team configuration templates and party mode setup for collaborative development
- Establish foundation for enterprise agentic development framework with adaptive scaling capabilities

.bmad/bmm/workflows/2-plan-workflows/prd/checklist.md

@@ -0,0 +1,346 @@
+# PRD + Epics + Stories Validation Checklist
+
+**Purpose**: Comprehensive validation that PRD, epics, and stories form a complete, implementable product plan.
+
+**Scope**: Validates the complete planning output (PRD.md + epics.md) for Levels 2-4 software projects
+
+**Expected Outputs**:
+
+- PRD.md with complete requirements
+- epics.md with detailed epic and story breakdown
+- Updated bmm-workflow-status.yaml
+
+---
+
+## 1. PRD Document Completeness
+
+### Core Sections Present
+
+- [ ] Executive Summary with vision alignment
+- [ ] Product differentiator clearly articulated
+- [ ] Project classification (type, domain, complexity)
+- [ ] Success criteria defined
+- [ ] Product scope (MVP, Growth, Vision) clearly delineated
+- [ ] Functional requirements comprehensive and numbered
+- [ ] Non-functional requirements (when applicable)
+- [ ] References section with source documents
+
+### Project-Specific Sections
+
+- [ ] **If complex domain:** Domain context and considerations documented
+- [ ] **If innovation:** Innovation patterns and validation approach documented
+- [ ] **If API/Backend:** Endpoint specification and authentication model included
+- [ ] **If Mobile:** Platform requirements and device features documented
+- [ ] **If SaaS B2B:** Tenant model and permission matrix included
+- [ ] **If UI exists:** UX principles and key interactions documented
+
+### Quality Checks
+
+- [ ] No unfilled template variables ({{variable}})
+- [ ] All variables properly populated with meaningful content
+- [ ] Product differentiator reflected throughout (not just stated once)
+- [ ] Language is clear, specific, and measurable
+- [ ] Project type correctly identified and sections match
+- [ ] Domain complexity appropriately addressed
+
+---
+
+## 2. Functional Requirements Quality
+
+### FR Format and Structure
+
+- [ ] Each FR has unique identifier (FR-001, FR-002, etc.)
+- [ ] FRs describe WHAT capabilities, not HOW to implement
+- [ ] FRs are specific and measurable
+- [ ] FRs are testable and verifiable
+- [ ] FRs focus on user/business value
+- [ ] No technical implementation details in FRs (those belong in architecture)
+
+### FR Completeness
+
+- [ ] All MVP scope features have corresponding FRs
+- [ ] Growth features documented (even if deferred)
+- [ ] Vision features captured for future reference
+- [ ] Domain-mandated requirements included
+- [ ] Innovation requirements captured with validation needs
+- [ ] Project-type specific requirements complete
+
+### FR Organization
+
+- [ ] FRs organized by capability/feature area (not by tech stack)
+- [ ] Related FRs grouped logically
+- [ ] Dependencies between FRs noted when critical
+- [ ] Priority/phase indicated (MVP vs Growth vs Vision)
+
+---
+
+## 3. Epics Document Completeness
+
+### Required Files
+
+- [ ] epics.md exists in output folder
+- [ ] Epic list in PRD.md matches epics in epics.md (titles and count)
+- [ ] All epics have detailed breakdown sections
+
+### Epic Quality
+
+- [ ] Each epic has clear goal and value proposition
+- [ ] Each epic includes complete story breakdown
+- [ ] Stories follow proper user story format: "As a [role], I want [goal], so that [benefit]"
+- [ ] Each story has numbered acceptance criteria
+- [ ] Prerequisites/dependencies explicitly stated per story
+- [ ] Stories are AI-agent sized (completable in 2-4 hour session)
+
+---
+
+## 4. FR Coverage Validation (CRITICAL)
+
+### Complete Traceability
+
+- [ ] **Every FR from PRD.md is covered by at least one story in epics.md**
+- [ ] Each story references relevant FR numbers
+- [ ] No orphaned FRs (requirements without stories)
+- [ ] No orphaned stories (stories without FR connection)
+- [ ] Coverage matrix verified (can trace FR → Epic → Stories)
+
+### Coverage Quality
+
+- [ ] Stories sufficiently decompose FRs into implementable units
+- [ ] Complex FRs broken into multiple stories appropriately
+- [ ] Simple FRs have appropriately scoped single stories
+- [ ] Non-functional requirements reflected in story acceptance criteria
+- [ ] Domain requirements embedded in relevant stories
+
+---
+
+## 5. Story Sequencing Validation (CRITICAL)
+
+### Epic 1 Foundation Check
+
+- [ ] **Epic 1 establishes foundational infrastructure**
+- [ ] Epic 1 delivers initial deployable functionality
+- [ ] Epic 1 creates baseline for subsequent epics
+- [ ] Exception: If adding to existing app, foundation requirement adapted appropriately
+
+### Vertical Slicing
+
+- [ ] **Each story delivers complete, testable functionality** (not horizontal layers)
+- [ ] No "build database" or "create UI" stories in isolation
+- [ ] Stories integrate across stack (data + logic + presentation when applicable)
+- [ ] Each story leaves system in working/deployable state
+
+### No Forward Dependencies
+
+- [ ] **No story depends on work from a LATER story or epic**
+- [ ] Stories within each epic are sequentially ordered
+- [ ] Each story builds only on previous work
+- [ ] Dependencies flow backward only (can reference earlier stories)
+- [ ] Parallel tracks clearly indicated if stories are independent
+
+### Value Delivery Path
+
+- [ ] Each epic delivers significant end-to-end value
+- [ ] Epic sequence shows logical product evolution
+- [ ] User can see value after each epic completion
+- [ ] MVP scope clearly achieved by end of designated epics
+
+---
+
+## 6. Scope Management
+
+### MVP Discipline
+
+- [ ] MVP scope is genuinely minimal and viable
+- [ ] Core features list contains only true must-haves
+- [ ] Each MVP feature has clear rationale for inclusion
+- [ ] No obvious scope creep in "must-have" list
+
+### Future Work Captured
+
+- [ ] Growth features documented for post-MVP
+- [ ] Vision features captured to maintain long-term direction
+- [ ] Out-of-scope items explicitly listed
+- [ ] Deferred features have clear reasoning for deferral
+
+### Clear Boundaries
+
+- [ ] Stories marked as MVP vs Growth vs Vision
+- [ ] Epic sequencing aligns with MVP → Growth progression
+- [ ] No confusion about what's in vs out of initial scope
+
+---
+
+## 7. Research and Context Integration
+
+### Source Document Integration
+
+- [ ] **If product brief exists:** Key insights incorporated into PRD
+- [ ] **If domain brief exists:** Domain requirements reflected in FRs and stories
+- [ ] **If research documents exist:** Research findings inform requirements
+- [ ] **If competitive analysis exists:** Differentiation strategy clear in PRD
+- [ ] All source documents referenced in PRD References section
+
+### Research Continuity to Architecture
+
+- [ ] Domain complexity considerations documented for architects
+- [ ] Technical constraints from research captured
+- [ ] Regulatory/compliance requirements clearly stated
+- [ ] Integration requirements with existing systems documented
+- [ ] Performance/scale requirements informed by research data
+
+### Information Completeness for Next Phase
+
+- [ ] PRD provides sufficient context for architecture decisions
+- [ ] Epics provide sufficient detail for technical design
+- [ ] Stories have enough acceptance criteria for implementation
+- [ ] Non-obvious business rules documented
+- [ ] Edge cases and special scenarios captured
+
+---
+
+## 8. Cross-Document Consistency
+
+### Terminology Consistency
+
+- [ ] Same terms used across PRD and epics for concepts
+- [ ] Feature names consistent between documents
+- [ ] Epic titles match between PRD and epics.md
+- [ ] No contradictions between PRD and epics
+
+### Alignment Checks
+
+- [ ] Success metrics in PRD align with story outcomes
+- [ ] Product differentiator articulated in PRD reflected in epic goals
+- [ ] Technical preferences in PRD align with story implementation hints
+- [ ] Scope boundaries consistent across all documents
+
+---
+
+## 9. Readiness for Implementation
+
+### Architecture Readiness (Next Phase)
+
+- [ ] PRD provides sufficient context for architecture workflow
+- [ ] Technical constraints and preferences documented
+- [ ] Integration points identified
+- [ ] Performance/scale requirements specified
+- [ ] Security and compliance needs clear
+
+### Development Readiness
+
+- [ ] Stories are specific enough to estimate
+- [ ] Acceptance criteria are testable
+- [ ] Technical unknowns identified and flagged
+- [ ] Dependencies on external systems documented
+- [ ] Data requirements specified
+
+### Track-Appropriate Detail
+
+**If BMad Method:**
+
+- [ ] PRD supports full architecture workflow
+- [ ] Epic structure supports phased delivery
+- [ ] Scope appropriate for product/platform development
+- [ ] Clear value delivery through epic sequence
+
+**If Enterprise Method:**
+
+- [ ] PRD addresses enterprise requirements (security, compliance, multi-tenancy)
+- [ ] Epic structure supports extended planning phases
+- [ ] Scope includes security, devops, and test strategy considerations
+- [ ] Clear value delivery with enterprise gates
+
+---
+
+## 10. Quality and Polish
+
+### Writing Quality
+
+- [ ] Language is clear and free of jargon (or jargon is defined)
+- [ ] Sentences are concise and specific
+- [ ] No vague statements ("should be fast", "user-friendly")
+- [ ] Measurable criteria used throughout
+- [ ] Professional tone appropriate for stakeholder review
+
+### Document Structure
+
+- [ ] Sections flow logically
+- [ ] Headers and numbering consistent
+- [ ] Cross-references accurate (FR numbers, section references)
+- [ ] Formatting consistent throughout
+- [ ] Tables/lists formatted properly
+
+### Completeness Indicators
+
+- [ ] No [TODO] or [TBD] markers remain
+- [ ] No placeholder text
+- [ ] All sections have substantive content
+- [ ] Optional sections either complete or omitted (not half-done)
+
+---
+
+## Critical Failures (Auto-Fail)
+
+If ANY of these are true, validation FAILS:
+
+- [ ] ❌ **No epics.md file exists** (two-file output required)
+- [ ] ❌ **Epic 1 doesn't establish foundation** (violates core sequencing principle)
+- [ ] ❌ **Stories have forward dependencies** (breaks sequential implementation)
+- [ ] ❌ **Stories not vertically sliced** (horizontal layers block value delivery)
+- [ ] ❌ **Epics don't cover all FRs** (orphaned requirements)
+- [ ] ❌ **FRs contain technical implementation details** (should be in architecture)
+- [ ] ❌ **No FR traceability to stories** (can't validate coverage)
+- [ ] ❌ **Template variables unfilled** (incomplete document)
+
+---
+
+## Validation Summary
+
+- **Pass Rate ≥ 95%:** ✅ EXCELLENT - Ready for architecture phase
+- **Pass Rate 85-94%:** ⚠️ GOOD - Minor fixes needed
+- **Pass Rate 70-84%:** ⚠️ FAIR - Important issues to address
+- **Pass Rate < 70%:** ❌ POOR - Significant rework required
+
+### Critical Issue Threshold
+
+- **0 Critical Failures:** Proceed to fixes
+- **1+ Critical Failures:** STOP - Must fix critical issues first
+
+---
+
+## Validation Execution Notes
+
+**When validating:**
+
+1. **Load ALL documents - whole or sharded (but not both of each) for example epics.md vs epics/\*.md:**
+   - PRD.md (required)
+   - epics.md (required)
+   - product-brief.md (if exists)
+   - domain-brief.md (if exists)
+   - research documents (if referenced)
+
+2. **Validate in order:**
+   - Check critical failures first (immediate stop if any found)
+   - Verify PRD completeness
+   - Verify epics completeness
+   - Cross-reference FR coverage (most important)
+   - Check sequencing (second most important)
+   - Validate research integration
+   - Check polish and quality
+
+3. **Report findings:**
+   - List critical failures prominently
+   - Group issues by severity
+   - Provide specific line numbers/sections
+   - Suggest concrete fixes
+   - Highlight what's working well
+
+4. **Provide actionable next steps:**
+   - If validation passes: "Ready for architecture workflow"
+   - If minor issues: "Fix [X] items then re-validate"
+   - If major issues: "Rework [sections] then re-validate"
+   - If critical failures: "Must fix critical items before proceeding"
+
+---
+
+**Remember:** This validation ensures the entire planning phase is complete and the implementation phase has everything needed to succeed. Be thorough but fair - the goal is quality, not perfection.

.bmad/bmm/workflows/2-plan-workflows/prd/domain-complexity.csv

@@ -0,0 +1,13 @@
+domain,signals,complexity,key_concerns,required_knowledge,suggested_workflow,web_searches,special_sections
+healthcare,"medical,diagnostic,clinical,FDA,patient,treatment,HIPAA,therapy,pharma,drug",high,"FDA approval;Clinical validation;HIPAA compliance;Patient safety;Medical device classification;Liability","Regulatory pathways;Clinical trial design;Medical standards;Data privacy;Integration requirements","domain-research","FDA software medical device guidance {date};HIPAA compliance software requirements;Medical software standards {date};Clinical validation software","clinical_requirements;regulatory_pathway;validation_methodology;safety_measures"
+fintech,"payment,banking,trading,investment,crypto,wallet,transaction,KYC,AML,funds,fintech",high,"Regional compliance;Security standards;Audit requirements;Fraud prevention;Data protection","KYC/AML requirements;PCI DSS;Open banking;Regional laws (US/EU/APAC);Crypto regulations","domain-research","fintech regulations {date};payment processing compliance {date};open banking API standards;cryptocurrency regulations {date}","compliance_matrix;security_architecture;audit_requirements;fraud_prevention"
+govtech,"government,federal,civic,public sector,citizen,municipal,voting",high,"Procurement rules;Security clearance;Accessibility (508);FedRAMP;Privacy;Transparency","Government procurement;Security frameworks;Accessibility standards;Privacy laws;Open data requirements","domain-research","government software procurement {date};FedRAMP compliance requirements;section 508 accessibility;government security standards","procurement_compliance;security_clearance;accessibility_standards;transparency_requirements"
+edtech,"education,learning,student,teacher,curriculum,assessment,K-12,university,LMS",medium,"Student privacy (COPPA/FERPA);Accessibility;Content moderation;Age verification;Curriculum standards","Educational privacy laws;Learning standards;Accessibility requirements;Content guidelines;Assessment validity","domain-research","educational software privacy {date};COPPA FERPA compliance;WCAG education requirements;learning management standards","privacy_compliance;content_guidelines;accessibility_features;curriculum_alignment"
+aerospace,"aircraft,spacecraft,aviation,drone,satellite,propulsion,flight,radar,navigation",high,"Safety certification;DO-178C compliance;Performance validation;Simulation accuracy;Export controls","Aviation standards;Safety analysis;Simulation validation;ITAR/export controls;Performance requirements","domain-research + technical-model","DO-178C software certification;aerospace simulation standards {date};ITAR export controls software;aviation safety requirements","safety_certification;simulation_validation;performance_requirements;export_compliance"
+automotive,"vehicle,car,autonomous,ADAS,automotive,driving,EV,charging",high,"Safety standards;ISO 26262;V2X communication;Real-time requirements;Certification","Automotive standards;Functional safety;V2X protocols;Real-time systems;Testing requirements","domain-research","ISO 26262 automotive software;automotive safety standards {date};V2X communication protocols;EV charging standards","safety_standards;functional_safety;communication_protocols;certification_requirements"
+scientific,"research,algorithm,simulation,modeling,computational,analysis,data science,ML,AI",medium,"Reproducibility;Validation methodology;Peer review;Performance;Accuracy;Computational resources","Scientific method;Statistical validity;Computational requirements;Domain expertise;Publication standards","technical-model","scientific computing best practices {date};research reproducibility standards;computational modeling validation;peer review software","validation_methodology;accuracy_metrics;reproducibility_plan;computational_requirements"
+legaltech,"legal,law,contract,compliance,litigation,patent,attorney,court",high,"Legal ethics;Bar regulations;Data retention;Attorney-client privilege;Court system integration","Legal practice rules;Ethics requirements;Court filing systems;Document standards;Confidentiality","domain-research","legal technology ethics {date};law practice management software requirements;court filing system standards;attorney client privilege technology","ethics_compliance;data_retention;confidentiality_measures;court_integration"
+insuretech,"insurance,claims,underwriting,actuarial,policy,risk,premium",high,"Insurance regulations;Actuarial standards;Data privacy;Fraud detection;State compliance","Insurance regulations by state;Actuarial methods;Risk modeling;Claims processing;Regulatory reporting","domain-research","insurance software regulations {date};actuarial standards software;insurance fraud detection;state insurance compliance","regulatory_requirements;risk_modeling;fraud_detection;reporting_compliance"
+energy,"energy,utility,grid,solar,wind,power,electricity,oil,gas",high,"Grid compliance;NERC standards;Environmental regulations;Safety requirements;Real-time operations","Energy regulations;Grid standards;Environmental compliance;Safety protocols;SCADA systems","domain-research","energy sector software compliance {date};NERC CIP standards;smart grid requirements;renewable energy software standards","grid_compliance;safety_protocols;environmental_compliance;operational_requirements"
+gaming,"game,player,gameplay,level,character,multiplayer,quest",redirect,"REDIRECT TO GAME WORKFLOWS","Game design","game-brief","NA","NA"
+general,"",low,"Standard requirements;Basic security;User experience;Performance","General software practices","continue","software development best practices {date}","standard_requirements"

.bmad/bmm/workflows/2-plan-workflows/prd/instructions.md

@@ -0,0 +1,703 @@
+# PRD Workflow - Intent-Driven Product Planning
+
+<critical>The workflow execution engine is governed by: {project-root}/.bmad/core/tasks/workflow.xml</critical>
+<critical>You MUST have already loaded and processed: {installed_path}/workflow.yaml</critical>
+<critical>This workflow uses INTENT-DRIVEN PLANNING - adapt organically to product type and context</critical>
+<critical>Communicate all responses in {communication_language} and adapt deeply to {user_skill_level}</critical>
+<critical>Generate all documents in {document_output_language}</critical>
+<critical>LIVING DOCUMENT: Write to PRD.md continuously as you discover - never wait until the end</critical>
+<critical>GUIDING PRINCIPLE: Identify what makes this product special and ensure it's reflected throughout the PRD</critical>
+<critical>Input documents specified in workflow.yaml input_file_patterns - workflow engine handles fuzzy matching, whole vs sharded document discovery automatically</critical>
+<critical>⚠️ ABSOLUTELY NO TIME ESTIMATES - NEVER mention hours, days, weeks, months, or ANY time-based predictions. AI has fundamentally changed development speed - what once took teams weeks/months can now be done by one person in hours. DO NOT give ANY time estimates whatsoever.</critical>
+<critical>⚠️ CHECKPOINT PROTOCOL: After EVERY <template-output> tag, you MUST follow workflow.xml substep 2c: SAVE content to file immediately → SHOW checkpoint separator (━━━━━━━━━━━━━━━━━━━━━━━) → DISPLAY generated content → PRESENT options [a]Advanced Elicitation/[c]Continue/[p]Party-Mode/[y]YOLO → WAIT for user response. Never batch saves or skip checkpoints.</critical>
+
+<workflow>
+
+<step n="0" goal="Validate workflow readiness" tag="workflow-status">
+<action>Check if {status_file} exists</action>
+
+<action if="status file not found">Set standalone_mode = true</action>
+
+<check if="status file found">
+  <action>Load the FULL file: {status_file}</action>
+  <action>Parse workflow_status section</action>
+  <action>Check status of "prd" workflow</action>
+  <action>Get project_track from YAML metadata</action>
+  <action>Find first non-completed workflow (next expected workflow)</action>
+
+  <check if="project_track is Quick Flow">
+    <output>**Quick Flow Track - Redirecting**
+
+Quick Flow projects use tech-spec workflow for implementation-focused planning.
+PRD is for BMad Method and Enterprise Method tracks that need comprehensive requirements.</output>
+<action>Exit and suggest tech-spec workflow</action>
+</check>
+
+  <check if="prd status is file path (already completed)">
+    <output>⚠️ PRD already completed: {{prd status}}</output>
+    <ask>Re-running will overwrite the existing PRD. Continue? (y/n)</ask>
+    <check if="n">
+      <output>Exiting. Use workflow-status to see your next step.</output>
+      <action>Exit workflow</action>
+    </check>
+  </check>
+
+<action>Set standalone_mode = false</action>
+</check>
+</step>
+
+<step n="0.5" goal="Discover and load input documents">
+<invoke-protocol name="discover_inputs" />
+<note>After discovery, these content variables are available: {product_brief_content}, {research_content}, {document_project_content}</note>
+</step>
+
+<step n="1" goal="Discovery - Project, Domain, and Vision">
+<action>Welcome {user_name} and begin comprehensive discovery, and then start to GATHER ALL CONTEXT:
+1. Check workflow-status.yaml for project_context (if exists)
+2. Review loaded content: {product_brief_content}, {research_content}, {document_project_content} (auto-loaded in Step 0.5)
+3. Detect project type AND domain complexity using data-driven classification
+</action>
+
+<action>Load classification data files COMPLETELY:
+
+- Load {project_types_data} - contains project type definitions, detection signals, and requirements
+- Load {domain_complexity_data} - contains domain classifications, complexity levels, and special requirements
+
+Parse CSV structure:
+
+- project_types_data has columns: project_type, detection_signals, key_questions, required_sections, skip_sections, web_search_triggers, innovation_signals
+- domain_complexity_data has columns: domain, signals, complexity, key_concerns, required_knowledge, suggested_workflow, web_searches, special_sections
+
+Store these in memory for use throughout the workflow.
+</action>
+
+<action>Begin natural discovery conversation:
+"Tell me about what you want to build - what problem does it solve and for whom?"
+
+As the user describes their product, listen for signals to classify:
+
+1. PROJECT TYPE classification
+2. DOMAIN classification
+   </action>
+
+<action>DUAL DETECTION - Use CSV data to match:
+
+**Project Type Detection:**
+
+- Compare user's description against detection_signals from each row in project_types_data
+- Look for keyword matches (semicolon-separated in CSV)
+- Identify best matching project_type (api_backend, mobile_app, saas_b2b, developer_tool, cli_tool, web_app, game, desktop_app, iot_embedded, blockchain_web3)
+- If multiple matches, ask clarifying question
+- Store matched project_type value
+
+**Domain Detection:**
+
+- Compare user's description against signals from each row in domain_complexity_data
+- Match domain keywords (semicolon-separated in CSV)
+- Identify domain (healthcare, fintech, govtech, edtech, aerospace, automotive, scientific, legaltech, insuretech, energy, gaming, general)
+- Get complexity level from matched row (high/medium/low/redirect)
+- Store matched domain and complexity_level values
+
+**Special Cases from CSV:**
+
+- If project_type = "game" → Use project_types_data row to get redirect message
+- If domain = "gaming" → Use domain_complexity_data redirect action
+- If complexity = "high" → Note suggested_workflow and web_searches from domain row
+  </action>
+
+<action>SPECIAL ROUTING based on detected values:
+
+**If game detected (from project_types_data):**
+"Game development requires the BMGD module (BMad Game Development) which has specialized workflows for game design."
+Exit workflow and redirect to BMGD.
+
+**If complex domain detected (complexity = "high" from domain_complexity_data):**
+Extract suggested_workflow and web_searches from the matched domain row.
+Offer domain research options:
+A) Run {suggested_workflow} workflow (thorough) - from CSV
+B) Quick web search using {web_searches} queries - from CSV
+C) User provides their own domain context
+D) Continue with general knowledge
+
+Present the options and WAIT for user choice.
+</action>
+
+<action>IDENTIFY WHAT MAKES IT SPECIAL early in conversation:
+Ask questions like:
+
+- "What excites you most about this product?"
+- "What would make users love this?"
+- "What's the unique value or compelling moment?"
+- "What makes this different from alternatives?"
+
+Capture this differentiator - it becomes a thread connecting throughout the PRD.
+</action>
+
+<template-output>vision_alignment</template-output>
+<template-output>project_classification</template-output>
+<template-output>project_type</template-output>
+<template-output>domain_type</template-output>
+<template-output>complexity_level</template-output>
+<check if="complexity_level == 'high'">
+<template-output>domain_context_summary</template-output>
+</check>
+<template-output>product_differentiator</template-output>
+<template-output>product_brief_path</template-output>
+<template-output>domain_brief_path</template-output>
+<template-output>research_documents</template-output>
+</step>
+
+<step n="2" goal="Success Definition">
+<action>Define what winning looks like for THIS specific product
+
+INTENT: Meaningful success criteria, not generic metrics
+
+Adapt to context:
+
+- Consumer: User love, engagement, retention
+- B2B: ROI, efficiency, adoption
+- Developer tools: Developer experience, community
+- Regulated: Compliance, safety, validation
+
+Make it specific:
+
+- NOT: "10,000 users"
+- BUT: "100 power users who rely on it daily"
+
+- NOT: "99.9% uptime"
+- BUT: "Zero data loss during critical operations"
+
+Connect to what makes the product special:
+
+- "Success means users experience [key value moment] and achieve [desired outcome]"</action>
+
+<template-output>success_criteria</template-output>
+<check if="business focus">
+<template-output>business_metrics</template-output>
+</check>
+</step>
+
+<step n="3" goal="Scope Definition">
+<action>Smart scope negotiation - find the sweet spot
+
+The Scoping Game:
+
+1. "What must work for this to be useful?" → MVP
+2. "What makes it competitive?" → Growth
+3. "What's the dream version?" → Vision
+
+Challenge scope creep conversationally:
+
+- "Could that wait until after launch?"
+- "Is that essential for proving the concept?"
+
+For complex domains:
+
+- Include compliance minimums in MVP
+- Note regulatory gates between phases</action>
+
+<template-output>mvp_scope</template-output>
+<template-output>growth_features</template-output>
+<template-output>vision_features</template-output>
+</step>
+
+<step n="4" goal="Domain-Specific Exploration" optional="true">
+<critical>This step is DATA-DRIVEN using domain_complexity_data CSV loaded in Step 1</critical>
+<action>Execute only if complexity_level = "high" OR domain-brief exists</action>
+
+<action>Retrieve domain-specific configuration from CSV:
+
+1. Find the row in {domain_complexity_data} where domain column matches the detected {domain} from Step 1
+2. Extract these columns from the matched row:
+   - key_concerns (semicolon-separated list)
+   - required_knowledge (describes what expertise is needed)
+   - web_searches (suggested search queries if research needed)
+   - special_sections (semicolon-separated list of domain-specific sections to document)
+3. Parse the semicolon-separated values into lists
+4. Store for use in this step
+   </action>
+
+<action>Explore domain-specific requirements using key_concerns from CSV:
+
+Parse key_concerns into individual concern areas.
+For each concern:
+
+- Ask the user about their approach to this concern
+- Discuss implications for the product
+- Document requirements, constraints, and compliance needs
+
+Example for healthcare domain:
+If key_concerns = "FDA approval;Clinical validation;HIPAA compliance;Patient safety;Medical device classification;Liability"
+Then explore:
+
+- "Will this product require FDA approval? What classification?"
+- "How will you validate clinical accuracy and safety?"
+- "What HIPAA compliance measures are needed?"
+- "What patient safety protocols must be in place?"
+- "What liability considerations affect the design?"
+
+Synthesize domain requirements that will shape everything:
+
+- Regulatory requirements (from key_concerns)
+- Compliance needs (from key_concerns)
+- Industry standards (from required_knowledge)
+- Safety/risk factors (from key_concerns)
+- Required validations (from key_concerns)
+- Special expertise needed (from required_knowledge)
+
+These inform:
+
+- What features are mandatory
+- What NFRs are critical
+- How to sequence development
+- What validation is required
+  </action>
+
+<check if="complexity_level == 'high'">
+  <template-output>domain_considerations</template-output>
+
+<action>Generate domain-specific special sections if defined:
+Parse special_sections list from the matched CSV row.
+For each section name, generate corresponding template-output.
+
+Example mappings from CSV:
+
+- "clinical_requirements" → <template-output>clinical_requirements</template-output>
+- "regulatory_pathway" → <template-output>regulatory_pathway</template-output>
+- "safety_measures" → <template-output>safety_measures</template-output>
+- "compliance_matrix" → <template-output>compliance_matrix</template-output>
+  </action>
+  </check>
+  </step>
+
+<step n="5" goal="Innovation Discovery" optional="true">
+<critical>This step uses innovation_signals from project_types_data CSV loaded in Step 1</critical>
+
+<action>Check for innovation in this product:
+
+1. Retrieve innovation_signals from the project_type row in {project_types_data}
+2. Parse the semicolon-separated innovation signals specific to this project type
+3. Listen for these signals in user's description and throughout conversation
+
+Example for api_backend:
+innovation_signals = "API composition;New protocol"
+
+Example for mobile_app:
+innovation_signals = "Gesture innovation;AR/VR features"
+
+Example for saas_b2b:
+innovation_signals = "Workflow automation;AI agents"
+</action>
+
+<action>Listen for general innovation signals in conversation:
+
+User language indicators:
+
+- "Nothing like this exists"
+- "We're rethinking how [X] works"
+- "Combining [A] with [B] for the first time"
+- "Novel approach to [problem]"
+- "No one has done [concept] before"
+
+Project-type-specific signals (from CSV innovation_signals column):
+
+- Match user's descriptions against the innovation_signals for their project_type
+- If matches found, flag as innovation opportunity
+  </action>
+
+<action>If innovation detected (general OR project-type-specific):
+
+Explore deeply:
+
+- What makes it unique?
+- What assumption are you challenging?
+- How do we validate it works?
+- What's the fallback if it doesn't?
+- Has anyone tried this before?
+
+Use web_search_triggers from project_types_data CSV if relevant:
+<WebSearch if="novel">{web_search_triggers} {concept} innovations {date}</WebSearch>
+</action>
+
+<check if="innovation detected">
+  <template-output>innovation_patterns</template-output>
+  <template-output>validation_approach</template-output>
+</check>
+</step>
+
+<step n="6" goal="Project-Specific Deep Dive">
+<critical>This step is DATA-DRIVEN using project_types_data CSV loaded in Step 1</critical>
+
+<action>Retrieve project-specific configuration from CSV:
+
+1. Find the row in {project_types_data} where project_type column matches the detected {project_type} from Step 1
+2. Extract these columns from the matched row:
+   - key_questions (semicolon-separated list)
+   - required_sections (semicolon-separated list)
+   - skip_sections (semicolon-separated list)
+   - innovation_signals (semicolon-separated list)
+3. Parse the semicolon-separated values into lists
+4. Store for use in this step
+   </action>
+
+<action>Conduct guided discovery using key_questions from CSV:
+
+Parse key_questions into individual questions.
+For each question:
+
+- Ask the user naturally in conversational style
+- Listen for their response
+- Ask clarifying follow-ups as needed
+- Connect answers to product value proposition
+
+Example flow:
+If key_questions = "Endpoints needed?;Authentication method?;Data formats?"
+Then ask:
+
+- "What are the main endpoints your API needs to expose?"
+- "How will you handle authentication and authorization?"
+- "What data formats will you support for requests and responses?"
+
+Adapt questions to the user's context and skill level.
+</action>
+
+<action>Document project-type-specific requirements:
+
+Based on the user's answers to key_questions, synthesize comprehensive requirements for this project type.
+
+Cover the areas indicated by required_sections from CSV (semicolon-separated list).
+Skip areas indicated by skip_sections from CSV.
+
+For each required section:
+
+- Summarize what was discovered
+- Document specific requirements, constraints, and decisions
+- Connect to product differentiator when relevant
+
+Always connect requirements to product value:
+"How does [requirement] support the product's core value proposition?"
+</action>
+
+<template-output>project_type_requirements</template-output>
+
+<!-- Dynamic template outputs based on required_sections from CSV -->
+
+<action>Generate dynamic template outputs based on required_sections:
+
+Parse required_sections list from the matched CSV row.
+For each section name in the list, generate a corresponding template-output.
+
+Common mappings (adapt based on actual CSV values):
+
+- "endpoint_specs" or "endpoint_specification" → <template-output>endpoint_specification</template-output>
+- "auth_model" or "authentication_model" → <template-output>authentication_model</template-output>
+- "platform_reqs" or "platform_requirements" → <template-output>platform_requirements</template-output>
+- "device_permissions" or "device_features" → <template-output>device_features</template-output>
+- "tenant_model" → <template-output>tenant_model</template-output>
+- "rbac_matrix" or "permission_matrix" → <template-output>permission_matrix</template-output>
+
+Generate all outputs dynamically - do not hardcode specific project types.
+</action>
+
+<note>Example CSV row for api_backend:
+key_questions = "Endpoints needed?;Authentication method?;Data formats?;Rate limits?;Versioning?;SDK needed?"
+required_sections = "endpoint_specs;auth_model;data_schemas;error_codes;rate_limits;api_docs"
+skip_sections = "ux_ui;visual_design;user_journeys"
+
+The LLM should parse these and generate corresponding template outputs dynamically.
+
+**Template Variable Strategy:**
+The prd-template.md has common template variables defined (endpoint_specification, authentication_model, platform_requirements, device_features, tenant_model, permission_matrix).
+
+For required_sections that match these common variables:
+
+- Generate the specific template-output (e.g., endpoint_specs → endpoint_specification)
+- These will render in their own subsections in the template
+
+For required_sections that DON'T have matching template variables:
+
+- Include the content in the main project_type_requirements variable
+- This ensures all requirements are captured even if template doesn't have dedicated sections
+
+This hybrid approach balances template structure with CSV-driven flexibility.
+</note>
+</step>
+
+<step n="7" goal="UX Principles" if="project has UI or UX">
+  <action>Only if product has a UI
+
+Light touch on UX - not full design:
+
+- Visual personality
+- Key interaction patterns
+- Critical user flows
+
+"How should this feel to use?"
+"What's the vibe - professional, playful, minimal?"
+
+Connect UX to product vision:
+"The UI should reinforce [core value proposition] through [design approach]"</action>
+
+  <check if="has UI">
+    <template-output>ux_principles</template-output>
+    <template-output>key_interactions</template-output>
+  </check>
+</step>
+
+<step n="8" goal="Functional Requirements Synthesis">
+<critical>This section is THE CAPABILITY CONTRACT for all downstream work</critical>
+<critical>UX designers will ONLY design what's listed here</critical>
+<critical>Architects will ONLY support what's listed here</critical>
+<critical>Epic breakdown will ONLY implement what's listed here</critical>
+<critical>If a capability is missing from FRs, it will NOT exist in the final product</critical>
+
+<action>Before writing FRs, understand their PURPOSE and USAGE:
+
+**Purpose:**
+FRs define WHAT capabilities the product must have. They are the complete inventory
+of user-facing and system capabilities that deliver the product vision.
+
+**How They Will Be Used:**
+
+1. UX Designer reads FRs → designs interactions for each capability
+2. Architect reads FRs → designs systems to support each capability
+3. PM reads FRs → creates epics and stories to implement each capability
+4. Dev Agent reads assembled context → implements stories based on FRs
+
+**Critical Property - COMPLETENESS:**
+Every capability discussed in vision, scope, domain requirements, and project-specific
+sections MUST be represented as an FR. Missing FRs = missing capabilities.
+
+**Critical Property - ALTITUDE:**
+FRs state WHAT capability exists and WHO it serves, NOT HOW it's implemented or
+specific UI/UX details. Those come later from UX and Architecture.
+</action>
+
+<action>Transform everything discovered into comprehensive functional requirements:
+
+**Coverage - Pull from EVERYWHERE:**
+
+- Core features from MVP scope → FRs
+- Growth features → FRs (marked as post-MVP if needed)
+- Domain-mandated features → FRs
+- Project-type specific needs → FRs
+- Innovation requirements → FRs
+- Anti-patterns (explicitly NOT doing) → Note in FR section if needed
+
+**Organization - Group by CAPABILITY AREA:**
+Don't organize by technology or layer. Group by what users/system can DO:
+
+- ✅ "User Management" (not "Authentication System")
+- ✅ "Content Discovery" (not "Search Algorithm")
+- ✅ "Team Collaboration" (not "WebSocket Infrastructure")
+
+**Format - Flat, Numbered List:**
+Each FR is one clear capability statement:
+
+- FR#: [Actor] can [capability] [context/constraint if needed]
+- Number sequentially (FR1, FR2, FR3...)
+- Aim for 20-50 FRs for typical projects (fewer for simple, more for complex)
+
+**Altitude Check:**
+Each FR should answer "WHAT capability exists?" NOT "HOW is it implemented?"
+
+- ✅ "Users can customize appearance settings"
+- ❌ "Users can toggle light/dark theme with 3 font size options stored in LocalStorage"
+
+The second example belongs in Epic Breakdown, not PRD.
+</action>
+
+<example>
+**Well-written FRs at the correct altitude:**
+
+**User Account & Access:**
+
+- FR1: Users can create accounts with email or social authentication
+- FR2: Users can log in securely and maintain sessions across devices
+- FR3: Users can reset passwords via email verification
+- FR4: Users can update profile information and preferences
+- FR5: Administrators can manage user roles and permissions
+
+**Content Management:**
+
+- FR6: Users can create, edit, and delete content items
+- FR7: Users can organize content with tags and categories
+- FR8: Users can search content by keyword, tag, or date range
+- FR9: Users can export content in multiple formats
+
+**Data Ownership (local-first products):**
+
+- FR10: All user data stored locally on user's device
+- FR11: Users can export complete data at any time
+- FR12: Users can import previously exported data
+- FR13: System monitors storage usage and warns before limits
+
+**Collaboration:**
+
+- FR14: Users can share content with specific users or teams
+- FR15: Users can comment on shared content
+- FR16: Users can track content change history
+- FR17: Users receive notifications for relevant updates
+
+**Notice:**
+✅ Each FR is a testable capability
+✅ Each FR is implementation-agnostic (could be built many ways)
+✅ Each FR specifies WHO and WHAT, not HOW
+✅ No UI details, no performance numbers, no technology choices
+✅ Comprehensive coverage of capability areas
+</example>
+
+<action>Generate the complete FR list by systematically extracting capabilities:
+
+1. MVP scope → extract all capabilities → write as FRs
+2. Growth features → extract capabilities → write as FRs (note if post-MVP)
+3. Domain requirements → extract mandatory capabilities → write as FRs
+4. Project-type specifics → extract type-specific capabilities → write as FRs
+5. Innovation patterns → extract novel capabilities → write as FRs
+
+Organize FRs by logical capability groups (5-8 groups typically).
+Number sequentially across all groups (FR1, FR2... FR47).
+</action>
+
+<action>SELF-VALIDATION - Before finalizing, ask yourself:
+
+**Completeness Check:**
+
+1. "Did I cover EVERY capability mentioned in the MVP scope section?"
+2. "Did I include domain-specific requirements as FRs?"
+3. "Did I cover the project-type specific needs (API/Mobile/SaaS/etc)?"
+4. "Could a UX designer read ONLY the FRs and know what to design?"
+5. "Could an Architect read ONLY the FRs and know what to support?"
+6. "Are there any user actions or system behaviors we discussed that have no FR?"
+
+**Altitude Check:**
+
+1. "Am I stating capabilities (WHAT) or implementation (HOW)?"
+2. "Am I listing acceptance criteria or UI specifics?" (Remove if yes)
+3. "Could this FR be implemented 5 different ways?" (Good - means it's not prescriptive)
+
+**Quality Check:**
+
+1. "Is each FR clear enough that someone could test whether it exists?"
+2. "Is each FR independent (not dependent on reading other FRs to understand)?"
+3. "Did I avoid vague terms like 'good', 'fast', 'easy'?" (Use NFRs for quality attributes)
+
+COMPLETENESS GATE: Review your FR list against the entire PRD written so far and think hard - did you miss anything? Add it now before proceeding.
+</action>
+
+<template-output>functional_requirements_complete</template-output>
+</step>
+
+<step n="9" goal="Non-Functional Requirements Discovery">
+<action>Only document NFRs that matter for THIS product
+
+Performance: Only if user-facing impact
+Security: Only if handling sensitive data
+Scale: Only if growth expected
+Accessibility: Only if broad audience
+Integration: Only if connecting systems
+
+For each NFR:
+
+- Why it matters for THIS product
+- Specific measurable criteria
+- Domain-driven requirements
+
+Skip categories that don't apply!</action>
+
+<!-- Only output sections that were discussed -->
+<check if="performance matters">
+  <template-output>performance_requirements</template-output>
+</check>
+<check if="security matters">
+  <template-output>security_requirements</template-output>
+</check>
+<check if="scale matters">
+  <template-output>scalability_requirements</template-output>
+</check>
+<check if="accessibility matters">
+  <template-output>accessibility_requirements</template-output>
+</check>
+<check if="integration matters">
+  <template-output>integration_requirements</template-output>
+</check>
+</step>
+
+<step n="10" goal="Complete PRD and determine next steps">
+<action>Quick review of captured requirements:
+
+"We've captured:
+
+- {{fr_count}} functional requirements
+- {{nfr_count}} non-functional requirements
+- MVP scope defined
+  {{if domain_complexity == 'high'}}
+- Domain-specific requirements addressed
+  {{/if}}
+  {{if innovation_detected}}
+- Innovation patterns documented
+  {{/if}}
+
+Your PRD is complete!"
+</action>
+
+<template-output>prd_summary</template-output>
+<template-output>product_value_summary</template-output>
+
+<check if="standalone_mode != true">
+  <action>Load the FULL file: {status_file}</action>
+  <action>Update workflow_status["prd"] = "{default_output_file}"</action>
+  <action>Save file, preserving ALL comments and structure</action>
+
+<action>Check workflow path to determine next expected workflows:
+
+- Look for "create-epics-and-stories" as optional after PRD
+- Look for "create-design" as conditional (if_has_ui)
+- Look for "create-epics-and-stories-after-ux" as optional
+- Identify the required next phase workflow
+  </action>
+  </check>
+
+<output>**✅ PRD Complete, {user_name}!**
+
+**Created:** PRD.md with {{fr_count}} FRs and NFRs
+
+**Next Steps:**
+
+<check if="standalone_mode != true">
+Based on your {{project_track}} workflow path, you can:
+
+**Option A: Create Epic Breakdown Now** (Optional)
+`workflow create-epics-and-stories`
+
+- Creates basic epic structure from PRD
+- Can be enhanced later with UX/Architecture context
+
+<check if="UI_exists">
+**Option B: UX Design First** (Recommended if UI)
+   `workflow create-design`
+   - Design user experience and interactions
+   - Epic breakdown can incorporate UX details later
+</check>
+
+**Option C: Skip to Architecture**
+`workflow create-architecture`
+
+- Define technical decisions
+- Epic breakdown created after with full context
+
+**Recommendation:** {{if UI_exists}}Do UX Design first, then Architecture, then create epics with full context{{else}}Go straight to Architecture, then create epics{{/if}}
+</check>
+
+<check if="standalone_mode == true">
+**Typical next workflows:**
+1. `workflow create-design` - UX Design (if UI exists)
+2. `workflow create-architecture` - Technical architecture
+3. `workflow create-epics-and-stories` - Epic breakdown
+
+**Note:** Epics can be created at any point but have richer detail when created after UX/Architecture.
+</check>
+</output>
+</step>
+
+</workflow>

.bmad/bmm/workflows/2-plan-workflows/prd/prd-template.md

@@ -0,0 +1,204 @@
+# {{project_name}} - Product Requirements Document
+
+**Author:** {{user_name}}
+**Date:** {{date}}
+**Version:** 1.0
+
+---
+
+## Executive Summary
+
+{{vision_alignment}}
+
+### What Makes This Special
+
+{{product_differentiator}}
+
+---
+
+## Project Classification
+
+**Technical Type:** {{project_type}}
+**Domain:** {{domain_type}}
+**Complexity:** {{complexity_level}}
+
+{{project_classification}}
+
+{{#if domain_context_summary}}
+
+### Domain Context
+
+{{domain_context_summary}}
+{{/if}}
+
+---
+
+## Success Criteria
+
+{{success_criteria}}
+
+{{#if business_metrics}}
+
+### Business Metrics
+
+{{business_metrics}}
+{{/if}}
+
+---
+
+## Product Scope
+
+### MVP - Minimum Viable Product
+
+{{mvp_scope}}
+
+### Growth Features (Post-MVP)
+
+{{growth_features}}
+
+### Vision (Future)
+
+{{vision_features}}
+
+---
+
+{{#if domain_considerations}}
+
+## Domain-Specific Requirements
+
+{{domain_considerations}}
+
+This section shapes all functional and non-functional requirements below.
+{{/if}}
+
+---
+
+{{#if innovation_patterns}}
+
+## Innovation & Novel Patterns
+
+{{innovation_patterns}}
+
+### Validation Approach
+
+{{validation_approach}}
+{{/if}}
+
+---
+
+{{#if project_type_requirements}}
+
+## {{project_type}} Specific Requirements
+
+{{project_type_requirements}}
+
+{{#if endpoint_specification}}
+
+### API Specification
+
+{{endpoint_specification}}
+{{/if}}
+
+{{#if authentication_model}}
+
+### Authentication & Authorization
+
+{{authentication_model}}
+{{/if}}
+
+{{#if platform_requirements}}
+
+### Platform Support
+
+{{platform_requirements}}
+{{/if}}
+
+{{#if device_features}}
+
+### Device Capabilities
+
+{{device_features}}
+{{/if}}
+
+{{#if tenant_model}}
+
+### Multi-Tenancy Architecture
+
+{{tenant_model}}
+{{/if}}
+
+{{#if permission_matrix}}
+
+### Permissions & Roles
+
+{{permission_matrix}}
+{{/if}}
+{{/if}}
+
+---
+
+{{#if ux_principles}}
+
+## User Experience Principles
+
+{{ux_principles}}
+
+### Key Interactions
+
+{{key_interactions}}
+{{/if}}
+
+---
+
+## Functional Requirements
+
+{{functional_requirements_complete}}
+
+---
+
+## Non-Functional Requirements
+
+{{#if performance_requirements}}
+
+### Performance
+
+{{performance_requirements}}
+{{/if}}
+
+{{#if security_requirements}}
+
+### Security
+
+{{security_requirements}}
+{{/if}}
+
+{{#if scalability_requirements}}
+
+### Scalability
+
+{{scalability_requirements}}
+{{/if}}
+
+{{#if accessibility_requirements}}
+
+### Accessibility
+
+{{accessibility_requirements}}
+{{/if}}
+
+{{#if integration_requirements}}
+
+### Integration
+
+{{integration_requirements}}
+{{/if}}
+
+{{#if no_nfrs}}
+_No specific non-functional requirements identified for this project type._
+{{/if}}
+
+---
+
+_This PRD captures the essence of {{project_name}} - {{product_value_summary}}_
+
+_Created through collaborative discovery between {{user_name}} and AI facilitator._

.bmad/bmm/workflows/2-plan-workflows/prd/project-types.csv

@@ -0,0 +1,11 @@
+project_type,detection_signals,key_questions,required_sections,skip_sections,web_search_triggers,innovation_signals
+api_backend,"API,REST,GraphQL,backend,service,endpoints","Endpoints needed?;Authentication method?;Data formats?;Rate limits?;Versioning?;SDK needed?","endpoint_specs;auth_model;data_schemas;error_codes;rate_limits;api_docs","ux_ui;visual_design;user_journeys","framework best practices;OpenAPI standards","API composition;New protocol"
+mobile_app,"iOS,Android,app,mobile,iPhone,iPad","Native or cross-platform?;Offline needed?;Push notifications?;Device features?;Store compliance?","platform_reqs;device_permissions;offline_mode;push_strategy;store_compliance","desktop_features;cli_commands","app store guidelines;platform requirements","Gesture innovation;AR/VR features"
+saas_b2b,"SaaS,B2B,platform,dashboard,teams,enterprise","Multi-tenant?;Permission model?;Subscription tiers?;Integrations?;Compliance?","tenant_model;rbac_matrix;subscription_tiers;integration_list;compliance_reqs","cli_interface;mobile_first","compliance requirements;integration guides","Workflow automation;AI agents"
+developer_tool,"SDK,library,package,npm,pip,framework","Language support?;Package managers?;IDE integration?;Documentation?;Examples?","language_matrix;installation_methods;api_surface;code_examples;migration_guide","visual_design;store_compliance","package manager best practices;API design patterns","New paradigm;DSL creation"
+cli_tool,"CLI,command,terminal,bash,script","Interactive or scriptable?;Output formats?;Config method?;Shell completion?","command_structure;output_formats;config_schema;scripting_support","visual_design;ux_principles;touch_interactions","CLI design patterns;shell integration","Natural language CLI;AI commands"
+web_app,"website,webapp,browser,SPA,PWA","SPA or MPA?;Browser support?;SEO needed?;Real-time?;Accessibility?","browser_matrix;responsive_design;performance_targets;seo_strategy;accessibility_level","native_features;cli_commands","web standards;WCAG guidelines","New interaction;WebAssembly use"
+game,"game,player,gameplay,level,character","REDIRECT TO USE THE BMad Method Game Module Agent and Workflows - HALT","game-brief;GDD","most_sections","game design patterns","Novel mechanics;Genre mixing"
+desktop_app,"desktop,Windows,Mac,Linux,native","Cross-platform?;Auto-update?;System integration?;Offline?","platform_support;system_integration;update_strategy;offline_capabilities","web_seo;mobile_features","desktop guidelines;platform requirements","Desktop AI;System automation"
+iot_embedded,"IoT,embedded,device,sensor,hardware","Hardware specs?;Connectivity?;Power constraints?;Security?;OTA updates?","hardware_reqs;connectivity_protocol;power_profile;security_model;update_mechanism","visual_ui;browser_support","IoT standards;protocol specs","Edge AI;New sensors"
+blockchain_web3,"blockchain,crypto,DeFi,NFT,smart contract","Chain selection?;Wallet integration?;Gas optimization?;Security audit?","chain_specs;wallet_support;smart_contracts;security_audit;gas_optimization","traditional_auth;centralized_db","blockchain standards;security patterns","Novel tokenomics;DAO structure"

.bmad/bmm/workflows/2-plan-workflows/prd/workflow.yaml

@@ -0,0 +1,52 @@
+# Product Requirements Document (PRD) Workflow
+name: prd
+description: "Unified PRD workflow for BMad Method and Enterprise Method tracks. Produces strategic PRD and tactical epic breakdown. Hands off to architecture workflow for technical design. Note: Quick Flow track uses tech-spec workflow."
+author: "BMad"
+
+# Critical variables from config
+config_source: "{project-root}/.bmad/bmm/config.yaml"
+project_name: "{config_source}:project_name"
+output_folder: "{config_source}:output_folder"
+user_name: "{config_source}:user_name"
+communication_language: "{config_source}:communication_language"
+document_output_language: "{config_source}:document_output_language"
+user_skill_level: "{config_source}:user_skill_level"
+date: system-generated
+
+# Workflow components
+installed_path: "{project-root}/.bmad/bmm/workflows/2-plan-workflows/prd"
+instructions: "{installed_path}/instructions.md"
+
+# Templates
+prd_template: "{installed_path}/prd-template.md"
+
+# Data files for data-driven behavior
+project_types_data: "{installed_path}/project-types.csv"
+domain_complexity_data: "{installed_path}/domain-complexity.csv"
+
+# Output files
+status_file: "{output_folder}/bmm-workflow-status.yaml"
+default_output_file: "{output_folder}/prd.md"
+
+# Smart input file references - handles both whole docs and sharded docs
+# Priority: Whole document first, then sharded version
+# Strategy: How to load sharded documents (FULL_LOAD, SELECTIVE_LOAD, INDEX_GUIDED)
+input_file_patterns:
+  product_brief:
+    description: "Product vision and goals (optional)"
+    whole: "{output_folder}/*brief*.md"
+    sharded: "{output_folder}/*brief*/index.md"
+    load_strategy: "FULL_LOAD"
+
+  research:
+    description: "Market or domain research (optional)"
+    whole: "{output_folder}/*research*.md"
+    sharded: "{output_folder}/*research*/index.md"
+    load_strategy: "FULL_LOAD"
+
+  document_project:
+    description: "Brownfield project documentation (optional)"
+    sharded: "{output_folder}/index.md"
+    load_strategy: "INDEX_GUIDED"
+
+standalone: true