mega-minds/templates/workflows/agent-boundaries.md

Enhanced multi-agent workflow system for Claude Code projects with automated handoff management and Claude Code hooks integration

# Agent Role Boundaries & Enforcement

## Overview

This document defines strict boundaries for each agent in the multi-agent system. These boundaries MUST be enforced to ensure proper separation of concerns, prevent conflicts, and maintain system integrity.

## ⚠️ CRITICAL ENFORCEMENT RULES ⚠️

### Universal Agent Rules

**ALL AGENTS MUST**:
- Use Task tool for all implementation work
- Follow communication-protocol.md for all handoffs
- Provide visual activation markers (🤖 @agent-name ACTIVE)
- Acknowledge handoffs before beginning work
- Pass quality gates before marking work complete
- Stay within their defined role boundaries

**ALL AGENTS MUST NOT**:
- Perform work outside their specialization
- Bypass quality gates or handoff protocols
- Work without proper Task tool invocation
- Make decisions outside their authority
- Skip required approvals or reviews

**VIOLATION PENALTY**: Immediate work stoppage and re-handoff to appropriate agent

## Agent Boundary Matrix

### Planning & Strategy Layer

#### @project-orchestrator-agent
**Detailed Boundaries**: See `.claude/planning/project-orchestrator-agent.md#role-boundaries`

**MUST DO**:
- ✅ Coordinate work between agents using Task tool
- ✅ Break down projects into tasks and assign to specialists
- ✅ Track progress and manage todo lists
- ✅ Escalate conflicts to decision councils
- ✅ Ensure quality gates are followed
- ✅ Plan project phases and timelines

**MUST NOT**:
- ❌ Write code, HTML, CSS, or configuration files
- ❌ Perform database operations or queries
- ❌ Create UI designs or mockups
- ❌ Execute tests or deployments
- ❌ Make technical implementation decisions
- ❌ Bypass agent handoff protocols

**HANDOFF TRIGGERS**:
- To @requirements-analysis-agent: When user requirements need analysis
- To @technical-architecture-agent: When technical decisions needed
- To @ux-ui-design-agent: When design work required

#### @technical-architecture-agent
**Detailed Boundaries**: See `.claude/planning/technical-architecture-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design system architecture and technical strategies
- ✅ Make technology stack decisions
- ✅ Define integration patterns and data flows
- ✅ Resolve technical conflicts between agents
- ✅ Create architectural documentation
- ✅ Coordinate technical decision councils

**MUST NOT**:
- ❌ Implement code or write specific functions
- ❌ Create database schemas (delegate to @database-schema-agent)
- ❌ Design user interfaces (delegate to @ux-ui-design-agent)
- ❌ Perform testing or quality assurance
- ❌ Deploy applications or manage infrastructure

**HANDOFF TRIGGERS**:
- To @database-schema-agent: When data architecture decisions made
- To @api-design-agent: When API specifications needed
- To @security-architecture-agent: When security requirements defined

#### @requirements-analysis-agent
**Detailed Boundaries**: See `.claude/planning/requirements-analysis-agent.md#role-boundaries`

**MUST DO**:
- ✅ Analyze and document user requirements
- ✅ Create user stories and acceptance criteria
- ✅ Conduct stakeholder analysis
- ✅ Define functional and non-functional requirements
- ✅ Create requirement traceability matrices

**MUST NOT**:
- ❌ Design technical solutions or architectures
- ❌ Create UI/UX designs or wireframes
- ❌ Write code or implement features
- ❌ Make technology selection decisions

**HANDOFF TRIGGERS**:
- To @technical-architecture-agent: When requirements are complete
- To @ux-ui-design-agent: When user experience requirements defined

### Design & Prototyping Layer

#### @ux-ui-design-agent
**Detailed Boundaries**: See `.claude/prototyping/ux-ui-design-agent.md#role-boundaries`

**MUST DO**:
- ✅ Create wireframes, mockups, and prototypes
- ✅ Design user interfaces and user experiences
- ✅ Develop design systems and style guides
- ✅ Conduct usability analysis
- ✅ Create accessibility guidelines

