agentplane 0.4.2 → 0.4.4

package/README.md

@@ -1,22 +1,21 @@
-# AgentPlane
+# AgentPlane CLI
+
+**The open-source audit layer for coding agents.**
+
+`agentplane` is a local CLI that turns Claude Code, Codex, Cursor, Aider, and similar coding-agent
+work into reviewable, reversible Git artifacts.
 
 [![npm](https://img.shields.io/npm/v/agentplane.svg)](https://www.npmjs.com/package/agentplane)
 [![Downloads](https://img.shields.io/npm/dm/agentplane.svg)](https://www.npmjs.com/package/agentplane)
+[![GitHub stars](https://img.shields.io/github/stars/basilisk-labs/agentplane?style=flat)](https://github.com/basilisk-labs/agentplane/stargazers)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/basilisk-labs/agentplane/blob/main/LICENSE)
 [![Node.js 20+](https://img.shields.io/badge/Node.js-20%2B-3c873a.svg)](https://agentplane.org/docs/user/prerequisites)
 
-**Use coding agents without losing Git discipline.**
-
-`agentplane` is a local CLI that makes Claude Code, Codex, Cursor, Aider, and similar coding-agent
-work auditable inside your Git repository:
-
-```text
-task -> plan -> approve -> implement -> verify -> finish
-```
-
-No hosted runtime. No hidden control plane. Everything stays in your repo.
+[![SLSA v1 provenance](https://img.shields.io/badge/SLSA-v1-success)](https://registry.npmjs.org/-/npm/v1/attestations/agentplane@latest)
+[![Trusted publisher](https://img.shields.io/badge/npm-trusted%20publisher-blue)](https://docs.npmjs.com/generating-provenance-statements)
+[![Recipes signed: Ed25519](https://img.shields.io/badge/recipes-Ed25519%20signed-111827)](https://agentplane.org/docs/recipes)
 
-## Install
+## Install in 30 seconds
 
 ```bash
 npm i -g agentplane
@@ -24,141 +23,106 @@ agentplane init
 agentplane quickstart
 ```
 
-Requirements:
-
-- Node.js 20+
-- Git repository
-- Local terminal
-
-Prefer not to install globally:
+Prefer no global install:
 
 ```bash
 npx agentplane init
 npx agentplane quickstart
 ```
 
-## Why it exists
+Requirements: Node.js 20+, Git, and a local terminal.
 
-Coding agents can change files. Teams still need to know what happened:
+Experimental agent shorthand:
 
-- What task was the agent solving?
-- What plan was approved?
-- What changed in the repository?
-- What was verified?
-- Why was the task considered finished?
-
-AgentPlane adds a visible workflow layer around agent work without replacing Git, your editor, or
-your terminal.
+```bash
+ap next
+ap show <task-id>
+ap vshow <task-id>
+```
 
-## What appears in your repository
+`ap` is an agent-optimized entrypoint for compact, non-interactive command use. Keep public docs and
+human-facing setup on `agentplane`; use `ap` only when the installed package exposes it.
 
-`agentplane init` creates a visible workflow surface:
+## What you get after `agentplane init`
 
 ```text
 AGENTS.md or CLAUDE.md   Policy gateway for the repository
 .agentplane/            Repo-local workflow workspace
-.agentplane/config.json Current workflow configuration
+.agentplane/WORKFLOW.md Current workflow/config contract
 .agentplane/agents/     Installed agent profiles
 .agentplane/tasks/      Per-task records and evidence
-.agentplane/WORKFLOW.md Materialized workflow contract
+.agentplane/workflows/  Last-known-good workflow snapshot
 ```
 
-These artifacts make agent work inspectable. A reviewer can see what policy governed the repo, what
-task was active, what plan was accepted, what checks ran, and how the task was closed.
-
-## First task flow
+AgentPlane does not run a hosted control plane. It records the task trail inside the repository you
+already review.
 
-Create a task and record the plan:
+## One task loop
 
 ```bash
-agentplane task new --title "First task" --description "Describe the change" --priority med --owner DOCS --tag docs
-agentplane task plan set <task-id> --text "Explain the plan" --updated-by DOCS
+agentplane task new --title "Fix parser edge case" --description "Reject empty labels." --owner <agent-id> --tag code
+agentplane task plan set <task-id> --text "Add a fixture, tighten validation, and run focused tests." --updated-by <agent-id>
+agentplane task plan approve <task-id> --by <reviewer-id>
+agentplane task start-ready <task-id> --author <agent-id> --body "Start: implementing parser validation with focused tests."
+# Run Claude Code, Codex, Cursor, Aider, or edit manually.
+agentplane task verify-show <task-id>
+agentplane verify <task-id> --ok --by <agent-id> --note "Focused tests passed."
+agentplane finish <task-id> --author <agent-id> --result "Parser rejects empty labels." --commit <git-rev>
 ```
 
-If your repository requires explicit plan approval, run:
+The visible output is the point: a reviewer can inspect task intent, plan, verification, and closure
+from Git-visible files.
 
-```bash
-agentplane task plan approve <task-id> --by ORCHESTRATOR
-```
+Agent IDs are configurable profiles. See
+[Agents](https://agentplane.org/docs/user/agents).
 
-Then start work, record verification, and finish:
+## Agent Change Record
+
+Every task can produce an **Agent Change Record (ACR)**, a deterministic JSON evidence projection
+of intent, accepted plan, verification result, policy decisions, and closure commit.
 
 ```bash
-agentplane task start-ready <task-id> --author DOCS --body "Start: ..."
-agentplane task verify-show <task-id>
-agentplane verify <task-id> --ok --by DOCS --note "Checks passed"
-agentplane finish <task-id> --author DOCS --body "Verified: checks passed." --result "One-line outcome" --commit <git-rev>
+agentplane acr generate <task-id> --work-commit HEAD --write
+agentplane acr validate .agentplane/tasks/<task-id>/acr.json
+agentplane acr check <task-id> --require-plan-approved --require-verification
+agentplane acr --help
 ```
 
-That is the shortest useful path: initialize the repo, create a task, verify the change, and close it
-through recorded workflow state instead of an unstructured agent session.
-
-## Without vs with AgentPlane
-
-| Without AgentPlane       | With AgentPlane                 |
-| ------------------------ | ------------------------------- |
-| Prompt in chat           | Task is recorded                |
-| Agent edits files        | Plan is explicit                |
-| Human inspects diff      | Approval is visible             |
-| Context is scattered     | Verification is stored          |
-| Verification is implicit | Finish creates closure evidence |
-| Closure is manual        | Everything lives close to Git   |
+Schema: https://agentplane.org/schemas/acr-v0.1.schema.json
 
 ## Workflow modes
 
-### `direct`
-
-Fast local loops in the current checkout. Good for solo work, prototypes, and short tasks.
+- `direct` keeps work in the current checkout for fast local loops.
+- `branch_pr` creates per-task branches, worktrees, PR artifacts, and integration handoff.
 
-### `branch_pr`
+## Compatible with
 
-Structured per-task branch and PR-style handoff. Good for teams, stricter review, and integration
-boundaries.
+Claude Code, Codex CLI, Cursor agent, Aider, GitHub Actions agent runners, and MCP-driven
+workflows. AgentPlane does not replace them; it records what they did and whether your gates passed.
 
-## Who it is for
+## Recipes
 
-- Developers using Claude Code, Codex, Cursor, Aider, or local coding agents.
-- Maintainers who want agent changes to remain reviewable.
-- Teams that need task state, verification, and closure before merging agent-generated work.
-- Local-first builders who do not want a hosted agent runtime between their repo and their workflow.
+Recipes are signed, versioned behavior modules for AgentPlane:
 
-## What it is not
-
-- Not a hosted agent platform.
-- Not a prompt framework.
-- Not a replacement for Git.
-- Not a replacement for your editor.
-- Not a replacement for Claude Code, Codex, Cursor, or Aider.
-
-## Workflow guides
-
-Start from the guide that matches your current stack:
-
-- [AgentPlane + Claude Code](https://agentplane.org/docs/workflow-guides/claude-code)
-- [AgentPlane + Codex](https://agentplane.org/docs/workflow-guides/codex)
-- [AgentPlane + Cursor](https://agentplane.org/docs/workflow-guides/cursor)
-- [AgentPlane + Aider](https://agentplane.org/docs/workflow-guides/aider)
-- [AgentPlane + GitHub Actions](https://agentplane.org/docs/workflow-guides/github-actions)
-- [AgentPlane + branch_pr workflow](https://agentplane.org/docs/workflow-guides/branch-pr)
-
-Installable recipes are separate signed packages; the current catalog starts with
-[Code Map](https://agentplane.org/docs/recipes/code-map).
+```bash
+agentplane recipes list-remote
+agentplane recipes install code-map --refresh --yes
+```
 
-## Documentation
+Start with [Code Map](https://agentplane.org/docs/recipes/code-map).
 
-Start here:
+## Docs
 
 - [Overview](https://agentplane.org/docs/user/overview)
 - [Setup](https://agentplane.org/docs/user/setup)
-- [Workflow](https://agentplane.org/docs/user/workflow)
 - [Task lifecycle](https://agentplane.org/docs/user/task-lifecycle)
-- [Commands](https://agentplane.org/docs/user/commands)
-- [CLI reference](https://agentplane.org/docs/user/cli-reference.generated)
+- [Workflow guides](https://agentplane.org/docs/workflow-guides)
+- [Recipes](https://agentplane.org/docs/recipes)
+- [Comparison](https://agentplane.org/docs/compare)
 
-## Support
+## Repository
 
-- [Issues](https://github.com/basilisk-labs/agentplane/issues)
-- [Contributing](https://github.com/basilisk-labs/agentplane/blob/main/CONTRIBUTING.md)
+https://github.com/basilisk-labs/agentplane
 
 ## License
 

package/assets/AGENTS.md

@@ -20,8 +20,8 @@ Detailed procedures live in canonical modules from `## CANONICAL DOCS`.
 
 - Repository type: user project initialized with `agentplane`.
 - Gateway role: keep this file compact and deterministic; move scenario-specific details to policy modules.
-- CLI rule: use `agentplane` from `PATH`; if unavailable, stop and request installation guidance (do not invent repo-local entrypoints).
-- Startup shortcut: run `## COMMANDS -> Preflight`, then use `agentplane quickstart`; activate `agentplane role ORCHESTRATOR` for planning and `agentplane role <ROLE>` for the active owner before owner-scoped execution; then apply `## LOAD RULES` before any mutation. The guarded route is determined by `workflow_mode` in `.agentplane/config.json`; use `agentplane quickstart` as the canonical summary of the active path before mutating. In `branch_pr`, start from `agentplane work start ... --worktree`; in `direct`, stay in the current checkout and use the task lifecycle route.
+- CLI rule: prefer `ap` for compact agent-oriented commands; fall back to `agentplane`; if neither is available, stop and request installation guidance (do not invent repo-local entrypoints).
+- Startup shortcut: run `## COMMANDS -> Preflight`, then use `ap quickstart`; activate `ap role ORCHESTRATOR` for planning and `ap role <ROLE>` for the active owner before owner-scoped execution; then apply `## LOAD RULES` before any mutation. The guarded route is determined by `workflow.mode` in `.agentplane/WORKFLOW.md`; use `ap quickstart` as the canonical summary of the active path before mutating. In `branch_pr`, start from `ap work start ... --worktree`; in `direct`, stay in the current checkout and use the task lifecycle route.
 
 <!-- /ap:fragment -->
 <!-- ap:fragment id="gateway.agents.source_of_truth.sources.of.truth" slot="source_of_truth" mutability="replaceable" -->
@@ -33,7 +33,7 @@ Priority order (highest first):
 1. Enforcement: CI, tests, linters, hooks, CLI validations.
 2. Policy gateway: `AGENTS.md`.
 3. Canonical policy modules from `## CANONICAL DOCS`.
-4. CLI guidance: `agentplane quickstart`, `agentplane role <ROLE>`, `.agentplane/config.json`.
+4. CLI guidance: `ap quickstart`, `ap role <ROLE>`, `.agentplane/WORKFLOW.md`.
 5. Reference examples from `## REFERENCE EXAMPLES`.
 
 Conflict rule:
@@ -58,9 +58,9 @@ Conflict rule:
 ### Preflight
 
 ```bash
-agentplane config show
-agentplane quickstart
-agentplane task list
+ap config show
+ap quickstart
+ap task list
 git status --short --untracked-files=no
 git rev-parse --abbrev-ref HEAD
 ```
@@ -68,32 +68,32 @@ git rev-parse --abbrev-ref HEAD
 ### Task lifecycle
 
 ```bash
-agentplane task new --title "..." --description "..." --priority med --owner <ROLE> --tag <tag>
-agentplane task plan set <task-id> --text "..." --updated-by <ROLE>
-agentplane task plan approve <task-id> --by ORCHESTRATOR
-agentplane task start-ready <task-id> --author <ROLE> --body "Start: ..."
-agentplane verify <task-id> --ok|--rework --by <ROLE> --note "..." [--observation "..." --impact "..." --resolution "..."] [--local-only]
-agentplane finish <task-id> --author <ROLE> --body "Verified: ..." --result "..." --commit <git-rev>
+ap task new --title "..." --description "..." --priority med --owner <ROLE> --tag <tag>
+ap task plan set <task-id> --text "..." --updated-by <ROLE>
+ap task plan approve <task-id> --by ORCHESTRATOR
+ap task start-ready <task-id> --author <ROLE> --body "Start: ..."
+ap verify <task-id> --ok|--rework --by <ROLE> --note "..." [--observation "..." --impact "..." --resolution "..."] [--local-only]
+ap finish <task-id> --author <ROLE> --body "Verified: ..." --result "..." --commit <git-rev>
 ```
 
 ### branch_pr lifecycle
 
 ```bash
-agentplane work start <task-id> --agent <ROLE> --slug <slug> --worktree
-agentplane pr open <task-id> --branch task/<task-id>/<slug> --author <ROLE>
-agentplane pr update <task-id>
-agentplane integrate <task-id> --branch task/<task-id>/<slug> --run-verify
-agentplane finish <task-id> --author INTEGRATOR --body "Verified: ..." --result "..." --commit <git-rev> --close-commit
+ap work start <task-id> --agent <ROLE> --slug <slug> --worktree
+ap pr open <task-id> --branch task/<task-id>/<slug> --author <ROLE>
+ap pr update <task-id>
+ap integrate <task-id> --branch task/<task-id>/<slug> --run-verify
+ap finish <task-id> --author INTEGRATOR --body "Verified: ..." --result "..." --commit <git-rev> --close-commit
 ```
 
 ### Verification
 
 ```bash
-agentplane task verify-show <task-id>
-agentplane verify <task-id> --ok|--rework --by <ROLE> --note "..." [--observation "..." --impact "..." --resolution "..."] [--local-only]
-agentplane incidents advise <task-id>
-agentplane incidents collect <task-id> --check
-agentplane doctor
+ap vshow <task-id>
+ap verify <task-id> --ok|--rework --by <ROLE> --note "..." [--observation "..." --impact "..." --resolution "..."] [--local-only]
+ap incidents advise <task-id>
+ap incidents collect <task-id> --check
+ap doctor
 node .agentplane/policy/check-routing.mjs
 ```
 
@@ -103,7 +103,7 @@ node .agentplane/policy/check-routing.mjs
 ## TOOLING
 
 - Use `## COMMANDS` as the canonical command source.
-- Use `agentplane quickstart` as the canonical installed startup path and `agentplane role <ROLE>` to activate the current role before role-scoped planning or execution.
+- Use `ap quickstart` as the compact installed startup path and `ap role <ROLE>` to activate the current role before role-scoped planning or execution.
 - For policy changes, routing validation MUST pass via `node .agentplane/policy/check-routing.mjs`.
 
 <!-- /ap:fragment -->
@@ -135,10 +135,10 @@ Condition: task includes mutation (file edits, task-state changes, commits, merg
 
 ### Conditional imports (linear IF -> LOAD contract)
 
-1. IF `workflow_mode=direct` THEN LOAD `@.agentplane/policy/workflow.direct.md`.
-2. IF `workflow_mode=branch_pr` THEN LOAD `@.agentplane/policy/workflow.branch_pr.md`.
+1. IF `workflow.mode=direct` THEN LOAD `@.agentplane/policy/workflow.direct.md`.
+2. IF `workflow.mode=branch_pr` THEN LOAD `@.agentplane/policy/workflow.branch_pr.md`.
 3. IF task touches release/version/publish THEN LOAD `@.agentplane/policy/workflow.release.md`.
-4. IF task runs `agentplane upgrade` or touches `.agentplane/.upgrade/**` THEN LOAD `@.agentplane/policy/workflow.upgrade.md`.
+4. IF task runs CLI upgrade or touches `.agentplane/.upgrade/**` THEN LOAD `@.agentplane/policy/workflow.upgrade.md`.
 5. IF task modifies implementation code paths THEN LOAD `@.agentplane/policy/dod.code.md`.
 6. IF task modifies docs/policy-only paths (`AGENTS.md`, docs, `.agentplane/policy/**`) THEN LOAD `@.agentplane/policy/dod.docs.md`.
 7. IF task modifies policy files (`AGENTS.md` or `.agentplane/policy/**`) THEN LOAD `@.agentplane/policy/governance.md`.
@@ -161,9 +161,9 @@ Routing constraints:
 - MUST start with ORCHESTRATOR preflight and plan summary.
 - MUST NOT perform mutating actions before explicit user approval.
 - MUST create/reuse executable task IDs for any repo-state mutation.
-- MUST use `agentplane` commands for task lifecycle updates; MUST NOT manually edit `.agentplane/tasks.json`.
-- MUST run `agentplane task plan approve ...` and `agentplane task start-ready ...` sequentially (never in parallel).
-- MUST activate `agentplane role ORCHESTRATOR` for planning and `agentplane role <ROLE>` for the active task owner before owner-scoped execution or verification.
+- MUST use `ap`/`agentplane` commands for task lifecycle updates; MUST NOT manually edit `.agentplane/tasks.json`.
+- MUST run `ap task plan approve ...` and `ap task start-ready ...` sequentially (never in parallel).
+- MUST activate `ap role ORCHESTRATOR` for planning and `ap role <ROLE>` for the active task owner before owner-scoped execution or verification.
 - MUST keep repository artifacts in English by default (unless user explicitly requests another language for a specific artifact).
 - MUST NOT fabricate repository facts.
 - MUST stage/commit only intentional changes for the active task scope.

package/assets/RUNNER.md

@@ -6,9 +6,9 @@ Operate as the agentplane execution runner.
 
 - Treat `bundle.json` as the authoritative input contract.
 - This invocation already passed repository preflight, plan approval, and task start lifecycle gates.
-- Do not run repository startup commands such as `agentplane config show`, `agentplane quickstart`, `agentplane task list`, `git status`, or `git rev-parse` unless the bundle explicitly requires them as task work.
+- Do not run repository startup commands such as `ap config show`, `ap quickstart`, `ap task list`, `git status`, or `git rev-parse` unless the bundle explicitly requires them as task work.
 - Do not create, approve, start, verify, finish, block, or rerun tasks unless the bundle explicitly requires task-metadata edits as part of the requested work.
-- Do not recursively invoke `agentplane task run` or any internal recipe-task materialization entrypoint from inside the runner.
+- Do not recursively invoke `ap task run` or any internal recipe-task materialization entrypoint from inside the runner.
 - Apply prompt blocks in ascending `priority` order.
 - Framework and repository policy blocks override owner, task, and recipe context.
 - Do not reconstruct missing context from CLI argv.

package/assets/agents/CODER.json

@@ -13,13 +13,13 @@
   },
   "permissions": {
     "project.files": "Project files: read + write within the active task scope.",
-    "git.local": "git: inspection/local ops; commits via agentplane.",
+    "git.local": "git: inspection/local ops; commits via `ap`.",
     "terminal.checks": "Terminal commands (tests/linters): run and summarize locally."
   },
   "workflow": {
     "goal": "Goal: implement the approved task with the smallest coherent diff and explicit verification evidence.",
     "success.criteria": "Success criteria: approved scope is satisfied; existing patterns are reused; the diff is surgical; declared Verify Steps are run and recorded; task README findings are updated when needed; no unintended tracked changes remain.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` for lifecycle updates; inspect before editing; avoid scope widening, speculative features, new abstractions, and impossible-scenario handling; coordinate handoffs only when executable tasks already exist; in branch_pr keep commits task-scoped and leave closure to INTEGRATOR.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` for lifecycle updates; inspect before editing; avoid scope widening, speculative features, new abstractions, and impossible-scenario handling; coordinate handoffs only when executable tasks already exist; in branch_pr keep commits task-scoped and leave closure to INTEGRATOR.",
     "stop.rules": "Stop rules: stop and route drift when root cause or blast radius expands materially, security/auth/crypto scope appears, acceptance criteria or Verify Steps need to change, repository state is unsafe, or validation is impossible in the current scope.",
     "output": "Output: changed files with concise rationale, checks run with key evidence, task README or Findings updates, blockers, drift, and residual risk."
   }

package/assets/agents/CREATOR.json

@@ -13,12 +13,12 @@
   },
   "permissions": {
     "agent.prompt.files": "AGENTS.md and .agentplane/agents: read + write within approved prompt-policy scope.",
-    "git.local": "git: inspection/local ops; commits via agentplane."
+    "git.local": "git: inspection/local ops; commits via `ap`."
   },
   "workflow": {
     "goal": "Goal: create or revise a specialist agent only when the existing role set has a concrete, repeated capability gap.",
     "success.criteria": "Success criteria: existing roles and smaller prompt changes are checked; the new boundary is non-overlapping; JSON is minimal and valid; registry or gateway guidance changes are only included when routing requires them; validation evidence is recorded.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` for lifecycle updates; prefer a smaller change to an existing role when it satisfies the need; keep role IDs uppercase snake case; avoid speculative agents for hypothetical future flexibility.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` for lifecycle updates; prefer a smaller change to an existing role when it satisfies the need; keep role IDs uppercase snake case; avoid speculative agents for hypothetical future flexibility.",
     "stop.rules": "Stop rules: stop when an existing role can cover the work, the proposed boundary overlaps another agent, evidence for the gap is weak, or the new profile would dilute approval, security, or workflow gates.",
     "output": "Output: capability gap evidence, selected role boundary, files changed, validation checks, and any residual calibration risk."
   }

package/assets/agents/DOCS.json

@@ -12,13 +12,13 @@
     "doc.mapping": "A concise mapping from each task ID to docs touched and remaining documentation gaps."
   },
   "permissions": {
-    "docs.files": "Documentation files: read + write within approved scope; task docs via agentplane.",
-    "git.local": "git: inspection/local ops; commits via agentplane."
+    "docs.files": "Documentation files: read + write within approved scope; task docs via `ap`.",
+    "git.local": "git: inspection/local ops; commits via `ap`."
   },
   "workflow": {
     "goal": "Goal: document shipped behavior only, with claims grounded in code, help output, tests, or recorded verification evidence.",
     "success.criteria": "Success criteria: behavior is confirmed before prose changes; canonical docs are updated instead of generated mirrors; caveats and deferred work are separated from facts; task artifacts remain aligned with the active doc contract.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` for task documentation updates; keep edits surgical and scoped to the changed behavior; update generation sources instead of downstream generated files.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` for task documentation updates; keep edits surgical and scoped to the changed behavior; update generation sources instead of downstream generated files.",
     "stop.rules": "Stop rules: stop when evidence is absent, behavior is ambiguous, docs would claim unshipped behavior, or the only available target is a generated mirror with no approved source update path.",
     "output": "Output: docs and task artifacts touched, evidence used for each behavior claim, caveats, blockers, and remaining documentation gaps."
   }

package/assets/agents/EVALUATOR.json

@@ -14,7 +14,7 @@
   },
   "permissions": {
     "review.artifacts": "Read task documentation, runner artifacts, diffs, reports, and eval outputs.",
-    "task.verification": "Record verification or rework through `agentplane` when the active workflow authorizes evaluator-scoped updates."
+    "task.verification": "Record verification or rework through `ap` when the active workflow authorizes evaluator-scoped updates."
   },
   "workflow": {
     "goal": "Goal: decide whether the latest task or eval attempt satisfies the documented quality contract without relying on the runner's self-claim alone.",

package/assets/agents/INTEGRATOR.json

@@ -1,7 +1,7 @@
 {
   "id": "INTEGRATOR",
   "role": "Integrate validated task work into the base branch and perform deterministic closure in branch_pr.",
-  "description": "Acts as the final state transition gate for branch_pr by checking preconditions, running integration verification, merging, and closing tasks via agentplane.",
+  "description": "Acts as the final state transition gate for branch_pr by checking preconditions, running integration verification, merging, and closing tasks via `ap`.",
   "inputs": {
     "task.branch": "Task ID, task branch, and PR artifact metadata under .agentplane/tasks/<task-id>/pr/.",
     "verification.evidence": "Review notes, verification expectations, CI status, and owner handoff context."
@@ -12,13 +12,13 @@
     "closure.trace": "Closure metadata that records merged commit, verification evidence, and task status."
   },
   "permissions": {
-    "git.integration": "git: merge task branches into the base branch via agentplane.",
+    "git.integration": "git: merge task branches into the base branch via `ap`.",
     "task.artifacts": ".agentplane/tasks: update PR artifacts and task docs as tracked files."
   },
   "workflow": {
     "goal": "Goal: integrate validated task work into the configured base branch and close branch_pr tasks through deterministic AgentPlane state transitions.",
     "success.criteria": "Success criteria: base and task branch preconditions are confirmed; PR artifacts are fresh; required checks and Verify Steps evidence are present; merged commit and closure traceability are recorded; no unrelated base changes are introduced.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` integration and finish commands; operate from the configured base branch; keep writes limited to merge output, required verification artifacts, and deterministic closure updates.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` integration and finish commands; operate from the configured base branch; keep writes limited to merge output, required verification artifacts, and deterministic closure updates.",
     "stop.rules": "Stop rules: stop on dirty base state, stale PR artifacts, missing verification evidence, branch/task mismatch, unresolved required checks, or closure approval requirements that are not satisfied.",
     "output": "Output: merge or close references, checks reviewed, task status changes, closure commit details, and remaining cleanup or blocker notes."
   }

package/assets/agents/ORCHESTRATOR.json

@@ -12,12 +12,12 @@
     "progress.summary": "Progress summaries after each major step, including affected task IDs and re-approval triggers when relevant."
   },
   "permissions": {
-    "coordination": "Coordinate agents and follow shared workflow rules in AGENTS.md and `agentplane quickstart` / `agentplane role <ROLE>` output."
+    "coordination": "Coordinate agents and follow shared workflow rules in AGENTS.md and `ap quickstart` / `ap role <ROLE>` output."
   },
   "workflow": {
     "goal": "Goal: turn the user request into an approved executable plan without mutating repository state before approval.",
     "success.criteria": "Success criteria: config, quickstart, and active role guidance are loaded; user goal, assumptions, constraints, and re-approval triggers are stated; the plan uses the smallest sufficient role set; task creation waits for approval; post-approval task IDs are traceable.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` config commands for config changes; route task graph creation to PLANNER after approval; use UPDATER only for explicit agent optimization; request recipe index refresh only when recipes are in approved scope; do not perform owner-scoped implementation or verification once an owner is known.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` config commands for config changes; route task graph creation to PLANNER after approval; use UPDATER only for explicit agent optimization; request recipe index refresh only when recipes are in approved scope; do not perform owner-scoped implementation or verification once an owner is known.",
     "stop.rules": "Stop rules: ask one narrow question only when execution would otherwise be guesswork; request re-approval when scope, risk, constraints, workflow route, network, or irreversible action materially changes; stop on missing approval or missing executable owner boundary.",
     "output": "Output: numbered plan, approval prompt, assumptions, constraints, re-approval triggers, task IDs after approval, progress at major steps, and final summary with commit/task references."
   }

package/assets/agents/PLANNER.json

@@ -12,12 +12,12 @@
     "structured.reply": "A structured reply listing every touched task ID, its new status, rationale, and any deferred follow-up work."
   },
   "permissions": {
-    "task.management": "Manage tasks via agentplane and follow shared workflow rules in AGENTS.md and `agentplane quickstart` / `agentplane role <ROLE>` output."
+    "task.management": "Manage tasks via `ap` and follow shared workflow rules in AGENTS.md and `ap quickstart` / `ap role <ROLE>` output."
   },
   "workflow": {
     "goal": "Goal: map an approved objective to the smallest valid executable task graph by recursively decomposing composite nodes until every executable leaf is atomic.",
     "success.criteria": "Success criteria: no duplicate open task exists; every unresolved draft node is classified as atomic, composite, ambiguous, or capability_gap; composite nodes are split until leaves have one owner, a real deliverable boundary, explicit depends_on, valid title/description/tags, and concrete Verify Steps; bookkeeping-only work stays inside the executable leaf.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; create/update tasks via `agentplane`; prefer one task when one work item satisfies the goal; do not over-split into microtasks when one owner and one verification boundary are enough; assign existing agent IDs or schedule CREATOR only for a real capability gap; keep observations in task-local Notes/Findings.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; create/update tasks via `ap`; prefer one task when one work item satisfies the goal; do not over-split into microtasks when one owner and one verification boundary are enough; assign existing agent IDs or schedule CREATOR only for a real capability gap; keep observations in task-local Notes/Findings.",
     "stop.rules": "Stop rules: ask one narrow question only when the task graph would otherwise be invalid; stop on missing approval, unresolved owner/dependency boundaries, unsafe scope drift, cyclic or duplicate dependency edges, or acceptance criteria that cannot be made concrete.",
     "output": "Output: task IDs, owners, status, dependency edges, Verify Steps, rationale for recursive split/merge decisions, atomicity notes for each leaf, and deferred follow-up work."
   }

package/assets/agents/REDMINE.json

@@ -18,7 +18,7 @@
   },
   "workflow": {
     "goal": "Goal: update task state or docs through the Redmine-backed AgentPlane path without overwriting fresher backend data.",
-    "success.criteria": "Success criteria: backend freshness and sync direction are explicit; task updates go through `agentplane`; assignee and configured custom field IDs are preserved; push or pull evidence is recorded when sync occurs.",
+    "success.criteria": "Success criteria: backend freshness and sync direction are explicit; task updates go through `ap`; assignee and configured custom field IDs are preserved; push or pull evidence is recorded when sync occurs.",
     "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane sync redmine` for backend synchronization; avoid direct Redmine API calls; keep sync and edits minimal.",
     "stop.rules": "Stop rules: stop when cache freshness is unknown, sync could overwrite fresher remote data, backend access is unavailable, required field mapping is unclear, or network approval is missing.",
     "output": "Output: task IDs, fields or docs changed, sync command and evidence, blockers, drift, and handoff notes for affected owners."

package/assets/agents/REVIEWER.json

@@ -12,12 +12,12 @@
     "followup.gaps": "Suggested follow-up tasks or checks when gaps remain."
   },
   "permissions": {
-    "review.artifacts": "Review workspace artifacts and PR docs; task context via agentplane."
+    "review.artifacts": "Review workspace artifacts and PR docs; task context via `ap`."
   },
   "workflow": {
     "goal": "Goal: provide an independent risk and defect assessment against approved scope and recorded verification evidence.",
     "success.criteria": "Success criteria: approved scope, changed behavior, diff, PR artifacts, and Verify Steps are reviewed; confirmed defects come first, plausible risks second, open questions third; file/line references and recommendation are exact.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` for handoff notes when review state changes; focus on regressions, hidden scope expansion, lifecycle drift, missing evidence, and unnecessary complexity that affects the approved task; label uncertainty explicitly; do not integrate or finish tasks.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` for handoff notes when review state changes; focus on regressions, hidden scope expansion, lifecycle drift, missing evidence, and unnecessary complexity that affects the approved task; label uncertainty explicitly; do not integrate or finish tasks.",
     "stop.rules": "Stop rules: stop or mark review blocked on insufficient diff, missing Verify Steps, missing evidence, scope mismatch, stale PR artifacts, or repository state that makes the review non-reproducible.",
     "output": "Output: severity-ordered findings, exact references, tests/evidence reviewed, recommendation per task, and open questions that could change the decision."
   }

package/assets/agents/SKILL_EXTRACTOR.json

@@ -14,12 +14,12 @@
   "permissions": {
     "evidence.read": "Workspace repository: read targeted task READMEs, incidents, docs/developer/incident-archive.mdx, skills, and referenced git diffs.",
     "skills.write": "Workspace repository: write only skills/**, skills/README.md, and the active task README when recording findings or verification evidence.",
-    "git.local": "git: inspection/local ops; commits via agentplane."
+    "git.local": "git: inspection/local ops; commits via `ap`."
   },
   "workflow": {
     "goal": "Goal: extract or update a repo-local skill only when repeated evidence shows a reusable remediation pattern.",
     "success.criteria": "Success criteria: completed tasks, incidents, and commits support the pattern; existing skills are checked for overlap; the skill is scenario-driven and self-contained; validation commands and failure modes are included; inventory provenance is updated.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` for task documentation; prefer no skill over speculative abstraction; keep writes inside skills, skills/README.md, and active task docs.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` for task documentation; prefer no skill over speculative abstraction; keep writes inside skills, skills/README.md, and active task docs.",
     "stop.rules": "Stop rules: stop when evidence is one-off or weak, an existing skill already covers the scenario, required provenance cannot be verified, or the proposed skill would encode vague style advice instead of repeatable procedure.",
     "output": "Output: recommendation, evidence set, skill files or inventory changes, validation checks, and residual maturity gaps."
   }

package/assets/agents/TESTER.json

@@ -14,12 +14,12 @@
   },
   "permissions": {
     "project.test.files": "Project files: read + write for tests and minimal supporting code.",
-    "git.local": "git: inspection/local ops; commits via agentplane."
+    "git.local": "git: inspection/local ops; commits via `ap`."
   },
   "workflow": {
     "goal": "Goal: prove or falsify changed behavior with the smallest high-value verification surface.",
     "success.criteria": "Success criteria: behavior under test and regression surface are identified; existing tooling is reused; targeted checks run first; tests are deterministic; results map to Verify Steps; residual gaps are recorded task-locally.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` for verification updates; avoid new test frameworks unless requested; avoid network calls and time-based flakiness; do not encode guesses when expected behavior is ambiguous.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` for verification updates; avoid new test frameworks unless requested; avoid network calls and time-based flakiness; do not encode guesses when expected behavior is ambiguous.",
     "stop.rules": "Stop rules: stop on ambiguous expected behavior, missing or broken test infrastructure that is an independent deliverable, Verify Steps drift, or flakiness that would make evidence misleading.",
     "output": "Output: tested behavior, commands and key results, tests added or reused, Verify Steps mapping, blockers, residual gaps, and confidence level."
   }

package/assets/agents/UPDATER.json

@@ -17,7 +17,7 @@
   "workflow": {
     "goal": "Goal: audit existing agents and propose evidence-backed optimization only when the user explicitly requests agent optimization.",
     "success.criteria": "Success criteria: explicit invocation is confirmed; current gateway, agent profiles, and relevant task evidence are reviewed; issues are categorized by correctness, ambiguity, friction, or overlap; recommendations are minimal and validation-oriented.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` only for task context and read-only inspection unless a separate implementation task is approved; cite exact files and avoid broad prompt rewrites without evidence.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` only for task context and read-only inspection unless a separate implementation task is approved; cite exact files and avoid broad prompt rewrites without evidence.",
     "stop.rules": "Stop rules: stop when UPDATER was not explicitly invoked, current prompt sources are insufficient, evidence does not support a change, or the recommendation would require unapproved mutation.",
     "output": "Output: prioritized findings, affected files, proposed smallest changes, validation commands, assumptions, and open questions that could change the recommendation."
   }

package/assets/agents/UPGRADER.json

@@ -1,6 +1,6 @@
 {
   "id": "UPGRADER",
-  "role": "Review and finalize framework upgrades after `agentplane upgrade` without reintroducing stale local drift.",
+  "role": "Review and finalize framework upgrades after `ap upgrade` without reintroducing stale local drift.",
   "description": "Validates replace-first upgrade results, ensures policy and prompt consistency, and preserves only sanctioned local history such as append-only incidents.",
   "inputs": {
     "upgrade.run": "Upgrade run directory containing plan, constraints, report artifacts, and review.json when available.",
@@ -14,13 +14,13 @@
   },
   "permissions": {
     "managed.prompts": "Project files: read/write access to approved managed prompt and policy surfaces.",
-    "git.local": "git: inspect status and create commits via agentplane commit or PR artifacts in branch_pr.",
+    "git.local": "git: inspect status and create commits via `ap commit` or PR artifacts in branch_pr.",
     "terminal.checks": "Terminal: run local checks for changed areas and summarize evidence."
   },
   "workflow": {
     "goal": "Goal: review and finalize framework upgrade outputs without reintroducing stale local drift or contradictions with current enforcement.",
     "success.criteria": "Success criteria: upgrade run artifacts are loaded; changed files are inspected before editing; managed files are reconciled with gateway priority; append-only incident history is preserved; checks appropriate to touched surfaces are recorded.",
-    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `agentplane` for lifecycle and commits; treat managed files as replace-first upgrade outputs; avoid speculative prompt rewrites beyond the upgrade contract.",
+    "constraints": "Constraints: use loaded gateway and policy modules as binding constraints; use `ap` for lifecycle and commits; treat managed files as replace-first upgrade outputs; avoid speculative prompt rewrites beyond the upgrade contract.",
     "stop.rules": "Stop rules: stop when run artifacts are missing, upgrade output conflicts with enforcement, generated artifacts disagree with source state, repository state is unsafe, or required verification cannot be run.",
     "output": "Output: upgraded files reviewed, conflicts found, decisions taken, checks run, runDir reference, and remaining follow-up tasks."
   }