Inspiration
I have delivered more than 50 web systems for local governments and clients in Indonesia, almost always as fixed-scope, fixed-price contracts. The contract is a Terms of Reference (TOR): a numbered list of requirements. The project ends with a handover document (in Indonesia, a Berita Acara Serah Terima) that the client signs only when every requirement is shown to be built and accepted.
Two weeks before every handover, the same thing happened: someone exported Jira to a spreadsheet and rebuilt the requirements traceability matrix by hand. We discovered requirements nobody had built, features nobody had asked for, and TOR changes agreed in a meeting but never written down. The information was all there - the TOR in Confluence, the work in Jira - it just was not connected. That is exactly the "context" problem Codegeist asks about.
What it does
Trace-to-Handover is a Forge app for Jira and Confluence with a Rovo agent.
- Requirement baseline from Confluence. Pick the TOR/SRS page. Requirements are extracted deterministically from numbered IDs (REQ-01, FR-2, NFR-01) in tables or lists, or from normative sentences ("The system shall...", also Indonesian "Sistem harus..."). The same page always yields the same IDs, which matters for an audit trail.
- Traceability matrix in Jira. A project tab traces each requirement to work items (label
trace-REQ-01) and to UAT evidence (labeluat-passed). Each requirement is Not traced, In progress, Awaiting UAT or Verified. Coverage and handover readiness are shown at the top. - Suggested links. For untraced requirements a TF-IDF matcher proposes candidate work items; one click creates the trace.
- Scope creep. Work items that trace to no requirement are listed as out-of-scope: trace them, raise a change request, or exclude them from billing.
- Baseline change log. Re-import the TOR after the client changes it; the app records which IDs were added, changed or removed, with the page version.
- Acceptance report. One click generates a Confluence page under the TOR: verdict, summary, full matrix with evidence links, out-of-scope work, change log and a sign-off block for vendor and client.
- Handover Auditor (Rovo agent). Ask "Are we ready for handover?" The agent calls the same readiness action as the UI, lists blockers with evidence, proposes links, and - only after confirmation - links issues and creates the acceptance report.
- Demo data. One button creates a sample TOR and 12 work items in the current project, so anyone can see the whole flow in a minute.
How we built it
- Forge app, UI Kit (
jira:projectPage), Node.js 24 runtime, required in Jira and connected to Confluence (multi-app compatibility). - Jira REST (search/jql, labels, transitions) and Confluence REST v2 (pages, spaces) plus CQL search - all calls
asUser(), so the app never shows or changes anything the user could not. - Forge Key-Value Storage for the baseline and change log per project (no personal data stored).
- Rovo:
rovo:agent"Handover Auditor" with fouractionmodules (get readiness, import baseline, link issue, create report). The UI and the agent share one service layer, so they always report the same numbers. - No LLM calls of our own and no external servers: extraction and matching are deterministic code; the natural-language layer is Rovo. The app is eligible for "Runs on Atlassian".
Challenges we ran into
- Function time limits. Seeding demo data needs ~35 REST calls; UI resolvers cannot use custom timeouts, so seeding runs in phases (page, issue batches, import) driven by the UI.
- Deterministic extraction. TOR documents mix tables, bullets, info panels and prose. We reserve explicit IDs first, ignore info/note panels, and generate stable IDs only for normative sentences.
- Agent safety. The agent must never link or create things on a guess. Write actions are separate, described as "only after the user confirmed", and Rovo shows a review step before running them.
- Weak hardware. Developed on a 2-core laptop; builds and deploys ran on a small VPS with the Forge CLI.
Accomplishments that we're proud of
- An end-to-end flow a delivery team can actually use at handover: contract -> backlog -> evidence -> signed document.
- The agent and the UI agree to the number, because they call the same code.
- Scope changes become visible and dated instead of being lost in email.
What we learned
- Forge multi-app compatibility (Jira required, Confluence optional) and how Rovo actions receive context.
- Keeping AI as the conversational layer on top of deterministic, auditable logic works well for contractual use cases.
What's next
- Teamwork Graph: pull pull-requests, deployments and test results as additional evidence per requirement.
- Expose the actions through
rovo:mcpfor third-party agents. - Requirement-level comments from the client during UAT and a PDF export of the signed report.
- Templates for regulated domains (healthcare, public sector) where traceability is mandatory.
Testing instructions (for judges)
- Install with the installation link (Jira is required; connect Confluence when prompted - the app needs both).
- Open any Jira software project and select the Trace-to-Handover tab (under "More" if it is not visible).
- Click Load demo data into this project (creates a TOR page in your first Confluence space and 12 work items). Wait for "Demo ready".
- Review the matrix, click Link on a suggested match, open Out of scope and Baseline tabs.
- Optional: edit the TOR page (add a row "REQ-10 ...") and click Re-import current page to see the change log.
- Click Generate acceptance report and open the Confluence page.
- Open Ask Rovo, choose the agent Handover Auditor, ask "Are we ready for handover?", then "link the suggested issue and generate the acceptance report" and confirm.
Support / privacy / terms: https://mazharrasyad.tech/trace-to-handover/index