bmad-method 4.27.6 → 5.0.0

package/docs/bmad-workflow-guide.md

@@ -1,12 +1,12 @@
-# BMad Method Universal Workflow Guide
+# BMAD Method Universal Workflow Guide
 
-This guide outlines the core BMad workflow that applies regardless of which AI-powered IDE you're using.
+This guide outlines the core BMAD workflow that applies regardless of which AI-powered IDE you're using.
 
 ## Overview
 
-The BMad Method follows a structured approach to AI-assisted software development:
+The BMAD Method follows a structured approach to AI-assisted software development:
 
-1. **Install BMad** in your project
+1. **Install BMAD** in your project
 2. **Plan with Gemini** using team-fullstack
 3. **Organize with bmad-master** (document sharding)
 4. **Develop iteratively** with SM → Dev cycles
@@ -15,14 +15,14 @@ The BMad Method follows a structured approach to AI-assisted software developmen
 
 ### Phase 1: Project Setup
 
-1. **Install BMad in your project**:
+1. **Install BMAD in your project**:
 
    ```bash
    npx bmad-method install
    ```
 
    - Choose "Complete installation"
-   - Select your IDE (Cursor, Claude Code, Windsurf, Trae, Roo Code, or GitHub Copilot)
+   - Select your IDE (Cursor, Claude Code, Windsurf, or Roo Code)
 
 2. **Verify installation**:
    - `.bmad-core/` folder created with all agents
@@ -33,13 +33,11 @@ The BMad Method follows a structured approach to AI-assisted software developmen
 
 Use Google's Gemini for collaborative planning with the full team:
 
