fix: resolve agent namespace issues across 11 plugins

Fixed 109 agent namespace issues where external agent references were
missing proper namespace prefixes (plugin-name::agent-name format).

Affected plugins (bumped to v1.2.1):
- tdd-workflows: Fixed 12 references in tdd-cycle, tdd-green, tdd-red
- incident-response: Fixed 29 references in incident-response, smart-fix
- data-engineering: Fixed 12 references in data-driven-feature
- backend-development: Fixed 11 references in feature-development
- framework-migration: Fixed 10 references in legacy-modernize
- git-pr-workflows: Fixed 7 references in git-workflow
- security-scanning: Fixed 7 references in security-hardening
- full-stack-orchestration: Fixed 6 references in full-stack-feature
- application-performance: Fixed 5 references in performance-optimization
- comprehensive-review: Fixed 5 references in full-review
- multi-platform-apps: Fixed 5 references in multi-platform

Changes:
- Added namespace prefixes for all external agent references
- Replaced 14 missing agents with appropriate equivalents
- Updated marketplace.json to bump affected plugin versions

Closes #95

.claude-plugin/marketplace.json

@@ -72,7 +72,7 @@
       "name": "git-pr-workflows",
       "source": "./plugins/git-pr-workflows",
       "description": "Git workflow automation, pull request enhancement, and team onboarding processes",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -102,7 +102,7 @@
       "name": "backend-development",
       "source": "./plugins/backend-development",
       "description": "Backend API design, GraphQL architecture, and test-driven backend development",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -161,7 +161,7 @@
       "name": "full-stack-orchestration",
       "source": "./plugins/full-stack-orchestration",
       "description": "End-to-end feature orchestration with testing, security, performance, and deployment",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -221,7 +221,7 @@
       "name": "tdd-workflows",
       "source": "./plugins/tdd-workflows",
       "description": "Test-driven development methodology with red-green-refactor cycles and code review",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -514,7 +514,7 @@
       "name": "data-engineering",
       "source": "./plugins/data-engineering",
       "description": "ETL pipeline construction, data warehouse design, batch processing workflows, and data-driven feature development",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -544,7 +544,7 @@
       "name": "incident-response",
       "source": "./plugins/incident-response",
       "description": "Production incident management, triage workflows, and automated incident resolution",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -812,7 +812,7 @@
       "name": "application-performance",
       "source": "./plugins/application-performance",
       "description": "Application profiling, performance optimization, and observability for frontend and backend systems",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -871,7 +871,7 @@
       "name": "comprehensive-review",
       "source": "./plugins/comprehensive-review",
       "description": "Multi-perspective code analysis covering architecture, security, and best practices",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -930,7 +930,7 @@
       "name": "framework-migration",
       "source": "./plugins/framework-migration",
       "description": "Framework updates, migration planning, and architectural transformation workflows",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -1047,7 +1047,7 @@
       "name": "security-scanning",
       "source": "./plugins/security-scanning",
       "description": "SAST analysis, dependency vulnerability scanning, OWASP Top 10 compliance, container security scanning, and automated security hardening",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"
@@ -1364,7 +1364,7 @@
       "name": "multi-platform-apps",
       "source": "./plugins/multi-platform-apps",
       "description": "Cross-platform application development coordinating web, iOS, Android, and desktop implementations",
