/orchestrate

Run a multi-step workflow by breaking a complex task into coordinated sub-tasks.

Steps

1. Parse the workflow specification from the argument:
   • Accept a natural language description of the end goal.
   • Or accept a structured plan with explicit steps.
2. Decompose into ordered sub-tasks:
   • Identify dependencies between tasks (which must complete before others start).
   • Determine which tasks can run in parallel.
   • Estimate complexity of each task (small, medium, large).
3. For each sub-task, define:
   • Clear objective and success criteria.
   • Input requirements (files, data, prior task outputs).
   • Expected output (files created, changes made, results).
   • Verification method (test, manual check, build success).
4. Execute tasks in dependency order:
   • Mark each task as pending, in-progress, or complete.
   • Capture output and errors from each step.
   • If a task fails, determine if downstream tasks should be skipped or can proceed.
5. After all tasks complete, run a final verification:
   • Build passes.
   • Tests pass.
   • No regressions introduced.
6. Report the full execution summary.

Format

Workflow: <description>
Tasks: <total> (<completed>/<total>)

| # | Task | Status | Duration | Notes |
|---|------|--------|----------|-------|
| 1 | <task> | done | 2m | <notes> |
| 2 | <task> | done | 5m | <notes> |
| 3 | <task> | failed | 1m | <error> |

Overall: <success/partial/failed>
Duration: <total time>

Rules

• Never execute destructive operations (delete, force push) without explicit confirmation.
• If a critical task fails, stop and report rather than continuing blindly.
• Keep each sub-task focused and independently verifiable.
• Save progress after each completed task so work is not lost on failure.
• Limit workflow to 10 tasks maximum; break larger workflows into phases.