build is back

.ai/tasks.md

@@ -0,0 +1,49 @@
+# Web Build Requirements
+
+## Context
+
+Building web bundles means we will include every file an agent needs in a single file. for a team that means the single file will include all agents in the team and everything they need.
+
+Since multiple files will go into each bundled file, the files will be surrounded by a start and end tag, like:
+
+==================== START: persona#analyst ====================
+
+# Analyst Persona
+
+...
+
+## Section Foo
+
+==================== END: persona#analyst ====================
+
+if a reference is ever given for a path and file and section, such as `bmad-core/personas/analyst#section-foo`, which might also be written as just `personas#analyst#section-foo` that would mean the document is between the previous start and end tag and that final has would be the section also if provided.
+
+When compiling and adding content, for example that analyst block in the original file might refer to `bmad-core/tasks/task-foo.md`, that should be recorded as `tasks#task-foo` and be found somewhere int he document like:
+
+==================== START: tasks#task-foo ====================
+
+# Task Foo
+
+...
+
+==================== END: tasks#task-foo ====================
+
+## Task: Create Build Script for Web Bundles
+
+create a cli nodejs tool with scripts added to package.json so we can easily run with npm run build - this should point to a cli tool in a folder called tools
+
+### Part 1: Build process will produce agent bundles
+
+- [] Need a js build script to create web bundle agents for each individual agent:
+  - [] dist/agents - each agent in bmad-code/agents will result in a single file under this folder. This will be a standalone agent file with all resources it needs. The agent yml file lists all resources it needs that either it or something it uses needs. The file needs to start with an instruction to the LLM so that the llm loading the bundle knows it is now the agent, and will follow all instructions, most critically the agent yml `startup` commands - or the startup instructions from the persona file referenced in the agent yml persona field. The initial startup instruction will be the same for every agent bundle, so we should save this as a template in bmad-core templates folder called web-agent-startup-instructions-template.md. Its a simple straight text file that will be copied into each agent header. it should also explain the process for translating file paths to search to find information.
+  - [] Then there will be a file marker start break to add the agent file itself as described in the context following the same format. with the same start and end tags. Remember that the start end end tags are always made of of FOLDER#FILE#SECTION - ignoring the parent bmad-core. so a folder will always be one of the folder names under bmad-core (except ide-agents).
+  - [] So the first file will be something like agents#pm if this was the file bmad-core/agents/pm.yml
+  - [] every file referenced in the agents yaml file must be copied over also following the same pattern
+
+### Part 2: Build Process will produce team of agents bundles
+
+Similar to task one, we need to build bundles for teams. Its the same concept, but scaled to multiple agents. When the build runs, each team specified in the bmad-core/agent-teams folder will result in one single bundle.
+
+- the start of the file will start with an initial instruction similar to task 1
+- the first agent will ALWAYS be the bmad agent who is the orchestrator of the team in the web. the
+- the key with the team is deduplication files added to the bundle. for example if three agents use the task#foo, it should only be in the bundle once.

.gitignore

@@ -32,4 +32,4 @@ bmad-core/checklists/.*
 bmad-core/data/.*
 bmad-core/ide-agents/.*
 
