@ngxtm/devkit 3.19.0 → 3.21.0

package/skills/data-engineering-data-driven-feature/SKILL.md

@@ -31,18 +31,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="machine-learning-ops::data-scientist"
+- Use Task tool with subagent_type="general-purpose"
 - 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-analytics::business-analyst"
+- Use Task tool with subagent_type="general-purpose"
 - 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="machine-learning-ops::data-scientist"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -50,19 +50,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="data-engineering::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - 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-engineering::data-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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-engineering::data-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -70,19 +70,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-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - 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-mobile-development::frontend-developer"
+- Use Task tool with subagent_type="general-purpose"
 - 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="machine-learning-ops::ml-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -90,13 +90,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-engineering::data-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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="cloud-infrastructure::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -104,13 +104,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="cloud-infrastructure::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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-monitoring::observability-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -118,19 +118,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="machine-learning-ops::data-scientist"
+- Use Task tool with subagent_type="general-purpose"
 - 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-analytics::business-analyst"
+- Use Task tool with subagent_type="general-purpose"
 - 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="machine-learning-ops::data-scientist"
+- Use Task tool with subagent_type="general-purpose"
 - 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

package/skills/debugging-toolkit-smart-debug/SKILL.md

@@ -39,7 +39,7 @@ Parse for:
 ## Workflow
 
 ### 1. Initial Triage
-Use Task tool (subagent_type="debugger") for AI-powered analysis:
+Use Task tool (subagent_type="general-purpose") for AI-powered analysis:
 - Error pattern recognition
 - Stack trace analysis with probable causes
 - Component dependency analysis

package/skills/doc-coauthoring/SKILL.md

@@ -250,7 +250,7 @@ Explain that testing will now occur to see if the document actually works for re
 
 ### Testing Approach
 
-**If access to sub-agents is available (e.g., in Claude Code):**
+**If access to Task agents is available (e.g., in Claude Code):**
 
 Perform the testing directly without user involvement.
 
@@ -260,11 +260,11 @@ Announce intention to predict what questions readers might ask when trying to di
 
 Generate 5-10 questions that readers would realistically ask.
 
-### Step 2: Test with Sub-Agent
+### Step 2: Test with Task Agent
 
 Announce that these questions will be tested with a fresh Claude instance (no context from this conversation).
 
-For each question, invoke a sub-agent with just the document content and the question.
+For each question, invoke a Task agent with just the document content and the question.
 
 Summarize what Reader Claude got right/wrong for each question.
 
@@ -272,7 +272,7 @@ Summarize what Reader Claude got right/wrong for each question.
 
 Announce additional checks will be performed.
 
-Invoke sub-agent to check for ambiguity, false assumptions, contradictions.
+Invoke Task agent to check for ambiguity, false assumptions, contradictions.
 
 Summarize any issues found.
 
@@ -289,7 +289,7 @@ Loop back to refinement for problematic sections.
 
 ---
 
-**If no access to sub-agents (e.g., claude.ai web interface):**
+**If no access to Task agents (e.g., claude.ai web interface):**
 
 The user will need to do the testing manually.
 

package/skills/docker-expert/SKILL.md

@@ -21,7 +21,7 @@ You are an advanced Docker containerization expert with comprehensive, practical
    - Database containerization with complex persistence → database-expert
 
    Example to output:
-   "This requires Kubernetes orchestration expertise. Please invoke: 'Use the kubernetes-expert subagent.' Stopping here."
+   "This requires Kubernetes orchestration expertise. Please invoke: 'Use the kubernetes-expert Task agent.' Stopping here."
 
 1. Analyze container setup comprehensively:
    

package/skills/error-debugging-multi-agent-review/SKILL.md

@@ -59,7 +59,7 @@ The Multi-Agent Review Tool leverages a distributed, specialized agent network t
 - **Dynamic Agent Matching**:
   - Analyze input characteristics
   - Select most appropriate agent types
