delimit-mcp-server

# `</>` Delimit

**The merge gate for AI-written code, with signed, replayable attestation.**

Wrap any AI coding assistant (Claude Code, Codex, Cursor, Gemini CLI) with a governance chain that runs your gates, records what changed, and signs a replayable receipt for every merge.

[![npm](https://img.shields.io/npm/v/delimit-cli)](https://www.npmjs.com/package/delimit-cli)
[![Tests](https://img.shields.io/badge/tests-4800%2B%20passing-brightgreen)](https://github.com/delimit-ai/delimit-mcp-server)
[![GitHub Action](https://img.shields.io/badge/GitHub%20Action-latest-blue)](https://github.com/marketplace/actions/delimit-merge-gate-for-ai-written-code)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
[![Glama Score](https://glama.ai/mcp/servers/delimit-ai/delimit-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/delimit-ai/delimit-mcp-server/score)

```console
$ delimit wrap -- claude "fix the flaky test in tests/api.spec.ts"

✓ repo_diagnose
✓ security_audit       0 critical · 0 secrets
✓ test_smoke           165/165
✓ changed_files        1
✓ attestation signed   att_a05050eb8e13277e
                       delimit.attestation.v1 · HMAC-SHA256
                       replay → https://delimit.ai/att/att_a05050eb8e13277e
```

Every wrapped run emits a `delimit.attestation.v1` bundle: repo head before/after, changed files, gate results, HMAC-SHA256 signature, and a replay URL. Advisory by default; flip to enforcing when you're ready.

---

## Fastest path to value: `delimit check`

Zero-config PR safety gate. No `init`, no setup, no account, no keys — run it on any repo and it applies deterministic checks (breaking API changes + leaked secrets) to your staged or modified files.

```bash
npx delimit-cli check
```

```console
$ delimit check

  Delimit Check

  Policy: default | Base: HEAD | Specs: 1

  + api/openapi.yaml — clean

  PASSED — no breaking changes, no leaked secrets
```

When a check finds a breaking change or a leaked secret, it prints the offending file and the issue and exits non-zero — so it drops straight into a pre-commit hook or CI step.

Common options:

```bash
delimit check --staged          # only check staged files
delimit check --base main       # compare against a git ref (default HEAD)
delimit check --fix             # show migration guidance for violations
delimit check --record          # write a content-pinned record of this check
```

`--record` writes a content-pinned record of the check to `.delimit/records/check-<ts>.json` (or a path you name). That record is the precursor to the signed, replayable Seal attestation — the same evidence shape, pinned to the exact content you checked.

<p align="center">
  <a href="https://delimit.ai/methodology/mcp-attestation">Methodology</a> · <a href="https://delimit.ai/reports/cal-com-v2-attestation">cal.com v2 worked example</a> · <a href="https://delimit.ai/docs/workflow">Workflow guide</a> · <a href="https://delimit.ai">Website</a>
</p>

---

## Worked examples

Real, reproducible merge-gate runs against public API specs:

- **[OpenAI OpenAPI: a year of AI frontier evolution under a cross-vendor merge gate](https://delimit.ai/reports/openai-openapi-attestation)** — OpenAI (openai/openai-openapi)
- **[Stripe v1 OpenAPI: 57 days under a merge gate](https://delimit.ai/reports/stripe-openapi-attestation)** — Stripe (stripe/openapi)
- **[Anthropic API: 76 days under a cross-vendor merge gate](https://delimit.ai/reports/anthropic-api-attestation)** — Anthropic (anthropics/anthropic-sdk-python)
- **[Twilio v2010 OpenAPI: 55 days under a merge gate](https://delimit.ai/reports/twilio-api-attestation)** — Twilio (twilio/twilio-oai)
- **[Docusign eSignature v2.1 OpenAPI: 46 days under a merge gate](https://delimit.ai/reports/docusign-esign-attestation)** — Docusign (docusign/OpenAPI-Specifications)
- **[Supabase Auth OpenAPI: 57 days under a merge gate](https://delimit.ai/reports/supabase-auth-openapi-attestation)** — Supabase Auth (supabase/auth)
- **[cal.com v2 OpenAPI: 60 days under a merge gate](https://delimit.ai/reports/cal-com-v2-attestation)** — cal.com (calcom/cal.com)
- **[EU TED v3 procurement API: $ref'd component-schema drift under a merge gate](https://delimit.ai/reports/eu-ted-v3-attestation)** — European Commission (TED v3 Public API)
- **[Cross-agent handoff: one artifact, four CLIs](https://delimit.ai/reports/cross-agent-handoff)** — Cross-CLI session handoff (worked example)
- **[delimit-mcp-server (self-attestation): same merge gate, third artifact class](https://delimit.ai/reports/delimit-mcp-server-tdqs)** — delimit-mcp-server (self-attestation)

See the full index at **[delimit.ai/reports](https://delimit.ai/reports)**. For the schema and signing methodology behind every report, see **[delimit.ai/methodology/mcp-attestation](https://delimit.ai/methodology/mcp-attestation)**.

---

## Golden Path — your first 10 minutes

The merge gate for AI-written code, end to end: lint a spec, see exactly what breaks, classify the bump, settle the hard calls with multiple models, and walk away with a signed, replayable attestation. Then keep the context that survives across sessions and models.

### 1. Install

```bash
npx delimit-cli scan          # discovery: finds your OpenAPI specs, frameworks, security issues, tests
npx delimit-cli init          # wire up the merge-gate config (--preset strict | default | relaxed)
```

`scan` (`delimit_scan`) reports what Delimit can do for this repo. `init` (`delimit_init`) drops in the policy preset and merge-gate config. No account, no keys.

### 2. The merge gate, end to end

**Lint the spec change (the gate).** Baseline vs. proposed, with policy applied — one pass/fail verdict.

```bash
npx delimit-cli lint old.yaml new.yaml       # tool: delimit_lint
```

**See exactly what breaks.** Pure structural diff — added/removed/modified endpoints, schemas, params, no policy.

```bash
npx delimit-cli diff old.yaml new.yaml       # tool: delimit_diff
```

**Classify the bump.** Deterministic MAJOR/MINOR/PATCH/NONE — same input, same answer, every time.

```text
delimit_semver       → MAJOR/MINOR/PATCH/NONE + next version string
delimit_impact       → blast radius: scans your dependency manifest for downstream callers (informational)
```

**Settle the hard calls.** When the gate verdict is a judgment call, put it to multiple models and let them debate to consensus.

```bash
npx delimit-cli deliberate "Is dropping the deprecated v1 /users field a safe MINOR?"
#   tool: delimit_deliberate — 3 hosted runs after `delimit signin` (free account), then bring your own keys
```

**Capture the signed, replayable attestation.** After a gate event (deploy / security / test / audit), record the evidence bundle and verify it any time.

```text
delimit_evidence_collect   → signed evidence bundle for the audit trail        (Pro)
delimit_evidence_verify    → confirm a bundle hasn't been tampered with         (Pro)
delimit_seal_verify        → check a Delimit Seal receipt against its bundled   (Free)
                             Layer-0 constitution — offline-verifiable
```

Every receipt is offline-verifiable: `npx delimit-cli seal-verify <receipt.json>`, or open its `delimit.ai/att/<id>` replay URL.

### 3. Context that survives sessions and models

Decisions, constraints, and tasks persist across sessions and across AI assistants — switch from Claude Code to Codex, Cursor, or Gemini CLI without losing the thread.

**Memory** — persist and recall the *why*, not just the diff.

```bash
npx delimit-cli remember "v1 /users field is frozen until Q3 — downstream billing depends on it"
#   tool: delimit_memory_store
npx delimit-cli recall billing               # local recall over your saved memories (Free)
```

For semantic recall by meaning across sessions, the assistant calls `delimit_memory_search` (Pro) directly.

**Ledger** — one task list, shared across every assistant and session.

```text
delimit_ledger_add        → record a task/bug/feature/strategic item
delimit_ledger_context    → session-start: top open items by priority (what's queued)
delimit_ledger_done       → close with a note (auto-captures a PR URL as ship proof)
```

That's the loop: gate the change, sign the proof, keep the context. Run it once on a real spec and you've used the whole merge gate.

---

## Think and Build

Beyond the merge gate, Delimit orchestrates multi-model deliberation and autonomous builds. `delimit think` dispatches a strategic question to Claude, Codex, Gemini, and Grok; `delimit build` activates a background daemon that executes ledger tasks through the gate chain. `delimit vault` manages local secrets (AES-256).

Works across any configuration, from a single model on a budget to a full panel.

---

## Try it in 2 minutes

```bash
npx delimit-cli doctor            # 14 prescriptive checks — tells you exactly what to fix
npx delimit-cli status            # Visual dashboard of your entire governance setup
npx delimit-cli simulate          # Dry-run: see what would be blocked before you commit
npx delimit-cli scan              # Instant health grade for your API spec
npx delimit-cli try owner/repo    # Try governance on any GitHub repo
```

No API keys. No account. No config files.

### Pick your first win

**Protect my API** — catch breaking changes before merge:
```bash
npx delimit-cli try
# Creates a sample API, introduces breaking changes, shows what gets blocked.
# Saves a governance report to delimit-report.md
```

**Watch for drift** — detect spec changes without review:
```bash
npx delimit-cli init        # Sets up governance + drift baseline
# Weekly drift checks run automatically via GitHub Action
```

**Run PR copilot** — governance gates on every pull request:
```yaml
# .github/workflows/api-governance.yml
- uses: delimit-ai/delimit-action@v1
  with:
    spec: api/openapi.yaml
# Posts gate status, violations, and remediation in PR comments
```

---

## What's New