/pbr:continue — Action-Oriented Resumption

You are running the continue skill. Unlike /pbr:resume which shows status and suggests actions, /pbr:continue determines and EXECUTES the next logical step automatically.

This skill runs inline and may delegate to other skills via agent invocation.

Step 0 — Immediate Output

Before ANY tool calls, display this banner:

code

╔══════════════════════════════════════════════════════════════╗
║  PLAN-BUILD-RUN ► NEXT STEP                                  ║
╚══════════════════════════════════════════════════════════════╝

Then proceed to Step 1.

Context Budget

Reference: skills/shared/context-budget.md for the universal orchestrator rules.

Additionally for this skill:

•Minimize state reads — read only STATE.md lines 1-20 to determine next action
•Delegate execution to the appropriate skill

Core Principle

Do, don't ask. Read STATE.md, determine the next action, and execute it. The user wants hands-off forward progress.

Flow

Step 1: Read State

Read .planning/STATE.md and determine current position:

•Current phase number and name
•Current plan progress
•Phase status (planning, building, reviewing, complete)

Then read .planning/ROADMAP.md to identify the current milestone boundary:

•Find which ## Milestone: section contains the current phase
•Determine if the current phase is the last phase in that milestone section
•If this is the last phase and it is verified/complete, warn: "This is the final phase of milestone {name}. After verification, run /pbr:milestone to complete it."
•If the current phase's Depends on references a phase from the previous milestone that is not yet complete, warn: "Cross-milestone dependency: Phase {N} depends on Phase {M} from milestone {prev}, which is not yet complete."

If STATE.md doesn't exist, display:

code

ERROR

No project state found.

**To fix:** Run `/pbr:begin` first.

Context Budget Guard

Before proceeding to priority evaluation, check for runaway continue chains:

•Read last_command from STATE.md. If last_command is missing, empty, or the field does not exist, skip directly to the fallback detection — do NOT error or warn.
•If last_command is present and equals /pbr:continue, this is a chained continue. Check session context for consecutive /pbr:continue invocations.
•
Fallback detection — if last_command is not available or not present in STATE.md:
- •Check .planning/.active-skill file — if it contains continue, treat as a chained continue
- •Check STATE.md last_action field — if it contains continue, treat as a chained continue
- •If neither source is available, assume this is the first invocation (do not warn)
•If this is the 6th consecutive /pbr:continue in a row, display:

code

WARNING: Context budget warning: 6 consecutive auto-continues detected.
Recommend running /pbr:pause then resuming in a fresh session.

Then present the user with a choice:

•"Continue" — proceed with the next action
•"Pause" — run /pbr:pause logic to save state and stop

This prevents runaway chains that fill the context window without a human checkpoint.

Step 2: Scan for Priority Items

Check the resumption priority hierarchy (same as /pbr:resume):

•UAT Blockers: VERIFICATION.md with status: gaps_found -> Execute /pbr:plan {N} --gaps
•Checkpoint pending: .checkpoint-manifest.json with pending items -> Resume the build
•Continue-here file: .continue-here.md exists -> Follow its next step
•Incomplete build: PLAN.md files without SUMMARY.md -> Execute /pbr:build {N}
•Unverified phase: All plans complete, no VERIFICATION.md -> Execute /pbr:review {N}
•Phase complete, more phases exist: Verification passed -> Execute /pbr:plan {N+1}
•All phases complete: Verification passed on final phase, no more phases in ROADMAP.md -> Stop. Display: "All phases are complete. Run /pbr:milestone audit to verify cross-phase integration, or /pbr:milestone complete to archive this milestone."

Step 3: Execute

Based on the determined action, display the delegation indicator to the user:

code

Delegating to /pbr:{skill} {args}...

Then invoke the appropriate skill. NEVER read SKILL.md files into your context — this wastes the main context budget with 500+ lines of instructions. Instead, invoke the skill directly:

Situation	Action	Skill to invoke
Gaps need closure	Plan gap closure	`/pbr:plan {N} --gaps`
Build incomplete	Continue build	`/pbr:build {N}`
Review needed	Run review	`/pbr:review {N}`
Next phase needed	Plan next phase	`/pbr:plan {N+1}`
Project not started	Plan phase 1	`/pbr:plan 1`

Where {N} is the current phase number determined from STATE.md in Step 1.

Step 4: Report and Chain

After execution completes, display a branded completion:

code

╔══════════════════════════════════════════════════════════════╗
║  PLAN-BUILD-RUN ► STEP COMPLETE                              ║
╚══════════════════════════════════════════════════════════════╝

Completed: {what was done}

---

## Next Up

**{Next action description}**

`/pbr:continue` or `{specific command}`

---

If features.auto_advance is true AND mode is autonomous: After the delegated skill completes, immediately re-run Step 1-3 to determine and execute the NEXT action. Continue chaining until a hard stop is reached. This enables hands-free phase cycling: build->review->plan->build->...

Hard Stops

Do NOT auto-continue when:

•config.mode is NOT autonomous and a gate confirmation is needed
•A checkpoint requires human input (decision, verify, action)
•An error occurred during execution
•The milestone is complete
•Verification found gaps (need user review before advancing)

In these cases, explain why auto-continue stopped and what the user needs to do.

Anti-Patterns

•DO NOT ask the user what to do — determine it from state
•DO NOT skip error handling — if something fails, stop and report
•DO NOT continue past checkpoints that need human input
•DO NOT auto-continue into a new milestone — that needs user initiation
•DO NOT modify STATE.md directly — let the delegated skill handle it