### Install a plugin using CLI

Source: https://code.claude.com/docs/en/plugins-reference

Use the `plugin install` command to add plugins from marketplaces. Specify the plugin name and optionally the marketplace. The scope option determines where the plugin is enabled.

```bash
claude plugin install <plugin> [options]
```

```bash
# Install to user scope (default)
claude plugin install formatter@my-marketplace
```

```bash
# Install to project scope (shared with team)
claude plugin install formatter@my-marketplace --scope project
```

```bash
# Install to local scope (gitignored)
claude plugin install formatter@my-marketplace --scope local
```

--------------------------------

### Example Plugin Details Output

Source: https://code.claude.com/docs/en/plugins-reference

This is an example of the output format for `claude plugin details`, showing component inventory and projected token costs for a plugin with two skills.

```text
security-guidance 1.2.0
  Real-time security analysis for Claude Code sessions
  Source: security-guidance@claude-code-marketplace

Component inventory
  Skills (2)  scan-dependencies, review-changes
  Agents (0)
  Hooks (1)  (harness-only — no model context cost)
  MCP servers (0)
  LSP servers (0)

Projected token cost
  Always-on:   ~180 tok   added to every session

Per-component (rounded)
  component            always-on  on-invoke
  scan-dependencies        ~100      ~2400
  review-changes            ~80      ~1800

  On-invoke cost is paid each time a skill or agent fires.
  Token counts are estimates and may differ from actual usage.
```

--------------------------------

### Install Community Marketplace Plugin

Source: https://code.claude.com/docs/en/plugins

Use this command to add the community marketplace to your available plugins.

```bash
claude plugin marketplace add anthropics/claude-plugins-community
```

--------------------------------

### List Installed Claude Plugins

Source: https://code.claude.com/docs/en/plugins-reference

Use this command to view all installed plugins, their versions, sources, and whether they are enabled. The `--json` option provides structured output.

```bash
claude plugin list [options]
```

--------------------------------

### Install Node Modules on Session Start - JSON

Source: https://code.claude.com/docs/en/plugins-reference

This hook installs node_modules on the first run and again when a plugin update includes a changed package.json. It uses diff to compare manifests and npm install for installation.

```json
{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "diff -q \"${CLAUDE_PLUGIN_ROOT}/package.json\" \"${CLAUDE_PLUGIN_DATA}/package.json\" >/dev/null 2>&1 || (cd \"${CLAUDE_PLUGIN_DATA}\" && cp \"${CLAUDE_PLUGIN_ROOT}/package.json\" . && npm install) || rm -f \"${CLAUDE_PLUGIN_DATA}/package.json\""
          }
        ]
      }
    ]
  }
}
```

--------------------------------

### claude plugin install

Source: https://code.claude.com/docs/en/plugins-reference

Installs a plugin from available marketplaces. You can specify a plugin name or a name with a marketplace, and choose an installation scope.

```APIDOC
## claude plugin install

### Description
Installs a plugin from available marketplaces.

### Method
CLI Command

### Endpoint
`claude plugin install <plugin> [options]`

### Parameters
#### Path Parameters
- **plugin** (string) - Required - Plugin name or `plugin-name@marketplace-name` for a specific marketplace

#### Query Parameters
- **-s, --scope** (string) - Optional - Installation scope: `user`, `project`, or `local`. Defaults to `user`.
- **-h, --help** (boolean) - Optional - Display help for command

### Request Example
```bash
claude plugin install formatter@my-marketplace
claude plugin install formatter@my-marketplace --scope project
claude plugin install formatter@my-marketplace --scope local
```
```

--------------------------------

### Configure an LSP server for your plugin

Source: https://code.claude.com/docs/en/plugins

LSP plugins provide real-time code intelligence. Create a custom LSP plugin by adding an `.lsp.json` file to your plugin root if a pre-built one is not available for your language. Users must have the language server binary installed.

