CLI: Command-Line Interface

Overview

The Packmind CLI provides the following commands:

init - Initialize Packmind in your project (configure agents + install skills)
config agents setup - Configure which AI coding agents to generate artifacts for (interactive)
config agents list - List configured agents across packmind.json files
config agents add - Add coding agents to packmind.json files
config agents rm - Remove coding agents from packmind.json files
login - Authenticate with your Packmind instance
logout - Clear stored credentials
whoami - Show current authentication status
install - Download packages locally
uninstall - Remove packages from your project
lint - Run detection programs (Enterprise only)
playbook diff - Show differences between local files and Packmind artefacts
playbook add - Stage a change between local files and Packmind artefacts
playbook submit - Submit local changes to Packmind
skills init - Install default Packmind skills locally
skills list - List all skills in your organization
standards list - List all standards in your organization
commands list - List all commands in your organization
packages create - Create a new package
packages add - Add standards, commands, or skills to a package
packages list - List all packages in your organization
plugins render - Render a Packmind package as a Claude plugin
plugins delete - Delete a rendered Claude plugin from this workspace
update - Update the CLI to the latest version

Installation

One-click install (Recommended)

The easiest way to install and configure the Packmind CLI is using the one-click install available in the Packmind web interface. Where to find it:

During your first onboarding after creating an account
Anytime in your Account Settings page

What it does:

Downloads and installs the Packmind CLI binary for your platform
Authenticates you automatically with your Packmind account
Sets up your PATH environment variable

Simply copy the provided command and paste it into your terminal. The script handles everything automatically.

Why this is recommended — The one-click install eliminates manual steps by combining installation and authentication in a single command.

Alternative: npm Package

Node.js 22 or higher required.

Global Installation:

npm install -g @packmind/cli

After installation, the packmind-cli command will be available globally. npx (no installation required):

npx @packmind/cli login

This runs the CLI directly without installing it, always using the latest version.

Alternative: Homebrew

Available on macOS and Linux.

brew tap PackmindHub/cli
brew install packmind-cli

After installation, the packmind-cli command will be available globally.

Alternative: Standalone Executables

Download the appropriate pre-built executable for your platform from the GitHub Releases page. Available platforms:

Linux x64: packmind-cli-linux-x64-{version}
Linux arm64: packmind-cli-linux-arm64-{version}
macOS arm64: packmind-cli-macos-arm64-{version} (signed and notarized)
Windows x64: packmind-cli-windows-x64-{version}.exe

For Linux/macOS, make the executable runnable:

chmod +x packmind-cli-*-{version}

Optional: Move to a directory in your PATH for easy access:

# Linux/macOS
sudo mv packmind-cli-*-{version} /usr/local/bin/packmind-cli

# Windows: Move to a directory in your PATH or run directly

Choosing an Installation Method — Use one-click install for the simplest experience with automatic authentication. Use npm global if you want packmind-cli always available system-wide. Use npx for project-specific usage or testing without installation. Use Homebrew if you prefer managing packages through your system package manager (macOS/Linux). Use standalone executables if you don’t have Node.js installed or need a specific binary for your environment.

Authentication

The CLI requires authentication to communicate with your Packmind instance. The easiest way to authenticate is using the login command:

packmind-cli login

This will:

Open your browser to the Packmind login page
After you authenticate, automatically receive credentials
Store credentials securely in ~/.packmind/credentials.json

For self-hosted instances, specify your host:

packmind-cli login --host https://your-packmind-instance.com

Manual code entry (if browser flow doesn’t work): You can also enter a login code manually from the web interface:

packmind-cli login --code YOUR_CODE_HERE

Logout Command

To clear stored credentials:

packmind-cli logout

This removes the credentials file. If you also have PACKMIND_API_KEY_V3 set as an environment variable, you’ll need to unset it separately:

unset PACKMIND_API_KEY_V3

Whoami Command

Check your current authentication status:

packmind-cli whoami

This displays:

Your API key (masked)
Connected host
Organization name
User name
Credential expiration status

API Key Authentication (PACKMIND_API_KEY_V3)

You can authenticate using the PACKMIND_API_KEY_V3 environment variable instead of the interactive login flow. This is the recommended approach for:

