@ngxtm/devkit 3.19.0 → 3.20.0

package/skills/loki-mode/CHANGELOG.md

@@ -158,7 +158,7 @@ Battle-tested patterns from practitioners:
 - **Confidence-Based Routing**: Auto-approve high confidence, escalate low
 - **Deterministic Outer Loops**: Rule-based validation, not LLM-judged
 - **Context Curation**: Manual selection beats automatic RAG
-- **Sub-Agents for Context Isolation**: Prevent token waste
+- **Task Agents for Context Isolation**: Prevent token waste
 - **Event-Driven Orchestration**: Async, decoupled coordination
 - **Policy-First Enforcement**: Runtime governance
 
@@ -172,7 +172,7 @@ Battle-tested patterns from practitioners:
 - Confidence-Based Routing thresholds
 - Deterministic Outer Loops workflow
 - Context Engineering principles
-- Sub-Agents for Context Isolation
+- Task Agents for Context Isolation
 
 ### Key Practitioner Insights
 
@@ -347,7 +347,7 @@ Comprehensive guide covering:
 - **Haiku**: Unit tests, monitoring, and simple tasks
 
 ### Changed
-- SKILL.md: Added Single-Responsibility Principle to subagent guidance
+- SKILL.md: Added Single-Responsibility Principle to Task agent guidance
 - SKILL.md: Clarified model selection (Opus=planning, Sonnet=dev, Haiku=tests)
 - SKILL.md: Dynamic Agent Selection table now shows Planning/Development/Testing columns
 - tool-orchestration.md: Added correlation_id, tool_reliability_rate to schema
@@ -939,7 +939,7 @@ The previous "37 agents" messaging was misleading because:
   - **Sonnet 4.5** is now clearly marked as **DEFAULT** for all standard implementation work
   - **Haiku 4.5** changed to **OPTIMIZATION ONLY** for simple/parallelizable tasks
   - **Opus 4.5** changed to **COMPLEX ONLY** for architecture & security
-  - Previous documentation incorrectly suggested Haiku as default for most subagents
+  - Previous documentation incorrectly suggested Haiku as default for most Task agents
   - Aligns with best practices: Sonnet for quality, Haiku for speed optimization only
 
 - **run.sh Implementation Gap** - RARV cycle now implemented in runner script (run.sh:870-871, 908-916):
@@ -1150,7 +1150,7 @@ For existing `.loki/` projects:
 
 ### Fixed
 - Removed duplicate CONTINUITY.md template from bootstrap script (was lines 2436-2470)
-- Removed duplicate Task Completion Report from subagent dispatch section (was lines 1731-1764)
+- Removed duplicate Task Completion Report from Task agent dispatch section (was lines 1731-1764)
 - Consolidated severity matrices (removed duplicates, kept one authoritative version)
 
 ## [2.14.0] - 2026-01-02
@@ -1353,8 +1353,8 @@ Loki Mode now combines the best practices from GitHub's ecosystem:
   - Secret scanning to prevent credential leaks
   - 5 quality gate categories with blocking rules
 
-  **Principle 2: Structured Prompting for Subagents**
-  - All subagent dispatches must include: GOAL, CONSTRAINTS, CONTEXT, OUTPUT FORMAT
+  **Principle 2: Structured Prompting for Task Agents**
+  - All Task agent dispatches must include: GOAL, CONSTRAINTS, CONTEXT, OUTPUT FORMAT
   - Goals explain "what success looks like" (not just actions)
   - Constraints define boundaries (dependencies, compatibility, performance)
   - Context includes CONTINUITY.md, ledgers, learnings, architecture decisions
@@ -1390,10 +1390,10 @@ Loki Mode now combines the best practices from GitHub's ecosystem:
 
 ### Changed
 - CODE_REVIEW phase now requires static analysis before AI reviewers
-- Subagent dispatch template updated with GOAL/CONSTRAINTS/CONTEXT/OUTPUT
+- Task agent dispatch template updated with GOAL/CONSTRAINTS/CONTEXT/OUTPUT
 - Task completion requires decision documentation (not just code output)
 - Quality gates now include static analysis tools (CodeQL, linters, security scanners)
