v4-v6 upgrade improvement and warning about file auto backup

bmad/bmm/workflows/3-solutioning/templates/backend-service-architecture.md

@@ -0,0 +1,66 @@
+# {{TITLE}} Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+{{technology_table}}
+
+## 2. Architecture Overview
+
+{{architecture_overview}}
+
+## 3. Data Architecture
+
+{{data_architecture}}
+
+## 4. Component and Integration Overview
+
+{{component_overview}}
+
+## 5. Architecture Decision Records
+
+{{architecture_decisions}}
+
+## 6. Implementation Guidance
+
+{{implementation_guidance}}
+
+## 7. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+## 8. Testing Strategy
+
+{{testing_strategy}}
+{{testing_specialist_section}}
+
+## 9. Deployment and Operations
+
+{{deployment_operations}}
+{{devops_specialist_section}}
+
+## 10. Security
+
+{{security}}
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/cli-tool-architecture.md

@@ -0,0 +1,66 @@
+# {{TITLE}} Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+{{technology_table}}
+
+## 2. Architecture Overview
+
+{{architecture_overview}}
+
+## 3. Data Architecture
+
+{{data_architecture}}
+
+## 4. Component and Integration Overview
+
+{{component_overview}}
+
+## 5. Architecture Decision Records
+
+{{architecture_decisions}}
+
+## 6. Implementation Guidance
+
+{{implementation_guidance}}
+
+## 7. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+## 8. Testing Strategy
+
+{{testing_strategy}}
+{{testing_specialist_section}}
+
+## 9. Deployment and Operations
+
+{{deployment_operations}}
+{{devops_specialist_section}}
+
+## 10. Security
+
+{{security}}
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/data-pipeline-architecture.md

@@ -0,0 +1,66 @@
+# {{TITLE}} Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+{{technology_table}}
+
+## 2. Architecture Overview
+
+{{architecture_overview}}
+
+## 3. Data Architecture
+
+{{data_architecture}}
+
+## 4. Component and Integration Overview
+
+{{component_overview}}
+
+## 5. Architecture Decision Records
+
+{{architecture_decisions}}
+
+## 6. Implementation Guidance
+
+{{implementation_guidance}}
+
+## 7. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+## 8. Testing Strategy
+
+{{testing_strategy}}
+{{testing_specialist_section}}
+
+## 9. Deployment and Operations
+
+{{deployment_operations}}
+{{devops_specialist_section}}
+
+## 10. Security
+
+{{security}}
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/desktop-app-architecture.md

@@ -0,0 +1,66 @@
+# {{TITLE}} Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+{{technology_table}}
+
+## 2. Architecture Overview
+
+{{architecture_overview}}
+
+## 3. Data Architecture
+
+{{data_architecture}}
+
+## 4. Component and Integration Overview
+
+{{component_overview}}
+
+## 5. Architecture Decision Records
+
+{{architecture_decisions}}
+
+## 6. Implementation Guidance
+
+{{implementation_guidance}}
+
+## 7. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+## 8. Testing Strategy
+
+{{testing_strategy}}
+{{testing_specialist_section}}
+
+## 9. Deployment and Operations
+
+{{deployment_operations}}
+{{devops_specialist_section}}
+
+## 10. Security
+
+{{security}}
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/embedded-firmware-architecture.md

@@ -0,0 +1,66 @@
+# {{TITLE}} Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+{{technology_table}}
+
+## 2. Architecture Overview
+
+{{architecture_overview}}
+
+## 3. Data Architecture
+
+{{data_architecture}}
+
+## 4. Component and Integration Overview
+
+{{component_overview}}
+
+## 5. Architecture Decision Records
+
+{{architecture_decisions}}
+
+## 6. Implementation Guidance
+
+{{implementation_guidance}}
+
+## 7. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+## 8. Testing Strategy
+
+{{testing_strategy}}
+{{testing_specialist_section}}
+
+## 9. Deployment and Operations
+
+{{deployment_operations}}
+{{devops_specialist_section}}
+
+## 10. Security
+
+{{security}}
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/game-engine-architecture.md

