@ngxtm/devkit 3.19.0 → 3.20.0

package/merged-commands/context-optimization.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/merged-commands/cook/auto/fast.md

@@ -3,7 +3,7 @@ description: ⚡ No research. Only scout, plan & implement ["trust me bro"]
 argument-hint: [tasks-or-prompt]
 ---
 
-Think harder to plan & start working on these tasks follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules: 
+Think harder to plan & start working on these tasks follow the Orchestration Protocol, Core Responsibilities, Task Agents Team and Development Rules: 
 <tasks>$ARGUMENTS</tasks>
 
 ---
@@ -21,6 +21,6 @@ Think harder to plan & start working on these tasks follow the Orchestration Pro
 
 ## Workflow:
 
-- **Scout**: Use `scout` subagent to find related resources, documents, and code snippets in the current codebase.
-- **Plan**: Trigger slash command `/plan:fast <detailed-instruction-prompt>` to create an implementation plan based on the reports from `scout` subagent.
+- **Scout**: Use a Task agent for scouting: Task(subagent_type="general-purpose", prompt="You are a scout. Find related resources, documents, and code snippets in the current codebase.", description="Scout codebase") to find related resources, documents, and code snippets in the current codebase.
+- **Plan**: Trigger slash command `/plan:fast <detailed-instruction-prompt>` to create an implementation plan based on the reports from the Task agent for scouting.
 - **Implementation**: Trigger slash command `/code "skip code review step" <plan-path-name>` to implement the plan.

package/merged-commands/cook/auto/parallel.md

@@ -10,7 +10,7 @@ argument-hint: [tasks]
 ## Workflow
 
 ### 1. Research (Optional)
-- Use max 2 `researcher` agents in parallel if tasks complex
+- Use max 2 Task agents for research in parallel if tasks complex
 - Use `/scout:ext` to search codebase
 - Keep reports ≤150 lines
 
@@ -20,30 +20,30 @@ argument-hint: [tasks]
 
 ### 3. Parallel Implementation
 - Read `plan.md` for dependency graph
-- Launch multiple `fullstack-developer` agents in PARALLEL for concurrent phases
-  - Example: "Phases 1-3 parallel" → launch 3 agents simultaneously
+- Launch multiple Task agents for fullstack development in PARALLEL for concurrent phases
+  - Example: "Phases 1-3 parallel" → launch 3 Task agents simultaneously
   - Pass phase file path: `{plan-dir}/phase-XX-*.md`
   - Include environment info
 - Wait for all parallel phases complete before dependent phases
 - Sequential phases: launch one agent at a time
 
 ### 4. Testing
-- Use `tester` subagent for full test suite
+- Use a Task agent for testing for full test suite
 - NO fake data/mocks/cheats
-- If fail: use `debugger`, fix, repeat
+- If fail: use Task agent for debugging, fix, repeat
 
 ### 5. Code Review
-- Use `code-reviewer` for all changes
+- Use Task agent for code review for all changes
 - If critical issues: fix, retest
 
 ### 6. Project Management & Docs
-- If approved: use `project-manager` + `docs-manager` in parallel
+- If approved: use Task agent for project management + Task agent for documentation in parallel
 - Update plan files, docs, roadmap
 - If rejected: fix and repeat
 
 ### 7. Final Report
 - Summary of all parallel phases
 - Guide to get started
-- Ask to commit (use `git-manager` if yes)
+- Ask to commit (use Task agent for git operations if yes)
 
-**Example:** Phases 1-3 parallel → Launch 3 fullstack-developer agents → Wait → Phase 4 sequential
+**Example:** Phases 1-3 parallel → Launch 3 Task agents for fullstack development → Wait → Phase 4 sequential

package/merged-commands/cook/auto.md

@@ -3,7 +3,7 @@ description: ⚡⚡ Implement a feature automatically ("trust me bro")
 argument-hint: [tasks]
 ---
 
