@ngxtm/devkit 3.19.0 → 3.21.0

package/skills/backend-development-feature-development/SKILL.md

@@ -61,19 +61,19 @@ Orchestrate end-to-end feature development from requirements to production deplo
 ## Phase 1: Discovery & Requirements Planning
 
 1. **Business Analysis & Requirements**
-   - Use Task tool with subagent_type="business-analytics::business-analyst"
+   - Use Task tool with subagent_type="general-purpose"
    - Prompt: "Analyze feature requirements for: $ARGUMENTS. Define user stories, acceptance criteria, success metrics, and business value. Identify stakeholders, dependencies, and risks. Create feature specification document with clear scope boundaries."
    - Expected output: Requirements document with user stories, success metrics, risk assessment
    - Context: Initial feature request and business context
 
 2. **Technical Architecture Design**
-   - Use Task tool with subagent_type="comprehensive-review::architect-review"
+   - Use Task tool with subagent_type="general-purpose"
    - Prompt: "Design technical architecture for feature: $ARGUMENTS. Using requirements: [include business analysis from step 1]. Define service boundaries, API contracts, data models, integration points, and technology stack. Consider scalability, performance, and security requirements."
    - Expected output: Technical design document with architecture diagrams, API specifications, data models
    - Context: Business requirements, existing system architecture
 
 3. **Feasibility & Risk Assessment**
-   - Use Task tool with subagent_type="security-scanning::security-auditor"
+   - Use Task tool with subagent_type="general-purpose"
    - Prompt: "Assess security implications and risks for feature: $ARGUMENTS. Review architecture: [include technical design from step 2]. Identify security requirements, compliance needs, data privacy concerns, and potential vulnerabilities."
    - Expected output: Security assessment with risk matrix, compliance checklist, mitigation strategies
    - Context: Technical design, regulatory requirements
@@ -81,19 +81,19 @@ Orchestrate end-to-end feature development from requirements to production deplo
 ## Phase 2: Implementation & Development
 
 4. **Backend Services Implementation**
-   - Use Task tool with subagent_type="backend-architect"
+   - Use Task tool with subagent_type="general-purpose"
    - Prompt: "Implement backend services for: $ARGUMENTS. Follow technical design: [include architecture from step 2]. Build RESTful/GraphQL APIs, implement business logic, integrate with data layer, add resilience patterns (circuit breakers, retries), implement caching strategies. Include feature flags for gradual rollout."
    - Expected output: Backend services with APIs, business logic, database integration, feature flags
    - Context: Technical design, API contracts, data models
 
 5. **Frontend Implementation**
-   - Use Task tool with subagent_type="frontend-mobile-development::frontend-developer"
+   - Use Task tool with subagent_type="general-purpose"
    - Prompt: "Build frontend components for: $ARGUMENTS. Integrate with backend APIs: [include API endpoints from step 4]. Implement responsive UI, state management, error handling, loading states, and analytics tracking. Add feature flag integration for A/B testing capabilities."
    - Expected output: Frontend components with API integration, state management, analytics
    - Context: Backend APIs, UI/UX designs, user stories
 
 6. **Data Pipeline & Integration**
-   - Use Task tool with subagent_type="data-engineering::data-engineer"
+   - Use Task tool with subagent_type="general-purpose"
    - Prompt: "Build data pipelines for: $ARGUMENTS. Design ETL/ELT processes, implement data validation, create analytics events, set up data quality monitoring. Integrate with product analytics platforms for feature usage tracking."
    - Expected output: Data pipelines, analytics events, data quality checks
    - Context: Data requirements, analytics needs, existing data infrastructure
@@ -101,19 +101,19 @@ Orchestrate end-to-end feature development from requirements to production deplo
 ## Phase 3: Testing & Quality Assurance
 
 7. **Automated Test Suite**
