### Initialize and Setup DecisionNode Project

Source: https://decisionnode.dev/docs

After global installation, navigate to your project directory and initialize DecisionNode. Then, configure your Gemini API key using the setup command.

```bash
cd your-project
decide init
decide setup  # configure your Gemini API key
```

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

### Install and Initialize DecisionNode CLI

Source: https://decisionnode.dev/docs/quickstart

Install the DecisionNode CLI globally and initialize it in your project directory. This sets up the global decision store.

```bash
npm install -g decisionnode
cd your-project
decide init
```

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

### Verify Global Installation

Source: https://decisionnode.dev/docs/installation

Checks if the DecisionNode CLI is installed correctly and accessible by running the help command.

```bash
decide help
```

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

### Install DecisionNode Globally

Source: https://decisionnode.dev/docs/installation

Installs the DecisionNode CLI and related tools globally on your system. Recommended for regular use.

```bash
npm install -g decisionnode
```

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

### Troubleshoot Global Installation Permissions

Source: https://decisionnode.dev/docs/installation

Installs DecisionNode globally using sudo to overcome EACCES permission errors on macOS or Linux.

```bash
sudo npm install -g decisionnode
```

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

### Launch DecisionNode UI

Source: https://decisionnode.dev/docs/quickstart

Start the local web UI for DecisionNode to visualize decisions as a graph, vector space, and searchable list. The UI opens at `http://localhost:7788`.

```bash
decide ui
```

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

### Get Status Tool

Source: https://decisionnode.dev/docs/mcp

Retrieve a project overview, including the total number of decisions, active count, and the time of the last activity.

```python
get_status(project)
```

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

### Start DecisionNode MCP Server with Full Path

Source: https://decisionnode.dev/docs/mcp

Use this command if the AI client requires a full path to the MCP server executable. The command is `decide-mcp` with no arguments for other clients.

```bash
npx -y decisionnode start-server
```

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

### Launch Local Decision Visualization UI

Source: https://decisionnode.dev/docs/workflows

Start a local web interface to visualize decisions in a graph, vector space, or list view. Matched nodes pulse live in the color of the calling MCP client. The UI is read-only; writes are handled by the CLI and MCP server.

```bash
# Foreground (Ctrl+C to stop)
decide ui
```

```bash
# Background — return the terminal immediately
decide ui -d
```

```bash
decide ui status
```

```bash
decide ui stop
```

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

### Run DecisionNode via NPX

Source: https://decisionnode.dev/docs/installation

Executes the DecisionNode CLI temporarily without a permanent installation. Useful for trying out the tool.

```bash
npx decide help
```

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

### Search for Existing Conventions

Source: https://decisionnode.dev/docs/workflows

Use this command to search for existing conventions before starting new work. If the MCP server is connected, the AI performs this automatically based on agent behavior settings.

```bash
decide search "how do we handle error logging?"
```

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

### Decision Embedding Example

Source: https://decisionnode.dev/docs/context

Illustrates the format of text that gets embedded for a decision, combining its fields for semantic representation.

```text
"UI: Use Tailwind CSS for all styling. Consistent design tokens. No arbitrary values Use @apply only for base components"
```

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

### MCP Conflict Detection Response

Source: https://decisionnode.dev/docs/context

Example of a response when a new decision is added via MCP and conflicts with existing similar decisions. The decision is not added, and similar decisions are returned.

```json
{ "success": false, "reason": "similar_decisions_found", "similar": [ { "id": "ui-001", "decision": "Use Tailwind CSS...", "similarity": "89%" } ] }
```

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

### Get History Tool

Source: https://decisionnode.dev/docs/mcp

View the activity log of recent decision changes, including adds, edits, deletes, and syncs. A limit parameter can be specified.

```python
get_history(limit?, project)
```

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

### Get Decision Tool

Source: https://decisionnode.dev/docs/mcp

Retrieve full details of a specific decision by its ID. Supports global decisions by prefixing the ID with 'global:'.

