Inspiration

When a Jira work item changes hands, the decisions that bind it (a deadline, a required review, a component nobody may touch) stay in someone's head, a page or a comment. The next person finds out late. I wanted the handoff itself to carry those decisions, and I wanted the safety call to come from rules a team can read, not from a model's guess.

What it does

  • Handoff check. A panel on the work item records a handoff to a named receiver and runs plain rules: the item needs a description and a due date, must not contradict any recorded decision, and the receiver must acknowledge every decision that binds it. The verdict is Clear, Needs info or Blocked.
  • Suggested fixes. The smallest edits that would stop the item contradicting its decisions (a due date, a label to add, a component to remove). Advice only; the app never edits the work item.
  • Rovo agent. Explains the verdict, quoting the rule check's sentence exactly. It finds decisions written in the description and comments and proposes them with a word-for-word quote as evidence. A proposal binds nothing until a person confirms it in the panel, and a repeat of a confirmed decision is rejected.
  • Handoff brief. Gathers what the receiver needs, including people connected to the item from Teamwork Graph (shared with, mentioned). It is advisory; no rule reads it.
  • Workflow validator. A transition guarded by the validator only goes through when the handoff is Clear.
  • MCP server. The same four Rovo actions are exposed through rovo:mcp for external agents.

How I built it

  • Forge UI Kit panel, resolvers and Forge storage. Only decisions and handoff records are stored; no chat is stored.
  • A pure TypeScript rule core with no Forge imports, no network and no clock, so every verdict is reproducible in tests.
  • rovo:agent with four actions, rovo:mcp, and jira:workflowValidator.
  • Two saved Teamwork Graph Cypher queries, called with asUser() so results respect the viewer's permissions.
  • 130+ unit tests, including a property test that applying the suggested fixes leaves no contradiction.

Measurement

I checked the rules against 48 synthetic handoffs whose labels were written by a model (Muse), not by people:

Check Agreement with Muse labels
Rules with recorded decisions 47 / 48
Rules alone, no decisions 34 / 48
No check 12 / 48

This is agreement with model-written labels, not accuracy. The one disagreement is a description of filler text ("tbd see above") that the rules accept as non-empty.

Challenges I ran into

  • Keeping the model out of the verdict. Rovo may only quote and explain, so the rule result is passed through untouched and the prompts forbid predicting it.
  • Evidence that cannot be invented. A proposed decision is kept only when its quote is found word for word in the work item, read again as the caller.
  • Silent empties. Teamwork Graph returns empty rows rather than errors when a scope or permission is missing, so the UI says the source "returned nothing" and never treats that as a fact.
  • Duplicates. Rovo kept re-proposing decisions that were already confirmed; the check now matches by scope and constraints and rejects the repeat.

Accomplishments that I'm proud of

  • A clear line between rules and model: the verdict is plain code, Rovo writes the words, and a person confirms every decision.
  • The same check runs in the panel, the Rovo agent, the MCP server and the workflow validator, so they cannot disagree.

What I learned

  • How Teamwork Graph saved queries work: they are registered once and run only as the user.
  • That a workflow validator turns advice into enforcement. That is where a handoff check earns its keep.
  • That measuring against model-written labels is useful for catching regressions, but must be named for what it is.

What's next

Read decisions from Confluence pages, and let a team mark a decision superseded from the panel.

Built With

Share this project:

Updates

Submission history