-**Ultrathink** to plan & start working on these tasks follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules: 
+**Ultrathink** to plan & start working on these tasks follow the Orchestration Protocol, Core Responsibilities, Task Agents Team and Development Rules: 
 <tasks>$ARGUMENTS</tasks>
 
 **IMPORTANT:** Analyze the list of skills  at `.claude/skills/*` and intelligently activate the skills that are needed for the task during the process.

package/merged-commands/cook/fast.md

@@ -1,5 +1,5 @@
 ---
-description: ⚡ Quick Feature — Rapid feature implementation
+description: Quick Feature — Rapid feature implementation
 version: "1.0"
 category: engineering
 execution-mode: execute
@@ -13,30 +13,7 @@ execution-mode: execute
 
 ---
 
-## 🛑 PRE-FLIGHT (DO FIRST — BLOCKS PHASE 1)
-
-**LOAD now** (in order; path `./rules/` or `~/.{TOOL}/skills/agent-assistant/rules/`):
-
-1. ORCHESTRATION-LAWS.md
-2. ADAPTIVE-EXECUTION.md
-3. EXECUTION-PROTOCOL.md
-
-**⛔ Do not run Phase 1 until all are loaded.** Follow **all** rules in those files; they override any conflicting instructions in this file.
-
----
-
-## 🔀 TIERED EXECUTION
-
-| Tier       | When               | Action                       |
-| ---------- | ------------------ | ---------------------------- |
-| **TIER 1** | runSubagent EXISTS | Invoke sub-agent (MANDATORY) |
-| **TIER 2** | Tool MISSING       | EMBODY agent file (FALLBACK) |
-
-**❌ Anti-Lazy**: Never use TIER 2 when TIER 1 tool available.
-
----
-
-## 📁 PRIOR PLAN CHECK
+## PRIOR PLAN CHECK
 
 ```
 IF ./reports/plans/PLAN-{feature}.md exists:
@@ -49,38 +26,52 @@ Any files in `./reports/` or `./documents/` → English only.
 
 ---
 
-## ⛔ INCREMENTAL EXECUTION (MANDATORY)
+## Execution
 
-One phase at a time, each phase independent: Phase 1 → then Phase 2 → … in one reply. No batching (load only what each phase needs). **Within each phase:** when doing a part, output it in format so user sees what’s happening (announce before doing).
+One phase at a time, sequential. Each phase must complete before next begins.
 
 ---
 
-## 🎭 Phase 1: CONTEXT SCAN
+## Phase 1: CONTEXT SCAN
+
+| Attribute | Value                                         |
+| --------- | --------------------------------------------- |
+| **Role**  | `scouter`                                     |
+| **Goal**  | Quick context gathering                       |
+| **Exit**  | Patterns found, integration points identified |
+
+### Delegation
 
-| Agent | `scouter`                                     |
-| ----- | --------------------------------------------- |
-| Goal  | Quick context gathering                       |
-| Exit  | Patterns found, integration points identified |
+> Task(subagent_type="general-purpose", prompt="You are a scouter. Perform quick context gathering for the feature. Exit when: patterns found, integration points identified.", description="scouter: Quick context gathering")
 
 ---
 
-## 🎭 Phase 2: MICRO-PLANNING
+## Phase 2: MICRO-PLANNING
 
-| Agent | `planner`                          |
-| ----- | ---------------------------------- |
-| Goal  | Quick implementation checklist     |
-| Exit  | Steps identified, approach defined |
+| Attribute | Value                              |
+| --------- | ---------------------------------- |
+| **Role**  | `planner`                          |
+| **Goal**  | Quick implementation checklist     |
+| **Exit**  | Steps identified, approach defined |
+
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a planner. Create a quick implementation checklist for the feature. Exit when: steps identified, approach defined.", description="planner: Quick implementation checklist")
 
 ---
 
-## 🎭 Phase 3: IMPLEMENTATION
+## Phase 3: IMPLEMENTATION
+
+| Attribute        | Value                                                                 |
+| ---------------- | --------------------------------------------------------------------- |
+| **Role**         | Route by domain: UI → `frontend-engineer`, API → `backend-engineer`, DB → `database-architect` |
+| **Prerequisite** | READ `./reports/plans/PLAN-{feature}.md` if exists                    |
+| **Goal**         | Implement feature                                                     |
+| **Exit**         | Feature implemented, code compiles, basic testing done                |
+
+### Delegation
 
-| Agent        | Route by domain                                                               |
-| ------------ | ----------------------------------------------------------------------------- |
-| Route        | UI → `frontend-engineer`, API → `backend-engineer`, DB → `database-architect` |
-| Prerequisite | READ `./reports/plans/PLAN-{feature}.md` if exists                            |
-| Goal         | Implement feature                                                             |
-| Exit         | Feature implemented, code compiles, basic testing done                        |
+> Task(subagent_type="general-purpose", prompt="You are a domain engineer (frontend, backend, or database as appropriate). Implement the feature following existing patterns. READ plan file if exists. Exit when: feature implemented, code compiles, basic testing done.", description="engineer: Implement feature")
 
 ---
 
@@ -98,6 +89,6 @@ One phase at a time, each phase independent: Phase 1 → then Phase 2 → … in
 
 Present feature with:
 
-1. ✅ **Done** — Feature complete
-2. 🧪 **Test** → `/test`
-3. 📝 **Docs** → `/docs:core`
+1. **Done** — Feature complete
+2. **Test** → `/test`
+3. **Docs** → `/docs:core`

package/merged-commands/cook/hard.md

@@ -13,34 +13,9 @@ execution-mode: execute
 
 ---
 
-## 🛑 PRE-FLIGHT (DO FIRST — BLOCKS PHASE 1)
-
-**LOAD now** (in order; path `./rules/` or `~/.{TOOL}/skills/agent-assistant/rules/`):
-
-1. ORCHESTRATION-LAWS.md
-2. ADAPTIVE-EXECUTION.md
-3. EXECUTION-PROTOCOL.md
-
-**⛔ Do not run Phase 1 until all are loaded.** Follow **all** rules in those files; they override any conflicting instructions in this file.
-
----
-
-## 🔀 TIERED EXECUTION
-
-> Reference: `{RULES_PATH}/ADAPTIVE-EXECUTION.md`
-
-| Tier       | When                          | Action                       |
-| ---------- | ----------------------------- | ---------------------------- |
-| **TIER 1** | runSubagent/Agent Tool EXISTS | Invoke sub-agent (MANDATORY) |
-| **TIER 2** | Tool MISSING or SYSTEM error  | EMBODY agent file (FALLBACK) |
-
-**❌ Anti-Lazy**: Never use TIER 2 when TIER 1 tool available.
-
----
-
 ## 📁 DELIVERABLE FILES
 
-| Agent        | Output                                          |
+| Role         | Output                                          |
 | ------------ | ----------------------------------------------- |
 | brainstormer | `./reports/brainstorms/BRAINSTORM-{feature}.md` |
 | researcher   | `./reports/researchers/RESEARCH-{feature}.md`   |
@@ -70,77 +45,99 @@ All files in `./reports/` → English only.
 
 ---
 
-## ⛔ INCREMENTAL EXECUTION (MANDATORY)
-
-One phase at a time, each phase independent: Phase 1 → then Phase 2 → … in one reply. No batching (load only what each phase needs). **Within each phase:** when doing a part, output it in format so user sees what’s happening (announce before doing). Format: rules/EXECUTION-PROTOCOL.md § Phase output structure.
-
----
-
 ## 🎭 Phase 1: REQUIREMENTS CLARIFICATION
 
-| Agent | `brainstormer`                                                       |
+| Role  | `brainstormer`                                                       |
 | ----- | -------------------------------------------------------------------- |
 | Goal  | Full requirements discovery                                          |
 | Exit  | Requirements clear, constraints identified, success criteria defined |
 
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a brainstormer. Full requirements discovery. [See exit criteria above]", description="brainstormer")
+
 ---
 
 ## 🎭 Phase 2: RESEARCH
 
-| Agent | `researcher`                                                               |
+| Role  | `researcher`                                                               |
 | ----- | -------------------------------------------------------------------------- |
 | Goal  | Research best practices and patterns                                       |
 | Exit  | Patterns researched, best practices identified, recommendations documented |
 
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a researcher. Research best practices and patterns. [See exit criteria above]", description="researcher")
+
 ---
 
 ## 🎭 Phase 3: CODEBASE ANALYSIS
 
-| Agent | `scouter`                                                               |
+| Role  | `scouter`                                                               |
 | ----- | ----------------------------------------------------------------------- |
 | Goal  | Map architecture and integration points                                 |
 | Exit  | Architecture understood, integration points mapped, patterns documented |
 
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a scouter. Map architecture and integration points. [See exit criteria above]", description="scouter")
+
 ---
 
 ## 🎭 Phase 3.5: DATABASE DESIGN (IF DATA CHANGES)
 
-| Agent   | `database-architect`                                        |
+| Role    | `database-architect`                                        |
 | ------- | ----------------------------------------------------------- |
 | Trigger | Feature involves database changes/migrations                |
 | Goal    | Schema design and data modeling                             |
 | Exit    | Schema designed, migrations planned, query patterns defined |
 
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a database-architect. Schema design and data modeling. [See exit criteria above]", description="database-architect")
+
 ---
 
 ## 🎭 Phase 4: DESIGN (IF UI NEEDED)
 
-| Agent   | `designer`                                            |
+| Role    | `designer`                                            |
 | ------- | ----------------------------------------------------- |
 | Trigger | Feature has UI components                             |
 | Goal    | UI/UX design                                          |
 | Exit    | Design created, accessibility considered, specs ready |
 
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a designer. UI/UX design. [See exit criteria above]", description="designer")
+
 ---
 
 ## 🎭 Phase 5: PLANNING
 
-| Agent        | `planner`                                           |
+| Role         | `planner`                                           |
 | ------------ | --------------------------------------------------- |
 | Prerequisite | **READ** RESEARCH + SCOUT + DESIGN files            |
 | Goal         | Create detailed implementation plan                 |
 | Output       | `./reports/plans/PLAN-{feature}.md`                 |
 | Exit         | Plan file created, phases defined, risks identified |
 
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a planner. READ RESEARCH + SCOUT + DESIGN files. Create detailed implementation plan. [See exit criteria above]", description="planner")
+
 ---
 
 ## 🎭 Phase 6: IMPLEMENTATION
 
-| Agent        | `tech-lead` → routes to specialists                     |
+| Role         | `tech-lead` → routes to specialists                     |
 | ------------ | ------------------------------------------------------- |
 | Prerequisite | **READ and FOLLOW** `./reports/plans/PLAN-{feature}.md` |
 | Goal         | Execute implementation plan                             |
 
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a tech-lead. READ and FOLLOW the PLAN file. Execute implementation plan. [See exit criteria below]", description="tech-lead")
+
 **STRICT ADHERENCE:**
 
 ```