```python
get_decision(id, project)
```

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

### Get Specific Decision

Source: https://decisionnode.dev/docs/cli

Retrieves a specific decision, including global decisions, using its ID.

```bash
decide get global:ui-001
```

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

### Initialize a New Project

Source: https://decisionnode.dev/docs/setup

Command to initialize a new project, which creates a dedicated folder for its configuration and data within the DecisionNode directory.

```bash
decide init
```

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

### Set Up Gemini API Key

Source: https://decisionnode.dev/docs/quickstart

Configure your Gemini API key for semantic search functionality. The key is saved to `~/.decisionnode/.env`.

```bash
decide setup
```

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

### Launch Local Web UI

Source: https://decisionnode.dev/docs/cli

Launches the local web interface for browsing and visualizing decisions. Defaults to port 7788, falls back to a random port if taken. Press Ctrl+C to stop.

```bash
decide ui [--port N] [--no-open]
```

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

### Launch DecisionNode UI in Background

Source: https://decisionnode.dev/docs/quickstart

Run the DecisionNode UI in the background, freeing up your terminal. Access it at `http://localhost:7788`.

```bash
decide ui -d
```

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

### List All Projects

Source: https://decisionnode.dev/docs/setup

Command to list all configured DecisionNode projects. The MCP server automatically resolves the correct project based on the current working directory.

```bash
decide projects
```

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

### Using decide and decisionnode Aliases

Source: https://decisionnode.dev/docs/cli

Demonstrates that `decide` and `decisionnode` are interchangeable aliases for the same command-line tool.

```bash
decide add          # short
decisionnode add    # same thing
```

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

### View and Configure DecisionNode

Source: https://decisionnode.dev/docs/cli

Displays the current DecisionNode configuration. Allows setting agent behavior (strict/relaxed) and search similarity thresholds.

```bash
decide config
```

```bash
decide config agent-behavior strict|relaxed
```

```bash
decide config search-threshold 0.0-1.0
```

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

### DecisionNode Storage Layout

Source: https://decisionnode.dev/docs/setup

Illustrates the default directory structure for DecisionNode data and configuration files within the user's home directory.

```bash
~/.decisionnode/
  .env                          # Gemini API key
  config.json                   # Global settings (agent behavior, threshold)
  .decisions/
    _global/                    # Global decisions (shared across all projects)
      ui.json
      vectors.json
    MyProject/
      ui.json                   # Decisions scoped to "UI"
      backend.json              # Decisions scoped to "Backend"
      vectors.json              # Embedding vectors for semantic search
      history/
        activity.json           # Audit log of all changes

```

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

### Run UI Server in Background

Source: https://decisionnode.dev/docs/cli

Runs the UI server in the background and returns the terminal immediately. Tracked via ~/.decisionnode/.ui-daemon.json. Can be combined with --port and --no-open flags.

```bash
decide ui -d  /  decide ui --detach
```

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

### Add Decision Tool

Source: https://decisionnode.dev/docs/mcp

Record a new decision. If similar decisions exist (>=75% similarity), they are returned instead of adding a new one. Use `force=true` to add anyway. Set `global=true` for cross-project decisions.

```python
add_decision(scope, decision, rationale, constraints, global?, force?, project)
```

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

### Check UI Server Status

Source: https://decisionnode.dev/docs/cli

Shows whether the background UI server is running. Reports the URL, PID, and uptime.

```bash
decide ui status
```

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

### Search Decisions with Query

Source: https://decisionnode.dev/docs/cli

Searches for decisions matching a specific query, including global decisions.

```bash
decide search "how should we handle authentication?"
```

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

### List Decisions Tool

Source: https://decisionnode.dev/docs/mcp

List all recorded decisions for a project, including global decisions. An optional scope parameter can be used for filtering.

```python
list_decisions(scope?, project)
```

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

### Configure Search Threshold

Source: https://decisionnode.dev/docs/setup