-   - Use Task tool with subagent_type="unit-testing::test-automator"
+   - Use Task tool with subagent_type="general-purpose"
    - Prompt: "Create comprehensive test suite for: $ARGUMENTS. Write unit tests for backend: [from step 4] and frontend: [from step 5]. Add integration tests for API endpoints, E2E tests for critical user journeys, performance tests for scalability validation. Ensure minimum 80% code coverage."
    - Expected output: Test suites with unit, integration, E2E, and performance tests
    - Context: Implementation code, acceptance criteria, test requirements
 
 8. **Security Validation**
-   - Use Task tool with subagent_type="security-scanning::security-auditor"
+   - Use Task tool with subagent_type="general-purpose"
    - Prompt: "Perform security testing for: $ARGUMENTS. Review implementation: [include backend and frontend from steps 4-5]. Run OWASP checks, penetration testing, dependency scanning, and compliance validation. Verify data encryption, authentication, and authorization."
    - Expected output: Security test results, vulnerability report, remediation actions
    - Context: Implementation code, security requirements
 
 9. **Performance Optimization**
-   - Use Task tool with subagent_type="application-performance::performance-engineer"
+   - Use Task tool with subagent_type="general-purpose"
    - Prompt: "Optimize performance for: $ARGUMENTS. Analyze backend services: [from step 4] and frontend: [from step 5]. Profile code, optimize queries, implement caching, reduce bundle sizes, improve load times. Set up performance budgets and monitoring."
    - Expected output: Performance improvements, optimization report, performance metrics
    - Context: Implementation code, performance requirements
@@ -121,19 +121,19 @@ Orchestrate end-to-end feature development from requirements to production deplo
 ## Phase 4: Deployment & Monitoring
 
 10. **Deployment Strategy & Pipeline**
-    - Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
+    - Use Task tool with subagent_type="general-purpose"
     - Prompt: "Prepare deployment for: $ARGUMENTS. Create CI/CD pipeline with automated tests: [from step 7]. Configure feature flags for gradual rollout, implement blue-green deployment, set up rollback procedures. Create deployment runbook and rollback plan."
     - Expected output: CI/CD pipeline, deployment configuration, rollback procedures
     - Context: Test suites, infrastructure requirements, deployment strategy
 
 11. **Observability & Monitoring**
-    - Use Task tool with subagent_type="observability-monitoring::observability-engineer"
+    - Use Task tool with subagent_type="general-purpose"
     - Prompt: "Set up observability for: $ARGUMENTS. Implement distributed tracing, custom metrics, error tracking, and alerting. Create dashboards for feature usage, performance metrics, error rates, and business KPIs. Set up SLOs/SLIs with automated alerts."
     - Expected output: Monitoring dashboards, alerts, SLO definitions, observability infrastructure
     - Context: Feature implementation, success metrics, operational requirements
 
 12. **Documentation & Knowledge Transfer**
-    - Use Task tool with subagent_type="documentation-generation::docs-architect"
+    - Use Task tool with subagent_type="general-purpose"
     - Prompt: "Generate comprehensive documentation for: $ARGUMENTS. Create API documentation, user guides, deployment guides, troubleshooting runbooks. Include architecture diagrams, data flow diagrams, and integration guides. Generate automated changelog from commits."
     - Expected output: API docs, user guides, runbooks, architecture documentation
     - Context: All previous phases' outputs

package/skills/best-practices/references/anti-patterns.md

@@ -528,9 +528,9 @@ read all the files in src/ and then tell me about the architecture
 ```
 read the main entry point and top-level directories to understand the architecture. don't read every file - just enough to explain the main patterns.
 ```
-Or use subagents:
+Or use Task agents:
 ```
-use a subagent to investigate the codebase architecture and report a summary.
+use a Task agent to investigate the codebase architecture and report a summary.
 ```
 
 ---

package/skills/best-practices/references/best-practices-guide.md

@@ -250,11 +250,11 @@ Analyze and fix the GitHub issue: $ARGUMENTS.
 
 Run `/fix-issue 1234` to invoke it. Use `disable-model-invocation: true` for workflows with side effects that you want to trigger manually.
 
