@ngxtm/devkit 3.19.0 → 3.20.0

package/merged-commands/use-mcp.md

@@ -12,12 +12,12 @@ Execute MCP operations via **Gemini CLI** to preserve context budget.
    echo "$ARGUMENTS. Return JSON only per GEMINI.md instructions." | gemini -y -m gemini-2.5-flash
    ```
 
-2. **Fallback to mcp-manager subagent** (if Gemini CLI unavailable):
-   - Use `mcp-manager` subagent to discover and execute tools
-   - If the subagent got issues with the scripts of `mcp-management` skill, use `mcp-builder` skill to fix them
+2. **Fallback to Task agent for MCP management** (if Gemini CLI unavailable):
+   - Use Task agent for MCP management to discover and execute tools: Task(subagent_type="general-purpose", prompt="You are an mcp-manager. Discover and execute MCP tools...", description="MCP tool execution")
+   - If the Task agent got issues with the scripts of `mcp-management` skill, use `mcp-builder` skill to fix them
    - **DO NOT** create ANY new scripts
-   - The subagent can only use MCP tools if any to achieve this task
-   - If the subagent can't find any suitable tools, just report it back to the main agent to move on to the next step
+   - The Task agent can only use MCP tools if any to achieve this task
+   - If the Task agent can't find any suitable tools, just report it back to the main agent to move on to the next step
 
 ## Important Notes
 

package/merged-commands/writing-plans.md

@@ -102,16 +102,16 @@ After saving the plan, offer execution choice:
 
 **"Plan complete and saved to `docs/plans/<filename>.md`. Two execution options:**
 
-**1. Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration
+**1. Task Agent-Driven (this session)** - I dispatch fresh Task agent per task, review between tasks, fast iteration
 
 **2. Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints
 
 **Which approach?"**
 
-**If Subagent-Driven chosen:**
+**If Task Agent-Driven chosen:**
 - **REQUIRED SUB-SKILL:** Use superpowers:subagent-driven-development
 - Stay in this session
-- Fresh subagent per task + code review
+- Fresh Task agent per task + code review
 
 **If Parallel Session chosen:**
 - Guide them to open new session in worktree

package/merged-commands/writing-skills.md

@@ -11,7 +11,7 @@ description: Use when creating new skills, editing existing skills, or verifying
 
 **Personal skills live in agent-specific directories (`~/.claude/skills` for Claude Code, `~/.codex/skills` for Codex)** 
 
-You write test cases (pressure scenarios with subagents), watch them fail (baseline behavior), write the skill (documentation), watch tests pass (agents comply), and refactor (close loopholes).
+You write test cases (pressure scenarios with Task agents), watch them fail (baseline behavior), write the skill (documentation), watch tests pass (agents comply), and refactor (close loopholes).
 
 **Core principle:** If you didn't watch an agent fail without the skill, you don't know if the skill teaches the right thing.
 
@@ -31,7 +31,7 @@ A **skill** is a reference guide for proven techniques, patterns, or tools. Skil
 
 | TDD Concept | Skill Creation |
 |-------------|----------------|
-| **Test case** | Pressure scenario with subagent |
+| **Test case** | Pressure scenario with Task agent |
 | **Production code** | Skill document (SKILL.md) |
 | **Test fails (RED)** | Agent violates rule without skill (baseline) |
 | **Test passes (GREEN)** | Agent complies with skill present |
@@ -159,7 +159,7 @@ When the description was changed to just "Use when executing implementation plan
 
 ```yaml
 # ❌ BAD: Summarizes workflow - Claude may follow this instead of reading skill
-description: Use when executing plans - dispatches subagent per task with code review between tasks
+description: Use when executing plans - dispatches Task agent per task with code review between tasks
 
 # ❌ BAD: Too much process detail
 description: Use for TDD - write test first, watch it fail, write minimal code, refactor
@@ -233,11 +233,11 @@ search-conversations supports multiple modes and filters. Run --help for details
 **Use cross-references:**
 ```markdown
 # ❌ BAD: Repeat workflow details
-When searching, dispatch subagent with template...
+When searching, dispatch Task agent with template...
 [20 lines of repeated instructions]
 
 # ✅ GOOD: Reference other skill
-Always use subagents (50-100x context savings). REQUIRED: Use [other-skill-name] for workflow.
+Always use Task agents (50-100x context savings). REQUIRED: Use [other-skill-name] for workflow.
 ```
 
 **Compress examples:**