CI/CD pipelines — Automated environments where interactive login isn’t possible
Docker containers — Pass the API key as an environment variable
Scripted workflows — When you need non-interactive authentication

Getting Your API Key

Log in to your Packmind instance (Cloud or self-hosted)
Navigate to Settings (click your profile icon in the top right)
Scroll to the CLI Authentication section
Go to the Environment Variable tab
Click Generate New Key to create an API key (valid for 90 days)
Copy the generated key

Setting the Environment Variable

Set the PACKMIND_API_KEY_V3 environment variable with your API key:

export PACKMIND_API_KEY_V3="your-api-key-here"

To make this permanent, add it to your shell configuration file (~/.bashrc, ~/.zshrc, etc.):

echo 'export PACKMIND_API_KEY_V3="your-api-key-here"' >> ~/.zshrc
source ~/.zshrc

CI/CD Example (GitHub Actions)

- name: Install Packmind packages
  env:
    PACKMIND_API_KEY_V3: ${{ secrets.PACKMIND_API_KEY_V3 }}
  run: packmind-cli install

Credential Priority — When both a credentials file and the PACKMIND_API_KEY_V3 environment variable exist, the environment variable takes precedence.

Init Command

Initialize Packmind in your project. This is the recommended first command to run when setting up Packmind in a new project.

What Init Does

The init command performs two main actions:

Configures AI agents - Interactively select which AI coding agents to generate artifacts for
Installs default skills - Including skill creator, standard creator, and onboarding skills

Basic Usage

packmind-cli init

This will:

Present an interactive prompt to select which AI agents you use (Claude Code, Cursor, GitHub Copilot, etc.)
Save your agent configuration to packmind.json
Install Packmind’s default skills to the appropriate locations for your selected agents
Display a success message with next steps

Example output:

Select coding agents to generate artifacts for:

  1. [*] Claude Code
  2. [ ] Cursor
  3. [ ] GitHub Copilot
  ...

Enter numbers separated by commas (default: 1,2,3): 1,2

Configuration saved. Artifacts will be generated for: Claude Code, Cursor

Installing default skills...
Default skills installed successfully!
  Files created: 5

Packmind initialized successfully!
Next step: Run /packmind-onboard in your AI agent to onboard the project

First-time setup — Run packmind-cli init after installing the CLI and logging in. It’s the quickest way to get Packmind configured for your project. After initialization, use the /packmind-onboard skill in your AI agent to scan your project and generate project-specific standards and commands.

Config Command

Configure Packmind settings.

Config Agents

Manage AI coding agents configured in your packmind.json files. The config agents command provides subcommands for interactive setup, listing, adding, and removing agents.

Config Agents Setup

Configure which AI coding agents to generate artifacts for via an interactive prompt:

packmind-cli config agents setup

This presents an interactive prompt where you can select from supported AI coding agents:

Claude Code - Artifacts in .claude/ directory
Cursor - Artifacts in .cursor/rules/ directory
GitHub Copilot - Artifacts in .github/copilot-instructions.md
Continue.dev - Artifacts in .continue/ directory
Junie - Artifacts in .junie/ directory
AGENTS.md - Single AGENTS.md file at project root
GitLab Duo - Artifacts in .gitlab/duo/ directory
OpenCode - Artifacts in .opencode/ directory
Codex - Artifacts in .agents/ directory

The command auto-detects existing agent configurations in your project and pre-selects them. Your selection is saved to packmind.json.

Auto-detection — If you already have agent configuration files (like .cursor/ or .claude/), they will be automatically pre-selected when you run this command.

Config Agents List

Display all configured coding agents across packmind.json files in a matrix view:

packmind-cli config agents list

The output shows a matrix with file paths as rows and agent names as columns, using checkmarks (✓) and dashes (-) to indicate which agents are configured in each file. Each file also shows its source — whether agents are configured locally (via the agents property in packmind.json) or inherited from organization settings. Use --path to scope the listing to a specific directory:

packmind-cli config agents list --path ./apps/api

Config Agents Add

Add one or more coding agents to all packmind.json files:

packmind-cli config agents add claude cursor

Use --path to target a specific directory:

packmind-cli config agents add --path ./packages/core claude

