> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hyperspell.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Cursor

> Capture work in Hyperspell and explicitly continue recent work with the native Cursor plugin.

Connect Cursor to your company brain through [MCP](/agents/mcp). The optional
Hyperspell Activity plugin adds local work notes, capture and explicit handoff.
Your existing connection and its permissions are used for every brain read/write.

## Install the activity plugin

Use a local Cursor Agent workspace with one root folder, command hooks enabled,
and Python 3.11 or later. Managed policy may restrict local plugin imports or
hooks. A plain MCP connection does not install the activity plugin.

> [!NOTE]
>
> Version **0.1.0** is a preview in PR #4822. Until release, use the ZIP committed
> in that PR; the hosted download is not proof the new version has been published.
> The daemon's `hyperspell activity` commands configure Claude, not Cursor.

From the feature checkout, extract the standalone plugin to a directory you will
keep. This example uses Cursor's documented local plugin directory:

```bash theme={null}
mkdir -p "$HOME/.cursor/plugins/local/hyperspell-activity"
unzip apps/web/public/plugins/hyperspell-cursor-activity-0.1.0.zip \
  -d "$HOME/.cursor/plugins/local/hyperspell-activity"
```

Restart Cursor and check Customize for the plugin, its skill and hooks. Local
imports must be allowed by your organization. An installed marketplace copy with
the same name takes precedence; enable only the version you intend to test.
See [Cursor's local plugin instructions](https://cursor.com/docs/plugins#test-plugins-locally).

For the terminal CLI, use the separate workspace installation below.

Start a new conversation after installation. The plugin does not install or copy
credentials. Confirm the Hyperspell connection offers `log_activity` and
`get_memory`, and use your actual server name when configuring capture.

### Cursor CLI workspace installation

For the CLI on macOS/Linux, extract the ZIP outside Cursor's native plugin
folders, then register its hooks and skill in your workspace:

```bash theme={null}
mkdir -p "$HOME/.local/share/hyperspell-cursor-activity"
unzip apps/web/public/plugins/hyperspell-cursor-activity-0.1.0.zip \
  -d "$HOME/.local/share/hyperspell-cursor-activity"
python3 "$HOME/.local/share/hyperspell-cursor-activity/scripts/register-hooks.py" \
  --workspace /absolute/path/to/project
cursor-agent --workspace /absolute/path/to/project
```

Registration installs `.cursor/skills/hyperspell-activity/SKILL.md` and merges
marked entries into `.cursor/hooks.json`. It preserves unrelated hooks and MCP
settings, and refuses to overwrite an unmanaged skill. Repeating registration
updates the installed skill and hooks. Keep the extracted directory at that path.
Review workspace changes before committing: hook commands contain absolute paths.

Use this route without `--plugin-dir` and without an enabled native copy of this
plugin. Some CLI builds activate native plugin hooks only after workspace hooks
exist, causing duplicate delivery when both routes are enabled.

To remove this registration before switching to native plugin installation:

```bash theme={null}
python3 "$HOME/.local/share/hyperspell-cursor-activity/scripts/register-hooks.py" \
  --workspace /absolute/path/to/project --remove
```

Removal deletes only marked hooks and the managed workspace skill. Local notes,
unrelated configuration and existing credentials remain. Start a new conversation
after installing or removing either route.

## Enable capture and handoff

Ask Cursor:

```text theme={null}
Use /hyperspell-activity to configure capture suggest and handoff on,
using my hyperspell MCP server.
```

Both options start off. `suggest` with your personal credential keeps a capture
private and requests sharing review. `personal` makes no sharing request;
`shared` requests company visibility where policy permits. A company-wide
credential cannot provide personal privacy.

* `/hyperspell-activity status`: inspect modes, pending work, saved IDs and errors.
* `/hyperspell-activity now`: save a summary through your connected brain.
* `/hyperspell-activity continue`: list recent local work, then select a number.
* `/hyperspell-activity pause` or `resume`: control this conversation's captures.

Handoff uses an explicit selection. It does not draw a prompt band, interpret
ordinary bare-number prompts, switch Git branches or reopen an old transcript.

## What is saved

Working turns update a bounded local note without model calls or network writes.
Notes contain a recent reply excerpt, touched file paths and saved summary, with
at most 30 recent work notes as the retention target. Active captures are protected.
State is private to your local user under `~/.cursor/hyperspell-activity`
(or under `CURSOR_CONFIG_DIR` when set).

A capture asks the current model for a title, two-to-five-sentence summary,
decisions, next steps and links. It normally updates one Vault entry per piece of
work, identified locally by repository and branch. It can span conversations;
a different machine may create another entry. Full transcripts, thinking text
and raw tool outputs are not uploaded. See the
[Vault example](/integrations/all/vault) for what a saved work summary looks like.

Claude, Codex and Cursor have separate local notes. Saved remote summaries can be
read by another connected agent with the same access, but there is no automatic
cross-client local-note discovery.

## Read or share an earlier capture

Updated servers keep private checkpoints when a captured summary changes. Ask
Cursor to find an earlier decision in this entry, then read only the relevant
checkpoint. The hosted `list_activity_history` and `get_activity_checkpoint`
tools support bounded listing, search and reads. The updated CLI offers
`hyperbrain memories history` and `checkpoint` under the same app and identity.

These are captured summaries, not full conversation histories. They cannot recover
content that was never captured or revisions overwritten before history was enabled.
Personal access is required; sharing the current entry does not share its archive.

To share one earlier capture, ask Cursor to preview it and prepare a separate copy
through `request_activity_checkpoint_sharing`. Confirm creating the copy, then
review its ordinary sharing request using `list_sharing_requests` with `kind="all"`.
The copy remains unchanged by later captures. The CLI alternative is
`hyperbrain memories request-checkpoint-sharing`, with `--confirm` only after
authorization. Installing the plugin alone does not update Core or an older CLI.

Filtered entries and their history cannot be read. Updating a filtered entry
discards its hidden archive in the same transaction; a clean replacement starts
fresh. This prevents old filtered content from becoming readable again.

There is no automatic expiry yet. Deleting the original or erasing its owner/app
removes private checkpoints; separate copies have their own lifecycle. See
[Vault work history](/integrations/all/vault#read-or-share-an-earlier-capture).

## Review sharing in Cursor

Ask Cursor to list pending session entries, read the relevant ones, and share or
keep private the entries you choose. The hosted `list_sharing_requests` and
`decide_sharing_request` tools use your personal identity and existing sharing
rules. The updated `hyperbrain memories sharing-requests` and `decide-sharing`
commands are an alternative against the same app and user.

Sharing an evolving entry also shares its later summary revisions. Keeping a
pending entry private dismisses its request; it does not revoke an existing
share. Turning capture off does not delete or unshare saved entries.

## Timing, recovery and removal

Automatic capture requests one follow-up at a completed turn boundary after
15 minutes of quiet pending work or a compaction boundary. It uses the active
model and normal tool permissions. There is no background model while idle and
no guaranteed exit flush. Use `now` before clearing or closing.

A failed write stays pending. Check `status` before retrying; a response saying
"saved" is insufficient unless the saved ID is present and the reservation is
cleared. A stale reservation names its owner; explicitly cancel that owner's
capture if the conversation has ended. Cancellation cannot undo a remote write.

For native IDE installation, disable the plugin in Customize to stop its hooks.
For CLI workspace installation, run the registration command above with `--remove`;
Customize does not control workspace hooks. Stop sessions before removing the
extracted plugin folder. Local notes and remote
entries remain until separately deleted. Do not reset the state directory while
a capture is in flight. Cloud agents and multi-root workspaces are outside this
initial support scope. Terminal and IDE acceptance must be verified separately.

Cursor CLI headless mode may omit `stop` and `afterAgentResponse`. In that mode,
explicit `now` captures from the current conversation; observed file/tool work is
saved locally before preparation and at session end. Automatic turn-boundary
capture requires a host that actually emits `stop`. A missing end event can still
lose unsaved local observations; use `now` before ending important work.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.