goop-execute

/goop-execute

Implement the blueprint one wave at a time. The orchestrator delegates all implementation to executor agents.

Gate check

Call goop_state({ action: "get" }). If specLocked is not true or no wave rows exist — check via goop_read_wave({ workflow_id }) returning at least one wave (not a 'no waves' message) — return BLOCKED with:

Run /goop-plan first.

Load references

goop_reference({ name: "dispatch-patterns" })
goop_reference({ name: "core-protocol" })

Steps

1. Read goop_read_db({ doc_types: ["spec", "blueprint", "chronicle"] }) for narrative context and goop_read_wave({ workflow_id }) for wave/task context; read PROJECT_KNOWLEDGE_BASE.md.
2. For each wave:
   • Delegate tasks to the right executor tier via task():
     • goop-executor-low for mechanical/pattern-following edits; escalate if hidden complexity.
     • goop-executor-medium for standard implementation work — the default tier when a task isn't clearly mechanical or complex/critical.
     • goop-executor-high for architecture-sensitive or security-critical work — use when genuinely warranted.
     • goop-executor-frontend-low for UI mechanical tasks; escalate if hidden complexity.
     • goop-executor-frontend-medium for standard UI component work — the default frontend tier when UI work isn't clearly mechanical or design/architectural.
     • goop-executor-frontend-high for deep design or UI-architecture work — use when genuinely warranted.
   • Use sequential dispatch for shared files; parallel dispatch for independent tasks.
   • Require every task to return STATUS, SUMMARY, ARTIFACTS, VERIFICATION, NEXT.
3. Apply the four-rule deviation system from phase-gates. Log every deviation to ADL.md via goop_adl.
4. Before dispatching a wave, call goop_state({ action: "update-wave", currentWave: N, totalWaves: M }) to record that Wave N is in progress. currentWave is 1-based; 0 means no wave has started.
5. After every task in a wave completes, run the wave verification gate before the wave can be marked complete:
   • Dispatch goop-wave-verifier scoped to that wave — one wave per dispatch; the role is execute-phase and inspect-only (see agents/goop-wave-verifier.md).
   • The verifier records a verification row per task via goop_write_wave({ wave_number: N, verifications: [...] }) and never implements fixes.
   • On gaps: dispatch the correctly tiered executor to remediate, then re-dispatch goop-wave-verifier for that wave to re-verify the remediated tasks.
   • Bound the remediation cycle with the three-strikes convention in references/test-authoring.md §Test Execution Discipline: after three failed attempts on the same gap, open a blocker via goop_blocker and stop; do not loop.
   • The wave is complete when its rows satisfy the runtime gate: verification rows persist forever (never deleted or edited), and the gate reads the latest row per check_name — at least one check present, and every check's latest row non-fail. A later pass or explicit skip for the same check supersedes that check's own prior fail; it does not resolve a different check's unresolved fail (isWaveVerified in src/features/enforcement/verifier-stage.ts). The runtime enforces the boundary: goop_write_wave rejects a complete-status transition without it.
6. If Atomic PRs = Yes: after the wave verification gate passes, open a PR for the verified wave against the previous branch (Wave N → Wave N-1; Wave 1 → main) via gh pr create or goop_create_pr. Do not wait for it to merge. Then create the Wave N+1 branch from the current wave's branch and continue. Show the PR URL in the checkpoint.
7. Save a checkpoint at wave boundaries.