```json
{
  "go": {
    "command": "gopls",
    "args": ["serve"],
    "extensionToLanguage": {
      ".go": "go"
    }
  }
}
```

--------------------------------

### Configure LSP Server Inline in plugin.json

Source: https://code.claude.com/docs/en/plugins-reference

Alternatively, configure LSP servers directly within the plugin.json file. Ensure the language server binary is installed separately and accessible in the system's PATH.

```json
{
  "name": "my-plugin",
  "lspServers": {
    "go": {
      "command": "gopls",
      "args": ["serve"],
      "extensionToLanguage": {
        ".go": "go"
      }
    }
  }
}
```

--------------------------------

### Load Multiple Local Plugins

Source: https://code.claude.com/docs/en/plugins

Specify the --plugin-dir flag multiple times to load several local plugins simultaneously. The local plugin takes precedence over installed marketplace plugins of the same name.

```bash
claude --plugin-dir ./plugin-one --plugin-dir ./plugin-two
```

--------------------------------

### Configure MCP Servers in Plugin

Source: https://code.claude.com/docs/en/plugins-reference

Define MCP servers in a .mcp.json file or inline in plugin.json. These servers automatically start when the plugin is enabled and appear as standard tools in Claude's toolkit.

```json
{
  "mcpServers": {
    "plugin-database": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
      "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],
      "env": {
        "DB_PATH": "${CLAUDE_PLUGIN_ROOT}/data"
      }
    },
    "plugin-api-client": {
      "command": "npx",
      "args": ["@company/mcp-server", "--plugin-mode"],
      "cwd": "${CLAUDE_PLUGIN_ROOT}"
    }
  }
}
```

--------------------------------

### Test Local Plugin Directory

Source: https://code.claude.com/docs/en/plugins

Use the --plugin-dir flag to load a local plugin directory for testing without installation. This flag can also accept a .zip archive of the plugin directory.

```bash
claude --plugin-dir ./my-plugin
```

```bash
claude --plugin-dir ./my-plugin.zip
```

--------------------------------

### Get Claude Plugin Details

Source: https://code.claude.com/docs/en/plugins-reference

Retrieve detailed information about a specific plugin, including its component inventory and projected token costs. Specify the plugin by name or by name@marketplace.

```bash
claude plugin details <name>
```

--------------------------------

### plugin enable

Source: https://code.claude.com/docs/en/plugins-reference

Enable a disabled plugin. If the plugin declares dependencies, Claude Code enables them transitively at the same scope. The command fails if a dependency is not installed.

```APIDOC
## plugin enable

### Description
Enable a disabled plugin.

### Method
CLI Command

### Endpoint
`claude plugin enable <plugin> [options]`

### Parameters
#### Arguments
- **<plugin>** (string) - Required - Plugin name or `plugin-name@marketplace-name`

#### Options
- **-s, --scope <scope>** (string) - Optional - Scope to enable: `user`, `project`, or `local`. Default: `user`
- **-h, --help** - Optional - Display help for command.
```

--------------------------------

### plugin prune

Source: https://code.claude.com/docs/en/plugins-reference

Remove auto-installed plugin dependencies that are no longer required by any installed plugin. This command requires Claude Code v2.1.121 or later.

```APIDOC
## plugin prune

### Description
Remove auto-installed plugin dependencies that are no longer required by any installed plugin.

### Method
CLI Command

### Endpoint
`claude plugin prune [options]`

### Parameters
#### Options
- **-s, --scope <scope>** (string) - Optional - Prune at scope: `user`, `project`, or `local`. Default: `user`
- **--dry-run** - Optional - List what would be removed without removing anything.
- **-y, --yes** - Optional - Skip the confirmation prompt. Required when stdin or stdout is not a TTY.
- **-h, --help** - Optional - Display help for command.

### Aliases
`autoremove`

### Note
`claude plugin prune` requires Claude Code v2.1.121 or later.
```

