@ngxtm/devkit 3.19.0 → 3.21.0

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.19.0",
+  "version": "3.21.0",
   "description": "Per-project AI skills with smart tech detection - lightweight and context-optimized",
   "main": "cli/index.js",
   "bin": {

package/rules/base/auto-skill.md

@@ -0,0 +1,60 @@
+# Auto-Skill Detection
+
+> Automatically detect and suggest relevant skills based on user's task
+
+## When to Activate
+
+Before starting ANY coding task, check if a relevant skill exists:
+
+1. **Analyze** the user's request — extract key technologies, patterns, or domains
+2. **Search** `skills-compact.json` for matching skill names/descriptions
+3. **Suggest** top 1-3 matching skills with name and category
+4. **Load** on user confirmation — read full skill from `skills/{name}/SKILL.md`
+
+## Skill Categories
+
+| Code | Category | Examples |
+|------|----------|----------|
+| `fe` | Frontend | react, vue, nextjs, tailwind, ui/ux |
+| `be` | Backend | node, express, nestjs, fastapi, api |
+| `db` | Database | postgres, mysql, mongodb, redis, prisma |
+| `ai` | AI/ML | llm, agents, rag, mcp, embeddings |
+| `ops` | DevOps | docker, k8s, ci/cd, aws, terraform |
+| `test` | Testing | jest, playwright, tdd, e2e |
+| `sec` | Security | auth, oauth, jwt, owasp, pentest |
+| `git` | Git/Workflow | pr, review, commit, branching |
+| `mob` | Mobile | react-native, flutter, ios, android |
+| `py` | Python | django, flask, fastapi, pandas |
+| `go` | Golang | gin, echo, fiber, concurrency |
+
+## How to Search
+
+1. Read `skills-compact.json` — format: `{ "skills": { "name": { "c": "category", "d": "description" } } }`
+2. Match skills whose name or description contains user's keywords
+3. If no direct match, suggest skills from the matching category
+4. On confirmation, read `skills/{skill-name}/SKILL.md`
+
+## Auto-Activate Triggers
+
+| User says... | Suggest skill |
+|--------------|---------------|
+| "create PR", "pull request" | /git-advanced-workflows |
+| "code review" | /code-review |
+| "write tests", "add tests" | /test-master |
+| "fix bug", "debug" | /systematic-debugging |
+| "learn", "teach me" | /learn |
+| "react component" | /react-expert |
+| "nextjs", "next.js" | /nextjs-best-practices |
+| "docker", "container" | /docker-expert |
+| "api design" | /api-design-principles |
+| "database schema" | /database-design |
+| "authentication", "auth" | /auth-implementation-patterns |
+| "mcp server" | /mcp-developer |
+
+## Rules
+
+1. **Don't auto-load** — always ask before loading a skill
+2. **Max 3 suggestions** — don't overwhelm user
+3. **Be concise** — one-line per skill suggestion
+4. **Remember context** — if user said "none", don't suggest again for same task
+5. **On-demand only** — only read full SKILL.md when user confirms

package/rules/base/command-routing.md

@@ -0,0 +1,58 @@
+# Command Routing Guide
+
+> Help Claude choose the right command and execution mode for each task.
+
+## Decision Tree
+
+```
+Is this a learning/educational request?
+  → /learn
+
+Is this brainstorming/ideation only (no code)?
+  → /brainstorm
+
+Is this just planning (no implementation)?
+  → /plan
+
+Is this a bug fix?
+  → /fix (simple) or /fix:hard (complex)
+
+Is this a small, well-defined task?
+  → /cook:fast
+
+Is this a medium task with clear requirements?
+  → /cook:auto (auto: plan → code → commit)
+  → OR /plan → /code (manual control)
+
+Is this a complex, full-lifecycle feature?
+  → /cook:hard (includes brainstorm+research+plan+code+test+review)
+  → OR /brainstorm → /plan → /code (manual, more control)
+```
+
+## Anti-Patterns
+
+- **NEVER** chain `/brainstorm` → `/plan` before `/cook:hard` — it already includes both internally, causing duplicate work
+- **NEVER** use `/cook:hard` for trivial fixes — overkill, wastes context
+- **NEVER** use `/cook:fast` for complex features — skips research/design, leads to rework
+
+## Command Reference
+
+| Command | Complexity | Multi-Agent | Best For |
+|---------|-----------|-------------|----------|
+| `/cook:fast` | Low | Light (scouter, engineer) | Well-defined small tasks |
+| `/cook` | Medium | Yes (full team) | Standard feature work |
+| `/cook:auto` | Medium | Yes (plan → code → git) | Autonomous implementation |
+| `/cook:hard` | High | Full (8 phases, all agents) | Complex features from scratch |
+| `/brainstorm` | N/A | No | Ideation, design exploration |
+| `/plan` | N/A | Optional (researcher) | Creating implementation plans |
+| `/code` | Medium | Yes (tester, reviewer) | Executing an existing plan |
+| `/learn` | N/A | No | Interactive tutorials |
+| `/fix` | Low | No | Quick bug fixes |
+| `/fix:hard` | Medium | Yes (debugger, tester) | Complex debugging |
+
+## When to Suggest Skills
+
+After choosing the right command, check if a domain-specific skill would help:
+- User says "react" → suggest `/react-expert` skill alongside chosen command
+- User says "auth" → suggest `/auth-implementation-patterns` skill
+- See `auto-skill.md` for full detection flow

package/rules/base/context-checkpoint.md

@@ -0,0 +1,38 @@
+# Context Checkpoint
+
+Auto-save session state to `.claude/sessions/` for context recovery.
+
+## When to Checkpoint
+After completing a subtask: implementing a feature step, running tests, phase transitions,
+receiving Task agent results, making key decisions.
+Do NOT checkpoint per individual file edit — wait until the subtask is complete.
+
+## Skip Checkpoint
+Simple Q&A, exploration reads, brainstorming, tasks completing in < 3 steps.
+
+## Protocol
+1. First checkpoint → ensure `.claude/sessions` is covered by `.gitignore`
+   (skip if `.claude/` or `.claude/sessions` already in gitignore), then create
+   `.claude/sessions/{YYMMDD-HHMM-desc}.md`
+2. Include `branch:{branch}` in header if in a git repo. Omit if not git.
+3. Update same file at each subsequent trigger. Silent — don't announce.
+4. Keep each section to 10 items max. Summarize older items if needed.
+5. On task completion → delete the checkpoint file.
+
+## Recovery
+If you recall working on a task but notice gaps in your prior context (earlier messages
+seem compressed or summarized), check `.claude/sessions/` for a matching checkpoint
+to restore state. Verify checkpoint has a `#` header and `## Next Action` before using.
+Say: "Resumed from checkpoint. Continuing..."
+Do NOT auto-load checkpoints in a fresh session — use `/recover` for cross-session.
+
+## Format
+```
+# {desc} | {command} | {phase} | branch:{branch}
+## Plan — {path or "none"}
+## Done — {bullets}
+## Pending — {bullets}
+## Decisions — {bullets}
+## Next Action — {exact step}
+## Files — Modified: {list} | Remaining: {list}
+```

package/rules-index.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "generatedAt": "2026-02-27T13:12:47.270Z",
+  "generatedAt": "2026-02-28T03:44:29.823Z",
   "templates": {
     "dart": {
       "path": "templates/dart/rules",

package/scripts/organize-rules.js

@@ -109,6 +109,7 @@ function organizeRules() {
   const stats = {};
 
   for (const ruleDir of rulesDirs) {
+    if (ruleDir === 'base') continue; // base rules handled by createBaseTemplate
     const srcDir = path.join(RULES_DIR, ruleDir);
     const tech = RULES_MAPPING[ruleDir] || ruleDir;
     const destDir = path.join(TEMPLATES_DIR, tech, 'rules', ruleDir);
@@ -171,6 +172,14 @@ function createBaseTemplate() {
   }
 
   console.log('  Created base template with essential hooks');
+
+  // Copy base rules from rules/base/ to templates/base/rules/
+  const baseRulesSource = path.join(RULES_DIR, 'base');
+  const baseRulesDest = path.join(baseDir, 'rules');
+  if (fs.existsSync(baseRulesSource)) {
+    const count = copyDir(baseRulesSource, baseRulesDest);
+    console.log(`  Copied ${count} base 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",