-### Create custom subagents
+### Create custom Task agents
 
 > **Tip:** Define specialized assistants in `.claude/agents/` that Claude can delegate to for isolated tasks.
 
-Subagents run in their own context with their own set of allowed tools. They're useful for tasks that read many files or need specialized focus without cluttering your main conversation.
+Task agents run in their own context with their own set of allowed tools. They're useful for tasks that read many files or need specialized focus without cluttering your main conversation.
 
 ```markdown
 ---
@@ -272,15 +272,15 @@ You are a senior security engineer. Review code for:
 Provide specific line references and suggested fixes.
 ```
 
-Tell Claude to use subagents explicitly: *"Use a subagent to review this code for security issues."*
+Tell Claude to use Task agents explicitly: *"Use a Task agent to review this code for security issues."*
 
 ### Install plugins
 
 > **Tip:** Run `/plugin` to browse the marketplace. Plugins add skills, tools, and integrations without configuration.
 
-Plugins bundle skills, hooks, subagents, and MCP servers into a single installable unit from the community and Anthropic.
+Plugins bundle skills, hooks, Task agents, and MCP servers into a single installable unit from the community and Anthropic.
 
-For guidance on choosing between skills, subagents, hooks, and MCP, see Extend Claude Code.
+For guidance on choosing between skills, Task agents, hooks, and MCP, see Extend Claude Code.
 
 ***
 
@@ -350,23 +350,23 @@ During long sessions, Claude's context window can fill with irrelevant conversat
 * For more control, run `/compact <instructions>`, like `/compact Focus on the API changes`
 * Customize compaction behavior in CLAUDE.md with instructions like `"When compacting, always preserve the full list of modified files and any test commands"` to ensure critical context survives summarization
 
-### Use subagents for investigation
+### Use Task agents for investigation
 
-> **Tip:** Delegate research with `"use subagents to investigate X"`. They explore in a separate context, keeping your main conversation clean for implementation.
+> **Tip:** Delegate research with `"use Task agents to investigate X"`. They explore in a separate context, keeping your main conversation clean for implementation.
 
-Since context is your fundamental constraint, subagents are one of the most powerful tools available. When Claude researches a codebase it reads lots of files, all of which consume your context. Subagents run in separate context windows and report back summaries:
+Since context is your fundamental constraint, Task agents are one of the most powerful tools available. When Claude researches a codebase it reads lots of files, all of which consume your context. Task agents run in separate context windows and report back summaries:
 
 ```
-Use subagents to investigate how our authentication system handles token
+Use Task agents to investigate how our authentication system handles token
 refresh, and whether we have any existing OAuth utilities I should reuse.
 ```
 
-The subagent explores the codebase, reads relevant files, and reports back with findings, all without cluttering your main conversation.
+The Task agent explores the codebase, reads relevant files, and reports back with findings, all without cluttering your main conversation.
 
-You can also use subagents for verification after Claude implements something:
+You can also use Task agents for verification after Claude implements something:
 
 ```
-use a subagent to review this code for edge cases
+use a Task agent to review this code for edge cases
 ```
 
 ### Rewind with checkpoints
@@ -487,7 +487,7 @@ These are common mistakes. Recognizing them early saves time:
 * **The trust-then-verify gap.** Claude produces a plausible-looking implementation that doesn't handle edge cases.
   > **Fix**: Always provide verification (tests, scripts, screenshots). If you can't verify it, don't ship it.
 * **The infinite exploration.** You ask Claude to "investigate" something without scoping it. Claude reads hundreds of files, filling the context.
-  > **Fix**: Scope investigations narrowly or use subagents so the exploration doesn't consume your main context.
+  > **Fix**: Scope investigations narrowly or use Task agents so the exploration doesn't consume your main context.
 
 ***
 
