MERGE INTEGRITY / GITHUB-NATIVE

Evidence for the code that landed.

Connect checks, approvals and repository rules to the exact merge candidate. See what changed, what landed, and what the evidence cannot establish.

Examples use synthetic data. No login or repository access.

YOUR CI AND MERGE QUEUE

Run checks on changes and their combined state.

MERGE PROOF

Make the relationship between evidence, candidate and landing inspectable.

INSPECT BEFORE YOU CONNECT

Read a result, including its limits.

Synthetic public examples.
Not customer results.

Tree equality alone does not prove that tests ran, checked out the expected code, or covered the behavior you care about.

HOW IT WORKS

Follow the evidence through the merge.

Candidate, evidence, currentness and landing
  1. Identify the candidate

    Bind the repository, PR, head, base and provider merge target to exact commit and tree identities.

  2. Establish what supports it

    Collect available checks, workflow execution records, approvals and applicable repository rules. Missing or unsupported evidence stays explicit.

  3. Recheck what changed

    Relevant GitHub events queue re-proofs. A fresh observation establishes currentness; a retained CURRENT label cannot do that by itself.

  4. Compare what landed

    When the required landing identities are available, bind the receipt to landed content. If they are missing or ambiguous, leave that relationship NOT_PROVEN.

GitHub merge queues already test combined changes. Merge Proof adds an inspectable evidence chain; it does not replace the queue or assume your merges are untested. Base movement alone is not a bug or an automatic failed verdict.

GitHub remains the source for provider checks, reviews and merge records. Git identities identify content; they do not independently authenticate those provider facts. A receipt is a point-in-time observation, not an atomic GitHub merge decision or a guarantee about a future merge.

SCOPE AND LIMITS

Evidence you can inspect, gaps you can act on.

Merge Proof is deterministic merge integrity, not an AI reviewer, security scanner or CI replacement.

Checks, approvals, rules and currentness
Checks and execution
Distinguishes accepted check conclusions from matching workflow, job and step execution records. Status-only success does not prove execution. Even execution records do not prove checkout contents or semantic test coverage.
Approvals and rules
Uses available classic protection and applicable rulesets together. Old-head approvals are insufficient under the implemented policy. Code-owner coverage, required teams, review-thread resolution and other unsupported requirements remain explicit gaps.
Currentness and history
Preserves the issued receipt and records refreshed observations separately. Provider unavailability is not proof of currentness or absence. Landing and merge records describe what could be bound, not GitHub's decision at the exact merge instant.
Technical boundaries and portable evidence

Two matching bounded observations detect observed races, but the GitHub API is not an atomic snapshot. Exact candidate, check producer and attempt identities matter. Missing validation requirements do not become automatic VERIFIED. Unsupported queue requirements, including ALLGREEN other-entry evidence, cannot be waived.

HTML and JSON receipts expose the evidence and gaps. Eligible receipts can carry portable replay artifacts. Unsigned replay checks consistency over supplied inputs; it does not establish packet provenance or independently authenticate GitHub facts. Git-derived facts can be recomputed against a separately acquired repository copy.

Merge Proof does not guarantee correctness or security. The free local CLI and Action inspect local Git evidence; they do not collect the hosted service's CI execution, approvals or remote-ref evidence.

Read the hosted evidence policy on GitHub →

READING THE RECEIPT

Unknown stays unknown.

Receipt labels and Git terminology
Policy Checks and merge authority

A passing policy Check is not necessarily a VERIFIED receipt. Policy determines which gaps block under the selected preset; GitHub separately decides whether the Check is required. A published Check is not an atomic merge authorization.

PR, repository & merge

Repository: a project's code and history. PR / pull request: proposed new work waiting for review and addition to the main code. Merge: integrating that work into the target version of the project.

Green checks & CI

CI (Continuous Integration): automated workflows that build, test or check changes. Green checks: GitHub reporting that automated checks passed. Passing checks don't establish that code is bug-free.