--------------------------------

### plugin uninstall

Source: https://code.claude.com/docs/en/plugins-reference

Remove an installed plugin. By default, uninstalling from the last remaining scope also deletes the plugin's data directory. Use `--keep-data` to preserve it.

```APIDOC
## plugin uninstall

### Description
Remove an installed plugin.

### Method
CLI Command

### Endpoint
`claude plugin uninstall <plugin> [options]`

### Parameters
#### Arguments
- **<plugin>** (string) - Required - Plugin name or `plugin-name@marketplace-name`

#### Options
- **-s, --scope <scope>** (string) - Optional - Uninstall from scope: `user`, `project`, or `local`. Default: `user`
- **--keep-data** - Optional - Preserve the plugin's persistent data directory.
- **--prune** - Optional - Also remove auto-installed dependencies that no other plugin requires.
- **-y, --yes** - Optional - Skip the `--prune` confirmation prompt. Required when stdin or stdout is not a TTY.
- **-h, --help** - Optional - Display help for command.

### Aliases
`remove`, `rm`
```

--------------------------------

### Enable a Disabled Claude Code Plugin

Source: https://code.claude.com/docs/en/plugins-reference

Enables a plugin that was previously disabled. If the plugin has dependencies, they will also be enabled at the same scope. The command will fail if a required dependency is not installed.

```bash
claude plugin enable <plugin> [options]
```

--------------------------------

### Uninstall a Claude Code Plugin

Source: https://code.claude.com/docs/en/plugins-reference

Use this command to remove an installed plugin. By default, uninstalling also deletes the plugin's data directory unless `--keep-data` is specified. The `--prune` option can be used to remove unused dependencies in one step.

```bash
claude plugin uninstall <plugin> [options]
```

--------------------------------

### Prune Unused Plugin Dependencies

Source: https://code.claude.com/docs/en/plugins-reference

Removes auto-installed plugin dependencies that are no longer required by any installed plugin. This command requires Claude Code v2.1.121 or later. Use `--dry-run` to see what would be removed without making changes.

```bash
claude plugin prune [options]
```

--------------------------------

### Create Plugin Directory Structure

Source: https://code.claude.com/docs/en/plugins

Initialize a new plugin by creating its directory and the manifest file.

```bash
mkdir -p my-plugin/.claude-plugin
```

--------------------------------

### Create Plugin Directory

Source: https://code.claude.com/docs/en/plugins

Use this command to create the root directory for your plugin.

```bash
mkdir my-first-plugin
```

--------------------------------

### Test Plugin from URL

Source: https://code.claude.com/docs/en/plugins

Use the --plugin-url flag to load a plugin packaged as a .zip archive hosted at a URL. Claude Code fetches and loads the archive at startup.

```bash
claude --plugin-url https://example.com/my-plugin.zip --plugin-url https://example.com/other.zip
```

```bash
claude --plugin-url "https://example.com/my-plugin.zip https://example.com/other.zip"
```

--------------------------------

### Load and Test Migrated Plugin

Source: https://code.claude.com/docs/en/plugins

Load your newly created plugin using the specified directory and test its components.

```bash
claude --plugin-dir ./my-plugin
```

--------------------------------

### Create Plugin Hooks Directory

Source: https://code.claude.com/docs/en/plugins

Prepare the directory structure for migrating hooks into your plugin.

```bash
mkdir my-plugin/hooks
```

--------------------------------

### Load and Test Plugin

Source: https://code.claude.com/docs/en/plugins

Run Claude Code with the `--plugin-dir` flag to load your plugin. Then, invoke your skill using its namespaced name.

```bash
claude --plugin-dir ./my-first-plugin
```

```shell
/my-first-plugin:hello
```

--------------------------------

### Copy Existing Skills to Plugin

Source: https://code.claude.com/docs/en/plugins

Migrate your standalone skills into the plugin's skill directory.