@@ -245,12 +245,12 @@ Always use subagents (50-100x context savings). REQUIRED: Use [other-skill-name]
 # ❌ BAD: Verbose example (42 words)
 your human partner: "How did we handle authentication errors in React Router before?"
 You: I'll search past conversations for React Router authentication patterns.
-[Dispatch subagent with search query: "React Router authentication error handling 401"]
+[Dispatch Task agent with search query: "React Router authentication error handling 401"]
 
 # ✅ GOOD: Minimal example (20 words)
 Partner: "How did we handle auth errors in React Router?"
 You: Searching...
-[Dispatch subagent → synthesis]
+[Dispatch Task agent → synthesis]
 ```
 
 **Eliminate redundancy:**
@@ -536,7 +536,7 @@ Follow the TDD cycle:
 
 ### RED: Write Failing Test (Baseline)
 
-Run pressure scenario with subagent WITHOUT the skill. Document exact behavior:
+Run pressure scenario with Task agent WITHOUT the skill. Document exact behavior:
 - What choices did they make?
 - What rationalizations did they use (verbatim)?
 - Which pressures triggered violations?

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngxtm/devkit",
-  "version": "3.19.0",
+  "version": "3.20.0",
   "description": "Per-project AI skills with smart tech detection - lightweight and context-optimized",
   "main": "cli/index.js",
   "bin": {

package/rules-index.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "generatedAt": "2026-02-27T13:12:47.270Z",
+  "generatedAt": "2026-02-27T15:08:44.475Z",
   "templates": {
     "dart": {
       "path": "templates/dart/rules",

package/skills/application-performance-performance-optimization/SKILL.md

@@ -38,21 +38,21 @@ Optimize application performance end-to-end using specialized performance and op
 
 ### 1. Comprehensive Performance Profiling
 
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Profile application performance comprehensively for: $ARGUMENTS. Generate flame graphs for CPU usage, heap dumps for memory analysis, trace I/O operations, and identify hot paths. Use APM tools like DataDog or New Relic if available. Include database query profiling, API response times, and frontend rendering metrics. Establish performance baselines for all critical user journeys."
 - Context: Initial performance investigation
 - Output: Detailed performance profile with flame graphs, memory analysis, bottleneck identification, baseline metrics
 
 ### 2. Observability Stack Assessment
 
-- Use Task tool with subagent_type="observability-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Assess current observability setup for: $ARGUMENTS. Review existing monitoring, distributed tracing with OpenTelemetry, log aggregation, and metrics collection. Identify gaps in visibility, missing metrics, and areas needing better instrumentation. Recommend APM tool integration and custom metrics for business-critical operations."
 - Context: Performance profile from step 1
 - Output: Observability assessment report, instrumentation gaps, monitoring recommendations
 
 ### 3. User Experience Analysis
 
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze user experience metrics for: $ARGUMENTS. Measure Core Web Vitals (LCP, FID, CLS), page load times, time to interactive, and perceived performance. Use Real User Monitoring (RUM) data if available. Identify user journeys with poor performance and their business impact."
 - Context: Performance baselines from step 1
 - Output: UX performance report, Core Web Vitals analysis, user impact assessment
@@ -61,21 +61,21 @@ Optimize application performance end-to-end using specialized performance and op
 
 ### 4. Database Performance Optimization
 
-- Use Task tool with subagent_type="database-cloud-optimization::database-optimizer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Optimize database performance for: $ARGUMENTS based on profiling data: {context_from_phase_1}. Analyze slow query logs, create missing indexes, optimize execution plans, implement query result caching with Redis/Memcached. Review connection pooling, prepared statements, and batch processing opportunities. Consider read replicas and database sharding if needed."
 - Context: Performance bottlenecks from phase 1
 - Output: Optimized queries, new indexes, caching strategy, connection pool configuration
 
 ### 5. Backend Code & API Optimization
 
-- Use Task tool with subagent_type="backend-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Optimize backend services for: $ARGUMENTS targeting bottlenecks: {context_from_phase_1}. Implement efficient algorithms, add application-level caching, optimize N+1 queries, use async/await patterns effectively. Implement pagination, response compression, GraphQL query optimization, and batch API operations. Add circuit breakers and bulkheads for resilience."
 - Context: Database optimizations from step 4, profiling data from phase 1
 - Output: Optimized backend code, caching implementation, API improvements, resilience patterns
 
 ### 6. Microservices & Distributed System Optimization
 
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Optimize distributed system performance for: $ARGUMENTS. Analyze service-to-service communication, implement service mesh optimizations, optimize message queue performance (Kafka/RabbitMQ), reduce network hops. Implement distributed caching strategies and optimize serialization/deserialization."
 - Context: Backend optimizations from step 5
 - Output: Service communication improvements, message queue optimization, distributed caching setup
@@ -84,21 +84,21 @@ Optimize application performance end-to-end using specialized performance and op
 
 ### 7. Frontend Bundle & Loading Optimization
 
-- Use Task tool with subagent_type="frontend-developer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Optimize frontend performance for: $ARGUMENTS targeting Core Web Vitals: {context_from_phase_1}. Implement code splitting, tree shaking, lazy loading, and dynamic imports. Optimize bundle sizes with webpack/rollup analysis. Implement resource hints (prefetch, preconnect, preload). Optimize critical rendering path and eliminate render-blocking resources."
 - Context: UX analysis from phase 1, backend optimizations from phase 2
 - Output: Optimized bundles, lazy loading implementation, improved Core Web Vitals
 
 ### 8. CDN & Edge Optimization
 
-- Use Task tool with subagent_type="cloud-infrastructure::cloud-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Optimize CDN and edge performance for: $ARGUMENTS. Configure CloudFlare/CloudFront for optimal caching, implement edge functions for dynamic content, set up image optimization with responsive images and WebP/AVIF formats. Configure HTTP/2 and HTTP/3, implement Brotli compression. Set up geographic distribution for global users."
 - Context: Frontend optimizations from step 7
 - Output: CDN configuration, edge caching rules, compression setup, geographic optimization
 
 ### 9. Mobile & Progressive Web App Optimization
 
-- Use Task tool with subagent_type="frontend-mobile-development::mobile-developer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Optimize mobile experience for: $ARGUMENTS. Implement service workers for offline functionality, optimize for slow networks with adaptive loading. Reduce JavaScript execution time for mobile CPUs. Implement virtual scrolling for long lists. Optimize touch responsiveness and smooth animations. Consider React Native/Flutter specific optimizations if applicable."
 - Context: Frontend optimizations from steps 7-8
 - Output: Mobile-optimized code, PWA implementation, offline functionality
@@ -107,14 +107,14 @@ Optimize application performance end-to-end using specialized performance and op
 
 ### 10. Comprehensive Load Testing
 
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Conduct comprehensive load testing for: $ARGUMENTS using k6/Gatling/Artillery. Design realistic load scenarios based on production traffic patterns. Test normal load, peak load, and stress scenarios. Include API testing, browser-based testing, and WebSocket testing if applicable. Measure response times, throughput, error rates, and resource utilization at various load levels."
 - Context: All optimizations from phases 1-3
 - Output: Load test results, performance under load, breaking points, scalability analysis
 
 ### 11. Performance Regression Testing
 
-- Use Task tool with subagent_type="performance-testing-review::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Create automated performance regression tests for: $ARGUMENTS. Set up performance budgets for key metrics, integrate with CI/CD pipeline using GitHub Actions or similar. Create Lighthouse CI tests for frontend, API performance tests with Artillery, and database performance benchmarks. Implement automatic rollback triggers for performance regressions."
 - Context: Load test results from step 10, baseline metrics from phase 1
 - Output: Performance test suite, CI/CD integration, regression prevention system
@@ -123,14 +123,14 @@ Optimize application performance end-to-end using specialized performance and op
 
 ### 12. Production Monitoring Setup
 
-- Use Task tool with subagent_type="observability-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement production performance monitoring for: $ARGUMENTS. Set up APM with DataDog/New Relic/Dynatrace, configure distributed tracing with OpenTelemetry, implement custom business metrics. Create Grafana dashboards for key metrics, set up PagerDuty alerts for performance degradation. Define SLIs/SLOs for critical services with error budgets."
 - Context: Performance improvements from all previous phases
 - Output: Monitoring dashboards, alert rules, SLI/SLO definitions, runbooks
 
 ### 13. Continuous Performance Optimization
 
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Establish continuous optimization process for: $ARGUMENTS. Create performance budget tracking, implement A/B testing for performance changes, set up continuous profiling in production. Document optimization opportunities backlog, create capacity planning models, and establish regular performance review cycles."
 - Context: Monitoring setup from step 12, all previous optimization work
 - Output: Performance budget tracking, optimization backlog, capacity planning, review process

package/skills/azure-ai-agents-python/references/tools.md

@@ -402,7 +402,7 @@ Chain multiple agents together.
 ```python
 from azure.ai.agents import ConnectedAgentTool
 
