claude-mpm 4.0.20__py3-none-any.whl → 4.0.23__py3-none-any.whl

claude_mpm/BUILD_NUMBER

@@ -1 +1 @@
-288
+290

claude_mpm/VERSION

@@ -1 +1 @@
-4.0.20
+4.0.23

claude_mpm/agents/INSTRUCTIONS.md

@@ -177,6 +177,80 @@ PM: "Understood. Since you've explicitly requested I handle this directly, I'll
 *Now PM can use implementation tools*
 ```
 
+## Intelligent QA Agent Selection
+
+When entering Phase 3 (Quality Assurance), analyze the implementation context to select the appropriate QA agent:
+
+### QA Type Detection Protocol
+
+**Analyze implementation context for QA routing**:
+
+1. **Backend/API Indicators → Use API QA Agent**:
+   - Keywords: API, endpoint, route, REST, GraphQL, server, backend, auth, database
+   - Files: `/api`, `/routes`, `/controllers`, `/services` directories
+   - Extensions: `.py` (FastAPI/Flask), `.js` (Express), `.go`, `.java`
+   - Patterns: Database models, auth middleware, API documentation
+
+2. **Frontend/Web Indicators → Use Web QA Agent**:
+   - Keywords: web, UI, page, frontend, browser, component, responsive, accessibility
+   - Files: `/components`, `/pages`, `/views`, `/public` directories
+   - Extensions: `.jsx`, `.tsx`, `.vue`, `.svelte`, `.html`, `.css`
+   - Patterns: React/Vue components, CSS changes, static assets
+
+3. **Mixed Implementation → Sequential QA**:
+   - Run API QA first for backend validation
+   - Then Web QA for frontend integration
+   - Finally coordinate results for full coverage
+
+4. **Neither → Use General QA Agent**:
+   - CLI tools, libraries, utilities, scripts
+   - Non-web, non-API code changes
+
+### QA Handoff Patterns
+
+**Engineer → API QA**:
+```
+Engineer: "Implemented REST API endpoints for user management with JWT authentication"
+PM: "I'll delegate to the API QA agent to validate the REST endpoints and authentication flow."
+Task to API QA: "Test the newly implemented user management REST API endpoints including JWT authentication, CRUD operations, and error handling."
+```
+
+**Web UI → Web QA**:
+```
+Web UI: "Created responsive checkout flow with form validation"
+PM: "I'll delegate to the Web QA agent to test the checkout flow across browsers."
+Task to Web QA: "Validate the responsive checkout flow including form validation, browser compatibility, and accessibility compliance."
+```
+
+**Engineer → API QA → Web QA (Full-stack)**:
+```
+Engineer: "Implemented complete user authentication with backend API and React frontend"
+PM: "I'll coordinate testing with both API QA and Web QA agents sequentially."
+Task to API QA: "Test authentication API endpoints, JWT flow, and database operations."
+[After API QA completion]
+Task to Web QA: "Test login UI, form validation, and session management in browsers."
+```
+
+### TodoWrite Patterns for QA Coordination
+
+**API Testing Tasks**:
+- `[PM] Route to API QA for REST endpoint validation`
+- `[API QA] Test user management REST endpoints for CRUD operations`
+- `[API QA] Validate JWT authentication and authorization flow`
+- `[API QA] Load test payment processing endpoints`
+
+**Web Testing Tasks**:
+- `[PM] Route to Web QA for browser-based testing`
+- `[Web QA] Test responsive checkout flow in Chrome/Firefox/Safari`
+- `[Web QA] Validate WCAG 2.1 accessibility compliance`
+- `[Web QA] Test React component rendering and state management`
+
+**Full-Stack Testing Tasks**:
+- `[PM] Coordinate sequential QA for authentication feature`
+- `[API QA] Validate backend auth API (Phase 1 of 2)`
+- `[Web QA] Test frontend login UI (Phase 2 of 2)`
+- `[PM] Synthesize QA results from API and Web testing`
+
 ## Memory-Conscious Delegation
 
 <!-- MEMORY WARNING: Claude Code retains all file contents read during execution -->

claude_mpm/agents/WORKFLOW.md

@@ -20,10 +20,275 @@
 - Ops Agent for infrastructure/deployment
 
 ### Phase 3: Quality Assurance (AFTER Implementation)
-- **CRITICAL**: QA Agent MUST receive original user instructions
-- Validation against acceptance criteria
-- Edge case testing and error scenarios
-- **Required Output**: "QA Complete: [Pass/Fail] - [Details]"
+
+**Intelligent QA Agent Selection**:
+
+The PM must analyze the implementation context to route to the appropriate QA agent based on a comprehensive decision tree. This ensures that each QA type focuses on their area of expertise while maintaining comprehensive coverage.
+
+#### QA Agent Types and Capabilities
+
+1. **API QA Agent** - Specialized for server-side and backend testing:
+   - **Primary Focus**: REST APIs, GraphQL, server routes, authentication systems
+   - **Triggered by keywords**: API, endpoint, route, REST, GraphQL, server, backend, authentication, authorization, database, microservice, webhook
+   - **File indicators**: 
+     - Directories: `/api`, `/routes`, `/controllers`, `/services`, `/models`, `/middleware`
+     - Files: `.py` (FastAPI/Flask/Django), `.js/.ts` (Express/NestJS), `.go`, `.java`, `.php`, `.rb`
+   - **Testing capabilities**:
+     - REST endpoint validation (CRUD operations, status codes, headers)
+     - GraphQL query and mutation testing
+     - Authentication and authorization flows (JWT, OAuth2, API keys)
+     - Database operation validation and data integrity
+     - Request/response schema validation (OpenAPI/Swagger)
+     - API performance and load testing
+     - Contract testing between services
+     - Security testing (OWASP API Security Top 10)
+   - **Tools and frameworks**: Postman/Newman, curl, HTTPie, Jest/Mocha for API tests
+   - **Required Output**: "API QA Complete: [Pass/Fail] - [Endpoints tested: X, Avg response time: Xms, Auth flows: X, Security checks: X, Issues: X]"
+
+2. **Web QA Agent** - Specialized for browser-based and frontend testing:
+   - **Primary Focus**: Web pages, UI components, browser testing, user experience
+   - **Triggered by keywords**: web, UI, page, frontend, browser, component, responsive, accessibility, user interface, client-side, SPA
+   - **File indicators**:
+     - Directories: `/components`, `/pages`, `/views`, `/public`, `/assets`, `/styles`
+     - Files: `.jsx/.tsx` (React), `.vue` (Vue.js), `.svelte`, `.html`, `.css/.scss`, `.js` (client-side)
+   - **Testing capabilities**:
+     - UI component functionality and rendering
+     - User flow validation (registration, login, checkout, etc.)
+     - Responsive design testing across devices and screen sizes
+     - Cross-browser compatibility (Chrome, Firefox, Safari, Edge)
+     - Accessibility compliance (WCAG 2.1 AA standards)
+     - Client-side performance (Core Web Vitals, load times)
+     - Interactive element testing (forms, buttons, navigation)
+     - Visual regression testing
+   - **Tools and frameworks**: Selenium, Playwright, Cypress, browser dev tools
+   - **Required Output**: "Web QA Complete: [Pass/Fail] - [Browsers tested: X, Pages validated: X, Accessibility score: X%, Performance score: X%, Issues: X]"
+
+3. **General QA Agent** - Default for comprehensive testing needs:
+   - **Primary Focus**: Libraries, CLI tools, utilities, integration testing
+   - **Default selection**: When neither API nor Web indicators are present
+   - **File indicators**: CLI tools, libraries, utilities, scripts, configuration files, test files
+   - **Testing capabilities**:
+     - Unit test execution and coverage analysis
+     - Integration testing between components
+     - CLI functionality and command validation
+     - Library method and function testing
+     - Configuration file validation
+     - Build and deployment process testing
+     - Cross-platform compatibility
+   - **Tools and frameworks**: pytest, Jest, JUnit, Mocha, CLI testing frameworks
+   - **Required Output**: "QA Complete: [Pass/Fail] - [Tests run: X, Coverage: X%, CLI commands: X, Issues: X]"
+
+4. **Full-Stack Testing** - Coordinated testing for complete features:
+   - **Triggered when**: Both backend AND frontend changes detected in implementation
+   - **Sequential execution order**:
+     a. **First: API QA** validates backend functionality and data flows
+     b. **Then: Web QA** validates frontend integration and user experience
+     c. **Finally: Integration validation** between all layers
+   - **Coordination requirements**:
+     - API QA must complete successfully before Web QA begins
+     - Both agents receive original user requirements
+     - Integration testing covers end-to-end user workflows
+     - Data consistency validation across frontend and backend
+   - **Required Output**: "Full-Stack QA Complete: [Pass/Fail] - API: [API results], Web: [Web results], Integration: [End-to-end results]"
+
+#### QA Selection Decision Tree
+
+The PM follows this decision logic to route QA testing appropriately:
+
+```
+📊 QA ROUTING DECISION TREE
+│
+├─ 🔍 ANALYZE IMPLEMENTATION CONTEXT
+│   ├─ Keywords Analysis
+│   ├─ File Path Analysis  
+│   ├─ Technology Stack Detection
+│   └─ Feature Scope Assessment
+│
+├─ 🌐 BACKEND INDICATORS → API QA Agent
+│   ├─ Keywords: api, endpoint, route, rest, graphql, server, backend, auth, database, microservice
+│   ├─ File Paths: /api/, /routes/, /controllers/, /services/, /models/, /middleware/
+│   ├─ Extensions: .py, .js/.ts (server), .go, .java, .php, .rb
+│   ├─ Content: @app.route, router.get, API decorators, database schemas
+│   └─ Output: "API QA Complete: [detailed API testing results]"
+│
+├─ 💻 FRONTEND INDICATORS → Web QA Agent  
+│   ├─ Keywords: web, ui, page, frontend, browser, component, responsive, accessibility, spa
+│   ├─ File Paths: /components/, /pages/, /views/, /public/, /assets/, /styles/
+│   ├─ Extensions: .jsx/.tsx, .vue, .svelte, .html, .css/.scss, .js (client)
+│   ├─ Content: React components, Vue templates, CSS frameworks, client-side logic
+│   └─ Output: "Web QA Complete: [detailed UI/UX testing results]"
+│
+├─ 🔄 FULL-STACK INDICATORS → Sequential QA (API → Web)
+│   ├─ Mixed Context: Both backend AND frontend changes
+│   ├─ User Stories: End-to-end feature requirements
+│   ├─ Integration: Frontend consumes backend APIs
+│   ├─ Execution: API QA first, then Web QA, then integration validation
+│   └─ Output: "Full-Stack QA Complete: [combined testing results]"
+│
+└─ ⚙️  DEFAULT → General QA Agent
+    ├─ No specific indicators detected
+    ├─ CLI tools, libraries, utilities
+    ├─ Configuration files, scripts
+    ├─ Pure logic/algorithm implementations
+    └─ Output: "QA Complete: [general testing results]"
+```
+
+**Detailed Detection Logic**:
+
+```
+Backend Indicators → Route to API QA:
+- API route definitions (e.g., @app.route, router.get, @api.route)
+- Database models, migrations, or ORM configurations
+- Authentication/authorization middleware and logic
+- GraphQL schemas, resolvers, or mutations
+- Server configuration files (server.js, app.py, main.go)
+- Backend service implementations and business logic
+- Microservice definitions and inter-service communication
+- API documentation or OpenAPI specifications
+
+Frontend Indicators → Route to Web QA:
+- React/Vue/Angular/Svelte components and pages
+- HTML templates, views, or page definitions
+- CSS/SCSS/Tailwind style files and responsive design
+- Client-side JavaScript for user interactions
+- Static assets (images, fonts, icons) and asset optimization
+- Frontend build configurations (webpack, vite, rollup)
+- Progressive Web App (PWA) configurations
+- Client-side routing and navigation logic
+
+Mixed Indicators → Sequential QA (API QA → Web QA → Integration):
+- Both backend and frontend files modified in implementation
+- Full-stack feature implementation (e.g., auth system, e-commerce)
+- End-to-end user stories spanning multiple layers
+- Features requiring backend API and frontend UI coordination
+- Real-time features (WebSocket, SSE) with client-server interaction
+- Data flow from database through API to user interface
+
+Default Indicators → General QA:
+- CLI tools and command-line applications
+- Libraries, utilities, and helper functions
+- Configuration file processing
+- Data processing scripts and algorithms
+- Testing frameworks and test utilities
+- Build tools and automation scripts
+```
+
+#### Practical Usage Examples
+
+**Example 1: API Implementation**
+```
+User Request: "Create a REST API for user management with CRUD operations"
+Engineer Output: "Implemented FastAPI endpoints in /api/users.py with authentication"
+
+PM Analysis:
+✅ Backend Keywords: "REST API", "endpoints", "authentication"
+✅ File Indicators: "/api/users.py"
+✅ Technology: FastAPI (Python backend)
+
+PM Decision: Route to API QA Agent
+API QA Tasks:
+- Test GET /users (list users)
+- Test POST /users (create user) 
+- Test PUT /users/{id} (update user)
+- Test DELETE /users/{id} (delete user)
+- Validate authentication headers
+- Check error responses (400, 401, 404, 500)
+- Verify response schemas match OpenAPI spec
+- Performance test with 100 concurrent requests
+
+API QA Output: "API QA Complete: Pass - [Endpoints tested: 4, Avg response time: 45ms, Auth flows: 2, Security checks: 3, Issues: 0]"
+```
+
+**Example 2: Web UI Implementation**
+```
+User Request: "Build a responsive dashboard with charts and user profile"
+Web UI Output: "Created React dashboard in /components/Dashboard.tsx with mobile-first design"
+
+PM Analysis:
+✅ Frontend Keywords: "responsive dashboard", "charts", "user profile"
+✅ File Indicators: "/components/Dashboard.tsx"
+✅ Technology: React (frontend framework)
+
+PM Decision: Route to Web QA Agent
+Web QA Tasks:
+- Test dashboard rendering on desktop (1920x1080)
+- Test mobile responsiveness (375x667, 768x1024)
+- Verify chart interactivity and data visualization
+- Test user profile edit functionality
+- Check accessibility (WCAG 2.1 AA compliance)
+- Cross-browser testing (Chrome, Firefox, Safari)
+- Measure Core Web Vitals (LCP, FID, CLS)
+
+Web QA Output: "Web QA Complete: Pass - [Browsers tested: 3, Pages validated: 2, Accessibility score: 95%, Performance score: 88%, Issues: 1 minor]"
+```
+
+**Example 3: Full-Stack Feature**
+```
+User Request: "Implement complete authentication system with login UI and JWT backend"
+Engineer Output: "Built auth API in /api/auth.py and login components in /components/auth/"
+
+PM Analysis:
+✅ Backend Keywords: "JWT backend", "auth API"
+✅ Frontend Keywords: "login UI", "components"
+✅ File Indicators: "/api/auth.py", "/components/auth/"
+✅ Full-Stack Feature: Both backend and frontend implementation
+
+PM Decision: Sequential QA (API QA → Web QA → Integration)
+
+Phase 1 - API QA:
+- Test POST /auth/login endpoint
+- Test POST /auth/register endpoint  
+- Test JWT token generation and validation
+- Test protected endpoint access with tokens
+- Verify password hashing and security
+
+API QA Output: "API QA Complete: Pass - [Endpoints tested: 3, Auth flows: 2, Security checks: 5, Issues: 0]"
+
+Phase 2 - Web QA:
+- Test login form submission and validation
+- Test registration form with field validation
+- Test token storage and automatic logout
+- Test protected route navigation
+- Test error handling for invalid credentials
+
+Web QA Output: "Web QA Complete: Pass - [Forms tested: 2, User flows: 3, Error states: 4, Issues: 0]"
+
+Phase 3 - Integration:
+- Test end-to-end user registration flow
+- Test login → protected page access flow
+- Test token refresh and session management
+- Test logout and token cleanup
+
+PM Final Output: "Full-Stack QA Complete: Pass - API: [3 endpoints validated], Web: [2 forms tested], Integration: [E2E flows working]"
+```
+
+**Example 4: CLI Tool Implementation**
+```
+User Request: "Create a command-line tool for file processing"
+Engineer Output: "Built CLI tool in /src/file_processor.py with argparse"
+
+PM Analysis:
+❌ No Backend API Keywords
+❌ No Frontend UI Keywords  
+✅ Default Indicators: CLI tool, file processing, Python script
+
+PM Decision: Route to General QA Agent
+General QA Tasks:
+- Test CLI commands with various arguments
+- Test file input/output operations
+- Test error handling for invalid files
+- Test cross-platform compatibility
+- Verify help documentation and usage
+
+General QA Output: "QA Complete: Pass - [CLI commands: 5, File operations: 3, Error cases: 4, Issues: 0]"
+```
+
+**CRITICAL Requirements**:
+- QA Agent MUST receive original user instructions for context
+- Validation against acceptance criteria defined in user request
+- Edge case testing and error scenarios for robust implementation
+- Performance and security validation where applicable
+- Clear, standardized output format for tracking and reporting
 
 ### Phase 4: Documentation (ONLY after QA sign-off)
 - API documentation updates
@@ -58,6 +323,45 @@ Context:
   Risk Factors: <Potential issues and mitigation strategies>
 ```
 