If the targeted files currently inherit agent configuration from organization settings, a confirmation prompt warns that adding local agents will override the organization-level defaults.

Config Agents Remove

Remove one or more coding agents from all packmind.json files:

packmind-cli config agents rm cursor copilot

Use --path to target a specific directory:

packmind-cli config agents rm --path ./apps/frontend claude

When all agents are removed from a file, the agents property is deleted entirely and the file reverts to organization-level defaults.

Supported Agents

Identifier	Agent
`claude`	Claude Code
`cursor`	Cursor
`copilot`	GitHub Copilot
`continue`	Continue.dev
`junie`	Junie
`agents_md`	AGENTS.md
`gitlab_duo`	GitLab Duo
`opencode`	OpenCode
`codex`	Codex

After adding or removing agents, run packmind-cli install to deploy or clean up the corresponding agent artifact files in your repository.

Install Command

Download commands, standards, and skills from packages to your local machine.

List Available Packages

packmind-cli packages list

View Package Details

packmind-cli packages show <package-slug>

View Workspace Status

See an overview of all packmind.json files and their installed packages across your workspace:

packmind-cli install --status

Example output:

Workspace packages status

packmind.json                        Packages
-----------------------------------------------------------------
./packmind.json                      generic
./apps/api/packmind.json             nestjs
./apps/frontend/packmind.json        frontend

3 unique packages currently installed.

This is useful for:

Understanding what packages are installed across a monorepo
Identifying empty or misconfigured packmind.json files (shown as <no packages>)
Getting a quick summary of unique packages in your workspace

Install Packages

packmind-cli install <package-slug> [additional-package-slugs...]

Example:

packmind-cli install backend frontend

This downloads all commands, standards, and skills from the specified packages and creates the appropriate files for your AI coding assistant.

Default skills included — When you install packages, Packmind’s default skills (including the packmind-update-playbook skill) are automatically installed alongside your package contents.

Lock File (`packmind-lock.json`)

When you install or uninstall packages, the CLI generates a packmind-lock.json file alongside your packmind.json. This file records the exact versions of all installed artifacts.

Recursive Install (Monorepos)

By default, packmind-cli install (with no package slugs) finds all packmind.json files in your git repository and installs their configured packages. After installation, a summary shows how many distributions were notified to Packmind.

packmind-cli install

To scope the recursive install to a specific directory, use the --path option:

packmind-cli install --path apps/frontend

AI Agent Rendering — The files created by the install command depend on which AI agents are enabled in your organization settings. The CLI respects your organization’s configured agents and creates instruction files accordingly (e.g., AGENTS.md, .cursor/rules/, .github/copilot-instructions.md). The .packmind/ directory is always created regardless of your configuration. To configure which agents are enabled, see Manage AI Agent Rendering.

Install Globally for Claude Code (`~/.claude`)

When you run packmind-cli install from inside your ~/.claude directory, the CLI switches into home-install mode — a streamlined flow optimized for sharing Packmind artifacts across every project you open in Claude Code, rather than tying them to a single repository.

cd ~/.claude
packmind-cli install <package-slug>

Why install here:

Global availability across projects — Skills, rules, and commands land directly under ~/.claude/skills/, ~/.claude/rules/, and ~/.claude/commands/, so Claude Code picks them up in any repository you open, not just one you have initialized with Packmind.
Single-agent rendering — Only Claude Code artifacts are generated. Any agents entries in packmind.json and your organization’s render modes are ignored, since ~/.claude is by definition Claude-specific.
Zero-prompt setup — If no packmind.json exists in ~/.claude, the CLI auto-creates one with {"agents": ["claude"]} and skips the interactive agent prompt entirely.
Clean file layout — The .claude/ path prefix is stripped from rendered files, so artifacts do not nest under a redundant ~/.claude/.claude/ subfolder.
No .packmind/ mirror — The server-side .packmind/ directory (whose internal links assume a repository layout) is skipped, keeping your home directory uncluttered.
No distribution notifications — Even if ~/.claude happens to live inside a git repository, the CLI does not notify Packmind that a distribution occurred — these artifacts are personal to your machine, not a team deployment.

