/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.