```bash
# Copy skills (if any)
cp -r .claude/skills my-plugin/
```

--------------------------------

### Create Plugin Manifest File

Source: https://code.claude.com/docs/en/plugins

Define the basic metadata for your plugin in the plugin.json file.

```json
{
  "name": "my-plugin",
  "description": "Migrated from standalone configuration",
  "version": "1.0.0"
}
```

--------------------------------

### Copy Existing Commands to Plugin

Source: https://code.claude.com/docs/en/plugins

Migrate your standalone commands into the plugin's command directory.

```bash
# Copy commands
cp -r .claude/commands my-plugin/
```

--------------------------------

### Create Skill Directory

Source: https://code.claude.com/docs/en/plugins

Use this command to create the directory structure for a new skill within your plugin. The `-p` flag ensures parent directories are created if they don't exist.

```bash
mkdir -p my-first-plugin/skills/hello
```

--------------------------------

### Create Plugin Manifest Directory

Source: https://code.claude.com/docs/en/plugins

Create the hidden directory where the plugin manifest will reside.

```bash
mkdir my-first-plugin/.claude-plugin
```

--------------------------------

### Create Symbolic Link - Bash

Source: https://code.claude.com/docs/en/plugins-reference

Creates a symbolic link from inside a marketplace plugin to a shared skill defined by a sibling plugin. On Windows, use mklink /D from an elevated Command Prompt or enable Developer Mode.

```bash
ln -s ../../shared-plugin/skills/foo ./skills/foo
```

--------------------------------

### Copy Existing Agents to Plugin

Source: https://code.claude.com/docs/en/plugins

Migrate your standalone agents into the plugin's agent directory.

```bash
# Copy agents (if any)
cp -r .claude/agents my-plugin/
```

--------------------------------

### Test Skill with Arguments

Source: https://code.claude.com/docs/en/plugins

After reloading plugins, invoke your skill with a name to see the personalized greeting.

```shell
/my-first-plugin:hello Alex
```

--------------------------------

### Custom Path Configuration for Commands and Agents

Source: https://code.claude.com/docs/en/plugins-reference

Specify custom paths for commands and agents to replace default directories. Multiple paths can be listed as an array.

```json
{
  "commands": [
    "./specialized/deploy.md",
    "./utilities/batch-process.md"
  ],
  "agents": [
    "./custom-agents/reviewer.md",
    "./custom-agents/tester.md"
  ]
}
```

--------------------------------

### Migrate Hooks Configuration

Source: https://code.claude.com/docs/en/plugins

Copy your hooks configuration from settings.json to the plugin's hooks.json. Use jq to process stdin for command inputs.

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [{ "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npm run lint:fix" }]
      }
    ]
  }
}
```

--------------------------------

### Correct Plugin Directory Structure

Source: https://code.claude.com/docs/en/plugins-reference

Ensure that commands, agents, and hooks are located at the plugin root level, not within the `.claude-plugin/` directory. Only `plugin.json` should reside in `.claude-plugin/`.

```text
my-plugin/
├── .claude-plugin/
│   └── plugin.json      ← Only manifest here
├── commands/            ← At root level
├── agents/              ← At root level
└── hooks/               ← At root level
```

--------------------------------

### Configure background monitors for your plugin

Source: https://code.claude.com/docs/en/plugins

Background monitors allow your plugin to watch logs, files, or external statuses and notify Claude of events. Configure monitors in a `monitors/monitors.json` file at the plugin root. Each stdout line from the command is delivered as a notification.

```json
[
  {
    "name": "error-log",
    "command": "tail -F ./logs/error.log",
    "description": "Application error log"
  }
]
```

--------------------------------

### Skill Directory Structure

Source: https://code.claude.com/docs/en/plugins-reference

Illustrates the expected file and directory structure for a plugin skill. Skills are typically located in the 'skills/' or 'commands/' directory.

```text
skills/
├── pdf-processor/
│   ├── SKILL.md
│   ├── reference.md (optional)
│   └── scripts/ (optional)
└── code-reviewer/
    └── SKILL.md
