---
title: "Project Management — Domain Orchestrator & Delivery Loop — Agent Skill for PM"
description: "Use when coordinating project-delivery work across the 8 project-management sub-skills — sprint/velocity analytics, portfolio health, Jira/JQL. Agent skill for Claude Code, Codex CLI, Gemini CLI, OpenClaw."
---

# Project Management — Domain Orchestrator & Delivery Loop

<div class="page-meta" markdown>
<span class="meta-badge">:material-clipboard-check-outline: Project Management</span>
<span class="meta-badge">:material-identifier: `pm-skills`</span>
<span class="meta-badge">:material-github: <a href="https://github.com/alirezarezvani/claude-skills/tree/main/project-management/skills/pm-skills/SKILL.md">Source</a></span>
</div>

<div class="install-banner" markdown>
<span class="install-label">Install:</span> <code>claude /plugin install pm-skills</code>
</div>


This orchestrator does two jobs. **Routing:** fork context, classify a PM inquiry with
`scripts/pm_goal_router.py`, run exactly one of the 8 sub-skills, return a digest.
**Looping:** turn a delivery goal into a bounded agentic loop — pull live Jira data via the
bundled Atlassian MCP, bridge it into the domain's deterministic analytics tools, verify
every step with machine-run gates, and refuse to close until everything is verified or a
human waives it. The bundled `.mcp.json` wires the Atlassian Remote MCP
(`https://mcp.atlassian.com/v1/sse`, OAuth handled by Claude Code).

## When to invoke

| Symptom | Sub-skill |
|---|---|
| "Project/portfolio health, risk EMV, capacity" | `senior-pm` |
| "Sprint velocity, retro follow-through, ceremony health, when-will-it-be-done" | `scrum-master` |
| "JQL, Jira workflows, boards, automation" | `jira-expert` |
| "Confluence spaces, page trees, content audits" | `confluence-expert` |
| "Users, groups, permissions, SSO" | `atlassian-admin` |
| "Reusable Jira/Confluence templates" | `atlassian-templates` |
| "Meeting transcripts, talk time, action items" | `meeting-analyzer` |
| "Status updates, 3P updates, stakeholder comms" | `team-communications` |

## Routing logic (deterministic)

Run the router — do not eyeball the table when a script can decide:

```bash
python3 scripts/pm_goal_router.py --text "<the goal>" --output json
```

Exit 0 → `route_to` names the sub-skill: load its SKILL.md and follow its workflow.
Exit 2 → ask ONE clarifying question naming the listed candidates, with a recommended
answer. Exit 3 → no signal: ask the user to restate the goal with the deliverable named.
Never guess silently; never silently chain a second sub-skill — digest first, confirm, then
chain.

## The delivery loop (agentic)

For goals (not questions) — "get sprint 14 to a verified close", "produce a portfolio
health report from live Jira", "make our flow metrics visible weekly" — run the
loop-library contract (Observe → Choose → Act → Verify → Record → Repeat-or-stop):

1. **Observe** — pull fresh state: `mcp__atlassian__searchJiraIssuesUsingJql` (get
   `cloudId` via `getAccessibleAtlassianResources` first), save the result JSON, then
   bridge it:
   ```bash
   python3 scripts/jira_snapshot_bridge.py --input snapshot.json --to flow            # WIP, throughput, cycle time p50/85/95, work-item age, SLE, aging alerts
   python3 scripts/jira_snapshot_bridge.py --input snapshot.json --to sprint > s.json # scrum-master schema
   python3 ../scrum-master/scripts/velocity_analyzer.py s.json                        # velocity + volatility + forecast
   ```
   Add `--forecast N` for a seeded Monte Carlo "when will N items be done" answer
   (refuses on < 10 completed items — thin history forecasts are lies).
2. **Choose** — route the next task with `pm_goal_router.py`; one task at a time.
3. **Act** — execute with the routed sub-skill's own tools per its SKILL.md.
4. **Verify** — gate the plan and every close with:
   ```bash
   python3 scripts/delivery_loop_gate.py --plan plan.json --mode plan    # exit 2 = blocked
   python3 scripts/delivery_loop_gate.py --plan plan.json --mode close   # exit 4 = close refused
   ```
   Plus each sub-skill's own gates (scrum-master's ≥ 3-sprints rule, atlassian-admin's
   VERIFY steps). Never adjudicate your own verification.
5. **Record / Repeat-or-stop** — for multi-task goals, run the state through the repo-wide
   harness (it enforces attempt caps, iteration budgets, and evidence logging):
   ```bash
   python3 engineering/agent-harness/skills/agent-harness/scripts/goal_compiler.py \
     --goal "<goal>" --manifest engineering/agent-harness/skills/agent-harness/assets/harnesses/project-management.json \
     --out .agent-harness/plan.json
   python3 engineering/agent-harness/skills/agent-harness/scripts/loop_controller.py init|next|record|verify|close ...
   ```
   Terminal states: success, clean no-op, blocked, approval-required, exhausted,
   stagnated. An exhausted budget is an escalation — never a success report.

## Hard rules (agentic delegation governance)

