@unbrained/pm-cli 2026.9.26 → 2026.9.27

package/plugins/pm-claude/skills/pm-planner/SKILL.md

@@ -1,173 +1,22 @@
 ---
 name: pm-planner
-description: Plan and organize pm CLI work — triage requests, break epics into tasks, prioritize the backlog, and keep the tracker clean. Use when decomposing features, planning sprints, or organizing incoming requests.
+description: Use when triaging requests, organizing a backlog, decomposing an epic, or making a durable pm plan. Search all statuses and build evidence-backed typed relationships.
+license: MIT
 ---
 
 # pm Planner
 
-Use this skill when decomposing features, organizing backlogs, triaging incoming work, or planning multi-item projects.
-
-## Planning Loop
-
-1. **Survey** — `pm_context` then `pm_list` with no filter to see the full active backlog.
-2. **Deduplicate** — `pm_search` before every create to avoid duplicate items.
-3. **Decompose** — break large items into Epic → Feature → Task hierarchy.
-4. **Prioritize** — use `pm_update` to set priority (`0`=critical … `4`=minimal).
-5. **Link parents** — always set `parent` on child items via `pm_update`.
-6. **Sync TUI** — call `TaskCreate` for any item you claim during this session (see Hybrid TUI Sync).
-7. **Validate** — `pm_validate` after batch creates to check consistency.
-
-## Hybrid TUI Sync
-
-pm is the **persistent store**. Claude Code's task panel is the **live session view**.
-
-When you claim a planning item or start active decomposition work:
-```
-TaskCreate:
-  subject: "[pm-xxxx] Plan: <epic/feature title>"
-  description: "Planning pm-xxxx — decomposing into child items"
-  activeForm: "Planning pm-xxxx"
-```
-Save the `taskId`. Call `TaskUpdate(in_progress)` when active.
-Call `TaskUpdate(completed)` when the planning item is closed.
-
-## MCP Call Patterns
-
-### Survey the Backlog
-```json
-{ "tool": "pm_context", "args": { "options": { "depth": "standard", "limit": "20" } } }
-{ "tool": "pm_list", "args": { "options": { "limit": "50" } } }
-```
-
-### Deduplicate Before Creating
-```json
-{ "tool": "pm_search", "args": { "query": "feature keywords", "options": { "limit": "10" } } }
-```
-
-### Create Epic → Feature → Task Hierarchy
-```json
-{
-  "tool": "pm_create",
-  "args": {
-    "options": {
-      "title": "Epic: Authentication system overhaul",
-      "type": "Epic",
-      "status": "open",
-      "priority": "1",
-      "description": "High-level initiative description.",
-      "createMode": "progressive"
-    }
-  }
-}
-```
-Then for each child feature/task, set `parent: "pm-xxxx"` via `pm_update`.
-
-### Prioritize the Backlog
-
-```json
-{ "tool": "pm_list", "args": { "options": { "status": "open", "limit": "30" } } }
-{ "tool": "pm_update", "args": { "id": "pm-xxxx", "options": { "priority": "0" } } }
-```
-
-### Link Parent
-
-```json
-{ "tool": "pm_update", "args": { "id": "pm-child", "options": { "parent": "pm-epic" } } }
-```
-
-### Run Dedupe Audit After Batch Work
-
-```json
-```
-
-### Validate After Batch Creates
-
-```json
-{ "tool": "pm_validate", "args": { "options": { "checkResolution": true } } }
-```
-
-## Item Type Guide
-
-| Type | When to use |
-|------|------------|
-| `Epic` | Large initiative spanning multiple features (weeks/months) |
-| `Feature` | Distinct capability under an epic (days) |
-| `Task` | Atomic unit of implementation work (hours) |
-| `Bug` | Defect with reproduce steps |
-| `Story` | User-facing narrative unit |
-
-## Priority Reference
-
-- `0` = critical — blocking release or other work
-- `1` = high — important, should be done soon
-- `2` = normal — standard priority (default)
-- `3` = low — nice to have
-- `4` = minimal — defer unless time allows
-
-## Acceptance Criteria Best Practice
-
-Write AC as numbered, testable assertions:
-1. Given [precondition], when [action], then [result].
-2. All existing tests pass.
-3. Coverage gate maintained.
-
-Set via `pm_create` with `acceptanceCriteria` field or `pm_update` with `options.acceptanceCriteria`.
-
-## Built-in Plan workflow (`pm_plan` / `pm plan`)
-
-For durable Codex-style ExecPlans, Claude-style Plan Mode, and Cursor-style editable checklists, pm exposes a first-class `Plan` item type plus a `pm plan` command family. Use [Command Reference: Plan Workflow](../../../../docs/COMMANDS.md#plan-workflow) as the canonical lifecycle recipe; this skill keeps only Claude-specific routing notes.
-
-### When to use `pm plan` vs. `pm_create` + tasks
-
-- `pm plan` — when you need a **living, resumable plan** with ordered steps, evidence, decisions, discoveries, validation, and the option to later materialize selected steps as real Tasks. Best for plan-then-execute workflows.
-- `pm_create` (Epic/Feature/Task) — when the work is already decomposed and you just need persistent backlog items.
-
-### Claude MCP routing
-
-Call the same lifecycle through the `pm_plan` MCP tool. Use `harness: "claude-code"` on creation, `subcommand: "show"` with `depth: "brief"` for low-token reads, and `subcommand: "resume"` after compaction or handoff.
-
-### Harness mapping cheatsheet
-
-| Harness signal | pm_plan equivalent |
-|----------------|--------------------|
-| Codex `update_plan` step status | `subcommand=update-step` with `stepStatus` |
-| Claude `TaskCreate` | `subcommand=add-step` |
-| Claude `TaskUpdate(in_progress)` | `subcommand=update-step` with `stepStatus=in_progress` |
-| Cursor edit a plan step | `subcommand=update-step` |
-| Resume after compaction | `subcommand=resume` with `resumeContext` then `subcommand=show --depth deep` |
-| Approve before edits | `subcommand=approve` |
-| Convert checklist into real items | `subcommand=materialize` |
-
-## Safety
-
-- Never pass `path` during real repository tracking.
-- Always `pm_search` before `pm_create`/`pm plan create` — avoid duplicates.
-- Run `pm_validate` after batch changes.
-- Set exactly one step `in_progress` per plan; pass `allowMultipleActive: true` only for explicit parallel branches.
-- Use `pm_plan` `subcommand=resume` after long-running sessions so the next agent can pick up with a deterministic context.
-
-## Progressive Disclosure and Token Discipline
-
-Load the smallest thing that answers the question. Costs are measured.
-
-| Need | Call | Cost |
-|------|------|------|
-| Pick or resume work | `pm_next`, or `pm_context` with `limit: 10` | ~2.1-2.5k tok |
-| Exact flags for one command | `pm_contracts` with `command: "<name>", flagsOnly: true` | ~1-3.4k tok |
-| The whole command surface with per-command ceilings | `pm_contracts` with `summary: true` | ~2.6k tok |
-| An unfamiliar capability family | `pm_run` with `action: "guide", topic: "<topic>", depth: "brief"` | ~0.6-1k tok |
-
-Guide topics are declared at runtime: `pm guide` prints the current index and
-`pm guide <topic> --depth brief` expands one topic. Do not copy the list.
-
-Never load `docs/COMMANDS.md` (~29k tok) or `docs/SDK.md` (~45k tok) whole.
-
-Bound every read in this order: projection (`outputInclude`), then row limit
-(`outputLimit` or `limit`), then `outputBudget`, then `outputCursor` to resume.
-Read the `omission_receipt` before treating a result as complete — a
-budget-truncated read is a claim about the part it withheld, and a truncated
-list must never be summarized as if it were the whole population.
-
-Author identity is detected automatically. Never pass `author` and never set
-`PM_AUTHOR`; the harness, model, effort, role, and topic are probed and recorded
-on every history entry.
+1. Read pm_context and the relevant parent or outcome milestone.
+2. Search all statuses and inspect nearest matches before creating anything.
+3. Use a Plan when ordered steps, decisions, discoveries, and handoff must
+   remain resumable. Use Epic, Feature, Task, Issue, and Decision items for
+   durable backlog work with different ownership.
+4. Give new work a parent, testable acceptance criteria, expected result, and
+   a create-time duplicate-check explanation.
+5. Add typed edges only when evidence supports their meaning. Use dependency
+   edges for ordering and verification edges for proof; do not invent graph
+   depth or fill the graph with related edges.
+6. Validate the resulting tracker and summarize the next actionable items.
+
+Use pm_plan for a living plan and pm_contracts to discover exact options.
+Keep one plan step in progress unless parallel work is explicitly intended.

package/plugins/pm-claude/skills/pm-planner/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "pm Planner"
+  short_description: "Plan and connect project work"
+  default_prompt: "Use pm to deduplicate this request, plan its work, and link it to the project outcome."

package/plugins/pm-claude/skills/pm-release/SKILL.md

@@ -1,108 +1,24 @@
 ---
 name: pm-release
-description: Run pm-cli release-readiness workflows — validation, coverage gates, changelog, GitHub checks — using native MCP tools with linked evidence. Use when preparing releases, publishing, or verifying post-release state.
+description: Use when preparing a pm release, reviewing its gates, publishing, or verifying the released artifact. Keep source, reviewed head, main, tag, registry, and telemetry evidence distinct.
+license: MIT
 ---
 
 # pm Release
 
-Use for release preparation, publication, and post-release verification.
-
-## Release Loop
-
-1. **Find or create** the release pm item (after duplicate check with `pm_search`).
-2. **Claim** it — then call `TaskCreate` to show the release in Claude Code's task panel.
-3. **Run local gates** before tagging:
-   - `pnpm build` — clean build
-   - `node scripts/run-tests.mjs coverage` — full coverage gate
-   - `pm_validate` with all checks
-   - `pm_health` for tracker status
-4. **Tag and push** — let CI run.
-5. **Verify GitHub checks** — `gh run list --limit 5` after push.
-6. **Record evidence** with `pm_comments`.
-7. **Close and release** the pm item, then `TaskUpdate(completed)`.
-
-## Hybrid TUI Sync
-
-### After claiming the release item
-```
-TaskCreate:
-  subject: "[pm-xxxx] Release: <version>"
-  description: "Release gate tracking for pm-xxxx"
-  activeForm: "Running release gates"
-```
-Save the `taskId`. Then `TaskUpdate(in_progress)`.
-
-### After pm_close + pm_release
-```
-TaskUpdate: { taskId: <saved>, status: "completed" }
-```
-
-## MCP Calls
-
-### Pre-Release Validation
-```json
-{ "tool": "pm_validate", "args": { "options": { "checkResolution": true, "checkHistoryDrift": true, "checkFiles": true } } }
-{ "tool": "pm_health", "args": {} }
-{ "tool": "pm_context", "args": { "options": { "depth": "standard" } } }
-```
-
-### Link Release Artifacts
-```json
-{ "tool": "pm_docs", "args": { "id": "pm-xxxx", "options": { "add": ["path=CHANGELOG.md,scope=project,note=release-notes"] } } }
-{ "tool": "pm_files", "args": { "id": "pm-xxxx", "options": { "add": ["path=package.json,scope=project,note=version"] } } }
-```
-
-### Record Evidence
-```json
-{
-  "tool": "pm_comments",
-  "args": {
-    "id": "pm-xxxx",
-    "options": {
-      "add": "Release evidence: build ok. Tests pass. 100% coverage. pm validate ok. GitHub CI green. npm publish ok."
-    }
-  }
-}
-```
-
-## Gate Script Reference
-
-```bash
-pnpm build                                   # TypeScript build
-node scripts/run-tests.mjs coverage          # Full test + coverage
-node scripts/release/run-gates.mjs           # All release gates
-gh run list --limit 5                        # GitHub CI status
-gh run view <run-id>                         # Detailed run status
-```
-
-## Safety
-
-- Never set `path` for real repository tracking — only for sandbox tests.
-- Run coverage gate before any `npm publish` or version tag.
-- Confirm GitHub CI green before closing the release item.
-
-## Progressive Disclosure and Token Discipline
-
-Load the smallest thing that answers the question. Costs are measured.
-
-| Need | Call | Cost |
-|------|------|------|
-| Pick or resume work | `pm_next`, or `pm_context` with `limit: 10` | ~2.1-2.5k tok |
-| Exact flags for one command | `pm_contracts` with `command: "<name>", flagsOnly: true` | ~1-3.4k tok |
-| The whole command surface with per-command ceilings | `pm_contracts` with `summary: true` | ~2.6k tok |
-| An unfamiliar capability family | `pm_run` with `action: "guide", topic: "<topic>", depth: "brief"` | ~0.6-1k tok |
-
-Guide topics are declared at runtime: `pm guide` prints the current index and
-`pm guide <topic> --depth brief` expands one topic. Do not copy the list.
-
-Never load `docs/COMMANDS.md` (~29k tok) or `docs/SDK.md` (~45k tok) whole.
-
-Bound every read in this order: projection (`outputInclude`), then row limit
-(`outputLimit` or `limit`), then `outputBudget`, then `outputCursor` to resume.
-Read the `omission_receipt` before treating a result as complete — a
-budget-truncated read is a claim about the part it withheld, and a truncated
-list must never be summarized as if it were the whole population.
-
-Author identity is detected automatically. Never pass `author` and never set
-`PM_AUTHOR`; the harness, model, effort, role, and topic are probed and recorded
-on every history entry.
+Inspect the release item and current release position before mutation. Search
+for an existing release or incident lineage and reuse it.
+
+1. Link the changed files, changelog, compatibility evidence, and release
+   tests to the item that owns them.
+2. Run the build, full coverage, static quality, security, docs, package,
+   version, and hosted analysis gates required by the repository.
+3. Verify the exact reviewed PR head and resolve actionable feedback before
+   merging. A silent or quota-limited provider is unavailable evidence.
+4. After publishing, verify the main commit, tag, GitHub Release, npm
+   package, installed npm and Bun consumers, Sentry, and telemetry separately.
+5. Record immutable close evidence and release the claim.
+
+Use the repository release pipeline and pm_contracts rather than a remembered
+flag spelling. Never assume a successful API request proves a scheduled
+release or physical telemetry delivery.

package/plugins/pm-claude/skills/pm-release/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "pm Release"
+  short_description: "Verify release gates and artifacts"
+  default_prompt: "Use pm to prepare, gate, and verify this release with distinct source and published evidence."

package/plugins/pm-claude/skills/pm-workflow/SKILL.md

@@ -1,170 +1,39 @@
 ---
 name: pm-workflow
-description: Use pm CLI natively in Claude Code through MCP tools for planning, tracking, mutation, validation, and reporting. Use this skill whenever work should be tracked through pm — before implementing, during implementation, and at close.
+description: Use when starting, resuming, or handing off work in a repository managed by pm. Orient from live context, reuse existing items, and leave evidence for the next agent.
+license: MIT
 ---
 
 # pm Workflow
 
-Use this skill for all pm-tracked work. Prefer native MCP tools over shell `pm` commands.
+Project management is context management. Read the live tracker before describing
+work as open, blocked, or done. Use the bundled pm MCP tools when available;
+use the pm CLI with the same contracts when they are not.
 
-## Tool Preference
+## Orient
 
-**Always use native MCP tools before falling back to Bash `pm` commands:**
+1. Read pm_context with a bounded limit, then pm_list for open and in-progress work.
+2. Search all statuses before creating an item. Inspect the candidate's full
+   metadata, comments, notes, learnings, dependencies, and history.
+3. Follow omission receipts and cursors before making a completeness claim.
+4. Cross-check release, CI, package, or infrastructure claims against the live
+   system that owns them.
 
-| Purpose | Tool |
-|---------|------|
-| Orient / read state | `pm_context`, `pm_search`, `pm_list`, `pm_get` |
-| Create / update | `pm_create`, `pm_update`, `pm_claim`, `pm_release`, `pm_close` |
-| Evidence | `pm_comments`, `pm_notes`, `pm_learnings`, `pm_files`, `pm_docs`, `pm_test` |
-| Verify | `pm_validate`, `pm_health`, `pm_contracts` |
-| Everything else | `pm_run` with an explicit `action` |
+## Work and hand off
 
-## Required Workflow Loop
+Claim only an item being actively edited. Link files, docs, tests, and typed
+relationships that express a real dependency or outcome. Record concise
+evidence, then close with resolution, expected, and actual results when the
+acceptance criteria are met. Release the claim when stopping.
 
-1. **Orient** — run `pm_context`, `pm_search`, and `pm_list` before creating new work.
-2. **Reuse** — claim an existing item when one matches instead of creating a duplicate.
-3. **Claim** — call `pm_claim` before substantial edits.
-4. **Sync TUI** — after claiming, call `TaskCreate` to mirror the item in Claude Code's task panel (see Hybrid TUI Sync below).
-5. **Link evidence** — call `pm_files`, `pm_docs`, `pm_test` as work progresses.
-6. **Add comments** — `pm_comments` for progress notes and verification results.
-7. **Verify** — run `pm_validate` and project tests before closing.
-8. **Close** — `pm_close` with reason, then `pm_release`, then `TaskUpdate(completed)`.
+For handoff, report the item IDs, exact current status, last verified result,
+remaining work, and the next read command. Do not copy the entire tracker.
 
-## Hybrid TUI Sync
+## Host adapters
 
-pm is the **persistent store** (cross-session). Claude Code's task panel is the **live session view**.
+In Claude Code, mirror a claimed item in the task panel when TaskCreate and
+TaskUpdate are available. Keep pm as the durable source of truth. In Codex,
+use the native MCP tools and the same claim, evidence, close, and release loop.
 
-### When claiming or creating an item
-
-Call `TaskCreate` immediately after `pm_claim` (or after `pm_create` if starting fresh):
-
-```
-TaskCreate:
-  subject: "[pm-xxxx] <item title>"
-  description: "Tracking pm item pm-xxxx. AC: <acceptance_criteria if set>"
-  activeForm: "Implementing pm-xxxx"
-```
-
-Save the returned `taskId` — you'll need it for `TaskUpdate` calls later in this session.
-
-### When setting in_progress
-
-Call `TaskUpdate` with `status: "in_progress"` using the `taskId` from above.
-
-### When closing
-
-Call `pm_close` then `pm_release`, then immediately call:
-```
-TaskUpdate:
-  taskId: <saved taskId>
-  status: "completed"
-```
-
-### Blocked items
-
-If a pm item becomes blocked, call `TaskUpdate` with `status: "in_progress"` and add "(BLOCKED)" to the subject so it's visible in the panel.
-
-## Tool Call Shape
-
-Most tools accept `cwd`, `author`, and `options`:
-
-```json
-{
-  "cwd": "/path/to/repo",
-  "options": { "limit": "10" }
-}
-```
-
-`pm_run` requires an `action` field:
-
-```json
-{
-  "action": "calendar",
-  "options": { "view": "week", "format": "markdown" }
-}
-```
-
-## Common Patterns
-
-**Get active work snapshot:**
-```json
-{ "tool": "pm_context", "args": { "options": { "limit": "10" } } }
-```
-
-**Search for existing work:**
-```json
-{ "tool": "pm_search", "args": { "query": "your keywords", "options": { "limit": "10" } } }
-```
-
-**Create a new item:**
-```json
-{
-  "tool": "pm_create",
-  "args": {
-    "options": {
-      "title": "Item title",
-      "description": "What this item tracks.",
-      "type": "Task",
-      "status": "open",
-      "priority": "1",
-      "createMode": "progressive"
-    }
-  }
-}
-```
-
-**Link changed files:**
-```json
-{
-  "tool": "pm_files",
-  "args": {
-    "id": "pm-xxxx",
-    "options": { "add": ["path=src/file.ts,scope=project,note=implementation"] }
-  }
-}
-```
-
-**Close with evidence:**
-```json
-{
-  "tool": "pm_close",
-  "args": {
-    "id": "pm-xxxx",
-    "reason": "All acceptance criteria met. Tests pass."
-  }
-}
-```
-
-## Priority Reference
-
-- `0` = critical, `1` = high, `2` = normal, `3` = low, `4` = minimal
-
-## Safety
-
-Do not pass `path` during real repository tracking. Only pass `path` for sandbox/test runs.
-
-## Progressive Disclosure and Token Discipline
-
-Load the smallest thing that answers the question. Costs are measured.
-
-| Need | Call | Cost |
-|------|------|------|
-| Pick or resume work | `pm_next`, or `pm_context` with `limit: 10` | ~2.1-2.5k tok |
-| Exact flags for one command | `pm_contracts` with `command: "<name>", flagsOnly: true` | ~1-3.4k tok |
-| The whole command surface with per-command ceilings | `pm_contracts` with `summary: true` | ~2.6k tok |
-| An unfamiliar capability family | `pm_run` with `action: "guide", topic: "<topic>", depth: "brief"` | ~0.6-1k tok |
-
-Guide topics are declared at runtime: `pm guide` prints the current index and
-`pm guide <topic> --depth brief` expands one topic. Do not copy the list.
-
-Never load `docs/COMMANDS.md` (~29k tok) or `docs/SDK.md` (~45k tok) whole.
-
-Bound every read in this order: projection (`outputInclude`), then row limit
-(`outputLimit` or `limit`), then `outputBudget`, then `outputCursor` to resume.
-Read the `omission_receipt` before treating a result as complete — a
-budget-truncated read is a claim about the part it withheld, and a truncated
-list must never be summarized as if it were the whole population.
-
-Author identity is detected automatically. Never pass `author` and never set
-`PM_AUTHOR`; the harness, model, effort, role, and topic are probed and recorded
-on every history entry.
+Use pm_contracts for exact active flags and pm_run for actions without a narrow
+tool. Never set a static author; let the host identity be detected.

package/plugins/pm-claude/skills/pm-workflow/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "pm Workflow"
+  short_description: "Orient and hand off tracked project work"
+  default_prompt: "Use pm to read live context, select existing work, and leave a concise evidence-backed handoff."

package/plugins/pm-codex/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pm-codex",
-  "version": "2026.9.26",
+  "version": "2026.9.27",
   "description": "Native Codex integration for pm-cli with bundled MCP tools, skills, commands, and agent workflows.",
   "author": {
     "name": "unbrained",

package/plugins/pm-codex/README.md

@@ -3,10 +3,18 @@
 This plugin packages pm-cli for Codex with:
 
 - a native stdio MCP server (`pm-mcp`) backed by pm command modules, not shell `pm` invocations
-- skills for developer, user, extension, SDK, release, and audit workflows
+- five portable skills for orientation, implementation, planning, review, and release
 - command prompts for common planning and verification loops
 - repo marketplace metadata for one-step local installation in Codex
 
+The root `plugin.json` and typed `mcp.json` are the portable package entrypoints.
+The `.codex-plugin/plugin.json` and `.mcp.json` files support existing hosts.
+Both MCP configurations start the same pinned launcher. The five shared skills are generated with the Claude package from
+`templates/agent-skills/`. The older `pm-native` and `pm-auditor` entrypoints
+are generated compatibility skills that route to `pm-workflow`, `pm-planner`,
+and `pm-audit`. `node scripts/gen-agent-plugin-skills.mjs --check` guards all
+published copies against drift.
+
 ## Install
 
 From this repository:
@@ -24,7 +32,7 @@ The launcher uses the local repo build when present. In a copied plugin cache it
 Prefer the narrow tools when they match the task: `pm_context`, `pm_search`, `pm_list`, `pm_get`, `pm_create`, `pm_copy`, `pm_focus`, `pm_update`, `pm_append`, `pm_claim`, `pm_release`, `pm_close`, `pm_comments`, `pm_files`, `pm_docs`, `pm_notes`, `pm_learnings`, `pm_deps`, `pm_test`, `pm_validate`, `pm_health`, `pm_contracts`, `pm_schema`, `pm_config`, and `pm_plan`.
 
 
-`pm_plan` exposes Codex-style ExecPlans as a first-class `Plan` item type with ordered steps, evidence, decisions, discoveries, validation, and materialization. See the `pm-native` skill for the full Plan workflow recipe.
+`pm_plan` exposes Codex-style ExecPlans as a first-class `Plan` item type with ordered steps, evidence, decisions, discoveries, validation, and materialization. See the `pm-planner` skill for the planning workflow.
 For `init` automation, pass `options.agentGuidance` (`ask|add|skip|status`) when you need deterministic AGENTS/CLAUDE guidance behavior in non-interactive runs.
 
 ## Safety

package/plugins/pm-codex/mcp.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "mcpServers": {
+    "pm-mcp": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["./scripts/pm-mcp-server.mjs"],
+      "cwd": "./"
+    }
+  }
+}

