@unbrained/pm-cli 2026.5.6 → 2026.5.11

package/.agents/skills/pm-user/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: pm-user
+description: Guides user- and operator-facing pm-cli workflows for planning, triage, prioritization, and task lifecycle management with minimal token usage. Use when routing requests into pm items without implementing code changes.
+license: MIT
+compatibility: Works in terminal-based agent harnesses that execute pm CLI commands.
+metadata:
+  owner: unbrained
+  domain: pm-cli
+  scope: operator-workflow
+---
+
+# pm User Skill
+
+Use this skill for planning and coordination work where the main output is clean tracker state.
+
+## Quick Start
+
+```bash
+pm guide quickstart
+pm context --limit 10
+pm search "<request keywords>" --limit 10
+pm list-open --limit 20
+pm list-in-progress --limit 20
+```
+
+## Primary Use Cases
+
+- Intake a new request and decide whether an item already exists.
+- Create parent lineage (`Epic` -> `Feature` -> `Task`) for net-new scope.
+- Prioritize and schedule work with deterministic metadata.
+- Maintain clear ownership and handoff notes.
+
+## Workflow Prompts
+
+### Prompt: New Request Triage
+
+`Triage this request using pm only. Reuse an existing item if relevant; otherwise create canonical parent lineage and a scoped child item with duplicate-check evidence.`
+
+### Prompt: Prioritization Sweep
+
+`Review open and in-progress items, normalize priority/status metadata, and leave append-only notes explaining why any prioritization changed.`
+
+### Prompt: Handoff Preparation
+
+`Prepare handoff for <ID>: summarize state in comments, ensure linked files/tests/docs are complete, and release claim when ready.`
+
+## Deterministic Metadata Commands
+
+```bash
+pm update <ID> --description "..." --ac "..." --estimate 60
+pm update <ID> --deadline +2d --priority 1 --status open
+pm comments <ID> "Decision log: <why this status/priority>"
+pm notes <ID> --add "Context for next owner."
+```
+
+## Progressive Disclosure References
+
+- [Triage and planning workflows](references/WORKFLOWS.md)
+- [Operator prompt templates](references/PROMPTS.md)

package/.agents/skills/pm-user/references/PROMPTS.md

@@ -0,0 +1,17 @@
+# Operator Prompt Templates
+
+## Triage
+
+`Find the canonical pm item for this request. Show duplicate-check commands, then either reuse and update the item or create parent lineage + child item with explicit rationale.`
+
+## Schedule
+
+`Apply deterministic scheduling metadata (status, priority, estimate, deadline) to <ID> and leave a comment explaining the prioritization decision.`
+
+## Handoff
+
+`Prepare <ID> for handoff: append current state, blockers, and next actions; release the claim when handoff is complete.`
+
+## Closure Readiness
+
+`Validate whether <ID> is close-ready by checking acceptance criteria, linked files/tests/docs, and latest verification evidence.`

package/.agents/skills/pm-user/references/WORKFLOWS.md

@@ -0,0 +1,35 @@
+# User and Operator Workflows
+
+## Intake Workflow
+
+1. Query current context:
+
+```bash
+pm context --limit 10
+pm search "<keywords>" --limit 10
+pm list-open --limit 20
+pm list-in-progress --limit 20
+```
+
+2. If existing item matches, reuse and update it.
+3. If no match exists, create parent lineage then child item.
+4. Add duplicate-check evidence in comments at creation time.
+
+## Claim and Ownership Workflow
+
+```bash
+pm claim <ID>
+pm update <ID> --status in_progress --message "Start work"
+pm comments <ID> "Owner update: <state>"
+pm release <ID>
+```
+
+## Audit-Friendly Collaboration
+
+For non-owner append-only collaboration:
+
+```bash
+pm comments <ID> --add "audit comment" --allow-audit-comment
+pm notes <ID> --add "audit note" --allow-audit-comment
+pm update <ID> --dep "id=<id>,kind=related,author=<author>,created_at=now" --allow-audit-dep-update
+```