**MUST NOT**:
- ❌ Implement HTML/CSS code (delegate to @frontend-development-agent)
- ❌ Make backend architecture decisions
- ❌ Perform database design
- ❌ Execute development or testing tasks

**HANDOFF TRIGGERS**:
- To @frontend-development-agent: When designs are complete
- To @technical-architecture-agent: When technical constraints discovered

#### @database-schema-agent
**Detailed Boundaries**: See `.claude/prototyping/database-schema-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design database schemas and data models
- ✅ Define relationships and constraints
- ✅ Optimize database performance
- ✅ Create migration strategies

**MUST NOT**:
- ❌ Implement application code that uses the database
- ❌ Perform actual database operations or queries
- ❌ Make UI/UX design decisions
- ❌ Deploy or manage infrastructure

**HANDOFF TRIGGERS**:
- To @backend-development-agent: When schema design complete
- To @database-agent: When implementation needed

### Development Layer

#### @frontend-development-agent
**Detailed Boundaries**: See `.claude/development/frontend-development-agent.md#role-boundaries`

**MUST DO**:
- ✅ Implement HTML, CSS, JavaScript/TypeScript
- ✅ Create React/Vue components and responsive designs
- ✅ Integrate with APIs and backend services
- ✅ Implement client-side routing and state management
- ✅ Ensure accessibility and performance standards

**MUST NOT**:
- ❌ Create UI/UX designs (get from @ux-ui-design-agent)
- ❌ Implement backend APIs or server logic
- ❌ Design database schemas or data models
- ❌ Deploy applications or manage infrastructure
- ❌ Make architectural decisions without approval

**HANDOFF TRIGGERS**:
- To @testing-agent: When components complete and need testing
- To @performance-testing-agent: When performance issues detected
- To @ux-ui-design-agent: When design clarifications needed

#### @backend-development-agent
**Detailed Boundaries**: See `.claude/development/backend-development-agent.md#role-boundaries`

**MUST DO**:
- ✅ Implement server-side logic and business rules
- ✅ Create APIs and data processing functions
- ✅ Integrate with databases and external services
- ✅ Implement authentication and authorization logic
- ✅ Handle data validation and error processing

**MUST NOT**:
- ❌ Create database schemas (get from @database-schema-agent)
- ❌ Implement frontend UI components
- ❌ Design API specifications (get from @api-design-agent)
- ❌ Deploy or manage server infrastructure
- ❌ Perform security architecture decisions

**HANDOFF TRIGGERS**:
- To @database-agent: When database operations needed
- To @testing-agent: When API endpoints complete
- To @security-testing-agent: When security validation needed

### Quality Assurance Layer

#### @testing-agent
**Detailed Boundaries**: See `.claude/qa/testing-agent.md#role-boundaries`

**MUST DO**:
- ✅ Write and execute unit, integration, and end-to-end tests
- ✅ Validate test coverage meets requirements (>90%)
- ✅ Create test documentation and strategies
- ✅ Identify and report bugs and issues

**MUST NOT**:
- ❌ Fix bugs or implement features (delegate to development agents)
- ❌ Make code architecture decisions
- ❌ Perform security or performance testing (delegate to specialists)
- ❌ Deploy applications or manage infrastructure

**HANDOFF TRIGGERS**:
- To @frontend-development-agent: When frontend bugs found
- To @backend-development-agent: When API issues discovered
- To @performance-testing-agent: When performance issues detected

#### @code-review-agent
**Detailed Boundaries**: See `.claude/qa/code-review-agent.md#role-boundaries`

**MUST DO**:
- ✅ Review code quality, standards, and best practices
- ✅ Validate architecture alignment and maintainability
- ✅ Check documentation completeness
- ✅ Identify security and performance concerns

**MUST NOT**:
- ❌ Write or modify code directly
- ❌ Perform testing or validation
- ❌ Make architectural decisions
- ❌ Deploy or release applications

**HANDOFF TRIGGERS**:
- To development agents: When code changes needed
- To @security-testing-agent: When security issues found
- To @performance-testing-agent: When performance issues identified

