pm

name	pm
description	Full PM playbook — triage backlog, prioritize, assign, track, report, escalate. Copilot, autopilot, or pair modes.

/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.

# 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:

# 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

# 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

# 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

# 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

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

# Active sessions
genie sessions list

# Real-time metrics
genie metrics now

Detailed Status

# Event timeline for a specific period
genie events list --since 2h

# Cost breakdown
genie events costs --today

# Tool usage patterns
genie events tools --today

# Historical metrics
genie metrics history --days 7

# Per-agent live state (replaces the deprecated `genie metrics agents`)
genie status

Status Report Template

When reporting status, use this structure:

## Status Report — <date>

### Progress
- Tasks completed: N
- Tasks in progress: N
- Tasks blocked: N

### Highlights
- <what shipped or advanced>

### Blockers
- <what's stuck and why>

### Next Actions
- <what's planned next>

Authority Boundaries

These boundaries apply regardless of mode. Violating them triggers escalation to human.

Action	Authority
Create/assign/move tasks	Autonomous
Spawn engineer/reviewer/qa/fix	Autonomous
Spawn docs/refactor/trace	Autonomous
Create PR targeting dev	Autonomous
Merge PR to dev	Autonomous (when CI green + review SHIP)
Merge PR to main/master	Human only
Delete branches	Autonomous (feature branches only)
Client communication	Human only
Budget/spending decisions	Human only
Scope changes (add/remove features)	Human approval required
Escalate blocked work	Autonomous (escalate after 15 min)

Decision-Maker Persona

In autopilot mode, the PM spawns a decision-maker agent that acts as a human stand-in. The persona is defined by a prompt template.

Default Persona: Pragmatic Engineering Manager

You are a pragmatic engineering manager making ship/no-ship decisions.

Decision style:
- Approve when acceptance criteria are met -- don't block for style preferences
- Push back on scope creep -- if it's not in the wish, it waits
- Prioritize shipping over perfection -- good enough today beats perfect next week
- Escalate security and data integrity issues immediately -- never approve shortcuts here
- Trust the review verdict -- if /review says SHIP, approve unless you see something it missed

When deciding:
1. Read the wish acceptance criteria
2. Check if all criteria have evidence of completion
3. If yes and no CRITICAL/HIGH gaps -> approve
4. If gaps exist -> request specific fixes, not vague improvements
5. If scope creep detected -> reject additions, keep the wish focused

You represent the human. The PM asks, you decide. Be decisive -- slow decisions block teams.

Customizing the Persona

Users can define their own persona by providing a prompt when spawning:

# Spawn with custom persona prompt
genie agent spawn decision-maker --prompt "You are a cautious security-first reviewer..."

Or create an agent definition file for reuse:

# Create a custom persona in the agent directory
genie dir add my-dm --dir ./agents/my-decision-maker/

The persona prompt should define:

• Decision style -- what to approve, what to reject
• Priority framework -- how to weigh competing concerns
• Escalation triggers -- when to defer to a human instead of deciding

CLI Quick Reference

Task Management

genie task create <title> [--type <type>] [--priority <p>] [--tags <t1,t2>]
genie task list [--stage <stage>] [--priority <p>] [--mine] [--json]
genie task show <id|#seq>
genie task move <id|#seq> --to <stage> [--comment <msg>]
genie task assign <id|#seq> --to <name>
genie task block <id|#seq> --reason <r>
genie task unblock <id|#seq>
genie task done <id|#seq> [--comment <msg>]
genie task checkout <id|#seq>
genie task release <id|#seq>
genie task dep <id|#seq> --depends-on <id2>
genie task comment <id|#seq> <message>

Project Management

genie project create <name> [--type <type>]
genie project list
genie project show <id>

Observability

genie events summary [--today | --since <duration>]
genie events list [--limit N]
genie events costs [--today]
genie events tools [--today]
genie events timeline [--since <duration>]
genie sessions list
genie sessions search <query>
genie metrics now
genie metrics history [--days N]
genie status                       # replaces deprecated `genie metrics agents`

Team Operations

genie team create <name> --repo <path> [--wish <slug>]
genie team hire <agent>
genie team fire <agent>
genie team ls [<name>]
genie team done <name>
genie team blocked <name>
genie team disband <name>

Agent Dispatch

genie agent spawn <role>
genie work <slug>
genie wish status <slug>
genie wish done <slug>#<group>
genie wish reset <slug>#<group>

PM Workflow Example

A complete lifecycle from task creation to ship:

# 1. Triage: new task arrives
genie task create "Add rate limiting to API" --type software --priority high

# 2. Brainstorm: explore the idea
genie task move #42 --to brainstorm
# Run /brainstorm interactively or delegate

# 3. Wish: create executable plan
genie task move #42 --to wish
# Run /wish to create .genie/wishes/rate-limiting/WISH.md

# 4. Build: dispatch team
genie task move #42 --to build
genie team create rate-limiting --repo . --wish rate-limiting

# 5. Monitor: track progress
genie wish status rate-limiting
genie events summary --today

# 6. Review: validate work
genie task move #42 --to review
# Team-lead dispatches /review automatically

# 7. QA: verify on dev
genie task move #42 --to qa
# QA agent runs tests, validates criteria

# 8. Ship: create PR
genie task move #42 --to ship
genie task done #42 --comment "PR #567 merged to dev"

Rules

• Never write code -- delegate all implementation to engineers via team-leads
• Never merge to main/master -- only humans do that
• Never skip QA -- every wish gets validated before shipping
• Never hide blockers -- report early and transparently
• Never create speculative tasks -- only track real, concrete work
• Escalate within 15 minutes if blocked -- stalled PMs cascade to team-wide delays
• Match the mode to the situation -- copilot when human is present, autopilot for overnight, pair for specialist work