@ngxtm/devkit 3.19.0 → 3.20.0

package/skills/framework-migration-legacy-modernize/SKILL.md

@@ -31,18 +31,18 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 1: Legacy Assessment and Risk Analysis
 
 ### 1. Comprehensive Legacy System Analysis
-- Use Task tool with subagent_type="legacy-modernizer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze the legacy codebase at $ARGUMENTS. Document technical debt inventory including: outdated dependencies, deprecated APIs, security vulnerabilities, performance bottlenecks, and architectural anti-patterns. Generate a modernization readiness report with component complexity scores (1-10), dependency mapping, and database coupling analysis. Identify quick wins vs complex refactoring targets."
 - Expected output: Detailed assessment report with risk matrix and modernization priorities
 
 ### 2. Dependency and Integration Mapping
-- Use Task tool with subagent_type="architect-review"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Based on the legacy assessment report, create a comprehensive dependency graph showing: internal module dependencies, external service integrations, shared database schemas, and cross-system data flows. Identify integration points that will require facade patterns or adapter layers during migration. Highlight circular dependencies and tight coupling that need resolution."
 - Context from previous: Legacy assessment report, component complexity scores
 - Expected output: Visual dependency map and integration point catalog
 
 ### 3. Business Impact and Risk Assessment
-- Use Task tool with subagent_type="business-analytics::business-analyst"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Evaluate business impact of modernizing each component identified. Create risk assessment matrix considering: business criticality (revenue impact), user traffic patterns, data sensitivity, regulatory requirements, and fallback complexity. Prioritize components using a weighted scoring system: (Business Value × 0.4) + (Technical Risk × 0.3) + (Quick Win Potential × 0.3). Define rollback strategies for each component."
 - Context from previous: Component inventory, dependency mapping
 - Expected output: Prioritized migration roadmap with risk mitigation strategies
@@ -50,18 +50,18 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 2: Test Coverage Establishment
 
 ### 1. Legacy Code Test Coverage Analysis
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze existing test coverage for legacy components at $ARGUMENTS. Use coverage tools to identify untested code paths, missing integration tests, and absent end-to-end scenarios. For components with <40% coverage, generate characterization tests that capture current behavior without modifying functionality. Create test harness for safe refactoring."
 - Expected output: Test coverage report and characterization test suite
 
 ### 2. Contract Testing Implementation
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement contract tests for all integration points identified in dependency mapping. Create consumer-driven contracts for APIs, message queue interactions, and database schemas. Set up contract verification in CI/CD pipeline. Generate performance baselines for response times and throughput to validate modernized components maintain SLAs."
 - Context from previous: Integration point catalog, existing test coverage
 - Expected output: Contract test suite with performance baselines
 
 ### 3. Test Data Management Strategy
-- Use Task tool with subagent_type="data-engineering::data-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Design test data management strategy for parallel system operation. Create data generation scripts for edge cases, implement data masking for sensitive information, and establish test database refresh procedures. Set up monitoring for data consistency between legacy and modernized components during migration."
 - Context from previous: Database schemas, test requirements
 - Expected output: Test data pipeline and consistency monitoring
@@ -69,18 +69,18 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 3: Incremental Migration Implementation
 
 ### 1. Strangler Fig Infrastructure Setup
-- Use Task tool with subagent_type="backend-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement strangler fig infrastructure with API gateway for traffic routing. Configure feature flags for gradual rollout using environment variables or feature management service. Set up proxy layer with request routing rules based on: URL patterns, headers, or user segments. Implement circuit breakers and fallback mechanisms for resilience. Create observability dashboard for dual-system monitoring."
 - Expected output: API gateway configuration, feature flag system, monitoring dashboard
 
 ### 2. Component Modernization - First Wave
-- Use Task tool with subagent_type="python-development::python-pro" or "golang-pro" (based on target stack)
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Modernize first-wave components (quick wins identified in assessment). For each component: extract business logic from legacy code, implement using modern patterns (dependency injection, SOLID principles), ensure backward compatibility through adapter patterns, maintain data consistency with event sourcing or dual writes. Follow 12-factor app principles. Components to modernize: [list from prioritized roadmap]"
 - Context from previous: Characterization tests, contract tests, infrastructure setup
 - Expected output: Modernized components with adapters
 
 ### 3. Security Hardening
-- Use Task tool with subagent_type="security-scanning::security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Audit modernized components for security vulnerabilities. Implement security improvements including: OAuth 2.0/JWT authentication, role-based access control, input validation and sanitization, SQL injection prevention, XSS protection, and secrets management. Verify OWASP top 10 compliance. Configure security headers and implement rate limiting."
 - Context from previous: Modernized component code
 - Expected output: Security audit report and hardened components
