@ngxtm/devkit 3.18.0 → 3.20.0

package/merged-commands/test/fast.md

@@ -1,5 +1,5 @@
 ---
-description: ⚡ Quick Test — Fast testing for specific scope
+description: Quick Test — Fast testing for specific scope
 version: "1.0"
 category: validation
 execution-mode: execute
@@ -13,48 +13,37 @@ execution-mode: execute
 
 ---
 
-## 🛑 PRE-FLIGHT (DO FIRST — BLOCKS PHASE 1)
-
-**LOAD now** (in order; path `./rules/` or `~/.{TOOL}/skills/agent-assistant/rules/`):
-1. ORCHESTRATION-LAWS.md  
-2. ADAPTIVE-EXECUTION.md  
-3. EXECUTION-PROTOCOL.md  
-
-**⛔ Do not run Phase 1 until all are loaded.** Follow **all** rules in those files; they override any conflicting instructions in this file.
+## Execution
+One phase at a time, sequential. Each phase must complete before next begins.
 
 ---
 
-## 🔀 TIERED EXECUTION
-
-| Tier | When | Action |
-|------|------|--------|
-| **TIER 1** | runSubagent EXISTS | Invoke sub-agent (MANDATORY) |
-| **TIER 2** | Tool MISSING | EMBODY agent file (FALLBACK) |
+## Phase 1: TEST EXECUTION
 
----
+| Attribute | Value |
+|-----------|-------|
+| **Role** | `tester` |
+| **Goal** | Run focused tests |
+| **Exit** | Tests run, results recorded |
 
-## ⛔ INCREMENTAL EXECUTION (MANDATORY)
+### Delegation
 
-One phase at a time, each phase independent: Phase 1 → then Phase 2 → … in one reply. No batching (load only what each phase needs). **Within each phase:** when doing a part, output it in format so user sees what’s happening (announce before doing).
+> Task(subagent_type="general-purpose", prompt="You are a tester. Run focused tests for the given scope. Exit when tests are run and results are recorded.", description="tester: Run focused tests")
 
 ---
 
-## 🎭 Phase 1: TEST EXECUTION
-
-| Agent | `tester` |
-|-------|----------|
-| Goal | Run focused tests |
-| Exit | Tests run, results recorded |
+## Phase 2: QUICK ANALYSIS (IF FAILURES)
 
----
+| Attribute | Value |
+|-----------|-------|
+| **Role** | `debugger` |
+| **Trigger** | If failures exist |
+| **Goal** | Quick failure analysis |
+| **Exit** | Root causes identified |
 
-## 🎭 Phase 2: QUICK ANALYSIS (IF FAILURES)
+### Delegation
 
-| Agent | `debugger` |
-|-------|------------|
-| Trigger | If failures exist |
-| Goal | Quick failure analysis |
-| Exit | Root causes identified |
+> Task(subagent_type="general-purpose", prompt="You are a debugger. Perform quick failure analysis on test failures. Exit when root causes are identified.", description="debugger: Quick failure analysis")
 
 ---
 
@@ -71,5 +60,5 @@ One phase at a time, each phase independent: Phase 1 → then Phase 2 → … in
 
 Present results with:
 
-1. ✅ **Pass** — Tests green
-2. 🔧 **Fix** → `/fix:fast`
+1. **Pass** — Tests green
+2. **Fix** → `/fix:fast`

package/merged-commands/test/hard.md

@@ -1,5 +1,5 @@
 ---
-description: ⚡⚡⚡ Full Test — Comprehensive QA with quality gates
+description: Full Test — Comprehensive QA with quality gates
 version: "1.0"
 category: validation
 execution-mode: execute
@@ -13,28 +13,7 @@ execution-mode: execute
 
 ---
 
