@ngxtm/devkit 3.18.0 → 3.20.0

package/merged-commands/fix/fast.md

@@ -11,9 +11,9 @@ Analyze the skills catalog and activate the skills that are needed for the task
 
 ## Workflow
 1. If the user provides a screenshots or videos, use `ai-multimodal` skill to describe as detailed as possible the issue, make sure developers can predict the root causes easily based on the description.
-2. Use `debugger` subagent to find the root cause of the issues and report back to main agent.
+2. Use a Task agent for debugging: Task(subagent_type="general-purpose", prompt="You are a debugger. Find the root cause of the issues and report back to main agent.", description="Debug issues") to find the root cause of the issues and report back to main agent.
 3. Activate `debugging` skills and `problem-solving` skills to tackle the issues.
 4. Start implementing the fix based the reports and solutions.
-5. Use `tester` agent to test the fix and make sure it works, then report back to main agent.
+5. Use a Task agent for testing: Task(subagent_type="general-purpose", prompt="You are a tester. Test the fix and make sure it works, then report back to main agent.", description="Test fix") to test the fix and make sure it works, then report back to main agent.
 6. If there are issues or failed tests, repeat from step 2.
 7. After finishing, respond back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.

package/merged-commands/fix/hard.md

@@ -1,9 +1,9 @@
 ---
-description: ⚡⚡⚡ Use subagents to plan and fix hard issues
+description: ⚡⚡⚡ Use Task agents to plan and fix hard issues
 argument-hint: [issues]
 ---
 
-**Ultrathink** to plan & start fixing these issues follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules: 
+**Ultrathink** to plan & start fixing these issues follow the Orchestration Protocol, Core Responsibilities, Task Agents Team and Development Rules: 
 <issues>$ARGUMENTS</issues>
 
 ## Workflow:
@@ -23,13 +23,13 @@ Use `sequential-thinking` skill to break complex problems into sequential though
 Use `problem-solving` skills to tackle the issues.
 Analyze the skills catalog and activate other skills that are needed for the task during the process.
 
-1. Use `debugger` subagent to find the root cause of the issues and report back to main agent.
-2. Use `researcher` subagent to research quickly about the root causes on the internet (if needed) and report back to main agent.
-3. Use `planner` subagent to create an implementation plan based on the reports, then report back to main agent.
+1. Use a Task agent for debugging: Task(subagent_type="general-purpose", prompt="You are a debugger. Find the root cause of the issues and report back to main agent.", description="Debug issues") to find the root cause of the issues and report back to main agent.
+2. Use a Task agent for research: Task(subagent_type="general-purpose", prompt="You are a researcher. Research quickly about the root causes on the internet (if needed) and report back to main agent.", description="Research root causes") to research quickly about the root causes on the internet (if needed) and report back to main agent.
+3. Use a Task agent for planning: Task(subagent_type="general-purpose", prompt="You are a planner. Create an implementation plan based on the reports, then report back to main agent.", description="Create fix plan") to create an implementation plan based on the reports, then report back to main agent.
 4. Then use `/code` SlashCommand to implement the plan step by step.
 5. Final Report:
   * Report back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.
-  * Ask the user if they want to commit and push to git repository, if yes, use `git-manager` subagent to commit and push to git repository.
+  * Ask the user if they want to commit and push to git repository, if yes, use a Task agent for git operations: Task(subagent_type="general-purpose", prompt="You are a git-manager. Commit and push to git repository.", description="Git commit and push") to commit and push to git repository.
   - **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
   - **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
 

package/merged-commands/fix/logs.md

@@ -14,13 +14,13 @@ argument-hint: [issue]
      - **Bash/Unix**: append `2>&1 | tee logs.txt`
      - **PowerShell**: append `*>&1 | Tee-Object logs.txt`
    - Run the command to generate logs
-2. Use `debugger` subagent to analyze `./logs.txt` and find root causes:
+2. Use a Task agent for debugging: Task(subagent_type="general-purpose", prompt="You are a debugger. Analyze ./logs.txt and find root causes.", description="Analyze logs") to analyze `./logs.txt` and find root causes:
    - Use `Grep` with `head_limit: 30` to read only last 30 lines (avoid loading entire file)
    - If insufficient context, increase `head_limit` as needed
