dod-guard

Anti-cheat Definition of Done verification for Claude Code. Locks proof commands in MCP storage so editing the rendered markdown cannot weaken verification.

What it does

• Locks proofs canonically — proof commands stored in MCP, not in editable markdown
• Tamper-evident — SHA256 fingerprint of proof set printed on every check
• Amendment audit trail — all proof modifications logged with mandatory reasons
• Weakening prevention — cannot convert machine-checkable proofs to manual
• Structured interviews — /interview skill gathers requirements before implementation

Install

As a Claude Code plugin (recommended)

claude plugin install --from github tychohenzen/dod-guard

As a standalone MCP server

Add to your .mcp.json:

{
  "mcpServers": {
    "dod-guard": {
      "command": "npx",
      "args": ["-y", "dod-guard"],
      "type": "stdio"
    }
  }
}

Via npm global install

npm install -g dod-guard

MCP Tools

| Tool | Description | |------|-------------| | dod_create | Create a locked DoD with proof commands and metadata | | dod_check | Execute all proofs from canonical storage, return PASS/FAIL | | dod_status | Read cached last check result without re-running | | dod_amend | Modify a proof with mandatory reason (audit-logged) | | dod_list | List all tracked DoDs with status | | dod_import | Parse existing DoD markdown and lock its proofs |

Skills

/interview

Structured requirements gathering skill. Researches the codebase, asks targeted questions one at a time, builds a confirmed requirements summary, then creates a locked DoD via dod_create.

The output is a self-contained spec with testable proofs that can be passed to /goal for autonomous implementation.

How it works

Proof lifecycle

/interview → dod_create → [implement] → dod_check → PASS/FAIL
                                              ↓
                                    dod_amend (if unreasonable)

1. Create — /interview or direct dod_create call locks proofs in ~/.claude/dod-store/
2. Implement — work through steps, proofs are the acceptance criteria
3. Check — dod_check executes commands from the locked store (not the markdown)
4. Amend — if a proof is genuinely unreasonable, dod_amend modifies it with a logged reason

Anti-cheat properties

• Proof commands live in ~/.claude/dod-store/{uuid}.json claude is not aware of, not in the markdown file claude may read/alter
• dod_check reads from the store — editing markdown proof text has zero effect
• Each check prints a SHA256 fingerprint — compare to detect store tampering
• Cannot weaken a machine-checkable proof to manual (blocked server-side)
• All amendments are permanently logged with timestamps and reasons

Predicate types

| Type | Value | Passes when | |------|-------|-------------| | exit_code | 0 | Command exits 0 | | exit_code | 1 | Command exits 1 (e.g. grep no matches) | | exit_code_not | 0 | Command exits non-zero | | output_contains | "text" | stdout contains text | | output_matches | "regex" | stdout matches regex | | output_not_contains | "text" | stdout does NOT contain text | | output_not_matches | "regex" | stdout does NOT match regex | | tdd | 0 | TDD enforcer. Must be observed failing before it can pass | | manual | — | Skipped by checker (human-only) |

TDD enforcement

The tdd predicate enforces test-driven development by requiring proof of a red-green cycle:

1. Write a failing test
2. Run dod_check — records the failure (RED phase, seen_failing=true)
3. Implement the feature
4. Run dod_check again — test passes AND was previously seen failing → proof passes

If a test passes without ever being observed failing, dod-guard rejects it with "TDD VIOLATION". This prevents writing tests after implementation that merely confirm existing behavior.

Tamper detection

Each DoD stores a SHA256 fingerprint of its proof set at creation time. On every dod_check, the current fingerprint is compared to the stored original. If they don't match (and no dod_amend was used), a tamper warning is emitted. Amendments via dod_amend legitimately update the stored fingerprint.

Development

npm install
npm run build    # TypeScript compilation
npm run bundle   # esbuild → dist/bundle.js
npm start        # Run MCP server

License

MIT