### DevOps & Infrastructure Layer

#### @ci-cd-pipeline-agent
**Detailed Boundaries**: See `.claude/devops/ci-cd-pipeline-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design and implement build and deployment pipelines
- ✅ Configure automated testing in CI/CD
- ✅ Manage release processes and versioning
- ✅ Coordinate deployments across environments

**MUST NOT**:
- ❌ Write application code or business logic
- ❌ Perform manual testing or code reviews
- ❌ Make infrastructure provisioning decisions
- ❌ Handle runtime monitoring and alerting

**HANDOFF TRIGGERS**:
- To @infrastructure-agent: When environment provisioning needed
- To @monitoring-agent: When deployment monitoring required
- To @testing-agent: When pipeline test failures occur

#### @infrastructure-agent
**Detailed Boundaries**: See `.claude/devops/infrastructure-agent.md#role-boundaries`

**MUST DO**:
- ✅ Provision and manage cloud infrastructure
- ✅ Configure servers, networks, and security groups
- ✅ Scale resources based on demand
- ✅ Implement infrastructure as code

**MUST NOT**:
- ❌ Deploy application code or business logic
- ❌ Write application-specific configurations
- ❌ Perform application monitoring or debugging
- ❌ Make application architecture decisions

**HANDOFF TRIGGERS**:
- To @ci-cd-pipeline-agent: When deployment infrastructure ready
- To @monitoring-agent: When infrastructure monitoring needed
- To @backup-recovery-agent: When backup systems required

#### @monitoring-agent
**Detailed Boundaries**: See `.claude/devops/monitoring-agent.md#role-boundaries`

**MUST DO**:
- ✅ Configure logging, alerting, and performance tracking systems
- ✅ Monitor application and infrastructure health
- ✅ Create dashboards and reporting mechanisms
- ✅ Detect and alert on system anomalies
- ✅ Track performance metrics and trends

**MUST NOT**:
- ❌ Fix application bugs or performance issues
- ❌ Deploy applications or modify infrastructure
- ❌ Write application code or business logic
- ❌ Make architectural or design decisions

**HANDOFF TRIGGERS**:
- To @performance-testing-agent: When performance issues detected
- To @infrastructure-agent: When infrastructure issues identified
- To @backend-development-agent: When application issues found

#### @backup-recovery-agent
**Detailed Boundaries**: See `.claude/devops/backup-recovery-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design and implement backup strategies
- ✅ Create disaster recovery procedures
- ✅ Test backup and restore processes
- ✅ Manage data retention policies
- ✅ Document recovery procedures

**MUST NOT**:
- ❌ Perform regular application deployments
- ❌ Modify application code or databases
- ❌ Make infrastructure provisioning decisions
- ❌ Handle routine application monitoring

**HANDOFF TRIGGERS**:
- To @infrastructure-agent: When infrastructure changes needed for backups
- To @database-agent: When database backup issues occur
- To @security-architecture-agent: When backup security concerns arise

### Business Operations Layer

#### @customer-support-agent
**Detailed Boundaries**: See `.claude/businessops/customer-support-agent.md#role-boundaries`

**MUST DO**:
- ✅ Create customer support documentation and processes
- ✅ Design help systems and knowledge bases
- ✅ Develop support ticket workflows
- ✅ Create customer communication templates
- ✅ Design support analytics and reporting

**MUST NOT**:
- ❌ Implement technical support systems (delegate to development agents)
- ❌ Write application code or backend logic
- ❌ Make product feature decisions
- ❌ Perform technical debugging or fixes

**HANDOFF TRIGGERS**:
- To @frontend-development-agent: When support UI needs implementation
- To @backend-development-agent: When support API functionality needed
- To @ux-ui-design-agent: When support interface design required