-      "version": "1.2.0",
+      "version": "1.2.1",
       "author": {
         "name": "Seth Hobson",
         "url": "https://github.com/wshobson"

plugins/application-performance/commands/performance-optimization.md

@@ -25,13 +25,13 @@ Optimize application performance end-to-end using specialized performance and op
 ## Phase 2: Database & Backend Optimization
 
 ### 4. Database Performance Optimization
-- Use Task tool with subagent_type="database-optimizer"
+- Use Task tool with subagent_type="database-cloud-optimization::database-optimizer"
 - Prompt: "Optimize database performance for: $ARGUMENTS based on profiling data: {context_from_phase_1}. Analyze slow query logs, create missing indexes, optimize execution plans, implement query result caching with Redis/Memcached. Review connection pooling, prepared statements, and batch processing opportunities. Consider read replicas and database sharding if needed."
 - Context: Performance bottlenecks from phase 1
 - Output: Optimized queries, new indexes, caching strategy, connection pool configuration
 
 ### 5. Backend Code & API Optimization
-- Use Task tool with subagent_type="backend-architect"
+- Use Task tool with subagent_type="backend-development::backend-architect"
 - Prompt: "Optimize backend services for: $ARGUMENTS targeting bottlenecks: {context_from_phase_1}. Implement efficient algorithms, add application-level caching, optimize N+1 queries, use async/await patterns effectively. Implement pagination, response compression, GraphQL query optimization, and batch API operations. Add circuit breakers and bulkheads for resilience."
 - Context: Database optimizations from step 4, profiling data from phase 1
 - Output: Optimized backend code, caching implementation, API improvements, resilience patterns
@@ -51,13 +51,13 @@ Optimize application performance end-to-end using specialized performance and op
 - Output: Optimized bundles, lazy loading implementation, improved Core Web Vitals
 
 ### 8. CDN & Edge Optimization
-- Use Task tool with subagent_type="cloud-architect"
+- Use Task tool with subagent_type="cloud-infrastructure::cloud-architect"
 - Prompt: "Optimize CDN and edge performance for: $ARGUMENTS. Configure CloudFlare/CloudFront for optimal caching, implement edge functions for dynamic content, set up image optimization with responsive images and WebP/AVIF formats. Configure HTTP/2 and HTTP/3, implement Brotli compression. Set up geographic distribution for global users."
 - Context: Frontend optimizations from step 7
 - Output: CDN configuration, edge caching rules, compression setup, geographic optimization
 
 ### 9. Mobile & Progressive Web App Optimization
-- Use Task tool with subagent_type="mobile-developer"
+- Use Task tool with subagent_type="frontend-mobile-development::mobile-developer"
 - Prompt: "Optimize mobile experience for: $ARGUMENTS. Implement service workers for offline functionality, optimize for slow networks with adaptive loading. Reduce JavaScript execution time for mobile CPUs. Implement virtual scrolling for long lists. Optimize touch responsiveness and smooth animations. Consider React Native/Flutter specific optimizations if applicable."
 - Context: Frontend optimizations from steps 7-8
 - Output: Mobile-optimized code, PWA implementation, offline functionality
@@ -71,7 +71,7 @@ Optimize application performance end-to-end using specialized performance and op
 - Output: Load test results, performance under load, breaking points, scalability analysis
 
 ### 11. Performance Regression Testing
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="performance-testing-review::test-automator"
 - Prompt: "Create automated performance regression tests for: $ARGUMENTS. Set up performance budgets for key metrics, integrate with CI/CD pipeline using GitHub Actions or similar. Create Lighthouse CI tests for frontend, API performance tests with Artillery, and database performance benchmarks. Implement automatic rollback triggers for performance regressions."
 - Context: Load test results from step 10, baseline metrics from phase 1
 - Output: Performance test suite, CI/CD integration, regression prevention system

plugins/backend-development/commands/feature-development.md

@@ -26,19 +26,19 @@ Orchestrate end-to-end feature development from requirements to production deplo
 ## Phase 1: Discovery & Requirements Planning
 
 1. **Business Analysis & Requirements**
-   - Use Task tool with subagent_type="business-analyst"
+   - Use Task tool with subagent_type="business-analytics::business-analyst"
    - Prompt: "Analyze feature requirements for: $ARGUMENTS. Define user stories, acceptance criteria, success metrics, and business value. Identify stakeholders, dependencies, and risks. Create feature specification document with clear scope boundaries."
    - Expected output: Requirements document with user stories, success metrics, risk assessment
    - Context: Initial feature request and business context
 
 2. **Technical Architecture Design**
-   - Use Task tool with subagent_type="architect-review"
+   - Use Task tool with subagent_type="comprehensive-review::architect-review"
    - Prompt: "Design technical architecture for feature: $ARGUMENTS. Using requirements: [include business analysis from step 1]. Define service boundaries, API contracts, data models, integration points, and technology stack. Consider scalability, performance, and security requirements."
    - Expected output: Technical design document with architecture diagrams, API specifications, data models
    - Context: Business requirements, existing system architecture
 
 3. **Feasibility & Risk Assessment**
-   - Use Task tool with subagent_type="security-auditor"
+   - Use Task tool with subagent_type="security-scanning::security-auditor"
    - Prompt: "Assess security implications and risks for feature: $ARGUMENTS. Review architecture: [include technical design from step 2]. Identify security requirements, compliance needs, data privacy concerns, and potential vulnerabilities."
    - Expected output: Security assessment with risk matrix, compliance checklist, mitigation strategies
    - Context: Technical design, regulatory requirements
@@ -52,13 +52,13 @@ Orchestrate end-to-end feature development from requirements to production deplo
    - Context: Technical design, API contracts, data models
 
 5. **Frontend Implementation**
-   - Use Task tool with subagent_type="frontend-developer"
+   - Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
    - Prompt: "Build frontend components for: $ARGUMENTS. Integrate with backend APIs: [include API endpoints from step 4]. Implement responsive UI, state management, error handling, loading states, and analytics tracking. Add feature flag integration for A/B testing capabilities."
    - Expected output: Frontend components with API integration, state management, analytics
    - Context: Backend APIs, UI/UX designs, user stories
 
 6. **Data Pipeline & Integration**
-   - Use Task tool with subagent_type="data-engineer"
+   - Use Task tool with subagent_type="data-engineering::data-engineer"
    - Prompt: "Build data pipelines for: $ARGUMENTS. Design ETL/ELT processes, implement data validation, create analytics events, set up data quality monitoring. Integrate with product analytics platforms for feature usage tracking."
    - Expected output: Data pipelines, analytics events, data quality checks
    - Context: Data requirements, analytics needs, existing data infrastructure
@@ -66,19 +66,19 @@ Orchestrate end-to-end feature development from requirements to production deplo
 ## Phase 3: Testing & Quality Assurance
 
 7. **Automated Test Suite**
-   - Use Task tool with subagent_type="test-automator"
+   - Use Task tool with subagent_type="unit-testing::test-automator"
    - Prompt: "Create comprehensive test suite for: $ARGUMENTS. Write unit tests for backend: [from step 4] and frontend: [from step 5]. Add integration tests for API endpoints, E2E tests for critical user journeys, performance tests for scalability validation. Ensure minimum 80% code coverage."
    - Expected output: Test suites with unit, integration, E2E, and performance tests
    - Context: Implementation code, acceptance criteria, test requirements
 
 8. **Security Validation**
-   - Use Task tool with subagent_type="security-auditor"
+   - Use Task tool with subagent_type="security-scanning::security-auditor"
    - Prompt: "Perform security testing for: $ARGUMENTS. Review implementation: [include backend and frontend from steps 4-5]. Run OWASP checks, penetration testing, dependency scanning, and compliance validation. Verify data encryption, authentication, and authorization."
    - Expected output: Security test results, vulnerability report, remediation actions
    - Context: Implementation code, security requirements
 
 9. **Performance Optimization**
-   - Use Task tool with subagent_type="performance-engineer"
+   - Use Task tool with subagent_type="application-performance::performance-engineer"
    - Prompt: "Optimize performance for: $ARGUMENTS. Analyze backend services: [from step 4] and frontend: [from step 5]. Profile code, optimize queries, implement caching, reduce bundle sizes, improve load times. Set up performance budgets and monitoring."
    - Expected output: Performance improvements, optimization report, performance metrics
    - Context: Implementation code, performance requirements
@@ -86,19 +86,19 @@ Orchestrate end-to-end feature development from requirements to production deplo
 ## Phase 4: Deployment & Monitoring
 
 10. **Deployment Strategy & Pipeline**
-    - Use Task tool with subagent_type="deployment-engineer"
+    - Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
     - Prompt: "Prepare deployment for: $ARGUMENTS. Create CI/CD pipeline with automated tests: [from step 7]. Configure feature flags for gradual rollout, implement blue-green deployment, set up rollback procedures. Create deployment runbook and rollback plan."
     - Expected output: CI/CD pipeline, deployment configuration, rollback procedures
     - Context: Test suites, infrastructure requirements, deployment strategy
 
 11. **Observability & Monitoring**
-    - Use Task tool with subagent_type="observability-engineer"
+    - Use Task tool with subagent_type="observability-monitoring::observability-engineer"
     - Prompt: "Set up observability for: $ARGUMENTS. Implement distributed tracing, custom metrics, error tracking, and alerting. Create dashboards for feature usage, performance metrics, error rates, and business KPIs. Set up SLOs/SLIs with automated alerts."
     - Expected output: Monitoring dashboards, alerts, SLO definitions, observability infrastructure
     - Context: Feature implementation, success metrics, operational requirements
 
 12. **Documentation & Knowledge Transfer**
-    - Use Task tool with subagent_type="doc-generator"
+    - Use Task tool with subagent_type="documentation-generation::docs-architect"
     - Prompt: "Generate comprehensive documentation for: $ARGUMENTS. Create API documentation, user guides, deployment guides, troubleshooting runbooks. Include architecture diagrams, data flow diagrams, and integration guides. Generate automated changelog from commits."
     - Expected output: API docs, user guides, runbooks, architecture documentation
     - Context: All previous phases' outputs

plugins/comprehensive-review/commands/full-review.md

@@ -39,7 +39,7 @@ Use Task tool with security and performance agents, incorporating Phase 1 findin
 - Context: Incorporates architectural vulnerabilities identified in Phase 1B
 
 ### 2B. Performance & Scalability Analysis
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="application-performance::performance-engineer"
 - Prompt: "Conduct performance analysis and scalability assessment for: $ARGUMENTS. Profile code for CPU/memory hotspots, analyze database query performance, review caching strategies, identify N+1 problems, assess connection pooling, and evaluate asynchronous processing patterns. Consider architectural findings from Phase 1: {phase1_architecture_context}. Check for memory leaks, resource contention, and bottlenecks under load."
 - Expected output: Performance metrics, bottleneck analysis, optimization recommendations
 - Context: Uses architecture insights to identify systemic performance issues
@@ -49,13 +49,13 @@ Use Task tool with security and performance agents, incorporating Phase 1 findin
 Use Task tool for test and documentation quality assessment:
 
 ### 3A. Test Coverage & Quality Analysis
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Evaluate testing strategy and implementation for: $ARGUMENTS. Analyze unit test coverage, integration test completeness, end-to-end test scenarios, test pyramid adherence, and test maintainability. Review test quality metrics including assertion density, test isolation, mock usage, and flakiness. Consider security and performance test requirements from Phase 2: {phase2_security_context}, {phase2_performance_context}. Verify TDD practices if --tdd-review flag is set."
 - Expected output: Coverage report, test quality metrics, testing gap analysis
 - Context: Incorporates security and performance testing requirements from Phase 2
 
 ### 3B. Documentation & API Specification Review
-- Use Task tool with subagent_type="docs-architect"
+- Use Task tool with subagent_type="code-documentation::docs-architect"
 - Prompt: "Review documentation completeness and quality for: $ARGUMENTS. Assess inline code documentation, API documentation (OpenAPI/Swagger), architecture decision records (ADRs), README completeness, deployment guides, and runbooks. Verify documentation reflects actual implementation based on all previous phase findings: {phase1_context}, {phase2_context}. Check for outdated documentation, missing examples, and unclear explanations."
 - Expected output: Documentation coverage report, inconsistency list, improvement recommendations
 - Context: Cross-references all previous findings to ensure documentation accuracy
@@ -65,13 +65,13 @@ Use Task tool for test and documentation quality assessment:
 Use Task tool to verify framework-specific and industry best practices:
 
 ### 4A. Framework & Language Best Practices
-- Use Task tool with subagent_type="framework-specialist"
+- Use Task tool with subagent_type="framework-migration::legacy-modernizer"
 - Prompt: "Verify adherence to framework and language best practices for: $ARGUMENTS. Check modern JavaScript/TypeScript patterns, React hooks best practices, Python PEP compliance, Java enterprise patterns, Go idiomatic code, or framework-specific conventions (based on --framework flag). Review package management, build configuration, environment handling, and deployment practices. Include all quality issues from previous phases: {all_previous_contexts}."
 - Expected output: Best practices compliance report, modernization recommendations
 - Context: Synthesizes all previous findings for framework-specific guidance
 
 ### 4B. CI/CD & DevOps Practices Review
-- Use Task tool with subagent_type="devops-engineer"
+- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
 - Prompt: "Review CI/CD pipeline and DevOps practices for: $ARGUMENTS. Evaluate build automation, test automation integration, deployment strategies (blue-green, canary), infrastructure as code, monitoring/observability setup, and incident response procedures. Assess pipeline security, artifact management, and rollback capabilities. Consider all issues identified in previous phases that impact deployment: {all_critical_issues}."
 - Expected output: Pipeline assessment, DevOps maturity evaluation, automation recommendations
 - Context: Focuses on operationalizing fixes for all identified issues

plugins/data-engineering/commands/data-driven-feature.md

@@ -7,18 +7,18 @@ Build features guided by data insights, A/B testing, and continuous measurement
 ## Phase 1: Data Analysis and Hypothesis Formation
 
 ### 1. Exploratory Data Analysis
-- Use Task tool with subagent_type="data-scientist"
+- Use Task tool with subagent_type="machine-learning-ops::data-scientist"
 - Prompt: "Perform exploratory data analysis for feature: $ARGUMENTS. Analyze existing user behavior data, identify patterns and opportunities, segment users by behavior, and calculate baseline metrics. Use modern analytics tools (Amplitude, Mixpanel, Segment) to understand current user journeys, conversion funnels, and engagement patterns."
 - Output: EDA report with visualizations, user segments, behavioral patterns, baseline metrics
 
 ### 2. Business Hypothesis Development
-- Use Task tool with subagent_type="business-analyst"
+- Use Task tool with subagent_type="business-analytics::business-analyst"
 - Context: Data scientist's EDA findings and behavioral patterns
 - Prompt: "Formulate business hypotheses for feature: $ARGUMENTS based on data analysis. Define clear success metrics, expected impact on key business KPIs, target user segments, and minimum detectable effects. Create measurable hypotheses using frameworks like ICE scoring or RICE prioritization."
 - Output: Hypothesis document, success metrics definition, expected ROI calculations
 
 ### 3. Statistical Experiment Design
-- Use Task tool with subagent_type="data-scientist"
+- Use Task tool with subagent_type="machine-learning-ops::data-scientist"
 - Context: Business hypotheses and success metrics
 - Prompt: "Design statistical experiment for feature: $ARGUMENTS. Calculate required sample size for statistical power, define control and treatment groups, specify randomization strategy, and plan for multiple testing corrections. Consider Bayesian A/B testing approaches for faster decision making. Design for both primary and guardrail metrics."
 - Output: Experiment design document, power analysis, statistical test plan
@@ -26,19 +26,19 @@ Build features guided by data insights, A/B testing, and continuous measurement
 ## Phase 2: Feature Architecture and Analytics Design
 
 ### 4. Feature Architecture Planning
-- Use Task tool with subagent_type="backend-architect"
+- Use Task tool with subagent_type="data-engineering::backend-architect"
 - Context: Business requirements and experiment design
 - Prompt: "Design feature architecture for: $ARGUMENTS with A/B testing capability. Include feature flag integration (LaunchDarkly, Split.io, or Optimizely), gradual rollout strategy, circuit breakers for safety, and clean separation between control and treatment logic. Ensure architecture supports real-time configuration updates."
 - Output: Architecture diagrams, feature flag schema, rollout strategy
 
 ### 5. Analytics Instrumentation Design
-- Use Task tool with subagent_type="data-engineer"
+- Use Task tool with subagent_type="data-engineering::data-engineer"
 - Context: Feature architecture and success metrics
 - Prompt: "Design comprehensive analytics instrumentation for: $ARGUMENTS. Define event schemas for user interactions, specify properties for segmentation and analysis, design funnel tracking and conversion events, plan cohort analysis capabilities. Implement using modern SDKs (Segment, Amplitude, Mixpanel) with proper event taxonomy."
 - Output: Event tracking plan, analytics schema, instrumentation guide
 
 ### 6. Data Pipeline Architecture
-- Use Task tool with subagent_type="data-engineer"
+- Use Task tool with subagent_type="data-engineering::data-engineer"
 - Context: Analytics requirements and existing data infrastructure
 - Prompt: "Design data pipelines for feature: $ARGUMENTS. Include real-time streaming for live metrics (Kafka, Kinesis), batch processing for detailed analysis, data warehouse integration (Snowflake, BigQuery), and feature store for ML if applicable. Ensure proper data governance and GDPR compliance."
 - Output: Pipeline architecture, ETL/ELT specifications, data flow diagrams
@@ -46,19 +46,19 @@ Build features guided by data insights, A/B testing, and continuous measurement
 ## Phase 3: Implementation with Instrumentation
 
 ### 7. Backend Implementation
-- Use Task tool with subagent_type="backend-engineer"
+- Use Task tool with subagent_type="backend-development::backend-architect"
 - Context: Architecture design and feature requirements
 - Prompt: "Implement backend for feature: $ARGUMENTS with full instrumentation. Include feature flag checks at decision points, comprehensive event tracking for all user actions, performance metrics collection, error tracking and monitoring. Implement proper logging for experiment analysis."
 - Output: Backend code with analytics, feature flag integration, monitoring setup
 
 ### 8. Frontend Implementation
-- Use Task tool with subagent_type="frontend-engineer"
+- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
 - Context: Backend APIs and analytics requirements
 - Prompt: "Build frontend for feature: $ARGUMENTS with analytics tracking. Implement event tracking for all user interactions, session recording integration if applicable, performance metrics (Core Web Vitals), and proper error boundaries. Ensure consistent experience between control and treatment groups."
 - Output: Frontend code with analytics, A/B test variants, performance monitoring
 
 ### 9. ML Model Integration (if applicable)
-- Use Task tool with subagent_type="ml-engineer"
+- Use Task tool with subagent_type="machine-learning-ops::ml-engineer"
 - Context: Feature requirements and data pipelines
 - Prompt: "Integrate ML models for feature: $ARGUMENTS if needed. Implement online inference with low latency, A/B testing between model versions, model performance tracking, and automatic fallback mechanisms. Set up model monitoring for drift detection."
 - Output: ML pipeline, model serving infrastructure, monitoring setup
@@ -66,13 +66,13 @@ Build features guided by data insights, A/B testing, and continuous measurement
 ## Phase 4: Pre-Launch Validation
 
 ### 10. Analytics Validation
-- Use Task tool with subagent_type="data-engineer"
+- Use Task tool with subagent_type="data-engineering::data-engineer"
 - Context: Implemented tracking and event schemas
 - Prompt: "Validate analytics implementation for: $ARGUMENTS. Test all event tracking in staging, verify data quality and completeness, validate funnel definitions, ensure proper user identification and session tracking. Run end-to-end tests for data pipeline."
 - Output: Validation report, data quality metrics, tracking coverage analysis
 
 ### 11. Experiment Setup
-- Use Task tool with subagent_type="platform-engineer"
+- Use Task tool with subagent_type="cloud-infrastructure::deployment-engineer"
 - Context: Feature flags and experiment design
 - Prompt: "Configure experiment infrastructure for: $ARGUMENTS. Set up feature flags with proper targeting rules, configure traffic allocation (start with 5-10%), implement kill switches, set up monitoring alerts for key metrics. Test randomization and assignment logic."
 - Output: Experiment configuration, monitoring dashboards, rollout plan
@@ -80,13 +80,13 @@ Build features guided by data insights, A/B testing, and continuous measurement
 ## Phase 5: Launch and Experimentation
 
 ### 12. Gradual Rollout
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="cloud-infrastructure::deployment-engineer"
 - Context: Experiment configuration and monitoring setup
 - Prompt: "Execute gradual rollout for feature: $ARGUMENTS. Start with internal dogfooding, then beta users (1-5%), gradually increase to target traffic. Monitor error rates, performance metrics, and early indicators. Implement automated rollback on anomalies."
 - Output: Rollout execution, monitoring alerts, health metrics
 
 ### 13. Real-time Monitoring
-- Use Task tool with subagent_type="observability-engineer"
+- Use Task tool with subagent_type="observability-monitoring::observability-engineer"
 - Context: Deployed feature and success metrics
 - Prompt: "Set up comprehensive monitoring for: $ARGUMENTS. Create real-time dashboards for experiment metrics, configure alerts for statistical significance, monitor guardrail metrics for negative impacts, track system performance and error rates. Use tools like Datadog, New Relic, or custom dashboards."
 - Output: Monitoring dashboards, alert configurations, SLO definitions
@@ -94,19 +94,19 @@ Build features guided by data insights, A/B testing, and continuous measurement
 ## Phase 6: Analysis and Decision Making
 
 ### 14. Statistical Analysis
-- Use Task tool with subagent_type="data-scientist"
+- Use Task tool with subagent_type="machine-learning-ops::data-scientist"
 - Context: Experiment data and original hypotheses
 - Prompt: "Analyze A/B test results for: $ARGUMENTS. Calculate statistical significance with confidence intervals, check for segment-level effects, analyze secondary metrics impact, investigate any unexpected patterns. Use both frequentist and Bayesian approaches. Account for multiple testing if applicable."
 - Output: Statistical analysis report, significance tests, segment analysis
 
 ### 15. Business Impact Assessment
-- Use Task tool with subagent_type="business-analyst"
+- Use Task tool with subagent_type="business-analytics::business-analyst"
 - Context: Statistical analysis and business metrics
 - Prompt: "Assess business impact of feature: $ARGUMENTS. Calculate actual vs expected ROI, analyze impact on key business metrics, evaluate cost-benefit including operational overhead, project long-term value. Make recommendation on full rollout, iteration, or rollback."
 - Output: Business impact report, ROI analysis, recommendation document
 
 ### 16. Post-Launch Optimization
-- Use Task tool with subagent_type="data-scientist"
+- Use Task tool with subagent_type="machine-learning-ops::data-scientist"
 - Context: Launch results and user feedback
 - Prompt: "Identify optimization opportunities for: $ARGUMENTS based on data. Analyze user behavior patterns in treatment group, identify friction points in user journey, suggest improvements based on data, plan follow-up experiments. Use cohort analysis for long-term impact."
 - Output: Optimization recommendations, follow-up experiment plans

plugins/framework-migration/commands/legacy-modernize.md

@@ -18,7 +18,7 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 - Expected output: Visual dependency map and integration point catalog
 
 ### 3. Business Impact and Risk Assessment
-- Use Task tool with subagent_type="project-manager"
+- Use Task tool with subagent_type="business-analytics::business-analyst"
 - Prompt: "Evaluate business impact of modernizing each component identified. Create risk assessment matrix considering: business criticality (revenue impact), user traffic patterns, data sensitivity, regulatory requirements, and fallback complexity. Prioritize components using a weighted scoring system: (Business Value × 0.4) + (Technical Risk × 0.3) + (Quick Win Potential × 0.3). Define rollback strategies for each component."
 - Context from previous: Component inventory, dependency mapping
 - Expected output: Prioritized migration roadmap with risk mitigation strategies
@@ -26,18 +26,18 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 2: Test Coverage Establishment
 
 ### 1. Legacy Code Test Coverage Analysis
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Analyze existing test coverage for legacy components at $ARGUMENTS. Use coverage tools to identify untested code paths, missing integration tests, and absent end-to-end scenarios. For components with <40% coverage, generate characterization tests that capture current behavior without modifying functionality. Create test harness for safe refactoring."
 - Expected output: Test coverage report and characterization test suite
 
 ### 2. Contract Testing Implementation
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Implement contract tests for all integration points identified in dependency mapping. Create consumer-driven contracts for APIs, message queue interactions, and database schemas. Set up contract verification in CI/CD pipeline. Generate performance baselines for response times and throughput to validate modernized components maintain SLAs."
 - Context from previous: Integration point catalog, existing test coverage
 - Expected output: Contract test suite with performance baselines
 
 ### 3. Test Data Management Strategy
-- Use Task tool with subagent_type="data-engineer"
+- Use Task tool with subagent_type="data-engineering::data-engineer"
 - Prompt: "Design test data management strategy for parallel system operation. Create data generation scripts for edge cases, implement data masking for sensitive information, and establish test database refresh procedures. Set up monitoring for data consistency between legacy and modernized components during migration."
 - Context from previous: Database schemas, test requirements
 - Expected output: Test data pipeline and consistency monitoring
@@ -45,18 +45,18 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 3: Incremental Migration Implementation
 
 ### 1. Strangler Fig Infrastructure Setup
-- Use Task tool with subagent_type="backend-architect"
+- Use Task tool with subagent_type="backend-development::backend-architect"
 - Prompt: "Implement strangler fig infrastructure with API gateway for traffic routing. Configure feature flags for gradual rollout using environment variables or feature management service. Set up proxy layer with request routing rules based on: URL patterns, headers, or user segments. Implement circuit breakers and fallback mechanisms for resilience. Create observability dashboard for dual-system monitoring."
 - Expected output: API gateway configuration, feature flag system, monitoring dashboard
 
 ### 2. Component Modernization - First Wave
-- Use Task tool with subagent_type="python-pro" or "golang-pro" (based on target stack)
+- Use Task tool with subagent_type="python-development::python-pro" or "golang-pro" (based on target stack)
 - Prompt: "Modernize first-wave components (quick wins identified in assessment). For each component: extract business logic from legacy code, implement using modern patterns (dependency injection, SOLID principles), ensure backward compatibility through adapter patterns, maintain data consistency with event sourcing or dual writes. Follow 12-factor app principles. Components to modernize: [list from prioritized roadmap]"
 - Context from previous: Characterization tests, contract tests, infrastructure setup
 - Expected output: Modernized components with adapters
 
 ### 3. Security Hardening
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="security-scanning::security-auditor"
 - Prompt: "Audit modernized components for security vulnerabilities. Implement security improvements including: OAuth 2.0/JWT authentication, role-based access control, input validation and sanitization, SQL injection prevention, XSS protection, and secrets management. Verify OWASP top 10 compliance. Configure security headers and implement rate limiting."
 - Context from previous: Modernized component code
 - Expected output: Security audit report and hardened components
@@ -64,13 +64,13 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 4: Performance Validation and Optimization
 
 ### 1. Performance Testing and Optimization
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="application-performance::performance-engineer"
 - Prompt: "Conduct performance testing comparing legacy vs modernized components. Run load tests simulating production traffic patterns, measure response times, throughput, and resource utilization. Identify performance regressions and optimize: database queries with indexing, caching strategies (Redis/Memcached), connection pooling, and async processing where applicable. Validate against SLA requirements."
 - Context from previous: Performance baselines, modernized components
 - Expected output: Performance test results and optimization recommendations
 
 ### 2. Progressive Rollout and Monitoring
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
 - Prompt: "Implement progressive rollout strategy using feature flags. Start with 5% traffic to modernized components, monitor error rates, latency, and business metrics. Define automatic rollback triggers: error rate >1%, latency >2x baseline, or business metric degradation. Create runbook for traffic shifting: 5% → 25% → 50% → 100% with 24-hour observation periods."
 - Context from previous: Feature flag configuration, monitoring dashboard
 - Expected output: Rollout plan with automated safeguards
@@ -84,7 +84,7 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 - Expected output: Decommissioning checklist and timeline
 
 ### 2. Documentation and Knowledge Transfer
-- Use Task tool with subagent_type="docs-architect"
+- Use Task tool with subagent_type="documentation-generation::docs-architect"
 - Prompt: "Create comprehensive modernization documentation including: architectural diagrams (before/after), API documentation with migration guides, runbooks for dual-system operation, troubleshooting guides for common issues, and lessons learned report. Generate developer onboarding guide for modernized system. Document technical decisions and trade-offs made during migration."
 - Context from previous: All migration artifacts and decisions
 - Expected output: Complete modernization documentation package

plugins/full-stack-orchestration/commands/full-stack-feature.md

@@ -5,19 +5,19 @@ Orchestrate full-stack feature development across backend, frontend, and infrast
 ## Phase 1: Architecture & Design Foundation
 
 ### 1. Database Architecture Design
-- Use Task tool with subagent_type="database-architect"
+- Use Task tool with subagent_type="database-design::database-architect"
 - Prompt: "Design database schema and data models for: $ARGUMENTS. Consider scalability, query patterns, indexing strategy, and data consistency requirements. Include migration strategy if modifying existing schema. Provide both logical and physical data models."
 - Expected output: Entity relationship diagrams, table schemas, indexing strategy, migration scripts, data access patterns
 - Context: Initial requirements and business domain model
 
 ### 2. Backend Service Architecture
-- Use Task tool with subagent_type="backend-architect"
+- Use Task tool with subagent_type="backend-development::backend-architect"
 - Prompt: "Design backend service architecture for: $ARGUMENTS. Using the database design from previous step, create service boundaries, define API contracts (OpenAPI/GraphQL), design authentication/authorization strategy, and specify inter-service communication patterns. Include resilience patterns (circuit breakers, retries) and caching strategy."
 - Expected output: Service architecture diagram, OpenAPI specifications, authentication flows, caching architecture, message queue design (if applicable)
 - Context: Database schema from step 1, non-functional requirements
 
 ### 3. Frontend Component Architecture
-- Use Task tool with subagent_type="frontend-developer"
+- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
 - Prompt: "Design frontend architecture and component structure for: $ARGUMENTS. Based on the API contracts from previous step, design component hierarchy, state management approach (Redux/Zustand/Context), routing structure, and data fetching patterns. Include accessibility requirements and responsive design strategy. Plan for Storybook component documentation."
 - Expected output: Component tree diagram, state management design, routing configuration, design system integration plan, accessibility checklist
 - Context: API specifications from step 2, UI/UX requirements
@@ -25,19 +25,19 @@ Orchestrate full-stack feature development across backend, frontend, and infrast
 ## Phase 2: Parallel Implementation
 
 ### 4. Backend Service Implementation
-- Use Task tool with subagent_type="python-pro" (or "golang-pro"/"nodejs-expert" based on stack)
+- Use Task tool with subagent_type="python-development::python-pro" (or "golang-pro"/"nodejs-expert" based on stack)
 - Prompt: "Implement backend services for: $ARGUMENTS. Using the architecture and API specs from Phase 1, build RESTful/GraphQL endpoints with proper validation, error handling, and logging. Implement business logic, data access layer, authentication middleware, and integration with external services. Include observability (structured logging, metrics, tracing)."
 - Expected output: Backend service code, API endpoints, middleware, background jobs, unit tests, integration tests
 - Context: Architecture designs from Phase 1, database schema
 
 ### 5. Frontend Implementation
-- Use Task tool with subagent_type="frontend-developer"
+- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
 - Prompt: "Implement frontend application for: $ARGUMENTS. Build React/Next.js components using the component architecture from Phase 1. Implement state management, API integration with proper error handling and loading states, form validation, and responsive layouts. Create Storybook stories for components. Ensure accessibility (WCAG 2.1 AA compliance)."
 - Expected output: React components, state management implementation, API client code, Storybook stories, responsive styles, accessibility implementations
 - Context: Component architecture from step 3, API contracts
 
 ### 6. Database Implementation & Optimization
-- Use Task tool with subagent_type="sql-pro"
+- Use Task tool with subagent_type="database-design::sql-pro"
 - Prompt: "Implement and optimize database layer for: $ARGUMENTS. Create migration scripts, stored procedures (if needed), optimize queries identified by backend implementation, set up proper indexes, and implement data validation constraints. Include database-level security measures and backup strategies."
 - Expected output: Migration scripts, optimized queries, stored procedures, index definitions, database security configuration
 - Context: Database design from step 1, query patterns from backend implementation

plugins/git-pr-workflows/commands/git-workflow.md

@@ -33,13 +33,13 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 2: Testing and Validation
 
 ### 1. Test Execution and Coverage
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Execute all test suites for the modified code. Run: 1) Unit tests, 2) Integration tests, 3) End-to-end tests if applicable. Generate coverage report and identify any untested code paths. Based on review issues: [insert critical/high issues], ensure tests cover the problem areas. Provide test results in format: {passed: [], failed: [], skipped: [], coverage: {statements: %, branches: %, functions: %, lines: %}, untested_critical_paths: []}"
 - Context from previous: Critical code review issues that need test coverage
 - Expected output: Complete test results and coverage metrics
 
 ### 2. Test Recommendations and Gap Analysis
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Based on test results [insert summary] and code changes, identify: 1) Missing test scenarios, 2) Edge cases not covered, 3) Integration points needing verification, 4) Performance benchmarks needed. Generate test implementation recommendations prioritized by risk. Consider the breaking changes identified: [insert breaking changes]."
 - Context from previous: Test results, breaking changes, untested paths
 - Expected output: Prioritized list of additional tests needed