When to use this mode — Reach for ~/.claude installs when you want a package available to Claude Code everywhere: personal coding preferences, cross-project organizational defaults, or experimental skills you want to try without modifying any repository. Per-repo packmind-cli install remains the right choice for project-specific standards that should be shared with teammates and committed to source control.

Lint Command

Enterprise Feature — The lint command is only available in the Enterprise edition.

Run detection programs against your codebase from the command line. This is useful for testing draft detection programs, verifying active programs, and integrating linting into your development workflow or CI/CD pipelines.

How Lint Works

The CLI supports two linting modes: Local Mode (recommended): When you have packmind.json files in your project, the CLI uses them to determine which standards to check against. The CLI automatically searches for all packmind.json files in your project tree:

Ancestor configs: Searches parent directories up to the Git repository root
Descendant configs: Searches subdirectories from your current location

All standards from packages defined in these packmind.json files are included in the analysis scope. This allows different parts of your codebase to have different standards while inheriting common standards from parent directories. To set up local linting, install packages using the install command. See Distribute Standards and Commands for details. Deployment Mode: If no packmind.json files are found, the CLI falls back to using standards that have been deployed to your Git repository through the web interface. See Deployment to learn about this approach.

Priority — When both local packmind.json files and deployments exist, the local configuration takes priority.

Basic Usage

packmind-cli lint .

This command:

Searches for packmind.json files in your project tree
Loads detection programs from the standards defined in your packages
Scans all files in the current directory (excluding node_modules, dist, and other common build folders)
Runs all active detection programs
Reports any violations found

Specify a Path

Lint a specific directory:

packmind-cli lint src/

packmind-cli lint /path/to/your/project

Lint a single file:

packmind-cli lint src/components/Button.tsx

When a single file is passed:

The CLI verifies the file exists and exits with an error if not
.packmindignore patterns are checked — if the file matches, it is skipped and the command exits with code 0
If the file is not in scope for the requested rule or standard (i.e. its extension doesn’t match the rule’s configured languages), an informational message is logged and no violations are reported

Limiting Scope with `--changed-files` and `--changed-lines`

When working on large codebases, you can focus the lint check on only the files or lines you’ve modified using the --changed-files and --changed-lines flags.

Git Repository Required — The --changed-files and --changed-lines flags require your project to be in a Git repository.

Deprecated Option — The --diff option is deprecated. Use --changed-files (equivalent to --diff=files) or --changed-lines (equivalent to --diff=lines) instead.

Check modified lines only:

packmind-cli lint . --changed-lines

This analyzes only the specific lines you’ve changed, making it ideal for pre-commit hooks or reviewing your work before pushing. Check modified files only:

packmind-cli lint . --changed-files

This analyzes all content in files you’ve modified, useful when you want full context but don’t want to scan the entire codebase. Example workflow:

# Make some changes to your code
git add .

# Check only what you changed
packmind-cli lint . --changed-lines

# If clean, commit
git commit -m "Your changes"

Output Formats

Choose between human-readable and IDE-friendly output:

packmind-cli lint . --logger=ide

Human-readable format (default) shows:

File paths with violations
Line and character positions
Rule identifiers
Summary of total violations found

IDE format provides structured output that can be parsed by editors and CI/CD tools.

Filtering by Severity

Use the --level flag to filter which violations are displayed based on their severity:

# Show only errors (suppress warnings)
packmind-cli lint . --level error

# Show warnings and errors (everything)
packmind-cli lint . --level warning

Value	What is displayed
`error`	Only error-level violations
`warning`	All violations (warnings and errors)

Without the --level flag, all violations are displayed regardless of severity.

CI/CD usage — Use --level error in your CI pipeline to focus on blocking violations only, while still running --level warning (or no flag) during local development to see all feedback. See Rule Severity for details on how severity affects exit codes.

Skills Command

Manage skills in your Packmind organization. Skills are reusable knowledge packages that AI coding assistants can discover and use.

Initialize Default Skills

packmind-cli skills init

This command installs Packmind’s default skills locally, including:

packmind-onboard — A skill for initializing Packmind in projects
packmind-update-playbook - A skill to manage your playbook: create skills, commands and standards or update the existing ones.