```

--------------------------------

### Define Plugin Monitors in monitors.json

Source: https://code.claude.com/docs/en/plugins-reference

Configure background shell commands to run persistently. Use this to watch log files or poll endpoints for status updates. The 'when' field controls activation timing.

```json
[
  {
    "name": "deploy-status",
    "command": "${CLAUDE_PLUGIN_ROOT}/scripts/poll-deploy.sh ${user_config.api_endpoint}",
    "description": "Deployment status changes"
  },
  {
    "name": "error-log",
    "command": "tail -F ./logs/error.log",
    "description": "Application error log",
    "when": "on-skill-invoke:debug"
  }
]
```

--------------------------------

### Set Default Agent in Plugin Settings

Source: https://code.claude.com/docs/en/plugins

Use a settings.json file at the plugin root to define default configurations, such as activating a specific agent when the plugin is enabled. Keys in settings.json take precedence over those in plugin.json.

```json
{
  "agent": "security-reviewer"
}
```

--------------------------------

### Define a Simple Skill

Source: https://code.claude.com/docs/en/plugins

The `SKILL.md` file defines the skill's behavior and description. `disable-model-invocation: true` prevents Claude from generating a response and instead uses the static content.

```markdown
---
description: Greet the user with a friendly message
disable-model-invocation: true
---

Greet the user warmly and ask how you can help them today.
```

--------------------------------

### Debug Claude Plugin Loading

Source: https://code.claude.com/docs/en/plugins-reference

Enable detailed logging for plugin loading by running the `claude` command with the `--debug` flag. This helps identify issues with plugin manifests, registration, and initialization.

```bash
claude --debug
```

--------------------------------

### Add Skill Arguments

Source: https://code.claude.com/docs/en/plugins

Update your `SKILL.md` to include the `$ARGUMENTS` placeholder, allowing your skill to accept and use user input for personalization.

```markdown
---
description: Greet the user with a personalized message
---

# Hello Skill

Greet the user named "$ARGUMENTS" warmly and ask how you can help them today. Make the greeting personal and encouraging.
```

--------------------------------

### Add a Skill to your plugin

Source: https://code.claude.com/docs/en/plugins

Skills are model-invoked and extend Claude's capabilities. They require a `skills/` directory with Skill folders containing `SKILL.md` files, including a `description` for Claude to understand when to use the skill.

```text
my-plugin/
├── .claude-plugin/
│   └── plugin.json
└── skills/
    └── code-review/
        └── SKILL.md
```

```yaml
---
description: Reviews code for best practices and potential issues. Use when reviewing code, checking PRs, or analyzing code quality.
---

When reviewing code, check for:
1. Code organization and structure
2. Error handling
3. Security concerns
4. Test coverage
```

--------------------------------

### Configure Plugin Channels

Source: https://code.claude.com/docs/en/plugins-reference

The `channels` field allows a plugin to declare message channels that inject content into the conversation, binding to an MCP server provided by the plugin. Per-channel `userConfig` can prompt for specific credentials like bot tokens.

```json
{
  "channels": [
    {
      "server": "telegram",
      "userConfig": {
        "bot_token": {
          "type": "string",
          "title": "Bot token",
          "description": "Telegram bot token",
          "sensitive": true
        },
        "owner_id": {
          "type": "string",
          "title": "Owner ID",
          "description": "Your Telegram user ID"
        }
      }
    }
  ]
}
```

--------------------------------

### Tag Claude Plugin Release

Source: https://code.claude.com/docs/en/plugins-reference

Create a Git tag for a plugin release. This command should be run from within the plugin's directory. Use `--push` to also push the tag to the remote repository.

```bash
claude plugin tag [options]
```

--------------------------------

### Define Plugin Manifest

Source: https://code.claude.com/docs/en/plugins

The `plugin.json` file defines your plugin's identity, including its name, description, and version. This metadata is used by Claude Code to display and manage your plugin.

```json
{
  "name": "my-first-plugin",
  "description": "A greeting plugin to learn the basics",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}