@@ -504,7 +504,7 @@ Over time, you'll develop intuition that no guide can capture. You'll know when
 ## Related resources
 
 * **How Claude Code works** - Understand the agentic loop, tools, and context management
-* **Extend Claude Code** - Choose between skills, hooks, MCP, subagents, and plugins
+* **Extend Claude Code** - Choose between skills, hooks, MCP, Task agents, and plugins
 * **Common workflows** - Step-by-step recipes for debugging, testing, PRs, and more
 * **CLAUDE.md** - Store project conventions and persistent context
 

package/skills/c4-architecture-c4-architecture/SKILL.md

@@ -54,7 +54,7 @@ All documentation is written to a new `C4-Documentation/` directory in the repos
 
 For each directory, starting from the deepest:
 
-- Use Task tool with subagent_type="c4-architecture::c4-code"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Analyze the code in directory: [directory_path]
 
@@ -110,7 +110,7 @@ For each directory, starting from the deepest:
 
 For each identified component:
 
-- Use Task tool with subagent_type="c4-architecture::c4-component"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Synthesize the following C4 Code-level documentation files into a logical component:
 
@@ -153,7 +153,7 @@ For each identified component:
 
 ### 2.3 Create Master Component Index
 
-- Use Task tool with subagent_type="c4-architecture::c4-component"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Create a master component index that lists all components in the system.
 
@@ -188,7 +188,7 @@ For each identified component:
 
 ### 3.2 Map Components to Containers
 
-- Use Task tool with subagent_type="c4-architecture::c4-container"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Synthesize components into containers based on deployment definitions.
 
@@ -261,7 +261,7 @@ For each identified component:
 
 ### 4.2 Create Context Documentation
 
-- Use Task tool with subagent_type="c4-architecture::c4-context"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: |
   Create comprehensive C4 Context-level documentation for the system.
 

package/skills/comprehensive-review-full-review/SKILL.md

@@ -41,13 +41,13 @@ Orchestrate comprehensive multi-dimensional code review using specialized review
 Use Task tool to orchestrate quality and architecture agents in parallel:
 
 ### 1A. Code Quality Analysis
-- Use Task tool with subagent_type="code-reviewer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Perform comprehensive code quality review for: $ARGUMENTS. Analyze code complexity, maintainability index, technical debt, code duplication, naming conventions, and adherence to Clean Code principles. Integrate with SonarQube, CodeQL, and Semgrep for static analysis. Check for code smells, anti-patterns, and violations of SOLID principles. Generate cyclomatic complexity metrics and identify refactoring opportunities."
 - Expected output: Quality metrics, code smell inventory, refactoring recommendations
 - Context: Initial codebase analysis, no dependencies on other phases
 
 ### 1B. Architecture & Design Review
-- Use Task tool with subagent_type="architect-review"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Review architectural design patterns and structural integrity in: $ARGUMENTS. Evaluate microservices boundaries, API design, database schema, dependency management, and adherence to Domain-Driven Design principles. Check for circular dependencies, inappropriate coupling, missing abstractions, and architectural drift. Verify compliance with enterprise architecture standards and cloud-native patterns."
 - Expected output: Architecture assessment, design pattern analysis, structural recommendations
 - Context: Runs parallel with code quality analysis
@@ -57,13 +57,13 @@ Use Task tool to orchestrate quality and architecture agents in parallel:
 Use Task tool with security and performance agents, incorporating Phase 1 findings:
 
 ### 2A. Security Vulnerability Assessment
-- Use Task tool with subagent_type="security-auditor"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Execute comprehensive security audit on: $ARGUMENTS. Perform OWASP Top 10 analysis, dependency vulnerability scanning with Snyk/Trivy, secrets detection with GitLeaks, input validation review, authentication/authorization assessment, and cryptographic implementation review. Include findings from Phase 1 architecture review: {phase1_architecture_context}. Check for SQL injection, XSS, CSRF, insecure deserialization, and configuration security issues."
 - Expected output: Vulnerability report, CVE list, security risk matrix, remediation steps
 - Context: Incorporates architectural vulnerabilities identified in Phase 1B
 
 ### 2B. Performance & Scalability Analysis
