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 (label uat-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 four action modules (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:mcp for 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)

  1. Install with the installation link (Jira is required; connect Confluence when prompted - the app needs both).
  2. Open any Jira software project and select the Trace-to-Handover tab (under "More" if it is not visible).
  3. Click Load demo data into this project (creates a TOR page in your first Confluence space and 12 work items). Wait for "Demo ready".
  4. Review the matrix, click Link on a suggested match, open Out of scope and Baseline tabs.
  5. Optional: edit the TOR page (add a row "REQ-10 ...") and click Re-import current page to see the change log.
  6. Click Generate acceptance report and open the Confluence page.
  7. 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

Share this project:

Updates

Submission history