/autonomous

name: autonomous
description: "Run multiple phases hands-free. Chains discuss, plan, build, and verify automatically."
allowed-tools: Read, Write, Bash, Glob, Grep, Skill, Task, AskUserQuestion
argument-hint: "[--from <N>] [--through <N>] [--speculative-depth <N>] [--dry-run]"

**STOP — DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by Claude Code's plugin system. Using the Read tool on this SKILL.md file wastes tokens. Begin executing Step 0 immediately.**

/pbr:autonomous — Hands-Free Multi-Phase Execution

References: @references/questioning.md, @references/ui-brand.md

Step 0 — Immediate Output

**Before ANY tool calls**, display this banner:

╔══════════════════════════════════════════════════════════════╗
║  PLAN-BUILD-RUN ► AUTONOMOUS MODE                           ║
╚══════════════════════════════════════════════════════════════╝

Then proceed to Step 1.

---

Step 1: Config Gate and Parse Arguments

1. Read `.planning/config.json`. Check `workflow.autonomous` — if `false` or missing, display:

Autonomous mode is disabled.

Enable with: /pbr:config set workflow.autonomous true

Stop immediately. Do NOT proceed.

2. Parse `$ARGUMENTS`:

| Argument | Meaning | Default | |----------|---------|---------| | `--from N` | Start from phase N | Current phase from STATE.md | | `--through N` | Stop after phase N | Last phase in current milestone | | `--speculative-depth N` | How many phases ahead to plan speculatively | From config `workflow.speculative_depth` (default 2) | | `--dry-run` | Show which phases would execute without doing anything | Off |

3. Determine speculative planning settings:

• Read `workflow.speculative_planning` from config — if false, speculative depth = 0
• Read `workflow.speculative_depth` from config (default: 2)
• If `--speculative-depth N` provided, override config value
• Store as `speculativeDepth` for use in Step 3

4. Read `gates.checkpoint_auto_resolve` from config (default: `"none"`). Values:

• `"none"`: STOP on all checkpoints (user must resolve)
• `"verify-only"`: Auto-resolve `checkpoint:human-verify` (proceed after confidence-gate passes), STOP on `checkpoint:human-action`
• `"verify-and-decision"`: Auto-resolve verify + decision checkpoints, STOP on `checkpoint:human-action`
• `"all"`: Auto-resolve all checkpoints (dangerous — only for fully automated pipelines)

Store as `checkpointResolveLevel` for use in Step 3c. 5. Read `.planning/STATE.md` to determine current phase (used as default for `--from`). 6. Read `.planning/ROADMAP.md` to build phase list for current milestone. 7. **CRITICAL (hook-enforced): Write .active-skill NOW.** Write `.planning/.active-skill` with the content `autonomous` using the Write tool. This registers the autonomous session with the workflow enforcement hooks. Child Skill() calls (plan, build, review) will overwrite this with their own skill name during execution and should restore or re-write it — but the orchestrator owns the initial write and final cleanup. 8. Filter to phases from `--from` through `--through` that are not yet complete. 8. If no phases to execute, display: "All phases in range are complete." and stop.

**If `--dry-run`:** Display the phase list with planned actions per phase, then stop without executing.

DRY RUN — Would execute:
  Phase 3 (data-layer): discuss -> plan -> build -> verify
  Phase 4 (api-endpoints): plan -> build -> verify  (CONTEXT.md exists, skip discuss)
    [speculative: plan Phase 5 during Phase 4 build]
  Phase 5 (frontend): discuss -> plan -> build -> verify
Speculative depth: 2

When `speculativeDepth > 0`, append the speculative depth value and annotate phases where speculative planning would occur. When `speculativeDepth == 0` (speculative_planning is false), omit the speculation lines.

---

Step 2: Dynamic Phase Detection

Before each phase iteration:

1. Re-read `.planning/ROADMAP.md` (catches inserted/removed phases between iterations) 2. Rebuild the phase list for the current milestone 3. Compare with previous iteration's list — if changed, log:

   Phase list changed: {diff}. Adjusting execution order.

4. Skip phases already marked as verified/complete in ROADMAP.md

**Verification tracking:** Initialize two counters at the start of the autonomous run:

• `phases_verified_full = 0` — count of phases that received full `/pbr:review` verification
• `phases_verified_total = 0` — count of phases that completed verification (any type)
• Read `verification.min_full_percent` from config (default: 30)
• Calculate `full_verify_interval`: if min_full_percent > 0, compute `Math.floor(100 / min_full_percent)` (e.g., 30% → every 3rd phase). If 0, set to Infinity (never force full).

---

Step 3: Phase Loop

For each remaining phase N:

3a. Discuss Phase (conditional)

• Check if `.planning/phases/{NN}-{slug}/CONTEXT.md` exists -- if so, skip (decisions already captured)
• Count requirements for this phase: parse the `### Phase {N}:` section in ROADMAP.md, count bullet lines under `**Requirements:**`
• **Auto-skip discuss** (no Skill() call) when ANY of these are true:
• CONTEXT.md already exists
• Requirement count is 0 or 1 (well-specified, no gray areas worth discussing)
• `--auto` mode is active AND all requirements are simple factual statements (no `[NEEDS DECISION]` markers)
• Log: `Phase {N}: auto-skipping discuss ({count} requirement(s), well-specified)`
• **Run discuss** only when: CONTEXT.md missing AND requirement count >= 2 AND at least one requirement contains ambiguous language or `[NEEDS DECISION]`
• Invoke: `Skill({ skill: "pbr:discuss", args: "{N} --auto" })`
• The `--auto` flag triggers smart discuss batching: collect ALL gray areas across the phase requirements and present them in a single batch for resolution, rather than asking one at a time.

3b. Plan Phase

• Check if `.planning/phases/{NN}-{slug}/PLAN-*.md` files exi