Automatic installation — Default skills are also installed automatically when you run packmind-cli init, install a package with packmind-cli install, or when packages are distributed to your repository via the web app.

List Skills

packmind-cli skills list

This command displays all skills in your Packmind organization, showing:

Slug — The skill identifier
Name — The display name
URL — Direct link to view the skill in the web app
Description — What the skill does

Example output:

Available skills:

- my-custom-skill
    Name: My Custom Skill
    URL: https://app.packmind.com/org/my-org/space/global/skills/my-custom-skill/files
    Description: Custom skill for my project...

Add a Skill

packmind-cli playbook add <path>
packmind-cli playbook submit --no-review

Arguments:

<path> - Path to the skill directory containing skill files

Example:

packmind-cli playbook add ./my-skill
packmind-cli playbook submit --no-review

Use --no-review to trigger a direct update. Omit --no-review to use the change proposals system and get validation of your changes.

This uploads the skill to your Packmind organization, making it available for distribution to repositories. When uploading a skill that already exists, Packmind automatically compares the content:

If changes are detected, a new version is created
If the content is identical, no new version is created

See Skills Management for details on versioning.

Standards Command

Create and manage coding standards from the command line.

List Standards

packmind-cli standards list

This command displays all standards in your Packmind organization, showing:

Slug — The standard identifier
Name — The display name
URL — Direct link to view the standard in the web app
Description — What the standard covers

Example output:

Available standards:

- error-handling
    Name: Error Handling
    URL: https://app.packmind.com/org/my-org/space/global/standards/abc123/summary
    Description: Ensure errors are handled predictably...

- typescript-conventions
    Name: TypeScript Conventions
    URL: https://app.packmind.com/org/my-org/space/global/standards/def456/summary
    Description: TypeScript coding conventions...

Create a Standard

See create a standard from the CLI to discover how you can create standards using the CLI.

Commands Command

Create and manage reusable, multi-step workflow commands from the command line.

List Commands

packmind-cli commands list

This command displays all commands in your Packmind organization, showing:

Slug — The command identifier
Name — The display name
URL — Direct link to view the command in the web app

Example output:

Available commands:

- add-a-new-rest-endpoint
    Name: Add a New REST Endpoint
    URL: https://app.packmind.com/org/my-org/space/global/commands/abc123

- setup-database-migration
    Name: Setup Database Migration
    URL: https://app.packmind.com/org/my-org/space/global/commands/def456

Create a Command

packmind-cli playbook add path/to-command.md
packmind-cli playbook submit

The markdown file content will be used as the command’s prompt. The name of the command will be deduced from the file path.

The command markdown should be located in a directory where commands are available.Such directories include:

.packmind/commands
.cursor/commands
.github/prompts

Packages Command

Create and manage packages from the command line.

List Packages

packmind-cli packages list

This command displays all packages in your Packmind organization, showing:

Slug — The package identifier
Name — The display name

Create a Package

packmind-cli packages create <name>

Arguments:

<name> - Name of the package to create

Options:

Flag	Short	Description
`--description`	`-d`	Description of the package

Example:

packmind-cli packages create "Backend Standards"

With a description:

packmind-cli packages create "Backend Standards" -d "Standards and commands for backend development"

This creates a new empty package in your Packmind organization. After creation, you can add commands, standards, and skills to the package through the web interface or by using the packages add command.

Package Identification

When you create a package, Packmind automatically generates a slug from the package name:

Name (provided by you): "Backend Standards"
Slug (auto-generated): "backend-standards"

The slug is used for:

Package installation: packmind-cli install backend-standards
Package identification and distribution

If a package with the same slug already exists in your space, Packmind appends a counter (e.g., backend-standards-1) to ensure uniqueness.

Add Items to a Package

packmind-cli packages add --to <package-slug> --standard <standard-slug>
packmind-cli packages add --to <package-slug> --command <command-slug>
packmind-cli packages add --to <package-slug> --skill <skill-slug>

Options:

Flag	Description
`--to`	Target package slug (required)
`--standard`	Slug of the standard to add to the package
`--command`	Slug of the command to add to the package
`--skill`	Slug of the skill to add to the package

Examples: Add a standard to a package:

packmind-cli packages add --to backend --standard error-handling

Add a command to a package:

packmind-cli packages add --to backend --command create-api-endpoint

Add a skill to a package:

packmind-cli packages add --to backend --skill debugging-workflow

Workflow tip — Use this command after creating standards, commands, or skills via CLI to organize them into packages. This is particularly useful when automating package management in scripts or CI/CD pipelines.

Plugins Command

Publish a Packmind package as a Claude Code plugin so its commands and skills can be installed directly into Claude Code, either from your own Claude marketplace or as a standalone plugin repository. A rendered plugin contains the package’s commands (as Claude slash commands) and skills (as Claude skills). Standards are not rendered because Claude plugins do not support them — when a package contains standards, the CLI reports how many were skipped.

Choose Your Workspace Mode

The plugins commands detect what kind of workspace you are in by looking inside the .claude-plugin/ directory:

File present	Mode	Use case
`.claude-plugin/marketplace.json`	Marketplace	A repository that hosts multiple plugins, each under `plugins/<plugin-name>/`
`.claude-plugin/plugin.json`	Standalone	A repository that contains a single plugin at its root
Neither	Not supported	The CLI exits with an error asking you to create one of the manifests first

Setting up a marketplace — Create a .claude-plugin/marketplace.json file at the root of a Git repository with the shape { "name": "<marketplace-name>", "owner": { "name": "<your-name>" }, "plugins": [] }. The CLI fills in the plugins array for you as you render packages. See Anthropic’s marketplace documentation for the full schema.

Setting up a standalone plugin — Create a .claude-plugin/plugin.json file at the root of a Git repository with at least { "name": "<plugin-name>" }. The plugin name must match the package slug you intend to render.

Plugins Render

Render a Packmind package as a Claude plugin in the current workspace.

packmind-cli plugins render <package-slug>

Arguments:

<package-slug> — Slug of the package to render (for example, security or @my-space/security)

Marketplace Workflow

Run the command from the root of your marketplace repository (the directory that contains .claude-plugin/marketplace.json):

packmind-cli plugins render security

The CLI will:

Download the package’s commands and skills from your Packmind organization
Write them under plugins/security/ (commands in plugins/security/commands/, skills in plugins/security/skills/)
Add or update the plugin entry inside .claude-plugin/marketplace.json, pointing source to ./plugins/security

Example output:

Rendered 12 files into ./plugins/security/
Skipped 3 standards (not supported in Claude plugins).
Updated .claude-plugin/marketplace.json

When the same plugin is rendered again, the CLI asks for confirmation before overwriting:

Plugin "security" already exists at "./plugins/security". Overwrite? [y/N]

Standalone Workflow

Run the command from the root of your standalone plugin repository (the directory that contains .claude-plugin/plugin.json):

packmind-cli plugins render security

The CLI will:

Verify that the package slug matches the name field declared in plugin.json
Download the package’s commands and skills
Write them directly at the repository root (commands/ and skills/)

Because a standalone repository already represents the plugin, the CLI always asks for confirmation before overwriting existing files:

Plugin "security" already exists in this workspace. Overwrite? [y/N]

Git remote detected automatically — When the workspace is a Git repository with a remote, the CLI captures the remote URL and current branch and sends them to Packmind so the distribution is tracked alongside your other deployments.

Plugins Delete

Remove a rendered plugin from the current workspace and notify Packmind that the distribution has been deleted.

packmind-cli plugins delete <package-slug>

Arguments:

<package-slug> — Slug of the plugin to delete (matches the package slug used during render)

Marketplace Workflow

Run the command from the root of your marketplace repository:

packmind-cli plugins delete security

The CLI will:

Locate the plugin entry in .claude-plugin/marketplace.json

Ask for confirmation:

Remove ./plugins/security and update marketplace.json for plugin "security"? [y/N]

Delete the plugin directory (for example, ./plugins/security) and remove its entry from marketplace.json

If the plugin is not declared in marketplace.json, the command exits without changes:

Plugin "security" is not declared in marketplace.json. Nothing to delete.

Standalone Workflow

Run the command from the root of your standalone plugin repository:

packmind-cli plugins delete security

