# Deterministic replay for Cursor — recorded at the proxy, not scraped from history.

> Cursor keeps its history in a SQLite database, so Reelier doesn't pretend to scan it. Put the recording proxy in front of your MCP servers and capture the run losslessly instead.

Markdown twin of https://www.reelier.com/for/cursor — deterministic replay for Cursor. Reelier records what an agent actually did, compiles it into a SKILL.md with an assertion per step, and replays it at 0 LLM tokens with a receipt every run.

## How capture works on Cursor

Plainly: `reelier scan` does not read Cursor's history. Cursor stores it in a SQLite database rather than a replayable tool-call transcript, and scan's source list deliberately excludes it — an honest omission, not a gap it papers over.

Capture on Cursor is the recording proxy: `reelier mcp --wrap` fronts each local MCP server your agent uses and writes every call to `.reelier/traces/*.jsonl` while the server behaves exactly as before. Wrap captures lossless traces (tool annotations included) — scan-from-history is a reconstruction; wrap is the recording.

## Wire it up

### .cursor/mcp.json — Reelier's tools inside Cursor

```json
{
  "mcpServers": {
    "reelier": {
      "command": "npx",
      "args": ["-y", "reelier", "serve"]
    }
  }
}
```

Project `.cursor/mcp.json` or user `~/.cursor/mcp.json` — same `mcpServers` shape either way.

### terminal — Cursor rules file

```sh
mkdir -p .cursor/rules
curl -fsSL https://raw.githubusercontent.com/seldonframe/reelier/main/integrations/cursor/reelier.mdc \
  -o .cursor/rules/reelier.mdc
```

Cursor's project-rules mechanism — a thinner variant of the Claude Code skill: when to freeze, when to replay, never claim to replay a coding session.

### .cursor/mcp.json — record through the proxy

```json
{
  "mcpServers": {
    "your-data-server": {
      "command": "npx",
      "args": ["-y", "reelier", "mcp", "--wrap", "npx -y @yourco/mcp-server"]
    }
  }
}
```

The recorder. Only local stdio servers (`{command, args}`) can sit behind the proxy — remote http/sse/url entries can't be wrapped. The server behaves exactly as before; every call is also written to `.reelier/traces/`.

## First receipt in 60 seconds

1. Front your data server with the wrapped entry above and restart Cursor.
2. Run the job once in Cursor, as usual. The proxy records every tool call to `.reelier/traces/<name>.jsonl`.
3. `npx -y reelier compile .reelier/traces/<name>.jsonl -o my-job.skill.md` — Compile the trace into a skill — one assertion per step; the compiler lists its open questions instead of guessing.
4. `npx -y reelier run my-job.skill.md` — Replay deterministically: 0 LLM tokens, receipt written. `npx -y reelier diff my-job` gates drift from the second run on.

## A real receipt

Verbatim output of a portfolio replay, run with the published CLI (`npx -y reelier@latest`, resolved to reelier@0.12.1) on 2026-07-21. The run record confirms passed: true and 0 LLM tokens. Replay it yourself:

```
npx -y reelier@latest run examples/portfolio/registry-latest.skill.md

=== registry-latest ===
✓ Step 1 — Latest dist-tag from the registry [passed] 152ms

PASSED: 1/1 steps ok, 0 failed, 152ms total
```

## FAQ

**Why doesn't reelier scan read Cursor's history?**

Because it can't do so honestly. Scan reads directories of tool-call transcripts; Cursor's history is a SQLite DB and `.cursor/rules` is config, not a transcript. Rather than reconstruct from a format it doesn't understand, Reelier leaves Cursor off the scan list and records at the proxy instead.

**Which MCP servers can be wrapped?**

Local stdio servers — an entry with a `command` (and optional `args`). Remote http/sse/url servers can't sit behind a stdio proxy; Reelier's own config-rewriting command (`reelier install`, Claude Code only today) reports such entries as skipped rather than silently mis-wrapping them, and the same boundary applies when you wrap by hand.

**Does Cursor need to be running to replay?**

No. The skill is a markdown file; `npx -y reelier run` replays it from any shell, cron job, or CI runner at 0 tokens. Replays are read-only by default — write steps never re-fire without `--allow-writes`.

## Links

- [Your OpenClaw cron burns 2,880 LLM calls a month. Here's the same job at zero.](https://www.reelier.com/blog/openclaw-cron-costs)
- [Scheduled agents re-learn the job every run. Replay the part that never changes.](https://www.reelier.com/blog/scheduled-agents-zero-token)
- [Agent cost calculator — what re-reasoning a recurring job costs, with your numbers.](https://www.reelier.com/tools/agent-cost-calculator)
- [seldonframe/reelier — the engine, AGPL-3.0. Fork it, audit it, self-host it.](https://github.com/seldonframe/reelier)

Other agents: [Claude Code](https://www.reelier.com/for/claude-code) · [Codex](https://www.reelier.com/for/codex) · [Windsurf](https://www.reelier.com/for/windsurf) · [OpenClaw](https://www.reelier.com/for/openclaw) · [Hermes](https://www.reelier.com/for/hermes)