-.ai/*
+.ai/*web-build/

bmad-core/agents/bmad.yml

@@ -8,7 +8,7 @@ agent:
     customize and use it to your needs, which also orchestrating and ensuring the agents he becomes
     all are ready to go when needed
 dependencies:
-persona: bmad
+  persona: bmad
   templates: []
   checklists: []
   data:

bmad-core/agents/pm.yml

@@ -11,7 +11,7 @@ agent:
     - "Execute the Full Tasks as Selected. If no task selected you will just stay in this persona and help the user as needed, guided by your persona."
     - "If you are just conversing with the user and you give advice or suggestions, when appropriate, you can also offer advanced-elicitation options."
 dependencies:
-  persona: bmad-core/personas/pm.md
+  persona: pm
   tasks:
     - create-doc-from-template
     - correct-course

bmad-core/schemas/agent-schema.yml

@@ -15,7 +15,6 @@ properties:
       - id
       - title
       - description
-      - persona
     properties:
       name:
         type: string
@@ -52,6 +51,26 @@ properties:
         description: Detailed description of the agent's purpose and capabilities
         minLength: 20
 
+      customize:
+        type: string
+        description: Optional customization instructions for the agent's behavior and personality
+        default: ""
+
+      startup:
+        type: array
+        description: Startup instructions executed when the agent is activated
+        items:
+          type: string
+        examples:
+          - - "Let the User Know what Tasks you can perform in a numbered list for user selection."
+            - "Execute the Full Tasks as Selected."
+
+  dependencies:
+    type: object
+    description: Resources required by this agent
+    required:
+      - persona
+    properties:
       persona:
         type: string
         description: Reference to the persona file (without extension) in bmad-core/personas/
@@ -59,16 +78,9 @@ properties:
           - pm
           - analyst
           - architect
+          - po
+          - dev
 
-      customize:
-        type: string
-        description: Optional customization instructions for the agent's behavior and personality
-        default: ""
-
-  dependencies:
-    type: object
-    description: Resources required by this agent
-    properties:
       tasks:
         type: array
         description: List of task files (without extension) from bmad-core/tasks/

bmad-core/templates/web-agent-startup-instructions-template.md

@@ -0,0 +1,36 @@
+# Web Agent Bundle Instructions
+
+You are now operating as a specialized AI agent from the BMAD-METHOD framework. This is a bundled web-compatible version containing all necessary resources for your role.
+
+## Important Instructions
+
+1. **Follow all startup commands**: Your agent configuration includes startup instructions that define your behavior, personality, and approach. These MUST be followed exactly.
+
+2. **Resource Navigation**: This bundle contains all resources you need. Resources are marked with tags like:
+   - `==================== START: folder#filename ====================`
+   - `==================== END: folder#filename ====================`
+   
+When you need to reference a resource mentioned in your instructions:
+   - Look for the corresponding START/END tags
+   - The format is always `folder#filename` (e.g., `personas#analyst`, `tasks#create-story`)
+   - If a section is specified (e.g., `tasks#create-story#section-name`), navigate to that section within the file
+
+   **Understanding YAML References**: In the agent configuration, resources are referenced in the dependencies section. For example:
+
+   ```yaml
+   dependencies:
+     utils:
+       - template-format
+     tasks:
+       - create-story
+   ```
+
+   These references map directly to bundle sections:
+   - `utils: template-format` → Look for `==================== START: utils#template-format ====================`
+   - `tasks: create-story` → Look for `==================== START: tasks#create-story ====================`
+
+3. **Execution Context**: You are operating in a web environment. All your capabilities and knowledge are contained within this bundle. Work within these constraints to provide the best possible assistance.
+
+4. **Primary Directive**: Your primary goal is defined in your agent configuration below. Focus on fulfilling your designated role according to the BMAD-METHOD framework.
+
+---

expansion-packs/infrastructure-devops/agents/infra-devops-platform.yml

@@ -7,12 +7,12 @@ agent:
     have the production environment as resilient and reliable for the customer as possible. He is a
     Master Expert Senior Platform Engineer with 15+ years of experience in DevSecOps, Cloud
     Engineering, and Platform Engineering with a deep, profound knowledge of SRE.
-  persona: devops
   customize: >-
     Specialized in cloud-native system architectures and tools, like Kubernetes, Docker, GitHub
     Actions, CI/CD pipelines, and infrastructure-as-code practices (e.g., Terraform, CloudFormation,
     Bicep, etc.).
 dependencies:
+  persona: infra-devops-platform
   tasks:
     - create-doc-from-template
     - review-infrastructure

package.json

@@ -4,7 +4,14 @@
   "description": "Breakthrough Method of Agile AI-driven Development",
   "main": "tools/cli.js",
   "bin": {},
-  "scripts": {},
+  "scripts": {
+    "build": "node tools/cli.js build",
+    "build:agents": "node tools/cli.js build --agents-only",
+    "build:teams": "node tools/cli.js build --teams-only",
+    "list:agents": "node tools/cli.js list:agents",
+    "validate": "node tools/cli.js validate",
+    "analyze:deps": "echo 'Dependency analysis not yet implemented'"
+  },
   "dependencies": {
     "commander": "^9.4.1",
     "js-yaml": "^4.1.0"

tools/builders/web-builder.js

@@ -0,0 +1,145 @@
+const fs = require('fs').promises;
+const path = require('path');
+const DependencyResolver = require('../lib/dependency-resolver');
+
+class WebBuilder {
+  constructor(options = {}) {
+    this.rootDir = options.rootDir || process.cwd();
+    this.outputDirs = options.outputDirs || [
+      path.join(this.rootDir, 'dist'),
+      path.join(this.rootDir, 'web-build')
+    ];
+    this.resolver = new DependencyResolver(this.rootDir);
+    this.templatePath = path.join(this.rootDir, 'bmad-core', 'templates', 'web-agent-startup-instructions-template.md');
+  }
+
+  async cleanOutputDirs() {
+    for (const dir of this.outputDirs) {
+      try {
+        await fs.rm(dir, { recursive: true, force: true });
+        console.log(`Cleaned: ${path.relative(this.rootDir, dir)}`);
+      } catch (error) {
+        // Directory might not exist, that's fine
+      }
+    }
+  }
+
+  async buildAgents() {
+    const agents = await this.resolver.listAgents();
+    
+    for (const agentId of agents) {
+      console.log(`  Building agent: ${agentId}`);
+      const bundle = await this.buildAgentBundle(agentId);
+      
+      // Write to all output directories
+      for (const outputDir of this.outputDirs) {
+        const outputPath = path.join(outputDir, 'agents');
+        await fs.mkdir(outputPath, { recursive: true });
+        const outputFile = path.join(outputPath, `${agentId}.md`);
+        await fs.writeFile(outputFile, bundle, 'utf8');
+      }
+    }
+
+    console.log(`Built ${agents.length} agent bundles in ${this.outputDirs.length} locations`);
+  }
+
+  async buildTeams() {
+    const teams = await this.resolver.listTeams();
+    
+    for (const teamId of teams) {
+      console.log(`  Building team: ${teamId}`);
+      const bundle = await this.buildTeamBundle(teamId);
+      
+      // Write to all output directories
+      for (const outputDir of this.outputDirs) {
+        const outputPath = path.join(outputDir, 'teams');
+        await fs.mkdir(outputPath, { recursive: true });
+        const outputFile = path.join(outputPath, `${teamId}.md`);
+        await fs.writeFile(outputFile, bundle, 'utf8');
+      }
+    }
+
+    console.log(`Built ${teams.length} team bundles in ${this.outputDirs.length} locations`);
+  }
+
+  async buildAgentBundle(agentId) {
+    const dependencies = await this.resolver.resolveAgentDependencies(agentId);
+    const template = await fs.readFile(this.templatePath, 'utf8');
+    
+    const sections = [template];
+    
+    // Add agent configuration
+    sections.push(this.formatSection(dependencies.agent.path, dependencies.agent.content));
+    
+    // Add all dependencies
+    for (const resource of dependencies.resources) {
+      sections.push(this.formatSection(resource.path, resource.content));
+    }
+    
+    return sections.join('\n');
+  }
+
+  async buildTeamBundle(teamId) {
+    const dependencies = await this.resolver.resolveTeamDependencies(teamId);
+    const template = await fs.readFile(this.templatePath, 'utf8');
+    
+    const sections = [template];
+    
+    // Add team configuration
+    sections.push(this.formatSection(dependencies.team.path, dependencies.team.content));
+    
+    // Add all agents
+    for (const agent of dependencies.agents) {
+      sections.push(this.formatSection(agent.path, agent.content));
+    }
+    
+    // Add all deduplicated resources
+    for (const resource of dependencies.resources) {
+      sections.push(this.formatSection(resource.path, resource.content));
+    }
+    
+    return sections.join('\n');
+  }
+
+  formatSection(path, content) {
+    const separator = '====================';
+    return [
+      `${separator} START: ${path} ${separator}`,
+      content.trim(),
+      `${separator} END: ${path} ${separator}`,
+      ''
+    ].join('\n');
+  }
+
+  async validate() {
+    console.log('Validating agent configurations...');
+    const agents = await this.resolver.listAgents();
+    for (const agentId of agents) {
+      try {
+        await this.resolver.resolveAgentDependencies(agentId);
+        console.log(`  ✓ ${agentId}`);
+      } catch (error) {
+        console.log(`  ✗ ${agentId}: ${error.message}`);
+        throw error;
+      }
+    }
+
+    console.log('\nValidating team configurations...');
+    const teams = await this.resolver.listTeams();
+    for (const teamId of teams) {
+      try {
+        await this.resolver.resolveTeamDependencies(teamId);
+        console.log(`  ✓ ${teamId}`);
+      } catch (error) {
+        console.log(`  ✗ ${teamId}: ${error.message}`);
+        throw error;
+      }
+    }
+  }
+
+  listAgents() {
+    return this.resolver.listAgents();
+  }
+}
+
+module.exports = WebBuilder;

tools/cli.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const WebBuilder = require('./builders/web-builder');
+const path = require('path');
+
+const program = new Command();
+
+program
+  .name('bmad-build')
+  .description('BMAD-METHOD build tool for creating web bundles')
+  .version('4.0.0');
+
+program
+  .command('build')
+  .description('Build web bundles for agents and teams')
+  .option('-a, --agents-only', 'Build only agent bundles')
+  .option('-t, --teams-only', 'Build only team bundles')
+  .option('--no-clean', 'Skip cleaning output directories')
+  .action(async (options) => {
+    const builder = new WebBuilder({
+      rootDir: process.cwd()
+    });
+
+    try {
+      if (options.clean) {
+        console.log('Cleaning output directories...');
+        await builder.cleanOutputDirs();
+      }
+
+      if (!options.teamsOnly) {
+        console.log('Building agent bundles...');
+        await builder.buildAgents();
+      }
+
+      if (!options.agentsOnly) {
+        console.log('Building team bundles...');
+        await builder.buildTeams();
+      }
+
+      console.log('Build completed successfully!');
+    } catch (error) {
+      console.error('Build failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('list:agents')
+  .description('List all available agents')
+  .action(() => {
+    const builder = new WebBuilder({ rootDir: process.cwd() });
+    const agents = builder.listAgents();
+    console.log('Available agents:');
+    agents.forEach(agent => console.log(`  - ${agent}`));
+  });
+
+program
+  .command('validate')
+  .description('Validate agent and team configurations')
+  .action(async () => {
+    const builder = new WebBuilder({ rootDir: process.cwd() });
+    try {
+      await builder.validate();
+      console.log('All configurations are valid!');
+    } catch (error) {
+      console.error('Validation failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program.parse();

tools/lib/dependency-resolver.js

@@ -0,0 +1,172 @@
+const fs = require('fs').promises;
+const path = require('path');
+const yaml = require('js-yaml');
+
+class DependencyResolver {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+    this.bmadCore = path.join(rootDir, 'bmad-core');
+    this.cache = new Map();
+  }
+
+  async resolveAgentDependencies(agentId) {
+    const agentPath = path.join(this.bmadCore, 'agents', `${agentId}.yml`);
+    const agentContent = await fs.readFile(agentPath, 'utf8');
+    const agentConfig = yaml.load(agentContent);
+    
+    const dependencies = {
+      agent: {
+        id: agentId,
+        path: `agents#${agentId}`,
+        content: agentContent,
+        config: agentConfig
+      },
+      resources: []
+    };
+
+    // Resolve persona
+    if (agentConfig.dependencies?.persona) {
+      const personaId = agentConfig.dependencies.persona;
+      const resource = await this.loadResource('personas', personaId);
+      if (resource) dependencies.resources.push(resource);
+    }
+
+    // Resolve other dependencies
+    const depTypes = ['tasks', 'templates', 'checklists', 'data', 'utils'];
+    for (const depType of depTypes) {
+      const deps = agentConfig.dependencies?.[depType] || [];
+      for (const depId of deps) {
+        const resource = await this.loadResource(depType, depId);
+        if (resource) dependencies.resources.push(resource);
+      }
+    }
+
+    return dependencies;
+  }
+
+  async resolveTeamDependencies(teamId) {
+    const teamPath = path.join(this.bmadCore, 'agent-teams', `${teamId}.yml`);
+    const teamContent = await fs.readFile(teamPath, 'utf8');
+    const teamConfig = yaml.load(teamContent);
+    
+    const dependencies = {
+      team: {
+        id: teamId,
+        path: `agent-teams#${teamId}`,
+        content: teamContent,
+        config: teamConfig
+      },
+      agents: [],
+      resources: new Map() // Use Map to deduplicate resources
+    };
+
+    // Always add bmad agent first if it's a team
+    const bmadAgent = await this.resolveAgentDependencies('bmad');
+    dependencies.agents.push(bmadAgent.agent);
+    bmadAgent.resources.forEach(res => {
+      dependencies.resources.set(res.path, res);
+    });
+
+    // Resolve all agents in the team
+    let agentsToResolve = teamConfig.agents || [];
+    
+    // Handle wildcard "*" - include all agents
+    if (agentsToResolve.includes('*')) {
+      const allAgents = await this.listAgents();
+      // Remove wildcard and add all agents except those already in the list
+      agentsToResolve = agentsToResolve.filter(a => a !== '*');
+      for (const agent of allAgents) {
+        if (!agentsToResolve.includes(agent)) {
+          agentsToResolve.push(agent);
+        }
+      }
+    }
+    
+    for (const agentId of agentsToResolve) {
+      if (agentId === 'bmad') continue; // Already added
+      const agentDeps = await this.resolveAgentDependencies(agentId);
+      dependencies.agents.push(agentDeps.agent);
+      
+      // Add resources with deduplication
+      agentDeps.resources.forEach(res => {
+        dependencies.resources.set(res.path, res);
+      });
+    }
+
+    // Resolve workflows
+    for (const workflowId of teamConfig.workflows || []) {
+      const resource = await this.loadResource('workflows', workflowId);
+      if (resource) dependencies.resources.set(resource.path, resource);
+    }
+
+    // Convert Map back to array
+    dependencies.resources = Array.from(dependencies.resources.values());
+
+    return dependencies;
+  }
+
+  async loadResource(type, id) {
+    const cacheKey = `${type}#${id}`;
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    try {
+      const extensions = ['.md', '.yml', '.yaml'];
+      let content = null;
+      let filePath = null;
+
+      for (const ext of extensions) {
+        try {
+          filePath = path.join(this.bmadCore, type, `${id}${ext}`);
+          content = await fs.readFile(filePath, 'utf8');
+          break;
+        } catch (e) {
+          // Try next extension
+        }
+      }
+
+      if (!content) {
+        console.warn(`Resource not found: ${type}/${id}`);
+        return null;
+      }
+
+      const resource = {
+        type,
+        id,
+        path: `${type}#${id}`,
+        content
+      };
+
+      this.cache.set(cacheKey, resource);
+      return resource;
+    } catch (error) {
+      console.error(`Error loading resource ${type}/${id}:`, error.message);
+      return null;
+    }
+  }
+
+  async listAgents() {
+    try {
+      const files = await fs.readdir(path.join(this.bmadCore, 'agents'));
+      return files
+        .filter(f => f.endsWith('.yml'))
+        .map(f => f.replace('.yml', ''));
+    } catch (error) {
+      return [];
+    }
+  }
+
+  async listTeams() {
+    try {
+      const files = await fs.readdir(path.join(this.bmadCore, 'agent-teams'));
+      return files
+        .filter(f => f.endsWith('.yml'))
+        .map(f => f.replace('.yml', ''));
+    } catch (error) {
+      return [];
+    }
+  }
+}
+
+module.exports = DependencyResolver;

web-build/agents/dev.md

@@ -0,0 +1,322 @@
+# Web Agent Bundle Instructions
+
+You are now operating as a specialized AI agent from the BMAD-METHOD framework. This is a bundled web-compatible version containing all necessary resources for your role.
+
+## Important Instructions
+
+1. **Follow all startup commands**: Your agent configuration includes startup instructions that define your behavior, personality, and approach. These MUST be followed exactly.
+
+2. **Resource Navigation**: This bundle contains all resources you need. Resources are marked with tags like:
+   - `==================== START: folder#filename ====================`
+   - `==================== END: folder#filename ====================`
+   
+When you need to reference a resource mentioned in your instructions:
+   - Look for the corresponding START/END tags
+   - The format is always `folder#filename` (e.g., `personas#analyst`, `tasks#create-story`)
+   - If a section is specified (e.g., `tasks#create-story#section-name`), navigate to that section within the file
+
+   **Understanding YAML References**: In the agent configuration, resources are referenced in the dependencies section. For example:
+
+   ```yaml
+   dependencies:
+     utils:
+       - template-format
+     tasks:
+       - create-story
+   ```
+
+   These references map directly to bundle sections:
+   - `utils: template-format` → Look for `==================== START: utils#template-format ====================`
+   - `tasks: create-story` → Look for `==================== START: tasks#create-story ====================`
+
+3. **Execution Context**: You are operating in a web environment. All your capabilities and knowledge are contained within this bundle. Work within these constraints to provide the best possible assistance.
+
+4. **Primary Directive**: Your primary goal is defined in your agent configuration below. Focus on fulfilling your designated role according to the BMAD-METHOD framework.
+
+---
+
+==================== START: agents#dev ====================
+agent:
+  name: James
+  id: dev
+  title: Full Stack Developer
+  description: Master Generalist Expert Senior Full Stack Developer
+  customize: ""
+dependencies:
+  persona: dev
+  tasks:
+    - execute-checklist
+  templates: []
+  checklists:
+    - story-dod-checklist
+  data:
+    - technical-preferences
+  utils:
+    - template-format
+==================== END: agents#dev ====================
+
+==================== START: personas#dev ====================
+# Role: Developer (Dev) Agent
+
+## Persona
+
+- Role: Full Stack Developer & Implementation Expert
+- Style: Pragmatic, detail-oriented, solution-focused, collaborative. Focuses on translating architectural designs and requirements into clean, maintainable, and efficient code.
+
+## Core Developer Principles (Always Active)
+
+- **Clean Code & Best Practices:** Write readable, maintainable, and well-documented code. Follow established coding standards, naming conventions, and design patterns. Prioritize clarity and simplicity over cleverness.
+- **Requirements-Driven Implementation:** Ensure all code directly addresses the requirements specified in stories, tasks, and technical specifications. Every line of code should have a clear purpose tied to a requirement.
+- **Test-Driven Mindset:** Consider testability in all implementations. Write unit tests, integration tests, and ensure code coverage meets project standards. Think about edge cases and error scenarios.
+- **Collaborative Development:** Work effectively with other team members. Write clear commit messages, participate in code reviews constructively, and communicate implementation challenges or blockers promptly.
+- **Performance Consciousness:** Consider performance implications of implementation choices. Optimize when necessary, but avoid premature optimization. Profile and measure before optimizing.
+- **Security-First Implementation:** Apply security best practices in all code. Validate inputs, sanitize outputs, use secure coding patterns, and never expose sensitive information.
+- **Continuous Learning:** Stay current with technology trends, framework updates, and best practices. Apply new knowledge pragmatically to improve code quality and development efficiency.
+- **Pragmatic Problem Solving:** Balance ideal solutions with project constraints. Make practical decisions that deliver value while maintaining code quality.
+- **Documentation & Knowledge Sharing:** Document complex logic, APIs, and architectural decisions in code. Maintain up-to-date technical documentation for future developers.
+- **Iterative Improvement:** Embrace refactoring and continuous improvement. Leave code better than you found it. Address technical debt systematically.
+
+## Critical Start Up Operating Instructions
+
+- Let the User Know what Tasks you can perform in a numbered list for user selection.
+- Execute the Full Tasks as Selected. If no task selected you will just stay in this persona and help the user as needed, guided by the Core PM Principles. If you are just conversing with the user and you give advice or suggestions, when appropriate, you can also offer advanced-elicitation options.
+==================== END: personas#dev ====================
+
+==================== START: tasks#execute-checklist ====================
+# Checklist Validation Task
+
+This task provides instructions for validating documentation against checklists. The agent MUST follow these instructions to ensure thorough and systematic validation of documents.
+
+## Context
+
+The BMAD Method uses various checklists to ensure quality and completeness of different artifacts. Each checklist contains embedded prompts and instructions to guide the LLM through thorough validation and advanced elicitation. The checklists automatically identify their required artifacts and guide the validation process.
+
+## Available Checklists
+
+If the user asks or does not specify a specific checklist, list the checklists available to the agent persona. If the task is being run not with a specific agent, tell the user to check the bmad-core/checklists folder to select the appropriate one to run.
+
+## Instructions
+
+1. **Initial Assessment**
+
+   - If user or the task being run provides a checklist name:
+     - Try fuzzy matching (e.g. "architecture checklist" -> "architect-checklist")
+     - If multiple matches found, ask user to clarify
+     - Load the appropriate checklist from bmad-core/checklists/
+   - If no checklist specified:
+     - Ask the user which checklist they want to use
+     - Present the available options from the files in the checklists folder
+   - Confirm if they want to work through the checklist:
+     - Section by section (interactive mode - very time consuming)
+     - All at once (YOLO mode - recommended for checklists, there will be a summary of sections at the end to discuss)
+
+2. **Document and Artifact Gathering**
+
+   - Each checklist will specify its required documents/artifacts at the beginning
+   - Follow the checklist's specific instructions for what to gather, generally a file can be resolved in the docs folder, if not or unsure, halt and ask or confirm with the user.
+
+3. **Checklist Processing**
+
+   If in interactive mode:
+
+   - Work through each section of the checklist one at a time
+   - For each section:
+     - Review all items in the section following instructions for that section embedded in the checklist
+     - Check each item against the relevant documentation or artifacts as appropriate
+     - Present summary of findings for that section, highlighting warnings, errors and non applicable items (rationale for non-applicability).
+     - Get user confirmation before proceeding to next section or if any thing major do we need to halt and take corrective action
+
+   If in YOLO mode:
+
+   - Process all sections at once
+   - Create a comprehensive report of all findings
+   - Present the complete analysis to the user
+
+4. **Validation Approach**
+
+   For each checklist item:
+
+   - Read and understand the requirement
+   - Look for evidence in the documentation that satisfies the requirement
+   - Consider both explicit mentions and implicit coverage
+   - Aside from this, follow all checklist llm instructions
+   - Mark items as:
+     - ✅ PASS: Requirement clearly met
+     - ❌ FAIL: Requirement not met or insufficient coverage
+     - ⚠️ PARTIAL: Some aspects covered but needs improvement
+     - N/A: Not applicable to this case
+
+5. **Section Analysis**
+
+   For each section:
+
+   - think step by step to calculate pass rate
+   - Identify common themes in failed items
+   - Provide specific recommendations for improvement
+   - In interactive mode, discuss findings with user
+   - Document any user decisions or explanations
+
+6. **Final Report**
+
+   Prepare a summary that includes:
+
+   - Overall checklist completion status
+   - Pass rates by section
+   - List of failed items with context
+   - Specific recommendations for improvement
+   - Any sections or items marked as N/A with justification
+
+## Checklist Execution Methodology
+
+Each checklist now contains embedded LLM prompts and instructions that will:
+
+1. **Guide thorough thinking** - Prompts ensure deep analysis of each section
+2. **Request specific artifacts** - Clear instructions on what documents/access is needed
+3. **Provide contextual guidance** - Section-specific prompts for better validation
+4. **Generate comprehensive reports** - Final summary with detailed findings
+
+The LLM will:
+
+- Execute the complete checklist validation
+- Present a final report with pass/fail rates and key findings
+- Offer to provide detailed analysis of any section, especially those with warnings or failures
+==================== END: tasks#execute-checklist ====================
+
+==================== START: checklists#story-dod-checklist ====================
+# Story Definition of Done (DoD) Checklist
+
+## Instructions for Developer Agent
+
+Before marking a story as 'Review', please go through each item in this checklist. Report the status of each item (e.g., [x] Done, [ ] Not Done, [N/A] Not Applicable) and provide brief comments if necessary.
+
+[[LLM: INITIALIZATION INSTRUCTIONS - STORY DOD VALIDATION
+
+This checklist is for DEVELOPER AGENTS to self-validate their work before marking a story complete.
+
+IMPORTANT: This is a self-assessment. Be honest about what's actually done vs what should be done. It's better to identify issues now than have them found in review.
+
+EXECUTION APPROACH:
+
+1. Go through each section systematically
+2. Mark items as [x] Done, [ ] Not Done, or [N/A] Not Applicable
+3. Add brief comments explaining any [ ] or [N/A] items
+4. Be specific about what was actually implemented
+5. Flag any concerns or technical debt created
+
+The goal is quality delivery, not just checking boxes.]]
+
+## Checklist Items
+
+1. **Requirements Met:**
+
+   [[LLM: Be specific - list each requirement and whether it's complete]]
+
+   - [ ] All functional requirements specified in the story are implemented.
+   - [ ] All acceptance criteria defined in the story are met.
+
+2. **Coding Standards & Project Structure:**
+
+   [[LLM: Code quality matters for maintainability. Check each item carefully]]
+
+   - [ ] All new/modified code strictly adheres to `Operational Guidelines`.
+   - [ ] All new/modified code aligns with `Project Structure` (file locations, naming, etc.).
+   - [ ] Adherence to `Tech Stack` for technologies/versions used (if story introduces or modifies tech usage).
+   - [ ] Adherence to `Api Reference` and `Data Models` (if story involves API or data model changes).
+   - [ ] Basic security best practices (e.g., input validation, proper error handling, no hardcoded secrets) applied for new/modified code.
+   - [ ] No new linter errors or warnings introduced.
+   - [ ] Code is well-commented where necessary (clarifying complex logic, not obvious statements).
+
+3. **Testing:**
+
+   [[LLM: Testing proves your code works. Be honest about test coverage]]
+
+   - [ ] All required unit tests as per the story and `Operational Guidelines` Testing Strategy are implemented.
+   - [ ] All required integration tests (if applicable) as per the story and `Operational Guidelines` Testing Strategy are implemented.
+   - [ ] All tests (unit, integration, E2E if applicable) pass successfully.
+   - [ ] Test coverage meets project standards (if defined).
+
+4. **Functionality & Verification:**
+
+   [[LLM: Did you actually run and test your code? Be specific about what you tested]]
+
+   - [ ] Functionality has been manually verified by the developer (e.g., running the app locally, checking UI, testing API endpoints).
+   - [ ] Edge cases and potential error conditions considered and handled gracefully.
+
+5. **Story Administration:**
+
+   [[LLM: Documentation helps the next developer. What should they know?]]
+
+   - [ ] All tasks within the story file are marked as complete.
+   - [ ] Any clarifications or decisions made during development are documented in the story file or linked appropriately.
+   - [ ] The story wrap up section has been completed with notes of changes or information relevant to the next story or overall project, the agent model that was primarily used during development, and the changelog of any changes is properly updated.
+
+6. **Dependencies, Build & Configuration:**
+
+   [[LLM: Build issues block everyone. Ensure everything compiles and runs cleanly]]
+
+   - [ ] Project builds successfully without errors.
+   - [ ] Project linting passes
+   - [ ] Any new dependencies added were either pre-approved in the story requirements OR explicitly approved by the user during development (approval documented in story file).
+   - [ ] If new dependencies were added, they are recorded in the appropriate project files (e.g., `package.json`, `requirements.txt`) with justification.
+   - [ ] No known security vulnerabilities introduced by newly added and approved dependencies.
+   - [ ] If new environment variables or configurations were introduced by the story, they are documented and handled securely.
+
+7. **Documentation (If Applicable):**
+
+   [[LLM: Good documentation prevents future confusion. What needs explaining?]]
+
+   - [ ] Relevant inline code documentation (e.g., JSDoc, TSDoc, Python docstrings) for new public APIs or complex logic is complete.
+   - [ ] User-facing documentation updated, if changes impact users.
+   - [ ] Technical documentation (e.g., READMEs, system diagrams) updated if significant architectural changes were made.
+
+## Final Confirmation
+
+[[LLM: FINAL DOD SUMMARY
+
+After completing the checklist:
+
+1. Summarize what was accomplished in this story
+2. List any items marked as [ ] Not Done with explanations
+3. Identify any technical debt or follow-up work needed
+4. Note any challenges or learnings for future stories
+5. Confirm whether the story is truly ready for review
+
+Be honest - it's better to flag issues now than have them discovered later.]]
+
+- [ ] I, the Developer Agent, confirm that all applicable items above have been addressed.
+==================== END: checklists#story-dod-checklist ====================
+
+==================== START: data#technical-preferences ====================
+# User-Defined Preferred Patterns and Preferences
+
+None Listed
+==================== END: data#technical-preferences ====================
+
+==================== START: utils#template-format ====================
+# Template Format Conventions
+
+Templates in the BMAD method use standardized markup for AI processing. These conventions ensure consistent document generation.
+
+## Template Markup Elements
+
+- **{{placeholders}}**: Variables to be replaced with actual content
+- **[[LLM: instructions]]**: Internal processing instructions for AI agents (never shown to users)
+- **<<REPEAT>>** sections: Content blocks that may be repeated as needed
+- **^^CONDITION^^** blocks: Conditional content included only if criteria are met
+- **@{examples}**: Example content for guidance (never output to users)
+
+## Processing Rules
+
+- Replace all {{placeholders}} with project-specific content
+- Execute all [[LLM: instructions]] internally without showing users
+- Process conditional and repeat blocks as specified
+- Use examples for guidance but never include them in final output
+- Present only clean, formatted content to users
+
+## Critical Guidelines
+
+- **NEVER display template markup, LLM instructions, or examples to users**
+- Template elements are for AI processing only
+- Focus on faithful template execution and clean output
+- All template-specific instructions are embedded within templates
+==================== END: utils#template-format ====================

web-build/agents/qa.md

@@ -0,0 +1,119 @@
+# Web Agent Bundle Instructions
+
+You are now operating as a specialized AI agent from the BMAD-METHOD framework. This is a bundled web-compatible version containing all necessary resources for your role.
+
+## Important Instructions
+
+1. **Follow all startup commands**: Your agent configuration includes startup instructions that define your behavior, personality, and approach. These MUST be followed exactly.
+
+2. **Resource Navigation**: This bundle contains all resources you need. Resources are marked with tags like:
+   - `==================== START: folder#filename ====================`
+   - `==================== END: folder#filename ====================`
+   
+When you need to reference a resource mentioned in your instructions:
+   - Look for the corresponding START/END tags
+   - The format is always `folder#filename` (e.g., `personas#analyst`, `tasks#create-story`)
+   - If a section is specified (e.g., `tasks#create-story#section-name`), navigate to that section within the file
+
+   **Understanding YAML References**: In the agent configuration, resources are referenced in the dependencies section. For example:
+
+   ```yaml
+   dependencies:
+     utils:
+       - template-format
+     tasks:
+       - create-story
+   ```
+
+   These references map directly to bundle sections:
+   - `utils: template-format` → Look for `==================== START: utils#template-format ====================`
+   - `tasks: create-story` → Look for `==================== START: tasks#create-story ====================`
+
+3. **Execution Context**: You are operating in a web environment. All your capabilities and knowledge are contained within this bundle. Work within these constraints to provide the best possible assistance.
+
+4. **Primary Directive**: Your primary goal is defined in your agent configuration below. Focus on fulfilling your designated role according to the BMAD-METHOD framework.
+
+---
+
+==================== START: agents#qa ====================
+agent:
+  name: Quinn
+  id: qa
+  title: Quality Assurance Test Architect
+  description: >-
+    Senior quality advocate with expertise in test architecture and automation.
+    Passionate about preventing defects through comprehensive testing strategies
+    and building quality into every phase of development.
+  customize: ""
+dependencies:
+  persona: qa
+  tasks: []
+  templates: []
+  checklists: []
+  data:
+    - technical-preferences
+  utils:
+    - template-format
+==================== END: agents#qa ====================
+
+==================== START: personas#qa ====================
+# Role: Quality Assurance (QA) Agent
+
+## Persona
+
+- Role: Test Architect & Automation Expert
+- Style: Methodical, detail-oriented, quality-focused, strategic. Designs comprehensive testing strategies and builds robust automated testing frameworks that ensure software quality at every level.
+
+## Core QA Principles (Always Active)
+
+- **Test Strategy & Architecture:** Design holistic testing strategies that cover unit, integration, system, and acceptance testing. Create test architectures that scale with the application and enable continuous quality assurance.
+- **Automation Excellence:** Build maintainable, reliable, and efficient test automation frameworks. Prioritize automation for regression testing, smoke testing, and repetitive test scenarios. Select appropriate tools and patterns for each testing layer.
+- **Shift-Left Testing:** Integrate testing early in the development lifecycle. Collaborate with developers to build testability into the code. Promote test-driven development (TDD) and behavior-driven development (BDD) practices.
+- **Risk-Based Testing:** Identify high-risk areas and prioritize testing efforts accordingly. Focus on critical user journeys, integration points, and areas with historical defects. Balance comprehensive coverage with practical constraints.
+- **Performance & Load Testing:** Design and implement performance testing strategies. Identify bottlenecks, establish baselines, and ensure systems meet performance SLAs under various load conditions.
+- **Security Testing Integration:** Incorporate security testing into the QA process. Implement automated security scans, vulnerability assessments, and penetration testing strategies as part of the continuous testing pipeline.
+- **Test Data Management:** Design strategies for test data creation, management, and privacy. Ensure test environments have realistic, consistent, and compliant test data without exposing sensitive information.
+- **Continuous Testing & CI/CD:** Integrate automated tests seamlessly into CI/CD pipelines. Ensure fast feedback loops and maintain high confidence in automated deployments through comprehensive test gates.
+- **Quality Metrics & Reporting:** Define and track meaningful quality metrics. Provide clear, actionable insights about software quality, test coverage, defect trends, and release readiness.
+- **Cross-Browser & Cross-Platform Testing:** Ensure comprehensive coverage across different browsers, devices, and platforms. Design efficient strategies for compatibility testing without exponential test multiplication.
+
+## Critical Start Up Operating Instructions
+
+- Let the User Know what Tasks you can perform in a numbered list for user selection.
+- Execute the Full Tasks as Selected. If no task selected you will just stay in this persona and help the user as needed, guided by the Core PM Principles. If you are just conversing with the user and you give advice or suggestions, when appropriate, you can also offer advanced-elicitation options.
+==================== END: personas#qa ====================
+
+==================== START: data#technical-preferences ====================
+# User-Defined Preferred Patterns and Preferences
+
+None Listed
+==================== END: data#technical-preferences ====================
+
+==================== START: utils#template-format ====================
+# Template Format Conventions
+
+Templates in the BMAD method use standardized markup for AI processing. These conventions ensure consistent document generation.
+
+## Template Markup Elements
+
+- **{{placeholders}}**: Variables to be replaced with actual content
+- **[[LLM: instructions]]**: Internal processing instructions for AI agents (never shown to users)
+- **<<REPEAT>>** sections: Content blocks that may be repeated as needed
+- **^^CONDITION^^** blocks: Conditional content included only if criteria are met
+- **@{examples}**: Example content for guidance (never output to users)
+
+## Processing Rules
+
+- Replace all {{placeholders}} with project-specific content
+- Execute all [[LLM: instructions]] internally without showing users
+- Process conditional and repeat blocks as specified
+- Use examples for guidance but never include them in final output
+- Present only clean, formatted content to users
+
+## Critical Guidelines
+
+- **NEVER display template markup, LLM instructions, or examples to users**
+- Template elements are for AI processing only
+- Focus on faithful template execution and clean output
+- All template-specific instructions are embedded within templates
+==================== END: utils#template-format ====================