This skill should be used when the user asks to 'implement milestone', 'implement all tasks', 'implement m5', or when working on an entire milestone's worth of tasks. Orchestrates milestone-level implementation across task groups with agent teams.
Orchestrate the implementation of an entire milestone by dispatching one agent per task. The orchestrator NEVER writes implementation code — it only gathers context, dispatches agents, validates results, and updates task status. Each agent uses /engy:implement for per-task TDD flow.
listTasks(projectId, milestoneRef, taskGroupId) — find tasks for the milestonelistTaskGroups(milestoneRef) — task groups within the milestoneupdateTask(id, status) — mark tasks in_progress / donegetProjectDetails(projectId) — project paths (specDir, projectDir)Use MCP to discover paths and task relationships, then Read/Glob/Grep for content.
The orchestrator is a pure coordinator. It gathers context, plans execution order, dispatches team members, verifies their results, and updates task status. It NEVER writes or modifies implementation code itself. All implementation work happens inside subagents.
listTaskGroups(milestoneRef) — get all task groups for the milestone.listTasks(milestoneRef, taskGroupId) to fetch only that group's tasks. Otherwise use listTasks(milestoneRef) for all tasks. Use compact: true (default) for the initial fetch to keep output small, then fetch full descriptions (compact: false) only for the tasks you'll actually dispatch.Glob("{specPath}/milestones/m{N}-*.plan.md"). Read it if found — this is the primary requirements source.{specPath}/spec.md for overall context.Read the project's CLAUDE.md to find all explicit validation and testing instructions. Extract two levels:
tsc at the monorepo root or across dependent packages) in both lightweight and full validation commands — not just the package being modified.blockedBy pointing to tasks in another group).blockedBy dependencies on other tasks in the same group → candidates for parallel dispatch.blockedBy dependencies within the group → serialized in dependency order after their blockers complete.done.in_progress tasks, check existing work via git status and git diff before re-dispatching.For each task group, in sequence:
Mark all tasks in the group as in_progress via updateTask(id, status: "in_progress").
One agent per task. For each task, spawn an agent with:
Parallelism: If multiple tasks in the group have no mutual blockedBy dependencies and pass the file overlap check (Step 3.4), spawn them as concurrent team members in a single message with multiple Agent tool calls. Dependent tasks wait until their blockers complete, then get dispatched.
Never use worktree isolation (isolation: "worktree") for parallel agents. Use regular agents with explicit file-ownership lists instead. Each agent receives a list of files it owns (may modify) and files it must not touch.
Agent prompt template:
Implement the following task using /engy:implement:
Task: {task title}
Description: {task description}
Plan context:
{relevant plan section}
Files you OWN (may create/modify):
{list of files this agent is responsible for}
Files you must NOT modify:
{list of files owned by other parallel agents or out of scope}
Before returning, you MUST:
1. Run these validation commands and fix any issues:
{lightweight validation commands from Step 2}
2. Commit your changes with a descriptive commit message.
3. Report back: what you implemented, what you committed, any issues encountered.
CRITICAL safety rules:
- Do NOT modify files outside your ownership list.
- NEVER run git stash, git reset, or any destructive git command.
- If something breaks on files you didn't touch, ignore it and report back.
As each team member returns:
done via updateTask(id, status: "done").After all tasks in a group complete, run the full validation gate (discovered in Step 2) before proceeding to the next group. This catches cross-task integration issues early. If validation fails, dispatch fix agents for the failing issues before moving on.
After all task groups complete:
Present a summary to the user:
done after a successful commit.isolation: "worktree" for parallel agents — use regular agents with explicit file-ownership lists.git stash, git reset, or other destructive git commands.references/agent-team-coordination.md - Task-level parallelization criteria, agent context requirements, and conflict prevention guidelinesPrevious: validate-plan | Next: review
When all tasks are complete and passing, proceed with /engy:review for a final code review of all changes.