@ngxtm/devkit 3.19.0 → 3.21.0

package/skills/requesting-code-review/SKILL.md

@@ -7,14 +7,14 @@ source: community
 
 # Requesting Code Review
 
-Dispatch superpowers:code-reviewer subagent to catch issues before they cascade.
+Dispatch superpowers:code-reviewer Task agent to catch issues before they cascade.
 
 **Core principle:** Review early, review often.
 
 ## When to Request Review
 
 **Mandatory:**
-- After each task in subagent-driven development
+- After each task in Task agent-driven development
 - After completing major feature
 - Before merge to main
 
@@ -31,7 +31,7 @@ BASE_SHA=$(git rev-parse HEAD~1)  # or origin/main
 HEAD_SHA=$(git rev-parse HEAD)
 ```
 
-**2. Dispatch code-reviewer subagent:**
+**2. Dispatch code-reviewer Task agent:**
 
 Use Task tool with superpowers:code-reviewer type, fill template at `code-reviewer.md`
 
@@ -58,14 +58,14 @@ You: Let me request code review before proceeding.
 BASE_SHA=$(git log --oneline | grep "Task 1" | head -1 | awk '{print $1}')
 HEAD_SHA=$(git rev-parse HEAD)
 
-[Dispatch superpowers:code-reviewer subagent]
+[Dispatch superpowers:code-reviewer Task agent]
   WHAT_WAS_IMPLEMENTED: Verification and repair functions for conversation index
   PLAN_OR_REQUIREMENTS: Task 2 from docs/plans/deployment-plan.md
   BASE_SHA: a7981ec
   HEAD_SHA: 3df7661
   DESCRIPTION: Added verifyIndex() and repairIndex() with 4 issue types
 
-[Subagent returns]:
+[Task agent returns]:
   Strengths: Clean architecture, real tests
   Issues:
     Important: Missing progress indicators
@@ -78,7 +78,7 @@ You: [Fix progress indicators]
 
 ## Integration with Workflows
 
-**Subagent-Driven Development:**
+**Task Agent-Driven Development:**
 - Review after EACH task
 - Catch issues before they compound
 - Fix before moving to next task

package/skills/security-scanning-security-hardening/SKILL.md

@@ -36,19 +36,19 @@ Implement comprehensive security hardening with defense-in-depth strategy throug
 ## Phase 1: Comprehensive Security Assessment
 
 ### 1. Initial Vulnerability Scanning
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Perform comprehensive security assessment on: $ARGUMENTS. Execute SAST analysis with Semgrep/SonarQube, DAST scanning with OWASP ZAP, dependency audit with Snyk/Trivy, secrets detection with GitLeaks/TruffleHog. Generate SBOM for supply chain analysis. Identify OWASP Top 10 vulnerabilities, CWE weaknesses, and CVE exposures."
 - Output: Detailed vulnerability report with CVSS scores, exploitability analysis, attack surface mapping, secrets exposure report, SBOM inventory
 - Context: Initial baseline for all remediation efforts
 
 ### 2. Threat Modeling and Risk Analysis
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Conduct threat modeling using STRIDE methodology for: $ARGUMENTS. Analyze attack vectors, create attack trees, assess business impact of identified vulnerabilities. Map threats to MITRE ATT&CK framework. Prioritize risks based on likelihood and impact."
 - Output: Threat model diagrams, risk matrix with prioritized vulnerabilities, attack scenario documentation, business impact analysis
 - Context: Uses vulnerability scan results to inform threat priorities
 
 ### 3. Architecture Security Review
-- Use Task tool with subagent_type="backend-api-security::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Review architecture for security weaknesses in: $ARGUMENTS. Evaluate service boundaries, data flow security, authentication/authorization architecture, encryption implementation, network segmentation. Design zero-trust architecture patterns. Reference threat model and vulnerability findings."
 - Output: Security architecture assessment, zero-trust design recommendations, service mesh security requirements, data classification matrix
 - Context: Incorporates threat model to address architectural vulnerabilities
@@ -56,25 +56,25 @@ Implement comprehensive security hardening with defense-in-depth strategy throug
 ## Phase 2: Vulnerability Remediation
 
 ### 4. Critical Vulnerability Fixes
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Coordinate immediate remediation of critical vulnerabilities (CVSS 7+) in: $ARGUMENTS. Fix SQL injections with parameterized queries, XSS with output encoding, authentication bypasses with secure session management, insecure deserialization with input validation. Apply security patches for CVEs."
 - Output: Patched code with vulnerability fixes, security patch documentation, regression test requirements
 - Context: Addresses high-priority items from vulnerability assessment
 
 ### 5. Backend Security Hardening
-- Use Task tool with subagent_type="backend-api-security::backend-security-coder"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement comprehensive backend security controls for: $ARGUMENTS. Add input validation with OWASP ESAPI, implement rate limiting and DDoS protection, secure API endpoints with OAuth2/JWT validation, add encryption for data at rest/transit using AES-256/TLS 1.3. Implement secure logging without PII exposure."
 - Output: Hardened API endpoints, validation middleware, encryption implementation, secure configuration templates
 - Context: Builds upon vulnerability fixes with preventive controls
 
 ### 6. Frontend Security Implementation
-- Use Task tool with subagent_type="frontend-mobile-security::frontend-security-coder"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement frontend security measures for: $ARGUMENTS. Configure CSP headers with nonce-based policies, implement XSS prevention with DOMPurify, secure authentication flows with PKCE OAuth2, add SRI for external resources, implement secure cookie handling with SameSite/HttpOnly/Secure flags."
 - Output: Secure frontend components, CSP policy configuration, authentication flow implementation, security headers configuration
 - Context: Complements backend security with client-side protections
 
 ### 7. Mobile Security Hardening
-- Use Task tool with subagent_type="frontend-mobile-security::mobile-security-coder"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement mobile app security for: $ARGUMENTS. Add certificate pinning, implement biometric authentication, secure local storage with encryption, obfuscate code with ProGuard/R8, implement anti-tampering and root/jailbreak detection, secure IPC communications."
 - Output: Hardened mobile application, security configuration files, obfuscation rules, certificate pinning implementation
 - Context: Extends security to mobile platforms if applicable
@@ -82,19 +82,19 @@ Implement comprehensive security hardening with defense-in-depth strategy throug
 ## Phase 3: Security Controls Implementation
 
 ### 8. Authentication and Authorization Enhancement
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement modern authentication system for: $ARGUMENTS. Deploy OAuth2/OIDC with PKCE, implement MFA with TOTP/WebAuthn/FIDO2, add risk-based authentication, implement RBAC/ABAC with principle of least privilege, add session management with secure token rotation."
 - Output: Authentication service configuration, MFA implementation, authorization policies, session management system
 - Context: Strengthens access controls based on architecture review
 
 ### 9. Infrastructure Security Controls
-- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Deploy infrastructure security controls for: $ARGUMENTS. Configure WAF rules for OWASP protection, implement network segmentation with micro-segmentation, deploy IDS/IPS systems, configure cloud security groups and NACLs, implement DDoS protection with rate limiting and geo-blocking."
 - Output: WAF configuration, network security policies, IDS/IPS rules, cloud security configurations
 - Context: Implements network-level defenses
 
 ### 10. Secrets Management Implementation
-- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement enterprise secrets management for: $ARGUMENTS. Deploy HashiCorp Vault or AWS Secrets Manager, implement secret rotation policies, remove hardcoded secrets, configure least-privilege IAM roles, implement encryption key management with HSM support."
 - Output: Secrets management configuration, rotation policies, IAM role definitions, key management procedures
 - Context: Eliminates secrets exposure vulnerabilities
@@ -102,19 +102,19 @@ Implement comprehensive security hardening with defense-in-depth strategy throug
 ## Phase 4: Validation and Compliance
 
 ### 11. Penetration Testing and Validation
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Execute comprehensive penetration testing for: $ARGUMENTS. Perform authenticated and unauthenticated testing, API security testing, business logic testing, privilege escalation attempts. Use Burp Suite, Metasploit, and custom exploits. Validate all security controls effectiveness."
 - Output: Penetration test report, proof-of-concept exploits, remediation validation, security control effectiveness metrics
 - Context: Validates all implemented security measures
 
 ### 12. Compliance and Standards Verification
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Verify compliance with security frameworks for: $ARGUMENTS. Validate against OWASP ASVS Level 2, CIS Benchmarks, SOC2 Type II requirements, GDPR/CCPA privacy controls, HIPAA/PCI-DSS if applicable. Generate compliance attestation reports."
 - Output: Compliance assessment report, gap analysis, remediation requirements, audit evidence collection
 - Context: Ensures regulatory and industry standard compliance
 
 ### 13. Security Monitoring and SIEM Integration
-- Use Task tool with subagent_type="incident-response::devops-troubleshooter"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement security monitoring and SIEM for: $ARGUMENTS. Deploy Splunk/ELK/Sentinel integration, configure security event correlation, implement behavioral analytics for anomaly detection, set up automated incident response playbooks, create security dashboards and alerting."
 - Output: SIEM configuration, correlation rules, incident response playbooks, security dashboards, alert definitions
 - Context: Establishes continuous security monitoring

package/skills/subagent-driven-development/SKILL.md

@@ -5,11 +5,11 @@ risk: unknown
 source: community
 ---
 
-# Subagent-Driven Development
+# Task Agent-Driven Development
 
-Execute plan by dispatching fresh subagent per task, with two-stage review after each: spec compliance review first, then code quality review.
+Execute plan by dispatching fresh Task agent per task, with two-stage review after each: spec compliance review first, then code quality review.
 
-**Core principle:** Fresh subagent per task + two-stage review (spec then quality) = high quality, fast iteration
+**Core principle:** Fresh Task agent per task + two-stage review (spec then quality) = high quality, fast iteration
 
 ## When to Use
 
@@ -33,7 +33,7 @@ digraph when_to_use {
 
 **vs. Executing Plans (parallel session):**
 - Same session (no context switch)
-- Fresh subagent per task (no context pollution)
+- Fresh Task agent per task (no context pollution)
 - Two-stage review after each task: spec compliance first, then code quality
 - Faster iteration (no human-in-loop between tasks)
 
@@ -45,55 +45,55 @@ digraph process {
 
     subgraph cluster_per_task {
         label="Per Task";
-        "Dispatch implementer subagent (./implementer-prompt.md)" [shape=box];
-        "Implementer subagent asks questions?" [shape=diamond];
+        "Dispatch implementer Task agent (./implementer-prompt.md)" [shape=box];
+        "Implementer Task agent asks questions?" [shape=diamond];
         "Answer questions, provide context" [shape=box];
-        "Implementer subagent implements, tests, commits, self-reviews" [shape=box];
-        "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)" [shape=box];
-        "Spec reviewer subagent confirms code matches spec?" [shape=diamond];
-        "Implementer subagent fixes spec gaps" [shape=box];
-        "Dispatch code quality reviewer subagent (./code-quality-reviewer-prompt.md)" [shape=box];
-        "Code quality reviewer subagent approves?" [shape=diamond];
-        "Implementer subagent fixes quality issues" [shape=box];
+        "Implementer Task agent implements, tests, commits, self-reviews" [shape=box];
+        "Dispatch spec reviewer Task agent (./spec-reviewer-prompt.md)" [shape=box];
+        "Spec reviewer Task agent confirms code matches spec?" [shape=diamond];
+        "Implementer Task agent fixes spec gaps" [shape=box];
+        "Dispatch code quality reviewer Task agent (./code-quality-reviewer-prompt.md)" [shape=box];
+        "Code quality reviewer Task agent approves?" [shape=diamond];
+        "Implementer Task agent fixes quality issues" [shape=box];
         "Mark task complete in TodoWrite" [shape=box];
     }
 
     "Read plan, extract all tasks with full text, note context, create TodoWrite" [shape=box];
     "More tasks remain?" [shape=diamond];
-    "Dispatch final code reviewer subagent for entire implementation" [shape=box];
+    "Dispatch final code reviewer Task agent for entire implementation" [shape=box];
     "Use superpowers:finishing-a-development-branch" [shape=box style=filled fillcolor=lightgreen];
 
-    "Read plan, extract all tasks with full text, note context, create TodoWrite" -> "Dispatch implementer subagent (./implementer-prompt.md)";
-    "Dispatch implementer subagent (./implementer-prompt.md)" -> "Implementer subagent asks questions?";
-    "Implementer subagent asks questions?" -> "Answer questions, provide context" [label="yes"];
-    "Answer questions, provide context" -> "Dispatch implementer subagent (./implementer-prompt.md)";
-    "Implementer subagent asks questions?" -> "Implementer subagent implements, tests, commits, self-reviews" [label="no"];
-    "Implementer subagent implements, tests, commits, self-reviews" -> "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)";
-    "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)" -> "Spec reviewer subagent confirms code matches spec?";
-    "Spec reviewer subagent confirms code matches spec?" -> "Implementer subagent fixes spec gaps" [label="no"];
-    "Implementer subagent fixes spec gaps" -> "Dispatch spec reviewer subagent (./spec-reviewer-prompt.md)" [label="re-review"];
-    "Spec reviewer subagent confirms code matches spec?" -> "Dispatch code quality reviewer subagent (./code-quality-reviewer-prompt.md)" [label="yes"];
-    "Dispatch code quality reviewer subagent (./code-quality-reviewer-prompt.md)" -> "Code quality reviewer subagent approves?";
-    "Code quality reviewer subagent approves?" -> "Implementer subagent fixes quality issues" [label="no"];
-    "Implementer subagent fixes quality issues" -> "Dispatch code quality reviewer subagent (./code-quality-reviewer-prompt.md)" [label="re-review"];
-    "Code quality reviewer subagent approves?" -> "Mark task complete in TodoWrite" [label="yes"];
+    "Read plan, extract all tasks with full text, note context, create TodoWrite" -> "Dispatch implementer Task agent (./implementer-prompt.md)";
+    "Dispatch implementer Task agent (./implementer-prompt.md)" -> "Implementer Task agent asks questions?";
+    "Implementer Task agent asks questions?" -> "Answer questions, provide context" [label="yes"];
+    "Answer questions, provide context" -> "Dispatch implementer Task agent (./implementer-prompt.md)";
+    "Implementer Task agent asks questions?" -> "Implementer Task agent implements, tests, commits, self-reviews" [label="no"];
+    "Implementer Task agent implements, tests, commits, self-reviews" -> "Dispatch spec reviewer Task agent (./spec-reviewer-prompt.md)";
+    "Dispatch spec reviewer Task agent (./spec-reviewer-prompt.md)" -> "Spec reviewer Task agent confirms code matches spec?";
+    "Spec reviewer Task agent confirms code matches spec?" -> "Implementer Task agent fixes spec gaps" [label="no"];
+    "Implementer Task agent fixes spec gaps" -> "Dispatch spec reviewer Task agent (./spec-reviewer-prompt.md)" [label="re-review"];
+    "Spec reviewer Task agent confirms code matches spec?" -> "Dispatch code quality reviewer Task agent (./code-quality-reviewer-prompt.md)" [label="yes"];
+    "Dispatch code quality reviewer Task agent (./code-quality-reviewer-prompt.md)" -> "Code quality reviewer Task agent approves?";
+    "Code quality reviewer Task agent approves?" -> "Implementer Task agent fixes quality issues" [label="no"];
+    "Implementer Task agent fixes quality issues" -> "Dispatch code quality reviewer Task agent (./code-quality-reviewer-prompt.md)" [label="re-review"];
+    "Code quality reviewer Task agent approves?" -> "Mark task complete in TodoWrite" [label="yes"];
     "Mark task complete in TodoWrite" -> "More tasks remain?";
-    "More tasks remain?" -> "Dispatch implementer subagent (./implementer-prompt.md)" [label="yes"];
-    "More tasks remain?" -> "Dispatch final code reviewer subagent for entire implementation" [label="no"];
-    "Dispatch final code reviewer subagent for entire implementation" -> "Use superpowers:finishing-a-development-branch";
+    "More tasks remain?" -> "Dispatch implementer Task agent (./implementer-prompt.md)" [label="yes"];
+    "More tasks remain?" -> "Dispatch final code reviewer Task agent for entire implementation" [label="no"];
+    "Dispatch final code reviewer Task agent for entire implementation" -> "Use superpowers:finishing-a-development-branch";
 }
 ```
 
 ## Prompt Templates
 