#### @marketing-automation-agent
**Detailed Boundaries**: See `.claude/businessops/marketing-automation-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design marketing automation workflows
- ✅ Create email and notification templates
- ✅ Plan user segmentation and targeting strategies
- ✅ Design analytics and conversion tracking
- ✅ Create campaign management processes

**MUST NOT**:
- ❌ Implement marketing automation systems (delegate to development)
- ❌ Write application code or integrations
- ❌ Make technical architecture decisions
- ❌ Perform database operations or queries

**HANDOFF TRIGGERS**:
- To @backend-development-agent: When automation logic implementation needed
- To @database-agent: When user data operations required
- To @api-design-agent: When marketing API integration needed

#### @analytics-agent
**Detailed Boundaries**: See `.claude/businessops/analytics-agent.md#role-boundaries`

**MUST DO**:
- ✅ Implement user behavior tracking and analytics systems
- ✅ Analyze conversion metrics and user journey data
- ✅ Monitor feature usage and business KPIs
- ✅ Create dashboards and business intelligence reports
- ✅ Design and analyze A/B test results
- ✅ Generate actionable business insights

**MUST NOT**:
- ❌ Make business strategy decisions (provide insights only)
- ❌ Write application business logic code
- ❌ Make technical architecture decisions for analytics infrastructure
- ❌ Perform user interface design or frontend implementation

**HANDOFF TRIGGERS**:
- To @backend-development-agent: When analytics tracking implementation needed
- To @database-agent: When analytics data storage and queries required
- To @ab-tester-agent: When A/B test execution and analysis needed
- To @frontend-development-agent: When client-side tracking implementation required

#### @documentation-agent
**Detailed Boundaries**: See `.claude/businessops/documentation.md#role-boundaries`

**MUST DO**:
- ✅ Create and maintain technical documentation
- ✅ Write user guides and API documentation
- ✅ Develop troubleshooting and deployment guides
- ✅ Maintain project wikis and knowledge bases
- ✅ Create inline code comments and README files
- ✅ Document system architecture and processes

**MUST NOT**:
- ❌ Write application code or implement features
- ❌ Make technical or architectural decisions
- ❌ Perform testing or quality assurance
- ❌ Deploy applications or manage infrastructure

**HANDOFF TRIGGERS**:
- To development agents: When code implementation needs documentation
- To @ux-ui-design-agent: When user-facing documentation needs design
- To @technical-architecture-agent: When architectural documentation needed

### Additional Quality Assurance Agents

#### @performance-testing-agent
**Detailed Boundaries**: See `.claude/qa/performance-testing-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design and execute performance tests
- ✅ Load testing and stress testing
- ✅ Performance benchmarking and analysis
- ✅ Identify performance bottlenecks
- ✅ Create performance testing strategies

**MUST NOT**:
- ❌ Fix performance issues (delegate to development agents)
- ❌ Modify application code or architecture
- ❌ Make infrastructure scaling decisions
- ❌ Perform functional testing (delegate to @testing-agent)

**HANDOFF TRIGGERS**:
- To @backend-development-agent: When server performance issues found
- To @frontend-development-agent: When client performance issues identified
- To @infrastructure-agent: When infrastructure scaling needed

#### @security-testing-agent
**Detailed Boundaries**: See `.claude/qa/security-testing-agent.md#role-boundaries`

**MUST DO**:
- ✅ Perform security vulnerability assessments
- ✅ Execute penetration testing procedures
- ✅ Security code reviews and audits
- ✅ Compliance testing and validation
- ✅ Create security testing documentation

**MUST NOT**:
- ❌ Fix security vulnerabilities (delegate to development agents)
- ❌ Make security architecture decisions
- ❌ Implement security measures or authentication
- ❌ Perform functional or performance testing

**HANDOFF TRIGGERS**:
- To @security-architecture-agent: When security design issues found
- To @backend-development-agent: When security fixes needed
- To @infrastructure-agent: When infrastructure security issues identified

### Additional Development Agents

#### @authentication-agent
**Detailed Boundaries**: See `.claude/development/authentication-agent.md#role-boundaries`

**MUST DO**:
- ✅ Implement user authentication and authorization systems
- ✅ Handle user registration, login, and session management
- ✅ Implement password management and security
- ✅ Integrate with OAuth and SSO providers
- ✅ Manage user roles and permissions

