@ngxtm/devkit 3.18.0 → 3.20.0

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

package/skills/full-stack-orchestration-full-stack-feature/SKILL.md

@@ -29,19 +29,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-design::database-architect"
+- Use Task tool with subagent_type="general-purpose"
 - 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-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - 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-mobile-development::frontend-developer"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -49,19 +49,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-development::python-pro" (or "golang-pro"/"nodejs-expert" based on stack)
+- Use Task tool with subagent_type="general-purpose"
 - 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-mobile-development::frontend-developer"
+- Use Task tool with subagent_type="general-purpose"
 - 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="database-design::sql-pro"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -69,19 +69,19 @@ Orchestrate full-stack feature development across backend, frontend, and infrast
 ## Phase 3: Integration & Testing
 
 ### 7. API Contract Testing
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Create contract tests for: $ARGUMENTS. Implement Pact/Dredd tests to validate API contracts between backend and frontend. Create integration tests for all API endpoints, test authentication flows, validate error responses, and ensure proper CORS configuration. Include load testing scenarios."
 - Expected output: Contract test suites, integration tests, load test scenarios, API documentation validation
 - Context: API implementations from Phase 2
 
 ### 8. End-to-End Testing
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement E2E tests for: $ARGUMENTS. Create Playwright/Cypress tests covering critical user journeys, cross-browser compatibility, mobile responsiveness, and error scenarios. Test feature flags integration, analytics tracking, and performance metrics. Include visual regression tests."
 - Expected output: E2E test suites, visual regression baselines, performance benchmarks, test reports
 - Context: Frontend and backend implementations from Phase 2
 
 ### 9. Security Audit & Hardening
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Perform security audit for: $ARGUMENTS. Review API security (authentication, authorization, rate limiting), check for OWASP Top 10 vulnerabilities, audit frontend for XSS/CSRF risks, validate input sanitization, and review secrets management. Provide penetration testing results and remediation steps."
 - Expected output: Security audit report, vulnerability assessment, remediation recommendations, security headers configuration
 - Context: All implementations from Phase 2
@@ -89,19 +89,19 @@ Orchestrate full-stack feature development across backend, frontend, and infrast
 ## Phase 4: Deployment & Operations
 
 ### 10. Infrastructure & CI/CD Setup
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Setup deployment infrastructure for: $ARGUMENTS. Create Docker containers, Kubernetes manifests (or cloud-specific configs), implement CI/CD pipelines with automated testing gates, setup feature flags (LaunchDarkly/Unleash), and configure monitoring/alerting. Include blue-green deployment strategy and rollback procedures."
 - Expected output: Dockerfiles, K8s manifests, CI/CD pipeline configs, feature flag setup, IaC templates (Terraform/CloudFormation)
 - Context: All implementations and tests from previous phases
 
 ### 11. Observability & Monitoring
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement observability stack for: $ARGUMENTS. Setup distributed tracing (OpenTelemetry), configure application metrics (Prometheus/DataDog), implement centralized logging (ELK/Splunk), create dashboards for key metrics, and define SLIs/SLOs. Include alerting rules and on-call procedures."
 - Expected output: Observability configuration, dashboard definitions, alert rules, runbooks, SLI/SLO definitions
 - Context: Infrastructure setup from step 10
 
 ### 12. Performance Optimization
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Optimize performance across stack for: $ARGUMENTS. Analyze and optimize database queries, implement caching strategies (Redis/CDN), optimize frontend bundle size and loading performance, setup lazy loading and code splitting, and tune backend service performance. Include before/after metrics."
 - Expected output: Performance improvements, caching configuration, CDN setup, optimized bundles, performance metrics report
 - Context: Monitoring data from step 11, load test results

package/skills/git-pr-workflows-git-workflow/SKILL.md

@@ -44,12 +44,12 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 1: Pre-Commit Review and Analysis
 
 ### 1. Code Quality Assessment
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Review all uncommitted changes for code quality issues. Check for: 1) Code style violations, 2) Security vulnerabilities, 3) Performance concerns, 4) Missing error handling, 5) Incomplete implementations. Generate a detailed report with severity levels (critical/high/medium/low) and provide specific line-by-line feedback. Output format: JSON with {issues: [], summary: {critical: 0, high: 0, medium: 0, low: 0}, recommendations: []}"
 - Expected output: Structured code review report for next phase
 
 ### 2. Dependency and Breaking Change Analysis
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze the changes for: 1) New dependencies or version changes, 2) Breaking API changes, 3) Database schema modifications, 4) Configuration changes, 5) Backward compatibility issues. Context from previous review: [insert issues summary]. Identify any changes that require migration scripts or documentation updates."
 - Context from previous: Code quality issues that might indicate breaking changes
 - Expected output: Breaking change assessment and migration requirements
@@ -57,13 +57,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="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - 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="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -71,13 +71,13 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 3: Commit Message Generation
 
 ### 1. Change Analysis and Categorization
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze all changes and categorize them according to Conventional Commits specification. Identify the primary change type (feat/fix/docs/style/refactor/perf/test/build/ci/chore/revert) and scope. For changes: [insert file list and summary], determine if this should be a single commit or multiple atomic commits. Consider test results: [insert test summary]."
 - Context from previous: Test results, code review summary
 - Expected output: Commit structure recommendation
 
 ### 2. Conventional Commit Message Creation
-- Use Task tool with subagent_type="llm-application-dev::prompt-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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)
@@ -85,12 +85,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="cicd-automation::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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="cicd-automation::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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
@@ -98,13 +98,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="documentation-generation::docs-architect"
+- Use Task tool with subagent_type="general-purpose"
 - 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="cicd-automation::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - 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

package/skills/google-adk-python/SKILL.md

@@ -25,7 +25,7 @@ Use this skill when users need to:
 
 **LlmAgent**: LLM-powered agents capable of dynamic routing and adaptive behavior
 - Define with name, model, instruction, description, and tools
-- Supports sub-agents for delegation and coordination
+- Supports Task agents for delegation and coordination
 - Intelligent decision-making based on context
 
 **Workflow Agents**: Structured, predictable orchestration patterns

package/skills/hr-pro/SKILL.md

@@ -27,7 +27,7 @@ source: community
 - Provide actionable steps and verification.
 - If detailed examples are required, open `resources/implementation-playbook.md`.
 
-You are **HR-Pro**, a professional, employee-centered and compliance-aware Human Resources subagent for Claude Code.
+You are **HR-Pro**, a professional, employee-centered and compliance-aware Human Resources Task agent for Claude Code.
 
 ## IMPORTANT LEGAL DISCLAIMER
 - **NOT LEGAL ADVICE.** HR-Pro provides general HR information and templates only and does not create an attorney–client relationship.