# Delivery Integrity Prover MCP

> Delivery Integrity Prover forces your AI agent to prove its work at every step. It stops agents from declaring a task 'done' until you see concrete proof: a checklist mapping every requirement, specific file changes with line numbers, verifiable build or test logs, and an explicit list of any remaining gaps.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** delivery-integrity, task-completion, verification, self-reflection, ai-coaching, quality-gate, testing

## Description

AI models can be fast, but they often rush to the finish line. They might declare success even if half the required code is missing or if they just left 'TODO' comments in the files. This MCP acts as a mandatory quality gate for your development work. Instead of accepting an agent’s summary message, it forces the system to map every single user requirement back to actual file changes; it demands execution logs—like successful build outputs or passing test suites. If anything is unverified, incomplete, or assumed, this connector flags it immediately. By connecting Delivery Integrity Prover through your Vinkius catalog, you ensure that your AI client doesn't just *say* the task is done; it proves it with evidence.

## Tools

### verify_delivery
This tool forces the agent to provide a structured report detailing how it met all requirements, listing specific file changes and providing necessary build logs before giving a final verdict.

## Prompt Examples

**Prompt:** 
```
I have successfully finished creating the user profiles page. I edited the view files.
```

**Response:** 
```
Verdict: INCOMPLETE_REQUIREMENTS. You claimed completion but did not map the prompt instructions to specific changes. Document how every requirement was implemented and check your pivots.
```

**Prompt:** 
```
Task: Create page speed middleware. Checklist: SpeedMiddleware parses headers (verified in src/middleware.ts:L12-30). Files: src/middleware.ts. Logs: npm run test output shows '12 tests passed, 0 failed' after running MiddlewareSuite. Gaps: Bypassed checking on dynamic routes, needs manual verification on live server. Pivots: all true. Verdict: DELIVERY_PROVEN.
```

**Response:** 
```
Verdict: DELIVERY_PROVEN. Requirements are mapped, middleware files updated, test logs provided, and route parsing limitations documented. Delivery verified.
```

**Prompt:** 
```
Task: Create page speed middleware. Checklist: SpeedMiddleware parses headers. Files: src/middleware.ts. Logs: Everything worked fine when compiling. Gaps: none. Pivots: requirementsMapped=true, artifactsModified=true, verificationExecuted=true, gapsIdentified=true, integrityProven=true. Verdict: DELIVERY_PROVEN.
```

**Response:** 
```
Verdict: UNVERIFIED_CHANGES. Your verification logs are a placeholder ('Everything worked fine'). Execute actual test or compile commands and provide the real console output to verify integrity.
```

## Capabilities

### Map requirements to changes
It forces the agent to create a checklist showing exactly which lines of code address each specific item in your prompt.

### Validate file modifications
The MCP ensures that every claimed change lists exact file paths and line number ranges, preventing vague claims like 'updated the whole module'.

### Supply execution evidence
It requires compilation output, test results, or build logs to prove code actually ran successfully.

### Identify remaining gaps
The system forces the agent to list any outstanding assumptions, manual checks required, or features that were out of scope.

## Use Cases

### Refactoring a core service endpoint
A developer asks their agent to refactor authentication logic. The agent claims success, but the `verify_delivery` tool immediately flags that while the main file was updated, the necessary corresponding unit tests were not run or logged.

### Building a multi-step data pipeline
The goal is to process user data through three services. The agent completes steps 1 and 2 but forgets step 3 (logging). Running the verification tool forces the agent to document the missing third service, preventing a broken release.

### Migrating an old API structure
The prompt requires updating five files and changing three endpoints. The agent updates only four files and leaves one endpoint untouched. Running `verify_delivery` generates the 'INCOMPLETE REQUIREMENTS' verdict, pointing directly to the missing file.

### Implementing security patches
The patch requires updating middleware and running full regression tests. The agent only changes the code and provides a placeholder log ('Looks good'). Running `verify_delivery` rejects this immediately, demanding real build logs or the process fails.

## Benefits

- You stop accepting vague claims. The `verify_delivery` tool demands a clear, auditable checklist that maps every single prompt requirement to an actual code change.
- It prevents incomplete commits. By requiring specific file paths and line ranges for modifications, you eliminate ambiguity about what actually changed in the codebase.
- You gain proof of execution. The MCP requires compilation output or test logs; 'it should work' is rejected if there are no verifiable outputs.
- You catch blind spots. It forces the agent to explicitly list any remaining assumptions or gaps that need manual review, making the delivery risk visible.
- It enforces quality at scale. Integrating this into your workflow makes it impossible for an AI agent to skip critical steps and still claim success.

## How It Works

The bottom line is you get an auditable record proving adherence to every requirement before committing code.

1. First, define the full task objective and all mandatory requirements for your AI agent.
2. Second, have the agent execute the code changes and generate standard outputs: updated files, build commands, and test runs.
3. Finally, use this MCP to run the verification protocol, supplying all logs and file mappings. The system returns a verdict that confirms whether or not the delivery is genuinely complete.

## Frequently Asked Questions

**Why are placeholder logs like 'tests passed' rejected?**
AI agents frequently assume that code works without executing it. Requiring actual command output logs forces them to run verification scripts, catching syntax errors and test failures early.

**What counts as a remaining gap?**
A remaining gap includes any manual check required by the user, edge cases that were explicitly left out of scope, or dependencies on other teams. Banning 'none' forces agents to acknowledge limitations.

**How does this prevent agents from lying about completion?**
It converts simple guidelines into strict tool-call checks. The agent must successfully match requirements to modified code lines and paste actual command outputs to get an approval verdict.

**How does using verify_delivery ensure that my AI agents pass security audits?**
It enforces strict, auditable proof of work, which is essential for secure codebases. By requiring explicit mapping of every requirement and listing file changes with specific line ranges, it prevents agents from making unrecorded or undocumented modifications before deployment.

**If an AI agent hits a compile error, how should I use verify_delivery?**
You must provide the actual compiler output as part of your verification logs. The tool demands empirical evidence; generic failure statements are rejected and require the agent to explicitly document and prove the fix before marking the task complete.

**When a user requirement is subjective, like 'improve UX,' how can I use verify_delivery?**
You must capture the implementation of those requirements in the ‘Remaining Gaps’ section. While code changes are mandatory for technical items, non-code decisions or required manual review steps belong explicitly listed as outstanding tasks to be audited later.

**Does running verify_delivery multiple times impact my API rate limits or performance?**
It consumes standard agent execution resources, but the quality assurance it provides outweighs that cost. Since it forces a full verification cycle (logs + files), treat it as your mandatory final CI/CD gate step within the workflow.

**What is the best way to integrate verify_delivery into an existing agent pipeline?**
Call verify_delivery as the absolute last step of your agent's execution sequence, right before any deployment trigger. This ensures that no matter how many steps happen beforehand, the task cannot be claimed complete without passing this structured audit gate.