@@ -53,7 +53,7 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 - Expected output: Commit structure recommendation
 
 ### 2. Conventional Commit Message Creation
-- Use Task tool with subagent_type="prompt-engineer"
+- Use Task tool with subagent_type="llm-application-dev::prompt-engineer"
 - Prompt: "Create Conventional Commits format message(s) based on categorization: [insert categorization]. Format: <type>(<scope>): <subject> with blank line then <body> explaining what and why (not how), then <footer> with BREAKING CHANGE: if applicable. Include: 1) Clear subject line (50 chars max), 2) Detailed body explaining rationale, 3) References to issues/tickets, 4) Co-authors if applicable. Consider the impact: [insert breaking changes if any]."
 - Context from previous: Change categorization, breaking changes
 - Expected output: Properly formatted commit message(s)
@@ -61,12 +61,12 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 4: Branch Strategy and Push Preparation
 
 ### 1. Branch Management
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
 - Prompt: "Based on workflow type [--trunk-based or --feature-branch], prepare branch strategy. For feature branch: ensure branch name follows pattern (feature|bugfix|hotfix)/<ticket>-<description>. For trunk-based: prepare for direct main push with feature flag strategy if needed. Current branch: [insert branch], target: [insert target branch]. Verify no conflicts with target branch."
 - Expected output: Branch preparation commands and conflict status
 
 ### 2. Pre-Push Validation
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
 - Prompt: "Perform final pre-push checks: 1) Verify all CI checks will pass, 2) Confirm no sensitive data in commits, 3) Validate commit signatures if required, 4) Check branch protection rules, 5) Ensure all review comments addressed. Test summary: [insert test results]. Review status: [insert review summary]."
 - Context from previous: All previous validation results
 - Expected output: Push readiness confirmation or blocking issues