-- Context-Aware Subagent Dispatch section rewritten for structured prompting
+- Context-Aware Task Agent Dispatch section rewritten for structured prompting
 
 ### Philosophy
 "Speed and control aren't trade-offs. They reinforce each other." - GitHub

package/skills/loki-mode/CONTEXT-EXPORT.md

@@ -13,7 +13,7 @@
 ### Key Features
 - 37 specialized agent types across 6 swarms (Engineering, Operations, Business, Data, Product, Growth)
 - Dynamic agent scaling based on project complexity
-- Task tool for subagent dispatch with fresh context
+- Task tool for Task agent dispatch with fresh context
 - Distributed task queue (pending, in-progress, completed, failed, dead-letter)
 - Circuit breakers for per-agent failure handling
 - Timeout/stuck agent detection with heartbeat monitoring

package/skills/loki-mode/README.md

@@ -522,12 +522,12 @@ Loki Mode incorporates research and patterns from leading AI labs and practition
 ### Practitioner Insights
 
 - **Boris Cherny** (Claude Code creator) - Self-verification loop, extended thinking
-- **Simon Willison** - Sub-agents for context isolation, skills system
+- **Simon Willison** - Task agents for context isolation, skills system
 - **Hacker News Community** - [Production patterns](https://news.ycombinator.com/item?id=44623207) from real deployments
 
 ### Inspirations
 
-- [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
 
 **[Full Acknowledgements](ACKNOWLEDGEMENTS.md)** - Complete list of 50+ research papers, articles, and resources

package/skills/loki-mode/SKILL.md

@@ -137,7 +137,7 @@ If bugs are found in these files, document them in `.loki/CONTINUITY.md` under "
 | - Identify highest priority unblocked task                        |
 +-------------------------------------------------------------------+
 | ACT: Execute the task                                             |
-| - Dispatch subagent via Task tool OR execute directly             |
+| - Dispatch Task agent via Task tool OR execute directly             |
 | - Write code, run tests, fix issues                               |
 | - Commit changes atomically (git checkpoint)                      |
 +-------------------------------------------------------------------+
@@ -175,7 +175,7 @@ If bugs are found in these files, document them in `.loki/CONTINUITY.md` under "
 ### Task Tool Model Parameter
 ```python
 # Opus for planning/architecture ONLY
-Task(subagent_type="Plan", model="opus", description="Design system architecture", prompt="...")
+Task(subagent_type="general-purpose", model="opus", description="Design system architecture", prompt="...")
 
 # Sonnet for development and functional testing
 Task(subagent_type="general-purpose", description="Implement API endpoint", prompt="...")
@@ -286,7 +286,7 @@ Task(description="Refactor database layer for performance", prompt="...")     #
 - **Direct Routing:** Minimal context - just the task and relevant file(s)
 - **Supervisor Mode:** Full context - CONTINUITY.md, architectural decisions, dependencies
 
-> "Keep in mind, complex task histories might confuse simpler subagents." - AWS Best Practices
+> "Keep in mind, complex task histories might confuse simpler Task agents." - AWS Best Practices
 
 ### E2E Testing with Playwright MCP (Anthropic Harness Pattern)
 
@@ -325,7 +325,7 @@ mcp_servers = {
 | Metric | What to Track | Store In |
 |--------|---------------|----------|
 | Wall time | Seconds from start to completion | `.loki/metrics/efficiency/` |
-| Agent count | Number of subagents spawned | `.loki/metrics/efficiency/` |
+| Agent count | Number of Task agents spawned | `.loki/metrics/efficiency/` |
 | Retry count | Attempts before success | `.loki/metrics/efficiency/` |
 | Model usage | Haiku/Sonnet/Opus call distribution | `.loki/metrics/efficiency/` |
 
@@ -351,12 +351,12 @@ See `references/tool-orchestration.md` for full implementation details.
 
 ---
 
-## Structured Prompting for Subagents
+## Structured Prompting for Task Agents
 
 **Single-Responsibility Principle:** Each agent should have ONE clear goal and narrow scope.
 ([UiPath Best Practices](https://www.uipath.com/blog/ai/agent-builder-best-practices))
 
-**Every subagent dispatch MUST include:**
+**Every Task agent dispatch MUST include:**
 
 ```markdown
 ## GOAL (What success looks like)
@@ -446,7 +446,7 @@ See `references/agent-types.md` for complete definitions and capabilities.
 - **NEVER** skip code review between tasks
 - **NEVER** proceed with unfixed Critical/High/Medium issues
 - **NEVER** dispatch reviewers sequentially (always parallel - 3x faster)
-- **NEVER** dispatch multiple implementation subagents in parallel (conflicts)
+- **NEVER** dispatch multiple implementation Task agents in parallel (conflicts)
 - **NEVER** implement without reading task requirements first
 
 ### Review Anti-Patterns
@@ -466,7 +466,7 @@ See `references/agent-types.md` for complete definitions and capabilities.
 - **ALWAYS** wait for all reviewers before aggregating
 - **ALWAYS** fix Critical/High/Medium immediately
 - **ALWAYS** re-run ALL 3 reviewers after fixes
-- **ALWAYS** checkpoint state before spawning subagents
+- **ALWAYS** checkpoint state before spawning Task agents
 
 ---
 
@@ -618,14 +618,14 @@ context_budget:
   reserve: "90% for model reasoning"
 ```
 
-### Sub-Agents for Context Isolation
+### Task Agents for Context Isolation
 
-**Use sub-agents to prevent token waste on noisy subtasks:**
+**Use Task agents to prevent token waste on noisy subtasks:**
 
 ```
-Main agent (focused) --> Sub-agent (file search)
-                     --> Sub-agent (test running)
-                     --> Sub-agent (linting)
+Main agent (focused) --> Task agent (file search)
+                     --> Task agent (test running)
+                     --> Task agent (linting)
 ```
 
 See `references/production-patterns.md` for full practitioner patterns.
@@ -690,7 +690,7 @@ Loki Mode with PRD at path/to/prd   # Start with PRD
 |-------|-------|
 | Trigger | "Loki Mode" or "Loki Mode with PRD at [path]" |
 | Skip When | Need human approval, want to review plan first, single small task |
-| Related Skills | subagent-driven-development, executing-plans |
+| Related Skills | task-agent-driven-development, executing-plans |
 
 ---
 

package/skills/loki-mode/autonomy/run.sh

@@ -1473,7 +1473,7 @@ build_prompt() {
     local analysis_instruction="CODEBASE_ANALYSIS_MODE: No PRD. FIRST: Analyze codebase - scan structure, read package.json/requirements.txt, examine README. THEN: Generate PRD at .loki/generated-prd.md. FINALLY: Execute SDLC phases."
 
     # Context Memory Instructions
-    local memory_instruction="CONTEXT MEMORY: Save state to .loki/memory/ledgers/LEDGER-orchestrator.md before complex operations. Create handoffs at .loki/memory/handoffs/ when passing work to subagents. Extract learnings to .loki/memory/learnings/ after completing tasks. Check .loki/rules/ for established patterns. If context feels heavy, create .loki/signals/CONTEXT_CLEAR_REQUESTED and the wrapper will reset context with your ledger preserved."
+    local memory_instruction="CONTEXT MEMORY: Save state to .loki/memory/ledgers/LEDGER-orchestrator.md before complex operations. Create handoffs at .loki/memory/handoffs/ when passing work to Task agents. Extract learnings to .loki/memory/learnings/ after completing tasks. Check .loki/rules/ for established patterns. If context feels heavy, create .loki/signals/CONTEXT_CLEAR_REQUESTED and the wrapper will reset context with your ledger preserved."
 
     # Load existing context if resuming
     local context_injection=""

package/skills/loki-mode/integrations/vibe-kanban.md

@@ -10,7 +10,7 @@ Loki Mode can optionally integrate with [Vibe Kanban](https://github.com/BloopAI
 | Progress monitoring | Log files | Real-time dashboard |
 | Manual intervention | Edit queue files | Drag-and-drop tasks |
 | Code review | Automated 3-reviewer | + Visual diff review |
-| Parallel agents | Background subagents | Isolated git worktrees |
+| Parallel agents | Background Task agents | Isolated git worktrees |
 
 ## Setup
 

package/skills/loki-mode/references/core-workflow.md

@@ -34,7 +34,7 @@ Every iteration follows this cycle:
 | - Determine exact steps to complete it                            |
 +-------------------------------------------------------------------+
 | ACT: Execute the task                                             |
-| - Dispatch subagent via Task tool OR execute directly             |
+| - Dispatch Task agent via Task tool OR execute directly             |
 | - Write code, run tests, fix issues                               |
 | - Commit changes atomically (git checkpoint)                      |
 | - Update queue files (.loki/queue/*.json)                         |
@@ -266,10 +266,10 @@ move_tasks_to_pending after_task=$last_good_task_id
 
 ---
 
-## If Subagent Fails
+## If Task Agent Fails
 
 1. Do NOT try to fix manually (context pollution)
-2. Dispatch fix subagent with specific error context
-3. If fix subagent fails 3x, move to dead letter queue
+2. Dispatch fix Task agent with specific error context
+3. If fix Task agent fails 3x, move to dead letter queue
 4. Open circuit breaker for that agent type
 5. Alert orchestrator for human review

package/skills/loki-mode/references/production-patterns.md

@@ -283,20 +283,20 @@ skills_architecture:
     - Skills can be updated independently
 ```
 
-### Sub-Agents for Context Isolation
+### Task Agents for Context Isolation
 
 **Key Insight:** Prevent massive token waste by isolating context-noisy subtasks.
 
 ```python
 async def context_isolated_search(query, codebase_path):
     """
-    Use sub-agent for grep/search to prevent context pollution.
+    Use Task agent for grep/search to prevent context pollution.
     Based on Simon Willison's patterns.
     """
     # Main agent stays focused
-    # Sub-agent handles noisy file searching
+    # Task agent handles noisy file searching
 
-    search_agent = spawn_subagent(
+    search_agent = spawn_task_agent(
         role="codebase-searcher",
         context_limit="10k tokens",
         permissions=["read-only"]
@@ -538,11 +538,11 @@ cost_patterns:
     max_tier: "$200/month often needs 2-3 subscriptions"
 
   token_economics:
-    sub_agents_multiply_cost: "Each duplicates context"
+    task_agents_multiply_cost: "Each duplicates context"
     example: "5-task parallel job = 50,000+ tokens per subtask"
 
   optimization:
-    context_isolation: "Use sub-agents for noisy tasks"
+    context_isolation: "Use Task agents for noisy tasks"
     information_abstraction: "Summarize, don't dump"
     fresh_conversations: "Reset after major tasks"
     skill_on_demand: "Load only when needed"

package/skills/loki-mode/references/quality-control.md

@@ -273,9 +273,9 @@ Task(subagent_type="general-purpose", model="opus",
 
 ---
 
-## Structured Prompting for Subagents
+## Structured Prompting for Task Agents
 
-**Every subagent dispatch MUST include:**
+**Every Task agent dispatch MUST include:**
 
 ```markdown
 ## GOAL (What success looks like)

package/skills/loki-mode/references/sdlc-phases.md

@@ -197,15 +197,15 @@ jobs:
 ### Workflow Per Task:
 
 ```
-1. Dispatch implementation subagent (Task tool, model: sonnet)
-2. Subagent implements with TDD, commits, reports back
+1. Dispatch implementation Task agent (Task tool, model: sonnet)
+2. Task agent implements with TDD, commits, reports back
 3. Dispatch 3 reviewers IN PARALLEL (single message, 3 Task calls):
    - code-reviewer (opus)
    - business-logic-reviewer (opus)
    - security-reviewer (opus)
 4. Aggregate findings by severity
 5. IF Critical/High/Medium found:
-   - Dispatch fix subagent
+   - Dispatch fix Task agent
    - Re-run ALL 3 reviewers
    - Loop until all PASS
 6. Add TODO comments for Low issues

package/skills/machine-learning-ops-ml-pipeline/SKILL.md

@@ -46,7 +46,7 @@ The multi-agent approach ensures each aspect is handled by domain experts:
 ## Phase 1: Data & Requirements Analysis
 
 <Task>
-subagent_type: data-engineer
+subagent_type: general-purpose
 prompt: |
   Analyze and design data pipeline for ML system with requirements: $ARGUMENTS
 
@@ -73,7 +73,7 @@ prompt: |
 </Task>
 
 <Task>
-subagent_type: data-scientist
+subagent_type: general-purpose
 prompt: |
   Design feature engineering and model requirements for: $ARGUMENTS
   Using data architecture from: {phase1.data-engineer.output}
@@ -103,7 +103,7 @@ prompt: |
 ## Phase 2: Model Development & Training
 
 <Task>
-subagent_type: ml-engineer
+subagent_type: general-purpose
 prompt: |
   Implement training pipeline based on requirements: {phase1.data-scientist.output}
   Using data pipeline: {phase1.data-engineer.output}
@@ -131,7 +131,7 @@ prompt: |
 </Task>
 
 <Task>
-subagent_type: python-pro
+subagent_type: general-purpose
 prompt: |
   Optimize and productionize ML code from: {phase2.ml-engineer.output}
 
@@ -160,7 +160,7 @@ prompt: |
 ## Phase 3: Production Deployment & Serving
 
 <Task>
-subagent_type: mlops-engineer
+subagent_type: general-purpose
 prompt: |
   Design production deployment for models from: {phase2.ml-engineer.output}
   With optimized code from: {phase2.python-pro.output}
@@ -194,7 +194,7 @@ prompt: |
 </Task>
 
 <Task>
-subagent_type: kubernetes-architect
+subagent_type: general-purpose
 prompt: |
   Design Kubernetes infrastructure for ML workloads from: {phase3.mlops-engineer.output}
 
@@ -223,7 +223,7 @@ prompt: |
 ## Phase 4: Monitoring & Continuous Improvement
 
 <Task>
-subagent_type: observability-engineer
+subagent_type: general-purpose
 prompt: |
   Implement comprehensive monitoring for ML system deployed in: {phase3.mlops-engineer.output}
   Using Kubernetes infrastructure: {phase3.kubernetes-architect.output}

package/skills/mcp-builder/reference/evaluation.md

@@ -179,7 +179,7 @@ Read the documentation of the target API to understand:
 - Available endpoints and functionality
 - If ambiguity exists, fetch additional information from the web
 - Parallelize this step AS MUCH AS POSSIBLE
-- Ensure each subagent is ONLY examining documentation from the file system or on the web
+- Ensure each Task agent is ONLY examining documentation from the file system or on the web
 
 ### Step 2: Tool Inspection
 
@@ -204,8 +204,8 @@ After understanding the API and tools, USE the MCP server tools:
 - Goal: identify specific content (e.g., users, channels, messages, projects, tasks) for creating realistic questions
 - Should NOT call any tools that modify state
 - Will NOT read the code of the MCP server implementation itself
-- Parallelize this step with individual sub-agents pursuing independent explorations
-- Ensure each subagent is only performing READ-ONLY, NON-DESTRUCTIVE, and IDEMPOTENT operations
+- Parallelize this step with individual Task agents pursuing independent explorations
+- Ensure each Task agent is only performing READ-ONLY, NON-DESTRUCTIVE, and IDEMPOTENT operations
 - BE CAREFUL: SOME TOOLS may return LOTS OF DATA which would cause you to run out of CONTEXT
 - Make INCREMENTAL, SMALL, AND TARGETED tool calls for exploration
 - In all tool call requests, use the `limit` parameter to limit results (<10)

package/skills/mcp-management/README.md

@@ -4,7 +4,7 @@ Intelligent management and execution of Model Context Protocol (MCP) servers.
 
 ## Overview
 
-This skill enables Claude to discover, analyze, and execute MCP server capabilities without polluting the main context window. Perfect for context-efficient MCP integration using subagent-based architecture.
+This skill enables Claude to discover, analyze, and execute MCP server capabilities without polluting the main context window. Perfect for context-efficient MCP integration using Task agent-based architecture.
 
 ## Features
 
@@ -12,7 +12,7 @@ This skill enables Claude to discover, analyze, and execute MCP server capabilit
 - **Intelligent Tool Discovery**: Analyze which tools are relevant for specific tasks
 - **Progressive Disclosure**: Load only necessary tool definitions
 - **Execution Engine**: Call MCP tools with proper parameter handling
-- **Context Efficiency**: Delegate MCP operations to `mcp-manager` subagent
+- **Context Efficiency**: Delegate MCP operations to `mcp-manager` Task agent
 
 ## Quick Start
 
@@ -71,13 +71,13 @@ The LLM reads `assets/tools.json` and intelligently selects tools. No separate a
 npx ts-node scripts/cli.ts call-tool memory add '{"key":"name","value":"Alice"}'
 ```
 
-### Pattern 4: Use with Subagent
+### Pattern 4: Use with Task agent
 
 In main Claude conversation:
 
 ```
 User: "I need to search the web and save results"
-Main Agent: [Spawns mcp-manager subagent]
+Main Agent: [Spawns mcp-manager Task agent]
 mcp-manager: Discovers brave-search + memory tools, reports back
 Main Agent: Uses recommended tools for implementation
 ```
@@ -87,7 +87,7 @@ Main Agent: Uses recommended tools for implementation
 ```
 Main Agent (Claude)
     ↓ (delegates MCP tasks)
-mcp-manager Subagent
+mcp-manager Task agent
     ↓ (uses skill)
 mcp-management Skill
     ↓ (connects via)
@@ -96,7 +96,7 @@ MCP Servers (memory, filesystem, etc.)
 
 **Benefits**:
 - Main agent context stays clean
-- MCP discovery happens in isolated subagent context
+- MCP discovery happens in isolated Task agent context
 - Only relevant tool definitions loaded when needed
 - Reduced token usage
 

package/skills/mcp-management/SKILL.md

@@ -15,7 +15,7 @@ MCP is an open protocol enabling AI agents to connect to external tools and data
 - Progressive disclosure of MCP capabilities (load only what's needed)
 - Intelligent tool/prompt/resource selection based on task requirements
 - Multi-server management from single config file
-- Context-efficient: subagents handle MCP discovery and execution
+- Context-efficient: Task agents handle MCP discovery and execution
 - Persistent tool catalog: automatically saves discovered tools to JSON for fast reference
 
 ## When to Use This Skill
@@ -25,7 +25,7 @@ Use this skill when:
 2. **Task-Based Tool Selection**: Analyzing which MCP tools are relevant for a specific task
 3. **Executing MCP Tools**: Calling MCP tools programmatically with proper parameter handling
 4. **MCP Integration**: Building or debugging MCP client implementations
-5. **Context Management**: Avoiding context pollution by delegating MCP operations to subagents
+5. **Context Management**: Avoiding context pollution by delegating MCP operations to Task agents
 
 ## Core Capabilities
 
@@ -80,7 +80,7 @@ echo "Take a screenshot of https://example.com" | gemini -y -m gemini-2.5-flash
 npx tsx scripts/cli.ts call-tool memory create_entities '{"entities":[...]}'
 ```
 
-**Fallback: mcp-manager Subagent**
+**Fallback: mcp-manager Task agent**
 
 See [references/gemini-cli-integration.md](references/gemini-cli-integration.md) for complete examples.
 
@@ -106,14 +106,14 @@ echo "Take a screenshot of https://example.com. Return JSON only per GEMINI.md i
 - Automatic tool discovery
 - Structured JSON responses (parseable by Claude)
 - GEMINI.md auto-loaded for consistent formatting
-- Faster than subagent orchestration
+- Faster than Task agent orchestration
 - No natural language ambiguity
 
 See [references/gemini-cli-integration.md](references/gemini-cli-integration.md) for complete guide.
 
-### Pattern 2: Subagent-Based Execution (Fallback)
+### Pattern 2: Task Agent-Based Execution (Fallback)
 
-Use `mcp-manager` agent when Gemini CLI unavailable. Subagent discovers tools, selects relevant ones, executes tasks, reports back.
+Use `mcp-manager` agent when Gemini CLI unavailable. Task agent discovers tools, selects relevant ones, executes tasks, reports back.
 
 **Benefit**: Main context stays clean, only relevant tool definitions loaded when needed.
 
@@ -166,7 +166,7 @@ npx tsx cli.ts list-tools  # Saves to assets/tools.json
 npx tsx cli.ts call-tool memory create_entities '{"entities":[...]}'
 ```
 
-**Method 3: mcp-manager Subagent**
+**Method 3: mcp-manager Task agent**
 
 See [references/gemini-cli-integration.md](references/gemini-cli-integration.md) for complete guide.
 
@@ -193,7 +193,7 @@ See [references/mcp-protocol.md](references/mcp-protocol.md) for:
    - Use when: Need specific tool/server control
    - Execute: `npx tsx scripts/cli.ts call-tool <server> <tool> <args>`
 
-3. **mcp-manager Subagent** (Fallback): Context-efficient delegation
+3. **mcp-manager Task agent** (Fallback): Context-efficient delegation
    - Use when: Gemini unavailable or failed
    - Keeps main context clean
 

package/skills/mcp-management/references/gemini-cli-integration.md

@@ -206,7 +206,7 @@ Shows detailed MCP communication logs.
 | Direct Scripts | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | Specific tools |
 | mcp-manager | ⭐ | ⭐⭐ | ⭐⭐⭐ | Fallback |
 
-**Recommendation**: Use Gemini CLI as primary method, fallback to scripts/subagent when unavailable.
+**Recommendation**: Use Gemini CLI as primary method, fallback to scripts/Task agent when unavailable.
 
 ## Resources
 

package/skills/multi-agent-patterns/SKILL.md

@@ -12,7 +12,7 @@ Master orchestrator, peer-to-peer, and hierarchical multi-agent architectures
 Use this skill when working with master orchestrator, peer-to-peer, and hierarchical multi-agent architectures.
 # Multi-Agent Architecture Patterns
 
-Multi-agent architectures distribute work across multiple language model instances, each with its own context window. When designed well, this distribution enables capabilities beyond single-agent limits. When designed poorly, it introduces coordination overhead that negates benefits. The critical insight is that sub-agents exist primarily to isolate context, not to anthropomorphize role division.
+Multi-agent architectures distribute work across multiple language model instances, each with its own context window. When designed well, this distribution enables capabilities beyond single-agent limits. When designed poorly, it introduces coordination overhead that negates benefits. The critical insight is that Task agents exist primarily to isolate context, not to anthropomorphize role division.
 
 ## When to Activate
 
@@ -26,7 +26,7 @@ Activate this skill when:
 
 ## Core Concepts
 
-Multi-agent systems address single-agent context limitations through distribution. Three dominant patterns exist: supervisor/orchestrator for centralized control, peer-to-peer/swarm for flexible handoffs, and hierarchical for layered abstraction. The critical design principle is context isolation—sub-agents exist primarily to partition context rather than to simulate organizational roles.
+Multi-agent systems address single-agent context limitations through distribution. Three dominant patterns exist: supervisor/orchestrator for centralized control, peer-to-peer/swarm for flexible handoffs, and hierarchical for layered abstraction. The critical design principle is context isolation—Task agents exist primarily to partition context rather than to simulate organizational roles.
 
 Effective multi-agent systems require explicit coordination protocols, consensus mechanisms that avoid sycophancy, and careful attention to failure modes including bottlenecks, divergence, and error propagation.
 
@@ -75,20 +75,20 @@ When to use: Complex tasks with clear decomposition, tasks requiring coordinatio
 
 Advantages: Strict control over workflow, easier to implement human-in-the-loop interventions, ensures adherence to predefined plans.
 
-Disadvantages: Supervisor context becomes bottleneck, supervisor failures cascade to all workers, "telephone game" problem where supervisors paraphrase sub-agent responses incorrectly.
+Disadvantages: Supervisor context becomes bottleneck, supervisor failures cascade to all workers, "telephone game" problem where supervisors paraphrase Task agent responses incorrectly.
 
 **The Telephone Game Problem and Solution**
-LangGraph benchmarks found supervisor architectures initially performed 50% worse than optimized versions due to the "telephone game" problem where supervisors paraphrase sub-agent responses incorrectly, losing fidelity.
+LangGraph benchmarks found supervisor architectures initially performed 50% worse than optimized versions due to the "telephone game" problem where supervisors paraphrase Task agent responses incorrectly, losing fidelity.
 
-The fix: implement a `forward_message` tool allowing sub-agents to pass responses directly to users:
+The fix: implement a `forward_message` tool allowing Task agents to pass responses directly to users:
 
 ```python
 def forward_message(message: str, to_user: bool = True):
     """
-    Forward sub-agent response directly to user without supervisor synthesis.
-    
+    Forward Task agent response directly to user without supervisor synthesis.
+
     Use when:
-    - Sub-agent response is final and complete
+    - Task agent response is final and complete
     - Supervisor synthesis would lose important details
     - Response format must be preserved exactly
     """
@@ -97,9 +97,9 @@ def forward_message(message: str, to_user: bool = True):
     return {"type": "supervisor_input", "content": message}
 ```
 
-With this pattern, swarm architectures slightly outperform supervisors because sub-agents respond directly to users, eliminating translation errors.
+With this pattern, swarm architectures slightly outperform supervisors because Task agents respond directly to users, eliminating translation errors.
 
-Implementation note: Implement direct pass-through mechanisms allowing sub-agents to pass responses directly to users rather than through supervisor synthesis when appropriate.
+Implementation note: Implement direct pass-through mechanisms allowing Task agents to pass responses directly to users rather than through supervisor synthesis when appropriate.
 
 **Pattern 2: Peer-to-Peer/Swarm**
 The peer-to-peer pattern removes central control, allowing agents to communicate directly based on predefined protocols. Any agent can transfer control to any other through explicit handoff mechanisms.
@@ -137,17 +137,17 @@ Disadvantages: Coordination overhead between layers, potential for misalignment
 
 ### Context Isolation as Design Principle
 
-The primary purpose of multi-agent architectures is context isolation. Each sub-agent operates in a clean context window focused on its subtask without carrying accumulated context from other subtasks.
+The primary purpose of multi-agent architectures is context isolation. Each Task agent operates in a clean context window focused on its subtask without carrying accumulated context from other subtasks.
 
 **Isolation Mechanisms**
-Full context delegation: For complex tasks where the sub-agent needs complete understanding, the planner shares its entire context. The sub-agent has its own tools and instructions but receives full context for its decisions.
+Full context delegation: For complex tasks where the Task agent needs complete understanding, the planner shares its entire context. The Task agent has its own tools and instructions but receives full context for its decisions.
 
-Instruction passing: For simple, well-defined subtasks, the planner creates instructions via function call. The sub-agent receives only the instructions needed for its specific task.
+Instruction passing: For simple, well-defined subtasks, the planner creates instructions via function call. The Task agent receives only the instructions needed for its specific task.
 
 File system memory: For complex tasks requiring shared state, agents read and write to persistent storage. The file system serves as the coordination mechanism, avoiding context bloat from shared state passing.
 
 **Isolation Trade-offs**
-Full context delegation provides maximum capability but defeats the purpose of sub-agents. Instruction passing maintains isolation but limits sub-agent flexibility. File system memory enables shared state without context passing but introduces latency and consistency challenges.
+Full context delegation provides maximum capability but defeats the purpose of Task agents. Instruction passing maintains isolation but limits Task agent flexibility. File system memory enables shared state without context passing but introduces latency and consistency challenges.
 
 The right choice depends on task complexity, coordination needs, and acceptable latency.