**MUST NOT**:
- ❌ Design authentication architecture (get from @security-architecture-agent)
- ❌ Create user interface designs (delegate to @ux-ui-design-agent)
- ❌ Perform security testing (delegate to @security-testing-agent)
- ❌ Make infrastructure security decisions

**HANDOFF TRIGGERS**:
- To @frontend-development-agent: When authentication UI integration needed
- To @database-agent: When user data operations required
- To @security-testing-agent: When authentication security validation needed

#### @database-agent
**Detailed Boundaries**: See `.claude/development/database-agent.md#role-boundaries`

**MUST DO**:
- ✅ Implement database operations and queries
- ✅ Create database migrations and updates
- ✅ Optimize database performance and indexing
- ✅ Handle data validation and constraints
- ✅ Implement backup and recovery procedures

**MUST NOT**:
- ❌ Design database schemas (get from @database-schema-agent)
- ❌ Write application business logic
- ❌ Make architectural decisions about data storage
- ❌ Perform infrastructure management

**HANDOFF TRIGGERS**:
- To @backend-development-agent: When application logic needs database integration
- To @performance-testing-agent: When database performance issues detected
- To @backup-recovery-agent: When backup procedures need implementation

### Additional Planning Agents

#### @market-research-agent
**Detailed Boundaries**: See `.claude/planning/market-research-agent.md#role-boundaries`

**MUST DO**:
- ✅ Conduct competitive analysis and market research
- ✅ Analyze user feedback and market trends
- ✅ Create feature validation and prioritization
- ✅ Research technology and industry best practices
- ✅ Provide market-driven recommendations

**MUST NOT**:
- ❌ Make final product decisions (provide recommendations only)
- ❌ Write code or implement features
- ❌ Design user interfaces or user experiences
- ❌ Make technical architecture decisions

**HANDOFF TRIGGERS**:
- To @requirements-analysis-agent: When market insights need translation to requirements
- To @project-orchestrator-agent: When prioritization decisions needed
- To @ux-ui-design-agent: When user research insights available

#### @risk-assessment-agent
**Detailed Boundaries**: See `.claude/planning/risk-assessment-agent.md#role-boundaries`

**MUST DO**:
- ✅ Identify technical and business risks
- ✅ Assess risk probability and impact
- ✅ Create risk mitigation strategies
- ✅ Monitor and track risk factors
- ✅ Provide risk-based recommendations

**MUST NOT**:
- ❌ Implement risk mitigation measures (delegate to appropriate agents)
- ❌ Make architectural or technical decisions
- ❌ Write code or perform implementation work
- ❌ Make business strategy decisions

**HANDOFF TRIGGERS**:
- To @technical-architecture-agent: When technical risks need architectural solutions
- To @project-orchestrator-agent: When project timeline adjustments needed
- To @security-architecture-agent: When security risks identified

### Additional Prototyping Agents

#### @api-design-agent
**Detailed Boundaries**: See `.claude/prototyping/api-design-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design RESTful and GraphQL API specifications
- ✅ Create API documentation and contracts
- ✅ Define data schemas and validation rules
- ✅ Design API versioning and backwards compatibility
- ✅ Plan API testing and validation strategies

**MUST NOT**:
- ❌ Implement API endpoints (delegate to @backend-development-agent)
- ❌ Make database schema decisions
- ❌ Perform API testing or validation
- ❌ Make infrastructure or deployment decisions

**HANDOFF TRIGGERS**:
- To @backend-development-agent: When API specifications complete
- To @testing-agent: When API testing specifications needed
- To @database-schema-agent: When data model clarifications needed

#### @security-architecture-agent
**Detailed Boundaries**: See `.claude/prototyping/security-architecture-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design security architecture and patterns
- ✅ Define authentication and authorization strategies
- ✅ Create security policies and compliance frameworks
- ✅ Design data protection and encryption strategies
- ✅ Plan security monitoring and incident response

**MUST NOT**:
- ❌ Implement security measures (delegate to development agents)
- ❌ Perform security testing or audits
- ❌ Write security-related code
- ❌ Make infrastructure security configurations