@@ -74,13 +74,13 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 5: Pull Request Creation
 
 ### 1. PR Description Generation
-- Use Task tool with subagent_type="docs-architect"
+- Use Task tool with subagent_type="documentation-generation::docs-architect"
 - Prompt: "Create comprehensive PR description including: 1) Summary of changes (what and why), 2) Type of change checklist, 3) Testing performed summary from [insert test results], 4) Screenshots/recordings if UI changes, 5) Deployment notes from [insert deployment considerations], 6) Related issues/tickets, 7) Breaking changes section if applicable: [insert breaking changes], 8) Reviewer checklist. Format as GitHub-flavored Markdown."
 - Context from previous: All validation results, test outcomes, breaking changes
 - Expected output: Complete PR description in Markdown
 
 ### 2. PR Metadata and Automation Setup
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
 - Prompt: "Configure PR metadata: 1) Assign appropriate reviewers based on CODEOWNERS, 2) Add labels (type, priority, component), 3) Link related issues, 4) Set milestone if applicable, 5) Configure merge strategy (squash/merge/rebase), 6) Set up auto-merge if all checks pass. Consider draft status: [--draft-pr flag]. Include test status: [insert test summary]."
 - Context from previous: PR description, test results, review status
 - Expected output: PR configuration commands and automation rules

