pm

# /pm — Project Management Playbook

Teach any agent to manage the full software development lifecycle: triage backlog, prioritize, assign, track, report, and escalate. Operates in three modes depending on who is making decisions.

## When to Use

- Agent needs to manage a backlog of tasks across stages
- Work requires coordination across multiple agents or teams
- User wants structured project management with clear stages
- User asks about task tracking, status, or project health
- `/genie` routes here for project management questions

## Three Modes

### Copilot Mode (PM + Human)

The PM suggests, the human decides. Use when a human is actively participating.

| PM Does | Human Does |
|---------|------------|
| Triage and prioritize backlog | Approve priorities |
| Suggest assignments | Confirm assignments |
| Monitor progress and surface blockers | Make scope decisions |
| Prepare status reports | Review and distribute reports |
| Recommend escalations | Authorize escalations |

**Entry:** Human invokes `/pm` directly or asks for help managing work.
**Exit:** Human says "I'll take it from here" or all tasks are shipped.

### Autopilot Mode (PM + Decision-Maker Persona)

The PM spawns a decision-maker agent that emulates human judgment. Use for fully autonomous operation.

```bash
# Spawn a decision-maker persona
genie agent spawn decision-maker
```

The decision-maker receives a persona prompt that defines its judgment style (see Decision-Maker Persona below). The PM orchestrates, the persona approves.

**Entry:** Human says "run autonomously" or "autopilot mode".
**Exit:** All tasks shipped, or a decision exceeds authority boundaries (escalate to human).

### Pair Mode (PM + Specialist Agent)

The PM pairs with a specialist agent for focused work. Use when a specific domain needs attention.

| Pair With | When |
|-----------|------|
| Brainstormer | Ideas need exploring before scoping |
| Architect (council) | Major design decisions needed |
| Reviewer | Quality gate needs PM context |
| QA | Test strategy needs PM input |

**Entry:** PM detects a task that benefits from specialist pairing.
**Exit:** Specialist delivers their output, PM resumes normal flow.

## Stage-to-Skill Mapping

Tasks flow through stages defined by the task type template. For the default `software` type:

```bash
# View the stage pipeline for software tasks
genie type show software
```

| Stage | Skill / Action | What Happens |
|-------|---------------|--------------|
| **draft** | Triage | PM reviews, sets priority, assigns owner |
| **brainstorm** | `/brainstorm` | Explore idea, track WRS, crystallize design |
| **wish** | `/wish` | Convert design into executable wish with groups |
| **build** | `/work` | Dispatch engineers per execution group |
| **review** | `/review` | Validate against acceptance criteria |
| **qa** | QA agent | Write tests, run suite, verify criteria on dev |
| **ship** | PR + merge | Create PR to dev, human merges to main |

### Moving Tasks Through Stages

```bash
# Move a task to the next stage
genie task move #<seq> --to brainstorm --comment "Ready for exploration"
genie task move #<seq> --to wish --comment "Design crystallized, scope clear"
genie task move #<seq> --to build --comment "Wish approved, dispatching engineers"
genie task move #<seq> --to review --comment "Implementation complete"
genie task move #<seq> --to qa --comment "Review passed, ready for QA"
genie task move #<seq> --to ship --comment "QA passed, creating PR"
```

## Agent Routing

The PM knows WHEN to spawn which specialist. Default flow is engineer -> reviewer -> qa -> fix, but specialists augment or replace steps when needed.

| Condition | Spawn | Instead of / In addition to |
|-----------|-------|-----------------------------|
| Wish includes documentation deliverables | `docs` | In addition to engineer (parallel) |
| Wish involves architecture changes or restructuring | `refactor` | Instead of engineer for that group |
| Failure with unknown root cause | `trace` | Before fix (trace diagnoses, fix applies) |
| Review returns FIX-FIRST | `fix` | Standard fix loop (max 2 iterations) |
| Complex decision with tradeoffs | `council` | Advisory before proceeding |
| Quality gate after merge to dev | `qa` | Validates acceptance criteria |

### Decision Points

**After reading WISH.md, before dispatching groups:**
1. Check wish scope for docs deliverables -> spawn `docs` in parallel with engineer
2. Check wish scope for "refactor" or "restructure" keywords -> spawn `refactor` instead of engineer for that group
3. Default: spawn `engineer`

**After engineer reports failure with unclear cause:**
1. Spawn `trace` BEFORE spawning `fix` -- trace diagnoses, fix applies
2. If trace finds root cause -> dispatch `fix` with trace report
3. If trace cannot determine cause -> escalate as BLOCKED

## Board Management

### Setting Up a Project Board

```bash
# Create a new project with the software template
genie project create "My Project" --type software

# List all projects
genie project list

# Show project details and task counts
genie project show <project-id>
```

### Board Operations

```bash
# List all tasks (backlog view)
genie task list --all

# Filter by stage
genie task list --stage build

# Filter by priority
genie task list --priority urgent

# Show only my assigned tasks
genie task list --mine

# Create a new task
genie task create "Implement auth middleware" --type software --priority high

# Assign a task
genie task assign #<seq> --to engineer

# Add dependencies
genie task dep #<seq> --depends-on #<other-seq>

# Block a task with reason
genie task block #<seq> --reason "Waiting for API spec"

# Mark task done
genie task done #<seq> --comment "PR #123 merged"
```

## Status Reporting

### Quick Status

```bash
# Today's activity summary
genie events summary --today

# Active sessions
genie sessions list

# Real-time metrics
genie metrics now
```

### Detailed Status

```bash
# Event timeline for a specific period