handoff

# Phase 3: Handoff

Declarative phase skill. Invoked by the prd-taskmaster orchestrator when
`current_phase` is `HANDOFF`. Never called directly by a user.

The one rule: **detect what the user has, recommend ONE mode, give the user a
structured choice, dispatch the chosen mode. Mode D executes only on tier=premium; otherwise it is a locked teaser.**

## Entry gate

1. Call `mcp__plugin_prd_go__check_gate(phase="HANDOFF", evidence={})`.
   If the call returns `{gate_passed: false, violations: [...]}`, report the
   violations and stop. The gate protects against re-entering a completed
   phase or skipping ahead from GENERATE.

   **Known issue (Mum dogfood feedback [4]/[10]):** check_gate(HANDOFF)
   requires `user_mode_choice` and `plan_file_exists` — both produced by
   HANDOFF itself. On first entry, evidence=`{}` will fail. State machine
   LEGAL_TRANSITIONS already prevents illegal entry — proceed past this
   gate on first entry. Semantic fix in flight (see morning brief).
2. Read the GENERATE outputs — `.taskmaster/docs/prd.md`, `.taskmaster/tasks/tasks.json`,
   `.taskmaster/reports/task-complexity-report.json`. If any are missing,
   report and stop. The gate should have caught this, but belt-and-braces.

## Handoff checklist

Copy into your response before running the procedure:

```
HANDOFF CHECKLIST:
- [ ] Capabilities detected (tier + per-capability flags)
- [ ] Recommended mode: ___ (reason: ___)
- [ ] Summary displayed (spec location, task count, capabilities)
- [ ] CLAUDE.md task workflow appended (idempotent)
- [ ] AskUserQuestion mode picker surfaced (or prose fallback if hook-blocked)
- [ ] User choice dispatched (Mode A / B / C, or D when tier=premium)
- [ ] Debrief scaffold emitted (optional, silently tolerated)
- [ ] Handoff complete
```

## Step 1: Detect capabilities

**MCP (preferred)**: `mcp__plugin_prd_go__detect_capabilities()`

**CLI fallback**: `python3 script.py detect-capabilities`

Returns a `tier` field (`"free"` or `"premium"`) plus per-capability flags.
Key signals:

| Capability | What It Enables |
|------------|----------------|
| superpowers plugin | Modes A, C (brainstorm, plans, subagents) |
| task-master-ai (CLI or MCP) | Mode B (native auto-execute loop) |
| ralph-loop plugin | Mode C (iterative execution loop) |
| atlas-launcher MCP (licensed) | Mode D — Atlas Fleet (tier=premium) |
| atlas-loop / atlas-cdd skills | legacy Mode-D seeds — superseded by atlas-launcher detection |
| Research model (task-master or MCP) | Deep research per task |
| Playwright MCP | Tier S browser verification |

**Mode D (Atlas Fleet) unlocks on `tier: "premium"` only** — i.e. a licensed
`atlas-launcher` MCP registration detected by `detect_atlas_launcher()`. Local
`atlas-loop`/`atlas-cdd` skills do NOT unlock it. See Step 2 and the Mode D
section below.

## Step 2: Recommend ONE mode

Decision logic (first match wins):

- `superpowers` + `ralph-loop` present → **Mode C** (recommended free)
- `superpowers` only → **Mode A** (plan-only, manual drive)
- `task-master-ai` only → **Mode B** (native auto-execute)
- Fallback → **Mode A**

External-tool modes (E–J: Cursor, RooCode, Codex, Gemini, CodeRabbit, Aider)
are offered as alternatives via the `alternative_modes` field, not primary
recommendations. **Mode D is recommended iff `tier == "premium"` AND the task
graph parallelizes (>= 2 independent dependency chains — check `fleet-waves`
output: any wave with >= 2 chunks). Premium + serial graph: recommend the best
free mode and say why ("your tasks form a single dependency chain — Verified
Loop is the right tool here"); Fleet stays selectable but not default. Free
tier: Mode D is a locked Atlas Pro teaser, never selectable, regardless of
which local plugins are installed.**

### Mode A: Plan Only (Manual)

```
Recommended: Plan Only
  superpowers:writing-plans creates your implementation plan
  Plan references TaskMaster task IDs from tasks.json
  You drive execution manually
```

### Mode B: TaskMaster Auto-Execute (Mode B — TaskMaster backend only)

```
Recommended: TaskMaster Auto-Execute
  MCP:  mcp__task-master-ai__next_task -> implement -> set_task_status(id, "done") (Mode B — TaskMaster backend only)
  CLI:  task-master next -> implement -> task-master set-status --id N --status done (Mode B — TaskMaster backend only)
  Native TaskMaster execution loop (no external orchestrator required)
```

### Mode C: Plan + Ralph Loop (Recommended Free)

```
Recommended: Plan + Ralph Loop
  superpowers:writing-plans → implementation plan referencing tasks.json IDs
  ralph-loop wraps each task:
    next_task → set_task_status("in-progress") → research if <80% confident
    → subagent-driven-development → execution gate (Tier A+ evidence)
    → post-doubt check → log to .claude/verification-log.md
    → set_task_status("done") → TodoWrite → repeat
  Completion: doubt agent reviews verification log before promise satisfied.
```

### Mode D: Atlas Fleet (selectable on tier=premium; 🔒 locked teaser on free)

```
🔒 Atlas Fleet                                          Atlas Pro · $29/mo
  Parallel multi-session execution across Claude, Codex, and Gemini:
    your task graph split into dependency waves of isolated git worktrees
    checker-gated merges into one integration branch, one final PR
    durable inbox result collection (verified, not narrated)
    CDD evidence card per task; one SHIP_CHECK_OK at the end
    Walk away, come back to proof.

  Unlock: https://atlas-ai.au/pro   (the free modes above stay free forever)
```

**When `tier == "premium"`** (licensed `atlas-launcher` detected): Mode D is a
real, selectable mode — dispatching it invokes `/prd:execute-fleet`
(the wave orchestrator skill). Show the unlocked card:

```
▸ Atlas Fleet                     ★ Pro · license active
  <N> waves · est. from your dependency graph · walk-away
```

**When `tier == "free"`**: Mode D is a locked teaser — not selectable, never
executed. If the user selects it while locked, respond w