atlassian-mcp-server

Dependency map

Explain in the conversation, for a piece of work, what it’s waiting on, who’s waiting on it, which of those links are in trouble, and who to talk to about each. It’s written for the person who owns the work and has to chase other teams.

Dependencies live in Projects, Jira links, service catalogues, code and, often, only in a Slack thread. Teamwork Graph helps find them, but its edge names don’t all read the same way, it misses some project links, and it skips custom Jira link types. So this skill finds candidates in the graph, then takes direction and status from the product records. The map shows recorded and unrecorded dependencies side by side.

Load the teamwork-graph-context skill first and follow it for gathering context, labelling sources, keeping sensitive content out and optional publishing. Its section “What the graph doesn’t tell you” matters most here. This file adds what’s specific to dependencies.

This skill selects “Answer-first delivery” in teamwork-graph-context: gather and assess, answer in the conversation, then ask whether the user wants an HTML report. Do not write report data, run a renderer or create an artifact unless the user requests an export, HTML report or publication. Use the existing report layout only for that optional export. Offer Atlassian Artifacts publication only after confirming availability; exporting does not authorise publishing.

Connectors

Two things to record for every dependency

Keep these separate all the way through, from gathering to the diagram.

A Not recorded dependency can be Blocked. If chat says it’s blocking, it’s Blocked and goes in Needs attention, labelled with where it came from (“from Slack, not recorded”).

Step 1: Resolve the anchor

The user gives you Anchor Resolve with Scope of “our work”
An Atlassian project AtlassianProject getProject (use the returned URL or ARI for graph calls) The project and its tracked Jira work
A goal AtlassianGoal getGoal with limits: {projects: 20} Its linked projects, each treated as a project anchor (up to 5)
An epic or work item JiraWorkItem The key It and its children
A Jira space or board JiraSpace The key Open epics, plus work due in the next 6 weeks
A team AtlassianTeam searchTeams, then the team’s projects Its active projects (up to 5)
A service or component CompassComponent or ExternalService The URL or ARI The service itself

Capture the anchor’s owner, team (from the record’s teams field), short name (the words people use for it in chat), and need-by date: the target date, due date or sprint end the anchor is working towards.

Step 2: Find the edges

Collect edges from each source below. For each one, record which side waits, its source (Recorded, Related or Not recorded), and the record it came from.

Project to project (project anchors)

Services and code

Which edges to keep

Step 3: Go one hop further on the ones in trouble

For each upstream dependency that’s Blocked, At risk or Stale (see Step 5), check once what it’s waiting on, using the same sources as Step 2. This catches second-order blockers (“we’re waiting on Search, and Search is waiting on Platform”).

Stop at two hops from the anchor. Say so in the footer, and name any edges you didn’t follow.

Step 4: Find dependencies nobody recorded

Step 5: Assess each dependency

The getProject dependency results already include each linked project’s status, target date and owner. Hydrate further only where you need more: getProject (include: ["updates", "teams"]) for dependencies that aren’t Done or need delivery evidence, and getJiraIssue for Jira work (status, assignee, due date, sprint or fix version, resolution date).

Give each one a state. Use the rule for its side.

Upstream (the anchor waits on it):

Downstream (it waits on the anchor):

Both sides:

For each Blocked, At risk or Stale dependency, find:

Stop gathering when every shown dependency has a state, a source, an owner (or “no owner”) and a date (or “no date”).

Step 6: Prepare offers to record what’s missing

For each Not recorded dependency, and each Related one with a known direction, prepare the write that fits. Present these offers after the conversational answer, and do not make a write without a yes:

Show exactly which links you’ll create, in which direction, first.

Answer and offer an export

Ask whether the user wants this exported to an HTML report. If they have already explicitly requested an export, HTML report or publication, proceed with that requested build without asking again. Otherwise stop here until they answer; a normal invocation of this skill does not request a report. Follow the shared availability and confirmation checks before offering or performing publication.

Step 7: Build the map (only on request)

Only after the user requests the report, write its data as one JSON file and run the renderer in this folder:

python3 <this skill's folder>/render.py map.json dependency-map-<anchor>.html

The rules below say what the renderer builds, and what each part of the data must hold.

What the map holds

Each dependency is a link (title, url, icon, app) plus:

The diagram puts second-hop upstream, upstream, the anchor, downstream and second-hop downstream in columns, labelled “Second hop”, “Waiting on”, “This project” (or “This goal”, “This epic”) and “Waiting on us”. Arrows point the way work flows, from the dependency to the work waiting on it, with a second, dashed arrow back for a both-ways dependency. Each column shows at most 7 nodes, most severe first: Done dependencies collapse into one node (“5 done”), and any further ones into “+4 on track”, each linking to the list, which holds the full set. An empty first-hop column shows “Nothing recorded downstream” (or upstream). Every node names its state, and its source when it isn’t Recorded, so the diagram never relies on colour.

Sections, in this order

  1. Header (not a card): eyebrow “Dependency map”, the anchor’s name as the only h1, with the anchor’s status lozenge right of it, then a meta line with owner (person icon), team (people-group) and need-by date (calendar), adding “passed” if it has, and last the date history if the need-by has passed. At the right end of the meta line, count lozenges: “1 blocked” (danger), “2 at risk” (warning), each only if the count is above zero.
  2. Summary (icon tree): metric tiles for Waiting on, Waiting on us, Need attention and Not recorded. Waiting on and Waiting on us count every dependency on that side, including Not recorded and Done ones, with a sublabel such as “5 done, 2 open” or “1 both ways”. Then 2 or 3 plain sentences on the one or two dependencies that matter most and why, naming teams and people. In small subtlest text underneath, list the apps actually used: “Generated from Projects, Jira and Slack. Check it before sharing.”
  3. Map (icon link): the dependency diagram (see “What the map holds”), then a legend, then a collapsed “All dependencies as a list” (<details id="all-deps">) with one row per dependency: title smart link, side, state, source, team, date and where it came from.
  4. Needs attention (icon priority-blocker): one row per Blocked, At risk or Stale dependency, whatever its source, most severe first. Each row has a state lozenge, plus a source lozenge if it isn’t Recorded. Then one sentence on what’s blocked and why, then “Contact: [person], [role]” with their manager as “Escalate to”, where to reach them, and a source smart link.
  5. Not recorded (icon search): only if any were found. One row each, with its state, the evidence quoted briefly, the source chip, and the offer from Step 6 that fits (“Add as a Jira link?”, “Link this thread to the project?”).
  6. Next steps (icon arrow-right): 2 to 4 numbered actions, most urgent first, each with the person to talk to.
  7. Sources footer (not a card), as teamwork-graph-context describes. Include “Followed 2 hops from [anchor]. Did not follow: [edges].”, related links left off the map, sub-projects used for Jira work, unreadable keys, differences between the graph and the records, and checks that weren’t run.

Lozenges:

When live

Only after the user requests a report or live export, consider a live version if the actual host supports connector-enabled artifacts. Follow “Live artifact” and live-artifacts.md in teamwork-graph-context, loading only the matching host adapter. Do not assume that agent-side MCP access is available inside page code. With no confirmed runtime, keep the conversational answer or requested static HTML map.

Step 8: Deliver the requested report