plugins/incident-response/commands/incident-response.md

@@ -27,7 +27,7 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 - Context: Initial alerts, monitoring dashboards, recent changes
 
 ### 2. Observability Analysis
-- Use Task tool with subagent_type="observability-engineer"
+- Use Task tool with subagent_type="observability-monitoring::observability-engineer"
 - Prompt: "Perform rapid observability sweep for incident: $ARGUMENTS. Query: 1) Distributed tracing (OpenTelemetry/Jaeger), 2) Metrics correlation (Prometheus/Grafana/DataDog), 3) Log aggregation (ELK/Splunk), 4) APM data, 5) Real User Monitoring. Identify anomalies, error patterns, and service degradation points."
 - Output: Observability findings, anomaly detection, service health matrix, trace analysis
 - Context: Severity level from step 1, affected services
@@ -41,19 +41,19 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 ## Phase 2: Investigation & Root Cause Analysis
 
 ### 4. Deep System Debugging
-- Use Task tool with subagent_type="debugger"
+- Use Task tool with subagent_type="error-debugging::debugger"
 - Prompt: "Conduct deep debugging for incident: $ARGUMENTS using observability data. Investigate: 1) Stack traces and error logs, 2) Database query performance and locks, 3) Network latency and timeouts, 4) Memory leaks and CPU spikes, 5) Dependency failures and cascading errors. Apply Five Whys analysis."
 - Output: Root cause identification, contributing factors, dependency impact map
 - Context: Observability analysis, mitigation status
 
 ### 5. Security Assessment
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="security-scanning::security-auditor"
 - Prompt: "Assess security implications of incident: $ARGUMENTS. Check: 1) DDoS attack indicators, 2) Authentication/authorization failures, 3) Data exposure risks, 4) Certificate issues, 5) Suspicious access patterns. Review WAF logs, security groups, and audit trails."
 - Output: Security assessment, breach analysis, vulnerability identification
 - Context: Root cause findings, system logs
 
 ### 6. Performance Engineering Analysis
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="application-performance::performance-engineer"
 - Prompt: "Analyze performance aspects of incident: $ARGUMENTS. Examine: 1) Resource utilization patterns, 2) Query optimization opportunities, 3) Caching effectiveness, 4) Load balancer health, 5) CDN performance, 6) Autoscaling triggers. Identify bottlenecks and capacity issues."
 - Output: Performance bottlenecks, resource recommendations, optimization opportunities
 - Context: Debug findings, current mitigation state