@@ -159,11 +156,15 @@ One phase at a time, each phase independent: Phase 1 → then Phase 2 → … in
 
 ## 🎭 Phase 7: TESTING
 
-| Agent        | `tester`                     |
+| Role         | `tester`                     |
 | ------------ | ---------------------------- |
 | Prerequisite | **READ** PLAN + Code changes |
 | Goal         | Comprehensive testing        |
 
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a tester. READ PLAN + Code changes. Comprehensive testing with plan checkpoint verification. [See exit criteria below]", description="tester")
+
 **PLAN CHECKPOINT VERIFICATION:**
 
 ```
@@ -178,11 +179,15 @@ FOR EACH checkpoint in PLAN:
 
 ## 🎭 Phase 8: REVIEW
 
-| Agent        | `reviewer`                       |
+| Role         | `reviewer`                       |
 | ------------ | -------------------------------- |
 | Prerequisite | **READ** PLAN + Code + Tests     |
 | Goal         | Quality review + Plan compliance |
 
+### Delegation
+
+> Task(subagent_type="general-purpose", prompt="You are a reviewer. READ PLAN + Code + Tests. Quality review and plan compliance check. [See exit criteria below]", description="reviewer")
+
 **REVIEW CHECKLIST:**
 
 - Does code implement plan specification?

package/merged-commands/cook.md

@@ -3,14 +3,14 @@ description: ⚡⚡⚡ Implement a feature [step by step]
 argument-hint: [tasks]
 ---
 
-Think harder to plan & start working on these tasks follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules: 
+Think harder to plan & start working on these tasks follow the Orchestration Protocol, Core Responsibilities, Task Agents Team and Development Rules: 
 <tasks>$ARGUMENTS</tasks>
 
 ---
 
 ## Role Responsibilities
 - You are an elite software engineering expert who specializes in system architecture design and technical decision-making. 
-- Your core mission is to collaborate with users to find the best possible solutions while maintaining brutal honesty about feasibility and trade-offs, then collaborate with your subagents to implement the plan.
+- Your core mission is to collaborate with users to find the best possible solutions while maintaining brutal honesty about feasibility and trade-offs, then collaborate with your Task agents to implement the plan.
 - You operate by the holy trinity of software engineering: **YAGNI** (You Aren't Gonna Need It), **KISS** (Keep It Simple, Stupid), and **DRY** (Don't Repeat Yourself). Every solution you propose must honor these principles.
 
 ---
@@ -41,13 +41,13 @@ Think harder to plan & start working on these tasks follow the Orchestration Pro
 
 ### Research
 
-* Use multiple `researcher` subagents in parallel to explore the user's request, idea validation, challenges, and find the best possible solutions.
+* Use multiple Task agents for research in parallel to explore the user's request, idea validation, challenges, and find the best possible solutions.
 * Keep every research markdown report concise (≤150 lines) while covering all requested topics and citations.
 * Use `/scout:ext` (preferred) or `/scout` (fallback) slash command to search the codebase for files needed to complete the task
 
 ### Plan
 
-*. Use `planner` subagent to analyze reports from `researcher` and `scout` subagents to create an implementation plan using the progressive disclosure structure:
+*. Use a Task agent for planning: Task(subagent_type="general-purpose", prompt="You are a planner. Analyze reports from researcher and scout Task agents to create an implementation plan using the progressive disclosure structure:...
   - Create a directory using naming pattern from `## Naming` section.
   - Save the overview access point at `plan.md`, keep it generic, under 80 lines, and list each phase with status/progress and links.
   - For each phase, add `phase-XX-phase-name.md` files containing sections (Context links, Overview with date/priority/statuses, Key Insights, Requirements, Architecture, Related code files, Implementation Steps, Todo list, Success Criteria, Risk Assessment, Security Considerations, Next steps).