@@ -88,13 +88,13 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 4: Performance Validation and Optimization
 
 ### 1. Performance Testing and Optimization
-- Use Task tool with subagent_type="application-performance::performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Conduct performance testing comparing legacy vs modernized components. Run load tests simulating production traffic patterns, measure response times, throughput, and resource utilization. Identify performance regressions and optimize: database queries with indexing, caching strategies (Redis/Memcached), connection pooling, and async processing where applicable. Validate against SLA requirements."
 - Context from previous: Performance baselines, modernized components
 - Expected output: Performance test results and optimization recommendations
 
 ### 2. Progressive Rollout and Monitoring
-- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement progressive rollout strategy using feature flags. Start with 5% traffic to modernized components, monitor error rates, latency, and business metrics. Define automatic rollback triggers: error rate >1%, latency >2x baseline, or business metric degradation. Create runbook for traffic shifting: 5% → 25% → 50% → 100% with 24-hour observation periods."
 - Context from previous: Feature flag configuration, monitoring dashboard
 - Expected output: Rollout plan with automated safeguards
@@ -102,13 +102,13 @@ Orchestrate a comprehensive legacy system modernization using the strangler fig
 ## Phase 5: Migration Completion and Documentation
 
 ### 1. Legacy Component Decommissioning
-- Use Task tool with subagent_type="legacy-modernizer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Plan safe decommissioning of replaced legacy components. Verify no remaining dependencies through traffic analysis (minimum 30 days at 0% traffic). Archive legacy code with documentation of original functionality. Update CI/CD pipelines to remove legacy builds. Clean up unused database tables and remove deprecated API endpoints. Document any retained legacy components with sunset timeline."
 - Context from previous: Traffic routing data, modernization status
 - Expected output: Decommissioning checklist and timeline
 
 ### 2. Documentation and Knowledge Transfer
-- Use Task tool with subagent_type="documentation-generation::docs-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Create comprehensive modernization documentation including: architectural diagrams (before/after), API documentation with migration guides, runbooks for dual-system operation, troubleshooting guides for common issues, and lessons learned report. Generate developer onboarding guide for modernized system. Document technical decisions and trade-offs made during migration."
 - Context from previous: All migration artifacts and decisions
 - Expected output: Complete modernization documentation package

package/skills/full-stack-orchestration-full-stack-feature/SKILL.md

@@ -29,19 +29,19 @@ Orchestrate full-stack feature development across backend, frontend, and infrast
 ## Phase 1: Architecture & Design Foundation
 
 ### 1. Database Architecture Design
-- Use Task tool with subagent_type="database-design::database-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Design database schema and data models for: $ARGUMENTS. Consider scalability, query patterns, indexing strategy, and data consistency requirements. Include migration strategy if modifying existing schema. Provide both logical and physical data models."
 - Expected output: Entity relationship diagrams, table schemas, indexing strategy, migration scripts, data access patterns
 - Context: Initial requirements and business domain model
 
 ### 2. Backend Service Architecture
-- Use Task tool with subagent_type="backend-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Design backend service architecture for: $ARGUMENTS. Using the database design from previous step, create service boundaries, define API contracts (OpenAPI/GraphQL), design authentication/authorization strategy, and specify inter-service communication patterns. Include resilience patterns (circuit breakers, retries) and caching strategy."
 - Expected output: Service architecture diagram, OpenAPI specifications, authentication flows, caching architecture, message queue design (if applicable)
 - Context: Database schema from step 1, non-functional requirements
 
 ### 3. Frontend Component Architecture
-- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Design frontend architecture and component structure for: $ARGUMENTS. Based on the API contracts from previous step, design component hierarchy, state management approach (Redux/Zustand/Context), routing structure, and data fetching patterns. Include accessibility requirements and responsive design strategy. Plan for Storybook component documentation."
 - Expected output: Component tree diagram, state management design, routing configuration, design system integration plan, accessibility checklist
 - Context: API specifications from step 2, UI/UX requirements
@@ -49,19 +49,19 @@ Orchestrate full-stack feature development across backend, frontend, and infrast
 ## Phase 2: Parallel Implementation
 
 ### 4. Backend Service Implementation
-- Use Task tool with subagent_type="python-development::python-pro" (or "golang-pro"/"nodejs-expert" based on stack)
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement backend services for: $ARGUMENTS. Using the architecture and API specs from Phase 1, build RESTful/GraphQL endpoints with proper validation, error handling, and logging. Implement business logic, data access layer, authentication middleware, and integration with external services. Include observability (structured logging, metrics, tracing)."
 - Expected output: Backend service code, API endpoints, middleware, background jobs, unit tests, integration tests
 - Context: Architecture designs from Phase 1, database schema
 
 ### 5. Frontend Implementation
-- Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement frontend application for: $ARGUMENTS. Build React/Next.js components using the component architecture from Phase 1. Implement state management, API integration with proper error handling and loading states, form validation, and responsive layouts. Create Storybook stories for components. Ensure accessibility (WCAG 2.1 AA compliance)."
 - Expected output: React components, state management implementation, API client code, Storybook stories, responsive styles, accessibility implementations
 - Context: Component architecture from step 3, API contracts
 
 ### 6. Database Implementation & Optimization
-- Use Task tool with subagent_type="database-design::sql-pro"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement and optimize database layer for: $ARGUMENTS. Create migration scripts, stored procedures (if needed), optimize queries identified by backend implementation, set up proper indexes, and implement data validation constraints. Include database-level security measures and backup strategies."
 - Expected output: Migration scripts, optimized queries, stored procedures, index definitions, database security configuration
 - Context: Database design from step 1, query patterns from backend implementation
@@ -69,19 +69,19 @@ Orchestrate full-stack feature development across backend, frontend, and infrast
 ## Phase 3: Integration & Testing
 
 ### 7. API Contract Testing
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Create contract tests for: $ARGUMENTS. Implement Pact/Dredd tests to validate API contracts between backend and frontend. Create integration tests for all API endpoints, test authentication flows, validate error responses, and ensure proper CORS configuration. Include load testing scenarios."
 - Expected output: Contract test suites, integration tests, load test scenarios, API documentation validation
 - Context: API implementations from Phase 2
 
 ### 8. End-to-End Testing
-- Use Task tool with subagent_type="test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement E2E tests for: $ARGUMENTS. Create Playwright/Cypress tests covering critical user journeys, cross-browser compatibility, mobile responsiveness, and error scenarios. Test feature flags integration, analytics tracking, and performance metrics. Include visual regression tests."
 - Expected output: E2E test suites, visual regression baselines, performance benchmarks, test reports
 - Context: Frontend and backend implementations from Phase 2
 
 ### 9. Security Audit & Hardening
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Perform security audit for: $ARGUMENTS. Review API security (authentication, authorization, rate limiting), check for OWASP Top 10 vulnerabilities, audit frontend for XSS/CSRF risks, validate input sanitization, and review secrets management. Provide penetration testing results and remediation steps."
 - Expected output: Security audit report, vulnerability assessment, remediation recommendations, security headers configuration
 - Context: All implementations from Phase 2
@@ -89,19 +89,19 @@ Orchestrate full-stack feature development across backend, frontend, and infrast
 ## Phase 4: Deployment & Operations
 
 ### 10. Infrastructure & CI/CD Setup
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Setup deployment infrastructure for: $ARGUMENTS. Create Docker containers, Kubernetes manifests (or cloud-specific configs), implement CI/CD pipelines with automated testing gates, setup feature flags (LaunchDarkly/Unleash), and configure monitoring/alerting. Include blue-green deployment strategy and rollback procedures."
 - Expected output: Dockerfiles, K8s manifests, CI/CD pipeline configs, feature flag setup, IaC templates (Terraform/CloudFormation)
 - Context: All implementations and tests from previous phases
 
 ### 11. Observability & Monitoring
-- Use Task tool with subagent_type="deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement observability stack for: $ARGUMENTS. Setup distributed tracing (OpenTelemetry), configure application metrics (Prometheus/DataDog), implement centralized logging (ELK/Splunk), create dashboards for key metrics, and define SLIs/SLOs. Include alerting rules and on-call procedures."
 - Expected output: Observability configuration, dashboard definitions, alert rules, runbooks, SLI/SLO definitions
 - Context: Infrastructure setup from step 10
 
 ### 12. Performance Optimization
-- Use Task tool with subagent_type="performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Optimize performance across stack for: $ARGUMENTS. Analyze and optimize database queries, implement caching strategies (Redis/CDN), optimize frontend bundle size and loading performance, setup lazy loading and code splitting, and tune backend service performance. Include before/after metrics."
 - Expected output: Performance improvements, caching configuration, CDN setup, optimized bundles, performance metrics report
 - Context: Monitoring data from step 11, load test results

package/skills/git-pr-workflows-git-workflow/SKILL.md