Branch, main, base, head & SHA

Branch: a separate line of development. Main: the primary version the team builds around; its branch may have another name. Base: the version receiving the changes. Head: the proposed version. SHA: the Git identifier used to tell exact versions apart.

VERIFIED & NOT_PROVEN

VERIFIED: for a CURRENT receipt, available evidence sufficiently satisfies the implemented checks for the stated scope and exact observed state. It is not a correctness or security guarantee.

NOT_PROVEN: Merge Proof could not establish everything required from the available evidence. Missing, ambiguous, unsupported or unavailable provider evidence stays NOT_PROVEN. This does not mean broken, buggy or unsafe. The receipt explains the gap.

STALE & currentness unavailable

STALE: something relevant changed. The old proof should not be treated as proof of what is there now. It does not mean the code is broken.

Freshness is separate from the original verdict. Without a fresh observation, the receipt shows CURRENTNESS UNAVAILABLE / REFRESH REQUIRED. Time passing alone does not make evidence stale. Re-proof evaluates the current situation.

FAIL & receipt

FAIL: sufficiently bound evidence demonstrated that a required condition was unmet. Collection uncertainty, missing evidence and provider unavailability are NOT_PROVEN instead. Neither verdict is a judgment that your code is bad.

Receipt: a saved record of the evidence, verdict, gaps and next action at that moment. When landing can be bound, a portable receipt can carry that evidence with the landed content.

TRY IT ON YOUR REPOSITORY

Connect GitHub. Keep your merge workflow.

7 days free. No card.
Report-only trial.

Authorize repositories and Merge Proof discovers open PRs, then queues proofs and re-proofs after relevant events. With no open PR, it watches for the next one without starting the trial. Provider errors, missing permissions or capacity limits can require attention.

During a new trial, Merge Proof observes and reports without blocking your merges. It does not enable new enforcing policies; previously configured enforcing policies remain enforced.

What you grant, and what we retain

Real source access
Contents read is real source access. Workflow text, API patch text and exact Git objects may reach the server. Deterministic reconstruction uses a private partial bare mirror and retains exact Git objects and receipt refs for replay. Customer code is not executed.
Limited writes
The standard App can publish or update its own receipt Check. It has no Contents write authority: it cannot push commits, modify files or workflows, merge or close PRs, post PR comments, or change branch protection and rulesets.
No AI transmission
The hosted proof product does not send source contents to an LLM or AI provider. No AI model decides the verdict.
Retention is separate from access
Receipts retain normalized evidence, paths, identifiers, hashes, rules, checks, reviews and actors, not incidental API patches or decoded workflow text. Historical receipt and landing archives, retained mirror objects and refs, account records and operational backups are not automatically erased on uninstall. There is no customer-selectable deletion deadline or automatic uninstall purge.

Read the privacy and deletion-request details →

Full permissions and authorization boundaries

Don't trust Merge Proof more than necessary. See the exact authority before connecting.

Standard GitHub App repository access

  • Read: Actions, Administration, Commit statuses, Contents, Merge queues, Pull requests, and GitHub's mandatory Metadata permission. These reads collect workflow/check evidence, repository rules, Git identities, merge-queue state, PR state, and landed content identifiers.
  • Checks: read and write. Read check results and publish or update this App's Merge Proof Check output; it cannot change repository files.
  • Organization members: read. Verify that the signed-in billing user is an organization owner.

GitHub sign-in: the OAuth request adds no extra OAuth scopes. Its short-lived user token is kept in process memory while Merge Proof checks identity, App installations, authorized repositories, and organization-owner status.

Technical access and processing: Contents read is real source access. GitHub responses can include workflow text and diff patches, and reconstruction fetches exact Git objects into a private partial bare mirror. Merge Proof uses these inputs to bind identifiers, inspect workflow action references and deterministically reconstruct trees; it does not execute customer code.

