> For the complete documentation index, see [llms.txt](https://docs.gomboc.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.gomboc.ai/orl/agent-skills/gomboc-enterprise-skills/cursor-enterprise.md).

# Cursor (Enterprise)

{% hint style="info" %}
This plugin is distributed only as a private zip package shared via Google Drive during Gomboc Enterprise onboarding. It is not published on any public marketplace.
{% endhint %}

#### What you will set up

By the end of this guide, you will have:

* The Gomboc Enterprise plugin package extracted locally on your machine
* The `gomboc` plugin installed in Cursor from the extracted plugin folder
* A valid `GOMBOC_API_TOKEN` available in the environment Cursor launches from
* Docker available so the ORL container runtime can run
* A working Cursor Agent flow for Gomboc enterprise remediation and rule workflows

For background on ORL, see [ORL (Open Remediation Language)](/orl.md). For Gomboc rule concepts, see [Rules](/policy-management/rules.md)

#### Who this is for

This guide is for Gomboc Enterprise customers who:

* use [Cursor](https://cursor.com) as their coding agent
* have a valid Gomboc Enterprise subscription
* need enterprise remediation, rule authoring, or rule publishing workflows

***

#### Prerequisites

Before you start, make sure you have the following.

**Cursor**

* Cursor must be installed and signed in. See cursor.com/docs for installation.
* For Cursor plugin internals, see the [Cursor Plugins reference](https://cursor.com/docs/reference/plugins).

**Enterprise Skills Plugin Package**

* The plugin is distributed as a zip package via a Google Drive link shared by your Gomboc contact during onboarding.
* Download the zip and extract it to a stable location on your machine (for example `~/gomboc/gomboc-enterprise-skills/`). The same extracted folder works for all four supported agent runtimes; you only need to do this once.
* To upgrade later, download the new zip your Gomboc contact provides and replace the extracted folder (or extract alongside and re-point the install commands to the new path).

{% hint style="info" %}
The zip contains the full plugin — every per-agent manifest (`plugin.json`, `gemini-extension.json`, `.codex-plugin/plugin.json`, `.cursor-plugin/plugin.json`) plus all skills, commands, and reference files.
{% endhint %}

**Gomboc API token**

* You need a valid `GOMBOC_API_TOKEN`. See [Generate A Personal Access Token](/getting-started/generate-a-personal-access-token.md).

**Docker (for the ORL runtime)**

* The Gomboc Enterprise plugin runs ORL through the public `gombocai/orl:latest` container image, managed automatically by the agent.
* Install Docker Desktop or Docker Engine for your operating system and confirm the daemon is running: `docker info`

For ORL concepts, see [Custom Rules Quickstart](/orl/quickstart.md)

***

#### **Step 1: Download and extract the plugin package**

Download the zip file from the Google Drive link your Gomboc contact provided and extract it:

```bash
# Example — adjust the zip filename and destination to match your setup
unzip ~/Downloads/gomboc-enterprise-skills.zip -d ~/gomboc/
```

For the rest of this guide, the path `~/gomboc/gomboc-enterprise-skills/` refers to the extracted folder. Adjust it to wherever you extracted the zip.

#### Step 2: Symlink the plugin into Cursor's local plugins folder

Cursor automatically loads plugins from `~/.cursor/plugins/local`. Create that folder if needed, then link the plugin directory from the extracted zip:

```bash
mkdir -p ~/.cursor/plugins/local
ln -s ~/gomboc/gomboc-enterprise-skills/plugins/gomboc ~/.cursor/plugins/local/gomboc
```

Optionally, do the same for the evaluation plugin:

```bash
ln -s ~/gomboc/gomboc-enterprise-skills/plugins/policy-fix-workflow ~/.cursor/plugins/local/policy-fix-workflow
```

Cursor discovers each plugin from its `.cursor-plugin/plugin.json` manifest inside the linked folder.

#### Step 3: Reload Cursor

Restart Cursor or run **Developer: Reload Window** so the new plugin is picked up.

#### Step 4: Configure your Gomboc token

The Gomboc skills read `GOMBOC_API_TOKEN` from the environment Cursor is launched from. Set it in the shell or environment file Cursor inherits:

```bash
export GOMBOC_API_TOKEN="<your-token>"
```

On macOS, when launching Cursor from Finder, set the variable via your login shell profile (for example `~/.zshrc`) and start Cursor from a terminal at least once after the change so the new value is loaded.

{% hint style="info" %}
Keep this token private. Do not commit it to source control.
{% endhint %}

#### **Step 5: Confirm the ORL runtime**

The `gomboc` plugin's `orl` skill resolves the runtime for you. It uses a local `orl` binary when one is on your `PATH`, and otherwise runs ORL through the `gombocai/orl:latest` Docker container (pulled automatically on first use). You do not invoke the runtime directly.

Verify the integration end-to-end by asking the agent to run the `orl` skill with the `version` subcommand. The skill prints the resolved ORL version and reports the execution method (local binary or container image).

In Cursor Agent chat, type: `/orl version`

If the call fails (no version returned, or an error referencing the runtime), see ORL runtime not available under [Troubleshooting](#troubleshooting) below.

#### Step 6: Verify Gomboc skills are loaded

1. Open **Cursor Settings** (Cmd+Shift+J on macOS, Ctrl+Shift+J on Windows/Linux).
2. Navigate to **Rules**.
3. In the **Agent Decides** section, look for Gomboc skills such as `diagnose`, `enforce-policy`, `analyze-context`, `build-fix`, `apply-fix`, `build-rule`, `review-rule`, `enrich-rule`, `release-rule`, and `save-as-rule`.

If the skills do not appear, reload Cursor and confirm the symlink at `/.cursor/plugins/local/gomboc` is intact.

#### Step 7: Run your first Gomboc workflow

In Cursor Agent, you can either let the agent decide when to use a Gomboc skill based on your task description, or invoke a skill explicitly by typing `/` and selecting it.

The main entry-point skills exposed by the plugin are:

| Invocation         | Purpose                                                                |
| ------------------ | ---------------------------------------------------------------------- |
| `/diagnose`        | Scan code for violations against Gomboc classifications                |
| `/analyze-context` | Detect language and fingerprint a specific violation                   |
| `/build-fix`       | Build a targeted ORL rule for a real violation                         |
| `/apply-fix`       | Run `orl remediate --dry-run`, present the diff, and apply on approval |
| `/enforce-policy`  | Run the full diagnose → cover → apply → verify loop                    |
| `/build-rule`      | Build a production-quality ORL rule from a classification              |
| `/review-rule`     | Run the 12-item robustness checklist on a rule package                 |
| `/enrich-rule`     | Apply org-grade metadata to a reviewed rule                            |
| `/release-rule`    | Release a reviewed and enriched rule (PR or direct push)               |
| `/save-as-rule`    | Promote an in-context fix into the org rule repository                 |
| `/rules-service`   | Query or publish against the Gomboc Rules Service                      |

The full list of skills exposed to Cursor is declared in `plugins/gomboc/.cursor-plugin/plugin.json`. Many other skills (language experts, planners, converters, classification experts) are also loaded and selected automatically by the agent when relevant.

For details about publishing ORL rules, see [Publish](/orl/publish.md) and [Rule Service API](/orl/publish/orl-rule-service-api.md)

***

#### Troubleshooting

Use this section to diagnose the most common setup issues.

**Plugin package download or extraction issues**

If the zip file provided by your Gomboc contact cannot be downloaded or extracted:

* Confirm the Google Drive link is still valid and has not expired. Ask your Gomboc contact to re-share if needed.
* Confirm the download completed fully before extracting — a partial download will fail silently or produce an empty folder.
* On macOS, if unzipping via Finder produces an incomplete result, prefer the terminal: `unzip ~/Downloads/gomboc-enterprise-skills.zip -d ~/gomboc/`
* Confirm you have write access to the destination folder.

If you are still unable to obtain the package, contact your Gomboc representative.

**Local symlink not picked up**

If you used the local install path and the plugin does not load:

* Confirm the symlink target exists and points at the `plugins/gomboc` directory: `ls -l ~/.cursor/plugins/local/gomboc`
* Confirm the manifest is at `plugins/gomboc/.cursor-plugin/plugin.json`.
* Run **Developer: Reload Window** in Cursor, or restart the app.

**Skills do not appear in Cursor**

If the plugin is installed but Gomboc skills are missing from **Settings → Rules → Agent Decides**:

* Reload Cursor.
* Confirm the symlink at `~/.cursor/plugins/local/gomboc` is intact.
* For local installs, confirm the symlink is intact and the plugin manifest is valid JSON.

**Token configuration errors**

If a Gomboc skill reports authentication or token errors:

* Confirm that `GOMBOC_API_TOKEN` is exported in the shell that launches Cursor.
* Confirm the token is valid and has not expired.
* Generate or rotate your token — see [Generate A Personal Access Token](/getting-started/generate-a-personal-access-token.md)
* Restart Cursor after updating the environment.

**ORL runtime not available**

If a Gomboc skill reports that ORL cannot be executed:

* Run `docker info` to confirm Docker is installed and the daemon is running.
* Pull the image manually to confirm registry access: `docker pull gombocai/orl:latest`
* If you maintain a local `orl` binary, confirm it is on `PATH` with `command -v orl`.
* Restart Cursor after fixing Docker or `PATH`.

**ORL command runs but remediation fails**

If ORL launches but the workflow does not complete:

* Confirm that you are running Cursor from the correct project or workspace.
* Confirm that the target files are supported by the workflow you are running.
* Confirm that your `GOMBOC_API_TOKEN` is valid.
* Review the Cursor Agent and ORL output for rule, language, workspace, or authentication errors.

For ORL concepts and supported rule workflows, see [ORL (Open Remediation Language)](/orl.md) and [Workspace](/orl/concepts/workspace.md)

**Plugin updates do not appear**

If a new version of the plugin is available but Cursor still shows an older version:

* Download the latest zip from the Google Drive link your Gomboc contact provided and replace the contents of your extracted folder.
* Run **Developer: Reload Window** in Cursor, or restart the app.

**Still need help?**

If you are still blocked, contact the Gomboc team with:

* the step where the setup failed
* the error message you received
* the absolute path to your extracted plugin folder
* the output of `docker info` (or `orl --help`, if you use a local binary)

See [Support](/support.md) for support channels.