@@ -55,7 +55,7 @@ Think harder to plan & start working on these tasks follow the Orchestration Pro
 ### Implementation
 
 * Use `/code` Slash Command to implement the plan step by step, follow the implementation plan in `./plans` directory.
-* Use `ui-ux-designer` subagent to implement the frontend part follow the design guidelines at `./docs/design-guidelines.md` file.
+* Use a Task agent for UI/UX design: Task(subagent_type="general-purpose", prompt="You are a ui-ux-designer. Implement the frontend part follow the design guidelines at ./docs/design-guidelines.md file.", description="Implement frontend UI") to implement the frontend part follow the design guidelines at `./docs/design-guidelines.md` file.
   * Use `ai-multimodal` skill to generate image assets.
   * Use `ai-multimodal` skill to analyze and verify generated assets.
   * Use `media-processing` skill for image editing (crop, resize, remove background) if needed.
@@ -64,13 +64,13 @@ Think harder to plan & start working on these tasks follow the Orchestration Pro
 ### Testing
 
 * Write the tests for the plan, **make sure you don't use fake data, mocks, cheats, tricks, temporary solutions, just to pass the build or github actions**, tests should be real and cover all possible cases.
-* Use `tester` subagent to run the tests, make sure it works, then report back to main agent.
-* If there are issues or failed tests, use `debugger` subagent to find the root cause of the issues, then ask main agent to fix all of them and 
+* Use a Task agent for testing: Task(subagent_type="general-purpose", prompt="You are a tester. Run the tests, make sure it works, then report back to main agent.", description="Run tests") to run the tests, make sure it works, then report back to main agent.
+* If there are issues or failed tests, use a Task agent for debugging: Task(subagent_type="general-purpose", prompt="You are a debugger. Find the root cause of the issues.", description="Debug failures") to find the root cause of the issues, then ask main agent to fix all of them and 
 * Repeat the process until all tests pass or no more issues are reported. Again, do not ignore failed tests or use fake data just to pass the build or github actions.
 
 ### Code Review
 
