Back to skill

Security audit

Uninstaller

Security checks for vulnerabilities and agentic risk

Overview

This is a real OpenClaw uninstaller, but its host-level scripts can delete data and contain unsafe path and argument handling that users should review before use.

Review this skill before installing or running it. Use it only when you intend to completely remove OpenClaw from the specific gateway host, avoid running it as an administrator, verify `OPENCLAW_STATE_DIR` is exactly the OpenClaw state directory, and prefer a verified local OpenClaw CLI over the unpinned npx fallback. Do not pass untrusted email or ntfy values to the scheduler.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (4)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/schedule-uninstall.sh:43
Finding
Host Command Injection Through Notification Arguments<![CDATA[ ## Vulnerability Details **File Location**: `scripts/schedule-uninstall.sh`, lines 43–51 and 89–94 **Vulnerability Type**: Shell command injection **Risk Level**: High ### Vulnerable Code ```bash # Build command string for one-shot ARG_STR="" for a in "${EXTRA_ARGS[@]}"; do ARG_STR="$ARG_STR '$a'" done CMD="sleep $DELAY && '$UNINSTALL_SCRIPT' $ARG_STR" case "$(uname -s)" in Darwin) if launchctl submit -l openclaw-uninstall -o "$LOG_FILE" -e "$LOG_FILE" -- \ /bin/bash -c "$CMD" 2>/dev/null; then ``` The same unsafe command string is passed to the Linux execution paths: ```bash if systemd-run --user --onetime --unit=openclaw-uninstall \ /bin/bash -c "$CMD" &>/dev/null; then echo "Linux uninstall scheduled (systemd), will run in ~${DELAY}s." else # Fallback: nohup + disown (works when systemd-run unavailable, e.g. WSL2 without systemd) (nohup bash -c "$CMD" >> "$LOG_FILE" 2>&1 &) ``` ### Technical Analysis Values supplied through `--notify-email` and `--notify-ntfy` are appended to a command string between single quotes. The script does not escape embedded single quotes before passing the result to `bash -c`. Shell metacharacters placed after an embedded quote are consequently interpreted as command syntax rather than as part of a notification argument. Array usage while initially collecting the arguments does not protect the values because the array is later converted back into an unsafe shell command string. The Skill documentation explicitly requires this scheduler to run on the gateway host rather than in a sandbox. Exploitation therefore results in command execution directly on that host with the privileges of the user running the Agent. ### Attack Path 1. An attacker persuades the user or Agent to request an ntfy topic or email value containing shell syntax, such as: ```text x'; touch /tmp/openclaw-injected; #' ``` 2. The Agent invokes: ```bash ./scripts/schedule-uninstall.sh --notify-ntfy "x'; to ...[truncated 795 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not serialize arguments into a command string passed to `bash -c`. - Create a dedicated wrapper that sleeps and then invokes the uninstall script using an argument array. - Where service APIs require separate arguments, supply each argument directly rather than through a shell interpreter. - If serialization is unavoidable, quote every argument using a robust mechanism such as `printf '%q'`; direct argument passing remains preferable. - Validate notification values before scheduling: - Enforce a conservative email-address format. - Restrict ntfy topics to an documented allowlist of characters and lengths. - Reject control characters, shell metacharacters, embedded URLs, and path separators where they are unnecessary. - Reject unknown options and detect missing option values instead of silently shifting arguments. - Add regression tests using quotes, semicolons, command substitutions, newlines, and redirection operators. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/uninstall-oneshot.sh:48
Finding
Environment-Controlled Recursive Deletion Without Path Validation<![CDATA[ ## Vulnerability Details **File Location**: `scripts/uninstall-oneshot.sh`, lines 48–52 **Vulnerability Type**: Unsafe recursive deletion **Risk Level**: High ### Vulnerable Code ```bash # 3. Delete state dir STATE_DIR="${OPENCLAW_STATE_DIR:-$HOME/.openclaw}" if [[ -d "$STATE_DIR" ]]; then log "Removing state dir: $STATE_DIR" rm -rf "$STATE_DIR" fi ``` ### Technical Analysis The destructive target is taken directly from the inherited `OPENCLAW_STATE_DIR` environment variable. The script verifies only that the value identifies an existing directory. It does not: - Canonicalize the path. - Confirm that it is an OpenClaw-specific directory. - Reject `$HOME`, `/`, `.`, `..`, or sensitive system locations. - Detect paths containing traversal components or symbolic-link-based redirection. - Present the resolved path as part of a target-specific confirmation. Quoting the variable prevents word splitting but does not make an attacker-controlled deletion target safe. Any existing directory writable by the executing account can be passed to `rm -rf`. ### Attack Path 1. A malicious or incorrectly configured execution environment defines an unrelated directory as the OpenClaw state directory: ```bash export OPENCLAW_STATE_DIR="$HOME" ``` 2. The user or Agent runs `uninstall-oneshot.sh`, directly or through the scheduler. 3. The script determines that the supplied path is an existing directory. 4. It executes: ```bash rm -rf "$HOME" ``` 5. User data is recursively removed within the permissions of the executing account. The same issue could target another user-writable project, mounted volume, or application-data directory. ### Impact Assessment Successful exploitation can cause irreversible deletion of unrelated files and directories accessible to the executing account. Under normal user execution, this can destroy the user’s home data, projects, application state, and credentials. If the script is run by a privileged account ...[truncated 201 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Canonicalize the target with a platform-appropriate utility before deletion. - Reject empty values and dangerous paths, including `/`, `$HOME`, `.`, `..`, system directories, and paths outside documented OpenClaw storage locations. - Require the canonical target to match an explicit allowlist, such as: - `$HOME/.openclaw` - A documented OpenClaw profile directory under `$HOME` - A user-confirmed custom path meeting strict constraints - Verify that the target is not a symbolic link and that every relevant parent component has expected ownership. - Show the exact canonical deletion target before confirmation. - Consider moving the directory to a quarantine or trash location before permanent deletion. - Use a safety function shared by all recursive deletion operations and add tests for root, home, relative, traversal, symlink, and whitespace-containing paths. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/schedule-uninstall.sh:9
Finding
Predictable Shared Temporary Log File Permits Symlink Attacks<![CDATA[ ## Vulnerability Details **File Location**: `scripts/schedule-uninstall.sh`, lines 9, 50, 78–79, and 94; `scripts/uninstall-oneshot.sh`, lines 7 and 18 **Vulnerability Type**: Unsafe temporary-file handling **Risk Level**: Medium ### Vulnerable Code ```bash LOG_FILE="/tmp/openclaw-uninstall.log" ``` The scheduler redirects output to the predictable path: ```bash if launchctl submit -l openclaw-uninstall -o "$LOG_FILE" -e "$LOG_FILE" -- \ /bin/bash -c "$CMD" 2>/dev/null; then ``` ```xml <key>StandardOutPath</key><string>$LOG_FILE</string> <key>StandardErrorPath</key><string>$LOG_FILE</string> ``` ```bash (nohup bash -c "$CMD" >> "$LOG_FILE" 2>&1 &) ``` The uninstall script also appends through `tee`: ```bash LOG_FILE="/tmp/openclaw-uninstall.log" ... log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"; } ``` ### Technical Analysis `/tmp` is normally writable by all local users. The fixed filename can be created in advance by another local account. The scripts do not verify file ownership, reject symbolic links, create the file exclusively, or place it in a private directory. Shell append redirection and `tee -a` normally follow symbolic links. A local attacker can therefore pre-create the log path as a symbolic link to another file writable by the victim. When the victim schedules or runs the uninstall, log output is appended to the symlink target. Platform-specific temporary-directory protections may reduce exploitability in some environments, but the code itself does not provide the required safety guarantees. ### Attack Path 1. A local attacker predicts the constant filename. 2. Before the victim executes the Skill, the attacker creates: ```bash ln -s /path/to/victim-writable-file /tmp/openclaw-uninstall.log ``` 3. The victim runs the scheduler or uninstall script. 4. Output redirection or `tee -a` follows the symbolic link. 5. Uninstall log content is appended to the selected target file. ### Impact As ...[truncated 421 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Create a private runtime directory using `mktemp -d` and set its mode to `0700`. - Create the log file exclusively with restrictive permissions such as `0600`. - Reject symbolic links and verify ownership before opening an existing file. - Prefer a user-private runtime location such as `$XDG_RUNTIME_DIR` where available. - Pass the securely created path to launchd or systemd. - If a stable user-facing path is required, expose it only after securely creating and validating the underlying file. - Remove temporary artifacts after they are no longer needed, subject to the documented log-retention policy. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:86
Finding
Unpinned Package Download and Execution in Documented Uninstall Procedure<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, line 86 **Vulnerability Type**: Unpinned third-party package execution **Risk Level**: Medium ### Vulnerable Code ```bash npx -y openclaw uninstall --all --yes --non-interactive ``` ### Technical Analysis The documented command asks `npx` to resolve and execute the current package associated with the `openclaw` name. It does not pin an exact reviewed version or verify package integrity. The `-y` option suppresses the normal installation confirmation. Package execution may run package code and lifecycle behavior obtained from the configured registry. Consequently, the effective code executed by this procedure can change after the Skill itself has been reviewed. The audit found no evidence that the current package is malicious. The vulnerability is the unpinned, mutable supply-chain execution path. ### Attack Path 1. A user follows the manual uninstall instructions when no trusted local OpenClaw CLI is available. 2. `npx` resolves the package from the configured package registry. 3. A future compromised release, registry-account compromise, or malicious registry configuration supplies altered package code. 4. `npx -y` downloads and executes that code without presenting an installation confirmation. 5. The downloaded code runs with the user’s local privileges. ### Impact Assessment A compromised package can execute arbitrary code with the privileges of the invoking user. It could read or modify accessible files, steal credentials, destroy data, or establish persistence. This finding is conditional on supply-chain compromise or unsafe registry configuration; no such compromise was established during the static audit. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Prefer an already-installed and verified `openclaw` executable. - If `npx` must be supported, pin an exact reviewed package version. - Document the expected registry and advise users to verify their npm registry configuration. - Publish and verify an integrity hash or signed release artifact where practical. - Avoid `-y` when interactive verification is possible. - Document that `npx` downloads and executes third-party code so users can make an informed decision. - Consider providing a self-contained, reviewed removal procedure that does not require downloading executable code during uninstall. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Memory PoisoningPersistent Context Injection, Context Window Stuffing, Memory Manipulation
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (48)

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The description presents the skill primarily as a guidance resource, but the body instructs the agent to autonomously schedule and perform destructive uninstall actions and optionally send outbound notifications. This mismatch can bypass user and reviewer expectations, making high-impact host actions more likely to be invoked under the guise of simple advice.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
1. Stop gateway: `openclaw gateway stop`
2. Uninstall service: `openclaw gateway uninstall`
3. Delete state: `rm -rf "${OPENCLAW_STATE_DIR:-$HOME/.openclaw}"`
4. Uninstall CLI: `npm rm -g openclaw` (or pnpm/bun)
5. macOS app: `rm -rf /Applications/OpenClaw.app`
Confidence
95% confidence
Finding
`rm -rf "${OPENCLAW_STATE_DIR:-$HOME/.openclaw}"` deletes a path derived from an environment variable, which could be manipulated to point outside the intended application directory. In a host-executed uninstall flow, that makes accidental or malicious deletion of arbitrary user data possible.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
1. Stop gateway: `openclaw gateway stop`
2. Uninstall service: `openclaw gateway uninstall`
3. Delete state: `rm -rf "${OPENCLAW_STATE_DIR:-$HOME/.openclaw}"`
4. Uninstall CLI: `npm rm -g openclaw` (or pnpm/bun)
5. macOS app: `rm -rf /Applications/OpenClaw.app`

### CLI already removed (manual service cleanup)
Confidence
90% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
2. Uninstall service: `openclaw gateway uninstall`
3. Delete state: `rm -rf "${OPENCLAW_STATE_DIR:-$HOME/.openclaw}"`
4. Uninstall CLI: `npm rm -g openclaw` (or pnpm/bun)
5. macOS app: `rm -rf /Applications/OpenClaw.app`

### CLI already removed (manual service cleanup)
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
case "$(uname -s)" in
  Darwin)
    launchctl bootout "gui/$UID/ai.openclaw.gateway" 2>/dev/null || true
    rm -f ~/Library/LaunchAgents/ai.openclaw.gateway.plist
    for f in ~/Library/LaunchAgents/com.openclaw.*.plist; do
      [[ -f "$f" ]] && rm -f "$f"
    done
Confidence
95% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
case "$(uname -s)" in
  Darwin)
    launchctl bootout "gui/$UID/ai.openclaw.gateway" 2>/dev/null || true
    rm -f ~/Library/LaunchAgents/ai.openclaw.gateway.plist
    for f in ~/Library/LaunchAgents/com.openclaw.*.plist; do
      [[ -f "$f" ]] && rm -f "$f"
    done
Confidence
95% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Chaining Abuse

High
Category
Tool Misuse
Content
launchctl bootout "gui/$UID/ai.openclaw.gateway" 2>/dev/null || true
    rm -f ~/Library/LaunchAgents/ai.openclaw.gateway.plist
    for f in ~/Library/LaunchAgents/com.openclaw.*.plist; do
      [[ -f "$f" ]] && rm -f "$f"
    done
    ;;
  Linux)
Confidence
75% confidence
Finding
Tool calls are chained to bypass individual safety checks or escalate capabilities beyond what any single tool call would allow.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
;;
  Linux)
    systemctl --user disable --now openclaw-gateway.service 2>/dev/null || true
    rm -f ~/.config/systemd/user/openclaw-gateway.service
    systemctl --user daemon-reload 2>/dev/null || true
    ;;
esac
Confidence
95% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
;;
  Linux)
    systemctl --user disable --now openclaw-gateway.service 2>/dev/null || true
    rm -f ~/.config/systemd/user/openclaw-gateway.service
    systemctl --user daemon-reload 2>/dev/null || true
    ;;
esac
Confidence
95% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Memory Manipulation

High
Category
Memory Poisoning
Content
;;
esac

# 3. Delete state dir
STATE_DIR="${OPENCLAW_STATE_DIR:-$HOME/.openclaw}"
if [[ -d "$STATE_DIR" ]]; then
  log "Removing state dir: $STATE_DIR"
Confidence
80% confidence
Finding
Skill manipulates agent memory, state, or stored context. Memory corruption can alter personality, override safety rules, or cause unpredictable behavior.

Memory Manipulation

High
Category
Memory Poisoning
Content
;;
esac

# 3. Delete state dir
STATE_DIR="${OPENCLAW_STATE_DIR:-$HOME/.openclaw}"
if [[ -d "$STATE_DIR" ]]; then
  log "Removing state dir: $STATE_DIR"
Confidence
80% confidence
Finding
Skill manipulates agent memory, state, or stored context. Memory corruption can alter personality, override safety rules, or cause unpredictable behavior.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# 6. macOS app
if [[ "$(uname -s)" == "Darwin" ]] && [[ -d "/Applications/OpenClaw.app" ]]; then
  log "Removing macOS app"
  rm -rf /Applications/OpenClaw.app
fi

log "=== Uninstall complete ==="
Confidence
100% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# 6. macOS app
if [[ "$(uname -s)" == "Darwin" ]] && [[ -d "/Applications/OpenClaw.app" ]]; then
  log "Removing macOS app"
  rm -rf /Applications/OpenClaw.app
fi

log "=== Uninstall complete ==="
Confidence
100% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# 6. macOS app
if [[ "$(uname -s)" == "Darwin" ]] && [[ -d "/Applications/OpenClaw.app" ]]; then
  log "Removing macOS app"
  rm -rf /Applications/OpenClaw.app
fi

log "=== Uninstall complete ==="
Confidence
100% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Lp3

Medium
Category
MCP Least Privilege
Confidence
96% confidence
Finding
The skill clearly instructs the agent to execute shell scripts and destructive uninstall commands, but the manifest does not declare any explicit tool scope or permission boundaries. That increases the risk of accidental or overbroad execution because reviewers and policy systems cannot easily constrain what tools the skill is expected to use.

Vague Triggers

Medium
Confidence
89% confidence
Finding
The trigger description is broad enough that ordinary cleanup or support conversations could unintentionally activate a destructive uninstall workflow. In a skill capable of host-level execution, ambiguous invocation criteria materially increase the chance of accidental system changes.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The example trigger phrase includes very generic wording like 'Uninstall', which may match unrelated conversations or other software contexts. Because the documented flow leads to autonomous uninstall scheduling, an overly broad trigger creates real accidental-execution risk.

Rp1

Medium
Category
MCP Rug Pull
Confidence
94% confidence
Finding
Using `npx -y openclaw` without a pinned version fetches and executes whatever package version is current at runtime. That creates a supply-chain risk where a malicious or compromised package update could run arbitrary code during uninstall on the host machine.

Session Persistence

Medium
Category
Rogue Agent
Content
#!/usr/bin/env bash
# schedule-uninstall.sh — Create launchd/systemd one-shot to run uninstall after delay.
# Agent calls this; script returns immediately after scheduling.
# Usage: schedule-uninstall.sh [--notify-email EMAIL] [--notify-ntfy TOPIC]
# Requires: host=gateway (must run on host, not in sandbox)
Confidence
84% confidence
Finding
The script is explicitly designed to create a launchd/systemd one-shot that persists beyond the current agent session. In a security context, persistence mechanisms are sensitive because they allow actions to occur later without an active user session, which can be abused if an attacker can trigger the scheduler or substitute the uninstall payload.

Session Persistence

Medium
Category
Rogue Agent
Content
case "$(uname -s)" in
  Darwin)
    if launchctl submit -l openclaw-uninstall -o "$LOG_FILE" -e "$LOG_FILE" -- \
      /bin/bash -c "$CMD" 2>/dev/null; then
      echo "macOS uninstall scheduled (launchctl), will run in ~${DELAY}s."
    else
Confidence
86% confidence
Finding
Using launchctl submit creates a deferred job managed by the OS, allowing the uninstall to execute after the initiating context has ended. While not inherently malicious in an uninstall utility, this is still a persistence primitive that can be dangerous if invoked unexpectedly or by another component without strong confirmation and provenance checks.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
This script schedules execution of an uninstall script after a delay and then returns immediately, which creates a destructive action decoupled from the initiating session. Although the skill’s stated purpose is legitimate removal, the scheduled one-shot provides only a generic success message and no explicit last-chance confirmation at the moment the destructive operation is queued, increasing the risk of accidental or coerced removal.

Session Persistence

Medium
Category
Rogue Agent
Content
$EXEC_LINE
WRAPEOF
      chmod +x "$WRAPPER"
      PLIST_DIR="${TMPDIR:-/tmp}"
      PLIST="$PLIST_DIR/openclaw-uninstall-$$.plist"
      cat > "$PLIST" << PLISTEOF
<?xml version="1.0"?>
Confidence
75% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Session Persistence

Medium
Category
Rogue Agent
Content
$EXEC_LINE
WRAPEOF
      chmod +x "$WRAPPER"
      PLIST_DIR="${TMPDIR:-/tmp}"
      PLIST="$PLIST_DIR/openclaw-uninstall-$$.plist"
      cat > "$PLIST" << PLISTEOF
<?xml version="1.0"?>
Confidence
75% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Session Persistence

Medium
Category
Rogue Agent
Content
$EXEC_LINE
WRAPEOF
      chmod +x "$WRAPPER"
      PLIST_DIR="${TMPDIR:-/tmp}"
      PLIST="$PLIST_DIR/openclaw-uninstall-$$.plist"
      cat > "$PLIST" << PLISTEOF
<?xml version="1.0"?>
Confidence
75% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Session Persistence

Medium
Category
Rogue Agent
Content
$EXEC_LINE
WRAPEOF
      chmod +x "$WRAPPER"
      PLIST_DIR="${TMPDIR:-/tmp}"
      PLIST="$PLIST_DIR/openclaw-uninstall-$$.plist"
      cat > "$PLIST" << PLISTEOF
<?xml version="1.0"?>
Confidence
75% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Static analysis

Detected: suspicious.destructive_delete_command

Documentation contains a destructive delete command without an explicit confirmation gate.

Warn
Code
suspicious.destructive_delete_command
Location
SKILL.md:95