> 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.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.gomboc.ai/orl/agent-skills/gomboc-enterprise-skills/cursor-enterprise.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.