-- Use Task tool with subagent_type="application-performance::performance-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Conduct performance analysis and scalability assessment for: $ARGUMENTS. Profile code for CPU/memory hotspots, analyze database query performance, review caching strategies, identify N+1 problems, assess connection pooling, and evaluate asynchronous processing patterns. Consider architectural findings from Phase 1: {phase1_architecture_context}. Check for memory leaks, resource contention, and bottlenecks under load."
 - Expected output: Performance metrics, bottleneck analysis, optimization recommendations
 - Context: Uses architecture insights to identify systemic performance issues
@@ -73,13 +73,13 @@ Use Task tool with security and performance agents, incorporating Phase 1 findin
 Use Task tool for test and documentation quality assessment:
 
 ### 3A. Test Coverage & Quality Analysis
-- Use Task tool with subagent_type="unit-testing::test-automator"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Evaluate testing strategy and implementation for: $ARGUMENTS. Analyze unit test coverage, integration test completeness, end-to-end test scenarios, test pyramid adherence, and test maintainability. Review test quality metrics including assertion density, test isolation, mock usage, and flakiness. Consider security and performance test requirements from Phase 2: {phase2_security_context}, {phase2_performance_context}. Verify TDD practices if --tdd-review flag is set."
 - Expected output: Coverage report, test quality metrics, testing gap analysis
 - Context: Incorporates security and performance testing requirements from Phase 2
 
 ### 3B. Documentation & API Specification Review
-- Use Task tool with subagent_type="code-documentation::docs-architect"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Review documentation completeness and quality for: $ARGUMENTS. Assess inline code documentation, API documentation (OpenAPI/Swagger), architecture decision records (ADRs), README completeness, deployment guides, and runbooks. Verify documentation reflects actual implementation based on all previous phase findings: {phase1_context}, {phase2_context}. Check for outdated documentation, missing examples, and unclear explanations."
 - Expected output: Documentation coverage report, inconsistency list, improvement recommendations
 - Context: Cross-references all previous findings to ensure documentation accuracy
@@ -89,13 +89,13 @@ Use Task tool for test and documentation quality assessment:
 Use Task tool to verify framework-specific and industry best practices:
 
 ### 4A. Framework & Language Best Practices
-- Use Task tool with subagent_type="framework-migration::legacy-modernizer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Verify adherence to framework and language best practices for: $ARGUMENTS. Check modern JavaScript/TypeScript patterns, React hooks best practices, Python PEP compliance, Java enterprise patterns, Go idiomatic code, or framework-specific conventions (based on --framework flag). Review package management, build configuration, environment handling, and deployment practices. Include all quality issues from previous phases: {all_previous_contexts}."
 - Expected output: Best practices compliance report, modernization recommendations
 - Context: Synthesizes all previous findings for framework-specific guidance
 
 ### 4B. CI/CD & DevOps Practices Review
-- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
+- Use Task tool with subagent_type="general-purpose"
 - Prompt: "Review CI/CD pipeline and DevOps practices for: $ARGUMENTS. Evaluate build automation, test automation integration, deployment strategies (blue-green, canary), infrastructure as code, monitoring/observability setup, and incident response procedures. Assess pipeline security, artifact management, and rollback capabilities. Consider all issues identified in previous phases that impact deployment: {all_critical_issues}."
 - Expected output: Pipeline assessment, DevOps maturity evaluation, automation recommendations
 - Context: Focuses on operationalizing fixes for all identified issues

package/skills/context-degradation/SKILL.md

@@ -157,11 +157,11 @@ Four strategies address different aspects of context degradation:
 
 **Compress**: Reduce tokens while preserving information through summarization, abstraction, and observation masking. This extends effective context capacity.
 
