Autopilot Full

Autopilot-full

You own the verdicts, never the PRs. One owner carries each PR from build to merge, and nothing merges until your swarm, which never wrote the code, has proven the code that lands.

A verdict covers one patch and green CI covers one head. Step 4 runs a full swarm once, and again only for a major change. The patch-id rule in playbooks/shipping.md can carry a lane's result, and every new head needs its own green CI.

1. The operator's gates come first. The grant covers only the queue's items, so items the operator names as theirs and PRs outside the queue stop at merge-ready. A request to state the plan is not a go.
2. Spawn one owner per PR, and keep its work where a replacement can find it. Resolve the forge once for the program. GitHub CLI (gh) is the default. If command -v origin succeeds and Origin can resolve the repository, use origin pr for every PR operation. Otherwise stay on gh and record the fallback. Never require Graphite (gt). Each owner is a Cursor cloud agent that builds, opens its PR per playbooks/opening-a-pr.md, proves the change on the real artifact, babysits to green per playbooks/babysit.md, and merges once steps 4 and 5 clear it.

Open the PR early so CI and bots run alongside the work. The code is ready only after the slop-strip (the deslop skill from the cursor-team-kit plugin (/deslop)) and the /no-comments pass, so the full swarm runs on finished code. Then rebase onto current trunk and report the code-ready head before self-proof, so verification runs on the base the patch lands on. Report every later head, and merge-ready once self-proof, CI, and babysit are done. Fix rounds stay on that base unless trunk conflicts or breaks CI, because each rebase restarts CI. Run the repo's checks for the touched paths on the committed head before the code-ready push and before a later push that needs a verifier.

Assume the VM dies. Soon after starting, push and start a decision trail in the root agent's store (path in the system prompt) per the show-me-your-work skill, then push after every unit worth keeping. Whoever spawns a subagent records its id, state, and a stuck-after runtime from past runs of its kind in that store, so the root can probe it if the parent dies. Force-push only your own branch, with --force-with-lease pinned to the SHA you last pushed or took over, and on any push you did not make, stop and report to the root. 3. Run owners in parallel off trunk, never stacked, so each PR lands on its own. 4. Swarm-verify once. A full swarm runs once, at the code-ready head. Another full swarm runs only for new behavior, a redesign, or a large new diff. A rebase, a merge-conflict resolution, or a minor fix gets a single verifier at the new head. Fan out independent verifiers at the code-ready SHA per the swarm skill. They re-run the gates, prove the load-bearing behavior live on the real surface through its control skill (such as control-ui or control-cli from cursor-team-kit) or a named driver, and audit the diff. The verdict is not clean without the live lane, or before you audit the merge-ready report's receipts, because no lane trusts a claim it has not checked.

Send every proven finding, whatever a lane labeled it, to the owner in one fix-forward, with a red test across every site with the same defect. A defect trunk shows without the PR is recorded against trunk and does not gate the PR, but one the PR copies or newly reaches is the PR's own. Never push a fix yourself, because each branch has one writer. Replace a stuck owner instead. 5. The owner merges only what you verified, tested on the trunk it lands on. Green CI alone never authorizes a merge. Once the swarm's lanes have started, merge prep rebases onto current trunk, reports the new head, and waits for green CI.

Right before merging, fetch trunk and ask whether its changes can affect the patch, because rebasing for every trunk move never ends. Rebase and wait for CI when the code that would land was never tested, as with a conflict, a file both sides changed, or a change to which checks run for the PR. A lockfile both sides changed needs no rebase when a frozen install passes on the merge result and the packages the PR changes resolve there as on the head, because that install tests the lockfile that would land, and a failing install means the rebase must repair it. When trunk changed a caller of the patch or something the patch depends on, such as code it calls or a dependency version, run the patch's checks on the merge result and merge on a pass. Otherwise merge. If trunk would force a third rebase past merge prep, hold and report to the root, which sequences the colliding work. 6. Run the root layer. Anything that loosens a gate, such as a raised budget or an allowlist entry, needs a verifier's proof and then your fresh countersign, because the owner is the one who wants green. Under a grant that covers approvals, that countersign is the approval, and the owner's record of it points at your countersign for a lane to check. A disabled or soft-failed check always comes out, because it stops guarding every case. Never give or bypass an approval the forge enforces, because no countersign covers it.

On the operator's go, arm /loop 1h to audit until no delegated work is left, because long runs drift and agents stall silently. Each tick re-reads this playbook from trunk and fixes drift, such as an unreported head or an unrecorded agent, by having its owner record it, because drift is a gap in the record, not a stall. It probes every agent, down to the leaf lanes, and judges each by its side effects, because status text and summaries can hide a stuck child. An agent is stuck when it errors, cannot start turns, or shows nothing new past its stuck-after runtime, and so is an owner that has neither pushed nor written a trail row by the first tick. One waiting on you or the operator is not stuck, so answer it. Replace a stuck agent at once, without waiting for its stop to land. A tick that changed something for the operator ends by catching them up per the ketchup skill, and one that changed nothing stays quiet. 7. Stand down at once on the operator's stop. A hold reaches every owner as a zero-writes order. Each reports where it stands and keeps its brief until the operator releases it.

Reply: catch the operator up per the ketchup skill, covering each PR's state and verdict, what merged, countersigns and why, and open operator gates, with links to each PR and the trails.