@@ -44,12 +44,12 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 1: Pre-Commit Review and Analysis
 
 ### 1. Code Quality Assessment
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Review all uncommitted changes for code quality issues. Check for: 1) Code style violations, 2) Security vulnerabilities, 3) Performance concerns, 4) Missing error handling, 5) Incomplete implementations. Generate a detailed report with severity levels (critical/high/medium/low) and provide specific line-by-line feedback. Output format: JSON with {issues: [], summary: {critical: 0, high: 0, medium: 0, low: 0}, recommendations: []}"
 - Expected output: Structured code review report for next phase
 
 ### 2. Dependency and Breaking Change Analysis
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze the changes for: 1) New dependencies or version changes, 2) Breaking API changes, 3) Database schema modifications, 4) Configuration changes, 5) Backward compatibility issues. Context from previous review: [insert issues summary]. Identify any changes that require migration scripts or documentation updates."
 - Context from previous: Code quality issues that might indicate breaking changes
 - Expected output: Breaking change assessment and migration requirements
@@ -57,13 +57,13 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 2: Testing and Validation
 
 ### 1. Test Execution and Coverage
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Execute all test suites for the modified code. Run: 1) Unit tests, 2) Integration tests, 3) End-to-end tests if applicable. Generate coverage report and identify any untested code paths. Based on review issues: [insert critical/high issues], ensure tests cover the problem areas. Provide test results in format: {passed: [], failed: [], skipped: [], coverage: {statements: %, branches: %, functions: %, lines: %}, untested_critical_paths: []}"
 - Context from previous: Critical code review issues that need test coverage
 - Expected output: Complete test results and coverage metrics
 
 ### 2. Test Recommendations and Gap Analysis
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Based on test results [insert summary] and code changes, identify: 1) Missing test scenarios, 2) Edge cases not covered, 3) Integration points needing verification, 4) Performance benchmarks needed. Generate test implementation recommendations prioritized by risk. Consider the breaking changes identified: [insert breaking changes]."
 - Context from previous: Test results, breaking changes, untested paths
 - Expected output: Prioritized list of additional tests needed
@@ -71,13 +71,13 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 3: Commit Message Generation
 
 ### 1. Change Analysis and Categorization
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze all changes and categorize them according to Conventional Commits specification. Identify the primary change type (feat/fix/docs/style/refactor/perf/test/build/ci/chore/revert) and scope. For changes: [insert file list and summary], determine if this should be a single commit or multiple atomic commits. Consider test results: [insert test summary]."
 - Context from previous: Test results, code review summary
 - Expected output: Commit structure recommendation
 
 ### 2. Conventional Commit Message Creation
-- Use Task tool with subagent_type="llm-application-dev::prompt-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Create Conventional Commits format message(s) based on categorization: [insert categorization]. Format: <type>(<scope>): <subject> with blank line then <body> explaining what and why (not how), then <footer> with BREAKING CHANGE: if applicable. Include: 1) Clear subject line (50 chars max), 2) Detailed body explaining rationale, 3) References to issues/tickets, 4) Co-authors if applicable. Consider the impact: [insert breaking changes if any]."
 - Context from previous: Change categorization, breaking changes
 - Expected output: Properly formatted commit message(s)
@@ -85,12 +85,12 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 4: Branch Strategy and Push Preparation
 
 ### 1. Branch Management
-- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Based on workflow type [--trunk-based or --feature-branch], prepare branch strategy. For feature branch: ensure branch name follows pattern (feature|bugfix|hotfix)/<ticket>-<description>. For trunk-based: prepare for direct main push with feature flag strategy if needed. Current branch: [insert branch], target: [insert target branch]. Verify no conflicts with target branch."
 - Expected output: Branch preparation commands and conflict status
 
 ### 2. Pre-Push Validation
-- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Perform final pre-push checks: 1) Verify all CI checks will pass, 2) Confirm no sensitive data in commits, 3) Validate commit signatures if required, 4) Check branch protection rules, 5) Ensure all review comments addressed. Test summary: [insert test results]. Review status: [insert review summary]."
 - Context from previous: All previous validation results
 - Expected output: Push readiness confirmation or blocking issues
@@ -98,13 +98,13 @@ Orchestrate a comprehensive git workflow from code review through PR creation, l
 ## Phase 5: Pull Request Creation
 
 ### 1. PR Description Generation
-- Use Task tool with subagent_type="documentation-generation::docs-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Create comprehensive PR description including: 1) Summary of changes (what and why), 2) Type of change checklist, 3) Testing performed summary from [insert test results], 4) Screenshots/recordings if UI changes, 5) Deployment notes from [insert deployment considerations], 6) Related issues/tickets, 7) Breaking changes section if applicable: [insert breaking changes], 8) Reviewer checklist. Format as GitHub-flavored Markdown."
 - Context from previous: All validation results, test outcomes, breaking changes
 - Expected output: Complete PR description in Markdown
 
 ### 2. PR Metadata and Automation Setup
-- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Configure PR metadata: 1) Assign appropriate reviewers based on CODEOWNERS, 2) Add labels (type, priority, component), 3) Link related issues, 4) Set milestone if applicable, 5) Configure merge strategy (squash/merge/rebase), 6) Set up auto-merge if all checks pass. Consider draft status: [--draft-pr flag]. Include test status: [insert test summary]."
 - Context from previous: PR description, test results, review status
 - Expected output: PR configuration commands and automation rules

package/skills/google-adk-python/SKILL.md

@@ -25,7 +25,7 @@ Use this skill when users need to:
 
 **LlmAgent**: LLM-powered agents capable of dynamic routing and adaptive behavior
 - Define with name, model, instruction, description, and tools
-- Supports sub-agents for delegation and coordination
+- Supports Task agents for delegation and coordination
 - Intelligent decision-making based on context
 
 **Workflow Agents**: Structured, predictable orchestration patterns

package/skills/hr-pro/SKILL.md

@@ -27,7 +27,7 @@ source: community
 - Provide actionable steps and verification.
 - If detailed examples are required, open `resources/implementation-playbook.md`.
 
-You are **HR-Pro**, a professional, employee-centered and compliance-aware Human Resources subagent for Claude Code.
+You are **HR-Pro**, a professional, employee-centered and compliance-aware Human Resources Task agent for Claude Code.
 
 ## IMPORTANT LEGAL DISCLAIMER
 - **NOT LEGAL ADVICE.** HR-Pro provides general HR information and templates only and does not create an attorney–client relationship.

package/skills/incident-response-incident-response/SKILL.md

@@ -45,19 +45,19 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 ## Phase 1: Detection & Triage
 
 ### 1. Incident Detection and Classification
-- Use Task tool with subagent_type="incident-responder"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "URGENT: Detect and classify incident: $ARGUMENTS. Analyze alerts from PagerDuty/Opsgenie/monitoring. Determine: 1) Incident severity (P0-P3), 2) Affected services and dependencies, 3) User impact and business risk, 4) Initial incident command structure needed. Check error budgets and SLO violations."
 - Output: Severity classification, impact assessment, incident command assignments, SLO status
 - Context: Initial alerts, monitoring dashboards, recent changes
 
 ### 2. Observability Analysis
-- Use Task tool with subagent_type="observability-monitoring::observability-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Perform rapid observability sweep for incident: $ARGUMENTS. Query: 1) Distributed tracing (OpenTelemetry/Jaeger), 2) Metrics correlation (Prometheus/Grafana/DataDog), 3) Log aggregation (ELK/Splunk), 4) APM data, 5) Real User Monitoring. Identify anomalies, error patterns, and service degradation points."
 - Output: Observability findings, anomaly detection, service health matrix, trace analysis
 - Context: Severity level from step 1, affected services
 
 ### 3. Initial Mitigation
-- Use Task tool with subagent_type="incident-responder"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Implement immediate mitigation for P$SEVERITY incident: $ARGUMENTS. Actions: 1) Traffic throttling/rerouting if needed, 2) Feature flag disabling for affected features, 3) Circuit breaker activation, 4) Rollback assessment for recent deployments, 5) Scale resources if capacity-related. Prioritize user experience restoration."
 - Output: Mitigation actions taken, temporary fixes applied, rollback decisions
 - Context: Observability findings, severity classification
@@ -65,19 +65,19 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 ## Phase 2: Investigation & Root Cause Analysis
 
 ### 4. Deep System Debugging
-- Use Task tool with subagent_type="error-debugging::debugger"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Conduct deep debugging for incident: $ARGUMENTS using observability data. Investigate: 1) Stack traces and error logs, 2) Database query performance and locks, 3) Network latency and timeouts, 4) Memory leaks and CPU spikes, 5) Dependency failures and cascading errors. Apply Five Whys analysis."
 - Output: Root cause identification, contributing factors, dependency impact map
 - Context: Observability analysis, mitigation status
 
 ### 5. Security Assessment
-- Use Task tool with subagent_type="security-scanning::security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Assess security implications of incident: $ARGUMENTS. Check: 1) DDoS attack indicators, 2) Authentication/authorization failures, 3) Data exposure risks, 4) Certificate issues, 5) Suspicious access patterns. Review WAF logs, security groups, and audit trails."
 - Output: Security assessment, breach analysis, vulnerability identification
 - Context: Root cause findings, system logs
 
 ### 6. Performance Engineering Analysis
-- Use Task tool with subagent_type="application-performance::performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Analyze performance aspects of incident: $ARGUMENTS. Examine: 1) Resource utilization patterns, 2) Query optimization opportunities, 3) Caching effectiveness, 4) Load balancer health, 5) CDN performance, 6) Autoscaling triggers. Identify bottlenecks and capacity issues."
 - Output: Performance bottlenecks, resource recommendations, optimization opportunities
 - Context: Debug findings, current mitigation state
