sg-parallel-execute

Execute independent plan groups concurrently with wave dependency barriers.

2|Updated May 15, 2026
One-click install
npx skills add https://github.com/gyuha/super-gsd --skill sg-parallel-execute
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sg-parallel-execute
Source: https://github.com/gyuha/super-gsd/tree/main/.agents/skills/sg-parallel-execute
Command: npx skills add https://github.com/gyuha/super-gsd --skill sg-parallel-execute

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill reduces slow, fragile sequential execution by running independent plan groups concurrently while still respecting dependency boundaries between waves.

Core Features & Use Cases

  • Wave-based parallel dispatch: Executes up to three independent Task agents per wave, processing waves one at a time (lowest wave number first) to preserve dependencies.
  • Deterministic, non-invasive execution: Each Task reads its group's PLAN.md directly and avoids touching GSD/Superpowers internal state files.
  • Failure-aware orchestration: On any Task failure, it appends a parallel-failed row to .planning/HANDOFF.md and stops to prevent advancing with inconsistent progress.

Quick Start

Provide the path to your parallel_groups.json file to start executing its wave-structured plan groups in the correct parallel order.

Frequently Asked Questions about sg-parallel-execute

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run independent plan groups in parallel instead of sequentially?

Parallel execution of independent plan groups requires a parallel_groups.json file defining wave-structured tasks. The orchestrator dispatches up to three Task agents concurrently per wave while preserving dependency barriers, reading each group's PLAN.md directly without invoking superpowers:executing-plans.

What is wave-based parallel task dispatch and how does it handle dependencies?

Wave-based parallel task dispatch executes independent groups concurrently in batches of up to three Task agents per wave. It processes waves sequentially from lowest to highest wave number, ensuring dependency barriers between waves are preserved while maximizing concurrency within each wave.

How do I set up parallel_groups.json for concurrent plan execution?

Setting up parallel_groups.json for concurrent plan execution requires defining independent plan groups in a JSON array format, each with its own PLAN.md file. Groups must be organized into waves where dependencies dictate execution order, with each group executed via bare Task() calls.

What happens when a parallel Task agent fails during wave execution?

When a Task agent fails during parallel wave execution, the orchestrator appends a parallel-failed row to .planning/HANDOFF.md and halts all further wave advancement. This prevents inconsistent progress across independent plan groups and stops subsequent waves from executing.

Can I use parallel plan execution with superpowers:executing-plans?

Parallel plan execution explicitly avoids invoking superpowers:executing-plans and instead uses bare Task() execution to run each group's PLAN.md directly. This non-invasive approach ensures Task agents do not touch GSD or Superpowers internal state files during concurrent dispatch.

Why does parallel orchestration limit concurrency to three Task dispatches per wave?

Parallel orchestration limits concurrency to three Task dispatches per wave to balance throughput with resource constraints and dependency safety. This maximum prevents overwhelming the system while still reducing slow sequential execution time by running independent plan groups concurrently within each wave barrier.