Commands to set and view the minimum similarity score for search results. Values range from 0.0 to 1.0. Changes take effect immediately.

```bash
decide config search-threshold           # View current (default: 0.3)
```

```bash
decide config search-threshold 0.5       # Stricter — only 50%+ similarity
```

```bash
decide config search-threshold 0.2       # More permissive
```

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

### List Projects Tool

Source: https://decisionnode.dev/docs/mcp

List all projects that contain decisions, along with the count of global decisions. Use this tool first in monorepos to identify the correct project name.

```python
list_projects(verbose?)
```

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

### Import Decisions from JSON

Source: https://decisionnode.dev/docs/cli

Imports decisions from a JSON file into the current project or the global store. Use `--overwrite` to replace existing decisions with matching IDs.

```bash
decide import <file.json> [--overwrite]
```

```bash
decide import <file.json> --global
```

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

### List Recorded Decisions

Source: https://decisionnode.dev/docs/quickstart

View all recorded decisions, organized by scope. This helps verify that your decisions have been saved correctly.

```bash
decide list
```

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

### Search Decisions

Source: https://decisionnode.dev/docs/cli

Searches for decisions, automatically including global decisions alongside project decisions.

```bash
decide search
```

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

### View Current Agent Behavior Setting

Source: https://decisionnode.dev/docs/setup

Command to display the current agent behavior configuration. This setting affects how the AI client decides when to use the `search_decisions` tool.

```bash
decide config
```

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

### Configure DecisionNode MCP Server for Cursor

Source: https://decisionnode.dev/docs/mcp

Add DecisionNode as an MCP server in Cursor's settings or directly edit the `~/.cursor/mcp.json` configuration file. Restart Cursor after changes.

```json
{
  "mcpServers": {
    "decisionnode": {
      "command": "decide-mcp",
      "args": []
    }
  }
}
```

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

### List Global Decisions

Source: https://decisionnode.dev/docs/cli

Lists only global decisions. Without this flag, `decide list` shows both project and global decisions together.

```bash
decide list --global
```

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

### List Decisions by Scope

Source: https://decisionnode.dev/docs/cli

Lists all decisions, grouped by scope. Use the `--scope` flag to filter for a specific scope. Includes global decisions by default.

```bash
decide list [--scope <scope>]
```

```bash
decide list --global
```

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

### Export and Import Decisions Between Projects

Source: https://decisionnode.dev/docs/workflows

Export decisions from one project to a JSON file and import them into another. Use `--global` to export or import global decisions. Exported decisions are printed to the terminal and redirected to a file.

```bash
cd old-project
decide export json > ~/decisions.json
```

```bash
cd new-project
decide init
decide import ~/decisions.json
```

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

### Add a Decision with Flags

Source: https://decisionnode.dev/docs/cli

Adds a decision using command-line flags for scope, decision text, rationale, and constraints. Use `--global` to add a decision applicable to all projects.

```bash
decide add -s <scope> -d <decision> [-r <rationale>] [-c <constraints>]
```

```bash
decide add --global
```

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

### One-Command Global Decision Add

Source: https://decisionnode.dev/docs/cli

Adds a global decision with specified parameters without interactive prompts.

```bash
decide add --global -s Security -d "Never commit .env files"
```

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

### List Decisions by Scope

Source: https://decisionnode.dev/docs/cli

Lists decisions filtered by a specific scope.

```bash
decide list --scope Backend
```

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

### Add Global Decisions

Source: https://decisionnode.dev/docs/workflows

Add decisions that apply across all projects, such as coding standards or file exclusion rules. These are automatically included in search results for every project, with project-specific decisions taking precedence.

```bash
decide add --global
```

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

### Generate Vector Embeddings

Source: https://decisionnode.dev/docs/cli

Creates vector embeddings for any decisions that lack them. Recommended after importing data or if embedding failed previously due to API key issues.

```bash
decide embed
```

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

### Configure Agent Behavior

Source: https://decisionnode.dev/docs/setup

