Inspiration

Vendors of self-managed software keep several release lines alive: long-term support (LTS) lines for cautious customers and recent feature lines. When a vulnerability is fixed, someone has to work out, from Jira fix versions and memory, which lines the policy says must get the fix, which exact shipped versions are affected, and what to tell a customer on version X. Atlassian's own Security Bug Fix Policy requires a bug-fix release "for all supported LTS releases of the affected product" for critical vulnerabilities. Apache's affected range for Log4Shell is a union of three intervals. The US Cyber Safety Review Board reported that one federal cabinet department spent 33,000 hours on its Log4j response, and that organizations struggled to understand "to which version they should upgrade". A USENIX Security study found that only 59.82% of vulnerability reports strictly match the standardized NVD entries, and that inconsistent vulnerable versions are highly prevalent. And now support agents and AI agents answer "are we affected?" for customers, where a model that compares "9.10.0" with "9.9.0" as text gives a confident wrong answer. We wanted that answer computed, once, for people and agents alike.

What it does

  • Reads your releases from Jira. Patchline groups a project's versions into release lines (MAJOR.MINOR), reads which are released and when, and lets you mark LTS lines and their end of support. One Jira project is one product.
  • Coverage per line, under your policy. For a vulnerability (severity and the version where the vulnerable code first shipped), code computes which lines must get the fix and each line's status: fixed, scheduled, missing, recommended, exempt, not affected or not released, with the policy reason. The default template is Atlassian's published Security Bug Fix Policy as parameters; there is also a Kubernetes-style "last 3 minor lines" template and a "latest line only" template that requires the CRA Article 13(10) confirmation.
  • Exact affected ranges. Patchline computes the affected shipped versions and the minimal ranges, for example [9.2.0, 9.7.3) ∪ [10.0.0, 10.0.2), and the CVE JSON 5 versions block. It self-checks every block with the CVE schema's own algorithm against every shipped version.
  • Checks the draft advisory. Enter what the draft says (10.0.0 - 10.0.1, fixed 10.0.2): Patchline lists the affected versions it misses first (in the demo, 29 shipped versions on four lines), then false alarms and fixed versions not listed. It never edits the draft.
  • Answers "is version X affected?" with one deterministic answer and upgrade advice: "upgrade to 9.7.3", "no fixed version on 9.2 yet; fix planned in 9.2.15", or "no fix on 9.5; nearest fixed version on a newer line: 9.6.4". It never advises a downgrade and never guesses an unknown version.
  • Creates the backports. One click creates a linked work item for each missing line, with the next planned version on that line as its fix version.
  • Notices when a published record goes stale. Mark the computed block as published. When a later release changes the truth, for example a backport ships, Patchline flags the published record, shows the corrected block and comments once on the work item.
  • For agents too. Patchline's Rovo agent explains coverage and drafts, and creates backports behind Rovo's review card. Its five read actions are listed in rovo:mcp, so a support team can build its own Rovo Studio agent, add Patchline's "Check a version" tool without code, and answer customers from the same code.

How we built it

  • Forge for Jira, Confluence optional: a global page (vulnerabilities with a full-width record view, release lines, settings and sample data), an issue panel with the coverage table, ranges, version check and draft check, an issue glance, an indexed jira:entityProperty (patchlineCoverage, patchlineGaps, patchlineSeverity, patchlineAffected, patchlineStale), triggers on version events and work item updates, a rovo:agent with eleven actions, a rovo:skill, and a rovo:mcp module exposing the five read actions as tools.
  • A pure engine (no Forge imports): a strict MAJOR.MINOR.PATCH grammar with numeric ordering, release lines and first-release dates, calendar-month policy windows with month-end clamping, coverage statuses, the affected predicate, minimal ranges, the CVE JSON 5 evaluator (including lessThanOrEqual, changes and *), the claim grammar, and per-version answers.
  • Two independent implementations. Before writing any app code, we wrote a Python standard-library oracle and its expected output. The Node engine's golden tests reproduce every oracle number exactly (coverage rows and their reasons, affected versions, ranges, CVE blocks, answers, stale records, draft checks and policy templates), plus edge cases and a 400-case property test that the CVE evaluator agrees with the affected predicate and that the ranges are minimal. 20 test groups, all passing.
  • No external calls. The Forge CLI reports the production version as eligible for Runs on Atlassian. Patchline stores no account IDs, names or email addresses.

Challenges we ran into

  • A release can arrive early. Jira lets you release a version that still has a later planned date, so Patchline counts any version Jira marks as released as shipped.
  • One release, several events. Releasing two versions fires several version events at once, and our first stale-record comment was posted four times. A short storage lock now lets exactly one invocation comment, and a failed comment can no longer stop the other records from being recomputed.
  • Time limits. Loading 49 sample versions and five work items, and removing them, exceeds one function call's time limit, so both run in short passes that the page repeats until done.
  • Proving the agent story. We built a Studio agent with no code, added Patchline's "Check a version" tool, and confirmed in Patchline's logs that the agent's answer came from our action (tool=check-version ok=true).
  • An agent can describe a result it never received. In testing we cancelled Rovo's review card for "create backports", and the agent still replied that the backports were created. Jira and our logs showed that nothing had run. The agent's instructions now say to report a change only when the action's result says it succeeded; after the fix, the same test answers "I have not created any backports".

