/auto

description: "Drive an autonomous execution arc end-to-end: brainstorm, spec, /prospect, plan, /prospect, TDD, /retrospect under the Rule 35 posture. Decide objectively-validatable forks yourself; stop only on a load-bearing fork or an ungranted approval. Modes: `arc` (default), `execute {plan|spec|ticket-id}` (skip ideation), `plan` (stop at a prospected plan), `config` (knob picker). Stackable, six axes: `full` (authority: all except push and deploy), `attended`|`unattended` (presence), `continue`|`stop` (duration), `tickets` (work source), `self-restart` (context recovery), `workflow`/`fanout={pct}`/`agents={N}` (fan-out). A bare invocation opens `config`. Overrides `autonomy` for this arc only. Use when the user hands off a goal, plan, ticket or SESSION.md with latitude to execute WITHOUT per-step approval: 'combined go', 'run overnight', 'just build it', 'do as much as you can'. For a multi-step arc, not a single change; distinct from /prospect, /retrospect, /handoff, /wrapup. (Code port — ADR-094.)"

/auto — Drive an autonomous execution arc

Drive a piece of work end-to-end under the autonomous decision-routing posture, stopping only where a human decision is genuinely load-bearing. This is the *entry point* that wires together the process skills you already have — `brainstorming`, `/prospect`, `superpowers:test-driven-development` / `superpowers:subagent-driven-development`, `/retrospect` — into one continuous arc, so a single invocation runs the whole chain instead of you re-approving each step.

It does NOT re-define the decide-vs-ask policy. That policy is **Rule 35** (decision routing) in `template/rules/working-rules.md`, scaled by the **`autonomy`** config posture. `/auto` *applies* Rule 35 to a concrete arc and adds the operational discipline an unattended run needs: what to *never* stop for, how to read the binding budget, how to pick the next unit of work, and how (optionally) to self-perpetuate across usage resets. Distilled from real autonomous runs — the friction points below are ones that actually bit.

Runtime precondition — Bash required

**`/auto` ships in three ports — `plugin-claude-code` (canonical), `plugin-antigravity` and `plugin-openai-codex` — and they have diverged (three distinct md5s, measured 2026-09-01).** It is not part of ADR-094's bare-slash collision set: no Cowork counterpart of this skill exists, so there is no canonical-owner question to resolve here and nothing to hand off to. What this section checks is a **capability**, not an ownership — do not restore a redirect to a Cowork variant.

**Before Step 0:** Check that the `Bash` tool is available. If `Bash` is NOT available (you are in Claude Cowork or another non-Code runtime), surface this and wait for an explicit reply:

> ⚠️ **Runtime mismatch — `/auto` needs Bash, and this runtime does not have it.** > > The arc runs `git` status/commit, the autonomy-config probe, the preflight commit gate, and (optionally) `CronCreate` through Bash. **There is no Cowork counterpart of this skill** — it is Code-only, so the choice is to run degraded or to stop. > > Running degraded loses every Bash-backed step: no commit, no `git` verification of live state, no commit gate, no resume schedule. The gates that are pure reasoning still run. To drive the chain by hand instead, the individual gates exist natively here — `/aria-cowork:prospect` before code, `/aria-cowork:retrospect` after, and `/aria-cowork:handoff` or `/aria-cowork:wrapup` to close. > > **Stop here rather than run degraded?** (`y` / `n`)

• **`y` / `yes`** — Stop cleanly, naming the individual Cowork gates above as the manual route.
• **`n` / `no`** — Proceed with this skill anyway; subsequent Bash failures are expected. Announce each one as it happens, and never report a Bash-backed step as done when it did not run.
• **No / other reply** — Treat as "do not proceed" and exit cleanly.

The question is polarised so the answers keep the same meaning as every other ADR-094 gate: **`y` declines to run this variant, `n` runs it anyway.** Only the question differs, because there is no sibling variant to offer — asking "proceed anyway?" here would invert `n` against the rest of the family.

This precondition is NOT suspended by any mode — `/auto` is inherently autonomous, so confirming the runtime can actually carry the arc is the one check that still matters. If `Bash` is available, proceed to Step 0.

⚠ **Removal trigger (Rule 37):** if a Cowork counterpart is ever built, this section reverts to a standard ADR-094 Runtime Gate with a live redirect, and this skill joins the collision set. Measured 2026-08-26: no such counterpart exists, Cowork's summed description budget stands at 8,010 of 9,000 so fitting one needs roughly a 193-char trim, and the Bash-backed machinery above would need a Cowork-native substitute — the budget is the smaller of the two obstacles.

When to use

• The user hands off a goal, plan, spec, ticket, or `SESSION.md`/handoff and signals latitude to run without per-step approval ("combined go", "continue autonomously", "go with your recommendation", "do as much as you can", "just build it", "take this and run", "run overnight"). A bare "go" alone is ambiguous — treat it as a `/auto` arc only when the surrounding context is clearly "drive this work autonomously," not when it's conversational ("go ahead and read that", "go with option B").
• After `brainstorming` or `/distill` concludes and the user says "ok, build it."
• At the start of a long or unattended arc the user wants driven to a durable checkpoint with minimal interruption.

**When NOT to use** (route to the right skill instead):

• One plan you want pressure-tested before any code → `/prospect`.
• Work that's already written/shipped and you want it validated → `/retrospect`.
• A session you're trying to pass off to the next session or a coworker → `/handoff`.
• A finished session with nothing pending → `/wrapup`.

`/auto` is the *driver*; those are the *g