agency-execute

Great Minds Agency — Wave Execution (GSD-Style)

Execute a planned phase using wave-based parallel execution with atomic commits.

Daemon Integration

When running under the daemon (/agency-daemon), the build phase uses a structured build approach instead of raw wave execution:

1. build-setup agent creates spec.md, todo.md, and tests/ before any code
2. builder agent works through todo.md item by item, running tests after each
3. build-reviewer (full pipeline only) does adversarial review of spec vs implementation
4. Hotfix builds skip the reviewer and use a tighter prompt with max 15 turns

The wave-based XML approach described below is used when invoking /agency-execute directly (outside the daemon). Both approaches produce the same output: committed code in the deliverables directory.

Context

This skill executes plans generated by /agency-plan:

• Wave parallelism — independent tasks run simultaneously via sub-agents
• Fresh context — each sub-agent gets only its task plan, no accumulated context rot
• Atomic commits — every completed task gets its own git commit
• Fail-safe — failed tasks don't block independent tasks in the same wave

Instructions

Step 1: Load the Phase Plan

Read engineering/phase-{N}-plan.md

Parse all <task-plan> XML blocks. Build the wave execution order. If no plan exists, tell the user to run /agency-plan {N} first.

Step 2: Pre-Flight Checks

Before executing anything:

# Clean working tree required
git status --porcelain
# Must be empty — uncommitted changes block atomic commits

# Ensure we're on the right branch
git branch --show-current
# Should be feature/{phase-name} or similar

# Build passes before we start
npm run build 2>&1 || echo "BUILD FAILED — fix before executing"

If pre-flight fails, STOP and report. Do not proceed with a dirty tree.

Step 3: Execute Wave by Wave

For each wave (1, 2, 3, ...):

3a. Spawn Parallel Sub-Agents

For each task in the current wave, spawn a haiku sub-agent with:

You are executing a single task from a phase plan.
Your ONLY job is to complete this task and verify it works.

## Task Plan
{paste the full XML task-plan here}

## Rules
1. Read EVERY file listed in <context> before making changes
2. Follow <steps> in exact order
3. Run ALL <verification> checks before reporting done
4. Do NOT modify files outside your task's scope
5. Do NOT commit — the orchestrator handles commits
6. If a step fails, report the failure with full error output

## Report Format
When done, report:
- STATUS: PASS or FAIL
- FILES_CHANGED: [list of files you modified]
- VERIFICATION: [results of each check]
- ERRORS: [any issues encountered]

Launch all tasks in the wave simultaneously using parallel Agent calls.

3b. Collect Results

Wait for all sub-agents in the wave to complete. For each:

• PASS: Stage changed files and create atomic commit:

  git add {files_changed}
  git commit -m "{commit-message from task-plan}
  
  Task: {task-id}
  Wave: {wave-number}
  Phase: {phase-number}
  
  Co-Authored-By: Claude <[email protected]>"
  

• FAIL: Log the failure, DO NOT commit. Add to retry queue.

3c. Wave Gate

Before proceeding to the next wave:

1. All PASS tasks are committed
2. Build still passes: npm run build
3. Tests still pass: npm run test

If the build breaks after commits:

• Identify which commit broke it
• Revert that specific commit: git revert {sha} --no-edit
• Add the task to the retry queue
• Continue to next wave

Step 4: Handle Failures

After all waves complete, for any failed tasks:

1. Analyze: Read the error output from the sub-agent
2. Diagnose: Spawn a haiku debug agent to investigate
3. Retry Once: Re-execute with additional context from the diagnosis
4. Escalate: If retry fails, log to STATUS.md and alert the user

Step 5: Update State

After execution completes, update STATUS.md:

phase: {N}
state: executed
tasks_total: {count}
tasks_complete: {pass_count}
tasks_failed: {fail_count}
tasks_retried: {retry_count}
last_commit: {sha}

Write an execution report to engineering/phase-{N}-execution.md:

# Phase {N} Execution Report
**Date**: {date}
**Duration**: {approximate time}
**Branch**: {branch-name}

## Wave Results
| Wave | Tasks | Passed | Failed | Commits |
|------|-------|--------|--------|---------|
| 1 | 3 | 3 | 0 | abc1234, def5678, ghi9012 |
| 2 | 2 | 1 | 1 | jkl3456 |
| ... | ... | ... | ... | ... |

## Commit Log
| Task ID | Commit | Message |
|---------|--------|---------|
| phase-1-task-1 | abc1234 | feat: add user auth endpoint |
| ... | ... | ... |

## Failed Tasks
| Task ID | Error | Retry Status |
|---------|-------|--------------|
| phase-1-task-5 | Type error in... | RETRY_PASS / RETRY_FAIL |

## Next Steps
- Run `/agency-verify {N}` to validate all work
- {Any manual steps needed}

Pre-PR Quality Gates (Auto-Trigger)

Before any PR is created from a task execution, run these conditional reviews:

Jony Ive — Visual Review (UI/Frontend Tasks Only)

If the task involves UI, frontend, CSS, components, or design:

Agent(model: "haiku", subagent_type: "jony-ive-designer",
  prompt: "Review the changes in this branch for visual quality.
  Read the changed files. Evaluate:
  - Is every element intentional? Remove anything that doesn't need to be there.
  - Does spacing, alignment, and typography feel considered?
  - Would this embarrass us on a stage demo?
  Write a brief visual review (pass/fail with notes) to rounds/{project}/jony-ive-review-{task-id}.md")

Maya Angelou — Copy Review (Text/Messaging Tasks Only)

If the task involves copy, messaging, landing pages, emails, or user-facing text:

Agent(model: "haiku", subagent_type: "maya-angelou-writer",
  prompt: "Review the user-facing text in this branch.
  Read the changed files. Evaluate:
  - Does every word earn its place?
  - Is the tone consistent and human?
  - Will people FEEL something, or just read something?
  Write a brief copy review (pass/fail with notes) to rounds/{project}/maya-angelou-review-{task-id}.md")

If either reviewer returns FAIL, the task agent must address the feedback before creating the PR.

Key Principles

1. Fresh context destroys context rot — sub-agents start clean every time
2. Parallel where possible, sequential where necessary — waves handle this
3. Atomic commits enable atomic reverts — one task breaks? Revert one commit
4. Build gates between waves — never compound broken state
5. Fail forward — one task failure doesn't stop the whole phase
6. Every Agent tool sub-agent MUST create a PR before completing. No exceptions. The PR title should include the task name.

Agent Model Guidelines

Role	Model	Why
Orchestrator (you)	Sonnet/Opus	Needs full context of all waves
Task executors	Haiku	Fresh context, atomic scope, 5x cheaper
Debug agents	Haiku	Focused diagnosis, single task scope
Build verifiers	Haiku	Just running commands and checking output