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

package/src/modules/bmgd/gametest/knowledge/unreal-testing.md

@@ -0,0 +1,388 @@
+# Unreal Engine Automation Testing Guide
+
+## Overview
+
+Unreal Engine provides a comprehensive automation system for testing games, including:
+
+- **Automation Framework** - Low-level test infrastructure
+- **Functional Tests** - In-game scenario testing
+- **Gauntlet** - Extended testing and automation
+
+## Automation Framework
+
+### Test Types
+
+| Type          | Flag            | Use Case                   |
+| ------------- | --------------- | -------------------------- |
+| Unit Tests    | `SmokeFilter`   | Fast, isolated logic tests |
+| Feature Tests | `ProductFilter` | Feature validation         |
+| Stress Tests  | `StressFilter`  | Performance under load     |
+| Perf Tests    | `PerfFilter`    | Benchmark comparisons      |
+
+### Basic Test Structure
+
+```cpp
+// MyGameTests.cpp
+#include "Misc/AutomationTest.h"
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+    FDamageCalculationTest,
+    "MyGame.Combat.DamageCalculation",
+    EAutomationTestFlags::ApplicationContextMask |
+    EAutomationTestFlags::ProductFilter
+)
+
+bool FDamageCalculationTest::RunTest(const FString& Parameters)
+{
+    // Arrange
+    float BaseDamage = 100.f;
+    float CritMultiplier = 2.f;
+
+    // Act
+    float Result = UDamageCalculator::Calculate(BaseDamage, CritMultiplier);
+
+    // Assert
+    TestEqual("Critical hit doubles damage", Result, 200.f);
+
+    return true;
+}
+```
+
+### Complex Test with Setup/Teardown
+
+```cpp
+IMPLEMENT_COMPLEX_AUTOMATION_TEST(
+    FInventorySystemTest,
+    "MyGame.Systems.Inventory",
+    EAutomationTestFlags::ApplicationContextMask |
+    EAutomationTestFlags::ProductFilter
+)
+
+void FInventorySystemTest::GetTests(
+    TArray<FString>& OutBeautifiedNames,
+    TArray<FString>& OutTestCommands) const
+{
+    OutBeautifiedNames.Add("AddItem");
+    OutTestCommands.Add("AddItem");
+
+    OutBeautifiedNames.Add("RemoveItem");
+    OutTestCommands.Add("RemoveItem");
+
+    OutBeautifiedNames.Add("StackItems");
+    OutTestCommands.Add("StackItems");
+}
+
+bool FInventorySystemTest::RunTest(const FString& Parameters)
+{
+    // Setup
+    UInventoryComponent* Inventory = NewObject<UInventoryComponent>();
+
+    if (Parameters == "AddItem")
+    {
+        UItemData* Sword = NewObject<UItemData>();
+        Sword->ItemID = "sword_01";
+
+        bool bAdded = Inventory->AddItem(Sword);
+
+        TestTrue("Item added successfully", bAdded);
+        TestEqual("Inventory count", Inventory->GetItemCount(), 1);
+    }
+    else if (Parameters == "RemoveItem")
+    {
+        // ... test logic
+    }
+    else if (Parameters == "StackItems")
+    {
+        // ... test logic
+    }
+
+    return true;
+}
+```
+
+### Latent Actions (Async Tests)
+
+```cpp
+DEFINE_LATENT_AUTOMATION_COMMAND_ONE_PARAMETER(
+    FWaitForActorSpawn,
+    FString, ActorName
+);
+
+bool FWaitForActorSpawn::Update()
+{
+    UWorld* World = GEngine->GetWorldContexts()[0].World();
+    AActor* Actor = nullptr;
+
+    for (TActorIterator<AActor> It(World); It; ++It)
+    {
+        if (It->GetName() == ActorName)
+        {
+            Actor = *It;
+            break;
+        }
+    }
+
+    return Actor != nullptr; // Return true when complete
+}
+
+bool FSpawnTest::RunTest(const FString& Parameters)
+{
+    // Spawn enemy
+    ADD_LATENT_AUTOMATION_COMMAND(FSpawnEnemy("Goblin"));
+
+    // Wait for spawn
+    ADD_LATENT_AUTOMATION_COMMAND(FWaitForActorSpawn("Goblin"));
+
+    // Verify
+    ADD_LATENT_AUTOMATION_COMMAND(FVerifyEnemyState("Goblin", "Idle"));
+
+    return true;
+}
+```
+
+## Functional Tests
+
+Functional tests run inside the game world and can test gameplay scenarios.
+
+### Setup
+
+1. Create a test map (`TestMap_Combat.umap`)
+2. Add `AFunctionalTest` actors to the map
+3. Configure test parameters in Details panel
+
+### Blueprint Functional Test
+
+```cpp
+// In Blueprint:
+// 1. Create child of AFunctionalTest
+// 2. Override "Start Test" event
+// 3. Call "Finish Test" when complete
+```
+
+### C++ Functional Test
+
+```cpp
+UCLASS()
+class APlayerCombatTest : public AFunctionalTest
+{
+    GENERATED_BODY()
+
+public:
+    virtual void StartTest() override;
+
+protected:
+    UPROPERTY(EditAnywhere)
+    TSubclassOf<AEnemy> EnemyClass;
+
+    UPROPERTY(EditAnywhere)
+    float ExpectedDamage = 50.f;
+
+private:
+    void OnEnemyDamaged(float Damage);
+};
+
+void APlayerCombatTest::StartTest()
+{
+    Super::StartTest();
+
+    // Spawn test enemy
+    AEnemy* Enemy = GetWorld()->SpawnActor<AEnemy>(EnemyClass);
+    Enemy->OnDamaged.AddDynamic(this, &APlayerCombatTest::OnEnemyDamaged);
+
+    // Get player and attack
+    APlayerCharacter* Player = Cast<APlayerCharacter>(
+        UGameplayStatics::GetPlayerCharacter(this, 0));
+    Player->Attack(Enemy);
+}
+
+void APlayerCombatTest::OnEnemyDamaged(float Damage)
+{
+    if (FMath::IsNearlyEqual(Damage, ExpectedDamage, 0.1f))
+    {
+        FinishTest(EFunctionalTestResult::Succeeded, "Damage correct");
+    }
+    else
+    {
+        FinishTest(EFunctionalTestResult::Failed,
+            FString::Printf(TEXT("Expected %f, got %f"),
+                ExpectedDamage, Damage));
+    }
+}
+```
+
+## Gauntlet Framework
+
+Gauntlet extends automation for large-scale testing, performance benchmarking, and multi-client scenarios.
+
+### Gauntlet Test Configuration
+
+```cpp
+// MyGameTest.cs (Gauntlet config)
+namespace MyGame.Automation
+{
+    public class PerformanceTestConfig : UnrealTestConfig
+    {
+        [AutoParam]
+        public string MapName = "TestMap_Performance";
+
+        [AutoParam]
+        public int Duration = 300; // 5 minutes
+
+        public override void ApplyToConfig(UnrealAppConfig Config)
+        {
+            base.ApplyToConfig(Config);
+            Config.AddCmdLineArg("-game");
+            Config.AddCmdLineArg($"-ExecCmds=open {MapName}");
+        }
+    }
+}
+```
+
+### Running Gauntlet
+
+```bash
+# Run performance test
+RunUAT.bat RunUnreal -project=MyGame -platform=Win64 \
+  -configuration=Development -build=local \
+  -test=MyGame.PerformanceTest -Duration=300
+```
+
+## Blueprint Testing
+
+### Test Helpers in Blueprint
+
+Create a Blueprint Function Library with test utilities:
+
+```cpp
+UCLASS()
+class UTestHelpers : public UBlueprintFunctionLibrary
+{
+    GENERATED_BODY()
+
+public:
+    UFUNCTION(BlueprintCallable, Category = "Testing")
+    static void AssertTrue(bool Condition, const FString& Message);
+
+    UFUNCTION(BlueprintCallable, Category = "Testing")
+    static void AssertEqual(int32 A, int32 B, const FString& Message);
+
+    UFUNCTION(BlueprintCallable, Category = "Testing")
+    static AActor* SpawnTestActor(
+        UObject* WorldContext,
+        TSubclassOf<AActor> ActorClass,
+        FVector Location);
+};
+```
+
+## Performance Testing
+
+### Frame Time Measurement
+
+```cpp
+bool FFrameTimeTest::RunTest(const FString& Parameters)
+{
+    TArray<float> FrameTimes;
+    float TotalTime = 0.f;
+
+    // Collect frame times
+    ADD_LATENT_AUTOMATION_COMMAND(FCollectFrameTimes(
+        FrameTimes, 1000 // frames
+    ));
+
+    // Analyze
+    ADD_LATENT_AUTOMATION_COMMAND(FAnalyzeFrameTimes(
+        FrameTimes,
+        16.67f, // Target: 60fps
+        0.99f   // 99th percentile threshold
+    ));
+
+    return true;
+}
+```
+
+### Memory Tracking
+
+```cpp
+bool FMemoryLeakTest::RunTest(const FString& Parameters)
+{
+    SIZE_T BaselineMemory = FPlatformMemory::GetStats().UsedPhysical;
+
+    // Perform operations
+    for (int i = 0; i < 100; i++)
+    {
+        UObject* Obj = NewObject<UMyObject>();
+        // ... use object
+        Obj->MarkAsGarbage();  // UE5 API (was MarkPendingKill in UE4)
+    }
+
+    CollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS);
+
+    SIZE_T FinalMemory = FPlatformMemory::GetStats().UsedPhysical;
+    SIZE_T Leaked = FinalMemory - BaselineMemory;
+
+    TestTrue("No significant leak", Leaked < 1024 * 1024); // 1MB tolerance
+
+    return true;
+}
+```
+
+## CI Integration
+
+### Command Line
+
+```bash
+# Run all tests (UE5)
+UnrealEditor.exe MyGame -ExecCmds="Automation RunTests Now" -unattended -nopause
+
+# Run specific test
+UnrealEditor.exe MyGame -ExecCmds="Automation RunTests MyGame.Combat" -unattended
+
+# Run with report
+UnrealEditor.exe MyGame \
+  -ExecCmds="Automation RunTests Now; Automation ReportResults" \
+  -ReportOutputPath=TestResults.xml
+
+# Note: For UE4, use UE4Editor.exe instead of UnrealEditor.exe
+```
+
+### GitHub Actions
+
+```yaml
+test:
+  runs-on: [self-hosted, windows, unreal]
+  steps:
+    - name: Run Tests
+      run: |
+        # UE5: UnrealEditor-Cmd.exe, UE4: UE4Editor-Cmd.exe
+        & "$env:UE_ROOT/Engine/Binaries/Win64/UnrealEditor-Cmd.exe" `
+          "${{ github.workspace }}/MyGame.uproject" `
+          -ExecCmds="Automation RunTests Now" `
+          -unattended -nopause -nullrhi
+```
+
+## Best Practices
+
+### DO
+
+- Use `SmokeFilter` for fast CI tests
+- Create dedicated test maps for functional tests
+- Clean up spawned actors after tests
+- Use latent commands for async operations
+- Profile tests to keep CI fast
+
+### DON'T
+
+- Don't test engine functionality
+- Don't rely on specific tick order
+- Don't leave test actors in production maps
+- Don't ignore test warnings
+- Don't skip garbage collection in tests
+
+## Troubleshooting
+
+| Issue          | Cause           | Fix                          |
+| -------------- | --------------- | ---------------------------- |
+| Test not found | Wrong flags     | Check `EAutomationTestFlags` |
+| Crash in test  | Missing world   | Use proper test context      |
+| Flaky results  | Timing issues   | Use latent commands          |
+| Slow tests     | Too many actors | Optimize test setup          |

package/src/modules/bmgd/gametest/qa-index.csv

@@ -0,0 +1,17 @@
+id,name,description,tags,fragment_file
+playtesting,Playtesting Fundamentals,"Core principles and methods for playtesting game builds","testing-methods,playtesting,design-validation",knowledge/playtesting.md
+qa-automation,QA Automation,"Automated testing strategies for games including unit and integration tests","automation,unit-tests,integration",knowledge/qa-automation.md
+performance-testing,Performance Testing,"Frame rate profiling and optimization testing strategies","performance,profiling,fps",knowledge/performance-testing.md
+balance-testing,Balance Testing,"Methods for testing game balance and tuning","design-validation,balance,economy",knowledge/balance-testing.md
+compatibility-testing,Compatibility Testing,"Platform and device compatibility testing approaches","compatibility,platforms,hardware",knowledge/compatibility-testing.md
+regression-testing,Regression Testing,"Strategies for catching regressions in game builds","regression,ci,automation",knowledge/regression-testing.md
+unity-testing,Unity Test Framework,"Unity-specific testing with Test Framework, Play Mode, and Edit Mode tests","unity,unit-tests,integration",knowledge/unity-testing.md
+unreal-testing,Unreal Automation,"Unreal Engine automation system, functional tests, and Gauntlet","unreal,automation,gauntlet",knowledge/unreal-testing.md
+godot-testing,Godot GUT Testing,"Godot Unit Test framework patterns and best practices","godot,gut,unit-tests",knowledge/godot-testing.md
+save-testing,Save System Testing,"Strategies for testing save/load systems and data integrity","save-system,data,persistence",knowledge/save-testing.md
+multiplayer-testing,Multiplayer Testing,"Network testing, sync validation, and lag simulation","multiplayer,networking,sync",knowledge/multiplayer-testing.md
+input-testing,Input Testing,"Controller, keyboard, and touch input validation","input,controllers,accessibility",knowledge/input-testing.md
+localization-testing,Localization Testing,"Text, audio, and cultural validation for international releases","localization,i18n,text",knowledge/localization-testing.md
+certification-testing,Platform Certification,"Console TRC/XR requirements and certification testing","certification,console,trc,xr",knowledge/certification-testing.md
+smoke-testing,Smoke Testing,"Critical path validation for build verification","smoke-tests,bvt,ci",knowledge/smoke-testing.md
+test-priorities,Test Priorities Matrix,"P0-P3 criteria, coverage targets, execution ordering for games","prioritization,risk,coverage",knowledge/test-priorities.md

package/src/modules/bmgd/module.yaml

@@ -0,0 +1,64 @@
+code: bmgd
+name: "BMGD: BMad Game Development"
+header: "BMad Game Development Module"
+subheader: "Configure the settings for the BMad Game Development module"
+default_selected: false
+
+# Variables from Core Config inserted:
+## user_name
+## communication_language
+## document_output_language
+## output_folder
+
+project_name:
+  prompt: "What is the name of your game project?"
+  default: "{directory_name}"
+  result: "{value}"
+
+game_dev_experience:
+  prompt:
+    - "What is your game development experience level?"
+    - "This affects how agents explain concepts in chat."
+  default: "intermediate"
+  result: "{value}"
+  single-select:
+    - value: "beginner"
+      label: "Beginner - New to game development, explain concepts clearly"
+    - value: "intermediate"
+      label: "Intermediate - Familiar with game dev concepts, balance explanation with efficiency"
+    - value: "expert"
+      label: "Expert - Experienced game developer, be direct and technical"
+
+planning_artifacts:
+  prompt: "Where should game planning artifacts be stored?\n(Game Briefs, GDDs, Narrative Designs, Architecture docs)"
+  default: "{output_folder}/planning-artifacts"
+  result: "{project-root}/{value}"
+
+implementation_artifacts:
+  prompt: "Where should implementation artifacts be stored?\n(sprint status, story files, reviews, retrospectives)"
+  default: "{output_folder}/implementation-artifacts"
+  result: "{project-root}/{value}"
+
+# Alias for workflow compatibility
+sprint_artifacts:
+  inherit: "implementation_artifacts"
+
+project_knowledge:
+  prompt: "Where should non-ephemeral project knowledge be searched for and stored?\n(docs, research, references)"
+  default: "docs"
+  result: "{project-root}/{value}"
+
+primary_platform:
+  prompt: "Which game development framework or engine do you want to install support for?"
+  default: ["unity", "unreal", "godot", "other"]
+  required: true
+  result: "{value}"
+  multi-select:
+    - value: "unity"
+      label: "Unity"
+    - value: "unreal"
+      label: "Unreal Engine"
+    - value: "godot"
+      label: "Godot"
+    - value: "other"
+      label: "Custom / Other"

package/src/modules/bmgd/teams/default-party.csv

@@ -0,0 +1,12 @@
+name,displayName,title,icon,role,identity,communicationStyle,principles,module,path
+"game-architect","Cloud Dragonborn","Game Architect","🏛️","Principal Game Systems Architect + Technical Director","Master architect with 20+ years shipping 30+ titles. Expert in distributed systems, engine design, multiplayer architecture, and technical leadership across all platforms.","Speaks like a wise sage from an RPG - calm, measured, uses architectural metaphors","Architecture is about delaying decisions until you have enough data. Build for tomorrow without over-engineering today. Hours of planning save weeks of refactoring hell.","bmgd","bmad/bmgd/agents/game-architect.md"
+"game-designer","Samus Shepard","Game Designer","🎲","Lead Game Designer + Creative Vision Architect","Veteran designer with 15+ years crafting AAA and indie hits. Expert in mechanics, player psychology, narrative design, and systemic thinking.","Talks like an excited streamer - enthusiastic, asks about player motivations, celebrates breakthroughs","Design what players want to FEEL, not what they say they want. Prototype fast. One hour of playtesting beats ten hours of discussion.","bmgd","bmad/bmgd/agents/game-designer.md"
+"game-dev","Link Freeman","Game Developer","🕹️","Senior Game Developer + Technical Implementation Specialist","Battle-hardened dev with expertise in Unity, Unreal, and custom engines. Ten years shipping across mobile, console, and PC. Writes clean, performant code.","Speaks like a speedrunner - direct, milestone-focused, always optimizing","60fps is non-negotiable. Write code designers can iterate without fear. Ship early, ship often, iterate on player feedback.","bmgd","bmad/bmgd/agents/game-dev.md"
+"game-scrum-master","Max","Game Dev Scrum Master","🎯","Game Development Scrum Master + Sprint Orchestrator","Certified Scrum Master specializing in game dev workflows. Expert at coordinating multi-disciplinary teams and translating GDDs into actionable stories.","Talks in game terminology - milestones are save points, handoffs are level transitions","Every sprint delivers playable increments. Clean separation between design and implementation. Keep the team moving through each phase.","bmgd","bmad/bmgd/agents/game-scrum-master.md"
+"game-qa","GLaDOS","Game QA Architect","🧪","Game QA Architect + Test Automation Specialist","Senior QA architect with 12+ years in game testing across Unity, Unreal, and Godot. Expert in automated testing frameworks, performance profiling, and shipping bug-free games.","Speaks like GLaDOS from Portal - methodical, data-driven. Trust, but verify with tests.","Test what matters: gameplay feel, performance, progression. Automated tests catch regressions, humans catch fun problems. Profile before optimize, test before ship.","bmgd","bmad/bmgd/agents/game-qa.md"
+"game-solo-dev","Indie","Game Solo Dev","🎮","Elite Indie Game Developer + Quick Flow Specialist","Battle-hardened solo game developer who ships complete games from concept to launch. Expert in Unity, Unreal, and Godot. Lives the Quick Flow workflow.","Direct, confident, gameplay-focused. Uses dev slang. Does it feel good? Ship it.","Prototype fast, fail fast, iterate faster. A playable build beats a perfect design doc. 60fps is non-negotiable. The core loop must be fun first.","bmgd","bmad/bmgd/agents/game-solo-dev.md"
+"sound-wizard","Zephyr ""Boom"" Chen","Audio Wizard","🎵","Lead Sound Designer + Audio Architect","15 years crafting iconic game audio. Expert in adaptive music systems, procedural audio, and spatial sound. Obsessed with making every action feel impactful.","Talks in onomatopoeia - WHOOSH for swooshes, KABOOM for explosions, describes everything through sound effects","Sound is 50% of the experience. Every footstep tells a story. Silence is the most powerful sound.","bmgd",""
+"dungeon-keeper","Morthos Grimforge","Level Designer","🗺️","Principal Level Designer + Environment Storyteller","20 years building legendary game spaces from sprawling RPG dungeons to tight FPS arenas. Master of flow, pacing, and environmental storytelling.","Speaks like a dramatic dungeon master - describes spaces theatrically, rolls for initiative on decisions","Every room must teach or test. The best levels don't need tutorials. Players should feel clever, not frustrated.","bmgd",""
+"narrative-weaver","Ink Sterling","Narrative Designer","📚","Lead Narrative Designer + Interactive Storyteller","Crafted award-winning branching narratives for 10+ titles. Expert in choice architecture, character arcs, and integrating story with mechanics.","Speaks in story beats - everything is Act 1, plot twists, climaxes, and emotional payoffs","Story serves gameplay, gameplay reveals story. Every choice must matter or don't offer it. Kill your darlings ruthlessly.","bmgd",""
+"particle-mage","Nova Starling","VFX Artist","✨","Principal VFX Artist + Visual Effects Wizard","12 years making explosions that make players say 'whoa'. Master of particle systems, shaders, and making abilities feel powerful.","Talks in visual effects - everything SPARKLES, EXPLODES, or WHOOSHES with TRAILING PARTICLES","Juice makes games feel amazing. Visual feedback must be instant and satisfying. When in doubt, add more particles.","bmgd",""
+"bug-hunter","Glitch McGee","Lead QA Engineer","🐛","Principal QA Engineer + Bug Assassin","Legendary bug hunter with 200+ shipped titles. Finds the weirdest edge cases. Breaks games in ways devs never imagined possible.","Speaks like a detective narrator from a noir film - everything's a case, clues, suspects, and mysteries solved","If it can break, it will break. Users will do the last thing you expect. Document everything. Repro steps are sacred.","bmgd",""

package/src/modules/bmgd/teams/team-gamedev.yaml

@@ -0,0 +1,29 @@
+# <!-- Powered by BMAD-CORE™ -->
+bundle:
+  name: Team Game Development
+  icon: 🎮
+  description: Specialized game development team including Game Designer (creative vision and GDD), Game Developer (implementation and code), Game Architect (technical systems and infrastructure), Game Scrum Master (sprint coordination), Game QA (testing and quality assurance), and Game Solo Dev (quick-flow development). Perfect for game projects across all scales and platforms.
+agents:
+  - game-designer
+  - game-dev
+  - game-architect
+  - game-scrum-master
+  - game-qa
+  - game-solo-dev
+
+workflows:
+  - brainstorm-game
+  - game-brief
+  - gdd
+  - narrative
+  - game-architecture
+  - sprint-planning
+  - sprint-status
+  - create-story
+  - dev-story
+  - code-review
+  - test-framework
+  - quick-prototype
+  - quick-dev
+
+party: "./default-party.csv"

package/src/modules/bmgd/workflows/1-preproduction/brainstorm-game/instructions.md

@@ -0,0 +1,130 @@
+<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>Communicate all responses in {communication_language}</critical>
+<critical>This is a meta-workflow that orchestrates the CIS brainstorming workflow with game-specific context and additional game design techniques</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="1" goal="Validate workflow readiness" tag="workflow-status">
+    <action>Check if {output_folder}/bmgd-workflow-status.yaml exists</action>
+
+    <check if="status file not found">
+      <output>No workflow status file found. Game brainstorming is optional - you can continue without status tracking.</output>
+      <action>Set standalone_mode = true</action>
+    </check>
+
+    <check if="status file found">
+      <action>Load the FULL file: {output_folder}/bmgd-workflow-status.yaml</action>
+      <action>Parse workflow_status section</action>
+      <action>Check status of "brainstorm-game" workflow</action>
+      <action>Get project_level from YAML metadata</action>
+      <action>Find first non-completed workflow (next expected workflow)</action>
+
+      <check if="project_type != 'game'">
+        <output>Note: This is a {{project_type}} project. Game brainstorming is designed for game projects.</output>
+        <ask>Continue with game brainstorming anyway? (y/n)</ask>
+        <check if="n">
+          <action>Exit workflow</action>
+        </check>
+      </check>
+
+      <check if="brainstorm-game status is file path (already completed)">
+        <output>⚠️ Game brainstorming session already completed: {{brainstorm-game status}}</output>
+        <ask>Re-running will create a new session. Continue? (y/n)</ask>
+        <check if="n">
+          <output>Exiting. Use workflow-status to see your next step.</output>
+          <action>Exit workflow</action>
+        </check>
+      </check>
+
+      <check if="brainstorm-game is not the next expected workflow (latter items are completed already in the list)">
+        <output>⚠️ Next expected workflow: {{next_workflow}}. Game brainstorming is out of sequence.</output>
+        <ask>Continue with game brainstorming anyway? (y/n)</ask>
+        <check if="n">
+          <output>Exiting. Run {{next_workflow}} instead.</output>
+          <action>Exit workflow</action>
+        </check>
+      </check>
+
+      <action>Set standalone_mode = false</action>
+    </check>
+
+  </step>
+
+  <step n="2" goal="Load game brainstorming context and techniques">
+    <action>Read the game context document from: {game_context}</action>
+    <action>This context provides game-specific guidance including:
+      - Focus areas for game ideation (mechanics, narrative, experience, etc.)
+      - Key considerations for game design
+      - Recommended techniques for game brainstorming
+      - Output structure guidance
+    </action>
+    <action>Load game-specific brain techniques from: {game_brain_methods}</action>
+    <action>These additional techniques supplement the standard CIS brainstorming methods with game design-focused approaches like:
+      - MDA Framework exploration
+      - Core loop brainstorming
+      - Player fantasy mining
+      - Genre mashup
+      - And other game-specific ideation methods
+    </action>
+  </step>
+
+  <step n="3" goal="Invoke CIS brainstorming with game context">
+    <action>Execute the CIS brainstorming workflow with game context and additional techniques</action>
+    <invoke-workflow path="{core_brainstorming}" data="{game_context}" techniques="{game_brain_methods}">
+      The CIS brainstorming workflow will:
+      - Merge game-specific techniques with standard techniques
+      - Present interactive brainstorming techniques menu
+      - Guide the user through selected ideation methods
+      - Generate and capture brainstorming session results
+      - Save output to: {output_folder}/brainstorming-session-results-{{date}}.md
+    </invoke-workflow>
+  </step>
+
+  <step n="4" goal="Update status and complete" tag="workflow-status">
+    <check if="standalone_mode != true">
+      <action>Load the FULL file: {output_folder}/bmgd-workflow-status.yaml</action>
+      <action>Find workflow_status key "brainstorm-game"</action>
+      <critical>ONLY write the file path as the status value - no other text, notes, or metadata</critical>
+      <action>Update workflow_status["brainstorm-game"] = "{output_folder}/bmm-brainstorming-session-{{date}}.md"</action>
+      <action>Save file, preserving ALL comments and structure including STATUS DEFINITIONS</action>
+
+      <action>Find first non-completed workflow in workflow_status (next workflow to do)</action>
+      <action>Determine next agent from path file based on next workflow</action>
+    </check>
+
+    <output>**✅ Game Brainstorming Session Complete, {user_name}!**
+
+**Session Results:**
+
+- Game brainstorming results saved to: {output_folder}/bmm-brainstorming-session-{{date}}.md
+
+{{#if standalone_mode != true}}
+**Status Updated:**
+
+- Progress tracking updated: brainstorm-game marked complete
+- Next workflow: {{next_workflow}}
+  {{else}}
+  **Note:** Running in standalone mode (no progress tracking)
+  {{/if}}
+
+**Next Steps:**
+
+{{#if standalone_mode != true}}
+
+- **Next workflow:** {{next_workflow}} ({{next_agent}} agent)
+- **Optional:** You can run other analysis workflows (research, game-brief) before proceeding
+
+Check status anytime with: `workflow-status`
+{{else}}
+Since no workflow is in progress:
+
+- Refer to the BMM workflow guide if unsure what to do next
+- Or run `workflow-init` to create a workflow path and get guided next steps
+  {{/if}}
+  </output>
+  </step>
+
+</workflow>