package/plugins/pm-codex/package.json

@@ -2,8 +2,8 @@
   "name": "pm-codex-runtime",
   "private": true,
   "type": "module",
-  "version": "2026.9.26",
+  "version": "2026.9.27",
   "dependencies": {
-    "@unbrained/pm-cli": "2026.9.26"
+    "@unbrained/pm-cli": "2026.9.27"
   }
 }

package/plugins/pm-codex/plugin.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "pm-codex",
+  "version": "2026.9.27",
+  "description": "Repository-native project context workflows and a version-pinned pm MCP server for Codex.",
+  "author": {
+    "name": "unbrained",
+    "url": "https://github.com/unbraind/pm-cli"
+  },
+  "homepage": "https://github.com/unbraind/pm-cli/tree/main/plugins/pm-codex",
+  "repository": "https://github.com/unbraind/pm-cli",
+  "license": "MIT",
+  "keywords": [
+    "pm-cli",
+    "codex",
+    "mcp",
+    "project-management",
+    "agents"
+  ],
+  "extensions": {
+    "com.openai": {
+      "interface": {
+        "displayName": "pm CLI",
+        "shortDescription": "Track project context with pm",
+        "longDescription": "Orient, plan, implement, verify, and hand off work with repository-native pm records and a bundled MCP server.",
+        "developerName": "unbrained",
+        "category": "Coding",
+        "capabilities": [
+          "Interactive",
+          "Read",
+          "Write"
+        ],
+        "websiteURL": "https://github.com/unbraind/pm-cli",
+        "privacyPolicyURL": "https://github.com/unbraind/pm-cli/blob/main/SECURITY.md",
+        "termsOfServiceURL": "https://github.com/unbraind/pm-cli/blob/main/LICENSE",
+        "defaultPrompt": [
+          "Use pm to orient, track, verify, and hand off this repository task."
+        ],
+        "composerIcon": "./assets/pm-cli-small.svg",
+        "logo": "./assets/pm-cli-small.svg",
+        "brandColor": "#2563EB"
+      }
+    }
+  }
+}