-  - Configure specialized sub-agents dynamically
+  - Configure specialized Task agents dynamically
 - **Expertise Routing**:
   ```python
   def route_agents(code_context):

package/skills/error-diagnostics-smart-debug/SKILL.md

@@ -39,7 +39,7 @@ Parse for:
 ## Workflow
 
 ### 1. Initial Triage
-Use Task tool (subagent_type="debugger") for AI-powered analysis:
+Use Task tool (subagent_type="general-purpose") for AI-powered analysis:
 - Error pattern recognition
 - Stack trace analysis with probable causes
 - Component dependency analysis

package/skills/finishing-a-development-branch/SKILL.md

@@ -195,7 +195,7 @@ git worktree remove <worktree-path>
 ## Integration
 
 **Called by:**
-- **subagent-driven-development** (Step 7) - After all tasks complete
+- **Task agent-driven-development** (Step 7) - After all tasks complete
 - **executing-plans** (Step 5) - After all batches complete
 
 **Pairs with:**

package/skills/fixing/SKILL.md

@@ -31,13 +31,13 @@ Classify before routing. See `references/complexity-assessment.md`.
 | **Complex** | System-wide, architecture impact | `references/workflow-deep.md` |
 | **Parallel** | 2+ independent issues | Parallel `fullstack-developer` agents |
 
-## Skill/Subagent Activation Matrix
+## Skill/Task Agent Activation Matrix
 
 See `references/skill-activation-matrix.md` for complete matrix.
 
 **Always activate:** `debugging` (all workflows)
 **Conditional:** `problem-solving`, `sequential-thinking`, `brainstorming`, `context-engineering`
-**Subagents:** `debugger`, `researcher`, `planner`, `code-reviewer`, `tester`, `Bash`
+**Task agents:** `debugger`, `researcher`, `planner`, `code-reviewer`, `tester`, `Bash`
 **Parallel:** Multiple `Explore` agents for scouting, `Bash` agents for verification
 
 ## Output Format
@@ -62,7 +62,7 @@ Load as needed:
 - `references/workflow-deep.md` - Deep: research + brainstorm + plan
 - `references/review-cycle.md` - Review logic (autonomous vs HITL)
 - `references/skill-activation-matrix.md` - When to activate each skill
-- `references/parallel-exploration.md` - Parallel Explore/Bash subagents patterns
+- `references/parallel-exploration.md` - Parallel Explore/Bash Task agent patterns
 
 **Specialized Workflows:**
 - `references/workflow-ci.md` - GitHub Actions/CI failures

package/skills/fixing/references/parallel-exploration.md

@@ -1,10 +1,10 @@
 # Parallel Exploration
 
-Patterns for launching multiple subagents in parallel to scout codebase and verify implementation.
+Patterns for launching multiple Task agents in parallel to scout codebase and verify implementation.
 
 ## Parallel Exploration (Scouting)
 
-Launch multiple `Explore` subagents simultaneously when needing to find:
+Launch multiple `Explore` Task agents simultaneously when needing to find:
 - Related files across different areas
 - Similar implementations/patterns
 - Dependencies and usage
@@ -26,7 +26,7 @@ Task("Explore", "Find test files for auth module", "Scout tests")
 
 ## Parallel Verification (Bash)
 
-Launch multiple `Bash` subagents to verify implementation from different angles.
+Launch multiple `Bash` Task agents to verify implementation from different angles.
 
 **Pattern:**
 ```
@@ -73,5 +73,5 @@ Task("Bash", "Run build", "Verify build")
 ## Resource Limits
 
 - Max 3 parallel agents recommended (system resources)
-- Each subagent has 200K token context limit
+- Each Task agent has 200K token context limit
 - Keep prompts concise to avoid context bloat

package/skills/fixing/references/skill-activation-matrix.md

@@ -18,9 +18,9 @@ When to activate each skill during fixing workflows.
 | `context-engineering` | Fixing AI/LLM/agent code, context window issues |
 | `ai-multimodal` | UI issues, screenshots provided, visual bugs |
 
-## Subagent Usage
+## Task Agent Usage
 
-| Subagent | Activate When |
+| Task Agent | Activate When |
 |----------|---------------|
 | `debugger` | Root cause unclear, need deep investigation |
 | `Explore` (parallel) | Scout multiple areas simultaneously |
@@ -61,5 +61,5 @@ See `references/parallel-exploration.md` for detailed patterns.
 | "stuck", "tried everything" | `problem-solving` |
 | "complex", "multi-step" | `sequential-thinking` |
 | "which approach", "options" | `brainstorming` |
-| "latest docs", "best practice" | `researcher` subagent |
+| "latest docs", "best practice" | `researcher` Task agent |
 | Screenshot attached | `ai-multimodal` |

package/skills/fixing/references/workflow-deep.md

@@ -5,7 +5,7 @@ Full pipeline with research, brainstorming, and planning for complex issues.
 ## Steps
 
 ### Step 1: Debug & Parallel Investigation
