/r-vpe

/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 (plugin-only install), --resume is unavailable: run a fresh pipeline, or use the symlink deploy for session state.

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