```

--------------------------------

### Define Plugin Color Theme

Source: https://code.claude.com/docs/en/plugins-reference

Create a custom color theme for the Claude Code IDE. Specify a base theme and override specific color tokens. This allows for personalized IDE aesthetics.

```json
{
  "name": "Dracula",
  "base": "dark",
  "overrides": {
    "claude": "#bd93f9",
    "error": "#ff5555",
    "success": "#50fa7b"
  }
}
```

--------------------------------

### Define User Configuration Schema

Source: https://code.claude.com/docs/en/plugins-reference

Use the `userConfig` field to declare values Claude Code prompts the user for when a plugin is enabled. This avoids manual editing of `settings.json`.

```json
{
  "userConfig": {
    "api_endpoint": {
      "type": "string",
      "title": "API endpoint",
      "description": "Your team's API endpoint"
    },
    "api_token": {
      "type": "string",
      "title": "API token",
      "description": "API authentication token",
      "sensitive": true
    }
  }
}
```

--------------------------------

### Validate Plugin Locally

Source: https://code.claude.com/docs/en/plugins

Run this command to validate your plugin locally before submission. The review pipeline uses the same check.

```bash
claude plugin validate
```

--------------------------------

### Make Hook Script Executable

Source: https://code.claude.com/docs/en/plugins-reference

Ensure your hook script has execute permissions. This is a common cause for hook scripts not running.

```bash
chmod +x script.sh
```

--------------------------------

### Verify Hook Script Shebang

Source: https://code.claude.com/docs/en/plugins-reference

The first line of your hook script must be a valid shebang, specifying the interpreter. Use `#!/bin/bash` or `#!/usr/bin/env bash`.

```bash
#!/bin/bash
```

--------------------------------

### Using CLAUDE_PLUGIN_ROOT in Hook Commands

Source: https://code.claude.com/docs/en/plugins-reference

Reference scripts or binaries within the plugin directory using the `${CLAUDE_PLUGIN_ROOT}` environment variable. Ensure paths with spaces are quoted when used in shell-form hooks or monitor commands.

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/process.sh"
          }
        ]
      }
    ]
  }
}
```

--------------------------------

### Configure PostToolUse Hook in Plugin

Source: https://code.claude.com/docs/en/plugins-reference

This JSON configuration defines a hook that triggers on 'PostToolUse' events, specifically when the matcher is 'Write' or 'Edit'. It executes a shell script for code formatting.

```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/format-code.sh"
          }
        ]
      }
    ]
  }
}
```

--------------------------------

### Configure Node Path for Plugin Server - JSON

Source: https://code.claude.com/docs/en/plugins-reference

Configures the NODE_PATH environment variable to point to the persisted node_modules directory, allowing scripts to run against them.

```json
{
  "mcpServers": {
    "routines": {
      "command": "node",
      "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"],
      "env": {
        "NODE_PATH": "${CLAUDE_PLUGIN_DATA}/node_modules"
      }
    }
  }
}
```

--------------------------------

### Test Hook Script Manually

Source: https://code.claude.com/docs/en/plugins-reference

Before relying on the hook system, test your script directly from the command line to isolate execution issues.

```bash
./scripts/your-script.sh
```

--------------------------------

### Use CLAUDE_PLUGIN_ROOT for Hook Paths

Source: https://code.claude.com/docs/en/plugins-reference

When referencing scripts or files within your plugin from a hook, always use the `${CLAUDE_PLUGIN_ROOT}` variable to ensure correct path resolution.

```json
"command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/your-script.sh"
```

--------------------------------

### Agent Configuration Frontmatter

Source: https://code.claude.com/docs/en/plugins-reference

Defines the frontmatter fields for a plugin agent. These fields specify the agent's name, description, model, and other operational parameters.

```markdown
---
name: agent-name
description: What this agent specializes in and when Claude should invoke it
model: sonnet
effort: medium
maxTurns: 20
disallowedTools: Write, Edit
---