-Activate `debugging` skill. Launch 2-3 `Explore` subagents in parallel:
+Activate `debugging` skill. Launch 2-3 `Explore` Task agents in parallel:
 ```
 Task("Explore", "Find error origin", "Trace error")
 Task("Explore", "Find affected components", "Map deps")
@@ -16,7 +16,7 @@ See `references/parallel-exploration.md` for patterns.
 **Output:** `✓ Step 1: Root cause - [summary], system impact: [scope]`
 
 ### Step 2: Research
-Use `researcher` subagent for external knowledge.
+Use `researcher` Task agent for external knowledge.
 
 - Search latest docs, best practices
 - Find similar issues/solutions
@@ -34,7 +34,7 @@ Activate `brainstorming` skill.
 **Output:** `✓ Step 3: Approach selected - [chosen approach]`
 
 ### Step 4: Plan
-Use `planner` subagent to create implementation plan.
+Use `planner` Task agent to create implementation plan.
 
 - Break down into phases
 - Identify dependencies
@@ -51,7 +51,7 @@ See `references/parallel-exploration.md`
 **Output:** `✓ Step 5: Implemented - [N] files, [M] phases, verified`
 
 ### Step 6: Test
-Use `tester` subagent.
+Use `tester` Task agent.
 
 - Comprehensive testing
 - Edge cases, security, performance
@@ -60,24 +60,24 @@ Use `tester` subagent.
 **Output:** `✓ Step 6: Tests [X/X passed]`
 
 ### Step 7: Review
-Use `code-reviewer` subagent.
+Use `code-reviewer` Task agent.
 
 See `references/review-cycle.md` for mode-specific handling.
 
 **Output:** `✓ Step 7: Review [score]/10 - [status]`
 
 ### Step 8: Finalize
-- Use `project-manager` subagent to update roadmap
-- Use `docs-manager` subagent for documentation
-- Use `git-manager` subagent for commit
+- Use `project-manager` Task agent to update roadmap
+- Use `docs-manager` Task agent for documentation
+- Use `git-manager` Task agent for commit
 
 **Output:** `✓ Step 8: Complete - [actions taken]`
 
-## Skills/Subagents Activated
+## Skills/Task agents Activated
 
-| Step | Skills/Subagents |
+| Step | Skills/Task agents |
 |------|------------------|
-| 1 | `debugging`, parallel `Explore` subagents for investigation |
+| 1 | `debugging`, parallel `Explore` Task agents for investigation |
 | 2 | `researcher` |
 | 3 | `brainstorming` |
 | 4 | `planner` |

package/skills/fixing/references/workflow-quick.md

@@ -29,7 +29,7 @@ See `references/parallel-exploration.md` for patterns.
 **Output:** `✓ Step 2: Fixed - [N] files, verified (types/lint passed)`
 
 ### Step 3: Verify
-Use `code-reviewer` subagent for quick review.
+Use `code-reviewer` Task agent for quick review.
 
 Prompt: "Quick review of fix for [issue]. Check: correctness, security, no regressions. Score X/10."
 
@@ -40,16 +40,16 @@ Prompt: "Quick review of fix for [issue]. Check: correctness, security, no regre
 ### Step 4: Complete
 Report summary to user.
 
-**If autonomous mode:** Ask to commit via `git-manager` subagent if score >= 9.0
+**If autonomous mode:** Ask to commit via `git-manager` Task agent if score >= 9.0
 **If HITL mode:** Ask user next action
 
 **Output:** `✓ Step 4: Complete - [action]`
 
-## Skills/Subagents Activated
+## Skills/Task agents Activated
 
 - `debugging` - Always (Step 1)
 - Parallel `git-manager` - Verification (Step 2)
-- `code-reviewer` subagent - Always (Step 3)
+- `code-reviewer` Task agent - Always (Step 3)
 - `context-engineering` - If dealing with AI/LLM code
 
 ## Notes

package/skills/fixing/references/workflow-standard.md

@@ -5,7 +5,7 @@ Full pipeline for moderate complexity issues.
 ## Steps
 
 ### Step 1: Debug & Investigate
-Activate `debugging` skill. Use `debugger` subagent if needed.
+Activate `debugging` skill. Use `debugger` Task agent if needed.
 
 - Read error messages, logs, stack traces
 - Reproduce the issue
@@ -15,7 +15,7 @@ Activate `debugging` skill. Use `debugger` subagent if needed.
 **Output:** `✓ Step 1: Root cause - [summary], [N] files affected`
 
 ### Step 2: Parallel Scout (if needed)
-Launch multiple `Explore` subagents in parallel to scout codebase.
+Launch multiple `Explore` Task agents in parallel to scout codebase.
 
 **Pattern:** In SINGLE message, launch 2-3 Explore agents:
 ```
