ChangeProof blocks unready changes at Done, catches approvals that went stale after an edit, and proves months later that the evidence wasn't tampered with, from Jira, Confluence, Rovo and your coding agent.

Measured on 14 Nov 2026 on our test site's demo release (2026.12, 7 changes): ChangeProof found 4 of the 7 not audit-ready, each with its exact fix, and built the sampled, framework-mapped audit binder, with its offline verification bundle, in about 12 seconds. Assembling the same binder by hand typically takes hours per release (our estimate, not a measurement).

  • Detect: PAY-10 was approved, then its description changed. The badge reads Re-approval needed.
  • Enforce: The release gate blocks PAY-7 at Done and lists its 4 gaps. Emergencies pass as recorded exceptions.
  • Prove: Someone deleted an approval. Verify reads TAMPERED: "the approval comment from 13 Nov was deleted".

In your terminal (MCP + the open release-guard skill):

> is PAY-3 ready to merge?
Verdict: Not ready · 2 gaps · Risk: Medium
  ran npm test (42 passed) → record-test-evidence @8f2d60a (self-reported)
  drafted a rollback plan citing config/cards-gateway.yaml:3@8f2d60a → waits for the owner to confirm
Approval stays human: the agent can't approve.

Beyond the video: built for production

  • Change collisions: two risky open changes to the same component in the same release stay a gap until someone independent reviews the overlap (Rovo and MCP list them too).
  • Formal approvals only (a policy option): only the Approve button, bound to the exact content, and Jira Service Management approvals count.
  • Signed audit binders: each binder's verification bundle carries the site's Ed25519 signature; an auditor checks it offline with the open-source verifier and --key.
  • Per-project CI secrets: a project can accept CI-verified test results only from its own pipelines.
  • Safe for agents: all 16 MCP tools act as the signed-in person, so they can't see or change more than that person can in Jira and Confluence; admin functions aren't tools; MCP works without Rovo.
  • Tested like a product: 268 unit tests and 150 live checks against a real site, and a clean install on a brand-new site with a second user.

Watch it (no install needed)

  • Video (3:08): https://youtu.be/iVDbA4CVwsU
    • 0:00 the auditor's question, and the old way;
    • 0:34 Catch it early: gaps, self-approval, stale approval;
    • 0:59 Fix it, without faking it: Rovo, Claude Code over MCP, the agent refusing to fake an approval;
    • 1:39 Release day: the release gate, and an emergency exception;
    • 2:00 Audit day: evidence pack, tampering caught, release binder;
    • 2:34 the auditor's own check: VERIFIED, then NOT VERIFIED after one edit.
  • Install link (Jira + Confluence): https://loheshm.github.io/changeproof (redirects to the Atlassian installation page)

Inspiration

Regulated teams (banks, payment processors, hospitals) must prove that every production change was approved, tested, reversible and documented. The evidence usually exists, scattered across Jira comments, CI runs and Confluence runbooks, but on audit day someone spends hours rebuilding it by hand, and nobody can say whether an approval was given before or after the change was edited, or whether a record was quietly altered since. We wanted the proof to build itself, inside Atlassian, where the work already happens.

The problem

Every production change at a bank or a hospital has to be provably approved, tested, reversible and documented. Auditors find that hard to see:

  • 58% of companies reporting a material weakness in FY25 cited IT-related weaknesses (IT, software, security and access), up from 31% in 2021 (KPMG, 2025 material weakness study).
  • Change management is one of the IT general controls auditors sample.

Teams already have the evidence: approvals in Jira comments or Jira Service Management, tests in CI, rollback plans in Confluence runbooks. What they can't easily prove are three things auditors actually ask:

  1. Could an unready change ship anyway?
  2. Was it approved before, or after, it was edited or released?
  3. Can this evidence still be trusted months later?

ChangeProof answers all three for any Jira project: Detect → Enforce → Prove.

What it does

Detect. Every change is checked against your policy:

  • independent approval, from comments, the panel's Approve button, or a Jira Service Management CAB approval;
  • test evidence, rollback plan, documentation, owner and release, change-freeze windows;
  • optionally, security impact, released by someone other than the implementer, and change collisions: two open, risky changes to the same Jira component shipping in the same release or within a few days. A collision stays a gap until someone independent comments "collision reviewed" or one change moves, and Rovo or MCP can list every collision in a release (find-change-collisions).