@@ -61,13 +61,13 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 ## Phase 3: Resolution & Recovery
 
 ### 7. Fix Implementation
-- Use Task tool with subagent_type="backend-architect"
+- Use Task tool with subagent_type="backend-development::backend-architect"
 - Prompt: "Design and implement production fix for incident: $ARGUMENTS based on root cause. Requirements: 1) Minimal viable fix for rapid deployment, 2) Risk assessment and rollback capability, 3) Staged rollout plan with monitoring, 4) Validation criteria and health checks. Consider both immediate fix and long-term solution."
 - Output: Fix implementation, deployment strategy, validation plan, rollback procedures
 - Context: Root cause analysis, performance findings, security assessment
 
 ### 8. Deployment and Validation
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
 - Prompt: "Execute emergency deployment for incident fix: $ARGUMENTS. Process: 1) Blue-green or canary deployment, 2) Progressive rollout with monitoring, 3) Health check validation at each stage, 4) Rollback triggers configured, 5) Real-time monitoring during deployment. Coordinate with incident command."
 - Output: Deployment status, validation results, monitoring dashboard, rollback readiness
 - Context: Fix implementation, current system state
@@ -75,7 +75,7 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 ## Phase 4: Communication & Coordination
 
 ### 9. Stakeholder Communication
-- Use Task tool with subagent_type="content-marketer"
+- Use Task tool with subagent_type="content-marketing::content-marketer"
 - Prompt: "Manage incident communication for: $ARGUMENTS. Create: 1) Status page updates (public-facing), 2) Internal engineering updates (technical details), 3) Executive summary (business impact/ETA), 4) Customer support briefing (talking points), 5) Timeline documentation with key decisions. Update every 15-30 minutes based on severity."
 - Output: Communication artifacts, status updates, stakeholder briefings, timeline log
 - Context: All previous phases, current resolution status
@@ -89,19 +89,19 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 ## Phase 5: Postmortem & Prevention
 
 ### 11. Blameless Postmortem
-- Use Task tool with subagent_type="docs-architect"
+- Use Task tool with subagent_type="documentation-generation::docs-architect"
 - Prompt: "Conduct blameless postmortem for incident: $ARGUMENTS. Document: 1) Complete incident timeline with decisions, 2) Root cause and contributing factors (systems focus), 3) What went well in response, 4) What could improve, 5) Action items with owners and deadlines, 6) Lessons learned for team education. Follow SRE postmortem best practices."
 - Output: Postmortem document, action items list, process improvements, training needs
 - Context: Complete incident history, all agent outputs
 
 ### 12. Monitoring and Alert Enhancement
-- Use Task tool with subagent_type="observability-engineer"
+- Use Task tool with subagent_type="observability-monitoring::observability-engineer"
 - Prompt: "Enhance monitoring to prevent recurrence of: $ARGUMENTS. Implement: 1) New alerts for early detection, 2) SLI/SLO adjustments if needed, 3) Dashboard improvements for visibility, 4) Runbook automation opportunities, 5) Chaos engineering scenarios for testing. Ensure alerts are actionable and reduce noise."
 - Output: New monitoring configuration, alert rules, dashboard updates, runbook automation
 - Context: Postmortem findings, root cause analysis
 
 ### 13. System Hardening
-- Use Task tool with subagent_type="backend-architect"
+- Use Task tool with subagent_type="backend-development::backend-architect"
 - Prompt: "Design system improvements to prevent incident: $ARGUMENTS. Propose: 1) Architecture changes for resilience (circuit breakers, bulkheads), 2) Graceful degradation strategies, 3) Capacity planning adjustments, 4) Technical debt prioritization, 5) Dependency reduction opportunities. Create implementation roadmap."
 - Output: Architecture improvements, resilience patterns, technical debt items, roadmap
 - Context: Postmortem action items, performance analysis

plugins/incident-response/commands/smart-fix.md

@@ -4,7 +4,7 @@
 
 ## Phase 1: Issue Analysis - Error Detection and Context Gathering
 
-Use Task tool with subagent_type="error-detective" followed by subagent_type="debugger":
+Use Task tool with subagent_type="error-debugging::error-detective" followed by subagent_type="error-debugging::debugger":
 
 **First: Error-Detective Analysis**
 
@@ -89,7 +89,7 @@ TESTING_REQUIREMENTS: [scenarios that must be covered]
 
 ## Phase 2: Root Cause Investigation - Deep Code Analysis
 
-Use Task tool with subagent_type="debugger" and subagent_type="code-reviewer" for systematic investigation:
+Use Task tool with subagent_type="error-debugging::debugger" and subagent_type="comprehensive-review::code-reviewer" for systematic investigation:
 
 **First: Debugger Code Analysis**
 
@@ -181,13 +181,13 @@ ARCHITECTURAL_CONCERNS: {if systemic issues exist}
 Based on Phase 2 output, route to appropriate domain agent using Task tool:
 
 **Routing Logic:**
-- Python issues → subagent_type="python-pro"
+- Python issues → subagent_type="python-development::python-pro"
-- TypeScript/JavaScript → subagent_type="typescript-pro"
+- TypeScript/JavaScript → subagent_type="javascript-typescript::typescript-pro"
-- Go → subagent_type="go-expert"
+- Go → subagent_type="systems-programming::golang-pro"
-- Rust → subagent_type="rust-expert"
+- Rust → subagent_type="systems-programming::rust-pro"
-- SQL/Database → subagent_type="database-optimizer"
+- SQL/Database → subagent_type="database-cloud-optimization::database-optimizer"
-- Performance → subagent_type="performance-engineer"
+- Performance → subagent_type="application-performance::performance-engineer"
-- Security → subagent_type="security-specialist"
+- Security → subagent_type="security-scanning::security-auditor"
 
 **Prompt Template (adapt for language):**
 ```
@@ -265,7 +265,7 @@ BACKWARD_COMPATIBILITY: {maintained | breaking with mitigation}
 
 ## Phase 4: Verification - Automated Testing and Performance Validation
 
-Use Task tool with subagent_type="test-automator" and subagent_type="performance-engineer":
+Use Task tool with subagent_type="unit-testing::test-automator" and subagent_type="application-performance::performance-engineer":
 
 **First: Test-Automator Regression Suite**
 
@@ -493,7 +493,7 @@ FINAL_VERDICT: {
 
 ## Phase 5: Documentation and Prevention - Long-term Resilience
 
-Use Task tool with subagent_type="code-reviewer" for prevention strategies:
+Use Task tool with subagent_type="comprehensive-review::code-reviewer" for prevention strategies:
 
 **Prompt:**
 ```
