Partition Scopes To Subagents

---
name: partition-scopes-to-subagents
description: 'Use when asked to partition non-overlapping scopes across subagents and drive each to completion with fresh review, fix reports, and a glanceable actual-work map. Not for concurrent independent sub-tasks — use parallel-launch.'
---

# Partition scopes to subagents

## Contract

| Field | Bound contract |
|---|---|
| Trigger | User names work that decomposes into non-overlapping scopes and asks to partition and execute them with subagents. |
| Authority | reversible-local: writes scoped to each subagent's assigned files, per-scope artifacts, and a coordination map; no VCS, credential, paid, published, or deployed mutation. |
| Side effect | Subagent briefs, per-scope work artifacts, review reports, fix reports, and an actual-work map written to local files only. |
| Done | All scopes return a review report and a fix report; an actual-work map lists every scope and its terminal status. |

## Inputs

- Scopes (required): Named, non-overlapping work units with explicit boundaries. Supplied by the user or derived from a map the user provides.
- Scope assignment (required): Which subagent owns which scope. Stated explicitly by the user or inferred from a DAG/map the user approves.
- Review duty (required): Each scope requires a fresh reviewer subagent after the implementer subagent completes. The reviewer is not the implementer.
- Compiled map (optional): A DAG, war map, or state machine providing deterministic skeleton routing. Provide it if the user supplied one; otherwise derive from the stated scopes.

## Procedure

1. **Validate scope non-overlap.** Before dispatching any subagent, confirm each named scope touches disjoint file sets or the user explicitly approved overlap. Stop if two scopes target the same file. Done when: all scopes are confirmed non-overlapping or overlap is user-approved.
2. **Compile the map.** If the user supplied a DAG or war map, adopt it as the execution skeleton. If not, derive a flat execution map from the stated scopes: one node per scope, no ordering edges. The map is the source of truth for what each subagent must do. Done when: the execution map is compiled and adopted as source of truth.
3. **Draft scope briefs.** For each scope, write a self-contained subagent brief containing: goal (one sentence), exact files or directories in scope, constraints from the parent task, and the completion predicate. Briefs are paths, not pasted content. Done when: a self-contained brief is written for each scope.
4. **Dispatch implementer subagents.** Dispatch one fresh implementer subagent per scope with its brief. Each implementer works in isolation and writes its result to a per-scope artifact file. Done when: one implementer is dispatched per scope with its brief.
5. **Dispatch fresh reviewer subagents.** After each implementer completes, dispatch a new reviewer subagent to audit that scope's artifact. The reviewer is not the same agent as the implementer. Collect the review report per scope. Done when: a fresh reviewer is dispatched per scope and review reports are collected.
6. **Route fix reports.** If the reviewer reports findings, dispatch a fix subagent for that scope and collect its fix report. Repeat review until the reviewer reports no blocking findings for that scope. Done when: each scope's reviewer reports no blocking findings.
7. **Record in the actual-work map.** After each scope reaches its terminal review status, write one entry in the actual-work map: scope name, implementer status, reviewer status, fix count, and terminal verdict. Done when: every scope has an entry in the actual-work map.
8. **Converge.** Once all scopes have terminal verdicts and all review reports are filed, the skill is done. Done when: all scopes have terminal verdicts and review reports are filed.

## Failure and recovery
- Scope overlap detected: Stop before dispatch. Return the conflicting scopes and ask the user to clarify boundaries.
- Subagent reports BLOCKED: Record BLOCKED in the actual-work map for that scope. Continue with other scopes. Report the full blocked list after all convergent scopes finish.
- Reviewer escalation: A reviewer finding that requires cross-scope knowledge returns to the controller, not to the implementer. Record the escalation in the actual-work map and resolve it before marking that scope done.
- Subagent crash: Re-dispatch the same brief to a fresh implementer subagent for that scope. Do not carry forward partial state from the crashed run.
- Non-converged result: If any scope remains BLOCKED after one re-dispatch, record the exhaustion and stop. Do not loop indefinitely.

## Output
One `actual-work-map.md` listing every scope with terminal status (done, blocked, or failed), reviewer verdict, and fix count — plus one review report per scope, one fix report per scope that required fixes, and one brief file per scope.