-- `./implementer-prompt.md` - Dispatch implementer subagent
-- `./spec-reviewer-prompt.md` - Dispatch spec compliance reviewer subagent
-- `./code-quality-reviewer-prompt.md` - Dispatch code quality reviewer subagent
+- `./implementer-prompt.md` - Dispatch implementer Task agent
+- `./spec-reviewer-prompt.md` - Dispatch spec compliance reviewer Task agent
+- `./code-quality-reviewer-prompt.md` - Dispatch code quality reviewer Task agent
 
 ## Example Workflow
 
 ```
-You: I'm using Subagent-Driven Development to execute this plan.
+You: I'm using Task Agent-Driven Development to execute this plan.
 
 [Read plan file once: docs/plans/feature-plan.md]
 [Extract all 5 tasks with full text and context]
@@ -102,7 +102,7 @@ You: I'm using Subagent-Driven Development to execute this plan.
 Task 1: Hook installation script
 
 [Get Task 1 text and context (already extracted)]
-[Dispatch implementation subagent with full task text + context]
+[Dispatch implementation Task agent with full task text + context]
 
 Implementer: "Before I begin - should the hook be installed at user or system level?"
 
@@ -126,7 +126,7 @@ Code reviewer: Strengths: Good test coverage, clean. Issues: None. Approved.
 Task 2: Recovery modes
 
 [Get Task 2 text and context (already extracted)]
-[Dispatch implementation subagent with full task text + context]
+[Dispatch implementation Task agent with full task text + context]
 
 Implementer: [No questions, proceeds]
 Implementer:
@@ -169,10 +169,10 @@ Done!
 ## Advantages
 
 **vs. Manual execution:**
-- Subagents follow TDD naturally
+- Task agents follow TDD naturally
 - Fresh context per task (no confusion)
-- Parallel-safe (subagents don't interfere)
-- Subagent can ask questions (before AND during work)
+- Parallel-safe (Task agents don't interfere)
+- Task agent can ask questions (before AND during work)
 
 **vs. Executing Plans:**
 - Same session (no handoff)
@@ -182,7 +182,7 @@ Done!
 **Efficiency gains:**
 - No file reading overhead (controller provides full text)
 - Controller curates exactly what context is needed
-- Subagent gets complete information upfront
+- Task agent gets complete information upfront
 - Questions surfaced before work begins (not after)
 
 **Quality gates:**
@@ -193,7 +193,7 @@ Done!
 - Code quality ensures implementation is well-built
 
 **Cost:**
-- More subagent invocations (implementer + 2 reviewers per task)
+- More Task agent invocations (implementer + 2 reviewers per task)
 - Controller does more prep work (extracting all tasks upfront)
 - Review loops add iterations
 - But catches issues early (cheaper than debugging later)
@@ -203,40 +203,40 @@ Done!
 **Never:**
 - Skip reviews (spec compliance OR code quality)
 - Proceed with unfixed issues
-- Dispatch multiple implementation subagents in parallel (conflicts)
-- Make subagent read plan file (provide full text instead)
-- Skip scene-setting context (subagent needs to understand where task fits)
-- Ignore subagent questions (answer before letting them proceed)
+- Dispatch multiple implementation Task agents in parallel (conflicts)
+- Make Task agent read plan file (provide full text instead)
+- Skip scene-setting context (Task agent needs to understand where task fits)
+- Ignore Task agent questions (answer before letting them proceed)
 - Accept "close enough" on spec compliance (spec reviewer found issues = not done)
 - Skip review loops (reviewer found issues = implementer fixes = review again)
 - Let implementer self-review replace actual review (both are needed)
 - **Start code quality review before spec compliance is ✅** (wrong order)
 - Move to next task while either review has open issues
 
-**If subagent asks questions:**
+**If Task agent asks questions:**
 - Answer clearly and completely
 - Provide additional context if needed
 - Don't rush them into implementation
 
 **If reviewer finds issues:**
-- Implementer (same subagent) fixes them
+- Implementer (same Task agent) fixes them
 - Reviewer reviews again
 - Repeat until approved
 - Don't skip the re-review
 
-**If subagent fails task:**
-- Dispatch fix subagent with specific instructions
+**If Task agent fails task:**
+- Dispatch fix Task agent with specific instructions
 - Don't try to fix manually (context pollution)
 
 ## Integration
 
 **Required workflow skills:**
 - **superpowers:writing-plans** - Creates the plan this skill executes
-- **superpowers:requesting-code-review** - Code review template for reviewer subagents
+- **superpowers:requesting-code-review** - Code review template for reviewer Task agents
 - **superpowers:finishing-a-development-branch** - Complete development after all tasks
 
-**Subagents should use:**
-- **superpowers:test-driven-development** - Subagents follow TDD for each task
+**Task agents should use:**
+- **superpowers:test-driven-development** - Task agents follow TDD for each task
 
 **Alternative workflow:**
 - **superpowers:executing-plans** - Use for parallel session instead of same-session execution

package/skills/subagent-driven-development/code-quality-reviewer-prompt.md

@@ -1,6 +1,6 @@
 # Code Quality Reviewer Prompt Template
 
-Use this template when dispatching a code quality reviewer subagent.
+Use this template when dispatching a code quality reviewer Task agent.
 
 **Purpose:** Verify implementation is well-built (clean, tested, maintainable)
 

package/skills/subagent-driven-development/implementer-prompt.md

@@ -1,6 +1,6 @@
-# Implementer Subagent Prompt Template
+# Implementer Task Agent Prompt Template
 
-Use this template when dispatching an implementer subagent.
+Use this template when dispatching an implementer Task agent.
 
 ```
 Task tool (general-purpose):
