execute
/execute
Dispatch and execute implementation plans with TDD and checkpoints. Use when plan is ready. Parallel by default for independent tasks.
- Author
- datit309 ↗
- Repository
- supergraph ↗
- Licence
- MIT
- Last repository change
- 23.10.2026
Assessment and security
- Files in this package
- 4
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 1
No signals detected. Repository changed on 23.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Dispatch and execute implementation plans with TDD and checkpoints. Use when plan is ready. Parallel by default for independent tasks.
Original author description
Dispatch and execute implementation plans with TDD and checkpoints. Use when plan is ready. Parallel by default for independent tasks.
How it works
- Steps
- Stop Conditions (Ask Instead of Guessing)
- Rules
SKILL.md preview
---
name: execute
description: Dispatch and execute implementation plans with TDD and checkpoints. Use when plan is ready. Parallel by default for independent tasks.
mcp: codebase-memory-mcp, supergraph-team
---
# /supergraph:execute
Dispatch plan tasks with TDD. Parallel by default when tasks are independent.
Usage: `/supergraph:execute` | `task N` | `tasks N,M` | `from task N` | `plan auth-login task 2` | `plan auth-login sequential`
## Steps
### 0. Announce
"I'm using /supergraph:execute to implement this plan."
### 1. Load Context
- `/supergraph:scan` should already be done. If `.supergraph-env` missing → STOP: "Run `/supergraph:scan` first."
- Commands from `.supergraph-env` (if present) or plan `## Environment Context`
### 2. Select Plan
Count plan files in `docs/supergraph/plans/*.md`:
| Count | Action |
|---|---|
| 0 | STOP: "Run `/supergraph:plan` first" |
| 1 | Auto-select |
| >1, no `plan <slug>` arg | STOP: list plans, ask user |
| `plan <slug>` provided | Match filename. If >1 match ask. |
Parse task scope: `task N`, `tasks N,M,K`, `from task N`, or all incomplete.
Parse `sequential` flag → force sequential mode.
### 3. Critical Review
Read plan before dispatch:
- Has `## Environment Context`?
- Selected tasks have all required fields (Status, Risk, Dependencies, Files, Acceptance, TDD, Steps, Checkpoint)?
- Commands real, not placeholders? File paths exact?
- Plan-reviewer returned `Approved` (or user explicitly approved)?
If missing or not Approved → STOP, dispatch `supergraph:plan-reviewer`, wait for Approval.
Also check: plan has user approval step (step 11)? If not → ask user: "Plan was not reviewed by you. Proceed anyway? [yes / no]"
Check dependencies: Task X depends on Task Y → is Y `Status: completed`? If not → STOP.
**If any concern: STOP, ask. Never guess.**
### 4. Branch Protection
If main/master → STOP, suggest new branch or worktree.
User approves → continue.
### 5. Determine Execution Mode & Group by Waves
Parse tasks from plan:
- **Wave-based DAG:** Group incomplete tasks by `Wave: N` (e.g. Wave 1, Wave 2, Wave 3).
- **Auto-Wave fallback:** If plan lacks `Wave:` fields, group tasks dynamically by dependencies:
- Wave 1: Tasks with `Dependencies: none`.
- Wave N: Tasks whose dependencies are all satisfied by Wave < N.
- **Wave Strategy:**
- Wave with 1 task → Sequential dispatch.
- Wave with >1 tasks → **Parallel dispatch** of concurrent subagents.
### 6. Wave-by-Wave Dispatch
Execute wave by wave in strict DAG order:
```text
Wave 1 (Base/Schema) ──> Wave 2 (Independent Features: PARALLEL) ──> Wave 3 (Integration/UI)
```
Shared executor instructions (see `serena/SKILL.md:Setup`): per task RED→GREEN→REFACTOR→Lint→Format, `get_diagnostics_for_file` after GREEN, prefer `replace_symbol_body`/`rename_symbol` over raw edits. Commit once per task. Max 3 retries.
#### Supergraph Native Team Engine (sg_task_* MCP Tools):
When `supergraph-team` MCP tools are available:
1. **Initialize Mission:** Call `sg_team_init(objective, base_branch)`. Supergraph auto-launches Live Dashboard UI at `http://127.0.0.1:3333` and opens your browser (or call `sg_team_ui` anytime).
2. **Register Tasks:** Call `sg_task_create` for each plan task specifying `id`, `title`, `wave`, `dependencies`, and `write_scopes`.
3. **Dispatch Workers in Wave:**
- Lead checks ready tasks with `sg_task_list(wave=N)`.
- Dispatches workers (subagent / teammate).
- Worker claims task: `sg_task_claim(task_id, worker_id)` → receives isolated worktree directory (`.supergraph/worktrees/task-<id>`).
- Worker implements TDD inside worktree directory:
- Worker enforces RED: `sg_task_record_red(task_id, test_output)`.
- Worker writes minimal GREEN code.
- Worker submits: `sg_task_submit(task_id, test_cmd)`.
4. **Merge & Sync:**
- Lead/Orchestrator runs verification gate: `sg_task_verify_merge(task_id, test_cmd, commit_msg)`.
- Engine automatically verifies test exit code 0, merges branch into base repo, and cleans up worktree.
#### Fallback / Native Subagent Runners (without MCP):
For each Wave:
1. **Prepare Wave Scope:** Identify tasks belonging to current Wave.
2. **Sequential (1 task):** Dispatch `Agent(subagent_type="supergraph:executor")` — run baseline tests first, execute task respecting dependencies, report task done/stuck + files changed.
3. **Parallel (>1 tasks):**
- **Antigravity / Subagent Runners:** Call `invoke_subagent` with concurrent executors in a single call:
- `Workspace: "branch"` (isolated git worktree/branch — guarantees zero file conflicts & avoids git index lock collisions).
- `Model: task.Model || "inherit"` (use `flash` for low-risk boilerplate/tests, `pro` for complex logic).
- Each subagent receives only its self-contained `## Task N` snippet + `## Environment Context`.
- **Claude Code / CLI:** Spawn one subagent per task in one message with self-contained task scope.
- Subagents execute TDD, report `ACCEPTANCE_PASSED: Task N`.
- Orchestrator waits for all subagents in current Wave to report completion.
4. **Wave Synchronization & Merge:**
- Merge worktree/branch changes back to target branch.
- Run Wave Verification `$TEST_CMD`.
- Orchestrator updates task statuses to `completed` in plan file.
- If tests pass → proceed to Wave N+1.
- If any task fails/stuck (after max 3 retries) → trigger `/supergraph:fix` or STOP and consult user.
### 6.5 Durable Task Artifacts and Dispatch Safety
Before dispatch, create the plan workspace with `sdd-workspace PLAN_FILE`, then run a **Pre-dispatch conflict scan** over task file sets and dependencies. Record the scan and any non-catastrophic ruling in `.supergraph/sdd/<plan-basename>/ledger.md`.
- batch only tasks with disjoint write sets and the same execution shape.
- Send each worker `task-N-brief.md`; require `task-N-report.md` with exact RED/GREEN/REFACTOR and verification evidence.
- Implementers and reviewers **must not spawn subagents**. The controller owns dispatch depth and parallelism.
- On a conflict that is not catastrophic, the controller records the ruling, affected files, and why execution can continue. Catastrophic conflicts stop the wave.
- Generate `review-<base>..<head>.diff` with `review-package` before scoped review.
### 7. Post-Execution Safety
If same-file edits for `CBM_PROJECT`: reindex if stale (`index_status`→`index_repository`, see `references/codebase-memory-contract.md`), then `detect_changes`/`trace_path`/`cross-boundary` via `codebase-memory-mcp`.
### 8. Final Verification
Run `$TEST_CMD`/`$LINT_CMD`/`$BUILD_CMD`. Reindex `CBM_PROJECT` if stale (`index_status`→`index_repository`), then `codebase-memory-mcp` `detect_changes`/`trace_path`, recipes `cycles/test-gaps/complexity/cross-boundary`.
### 9. Handoff
`/supergraph:fix` → `/supergraph:integration` → `/supergraph:verify` → `/supergraph:review`
### 10. Report
```
✅ Execution Complete
Plan: [path] | Scope: [tasks]
Tasks: N/N done | Stuck: [none | list]
Tests: PASS | Lint: PASS | Graph: updated
```
Announce completion in user's language.
## Stop Conditions (Ask Instead of Guessing)
- Plan not found or ambiguous | Missing Environment Context | Unclear instruction or placeholder
- Branch is main/master without permission | Baseline tests fail | Dependency not completed
- Agent stuck after 3 retries
## Rules
- Parallel when zero file overlap + no dependencies | Sequential for dependencies
- One commit per task, NEVER mid-TDD | Never `git add -A`
- Max 3 retries per step | Self-contained prompt per parallel agent
- Always verify after parallel | Always review plan before dispatch
- Never create plan — only execute
- Prefer Serena symbol tools over text edits when available
Files in this package (4)
- SKILL.md 8 KB
- scripts/review-package 2 KB
- scripts/sdd-workspace 1 KB
- scripts/task-brief 2 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · datit309/supergraph | 100 | MIT |
| insideout-ai/make-it-work | 100 | MIT |
| yaleh/quay | 100 | MIT |
| jkaloger/lazyspec | 100 | MIT |
| shakestzd/htmlgraph | 100 | MIT |
| shakestzd/htmlgraph | 100 | MIT |
| shakestzd/htmlgraph | 100 | MIT |
| crbnos/carbon | 100 | AGPL-3.0 |
| alirezarezvani/claude-skills | 100 | MIT |
Database snapshot: 13.11.2026 · package version 600069d7542d (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 90executing-plans
Use when you have a written implementation plan to execute in a separate session with review checkpoints - 90executing-plans
Use when you have a written implementation plan to execute in a separate session with review checkpoints - 90executing-plans
Use when you have a written implementation plan to execute in a separate session with review checkpoints - 90executing-plans
Use when you have a written implementation plan to execute in a separate session with review checkpoints - 90executing-plans
Use when you have a written implementation plan to execute in a separate session with review checkpoints - 90executing-plans
Use when you have a written implementation plan to execute in a separate session with review checkpoints