package/.claude-plugin/marketplace.json

@@ -0,0 +1,38 @@
+{
+  "name": "pm",
+  "owner": {
+    "name": "unbrained",
+    "url": "https://github.com/unbraind/pm-cli"
+  },
+  "metadata": {
+    "description": "Official marketplace for pm CLI — native git-based project management for Claude Code and AI coding agents.",
+    "version": "1.3.0"
+  },
+  "plugins": [
+    {
+      "name": "pm-cli",
+      "source": "./plugins/pm-cli-claude",
+      "description": "Native pm CLI integration for Claude Code — 18 MCP tools, 5 workflow skills, 14 slash commands, 3 subagents, hybrid TUI task tracking, session context injection, and coordination subagents for git-based project management without leaving Claude Code.",
+      "version": "1.3.0",
+      "author": {
+        "name": "unbrained",
+        "url": "https://github.com/unbraind/pm-cli"
+      },
+      "homepage": "https://github.com/unbraind/pm-cli",
+      "repository": "https://github.com/unbraind/pm-cli",
+      "license": "MIT",
+      "keywords": [
+        "pm-cli",
+        "project-management",
+        "mcp",
+        "tasks",
+        "agents",
+        "workflows",
+        "git-native",
+        "task-tracker",
+        "ai"
+      ],
+      "category": "productivity"
+    }
+  ]
+}

package/.pi/README.md

@@ -0,0 +1,35 @@
+# pm CLI Pi Package
+
+This directory is the installable Pi package payload for `@unbrained/pm-cli`.
+
+Install from npm after publish:
+
+```bash
+pi install npm:@unbrained/pm-cli
+```
+
+For local development from a checkout:
+
+```bash
+pnpm build
+pi install -l .
+# or one-shot
+pi -e .
+```
+
+Resources exposed by `package.json`:
+
+- `.pi/extensions/pm-cli/index.js` — native Pi extension registering the `pm` tool, custom TUI renderers, autocomplete, status/widget UI, and slash commands.
+- `.pi/skills/*` — Pi skills for native pm workflows and release validation.
+- `.pi/prompts/*` — prompt templates for pm-tracked work.
+- `.pi/agents/*` and `.pi/chains/*` — optional pi-subagents setup for pm triage and verification workflows in repositories that use subagents.
+
+The extension imports the built package from `dist/`, so run `pnpm build` before local install or before publishing.
+
+Interactive commands:
+
+- `/pm-board [limit]` — dashboard panel for active pm context.
+- `/pm-item <id>` and `/pm-history <id>` — item details/history panels.
+- `/pm-actions` and `/pm-workflows` — native action list and workflow reminders.
+
+The `pm` tool should be preferred over shelling out to `pm`; it calls pm command modules directly in-process.

package/.pi/agents/pm-triage-agent.md

@@ -0,0 +1,19 @@
+---
+name: pm-triage-agent
+description: Native pm triage agent for Pi. Use to inspect context, search for duplicates, select or create tracker lineage, and hand off an implementation-ready pm item without shelling out to the pm CLI.
+tools: pm,read,grep,find,ls
+skills: pm-native,pm-user
+---
+
+# pm Triage Agent
+
+Use the native `pm` tool only for pm operations.
+
+Workflow:
+1. Run `pm` action `context` with `limit: 10`.
+2. Run `pm` action `search` with the user's key terms.
+3. Run `pm` actions `list-open` and `list-in-progress`.
+4. If an item exists, recommend reusing it and claim/start only when asked.
+5. If no item exists, identify parent lineage and propose a create payload with duplicate-check evidence.
+
+Output a concise handoff with item id, rationale, recommended next action, and exact native `pm` tool calls.

package/.pi/agents/pm-verification-agent.md