@@ -10,7 +10,7 @@ Task tool (general-purpose):
 
     ## Task Description
 
-    [FULL TEXT of task from plan - paste it here, don't make subagent read file]
+    [FULL TEXT of task from plan - paste it here, don't make Task agent read file]
 
     ## Context
 

package/skills/subagent-driven-development/spec-reviewer-prompt.md

@@ -1,6 +1,6 @@
 # Spec Compliance Reviewer Prompt Template
 
-Use this template when dispatching a spec compliance reviewer subagent.
+Use this template when dispatching a spec compliance reviewer Task agent.
 
 **Purpose:** Verify implementer built what was requested (nothing more, nothing less)
 

package/skills/tdd-workflows-tdd-cycle/SKILL.md

@@ -42,13 +42,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 1: Test Specification and Design
 
 ### 1. Requirements Analysis
-- Use Task tool with subagent_type="comprehensive-review::architect-review"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze requirements for: $ARGUMENTS. Define acceptance criteria, identify edge cases, and create test scenarios. Output a comprehensive test specification."
 - Output: Test specification, acceptance criteria, edge case matrix
 - Validation: Ensure all requirements have corresponding test scenarios
 
 ### 2. Test Architecture Design
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Design test architecture for: $ARGUMENTS based on test specification. Define test structure, fixtures, mocks, and test data strategy. Ensure testability and maintainability."
 - Output: Test architecture, fixture design, mock strategy
 - Validation: Architecture supports isolated, fast, reliable tests
@@ -56,13 +56,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 2: RED - Write Failing Tests
 
 ### 3. Write Unit Tests (Failing)
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Write FAILING unit tests for: $ARGUMENTS. Tests must fail initially. Include edge cases, error scenarios, and happy paths. DO NOT implement production code."
 - Output: Failing unit tests, test documentation
 - **CRITICAL**: Verify all tests fail with expected error messages
 
 ### 4. Verify Test Failure
-- Use Task tool with subagent_type="tdd-workflows::code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Verify that all tests for: $ARGUMENTS are failing correctly. Ensure failures are for the right reasons (missing implementation, not test errors). Confirm no false positives."
 - Output: Test failure verification report
 - **GATE**: Do not proceed until all tests fail appropriately
@@ -70,13 +70,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 3: GREEN - Make Tests Pass
 
 ### 5. Minimal Implementation
-- Use Task tool with subagent_type="backend-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement MINIMAL code to make tests pass for: $ARGUMENTS. Focus only on making tests green. Do not add extra features or optimizations. Keep it simple."
 - Output: Minimal working implementation
 - Constraint: No code beyond what's needed to pass tests
 
 ### 6. Verify Test Success
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Run all tests for: $ARGUMENTS and verify they pass. Check test coverage metrics. Ensure no tests were accidentally broken."
 - Output: Test execution report, coverage metrics
 - **GATE**: All tests must pass before proceeding
@@ -84,13 +84,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 4: REFACTOR - Improve Code Quality
 
 ### 7. Code Refactoring
-- Use Task tool with subagent_type="tdd-workflows::code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Refactor implementation for: $ARGUMENTS while keeping tests green. Apply SOLID principles, remove duplication, improve naming, and optimize performance. Run tests after each refactoring."
 - Output: Refactored code, refactoring report
 - Constraint: Tests must remain green throughout
 
 ### 8. Test Refactoring
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Refactor tests for: $ARGUMENTS. Remove test duplication, improve test names, extract common fixtures, and enhance test readability. Ensure tests still provide same coverage."
 - Output: Refactored tests, improved test structure
 - Validation: Coverage metrics unchanged or improved
@@ -98,13 +98,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 5: Integration and System Tests
 
 ### 9. Write Integration Tests (Failing First)
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Write FAILING integration tests for: $ARGUMENTS. Test component interactions, API contracts, and data flow. Tests must fail initially."
 - Output: Failing integration tests
 - Validation: Tests fail due to missing integration logic
 
 ### 10. Implement Integration
-- Use Task tool with subagent_type="backend-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement integration code for: $ARGUMENTS to make integration tests pass. Focus on component interaction and data flow."
 - Output: Integration implementation
 - Validation: All integration tests pass
@@ -112,13 +112,13 @@ Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-g
 ## Phase 6: Continuous Improvement Cycle
 
 ### 11. Performance and Edge Case Tests
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Add performance tests and additional edge case tests for: $ARGUMENTS. Include stress tests, boundary tests, and error recovery tests."
 - Output: Extended test suite
 - Metric: Increased test coverage and scenario coverage
 
 ### 12. Final Code Review
-- Use Task tool with subagent_type="comprehensive-review::architect-review"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Perform comprehensive review of: $ARGUMENTS. Verify TDD process was followed, check code quality, test quality, and coverage. Suggest improvements."
 - Output: Review report, improvement suggestions
 - Action: Implement critical suggestions while maintaining green tests

package/skills/tdd-workflows-tdd-green/resources/implementation-playbook.md

@@ -32,7 +32,7 @@ Implement minimal code to make failing tests pass in TDD green phase:
 
 ## Implementation Process
 
-Use Task tool with subagent_type="unit-testing::test-automator" to implement minimal passing code.
+Use Task tool with subagent_type="general-purpose" to implement minimal passing code.
 
 Prompt: "Implement MINIMAL code to make these failing tests pass: $ARGUMENTS. Follow TDD green phase principles:
 

package/skills/tdd-workflows-tdd-red/SKILL.md

@@ -35,7 +35,7 @@ Write comprehensive failing tests following TDD red phase principles.
 
 ## Role
 
-Generate failing tests using Task tool with subagent_type="unit-testing::test-automator".
+Generate failing tests using Task tool with subagent_type="general-purpose".
 
 ## Prompt Template
 

package/skills/tdd-workflows-tdd-refactor/SKILL.md

@@ -28,7 +28,7 @@ Refactor code with confidence using comprehensive test safety net:
 
 ## Usage
 
-Use Task tool with subagent_type="tdd-orchestrator" to perform safe refactoring.
+Use Task tool with subagent_type="general-purpose" to perform safe refactoring.
 
 Prompt: "Refactor this code while keeping all tests green: $ARGUMENTS. Apply TDD refactor phase:
 

package/skills/typescript-expert/SKILL.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/skills/writing-plans/SKILL.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/skills/writing-skills/SKILL.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/skills/writing-skills/examples/CLAUDE_MD_TESTING.md

@@ -181,7 +181,7 @@ For each variant:
 
 ## Next Steps
 
-1. Create subagent test harness
+1. Create Task agent test harness
 2. Run NULL baseline on all 4 scenarios
 3. Test each variant on same scenarios
 4. Compare compliance rates