-1. **Open [Google Gems](https://gemini.google.com/gems/view)**
-2. **Create a new Gem**:
-   - Give it a title and description (e.g., "BMad Team Fullstack")
-3. **Load team-fullstack**:
-   - Copy contents of: `dist/teams/team-fullstack.txt` from your project
-   - Paste this content into the Gem setup to configure the team
-4. **Collaborate with the team**:
+1. **Open [Google AI Studio](https://aistudio.google.com/)**
+2. **Load team-fullstack**:
+   - Copy contents of: `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
+   - Paste into new Gemini chat
+3. **Collaborate with the team**:
    - Business Analyst: Requirements gathering
    - Product Manager: Feature prioritization
    - Solution Architect: Technical design
@@ -55,9 +53,9 @@ Help me brainstorm features and create a comprehensive PRD."
 that can handle [specific requirements]."
 ```
 
-5. **Export planning documents**:
-   - Copy the PRD output and save as `docs/prd.md` in your project
-   - Copy the architecture output and save as `docs/architecture.md` in your project
+4. **Export planning documents**:
+   - Save PRD as `docs/prd.md`
+   - Save architecture as `docs/architecture.md`
 
 ### Phase 3: Document Organization (IDE)
 
@@ -112,13 +110,11 @@ Follow the SM → Dev cycle for systematic story development:
 - **Claude Code**: `/agent-name` (e.g., `/bmad-master`)
 - **Cursor**: `@agent-name` (e.g., `@bmad-master`)
 - **Windsurf**: `@agent-name` (e.g., `@bmad-master`)
-- **Trae**: `@agent-name` (e.g., `@bmad-master`)
 - **Roo Code**: Select mode from mode selector (e.g., `bmad-bmad-master`)
-- **GitHub Copilot**: Open the Chat view (`⌃⌘I` on Mac, `Ctrl+Alt+I` on Windows/Linux) and select **Agent** from the chat mode selector.
 
 ### Chat Management:
 
-- **Claude Code, Cursor, Windsurf, Trae**: Start new chats when switching agents
+- **Claude Code, Cursor, Windsurf**: Start new chats when switching agents
 - **Roo Code**: Switch modes within the same conversation
 
 ## Available Agents

package/docs/claude-code-guide.md

@@ -0,0 +1,119 @@
+# BMAD Method Guide for Claude Code
+
+This guide walks you through the complete BMAD workflow using Claude Code as your AI-powered IDE.
+
+## Step 1: Install BMAD in Your Project
+
+1. Navigate to your project directory
+2. Run the BMAD installer:
+   ```bash
+   npx bmad-method install
+   ```
+3. When prompted:
+   - **Installation Type**: Choose "Complete installation (recommended)"
+   - **IDE**: Select "Claude Code"
+
+This creates a `.bmad-core` folder with all agents and a `.claude/commands` folder with agent commands.
+
+## Step 2: Set Up Team Fullstack in Gemini
+
+For ideation and planning, use Google's Gemini with the team-fullstack configuration:
+
+1. Open [Google AI Studio (Gemini)](https://aistudio.google.com/)
+2. Create a new chat
+3. Copy the contents of `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
+4. Paste this content into Gemini to set up the team
+
+### Gemini Planning Phase
+
+In Gemini, ask the BMAD team to help you:
+
+- **Ideate** your project concept
+- **Brainstorm** features and requirements
+- **Create a PRD** (Product Requirements Document)
+- **Design the architecture**
+
+Ask questions like:
+
+- "Help me brainstorm a [type of application] that does [core functionality]"
+- "Create a comprehensive PRD for this concept"
+- "Design the technical architecture for this system"
+
+Copy the PRD and architecture documents that Gemini creates into your project's `docs/` folder:
+
+- `docs/prd.md`
+- `docs/architecture.md`
+
+## Step 3: Back to Claude Code - Document Sharding
+
+Once you have your PRD and architecture documents in the `docs/` folder:
+
+1. **Start a new chat in Claude Code**
+2. **Load the bmad-master agent**: Type `/bmad-master`
+3. **Shard the PRD**: Type `*shard-doc docs/prd.md prd`
+4. **Shard the architecture**: Type `*shard-doc docs/architecture.md architecture`
+
+This creates organized folders:
+
+- `docs/prd/` - Contains broken down PRD sections
+- `docs/architecture/` - Contains broken down architecture sections
+
+## Step 4: Story Development Cycle
+
+Now begin the iterative development cycle:
+
+### Create Stories (Scrum Master)
+
+1. **Start a new chat**
+2. **Load SM agent**: Type `/sm`
+3. **Create story**: Type `*create` (this runs the create-next-story task)
+4. **Review the generated story**
+5. **If approved**: Set story status to "Approved" in the story file
+
+### Implement Stories (Developer)
+
+1. **Start a new chat**
+2. **Load Dev agent**: Type `/dev`
+3. **The agent will ask which story to implement**
+4. **Follow the development tasks** the agent provides
+5. **When story is complete**: Mark status as "Done"
+
+### Repeat the Cycle
+
+1. **Start a new chat with SM agent** (`/sm`)
+2. **Create next story**: Type `*create`
+3. **Review and approve**
+4. **Start new chat with Dev agent** (`/dev`)
+5. **Implement the story**
+6. **Repeat until project complete**
+
+## Available Commands in Claude Code
+
+All BMAD agents are available as Claude Code commands:
+
+- `/bmad-master` - Universal task executor
+- `/sm` - Scrum Master for story creation
+- `/dev` - Full-stack developer for implementation
+- `/architect` - Solution architect for design
+- `/pm` - Product manager for planning
+- `/analyst` - Business analyst for requirements
+- `/qa` - QA specialist for testing
+- `/po` - Product owner for prioritization
+- `/ux-expert` - UX specialist for design
+
+## Key Workflow Principles
+
+1. **Always start new chats** when switching agents to avoid context confusion
+2. **Use Gemini for initial planning** and ideation with the team-fullstack bundle
+3. **Use bmad-master for document management** (sharding, templates, etc.)
+4. **Follow the SM → Dev cycle** for consistent story development
+5. **Review and approve stories** before implementation begins
+
+## Tips for Success
+
+- **Keep chats focused**: Each chat should have one agent and one primary task
+- **Use \*help command**: Every agent supports `*help` to see available commands
+- **Review generated content**: Always review and approve stories before marking them ready
+- **Maintain status updates**: Keep story statuses current (Draft → Approved → InProgress → Done)
+
+This workflow ensures systematic, AI-assisted development following agile principles with clear handoffs between planning, story creation, and implementation phases.

package/docs/cursor-guide.md

@@ -0,0 +1,127 @@
+# BMAD Method Guide for Cursor
+
+This guide walks you through the complete BMAD workflow using Cursor as your AI-powered IDE.
+
+## Step 1: Install BMAD in Your Project
+
+1. Navigate to your project directory
+2. Run the BMAD installer:
+   ```bash
+   npx bmad-method install
+   ```
+3. When prompted:
+   - **Installation Type**: Choose "Complete installation (recommended)"
+   - **IDE**: Select "Cursor"
+
+This creates a `.bmad-core` folder with all agents and a `.cursor/rules` folder with agent rules.
+
+## Step 2: Set Up Team Fullstack in Gemini
+
+For ideation and planning, use Google's Gemini with the team-fullstack configuration:
+
+1. Open [Google AI Studio (Gemini)](https://aistudio.google.com/)
+2. Create a new chat
+3. Copy the contents of `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
+4. Paste this content into Gemini to set up the team
+
+### Gemini Planning Phase
+
+In Gemini, ask the BMAD team to help you:
+
+- **Ideate** your project concept
+- **Brainstorm** features and requirements
+- **Create a PRD** (Product Requirements Document)
+- **Design the architecture**
+
+Ask questions like:
+
+- "Help me brainstorm a [type of application] that does [core functionality]"
+- "Create a comprehensive PRD for this concept"
+- "Design the technical architecture for this system"
+
+Copy the PRD and architecture documents that Gemini creates into your project's `docs/` folder:
+
+- `docs/prd.md`
+- `docs/architecture.md`
+
+## Step 3: Back to Cursor - Document Sharding
+
+Once you have your PRD and architecture documents in the `docs/` folder:
+
+1. **Start a new chat in Cursor**
+2. **Load the bmad-master agent**: Type `@bmad-master`
+3. **Shard the PRD**: Type `*shard-doc docs/prd.md prd`
+4. **Shard the architecture**: Type `*shard-doc docs/architecture.md architecture`
+
+This creates organized folders:
+
+- `docs/prd/` - Contains broken down PRD sections
+- `docs/architecture/` - Contains broken down architecture sections
+
+## Step 4: Story Development Cycle
+
+Now begin the iterative development cycle:
+
+### Create Stories (Scrum Master)
+
+1. **Start a new chat**
+2. **Load SM agent**: Type `@sm`
+3. **Create story**: Type `*create` (this runs the create-next-story task)
+4. **Review the generated story**
+5. **If approved**: Set story status to "Approved" in the story file
+
+### Implement Stories (Developer)
+
+1. **Start a new chat**
+2. **Load Dev agent**: Type `@dev`
+3. **The agent will ask which story to implement**
+4. **Follow the development tasks** the agent provides
+5. **When story is complete**: Mark status as "Done"
+
+### Repeat the Cycle
+
+1. **Start a new chat with SM agent** (`@sm`)
+2. **Create next story**: Type `*create`
+3. **Review and approve**
+4. **Start new chat with Dev agent** (`@dev`)
+5. **Implement the story**
+6. **Repeat until project complete**
+
+## Available Agent Rules in Cursor
+
+All BMAD agents are available as Cursor rules (use `@` prefix):
+
+- `@bmad-master` - Universal task executor
+- `@sm` - Scrum Master for story creation
+- `@dev` - Full-stack developer for implementation
+- `@architect` - Solution architect for design
+- `@pm` - Product manager for planning
+- `@analyst` - Business analyst for requirements
+- `@qa` - QA specialist for testing
+- `@po` - Product owner for prioritization
+- `@ux-expert` - UX specialist for design
+
+## Cursor-Specific Features
+
+- **Agent rules are stored in**: `.cursor/rules/` as `.mdc` files
+- **Auto-completion**: Cursor will suggest `@agent-name` as you type
+- **Rule activation**: Rules activate automatically when you mention `@agent-name`
+- **Context awareness**: Agents have access to your current file context
+
+## Key Workflow Principles
+
+1. **Always start new chats** when switching agents to avoid context confusion
+2. **Use Gemini for initial planning** and ideation with the team-fullstack bundle
+3. **Use bmad-master for document management** (sharding, templates, etc.)
+4. **Follow the SM → Dev cycle** for consistent story development
+5. **Review and approve stories** before implementation begins
+
+## Tips for Success
+
+- **Keep chats focused**: Each chat should have one agent and one primary task
+- **Use \*help command**: Every agent supports `*help` to see available commands
+- **Review generated content**: Always review and approve stories before marking them ready
+- **Maintain status updates**: Keep story statuses current (Draft → Approved → InProgress → Done)
+- **Leverage Cursor's context**: Agents can see your current file selection for better assistance
+
+This workflow ensures systematic, AI-assisted development following agile principles with clear handoffs between planning, story creation, and implementation phases.

package/docs/roo-code-guide.md

@@ -0,0 +1,140 @@
+# BMAD Method Guide for Roo Code
+
+This guide walks you through the complete BMAD workflow using Roo Code as your AI-powered IDE.
+
+## Step 1: Install BMAD in Your Project
+
+1. Navigate to your project directory
+2. Run the BMAD installer:
+   ```bash
+   npx bmad-method install
+   ```
+3. When prompted:
+   - **Installation Type**: Choose "Complete installation (recommended)"
+   - **IDE**: Select "Roo Code"
+
+This creates a `.bmad-core` folder with all agents and a `.roo/.roomodes` file with custom modes.
+
+## Step 2: Set Up Team Fullstack in Gemini
+
+For ideation and planning, use Google's Gemini with the team-fullstack configuration:
+
+1. Open [Google AI Studio (Gemini)](https://aistudio.google.com/)
+2. Create a new chat
+3. Copy the contents of `/Users/brianmadison/dev/BMAD-METHOD/.bmad-core/web-bundles/teams/team-fullstack.txt`
+4. Paste this content into Gemini to set up the team
+
+### Gemini Planning Phase
+
+In Gemini, ask the BMAD team to help you:
+
+- **Ideate** your project concept
+- **Brainstorm** features and requirements
+- **Create a PRD** (Product Requirements Document)
+- **Design the architecture**
+
+Ask questions like:
+
+- "Help me brainstorm a [type of application] that does [core functionality]"
+- "Create a comprehensive PRD for this concept"
+- "Design the technical architecture for this system"
+
+Copy the PRD and architecture documents that Gemini creates into your project's `docs/` folder:
+
+- `docs/prd.md`
+- `docs/architecture.md`
+
+## Step 3: Back to Roo Code - Document Sharding
+
+Once you have your PRD and architecture documents in the `docs/` folder:
+
+1. **Open your project in Roo Code**
+2. **Select the bmad-master mode** from the mode selector (usually in status bar)
+3. **Shard the PRD**: Type `*shard-doc docs/prd.md prd`
+4. **Shard the architecture**: Type `*shard-doc docs/architecture.md architecture`
+
+This creates organized folders:
+
+- `docs/prd/` - Contains broken down PRD sections
+- `docs/architecture/` - Contains broken down architecture sections
+
+## Step 4: Story Development Cycle
+
+Now begin the iterative development cycle:
+
+### Create Stories (Scrum Master)
+
+1. **Start a new chat or conversation**
+2. **Switch to SM mode**: Select `bmad-sm` from the mode selector
+3. **Create story**: Type `*create` (this runs the create-next-story task)
+4. **Review the generated story**
+5. **If approved**: Set story status to "Approved" in the story file
+
+### Implement Stories (Developer)
+
+1. **Start a new conversation**
+2. **Switch to Dev mode**: Select `bmad-dev` from the mode selector
+3. **The agent will ask which story to implement**
+4. **Follow the development tasks** the agent provides
+5. **When story is complete**: Mark status as "Done"
+
+### Repeat the Cycle
+
+1. **Switch to SM mode** (`bmad-sm`)
+2. **Create next story**: Type `*create`
+3. **Review and approve**
+4. **Switch to Dev mode** (`bmad-dev`)
+5. **Implement the story**
+6. **Repeat until project complete**
+
+## Available Custom Modes in Roo Code
+
+All BMAD agents are available as custom modes:
+
+- `bmad-bmad-master` - 🧙 Universal task executor
+- `bmad-sm` - 🏃 Scrum Master for story creation
+- `bmad-dev` - 💻 Full-stack developer for implementation
+- `bmad-architect` - 🏗️ Solution architect for design
+- `bmad-pm` - 📋 Product manager for planning
+- `bmad-analyst` - 📊 Business analyst for requirements
+- `bmad-qa` - 🧪 QA specialist for testing
+- `bmad-po` - 🎯 Product owner for prioritization
+- `bmad-ux-expert` - 🎨 UX specialist for design
+
+## Roo Code-Specific Features
+
+- **Custom modes are stored in**: `.roo/.roomodes` file
+- **Mode switching**: Use the mode selector in Roo Code's interface
+- **File permissions**: Each agent has specific file access permissions
+  - **Documentation agents** (SM, PM, PO, Analyst): Limited to `.md` and `.txt` files
+  - **Technical agents** (Dev, Architect, Master): Full file access
+  - **QA agents**: Access to test files and documentation
+  - **UX agents**: Access to design-related files
+- **Context preservation**: Modes maintain context within conversations
+
+## Key Workflow Principles
+
+1. **Switch modes instead of starting new chats** - Roo Code handles context better with mode switching
+2. **Use Gemini for initial planning** and ideation with the team-fullstack bundle
+3. **Use bmad-master mode for document management** (sharding, templates, etc.)
+4. **Follow the SM → Dev mode cycle** for consistent story development
+5. **Review and approve stories** before implementation begins
+
+## Tips for Success
+
+- **Use mode selector effectively**: Switch modes as needed for different tasks
+- **Respect file permissions**: Agents can only edit files they have permission for
+- **Use \*help command**: Every mode supports `*help` to see available commands
+- **Review generated content**: Always review and approve stories before marking them ready
+- **Maintain status updates**: Keep story statuses current (Draft → Approved → InProgress → Done)
+- **Leverage Roo's context**: Modes can maintain context across the conversation
+
+## File Permission Summary
+
+- **bmad-analyst, bmad-pm, bmad-po, bmad-sm**: `.md`, `.txt` files only
+- **bmad-architect**: `.md`, `.txt`, `.yml`, `.yaml`, `.json` files
+- **bmad-qa**: Test files (`.test.js`, `.spec.ts`, etc.) and `.md` files
+- **bmad-ux-expert**: `.md`, `.css`, `.scss`, `.html`, `.jsx`, `.tsx` files
+- **bmad-dev, bmad-bmad-master, bmad-orchestrator**: Full file access
+
+This workflow ensures systematic, AI-assisted development following agile principles with clear handoffs between planning, story creation, and implementation phases.

package/docs/sample-output/simple-fullstack-greenfield/prd.md

@@ -0,0 +1,42 @@
+# PRD
+
+## Epic 1: Core To-Do Functionality
+
+**Goal:** To deliver a functional, single-user to-do application with user authentication and full CRUD (Create, Read, Update, Delete) capabilities for tasks.
+
+**Stories:**
+
+**Story 1.1: User Authentication**
+
+- **As a** user,
+- **I want** to be able to sign up, log in, and log out,
+- **so that** I can securely manage my personal to-do list.
+- **Acceptance Criteria:**
+  1.  The application uses the Supabase Auth UI for login and sign-up forms.
+  2.  A user can create an account and will be automatically logged in.
+  3.  A logged-in user can log out, which redirects them to the login page.
+  4.  The main to-do list page is protected and only visible to authenticated users.
+
+**Story 1.2: Create and View To-Dos**
+
+- **As an** authenticated user,
+- **I want** to enter a task into an input field and see it appear on my to-do list,
+- **so that** I can keep track of my tasks.
+- **Acceptance Criteria:**
+  1.  There is a text input field and a "Create" button on the main page.
+  2.  Submitting a new task adds it to the database and displays it in the list of to-dos without a page refresh.
+  3.  The to-do list is fetched from the Supabase database when the page loads.
+  4.  The input field is cleared after a to-do is successfully created.
+
+**Story 1.3: Update and Delete To-Dos**
+
+- **As an** authenticated user,
+- **I want** to be able to mark a to-do as complete and delete it,
+- **so that** I can manage my task list effectively.
+- **Acceptance Criteria:**
+  1.  Each to-do item has a checkbox or button to toggle its "completed" status.
+  2.  Changing the status updates the item in the database and visually (e.g., with a strikethrough).
+  3.  Each to-do item has a "Delete" button.
+  4.  Clicking "Delete" removes the to-do from the UI and the database.
+
+With this epic, the planning phase is complete. All the requirements are clearly defined and structured for development.

package/docs/versioning-and-releases.md

@@ -2,17 +2,17 @@
 
 ## Automated Releases (Recommended)
 
-The easiest way to release new versions is through **automatic semantic releases**. Just commit with the right message format and push and everything else happens automatically.
+The easiest way to release new versions is through **automatic semantic releases**. Just commit with the right message format and push - everything else happens automatically!
 
 ### Commit Message Format
 
 Use these prefixes to control what type of release happens:
 
-```bash
+````bash
 fix: resolve CLI argument parsing bug      # → patch release (4.1.0 → 4.1.1)
 feat: add new agent orchestration mode     # → minor release (4.1.0 → 4.2.0)
 feat!: redesign CLI interface              # → major release (4.1.0 → 5.0.0)
-```
+```text
 
 ### What Happens Automatically
 
@@ -35,30 +35,30 @@ git push
 
 # That's it! Release happens automatically 🎉
 # Users can now run: npx bmad-method (and get the new version)
-```
+````
 
 ### Commits That DON'T Trigger Releases
 
 These commit types won't create releases (use them for maintenance):
 
-```bash
+````bash
 chore: update dependencies     # No release
 docs: fix typo in readme      # No release
 style: format code            # No release
 test: add unit tests          # No release
-```
+```text
 
 ### Test Your Setup
 
 ```bash
 npm run release:test    # Safe to run locally - tests the config
-```
+````
 
 ---
 
 ## Manual Release Methods (Exceptions Only)
 
-⚠️ Only use these methods if you need to bypass the automatic system
+**⚠️ Only use these methods if you need to bypass the automatic system**
 
 ### Quick Manual Version Bump
 
@@ -75,3 +75,11 @@ git push && git push --tags
 ### Manual GitHub Actions Trigger
 
 You can also trigger releases manually through GitHub Actions workflow dispatch if needed.
+
+---
+
+## Summary
+
+**For 99% of releases**: Just use `fix:` or `feat:` commit messages and push. Everything else is automatic!
+
+**Manual methods**: Only needed for special cases or if you want to bypass the automated system.

package/docs/versions.md

@@ -2,9 +2,9 @@
 
 ## Previous Versions
 
-- [Version 3](https://github.com/bmadcode/BMad-Method/tree/V3)
-- [Version 2](https://github.com/bmadcode/BMad-Method/tree/V2)
-- [Version 1](https://github.com/bmadcode/BMad-Method/tree/V1)
+- [Version 3](https://github.com/bmadcode/BMAD-METHOD/tree/V3)
+- [Version 2](https://github.com/bmadcode/BMAD-METHOD/tree/V2)
+- [Version 1](https://github.com/bmadcode/BMAD-METHOD/tree/V1)
 
 ## Current Version: V4 - Alpha
 
@@ -16,6 +16,7 @@ Guiding Principles of V4:
 - Helpers for installers and web builders that will work with any OS and IDE easily
 - Align all agents to be the same for IDE and Web, without losing the power of the web versions, or the leanness of the files in the IDE to reduce context
 - Further improvements to the two most important agents - the SM and DEV
+- Expansion Packs - Coming soon...
 
 ## V3
 
@@ -25,7 +26,7 @@ V3 didn't fix the disconnect, but it did make it easier to maintain them all in
 
 V3's biggest impact was a full explosion of customizability. Tasks, Personas, Agent Configurations, Doc Templates, data payloads.
 
-BUT - the BIGGEST change was the realization that we were barely scratching the surface of what could be loaded into Gemini Gems and still have very long chats. The BMad AGENT arose, and with a single V3 release - the future of the BMad Method was changed forever.
+BUT - the BIGGEST change was the realization that we were barely scratching the surface of what could be loaded into Gemini Gems and still have very long chats. The BMAD AGENT arose, and with a single V3 release - the future of the BMad Method was changed forever.
 
 Now, instead of configuring 4+ web agents, all needing many files uploaded to create them, a single Agent called BMad, with a whole team, and the ability to switch and maintain personas evolved. Now you could in the same chat thread, talk to the whole team, or anyone on the team. No more exporting and reimporting docs to different chats - all of the sudden, you could finish the PRD, and ask Josh to pass it off to the Architect, and that was it, the architect just had it and we moved on! And all of that with just 7 total files to upload, delivering all power.