-3. Use `scout` subagent to analyze the codebase and find the exact location of the issues, then report back to main agent.
-4. Use `planner` subagent to create an implementation plan based on the reports, then report back to main agent.
+3. Use a Task agent for scouting: Task(subagent_type="general-purpose", prompt="You are a scout. Analyze the codebase and find the exact location of the issues, then report back to main agent.", description="Scout codebase") to analyze the codebase and find the exact location of the issues, then report back to main agent.
+4. Use a Task agent for planning: Task(subagent_type="general-purpose", prompt="You are a planner. Create an implementation plan based on the reports, then report back to main agent.", description="Create fix plan") to create an implementation plan based on the reports, then report back to main agent.
 5. Start implementing the fix based the reports and solutions.
-6. Use `tester` agent to test the fix and make sure it works, then report back to main agent.
-7. Use `code-reviewer` subagent to quickly review the code changes and make sure it meets requirements, then report back to main agent.
+6. Use a Task agent for testing to test the fix and make sure it works, then report back to main agent.
+7. Use a Task agent for code review: Task(subagent_type="general-purpose", prompt="You are a code-reviewer. Quickly review the code changes and make sure it meets requirements, then report back to main agent.", description="Code review") to quickly review the code changes and make sure it meets requirements, then report back to main agent.
 8. If there are issues or failed tests, repeat from step 3.
 9. After finishing, respond back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.

package/merged-commands/fix/parallel.md

@@ -10,7 +10,7 @@ argument-hint: [issues]
 ## Workflow
 
 ### 1. Issue Analysis
-- Use `debugger` subagent to analyze root causes
+- Use a Task agent for debugging: Task(subagent_type="general-purpose", prompt="You are a debugger. Analyze root causes.", description="Analyze root causes") to analyze root causes
 - Use `/scout:ext` to find related files
 - Categorize issues by scope/area (frontend, backend, auth, payments, etc.)
 - Identify dependencies between issues
@@ -23,32 +23,32 @@ argument-hint: [issues]
 
 ### 3. Parallel Fix Implementation
 - Read `plan.md` for dependency graph
-- Launch multiple `fullstack-developer` agents in PARALLEL for independent fixes
-  - Example: "Fix auth + Fix payments + Fix UI" → launch 3 agents simultaneously
+- Launch multiple Task agents for fullstack development in PARALLEL for independent fixes
+  - Example: "Fix auth + Fix payments + Fix UI" → launch 3 Task agents simultaneously
   - Pass phase file path: `{plan-dir}/phase-XX-*.md`
   - Include environment info
 - Wait for all parallel fixes complete before dependent fixes
 - Sequential fixes: launch one agent at a time
 
 ### 4. Testing
-- Use `tester` subagent for full test suite
+- Use a Task agent for testing for full test suite
 - NO fake data/mocks/cheats
 - Verify all issues resolved
-- If fail: use `debugger`, fix, repeat
+- If fail: use Task agent for debugging, fix, repeat
 
 ### 5. Code Review
-- Use `code-reviewer` for all changes
+- Use Task agent for code review for all changes
 - Verify fixes don't introduce regressions
 - If critical issues: fix, retest
 
 ### 6. Project Management & Docs
-- If approved: use `project-manager` + `docs-manager` in parallel
+- If approved: use Task agent for project management + Task agent for documentation in parallel
 - Update plan files, docs, roadmap
 - If rejected: fix and repeat
 
 ### 7. Final Report
 - Summary of all fixes from parallel phases
 - Verification status per issue
-- Ask to commit (use `git-manager` if yes)
+- Ask to commit (use Task agent for git operations if yes)
 
-**Example:** Fix 1 (auth) + Fix 2 (payments) + Fix 3 (UI) → Launch 3 fullstack-developer agents → Wait → Fix 4 (integration) sequential
+**Example:** Fix 1 (auth) + Fix 2 (payments) + Fix 3 (UI) → Launch 3 Task agents for fullstack development → Wait → Fix 4 (integration) sequential