@@ -0,0 +1,244 @@
+# Game Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+| Category           | Technology             | Version                | Justification                |
+| ------------------ | ---------------------- | ---------------------- | ---------------------------- |
+| Game Engine        | {{game_engine}}        | {{engine_version}}     | {{engine_justification}}     |
+| Language           | {{language}}           | {{language_version}}   | {{language_justification}}   |
+| Rendering Pipeline | {{rendering_pipeline}} | {{rendering_version}}  | {{rendering_justification}}  |
+| Physics Engine     | {{physics}}            | {{physics_version}}    | {{physics_justification}}    |
+| Audio Middleware   | {{audio}}              | {{audio_version}}      | {{audio_justification}}      |
+| Networking         | {{networking}}         | {{networking_version}} | {{networking_justification}} |
+| Backend Services   | {{backend}}            | {{backend_version}}    | {{backend_justification}}    |
+| Analytics          | {{analytics}}          | {{analytics_version}}  | {{analytics_justification}}  |
+
+{{additional_tech_stack_rows}}
+
+## 2. Engine and Platform
+
+### 2.1 Game Engine Choice
+
+{{engine_choice}}
+
+### 2.2 Target Platforms
+
+{{target_platforms}}
+
+### 2.3 Rendering Pipeline
+
+{{rendering_pipeline_details}}
+
+## 3. Game Architecture
+
+### 3.1 Architecture Pattern
+
+{{architecture_pattern}}
+
+### 3.2 Scene Structure
+
+{{scene_structure}}
+
+### 3.3 Game Loop
+
+{{game_loop}}
+
+### 3.4 State Machine
+
+{{state_machine}}
+
+## 4. Scene and Level Architecture
+
+### 4.1 Scene Organization
+
+{{scene_organization}}
+
+### 4.2 Level Streaming
+
+{{level_streaming}}
+
+### 4.3 Additive Loading
+
+{{additive_loading}}
+
+### 4.4 Memory Management
+
+{{memory_management}}
+
+## 5. Gameplay Systems
+
+### 5.1 Player Controller
+
+{{player_controller}}
+
+### 5.2 Game State Management
+
+{{game_state}}
+
+### 5.3 Inventory System
+
+{{inventory}}
+
+### 5.4 Progression System
+
+{{progression}}
+
+### 5.5 Combat/Core Mechanics
+
+{{core_mechanics}}
+
+## 6. Rendering Architecture
+
+### 6.1 Rendering Pipeline
+
+{{rendering_pipeline_architecture}}
+
+### 6.2 Shaders
+
+{{shaders}}
+
+### 6.3 Post-Processing
+
+{{post_processing}}
+
+### 6.4 LOD System
+
+{{lod_system}}
+
+### 6.5 Occlusion Culling
+
+{{occlusion}}
+
+## 7. Asset Pipeline
+
+### 7.1 Model Import
+
+{{model_import}}
+
+### 7.2 Textures and Materials
+
+{{textures_materials}}
+
+### 7.3 Asset Bundles/Addressables
+
+{{asset_bundles}}
+
+### 7.4 Asset Optimization
+
+{{asset_optimization}}
+
+## 8. Animation System
+
+{{animation_system}}
+
+## 9. Physics and Collision
+
+{{physics_collision}}
+
+## 10. Multiplayer Architecture
+
+{{multiplayer_section}}
+
+**Note:** {{multiplayer_note}}
+
+## 11. Backend Services
+
+{{backend_services}}
+
+**Note:** {{backend_note}}
+
+## 12. Save System
+
+{{save_system}}
+
+## 13. UI/UX Architecture
+
+{{ui_architecture}}
+
+## 14. Audio Architecture
+
+{{audio_architecture}}
+
+{{audio_specialist_section}}
+
+## 15. Component and Integration Overview
+
+{{component_overview}}
+
+## 16. Architecture Decision Records
+
+{{architecture_decisions}}
+
+**Key decisions:**
+
+- Why this engine? {{engine_decision}}
+- ECS vs OOP? {{ecs_vs_oop_decision}}
+- Multiplayer approach? {{multiplayer_decision}}
+- Asset streaming? {{asset_streaming_decision}}
+
+## 17. Implementation Guidance
+
+### 17.1 Prefab/Blueprint Conventions
+
+{{prefab_conventions}}
+
+### 17.2 Coding Patterns
+
+{{coding_patterns}}
+
+### 17.3 Performance Guidelines
+
+{{performance_guidelines}}
+
+## 18. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+**Critical folders:**
+
+- {{critical_folder_1}}: {{critical_folder_1_description}}
+- {{critical_folder_2}}: {{critical_folder_2_description}}
+- {{critical_folder_3}}: {{critical_folder_3_description}}
+
+## 19. Performance and Optimization
+
+{{performance_optimization}}
+
+{{performance_specialist_section}}
+
+## 20. Testing Strategy
+
+{{testing_strategy}}
+
+## 21. Build and Distribution
+
+{{build_distribution}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+### Recommended Specialists:
+
+- {{audio_specialist_recommendation}}
+- {{performance_specialist_recommendation}}
+- {{multiplayer_specialist_recommendation}}
+- {{monetization_specialist_recommendation}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/game-engine-godot-guide.md

@@ -0,0 +1,428 @@
+# Godot Game Engine Architecture Guide
+
+This guide provides Godot-specific guidance for solution architecture generation.
+
+---
+
+## Godot-Specific Questions
+
+### 1. Godot Version and Language Strategy
+
+**Ask:**
+
+- Which Godot version? (3.x, 4.x)
+- Language preference? (GDScript only, C# only, or Mixed GDScript+C#)
+- Target platform(s)? (PC, Mobile, Web, Console)
+
+**Guidance:**
+
+- **Godot 4.x**: Modern, Vulkan renderer, better 3D, C# improving
+- **Godot 3.x**: Stable, mature ecosystem, OpenGL
+- **GDScript**: Python-like, fast iteration, integrated with editor
+- **C#**: Better performance for complex systems, familiar to Unity devs
+- **Mixed**: GDScript for game logic, C# for performance-critical (physics, AI)
+
+**Record ADR:** Godot version and language strategy
+
+---
+
+### 2. Node-Based Architecture
+
+**Ask:**
+
+- Scene composition strategy? (Nested scenes, scene inheritance, or flat hierarchy)
+- Node organization patterns? (By feature, by type, or hybrid)
+
+**Guidance:**
+
+- **Scenes as Prefabs**: Each reusable entity is a scene (Player.tscn, Enemy.tscn)
+- **Scene Inheritance**: Extend base scenes for variations (BaseEnemy → FlyingEnemy)
+- **Node Signals**: Use built-in signal system for decoupled communication
+- **Autoload Singletons**: For global managers (GameManager, AudioManager)
+
+**Godot Pattern:**
+
+```gdscript
+# Player.gd
+extends CharacterBody2D
+
+signal health_changed(new_health)
+signal died
+
+@export var max_health: int = 100
+var health: int = max_health
+
+func take_damage(amount: int) -> void:
+    health -= amount
+    health_changed.emit(health)
+    if health <= 0:
+        died.emit()
+        queue_free()
+```
+
+**Record ADR:** Scene architecture and node organization
+
+---
+
+### 3. Resource Management
+
+**Ask:**
+
+- Use Godot Resources for data? (Custom Resource types for game data)
+- Asset loading strategy? (preload vs load vs ResourceLoader)
+
+**Guidance:**
+
+- **Resources**: Like Unity ScriptableObjects, serializable data containers
+- **preload()**: Load at compile time (fast, but increases binary size)
+- **load()**: Load at runtime (slower, but smaller binary)
+- **ResourceLoader.load_threaded_request()**: Async loading for large assets
+
+**Pattern:**
+
+```gdscript
+# EnemyData.gd
+class_name EnemyData
+extends Resource
+
+@export var enemy_name: String
+@export var health: int
+@export var speed: float
+@export var prefab_scene: PackedScene
+```
+
+**Record ADR:** Resource and asset loading strategy
+
+---
+
+## Godot-Specific Architecture Sections
+
+### Signal-Driven Communication
+
+**Godot's built-in Observer pattern:**
+
+```gdscript
+# GameManager.gd (Autoload singleton)
+extends Node
+
+signal game_started
+signal game_paused
+signal game_over(final_score: int)
+
+func start_game() -> void:
+    game_started.emit()
+
+func pause_game() -> void:
+    get_tree().paused = true
+    game_paused.emit()
+
+# In Player.gd
+func _ready() -> void:
+    GameManager.game_started.connect(_on_game_started)
+    GameManager.game_over.connect(_on_game_over)
+
+func _on_game_started() -> void:
+    position = Vector2.ZERO
+    health = max_health
+```
+
+**Benefits:**
+
+- Decoupled systems
+- No FindNode or get_node everywhere
+- Type-safe with typed signals (Godot 4)
+
+---
+
+### Godot Scene Architecture
+
+**Scene organization patterns:**
+
+**1. Composition Pattern:**
+
+```
+Player (CharacterBody2D)
+├── Sprite2D
+├── CollisionShape2D
+├── AnimationPlayer
+├── HealthComponent (Node - custom script)
+├── InputComponent (Node - custom script)
+└── WeaponMount (Node2D)
+    └── Weapon (instanced scene)
+```
+
+**2. Scene Inheritance:**
+
+```
+BaseEnemy.tscn
+├── Inherits → FlyingEnemy.tscn (adds wings, aerial movement)
+└── Inherits → GroundEnemy.tscn (adds ground collision)
+```
+
+**3. Autoload Singletons:**
+
+```
+# In Project Settings > Autoload:
+GameManager → res://scripts/managers/game_manager.gd
+AudioManager → res://scripts/managers/audio_manager.gd
+SaveManager → res://scripts/managers/save_manager.gd
+```
+
+---
+
+### Performance Optimization
+
+**Godot-specific considerations:**
+
+- **Static Typing**: Use type hints for GDScript performance (`var health: int = 100`)
+- **Object Pooling**: Implement manually or use addons
+- **CanvasItem batching**: Reduce draw calls with texture atlases
+- **Viewport rendering**: Offload effects to separate viewports
+- **GDScript vs C#**: C# faster for heavy computation, GDScript faster for simple logic
+
+**Target Performance:**
+
+- **PC**: 60 FPS minimum
+- **Mobile**: 60 FPS (high-end), 30 FPS (low-end)
+- **Web**: 30-60 FPS depending on complexity
+
+**Profiler:**
+
+- Use Godot's built-in profiler (Debug > Profiler)
+- Monitor FPS, draw calls, physics time
+
+---
+
+### Testing Strategy
+
+**GUT (Godot Unit Test):**
+
+```gdscript
+# test_player.gd
+extends GutTest
+
+func test_player_takes_damage():
+    var player = Player.new()
+    add_child(player)
+    player.health = 100
+
+    player.take_damage(20)
+
+    assert_eq(player.health, 80, "Player health should decrease")
+```
+
+**GoDotTest for C#:**
+
+```csharp
+[Test]
+public void PlayerTakesDamage_DecreasesHealth()
+{
+    var player = new Player();
+    player.Health = 100;
+
+    player.TakeDamage(20);
+
+    Assert.That(player.Health, Is.EqualTo(80));
+}
+```
+
+**Recommended Coverage:**
+
+- 80% minimum test coverage (from expansion pack)
+- Test game systems, not rendering
+- Use GUT for GDScript, GoDotTest for C#
+
+---
+
+### Source Tree Structure
+
+**Godot-specific folders:**
+
+```
+project/
+├── scenes/              # All .tscn scene files
+│   ├── main_menu.tscn
+│   ├── levels/
+│   │   ├── level_1.tscn
+│   │   └── level_2.tscn
+│   ├── player/
+│   │   └── player.tscn
+│   └── enemies/
+│       ├── base_enemy.tscn
+│       └── flying_enemy.tscn
+├── scripts/             # GDScript and C# files
+│   ├── player/
+│   │   ├── player.gd
+│   │   └── player_input.gd
+│   ├── enemies/
+│   ├── managers/
+│   │   ├── game_manager.gd  (Autoload)
+│   │   └── audio_manager.gd (Autoload)
+│   └── ui/
+├── resources/           # Custom Resource types
+│   ├── enemy_data.gd
+│   └── level_data.gd
+├── assets/
+│   ├── sprites/
+│   ├── textures/
+│   ├── audio/
+│   │   ├── music/
+│   │   └── sfx/
+│   ├── fonts/
+│   └── shaders/
+├── addons/              # Godot plugins
+└── project.godot        # Project settings
+```
+
+---
+
+### Deployment and Build
+
+**Platform-specific:**
+
+- **PC**: Export presets for Windows, Linux, macOS
+- **Mobile**: Android (APK/AAB), iOS (Xcode project)
+- **Web**: HTML5 export (SharedArrayBuffer requirements)
+- **Console**: Partner programs for Switch, Xbox, PlayStation
+
+**Export templates:**
+
+- Download from Godot website for each platform
+- Configure export presets in Project > Export
+
+**Build automation:**
+
+- Use `godot --export` command-line for CI/CD
+- Example: `godot --export-release "Windows Desktop" output/game.exe`
+
+---
+
+## Specialist Recommendations
+
+### Audio Designer
+
+**When needed:** Games with music, sound effects, ambience
+**Responsibilities:**
+
+- AudioStreamPlayer node architecture (2D vs 3D audio)
+- Audio bus setup in Godot's audio mixer
+- Music transitions with AudioStreamPlayer.finished signal
+- Sound effect implementation
+- Audio performance optimization
+
+### Performance Optimizer
+
+**When needed:** Mobile games, large-scale games, complex 3D
+**Responsibilities:**
+
+- Godot profiler analysis
+- Static typing optimization
+- Draw call reduction
+- Physics optimization (collision layers/masks)
+- Memory management
+- C# performance optimization for heavy systems
+
+### Multiplayer Architect
+
+**When needed:** Multiplayer/co-op games
+**Responsibilities:**
+
+- High-level multiplayer API or ENet
+- RPC architecture (remote procedure calls)
+- State synchronization patterns
+- Client-server vs peer-to-peer
+- Anti-cheat considerations
+- Latency compensation
+
+### Monetization Specialist
+
+**When needed:** F2P, mobile games with IAP
+**Responsibilities:**
+
+- In-app purchase integration (via plugins)
+- Ad network integration
+- Analytics integration
+- Economy design
+- Godot-specific monetization patterns
+
+---
+
+## Common Pitfalls
+
+1. **Over-using get_node()** - Cache node references in `@onready` variables
+2. **Not using type hints** - Static typing improves GDScript performance
+3. **Deep node hierarchies** - Keep scene trees shallow for performance
+4. **Ignoring signals** - Use signals instead of polling or direct coupling
+5. **Not leveraging autoload** - Use autoload singletons for global state
+6. **Poor scene organization** - Plan scene structure before building
+7. **Forgetting to queue_free()** - Memory leaks from unreleased nodes
+
+---
+
+## Godot vs Unity Differences
+
+### Architecture Differences:
+
+| Unity                  | Godot          | Notes                                   |
+| ---------------------- | -------------- | --------------------------------------- |
+| GameObject + Component | Node hierarchy | Godot nodes have built-in functionality |
+| MonoBehaviour          | Node + Script  | Attach scripts to nodes                 |
+| ScriptableObject       | Resource       | Custom data containers                  |
+| UnityEvent             | Signal         | Godot signals are built-in              |
+| Prefab                 | Scene (.tscn)  | Scenes are reusable like prefabs        |
+| Singleton pattern      | Autoload       | Built-in singleton system               |
+
+### Language Differences:
+
+| Unity C#                              | GDScript                                    | Notes                       |
+| ------------------------------------- | ------------------------------------------- | --------------------------- |
+| `public class Player : MonoBehaviour` | `class_name Player extends CharacterBody2D` | GDScript more concise       |
+| `void Start()`                        | `func _ready():`                            | Initialization              |
+| `void Update()`                       | `func _process(delta):`                     | Per-frame update            |
+| `void FixedUpdate()`                  | `func _physics_process(delta):`             | Physics update              |
+| `[SerializeField]`                    | `@export`                                   | Inspector-visible variables |
+| `GetComponent<T>()`                   | `get_node("NodeName")` or `$NodeName`       | Node access                 |
+
+---
+
+## Key Architecture Decision Records
+
+### ADR Template for Godot Projects
+
+**ADR-XXX: [Title]**
+
+**Context:**
+What Godot-specific issue are we solving?
+
+**Options:**
+
+1. GDScript solution
+2. C# solution
+3. GDScript + C# hybrid
+4. Third-party addon (Godot Asset Library)
+
+**Decision:**
+We chose [Option X]
+
+**Godot-specific Rationale:**
+
+- GDScript vs C# performance tradeoffs
+- Engine integration (signals, nodes, resources)
+- Community support and addons
+- Team expertise
+- Platform compatibility
+
+**Consequences:**
+
+- Impact on performance
+- Learning curve
+- Maintenance considerations
+- Platform limitations (Web export with C#)
+
+---
+
+_This guide is specific to Godot Engine. For other engines, see:_
+
+- game-engine-unity-guide.md
+- game-engine-unreal-guide.md
+- game-engine-web-guide.md

bmad/bmm/workflows/3-solutioning/templates/game-engine-unity-guide.md

@@ -0,0 +1,333 @@
+# Unity Game Engine Architecture Guide
+
+This guide provides Unity-specific guidance for solution architecture generation.
+
+---
+
+## Unity-Specific Questions
+
+### 1. Unity Version and Render Pipeline
+
+**Ask:**
+
+- Which Unity version are you targeting? (2021 LTS, 2022 LTS, 2023+, 6000+)
+- Which render pipeline? (Built-in, URP Universal Render Pipeline, HDRP High Definition)
+- Target platform(s)? (PC, Mobile, Console, WebGL)
+
+**Guidance:**
+
+- **2021/2022 LTS**: Stable, well-supported, good for production
+- **URP**: Best for mobile and cross-platform (lower overhead)
+- **HDRP**: High-fidelity graphics for PC/console only
+- **Built-in**: Legacy, avoid for new projects
+
+**Record ADR:** Unity version and render pipeline choice
+
+---
+
+### 2. Architecture Pattern
+
+**Ask:**
+
+- Component-based MonoBehaviour architecture? (Unity standard)
+- ECS (Entity Component System) for performance-critical systems?
+- Hybrid (MonoBehaviour + ECS where needed)?
+
+**Guidance:**
+
+- **MonoBehaviour**: Standard, easy to use, good for most games
+- **ECS/DOTS**: High performance, steep learning curve, use for massive scale (1000s of entities)
+- **Hybrid**: MonoBehaviour for gameplay, ECS for particles/crowds
+
+**Record ADR:** Architecture pattern choice and justification
+
+---
+
+### 3. Data Management Strategy
+
+**Ask:**
+
+- ScriptableObjects for data-driven design?
+- JSON/XML config files?
+- Addressables for asset management?
+
+**Guidance:**
+
+- **ScriptableObjects**: Unity-native, inspector-friendly, good for game data (enemies, items, levels)
+- **Addressables**: Essential for large games, enables asset streaming and DLC
+- Avoid Resources folder (deprecated pattern)
+
+**Record ADR:** Data management approach
+
+---
+
+## Unity-Specific Architecture Sections
+
+### Game Systems Architecture
+
+**Components to define:**
+
+- **Player Controller**: Character movement, input handling
+- **Camera System**: Follow camera, cinemachine usage
+- **Game State Manager**: Scene transitions, game modes, pause/resume
+- **Save System**: PlayerPrefs vs JSON vs Cloud Save
+- **Input System**: New Input System vs Legacy
+
+**Unity-specific patterns:**
+
+```csharp
+// Singleton GameManager pattern
+public class GameManager : MonoBehaviour
+{
+    public static GameManager Instance { get; private set; }
+
+    void Awake()
+    {
+        if (Instance == null) Instance = this;
+        else Destroy(gameObject);
+        DontDestroyOnLoad(gameObject);
+    }
+}
+
+// ScriptableObject data pattern
+[CreateAssetMenu(fileName = "EnemyData", menuName = "Game/Enemy")]
+public class EnemyData : ScriptableObject
+{
+    public string enemyName;
+    public int health;
+    public float speed;
+    public GameObject prefab;
+}
+```
+
+---
+
+### Unity Events and Communication
+
+**Ask:**
+
+- UnityEvents for inspector-wired connections?
+- C# Events for code-based pub/sub?
+- Message system for decoupled communication?
+
+**Guidance:**
+
+- **UnityEvents**: Good for designer-configurable connections
+- **C# Events**: Better performance, type-safe
+- **Avoid** FindObjectOfType and GetComponent in Update()
+
+**Pattern:**
+
+```csharp
+// Event-driven damage system
+public class HealthSystem : MonoBehaviour
+{
+    public UnityEvent<int> OnDamaged;
+    public UnityEvent OnDeath;
+
+    public void TakeDamage(int amount)
+    {
+        health -= amount;
+        OnDamaged?.Invoke(amount);
+        if (health <= 0) OnDeath?.Invoke();
+    }
+}
+```
+
+---
+
+### Performance Optimization
+
+**Unity-specific considerations:**
+
+- **Object Pooling**: Essential for bullets, particles, enemies
+- **Sprite Batching**: Use sprite atlases, minimize draw calls
+- **Physics Optimization**: Layer-based collision matrix
+- **Profiler Usage**: CPU, GPU, Memory, Physics profilers
+- **IL2CPP vs Mono**: Build performance differences
+
+**Target Performance:**
+
+- Mobile: 60 FPS minimum (30 FPS for complex 3D)
+- PC: 60 FPS minimum
+- Monitor with Unity Profiler
+
+---
+
+### Testing Strategy
+
+**Unity Test Framework:**
+
+- **Edit Mode Tests**: Test pure C# logic, no Unity lifecycle
+- **Play Mode Tests**: Test MonoBehaviour components in play mode
+- Use `[UnityTest]` attribute for coroutine tests
+- Mock Unity APIs with interfaces
+
+**Example:**
+
+```csharp
+[UnityTest]
+public IEnumerator Player_TakesDamage_DecreasesHealth()
+{
+    var player = new GameObject().AddComponent<Player>();
+    player.health = 100;
+
+    player.TakeDamage(20);
+
+    yield return null; // Wait one frame
+
+    Assert.AreEqual(80, player.health);
+}
+```
+
+---
+
+### Source Tree Structure
+
+**Unity-specific folders:**
+
+```
+Assets/
+├── Scenes/              # All .unity scene files
+│   ├── MainMenu.unity
+│   ├── Level1.unity
+│   └── Level2.unity
+├── Scripts/             # All C# code
+│   ├── Player/
+│   ├── Enemies/
+│   ├── Managers/
+│   ├── UI/
+│   └── Utilities/
+├── Prefabs/             # Reusable game objects
+├── ScriptableObjects/   # Game data assets
+│   ├── Enemies/
+│   ├── Items/
+│   └── Levels/
+├── Materials/
+├── Textures/
+├── Audio/
+│   ├── Music/
+│   └── SFX/
+├── Fonts/
+├── Animations/
+├── Resources/           # Avoid - use Addressables instead
+└── Plugins/             # Third-party SDKs
+```
+
+---
+
+### Deployment and Build
+
+**Platform-specific:**
+
+- **PC**: Standalone builds (Windows/Mac/Linux)
+- **Mobile**: IL2CPP mandatory for iOS, recommended for Android
+- **WebGL**: Compression, memory limitations
+- **Console**: Platform-specific SDKs and certification
+
+**Build pipeline:**
+
+- Unity Cloud Build OR
+- CI/CD with command-line builds: `Unity -batchmode -buildTarget ...`
+
+---
+
+## Specialist Recommendations
+
+### Audio Designer
+
+**When needed:** Games with music, sound effects, ambience
+**Responsibilities:**
+
+- Audio system architecture (2D vs 3D audio)
+- Audio mixer setup
+- Music transitions and adaptive audio
+- Sound effect implementation
+- Audio performance optimization
+
+### Performance Optimizer
+
+**When needed:** Mobile games, large-scale games, VR
+**Responsibilities:**
+
+- Profiling and optimization
+- Memory management
+- Draw call reduction
+- Physics optimization
+- Asset optimization (textures, meshes, audio)
+
+### Multiplayer Architect
+
+**When needed:** Multiplayer/co-op games
+**Responsibilities:**
+
+- Netcode architecture (Netcode for GameObjects, Mirror, Photon)
+- Client-server vs peer-to-peer
+- State synchronization
+- Anti-cheat considerations
+- Latency compensation
+
+### Monetization Specialist
+
+**When needed:** F2P, mobile games with IAP
+**Responsibilities:**
+
+- Unity IAP integration
+- Ad network integration (AdMob, Unity Ads)
+- Analytics integration
+- Economy design (virtual currency, shop)
+
+---
+
+## Common Pitfalls
+
+1. **Over-using GetComponent** - Cache references in Awake/Start
+2. **Empty Update methods** - Remove them, they have overhead
+3. **String comparisons for tags** - Use CompareTag() instead
+4. **Resources folder abuse** - Migrate to Addressables
+5. **Not using object pooling** - Instantiate/Destroy is expensive
+6. **Ignoring the Profiler** - Profile early, profile often
+7. **Not testing on target hardware** - Mobile performance differs vastly
+
+---
+
+## Key Architecture Decision Records
+
+### ADR Template for Unity Projects
+
+**ADR-XXX: [Title]**
+
+**Context:**
+What Unity-specific issue are we solving?
+
+**Options:**
+
+1. Unity Built-in Solution (e.g., Built-in Input System)
+2. Unity Package (e.g., New Input System)
+3. Third-party Asset (e.g., Rewired)
+4. Custom Implementation
+
+**Decision:**
+We chose [Option X]
+
+**Unity-specific Rationale:**
+
+- Version compatibility
+- Performance characteristics
+- Community support
+- Asset Store availability
+- License considerations
+
+**Consequences:**
+
+- Impact on build size
+- Platform compatibility
+- Learning curve for team
+
+---
+
+_This guide is specific to Unity Engine. For other engines, see:_
+
+- game-engine-godot-guide.md
+- game-engine-unreal-guide.md
+- game-engine-web-guide.md

bmad/bmm/workflows/3-solutioning/templates/game-engine-web-guide.md

@@ -0,0 +1,528 @@
+# Web Game Engine Architecture Guide
+
+This guide provides web game engine-specific guidance (Phaser, PixiJS, Three.js, Babylon.js) for solution architecture generation.
+
+---
+
+## Web Game-Specific Questions
+
+### 1. Engine and Technology Selection
+
+**Ask:**
+
+- Which engine? (Phaser 3, PixiJS, Three.js, Babylon.js, custom Canvas/WebGL)
+- TypeScript or JavaScript?
+- Build tool? (Vite, Webpack, Rollup, Parcel)
+- Target platform(s)? (Desktop web, mobile web, PWA, Cordova/Capacitor wrapper)
+
+**Guidance:**
+
+- **Phaser 3**: Full-featured 2D game framework, great for beginners
+- **PixiJS**: 2D rendering library, more low-level than Phaser
+- **Three.js**: 3D graphics library, mature ecosystem
+- **Babylon.js**: Complete 3D game engine, WebXR support
+- **TypeScript**: Recommended for all web games (type safety, better tooling)
+- **Vite**: Modern, fast, HMR - best for development
+
+**Record ADR:** Engine selection and build tooling
+
+---
+
+### 2. Architecture Pattern
+
+**Ask:**
+
+- Scene-based architecture? (Phaser scenes, custom scene manager)
+- ECS (Entity Component System)? (Libraries: bitECS, ecsy)
+- State management? (Redux, Zustand, custom FSM)
+
+**Guidance:**
+
+- **Scene-based**: Natural for Phaser, good for level-based games
+- **ECS**: Better performance for large entity counts (100s+)
+- **FSM**: Good for simple state transitions (menu → game → gameover)
+
+**Phaser Pattern:**
+
+```typescript
+// MainMenuScene.ts
+export class MainMenuScene extends Phaser.Scene {
+  constructor() {
+    super({ key: 'MainMenu' });
+  }
+
+  create() {
+    this.add.text(400, 300, 'Main Menu', { fontSize: '32px' });
+
+    const startButton = this.add
+      .text(400, 400, 'Start Game', { fontSize: '24px' })
+      .setInteractive()
+      .on('pointerdown', () => {
+        this.scene.start('GameScene');
+      });
+  }
+}
+```
+
+**Record ADR:** Architecture pattern and scene management
+
+---
+
+### 3. Asset Management
+
+**Ask:**
+
+- Asset loading strategy? (Preload all, lazy load, progressive)
+- Texture atlas usage? (TexturePacker, built-in tools)
+- Audio format strategy? (MP3, OGG, WebM)
+
+**Guidance:**
+
+- **Preload**: Load all assets at start (simple, small games)
+- **Lazy load**: Load per-level (better for larger games)
+- **Texture atlases**: Essential for performance (reduce draw calls)
+- **Audio**: MP3 for compatibility, OGG for smaller size, use both
+
+**Phaser loading:**
+
+```typescript
+class PreloadScene extends Phaser.Scene {
+  preload() {
+    // Show progress bar
+    this.load.on('progress', (value: number) => {
+      console.log('Loading: ' + Math.round(value * 100) + '%');
+    });
+
+    // Load assets
+    this.load.atlas('sprites', 'assets/sprites.png', 'assets/sprites.json');
+    this.load.audio('music', ['assets/music.mp3', 'assets/music.ogg']);
+    this.load.audio('jump', ['assets/sfx/jump.mp3', 'assets/sfx/jump.ogg']);
+  }
+
+  create() {
+    this.scene.start('MainMenu');
+  }
+}
+```
+
+**Record ADR:** Asset loading and management strategy
+
+---
+
+## Web Game-Specific Architecture Sections
+
+### Performance Optimization
+
+**Web-specific considerations:**
+
+- **Object Pooling**: Mandatory for bullets, particles, enemies (avoid GC pauses)
+- **Sprite Batching**: Use texture atlases, minimize state changes
+- **Canvas vs WebGL**: WebGL for better performance (most games)
+- **Draw Call Reduction**: Batch similar sprites, use sprite sheets
+- **Memory Management**: Watch heap size, profile with Chrome DevTools
+
+**Object Pooling Pattern:**
+
+```typescript
+class BulletPool {
+  private pool: Bullet[] = [];
+  private scene: Phaser.Scene;
+
+  constructor(scene: Phaser.Scene, size: number) {
+    this.scene = scene;
+    for (let i = 0; i < size; i++) {
+      const bullet = new Bullet(scene);
+      bullet.setActive(false).setVisible(false);
+      this.pool.push(bullet);
+    }
+  }
+
+  spawn(x: number, y: number, velocityX: number, velocityY: number): Bullet | null {
+    const bullet = this.pool.find((b) => !b.active);
+    if (bullet) {
+      bullet.spawn(x, y, velocityX, velocityY);
+    }
+    return bullet || null;
+  }
+}
+```
+
+**Target Performance:**
+
+- **Desktop**: 60 FPS minimum
+- **Mobile**: 60 FPS (high-end), 30 FPS (low-end)
+- **Profile with**: Chrome DevTools Performance tab, Phaser Debug plugin
+
+---
+
+### Input Handling
+
+**Multi-input support:**
+
+```typescript
+class GameScene extends Phaser.Scene {
+  private cursors?: Phaser.Types.Input.Keyboard.CursorKeys;
+  private wasd?: { [key: string]: Phaser.Input.Keyboard.Key };
+
+  create() {
+    // Keyboard
+    this.cursors = this.input.keyboard?.createCursorKeys();
+    this.wasd = this.input.keyboard?.addKeys('W,S,A,D') as any;
+
+    // Mouse/Touch
+    this.input.on('pointerdown', (pointer: Phaser.Input.Pointer) => {
+      this.handleClick(pointer.x, pointer.y);
+    });
+
+    // Gamepad (optional)
+    this.input.gamepad?.on('down', (pad, button, index) => {
+      this.handleGamepadButton(button);
+    });
+  }
+
+  update() {
+    // Handle keyboard input
+    if (this.cursors?.left.isDown || this.wasd?.A.isDown) {
+      this.player.moveLeft();
+    }
+  }
+}
+```
+
+---
+
+### State Persistence
+
+**LocalStorage pattern:**
+
+```typescript
+interface GameSaveData {
+  level: number;
+  score: number;
+  playerStats: {
+    health: number;
+    lives: number;
+  };
+}
+
+class SaveManager {
+  private static SAVE_KEY = 'game_save_data';
+
+  static save(data: GameSaveData): void {
+    localStorage.setItem(this.SAVE_KEY, JSON.stringify(data));
+  }
+
+  static load(): GameSaveData | null {
+    const data = localStorage.getItem(this.SAVE_KEY);
+    return data ? JSON.parse(data) : null;
+  }
+
+  static clear(): void {
+    localStorage.removeItem(this.SAVE_KEY);
+  }
+}
+```
+
+---
+
+### Source Tree Structure
+
+**Phaser + TypeScript + Vite:**
+
+```
+project/
+├── public/              # Static assets
+│   ├── assets/
+│   │   ├── sprites/
+│   │   ├── audio/
+│   │   │   ├── music/
+│   │   │   └── sfx/
+│   │   └── fonts/
+│   └── index.html
+├── src/
+│   ├── main.ts         # Game initialization
+│   ├── config.ts       # Phaser config
+│   ├── scenes/         # Game scenes
+│   │   ├── PreloadScene.ts
+│   │   ├── MainMenuScene.ts
+│   │   ├── GameScene.ts
+│   │   └── GameOverScene.ts
+│   ├── entities/       # Game objects
+│   │   ├── Player.ts
+│   │   ├── Enemy.ts
+│   │   └── Bullet.ts
+│   ├── systems/        # Game systems
+│   │   ├── InputManager.ts
+│   │   ├── AudioManager.ts
+│   │   └── SaveManager.ts
+│   ├── utils/          # Utilities
+│   │   ├── ObjectPool.ts
+│   │   └── Constants.ts
+│   └── types/          # TypeScript types
+│       └── index.d.ts
+├── tests/              # Unit tests
+├── package.json
+├── tsconfig.json
+├── vite.config.ts
+└── README.md
+```
+
+---
+
+### Testing Strategy
+
+**Jest + TypeScript:**
+
+```typescript
+// Player.test.ts
+import { Player } from '../entities/Player';
+
+describe('Player', () => {
+  let player: Player;
+
+  beforeEach(() => {
+    // Mock Phaser scene
+    const mockScene = {
+      add: { sprite: jest.fn() },
+      physics: { add: { sprite: jest.fn() } },
+    } as any;
+
+    player = new Player(mockScene, 0, 0);
+  });
+
+  test('takes damage correctly', () => {
+    player.health = 100;
+    player.takeDamage(20);
+    expect(player.health).toBe(80);
+  });
+
+  test('dies when health reaches zero', () => {
+    player.health = 10;
+    player.takeDamage(20);
+    expect(player.alive).toBe(false);
+  });
+});
+```
+
+**E2E Testing:**
+
+- Playwright for browser automation
+- Cypress for interactive testing
+- Test game states, not individual frames
+
+---
+
+### Deployment and Build
+
+**Build for production:**
+
+```json
+// package.json scripts
+{
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc andand vite build",
+    "preview": "vite preview",
+    "test": "jest"
+  }
+}
+```
+
+**Deployment targets:**
+
+- **Static hosting**: Netlify, Vercel, GitHub Pages, AWS S3
+- **CDN**: Cloudflare, Fastly for global distribution
+- **PWA**: Service worker for offline play
+- **Mobile wrapper**: Cordova or Capacitor for app stores
+
+**Optimization:**
+
+```typescript
+// vite.config.ts
+export default defineConfig({
+  build: {
+    rollupOptions: {
+      output: {
+        manualChunks: {
+          phaser: ['phaser'], // Separate Phaser bundle
+        },
+      },
+    },
+    minify: 'terser',
+    terserOptions: {
+      compress: {
+        drop_console: true, // Remove console.log in prod
+      },
+    },
+  },
+});
+```
+
+---
+
+## Specialist Recommendations
+
+### Audio Designer
+
+**When needed:** Games with music, sound effects, ambience
+**Responsibilities:**
+
+- Web Audio API architecture
+- Audio sprite creation (combine sounds into one file)
+- Music loop management
+- Sound effect implementation
+- Audio performance on web (decode strategy)
+
+### Performance Optimizer
+
+**When needed:** Mobile web games, complex games
+**Responsibilities:**
+
+- Chrome DevTools profiling
+- Object pooling implementation
+- Draw call optimization
+- Memory management
+- Bundle size optimization
+- Network performance (asset loading)
+
+### Monetization Specialist
+
+**When needed:** F2P web games
+**Responsibilities:**
+
+- Ad network integration (Google AdSense, AdMob for web)
+- In-game purchases (Stripe, PayPal)
+- Analytics (Google Analytics, custom events)
+- A/B testing frameworks
+- Economy design
+
+### Platform Specialist
+
+**When needed:** Mobile wrapper apps (Cordova/Capacitor)
+**Responsibilities:**
+
+- Native plugin integration
+- Platform-specific performance tuning
+- App store submission
+- Device compatibility testing
+- Push notification setup
+
+---
+
+## Common Pitfalls
+
+1. **Not using object pooling** - Frequent instantiation causes GC pauses
+2. **Too many draw calls** - Use texture atlases and sprite batching
+3. **Loading all assets at once** - Causes long initial load times
+4. **Not testing on mobile** - Performance vastly different on phones
+5. **Ignoring bundle size** - Large bundles = slow load times
+6. **Not handling window resize** - Web games run in resizable windows
+7. **Forgetting audio autoplay restrictions** - Browsers block auto-play without user interaction
+
+---
+
+## Engine-Specific Patterns
+
+### Phaser 3
+
+```typescript
+const config: Phaser.Types.Core.GameConfig = {
+  type: Phaser.AUTO, // WebGL with Canvas fallback
+  width: 800,
+  height: 600,
+  physics: {
+    default: 'arcade',
+    arcade: { gravity: { y: 300 }, debug: false },
+  },
+  scene: [PreloadScene, MainMenuScene, GameScene, GameOverScene],
+};
+
+const game = new Phaser.Game(config);
+```
+
+### PixiJS
+
+```typescript
+const app = new PIXI.Application({
+  width: 800,
+  height: 600,
+  backgroundColor: 0x1099bb,
+});
+
+document.body.appendChild(app.view);
+
+const sprite = PIXI.Sprite.from('assets/player.png');
+app.stage.addChild(sprite);
+
+app.ticker.add((delta) => {
+  sprite.rotation += 0.01 * delta;
+});
+```
+
+### Three.js
+
+```typescript
+const scene = new THREE.Scene();
+const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+const renderer = new THREE.WebGLRenderer();
+
+renderer.setSize(window.innerWidth, window.innerHeight);
+document.body.appendChild(renderer.domElement);
+
+const geometry = new THREE.BoxGeometry();
+const material = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
+const cube = new THREE.Mesh(geometry, material);
+scene.add(cube);
+
+function animate() {
+  requestAnimationFrame(animate);
+  cube.rotation.x += 0.01;
+  renderer.render(scene, camera);
+}
+animate();
+```
+
+---
+
+## Key Architecture Decision Records
+
+### ADR Template for Web Games
+
+**ADR-XXX: [Title]**
+
+**Context:**
+What web game-specific issue are we solving?
+
+**Options:**
+
+1. Phaser 3 (full framework)
+2. PixiJS (rendering library)
+3. Three.js/Babylon.js (3D)
+4. Custom Canvas/WebGL
+
+**Decision:**
+We chose [Option X]
+
+**Web-specific Rationale:**
+
+- Engine features vs bundle size
+- Community and plugin ecosystem
+- TypeScript support
+- Performance on target devices (mobile web)
+- Browser compatibility
+- Development velocity
+
+**Consequences:**
+
+- Impact on bundle size (Phaser ~1.2MB gzipped)
+- Learning curve
+- Platform limitations
+- Plugin availability
+
+---
+
+_This guide is specific to web game engines. For native engines, see:_
+
+- game-engine-unity-guide.md
+- game-engine-godot-guide.md
+- game-engine-unreal-guide.md

bmad/bmm/workflows/3-solutioning/templates/infrastructure-architecture.md

@@ -0,0 +1,66 @@
+# {{TITLE}} Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+{{technology_table}}
+
+## 2. Architecture Overview
+
+{{architecture_overview}}
+
+## 3. Data Architecture
+
+{{data_architecture}}
+
+## 4. Component and Integration Overview
+
+{{component_overview}}
+
+## 5. Architecture Decision Records
+
+{{architecture_decisions}}
+
+## 6. Implementation Guidance
+
+{{implementation_guidance}}
+
+## 7. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+## 8. Testing Strategy
+
+{{testing_strategy}}
+{{testing_specialist_section}}
+
+## 9. Deployment and Operations
+
+{{deployment_operations}}
+{{devops_specialist_section}}
+
+## 10. Security
+
+{{security}}
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/library-package-architecture.md

@@ -0,0 +1,66 @@
+# {{TITLE}} Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+{{technology_table}}
+
+## 2. Architecture Overview
+
+{{architecture_overview}}
+
+## 3. Data Architecture
+
+{{data_architecture}}
+
+## 4. Component and Integration Overview
+
+{{component_overview}}
+
+## 5. Architecture Decision Records
+
+{{architecture_decisions}}
+
+## 6. Implementation Guidance
+
+{{implementation_guidance}}
+
+## 7. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+## 8. Testing Strategy
+
+{{testing_strategy}}
+{{testing_specialist_section}}
+
+## 9. Deployment and Operations
+
+{{deployment_operations}}
+{{devops_specialist_section}}
+
+## 10. Security
+
+{{security}}
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/mobile-app-architecture.md

@@ -0,0 +1,66 @@
+# {{TITLE}} Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+{{technology_table}}
+
+## 2. Architecture Overview
+
+{{architecture_overview}}
+
+## 3. Data Architecture
+
+{{data_architecture}}
+
+## 4. Component and Integration Overview
+
+{{component_overview}}
+
+## 5. Architecture Decision Records
+
+{{architecture_decisions}}
+
+## 6. Implementation Guidance
+
+{{implementation_guidance}}
+
+## 7. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+## 8. Testing Strategy
+
+{{testing_strategy}}
+{{testing_specialist_section}}
+
+## 9. Deployment and Operations
+
+{{deployment_operations}}
+{{devops_specialist_section}}
+
+## 10. Security
+
+{{security}}
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/registry.csv

@@ -0,0 +1,172 @@
+id,name,project_types,languages,architecture_style,repo_strategy,tags,template_path,reference_architecture_path,guide_path
+web-nextjs-ssr-monorepo,Next.js SSR Monolith,web,TypeScript,monolith,monorepo,"ssr,react,fullstack,vercel",web-fullstack-architecture.md,,
+web-nuxt-ssr-monorepo,Nuxt SSR Monolith,web,TypeScript,monolith,monorepo,"ssr,vue,fullstack",web-fullstack-architecture.md,,
+web-sveltekit-ssr-monorepo,SvelteKit SSR Monolith,web,TypeScript,monolith,monorepo,"ssr,svelte,fullstack",web-fullstack-architecture.md,,
+web-remix-ssr-monorepo,Remix SSR Monolith,web,TypeScript,monolith,monorepo,"ssr,react,fullstack",web-fullstack-architecture.md,,
+web-rails-monolith,Rails Monolith,web,Ruby,monolith,monorepo,"ssr,mvc,fullstack",web-fullstack-architecture.md,,
+web-django-templates,Django with Templates,web,Python,monolith,monorepo,"ssr,mvc,fullstack",web-fullstack-architecture.md,,
+web-laravel-monolith,Laravel Monolith,web,PHP,monolith,monorepo,"ssr,mvc,fullstack",web-fullstack-architecture.md,,
+web-aspnet-mvc,ASP.NET MVC,web,C#,monolith,monorepo,"ssr,mvc,fullstack,dotnet",web-fullstack-architecture.md,,
+web-express-api,Express REST API,web,TypeScript,monolith,monorepo,"api,rest,backend",web-api-architecture.md,,
+web-fastapi,FastAPI,web,Python,monolith,monorepo,"api,rest,backend,async",web-api-architecture.md,,
+web-flask-api,Flask REST API,web,Python,monolith,monorepo,"api,rest,backend",web-api-architecture.md,,
+web-django-rest,Django REST Framework,web,Python,monolith,monorepo,"api,rest,backend",web-api-architecture.md,,
+web-rails-api,Rails API Mode,web,Ruby,monolith,monorepo,"api,rest,backend",web-api-architecture.md,,
+web-gin-api,Gin API (Go),web,Go,monolith,monorepo,"api,rest,backend",web-api-architecture.md,,
+web-spring-boot-api,Spring Boot API,web,Java,monolith,monorepo,"api,rest,backend",web-api-architecture.md,,
+web-aspnet-api,ASP.NET Web API,web,C#,monolith,monorepo,"api,rest,backend,dotnet",web-api-architecture.md,,
+web-react-django-separate,React + Django (Separate),web,"TypeScript,Python",spa-with-api,monorepo,"spa,react,django",web-fullstack-architecture.md,,
+web-react-express-separate,React + Express (Separate),web,TypeScript,spa-with-api,monorepo,"spa,react,node",web-fullstack-architecture.md,,
+web-vue-rails-separate,Vue + Rails (Separate),web,"TypeScript,Ruby",spa-with-api,monorepo,"spa,vue,rails",web-fullstack-architecture.md,,
+web-vue-laravel-separate,Vue + Laravel (Separate),web,"TypeScript,PHP",spa-with-api,monorepo,"spa,vue,laravel",web-fullstack-architecture.md,,
+web-angular-spring-separate,Angular + Spring Boot,web,"TypeScript,Java",spa-with-api,monorepo,"spa,angular,spring",web-fullstack-architecture.md,,
+web-angular-dotnet-separate,Angular + .NET API,web,"TypeScript,C#",spa-with-api,monorepo,"spa,angular,dotnet",web-fullstack-architecture.md,,
+web-svelte-go-separate,Svelte + Go API,web,"TypeScript,Go",spa-with-api,monorepo,"spa,svelte,go",web-fullstack-architecture.md,,
+web-nextjs-microservices-mono,Next.js Microservices (Monorepo),web,TypeScript,microservices,monorepo,"microservices,react,nx,turborepo",web-fullstack-architecture.md,,
+web-node-microservices-mono,Node.js Microservices (Monorepo),web,TypeScript,microservices,monorepo,"microservices,node,nx",web-fullstack-architecture.md,,
+web-go-microservices-mono,Go Microservices (Monorepo),web,Go,microservices,monorepo,"microservices,go,grpc",web-fullstack-architecture.md,,
+web-python-microservices-mono,Python Microservices (Monorepo),web,Python,microservices,monorepo,"microservices,python,fastapi",web-fullstack-architecture.md,,
+web-nextjs-microservices-poly,Next.js Microservices (Polyrepo),web,TypeScript,microservices,polyrepo,"microservices,react,kubernetes",web-fullstack-architecture.md,,
+web-node-microservices-poly,Node.js Microservices (Polyrepo),web,TypeScript,microservices,polyrepo,"microservices,node,kubernetes",web-fullstack-architecture.md,,
+web-go-microservices-poly,Go Microservices (Polyrepo),web,Go,microservices,polyrepo,"microservices,go,kubernetes,grpc",web-fullstack-architecture.md,,
+web-java-microservices-poly,Java Microservices (Polyrepo),web,Java,microservices,polyrepo,"microservices,spring,kubernetes",web-fullstack-architecture.md,,
+web-nextjs-vercel-serverless,Next.js Serverless (Vercel),web,TypeScript,serverless,monorepo,"serverless,vercel,edge",web-fullstack-architecture.md,,
+web-lambda-node-serverless,AWS Lambda (Node.js),web,TypeScript,serverless,monorepo,"serverless,aws,lambda",web-api-architecture.md,,
+web-lambda-python-serverless,AWS Lambda (Python),web,Python,serverless,monorepo,"serverless,aws,lambda",web-api-architecture.md,,
+web-lambda-go-serverless,AWS Lambda (Go),web,Go,serverless,monorepo,"serverless,aws,lambda",web-api-architecture.md,,
+web-cloudflare-workers,Cloudflare Workers,web,TypeScript,serverless,monorepo,"serverless,cloudflare,edge",web-api-architecture.md,,
+web-netlify-functions,Netlify Functions,web,TypeScript,serverless,monorepo,"serverless,netlify,edge",web-api-architecture.md,,
+web-astro-jamstack,Astro Static Site,web,TypeScript,jamstack,monorepo,"static,ssg,content",web-fullstack-architecture.md,,
+web-hugo-jamstack,Hugo Static Site,web,Go,jamstack,monorepo,"static,ssg,content",web-fullstack-architecture.md,,
+web-gatsby-jamstack,Gatsby Static Site,web,TypeScript,jamstack,monorepo,"static,ssg,react",web-fullstack-architecture.md,,
+web-eleventy-jamstack,Eleventy Static Site,web,JavaScript,jamstack,monorepo,"static,ssg,content",web-fullstack-architecture.md,,
+web-jekyll-jamstack,Jekyll Static Site,web,Ruby,jamstack,monorepo,"static,ssg,content",web-fullstack-architecture.md,,
+mobile-swift-native,iOS Native (Swift),mobile,Swift,native,monorepo,"ios,native,xcode,uikit",mobile-app-architecture.md,,
+mobile-swiftui-native,iOS Native (SwiftUI),mobile,Swift,native,monorepo,"ios,native,xcode,swiftui",mobile-app-architecture.md,,
+mobile-kotlin-native,Android Native (Kotlin),mobile,Kotlin,native,monorepo,"android,native,android-studio",mobile-app-architecture.md,,
+mobile-compose-native,Android Native (Compose),mobile,Kotlin,native,monorepo,"android,native,compose",mobile-app-architecture.md,,
+mobile-react-native,React Native,mobile,TypeScript,cross-platform,monorepo,"cross-platform,react,expo",mobile-app-architecture.md,,
+mobile-flutter,Flutter,mobile,Dart,cross-platform,monorepo,"cross-platform,flutter,material",mobile-app-architecture.md,,
+mobile-xamarin,Xamarin,mobile,C#,cross-platform,monorepo,"cross-platform,xamarin,dotnet",mobile-app-architecture.md,,
+mobile-ionic-hybrid,Ionic Hybrid,mobile,TypeScript,hybrid,monorepo,"hybrid,ionic,capacitor",mobile-app-architecture.md,,
+mobile-capacitor-hybrid,Capacitor Hybrid,mobile,TypeScript,hybrid,monorepo,"hybrid,capacitor,webview",mobile-app-architecture.md,,
+mobile-cordova-hybrid,Cordova Hybrid,mobile,JavaScript,hybrid,monorepo,"hybrid,cordova,webview",mobile-app-architecture.md,,
+mobile-pwa,Progressive Web App,mobile,TypeScript,pwa,monorepo,"pwa,service-worker,offline",mobile-app-architecture.md,,
+game-unity-3d,Unity 3D,game,C#,monolith,monorepo,"3d,unity,game-engine",game-engine-architecture.md,,game-engine-unity-guide.md
+game-unreal-3d,Unreal Engine 3D,game,"C++,Blueprint",monolith,monorepo,"3d,unreal,aaa",game-engine-architecture.md,,game-engine-unreal-guide.md
+game-godot-3d,Godot 3D,game,GDScript,monolith,monorepo,"3d,godot,open-source",game-engine-architecture.md,,game-engine-godot-guide.md
+game-custom-3d-cpp,Custom 3D Engine (C++),game,C++,monolith,monorepo,"3d,custom,opengl",game-engine-architecture.md,,game-engine-general-guide.md
+game-custom-3d-rust,Custom 3D Engine (Rust),game,Rust,monolith,monorepo,"3d,custom,vulkan",game-engine-architecture.md,,game-engine-general-guide.md
+game-unity-2d,Unity 2D,game,C#,monolith,monorepo,"2d,unity,game-engine",game-engine-architecture.md,,game-engine-unity-guide.md
+game-godot-2d,Godot 2D,game,GDScript,monolith,monorepo,"2d,godot,open-source",game-engine-architecture.md,,game-engine-godot-guide.md
+game-gamemaker,GameMaker,game,GML,monolith,monorepo,"2d,gamemaker,indie",game-engine-architecture.md,,game-engine-general-guide.md
+game-phaser,Phaser (Web),game,TypeScript,monolith,monorepo,"2d,phaser,html5",game-engine-architecture.md,,game-engine-web-guide.md
+game-pixijs,PixiJS (Web),game,TypeScript,monolith,monorepo,"2d,pixijs,canvas",game-engine-architecture.md,,game-engine-web-guide.md
+game-threejs,Three.js (Web),game,TypeScript,monolith,monorepo,"3d,threejs,webgl",game-engine-architecture.md,,game-engine-web-guide.md
+game-babylonjs,Babylon.js (Web),game,TypeScript,monolith,monorepo,"3d,babylonjs,webgl",game-engine-architecture.md,,game-engine-web-guide.md
+game-text-python,Text-Based (Python),game,Python,monolith,monorepo,"text,roguelike",game-engine-architecture.md,,game-engine-general-guide.md
+game-text-js,Text-Based (JavaScript),game,JavaScript,monolith,monorepo,"text,interactive-fiction",game-engine-architecture.md,,game-engine-general-guide.md
+game-text-cpp,Text-Based (C++),game,C++,monolith,monorepo,"text,roguelike,mud",game-engine-architecture.md,,game-engine-general-guide.md
+backend-express-rest,Express REST,backend,TypeScript,monolith,monorepo,"rest,express",backend-service-architecture.md,,
+backend-fastapi-rest,FastAPI REST,backend,Python,monolith,monorepo,"rest,fastapi,async",backend-service-architecture.md,,
+backend-django-rest-fw,Django REST Framework,backend,Python,monolith,monorepo,"rest,django",backend-service-architecture.md,,
+backend-flask-rest,Flask REST,backend,Python,monolith,monorepo,"rest,flask,lightweight",backend-service-architecture.md,,
+backend-spring-boot-rest,Spring Boot REST,backend,Java,monolith,monorepo,"rest,spring,enterprise",backend-service-architecture.md,,
+backend-gin-rest,Gin REST (Go),backend,Go,monolith,monorepo,"rest,gin,performance",backend-service-architecture.md,,
+backend-actix-rest,Actix Web (Rust),backend,Rust,monolith,monorepo,"rest,actix,performance",backend-service-architecture.md,,
+backend-rails-api,Rails API,backend,Ruby,monolith,monorepo,"rest,rails",backend-service-architecture.md,,
+backend-apollo-graphql,Apollo GraphQL,backend,TypeScript,monolith,monorepo,"graphql,apollo",backend-service-architecture.md,,
+backend-hasura-graphql,Hasura GraphQL,backend,any,monolith,monorepo,"graphql,hasura,postgres",backend-service-architecture.md,,
+backend-strawberry-graphql,Strawberry GraphQL (Python),backend,Python,monolith,monorepo,"graphql,strawberry,async",backend-service-architecture.md,,
+backend-graphql-go,gqlgen (Go),backend,Go,monolith,monorepo,"graphql,gqlgen,type-safe",backend-service-architecture.md,,
+backend-grpc-go,gRPC Service (Go),backend,Go,monolith,monorepo,"grpc,protobuf",backend-service-architecture.md,,
+backend-grpc-node,gRPC Service (Node.js),backend,TypeScript,monolith,monorepo,"grpc,protobuf",backend-service-architecture.md,,
+backend-grpc-rust,gRPC Service (Rust),backend,Rust,monolith,monorepo,"grpc,tonic",backend-service-architecture.md,,
+backend-grpc-java,gRPC Service (Java),backend,Java,monolith,monorepo,"grpc,protobuf",backend-service-architecture.md,,
+backend-socketio-realtime,Socket.IO Realtime,backend,TypeScript,monolith,monorepo,"realtime,socketio",backend-service-architecture.md,,
+backend-phoenix-realtime,Phoenix Channels,backend,Elixir,monolith,monorepo,"realtime,phoenix",backend-service-architecture.md,,
+backend-ably-realtime,Ably Realtime,backend,any,monolith,monorepo,"realtime,ably,managed",backend-service-architecture.md,,
+backend-pusher-realtime,Pusher Realtime,backend,any,monolith,monorepo,"realtime,pusher,managed",backend-service-architecture.md,,
+backend-kafka-event,Kafka Event-Driven,backend,"Java,Go,Python",event-driven,monorepo,"event-driven,kafka,streaming",backend-service-architecture.md,,
+backend-rabbitmq-event,RabbitMQ Event-Driven,backend,"Python,Go,Node",event-driven,monorepo,"event-driven,rabbitmq,amqp",backend-service-architecture.md,,
+backend-nats-event,NATS Event-Driven,backend,Go,event-driven,monorepo,"event-driven,nats,messaging",backend-service-architecture.md,,
+backend-sqs-event,AWS SQS Event-Driven,backend,"Python,Node",event-driven,monorepo,"event-driven,aws,sqs",backend-service-architecture.md,,
+backend-celery-batch,Celery Batch (Python),backend,Python,batch,monorepo,"batch,celery,redis,async",backend-service-architecture.md,,
+backend-airflow-batch,Airflow Pipelines,backend,Python,batch,monorepo,"batch,airflow,orchestration,dags",backend-service-architecture.md,,
+backend-prefect-batch,Prefect Pipelines,backend,Python,batch,monorepo,"batch,prefect,orchestration",backend-service-architecture.md,,
+backend-temporal-batch,Temporal Workflows,backend,"Go,TypeScript",batch,monorepo,"batch,temporal,workflows",backend-service-architecture.md,,
+embedded-freertos-esp32,FreeRTOS ESP32,embedded,C,rtos,monorepo,"iot,freertos,wifi",embedded-firmware-architecture.md,,
+embedded-freertos-stm32,FreeRTOS STM32,embedded,C,rtos,monorepo,"stm32,freertos,arm,cortex",embedded-firmware-architecture.md,,
+embedded-zephyr,Zephyr RTOS,embedded,C,rtos,monorepo,"zephyr,iot,bluetooth",embedded-firmware-architecture.md,,
+embedded-nuttx,NuttX RTOS,embedded,C,rtos,monorepo,"nuttx,posix",embedded-firmware-architecture.md,,
+embedded-arduino-bare,Arduino Bare Metal,embedded,"C,C++",bare-metal,monorepo,"arduino,bare-metal,avr",embedded-firmware-architecture.md,,
+embedded-stm32-bare,STM32 Bare Metal,embedded,C,bare-metal,monorepo,"stm32,bare-metal,arm",embedded-firmware-architecture.md,,
+embedded-pic-bare,PIC Microcontroller,embedded,C,bare-metal,monorepo,"pic,microchip",embedded-firmware-architecture.md,,
+embedded-avr-bare,AVR Bare Metal,embedded,C,bare-metal,monorepo,"avr,atmega",embedded-firmware-architecture.md,,
+embedded-raspberrypi,Raspberry Pi (Linux),embedded,Python,linux,monorepo,"raspberry-pi,gpio,python",embedded-firmware-architecture.md,,
+embedded-beaglebone,BeagleBone (Linux),embedded,Python,linux,monorepo,"beaglebone,gpio",embedded-firmware-architecture.md,,
+embedded-jetson,NVIDIA Jetson,embedded,Python,linux,monorepo,"jetson,ai,gpu",embedded-firmware-architecture.md,,
+embedded-esp32-iot,ESP32 IoT Cloud,embedded,C,iot-cloud,monorepo,"esp32,mqtt,aws-iot",embedded-firmware-architecture.md,,
+embedded-arduino-iot,Arduino IoT Cloud,embedded,"C,C++",iot-cloud,monorepo,"arduino,iot,mqtt,cloud",embedded-firmware-architecture.md,,
+embedded-particle,Particle IoT,embedded,"C,C++",iot-cloud,monorepo,"particle,iot,cellular,cloud",embedded-firmware-architecture.md,,
+library-npm-ts,NPM Library (TypeScript),library,TypeScript,library,monorepo,"npm,package,tsup",library-package-architecture.md,,
+library-npm-js,NPM Library (JavaScript),library,JavaScript,library,monorepo,"npm,package,rollup",library-package-architecture.md,,
+library-pypi,PyPI Package,library,Python,library,monorepo,"pypi,wheel,setuptools",library-package-architecture.md,,
+library-cargo,Cargo Crate (Rust),library,Rust,library,monorepo,"cargo,crate,docs-rs",library-package-architecture.md,,
+library-go-modules,Go Module,library,Go,library,monorepo,"go,pkg-go-dev",library-package-architecture.md,,
+library-maven-java,Maven Library (Java),library,Java,library,monorepo,"maven,jar,central",library-package-architecture.md,,
+library-nuget-csharp,NuGet Package (C#),library,C#,library,monorepo,"nuget,dotnet,package",library-package-architecture.md,,
+library-cpp-cmake,C++ Library (CMake),library,C++,library,monorepo,"cpp,conan,vcpkg",library-package-architecture.md,,
+library-c-shared,C Shared Library,library,C,library,monorepo,"c,header-only",library-package-architecture.md,,
+cli-node-simple,CLI Tool (Node.js),cli,TypeScript,cli,monorepo,"cli,commander,yargs",cli-tool-architecture.md,,
+cli-python-simple,CLI Tool (Python),cli,Python,cli,monorepo,"cli,click,argparse",cli-tool-architecture.md,,
+cli-go-simple,CLI Tool (Go),cli,Go,cli,monorepo,"cli,cobra,single-binary",cli-tool-architecture.md,,
+cli-rust-simple,CLI Tool (Rust),cli,Rust,cli,monorepo,"cli,clap,single-binary",cli-tool-architecture.md,,
+cli-node-interactive,Interactive CLI (Node.js),cli,TypeScript,cli-interactive,monorepo,"cli,ink,blessed",cli-tool-architecture.md,,
+cli-python-interactive,Interactive CLI (Python),cli,Python,cli-interactive,monorepo,"cli,rich,textual,prompt-toolkit",cli-tool-architecture.md,,
+cli-rust-interactive,Interactive TUI (Rust),cli,Rust,cli-interactive,monorepo,"cli,ratatui,crossterm",cli-tool-architecture.md,,
+cli-go-interactive,Interactive TUI (Go),cli,Go,cli-interactive,monorepo,"cli,bubbletea,charm",cli-tool-architecture.md,,
+cli-node-daemon,CLI with Daemon (Node.js),cli,TypeScript,cli-daemon,monorepo,"cli,service,systemd",cli-tool-architecture.md,,
+cli-python-daemon,CLI with Daemon (Python),cli,Python,cli-daemon,monorepo,"cli,service,systemd",cli-tool-architecture.md,,
+cli-go-daemon,CLI with Service (Go),cli,Go,cli-daemon,monorepo,"cli,service,systemd",cli-tool-architecture.md,,
+desktop-electron,Electron App,desktop,TypeScript,desktop,monorepo,"electron,cross-platform,chromium",desktop-app-architecture.md,,
+desktop-tauri,Tauri App,desktop,"TypeScript,Rust",desktop,monorepo,"tauri,rust,webview,lightweight",desktop-app-architecture.md,,
+desktop-wails,Wails App (Go),desktop,"TypeScript,Go",desktop,monorepo,"wails,go,webview",desktop-app-architecture.md,,
+desktop-qt-cpp,Qt Desktop (C++),desktop,C++,desktop,monorepo,"qt,cpp,native,cross-platform",desktop-app-architecture.md,,
+desktop-qt-python,Qt Desktop (Python),desktop,Python,desktop,monorepo,"qt,python,pyside6",desktop-app-architecture.md,,
+desktop-dotnet-wpf,WPF Desktop (.NET),desktop,C#,desktop,monorepo,"dotnet,windows,xaml",desktop-app-architecture.md,,
+desktop-dotnet-maui,MAUI Desktop (.NET),desktop,C#,desktop,monorepo,"dotnet,cross-platform,xaml",desktop-app-architecture.md,,
+desktop-swiftui-macos,SwiftUI macOS,desktop,Swift,desktop,monorepo,"swiftui,macos,native,declarative",desktop-app-architecture.md,,
+desktop-gtk,GTK Desktop,desktop,"C,Python",desktop,monorepo,"gtk,linux,gnome",desktop-app-architecture.md,,
+desktop-tkinter,Tkinter Desktop (Python),desktop,Python,desktop,monorepo,"tkinter,simple,cross-platform",desktop-app-architecture.md,,
+data-etl-python,Python ETL,data,Python,pipeline,monorepo,"etl,pandas,dask",data-pipeline-architecture.md,,
+data-etl-spark,Spark ETL,data,"Scala,Python",pipeline,monorepo,"etl,spark,big-data,pyspark",data-pipeline-architecture.md,,
+data-dbt,dbt Transformations,data,SQL,pipeline,monorepo,"etl,dbt,sql,analytics-engineering",data-pipeline-architecture.md,,
+data-ml-training,ML Training Pipeline,data,Python,pipeline,monorepo,"ml,mlflow,pytorch,tensorflow",data-pipeline-architecture.md,,
+data-ml-inference,ML Inference Service,data,Python,pipeline,monorepo,"ml,serving,triton,torchserve",data-pipeline-architecture.md,,
+data-kubeflow,Kubeflow Pipelines,data,Python,pipeline,monorepo,"ml,kubeflow,kubernetes,pipelines",data-pipeline-architecture.md,,
+data-analytics-superset,Superset Analytics,data,Python,analytics,monorepo,"analytics,superset,dashboards,bi",data-pipeline-architecture.md,,
+data-analytics-metabase,Metabase Analytics,data,any,analytics,monorepo,"analytics,metabase,dashboards,bi",data-pipeline-architecture.md,,
+data-looker,Looker/LookML,data,LookML,analytics,monorepo,"analytics,looker,bi,enterprise",data-pipeline-architecture.md,,
+data-warehouse-snowflake,Snowflake Warehouse,data,SQL,warehouse,monorepo,"warehouse,snowflake,cloud,dbt",data-pipeline-architecture.md,,
+data-warehouse-bigquery,BigQuery Warehouse,data,SQL,warehouse,monorepo,"warehouse,bigquery,gcp,dbt",data-pipeline-architecture.md,,
+data-warehouse-redshift,Redshift Warehouse,data,SQL,warehouse,monorepo,"warehouse,redshift,aws,dbt",data-pipeline-architecture.md,,
+data-streaming-kafka,Kafka Streaming,data,"Java,Scala",streaming,monorepo,"streaming,kafka,confluent,real-time",data-pipeline-architecture.md,,
+data-streaming-flink,Flink Streaming,data,"Java,Python",streaming,monorepo,"streaming,flink,stateful,real-time",data-pipeline-architecture.md,,
+data-streaming-spark,Spark Streaming,data,"Scala,Python",streaming,monorepo,"streaming,spark,micro-batch",data-pipeline-architecture.md,,
+extension-chrome,Chrome Extension,extension,TypeScript,extension,monorepo,"browser,extension,manifest-v3",desktop-app-architecture.md,,
+extension-firefox,Firefox Extension,extension,TypeScript,extension,monorepo,"browser,webextensions,manifest-v2",desktop-app-architecture.md,,
+extension-safari,Safari Extension,extension,Swift,extension,monorepo,"browser,safari,xcode,app-extension",desktop-app-architecture.md,,
+extension-vscode,VS Code Extension,extension,TypeScript,extension,monorepo,"vscode,ide,language-server",desktop-app-architecture.md,,
+extension-intellij,IntelliJ Plugin,extension,Kotlin,extension,monorepo,"jetbrains,plugin,ide",desktop-app-architecture.md,,
+extension-sublime,Sublime Text Plugin,extension,Python,extension,monorepo,"sublime,editor",desktop-app-architecture.md,,
+infra-terraform,Terraform IaC,infra,HCL,iac,monorepo,"terraform,iac,cloud,multi-cloud",infrastructure-architecture.md,,
+infra-pulumi,Pulumi IaC,infra,"TypeScript,Python,Go",iac,monorepo,"pulumi,iac,cloud,programming",infrastructure-architecture.md,,
+infra-cdk-aws,AWS CDK,infra,TypeScript,iac,monorepo,"cdk,iac,cloudformation",infrastructure-architecture.md,,
+infra-cdktf,CDK for Terraform,infra,TypeScript,iac,monorepo,"cdktf,iac,typescript",infrastructure-architecture.md,,
+infra-k8s-operator,Kubernetes Operator,infra,Go,k8s-operator,monorepo,"kubernetes,operator,controller,crd",infrastructure-architecture.md,,
+infra-helm-charts,Helm Charts,infra,YAML,k8s-package,monorepo,"kubernetes,helm,package,templating",infrastructure-architecture.md,,
+infra-ansible,Ansible Playbooks,infra,YAML,config-mgmt,monorepo,"ansible,automation,idempotent",infrastructure-architecture.md,,
+infra-chef,Chef Cookbooks,infra,Ruby,config-mgmt,monorepo,"chef,automation,ruby-dsl",infrastructure-architecture.md,,
+infra-puppet,Puppet Manifests,infra,Puppet,config-mgmt,monorepo,"puppet,automation,declarative",infrastructure-architecture.md,,
+infra-saltstack,SaltStack,infra,YAML,config-mgmt,monorepo,"salt,automation,python",infrastructure-architecture.md,,

bmad/bmm/workflows/3-solutioning/templates/web-api-architecture.md

@@ -0,0 +1,66 @@
+# {{TITLE}} Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+{{technology_table}}
+
+## 2. Architecture Overview
+
+{{architecture_overview}}
+
+## 3. Data Architecture
+
+{{data_architecture}}
+
+## 4. Component and Integration Overview
+
+{{component_overview}}
+
+## 5. Architecture Decision Records
+
+{{architecture_decisions}}
+
+## 6. Implementation Guidance
+
+{{implementation_guidance}}
+
+## 7. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+## 8. Testing Strategy
+
+{{testing_strategy}}
+{{testing_specialist_section}}
+
+## 9. Deployment and Operations
+
+{{deployment_operations}}
+{{devops_specialist_section}}
+
+## 10. Security
+
+{{security}}
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_

bmad/bmm/workflows/3-solutioning/templates/web-fullstack-architecture.md

@@ -0,0 +1,277 @@
+# Solution Architecture Document
+
+**Project:** {{project_name}}
+**Date:** {{date}}
+**Author:** {{user_name}}
+
+## Executive Summary
+
+{{executive_summary}}
+
+## 1. Technology Stack and Decisions
+
+### 1.1 Technology and Library Decision Table
+
+| Category         | Technology     | Version                | Justification                |
+| ---------------- | -------------- | ---------------------- | ---------------------------- |
+| Framework        | {{framework}}  | {{framework_version}}  | {{framework_justification}}  |
+| Language         | {{language}}   | {{language_version}}   | {{language_justification}}   |
+| Database         | {{database}}   | {{database_version}}   | {{database_justification}}   |
+| Authentication   | {{auth}}       | {{auth_version}}       | {{auth_justification}}       |
+| Hosting          | {{hosting}}    | {{hosting_version}}    | {{hosting_justification}}    |
+| State Management | {{state_mgmt}} | {{state_mgmt_version}} | {{state_mgmt_justification}} |
+| Styling          | {{styling}}    | {{styling_version}}    | {{styling_justification}}    |
+| Testing          | {{testing}}    | {{testing_version}}    | {{testing_justification}}    |
+
+{{additional_tech_stack_rows}}
+
+## 2. Application Architecture
+
+### 2.1 Architecture Pattern
+
+{{architecture_pattern_description}}
+
+### 2.2 Server-Side Rendering Strategy
+
+{{ssr_strategy}}
+
+### 2.3 Page Routing and Navigation
+
+{{routing_navigation}}
+
+### 2.4 Data Fetching Approach
+
+{{data_fetching}}
+
+## 3. Data Architecture
+
+### 3.1 Database Schema
+
+{{database_schema}}
+
+### 3.2 Data Models and Relationships
+
+{{data_models}}
+
+### 3.3 Data Migrations Strategy
+
+{{migrations_strategy}}
+
+## 4. API Design
+
+### 4.1 API Structure
+
+{{api_structure}}
+
+### 4.2 API Routes
+
+{{api_routes}}
+
+### 4.3 Form Actions and Mutations
+
+{{form_actions}}
+
+## 5. Authentication and Authorization
+
+### 5.1 Auth Strategy
+
+{{auth_strategy}}
+
+### 5.2 Session Management
+
+{{session_management}}
+
+### 5.3 Protected Routes
+
+{{protected_routes}}
+
+### 5.4 Role-Based Access Control
+
+{{rbac}}
+
+## 6. State Management
+
+### 6.1 Server State
+
+{{server_state}}
+
+### 6.2 Client State
+
+{{client_state}}
+
+### 6.3 Form State
+
+{{form_state}}
+
+### 6.4 Caching Strategy
+
+{{caching_strategy}}
+
+## 7. UI/UX Architecture
+
+### 7.1 Component Structure
+
+{{component_structure}}
+
+### 7.2 Styling Approach
+
+{{styling_approach}}
+
+### 7.3 Responsive Design
+
+{{responsive_design}}
+
+### 7.4 Accessibility
+
+{{accessibility}}
+
+## 8. Performance Optimization
+
+### 8.1 SSR Caching
+
+{{ssr_caching}}
+
+### 8.2 Static Generation
+
+{{static_generation}}
+
+### 8.3 Image Optimization
+
+{{image_optimization}}
+
+### 8.4 Code Splitting
+
+{{code_splitting}}
+
+## 9. SEO and Meta Tags
+
+### 9.1 Meta Tag Strategy
+
+{{meta_tag_strategy}}
+
+### 9.2 Sitemap
+
+{{sitemap}}
+
+### 9.3 Structured Data
+
+{{structured_data}}
+
+## 10. Deployment Architecture
+
+### 10.1 Hosting Platform
+
+{{hosting_platform}}
+
+### 10.2 CDN Strategy
+
+{{cdn_strategy}}
+
+### 10.3 Edge Functions
+
+{{edge_functions}}
+
+### 10.4 Environment Configuration
+
+{{environment_config}}
+
+## 11. Component and Integration Overview
+
+### 11.1 Major Modules
+
+{{major_modules}}
+
+### 11.2 Page Structure
+
+{{page_structure}}
+
+### 11.3 Shared Components
+
+{{shared_components}}
+
+### 11.4 Third-Party Integrations
+
+{{third_party_integrations}}
+
+## 12. Architecture Decision Records
+
+{{architecture_decisions}}
+
+**Key decisions:**
+
+- Why this framework? {{framework_decision}}
+- SSR vs SSG? {{ssr_vs_ssg_decision}}
+- Database choice? {{database_decision}}
+- Hosting platform? {{hosting_decision}}
+
+## 13. Implementation Guidance
+
+### 13.1 Development Workflow
+
+{{development_workflow}}
+
+### 13.2 File Organization
+
+{{file_organization}}
+
+### 13.3 Naming Conventions
+
+{{naming_conventions}}
+
+### 13.4 Best Practices
+
+{{best_practices}}
+
+## 14. Proposed Source Tree
+
+```
+{{source_tree}}
+```
+
+**Critical folders:**
+
+- {{critical_folder_1}}: {{critical_folder_1_description}}
+- {{critical_folder_2}}: {{critical_folder_2_description}}
+- {{critical_folder_3}}: {{critical_folder_3_description}}
+
+## 15. Testing Strategy
+
+### 15.1 Unit Tests
+
+{{unit_tests}}
+
+### 15.2 Integration Tests
+
+{{integration_tests}}
+
+### 15.3 E2E Tests
+
+{{e2e_tests}}
+
+### 15.4 Coverage Goals
+
+{{coverage_goals}}
+
+{{testing_specialist_section}}
+
+## 16. DevOps and CI/CD
+
+{{devops_section}}
+
+{{devops_specialist_section}}
+
+## 17. Security
+
+{{security_section}}
+
+{{security_specialist_section}}
+
+---
+
+## Specialist Sections
+
+{{specialist_sections_summary}}
+
+---
+
+_Generated using BMad Method Solution Architecture workflow_