@@ -85,13 +85,13 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 ## Phase 3: Resolution & Recovery
 
 ### 7. Fix Implementation
-- Use Task tool with subagent_type="backend-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Design and implement production fix for incident: $ARGUMENTS based on root cause. Requirements: 1) Minimal viable fix for rapid deployment, 2) Risk assessment and rollback capability, 3) Staged rollout plan with monitoring, 4) Validation criteria and health checks. Consider both immediate fix and long-term solution."
 - Output: Fix implementation, deployment strategy, validation plan, rollback procedures
 - Context: Root cause analysis, performance findings, security assessment
 
 ### 8. Deployment and Validation
-- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Execute emergency deployment for incident fix: $ARGUMENTS. Process: 1) Blue-green or canary deployment, 2) Progressive rollout with monitoring, 3) Health check validation at each stage, 4) Rollback triggers configured, 5) Real-time monitoring during deployment. Coordinate with incident command."
 - Output: Deployment status, validation results, monitoring dashboard, rollback readiness
 - Context: Fix implementation, current system state
@@ -99,13 +99,13 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 ## Phase 4: Communication & Coordination
 
 ### 9. Stakeholder Communication
-- Use Task tool with subagent_type="content-marketing::content-marketer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Manage incident communication for: $ARGUMENTS. Create: 1) Status page updates (public-facing), 2) Internal engineering updates (technical details), 3) Executive summary (business impact/ETA), 4) Customer support briefing (talking points), 5) Timeline documentation with key decisions. Update every 15-30 minutes based on severity."
 - Output: Communication artifacts, status updates, stakeholder briefings, timeline log
 - Context: All previous phases, current resolution status
 
 ### 10. Customer Impact Assessment
-- Use Task tool with subagent_type="incident-responder"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Assess and document customer impact for incident: $ARGUMENTS. Analyze: 1) Affected user segments and geography, 2) Failed transactions or data loss, 3) SLA violations and contractual implications, 4) Customer support ticket volume, 5) Revenue impact estimation. Prepare proactive customer outreach list."
 - Output: Customer impact report, SLA analysis, outreach recommendations
 - Context: Resolution progress, communication status
@@ -113,19 +113,19 @@ Orchestrate multi-agent incident response with modern SRE practices for rapid re
 ## Phase 5: Postmortem & Prevention
 
 ### 11. Blameless Postmortem
-- Use Task tool with subagent_type="documentation-generation::docs-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Conduct blameless postmortem for incident: $ARGUMENTS. Document: 1) Complete incident timeline with decisions, 2) Root cause and contributing factors (systems focus), 3) What went well in response, 4) What could improve, 5) Action items with owners and deadlines, 6) Lessons learned for team education. Follow SRE postmortem best practices."
 - Output: Postmortem document, action items list, process improvements, training needs
 - Context: Complete incident history, all agent outputs
 
 ### 12. Monitoring and Alert Enhancement
-- Use Task tool with subagent_type="observability-monitoring::observability-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Enhance monitoring to prevent recurrence of: $ARGUMENTS. Implement: 1) New alerts for early detection, 2) SLI/SLO adjustments if needed, 3) Dashboard improvements for visibility, 4) Runbook automation opportunities, 5) Chaos engineering scenarios for testing. Ensure alerts are actionable and reduce noise."
 - Output: New monitoring configuration, alert rules, dashboard updates, runbook automation
 - Context: Postmortem findings, root cause analysis
 
 ### 13. System Hardening
-- Use Task tool with subagent_type="backend-development::backend-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Design system improvements to prevent incident: $ARGUMENTS. Propose: 1) Architecture changes for resilience (circuit breakers, bulkheads), 2) Graceful degradation strategies, 3) Capacity planning adjustments, 4) Technical debt prioritization, 5) Dependency reduction opportunities. Create implementation roadmap."
 - Output: Architecture improvements, resilience patterns, technical debt items, roadmap
 - Context: Postmortem action items, performance analysis

package/skills/incident-response-smart-fix/resources/implementation-playbook.md

@@ -8,7 +8,7 @@ This file contains detailed patterns, checklists, and code samples referenced by
 
 ## Phase 1: Issue Analysis - Error Detection and Context Gathering
 
-Use Task tool with subagent_type="error-debugging::error-detective" followed by subagent_type="error-debugging::debugger":
+Use Task tool with subagent_type="general-purpose" followed by subagent_type="general-purpose":
 
 **First: Error-Detective Analysis**
 
@@ -93,7 +93,7 @@ TESTING_REQUIREMENTS: [scenarios that must be covered]
 
 ## Phase 2: Root Cause Investigation - Deep Code Analysis
 
