Skip to main content
PM is a lightweight project-management layer that sits above OpenSpec and Superpowers inside Claude Code. It doesn’t duplicate what those tools already do — it fills the gap above them, owning cross-epic ordering, an explicit detour stack, and the reconcile gate that ties interrupted work back to the proposal it was built against. After any context compaction, PM answers three questions in seconds: what were we working on before the detour, what work is currently outstanding, and what is the next highest-priority item to tackle.

​
The problem PM solves

Agentic coding sessions are interrupted constantly — a bug surfaces mid-sprint, a new requirement lands, a context window fills up and collapses. Traditional task trackers live outside the session entirely and don’t survive the compaction boundary. Notes in a conversation transcript vanish with the context. Even a carefully maintained CLAUDE.md doesn’t tell you whether the proposal you were halfway through is still valid after the detour that interrupted it. PM solves this by living inside Claude Code as a plugin with its own hooks. A SessionStart hook re-injects the full briefing the moment a new context begins — so the agent picking up after compaction sees the active epic, the detour stack, and the next-up queue without any manual re-orientation. A PreToolUse gate-guard hook mechanically blocks writes while a reconcile is still owed. Nothing depends on the agent “remembering” the right thing.

​
Core mechanisms

PM is built on three interlocking mechanisms. Together they make project state durable across the events that normally destroy it:

Epics & Lanes

Every unit of work is an epic with a lane (openspec, superpowers, claude-code, decision, external), a priority (P0–P3), and a lifecycle status. Epics are lane-agnostic at the conductor level — PM tracks them regardless of which tool owns execution.

Detour Stack

When a mid-build interrupt arrives, PM classifies it as minimal (fix-and-resume, logged only) or substantial (PUSH the active epic, build the detour, POP and reconcile). The stack is durable in .conductor/state.json — it survives compaction and session restarts.

Reconcile Gate

Before a paused epic can resume, a fresh-context reconciler agent re-validates it against what the detour actually shipped. The verdict is written durably via record-reconcile — not left in the transcript — and a PreToolUse hook hard-blocks any write while the gate is still owed.

Quick Start

Install PM, run /pm:init in your project, and get your first status briefing in under five minutes. No npm install, no external dependencies.

​
What PM is NOT

PM is not a replacement for OpenSpec or Superpowers. It sits deliberately above them and only owns what neither of those tools owns:
  • OpenSpec owns the spec-driven proposal workflow — proposal.md, design.md, tasks.md, gate reviews. PM tracks that an OpenSpec epic exists and its priority; it doesn’t touch the spec artifacts themselves.
  • Superpowers owns execution discipline — brainstorming, TDD, subagent-driven development, code review. PM tracks when and in what order an epic gets built; Superpowers drives how well it gets built.
  • PM owns cross-epic ordering, the detour stack, and reconcile links. Nothing else. Stories stay wherever they already live — PM doesn’t move them or replace them.
PM runs exclusively in Claude Code today. Codex, Gemini CLI, Grok Build, and other AGENTS.md-based platforms are on the roadmap.

​
Real numbers

These aren’t benchmarks — they’re real figures pulled from PM’s own git log, from the project that manages its own development through PM itself: All 21 agents ran worktree-isolated and converged back through sequential merge with zero data loss and zero unresolvable conflicts. Every conflict was mechanical (a shared CHANGELOG header, a usage string) — never a real logic collision. The engine (scripts/conductor.mjs) is ~2,100 lines of Node 18+ built-ins only.
PM manages its own development — the backlog, roadmap, and every release of PM itself run through PM. The PROJECT.md in the cfdude/pm repo is a live example of what PM produces.