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.
teamwork-graph-context), map from it and say in the footer which kind of dependency wasn’t checked. With neither, say so before building: the map can show only dependencies found by search, all of them Not recorded.teamwork-graph-context describes: Slack or Teams, to read a handoff thread in full and check whether its last question was answered (the chat check for stale handoffs). GitHub or GitLab, to read pull request bodies and reviews that the graph returns empty.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”).
| 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.
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.
getProject with include: ["dependencies", "links", "teams", "updates", "highlights"] and limits: {dependencies: 20, links: 20, updates: 5, highlights: 20}. Don’t filter by linkType. Split the links into work tracking and related yourself, because related links often hold the plan and other docs. This is the source of truth.
DEPENDS_ON: the anchor waits on the other project (upstream).DEPENDED_BY: the other project waits on the anchor (downstream).RELATED: no direction. Read the other project’s updates and decision highlights too (getProject with include: ["updates", "highlights"], highlightType: DECISION). Place it only when a record says which side waits, such as an update (“ship once upload is live”) or a decision. Label it Related, and cite the record that gave the direction. Otherwise list it in the footer as related, and leave it off the map.getGraphContext on the project URL (atlassian_project_depends_on_atlassian_project, atlassian_project_links_atlassian_project). The graph shows depends-on only from the depending side and can miss links. If the counts differ, use getProject and say so in the footer.getProject, jira_work_item_tracks_atlassian_project edges in the graph, and their children (up to 50, with JQL parent in (...)). A project’s tracked epics are part of the project, not an extra hop.searchJiraIssuesUsingJql, key in (...), fields: ["summary", "status", "assignee", "project", "issuelinks"] and maxResults: 50, paging with nextPageToken until the known scoped work has been read. Keep the scope limits above. Inspect all issuelinks entries, including custom types; queries limited to the names “blocks” and “is blocked by” miss them. Use getJiraIssue with view: evidence when the batch doesn’t provide the link details needed to confirm an edge.outwardIssue, read “[this item] [type.outward] [other item]”; with inwardIssue, read “[this item] [type.inward] [other item]”. The other item is upstream when the phrase says “is blocked by”, “depends on”, “requires” or “is caused by”, and downstream for “blocks”, “is depended on by”, “is required by” or “causes”. Generic relates, clones, duplicates and follows links do not establish a dependency. For unfamiliar custom wording, confirm which side waits from the records or ask the user; until confirmed, leave the edge off the map and name the unresolved link type in the footer. An inward or outward field alone does not establish which side waits.teamwork-graph-context. If one can’t be read, list it as unreadable and don’t count that work as checked.getGraphContext on the component or service for its dependencies and consumers.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.
search (STANDARD, targetApp: THIRD_PARTY, then ALL) with the anchor’s short name. Lead with “blocking [short name]”, “[short name] blocker” and “[short name] blocked”, then try “waiting on” and “depends on”, which return more noise. Keep results from the last 30 days, by lastModified, and mention any strong older hit in the footer.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:
listJiraIssueChangelogs.For each Blocked, At risk or Stale dependency, find:
getPeopleInfo with manager: true for their role and their manager, so the user knows where to escalate.Stop gathering when every shown dependency has a state, a source, an owner (or “no owner”) and a date (or “no date”).
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:
createJiraIssueLink with type Blocks.createJiraIssueRemoteIssueLink.addConnectionsToProjects with type EXTERNAL_LINK.Show exactly which links you’ll create, in which direction, first.
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.
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
example.json in this folder (made-up sample data). Copy its keys and fill them from the steps above. Text fields, links, lozenges and icons follow the shared rules in the atlassian-design skill’s references/data-format.md. Leave out a key you have nothing for.anchor is a link plus {"kind", "status", "owner", "team", "needBy", "passed", "history"}: kind is project, goal or epic, passed is true when the need-by date has passed, and history is the date history, the last meta item, given only when the need-by date has passed. dependencies lists every dependency once, as described below. A Blocked, At risk or Stale one adds why, one sentence on what’s blocked and why, and contact, the “Contact: [person], [role]” line with their manager as “Escalate to” and where to reach them. A Not recorded one adds evidence, {"text", "quote", "link"}: the sentence, the evidence quoted briefly and its source chip, and offer, the offer from Step 6 that fits. summary is the 2 or 3 sentences, generatedFrom the apps actually used, and nextSteps the 2 to 4 actions as {"text", "from"}, with the person to talk to in the text and where the step came from in from (“From PLAT-221 in Jira”).references/hand-built.md in this folder.The rules below say what the renderer builds, and what each part of the data must hold.
Each dependency is a link (title, url, icon, app) plus:
side: upstream (the anchor waits on it) or downstream (it waits on the anchor). A second-hop dependency, found in Step 3, has "hop": 2 and feeds, the id of the first-hop dependency it feeds, so give that one an id (its key works).state: blocked, at-risk, stale, on-track, done or unknown, from Step 5.source: recorded (the default), related or not-recorded. bothWays: true when the work also flows the other way.team, date and from: the team, the date that matters (“Nov 18”, “Needs it Nov 1”, “Done Oct 2”), and where it came from (“Jira”, “Slack”).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.
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.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.”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.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.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?”).arrow-right): 2 to 4 numbered actions, most urgent first, each with the person to talk to.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:
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.
searchJiraIssuesUsingJql for every Jira dependency on the map, as one key in (...) query, and getGraphObject for project dependencies, by ARI. Add executeWrite only if the page offers the write below, and call it only with createJiraIssueLink.executeWrite and createJiraIssueLink, if that tool doesn’t need approval for each action. Show the exact link and its direction, wait for a confirm click, call it once, then refresh that row. Otherwise keep the offer in chat.teamwork-graph-context. Publish only if requested; report export alone does not authorise it. Create a Confluence page instead only if the user asks.