Detailed system prompt for the agent describing its role, expertise, and behavior.
```

--------------------------------

### Complete Plugin Manifest Schema

Source: https://code.claude.com/docs/en/plugins-reference

Defines the metadata and configuration for a Claude Code plugin. Use this schema to specify plugin details like name, version, author, dependencies, and custom component paths.

```json
{
  "name": "plugin-name",
  "displayName": "Plugin Name",
  "version": "1.2.0",
  "description": "Brief plugin description",
  "author": {
    "name": "Author Name",
    "email": "author@example.com",
    "url": "https://github.com/author"
  },
  "homepage": "https://docs.example.com/plugin",
  "repository": "https://github.com/author/plugin",
  "license": "MIT",
  "keywords": ["keyword1", "keyword2"],
  "skills": "./custom/skills/",
  "commands": ["./custom/commands/special.md"],
  "agents": ["./custom/agents/reviewer.md"],
  "hooks": "./config/hooks.json",
  "mcpServers": "./mcp-config.json",
  "outputStyles": "./styles/",
  "lspServers": "./.lsp.json",
  "experimental": {
    "themes": "./themes/",
    "monitors": "./monitors.json"
  },
  "dependencies": [
    "helper-lib",
    { "name": "secrets-vault", "version": "~2.1.0" }
  ]
}
```

--------------------------------

### plugin update

Source: https://code.claude.com/docs/en/plugins-reference

Update a plugin to the latest version.

```APIDOC
## plugin update

### Description
Update a plugin to the latest version.

### Method
CLI Command

### Endpoint
`claude plugin update <plugin> [options]`

### Parameters
#### Arguments
- **<plugin>** (string) - Required - Plugin name or `plugin-name@marketplace-name`

#### Options
- **-s, --scope <scope>** (string) - Optional - Scope to update: `user`, `project`, `local`, or `managed`. Default: `user`
- **-h, --help** - Optional - Display help for command.
```

--------------------------------

### Validate Plugin with Strict Mode

Source: https://code.claude.com/docs/en/plugins-reference

Validates a plugin's manifest file, treating unrecognized fields as errors when the --strict flag is used. This is useful in CI to catch potential issues before publishing.

```bash
claude plugin validate ./my-plugin --strict
```

--------------------------------

### plugin disable

Source: https://code.claude.com/docs/en/plugins-reference

Disable a plugin without uninstalling it. This command fails if another enabled plugin depends on the target plugin. The error message includes a chained command that disables every dependent first.

```APIDOC
## plugin disable

### Description
Disable a plugin without uninstalling it.

### Method
CLI Command

### Endpoint
`claude plugin disable <plugin> [options]`

### Parameters
#### Arguments
- **<plugin>** (string) - Required - Plugin name or `plugin-name@marketplace-name`

#### Options
- **-s, --scope <scope>** (string) - Optional - Scope to disable: `user`, `project`, or `local`. Default: `user`
- **-h, --help** - Optional - Display help for command.
```

--------------------------------

### Update a Claude Code Plugin

Source: https://code.claude.com/docs/en/plugins-reference

Updates a specified plugin to its latest available version. The update can be performed across different scopes including 'user', 'project', 'local', and 'managed'.

```bash
claude plugin update <plugin> [options]
```

--------------------------------

### Disable a Claude Code Plugin

Source: https://code.claude.com/docs/en/plugins-reference

Disables a plugin without uninstalling it. This command will fail if another enabled plugin depends on the target plugin. The error message provides a chained command to disable dependents first.

```bash
claude plugin disable <plugin> [options]
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.