package/merged-commands/fix/test.md

@@ -9,12 +9,12 @@ Analyze the skills catalog and activate the skills that are needed for the task
 <issues>$ARGUMENTS</issues>
 
 ## Workflow:
-1. Use `tester` subagent to compile the code and fix all syntax errors if any.
-2. Use `tester` subagent to run the tests and report back to main agent.
-3. If there are issues or failed tests, use `debugger` subagent to find the root cause of the issues, then report back to main agent.
-4. Use `planner` subagent to create an implementation plan based on the reports, then report back to main agent.
+1. Use a Task agent for testing: Task(subagent_type="general-purpose", prompt="You are a tester. Compile the code and fix all syntax errors if any.", description="Compile code") to compile the code and fix all syntax errors if any.
+2. Use a Task agent for testing: Task(subagent_type="general-purpose", prompt="You are a tester. Run the tests and report back to main agent.", description="Run tests") to run the tests and report back to main agent.
+3. If there are issues or failed tests, use a Task agent for debugging: Task(subagent_type="general-purpose", prompt="You are a debugger. Find the root cause of the issues, then report back to main agent.", description="Debug failures") to find the root cause of the issues, then report back to main agent.
+4. Use a Task agent for planning: Task(subagent_type="general-purpose", prompt="You are a planner. Create an implementation plan based on the reports, then report back to main agent.", description="Create fix plan") to create an implementation plan based on the reports, then report back to main agent.
 5. Use main agent to implement the plan step by step.
-6. Use `tester` agent to test the fix and make sure it works, then report back to main agent.
-6. Use `code-reviewer` subagent to quickly review the code changes and make sure it meets requirements, then report back to main agent.
+6. Use a Task agent for testing: Task(subagent_type="general-purpose", prompt="You are a tester. Test the fix and make sure it works, then report back to main agent.", description="Test fix") to test the fix and make sure it works, then report back to main agent.
+6. Use a Task agent for code review: Task(subagent_type="general-purpose", prompt="You are a code-reviewer. Quickly review the code changes and make sure it meets requirements, then report back to main agent.", description="Code review") to quickly review the code changes and make sure it meets requirements, then report back to main agent.
 7. If there are issues or failed tests, repeat from step 2.
 8. After finishing, respond back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.

package/merged-commands/fix/ui.md

@@ -8,7 +8,7 @@ argument-hint: [issue]
 2. **`aesthetic`** - Design principles
 3. **`frontend-design`** - Implementation patterns
 
-Use `ui-ux-designer` subagent to read and analyze `./docs/design-guidelines.md` then fix the following issues:
+Use a Task agent for UI/UX design: Task(subagent_type="general-purpose", prompt="You are a ui-ux-designer. Read and analyze ./docs/design-guidelines.md then fix the following issues.", description="Fix UI issues") to read and analyze `./docs/design-guidelines.md` then fix the following issues:
 <issue>$ARGUMENTS</issue>
 
 ## Workflow
@@ -22,22 +22,22 @@ python3 .claude/skills/ui-ux-pro-max/scripts/search.py "z-index animation" --dom
 
 If the user provides a screenshots or videos, use `ai-multimodal` skill to describe as detailed as possible the issue, make sure developers can predict the root causes easily based on the description.
 