After confirmation, the CLI removes the rendered commands/ and skills/ directories. The .claude-plugin/plugin.json manifest is left untouched so you can re-render the plugin later.

Troubleshooting

Problem: No .claude-plugin/marketplace.json or .claude-plugin/plugin.json found in this directory.
Solution: Run the command from the root of a workspace that contains one of these manifests. Create the appropriate manifest first if the workspace is brand new.
Problem: The plugin '<name>' is not handled in this repo. (standalone mode)
Solution: The package slug you passed does not match the name declared in .claude-plugin/plugin.json. Update the manifest or pass the matching slug.
Problem: Plugin "<name>" has a remote source. Run this command in the workspace of the remote plugin.
Solution: The marketplace entry points to a remote source (for example, a GitHub repository) rather than a local folder. Switch to the workspace that owns the remote plugin and run the command there.
Problem: Some content from the package is missing in the rendered plugin.
Solution: Standards are intentionally skipped because Claude plugins do not support them. Check the Skipped N standards line in the command output to see how many were excluded.

Playbook Command

Manage local artifact changes and propose them to your team using a git-like staging workflow. The playbook command groups six subcommands: diff, status, add, rm, unstage, and submit.

View Differences

packmind-cli playbook diff

Compares your local artifact files (standards, commands, skills) against the versions published in Packmind. No changes are submitted. Example output:

Standard: Error Handling

  Rule (update)
  - Validate inputs at system boundaries and fail fast
  + Validate inputs at system boundaries, fail fast, and log the context

  Rule (add)
  + Preserve context when rethrowing errors

  Rule (delete)
  - Avoid swallowing exceptions silently

For each standard, the diff shows:

Rule (update) — a rule that was modified (Packmind detects this automatically using similarity matching)
Rule (add) — a new rule added locally
Rule (delete) — a rule removed locally

Options:

Flag	Short	Description
`--include-submitted`		Include already-submitted changes in the output
`--path <path>`	`-p`	Limit analysis to a specific path

Check Status

packmind-cli playbook status

Shows staged changes ready for submission and untracked local modifications. Example output:

Changes to be submitted:
  - Standard "Error Handling" (updated)
    .claude/rules/error-handling.md

Changes not tracked:
  - Command "Deploy" (modified)
    .claude/commands/deploy.md

Use `packmind playbook add <path>` to track them

Stage Changes

packmind-cli playbook add <path>

Stages a local artifact change for submission. The change type (created or updated) is detected automatically by comparing with the deployed version.

Stage Removal

packmind-cli playbook rm <path>

Stages an artifact for removal from the playbook. The artifact must have been distributed by Packmind. Alias: remove.

Unstage Changes

packmind-cli playbook unstage <path>

Removes a previously staged change from the playbook without submitting it.

Submit Proposals

packmind-cli playbook submit -m "Improve error handling rules for better observability"

Submits all staged changes as change proposals for team review in the Packmind web app.

Flag	Short	Description
`--message <text>`	`-m`	Message describing the intent behind the changes (max 1024 chars)

If you omit -m, Packmind opens your default editor so you can write the message interactively.

How Rule Updates Are Detected

When you modify a rule in a standard file, Packmind automatically determines whether the change is a rule update (the same rule was edited) or a separate deletion and addition (two unrelated rules). This keeps your change proposals clean and meaningful, showing reviewers exactly what was changed rather than an unrelated delete + add pair.

Requires a git repository — The playbook command requires your project to be in a git repository with a configured remote. Make sure you have run packmind-cli install to set up your packmind.json before using playbook.

Update Command

Update the Packmind CLI to the latest version.

packmind-cli update

This checks for a newer version and updates the CLI in place:

Standalone executable — Downloads the latest binary from GitHub and replaces the current executable automatically.
npm global install — Runs npm install -g @packmind/cli@latest to update through npm.

Example output:

Current version: 1.2.0 (standalone executable)
New version available: 1.2.0 -> 1.3.0
Downloading packmind-cli-macos-arm64...
Downloaded successfully (12.4 MB)

Updated to v1.3.0
Binary location: /usr/local/bin/packmind-cli

If you are already on the latest version:

Already up to date (v1.3.0)

Permission error on Linux/macOS — If you see a permission denied error, run the command with sudo:

sudo packmind-cli update

Check for Updates Without Installing

Use the --check flag to see if a newer version is available without performing the update:

packmind-cli update --check

This is useful in CI/CD pipelines or scripts where you want to detect outdated CLI versions without automatically upgrading. The command exits with code 1 if a newer version is available, and code 0 if already up to date. Example:

if ! packmind-cli update --check; then
  echo "A new version of packmind-cli is available. Run 'packmind-cli update' to upgrade."
fi

The update command is available for standalone executables and npm global installs only. If you manage the CLI through a local package.json, update it with npm update @packmind/cli instead.

Create your first command: Learn how to create commands with AI assistance
Packages Management: Learn about organizing commands, standards, and skills into packages
Linter: Automated Detection: Learn about how detection programs work
Standards Management: Create rules and add code examples
Skills Management: Create and manage reusable skills

​Overview

​Installation

​One-click install (Recommended)

​Alternative: npm Package

​Alternative: Homebrew

​Alternative: Standalone Executables

​Authentication

​Login Command (Recommended)

​Logout Command

​Whoami Command

​API Key Authentication (PACKMIND_API_KEY_V3)

​Getting Your API Key

​Setting the Environment Variable

​CI/CD Example (GitHub Actions)

​Init Command

​What Init Does

​Basic Usage

​Config Command

​Config Agents

​Config Agents Setup

​Config Agents List

​Config Agents Add

​Config Agents Remove

​Supported Agents

​Install Command

​List Available Packages

​View Package Details

​View Workspace Status

​Install Packages

​Lock File (packmind-lock.json)

​Recursive Install (Monorepos)

​Install Globally for Claude Code (~/.claude)

​Lint Command

​How Lint Works

​Basic Usage

​Specify a Path

​Limiting Scope with --changed-files and --changed-lines

​Output Formats

​Filtering by Severity

​Skills Command

​Initialize Default Skills

​List Skills

​Add a Skill

​Standards Command

​List Standards

​Create a Standard

​Commands Command

​List Commands

​Create a Command

​Packages Command

​List Packages

​Create a Package

​Package Identification

​Add Items to a Package

​Plugins Command

​Choose Your Workspace Mode

​Plugins Render

​Marketplace Workflow

​Standalone Workflow

​Plugins Delete

​Marketplace Workflow

​Standalone Workflow

​Troubleshooting

​Playbook Command

​View Differences

​Check Status

​Stage Changes

​Stage Removal

​Unstage Changes

​Submit Proposals

​How Rule Updates Are Detected

​Update Command

​Check for Updates Without Installing

​Related Documentation

Overview

Installation

One-click install (Recommended)

Alternative: npm Package

Alternative: Homebrew

Alternative: Standalone Executables

Authentication

Login Command (Recommended)

Logout Command

Whoami Command

API Key Authentication (PACKMIND_API_KEY_V3)

Getting Your API Key

Setting the Environment Variable

CI/CD Example (GitHub Actions)

Init Command

What Init Does

Basic Usage

Config Command

Config Agents

Config Agents Setup

Config Agents List

Config Agents Add

Config Agents Remove

Supported Agents

Install Command

List Available Packages

View Package Details

View Workspace Status

Install Packages

Lock File (`packmind-lock.json`)

Recursive Install (Monorepos)

Install Globally for Claude Code (`~/.claude`)

Lint Command

How Lint Works

Basic Usage

Specify a Path

Limiting Scope with `--changed-files` and `--changed-lines`

Output Formats

Filtering by Severity

Skills Command

Initialize Default Skills

List Skills

Add a Skill

Standards Command

List Standards

Create a Standard

Commands Command

List Commands

Create a Command

Packages Command

List Packages

Create a Package

Package Identification

Add Items to a Package

Plugins Command

Choose Your Workspace Mode

Plugins Render

Marketplace Workflow

Standalone Workflow

Plugins Delete

Marketplace Workflow

Standalone Workflow

Troubleshooting

Playbook Command

View Differences

Check Status

Stage Changes

Stage Removal

Unstage Changes

Submit Proposals

How Rule Updates Are Detected

Update Command

Check for Updates Without Installing

Related Documentation