delegate
TRIGGER when: asked to delegate work, execute or parallelize a plan, "run this plan", or "delegate this". Writing, reading, or finishing a plan is not a trigger and authorizes no dispatch. Decomposes work by dependency, launches bounded provider-native workers in parallel waves, validates completion, and reports results while preserving failure isolation and recursion limits. Keeps judgment in the active session and coupled implementation with one continuing worker.
mifunedev · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add mifunedev/agro --skill delegate技能说明
name: delegate description: | TRIGGER when: asked to delegate work, execute or parallelize a plan, "run this plan", or "delegate this". Writing, reading, or finishing a plan is not a trigger and authorizes no dispatch. Decomposes work by dependency, launches bounded provider-native workers in parallel waves, validates completion, and reports results while preserving failure isolation and recursion limits. Keeps judgment in the active session and coupled implementation with one continuing worker. argument-hint: "[--plan ] [--dry-run]"
Delegate
Parallel execution coordinator. Read a plan or conversation context, decompose it into a dependency-ordered task graph, and spawn worker sub-agents in parallel waves. Each wave completes before the next begins. Results are collected, validated, and reported.
Core principle: dependency order is absolute. Size each task for usefulness, not for a worker count.
When a worker is justified
Use a worker only when the task is self-contained and gains from parallelism, isolated context, restricted tools, or containment of verbose disposable output. Keep judgment in the active session when phases share substantial context or require iterative refinement; keep coupled implementation with one continuing worker.
A worker is a bounded execution context, not a project role. The active coding
agent is the runtime and stays the owner of the work; skills — /architect,
/spec, /audit, /retro — are how it adopts a role. The active session acts as
advisor: it keeps goal interpretation, architecture, decomposition, verification,
and acceptance, and it assigns bounded implementation to workers. Delegation buys
isolation, parallelism, and bounded implementation, and nothing else.
| Assign it to a worker | Keep it in the active session |
|---|---|
| Tracked implementation edits: code, tests, docs, integration fixes, repair | Goal interpretation, architecture, decomposition, verification, acceptance |
| Coupled implementation, in one continuing worker | Reconciliation of results that share substantial context |
| Independent parallel research or source sweeps | Iterative refinement against operator feedback |
| Verbose disposable output — logs, search dumps, test runs | A result you would have to re-derive to use |
| Disjoint file ownership with no shared mutable state | The second of two tasks that touch the same file, until the first completes |
| A deliberate tool or permission restriction | Task state: prd.json, progress.txt, and acceptance records |
A small task can use one worker; parallelism is not mandatory. A factual question
or a plan-only request needs no worker: loading this skill, writing a plan, or
finishing a plan authorizes no dispatch and creates no execution state. Do not
invent named architectural roles for workers. /delegate owns fan-out policy;
other skills must not grow a competing worker hierarchy beside it.
Complexity classification
Classify each subtask by uncertainty, blast radius, security exposure, reversibility, context requirements, and acceptance clarity. Line count alone does not determine complexity. Mechanical work has known transformations and decisive checks. Ambiguous requirements, cross-boundary changes, migrations, and uncertain debugging warrant stronger reasoning before a worker writes. The advisor resolves architecture; even a high-capability worker receives bounded implementation scope, never an instruction to redesign the architecture.
Coupled implementation stays with one continuing worker. Use the provider's native continuation when it exists; otherwise checkpoint the artifacts and rebrief the next bounded worker with only the incomplete scope. Never replay completed work. Parallel writers get isolated worktrees. Serialize shared-file work. Workers stay flat unless the recursion-authorization gate in step 5 authorizes recursion.
Worker model and reasoning policy
Apply this policy to every worker:
- Explicit operator selections and exclusions are binding. Pass a selected model unchanged; never dispatch to an excluded model.
- Select unspecified settings per task. Choose the model and reasoning setting from the task's complexity, risk, and the authorized budget. Record the selection reason in the dispatch record before dispatch.
- Perform a native capability check first. Before the first dispatch, confirm
which model and reasoning controls the running provider's worker tool exposes.
Record the requested settings and the observed settings separately, each with its
provenance. An unknown value stays
unknown; never record it as confirmed or zero. A display name or an accepted request does not prove the effective configuration. - An unsupported required control blocks. When a required model or reasoning
control is unavailable, mark the affected worker and its dependents
BLOCKEDand ask the operator for an authorized alternative. Never substitute a model, lower a setting, change shared or parent settings, or call a nested inference CLI to obtain the control. - Escalate reasoning only on evidence. Raise a worker's reasoning setting only when evidence shows uncertainty or repeated failure, never because a tool or a credential is missing.
- Stop at the declared budget. When a task reaches its declared budget, stop and ask the operator; do not retry indefinitely.
Provider-specific preferences (Claude Code)
The preferences below are operator preferences, not the portable role definition. Each one requires native verification before use.
- The advisor session runs on Fable 5.1 with the operator-selected effort.
- A low-complexity worker runs on Opus.
- The advisor judges the effort level for each worker task:
lowfor mechanical work,mediumfor standard work,highorxhighfor high-uncertainty work, nevermax. Record the selected effort and its reason in the dispatch r