@@ -0,0 +1,21 @@
+---
+name: pm-verification-agent
+description: Native pm verification agent for Pi. Use to inspect linked files/tests/docs, run sandbox-safe linked tests through pm, validate close readiness, and produce closure evidence.
+tools: pm,bash,read,grep,find,ls
+skills: pm-native,pm-release
+---
+
+# pm Verification Agent
+
+Use the native `pm` tool for pm mutations and linked-test orchestration.
+Use bash only for non-pm project commands such as `pnpm build` or `gh run list`.
+
+Workflow:
+1. Read the target item with `pm` action `get`.
+2. Check linked files/docs/tests and acceptance criteria.
+3. Run `pm` action `test` with `run: true` or equivalent linked-test options when available.
+4. Run targeted project validation requested by the parent.
+5. Add a `pm` comment summarizing evidence.
+6. Recommend close/release only if verification is clean.
+
+Output failures with exact commands, item id, and next remediation step.

package/.pi/chains/pm-native-delivery.chain.md

@@ -0,0 +1,11 @@
+---
+name: pm-native-delivery
+description: Triage, implement, and verify a pm-tracked change using native pm operations in Pi.
+steps:
+  - agent: pm-triage-agent
+    task: "Triage the requested work and identify the canonical pm item for: {task}"
+  - agent: worker
+    task: "Implement the approved scope from the triage handoff. Use native pm for tracker operations, link changed files/tests/docs, and keep edits scoped. Original request: {task}\n\nTriage handoff:\n{previous}"
+  - agent: pm-verification-agent
+    task: "Verify the implementation and produce pm closure evidence. Original request: {task}\n\nImplementation handoff:\n{previous}"
+---

package/.pi/extensions/pm-cli/index.js