Commands to set the agent's behavior regarding searching for decisions. 'strict' requires a search before any code change, while 'relaxed' allows the AI to decide when a search is relevant. Restart the MCP server or reconnect the AI client for changes to take effect.

```bash
decide config agent-behavior strict    # AI must search before ANY code change (default)
```

```bash
decide config agent-behavior relaxed  # AI searches when it thinks it's relevant
```

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

### One-Command Decision Add

Source: https://decisionnode.dev/docs/cli

Adds a decision with specified parameters without interactive prompts.

```bash
decide add -s UI -d "Use Tailwind for all styling" -r "Consistent tokens" -c "No arbitrary values"
```

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

### Register MCP Server for Claude Code

Source: https://decisionnode.dev/docs/quickstart

Register the DecisionNode MCP server to enable integration with Claude Code. Restart Claude Code after running this command.

```bash
claude mcp add decisionnode -s user decide-mcp
```

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

### Export Decisions to JSON

Source: https://decisionnode.dev/docs/cli

Exports all decisions to a JSON file at the specified path.

```bash
decide export json > ~/my-project-decisions.json
```

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

### Add a New Decision (One Command)

Source: https://decisionnode.dev/docs/quickstart

Add a new decision with all details provided as command-line arguments. Useful for scripting or quick entries.

```bash
decide add -s UI -d "Use Tailwind CSS for all styling" -r "Consistent tokens" -c "No arbitrary values"
```

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

### View Decision Details by ID

Source: https://decisionnode.dev/docs/cli

Retrieves and displays the full details of a specific decision using its ID. Prefix global decision IDs with `global:`.

```bash
decide get <id>
```

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

### get_status

Source: https://decisionnode.dev/docs/mcp

Provides an overview of a project's decision status, including the total number of decisions, the count of active decisions, and the time of the last activity.

```APIDOC
## get_status(project)

### Description
Get a project overview: total decisions, active count, and last activity.

### Parameters
#### Query Parameters
- **project** (string) - Optional - The project to get the status for. Defaults to the current project.
```

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

### Scope JSON File Structure

Source: https://decisionnode.dev/docs/decisions

Each architectural scope is stored as a JSON file containing an array of decisions for that scope. This organizes decisions by their domain.

```json
{
  "scope": "UI",
  "decisions": [
    { "id": "ui-001", "scope": "UI", "decision": "...", ... },
    { "id": "ui-002", "scope": "UI", "decision": "...", ... }
  ]
}
```

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

### list_projects

Source: https://decisionnode.dev/docs/mcp

Lists all projects that have associated decisions, along with the count of global decisions. This is useful for identifying the correct project name in monorepos.

```APIDOC
## list_projects(verbose?)

### Description
List all projects with decisions, plus global decision count. Use this first in monorepos to find the right project name.

### Parameters
#### Query Parameters
- **verbose** (boolean) - Optional - If true, provides more detailed information about each project.
```

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

### list_decisions

Source: https://decisionnode.dev/docs/mcp

Lists all recorded decisions for a specified project, including global decisions. The list can be optionally filtered by scope.

```APIDOC
## list_decisions(scope?, project)

### Description
List all recorded decisions for a project, including global decisions. Optionally filter by scope.

### Parameters
#### Query Parameters
- **scope** (string) - Optional - The scope to filter decisions by.
- **project** (string) - Optional - The project to list decisions from. Defaults to the current project.
```

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

### Export Decisions

Source: https://decisionnode.dev/docs/cli

Prints decisions to the terminal in a specified format (md, json, csv). Redirect output to save to a file. Use `--global` to export only global decisions.

```bash
decide export [format]
```

```bash
decide export json > ~/decisions.json
```

```bash
decide export --global
```

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

### View Activity History

Source: https://decisionnode.dev/docs/cli

Displays the activity log of recent DecisionNode operations like adds, edits, deletes, and syncs. Can be filtered by source (cli, mcp, cloud, marketplace).

