invoke-orchestrate

Decompose approved implementation plans into batched JSON tasks with dependency edges.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/ricky-russo/invoke --skill invoke-orchestrate
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: invoke-orchestrate
Source: https://github.com/ricky-russo/invoke/tree/main/plugin/skills/invoke-orchestrate
Command: npx skills add https://github.com/ricky-russo/invoke --skill invoke-orchestrate

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Orchestrate converts an approved implementation plan into small, isolated, context-safe tasks organized into sequential batches and explicit dependency edges so DAG-aware runners and multi-provider builders can execute work in parallel without conflicts. It enforces messaging standards, validates pipeline state, prevents file-level merge conflicts, and ensures the pipeline advances reliably from plan to build.

Core Features & Use Cases

  • Messaging enforcement: mandates loading the standardized messaging format before any pipeline actions to ensure consistent outputs.
  • State and artifact handling: verifies pipeline stage, reads the approved plan and optional spec, and records tasks as a JSON artifact in the pipeline store.
  • Strategy selection and task decomposition: auto-detects or presents build strategies, decomposes plans into well-sized tasks with acceptance criteria, relevant files, interfaces, and builder subroles.
  • Batching and dependency validation: groups tasks into parallel-safe batches while encoding depends_on edges for DAG-aware execution and validates no circular or self-dependencies exist.
  • Conflict prevention and safety checks: checks for file creation/modification overlaps within batches and enforces sizing and timeout guidelines to avoid oversized tasks.
  • Use cases: breaking an approved feature plan into per-file implementation tasks for parallel builders, converting a bug-fix plan into prioritized fix tasks, or preparing a prototype plan for staged implementation.

Quick Start

Ask the orchestrate stage to break the approved plan file into executable task batches, pick or confirm the suggested strategy, and save the resulting tasks artifact to advance the pipeline to build.

Frequently Asked Questions about invoke-orchestrate

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

FAQPage Schema
How do I break an approved implementation plan into executable tasks?

To break an approved implementation plan into executable tasks, you decompose the plan into isolated work items with acceptance criteria, relevant files, and builder subroles. This produces a structured JSON tasks artifact organized into parallel-safe sequential batches.

What is a task DAG in software development pipelines?

A task DAG is a directed acyclic graph of isolated development tasks where explicit depends_on edges define execution order. It groups parallel-safe work into sequential batches so DAG-aware runners and multi-provider builders can execute work without file-level merge conflicts.

How do I prevent file conflicts when running parallel build tasks?

To prevent file conflicts when running parallel build tasks, you validate file creation and modification overlaps within parallel-safe batches. Checking for file overlaps ensures multi-provider builders can execute isolated work items simultaneously without causing merge conflicts.

How do I validate dependencies when organizing tasks into batches?

To validate dependencies when organizing tasks into batches, you encode explicit depends_on edges for DAG-aware execution and verify that no circular or self-dependencies exist. This ensures the pipeline advances reliably from plan to build.

Do I need an approved plan and spec before task decomposition?

Yes, you need an approved plan before task decomposition, while an optional spec can provide additional context. The orchestrate stage verifies pipeline state, reads these artifacts, and records the resulting tasks as a JSON artifact in the pipeline store.

What are the limitations of oversized tasks in pipeline orchestration?

Oversized tasks in pipeline orchestration risk stalling execution and exceeding timeout guidelines. Enforcing task-sizing constraints during decomposition prevents oversized work items and ensures builders can complete individual work items within timeout limits.