1. **Agents are contributors, never owners** (Linear model): every loop task carries a
   named human owner; agent-executed tasks also carry a named human reviewer.
   `delivery_loop_gate.py` enforces this (G1/G2).
2. **Acceptance must be machine-checkable** — a command, or a criterion with a threshold.
   "Looks good" is not a gate (G3).
3. **Every Jira/Confluence write is auditable and reversible-first** (Rovo discipline):
   never `transitionJiraIssue` to Done without verify evidence; destructive/irreversible
   actions (deletes, permission changes, org-wide admin) are approval-required terminal
   states, not loop steps.
4. **Never modify a gate you are judged by** — same locked-evaluator invariant as
   autoresearch-agent.
5. **Forecasts are ranges with confidence, never dates** — Monte Carlo percentiles
   (p50/p70/p85/p95), per Vacanti. Single-date promises are the anti-pattern.
6. **Max 3 attempts per task, 12 loop iterations per goal** — then escalate to the named
   human with the evidence log.

## Forcing-question library (grill-with-docs pattern)

One per turn, recommended answer, canon citation. Never run a sub-skill or start a loop
until the lane-defining decision is locked:

- **SPRINT lane**: "Do you want to *measure* flow (cycle time, WIP, throughput, age) or
  *forecast* delivery? Recommended: measure first — a forecast off unmeasured flow is
  noise. Canon: Kanban Guide (May 2025) four mandatory flow measures; Vacanti,
  *Actionable Agile Metrics*."
- **HEALTH lane**: "Is your project status self-reported RAG or derived from signals?
  Recommended: derive it (schedule variance, aging WIP, scope churn) and diff against the
  self-report — that diff finds watermelon projects. Canon: Kanban Guide 2025;
  DORA 2025 (AI amplifies, doesn't fix, weak signals)."
- **JIRA lane**: "Is this configuration change deployable to a test project first?
  Recommended: always stage in a test project; jira-expert's workflow validator must exit
  0 before production. Canon: jira-expert validation workflow."
- **ADMIN lane**: "Is this action reversible, and who approves it? Recommended: name the
  approver before touching permissions — admin actions are approval-required terminal
  states in any loop. Canon: atlassian-admin VERIFY discipline; loop-library stop states."
- **LOOP intake**: "What single observable outcome means DONE, and which command proves
  it? Recommended: a named artifact + a command that exits 0 against it. Canon:
  agent-harness verifier's law; Anthropic, *Building Effective Agents* (evaluator needs
  clear criteria)."
- **MEETINGS/COMMS lanes**: "Could this meeting be an async written update? Recommended:
  status-broadcast meetings convert to async 3P updates; decision meetings keep sync.
  Canon: GitLab async-first handbook."

## Assumptions

1. The user has (or is preparing analysis for someone with) delivery authority.
2. Jira/Confluence access goes through the bundled MCP; capabilities NOT in
   `project-management/references/atlassian-mcp-tools.md` (project/sprint/board/space
   creation, admin config) are done in the web UI — never invent tool names.
3. Inputs may be partial — every tool ships `--sample` so the shape is visible first.

## Non-goals

- Not a replacement for the sub-skills — the orchestrator routes and loops; the
  sub-skills do the work.
- Not the generic loop engine — that is `engineering/agent-harness`; this orchestrator is
  the PM-domain adapter (data bridge + governance gate + lane router).
- Does not decide *what* to build — that's `product-team`.

## Output artifacts

| Mode | Artifact |
|---|---|
| Route | Sub-skill's own artifact + ≤ 200-word digest with one canon-cited challenge |
| Flow report | `flow_metrics.json` (bridge output) with SLE conformance + aging alerts |
| Delivery loop | `.agent-harness/plan.json` + `state.json` + gate verdicts + close handoff |

## Anti-patterns (do not)

- ❌ Run all 8 sub-skills "to be thorough" — route to one, digest, chain on confirmation
- ❌ Report sprint health or forecasts from hand-typed numbers when a Jira snapshot is one
  MCP call away — bridge real data
- ❌ Close a loop with unverified tasks, or report an exhausted budget as success
- ❌ Let an agent be the assignee of record — humans own, agents contribute
- ❌ Auto-transition Jira issues or touch permissions inside a loop without the named
  approver

## References

- [references/flow_forecasting_canon.md](https://github.com/alirezarezvani/claude-skills/tree/main/project-management/skills/pm-skills/references/flow_forecasting_canon.md) — Kanban
  Guide 2025, Vacanti Monte Carlo, DORA 2025, EBM, SPACE
- [references/agentic_delivery_governance.md](https://github.com/alirezarezvani/claude-skills/tree/main/project-management/skills/pm-skills/references/agentic_delivery_governance.md) —
  Linear/Rovo delegation models, Anthropic agent patterns, audit discipline
- [references/pm_loop_playbook.md](https://github.com/alirezarezvani/claude-skills/tree/main/project-management/skills/pm-skills/references/pm_loop_playbook.md) — the five reusable PM
  loops (sprint, health, retro-action, RAID-hygiene, comms) mapped to the loop contract
- Canonical MCP tool list: `project-management/references/atlassian-mcp-tools.md`
- Loop engine: `engineering/agent-harness` · Loop vocabulary: `loop-library`