```bash
decide history [--filter <source>]
```

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

### Record New Decisions

Source: https://decisionnode.dev/docs/workflows

Record agreed-upon approaches to maintain conventions. This can be done interactively or with a single command, optionally including scope, description, and reason. The AI can also call `add_decision` through MCP.

```bash
decide add
```

```bash
decide add -s UI -d "Use Tailwind" -r "Consistent tokens"
```

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

### Decision Node CLI Commands

Source: https://decisionnode.dev/docs/decisions

Commands to manage the lifecycle of decisions. Use 'deprecate' to hide decisions from search and AI, and 'activate' to make them visible again.

```bash
# Deprecate a decision (hides from search)
decide deprecate ui-001

# Re-activate it later
decide activate ui-001
```

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

### add_decision

Source: https://decisionnode.dev/docs/mcp

Records a new decision with its scope, rationale, and constraints. If a similar decision already exists, it returns the existing ones, allowing for updates or overwrites with `force=true`.

```APIDOC
## add_decision(scope, decision, rationale, constraints, global?, force?, project)

### Description
Record a new decision. If similar decisions exist (75% similarity), returns them instead of adding — the AI can then update the existing one, deprecate it, or re-call with force=true to add anyway. Set global=true for cross-project decisions.

### Parameters
#### Query Parameters
- **scope** (string) - Required - The scope of the decision.
- **decision** (string) - Required - The content of the decision.
- **rationale** (string) - Required - The reasoning behind the decision.
- **constraints** (string) - Required - Any constraints associated with the decision.
- **global** (boolean) - Optional - Whether the decision is global (cross-project). Defaults to false.
- **force** (boolean) - Optional - Forces adding the decision even if similar ones exist. Defaults to false.
- **project** (string) - Optional - The project to add the decision to. Defaults to the current project.
```

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

### Local Vector Store Format

Source: https://decisionnode.dev/docs/context

Shows the structure of entries in the local `vectors.json` file, mapping decision IDs to their vector embeddings and timestamps.

```json
{ "ui-001": { "vector": [0.12, -0.45, ...], "embeddedAt": "2024-..." } }
```

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

### Stop Background UI Server

Source: https://decisionnode.dev/docs/cli

Stops a running background UI server and cleans up the daemon state file.

```bash
decide ui stop
```

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

### Add a New Decision (Interactive)

Source: https://decisionnode.dev/docs/quickstart

Use the `decide add` command to interactively capture a new decision, including scope, decision statement, rationale, and constraints.

```bash
decide add
```

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

### Edit Decision Interactively

Source: https://decisionnode.dev/docs/cli

Opens a decision for interactive editing of its text, rationale, and constraints. Supports global decisions and can force edits with `-f`.

```bash
decide edit <id> [-f]
```

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

### Review Decision History

Source: https://decisionnode.dev/docs/workflows

View a log of all changes made to decisions, including additions, updates, deprecations, activations, and deletions. You can filter the history by the tool that made the change (e.g., `mcp` or `cli`).

```bash
# View recent activity
decide history
```

```bash
# Filter by source
decide history --filter mcp
decide history --filter cli
```

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

### Update Decision Tool

Source: https://decisionnode.dev/docs/mcp

Update an existing decision. Supports global decisions via prefix. The 'status' parameter can be set to 'deprecated' or 'active'.

```python
update_decision(id, decision?, rationale?, status?, constraints?, project)
```

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

### Search Decisions Semantically

Source: https://decisionnode.dev/docs/cli

Performs a semantic search across active decisions using vector embeddings. Requires a Gemini API key and automatically includes global decisions.

```bash
decide search "<query>"
```

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

### CLI Semantic Search

Source: https://decisionnode.dev/docs/context

Performs a semantic search for decisions related to error logging. Results are returned ranked by similarity score.

```bash
# Semantic search
decide search "how should we handle error logging?"
# Returns matches ranked by similarity score
```

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

### get_history

Source: https://decisionnode.dev/docs/mcp

