Core 0.33.0

What changed

New: `ap-dev-flow-auto`

ap-dev-flow-auto runs the same pipeline as ap-dev-flow without stopping to ask you anything, and ends with the branch pushed and a draft pull request open. It is optional and runs only when you name it.

The review bar is unchanged. Every task still gets a fresh implementer, a passing verify command, and an independent read-only review, and the whole change still gets an integration review and acceptance verification. What changes is what happens where a human used to be:

A machine gate replaces your plan approval. The plan passes only when a review round returns ready with zero blocking findings. Any other verdict means the required changes are applied and a new reviewer looks again. After four rounds without a clean verdict the run stops rather than implementing a plan nobody approved.
Open questions are carried, not asked. Each keeps the assumption that was taken and how it can be settled, and they are all listed on the pull request.
Caps are higher: four rounds for plan review, integration review, and verification repair, against two in interactive. The per-task repair ladder stays at five in both.
A stopped run opens no pull request. The branch and run folder are left as they are, with the stop reason reported.

See Dev flow.

What it is allowed to do

Naming ap-dev-flow-auto authorizes it to push the branch it creates to your default remote and to open one draft pull request from it. That is the whole grant. It does not merge, publish, deploy, force-push, rewrite remote history, or push to your primary branch or any branch it did not create.

Ask it for no pull request and it stops at a ready branch, writing the pull request body into the run folder. Because it cannot ask mid-run, it checks up front that subagents are available and that gh is authenticated, and refuses to start rather than discovering at the end that it cannot finish.

Changes to the existing dev-flow skills

Interactive runs behave as before, with one addition: resuming a run that the other orchestrator started now converts it.

The run folder’s meta.yaml now records mode (interactive or auto). Stage skills read the mode and the caps from that file instead of assuming interactive values. Runs created by ap-dev-flow still default to interactive and its caps.
Both orchestrators check mode when resuming a run and convert it to their own, so resuming an interactive run unattended does not leave stages waiting for answers, and resuming an auto run interactively does not suppress the questions you asked for.
ap-review-plan applies review changes and recognizes an approval gate under either orchestrator, not just ap-dev-flow.
ap-dev-research does not ask about blocking open questions under mode: auto; it records each hypothesis and how it will be learned.
ap-dev-implement does not stop to ask when the plan changed since its preflight under mode: auto. It re-runs the preflight against the current plan and records a ruling, which the orchestrator puts on the pull request. Interactive runs still ask.
ap-dev-review-code and ap-dev-verify take their caps from meta.yaml.
The bundled dev-run-workspace script takes an optional mode argument: dev-run-workspace new <slug> auto. The two-argument form is unchanged.

Still to come

ap-subagent-driven-development remains installed as a retired pointer to ap-dev-implement. It will be deleted in a later version. Update the CLI to 0.3.1 or newer before that release so agents-pack update removes it cleanly.

How to update

Make sure the CLI is 0.3.1 or newer:
```
agents-pack --version
```
Update the content pack in each repository or global installation:
```
agents-pack update --check
agents-pack update
```
ap-dev-flow-auto is optional, so updating does not install it. Add it when you want it:
```
agents-pack install ap-dev-flow-auto --dry-run
agents-pack install ap-dev-flow-auto --yes
```
It needs the stage skills (ap-dev-research, ap-dev-plan, ap-review-plan, ap-dev-implement, ap-dev-review-code, and ap-dev-verify) and will name any that are missing instead of running that step itself.