Inspiration

A review can outlive the context behind it. A software release owner may return to a Jira issue whose status, priority or planned version has changed since the review. A value can even change and return to its starting point, leaving a current comparison unable to explain what was observed earlier.

I built ContextLatch to keep that personal review, its selected context and the observations behind the next decision together.

What it does

I select one to three accessible issues in the current Jira project, inspect status, priority and fix-version values, and record a personal review with a reason. ContextLatch saves those values with the review. An explicit recheck shows the exact recorded and current values and saves an observation.

A linked re-review preserves its predecessor. Saved observations retain a change that was actually observed after a later revert. Named runs keep separate sequences, and a receipt can recover an existing review after reload. Unknown context prevents recording; competing saves produce an explicit conflict instead of overwriting the accepted review.

This is personal review evidence, not organizational release authorization. ContextLatch reads Jira; it does not transition issues or deploy software.

How I built it

The app uses Atlassian Forge Custom UI, resolvers, KVS and Custom Entity transactions. Forge supplies the account, site and project context on the server. Jira REST reads run as the current user, and current issue access is checked before historical values are disclosed. Payload identity is not an authorization input.

I added a 90-day content-retention limit, a separate confirmed privacy-erasure path and an hourly worker for due personal-data reporting. Erasure leaves a barrier against late in-flight saves and does not change Jira issues.

How I used AI

I used Codex to assist with implementation, deterministic fixtures, adversarial tests, debugging, browser-assisted operator checks and documentation. Debugging native storage exposed scalar-type and optional-value constraints; a checked storage wrapper made those boundaries explicit.

ContextLatch itself calls no AI model. Field comparisons are deterministic, and the reviewer remains responsible for the decision. This candidate does not claim a Rovo, Teamwork Graph, Atlassian MCP or Marketplace bonus integration.

What I tested

The maintained r7 source passes 81 local regression tests and its build. A clean build from the private source archive reproduces all 33 maintained files. I exercised real Forge/Jira integration with synthetic issues on a separate Jira site/account: review capture, exact changed-field detection, linked re-review, source restoration, saved observations and receipt recovery. A two-tab check accepted one successor, rejected a competing save and recovered the accepted result.

A separate non-admin Jira User discovered the app and completed a review, recheck and reload recovery with Browse=true, Edit=false, Transition=false, project administration=false and global administration=false. Both tested users could open their own records and were denied the other user's run and receipt. The non-admin observed an exact status change and its later restoration while the earlier changed observation remained saved.

Access-revocation testing exposed a case where a service-unavailable response left cached evidence visible. I preserved that failure and corrected the frontend to hide cached private values when current access cannot be verified. Local unavailable/transport tests pass, including same-request recovery of uncertain saves without duplicates. On deployed r6, real source revocation caused history and receipt recovery to deny access and hide cached values; restored access returned the exact original receipt and observations. The native r6 response was denial, not an induced provider outage. The temporary project grants were removed and staging was disabled without its scheduled trigger.

Two existing sites were tested with the same account: each accepted its own records and denied the other site's receipt. Removing only a temporary installation caused its retained client to hide cached private evidence. A separate real 15-minute organization-session expiry hid cached evidence; after I reverified, the exact receipt and history recovered. This was policy-backed session expiry, not an induced internal Forge OAuth-token expiry.

Controlled staging tests caused real hosted 25-second termination around storage transactions. Original requests recovered their intended records without duplicates. Testing exposed a further frontend defect: the receipt recovered but run controls required a manual reopen. The preserved failure led to r7, which performs a fresh access-checked admission for the exact saved receipt before restoring controls. Real post-commit review and observation timeouts verified automatic recovery, keyboard focus, exact rows and unchanged history. Staging was then disabled with no schedule or fault hooks; normal r7 was promoted and the existing independent production receipt, two reviews and six observations were read back unchanged.

The local silent screen recording shows actual app run creation, preview and review capture, followed by an earlier real Jira change/revert/history example. These are edited examples from separate synthetic runs; the happy-path footage predates the latest error-handling and recovery-control corrections. These are Codex-assisted operator checks, not human usability research. I have not measured time savings, adoption or real release outcomes.

Testing instructions

A Jira Cloud administrator installs the app using the installation link supplied in the hackathon's installation field. Each reviewer signs in with their own Atlassian account and uses issues they can currently access. No app API key or shared creator credentials are needed.

Open a Jira project and select ContextLatch. If Jira hides the project tab, open this route after replacing the site and project placeholders:

https://YOUR-SITE.atlassian.net/jira/software/projects/PROJECT-KEY/apps/9bf84d4b-53a9-4c79-b83c-7674af9431a3/33443ead-a3d6-4be0-80b3-adb1e913e52f

Enter a run name and one to three numeric issue IDs from that project. For an issue key, open https://YOUR-SITE.atlassian.net/rest/api/3/issue/ISSUE-KEY?fields=project in the signed-in browser and copy its top-level id, not the project's ID.

Inspect context, enter a reason and record a personal review. Keep its receipt. Recheck, load history, reload and recover that receipt. For an authorized synthetic demonstration, change one selected issue's status in Jira, then recheck to see the exact difference. Restore the issue, explicitly reopen the original receipt and recheck again. The current comparison can be unchanged while history retains the earlier observed change.

Starting a new run preserves earlier evidence. Use the separate confirmed erasure control only when you intend to remove your app data in that project.

Limits and next steps

Checks are explicit, not continuous monitoring. A change that reverts between checks can be missed. Only the selected status, priority and fix-version values are compared. Discovery can lag, so keep a receipt for recovery. The bounded same-account Browse-only and revocation checks passed. The separate non-admin and mixed-user checks above are bounded synthetic tests, not proof of every tenant or permission configuration. Physical provider expiry/backups, internal Forge OAuth-token expiry, a global vendor outage and representative human comprehension remain unobserved. The session-expiry and controlled termination results above have their stated boundaries; local models are not relabeled as other native events. This is a controlled prototype, not a general beta.

Privacy and support: https://contextlatch-privacy-support.inwardlabel.chatgpt.site

Built With

Share this project:

Updates