r-vpe git:20260902.42a192dA

Immutable. This exact content never changes and is served at /api/v1/blob/c35bf03c75e226a0.

---
name: r-vpe
description: >
  Optional end-to-end pipeline orchestrator. Takes outcome-oriented
---

# /rdf:r-vpe — Pipeline Orchestrator

Optional end-to-end pipeline orchestrator. Takes outcome-oriented
conversation from the user and manages the full
spec → plan → build → ship workflow.

This command is purely additive. It calls existing pipeline commands
unchanged. Users who prefer manual control can continue using
/rdf:r-spec, /rdf:r-plan, /rdf:r-build, and /rdf:r-ship independently.

## Invocation

/rdf:r-vpe                — start new pipeline from conversation
/rdf:r-vpe --resume       — resume interrupted pipeline from state file

## Task List Protocol

Create tasks progressively — one stage at a time, not all upfront.
The task list UI sorts by status bucket (in_progress → pending →
completed), then by creation order within each bucket. Creating all
pipeline tasks at startup causes future-stage tasks (Plan, Build,
Ship) to appear before the current sub-command's tasks (Research,
Write spec, Phase 2...) in the pending list.

**Rules:**
- Create only Intake at startup
- Sub-commands (/rdf:r-spec, /rdf:r-plan, /rdf:r-build) create their own task
  lists — do NOT create duplicate umbrella tasks for those stages
- Create Ship only after /rdf:r-build completes all phases — this keeps
  it after all phase tasks in creation order

At startup:

TaskCreate: "Intake: understand outcome and scope"
  activeForm: "Understanding desired outcome"

After all build phases pass:

TaskCreate: "Ship: release workflow"
  activeForm: "Shipping"

## Resume Protocol

If --resume is specified, source `~/.rdf/state/rdf-bus.sh`, call
`rdf_session_init`, and look for
`.rdf/work-output/vpe-progress-${RDF_SESSION_ID}.md`. If not
found, glob `.rdf/work-output/vpe-progress-*.md` and present
candidates ordered by mtime. If exactly one un-suffixed
`.rdf/work-output/vpe-progress.md` exists (legacy from pre-3.1.0),
prompt: "Found legacy progress file. Import? [Y/n]".
If `~/.rdf/state/rdf-bus.sh` is absent (helpers not yet bootstrapped — fresh
plugin install before its first session restart), `--resume` is unavailable:
run a fresh pipeline; restart the session (plugin) or run `rdf deploy
claude-code` (checkout) to deliver them.

1. Read the state file
2. Determine pipeline stage reached
3. Present resume state:
   "Resuming pipeline for: {topic}
    Stage: {intake|spec|plan|build|ship}
    Progress: {stage-specific detail}
    Continue? [Y/start fresh]"
4. If continuing: skip completed stages, resume current stage
   (delegate to the appropriate command's own resume mechanism)

## Stage 1: Intake

Mark task "Intake" as in_progress.

### Adaptive Conversation

Read the user's input. Assess clarity:

**Clear input** (actionable problem statement with scope):
  Restate as structured problem statement. Ask for confirmation.
  1 exchange.

**Partially clear** (has direction but missing scope or motivation):
  Ask 1-2 targeted questions:
  - "What's driving this?" (if motivation unclear)
  - "What does success look like?" (if acceptance unclear)
  Then synthesize. 2-3 exchanges.

**Vague input** (general dissatisfaction or broad goal):
  Ask up to 3 questions:
  - "What specific friction are you experiencing?"
  - "What's driving this change now?"
  - "What would success look like?"
  Then synthesize. 3-4 exchanges.

**Max 4 exchanges before synthesizing.** Do not let intake become
an unbounded conversation.

### Problem Statement Synthesis

After intake, present:

"Here's what I understand:

**Problem:** {1-2 sentences describing the current state}
**Goal:** {1-2 sentences describing desired outcome}
**Scope:** {what's in, what's explicitly out}
**Success:** {how to verify it's done}

Ready to design? [Y/adjust]"

Wait for user confirmation.

Write state to .rdf/work-output/vpe-progress-${RDF_SESSION_ID}.md:
    TOPIC: {topic}
    STAGE: intake
    STATUS: complete
    PROBLEM: {problem statement}
    GOAL: {goal}
    SCOPE: {scope}

Mark task "Intake" as completed.

## Stage 2: Design (invokes /rdf:r-spec)

Before invoking /rdf:r-spec, check docs/specs/ for existing specs. If a
recent spec exists and matches the intake topic, present:
  "Found existing spec: {path}. Use this? [Y/new spec]"
If Y, skip to Stage 3 (Plan).

Otherwise, invoke /rdf:r-spec with the synthesized problem statement as
the seed input. The user participates in brainstorming and design
questions as normal — VPE does not suppress or shortcut the /rdf:r-spec
workflow.

VPE's role during spec:
- Ensure the problem statement from intake is the starting context
- Let /rdf:r-spec handle all brainstorming, research, and spec writing
- After /rdf:r-spec completes, read the committed spec path

After spec is committed:

"Spec complete: {spec path}
 Ready to plan the implementation? [Y/pause]"

If user says pause: write state and stop (user can resume with
/rdf:r-vpe --resume).

Write state:
  STAGE: spec
  STATUS: complete
  SPEC_PATH: {path}

## Stage 3: Plan (invokes /rdf:r-plan)

Invoke /rdf:r-plan with the spec path. The user approves the plan as
normal — VPE does not suppress the /rdf:r-plan workflow.

After plan is committed:

"Plan ready: {plan_path} ({N} phases)
 Ready to build? [Y/pause/build-specific-phase]"

Write state:
  STAGE: plan
  STATUS: complete
  PLAN_PHASES: {N}

## Stage 4: Build (invokes /rdf:r-build --parallel)

Invoke /rdf:r-build --parallel. The build command handles all phase
orchestration: dependency graph reading, batch computation, parallel
dispatch, merge, quality gates, and failure handling.

VPE receives the aggregate result:
- All phases passed → continue to ship
- Failures exist → present to user:
  "Build completed with failures:
   {failure summary from /rdf:r-build}
   [retry-failed / pause / continue-to-ship]"
  Wait for user decision.

After all phases complete:
  "All {N} phases complete. End-of-plan review: {verdict}.
   Ready to ship? [Y/pause]"

Write state after build completes:
  STAGE: build
  STATUS: complete
  COMPLETED_PHASES: [1, 2, ..., N]

Create the Ship task now (after all phase tasks exist, so it
appears last in the pending list):

TaskCreate: "Ship: release workflow"
  activeForm: "Shipping"

## Stage 5: Ship (invokes /rdf:r-ship)

Mark task "Ship" as in_progress.

Invoke /rdf:r-ship. The user confirms the PR as normal — VPE does not
suppress the /rdf:r-ship workflow.

After ship completes:

"> **Pipeline complete** — {project} shipped.
>  Spec: {spec_path}
>  Plan: {plan_path} ({N} phases)
>  Ship: {PR URL}"

Write state:
  STAGE: ship
  STATUS: complete

Mark task "Ship" as completed.

Clean up: vpe-progress-${RDF_SESSION_ID}.md retained for session log reference.

## Constraints

- Never modify existing pipeline commands — call them as-is
- Never suppress user interaction within pipeline commands
- Never skip approval gates (spec approval, plan approval, ship confirmation)
- Auto-continue between build phases only (phases are already approved
  as a batch when the plan was approved)
- Max 4 exchanges during intake — escalate to /rdf:r-spec if more exploration needed
- Track state in vpe-progress-${RDF_SESSION_ID}.md for crash recovery at every stage transition