autonomous

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.

1. 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 |

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

1. Read gates.checkpoint_auto_resolve from config (default: "none"). Values:
2. "none": STOP on all checkpoints (user must resolve)
3. "verify-only": Auto-resolve checkpoint:human-verify (proceed after confidence-gate passes), STOP on checkpoint:human-action
4. "verify-and-decision": Auto-resolve verify + decision checkpoints, STOP on checkpoint:human-action
5. "all": Auto-resolve all checkpoints (dangerous — only for fully automated pipelines)

Store as checkpointResolveLevel for use in Step 3c.

1. Read .planning/STATE.md to determine current phase (used as default for --from).
2. Read .planning/ROADMAP.md to build phase list for current milestone.
3. 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.
4. Filter to phases from --from through --through that are not yet complete.
5. 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. ``

1. 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 exist
• If NOT exists:
• Invoke: Skill({ skill: "pbr:plan", args: "{N} --auto" })
• If plans exist (from speculative planning or prior run): skip planning.
• Log: Phase {N}: plans already exist (speculative or prior) -- skipping plan step.
• Note: even if planning is skipped, the 3b-validate gate below will verify plans are validated.
• If Skill returns failure: stop autonomous loop, display error, suggest: /pbr:plan {N}

3b-validate. Plan Validation Gate (always runs)

CRITICAL -- DO NOT SKIP. No phase may enter build without passing plan validation.

1. Check if .planning/phases/{NN}-{slug}/.plan-check.json exists.
2. If it exists: read it and verify status === "passed".
3. If passed: log Phase {N}: plan validation passed and proceed to 3c.
4. If not passed: log Phase {N}: plan validation failed -- re-running plan checker
5. Invoke: Skill({ skill: "pbr:plan", args: "{N} --audit --auto" })
6. Re-check .plan-check.json. If still not passed: stop autonomous loop.

Display: BLOCKED: Phase {N} plans failed validation. Fix issues with /pbr:plan {N} --audit

1. If .plan-check.json does NOT exist (plans came from speculative planner which bypassed plan-checker):
2. Log: Phase {N}: no .plan-check.json -- running plan checker on existing plans
3. Invoke: Skill({ skill: "pbr:plan", args: "{N} --audit --auto" })
4. After completion, re-check .plan-check.json. If missing or failed: stop autonomous loop with same BLOCKED message.

3c. Build Phase

• Check if all PLAN files have corresponding SUMMARY files
• If incomplete:
• Invoke: Skill({ skill: "pbr:build", args: "{N} --auto" })
• If all SUMMARYs exist: skip build
• Checkpoint handling (uses checkpointResolveLevel from Step 1):
• checkpoint:human-action: ALWAYS stop (regardless of config). Display: "Human action required in Phase {N}. Complete the action, then resume with: /pbr:autonomous --from {N}"
• checkpoint:human-verify: If checkpointResolveLevel is "verify-only", "verify-and-decision", or "all": auto-resolve by running confidence gate. Otherwise STOP.
• checkpoint:human-decision: If checkpointResolveLevel is "verify-and-decision" or "all": auto-resolve with default option. Otherwise STOP.
• Any o