@@ -609,13 +609,13 @@ For issues spanning multiple domains, orchestrate specialized agents sequentiall
 
 **Sequence:**
 1. **Phase 1-2**: error-detective + debugger identify slow database queries
-2. **Phase 3a**: Task(subagent_type="database-optimizer")
+2. **Phase 3a**: Task(subagent_type="database-cloud-optimization::database-optimizer")
    - Optimize query with proper indexes
    - Context: "Query execution taking 5s, missing index on user_id column, N+1 query pattern detected"
-3. **Phase 3b**: Task(subagent_type="performance-engineer")
+3. **Phase 3b**: Task(subagent_type="application-performance::performance-engineer")
    - Add caching layer for frequently accessed data
    - Context: "Database query optimized from 5s to 50ms by adding index on user_id column. Application still experiencing 2s response times due to N+1 query pattern loading 100+ user records per request. Add Redis caching with 5-minute TTL for user profiles."
-4. **Phase 3c**: Task(subagent_type="devops-troubleshooter")
+4. **Phase 3c**: Task(subagent_type="incident-response::devops-troubleshooter")
    - Configure monitoring for query performance and cache hit rates
    - Context: "Cache layer added with Redis. Need monitoring for: query p95 latency (threshold: 100ms), cache hit rate (threshold: >80%), cache memory usage (alert at 80%)."
 
@@ -626,11 +626,11 @@ For issues spanning multiple domains, orchestrate specialized agents sequentiall
    - Context: "TypeError: Cannot read property 'map' of undefined, 500+ occurrences in last hour, affects Safari users on iOS 14"
 2. **Phase 2**: debugger + code-reviewer investigate
    - Context: "API response sometimes returns null instead of empty array when no results. Frontend assumes array."
-3. **Phase 3a**: Task(subagent_type="typescript-pro")
+3. **Phase 3a**: Task(subagent_type="javascript-typescript::typescript-pro")
    - Fix frontend with proper null checks
    - Add type guards
    - Context: "Backend API /api/users endpoint returning null instead of [] when no results. Fix frontend to handle both. Add TypeScript strict null checks."
-4. **Phase 3b**: Task(subagent_type="backend-expert")
+4. **Phase 3b**: Task(subagent_type="backend-development::backend-architect")
    - Fix backend to always return array
    - Update API contract
    - Context: "Frontend now handles null, but API should follow contract and return [] not null. Update OpenAPI spec to document this."
@@ -642,9 +642,9 @@ For issues spanning multiple domains, orchestrate specialized agents sequentiall
 **Sequence:**
 1. **Phase 1**: error-detective reviews security scan report
    - Context: "SQL injection vulnerability in login endpoint, Snyk severity: HIGH"
-2. **Phase 2**: debugger + security-specialist investigate
+2. **Phase 2**: debugger + security-auditor investigate
    - Context: "User input not sanitized in SQL WHERE clause, allows authentication bypass"
-3. **Phase 3**: Task(subagent_type="security-specialist")
+3. **Phase 3**: Task(subagent_type="security-scanning::security-auditor")
    - Implement parameterized queries
    - Add input validation
    - Add rate limiting
@@ -652,7 +652,7 @@ For issues spanning multiple domains, orchestrate specialized agents sequentiall
 4. **Phase 4a**: test-automator adds security tests
    - SQL injection attempts
    - Brute force scenarios
-5. **Phase 4b**: security-specialist performs penetration testing
+5. **Phase 4b**: security-auditor performs penetration testing
 6. **Phase 5**: code-reviewer documents security improvements and creates postmortem
 
 **Context Passing Template:**

plugins/multi-platform-apps/commands/multi-platform.md

@@ -33,7 +33,7 @@ Build and deploy the same feature consistently across web, mobile, and desktop p
 - Expected output: Design system documentation, component library specs, platform guidelines
 
 ### 3. Shared Business Logic Architecture
-- Use Task tool with subagent_type="software-architect"
+- Use Task tool with subagent_type="comprehensive-review::architect-review"
 - Prompt: "Design shared business logic architecture for cross-platform feature. Define:
   - Core domain models and entities (platform-agnostic)
   - Business rules and validation logic
@@ -93,7 +93,7 @@ Build and deploy the same feature consistently across web, mobile, and desktop p
 - Expected output: Native Android implementation with tests
 
 ### 4d. Desktop Implementation (Optional - Electron/Tauri)
-- Use Task tool with subagent_type="desktop-developer"
+- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
 - Prompt: "Implement desktop version using Tauri 2.0 or Electron with:
   - Shared web codebase where possible
   - Native OS integration (system tray, notifications)
@@ -109,7 +109,7 @@ Build and deploy the same feature consistently across web, mobile, and desktop p
 ## Phase 3: Integration and Validation
 
 ### 5. API Documentation and Testing
-- Use Task tool with subagent_type="api-documenter"
+- Use Task tool with subagent_type="documentation-generation::api-documenter"
 - Prompt: "Create comprehensive API documentation including:
   - Interactive OpenAPI/Swagger documentation
   - Platform-specific integration guides
@@ -125,7 +125,7 @@ Build and deploy the same feature consistently across web, mobile, and desktop p
 - Expected output: Complete API documentation portal, test results
 
 ### 6. Cross-Platform Testing and Feature Parity
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Validate feature parity across all platforms:
   - Functional testing matrix (features work identically)
   - UI consistency verification (follows design system)
@@ -140,7 +140,7 @@ Build and deploy the same feature consistently across web, mobile, and desktop p
 - Expected output: Test report, parity matrix, performance metrics
 
 ### 7. Platform-Specific Optimizations
-- Use Task tool with subagent_type="performance-optimizer"
+- Use Task tool with subagent_type="application-performance::performance-engineer"
 - Prompt: "Optimize each platform implementation:
   - Web: Bundle size, lazy loading, CDN setup, SEO
   - iOS: App size, launch time, memory usage, battery

plugins/security-scanning/commands/security-hardening.md

@@ -17,7 +17,7 @@ Implement comprehensive security hardening with defense-in-depth strategy throug
 - Context: Uses vulnerability scan results to inform threat priorities
 
 ### 3. Architecture Security Review
-- Use Task tool with subagent_type="backend-architect"
+- Use Task tool with subagent_type="backend-api-security::backend-architect"
 - Prompt: "Review architecture for security weaknesses in: $ARGUMENTS. Evaluate service boundaries, data flow security, authentication/authorization architecture, encryption implementation, network segmentation. Design zero-trust architecture patterns. Reference threat model and vulnerability findings."
 - Output: Security architecture assessment, zero-trust design recommendations, service mesh security requirements, data classification matrix
 - Context: Incorporates threat model to address architectural vulnerabilities
@@ -31,19 +31,19 @@ Implement comprehensive security hardening with defense-in-depth strategy throug
 - Context: Addresses high-priority items from vulnerability assessment
 
 ### 5. Backend Security Hardening
-- Use Task tool with subagent_type="backend-security-coder"
+- Use Task tool with subagent_type="backend-api-security::backend-security-coder"
 - Prompt: "Implement comprehensive backend security controls for: $ARGUMENTS. Add input validation with OWASP ESAPI, implement rate limiting and DDoS protection, secure API endpoints with OAuth2/JWT validation, add encryption for data at rest/transit using AES-256/TLS 1.3. Implement secure logging without PII exposure."
 - Output: Hardened API endpoints, validation middleware, encryption implementation, secure configuration templates
 - Context: Builds upon vulnerability fixes with preventive controls
 
 ### 6. Frontend Security Implementation
