---
name: spawn
description: "Primary Shepherd entry for initializing, planting, planning, starting, resuming, and closing one explicit sprint. Use whenever an operator invokes /shepherd:spawn with a run or version."
---

# spawn: own the selected sprint end to end

Spawn is the primary Shepherd entry point. One invocation owns one explicit run from
bootstrap through close. Spawn invokes Start in `conductor` mode only after planning; Start
is its callable subcommand, not an operator prerequisite. Never return initialization,
Plant, binding, or Start as operator work.

Every fresh Spawn follows the same bootstrap, optional Plant, and Engineer/Critic planning
sequence. Choose how to execute only after the engineered plan, graph, and lane plans are
verified. No execution mode may replace planning.

Spawn never edits Native-owned state directly. Native Shepherd alone writes project and run
identity, dispatch, bindings, locks, lanes, and transitions.

## Select and bootstrap one run

Resolve the supplied run or version to canonical run, branch, base, and version. Never use an
ambient active run, a sibling binding, or a convenient executing sprint. For absent project
identity, run exactly:

```text
shepherd init --confirm
```

Read only the selected run:

```text
shepherd run show <run> --json
```

If absent, initialize the run through Native Shepherd:

```text
shepherd run init <run> --branch <branch> --base <base> --version <version>
```

Bind the trusted current root session explicitly. Use `planning` for `planted` or `planned`
and `execution` only for `executing`:

```text
shepherd dispatch bind-root --run <run> --mode <planning|execution> --confirm
```

These are exact argv contracts. Reject wrappers, shell syntax, extra flags, identity
mismatches, and `--force`. The selected malformed run fails closed. Stale or malformed sibling
runs are outside its authority and cannot block it.

## Resume the invariant lifecycle

After each successful Native transition, continue in the same invocation:

- absent project: initialize;
- absent run: initialize and bind;
- planted without verified seed: invoke `plant`, verify, and continue;
- planted with verified seed: plan;
- planned: Start in `conductor` mode;
- executing: resume from durable lane and dispatch records;
- closing: reconcile and close;
- closed: report without mutation.

Never repeat a completed stage or switch runs. Record exact command, exit, and failed
predicate on failure, then finish every safe repository-side action still available.

## Plan, then execute

One isolated persistent `shepherd:engineer` subagent owns Shepherd's `planning` skill. It
dispatches bounded Auditor and Discovery orientation, authors the plan,
and applies read-only Critic findings. Require `shepherd plan verify --run <run>`, Critic
GREEN, and the Native `planned` transition. Root never authors or silently accepts the plan.

Then invoke Start `conductor` mode inside this Spawn. Every ready lane receives its own
isolated, persistent `shepherd:conductor` subagent under `lane-execution`, consuming only its
verified lane plan and dispatching Shepherd-owned `implementing`, `artifact-work`,
`reviewing`, `debugging`, and `verification` skills. Lanes never share mutable context or
scope. Root integrates verified lane outcomes; Spawn retains lifecycle, close,
delivery, and authorized release custody.