-Use Task tool with subagent_type="error-debugging::debugger" and subagent_type="comprehensive-review::code-reviewer" for systematic investigation:
+Use Task tool with subagent_type="general-purpose" and subagent_type="general-purpose" for systematic investigation:
 
 **First: Debugger Code Analysis**
 
@@ -185,13 +185,13 @@ ARCHITECTURAL_CONCERNS: {if systemic issues exist}
 Based on Phase 2 output, route to appropriate domain agent using Task tool:
 
 **Routing Logic:**
-- Python issues → subagent_type="python-development::python-pro"
-- TypeScript/JavaScript → subagent_type="javascript-typescript::typescript-pro"
-- Go → subagent_type="systems-programming::golang-pro"
-- Rust → subagent_type="systems-programming::rust-pro"
-- SQL/Database → subagent_type="database-cloud-optimization::database-optimizer"
-- Performance → subagent_type="application-performance::performance-engineer"
-- Security → subagent_type="security-scanning::security-auditor"
+- Python issues → subagent_type="general-purpose"
+- TypeScript/JavaScript → subagent_type="general-purpose"
+- Go → subagent_type="general-purpose"
+- Rust → subagent_type="general-purpose"
+- SQL/Database → subagent_type="general-purpose"
+- Performance → subagent_type="general-purpose"
+- Security → subagent_type="general-purpose"
 
 **Prompt Template (adapt for language):**
 ```
@@ -269,7 +269,7 @@ BACKWARD_COMPATIBILITY: {maintained | breaking with mitigation}
 
 ## Phase 4: Verification - Automated Testing and Performance Validation
 
-Use Task tool with subagent_type="unit-testing::test-automator" and subagent_type="application-performance::performance-engineer":
+Use Task tool with subagent_type="general-purpose" and subagent_type="general-purpose":
 
 **First: Test-Automator Regression Suite**
 
@@ -497,7 +497,7 @@ FINAL_VERDICT: {
 
 ## Phase 5: Documentation and Prevention - Long-term Resilience
 
-Use Task tool with subagent_type="comprehensive-review::code-reviewer" for prevention strategies:
+Use Task tool with subagent_type="general-purpose" for prevention strategies:
 
 **Prompt:**
 ```
@@ -613,13 +613,13 @@ For issues spanning multiple domains, orchestrate specialized agents sequentiall
 
 **Sequence:**
 1. **Phase 1-2**: error-detective + debugger identify slow database queries
-2. **Phase 3a**: Task(subagent_type="database-cloud-optimization::database-optimizer")
+2. **Phase 3a**: Task(subagent_type="general-purpose")
    - Optimize query with proper indexes
    - Context: "Query execution taking 5s, missing index on user_id column, N+1 query pattern detected"
-3. **Phase 3b**: Task(subagent_type="application-performance::performance-engineer")
+3. **Phase 3b**: Task(subagent_type="general-purpose")
    - Add caching layer for frequently accessed data
    - Context: "Database query optimized from 5s to 50ms by adding index on user_id column. Application still experiencing 2s response times due to N+1 query pattern loading 100+ user records per request. Add Redis caching with 5-minute TTL for user profiles."
-4. **Phase 3c**: Task(subagent_type="incident-response::devops-troubleshooter")
+4. **Phase 3c**: Task(subagent_type="general-purpose")
    - Configure monitoring for query performance and cache hit rates
    - Context: "Cache layer added with Redis. Need monitoring for: query p95 latency (threshold: 100ms), cache hit rate (threshold: >80%), cache memory usage (alert at 80%)."
 
@@ -630,11 +630,11 @@ For issues spanning multiple domains, orchestrate specialized agents sequentiall
    - Context: "TypeError: Cannot read property 'map' of undefined, 500+ occurrences in last hour, affects Safari users on iOS 14"
 2. **Phase 2**: debugger + code-reviewer investigate
    - Context: "API response sometimes returns null instead of empty array when no results. Frontend assumes array."
-3. **Phase 3a**: Task(subagent_type="javascript-typescript::typescript-pro")
+3. **Phase 3a**: Task(subagent_type="general-purpose")
    - Fix frontend with proper null checks
    - Add type guards
    - Context: "Backend API /api/users endpoint returning null instead of [] when no results. Fix frontend to handle both. Add TypeScript strict null checks."
-4. **Phase 3b**: Task(subagent_type="backend-development::backend-architect")
+4. **Phase 3b**: Task(subagent_type="general-purpose")
    - Fix backend to always return array
    - Update API contract
    - Context: "Frontend now handles null, but API should follow contract and return [] not null. Update OpenAPI spec to document this."