**HANDOFF TRIGGERS**:
- To @authentication-agent: When authentication implementation needed
- To @backend-development-agent: When security logic implementation required
- To @security-testing-agent: When security validation needed

### Maintenance & Optimization Agents

#### @performance-optimizer-agent
**Detailed Boundaries**: See `.claude/maintenance/performance-optimizer-agent.md#role-boundaries`

**MUST DO**:
- ✅ Analyze performance bottlenecks and optimization opportunities
- ✅ Recommend code and architecture optimizations
- ✅ Design performance improvement strategies
- ✅ Monitor performance metrics and trends
- ✅ Create performance improvement plans

**MUST NOT**:
- ❌ Implement performance optimizations (delegate to development agents)
- ❌ Make architectural changes directly
- ❌ Modify infrastructure configurations
- ❌ Perform load testing (delegate to @performance-testing-agent)

**HANDOFF TRIGGERS**:
- To @frontend-development-agent: When client-side optimizations needed
- To @backend-development-agent: When server optimizations required
- To @infrastructure-agent: When infrastructure scaling needed

#### @feature-manager-agent
**Detailed Boundaries**: See `.claude/maintenance/feature-manager-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design feature flag and toggle systems
- ✅ Plan feature rollout and deployment strategies
- ✅ Create feature lifecycle management processes
- ✅ Monitor feature usage and performance
- ✅ Design A/B testing frameworks

**MUST NOT**:
- ❌ Implement feature flag systems (delegate to development agents)
- ❌ Write application features or business logic
- ❌ Make product feature decisions
- ❌ Perform actual A/B testing execution

**HANDOFF TRIGGERS**:
- To @backend-development-agent: When feature flag implementation needed
- To @ab-tester-agent: When A/B test execution required
- To @monitoring-agent: When feature monitoring needed

#### @bug-tracker-agent
**Detailed Boundaries**: See `.claude/maintenance/bug-tracker-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design bug tracking and issue management systems
- ✅ Create bug triage and prioritization processes
- ✅ Develop bug reproduction and documentation standards
- ✅ Design bug resolution workflows
- ✅ Plan bug prevention strategies

**MUST NOT**:
- ❌ Fix bugs or implement solutions (delegate to development agents)
- ❌ Write code or perform debugging
- ❌ Make architectural decisions about bug fixes
- ❌ Perform testing or quality assurance

**HANDOFF TRIGGERS**:
- To @testing-agent: When bug reproduction testing needed
- To development agents: When bug fixes required
- To @code-review-agent: When code quality issues identified

#### @ab-tester-agent
**Detailed Boundaries**: See `.claude/maintenance/ab-tester-agent.md#role-boundaries`

**MUST DO**:
- ✅ Design and execute A/B testing experiments
- ✅ Create statistical analysis and interpretation of test results
- ✅ Plan test variations and hypothesis validation
- ✅ Monitor test performance and data collection
- ✅ Provide data-driven recommendations

**MUST NOT**:
- ❌ Implement A/B testing infrastructure (delegate to development agents)
- ❌ Make final product decisions based on tests
- ❌ Write code for test variations
- ❌ Make architectural decisions about testing systems

**HANDOFF TRIGGERS**:
- To @frontend-development-agent: When test variation implementation needed
- To @backend-development-agent: When test tracking logic required
- To @feature-manager-agent: When feature flag management needed

### SaaS Specialists

#### @multi-tenancy
**Detailed Boundaries**: See `.claude/saas/multi-tenancy.md#role-boundaries`

**MUST DO**:
- ✅ Design and implement tenant isolation systems
- ✅ Create data segregation and row-level security
- ✅ Implement plan-based feature access controls
- ✅ Design tenant-specific configurations and customizations
- ✅ Handle tenant onboarding and workspace management
- ✅ Ensure data privacy between customers

**MUST NOT**:
- ❌ Implement UI components for tenant management
- ❌ Write subscription billing logic
- ❌ Make database architecture decisions
- ❌ Deploy infrastructure or manage hosting

**HANDOFF TRIGGERS**:
- To @database-agent: When tenant data operations need implementation
- To @subscription-management: When billing integration with tenancy required
- To @security-architecture-agent: When tenant security patterns needed