Persistence and AI boundary: receipts retain normalized evidence, identifiers, paths, hashes, rules, checks, reviews, actors, workflow provenance and reconstructed Git facts. Exact Git objects and receipt references are retained for replay. Git may materialize reachable blobs. Active receipt eviction does not delete the historical archive. Incidental API patch text and decoded workflow text are not written into receipts. No source contents are sent to an LLM or AI provider; no AI model decides the verdict.

Write authority: the standard grant does not include Contents write, Secrets, Workflows write or organization administration. It cannot push commits, change branches or files, merge or close PRs, post PR comments, alter repository settings, edit branch protection/rulesets or modify Actions workflows. A separate optional Enhanced Policy Proof companion, if explicitly enabled later, has repository Administration write authority but is constrained by Merge Proof to policy reads; it is not part of this standard connection.

After uninstall or revocation: new collection stops and hosted access fails closed because current installation/repository access is rechecked. Historical receipts, evidence, retained Git objects, account records and operational backups are not automatically erased; current code has no customer-selectable deletion deadline or automatic uninstall purge. Private access follows current repository authority, not only billing ownership. Uninstall does not make retained evidence public.

Start the free GitHub trial

Review the App's permissions in GitHub before authorizing it.

PRICING

Start with a report-only trial.

No card upfront.
No automatic charge at trial expiry.

7-DAY HOSTED TRIAL

$0

No card required. Report-only during trial.

The clock starts with your first successful hosted proof, not when you connect GitHub or install the App. Automatic proofs and re-proofs are report-only during trial.

TRY MERGE PROOF FREE

PRO

$29/month

per observed active developer

Keep hosted proofs, automatic re-proofs, GitHub Checks and inspectable HTML/JSON receipts for $29/month per observed active developer.

No card for the trial. Choose paid Pro to continue; there’s no automatic charge when the trial ends.

Paid Pro supports optional administrator-configured enforcing gates. Technical capacity and evidence limits apply.

No automatic charge at trial expiry. Without a subscription, new hosted proofs, re-proofs and scans pause. Existing receipts remain accessible while you retain authorization, subject to retention and capacity limits.

What starts the seven-day trial?

The first CURRENT, collection-complete VERIFIED or NOT_PROVEN hosted receipt starts seven calendar days, exactly once. NOT_PROVEN means evidence is missing; it does not mean your code is broken. Failed, unavailable or stale collection does not start the clock. Connecting GitHub, installing the App, authorizing repositories and historical scans do not start it either.

One trial is shared across installations owned by the same GitHub account. Reinstalling or refreshing the same head does not restart it.

Does the trial block merges?

The trial does not enable new enforcing policies. New enforcement requires paid Pro and a repository administrator; GitHub must separately require the correct Merge Proof Check. Merge Proof never edits branch protection or rulesets.

Previously configured enforcing policies remain enforced. At hosted expiry they report failure; report-only notices are neutral. If GitHub requires the check, subscribe or remove that required check. Provider or permission failures can prevent delivery; automatic unblocking is not guaranteed. A passing policy Check is not necessarily a VERIFIED receipt.

Prefer local? Free forever. MIT CLI + GitHub Action for deterministic local Git analysis, not the hosted evidence collector. Use free local →

Who counts as an active developer?

Distinct human GitHub IDs observed opening covered PRs or pushing covered commits. Bots, configured service identities and inactive organization members are excluded. One human counts once across the paying account’s installations. Initial pricing uses the preceding 30 days of observed covered activity; subsequent counts use the subscription month. Review the count before checkout. Increases require confirmation; changes take effect at renewal without proration.

What's in the bounded historical scan?

Look back at what available evidence can establish about previous merges. The free scan covers up to 5 merged PRs among the 30 most recently updated closed PRs. Unsupported history stays unavailable. Current rules cannot establish historical approval validity. One bounded scan does not start the trial or count bugs prevented. Squash/rebase reconstruction and historical approval validity may be unsupported or unavailable. New scan collection pauses when hosted access expires.