@@ -648,7 +648,7 @@ For issues spanning multiple domains, orchestrate specialized agents sequentiall
    - Context: "SQL injection vulnerability in login endpoint, Snyk severity: HIGH"
 2. **Phase 2**: debugger + security-auditor investigate
    - Context: "User input not sanitized in SQL WHERE clause, allows authentication bypass"
-3. **Phase 3**: Task(subagent_type="security-scanning::security-auditor")
+3. **Phase 3**: Task(subagent_type="general-purpose")
    - Implement parameterized queries
    - Add input validation
    - Add rate limiting

package/skills/linear-claude-skill/SKILL.md

@@ -387,13 +387,13 @@ For detailed helper script usage, see **troubleshooting.md**.
 
 ### Parallel Agent Execution
 
-For bulk operations or background execution, use the `Linear-specialist` subagent:
+For bulk operations or background execution, use the `Linear-specialist` Task agent:
 
 ```javascript
 Task({
   description: "Update Linear issues",
   prompt: "Mark ENG-101, ENG-102, ENG-103 as Done",
-  subagent_type: "Linear-specialist"
+  subagent_type: "general-purpose"
 })
 ```
 

package/skills/loki-mode/ACKNOWLEDGEMENTS.md

@@ -21,7 +21,7 @@ Loki Mode is built for Claude and incorporates Anthropic's cutting-edge research
 | [Computer Use Safety](https://www.anthropic.com/news/3-5-models-and-computer-use) | Safe autonomous operation patterns |
 | [Sabotage Evaluations](https://www.anthropic.com/research/sabotage-evaluations-for-frontier-models) | Safety evaluation methodology |
 | [Effective Harnesses for Long-Running Agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents) | One-feature-at-a-time pattern, Playwright MCP for E2E |
-| [Claude Agent SDK Overview](https://platform.claude.com/docs/en/agent-sdk/overview) | Task tool, subagents, resume parameter, hooks |
+| [Claude Agent SDK Overview](https://platform.claude.com/docs/en/agent-sdk/overview) | Task tool, Task agents, resume parameter, hooks |
 
 ### Google DeepMind
 
@@ -101,7 +101,7 @@ AWS Bedrock's multi-agent collaboration patterns inform Loki Mode's routing and
 | Resource | Contribution |
 |----------|--------------|
 | [NVIDIA ToolOrchestra](https://github.com/NVlabs/ToolOrchestra) | Efficiency metrics, three-reward signal framework, dynamic agent selection |
-| [LerianStudio/ring](https://github.com/LerianStudio/ring) | Subagent-driven-development pattern |
+| [LerianStudio/ring](https://github.com/LerianStudio/ring) | Task-agent-driven-development pattern |
 | [Awesome Agentic Patterns](https://github.com/nibzard/awesome-agentic-patterns) | 105+ production patterns catalog |
 
 ### Best Practices Guides
@@ -124,7 +124,7 @@ Battle-tested insights from practitioners deploying agents in production.
 |--------|-------------|
 | [What Actually Works in Production for Autonomous Agents](https://news.ycombinator.com/item?id=44623207) | "Zero companies without human in the loop" |
 | [Coding with LLMs in Summer 2025](https://news.ycombinator.com/item?id=44623953) | Context curation beats automatic RAG |
-| [Superpowers: How I'm Using Coding Agents](https://news.ycombinator.com/item?id=45547344) | Sub-agents for context isolation (Simon Willison) |
+| [Superpowers: How I'm Using Coding Agents](https://news.ycombinator.com/item?id=45547344) | Task agents for context isolation (Simon Willison) |
 | [Claude Code Experience After Two Weeks](https://news.ycombinator.com/item?id=44596472) | Fresh contexts yield better results |
 | [AI Agent Benchmarks Are Broken](https://news.ycombinator.com/item?id=44531697) | LLM-as-judge has shared blind spots |
 | [How to Orchestrate Multi-Agent Workflows](https://news.ycombinator.com/item?id=45955997) | Event-driven, decoupled coordination |
@@ -150,7 +150,7 @@ Special thanks to thought leaders whose patterns and insights shaped Loki Mode:
 | **Boris Cherny** (Creator of Claude Code) | Self-verification loop (2-3x quality improvement), extended thinking mode, "Less prompting, more systems" philosophy |
 | **Ivan Steshov** | Centralized constitution, agent lineage tracking, structured artifacts as contracts |
 | **Addy Osmani** | Git checkpoint system, specification-first approach, visual aids (Mermaid diagrams) |
-| **Simon Willison** | Sub-agents for context isolation, skills system, context curation patterns |
+| **Simon Willison** | Task agents for context isolation, skills system, context curation patterns |
 
 ---