-- Use Task tool with subagent_type="frontend-security-coder"
+- Use Task tool with subagent_type="frontend-mobile-security::frontend-security-coder"
 - Prompt: "Implement frontend security measures for: $ARGUMENTS. Configure CSP headers with nonce-based policies, implement XSS prevention with DOMPurify, secure authentication flows with PKCE OAuth2, add SRI for external resources, implement secure cookie handling with SameSite/HttpOnly/Secure flags."
 - Output: Secure frontend components, CSP policy configuration, authentication flow implementation, security headers configuration
 - Context: Complements backend security with client-side protections
 
 ### 7. Mobile Security Hardening
-- Use Task tool with subagent_type="mobile-security-coder"
+- Use Task tool with subagent_type="frontend-mobile-security::mobile-security-coder"
 - Prompt: "Implement mobile app security for: $ARGUMENTS. Add certificate pinning, implement biometric authentication, secure local storage with encryption, obfuscate code with ProGuard/R8, implement anti-tampering and root/jailbreak detection, secure IPC communications."
 - Output: Hardened mobile application, security configuration files, obfuscation rules, certificate pinning implementation
 - Context: Extends security to mobile platforms if applicable
@@ -57,13 +57,13 @@ Implement comprehensive security hardening with defense-in-depth strategy throug
 - Context: Strengthens access controls based on architecture review
 
 ### 9. Infrastructure Security Controls
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
 - Prompt: "Deploy infrastructure security controls for: $ARGUMENTS. Configure WAF rules for OWASP protection, implement network segmentation with micro-segmentation, deploy IDS/IPS systems, configure cloud security groups and NACLs, implement DDoS protection with rate limiting and geo-blocking."
 - Output: WAF configuration, network security policies, IDS/IPS rules, cloud security configurations
 - Context: Implements network-level defenses
 
 ### 10. Secrets Management Implementation
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
 - Prompt: "Implement enterprise secrets management for: $ARGUMENTS. Deploy HashiCorp Vault or AWS Secrets Manager, implement secret rotation policies, remove hardcoded secrets, configure least-privilege IAM roles, implement encryption key management with HSM support."
 - Output: Secrets management configuration, rotation policies, IAM role definitions, key management procedures
 - Context: Eliminates secrets exposure vulnerabilities
@@ -83,7 +83,7 @@ Implement comprehensive security hardening with defense-in-depth strategy throug
 - Context: Ensures regulatory and industry standard compliance
 
 ### 13. Security Monitoring and SIEM Integration
-- Use Task tool with subagent_type="devops-troubleshooter"
+- Use Task tool with subagent_type="incident-response::devops-troubleshooter"
 - Prompt: "Implement security monitoring and SIEM for: $ARGUMENTS. Deploy Splunk/ELK/Sentinel integration, configure security event correlation, implement behavioral analytics for anomaly detection, set up automated incident response playbooks, create security dashboards and alerting."
 - Output: SIEM configuration, correlation rules, incident response playbooks, security dashboards, alert definitions
 - Context: Establishes continuous security monitoring

plugins/tdd-workflows/commands/tdd-cycle.md

@@ -18,13 +18,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 1: Test Specification and Design
 
 ### 1. Requirements Analysis
-- Use Task tool with subagent_type="architect-review"
+- Use Task tool with subagent_type="comprehensive-review::architect-review"
 - Prompt: "Analyze requirements for: $ARGUMENTS. Define acceptance criteria, identify edge cases, and create test scenarios. Output a comprehensive test specification."
 - Output: Test specification, acceptance criteria, edge case matrix
 - Validation: Ensure all requirements have corresponding test scenarios
 
 ### 2. Test Architecture Design
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Design test architecture for: $ARGUMENTS based on test specification. Define test structure, fixtures, mocks, and test data strategy. Ensure testability and maintainability."
 - Output: Test architecture, fixture design, mock strategy
 - Validation: Architecture supports isolated, fast, reliable tests
@@ -32,13 +32,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 2: RED - Write Failing Tests
 
 ### 3. Write Unit Tests (Failing)
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Write FAILING unit tests for: $ARGUMENTS. Tests must fail initially. Include edge cases, error scenarios, and happy paths. DO NOT implement production code."
 - Output: Failing unit tests, test documentation
 - **CRITICAL**: Verify all tests fail with expected error messages
 
 ### 4. Verify Test Failure
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="tdd-workflows::code-reviewer"
 - Prompt: "Verify that all tests for: $ARGUMENTS are failing correctly. Ensure failures are for the right reasons (missing implementation, not test errors). Confirm no false positives."
 - Output: Test failure verification report
 - **GATE**: Do not proceed until all tests fail appropriately
@@ -46,13 +46,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 3: GREEN - Make Tests Pass
 
 ### 5. Minimal Implementation
-- Use Task tool with subagent_type="backend-architect"
+- Use Task tool with subagent_type="backend-development::backend-architect"
 - Prompt: "Implement MINIMAL code to make tests pass for: $ARGUMENTS. Focus only on making tests green. Do not add extra features or optimizations. Keep it simple."
 - Output: Minimal working implementation
 - Constraint: No code beyond what's needed to pass tests
 
 ### 6. Verify Test Success
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Run all tests for: $ARGUMENTS and verify they pass. Check test coverage metrics. Ensure no tests were accidentally broken."
 - Output: Test execution report, coverage metrics
 - **GATE**: All tests must pass before proceeding
@@ -60,13 +60,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 4: REFACTOR - Improve Code Quality
 
 ### 7. Code Refactoring
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="tdd-workflows::code-reviewer"
 - Prompt: "Refactor implementation for: $ARGUMENTS while keeping tests green. Apply SOLID principles, remove duplication, improve naming, and optimize performance. Run tests after each refactoring."
 - Output: Refactored code, refactoring report
 - Constraint: Tests must remain green throughout
 
 ### 8. Test Refactoring
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Refactor tests for: $ARGUMENTS. Remove test duplication, improve test names, extract common fixtures, and enhance test readability. Ensure tests still provide same coverage."
 - Output: Refactored tests, improved test structure
 - Validation: Coverage metrics unchanged or improved
@@ -74,13 +74,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 5: Integration and System Tests
 
 ### 9. Write Integration Tests (Failing First)
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Write FAILING integration tests for: $ARGUMENTS. Test component interactions, API contracts, and data flow. Tests must fail initially."
 - Output: Failing integration tests
 - Validation: Tests fail due to missing integration logic
 
 ### 10. Implement Integration
-- Use Task tool with subagent_type="backend-architect"
+- Use Task tool with subagent_type="backend-development::backend-architect"
 - Prompt: "Implement integration code for: $ARGUMENTS to make integration tests pass. Focus on component interaction and data flow."
 - Output: Integration implementation
 - Validation: All integration tests pass
@@ -88,13 +88,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 6: Continuous Improvement Cycle
 
 ### 11. Performance and Edge Case Tests
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="unit-testing::test-automator"
 - Prompt: "Add performance tests and additional edge case tests for: $ARGUMENTS. Include stress tests, boundary tests, and error recovery tests."
 - Output: Extended test suite
 - Metric: Increased test coverage and scenario coverage
 
 ### 12. Final Code Review
-- Use Task tool with subagent_type="architect-review"
+- Use Task tool with subagent_type="comprehensive-review::architect-review"
 - Prompt: "Perform comprehensive review of: $ARGUMENTS. Verify TDD process was followed, check code quality, test quality, and coverage. Suggest improvements."
 - Output: Review report, improvement suggestions
 - Action: Implement critical suggestions while maintaining green tests

plugins/tdd-workflows/commands/tdd-green.md

@@ -4,7 +4,7 @@ Implement minimal code to make failing tests pass in TDD green phase:
 
 ## Implementation Process
 
-Use Task tool with subagent_type="test-automator" to implement minimal passing code.
+Use Task tool with subagent_type="unit-testing::test-automator" to implement minimal passing code.
 
 Prompt: "Implement MINIMAL code to make these failing tests pass: $ARGUMENTS. Follow TDD green phase principles:
 

plugins/tdd-workflows/commands/tdd-red.md

@@ -4,7 +4,7 @@ Write comprehensive failing tests following TDD red phase principles.
 
 ## Role
 
-Generate failing tests using Task tool with subagent_type="test-automator".
+Generate failing tests using Task tool with subagent_type="unit-testing::test-automator".
 
 ## Prompt Template