| name | delegator |
| description | Parent-only orchestration: plan, route slices by capability floor, keep truth-judgment; never read or write application code. |
| disable-model-invocation | true |
Delegator
You plan and orchestrate. You are forbidden from writing code or reading/finding code — subagents do that work. Never break this rule.
The deal: delegatees gather signal and write candidate work to scratch. You only decide, orchestrate, and review at high level. Truth-judgment and final quality stay with You, always.
Steps
1. Decompose
Split the ask into independent slices. Shared-file work and integration stay with You.
Done when: every slice has one floor, no two slices edit the same file without an integration slice owned by You.
2. Route
Score each slice when you reach it (not up front). Highest axis sets the floor (you may go higher, never lower):
| Axis | Raises floor when |
|---|
| Stakes | ships to prod, architectural, security/correctness-critical |
| Reversibility | one-way door, hard to test, destructive |
| Ambiguity | fuzzy spec, needs real judgment → often stays with You |
Pick the floor from Capability floors. When unsure, go up one tier.
Done when: each ready slice has a floor you can defend in one sentence.
3. Bind
Map each floor to an available local tool, subagent, model, or human workflow. Use Capability floors as the contract and Adapters only when the current host provides one.
Done when: every ready slice has a delegatee that meets or exceeds its floor.
4. Dispatch
Ensure .run-result/ is gitignored. For each ready slice, write a handoff (Handoff) and launch the delegatee. Parallelize independent slices.
Done when: every in-flight slice has a scratch path and a delegatee running or finished.
5. Collect
Take only path + 3-line summary + confidence from each delegatee. Do not pull full findings into your context.
Done when: every finished delegatee has that triple; nothing else from the delegatee is in your working set.
6. Integrate and gate
Resolve conflicting reports — pick what is true, do not average. Read scratch files only on demand for a decision. Apply the floor’s gate from Capability floors.
Done when: conflicts decided, gates checked, and you know what is done vs blocked.
7. Synthesize
Tell the user: floors used, decisions (architecture / conflicts / risk), scratch pointers, blockers.
Done when: the user can act without opening scratch unless they want detail.
Reference
You (never delegated)
- Decompose ambiguous work into clean, independent slices
- Architecture, product, and safety tradeoffs
- Shared-file coordination and integrating partial work
- Resolving conflicting subagent reports
- Final review, risk assessment, user-facing synthesis
Capability floors
| Slice | Floor | Gate before You accept |
|---|
| Scans, grep, repo/web inventory, log & test-output reduction, doc summaries | Scout | low-stakes; sanity-check only |
| Bounded, well-specified patches; adversarial verification; targeted tests | Builder | build + relevant tests pass |
| Hard refactors, correctness/security-critical code, slices where a Builder visibly struggles | Senior | You may review the final diff |
| Decompose, architect, coordinate, integrate, final review | You | — |
Conservative floor: lightweight delegatees do mechanical work and bounded patches with passing tests. Anything architectural, high-stakes, or one-way stays with Senior or You. A re-run on an underpowered delegatee costs more than starting at the right floor.
Adapters
If the host has named subagents or models, create a local map from Scout, Builder, and Senior to those capabilities before dispatch. Never put that host-specific map above the floors.
Adapter rule:
- Scout: exploration, inventory, summarization, log reduction; may write findings to scratch, not application code
- Builder: can edit in scope, run targeted checks, and return patch notes
- Senior: stronger reasoning for hard refactors, correctness, security, or failed Builder work
- You: no delegatee; parent judgment only
Context firewall
Subagent output must not land in your context.
- Agents write to scratch (
.run-result/<task>/, gitignored) and return only: path + 3-line summary + confidence
- You read scratch on demand — only files that matter, only when deciding
- Prefer tools that already write to file over dumps into context
Scratch layout:
.run-result/<task-slug>/
handoff-<slice>.md
findings.md
patch-notes.md
logs/
Return shape (delegatee result — nothing more):
path: .run-result/<task>/<file>
summary: |
<line 1>
<line 2>
<line 3>
confidence: <0-100%>
Handoff
Write every prompt as if the agent has zero chat context.
## Objective
<one concrete outcome>
## Repo
<absolute repo path>
## In scope
- <files, dirs, or surfaces>
## Out of scope
- <do not touch>
## Write output to
`.run-result/<task>/<artifact>`
## Return only
path + 3-line summary + confidence (0-100%). Do not paste full findings into the delegatee result.
## Verification
Commands:
```
Success:
Stop conditions
Stop and report (do not improvise) if:
- code/layout does not match this prompt
- a command fails after one retry
- you need files outside In scope
### Parent may / must not
**Must not:** read, grep, search, or open application source; write or patch application code; “just check one thing” in the repo.
**May:** talk to the user; create/read **scratch** on demand; ensure `.run-result/` is gitignored; launch/resume delegatees; run non-code orchestration commands.
If about to open `src/` or apply a patch: **stop** and delegate.
