/orchestrate

name: orchestrate
description: 'Dispatch independent tasks to parallel workers without write collisions, decide what each does next, and recover dead ones. Use when: running or managing two or more agents.'
practices: [team-topologies, evidence-based-engineering, design-by-contract]
hexagonal_role: supporting
consumes: [accepted-intent, native-work-state, candidate-evidence, explicit-role-packets]
produces: [native-handoffs, reconciled-feedback, runtime-evidence, per-packet-results]
context_rel:
- kind: customer-of
  with: codex-exec
- kind: customer-of
  with: claude-exec
- kind: customer-of
  with: agy-native
skill_api_version: 1
user-invocable: true
metadata:
  graph_root: true
  tier: execution
  dependencies: []
  capabilities: [coordinate_native_work, recover_assignments, reconcile_feedback, role_dispatch, observe_workers, dispatch_once]
  effects: [dispatch_authorized_workers, update_native_handoffs, manage_runtime_sessions, invoke_selected_executor]
  canonical_status: canonical
  disposition: keep
output_contract: observed native assignments, per-packet runtime results, exact candidate and judgment references, affected-work handoffs and explicit remaining gaps

Orchestrate

This skill decides what each worker does next and launches it safely. The core move: send free capacity to finished work that still owes checks, integration or a judgment before starting anything new, and launch nothing until every packet in the batch is valid with canonical write scopes that do not collide. It worked when no finished-but-unchecked candidate waits while new work starts, no task runs on a closed but unintegrated prerequisite, no two launched workers share a canonical path or a contended resource, and each packet has a result naming observed engagement, terminal status and `not_as_briefed`.

One agent and one writer is the default. Give work to parallel workers only where the pieces are independent: disjoint canonical write scopes and no contended runtime resource. Dependent or overlapping work stays with one writer or runs in sequence. Within that, concurrency follows the observed bottleneck: reserve capacity for integration, review and repair, and reduce new starts while candidates accumulate.

• Use this skill for the next dispatch, packet checks, launch, observation,

recovery and integration order.

• Use [Navigate](../navigate/SKILL.md) to pick the next wave on a bead graph

toward frozen acceptance.

• Use [Validate](../validate/SKILL.md) to judge a result; exit 0, a receipt and

factory completion never validate output.

• Use [codex-exec](../codex-exec/SKILL.md), [claude-exec](../claude-exec/SKILL.md)

or [agy-native](../agy-native/SKILL.md) for one headless run the caller selected.

Before any dispatch

• **Finished is not done.** Exit 0, a pushed branch, a closed tracker item or a

worker saying "done" makes a candidate. It still owes its checks, integration and, when one is owed, a fresh judgment.

• **A held step keeps the task open.** When a worker lists a step under

`not_as_briefed` (refused, held, worked around or unverified), the task is not complete. A result marked `out of authority` is not a candidate. Retry the step yourself only within your authority and the caller's limits, never by the route the worker was denied. Otherwise integrate the finished part only if it stands alone, and report the open step as a blocker.

• **Drain before starting.** While candidates wait on checks, repair,

integration or an owed judgment, free capacity goes there first: candidates that unblock held dependents, then the oldest. A free slot alone is not a dispatch reason; start new implementation with what is left.

• **Judges did not author.** Review or validation of a candidate goes to a

context that did not write it.

• **Readiness is content.** A prerequisite counts only when its bytes are in

the intended checkout. A closed item whose change is missing, stale or unavailable there is not ready: hold its dependents, keep its native status, and report the gap.

• **Reconcile before resuming.** Match tracker assignments against observed

runtime state, validators included, before dispatching. Never duplicate an assignment because this conversation lacks it. For each task check who holds it, its starting content, its write scope, pending checks, the current candidate and who integrates it; an empty ready list does not prove completion ([Navigate](../navigate/SKILL.md#rules-that-decide-the-pick)).

• **Decisions are not build work.** A decision item goes to the resolver it

names ([Navigate](../navigate/SKILL.md#foggy-epics)), never to an implementer; with BD, pull build work with `bd ready --exclude-type decision`.

Record only the concrete constraint and next action in the existing native handoff.

Check the packets

Dispatch a fresh implementer for one coherent accepted task through the runtime's task-only dispatch; a forked session, cleared summary or resumed author context still carries the history ([RPI](../rpi/SKILL.md#delegation-and-handoffs)).

• **Validate the whole batch first.** This list is the one packet contract.

Every packet needs its packet identity, caller intent with its accepted examples, applicable constraints, role, selected executor, workspace, starting commit, usable prerequisites, authorized source scope, evidence destination, all transitive effects, the actions it must not take (such as push, merge, history rewrite, tracker or external writes), the checks it must run, who integrates its result, the real remaining bounds, the [per-packet result](#per-packet-result) fields, and a canonical workspace-relative write scope, generated companions and regeneration outputs included, in separate isolation. If any packet is invalid, launch none: starting the valid ones and fixing the rest later is a partial launch.

• **Compare canonical scopes.** Resolve symlinks, normalize paths and compare

case-insensitively