Judges: try it in 3 minutes
You need site-admin rights on a Jira + Confluence Cloud site (a free developer site works; Rovo is only needed for step 6).
- Install with the Jira link (Get app → your site → Install), then the Confluence link: choose the same site and tick the "Confluence" checkbox so both products share one installation.
- One-click sample data: Jira → Apps → Precedent — Decision Log → Setup & integrations → pick any Confluence space and Jira project → Create sample content. It creates an architecture review page with four
/decisionitems, a decision page, and seven work items, four of which quietly contradict those decisions. The PostgreSQL decision comes with a guard (governed paths, denied packages) and two assumptions. - Turn on enforcement: same tab, Enforce in Jira → Turn on for all projects (create-time warning) and Turn on for all workflows (Done gate).
- Get warned while creating: press Create, type "Move payout reconciliation to MongoDB", press Tab. The label turns into "Summary · ⚠Already decided in DEC-n"; the ⓘ explains who decided, when, and what to use instead.
- See the conflict, then the gate: open "Store payout ledger in MongoDB for flexible schemas". The Precedent panel shows the contradicted decision, the evidence, a one-click compliant alternative, and the 🧠Precedent brief kept at the end of the description. Now move it to Done: Jira refuses with "Blocked by Precedent: … contradicts DEC-n".
- Ask Rovo: click Ask Precedent in the panel (Rovo sites). The agent explains why the decision was made, who owns it, and the options.
- Hand it to a coding agent: Development → Open in coding tool → Claude Code / Cursor / VS Code. Jira passes the summary and description, and with it the Precedent brief, into the agent's first prompt.
Everything else (Decision Radar, JQL precedentConflicts > 0, the Decision Log, Inbox, tripwires, Teamwork Graph) is described in the full testing instructions below.
Inspiration
Every team has had this moment: "Wait — didn't we already decide not to do that?" Decisions live in architecture reviews, meeting notes and Jira comments. Months later someone files work that quietly contradicts one, or, more and more often, an AI coding agent implements it in minutes. Registers that only store decisions don't help, because nobody reads them at the moment it matters. We wanted a decision memory that acts: it speaks up while the work item is being written, holds the line in the workflow, and briefs the coding agent before it writes code.
What it does
In one line: decisions written where teams already work → a DEC-n register with guardrails and optional guards → every new or edited work item, every create dialog, every workflow transition and every agent plan is checked deterministically → conflicts surface with evidence, a compliant alternative, and the owner to ask.
- Capture without new process: Confluence
/decisionitems, decision pages and Jira comments starting withDecision:are harvested automatically. Decisions written in plain prose ("we agreed to…") land in a Decision Inbox when the page is published: accept, merge into an existing decision, or dismiss. - Warn while creating: a
jira:uiModificationsmodule flags the Summary in Jira's own Create dialog: "⚠Already decided in DEC-1", with who decided, when, and what to use instead. - Flag on the work item: the issue panel shows the contradicted decision, the exact sentence that tripped the guardrail, and a one-click compliant rewrite ("MongoDB" → "PostgreSQL"). Every result is indexed for JQL (
precedentConflicts > 0). - Enforce in the workflow: a
jira:workflowValidatorblocks Done while a conflict is open, unless the team reviewed it or logged an exception. One click adds it to every workflow. - Brief the coding agent: Precedent keeps a short 🧠Precedent brief on every governed work item. Jira's Open in coding tool hands it to Claude Code, Cursor, Copilot, Codex or VS Code. MCP agents call
precedent-preflightandguard-check. - Keep decisions alive: assumptions and revisit dates; tripwires (JQL count thresholds, dates, an epic being done) measured hourly. When one trips, the decision is flagged needs review, the Decision Radar turns red, and the owner is asked where the decision was made. A health score per decision, a lineage timeline, and supersede / exception history complete the picture.
- Findable everywhere: a Teamwork Graph connector puts every decision into Rovo Search; the Rovo agent explains and cites.
How Precedent compares
| Capability | Precedent | Decision-register apps | ADR files in the repo | Wiki pages & meeting notes |
|---|---|---|---|---|
Captures decisions where teams already write (/decision, meeting-note prose, Jira comments) |
✅ automatic + inbox | âš ï¸ manual entry in the app | ⌠separate files | ✅ but unstructured |
| Warns in Jira's Create dialog | ✅ | ⌠| ⌠| ⌠|
| Flags contradicting Jira work with evidence + one-click fix | ✅ | ⌠| ⌠| ⌠|
| Blocks the workflow (Done) on unresolved conflicts | ✅ | ⌠| ⌠| ⌠|
| Briefs AI coding agents (Open in coding tool, MCP preflight / guard-check) | ✅ | ⌠| âš ï¸ only if the agent reads them | ⌠|
| Deterministic guards (code paths, packages, JQL scope) | ✅ | ⌠| âš ï¸ conventions only | ⌠|
| Assumptions, revisit dates and automatic tripwires | ✅ | âš ï¸ review dates at best | ⌠| ⌠|
| Searchable in Rovo via Teamwork Graph, explained by a Rovo agent | ✅ | ⌠| ⌠| âš ï¸ page search only |
| JQL, Radar and health score for leads | ✅ | âš ï¸ register views | ⌠| ⌠|
| Runs entirely on Atlassian, no data egress | ✅ | varies | n/a | ✅ |
How we built it
- One Forge app across Jira and Confluence: a single installation with shared storage, on the
nodejs24.xruntime. Custom UI in React (hand-drawn SVG charts, no external assets) for the issue panel, Decision Radar, Decision Log and the page byline. UI Kit was not needed. - Deterministic core, no LLM bill:
- ADF parsing, guardrail extraction from decision sentences ("X instead of Y", "do not introduce…").
- Direction-aware matching ("remove MongoDB" is aligned; "move the ledger to MongoDB" is a conflict).
- BM25 relevance with generic-word suppression, guard evaluation (glob paths, package patterns, JQL scope), and fix generation.
- The Forge LLM API is billed to the developer, so reasoning lives in the Rovo agent instead.
- Jira-native enforcement:
jira:uiModifications: contexts registered per project withasApp.jira:workflowValidator: added to workflows via the workflows API.- Issue properties with
jira:entityPropertyfor JQL.
- Agents:
rovo:agent+ nineactionmodules +rovo:mcp. The Precedent brief is rendered from one model into markdown (for MCP) and ADF (description block or comment). - Background work: an async event queue re-checks work after every decision change. Scheduled triggers run a daily sweep and hourly tripwires. A Teamwork Graph sync job runs after every change.
- Quality: 68 unit tests (
node --test), ESLint, and an end-to-end script against a live site. Every feature was verified on a real Jira + Confluence + Rovo site before recording.
Challenges we ran into
- Getting a brief into a coding agent. We first planned to post the brief as a comment. We then captured the real
claude-cli://deeplink Jira builds for Open in coding tool and found it carries only the summary and the description. So the brief can now live in a marked block at the end of the description. Precedent never checks its own block, and the one-click fix never rewrites it. - Create-dialog warnings. UI modification contexts allow only one wildcard, so we register one context per project. The new Create dialog also tucks field descriptions behind an ⓘ, so the warning is mirrored into the Summary label.
- Timeouts. Resolvers must finish in 25 seconds, so the one-click Done gate processes projects in batches from the UI and shows progress.
- Telling "remove MongoDB" from "move to MongoDB" without an LLM. We used direction cues in a token window, with regression tests for every false positive we met on a real site.
- External MCP (Preview) authenticates but still refuses tool calls for third-party apps on our sites. We document it honestly and show the native Open in coding tool path and Rovo Studio instead.
Accomplishments that we're proud of
- A real Claude Code session, started from Jira with nothing but Jira's own prompt, stopped before writing code and proposed the compliant design, because of a decision written months earlier in Confluence.
- Enforcement at every step of the work item's life (create, edit, transition, implementation) from one register, fully deterministic and explainable.
- Decisions that notice when the world changes (tripwires), instead of silently going stale.
- Production version Runs on Atlassian eligible: no external calls, no external storage, no API keys.
What we learned
- The highest-leverage place for a decision is not a register but the moment someone is about to contradict it: the Create dialog, the transition, the agent's first prompt.
- Agents follow rules best when the rules are short, specific and machine-checkable (paths, packages), so guards beat prose.
- Atlassian's newest surfaces (Teamwork Graph connectors, Open in coding tool, workflow rules for Forge) fit together well with a single data model.
What's next
- Bitbucket merge check fed by a decisions-as-code export (
.precedent/guards.json), and anAGENTS.mdexport for repositories. - Exception requests with approval and expiry, feeding the Done gate.
- A time-travel view of the register ("what did we believe on launch day?") and a dashboard gadget for decision debt.
Trust & privacy
- Runs entirely on Atlassian: Forge functions, Forge storage, Forge queues. The production version makes no external network calls; the Forge CLI reports it as Runs on Atlassian eligible.
- No data leaves your site: Teamwork Graph and Rovo are Atlassian services. There are no API keys, no third-party AI, and the app does not use the Forge LLM API.
- Permission-filtered: user actions run with the user's own permissions (browse checks before showing a work item's check, edit checks before the one-click fix, the Done-gate setup runs as the admin who clicks). The register itself is site-wide, like the Decision Log it powers; its Teamwork Graph copy is workspace-visible.
- Tested: 68 unit tests plus a live end-to-end script.
- Open source: MIT, https://github.com/qybaihe/precedent.
How Precedent meets the technical requirements
- Built on Forge: a single Forge app (
manifest.ymlin the repo) onnodejs24.x, deployed to production and shared through installation links. - Integrates Atlassian products:
- Jira: issue panel, project page, global page, UI modifications, workflow validator, issue properties + JQL, triggers.
- Confluence: global page, page byline, page triggers, page comments.
- Rovo:
rovo:agentand nineactionmodules. - Atlassian MCP (
rovo:mcp) and Teamwork Graph (graph:connector).
- Non-trivial implementation: see How we built it; 68 unit tests.
- New work: created from scratch during the Codegeist 2026 submission period.
- Runs on Atlassian: yes (production version eligible).
Built With
- atlassian-document-format
- atlassian-forge
- bm25
- confluence
- forge-async-events
- forge-custom-ui
- forge-kvs
- javascript
- jira
- jira-ui-modifications
- jira-workflow-validator
- jql
- mcp
- node.js
- react
- rovo
- rovo-actions
- rovo-agents
- teamwork-graph
- vite