+### QA Agent Selection Logic
+
+When delegating QA tasks, the PM must intelligently select the appropriate QA agent based on implementation context:
+
+```python
+# Pseudo-code for QA agent selection
+def select_qa_agent(implementation_context, available_agents):
+    backend_keywords = ['api', 'endpoint', 'route', 'rest', 'graphql', 
+                       'server', 'backend', 'auth', 'database', 'service']
+    frontend_keywords = ['web', 'ui', 'page', 'frontend', 'browser', 
+                        'component', 'responsive', 'accessibility', 'react', 'vue']
+    
+    context_lower = implementation_context.lower()
+    
+    has_backend = any(keyword in context_lower for keyword in backend_keywords)
+    has_frontend = any(keyword in context_lower for keyword in frontend_keywords)
+    
+    # Check file extensions and paths
+    if any(ext in implementation_context for ext in ['.py', '.go', '.java', '/api/', '/routes/']):
+        has_backend = True
+    if any(ext in implementation_context for ext in ['.jsx', '.tsx', '.vue', '/components/', '/pages/']):
+        has_frontend = True
+    
+    # Determine QA agent(s) to use
+    if has_backend and has_frontend:
+        return ['api_qa', 'web_qa']  # Sequential testing for full-stack
+    elif has_backend and 'api_qa' in available_agents:
+        return ['api_qa']
+    elif has_frontend and 'web_qa' in available_agents:
+        return ['web_qa']
+    else:
+        return ['qa']  # Default general QA
+
+# Example usage in delegation
+selected_qa = select_qa_agent(engineer_output, deployed_agents)
+for qa_agent in selected_qa:
+    delegate_to(qa_agent, original_requirements)
+```
+
 ### Research-First Scenarios
 
 Delegate to Research when:

claude_mpm/agents/agents_metadata.py

@@ -75,6 +75,56 @@ QA_CONFIG = {
     },
 }
 
+# API QA Agent Metadata
+API_QA_CONFIG = {
+    "name": "api_qa_agent",
+    "version": "1.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "rest_api_testing",
+        "graphql_testing",
+        "endpoint_validation",
+        "authentication_testing",
+        "authorization_testing",
+        "contract_testing",
+        "load_testing",
+        "api_performance_testing",
+    ],
+    "primary_interface": "api_testing_framework",
+    "performance_targets": {
+        "endpoint_validation": "2m",
+        "auth_flow_testing": "5m",
+        "load_testing": "10m",
+        "contract_validation": "5m",
+        "response_time_target": "200ms",
+    },
+}
+
+# Web QA Agent Metadata
+WEB_QA_CONFIG = {
+    "name": "web_qa_agent",
+    "version": "1.0.0",
+    "type": "core_agent",
+    "capabilities": [
+        "browser_automation",
+        "e2e_testing",
+        "ui_testing",
+        "responsive_testing",
+        "accessibility_testing",
+        "cross_browser_testing",
+        "performance_testing",
+        "visual_regression",
+    ],
+    "primary_interface": "browser_testing_framework",
+    "performance_targets": {
+        "e2e_test_suite": "15m",
+        "accessibility_audit": "5m",
+        "cross_browser_test": "20m",
+        "page_load_target": "2.5s",
+        "lighthouse_score": "90",
+    },
+}
+
 # Research Agent Metadata
 RESEARCH_CONFIG = {
     "name": "research_agent",
@@ -218,6 +268,8 @@ ALL_AGENT_CONFIGS = {
     "documentation": DOCUMENTATION_CONFIG,
     "version_control": VERSION_CONTROL_CONFIG,
     "qa": QA_CONFIG,
+    "api_qa": API_QA_CONFIG,
+    "web_qa": WEB_QA_CONFIG,
     "research": RESEARCH_CONFIG,
     "ops": OPS_CONFIG,
     "security": SECURITY_CONFIG,

claude_mpm/agents/base_agent_loader.py

@@ -38,31 +38,91 @@ BASE_AGENT_CACHE_KEY = "base_agent:instructions"
 
 
 def _get_base_agent_file() -> Path:
-    """Get the base agent file path."""
-    # Check if we're running from a wheel installation
+    """Get the base agent file path with priority-based search.
+    
+    Priority order:
+    1. Environment variable override (CLAUDE_MPM_BASE_AGENT_PATH)
+    2. Current working directory (for local development)
+    3. Known development locations
+    4. User override location (~/.claude/agents/)
+    5. Package installation location (fallback)
+    """
+    # Priority 0: Check environment variable override
+    env_path = os.environ.get("CLAUDE_MPM_BASE_AGENT_PATH")
+    if env_path:
+        env_base_agent = Path(env_path)
+        if env_base_agent.exists():
+            logger.info(f"Using environment variable base_agent: {env_base_agent}")
+            return env_base_agent
+        else:
+            logger.warning(f"CLAUDE_MPM_BASE_AGENT_PATH set but file doesn't exist: {env_base_agent}")
+    
+    # Priority 1: Check current working directory for local development
+    cwd = Path.cwd()
+    cwd_base_agent = cwd / "src" / "claude_mpm" / "agents" / "base_agent.json"
+    if cwd_base_agent.exists():
+        logger.info(f"Using local development base_agent from cwd: {cwd_base_agent}")
+        return cwd_base_agent
+    
+    # Priority 2: Check known development locations
+    known_dev_paths = [
+        Path("/Users/masa/Projects/claude-mpm/src/claude_mpm/agents/base_agent.json"),
+        Path.home() / "Projects" / "claude-mpm" / "src" / "claude_mpm" / "agents" / "base_agent.json",
+        Path.home() / "projects" / "claude-mpm" / "src" / "claude_mpm" / "agents" / "base_agent.json",
+    ]
+    
+    for dev_path in known_dev_paths:
+        if dev_path.exists():
+            logger.info(f"Using development base_agent: {dev_path}")
+            return dev_path
+    
+    # Priority 3: Check user override location
+    user_base_agent = Path.home() / ".claude" / "agents" / "base_agent.json"
+    if user_base_agent.exists():
+        logger.info(f"Using user override base_agent: {user_base_agent}")
+        return user_base_agent
+    
+    # Priority 4: Check if we're running from a wheel installation
     try:
         import claude_mpm
 
         package_path = Path(claude_mpm.__file__).parent
         path_str = str(package_path.resolve())
+        
+        # For development/editable installs, check if there's a local src directory
         if "site-packages" in path_str or "dist-packages" in path_str:
+            # Check if this is a pipx/pip installation
+            if "pipx" in path_str:
+                logger.debug(f"Detected pipx installation at {package_path}")
+            
             # For wheel installations, check data directory
             data_base_agent = package_path / "data" / "agents" / "base_agent.json"
             if data_base_agent.exists():
-                logger.debug(f"Using wheel installation base_agent: {data_base_agent}")
+                logger.info(f"Using wheel installation base_agent: {data_base_agent}")
                 return data_base_agent
-    except Exception:
-        pass
-
-    # Use the base_agent.json in the agents directory
+            
+            # Also check direct agents directory in package
+            pkg_base_agent = package_path / "agents" / "base_agent.json"
+            if pkg_base_agent.exists():
+                logger.info(f"Using package base_agent: {pkg_base_agent}")
+                return pkg_base_agent
+    except Exception as e:
+        logger.debug(f"Exception checking package path: {e}")
+    
+    # Final fallback: Use the base_agent.json relative to this file
     base_agent_path = Path(__file__).parent / "base_agent.json"
     if base_agent_path.exists():
-        logger.debug(f"Using base agent template: {base_agent_path}")
+        logger.info(f"Using fallback base_agent relative to module: {base_agent_path}")
         return base_agent_path
 
-    # Fallback error
-    logger.error("Base agent template file not found")
-    raise FileNotFoundError("base_agent.json not found in agents directory")
+    # Error if no base agent found
+    logger.error("Base agent template file not found in any location")
+    logger.error(f"Searched locations:")
+    logger.error(f"  1. CWD: {cwd_base_agent}")
+    logger.error(f"  2. Dev paths: {known_dev_paths}")
+    logger.error(f"  3. User: {user_base_agent}")
+    logger.error(f"  4. Module: {base_agent_path}")
+    raise FileNotFoundError("base_agent.json not found in any expected location")
 
 
 # Base agent file path (dynamically determined)
@@ -252,19 +312,15 @@ def _remove_test_mode_instructions(content: str) -> str:
 
         # Check if we're in the test section and need to continue skipping
         if skip_section:
-            # Check if we've reached a section that's NOT part of test protocol
-            # This includes any heading that's not a subsection of the test protocol
-            if (
-                line.startswith("####")
-                or line.startswith("###")
-                or line.startswith("##")
-            ) and "Standard Test Response Protocol" not in line:
+            # Check if we've reached a new top-level section (## but not ###)
+            # Only stop skipping when we hit another ## section (same level as test section)
+            if line.startswith("##") and not line.startswith("###"):
                 skip_section = False
                 # Don't skip this line - it's the start of a new section
                 filtered_lines.append(line)
                 i += 1
                 continue
-            # Skip this line as we're still in test section
+            # Skip this line as we're still in test section (includes ### subsections)
             i += 1
             continue
 

claude_mpm/agents/templates/__init__.py

@@ -17,6 +17,8 @@ AGENT_TEMPLATES = {
     "documentation": "documentation_agent.md",
     "engineer": "engineer_agent.md",
     "qa": "qa_agent.md",
+    "api_qa": "api_qa_agent.md",
+    "web_qa": "web_qa_agent.md",
     "version_control": "version_control_agent.md",
     "research": "research_agent.md",
     "ops": "ops_agent.md",
@@ -29,6 +31,8 @@ AGENT_NICKNAMES = {
     "documentation": "Documenter",
     "engineer": "Engineer",
     "qa": "QA",
+    "api_qa": "API QA",
+    "web_qa": "Web QA",
     "version_control": "Versioner",
     "research": "Researcher",
     "ops": "Ops",