Retrieves the activity log of recent decision changes, including additions, edits, deletions, and syncs, up to a specified limit.

```APIDOC
## get_history(limit?, project)

### Description
View the activity log of recent decision changes — adds, edits, deletes, and syncs.

### Parameters
#### Query Parameters
- **limit** (integer) - Optional - The maximum number of history entries to retrieve.
- **project** (string) - Optional - The project to get the history for. Defaults to the current project.
```

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

### Activate a Deprecated Decision

Source: https://decisionnode.dev/docs/cli

Re-enables a deprecated decision, making it immediately searchable again. Supports global decisions.

```bash
decide activate <id>
```

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

### Check for Missing Embeddings

Source: https://decisionnode.dev/docs/cli

Identifies decisions (both project and global) that are missing vector embeddings and are therefore not searchable.

```bash
decide check
```

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

### Clean Up Decision Metadata

Source: https://decisionnode.dev/docs/cli

Removes orphaned vectors and outdated review metadata that no longer correspond to existing decisions.

```bash
decide clean
```

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

### get_decision

Source: https://decisionnode.dev/docs/mcp

Retrieves the full details of a specific decision using its ID. It supports global decisions by prefixing the ID with 'global:'.

```APIDOC
## get_decision(id, project)

### Description
Get full details of a specific decision by ID. Supports global: prefix for global decisions (e.g. global:ui-001).

### Parameters
#### Query Parameters
- **id** (string) - Required - The ID of the decision to retrieve. Can be prefixed with 'global:' for global decisions.
- **project** (string) - Optional - The project the decision belongs to. Defaults to the current project.
```

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

### Search Decisions Tool

Source: https://decisionnode.dev/docs/mcp

Semantically search active decisions. Excludes deprecated decisions and automatically includes global ones. This is typically called by the AI before writing code.

```python
search_decisions(query, limit?, project)
```

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

### Search for a Decision

Source: https://decisionnode.dev/docs/quickstart

Perform a semantic search for decisions using natural language queries. DecisionNode uses cosine similarity to find the best match.

```bash
decide search "how should we style components?"
```

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

### Activate Decision

Source: https://decisionnode.dev/docs/cli

Re-activates a deprecated decision using its ID.

```bash
decide activate ui-003
```

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

### Deprecate and Activate Decisions

Source: https://decisionnode.dev/docs/workflows

Instead of deleting, deprecate conventions that are no longer relevant. Deprecated decisions are hidden from search but can be reactivated. They remain in the list with a warning.

```bash
# Hide from search
decide deprecate ui-015
```

```bash
# Bring it back
decide activate ui-015
```

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

### Set PowerShell Execution Policy

Source: https://decisionnode.dev/docs/installation

Adjusts the PowerShell execution policy to allow running scripts, which may be necessary if commands are not recognized.

```powershell
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
```

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

### search_decisions

Source: https://decisionnode.dev/docs/mcp

Performs a semantic search across active decisions, excluding deprecated ones. It automatically includes global decisions and is typically called by AI before writing code.

```APIDOC
## search_decisions(query, limit?, project)

### Description
Semantic search across active decisions only — deprecated decisions are excluded. Automatically includes global decisions. The AI calls this before writing code.

### Parameters
#### Query Parameters
- **query** (string) - Required - The search query.
- **limit** (integer) - Optional - The maximum number of results to return.
- **project** (string) - Optional - The project to search within. Defaults to the current project.
```

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

### CLI Embed Unembedded Decisions

Source: https://decisionnode.dev/docs/context

Generates vectors for decisions that currently lack them, useful after importing decisions or if embedding failed previously.

```bash
# Embed any unembedded decisions
decide embed
# Generates vectors for decisions that failed or were imported
```

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

### Decision Node JSON Structure

Source: https://decisionnode.dev/docs/decisions

Represents a single, scoped technical choice, its rationale, and its lifecycle. This is the atomic unit of architectural memory.