-## 🛑 PRE-FLIGHT (DO FIRST — BLOCKS PHASE 1)
-
-**LOAD now** (in order; path `./rules/` or `~/.{TOOL}/skills/agent-assistant/rules/`):
-
-1. ORCHESTRATION-LAWS.md
-2. ADAPTIVE-EXECUTION.md
-3. EXECUTION-PROTOCOL.md
-
-**⛔ Do not run Phase 1 until all are loaded.** Follow **all** rules in those files; they override any conflicting instructions in this file.
-
----
-
-## 🔀 TIERED EXECUTION
-
-| Tier       | When               | Action                       |
-| ---------- | ------------------ | ---------------------------- |
-| **TIER 1** | runSubagent EXISTS | Invoke sub-agent (MANDATORY) |
-| **TIER 2** | Tool MISSING       | EMBODY agent file (FALLBACK) |
-
----
-
-## 📁 PLAN CHECKPOINT VERIFICATION
+## PLAN CHECKPOINT VERIFICATION
 
 ```
 IF ./reports/plans/PLAN-{scope}.md exists:
@@ -46,56 +25,80 @@ IF ./reports/plans/PLAN-{scope}.md exists:
 
 ---
 
-## ⛔ INCREMENTAL EXECUTION (MANDATORY)
-
-One phase at a time, each phase independent: Phase 1 → then Phase 2 → … in one reply. No batching (load only what each phase needs). **Within each phase:** when doing a part, output it in format so user sees what’s happening (announce before doing).
+## Execution
+One phase at a time, sequential. Each phase must complete before next begins.
 
 ---
 
-## 🎭 Phase 1: TEST STRATEGY
+## Phase 1: TEST STRATEGY
 
-| Agent | `tester`                                |
-| ----- | --------------------------------------- |
-| Goal  | Design test strategy                    |
-| Exit  | Strategy defined, test types identified |
+| Attribute | Value |
+|-----------|-------|
+| **Role** | `tester` |
+| **Goal** | Design test strategy |
+| **Exit** | Strategy defined, test types identified |
+
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a tester. Design a test strategy. Exit when strategy is defined and test types are identified.", description="tester: Design test strategy")
 
 ---
 
-## 🎭 Phase 2: DEPENDENCY MAPPING
+## Phase 2: DEPENDENCY MAPPING
+
+| Attribute | Value |
+|-----------|-------|
+| **Role** | `scouter` |
+| **Goal** | Map test dependencies |
+| **Exit** | Dependencies mapped, environment ready |
 
-| Agent | `scouter`                              |
-| ----- | -------------------------------------- |
-| Goal  | Map test dependencies                  |
-| Exit  | Dependencies mapped, environment ready |
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a scouter. Map test dependencies. Exit when dependencies are mapped and environment is ready.", description="scouter: Map test dependencies")
 
 ---
 
-## 🎭 Phase 3: TEST EXECUTION
+## Phase 3: TEST EXECUTION
+
+| Attribute | Value |
+|-----------|-------|
+| **Role** | `tester` |
+| **Prerequisite** | READ PLAN file if exists |
+| **Goal** | Run full test suite |
+| **Exit** | All tests run, coverage measured, checkpoint mapping documented |
 
-| Agent        | `tester`                                                        |
-| ------------ | --------------------------------------------------------------- |
-| Prerequisite | READ PLAN file if exists                                        |
-| Goal         | Run full test suite                                             |
-| Exit         | All tests run, coverage measured, checkpoint mapping documented |
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a tester. Run the full test suite. Read the PLAN file if it exists. Exit when all tests are run, coverage is measured, and checkpoint mapping is documented.", description="tester: Run full test suite")
 
 ---
 
-## 🎭 Phase 4: FAILURE ANALYSIS (IF FAILURES)
+## Phase 4: FAILURE ANALYSIS (IF FAILURES)
+
+| Attribute | Value |
+|-----------|-------|
+| **Role** | `debugger` |
+| **Trigger** | If failures exist |
+| **Goal** | Analyze failures |
+| **Exit** | Root causes identified |
+
+### Delegation
 
-| Agent   | `debugger`             |
-| ------- | ---------------------- |
-| Trigger | If failures exist      |
-| Goal    | Analyze failures       |
-| Exit    | Root causes identified |
+> Task(subagent_type="general-purpose", prompt="You are a debugger. Analyze test failures. Exit when root causes are identified.", description="debugger: Analyze test failures")
 
 ---
 
-## 🎭 Phase 5: QUALITY GATES
+## Phase 5: QUALITY GATES
+
+| Attribute | Value |
+|-----------|-------|
+| **Role** | `tester` |
+| **Goal** | Verify quality gates |
+| **Exit** | All gates pass, coverage adequate |
+
+### Delegation
 
-| Agent | `tester`                          |
-| ----- | --------------------------------- |
-| Goal  | Verify quality gates              |
-| Exit  | All gates pass, coverage adequate |
+> Task(subagent_type="general-purpose", prompt="You are a tester. Verify quality gates. Exit when all gates pass and coverage is adequate.", description="tester: Verify quality gates")
 
 ---
 
@@ -103,6 +106,6 @@ One phase at a time, each phase independent: Phase 1 → then Phase 2 → … in
 
 Present test report with:
 
-1. ✅ **Pass** — All tests green
-2. 🔧 **Fix** → `/fix:fast`
-3. 📝 **Review** → `/review`
+1. **Pass** — All tests green
+2. **Fix** → `/fix:fast`
+3. **Review** → `/review`

package/merged-commands/test/ui.md

@@ -74,7 +74,7 @@ node screenshot.js --url https://example.com/settings --output settings.png --cl
 - All the screenshots should be saved in the same report directory.
 - Browse $URL with the specified $OPTIONS, discover all pages, components, and endpoints.
 - Create a test plan based on the discovered structure
-- Use multiple `tester` subagents or tool calls in parallel to test all pages, forms, navigation, user flows, accessibility, functionalities, usability, responsive layouts, cross-browser compatibility, performance, security, seo, etc.
+- Use multiple Task agents in parallel to test all pages, forms, navigation, user flows, accessibility, functionalities, usability, responsive layouts, cross-browser compatibility, performance, security, seo, etc.: Task(subagent_type="general-purpose", prompt="You are a tester. Test [specific area]...", description="Test [area]")
 - Use `ai-multimodal` to analyze all screenshots and visual elements.
 - Generate a comprehensive report in Markdown format, embedding all screenshots directly in the report.
 - Finally respond to the user with a concise summary of findings and recommendations.

package/merged-commands/test.md

@@ -2,7 +2,7 @@
 description: ⚡ Run tests locally and analyze the summary report.
 ---
 
-Use the `tester` subagent to run tests locally and analyze the summary report.
+Use a Task agent for testing: Task(subagent_type="general-purpose", prompt="You are a tester. Run tests locally and analyze the summary report.", description="Run tests") to run tests locally and analyze the summary report.
 
 **IMPORTANT**: **Do not** start implementing.
 **IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.

package/merged-commands/typescript-expert.md

@@ -27,7 +27,7 @@ You are an advanced TypeScript expert with deep, practical knowledge of type-lev
    - Type performance profiling or compiler internals → typescript-type-expert
 
    Example to output:
-   "This requires deep bundler expertise. Please invoke: 'Use the typescript-build-expert subagent.' Stopping here."
+   "This requires deep bundler expertise. Please invoke: 'Use the typescript-build-expert Task agent.' Stopping here."
 
 1. Analyze project setup comprehensively:
    

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.18.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-27T09:39:22.280Z",
+  "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.
 ```
 
 ---