Accomplishments that we're proud of

  • The draft advisory in the demo says "10.0.0 to 10.0.1". Patchline shows it misses 29 shipped versions on four release lines, and after the backports ship, that even the record Patchline helped publish is now out of date.
  • Every number in the app, the testing guide and the video comes from the engine, and the engine agrees with a second implementation.

What we learned

  • "Is version X affected?" is a computation, not a judgment. Once it is a tool, any agent can answer it correctly.
  • Most of the work is in the edges: month-end windows, lines that ship after the fix, releases with planned dates, and records that go stale after a release.

What's next

  • More version schemes (calendar versions, Maven qualifiers).
  • Teamwork Graph pull-request status on backport work items, so a line can show "merged, not released".
  • Writing the computed versions into Jira's Affects versions field on request.

How it meets the technology requirement

Patchline is built entirely on Atlassian Forge. It integrates:

  • Jira: a global page, an issue panel, an issue glance, an indexed entity property for JQL, version and work item triggers, backport work items, links and comments;
  • Confluence: reading a draft advisory and writing a version table page, as the user;
  • Rovo: an agent with eleven actions (the CREATE and UPDATE ones go through Rovo's review card) and a skill;
  • Atlassian MCP: a rovo:mcp module with five read tools that customer-built agents can use.

It makes no external calls.

Bonus prize: Best Agents - Rovo/Assignable agents

Patchline uses all three parts of the rule: a rovo:agent, a reusable rovo:skill, and rovo:action modules that other agents invoke as tools.

  • Its own agent does real work: it explains coverage gaps with the policy reasons, turns a draft advisory's prose into checkable claims and shows how it read them, and creates backports, exemptions and published records only after the person confirms Rovo's review card. Given "Larkspur Server 10.0.0 and 10.0.1 are affected. Upgrade to 10.0.2.", it answered "I read your claim as affected versions 10.0.0 - 10.0.1 and fixed version 10.0.2" and listed the 29 missed versions per line; the log shows tool=check-advisory ok=true.
  • Other agents reuse its tools: on our demo site we built a Rovo Studio agent "Support Assistant" with no code, added Patchline's "Check a version" and "Get affected ranges" tools, and asked "A customer on Larkspur Server 9.7.1 asks: are we affected by LSA-2026-07, and what should we upgrade to?". It answered "affected … upgrade to 9.7.3", and Patchline's production log shows the call: tool=check-version ref=LRK-1 ok=true. Patchline did not ship that agent.
  • External clients: the same five read tools are available through the Atlassian MCP server at https://mcp.atlassian.com/forge/92286d09-6a6c-49e6-b715-4f59759d3fec after a site admin enables them; every call runs with the caller's own Jira permissions. Writes are deliberately not tools.

Open-source skill.md (Apache-2.0) for third-party agents:

---
name: patchline-affected
description: Answer whether a specific version of the product is affected by a vulnerability, and what the customer should upgrade to, using Patchline's computed answer. Use it when a person asks "are we affected", "is version X vulnerable" or "what should we upgrade to" for an advisory, a CVE or a vulnerability work item.
license: Apache-2.0
---
# Answer "is version X affected?"

1. Find the vulnerability: a work-item key (LRK-1), an advisory ID (LSA-2026-07) or a CVE ID.
2. Call `check-version` with that reference and the exact version (MAJOR.MINOR.PATCH, for example 9.7.1).
   Never compare version strings yourself: 9.10.0 is newer than 9.9.0.
3. Quote the returned `status` and `reason` verbatim:
   - affected with "upgrade to X": tell the customer to upgrade to X;
   - affected with "fix planned in X": say no fixed version exists on that line yet and when X is planned;
   - affected with "nearest fixed version on a newer line": say there is no fix on their line and name that version;
   - not affected: give the reason (fixed in X, or the vulnerable code first shipped later);
   - unknown version: ask for the exact version; do not guess.
4. If the person asks for every affected version, call `get-affected-ranges` and quote `interval`.
5. Do not change records. Backports, exemptions and published records need a person in Jira.

Privacy and support

  • Patchline runs entirely on Atlassian Forge and makes no external calls.
  • It stores release-line settings and vulnerability records (severity, introduced-in version, exemptions with reasons, the published block) in Forge storage on the customer's site, and one issue property per vulnerability work item.
  • It does not store account IDs, names or email addresses.
  • Questions or problems: leave a comment on this Devpost page.

Built With

Share this project:

Updates

Submission history