The checks are strict in the ways that matter:

  • Approvals go stale if the change is edited after approval and before release, or if they come after release.
  • Release is when it shipped: the first move into a done status (a Resolved → Closed workflow releases at Resolved), judged against everyone who was ever assigned, and freeze windows are checked against the real release date (and today's date at the gate).
  • Emergency changes can be approved retrospectively within N days (DORA RTS Art. 17(1)(g)).
  • "Not approved yet", "Approved once tests pass", "Rollback plan: TBD" or an unfilled template never counts as evidence.
  • Approvals from apps, bots or service-desk customers never count, and nor does one from anyone who was ever the assignee.
  • Risk-based approval: low-risk changes can be approved by any independent person, medium-risk changes need the approvers group, and high-risk changes also need a CAB member.
  • Formal approvals only (an option): free-text "approved" comments stop counting; only the panel's Approve button, which binds the approval to the exact content, and Jira Service Management approvals do.
  • Approved before it reached customers: CI can report production deployments, and an approval after the first production deployment doesn't count, even before the Jira move to Done.
  • Evidence is judged as it stood at release. A "tested" label, comment or runbook added after Done doesn't count, and an emergency label added afterwards doesn't make a change an emergency. Emergencies may complete their evidence within the retrospective window.

Every surface uses the same five verdicts: Audit-ready, Not ready · N gaps, Re-approval needed, Emergency exception and Not monitored. Risk is shown separately. Verdicts appear:

  • on a badge on every issue;
  • in a checklist panel with the exact fix;
  • on a project dashboard;
  • in a Confluence macro;
  • in JQL (changeproofReady = "false"), so filters, dashboards and Jira Automation can use them. The JQL property is a convenience; the gate always re-checks live.

Enforce. A workflow validator blocks the move to Done until the change is audit-ready, in company-managed and team-managed projects. A second validator, ChangeProof independent release, stops the assignee (the implementer) from moving their own change to Done. Both are Forge workflow validators, a Preview module. The binder lists any change that reached Done without a gate run.

  • Emergencies pass the gate as recorded exceptions. If the implementer declared the emergency, that is flagged for the reviewer.
  • Each one gets a review deadline and closes once the evidence or a retrospective approval arrives.
  • Every gate run is logged (blocked, passed or emergency exception), so the binder can show the preventive control actually operating: "blocked 3×, 2 changes fixed and then passed".
  • Three days before a release date, ChangeProof updates a Release readiness page and nudges the owners.
  • Tests your CI signed. A pipeline posts its real counts to a signed Forge web trigger (HMAC-SHA256; a GitHub Actions step is included). Those records are labelled CI-verified, and the policy can require them, so nobody at a keyboard, human or agent, can type a test count that counts. A project can have its own CI secret, and then a pipeline holding the site secret, or another project's, can't post to it.
  • Standard changes. Pre-approved, low-risk change models (standard:<id>) satisfy approval by citing the model's own approval, until the model expires or the change is high risk.
  • Post-implementation review (optional): emergency, high-risk and failed changes need a "PIR:" within N days of release.

Prove.

  • Evidence packs are Confluence pages carrying a SHA-256 fingerprint and the fingerprint of the policy in force, chained into a ledger that users can't edit (a test-site erase leaves a logged tombstone).
  • Packs go only to the configured space or the space matching the project. Restricted comments, service-desk internal notes and issues with a security level are never copied.
  • Verify, from Jira, from the Confluence page itself, from Rovo or over MCP, gives one of three answers:
    • INTACT: nothing changed.
    • CHANGED: the change moved on (new comments, status, description edits), and the pack keeps the original.
    • TAMPERED: an approval or comment, a linked document, the pack page or the ledger was removed or altered. The exact reason is named, e.g. "the approval comment from 13 Nov was deleted".
  • Verify also reports whether the policy has changed since the pack, and who changed what.
  • A timeline per change (panel, pack page, and the change-timeline tool): created → approved → edited → re-approved → tests recorded → gate blocked or passed → released → pack.
  • Audit binders show:
    • the population, with "N of M" when it is larger than one binder assesses;
    • a reproducible seeded sample;
    • pass rates per control, mapped to PCI DSS v4.0.1, SOC 2, ISO 27001:2022, SOX ITGC or DORA;
    • the release gate's operation in the period;
    • control design changes: every policy change in the period, with who, when and what;
    • every exception;
    • a ledger check over the whole chain;
    • change failure rate: a change is failed when an incident or bug is linked to it after release, a DORA four-keys metric;
    • an offline verification bundle: node tools/verify-binder.mjs bundle.json (open source, in LoheshM/changeproof-skills) recomputes every ledger hash and link, the population fingerprint and the seeded sample with Node.js alone, so the auditor doesn't have to trust ChangeProof. The bundle is signed with the site's Ed25519 key; with --key (the public key from Jira) the verifier also proves it came from that site. Change one byte and it fails.
  • Binders build themselves: when a Jira version is released, its binder is written to Confluence automatically (an admin option).
  • A dashboard gadget puts the five verdicts on any Jira dashboard, and Jira Automation actions (check readiness, request fixes, generate a pack) let teams use ChangeProof in their own rules (a Jira admin clicks Connect once when first adding one).

Where developers work: MCP plus an open skill.

  • ChangeProof exposes 16 tools through rovo:mcp. Every assessment, verification, binder, timeline, collision and what-if answer starts with one Verdict: line. The Rovo agent gets the 14 that don't need a terminal.
  • Policy what-if: ask "what would DORA break?" and simulate-policy lists the open changes that would stop being audit-ready under that preset, with their new gaps. It is read-only: nothing changes until an admin applies the preset.
  • The open release-guard Agent Skill (one SKILL.md, for Claude Code, Cursor and others) turns "is this ready to merge?" into a loop:
    1. find the Jira key from the branch;
    2. explain-gaps;
    3. run the real test suite and record-test-evidence, with the SHA and command, labelled self-reported or peer-recorded (or push, and let CI post CI-verified results);
    4. draft a rollback plan grounded in the code, e.g. config/cards-gateway.yaml:3@8f2d60a, which only counts once the owner confirms it;
    5. re-assess.
  • The agent never approves. Approval stays human.

Rovo agent. Ask "Which changes in release 2026.12 are not ready?", "Does anything collide in this release?", "What would DORA break in this project?", "Build the DORA binder for this release", "Has the evidence for PAY-1 been tampered with?" or "Draft a rollback plan for PAY-3". Text from issues and pages reaches the agent fenced as data, never as instructions.

How we built it

  • One engine, many front doors. Pure modules (policy, fingerprint, timeline, binder, drafts, frameworks, collisions, demo, errors) are covered by 268 unit tests, including golden hashes (packs made by older versions keep verifying) and golden verdicts for every change shown in the video. 16 Forge module types; every UI, action, tool and trigger calls one service layer, so a verdict is the same in Jira, Confluence, Rovo and MCP. A live regression runs 150 checks: the engine against real Jira and Confluence data, the deployed app's UI in a browser, and the deployed web trigger; a second script drives the real Rovo chat.
  • The user's own permissions. Calls run as the user. Only the workflow validator, the release trigger and the daily job run as the app.
  • App-only shared state, bounded. The policy, ledger and logs live in Jira Forge app properties: both installations see them, and no user or admin can edit them through the API. Per-issue records live on the issue (and pack fingerprints on the pack page), each signed with an app-only key, so a test result edited or copied through the REST API is ignored and raised as an integrity alert, shown on the change itself. Signatures can't show that a record was deleted or an older copy put back, so ChangeProof also leaves a note on the change for every test run and production deployment it stores, and the app-only ledger remembers every pack: a deleted or rolled-back record is flagged on the change and fails its check, and a pack whose page is gone reads TAMPERED. Ledger records are folded 32 to a property, so storage no longer grows with the number of issues: about 20 properties, plus one per 32 evidence packs.
  • Agent-safe. Writes are CREATE, so Rovo asks the user to confirm. Fix requests, test records and code links are idempotent. Inputs are validated and JQL values are quoted.

Challenges we ran into (all solved)

Each of these came up while building and is fixed in the version you can install today.

  • One app, two installations. Forge storage is scoped to each installation, so at first the Confluence side and the MCP tools saw an empty evidence ledger. Fix: shared state (policy, ledger, logs) lives in Jira app properties, which both installations read and no user can edit. Jira, Confluence, Rovo and MCP now return the same verdict.
  • Designing for Jira's 100-property limit. Jira gives each app at most 100 app properties per site, a sensible guardrail. Our first design kept one property per record, which a real site would outgrow. Fix, by design rather than workaround: each record now lives on the thing it describes. Test runs, gate results and deployments sit on the Jira issue; pack fingerprints sit on the Confluence pack page. Each record is signed with an app-only key, so an edit made through the REST API is detected and raised as an integrity alert. The ledger is packed 32 records to a property. Storage no longer grows with the number of issues: production went from 100 properties to about 20. A resumable migration moved the existing data with nothing lost.
  • A gate that deadlocked. A workflow validator that posts a comment on the issue it is checking hangs until Jira's 25-second timeout. Fix: comments and exception notices moved to the issue-updated trigger. The one write left in the transition is the gate's own small log record (so the binder can prove the gate ran): a median of 550 ms over 20 measured releases (the whole check: median 1.3 s, 95th percentile 2.6 s), far inside the limit.
  • Evidence that only looked like evidence. "not approved yet" and ChangeProof's own fix-request comments were first read as approvals. Fix: matching is negation-aware ("not approved", "awaiting approval", "Rollback: none" never count) and source-aware (the app's own comments, bots and the assignee never count), with a regression test for each case.
  • Attacking our own app. Before submitting, four independent reviews (engine edge cases, platform and scale, a judge's fresh install, and a security review that tried to fake or hide evidence) found 87 issues, and a critic checked every one against the code. We fixed what mattered: unfilled templates ("Rollback plan: TBD") no longer count, a reassignment before release can't launder self-release, label spam can't push history out of view, deleted or rolled-back records are caught, and the demo works on a non-English site with no Confluence space yet. Each fix has a test, and golden tests prove no verdict in the video changed.
  • Our own agent caught us out. Running the release-guard skill on our demo repository, Claude spotted a test that could never fail: it compared the timeout result with the same condition. Fix: we replaced it with a real assertion (a 4.5-second APAC authorization must not time out). This is the review we built ChangeProof to encourage.

How it compares

Jira Service Management Premium already offers change calendars, risk and deployment gating, and ChangeProof reads its CAB approvals. ChangeProof adds the proof layer on any Jira project:

  • stale-approval detection;
  • tamper-evident packs and a verifiable ledger;
  • sampled, framework-mapped binders;
  • AI drafts that can never count as evidence;
  • the MCP developer loop.

Accomplishments we're proud of

  • An auditor can verify a binder without trusting ChangeProof: the open-source verifier recomputes every hash offline and checks the chain ends at the head shown in Jira; changing one byte makes it fail.
  • One verdict engine behind 16 Forge module types, so Jira, Confluence, Rovo and MCP never disagree.
  • Agents can do the busywork (record real test runs, draft rollback plans) but structurally cannot approve, and their drafts never count until a person confirms them.
  • We attacked our own app before submitting: four independent reviews and a critic, 87 findings checked against the code, the important ones fixed with a test each.
  • 268 unit tests and 150 live checks against a real Atlassian site, rerun after every change.

What we learned

  • Forge storage is per installation; shared state for a Jira + Confluence app belongs in app properties, and Jira caps those at 100 per site, so records must live on the issue or page they describe.
  • A signature proves who wrote a record, not that it is the newest or still there: deletion needs its own anchor.
  • "Evidence" has to be judged as it stood at release time; otherwise anything added later can launder a bad change.

What's next

  • Marketplace listing, after Atlassian's security review and with a support process behind it.
  • PR reviewer independence via the Teamwork Graph: treat a code reviewer who also implemented the change as not independent. It needs the site's source control connected to the graph, so it comes with the first customer pilots.
  • Collisions across projects and by service label, not just Jira components within one project.
  • Pilots with regulated teams, to tune the framework presets with real auditors.

Design boundaries

Deliberate limits, and why:

  • "CI-verified" proves which pipeline posted, not what it ran. Results are signed with a per-project (or site) secret held by the pipeline. Short-lived GitHub OIDC tokens would bind them to a workflow run, but checking those means fetching GitHub's keys over the network, and ChangeProof makes no outbound calls (Runs on Atlassian). Per-project secrets keep that boundary.
  • One binder covers up to 1,000 changes. A larger population is split by release or date range; a binder that couldn't list everything says PARTIAL instead of over-claiming.
  • Reinstalling gives the CI web trigger a new URL (Forge behaviour). The admin page says when the URL has changed since the CI secret was made.

Try it yourself (install path)

Before you start: two people on the site (approvals must come from someone other than the implementer); one Confluence space (Spaces → Create space); Rovo active on the site for the Rovo steps (a brand-new trial site may not have Rovo yet; check for Ask Rovo in the top bar) (without Rovo, every step has another route, and MCP works without Rovo); a version in your project (Releases → Create version) before creating the demo. Add the release gate before moving anything to Done.

  1. Install with the installation link, into Jira and Confluence. Open Jira settings → Apps → ChangeProof policy → Getting started.
    • Fastest path: under Try it now, choose a project and a space and click Create demo changes. ChangeProof creates six scenarios covering four of the five verdicts (Audit-ready, self-approval, three gaps, Re-approval needed, Emergency exception, high-risk with four gaps), with runbook pages, and lists them with links and the verdict to expect. The runbook space also becomes your evidence space (change it in Getting started, step 2). Remove demo changes deletes them afterwards.
    • Note: separation of duties needs a second user. The assignee can never approve their own change, so on a one-person site every approval is a self-approval; the demo says so and adjusts its expected verdicts. Invite one teammate (Jira Free allows 10) to see Audit-ready.
  2. Open an issue. The Audit readiness badge sits in the sidebar; expand it for the checklist. On the Audit-ready demo change, edit the description and click Re-check: Re-approval needed. On the three-gaps change, click Approve this change (you're not its assignee): the approval gap closes.
  3. Release gate. Add ChangeProof release gate to the transition into Done (team-managed project: Space settings → Work types → Task → Edit workflow → the arrow into Done → Rules → Validate details; company-managed: Project settings → Workflows; Getting started has both) and move an unready issue to Done: it's blocked, with the gaps. Add the label emergency-change: it passes as an exception. Then open History in the panel: the blocked and passed gate runs are there.
  4. Evidence pack. Generate evidence pack, then Verify evidence: INTACT. Edit the description: CHANGED. Delete the approval comment and verify again: TAMPERED. On the Confluence page, use ••• → Apps → Verify with ChangeProof.
  5. Rovo. Open the agent: Ask Rovo in the top bar → the Rovo ▾ agent switcher at the top of the chat → search "ChangeProof" → ChangeProof Auditor (Jira and Confluence both list it; it's the same agent). Ask "Build the PCI binder for release " (or use the project's ChangeProof page → Audit binder tab), "Does anything collide in this release?", or "Draft a rollback plan for from its runbooks" on the three-gaps change; only its assignee can click Confirm draft, so log in as the teammate or reassign the change to yourself first. No Rovo on your site? The same answers without it: the project's ChangeProof tab (what isn't ready), step 7 (collisions), Policy tab → pick a preset → Preview impact (what DORA would break), the Audit binder tab, and MCP (step 8) for the rollback draft.
  6. JQL. Search changeproofReady = "false" ORDER BY changeproofGaps DESC. Click Index existing changes in Getting started first.
  7. Change collisions. Policy tab → tick Change collision reviewed → Save. Create a component (Project settings → Components; team-managed projects: turn Components on first) and set it on the PCI key rotation and PostgreSQL demo changes (if the project already had a component, the demo did this for you). Re-check either one: a Change collision banner and a gap. A comment "collision reviewed" from someone other than the assignee clears it.
  8. MCP. admin.atlassian.com → Apps → Sites → your site → Connected apps → search ChangeProof. It is listed twice (Jira and Confluence): on each, View app details → Tools → Enable tools. Rovo is not needed for MCP. Then run claude mcp add --transport http changeproof https://mcp.atlassian.com/forge/872ce7fc-ddc9-4dcf-b58a-19fca5a48a6e and /mcp to sign in, picking this site on the consent screen. Copy release-guard/ from the open-source skill repo, github.com/LoheshM/changeproof-skills (Apache-2.0), into .claude/skills/. No repository handy? Use its examples/cards-gateway sample (the one in the video): its README makes the change on a branch named after the card-timeout demo key, pushes it, and you ask "Is this branch ready to merge?". The agent records the real test run and drafts a rollback plan after you agree, and never approves.
  9. Dashboard and macro. Open the project, then the project's ChangeProof tab (or More → ChangeProof). On a Confluence page, insert /ChangeProof release readiness.

ChangeProof stores its policy and policy change log, evidence fingerprints (hashes only), the release-gate log, test records, exceptions and daily counts inside your Atlassian site: app-only Forge app properties, plus signed issue and page properties for per-issue records. It makes no outbound calls; the only way in is one signed inbound web trigger for CI.


Category: Apps for Specialized Industries (finance, payments, insurance, healthcare) · Bonus prize: Best app with Atlassian MCP (16 MCP tools, plus a Rovo agent with 14 actions) · Built with: Forge, UI Kit, Jira, Jira Service Management, Confluence, Rovo, rovo:mcp, an open-source Agent Skill and CLI tools (LoheshM/changeproof-skills). Runs on Atlassian: no outbound calls, one signed inbound web trigger.

Built With

Share this project:

Updates

Submission history