-**Isolate**: Split context across sub-agents or sessions to prevent any single context from growing large enough to degrade. This is the most aggressive strategy but often the most effective.
+**Isolate**: Split context across Task agents or sessions to prevent any single context from growing large enough to degrade. This is the most aggressive strategy but often the most effective.
 
 ### Architectural Patterns
 
-Implement these strategies through specific architectural patterns. Use just-in-time context loading to retrieve information only when needed. Use observation masking to replace verbose tool outputs with compact references. Use sub-agent architectures to isolate context for different tasks. Use compaction to summarize growing context before it exceeds limits.
+Implement these strategies through specific architectural patterns. Use just-in-time context loading to retrieve information only when needed. Use observation masking to replace verbose tool outputs with compact references. Use Task agent architectures to isolate context for different tasks. Use compaction to summarize growing context before it exceeds limits.
 
 ## Examples
 

package/skills/context-engineering/SKILL.md

@@ -25,13 +25,13 @@ Context engineering curates the smallest high-signal token set for LLM tasks. Th
 1. **Context quality > quantity** - High-signal tokens beat exhaustive content
 2. **Attention is finite** - U-shaped curve favors beginning/end positions
 3. **Progressive disclosure** - Load information just-in-time
-4. **Isolation prevents degradation** - Partition work across sub-agents
+4. **Isolation prevents degradation** - Partition work across Task agents
 5. **Measure before optimizing** - Know your baseline
 
 **IMPORTANT:**
 - Sacrifice grammar for the sake of concision.
 - Ensure token efficiency while maintaining high quality.
-- Pass these rules to subagents.
+- Pass these rules to Task agents.
 
 ## Quick Reference
 
@@ -61,7 +61,7 @@ Context engineering curates the smallest high-signal token set for LLM tasks. Th
 1. **Write**: Save context externally (scratchpads, files)
 2. **Select**: Pull only relevant context (retrieval, filtering)
 3. **Compress**: Reduce tokens while preserving info (summarization)
-4. **Isolate**: Split across sub-agents (partitioning)
+4. **Isolate**: Split across Task agents (partitioning)
 
 ## Anti-Patterns
 
@@ -75,7 +75,7 @@ Context engineering curates the smallest high-signal token set for LLM tasks. Th
 
 1. Place critical info at beginning/end of context
 2. Implement compaction at 70-80% utilization
-3. Use sub-agents for context isolation, not role-play
+3. Use Task agents for context isolation, not role-play
 4. Design tools with 4-question framework (what, when, inputs, returns)
 5. Optimize for tokens-per-task, not tokens-per-request
 6. Validate with probe-based evaluation

package/skills/context-engineering/references/context-degradation.md

@@ -61,7 +61,7 @@ Predictable degradation as context grows. Not binary - a continuum.
 1. **Write**: Save externally (scratchpads, files)
 2. **Select**: Pull only relevant (retrieval, filtering)
 3. **Compress**: Reduce tokens (summarization)
-4. **Isolate**: Split across sub-agents (partitioning)
+4. **Isolate**: Split across Task agents (partitioning)
 
 ## Detection Heuristics
 

package/skills/context-engineering/references/context-optimization.md

@@ -51,7 +51,7 @@ context += [unique_content]                   # Variable last
 
 ## Context Partitioning
 
-Split work across sub-agents with isolated contexts.
+Split work across Task agents with isolated contexts.
 
 ```python
 result = await sub_agent.process(subtask, clean_context=True)

package/skills/context-engineering/references/multi-agent-patterns.md

@@ -4,7 +4,7 @@ Distribute work across multiple context windows for isolation and scale.
 
 ## Core Insight
 
-Sub-agents exist to **isolate context**, not anthropomorphize roles.
+Task agents exist to **isolate context**, not anthropomorphize roles.
 
 ## Token Economics
 

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

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

package/skills/context-optimization/SKILL.md

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

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

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