Shipmoor

Shipmoor × Cursor

Shipmoor for Cursor

Cursor writes the code. Shipmoor catches the structural defects and claim gaps the agent slips in, locally, with deterministic checks an LLM never overrides, and holds the agent to a fix before it calls the work done.

Get started → Install Community CLI
  • Local structural scan in Cursor
  • Stop-gate via native Cursor hooks
  • No source upload

The summary says done. The scan says phantom import · afterFileEdit re-checks every edit.

Cursor's agent edits across your repo at a pace no reviewer keeps up with, then hands you a diff with a confident summary. The summary is not the change. Shipmoor closes that gap with deterministic checks that run where the code is created, not after it's already on a reviewer's screen.

  • local scan
  • deterministic gate
  • native Cursor hooks
  • an LLM never blocks
  • no source upload
$ shipmoor scan --changed
 
scanning 6 changed files · cursor agent edit
✗ high   SM-IMP-002  phantom import        src/api/orders.ts:3
         'normalizeCart' imported from ./cart · not exported there
! med    SM-STB-007  placeholder stub      src/api/orders.ts:48
         applyDiscount() returns 0 · empty body, no logic
 
verdict: 1 high · gate would block · fix before "done"
human · json · sarif output · stable CI exit codes

Phantom imports, placeholder stubs, and silenced errors all read as "done" to the agent; Shipmoor reads them as findings.

Three ways Shipmoor plugs into Cursor

From a free local scan you run yourself, up to an enforced stop-gate wired with Cursor's native hooks.

  • 01 · Community CLI

    Local structural scan

    Scan your changes for phantom and undeclared imports, placeholder and empty-body stubs, and silenced errors. Human, JSON, and SARIF output; stable CI exit codes.

    Live · free
  • 02 · Agent Skills

    Behaviors in .cursor/rules

    shipmoor skills install cursor writes an always-applied rule that tells the agent to scan, triage, and gate before "done", and not to invent imports or fake success.

    Live · IC
  • 03 · The harness loop

    Soft adapter today

    shipmoor harness install cursor installs a soft adapter that points the agent at the latest scan report. A hard, enforced stop-gate is wired with native Cursor hooks (below).

    Soft adapter live · native-hook adapter roadmap

We'll be straight about the asymmetry: on Claude Code, the harness installs a hard PostToolUse + Stop loop that blocks and feeds findings back out of the box. On Cursor, the shipped adapter is a rules nudge today, but Cursor's native hook surface lets you build the same hard gate now, and a first-class adapter that does it for you is in progress.

A real stop-gate in Cursor, today

Cursor exposes lifecycle hooks via .cursor/hooks.json. Two of them give you a Claude-parity gate driven by one-shot shipmoor scan calls, with no background daemon.

  • afterFileEdit Re-scan the file the agent just edited Refresh the report the agent is told to treat as authoritative, so findings are never stale.
  • stop Hold the agent until blockers clear When the agent tries to finish, scan the change-set; if a blocking finding is present, return a followup_message (auto-submitted as the agent's next turn) so it keeps working. A loop_limit bounds it so a session can never get stuck. 
{
  "version": 1,
  "hooks": {
    "afterFileEdit": [{ "command": ".cursor/hooks/shipmoor-scan-edit.sh", "timeout": 30 }],
    "stop":          [{ "command": ".cursor/hooks/shipmoor-gate.sh", "timeout": 90, "loop_limit": 3 }]
  }
}

The stop script runs shipmoor scan --changed --fail-on high; if it finds blockers, it prints them as the follow-up message. That's the whole gate. A rule that asks an agent to scan is advisory; a gate that won't let it say "done" until the blockers clear is enforced, and that difference is the point.

Deterministic evidence decides: an LLM never blocks

A gate you could hallucinate past would be worse than none

Every finding that can hold the gate comes from a deterministic structural check. Shipmoor's architecture structurally bars any LLM inference from producing a blocking verdict: a model can advise, never block. The optional advisory runs inside your own coding agent (Shipmoor hosts and calls no model) and is labeled as inference, excluded from the verdict.

What this is not: Shipmoor catches what didn't earn its claim and says "couldn't check" where it has no probe. It doesn't prove your change did what the ticket asked, and it checks structural risk, not logic or design. Your tests still run. It raises the floor and gives a repeatable checkpoint; it doesn't replace your judgment.

Check the change against the task

Beyond defects, Claim Check compares an agent's change to the task it was given, and flags work that's well-formed but doesn't do what was asked.

Claim Check

Resolves intent from the ticket, prompt, or the Cursor agent session (secrets masked on ingest). A deterministic floor decides; the LLM only advises.

Local first: your source never leaves

The scan engine runs on your machine or in your own CI runner. The Shipmoor Console handles licensing and billing only; it never receives your source. No source upload, at any tier.

PythonTypeScriptJavaScriptGo

Get started in Cursor

Start free and local with no account, then add the agent skills and harness adapter.

shipmoor scan --changed

Free, local, no account. Scan your current changes before you wire anything up.

  • Install the always-applied Cursor rule

    shipmoor skills install cursor

  • Install the harness adapter

    shipmoor harness install cursor

  • Start safe: report only, then escalate

    shipmoor harness mode observe

The Community CLI is free. Agent Skills, Claim Check, and the harness are part of Shipmoor IC ($19/dev·mo, $190/yr). Self-serve, no sales call.

Catch it in Cursor, before review

One installer. One shipmoor command. Free Community scans, then wire the stop-gate with Cursor's native hooks.

curl -fsSL https://dl.shipmoor.dev/install.sh | bash

Install Community CLI →

Keep exploring