-# Create sub-agent
+# Create Task agent
 research_agent = client.create_agent(
     model=os.environ["MODEL_DEPLOYMENT_NAME"],
     name="researcher",

package/skills/backend-development-feature-development/SKILL.md

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

package/skills/best-practices/references/anti-patterns.md

@@ -528,9 +528,9 @@ read all the files in src/ and then tell me about the architecture
 ```
 read the main entry point and top-level directories to understand the architecture. don't read every file - just enough to explain the main patterns.
 ```
-Or use subagents:
+Or use Task agents:
 ```
-use a subagent to investigate the codebase architecture and report a summary.
+use a Task agent to investigate the codebase architecture and report a summary.
 ```
 
 ---

package/skills/best-practices/references/best-practices-guide.md

@@ -250,11 +250,11 @@ Analyze and fix the GitHub issue: $ARGUMENTS.
 
 Run `/fix-issue 1234` to invoke it. Use `disable-model-invocation: true` for workflows with side effects that you want to trigger manually.
 
-### Create custom subagents
+### Create custom Task agents
 
 > **Tip:** Define specialized assistants in `.claude/agents/` that Claude can delegate to for isolated tasks.
 
-Subagents run in their own context with their own set of allowed tools. They're useful for tasks that read many files or need specialized focus without cluttering your main conversation.
+Task agents run in their own context with their own set of allowed tools. They're useful for tasks that read many files or need specialized focus without cluttering your main conversation.
 
 ```markdown
 ---
@@ -272,15 +272,15 @@ You are a senior security engineer. Review code for:
 Provide specific line references and suggested fixes.
 ```
 
-Tell Claude to use subagents explicitly: *"Use a subagent to review this code for security issues."*
+Tell Claude to use Task agents explicitly: *"Use a Task agent to review this code for security issues."*
 
 ### Install plugins
 
 > **Tip:** Run `/plugin` to browse the marketplace. Plugins add skills, tools, and integrations without configuration.
 
-Plugins bundle skills, hooks, subagents, and MCP servers into a single installable unit from the community and Anthropic.
+Plugins bundle skills, hooks, Task agents, and MCP servers into a single installable unit from the community and Anthropic.
 
-For guidance on choosing between skills, subagents, hooks, and MCP, see Extend Claude Code.
+For guidance on choosing between skills, Task agents, hooks, and MCP, see Extend Claude Code.
 
 ***
 
@@ -350,23 +350,23 @@ During long sessions, Claude's context window can fill with irrelevant conversat
 * For more control, run `/compact <instructions>`, like `/compact Focus on the API changes`
 * Customize compaction behavior in CLAUDE.md with instructions like `"When compacting, always preserve the full list of modified files and any test commands"` to ensure critical context survives summarization
 
-### Use subagents for investigation
+### Use Task agents for investigation
 
-> **Tip:** Delegate research with `"use subagents to investigate X"`. They explore in a separate context, keeping your main conversation clean for implementation.
+> **Tip:** Delegate research with `"use Task agents to investigate X"`. They explore in a separate context, keeping your main conversation clean for implementation.
 
-Since context is your fundamental constraint, subagents are one of the most powerful tools available. When Claude researches a codebase it reads lots of files, all of which consume your context. Subagents run in separate context windows and report back summaries:
+Since context is your fundamental constraint, Task agents are one of the most powerful tools available. When Claude researches a codebase it reads lots of files, all of which consume your context. Task agents run in separate context windows and report back summaries:
 
 ```
-Use subagents to investigate how our authentication system handles token
+Use Task agents to investigate how our authentication system handles token
 refresh, and whether we have any existing OAuth utilities I should reuse.
 ```
 
-The subagent explores the codebase, reads relevant files, and reports back with findings, all without cluttering your main conversation.
+The Task agent explores the codebase, reads relevant files, and reports back with findings, all without cluttering your main conversation.
 
-You can also use subagents for verification after Claude implements something:
+You can also use Task agents for verification after Claude implements something:
 
 ```
-use a subagent to review this code for edge cases
+use a Task agent to review this code for edge cases
 ```
 
 ### Rewind with checkpoints
@@ -487,7 +487,7 @@ These are common mistakes. Recognizing them early saves time:
 * **The trust-then-verify gap.** Claude produces a plausible-looking implementation that doesn't handle edge cases.
   > **Fix**: Always provide verification (tests, scripts, screenshots). If you can't verify it, don't ship it.
 * **The infinite exploration.** You ask Claude to "investigate" something without scoping it. Claude reads hundreds of files, filling the context.
-  > **Fix**: Scope investigations narrowly or use subagents so the exploration doesn't consume your main context.
+  > **Fix**: Scope investigations narrowly or use Task agents so the exploration doesn't consume your main context.
 
 ***
 
@@ -504,7 +504,7 @@ Over time, you'll develop intuition that no guide can capture. You'll know when
 ## Related resources
 
 * **How Claude Code works** - Understand the agentic loop, tools, and context management
-* **Extend Claude Code** - Choose between skills, hooks, MCP, subagents, and plugins
+* **Extend Claude Code** - Choose between skills, hooks, MCP, Task agents, and plugins
 * **Common workflows** - Step-by-step recipes for debugging, testing, PRs, and more
 * **CLAUDE.md** - Store project conventions and persistent context
 

package/skills/c4-architecture-c4-architecture/SKILL.md

@@ -54,7 +54,7 @@ All documentation is written to a new `C4-Documentation/` directory in the repos
 
 For each directory, starting from the deepest:
 
-- Use Task tool with subagent_type="c4-architecture::c4-code"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Analyze the code in directory: [directory_path]
 
@@ -110,7 +110,7 @@ For each directory, starting from the deepest:
 
 For each identified component:
 
-- Use Task tool with subagent_type="c4-architecture::c4-component"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Synthesize the following C4 Code-level documentation files into a logical component:
 
@@ -153,7 +153,7 @@ For each identified component:
 
 ### 2.3 Create Master Component Index
 
-- Use Task tool with subagent_type="c4-architecture::c4-component"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Create a master component index that lists all components in the system.
 
@@ -188,7 +188,7 @@ For each identified component:
 
 ### 3.2 Map Components to Containers
 
-- Use Task tool with subagent_type="c4-architecture::c4-container"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Synthesize components into containers based on deployment definitions.
 
@@ -261,7 +261,7 @@ For each identified component:
 
 ### 4.2 Create Context Documentation
 
-- Use Task tool with subagent_type="c4-architecture::c4-context"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Create comprehensive C4 Context-level documentation for the system.
 

package/skills/comprehensive-review-full-review/SKILL.md

@@ -41,13 +41,13 @@ Orchestrate comprehensive multi-dimensional code review using specialized review
 Use Task tool to orchestrate quality and architecture agents in parallel:
 
 ### 1A. Code Quality Analysis
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Perform comprehensive code quality review for: $ARGUMENTS. Analyze code complexity, maintainability index, technical debt, code duplication, naming conventions, and adherence to Clean Code principles. Integrate with SonarQube, CodeQL, and Semgrep for static analysis. Check for code smells, anti-patterns, and violations of SOLID principles. Generate cyclomatic complexity metrics and identify refactoring opportunities."
 - Expected output: Quality metrics, code smell inventory, refactoring recommendations
 - Context: Initial codebase analysis, no dependencies on other phases
 
 ### 1B. Architecture & Design Review
-- Use Task tool with subagent_type="architect-review"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Review architectural design patterns and structural integrity in: $ARGUMENTS. Evaluate microservices boundaries, API design, database schema, dependency management, and adherence to Domain-Driven Design principles. Check for circular dependencies, inappropriate coupling, missing abstractions, and architectural drift. Verify compliance with enterprise architecture standards and cloud-native patterns."
 - Expected output: Architecture assessment, design pattern analysis, structural recommendations
 - Context: Runs parallel with code quality analysis
@@ -57,13 +57,13 @@ Use Task tool to orchestrate quality and architecture agents in parallel:
 Use Task tool with security and performance agents, incorporating Phase 1 findings:
 
 ### 2A. Security Vulnerability Assessment
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Execute comprehensive security audit on: $ARGUMENTS. Perform OWASP Top 10 analysis, dependency vulnerability scanning with Snyk/Trivy, secrets detection with GitLeaks, input validation review, authentication/authorization assessment, and cryptographic implementation review. Include findings from Phase 1 architecture review: {phase1_architecture_context}. Check for SQL injection, XSS, CSRF, insecure deserialization, and configuration security issues."
 - Expected output: Vulnerability report, CVE list, security risk matrix, remediation steps
 - Context: Incorporates architectural vulnerabilities identified in Phase 1B
 
 ### 2B. Performance & Scalability Analysis
-- Use Task tool with subagent_type="application-performance::performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Conduct performance analysis and scalability assessment for: $ARGUMENTS. Profile code for CPU/memory hotspots, analyze database query performance, review caching strategies, identify N+1 problems, assess connection pooling, and evaluate asynchronous processing patterns. Consider architectural findings from Phase 1: {phase1_architecture_context}. Check for memory leaks, resource contention, and bottlenecks under load."
 - Expected output: Performance metrics, bottleneck analysis, optimization recommendations
 - Context: Uses architecture insights to identify systemic performance issues
@@ -73,13 +73,13 @@ Use Task tool with security and performance agents, incorporating Phase 1 findin
 Use Task tool for test and documentation quality assessment:
 
 ### 3A. Test Coverage & Quality Analysis
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Evaluate testing strategy and implementation for: $ARGUMENTS. Analyze unit test coverage, integration test completeness, end-to-end test scenarios, test pyramid adherence, and test maintainability. Review test quality metrics including assertion density, test isolation, mock usage, and flakiness. Consider security and performance test requirements from Phase 2: {phase2_security_context}, {phase2_performance_context}. Verify TDD practices if --tdd-review flag is set."
 - Expected output: Coverage report, test quality metrics, testing gap analysis
 - Context: Incorporates security and performance testing requirements from Phase 2
 
 ### 3B. Documentation & API Specification Review
-- Use Task tool with subagent_type="code-documentation::docs-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Review documentation completeness and quality for: $ARGUMENTS. Assess inline code documentation, API documentation (OpenAPI/Swagger), architecture decision records (ADRs), README completeness, deployment guides, and runbooks. Verify documentation reflects actual implementation based on all previous phase findings: {phase1_context}, {phase2_context}. Check for outdated documentation, missing examples, and unclear explanations."
 - Expected output: Documentation coverage report, inconsistency list, improvement recommendations
 - Context: Cross-references all previous findings to ensure documentation accuracy
@@ -89,13 +89,13 @@ Use Task tool for test and documentation quality assessment:
 Use Task tool to verify framework-specific and industry best practices:
 
 ### 4A. Framework & Language Best Practices
-- Use Task tool with subagent_type="framework-migration::legacy-modernizer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Verify adherence to framework and language best practices for: $ARGUMENTS. Check modern JavaScript/TypeScript patterns, React hooks best practices, Python PEP compliance, Java enterprise patterns, Go idiomatic code, or framework-specific conventions (based on --framework flag). Review package management, build configuration, environment handling, and deployment practices. Include all quality issues from previous phases: {all_previous_contexts}."
 - Expected output: Best practices compliance report, modernization recommendations
 - Context: Synthesizes all previous findings for framework-specific guidance
 
 ### 4B. CI/CD & DevOps Practices Review
-- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Review CI/CD pipeline and DevOps practices for: $ARGUMENTS. Evaluate build automation, test automation integration, deployment strategies (blue-green, canary), infrastructure as code, monitoring/observability setup, and incident response procedures. Assess pipeline security, artifact management, and rollback capabilities. Consider all issues identified in previous phases that impact deployment: {all_critical_issues}."
 - Expected output: Pipeline assessment, DevOps maturity evaluation, automation recommendations
 - Context: Focuses on operationalizing fixes for all identified issues

package/skills/context-degradation/SKILL.md

@@ -157,11 +157,11 @@ Four strategies address different aspects of context degradation:
 
 **Compress**: Reduce tokens while preserving information through summarization, abstraction, and observation masking. This extends effective context capacity.
 
-**Isolate**: Split context across sub-agents or sessions to prevent any single context from growing large enough to degrade. This is the most aggressive strategy but often the most effective.
+**Isolate**: Split context across Task agents or sessions to prevent any single context from growing large enough to degrade. This is the most aggressive strategy but often the most effective.
 
 ### Architectural Patterns
 
-Implement these strategies through specific architectural patterns. Use just-in-time context loading to retrieve information only when needed. Use observation masking to replace verbose tool outputs with compact references. Use sub-agent architectures to isolate context for different tasks. Use compaction to summarize growing context before it exceeds limits.
+Implement these strategies through specific architectural patterns. Use just-in-time context loading to retrieve information only when needed. Use observation masking to replace verbose tool outputs with compact references. Use Task agent architectures to isolate context for different tasks. Use compaction to summarize growing context before it exceeds limits.
 
 ## Examples
 

package/skills/context-engineering/SKILL.md

@@ -25,13 +25,13 @@ Context engineering curates the smallest high-signal token set for LLM tasks. Th
 1. **Context quality > quantity** - High-signal tokens beat exhaustive content
 2. **Attention is finite** - U-shaped curve favors beginning/end positions
 3. **Progressive disclosure** - Load information just-in-time
-4. **Isolation prevents degradation** - Partition work across sub-agents
+4. **Isolation prevents degradation** - Partition work across Task agents
 5. **Measure before optimizing** - Know your baseline
 
 **IMPORTANT:**
 - Sacrifice grammar for the sake of concision.
 - Ensure token efficiency while maintaining high quality.
-- Pass these rules to subagents.
+- Pass these rules to Task agents.
 
 ## Quick Reference
 
@@ -61,7 +61,7 @@ Context engineering curates the smallest high-signal token set for LLM tasks. Th
 1. **Write**: Save context externally (scratchpads, files)
 2. **Select**: Pull only relevant context (retrieval, filtering)
 3. **Compress**: Reduce tokens while preserving info (summarization)
-4. **Isolate**: Split across sub-agents (partitioning)
+4. **Isolate**: Split across Task agents (partitioning)
 
 ## Anti-Patterns
 
@@ -75,7 +75,7 @@ Context engineering curates the smallest high-signal token set for LLM tasks. Th
 
 1. Place critical info at beginning/end of context
 2. Implement compaction at 70-80% utilization
-3. Use sub-agents for context isolation, not role-play
+3. Use Task agents for context isolation, not role-play
 4. Design tools with 4-question framework (what, when, inputs, returns)
 5. Optimize for tokens-per-task, not tokens-per-request
 6. Validate with probe-based evaluation

package/skills/context-engineering/references/context-degradation.md

@@ -61,7 +61,7 @@ Predictable degradation as context grows. Not binary - a continuum.
 1. **Write**: Save externally (scratchpads, files)
 2. **Select**: Pull only relevant (retrieval, filtering)
 3. **Compress**: Reduce tokens (summarization)
-4. **Isolate**: Split across sub-agents (partitioning)
+4. **Isolate**: Split across Task agents (partitioning)
 
 ## Detection Heuristics
 

package/skills/context-engineering/references/context-optimization.md

@@ -51,7 +51,7 @@ context += [unique_content]                   # Variable last
 
 ## Context Partitioning
 
-Split work across sub-agents with isolated contexts.
+Split work across Task agents with isolated contexts.
 
 ```python
 result = await sub_agent.process(subtask, clean_context=True)

package/skills/context-engineering/references/multi-agent-patterns.md

@@ -4,7 +4,7 @@ Distribute work across multiple context windows for isolation and scale.
 
 ## Core Insight
 
-Sub-agents exist to **isolate context**, not anthropomorphize roles.
+Task agents exist to **isolate context**, not anthropomorphize roles.
 
 ## Token Economics