From e39aa33eea15ec3c9c7c6776fa9d4b8e8971501b Mon Sep 17 00:00:00 2001 From: sjennings Date: Thu, 18 Dec 2025 02:14:18 -0600 Subject: [PATCH 1/5] fix(bmgd): add workflow status update to game-architecture completion (#1161) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(bmgd): add workflow status update to game-architecture completion The game-architecture workflow was not updating the bmgd-workflow-status.yaml file on completion, unlike other BMGD workflows (narrative, brainstorm-game). Changes: - Add step 4 "Update Workflow Status" to update create-architecture status - Renumber subsequent steps (5-8 → 6-9) - Add success metric for workflow status update - Add failure condition for missing status update * feat(bmgd): add generate-project-context workflow for game development Adds a new workflow to create optimized project-context.md files for AI agent consistency in game development projects. New workflow files: - workflow.md: Main workflow entry point - project-context-template.md: Template for context file - steps/step-01-discover.md: Context discovery & initialization - steps/step-02-generate.md: Rules generation with A/P/C menus - steps/step-03-complete.md: Finalization & optimization Integration: - Added generate-project-context trigger to game-architect agent menu - Added project context creation option to game-architecture completion step - Renumbered steps 6-9 → 7-10 to accommodate new step 6 Adapted from BMM generate-project-context with game-specific: - Engine patterns (Unity, Unreal, Godot) - Performance and frame budget rules - Platform-specific requirements - Game testing patterns --------- Co-authored-by: Scott Jennings Co-authored-by: Brian --- .../bmgd/agents/game-architect.agent.yaml | 4 + .../steps/step-09-complete.md | 66 +++- .../project-context-template.md | 20 + .../steps/step-01-discover.md | 201 ++++++++++ .../steps/step-02-generate.md | 373 ++++++++++++++++++ .../steps/step-03-complete.md | 279 +++++++++++++ .../generate-project-context/workflow.md | 48 +++ 7 files changed, 985 insertions(+), 6 deletions(-) create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/project-context-template.md create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-01-discover.md create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-02-generate.md create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-03-complete.md create mode 100644 src/modules/bmgd/workflows/3-technical/generate-project-context/workflow.md diff --git a/src/modules/bmgd/agents/game-architect.agent.yaml b/src/modules/bmgd/agents/game-architect.agent.yaml index 8e218901..3b28024d 100644 --- a/src/modules/bmgd/agents/game-architect.agent.yaml +++ b/src/modules/bmgd/agents/game-architect.agent.yaml @@ -33,6 +33,10 @@ agent: exec: "{project-root}/_bmad/bmgd/workflows/3-technical/game-architecture/workflow.md" description: Produce a Scale Adaptive Game Architecture + - trigger: generate-project-context + exec: "{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context/workflow.md" + description: Create optimized project-context.md for AI agent consistency + - trigger: correct-course workflow: "{project-root}/_bmad/bmgd/workflows/4-production/correct-course/workflow.yaml" description: Course Correction Analysis (when implementation is off-track) diff --git a/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-09-complete.md b/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-09-complete.md index 7e71161e..51f022e3 100644 --- a/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-09-complete.md +++ b/src/modules/bmgd/workflows/3-technical/game-architecture/steps/step-09-complete.md @@ -12,6 +12,7 @@ outputFile: '{output_folder}/game-architecture.md' # Handoff References epicWorkflow: '{project-root}/_bmad/bmgd/workflows/4-production/epic-workflow/workflow.yaml' +projectContextWorkflow: '{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context/workflow.md' --- # Step 9: Completion @@ -131,7 +132,17 @@ platform: '{{platform}}' --- ```` -### 4. Present Completion Summary +### 4. Update Workflow Status + +**If not in standalone mode:** + +Load `{output_folder}/bmgd-workflow-status.yaml` and: + +- Update `create-architecture` status to the output file path +- Preserve all comments and structure +- Determine next workflow in sequence + +### 5. Present Completion Summary "**Architecture Complete!** @@ -158,9 +169,50 @@ platform: '{{platform}}' **Document saved to:** `{outputFile}` -Do you want to review or adjust anything before we finalize?" +Do you want to review or adjust anything before we finalize? -### 5. Handle Review Requests +**Optional Enhancement: Project Context File** + +Would you like to create a `project-context.md` file? This is a concise, optimized guide for AI agents that captures: + +- Critical engine-specific rules they might miss +- Specific patterns and conventions for your game project +- Performance and optimization requirements +- Anti-patterns and edge cases to avoid + +{if_existing_project_context} +I noticed you already have a project context file. Would you like to update it with your new architectural decisions? +{else} +This file helps ensure AI agents implement game code consistently with your project's unique requirements and patterns. +{/if_existing_project_context} + +**Create/Update project context?** [Y/N]" + +### 6. Handle Project Context Creation Choice + +If user responds 'Y' or 'yes' to creating/updating project context: + +"Excellent choice! Let me launch the Generate Project Context workflow to create a comprehensive guide for AI agents. + +This will help ensure consistent implementation by capturing: + +- Engine-specific patterns and rules +- Performance and optimization conventions from your architecture +- Testing and quality standards +- Anti-patterns to avoid + +The workflow will collaborate with you to create an optimized `project-context.md` file that AI agents will read before implementing any game code." + +**Execute the Generate Project Context workflow:** + +- Load and execute: `{projectContextWorkflow}` +- The workflow will handle discovery, generation, and completion of the project context file +- After completion, return here for final handoff + +If user responds 'N' or 'no': +"Understood! Your architecture is complete and ready for implementation. You can always create a project context file later using the Generate Project Context workflow if needed." + +### 7. Handle Review Requests **If user wants to review:** @@ -179,7 +231,7 @@ Or type 'all' to see the complete document." **Show requested section and allow edits.** -### 6. Present Next Steps Menu +### 8. Present Next Steps Menu **After user confirms completion:** @@ -204,7 +256,7 @@ Or type 'all' to see the complete document." 2. Proceed to Epic creation workflow 3. Exit workflow" -### 7. Handle User Selection +### 9. Handle User Selection Based on user choice: @@ -224,7 +276,7 @@ Based on user choice: - Confirm document is saved and complete - Exit workflow gracefully -### 8. Provide Handoff Guidance +### 10. Provide Handoff Guidance **For Epic Creation handoff:** @@ -270,6 +322,7 @@ This is the final step. Ensure: - Development setup is complete - Document status updated to 'complete' - Frontmatter shows all steps completed +- Workflow status updated (if tracking) - User has clear next steps - Document saved and ready for AI agent consumption @@ -278,6 +331,7 @@ This is the final step. Ensure: - Missing executive summary - Incomplete development setup - Frontmatter not updated +- Status not updated when tracking - No clear next steps provided - User left without actionable guidance diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/project-context-template.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/project-context-template.md new file mode 100644 index 00000000..b9e4d3bc --- /dev/null +++ b/src/modules/bmgd/workflows/3-technical/generate-project-context/project-context-template.md @@ -0,0 +1,20 @@ +--- +project_name: '{{project_name}}' +user_name: '{{user_name}}' +date: '{{date}}' +sections_completed: [] +--- + +# Project Context for AI Agents + +_This file contains critical rules and patterns that AI agents must follow when implementing game code in this project. Focus on unobvious details that agents might otherwise miss._ + +--- + +## Technology Stack & Versions + +_Documented after discovery phase_ + +## Critical Implementation Rules + +_Documented after discovery phase_ diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-01-discover.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-01-discover.md new file mode 100644 index 00000000..a92db901 --- /dev/null +++ b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-01-discover.md @@ -0,0 +1,201 @@ +# Step 1: Context Discovery & Initialization + +## MANDATORY EXECUTION RULES (READ FIRST): + +- NEVER generate content without user input +- ALWAYS treat this as collaborative discovery between technical peers +- YOU ARE A FACILITATOR, not a content generator +- FOCUS on discovering existing project context and technology stack +- IDENTIFY critical implementation rules that AI agents need +- ABSOLUTELY NO TIME ESTIMATES + +## EXECUTION PROTOCOLS: + +- Show your analysis before taking any action +- Read existing project files to understand current context +- Initialize document and update frontmatter +- FORBIDDEN to load next step until discovery is complete + +## CONTEXT BOUNDARIES: + +- Variables from workflow.md are available in memory +- Focus on existing project files and architecture decisions +- Look for patterns, conventions, and unique requirements +- Prioritize rules that prevent implementation mistakes + +## YOUR TASK: + +Discover the project's game engine, technology stack, existing patterns, and critical implementation rules that AI agents must follow when writing game code. + +## DISCOVERY SEQUENCE: + +### 1. Check for Existing Project Context + +First, check if project context already exists: + +- Look for file at `{output_folder}/project-context.md` +- If exists: Read complete file to understand existing rules +- Present to user: "Found existing project context with {number_of_sections} sections. Would you like to update this or create a new one?" + +### 2. Discover Game Engine & Technology Stack + +Load and analyze project files to identify technologies: + +**Architecture Document:** + +- Look for `{output_folder}/game-architecture.md` or `{output_folder}/architecture.md` +- Extract engine choice with specific version (Unity, Unreal, Godot, custom) +- Note architectural decisions that affect implementation + +**Engine-Specific Files:** + +- Unity: Check for `ProjectSettings/ProjectVersion.txt`, `Packages/manifest.json` +- Unreal: Check for `.uproject` files, `Config/DefaultEngine.ini` +- Godot: Check for `project.godot`, `export_presets.cfg` +- Custom: Check for engine config files, build scripts + +**Package/Dependency Files:** + +- Unity: `Packages/manifest.json`, NuGet packages +- Unreal: `.Build.cs` files, plugin configs +- Godot: `addons/` directory, GDExtension configs +- Web-based: `package.json`, `requirements.txt` + +**Configuration Files:** + +- Build tool configs +- Linting and formatting configs +- Testing configurations +- CI/CD pipeline configs + +### 3. Identify Existing Code Patterns + +Search through existing codebase for patterns: + +**Naming Conventions:** + +- Script/class naming patterns +- Asset naming conventions +- Scene/level naming patterns +- Test file naming patterns + +**Code Organization:** + +- How components/scripts are structured +- Where utilities and helpers are placed +- How systems are organized +- Folder hierarchy patterns + +**Engine-Specific Patterns:** + +- Unity: MonoBehaviour patterns, ScriptableObject usage, serialization rules +- Unreal: Actor/Component patterns, Blueprint integration, UE macros +- Godot: Node patterns, signal usage, autoload patterns + +### 4. Extract Critical Implementation Rules + +Look for rules that AI agents might miss: + +**Engine-Specific Rules:** + +- Unity: Assembly definitions, Unity lifecycle methods, coroutine patterns +- Unreal: UPROPERTY/UFUNCTION usage, garbage collection rules, tick patterns +- Godot: `_ready` vs `_enter_tree`, node ownership, scene instancing + +**Performance Rules:** + +- Frame budget constraints +- Memory allocation patterns +- Hot path optimization requirements +- Object pooling patterns + +**Platform-Specific Rules:** + +- Target platform constraints +- Input handling conventions +- Platform-specific code patterns +- Build configuration rules + +**Testing Rules:** + +- Test structure requirements +- Mock usage conventions +- Integration vs unit test boundaries +- Play mode vs edit mode testing + +### 5. Initialize Project Context Document + +Based on discovery, create or update the context document: + +#### A. Fresh Document Setup (if no existing context) + +Copy template from `{installed_path}/project-context-template.md` to `{output_folder}/project-context.md` +Initialize frontmatter with: + +```yaml +--- +project_name: '{{project_name}}' +user_name: '{{user_name}}' +date: '{{date}}' +sections_completed: ['technology_stack'] +existing_patterns_found: { { number_of_patterns_discovered } } +--- +``` + +#### B. Existing Document Update + +Load existing context and prepare for updates +Set frontmatter `sections_completed` to track what will be updated + +### 6. Present Discovery Summary + +Report findings to user: + +"Welcome {{user_name}}! I've analyzed your game project for {{project_name}} to discover the context that AI agents need. + +**Game Engine & Stack Discovered:** +{{engine_and_version}} +{{list_of_technologies_with_versions}} + +**Existing Patterns Found:** + +- {{number_of_patterns}} implementation patterns +- {{number_of_conventions}} coding conventions +- {{number_of_rules}} critical rules + +**Key Areas for Context Rules:** + +- {{area_1}} (e.g., Engine lifecycle and patterns) +- {{area_2}} (e.g., Performance and optimization) +- {{area_3}} (e.g., Platform-specific requirements) + +{if_existing_context} +**Existing Context:** Found {{sections}} sections already defined. We can update or add to these. +{/if_existing_context} + +Ready to create/update your project context. This will help AI agents implement game code consistently with your project's standards. + +[C] Continue to context generation" + +## SUCCESS METRICS: + +- Existing project context properly detected and handled +- Game engine and technology stack accurately identified with versions +- Critical implementation patterns discovered +- Project context document properly initialized +- Discovery findings clearly presented to user +- User ready to proceed with context generation + +## FAILURE MODES: + +- Not checking for existing project context before creating new one +- Missing critical engine versions or configurations +- Overlooking important coding patterns or conventions +- Not initializing frontmatter properly +- Not presenting clear discovery summary to user + +## NEXT STEP: + +After user selects [C] to continue, load `./step-02-generate.md` to collaboratively generate the specific project context rules. + +Remember: Do NOT proceed to step-02 until user explicitly selects [C] from the menu and discovery is confirmed! diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-02-generate.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-02-generate.md new file mode 100644 index 00000000..75e978cb --- /dev/null +++ b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-02-generate.md @@ -0,0 +1,373 @@ +# Step 2: Context Rules Generation + +## MANDATORY EXECUTION RULES (READ FIRST): + +- NEVER generate content without user input +- ALWAYS treat this as collaborative discovery between technical peers +- YOU ARE A FACILITATOR, not a content generator +- FOCUS on unobvious rules that AI agents need to be reminded of +- KEEP CONTENT LEAN - optimize for LLM context efficiency +- ABSOLUTELY NO TIME ESTIMATES + +## EXECUTION PROTOCOLS: + +- Show your analysis before taking any action +- Focus on specific, actionable rules rather than general advice +- Present A/P/C menu after each major rule category +- ONLY save when user chooses C (Continue) +- Update frontmatter with completed sections +- FORBIDDEN to load next step until all sections are complete + +## COLLABORATION MENUS (A/P/C): + +This step will generate content and present choices for each rule category: + +- **A (Advanced Elicitation)**: Use discovery protocols to explore nuanced implementation rules +- **P (Party Mode)**: Bring multiple perspectives to identify critical edge cases +- **C (Continue)**: Save the current rules and proceed to next category + +## PROTOCOL INTEGRATION: + +- When 'A' selected: Execute {project-root}/\_bmad/core/tasks/advanced-elicitation.xml +- When 'P' selected: Execute {project-root}/\_bmad/core/workflows/party-mode +- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed +- User accepts/rejects protocol changes before proceeding + +## CONTEXT BOUNDARIES: + +- Discovery results from step-1 are available +- Game engine and existing patterns are identified +- Focus on rules that prevent implementation mistakes +- Prioritize unobvious details that AI agents might miss + +## YOUR TASK: + +Collaboratively generate specific, critical rules that AI agents must follow when implementing game code in this project. + +## CONTEXT GENERATION SEQUENCE: + +### 1. Technology Stack & Versions + +Document the exact technology stack from discovery: + +**Core Technologies:** +Based on user skill level, present findings: + +**Expert Mode:** +"Technology stack from your architecture and project files: +{{exact_technologies_with_versions}} + +Any critical version constraints I should document for agents?" + +**Intermediate Mode:** +"I found your technology stack: + +**Game Engine:** +{{engine_with_version}} + +**Key Dependencies:** +{{important_dependencies_with_versions}} + +Are there any version constraints or compatibility notes agents should know about?" + +**Beginner Mode:** +"Here are the technologies you're using: + +**Game Engine:** +{{friendly_description_of_engine}} + +**Important Notes:** +{{key_things_agents_need_to_know_about_versions}} + +Should I document any special version rules or compatibility requirements?" + +### 2. Engine-Specific Rules + +Focus on unobvious engine patterns agents might miss: + +**Unity Rules (if applicable):** +"Based on your Unity project, I notice some specific patterns: + +**Lifecycle Rules:** +{{unity_lifecycle_patterns}} + +**Serialization Rules:** +{{serialization_requirements}} + +**Assembly Definitions:** +{{assembly_definition_rules}} + +**Coroutine/Async Patterns:** +{{async_patterns}} + +Are these patterns correct? Any other Unity-specific rules agents should follow?" + +**Unreal Rules (if applicable):** +"Based on your Unreal project, I notice some specific patterns: + +**UPROPERTY/UFUNCTION Rules:** +{{macro_usage_patterns}} + +**Blueprint Integration:** +{{blueprint_rules}} + +**Garbage Collection:** +{{gc_patterns}} + +**Tick Patterns:** +{{tick_optimization_rules}} + +Are these patterns correct? Any other Unreal-specific rules agents should follow?" + +**Godot Rules (if applicable):** +"Based on your Godot project, I notice some specific patterns: + +**Node Lifecycle:** +{{node_lifecycle_patterns}} + +**Signal Usage:** +{{signal_conventions}} + +**Scene Instancing:** +{{scene_patterns}} + +**Autoload Patterns:** +{{autoload_rules}} + +Are these patterns correct? Any other Godot-specific rules agents should follow?" + +### 3. Performance Rules + +Document performance-critical patterns: + +**Frame Budget Rules:** +"Your game has these performance requirements: + +**Target Frame Rate:** +{{target_fps}} + +**Frame Budget:** +{{milliseconds_per_frame}} + +**Critical Systems:** +{{systems_that_must_meet_budget}} + +**Hot Path Rules:** +{{hot_path_patterns}} + +Any other performance rules agents must follow?" + +**Memory Management:** +"Memory patterns for your project: + +**Allocation Rules:** +{{allocation_patterns}} + +**Pooling Requirements:** +{{object_pooling_rules}} + +**Asset Loading:** +{{asset_loading_patterns}} + +Are there memory constraints agents should know about?" + +### 4. Code Organization Rules + +Document project structure and organization: + +**Folder Structure:** +"Your project organization: + +**Script Organization:** +{{script_folder_structure}} + +**Asset Organization:** +{{asset_folder_patterns}} + +**Scene/Level Organization:** +{{scene_organization}} + +Any organization rules agents must follow?" + +**Naming Conventions:** +"Your naming patterns: + +**Script/Class Names:** +{{class_naming_patterns}} + +**Asset Names:** +{{asset_naming_patterns}} + +**Variable/Method Names:** +{{variable_naming_patterns}} + +Any other naming rules?" + +### 5. Testing Rules + +Focus on testing patterns that ensure consistency: + +**Test Structure Rules:** +"Your testing setup shows these patterns: + +**Test Organization:** +{{test_file_organization}} + +**Test Categories:** +{{unit_vs_integration_boundaries}} + +**Mocking Patterns:** +{{mock_usage_conventions}} + +**Play Mode Testing:** +{{play_mode_test_patterns}} + +Are there testing rules agents should always follow?" + +### 6. Platform & Build Rules + +Document platform-specific requirements: + +**Target Platforms:** +"Your platform configuration: + +**Primary Platform:** +{{primary_platform}} + +**Platform-Specific Code:** +{{platform_conditional_patterns}} + +**Build Configurations:** +{{build_config_rules}} + +**Input Handling:** +{{input_abstraction_patterns}} + +Any platform rules agents must know?" + +### 7. Critical Don't-Miss Rules + +Identify rules that prevent common mistakes: + +**Anti-Patterns to Avoid:** +"Based on your codebase, here are critical things agents must NOT do: + +{{critical_anti_patterns_with_examples}} + +**Edge Cases:** +{{specific_edge_cases_agents_should_handle}} + +**Common Gotchas:** +{{engine_specific_gotchas}} + +**Performance Traps:** +{{performance_patterns_to_avoid}} + +Are there other 'gotchas' agents should know about?" + +### 8. Generate Context Content + +For each category, prepare lean content for the project context file: + +#### Content Structure: + +```markdown +## Technology Stack & Versions + +{{concise_technology_list_with_exact_versions}} + +## Critical Implementation Rules + +### Engine-Specific Rules + +{{bullet_points_of_engine_rules}} + +### Performance Rules + +{{bullet_points_of_performance_requirements}} + +### Code Organization Rules + +{{bullet_points_of_organization_patterns}} + +### Testing Rules + +{{bullet_points_of_testing_requirements}} + +### Platform & Build Rules + +{{bullet_points_of_platform_requirements}} + +### Critical Don't-Miss Rules + +{{bullet_points_of_anti_patterns_and_gotchas}} +``` + +### 9. Present Content and Menu + +After each category, show the generated rules and present choices: + +"I've drafted the {{category_name}} rules for your project context. + +**Here's what I'll add:** + +[Show the complete markdown content for this category] + +**What would you like to do?** +[A] Advanced Elicitation - Explore nuanced rules for this category +[P] Party Mode - Review from different implementation perspectives +[C] Continue - Save these rules and move to next category" + +### 10. Handle Menu Selection + +#### If 'A' (Advanced Elicitation): + +- Execute advanced-elicitation.xml with current category rules +- Process enhanced rules that come back +- Ask user: "Accept these enhanced rules for {{category}}? (y/n)" +- If yes: Update content, then return to A/P/C menu +- If no: Keep original content, then return to A/P/C menu + +#### If 'P' (Party Mode): + +- Execute party-mode workflow with category rules context +- Process collaborative insights on implementation patterns +- Ask user: "Accept these changes to {{category}} rules? (y/n)" +- If yes: Update content, then return to A/P/C menu +- If no: Keep original content, then return to A/P/C menu + +#### If 'C' (Continue): + +- Save the current category content to project context file +- Update frontmatter: `sections_completed: [...]` +- Proceed to next category or step-03 if complete + +## APPEND TO PROJECT CONTEXT: + +When user selects 'C' for a category, append the content directly to `{output_folder}/project-context.md` using the structure from step 8. + +## SUCCESS METRICS: + +- All critical technology versions accurately documented +- Engine-specific rules cover unobvious patterns +- Performance rules capture project-specific requirements +- Code organization rules maintain project standards +- Testing rules ensure consistent test quality +- Platform rules prevent cross-platform issues +- Content is lean and optimized for LLM context +- A/P/C menu presented and handled correctly for each category + +## FAILURE MODES: + +- Including obvious rules that agents already know +- Making content too verbose for LLM context efficiency +- Missing critical anti-patterns or edge cases +- Not getting user validation for each rule category +- Not documenting exact versions and configurations +- Not presenting A/P/C menu after content generation + +## NEXT STEP: + +After completing all rule categories and user selects 'C' for the final category, load `./step-03-complete.md` to finalize the project context file. + +Remember: Do NOT proceed to step-03 until all categories are complete and user explicitly selects 'C' for each! diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-03-complete.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-03-complete.md new file mode 100644 index 00000000..e87e1382 --- /dev/null +++ b/src/modules/bmgd/workflows/3-technical/generate-project-context/steps/step-03-complete.md @@ -0,0 +1,279 @@ +# Step 3: Context Completion & Finalization + +## MANDATORY EXECUTION RULES (READ FIRST): + +- NEVER generate content without user input +- ALWAYS treat this as collaborative completion between technical peers +- YOU ARE A FACILITATOR, not a content generator +- FOCUS on finalizing a lean, LLM-optimized project context +- ENSURE all critical rules are captured and actionable +- ABSOLUTELY NO TIME ESTIMATES + +## EXECUTION PROTOCOLS: + +- Show your analysis before taking any action +- Review and optimize content for LLM context efficiency +- Update frontmatter with completion status +- NO MORE STEPS - this is the final step + +## CONTEXT BOUNDARIES: + +- All rule categories from step-2 are complete +- Technology stack and versions are documented +- Focus on final review, optimization, and completion +- Ensure the context file is ready for AI agent consumption + +## YOUR TASK: + +Complete the project context file, optimize it for LLM efficiency, and provide guidance for usage and maintenance. + +## COMPLETION SEQUENCE: + +### 1. Review Complete Context File + +Read the entire project context file and analyze: + +**Content Analysis:** + +- Total length and readability for LLMs +- Clarity and specificity of rules +- Coverage of all critical areas +- Actionability of each rule + +**Structure Analysis:** + +- Logical organization of sections +- Consistency of formatting +- Absence of redundant or obvious information +- Optimization for quick scanning + +### 2. Optimize for LLM Context + +Ensure the file is lean and efficient: + +**Content Optimization:** + +- Remove any redundant rules or obvious information +- Combine related rules into concise bullet points +- Use specific, actionable language +- Ensure each rule provides unique value + +**Formatting Optimization:** + +- Use consistent markdown formatting +- Implement clear section hierarchy +- Ensure scannability with strategic use of bolding +- Maintain readability while maximizing information density + +### 3. Final Content Structure + +Ensure the final structure follows this optimized format: + +```markdown +# Project Context for AI Agents + +_This file contains critical rules and patterns that AI agents must follow when implementing game code in this project. Focus on unobvious details that agents might otherwise miss._ + +--- + +## Technology Stack & Versions + +{{concise_technology_list}} + +## Critical Implementation Rules + +### Engine-Specific Rules + +{{engine_rules}} + +### Performance Rules + +{{performance_requirements}} + +### Code Organization Rules + +{{organization_patterns}} + +### Testing Rules + +{{testing_requirements}} + +### Platform & Build Rules + +{{platform_requirements}} + +### Critical Don't-Miss Rules + +{{anti_patterns_and_gotchas}} + +--- + +## Usage Guidelines + +**For AI Agents:** + +- Read this file before implementing any game code +- Follow ALL rules exactly as documented +- When in doubt, prefer the more restrictive option +- Update this file if new patterns emerge + +**For Humans:** + +- Keep this file lean and focused on agent needs +- Update when technology stack changes +- Review quarterly for outdated rules +- Remove rules that become obvious over time + +Last Updated: {{date}} +``` + +### 4. Present Completion Summary + +Based on user skill level, present the completion: + +**Expert Mode:** +"Project context complete. Optimized for LLM consumption with {{rule_count}} critical rules across {{section_count}} sections. + +File saved to: `{output_folder}/project-context.md` + +Ready for AI agent integration." + +**Intermediate Mode:** +"Your project context is complete and optimized for AI agents! + +**What we created:** + +- {{rule_count}} critical implementation rules +- Technology stack with exact versions +- Engine-specific patterns and conventions +- Performance and optimization guidelines +- Testing and platform requirements + +**Key benefits:** + +- AI agents will implement consistently with your standards +- Reduced context switching and implementation errors +- Clear guidance for unobvious project requirements + +**Next steps:** + +- AI agents should read this file before implementing +- Update as your project evolves +- Review periodically for optimization" + +**Beginner Mode:** +"Excellent! Your project context guide is ready! + +**What this does:** +Think of this as a 'rules of the road' guide for AI agents working on your game. It ensures they all follow the same patterns and avoid common mistakes. + +**What's included:** + +- Exact engine and technology versions to use +- Critical coding rules they might miss +- Performance and optimization standards +- Testing and platform requirements + +**How AI agents use it:** +They read this file before writing any code, ensuring everything they create follows your project's standards perfectly. + +Your project context is saved and ready to help agents implement consistently!" + +### 5. Final File Updates + +Update the project context file with completion information: + +**Frontmatter Update:** + +```yaml +--- +project_name: '{{project_name}}' +user_name: '{{user_name}}' +date: '{{date}}' +sections_completed: + ['technology_stack', 'engine_rules', 'performance_rules', 'organization_rules', 'testing_rules', 'platform_rules', 'anti_patterns'] +status: 'complete' +rule_count: { { total_rules } } +optimized_for_llm: true +--- +``` + +**Add Usage Section:** +Append the usage guidelines from step 3 to complete the document. + +### 6. Completion Validation + +Final checks before completion: + +**Content Validation:** + +- All critical technology versions documented +- Engine-specific rules are specific and actionable +- Performance rules capture project requirements +- Code organization rules maintain standards +- Testing rules ensure consistency +- Platform rules prevent cross-platform issues +- Anti-pattern rules prevent common mistakes + +**Format Validation:** + +- Content is lean and optimized for LLMs +- Structure is logical and scannable +- No redundant or obvious information +- Consistent formatting throughout + +### 7. Completion Message + +Present final completion to user: + +"**Project Context Generation Complete!** + +Your optimized project context file is ready at: +`{output_folder}/project-context.md` + +**Context Summary:** + +- {{rule_count}} critical rules for AI agents +- {{section_count}} comprehensive sections +- Optimized for LLM context efficiency +- Ready for immediate agent integration + +**Key Benefits:** + +- Consistent implementation across all AI agents +- Reduced common mistakes and edge cases +- Clear guidance for project-specific patterns +- Minimal LLM context usage + +**Next Steps:** + +1. AI agents will automatically read this file when implementing +2. Update this file when your technology stack or patterns evolve +3. Review quarterly to optimize and remove outdated rules + +Your project context will help ensure high-quality, consistent game implementation across all development work. Great work capturing your project's critical implementation requirements!" + +## SUCCESS METRICS: + +- Complete project context file with all critical rules +- Content optimized for LLM context efficiency +- All technology versions and patterns documented +- File structure is logical and scannable +- Usage guidelines included for agents and humans +- Frontmatter properly updated with completion status +- User provided with clear next steps and benefits + +## FAILURE MODES: + +- Final content is too verbose for LLM consumption +- Missing critical implementation rules or patterns +- Not optimizing content for agent readability +- Not providing clear usage guidelines +- Frontmatter not properly updated +- Not validating file completion before ending + +## WORKFLOW COMPLETE: + +This is the final step of the Generate Project Context workflow. The user now has a comprehensive, optimized project context file that will ensure consistent, high-quality game implementation across all AI agents working on the project. + +The project context file serves as the critical "rules of the road" that agents need to implement game code consistently with the project's standards and patterns. diff --git a/src/modules/bmgd/workflows/3-technical/generate-project-context/workflow.md b/src/modules/bmgd/workflows/3-technical/generate-project-context/workflow.md new file mode 100644 index 00000000..8eb8945c --- /dev/null +++ b/src/modules/bmgd/workflows/3-technical/generate-project-context/workflow.md @@ -0,0 +1,48 @@ +--- +name: generate-project-context +description: Creates a concise project-context.md file with critical rules and patterns that AI agents must follow when implementing game code. Optimized for LLM context efficiency. +--- + +# Generate Project Context Workflow + +**Goal:** Create a concise, optimized `project-context.md` file containing critical rules, patterns, and guidelines that AI agents must follow when implementing game code. This file focuses on unobvious details that LLMs need to be reminded of. + +**Your Role:** You are a technical facilitator working with a peer to capture the essential implementation rules that will ensure consistent, high-quality game code generation across all AI agents working on the project. + +--- + +## WORKFLOW ARCHITECTURE + +This uses **micro-file architecture** for disciplined execution: + +- Each step is a self-contained file with embedded rules +- Sequential progression with user control at each step +- Document state tracked in frontmatter +- Focus on lean, LLM-optimized content generation +- You NEVER proceed to a step file if the current step file indicates the user must approve and indicate continuation. + +--- + +## INITIALIZATION + +### Configuration Loading + +Load config from `{project-root}/_bmad/bmgd/config.yaml` and resolve: + +- `project_name`, `output_folder`, `user_name` +- `communication_language`, `document_output_language`, `game_dev_experience` +- `date` as system-generated current datetime + +### Paths + +- `installed_path` = `{project-root}/_bmad/bmgd/workflows/3-technical/generate-project-context` +- `template_path` = `{installed_path}/project-context-template.md` +- `output_file` = `{output_folder}/project-context.md` + +--- + +## EXECUTION + +Load and execute `steps/step-01-discover.md` to begin the workflow. + +**Note:** Input document discovery and initialization protocols are handled in step-01-discover.md. From 7b762fe21100f0c22141ef8ac6399d1ec02156c2 Mon Sep 17 00:00:00 2001 From: Alex Verkhovsky Date: Fri, 19 Dec 2025 22:31:54 -0700 Subject: [PATCH 2/5] fix: sync package-lock.json with package.json version (#1168) --- package-lock.json | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/package-lock.json b/package-lock.json index e84d76c7..d2421a22 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "bmad-method", - "version": "6.0.0-alpha.17", + "version": "6.0.0-alpha.19", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "bmad-method", - "version": "6.0.0-alpha.17", + "version": "6.0.0-alpha.19", "license": "MIT", "dependencies": { "@kayvan/markdown-tree-parser": "^1.6.1", @@ -98,6 +98,7 @@ "integrity": "sha512-yDBHV9kQNcr2/sUr9jghVyz9C3Y5G2zUM2H2lo+9mKv4sFgbA8s8Z9t8D1jiTkGoO/NoIfKMyKWr4s6CN23ZwQ==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.27.1", @@ -1840,6 +1841,7 @@ "integrity": "sha512-aPTXCrfwnDLj4VvXrm+UUCQjNEvJgNA8s5F1cvwQU+3KNltTOkBm1j30uNLyqqPNe7gE3KFzImYoZEfLhp4Yow==", "devOptional": true, "license": "MIT", + "peer": true, "dependencies": { "undici-types": "~7.10.0" } @@ -2156,6 +2158,7 @@ "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", "dev": true, "license": "MIT", + "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -2517,6 +2520,7 @@ } ], "license": "MIT", + "peer": true, "dependencies": { "caniuse-lite": "^1.0.30001735", "electron-to-chromium": "^1.5.204", @@ -3406,6 +3410,7 @@ "integrity": "sha512-RNCHRX5EwdrESy3Jc9o8ie8Bog+PeYvvSR8sDGoZxNFTvZ4dlxUB3WzQ3bQMztFrSRODGrLLj8g6OFuGY/aiQg==", "dev": true, "license": "MIT", + "peer": true, "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.12.1", @@ -7493,6 +7498,7 @@ "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==", "dev": true, "license": "MIT", + "peer": true, "bin": { "prettier": "bin/prettier.cjs" }, @@ -8325,6 +8331,7 @@ "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", "dev": true, "license": "MIT", + "peer": true, "engines": { "node": ">=12" }, From b276d5a3871d29eaba8af99432495f8cc2d2e6f4 Mon Sep 17 00:00:00 2001 From: Alex Verkhovsky Date: Fri, 19 Dec 2025 22:33:55 -0700 Subject: [PATCH 3/5] refactor: streamline quick-flow-solo-dev persona for clarity and accuracy (#1167) Co-authored-by: Brian --- .../bmm/agents/quick-flow-solo-dev.agent.yaml | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/src/modules/bmm/agents/quick-flow-solo-dev.agent.yaml b/src/modules/bmm/agents/quick-flow-solo-dev.agent.yaml index 1a49a8be..a04d6b33 100644 --- a/src/modules/bmm/agents/quick-flow-solo-dev.agent.yaml +++ b/src/modules/bmm/agents/quick-flow-solo-dev.agent.yaml @@ -10,13 +10,12 @@ agent: persona: role: Elite Full-Stack Developer + Quick Flow Specialist - identity: Barry is an elite developer who thrives on autonomous execution. He lives and breathes the BMAD Quick Flow workflow, taking projects from concept to deployment with ruthless efficiency. No handoffs, no delays - just pure, focused development. He architects specs, writes the code, and ships features faster than entire teams. - communication_style: "Direct, confident, and implementation-focused. Uses tech slang and gets straight to the point. No fluff, just results. Every response moves the project forward." + identity: Barry handles Quick Flow - from tech spec creation through implementation. Minimum ceremony, lean artifacts, ruthless efficiency. + communication_style: "Direct, confident, and implementation-focused. Uses tech slang (e.g., refactor, patch, extract, spike) and gets straight to the point. No fluff, just results. Stays focused on the task at hand." principles: | - - Planning and execution are two sides of the same coin. Quick Flow is my religion. + - Planning and execution are two sides of the same coin. - Specs are for building, not bureaucracy. Code that ships is better than perfect code that doesn't. - - Documentation happens alongside development, not after. Ship early, ship often. - - Find if this exists, if it does, always treat it as the bible I plan and execute against: `**/project-context.md `` + - If `**/project-context.md` exists, follow it. If absent, proceed without. menu: - trigger: create-tech-spec @@ -27,10 +26,6 @@ agent: workflow: "{project-root}/_bmad/bmm/workflows/bmad-quick-flow/quick-dev/workflow.yaml" description: Implement the tech spec end-to-end solo (Core of Quick Flow) - - trigger: code-review - workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/code-review/workflow.yaml" - description: Review code and improve it (Highly Recommended, use fresh context and different LLM for best results) - - trigger: party-mode exec: "{project-root}/_bmad/core/workflows/party-mode/workflow.md" description: Bring in other experts when I need specialized backup From 4271fe5f2b2c229109fefe11c27ea08112b25c14 Mon Sep 17 00:00:00 2001 From: Serhii Date: Sat, 20 Dec 2025 07:37:09 +0200 Subject: [PATCH 4/5] fix(bmm): resolve dead references and syntax errors in agents and workflows (#1164) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Fix XML syntax error in dev-story/instructions.xml:20 (goto element) - Fix path typo in tech-writer.agent.yaml (_bmadbmm → _bmad/bmm) - Fix wrong route in analyst.agent.yaml (edit-agent → party-mode) - Comment out unimplemented validate-create-story in sm.agent.yaml - Comment out unimplemented validate-design in ux-designer.agent.yaml - Remove misleading validate-create-story reference in create-story output Fixes #1075 Related to #1163 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.5 Co-authored-by: Brian --- src/modules/bmm/agents/analyst.agent.yaml | 2 +- src/modules/bmm/agents/sm.agent.yaml | 9 ++++++--- src/modules/bmm/agents/tech-writer.agent.yaml | 2 +- src/modules/bmm/agents/ux-designer.agent.yaml | 9 ++++++--- .../4-implementation/create-story/instructions.xml | 14 ++------------ .../4-implementation/dev-story/instructions.xml | 2 +- 6 files changed, 17 insertions(+), 21 deletions(-) diff --git a/src/modules/bmm/agents/analyst.agent.yaml b/src/modules/bmm/agents/analyst.agent.yaml index dbe46d1c..9a1add04 100644 --- a/src/modules/bmm/agents/analyst.agent.yaml +++ b/src/modules/bmm/agents/analyst.agent.yaml @@ -43,7 +43,7 @@ agent: triggers: - party-mode: - input: SPM or fuzzy match start party mode - - route: "{project-root}/_bmad/core/workflows/edit-agent/workflow.md" + - route: "{project-root}/_bmad/core/workflows/party-mode/workflow.md" - data: what is being discussed or suggested with the command, along with custom party custom agents if specified - type: exec - expert-chat: diff --git a/src/modules/bmm/agents/sm.agent.yaml b/src/modules/bmm/agents/sm.agent.yaml index 26e2fe06..64262df4 100644 --- a/src/modules/bmm/agents/sm.agent.yaml +++ b/src/modules/bmm/agents/sm.agent.yaml @@ -32,9 +32,12 @@ agent: workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/create-story/workflow.yaml" description: Create Story (Required to prepare stories for development) - - trigger: validate-create-story - validate-workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/create-story/workflow.yaml" - description: Validate Story (Highly Recommended, use fresh context and different LLM for best results) + # TODO: validate-create-story is not yet implemented + # The validate-workflow: handler type is not recognized by the workflow engine + # See: https://github.com/bmad-code-org/BMAD-METHOD/issues/1075 + # - trigger: validate-create-story + # workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/create-story/validate-workflow.yaml" + # description: Validate Story (Highly Recommended, use fresh context and different LLM for best results) - trigger: epic-retrospective workflow: "{project-root}/_bmad/bmm/workflows/4-implementation/retrospective/workflow.yaml" diff --git a/src/modules/bmm/agents/tech-writer.agent.yaml b/src/modules/bmm/agents/tech-writer.agent.yaml index a5eb9252..48b68e83 100644 --- a/src/modules/bmm/agents/tech-writer.agent.yaml +++ b/src/modules/bmm/agents/tech-writer.agent.yaml @@ -54,7 +54,7 @@ agent: description: Create clear technical explanations with examples - trigger: standards-guide - action: "Display the complete documentation standards from {project-root}/_bmadbmm/data/documentation-standards.md in a clear, formatted way for the user." + action: "Display the complete documentation standards from {project-root}/_bmad/bmm/data/documentation-standards.md in a clear, formatted way for the user." description: Show BMAD documentation standards reference (CommonMark, Mermaid, OpenAPI) - trigger: party-mode diff --git a/src/modules/bmm/agents/ux-designer.agent.yaml b/src/modules/bmm/agents/ux-designer.agent.yaml index b269fd01..2bf7a844 100644 --- a/src/modules/bmm/agents/ux-designer.agent.yaml +++ b/src/modules/bmm/agents/ux-designer.agent.yaml @@ -27,9 +27,12 @@ agent: exec: "{project-root}/_bmad/bmm/workflows/2-plan-workflows/create-ux-design/workflow.md" description: Generate a UX Design and UI Plan from a PRD (Recommended before creating Architecture) - - trigger: validate-design - validate-workflow: "{project-root}/_bmad/bmm/workflows/2-plan-workflows/create-ux-design/workflow.yaml" - description: Validate UX Specification and Design Artifacts + # TODO: validate-design is not yet implemented + # The validate-workflow: handler type is not recognized by the workflow engine + # See: https://github.com/bmad-code-org/BMAD-METHOD/issues/1075 + # - trigger: validate-design + # workflow: "{project-root}/_bmad/bmm/workflows/2-plan-workflows/create-ux-design/validate-workflow.yaml" + # description: Validate UX Specification and Design Artifacts - trigger: create-excalidraw-wireframe workflow: "{project-root}/_bmad/bmm/workflows/excalidraw-diagrams/create-wireframe/workflow.yaml" diff --git a/src/modules/bmm/workflows/4-implementation/create-story/instructions.xml b/src/modules/bmm/workflows/4-implementation/create-story/instructions.xml index e3805451..52405e71 100644 --- a/src/modules/bmm/workflows/4-implementation/create-story/instructions.xml +++ b/src/modules/bmm/workflows/4-implementation/create-story/instructions.xml @@ -334,18 +334,8 @@ **Next Steps:** 1. Review the comprehensive story in {{story_file}} - 2. **Optional Quality Competition:** Run the scrum masters `*validate-create-story` to have a fresh LLM systematically review and - improve the story context - 3. Run dev agents `dev-story` for optimized implementation - 4. Run `code-review` when complete (auto-marks done) - - **Quality Competition Option:** The `*validate-create-story` command runs the story context through an independent LLM in fresh - context that will: - - Systematically re-analyze all source documents - - Identify any misses, omissions, or improvements - - Compete to create a more comprehensive story context - - Present findings interactively for your approval - - Apply improvements to create the ultimate developer implementation guide + 2. Run dev agents `dev-story` for optimized implementation + 3. Run `code-review` when complete (auto-marks done) **The developer now has everything needed for flawless implementation!** diff --git a/src/modules/bmm/workflows/4-implementation/dev-story/instructions.xml b/src/modules/bmm/workflows/4-implementation/dev-story/instructions.xml index 47e76f07..40c56244 100644 --- a/src/modules/bmm/workflows/4-implementation/dev-story/instructions.xml +++ b/src/modules/bmm/workflows/4-implementation/dev-story/instructions.xml @@ -17,7 +17,7 @@ Use {{story_path}} directly Read COMPLETE story file Extract story_key from filename or metadata - anchor with id task_check + From a20198b94b028bf0a041776db6572a4ae94e2841 Mon Sep 17 00:00:00 2001 From: Brian Madison Date: Sat, 20 Dec 2025 16:39:43 +0800 Subject: [PATCH 5/5] workflow step location fixed in create product brief --- .../1-analysis/create-product-brief/steps/step-01-init.md | 2 +- .../1-analysis/create-product-brief/steps/step-01b-continue.md | 2 +- .../1-analysis/create-product-brief/steps/step-02-vision.md | 2 +- .../1-analysis/create-product-brief/steps/step-03-users.md | 2 +- .../1-analysis/create-product-brief/steps/step-04-metrics.md | 2 +- .../1-analysis/create-product-brief/steps/step-05-scope.md | 2 +- .../1-analysis/create-product-brief/steps/step-06-complete.md | 2 +- .../bmm/workflows/1-analysis/create-product-brief/workflow.md | 2 +- 8 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-01-init.md b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-01-init.md index 7ce3f756..dbb0189c 100644 --- a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-01-init.md +++ b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-01-init.md @@ -3,7 +3,7 @@ name: 'step-01-init' description: 'Initialize the product brief workflow by detecting continuation state and setting up the document' # Path Definitions -workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/product-brief' +workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/create-product-brief' # File References thisStepFile: '{workflow_path}/steps/step-01-init.md' diff --git a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-01b-continue.md b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-01b-continue.md index 778b4c7d..3ffad7db 100644 --- a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-01b-continue.md +++ b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-01b-continue.md @@ -3,7 +3,7 @@ name: 'step-01b-continue' description: 'Resume the product brief workflow from where it was left off, ensuring smooth continuation' # Path Definitions -workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/product-brief' +workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/create-product-brief' # File References thisStepFile: '{workflow_path}/steps/step-01b-continue.md' diff --git a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-02-vision.md b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-02-vision.md index 6b98dec8..8492b92c 100644 --- a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-02-vision.md +++ b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-02-vision.md @@ -3,7 +3,7 @@ name: 'step-02-vision' description: 'Discover and define the core product vision, problem statement, and unique value proposition' # Path Definitions -workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/product-brief' +workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/create-product-brief' # File References thisStepFile: '{workflow_path}/steps/step-02-vision.md' diff --git a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-03-users.md b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-03-users.md index a5526470..e415cc7b 100644 --- a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-03-users.md +++ b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-03-users.md @@ -3,7 +3,7 @@ name: 'step-03-users' description: 'Define target users with rich personas and map their key interactions with the product' # Path Definitions -workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/product-brief' +workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/create-product-brief' # File References thisStepFile: '{workflow_path}/steps/step-03-users.md' diff --git a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-04-metrics.md b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-04-metrics.md index 88993ae4..d888f716 100644 --- a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-04-metrics.md +++ b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-04-metrics.md @@ -3,7 +3,7 @@ name: 'step-04-metrics' description: 'Define comprehensive success metrics that include user success, business objectives, and key performance indicators' # Path Definitions -workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/product-brief' +workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/create-product-brief' # File References thisStepFile: '{workflow_path}/steps/step-04-metrics.md' diff --git a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-05-scope.md b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-05-scope.md index fb68106b..94fcad1d 100644 --- a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-05-scope.md +++ b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-05-scope.md @@ -3,7 +3,7 @@ name: 'step-05-scope' description: 'Define MVP scope with clear boundaries and outline future vision while managing scope creep' # Path Definitions -workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/product-brief' +workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/create-product-brief' # File References thisStepFile: '{workflow_path}/steps/step-05-scope.md' diff --git a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-06-complete.md b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-06-complete.md index 9b67a4c3..62716722 100644 --- a/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-06-complete.md +++ b/src/modules/bmm/workflows/1-analysis/create-product-brief/steps/step-06-complete.md @@ -3,7 +3,7 @@ name: 'step-06-complete' description: 'Complete the product brief workflow, update status files, and suggest next steps for the project' # Path Definitions -workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/product-brief' +workflow_path: '{project-root}/_bmad/bmm/workflows/1-analysis/create-product-brief' # File References thisStepFile: '{workflow_path}/steps/step-06-complete.md' diff --git a/src/modules/bmm/workflows/1-analysis/create-product-brief/workflow.md b/src/modules/bmm/workflows/1-analysis/create-product-brief/workflow.md index 0e078e5f..f06b7fe5 100644 --- a/src/modules/bmm/workflows/1-analysis/create-product-brief/workflow.md +++ b/src/modules/bmm/workflows/1-analysis/create-product-brief/workflow.md @@ -55,4 +55,4 @@ Load and read full config from {project-root}/\_bmad/bmm/config.yaml and resolve ### 2. First Step EXECUTION -Load, read the full file and then execute `{project-root}/_bmad/bmm/workflows/1-analysis/product-brief/steps/step-01-init.md` to begin the workflow. +Load, read the full file and then execute `{project-root}/_bmad/bmm/workflows/1-analysis/create-product-brief/steps/step-01-init.md` to begin the workflow.