AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

pm-skills

Use when a delivery request needs routing across the project-management skills (sprints, portfolio health, Jira, Confluence, comms), or to run a delivery loop. Routes with pm_goal_router.py, bridges Jira data with jira_snapshot_bridge.py and gates with delivery_loop_gate.py.

Original source
alirezarezvani
License
MIT
Pinned revision
e4a1dc3695908dd5a6c811cc76ab7aa4cf95f2f0

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

This skill also requires local files or dependencies. Remote reading alone may not be enough.

Ask your assistant

Use Agentic Memory skills to read alirezarezvani--pm-skills at revision e4a1dc3695908dd5a6c811cc76ab7aa4cf95f2f0, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 4

SKILL.md

Project Management — Domain Orchestrator & Delivery Loop

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:

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