@@ -0,0 +1,387 @@
+import { PM_PI_TOOL_PARAMETERS_SCHEMA, PM_TOOL_ACTIONS } from "../../../dist/sdk/cli-contracts.js";
+import { runNativePmAction } from "../../../dist/pi/native.js";
+
+const PM_PI_TOOL_PARAMETERS_SCHEMA_COMPAT = {
+  ...PM_PI_TOOL_PARAMETERS_SCHEMA,
+  additionalProperties: true,
+};
+
+function contentText(result) {
+  if (typeof result === "string") return result;
+  return JSON.stringify(result, null, 2);
+}
+
+function firstText(result) {
+  const entry = Array.isArray(result?.content) ? result.content.find((part) => part?.type === "text") : undefined;
+  return typeof entry?.text === "string" ? entry.text : "";
+}
+
+function truncatePlain(value, width) {
+  const text = String(value ?? "");
+  let visible = 0;
+  let output = "";
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "\u001b") {
+      const match = text.slice(index).match(/^\u001b\[[0-9;?]*[ -/]*[@-~]/);
+      if (match) {
+        output += match[0];
+        index += match[0].length - 1;
+        continue;
+      }
+    }
+    if (visible >= Math.max(0, width - 1)) return `${output}…`;
+    output += char;
+    visible += 1;
+  }
+  return output;
+}
+
+function statusIcon(status, theme) {
+  const normalized = String(status ?? "").toLowerCase();
+  if (normalized === "closed") return theme.fg("success", "✓");
+  if (normalized === "blocked") return theme.fg("warning", "!");
+  if (normalized === "in_progress") return theme.fg("accent", "▶");
+  if (normalized === "canceled") return theme.fg("dim", "×");
+  return theme.fg("dim", "○");
+}
+
+class PmPanelComponent {
+  constructor(title, lines, theme, onClose) {
+    this.title = title;
+    this.lines = lines;
+    this.theme = theme;
+    this.onClose = onClose;
+    this.cachedWidth = undefined;
+    this.cachedLines = undefined;
+  }
+
+  handleInput(data) {
+    if (data === "\u001b" || data === "\u0003" || data === "q" || data === "Q") {
+      this.onClose?.();
+    }
+  }
+
+  render(width) {
+    if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+    const theme = this.theme;
+    const usable = Math.max(20, width);
+    const border = theme.fg("borderMuted", "─".repeat(Math.max(0, usable)));
+    const rendered = [
+      border,
+      truncatePlain(`${theme.fg("accent", theme.bold(` pm ${this.title} `))}${theme.fg("dim", "q/esc closes")}`, usable),
+      border,
+      ...this.lines.map((line) => truncatePlain(line, usable)),
+      border,
+    ];
+    this.cachedWidth = width;
+    this.cachedLines = rendered;
+    return rendered;
+  }
+
+  invalidate() {
+    this.cachedWidth = undefined;
+    this.cachedLines = undefined;
+  }
+}
+
+function makeItemLine(item, theme) {
+  const id = theme.fg("accent", item.id ?? "unknown");
+  const type = theme.fg("muted", item.type ?? "Item");
+  const status = statusIcon(item.status, theme);
+  const priority = item.priority === undefined ? "" : theme.fg("dim", ` p${item.priority}`);
+  const owner = item.assignee ? theme.fg("dim", ` @${item.assignee}`) : "";
+  return `${status} ${id} ${type}${priority}${owner} ${item.title ?? "(untitled)"}`;
+}
+
+function contextLines(result, theme) {
+  const lines = [];
+  const summary = result?.summary;
+  if (summary) {
+    lines.push(
+      `${theme.fg("muted", "summary")} active=${summary.active_items ?? 0} open=${summary.open ?? 0} in_progress=${summary.in_progress ?? 0} blocked=${summary.blocked ?? 0}`,
+    );
+  }
+  const high = Array.isArray(result?.high_level) ? result.high_level : [];
+  const low = Array.isArray(result?.low_level) ? result.low_level : [];
+  if (high.length > 0) {
+    lines.push("", theme.fg("accent", "High level"));
+    lines.push(...high.map((item) => makeItemLine(item, theme)));
+  }
+  if (low.length > 0) {
+    lines.push("", theme.fg("accent", "Tasks"));
+    lines.push(...low.map((item) => makeItemLine(item, theme)));
+  }
+  if (lines.length === 0) lines.push(theme.fg("dim", "No pm context items found."));
+  return lines;
+}
+
+function listLines(result, theme) {
+  const items = Array.isArray(result?.items) ? result.items : Array.isArray(result) ? result : [];
+  if (items.length === 0) return [theme.fg("dim", "No items.")];
+  return items.map((entry) => makeItemLine(entry.item ?? entry, theme));
+}
+
+function historyLines(result, theme) {
+  const entries = Array.isArray(result?.history) ? result.history : Array.isArray(result?.entries) ? result.entries : [];
+  if (entries.length === 0) return [theme.fg("dim", "No history entries.")];
+  return entries.slice(0, 30).map((entry) => {
+    const at = entry.timestamp ?? entry.created_at ?? "";
+    const op = entry.op ?? entry.operation ?? entry.type ?? "history";
+    const author = entry.author ? ` ${theme.fg("dim", `@${entry.author}`)}` : "";
+    const message = entry.message ?? entry.text ?? entry.reason ?? "";
+    return `${theme.fg("muted", at)} ${theme.fg("accent", op)}${author} ${message}`;
+  });
+}
+
+function getItemLines(result, theme) {
+  const item = result?.item ?? result;
+  if (!item || typeof item !== "object") return [theme.fg("dim", "No item details.")];
+  const lines = [makeItemLine(item, theme)];
+  if (item.description) lines.push("", item.description);
+  if (item.acceptance_criteria) lines.push("", `${theme.fg("accent", "Acceptance")}: ${item.acceptance_criteria}`);
+  if (Array.isArray(item.comments) && item.comments.length > 0) {
+    lines.push("", theme.fg("accent", "Recent comments"));
+    for (const comment of item.comments.slice(-5)) {
+      lines.push(`${theme.fg("muted", comment.created_at ?? "")} ${comment.author ?? "unknown"}: ${comment.text ?? ""}`);
+    }
+  }
+  return lines;
+}
+
+function resultLines(details, theme) {
+  const action = details?.action;
+  const result = details?.result;
+  if (action === "context") return contextLines(result, theme);
+  if (String(action ?? "").startsWith("list") || action === "search") return listLines(result, theme);
+  if (action === "history" || action === "activity") return historyLines(result, theme);
+  if (action === "get") return getItemLines(result, theme);
+  const raw = contentText(result);
+  return raw.split("\n").slice(0, 40);
+}
+
+function errorDetails(error) {
+  return {
+    message: error instanceof Error ? error.message : String(error),
+    code: typeof error?.exitCode === "number" ? error.exitCode : 1,
+  };
+}
+
+function uiTheme(ctx) {
+  return ctx.ui?.theme ?? {
+    fg: (_name, text) => String(text),
+    bold: (text) => String(text),
+  };
+}
+
+async function showPanel(ctx, title, lines, overlay = true) {
+  if (!ctx.hasUI || typeof ctx.ui?.custom !== "function") {
+    ctx.ui.notify(lines.join("\n"), "info");
+    return;
+  }
+  await ctx.ui.custom((_tui, theme, _keybindings, done) => new PmPanelComponent(title, lines, theme, () => done(undefined)), {
+    overlay,
+    overlayOptions: { anchor: "right-center", width: "70%", minWidth: 60, maxHeight: "85%", margin: 1 },
+  });
+}
+
+async function runForCommand(ctx, params) {
+  return runNativePmAction({ cwd: ctx.cwd, ...params });
+}
+
+export function createPmToolDefinition() {
+  return {
+    name: "pm",
+    label: "pm",
+    description:
+      "Use pm natively from Pi without shelling out to the pm CLI. Supports pm project context, search, lifecycle mutations, links, tests, validation, extension management, templates, calendar, guide, audit, beads, todos, and managed test-run workflows.",
+    promptSnippet: "Run native pm project-management operations without bash or the pm CLI.",
+    promptGuidelines: [
+      "Use the pm tool instead of bash pm commands for project-management operations when this tool is available.",
+      "Use pm action=context/list-open/list-in-progress/search before creating new work items.",
+      "For mutations, set author explicitly and link changed files/tests/docs through pm actions before closing work.",
+      "Use pm action=contracts or guide when you need exact action/flag support instead of guessing parameters.",
+    ],
+    parameters: PM_PI_TOOL_PARAMETERS_SCHEMA_COMPAT,
+    async execute(_toolCallId, params, _signal, onUpdate, ctx) {
+      onUpdate?.({ content: [{ type: "text", text: `Running native pm action: ${params.action}` }] });
+      try {
+        const result = await runNativePmAction({ cwd: ctx?.cwd, ...params });
+        return {
+          content: [{ type: "text", text: contentText(result) }],
+          details: { ok: true, action: params.action, result, native: true },
+        };
+      } catch (error) {
+        const details = errorDetails(error);
+        throw new Error(`pm ${params.action ?? "action"} failed: ${details.message}`);
+      }
+    },
+    renderCall(args, theme) {
+      const action = args?.action ?? "action";
+      const target = args?.id ?? args?.query ?? args?.target ?? args?.title ?? "";
+      return new PmPanelComponent("tool", [`${theme.fg("toolTitle", theme.bold("pm"))} ${theme.fg("accent", action)} ${theme.fg("dim", target)}`], theme);
+    },
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) return new PmPanelComponent("running", [theme.fg("warning", "Running…")], theme);
+      const details = result?.details;
+      if (!details?.ok) return new PmPanelComponent("result", [firstText(result) || contentText(result)], theme);
+      const lines = resultLines(details, theme);
+      const visible = expanded ? lines : lines.slice(0, 12);
+      if (!expanded && lines.length > visible.length) visible.push(theme.fg("dim", `… ${lines.length - visible.length} more; expand tool output for details`));
+      return new PmPanelComponent(String(details.action ?? "result"), visible, theme);
+    },
+  };
+}
+
+export function registerPmCommands(pi) {
+  pi.registerCommand("pm-context", {
+    description: "Show pm context snapshot using the native pm integration",
+    handler: async (args, ctx) => {
+      const limit = args?.trim() || "10";
+      const result = await runForCommand(ctx, { action: "context", limit, json: true });
+      await showPanel(ctx, "context", contextLines(result, uiTheme(ctx)));
+    },
+  });
+
+  pi.registerCommand("pm-board", {
+    description: "Open an interactive pm dashboard panel: /pm-board [limit]",
+    handler: async (args, ctx) => {
+      const limit = args?.trim() || "12";
+      const result = await runForCommand(ctx, { action: "context", limit, depth: "standard", json: true });
+      await showPanel(ctx, "board", contextLines(result, uiTheme(ctx)));
+    },
+  });
+
+  pi.registerCommand("pm-item", {
+    description: "Open pm item details: /pm-item <id>",
+    getArgumentCompletions: () => null,
+    handler: async (args, ctx) => {
+      const id = args?.trim();
+      if (!id) return ctx.ui.notify("Usage: /pm-item <id>", "error");
+      const result = await runForCommand(ctx, { action: "get", id, json: true });
+      await showPanel(ctx, id, getItemLines(result, uiTheme(ctx)));
+    },
+  });
+
+  pi.registerCommand("pm-history", {
+    description: "Open pm item history/activity panel: /pm-history <id>",
+    handler: async (args, ctx) => {
+      const id = args?.trim();
+      if (!id) return ctx.ui.notify("Usage: /pm-history <id>", "error");
+      const result = await runForCommand(ctx, { action: "history", id, limit: 30, json: true });
+      await showPanel(ctx, `${id} history`, historyLines(result, uiTheme(ctx)));
+    },
+  });
+
+  pi.registerCommand("pm-start", {
+    description: "Start/claim a pm item: /pm-start <id>",
+    handler: async (args, ctx) => {
+      const id = args?.trim();
+      if (!id) return ctx.ui.notify("Usage: /pm-start <id>", "error");
+      const result = await runForCommand(ctx, { action: "start-task", id, author: "pi-agent" });
+      ctx.ui.notify(contentText(result), "success");
+    },
+  });
+
+  pi.registerCommand("pm-close", {
+    description: "Close and release a pm item: /pm-close <id> <reason>",
+    handler: async (args, ctx) => {
+      const [id, ...reasonParts] = (args ?? "").trim().split(/\s+/);
+      const reason = reasonParts.join(" ");
+      if (!id || !reason) return ctx.ui.notify("Usage: /pm-close <id> <reason>", "error");
+      const result = await runForCommand(ctx, { action: "close-task", id, text: reason, author: "pi-agent", validateClose: "warn" });
+      ctx.ui.notify(contentText(result), "success");
+    },
+  });
+
+  pi.registerCommand("pm-actions", {
+    description: "List native pm tool actions",
+    handler: async (_args, ctx) => {
+      await showPanel(ctx, "actions", PM_TOOL_ACTIONS.map((action) => `• ${action}`));
+    },
+  });
+
+  pi.registerCommand("pm-workflows", {
+    description: "Show native pm workflow shortcuts and bundled Pi resources",
+    handler: async (_args, ctx) => {
+      await showPanel(ctx, "workflows", [
+        "1. /pm-board to inspect focus/context items.",
+        "2. Use the pm tool action=search/list-open/list-in-progress before creating work.",
+        "3. /pm-start <id> or pm action=start-task to claim and move in_progress.",
+        "4. Use pm action=files/docs/test to link implementation evidence.",
+        "5. Run pm action=test/validate and close with pm action=close-task.",
+        "Bundled resources: pm-native and pm-release skills, pm-workflow prompt, pm subagent templates in .pi/agents.",
+      ]);
+    },
+  });
+}
+
+function patchPmToolParametersInProviderPayload(payload) {
+  if (!payload || typeof payload !== "object" || !Array.isArray(payload.tools)) {
+    return undefined;
+  }
+  let changed = false;
+  const tools = payload.tools.map((tool) => {
+    if (!tool || typeof tool !== "object") {
+      return tool;
+    }
+    if (tool.name === "pm") {
+      const parameters = tool.parameters;
+      if (!parameters || parameters.type !== "object") {
+        changed = true;
+        return { ...tool, parameters: PM_PI_TOOL_PARAMETERS_SCHEMA_COMPAT };
+      }
+    }
+    if (tool.function?.name === "pm") {
+      const parameters = tool.function.parameters;
+      if (!parameters || parameters.type !== "object") {
+        changed = true;
+        return { ...tool, function: { ...tool.function, parameters: PM_PI_TOOL_PARAMETERS_SCHEMA_COMPAT } };
+      }
+    }
+    return tool;
+  });
+  return changed ? { ...payload, tools } : undefined;
+}
+
+function installPmAutocomplete(ctx) {
+  if (typeof ctx.ui?.addAutocompleteProvider !== "function") return;
+  ctx.ui.addAutocompleteProvider((current) => ({
+    async getSuggestions(lines, line, col, options) {
+      const beforeCursor = (lines[line] ?? "").slice(0, col);
+      const match = beforeCursor.match(/(?:^|[\s(])@(pm-[a-z0-9-]*)$/i);
+      if (!match) return current.getSuggestions(lines, line, col, options);
+      try {
+        const result = await runNativePmAction({ cwd: ctx.cwd, action: "list-open", limit: 20, json: true });
+        const items = Array.isArray(result?.items) ? result.items : [];
+        return {
+          prefix: `@${match[1] ?? ""}`,
+          items: items.map((item) => ({ value: `@${item.id}`, label: item.id, description: item.title ?? item.status ?? "pm item" })),
+        };
+      } catch {
+        return current.getSuggestions(lines, line, col, options);
+      }
+    },
+    applyCompletion(lines, line, col, item, prefix) {
+      return current.applyCompletion(lines, line, col, item, prefix);
+    },
+    shouldTriggerFileCompletion(lines, line, col) {
+      return current.shouldTriggerFileCompletion?.(lines, line, col) ?? true;
+    },
+  }));
+}
+
+export default function pmCliPiExtension(pi) {
+  pi.registerTool(createPmToolDefinition());
+  pi.on("before_provider_request", (event) => patchPmToolParametersInProviderPayload(event.payload));
+  registerPmCommands(pi);
+  pi.on("session_start", async (_event, ctx) => {
+    ctx.ui.setStatus?.("pm", ctx.ui.theme?.fg ? ctx.ui.theme.fg("accent", "pm native") : "pm native");
+    ctx.ui.setWidget?.("pm-native", ["pm native ready • /pm-board • /pm-actions • @pm-id autocomplete"], { placement: "belowEditor" });
+    installPmAutocomplete(ctx);
+  });
+  pi.on("session_shutdown", async (_event, ctx) => {
+    ctx.ui.setStatus?.("pm", undefined);
+    ctx.ui.setWidget?.("pm-native", undefined);
+  });
+}

package/.pi/prompts/pm-workflow.md

@@ -0,0 +1,5 @@
+---
+description: Start a pm-tracked implementation workflow using the native pm Pi tool.
+---
+
+Use the native `pm` tool to orient, find an existing relevant item, claim it, link evidence, verify, and close/release only after acceptance criteria are met. Do not run `pm` via bash when the native tool is available.