@ngxtm/devkit 3.18.0 → 3.20.0

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
 

package/skills/context-engineering/references/runtime-awareness.md

@@ -157,7 +157,7 @@ Context: 91% [CRITICAL - compaction needed]
 | 5-Hour | Action |
 |--------|--------|
 | < 70% | Normal usage |
-| 70-90% | Reduce parallelization, delegate to subagents |
+| 70-90% | Reduce parallelization, delegate to Task agents |
 | > 90% | Wait for reset or use lower-tier models |
 
 | 7-Day | Action |

package/skills/context-optimization/SKILL.md

@@ -81,10 +81,10 @@ Design prompts to maximize cache stability: avoid dynamic content like timestamp
 
 ### Context Partitioning
 
-**Sub-Agent Partitioning**
-The most aggressive form of context optimization is partitioning work across sub-agents with isolated contexts. Each sub-agent operates in a clean context focused on its subtask without carrying accumulated context from other subtasks.
+**Task Agent Partitioning**
+The most aggressive form of context optimization is partitioning work across Task agents with isolated contexts. Each Task agent operates in a clean context focused on its subtask without carrying accumulated context from other subtasks.
 
-This approach achieves separation of concerns—the detailed search context remains isolated within sub-agents while the coordinator focuses on synthesis and analysis.
+This approach achieves separation of concerns—the detailed search context remains isolated within Task agents while the coordinator focuses on synthesis and analysis.
 
 **Result Aggregation**
 Aggregate results from partitioned subtasks by validating all partitions completed, merging compatible results, and summarizing if still too large.

package/skills/daily-news-report/SKILL.md

@@ -11,7 +11,7 @@ source: community
 
 # Daily News Report v3.0
 
-> **Architecture Upgrade**: Main Agent Orchestration + SubAgent Execution + Browser Scraping + Smart Caching
+> **Architecture Upgrade**: Main Agent Orchestration + Task Agent Execution + Browser Scraping + Smart Caching
 
 ## Core Architecture
 
@@ -35,7 +35,7 @@ source: community
 └──────────────────────────────────────────────────────────────────────┘
          ↓ Dispatch                          ↑ Return Results
 ┌─────────────────────────────────────────────────────────────────────┐
-│                        SubAgent Execution Layer                      │
+│                        Task Agent Execution Layer                      │
 ├─────────────────────────────────────────────────────────────────────┤
 │                                                                      │
 │   ┌─────────────┐   ┌─────────────┐   ┌─────────────┐              │
@@ -74,7 +74,7 @@ Steps:
   5. Check if a partial report exists for today (append mode)
 ```
 
-### Phase 2: Dispatch SubAgents
+### Phase 2: Dispatch Task Agents
 
 **Strategy**: Parallel dispatch, batch execution, early stopping mechanism
 
@@ -95,9 +95,9 @@ If still < 20 items:
     - Browser Worker: ProductHunt, Latent Space (Require JS rendering)
 ```
 
-### Phase 3: SubAgent Task Format
+### Phase 3: Task Agent Task Format
 
-Task format received by each SubAgent:
+Task format received by each Task Agent:
 
 ```yaml
 task: fetch_and_extract
@@ -134,12 +134,12 @@ Main Agent Responsibilities:
 
 ```yaml
 Monitoring:
-  - Check SubAgent return status (success/partial/failed)
+  - Check Task Agent return status (success/partial/failed)
   - Count collected items
   - Record success rate per source
 
 Feedback Loop:
-  - If a SubAgent fails, decide whether to retry or skip
+  - If a Task Agent fails, decide whether to retry or skip
   - If a source fails persistently, mark as disabled
   - Dynamically adjust source selection for subsequent batches
 
@@ -158,7 +158,7 @@ Deduplication:
   - Check cache.json to avoid history duplicates
 
 Score Calibration:
-  - Unify scoring standards across SubAgents
+  - Unify scoring standards across Task Agents
   - Adjust weights based on source credibility
   - Bonus points for manually curated high-quality sources
 
@@ -212,7 +212,7 @@ Update cache.json:
   - article_history: Record included articles
 ```
 
-## SubAgent Call Examples
+## Task Agent Call Examples
 
 ### Using general-purpose Agent
 
@@ -260,7 +260,7 @@ Task Call:
 
 ```
 Task Call:
-  subagent_type: worker
+  subagent_type: general-purpose
   prompt: |
     task: fetch_and_extract
     input:
@@ -288,7 +288,7 @@ Task Call:
 > Curated from N sources today, containing 20 high-quality items
 > Generation Time: X min | Version: v3.0
 >
-> **Warning**: Sub-agent 'worker' not detected. Running in generic mode (Serial Execution). Performance might be degraded.
+> **Warning**: Task agent 'worker' not detected. Running in generic mode (Serial Execution). Performance might be degraded.
 
 ---
 
@@ -318,11 +318,11 @@ Task Call:
 
 1.  **Quality over Quantity**: Low-quality content does not enter the report.
 2.  **Early Stop**: Stop scraping once 20 high-quality items are reached.
-3.  **Parallel First**: SubAgents in the same batch execute in parallel.
+3.  **Parallel First**: Task Agents in the same batch execute in parallel.
 4.  **Fault Tolerance**: Failure of a single source does not affect the whole process.
 5.  **Cache Reuse**: Avoid re-scraping the same content.
 6.  **Main Agent Control**: All decisions are made by the Main Agent.
-7.  **Fallback Awareness**: Detect sub-agent availability, gracefully degrade if unavailable.
+7.  **Fallback Awareness**: Detect Task agent availability, gracefully degrade if unavailable.
 
 ## Expected Performance
 
@@ -336,7 +336,7 @@ Task Call:
 
 | Error Type | Handling |
 |---|---|
-| SubAgent Timeout | Log error, continue to next |
+| Task Agent Timeout | Log error, continue to next |
 | Source 403/404 | Mark disabled, update sources.json |
 | Extraction Failed | Return raw content, Main Agent decides |
 | Browser Crash | Skip source, log entry |
@@ -346,7 +346,7 @@ Task Call:
 To ensure usability across different Agent environments, the following checks must be performed:
 
 1.  **Environment Check**:
-    -   In Phase 1 initialization, attempt to detect if `worker` sub-agent exists.
+    -   In Phase 1 initialization, attempt to detect if `worker` Task agent exists.
     -   If not exists (or plugin not installed), automatically switch to **Serial Execution Mode**.
 
 2.  **Serial Execution Mode**:

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

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

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

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

package/skills/doc-coauthoring/SKILL.md

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

package/skills/docker-expert/SKILL.md

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

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

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

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

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

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

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