```json
{
  "id": "ui-001",
  "scope": "UI",
  "decision": "Use Tailwind CSS for all styling",
  "status": "active",
  "rationale": "Consistent design tokens, easy for AI to generate correct classes.",
  "constraints": [
    "No arbitrary values (e.g. w-[37px]) unless absolutely necessary",
    "Use @apply only for reusable base components"
  ],
  "createdAt": "2024-03-20T10:00:00Z"
}
```

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

### Check and Fix Embedding Health

Source: https://decisionnode.dev/docs/workflows

Verify that decisions have searchable embeddings and generate them if missing. This is important if decisions were added without an API key or if embedding failed. Also includes a command to clean up orphaned vectors.

```bash
# See which decisions are missing embeddings
decide check
```

```bash
# Generate embeddings for anything that's missing
decide embed
```

```bash
# Clean up orphaned vectors from deleted decisions
decide clean
```

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

### Delete Decision Tool

Source: https://decisionnode.dev/docs/mcp

Permanently delete a decision and its associated embedding. Supports global decisions via prefix. Consider deprecating instead of deleting.

```python
delete_decision(id, project)
```

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

### Deprecate Decision

Source: https://decisionnode.dev/docs/cli

Marks a decision as deprecated using its ID.

```bash
decide deprecate ui-003
```

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

### update_decision

Source: https://decisionnode.dev/docs/mcp

Updates an existing decision identified by its ID. Fields like decision content, rationale, status, and constraints can be modified. Supports global decisions and allows re-enabling deprecated decisions.

```APIDOC
## update_decision(id, decision?, rationale?, status?, constraints?, project)

### Description
Update an existing decision. Supports global: prefix. Set status to 'deprecated' to hide from search or 'active' to re-enable.

### Parameters
#### Query Parameters
- **id** (string) - Required - The ID of the decision to update. Can be prefixed with 'global:' for global decisions.
- **decision** (string) - Optional - The new content for the decision.
- **rationale** (string) - Optional - The updated rationale for the decision.
- **status** (string) - Optional - The new status of the decision ('deprecated' or 'active').
- **constraints** (string) - Optional - The updated constraints for the decision.
- **project** (string) - Optional - The project the decision belongs to. Defaults to the current project.
```

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

### Deprecate a Decision

Source: https://decisionnode.dev/docs/cli

Marks a decision as deprecated, removing it from search results while preserving its data and embedding. Supports global decisions.

```bash
decide deprecate <id>
```

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

### CLI Embedding Health Check

Source: https://decisionnode.dev/docs/context

Checks the embedding status of decisions, indicating which ones have associated vectors and which are missing them.

```bash
# Check embedding health
decide check
# Shows which decisions are embedded vs missing vectors
```

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

### CLI Clean Orphaned Vectors

Source: https://decisionnode.dev/docs/context

Removes vector embeddings that are no longer associated with any existing decisions, helping to maintain data integrity.

```bash
# Remove orphaned vectors
decide clean
# Cleans up vectors for decisions that no longer exist
```

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

### Delete a Decision or Scope

Source: https://decisionnode.dev/docs/cli

Permanently removes a decision by ID or an entire scope. Use `-f` to bypass confirmation prompts. Consider deprecating instead of deleting if data might be needed later.

```bash
decide delete <id> [-f]
```

```bash
decide delete-scope <scope> [-f]
```

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

### delete_decision

Source: https://decisionnode.dev/docs/mcp

Permanently deletes a decision and its associated embedding. It's recommended to consider deprecating decisions instead of deleting them if they might be needed later.

```APIDOC
## delete_decision(id, project)

### Description
Permanently delete a decision and its embedding. Supports global: prefix. Consider deprecating instead if the user might want it back.

### Parameters
#### Query Parameters
- **id** (string) - Required - The ID of the decision to delete. Can be prefixed with 'global:' for global decisions.
- **project** (string) - Optional - The project the decision belongs to. Defaults to the current project.
```

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