-1. Use `ui-ux-designer` subagent to implement the fix step by step.
+1. Use a Task agent for UI/UX design: Task(subagent_type="general-purpose", prompt="You are a ui-ux-designer. Implement the fix step by step.", description="Implement UI fix") to implement the fix step by step.
 2. Use screenshot capture tools along with `ai-multimodal` skill to take screenshots of the implemented fix (at the exact parent container, don't take screenshot of the whole page) and use the appropriate Gemini analysis skills (`ai-multimodal`, `video-analysis`, or `document-extraction`) to analyze those outputs so the result matches the design guideline and addresses all issues.
   - If the issues are not addressed, repeat the process until all issues are addressed.
 3. Use `chrome-devtools` skill to analyze the implemented fix and make sure it matches the design guideline.
-4. Use `tester` agent to test the fix and compile the code to make sure it works, then report back to main agent.
+4. Use a Task agent for testing to test the fix and compile the code to make sure it works, then report back to main agent.
   - If there are issues or failed tests, ask main agent to fix all of them and repeat the process until all tests pass.
 5. Project Management & Documentation:
-  **If user approves the changes:** Use `project-manager` and `docs-manager` subagents in parallel to update the project progress and documentation:
-    * Use `project-manager` subagent to update the project progress and task status in the given plan file.
-    * Use `docs-manager` subagent to update the docs in `./docs` directory if needed.
-    * Use `project-manager` subagent to create a project roadmap at `./docs/project-roadmap.md` file.
+  **If user approves the changes:** Use Task agents for project management and documentation in parallel to update the project progress and documentation:
+    * Use a Task agent for project management: Task(subagent_type="general-purpose", prompt="You are a project-manager. Update the project progress and task status in the given plan file.", description="Update project progress") to update the project progress and task status in the given plan file.
+    * Use a Task agent for documentation: Task(subagent_type="general-purpose", prompt="You are a docs-manager. Update the docs in ./docs directory if needed.", description="Update docs") to update the docs in `./docs` directory if needed.
+    * Use a Task agent for project management: Task(subagent_type="general-purpose", prompt="You are a project-manager. Create a project roadmap at ./docs/project-roadmap.md file.", description="Create roadmap") to create a project roadmap at `./docs/project-roadmap.md` file.
     * **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
   **If user rejects the changes:** Ask user to explain the issues and ask main agent to fix all of them and repeat the process.
 6. Final Report:
   * Report back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.
-  * Ask the user if they want to commit and push to git repository, if yes, use `git-manager` subagent to commit and push to git repository.
+  * Ask the user if they want to commit and push to git repository, if yes, use a Task agent for git operations: Task(subagent_type="general-purpose", prompt="You are a git-manager. Commit and push to git repository.", description="Git commit and push") to commit and push to git repository.
   * **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
   * **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
 

package/merged-commands/fixing.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/merged-commands/framework-migration-legacy-modernize.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/merged-commands/full-stack-orchestration-full-stack-feature.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/merged-commands/git/cm.md

@@ -1,7 +1,7 @@
 ---
 description: Stage all files and create a commit.
 ---
-Use `git-manager` subagent to: 
+Use Task agent for git management: Task(subagent_type="general-purpose", prompt="You are a git-manager. Analyze changes, categorize commits, stage and commit...", description="Git commit") to:
 - Analyze changes with `git status` and `git diff --stat`
 - Categorize changes into multiple commits
 - Stage files and create commits based on the changes made

package/merged-commands/git/cp.md

@@ -1,7 +1,7 @@
 ---
 description: Stage, commit and push all code in the current branch
 ---
-Use `git-manager` subagent to: 
+Use Task agent for git management: Task(subagent_type="general-purpose", prompt="You are a git-manager. Analyze changes, categorize commits, stage, commit, and push...", description="Git commit and push") to:
 - Analyze changes with `git status` and `git diff --stat`
 - Categorize changes into multiple commits
 - Stage files and create commits based on the changes made

package/merged-commands/git/merge.md

@@ -10,7 +10,7 @@ FROM_BRANCH: $2 (defaults to current branch)
 
 ## Workflow
 
-Use `git-manager` subagent to execute the merge workflow:
+Use Task agent for git management to execute the merge workflow: Task(subagent_type="general-purpose", prompt="You are a git-manager. Execute merge workflow...", description="Git merge")
 
 ### Step 1: Sync with remote (CRITICAL)
 ```bash

package/merged-commands/git/pr.md

@@ -10,7 +10,7 @@ FROM_BRANCH: $2 (defaults to current branch)
 
 ## Workflow
 
-Use `git-manager` subagent to execute the PR workflow:
+Use Task agent for git management to execute the PR workflow: Task(subagent_type="general-purpose", prompt="You are a git-manager. Execute PR workflow...", description="Create pull request")
 
 ### Step 1: Ensure remote is synced
 ```bash

package/merged-commands/git-pr-workflows-git-workflow.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/merged-commands/google-adk-python.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/merged-commands/hr-pro.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.