-* After finishing, delegate to `code-reviewer` subagent to review code. If there are critical issues, ask main agent to improve the code and tell `tester` agent to run the tests again. 
+* After finishing, delegate to a Task agent for code review: Task(subagent_type="general-purpose", prompt="You are a code-reviewer. Review code.", description="Code review") to review code. If there are critical issues, ask main agent to improve the code and tell the Task agent for testing to run the tests again.
 * Repeat the "Testing" process until all tests pass.
 * When all tests pass, code is reviewed, the tasks are completed, report back to user with a summary of the changes and explain everything briefly, ask user to review the changes and approve them.
 * **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
@@ -78,10 +78,10 @@ Think harder to plan & start working on these tasks follow the Orchestration Pro
 ### Project Management & Documentation
 
 **If user approves the changes:**
-* Use `project-manager` and `docs-manager` subagents in parallel to update the project progress and documentation:
-  * Use `project-manager` subagent to update the project progress and task status in the given plan file.
-  * Use `docs-manager` subagent to update the docs in `./docs` directory if needed.
-  * Use `project-manager` subagent to create a project roadmap at `./docs/project-roadmap.md` file.
+* Use Task agents for project management and documentation in parallel to update the project progress and documentation:
+  * Use a Task agent for project management: Task(subagent_type="general-purpose", prompt="You are a project-manager. Update the project progress and task status in the given plan file.", description="Update project progress") to update the project progress and task status in the given plan file.
+  * Use a Task agent for documentation: Task(subagent_type="general-purpose", prompt="You are a docs-manager. Update the docs in ./docs directory if needed.", description="Update docs") to update the docs in `./docs` directory if needed.
+  * Use a Task agent for project management: Task(subagent_type="general-purpose", prompt="You are a project-manager. Create a project roadmap at ./docs/project-roadmap.md file.", description="Create roadmap") to create a project roadmap at `./docs/project-roadmap.md` file.
 * **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
 
 **If user rejects the changes:**
@@ -95,7 +95,7 @@ Think harder to plan & start working on these tasks follow the Orchestration Pro
 
 ### Final Report
 * Report back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.
-* Ask the user if they want to commit and push to git repository, if yes, use `git-manager` subagent to commit and push to git repository.
+* Ask the user if they want to commit and push to git repository, if yes, use a Task agent for git operations: Task(subagent_type="general-purpose", prompt="You are a git-manager. Commit and push to git repository.", description="Git commit and push") to commit and push to git repository.
 - **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
 - **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
 

package/merged-commands/daily-news-report.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**: