Getting Started

The background, agent-agnostic watcher: a debounced scan-on-change loop with a privacy-safe event stream. Paths, rule-ids, and counts only, never source or finding prose.

Test Evidence is a standalone command, and, for any caller entitled to Claim Check's full mode, it's also automatically composed into shipmoor claim-check as one more concurrent evidence producer over the same change surface. How passed, reduced, and weakened each land in the gate, what changes without the hook wired, and running Test Evidence directly in CI.

Per-agent install targets and how the loop runs in Claude, Codex, Cursor, and Aider, with a worked example of the review and pr-preflight loops on a real change.

Common Shipmoor Claim Check situations and fixes: the claim_check entitlement, unknown_signing_key, an unapproved acceptance draft producing INCONCLUSIVE, fix-packet tag matching, malformed acceptance sets, unknown agent commands, judge failures, and why the CI exit code now gates unconditionally. Diagnose with shipmoor doctor and shipmoor capabilities.

Common Shipmoor Code Review situations and fixes: the cli_pro entitlement locked, no agent configured, the agent self placeholder, exit-3 operational failures, large diffs, non-UTF-8 paths, and why a review never blocks a merge.

Common issues and fixes: PATH after install, phantom-import noise when third-party deps aren't installed (scope to --changed), license and entitlement not detected, and CI exit-code handling.

How Claude Code's native hooks close the loop: the agent makes an edit, the PostToolUse hook scans it, a finding is handed back (additionalContext in feedback mode, stderr and exit 2 in block mode), the agent fixes its own mistake, the re-scan clears, and the Stop hook gates before the agent declares done.

For obligations the deterministic floor can't check mechanically, your own coding agent adjudicates. It can only BLOCK by citing a divergence that survives execution, or ABSTAIN by routing to a human. It never passes a check. K=3 samples, 2-of-3 to block, a confidence floor below which the judge steps back, two-phase decomposition then audit, and evidence pointers confirmed by running them for real.

What each skill does and the CLI loop it drives: shipmoor-review, shipmoor-fix, shipmoor-intent-contract, shipmoor-agent-guard, and shipmoor-pr-preflight.

The full depth on the three signals shipmoor test-evidence reports: passed (deterministic, harvested with three assurance levels), reduced (a test-id set difference that catches a deleted test), and weakened (a judgment-only signal whose schema makes a pass literally unrepresentable). Includes the anti-gaming design and findings measured in Shipmoor's own evaluation harness.

Device-flow auth (shipmoor login / logout / whoami) and the local-license model: a signed token read from SHIPMOOR_LICENSE_TOKEN, SHIPMOOR_LICENSE_FILE, or ~/.shipmoor/license.jwt, verified offline with no source or token sent to Shipmoor.

The local-first guarantees: no source upload ever, no Shipmoor cloud in the critical path, offline license verification, BYO-Judge under your own provider, and the data-residency posture. Notes which governance features are on the roadmap (RBAC, SOC 2 / ISO).

Run the structural scan and scope it to what your agent changed: scan [path], --changed, --staged, --diff, and --patch.

Emit SARIF from a Shipmoor scan, upload it into GitHub code scanning, and handle the exit-code contract (exit 1 means the gate fired, not an error) so findings still reach the Security tab.

Every detection rule Shipmoor ships, grouped by language and failure class, with severity and a short description. Generated from shipmoor rules.

The four Claim Check verdicts, READY, READY WITH GAPS, BLOCKED, and INCONCLUSIVE, and exactly how they're fused from the floor's binary signal and the judge's opinion. Includes a full worked example of the fix packet: fixes, route_to_human, and author_checks.

Run your first advisory Shipmoor Code Review in five minutes: install the 0.6.0 CLI, sign in for cli_pro, run shipmoor review --agent claude, and read the shipmoor.scan.v1 output.

Install Shipmoor and run your first scan on an agent-generated change in five minutes. Free, local, no account.

Wire the PostToolUse hook into your coding agent, run shipmoor test-evidence over a real change, and read your first passed, reduced, and weakened report in about five minutes.

Where intent comes from on shipmoor claim-check: --intent-ticket outranks --intent-prompt outranks the acceptance file's own goal key. How agreement across sources sets confidence, the wider ticket, session, prompt, and manual precedence on claim-check resolve, and what changes for an acceptance set committed before this model.

What leaves your machine, and what never does. Your source, diffs, and intent text stay local. The only model that ever sees your change is the agent command you configure yourself, running as a subprocess you control. The deterministic floor never calls a model at all. A local, opt-in signal helps grow the probe library, and it never leaves your machine either.

What each Shipmoor tier unlocks: Community (free), Shipmoor IC ($19/dev·mo), and Team / Enterprise (coming soon), and which entitlement gates which feature.

Shipmoor is a local-first code-integrity layer that catches defects and claim gaps in agent-generated code before they reach review or production.

Test Evidence checks whether a coding agent's tests actually ran and passed, whether the test surface was quietly shrunk, and whether a kept test was gutted so it can never fail again. Two signals are fully deterministic; the third rides Claim Check's judge machinery and can only ever flag weakened or stay silent, never certify a pass.

The three output modes: human, deterministic JSON (shipmoor.scan.v1), and SARIF. Covers --output and --markdown-summary, and the stable CI exit-code contract (0 clean, 1 threshold/gate, 2 usage, 3 scan-failed).

The stable JSON contracts every consumer reads: shipmoor.scan.v1, shipmoor.capabilities.v1, and shipmoor.identity.v1, with the schemas and the rule that the entitlement vocabulary is defined once in shipmoor-core.

Manage billing and licenses in the Console (accounts.shipmoor.dev): sign-up, SSO via GitHub/WorkOS, Stripe billing, and upgrading through the CLI. The Console is a control plane and never receives source code.

Manage skills with shipmoor skills {list,install,uninstall,status}. How install writes a single managed block into your agent's file (e.g. CLAUDE.md) and how capabilities gate availability.

Install the universal Shipmoor CLI, put it on your PATH, choose a release channel, and keep it current with shipmoor upgrade.

Install the harness into an agent with shipmoor harness install, inspect it with status --json, and pick a mode: observe, feedback, or block. What each mode does to the agent loop.

Install the Shipmoor IDE extension from the VS Code Marketplace or Open VSX, point it at your signed-in CLI, and see findings as native editor diagnostics.

The Shipmoor IDE Extension brings the same CLI-backed integrity findings into your editor as native diagnostics. A thin client over the shipmoor CLI: same scan, same schema, same findings as CI. (IC feature.)

Advisory Shipmoor Code Review in VS Code: review findings render as Information-level diagnostics in a separate collection, excluded from your problem counts, and kept structurally distinct from the structural scan.

Run Shipmoor as a local CI gate in GitHub Actions and upload SARIF to code scanning, using the copy-paste workflow or the composite action.

The exit-code mapping is unconditional: BLOCKED and INCONCLUSIVE always exit 1, READY and READY_WITH_GAPS always exit 0. No flag or config key softens a bad verdict. How the verdict is fused, why an unapproved acceptance set reads as INCONCLUSIVE, how to keep a CI step informational, and the floor policy file's real, narrow tuning scope.

Make a scan block: --fail-on <severity>, the severity policy, and how baselines suppress known findings. Notes which policy/baseline capabilities are Community vs Team.

The generated-code failure modes Shipmoor catches (phantom import, hallucinated API, stub path, and more), the severity model, and shipmoor rules / shipmoor explain <finding-id> for the catalog and per-finding guidance.

Wire Shipmoor into Cursor with the native .cursor/hooks.json adapter, the supported single-repo path, plus an advanced pattern for multi-root workspaces.

The mental model behind Shipmoor: the structural scan, the claim check, severity, the three claim-check axes, tiers and entitlements, and the local-first guarantee.

Project configuration: .shipmoor.yaml/.shipmoor.yml discovery, the harness block, .shipmoor/intent files, the verdict-policy and baseline files, and the adapter-managed files Shipmoor writes into your agent.

Install and use the free local Shipmoor Community CLI for pre-merge checks on agent-assisted code.

Shipmoor Code Review is an advisory, bring-your-own-agent AI review that runs locally, hosts no model, uploads no source, and never gates your build. Learn how it differs from the deterministic structural scan. (Pro feature.)

The complete shipmoor claim-check surface in 0.8.0: the positional target, selectors, --floor-only, --acceptance, the --agent judge, the intent flags, output flags, the config file, the init/resolve/probes subcommands, and the unconditional exit-code model.

The complete shipmoor review surface: selectors, the --agent reviewer, execution knobs, output flags, and the exit-code model. A review never returns the gating exit code 1.

The complete shipmoor test-evidence surface in v0.8.0: the positional target, the --staged/--diff/--all/--from/--to selectors, the --agent weakened-test judge, --high-assurance, --attest-out, --json, --terse, --no-color, exit codes, the hook subcommand, and the test_evidence: config block.

The complete shipmoor command surface: scan and its scopes/flags, rules, explain, login/logout/whoami, capabilities, upgrade, skills, harness, repair-guidance, and version, with the tier each requires.

Wire Shipmoor into Claude Code on three levels: the scan engine, always-on Skills, and Harness lifecycle hooks that make the scan happen and gate the result.

Sign in, write a small acceptance set by hand with shipmoor claim-check init, run your first check with a one-line --intent-prompt, and read a real READY verdict and a real BLOCKED one, in about five minutes.

Claim Check checks whether a change did what the task asked. A deterministic floor decides READY or BLOCKED; an optional bring-your-own judge can only block or abstain, never pass. When it can't decide something on its own, it hands back a fix packet naming the exact test to write next.

Run Shipmoor as a local CI gate: the same scan you run on your laptop, scoped to the change, exiting with a stable code. No source upload, SARIF into code scanning, and Claim Check available as advisory or a gate you opt into.

Wire shipmoor claim-check into CI. The exit code maps BLOCKED and INCONCLUSIVE to a non-zero code unconditionally, so the real per-team choice is floor-only versus full judge-enabled mode in the blocking step, not whether to gate at all. Covers GitHub Actions, generic CI, the VSA artifact, an optional advisory judge step, and Test Evidence composition.

Post advisory Shipmoor Code Review comments on pull requests that never gate the build, using a hardened split-workflow trust model so an untrusted fork PR can never combine source checkout with your agent's credentials.

Public release notes: notable user-facing changes by version, starting from the v0.4.0 mono-repo consolidation. Curated from the internal CHANGELOG.

Read this machine's entitlement state with shipmoor capabilities --json (shipmoor.capabilities.v1). The entitlement vocabulary (intent_scan, agent_skills, agent_harness, ide_extension_pro, …) and how grace/expiry behave.

Claim Check runs several evidence producers concurrently and records every outcome as a content-addressed attestation on disk. The VSA (Verification Summary Attestation) is the one binding output; a trace sidecar is additive only. How the fix packet's evidence pointers relate to the VSA's per-item dispositions.

Bring your own agent as the reviewer. The stdin ChatRequest to stdout ChatResponse wire contract, the built-in claude, codex, and cursor presets, the example-agent.py reference, and the review then fix loop through Skills and the harness.

The four harness adapters, Claude Code, Cursor, Codex, and Aider: what each install command writes, the files it manages, and how the scan decision is delivered back to the agent.

Agent Skills run the Shipmoor loop from inside your coding agent: review, fix, claim-check, guard, and PR preflight, installed straight into Claude, Codex, Cursor, or Aider.

The local feedback loop for coding agents: the harness watches what your agent edits, runs shipmoor scan against those edits, and routes findings back into the agent's context so it fixes its own mistakes during the session. Bundled into the shipmoor binary as shipmoor harness. (IC feature.)