RuleBridge

The problem

Every Confluence decision page speaks with two voices. The declaration — "DECIDED" in the title, a "Final" policy, an "Approved" label — is what everyone trusts and acts on. The body is what the team actually left behind. Over a page's life the two voices quietly drift apart:

• "Q3 pricing — DECIDED" — with an open question still sitting in the body, unanswered.
• "Vendor selection — APPROVED" — with action items still unchecked, including one naming an owner and no due date.
• "Refund policy — FINAL" — still containing TBD and a TODO.
• A page titled "FINAL" that still carries the draft label.
• Two linked decision pages that state opposite positions on the same subject — "Decision: use Postgres" on one, "Rejected: Postgres" on the other.

No tool warns about any of this, because every reader trusts the declaration. The result is not a crash — it is decisions being executed that were never really closed, policies being quoted that were never really finished, and follow-ups with an owner but no date that simply evaporate. It is the broken bridge between what a team recorded and what is actually true.

The solution

RuleBridge is a Forge app that checks the bridge between a page's declaration and its body:

1. Deterministic rules engine. A pure-function engine compares what a page declares (title + label signal, mapped by a small fixed table) against what its body contains. Six defensible rules: decided-but-open-questions, decided-but-open-actions, owner-without-due-date, final-with-placeholders, draft-labeled-final, and contradictory-linked-decisions. No LLM, no guessing: the same page always produces the same verdict, which is exactly what a trust tool needs. The cross-page rule is deliberately the most conservative: it fires only on explicit, opposite stance statements ("Decision: use X" vs "Rejected: X") about the exact same subject — free prose never becomes a "position", because a false accusation is the worst output this tool can produce.

2. A verdict where the work happens. A content byline item under every page title shows the verdict on the page itself, with every finding explained in one sentence — and the fix attached. The same check is one click away in the page's content action menu for a full modal view.

3. One-click fixes, human-confirmed — and additive only. A page body is prose a team owns; there is no safe silent rewrite. So every finding offers its honest repair, executed only on an explicit click:

   • Insert a decision-log table at the page top recording the open question/action, the named owner, and the missing due date — implicit loose ends become visible, tracked work;
   • Flag the page with a needs-review label — the page joins the review queue; the body is not touched at all;
   • Draft an unresolved-items summary at the page top, generated from the current findings, inside a labelled macro block. In every case the original body is preserved verbatim below the inserted block; nothing is ever silently rewritten.

4. A space-wide contradiction scan. A space page lists every self-contradicting page in the space in one table, plus a second table for linked decision pairs that contradict each other — the ten-second truth check a lead runs before a steering meeting.

5. The same brain, as a Rovo agent. RuleBridge ships a Rovo agent plus three reusable actions (check-page-contradictions, fix-page-contradiction, scan-space-contradictions). Ask in chat: "Scan the OPS space for contradicting decision records" or "Fix the contradiction on this page". Because the actions are standard Forge actions, any other agent — including customer-built ones — can invoke the same check as a tool. The fix action is safe by construction: it re-runs the check and only applies a fix the engine currently offers, so a stale or hallucinated request fails safely instead of writing.

How it is built (Forge modules used)

All product calls go through one client (src/lib/confluenceClient.js) using api.asUser().requestConfluence(...), so Confluence's own permission checks gate every read and write; the app never acts with broader rights than the person using it. Storage-format bodies are flattened to text deterministically in the client (task lists keep their checkbox state — that state is evidence the rules read). The engine (src/lib/decisionRules.js) is a pure module with a 44-case test suite (rules, REST client over a fake transport, fix executor) that runs with npm test — no site needed.

Why this matters

Decision records are the memory of a business team. When the memory declares "decided" over an unanswered question, or "final" over a TBD, the organisation acts on fiction — politely, confidently, and at scale. RuleBridge makes that gap visible at the moment and place it can be fixed — on the page, across the space, or in a chat with an agent — and removes the toil of repairing it. It is deliberately deterministic: teams will only trust an automated consistency checker if it never cries wolf, and every rule here can be explained in one sentence.

Built With

• atlassian-forge
• confluence-cloud-rest-api
• forge-api
• forge-bridge
• forge-react
• forge-resolver
• forge-ui-kit
• node-js-24
• rovo