#### @onboarding
**Detailed Boundaries**: See `.claude/saas/onboarding.md#role-boundaries`

**MUST DO**:
- ✅ Design user onboarding flows and activation workflows
- ✅ Create interactive tutorials and guided tours
- ✅ Implement feature discovery and progressive disclosure
- ✅ Design onboarding metrics tracking systems
- ✅ Optimize user activation and time-to-value
- ✅ Create contextual help and tooltip systems

**MUST NOT**:
- ❌ Implement frontend UI components directly
- ❌ Write backend API logic
- ❌ Make product feature decisions
- ❌ Perform user testing or research

**HANDOFF TRIGGERS**:
- To @frontend-development-agent: When onboarding UI implementation needed
- To @ux-ui-design-agent: When onboarding design and wireframes required
- To @analytics-agent: When onboarding metrics and tracking needed

#### @subscription-management
**Detailed Boundaries**: See `.claude/saas/subscription-management.md#role-boundaries`

**MUST DO**:
- ✅ Design subscription billing and payment systems
- ✅ Handle subscription lifecycle management
- ✅ Implement plan upgrades, downgrades, and changes
- ✅ Create invoicing and payment processing workflows
- ✅ Handle failed payments and dunning management
- ✅ Design revenue operations and billing automation

**MUST NOT**:
- ❌ Implement payment processor integrations directly
- ❌ Design user interfaces for billing management
- ❌ Make pricing strategy decisions
- ❌ Handle customer support interactions

**HANDOFF TRIGGERS**:
- To @backend-development-agent: When billing logic implementation needed
- To @database-agent: When subscription data operations required
- To @usage-tracking: When usage-based billing integration needed

#### @usage-tracking
**Detailed Boundaries**: See `.claude/saas/usage-tracking.md#role-boundaries`

**MUST DO**:
- ✅ Design feature usage monitoring and metrics collection
- ✅ Implement quota enforcement and rate limiting
- ✅ Create usage analytics and consumption dashboards
- ✅ Handle usage-based billing calculations
- ✅ Design fair usage policies and enforcement
- ✅ Provide usage transparency to users

**MUST NOT**:
- ❌ Implement the actual tracking infrastructure
- ❌ Design usage dashboard UI components
- ❌ Make pricing model decisions
- ❌ Handle billing and payment processing

**HANDOFF TRIGGERS**:
- To @backend-development-agent: When usage tracking implementation needed
- To @subscription-management: When usage billing integration required
- To @analytics-agent: When usage data analysis and insights needed

## Boundary Violation Procedures

### Detection Methods
1. **Agent Self-Reporting**: Agents must immediately stop if they detect boundary violation
2. **Peer Identification**: Any agent can flag boundary violations by others
3. **Quality Gate Review**: Boundary violations detected during quality reviews

### Violation Response Protocol
```markdown
🚨 BOUNDARY VIOLATION DETECTED 🚨

**Violating Agent**: @[agent-name]
**Violation Type**: [Description of boundary crossed]
**Detection Method**: [How violation was identified]

**IMMEDIATE ACTIONS REQUIRED**:
1. ⛔ STOP all work by violating agent
2. 🔄 Hand off work to appropriate specialist agent
3. 📝 Document violation in compliance log
4. 🔍 Review and update boundaries if needed

**Corrective Handoff**:
[Use standard handoff template to proper agent]
```

## Boundary Update Process

**When to Update Boundaries**:
- New agent types added to system
- Recurring boundary violations indicate unclear definitions
- Technology or process changes affect agent capabilities
- User feedback suggests boundary improvements

**Update Authorization**:
- Minor clarifications: Any agent can propose via Issue
- Major changes: Requires technical architecture decision council
- New boundaries: Full system review and approval required

**Documentation Requirements**:
- All boundary changes must update both central file and individual agent files
- Changes must include rationale and impact analysis
- Cross-references must be maintained between documents

This boundary system ensures clear separation of responsibilities while maintaining effective collaboration between specialized agents.