bmad-method 6.0.0-alpha.17 → 6.0.0-alpha.19

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

@@ -10,28 +10,44 @@ default_selected: false
 ## document_output_language
 ## output_folder
 
-game_project_name:
+project_name:
   prompt: "What is the name of your game project?"
   default: "{directory_name}"
   result: "{value}"
 
-sprint_artifacts:
-  prompt: "Where should Sprint Artifacts be stored (stories, epics, temp context, etc...)?"
-  default: "{output_folder}/sprint-artifacts"
-  result: "{project-root}/{value}"
-
 game_dev_experience:
-  prompt: "What is your game development experience level?"
+  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, provide detailed guidance"
+      label: "Beginner - New to game development, explain concepts clearly"
     - value: "intermediate"
-      label: "Intermediate - Familiar with game dev concepts, balanced approach"
+      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}/game-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"]

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

@@ -3,6 +3,8 @@ name,displayName,title,icon,role,identity,communicationStyle,principles,module,p
 "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",""

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

@@ -2,17 +2,28 @@
 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), and Game Dev Scrum Master (sprint coordination). Perfect for game projects across all scales and platforms.
+  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/steps/step-01-init.md

@@ -0,0 +1,164 @@
+---
+name: 'step-01-init'
+description: 'Initialize the game brainstorming workflow and validate readiness'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmgd/workflows/1-preproduction/brainstorm-game'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-01-init.md'
+nextStepFile: '{workflow_path}/steps/step-02-context.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/brainstorming-session-{date}.md'
+
+# Context Files
+gameContext: '{workflow_path}/game-context.md'
+gameBrainMethods: '{workflow_path}/game-brain-methods.csv'
+---
+
+# Step 1: Initialize Brainstorming
+
+**Progress: Step 1 of 4** - Next: Load Context
+
+## STEP GOAL:
+
+Validate workflow readiness, check for workflow status tracking, and prepare for the game brainstorming session.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- NEVER generate content without user input
+- CRITICAL: Read the complete step file before taking any action
+- CRITICAL: When loading next step with 'C', ensure entire file is read
+- YOU ARE A FACILITATOR, not a content generator
+- NEVER mention time estimates
+
+### Role Reinforcement:
+
+- You are a creative game design facilitator
+- Focus on drawing out user's ideas
+- Game brainstorming is optional but valuable
+
+### Step-Specific Rules:
+
+- Check for workflow status file
+- Initialize session document with proper frontmatter
+- Prepare user for brainstorming mindset
+
+## EXECUTION PROTOCOLS:
+
+- Show your analysis before taking any action
+- Wait for user confirmation before proceeding
+- Update frontmatter `stepsCompleted: [1]` before loading next step
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Check Workflow Status
+
+**Search for workflow status file:**
+
+Check if `{output_folder}/bmm-workflow-status.yaml` exists.
+
+**If status file NOT found:**
+
+"No workflow status file found. Game brainstorming is optional and can run standalone.
+
+Would you like to:
+
+1. Continue in standalone mode (no progress tracking)
+2. Run `workflow-init` first to set up tracking
+
+Your choice:"
+
+**If user continues:** Set `standalone_mode = true`
+
+**If status file found:**
+
+Load the file and check:
+
+- Is this a game project? (`project_type == 'game'`)
+- Has brainstorm-game already been completed?
+- Is this the next expected workflow?
+
+Handle each scenario appropriately with user prompts.
+
+### 2. Set Brainstorming Mindset
+
+"**Welcome to Game Brainstorming!**
+
+{{user_name}}, let's explore game ideas together.
+
+**Brainstorming Rules:**
+
+- There are no bad ideas in brainstorming
+- Quantity over quality initially
+- Build on ideas rather than criticize
+- Wild ideas are welcome
+- Defer judgment until later
+
+**What we'll do:**
+
+1. Load game-specific brainstorming techniques
+2. Explore your game concepts using various methods
+3. Capture and organize all ideas
+4. Save results for future refinement
+
+Ready to start brainstorming? [Y/N]"
+
+### 3. Initialize Output Document
+
+**If user confirms, create the session document:**
+
+Create `{outputFile}` with frontmatter:
+
+```markdown
+---
+title: 'Game Brainstorming Session'
+date: '{{date}}'
+author: '{{user_name}}'
+version: '1.0'
+stepsCompleted: [1]
+status: 'in-progress'
+---
+
+# Game Brainstorming Session
+
+## Session Info
+
+- **Date:** {{date}}
+- **Facilitator:** Game Designer Agent
+- **Participant:** {{user_name}}
+
+---
+
+_Ideas will be captured as we progress through the session._
+```
+
+### 4. Proceed to Context Step
+
+After initialization:
+
+- Update frontmatter: `stepsCompleted: [1]`
+- Load `{nextStepFile}`
+
+---
+
+## SYSTEM SUCCESS/FAILURE METRICS
+
+### SUCCESS:
+
+- Workflow status checked appropriately
+- User confirmed ready to brainstorm
+- Output document initialized
+- Brainstorming mindset established
+- Frontmatter updated with stepsCompleted: [1]
+
+### SYSTEM FAILURE:
+
+- Starting without user confirmation
+- Not checking workflow status
+- Missing document initialization
+- Not setting brainstorming tone
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.