@@ -48,7 +48,7 @@ Task("Bash", "Run build", "Verify build")
 **Output:** `✓ Step 3: Implemented - [N] files, verified (types/lint/build passed)`
 
 ### Step 4: Test
-Use `tester` subagent to run tests.
+Use `tester` Task agent to run tests.
 
 - Write new tests if needed
 - Run existing test suite
@@ -57,7 +57,7 @@ Use `tester` subagent to run tests.
 **Output:** `✓ Step 4: Tests [X/X passed]`
 
 ### Step 5: Review
-Use `code-reviewer` subagent.
+Use `code-reviewer` Task agent.
 
 See `references/review-cycle.md` for mode-specific handling.
 
@@ -65,21 +65,21 @@ See `references/review-cycle.md` for mode-specific handling.
 
 ### Step 6: Finalize
 - Report summary to user
-- Ask to commit via `git-manager` subagent
+- Ask to commit via `git-manager` Task agent
 - Update docs if needed via `docs-manager`
 
 **Output:** `✓ Step 6: Complete - [action]`
 
-## Skills/Subagents Activated
+## Skills/Task agents Activated
 
-| Step | Skills/Subagents |
+| Step | Skills/Task agents |
 |------|------------------|
-| 1 | `debugging`, `debugger` subagent |
-| 2 | Multiple `Explore` subagents in parallel (optional) |
+| 1 | `debugging`, `debugger` Task agent |
+| 2 | Multiple `Explore` Task agents in parallel (optional) |
 | 3 | `problem-solving`, `sequential-thinking`, parallel `Bash` for verification |
-| 4 | `tester` subagent |
-| 5 | `code-reviewer` subagent |
-| 6 | `git-manager`, `docs-manager` subagents |
+| 4 | `tester` Task agent |
+| 5 | `code-reviewer` Task agent |
+| 6 | `git-manager`, `docs-manager` Task agents |
 
 **Rules:** Don't skip steps. Validate before proceeding. One phase at a time.
 **Frontend:** Use `chrome`, `chrome-devtools` or any relevant skills/tools to verify. 

package/skills/framework-migration-legacy-modernize/SKILL.md

@@ -31,18 +31,18 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 1: Legacy Assessment and Risk Analysis
 
 ### 1. Comprehensive Legacy System Analysis
-- Use Task tool with subagent_type="legacy-modernizer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze the legacy codebase at $ARGUMENTS. Document technical debt inventory including: outdated dependencies, deprecated APIs, security vulnerabilities, performance bottlenecks, and architectural anti-patterns. Generate a modernization readiness report with component complexity scores (1-10), dependency mapping, and database coupling analysis. Identify quick wins vs complex refactoring targets."
 - Expected output: Detailed assessment report with risk matrix and modernization priorities
 
 ### 2. Dependency and Integration Mapping
-- Use Task tool with subagent_type="architect-review"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Based on the legacy assessment report, create a comprehensive dependency graph showing: internal module dependencies, external service integrations, shared database schemas, and cross-system data flows. Identify integration points that will require facade patterns or adapter layers during migration. Highlight circular dependencies and tight coupling that need resolution."
 - Context from previous: Legacy assessment report, component complexity scores
 - Expected output: Visual dependency map and integration point catalog
 
 ### 3. Business Impact and Risk Assessment
-- Use Task tool with subagent_type="business-analytics::business-analyst"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -50,18 +50,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="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - 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="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - 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-engineering::data-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -69,18 +69,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-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - 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-development::python-pro" or "golang-pro" (based on target stack)
+- Use Task tool with subagent_type="general-purpose"
 - 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-scanning::security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -88,13 +88,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="application-performance::performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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-strategies::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -102,13 +102,13 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 5: Migration Completion and Documentation
 
 ### 1. Legacy Component Decommissioning
-- Use Task tool with subagent_type="legacy-modernizer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Plan safe decommissioning of replaced legacy components. Verify no remaining dependencies through traffic analysis (minimum 30 days at 0% traffic). Archive legacy code with documentation of original functionality. Update CI/CD pipelines to remove legacy builds. Clean up unused database tables and remove deprecated API endpoints. Document any retained legacy components with sunset timeline."
 - Context from previous: Traffic routing data, modernization status
 - Expected output: Decommissioning checklist and timeline
 
 ### 2. Documentation and Knowledge Transfer
-- Use Task tool with subagent_type="documentation-generation::docs-architect"
+- Use Task tool with subagent_type="general-purpose"
 - 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